Back to index

im-sdk  12.3.91
Enumerations | Functions
encode.h File Reference

Go to the source code of this file.

Enumerations

enum  encode_id_list {
  ENCODE_ERROR = -1, ENCODE_GB2312 = 0, ENCODE_GBK, ENCODE_GB18030,
  ENCODE_BIG5, ENCODE_EUC_TW, ENCODE_BIG5HK, ENCODE_EUC_TH,
  ENCODE_EUC_KO, ENCODE_UTF8, ENCODES_NUM, ENCODE_ERROR = -1,
  ENCODE_UTF8, ENCODES_NUM
}
enum  lang_group_list {
  LANG_ERROR = -1, LANG_ZH_CN = 0, LANG_ZH_TW, LANG_ZH_HK,
  LANG_TH_TH, LANG_KO_KR, LANGS_NUM, LANG_ERROR = -1,
  LANGS_NUM
}

Functions

char * get_langname_from_langid (int langid)
char * get_langname_from_locale (char *locale)
char * get_langname_from_encodeid (int encodeid)
int get_langid_from_locale (char *locale)
int get_langid_from_localeid (int localeid)
int get_encodeid_from_name (char *name)
int get_encodeid_from_locale (char *locale)
char * get_name_from_encodeid (int encode_id)
char * get_default_locale_from_locale (char *locale)
int get_char_len_by_encodeid (int encode_id, unsigned char *ch_ptr)
int is_valid_code (int encode_id, unsigned char *int_code, int code_len)
int Convert_Native_To_UTF8 (int encode_id, char *from_buf, size_t from_left, char **to_buf, size_t *to_left)
int Convert_UTF8_To_Native (int encode_id, char *from_buf, size_t from_left, char **to_buf, size_t *to_left)
int Convert_Native_To_UTF16 (int encode_id, char *from_buf, size_t from_left, char **to_buf, size_t *to_left)
int Convert_UTF16_To_Native (int encode_id, char *from_buf, size_t from_left, char **to_buf, size_t *to_left)

Enumeration Type Documentation

Enumerator:
ENCODE_ERROR 
ENCODE_GB2312 
ENCODE_GBK 
ENCODE_GB18030 
ENCODE_BIG5 
ENCODE_EUC_TW 
ENCODE_BIG5HK 
ENCODE_EUC_TH 
ENCODE_EUC_KO 
ENCODE_UTF8 
ENCODES_NUM 
ENCODE_ERROR 
ENCODE_UTF8 
ENCODES_NUM 

Definition at line 3 of file encode.h.

Enumerator:
LANG_ERROR 
LANG_ZH_CN 
LANG_ZH_TW 
LANG_ZH_HK 
LANG_TH_TH 
LANG_KO_KR 
LANGS_NUM 
LANG_ERROR 
LANGS_NUM 

Definition at line 17 of file encode.h.


Function Documentation

int Convert_Native_To_UTF16 ( int  encode_id,
char *  from_buf,
size_t  from_left,
char **  to_buf,
size_t *  to_left 
)

Definition at line 859 of file encode.c.

