1 #include "sdlskk_internal.h"
2 #include <stdlib.h>
3 #include <string.h>
4
5 static SDLSKK_Encoding char_encoding = SDLSKK_EUCJP;
6
SDLSKK_set_encoding(SDLSKK_Encoding encoding)7 void SDLSKK_set_encoding( SDLSKK_Encoding encoding )
8 {
9 char_encoding = encoding;
10 }
11
SDLSKK_get_encoding(void)12 SDLSKK_Encoding SDLSKK_get_encoding( void )
13 {
14 return char_encoding;
15 }
16
SDLSKK_Str_len(SDLSKK_Char * str)17 int SDLSKK_Str_len( SDLSKK_Char* str )
18 {
19 int i;
20 for( i=0; str[i] != 0; ++i )
21 ;
22 return i;
23 }
24
25
SDLSKK_Str_to_cstr_utf8(SDLSKK_Char * str,unsigned char * cstr,size_t size)26 unsigned char* SDLSKK_Str_to_cstr_utf8( SDLSKK_Char* str, unsigned char* cstr, size_t size )
27 {
28 int str_pos, cstr_pos;
29
30 for( str_pos=0, cstr_pos=0; str[str_pos] != 0; ++str_pos ){
31 if( str[str_pos] <= 0x7F ){
32 if( cstr_pos + 1 >= size )
33 return NULL;
34 cstr[cstr_pos] = str[str_pos];
35 ++cstr_pos;
36 }else if( str[str_pos] >= 0x80 && str[str_pos] <= 0x7FF ){
37 if( cstr_pos + 2 >= size )
38 return NULL;
39 cstr[cstr_pos] = ((str[str_pos]>>6)&0x1F)|0xC0;
40 cstr[cstr_pos+1] = (str[str_pos]&0x3F)|0x80;
41 cstr_pos += 2;
42 }else if( str[str_pos] >= 0x800 && str[str_pos] <= 0xFFFF ){
43 if( cstr_pos + 3 >= size )
44 return NULL;
45 cstr[cstr_pos] = ((str[str_pos] >> 12) & 0x0F) | 0xE0;
46 cstr[cstr_pos+1] = ((str[str_pos] >> 6) & 0x3F) | 0x80;
47 cstr[cstr_pos+2] = (str[str_pos] & 0x3F) | 0x80;
48 cstr_pos += 3;
49 }else if( str[str_pos] >= 0x10000 && str[str_pos] <= 0x1FFFFF ){
50 if( cstr_pos + 4 >= size )
51 return NULL;
52 cstr[cstr_pos] = ((str[str_pos] >> 18) & 0x07) | 0xF0;
53 cstr[cstr_pos+1] = ((str[str_pos] >> 12) & 0x3F) | 0x80;
54 cstr[cstr_pos+2] = ((str[str_pos] >> 6) & 0x3F) | 0x80;
55 cstr[cstr_pos+3] = (str[str_pos] & 0x3F) | 0x80;
56 cstr_pos += 4;
57 }else if( str[str_pos] >= 0x200000 && str[str_pos] <= 0x3FFFFFF ){
58 if( cstr_pos + 5 >= size )
59 return NULL;
60 cstr[cstr_pos] = ((str[str_pos] >> 24) & 0x03) | 0xF8;
61 cstr[cstr_pos+1] = ((str[str_pos] >> 18) & 0x3F) | 0x80;
62 cstr[cstr_pos+2] = ((str[str_pos] >> 12) & 0x3F) | 0x80;
63 cstr[cstr_pos+3] = ((str[str_pos] >> 6) & 0x3F) | 0x80;
64 cstr[cstr_pos+4] = (str[str_pos] & 0x3F) | 0x80;
65 cstr_pos += 5;
66 }else if( str[str_pos] >= 0x4000000 && str[str_pos] <= 0x7FFFFFFF ){
67 if( cstr_pos + 6 >= size )
68 return NULL;
69 cstr[cstr_pos] = ((str[str_pos] >> 30) & 0x01) | 0xFC;
70 cstr[cstr_pos+1] = ((str[str_pos] >> 24) & 0x3F) | 0x80;
71 cstr[cstr_pos+2] = ((str[str_pos] >> 18) & 0x3F) | 0x80;
72 cstr[cstr_pos+3] = ((str[str_pos] >> 12) & 0x3F) | 0x80;
73 cstr[cstr_pos+4] = ((str[str_pos] >> 6) & 0x3F) | 0x80;
74 cstr[cstr_pos+5] = (str[str_pos] & 0x3F) | 0x80;
75 cstr_pos += 6;
76 }else{
77 return NULL;
78 }
79 }
80 cstr[cstr_pos]='\0';
81 return cstr;
82 }
83
SDLSKK_Str_to_cstr_eucjp(SDLSKK_Char * str,unsigned char * cstr,size_t size)84 unsigned char* SDLSKK_Str_to_cstr_eucjp( SDLSKK_Char* str, unsigned char* cstr, size_t size )
85 {
86 int str_pos, cstr_pos, i;
87 unsigned char c;
88 for( str_pos = cstr_pos = 0; str[str_pos] ; ++str_pos ){
89 for( i=3; i>=0; --i ){
90 c = ( str[str_pos] & ( ((unsigned int)0xFF) << i*8 ) ) >> i*8;
91 if( c != 0 ){
92 cstr[cstr_pos] = c;
93 ++cstr_pos;
94 if( cstr_pos >= size )
95 return NULL;
96 }
97 }
98 }
99 cstr[cstr_pos] = '\0';
100 return cstr;
101 }
102
SDLSKK_Str_to_cstr_sjis(SDLSKK_Char * str,unsigned char * cstr,size_t size)103 unsigned char* SDLSKK_Str_to_cstr_sjis( SDLSKK_Char* str, unsigned char* cstr, size_t size )
104 {
105 return SDLSKK_Str_to_cstr_eucjp( str, cstr, size );
106 }
107
SDLSKK_Str_to_cstr(SDLSKK_Char * str,char * cstr,size_t size)108 char* SDLSKK_Str_to_cstr( SDLSKK_Char* str, char* cstr, size_t size )
109 {
110 switch( char_encoding ){
111 case SDLSKK_EUCJP:
112 return (char*)SDLSKK_Str_to_cstr_eucjp( str, (unsigned char*)cstr, size );
113 case SDLSKK_UTF8:
114 return (char*)SDLSKK_Str_to_cstr_utf8( str, (unsigned char*)cstr, size );
115 case SDLSKK_SJIS:
116 return (char*)SDLSKK_Str_to_cstr_sjis( str, (unsigned char*)cstr, size );
117 }
118 /* NOT REACHED */
119 }
120
121
SDLSKK_str_equal(SDLSKK_Char * str1,SDLSKK_Char * str2)122 int SDLSKK_str_equal( SDLSKK_Char *str1, SDLSKK_Char *str2 )
123 {
124 int i;
125
126 if( (str1 == NULL)||(str2 == NULL) )
127 return 0;
128
129 for( i=0; str1[i] != 0; ++i ){
130 if( str1[i] != str2[i] )
131 return 0;
132 }
133 if( str2[i] == 0 )
134 return 1;
135 else
136 return 0;
137 }
138
SDLSKK_Str_new(SDLSKK_Char * str)139 SDLSKK_Char* SDLSKK_Str_new( SDLSKK_Char * str )
140 {
141 int len;
142 int i;
143 SDLSKK_Char* result;
144 for( i=0; str[i] != 0; i++ )
145 ;
146 len = i+1;
147 result = SDLSKK_malloc( len * sizeof(SDLSKK_Char) );
148 memcpy( result, str, len * sizeof(SDLSKK_Char) );
149 return result;
150 }
151
SDLSKK_Str_new2(char * str)152 SDLSKK_Char* SDLSKK_Str_new2( char* str )
153 {
154 SDLSKK_Char* buf;
155 SDLSKK_Char* new_str;
156 int str_pos, buf_pos;
157
158 buf = SDLSKK_malloc( (strlen(str)+1)*sizeof(SDLSKK_Char) );
159 for( str_pos = 0, buf_pos = 0; str[str_pos] != '\0'; ++buf_pos ){
160 buf[buf_pos] = SDLSKK_get_sc( str, &str_pos );
161 }
162 buf[buf_pos] = 0;
163 new_str = SDLSKK_Str_new( buf );
164 free( buf );
165 return new_str;
166 }
167
SDLSKK_Str_insert_Char(SDLSKK_Char * str,int pos,SDLSKK_Char c,int max_buf)168 SDLSKK_Char* SDLSKK_Str_insert_Char( SDLSKK_Char* str, int pos, SDLSKK_Char c, int max_buf )
169 {
170 int len;
171 len = SDLSKK_Str_len(str);
172
173 if( len >= max_buf - 1 ){
174 return NULL;
175 }
176 if( pos < 0 || pos > len )
177 return NULL;
178 memmove( &str[pos+1], &str[pos], (len-pos+1)*sizeof(SDLSKK_Char) );
179 str[pos] = c;
180 return str;
181 }
182
SDLSKK_Str_insert_Str(SDLSKK_Char * str,int pos,SDLSKK_Char * istr,int max_buf)183 SDLSKK_Char* SDLSKK_Str_insert_Str( SDLSKK_Char* str, int pos, SDLSKK_Char *istr, int max_buf )
184 {
185 int str_len, istr_len;
186
187 str_len = SDLSKK_Str_len( str );
188 istr_len = SDLSKK_Str_len( istr );
189 if( str_len + istr_len + 1 >= max_buf )
190 return NULL;
191 if( pos < 0 || pos > str_len )
192 return NULL;
193 memmove( &str[pos+istr_len], &str[pos], (str_len-pos+1)*sizeof(SDLSKK_Char) );
194 memmove( &str[pos], istr, istr_len*sizeof(SDLSKK_Char) );
195 return str;
196 }
197
SDLSKK_Str_delete_Char(SDLSKK_Char * str,int pos)198 SDLSKK_Char* SDLSKK_Str_delete_Char( SDLSKK_Char* str, int pos )
199 {
200 if( pos < 0 || pos >= SDLSKK_Str_len( str ) )
201 return NULL;
202 memmove( &str[pos], &str[pos+1], (SDLSKK_Str_len(str)-pos+1)*sizeof(SDLSKK_Char) );
203 return str;
204 }
205
SDLSKK_Str_clear(SDLSKK_Char * str)206 void SDLSKK_Str_clear( SDLSKK_Char* str )
207 {
208 str[0] = 0;
209 }
210
211
SDLSKK_get_sc_utf8(unsigned char * line,int * pos)212 SDLSKK_Char SDLSKK_get_sc_utf8( unsigned char* line, int* pos )
213 {
214 SDLSKK_Char result;
215 int len;
216 int i;
217
218 if( line[*pos] == 0 )
219 return 0;
220
221 if( ( line[*pos] & 0x80 ) == 0 ){
222 ++*pos;
223 return line[ *pos-1 ];
224 }else{
225 for( i=0; ((0x80>>i)&line[*pos])!=0; i++ )
226 ;
227 len = i;
228 }
229 if( len>6 )
230 return 0xFFFFFFFF;
231 result = (0xFFU>>len) & line[*pos];
232 for( i=1; i<len; ++i ){
233 result = ( result << 6 )|( line[*pos+i] & 0x3F );
234 }
235 *pos += len;
236 return result;
237 }
238
SDLSKK_get_sc_eucjp(unsigned char * line,int * pos)239 SDLSKK_Char SDLSKK_get_sc_eucjp( unsigned char* line, int* pos )
240 {
241 SDLSKK_Char result;
242
243 if( line[*pos] == 0 )
244 return 0;
245
246 if( line[ *pos ] <= 0x7E ){
247 result = line[ *pos ];
248 ++*pos;
249 return result;
250 }
251 if( line[ *pos ] >= 0xA0 && line[ *pos ] <= 0xFF ){
252 result = (line[ *pos ]<<8) + line[ *pos + 1 ];
253 *pos += 2;
254 return result;
255 }
256 if( line[ *pos ] == 0x8E ){
257 result = (line[ *pos ]<<8) + line[ *pos + 1 ];
258 *pos += 2;
259 return result;
260 }
261 if( line[ *pos ] == 0x8F ){
262 result = (line[ *pos ]<<16) + (line[ *pos + 1 ]<<8) + line[ *pos + 2 ];
263 *pos += 3;
264 return result;
265 }
266 return 0xFFFFFFFF;
267 }
268
SDLSKK_get_sc_sjis(unsigned char * line,int * pos)269 SDLSKK_Char SDLSKK_get_sc_sjis( unsigned char* line, int* pos )
270 {
271 SDLSKK_Char result;
272
273 if( line[*pos] == 0 )
274 return 0;
275
276 if( line[ *pos ] <= 0x7E ){
277 result = line[ *pos ];
278 ++*pos;
279 return result;
280 }
281 if( ( 0x81 <= line[ *pos ] && line[ *pos ] <= 0x9F ) ||
282 ( 0xE0 <= line[ *pos ] && line[ *pos ] <= 0xEF ) ){
283 result = (line[ *pos ]<<8) + line[ *pos + 1 ];
284 *pos += 2;
285 return result;
286 }
287 return 0xFFFFFFFF;
288 }
289
SDLSKK_get_sc(char * line,int * pos)290 SDLSKK_Char SDLSKK_get_sc( char* line, int* pos )
291 {
292 switch( char_encoding ){
293 case SDLSKK_EUCJP:
294 return SDLSKK_get_sc_eucjp( (unsigned char*)line, pos );
295 case SDLSKK_UTF8:
296 return SDLSKK_get_sc_utf8( (unsigned char*)line, pos );
297 case SDLSKK_SJIS:
298 return SDLSKK_get_sc_sjis( (unsigned char*)line, pos );
299 }
300 /* NOT REACHED */
301 }
302
303
SDLSKK_cstr_tokenize(char * line,char delimiter,int * pos)304 SDLSKK_Char* SDLSKK_cstr_tokenize( char* line, char delimiter, int* pos )
305 {
306 int i;
307 SDLSKK_Char* str = SDLSKK_malloc( (strlen(line)+1)*sizeof(SDLSKK_Char) );
308 SDLSKK_Char* new_str;
309
310 i = -1;
311 do {
312 ++i;
313 str[i] = SDLSKK_get_sc( line, pos );
314 }while( !( str[i] == 0 || str[i] == delimiter || str[i] == '\n') );
315
316 str[i] = 0;
317 new_str = SDLSKK_Str_new( str );
318 free( str );
319 return new_str;
320 }
321
322 /* like String#chop! on Ruby */
SDLSKK_Str_chop(SDLSKK_Char * str)323 void SDLSKK_Str_chop( SDLSKK_Char* str )
324 {
325 if( SDLSKK_Str_len( str ) == 0 )
326 return ;
327 str[ SDLSKK_Str_len( str ) -1 ] = 0;
328 }
329
330 /* SDLSKK_XStr */
SDLSKK_XStr_new1(SDLSKK_Char * str)331 SDLSKK_XStr* SDLSKK_XStr_new1( SDLSKK_Char* str )
332 {
333 SDLSKK_XStr* new_str = SDLSKK_malloc( sizeof(SDLSKK_XStr) );
334
335 new_str->len = SDLSKK_Str_len( str );
336 new_str->max = new_str->len + 1;
337 new_str->buf = SDLSKK_Str_new( str );
338 return new_str;
339 }
340
341 #define SDLSKK_MAX(x,y) ( ((x)>(y))?(x):(y) )
SDLSKK_XStr_new2(SDLSKK_Char * str,int maxlen)342 SDLSKK_XStr* SDLSKK_XStr_new2( SDLSKK_Char* str, int maxlen )
343 {
344 SDLSKK_XStr* new_str = SDLSKK_malloc( sizeof(SDLSKK_XStr) );
345
346 new_str->len = SDLSKK_Str_len( str );
347 new_str->max = SDLSKK_MAX( new_str->len + 1, maxlen );
348 new_str->buf = SDLSKK_malloc( new_str->max*sizeof(SDLSKK_Char) );
349 memcpy( new_str->buf, str, (new_str->len + 1)*sizeof(SDLSKK_Char) );
350 return new_str;
351 }
352
SDLSKK_XStr_new3(char * str)353 SDLSKK_XStr* SDLSKK_XStr_new3( char* str )
354 {
355 SDLSKK_XStr* new_str = SDLSKK_malloc( sizeof(SDLSKK_XStr) );
356
357 new_str->buf = SDLSKK_Str_new2( str );
358 new_str->len = SDLSKK_Str_len( new_str->buf );
359 new_str->max = new_str->len + 1;
360
361 return new_str;
362 }
363
SDLSKK_XStr_new4(char * str,int maxlen)364 SDLSKK_XStr* SDLSKK_XStr_new4( char* str, int maxlen )
365 {
366 SDLSKK_XStr* new_str;
367 SDLSKK_Char* tmp;
368
369 tmp = SDLSKK_Str_new2( str );
370 new_str = SDLSKK_XStr_new2( tmp, maxlen );
371 free( tmp );
372 return new_str;
373 }
374
SDLSKK_XStr_new5(SDLSKK_XStr * str)375 SDLSKK_XStr* SDLSKK_XStr_new5( SDLSKK_XStr* str )
376 {
377 return SDLSKK_XStr_new2( str->buf, str->max );
378 }
379
XStr_realloc(SDLSKK_XStr * str,size_t size)380 static void XStr_realloc( SDLSKK_XStr* str, size_t size )
381 {
382 int newstr_max_len;
383
384 if( size + 1 >= str->max ){
385 newstr_max_len = ( size + 1 )*2;
386 str->buf = SDLSKK_realloc( str->buf, newstr_max_len*sizeof(SDLSKK_Char) );
387 str->max = newstr_max_len;
388 }
389 }
SDLSKK_XStr_delete(SDLSKK_XStr * str)390 void SDLSKK_XStr_delete( SDLSKK_XStr* str )
391 {
392 free( str->buf );
393 free( str );
394 }
395
SDLSKK_XStr_insert_Char(SDLSKK_XStr * str,int pos,SDLSKK_Char c)396 void SDLSKK_XStr_insert_Char( SDLSKK_XStr* str, int pos, SDLSKK_Char c )
397 {
398 XStr_realloc( str, str->len + 1 );
399 if( SDLSKK_Str_insert_Char( str->buf, pos, c, str->max ) != NULL )
400 ++(str->len);
401
402 }
403
SDLSKK_XStr_insert_Str(SDLSKK_XStr * str,int pos,SDLSKK_Char * istr)404 void SDLSKK_XStr_insert_Str( SDLSKK_XStr* str, int pos, SDLSKK_Char *istr )
405 {
406 XStr_realloc( str, str->len + SDLSKK_Str_len(istr) );
407 if( SDLSKK_Str_insert_Str( str->buf, pos, istr, str->max ) != NULL )
408 str->len += SDLSKK_Str_len(istr);
409 }
410
SDLSKK_XStr_delete_Char(SDLSKK_XStr * str,int pos)411 void SDLSKK_XStr_delete_Char( SDLSKK_XStr* str, int pos )
412 {
413 if( SDLSKK_Str_delete_Char( str->buf, pos ) )
414 str->len -= 1;
415 }
416
SDLSKK_XStr_clear(SDLSKK_XStr * str)417 void SDLSKK_XStr_clear( SDLSKK_XStr* str )
418 {
419 str->buf[0] = 0;
420 str->len = 0;
421 }
SDLSKK_XStr_concat_Str(SDLSKK_XStr * str1,SDLSKK_Char * str2)422 void SDLSKK_XStr_concat_Str( SDLSKK_XStr* str1, SDLSKK_Char* str2 )
423 {
424 SDLSKK_XStr_insert_Str( str1, str1->len, str2 );
425 }
426
SDLSKK_XStr_copy_Str(SDLSKK_XStr * str1,SDLSKK_Char * str2)427 void SDLSKK_XStr_copy_Str( SDLSKK_XStr* str1, SDLSKK_Char* str2 )
428 {
429 SDLSKK_XStr_clear( str1 );
430 SDLSKK_XStr_insert_Str( str1, 0, str2 );
431 }
432
SDLSKK_XStr_slice_Str(SDLSKK_XStr * dest,SDLSKK_Char * src,int start,int end)433 void SDLSKK_XStr_slice_Str( SDLSKK_XStr* dest, SDLSKK_Char* src, int start, int end )
434 {
435 int len = end - start + 1;
436
437 if( !( 0 <= start && start <= end && end <= SDLSKK_Str_len( src ) ) )
438 return;
439
440 XStr_realloc( dest, len );
441 memmove( dest->buf, &src[start], len * sizeof(SDLSKK_Char) );
442 dest->buf[len] = 0;
443 dest->len = len;
444 }
445
446 #include "jisx0208_eucjp_latin_table.tbl"
447 #include "jisx0208_utf8_latin_table.tbl"
448 #include "jisx0208_sjis_latin_table.tbl"
SDLSKK_latin_to_jisx0208_Char(SDLSKK_Char ch)449 SDLSKK_Char SDLSKK_latin_to_jisx0208_Char( SDLSKK_Char ch )
450 {
451 switch( char_encoding ){
452 case SDLSKK_EUCJP:
453 return jisx0208_eucjp_latin_table[ch];
454 case SDLSKK_UTF8:
455 return jisx0208_utf8_latin_table[ch];
456 case SDLSKK_SJIS:
457 return jisx0208_sjis_latin_table[ch];
458 }
459 /* NOT REACHED */
460 }
461
462
SDLSKK_hiragana_to_katakana_utf8(SDLSKK_Char ch)463 SDLSKK_Char SDLSKK_hiragana_to_katakana_utf8( SDLSKK_Char ch )
464 {
465 if( ch >= 0x3041 && ch <= 0x3096 )
466 return ch + 0x60;
467 return ch;
468 }
SDLSKK_katakana_to_hiragana_utf8(SDLSKK_Char ch)469 SDLSKK_Char SDLSKK_katakana_to_hiragana_utf8( SDLSKK_Char ch )
470 {
471 if( ch >= 0x30A1 && ch <= 0x30F6 )
472 return ch - 0x60;
473 return ch;
474 }
475
SDLSKK_hiragana_to_katakana_eucjp(SDLSKK_Char ch)476 SDLSKK_Char SDLSKK_hiragana_to_katakana_eucjp( SDLSKK_Char ch )
477 {
478 if( ch >= 0xA4A1 && ch <= 0xA4F3 )
479 return ch + 0x0100;
480 return ch;
481 }
SDLSKK_katakana_to_hiragana_eucjp(SDLSKK_Char ch)482 SDLSKK_Char SDLSKK_katakana_to_hiragana_eucjp( SDLSKK_Char ch )
483 {
484 if( ch >= 0xA5A1 && ch <= 0xA5F3 )
485 return ch - 0x0100;
486 return ch;
487 }
488
SDLSKK_hiragana_to_katakana_sjis(SDLSKK_Char ch)489 SDLSKK_Char SDLSKK_hiragana_to_katakana_sjis( SDLSKK_Char ch )
490 {
491 if( ch >= 0x829F && ch <= 0x8302 )
492 return ch + 0xa1;
493 return ch;
494 }
SDLSKK_katakana_to_hiragana_sjis(SDLSKK_Char ch)495 SDLSKK_Char SDLSKK_katakana_to_hiragana_sjis( SDLSKK_Char ch )
496 {
497 if( ch >= 0x8340 && ch <= 0x8393 )
498 return ch - 0xa1;
499 return ch;
500 }
501
SDLSKK_hiragana_to_katakana(SDLSKK_Char ch)502 SDLSKK_Char SDLSKK_hiragana_to_katakana( SDLSKK_Char ch )
503 {
504 switch( char_encoding ){
505 case SDLSKK_EUCJP:
506 return SDLSKK_hiragana_to_katakana_eucjp( ch );
507 case SDLSKK_UTF8:
508 return SDLSKK_hiragana_to_katakana_utf8( ch );
509 case SDLSKK_SJIS:
510 return SDLSKK_hiragana_to_katakana_sjis( ch );
511 }
512 /* NOT REACHED */
513 }
SDLSKK_katakana_to_hiragana(SDLSKK_Char ch)514 SDLSKK_Char SDLSKK_katakana_to_hiragana( SDLSKK_Char ch )
515 {
516 switch( char_encoding ){
517 case SDLSKK_EUCJP:
518 return SDLSKK_katakana_to_hiragana_eucjp( ch );
519 case SDLSKK_UTF8:
520 return SDLSKK_katakana_to_hiragana_utf8( ch );
521 case SDLSKK_SJIS:
522 return SDLSKK_katakana_to_hiragana_sjis( ch );
523 }
524 /* NOT REACHED */
525 }
526
527
SDLSKK_Str_hiragana_to_katakana(SDLSKK_Char * str)528 SDLSKK_Char* SDLSKK_Str_hiragana_to_katakana( SDLSKK_Char* str )
529 {
530 SDLSKK_Char* new_str;
531 int i;
532
533 new_str = SDLSKK_Str_new( str );
534 for( i=0; new_str[i] != 0 ; i++ )
535 new_str[i] = SDLSKK_hiragana_to_katakana( new_str[i] );
536
537 return new_str;
538 }
SDLSKK_Str_katakana_to_hiragana(SDLSKK_Char * str)539 SDLSKK_Char* SDLSKK_Str_katakana_to_hiragana( SDLSKK_Char* str )
540 {
541 SDLSKK_Char* new_str;
542 int i;
543
544 new_str = SDLSKK_Str_new( str );
545 for( i=0; new_str[i] != 0 ; i++ )
546 new_str[i] = SDLSKK_katakana_to_hiragana( new_str[i] );
547
548 return new_str;
549 }
550
551
552 /* for debug */
SDLSKK_Char_to_char(SDLSKK_Char c,char * result)553 void SDLSKK_Char_to_char( SDLSKK_Char c, char *result )
554 {
555 int j,k;
556 unsigned char b;
557
558 for( j=3, k=0; j>=0; --j ){
559 b = ( c & ( ((unsigned int)0xFF) << j*8 ) ) >> j*8;
560 if( b != 0 ){
561 result[k] = b;
562 ++k;
563 }
564 }
565 result[k] = '\0';
566 }
567
print_Str(SDLSKK_Char * str)568 void print_Str( SDLSKK_Char* str )
569 {
570 char buf[1000];
571 SDLSKK_Str_to_cstr( str, buf, sizeof(buf) );
572 printf( "%s", buf );
573 }
574