The main issue want to be resolve is that some tools need EfiCompress and other tools...
authorklu2 <klu2@6f19259b-4bc3-4df7-8a09-765794883524>
Thu, 7 Dec 2006 05:29:07 +0000 (05:29 +0000)
committerklu2 <klu2@6f19259b-4bc3-4df7-8a09-765794883524>
Thu, 7 Dec 2006 05:29:07 +0000 (05:29 +0000)
EfiCompress and TianoCompress are all originated from LZ77 algorithms and they have very little different, that different position set for Huffman code.
EfiCompress is defined in EFI 1.1 spec and EfiRom tool need it to create a recognized compressed EFI driver.
TianoCompress is for pursuer more size saving and it used be GenFfs and GenSection tools.
So this patch:
1) Split EfiComress and TianoCompress in edkII‚Äôs tools
2) Change EfiRom tool use EfiCompress and GenFfs/GenSection use TianoCompress

git-svn-id: https://edk2.svn.sourceforge.net/svnroot/edk2/trunk/edk2@2064 6f19259b-4bc3-4df7-8a09-765794883524

Tools/CCode/Source/Common/Compress.h [new file with mode: 0644]
Tools/CCode/Source/Common/EfiCompress.c
Tools/CCode/Source/Common/EfiCompress.h [deleted file]
Tools/CCode/Source/Common/TianoCompress.c [new file with mode: 0644]
Tools/CCode/Source/CompressDll/CompressDll.c
Tools/CCode/Source/EfiCompress/EfiCompressMain.c
Tools/CCode/Source/EfiRom/EfiRom.c
Tools/CCode/Source/GenFfsFile/GenFfsFile.c
Tools/CCode/Source/GenSection/GenSection.c

diff --git a/Tools/CCode/Source/Common/Compress.h b/Tools/CCode/Source/Common/Compress.h
new file mode 100644 (file)
index 0000000..7366e72
--- /dev/null
@@ -0,0 +1,94 @@
+/*++\r
+\r
+Copyright (c) 2004 - 2006, Intel Corporation                                              \r
+All rights reserved. This program and the accompanying materials                          \r
+are licensed and made available under the terms and conditions of the BSD License         \r
+which accompanies this distribution.  The full text of the license may be found at        \r
+http://opensource.org/licenses/bsd-license.php                                            \r
+                                                                                          \r
+THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,                     \r
+WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.             \r
+\r
+Module Name:\r
+\r
+  Compress.h\r
+\r
+Abstract:\r
+\r
+  Header file for compression routine.\r
+  Providing both EFI and Tiano Compress algorithms.\r
+  \r
+--*/\r
+\r
+#ifndef _COMPRESS_H_\r
+#define _COMPRESS_H_\r
+\r
+#include <string.h>\r
+#include <stdlib.h>\r
+\r
+#include <Common/UefiBaseTypes.h>\r
+/*++\r
+\r
+Routine Description:\r
+\r
+  Tiano compression routine.\r
+\r
+--*/\r
+EFI_STATUS\r
+TianoCompress (\r
+  IN      UINT8   *SrcBuffer,\r
+  IN      UINT32  SrcSize,\r
+  IN      UINT8   *DstBuffer,\r
+  IN OUT  UINT32  *DstSize\r
+  )\r
+;\r
+\r
+/*++\r
+\r
+Routine Description:\r
+\r
+  Efi compression routine.\r
+\r
+--*/\r
+EFI_STATUS\r
+EfiCompress (\r
+  IN      UINT8   *SrcBuffer,\r
+  IN      UINT32  SrcSize,\r
+  IN      UINT8   *DstBuffer,\r
+  IN OUT  UINT32  *DstSize\r
+  )\r
+;\r
+\r
+/*++\r
+\r
+Routine Description:\r
+\r
+  The compression routine.\r
+\r
+Arguments:\r
+\r
+  SrcBuffer   - The buffer storing the source data\r
+  SrcSize     - The size of source data\r
+  DstBuffer   - The buffer to store the compressed data\r
+  DstSize     - On input, the size of DstBuffer; On output,\r
+                the size of the actual compressed data.\r
+\r
+Returns:\r
+\r
+  EFI_BUFFER_TOO_SMALL  - The DstBuffer is too small. In this case,\r
+                DstSize contains the size needed.\r
+  EFI_SUCCESS           - Compression is successful.\r
+  EFI_OUT_OF_RESOURCES  - No resource to complete function.\r
+  EFI_INVALID_PARAMETER - Parameter supplied is wrong.\r
+\r
+--*/\r
+typedef\r
+EFI_STATUS\r
+(*COMPRESS_FUNCTION) (\r
+  IN      UINT8   *SrcBuffer,\r
+  IN      UINT32  SrcSize,\r
+  IN      UINT8   *DstBuffer,\r
+  IN OUT  UINT32  *DstSize\r
+  );\r
+\r
+#endif\r
index 5b91b1d..87f52fd 100644 (file)
@@ -1,6 +1,6 @@
 /*++\r
 \r
-Copyright (c) 2004, Intel Corporation                                                         \r
+Copyright (c) 2006, Intel Corporation                                              \r
 All rights reserved. This program and the accompanying materials                          \r
 are licensed and made available under the terms and conditions of the BSD License         \r
 which accompanies this distribution.  The full text of the license may be found at        \r
@@ -23,248 +23,248 @@ Abstract:
 \r
 --*/\r
 \r
-#include "EfiCompress.h"\r
+#include "Compress.h"\r
+\r
 \r
 //\r
 // Macro Definitions\r
 //\r
-typedef INT32 NODE;\r
-#define UINT8_BIT     8\r
-#define THRESHOLD     3\r
-#define INIT_CRC      0\r
-#define WNDBIT        19\r
-#define WNDSIZ        (1U << WNDBIT)\r
-#define MAXMATCH      256\r
-#define BLKSIZ        (1U << 14)  // 16 * 1024U\r
-#define PERC_FLAG     0x80000000U\r
-#define CODE_BIT      16\r
-#define NIL           0\r
-#define MAX_HASH_VAL  (3 * WNDSIZ + (WNDSIZ / 512 + 1) * UINT8_MAX)\r
-#define HASH(p, c)    ((p) + ((c) << (WNDBIT - 9)) + WNDSIZ * 2)\r
-#define CRCPOLY       0xA001\r
-#define UPDATE_CRC(c) mCrc = mCrcTable[(mCrc ^ (c)) & 0xFF] ^ (mCrc >> UINT8_BIT)\r
+\r
+typedef INT16             NODE;\r
+#define UINT8_MAX         0xff\r
+#define UINT8_BIT         8\r
+#define THRESHOLD         3\r
+#define INIT_CRC          0\r
+#define WNDBIT            13\r
+#define WNDSIZ            (1U << WNDBIT)\r
+#define MAXMATCH          256\r
+#define PERC_FLAG         0x8000U\r
+#define CODE_BIT          16\r
+#define NIL               0\r
+#define MAX_HASH_VAL      (3 * WNDSIZ + (WNDSIZ / 512 + 1) * UINT8_MAX)\r
+#define HASH(p, c)        ((p) + ((c) << (WNDBIT - 9)) + WNDSIZ * 2)\r
+#define CRCPOLY           0xA001\r
+#define UPDATE_CRC(c)     mCrc = mCrcTable[(mCrc ^ (c)) & 0xFF] ^ (mCrc >> UINT8_BIT)\r
 \r
 //\r
 // C: the Char&Len Set; P: the Position Set; T: the exTra Set\r
 //\r
-#define NC    (UINT8_MAX + MAXMATCH + 2 - THRESHOLD)\r
-#define CBIT  9\r
-#define NP    (WNDBIT + 1)\r
-#define PBIT  5\r
-#define NT    (CODE_BIT + 3)\r
-#define TBIT  5\r
+\r
+#define NC                (UINT8_MAX + MAXMATCH + 2 - THRESHOLD)\r
+#define CBIT              9\r
+#define NP                (WNDBIT + 1)\r
+#define PBIT              4\r
+#define NT                (CODE_BIT + 3)\r
+#define TBIT              5\r
 #if NT > NP\r
-#define NPT NT\r
+  #define                 NPT NT\r
 #else\r
-#define NPT NP\r
+  #define                 NPT NP\r
 #endif\r
+\r
 //\r
 // Function Prototypes\r
 //\r
-STATIC VOID PutDword(IN UINT32 Data);\r
 \r
 STATIC\r
-EFI_STATUS\r
+VOID \r
+PutDword(\r
+  IN UINT32 Data\r
+  );\r
+\r
+STATIC\r
+EFI_STATUS \r
 AllocateMemory (\r
-  VOID\r
   );\r
 \r
 STATIC\r
 VOID\r
 FreeMemory (\r
-  VOID\r
   );\r
 \r
-STATIC\r
-VOID\r
+STATIC \r
+VOID \r
 InitSlide (\r
-  VOID\r
   );\r
 \r
-STATIC\r
-NODE\r
+STATIC \r
+NODE \r
 Child (\r
-  IN NODE   NodeQ,\r
-  IN UINT8  CharC\r
+  IN NODE q, \r
+  IN UINT8 c\r
   );\r
 \r
-STATIC\r
-VOID\r
+STATIC \r
+VOID \r
 MakeChild (\r
-  IN NODE  NodeQ,\r
-  IN UINT8 CharC,\r
-  IN NODE  NodeR\r
+  IN NODE q, \r
+  IN UINT8 c, \r
+  IN NODE r\r
   );\r
-\r
-STATIC\r
-VOID\r
+  \r
+STATIC \r
+VOID \r
 Split (\r
   IN NODE Old\r
   );\r
 \r
-STATIC\r
-VOID\r
+STATIC \r
+VOID \r
 InsertNode (\r
-  VOID\r
   );\r
-\r
-STATIC\r
-VOID\r
+  \r
+STATIC \r
+VOID \r
 DeleteNode (\r
-  VOID\r
   );\r
 \r
-STATIC\r
-VOID\r
+STATIC \r
+VOID \r
 GetNextMatch (\r
-  VOID\r
   );\r
-\r
-STATIC\r
-EFI_STATUS\r
+  \r
+STATIC \r
+EFI_STATUS \r
 Encode (\r
-  VOID\r
   );\r
 \r
-STATIC\r
-VOID\r
+STATIC \r
+VOID \r
 CountTFreq (\r
-  VOID\r
   );\r
 \r
-STATIC\r
-VOID\r
+STATIC \r
+VOID \r
 WritePTLen (\r
-  IN INT32 Number,\r
-  IN INT32 nbit,\r
+  IN INT32 n, \r
+  IN INT32 nbit, \r
   IN INT32 Special\r
   );\r
 \r
-STATIC\r
-VOID\r
+STATIC \r
+VOID \r
 WriteCLen (\r
-  VOID\r
   );\r
-\r
-STATIC\r
-VOID\r
+  \r
+STATIC \r
+VOID \r
 EncodeC (\r
-  IN INT32 Value\r
+  IN INT32 c\r
   );\r
 \r
-STATIC\r
-VOID\r
+STATIC \r
+VOID \r
 EncodeP (\r
-  IN UINT32 Value\r
+  IN UINT32 p\r
   );\r
 \r
-STATIC\r
-VOID\r
+STATIC \r
+VOID \r
 SendBlock (\r
-  VOID\r
   );\r
-\r
-STATIC\r
-VOID\r
+  \r
+STATIC \r
+VOID \r
 Output (\r
-  IN UINT32 c,\r
+  IN UINT32 c, \r
   IN UINT32 p\r
   );\r
 \r
-STATIC\r
-VOID\r
+STATIC \r
+VOID \r
 HufEncodeStart (\r
-  VOID\r
   );\r
-\r
-STATIC\r
-VOID\r
+  \r
+STATIC \r
+VOID \r
 HufEncodeEnd (\r
-  VOID\r
   );\r
-\r
-STATIC\r
-VOID\r
+  \r
+STATIC \r
+VOID \r
 MakeCrcTable (\r
-  VOID\r
   );\r
-\r
-STATIC\r
-VOID\r
+  \r
+STATIC \r
+VOID \r
 PutBits (\r
-  IN INT32  Number,\r
-  IN UINT32 Value\r
+  IN INT32 n, \r
+  IN UINT32 x\r
   );\r
-\r
-STATIC\r
-INT32\r
+  \r
+STATIC \r
+INT32 \r
 FreadCrc (\r
-  OUT UINT8 *Pointer,\r
-  IN  INT32 Number\r
+  OUT UINT8 *p, \r
+  IN  INT32 n\r
   );\r
-\r
-STATIC\r
-VOID\r
+  \r
+STATIC \r
+VOID \r
 InitPutBits (\r
-  VOID\r
   );\r
-\r
-STATIC\r
-VOID\r
+  \r
+STATIC \r
+VOID \r
 CountLen (\r
-  IN INT32 Index\r
+  IN INT32 i\r
   );\r
 \r
-STATIC\r
-VOID\r
+STATIC \r
+VOID \r
 MakeLen (\r
   IN INT32 Root\r
   );\r
-\r
-STATIC\r
-VOID\r
+  \r
+STATIC \r
+VOID \r
 DownHeap (\r
-  IN INT32 Index\r
+  IN INT32 i\r
   );\r
 \r
-STATIC\r
-VOID\r
+STATIC \r
+VOID \r
 MakeCode (\r
-  IN  INT32       Number,\r
-  IN  UINT8 Len[  ],\r
+  IN  INT32 n, \r
+  IN  UINT8 Len[], \r
   OUT UINT16 Code[]\r
   );\r
-\r
-STATIC\r
-INT32\r
+  \r
+STATIC \r
+INT32 \r
 MakeTree (\r
-  IN  INT32            NParm,\r
-  IN  UINT16  FreqParm[],\r
-  OUT UINT8   LenParm[ ],\r
+  IN  INT32   NParm, \r
+  IN  UINT16  FreqParm[], \r
+  OUT UINT8   LenParm[], \r
   OUT UINT16  CodeParm[]\r
   );\r
 \r
+\r
 //\r
 //  Global Variables\r
 //\r
-static UINT8  *mSrc, *mDst, *mSrcUpperLimit, *mDstUpperLimit;\r
 \r
-static UINT8  *mLevel, *mText, *mChildCount, *mBuf, mCLen[NC], mPTLen[NPT], *mLen;\r
-static INT16  mHeap[NC + 1];\r
-static INT32  mRemainder, mMatchLen, mBitCount, mHeapSize, mN;\r
-static UINT32 mBufSiz = 0, mOutputPos, mOutputMask, mSubBitBuf, mCrc;\r
-static UINT32 mCompSize, mOrigSize;\r
+STATIC UINT8  *mSrc, *mDst, *mSrcUpperLimit, *mDstUpperLimit;\r
+\r
+STATIC UINT8  *mLevel, *mText, *mChildCount, *mBuf, mCLen[NC], mPTLen[NPT], *mLen;\r
+STATIC INT16  mHeap[NC + 1];\r
+STATIC INT32  mRemainder, mMatchLen, mBitCount, mHeapSize, mN;\r
+STATIC UINT32 mBufSiz = 0, mOutputPos, mOutputMask, mSubBitBuf, mCrc;\r
+STATIC UINT32 mCompSize, mOrigSize;\r
 \r
-static UINT16 *mFreq, *mSortPtr, mLenCnt[17], mLeft[2 * NC - 1], mRight[2 * NC - 1], mCrcTable[UINT8_MAX + 1],\r
-  mCFreq[2 * NC - 1], mCTable[4096], mCCode[NC], mPFreq[2 * NP - 1], mPTCode[NPT], mTFreq[2 * NT - 1];\r
+STATIC UINT16 *mFreq, *mSortPtr, mLenCnt[17], mLeft[2 * NC - 1], mRight[2 * NC - 1],\r
+              mCrcTable[UINT8_MAX + 1], mCFreq[2 * NC - 1], mCTable[4096], mCCode[NC],\r
+              mPFreq[2 * NP - 1], mPTCode[NPT], mTFreq[2 * NT - 1];\r
+\r
+STATIC NODE   mPos, mMatchPos, mAvail, *mPosition, *mParent, *mPrev, *mNext = NULL;\r
 \r
-static NODE   mPos, mMatchPos, mAvail, *mPosition, *mParent, *mPrev, *mNext = NULL;\r
 \r
 //\r
 // functions\r
 //\r
+\r
 EFI_STATUS\r
