cbfstool/lzma: Avoid use of typedef with structs and enums

When typedef is used with structs, enums, and to create new typenames,
readability suffers. As such, restrict use of typedefs only to
creating new data types.

The 80 character limit is intentionally ignored in this patch in order
to make reviewing easier.

Change-Id: I62660b19bccf234128930a047c754bce3ebb6cf8
Signed-off-by: Alexandru Gagniuc <mr.nuke.me@gmail.com>
Reviewed-on: http://review.coreboot.org/5070
Tested-by: build bot (Jenkins)
Reviewed-by: Paul Menzel <paulepanter@users.sourceforge.net>
Reviewed-by: Ronald G. Minnich <rminnich@gmail.com>

1 files changed, 108 insertions, 108 deletions

diff --git a/util/cbfstool/lzma/C/LzmaEnc.c b/util/cbfstool/lzma/C/LzmaEnc.c
index 83012d8a07..9b18b19688 100644
--- a/util/cbfstool/lzma/C/LzmaEnc.c
+++ b/util/cbfstool/lzma/C/LzmaEnc.c
@@ -42,7 +42,7 @@ static int ttt = 0;
 #define kNumBitPriceShiftBits 4
 #define kBitPrice (1 << kNumBitPriceShiftBits)
 
-void LzmaEncProps_Init(CLzmaEncProps *p)
+void LzmaEncProps_Init(struct CLzmaEncProps *p)
 {
   p->level = 5;
   p->dictSize = p->mc = 0;
@@ -50,7 +50,7 @@ void LzmaEncProps_Init(CLzmaEncProps *p)
   p->writeEndMark = 0;
 }
 
-void LzmaEncProps_Normalize(CLzmaEncProps *p)
+void LzmaEncProps_Normalize(struct CLzmaEncProps *p)
 {
   int level = p->level;
   if (level < 0) level = 5;
@@ -73,9 +73,9 @@ void LzmaEncProps_Normalize(CLzmaEncProps *p)
       #endif
 }
 
-uint32_t LzmaEncProps_GetDictSize(const CLzmaEncProps *props2)
+uint32_t LzmaEncProps_GetDictSize(const struct CLzmaEncProps *props2)
 {
-  CLzmaEncProps props = *props2;
+  struct CLzmaEncProps props = *props2;
   LzmaEncProps_Normalize(&props);
   return props.dictSize;
 }
@@ -139,7 +139,7 @@ static void LzmaEnc_FastPosInit(uint8_t *g_FastPos)
 
 typedef unsigned CState;
 
-typedef struct
+struct COptimal
 {
   uint32_t price;
 
@@ -153,7 +153,7 @@ typedef struct
   uint32_t posPrev;
   uint32_t backPrev;
   uint32_t backs[LZMA_NUM_REPS];
-} COptimal;
+};
 
 #define kNumOpts (1 << 12)
 
@@ -201,24 +201,24 @@ typedef struct
 
 #define kNumStates 12
 
-typedef struct
+struct CLenEnc
 {
   CLzmaProb choice;
   CLzmaProb choice2;
   CLzmaProb low[LZMA_NUM_PB_STATES_MAX << kLenNumLowBits];
   CLzmaProb mid[LZMA_NUM_PB_STATES_MAX << kLenNumMidBits];
   CLzmaProb high[kLenNumHighSymbols];
-} CLenEnc;
+};
 
-typedef struct
+struct CLenPriceEnc
 {
-  CLenEnc p;
+  struct CLenEnc p;
   uint32_t prices[LZMA_NUM_PB_STATES_MAX][kLenNumSymbolsTotal];
   uint32_t tableSize;
   uint32_t counters[LZMA_NUM_PB_STATES_MAX];
-} CLenPriceEnc;
+};
 
-typedef struct
+struct CRangeEnc
 {
   uint32_t range;
   uint8_t cache;
@@ -227,12 +227,12 @@ typedef struct
   uint8_t *buf;
   uint8_t *bufLim;
   uint8_t *bufBase;
-  ISeqOutStream *outStream;
+  struct ISeqOutStream *outStream;
   uint64_t processed;
   SRes res;
-} CRangeEnc;
+};
 
-typedef struct
+struct CSaveState
 {
   CLzmaProb *litProbs;
 
@@ -247,16 +247,16 @@ typedef struct
   CLzmaProb posEncoders[kNumFullDistances - kEndPosModelIndex];
   CLzmaProb posAlignEncoder[1 << kNumAlignBits];
 
-  CLenPriceEnc lenEnc;
-  CLenPriceEnc repLenEnc;
+  struct CLenPriceEnc lenEnc;
+  struct CLenPriceEnc repLenEnc;
 
   uint32_t reps[LZMA_NUM_REPS];
   uint32_t state;
-} CSaveState;
+};
 
