X-Git-Url: https://git.proxmox.com/?p=mirror_edk2.git;a=blobdiff_plain;f=Tools%2FCCode%2FSource%2FCommon%2FEfiCompress.c;h=87f52fd48ff8725d5f24b1efff9e601af4f308f0;hp=5b91b1d216df5f046b66660bb614e29289395d3f;hb=30f80dd8dedf2c333be4616442daf5d1b412e23e;hpb=61e61e3d30f3965953dcfe646d15a17bd9173da1

diff --git a/Tools/CCode/Source/Common/EfiCompress.c b/Tools/CCode/Source/Common/EfiCompress.c
index 5b91b1d216..87f52fd48f 100644
--- a/Tools/CCode/Source/Common/EfiCompress.c
+++ b/Tools/CCode/Source/Common/EfiCompress.c
@@ -1,6 +1,6 @@
 /*++
 
-Copyright (c) 2004, Intel Corporation                                                         
+Copyright (c) 2006, Intel Corporation                                              
 All rights reserved. This program and the accompanying materials                          
 are licensed and made available under the terms and conditions of the BSD License         
 which accompanies this distribution.  The full text of the license may be found at        
@@ -23,248 +23,248 @@ Abstract:
 
 --*/
 
-#include "EfiCompress.h"
+#include "Compress.h"
+
 
 //
 // Macro Definitions
 //
-typedef INT32 NODE;
-#define UINT8_BIT     8
-#define THRESHOLD     3
-#define INIT_CRC      0
-#define WNDBIT        19
-#define WNDSIZ        (1U << WNDBIT)
-#define MAXMATCH      256
-#define BLKSIZ        (1U << 14)  // 16 * 1024U
-#define PERC_FLAG     0x80000000U
-#define CODE_BIT      16
-#define NIL           0
-#define MAX_HASH_VAL  (3 * WNDSIZ + (WNDSIZ / 512 + 1) * UINT8_MAX)
-#define HASH(p, c)    ((p) + ((c) << (WNDBIT - 9)) + WNDSIZ * 2)
-#define CRCPOLY       0xA001
-#define UPDATE_CRC(c) mCrc = mCrcTable[(mCrc ^ (c)) & 0xFF] ^ (mCrc >> UINT8_BIT)
+
+typedef INT16             NODE;
+#define UINT8_MAX         0xff
+#define UINT8_BIT         8
+#define THRESHOLD         3
+#define INIT_CRC          0
+#define WNDBIT            13
+#define WNDSIZ            (1U << WNDBIT)
+#define MAXMATCH          256
+#define PERC_FLAG         0x8000U
+#define CODE_BIT          16
+#define NIL               0
+#define MAX_HASH_VAL      (3 * WNDSIZ + (WNDSIZ / 512 + 1) * UINT8_MAX)
+#define HASH(p, c)        ((p) + ((c) << (WNDBIT - 9)) + WNDSIZ * 2)
+#define CRCPOLY           0xA001
+#define UPDATE_CRC(c)     mCrc = mCrcTable[(mCrc ^ (c)) & 0xFF] ^ (mCrc >> UINT8_BIT)
 
 //
 // C: the Char&Len Set; P: the Position Set; T: the exTra Set
 //
-#define NC    (UINT8_MAX + MAXMATCH + 2 - THRESHOLD)
-#define CBIT  9
-#define NP    (WNDBIT + 1)
-#define PBIT  5
-#define NT    (CODE_BIT + 3)
-#define TBIT  5
+
+#define NC                (UINT8_MAX + MAXMATCH + 2 - THRESHOLD)
+#define CBIT              9
+#define NP                (WNDBIT + 1)
+#define PBIT              4
+#define NT                (CODE_BIT + 3)
+#define TBIT              5
 #if NT > NP
-#define NPT NT
+  #define                 NPT NT
 #else
-#define NPT NP
+  #define                 NPT NP
 #endif
+
 //
 // Function Prototypes
 //
-STATIC VOID PutDword(IN UINT32 Data);
 
 STATIC
-EFI_STATUS
+VOID 
+PutDword(
+  IN UINT32 Data
+  );
+
+STATIC
+EFI_STATUS 
 AllocateMemory (
-  VOID
   );
 
 STATIC
 VOID
 FreeMemory (
-  VOID
   );
 
-STATIC
-VOID
+STATIC 
+VOID 
 InitSlide (
-  VOID
   );
 
-STATIC
-NODE
+STATIC 
+NODE 
 Child (
-  IN NODE   NodeQ,
-  IN UINT8  CharC
+  IN NODE q, 
+  IN UINT8 c
   );
 
-STATIC
-VOID
+STATIC 
+VOID 
 MakeChild (
-  IN NODE  NodeQ,
-  IN UINT8 CharC,
-  IN NODE  NodeR
+  IN NODE q, 
+  IN UINT8 c, 
+  IN NODE r
   );
-
-STATIC
-VOID
+  
+STATIC 
+VOID 
 Split (
   IN NODE Old
   );
 
-STATIC
-VOID
+STATIC 
+VOID 
 InsertNode (
-  VOID
   );
-
-STATIC
-VOID
+  
+STATIC 
+VOID 
 DeleteNode (
-  VOID
   );
 
-STATIC
-VOID
+STATIC 
+VOID 
 GetNextMatch (
-  VOID
   );
-
-STATIC
-EFI_STATUS
+  
+STATIC 
+EFI_STATUS 
 Encode (
-  VOID
   );
 
-STATIC
-VOID
+STATIC 
+VOID 
 CountTFreq (
-  VOID
   );
 
-STATIC
-VOID
+STATIC 
+VOID 
 WritePTLen (
-  IN INT32 Number,
-  IN INT32 nbit,
+  IN INT32 n, 
+  IN INT32 nbit, 
   IN INT32 Special
   );
 
-STATIC
-VOID
+STATIC 
+VOID 
 WriteCLen (
-  VOID
   );
-
-STATIC
-VOID
+  
+STATIC 
+VOID 
 EncodeC (
-  IN INT32 Value
+  IN INT32 c
   );
 
-STATIC
-VOID
+STATIC 
+VOID 
 EncodeP (
-  IN UINT32 Value
+  IN UINT32 p
   );
 
-STATIC
-VOID
+STATIC 
+VOID 
 SendBlock (
-  VOID
   );
-
-STATIC
-VOID
+  
+STATIC 
+VOID 
 Output (
-  IN UINT32 c,
+  IN UINT32 c, 
   IN UINT32 p
   );
 
-STATIC
-VOID
+STATIC 
+VOID 
 HufEncodeStart (
-  VOID
   );
-
-STATIC
-VOID
+  
+STATIC 
+VOID 
 HufEncodeEnd (
-  VOID
   );
-
-STATIC
-VOID
+  
+STATIC 
+VOID 
 MakeCrcTable (
-  VOID
   );
-
-STATIC
-VOID
+  
+STATIC 
+VOID 
 PutBits (
-  IN INT32  Number,
-  IN UINT32 Value
+  IN INT32 n, 
+  IN UINT32 x
   );
-
-STATIC
-INT32
+  
+STATIC 
+INT32 
 FreadCrc (
-  OUT UINT8 *Pointer,
-  IN  INT32 Number
+  OUT UINT8 *p, 
+  IN  INT32 n
   );
-
-STATIC
-VOID
+  
+STATIC 
+VOID 
 InitPutBits (
-  VOID
   );
-
-STATIC
-VOID
+  
+STATIC 
+VOID 
 CountLen (
-  IN INT32 Index
+  IN INT32 i
   );
 
-STATIC
-VOID
+STATIC 
+VOID 
 MakeLen (
   IN INT32 Root
   );
-
-STATIC
-VOID
+  
+STATIC 
+VOID 
 DownHeap (
-  IN INT32 Index
+  IN INT32 i
   );
 
-STATIC
-VOID
+STATIC 
+VOID 
 MakeCode (
-  IN  INT32       Number,
-  IN  UINT8 Len[  ],
+  IN  INT32 n, 
+  IN  UINT8 Len[], 
   OUT UINT16 Code[]
   );
