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\gzwrite.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@_0CH@DEEGAHIB@internal?5error?3?5deflate?5stream?5c@ ; `string'\r
  12 EXTRN   __imp__vsnprintf:PROC\r
  13 EXTRN   _write:PROC\r
  14 ;       COMDAT ??_C@_0CH@DEEGAHIB@internal?5error?3?5deflate?5stream?5c@\r
  15 CONST   SEGMENT\r
  16 ??_C@_0CH@DEEGAHIB@internal?5error?3?5deflate?5stream?5c@ DB 'internal er'\r
  17         DB      'ror: deflate stream corrupt', 00H              ; `string'\r
  18 PUBLIC  _gzflags@0\r
  19 ; Function compile flags: /Ogtp\r
  20 ; File c:\workspaces\sysdyn\org.simantics.fmu\fmusolution\zlib-1.2.6\gzwrite.c\r
  21 ;       COMDAT _gzflags@0\r
  22 _TEXT   SEGMENT\r
  23 _gzflags@0 PROC                                         ; COMDAT\r
  24 \r
  25 ; 567  :     unsigned long flags = 0;\r
  26 ; 568  : #if defined(STDC) || defined(Z_HAVE_STDARG_H)\r
  27 ; 569  : #  ifdef NO_vsnprintf\r
  28 ; 570  :     flags += 1L << 25;\r
  29 ; 571  : #    ifdef HAS_vsprintf_void\r
  30 ; 572  :     flags += 1L << 26;\r
  31 ; 573  : #    endif\r
  32 ; 574  : #  else\r
  33 ; 575  : #    ifdef HAS_vsnprintf_void\r
  34 ; 576  :     flags += 1L << 26;\r
  35 ; 577  : #    endif\r
  36 ; 578  : #  endif\r
  37 ; 579  : #else\r
  38 ; 580  :     flags += 1L << 24;\r
  39 ; 581  : #  ifdef NO_snprintf\r
  40 ; 582  :     flags += 1L << 25;\r
  41 ; 583  : #    ifdef HAS_sprintf_void\r
  42 ; 584  :     flags += 1L << 26;\r
  43 ; 585  : #    endif\r
  44 ; 586  : #  else\r
  45 ; 587  : #    ifdef HAS_snprintf_void\r
  46 ; 588  :     flags += 1L << 26;\r
  47 ; 589  : #    endif\r
  48 ; 590  : #  endif\r
  49 ; 591  : #endif\r
  50 ; 592  :     return flags;\r
  51 \r
  52   00000 33 c0            xor     eax, eax\r
  53 \r
  54 ; 593  : }\r
  55 \r
  56   00002 c3               ret     0\r
  57 _gzflags@0 ENDP\r
  58 ; Function compile flags: /Ogtp\r
  59 ;       COMDAT _gz_init\r
  60 _TEXT   SEGMENT\r
  61 _gz_init PROC                                           ; COMDAT\r
  62 ; _state$ = esi\r
  63 \r
  64 ; 18   :     int ret;\r
  65 ; 19   :     z_streamp strm = &(state->strm);\r
  66 ; 20   : \r
  67 ; 21   :     /* allocate input buffer */\r
  68 ; 22   :     state->in = malloc(state->want);\r
  69 \r
  70   00000 8b 46 20         mov     eax, DWORD PTR [esi+32]\r
  71   00003 53               push    ebx\r
  72   00004 57               push    edi\r
  73   00005 50               push    eax\r
  74   00006 8d 7e 64         lea     edi, DWORD PTR [esi+100]\r
  75   00009 ff 15 00 00 00\r
  76         00               call    DWORD PTR __imp__malloc\r
  77   0000f 8b d8            mov     ebx, eax\r
  78   00011 83 c4 04         add     esp, 4\r
  79   00014 89 5e 24         mov     DWORD PTR [esi+36], ebx\r
  80 \r
  81 ; 23   :     if (state->in == NULL) {\r
  82 \r
  83   00017 85 db            test    ebx, ebx\r
  84   00019 75 18            jne     SHORT $LN5@gz_init\r
  85 \r
  86 ; 24   :         gz_error(state, Z_MEM_ERROR, "out of memory");\r
  87 \r
  88   0001b 68 00 00 00 00   push    OFFSET ??_C@_0O@BNNCBLEN@out?5of?5memory?$AA@\r
  89   00020 8d 43 fc         lea     eax, DWORD PTR [ebx-4]\r
  90   00023 8b ce            mov     ecx, esi\r
  91   00025 e8 00 00 00 00   call    _gz_error\r
  92   0002a 83 c4 04         add     esp, 4\r
  93   0002d 5f               pop     edi\r
  94 \r
  95 ; 25   :         return -1;\r
  96 \r
  97   0002e 83 c8 ff         or      eax, -1\r
  98   00031 5b               pop     ebx\r
  99 \r
 100 ; 62   : }\r
 101 \r
 102   00032 c3               ret     0\r
 103 $LN5@gz_init:\r
 104 \r
 105 ; 26   :     }\r
 106 ; 27   : \r
 107 ; 28   :     /* only need output buffer and deflate state if compressing */\r
 108 ; 29   :     if (!state->direct) {\r
 109 \r
 110   00033 83 7e 2c 00      cmp     DWORD PTR [esi+44], 0\r
 111   00037 0f 85 8b 00 00\r
 112         00               jne     $LN8@gz_init\r
 113 \r
 114 ; 30   :         /* allocate output buffer */\r
 115 ; 31   :         state->out = malloc(state->want);\r
 116 \r
 117   0003d 8b 46 20         mov     eax, DWORD PTR [esi+32]\r
 118   00040 50               push    eax\r
 119   00041 ff 15 00 00 00\r
 120         00               call    DWORD PTR __imp__malloc\r
 121 \r
 122 ; 32   :         if (state->out == NULL) {\r
 123 \r
 124   00047 33 c9            xor     ecx, ecx\r
 125   00049 83 c4 04         add     esp, 4\r
 126   0004c 89 46 28         mov     DWORD PTR [esi+40], eax\r
 127   0004f 3b c1            cmp     eax, ecx\r
 128   00051 75 21            jne     SHORT $LN3@gz_init\r
 129 \r
 130 ; 33   :             free(state->in);\r
 131 \r
 132   00053 53               push    ebx\r
 133   00054 ff 15 00 00 00\r
 134         00               call    DWORD PTR __imp__free\r
 135 \r
 136 ; 34   :             gz_error(state, Z_MEM_ERROR, "out of memory");\r
 137 \r
 138   0005a 68 00 00 00 00   push    OFFSET ??_C@_0O@BNNCBLEN@out?5of?5memory?$AA@\r
 139   0005f b8 fc ff ff ff   mov     eax, -4                        ; fffffffcH\r
 140   00064 8b ce            mov     ecx, esi\r
 141   00066 e8 00 00 00 00   call    _gz_error\r
 142   0006b 83 c4 08         add     esp, 8\r
 143   0006e 5f               pop     edi\r
 144 \r
 145 ; 35   :             return -1;\r
 146 \r
 147   0006f 83 c8 ff         or      eax, -1\r
 148   00072 5b               pop     ebx\r
 149 \r
 150 ; 62   : }\r
 151 \r
 152   00073 c3               ret     0\r
 153 $LN3@gz_init:\r
 154 \r
 155 ; 36   :         }\r
 156 ; 37   : \r
 157 ; 38   :         /* allocate deflate memory, set up for gzip compression */\r
 158 ; 39   :         strm->zalloc = Z_NULL;\r
 159 ; 40   :         strm->zfree = Z_NULL;\r
 160 ; 41   :         strm->opaque = Z_NULL;\r
 161 ; 42   :         ret = deflateInit2(strm, state->level, Z_DEFLATED,\r
 162 ; 43   :                            MAX_WBITS + 16, DEF_MEM_LEVEL, state->strategy);\r
 163 \r
 164   00074 6a 38            push    56                     ; 00000038H\r
 165   00076 68 00 00 00 00   push    OFFSET ??_C@_05BOAHNBIE@1?42?46?$AA@\r
 166   0007b 89 4f 20         mov     DWORD PTR [edi+32], ecx\r
 167   0007e 89 4f 24         mov     DWORD PTR [edi+36], ecx\r
 168   00081 89 4f 28         mov     DWORD PTR [edi+40], ecx\r
 169   00084 8b 46 4c         mov     eax, DWORD PTR [esi+76]\r
 170   00087 8b 4e 48         mov     ecx, DWORD PTR [esi+72]\r
 171   0008a 50               push    eax\r
 172   0008b 6a 08            push    8\r
 173   0008d 6a 1f            push    31                     ; 0000001fH\r
 174   0008f 6a 08            push    8\r
 175   00091 51               push    ecx\r
 176   00092 57               push    edi\r
 177   00093 e8 00 00 00 00   call    _deflateInit2_@32\r
 178 \r
 179 ; 44   :         if (ret != Z_OK) {\r
 180 \r
 181   00098 85 c0            test    eax, eax\r
 182   0009a 74 2c            je      SHORT $LN8@gz_init\r
 183 \r
 184 ; 45   :             free(state->out);\r
 185 \r
 186   0009c 8b 56 28         mov     edx, DWORD PTR [esi+40]\r
 187   0009f 8b 3d 00 00 00\r
 188         00               mov     edi, DWORD PTR __imp__free\r
 189   000a5 52               push    edx\r
 190   000a6 ff d7            call    edi\r
 191 \r
 192 ; 46   :             free(state->in);\r
 193 \r
 194   000a8 8b 46 24         mov     eax, DWORD PTR [esi+36]\r
 195   000ab 50               push    eax\r
 196   000ac ff d7            call    edi\r
 197 \r
 198 ; 47   :             gz_error(state, Z_MEM_ERROR, "out of memory");\r
 199 \r
 200   000ae 68 00 00 00 00   push    OFFSET ??_C@_0O@BNNCBLEN@out?5of?5memory?$AA@\r
 201   000b3 b8 fc ff ff ff   mov     eax, -4                        ; fffffffcH\r
 202   000b8 8b ce            mov     ecx, esi\r
 203   000ba e8 00 00 00 00   call    _gz_error\r
 204   000bf 83 c4 0c         add     esp, 12                        ; 0000000cH\r
 205   000c2 5f               pop     edi\r
 206 \r
 207 ; 48   :             return -1;\r
 208 \r
 209   000c3 83 c8 ff         or      eax, -1\r
 210   000c6 5b               pop     ebx\r
 211 \r
 212 ; 62   : }\r
 213 \r
 214   000c7 c3               ret     0\r
 215 $LN8@gz_init:\r
 216 \r
 217 ; 49   :         }\r
 218 ; 50   :     }\r
 219 ; 51   : \r
 220 ; 52   :     /* mark state as initialized */\r
 221 ; 53   :     state->size = state->want;\r
 222 ; 54   : \r
 223 ; 55   :     /* initialize write buffer if compressing */\r
 224 ; 56   :     if (!state->direct) {\r
 225 \r
 226   000c8 83 7e 2c 00      cmp     DWORD PTR [esi+44], 0\r
 227   000cc 8b 46 20         mov     eax, DWORD PTR [esi+32]\r
 228   000cf 89 46 1c         mov     DWORD PTR [esi+28], eax\r
 229   000d2 75 0c            jne     SHORT $LN1@gz_init\r
 230 \r
 231 ; 57   :         strm->avail_out = state->size;\r
 232 \r
 233   000d4 89 47 10         mov     DWORD PTR [edi+16], eax\r
 234 \r
 235 ; 58   :         strm->next_out = state->out;\r
 236 \r
 237   000d7 8b 46 28         mov     eax, DWORD PTR [esi+40]\r
 238   000da 89 47 0c         mov     DWORD PTR [edi+12], eax\r
 239 \r
 240 ; 59   :         state->x.next = strm->next_out;\r
 241 \r
 242   000dd 89 46 04         mov     DWORD PTR [esi+4], eax\r
 243 $LN1@gz_init:\r
 244 \r
 245 ; 60   :     }\r
 246 ; 61   :     return 0;\r
 247 \r
 248   000e0 5f               pop     edi\r
 249   000e1 33 c0            xor     eax, eax\r
 250   000e3 5b               pop     ebx\r
 251 \r
 252 ; 62   : }\r
 253 \r
 254   000e4 c3               ret     0\r
 255 _gz_init ENDP\r
 256 ; Function compile flags: /Ogtp\r
 257 ;       COMDAT _gz_comp\r
 258 _TEXT   SEGMENT\r
 259 _flush$ = 8                                             ; size = 4\r
 260 _gz_comp PROC                                           ; COMDAT\r
 261 ; _state$ = ebx\r
 262 \r
 263 ; 73   : {\r
 264 \r
 265   00000 55               push    ebp\r
 266   00001 8b ec            mov     ebp, esp\r
 267 \r
 268 ; 74   :     int ret, got;\r
 269 ; 75   :     unsigned have;\r
 270 ; 76   :     z_streamp strm = &(state->strm);\r
 271 ; 77   : \r
 272 ; 78   :     /* allocate memory if this is the first time through */\r
 273 ; 79   :     if (state->size == 0 && gz_init(state) == -1)\r
 274 \r
 275   00003 83 7b 1c 00      cmp     DWORD PTR [ebx+28], 0\r
 276   00007 56               push    esi\r
 277   00008 57               push    edi\r
 278   00009 8d 7b 64         lea     edi, DWORD PTR [ebx+100]\r
 279   0000c 75 0c            jne     SHORT $LN21@gz_comp\r
 280   0000e 8b f3            mov     esi, ebx\r
 281   00010 e8 00 00 00 00   call    _gz_init\r
 282   00015 83 f8 ff         cmp     eax, -1\r
 283 \r
 284 ; 80   :         return -1;\r
 285 \r
 286   00018 74 4c            je      SHORT $LN24@gz_comp\r
 287 $LN21@gz_comp:\r
 288 \r
 289 ; 81   : \r
 290 ; 82   :     /* write directly if requested */\r
 291 ; 83   :     if (state->direct) {\r
 292 \r
 293   0001a 83 7b 2c 00      cmp     DWORD PTR [ebx+44], 0\r
 294   0001e 74 4d            je      SHORT $LN14@gz_comp\r
 295 \r
 296 ; 84   :         got = write(state->fd, strm->next_in, strm->avail_in);\r
 297 \r
 298   00020 8b 47 04         mov     eax, DWORD PTR [edi+4]\r
 299   00023 8b 0f            mov     ecx, DWORD PTR [edi]\r
 300   00025 8b 53 14         mov     edx, DWORD PTR [ebx+20]\r
 301   00028 50               push    eax\r
 302   00029 51               push    ecx\r
 303   0002a 52               push    edx\r
 304   0002b e8 00 00 00 00   call    _write\r
 305   00030 83 c4 0c         add     esp, 12                        ; 0000000cH\r
 306 \r
 307 ; 85   :         if (got < 0 || (unsigned)got != strm->avail_in) {\r
 308 \r
 309   00033 85 c0            test    eax, eax\r
 310   00035 78 12            js      SHORT $LN12@gz_comp\r
 311   00037 3b 47 04         cmp     eax, DWORD PTR [edi+4]\r
 312   0003a 75 0d            jne     SHORT $LN12@gz_comp\r
 313 \r
 314 ; 88   :         }\r
 315 ; 89   :         strm->avail_in = 0;\r
 316 \r
 317   0003c c7 47 04 00 00\r
 318         00 00            mov     DWORD PTR [edi+4], 0\r
 319   00043 5f               pop     edi\r
 320 \r
 321 ; 127  : \r
 322 ; 128  :     /* all done, no errors */\r
 323 ; 129  :     return 0;\r
 324 \r
 325   00044 33 c0            xor     eax, eax\r
 326   00046 5e               pop     esi\r
 327 \r
 328 ; 130  : }\r
 329 \r
 330   00047 5d               pop     ebp\r
 331   00048 c3               ret     0\r
 332 $LN12@gz_comp:\r
 333 \r
 334 ; 86   :             gz_error(state, Z_ERRNO, zstrerror());\r
 335 \r
 336   00049 ff 15 00 00 00\r
 337         00               call    DWORD PTR __imp___errno\r
 338   0004f 8b 00            mov     eax, DWORD PTR [eax]\r
 339   00051 50               push    eax\r
 340   00052 ff 15 00 00 00\r
 341         00               call    DWORD PTR __imp__strerror\r
 342   00058 50               push    eax\r
 343   00059 83 c8 ff         or      eax, -1\r
 344   0005c 8b cb            mov     ecx, ebx\r
 345   0005e e8 00 00 00 00   call    _gz_error\r
 346   00063 83 c4 08         add     esp, 8\r
 347 $LN24@gz_comp:\r
 348 \r
 349 ; 87   :             return -1;\r
 350 \r
 351   00066 5f               pop     edi\r
 352   00067 83 c8 ff         or      eax, -1\r
 353   0006a 5e               pop     esi\r
 354 \r
 355 ; 130  : }\r
 356 \r
 357   0006b 5d               pop     ebp\r
 358   0006c c3               ret     0\r
 359 $LN14@gz_comp:\r
 360 \r
 361 ; 90   :         return 0;\r
 362 ; 91   :     }\r
 363 ; 92   : \r
 364 ; 93   :     /* run deflate() on provided input until it produces no more output */\r
 365 ; 94   :     ret = Z_OK;\r
 366 \r
 367   0006d 33 c0            xor     eax, eax\r
 368   0006f 90               npad    1\r
 369 $LL11@gz_comp:\r
 370 \r
 371 ; 95   :     do {\r
 372 ; 96   :         /* write out current buffer contents if full, or if flushing, but if\r
 373 ; 97   :            doing Z_FINISH then don't write until we get to Z_STREAM_END */\r
 374 ; 98   :         if (strm->avail_out == 0 || (flush != Z_NO_FLUSH &&\r
 375 ; 99   :             (flush != Z_FINISH || ret == Z_STREAM_END))) {\r
 376 \r
 377   00070 83 7f 10 00      cmp     DWORD PTR [edi+16], 0\r
 378   00074 74 11            je      SHORT $LN6@gz_comp\r
 379   00076 8b 4d 08         mov     ecx, DWORD PTR _flush$[ebp]\r
 380   00079 85 c9            test    ecx, ecx\r
 381   0007b 74 45            je      SHORT $LN8@gz_comp\r
 382   0007d 83 f9 04         cmp     ecx, 4\r
 383   00080 75 05            jne     SHORT $LN6@gz_comp\r
 384   00082 83 f8 01         cmp     eax, 1\r
 385   00085 75 3b            jne     SHORT $LN8@gz_comp\r
 386 $LN6@gz_comp:\r
 387 \r
 388 ; 100  :             have = (unsigned)(strm->next_out - state->x.next);\r
 389 \r
 390   00087 8b 43 04         mov     eax, DWORD PTR [ebx+4]\r
 391   0008a 8b 77 0c         mov     esi, DWORD PTR [edi+12]\r
 392   0008d 2b f0            sub     esi, eax\r
 393 \r
 394 ; 101  :             if (have && ((got = write(state->fd, state->x.next, have)) < 0 ||\r
 395 ; 102  :                          (unsigned)got != have)) {\r
 396 \r
 397   0008f 74 16            je      SHORT $LN23@gz_comp\r
 398   00091 8b 4b 14         mov     ecx, DWORD PTR [ebx+20]\r
 399   00094 56               push    esi\r
 400   00095 50               push    eax\r
 401   00096 51               push    ecx\r
 402   00097 e8 00 00 00 00   call    _write\r
 403   0009c 83 c4 0c         add     esp, 12                        ; 0000000cH\r
 404   0009f 85 c0            test    eax, eax\r
 405   000a1 78 45            js      SHORT $LN4@gz_comp\r
 406   000a3 3b c6            cmp     eax, esi\r
 407   000a5 75 41            jne     SHORT $LN4@gz_comp\r
 408 $LN23@gz_comp:\r
 409 \r
 410 ; 105  :             }\r
 411 ; 106  :             if (strm->avail_out == 0) {\r
 412 \r
 413   000a7 83 7f 10 00      cmp     DWORD PTR [edi+16], 0\r
 414   000ab 75 0c            jne     SHORT $LN3@gz_comp\r
 415 \r
 416 ; 107  :                 strm->avail_out = state->size;\r
 417 \r
 418   000ad 8b 53 1c         mov     edx, DWORD PTR [ebx+28]\r
 419   000b0 89 57 10         mov     DWORD PTR [edi+16], edx\r
 420 \r
 421 ; 108  :                 strm->next_out = state->out;\r
 422 \r
 423   000b3 8b 43 28         mov     eax, DWORD PTR [ebx+40]\r
 424   000b6 89 47 0c         mov     DWORD PTR [edi+12], eax\r
 425 $LN3@gz_comp:\r
 426 \r
 427 ; 109  :             }\r
 428 ; 110  :             state->x.next = strm->next_out;\r
 429 \r
 430   000b9 8b 4f 0c         mov     ecx, DWORD PTR [edi+12]\r
 431   000bc 89 4b 04         mov     DWORD PTR [ebx+4], ecx\r
 432   000bf 8b 4d 08         mov     ecx, DWORD PTR _flush$[ebp]\r
 433 $LN8@gz_comp:\r
 434 \r
 435 ; 111  :         }\r
 436 ; 112  : \r
 437 ; 113  :         /* compress */\r
 438 ; 114  :         have = strm->avail_out;\r
 439 \r
 440   000c2 8b 77 10         mov     esi, DWORD PTR [edi+16]\r
 441 \r
 442 ; 115  :         ret = deflate(strm, flush);\r
 443 \r
 444   000c5 51               push    ecx\r
 445   000c6 57               push    edi\r
 446   000c7 e8 00 00 00 00   call    _deflate@8\r
 447 \r
 448 ; 116  :         if (ret == Z_STREAM_ERROR) {\r
 449 \r
 450   000cc 83 f8 fe         cmp     eax, -2                        ; fffffffeH\r
 451   000cf 74 3b            je      SHORT $LN20@gz_comp\r
 452 \r
 453 ; 120  :         }\r
 454 ; 121  :         have -= strm->avail_out;\r
 455 \r
 456   000d1 2b 77 10         sub     esi, DWORD PTR [edi+16]\r
 457 \r
 458 ; 122  :     } while (have);\r
 459 \r
 460   000d4 75 9a            jne     SHORT $LL11@gz_comp\r
 461 \r
 462 ; 123  : \r
 463 ; 124  :     /* if that completed a deflate stream, allow another to start */\r
 464 ; 125  :     if (flush == Z_FINISH)\r
 465 \r
 466   000d6 83 7d 08 04      cmp     DWORD PTR _flush$[ebp], 4\r
 467   000da 75 06            jne     SHORT $LN1@gz_comp\r
 468 \r
 469 ; 126  :         deflateReset(strm);\r
 470 \r
 471   000dc 57               push    edi\r
 472   000dd e8 00 00 00 00   call    _deflateReset@4\r
 473 $LN1@gz_comp:\r
 474 \r
 475 ; 127  : \r
 476 ; 128  :     /* all done, no errors */\r
 477 ; 129  :     return 0;\r
 478 \r
 479   000e2 5f               pop     edi\r
 480   000e3 33 c0            xor     eax, eax\r
 481   000e5 5e               pop     esi\r
 482 \r
 483 ; 130  : }\r
 484 \r
 485   000e6 5d               pop     ebp\r
 486   000e7 c3               ret     0\r
 487 $LN4@gz_comp:\r
 488 \r
 489 ; 103  :                 gz_error(state, Z_ERRNO, zstrerror());\r
 490 \r
 491   000e8 ff 15 00 00 00\r
 492         00               call    DWORD PTR __imp___errno\r
 493   000ee 8b 10            mov     edx, DWORD PTR [eax]\r
 494   000f0 52               push    edx\r
 495   000f1 ff 15 00 00 00\r
 496         00               call    DWORD PTR __imp__strerror\r
 497   000f7 50               push    eax\r
 498   000f8 83 c8 ff         or      eax, -1\r
 499   000fb 8b cb            mov     ecx, ebx\r
 500   000fd e8 00 00 00 00   call    _gz_error\r
 501   00102 83 c4 08         add     esp, 8\r
 502   00105 5f               pop     edi\r
 503 \r
 504 ; 104  :                 return -1;\r
 505 \r
 506   00106 83 c8 ff         or      eax, -1\r
 507   00109 5e               pop     esi\r
 508 \r
 509 ; 130  : }\r
 510 \r
 511   0010a 5d               pop     ebp\r
 512   0010b c3               ret     0\r
 513 $LN20@gz_comp:\r
 514 \r
 515 ; 117  :             gz_error(state, Z_STREAM_ERROR,\r
 516 ; 118  :                       "internal error: deflate stream corrupt");\r
 517 \r
 518   0010c 68 00 00 00 00   push    OFFSET ??_C@_0CH@DEEGAHIB@internal?5error?3?5deflate?5stream?5c@\r
 519   00111 b8 fe ff ff ff   mov     eax, -2                        ; fffffffeH\r
 520   00116 8b cb            mov     ecx, ebx\r
 521   00118 e8 00 00 00 00   call    _gz_error\r
 522   0011d 83 c4 04         add     esp, 4\r
 523   00120 5f               pop     edi\r
 524 \r
 525 ; 119  :             return -1;\r
 526 \r
 527   00121 83 c8 ff         or      eax, -1\r
 528   00124 5e               pop     esi\r
 529 \r
 530 ; 130  : }\r
 531 \r
 532   00125 5d               pop     ebp\r
 533   00126 c3               ret     0\r
 534 _gz_comp ENDP\r
 535 ; Function compile flags: /Ogtp\r
 536 ;       COMDAT _gz_zero\r
 537 _TEXT   SEGMENT\r
 538 _first$ = -4                                            ; size = 4\r
 539 _len$ = 8                                               ; size = 8\r
 540 _gz_zero PROC                                           ; COMDAT\r
 541 ; _state$ = eax\r
 542 \r
 543 ; 136  : {\r
 544 \r
 545   00000 55               push    ebp\r
 546   00001 8b ec            mov     ebp, esp\r
 547   00003 51               push    ecx\r
 548   00004 53               push    ebx\r
 549   00005 8b d8            mov     ebx, eax\r
 550 \r
 551 ; 137  :     int first;\r
 552 ; 138  :     unsigned n;\r
 553 ; 139  :     z_streamp strm = &(state->strm);\r
 554 ; 140  : \r
 555 ; 141  :     /* consume whatever's left in the input buffer */\r
 556 ; 142  :     if (strm->avail_in && gz_comp(state, Z_NO_FLUSH) == -1)\r
 557 \r
 558   00007 83 7b 68 00      cmp     DWORD PTR [ebx+104], 0\r
 559   0000b 74 16            je      SHORT $LN5@gz_zero\r
 560   0000d 6a 00            push    0\r
 561   0000f e8 00 00 00 00   call    _gz_comp\r
 562   00014 83 c4 04         add     esp, 4\r
 563   00017 83 f8 ff         cmp     eax, -1\r
 564   0001a 75 07            jne     SHORT $LN5@gz_zero\r
 565 \r
 566 ; 143  :         return -1;\r
 567 \r
 568   0001c 0b c0            or      eax, eax\r
 569   0001e 5b               pop     ebx\r
 570 \r
 571 ; 160  :     }\r
 572 ; 161  :     return 0;\r
 573 ; 162  : }\r
 574 \r
 575   0001f 8b e5            mov     esp, ebp\r
 576   00021 5d               pop     ebp\r
 577   00022 c3               ret     0\r
 578 $LN5@gz_zero:\r
 579   00023 56               push    esi\r
 580 \r
 581 ; 144  : \r
 582 ; 145  :     /* compress len zeros (len guaranteed > 0) */\r
 583 ; 146  :     first = 1;\r
 584 ; 147  :     while (len) {\r
 585 \r
 586   00024 8b 75 08         mov     esi, DWORD PTR _len$[ebp]\r
 587   00027 8b c6            mov     eax, esi\r
 588   00029 0b 45 0c         or      eax, DWORD PTR _len$[ebp+4]\r
 589   0002c 57               push    edi\r
 590   0002d c7 45 fc 01 00\r
 591         00 00            mov     DWORD PTR _first$[ebp], 1\r
 592   00034 75 0d            jne     SHORT $LN4@gz_zero\r
 593   00036 5f               pop     edi\r
 594   00037 5e               pop     esi\r
 595   00038 5b               pop     ebx\r
 596 \r
 597 ; 160  :     }\r
 598 ; 161  :     return 0;\r
 599 ; 162  : }\r
 600 \r
 601   00039 8b e5            mov     esp, ebp\r
 602   0003b 5d               pop     ebp\r
 603   0003c c3               ret     0\r
 604   0003d 8d 49 00         npad    3\r
 605 $LL14@gz_zero:\r
 606 \r
 607 ; 144  : \r
 608 ; 145  :     /* compress len zeros (len guaranteed > 0) */\r
 609 ; 146  :     first = 1;\r
 610 ; 147  :     while (len) {\r
 611 \r
 612   00040 8b 75 08         mov     esi, DWORD PTR _len$[ebp]\r
 613 $LN4@gz_zero:\r
 614 \r
 615 ; 148  :         n = GT_OFF(state->size) || (z_off64_t)state->size > len ?\r
 616 ; 149  :             (unsigned)len : state->size;\r
 617 \r
 618   00043 8b 4b 1c         mov     ecx, DWORD PTR [ebx+28]\r
 619   00046 33 c0            xor     eax, eax\r
 620   00048 33 ff            xor     edi, edi\r
 621   0004a 3b 45 0c         cmp     eax, DWORD PTR _len$[ebp+4]\r
 622   0004d 7f 08            jg      SHORT $LN8@gz_zero\r
 623   0004f 7c 04            jl      SHORT $LN13@gz_zero\r
 624   00051 3b ce            cmp     ecx, esi\r
 625   00053 77 02            ja      SHORT $LN8@gz_zero\r
 626 $LN13@gz_zero:\r
 627   00055 8b f1            mov     esi, ecx\r
 628 $LN8@gz_zero:\r
 629 \r
 630 ; 150  :         if (first) {\r
 631 \r
 632   00057 39 7d fc         cmp     DWORD PTR _first$[ebp], edi\r
 633   0005a 74 11            je      SHORT $LN2@gz_zero\r
 634 \r
 635 ; 151  :             memset(state->in, 0, n);\r
 636 \r
 637   0005c 8b 4b 24         mov     ecx, DWORD PTR [ebx+36]\r
 638   0005f 56               push    esi\r
 639   00060 57               push    edi\r
 640   00061 51               push    ecx\r
 641   00062 e8 00 00 00 00   call    _memset\r
 642   00067 83 c4 0c         add     esp, 12                        ; 0000000cH\r
 643 \r
 644 ; 152  :             first = 0;\r
 645 \r
 646   0006a 89 7d fc         mov     DWORD PTR _first$[ebp], edi\r
 647 $LN2@gz_zero:\r
 648 \r
 649 ; 153  :         }\r
 650 ; 154  :         strm->avail_in = n;\r
 651 \r
 652   0006d 89 73 68         mov     DWORD PTR [ebx+104], esi\r
 653 \r
 654 ; 155  :         strm->next_in = state->in;\r
 655 \r
 656   00070 8b 53 24         mov     edx, DWORD PTR [ebx+36]\r
 657   00073 89 53 64         mov     DWORD PTR [ebx+100], edx\r
 658 \r
 659 ; 156  :         state->x.pos += n;\r
 660 \r
 661   00076 01 73 08         add     DWORD PTR [ebx+8], esi\r
 662 \r
 663 ; 157  :         if (gz_comp(state, Z_NO_FLUSH) == -1)\r
 664 \r
 665   00079 57               push    edi\r
 666   0007a 11 7b 0c         adc     DWORD PTR [ebx+12], edi\r
 667   0007d e8 00 00 00 00   call    _gz_comp\r
 668   00082 83 c4 04         add     esp, 4\r
 669   00085 83 f8 ff         cmp     eax, -1\r
 670   00088 74 1b            je      SHORT $LN11@gz_zero\r
 671 \r
 672 ; 159  :         len -= n;\r
 673 \r
 674   0008a 8b 45 08         mov     eax, DWORD PTR _len$[ebp]\r
 675   0008d 8b 4d 0c         mov     ecx, DWORD PTR _len$[ebp+4]\r
 676   00090 2b c6            sub     eax, esi\r
 677   00092 1b cf            sbb     ecx, edi\r
 678   00094 89 45 08         mov     DWORD PTR _len$[ebp], eax\r
 679   00097 0b c1            or      eax, ecx\r
 680   00099 89 4d 0c         mov     DWORD PTR _len$[ebp+4], ecx\r
 681   0009c 75 a2            jne     SHORT $LL14@gz_zero\r
 682   0009e 5f               pop     edi\r
 683   0009f 5e               pop     esi\r
 684   000a0 5b               pop     ebx\r
 685 \r
 686 ; 160  :     }\r
 687 ; 161  :     return 0;\r
 688 ; 162  : }\r
 689 \r
 690   000a1 8b e5            mov     esp, ebp\r
 691   000a3 5d               pop     ebp\r
 692   000a4 c3               ret     0\r
 693 $LN11@gz_zero:\r
 694   000a5 5f               pop     edi\r
 695   000a6 5e               pop     esi\r
 696 \r
 697 ; 158  :             return -1;\r
 698 \r
 699   000a7 83 c8 ff         or      eax, -1\r
 700   000aa 5b               pop     ebx\r
 701 \r
 702 ; 160  :     }\r
 703 ; 161  :     return 0;\r
 704 ; 162  : }\r
 705 \r
 706   000ab 8b e5            mov     esp, ebp\r
 707   000ad 5d               pop     ebp\r
 708   000ae c3               ret     0\r
 709 _gz_zero ENDP\r
 710 PUBLIC  _gzclose_w@4\r
 711 ; Function compile flags: /Ogtp\r
 712 ;       COMDAT _gzclose_w@4\r
 713 _TEXT   SEGMENT\r
 714 _file$ = 8                                              ; size = 4\r
 715 _gzclose_w@4 PROC                                       ; COMDAT\r
 716 \r
 717 ; 528  : {\r
 718 \r
 719   00000 55               push    ebp\r
 720   00001 8b ec            mov     ebp, esp\r
 721   00003 53               push    ebx\r
 722 \r
 723 ; 529  :     int ret = Z_OK;\r
 724 ; 530  :     gz_statep state;\r
 725 ; 531  : \r
 726 ; 532  :     /* get internal structure */\r
 727 ; 533  :     if (file == NULL)\r
 728 \r
 729   00004 8b 5d 08         mov     ebx, DWORD PTR _file$[ebp]\r
 730   00007 57               push    edi\r
 731   00008 33 ff            xor     edi, edi\r
 732   0000a 85 db            test    ebx, ebx\r
 733   0000c 75 0b            jne     SHORT $LN7@gzclose_w\r
 734 $LN11@gzclose_w:\r
 735   0000e 5f               pop     edi\r
 736 \r
 737 ; 534  :         return Z_STREAM_ERROR;\r
 738 \r
 739   0000f b8 fe ff ff ff   mov     eax, -2                        ; fffffffeH\r
 740   00014 5b               pop     ebx\r
 741 \r
 742 ; 562  : }\r
 743 \r
 744   00015 5d               pop     ebp\r
 745   00016 c2 04 00         ret     4\r
 746 $LN7@gzclose_w:\r
 747 \r
 748 ; 535  :     state = (gz_statep)file;\r
 749 ; 536  : \r
 750 ; 537  :     /* check that we're writing */\r
 751 ; 538  :     if (state->mode != GZ_WRITE)\r
 752 \r
 753   00019 81 7b 10 b1 79\r
 754         00 00            cmp     DWORD PTR [ebx+16], 31153 ; 000079b1H\r
 755 \r
 756 ; 539  :         return Z_STREAM_ERROR;\r
 757 \r
 758   00020 75 ec            jne     SHORT $LN11@gzclose_w\r
 759 \r
 760 ; 540  : \r
 761 ; 541  :     /* check for seek request */\r
 762 ; 542  :     if (state->seek) {\r
 763 \r
 764   00022 39 7b 58         cmp     DWORD PTR [ebx+88], edi\r
 765   00025 74 1d            je      SHORT $LN10@gzclose_w\r
 766 \r
 767 ; 543  :         state->seek = 0;\r
 768 ; 544  :         if (gz_zero(state, state->skip) == -1)\r
 769 \r
 770   00027 8b 43 54         mov     eax, DWORD PTR [ebx+84]\r
 771   0002a 8b 4b 50         mov     ecx, DWORD PTR [ebx+80]\r
 772   0002d 50               push    eax\r
 773   0002e 51               push    ecx\r
 774   0002f 8b c3            mov     eax, ebx\r
 775   00031 89 7b 58         mov     DWORD PTR [ebx+88], edi\r
 776   00034 e8 00 00 00 00   call    _gz_zero\r
 777   00039 83 c4 08         add     esp, 8\r
 778   0003c 83 f8 ff         cmp     eax, -1\r
 779   0003f 75 03            jne     SHORT $LN10@gzclose_w\r
 780 \r
 781 ; 545  :             ret = state->err;\r
 782 \r
 783   00041 8b 7b 5c         mov     edi, DWORD PTR [ebx+92]\r
 784 $LN10@gzclose_w:\r
 785 \r
 786 ; 546  :     }\r
 787 ; 547  : \r
 788 ; 548  :     /* flush, free memory, and close file */\r
 789 ; 549  :     if (gz_comp(state, Z_FINISH) == -1)\r
 790 \r
 791   00044 6a 04            push    4\r
 792   00046 e8 00 00 00 00   call    _gz_comp\r
 793   0004b 83 c4 04         add     esp, 4\r
 794   0004e 83 f8 ff         cmp     eax, -1\r
 795   00051 75 03            jne     SHORT $LN3@gzclose_w\r
 796 \r
 797 ; 550  :         ret = state->err;\r
 798 \r
 799   00053 8b 7b 5c         mov     edi, DWORD PTR [ebx+92]\r
 800 $LN3@gzclose_w:\r
 801 \r
 802 ; 551  :     if (!state->direct) {\r
 803 \r
 804   00056 83 7b 2c 00      cmp     DWORD PTR [ebx+44], 0\r
 805   0005a 56               push    esi\r
 806   0005b 8b 35 00 00 00\r
 807         00               mov     esi, DWORD PTR __imp__free\r
 808   00061 75 12            jne     SHORT $LN2@gzclose_w\r
 809 \r
 810 ; 552  :         (void)deflateEnd(&(state->strm));\r
 811 \r
 812   00063 8d 53 64         lea     edx, DWORD PTR [ebx+100]\r
 813   00066 52               push    edx\r
 814   00067 e8 00 00 00 00   call    _deflateEnd@4\r
 815 \r
 816 ; 553  :         free(state->out);\r
 817 \r
 818   0006c 8b 43 28         mov     eax, DWORD PTR [ebx+40]\r
 819   0006f 50               push    eax\r
 820   00070 ff d6            call    esi\r
 821   00072 83 c4 04         add     esp, 4\r
 822 $LN2@gzclose_w:\r
 823 \r
 824 ; 554  :     }\r
 825 ; 555  :     free(state->in);\r
 826 \r
 827   00075 8b 4b 24         mov     ecx, DWORD PTR [ebx+36]\r
 828   00078 51               push    ecx\r
 829   00079 ff d6            call    esi\r
 830 \r
 831 ; 556  :     gz_error(state, Z_OK, NULL);\r
 832 \r
 833   0007b 6a 00            push    0\r
 834   0007d 33 c0            xor     eax, eax\r
 835   0007f 8b cb            mov     ecx, ebx\r
 836   00081 e8 00 00 00 00   call    _gz_error\r
 837 \r
 838 ; 557  :     free(state->path);\r
 839 \r
 840   00086 8b 53 18         mov     edx, DWORD PTR [ebx+24]\r
 841   00089 52               push    edx\r
 842   0008a ff d6            call    esi\r
 843 \r
 844 ; 558  :     if (close(state->fd) == -1)\r
 845 \r
 846   0008c 8b 43 14         mov     eax, DWORD PTR [ebx+20]\r
 847   0008f 50               push    eax\r
 848   00090 e8 00 00 00 00   call    _close\r
 849   00095 83 c4 10         add     esp, 16                        ; 00000010H\r
 850   00098 83 f8 ff         cmp     eax, -1\r
 851   0009b 75 02            jne     SHORT $LN1@gzclose_w\r
 852 \r
 853 ; 559  :         ret = Z_ERRNO;\r
 854 \r
 855   0009d 0b f8            or      edi, eax\r
 856 $LN1@gzclose_w:\r
 857 \r
 858 ; 560  :     free(state);\r
 859 \r
 860   0009f 53               push    ebx\r
 861   000a0 ff d6            call    esi\r
 862   000a2 83 c4 04         add     esp, 4\r
 863   000a5 5e               pop     esi\r
 864 \r
 865 ; 561  :     return ret;\r
 866 \r
 867   000a6 8b c7            mov     eax, edi\r
 868   000a8 5f               pop     edi\r
 869   000a9 5b               pop     ebx\r
 870 \r
 871 ; 562  : }\r
 872 \r
 873   000aa 5d               pop     ebp\r
 874   000ab c2 04 00         ret     4\r
 875 _gzclose_w@4 ENDP\r
 876 _TEXT   ENDS\r
 877 PUBLIC  _gzsetparams@12\r
 878 ; Function compile flags: /Ogtp\r
 879 ;       COMDAT _gzsetparams@12\r
 880 _TEXT   SEGMENT\r
 881 _file$ = 8                                              ; size = 4\r
 882 _level$ = 12                                            ; size = 4\r
 883 _strategy$ = 16                                         ; size = 4\r
 884 _gzsetparams@12 PROC                                    ; COMDAT\r
 885 \r
 886 ; 488  : {\r
 887 \r
 888   00000 55               push    ebp\r
 889   00001 8b ec            mov     ebp, esp\r
 890   00003 53               push    ebx\r
 891 \r
 892 ; 489  :     gz_statep state;\r
 893 ; 490  :     z_streamp strm;\r
 894 ; 491  : \r
 895 ; 492  :     /* get internal structure */\r
 896 ; 493  :     if (file == NULL)\r
 897 \r
 898   00004 8b 5d 08         mov     ebx, DWORD PTR _file$[ebp]\r
 899   00007 85 db            test    ebx, ebx\r
 900   00009 75 0a            jne     SHORT $LN8@gzsetparam\r
 901 $LN6@gzsetparam:\r
 902 \r
 903 ; 494  :         return Z_STREAM_ERROR;\r
 904 \r
 905   0000b b8 fe ff ff ff   mov     eax, -2                        ; fffffffeH\r
 906   00010 5b               pop     ebx\r
 907 \r
 908 ; 523  : }\r
 909 \r
 910   00011 5d               pop     ebp\r
 911   00012 c2 0c 00         ret     12                     ; 0000000cH\r
 912 $LN8@gzsetparam:\r
 913 \r
 914 ; 495  :     state = (gz_statep)file;\r
 915 ; 496  :     strm = &(state->strm);\r
 916 ; 497  : \r
 917 ; 498  :     /* check that we're writing and that there's no error */\r
 918 ; 499  :     if (state->mode != GZ_WRITE || state->err != Z_OK)\r
 919 \r
 920   00015 81 7b 10 b1 79\r
 921         00 00            cmp     DWORD PTR [ebx+16], 31153 ; 000079b1H\r
 922   0001c 75 ed            jne     SHORT $LN6@gzsetparam\r
 923   0001e 83 7b 5c 00      cmp     DWORD PTR [ebx+92], 0\r
 924   00022 75 e7            jne     SHORT $LN6@gzsetparam\r
 925 \r
 926 ; 500  :         return Z_STREAM_ERROR;\r
 927 ; 501  : \r
 928 ; 502  :     /* if no change is requested, then do nothing */\r
 929 ; 503  :     if (level == state->level && strategy == state->strategy)\r
 930 \r
 931   00024 56               push    esi\r
 932   00025 8b 75 0c         mov     esi, DWORD PTR _level$[ebp]\r
 933   00028 57               push    edi\r
 934   00029 8b 7d 10         mov     edi, DWORD PTR _strategy$[ebp]\r
 935   0002c 3b 73 48         cmp     esi, DWORD PTR [ebx+72]\r
 936   0002f 75 05            jne     SHORT $LN5@gzsetparam\r
 937   00031 3b 7b 4c         cmp     edi, DWORD PTR [ebx+76]\r
 938 \r
 939 ; 504  :         return Z_OK;\r
 940 \r
 941   00034 74 63            je      SHORT $LN14@gzsetparam\r
 942 $LN5@gzsetparam:\r
 943 \r
 944 ; 505  : \r
 945 ; 506  :     /* check for seek request */\r
 946 ; 507  :     if (state->seek) {\r
 947 \r
 948   00036 83 7b 58 00      cmp     DWORD PTR [ebx+88], 0\r
 949   0003a 74 27            je      SHORT $LN11@gzsetparam\r
 950 \r
 951 ; 508  :         state->seek = 0;\r
 952 ; 509  :         if (gz_zero(state, state->skip) == -1)\r
 953 \r
 954   0003c 8b 43 54         mov     eax, DWORD PTR [ebx+84]\r
 955   0003f 8b 4b 50         mov     ecx, DWORD PTR [ebx+80]\r
 956   00042 50               push    eax\r
 957   00043 51               push    ecx\r
 958   00044 8b c3            mov     eax, ebx\r
 959   00046 c7 43 58 00 00\r
 960         00 00            mov     DWORD PTR [ebx+88], 0\r
 961   0004d e8 00 00 00 00   call    _gz_zero\r
 962   00052 83 c4 08         add     esp, 8\r
 963   00055 83 f8 ff         cmp     eax, -1\r
 964   00058 75 09            jne     SHORT $LN11@gzsetparam\r
 965 \r
 966 ; 510  :             return -1;\r
 967 \r
 968   0005a 5f               pop     edi\r
 969   0005b 5e               pop     esi\r
 970   0005c 0b c0            or      eax, eax\r
 971   0005e 5b               pop     ebx\r
 972 \r
 973 ; 523  : }\r
 974 \r
 975   0005f 5d               pop     ebp\r
 976   00060 c2 0c 00         ret     12                     ; 0000000cH\r
 977 $LN11@gzsetparam:\r
 978 \r
 979 ; 511  :     }\r
 980 ; 512  : \r
 981 ; 513  :     /* change compression parameters for subsequent input */\r
 982 ; 514  :     if (state->size) {\r
 983 \r
 984   00063 83 7b 1c 00      cmp     DWORD PTR [ebx+28], 0\r
 985   00067 74 2a            je      SHORT $LN2@gzsetparam\r
 986 \r
 987 ; 515  :         /* flush previous input with previous parameters before changing */\r
 988 ; 516  :         if (strm->avail_in && gz_comp(state, Z_PARTIAL_FLUSH) == -1)\r
 989 \r
 990   00069 83 7b 68 00      cmp     DWORD PTR [ebx+104], 0\r
 991   0006d 74 19            je      SHORT $LN1@gzsetparam\r
 992   0006f 6a 01            push    1\r
 993   00071 e8 00 00 00 00   call    _gz_comp\r
 994   00076 83 c4 04         add     esp, 4\r
 995   00079 83 f8 ff         cmp     eax, -1\r
 996   0007c 75 0a            jne     SHORT $LN1@gzsetparam\r
 997 \r
 998 ; 517  :             return state->err;\r
 999 \r
1000   0007e 8b 43 5c         mov     eax, DWORD PTR [ebx+92]\r
1001   00081 5f               pop     edi\r
1002   00082 5e               pop     esi\r
1003   00083 5b               pop     ebx\r
1004 \r
1005 ; 523  : }\r
1006 \r
1007   00084 5d               pop     ebp\r
1008   00085 c2 0c 00         ret     12                     ; 0000000cH\r
1009 $LN1@gzsetparam:\r
1010 \r
1011 ; 518  :         deflateParams(strm, level, strategy);\r
1012 \r
1013   00088 57               push    edi\r
1014   00089 56               push    esi\r
1015   0008a 8d 43 64         lea     eax, DWORD PTR [ebx+100]\r
1016   0008d 50               push    eax\r
1017   0008e e8 00 00 00 00   call    _deflateParams@12\r
1018 $LN2@gzsetparam:\r
1019 \r
1020 ; 519  :     }\r
1021 ; 520  :     state->level = level;\r
1022 \r
1023   00093 89 73 48         mov     DWORD PTR [ebx+72], esi\r
1024 \r
1025 ; 521  :     state->strategy = strategy;\r
1026 \r
1027   00096 89 7b 4c         mov     DWORD PTR [ebx+76], edi\r
1028 $LN14@gzsetparam:\r
1029 \r
1030 ; 522  :     return Z_OK;\r
1031 \r
1032   00099 5f               pop     edi\r
1033   0009a 5e               pop     esi\r
1034   0009b 33 c0            xor     eax, eax\r
1035   0009d 5b               pop     ebx\r
1036 \r
1037 ; 523  : }\r
1038 \r
1039   0009e 5d               pop     ebp\r
1040   0009f c2 0c 00         ret     12                     ; 0000000cH\r
1041 _gzsetparams@12 ENDP\r
1042 _TEXT   ENDS\r
1043 PUBLIC  _gzflush@8\r
1044 ; Function compile flags: /Ogtp\r
1045 ;       COMDAT _gzflush@8\r
1046 _TEXT   SEGMENT\r
1047 _file$ = 8                                              ; size = 4\r
1048 _flush$ = 12                                            ; size = 4\r
1049 _gzflush@8 PROC                                         ; COMDAT\r
1050 \r
1051 ; 455  : {\r
1052 \r
1053   00000 55               push    ebp\r
1054   00001 8b ec            mov     ebp, esp\r
1055   00003 53               push    ebx\r
1056 \r
1057 ; 456  :     gz_statep state;\r
1058 ; 457  : \r
1059 ; 458  :     /* get internal structure */\r
1060 ; 459  :     if (file == NULL)\r
1061 \r
1062   00004 8b 5d 08         mov     ebx, DWORD PTR _file$[ebp]\r
1063   00007 85 db            test    ebx, ebx\r
1064   00009 75 08            jne     SHORT $LN7@gzflush\r
1065 \r
1066 ; 460  :         return -1;\r
1067 \r
1068   0000b 83 c8 ff         or      eax, -1\r
1069   0000e 5b               pop     ebx\r
1070 \r
1071 ; 481  : }\r
1072 \r
1073   0000f 5d               pop     ebp\r
1074   00010 c2 08 00         ret     8\r
1075 $LN7@gzflush:\r
1076 \r
1077 ; 461  :     state = (gz_statep)file;\r
1078 ; 462  : \r
1079 ; 463  :     /* check that we're writing and that there's no error */\r
1080 ; 464  :     if (state->mode != GZ_WRITE || state->err != Z_OK)\r
1081 \r
1082   00013 81 7b 10 b1 79\r
1083         00 00            cmp     DWORD PTR [ebx+16], 31153 ; 000079b1H\r
1084   0001a 75 58            jne     SHORT $LN5@gzflush\r
1085   0001c 83 7b 5c 00      cmp     DWORD PTR [ebx+92], 0\r
1086   00020 75 52            jne     SHORT $LN5@gzflush\r
1087 \r
1088 ; 466  : \r
1089 ; 467  :     /* check flush parameter */\r
1090 ; 468  :     if (flush < 0 || flush > Z_FINISH)\r
1091 \r
1092   00022 56               push    esi\r
1093   00023 8b 75 0c         mov     esi, DWORD PTR _flush$[ebp]\r
1094   00026 83 fe 04         cmp     esi, 4\r
1095   00029 77 3e            ja      SHORT $LN3@gzflush\r
1096 \r
1097 ; 470  : \r
1098 ; 471  :     /* check for seek request */\r
1099 ; 472  :     if (state->seek) {\r
1100 \r
1101   0002b 83 7b 58 00      cmp     DWORD PTR [ebx+88], 0\r
1102   0002f 74 26            je      SHORT $LN1@gzflush\r
1103 \r
1104 ; 473  :         state->seek = 0;\r
1105 ; 474  :         if (gz_zero(state, state->skip) == -1)\r
1106 \r
1107   00031 8b 43 54         mov     eax, DWORD PTR [ebx+84]\r
1108   00034 8b 4b 50         mov     ecx, DWORD PTR [ebx+80]\r
1109   00037 50               push    eax\r
1110   00038 51               push    ecx\r
1111   00039 8b c3            mov     eax, ebx\r
1112   0003b c7 43 58 00 00\r
1113         00 00            mov     DWORD PTR [ebx+88], 0\r
1114   00042 e8 00 00 00 00   call    _gz_zero\r
1115   00047 83 c4 08         add     esp, 8\r
1116   0004a 83 f8 ff         cmp     eax, -1\r
1117   0004d 75 08            jne     SHORT $LN1@gzflush\r
1118 \r
1119 ; 475  :             return -1;\r
1120 \r
1121   0004f 5e               pop     esi\r
1122   00050 0b c0            or      eax, eax\r
1123   00052 5b               pop     ebx\r
1124 \r
1125 ; 481  : }\r
1126 \r
1127   00053 5d               pop     ebp\r
1128   00054 c2 08 00         ret     8\r
1129 $LN1@gzflush:\r
1130 \r
1131 ; 476  :     }\r
1132 ; 477  : \r
1133 ; 478  :     /* compress remaining data with requested flush */\r
1134 ; 479  :     gz_comp(state, flush);\r
1135 \r
1136   00057 56               push    esi\r
1137   00058 e8 00 00 00 00   call    _gz_comp\r
1138 \r
1139 ; 480  :     return state->err;\r
1140 \r
1141   0005d 8b 43 5c         mov     eax, DWORD PTR [ebx+92]\r
1142   00060 83 c4 04         add     esp, 4\r
1143   00063 5e               pop     esi\r
1144   00064 5b               pop     ebx\r
1145 \r
1146 ; 481  : }\r
1147 \r
1148   00065 5d               pop     ebp\r
1149   00066 c2 08 00         ret     8\r
1150 $LN3@gzflush:\r
1151   00069 5e               pop     esi\r
1152 \r
1153 ; 469  :         return Z_STREAM_ERROR;\r
1154 \r
1155   0006a b8 fe ff ff ff   mov     eax, -2                        ; fffffffeH\r
1156   0006f 5b               pop     ebx\r
1157 \r
1158 ; 481  : }\r
1159 \r
1160   00070 5d               pop     ebp\r
1161   00071 c2 08 00         ret     8\r
1162 $LN5@gzflush:\r
1163 \r
1164 ; 465  :         return Z_STREAM_ERROR;\r
1165 \r
1166   00074 b8 fe ff ff ff   mov     eax, -2                        ; fffffffeH\r
1167   00079 5b               pop     ebx\r
1168 \r
1169 ; 481  : }\r
1170 \r
1171   0007a 5d               pop     ebp\r
1172   0007b c2 08 00         ret     8\r
1173 _gzflush@8 ENDP\r
1174 _TEXT   ENDS\r
1175 PUBLIC  _gzprintf\r
1176 ; Function compile flags: /Ogtp\r
1177 ;       COMDAT _gzprintf\r
1178 _TEXT   SEGMENT\r
1179 _file$ = 8                                              ; size = 4\r
1180 _format$ = 12                                           ; size = 4\r
1181 _gzprintf PROC                                          ; COMDAT\r
1182 \r
1183 ; 304  : {\r
1184 \r
1185   00000 55               push    ebp\r
1186   00001 8b ec            mov     ebp, esp\r
1187   00003 56               push    esi\r
1188 \r
1189 ; 305  :     int size, len;\r
1190 ; 306  :     gz_statep state;\r
1191 ; 307  :     z_streamp strm;\r
1192 ; 308  :     va_list va;\r
1193 ; 309  : \r
1194 ; 310  :     /* get internal structure */\r
1195 ; 311  :     if (file == NULL)\r
1196 \r
1197   00004 8b 75 08         mov     esi, DWORD PTR _file$[ebp]\r
1198   00007 85 f6            test    esi, esi\r
1199   00009 75 06            jne     SHORT $LN9@gzprintf\r
1200 \r
1201 ; 312  :         return -1;\r
1202 \r
1203   0000b 83 c8 ff         or      eax, -1\r
1204   0000e 5e               pop     esi\r
1205 \r
1206 ; 369  : }\r
1207 \r
1208   0000f 5d               pop     ebp\r
1209   00010 c3               ret     0\r
1210 $LN9@gzprintf:\r
1211 \r
1212 ; 313  :     state = (gz_statep)file;\r
1213 ; 314  :     strm = &(state->strm);\r
1214 ; 315  : \r
1215 ; 316  :     /* check that we're writing and that there's no error */\r
1216 ; 317  :     if (state->mode != GZ_WRITE || state->err != Z_OK)\r
1217 \r
1218   00011 81 7e 10 b1 79\r
1219         00 00            cmp     DWORD PTR [esi+16], 31153 ; 000079b1H\r
1220   00018 75 16            jne     SHORT $LN14@gzprintf\r
1221   0001a 83 7e 5c 00      cmp     DWORD PTR [esi+92], 0\r
1222   0001e 75 10            jne     SHORT $LN14@gzprintf\r
1223 \r
1224 ; 318  :         return 0;\r
1225 ; 319  : \r
1226 ; 320  :     /* make sure we have some buffer space */\r
1227 ; 321  :     if (state->size == 0 && gz_init(state) == -1)\r
1228 \r
1229   00020 83 7e 1c 00      cmp     DWORD PTR [esi+28], 0\r
1230   00024 75 0f            jne     SHORT $LN6@gzprintf\r
1231   00026 e8 00 00 00 00   call    _gz_init\r
1232   0002b 83 f8 ff         cmp     eax, -1\r
1233   0002e 75 05            jne     SHORT $LN6@gzprintf\r
1234 $LN14@gzprintf:\r
1235 \r
1236 ; 322  :         return 0;\r
1237 \r
1238   00030 33 c0            xor     eax, eax\r
1239   00032 5e               pop     esi\r
1240 \r
1241 ; 369  : }\r
1242 \r
1243   00033 5d               pop     ebp\r
1244   00034 c3               ret     0\r
1245 $LN6@gzprintf:\r
1246 \r
1247 ; 323  : \r
1248 ; 324  :     /* check for seek request */\r
1249 ; 325  :     if (state->seek) {\r
1250 \r
1251   00035 83 7e 58 00      cmp     DWORD PTR [esi+88], 0\r
1252   00039 74 1e            je      SHORT $LN4@gzprintf\r
1253 \r
1254 ; 326  :         state->seek = 0;\r
1255 ; 327  :         if (gz_zero(state, state->skip) == -1)\r
1256 \r
1257   0003b 8b 46 54         mov     eax, DWORD PTR [esi+84]\r
1258   0003e 8b 4e 50         mov     ecx, DWORD PTR [esi+80]\r
1259   00041 50               push    eax\r
1260   00042 51               push    ecx\r
1261   00043 8b c6            mov     eax, esi\r
1262   00045 c7 46 58 00 00\r
1263         00 00            mov     DWORD PTR [esi+88], 0\r
1264   0004c e8 00 00 00 00   call    _gz_zero\r
1265   00051 83 c4 08         add     esp, 8\r
1266   00054 83 f8 ff         cmp     eax, -1\r
1267 \r
1268 ; 328  :             return 0;\r
1269 \r
1270   00057 74 d7            je      SHORT $LN14@gzprintf\r
1271 $LN4@gzprintf:\r
1272 \r
1273 ; 329  :     }\r
1274 ; 330  : \r
1275 ; 331  :     /* consume whatever's left in the input buffer */\r
1276 ; 332  :     if (strm->avail_in && gz_comp(state, Z_NO_FLUSH) == -1)\r
1277 \r
1278   00059 83 7e 68 00      cmp     DWORD PTR [esi+104], 0\r
1279   0005d 74 13            je      SHORT $LN12@gzprintf\r
1280   0005f 53               push    ebx\r
1281   00060 6a 00            push    0\r
1282   00062 8b de            mov     ebx, esi\r
1283   00064 e8 00 00 00 00   call    _gz_comp\r
1284   00069 83 c4 04         add     esp, 4\r
1285   0006c 5b               pop     ebx\r
1286   0006d 83 f8 ff         cmp     eax, -1\r
1287 \r
1288 ; 333  :         return 0;\r
1289 \r
1290   00070 74 be            je      SHORT $LN14@gzprintf\r
1291 $LN12@gzprintf:\r
1292 \r
1293 ; 334  : \r
1294 ; 335  :     /* do the printf() into the input buffer, put length in len */\r
1295 ; 336  :     size = (int)(state->size);\r
1296 ; 337  :     state->in[size - 1] = 0;\r
1297 \r
1298   00072 8b 56 24         mov     edx, DWORD PTR [esi+36]\r
1299   00075 57               push    edi\r
1300   00076 8b 7e 1c         mov     edi, DWORD PTR [esi+28]\r
1301   00079 c6 44 17 ff 00   mov     BYTE PTR [edi+edx-1], 0\r
1302 \r
1303 ; 338  :     va_start(va, format);\r
1304 ; 339  : #ifdef NO_vsnprintf\r
1305 ; 340  : #  ifdef HAS_vsprintf_void\r
1306 ; 341  :     (void)vsprintf(state->in, format, va);\r
1307 ; 342  :     va_end(va);\r
1308 ; 343  :     for (len = 0; len < size; len++)\r
1309 ; 344  :         if (state->in[len] == 0) break;\r
1310 ; 345  : #  else\r
1311 ; 346  :     len = vsprintf(state->in, format, va);\r
1312 ; 347  :     va_end(va);\r
1313 ; 348  : #  endif\r
1314 ; 349  : #else\r
1315 ; 350  : #  ifdef HAS_vsnprintf_void\r
1316 ; 351  :     (void)vsnprintf(state->in, size, format, va);\r
1317 ; 352  :     va_end(va);\r
1318 ; 353  :     len = strlen(state->in);\r
1319 ; 354  : #  else\r
1320 ; 355  :     len = vsnprintf((char *)(state->in), size, format, va);\r
1321 \r
1322   0007e 8b 4d 0c         mov     ecx, DWORD PTR _format$[ebp]\r
1323   00081 8b 56 24         mov     edx, DWORD PTR [esi+36]\r
1324   00084 8d 45 10         lea     eax, DWORD PTR _format$[ebp+4]\r
1325   00087 50               push    eax\r
1326   00088 51               push    ecx\r
1327   00089 57               push    edi\r
1328   0008a 52               push    edx\r
1329   0008b ff 15 00 00 00\r
1330         00               call    DWORD PTR __imp__vsnprintf\r
1331   00091 8b c8            mov     ecx, eax\r
1332   00093 83 c4 10         add     esp, 16                        ; 00000010H\r
1333 \r
1334 ; 356  :     va_end(va);\r
1335 ; 357  : #  endif\r
1336 ; 358  : #endif\r
1337 ; 359  : \r
1338 ; 360  :     /* check that printf() results fit in buffer */\r
1339 ; 361  :     if (len <= 0 || len >= (int)size || state->in[size - 1] != 0)\r
1340 \r
1341   00096 85 c9            test    ecx, ecx\r
1342   00098 7e 26            jle     SHORT $LN1@gzprintf\r
1343   0009a 3b cf            cmp     ecx, edi\r
1344   0009c 7d 22            jge     SHORT $LN1@gzprintf\r
1345   0009e 8b 46 24         mov     eax, DWORD PTR [esi+36]\r
1346   000a1 80 7c 07 ff 00   cmp     BYTE PTR [edi+eax-1], 0\r
1347   000a6 75 18            jne     SHORT $LN1@gzprintf\r
1348 \r
1349 ; 363  : \r
1350 ; 364  :     /* update buffer and position, defer compression until needed */\r
1351 ; 365  :     strm->avail_in = (unsigned)len;\r
1352 \r
1353   000a8 89 4e 68         mov     DWORD PTR [esi+104], ecx\r
1354 \r
1355 ; 366  :     strm->next_in = state->in;\r
1356 \r
1357   000ab 8b 56 24         mov     edx, DWORD PTR [esi+36]\r
1358   000ae 89 56 64         mov     DWORD PTR [esi+100], edx\r
1359 \r
1360 ; 367  :     state->x.pos += len;\r
1361 \r
1362   000b1 8b c1            mov     eax, ecx\r
1363   000b3 99               cdq\r
1364   000b4 01 46 08         add     DWORD PTR [esi+8], eax\r
1365   000b7 5f               pop     edi\r
1366 \r
1367 ; 368  :     return len;\r
1368 \r
1369   000b8 8b c1            mov     eax, ecx\r
1370   000ba 11 56 0c         adc     DWORD PTR [esi+12], edx\r
1371   000bd 5e               pop     esi\r
1372 \r
1373 ; 369  : }\r
1374 \r
1375   000be 5d               pop     ebp\r
1376   000bf c3               ret     0\r
1377 $LN1@gzprintf:\r
1378   000c0 5f               pop     edi\r
1379 \r
1380 ; 362  :         return 0;\r
1381 \r
1382   000c1 33 c0            xor     eax, eax\r
1383   000c3 5e               pop     esi\r
1384 \r
1385 ; 369  : }\r
1386 \r
1387   000c4 5d               pop     ebp\r
1388   000c5 c3               ret     0\r
1389 _gzprintf ENDP\r
1390 _TEXT   ENDS\r
1391 PUBLIC  _gzwrite@12\r
1392 ; Function compile flags: /Ogtp\r
1393 ;       COMDAT _gzwrite@12\r
1394 _TEXT   SEGMENT\r
1395 _file$ = 8                                              ; size = 4\r
1396 _buf$ = 12                                              ; size = 4\r
1397 _put$ = 16                                              ; size = 4\r
1398 _len$ = 16                                              ; size = 4\r
1399 _gzwrite@12 PROC                                        ; COMDAT\r
1400 \r
1401 ; 169  : {\r
1402 \r
1403   00000 55               push    ebp\r
1404   00001 8b ec            mov     ebp, esp\r
1405   00003 53               push    ebx\r
1406 \r
1407 ; 170  :     unsigned put = len;\r
1408 ; 171  :     unsigned n;\r
1409 ; 172  :     gz_statep state;\r
1410 ; 173  :     z_streamp strm;\r
1411 ; 174  : \r
1412 ; 175  :     /* get internal structure */\r
1413 ; 176  :     if (file == NULL)\r
1414 \r
1415   00004 8b 5d 08         mov     ebx, DWORD PTR _file$[ebp]\r
1416   00007 57               push    edi\r
1417   00008 8b 7d 10         mov     edi, DWORD PTR _len$[ebp]\r
1418   0000b 89 7d 10         mov     DWORD PTR _put$[ebp], edi\r
1419   0000e 85 db            test    ebx, ebx\r
1420 \r
1421 ; 177  :         return 0;\r
1422 \r
1423   00010 74 27            je      SHORT $LN32@gzwrite\r
1424 \r
1425 ; 178  :     state = (gz_statep)file;\r
1426 ; 179  :     strm = &(state->strm);\r
1427 ; 180  : \r
1428 ; 181  :     /* check that we're writing and that there's no error */\r
1429 ; 182  :     if (state->mode != GZ_WRITE || state->err != Z_OK)\r
1430 \r
1431   00012 81 7b 10 b1 79\r
1432         00 00            cmp     DWORD PTR [ebx+16], 31153 ; 000079b1H\r
1433   00019 75 1e            jne     SHORT $LN32@gzwrite\r
1434   0001b 83 7b 5c 00      cmp     DWORD PTR [ebx+92], 0\r
1435   0001f 75 18            jne     SHORT $LN32@gzwrite\r
1436 \r
1437 ; 183  :         return 0;\r
1438 ; 184  : \r
1439 ; 185  :     /* since an int is returned, make sure len fits in one, otherwise return\r
1440 ; 186  :        with an error (this avoids the flaw in the interface) */\r
1441 ; 187  :     if ((int)len < 0) {\r
1442 \r
1443   00021 85 ff            test    edi, edi\r
1444   00023 79 1c            jns     SHORT $LN30@gzwrite\r
1445 \r
1446 ; 188  :         gz_error(state, Z_DATA_ERROR, "requested length does not fit in int");\r
1447 \r
1448   00025 68 00 00 00 00   push    OFFSET ??_C@_0CF@MLPJFDMM@requested?5length?5does?5not?5fit?5in@\r
1449   0002a b8 fd ff ff ff   mov     eax, -3                        ; fffffffdH\r
1450   0002f 8b cb            mov     ecx, ebx\r
1451   00031 e8 00 00 00 00   call    _gz_error\r
1452   00036 83 c4 04         add     esp, 4\r
1453 $LN32@gzwrite:\r
1454 \r
1455 ; 189  :         return 0;\r
1456 \r
1457   00039 5f               pop     edi\r
1458   0003a 33 c0            xor     eax, eax\r
1459   0003c 5b               pop     ebx\r
1460 \r
1461 ; 240  : }\r
1462 \r
1463   0003d 5d               pop     ebp\r
1464   0003e c2 0c 00         ret     12                     ; 0000000cH\r
1465 $LN30@gzwrite:\r
1466 \r
1467 ; 190  :     }\r
1468 ; 191  : \r
1469 ; 192  :     /* if len is zero, avoid unnecessary operations */\r
1470 ; 193  :     if (len == 0)\r
1471 ; 194  :         return 0;\r
1472 \r
1473   00041 74 f6            je      SHORT $LN32@gzwrite\r
1474 \r
1475 ; 195  : \r
1476 ; 196  :     /* allocate memory if this is the first time through */\r
1477 ; 197  :     if (state->size == 0 && gz_init(state) == -1)\r
1478 \r
1479   00043 83 7b 1c 00      cmp     DWORD PTR [ebx+28], 0\r
1480   00047 56               push    esi\r
1481   00048 75 0c            jne     SHORT $LN24@gzwrite\r
1482   0004a 8b f3            mov     esi, ebx\r
1483   0004c e8 00 00 00 00   call    _gz_init\r
1484   00051 83 f8 ff         cmp     eax, -1\r
1485 \r
1486 ; 198  :         return 0;\r
1487 \r
1488   00054 74 75            je      SHORT $LN31@gzwrite\r
1489 $LN24@gzwrite:\r
1490 \r
1491 ; 199  : \r
1492 ; 200  :     /* check for seek request */\r
1493 ; 201  :     if (state->seek) {\r
1494 \r
1495   00056 33 f6            xor     esi, esi\r
1496   00058 39 73 58         cmp     DWORD PTR [ebx+88], esi\r
1497   0005b 74 1a            je      SHORT $LN28@gzwrite\r
1498 \r
1499 ; 202  :         state->seek = 0;\r
1500 ; 203  :         if (gz_zero(state, state->skip) == -1)\r
1501 \r
1502   0005d 8b 43 54         mov     eax, DWORD PTR [ebx+84]\r
1503   00060 8b 4b 50         mov     ecx, DWORD PTR [ebx+80]\r
1504   00063 50               push    eax\r
1505   00064 51               push    ecx\r
1506   00065 8b c3            mov     eax, ebx\r
1507   00067 89 73 58         mov     DWORD PTR [ebx+88], esi\r
1508   0006a e8 00 00 00 00   call    _gz_zero\r
1509   0006f 83 c4 08         add     esp, 8\r
1510   00072 83 f8 ff         cmp     eax, -1\r
1511 \r
1512 ; 204  :             return 0;\r
1513 \r
1514   00075 74 54            je      SHORT $LN31@gzwrite\r
1515 $LN28@gzwrite:\r
1516 \r
1517 ; 205  :     }\r
1518 ; 206  : \r
1519 ; 207  :     /* for small len, copy to input buffer, otherwise compress directly */\r
1520 ; 208  :     if (len < state->size) {\r
1521 \r
1522   00077 3b 7b 1c         cmp     edi, DWORD PTR [ebx+28]\r
1523   0007a 73 58            jae     SHORT $LN10@gzwrite\r
1524   0007c 8d 64 24 00      npad    4\r
1525 $LL9@gzwrite:\r
1526 \r
1527 ; 209  :         /* copy to input buffer, compress when full */\r
1528 ; 210  :         do {\r
1529 ; 211  :             if (strm->avail_in == 0)\r
1530 \r
1531   00080 8b 43 68         mov     eax, DWORD PTR [ebx+104]\r
1532   00083 85 c0            test    eax, eax\r
1533   00085 75 06            jne     SHORT $LN6@gzwrite\r
1534 \r
1535 ; 212  :                 strm->next_in = state->in;\r
1536 \r
1537   00087 8b 53 24         mov     edx, DWORD PTR [ebx+36]\r
1538   0008a 89 53 64         mov     DWORD PTR [ebx+100], edx\r
1539 $LN6@gzwrite:\r
1540 \r
1541 ; 213  :             n = state->size - strm->avail_in;\r
1542 \r
1543   0008d 8b 73 1c         mov     esi, DWORD PTR [ebx+28]\r
1544   00090 2b f0            sub     esi, eax\r
1545 \r
1546 ; 214  :             if (n > len)\r
1547 \r
1548   00092 3b f7            cmp     esi, edi\r
1549   00094 76 02            jbe     SHORT $LN5@gzwrite\r
1550 \r
1551 ; 215  :                 n = len;\r
1552 \r
1553   00096 8b f7            mov     esi, edi\r
1554 $LN5@gzwrite:\r
1555 \r
1556 ; 216  :             memcpy(strm->next_in + strm->avail_in, buf, n);\r
1557 \r
1558   00098 8b 4d 0c         mov     ecx, DWORD PTR _buf$[ebp]\r
1559   0009b 8b 53 64         mov     edx, DWORD PTR [ebx+100]\r
1560   0009e 56               push    esi\r
1561   0009f 51               push    ecx\r
1562   000a0 03 d0            add     edx, eax\r
1563   000a2 52               push    edx\r
1564   000a3 e8 00 00 00 00   call    _memcpy\r
1565 \r
1566 ; 217  :             strm->avail_in += n;\r
1567 \r
1568   000a8 01 73 68         add     DWORD PTR [ebx+104], esi\r
1569   000ab 83 c4 0c         add     esp, 12                        ; 0000000cH\r
1570 \r
1571 ; 218  :             state->x.pos += n;\r
1572 \r
1573   000ae 01 73 08         add     DWORD PTR [ebx+8], esi\r
1574   000b1 83 53 0c 00      adc     DWORD PTR [ebx+12], 0\r
1575 \r
1576 ; 219  :             buf = (char *)buf + n;\r
1577 \r
1578   000b5 01 75 0c         add     DWORD PTR _buf$[ebp], esi\r
1579 \r
1580 ; 220  :             len -= n;\r
1581 \r
1582   000b8 2b fe            sub     edi, esi\r
1583 \r
1584 ; 221  :             if (len && gz_comp(state, Z_NO_FLUSH) == -1)\r
1585 \r
1586   000ba 74 48            je      SHORT $LN27@gzwrite\r
1587   000bc 6a 00            push    0\r
1588   000be e8 00 00 00 00   call    _gz_comp\r
1589   000c3 83 c4 04         add     esp, 4\r
1590   000c6 83 f8 ff         cmp     eax, -1\r
1591   000c9 75 b5            jne     SHORT $LL9@gzwrite\r
1592 $LN31@gzwrite:\r
1593   000cb 5e               pop     esi\r
1594   000cc 5f               pop     edi\r
1595 \r
1596 ; 222  :                 return 0;\r
1597 \r
1598   000cd 33 c0            xor     eax, eax\r
1599   000cf 5b               pop     ebx\r
1600 \r
1601 ; 240  : }\r
1602 \r
1603   000d0 5d               pop     ebp\r
1604   000d1 c2 0c 00         ret     12                     ; 0000000cH\r
1605 $LN10@gzwrite:\r
1606 \r
1607 ; 223  :         } while (len);\r
1608 ; 224  :     }\r
1609 ; 225  :     else {\r
1610 ; 226  :         /* consume whatever's left in the input buffer */\r
1611 ; 227  :         if (strm->avail_in && gz_comp(state, Z_NO_FLUSH) == -1)\r
1612 \r
1613   000d4 39 73 68         cmp     DWORD PTR [ebx+104], esi\r
1614   000d7 74 0e            je      SHORT $LN2@gzwrite\r
1615   000d9 56               push    esi\r
1616   000da e8 00 00 00 00   call    _gz_comp\r
1617   000df 83 c4 04         add     esp, 4\r
1618   000e2 83 f8 ff         cmp     eax, -1\r
1619 \r
1620 ; 228  :             return 0;\r
1621 \r
1622   000e5 74 e4            je      SHORT $LN31@gzwrite\r
1623 $LN2@gzwrite:\r
1624 \r
1625 ; 229  : \r
1626 ; 230  :         /* directly compress user buffer to file */\r
1627 ; 231  :         strm->avail_in = len;\r
1628 ; 232  :         strm->next_in = (voidp)buf;\r
1629 \r
1630   000e7 8b 45 0c         mov     eax, DWORD PTR _buf$[ebp]\r
1631   000ea 89 7b 68         mov     DWORD PTR [ebx+104], edi\r
1632   000ed 89 43 64         mov     DWORD PTR [ebx+100], eax\r
1633 \r
1634 ; 233  :         state->x.pos += len;\r
1635 \r
1636   000f0 01 7b 08         add     DWORD PTR [ebx+8], edi\r
1637 \r
1638 ; 234  :         if (gz_comp(state, Z_NO_FLUSH) == -1)\r
1639 \r
1640   000f3 56               push    esi\r
1641   000f4 11 73 0c         adc     DWORD PTR [ebx+12], esi\r
1642   000f7 e8 00 00 00 00   call    _gz_comp\r
1643   000fc 83 c4 04         add     esp, 4\r
1644   000ff 83 f8 ff         cmp     eax, -1\r
1645 \r
1646 ; 235  :             return 0;\r
1647 \r
1648   00102 74 c7            je      SHORT $LN31@gzwrite\r
1649 $LN27@gzwrite:\r
1650 \r
1651 ; 236  :     }\r
1652 ; 237  : \r
1653 ; 238  :     /* input was all buffered or compressed (put will fit in int) */\r
1654 ; 239  :     return (int)put;\r
1655 \r
1656   00104 8b 45 10         mov     eax, DWORD PTR _put$[ebp]\r
1657   00107 5e               pop     esi\r
1658   00108 5f               pop     edi\r
1659   00109 5b               pop     ebx\r
1660 \r
1661 ; 240  : }\r
1662 \r
1663   0010a 5d               pop     ebp\r
1664   0010b c2 0c 00         ret     12                     ; 0000000cH\r
1665 _gzwrite@12 ENDP\r
1666 PUBLIC  _gzputs@8\r
1667 ; Function compile flags: /Ogtp\r
1668 ;       COMDAT _gzputs@8\r
1669 _TEXT   SEGMENT\r
1670 _file$ = 8                                              ; size = 4\r
1671 _str$ = 12                                              ; size = 4\r
1672 _gzputs@8 PROC                                          ; COMDAT\r
1673 \r
1674 ; 289  : {\r
1675 \r
1676   00000 55               push    ebp\r
1677   00001 8b ec            mov     ebp, esp\r
1678 \r
1679 ; 290  :     int ret;\r
1680 ; 291  :     unsigned len;\r
1681 ; 292  : \r
1682 ; 293  :     /* write string */\r
1683 ; 294  :     len = (unsigned)strlen(str);\r
1684 \r
1685   00003 8b 55 0c         mov     edx, DWORD PTR _str$[ebp]\r
1686   00006 8b c2            mov     eax, edx\r
1687   00008 56               push    esi\r
1688   00009 8d 70 01         lea     esi, DWORD PTR [eax+1]\r
1689   0000c 8d 64 24 00      npad    4\r
1690 $LL5@gzputs:\r
1691   00010 8a 08            mov     cl, BYTE PTR [eax]\r
1692   00012 40               inc     eax\r
1693   00013 84 c9            test    cl, cl\r
1694   00015 75 f9            jne     SHORT $LL5@gzputs\r
1695   00017 2b c6            sub     eax, esi\r
1696   00019 8b f0            mov     esi, eax\r
1697 \r
1698 ; 295  :     ret = gzwrite(file, str, len);\r
1699 \r
1700   0001b 8b 45 08         mov     eax, DWORD PTR _file$[ebp]\r
1701   0001e 56               push    esi\r
1702   0001f 52               push    edx\r
1703   00020 50               push    eax\r
1704   00021 e8 00 00 00 00   call    _gzwrite@12\r
1705 \r
1706 ; 296  :     return ret == 0 && len != 0 ? -1 : ret;\r
1707 \r
1708   00026 85 c0            test    eax, eax\r
1709   00028 75 07            jne     SHORT $LN4@gzputs\r
1710   0002a 85 f6            test    esi, esi\r
1711   0002c 74 03            je      SHORT $LN4@gzputs\r
1712   0002e 83 c8 ff         or      eax, -1\r
1713 $LN4@gzputs:\r
1714   00031 5e               pop     esi\r
1715 \r
1716 ; 297  : }\r
1717 \r
1718   00032 5d               pop     ebp\r
1719   00033 c2 08 00         ret     8\r
1720 _gzputs@8 ENDP\r
1721 _TEXT   ENDS\r
1722 PUBLIC  _gzputc@8\r
1723 ; Function compile flags: /Ogtp\r
1724 ;       COMDAT _gzputc@8\r
1725 _TEXT   SEGMENT\r
1726 _file$ = 8                                              ; size = 4\r
1727 _buf$ = 11                                              ; size = 1\r
1728 _c$ = 12                                                ; size = 4\r
1729 _gzputc@8 PROC                                          ; COMDAT\r
1730 \r
1731 ; 246  : {\r
1732 \r
1733   00000 55               push    ebp\r
1734   00001 8b ec            mov     ebp, esp\r
1735   00003 56               push    esi\r
1736 \r
1737 ; 247  :     unsigned char buf[1];\r
1738 ; 248  :     gz_statep state;\r
1739 ; 249  :     z_streamp strm;\r
1740 ; 250  : \r
1741 ; 251  :     /* get internal structure */\r
1742 ; 252  :     if (file == NULL)\r
1743 \r
1744   00004 8b 75 08         mov     esi, DWORD PTR _file$[ebp]\r
1745   00007 85 f6            test    esi, esi\r
1746   00009 75 08            jne     SHORT $LN8@gzputc\r
1747 $LN12@gzputc:\r
1748 \r
1749 ; 253  :         return -1;\r
1750 \r
1751   0000b 83 c8 ff         or      eax, -1\r
1752   0000e 5e               pop     esi\r
1753 \r
1754 ; 283  : }\r
1755 \r
1756   0000f 5d               pop     ebp\r
1757   00010 c2 08 00         ret     8\r
1758 $LN8@gzputc:\r
1759 \r
1760 ; 254  :     state = (gz_statep)file;\r
1761 ; 255  :     strm = &(state->strm);\r
1762 ; 256  : \r
1763 ; 257  :     /* check that we're writing and that there's no error */\r
1764 ; 258  :     if (state->mode != GZ_WRITE || state->err != Z_OK)\r
1765 \r
1766   00013 81 7e 10 b1 79\r
1767         00 00            cmp     DWORD PTR [esi+16], 31153 ; 000079b1H\r
1768   0001a 75 ef            jne     SHORT $LN12@gzputc\r
1769   0001c 83 7e 5c 00      cmp     DWORD PTR [esi+92], 0\r
1770   00020 75 e9            jne     SHORT $LN12@gzputc\r
1771 \r
1772 ; 259  :         return -1;\r
1773 ; 260  : \r
1774 ; 261  :     /* check for seek request */\r
1775 ; 262  :     if (state->seek) {\r
1776 \r
1777   00022 83 7e 58 00      cmp     DWORD PTR [esi+88], 0\r
1778   00026 74 1e            je      SHORT $LN4@gzputc\r
1779 \r
1780 ; 263  :         state->seek = 0;\r
1781 ; 264  :         if (gz_zero(state, state->skip) == -1)\r
1782 \r
1783   00028 8b 46 54         mov     eax, DWORD PTR [esi+84]\r
1784   0002b 8b 4e 50         mov     ecx, DWORD PTR [esi+80]\r
1785   0002e 50               push    eax\r
1786   0002f 51               push    ecx\r
1787   00030 8b c6            mov     eax, esi\r
1788   00032 c7 46 58 00 00\r
1789         00 00            mov     DWORD PTR [esi+88], 0\r
1790   00039 e8 00 00 00 00   call    _gz_zero\r
1791   0003e 83 c4 08         add     esp, 8\r
1792   00041 83 f8 ff         cmp     eax, -1\r
1793 \r
1794 ; 265  :             return -1;\r
1795 \r
1796   00044 74 c5            je      SHORT $LN12@gzputc\r
1797 $LN4@gzputc:\r
1798 \r
1799 ; 266  :     }\r
1800 ; 267  : \r
1801 ; 268  :     /* try writing to input buffer for speed (state->size == 0 if buffer not\r
1802 ; 269  :        initialized) */\r
1803 ; 270  :     if (strm->avail_in < state->size) {\r
1804 \r
1805   00046 8b 4e 68         mov     ecx, DWORD PTR [esi+104]\r
1806   00049 3b 4e 1c         cmp     ecx, DWORD PTR [esi+28]\r
1807   0004c 73 2c            jae     SHORT $LN3@gzputc\r
1808 \r
1809 ; 271  :         if (strm->avail_in == 0)\r
1810 \r
1811   0004e 85 c9            test    ecx, ecx\r
1812   00050 75 06            jne     SHORT $LN2@gzputc\r
1813 \r
1814 ; 272  :             strm->next_in = state->in;\r
1815 \r
1816   00052 8b 56 24         mov     edx, DWORD PTR [esi+36]\r
1817   00055 89 56 64         mov     DWORD PTR [esi+100], edx\r
1818 $LN2@gzputc:\r
1819 \r
1820 ; 273  :         strm->next_in[strm->avail_in++] = c;\r
1821 \r
1822   00058 8b 56 64         mov     edx, DWORD PTR [esi+100]\r
1823   0005b 8b 45 0c         mov     eax, DWORD PTR _c$[ebp]\r
1824   0005e 88 04 11         mov     BYTE PTR [ecx+edx], al\r
1825   00061 b9 01 00 00 00   mov     ecx, 1\r
1826   00066 01 4e 68         add     DWORD PTR [esi+104], ecx\r
1827 \r
1828 ; 274  :         state->x.pos++;\r
1829 \r
1830   00069 01 4e 08         add     DWORD PTR [esi+8], ecx\r
1831   0006c 83 56 0c 00      adc     DWORD PTR [esi+12], 0\r
1832 \r
1833 ; 275  :         return c & 0xff;\r
1834 \r
1835   00070 25 ff 00 00 00   and     eax, 255               ; 000000ffH\r
1836   00075 5e               pop     esi\r
1837 \r
1838 ; 283  : }\r
1839 \r
1840   00076 5d               pop     ebp\r
1841   00077 c2 08 00         ret     8\r
1842 $LN3@gzputc:\r
1843   0007a 53               push    ebx\r
1844 \r
1845 ; 276  :     }\r
1846 ; 277  : \r
1847 ; 278  :     /* no room in buffer or not initialized, use gz_write() */\r
1848 ; 279  :     buf[0] = c;\r
1849 \r
1850   0007b 8b 5d 0c         mov     ebx, DWORD PTR _c$[ebp]\r
1851 \r
1852 ; 280  :     if (gzwrite(file, buf, 1) != 1)\r
1853 \r
1854   0007e 6a 01            push    1\r
1855   00080 8d 45 0b         lea     eax, DWORD PTR _buf$[ebp]\r
1856   00083 50               push    eax\r
1857   00084 56               push    esi\r
1858   00085 88 5d 0b         mov     BYTE PTR _buf$[ebp], bl\r
1859   00088 e8 00 00 00 00   call    _gzwrite@12\r
1860   0008d 83 f8 01         cmp     eax, 1\r
1861   00090 74 09            je      SHORT $LN1@gzputc\r
1862 \r
1863 ; 281  :         return -1;\r
1864 \r
1865   00092 5b               pop     ebx\r
1866   00093 83 c8 ff         or      eax, -1\r
1867   00096 5e               pop     esi\r
1868 \r
1869 ; 283  : }\r
1870 \r
1871   00097 5d               pop     ebp\r
1872   00098 c2 08 00         ret     8\r
1873 $LN1@gzputc:\r
1874 \r
1875 ; 282  :     return c & 0xff;\r
1876 \r
1877   0009b 8b c3            mov     eax, ebx\r
1878   0009d 5b               pop     ebx\r
1879   0009e 25 ff 00 00 00   and     eax, 255               ; 000000ffH\r
1880   000a3 5e               pop     esi\r
1881 \r
1882 ; 283  : }\r
1883 \r
1884   000a4 5d               pop     ebp\r
1885   000a5 c2 08 00         ret     8\r
1886 _gzputc@8 ENDP\r
1887 END\r