Geant4 11.1.1
Toolkit for the simulation of the passage of particles through matter
Loading...
Searching...
No Matches
Macros | Functions
infback.c File Reference
#include "zutil.h"
#include "inftrees.h"
#include "inflate.h"
#include "inffast.h"
#include "inffixed.h"

Go to the source code of this file.

Macros

#define LOAD()
 
#define RESTORE()
 
#define INITBITS()
 
#define PULL()
 
#define PULLBYTE()
 
#define NEEDBITS(n)
 
#define BITS(n)    ((unsigned)hold & ((1U << (n)) - 1))
 
#define DROPBITS(n)
 
#define BYTEBITS()
 
#define ROOM()
 

Functions

void fixedtables OF ((struct inflate_state FAR *state))
 
int ZEXPORT inflateBackInit_ (z_streamp strm, int windowBits, unsigned char FAR *window, const char *version, int stream_size)
 
void fixedtables (struct inflate_state FAR *state)
 
int ZEXPORT inflateBack (z_streamp strm, in_func in, void FAR *in_desc, out_func out, void FAR *out_desc)
 
int ZEXPORT inflateBackEnd (z_streamp strm)
 

Macro Definition Documentation

◆ BITS

#define BITS (   n)     ((unsigned)hold & ((1U << (n)) - 1))

Definition at line 190 of file infback.c.

◆ BYTEBITS

#define BYTEBITS ( )
Value:
do { \
hold >>= bits & 7; \
bits -= bits & 7; \
} while (0)

Definition at line 201 of file infback.c.

◆ DROPBITS

#define DROPBITS (   n)
Value:
do { \
hold >>= (n); \
bits -= (unsigned)(n); \
} while (0)

Definition at line 194 of file infback.c.

◆ INITBITS

#define INITBITS ( )
Value:
do { \
hold = 0; \
bits = 0; \
} while (0)

Definition at line 150 of file infback.c.

◆ LOAD

#define LOAD ( )
Value:
do { \
put = strm->next_out; \
left = strm->avail_out; \
next = strm->next_in; \
have = strm->avail_in; \
hold = state->hold; \
bits = state->bits; \
} while (0)

Definition at line 128 of file infback.c.

◆ NEEDBITS

#define NEEDBITS (   n)
Value:
do { \
while (bits < (unsigned)(n)) \
PULLBYTE(); \
} while (0)

Definition at line 183 of file infback.c.

◆ PULL

#define PULL ( )
Value:
do { \
if (have == 0) { \
have = in(in_desc, &next); \
if (have == 0) { \
next = Z_NULL; \
ret = Z_BUF_ERROR; \
goto inf_leave; \
} \
} \
} while (0)
Z_BUF_ERROR
#define Z_BUF_ERROR
Definition: zlib.h:184
Z_NULL
#define Z_NULL
Definition: zlib.h:212

Definition at line 158 of file infback.c.

◆ PULLBYTE

#define PULLBYTE ( )
Value:
do { \
PULL(); \
have--; \
hold += (unsigned long)(*next++) << bits; \
bits += 8; \
} while (0)

Definition at line 172 of file infback.c.

◆ RESTORE

#define RESTORE ( )
Value:
do { \
strm->next_out = put; \
strm->avail_out = left; \
strm->next_in = next; \
strm->avail_in = have; \
state->hold = hold; \
state->bits = bits; \
} while (0)

Definition at line 139 of file infback.c.

◆ ROOM

#define ROOM ( )
Value:
do { \
if (left == 0) { \
put = state->window; \
left = state->wsize; \
state->whave = left; \
if (out(out_desc, put, left)) { \
ret = Z_BUF_ERROR; \
goto inf_leave; \
} \
} \
} while (0)

Definition at line 210 of file infback.c.

Function Documentation

◆ fixedtables()

void fixedtables ( struct inflate_state FAR *  state)

Definition at line 82 of file infback.c.