-Compress (\r
+EfiCompress (\r
   IN      UINT8   *SrcBuffer,\r
   IN      UINT32  SrcSize,\r
   IN      UINT8   *DstBuffer,\r
@@ -289,61 +289,65 @@ Returns:
   EFI_BUFFER_TOO_SMALL  - The DstBuffer is too small. In this case,\r
                 DstSize contains the size needed.\r
   EFI_SUCCESS           - Compression is successful.\r
-  EFI_OUT_OF_RESOURCES  - No resource to complete function.\r
 \r
 --*/\r
 {\r
-  EFI_STATUS  Status;\r
-\r
+  EFI_STATUS Status = EFI_SUCCESS;\r
+  \r
   //\r
   // Initializations\r
   //\r
-  mBufSiz         = 0;\r
-  mBuf            = NULL;\r
-  mText           = NULL;\r
-  mLevel          = NULL;\r
-  mChildCount     = NULL;\r
-  mPosition       = NULL;\r
-  mParent         = NULL;\r
-  mPrev           = NULL;\r
-  mNext           = NULL;\r
-\r
-  mSrc            = SrcBuffer;\r
-  mSrcUpperLimit  = mSrc + SrcSize;\r
-  mDst            = DstBuffer;\r
-  mDstUpperLimit  = mDst +*DstSize;\r
-\r
-  PutDword (0L);\r
-  PutDword (0L);\r
+  mBufSiz = 0;\r
+  mBuf = NULL;\r
+  mText       = NULL;\r
+  mLevel      = NULL;\r
+  mChildCount = NULL;\r
+  mPosition   = NULL;\r
+  mParent     = NULL;\r
+  mPrev       = NULL;\r
+  mNext       = NULL;\r
 \r
-  MakeCrcTable ();\r
+  \r
+  mSrc = SrcBuffer;\r
+  mSrcUpperLimit = mSrc + SrcSize;\r
+  mDst = DstBuffer;\r
+  mDstUpperLimit = mDst + *DstSize;\r
 \r
-  mOrigSize             = mCompSize = 0;\r
-  mCrc                  = INIT_CRC;\r
+  PutDword(0L);\r
+  PutDword(0L);\r
+  \r
+  MakeCrcTable ();\r
 \r
+  mOrigSize = mCompSize = 0;\r
+  mCrc = INIT_CRC;\r
+  \r
   //\r
   // Compress it\r
   //\r
-  Status = Encode ();\r
+  \r
+  Status = Encode();\r
   if (EFI_ERROR (Status)) {\r
     return EFI_OUT_OF_RESOURCES;\r
   }\r
+  \r
   //\r
   // Null terminate the compressed data\r
   //\r
   if (mDst < mDstUpperLimit) {\r
     *mDst++ = 0;\r
   }\r
+  \r
   //\r
   // Fill in compressed size and original size\r
   //\r
   mDst = DstBuffer;\r
-  PutDword (mCompSize + 1);\r
-  PutDword (mOrigSize);\r
+  PutDword(mCompSize+1);\r
+  PutDword(mOrigSize);\r
 \r
   //\r
   // Return\r
   //\r
+  \r
   if (mCompSize + 1 + 8 > *DstSize) {\r
     *DstSize = mCompSize + 1 + 8;\r
     return EFI_BUFFER_TOO_SMALL;\r
@@ -354,9 +358,9 @@ Returns:
 \r
 }\r
 \r
-STATIC\r
-VOID\r
-PutDword (\r
+STATIC \r
+VOID \r
+PutDword(\r
   IN UINT32 Data\r
   )\r
 /*++\r
@@ -374,35 +378,32 @@ Returns: (VOID)
 --*/\r
 {\r
   if (mDst < mDstUpperLimit) {\r
-    *mDst++ = (UINT8) (((UINT8) (Data)) & 0xff);\r
+    *mDst++ = (UINT8)(((UINT8)(Data        )) & 0xff);\r
   }\r
 \r
   if (mDst < mDstUpperLimit) {\r
-    *mDst++ = (UINT8) (((UINT8) (Data >> 0x08)) & 0xff);\r
+    *mDst++ = (UINT8)(((UINT8)(Data >> 0x08)) & 0xff);\r
   }\r
 \r
   if (mDst < mDstUpperLimit) {\r
-    *mDst++ = (UINT8) (((UINT8) (Data >> 0x10)) & 0xff);\r
+    *mDst++ = (UINT8)(((UINT8)(Data >> 0x10)) & 0xff);\r
   }\r
 \r
   if (mDst < mDstUpperLimit) {\r
-    *mDst++ = (UINT8) (((UINT8) (Data >> 0x18)) & 0xff);\r
+    *mDst++ = (UINT8)(((UINT8)(Data >> 0x18)) & 0xff);\r
   }\r
 }\r
 \r
 STATIC\r
 EFI_STATUS\r
-AllocateMemory (\r
-  VOID\r
-  )\r
+AllocateMemory ()\r
 /*++\r
 \r
 Routine Description:\r
 \r
   Allocate memory spaces for data structures used in compression process\r
   \r
-Argements: \r
-  VOID\r
+Argements: (VOID)\r
 \r
 Returns:\r
 \r
@@ -411,40 +412,34 @@ Returns:
 \r
 --*/\r
 {\r
-  UINT32  Index;\r
-\r
-  mText = malloc (WNDSIZ * 2 + MAXMATCH);\r
-  for (Index = 0; Index < WNDSIZ * 2 + MAXMATCH; Index++) {\r
-    mText[Index] = 0;\r
+  UINT32      i;\r
+  \r
+  mText       = malloc (WNDSIZ * 2 + MAXMATCH);\r
+  for (i = 0 ; i < WNDSIZ * 2 + MAXMATCH; i ++) {\r
+    mText[i] = 0;\r
   }\r
 \r
-  mLevel      = malloc ((WNDSIZ + UINT8_MAX + 1) * sizeof (*mLevel));\r
-  mChildCount = malloc ((WNDSIZ + UINT8_MAX + 1) * sizeof (*mChildCount));\r
-  mPosition   = malloc ((WNDSIZ + UINT8_MAX + 1) * sizeof (*mPosition));\r
-  mParent     = malloc (WNDSIZ * 2 * sizeof (*mParent));\r
-  mPrev       = malloc (WNDSIZ * 2 * sizeof (*mPrev));\r
-  mNext       = malloc ((MAX_HASH_VAL + 1) * sizeof (*mNext));\r
-\r
-  mBufSiz     = BLKSIZ;\r
-  mBuf        = malloc (mBufSiz);\r
-  while (mBuf == NULL) {\r
+  mLevel      = malloc ((WNDSIZ + UINT8_MAX + 1) * sizeof(*mLevel));\r
+  mChildCount = malloc ((WNDSIZ + UINT8_MAX + 1) * sizeof(*mChildCount));\r
+  mPosition   = malloc ((WNDSIZ + UINT8_MAX + 1) * sizeof(*mPosition));\r
+  mParent     = malloc (WNDSIZ * 2 * sizeof(*mParent));\r
+  mPrev       = malloc (WNDSIZ * 2 * sizeof(*mPrev));\r
+  mNext       = malloc ((MAX_HASH_VAL + 1) * sizeof(*mNext));\r
+  \r
+  mBufSiz = 16 * 1024U;\r
+  while ((mBuf = malloc(mBufSiz)) == NULL) {\r
     mBufSiz = (mBufSiz / 10U) * 9U;\r
     if (mBufSiz < 4 * 1024U) {\r
       return EFI_OUT_OF_RESOURCES;\r
     }\r
-\r
-    mBuf = malloc (mBufSiz);\r
   }\r
-\r
   mBuf[0] = 0;\r
-\r
+  \r
   return EFI_SUCCESS;\r
 }\r
 \r
 VOID\r
-FreeMemory (\r
-  VOID\r
-  )\r
+FreeMemory ()\r
 /*++\r
 \r
 Routine Description:\r
@@ -457,46 +452,45 @@ Returns: (VOID)
 \r
 --*/\r
 {\r
-  if (mText != NULL) {\r
+  if (mText) {\r
     free (mText);\r
   }\r
-\r
-  if (mLevel != NULL) {\r
+  \r
+  if (mLevel) {\r
     free (mLevel);\r
   }\r
-\r
-  if (mChildCount != NULL) {\r
+  \r
+  if (mChildCount) {\r
     free (mChildCount);\r
   }\r
-\r
-  if (mPosition != NULL) {\r
+  \r
+  if (mPosition) {\r
     free (mPosition);\r
   }\r
-\r
-  if (mParent != NULL) {\r
+  \r
+  if (mParent) {\r
     free (mParent);\r
   }\r
-\r
-  if (mPrev != NULL) {\r
+  \r
+  if (mPrev) {\r
     free (mPrev);\r
   }\r
-\r
-  if (mNext != NULL) {\r
+  \r
+  if (mNext) {\r
     free (mNext);\r
   }\r
-\r
-  if (mBuf != NULL) {\r
+  \r
+  if (mBuf) {\r
     free (mBuf);\r
-  }\r
+  }  \r
 \r
-  return ;\r
+  return;\r
 }\r
 \r
-STATIC\r
-VOID\r
-InitSlide (\r
-  VOID\r
-  )\r
+\r
+STATIC \r
+VOID \r
+InitSlide ()\r
 /*++\r
 \r
 Routine Description:\r
@@ -509,33 +503,32 @@ Returns: (VOID)
 \r
 --*/\r
 {\r
-  NODE  Index;\r
+  NODE i;\r
 \r
-  for (Index = WNDSIZ; Index <= WNDSIZ + UINT8_MAX; Index++) {\r
-    mLevel[Index]     = 1;\r
-    mPosition[Index]  = NIL;  /* sentinel */\r
+  for (i = WNDSIZ; i <= WNDSIZ + UINT8_MAX; i++) {\r
+    mLevel[i] = 1;\r
+    mPosition[i] = NIL;  /* sentinel */\r
   }\r
-\r
-  for (Index = WNDSIZ; Index < WNDSIZ * 2; Index++) {\r
-    mParent[Index] = NIL;\r
-  }\r
-\r
+  for (i = WNDSIZ; i < WNDSIZ * 2; i++) {\r
+    mParent[i] = NIL;\r
+  }  \r
   mAvail = 1;\r
-  for (Index = 1; Index < WNDSIZ - 1; Index++) {\r
-    mNext[Index] = (NODE) (Index + 1);\r
+  for (i = 1; i < WNDSIZ - 1; i++) {\r
+    mNext[i] = (NODE)(i + 1);\r
   }\r
-\r
+  \r
   mNext[WNDSIZ - 1] = NIL;\r
-  for (Index = WNDSIZ * 2; Index <= MAX_HASH_VAL; Index++) {\r
-    mNext[Index] = NIL;\r
-  }\r
+  for (i = WNDSIZ * 2; i <= MAX_HASH_VAL; i++) {\r
+    mNext[i] = NIL;\r
+  }  \r
 }\r
 \r
-STATIC\r
-NODE\r
+\r
+STATIC \r
+NODE \r
 Child (\r
-  IN NODE  NodeQ,\r
-  IN UINT8 CharC\r
+  IN NODE q, \r
+  IN UINT8 c\r
   )\r
 /*++\r
 \r
@@ -545,8 +538,8 @@ Routine Description:
   \r
 Arguments:\r
 \r
-  NodeQ       - the parent node\r
-  CharC       - the edge character\r
+  q       - the parent node\r
+  c       - the edge character\r
   \r
 Returns:\r
 \r
@@ -554,26 +547,23 @@ Returns:
   \r
 --*/\r
 {\r
-  NODE  NodeR;\r
-\r
-  NodeR = mNext[HASH (NodeQ, CharC)];\r
-  //\r
-  // sentinel\r
-  //\r
-  mParent[NIL] = NodeQ;\r
-  while (mParent[NodeR] != NodeQ) {\r
-    NodeR = mNext[NodeR];\r
+  NODE r;\r
+  \r
+  r = mNext[HASH(q, c)];\r
+  mParent[NIL] = q;  /* sentinel */\r
+  while (mParent[r] != q) {\r
+    r = mNext[r];\r
   }\r
-\r
-  return NodeR;\r
+  \r
+  return r;\r
 }\r
 \r
-STATIC\r
-VOID\r
+STATIC \r
+VOID \r
 MakeChild (\r
-  IN NODE  Parent,\r
-  IN UINT8 CharC,\r
-  IN NODE  Child\r
+  IN NODE q, \r
+  IN UINT8 c, \r
+  IN NODE r\r
   )\r
 /*++\r
 \r
@@ -583,29 +573,28 @@ Routine Description:
   \r
 Arguments:\r
 \r
-  Parent       - the parent node\r
-  CharC   - the edge character\r
-  Child       - the child node\r
+  q       - the parent node\r
+  c       - the edge character\r
+  r       - the child node\r
   \r
 Returns: (VOID)\r
 \r
 --*/\r
 {\r
-  NODE  Node1;\r
-  NODE  Node2;\r
-\r
-  Node1           = (NODE) HASH (Parent, CharC);\r
-  Node2           = mNext[Node1];\r
-  mNext[Node1]    = Child;\r
-  mNext[Child]    = Node2;\r
-  mPrev[Node2]    = Child;\r
-  mPrev[Child]    = Node1;\r
-  mParent[Child]  = Parent;\r
-  mChildCount[Parent]++;\r
+  NODE h, t;\r
+  \r
+  h = (NODE)HASH(q, c);\r
+  t = mNext[h];\r
+  mNext[h] = r;\r
+  mNext[r] = t;\r
+  mPrev[t] = r;\r
+  mPrev[r] = h;\r
+  mParent[r] = q;\r
+  mChildCount[q]++;\r
 }\r
 \r
-STATIC\r
-VOID\r
+STATIC \r
+VOID \r
 Split (\r
   NODE Old\r
   )\r
@@ -623,30 +612,27 @@ Returns: (VOID)
 \r
 --*/\r
 {\r
-  NODE  New;\r
-  NODE  TempNode;\r
-\r
-  New               = mAvail;\r
-  mAvail            = mNext[New];\r
-  mChildCount[New]  = 0;\r
-  TempNode          = mPrev[Old];\r
-  mPrev[New]        = TempNode;\r
-  mNext[TempNode]   = New;\r
-  TempNode          = mNext[Old];\r
-  mNext[New]        = TempNode;\r
-  mPrev[TempNode]   = New;\r
-  mParent[New]      = mParent[Old];\r
-  mLevel[New]       = (UINT8) mMatchLen;\r
-  mPosition[New]    = mPos;\r
-  MakeChild (New, mText[mMatchPos + mMatchLen], Old);\r
-  MakeChild (New, mText[mPos + mMatchLen], mPos);\r
+  NODE New, t;\r
+\r
+  New = mAvail;\r
+  mAvail = mNext[New];\r
+  mChildCount[New] = 0;\r
+  t = mPrev[Old];\r
+  mPrev[New] = t;\r
+  mNext[t] = New;\r
+  t = mNext[Old];\r
+  mNext[New] = t;\r
+  mPrev[t] = New;\r
+  mParent[New] = mParent[Old];\r
+  mLevel[New] = (UINT8)mMatchLen;\r
+  mPosition[New] = mPos;\r
+  MakeChild(New, mText[mMatchPos + mMatchLen], Old);\r
+  MakeChild(New, mText[mPos + mMatchLen], mPos);\r
 }\r
 \r
-STATIC\r
-VOID\r
-InsertNode (\r
-  VOID\r
-  )\r
+STATIC \r
+VOID \r
+InsertNode ()\r
 /*++\r
 \r
 Routine Description:\r
@@ -659,15 +645,11 @@ Returns: (VOID)
 \r
 --*/\r
 {\r
-  NODE  NodeQ;\r
-  NODE  NodeR;\r
-  NODE  Index2;\r
-  NODE  NodeT;\r
-  UINT8 CharC;\r
-  UINT8 *t1;\r
-  UINT8 *t2;\r
+  NODE q, r, j, t;\r
+  UINT8 c, *t1, *t2;\r
 \r
   if (mMatchLen >= 4) {\r
+    \r
     //\r
     // We have just got a long match, the target tree\r
     // can be located by MatchPos + 1. Travese the tree\r
@@ -675,110 +657,97 @@ Returns: (VOID)
     // The usage of PERC_FLAG ensures proper node deletion\r
     // in DeleteNode() later.\r
     //\r
+    \r
     mMatchLen--;\r
-    NodeR = (NODE) ((mMatchPos + 1) | WNDSIZ);\r
-    NodeQ = mParent[NodeR];\r
-    while (NodeQ == NIL) {\r
-      NodeR = mNext[NodeR];\r
-      NodeQ = mParent[NodeR];\r
+    r = (INT16)((mMatchPos + 1) | WNDSIZ);\r
+    while ((q = mParent[r]) == NIL) {\r
+      r = mNext[r];\r
     }\r
-\r
-    while (mLevel[NodeQ] >= mMatchLen) {\r
-      NodeR = NodeQ;\r
-      NodeQ = mParent[NodeQ];\r
+    while (mLevel[q] >= mMatchLen) {\r
+      r = q;  q = mParent[q];\r
     }\r
-\r
-    NodeT = NodeQ;\r
-    while (mPosition[NodeT] < 0) {\r
-      mPosition[NodeT]  = mPos;\r
-      NodeT             = mParent[NodeT];\r
-    }\r
-\r
-    if (NodeT < WNDSIZ) {\r
-      mPosition[NodeT] = (NODE) (mPos | (UINT32) PERC_FLAG);\r
+    t = q;\r
+    while (mPosition[t] < 0) {\r
+      mPosition[t] = mPos;\r
+      t = mParent[t];\r
     }\r
+    if (t < WNDSIZ) {\r
+      mPosition[t] = (NODE)(mPos | PERC_FLAG);\r
+    }    \r
   } else {\r
+    \r
     //\r
     // Locate the target tree\r
     //\r
-    NodeQ = (NODE) (mText[mPos] + WNDSIZ);\r
-    CharC = mText[mPos + 1];\r
-    NodeR = Child (NodeQ, CharC);\r
-    if (NodeR == NIL) {\r
-      MakeChild (NodeQ, CharC, mPos);\r
+    \r
+    q = (INT16)(mText[mPos] + WNDSIZ);\r
+    c = mText[mPos + 1];\r
+    if ((r = Child(q, c)) == NIL) {\r
+      MakeChild(q, c, mPos);\r
       mMatchLen = 1;\r
-      return ;\r
+      return;\r
     }\r
-\r
     mMatchLen = 2;\r
   }\r
+  \r
   //\r
   // Traverse down the tree to find a match.\r
   // Update Position value along the route.\r
   // Node split or creation is involved.\r
   //\r
-  for (;;) {\r
-    if (NodeR >= WNDSIZ) {\r
-      Index2    = MAXMATCH;\r
-      mMatchPos = NodeR;\r
+  \r
+  for ( ; ; ) {\r
+    if (r >= WNDSIZ) {\r
+      j = MAXMATCH;\r
+      mMatchPos = r;\r
     } else {\r
-      Index2    = mLevel[NodeR];\r
-      mMatchPos = (NODE) (mPosition[NodeR] & (UINT32)~PERC_FLAG);\r
+      j = mLevel[r];\r
+      mMatchPos = (NODE)(mPosition[r] & ~PERC_FLAG);\r
     }\r
-\r
     if (mMatchPos >= mPos) {\r
       mMatchPos -= WNDSIZ;\r
-    }\r
-\r
-    t1  = &mText[mPos + mMatchLen];\r
-    t2  = &mText[mMatchPos + mMatchLen];\r
-    while (mMatchLen < Index2) {\r
+    }    \r
+    t1 = &mText[mPos + mMatchLen];\r
+    t2 = &mText[mMatchPos + mMatchLen];\r
+    while (mMatchLen < j) {\r
       if (*t1 != *t2) {\r
-        Split (NodeR);\r
-        return ;\r
+        Split(r);\r
+        return;\r
       }\r
-\r
       mMatchLen++;\r
       t1++;\r
       t2++;\r
     }\r
-\r
     if (mMatchLen >= MAXMATCH) {\r
       break;\r
     }\r
-\r
-    mPosition[NodeR]  = mPos;\r
-    NodeQ             = NodeR;\r
-    NodeR             = Child (NodeQ, *t1);\r
-    if (NodeR == NIL) {\r
-      MakeChild (NodeQ, *t1, mPos);\r
-      return ;\r
+    mPosition[r] = mPos;\r
+    q = r;\r
+    if ((r = Child(q, *t1)) == NIL) {\r
+      MakeChild(q, *t1, mPos);\r
+      return;\r
     }\r
-\r
     mMatchLen++;\r
   }\r
-\r
-  NodeT           = mPrev[NodeR];\r
-  mPrev[mPos]     = NodeT;\r
-  mNext[NodeT]    = mPos;\r
-  NodeT           = mNext[NodeR];\r
-  mNext[mPos]     = NodeT;\r
-  mPrev[NodeT]    = mPos;\r
-  mParent[mPos]   = NodeQ;\r
-  mParent[NodeR]  = NIL;\r
-\r
+  t = mPrev[r];\r
+  mPrev[mPos] = t;\r
+  mNext[t] = mPos;\r
+  t = mNext[r];\r
+  mNext[mPos] = t;\r
+  mPrev[t] = mPos;\r
+  mParent[mPos] = q;\r
+  mParent[r] = NIL;\r
+  \r
   //\r
   // Special usage of 'next'\r
   //\r
-  mNext[NodeR] = mPos;\r
-\r
+  mNext[r] = mPos;\r
+  \r
 }\r
 \r
-STATIC\r
-VOID\r
-DeleteNode (\r
-  VOID\r
-  )\r
+STATIC \r
+VOID \r
+DeleteNode ()\r
 /*++\r
 \r
 Routine Description:\r
@@ -792,88 +761,67 @@ Returns: (VOID)
 \r
 --*/\r
 {\r
-  NODE  NodeQ;\r
-  NODE  NodeR;\r
-  NODE  NodeS;\r
-  NODE  NodeT;\r
-  NODE  NodeU;\r
+  NODE q, r, s, t, u;\r
 \r
   if (mParent[mPos] == NIL) {\r
-    return ;\r
+    return;\r
   }\r
-\r
-  NodeR         = mPrev[mPos];\r
-  NodeS         = mNext[mPos];\r
-  mNext[NodeR]  = NodeS;\r
-  mPrev[NodeS]  = NodeR;\r
-  NodeR         = mParent[mPos];\r
+  \r
+  r = mPrev[mPos];\r
+  s = mNext[mPos];\r
+  mNext[r] = s;\r
+  mPrev[s] = r;\r
+  r = mParent[mPos];\r
   mParent[mPos] = NIL;\r
-  if (NodeR >= WNDSIZ) {\r
-    return ;\r
-  }\r
-\r
-  mChildCount[NodeR]--;\r
-  if (mChildCount[NodeR] > 1) {\r
-    return ;\r
-  }\r
-\r
-  NodeT = (NODE) (mPosition[NodeR] & (UINT32)~PERC_FLAG);\r
-  if (NodeT >= mPos) {\r
-    NodeT -= WNDSIZ;\r
-  }\r
-\r
-  NodeS = NodeT;\r
-  NodeQ = mParent[NodeR];\r
-  NodeU = mPosition[NodeQ];\r
-  while (NodeU & (UINT32) PERC_FLAG) {\r
-    NodeU &= (UINT32)~PERC_FLAG;\r
-    if (NodeU >= mPos) {\r
-      NodeU -= WNDSIZ;\r
+  if (r >= WNDSIZ || --mChildCount[r] > 1) {\r
+    return;\r
+  }\r
+  t = (NODE)(mPosition[r] & ~PERC_FLAG);\r
+  if (t >= mPos) {\r
+    t -= WNDSIZ;\r
+  }\r
+  s = t;\r
+  q = mParent[r];\r
+  while ((u = mPosition[q]) & PERC_FLAG) {\r
+    u &= ~PERC_FLAG;\r
+    if (u >= mPos) {\r
+      u -= WNDSIZ;\r
     }\r
-\r
-    if (NodeU > NodeS) {\r
-      NodeS = NodeU;\r
+    if (u > s) {\r
+      s = u;\r
     }\r
-\r
-    mPosition[NodeQ]  = (NODE) (NodeS | WNDSIZ);\r
-    NodeQ             = mParent[NodeQ];\r
-    NodeU             = mPosition[NodeQ];\r
+    mPosition[q] = (INT16)(s | WNDSIZ);\r
+    q = mParent[q];\r
   }\r
-\r
-  if (NodeQ < WNDSIZ) {\r
-    if (NodeU >= mPos) {\r
-      NodeU -= WNDSIZ;\r
+  if (q < WNDSIZ) {\r
+    if (u >= mPos) {\r
+      u -= WNDSIZ;\r
     }\r
-\r
-    if (NodeU > NodeS) {\r
-      NodeS = NodeU;\r
+    if (u > s) {\r
+      s = u;\r
     }\r
-\r
-    mPosition[NodeQ] = (NODE) (NodeS | WNDSIZ | (UINT32) PERC_FLAG);\r
-  }\r
-\r
-  NodeS           = Child (NodeR, mText[NodeT + mLevel[NodeR]]);\r
-  NodeT           = mPrev[NodeS];\r
-  NodeU           = mNext[NodeS];\r
-  mNext[NodeT]    = NodeU;\r
-  mPrev[NodeU]    = NodeT;\r
-  NodeT           = mPrev[NodeR];\r
-  mNext[NodeT]    = NodeS;\r
-  mPrev[NodeS]    = NodeT;\r
-  NodeT           = mNext[NodeR];\r
-  mPrev[NodeT]    = NodeS;\r
-  mNext[NodeS]    = NodeT;\r
-  mParent[NodeS]  = mParent[NodeR];\r
-  mParent[NodeR]  = NIL;\r
-  mNext[NodeR]    = mAvail;\r
-  mAvail          = NodeR;\r
+    mPosition[q] = (INT16)(s | WNDSIZ | PERC_FLAG);\r
+  }\r
+  s = Child(r, mText[t + mLevel[r]]);\r
+  t = mPrev[s];\r
+  u = mNext[s];\r
+  mNext[t] = u;\r
+  mPrev[u] = t;\r
+  t = mPrev[r];\r
+  mNext[t] = s;\r
+  mPrev[s] = t;\r
+  t = mNext[r];\r
+  mPrev[t] = s;\r
+  mNext[s] = t;\r
+  mParent[s] = mParent[r];\r
+  mParent[r] = NIL;\r
+  mNext[r] = mAvail;\r
+  mAvail = r;\r
 }\r
 \r
-STATIC\r
-VOID\r
-GetNextMatch (\r
-  VOID\r
-  )\r
+STATIC \r
+VOID \r
+GetNextMatch ()\r
 /*++\r
 \r
 Routine Description:\r
@@ -887,26 +835,22 @@ Returns: (VOID)
 \r
 --*/\r
 {\r
-  INT32 Number;\r
+  INT32 n;\r
 \r
   mRemainder--;\r
-  mPos++;\r
-  if (mPos == WNDSIZ * 2) {\r
-    memmove (&mText[0], &mText[WNDSIZ], WNDSIZ + MAXMATCH);\r
-    Number = FreadCrc (&mText[WNDSIZ + MAXMATCH], WNDSIZ);\r
-    mRemainder += Number;\r
+  if (++mPos == WNDSIZ * 2) {\r
+    memmove(&mText[0], &mText[WNDSIZ], WNDSIZ + MAXMATCH);\r
+    n = FreadCrc(&mText[WNDSIZ + MAXMATCH], WNDSIZ);\r
+    mRemainder += n;\r
     mPos = WNDSIZ;\r
   }\r
-\r
-  DeleteNode ();\r
-  InsertNode ();\r
+  DeleteNode();\r
+  InsertNode();\r
 }\r
 \r
 STATIC\r
 EFI_STATUS\r
-Encode (\r
-  VOID\r
-  )\r
+Encode ()\r
 /*++\r
 \r
 Routine Description:\r
@@ -926,77 +870,65 @@ Returns:
   INT32       LastMatchLen;\r
   NODE        LastMatchPos;\r
 \r
-  Status = AllocateMemory ();\r
-  if (EFI_ERROR (Status)) {\r
-    FreeMemory ();\r
+  Status = AllocateMemory();\r
+  if (EFI_ERROR(Status)) {\r
+    FreeMemory();\r
     return Status;\r
   }\r
 \r
-  InitSlide ();\r
-\r
-  HufEncodeStart ();\r
-\r
-  mRemainder  = FreadCrc (&mText[WNDSIZ], WNDSIZ + MAXMATCH);\r
+  InitSlide();\r
+  \r
+  HufEncodeStart();\r
 \r
-  mMatchLen   = 0;\r
-  mPos        = WNDSIZ;\r
-  InsertNode ();\r
+  mRemainder = FreadCrc(&mText[WNDSIZ], WNDSIZ + MAXMATCH);\r
+  \r
+  mMatchLen = 0;\r
+  mPos = WNDSIZ;\r
+  InsertNode();\r
   if (mMatchLen > mRemainder) {\r
     mMatchLen = mRemainder;\r
   }\r
-\r
   while (mRemainder > 0) {\r
-    LastMatchLen  = mMatchLen;\r
-    LastMatchPos  = mMatchPos;\r
-    GetNextMatch ();\r
+    LastMatchLen = mMatchLen;\r
+    LastMatchPos = mMatchPos;\r
+    GetNextMatch();\r
     if (mMatchLen > mRemainder) {\r
       mMatchLen = mRemainder;\r
     }\r
-\r
+    \r
     if (mMatchLen > LastMatchLen || LastMatchLen < THRESHOLD) {\r
+      \r
       //\r
       // Not enough benefits are gained by outputting a pointer,\r
       // so just output the original character\r
       //\r
-      Output (mText[mPos - 1], 0);\r
-\r
+      \r
+      Output(mText[mPos - 1], 0);\r
     } else {\r
-\r
-      if (LastMatchLen == THRESHOLD) {\r
-        if (((mPos - LastMatchPos - 2) & (WNDSIZ - 1)) > (1U << 11)) {\r
-          Output (mText[mPos - 1], 0);\r
-          continue;\r
-        }\r
-      }\r
+      \r
       //\r
       // Outputting a pointer is beneficial enough, do it.\r
       //\r
-      Output (\r
-        LastMatchLen + (UINT8_MAX + 1 - THRESHOLD),\r
-        (mPos - LastMatchPos - 2) & (WNDSIZ - 1)\r
-        );\r
-      LastMatchLen--;\r
-      while (LastMatchLen > 0) {\r
-        GetNextMatch ();\r
-        LastMatchLen--;\r
+      \r
+      Output(LastMatchLen + (UINT8_MAX + 1 - THRESHOLD),\r
+             (mPos - LastMatchPos - 2) & (WNDSIZ - 1));\r
+      while (--LastMatchLen > 0) {\r
+        GetNextMatch();\r
       }\r
-\r
       if (mMatchLen > mRemainder) {\r
         mMatchLen = mRemainder;\r
       }\r
     }\r
   }\r
-\r
-  HufEncodeEnd ();\r
-  FreeMemory ();\r
+  \r
+  HufEncodeEnd();\r
+  FreeMemory();\r
   return EFI_SUCCESS;\r
 }\r
 \r
-STATIC\r
-VOID\r
-CountTFreq (\r
-  VOID\r
-  )\r
+STATIC \r
+VOID \r
+CountTFreq ()\r
 /*++\r
 \r
 Routine Description:\r
@@ -1009,32 +941,26 @@ Returns: (VOID)
 \r
 --*/\r
 {\r
-  INT32 Index;\r
-  INT32 Index3;\r
-  INT32 Number;\r
-  INT32 Count;\r
+  INT32 i, k, n, Count;\r
 \r
-  for (Index = 0; Index < NT; Index++) {\r
-    mTFreq[Index] = 0;\r
+  for (i = 0; i < NT; i++) {\r
+    mTFreq[i] = 0;\r
   }\r
-\r
-  Number = NC;\r
-  while (Number > 0 && mCLen[Number - 1] == 0) {\r
-    Number--;\r
+  n = NC;\r
+  while (n > 0 && mCLen[n - 1] == 0) {\r
+    n--;\r
   }\r
-\r
-  Index = 0;\r
-  while (Index < Number) {\r
-    Index3 = mCLen[Index++];\r
-    if (Index3 == 0) {\r
+  i = 0;\r
+  while (i < n) {\r
+    k = mCLen[i++];\r
+    if (k == 0) {\r
       Count = 1;\r
-      while (Index < Number && mCLen[Index] == 0) {\r
-        Index++;\r
+      while (i < n && mCLen[i] == 0) {\r
+        i++;\r
         Count++;\r
       }\r
-\r
       if (Count <= 2) {\r
-        mTFreq[0] = (UINT16) (mTFreq[0] + Count);\r
+        mTFreq[0] = (UINT16)(mTFreq[0] + Count);\r
       } else if (Count <= 18) {\r
         mTFreq[1]++;\r
       } else if (Count == 19) {\r
@@ -1044,16 +970,16 @@ Returns: (VOID)
         mTFreq[2]++;\r
       }\r
     } else {\r
-      mTFreq[Index3 + 2]++;\r
+      mTFreq[k + 2]++;\r
     }\r
   }\r
 }\r
 \r
-STATIC\r
-VOID\r
+STATIC \r
+VOID \r
 WritePTLen (\r
-  IN INT32 Number,\r
-  IN INT32 nbit,\r
+  IN INT32 n, \r
+  IN INT32 nbit, \r
   IN INT32 Special\r
   )\r
 /*++\r
@@ -1064,7 +990,7 @@ Routine Description:
   \r
 Arguments:\r
 \r
-  Number       - the number of symbols\r
+  n       - the number of symbols\r
   nbit    - the number of bits needed to represent 'n'\r
   Special - the special symbol that needs to be take care of\r
   \r
@@ -1072,38 +998,32 @@ Returns: (VOID)
 \r
 --*/\r
 {\r
-  INT32 Index;\r
-  INT32 Index3;\r
+  INT32 i, k;\r
 \r
-  while (Number > 0 && mPTLen[Number - 1] == 0) {\r
-    Number--;\r
+  while (n > 0 && mPTLen[n - 1] == 0) {\r
+    n--;\r
   }\r
-\r
-  PutBits (nbit, Number);\r
-  Index = 0;\r
-  while (Index < Number) {\r
-    Index3 = mPTLen[Index++];\r
-    if (Index3 <= 6) {\r
-      PutBits (3, Index3);\r
+  PutBits(nbit, n);\r
+  i = 0;\r
+  while (i < n) {\r
+    k = mPTLen[i++];\r
+    if (k <= 6) {\r
+      PutBits(3, k);\r
     } else {\r
-      PutBits (Index3 - 3, (1U << (Index3 - 3)) - 2);\r
+      PutBits(k - 3, (1U << (k - 3)) - 2);\r
     }\r
-\r
-    if (Index == Special) {\r
-      while (Index < 6 && mPTLen[Index] == 0) {\r
-        Index++;\r
+    if (i == Special) {\r
+      while (i < 6 && mPTLen[i] == 0) {\r
+        i++;\r
       }\r
-\r
-      PutBits (2, (Index - 3) & 3);\r
+      PutBits(2, (i - 3) & 3);\r
     }\r
   }\r
 }\r
 \r
-STATIC\r
-VOID\r
-WriteCLen (\r
-  VOID\r
-  )\r
+STATIC \r
+VOID \r
+WriteCLen ()\r
 /*++\r
 \r
 Routine Description:\r
@@ -1116,172 +1036,146 @@ Returns: (VOID)
 \r
 --*/\r
 {\r
-  INT32 Index;\r
-  INT32 Index3;\r
-  INT32 Number;\r
-  INT32 Count;\r
-\r
-  Number = NC;\r
-  while (Number > 0 && mCLen[Number - 1] == 0) {\r
-    Number--;\r
-  }\r
+  INT32 i, k, n, Count;\r
 \r
-  PutBits (CBIT, Number);\r
-  Index = 0;\r
-  while (Index < Number) {\r
-    Index3 = mCLen[Index++];\r
-    if (Index3 == 0) {\r
+  n = NC;\r
+  while (n > 0 && mCLen[n - 1] == 0) {\r
+    n--;\r
+  }\r
+  PutBits(CBIT, n);\r
+  i = 0;\r
+  while (i < n) {\r
+    k = mCLen[i++];\r
+    if (k == 0) {\r
       Count = 1;\r
-      while (Index < Number && mCLen[Index] == 0) {\r
-        Index++;\r
+      while (i < n && mCLen[i] == 0) {\r
+        i++;\r
         Count++;\r
       }\r
-\r
       if (Count <= 2) {\r
-        for (Index3 = 0; Index3 < Count; Index3++) {\r
-          PutBits (mPTLen[0], mPTCode[0]);\r
+        for (k = 0; k < Count; k++) {\r
+          PutBits(mPTLen[0], mPTCode[0]);\r
         }\r
       } else if (Count <= 18) {\r
-        PutBits (mPTLen[1], mPTCode[1]);\r
-        PutBits (4, Count - 3);\r
+        PutBits(mPTLen[1], mPTCode[1]);\r
+        PutBits(4, Count - 3);\r
       } else if (Count == 19) {\r
-        PutBits (mPTLen[0], mPTCode[0]);\r
-        PutBits (mPTLen[1], mPTCode[1]);\r
-        PutBits (4, 15);\r
+        PutBits(mPTLen[0], mPTCode[0]);\r
+        PutBits(mPTLen[1], mPTCode[1]);\r
+        PutBits(4, 15);\r
       } else {\r
-        PutBits (mPTLen[2], mPTCode[2]);\r
-        PutBits (CBIT, Count - 20);\r
+        PutBits(mPTLen[2], mPTCode[2]);\r
+        PutBits(CBIT, Count - 20);\r
       }\r
     } else {\r
-      PutBits (mPTLen[Index3 + 2], mPTCode[Index3 + 2]);\r
+      PutBits(mPTLen[k + 2], mPTCode[k + 2]);\r
     }\r
   }\r
 }\r
 \r
-STATIC\r
-VOID\r
+STATIC \r
+VOID \r
 EncodeC (\r
-  IN INT32 Value\r
+  IN INT32 c\r
   )\r
 {\r
-  PutBits (mCLen[Value], mCCode[Value]);\r
+  PutBits(mCLen[c], mCCode[c]);\r
 }\r
 \r
-STATIC\r
-VOID\r
+STATIC \r
+VOID \r
 EncodeP (\r
-  IN UINT32 Value\r
+  IN UINT32 p\r
   )\r
 {\r
-  UINT32  Index;\r
-  UINT32  NodeQ;\r
-\r
-  Index = 0;\r
-  NodeQ = Value;\r
-  while (NodeQ) {\r
-    NodeQ >>= 1;\r
-    Index++;\r
-  }\r
+  UINT32 c, q;\r
 \r
-  PutBits (mPTLen[Index], mPTCode[Index]);\r
-  if (Index > 1) {\r
-    PutBits (Index - 1, Value & (0xFFFFFFFFU >> (32 - Index + 1)));\r
+  c = 0;\r
+  q = p;\r
+  while (q) {\r
+    q >>= 1;\r
+    c++;\r
+  }\r
+  PutBits(mPTLen[c], mPTCode[c]);\r
+  if (c > 1) {\r
+    PutBits(c - 1, p & (0xFFFFU >> (17 - c)));\r
   }\r
 }\r
 \r
-STATIC\r
-VOID\r
-SendBlock (\r
-  VOID\r
-  )\r
+STATIC \r
+VOID \r
+SendBlock ()\r
 /*++\r
 \r
 Routine Description:\r
 \r
   Huffman code the block and output it.\r
   \r
-Arguments: \r
-  (VOID)\r
+Argument: (VOID)\r
 \r
-Returns: \r
-  (VOID)\r
+Returns: (VOID)\r
 \r
 --*/\r
 {\r
-  UINT32  Index;\r
-  UINT32  Index2;\r
-  UINT32  Index3;\r
-  UINT32  Flags;\r
-  UINT32  Root;\r
-  UINT32  Pos;\r
-  UINT32  Size;\r
+  UINT32 i, k, Flags, Root, Pos, Size;\r
   Flags = 0;\r
 \r
-  Root  = MakeTree (NC, mCFreq, mCLen, mCCode);\r
-  Size  = mCFreq[Root];\r
-  PutBits (16, Size);\r
+  Root = MakeTree(NC, mCFreq, mCLen, mCCode);\r
+  Size = mCFreq[Root];\r
+  PutBits(16, Size);\r
   if (Root >= NC) {\r
-    CountTFreq ();\r
-    Root = MakeTree (NT, mTFreq, mPTLen, mPTCode);\r
+    CountTFreq();\r
+    Root = MakeTree(NT, mTFreq, mPTLen, mPTCode);\r
     if (Root >= NT) {\r
-      WritePTLen (NT, TBIT, 3);\r
+      WritePTLen(NT, TBIT, 3);\r
     } else {\r
-      PutBits (TBIT, 0);\r
-      PutBits (TBIT, Root);\r
+      PutBits(TBIT, 0);\r
+      PutBits(TBIT, Root);\r
     }\r
-\r
-    WriteCLen ();\r
+    WriteCLen();\r
   } else {\r
-    PutBits (TBIT, 0);\r
-    PutBits (TBIT, 0);\r
-    PutBits (CBIT, 0);\r
-    PutBits (CBIT, Root);\r
+    PutBits(TBIT, 0);\r
+    PutBits(TBIT, 0);\r
+    PutBits(CBIT, 0);\r
+    PutBits(CBIT, Root);\r
   }\r
-\r
-  Root = MakeTree (NP, mPFreq, mPTLen, mPTCode);\r
+  Root = MakeTree(NP, mPFreq, mPTLen, mPTCode);\r
   if (Root >= NP) {\r
-    WritePTLen (NP, PBIT, -1);\r
+    WritePTLen(NP, PBIT, -1);\r
   } else {\r
-    PutBits (PBIT, 0);\r
-    PutBits (PBIT, Root);\r
+    PutBits(PBIT, 0);\r
+    PutBits(PBIT, Root);\r
   }\r
-\r
   Pos = 0;\r
-  for (Index = 0; Index < Size; Index++) {\r
-    if (Index % UINT8_BIT == 0) {\r
+  for (i = 0; i < Size; i++) {\r
+    if (i % UINT8_BIT == 0) {\r
       Flags = mBuf[Pos++];\r
     } else {\r
       Flags <<= 1;\r
     }\r
-\r
     if (Flags & (1U << (UINT8_BIT - 1))) {\r
-      EncodeC (mBuf[Pos++] + (1U << UINT8_BIT));\r
-      Index3 = mBuf[Pos++];\r
-      for (Index2 = 0; Index2 < 3; Index2++) {\r
-        Index3 <<= UINT8_BIT;\r
-        Index3 += mBuf[Pos++];\r
-      }\r
-\r
-      EncodeP (Index3);\r
+      EncodeC(mBuf[Pos++] + (1U << UINT8_BIT));\r
+      k = mBuf[Pos++] << UINT8_BIT;\r
+      k += mBuf[Pos++];\r
+      EncodeP(k);\r
     } else {\r
-      EncodeC (mBuf[Pos++]);\r
+      EncodeC(mBuf[Pos++]);\r
     }\r
   }\r
-\r
-  for (Index = 0; Index < NC; Index++) {\r
-    mCFreq[Index] = 0;\r
+  for (i = 0; i < NC; i++) {\r
+    mCFreq[i] = 0;\r
   }\r
-\r
-  for (Index = 0; Index < NP; Index++) {\r
-    mPFreq[Index] = 0;\r
+  for (i = 0; i < NP; i++) {\r
+    mPFreq[i] = 0;\r
   }\r
 }\r
 \r
-STATIC\r
-VOID\r
+\r
+STATIC \r
+VOID \r
 Output (\r
-  IN UINT32 CharC,\r
-  IN UINT32 Pos\r
+  IN UINT32 c, \r
+  IN UINT32 p\r
   )\r
 /*++\r
 \r
@@ -1291,115 +1185,95 @@ Routine Description:
 \r
 Arguments:\r
 \r
-  CharC     - The original character or the 'String Length' element of a Pointer\r
-  Pos     - The 'Position' field of a Pointer\r
+  c     - The original character or the 'String Length' element of a Pointer\r
+  p     - The 'Position' field of a Pointer\r
 \r
 Returns: (VOID)\r
 \r
 --*/\r
 {\r
-  static UINT32 CPos;\r
+  STATIC UINT32 CPos;\r
 \r
   if ((mOutputMask >>= 1) == 0) {\r
     mOutputMask = 1U << (UINT8_BIT - 1);\r
-    //\r
-    // Check the buffer overflow per outputing UINT8_BIT symbols\r
-    // which is an Original Character or a Pointer. The biggest\r
-    // symbol is a Pointer which occupies 5 bytes.\r
-    //\r
-    if (mOutputPos >= mBufSiz - 5 * UINT8_BIT) {\r
-      SendBlock ();\r
+    if (mOutputPos >= mBufSiz - 3 * UINT8_BIT) {\r
+      SendBlock();\r
       mOutputPos = 0;\r
     }\r
-\r
-    CPos        = mOutputPos++;\r
-    mBuf[CPos]  = 0;\r
+    CPos = mOutputPos++;  \r
+    mBuf[CPos] = 0;\r
   }\r
-\r
-  mBuf[mOutputPos++] = (UINT8) CharC;\r
-  mCFreq[CharC]++;\r
-  if (CharC >= (1U << UINT8_BIT)) {\r
+  mBuf[mOutputPos++] = (UINT8) c;\r
+  mCFreq[c]++;\r
+  if (c >= (1U << UINT8_BIT)) {\r
     mBuf[CPos] |= mOutputMask;\r
-    mBuf[mOutputPos++]  = (UINT8) (Pos >> 24);\r
-    mBuf[mOutputPos++]  = (UINT8) (Pos >> 16);\r
-    mBuf[mOutputPos++]  = (UINT8) (Pos >> (UINT8_BIT));\r
-    mBuf[mOutputPos++]  = (UINT8) Pos;\r
-    CharC               = 0;\r
-    while (Pos) {\r
-      Pos >>= 1;\r
-      CharC++;\r
+    mBuf[mOutputPos++] = (UINT8)(p >> UINT8_BIT);\r
+    mBuf[mOutputPos++] = (UINT8) p;\r
+    c = 0;\r
+    while (p) {\r
+      p >>= 1;\r
+      c++;\r
     }\r
-\r
-    mPFreq[CharC]++;\r
+    mPFreq[c]++;\r
   }\r
 }\r
 \r
 STATIC\r
 VOID\r
-HufEncodeStart (\r
-  VOID\r
-  )\r
+HufEncodeStart ()\r
 {\r
-  INT32 Index;\r
+  INT32 i;\r
 \r
-  for (Index = 0; Index < NC; Index++) {\r
-    mCFreq[Index] = 0;\r
+  for (i = 0; i < NC; i++) {\r
+    mCFreq[i] = 0;\r
   }\r
-\r
-  for (Index = 0; Index < NP; Index++) {\r
-    mPFreq[Index] = 0;\r
+  for (i = 0; i < NP; i++) {\r
+    mPFreq[i] = 0;\r
   }\r
-\r
   mOutputPos = mOutputMask = 0;\r
-  InitPutBits ();\r
-  return ;\r
+  InitPutBits();\r
+  return;\r
 }\r
 \r
-STATIC\r
-VOID\r
-HufEncodeEnd (\r
-  VOID\r
-  )\r
+STATIC \r
+VOID \r
+HufEncodeEnd ()\r
 {\r
-  SendBlock ();\r
-\r
+  SendBlock();\r
+  \r
   //\r
   // Flush remaining bits\r
   //\r
-  PutBits (UINT8_BIT - 1, 0);\r
-\r
-  return ;\r
+  PutBits(UINT8_BIT - 1, 0);\r
+  \r
+  return;\r
 }\r
 \r
-STATIC\r
-VOID\r
-MakeCrcTable (\r
-  VOID\r
-  )\r
+\r
+STATIC \r
+VOID \r
+MakeCrcTable ()\r
 {\r
-  UINT32  Index;\r
-  UINT32  Index2;\r
-  UINT32  Temp;\r
-\r
-  for (Index = 0; Index <= UINT8_MAX; Index++) {\r
-    Temp = Index;\r
-    for (Index2 = 0; Index2 < UINT8_BIT; Index2++) {\r
-      if (Temp & 1) {\r
-        Temp = (Temp >> 1) ^ CRCPOLY;\r
+  UINT32 i, j, r;\r
+\r
+  for (i = 0; i <= UINT8_MAX; i++) {\r
+    r = i;\r
+    for (j = 0; j < UINT8_BIT; j++) {\r
+      if (r & 1) {\r
+        r = (r >> 1) ^ CRCPOLY;\r
       } else {\r
-        Temp >>= 1;\r
+        r >>= 1;\r
       }\r
     }\r
-\r
-    mCrcTable[Index] = (UINT16) Temp;\r
+    mCrcTable[i] = (UINT16)r;    \r
   }\r
 }\r
 \r
-STATIC\r
-VOID\r
+STATIC \r
+VOID \r
 PutBits (\r
-  IN INT32  Number,\r
-  IN UINT32 Value\r
+  IN INT32 n, \r
+  IN UINT32 x\r
   )\r
 /*++\r
 \r
@@ -1407,39 +1281,47 @@ Routine Description:
 \r
   Outputs rightmost n bits of x\r
 \r
-Arguments:\r
+Argments:\r
 \r
-  Number   - the rightmost n bits of the data is used\r
+  n   - the rightmost n bits of the data is used\r
   x   - the data \r
 \r
 Returns: (VOID)\r
 \r
 --*/\r
 {\r
-  UINT8 Temp;\r
-\r
-  while (Number >= mBitCount) {\r
-    //\r
-    // Number -= mBitCount should never equal to 32\r
-    //\r
-    Temp = (UINT8) (mSubBitBuf | (Value >> (Number -= mBitCount)));\r
+  UINT8 Temp;  \r
+  \r
+  if (n < mBitCount) {\r
+    mSubBitBuf |= x << (mBitCount -= n);\r
+  } else {\r
+      \r
+    Temp = (UINT8)(mSubBitBuf | (x >> (n -= mBitCount)));\r
     if (mDst < mDstUpperLimit) {\r
       *mDst++ = Temp;\r
     }\r
-\r
     mCompSize++;\r
-    mSubBitBuf  = 0;\r
-    mBitCount   = UINT8_BIT;\r
-  }\r
 \r
-  mSubBitBuf |= Value << (mBitCount -= Number);\r
+    if (n < UINT8_BIT) {\r
+      mSubBitBuf = x << (mBitCount = UINT8_BIT - n);\r
+    } else {\r
+        \r
+      Temp = (UINT8)(x >> (n - UINT8_BIT));\r
+      if (mDst < mDstUpperLimit) {\r
+        *mDst++ = Temp;\r
+      }\r
+      mCompSize++;\r
+      \r
+      mSubBitBuf = x << (mBitCount = 2 * UINT8_BIT - n);\r
+    }\r
+  }\r
 }\r
 \r
-STATIC\r
-INT32\r
+STATIC \r
+INT32 \r
 FreadCrc (\r
-  OUT UINT8 *Pointer,\r
-  IN  INT32 Number\r
+  OUT UINT8 *p, \r
+  IN  INT32 n\r
   )\r
 /*++\r
 \r
@@ -1449,8 +1331,8 @@ Routine Description:
   \r
 Arguments:\r
 \r
-  Pointer   - the buffer to hold the data\r
-  Number   - number of bytes to read\r
+  p   - the buffer to hold the data\r
+  n   - number of bytes to read\r
 \r
 Returns:\r
 \r
@@ -1458,39 +1340,34 @@ Returns:
   \r
 --*/\r
 {\r
-  INT32 Index;\r
+  INT32 i;\r
 \r
-  for (Index = 0; mSrc < mSrcUpperLimit && Index < Number; Index++) {\r
-    *Pointer++ = *mSrc++;\r
+  for (i = 0; mSrc < mSrcUpperLimit && i < n; i++) {\r
+    *p++ = *mSrc++;\r
   }\r
+  n = i;\r
 \r
-  Number = Index;\r
-\r
-  Pointer -= Number;\r
-  mOrigSize += Number;\r
-  Index--;\r
-  while (Index >= 0) {\r
-    UPDATE_CRC (*Pointer++);\r
-    Index--;\r
+  p -= n;\r
+  mOrigSize += n;\r
+  while (--i >= 0) {\r
+    UPDATE_CRC(*p++);\r
   }\r
-\r
-  return Number;\r
+  return n;\r
 }\r
 \r
-STATIC\r
-VOID\r
-InitPutBits (\r
-  VOID\r
-  )\r
+\r
+STATIC \r
+VOID \r
+InitPutBits ()\r
 {\r
-  mBitCount   = UINT8_BIT;\r
-  mSubBitBuf  = 0;\r
+  mBitCount = UINT8_BIT;  \r
+  mSubBitBuf = 0;\r
 }\r
 \r
-STATIC\r
-VOID\r
+STATIC \r
+VOID \r
 CountLen (\r
-  IN INT32 Index\r
+  IN INT32 i\r
   )\r
 /*++\r
 \r
@@ -1500,26 +1377,26 @@ Routine Description:
   \r
 Arguments:\r
 \r
-  Index   - the top node\r
+  i   - the top node\r
   \r
 Returns: (VOID)\r
 \r
 --*/\r
 {\r
-  static INT32  Depth = 0;\r
+  STATIC INT32 Depth = 0;\r
 \r
-  if (Index < mN) {\r
+  if (i < mN) {\r
     mLenCnt[(Depth < 16) ? Depth : 16]++;\r
   } else {\r
     Depth++;\r
-    CountLen (mLeft[Index]);\r
-    CountLen (mRight[Index]);\r
+    CountLen(mLeft [i]);\r
+    CountLen(mRight[i]);\r
     Depth--;\r
   }\r
 }\r
 \r
-STATIC\r
-VOID\r
+STATIC \r
+VOID \r
 MakeLen (\r
   IN INT32 Root\r
   )\r
@@ -1532,91 +1409,76 @@ Routine Description:
 Arguments:\r
 \r
   Root   - the root of the tree\r
-  \r
-Returns:\r
-\r
-  VOID\r
 \r
 --*/\r
 {\r
-  INT32   Index;\r
-  INT32   Index3;\r
-  UINT32  Cum;\r
+  INT32 i, k;\r
+  UINT32 Cum;\r
 \r
-  for (Index = 0; Index <= 16; Index++) {\r
-    mLenCnt[Index] = 0;\r
+  for (i = 0; i <= 16; i++) {\r
+    mLenCnt[i] = 0;\r
   }\r
-\r
-  CountLen (Root);\r
-\r
+  CountLen(Root);\r
+  \r
   //\r
   // Adjust the length count array so that\r
   // no code will be generated longer than its designated length\r
   //\r
+  \r
   Cum = 0;\r
-  for (Index = 16; Index > 0; Index--) {\r
-    Cum += mLenCnt[Index] << (16 - Index);\r
+  for (i = 16; i > 0; i--) {\r
+    Cum += mLenCnt[i] << (16 - i);\r
   }\r
-\r
   while (Cum != (1U << 16)) {\r
     mLenCnt[16]--;\r
-    for (Index = 15; Index > 0; Index--) {\r
-      if (mLenCnt[Index] != 0) {\r
-        mLenCnt[Index]--;\r
-        mLenCnt[Index + 1] += 2;\r
+    for (i = 15; i > 0; i--) {\r
+      if (mLenCnt[i] != 0) {\r
+        mLenCnt[i]--;\r
+        mLenCnt[i+1] += 2;\r
         break;\r
       }\r
     }\r
-\r
     Cum--;\r
   }\r
-\r
-  for (Index = 16; Index > 0; Index--) {\r
-    Index3 = mLenCnt[Index];\r
-    Index3--;\r
-    while (Index3 >= 0) {\r
-      mLen[*mSortPtr++] = (UINT8) Index;\r
-      Index3--;\r
+  for (i = 16; i > 0; i--) {\r
+    k = mLenCnt[i];\r
+    while (--k >= 0) {\r
+      mLen[*mSortPtr++] = (UINT8)i;\r
     }\r
   }\r
 }\r
 \r
-STATIC\r
-VOID\r
+STATIC \r
+VOID \r
 DownHeap (\r
-  IN INT32 Index\r
+  IN INT32 i\r
   )\r
 {\r
-  INT32 Index2;\r
-  INT32 Index3;\r
+  INT32 j, k;\r
 \r
   //\r
-  // priority queue: send Index-th entry down heap\r
+  // priority queue: send i-th entry down heap\r
   //\r
-  Index3  = mHeap[Index];\r
-  Index2  = 2 * Index;\r
-  while (Index2 <= mHeapSize) {\r
-    if (Index2 < mHeapSize && mFreq[mHeap[Index2]] > mFreq[mHeap[Index2 + 1]]) {\r
-      Index2++;\r
+  \r
+  k = mHeap[i];\r
+  while ((j = 2 * i) <= mHeapSize) {\r
+    if (j < mHeapSize && mFreq[mHeap[j]] > mFreq[mHeap[j + 1]]) {\r
+      j++;\r
     }\r
-\r
-    if (mFreq[Index3] <= mFreq[mHeap[Index2]]) {\r
+    if (mFreq[k] <= mFreq[mHeap[j]]) {\r
       break;\r
     }\r
-\r
-    mHeap[Index]  = mHeap[Index2];\r
-    Index         = Index2;\r
-    Index2        = 2 * Index;\r
+    mHeap[i] = mHeap[j];\r
+    i = j;\r
   }\r
-\r
-  mHeap[Index] = (INT16) Index3;\r
+  mHeap[i] = (INT16)k;\r
 }\r
 \r
-STATIC\r
-VOID\r
+STATIC \r
+VOID \r
 MakeCode (\r
-  IN  INT32       Number,\r
-  IN  UINT8 Len[  ],\r
+  IN  INT32 n, \r
+  IN  UINT8 Len[], \r
   OUT UINT16 Code[]\r
   )\r
 /*++\r
@@ -1627,7 +1489,7 @@ Routine Description:
   \r
 Arguments:\r
 \r
-  Number     - number of symbols\r
+  n     - number of symbols\r
   Len   - the code length array\r
   Code  - stores codes for each symbol\r
 \r
@@ -1635,25 +1497,24 @@ Returns: (VOID)
 \r
 --*/\r
 {\r
-  INT32   Index;\r
-  UINT16  Start[18];\r
+  INT32    i;\r
+  UINT16   Start[18];\r
 \r
   Start[1] = 0;\r
-  for (Index = 1; Index <= 16; Index++) {\r
-    Start[Index + 1] = (UINT16) ((Start[Index] + mLenCnt[Index]) << 1);\r
+  for (i = 1; i <= 16; i++) {\r
+    Start[i + 1] = (UINT16)((Start[i] + mLenCnt[i]) << 1);\r
   }\r
-\r
-  for (Index = 0; Index < Number; Index++) {\r
-    Code[Index] = Start[Len[Index]]++;\r
+  for (i = 0; i < n; i++) {\r
+    Code[i] = Start[Len[i]]++;\r
   }\r
 }\r
 \r
-STATIC\r
-INT32\r
+STATIC \r
+INT32 \r
 MakeTree (\r
-  IN  INT32            NParm,\r
-  IN  UINT16  FreqParm[],\r
-  OUT UINT8   LenParm[ ],\r
+  IN  INT32   NParm, \r
+  IN  UINT16  FreqParm[], \r
+  OUT UINT8   LenParm[], \r
   OUT UINT16  CodeParm[]\r
   )\r
 /*++\r
@@ -1675,68 +1536,62 @@ Returns:
   \r
 --*/\r
 {\r
-  INT32 Index;\r
-  INT32 Index2;\r
-  INT32 Index3;\r
-  INT32 Avail;\r
-\r
+  INT32 i, j, k, Avail;\r
+  \r
   //\r
   // make tree, calculate len[], return root\r
   //\r
-  mN        = NParm;\r
-  mFreq     = FreqParm;\r
-  mLen      = LenParm;\r
-  Avail     = mN;\r
+\r
+  mN = NParm;\r
+  mFreq = FreqParm;\r
+  mLen = LenParm;\r
+  Avail = mN;\r
   mHeapSize = 0;\r
-  mHeap[1]  = 0;\r
-  for (Index = 0; Index < mN; Index++) {\r
-    mLen[Index] = 0;\r
-    if (mFreq[Index]) {\r
-      mHeapSize++;\r
-      mHeap[mHeapSize] = (INT16) Index;\r
-    }\r
+  mHeap[1] = 0;\r
+  for (i = 0; i < mN; i++) {\r
+    mLen[i] = 0;\r
+    if (mFreq[i]) {\r
+      mHeap[++mHeapSize] = (INT16)i;\r
+    }    \r
   }\r
-\r
   if (mHeapSize < 2) {\r
     CodeParm[mHeap[1]] = 0;\r
     return mHeap[1];\r
   }\r
-\r
-  for (Index = mHeapSize / 2; Index >= 1; Index--) {\r
+  for (i = mHeapSize / 2; i >= 1; i--) {\r
+    \r
     //\r
-    // make priority queue\r
+    // make priority queue \r
     //\r
-    DownHeap (Index);\r
+    DownHeap(i);\r
   }\r
-\r
   mSortPtr = CodeParm;\r
   do {\r
-    Index = mHeap[1];\r
-    if (Index < mN) {\r
-      *mSortPtr++ = (UINT16) Index;\r
+    i = mHeap[1];\r
+    if (i < mN) {\r
+      *mSortPtr++ = (UINT16)i;\r
     }\r
-\r
     mHeap[1] = mHeap[mHeapSize--];\r
-    DownHeap (1);\r
-    Index2 = mHeap[1];\r
-    if (Index2 < mN) {\r
-      *mSortPtr++ = (UINT16) Index2;\r
+    DownHeap(1);\r
+    j = mHeap[1];\r
+    if (j < mN) {\r
+      *mSortPtr++ = (UINT16)j;\r
     }\r
-\r
-    Index3        = Avail++;\r
-    mFreq[Index3] = (UINT16) (mFreq[Index] + mFreq[Index2]);\r
-    mHeap[1]      = (INT16) Index3;\r
-    DownHeap (1);\r
-    mLeft[Index3]   = (UINT16) Index;\r
-    mRight[Index3]  = (UINT16) Index2;\r
+    k = Avail++;\r
+    mFreq[k] = (UINT16)(mFreq[i] + mFreq[j]);\r
+    mHeap[1] = (INT16)k;\r
+    DownHeap(1);\r
+    mLeft[k] = (UINT16)i;\r
+    mRight[k] = (UINT16)j;\r
   } while (mHeapSize > 1);\r
-\r
+  \r
   mSortPtr = CodeParm;\r
-  MakeLen (Index3);\r
-  MakeCode (NParm, LenParm, CodeParm);\r
-\r
+  MakeLen(k);\r
+  MakeCode(NParm, LenParm, CodeParm);\r
+  \r
   //\r
   // return root\r
   //\r
-  return Index3;\r
+  return k;\r
 }\r
+\r
diff --git a/Tools/CCode/Source/Common/EfiCompress.h b/Tools/CCode/Source/Common/EfiCompress.h
deleted file mode 100644 (file)
index 6ad80e4..0000000
+++ /dev/null
@@ -1,69 +0,0 @@
-/*++\r
-\r
-Copyright (c) 2004, Intel Corporation                                                         \r
-All rights reserved. This program and the accompanying materials                          \r
-are licensed and made available under the terms and conditions of the BSD License         \r
-which accompanies this distribution.  The full text of the license may be found at        \r
-http://opensource.org/licenses/bsd-license.php                                            \r
-                                                                                          \r
-THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,                     \r
-WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.             \r
-\r
-Module Name:\r
-\r
-  EfiCompress.h\r
-\r
-Abstract:\r
-\r
-  Header file for compression routine\r
-  \r
---*/\r
-\r
-#ifndef _EFICOMPRESS_H\r
-#define _EFICOMPRESS_H\r
-\r
-#include <string.h>\r
-#include <stdlib.h>\r
-\r
-#include <Common/UefiBaseTypes.h>\r
-\r
-EFI_STATUS\r
-Compress (\r
-  IN      UINT8   *SrcBuffer,\r
-  IN      UINT32  SrcSize,\r
-  IN      UINT8   *DstBuffer,\r
-  IN OUT  UINT32  *DstSize\r
-  )\r
-;\r
-\r
-/*++\r
-\r
-Routine Description:\r
-\r
-  The compression routine.\r
-\r
-Arguments:\r
-\r
-  SrcBuffer   - The buffer storing the source data\r
-  SrcSize     - The size of source data\r
-  DstBuffer   - The buffer to store the compressed data\r
-  DstSize     - On input, the size of DstBuffer; On output,\r
-                the size of the actual compressed data.\r
-\r
-Returns:\r
-\r
-  EFI_BUFFER_TOO_SMALL  - The DstBuffer is too small. In this case,\r
-                DstSize contains the size needed.\r
-  EFI_SUCCESS           - Compression is successful.\r
-\r
---*/\r
-typedef\r
-EFI_STATUS\r
-(*COMPRESS_FUNCTION) (\r
-  IN      UINT8   *SrcBuffer,\r
-  IN      UINT32  SrcSize,\r
-  IN      UINT8   *DstBuffer,\r
-  IN OUT  UINT32  *DstSize\r
-  );\r
-\r
-#endif\r
diff --git a/Tools/CCode/Source/Common/TianoCompress.c b/Tools/CCode/Source/Common/TianoCompress.c
new file mode 100644 (file)
index 0000000..dc78e7a
--- /dev/null
@@ -0,0 +1,1752 @@
+/*++\r
+\r
+Copyright (c) 2006, Intel Corporation                                              \r
+All rights reserved. This program and the accompanying materials                          \r
+are licensed and made available under the terms and conditions of the BSD License         \r
+which accompanies this distribution.  The full text of the license may be found at        \r
+http://opensource.org/licenses/bsd-license.php                                            \r
+                                                                                          \r
+THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,                     \r
+WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.             \r
+\r
+Module Name:\r
+\r
+  TianoCompress.c\r
+\r
+Abstract:\r
+\r
+  Compression routine. The compression algorithm is a mixture of\r
+  LZ77 and Huffman coding. LZ77 transforms the source data into a\r
+  sequence of Original Characters and Pointers to repeated strings.\r
+  This sequence is further divided into Blocks and Huffman codings\r
+  are applied to each Block.\r
+\r
+--*/\r
+\r
+#include "Compress.h"\r
+\r
+//\r
+// Macro Definitions\r
+//\r
+typedef INT32 NODE;\r
+#define UINT8_MAX     0xff\r
+#define UINT8_BIT     8\r
+#define THRESHOLD     3\r
+#define INIT_CRC      0\r
+#define WNDBIT        19\r
+#define WNDSIZ        (1U << WNDBIT)\r
+#define MAXMATCH      256\r
+#define BLKSIZ        (1U << 14)  // 16 * 1024U\r
+#define PERC_FLAG     0x80000000U\r
+#define CODE_BIT      16\r
+#define NIL           0\r
+#define MAX_HASH_VAL  (3 * WNDSIZ + (WNDSIZ / 512 + 1) * UINT8_MAX)\r
+#define HASH(p, c)    ((p) + ((c) << (WNDBIT - 9)) + WNDSIZ * 2)\r
+#define CRCPOLY       0xA001\r
+#define UPDATE_CRC(c) mCrc = mCrcTable[(mCrc ^ (c)) & 0xFF] ^ (mCrc >> UINT8_BIT)\r
+\r
+//\r
+// C: the Char&Len Set; P: the Position Set; T: the exTra Set\r
+//\r
+#define NC    (UINT8_MAX + MAXMATCH + 2 - THRESHOLD)\r
+#define CBIT  9\r
+#define NP    (WNDBIT + 1)\r
+#define PBIT  5\r
+#define NT    (CODE_BIT + 3)\r
+#define TBIT  5\r
+#if NT > NP\r
+#define NPT NT\r
+#else\r
+#define NPT NP\r
+#endif\r
+//\r
+// Function Prototypes\r
+//\r
+\r
+STATIC\r
+VOID\r
+PutDword(\r
+  IN UINT32 Data\r
+  );\r
+\r
+STATIC\r
+EFI_STATUS\r
+AllocateMemory (\r
+  VOID\r
+  );\r
+\r
+STATIC\r
+VOID\r
+FreeMemory (\r
+  VOID\r
+  );\r
+\r
+STATIC\r
+VOID\r
+InitSlide (\r
+  VOID\r
+  );\r
+\r
+STATIC\r
+NODE\r
+Child (\r
+  IN NODE   NodeQ,\r
+  IN UINT8  CharC\r
+  );\r
+\r
+STATIC\r
+VOID\r
+MakeChild (\r
+  IN NODE  NodeQ,\r
+  IN UINT8 CharC,\r
+  IN NODE  NodeR\r
+  );\r
+\r
+STATIC\r
+VOID\r
+Split (\r
+  IN NODE Old\r
+  );\r
+\r
+STATIC\r
+VOID\r
+InsertNode (\r
+  VOID\r
+  );\r
+\r
+STATIC\r
+VOID\r
+DeleteNode (\r
+  VOID\r
+  );\r
+\r
+STATIC\r
+VOID\r
+GetNextMatch (\r
+  VOID\r
+  );\r
+\r
+STATIC\r
+EFI_STATUS\r
+Encode (\r
+  VOID\r
+  );\r
+\r
+STATIC\r
+VOID\r
+CountTFreq (\r
+  VOID\r
+  );\r
+\r
+STATIC\r
+VOID\r
+WritePTLen (\r
+  IN INT32 Number,\r
+  IN INT32 nbit,\r
+  IN INT32 Special\r
+  );\r
+\r
+STATIC\r
+VOID\r
+WriteCLen (\r
+  VOID\r
+  );\r
+\r
+STATIC\r
+VOID\r
+EncodeC (\r
+  IN INT32 Value\r
+  );\r
+\r
+STATIC\r
+VOID\r
+EncodeP (\r
+  IN UINT32 Value\r
+  );\r
+\r
+STATIC\r
+VOID\r
+SendBlock (\r
+  VOID\r
+  );\r
+\r
+STATIC\r
+VOID\r
+Output (\r
+  IN UINT32 c,\r
+  IN UINT32 p\r
+  );\r
+\r
+STATIC\r
+VOID\r
+HufEncodeStart (\r
+  VOID\r
+  );\r
+\r
+STATIC\r
+VOID\r
+HufEncodeEnd (\r
+  VOID\r
+  );\r
+\r
+STATIC\r
+VOID\r
+MakeCrcTable (\r
+  VOID\r
+  );\r
+\r
+STATIC\r
+VOID\r
+PutBits (\r
+  IN INT32  Number,\r
+  IN UINT32 Value\r
+  );\r
+\r
+STATIC\r
+INT32\r
+FreadCrc (\r
+  OUT UINT8 *Pointer,\r
+  IN  INT32 Number\r
+  );\r
+\r
+STATIC\r
+VOID\r
+InitPutBits (\r
+  VOID\r
+  );\r
+\r
+STATIC\r
+VOID\r
+CountLen (\r
+  IN INT32 Index\r
+  );\r
+\r
+STATIC\r
+VOID\r
+MakeLen (\r
+  IN INT32 Root\r
+  );\r
+\r
+STATIC\r
+VOID\r
+DownHeap (\r
+  IN INT32 Index\r
+  );\r
+\r
+STATIC\r
+VOID\r
+MakeCode (\r
+  IN  INT32       Number,\r
+  IN  UINT8 Len[  ],\r
+  OUT UINT16 Code[]\r
+  );\r
+\r
+STATIC\r
+INT32\r
+MakeTree (\r
+  IN  INT32            NParm,\r
+  IN  UINT16  FreqParm[],\r
+  OUT UINT8   LenParm[ ],\r
+  OUT UINT16  CodeParm[]\r
+  );\r
+\r
+//\r
+//  Global Variables\r
+//\r
+STATIC UINT8  *mSrc, *mDst, *mSrcUpperLimit, *mDstUpperLimit;\r
+\r
+STATIC UINT8  *mLevel, *mText, *mChildCount, *mBuf, mCLen[NC], mPTLen[NPT], *mLen;\r
+STATIC INT16  mHeap[NC + 1];\r
+STATIC INT32  mRemainder, mMatchLen, mBitCount, mHeapSize, mN;\r
+STATIC UINT32 mBufSiz = 0, mOutputPos, mOutputMask, mSubBitBuf, mCrc;\r
+STATIC UINT32 mCompSize, mOrigSize;\r
+\r
+STATIC UINT16 *mFreq, *mSortPtr, mLenCnt[17], mLeft[2 * NC - 1], mRight[2 * NC - 1], mCrcTable[UINT8_MAX + 1],\r
+  mCFreq[2 * NC - 1], mCTable[4096], mCCode[NC], mPFreq[2 * NP - 1], mPTCode[NPT], mTFreq[2 * NT - 1];\r
+\r
+STATIC NODE   mPos, mMatchPos, mAvail, *mPosition, *mParent, *mPrev, *mNext = NULL;\r
+\r
+//\r
+// functions\r
+//\r
+EFI_STATUS\r
+TianoCompress (\r
+  IN      UINT8   *SrcBuffer,\r
+  IN      UINT32  SrcSize,\r
+  IN      UINT8   *DstBuffer,\r
+  IN OUT  UINT32  *DstSize\r
+  )\r
+/*++\r
+\r
+Routine Description:\r
+\r
+  The internal implementation of [Efi/Tiano]Compress().\r
+\r
+Arguments:\r
+\r
+  SrcBuffer   - The buffer storing the source data\r
+  SrcSize     - The size of source data\r
+  DstBuffer   - The buffer to store the compressed data\r
+  DstSize     - On input, the size of DstBuffer; On output,\r
+                the size of the actual compressed data.\r
+  Version     - The version of de/compression algorithm.\r
+                Version 1 for EFI 1.1 de/compression algorithm.\r
+                Version 2 for Tiano de/compression algorithm.\r
+\r
+Returns:\r
+\r
+  EFI_BUFFER_TOO_SMALL  - The DstBuffer is too small. In this case,\r
+                DstSize contains the size needed.\r
+  EFI_SUCCESS           - Compression is successful.\r
+  EFI_OUT_OF_RESOURCES  - No resource to complete function.\r
+  EFI_INVALID_PARAMETER - Parameter supplied is wrong.\r
+\r
+--*/\r
+{\r
+  EFI_STATUS  Status;\r
+\r
+  //\r
+  // Initializations\r
+  //\r
+  mBufSiz         = 0;\r
+  mBuf            = NULL;\r
+  mText           = NULL;\r
+  mLevel          = NULL;\r
+  mChildCount     = NULL;\r
+  mPosition       = NULL;\r
+  mParent         = NULL;\r
+  mPrev           = NULL;\r
+  mNext           = NULL;\r
+\r
+  mSrc            = SrcBuffer;\r
+  mSrcUpperLimit  = mSrc + SrcSize;\r
+  mDst            = DstBuffer;\r
+  mDstUpperLimit  = mDst +*DstSize;\r
+\r
+  PutDword (0L);\r
+  PutDword (0L);\r
+\r
+  MakeCrcTable ();\r
+\r
+  mOrigSize             = mCompSize = 0;\r
+  mCrc                  = INIT_CRC;\r
+\r
+  //\r
+  // Compress it\r
+  //\r
+  Status = Encode ();\r
+  if (EFI_ERROR (Status)) {\r
+    return EFI_OUT_OF_RESOURCES;\r
+  }\r
+  //\r
+  // Null terminate the compressed data\r
+  //\r
+  if (mDst < mDstUpperLimit) {\r
+    *mDst++ = 0;\r
+  }\r
+  //\r
+  // Fill in compressed size and original size\r
+  //\r
+  mDst = DstBuffer;\r
+  PutDword (mCompSize + 1);\r
+  PutDword (mOrigSize);\r
+\r
+  //\r
+  // Return\r
+  //\r
+  if (mCompSize + 1 + 8 > *DstSize) {\r
+    *DstSize = mCompSize + 1 + 8;\r
+    return EFI_BUFFER_TOO_SMALL;\r
+  } else {\r
+    *DstSize = mCompSize + 1 + 8;\r
+    return EFI_SUCCESS;\r
+  }\r
+\r
+}\r
+\r
+STATIC\r
+VOID\r
+PutDword (\r
+  IN UINT32 Data\r
+  )\r
+/*++\r
+\r
+Routine Description:\r
+\r
+  Put a dword to output stream\r
+  \r
+Arguments:\r
+\r
+  Data    - the dword to put\r
+  \r
+Returns: (VOID)\r
+  \r
+--*/\r
+{\r
+  if (mDst < mDstUpperLimit) {\r
+    *mDst++ = (UINT8) (((UINT8) (Data)) & 0xff);\r
+  }\r
+\r
+  if (mDst < mDstUpperLimit) {\r
+    *mDst++ = (UINT8) (((UINT8) (Data >> 0x08)) & 0xff);\r
+  }\r
+\r
+  if (mDst < mDstUpperLimit) {\r
+    *mDst++ = (UINT8) (((UINT8) (Data >> 0x10)) & 0xff);\r
+  }\r
+\r
+  if (mDst < mDstUpperLimit) {\r
+    *mDst++ = (UINT8) (((UINT8) (Data >> 0x18)) & 0xff);\r
+  }\r
+}\r
+\r
+STATIC\r
+EFI_STATUS\r
+AllocateMemory (\r
+  VOID\r
+  )\r
+/*++\r
+\r
+Routine Description:\r
+\r
+  Allocate memory spaces for data structures used in compression process\r
+  \r
+Argements: \r
+  VOID\r
+\r
+Returns:\r
+\r
+  EFI_SUCCESS           - Memory is allocated successfully\r
+  EFI_OUT_OF_RESOURCES  - Allocation fails\r
+\r
+--*/\r
+{\r
+  UINT32  Index;\r
+\r
+  mText = malloc (WNDSIZ * 2 + MAXMATCH);\r
+  for (Index = 0; Index < WNDSIZ * 2 + MAXMATCH; Index++) {\r
+    mText[Index] = 0;\r
+  }\r
+\r
+  mLevel      = malloc ((WNDSIZ + UINT8_MAX + 1) * sizeof (*mLevel));\r
+  mChildCount = malloc ((WNDSIZ + UINT8_MAX + 1) * sizeof (*mChildCount));\r
+  mPosition   = malloc ((WNDSIZ + UINT8_MAX + 1) * sizeof (*mPosition));\r
+  mParent     = malloc (WNDSIZ * 2 * sizeof (*mParent));\r
+  mPrev       = malloc (WNDSIZ * 2 * sizeof (*mPrev));\r
+  mNext       = malloc ((MAX_HASH_VAL + 1) * sizeof (*mNext));\r
+\r
+  mBufSiz     = BLKSIZ;\r
+  mBuf        = malloc (mBufSiz);\r
+  while (mBuf == NULL) {\r
+    mBufSiz = (mBufSiz / 10U) * 9U;\r
+    if (mBufSiz < 4 * 1024U) {\r
+      return EFI_OUT_OF_RESOURCES;\r
+    }\r
+\r
+    mBuf = malloc (mBufSiz);\r
+  }\r
+\r
+  mBuf[0] = 0;\r
+\r
+  return EFI_SUCCESS;\r
+}\r
+\r
+VOID\r
+FreeMemory (\r
+  VOID\r
+  )\r
+/*++\r
+\r
+Routine Description:\r
+\r
+  Called when compression is completed to free memory previously allocated.\r
+  \r
+Arguments: (VOID)\r
+\r
+Returns: (VOID)\r
+\r
+--*/\r
+{\r
+  if (mText != NULL) {\r
+    free (mText);\r
+  }\r
+\r
+  if (mLevel != NULL) {\r
+    free (mLevel);\r
+  }\r
+\r
+  if (mChildCount != NULL) {\r
+    free (mChildCount);\r
+  }\r
+\r
+  if (mPosition != NULL) {\r
+    free (mPosition);\r
+  }\r
+\r
+  if (mParent != NULL) {\r
+    free (mParent);\r
+  }\r
+\r
+  if (mPrev != NULL) {\r
+    free (mPrev);\r
+  }\r
+\r
+  if (mNext != NULL) {\r
+    free (mNext);\r
+  }\r
+\r
+  if (mBuf != NULL) {\r
+    free (mBuf);\r
+  }\r
+\r
+  return ;\r
+}\r
+\r
+STATIC\r
+VOID\r
+InitSlide (\r
+  VOID\r
+  )\r
+/*++\r
+\r
+Routine Description:\r
+\r
+  Initialize String Info Log data structures\r
+  \r
+Arguments: (VOID)\r
+\r
+Returns: (VOID)\r
+\r
+--*/\r
+{\r
+  NODE  Index;\r
+\r
+  for (Index = WNDSIZ; Index <= WNDSIZ + UINT8_MAX; Index++) {\r
+    mLevel[Index]     = 1;\r
+    mPosition[Index]  = NIL;  /* sentinel */\r
+  }\r
+\r
+  for (Index = WNDSIZ; Index < WNDSIZ * 2; Index++) {\r
+    mParent[Index] = NIL;\r
+  }\r
+\r
+  mAvail = 1;\r
+  for (Index = 1; Index < WNDSIZ - 1; Index++) {\r
+    mNext[Index] = (NODE) (Index + 1);\r
+  }\r
+\r
+  mNext[WNDSIZ - 1] = NIL;\r
+  for (Index = WNDSIZ * 2; Index <= MAX_HASH_VAL; Index++) {\r
+    mNext[Index] = NIL;\r
+  }\r
+}\r
+\r
+STATIC\r
+NODE\r
+Child (\r
+  IN NODE  NodeQ,\r
+  IN UINT8 CharC\r
+  )\r
+/*++\r
+\r
+Routine Description:\r
+\r
+  Find child node given the parent node and the edge character\r
+  \r
+Arguments:\r
+\r
+  NodeQ       - the parent node\r
+  CharC       - the edge character\r
+  \r
+Returns:\r
+\r
+  The child node (NIL if not found)  \r
+  \r
+--*/\r
+{\r
+  NODE  NodeR;\r
+\r
+  NodeR = mNext[HASH (NodeQ, CharC)];\r
+  //\r
+  // sentinel\r
+  //\r
+  mParent[NIL] = NodeQ;\r
+  while (mParent[NodeR] != NodeQ) {\r
+    NodeR = mNext[NodeR];\r
+  }\r
+\r
+  return NodeR;\r
+}\r
+\r
+STATIC\r
+VOID\r
+MakeChild (\r
+  IN NODE  Parent,\r
+  IN UINT8 CharC,\r
+  IN NODE  Child\r
+  )\r
+/*++\r
+\r
+Routine Description:\r
+\r
+  Create a new child for a given parent node.\r
+  \r
+Arguments:\r
+\r
+  Parent       - the parent node\r
+  CharC   - the edge character\r
+  Child       - the child node\r
+  \r
+Returns: (VOID)\r
+\r
+--*/\r
+{\r
+  NODE  Node1;\r
+  NODE  Node2;\r
+\r
+  Node1           = (NODE) HASH (Parent, CharC);\r
+  Node2           = mNext[Node1];\r
+  mNext[Node1]    = Child;\r
+  mNext[Child]    = Node2;\r
+  mPrev[Node2]    = Child;\r
+  mPrev[Child]    = Node1;\r
+  mParent[Child]  = Parent;\r
+  mChildCount[Parent]++;\r
+}\r
+\r
+STATIC\r
+VOID\r
+Split (\r
+  NODE Old\r
+  )\r
+/*++\r
+\r
+Routine Description:\r
+\r
+  Split a node.\r
+  \r
+Arguments:\r
+\r
+  Old     - the node to split\r
+  \r
+Returns: (VOID)\r
+\r
+--*/\r
+{\r
+  NODE  New;\r
+  NODE  TempNode;\r
+\r
+  New               = mAvail;\r
+  mAvail            = mNext[New];\r
+  mChildCount[New]  = 0;\r
+  TempNode          = mPrev[Old];\r
+  mPrev[New]        = TempNode;\r
+  mNext[TempNode]   = New;\r
+  TempNode          = mNext[Old];\r
+  mNext[New]        = TempNode;\r
+  mPrev[TempNode]   = New;\r
+  mParent[New]      = mParent[Old];\r
+  mLevel[New]       = (UINT8) mMatchLen;\r
+  mPosition[New]    = mPos;\r
+  MakeChild (New, mText[mMatchPos + mMatchLen], Old);\r
+  MakeChild (New, mText[mPos + mMatchLen], mPos);\r
+}\r
+\r
+STATIC\r
+VOID\r
+InsertNode (\r
+  VOID\r
+  )\r
+/*++\r
+\r
+Routine Description:\r
+\r
+  Insert string info for current position into the String Info Log\r
+  \r
+Arguments: (VOID)\r
+\r
+Returns: (VOID)\r
+\r
+--*/\r
+{\r
+  NODE  NodeQ;\r
+  NODE  NodeR;\r
+  NODE  Index2;\r
+  NODE  NodeT;\r
+  UINT8 CharC;\r
+  UINT8 *t1;\r
+  UINT8 *t2;\r
+\r
+  if (mMatchLen >= 4) {\r
+    //\r
+    // We have just got a long match, the target tree\r
+    // can be located by MatchPos + 1. Travese the tree\r
+    // from bottom up to get to a proper starting point.\r
+    // The usage of PERC_FLAG ensures proper node deletion\r
+    // in DeleteNode() later.\r
+    //\r
+    mMatchLen--;\r
+    NodeR = (NODE) ((mMatchPos + 1) | WNDSIZ);\r
+    NodeQ = mParent[NodeR];\r
+    while (NodeQ == NIL) {\r
+      NodeR = mNext[NodeR];\r
+      NodeQ = mParent[NodeR];\r
+    }\r
+\r
+    while (mLevel[NodeQ] >= mMatchLen) {\r
+      NodeR = NodeQ;\r
+      NodeQ = mParent[NodeQ];\r
+    }\r
+\r
+    NodeT = NodeQ;\r
+    while (mPosition[NodeT] < 0) {\r
+      mPosition[NodeT]  = mPos;\r
+      NodeT             = mParent[NodeT];\r
+    }\r
+\r
+    if (NodeT < WNDSIZ) {\r
+      mPosition[NodeT] = (NODE) (mPos | (UINT32) PERC_FLAG);\r
+    }\r
+  } else {\r
+    //\r
+    // Locate the target tree\r
+    //\r
+    NodeQ = (NODE) (mText[mPos] + WNDSIZ);\r
+    CharC = mText[mPos + 1];\r
+    NodeR = Child (NodeQ, CharC);\r
+    if (NodeR == NIL) {\r
+      MakeChild (NodeQ, CharC, mPos);\r
+      mMatchLen = 1;\r
+      return ;\r
+    }\r
+\r
+    mMatchLen = 2;\r
+  }\r
+  //\r
+  // Traverse down the tree to find a match.\r
+  // Update Position value along the route.\r
+  // Node split or creation is involved.\r
+  //\r
+  for (;;) {\r
+    if (NodeR >= WNDSIZ) {\r
+      Index2    = MAXMATCH;\r
+      mMatchPos = NodeR;\r
+    } else {\r
+      Index2    = mLevel[NodeR];\r
+      mMatchPos = (NODE) (mPosition[NodeR] & (UINT32)~PERC_FLAG);\r
+    }\r
+\r
+    if (mMatchPos >= mPos) {\r
+      mMatchPos -= WNDSIZ;\r
+    }\r
+\r
+    t1  = &mText[mPos + mMatchLen];\r
+    t2  = &mText[mMatchPos + mMatchLen];\r
+    while (mMatchLen < Index2) {\r
+      if (*t1 != *t2) {\r
+        Split (NodeR);\r
+        return ;\r
+      }\r
+\r
+      mMatchLen++;\r
+      t1++;\r
+      t2++;\r
+    }\r
+\r
+    if (mMatchLen >= MAXMATCH) {\r
+      break;\r
+    }\r
+\r
+    mPosition[NodeR]  = mPos;\r
+    NodeQ             = NodeR;\r
+    NodeR             = Child (NodeQ, *t1);\r
+    if (NodeR == NIL) {\r
+      MakeChild (NodeQ, *t1, mPos);\r
+      return ;\r
+    }\r
+\r
+    mMatchLen++;\r
+  }\r
+\r
+  NodeT           = mPrev[NodeR];\r
+  mPrev[mPos]     = NodeT;\r
+  mNext[NodeT]    = mPos;\r
+  NodeT           = mNext[NodeR];\r
+  mNext[mPos]     = NodeT;\r
+  mPrev[NodeT]    = mPos;\r
+  mParent[mPos]   = NodeQ;\r
+  mParent[NodeR]  = NIL;\r
+\r
+  //\r
+  // Special usage of 'next'\r
+  //\r
+  mNext[NodeR] = mPos;\r
+\r
+}\r
+\r
+STATIC\r
+VOID\r
+DeleteNode (\r
+  VOID\r
+  )\r
+/*++\r
+\r
+Routine Description:\r
+\r
+  Delete outdated string info. (The Usage of PERC_FLAG\r
+  ensures a clean deletion)\r
+  \r
+Arguments: (VOID)\r
+\r
+Returns: (VOID)\r
+\r
+--*/\r
+{\r
+  NODE  NodeQ;\r
+  NODE  NodeR;\r
+  NODE  NodeS;\r
+  NODE  NodeT;\r
+  NODE  NodeU;\r
+\r
+  if (mParent[mPos] == NIL) {\r
+    return ;\r
+  }\r
+\r
+  NodeR         = mPrev[mPos];\r
+  NodeS         = mNext[mPos];\r
+  mNext[NodeR]  = NodeS;\r
+  mPrev[NodeS]  = NodeR;\r
+  NodeR         = mParent[mPos];\r
+  mParent[mPos] = NIL;\r
+  if (NodeR >= WNDSIZ) {\r
+    return ;\r
+  }\r
+\r
+  mChildCount[NodeR]--;\r
+  if (mChildCount[NodeR] > 1) {\r
+    return ;\r
+  }\r
+\r
+  NodeT = (NODE) (mPosition[NodeR] & (UINT32)~PERC_FLAG);\r
+  if (NodeT >= mPos) {\r
+    NodeT -= WNDSIZ;\r
+  }\r
+\r
+  NodeS = NodeT;\r
+  NodeQ = mParent[NodeR];\r
+  NodeU = mPosition[NodeQ];\r
+  while (NodeU & (UINT32) PERC_FLAG) {\r
+    NodeU &= (UINT32)~PERC_FLAG;\r
+    if (NodeU >= mPos) {\r
+      NodeU -= WNDSIZ;\r
+    }\r
+\r
+    if (NodeU > NodeS) {\r
+      NodeS = NodeU;\r
+    }\r
+\r
+    mPosition[NodeQ]  = (NODE) (NodeS | WNDSIZ);\r
+    NodeQ             = mParent[NodeQ];\r
+    NodeU             = mPosition[NodeQ];\r
+  }\r
+\r
+  if (NodeQ < WNDSIZ) {\r
+    if (NodeU >= mPos) {\r
+      NodeU -= WNDSIZ;\r
+    }\r
+\r
+    if (NodeU > NodeS) {\r
+      NodeS = NodeU;\r
+    }\r
+\r
+    mPosition[NodeQ] = (NODE) (NodeS | WNDSIZ | (UINT32) PERC_FLAG);\r
+  }\r
+\r
+  NodeS           = Child (NodeR, mText[NodeT + mLevel[NodeR]]);\r
+  NodeT           = mPrev[NodeS];\r
+  NodeU           = mNext[NodeS];\r
+  mNext[NodeT]    = NodeU;\r
+  mPrev[NodeU]    = NodeT;\r
+  NodeT           = mPrev[NodeR];\r
+  mNext[NodeT]    = NodeS;\r
+  mPrev[NodeS]    = NodeT;\r
+  NodeT           = mNext[NodeR];\r
+  mPrev[NodeT]    = NodeS;\r
+  mNext[NodeS]    = NodeT;\r
+  mParent[NodeS]  = mParent[NodeR];\r
+  mParent[NodeR]  = NIL;\r
+  mNext[NodeR]    = mAvail;\r
+  mAvail          = NodeR;\r
+}\r
+\r
+STATIC\r
+VOID\r
+GetNextMatch (\r
+  VOID\r
+  )\r
+/*++\r
+\r
+Routine Description:\r
+\r
+  Advance the current position (read in new data if needed).\r
+  Delete outdated string info. Find a match string for current position.\r
+\r
+Arguments: (VOID)\r
+\r
+Returns: (VOID)\r
+\r
+--*/\r
+{\r
+  INT32 Number;\r
+\r
+  mRemainder--;\r
+  mPos++;\r
+  if (mPos == WNDSIZ * 2) {\r
+    memmove (&mText[0], &mText[WNDSIZ], WNDSIZ + MAXMATCH);\r
+    Number = FreadCrc (&mText[WNDSIZ + MAXMATCH], WNDSIZ);\r
+    mRemainder += Number;\r
+    mPos = WNDSIZ;\r
+  }\r
+\r
+  DeleteNode ();\r
+  InsertNode ();\r
+}\r
+\r
+STATIC\r
+EFI_STATUS\r
+Encode (\r
+  VOID\r
+  )\r
+/*++\r
+\r
+Routine Description:\r
+\r
+  The main controlling routine for compression process.\r
+\r
+Arguments: (VOID)\r
+\r
+Returns:\r
+  \r
+  EFI_SUCCESS           - The compression is successful\r
+  EFI_OUT_0F_RESOURCES  - Not enough memory for compression process\r
+\r
+--*/\r
+{\r
+  EFI_STATUS  Status;\r
+  INT32       LastMatchLen;\r
+  NODE        LastMatchPos;\r
+\r
+  Status = AllocateMemory ();\r
+  if (EFI_ERROR (Status)) {\r
+    FreeMemory ();\r
+    return Status;\r
+  }\r
+\r
+  InitSlide ();\r
+\r
+  HufEncodeStart ();\r
+\r
+  mRemainder  = FreadCrc (&mText[WNDSIZ], WNDSIZ + MAXMATCH);\r
+\r
+  mMatchLen   = 0;\r
+  mPos        = WNDSIZ;\r
+  InsertNode ();\r
+  if (mMatchLen > mRemainder) {\r
+    mMatchLen = mRemainder;\r
+  }\r
+\r
+  while (mRemainder > 0) {\r
+    LastMatchLen  = mMatchLen;\r
+    LastMatchPos  = mMatchPos;\r
+    GetNextMatch ();\r
+    if (mMatchLen > mRemainder) {\r
+      mMatchLen = mRemainder;\r
+    }\r
+\r
+    if (mMatchLen > LastMatchLen || LastMatchLen < THRESHOLD) {\r
+      //\r
+      // Not enough benefits are gained by outputting a pointer,\r
+      // so just output the original character\r
+      //\r
+      Output (mText[mPos - 1], 0);\r
+\r
+    } else {\r
+\r
+      if (LastMatchLen == THRESHOLD) {\r
+        if (((mPos - LastMatchPos - 2) & (WNDSIZ - 1)) > (1U << 11)) {\r
+          Output (mText[mPos - 1], 0);\r
+          continue;\r
+        }\r
+      }\r
+      //\r
+      // Outputting a pointer is beneficial enough, do it.\r
+      //\r
+      Output (\r
+        LastMatchLen + (UINT8_MAX + 1 - THRESHOLD),\r
+        (mPos - LastMatchPos - 2) & (WNDSIZ - 1)\r
+        );\r
+      LastMatchLen--;\r
+      while (LastMatchLen > 0) {\r
+        GetNextMatch ();\r
+        LastMatchLen--;\r
+      }\r
+\r
+      if (mMatchLen > mRemainder) {\r
+        mMatchLen = mRemainder;\r
+      }\r
+    }\r
+  }\r
+\r
+  HufEncodeEnd ();\r
+  FreeMemory ();\r
+  return EFI_SUCCESS;\r
+}\r
+\r
+STATIC\r
+VOID\r
+CountTFreq (\r
+  VOID\r
+  )\r
+/*++\r
+\r
+Routine Description:\r
+\r
+  Count the frequencies for the Extra Set\r
+  \r
+Arguments: (VOID)\r
+\r
+Returns: (VOID)\r
+\r
+--*/\r
+{\r
+  INT32 Index;\r
+  INT32 Index3;\r
+  INT32 Number;\r
+  INT32 Count;\r
+\r
+  for (Index = 0; Index < NT; Index++) {\r
+    mTFreq[Index] = 0;\r
+  }\r
+\r
+  Number = NC;\r
+  while (Number > 0 && mCLen[Number - 1] == 0) {\r
+    Number--;\r
+  }\r
+\r
+  Index = 0;\r
+  while (Index < Number) {\r
+    Index3 = mCLen[Index++];\r
+    if (Index3 == 0) {\r
+      Count = 1;\r
+      while (Index < Number && mCLen[Index] == 0) {\r
+        Index++;\r
+        Count++;\r
+      }\r
+\r
+      if (Count <= 2) {\r
+        mTFreq[0] = (UINT16) (mTFreq[0] + Count);\r
+      } else if (Count <= 18) {\r
+        mTFreq[1]++;\r
+      } else if (Count == 19) {\r
+        mTFreq[0]++;\r
+        mTFreq[1]++;\r
+      } else {\r
+        mTFreq[2]++;\r
+      }\r
+    } else {\r
+      mTFreq[Index3 + 2]++;\r
+    }\r
+  }\r
+}\r
+\r
+STATIC\r
+VOID\r
+WritePTLen (\r
+  IN INT32 Number,\r
+  IN INT32 nbit,\r
+  IN INT32 Special\r
+  )\r
+/*++\r
+\r
+Routine Description:\r
+\r
+  Outputs the code length array for the Extra Set or the Position Set.\r
+  \r
+Arguments:\r
+\r
+  Number       - the number of symbols\r
+  nbit    - the number of bits needed to represent 'n'\r
+  Special - the special symbol that needs to be take care of\r
+  \r
+Returns: (VOID)\r
+\r
+--*/\r
+{\r
+  INT32 Index;\r
+  INT32 Index3;\r
+\r
+  while (Number > 0 && mPTLen[Number - 1] == 0) {\r
+    Number--;\r
+  }\r
+\r
+  PutBits (nbit, Number);\r
+  Index = 0;\r
+  while (Index < Number) {\r
+    Index3 = mPTLen[Index++];\r
+    if (Index3 <= 6) {\r
+      PutBits (3, Index3);\r
+    } else {\r
+      PutBits (Index3 - 3, (1U << (Index3 - 3)) - 2);\r
+    }\r
+\r
+    if (Index == Special) {\r
+      while (Index < 6 && mPTLen[Index] == 0) {\r
+        Index++;\r
+      }\r
+\r
+      PutBits (2, (Index - 3) & 3);\r
+    }\r
+  }\r
+}\r
+\r
+STATIC\r
+VOID\r
+WriteCLen (\r
+  VOID\r
+  )\r
+/*++\r
+\r
+Routine Description:\r
+\r
+  Outputs the code length array for Char&Length Set\r
+  \r
+Arguments: (VOID)\r
+\r
+Returns: (VOID)\r
+\r
+--*/\r
+{\r
+  INT32 Index;\r
+  INT32 Index3;\r
+  INT32 Number;\r
+  INT32 Count;\r
+\r
+  Number = NC;\r
+  while (Number > 0 && mCLen[Number - 1] == 0) {\r
+    Number--;\r
+  }\r
+\r
+  PutBits (CBIT, Number);\r
+  Index = 0;\r
+  while (Index < Number) {\r
+    Index3 = mCLen[Index++];\r
+    if (Index3 == 0) {\r
+      Count = 1;\r
+      while (Index < Number && mCLen[Index] == 0) {\r
+        Index++;\r
+        Count++;\r
+      }\r
+\r
+      if (Count <= 2) {\r
+        for (Index3 = 0; Index3 < Count; Index3++) {\r
+          PutBits (mPTLen[0], mPTCode[0]);\r
+        }\r
+      } else if (Count <= 18) {\r
+        PutBits (mPTLen[1], mPTCode[1]);\r
+        PutBits (4, Count - 3);\r
+      } else if (Count == 19) {\r
+        PutBits (mPTLen[0], mPTCode[0]);\r
+        PutBits (mPTLen[1], mPTCode[1]);\r
+        PutBits (4, 15);\r
+      } else {\r
+        PutBits (mPTLen[2], mPTCode[2]);\r
+        PutBits (CBIT, Count - 20);\r
+      }\r
+    } else {\r
+      PutBits (mPTLen[Index3 + 2], mPTCode[Index3 + 2]);\r
+    }\r
+  }\r
+}\r
+\r
+STATIC\r
+VOID\r
+EncodeC (\r
+  IN INT32 Value\r
+  )\r
+{\r
+  PutBits (mCLen[Value], mCCode[Value]);\r
+}\r
+\r
+STATIC\r
+VOID\r
+EncodeP (\r
+  IN UINT32 Value\r
+  )\r
+{\r
+  UINT32  Index;\r
+  UINT32  NodeQ;\r
+\r
+  Index = 0;\r
+  NodeQ = Value;\r
+  while (NodeQ) {\r
+    NodeQ >>= 1;\r
+    Index++;\r
+  }\r
+\r
+  PutBits (mPTLen[Index], mPTCode[Index]);\r
+  if (Index > 1) {\r
+    PutBits (Index - 1, Value & (0xFFFFFFFFU >> (32 - Index + 1)));\r
+  }\r
+}\r
+\r
+STATIC\r
+VOID\r
+SendBlock (\r
+  VOID\r
+  )\r
+/*++\r
+\r
+Routine Description:\r
+\r
+  Huffman code the block and output it.\r
+  \r
+Arguments: \r
+  (VOID)\r
+\r
+Returns: \r
+  (VOID)\r
+\r
+--*/\r
+{\r
+  UINT32  Index;\r
+  UINT32  Index2;\r
+  UINT32  Index3;\r
+  UINT32  Flags;\r
+  UINT32  Root;\r
+  UINT32  Pos;\r
+  UINT32  Size;\r
+  Flags = 0;\r
+\r
+  Root  = MakeTree (NC, mCFreq, mCLen, mCCode);\r
+  Size  = mCFreq[Root];\r
+  PutBits (16, Size);\r
+  if (Root >= NC) {\r
+    CountTFreq ();\r
+    Root = MakeTree (NT, mTFreq, mPTLen, mPTCode);\r
+    if (Root >= NT) {\r
+      WritePTLen (NT, TBIT, 3);\r
+    } else {\r
+      PutBits (TBIT, 0);\r
+      PutBits (TBIT, Root);\r
+    }\r
+\r
+    WriteCLen ();\r
+  } else {\r
+    PutBits (TBIT, 0);\r
+    PutBits (TBIT, 0);\r
+    PutBits (CBIT, 0);\r
+    PutBits (CBIT, Root);\r
+  }\r
+\r
+  Root = MakeTree (NP, mPFreq, mPTLen, mPTCode);\r
+  if (Root >= NP) {\r
+    WritePTLen (NP, PBIT, -1);\r
+  } else {\r
+    PutBits (PBIT, 0);\r
+    PutBits (PBIT, Root);\r
+  }\r
+\r
+  Pos = 0;\r
+  for (Index = 0; Index < Size; Index++) {\r
+    if (Index % UINT8_BIT == 0) {\r
+      Flags = mBuf[Pos++];\r
+    } else {\r
+      Flags <<= 1;\r
+    }\r
+\r
+    if (Flags & (1U << (UINT8_BIT - 1))) {\r
+      EncodeC (mBuf[Pos++] + (1U << UINT8_BIT));\r
+      Index3 = mBuf[Pos++];\r
+      for (Index2 = 0; Index2 < 3; Index2++) {\r
+        Index3 <<= UINT8_BIT;\r
+        Index3 += mBuf[Pos++];\r
+      }\r
+\r
+      EncodeP (Index3);\r
+    } else {\r
+      EncodeC (mBuf[Pos++]);\r
+    }\r
+  }\r
+\r
+  for (Index = 0; Index < NC; Index++) {\r
+    mCFreq[Index] = 0;\r
+  }\r
+\r
+  for (Index = 0; Index < NP; Index++) {\r
+    mPFreq[Index] = 0;\r
+  }\r
+}\r
+\r
+STATIC\r
+VOID\r
+Output (\r
+  IN UINT32 CharC,\r
+  IN UINT32 Pos\r
+  )\r
+/*++\r
+\r
+Routine Description:\r
+\r
+  Outputs an Original Character or a Pointer\r
+\r
+Arguments:\r
+\r
+  CharC     - The original character or the 'String Length' element of a Pointer\r
+  Pos     - The 'Position' field of a Pointer\r
+\r
+Returns: (VOID)\r
+\r
+--*/\r
+{\r
+  STATIC UINT32 CPos;\r
+\r
+  if ((mOutputMask >>= 1) == 0) {\r
+    mOutputMask = 1U << (UINT8_BIT - 1);\r
+    //\r
+    // Check the buffer overflow per outputing UINT8_BIT symbols\r
+    // which is an Original Character or a Pointer. The biggest\r
+    // symbol is a Pointer which occupies 5 bytes.\r
+    //\r
+    if (mOutputPos >= mBufSiz - 5 * UINT8_BIT) {\r
+      SendBlock ();\r
+      mOutputPos = 0;\r
+    }\r
+\r
+    CPos        = mOutputPos++;\r
+    mBuf[CPos]  = 0;\r
+  }\r
+\r
+  mBuf[mOutputPos++] = (UINT8) CharC;\r
+  mCFreq[CharC]++;\r
+  if (CharC >= (1U << UINT8_BIT)) {\r
+    mBuf[CPos] |= mOutputMask;\r
+    mBuf[mOutputPos++]  = (UINT8) (Pos >> 24);\r
+    mBuf[mOutputPos++]  = (UINT8) (Pos >> 16);\r
+    mBuf[mOutputPos++]  = (UINT8) (Pos >> (UINT8_BIT));\r
+    mBuf[mOutputPos++]  = (UINT8) Pos;\r
+    CharC               = 0;\r
+    while (Pos) {\r
+      Pos >>= 1;\r
+      CharC++;\r
+    }\r
+\r
+    mPFreq[CharC]++;\r
+  }\r
+}\r
+\r
+STATIC\r
+VOID\r
+HufEncodeStart (\r
+  VOID\r
+  )\r
+{\r
+  INT32 Index;\r
+\r
+  for (Index = 0; Index < NC; Index++) {\r
+    mCFreq[Index] = 0;\r
+  }\r
+\r
+  for (Index = 0; Index < NP; Index++) {\r
+    mPFreq[Index] = 0;\r
+  }\r
+\r
+  mOutputPos = mOutputMask = 0;\r
+  InitPutBits ();\r
+  return ;\r
+}\r
+\r
+STATIC\r
+VOID\r
+HufEncodeEnd (\r
+  VOID\r
+  )\r
+{\r
+  SendBlock ();\r
+\r
+  //\r
+  // Flush remaining bits\r
+  //\r
+  PutBits (UINT8_BIT - 1, 0);\r
+\r
+  return ;\r
+}\r
+\r
+STATIC\r
+VOID\r
+MakeCrcTable (\r
+  VOID\r
+  )\r
+{\r
+  UINT32  Index;\r
+  UINT32  Index2;\r
+  UINT32  Temp;\r
+\r
+  for (Index = 0; Index <= UINT8_MAX; Index++) {\r
+    Temp = Index;\r
+    for (Index2 = 0; Index2 < UINT8_BIT; Index2++) {\r
+      if (Temp & 1) {\r
+        Temp = (Temp >> 1) ^ CRCPOLY;\r
+      } else {\r
+        Temp >>= 1;\r
+      }\r
+    }\r
+\r
+    mCrcTable[Index] = (UINT16) Temp;\r
+  }\r
+}\r
+\r
+STATIC\r
+VOID\r
+PutBits (\r
+  IN INT32  Number,\r
+  IN UINT32 Value\r
+  )\r
+/*++\r
+\r
+Routine Description:\r
+\r
+  Outputs rightmost n bits of x\r
+\r
+Arguments:\r
+\r
+  Number   - the rightmost n bits of the data is used\r
+  x   - the data \r
+\r
+Returns: (VOID)\r
+\r
+--*/\r
+{\r
+  UINT8 Temp;\r
+\r
+  while (Number >= mBitCount) {\r
+    //\r
+    // Number -= mBitCount should never equal to 32\r
+    //\r
+    Temp = (UINT8) (mSubBitBuf | (Value >> (Number -= mBitCount)));\r
+    if (mDst < mDstUpperLimit) {\r
+      *mDst++ = Temp;\r
+    }\r
+\r
+    mCompSize++;\r
+    mSubBitBuf  = 0;\r
+    mBitCount   = UINT8_BIT;\r
+  }\r
+\r
+  mSubBitBuf |= Value << (mBitCount -= Number);\r
+}\r
+\r
+STATIC\r
+INT32\r
+FreadCrc (\r
+  OUT UINT8 *Pointer,\r
+  IN  INT32 Number\r
+  )\r
+/*++\r
+\r
+Routine Description:\r
+\r
+  Read in source data\r
+  \r
+Arguments:\r
+\r
+  Pointer   - the buffer to hold the data\r
+  Number   - number of bytes to read\r
+\r
+Returns:\r
+\r
+  number of bytes actually read\r
+  \r
+--*/\r
+{\r
+  INT32 Index;\r
+\r
+  for (Index = 0; mSrc < mSrcUpperLimit && Index < Number; Index++) {\r
+    *Pointer++ = *mSrc++;\r
+  }\r
+\r
+  Number = Index;\r
+\r
+  Pointer -= Number;\r
+  mOrigSize += Number;\r
+  Index--;\r
+  while (Index >= 0) {\r
+    UPDATE_CRC (*Pointer++);\r
+    Index--;\r
+  }\r
+\r
+  return Number;\r
+}\r
+\r
+STATIC\r
+VOID\r
+InitPutBits (\r
+  VOID\r
+  )\r
+{\r
+  mBitCount   = UINT8_BIT;\r
+  mSubBitBuf  = 0;\r
+}\r
+\r
+STATIC\r
+VOID\r
+CountLen (\r
+  IN INT32 Index\r
+  )\r
+/*++\r
+\r
+Routine Description:\r
+\r
+  Count the number of each code length for a Huffman tree.\r
+  \r
+Arguments:\r
+\r
+  Index   - the top node\r
+  \r
+Returns: (VOID)\r
+\r
+--*/\r
+{\r
+  STATIC INT32  Depth = 0;\r
+\r
+  if (Index < mN) {\r
+    mLenCnt[(Depth < 16) ? Depth : 16]++;\r
+  } else {\r
+    Depth++;\r
+    CountLen (mLeft[Index]);\r
+    CountLen (mRight[Index]);\r
+    Depth--;\r
+  }\r
+}\r
+\r
+STATIC\r
+VOID\r
+MakeLen (\r
+  IN INT32 Root\r
+  )\r
+/*++\r
+\r
+Routine Description:\r
+\r
+  Create code length array for a Huffman tree\r
+  \r
+Arguments:\r
+\r
+  Root   - the root of the tree\r
+  \r
+Returns:\r
+\r
+  VOID\r
+\r
+--*/\r
+{\r
+  INT32   Index;\r
+  INT32   Index3;\r
+  UINT32  Cum;\r
+\r
+  for (Index = 0; Index <= 16; Index++) {\r
+    mLenCnt[Index] = 0;\r
+  }\r
+\r
+  CountLen (Root);\r
+\r
+  //\r
+  // Adjust the length count array so that\r
+  // no code will be generated longer than its designated length\r
+  //\r
+  Cum = 0;\r
+  for (Index = 16; Index > 0; Index--) {\r
+    Cum += mLenCnt[Index] << (16 - Index);\r
+  }\r
+\r
+  while (Cum != (1U << 16)) {\r
+    mLenCnt[16]--;\r
+    for (Index = 15; Index > 0; Index--) {\r
+      if (mLenCnt[Index] != 0) {\r
+        mLenCnt[Index]--;\r
+        mLenCnt[Index + 1] += 2;\r
+        break;\r
+      }\r
+    }\r
+\r
+    Cum--;\r
+  }\r
+\r
+  for (Index = 16; Index > 0; Index--) {\r
+    Index3 = mLenCnt[Index];\r
+    Index3--;\r
+    while (Index3 >= 0) {\r
+      mLen[*mSortPtr++] = (UINT8) Index;\r
+      Index3--;\r
+    }\r
+  }\r
+}\r
+\r
+STATIC\r
+VOID\r
+DownHeap (\r
+  IN INT32 Index\r
+  )\r
+{\r
+  INT32 Index2;\r
+  INT32 Index3;\r
+\r
+  //\r
+  // priority queue: send Index-th entry down heap\r
+  //\r
+  Index3  = mHeap[Index];\r
+  Index2  = 2 * Index;\r
+  while (Index2 <= mHeapSize) {\r
+    if (Index2 < mHeapSize && mFreq[mHeap[Index2]] > mFreq[mHeap[Index2 + 1]]) {\r
+      Index2++;\r
+    }\r
+\r
+    if (mFreq[Index3] <= mFreq[mHeap[Index2]]) {\r
+      break;\r
+    }\r
+\r
+    mHeap[Index]  = mHeap[Index2];\r
+    Index         = Index2;\r
+    Index2        = 2 * Index;\r
+  }\r
+\r
+  mHeap[Index] = (INT16) Index3;\r
+}\r
+\r
+STATIC\r
+VOID\r
+MakeCode (\r
+  IN  INT32       Number,\r
+  IN  UINT8 Len[  ],\r
+  OUT UINT16 Code[]\r
+  )\r
+/*++\r
+\r
+Routine Description:\r
+\r
+  Assign code to each symbol based on the code length array\r
+  \r
+Arguments:\r
+\r
+  Number     - number of symbols\r
+  Len   - the code length array\r
+  Code  - stores codes for each symbol\r
+\r
+Returns: (VOID)\r
+\r
+--*/\r
+{\r
+  INT32   Index;\r
+  UINT16  Start[18];\r
+\r
+  Start[1] = 0;\r
+  for (Index = 1; Index <= 16; Index++) {\r
+    Start[Index + 1] = (UINT16) ((Start[Index] + mLenCnt[Index]) << 1);\r
+  }\r
+\r
+  for (Index = 0; Index < Number; Index++) {\r
+    Code[Index] = Start[Len[Index]]++;\r
+  }\r
+}\r
+\r
+STATIC\r
+INT32\r
+MakeTree (\r
+  IN  INT32            NParm,\r
+  IN  UINT16  FreqParm[],\r
+  OUT UINT8   LenParm[ ],\r
+  OUT UINT16  CodeParm[]\r
+  )\r
+/*++\r
+\r
+Routine Description:\r
+\r
+  Generates Huffman codes given a frequency distribution of symbols\r
+  \r
+Arguments:\r
+\r
+  NParm    - number of symbols\r
+  FreqParm - frequency of each symbol\r
+  LenParm  - code length for each symbol\r
+  CodeParm - code for each symbol\r
+  \r
+Returns:\r
+\r
+  Root of the Huffman tree.\r
+  \r
+--*/\r
+{\r
+  INT32 Index;\r
+  INT32 Index2;\r
+  INT32 Index3;\r
+  INT32 Avail;\r
+\r
+  //\r
+  // make tree, calculate len[], return root\r
+  //\r
+  mN        = NParm;\r
+  mFreq     = FreqParm;\r
+  mLen      = LenParm;\r
+  Avail     = mN;\r
+  mHeapSize = 0;\r
+  mHeap[1]  = 0;\r
+  for (Index = 0; Index < mN; Index++) {\r
+    mLen[Index] = 0;\r
+    if (mFreq[Index]) {\r
+      mHeapSize++;\r
+      mHeap[mHeapSize] = (INT16) Index;\r
+    }\r
+  }\r
+\r
+  if (mHeapSize < 2) {\r
+    CodeParm[mHeap[1]] = 0;\r
+    return mHeap[1];\r
+  }\r
+\r
+  for (Index = mHeapSize / 2; Index >= 1; Index--) {\r
+    //\r
+    // make priority queue\r
+    //\r
+    DownHeap (Index);\r
+  }\r
+\r
+  mSortPtr = CodeParm;\r
+  do {\r
+    Index = mHeap[1];\r
+    if (Index < mN) {\r
+      *mSortPtr++ = (UINT16) Index;\r
+    }\r
+\r
+    mHeap[1] = mHeap[mHeapSize--];\r
+    DownHeap (1);\r
+    Index2 = mHeap[1];\r
+    if (Index2 < mN) {\r
+      *mSortPtr++ = (UINT16) Index2;\r
+    }\r
+\r
+    Index3        = Avail++;\r
+    mFreq[Index3] = (UINT16) (mFreq[Index] + mFreq[Index2]);\r
+    mHeap[1]      = (INT16) Index3;\r
+    DownHeap (1);\r
+    mLeft[Index3]   = (UINT16) Index;\r
+    mRight[Index3]  = (UINT16) Index2;\r
+  } while (mHeapSize > 1);\r
+\r
+  mSortPtr = CodeParm;\r
+  MakeLen (Index3);\r
+  MakeCode (NParm, LenParm, CodeParm);\r
+\r
+  //\r
+  // return root\r
+  //\r
+  return Index3;\r
+}\r
index cc06f26..f46e603 100644 (file)
 typedef long long __int64;/*For cygwin build*/\r
 #endif\r
 #include "CompressDll.h"\r
-#include "EfiCompress.h"\r
+#include "Compress.h"\r
 \r
 extern\r
 EFI_STATUS\r
-Compress (\r
+TianoCompress (\r
   IN      UINT8   *SrcBuffer,\r
   IN      UINT32  SrcSize,\r
   IN      UINT8   *DstBuffer,\r
@@ -47,7 +47,7 @@ JNIEXPORT jbyteArray JNICALL  Java_org_tianocore_framework_tasks_Compress_CallCo
    //  First call compress function and get need buffer size\r
    //\r
 \r
-   Result = Compress (\r
+   Result = TianoCompress (\r
         (char*) InputBuffer, \r
         SourceSize,  \r
         DestBuffer,\r
@@ -61,7 +61,7 @@ JNIEXPORT jbyteArray JNICALL  Java_org_tianocore_framework_tasks_Compress_CallCo
    //\r
    //  Second call compress and get the DestBuffer value\r
    //\r
-   Result = Compress(\r
+   Result = TianoCompress(\r
               (char*) InputBuffer, \r
         SourceSize,  \r
         DestBuffer,\r
index f745ea2..b07f629 100644 (file)
@@ -27,7 +27,7 @@ Abstract:
 #include <stdio.h>\r
 \r
 #include <Common/UefiBaseTypes.h>\r
-#include "EfiCompress.h"\r
+#include "Compress.h"\r
 \r
 #define UTILITY_NAME "EfiCompress"\r
 #define UTILITY_MAJOR_VERSION 1\r
@@ -176,14 +176,14 @@ Returns:
   // Get destination data size and do the compression\r
   //\r
   DstSize = 0;\r
-  Status  = Compress (SrcBuffer, SrcSize, DstBuffer, &DstSize);\r
+  Status  = EfiCompress (SrcBuffer, SrcSize, DstBuffer, &DstSize);\r
   if (Status == EFI_BUFFER_TOO_SMALL) {\r
     if ((DstBuffer = malloc (DstSize)) == NULL) {\r
       printf ("Can't allocate memory\n");\r
       goto Done;\r
     }\r
 \r
-    Status = Compress (SrcBuffer, SrcSize, DstBuffer, &DstSize);\r
+    Status = EfiCompress (SrcBuffer, SrcSize, DstBuffer, &DstSize);\r
   }\r
 \r
   if (EFI_ERROR (Status)) {\r
index 2cc478b..5aca23f 100644 (file)
@@ -31,7 +31,7 @@ Abstract:
 \r
 #include <IndustryStandard/pci22.h>  // for option ROM header structures\r
 \r
-#include "EfiCompress.h"\r
+#include "Compress.h"\r
 #include "CommonLib.h"\r
 \r
 //\r
@@ -633,7 +633,7 @@ Returns:
     }\r
 \r
     CompressedFileSize  = FileSize;\r
-    Status              = Compress (Buffer, FileSize, CompressedBuffer, &CompressedFileSize);\r
+    Status              = EfiCompress (Buffer, FileSize, CompressedBuffer, &CompressedFileSize);\r
     if (Status != STATUS_SUCCESS) {\r
       fprintf (stdout, "ERROR: Compression failed\n");\r
       goto BailOut;\r
index 1eea09f..2ee7c44 100644 (file)
@@ -38,7 +38,7 @@ Abstract:
 #include <Common/FirmwareVolumeImageFormat.h>\r
 \r
 #include "ParseInf.h"\r
-#include "EfiCompress.h"\r
+#include "Compress.h"\r
 #include "EfiCustomizedCompress.h"\r
 #include "Crc32.h"\r
 #include "GenFfsFile.h"\r
@@ -591,14 +591,14 @@ Returns:
     // Added "Dummy" to keep backward compatibility.\r
     //\r
     CompressionType   = EFI_STANDARD_COMPRESSION;\r
-    CompressFunction  = (COMPRESS_FUNCTION) Compress;\r
+    CompressFunction  = (COMPRESS_FUNCTION) TianoCompress;\r
 \r
   } else if (strcmpi (Type, "LZH") == 0) {\r
     //\r
     // EFI stardard compression (LZH)\r
     //\r
     CompressionType   = EFI_STANDARD_COMPRESSION;\r
-    CompressFunction  = (COMPRESS_FUNCTION) Compress;\r
+    CompressFunction  = (COMPRESS_FUNCTION) TianoCompress;\r
 \r
   } else {\r
     //\r
index 353b1a3..8599346 100644 (file)
@@ -28,7 +28,7 @@ Abstract:
 #include <Protocol/GuidedSectionExtraction.h>\r
 \r
 #include "CommonLib.h"\r
-#include "EfiCompress.h"\r
+#include "Compress.h"\r
 #include "EfiCustomizedCompress.h"\r
 #include "Crc32.h"\r
 #include "EfiUtilityMsgs.h"\r
@@ -429,7 +429,7 @@ Returns:
     break;\r
 \r
   case EFI_STANDARD_COMPRESSION:\r
-    CompressFunction = (COMPRESS_FUNCTION) Compress;\r
+    CompressFunction = (COMPRESS_FUNCTION) TianoCompress;\r
     break;\r
 \r
   case EFI_CUSTOMIZED_COMPRESSION:\r