-typedef struct
+struct CLzmaEnc
 {
-  IMatchFinder matchFinder;
+  struct IMatchFinder matchFinder;
   void *matchFinderObj;
 
   #ifndef _7ZIP_ST
@@ -264,7 +264,7 @@ typedef struct
   CMatchFinderMt matchFinderMt;
   #endif
 
-  CMatchFinder matchFinderBase;
+  struct CMatchFinder matchFinderBase;
 
   #ifndef _7ZIP_ST
   uint8_t pad[128];
@@ -276,7 +276,7 @@ typedef struct
   uint32_t longestMatchLength;
   uint32_t numPairs;
   uint32_t numAvail;
-  COptimal opt[kNumOpts];
+  struct COptimal opt[kNumOpts];
 
   #ifndef LZMA_LOG_BSR
   uint8_t g_FastPos[1 << kNumLogBits];
@@ -312,14 +312,14 @@ typedef struct
   CLzmaProb posEncoders[kNumFullDistances - kEndPosModelIndex];
   CLzmaProb posAlignEncoder[1 << kNumAlignBits];
 
-  CLenPriceEnc lenEnc;
-  CLenPriceEnc repLenEnc;
+  struct CLenPriceEnc lenEnc;
+  struct CLenPriceEnc repLenEnc;
 
   unsigned lclp;
 
   bool fastMode;
 
-  CRangeEnc rc;
+  struct CRangeEnc rc;
 
   bool writeEndMark;
   uint64_t nowPos64;
@@ -333,8 +333,8 @@ typedef struct
 
   int needInit;
 
-  CSaveState saveState;
-} CLzmaEnc;
+  struct CSaveState saveState;
+};
 
 /*static void LzmaEnc_SaveState(CLzmaEncHandle pp)
 {
@@ -388,10 +388,10 @@ typedef struct
   memcpy(dest->litProbs, p->litProbs, (0x300 << dest->lclp) * sizeof(CLzmaProb));
 }*/
 
-SRes LzmaEnc_SetProps(CLzmaEncHandle pp, const CLzmaEncProps *props2)
+SRes LzmaEnc_SetProps(CLzmaEncHandle pp, const struct CLzmaEncProps *props2)
 {
-  CLzmaEnc *p = (CLzmaEnc *)pp;
-  CLzmaEncProps props = *props2;
+  struct CLzmaEnc *p = (struct CLzmaEnc *)pp;
+  struct CLzmaEncProps props = *props2;
   LzmaEncProps_Normalize(&props);
 
   if (props.lc > LZMA_LC_MAX || props.lp > LZMA_LP_MAX || props.pb > LZMA_PB_MAX ||
@@ -453,7 +453,7 @@ static const int kShortRepNextStates[kNumStates]= {9, 9, 9, 9, 9, 9, 9, 11, 11,
 
 #define kInfinityPrice (1 << 30)
 
-static void RangeEnc_Construct(CRangeEnc *p)
+static void RangeEnc_Construct(struct CRangeEnc *p)
 {
   p->outStream = 0;
   p->bufBase = 0;
@@ -462,7 +462,7 @@ static void RangeEnc_Construct(CRangeEnc *p)
 #define RangeEnc_GetProcessed(p) ((p)->processed + ((p)->buf - (p)->bufBase) + (p)->cacheSize)
 
 #define RC_BUF_SIZE (1 << 16)
-static int RangeEnc_Alloc(CRangeEnc *p, ISzAlloc *alloc)
+static int RangeEnc_Alloc(struct CRangeEnc *p, struct ISzAlloc *alloc)
 {
   if (p->bufBase == 0)
   {
@@ -474,13 +474,13 @@ static int RangeEnc_Alloc(CRangeEnc *p, ISzAlloc *alloc)
   return 1;
 }
 
-static void RangeEnc_Free(CRangeEnc *p, ISzAlloc *alloc)
+static void RangeEnc_Free(struct CRangeEnc *p, struct ISzAlloc *alloc)
 {
   alloc->Free(alloc, p->bufBase);
   p->bufBase = 0;
 }
 
-static void RangeEnc_Init(CRangeEnc *p)
+static void RangeEnc_Init(struct CRangeEnc *p)
 {
   /* Stream.Init(); */
   p->low = 0;
@@ -494,7 +494,7 @@ static void RangeEnc_Init(CRangeEnc *p)
   p->res = SZ_OK;
 }
 
-static void RangeEnc_FlushStream(CRangeEnc *p)
+static void RangeEnc_FlushStream(struct CRangeEnc *p)
 {
   size_t num;
   if (p->res != SZ_OK)
@@ -506,7 +506,7 @@ static void RangeEnc_FlushStream(CRangeEnc *p)
   p->buf = p->bufBase;
 }
 
-static void RangeEnc_ShiftLow(CRangeEnc *p)
+static void RangeEnc_ShiftLow(struct CRangeEnc *p)
 {
   if ((uint32_t)p->low < (uint32_t)0xFF000000 || (int)(p->low >> 32) != 0)
   {
@@ -527,14 +527,14 @@ static void RangeEnc_ShiftLow(CRangeEnc *p)
   p->low = (uint32_t)p->low << 8;
 }
 
-static void RangeEnc_FlushData(CRangeEnc *p)
+static void RangeEnc_FlushData(struct CRangeEnc *p)
 {
   int i;
   for (i = 0; i < 5; i++)
     RangeEnc_ShiftLow(p);
 }
 
-static void RangeEnc_EncodeDirectBits(CRangeEnc *p, uint32_t value, int numBits)
+static void RangeEnc_EncodeDirectBits(struct CRangeEnc *p, uint32_t value, int numBits)
 {
   do
   {
@@ -549,7 +549,7 @@ static void RangeEnc_EncodeDirectBits(CRangeEnc *p, uint32_t value, int numBits)
   while (numBits != 0);
 }
 
-static void RangeEnc_EncodeBit(CRangeEnc *p, CLzmaProb *prob, uint32_t symbol)
+static void RangeEnc_EncodeBit(struct CRangeEnc *p, CLzmaProb *prob, uint32_t symbol)
 {
   uint32_t ttt = *prob;
   uint32_t newBound = (p->range >> kNumBitModelTotalBits) * ttt;
@@ -572,7 +572,7 @@ static void RangeEnc_EncodeBit(CRangeEnc *p, CLzmaProb *prob, uint32_t symbol)
   }
 }
 
-static void LitEnc_Encode(CRangeEnc *p, CLzmaProb *probs, uint32_t symbol)
+static void LitEnc_Encode(struct CRangeEnc *p, CLzmaProb *probs, uint32_t symbol)
 {
   symbol |= 0x100;
   do
@@ -583,7 +583,7 @@ static void LitEnc_Encode(CRangeEnc *p, CLzmaProb *probs, uint32_t symbol)
   while (symbol < 0x10000);
 }
 
-static void LitEnc_EncodeMatched(CRangeEnc *p, CLzmaProb *probs, uint32_t symbol, uint32_t matchuint8_t)
+static void LitEnc_EncodeMatched(struct CRangeEnc *p, CLzmaProb *probs, uint32_t symbol, uint32_t matchuint8_t)
 {
   uint32_t offs = 0x100;
   symbol |= 0x100;
@@ -663,7 +663,7 @@ static uint32_t LitEnc_GetPriceMatched(const CLzmaProb *probs, uint32_t symbol,
 }
 
 
-static void RcTree_Encode(CRangeEnc *rc, CLzmaProb *probs, int numBitLevels, uint32_t symbol)
+static void RcTree_Encode(struct CRangeEnc *rc, CLzmaProb *probs, int numBitLevels, uint32_t symbol)
 {
   uint32_t m = 1;
   int i;
@@ -677,7 +677,7 @@ static void RcTree_Encode(CRangeEnc *rc, CLzmaProb *probs, int numBitLevels, uin
   }
 }
 
-static void RcTree_ReverseEncode(CRangeEnc *rc, CLzmaProb *probs, int numBitLevels, uint32_t symbol)
+static void RcTree_ReverseEncode(struct CRangeEnc *rc, CLzmaProb *probs, int numBitLevels, uint32_t symbol)
 {
   uint32_t m = 1;
   int i;
@@ -718,7 +718,7 @@ static uint32_t RcTree_ReverseGetPrice(const CLzmaProb *probs, int numBitLevels,
 }
 
 
-static void LenEnc_Init(CLenEnc *p)
+static void LenEnc_Init(struct CLenEnc *p)
 {
   unsigned i;
   p->choice = p->choice2 = kProbInitValue;
@@ -730,7 +730,7 @@ static void LenEnc_Init(CLenEnc *p)
     p->high[i] = kProbInitValue;
 }
 
-static void LenEnc_Encode(CLenEnc *p, CRangeEnc *rc, uint32_t symbol, uint32_t posState)
+static void LenEnc_Encode(struct CLenEnc *p, struct CRangeEnc *rc, uint32_t symbol, uint32_t posState)
 {
   if (symbol < kLenNumLowSymbols)
   {
@@ -753,7 +753,7 @@ static void LenEnc_Encode(CLenEnc *p, CRangeEnc *rc, uint32_t symbol, uint32_t p
   }
 }
 
-static void LenEnc_SetPrices(CLenEnc *p, uint32_t posState, uint32_t numSymbols, uint32_t *prices, uint32_t *ProbPrices)
+static void LenEnc_SetPrices(struct CLenEnc *p, uint32_t posState, uint32_t numSymbols, uint32_t *prices, uint32_t *ProbPrices)
 {
   uint32_t a0 = GET_PRICE_0a(p->choice);
   uint32_t a1 = GET_PRICE_1a(p->choice);
@@ -776,20 +776,20 @@ static void LenEnc_SetPrices(CLenEnc *p, uint32_t posState, uint32_t numSymbols,
     prices[i] = b1 + RcTree_GetPrice(p->high, kLenNumHighBits, i - kLenNumLowSymbols - kLenNumMidSymbols, ProbPrices);
 }
 
-static void LenPriceEnc_UpdateTable(CLenPriceEnc *p, uint32_t posState, uint32_t *ProbPrices)
+static void LenPriceEnc_UpdateTable(struct CLenPriceEnc *p, uint32_t posState, uint32_t *ProbPrices)
 {
   LenEnc_SetPrices(&p->p, posState, p->tableSize, p->prices[posState], ProbPrices);
   p->counters[posState] = p->tableSize;
 }
 
-static void LenPriceEnc_UpdateTables(CLenPriceEnc *p, uint32_t numPosStates, uint32_t *ProbPrices)
+static void LenPriceEnc_UpdateTables(struct CLenPriceEnc *p, uint32_t numPosStates, uint32_t *ProbPrices)
 {
   uint32_t posState;
   for (posState = 0; posState < numPosStates; posState++)
     LenPriceEnc_UpdateTable(p, posState, ProbPrices);
 }
 
-static void LenEnc_Encode2(CLenPriceEnc *p, CRangeEnc *rc, uint32_t symbol, uint32_t posState, bool updatePrice, uint32_t *ProbPrices)
+static void LenEnc_Encode2(struct CLenPriceEnc *p, struct CRangeEnc *rc, uint32_t symbol, uint32_t posState, bool updatePrice, uint32_t *ProbPrices)
 {
   LenEnc_Encode(&p->p, rc, symbol, posState);
   if (updatePrice)
@@ -800,7 +800,7 @@ static void LenEnc_Encode2(CLenPriceEnc *p, CRangeEnc *rc, uint32_t symbol, uint
 
 
 
-static void MovePos(CLzmaEnc *p, uint32_t num)
+static void MovePos(struct CLzmaEnc *p, uint32_t num)
 {
   #ifdef SHOW_STAT
   ttt += num;
@@ -813,7 +813,7 @@ static void MovePos(CLzmaEnc *p, uint32_t num)
   }
 }
 
-static uint32_t ReadMatchDistances(CLzmaEnc *p, uint32_t *numDistancePairsRes)
+static uint32_t ReadMatchDistances(struct CLzmaEnc *p, uint32_t *numDistancePairsRes)
 {
   uint32_t lenRes = 0, numPairs;
   p->numAvail = p->matchFinder.GetNumAvailableBytes(p->matchFinderObj);
@@ -853,14 +853,14 @@ static uint32_t ReadMatchDistances(CLzmaEnc *p, uint32_t *numDistancePairsRes)
 #define MakeAsShortRep(p) (p)->backPrev = 0; (p)->prev1IsChar = false;
 #define IsShortRep(p) ((p)->backPrev == 0)
 
-static uint32_t GetRepLen1Price(CLzmaEnc *p, uint32_t state, uint32_t posState)
+static uint32_t GetRepLen1Price(struct CLzmaEnc *p, uint32_t state, uint32_t posState)
 {
   return
     GET_PRICE_0(p->isRepG0[state]) +
     GET_PRICE_0(p->isRep0Long[state][posState]);
 }
 
-static uint32_t GetPureRepPrice(CLzmaEnc *p, uint32_t repIndex, uint32_t state, uint32_t posState)
+static uint32_t GetPureRepPrice(struct CLzmaEnc *p, uint32_t repIndex, uint32_t state, uint32_t posState)
 {
   uint32_t price;
   if (repIndex == 0)
@@ -882,13 +882,13 @@ static uint32_t GetPureRepPrice(CLzmaEnc *p, uint32_t repIndex, uint32_t state,
   return price;
 }
 
-static uint32_t GetRepPrice(CLzmaEnc *p, uint32_t repIndex, uint32_t len, uint32_t state, uint32_t posState)
+static uint32_t GetRepPrice(struct CLzmaEnc *p, uint32_t repIndex, uint32_t len, uint32_t state, uint32_t posState)
 {
   return p->repLenEnc.prices[posState][len - LZMA_MATCH_LEN_MIN] +
     GetPureRepPrice(p, repIndex, state, posState);
 }
 
-static uint32_t Backward(CLzmaEnc *p, uint32_t *backRes, uint32_t cur)
+static uint32_t Backward(struct CLzmaEnc *p, uint32_t *backRes, uint32_t cur)
 {
   uint32_t posMem = p->opt[cur].posPrev;
   uint32_t backMem = p->opt[cur].backPrev;
@@ -926,7 +926,7 @@ static uint32_t Backward(CLzmaEnc *p, uint32_t *backRes, uint32_t cur)
 
 #define LIT_PROBS(pos, prevuint8_t) (p->litProbs + ((((pos) & p->lpMask) << p->lc) + ((prevuint8_t) >> (8 - p->lc))) * 0x300)
 
-static uint32_t GetOptimum(CLzmaEnc *p, uint32_t position, uint32_t *backRes)
+static uint32_t GetOptimum(struct CLzmaEnc *p, uint32_t position, uint32_t *backRes)
 {
   uint32_t numAvail, mainLen, numPairs, repMaxIndex, i, posState, lenEnd, len, cur;
   uint32_t matchPrice, repMatchPrice, normalMatchPrice;
@@ -936,7 +936,7 @@ static uint32_t GetOptimum(CLzmaEnc *p, uint32_t position, uint32_t *backRes)
   uint8_t curuint8_t, matchuint8_t;
   if (p->optimumEndIndex != p->optimumCurrentIndex)
   {
-    const COptimal *opt = &p->opt[p->optimumCurrentIndex];
+    const struct COptimal *opt = &p->opt[p->optimumCurrentIndex];
     uint32_t lenRes = opt->posPrev - p->optimumCurrentIndex;
     *backRes = opt->backPrev;
     p->optimumCurrentIndex = opt->posPrev;
@@ -1057,7 +1057,7 @@ static uint32_t GetOptimum(CLzmaEnc *p, uint32_t position, uint32_t *backRes)
     do
     {
       uint32_t curAndLenPrice = price + p->repLenEnc.prices[posState][repLen - 2];
-      COptimal *opt = &p->opt[repLen];
+      struct COptimal *opt = &p->opt[repLen];
       if (curAndLenPrice < opt->price)
       {
         opt->price = curAndLenPrice;
@@ -1079,7 +1079,7 @@ static uint32_t GetOptimum(CLzmaEnc *p, uint32_t position, uint32_t *backRes)
       offs += 2;
     for (; ; len++)
     {
-      COptimal *opt;
+      struct COptimal *opt;
       uint32_t distance = matches[offs + 1];
 
       uint32_t curAndLenPrice = normalMatchPrice + p->lenEnc.prices[posState][len - LZMA_MATCH_LEN_MIN];
@@ -1128,8 +1128,8 @@ static uint32_t GetOptimum(CLzmaEnc *p, uint32_t position, uint32_t *backRes)
     bool nextIsChar;
     uint8_t curuint8_t, matchuint8_t;
     const uint8_t *data;
-    COptimal *curOpt;
-    COptimal *nextOpt;
+    struct COptimal *curOpt;
+    struct COptimal *nextOpt;
 
     cur++;
     if (cur == lenEnd)
@@ -1172,7 +1172,7 @@ static uint32_t GetOptimum(CLzmaEnc *p, uint32_t position, uint32_t *backRes)
     else
     {
       uint32_t pos;
-      const COptimal *prevOpt;
+      const struct COptimal *prevOpt;
       if (curOpt->prev1IsChar && curOpt->prev2)
       {
         posPrev = curOpt->posPrev2;
@@ -1286,7 +1286,7 @@ static uint32_t GetOptimum(CLzmaEnc *p, uint32_t position, uint32_t *backRes)
         /* for (; lenTest2 >= 2; lenTest2--) */
         {
           uint32_t curAndLenPrice;
-          COptimal *opt;
+          struct COptimal *opt;
           uint32_t offset = cur + 1 + lenTest2;
           while (lenEnd < offset)
             p->opt[++lenEnd].price = kInfinityPrice;
@@ -1323,7 +1323,7 @@ static uint32_t GetOptimum(CLzmaEnc *p, uint32_t position, uint32_t *backRes)
       do
       {
         uint32_t curAndLenPrice = price + p->repLenEnc.prices[posState][lenTest - 2];
-        COptimal *opt = &p->opt[cur + lenTest];
+        struct COptimal *opt = &p->opt[cur + lenTest];
         if (curAndLenPrice < opt->price)
         {
           opt->price = curAndLenPrice;
@@ -1365,7 +1365,7 @@ static uint32_t GetOptimum(CLzmaEnc *p, uint32_t position, uint32_t *backRes)
             /* for (; lenTest2 >= 2; lenTest2--) */
             {
               uint32_t curAndLenPrice;
-              COptimal *opt;
+              struct COptimal *opt;
               uint32_t offset = cur + lenTest + 1 + lenTest2;
               while (lenEnd < offset)
                 p->opt[++lenEnd].price = kInfinityPrice;
@@ -1411,7 +1411,7 @@ static uint32_t GetOptimum(CLzmaEnc *p, uint32_t position, uint32_t *backRes)
       {
         uint32_t curAndLenPrice = normalMatchPrice + p->lenEnc.prices[posState][lenTest - LZMA_MATCH_LEN_MIN];
         uint32_t lenToPosState = GetLenToPosState(lenTest);
-        COptimal *opt;
+        struct COptimal *opt;
         if (curBack < kNumFullDistances)
           curAndLenPrice += p->distancesPrices[lenToPosState][curBack];
         else
@@ -1455,7 +1455,7 @@ static uint32_t GetOptimum(CLzmaEnc *p, uint32_t position, uint32_t *backRes)
             {
               uint32_t offset = cur + lenTest + 1 + lenTest2;
               uint32_t curAndLenPrice;
-              COptimal *opt;
+              struct COptimal *opt;
               while (lenEnd < offset)
                 p->opt[++lenEnd].price = kInfinityPrice;
               curAndLenPrice = nextRepMatchPrice + GetRepPrice(p, 0, lenTest2, state2, posStateNext);
@@ -1486,7 +1486,7 @@ static uint32_t GetOptimum(CLzmaEnc *p, uint32_t position, uint32_t *backRes)
 
 #define ChangePair(smallDist, bigDist) (((bigDist) >> 7) > (smallDist))
 
-static uint32_t GetOptimumFast(CLzmaEnc *p, uint32_t *backRes)
+static uint32_t GetOptimumFast(struct CLzmaEnc *p, uint32_t *backRes)
 {
   uint32_t numAvail, mainLen, mainDist, numPairs, repIndex, repLen, i;
   const uint8_t *data;
@@ -1594,7 +1594,7 @@ static uint32_t GetOptimumFast(CLzmaEnc *p, uint32_t *backRes)
   return mainLen;
 }
 
-static void WriteEndMarker(CLzmaEnc *p, uint32_t posState)
+static void WriteEndMarker(struct CLzmaEnc *p, uint32_t posState)
 {
   uint32_t len;
   RangeEnc_EncodeBit(&p->rc, &p->isMatch[p->state][posState], 1);
@@ -1607,7 +1607,7 @@ static void WriteEndMarker(CLzmaEnc *p, uint32_t posState)
   RcTree_ReverseEncode(&p->rc, p->posAlignEncoder, kNumAlignBits, kAlignMask);
 }
 
-static SRes CheckErrors(CLzmaEnc *p)
+static SRes CheckErrors(struct CLzmaEnc *p)
 {
   if (p->result != SZ_OK)
     return p->result;
@@ -1620,7 +1620,7 @@ static SRes CheckErrors(CLzmaEnc *p)
   return p->result;
 }
 
-static SRes Flush(CLzmaEnc *p, uint32_t nowPos)
+static SRes Flush(struct CLzmaEnc *p, uint32_t nowPos)
 {
   /* ReleaseMFStream(); */
   p->finished = true;
@@ -1631,7 +1631,7 @@ static SRes Flush(CLzmaEnc *p, uint32_t nowPos)
   return CheckErrors(p);
 }
 
-static void FillAlignPrices(CLzmaEnc *p)
+static void FillAlignPrices(struct CLzmaEnc *p)
 {
   uint32_t i;
   for (i = 0; i < kAlignTableSize; i++)
@@ -1639,7 +1639,7 @@ static void FillAlignPrices(CLzmaEnc *p)
   p->alignPriceCount = 0;
 }
 
-static void FillDistancesPrices(CLzmaEnc *p)
+static void FillDistancesPrices(struct CLzmaEnc *p)
 {
   uint32_t tempPrices[kNumFullDistances];
   uint32_t i, lenToPosState;
@@ -1673,7 +1673,7 @@ static void FillDistancesPrices(CLzmaEnc *p)
   p->matchPriceCount = 0;
 }
 
-static void LzmaEnc_Construct(CLzmaEnc *p)
+static void LzmaEnc_Construct(struct CLzmaEnc *p)
 {
   RangeEnc_Construct(&p->rc);
   MatchFinder_Construct(&p->matchFinderBase);
@@ -1683,7 +1683,7 @@ static void LzmaEnc_Construct(CLzmaEnc *p)
   #endif
 
   {
-    CLzmaEncProps props;
+    struct CLzmaEncProps props;
     LzmaEncProps_Init(&props);
     LzmaEnc_SetProps(p, &props);
   }
@@ -1697,16 +1697,16 @@ static void LzmaEnc_Construct(CLzmaEnc *p)
   p->saveState.litProbs = 0;
 }
 
-CLzmaEncHandle LzmaEnc_Create(ISzAlloc *alloc)
+CLzmaEncHandle LzmaEnc_Create(struct ISzAlloc *alloc)
 {
   void *p;
-  p = alloc->Alloc(alloc, sizeof(CLzmaEnc));
+  p = alloc->Alloc(alloc, sizeof(struct CLzmaEnc));
   if (p != 0)
-    LzmaEnc_Construct((CLzmaEnc *)p);
+    LzmaEnc_Construct((struct CLzmaEnc *)p);
   return p;
 }
 
-static void LzmaEnc_FreeLits(CLzmaEnc *p, ISzAlloc *alloc)
+static void LzmaEnc_FreeLits(struct CLzmaEnc *p, struct ISzAlloc *alloc)
 {
   alloc->Free(alloc, p->litProbs);
   alloc->Free(alloc, p->saveState.litProbs);
@@ -1714,7 +1714,7 @@ static void LzmaEnc_FreeLits(CLzmaEnc *p, ISzAlloc *alloc)
   p->saveState.litProbs = 0;
 }
 
-static void LzmaEnc_Destruct(CLzmaEnc *p, ISzAlloc *alloc, ISzAlloc *allocBig)
+static void LzmaEnc_Destruct(struct CLzmaEnc *p, struct ISzAlloc *alloc, struct ISzAlloc *allocBig)
 {
   #ifndef _7ZIP_ST
   MatchFinderMt_Destruct(&p->matchFinderMt, allocBig);
@@ -1724,13 +1724,13 @@ static void LzmaEnc_Destruct(CLzmaEnc *p, ISzAlloc *alloc, ISzAlloc *allocBig)
   RangeEnc_Free(&p->rc, alloc);
 }
 
-void LzmaEnc_Destroy(CLzmaEncHandle p, ISzAlloc *alloc, ISzAlloc *allocBig)
+void LzmaEnc_Destroy(CLzmaEncHandle p, struct ISzAlloc *alloc, struct ISzAlloc *allocBig)
 {
-  LzmaEnc_Destruct((CLzmaEnc *)p, alloc, allocBig);
+  LzmaEnc_Destruct((struct CLzmaEnc *)p, alloc, allocBig);
   alloc->Free(alloc, p);
 }
 
-static SRes LzmaEnc_CodeOneBlock(CLzmaEnc *p, bool useLimits, uint32_t maxPackSize, uint32_t maxUnpackSize)
+static SRes LzmaEnc_CodeOneBlock(struct CLzmaEnc *p, bool useLimits, uint32_t maxPackSize, uint32_t maxUnpackSize)
 {
   uint32_t nowPos32, startPos32;
   if (p->needInit)
@@ -1894,7 +1894,7 @@ static SRes LzmaEnc_CodeOneBlock(CLzmaEnc *p, bool useLimits, uint32_t maxPackSi
 
 #define kBigHashDicLimit ((uint32_t)1 << 24)
 
-static SRes LzmaEnc_Alloc(CLzmaEnc *p, uint32_t keepWindowSize, ISzAlloc *alloc, ISzAlloc *allocBig)
+static SRes LzmaEnc_Alloc(struct CLzmaEnc *p, uint32_t keepWindowSize, struct ISzAlloc *alloc, struct ISzAlloc *allocBig)
 {
   uint32_t beforeSize = kNumOpts;
   #ifndef _7ZIP_ST
@@ -1946,7 +1946,7 @@ static SRes LzmaEnc_Alloc(CLzmaEnc *p, uint32_t keepWindowSize, ISzAlloc *alloc,
   return SZ_OK;
 }
 
-static void LzmaEnc_Init(CLzmaEnc *p)
+static void LzmaEnc_Init(struct CLzmaEnc *p)
 {
   uint32_t i;
   p->state = 0;
@@ -2004,7 +2004,7 @@ static void LzmaEnc_Init(CLzmaEnc *p)
   p->lpMask = (1 << p->lp) - 1;
 }
 
-static void LzmaEnc_InitPrices(CLzmaEnc *p)
+static void LzmaEnc_InitPrices(struct CLzmaEnc *p)
 {
   if (!p->fastMode)
   {
@@ -2019,7 +2019,7 @@ static void LzmaEnc_InitPrices(CLzmaEnc *p)
   LenPriceEnc_UpdateTables(&p->repLenEnc, 1 << p->pb, p->ProbPrices);
 }
 
-static SRes LzmaEnc_AllocAndInit(CLzmaEnc *p, uint32_t keepWindowSize, ISzAlloc *alloc, ISzAlloc *allocBig)
+static SRes LzmaEnc_AllocAndInit(struct CLzmaEnc *p, uint32_t keepWindowSize, struct ISzAlloc *alloc, struct ISzAlloc *allocBig)
 {
   uint32_t i;
   for (i = 0; i < (uint32_t)kDicLogSizeMaxCompress; i++)
@@ -2036,10 +2036,10 @@ static SRes LzmaEnc_AllocAndInit(CLzmaEnc *p, uint32_t keepWindowSize, ISzAlloc
   return SZ_OK;
 }
 
-static SRes LzmaEnc_Prepare(CLzmaEncHandle pp, ISeqOutStream *outStream, ISeqInStream *inStream,
-    ISzAlloc *alloc, ISzAlloc *allocBig)
+static SRes LzmaEnc_Prepare(CLzmaEncHandle pp, struct ISeqOutStream *outStream, struct ISeqInStream *inStream,
+    struct ISzAlloc *alloc, struct ISzAlloc *allocBig)
 {
-  CLzmaEnc *p = (CLzmaEnc *)pp;
+  struct CLzmaEnc *p = (struct CLzmaEnc *)pp;
   p->matchFinderBase.stream = inStream;
   p->needInit = 1;
   p->rc.outStream = outStream;
@@ -2056,7 +2056,7 @@ static SRes LzmaEnc_Prepare(CLzmaEncHandle pp, ISeqOutStream *outStream, ISeqInS
   return LzmaEnc_AllocAndInit(p, keepWindowSize, alloc, allocBig);
 }*/
 
-static void LzmaEnc_SetInputBuf(CLzmaEnc *p, const uint8_t *src, size_t srcLen)
+static void LzmaEnc_SetInputBuf(struct CLzmaEnc *p, const uint8_t *src, size_t srcLen)
 {
   p->matchFinderBase.directInput = 1;
   p->matchFinderBase.bufferBase = (uint8_t *)src;
@@ -2064,9 +2064,9 @@ static void LzmaEnc_SetInputBuf(CLzmaEnc *p, const uint8_t *src, size_t srcLen)
 }
 
 static SRes LzmaEnc_MemPrepare(CLzmaEncHandle pp, const uint8_t *src, size_t srcLen,
-    uint32_t keepWindowSize, ISzAlloc *alloc, ISzAlloc *allocBig)
+    uint32_t keepWindowSize, struct ISzAlloc *alloc, struct ISzAlloc *allocBig)
 {
-  CLzmaEnc *p = (CLzmaEnc *)pp;
+  struct CLzmaEnc *p = (struct CLzmaEnc *)pp;
   LzmaEnc_SetInputBuf(p, src, srcLen);
   p->needInit = 1;
 
@@ -2084,17 +2084,17 @@ static void LzmaEnc_Finish(CLzmaEncHandle pp)
   #endif
 }
 
-typedef struct
+struct CSeqOutStreamBuf
 {
-  ISeqOutStream funcTable;
+  struct ISeqOutStream funcTable;
   uint8_t *data;
   size_t rem;
   bool overflow;
-} CSeqOutStreamBuf;
+};
 
 static size_t MyWrite(void *pp, const void *data, size_t size)
 {
-  CSeqOutStreamBuf *p = (CSeqOutStreamBuf *)pp;
+  struct CSeqOutStreamBuf *p = (struct CSeqOutStreamBuf *)pp;
   if (p->rem < size)
   {
     size = p->rem;
@@ -2153,7 +2153,7 @@ static size_t MyWrite(void *pp, const void *data, size_t size)
   return res;
 }*/
 
-static SRes LzmaEnc_Encode2(CLzmaEnc *p, ICompressProgress *progress)
+static SRes LzmaEnc_Encode2(struct CLzmaEnc *p, struct ICompressProgress *progress)
 {
   SRes res = SZ_OK;
 
@@ -2183,16 +2183,16 @@ static SRes LzmaEnc_Encode2(CLzmaEnc *p, ICompressProgress *progress)
   return res;
 }
 
-SRes LzmaEnc_Encode(CLzmaEncHandle pp, ISeqOutStream *outStream, ISeqInStream *inStream, ICompressProgress *progress,
-    ISzAlloc *alloc, ISzAlloc *allocBig)
+SRes LzmaEnc_Encode(CLzmaEncHandle pp, struct ISeqOutStream *outStream, struct ISeqInStream *inStream, struct ICompressProgress *progress,
+    struct ISzAlloc *alloc, struct ISzAlloc *allocBig)
 {
   RINOK(LzmaEnc_Prepare(pp, outStream, inStream, alloc, allocBig));
-  return LzmaEnc_Encode2((CLzmaEnc *)pp, progress);
+  return LzmaEnc_Encode2((struct CLzmaEnc *)pp, progress);
 }
 
 SRes LzmaEnc_WriteProperties(CLzmaEncHandle pp, uint8_t *props, size_t *size)
 {
-  CLzmaEnc *p = (CLzmaEnc *)pp;
+  struct CLzmaEnc *p = (struct CLzmaEnc *)pp;
   int i;
   uint32_t dictSize = p->dictSize;
   if (*size < LZMA_PROPS_SIZE)
@@ -2220,12 +2220,12 @@ SRes LzmaEnc_WriteProperties(CLzmaEncHandle pp, uint8_t *props, size_t *size)
 }
 
 SRes LzmaEnc_MemEncode(CLzmaEncHandle pp, uint8_t *dest, size_t *destLen, const uint8_t *src, size_t srcLen,
-    int writeEndMark, ICompressProgress *progress, ISzAlloc *alloc, ISzAlloc *allocBig)
+		       int writeEndMark, struct ICompressProgress *progress, struct ISzAlloc *alloc, struct ISzAlloc *allocBig)
 {
   SRes res;
-  CLzmaEnc *p = (CLzmaEnc *)pp;
+  struct CLzmaEnc *p = (struct CLzmaEnc *)pp;
 
-  CSeqOutStreamBuf outStream;
+  struct CSeqOutStreamBuf outStream;
 
   LzmaEnc_SetInputBuf(p, src, srcLen);
 
@@ -2248,10 +2248,10 @@ SRes LzmaEnc_MemEncode(CLzmaEncHandle pp, uint8_t *dest, size_t *destLen, const
 }
 
 SRes LzmaEncode(uint8_t *dest, size_t *destLen, const uint8_t *src, size_t srcLen,
-    const CLzmaEncProps *props, uint8_t *propsEncoded, size_t *propsSize, int writeEndMark,
-    ICompressProgress *progress, ISzAlloc *alloc, ISzAlloc *allocBig)
+    const struct CLzmaEncProps *props, uint8_t *propsEncoded, size_t *propsSize, int writeEndMark,
+    struct ICompressProgress *progress, struct ISzAlloc *alloc, struct ISzAlloc *allocBig)
 {
-  CLzmaEnc *p = (CLzmaEnc *)LzmaEnc_Create(alloc);
+  struct CLzmaEnc *p = (struct CLzmaEnc *)LzmaEnc_Create(alloc);
   SRes res;
   if (p == 0)
     return SZ_ERROR_MEM;