84{
85#ifdef BUILDFIXED
86 static int virgin = 1;
87 static code *lenfix, *distfix;
88 static code fixed[544];
89
90 /* build fixed huffman tables if first call (may not be thread safe) */
91 if (virgin) {
92 unsigned sym, bits;
93 static code *next;
94
95 /* literal/length table */
96 sym = 0;
97 while (sym < 144) state->lens[sym++] = 8;
98 while (sym < 256) state->lens[sym++] = 9;
99 while (sym < 280) state->lens[sym++] = 7;
100 while (sym < 288) state->lens[sym++] = 8;
101 next = fixed;
102 lenfix = next;
103 bits = 9;
104 inflate_table(LENS, state->lens, 288, &(next), &(bits), state->work);
105
106 /* distance table */
107 sym = 0;
108 while (sym < 32) state->lens[sym++] = 5;
109 distfix = next;
110 bits = 5;
111 inflate_table(DISTS, state->lens, 32, &(next), &(bits), state->work);
112
113 /* do this just once */
114 virgin = 0;
115 }
116#else /* !BUILDFIXED */
117# include "inffixed.h"
118#endif /* BUILDFIXED */
119 state->lencode = lenfix;
120 state->lenbits = 9;
121 state->distcode = distfix;
122 state->distbits = 5;
123}
inflate_table
int ZLIB_INTERNAL inflate_table(codetype type, unsigned short FAR *lens, unsigned codes, code FAR *FAR *table, unsigned FAR *bits, unsigned short FAR *work)
Definition: inftrees.c:32
LENS
@ LENS
Definition: inftrees.h:56
DISTS
@ DISTS
Definition: inftrees.h:57
code
Definition: inftrees.h:24

Referenced by inflateBack().

◆ inflateBack()

int ZEXPORT inflateBack ( z_streamp  strm,
in_func  in,
void FAR *  in_desc,
out_func  out,
void FAR *  out_desc 
)

Definition at line 250 of file infback.c.

