gerrit.simantics Code Review - simantics/sysdyn.git/blob

   1 ; Listing generated by Microsoft (R) Optimizing Compiler Version 16.00.30319.01 \r
   2 \r
   3         TITLE   C:\Workspaces\Sysdyn\org.simantics.fmu\FMUSolution\zlib-1.2.6\gzread.c\r
   4         .686P\r
   5         .XMM\r
   6         include listing.inc\r
   7         .model  flat\r
   8 \r
   9 INCLUDELIB OLDNAMES\r
  10 \r
  11 PUBLIC  ??_C@_0BH@CFIIDOJD@unexpected?5end?5of?5file?$AA@ ; `string'\r
  12 PUBLIC  ??_C@_0CH@CPOLIEKA@internal?5error?3?5inflate?5stream?5c@ ; `string'\r
  13 PUBLIC  ??_C@_0BG@HCKBMIHF@compressed?5data?5error?$AA@ ; `string'\r
  14 PUBLIC  ??_C@_0CF@MLPJFDMM@requested?5length?5does?5not?5fit?5in@ ; `string'\r
  15 PUBLIC  ??_C@_0BP@IIKIGMCC@out?5of?5room?5to?5push?5characters?$AA@ ; `string'\r
  16 EXTRN   __imp__memchr:PROC\r
  17 EXTRN   __imp__memmove:PROC\r
  18 EXTRN   __imp__strerror:PROC\r
  19 EXTRN   __imp___errno:PROC\r
  20 EXTRN   _read:PROC\r
  21 EXTRN   _close:PROC\r
  22 ;       COMDAT ??_C@_0BP@IIKIGMCC@out?5of?5room?5to?5push?5characters?$AA@\r
  23 CONST   SEGMENT\r
  24 ??_C@_0BP@IIKIGMCC@out?5of?5room?5to?5push?5characters?$AA@ DB 'out of ro'\r
  25         DB      'om to push characters', 00H                    ; `string'\r
  26 CONST   ENDS\r
  27 ;       COMDAT ??_C@_0CF@MLPJFDMM@requested?5length?5does?5not?5fit?5in@\r
  28 CONST   SEGMENT\r
  29 ??_C@_0CF@MLPJFDMM@requested?5length?5does?5not?5fit?5in@ DB 'requested l'\r
  30         DB      'ength does not fit in int', 00H                ; `string'\r
  31 CONST   ENDS\r
  32 ;       COMDAT ??_C@_0BG@HCKBMIHF@compressed?5data?5error?$AA@\r
  33 CONST   SEGMENT\r
  34 ??_C@_0BG@HCKBMIHF@compressed?5data?5error?$AA@ DB 'compressed data error'\r
  35         DB      00H                                             ; `string'\r
  36 CONST   ENDS\r
  37 ;       COMDAT ??_C@_0CH@CPOLIEKA@internal?5error?3?5inflate?5stream?5c@\r
  38 CONST   SEGMENT\r
  39 ??_C@_0CH@CPOLIEKA@internal?5error?3?5inflate?5stream?5c@ DB 'internal er'\r
  40         DB      'ror: inflate stream corrupt', 00H              ; `string'\r
  41 CONST   ENDS\r
  42 ;       COMDAT ??_C@_0BH@CFIIDOJD@unexpected?5end?5of?5file?$AA@\r
  43 CONST   SEGMENT\r
  44 ??_C@_0BH@CFIIDOJD@unexpected?5end?5of?5file?$AA@ DB 'unexpected end of f'\r
  45         DB      'ile', 00H                                      ; `string'\r
  46 PUBLIC  _gzclose_r@4\r
  47 ; Function compile flags: /Ogtp\r
  48 ; File c:\workspaces\sysdyn\org.simantics.fmu\fmusolution\zlib-1.2.6\gzread.c\r
  49 ;       COMDAT _gzclose_r@4\r
  50 _TEXT   SEGMENT\r
  51 _err$ = 8                                               ; size = 4\r
  52 _file$ = 8                                              ; size = 4\r
  53 _gzclose_r@4 PROC                                       ; COMDAT\r
  54 \r
  55 ; 559  : {\r
  56 \r
  57   00000 55               push    ebp\r
  58   00001 8b ec            mov     ebp, esp\r
  59   00003 56               push    esi\r
  60 \r
  61 ; 560  :     int ret, err;\r
  62 ; 561  :     gz_statep state;\r
  63 ; 562  : \r
  64 ; 563  :     /* get internal structure */\r
  65 ; 564  :     if (file == NULL)\r
  66 \r
  67   00004 8b 75 08         mov     esi, DWORD PTR _file$[ebp]\r
  68   00007 85 f6            test    esi, esi\r
  69   00009 75 0a            jne     SHORT $LN3@gzclose_r\r
  70 $LN8@gzclose_r:\r
  71 \r
  72 ; 565  :         return Z_STREAM_ERROR;\r
  73 \r
  74   0000b b8 fe ff ff ff   mov     eax, -2                        ; fffffffeH\r
  75   00010 5e               pop     esi\r
  76 \r
  77 ; 584  : }\r
  78 \r
  79   00011 5d               pop     ebp\r
  80   00012 c2 04 00         ret     4\r
  81 $LN3@gzclose_r:\r
  82 \r
  83 ; 566  :     state = (gz_statep)file;\r
  84 ; 567  : \r
  85 ; 568  :     /* check that we're reading */\r
  86 ; 569  :     if (state->mode != GZ_READ)\r
  87 \r
  88   00015 81 7e 10 4f 1c\r
  89         00 00            cmp     DWORD PTR [esi+16], 7247 ; 00001c4fH\r
  90 \r
  91 ; 570  :         return Z_STREAM_ERROR;\r
  92 \r
  93   0001c 75 ed            jne     SHORT $LN8@gzclose_r\r
  94 \r
  95 ; 571  : \r
  96 ; 572  :     /* free memory and close file */\r
  97 ; 573  :     if (state->size) {\r
  98 \r
  99   0001e 83 7e 1c 00      cmp     DWORD PTR [esi+28], 0\r
 100   00022 53               push    ebx\r
 101   00023 57               push    edi\r
 102   00024 8b 3d 00 00 00\r
 103         00               mov     edi, DWORD PTR __imp__free\r
 104   0002a 74 18            je      SHORT $LN1@gzclose_r\r
 105 \r
 106 ; 574  :         inflateEnd(&(state->strm));\r
 107 \r
 108   0002c 8d 46 64         lea     eax, DWORD PTR [esi+100]\r
 109   0002f 50               push    eax\r
 110   00030 e8 00 00 00 00   call    _inflateEnd@4\r
 111 \r
 112 ; 575  :         free(state->out);\r
 113 \r
 114   00035 8b 4e 28         mov     ecx, DWORD PTR [esi+40]\r
 115   00038 51               push    ecx\r
 116   00039 ff d7            call    edi\r
 117 \r
 118 ; 576  :         free(state->in);\r
 119 \r
 120   0003b 8b 56 24         mov     edx, DWORD PTR [esi+36]\r
 121   0003e 52               push    edx\r
 122   0003f ff d7            call    edi\r
 123   00041 83 c4 08         add     esp, 8\r
 124 $LN1@gzclose_r:\r
 125 \r
 126 ; 577  :     }\r
 127 ; 578  :     err = state->err == Z_BUF_ERROR ? Z_BUF_ERROR : Z_OK;\r
 128 \r
 129   00044 33 c0            xor     eax, eax\r
 130   00046 83 7e 5c fb      cmp     DWORD PTR [esi+92], -5 ; fffffffbH\r
 131 \r
 132 ; 579  :     gz_error(state, Z_OK, NULL);\r
 133 \r
 134   0004a 6a 00            push    0\r
 135   0004c 0f 95 c0         setne   al\r
 136   0004f 8b ce            mov     ecx, esi\r
 137   00051 48               dec     eax\r
 138   00052 83 e0 fb         and     eax, -5                        ; fffffffbH\r
 139   00055 89 45 08         mov     DWORD PTR _err$[ebp], eax\r
 140   00058 33 c0            xor     eax, eax\r
 141   0005a e8 00 00 00 00   call    _gz_error\r
 142 \r
 143 ; 580  :     free(state->path);\r
 144 \r
 145   0005f 8b 4e 18         mov     ecx, DWORD PTR [esi+24]\r
 146   00062 51               push    ecx\r
 147   00063 ff d7            call    edi\r
 148 \r
 149 ; 581  :     ret = close(state->fd);\r
 150 \r
 151   00065 8b 56 14         mov     edx, DWORD PTR [esi+20]\r
 152   00068 52               push    edx\r
 153   00069 e8 00 00 00 00   call    _close\r
 154 \r
 155 ; 582  :     free(state);\r
 156 \r
 157   0006e 56               push    esi\r
 158   0006f 8b d8            mov     ebx, eax\r
 159   00071 ff d7            call    edi\r
 160   00073 83 c4 10         add     esp, 16                        ; 00000010H\r
 161   00076 5f               pop     edi\r
 162 \r
 163 ; 583  :     return ret ? Z_ERRNO : err;\r
 164 \r
 165   00077 85 db            test    ebx, ebx\r
 166   00079 5b               pop     ebx\r
 167   0007a 74 08            je      SHORT $LN6@gzclose_r\r
 168   0007c 83 c8 ff         or      eax, -1\r
 169   0007f 5e               pop     esi\r
 170 \r
 171 ; 584  : }\r
 172 \r
 173   00080 5d               pop     ebp\r
 174   00081 c2 04 00         ret     4\r
 175 $LN6@gzclose_r:\r
 176 \r
 177 ; 583  :     return ret ? Z_ERRNO : err;\r
 178 \r
 179   00084 8b 45 08         mov     eax, DWORD PTR _err$[ebp]\r
 180   00087 5e               pop     esi\r
 181 \r
 182 ; 584  : }\r
 183 \r
 184   00088 5d               pop     ebp\r
 185   00089 c2 04 00         ret     4\r
 186 _gzclose_r@4 ENDP\r
 187 ; Function compile flags: /Ogtp\r
 188 _TEXT   ENDS\r
 189 ;       COMDAT _gz_load\r
 190 _TEXT   SEGMENT\r
 191 _buf$ = 8                                               ; size = 4\r
 192 _gz_load PROC                                           ; COMDAT\r
 193 ; _state$ = ebx\r
 194 ; _len$ = edi\r
 195 ; _have$ = esi\r
 196 \r
 197 ; 25   : {\r
 198 \r
 199   00000 55               push    ebp\r
 200   00001 8b ec            mov     ebp, esp\r
 201 \r
 202 ; 26   :     int ret;\r
 203 ; 27   : \r
 204 ; 28   :     *have = 0;\r
 205 \r
 206   00003 c7 06 00 00 00\r
 207         00               mov     DWORD PTR [esi], 0\r
 208   00009 8d a4 24 00 00\r
 209         00 00            npad    7\r
 210 $LL6@gz_load:\r
 211 \r
 212 ; 29   :     do {\r
 213 ; 30   :         ret = read(state->fd, buf + *have, len - *have);\r
 214 \r
 215   00010 8b 06            mov     eax, DWORD PTR [esi]\r
 216   00012 8b cf            mov     ecx, edi\r
 217   00014 2b c8            sub     ecx, eax\r
 218   00016 03 45 08         add     eax, DWORD PTR _buf$[ebp]\r
 219   00019 51               push    ecx\r
 220   0001a 50               push    eax\r
 221   0001b 8b 43 14         mov     eax, DWORD PTR [ebx+20]\r
 222   0001e 50               push    eax\r
 223   0001f e8 00 00 00 00   call    _read\r
 224   00024 83 c4 0c         add     esp, 12                        ; 0000000cH\r
 225 \r
 226 ; 31   :         if (ret <= 0)\r
 227 \r
 228   00027 85 c0            test    eax, eax\r
 229   00029 7e 08            jle     SHORT $LN11@gz_load\r
 230 \r
 231 ; 32   :             break;\r
 232 ; 33   :         *have += ret;\r
 233 \r
 234   0002b 01 06            add     DWORD PTR [esi], eax\r
 235 \r
 236 ; 34   :     } while (*have < len);\r
 237 \r
 238   0002d 39 3e            cmp     DWORD PTR [esi], edi\r
 239   0002f 72 df            jb      SHORT $LL6@gz_load\r
 240 \r
 241 ; 35   :     if (ret < 0) {\r
 242 \r
 243   00031 85 c0            test    eax, eax\r
 244 $LN11@gz_load:\r
 245   00033 79 22            jns     SHORT $LN2@gz_load\r
 246 \r
 247 ; 36   :         gz_error(state, Z_ERRNO, zstrerror());\r
 248 \r
 249   00035 ff 15 00 00 00\r
 250         00               call    DWORD PTR __imp___errno\r
 251   0003b 8b 08            mov     ecx, DWORD PTR [eax]\r
 252   0003d 51               push    ecx\r
 253   0003e ff 15 00 00 00\r
 254         00               call    DWORD PTR __imp__strerror\r
 255   00044 50               push    eax\r
 256   00045 83 c8 ff         or      eax, -1\r
 257   00048 8b cb            mov     ecx, ebx\r
 258   0004a e8 00 00 00 00   call    _gz_error\r
 259   0004f 83 c4 08         add     esp, 8\r
 260 \r
 261 ; 37   :         return -1;\r
 262 \r
 263   00052 83 c8 ff         or      eax, -1\r
 264 \r
 265 ; 42   : }\r
 266 \r
 267   00055 5d               pop     ebp\r
 268   00056 c3               ret     0\r
 269 $LN2@gz_load:\r
 270 \r
 271 ; 38   :     }\r
 272 ; 39   :     if (ret == 0)\r
 273 \r
 274   00057 85 c0            test    eax, eax\r
 275   00059 75 07            jne     SHORT $LN1@gz_load\r
 276 \r
 277 ; 40   :         state->eof = 1;\r
 278 \r
 279   0005b c7 43 40 01 00\r
 280         00 00            mov     DWORD PTR [ebx+64], 1\r
 281 $LN1@gz_load:\r
 282 \r
 283 ; 41   :     return 0;\r
 284 \r
 285   00062 33 c0            xor     eax, eax\r
 286 \r
 287 ; 42   : }\r
 288 \r
 289   00064 5d               pop     ebp\r
 290   00065 c3               ret     0\r
 291 _gz_load ENDP\r
 292 ; Function compile flags: /Ogtp\r
 293 ;       COMDAT _gz_avail\r
 294 _TEXT   SEGMENT\r
 295 _got$ = -4                                              ; size = 4\r
 296 _gz_avail PROC                                          ; COMDAT\r
 297 ; _state$ = eax\r
 298 \r
 299 ; 53   : {\r
 300 \r
 301   00000 55               push    ebp\r
 302   00001 8b ec            mov     ebp, esp\r
 303   00003 51               push    ecx\r
 304   00004 53               push    ebx\r
 305   00005 8b d8            mov     ebx, eax\r
 306 \r
 307 ; 54   :     unsigned got;\r
 308 ; 55   :     z_streamp strm = &(state->strm);\r
 309 ; 56   : \r
 310 ; 57   :     if (state->err != Z_OK && state->err != Z_BUF_ERROR)\r
 311 \r
 312   00007 8b 43 5c         mov     eax, DWORD PTR [ebx+92]\r
 313   0000a 85 c0            test    eax, eax\r
 314   0000c 74 0d            je      SHORT $LN4@gz_avail\r
 315   0000e 83 f8 fb         cmp     eax, -5                        ; fffffffbH\r
 316   00011 74 08            je      SHORT $LN4@gz_avail\r
 317 $LN7@gz_avail:\r
 318 \r
 319 ; 58   :         return -1;\r
 320 \r
 321   00013 83 c8 ff         or      eax, -1\r
 322   00016 5b               pop     ebx\r
 323 \r
 324 ; 69   : }\r
 325 \r
 326   00017 8b e5            mov     esp, ebp\r
 327   00019 5d               pop     ebp\r
 328   0001a c3               ret     0\r
 329 $LN4@gz_avail:\r
 330 \r
 331 ; 59   :     if (state->eof == 0) {\r
 332 \r
 333   0001b 83 7b 40 00      cmp     DWORD PTR [ebx+64], 0\r
 334   0001f 75 47            jne     SHORT $LN3@gz_avail\r
 335 \r
 336 ; 60   :         if (strm->avail_in)\r
 337 \r
 338   00021 8b 43 68         mov     eax, DWORD PTR [ebx+104]\r
 339   00024 85 c0            test    eax, eax\r
 340   00026 74 12            je      SHORT $LN2@gz_avail\r
 341 \r
 342 ; 61   :             memmove(state->in, strm->next_in, strm->avail_in);\r
 343 \r
 344   00028 8b 4b 24         mov     ecx, DWORD PTR [ebx+36]\r
 345   0002b 50               push    eax\r
 346   0002c 8b 43 64         mov     eax, DWORD PTR [ebx+100]\r
 347   0002f 50               push    eax\r
 348   00030 51               push    ecx\r
 349   00031 ff 15 00 00 00\r
 350         00               call    DWORD PTR __imp__memmove\r
 351   00037 83 c4 0c         add     esp, 12                        ; 0000000cH\r
 352 $LN2@gz_avail:\r
 353 \r
 354 ; 62   :         if (gz_load(state, state->in + strm->avail_in,\r
 355 ; 63   :                     state->size - strm->avail_in, &got) == -1)\r
 356 \r
 357   0003a 8b 43 68         mov     eax, DWORD PTR [ebx+104]\r
 358   0003d 8b 53 24         mov     edx, DWORD PTR [ebx+36]\r
 359   00040 56               push    esi\r
 360   00041 57               push    edi\r
 361   00042 8b 7b 1c         mov     edi, DWORD PTR [ebx+28]\r
 362   00045 03 d0            add     edx, eax\r
 363   00047 2b f8            sub     edi, eax\r
 364   00049 52               push    edx\r
 365   0004a 8d 75 fc         lea     esi, DWORD PTR _got$[ebp]\r
 366   0004d e8 00 00 00 00   call    _gz_load\r
 367   00052 83 c4 04         add     esp, 4\r
 368   00055 5f               pop     edi\r
 369   00056 5e               pop     esi\r
 370   00057 83 f8 ff         cmp     eax, -1\r
 371 \r
 372 ; 64   :             return -1;\r
 373 \r
 374   0005a 74 b7            je      SHORT $LN7@gz_avail\r
 375 \r
 376 ; 65   :         strm->avail_in += got;\r
 377 \r
 378   0005c 8b 45 fc         mov     eax, DWORD PTR _got$[ebp]\r
 379   0005f 01 43 68         add     DWORD PTR [ebx+104], eax\r
 380 \r
 381 ; 66   :         strm->next_in = state->in;\r
 382 \r
 383   00062 8b 4b 24         mov     ecx, DWORD PTR [ebx+36]\r
 384   00065 89 4b 64         mov     DWORD PTR [ebx+100], ecx\r
 385 $LN3@gz_avail:\r
 386 \r
 387 ; 67   :     }\r
 388 ; 68   :     return 0;\r
 389 \r
 390   00068 33 c0            xor     eax, eax\r
 391   0006a 5b               pop     ebx\r
 392 \r
 393 ; 69   : }\r
 394 \r
 395   0006b 8b e5            mov     esp, ebp\r
 396   0006d 5d               pop     ebp\r
 397   0006e c3               ret     0\r
 398 _gz_avail ENDP\r
 399 ; Function compile flags: /Ogtp\r
 400 ;       COMDAT _gz_decomp\r
 401 _TEXT   SEGMENT\r
 402 _had$ = -4                                              ; size = 4\r
 403 _gz_decomp PROC                                         ; COMDAT\r
 404 ; _state$ = ebx\r
 405 \r
 406 ; 168  : {\r
 407 \r
 408   00000 55               push    ebp\r
 409   00001 8b ec            mov     ebp, esp\r
 410   00003 51               push    ecx\r
 411 \r
 412 ; 169  :     int ret = Z_OK;\r
 413 ; 170  :     unsigned had;\r
 414 ; 171  :     z_streamp strm = &(state->strm);\r
 415 ; 172  : \r
 416 ; 173  :     /* fill output buffer up to end of deflate stream */\r
 417 ; 174  :     had = strm->avail_out;\r
 418 \r
 419   00004 8b 43 74         mov     eax, DWORD PTR [ebx+116]\r
 420   00007 56               push    esi\r
 421   00008 57               push    edi\r
 422   00009 8d 7b 64         lea     edi, DWORD PTR [ebx+100]\r
 423   0000c 33 f6            xor     esi, esi\r
 424   0000e 89 45 fc         mov     DWORD PTR _had$[ebp], eax\r
 425 $LL11@gz_decomp:\r
 426 \r
 427 ; 175  :     do {\r
 428 ; 176  :         /* get more input for inflate() */\r
 429 ; 177  :         if (strm->avail_in == 0 && gz_avail(state) == -1)\r
 430 \r
 431   00011 83 7f 04 00      cmp     DWORD PTR [edi+4], 0\r
 432   00015 75 16            jne     SHORT $LN22@gz_decomp\r
 433   00017 8b c3            mov     eax, ebx\r
 434   00019 e8 00 00 00 00   call    _gz_avail\r
 435   0001e 83 f8 ff         cmp     eax, -1\r
 436   00021 0f 84 c7 00 00\r
 437         00               je      $LN17@gz_decomp\r
 438 \r
 439 ; 178  :             return -1;\r
 440 ; 179  :         if (strm->avail_in == 0) {\r
 441 \r
 442   00027 83 7f 04 00      cmp     DWORD PTR [edi+4], 0\r
 443   0002b 74 55            je      SHORT $LN18@gz_decomp\r
 444 $LN22@gz_decomp:\r
 445 \r
 446 ; 182  :         }\r
 447 ; 183  : \r
 448 ; 184  :         /* decompress and handle errors */\r
 449 ; 185  :         ret = inflate(strm, Z_NO_FLUSH);\r
 450 \r
 451   0002d 6a 00            push    0\r
 452   0002f 57               push    edi\r
 453   00030 e8 00 00 00 00   call    _inflate@8\r
 454   00035 8b f0            mov     esi, eax\r
 455 \r
 456 ; 186  :         if (ret == Z_STREAM_ERROR || ret == Z_NEED_DICT) {\r
 457 \r
 458   00037 83 fe fe         cmp     esi, -2                        ; fffffffeH\r
 459   0003a 0f 84 9a 00 00\r
 460         00               je      $LN5@gz_decomp\r
 461   00040 83 fe 02         cmp     esi, 2\r
 462   00043 0f 84 91 00 00\r
 463         00               je      $LN5@gz_decomp\r
 464 \r
 465 ; 190  :         }\r
 466 ; 191  :         if (ret == Z_MEM_ERROR) {\r
 467 \r
 468   00049 83 fe fc         cmp     esi, -4                        ; fffffffcH\r
 469   0004c 74 4a            je      SHORT $LN20@gz_decomp\r
 470 \r
 471 ; 193  :             return -1;\r
 472 ; 194  :         }\r
 473 ; 195  :         if (ret == Z_DATA_ERROR) {              /* deflate stream invalid */\r
 474 \r
 475   0004e 83 fe fd         cmp     esi, -3                        ; fffffffdH\r
 476   00051 74 62            je      SHORT $LN21@gz_decomp\r
 477 \r
 478 ; 198  :             return -1;\r
 479 ; 199  :         }\r
 480 ; 200  :     } while (strm->avail_out && ret != Z_STREAM_END);\r
 481 \r
 482   00053 83 7f 10 00      cmp     DWORD PTR [edi+16], 0\r
 483   00057 74 05            je      SHORT $LN9@gz_decomp\r
 484   00059 83 fe 01         cmp     esi, 1\r
 485   0005c 75 b3            jne     SHORT $LL11@gz_decomp\r
 486 $LN9@gz_decomp:\r
 487 \r
 488 ; 201  : \r
 489 ; 202  :     /* update available output */\r
 490 ; 203  :     state->x.have = had - strm->avail_out;\r
 491 \r
 492   0005e 8b 45 fc         mov     eax, DWORD PTR _had$[ebp]\r
 493   00061 2b 47 10         sub     eax, DWORD PTR [edi+16]\r
 494   00064 89 03            mov     DWORD PTR [ebx], eax\r
 495 \r
 496 ; 204  :     state->x.next = strm->next_out - state->x.have;\r
 497 \r
 498   00066 8b 4f 0c         mov     ecx, DWORD PTR [edi+12]\r
 499   00069 2b c8            sub     ecx, eax\r
 500   0006b 89 4b 04         mov     DWORD PTR [ebx+4], ecx\r
 501 \r
 502 ; 205  : \r
 503 ; 206  :     /* if the gzip stream completed successfully, look for another */\r
 504 ; 207  :     if (ret == Z_STREAM_END)\r
 505 \r
 506   0006e 83 fe 01         cmp     esi, 1\r
 507   00071 75 07            jne     SHORT $LN1@gz_decomp\r
 508 \r
 509 ; 208  :         state->how = LOOK;\r
 510 \r
 511   00073 c7 43 30 00 00\r
 512         00 00            mov     DWORD PTR [ebx+48], 0\r
 513 $LN1@gz_decomp:\r
 514   0007a 5f               pop     edi\r
 515 \r
 516 ; 209  : \r
 517 ; 210  :     /* good decompression */\r
 518 ; 211  :     return 0;\r
 519 \r
 520   0007b 33 c0            xor     eax, eax\r
 521   0007d 5e               pop     esi\r
 522 \r
 523 ; 212  : }\r
 524 \r
 525   0007e 8b e5            mov     esp, ebp\r
 526   00080 5d               pop     ebp\r
 527   00081 c3               ret     0\r
 528 $LN18@gz_decomp:\r
 529 \r
 530 ; 180  :             gz_error(state, Z_BUF_ERROR, "unexpected end of file");\r
 531 \r
 532   00082 68 00 00 00 00   push    OFFSET ??_C@_0BH@CFIIDOJD@unexpected?5end?5of?5file?$AA@\r
 533   00087 b8 fb ff ff ff   mov     eax, -5                        ; fffffffbH\r
 534   0008c 8b cb            mov     ecx, ebx\r
 535   0008e e8 00 00 00 00   call    _gz_error\r
 536   00093 83 c4 04         add     esp, 4\r
 537 \r
 538 ; 181  :             break;\r
 539 \r
 540   00096 eb c6            jmp     SHORT $LN9@gz_decomp\r
 541 $LN20@gz_decomp:\r
 542 \r
 543 ; 192  :             gz_error(state, Z_MEM_ERROR, "out of memory");\r
 544 \r
 545   00098 68 00 00 00 00   push    OFFSET ??_C@_0O@BNNCBLEN@out?5of?5memory?$AA@\r
 546   0009d b8 fc ff ff ff   mov     eax, -4                        ; fffffffcH\r
 547   000a2 8b cb            mov     ecx, ebx\r
 548   000a4 e8 00 00 00 00   call    _gz_error\r
 549   000a9 83 c4 04         add     esp, 4\r
 550   000ac 5f               pop     edi\r
 551   000ad 83 c8 ff         or      eax, -1\r
 552   000b0 5e               pop     esi\r
 553 \r
 554 ; 212  : }\r
 555 \r
 556   000b1 8b e5            mov     esp, ebp\r
 557   000b3 5d               pop     ebp\r
 558   000b4 c3               ret     0\r
 559 $LN21@gz_decomp:\r
 560 \r
 561 ; 196  :             gz_error(state, Z_DATA_ERROR,\r
 562 ; 197  :                      strm->msg == NULL ? "compressed data error" : strm->msg);\r
 563 \r
 564   000b5 8b 7f 18         mov     edi, DWORD PTR [edi+24]\r
 565   000b8 85 ff            test    edi, edi\r
 566   000ba 75 05            jne     SHORT $LN14@gz_decomp\r
 567   000bc bf 00 00 00 00   mov     edi, OFFSET ??_C@_0BG@HCKBMIHF@compressed?5data?5error?$AA@\r
 568 $LN14@gz_decomp:\r
 569   000c1 57               push    edi\r
 570   000c2 b8 fd ff ff ff   mov     eax, -3                        ; fffffffdH\r
 571   000c7 8b cb            mov     ecx, ebx\r
 572   000c9 e8 00 00 00 00   call    _gz_error\r
 573   000ce 83 c4 04         add     esp, 4\r
 574   000d1 5f               pop     edi\r
 575   000d2 83 c8 ff         or      eax, -1\r
 576   000d5 5e               pop     esi\r
 577 \r
 578 ; 212  : }\r
 579 \r
 580   000d6 8b e5            mov     esp, ebp\r
 581   000d8 5d               pop     ebp\r
 582   000d9 c3               ret     0\r
 583 $LN5@gz_decomp:\r
 584 \r
 585 ; 187  :             gz_error(state, Z_STREAM_ERROR,\r
 586 ; 188  :                      "internal error: inflate stream corrupt");\r
 587 \r
 588   000da 68 00 00 00 00   push    OFFSET ??_C@_0CH@CPOLIEKA@internal?5error?3?5inflate?5stream?5c@\r
 589   000df b8 fe ff ff ff   mov     eax, -2                        ; fffffffeH\r
 590   000e4 8b cb            mov     ecx, ebx\r
 591   000e6 e8 00 00 00 00   call    _gz_error\r
 592   000eb 83 c4 04         add     esp, 4\r
 593 $LN17@gz_decomp:\r
 594 \r
 595 ; 189  :             return -1;\r
 596 \r
 597   000ee 5f               pop     edi\r
 598   000ef 83 c8 ff         or      eax, -1\r
 599   000f2 5e               pop     esi\r
 600 \r
 601 ; 212  : }\r
 602 \r
 603   000f3 8b e5            mov     esp, ebp\r
 604   000f5 5d               pop     ebp\r
 605   000f6 c3               ret     0\r
 606 _gz_decomp ENDP\r
 607 ; Function compile flags: /Ogtp\r
 608 _TEXT   ENDS\r
 609 ;       COMDAT _gz_look\r
 610 _TEXT   SEGMENT\r
 611 tv68 = -4                                               ; size = 4\r
 612 _gz_look PROC                                           ; COMDAT\r
 613 ; _state$ = esi\r
 614 \r
 615 ; 82   : {\r
 616 \r
 617   00000 55               push    ebp\r
 618   00001 8b ec            mov     ebp, esp\r
 619   00003 51               push    ecx\r
 620   00004 53               push    ebx\r
 621 \r
 622 ; 83   :     z_streamp strm = &(state->strm);\r
 623 ; 84   : \r
 624 ; 85   :     /* allocate read buffers and inflate memory */\r
 625 ; 86   :     if (state->size == 0) {\r
 626 \r
 627   00005 33 db            xor     ebx, ebx\r
 628   00007 57               push    edi\r
 629   00008 8d 7e 64         lea     edi, DWORD PTR [esi+100]\r
 630   0000b 39 5e 1c         cmp     DWORD PTR [esi+28], ebx\r
 631   0000e 0f 85 ce 00 00\r
 632         00               jne     $LN7@gz_look\r
 633 \r
 634 ; 87   :         /* allocate buffers */\r
 635 ; 88   :         state->in = malloc(state->want);\r
 636 \r
 637   00014 8b 5e 20         mov     ebx, DWORD PTR [esi+32]\r
 638   00017 53               push    ebx\r
 639   00018 ff 15 00 00 00\r
 640         00               call    DWORD PTR __imp__malloc\r
 641   0001e 89 45 fc         mov     DWORD PTR tv68[ebp], eax\r
 642   00021 89 46 24         mov     DWORD PTR [esi+36], eax\r
 643 \r
 644 ; 89   :         state->out = malloc(state->want << 1);\r
 645 \r
 646   00024 8d 04 1b         lea     eax, DWORD PTR [ebx+ebx]\r
 647   00027 50               push    eax\r
 648   00028 ff 15 00 00 00\r
 649         00               call    DWORD PTR __imp__malloc\r
 650 \r
 651 ; 90   :         if (state->in == NULL || state->out == NULL) {\r
 652 \r
 653   0002e 33 c9            xor     ecx, ecx\r
 654   00030 83 c4 08         add     esp, 8\r
 655   00033 89 46 28         mov     DWORD PTR [esi+40], eax\r
 656   00036 39 4d fc         cmp     DWORD PTR tv68[ebp], ecx\r
 657   00039 74 67            je      SHORT $LN10@gz_look\r
 658   0003b 3b c1            cmp     eax, ecx\r
 659   0003d 74 73            je      SHORT $LN15@gz_look\r
 660 \r
 661 ; 97   :         }\r
 662 ; 98   :         state->size = state->want;\r
 663 ; 99   : \r
 664 ; 100  :         /* allocate inflate memory */\r
 665 ; 101  :         state->strm.zalloc = Z_NULL;\r
 666 ; 102  :         state->strm.zfree = Z_NULL;\r
 667 ; 103  :         state->strm.opaque = Z_NULL;\r
 668 ; 104  :         state->strm.avail_in = 0;\r
 669 ; 105  :         state->strm.next_in = Z_NULL;\r
 670 ; 106  :         if (inflateInit2(&(state->strm), 15 + 16) != Z_OK) {    /* gunzip */\r
 671 \r
 672   0003f 6a 38            push    56                     ; 00000038H\r
 673   00041 68 00 00 00 00   push    OFFSET ??_C@_05BOAHNBIE@1?42?46?$AA@\r
 674   00046 6a 1f            push    31                     ; 0000001fH\r
 675   00048 57               push    edi\r
 676   00049 89 5e 1c         mov     DWORD PTR [esi+28], ebx\r
 677   0004c 89 8e 84 00 00\r
 678         00               mov     DWORD PTR [esi+132], ecx\r
 679   00052 89 8e 88 00 00\r
 680         00               mov     DWORD PTR [esi+136], ecx\r
 681   00058 89 8e 8c 00 00\r
 682         00               mov     DWORD PTR [esi+140], ecx\r
 683   0005e 89 4e 68         mov     DWORD PTR [esi+104], ecx\r
 684   00061 89 0f            mov     DWORD PTR [edi], ecx\r
 685   00063 e8 00 00 00 00   call    _inflateInit2_@16\r
 686   00068 85 c0            test    eax, eax\r
 687   0006a 74 74            je      SHORT $LN16@gz_look\r
 688 \r
 689 ; 107  :             free(state->out);\r
 690 \r
 691   0006c 8b 4e 28         mov     ecx, DWORD PTR [esi+40]\r
 692   0006f 8b 3d 00 00 00\r
 693         00               mov     edi, DWORD PTR __imp__free\r
 694   00075 51               push    ecx\r
 695   00076 ff d7            call    edi\r
 696 \r
 697 ; 108  :             free(state->in);\r
 698 \r
 699   00078 8b 56 24         mov     edx, DWORD PTR [esi+36]\r
 700   0007b 52               push    edx\r
 701   0007c ff d7            call    edi\r
 702 \r
 703 ; 109  :             state->size = 0;\r
 704 ; 110  :             gz_error(state, Z_MEM_ERROR, "out of memory");\r
 705 \r
 706   0007e 68 00 00 00 00   push    OFFSET ??_C@_0O@BNNCBLEN@out?5of?5memory?$AA@\r
 707   00083 b8 fc ff ff ff   mov     eax, -4                        ; fffffffcH\r
 708   00088 8b ce            mov     ecx, esi\r
 709   0008a c7 46 1c 00 00\r
 710         00 00            mov     DWORD PTR [esi+28], 0\r
 711   00091 e8 00 00 00 00   call    _gz_error\r
 712   00096 83 c4 0c         add     esp, 12                        ; 0000000cH\r
 713   00099 5f               pop     edi\r
 714 \r
 715 ; 111  :             return -1;\r
 716 \r
 717   0009a 83 c8 ff         or      eax, -1\r
 718   0009d 5b               pop     ebx\r
 719 \r
 720 ; 159  : }\r
 721 \r
 722   0009e 8b e5            mov     esp, ebp\r
 723   000a0 5d               pop     ebp\r
 724   000a1 c3               ret     0\r
 725 $LN10@gz_look:\r
 726 \r
 727 ; 91   :             if (state->out != NULL)\r
 728 \r
 729   000a2 3b c1            cmp     eax, ecx\r
 730   000a4 74 0c            je      SHORT $LN15@gz_look\r
 731 \r
 732 ; 92   :                 free(state->out);\r
 733 \r
 734   000a6 50               push    eax\r
 735   000a7 ff 15 00 00 00\r
 736         00               call    DWORD PTR __imp__free\r
 737   000ad 83 c4 04         add     esp, 4\r
 738   000b0 33 c9            xor     ecx, ecx\r
 739 $LN15@gz_look:\r
 740 \r
 741 ; 93   :             if (state->in != NULL)\r
 742 \r
 743   000b2 8b 46 24         mov     eax, DWORD PTR [esi+36]\r
 744   000b5 3b c1            cmp     eax, ecx\r
 745   000b7 74 0a            je      SHORT $LN8@gz_look\r
 746 \r
 747 ; 94   :                 free(state->in);\r
 748 \r
 749   000b9 50               push    eax\r
 750   000ba ff 15 00 00 00\r
 751         00               call    DWORD PTR __imp__free\r
 752   000c0 83 c4 04         add     esp, 4\r
 753 $LN8@gz_look:\r
 754 \r
 755 ; 95   :             gz_error(state, Z_MEM_ERROR, "out of memory");\r
 756 \r
 757   000c3 68 00 00 00 00   push    OFFSET ??_C@_0O@BNNCBLEN@out?5of?5memory?$AA@\r
 758   000c8 b8 fc ff ff ff   mov     eax, -4                        ; fffffffcH\r
 759   000cd 8b ce            mov     ecx, esi\r
 760   000cf e8 00 00 00 00   call    _gz_error\r
 761   000d4 83 c4 04         add     esp, 4\r
 762 $LN18@gz_look:\r
 763 \r
 764 ; 96   :             return -1;\r
 765 \r
 766   000d7 5f               pop     edi\r
 767   000d8 83 c8 ff         or      eax, -1\r
 768   000db 5b               pop     ebx\r
 769 \r
 770 ; 159  : }\r
 771 \r
 772   000dc 8b e5            mov     esp, ebp\r
 773   000de 5d               pop     ebp\r
 774   000df c3               ret     0\r
 775 $LN16@gz_look:\r
 776 \r
 777 ; 94   :                 free(state->in);\r
 778 \r
 779   000e0 33 db            xor     ebx, ebx\r
 780 $LN7@gz_look:\r
 781 \r
 782 ; 112  :         }\r
 783 ; 113  :     }\r
 784 ; 114  : \r
 785 ; 115  :     /* get at least the magic bytes in the input buffer */\r
 786 ; 116  :     if (strm->avail_in < 2) {\r
 787 \r
 788   000e2 8b 47 04         mov     eax, DWORD PTR [edi+4]\r
 789   000e5 83 f8 02         cmp     eax, 2\r
 790   000e8 73 13            jae     SHORT $LN4@gz_look\r
 791 \r
 792 ; 117  :         if (gz_avail(state) == -1)\r
 793 \r
 794   000ea 8b c6            mov     eax, esi\r
 795   000ec e8 00 00 00 00   call    _gz_avail\r
 796   000f1 83 f8 ff         cmp     eax, -1\r
 797 \r
 798 ; 118  :             return -1;\r
 799 \r
 800   000f4 74 e1            je      SHORT $LN18@gz_look\r
 801 \r
 802 ; 119  :         if (strm->avail_in == 0)\r
 803 \r
 804   000f6 8b 47 04         mov     eax, DWORD PTR [edi+4]\r
 805   000f9 3b c3            cmp     eax, ebx\r
 806 \r
 807 ; 120  :             return 0;\r
 808 \r
 809   000fb 74 70            je      SHORT $LN17@gz_look\r
 810 $LN4@gz_look:\r
 811 \r
 812 ; 121  :     }\r
 813 ; 122  : \r
 814 ; 123  :     /* look for gzip magic bytes -- if there, do gzip decoding (note: there is\r
 815 ; 124  :        a logical dilemma here when considering the case of a partially written\r
 816 ; 125  :        gzip file, to wit, if a single 31 byte is written, then we cannot tell\r
 817 ; 126  :        whether this is a single-byte file, or just a partially written gzip\r
 818 ; 127  :        file -- for here we assume that if a gzip file is being written, then\r
 819 ; 128  :        the header will be written in a single operation, so that reading a\r
 820 ; 129  :        single byte is sufficient indication that it is not a gzip file) */\r
 821 ; 130  :     if (strm->avail_in > 1 &&\r
 822 ; 131  :             strm->next_in[0] == 31 && strm->next_in[1] == 139) {\r
 823 \r
 824   000fd ba 01 00 00 00   mov     edx, 1\r
 825   00102 3b c2            cmp     eax, edx\r
 826   00104 76 25            jbe     SHORT $LN3@gz_look\r
 827   00106 8b 07            mov     eax, DWORD PTR [edi]\r
 828   00108 80 38 1f         cmp     BYTE PTR [eax], 31     ; 0000001fH\r
 829   0010b 75 1e            jne     SHORT $LN3@gz_look\r
 830   0010d 80 78 01 8b      cmp     BYTE PTR [eax+1], 139  ; 0000008bH\r
 831   00111 75 18            jne     SHORT $LN3@gz_look\r
 832 \r
 833 ; 132  :         inflateReset(strm);\r
 834 \r
 835   00113 57               push    edi\r
 836   00114 e8 00 00 00 00   call    _inflateReset@4\r
 837   00119 5f               pop     edi\r
 838 \r
 839 ; 133  :         state->how = GZIP;\r
 840 ; 134  :         state->direct = 0;\r
 841 \r
 842   0011a 89 5e 2c         mov     DWORD PTR [esi+44], ebx\r
 843   0011d c7 46 30 02 00\r
 844         00 00            mov     DWORD PTR [esi+48], 2\r
 845 \r
 846 ; 158  :     return 0;\r
 847 \r
 848   00124 33 c0            xor     eax, eax\r
 849   00126 5b               pop     ebx\r
 850 \r
 851 ; 159  : }\r
 852 \r
 853   00127 8b e5            mov     esp, ebp\r
 854   00129 5d               pop     ebp\r
 855   0012a c3               ret     0\r
 856 $LN3@gz_look:\r
 857 \r
 858 ; 135  :         return 0;\r
 859 ; 136  :     }\r
 860 ; 137  : \r
 861 ; 138  :     /* no gzip header -- if we were decoding gzip before, then this is trailing\r
 862 ; 139  :        garbage.  Ignore the trailing garbage and finish. */\r
 863 ; 140  :     if (state->direct == 0) {\r
 864 \r
 865   0012b 39 5e 2c         cmp     DWORD PTR [esi+44], ebx\r
 866   0012e 75 10            jne     SHORT $LN2@gz_look\r
 867 \r
 868 ; 141  :         strm->avail_in = 0;\r
 869 \r
 870   00130 89 5f 04         mov     DWORD PTR [edi+4], ebx\r
 871   00133 5f               pop     edi\r
 872 \r
 873 ; 142  :         state->eof = 1;\r
 874 ; 143  :         state->x.have = 0;\r
 875 \r
 876   00134 89 1e            mov     DWORD PTR [esi], ebx\r
 877   00136 89 56 40         mov     DWORD PTR [esi+64], edx\r
 878 \r
 879 ; 158  :     return 0;\r
 880 \r
 881   00139 33 c0            xor     eax, eax\r
 882   0013b 5b               pop     ebx\r
 883 \r
 884 ; 159  : }\r
 885 \r
 886   0013c 8b e5            mov     esp, ebp\r
 887   0013e 5d               pop     ebp\r
 888   0013f c3               ret     0\r
 889 $LN2@gz_look:\r
 890 \r
 891 ; 144  :         return 0;\r
 892 ; 145  :     }\r
 893 ; 146  : \r
 894 ; 147  :     /* doing raw i/o, copy any leftover input to output -- this assumes that\r
 895 ; 148  :        the output buffer is larger than the input buffer, which also assures\r
 896 ; 149  :        space for gzungetc() */\r
 897 ; 150  :     state->x.next = state->out;\r
 898 \r
 899   00140 8b 46 28         mov     eax, DWORD PTR [esi+40]\r
 900   00143 89 46 04         mov     DWORD PTR [esi+4], eax\r
 901 \r
 902 ; 151  :     if (strm->avail_in) {\r
 903 \r
 904   00146 8b 4f 04         mov     ecx, DWORD PTR [edi+4]\r
 905   00149 3b cb            cmp     ecx, ebx\r
 906   0014b 74 1a            je      SHORT $LN1@gz_look\r
 907 \r
 908 ; 152  :         memcpy(state->x.next, strm->next_in, strm->avail_in);\r
 909 \r
 910   0014d 51               push    ecx\r
 911   0014e 8b 0f            mov     ecx, DWORD PTR [edi]\r
 912   00150 51               push    ecx\r
 913   00151 50               push    eax\r
 914   00152 e8 00 00 00 00   call    _memcpy\r
 915 \r
 916 ; 153  :         state->x.have = strm->avail_in;\r
 917 \r
 918   00157 8b 57 04         mov     edx, DWORD PTR [edi+4]\r
 919   0015a 89 16            mov     DWORD PTR [esi], edx\r
 920   0015c 83 c4 0c         add     esp, 12                        ; 0000000cH\r
 921 \r
 922 ; 154  :         strm->avail_in = 0;\r
 923 \r
 924   0015f 89 5f 04         mov     DWORD PTR [edi+4], ebx\r
 925   00162 ba 01 00 00 00   mov     edx, 1\r
 926 $LN1@gz_look:\r
 927 \r
 928 ; 155  :     }\r
 929 ; 156  :     state->how = COPY;\r
 930 \r
 931   00167 89 56 30         mov     DWORD PTR [esi+48], edx\r
 932 \r
 933 ; 157  :     state->direct = 1;\r
 934 \r
 935   0016a 89 56 2c         mov     DWORD PTR [esi+44], edx\r
 936 $LN17@gz_look:\r
 937 \r
 938 ; 158  :     return 0;\r
 939 \r
 940   0016d 5f               pop     edi\r
 941   0016e 33 c0            xor     eax, eax\r
 942   00170 5b               pop     ebx\r
 943 \r
 944 ; 159  : }\r
 945 \r
 946   00171 8b e5            mov     esp, ebp\r
 947   00173 5d               pop     ebp\r
 948   00174 c3               ret     0\r
 949 _gz_look ENDP\r
 950 PUBLIC  _gzdirect@4\r
 951 ; Function compile flags: /Ogtp\r
 952 ;       COMDAT _gzdirect@4\r
 953 _TEXT   SEGMENT\r
 954 _file$ = 8                                              ; size = 4\r
 955 _gzdirect@4 PROC                                        ; COMDAT\r
 956 \r
 957 ; 539  : {\r
 958 \r
 959   00000 55               push    ebp\r
 960   00001 8b ec            mov     ebp, esp\r
 961   00003 56               push    esi\r
 962 \r
 963 ; 540  :     gz_statep state;\r
 964 ; 541  : \r
 965 ; 542  :     /* get internal structure */\r
 966 ; 543  :     if (file == NULL)\r
 967 \r
 968   00004 8b 75 08         mov     esi, DWORD PTR _file$[ebp]\r
 969   00007 85 f6            test    esi, esi\r
 970   00009 75 07            jne     SHORT $LN2@gzdirect\r
 971 \r
 972 ; 544  :         return 0;\r
 973 \r
 974   0000b 33 c0            xor     eax, eax\r
 975   0000d 5e               pop     esi\r
 976 \r
 977 ; 554  : }\r
 978 \r
 979   0000e 5d               pop     ebp\r
 980   0000f c2 04 00         ret     4\r
 981 $LN2@gzdirect:\r
 982 \r
 983 ; 545  :     state = (gz_statep)file;\r
 984 ; 546  : \r
 985 ; 547  :     /* if the state is not known, but we can find out, then do so (this is\r
 986 ; 548  :        mainly for right after a gzopen() or gzdopen()) */\r
 987 ; 549  :     if (state->mode == GZ_READ && state->how == LOOK && state->x.have == 0)\r
 988 \r
 989   00012 81 7e 10 4f 1c\r
 990         00 00            cmp     DWORD PTR [esi+16], 7247 ; 00001c4fH\r
 991   00019 75 10            jne     SHORT $LN1@gzdirect\r
 992   0001b 83 7e 30 00      cmp     DWORD PTR [esi+48], 0\r
 993   0001f 75 0a            jne     SHORT $LN1@gzdirect\r
 994   00021 83 3e 00         cmp     DWORD PTR [esi], 0\r
 995   00024 75 05            jne     SHORT $LN1@gzdirect\r
 996 \r
 997 ; 550  :         (void)gz_look(state);\r
 998 \r
 999   00026 e8 00 00 00 00   call    _gz_look\r
