src/zlib/inflate.c

20  * - Unroll direct copy to three copies per loop in inffast.c
37  * - Make MATCH copy in inflate() much faster for when inflate_fast() not used
46  * - Unroll last copy for window match in inflate_fast()
383     unsigned copy, dist;
402     /* copy state->wsize or less output bytes into the circular window */
403     copy = out - strm->avail_out;
404     if (copy >= state->wsize) {
411         if (dist > copy) dist = copy;
412         zmemcpy(state->window + state->wnext, strm->next_out - copy, dist);
413         copy -= dist;
414         if (copy) {
415             zmemcpy(state->window, strm->next_out - copy, copy);
416             state->wnext = copy;
595    and there is no window currently, goto inf_leave will create one and copy
620     unsigned copy;              /* number of stored or match bytes to copy */
621     unsigned char FAR *from;    /* where to copy match bytes from */
624     unsigned len;               /* length to copy for repeats, bits to drop */
739                 copy = state->length;
740                 if (copy > have) copy = have;
741                 if (copy) {
746                                 len + copy > state->head->extra_max ?
747                                 state->head->extra_max - len : copy);
750                         state->check = crc32(state->check, next, copy);
751                     have -= copy;
752                     next += copy;
753                     state->length -= copy;
762                 copy = 0;
764                     len = (unsigned)(next[copy++]);
769                 } while (len && copy < have);
771                     state->check = crc32(state->check, next, copy);
772                 have -= copy;
773                 next += copy;
783                 copy = 0;
785                     len = (unsigned)(next[copy++]);
790                 } while (len && copy < have);
792                     state->check = crc32(state->check, next, copy);
793                 have -= copy;
794                 next += copy;
885             copy = state->length;
886             if (copy) {
887                 if (copy > have) copy = have;
888                 if (copy > left) copy = left;
889                 if (copy == 0) goto inf_leave;
890                 zmemcpy(put, next, copy);
891                 have -= copy;
892                 next += copy;
893                 left -= copy;
894                 put += copy;
895                 state->length -= copy;
961                         copy = 3 + BITS(2);
968                         copy = 3 + BITS(3);
975                         copy = 11 + BITS(7);
978                     if (state->have + copy > state->nlen + state->ndist) {
983                     while (copy--)
1129             copy = out - left;
1130             if (state->offset > copy) {         /* copy from window */
1131                 copy = state->offset - copy;
1132                 if (copy > state->whave) {
1140                     copy -= state->whave;
1141                     if (copy > state->length) copy = state->length;
1142                     if (copy > left) copy = left;
1143                     left -= copy;
1144                     state->length -= copy;
1147                     } while (--copy);
1152                 if (copy > state->wnext) {
1153                     copy -= state->wnext;
1154                     from = state->window + (state->wsize - copy);
1157                     from = state->window + (state->wnext - copy);
1158                 if (copy > state->length) copy = state->length;
1160             else {                              /* copy from output */
1162                 copy = state->length;
1164             if (copy > left) copy = left;
1165             left -= copy;
1166             state->length -= copy;
1169             } while (--copy);
1297     /* copy dictionary to window using updatewindow(), which will amend the
1432     struct inflate_state FAR *copy;
1443     copy = (struct inflate_state FAR *)
1445     if (copy == Z_NULL) return Z_MEM_ERROR;
1451             ZFREE(source, copy);
1456     /* copy state */
1458     zmemcpy((voidpf)copy, (voidpf)state, sizeof(struct inflate_state));
1461         copy->lencode = copy->codes + (state->lencode - state->codes);
1462         copy->distcode = copy->codes + (state->distcode - state->codes);
1464     copy->next = copy->codes + (state->next - state->codes);
1469     copy->window = window;
1470     dest->state = (struct internal_state FAR *)copy;