{
       char   *ip;
       char          *op;
       size_t        ileft, oleft;

       char          *codeset;
       iconv_t              fd_iconv_native_to_utf8;

       size_t        ret = 0;
       int           skip_native_to_utf8_iconv = 0;

       if (encode_id < 0 || encode_id >= ENCODES_NUM)
              return(-1);

       if ( (from_left < 0) || (*to_left < 0) )
              return(-1);

       /* Initialize the iconv of utf8_to_ucs2 */
       if (fd_iconv_UTF8_to_UTF16 == (iconv_t)-1 )
               return(-1);

       if (fd_iconv_UTF8_to_UTF16 == NULL) {
              fd_iconv_UTF8_to_UTF16 = iconv_open("UTF-16", "UTF-8");
              if (fd_iconv_UTF8_to_UTF16 == (iconv_t)-1 )
                     return(-1);
       }

       if (encode_id == ENCODE_UTF8)
              skip_native_to_utf8_iconv = 1;

       ip = (char *) from_buf;
       ileft = from_left;

       op = *((char **) to_buf);
       oleft = *to_left;

       if (!skip_native_to_utf8_iconv) {
              char          buffer[UTF16_STRLEN];   /* Fix me! */
              const size_t  buf_len = UTF16_STRLEN;
              char          *src, *dst;
              size_t        src_len, dst_len;

              /* Initialize the iconv of native_to_utf8 */
              fd_iconv_native_to_utf8 = encode_info[encode_id].fd_iconv_to_utf8;
              if (fd_iconv_native_to_utf8 == (iconv_t)-1) return(-1);

              if (fd_iconv_native_to_utf8 == NULL) {
                     codeset = encode_info[encode_id].iconv_codeset_name;
                     fd_iconv_native_to_utf8 = iconv_open("UTF-8", codeset);
                     encode_info[encode_id].fd_iconv_to_utf8 = fd_iconv_native_to_utf8;
                     if ( fd_iconv_native_to_utf8 == (iconv_t) -1 )
                            return(-1);
              }

              while ((ileft > 0) && (oleft > 0)) {
                     dst = buffer;
                     dst_len = buf_len;
                     ret = iconv(fd_iconv_native_to_utf8, &ip, &ileft, (char **) &dst, &dst_len);
                     if (ret == -1) {
                            return(-1);
                     }
                     src = buffer;
                     src_len = buf_len - dst_len;
                     ret = iconv(fd_iconv_UTF8_to_UTF16, (char **) &src, &src_len, &op, &oleft);
                     if (ret == -1) {
                            return(-1);
                     }
              }

       } else {
              ret = iconv(fd_iconv_UTF8_to_UTF16, &ip, &ileft, &op, &oleft);
              if (ret == -1) {
                      return(-1);
              }
       }

       if (0xFEFF == **((CARD16 **) to_buf)) {
              memmove(*to_buf, *to_buf + 2, *to_left - oleft - 2);
              *to_left = (oleft + 2);
       } else {
              *to_left = oleft;
       }

       return(0);
}
int Convert_Native_To_UTF8 ( int  encode_id,
char *  from_buf,
size_t  from_left,
char **  to_buf,
size_t *  to_left 
)

Definition at line 758 of file encode.c.

{
       char   *ip;
       char          *op;
       size_t        ileft, oleft;
       iconv_t              fd_iconv;
       char          *codeset;
       size_t        ret = 0;
       
       if (encode_id < 0 || encode_id >= ENCODES_NUM)
              return(-1);

       if ( (from_left < 0) || (*to_left < 0) )
              return(-1);

       ip = (char *) from_buf;
       ileft = from_left;

       op = *((char **) to_buf);
       oleft = *to_left;

       if (encode_id == ENCODE_UTF8) {
              if (ileft > oleft)
                     return(-1);
              memcpy(op, ip, ileft);
              *to_left = oleft - ileft;
              return(0);
       }

       fd_iconv = encode_info[encode_id].fd_iconv_to_utf8;
       if (fd_iconv == (iconv_t)-1) return(-1);

       if (fd_iconv == NULL) {
              codeset = encode_info[encode_id].iconv_codeset_name;
              fd_iconv = iconv_open("UTF-8", codeset);
              encode_info[encode_id].fd_iconv_to_utf8 = fd_iconv;
              if ( fd_iconv == (iconv_t) -1 )
                     return(-1);
       }

       ret = iconv(fd_iconv, &ip, &ileft, &op, &oleft);
       if (ret == -1) {
              return(-1);
       }
       *to_left = oleft;
       return(0);

}

Here is the caller graph for this function:

int Convert_UTF16_To_Native ( int  encode_id,
char *  from_buf,
size_t  from_left,
char **  to_buf,
size_t *  to_left 
)

Definition at line 947 of file encode.c.

