float형을 int로 빠르게 cast 하는 방법 / 문자열에서 코드종류 알아내기

LONG

 

< 조합/완성형 한글코드 판단 소스 >

  

 Discription : 한글코드 인식 루틴
                 한글코드는 조합형코드와 완성형 코드의 빈도수를 검사해서
                 판단하게되는데, 이렇게 빈도수만가지고 판단하게 되면 정확
                 한 판단이 힘들다.
                 따라서 전후 코드를 참조하고, 때로는 글자순서에 따른 판단
                 을 가미하여 좀더 정확한 판단을 할 수 있도록 했다.
 ****************************************************************************/
 //------------------------------------------------------------------------
 // #include <vcl\vcl.h>
 #include <windows.h>
 // #pragma hdrstop
 #include <stdlib.h>
 //------------------------------------------------------------------------
 #define KS5061_VERIFY_COUNT 512   // 완성형코드 확인 횟수

 bool _JisCheck = false;
 //------------------------------------------------------------------------
 int Check_HanRange( int hancode, int HexStart, int HexEnd, int max )
 {
   for( int i = 0; i < max; i++ )
   {
     if( hancode > HexStart+0x0100*i && hancode < HexEnd+0x0100*i )
       return  true;
   }
   return  false;
 }
 //------------------------------------------------------------------------
 int codecmp(const void *p,const void *q);
 #define MAX_CODE  48
 int isNotKsCode( int hancode )
 {
   static int kssmcode[MAX_CODE] = {
     0x8877,   //  "강"
     0x8969,   //  "결"
     0x89a1,   //  "고"
     0x8b71,   //  "금"
     0x8fa1,   //  "끼"
     0x9281,   //  "누"
     0x9c61,   //  "라"

     0x9e81,   // "루"
     0xa061,   //  "마"
     0xa0f5,   //  "멋"
     0xa2a1,   //  "뭐"
     0xa3a8,   //  "믿"
     0xa4e1,   //  "버"
     0xa4e5,   //  "번"
     0xa4f1,   // "범"
     0xa5c1,   //  "봐"
     0xa7a1,   //  "비"
     0xa8b1,   //  "뺨"
     0xaca1,   //  "샤"
     0xace1,   //  "서"
     0xace2,   //  "서"
     0xace3,   //  "서"
     0xace4,   //  "서"
     0xace5,   //  "선
     0xace6,   //  "서"
     0xace7,   //  "서"
     0xace8,   //  "서"
     0xace9,   //  "서"
     0xb3a2,   //  "씩"
     0xb4a1,   //  "야"
     0xb4a2,   //  "약"
     0xb4e1,   //  "어"
     0xb4f1,   //  "엄"
     0xb4f4,   //  "없"
     0xb541,   //  "에"

     0xb5e1,   //  "왜"
     0xb765,   //  "은"
     0xb8e5,   //  "전"
     0xb941,   //  "제"
     0xb9a1,   //  "조"
     0xb9a5,   //  "존"
     0xb9c1,   //  "좌"
     0xc561,   //  "켜"
     0xc7a1,   //  "키"
     0xcfa1,   //  "피"
     0xdbad,   //  "┃"
     0xdccf,   //  "ⓒ"
     0xe7e6,   //  "戊"
   };

   //  조합형 일어의 경우 완성형과 동일한 부분이 있는데,
   //  완성형에서는 거의 사용되지 않는 문자이므로,
   //  아래 코드가 있을경우 무조건 조합형으로 인식
   //  만일 조합형 일어 코드가 아니라면...
 if( hancode == 0xb7e7 ) return false;

   if( (int *)bsearch(&hancode, kssmcode, MAX_CODE, sizeof(int), codecmp) !=
 NULL ||
    ( hancode >= 0xd000 && hancode <= 0xd3ff ) ||
       ( hancode >= 0xdda1 && hancode <= 0xde98 ) ||
       ( hancode >= 0xdba1 && hancode <= 0xdbc8 ) ||

        //  조합형 한글이 제대로 인식이 되지 않던 문제 해결
       //  아래 코드가 있을경우 무조건 조합형으로 인식
       
       //  일부 완성형 코드가 조합형으로 인식하는 오류가 있어서
       //  검사 범위를 0xb400 - 0xb8ff 에서 0xb400 - 0xb7ff로 바꿈
       
       //  조합형과 완성형 둘다 사용되는 코드중, 완성형에서 자주
       //  사용되지 않는 코드들은 조합형 코드로 간주한다.
       ( hancode >= 0xc500 && hancode <= 0xc5ff ) ||
       ( hancode >= 0xb700 && hancode <= 0xb7cd ) ||
       ( hancode >= 0xb7cf && hancode <= 0xb7ff ) ||

       //  조합형 모음일경우 무조건 조합형으로 인식
       ( hancode >= 0xda00 && hancode <= 0xdaff ) ||

       //  조합형 선문자일경우도 무조건 조합형으로 인식
       //  만일 조합형 선문자 코드가 아니라면...
       ( hancode >= 0xd9b0 && hancode <= 0xd9cf ) ||
       ( hancode >= 0xd4b0 && hancode <= 0xd4cf ) )
     return  true;
   return  false;
 }
 //------------------------------------------------------------------------
 int isKS( String buf, int len )
 {
   int   hancode;
   byte  first, second;
   int   ks_count = 0;
   int   kssm_count = 0;
   int   max, count = 0;
   int   JpCount = 0;

   if( len >= 0 )  max = len;
   else  max = buf.Length();

   int   oldcode = false;
   for( int i = 0; i < max; i++ )
   {
     first = buf[count];
     count++;
     if(first < 0x80)  continue; //  한글코드가 아니라면
     second = buf[count];
     if( count > 10240 ) break;
     if( count >= max )  break;
     count++;

     hancode = (first << 8) + second;  //  한글코드를 조합하기

     //  조합형과 완성형 둘다 자주 쓰이는 코드일경우에는
     //  카운트를 하지않는다.
     if( hancode >= 0xb500 && hancode < 0xb5ff &&
         hancode != 0xb5a5 && hancode != 0xb5e1 &&
         hancode != 0xb541 )
       continue;

     //  완성형에서 빨,래,닯,데,덧과 같은 글자는 조합형에서도 자주 쓰이는
     //  글자이므로 카운트를 하지 않는다.
     if( hancode == 0xbba1 ||
         hancode == 0xb7a1 ||
         hancode == 0xb4e5 ||
         hancode == 0xb7b6 ||
         hancode == 0xb4f6 ||
         hancode == 0xb8e1 ||  //  "저"
         hancode == 0xb1c1 ||  //  "쏴"
         hancode == 0xbaa1 ||  //  "줘"
         hancode == 0xbba5 ||  //  "진"
         hancode == 0xb6a1 ||  //  "워"/"땀"
         hancode == 0xb6e1 ||  //  "위"
         hancode == 0xa1a1 ) continue;

         // 띄엄띄엄 띄워진 KS5061의 특수문자 코드인가?
     if( ( (hancode > 0xa1a2 && hancode < 0xa1ff) ||
         (hancode > 0xa2a0 && hancode < 0xa2e6) ||
         (hancode > 0xa3a0 && hancode < 0xa3ff) ||
         (hancode > 0xa4a0 && hancode < 0xa4ff) ||
         (hancode > 0xa5a0 && hancode < 0xa5f9) ||
         (hancode > 0xa6a0 && hancode < 0xa6e5) ||
         (hancode > 0xa7a0 && hancode < 0xa7f0) ||
         (hancode > 0xa8a0 && hancode < 0xa8ff) ||
         (hancode > 0xa9a0 && hancode < 0xa9ff) ||
         (hancode > 0xaaa0 && hancode < 0xaaf4) ||
         (hancode > 0xaba0 && hancode < 0xabf7) ||
         (hancode > 0xaca0 && hancode < 0xacc2) ||
         (hancode > 0xacd0 && hancode < 0xacf2) ||

         hancode == 0xaec2 ||

         (hancode > 0xadd0 && hancode < 0xadff) ||

         // KS5061의 한글코드인가?
         Check_HanRange( hancode, 0xb0a0, 0xb0ff, 16 ) ||
         Check_HanRange( hancode, 0xc0a0, 0xc0ff, 9  ) ||

         ( hancode == 0xb8ae ) ||
         ( hancode == 0xb7e7 ) || // 완성형 '루'

         // KS5061의 한자코드인가?
         Check_HanRange( hancode, 0xcaa0, 0xcaff, 6  ) ||
         Check_HanRange( hancode, 0xd0a0, 0xd0ff, 16 ) ||
         Check_HanRange( hancode, 0xe0a0, 0xe0ff, 16 ) ||
         Check_HanRange( hancode, 0xf0a0, 0xf0ff, 14 ) ) &&

         //  조합형과 완성형 둘다 사용되는 코드중, 조합형에서 자주
         //  사용되는 코드는 강제로 조합형 코드로 간주한다.
         !isNotKsCode( hancode ) )
     {
       if(++ks_count >= KS5061_VERIFY_COUNT)
         break;
     }
     else
     {
       if(++kssm_count >= KS5061_VERIFY_COUNT)
         break;
     }
   }

   //  대부분 조합형보다는 완성형 글이 많으므로 카운트 값이
   //  같을 경우 완성형으로 처리하도록 한다.
   if( ks_count >= kssm_count )
     return  KS_CODE;
   else
     return  KSSM_CODE;
 }

 

