Show
Ignore:
Timestamp:
03/21/12 18:36:20 (2 years ago)
Author:
robert
Message:

Ran script to remove trailing spaces and tabs

Files:
1 modified

Legend:

Unmodified
Added
Removed
  • OpenSceneGraph/trunk/src/osgPlugins/zip/unzip.cpp

    r12611 r13041  
    528528//   static string (which must not be deallocated). 
    529529 
    530                         // Advanced functions  
     530                        // Advanced functions 
    531531 
    532532//  The following functions are needed only in some special applications. 
     
    545545//   can be determined from the Adler32 value returned by this call of 
    546546//   inflate. The compressor and decompressor must use exactly the same 
    547 //   dictionary.  
     547//   dictionary. 
    548548// 
    549549//     inflateSetDictionary returns Z_OK if success, Z_STREAM_ERROR if a 
     
    556556 
    557557int inflateSync (z_streamp strm); 
    558 //  
     558// 
    559559//    Skips invalid compressed data until a full flush point can be found, or until all 
    560560//  available input is skipped. No output is provided. 
     
    647647#define ERR_RETURN(strm,err) \ 
    648648  return (strm->msg = (char*)ERR_MSG(err), (err)) 
    649 // To be used only when the state is known to be valid  
     649// To be used only when the state is known to be valid 
    650650 
    651651        // common constants 
     
    655655#define STATIC_TREES 1 
    656656#define DYN_TREES    2 
    657 // The three kinds of block type  
     657// The three kinds of block type 
    658658 
    659659#define MIN_MATCH  3 
    660660#define MAX_MATCH  258 
    661 // The minimum and maximum match lengths  
    662  
    663 #define PRESET_DICT 0x20 // preset dictionary flag in zlib header  
    664  
    665         // target dependencies  
     661// The minimum and maximum match lengths 
     662 
     663#define PRESET_DICT 0x20 // preset dictionary flag in zlib header 
     664 
     665        // target dependencies 
    666666 
    667667#define OS_CODE  0x0b  // Window 95 & Windows NT 
     
    669669 
    670670 
    671          // functions  
     671         // functions 
    672672 
    673673#define zmemzero(dest, len) memset(dest, 0, len) 
     
    814814      IBM_CODES,    // processing fixed or dynamic block 
    815815      IBM_DRY,      // output remaining window bytes 
    816       IBM_DONE,     // finished last block, done  
    817       IBM_BAD}      // got a data error--stuck here  
     816      IBM_DONE,     // finished last block, done 
     817      IBM_BAD}      // got a data error--stuck here 
    818818inflate_block_mode; 
    819819 
    820 // inflate blocks semi-private state  
     820// inflate blocks semi-private state 
    821821struct inflate_blocks_state { 
    822822 
    823   // mode  
    824   inflate_block_mode  mode;     // current inflate_block mode  
    825  
    826   // mode dependent information  
     823  // mode 
     824  inflate_block_mode  mode;     // current inflate_block mode 
     825 
     826  // mode dependent information 
    827827  union { 
    828     uInt left;          // if STORED, bytes left to copy  
     828    uInt left;          // if STORED, bytes left to copy 
    829829    struct { 
    830       uInt table;               // table lengths (14 bits)  
     830      uInt table;               // table lengths (14 bits) 
    831831      uInt index;               // index into blens (or border) 
    832832      uInt *blens;             // bit lengths of codes 
    833       uInt bb;                  // bit length tree depth  
    834       inflate_huft *tb;         // bit length decoding tree  
    835     } trees;            // if DTREE, decoding info for trees  
     833      uInt bb;                  // bit length tree depth 
     834      inflate_huft *tb;         // bit length decoding tree 
     835    } trees;            // if DTREE, decoding info for trees 
    836836    struct { 
    837       inflate_codes_statef  
     837      inflate_codes_statef 
    838838         *codes; 
    839     } decode;           // if CODES, current state  
     839    } decode;           // if CODES, current state 
    840840  } sub;                // submode 
    841   uInt last;            // true if this block is the last block  
    842  
    843   // mode independent information  
    844   uInt bitk;            // bits in bit buffer  
    845   uLong bitb;           // bit buffer  
    846   inflate_huft *hufts;  // single malloc for tree space  
    847   Byte *window;        // sliding window  
    848   Byte *end;           // one byte after sliding window  
    849   Byte *read;          // window read pointer  
    850   Byte *write;         // window write pointer  
    851   check_func checkfn;   // check function  
    852   uLong check;          // check on output  
     841  uInt last;            // true if this block is the last block 
     842 
     843  // mode independent information 
     844  uInt bitk;            // bits in bit buffer 
     845  uLong bitb;           // bit buffer 
     846  inflate_huft *hufts;  // single malloc for tree space 
     847  Byte *window;        // sliding window 
     848  Byte *end;           // one byte after sliding window 
     849  Byte *read;          // window read pointer 
     850  Byte *write;         // window write pointer 
     851  check_func checkfn;   // check function 
     852  uLong check;          // check on output 
    853853 
    854854}; 
     
    856856 
    857857// defines for inflate input/output 
    858 //   update pointers and return  
     858//   update pointers and return 
    859859#define UPDBITS {s->bitb=b;s->bitk=k;} 
    860860#define UPDIN {z->avail_in=n;z->total_in+=(uLong)(p-z->next_in);z->next_in=p;} 
     
    862862#define UPDATE {UPDBITS UPDIN UPDOUT} 
    863863#define LEAVE {UPDATE return inflate_flush(s,z,r);} 
    864 //   get bytes and bits  
     864//   get bytes and bits 
    865865#define LOADIN {p=z->next_in;n=z->avail_in;b=s->bitb;k=s->bitk;} 
    866866#define NEEDBYTE {if(n)r=Z_OK;else LEAVE} 
     
    868868#define NEEDBITS(j) {while(k<(j)){NEEDBYTE;b|=((uLong)NEXTBYTE)<<k;k+=8;}} 
    869869#define DUMPBITS(j) {b>>=(j);k-=(j);} 
    870 //   output bytes  
     870//   output bytes 
    871871#define WAVAIL (uInt)(q<s->read?s->read-q-1:s->end-q) 
    872872#define LOADOUT {q=s->write;m=(uInt)WAVAIL;} 
     
    875875#define NEEDOUT {if(m==0){WRAP if(m==0){FLUSH WRAP if(m==0) LEAVE}}r=Z_OK;} 
    876876#define OUTBYTE(a) {*q++=(Byte)(a);m--;} 
    877 //   load local pointers  
     877//   load local pointers 
    878878#define LOAD {LOADIN LOADOUT} 
    879879 
    880 // masks for lower bits (size given to avoid silly warnings with Visual C++)  
     880// masks for lower bits (size given to avoid silly warnings with Visual C++) 
    881881// And'ing with mask[n] masks the lower n bits 
    882882const uInt inflate_mask[17] = { 
     
    10491049  Byte *q; 
    10501050 
    1051   // local copies of source and destination pointers  
     1051  // local copies of source and destination pointers 
    10521052  p = z->next_out; 
    10531053  q = s->read; 
    10541054 
    1055   // compute number of bytes to copy as far as end of window  
     1055  // compute number of bytes to copy as far as end of window 
    10561056  n = (uInt)((q <= s->write ? s->write : s->end) - q); 
    10571057  if (n > z->avail_out) n = z->avail_out; 
     
    10621062  z->total_out += n; 
    10631063 
    1064   // update check information  
     1064  // update check information 
    10651065  if (s->checkfn != Z_NULL) 
    10661066    z->adler = s->check = (*s->checkfn)(s->check, q, n); 
    10671067 
    1068   // copy as far as end of window  
     1068  // copy as far as end of window 
    10691069  if (n!=0)          // check for n!=0 to avoid waking up CodeGuard 
    10701070  { memcpy(p, q, n); 
     
    10761076  if (q == s->end) 
    10771077  { 
    1078     // wrap pointers  
     1078    // wrap pointers 
    10791079    q = s->window; 
    10801080    if (s->write == s->end) 
    10811081      s->write = s->window; 
    10821082 
    1083     // compute bytes to copy  
     1083    // compute bytes to copy 
    10841084    n = (uInt)(s->write - q); 
    10851085    if (n > z->avail_out) n = z->avail_out; 
    10861086    if (n && r == Z_BUF_ERROR) r = Z_OK; 
    10871087 
    1088     // update counters  
     1088    // update counters 
    10891089    z->avail_out -= n; 
    10901090    z->total_out += n; 
    10911091 
    1092     // update check information  
     1092    // update check information 
    10931093    if (s->checkfn != Z_NULL) 
    10941094      z->adler = s->check = (*s->checkfn)(s->check, q, n); 
     
    11151115#define bits word.what.Bits 
    11161116 
    1117 typedef enum {        // waiting for "i:"=input, "o:"=output, "x:"=nothing  
    1118       START,    // x: set up for LEN  
    1119       LEN,      // i: get length/literal/eob next  
    1120       LENEXT,   // i: getting length extra (have base)  
    1121       DIST,     // i: get distance next  
    1122       DISTEXT,  // i: getting distance extra  
     1117typedef enum {        // waiting for "i:"=input, "o:"=output, "x:"=nothing 
     1118      START,    // x: set up for LEN 
     1119      LEN,      // i: get length/literal/eob next 
     1120      LENEXT,   // i: getting length extra (have base) 
     1121      DIST,     // i: get distance next 
     1122      DISTEXT,  // i: getting distance extra 
    11231123      COPY,     // o: copying bytes in window, waiting for space 
    1124       LIT,      // o: got literal, waiting for output space  
    1125       WASH,     // o: got eob, possibly still output waiting  
    1126       END,      // x: got eob and all data flushed  
    1127       BADCODE}  // x: got error  
     1124      LIT,      // o: got literal, waiting for output space 
     1125      WASH,     // o: got eob, possibly still output waiting 
     1126      END,      // x: got eob and all data flushed 
     1127      BADCODE}  // x: got error 
    11281128inflate_codes_mode; 
    11291129 
     
    11311131struct inflate_codes_state { 
    11321132 
    1133   // mode  
    1134   inflate_codes_mode mode;      // current inflate_codes mode  
    1135  
    1136   // mode dependent information  
     1133  // mode 
     1134  inflate_codes_mode mode;      // current inflate_codes mode 
     1135 
     1136  // mode dependent information 
    11371137  uInt len; 
    11381138  union { 
    11391139    struct { 
    1140       const inflate_huft *tree;       // pointer into tree  
    1141       uInt need;                // bits needed  
    1142     } code;             // if LEN or DIST, where in tree  
    1143     uInt lit;           // if LIT, literal  
     1140      const inflate_huft *tree;       // pointer into tree 
     1141      uInt need;                // bits needed 
     1142    } code;             // if LEN or DIST, where in tree 
     1143    uInt lit;           // if LIT, literal 
    11441144    struct { 
    1145       uInt get;                 // bits to get for extra  
    1146       uInt dist;                // distance back to copy from  
    1147     } copy;             // if EXT or COPY, where and how much  
     1145      uInt get;                 // bits to get for extra 
     1146      uInt dist;                // distance back to copy from 
     1147    } copy;             // if EXT or COPY, where and how much 
    11481148  } sub;                // submode 
    11491149 
    1150   // mode independent information  
    1151   Byte lbits;           // ltree bits decoded per branch  
    1152   Byte dbits;           // dtree bits decoder per branch  
     1150  // mode independent information 
     1151  Byte lbits;           // ltree bits decoded per branch 
     1152  Byte dbits;           // dtree bits decoder per branch 
    11531153  const inflate_huft *ltree;          // literal/length/eob tree 
    11541154  const inflate_huft *dtree;          // distance tree 
     
    12221222      DUMPBITS(t->bits) 
    12231223      e = (uInt)(t->exop); 
    1224       if (e == 0)               // literal  
     1224      if (e == 0)               // literal 
    12251225      { 
    12261226        c->sub.lit = t->base; 
     
    12311231        break; 
    12321232      } 
    1233       if (e & 16)               // length  
     1233      if (e & 16)               // length 
    12341234      { 
    12351235        c->sub.copy.get = e & 15; 
     
    12381238        break; 
    12391239      } 
    1240       if ((e & 64) == 0)        // next table  
     1240      if ((e & 64) == 0)        // next table 
    12411241      { 
    12421242        c->sub.code.need = e; 
     
    12441244        break; 
    12451245      } 
    1246       if (e & 32)               // end of block  
     1246      if (e & 32)               // end of block 
    12471247      { 
    12481248        LuTracevv((stderr, "inflate:         end of block\n")); 
     
    12501250        break; 
    12511251      } 
    1252       c->mode = BADCODE;        // invalid code  
     1252      c->mode = BADCODE;        // invalid code 
    12531253      z->msg = (char*)"invalid literal/length code"; 
    12541254      r = Z_DATA_ERROR; 
    12551255      LEAVE 
    1256     case LENEXT:        // i: getting length extra (have base)  
     1256    case LENEXT:        // i: getting length extra (have base) 
    12571257      j = c->sub.copy.get; 
    12581258      NEEDBITS(j) 
     
    12631263      LuTracevv((stderr, "inflate:         length %u\n", c->len)); 
    12641264      c->mode = DIST; 
    1265     case DIST:          // i: get distance next  
     1265    case DIST:          // i: get distance next 
    12661266      j = c->sub.code.need; 
    12671267      NEEDBITS(j) 
     
    12691269      DUMPBITS(t->bits) 
    12701270      e = (uInt)(t->exop); 
    1271       if (e & 16)               // distance  
     1271      if (e & 16)               // distance 
    12721272      { 
    12731273        c->sub.copy.get = e & 15; 
     
    12761276        break; 
    12771277      } 
    1278       if ((e & 64) == 0)        // next table  
     1278      if ((e & 64) == 0)        // next table 
    12791279      { 
    12801280        c->sub.code.need = e; 
     
    12821282        break; 
    12831283      } 
    1284       c->mode = BADCODE;        // invalid code  
     1284      c->mode = BADCODE;        // invalid code 
    12851285      z->msg = (char*)"invalid distance code"; 
    12861286      r = Z_DATA_ERROR; 
    12871287      LEAVE 
    1288     case DISTEXT:       // i: getting distance extra  
     1288    case DISTEXT:       // i: getting distance extra 
    12891289      j = c->sub.copy.get; 
    12901290      NEEDBITS(j) 
     
    12931293      LuTracevv((stderr, "inflate:         distance %u\n", c->sub.copy.dist)); 
    12941294      c->mode = COPY; 
    1295     case COPY:          // o: copying bytes in window, waiting for space  
     1295    case COPY:          // o: copying bytes in window, waiting for space 
    12961296      f = q - c->sub.copy.dist; 
    12971297      while (f < s->window)             // modulo window size-"while" instead 
    1298         f += s->end - s->window;        // of "if" handles invalid distances  
     1298        f += s->end - s->window;        // of "if" handles invalid distances 
    12991299      while (c->len) 
    13001300      { 
     
    13071307      c->mode = START; 
    13081308      break; 
    1309     case LIT:           // o: got literal, waiting for output space  
     1309    case LIT:           // o: got literal, waiting for output space 
    13101310      NEEDOUT 
    13111311      OUTBYTE(c->sub.lit) 
    13121312      c->mode = START; 
    13131313      break; 
    1314     case WASH:          // o: got eob, possibly more output  
    1315       if (k > 7)        // return unused byte, if any  
     1314    case WASH:          // o: got eob, possibly more output 
     1315      if (k > 7)        // return unused byte, if any 
    13161316      { 
    13171317        //Assert(k < 16, "inflate_codes grabbed too many bytes") 
    13181318        k -= 8; 
    13191319        n++; 
    1320         p--;            // can always return one  
     1320        p--;            // can always return one 
    13211321      } 
    13221322      FLUSH 
     
    13481348// For conditions of distribution and use, see copyright notice in zlib.h 
    13491349 
    1350 //struct inflate_codes_state {int dummy;}; // for buggy compilers  
     1350//struct inflate_codes_state {int dummy;}; // for buggy compilers 
    13511351 
    13521352 
     
    14541454  uInt n;               // bytes available there 
    14551455  Byte *q;             // output window write pointer 
    1456   uInt m;               // bytes to end of window or read pointer  
    1457  
    1458   // copy input/output information to locals (UPDATE macro restores)  
     1456  uInt m;               // bytes to end of window or read pointer 
     1457 
     1458  // copy input/output information to locals (UPDATE macro restores) 
    14591459  LOAD 
    14601460 
    1461   // process input based on current state  
     1461  // process input based on current state 
    14621462  for(;;) switch (s->mode) 
    14631463  { 
     
    14681468      switch (t >> 1) 
    14691469      { 
    1470         case 0:                         // stored  
     1470        case 0:                         // stored 
    14711471          LuTracev((stderr, "inflate:     stored block%s\n", 
    14721472                 s->last ? " (last)" : "")); 
    14731473          DUMPBITS(3) 
    1474           t = k & 7;                    // go to byte boundary  
     1474          t = k & 7;                    // go to byte boundary 
    14751475          DUMPBITS(t) 
    14761476          s->mode = IBM_LENS;               // get length of stored block 
    14771477          break; 
    1478         case 1:                         // fixed  
     1478        case 1:                         // fixed 
    14791479          LuTracev((stderr, "inflate:     fixed codes block%s\n", 
    14801480                 s->last ? " (last)" : "")); 
     
    14941494          s->mode = IBM_CODES; 
    14951495          break; 
    1496         case 2:                         // dynamic  
     1496        case 2:                         // dynamic 
    14971497          LuTracev((stderr, "inflate:     dynamic codes block%s\n", 
    14981498                 s->last ? " (last)" : "")); 
     
    15181518      } 
    15191519      s->sub.left = (uInt)b & 0xffff; 
    1520       b = k = 0;                      // dump bits  
     1520      b = k = 0;                      // dump bits 
    15211521      LuTracev((stderr, "inflate:       stored length %u\n", s->sub.left)); 
    15221522      s->mode = s->sub.left ? IBM_STORED : (s->last ? IBM_DRY : IBM_TYPE); 
     
    16031603          s->sub.trees.blens[s->sub.trees.index++] = c; 
    16041604        } 
    1605         else // c == 16..18  
     1605        else // c == 16..18 
    16061606        { 
    16071607          i = c == 18 ? 7 : c - 14; 
     
    16351635        inflate_codes_statef *c; 
    16361636 
    1637         bl = 9;         // must be <= 9 for lookahead assumptions  
     1637        bl = 9;         // must be <= 9 for lookahead assumptions 
    16381638        bd = 6;         // must be <= 9 for lookahead assumptions 
    16391639        t = s->sub.trees.table; 
     
    17301730    const uInt *,      // list of extra bits for non-simple codes 
    17311731    inflate_huft **,// result: starting table 
    1732     uInt *,            // maximum lookup bits (returns actual)  
    1733     inflate_huft *,     // space for trees  
    1734     uInt *,             // hufts used in space  
    1735     uInt * );         // space for values  
    1736  
    1737 // Tables for deflate from PKZIP's appnote.txt.  
     1732    uInt *,            // maximum lookup bits (returns actual) 
     1733    inflate_huft *,     // space for trees 
     1734    uInt *,             // hufts used in space 
     1735    uInt * );         // space for values 
     1736 
     1737// Tables for deflate from PKZIP's appnote.txt. 
    17381738const uInt cplens[31] = { // Copy lengths for literal codes 257..285 
    17391739        3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 15, 17, 19, 23, 27, 31, 
     
    17471747        257, 385, 513, 769, 1025, 1537, 2049, 3073, 4097, 6145, 
    17481748        8193, 12289, 16385, 24577}; 
    1749 const uInt cpdext[30] = { // Extra bits for distance codes  
     1749const uInt cpdext[30] = { // Extra bits for distance codes 
    17501750        0, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 
    17511751        7, 7, 8, 8, 9, 9, 10, 10, 11, 11, 
     
    17851785 
    17861786 
    1787 // If BMAX needs to be larger than 16, then h and x[] should be uLong.  
     1787// If BMAX needs to be larger than 16, then h and x[] should be uLong. 
    17881788#define BMAX 15         // maximum bit length of any code 
    17891789 
     
    18071807  uInt a;                       // counter for codes of length k 
    18081808  uInt c[BMAX+1];               // bit length count table 
    1809   uInt f;                       // i repeats in table every f entries  
    1810   int g;                        // maximum code length  
    1811   int h;                        // table level  
    1812   register uInt i;              // counter, current code  
     1809  uInt f;                       // i repeats in table every f entries 
     1810  int g;                        // maximum code length 
     1811  int h;                        // table level 
     1812  register uInt i;              // counter, current code 
    18131813  register uInt j;              // counter 
    1814   register int k;               // number of bits in current code  
    1815   int l;                        // bits per table (returned in m)  
    1816   uInt mask;                    // (1 << w) - 1, to avoid cc -O bug on HP  
     1814  register int k;               // number of bits in current code 
     1815  int l;                        // bits per table (returned in m) 
     1816  uInt mask;                    // (1 << w) - 1, to avoid cc -O bug on HP 
    18171817  register uInt *p;            // pointer into c[], b[], or v[] 
    1818   inflate_huft *q;              // points to current table  
    1819   struct inflate_huft_s r;      // table entry for structure assignment  
    1820   inflate_huft *u[BMAX];        // table stack  
    1821   register int w;               // bits before this table == (l * h)  
    1822   uInt x[BMAX+1];               // bit offsets, then code stack  
    1823   uInt *xp;                    // pointer into x  
    1824   int y;                        // number of dummy codes added  
    1825   uInt z;                       // number of entries in current table  
     1818  inflate_huft *q;              // points to current table 
     1819  struct inflate_huft_s r;      // table entry for structure assignment 
     1820  inflate_huft *u[BMAX];        // table stack 
     1821  register int w;               // bits before this table == (l * h) 
     1822  uInt x[BMAX+1];               // bit offsets, then code stack 
     1823  uInt *xp;                    // pointer into x 
     1824  int y;                        // number of dummy codes added 
     1825  uInt z;                       // number of entries in current table 
    18261826 
    18271827  // provide a default value 
    18281828  r.base = 0; 
    18291829 
    1830   // Generate counts for each bit length  
     1830  // Generate counts for each bit length 
    18311831  p = c; 
    18321832#define C0 *p++ = 0; 
     
    18361836  p = b;  i = n; 
    18371837  do { 
    1838     c[*p++]++;                  // assume all entries <= BMAX  
     1838    c[*p++]++;                  // assume all entries <= BMAX 
    18391839  } while (--i); 
    1840   if (c[0] == n)                // null input--all zero length codes  
     1840  if (c[0] == n)                // null input--all zero length codes 
    18411841  { 
    18421842    *t = (inflate_huft *)Z_NULL; 
     
    18461846 
    18471847 
    1848   // Find minimum and maximum length, bound *m by those  
     1848  // Find minimum and maximum length, bound *m by those 
    18491849  l = *m; 
    18501850  for (j = 1; j <= BMAX; j++) 
    18511851    if (c[j]) 
    18521852      break; 
    1853   k = j;                        // minimum code length  
     1853  k = j;                        // minimum code length 
    18541854  if ((uInt)l < j) 
    18551855    l = j; 
     
    18571857    if (c[i]) 
    18581858      break; 
    1859   g = i;                        // maximum code length  
     1859  g = i;                        // maximum code length 
    18601860  if ((uInt)l > i) 
    18611861    l = i; 
     
    18631863 
    18641864 
    1865   // Adjust last length count to fill out codes, if needed  
     1865  // Adjust last length count to fill out codes, if needed 
    18661866  for (y = 1 << j; j < i; j++, y <<= 1) 
    18671867    if ((y -= c[j]) < 0) 
     
    18721872 
    18731873 
    1874   // Generate starting offsets into the value table for each length  
     1874  // Generate starting offsets into the value table for each length 
    18751875  x[1] = j = 0; 
    18761876  p = c + 1;  xp = x + 2; 
    1877   while (--i) {                 // note that i == g from above  
     1877  while (--i) {                 // note that i == g from above 
    18781878    *xp++ = (j += *p++); 
    18791879  } 
    18801880 
    18811881 
    1882   // Make a table of values in order of bit lengths  
     1882  // Make a table of values in order of bit lengths 
    18831883  p = b;  i = 0; 
    18841884  do { 
     
    18861886      v[x[j]++] = i; 
    18871887  } while (++i < n); 
    1888   n = x[g];                     // set n to length of v  
    1889  
    1890  
    1891   // Generate the Huffman codes and for each, make the table entries  
    1892   x[0] = i = 0;                 // first Huffman code is zero  
    1893   p = v;                        // grab values in bit order  
    1894   h = -1;                       // no tables yet--level -1  
    1895   w = -l;                       // bits decoded == (l * h)  
    1896   u[0] = (inflate_huft *)Z_NULL;        // just to keep compilers happy  
    1897   q = (inflate_huft *)Z_NULL;   // ditto  
    1898   z = 0;                        // ditto  
    1899  
    1900   // go through the bit lengths (k already is bits in shortest code)  
     1888  n = x[g];                     // set n to length of v 
     1889 
     1890 
     1891  // Generate the Huffman codes and for each, make the table entries 
     1892  x[0] = i = 0;                 // first Huffman code is zero 
     1893  p = v;                        // grab values in bit order 
     1894  h = -1;                       // no tables yet--level -1 
     1895  w = -l;                       // bits decoded == (l * h) 
     1896  u[0] = (inflate_huft *)Z_NULL;        // just to keep compilers happy 
     1897  q = (inflate_huft *)Z_NULL;   // ditto 
     1898  z = 0;                        // ditto 
     1899 
     1900  // go through the bit lengths (k already is bits in shortest code) 
    19011901  for (; k <= g; k++) 
    19021902  { 
     
    19041904    while (a--) 
    19051905    { 
    1906       // here i is the Huffman code of length k bits for value *p  
    1907       // make tables up to required level  
     1906      // here i is the Huffman code of length k bits for value *p 
     1907      // make tables up to required level 
    19081908      while (k > w + l) 
    19091909      { 
    19101910        h++; 
    1911         w += l;                 // previous table always l bits  
     1911        w += l;                 // previous table always l bits 
    19121912 
    19131913        // compute minimum size table less than or equal to l bits 
    19141914        z = g - w; 
    1915         z = z > (uInt)l ? l : z;        // table size upper limit  
    1916         if ((f = 1 << (j = k - w)) > a + 1)     // try a k-w bit table  
    1917         {                       // too few codes for k-w bit table  
    1918           f -= a + 1;           // deduct codes from patterns left  
     1915        z = z > (uInt)l ? l : z;        // table size upper limit 
     1916        if ((f = 1 << (j = k - w)) > a + 1)     // try a k-w bit table 
     1917        {                       // too few codes for k-w bit table 
     1918          f -= a + 1;           // deduct codes from patterns left 
    19191919          xp = c + k; 
    19201920          if (j < z) 
    1921             while (++j < z)     // try smaller tables up to z bits  
     1921            while (++j < z)     // try smaller tables up to z bits 
    19221922            { 
    19231923              if ((f <<= 1) <= *++xp) 
    1924                 break;          // enough codes to use up j bits  
     1924                break;          // enough codes to use up j bits 
    19251925              f -= *xp;         // else deduct codes from patterns 
    19261926            } 
    19271927        } 
    1928         z = 1 << j;             // table entries for j-bit table  
    1929  
    1930         // allocate new table  
    1931         if (*hn + z > MANY)     // (note: doesn't matter for fixed)  
    1932           return Z_DATA_ERROR;  // overflow of MANY  
     1928        z = 1 << j;             // table entries for j-bit table 
     1929 
     1930        // allocate new table 
     1931        if (*hn + z > MANY)     // (note: doesn't matter for fixed) 
     1932          return Z_DATA_ERROR;  // overflow of MANY 
    19331933        u[h] = q = hp + *hn; 
    19341934        *hn += z; 
    19351935 
    1936         // connect to last table, if there is one  
     1936        // connect to last table, if there is one 
    19371937        if (h) 
    19381938        { 
    19391939          x[h] = i;             // save pattern for backing up 
    1940           r.bits = (Byte)l;     // bits to dump before this table  
    1941           r.exop = (Byte)j;     // bits in this table  
     1940          r.bits = (Byte)l;     // bits to dump before this table 
     1941          r.exop = (Byte)j;     // bits in this table 
    19421942          j = i >> (w - l); 
    1943           r.base = (uInt)(q - u[h-1] - j);   // offset to this table  
    1944           u[h-1][j] = r;        // connect to last table  
     1943          r.base = (uInt)(q - u[h-1] - j);   // offset to this table 
     1944          u[h-1][j] = r;        // connect to last table 
    19451945        } 
    19461946        else 
    1947           *t = q;               // first table is returned result  
     1947          *t = q;               // first table is returned result 
    19481948      } 
    19491949 
    1950       // set up table entry in r  
     1950      // set up table entry in r 
    19511951      r.bits = (Byte)(k - w); 
    19521952      if (p >= v + n) 
    1953         r.exop = 128 + 64;      // out of values--invalid code  
     1953        r.exop = 128 + 64;      // out of values--invalid code 
    19541954      else if (*p < s) 
    19551955      { 
    1956         r.exop = (Byte)(*p < 256 ? 0 : 32 + 64);     // 256 is end-of-block  
    1957         r.base = *p++;          // simple code is just the value  
     1956        r.exop = (Byte)(*p < 256 ? 0 : 32 + 64);     // 256 is end-of-block 
     1957        r.base = *p++;          // simple code is just the value 
    19581958      } 
    19591959      else 
    19601960      { 
    1961         r.exop = (Byte)(e[*p - s] + 16 + 64);// non-simple--look up in lists  
     1961        r.exop = (Byte)(e[*p - s] + 16 + 64);// non-simple--look up in lists 
    19621962        r.base = d[*p++ - s]; 
    19631963      } 
     
    19681968        q[j] = r; 
    19691969 
    1970       // backwards increment the k-bit code i  
     1970      // backwards increment the k-bit code i 
    19711971      for (j = 1 << (k - 1); i & j; j >>= 1) 
    19721972        i ^= j; 
    19731973      i ^= j; 
    19741974 
    1975       // backup over finished tables  
    1976       mask = (1 << w) - 1;      // needed on HP, cc -O bug  
     1975      // backup over finished tables 
     1976      mask = (1 << w) - 1;      // needed on HP, cc -O bug 
    19771977      while ((i & mask) != x[h]) 
    19781978      { 
     
    19851985 
    19861986 
    1987   // Return Z_BUF_ERROR if we were given an incomplete table  
     1987  // Return Z_BUF_ERROR if we were given an incomplete table 
    19881988  return y != 0 && g != 1 ? Z_BUF_ERROR : Z_OK; 
    19891989} 
     
    19981998{ 
    19991999  int r; 
    2000   uInt hn = 0;          // hufts used in space  
    2001   uInt *v;             // work area for huft_build  
     2000  uInt hn = 0;          // hufts used in space 
     2001  uInt *v;             // work area for huft_build 
    20022002 
    20032003  if ((v = (uInt*)ZALLOC(z, 19, sizeof(uInt))) == Z_NULL) 
     
    20292029{ 
    20302030  int r; 
    2031   uInt hn = 0;          // hufts used in space  
    2032   uInt *v;             // work area for huft_build  
    2033  
    2034   // allocate work area  
     2031  uInt hn = 0;          // hufts used in space 
     2032  uInt *v;             // work area for huft_build 
     2033 
     2034  // allocate work area 
    20352035  if ((v = (uInt*)ZALLOC(z, 288, sizeof(uInt))) == Z_NULL) 
    20362036    return Z_MEM_ERROR; 
    20372037 
    2038   // build literal/length tree  
     2038  // build literal/length tree 
    20392039  r = huft_build(c, nl, 257, cplens, cplext, tl, bl, hp, &hn, v); 
    20402040  if (r != Z_OK || *bl == 0) 
     
    20512051  } 
    20522052 
    2053   // build distance tree  
     2053  // build distance tree 
    20542054  r = huft_build(c + nl, nd, 0, cpdist, cpdext, td, bd, hp, &hn, v); 
    20552055  if (r != Z_OK || (*bd == 0 && nl > 257)) 
     
    20702070  } 
    20712071 
    2072   // done  
     2072  // done 
    20732073  ZFREE(z, v); 
    20742074  return Z_OK; 
     
    21002100 
    21012101 
    2102 //struct inflate_codes_state {int dummy;}; // for buggy compilers  
    2103  
    2104  
    2105 // macros for bit input with no checking and for returning unused bytes  
     2102//struct inflate_codes_state {int dummy;}; // for buggy compilers 
     2103 
     2104 
     2105// macros for bit input with no checking and for returning unused bytes 
    21062106#define GRABBITS(j) {while(k<(j)){b|=((uLong)NEXTBYTE)<<k;k+=8;}} 
    21072107#define UNGRAB {c=z->avail_in-n;c=(k>>3)<c?k>>3:c;n+=c;p-=c;k-=c<<3;} 
     
    21102110// (the maximum string length) and number of input bytes available 
    21112111// at least ten.  The ten bytes are six bytes for the longest length/ 
    2112 // distance pair plus four bytes for overloading the bit buffer.  
     2112// distance pair plus four bytes for overloading the bit buffer. 
    21132113 
    21142114int inflate_fast( 
     
    21192119z_streamp z) 
    21202120{ 
    2121   const inflate_huft *t;      // temporary pointer  
    2122   uInt e;               // extra bits or operation  
    2123   uLong b;              // bit buffer  
    2124   uInt k;               // bits in bit buffer  
    2125   Byte *p;             // input data pointer  
    2126   uInt n;               // bytes available there  
    2127   Byte *q;             // output window write pointer  
    2128   uInt m;               // bytes to end of window or read pointer  
     2121  const inflate_huft *t;      // temporary pointer 
     2122  uInt e;               // extra bits or operation 
     2123  uLong b;              // bit buffer 
     2124  uInt k;               // bits in bit buffer 
     2125  Byte *p;             // input data pointer 
     2126  uInt n;               // bytes available there 
     2127  Byte *q;             // output window write pointer 
     2128  uInt m;               // bytes to end of window or read pointer 
    21292129  uInt ml;              // mask for literal/length tree 
    2130   uInt md;              // mask for distance tree  
    2131   uInt c;               // bytes to copy  
    2132   uInt d;               // distance back to copy from  
    2133   Byte *r;             // copy source pointer  
    2134  
    2135   // load input, output, bit values  
     2130  uInt md;              // mask for distance tree 
     2131  uInt c;               // bytes to copy 
     2132  uInt d;               // distance back to copy from 
     2133  Byte *r;             // copy source pointer 
     2134 
     2135  // load input, output, bit values 
    21362136  LOAD 
    21372137 
    2138   // initialize masks  
     2138  // initialize masks 
    21392139  ml = inflate_mask[bl]; 
    21402140  md = inflate_mask[bd]; 
    21412141 
    2142   // do until not enough input or output space for fast loop  
    2143   do {                          // assume called with m >= 258 && n >= 10  
    2144     // get literal/length code  
    2145     GRABBITS(20)                // max bits for literal/length code  
     2142  // do until not enough input or output space for fast loop 
     2143  do {                          // assume called with m >= 258 && n >= 10 
     2144    // get literal/length code 
     2145    GRABBITS(20)                // max bits for literal/length code 
    21462146    if ((e = (t = tl + ((uInt)b & ml))->exop) == 0) 
    21472147    { 
     
    21582158      if (e & 16) 
    21592159      { 
    2160         // get extra bits for length  
     2160        // get extra bits for length 
    21612161        e &= 15; 
    21622162        c = t->base + ((uInt)b & inflate_mask[e]); 
     
    21642164        LuTracevv((stderr, "inflate:         * length %u\n", c)); 
    21652165 
    2166         // decode distance base of block to copy  
    2167         GRABBITS(15);           // max bits for distance code  
     2166        // decode distance base of block to copy 
     2167        GRABBITS(15);           // max bits for distance code 
    21682168        e = (t = td + ((uInt)b & md))->exop; 
    21692169        for (;;) { 
     
    21712171          if (e & 16) 
    21722172          { 
    2173             // get extra bits to add to distance base  
     2173            // get extra bits to add to distance base 
    21742174            e &= 15; 
    2175             GRABBITS(e)         // get extra bits (up to 13)  
     2175            GRABBITS(e)         // get extra bits (up to 13) 
    21762176            d = t->base + ((uInt)b & inflate_mask[e]); 
    21772177            DUMPBITS(e) 
     
    25952595  LuTracev((stderr, "inflate: allocated\n")); 
    25962596 
    2597   // reset state  
     2597  // reset state 
    25982598  inflateReset(z); 
    25992599  return Z_OK; 
     
    26402640        z->state->mode = IM_BAD; 
    26412641        z->msg = (char*)"incorrect header check"; 
    2642         z->state->sub.marker = 5;       // can't try inflateSync  
     2642        z->state->sub.marker = 5;       // can't try inflateSync 
    26432643        break; 
    26442644      } 
     
    26712671      z->state->mode = IM_BAD; 
    26722672      z->msg = (char*)"need dictionary"; 
    2673       z->state->sub.marker = 0;       // can try inflateSync  
     2673      z->state->sub.marker = 0;       // can try inflateSync 
    26742674      return Z_STREAM_ERROR; 
    26752675    case IM_BLOCKS: 
     
    26782678      { 
    26792679        z->state->mode = IM_BAD; 
    2680         z->state->sub.marker = 0;       // can try inflateSync  
     2680        z->state->sub.marker = 0;       // can try inflateSync 
    26812681        break; 
    26822682      } 
     
    27132713        z->state->mode = IM_BAD; 
    27142714        z->msg = (char*)"incorrect data check"; 
    2715         z->state->sub.marker = 5;       // can't try inflateSync  
     2715        z->state->sub.marker = 5;       // can't try inflateSync 
    27162716        break; 
    27172717      } 
     
    27532753    unz_file_info_internal_s(): 
    27542754        offset_curfile(0) {} 
    2755          
     2755 
    27562756    uLong offset_curfile;// relative offset of local header 4 bytes 
    27572757} unz_file_info_internal; 
     
    28402840int lufseek(LUFILE *stream, long offset, int whence) 
    28412841{ if (stream->is_handle && stream->canseek) 
    2842   {  
     2842  { 
    28432843#ifdef ZIP_STD 
    28442844    return fseek(stream->h,stream->initial_offset+offset,whence); 
     
    28642864{ unsigned int toread = (unsigned int)(size*n); 
    28652865  if (stream->is_handle) 
    2866   {  
     2866  { 
    28672867#ifdef ZIP_STD 
    28682868    return fread(ptr,size,n,stream->h); 
     
    30153015    err = unzlocal_getByte(fin,&i); 
    30163016    x = (uLong)i; 
    3017      
     3017 
    30183018    if (err==UNZ_OK) 
    30193019        err = unzlocal_getByte(fin,&i); 
     
    30273027        err = unzlocal_getByte(fin,&i); 
    30283028    x += ((uLong)i)<<24; 
    3029     
     3029 
    30303030    if (err==UNZ_OK) 
    30313031        *pX = x; 
     
    30363036 
    30373037 
    3038 // My own strcmpi / strcasecmp  
     3038// My own strcmpi / strcasecmp 
    30393039int strcmpcasenosensitive_internal (const char* fileName1,const char *fileName2) 
    30403040{ 
     
    30693069{ if (iCaseSensitivity==1) return strcmp(fileName1,fileName2); 
    30703070  else return strcmpcasenosensitive_internal(fileName1,fileName2); 
    3071 }  
     3071} 
    30723072 
    30733073#define BUFREADCOMMENT (0x400) 
     
    31693169int unzClose (unzFile file) 
    31703170{ 
    3171      
     3171 
    31723172    if (file==NULL) 
    31733173        return UNZ_PARAMERROR; 
     
    31863186//  Write info about the ZipFile in the *pglobal_info structure. 
    31873187//  No preparation of the structure is needed 
    3188 //  return UNZ_OK if there is no problem.  
     3188//  return UNZ_OK if there is no problem. 
    31893189int unzGetGlobalInfo (unzFile file,unz_global_info *pglobal_info) 
    31903190{ 
     
    41794179    // make sure there rd is always null terminated 
    41804180    rd[MAX_PATH] = 0; 
    4181    
     4181 
    41824182    size_t len=_tcslen(rd); 
    41834183    if (len>0 && (rd[len-1]=='/' || rd[len-1]=='\\')) rd[len-1]=0; 
     
    41984198    name++; 
    41994199  } 
    4200   TCHAR cd[MAX_PATH]; *cd=0;  
    4201   if (rootdir!=0)  
     4200  TCHAR cd[MAX_PATH]; *cd=0; 
     4201  if (rootdir!=0) 
    42024202#ifdef ZIP_STD 
    42034203  strncpy(cd,rootdir,MAX_PATH); 
    42044204#else 
    42054205  _tcsncpy_s(cd,MAX_PATH,rootdir,MAX_PATH); 
    4206 #endif   
    4207    
     4206#endif 
     4207 
    42084208  cd[MAX_PATH-1]=0; 
    42094209  size_t len=_tcslen(cd); 
    4210    
     4210 
    42114211#ifdef ZIP_STD 
    42124212  strncpy(cd+len,dir,MAX_PATH-len); 
    42134213#else 
    42144214  _tcsncpy_s(cd+len,MAX_PATH-len,dir,MAX_PATH-len); 
    4215 #endif  
    4216    
    4217    
     4215#endif 
     4216 
     4217 
    42184218  cd[MAX_PATH-1]=0; 
    42194219#ifdef ZIP_STD 
     
    42404240    bool reached_eof; 
    42414241    int res = unzReadCurrentFile(uf,dst,len,&reached_eof); 
    4242     if (res<=0)  
     4242    if (res<=0) 
    42434243    { 
    42444244       unzCloseCurrentFile(uf); currentfile=-1; 
     
    42934293    // is how the user retrieve's the file's name within the zip) never returns absolute paths. 
    42944294    const TCHAR *name=ufn; const TCHAR *c=name; while (*c!=0) {if (*c=='/' || *c=='\\') name=c+1; c++;} 
    4295     TCHAR dir[MAX_PATH];  
     4295    TCHAR dir[MAX_PATH]; 
    42964296 
    42974297#ifdef ZIP_STD 
     
    42994299#else 
    43004300  _tcsncpy_s(dir,MAX_PATH,ufn,MAX_PATH); 
    4301 #endif  
    4302          
     4301#endif 
     4302 
    43034303 
    43044304        if (name==ufn) *dir=0; else dir[name-ufn]=0; 
    43054305    bool isabsolute = (dir[0]=='/' || dir[0]=='\\' || (dir[0]!=0 && dir[1]==':')); 
    43064306 
    4307     if (isabsolute)  
     4307    if (isabsolute) 
    43084308        { 
    4309                  
     4309 
    43104310#ifdef ZIP_STD 
    43114311                size_t dirlen=_tcslen(dir); 
     
    43144314#else 
    43154315                _tsprintf(fn,MAX_PATH,_T("%s%s"),dir,name); 
    4316 #endif  
     4316#endif 
    43174317                EnsureDirectory(0,dir); 
    4318          
     4318 
    43194319        } 
    4320     else  
     4320    else 
    43214321        { 
    43224322#ifdef ZIP_STD 
     
    43414341  unzOpenCurrentFile(uf,password); 
    43424342  if (unzbuf==0) unzbuf=new char[16384]; DWORD haderr=0; 
    4343   //   
     4343  // 
    43444344 
    43454345  for (; haderr==0;) 
     
    44154415#else 
    44164416  _tcsncpy_s(buf,_tcslen(buf),msg,n); 
    4417 #endif  
    4418    
    4419    
    4420    
    4421    
     4417#endif 
     4418 
     4419 
     4420 
     4421 
    44224422  buf[n]=0; 
    44234423  return mlen;