home *** CD-ROM | disk | FTP | other *** search
/ ftp.funduc.com / 2014.08.ftp.funduc.com.tar / ftp.funduc.com / fshedcode102502.zip / BinTrans.cpp < prev    next >
C/C++ Source or Header  |  2001-04-19  |  9KB  |  411 lines
  1.  
  2. //-------------------------------------------------------------------
  3. char Text2BinTranslator::cTranslateAnsiToOem( char c )
  4. {
  5.     char sbuf[2], dbuf[2];
  6.     sbuf[0]=c;
  7.     sbuf[1]=0;
  8.     CharToOemBuff( sbuf, dbuf, 1 );
  9.     return dbuf[0];
  10. }
  11.  
  12. //-------------------------------------------------------------------
  13. // Find char c from pointer to array src on, return it's position.
  14. int Text2BinTranslator::iFindBytePos( char* src, char c )
  15. {
  16.     int i=0;
  17.     while (src[i] != c)
  18.         i++;
  19.     return i;
  20. }
  21.  
  22. //-------------------------------------------------------------------
  23. // Create translation of bytecode-string.
  24. int Text2BinTranslator::GetTrans2Bin( SimpleArray<char>& sa, int charmode, int binmode )
  25. {
  26.     sa.ClearAll();
  27.  
  28.     int destlen = iLengthOfTransToBin( m_pT, m_nUpperBound );
  29.     if (destlen > 0)
  30.     {
  31.         sa.SetSize( destlen );
  32.         sa.ExpandToSize();
  33.         iCreateBcTranslation( (char*) sa, m_pT, m_nUpperBound, charmode, binmode );
  34.         return TRUE;
  35.     }
  36.     else
  37.     {
  38.         // Empty input string => don't allocate anything and return 0.
  39.         return FALSE;
  40.     }
  41.  
  42.     return TRUE;
  43. }
  44.  
  45. //-------------------------------------------------------------------
  46. // How long is a bytecode-string that encodes char-array src of length srclen?
  47. // Return: Length of bytecode-string including zero-byte.
  48. int Text2BinTranslator::iBytes2BytecodeDestLen( char* src, int srclen )
  49. {
  50.     int i, destlen = 1;
  51.     for (i=0; i<srclen; i++)
  52.     {
  53.         if (src[i] == '<')
  54.             destlen+=2; // Escapecode needed.
  55.         else if( src[i] == '\\' )
  56.             destlen+=2; // Escapecode needed.
  57.         else if (src[i] >= 32 && src[i] < 127)
  58.             destlen++; // Normal char.
  59.         else if( src[i]==10 || src[i]==13 )
  60.             destlen++; // LF/CR.
  61.         else
  62.             destlen+=7; // Escapecode needed: <bh:xx>
  63.     }
  64.     return destlen;
  65. }
  66.  
  67. //-------------------------------------------------------------------
  68. // Bytecode?
  69. // Return = 0 if no bytecode
  70. //        else = Length 1/2/4 if bytecode
  71. int Text2BinTranslator::iIsBytecode( char* src, int len )
  72. {
  73.     int i=0;
  74.  
  75.     if (src[i] == '<')
  76.     {
  77.         if (i+1 < len)
  78.         {
  79.             switch (src[i+1])
  80.             {
  81.             case 'b': case 'w': case 'l': case 'f': case 'd':
  82.                 if (i+2 < len)
  83.                 {
  84.                     switch (src[i+2])
  85.                     {
  86.                         case 'd': case 'h': case 'l': case 'o':
  87.                             if (i+3 < len)
  88.                             {
  89.                                 if (src[i+3] == ':')
  90.                                 {
  91.                                     int j,k;
  92.                                     for (j=4; j < len; j++)
  93.                                     {
  94.                                         if (src[i+j] == '>')
  95.                                             break;
  96.                                     }
  97.                                     if (j==4 || j==len)
  98.                                         // No concluding ">" found.
  99.                                         return FALSE;
  100.                                     for (k=4; k<j; k++)
  101.                                     {
  102.                                         switch (src[i+2])
  103.                                         {
  104.                                         case 'd':
  105.                                             if ((src[i+k]>='0' && src[i+k]<='9') || src[i+k]=='-')
  106.                                                 continue;
  107.                                             else
  108.                                                 return FALSE; // Non-digit found.
  109.                                             break;
  110.  
  111.                                         case 'h':
  112.                                             if ((src[i+k]>='0' && src[i+k]<='9') ||
  113.                                              (src[i+k]>='a' && src[i+k]<='f'))
  114.                                                 continue;
  115.                                             else
  116.                                                 return FALSE; // Non-hex-digit.
  117.                                             break;
  118.  
  119.                                         case 'o': case 'l': // float or double.
  120.                                             if ((src[i+k]>='0' && src[i+k]<='9') || src[i+k]=='-' || src[i+k]=='.' || src[i+k]=='e' || src[i+k]=='E')
  121.                                                 continue;
  122.                                             else
  123.                                                 return FALSE;
  124.                                             break;
  125.                                         }
  126.                                     }
  127.                                     switch (src[i+1])
  128.                                     {
  129.                                     default:
  130.                                     case 'b': return 1;
  131.                                     case 'w': return 2;
  132.                                     case 'l': return 4;
  133.                                     case 'f': return 4;
  134.                                     case 'd': return 8;
  135.                                     }
  136.                                 }
  137.                                 else
  138.                                     return FALSE; // No ':'.
  139.                             }
  140.                             else
  141.                                 return FALSE; // No space for ':'.
  142.                             break;
  143.                         
  144.                         default:
  145.                             return FALSE; // Wrong second option.
  146.                     }
  147.                 }
  148.                 else
  149.                     return FALSE; // No space for option 2.
  150.                 break;
  151.             
  152.             default:
  153.                 return FALSE; // Wrong first option.
  154.                 break;
  155.             }
  156.         }
  157.         else
  158.             return FALSE; // No space for option 1;
  159.     }
  160.     else
  161.         return FALSE; // No '<'.
  162. }
  163.  
  164. //-------------------------------------------------------------------
  165. // Get value of *one* bytecode token.
  166. // Return: value of code.
  167. // bytecode must be checked before!!
  168. int Text2BinTranslator::iTranslateOneBytecode( char* dest, char* src, int srclen, int binmode )
  169. {
  170.     int i, k=0;
  171.     char buf[50];
  172.     for (i=4; i<srclen; i++)
  173.     {
  174.         if (src[i]=='>')
  175.             break;
  176.         else
  177.         {
  178.             buf[k++] = src[i];
  179.         }
  180.     }
  181.     buf[k] = 0;
  182.     int value;
  183.     float fvalue;
  184.     double dvalue;
  185.     switch (src[2]) // Get value from text.
  186.     {
  187.     case 'd':
  188.         sscanf (buf, "%d", &value);
  189.         break;
  190.  
  191.     case 'h':
  192.         sscanf (buf, "%x", &value);
  193.         break;
  194.  
  195.     case 'l':
  196.         sscanf (buf, "%f", &fvalue);
  197.         break;
  198.  
  199.     case 'o':
  200.         sscanf (buf, "%lf", &dvalue);
  201.         break;
  202.     }
  203.  
  204.     if (binmode == LITTLEENDIAN_MODE)
  205.     {
  206.         switch (src[1])
  207.         {
  208.         case 'b':
  209.             dest[0] = (char) value;
  210.             break;
  211.  
  212.         case 'w':
  213.             dest[0] = (value & 0xff);
  214.             dest[1] = (value & 0xff00)>>8;
  215.             break;
  216.         
  217.         case 'l':
  218.             dest[0] = (value & 0xff);
  219.             dest[1] = (value & 0xff00)>>8;
  220.             dest[2] = (value & 0xff0000)>>16;
  221.             dest[3] = (value & 0xff000000)>>24;
  222.             break;
  223.  
  224.         case 'f':
  225.             *((float*)dest) = fvalue;
  226.             break;
  227.  
  228.         case 'd':
  229.             *((double*)dest) = dvalue;
  230.             break;
  231.         }
  232.     }
  233.     else // BIGENDIAN_MODE
  234.     {
  235.         switch (src[1])
  236.         {
  237.         case 'b':
  238.             dest[0] = (char) value;
  239.             break;
  240.  
  241.         case 'w':
  242.             dest[0] = HIBYTE (LOWORD (value));
  243.             dest[1] = LOBYTE (LOWORD (value));
  244.             break;
  245.         
  246.         case 'l':
  247.             dest[0] = HIBYTE (HIWORD (value));
  248.             dest[1] = LOBYTE (HIWORD (value));
  249.             dest[2] = HIBYTE (LOWORD (value));
  250.             dest[3] = LOBYTE (LOWORD (value));
  251.             break;
  252.  
  253.         case 'f':
  254.             {
  255.                 char* p = (char*) &fvalue;
  256.                 int i;
  257.                 for (i=0; i<4; i++)
  258.                 {
  259.                     dest[i] = p[3-i];
  260.                 }
  261.             }
  262.             break;
  263.  
  264.         case 'd':
  265.             {
  266.                 char* p = (char*) &dvalue;
  267.                 int i;
  268.                 for (i=0; i<8; i++)
  269.                 {
  270.                     dest[i] = p[7-i];
  271.                 }
  272.             }
  273.             break;
  274.         }
  275.     }
  276.     return value;
  277. }
  278.  
  279. //-------------------------------------------------------------------
  280. // Get length of translated array of bytes from text.
  281. int Text2BinTranslator::iLengthOfTransToBin( char* src, int srclen )
  282. {
  283.     int i, destlen = 0, l, k;
  284.     for (i=0; i<srclen; i++)
  285.     {
  286.         if ((l = iIsBytecode (&(src[i]), srclen-i)) == 0)
  287.         {
  288.             if (src[i] == '\\')
  289.             {
  290.                 if (i+1 < srclen)
  291.                 {
  292.                     if (src[i+1] == '<')
  293.                     {
  294.                         // Code for "<" alone without decoding.
  295.                         destlen++;
  296.                         i++;
  297.                     }
  298.                     else if( src[i+1] == '\\' )
  299.                     {
  300.                         // Code for "\\".
  301.                         destlen++;
  302.                         i++;
  303.                     }
  304.                     else
  305.                     {
  306.                         destlen++;
  307.                     }
  308.                 }
  309.                 else
  310.                 {
  311.                     destlen++;
  312.                 }
  313.             }
  314.             else
  315.             {
  316.                 destlen++;
  317.             }
  318.         }
  319.         else
  320.         {
  321.             destlen += l;
  322.             for (k=i; i<srclen; k++)
  323.             {
  324.                 if (src[k]=='>')
  325.                     break;
  326.             }
  327.             i = k;
  328.         }
  329.     }
  330.     return destlen;
  331. }
  332.  
  333. //-------------------------------------------------------------------
  334. // dest must be set to right length before calling.
  335. int Text2BinTranslator::iCreateBcTranslation( char* dest, char* src, int srclen, int charmode, int binmode )
  336. {
  337.     int i, di=0, bclen;
  338.     for (i=0; i<srclen; i++)
  339.     {
  340.         if ((bclen = iIsBytecode(&(src[i]), srclen-i)) > 0) // Get length of byte-code.
  341.         {
  342.             // Bytecode found.
  343.             iTranslateOneBytecode (&(dest[di]), &(src[i]), srclen-i, binmode);
  344.             di += bclen;
  345.             i += iFindBytePos( &( src[i] ), '>' );
  346.         }
  347.         else // Normal character.
  348.         {
  349.             if (src[i] == '\\') // Special char "\<" or "\\"?
  350.             {
  351.                 if (i+1 < srclen)
  352.                 {
  353.                     if (src[i+1] == '<')
  354.                     {
  355.                         dest[di++] = '<'; // Special char recognized.
  356.                         i++;
  357.                     }
  358.                     else if( src[i+1] == '\\' )
  359.                     {
  360.                         dest[di++] = '\\'; // Special char recognized.
  361.                         i++;
  362.                     }
  363.                     else
  364.                         dest[di++] = src[i]; // Unknown special char.
  365.                 }
  366.                 else
  367.                     dest[di++] = src[i]; // Not enough space for special char.
  368.             }
  369.             else
  370.             {
  371.                 // No special char.
  372.                 switch (charmode)
  373.                 {
  374.                 case ANSI_SET:
  375.                     dest[di++] = src[i];
  376.                     break;
  377.  
  378.                 case OEM_SET:
  379.                     dest[di++] = cTranslateAnsiToOem (src[i]);
  380.                     break;
  381.                 }
  382.             }
  383.         }
  384.     }
  385.     return di;
  386. }
  387.  
  388. //-------------------------------------------------------------------
  389. Text2BinTranslator::Text2BinTranslator( char* ps )
  390. {
  391.     // Create a Text2BinTranslator from a normal char array-string.
  392.     m_nGrowBy = 64;
  393.     Clear();
  394.     SetToString( ps );
  395. }
  396.  
  397. //-------------------------------------------------------------------
  398. Text2BinTranslator::Text2BinTranslator()
  399. {
  400.     SimpleString::SimpleString();
  401. }
  402.  
  403. //-------------------------------------------------------------------
  404. int Text2BinTranslator::bCompareBin( Text2BinTranslator& tr2, int charmode, int binmode )
  405. {
  406.     SimpleArray<char> sa1, sa2;
  407.     GetTrans2Bin( sa1, charmode, binmode );
  408.     tr2.GetTrans2Bin( sa2, charmode, binmode );
  409.     return ( sa1 == sa2 );
  410. }
  411.