< 조합<->확장완성형 변환 소스 >

 확장완성형의 경우 크기가 큰 관계로 #define문을 통해서 프로그래에 내장할수도 있고, 또는 외부 파일로 저장하여 읽어들일수있도록 했습니다.

//------------------------------------------------------------------------
// #include <vcl\vcl.h>
// #pragma hdrstop
 //------------------------------------------------------------------------

 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <dir.h>
 #include <io.h>
 #include <dos.h>
 #include <dir.h>
 #include <dos.h>
 #include <io.h>

 typedef unsigned short int  word;

 #define DLL_ExtKS

 typedef struct  {   //  한글 코드 형태
     word  lasc :5;
     word  midc :5;
     word  firc :5;
     word  dummy:1;
 }   hcode;

 #define SINGLENUM   51  //  한글 낱자의 수
 #define SIZE_EXTKS  (sizeof(word)*8822)
 #define SIZE_KS     (sizeof(word)*2350)

 int isReadTable = false;
 //  확장 완성형 테이블을 읽어오는 함수
 int Read_ExtKSTable( void );
 // 현재 이지패드가 있는 경로와 파일명을 합성
 // 이건 따로 만들어야 함.
 void SetFilePath( char *dest, char *filename );

 //  한글 코드 변환
 int  codecmp(const void *p,const void *q);
 word comb2comb(char src, char dest, word code); // 조합 --> 조합
 word KSSM2KS(word code);      //  조합 -> 완성
 word KS2KSSM(word code);      //  완성 -> 조합
 word KSSM2ExtKS(word code);   //  조합 -> 확장완성
 word ExtKS2KSSM(word code);   //  확장완성 -> 조합

 word *ExtKSTable;
 word *KSTable;

 //  한글 낱자 51자의 조합형 코드
 word SingleTable[SINGLENUM] = {
   0x8841, 0x8c41, 0x8444, 0x9041, 0x8446, 0x8447, 0x9441, 0x9841,
   0x9c41, 0x844a, 0x844b, 0x844c, 0x844d, 0x844e, 0x844f, 0x8450,
   0xa041, 0xa441, 0xa841, 0x8454, 0xac41, 0xb041, 0xb441, 0xb841,
   0xbc41, 0xc041, 0xc441, 0xc841, 0xcc41, 0xd041, 0x8461, 0x8481,
   0x84a1, 0x84c1, 0x84e1, 0x8541, 0x8561, 0x8581, 0x85a1, 0x85c1,
   0x85e1, 0x8641, 0x8661, 0x8681, 0x86a1, 0x86c1, 0x86e1, 0x8741,
   0x8761, 0x8781, 0x87a1
 };

 //  조합형 코드 테이블
 //  삼보 조합형
 char KSSM1Table[32] = {
   -1,  0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14,
   15, 16, 17, 18, 19, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1
 };

 char KSSM2Table[32] = {
   -1, -1,  0,  1,  2,  3,  4,  5, -1, -1,  6,  7,  8,  9, 10, 11,
   -1, -1, 12, 13, 14, 15, 16, 17, -1, -1, 18, 19, 20, 21, -1, -1
 };

 char KSSM2Table0[22] = {
    2,  3,  4,  5,  6,  7, 10, 11, 12, 13, 14, 15, 18, 19, 20, 21,
   22, 23, 26, 27, 28, 29
 };

 char KSSM3Table[32] = {
   -1,  0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14,
   15, 16, -1, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, -1, -1
 };

 char KSSM3Table0[28] = {
    1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15, 16,
   17, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29
 };

 word  SpecTable[128] = {
     0xa1d9, 0xa1da, 0xa2be, 0xa1df, 0xa2c0, 0xa2bc, 0xa1dc, 0xa1e0,
     0xa1db, 0xa1e1, 0xa1ce, 0xa1cf, 0xa2dc, 0xa2dd, 0xa2b4, 0xa2ba,
     0xa2b8, 0xa2d5, 0xa3a1, 0xa2d2, 0xa1d7, 0xa1aa, 0xa2d9, 0xa1e8,
     0xa1e9, 0xa1e6, 0xa1e7, 0xa1d0, 0xa1ea, 0xa1e3, 0xa1e5, 0xeced,
     0xeac5, 0xfbfd, 0xe2a9, 0xd9ca, 0xd0dd, 0xf7cf, 0xd2b4, 0xa2cf,
     0xa1b8, 0xa1b9, 0xa8f6, 0xa8f9, 0xa3df, 0xa1ad, 0xa1c5, 0xa2c6,
     0xa2c7, 0xa2c8, 0xa6a2, 0xa6a9, 0xa6be, 0xa6b9, 0xa6c1, 0xa6c2,
     0xa6b4, 0xa6ad, 0xa6af, 0xa6b0, 0xa6c3, 0xa6c4, 0xa6a4, 0xa6a6,
     0xa6aa, 0xa6a8, 0xa6a7, 0xa6a1, 0xa6ab, 0xa6bc, 0xa6b7, 0xa6b1,
     0xa6ae, 0xa6b5, 0xa6b3, 0xa6b2, 0xa6ac, 0xa6b6, 0xa6ba, 0xa6bf,
     0xa6b8, 0xa6bd, 0xa6c5, 0xa6c6, 0xa6c8, 0xa6c7, 0xa6c0, 0xa6bb,
     0xa6a5, 0xa6a3, 0xa2c3, 0xa2c9, 0xa2ca, 0xa2cb, 0xa2cc, 0xa5e1,
     0xa9ac, 0xa5c3, 0xa5f0, 0xa5d2, 0xa5f2, 0xa5ec, 0xa5f3, 0xa5d5,
     0xa5e8, 0xa7d9, 0xa5e4, 0xa1c4, 0xa9aa, 0xa1f4, 0xa1fb, 0xa1d5,
     0xa1be, 0xa1c3, 0xa1c2, 0xa1f2, 0xa1f3, 0xa1c0, 0xa2cd, 0xa1a3,
     0xa1a4, 0xa1e7, 0xa1ee, 0xa9fa, 0xa9f7, 0,      0,      0xaec2,
 };

 //------------------------------------------------------------------------
 word comb2comb(char src, char dest, word code)
 {
   int   firc, midc, lasc;

   if(src == dest) return  code;

   firc = ((hcode *)&code)->firc;
   midc = ((hcode *)&code)->midc;
   lasc = ((hcode *)&code)->lasc;

   if( src == KSSM_CODE )
   {
     firc = KSSM1Table[firc];
     midc = KSSM2Table[midc];
     lasc = KSSM3Table[lasc];
   }
   if( firc < 0 || midc < 0 || lasc < 0 )  return  0;
   if( dest == KSSM_CODE )
   {
     firc++;
     midc = KSSM2Table0[midc];
     lasc = KSSM3Table0[lasc];
   }
   return(0x8000 + (firc << 10) + (midc << 5) + lasc);
 }
 //------------------------------------------------------------------------
 int codecmp(const void *p,const void *q)
 {
   word *p1 = (word *)p;
   word *q1 = (word *)q;
   return (*p1 - *q1);
 }
 //------------------------------------------------------------------------
 word KSSM2ExtKS(word Code)
 {
   word newCode;

   word index;
   word *p;
   BYTE high, low;

   newCode = KSSM2KS(Code);
   if( newCode == 0 )
   {
     if( (p = (word *)bsearch(&Code, ExtKSTable,
            SIZE_EXTKS / sizeof(word),
            sizeof(word), codecmp2)) != NULL)
       index = p - ExtKSTable;
     else  return  0;
     if(index < 5696)
     {
       high = (index / 178) + 0x81;
       index %= 178;
       if(index < 26 ) low = 0x41 + index;
       else if(index < 52) low = 0x61 + index - 26;
       else  low = 0x81 + index - 52;
     }
     else if(index < 8804)
     {
       index -= 5696;
       high = (index / 84) + 0xA1;
       index %= 84;
       if(index < 26)  low = 0x41 + index;
       else if(index < 52) low = 0x61 + index - 26;
       else  low = 0x81 + index - 52;
     }
     else {
       high = 0xC6;
       low = (index - 8804) % 18 + 0x41;
     }
     newCode = (((word) high) << 8) + low;
   }
   return newCode;
 }
 //------------------------------------------------------------------------
 word ExtKS2KSSM(word Code)
 {
   word newCode;
   BYTE high, low;
   word index;

   newCode = KS2KSSM(Code);
   if( newCode == 0 )
   {
     high = (BYTE) (Code >> 8);
     low = (BYTE) Code;
     if( high >= 0x81 && high <= 0xA0 )
     {
       index = (high - 0x81) * 178;
       if( low >= 0x41 && low <= 0x5A )  index += (low - 0x41);
       else if( low >= 0x61 && low <= 0x7A ) index += (low - 0x61 + 26);
       else index += (low - 0x81 + 52);
     }
     else if( high >= 0xA1 && high <= 0xC5 )
     {
       index = (high - 0xA1) * 84 + 5696;
       if( low >= 0x41 && low <= 0x5A )  index += (low - 0x41);
       else if( low >= 0x61 && low <= 0x7A ) index += (low - 0x61 + 26);
       else  index += (low - 0x81 + 52);
     }
     else if( high == 0xC6 && low >= 0x41 && low <= 0x52 )
       index = (low - 0x41 +

 8804);
     if( index >= 8822 ) return 0;
     newCode = ExtKSTable[index];
   }
   return  newCode;
 }
 //------------------------------------------------------------------------
 word KSSM2KS(word code)
 {
   BYTE  high, low;
   BYTE  temp;
   int   index;
   word  *p;

   high = (BYTE)(code >> 8);
   low = (BYTE)code;

   if( high == 0xd4 )
   {
     index = low-0x81;
     if( index < 128 )
       return  SpecTable[index];
   }

   //  한글 변환
   if( (p = (word *)bsearch(&code, KSTable, 2350,
          sizeof(word), codecmp2)) != NULL )
   {
     index = p - KSTable;
     return((((index / 94)+0xb0)<<8)+(index % 94) + 0xa1);
   }
   //  특수 문자 변환1
   else
   {
     if( high >= 0xd9 && high <= 0xde )
     {
       if( low < 0x30 || (low > 0x7e && low < 0x91) )
         return(0);
       if( low >= 0xa1 )
         temp = (high - 0xd9) * 2 + 0xa1 + 1;
       else
       {
         temp = (high - 0xd9) * 2 + 0xa1;
         if( low <= 0x7e ) low += 0x70;
         else      low += (0x70 - 18);
       }
       return((temp << 8) + low);
     }

     //  특수 문자 변환2
     else
     {
       if( high == 0xd4 )
       {
         if( low < 0x80 )  return  0;
         if( low <= 0xdd )
         {
           temp = 0xad;
           low += 0x21;
         }
         else
         {
           temp = 0xae;
           low -= 0x3d;
         }
         return((temp << 8) + low);
       }
       //  한자 변환
       else if( high >= 0xe0 && high <= 0xf9)
       {
         if( low < 0x30 || (low > 0x7e && low < 0x91)) return  0;
         if( low >= 0xa1) temp = (high - 0xe0) * 2 + 0xca + 1;
         else
         {
           temp = (high - 0xe0) * 2 + 0xca;
           if( low <= 0x7e ) low += 0x70;
      

     else low += (0x70 - 18);
         }
         return((temp << 8) + low);
       }
     }
   }
   for(index = 0;index < SINGLENUM;index++)
     if( SingleTable[index] == code) return(0xa4a1 + index);

   return(0);
 }
 //------------------------------------------------------------------------
 word KS2KSSM(word code)
 {
   BYTE high, low;
   BYTE temp;
   int  index;
   int  mod, rem;

   high = (BYTE)(code >> 8);
   low = (BYTE)code;

   //  특수 문자 변환1
   if( high >= 0xa1 && high <= 0xac )
   {
     if( low < 0xa1 || low > 0xfe) return  0;
     mod = (high - 0xa1) >> 1;
     rem = (high - 0xa1) & 0x01;
     if( rem) temp = low;
     else {
       temp = low - 0x70;
       if( temp > 0x7e) temp += 18;
     }
     return(((mod + 0xd9) << 8) + temp);
   }
   //  특수 문자 변환2
   else if( high == 0xad) {
     if( low < 0xa1 || low > 0xfe) return  0;
     temp = low - 0x21;
     return((0xd4 << 8) + temp);
   }
   //  특수 문자 변환3
   else if( high == 0xae) {
     if( low < 0xa1 || low > 0xc1)
     {
       if( low == 0xc2 ) return  0xd4ff;
       return  0;
     }
     temp = low + 0x3d;

     return((0xd4 << 8) + temp);
   }
   //  한글 변환
   else if( high >= 0xb0 && high <= 0xc8) {
     if( low < 0xa1 || low > 0xfe) return(0);
     index = (high - 0xb0) * 94 + low - 0xa1;
     return(KSTable[index]);
   }
   //  한자 변환
   else if( high >= 0xca && high <= 0xfd) {
     if( low < 0xa1 || low > 0xfe) return(0);
     mod = (high - 0xca) >> 1;
     rem = (high - 0xca) & 0x01;
     if( rem) temp = low;
     else {
       temp = low - 0x70;
       if( temp > 0x7e) temp += 18;
     }
     return(((mod + 0xe0) << 8) + temp);
   }

   index = ((code >> 8) - 0xb0) * 94 + (code & 0x00ff) - 0xa1;
   if( index < 0 || index >= 2350 )  return  0;
   return(KSTable[index]);
 }
 //------------------------------------------------------------------------
 bool _isReadExtKSTable = false;
 int Read_ExtKSTable( void )
 {
 if( ExtKSTable ) return true;
   char tempfile[300];
   int  retval = false;
   FILE *fp;

   SetFilePath( tempfile, "ExtKS.TBL" );
   fp = fopen( tempfile, "rb" );
   if( fp )
   {
     if( (unsigned long)filelength(fileno(fp)) == SIZE_EXTKS+SIZE_KS )
     {
       ExtKSTable = new word [8822];
       KSTable = new word [2350];
       fread( ExtKSTable, SIZE_EXTKS, 1, fp );
       fread( KSTable, SIZE_KS, 1, fp );
       retval = true;
     }
     fclose( fp );
     return  retval;
   }
   return  false;
 }
 //------------------------------------------------------------------------
 word ConvertHanCode(char SrcCode, char DestCode, word code)
 {
   if(SrcCode == KS_CODE )
     return  ExtKS2KSSM(code);
   else
     return  KSSM2ExtKS(code);
 }
 //------------------------------------------------------------------------
 void ConvertHanCodeStr(char SrcCode, char DestCode, char *str, int size )
 {
   BYTE high, low;
   int  i;
   BYTE *ptr = (BYTE *)str;
   word code;

   if(SrcCode == DestCode) return;

   if( Read_ExtKSTable() )
   {
     for( i = 0; i < size; )
     {
       if( !*(ptr) ) break;
       high = *(ptr);
       if( high >= 0x80 )
       {
         if( i+1 < size )
         {
           low = *(ptr+1);
           code = (high << 8) + low;
           code = ConvertHanCode(SrcCode, DestCode, code);
           if( code )
           {
             *(ptr) = (BYTE)(code >> 8);
             *(ptr+1) = (BYTE)(code & 0xFF);
           }
           else
           {
             *(ptr) = ' ';
             *(ptr+1) = ' ';
           }
           i += 2;
           ptr += 2;
         }
         else
         {
          i++;

           ptr++;
         }
       }
       else
       {
        i++;
         ptr++;
       }
     }
   }
 }
 //------------------------------------------------------------------------
 void Convert_Hanja2Han( char *str )
 {
   int Code;
   BYTE *ptr = (BYTE *)str;
   BYTE high, low;

  if( !Read_ExtKSTable() ) return;

   while( *ptr )
   {
     high = *ptr;
     if( high >= 0x80 )
     {
      if( *(ptr+1) )
       {
        low = *(ptr+1);
        Code = ExtKS2KSSM( (high<<8) + low );
         high = Code>>8;
         low  = (BYTE)Code;
         Hanja2Han( high, low );
         Code = KSSM2ExtKS( (high<<8) + low );
         high = Code>>8;
         low  = (BYTE)Code;
         *ptr = high;
         *(ptr+1) = low;
         ptr += 2;
       }
       else break;
     }
     else ptr++;
   }
 }
 //------------------------------------------------------------------------ 

ARTICLE

<float형을 int로 빠르게 cast 하는 방법>

  이건 보통 게임제작할때 많이 쓰이는 기법인데, 간단하면서도 빠른속도를 내주는 방법입니다.

  보통 float형을 int형으로 cast할때 (int)로 cast하는데요...
  이렇게 하는 것 보다는 다음과 같이 해주면 훨씬 빠르게 됩니다.
  num이란 float형 변수가 있을때 

           *(int *)#

  라고 해주면 훨씬 빠른 프로그램을 작성할 수 있습니다.

 

 

< 문자열에서 코드종류 알아내기 >

 이건 문자열에서 지정된 위치의 글자가 영문인지, 한글 상위/하위 바이트인지를 판별하는 루틴입니다. 참고로 TCodeType은 다음과 같은 의미입니다.

 

  ctEng  : 영문
  ctFirst: 한글 상위바이트
  ctLast : 한글 하위바이트

 

  enum  TCodeType { ctError = -1, ctEng, ctFirst, ctLast };

  TCodeType GetCodeType( char *str, int pos )
  {
       TCodeType type = ctEng;
       BYTE  *ptr = (BYTE *)str;
       while( *ptr ) {
            type = (type == ctFirst) ? ctLast : (*ptr >= 0x80 ? ctFirst : ctEng);
            if( pos == 0 )  return  type;
            pos--;
            ptr++;
       }
       return  ctError;
  }

 

 

[↓Click! 조합/완성형 한글코드 판단 소스 / 조합↔확장완성형 변환 소스 ]