256{
257 struct inflate_state FAR *state;
258 z_const unsigned char FAR *next; /* next input */
259 unsigned char FAR *put; /* next output */
260 unsigned have, left; /* available input and output */
261 unsigned long hold; /* bit buffer */
262 unsigned bits; /* bits in bit buffer */
263 unsigned copy; /* number of stored or match bytes to copy */
264 unsigned char FAR *from; /* where to copy match bytes from */
265 code here; /* current decoding table entry */
266 code last; /* parent table entry */
267 unsigned len; /* length to copy for repeats, bits to drop */
268 int ret; /* return code */
269 static const unsigned short order[19] = /* permutation of code lengths */
270 {16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15};
271
272 /* Check that the strm exists and that the state was initialized */
273 if (strm == Z_NULL || strm->state == Z_NULL)
274 return Z_STREAM_ERROR;
275 state = (struct inflate_state FAR *)strm->state;
276
277 /* Reset the state */
278 strm->msg = Z_NULL;
279 state->mode = TYPE;
280 state->last = 0;
281 state->whave = 0;
282 next = strm->next_in;
283 have = next != Z_NULL ? strm->avail_in : 0;
284 hold = 0;
285 bits = 0;
286 put = state->window;
287 left = state->wsize;
288
289 /* Inflate until end of block marked as last */
290 for (;;)
291 switch (state->mode) {
292 case TYPE:
293 /* determine and dispatch block type */
294 if (state->last) {
295 BYTEBITS();
296 state->mode = DONE;
297 break;
298 }
299 NEEDBITS(3);
300 state->last = BITS(1);
301 DROPBITS(1);
302 switch (BITS(2)) {
303 case 0: /* stored block */
304 Tracev((stderr, "inflate: stored block%s\n",
305 state->last ? " (last)" : ""));
306 state->mode = STORED;
307 break;
308 case 1: /* fixed block */
309 fixedtables(state);
310 Tracev((stderr, "inflate: fixed codes block%s\n",
311 state->last ? " (last)" : ""));
312 state->mode = LEN; /* decode codes */
313 break;
314 case 2: /* dynamic block */
315 Tracev((stderr, "inflate: dynamic codes block%s\n",
316 state->last ? " (last)" : ""));
317 state->mode = TABLE;
318 break;
319 case 3:
320 strm->msg = (char *)"invalid block type";
321 state->mode = BAD;
322 }
323 DROPBITS(2);
324 break;
325
326 case STORED:
327 /* get and verify stored block length */
328 BYTEBITS(); /* go to byte boundary */
329 NEEDBITS(32);
330 if ((hold & 0xffff) != ((hold >> 16) ^ 0xffff)) {
331 strm->msg = (char *)"invalid stored block lengths";
332 state->mode = BAD;
333 break;
334 }
335 state->length = (unsigned)hold & 0xffff;
336 Tracev((stderr, "inflate: stored length %u\n",
337 state->length));
338 INITBITS();
339
340 /* copy stored block from input to output */
341 while (state->length != 0) {
342 copy = state->length;
343 PULL();
344 ROOM();
345 if (copy > have) copy = have;
346 if (copy > left) copy = left;
347 zmemcpy(put, next, copy);
348 have -= copy;
349 next += copy;
350 left -= copy;
351 put += copy;
352 state->length -= copy;
353 }
354 Tracev((stderr, "inflate: stored end\n"));
355 state->mode = TYPE;
356 break;
357
358 case TABLE:
359 /* get dynamic table entries descriptor */
360 NEEDBITS(14);
361 state->nlen = BITS(5) + 257;
362 DROPBITS(5);
363 state->ndist = BITS(5) + 1;
364 DROPBITS(5);
365 state->ncode = BITS(4) + 4;
366 DROPBITS(4);
367#ifndef PKZIP_BUG_WORKAROUND
368 if (state->nlen > 286 || state->ndist > 30) {
369 strm->msg = (char *)"too many length or distance symbols";
370 state->mode = BAD;
371 break;
372 }
373#endif
374 Tracev((stderr, "inflate: table sizes ok\n"));
375
376 /* get code length code lengths (not a typo) */
377 state->have = 0;
378 while (state->have < state->ncode) {
379 NEEDBITS(3);
380 state->lens[order[state->have++]] = (unsigned short)BITS(3);
381 DROPBITS(3);
382 }
383 while (state->have < 19)
384 state->lens[order[state->have++]] = 0;
385 state->next = state->codes;
386 state->lencode = (code const FAR *)(state->next);
387 state->lenbits = 7;
388 ret = inflate_table(CODES, state->lens, 19, &(state->next),
389 &(state->lenbits), state->work);
390 if (ret) {
391 strm->msg = (char *)"invalid code lengths set";
392 state->mode = BAD;
393 break;
394 }
395 Tracev((stderr, "inflate: code lengths ok\n"));
396
397 /* get length and distance code code lengths */
398 state->have = 0;
399 while (state->have < state->nlen + state->ndist) {
400 for (;;) {
401 here = state->lencode[BITS(state->lenbits)];
402 if ((unsigned)(here.bits) <= bits) break;
403 PULLBYTE();
404 }
405 if (here.val < 16) {
406 DROPBITS(here.bits);
407 state->lens[state->have++] = here.val;
408 }
409 else {
410 if (here.val == 16) {
411 NEEDBITS(here.bits + 2);
412 DROPBITS(here.bits);
413 if (state->have == 0) {
414 strm->msg = (char *)"invalid bit length repeat";
415 state->mode = BAD;
416 break;
417 }
418 len = (unsigned)(state->lens[state->have - 1]);
419 copy = 3 + BITS(2);
420 DROPBITS(2);
421 }
422 else if (here.val == 17) {
423 NEEDBITS(here.bits + 3);
424 DROPBITS(here.bits);
425 len = 0;
426 copy = 3 + BITS(3);
427 DROPBITS(3);
428 }
429 else {
430 NEEDBITS(here.bits + 7);
431 DROPBITS(here.bits);
432 len = 0;
433 copy = 11 + BITS(7);
434 DROPBITS(7);
435 }
436 if (state->have + copy > state->nlen + state->ndist) {
437 strm->msg = (char *)"invalid bit length repeat";
438 state->mode = BAD;
439 break;
440 }
441 while (copy--)
442 state->lens[state->have++] = (unsigned short)len;
443 }
444 }
445
446 /* handle error breaks in while */
447 if (state->mode == BAD) break;
448
449 /* check for end-of-block code (better have one) */
450 if (state->lens[256] == 0) {
451 strm->msg = (char *)"invalid code -- missing end-of-block";
452 state->mode = BAD;
453 break;
454 }
455
456 /* build code tables -- note: do not change the lenbits or distbits
457 values here (9 and 6) without reading the comments in inftrees.h
458 concerning the ENOUGH constants, which depend on those values */
459 state->next = state->codes;
460 state->lencode = (code const FAR *)(state->next);
461 state->lenbits = 9;
462 ret = inflate_table(LENS, state->lens, state->nlen, &(state->next),
463 &(state->lenbits), state->work);
464 if (ret) {
465 strm->msg = (char *)"invalid literal/lengths set";
466 state->mode = BAD;
467 break;
468 }
469 state->distcode = (code const FAR *)(state->next);
470 state->distbits = 6;
471 ret = inflate_table(DISTS, state->lens + state->nlen, state->ndist,
472 &(state->next), &(state->distbits), state->work);
473 if (ret) {
474 strm->msg = (char *)"invalid distances set";
475 state->mode = BAD;
476 break;
477 }
478 Tracev((stderr, "inflate: codes ok\n"));
479 state->mode = LEN;
480 /* fallthrough */
481
482 case LEN:
483 /* use inflate_fast() if we have enough input and output */
484 if (have >= 6 && left >= 258) {
485 RESTORE();
486 if (state->whave < state->wsize)
487 state->whave = state->wsize - left;
488 inflate_fast(strm, state->wsize);
489 LOAD();
490 break;
491 }
492
493 /* get a literal, length, or end-of-block code */
494 for (;;) {
495 here = state->lencode[BITS(state->lenbits)];
496 if ((unsigned)(here.bits) <= bits) break;
497 PULLBYTE();
498 }
499 if (here.op && (here.op & 0xf0) == 0) {
500 last = here;
501 for (;;) {
502 here = state->lencode[last.val +
503 (BITS(last.bits + last.op) >> last.bits)];
504 if ((unsigned)(last.bits + here.bits) <= bits) break;
505 PULLBYTE();
506 }
507 DROPBITS(last.bits);
508 }
509 DROPBITS(here.bits);
510 state->length = (unsigned)here.val;
511
512 /* process literal */
513 if (here.op == 0) {
514 Tracevv((stderr, here.val >= 0x20 && here.val < 0x7f ?
515 "inflate: literal '%c'\n" :
516 "inflate: literal 0x%02x\n", here.val));
517 ROOM();
518 *put++ = (unsigned char)(state->length);
519 left--;
520 state->mode = LEN;
521 break;
522 }
523
524 /* process end of block */
525 if (here.op & 32) {
526 Tracevv((stderr, "inflate: end of block\n"));
527 state->mode = TYPE;
528 break;
529 }
530
531 /* invalid code */
532 if (here.op & 64) {
533 strm->msg = (char *)"invalid literal/length code";
534 state->mode = BAD;
535 break;
536 }
537
538 /* length code -- get extra bits, if any */
539 state->extra = (unsigned)(here.op) & 15;
540 if (state->extra != 0) {
541 NEEDBITS(state->extra);
542 state->length += BITS(state->extra);
543 DROPBITS(state->extra);
544 }
545 Tracevv((stderr, "inflate: length %u\n", state->length));
546
547 /* get distance code */
548 for (;;) {
549 here = state->distcode[BITS(state->distbits)];
550 if ((unsigned)(here.bits) <= bits) break;
551 PULLBYTE();
552 }
553 if ((here.op & 0xf0) == 0) {
554 last = here;
555 for (;;) {
556 here = state->distcode[last.val +
557 (BITS(last.bits + last.op) >> last.bits)];
558 if ((unsigned)(last.bits + here.bits) <= bits) break;
559 PULLBYTE();
560 }
561 DROPBITS(last.bits);
562 }
563 DROPBITS(here.bits);
564 if (here.op & 64) {
565 strm->msg = (char *)"invalid distance code";
566 state->mode = BAD;
567 break;
568 }
569 state->offset = (unsigned)here.val;
570
571 /* get distance extra bits, if any */
572 state->extra = (unsigned)(here.op) & 15;
573 if (state->extra != 0) {
574 NEEDBITS(state->extra);
575 state->offset += BITS(state->extra);
576 DROPBITS(state->extra);
577 }
578 if (state->offset > state->wsize - (state->whave < state->wsize ?
579 left : 0)) {
580 strm->msg = (char *)"invalid distance too far back";
581 state->mode = BAD;
582 break;
583 }
584 Tracevv((stderr, "inflate: distance %u\n", state->offset));
585
586 /* copy match from window to output */
587 do {
588 ROOM();
589 copy = state->wsize - state->offset;
590 if (copy < left) {
591 from = put + copy;
592 copy = left - copy;
593 }
594 else {
595 from = put - state->offset;
596 copy = left;
597 }
598 if (copy > state->length) copy = state->length;
599 state->length -= copy;
600 left -= copy;
601 do {
602 *put++ = *from++;
603 } while (--copy);
604 } while (state->length != 0);
605 break;
606
607 case DONE:
608 /* inflate stream terminated properly -- write leftover output */
609 ret = Z_STREAM_END;
610 if (left < state->wsize) {
611 if (out(out_desc, state->window, state->wsize - left))
612 ret = Z_BUF_ERROR;
613 }
614 goto inf_leave;
615
616 case BAD:
617 ret = Z_DATA_ERROR;
618 goto inf_leave;
619
620 default: /* can't happen, but makes compilers happy */
621 ret = Z_STREAM_ERROR;
622 goto inf_leave;
623 }
624
625 /* Return unused input */
626 inf_leave:
627 strm->next_in = next;
628 strm->avail_in = have;
629 return ret;
630}
LOAD
#define LOAD()
Definition: infback.c:128
fixedtables
void fixedtables(struct inflate_state FAR *state)
Definition: infback.c:82
PULL
#define PULL()
Definition: infback.c:158
INITBITS
#define INITBITS()
Definition: infback.c:150
BITS
#define BITS(n)
Definition: infback.c:190
DROPBITS
#define DROPBITS(n)
Definition: infback.c:194
BYTEBITS
#define BYTEBITS()
Definition: infback.c:201
ROOM
#define ROOM()
Definition: infback.c:210
NEEDBITS
#define NEEDBITS(n)
Definition: infback.c:183
PULLBYTE
#define PULLBYTE()
Definition: infback.c:172
RESTORE
#define RESTORE()
Definition: infback.c:139
inflate_fast
void ZLIB_INTERNAL inflate_fast(z_streamp strm, unsigned start)
Definition: inffast.c:50
TABLE
@ TABLE
Definition: inflate.h:37
STORED
@ STORED
Definition: inflate.h:34
DONE
@ DONE
Definition: inflate.h:49
TYPE
@ TYPE
Definition: inflate.h:32
BAD
@ BAD
Definition: inflate.h:50
LEN
@ LEN
Definition: inflate.h:41
CODES
@ CODES
Definition: inftrees.h:55
field_utils::copy
void copy(G4double dst[], const G4double src[], std::size_t size=G4FieldTrack::ncompSVEC)
Definition: G4FieldUtils.cc:98
code::op
unsigned char op
Definition: inftrees.h:25
code::bits
unsigned char bits
Definition: inftrees.h:26
code::val
unsigned short val
Definition: inftrees.h:27
inflate_state
Definition: inflate.h:82
inflate_state::distcode
code const FAR * distcode
Definition: inflate.h:111
inflate_state::lenbits
unsigned lenbits
Definition: inflate.h:112
inflate_state::ndist
unsigned ndist
Definition: inflate.h:117
inflate_state::lencode
code const FAR * lencode
Definition: inflate.h:110
inflate_state::nlen
unsigned nlen
Definition: inflate.h:116
inflate_state::have
unsigned have
Definition: inflate.h:118
inflate_state::length
unsigned length
Definition: inflate.h:105
inflate_state::hold
unsigned long hold
Definition: inflate.h:102
inflate_state::extra
unsigned extra
Definition: inflate.h:108
inflate_state::ncode
unsigned ncode
Definition: inflate.h:115
inflate_state::strm
z_streamp strm
Definition: inflate.h:83
inflate_state::whave
unsigned whave
Definition: inflate.h:98
inflate_state::work
unsigned short work[288]
Definition: inflate.h:121
inflate_state::next
code FAR * next
Definition: inflate.h:119
inflate_state::distbits
unsigned distbits
Definition: inflate.h:113
inflate_state::mode
inflate_mode mode
Definition: inflate.h:84
inflate_state::window
unsigned char FAR * window
Definition: inflate.h:100
inflate_state::lens
unsigned short lens[320]
Definition: inflate.h:120
inflate_state::bits
unsigned bits
Definition: inflate.h:103
inflate_state::last
int last
Definition: inflate.h:85
inflate_state::wsize
unsigned wsize
Definition: inflate.h:97
inflate_state::offset
unsigned offset
Definition: inflate.h:106
inflate_state::codes
code codes[ENOUGH]
Definition: inflate.h:122
Z_STREAM_END
#define Z_STREAM_END
Definition: zlib.h:178
Z_DATA_ERROR
#define Z_DATA_ERROR
Definition: zlib.h:182
Z_STREAM_ERROR
#define Z_STREAM_ERROR
Definition: zlib.h:181
zmemcpy
void ZLIB_INTERNAL zmemcpy(Bytef *dest, const Bytef *source, uInt len)
Definition: zutil.c:148
Tracev
#define Tracev(x)
Definition: zutil.h:252
Tracevv
#define Tracevv(x)
Definition: zutil.h:253

◆ inflateBackEnd()

int ZEXPORT inflateBackEnd ( z_streamp  strm)

Definition at line 632 of file infback.c.

634{
635 if (strm == Z_NULL || strm->state == Z_NULL || strm->zfree == (free_func)0)
636 return Z_STREAM_ERROR;
637 ZFREE(strm, strm->state);
638 strm->state = Z_NULL;
639 Tracev((stderr, "inflate: end\n"));
640 return Z_OK;
641}
Z_OK
#define Z_OK
Definition: zlib.h:177
ZFREE
#define ZFREE(strm, addr)
Definition: zutil.h:266

◆ inflateBackInit_()

int ZEXPORT inflateBackInit_ ( z_streamp  strm,
int  windowBits,
unsigned char FAR *  window,
const char *  version,
int  stream_size 
)

Definition at line 28 of file infback.c.

34{
35 struct inflate_state FAR *state;
36
37 if (version == Z_NULL || version[0] != ZLIB_VERSION[0] ||
38 stream_size != (int)(sizeof(z_stream)))
39 return Z_VERSION_ERROR;
40 if (strm == Z_NULL || window == Z_NULL ||
41 windowBits < 8 || windowBits > 15)
42 return Z_STREAM_ERROR;
43 strm->msg = Z_NULL; /* in case we return an error */
44 if (strm->zalloc == (alloc_func)0) {
45#ifdef Z_SOLO
46 return Z_STREAM_ERROR;
47#else
48 strm->zalloc = zcalloc;
49 strm->opaque = (voidpf)0;
50#endif
51 }
52 if (strm->zfree == (free_func)0)
53#ifdef Z_SOLO
54 return Z_STREAM_ERROR;
55#else
56 strm->zfree = zcfree;
57#endif
58 state = (struct inflate_state FAR *)ZALLOC(strm, 1,
59 sizeof(struct inflate_state));
60 if (state == Z_NULL) return Z_MEM_ERROR;
61 Tracev((stderr, "inflate: allocated\n"));
62 strm->state = (struct internal_state FAR *)state;
63 state->dmax = 32768U;
64 state->wbits = (uInt)windowBits;
65 state->wsize = 1U << windowBits;
66 state->window = window;
67 state->wnext = 0;
68 state->whave = 0;
69 return Z_OK;
70}
inflate_state::wnext
unsigned wnext
Definition: inflate.h:99
inflate_state::wbits
unsigned wbits
Definition: inflate.h:96
inflate_state::dmax
unsigned dmax
Definition: inflate.h:91
internal_state
Definition: deflate.h:99
internal_state::window
Bytef * window
Definition: deflate.h:118
z_stream_s
Definition: zlib.h:86
ZLIB_VERSION
#define ZLIB_VERSION
Definition: zlib.h:40
Z_VERSION_ERROR
#define Z_VERSION_ERROR
Definition: zlib.h:185
Z_MEM_ERROR
#define Z_MEM_ERROR
Definition: zlib.h:183
zcfree
void ZLIB_INTERNAL zcfree(voidpf opaque, voidpf ptr)
Definition: zutil.c:314
zcalloc
voidpf ZLIB_INTERNAL zcalloc(voidpf opaque, unsigned items, unsigned size)
Definition: zutil.c:304
ZALLOC
#define ZALLOC(strm, items, size)
Definition: zutil.h:264

◆ OF()

void fixedtables OF ( (struct inflate_state FAR *state)  )