source: svn/newcon3bcm2_21bu/dst/dmw/src/cc/cc_util.c @ 69

#include "cc_config.h"
#include "cc_type.h"
#include "cc_def.h"
#include "cc_private.h"

//#include <string.h>
#include <stdarg.h>

#if 0
__STRING__() {}
#endif

#if USE_ADVANCED_KSX_TO_UNICODE_TABLE
#include "ksx_uni_table2.h"
#else

#if USE_INNER_KSX_TO_UNICODE_TABLE
#include "cc_ksx_unicode_table.h"
#else
//UINT16 *p_ck2uk_table=DST_cktouk;
extern UINT16 p_ck2uk_table[];
#endif

#endif


int DCCUtil_UStrLen(UINT16 *str)
{
        int i;
        
        for(i=0; str[i]; i++);
        
        return i;
}

#if USE_ADVANCED_KSX_TO_UNICODE_TABLE

UINT16 DCCUtil_Ksx1001toUnicode(UINT16 code)
{
        UINT8 byte1=(code>>8), byte2=(code&0xff);
        int tab_idx = ((int)byte1 - 0x00a1) * 94 + (int)byte2 - 0x00a1;
        long code_ucs2;
        
        if(code<0xa1a0 || code>0xfdff) return code;
        
        if(code==0xa2e6) return 0x20ac;
        else if(code==0xa1a1) return 0x20;
        //else if(code==0xa3dc) return 0x209a;
        else if(code==0xa2a6) return 0x7e;
        else if(code==0xa2e7) return 0x00ae;
        else if(code>=0xa3a0 && code<0xa4a0) return code-0xa3a0+0x20;
        else if(code>=0xa4a0 && code<0xa5a0) return code-0xa4a0+0x2f80+0x1b0;
        else if (tab_idx >= 0 && tab_idx < ksc5601max) {
                code_ucs2 = tabksc5601[tab_idx];
                if (code_ucs2 != -1) return code_ucs2;
        }
        
        return 0x20; //if not exist, then return 0x20(blank)
}

#else

UINT16 DCCUtil_Ksx1001toUnicode(UINT16 code)
{
        UINT16 ret_code;
        
        if(!p_ck2uk_table) return code;
        
        if(code<0xa1a0 || code>0xfdff) return code;
        
        if(code>=0xa3a0 && code<=0xa3fe) {
                ret_code=code-0xa380;
        }
        else {
                code |= 0x8080;
                
                if(code>=0xb0a1 && code<=0xc8fe) {
                        code-=45217;
                        code=code/256*94 + code%256;
                        ret_code=p_ck2uk_table[code];
                }
                else if(code==0xa1a1) //space
                        ret_code=0x20;
                else if(code==0xa3dc) //back slash -> won
                        ret_code=0x20a9;
                else if(code>=0xa3a0 && code<=0xa3fe)
                        ret_code=code-0xa380;
                else if(code==0xa2a6)
                        ret_code=0x7e;
                else
                        ret_code=0x20;//Áö¿øÇÏÁö ¾Ê´Â ÄÚµå´Â °ø¹é ó¸®//ret_code=0x25af; //Áö¿øÇÏÁö ¾Ê´Â codeÀÎ °æ¿ì ¼¼¿î Á÷»ç°¢Çü
        }
        
        return ret_code;
}

#endif


#if 0
__DEBUG__() {}
#endif



#define MAX_NAME_LEN 16
#define MAX_DBG_ITEM 64

static struct {
        char name[MAX_NAME_LEN];
        BOOL is_on;
} p_dbg_info[MAX_DBG_ITEM]=
{ 
        {"noti", FALSE},
        {"warn", TRUE},
        {"error", TRUE},
        {"ud", FALSE},
        {"dmx708", FALSE},
        {"parse708", FALSE},
        {"parse708ex", FALSE},
        {"win_ch", FALSE},
        {"win_chex", FALSE},
        {"win_rect", FALSE},
        {"win_line", FALSE},
        {"spl", FALSE},
        {"dfx", FALSE},
        {"708data", FALSE},
        //{"ddi_box", TRUE},
        //{"ddi_ch", TRUE},
};

static int p_dbg_idx=14;
static UINT32 p_ms_debug_off;
static BOOL p_is_dbg_on=TRUE;


void DCCUtil_DbgPrint(char *pname, char *fmt, ...)
{
        int i;
        
        if(!p_is_dbg_on) return;
        
        for(i=0; i<p_dbg_idx; i++) {
                if(strcmp(pname, p_dbg_info[i].name)==0) {
                        if(!p_dbg_info[i].is_on) return;
                                
                        break;
                }
        }
        
        if(i==p_dbg_idx) { /* ãÁö ¸øÇÔ, µî·Ï */
                if(p_dbg_idx<MAX_DBG_ITEM-1) {
                        strcpy(p_dbg_info[p_dbg_idx++].name, pname);
                }
                else {
                        DHL_OS_Printf("!! dbg item is over MAX_DBG_ITEM(%d)\n", MAX_DBG_ITEM);
                }
                
                return;
        }
        
        if(DCCDDI_GetCurMs()-p_ms_debug_off<3000) return;
                /* 3ÃÊ Á¤µµ ½Ã°£À» ¹ø´Ù */
        
        if(1) {
                char buf[512];
                va_list v;
                sprintf(buf, "[CC:%05d][%8s] ", DCCDDI_GetCurMs()/10, pname);
                
                va_start(v, fmt);
#if SUPPORT_WINDOWS
                _vsnprintf(buf+strlen(buf), 512-strlen(buf), fmt, v);
#else
                vsnprintf(buf+strlen(buf), 512-strlen(buf), fmt, v);
#endif
                va_end(v);

                DHL_OS_Printf(buf);

        }
}

void DCCUtil_ShowDbgItem()
{
        int i;
        
        p_ms_debug_off=DCCDDI_GetCurMs();
        
        DHL_OS_Printf("Debug Info.\n");
        DHL_OS_Printf("--------------------------------------------------\n");
        DHL_OS_Printf("id   on     name\n");
        DHL_OS_Printf("--------------------------------------------------\n");
        for(i=0; i<p_dbg_idx; i++) {
                DHL_OS_Printf("%2d : %s | %s\n", i, p_dbg_info[i].is_on?"On ":"Off", p_dbg_info[i].name);
        }
        
        DHL_OS_Printf("--------------------------------------------------\n");
        
}


void DCCUtil_SetDbgOn(char *pname, BOOL is_on)
{
        int i;
        
        for(i=0; i<p_dbg_idx; i++) {
                if(strcmp(pname, p_dbg_info[i].name)==0) {
                        p_dbg_info[i].is_on=is_on;
                        return;
                }
        }
        
        if(p_dbg_idx<MAX_DBG_ITEM-1) {
                strcpy(p_dbg_info[p_dbg_idx].name, pname);
                p_dbg_info[p_dbg_idx].is_on=is_on;
                p_dbg_idx++;
        }
}


void DCCUtil_ToggleDbgOn(char *pname)
{
        int i;
        
        for(i=0; i<p_dbg_idx; i++) {
                if(strcmp(pname, p_dbg_info[i].name)==0) {
                        p_dbg_info[i].is_on=p_dbg_info[i].is_on?FALSE:TRUE;
                        return;
                }
        }
}


void DCCUtil_SetDbgOnByIdx(int idx, BOOL is_on)
{
        if(idx>=p_dbg_idx) {
                DHL_OS_Printf("!! bad idx num\n");
                return;
        }
        
        p_dbg_info[idx].is_on=is_on;
}


void DCCUtil_ToggleDbgOnByIdx(int idx)
{
        if(idx>=p_dbg_idx) {
                DHL_OS_Printf("!! bad idx num\n");
                return;
        }
        
        p_dbg_info[idx].is_on=p_dbg_info[idx].is_on?FALSE:TRUE;
}

void cda(char *pname) /* cc debug active */
{
        DCCUtil_SetDbgOn(pname, TRUE);
}

void cdi(char *pname) /* cc debug inactive */
{
        DCCUtil_SetDbgOn(pname, FALSE);
}

void csd() /* cc show debug */
{
        DCCUtil_ShowDbgItem();
}

void cdai(int idx) /* cc debug active by index */
{
        DCCUtil_SetDbgOnByIdx(idx, TRUE);
}

void cdii(int idx) /* cc debug inactive by index */
{
        DCCUtil_SetDbgOnByIdx(idx, FALSE);
}

void ctn(char *pname) /* cc toggle by name */
{
        DCCUtil_ToggleDbgOn(pname);
}

void cti(int idx) /* cc toggle by index */
{
        DCCUtil_ToggleDbgOnByIdx(idx);
}

void cdo()
{
        p_is_dbg_on=p_is_dbg_on?FALSE:TRUE;
}

#if 0
__BIT_BUFFER__() {}
#endif

#define MAX_SIZE_BIT_BUF (256+3)

static UINT8 p_regBitBuf[MAX_SIZE_BIT_BUF];//neverdai 070522.
static UINT16 p_regBitBufSize, p_regBitBufIdx;

static void p_attach_end_marker()//neverdai 070522.
{
        p_regBitBuf[p_regBitBufSize/8]=0x0;
        p_regBitBuf[p_regBitBufSize/8+1]=0x0;
        p_regBitBuf[p_regBitBufSize/8+2]=0x1;
        p_regBitBufSize+=24;
}


void DCCUtil_InitBitBuf(UINT8 *pdata, int size)
{
        if(!pdata || size==0) {
                p_regBitBufSize=0;
                return;
        }

        if(size>=MAX_SIZE_BIT_BUF) {
                CCPRINT("warn", "!! Error..size is over 256\n");
#if 0
                p_regBitBufSize=0;
                return;
#else
                size=MAX_SIZE_BIT_BUF;
#endif
        }
                
        memcpy(p_regBitBuf, pdata, size);
        p_regBitBufSize=size<<3;//p_regBitBufSize*8;
        p_regBitBufIdx=0;
        p_attach_end_marker();
}


UINT32 DCCUtil_NextBits(UINT8 size)
{
        int i;
        UINT32 retVal;
        UINT8 temp;

        //bit under flow check
        if(p_regBitBufIdx+size>p_regBitBufSize) {
                return 0;
        }
        
        temp=p_regBitBuf[p_regBitBufIdx/8];
        
        for(i=p_regBitBufIdx, retVal=0 ;i<p_regBitBufIdx+size;) {
                
                retVal=(retVal<<1)|((temp>>(7-i%8))&0x1);
                
                if(++i%8==0)
                        temp=p_regBitBuf[i/8];
        }
        
        return retVal;  
}
                

UINT32 DCCUtil_GetBits(UINT8 size)
{
        int retValue;
        
        //bit under flow check  
        if(p_regBitBufIdx+size>p_regBitBufSize) {
                return 0;
        }
        
        retValue=DCCUtil_NextBits(size);
        
        p_regBitBufIdx+=size;
        
        return retValue;
}

void DCCUtil_UngetBits(UINT32 size, UINT32 data)
{
        //ÇÊ¿ä¾øÀ» µí.
}

//GetBits³ª NextBits Àü¿¡ bit underflow check.
int DCCUtil_CheckBits(UINT8 size)
{
        if(p_regBitBufIdx+size>p_regBitBufSize) {
                return -1;
        }
        return 0;       //success
}