{
       char   *ip;
       char          *op;
       size_t        ileft, oleft;
       char          *codeset;
       iconv_t              fd_iconv_utf8_to_native;

       size_t        ret = 0;
       int           skip_utf8_to_native_iconv = 0;

       if (encode_id < 0 || encode_id >= ENCODES_NUM)
              return(-1);

       if ( (from_left < 0) || (*to_left < 0) )
              return(-1);

       /* Initialize the iconv of utf8_to_ucs2 */
       if (fd_iconv_UTF16_to_UTF8 == (iconv_t)-1 )
               return(-1);

       if (fd_iconv_UTF16_to_UTF8 == NULL) {
              fd_iconv_UTF16_to_UTF8 = iconv_open("UTF-8", "UTF-16");
              if (fd_iconv_UTF16_to_UTF8 == (iconv_t)-1 )
                     return(-1);
       }

       if (encode_id == ENCODE_UTF8)
              skip_utf8_to_native_iconv = 1;

       ip = (char *) from_buf;
       ileft = from_left;

       op = *((char **) to_buf);
       oleft = *to_left;

       if (!skip_utf8_to_native_iconv) {
              char          buffer[UTF16_STRLEN];   /* Fix me! */
              const size_t  buf_len = UTF16_STRLEN;
              char          *src, *dst;
              size_t        src_len, dst_len;

              /* Initialize the iconv of native_to_utf8 */
              fd_iconv_utf8_to_native = encode_info[encode_id].fd_iconv_from_utf8;
              if (fd_iconv_utf8_to_native == (iconv_t)-1) return(-1);

              if (fd_iconv_utf8_to_native == NULL) {
                     codeset = encode_info[encode_id].iconv_codeset_name;
                     fd_iconv_utf8_to_native = iconv_open(codeset, "UTF-8");
                     encode_info[encode_id].fd_iconv_from_utf8 = fd_iconv_utf8_to_native;
                     if ( fd_iconv_utf8_to_native == (iconv_t) -1 )
                            return(-1);
              }

              while ((ileft > 0) && (oleft > 0)) {
                     dst = buffer;
                     dst_len = buf_len;
                     ret = iconv(fd_iconv_UTF16_to_UTF8, &ip, &ileft, (char **) &dst, &dst_len);
                     if (ret == -1) {
                            return(-1);
                     }
                     src = buffer;
                     src_len = buf_len - dst_len;
                     ret = iconv(fd_iconv_utf8_to_native, (char **) &src, &src_len, &op, &oleft);
                     if (ret == -1) {
                            return(-1);
                     }
              }

       } else {
              ret = iconv(fd_iconv_UTF16_to_UTF8, &ip, &ileft, &op, &oleft);
              if (ret == -1) {
                      return(-1);
              }
       }

       *to_left = oleft;

       return(0);
}

Here is the caller graph for this function:

int Convert_UTF8_To_Native ( int  encode_id,
char *  from_buf,
size_t  from_left,
char **  to_buf,
size_t *  to_left 
)

Definition at line 808 of file encode.c.

{
       char   *ip;
       char          *op;
       size_t        ileft, oleft;
       iconv_t              fd_iconv;
       char          *codeset;
       size_t        ret = 0;
       
       if (encode_id < 0 || encode_id >= ENCODES_NUM)
              return(-1);

       if ( (from_left < 0) || (*to_left < 0) )
              return(-1);

       ip = (char *) from_buf;
       ileft = from_left;

       op = *((char **) to_buf);
       oleft = *to_left;

       if (encode_id == ENCODE_UTF8) {
              if (ileft > oleft)
                     return(-1);
              memcpy(op, ip, ileft);
              *to_left = oleft - ileft;
              return(0);
       }

       fd_iconv = encode_info[encode_id].fd_iconv_from_utf8;
       if (fd_iconv == (iconv_t)-1) return(-1);

       if (fd_iconv == NULL) {
              codeset = encode_info[encode_id].iconv_codeset_name;
              fd_iconv = iconv_open(codeset, "UTF-8");
              encode_info[encode_id].fd_iconv_from_utf8 = fd_iconv;
              if ( fd_iconv == (iconv_t) -1 )
                     return(-1);
       }

       ret = iconv(fd_iconv, &ip, &ileft, &op, &oleft);
       if (ret == -1) {
              return(-1);
       }
       *to_left = oleft;
       return(0);
}
int get_char_len_by_encodeid ( int  encode_id,
unsigned char *  ch_ptr 
)

Definition at line 581 of file encode.c.

{
       int ret = 2;  /* default character length */
       unsigned char code0, code1;

       code0 = ch_ptr[0];
       if (code0 < 0x80) return(1);

       if (encode_id == ENCODE_UTF8) {
              if (code0 > 0xe0)           /* 3 bytes */
                     ret = 3;
       } else if (encode_id == ENCODE_GB18030) {
              code1 = ch_ptr[1];
              if (code0 >=0x81 && code0 <= 0xFE) {
                     if (code1 >= 0x30 && code1 <= 0x39)
                            ret = 4;
              } 
       } else if (encode_id == ENCODE_EUC_TW) {
              if (code0 == 0x8e)          /* 4 bytes */
                     ret = 4;
       } else if (encode_id == ENCODE_EUC_TH) {
              ret = 1;
       }

       return(ret);
}
char* get_default_locale_from_locale ( char *  locale)

