Return to BranchX86.c CVS log

Up to [ELWIX - Embedded LightWeight unIX -] / elwix / tools / oldlzma / SRC / 7zip / Compress / Branch

Annotation of elwix/tools/oldlzma/SRC/7zip/Compress/Branch/BranchX86.c, revision 1.1.1.1

1.1       misho       1: /* BranchX86.c */
                      2: 
                      3: #include "BranchX86.h"
                      4: 
                      5: /*
                      6: static int inline Test86MSByte(Byte b)
                      7: {
                      8:   return (b == 0 || b == 0xFF);
                      9: }
                     10: */
                     11: #define Test86MSByte(b) ((b) == 0 || (b) == 0xFF)
                     12: 
                     13: const int kMaskToAllowedStatus[8] = {1, 1, 1, 0, 1, 0, 0, 0};
                     14: const Byte kMaskToBitNumber[8] = {0, 1, 2, 2, 3, 3, 3, 3};
                     15: 
                     16: /*
                     17: void x86_Convert_Init(UInt32 *prevMask, UInt32 *prevPos)
                     18: {
                     19:   *prevMask = 0;
                     20:   *prevPos = (UInt32)(-5);
                     21: }
                     22: */
                     23: 
                     24: UInt32 x86_Convert(Byte *buffer, UInt32 endPos, UInt32 nowPos, 
                     25:     UInt32 *prevMask, UInt32 *prevPos, int encoding)
                     26: {
                     27:   UInt32 bufferPos = 0;
                     28:   UInt32 limit;
                     29: 
                     30:   if (endPos < 5)
                     31:     return 0;
                     32:   
                     33:   if (nowPos - *prevPos > 5)
                     34:     *prevPos = nowPos - 5;
                     35:   
                     36:   limit = endPos - 5;
                     37:   while(bufferPos <= limit)
                     38:   {
                     39:     Byte b = buffer[bufferPos];
                     40:     UInt32 offset;
                     41:     if (b != 0xE8 && b != 0xE9)
                     42:     {
                     43:       bufferPos++;
                     44:       continue;
                     45:     }
                     46:     offset = (nowPos + bufferPos - *prevPos);
                     47:     *prevPos = (nowPos + bufferPos);
                     48:     if (offset > 5)
                     49:       *prevMask = 0;
                     50:     else
                     51:     {
                     52:       UInt32 i;
                     53:       for (i = 0; i < offset; i++)
                     54:       {
                     55:         *prevMask &= 0x77;
                     56:         *prevMask <<= 1;
                     57:       }
                     58:     }
                     59:     b = buffer[bufferPos + 4];
                     60:     if (Test86MSByte(b) && kMaskToAllowedStatus[(*prevMask >> 1) & 0x7] && 
                     61:       (*prevMask >> 1) < 0x10)
                     62:     {
                     63:       UInt32 src = 
                     64:         ((UInt32)(b) << 24) |
                     65:         ((UInt32)(buffer[bufferPos + 3]) << 16) |
                     66:         ((UInt32)(buffer[bufferPos + 2]) << 8) |
                     67:         (buffer[bufferPos + 1]);
                     68:       
                     69:       UInt32 dest;
                     70:       while(1)
                     71:       {
                     72:         UInt32 index;
                     73:         if (encoding)
                     74:           dest = (nowPos + bufferPos + 5) + src;
                     75:         else
                     76:           dest = src - (nowPos + bufferPos + 5);
                     77:         if (*prevMask == 0)
                     78:           break;
                     79:         index = kMaskToBitNumber[*prevMask >> 1];
                     80:         b = (Byte)(dest >> (24 - index * 8));
                     81:         if (!Test86MSByte(b))
                     82:           break;
                     83:         src = dest ^ ((1 << (32 - index * 8)) - 1);
                     84:       }
                     85:       buffer[bufferPos + 4] = (Byte)(~(((dest >> 24) & 1) - 1));
                     86:       buffer[bufferPos + 3] = (Byte)(dest >> 16);
                     87:       buffer[bufferPos + 2] = (Byte)(dest >> 8);
                     88:       buffer[bufferPos + 1] = (Byte)dest;
                     89:       bufferPos += 5;
                     90:       *prevMask = 0;
                     91:     }
                     92:     else
                     93:     {
                     94:       bufferPos++;
                     95:       *prevMask |= 1;
                     96:       if (Test86MSByte(b))
                     97:         *prevMask |= 0x10;
                     98:     }
                     99:   }
                    100:   return bufferPos;
                    101: }