1 /*---------------------------------------------------------------------------*
2 Project: Revolution ENC sample demo
3 File: sample.c
4
5 Copyright 2006 Nintendo. All rights reserved.
6
7 These coded instructions, statements, and computer programs contain
8 proprietary information of Nintendo of America Inc. and/or Nintendo
9 Company Ltd., and are protected by Federal copyright law. They may
10 not be disclosed to third parties or copied or duplicated in any form,
11 in whole or in part, without the prior written consent of Nintendo.
12
13 $Log: sample.c,v $
14 Revision 1.6 08/14/2006 04:31:35 yoshioka_yasuhiro
15 Added demos for ENCConvertStringJisToUnicode and ENCConvertStringUnicodeToJis.
16
17 Revision 1.4 08/09/2006 10:37:37 yoshioka_yasuhiro
18 Specification change.
19 ENCConverString* functions returns a result code,
20 and read/write dstlen and srclen.
21
22 Revision 1.3 08/08/2006 10:48:23 yoshioka_yasuhiro
23 Fix for specification change.
24 Modified termination check.
25
26 Revision 1.1 08/07/2006 06:43:14 yoshioka_yasuhiro
27 Initial commit.
28
29 $NoKeywords: $
30 *---------------------------------------------------------------------------*/
31
32 #include <revolution.h>
33 #include <revolution/enc.h>
34
35 #include "demostrings.h"
36
main()37 int main()
38 {
39 BOOL test_clear = TRUE;
40 #define LENGTH 0x100
41
42 /* string*/
43 {
44 /*u8 char8[8];
45 u16 char16;
46 u8 mbs[8];
47 u16 wc;*/
48 s32 srclen, dstlen;
49 ENCResult err_code;
50
51 /* SJIS str -> UNICODE str */
52 OSReport("\n* SJIS str -> UNICODE str *\n");
53 srclen = -1;
54 err_code = ENCConvertStringSjisToUnicode(NULL, &dstlen, sjis, &srclen);
55 if (err_code)
56 {
57 OSReport("ERROR: %d\n", err_code);
58 OSReport("dstlen: %d, srclen: %d\n", dstlen, srclen);
59 test_clear = FALSE;
60 }
61 else
62 {
63 u16 dst[LENGTH];
64 OSReport("dstlen: %d, srclen: %d\n", dstlen, srclen);
65 err_code = ENCConvertStringSjisToUnicode(dst, &dstlen, sjis, &srclen);
66 if (err_code)
67 {
68 OSReport("ERROR: %d\n", err_code);
69 OSReport("dstlen: %d, srclen: %d\n", dstlen, srclen);
70 test_clear = FALSE;
71 }
72 else
73 {
74 s32 i, j;
75 OSReport("dstlen: %d, srclen: %d\n", dstlen, srclen);
76 for (i = 0; i < dstlen; ++i)
77 {
78 if (dst[i] == uni[i])
79 continue;
80 OSReport("FAILURE\nend @ %d\n", i);
81 OSReport("result\tanswer\n");
82 for (j = 0; j < 8; ++j)
83 OSReport("%#x\t%#x\n", dst[i + j], uni[i + j]);
84 test_clear = FALSE;
85 break;
86 }
87 if (i == dstlen)
88 {
89 OSReport("SUCCESS\nend @ %d\n", i - 1);
90 }
91 }
92 }
93
94 /* UNICODE str -> SJIS str */
95 OSReport("\n* UNICODE str -> SJIS str *\n");
96 srclen = -1;
97 err_code = ENCConvertStringUnicodeToSjis(NULL, &dstlen, uni, &srclen);
98 if (err_code)
99 {
100 OSReport("ERROR: %d\n", err_code);
101 OSReport("dstlen: %d, srclen: %d\n", dstlen, srclen);
102 test_clear = FALSE;
103 }
104 else
105 {
106 u8 dst[LENGTH];
107 OSReport("dstlen: %d, srclen: %d\n", dstlen, srclen);
108 err_code = ENCConvertStringUnicodeToSjis(dst, &dstlen, uni, &srclen);
109 if (err_code)
110 {
111 OSReport("ERROR: %d\n", err_code);
112 OSReport("dstlen: %d, srclen: %d\n", dstlen, srclen);
113 test_clear = FALSE;
114 }
115 else
116 {
117 s32 i, j;
118 OSReport("dstlen: %d, srclen: %d\n", dstlen, srclen);
119 for (i = 0; i < dstlen; ++i)
120 {
121 if (dst[i] == sjis[i])
122 continue;
123 OSReport("FAILURE\nend @ %d\n", i);
124 OSReport("result\tanswer\n");
125 for (j = 0; j < 8; ++j)
126 OSReport("%#x\t%#x\n", dst[i + j], sjis[i + j]);
127 test_clear = FALSE;
128 break;
129 }
130 if (i == dstlen)
131 {
132 OSReport("SUCCESS\nend @ %d\n", i - 1);
133 }
134 }
135 }
136
137 /* JIS str -> SJIS str */
138 OSReport("\n* JIS str -> SJIS str *\n");
139 srclen = -1;
140 err_code = ENCConvertStringJisToSjis(NULL, &dstlen, jis2, &srclen);
141 if (err_code)
142 {
143 OSReport("ERROR: %d\n", err_code);
144 OSReport("dstlen: %d, srclen: %d\n", dstlen, srclen);
145 test_clear = FALSE;
146 }
147 else
148 {
149 u8 dst[LENGTH];
150 OSReport("dstlen: %d, srclen: %d\n", dstlen, srclen);
151 err_code = ENCConvertStringJisToSjis(dst, &dstlen, jis2, &srclen);
152 if (err_code)
153 {
154 OSReport("ERROR: %d\n", err_code);
155 OSReport("dstlen: %d, srclen: %d\n", dstlen, srclen);
156 test_clear = FALSE;
157 }
158 else
159 {
160 s32 i, j;
161 OSReport("dstlen: %d, srclen: %d\n", dstlen, srclen);
162 for (i = 0; i < dstlen; ++i)
163 {
164 if (dst[i] == sjis[i])
165 continue;
166 OSReport("FAILURE\nend @ %d\n", i);
167 OSReport("result\tanswer\n");
168 for (j = 0; j < 8; ++j)
169 OSReport("%#x\t%#x\n", dst[i + j], sjis[i + j]);
170 test_clear = FALSE;
171 break;
172 }
173 if (i == dstlen)
174 {
175 OSReport("SUCCESS\nend @ %d\n", i - 1);
176 }
177 }
178 }
179
180 /* SJIS str -> JIS str */
181 OSReport("\n* SJIS str -> JIS str *\n");
182 srclen = -1;
183 err_code = ENCConvertStringSjisToJis(NULL, &dstlen, sjis, &srclen);
184 if (err_code)
185 {
186 OSReport("ERROR: %d\n", err_code);
187 OSReport("dstlen: %d, srclen: %d\n", dstlen, srclen);
188 test_clear = FALSE;
189 }
190 else
191 {
192 u8 dst[LENGTH];
193 OSReport("dstlen: %d, srclen: %d\n", dstlen, srclen);
194 err_code = ENCConvertStringSjisToJis(dst, &dstlen, sjis, &srclen);
195 if (err_code)
196 {
197 OSReport("ERROR: %d\n", err_code);
198 OSReport("dstlen: %d, srclen: %d\n", dstlen, srclen);
199 test_clear = FALSE;
200 }
201 else
202 {
203 s32 i, j;
204 OSReport("dstlen: %d, srclen: %d\n", dstlen, srclen);
205 for (i = 0; i < dstlen; ++i)
206 {
207 if (dst[i] == jis[i])
208 continue;
209 OSReport("FAILURE\nend @ %d\n", i);
210 OSReport("result\tanswer\n");
211 for (j = 0; j < 8; ++j)
212 OSReport("%#x\t%#x\n", dst[i + j], jis[i + j]);
213 test_clear = FALSE;
214 break;
215 }
216 if (i == dstlen)
217 {
218 OSReport("SUCCESS\nend @ %d\n", i - 1);
219 }
220 }
221 }
222
223 /* JIS str -> UNICODE str */
224 OSReport("\n* JIS str -> UNICODE str *\n");
225 srclen = -1;
226 err_code = ENCConvertStringJisToUnicode(NULL, &dstlen, jis2, &srclen);
227 if (err_code)
228 {
229 OSReport("ERROR: %d\n", err_code);
230 OSReport("dstlen: %d, srclen: %d\n", dstlen, srclen);
231 test_clear = FALSE;
232 }
233 else
234 {
235 u16 dst[LENGTH];
236 OSReport("dstlen: %d, srclen: %d\n", dstlen, srclen);
237 err_code = ENCConvertStringJisToUnicode(dst, &dstlen, jis2, &srclen);
238 if (err_code)
239 {
240 OSReport("ERROR: %d\n", err_code);
241 OSReport("dstlen: %d, srclen: %d\n", dstlen, srclen);
242 test_clear = FALSE;
243 }
244 else
245 {
246 s32 i, j;
247 OSReport("dstlen: %d, srclen: %d\n", dstlen, srclen);
248 for (i = 0; i < dstlen; ++i)
249 {
250 if (dst[i] == uni[i])
251 continue;
252 OSReport("FAILURE\nend @ %d\n", i);
253 OSReport("result\tanswer\n");
254 for (j = 0; j < 8; ++j)
255 OSReport("%#x\t%#x\n", dst[i + j], uni[i + j]);
256 test_clear = FALSE;
257 break;
258 }
259 if (i == dstlen)
260 {
261 OSReport("SUCCESS\nend @ %d\n", i - 1);
262 }
263 }
264 }
265
266 /* UNICODE str -> JIS str */
267 OSReport("\n* UNICODE str -> JIS str *\n");
268 srclen = -1;
269 err_code = ENCConvertStringUnicodeToJis(NULL, &dstlen, uni, &srclen);
270 if (err_code)
271 {
272 OSReport("ERROR: %d\n", err_code);
273 OSReport("dstlen: %d, srclen: %d\n", dstlen, srclen);
274 test_clear = FALSE;
275 }
276 else
277 {
278 u8 dst[LENGTH];
279 OSReport("dstlen: %d, srclen: %d\n", dstlen, srclen);
280 err_code = ENCConvertStringUnicodeToJis(dst, &dstlen, uni, &srclen);
281 if (err_code)
282 {
283 OSReport("ERROR: %d\n", err_code);
284 OSReport("dstlen: %d, srclen: %d\n", dstlen, srclen);
285 test_clear = FALSE;
286 }
287 else
288 {
289 s32 i, j;
290 OSReport("dstlen: %d, srclen: %d\n", dstlen, srclen);
291 for (i = 0; i < dstlen; ++i)
292 {
293 if (dst[i] == jis[i])
294 continue;
295 OSReport("FAILURE\nend @ %d\n", i);
296 OSReport("result\tanswer\n");
297 for (j = 0; j < 8; ++j)
298 OSReport("%#x\t%#x\n", dst[i + j], jis[i + j]);
299 test_clear = FALSE;
300 break;
301 }
302 if (i == dstlen)
303 {
304 OSReport("SUCCESS\nend @ %d\n", i - 1);
305 }
306 }
307 }
308
309 /* LATIN1 str -> UNICODE str */
310 OSReport("\n* LATIN1 str -> UNICODE str *\n");
311 srclen = -1;
312 err_code = ENCConvertStringLatin1ToUnicode(NULL, &dstlen, latin1, &srclen);
313 if (err_code)
314 {
315 OSReport("ERROR: %d\n", err_code);
316 OSReport("dstlen: %d, srclen: %d\n", dstlen, srclen);
317 test_clear = FALSE;
318 }
319 else
320 {
321 u16 dst[LENGTH];
322 OSReport("dstlen: %d, srclen: %d\n", dstlen, srclen);
323 err_code = ENCConvertStringLatin1ToUnicode(dst, &dstlen, latin1, &srclen);
324 if (err_code)
325 {
326 OSReport("ERROR: %d\n", err_code);
327 OSReport("dstlen: %d, srclen: %d\n", dstlen, srclen);
328 test_clear = FALSE;
329 }
330 else
331 {
332 s32 i, j;
333 OSReport("dstlen: %d, srclen: %d\n", dstlen, srclen);
334 for (i = 0; i < dstlen; ++i)
335 {
336 if (dst[i] == uni1[i])
337 continue;
338 OSReport("FAILURE\nend @ %d\n", i);
339 OSReport("result\tanswer\n");
340 for (j = 0; j < 8; ++j)
341 OSReport("%#x\t%#x\n", dst[i + j], uni1[i + j]);
342 test_clear = FALSE;
343 break;
344 }
345 if (i == dstlen)
346 {
347 OSReport("SUCCESS\nend @ %d\n", i - 1);
348 }
349 }
350 }
351
352 /* UNICODE str -> LATIN1 str */
353 OSReport("\n* UNICODE str -> LATIN1 str *\n");
354 srclen = -1;
355 err_code = ENCConvertStringUnicodeToLatin1(NULL, &dstlen, uni1, &srclen);
356 if (err_code)
357 {
358 OSReport("ERROR: %d\n", err_code);
359 OSReport("dstlen: %d, srclen: %d\n", dstlen, srclen);
360 test_clear = FALSE;
361 }
362 else
363 {
364 u8 dst[LENGTH];
365 OSReport("dstlen: %d, srclen: %d\n", dstlen, srclen);
366 err_code = ENCConvertStringUnicodeToLatin1(dst, &dstlen, uni1, &srclen);
367 if (err_code)
368 {
369 OSReport("ERROR: %d\n", err_code);
370 OSReport("dstlen: %d, srclen: %d\n", dstlen, srclen);
371 test_clear = FALSE;
372 }
373 else
374 {
375 s32 i, j;
376 OSReport("dstlen: %d, srclen: %d\n", dstlen, srclen);
377 for (i = 0; i < dstlen; ++i)
378 {
379 if (dst[i] == latin1[i])
380 continue;
381 OSReport("FAILURE\nend @ %d\n", i);
382 OSReport("result\tanswer\n");
383 for (j = 0; j < 8; ++j)
384 OSReport("%#x\t%#x\n", dst[i + j], latin1[i + j]);
385 test_clear = FALSE;
386 break;
387 }
388 if (i == dstlen)
389 {
390 OSReport("SUCCESS\nend @ %d\n", i - 1);
391 }
392 }
393 }
394 }
395
396 /* character*/
397 {
398 u8 char8[8];
399 u16 char16;
400 u8 mbs[8];
401 u16 wc;
402 s32 srclen, dstlen;
403 ENCResult err_code;
404
405 *mbs = 0x94;
406 *(mbs + 1) = 0x43;
407 wc = 0x4EFB;
408 /* SJIS char -> UNICODE char */
409 OSReport("\n* SJIS char -> UNICODE char *\n");
410 srclen = 2;
411 dstlen = 1;
412 err_code = ENCConvertStringSjisToUnicode(&char16, &dstlen, mbs, &srclen);
413 if (char16 == wc)
414 {
415 OSReport("SUCCESS\n");
416 }
417 else
418 {
419 OSReport("FAILURE\n");
420 test_clear = FALSE;
421 }
422 OSReport("%#x, %#x -> %#x\n", *mbs, *(mbs + 1), char16);
423
424 /* UNICODE char -> SJIS char */
425 OSReport("\n* UNICODE char -> SJIS char *\n");
426 srclen = 1;
427 err_code = ENCConvertStringUnicodeToSjis(NULL, &dstlen, &wc, &srclen);
428 err_code = ENCConvertStringUnicodeToSjis(char8, &dstlen, &wc, &srclen);
429 if (*char8 == *mbs && *(char8 + 1) == *(mbs + 1))
430 {
431 OSReport("SUCCESS\n");
432 }
433 else
434 {
435 OSReport("FAILURE\n");
436 test_clear = FALSE;
437 }
438 OSReport("%#x -> %#x, %#x\n", wc, *char8, *(char8 + 1));
439
440 /* SJIS char -> JIS char */
441 *mbs = 0x94;
442 *(mbs + 1) = 0x43;
443 OSReport("\n* SJIS char -> JIS char *\n");
444 srclen = 2;
445 err_code = ENCConvertStringSjisToJis(NULL, &dstlen, mbs, &srclen);
446 err_code = ENCConvertStringSjisToJis(char8, &dstlen, mbs, &srclen);
447 if (*(char8 + 3) == 0x47 && *(char8 + 4) == 0x24)
448 {
449 OSReport("SUCCESS\n");
450 }
451 else
452 {
453 OSReport("FAILURE\n");
454 test_clear = FALSE;
455 }
456 OSReport("%#x, %#x -> %#x, %#x\n", *mbs, *(mbs + 1), *(char8 + 3), *(char8 + 4));
457
458 /* JIS char -> SJIS char */
459 *mbs = 0x1B;
460 *(mbs + 1) = 0x24;
461 *(mbs + 2) = 0x42;
462 *(mbs + 3) = 0x47;
463 *(mbs + 4) = 0x24;
464 *(mbs + 5) = 0x1B;
465 *(mbs + 6) = 0x28;
466 *(mbs + 7) = 0x42;
467 OSReport("\n* JIS char -> SJIS char *\n");
468 srclen = 8;
469 err_code = ENCConvertStringJisToSjis(NULL, &dstlen, mbs, &srclen);
470 err_code = ENCConvertStringJisToSjis(char8, &dstlen, mbs, &srclen);
471 if (*char8 == 0x94 && *(char8 + 1) == 0x43)
472 {
473 OSReport("SUCCESS\n");
474 }
475 else
476 {
477 OSReport("FAILURE\n");
478 test_clear = FALSE;
479 }
480 OSReport("%#x, %#x -> %#x, %#x\n", *mbs, *(mbs + 1), *char8, *(char8 + 1));
481 }
482 {
483 u8 char8;
484 u16 char16;
485 u8 lc;
486 u16 wc;
487 s32 srclen, dstlen;
488 s32 err_code;
489
490 lc = 0x80;
491 wc = 0x20AC;
492 /* LATIN1 char -> UNICODE char */
493 OSReport("\n* LATIN1 char -> UNICODE char *\n");
494 srclen = 1;
495 dstlen = 1;
496 err_code = ENCConvertStringLatin1ToUnicode(&char16, &dstlen, &lc, &srclen);
497 if (char16 == wc)
498 {
499 OSReport("SUCCESS\n");
500 }
501 else
502 {
503 OSReport("FAILURE\n");
504 test_clear = FALSE;
505 }
506 OSReport("%#x -> %#x\n", lc, wc);
507
508 /* UNICODE char -> LATIN1 char */
509 OSReport("\n* UNICODE char -> LATIN1 char *\n");
510 srclen = 1;
511 dstlen = 1;
512 err_code = ENCConvertStringUnicodeToLatin1(&char8, &dstlen, &wc, &srclen);
513 if (char8 == lc)
514 {
515 OSReport("SUCCESS\n");
516 }
517 else
518 {
519 OSReport("FAILURE\n");
520 test_clear = FALSE;
521 }
522 OSReport("%#x -> %#x\n", wc, char8);
523 }
524
525 if (test_clear)
526 OSReport("\nTOTAL SUCCESS\n");
527 else
528 OSReport("\nTOTAL FAILURE\n");
529
530 return 0;
531 }
532