/* DMW_CodeConv.c Unicode --> KS code conversion API especially for shell debugging.. Copyright 2003~2009 Digital STREAM Technology, Inc. All Rights Reserved */ #include "DMW_Platform.h" #include "DMW_CodeConv.h" //#include //#include //--------------------------------------------------------- // Configurations.. #if CODE_CONV_USE_MW_TABLE #include "DMW_KsH2Uc.h" // define our own table.. // this is for the case when Application does not have conversion table #else extern UINT16 DST_cktouk[]; // if application have conversion table, // just use that symbol.. #endif //--------------------------------------------------------- #define max(a,b) (((a) > (b)) ? (a) : (b)) #define min(a,b) (((a) < (b)) ? (a) : (b)) int DmwCodeConvPrint(char *fmt, ...) { va_list v; int n; va_start(v, fmt); n = DHL_OS_Printf(fmt, v); va_end(v); return n; } #define dprint DmwCodeConvPrint //#define dprint DHL_OS_Printf //--------------------------------------------------------- //UINT16 *dmw_ksh2uc; #define dmw_ksh2uc (DST_cktouk) // ks 한글 코드(0xb0a1 ~ 0xc8fe)를 unicode로 변환하는 테이블 포인터 // table의 크기 // // 94 character per line * 25 line * 2 bytes per character = 4700 bytes // // 한글만 변환가능함. // UINT16 *dmw_uch2ks; // unicode 한글코드(0xac00 ~ 0xd7af)를 ks 코드로 변환하는 테이블.. // table 크기 // (0xd7af - 0xac00 + 1) * 2 = 11184 * 2 = 22368 // // Unicode에서 다루는 글자가 ks보다 많으므로 코드맵 상에 존재하지 않는 경우에는 0이 들어있다. // static으로 존재하는 table이 아니고, 코드 inverse 루틴으로 동적으로 만들어진다. // #define IsHangulUc(c) ( ((c)>=0xac00) && ((c)<=0xd7af) ) UINT16 *DMW_GetKs2UcTable(void) { return dmw_ksh2uc; } /* for Hangul font (end) */ // 완성형 한글 코드를 unicode로 변환하는 테이블 // // 한글 '가'에 해당하는 완성형 코드는 0xB0A1 이다. // UINT16 ksh_to_unicode(UINT16 ks) { // KS 한글 코드를 Unicode 한글로 변환하는 함수.. // KS 코드이나 한글이 아니면 현재 0을 리턴한다. // // Unicode 상에서 0x0000은 NULL을 의미함. // UINT8 c1, c2; int block; // big endian을 가정한 경우 임.. platform independant 구현을 원하면 UINT8 * pointer로 입력을 받으면 된다. c1 = (ks >> 8); c2 = (ks & 0xff); // ks code map 영역에 속한 글자인지 체크.. if (c1 < 0xA1 || c1 > 0xFE) { //dprint("c1 is not ks code!!\n"); return 0; } if (c2 < 0xA1 || c2 > 0xFE) { //dprint("c2 is not ks code!!\n"); return 0; } // 한글인지 검사.. if (c1 < 0xB0 || c1 > 0xC8) { //dprint("c1 is not hangul!!\n"); //return 0; return 0x003F; // cafrii 041126 fix // 한글은 아니지만 KS 코드는 맞으므로 '?' 글자를 주자. } // block number (0, 1, 2, ..) 결정.. block = c1 - 0xB0; //dprint("block number %d\n", block); return dmw_ksh2uc[block*94 + (c2-0xA1)]; } int DMW_InitCodeConvLib(void) { int k; if (dmw_uch2ks) { //dprint("check code: %x %x\n", dmw_uch2ks[0], dmw_uch2ks[11184-19]); if (dmw_uch2ks[0] == 0xb0a1 && dmw_uch2ks[11184-19] == 0xc8fe) { // check whether first and last code are correct.. //dprint("already inited..\n"); return statusOK; // it seems already initialized.. } // if not, free and realloc.. DHL_OS_Free((void**)&dmw_uch2ks); } dmw_uch2ks = DHL_OS_Malloc(2 * (0xD7AF - 0xAC00 + 1)); if (dmw_uch2ks == NULL) return statusOutOfMemory; memset(dmw_uch2ks, 0, 2 * (0xD7AF - 0xAC00 + 1)); #if 1 // 가나다 순서로 정렬되어 있으므로 이 특성을 잘 이용하면 빨리 초기화가 가능하다.. // // memset(dmw_uch2ks, 0, sizeof(xx)); // 이미 초기화 된 상태이다.. for (k=0; k<25*94; k++) { //if (dmw_ksh2uc[k] - 0xac00 >= 11184) dprint("!! range over!!\n"); dmw_uch2ks[dmw_ksh2uc[k] - 0xac00] = ((0xB0 + k/94) << 8) + (0xA1 + k%94); } #else // brute search algorithm.. for (uc = 0xAC00; uc <= 0xD7AF; uc++) // total 11184 character.. { for (k=0; k<25*94; k++) { // search 2350 character table.. if (dmw_ksh2uc[k] == uc) { // found!!! break; } } ks = (k>=25*94) ? 0 : ((0xB0 + k/94) << 8) + (0xA1 + k%94); dmw_uch2ks[uc-0xac00] = ks; } #endif return statusOK; } //--------------------------------- // DMW_ConvKs2Uc // // KS 문자열을 Unicode로 변환. NULL (0x0000) 으로 종료되므로 // 별도의 length 정보는 리턴하지 않는다. // 필요한 메모리는 내부에서 할당해서 사용한다. // 사용 후에 DMW_FreeUcString 으로 메모리를 해제해 줘야 한다. // // 'len'은 ks_char의 문자열 길이 (null 제외)이며 // 음의 값을 지정할 경우 strlen 함수로 자동 결정된다. // // cafrii 041126 add UINT16 *DMW_ConvKs2Uc(char *ks_char, int len) { // 주의! 사용 후에 리턴되는 uc 메모리를 해제하여야 함. // UINT16 *ucs; UINT16 uc; int i, k, uc_len; UINT8 *ks = (UINT8 *) ks_char; if (len < 0) len = strlen((const char *)ks); //dprint("ConvKs2Uc: ascii %d bytes (except \\0)\n", len); uc_len = 0; for (i=0; i unicode %04x", ks[i], ks[i+1], uc); // ks[i], ks[i+1] 이 하나의 unicode 이다. ucs[k++] = uc; i++; } } else { // 마지막 글자임.. ucs[k++] = (UINT16) ks[i]; } //dprint("\n"); } // null termination.. ucs[k] = 0; return ucs; } //--------------------------------- // DMW_ConvUc2Ks // // UINT8 *DMW_ConvUc2Ks(UINT16 *uc_16, int len) { // unicode string을 Ks 코드로 변환하여 리턴한다. // 변환에 필요한 메모리는 내부적으로 동적 할당한다. // 사용 후 꼭 DMW_FreeKsString을 이용하여 해제해야 한다. // // len 은 UINT16 형태의 unicode 문자 갯수이다. (byte size가 아님에 유의!) // len 이 negative값을 가지면 Null terminated string으로 간주한다. // // 리턴되는 문자열은 null-terminate 된 상태이다. #define DMW_CONV_MAX_STRING_LEN 4096 // 지원하는 string의 길이에 제한을 두자.. 바이트 수가 아니라 글자 수이다. // Psip table 변환에 주로 사용할 것이므로 4K면 충분하다. // uc pointer가 16 bit align이 잘 안되어 있을 수도 있으므로, byte단위로 읽어서 사용하자. // // cafrii 081006, endian 에 따라 다르게 동작하지 않도록 그냥 16 bit로 처리. // //#define UC(n) ((uc[2*(n)]<<8)|uc[2*(n)+1]) #define UC(n) (uc_16[n]) //UINT8 *uc = (UINT8 *)uc_16; int i, err; UINT16 ks; int offset; // byte offset of KS string buf UINT8 *buf; // ks string buf int bufsize; int dbg = 0; if (len < 0) { // length를 계산한다. for (i=0; i bufsize-1) break; buf[offset++] = (ks >> 8) & 0xff; buf[offset++] = (ks & 0xff); if (dbg) dprint("\t UC[%d] : %04x --> H: %04x (%c%c)\n", i, UC(i), ks, buf[offset-2], buf[offset-1]); } else { if (((UC(i) >> 8) & 0xff) == 0) { // seems to be english.. if (offset+1 > bufsize-1) break; buf[offset++] = (UC(i) & 0xff); if (dbg) dprint("\t UC[%d] : %04x --> E: %02x (%c)\n", i, UC(i), buf[offset-1], buf[offset-1]); } else { if (offset+5 > bufsize-1) break; sprintf((char *)&buf[offset], "#%04x", UC(i)); offset += 5; if (dbg) dprint("\t UC[%d] : %04x --> ?\n", i, UC(i)); } } } buf[offset++] = 0; // null termination.. if (dbg) dprint(" total %d bytes..\n", offset); return buf; #undef UC } void DMW_FreeKsString(UINT8 *ks) { //dprint("free buffer %08x..\n", ks); DHL_OS_Free((void**)&ks); } void DMW_FreeUcString(UINT16 *uc) { DHL_OS_Free((void**)&uc); } /* note! PSIP multiple string의 unicode는 모두 big endian 으로 encoding 되어 있으므로 Little endian system에서 PSIP 문자열을 출력할 때에는 (UINT8 *) --> (UINT16 *) 와 같이 바로 casing 연산을 하면 안된다. */ int DMW_UniPrint(UINT16 *ucs, int len) { UINT8 *s; //dprint("DMW_UniPrint (%x, %d)\n", ucs, len); s = DMW_ConvUc2Ks(ucs, len); if (s) { //dprint("buffer: %08x\n", s); dprint((char *)s); //dprint("free buffer %08x..\n", s); DMW_FreeKsString(s); } return 0; } //----------------------- // DMW_Unicode2Ks // // Unicode string을 ascii string으로 변환하여 'buf' 에 저장한다. // // len 은 Unicode 문자 갯수이다. (byte char 갯수가 아님!!) // len 이 0이면 NULL terminated string 이라는 뜻임 // char *DMW_Unicode2Ks(UINT16 *ucs, int len, char *buf) { #if 1 // cafrii 041103 add, for korean 'short name' display static char buf_0[256]; // 버퍼를 지정하지 않는 경우에는 최대 255 바이트 까지만 지원하도록 하자. char *s; int bytelen; if (buf == NULL) buf = buf_0; s = (char *)DMW_ConvUc2Ks((UINT16 *)ucs, len>0 ? len : -1); bytelen = strlen(s); // KS 변환된 문자열의 바이트 길이 (문자 갯수랑 일치하지 않음) memcpy(buf, s, min(256, bytelen+1)); // null terminator 까지 복사.. DMW_FreeKsString((UINT8 *)s); return buf; #else // 그냥 영문 ascii 만 표시하는 간단한 구현.. static char buf_0[256]; int i; if (buf == NULL) buf = buf_0; if (len < 0) { for (i=0; i<255; i++) { // 최대 길이는 256으로 제한. if (ucs[i] == 0) break; } len = i; } for (i=0; i> 8) == 0) // it seems ascii buf[i] = ucs[i] & 0xff; else buf[i] = '?'; } return buf; #endif } //--------------------------- // DMW_MakeRandomKsString // // 테스트를 위해서 랜덤한 문자열을 만드는 함수. // 지정한 버퍼에 임의 길의의 임의 문자열을 만든다. // // mode = 0 : 영문 문자열 // mode = 1 : 한글 문자열 // mode = 2~ : 영문/한글 혼용.. // char *DMW_MakeRandomKsString(char *buf, int size, int mode) { int k, bHangle = 0; char c1, c2; size--; for (k=0; k= size) // 마지막 글자는 영문으로 종료해야 함.. bHangle = 0; // 영문.. else if (rand() % 3 == 0) bHangle = !bHangle; } if (bHangle == 0) { buf[k] = rand() % (0x7A - 0x2A + 1) + 0x2A; if (buf[k] == '%' || buf[k] == '\\' || buf[k] == '#') buf[k] = 'A'; } else { if (k+1 >= size) { buf[k] = '.'; break; } // 랜덤 한글.. c1 = rand() % (0xC8 - 0xB0 + 1) + 0xB0; c2 = rand() % (0xFE - 0xA1 + 1) + 0xA1; buf[k] = c1; k++; buf[k] = c2; } } buf[k] = 0; return buf; } //--------------------------- // DMW_MakeRandomKsString // // strlen 의 unicode 버전이다. // // cafrii 041126 add int DMW_UcStringLen(UINT16 *ucs) { int len = 0; if (ucs == NULL) return 0; while (ucs[len]) len++; return len; } //--------------------------- // Unicode string library.. // UniStrLen // unicode version of strcpy int UniStrLen(UINT16 *str) { register UINT16 *p = str; while (*p) p++; return (int)(p - str); } // UniStrCopy // unicode version of strcpy UINT16 *UniStrCopy(UINT16 *dst, UINT16 *src) { register UINT16 *d = dst, *s = src; while (*s) *d++ = *s++; *d = 0; return dst; } // UniStrNCopy // unicode version of strncpy UINT16 *UniStrNCopy(UINT16 *dst, UINT16 *src, int len) { register int n = 0; register UINT16 *d = dst, *s = src; while (*s && n < len) { *d++ = *s++; n++; } if (n < len) *d = 0; return dst; } // UniStrCat // unicode version of strcat UINT16 *UniStrCat(UINT16 *dst, UINT16 *src) { register UINT16 *s = src, *d = dst; // search last position while (*d) d++; // strcpy while (*s) *d++ = *s++; *d = 0; // null terminate return dst; } // UniStrCompare // unicode version of strcmp int UniStrCompare(UINT16 *string1, UINT16 *string2) { register UINT16 *str1 = string1, *str2 = string2; for (; *str1 != 0 || *str2 != 0; str1++, str2++) { if (*str1 != *str2) return (*str1 - *str2); } return 0; } // UniStrTrim // cut out trailing unnecessary space. // return string pointer UINT16 *UniStrTrim(UINT16 *uStr) { register UINT16 *s = uStr; // search tail while (*s && *s != ' ') s++; // now, *s is 0 or space. *s = 0; return uStr; } // UniStrFromAscii // just convert char string to Unicode string. // only applicable in ascii code. void UniStrFromAscii(UINT16 *ustr, char *str) { while (*str) *ustr++ = (UINT16)(*str++); *ustr = 0; } // convert one Hex character to digit #define HEX_CH_2_DIGIT(c) ( \ ((c)>='0' && (c)<='9') ? (c)-'0' : \ ((c)>='a' && (c)<='f') ? (c)-'a'+10 : \ ((c)>='A' && (c)<='F') ? (c)-'A'+10 : 0) // convert two character hax to digit static UINT16 ConvHexToInt(char ch1, char ch2) { return ((HEX_CH_2_DIGIT(ch1)<<4U) | HEX_CH_2_DIGIT(ch2)); } // UniStrCreate // convert string to unicode string // non-Latin ASCII can be converted using "&" escaper. // uStr can be null. in that case, internal static buffer is used (max 79 chars) // return converted unicode string pointer UINT16 *UniStrCreate(char *cStr, UINT16 *uStr) { static UINT16 sUStrBuf[80]; // provide temporary buffer register UINT16 *u; register char *p; p = cStr; u = uStr ? uStr : sUStrBuf; for (; *p; p++, u++) { if (*p != '&') *u = (UINT16)(*p); else { if (*(++p) == '&') *u = (UINT16)'&'; else { *u = ConvHexToInt(p[0], p[1]); p++; } } } *u = 0; // null terminate return uStr ? uStr : sUStrBuf; } #if 0 _____TEST_______() #endif // cafrii 041126 add void TestConvKs2Uc(int number) { int i; char buf[100]; UINT16 *ucs; srand(DHL_OS_GetMsCount()); if (number == 0) number = 20; for (i=0; i