-
-STATIC
-INT32
+  
+STATIC 
+INT32 
 MakeTree (
-  IN  INT32            NParm,
-  IN  UINT16  FreqParm[],
-  OUT UINT8   LenParm[ ],
+  IN  INT32   NParm, 
+  IN  UINT16  FreqParm[], 
+  OUT UINT8   LenParm[], 
   OUT UINT16  CodeParm[]
   );
 
+
 //
 //  Global Variables
 //
-static UINT8  *mSrc, *mDst, *mSrcUpperLimit, *mDstUpperLimit;
 
-static UINT8  *mLevel, *mText, *mChildCount, *mBuf, mCLen[NC], mPTLen[NPT], *mLen;
-static INT16  mHeap[NC + 1];
-static INT32  mRemainder, mMatchLen, mBitCount, mHeapSize, mN;
-static UINT32 mBufSiz = 0, mOutputPos, mOutputMask, mSubBitBuf, mCrc;
-static UINT32 mCompSize, mOrigSize;
+STATIC UINT8  *mSrc, *mDst, *mSrcUpperLimit, *mDstUpperLimit;
+
+STATIC UINT8  *mLevel, *mText, *mChildCount, *mBuf, mCLen[NC], mPTLen[NPT], *mLen;
+STATIC INT16  mHeap[NC + 1];
+STATIC INT32  mRemainder, mMatchLen, mBitCount, mHeapSize, mN;
+STATIC UINT32 mBufSiz = 0, mOutputPos, mOutputMask, mSubBitBuf, mCrc;
+STATIC UINT32 mCompSize, mOrigSize;
 
-static UINT16 *mFreq, *mSortPtr, mLenCnt[17], mLeft[2 * NC - 1], mRight[2 * NC - 1], mCrcTable[UINT8_MAX + 1],
-  mCFreq[2 * NC - 1], mCTable[4096], mCCode[NC], mPFreq[2 * NP - 1], mPTCode[NPT], mTFreq[2 * NT - 1];
+STATIC UINT16 *mFreq, *mSortPtr, mLenCnt[17], mLeft[2 * NC - 1], mRight[2 * NC - 1],
+              mCrcTable[UINT8_MAX + 1], mCFreq[2 * NC - 1], mCTable[4096], mCCode[NC],
+              mPFreq[2 * NP - 1], mPTCode[NPT], mTFreq[2 * NT - 1];
+
+STATIC NODE   mPos, mMatchPos, mAvail, *mPosition, *mParent, *mPrev, *mNext = NULL;
 
-static NODE   mPos, mMatchPos, mAvail, *mPosition, *mParent, *mPrev, *mNext = NULL;
 
 //
 // functions
 //
+
 EFI_STATUS