Definition at line 556 of file encode.c.

{
       int encode_id, i, ret;
       char *s;

       ret = -1;
       for (encode_id = 0; encode_id < ENCODES_NUM; encode_id++) {
              i = 0;
              while (1) {
                     s = encode_info[encode_id].support_locales[i];
                     if (!s || !*s) break;
                     if (!strcasecmp(s, locale)) {
                            ret = encode_id;
                            break;
                     }
                     i++;
              }
              if (ret != -1) break;
       }
       
       if (ret == -1) return(NULL);

       return(encode_info[ret].support_locales[0]);
}
int get_encodeid_from_locale ( char *  locale)

Definition at line 523 of file encode.c.

{
       int encode_id, i, ret;
       char *s;
       
       ret = -1;
       for (encode_id = 0; encode_id < ENCODES_NUM; encode_id++) {
              i = 0;
              while (1) {
                     s = encode_info[encode_id].support_locales[i];
                     if (!s || !*s) break;
                     if (!strcasecmp(s, locale)) {
                            ret = encode_id;
                            break;
                     }
                     i++;
              }
              if (ret != -1) break;
       }

       if (ret == -1) ret = ENCODE_ERROR; /* return default encode */

       return(ret);  
}
int get_encodeid_from_name ( char *  name)

Definition at line 500 of file encode.c.

{
       int encode_id, i, ret;
       char *s;
       
       ret = -1;
       for (encode_id = 0; encode_id < ENCODES_NUM; encode_id++) {
              i = 0;
              while (1) {
                     s = encode_info[encode_id].called_names[i];
                     if (!s || !*s) break;
                     if (!strcasecmp(s, name)) {
                            ret = encode_id;
                            break;
                     }
                     i++;
              }
              if (ret != -1) break;
       }
       if (ret == -1) ret = ENCODE_GB2312; /* return default encode */
       return(ret);  
}
int get_langid_from_locale ( char *  locale)

Definition at line 449 of file encode.c.

{
       int lang_id, i, ret;
       char *s;

       ret = -1;
       for (lang_id = 0; lang_id < LANGS_NUM; lang_id++) {
              i = 0;
              while (1) {
                     s = langgroup_info[lang_id].support_locales[i];
                     if (!s || !*s) break;
                     if (!strcasecmp(s, locale)) {
                            ret = lang_id;
                            break;
                     }
                     i++;
              }
              if (ret != -1) break;
       }

       if (ret == -1) 
              ret = 0;

       return(ret);
}
int get_langid_from_localeid ( int  localeid)

Definition at line 474 of file encode.c.

{
       int lang_id, i, ret;
       int support_encode;

       ret = -1;
       for (lang_id = 0; lang_id < LANGS_NUM; lang_id++) {
              i = 0;
              while (1) {
                     support_encode = langgroup_info[lang_id].support_encodes[i];
                     if (support_encode == ENCODE_ERROR) break;
                     if (localeid == support_encode) {
                            ret = lang_id;
                            break;
                     }
                     i++;
              }
              if (ret != -1) break;
       }

       if (ret == -1) 
              ret = 0;

       return(ret);
}

Here is the caller graph for this function:

char* get_langname_from_encodeid ( int  encodeid)

Definition at line 423 of file encode.c.

{
       int lang_id, i, ret;
       int support_encode;

       ret = -1;
       for (lang_id = 0; lang_id < LANGS_NUM; lang_id++) {
              i = 0;
              while (1) {
                     support_encode = langgroup_info[lang_id].support_encodes[i];
                     if (support_encode == ENCODE_ERROR) break;
                     if (encodeid == support_encode) {
                            ret = lang_id;
                            break;
                     }
                     i++;
              }
              if (ret != -1) break;
       }

       if (ret == -1) 
              ret = 0;

       return(langgroup_info[ret].lang_name);
}
char* get_langname_from_langid ( int  langid)

Definition at line 387 of file encode.c.

{
       int ret = langid;
       
       if (langid < 0 || langid >= LANGS_NUM) 
              ret = 0;

       return(langgroup_info[ret].lang_name);
}