1000 $LN1@gzdirect:\r
1001 \r
1002 ; 551  : \r
1003 ; 552  :     /* return 1 if transparent, 0 if processing a gzip stream */\r
1004 ; 553  :     return state->direct;\r
1005 \r
1006   0002b 8b 46 2c         mov     eax, DWORD PTR [esi+44]\r
1007   0002e 5e               pop     esi\r
1008 \r
1009 ; 554  : }\r
1010 \r
1011   0002f 5d               pop     ebp\r
1012   00030 c2 04 00         ret     4\r
1013 _gzdirect@4 ENDP\r
1014 ; Function compile flags: /Ogtp\r
1015 _TEXT   ENDS\r
1016 ;       COMDAT _gz_fetch\r
1017 _TEXT   SEGMENT\r
1018 _gz_fetch PROC                                          ; COMDAT\r
1019 ; _state$ = eax\r
1020 \r
1021 ; 222  : {\r
1022 \r
1023   00000 53               push    ebx\r
1024   00001 56               push    esi\r
1025   00002 8b f0            mov     esi, eax\r
1026 $LL13@gz_fetch:\r
1027 \r
1028 ; 223  :     z_streamp strm = &(state->strm);\r
1029 ; 224  : \r
1030 ; 225  :     do {\r
1031 ; 226  :         switch(state->how) {\r
1032 \r
1033   00004 8b 46 30         mov     eax, DWORD PTR [esi+48]\r
1034   00007 83 e8 00         sub     eax, 0\r
1035   0000a 74 26            je      SHORT $LN8@gz_fetch\r
1036   0000c 48               dec     eax\r
1037   0000d 74 49            je      SHORT $LN5@gz_fetch\r
1038   0000f 48               dec     eax\r
1039   00010 75 30            jne     SHORT $LN12@gz_fetch\r
1040 \r
1041 ; 238  :             return 0;\r
1042 ; 239  :         case GZIP:      /* -> GZIP or LOOK (if end of gzip stream) */\r
1043 ; 240  :             strm->avail_out = state->size << 1;\r
1044 \r
1045   00012 8b 46 1c         mov     eax, DWORD PTR [esi+28]\r
1046   00015 03 c0            add     eax, eax\r
1047   00017 89 46 74         mov     DWORD PTR [esi+116], eax\r
1048 \r
1049 ; 241  :             strm->next_out = state->out;\r
1050 \r
1051   0001a 8b 4e 28         mov     ecx, DWORD PTR [esi+40]\r
1052 \r
1053 ; 242  :             if (gz_decomp(state) == -1)\r
1054 \r
1055   0001d 8b de            mov     ebx, esi\r
1056   0001f 89 4e 70         mov     DWORD PTR [esi+112], ecx\r
1057   00022 e8 00 00 00 00   call    _gz_decomp\r
1058   00027 83 f8 ff         cmp     eax, -1\r
1059   0002a 75 16            jne     SHORT $LN12@gz_fetch\r
1060 $LN19@gz_fetch:\r
1061   0002c 5e               pop     esi\r
1062 \r
1063 ; 229  :                 return -1;\r
1064 \r
1065   0002d 83 c8 ff         or      eax, -1\r
1066   00030 5b               pop     ebx\r
1067 \r
1068 ; 247  : }\r
1069 \r
1070   00031 c3               ret     0\r
1071 $LN8@gz_fetch:\r
1072 \r
1073 ; 227  :         case LOOK:      /* -> LOOK, COPY (only if never GZIP), or GZIP */\r
1074 ; 228  :             if (gz_look(state) == -1)\r
1075 \r
1076   00032 e8 00 00 00 00   call    _gz_look\r
1077   00037 83 f8 ff         cmp     eax, -1\r
1078   0003a 74 f0            je      SHORT $LN19@gz_fetch\r
1079 \r
1080 ; 230  :             if (state->how == LOOK)\r
1081 \r
1082   0003c 83 7e 30 00      cmp     DWORD PTR [esi+48], 0\r
1083   00040 74 11            je      SHORT $LN1@gz_fetch\r
1084 $LN12@gz_fetch:\r
1085 \r
1086 ; 243  :                 return -1;\r
1087 ; 244  :         }\r
1088 ; 245  :     } while (state->x.have == 0 && (!state->eof || strm->avail_in));\r
1089 \r
1090   00042 83 3e 00         cmp     DWORD PTR [esi], 0\r
1091   00045 75 0c            jne     SHORT $LN1@gz_fetch\r
1092   00047 83 7e 40 00      cmp     DWORD PTR [esi+64], 0\r
1093   0004b 74 b7            je      SHORT $LL13@gz_fetch\r
1094   0004d 83 7e 68 00      cmp     DWORD PTR [esi+104], 0\r
1095   00051 75 b1            jne     SHORT $LL13@gz_fetch\r
1096 $LN1@gz_fetch:\r
1097   00053 5e               pop     esi\r
1098 \r
1099 ; 246  :     return 0;\r
1100 \r
1101   00054 33 c0            xor     eax, eax\r
1102   00056 5b               pop     ebx\r
1103 \r
1104 ; 247  : }\r
1105 \r
1106   00057 c3               ret     0\r
1107 $LN5@gz_fetch:\r
1108 \r
1109 ; 231  :                 return 0;\r
1110 ; 232  :             break;\r
1111 ; 233  :         case COPY:      /* -> COPY */\r
1112 ; 234  :             if (gz_load(state, state->out, state->size << 1, &(state->x.have))\r
1113 ; 235  :                     == -1)\r
1114 \r
1115   00058 8b 56 28         mov     edx, DWORD PTR [esi+40]\r
1116   0005b 57               push    edi\r
1117   0005c 8b 7e 1c         mov     edi, DWORD PTR [esi+28]\r
1118   0005f 03 ff            add     edi, edi\r
1119   00061 52               push    edx\r
1120   00062 8b de            mov     ebx, esi\r
1121   00064 e8 00 00 00 00   call    _gz_load\r
1122   00069 83 c4 04         add     esp, 4\r
1123   0006c 5f               pop     edi\r
1124   0006d 83 f8 ff         cmp     eax, -1\r
1125 \r
1126 ; 236  :                 return -1;\r
1127 \r
1128   00070 74 ba            je      SHORT $LN19@gz_fetch\r
1129 \r
1130 ; 237  :             state->x.next = state->out;\r
1131 \r
1132   00072 8b 46 28         mov     eax, DWORD PTR [esi+40]\r
1133   00075 89 46 04         mov     DWORD PTR [esi+4], eax\r
1134   00078 5e               pop     esi\r
1135 \r
1136 ; 246  :     return 0;\r
1137 \r
1138   00079 33 c0            xor     eax, eax\r
1139   0007b 5b               pop     ebx\r
1140 \r
1141 ; 247  : }\r
1142 \r
1143   0007c c3               ret     0\r
1144 _gz_fetch ENDP\r
1145 ; Function compile flags: /Ogtp\r
1146 ;       COMDAT _gz_skip\r
1147 _TEXT   SEGMENT\r
1148 _len$ = 8                                               ; size = 8\r
1149 _gz_skip PROC                                           ; COMDAT\r
1150 ; _state$ = esi\r
1151 \r
1152 ; 253  : {\r
1153 \r
1154   00000 55               push    ebp\r
1155   00001 8b ec            mov     ebp, esp\r
1156   00003 53               push    ebx\r
1157 \r
1158 ; 254  :     unsigned n;\r
1159 ; 255  : \r
1160 ; 256  :     /* skip over len bytes or reach end-of-file, whichever comes first */\r
1161 ; 257  :     while (len)\r
1162 \r
1163   00004 8b 5d 0c         mov     ebx, DWORD PTR _len$[ebp+4]\r
1164   00007 57               push    edi\r
1165   00008 8b 7d 08         mov     edi, DWORD PTR _len$[ebp]\r
1166   0000b 8b c7            mov     eax, edi\r
1167   0000d 0b c3            or      eax, ebx\r
1168   0000f 74 4b            je      SHORT $LN6@gz_skip\r
1169 $LL7@gz_skip:\r
1170 \r
1171 ; 258  :         /* skip over whatever is in output buffer */\r
1172 ; 259  :         if (state->x.have) {\r
1173 \r
1174   00011 8b 0e            mov     ecx, DWORD PTR [esi]\r
1175   00013 85 c9            test    ecx, ecx\r
1176   00015 74 27            je      SHORT $LN5@gz_skip\r
1177 \r
1178 ; 260  :             n = GT_OFF(state->x.have) || (z_off64_t)state->x.have > len ?\r
1179 ; 261  :                 (unsigned)len : state->x.have;\r
1180 \r
1181   00017 33 c0            xor     eax, eax\r
1182   00019 3b c3            cmp     eax, ebx\r
1183   0001b 7f 0a            jg      SHORT $LN10@gz_skip\r
1184   0001d 7c 04            jl      SHORT $LN15@gz_skip\r
1185   0001f 3b cf            cmp     ecx, edi\r
1186   00021 77 04            ja      SHORT $LN10@gz_skip\r
1187 $LN15@gz_skip:\r
1188   00023 8b c1            mov     eax, ecx\r
1189   00025 eb 02            jmp     SHORT $LN11@gz_skip\r
1190 $LN10@gz_skip:\r
1191   00027 8b c7            mov     eax, edi\r
1192 $LN11@gz_skip:\r
1193 \r
1194 ; 262  :             state->x.have -= n;\r
1195 ; 263  :             state->x.next += n;\r
1196 \r
1197   00029 01 46 04         add     DWORD PTR [esi+4], eax\r
1198   0002c 2b c8            sub     ecx, eax\r
1199   0002e 89 0e            mov     DWORD PTR [esi], ecx\r
1200 \r
1201 ; 264  :             state->x.pos += n;\r
1202 \r
1203   00030 33 c9            xor     ecx, ecx\r
1204   00032 01 46 08         add     DWORD PTR [esi+8], eax\r
1205   00035 11 4e 0c         adc     DWORD PTR [esi+12], ecx\r
1206 \r
1207 ; 265  :             len -= n;\r
1208 \r
1209   00038 2b f8            sub     edi, eax\r
1210   0003a 1b d9            sbb     ebx, ecx\r
1211   0003c eb 18            jmp     SHORT $LN1@gz_skip\r
1212 $LN5@gz_skip:\r
1213 \r
1214 ; 266  :         }\r
1215 ; 267  : \r
1216 ; 268  :         /* output buffer empty -- return if we're at the end of the input */\r
1217 ; 269  :         else if (state->eof && state->strm.avail_in == 0)\r
1218 \r
1219   0003e 83 7e 40 00      cmp     DWORD PTR [esi+64], 0\r
1220   00042 74 06            je      SHORT $LN3@gz_skip\r
1221   00044 83 7e 68 00      cmp     DWORD PTR [esi+104], 0\r
1222   00048 74 12            je      SHORT $LN6@gz_skip\r
1223 $LN3@gz_skip:\r
1224 \r
1225 ; 270  :             break;\r
1226 ; 271  : \r
1227 ; 272  :         /* need more data to skip -- load up output buffer */\r
1228 ; 273  :         else {\r
1229 ; 274  :             /* get more output, looking for header if required */\r
1230 ; 275  :             if (gz_fetch(state) == -1)\r
1231 \r
1232   0004a 8b c6            mov     eax, esi\r
1233   0004c e8 00 00 00 00   call    _gz_fetch\r
1234   00051 83 f8 ff         cmp     eax, -1\r
1235   00054 74 0c            je      SHORT $LN14@gz_skip\r
1236 $LN1@gz_skip:\r
1237 \r
1238 ; 254  :     unsigned n;\r
1239 ; 255  : \r
1240 ; 256  :     /* skip over len bytes or reach end-of-file, whichever comes first */\r
1241 ; 257  :     while (len)\r
1242 \r
1243   00056 8b cf            mov     ecx, edi\r
1244   00058 0b cb            or      ecx, ebx\r
1245   0005a 75 b5            jne     SHORT $LL7@gz_skip\r
1246 $LN6@gz_skip:\r
1247   0005c 5f               pop     edi\r
1248 \r
1249 ; 277  :         }\r
1250 ; 278  :     return 0;\r
1251 \r
1252   0005d 33 c0            xor     eax, eax\r
1253   0005f 5b               pop     ebx\r
1254 \r
1255 ; 279  : }\r
1256 \r
1257   00060 5d               pop     ebp\r
1258   00061 c3               ret     0\r
1259 $LN14@gz_skip:\r
1260   00062 5f               pop     edi\r
1261 \r
1262 ; 276  :                 return -1;\r
1263 \r
1264   00063 83 c8 ff         or      eax, -1\r
1265   00066 5b               pop     ebx\r
1266 \r
1267 ; 279  : }\r
1268 \r
1269   00067 5d               pop     ebp\r
1270   00068 c3               ret     0\r
1271 _gz_skip ENDP\r
1272 PUBLIC  _gzgets@12\r
1273 ; Function compile flags: /Ogtp\r
1274 ;       COMDAT _gzgets@12\r
1275 _TEXT   SEGMENT\r
1276 _left$ = 8                                              ; size = 4\r
1277 _file$ = 8                                              ; size = 4\r
1278 _buf$ = 12                                              ; size = 4\r
1279 _str$ = 16                                              ; size = 4\r
1280 _len$ = 16                                              ; size = 4\r
1281 _gzgets@12 PROC                                         ; COMDAT\r
1282 \r
1283 ; 477  : {\r
1284 \r
1285   00000 55               push    ebp\r
1286   00001 8b ec            mov     ebp, esp\r
1287   00003 53               push    ebx\r
1288   00004 56               push    esi\r
1289 \r
1290 ; 478  :     unsigned left, n;\r
1291 ; 479  :     char *str;\r
1292 ; 480  :     unsigned char *eol;\r
1293 ; 481  :     gz_statep state;\r
1294 ; 482  : \r
1295 ; 483  :     /* check parameters and get internal structure */\r
1296 ; 484  :     if (file == NULL || buf == NULL || len < 1)\r
1297 \r
1298   00005 8b 75 08         mov     esi, DWORD PTR _file$[ebp]\r
1299   00008 57               push    edi\r
1300   00009 85 f6            test    esi, esi\r
1301   0000b 0f 84 f0 00 00\r
1302         00               je      $LN14@gzgets\r
1303   00011 8b 7d 0c         mov     edi, DWORD PTR _buf$[ebp]\r
1304   00014 85 ff            test    edi, edi\r
1305   00016 0f 84 e5 00 00\r
1306         00               je      $LN14@gzgets\r
1307   0001c 8b 5d 10         mov     ebx, DWORD PTR _len$[ebp]\r
1308   0001f 83 fb 01         cmp     ebx, 1\r
1309   00022 0f 8c d9 00 00\r
1310         00               jl      $LN14@gzgets\r
1311 \r
1312 ; 486  :     state = (gz_statep)file;\r
1313 ; 487  : \r
1314 ; 488  :     /* check that we're reading and that there's no (serious) error */\r
1315 ; 489  :     if (state->mode != GZ_READ ||\r
1316 ; 490  :         (state->err != Z_OK && state->err != Z_BUF_ERROR))\r
1317 \r
1318   00028 81 7e 10 4f 1c\r
1319         00 00            cmp     DWORD PTR [esi+16], 7247 ; 00001c4fH\r
1320   0002f 0f 85 cc 00 00\r
1321         00               jne     $LN14@gzgets\r
1322   00035 8b 46 5c         mov     eax, DWORD PTR [esi+92]\r
1323   00038 85 c0            test    eax, eax\r
1324   0003a 74 09            je      SHORT $LN13@gzgets\r
1325   0003c 83 f8 fb         cmp     eax, -5                        ; fffffffbH\r
1326   0003f 0f 85 bc 00 00\r
1327         00               jne     $LN14@gzgets\r
1328 $LN13@gzgets:\r
1329 \r
1330 ; 491  :         return NULL;\r
1331 ; 492  : \r
1332 ; 493  :     /* process a skip request */\r
1333 ; 494  :     if (state->seek) {\r
1334 \r
1335   00045 83 7e 58 00      cmp     DWORD PTR [esi+88], 0\r
1336   00049 74 20            je      SHORT $LN25@gzgets\r
1337 \r
1338 ; 495  :         state->seek = 0;\r
1339 ; 496  :         if (gz_skip(state, state->skip) == -1)\r
1340 \r
1341   0004b 8b 46 54         mov     eax, DWORD PTR [esi+84]\r
1342   0004e 8b 4e 50         mov     ecx, DWORD PTR [esi+80]\r
1343   00051 50               push    eax\r
1344   00052 51               push    ecx\r
1345   00053 c7 46 58 00 00\r
1346         00 00            mov     DWORD PTR [esi+88], 0\r
1347   0005a e8 00 00 00 00   call    _gz_skip\r
1348   0005f 83 c4 08         add     esp, 8\r
1349   00062 83 f8 ff         cmp     eax, -1\r
1350 \r
1351 ; 497  :             return NULL;\r
1352 \r
1353   00065 0f 84 96 00 00\r
1354         00               je      $LN14@gzgets\r
1355 $LN25@gzgets:\r
1356 \r
1357 ; 498  :     }\r
1358 ; 499  : \r
1359 ; 500  :     /* copy output bytes up to new line or len - 1, whichever comes first --\r
1360 ; 501  :        append a terminating zero to the string (we don't check for a zero in\r
1361 ; 502  :        the contents, let the user worry about that) */\r
1362 ; 503  :     str = buf;\r
1363 ; 504  :     left = (unsigned)len - 1;\r
1364 \r
1365   0006b 4b               dec     ebx\r
1366   0006c 89 7d 10         mov     DWORD PTR _str$[ebp], edi\r
1367   0006f 89 5d 08         mov     DWORD PTR _left$[ebp], ebx\r
1368 \r
1369 ; 505  :     if (left) do {\r
1370 \r
1371   00072 0f 84 89 00 00\r
1372         00               je      $LN14@gzgets\r
1373 $LL8@gzgets:\r
1374 \r
1375 ; 506  :         /* assure that something is in the output buffer */\r
1376 ; 507  :         if (state->x.have == 0 && gz_fetch(state) == -1)\r
1377 \r
1378   00078 8b 3e            mov     edi, DWORD PTR [esi]\r
1379   0007a 85 ff            test    edi, edi\r
1380   0007c 75 12            jne     SHORT $LN24@gzgets\r
1381   0007e 8b c6            mov     eax, esi\r
1382   00080 e8 00 00 00 00   call    _gz_fetch\r
1383   00085 83 f8 ff         cmp     eax, -1\r
1384   00088 74 77            je      SHORT $LN14@gzgets\r
1385 \r
1386 ; 508  :             return NULL;                /* error */\r
1387 ; 509  :         if (state->x.have == 0) {       /* end of file */\r
1388 \r
1389   0008a 8b 3e            mov     edi, DWORD PTR [esi]\r
1390   0008c 85 ff            test    edi, edi\r
1391   0008e 74 56            je      SHORT $LN22@gzgets\r
1392 $LN24@gzgets:\r
1393 \r
1394 ; 511  :             break;                      /* return what we have */\r
1395 ; 512  :         }\r
1396 ; 513  : \r
1397 ; 514  :         /* look for end-of-line in current output buffer */\r
1398 ; 515  :         n = state->x.have > left ? left : state->x.have;\r
1399 \r
1400   00090 3b fb            cmp     edi, ebx\r
1401   00092 76 02            jbe     SHORT $LN18@gzgets\r
1402   00094 8b fb            mov     edi, ebx\r
1403 $LN18@gzgets:\r
1404 \r
1405 ; 516  :         eol = memchr(state->x.next, '\n', n);\r
1406 \r
1407   00096 8b 56 04         mov     edx, DWORD PTR [esi+4]\r
1408   00099 57               push    edi\r
1409   0009a 6a 0a            push    10                     ; 0000000aH\r
1410   0009c 52               push    edx\r
1411   0009d ff 15 00 00 00\r
1412         00               call    DWORD PTR __imp__memchr\r
1413   000a3 8b d8            mov     ebx, eax\r
1414   000a5 83 c4 0c         add     esp, 12                        ; 0000000cH\r
1415 \r
1416 ; 517  :         if (eol != NULL)\r
1417 \r
1418   000a8 85 db            test    ebx, ebx\r
1419   000aa 74 06            je      SHORT $LN3@gzgets\r
1420 \r
1421 ; 518  :             n = (unsigned)(eol - state->x.next) + 1;\r
1422 \r
1423   000ac 8b fb            mov     edi, ebx\r
1424   000ae 2b 7e 04         sub     edi, DWORD PTR [esi+4]\r
1425   000b1 47               inc     edi\r
1426 $LN3@gzgets:\r
1427 \r
1428 ; 519  : \r
1429 ; 520  :         /* copy through end-of-line, or remainder if not found */\r
1430 ; 521  :         memcpy(buf, state->x.next, n);\r
1431 \r
1432   000b2 8b 46 04         mov     eax, DWORD PTR [esi+4]\r
1433   000b5 8b 4d 0c         mov     ecx, DWORD PTR _buf$[ebp]\r
1434   000b8 57               push    edi\r
1435   000b9 50               push    eax\r
1436   000ba 51               push    ecx\r
1437   000bb e8 00 00 00 00   call    _memcpy\r
1438 \r
1439 ; 522  :         state->x.have -= n;\r
1440 \r
1441   000c0 29 3e            sub     DWORD PTR [esi], edi\r
1442 \r
1443 ; 523  :         state->x.next += n;\r
1444 \r
1445   000c2 01 7e 04         add     DWORD PTR [esi+4], edi\r
1446 \r
1447 ; 524  :         state->x.pos += n;\r
1448 ; 525  :         left -= n;\r
1449 \r
1450   000c5 8b 45 08         mov     eax, DWORD PTR _left$[ebp]\r
1451   000c8 83 c4 0c         add     esp, 12                        ; 0000000cH\r
1452   000cb 01 7e 08         add     DWORD PTR [esi+8], edi\r
1453   000ce 83 56 0c 00      adc     DWORD PTR [esi+12], 0\r
1454 \r
1455 ; 526  :         buf += n;\r
1456 \r
1457   000d2 01 7d 0c         add     DWORD PTR _buf$[ebp], edi\r
1458   000d5 2b c7            sub     eax, edi\r
1459   000d7 89 45 08         mov     DWORD PTR _left$[ebp], eax\r
1460 \r
1461 ; 527  :     } while (left && eol == NULL);\r
1462 \r
1463   000da 85 c0            test    eax, eax\r
1464   000dc 74 0f            je      SHORT $LN2@gzgets\r
1465   000de 85 db            test    ebx, ebx\r
1466   000e0 75 0b            jne     SHORT $LN2@gzgets\r
1467   000e2 8b d8            mov     ebx, eax\r
1468   000e4 eb 92            jmp     SHORT $LL8@gzgets\r
1469 $LN22@gzgets:\r
1470 \r
1471 ; 510  :             state->past = 1;            /* read past end */\r
1472 \r
1473   000e6 c7 46 44 01 00\r
1474         00 00            mov     DWORD PTR [esi+68], 1\r
1475 $LN2@gzgets:\r
1476 \r
1477 ; 528  : \r
1478 ; 529  :     /* return terminated string, or if nothing, end of file */\r
1479 ; 530  :     if (buf == str)\r
1480 \r
1481   000ed 8b 4d 0c         mov     ecx, DWORD PTR _buf$[ebp]\r
1482   000f0 8b 45 10         mov     eax, DWORD PTR _str$[ebp]\r
1483   000f3 3b c8            cmp     ecx, eax\r
1484 \r
1485 ; 531  :         return NULL;\r
1486 \r
1487   000f5 74 0a            je      SHORT $LN14@gzgets\r
1488 \r
1489 ; 532  :     buf[0] = 0;\r
1490 \r
1491   000f7 5f               pop     edi\r
1492   000f8 5e               pop     esi\r
1493   000f9 c6 01 00         mov     BYTE PTR [ecx], 0\r
1494   000fc 5b               pop     ebx\r
1495 \r
1496 ; 533  :     return str;\r
1497 ; 534  : }\r
1498 \r
1499   000fd 5d               pop     ebp\r
1500   000fe c2 0c 00         ret     12                     ; 0000000cH\r
1501 $LN14@gzgets:\r
1502   00101 5f               pop     edi\r
1503   00102 5e               pop     esi\r
1504 \r
1505 ; 485  :         return NULL;\r
1506 \r
1507   00103 33 c0            xor     eax, eax\r
1508   00105 5b               pop     ebx\r
1509 \r
1510 ; 533  :     return str;\r
1511 ; 534  : }\r
1512 \r
1513   00106 5d               pop     ebp\r
1514   00107 c2 0c 00         ret     12                     ; 0000000cH\r
1515 _gzgets@12 ENDP\r
1516 _TEXT   ENDS\r
1517 PUBLIC  _gzungetc@8\r
1518 ; Function compile flags: /Ogtp\r
1519 ;       COMDAT _gzungetc@8\r
1520 _TEXT   SEGMENT\r
1521 _c$ = 8                                                 ; size = 4\r
1522 _file$ = 12                                             ; size = 4\r
1523 _gzungetc@8 PROC                                        ; COMDAT\r
1524 \r
1525 ; 416  : {\r
1526 \r
1527   00000 55               push    ebp\r
1528   00001 8b ec            mov     ebp, esp\r
1529   00003 56               push    esi\r
1530 \r
1531 ; 417  :     gz_statep state;\r
1532 ; 418  : \r
1533 ; 419  :     /* get internal structure */\r
1534 ; 420  :     if (file == NULL)\r
1535 \r
1536   00004 8b 75 0c         mov     esi, DWORD PTR _file$[ebp]\r
1537   00007 57               push    edi\r
1538   00008 33 ff            xor     edi, edi\r
1539   0000a 3b f7            cmp     esi, edi\r
1540   0000c 75 09            jne     SHORT $LN11@gzungetc\r
1541 $LN9@gzungetc:\r
1542   0000e 5f               pop     edi\r
1543 \r
1544 ; 421  :         return -1;\r
1545 \r
1546   0000f 83 c8 ff         or      eax, -1\r
1547   00012 5e               pop     esi\r
1548 \r
1549 ; 469  :     return c;\r
1550 ; 470  : }\r
1551 \r
1552   00013 5d               pop     ebp\r
1553   00014 c2 08 00         ret     8\r
1554 $LN11@gzungetc:\r
1555 \r
1556 ; 422  :     state = (gz_statep)file;\r
1557 ; 423  : \r
1558 ; 424  :     /* check that we're reading and that there's no (serious) error */\r
1559 ; 425  :     if (state->mode != GZ_READ ||\r
1560 ; 426  :         (state->err != Z_OK && state->err != Z_BUF_ERROR))\r
1561 \r
1562   00017 81 7e 10 4f 1c\r
1563         00 00            cmp     DWORD PTR [esi+16], 7247 ; 00001c4fH\r
1564   0001e 75 ee            jne     SHORT $LN9@gzungetc\r
1565   00020 8b 46 5c         mov     eax, DWORD PTR [esi+92]\r
1566   00023 3b c7            cmp     eax, edi\r
1567   00025 74 05            je      SHORT $LN10@gzungetc\r
1568   00027 83 f8 fb         cmp     eax, -5                        ; fffffffbH\r
1569   0002a 75 e2            jne     SHORT $LN9@gzungetc\r
1570 $LN10@gzungetc:\r
1571   0002c 53               push    ebx\r
1572 \r
1573 ; 427  :         return -1;\r
1574 ; 428  : \r
1575 ; 429  :     /* process a skip request */\r
1576 ; 430  :     if (state->seek) {\r
1577 \r
1578   0002d 83 cb ff         or      ebx, -1\r
1579   00030 39 7e 58         cmp     DWORD PTR [esi+88], edi\r
1580   00033 74 17            je      SHORT $LN7@gzungetc\r
1581 \r
1582 ; 431  :         state->seek = 0;\r
1583 ; 432  :         if (gz_skip(state, state->skip) == -1)\r
1584 \r
1585   00035 8b 46 54         mov     eax, DWORD PTR [esi+84]\r
1586   00038 8b 4e 50         mov     ecx, DWORD PTR [esi+80]\r
1587   0003b 50               push    eax\r
1588   0003c 51               push    ecx\r
1589   0003d 89 7e 58         mov     DWORD PTR [esi+88], edi\r
1590   00040 e8 00 00 00 00   call    _gz_skip\r
1591   00045 83 c4 08         add     esp, 8\r
1592   00048 3b c3            cmp     eax, ebx\r
1593 \r
1594 ; 433  :             return -1;\r
1595 \r
1596   0004a 74 4d            je      SHORT $LN18@gzungetc\r
1597 $LN7@gzungetc:\r
1598 \r
1599 ; 434  :     }\r
1600 ; 435  : \r
1601 ; 436  :     /* can't push EOF */\r
1602 ; 437  :     if (c < 0)\r
1603 \r
1604   0004c 8b 45 08         mov     eax, DWORD PTR _c$[ebp]\r
1605   0004f 3b c7            cmp     eax, edi\r
1606 \r
1607 ; 438  :         return -1;\r
1608 \r
1609   00051 7c 46            jl      SHORT $LN18@gzungetc\r
1610 \r
1611 ; 439  : \r
1612 ; 440  :     /* if output buffer empty, put byte at end (allows more pushing) */\r
1613 ; 441  :     if (state->x.have == 0) {\r
1614 \r
1615   00053 8b 0e            mov     ecx, DWORD PTR [esi]\r
1616 \r
1617 ; 442  :         state->x.have = 1;\r
1618 ; 443  :         state->x.next = state->out + (state->size << 1) - 1;\r
1619 \r
1620   00055 8b 56 1c         mov     edx, DWORD PTR [esi+28]\r
1621   00058 3b cf            cmp     ecx, edi\r
1622   0005a 75 22            jne     SHORT $LN5@gzungetc\r
1623   0005c 8b 4e 28         mov     ecx, DWORD PTR [esi+40]\r
1624   0005f 8d 4c 51 ff      lea     ecx, DWORD PTR [ecx+edx*2-1]\r
1625   00063 c7 06 01 00 00\r
1626         00               mov     DWORD PTR [esi], 1\r
1627   00069 89 4e 04         mov     DWORD PTR [esi+4], ecx\r
1628 \r
1629 ; 444  :         state->x.next[0] = c;\r
1630 \r
1631   0006c 88 01            mov     BYTE PTR [ecx], al\r
1632 \r
1633 ; 467  :     state->x.pos--;\r
1634 \r
1635   0006e 01 5e 08         add     DWORD PTR [esi+8], ebx\r
1636   00071 89 7e 44         mov     DWORD PTR [esi+68], edi\r
1637   00074 11 5e 0c         adc     DWORD PTR [esi+12], ebx\r
1638   00077 5b               pop     ebx\r
1639   00078 5f               pop     edi\r
1640   00079 5e               pop     esi\r
1641 \r
1642 ; 469  :     return c;\r
1643 ; 470  : }\r
1644 \r
1645   0007a 5d               pop     ebp\r
1646   0007b c2 08 00         ret     8\r
1647 $LN5@gzungetc:\r
1648 \r
1649 ; 445  :         state->x.pos--;\r
1650 ; 446  :         state->past = 0;\r
1651 ; 447  :         return c;\r
1652 ; 448  :     }\r
1653 ; 449  : \r
1654 ; 450  :     /* if no room, give up (must have already done a gzungetc()) */\r
1655 ; 451  :     if (state->x.have == (state->size << 1)) {\r
1656 \r
1657   0007e 8d 3c 12         lea     edi, DWORD PTR [edx+edx]\r
1658   00081 3b cf            cmp     ecx, edi\r
1659   00083 75 1d            jne     SHORT $LN4@gzungetc\r
1660 \r
1661 ; 452  :         gz_error(state, Z_DATA_ERROR, "out of room to push characters");\r
1662 \r
1663   00085 68 00 00 00 00   push    OFFSET ??_C@_0BP@IIKIGMCC@out?5of?5room?5to?5push?5characters?$AA@\r
1664   0008a b8 fd ff ff ff   mov     eax, -3                        ; fffffffdH\r
1665   0008f 8b ce            mov     ecx, esi\r
1666   00091 e8 00 00 00 00   call    _gz_error\r
1667   00096 83 c4 04         add     esp, 4\r
1668 $LN18@gzungetc:\r
1669 \r
1670 ; 453  :         return -1;\r
1671 \r
1672   00099 8b c3            mov     eax, ebx\r
1673   0009b 5b               pop     ebx\r
1674   0009c 5f               pop     edi\r
1675   0009d 5e               pop     esi\r
1676 \r
1677 ; 469  :     return c;\r
1678 ; 470  : }\r
1679 \r
1680   0009e 5d               pop     ebp\r
1681   0009f c2 08 00         ret     8\r
1682 $LN4@gzungetc:\r
1683 \r
1684 ; 454  :     }\r
1685 ; 455  : \r
1686 ; 456  :     /* slide output data if needed and insert byte before existing data */\r
1687 ; 457  :     if (state->x.next == state->out) {\r
1688 \r
1689   000a2 8b 7e 28         mov     edi, DWORD PTR [esi+40]\r
1690   000a5 39 7e 04         cmp     DWORD PTR [esi+4], edi\r
1691   000a8 75 1b            jne     SHORT $LN3@gzungetc\r
1692 \r
1693 ; 458  :         unsigned char *src = state->out + state->x.have;\r
1694 \r
1695   000aa 03 cf            add     ecx, edi\r
1696 \r
1697 ; 459  :         unsigned char *dest = state->out + (state->size << 1);\r
1698 \r
1699   000ac 8d 14 57         lea     edx, DWORD PTR [edi+edx*2]\r
1700 \r
1701 ; 460  :         while (src > state->out)\r
1702 \r
1703   000af 3b cf            cmp     ecx, edi\r
1704   000b1 76 0f            jbe     SHORT $LN1@gzungetc\r
1705 $LL2@gzungetc:\r
1706 \r
1707 ; 461  :             *--dest = *--src;\r
1708 \r
1709   000b3 8a 59 ff         mov     bl, BYTE PTR [ecx-1]\r
1710   000b6 49               dec     ecx\r
1711   000b7 4a               dec     edx\r
1712   000b8 88 1a            mov     BYTE PTR [edx], bl\r
1713   000ba 3b 4e 28         cmp     ecx, DWORD PTR [esi+40]\r
1714   000bd 77 f4            ja      SHORT $LL2@gzungetc\r
1715 \r
1716 ; 460  :         while (src > state->out)\r
1717 \r
1718   000bf 83 cb ff         or      ebx, -1\r
1719 $LN1@gzungetc:\r
1720 \r
1721 ; 462  :         state->x.next = dest;\r
1722 \r
1723   000c2 89 56 04         mov     DWORD PTR [esi+4], edx\r
1724 $LN3@gzungetc:\r
1725 \r
1726 ; 463  :     }\r
1727 ; 464  :     state->x.have++;\r
1728 ; 465  :     state->x.next--;\r
1729 \r
1730   000c5 01 5e 04         add     DWORD PTR [esi+4], ebx\r
1731   000c8 ff 06            inc     DWORD PTR [esi]\r
1732   000ca 8b 4e 04         mov     ecx, DWORD PTR [esi+4]\r
1733 \r
1734 ; 466  :     state->x.next[0] = c;\r
1735 \r
1736   000cd 88 01            mov     BYTE PTR [ecx], al\r
1737 \r
1738 ; 467  :     state->x.pos--;\r
1739 \r
1740   000cf 01 5e 08         add     DWORD PTR [esi+8], ebx\r
1741 \r
1742 ; 468  :     state->past = 0;\r
1743 \r
1744   000d2 c7 46 44 00 00\r
1745         00 00            mov     DWORD PTR [esi+68], 0\r
1746   000d9 11 5e 0c         adc     DWORD PTR [esi+12], ebx\r
1747   000dc 5b               pop     ebx\r
1748   000dd 5f               pop     edi\r
1749   000de 5e               pop     esi\r
1750 \r
1751 ; 469  :     return c;\r
1752 ; 470  : }\r
1753 \r
1754   000df 5d               pop     ebp\r
1755   000e0 c2 08 00         ret     8\r
1756 _gzungetc@8 ENDP\r
1757 _TEXT   ENDS\r
1758 PUBLIC  _gzread@12\r
1759 ; Function compile flags: /Ogtp\r
1760 ;       COMDAT _gzread@12\r
1761 _TEXT   SEGMENT\r
1762 _n$ = 8                                                 ; size = 4\r
1763 _file$ = 8                                              ; size = 4\r
1764 _buf$ = 12                                              ; size = 4\r
1765 _got$ = 16                                              ; size = 4\r
1766 _len$ = 16                                              ; size = 4\r
1767 _gzread@12 PROC                                         ; COMDAT\r
1768 \r
1769 ; 286  : {\r
1770 \r
1771   00000 55               push    ebp\r
1772   00001 8b ec            mov     ebp, esp\r
1773   00003 53               push    ebx\r
1774 \r
1775 ; 287  :     unsigned got, n;\r
1776 ; 288  :     gz_statep state;\r
1777 ; 289  :     z_streamp strm;\r
1778 ; 290  : \r
1779 ; 291  :     /* get internal structure */\r
1780 ; 292  :     if (file == NULL)\r
1781 \r
1782   00004 8b 5d 08         mov     ebx, DWORD PTR _file$[ebp]\r
1783   00007 85 db            test    ebx, ebx\r
1784   00009 75 08            jne     SHORT $LN22@gzread\r
1785 $LN20@gzread:\r
1786 \r
1787 ; 293  :         return -1;\r
1788 \r
1789   0000b 83 c8 ff         or      eax, -1\r
1790   0000e 5b               pop     ebx\r
1791 \r
1792 ; 373  : }\r
1793 \r
1794   0000f 5d               pop     ebp\r
1795   00010 c2 0c 00         ret     12                     ; 0000000cH\r
1796 $LN22@gzread:\r
1797 \r
1798 ; 294  :     state = (gz_statep)file;\r
1799 ; 295  :     strm = &(state->strm);\r
1800 ; 296  : \r
1801 ; 297  :     /* check that we're reading and that there's no (serious) error */\r
1802 ; 298  :     if (state->mode != GZ_READ ||\r
1803 ; 299  :             (state->err != Z_OK && state->err != Z_BUF_ERROR))\r
1804 \r
1805   00013 81 7b 10 4f 1c\r
1806         00 00            cmp     DWORD PTR [ebx+16], 7247 ; 00001c4fH\r
1807   0001a 75 ef            jne     SHORT $LN20@gzread\r
1808   0001c 8b 43 5c         mov     eax, DWORD PTR [ebx+92]\r
1809   0001f 85 c0            test    eax, eax\r
1810   00021 74 05            je      SHORT $LN21@gzread\r
1811   00023 83 f8 fb         cmp     eax, -5                        ; fffffffbH\r
1812   00026 75 e3            jne     SHORT $LN20@gzread\r
1813 $LN21@gzread:\r
1814   00028 57               push    edi\r
1815 \r
1816 ; 300  :         return -1;\r
1817 ; 301  : \r
1818 ; 302  :     /* since an int is returned, make sure len fits in one, otherwise return\r
1819 ; 303  :        with an error (this avoids the flaw in the interface) */\r
1820 ; 304  :     if ((int)len < 0) {\r
1821 \r
1822   00029 8b 7d 10         mov     edi, DWORD PTR _len$[ebp]\r
1823   0002c 85 ff            test    edi, edi\r
1824   0002e 79 1d            jns     SHORT $LN37@gzread\r
1825 \r
1826 ; 305  :         gz_error(state, Z_DATA_ERROR, "requested length does not fit in int");\r
1827 \r
1828   00030 68 00 00 00 00   push    OFFSET ??_C@_0CF@MLPJFDMM@requested?5length?5does?5not?5fit?5in@\r
1829   00035 b8 fd ff ff ff   mov     eax, -3                        ; fffffffdH\r
1830   0003a 8b cb            mov     ecx, ebx\r
1831   0003c e8 00 00 00 00   call    _gz_error\r
1832   00041 83 c4 04         add     esp, 4\r
1833   00044 5f               pop     edi\r
1834 \r
1835 ; 306  :         return -1;\r
1836 \r
1837   00045 83 c8 ff         or      eax, -1\r
1838   00048 5b               pop     ebx\r
1839 \r
1840 ; 373  : }\r
1841 \r
1842   00049 5d               pop     ebp\r
1843   0004a c2 0c 00         ret     12                     ; 0000000cH\r
1844 $LN37@gzread:\r
1845 \r
1846 ; 307  :     }\r
1847 ; 308  : \r
1848 ; 309  :     /* if len is zero, avoid unnecessary operations */\r
1849 ; 310  :     if (len == 0)\r
1850 \r
1851   0004d 75 08            jne     SHORT $LN18@gzread\r
1852 \r
1853 ; 311  :         return 0;\r
1854 \r
1855   0004f 5f               pop     edi\r
1856   00050 33 c0            xor     eax, eax\r
1857   00052 5b               pop     ebx\r
1858 \r
1859 ; 373  : }\r
1860 \r
1861   00053 5d               pop     ebp\r
1862   00054 c2 0c 00         ret     12                     ; 0000000cH\r
1863 $LN18@gzread:\r
1864 \r
1865 ; 312  : \r
1866 ; 313  :     /* process a skip request */\r
1867 ; 314  :     if (state->seek) {\r
1868 \r
1869   00057 83 7b 58 00      cmp     DWORD PTR [ebx+88], 0\r
1870   0005b 56               push    esi\r
1871   0005c 74 22            je      SHORT $LN32@gzread\r
1872 \r
1873 ; 315  :         state->seek = 0;\r
1874 ; 316  :         if (gz_skip(state, state->skip) == -1)\r
1875 \r
1876   0005e 8b 43 54         mov     eax, DWORD PTR [ebx+84]\r
1877   00061 8b 4b 50         mov     ecx, DWORD PTR [ebx+80]\r
1878   00064 50               push    eax\r
1879   00065 51               push    ecx\r
1880   00066 8b f3            mov     esi, ebx\r
1881   00068 c7 43 58 00 00\r
1882         00 00            mov     DWORD PTR [ebx+88], 0\r
1883   0006f e8 00 00 00 00   call    _gz_skip\r
1884   00074 83 c4 08         add     esp, 8\r
1885   00077 83 f8 ff         cmp     eax, -1\r
1886 \r
1887 ; 317  :             return -1;\r
1888 \r
1889   0007a 0f 84 eb 00 00\r
1890         00               je      $LN31@gzread\r
1891 $LN32@gzread:\r
1892 \r
1893 ; 318  :     }\r
1894 ; 319  : \r
1895 ; 320  :     /* get len bytes to buf, or less than len if at the end */\r
1896 ; 321  :     got = 0;\r
1897 \r
1898   00080 c7 45 10 00 00\r
1899         00 00            mov     DWORD PTR _got$[ebp], 0\r
1900 $LL15@gzread:\r
1901 \r
1902 ; 322  :     do {\r
1903 ; 323  :         /* first just try copying data from the output buffer */\r
1904 ; 324  :         if (state->x.have) {\r
1905 \r
1906   00087 8b 33            mov     esi, DWORD PTR [ebx]\r
1907   00089 85 f6            test    esi, esi\r
1908   0008b 74 33            je      SHORT $LN12@gzread\r
1909 \r
1910 ; 325  :             n = state->x.have > len ? len : state->x.have;\r
1911 \r
1912   0008d 3b f7            cmp     esi, edi\r
1913   0008f 76 02            jbe     SHORT $LN25@gzread\r
1914   00091 8b f7            mov     esi, edi\r
1915 $LN25@gzread:\r
1916 \r
1917 ; 326  :             memcpy(buf, state->x.next, n);\r
1918 \r
1919   00093 8b 53 04         mov     edx, DWORD PTR [ebx+4]\r
1920   00096 8b 45 0c         mov     eax, DWORD PTR _buf$[ebp]\r
1921   00099 56               push    esi\r
1922   0009a 52               push    edx\r
1923   0009b 50               push    eax\r
1924   0009c 89 75 08         mov     DWORD PTR _n$[ebp], esi\r
1925   0009f e8 00 00 00 00   call    _memcpy\r
1926 \r
1927 ; 327  :             state->x.next += n;\r
1928 \r
1929   000a4 01 73 04         add     DWORD PTR [ebx+4], esi\r
1930 \r
1931 ; 328  :             state->x.have -= n;\r
1932 \r
1933   000a7 29 33            sub     DWORD PTR [ebx], esi\r
1934 \r
1935 ; 361  :             state->x.have = 0;\r
1936 ; 362  :         }\r
1937 ; 363  : \r
1938 ; 364  :         /* update progress */\r
1939 ; 365  :         len -= n;\r
1940 ; 366  :         buf = (char *)buf + n;\r
1941 \r
1942   000a9 01 75 0c         add     DWORD PTR _buf$[ebp], esi\r
1943 \r
1944 ; 367  :         got += n;\r
1945 \r
1946   000ac 01 75 10         add     DWORD PTR _got$[ebp], esi\r
1947   000af 83 c4 0c         add     esp, 12                        ; 0000000cH\r
1948   000b2 2b fe            sub     edi, esi\r
1949 \r
1950 ; 368  :         state->x.pos += n;\r
1951 \r
1952   000b4 01 73 08         add     DWORD PTR [ebx+8], esi\r
1953   000b7 83 53 0c 00      adc     DWORD PTR [ebx+12], 0\r
1954   000bb e9 88 00 00 00   jmp     $LN14@gzread\r
1955 $LN12@gzread:\r
1956 \r
1957 ; 329  :         }\r
1958 ; 330  : \r
1959 ; 331  :         /* output buffer empty -- return if we're at the end of the input */\r
1960 ; 332  :         else if (state->eof && strm->avail_in == 0) {\r
1961 \r
1962   000c0 83 7b 40 00      cmp     DWORD PTR [ebx+64], 0\r
1963   000c4 74 0a            je      SHORT $LN10@gzread\r
1964   000c6 83 7b 68 00      cmp     DWORD PTR [ebx+104], 0\r
1965   000ca 0f 84 8a 00 00\r
1966         00               je      $LN28@gzread\r
1967 $LN10@gzread:\r
1968 \r
1969 ; 333  :             state->past = 1;        /* tried to read past end */\r
1970 ; 334  :             break;\r
1971 ; 335  :         }\r
1972 ; 336  : \r
1973 ; 337  :         /* need output data -- for small len or new stream load up our output\r
1974 ; 338  :            buffer */\r
1975 ; 339  :         else if (state->how == LOOK || len < (state->size << 1)) {\r
1976 \r
1977   000d0 8b 43 30         mov     eax, DWORD PTR [ebx+48]\r
1978   000d3 85 c0            test    eax, eax\r
1979   000d5 74 65            je      SHORT $LN7@gzread\r
1980   000d7 8b 4b 1c         mov     ecx, DWORD PTR [ebx+28]\r
1981   000da 03 c9            add     ecx, ecx\r
1982   000dc 3b f9            cmp     edi, ecx\r
1983   000de 72 5c            jb      SHORT $LN7@gzread\r
1984 \r
1985 ; 343  :             continue;       /* no progress yet -- go back to memcpy() above */\r
1986 ; 344  :             /* the copy above assures that we will leave with space in the\r
1987 ; 345  :                output buffer, allowing at least one gzungetc() to succeed */\r
1988 ; 346  :         }\r
1989 ; 347  : \r
1990 ; 348  :         /* large len -- read directly into user buffer */\r
1991 ; 349  :         else if (state->how == COPY) {      /* read directly */\r
1992 \r
1993   000e0 83 f8 01         cmp     eax, 1\r
1994   000e3 75 28            jne     SHORT $LN4@gzread\r
1995 \r
1996 ; 350  :             if (gz_load(state, buf, len, &n) == -1)\r
1997 \r
1998   000e5 8b 55 0c         mov     edx, DWORD PTR _buf$[ebp]\r
1999   000e8 52               push    edx\r
2000   000e9 8d 75 08         lea     esi, DWORD PTR _n$[ebp]\r
2001   000ec e8 00 00 00 00   call    _gz_load\r
2002   000f1 83 c4 04         add     esp, 4\r
2003   000f4 83 f8 ff         cmp     eax, -1\r
2004   000f7 74 72            je      SHORT $LN31@gzread\r
2005 \r
2006 ; 351  :                 return -1;\r
2007 ; 352  :         }\r
2008 ; 353  : \r
2009 ; 354  :         /* large len -- decompress directly into user buffer */\r
2010 ; 355  :         else {  /* state->how == GZIP */\r
2011 \r
2012   000f9 8b 75 08         mov     esi, DWORD PTR _n$[ebp]\r
2013 \r
2014 ; 361  :             state->x.have = 0;\r
2015 ; 362  :         }\r
2016 ; 363  : \r
2017 ; 364  :         /* update progress */\r
2018 ; 365  :         len -= n;\r
2019 ; 366  :         buf = (char *)buf + n;\r
2020 \r
2021   000fc 01 75 0c         add     DWORD PTR _buf$[ebp], esi\r
2022 \r
2023 ; 367  :         got += n;\r
2024 \r
2025   000ff 01 75 10         add     DWORD PTR _got$[ebp], esi\r
2026   00102 2b fe            sub     edi, esi\r
2027 \r
2028 ; 368  :         state->x.pos += n;\r
2029 \r
2030   00104 01 73 08         add     DWORD PTR [ebx+8], esi\r
2031   00107 83 53 0c 00      adc     DWORD PTR [ebx+12], 0\r
2032   0010b eb 3b            jmp     SHORT $LN14@gzread\r
2033 $LN4@gzread:\r
2034 \r
2035 ; 356  :             strm->avail_out = len;\r
2036 ; 357  :             strm->next_out = buf;\r
2037 \r
2038   0010d 8b 45 0c         mov     eax, DWORD PTR _buf$[ebp]\r
2039   00110 89 7b 74         mov     DWORD PTR [ebx+116], edi\r
2040   00113 89 43 70         mov     DWORD PTR [ebx+112], eax\r
2041 \r
2042 ; 358  :             if (gz_decomp(state) == -1)\r
2043 \r
2044   00116 e8 00 00 00 00   call    _gz_decomp\r
2045   0011b 83 f8 ff         cmp     eax, -1\r
2046   0011e 74 4b            je      SHORT $LN31@gzread\r
2047 \r
2048 ; 359  :                 return -1;\r
2049 ; 360  :             n = state->x.have;\r
2050 \r
2051   00120 8b 33            mov     esi, DWORD PTR [ebx]\r
2052 \r
2053 ; 361  :             state->x.have = 0;\r
2054 ; 362  :         }\r
2055 ; 363  : \r
2056 ; 364  :         /* update progress */\r
2057 ; 365  :         len -= n;\r
2058 ; 366  :         buf = (char *)buf + n;\r
2059 \r
2060   00122 01 75 0c         add     DWORD PTR _buf$[ebp], esi\r
2061 \r
2062 ; 367  :         got += n;\r
2063 \r
2064   00125 01 75 10         add     DWORD PTR _got$[ebp], esi\r
2065   00128 2b fe            sub     edi, esi\r
2066 \r
2067 ; 368  :         state->x.pos += n;\r
2068 \r
2069   0012a 01 73 08         add     DWORD PTR [ebx+8], esi\r
2070   0012d 89 75 08         mov     DWORD PTR _n$[ebp], esi\r
2071   00130 c7 03 00 00 00\r
2072         00               mov     DWORD PTR [ebx], 0\r
2073   00136 83 53 0c 00      adc     DWORD PTR [ebx+12], 0\r
2074   0013a eb 0c            jmp     SHORT $LN14@gzread\r
2075 $LN7@gzread:\r
2076 \r
2077 ; 340  :             /* get more output, looking for header if required */\r
2078 ; 341  :             if (gz_fetch(state) == -1)\r
2079 \r
2080   0013c 8b c3            mov     eax, ebx\r
2081   0013e e8 00 00 00 00   call    _gz_fetch\r
2082   00143 83 f8 ff         cmp     eax, -1\r
2083   00146 74 23            je      SHORT $LN31@gzread\r
2084 $LN14@gzread:\r
2085 \r
2086 ; 369  :     } while (len);\r
2087 \r
2088   00148 85 ff            test    edi, edi\r
2089   0014a 0f 85 37 ff ff\r
2090         ff               jne     $LL15@gzread\r
2091 \r
2092 ; 370  : \r
2093 ; 371  :     /* return number of bytes read into user buffer (will fit in int) */\r
2094 ; 372  :     return (int)got;\r
2095 \r
2096   00150 8b 45 10         mov     eax, DWORD PTR _got$[ebp]\r
2097   00153 5e               pop     esi\r
2098   00154 5f               pop     edi\r
2099   00155 5b               pop     ebx\r
2100 \r
2101 ; 373  : }\r
2102 \r
2103   00156 5d               pop     ebp\r
2104   00157 c2 0c 00         ret     12                     ; 0000000cH\r
2105 $LN28@gzread:\r
2106 \r
2107 ; 370  : \r
2108 ; 371  :     /* return number of bytes read into user buffer (will fit in int) */\r
2109 ; 372  :     return (int)got;\r
2110 \r
2111   0015a 8b 45 10         mov     eax, DWORD PTR _got$[ebp]\r
2112   0015d 5e               pop     esi\r
2113   0015e 5f               pop     edi\r
2114   0015f c7 43 44 01 00\r
2115         00 00            mov     DWORD PTR [ebx+68], 1\r
2116   00166 5b               pop     ebx\r
2117 \r
2118 ; 373  : }\r
2119 \r
2120   00167 5d               pop     ebp\r
2121   00168 c2 0c 00         ret     12                     ; 0000000cH\r
2122 $LN31@gzread:\r
2123   0016b 5e               pop     esi\r
2124   0016c 5f               pop     edi\r
2125 \r
2126 ; 342  :                 return -1;\r
2127 \r
2128   0016d 83 c8 ff         or      eax, -1\r
2129   00170 5b               pop     ebx\r
2130 \r
2131 ; 373  : }\r
2132 \r
2133   00171 5d               pop     ebp\r
2134   00172 c2 0c 00         ret     12                     ; 0000000cH\r
2135 _gzread@12 ENDP\r
2136 PUBLIC  _gzgetc_@4\r
2137 ; Function compile flags: /Ogtp\r
2138 ;       COMDAT _gzgetc_@4\r
2139 _TEXT   SEGMENT\r
2140 _file$ = 8                                              ; size = 4\r
2141 _buf$ = 11                                              ; size = 1\r
2142 _gzgetc_@4 PROC                                         ; COMDAT\r
2143 \r
2144 ; 378  : {\r
2145 \r
2146   00000 55               push    ebp\r
2147   00001 8b ec            mov     ebp, esp\r
2148 \r
2149 ; 379  :     int ret;\r
2150 ; 380  :     unsigned char buf[1];\r
2151 ; 381  :     gz_statep state;\r
2152 ; 382  : \r
2153 ; 383  :     /* get internal structure */\r
2154 ; 384  :     if (file == NULL)\r
2155 \r
2156   00003 8b 45 08         mov     eax, DWORD PTR _file$[ebp]\r
2157   00006 85 c0            test    eax, eax\r
2158 \r
2159 ; 385  :         return -1;\r
2160 \r
2161   00008 74 4f            je      SHORT $LN2@gzgetc_\r
2162 \r
2163 ; 386  :     state = (gz_statep)file;\r
2164 ; 387  : \r
2165 ; 388  :     /* check that we're reading and that there's no (serious) error */\r
2166 ; 389  :     if (state->mode != GZ_READ ||\r
2167 ; 390  :         (state->err != Z_OK && state->err != Z_BUF_ERROR))\r
2168 \r
2169   0000a 81 78 10 4f 1c\r
2170         00 00            cmp     DWORD PTR [eax+16], 7247 ; 00001c4fH\r
2171   00011 75 46            jne     SHORT $LN2@gzgetc_\r
2172   00013 8b 48 5c         mov     ecx, DWORD PTR [eax+92]\r
2173   00016 85 c9            test    ecx, ecx\r
2174   00018 74 05            je      SHORT $LN3@gzgetc_\r
2175   0001a 83 f9 fb         cmp     ecx, -5                        ; fffffffbH\r
2176   0001d 75 3a            jne     SHORT $LN2@gzgetc_\r
2177 $LN3@gzgetc_:\r
2178 \r
2179 ; 392  : \r
2180 ; 393  :     /* try output buffer (no need to check for skip request) */\r
2181 ; 394  :     if (state->x.have) {\r
2182 \r
2183   0001f 8b 08            mov     ecx, DWORD PTR [eax]\r
2184   00021 85 c9            test    ecx, ecx\r
2185   00023 74 1b            je      SHORT $LN1@gzgetc_\r
2186 \r
2187 ; 395  :         state->x.have--;\r
2188 \r
2189   00025 49               dec     ecx\r
2190 \r
2191 ; 396  :         state->x.pos++;\r
2192 \r
2193   00026 83 40 08 01      add     DWORD PTR [eax+8], 1\r
2194   0002a 89 08            mov     DWORD PTR [eax], ecx\r
2195 \r
2196 ; 397  :         return *(state->x.next)++;\r
2197 \r
2198   0002c 8b 48 04         mov     ecx, DWORD PTR [eax+4]\r
2199   0002f 83 50 0c 00      adc     DWORD PTR [eax+12], 0\r
2200   00033 8a 11            mov     dl, BYTE PTR [ecx]\r
2201   00035 41               inc     ecx\r
2202   00036 89 48 04         mov     DWORD PTR [eax+4], ecx\r
2203   00039 0f b6 c2         movzx   eax, dl\r
2204 \r
2205 ; 403  : }\r
2206 \r
2207   0003c 5d               pop     ebp\r
2208   0003d c2 04 00         ret     4\r
2209 $LN1@gzgetc_:\r
2210 \r
2211 ; 398  :     }\r
2212 ; 399  : \r
2213 ; 400  :     /* nothing there -- try gzread() */\r
2214 ; 401  :     ret = gzread(file, buf, 1);\r
2215 \r
2216   00040 6a 01            push    1\r
2217   00042 8d 4d 0b         lea     ecx, DWORD PTR _buf$[ebp]\r
2218   00045 51               push    ecx\r
2219   00046 50               push    eax\r
2220   00047 e8 00 00 00 00   call    _gzread@12\r
2221 \r
2222 ; 402  :     return ret < 1 ? -1 : buf[0];\r
2223 \r
2224   0004c 83 f8 01         cmp     eax, 1\r
2225   0004f 7c 08            jl      SHORT $LN2@gzgetc_\r
2226   00051 0f b6 45 0b      movzx   eax, BYTE PTR _buf$[ebp]\r
2227 \r
2228 ; 403  : }\r
2229 \r
2230   00055 5d               pop     ebp\r
2231   00056 c2 04 00         ret     4\r
2232 $LN2@gzgetc_:\r
2233 \r
2234 ; 391  :         return -1;\r
2235 \r
2236   00059 83 c8 ff         or      eax, -1\r
2237 \r
2238 ; 403  : }\r
2239 \r
2240   0005c 5d               pop     ebp\r
2241   0005d c2 04 00         ret     4\r
2242 _gzgetc_@4 ENDP\r
2243 _TEXT   ENDS\r
2244 PUBLIC  _gzgetc@4\r
2245 ; Function compile flags: /Ogtp\r
2246 ;       COMDAT _gzgetc@4\r
2247 _TEXT   SEGMENT\r
2248 _file$ = 8                                              ; size = 4\r
2249 _gzgetc@4 PROC                                          ; COMDAT\r
2250 \r
2251 ; 408  : {\r
2252 \r
2253   00000 55               push    ebp\r
2254   00001 8b ec            mov     ebp, esp\r
2255 \r
2256 ; 410  : }    \r
2257 \r
2258   00003 5d               pop     ebp\r
2259 \r
2260 ; 409  :     return gzgetc_(file);\r
2261 \r
2262   00004 e9 00 00 00 00   jmp     _gzgetc_@4\r
2263 _gzgetc@4 ENDP\r
2264 _TEXT   ENDS\r
2265 END\r