-Compress (
+EfiCompress (
   IN      UINT8   *SrcBuffer,
   IN      UINT32  SrcSize,
   IN      UINT8   *DstBuffer,
@@ -289,61 +289,65 @@ Returns:
   EFI_BUFFER_TOO_SMALL  - The DstBuffer is too small. In this case,
                 DstSize contains the size needed.
   EFI_SUCCESS           - Compression is successful.
-  EFI_OUT_OF_RESOURCES  - No resource to complete function.
 
 --*/
 {
-  EFI_STATUS  Status;
-
+  EFI_STATUS Status = EFI_SUCCESS;
+  
   //
   // Initializations
   //
-  mBufSiz         = 0;
-  mBuf            = NULL;
-  mText           = NULL;
-  mLevel          = NULL;
-  mChildCount     = NULL;
-  mPosition       = NULL;
-  mParent         = NULL;
-  mPrev           = NULL;
-  mNext           = NULL;
-
-  mSrc            = SrcBuffer;
-  mSrcUpperLimit  = mSrc + SrcSize;
-  mDst            = DstBuffer;
-  mDstUpperLimit  = mDst +*DstSize;
-
-  PutDword (0L);
-  PutDword (0L);
+  mBufSiz = 0;
+  mBuf = NULL;
+  mText       = NULL;
+  mLevel      = NULL;
+  mChildCount = NULL;
+  mPosition   = NULL;
+  mParent     = NULL;
+  mPrev       = NULL;
+  mNext       = NULL;
 
-  MakeCrcTable ();
+  
+  mSrc = SrcBuffer;
+  mSrcUpperLimit = mSrc + SrcSize;
+  mDst = DstBuffer;
+  mDstUpperLimit = mDst + *DstSize;
 
-  mOrigSize             = mCompSize = 0;
-  mCrc                  = INIT_CRC;
+  PutDword(0L);
+  PutDword(0L);
+  
+  MakeCrcTable ();
 
+  mOrigSize = mCompSize = 0;
+  mCrc = INIT_CRC;
+  
   //
   // Compress it
   //
-  Status = Encode ();
+  
+  Status = Encode();
   if (EFI_ERROR (Status)) {
     return EFI_OUT_OF_RESOURCES;
   }
+  
   //
   // Null terminate the compressed data
   //
   if (mDst < mDstUpperLimit) {
     *mDst++ = 0;
   }
+  
   //
   // Fill in compressed size and original size
   //
   mDst = DstBuffer;
-  PutDword (mCompSize + 1);
-  PutDword (mOrigSize);
+  PutDword(mCompSize+1);
+  PutDword(mOrigSize);
 
   //
   // Return
   //
+  
   if (mCompSize + 1 + 8 > *DstSize) {
     *DstSize = mCompSize + 1 + 8;
     return EFI_BUFFER_TOO_SMALL;
@@ -354,9 +358,9 @@ Returns:
 
 }
 
-STATIC
-VOID
-PutDword (
+STATIC 
+VOID 
+PutDword(
   IN UINT32 Data
   )
 /*++
@@ -374,35 +378,32 @@ Returns: (VOID)
 --*/
 {
   if (mDst < mDstUpperLimit) {
-    *mDst++ = (UINT8) (((UINT8) (Data)) & 0xff);
+    *mDst++ = (UINT8)(((UINT8)(Data        )) & 0xff);
   }
 
   if (mDst < mDstUpperLimit) {
-    *mDst++ = (UINT8) (((UINT8) (Data >> 0x08)) & 0xff);
+    *mDst++ = (UINT8)(((UINT8)(Data >> 0x08)) & 0xff);
   }
 
   if (mDst < mDstUpperLimit) {
-    *mDst++ = (UINT8) (((UINT8) (Data >> 0x10)) & 0xff);
+    *mDst++ = (UINT8)(((UINT8)(Data >> 0x10)) & 0xff);
   }
 
   if (mDst < mDstUpperLimit) {
-    *mDst++ = (UINT8) (((UINT8) (Data >> 0x18)) & 0xff);
+    *mDst++ = (UINT8)(((UINT8)(Data >> 0x18)) & 0xff);
   }
 }
 
 STATIC
 EFI_STATUS
-AllocateMemory (
-  VOID
-  )
+AllocateMemory ()
 /*++
 
 Routine Description:
 
   Allocate memory spaces for data structures used in compression process
   
-Argements: 
-  VOID
+Argements: (VOID)
 
 Returns:
 
@@ -411,40 +412,34 @@ Returns:
 
 --*/
 {
-  UINT32  Index;
-
-  mText = malloc (WNDSIZ * 2 + MAXMATCH);
-  for (Index = 0; Index < WNDSIZ * 2 + MAXMATCH; Index++) {
-    mText[Index] = 0;
+  UINT32      i;
+  
+  mText       = malloc (WNDSIZ * 2 + MAXMATCH);
+  for (i = 0 ; i < WNDSIZ * 2 + MAXMATCH; i ++) {
+    mText[i] = 0;
   }
 
-  mLevel      = malloc ((WNDSIZ + UINT8_MAX + 1) * sizeof (*mLevel));
-  mChildCount = malloc ((WNDSIZ + UINT8_MAX + 1) * sizeof (*mChildCount));
-  mPosition   = malloc ((WNDSIZ + UINT8_MAX + 1) * sizeof (*mPosition));
-  mParent     = malloc (WNDSIZ * 2 * sizeof (*mParent));
-  mPrev       = malloc (WNDSIZ * 2 * sizeof (*mPrev));
-  mNext       = malloc ((MAX_HASH_VAL + 1) * sizeof (*mNext));
-
-  mBufSiz     = BLKSIZ;
-  mBuf        = malloc (mBufSiz);
-  while (mBuf == NULL) {
+  mLevel      = malloc ((WNDSIZ + UINT8_MAX + 1) * sizeof(*mLevel));
+  mChildCount = malloc ((WNDSIZ + UINT8_MAX + 1) * sizeof(*mChildCount));
+  mPosition   = malloc ((WNDSIZ + UINT8_MAX + 1) * sizeof(*mPosition));
+  mParent     = malloc (WNDSIZ * 2 * sizeof(*mParent));
+  mPrev       = malloc (WNDSIZ * 2 * sizeof(*mPrev));
+  mNext       = malloc ((MAX_HASH_VAL + 1) * sizeof(*mNext));
+  
+  mBufSiz = 16 * 1024U;
+  while ((mBuf = malloc(mBufSiz)) == NULL) {
     mBufSiz = (mBufSiz / 10U) * 9U;
     if (mBufSiz < 4 * 1024U) {
       return EFI_OUT_OF_RESOURCES;
     }
-
-    mBuf = malloc (mBufSiz);
   }
-
   mBuf[0] = 0;
-
+  
   return EFI_SUCCESS;
 }
 
 VOID
-FreeMemory (
-  VOID
-  )
+FreeMemory ()
 /*++
 
 Routine Description:
@@ -457,46 +452,45 @@ Returns: (VOID)
 
 --*/
 {
-  if (mText != NULL) {
+  if (mText) {
     free (mText);
   }
-
-  if (mLevel != NULL) {
+  
+  if (mLevel) {
     free (mLevel);
   }
-
-  if (mChildCount != NULL) {
+  
+  if (mChildCount) {
     free (mChildCount);
   }
-
-  if (mPosition != NULL) {
+  
+  if (mPosition) {
     free (mPosition);
   }
-
-  if (mParent != NULL) {
+  
+  if (mParent) {
     free (mParent);
   }
-
-  if (mPrev != NULL) {
+  
+  if (mPrev) {
     free (mPrev);
   }
-
-  if (mNext != NULL) {
+  
+  if (mNext) {
     free (mNext);
   }
-
-  if (mBuf != NULL) {
+  
+  if (mBuf) {
     free (mBuf);
-  }
+  }  
 
-  return ;
+  return;
 }
 
-STATIC
-VOID
-InitSlide (
-  VOID
-  )
+
+STATIC 
+VOID 
+InitSlide ()
 /*++
 
 Routine Description:
@@ -509,33 +503,32 @@ Returns: (VOID)
 
 --*/
 {
-  NODE  Index;
+  NODE i;
 
-  for (Index = WNDSIZ; Index <= WNDSIZ + UINT8_MAX; Index++) {
-    mLevel[Index]     = 1;
-    mPosition[Index]  = NIL;  /* sentinel */
+  for (i = WNDSIZ; i <= WNDSIZ + UINT8_MAX; i++) {
+    mLevel[i] = 1;
+    mPosition[i] = NIL;  /* sentinel */
   }
-
-  for (Index = WNDSIZ; Index < WNDSIZ * 2; Index++) {
-    mParent[Index] = NIL;
-  }
-
+  for (i = WNDSIZ; i < WNDSIZ * 2; i++) {
+    mParent[i] = NIL;
+  }  
   mAvail = 1;
-  for (Index = 1; Index < WNDSIZ - 1; Index++) {
-    mNext[Index] = (NODE) (Index + 1);
+  for (i = 1; i < WNDSIZ - 1; i++) {
+    mNext[i] = (NODE)(i + 1);
   }
-
+  
   mNext[WNDSIZ - 1] = NIL;
-  for (Index = WNDSIZ * 2; Index <= MAX_HASH_VAL; Index++) {
-    mNext[Index] = NIL;
-  }
+  for (i = WNDSIZ * 2; i <= MAX_HASH_VAL; i++) {
+    mNext[i] = NIL;
+  }  
 }
 
-STATIC
-NODE
+
+STATIC 
+NODE 
 Child (
-  IN NODE  NodeQ,
-  IN UINT8 CharC
+  IN NODE q, 
+  IN UINT8 c
   )
 /*++
 
@@ -545,8 +538,8 @@ Routine Description:
   
 Arguments:
 
-  NodeQ       - the parent node
-  CharC       - the edge character
+  q       - the parent node
+  c       - the edge character
   
 Returns:
 
@@ -554,26 +547,23 @@ Returns:
   
 --*/
 {
-  NODE  NodeR;
-
-  NodeR = mNext[HASH (NodeQ, CharC)];
-  //
-  // sentinel
-  //
-  mParent[NIL] = NodeQ;
-  while (mParent[NodeR] != NodeQ) {
-    NodeR = mNext[NodeR];
+  NODE r;
+  
+  r = mNext[HASH(q, c)];
+  mParent[NIL] = q;  /* sentinel */
+  while (mParent[r] != q) {
+    r = mNext[r];
   }
-
-  return NodeR;
+  
+  return r;
 }
 
-STATIC
-VOID
+STATIC 
+VOID 
 MakeChild (
-  IN NODE  Parent,
-  IN UINT8 CharC,
-  IN NODE  Child
+  IN NODE q, 
+  IN UINT8 c, 
+  IN NODE r
   )
 /*++
 
@@ -583,29 +573,28 @@ Routine Description:
   
 Arguments:
 
-  Parent       - the parent node
-  CharC   - the edge character
-  Child       - the child node
+  q       - the parent node
+  c       - the edge character
+  r       - the child node
   
 Returns: (VOID)
 
 --*/
 {
-  NODE  Node1;
-  NODE  Node2;
-
-  Node1           = (NODE) HASH (Parent, CharC);
-  Node2           = mNext[Node1];
-  mNext[Node1]    = Child;
-  mNext[Child]    = Node2;
-  mPrev[Node2]    = Child;
-  mPrev[Child]    = Node1;
-  mParent[Child]  = Parent;
-  mChildCount[Parent]++;
+  NODE h, t;
+  
+  h = (NODE)HASH(q, c);
+  t = mNext[h];
+  mNext[h] = r;
+  mNext[r] = t;
+  mPrev[t] = r;
+  mPrev[r] = h;
+  mParent[r] = q;
+  mChildCount[q]++;
 }
 
-STATIC
-VOID
+STATIC 
+VOID 
 Split (
   NODE Old
   )
@@ -623,30 +612,27 @@ Returns: (VOID)
 
 --*/
 {
-  NODE  New;
-  NODE  TempNode;
-
-  New               = mAvail;
-  mAvail            = mNext[New];
-  mChildCount[New]  = 0;
-  TempNode          = mPrev[Old];
-  mPrev[New]        = TempNode;
-  mNext[TempNode]   = New;
-  TempNode          = mNext[Old];
-  mNext[New]        = TempNode;
-  mPrev[TempNode]   = New;
-  mParent[New]      = mParent[Old];
-  mLevel[New]       = (UINT8) mMatchLen;
-  mPosition[New]    = mPos;
-  MakeChild (New, mText[mMatchPos + mMatchLen], Old);
-  MakeChild (New, mText[mPos + mMatchLen], mPos);
+  NODE New, t;
+
+  New = mAvail;
+  mAvail = mNext[New];
+  mChildCount[New] = 0;
+  t = mPrev[Old];
+  mPrev[New] = t;
+  mNext[t] = New;
+  t = mNext[Old];
+  mNext[New] = t;
+  mPrev[t] = New;
+  mParent[New] = mParent[Old];
+  mLevel[New] = (UINT8)mMatchLen;
+  mPosition[New] = mPos;
+  MakeChild(New, mText[mMatchPos + mMatchLen], Old);
+  MakeChild(New, mText[mPos + mMatchLen], mPos);
 }
 
-STATIC
-VOID
-InsertNode (
-  VOID
-  )
+STATIC 
+VOID 
+InsertNode ()
 /*++
 
 Routine Description:
@@ -659,15 +645,11 @@ Returns: (VOID)
 
 --*/
 {
-  NODE  NodeQ;
-  NODE  NodeR;
-  NODE  Index2;
-  NODE  NodeT;
-  UINT8 CharC;
-  UINT8 *t1;
-  UINT8 *t2;
+  NODE q, r, j, t;
+  UINT8 c, *t1, *t2;
 
   if (mMatchLen >= 4) {
+    
     //
     // We have just got a long match, the target tree
     // can be located by MatchPos + 1. Travese the tree
@@ -675,110 +657,97 @@ Returns: (VOID)
     // The usage of PERC_FLAG ensures proper node deletion
     // in DeleteNode() later.
     //
+    
     mMatchLen--;
-    NodeR = (NODE) ((mMatchPos + 1) | WNDSIZ);
-    NodeQ = mParent[NodeR];
-    while (NodeQ == NIL) {
-      NodeR = mNext[NodeR];
-      NodeQ = mParent[NodeR];
+    r = (INT16)((mMatchPos + 1) | WNDSIZ);
+    while ((q = mParent[r]) == NIL) {
+      r = mNext[r];
     }
-
-    while (mLevel[NodeQ] >= mMatchLen) {
-      NodeR = NodeQ;
-      NodeQ = mParent[NodeQ];
+    while (mLevel[q] >= mMatchLen) {
+      r = q;  q = mParent[q];
     }
-
-    NodeT = NodeQ;
-    while (mPosition[NodeT] < 0) {
-      mPosition[NodeT]  = mPos;
-      NodeT             = mParent[NodeT];
-    }
-
-    if (NodeT < WNDSIZ) {
-      mPosition[NodeT] = (NODE) (mPos | (UINT32) PERC_FLAG);
+    t = q;
+    while (mPosition[t] < 0) {
+      mPosition[t] = mPos;
+      t = mParent[t];
     }
+    if (t < WNDSIZ) {
+      mPosition[t] = (NODE)(mPos | PERC_FLAG);
+    }    
   } else {
+    
     //
     // Locate the target tree
     //
-    NodeQ = (NODE) (mText[mPos] + WNDSIZ);
-    CharC = mText[mPos + 1];
-    NodeR = Child (NodeQ, CharC);
-    if (NodeR == NIL) {
-      MakeChild (NodeQ, CharC, mPos);
+    
+    q = (INT16)(mText[mPos] + WNDSIZ);
+    c = mText[mPos + 1];
+    if ((r = Child(q, c)) == NIL) {
+      MakeChild(q, c, mPos);
       mMatchLen = 1;
-      return ;
+      return;
     }
-
     mMatchLen = 2;
   }
+  
   //
   // Traverse down the tree to find a match.
   // Update Position value along the route.
   // Node split or creation is involved.
   //
-  for (;;) {
-    if (NodeR >= WNDSIZ) {
-      Index2    = MAXMATCH;
-      mMatchPos = NodeR;
+  
+  for ( ; ; ) {
+    if (r >= WNDSIZ) {
+      j = MAXMATCH;
+      mMatchPos = r;
     } else {
-      Index2    = mLevel[NodeR];
-      mMatchPos = (NODE) (mPosition[NodeR] & (UINT32)~PERC_FLAG);
+      j = mLevel[r];
+      mMatchPos = (NODE)(mPosition[r] & ~PERC_FLAG);
     }
-
     if (mMatchPos >= mPos) {
       mMatchPos -= WNDSIZ;
-    }
-
-    t1  = &mText[mPos + mMatchLen];
-    t2  = &mText[mMatchPos + mMatchLen];
-    while (mMatchLen < Index2) {
+    }    
+    t1 = &mText[mPos + mMatchLen];
+    t2 = &mText[mMatchPos + mMatchLen];
+    while (mMatchLen < j) {
       if (*t1 != *t2) {
-        Split (NodeR);
-        return ;
+        Split(r);
+        return;
       }
-
       mMatchLen++;
       t1++;
       t2++;
     }
-
     if (mMatchLen >= MAXMATCH) {
       break;
     }
-
-    mPosition[NodeR]  = mPos;
-    NodeQ             = NodeR;
-    NodeR             = Child (NodeQ, *t1);
-    if (NodeR == NIL) {
-      MakeChild (NodeQ, *t1, mPos);
-      return ;
+    mPosition[r] = mPos;
+    q = r;
+    if ((r = Child(q, *t1)) == NIL) {
+      MakeChild(q, *t1, mPos);
+      return;
     }
-
     mMatchLen++;
   }
-
-  NodeT           = mPrev[NodeR];
-  mPrev[mPos]     = NodeT;
-  mNext[NodeT]    = mPos;
-  NodeT           = mNext[NodeR];
-  mNext[mPos]     = NodeT;
-  mPrev[NodeT]    = mPos;
-  mParent[mPos]   = NodeQ;
-  mParent[NodeR]  = NIL;
-
+  t = mPrev[r];
+  mPrev[mPos] = t;
+  mNext[t] = mPos;
+  t = mNext[r];
+  mNext[mPos] = t;
+  mPrev[t] = mPos;
+  mParent[mPos] = q;
+  mParent[r] = NIL;
+  
   //
   // Special usage of 'next'
   //
-  mNext[NodeR] = mPos;
-
+  mNext[r] = mPos;
+  
 }
 
-STATIC
-VOID
-DeleteNode (
-  VOID
-  )
+STATIC 
+VOID 
+DeleteNode ()
 /*++
 
 Routine Description:
@@ -792,88 +761,67 @@ Returns: (VOID)
 
 --*/
 {
-  NODE  NodeQ;
-  NODE  NodeR;
-  NODE  NodeS;
-  NODE  NodeT;
-  NODE  NodeU;
+  NODE q, r, s, t, u;
 
   if (mParent[mPos] == NIL) {
-    return ;
+    return;
   }
-
-  NodeR         = mPrev[mPos];
-  NodeS         = mNext[mPos];
-  mNext[NodeR]  = NodeS;
-  mPrev[NodeS]  = NodeR;
-  NodeR         = mParent[mPos];
+  
+  r = mPrev[mPos];
+  s = mNext[mPos];
+  mNext[r] = s;
+  mPrev[s] = r;
+  r = mParent[mPos];
   mParent[mPos] = NIL;
-  if (NodeR >= WNDSIZ) {
-    return ;
-  }
-
-  mChildCount[NodeR]--;
-  if (mChildCount[NodeR] > 1) {
-    return ;
-  }
-
-  NodeT = (NODE) (mPosition[NodeR] & (UINT32)~PERC_FLAG);
-  if (NodeT >= mPos) {
-    NodeT -= WNDSIZ;
-  }
-
-  NodeS = NodeT;
-  NodeQ = mParent[NodeR];
-  NodeU = mPosition[NodeQ];
-  while (NodeU & (UINT32) PERC_FLAG) {
-    NodeU &= (UINT32)~PERC_FLAG;
-    if (NodeU >= mPos) {
-      NodeU -= WNDSIZ;
+  if (r >= WNDSIZ || --mChildCount[r] > 1) {
+    return;
+  }
+  t = (NODE)(mPosition[r] & ~PERC_FLAG);
+  if (t >= mPos) {
+    t -= WNDSIZ;
+  }
+  s = t;
+  q = mParent[r];
+  while ((u = mPosition[q]) & PERC_FLAG) {
+    u &= ~PERC_FLAG;
+    if (u >= mPos) {
+      u -= WNDSIZ;
     }
-
-    if (NodeU > NodeS) {
-      NodeS = NodeU;
+    if (u > s) {
+      s = u;
     }
-
-    mPosition[NodeQ]  = (NODE) (NodeS | WNDSIZ);
-    NodeQ             = mParent[NodeQ];
-    NodeU             = mPosition[NodeQ];
+    mPosition[q] = (INT16)(s | WNDSIZ);
+    q = mParent[q];
   }
-
-  if (NodeQ < WNDSIZ) {
-    if (NodeU >= mPos) {
-      NodeU -= WNDSIZ;
+  if (q < WNDSIZ) {
+    if (u >= mPos) {
+      u -= WNDSIZ;
     }
-
-    if (NodeU > NodeS) {
-      NodeS = NodeU;
+    if (u > s) {
+      s = u;
     }
-
-    mPosition[NodeQ] = (NODE) (NodeS | WNDSIZ | (UINT32) PERC_FLAG);
-  }
-
-  NodeS           = Child (NodeR, mText[NodeT + mLevel[NodeR]]);
-  NodeT           = mPrev[NodeS];
-  NodeU           = mNext[NodeS];
-  mNext[NodeT]    = NodeU;
-  mPrev[NodeU]    = NodeT;
-  NodeT           = mPrev[NodeR];
-  mNext[NodeT]    = NodeS;
-  mPrev[NodeS]    = NodeT;
-  NodeT           = mNext[NodeR];
-  mPrev[NodeT]    = NodeS;
-  mNext[NodeS]    = NodeT;
-  mParent[NodeS]  = mParent[NodeR];
-  mParent[NodeR]  = NIL;
-  mNext[NodeR]    = mAvail;
-  mAvail          = NodeR;
+    mPosition[q] = (INT16)(s | WNDSIZ | PERC_FLAG);
+  }
+  s = Child(r, mText[t + mLevel[r]]);
+  t = mPrev[s];
+  u = mNext[s];
+  mNext[t] = u;
+  mPrev[u] = t;
+  t = mPrev[r];
+  mNext[t] = s;
+  mPrev[s] = t;
+  t = mNext[r];
+  mPrev[t] = s;
+  mNext[s] = t;
+  mParent[s] = mParent[r];
+  mParent[r] = NIL;
+  mNext[r] = mAvail;
+  mAvail = r;
 }
 
-STATIC
-VOID
-GetNextMatch (
-  VOID
-  )
+STATIC 
+VOID 
+GetNextMatch ()
 /*++
 
 Routine Description:
@@ -887,26 +835,22 @@ Returns: (VOID)
 
 --*/
 {
-  INT32 Number;
+  INT32 n;
 
   mRemainder--;
-  mPos++;
-  if (mPos == WNDSIZ * 2) {
-    memmove (&mText[0], &mText[WNDSIZ], WNDSIZ + MAXMATCH);
-    Number = FreadCrc (&mText[WNDSIZ + MAXMATCH], WNDSIZ);
-    mRemainder += Number;
+  if (++mPos == WNDSIZ * 2) {
+    memmove(&mText[0], &mText[WNDSIZ], WNDSIZ + MAXMATCH);
+    n = FreadCrc(&mText[WNDSIZ + MAXMATCH], WNDSIZ);
+    mRemainder += n;
     mPos = WNDSIZ;
   }
-
-  DeleteNode ();
-  InsertNode ();
+  DeleteNode();
+  InsertNode();
 }
 
 STATIC
 EFI_STATUS
-Encode (
-  VOID
-  )
+Encode ()
 /*++
 
 Routine Description:
@@ -926,77 +870,65 @@ Returns:
   INT32       LastMatchLen;
   NODE        LastMatchPos;
 
-  Status = AllocateMemory ();
-  if (EFI_ERROR (Status)) {
-    FreeMemory ();
+  Status = AllocateMemory();
+  if (EFI_ERROR(Status)) {
+    FreeMemory();
     return Status;
   }
 
-  InitSlide ();
-
-  HufEncodeStart ();
-
-  mRemainder  = FreadCrc (&mText[WNDSIZ], WNDSIZ + MAXMATCH);
+  InitSlide();
+  
+  HufEncodeStart();
 
-  mMatchLen   = 0;
-  mPos        = WNDSIZ;
-  InsertNode ();
+  mRemainder = FreadCrc(&mText[WNDSIZ], WNDSIZ + MAXMATCH);
+  
+  mMatchLen = 0;
+  mPos = WNDSIZ;
+  InsertNode();
   if (mMatchLen > mRemainder) {
     mMatchLen = mRemainder;
   }
-
   while (mRemainder > 0) {
-    LastMatchLen  = mMatchLen;
-    LastMatchPos  = mMatchPos;
-    GetNextMatch ();
+    LastMatchLen = mMatchLen;
+    LastMatchPos = mMatchPos;
+    GetNextMatch();
     if (mMatchLen > mRemainder) {
       mMatchLen = mRemainder;
     }
-
+    
     if (mMatchLen > LastMatchLen || LastMatchLen < THRESHOLD) {
+      
       //
       // Not enough benefits are gained by outputting a pointer,
       // so just output the original character
       //
-      Output (mText[mPos - 1], 0);
-
+      
+      Output(mText[mPos - 1], 0);
     } else {
-
-      if (LastMatchLen == THRESHOLD) {
-        if (((mPos - LastMatchPos - 2) & (WNDSIZ - 1)) > (1U << 11)) {
-          Output (mText[mPos - 1], 0);
-          continue;
-        }
-      }
+      
       //
       // Outputting a pointer is beneficial enough, do it.
       //
-      Output (
-        LastMatchLen + (UINT8_MAX + 1 - THRESHOLD),
-        (mPos - LastMatchPos - 2) & (WNDSIZ - 1)
-        );
-      LastMatchLen--;
-      while (LastMatchLen > 0) {
-        GetNextMatch ();
-        LastMatchLen--;
+      
+      Output(LastMatchLen + (UINT8_MAX + 1 - THRESHOLD),
+             (mPos - LastMatchPos - 2) & (WNDSIZ - 1));
+      while (--LastMatchLen > 0) {
+        GetNextMatch();
       }
-
       if (mMatchLen > mRemainder) {
         mMatchLen = mRemainder;
       }
     }
   }
-
-  HufEncodeEnd ();
-  FreeMemory ();
+  
+  HufEncodeEnd();
+  FreeMemory();
   return EFI_SUCCESS;
 }
 
-STATIC
-VOID
-CountTFreq (
-  VOID
-  )
+STATIC 
+VOID 
+CountTFreq ()
 /*++
 
 Routine Description:
@@ -1009,32 +941,26 @@ Returns: (VOID)
 
 --*/
 {
-  INT32 Index;
-  INT32 Index3;
-  INT32 Number;
-  INT32 Count;
+  INT32 i, k, n, Count;
 
-  for (Index = 0; Index < NT; Index++) {
-    mTFreq[Index] = 0;
+  for (i = 0; i < NT; i++) {
+    mTFreq[i] = 0;
   }
-
-  Number = NC;
-  while (Number > 0 && mCLen[Number - 1] == 0) {
-    Number--;
+  n = NC;
+  while (n > 0 && mCLen[n - 1] == 0) {
+    n--;
   }
-
-  Index = 0;
-  while (Index < Number) {
-    Index3 = mCLen[Index++];
-    if (Index3 == 0) {
+  i = 0;
+  while (i < n) {
+    k = mCLen[i++];
+    if (k == 0) {
       Count = 1;
-      while (Index < Number && mCLen[Index] == 0) {
-        Index++;
+      while (i < n && mCLen[i] == 0) {
+        i++;
         Count++;
       }
-
       if (Count <= 2) {
-        mTFreq[0] = (UINT16) (mTFreq[0] + Count);
+        mTFreq[0] = (UINT16)(mTFreq[0] + Count);
       } else if (Count <= 18) {
         mTFreq[1]++;
       } else if (Count == 19) {
@@ -1044,16 +970,16 @@ Returns: (VOID)
         mTFreq[2]++;
       }
     } else {
-      mTFreq[Index3 + 2]++;
+      mTFreq[k + 2]++;
     }
   }
 }
 
-STATIC
-VOID
+STATIC 
+VOID 
 WritePTLen (
-  IN INT32 Number,
-  IN INT32 nbit,
+  IN INT32 n, 
+  IN INT32 nbit, 
   IN INT32 Special
   )
 /*++
@@ -1064,7 +990,7 @@ Routine Description:
   
 Arguments:
 
-  Number       - the number of symbols
+  n       - the number of symbols
   nbit    - the number of bits needed to represent 'n'
   Special - the special symbol that needs to be take care of
   
@@ -1072,38 +998,32 @@ Returns: (VOID)
 
 --*/
 {
-  INT32 Index;
-  INT32 Index3;
+  INT32 i, k;
 
-  while (Number > 0 && mPTLen[Number - 1] == 0) {
-    Number--;
+  while (n > 0 && mPTLen[n - 1] == 0) {
+    n--;
   }
-
-  PutBits (nbit, Number);
-  Index = 0;
-  while (Index < Number) {
-    Index3 = mPTLen[Index++];
-    if (Index3 <= 6) {
-      PutBits (3, Index3);
+  PutBits(nbit, n);
+  i = 0;
+  while (i < n) {
+    k = mPTLen[i++];
+    if (k <= 6) {
+      PutBits(3, k);
     } else {
-      PutBits (Index3 - 3, (1U << (Index3 - 3)) - 2);
+      PutBits(k - 3, (1U << (k - 3)) - 2);
     }
-
-    if (Index == Special) {
-      while (Index < 6 && mPTLen[Index] == 0) {
-        Index++;
+    if (i == Special) {
+      while (i < 6 && mPTLen[i] == 0) {
+        i++;
       }
-
-      PutBits (2, (Index - 3) & 3);
+      PutBits(2, (i - 3) & 3);
     }
   }
 }
 
-STATIC
-VOID
-WriteCLen (
-  VOID
-  )
+STATIC 
+VOID 
+WriteCLen ()
 /*++
 
 Routine Description:
@@ -1116,172 +1036,146 @@ Returns: (VOID)
 
 --*/
 {
-  INT32 Index;
-  INT32 Index3;
-  INT32 Number;
-  INT32 Count;
-
-  Number = NC;
-  while (Number > 0 && mCLen[Number - 1] == 0) {
-    Number--;
-  }
+  INT32 i, k, n, Count;
 
-  PutBits (CBIT, Number);
-  Index = 0;
-  while (Index < Number) {
-    Index3 = mCLen[Index++];
-    if (Index3 == 0) {
+  n = NC;
+  while (n > 0 && mCLen[n - 1] == 0) {
+    n--;
+  }
+  PutBits(CBIT, n);
+  i = 0;
+  while (i < n) {
+    k = mCLen[i++];
+    if (k == 0) {
       Count = 1;
-      while (Index < Number && mCLen[Index] == 0) {
-        Index++;
+      while (i < n && mCLen[i] == 0) {
+        i++;
         Count++;
       }
-
       if (Count <= 2) {
-        for (Index3 = 0; Index3 < Count; Index3++) {
-          PutBits (mPTLen[0], mPTCode[0]);
+        for (k = 0; k < Count; k++) {
+          PutBits(mPTLen[0], mPTCode[0]);
         }
       } else if (Count <= 18) {
-        PutBits (mPTLen[1], mPTCode[1]);
-        PutBits (4, Count - 3);
+        PutBits(mPTLen[1], mPTCode[1]);
+        PutBits(4, Count - 3);
       } else if (Count == 19) {
-        PutBits (mPTLen[0], mPTCode[0]);
-        PutBits (mPTLen[1], mPTCode[1]);
-        PutBits (4, 15);
+        PutBits(mPTLen[0], mPTCode[0]);
+        PutBits(mPTLen[1], mPTCode[1]);
+        PutBits(4, 15);
       } else {
-        PutBits (mPTLen[2], mPTCode[2]);
-        PutBits (CBIT, Count - 20);
+        PutBits(mPTLen[2], mPTCode[2]);
+        PutBits(CBIT, Count - 20);
       }
     } else {
-      PutBits (mPTLen[Index3 + 2], mPTCode[Index3 + 2]);
+      PutBits(mPTLen[k + 2], mPTCode[k + 2]);
     }
   }
 }
 
-STATIC
-VOID
+STATIC 
+VOID 
 EncodeC (
-  IN INT32 Value
+  IN INT32 c
   )
 {
-  PutBits (mCLen[Value], mCCode[Value]);
+  PutBits(mCLen[c], mCCode[c]);
 }
 
-STATIC
-VOID
+STATIC 
+VOID 
 EncodeP (
-  IN UINT32 Value
+  IN UINT32 p
   )
 {
-  UINT32  Index;
-  UINT32  NodeQ;
-
-  Index = 0;
-  NodeQ = Value;
-  while (NodeQ) {
-    NodeQ >>= 1;
-    Index++;
-  }
+  UINT32 c, q;
 
-  PutBits (mPTLen[Index], mPTCode[Index]);
-  if (Index > 1) {
-    PutBits (Index - 1, Value & (0xFFFFFFFFU >> (32 - Index + 1)));
+  c = 0;
+  q = p;
+  while (q) {
+    q >>= 1;
+    c++;
+  }
+  PutBits(mPTLen[c], mPTCode[c]);
+  if (c > 1) {
+    PutBits(c - 1, p & (0xFFFFU >> (17 - c)));
   }
 }
 
-STATIC
-VOID
-SendBlock (
-  VOID
-  )
+STATIC 
+VOID 
+SendBlock ()
 /*++
 
 Routine Description:
 
   Huffman code the block and output it.
   
-Arguments: 
-  (VOID)
+Argument: (VOID)
 
-Returns: 
-  (VOID)
+Returns: (VOID)
 
 --*/
 {
-  UINT32  Index;
-  UINT32  Index2;
-  UINT32  Index3;
-  UINT32  Flags;
-  UINT32  Root;
-  UINT32  Pos;
-  UINT32  Size;
+  UINT32 i, k, Flags, Root, Pos, Size;
   Flags = 0;
 
-  Root  = MakeTree (NC, mCFreq, mCLen, mCCode);
-  Size  = mCFreq[Root];
-  PutBits (16, Size);
+  Root = MakeTree(NC, mCFreq, mCLen, mCCode);
+  Size = mCFreq[Root];
+  PutBits(16, Size);
   if (Root >= NC) {
-    CountTFreq ();
-    Root = MakeTree (NT, mTFreq, mPTLen, mPTCode);
+    CountTFreq();
+    Root = MakeTree(NT, mTFreq, mPTLen, mPTCode);
     if (Root >= NT) {
-      WritePTLen (NT, TBIT, 3);
+      WritePTLen(NT, TBIT, 3);
     } else {
-      PutBits (TBIT, 0);
-      PutBits (TBIT, Root);
+      PutBits(TBIT, 0);
+      PutBits(TBIT, Root);
     }
-
-    WriteCLen ();
+    WriteCLen();
   } else {
-    PutBits (TBIT, 0);
-    PutBits (TBIT, 0);
-    PutBits (CBIT, 0);
-    PutBits (CBIT, Root);
+    PutBits(TBIT, 0);
+    PutBits(TBIT, 0);
+    PutBits(CBIT, 0);
+    PutBits(CBIT, Root);
   }
-
-  Root = MakeTree (NP, mPFreq, mPTLen, mPTCode);
+  Root = MakeTree(NP, mPFreq, mPTLen, mPTCode);
   if (Root >= NP) {
-    WritePTLen (NP, PBIT, -1);
+    WritePTLen(NP, PBIT, -1);
   } else {
-    PutBits (PBIT, 0);
-    PutBits (PBIT, Root);
+    PutBits(PBIT, 0);
+    PutBits(PBIT, Root);
   }
-
   Pos = 0;
-  for (Index = 0; Index < Size; Index++) {
-    if (Index % UINT8_BIT == 0) {
+  for (i = 0; i < Size; i++) {
+    if (i % UINT8_BIT == 0) {
       Flags = mBuf[Pos++];
     } else {
       Flags <<= 1;
     }
-
     if (Flags & (1U << (UINT8_BIT - 1))) {
-      EncodeC (mBuf[Pos++] + (1U << UINT8_BIT));
-      Index3 = mBuf[Pos++];
-      for (Index2 = 0; Index2 < 3; Index2++) {
-        Index3 <<= UINT8_BIT;
-        Index3 += mBuf[Pos++];
-      }
-
-      EncodeP (Index3);
+      EncodeC(mBuf[Pos++] + (1U << UINT8_BIT));
+      k = mBuf[Pos++] << UINT8_BIT;
+      k += mBuf[Pos++];
+      EncodeP(k);
     } else {
-      EncodeC (mBuf[Pos++]);
+      EncodeC(mBuf[Pos++]);
     }
   }
-
-  for (Index = 0; Index < NC; Index++) {
-    mCFreq[Index] = 0;
+  for (i = 0; i < NC; i++) {
+    mCFreq[i] = 0;
   }
-
-  for (Index = 0; Index < NP; Index++) {
-    mPFreq[Index] = 0;
+  for (i = 0; i < NP; i++) {
+    mPFreq[i] = 0;
   }
 }
 
-STATIC
-VOID
+
+STATIC 
+VOID 
 Output (
-  IN UINT32 CharC,
-  IN UINT32 Pos
+  IN UINT32 c, 
+  IN UINT32 p
   )
 /*++
 
@@ -1291,115 +1185,95 @@ Routine Description:
 
 Arguments:
 
-  CharC     - The original character or the 'String Length' element of a Pointer
-  Pos     - The 'Position' field of a Pointer
+  c     - The original character or the 'String Length' element of a Pointer
+  p     - The 'Position' field of a Pointer
 
 Returns: (VOID)
 
 --*/
 {
-  static UINT32 CPos;
+  STATIC UINT32 CPos;
 
   if ((mOutputMask >>= 1) == 0) {
     mOutputMask = 1U << (UINT8_BIT - 1);
-    //
-    // Check the buffer overflow per outputing UINT8_BIT symbols
-    // which is an Original Character or a Pointer. The biggest
-    // symbol is a Pointer which occupies 5 bytes.
-    //
-    if (mOutputPos >= mBufSiz - 5 * UINT8_BIT) {
-      SendBlock ();
+    if (mOutputPos >= mBufSiz - 3 * UINT8_BIT) {
+      SendBlock();
       mOutputPos = 0;
     }
-
-    CPos        = mOutputPos++;
-    mBuf[CPos]  = 0;
+    CPos = mOutputPos++;  
+    mBuf[CPos] = 0;
   }
-
-  mBuf[mOutputPos++] = (UINT8) CharC;
-  mCFreq[CharC]++;
-  if (CharC >= (1U << UINT8_BIT)) {
+  mBuf[mOutputPos++] = (UINT8) c;
+  mCFreq[c]++;
+  if (c >= (1U << UINT8_BIT)) {
     mBuf[CPos] |= mOutputMask;
-    mBuf[mOutputPos++]  = (UINT8) (Pos >> 24);
-    mBuf[mOutputPos++]  = (UINT8) (Pos >> 16);
-    mBuf[mOutputPos++]  = (UINT8) (Pos >> (UINT8_BIT));
-    mBuf[mOutputPos++]  = (UINT8) Pos;
-    CharC               = 0;
-    while (Pos) {
-      Pos >>= 1;
-      CharC++;
+    mBuf[mOutputPos++] = (UINT8)(p >> UINT8_BIT);
+    mBuf[mOutputPos++] = (UINT8) p;
+    c = 0;
+    while (p) {
+      p >>= 1;
+      c++;
     }
-
-    mPFreq[CharC]++;
+    mPFreq[c]++;
   }
 }
 
 STATIC
 VOID
-HufEncodeStart (
-  VOID
-  )
+HufEncodeStart ()
 {
-  INT32 Index;
+  INT32 i;
 
-  for (Index = 0; Index < NC; Index++) {
-    mCFreq[Index] = 0;
+  for (i = 0; i < NC; i++) {
+    mCFreq[i] = 0;
   }
-
-  for (Index = 0; Index < NP; Index++) {
-    mPFreq[Index] = 0;
+  for (i = 0; i < NP; i++) {
+    mPFreq[i] = 0;
   }
-
   mOutputPos = mOutputMask = 0;
-  InitPutBits ();
-  return ;
+  InitPutBits();
+  return;
 }
 
-STATIC
-VOID
-HufEncodeEnd (
-  VOID
-  )
+STATIC 
+VOID 
+HufEncodeEnd ()
 {
-  SendBlock ();
-
+  SendBlock();
+  
   //
   // Flush remaining bits
   //
-  PutBits (UINT8_BIT - 1, 0);
-
-  return ;
+  PutBits(UINT8_BIT - 1, 0);
+  
+  return;
 }
 
-STATIC
-VOID
-MakeCrcTable (
-  VOID
-  )
+
+STATIC 
+VOID 
+MakeCrcTable ()
 {
-  UINT32  Index;
-  UINT32  Index2;
-  UINT32  Temp;
-
-  for (Index = 0; Index <= UINT8_MAX; Index++) {
-    Temp = Index;
-    for (Index2 = 0; Index2 < UINT8_BIT; Index2++) {
-      if (Temp & 1) {
-        Temp = (Temp >> 1) ^ CRCPOLY;
+  UINT32 i, j, r;
+
+  for (i = 0; i <= UINT8_MAX; i++) {
+    r = i;
+    for (j = 0; j < UINT8_BIT; j++) {
+      if (r & 1) {
+        r = (r >> 1) ^ CRCPOLY;
       } else {
-        Temp >>= 1;
+        r >>= 1;
       }
     }
-
-    mCrcTable[Index] = (UINT16) Temp;
+    mCrcTable[i] = (UINT16)r;    
   }
 }
 
-STATIC
-VOID
+STATIC 
+VOID 
 PutBits (
-  IN INT32  Number,
-  IN UINT32 Value
+  IN INT32 n, 
+  IN UINT32 x
   )
 /*++
 
@@ -1407,39 +1281,47 @@ Routine Description:
 
   Outputs rightmost n bits of x
 
-Arguments:
+Argments:
 
-  Number   - the rightmost n bits of the data is used
+  n   - the rightmost n bits of the data is used
   x   - the data 
 
 Returns: (VOID)
 
 --*/
 {
-  UINT8 Temp;
-
-  while (Number >= mBitCount) {
-    //
-    // Number -= mBitCount should never equal to 32
-    //
-    Temp = (UINT8) (mSubBitBuf | (Value >> (Number -= mBitCount)));
+  UINT8 Temp;  
+  
+  if (n < mBitCount) {
+    mSubBitBuf |= x << (mBitCount -= n);
+  } else {
+      
+    Temp = (UINT8)(mSubBitBuf | (x >> (n -= mBitCount)));
     if (mDst < mDstUpperLimit) {
       *mDst++ = Temp;
     }
-
     mCompSize++;
-    mSubBitBuf  = 0;
-    mBitCount   = UINT8_BIT;
-  }
 
-  mSubBitBuf |= Value << (mBitCount -= Number);
+    if (n < UINT8_BIT) {
+      mSubBitBuf = x << (mBitCount = UINT8_BIT - n);
+    } else {
+        
+      Temp = (UINT8)(x >> (n - UINT8_BIT));
+      if (mDst < mDstUpperLimit) {
+        *mDst++ = Temp;
+      }
+      mCompSize++;
+      
+      mSubBitBuf = x << (mBitCount = 2 * UINT8_BIT - n);
+    }
+  }
 }
 
-STATIC
-INT32
+STATIC 
+INT32 
 FreadCrc (
-  OUT UINT8 *Pointer,
-  IN  INT32 Number
+  OUT UINT8 *p, 
+  IN  INT32 n
   )
 /*++
 
@@ -1449,8 +1331,8 @@ Routine Description:
   
 Arguments:
 
-  Pointer   - the buffer to hold the data
-  Number   - number of bytes to read
+  p   - the buffer to hold the data
+  n   - number of bytes to read
 
 Returns:
 
@@ -1458,39 +1340,34 @@ Returns:
   
 --*/
 {
-  INT32 Index;
+  INT32 i;
 
-  for (Index = 0; mSrc < mSrcUpperLimit && Index < Number; Index++) {
-    *Pointer++ = *mSrc++;
+  for (i = 0; mSrc < mSrcUpperLimit && i < n; i++) {
+    *p++ = *mSrc++;
   }
+  n = i;
 
-  Number = Index;
-
-  Pointer -= Number;
-  mOrigSize += Number;
-  Index--;
-  while (Index >= 0) {
-    UPDATE_CRC (*Pointer++);
-    Index--;
+  p -= n;
+  mOrigSize += n;
+  while (--i >= 0) {
+    UPDATE_CRC(*p++);
   }
-
-  return Number;
+  return n;
 }
 
-STATIC
-VOID
-InitPutBits (
-  VOID
-  )
+
+STATIC 
+VOID 
+InitPutBits ()
 {
-  mBitCount   = UINT8_BIT;
-  mSubBitBuf  = 0;
+  mBitCount = UINT8_BIT;  
+  mSubBitBuf = 0;
 }
 
-STATIC
-VOID
+STATIC 
+VOID 
 CountLen (
-  IN INT32 Index
+  IN INT32 i
   )
 /*++
 
@@ -1500,26 +1377,26 @@ Routine Description:
   
 Arguments:
 
-  Index   - the top node
+  i   - the top node
   
 Returns: (VOID)
 
 --*/
 {
-  static INT32  Depth = 0;
+  STATIC INT32 Depth = 0;
 
-  if (Index < mN) {
+  if (i < mN) {
     mLenCnt[(Depth < 16) ? Depth : 16]++;
   } else {
     Depth++;
-    CountLen (mLeft[Index]);
-    CountLen (mRight[Index]);
+    CountLen(mLeft [i]);
+    CountLen(mRight[i]);
     Depth--;
   }
 }
 
-STATIC
-VOID
+STATIC 
+VOID 
 MakeLen (
   IN INT32 Root
   )
@@ -1532,91 +1409,76 @@ Routine Description:
 Arguments:
 
   Root   - the root of the tree
-  
-Returns:
-
-  VOID
 
 --*/
 {
-  INT32   Index;
-  INT32   Index3;
-  UINT32  Cum;
+  INT32 i, k;
+  UINT32 Cum;
 
-  for (Index = 0; Index <= 16; Index++) {
-    mLenCnt[Index] = 0;
+  for (i = 0; i <= 16; i++) {
+    mLenCnt[i] = 0;
   }
-
-  CountLen (Root);
-
+  CountLen(Root);
+  
   //
   // Adjust the length count array so that
   // no code will be generated longer than its designated length
   //
+  
   Cum = 0;
-  for (Index = 16; Index > 0; Index--) {
-    Cum += mLenCnt[Index] << (16 - Index);
+  for (i = 16; i > 0; i--) {
+    Cum += mLenCnt[i] << (16 - i);
   }
-
   while (Cum != (1U << 16)) {
     mLenCnt[16]--;
-    for (Index = 15; Index > 0; Index--) {
-      if (mLenCnt[Index] != 0) {
-        mLenCnt[Index]--;
-        mLenCnt[Index + 1] += 2;
+    for (i = 15; i > 0; i--) {
+      if (mLenCnt[i] != 0) {
+        mLenCnt[i]--;
+        mLenCnt[i+1] += 2;
         break;
       }
     }
-
     Cum--;
   }
-
-  for (Index = 16; Index > 0; Index--) {
-    Index3 = mLenCnt[Index];
-    Index3--;
-    while (Index3 >= 0) {
-      mLen[*mSortPtr++] = (UINT8) Index;
-      Index3--;
+  for (i = 16; i > 0; i--) {
+    k = mLenCnt[i];
+    while (--k >= 0) {
+      mLen[*mSortPtr++] = (UINT8)i;
     }
   }
 }
 
-STATIC
-VOID
+STATIC 
+VOID 
 DownHeap (
-  IN INT32 Index
+  IN INT32 i
   )
 {
-  INT32 Index2;
-  INT32 Index3;
+  INT32 j, k;
 
   //
-  // priority queue: send Index-th entry down heap
+  // priority queue: send i-th entry down heap
   //
-  Index3  = mHeap[Index];
-  Index2  = 2 * Index;
-  while (Index2 <= mHeapSize) {
-    if (Index2 < mHeapSize && mFreq[mHeap[Index2]] > mFreq[mHeap[Index2 + 1]]) {
-      Index2++;
+  
+  k = mHeap[i];
+  while ((j = 2 * i) <= mHeapSize) {
+    if (j < mHeapSize && mFreq[mHeap[j]] > mFreq[mHeap[j + 1]]) {
+      j++;
     }
-
-    if (mFreq[Index3] <= mFreq[mHeap[Index2]]) {
+    if (mFreq[k] <= mFreq[mHeap[j]]) {
       break;
     }
-
-    mHeap[Index]  = mHeap[Index2];
-    Index         = Index2;
-    Index2        = 2 * Index;
+    mHeap[i] = mHeap[j];
+    i = j;
   }
-
-  mHeap[Index] = (INT16) Index3;
+  mHeap[i] = (INT16)k;
 }
 
-STATIC
-VOID
+STATIC 
+VOID 
 MakeCode (
-  IN  INT32       Number,
-  IN  UINT8 Len[  ],
+  IN  INT32 n, 
+  IN  UINT8 Len[], 
   OUT UINT16 Code[]
   )
 /*++
@@ -1627,7 +1489,7 @@ Routine Description:
   
 Arguments:
 
-  Number     - number of symbols
+  n     - number of symbols
   Len   - the code length array
   Code  - stores codes for each symbol
 
@@ -1635,25 +1497,24 @@ Returns: (VOID)
 
 --*/
 {
-  INT32   Index;
-  UINT16  Start[18];
+  INT32    i;
+  UINT16   Start[18];
 
   Start[1] = 0;
-  for (Index = 1; Index <= 16; Index++) {
-    Start[Index + 1] = (UINT16) ((Start[Index] + mLenCnt[Index]) << 1);
+  for (i = 1; i <= 16; i++) {
+    Start[i + 1] = (UINT16)((Start[i] + mLenCnt[i]) << 1);
   }
-
-  for (Index = 0; Index < Number; Index++) {
-    Code[Index] = Start[Len[Index]]++;
+  for (i = 0; i < n; i++) {
+    Code[i] = Start[Len[i]]++;
   }
 }
 
-STATIC
-INT32
+STATIC 
+INT32 
 MakeTree (
-  IN  INT32            NParm,
-  IN  UINT16  FreqParm[],
-  OUT UINT8   LenParm[ ],
+  IN  INT32   NParm, 
+  IN  UINT16  FreqParm[], 
+  OUT UINT8   LenParm[], 
   OUT UINT16  CodeParm[]
   )
 /*++
@@ -1675,68 +1536,62 @@ Returns:
   
 --*/
 {
-  INT32 Index;
-  INT32 Index2;
-  INT32 Index3;
-  INT32 Avail;
-
+  INT32 i, j, k, Avail;
+  
   //
   // make tree, calculate len[], return root
   //
-  mN        = NParm;
-  mFreq     = FreqParm;
-  mLen      = LenParm;
-  Avail     = mN;
+
+  mN = NParm;
+  mFreq = FreqParm;
+  mLen = LenParm;
+  Avail = mN;
   mHeapSize = 0;
-  mHeap[1]  = 0;
-  for (Index = 0; Index < mN; Index++) {
-    mLen[Index] = 0;
-    if (mFreq[Index]) {
-      mHeapSize++;
-      mHeap[mHeapSize] = (INT16) Index;
-    }
+  mHeap[1] = 0;
+  for (i = 0; i < mN; i++) {
+    mLen[i] = 0;
+    if (mFreq[i]) {
+      mHeap[++mHeapSize] = (INT16)i;
+    }    
   }
-
   if (mHeapSize < 2) {
     CodeParm[mHeap[1]] = 0;
     return mHeap[1];
   }
-
-  for (Index = mHeapSize / 2; Index >= 1; Index--) {
+  for (i = mHeapSize / 2; i >= 1; i--) {
+    
     //
-    // make priority queue
+    // make priority queue 
     //
-    DownHeap (Index);
+    DownHeap(i);
   }
-
   mSortPtr = CodeParm;
   do {
-    Index = mHeap[1];
-    if (Index < mN) {
-      *mSortPtr++ = (UINT16) Index;
+    i = mHeap[1];
+    if (i < mN) {
+      *mSortPtr++ = (UINT16)i;
     }
-
     mHeap[1] = mHeap[mHeapSize--];
-    DownHeap (1);
-    Index2 = mHeap[1];
-    if (Index2 < mN) {
-      *mSortPtr++ = (UINT16) Index2;
+    DownHeap(1);
+    j = mHeap[1];
+    if (j < mN) {
+      *mSortPtr++ = (UINT16)j;
     }
-
-    Index3        = Avail++;
-    mFreq[Index3] = (UINT16) (mFreq[Index] + mFreq[Index2]);
-    mHeap[1]      = (INT16) Index3;
-    DownHeap (1);
-    mLeft[Index3]   = (UINT16) Index;
-    mRight[Index3]  = (UINT16) Index2;
+    k = Avail++;
+    mFreq[k] = (UINT16)(mFreq[i] + mFreq[j]);
+    mHeap[1] = (INT16)k;
+    DownHeap(1);
+    mLeft[k] = (UINT16)i;
+    mRight[k] = (UINT16)j;
   } while (mHeapSize > 1);
-
+  
   mSortPtr = CodeParm;
-  MakeLen (Index3);
-  MakeCode (NParm, LenParm, CodeParm);
-
+  MakeLen(k);
+  MakeCode(NParm, LenParm, CodeParm);
+  
   //
   // return root
   //
-  return Index3;
+  return k;
 }
+