Here is the caller graph for this function:

char* get_langname_from_locale ( char *  locale)

Definition at line 397 of file encode.c.

{
       int lang_id, i, ret;
       char *s;

       ret = -1;
       for (lang_id = 0; lang_id < LANGS_NUM; lang_id++) {
              i = 0;
              while (1) {
                     s = langgroup_info[lang_id].support_locales[i];
                     if (!s || !*s) break;
                     if (!strcasecmp(s, locale)) {
                            ret = lang_id;
                            break;
                     }
                     i++;
              }
              if (ret != -1) break;
       }

       if (ret == -1) 
              ret = 0;

       return(langgroup_info[ret].lang_name);
}
char* get_name_from_encodeid ( int  encode_id)

Definition at line 548 of file encode.c.

{
       if (encode_id >= 0 && encode_id <= ENCODES_NUM)
              return(encode_info[encode_id].called_names[0]);
       else
              return(NULL);
}
int is_valid_code ( int  encode_id,
unsigned char *  int_code,
int  code_len 
)

Definition at line 630 of file encode.c.

{
       unsigned char code0, code1, code2, code3;
       
       code0 = int_code[0];
       code1 = int_code[1];

       switch (encode_id) {
              case ENCODE_GB2312:
                     if (code0 < 0xA1 || code0 > 0xFE)
                            return (-1);
                     if (code1 < 0xA1 || code1 > 0xFE)
                            return (-1);
                     break;
                     
              case ENCODE_GBK:
                     if (code0 < 0x81 || code0 > 0xFE)
                            return (-1);
                     if (code1 < 0x40 || code1 > 0xFE || code1 == 0x7F)
                            return (-1);
                     break;

              case ENCODE_GB18030:
                     if (code_len == 2) {
                            if (code0 < 0x81 || code0 > 0xFE)
                                   return (-1);
                            if (code1 < 0x40 || code1 > 0xFE || code1 == 0x7F)
                                   return (-1);
                     } else if (code_len == 4) {
                            code2 = int_code[2];
                            code3 = int_code[3];
                            if (code0 < 0x81 || code0 > 0xFE)
                                   return (-1);
                            if (code1 < 0x30 || code1 > 0x39)
                                   return (-1);
                            if (code2 < 0x81 || code2 > 0xFE)
                                   return (-1);
                            if (code3 < 0x30 || code3 > 0x39)
                                   return (-1);
                     }
                     break;

              case ENCODE_BIG5:
#if 0
                     /* define in lcbig5.c */
                     if ((code0 >= 0xA1) && code0 <= 0xC5) || (code0 >= 0xC9 && code0 <= 0xF9)) {
                            if (code1 < 0x40 || code1 == 0xFF || (code1 >= 0x7F && code1 <= 0xA0))
                                   return (-1);
                            else
                                   return (0);
                     } else {
                            if (code0 == 0xC6 && (code1 >= 0x40 && code1 <= 0x7E))
                                   return (0);
                            else
                                   return (-1);
                     }
#endif
                                   
                     if (code0 < 0xA1 || code0 > 0xFE)
                            return (-1);
                     if (code1 < 0x40 || code1 > 0xFE)
                            return (-1);
                     if (code1 > 0x7E && code1 < 0xA1)
                            return (-1);
                     break;

              case ENCODE_EUC_TW:
                     if (code_len == 2) {
                            if (code0 < 0x80 || code1 <0x80)
                                   return (-1);
                     } if (code_len == 4) {
                            code2 = int_code[2];
                            code3 = int_code[3];
                            if (code0 != 0x8E)
                                   return(-1);
                            if (code1 < 0x80 || code2 < 0x80 || code3 < 0x80)
                                   return(-1);
                     }
                     break;

              case ENCODE_BIG5HK:
                     if (code0 < 0x81 || code0 > 0xFE)
                            return (-1);
                     if (code1 < 0x40 || code1 > 0xFE)
                            return (-1);
                     break;

              case ENCODE_EUC_KO:
                     if (code0 < 0xA1 || code0 > 0xFE)
                            return (-1);
                     if (code1 < 0xA1 || code1 > 0xFE)
                            return (-1);
                     break;

              case ENCODE_UTF8:
                     break;
       }
       return(0);
}

Here is the caller graph for this function: