字符编码转换 各种函数 UTF格式转换、

最新推荐文章于 2023-02-01 14:46:23 发布
最新推荐文章于 2023-02-01 14:46:23 发布
阅读量1.2k 收藏
点赞数
分类专栏： C语言 文章标签： null c encoding table 2010 url
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jeff_2009/article/details/6095576
版权

/*
 * codeconv.c
 *
 * Heidun IDS developer team
 *  Created on: Jun 11, 2009
 *      Author: Xiaodong Zhong
 */

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include "our_design_config_init.h"
#include "code_table.h"


typedef unsigned char   uchar;
typedef unsigned short  ushort;
static u_int8_t EBCDIC_translate_ASCII [ 256 ] = {
    0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08,
    0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F,
    0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18,
    0x19, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x1F,
    0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28,
    0x29, 0x2A, 0x2B, 0x2C, 0x2D, 0x2E, 0x2F,
    0x2E, 0x2E, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38,
    0x39, 0x3A, 0x3B, 0x3C, 0x3D, 0x2E, 0x3F,
    0x20, 0x2E, 0x2E, 0x2E, 0x2E, 0x2E, 0x2E, 0x2E, 0x2E,
    0x2E, 0x2E, 0x2E, 0x3C, 0x28, 0x2B, 0x7C,
    0x26, 0x2E, 0x2E, 0x2E, 0x2E, 0x2E, 0x2E, 0x2E, 0x2E,
    0x2E, 0x21, 0x24, 0x2A, 0x29, 0x3B, 0x5E,
    0x2D, 0x2F, 0x2E, 0x2E, 0x2E, 0x2E, 0x2E, 0x2E, 0x2E,
    0x2E, 0x7C, 0x2C, 0x25, 0x5F, 0x3E, 0x3F,
    0x2E, 0x2E, 0x2E, 0x2E, 0x2E, 0x2E, 0x2E, 0x2E, 0x2E,
    0x2E, 0x3A, 0x23, 0x40, 0x27, 0x3D, 0x22,
    0x2E, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68,
    0x69, 0x2E, 0x2E, 0x2E, 0x2E, 0x2E, 0x2E,
    0x2E, 0x6A, 0x6B, 0x6C, 0x6D, 0x6E, 0x6F, 0x70, 0x71,
    0x72, 0x2E, 0x2E, 0x2E, 0x2E, 0x2E, 0x2E,
    0x2E, 0x7E, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79,
    0x7A, 0x2E, 0x2E, 0x2E, 0x5B, 0x2E, 0x2E,
    0x2E, 0x2E, 0x2E, 0x2E, 0x2E, 0x2E, 0x2E, 0x2E, 0x2E,
    0x2E, 0x2E, 0x2E, 0x2E, 0x5D, 0x2E, 0x2E,
    0x7B, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48,
    0x49, 0x2E, 0x2E, 0x2E, 0x2E, 0x2E, 0x2E,
    0x7D, 0x4A, 0x4B, 0x4C, 0x4D, 0x4E, 0x4F, 0x50, 0x51,
    0x52, 0x2E, 0x2E, 0x2E, 0x2E, 0x2E, 0x2E,
    0x5C, 0x2E, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59,
    0x5A, 0x2E, 0x2E, 0x2E, 0x2E, 0x2E, 0x2E,
    0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38,
    0x39, 0x2E, 0x2E, 0x2E, 0x2E, 0x2E, 0x2E
};

void EBCDIC_to_ASCII(u_int8_t *buf, u_int32_t bytes)
{
 u_int32_t i;
 u_int8_t *bufptr;

 bufptr = buf;

 for (i = 0; i < bytes; i++, bufptr++) {
  *bufptr = EBCDIC_translate_ASCII[*bufptr];
 }
}

u_int8_t EBCDIC_to_ASCII1(u_int8_t c)
{
 return EBCDIC_translate_ASCII[c];
}

/**
* 0     ----Little Endian UTF-16 串(低字节在前)
* != 0  ----Big    Endian UTF-16 串(高字节在前)
**/
static int isLittleEndian =  0;

/**
*  功  能: 设置 UTF-16 编码方式
*  输  入:
*        0     ----Little Endian UTF-16 串(低字节在前)
*        1     ----Big    Endian UTF-16 串(高字节在前)
*  输  出:
*  返  回:
**/
int SetEndian()
{
    uchar   *p = NULL;
    ushort  tst = 0x1234;

    /* 获取CPU字节码顺序 */
    p = (uchar *)&tst;

    if     (*p == 0x12) isLittleEndian = 1;
    else if(*p == 0x34) isLittleEndian = 0;
    else
    {
        LogMessage( "Unknown CPU Bytes Order!/n");
        return -1;
    }

    return 0;
}

/**
*  功  能: 将 UTF-16 编码转成 UTF-8 编码
*  输  入: inb      ----utf-16字串
*          inlenb   ----utf-16字串长度(字节数)
*          outlen   ----输出缓冲区最大值
*  输  出: out      ----utf-8字串
*          outlen   ----utf-8字串长度
*  返  回: >= 0     ----转换后utf-8字串长度
*          -1       ----转换出错
**/
int UTF16ToUTF8(uchar *out, int *outlen, const uchar *inb, int *inlenb)
{
    uchar* outstart = out;
    const uchar* processed = inb;
    uchar* outend = out + *outlen;
    ushort* in = (unsigned short*) inb;
    ushort* inend;
    unsigned int c, d, inlen;
    unsigned char *tmp;
    int bits;

    if((*inlenb % 2) == 1) (*inlenb)--;
    inlen = *inlenb / 2;
    inend = in + inlen;
    while((in < inend) && (out - outstart + 5 < *outlen))
    {
        if(isLittleEndian)
        {
            c= *in++;
        }
        else
        {
            tmp = (unsigned char *) in;
            c   = *tmp++;
            c   = c | (((unsigned int)*tmp) << 8);
            in++;
        }
        if((c & 0xFC00) == 0xD800)
        {
            if(in >= inend) break;
            if(isLittleEndian) { d = *in++; }
            else
            {
                tmp = (unsigned char *) in;
                d   = *tmp++;
                d   = d | (((unsigned int)*tmp) << 8);
                in++;
            }
            if((d & 0xFC00) == 0xDC00)
            {
                c &= 0x03FF;
                c <<= 10;
                c |= d & 0x03FF;
                c += 0x10000;
            }
            else
            {
                *outlen = out - outstart;
                *inlenb = processed - inb;
                return -1;
            }
        }

        if(out >= outend)    break;
        if     (c <    0x80) { *out++ =  c;                        bits= -6; }
        else if(c <   0x800) { *out++ = ((c >>  6) & 0x1F) | 0xC0; bits=  0; }
        else if(c < 0x10000) { *out++ = ((c >> 12) & 0x0F) | 0xE0; bits=  6; }
        else                 { *out++ = ((c >> 18) & 0x07) | 0xF0; bits= 12; }

        for(; bits >= 0; bits-= 6)
        {
            if (out >= outend)
            break;
            *out++ = ((c >> bits) & 0x3F) | 0x80;
        }
        processed = (const unsigned char*) in;
    }

    *outlen = out - outstart;
    *inlenb = processed - inb;

    return(*outlen);
}

/**
*  功  能: 将 UTF-8 编码转成 UTF-16 编码
*  输  入: in       ----utf-8字串
*          inlen    ----utf-8字串长度
*          outlen   ----输出缓冲区最大值
*  输  出: outb     ----utf-16字串
*          outlenb  ----utf-16字串长度(字节数)
*  返  回: >= 0     ----转换后utf-16字串长度(字节数)
*          -1       ----转换出错
**/
int UTF8ToUTF16(uchar *outb, int *outlen, const uchar *in, int *inlen)
{
    ushort *out = (unsigned short*) outb;
    const uchar* processed = in;
    const uchar *const instart = in;
    ushort *outstart= out, *outend;
    const uchar* inend;
    unsigned int c, d;
    int trailing;
    uchar *tmp;
    ushort tmp1, tmp2;

    if((out == NULL) || (outlen == NULL) || (inlen == NULL)) return -1;
    if(in == NULL)
    {
        *outlen = 0;
        *inlen = 0;
        return 0;
    }
    inend= in + *inlen;
    outend = out + (*outlen / 2);
    while(in < inend)
    {
        d= *in++;
        if     (d < 0x80) { c= d; trailing= 0; }
        else if(d < 0xC0)
        {
            *outlen = (out - outstart) * 2;
            *inlen = processed - instart;
            return -1;
        }
        else if(d < 0xE0)  { c= d & 0x1F; trailing= 1; }
        else if(d < 0xF0)  { c= d & 0x0F; trailing= 2; }
        else if(d < 0xF8)  { c= d & 0x07; trailing= 3; }
        else
        {
            *outlen = (out - outstart) * 2;
            *inlen = processed - instart;
            return -1;
        }

        if(inend - in < trailing)  break;

        for(; trailing; trailing--)
        {
            if((in >= inend) || (((d= *in++) & 0xC0) != 0x80))
            break;
            c <<= 6;
            c |= d & 0x3F;
        }

        if(c < 0x10000)
        {
            if(out >= outend) break;
            if(isLittleEndian) { *out++ = c; }
            else
            {
                tmp        = (unsigned char *) out;
                *tmp       = c ;
                *(tmp + 1) = c >> 8 ;
                out++;
            }
        }
        else if(c < 0x110000)
        {
            if(out+1 >= outend) break;
            c -= 0x10000;
            if(isLittleEndian)
            {
                *out++ = 0xD800 | (c >> 10);
                *out++ = 0xDC00 | (c & 0x03FF);
            }
            else
            {
                tmp1       = 0xD800 | (c >> 10);
                tmp        = (unsigned char *) out;
                *tmp       = (unsigned char) tmp1;
                *(tmp + 1) = tmp1 >> 8;
                out++;

                tmp2       = 0xDC00 | (c & 0x03FF);
                tmp        = (unsigned char *) out;
                *tmp       = (unsigned char) tmp2;
                *(tmp + 1) = tmp2 >> 8;
                out++;
            }
        }
        else break;

        processed = in;
    }

    *outlen = (out - outstart) * 2;
    *inlen = processed - instart;

    return(*outlen);
}

/**
*  功  能: 查找 GB2312 编码对应的 UTF-16 编码值(二分法查找)
*  输  入: gbkey    ----GB2312编码值
*  输  出:
*  返  回: >= 0     ----UTF-16编码值
*          -1       ----编码表无对应GB2312编码
*  引  用: 全局变量
*    _GB2UTFTable   ----GB2312->UNICODE对照表
**/
short UTF16Seek(ushort gbkey)
{
    int first = 0, mid = 0;
    int end = GBUTF_TABLE_SIZE - 1;

    while(first <= end)
    {
        mid = (first + end) >> 1;

        if (_GB2UTFTable[mid].gbcode == gbkey)
        {
            return _GB2UTFTable[mid].unicode;
        }

        if (_GB2UTFTable[mid].gbcode > gbkey)
        {
            end = mid - 1;
        }
        else
        {
            first = mid + 1;
        }
    }

    return -1;
}

/**
*  功  能: 查找 UTF-16 编码对应的 GB2312 编码值(二分法查找)
*  输  入: utfkey   ----UTF-16编码值
*  输  出:
*  返  回: >= 0     ----GB2312编码值
*          -1       ----编码表无对应UTF-16编码
*  引  用: 全局变量
*     _UTF2GBTable  ----UNICODE->GB2312对照表
**/
short GBSeek(ushort utfkey)
{
    int first = 0, mid = 0;
    int end = UTFGB_TABLE_SIZE - 1;

    while(first <= end)
    {
        mid = (first + end) >> 1;

        if (_UTF2GBTable[mid].unicode == utfkey)
        {
            return _UTF2GBTable[mid].gbcode;
        }

        if (_UTF2GBTable[mid].unicode > utfkey)
        {
            end = mid - 1;
        }
        else
        {
            first = mid + 1;
        }
    }

    return -1;
}

/**
*  功  能: 计算 UTF-16 编码字串的长度(双字节数)
*  输  入: in      ----UTF-16字串缓冲区
*  输  出:
*  返  回: >= 0    ----UTF-16编码长度(双字节数)
**/
long UTF16Len(const uchar *in)
{
    register  int i = 0;

    if(NULL == in) return 0;
    while(1)
    {
        if(0 == in[2*i] && 0 == in[2*i+1])
            break;
        i++;
    }

    return i;
}

/**
*  功  能: 将 UTF-16 编码转成 GB2312 编码
*  输  入: in       ----utf-16字串
*          inlen    ----utf-16字串长度(字节数)
*          outlen   ----输出缓冲区最大值
*  输  出: out      ----GB2312字串
*  返  回: >=0      ----转换后GB2312字串长度(字节数)
*          -1       ----转换出错
**/
int UTF16ToGB(uchar *out, int outlen, uchar *in, int inlen)
{
    register int i = 0, k = 0;
    ushort  c1 = 0, c2 = 0;
    int     len = 0;

    if(NULL == in) { out[0] = '/0'; return 0; }

    len = (inlen < 0 ? 0 : inlen);
    if(len % 2 == 1) len --;
    i = 0;
    if(len >= 2)
    {
        /* UTF-16编码方式 */
        if(in[0] == 0xFF && in[1] == 0xFE)
        {
            i = 2;
        }
        if(in[0] == 0xFE && in[1] == 0xFF)
        {
            i = 2;
        }
    }

    for(i, k = 0; i < len; i += 2)
    {
        if(isLittleEndian)
        {
            c1 = (in[i] << 8) | (uchar)in[i+1];
        }
        else
        {
            c1 = (in[i+1] << 8) | (uchar)in[i];
        }
        c2 = GBSeek(c1);
        if(-1 == (short)c2)
        {
            LogMessage( "At [%d] [0x%4.4X] not found!/n", i, c1);
            return -1;
        }

        if(NULL == out)  return -1;
        if(0xFF00 & c2)
        {
            if(k >= outlen - 3) return -1;

            out[k++] = c2 >> 8;
            out[k++] = c2 & 0x00FF;
        }
        else
        {
            if(k >= outlen - 1) return -1;

            out[k++] = (uchar)c2;
        }
    }
    out[k] = 0;

    return k;
}

/**
*  功  能: 将 UTF-8 编码转成 GB2312 编码
*  输  入: in       ----utf-8字串
*          inlen    ----utf-8字串长度
*          outlen   ----输出缓冲区最大值
*  输  出: out      ----GB2312字串
*  返  回: >=0      ----转换后GB2312字串长度(字节数)
*          -1       ----转换出错
**/
int UTF8ToGB(uchar *out, int outlen, uchar *in, int inlen)
{
    uchar *out1 = NULL;
    int len = 0, len1 = 0, len2 = 0;

    len = (inlen < 0 ? 0 : inlen);
    len1 = 2 * len;
    out1 = (uchar *)calloc(1, len1 + 2);
    if(NULL == out1)
    {
        LogMessage( "allot memory error!/n");
        return -1;
    }

    len1 = UTF8ToUTF16(out1, &len1, in, &len);
    if(len1 <= 0)
    {
        free(out1);
        return len1;
    }

    len2 = outlen;
    len2 = UTF16ToGB(out, len2, out1, len1);
    free(out1);

    return len2;
}

/**
*  功  能: 将 GB2312 编码转成 UTF-16 编码
*  输  入: in       ----GB2312字串
*          inlen    ----GB2312字串长度
*          outlen   ----输出缓冲区最大值
*  输  出: out      ----utf-16字串
*  返  回: >=0      ----转换后utf-16字串长度(字节数)
*          -1       ----转换出错
**/
int GBToUTF16(uchar *out, int outlen, uchar *in, int inlen)
{
    register int i, k;
    ushort    c1, c2;
    int       len = 0;

    if(NULL == in)
    {
        out[0] = '/0';
        return 0;
    }

    len = (inlen < 0 ? 0 : inlen);

    for(i = 0, k = 0; i < len; i++)
    {
        c1 = (uchar)in[i];
        c2 = UTF16Seek(c1);          /* 查找单字节码 */
        if(-1 == (short)c2)
        {
            if(++i < len)
            {
                c1 = (c1 << 8) | (uchar)in[i];
                c2 = UTF16Seek(c1);  /* 查找双字节码 */
                if(-1 == (short)c2)
                {
                    LogMessage( "At [%d] [0x%4.4X] not found1!/n", i, c1);
                    return -1;
                }
            }
            else
            {
                LogMessage( "At [%d] [0x%4.4X] not found2!/n", i, c1);
                return -1;
            }
        }

        /* 超出输出缓冲区的大小 */
        if(k > outlen -3) return -1;

        if(isLittleEndian)
        {
            out[k++] = c2 >> 8;
            out[k++] = c2 & 0x00FF;
        }
        else
        {
            out[k++] = c2 & 0x00FF;
            out[k++] = c2 >> 8;
        }
    }

    return k;
}

/**
*  功  能: 将 GB2312 编码转成 UTF-8 编码
*  输  入: in       ----GB2312字串
*          inlen    ----GB2312字串长度
*          outlen   ----输出缓冲区最大值
*  输  出: out      ----utf-8字串
*  返  回: >=0      ----转换后utf-8字串长度(字节数)
*          -1       ----转换出错
**/
int GBToUTF8(uchar *out, int outlen, uchar *in, int inlen)
{
    uchar *out1 = NULL;
    int   len = 0, len1 = 0, len2 = 0;

    len = (inlen < 0 ? 0 : inlen);
    len1 = 2 * len + 2;
    out1 = (uchar *)calloc(1, len1);
    if(NULL == out1)
    {
        LogMessage( "allot memory error!/n");
        return -1;
    }

    len1 = GBToUTF16(out1, len1, in, len);
    if(len1 <= 0)
    {
        free(out1);
        return len1;
    }

    len2 = outlen;
    len2 = UTF16ToUTF8(out, &len2, out1, &len1);
    free(out1);

    return len2;
}

/**
*  功  能: 将 fcode 编码转成 tcode 编码
*  输  入: fcode    ----源编码类型
*          tcode    ----目标编码类型
*          in       ----fcode类型编码字串
*          inlen    ----focde类型编码字串长度
*          outlen   ----输出缓冲区上限
*  输  出: out      ----tcode类型编码字串
*          outlen   ----tcode类型编码字串长度
*  返  回: >=0      ----转换后字串长度(字节数)
*          -1       ----转换出错
**/
int CodeConv(char *incode, char *outcode,uint8_t *out, int *outlen, uint8_t *in, int inlen)
{
    int len = 0, len1 = 0;

    if(NULL == incode || NULL == outcode) { *outlen = 0; return -1; }
    if(NULL == in) { *outlen = 0; out[0] = '/0'; return 0; }
    if(*outlen <= 0)  return (*outlen % 2);
    if(SetEndian() < 0) { *outlen = 0; return -1; }

    len = (inlen < 0 ? 0 : inlen);
    len1 = *outlen;

    if(strcasecmp(incode, "UTF-8")   != 0 &&
       strcasecmp(incode, "UTF8")    != 0 &&
       strcasecmp(incode, "UTF-16")  != 0 &&
       strcasecmp(incode, "UTF16")   != 0 &&
       strcasecmp(incode, "UNICODE") != 0 &&
       strcasecmp(incode, "GB2312")  != 0)
    {
        LogMessage( "Encoding [%s] is not supported/n", incode);
        return -1;
    }

    if(strcasecmp(outcode, "UTF-8")   != 0 &&
       strcasecmp(outcode, "UTF8")    != 0 &&
       strcasecmp(outcode, "UTF-16")  != 0 &&
       strcasecmp(outcode, "UTF16")   != 0 &&
       strcasecmp(outcode, "UNICODE") != 0 &&
       strcasecmp(outcode, "GB2312")  != 0)
    {
        LogMessage( "Ecoding [%s] is not supported/n", outcode);
        return -1;
    }

    /* GB2312 -> UTF-8 */
    if(strcasecmp(incode,  "GB2312") == 0 &&
      (strcasecmp(outcode, "UTF8")   == 0 ||
       strcasecmp(outcode, "UTF-8")  == 0))
    {
        len1 = GBToUTF8(out, len1, in, len);
    }
    /* UTF-8 -> GB2312 */
    else if(strcasecmp(outcode, "GB2312") == 0 &&
           (strcasecmp(incode,  "UTF8")   == 0 ||
            strcasecmp(incode,  "UTF-8")  == 0))
    {
        len1 = UTF8ToGB(out, len1, in, len);
    }
    /* GB2312 -> UTF-16 */
    else if(strcasecmp(incode,  "GB2312")  == 0 &&
           (strcasecmp(outcode, "UTF16")   == 0 ||
            strcasecmp(outcode, "UTF-16")  == 0 ||
            strcasecmp(outcode, "UNICODE") == 0))
    {
        len1 = GBToUTF16(out, len1, in, len);
    }
    /* UTF-16 -> GB2312 */
    else if(strcasecmp(outcode, "GB2312")  == 0 &&
           (strcasecmp(incode,  "UTF16")   == 0 ||
            strcasecmp(incode,  "UTF-16")  == 0 ||
            strcasecmp(incode,  "UNICODE") == 0))
    {
        len1 = UTF16ToGB(out, len1, in, len);
    }
    /* UTF-8 -> UTF-16 */
    else if((strcasecmp(incode,  "UTF8")    == 0  ||
             strcasecmp(incode,  "UTF-8")   == 0) &&
            (strcasecmp(outcode, "UTF16")   == 0  ||
             strcasecmp(outcode, "UTF-16")  == 0  ||
             strcasecmp(outcode, "UNICODE") == 0))
    {
        len1 = UTF8ToUTF16(out, &len1, in, &len);
    }
    /* UTF-16 -> UTF-8 */
    else if((strcasecmp(outcode, "UTF8")    == 0  ||
             strcasecmp(outcode, "UTF-8")   == 0) &&
            (strcasecmp(incode,  "UTF16")   == 0  ||
             strcasecmp(incode,  "UTF-16")  == 0  ||
             strcasecmp(incode,  "UNICODE") == 0))
    {
        len1 = UTF16ToUTF8(out, &len1, in, &len);
    }
    else
    {
        len1 = len;
        memcpy(out, in, len);
    }

    *outlen = (len1 < 0 ? 0 : len1);

    if(len1 < 0) return -1;

    return (*outlen);
}
int sessionAuditDecodeToURL(u_int8_t *inputstr,u_int32_t inputlen, u_int8_t *outputstr)
{
 char conv[] = "0123456789ABCDEF";
 u_int32_t i ;
 u_int8_t *d_ptr;
 u_int8_t *data;

 data = inputstr;
 d_ptr = outputstr;
 for(i = 0; i < inputlen; i++)
 {
  *d_ptr = conv[((*data & 0xFF) >> 4)];
  d_ptr++;

  *d_ptr = conv[((*data & 0xFF) & 0x0F)];
  d_ptr++;

  data++;
 }
 return 0;
}


#ifdef SAS3_10Q2_DECODE
//zxd change 20100315
int DecodeToURL(uint8_t *inputstr,u_int32_t inputlen, uint8_t *outputstr)
{
 int i;
 for (i = 0;i<inputlen;i++)
 {
  if (inputstr[i] == '/0')
  {
   outputstr[i] = '/0';
  }else if (inputstr[i] == '/'')
  {
   outputstr[i] = '"';
  }
  else if (inputstr[i] == '//')
  {
   outputstr[i] = '/';
  }
  else
   outputstr[i] = inputstr[i];
 }
 return 0;
}
#else
/*zxd change 20100222
 * URL decode
 *
 * */
int DecodeToURL(u_int8_t *inputstr,u_int32_t inputlen, u_int8_t *outputstr)
{
 char conv[] = "0123456789ABCDEF";
 u_int32_t i ;
 char *d_ptr;
 char *data;

 data = inputstr;
 d_ptr = outputstr;
 for(i = 0; i < inputlen; i++)
 {
  *d_ptr = conv[((*data & 0xFF) >> 4)];
  d_ptr++;

  *d_ptr = conv[((*data & 0xFF) & 0x0F)];
  d_ptr++;

  data++;
 }
 return 0;
}
#endif

jeff_2009
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
php中的字符编码转换函数用法示例
01-20
本文实例讲述了php中的字符编码转换函数的用法，分享给大家供大家参考。具体实现方法如下： 一般来说，在网页程序中，尤其是涉及到数据库的读出过程中，往往最恼火的就是字符编码的问题，php4.0.6以上的版本提供了mb...
“”(十六进制值 0x1D)是无效的字符
weixin_30760895的博客
07-21 3154
加载或保存XML时引发的异常.System.ArgumentException: “”(十六进制值 0x1D)是无效的字符。 产生原因是xml文件中包含低位非打印字符造成的 处理方法：在产生xml文件的时候，过滤低位非打印字符 把一个字符串中的 低序位 ASCII 字符 替换成 字符 转换 ASCII 0 - 8 -> - 转换 ASCII 11 - 12 -&gt...
UTF-8编码的转换
蘸月居
07-14 2189
一.UNICODE的相关概念UNICODE是为了处理包括中文，日文等字符而提出的一种通用的字符集。最初的UNICODE为双字节字符集，即16位编码，能够包括65，536个字符。但这样的容量并不能满足所有需要，因此，现在的UNICODE已经扩展到4个字节，能够容纳1,112,064 个字符，而这些在16位之后的扩展背称为增补字符。编码字符集是一个字符集，它为每一个字符分配一个唯一数字。Uni
两个unsigned char 转short,short转两个进制char
sheng199463的博客
02-01 1101
unsigned char 与short转换
负数的二进制表示方法（正数：原码、负数：补码）
weixin_30785593的博客
01-26 9115
原文连接：http://blog.csdn.net/diandianxiyu_geek/article/details/44098121 一：表示法： 1、正数5的表示法 假设有一个 int 类型的数，值为5，那么，我们知道它在计算机中表示为：00000000 00000000 00000000 000001015转换成二制是101，不过int类型的数占用4字节（32位），...
C++ 字符集转换 codecvt utf-8 gb2312 url
C++ 爱好者 make_it_simple888
12-12 6561
现在的做法： http://www.cppblog.com/mythma/archive/2012/09/11/wstring_convert_utf8.html 扔掉MultiByteToWideChar 吧，使用std::wstring_convert和 std::codecvt_utf8 来处理UTF8与WChar之间的互转。 VC和Clang都支持哦~ #include
PHP编码转换函数 自动转换字符集支持数组转换
12-18
复制代码 代码如下: // 自动转换字符集 支持数组转换 function auto_charset($fContents, $from=’gbk’, $to=’utf-8′) { $from = strtoupper($from) == ‘UTF8’ ? ‘utf-8’ : $from; $to = strtoupper($to) == ...
php实现utf-8和GB2312编码相互转换函数代码
01-20
php /******************************************** * * 函数名：get_utf8_to_gb($value) * 作 用：utf8编码字符串转换成gb2312编码 * 作 者：刘先忠 * 日 期：2011-11-09 * ***************************...
PHP iconv()函数字符编码转换的问题讲解
01-02
在php中iconv函数库能够完成各种字符集间的转换，是php编程中不可缺少的基础函数库；但有时候iconv对于部分数据转码会无缘无故的少一些。比如在转换字符”—”到gb2312时会出错。 下面一起慢慢看一下这个函数的用法...
php自定义函数实现汉字转换utf8编码的方法
10-21
主要介绍了php自定义函数实现汉字转换utf8编码的方法,涉及php针对字符串的遍历、截取及编码转换相关操作技巧,需要的朋友可以参考下
c/c++ 字符集 gbk/utf8互转，Ansi/Utf8互转 纯c实现跨平台
12-04
跨平台（windows Linux）是纯c实现 gbk/utf8互转，Ansi/Utf8互转，
usinged char 与 usinged short 存储转换
Jade的博客
08-13 824
usinged short是16字节 usinged char是8字节。当usinged short需要转换为uchar类型存储时，可采用高八位，低八位分别存储方式。方式如下： unsigned short newValue; uchar H = newValue &gt;&gt; 8; uchar L = newValue &amp; 0x00ff; 反之，当uchar需要转换为usinge...
[155]python之分析decode、encode、unicode编码转换
周小董
06-26 4412
decode()方法使用注册编码的编解码器的字符串进行解码。它默认为默认的字符串编码。decode函数可以将一个普通字符串转换为unicode对象。decode是将普通字符串按照参数中的编码格式进行解析，然后生成对应的unicode对象，比如在这里我们代码用的是utf-8，那么把一个字符串转换为unicode就是如下形式：s2=’哈’.decode(‘utf-8′)，s2就是一个存储了’哈’字的u...
描述符和字符串之间的相互转换(支持中文)
zhengdan66的专栏
08-15 545
<br />#include "utf.h"<br />/**<br />* 描述符转char*<br />* @param[in] aDescriptor 被转换的描述符<br />* @return 转换结果<br />*/<br />const char* descriptorToStringL(const TDesC& aDescriptor)<br />{<br />TInt length = aDescriptor.Length(); <br />HBufC8* buffer = HBufC8:
小程序 js把本地或取得临时的视频或者图片路径封装成file文件流
Carina的编程技术博客
11-01 6321
import FormData from '../../../utils/formdata' uploadFiles(newUrl){ // newUrl是本地文件的 tmp 地址 let formData = new FormData(); // 用法 // formData.append("name", "value"); // value 表单值 // formData.appendFile("file", filepath); // filepath 文件路径 fo.
(Unicode) UTF-8与UTF-16之间转换
热门推荐
韩搏专栏
10-21 3万+
一、Unicode的由来  1、我们知道计算机其实只认识0101这样的字符串，当然了让我们看这样的01串会比较头晕，所以为了描述简单一般都用八进制、十进制、十六进制表示。 实际上都是等价的。其它像文字图片音视频等计算机也是不认识的，为了让计算机能表示这些信息就必须转换成一些数字，必须按照一些规则转换。 比如：刚开始的时候就有ASCII字符集(American Standard Code fo
fopen怎么使用相对路径
jeff_2009的专栏
05-28 1万+
第一行为 UNIX 系统使用；第二行是 Windows 系列系统的用法；第三、四行则为 URL 的使用范例。$fp = fopen("/home/rasmus/file.txt", "r");$fp = fopen("c://mydata//info.txt", "r");$fp = fopen("http://www.php.net/", "r");$fp = fopen("ftp://user
TDS协议 加密密码算法
jeff_2009的专栏
05-19 3058
看freetds的源码：unsigned char *tds7_crypt_pass(const unsigned char *clear_pass, int len, unsigned char *crypt_pass){ int i; for (i = 0; i   crypt_pass[i] = ((clear_pass[i] > 4)) ^ 0xA5; return crypt_pass;}这一点，wireshark早已经解析出来了。只是，当时不知道用哪种算法实现。
Eclipse遇到的一些问题，和对应的解决办法
jeff_2009的专栏
12-15 2856
<br />1、“binary not found”<br />    需要build（编译）工程，注意build preference中的“自动生成makefile文件”注释掉（一般都自己写  Makefile文件）。build后就会出现binary等文档。注意eclipse中build、run、debug都需要revise configure<br /> 关于eclipse的build：<br />（1）在eclipse的project菜单下有build   automatically。选中这个的话。每
python处理excel的字符编码转换为utf-8
最新发布
09-03
Python处理Excel的字符编码转换为UTF-8相对简单。首先，要使用Python的pandas库来读取和处理Excel文件。然后，我们可以使用以下代码将Excel文件中的字符编码转换为UTF-8： ```python import pandas as pd # 读取Excel文件 df = pd.read_excel('文件路径') # 将字符编码转换为UTF-8 df = df.applymap(lambda x: x.encode('latin1').decode('utf-8')) # 保存转换后的Excel文件 df.to_excel('保存路径', index=False) ``` 首先，我们导入pandas库。然后，使用`pd.read_excel`函数读取Excel文件，并将其存储在DataFrame变量`df`中。 接下来，我们使用`applymap`函数遍历DataFrame中的每个单元格，并使用lambda函数将每个单元格的编码从latin1转换为UTF-8。这样就完成了字符编码的转换。 最后，我们使用`to_excel`函数将转换后的DataFrame保存为Excel文件，同时指定`index=False`来防止保存索引。 这样，我们就完成了将Excel文件中的字符编码转换为UTF-8的处理。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值