tioga 1.11 → 1.13

Sign up to get free protection for your applications and to get access to all the features.
Files changed (148) hide show
  1. data/Tioga_README +58 -35
  2. data/{split/scripts → bin}/tioga +1 -1
  3. data/{split → ext/Dobjects}/Dtable/dtable.c +81 -15
  4. data/{split → ext/Dobjects}/Dtable/dtable_intern.h +0 -0
  5. data/ext/Dobjects/Dtable/extconf.rb +7 -0
  6. data/{split → ext/Dobjects}/Dtable/include/dtable.h +0 -0
  7. data/{split → ext/Dobjects}/Dvector/dvector.c +361 -51
  8. data/{split → ext/Dobjects}/Dvector/dvector_intern.h +0 -0
  9. data/ext/Dobjects/Dvector/extconf.rb +22 -0
  10. data/{split/Dtable → ext/Dobjects/Dvector/include}/dvector.h +0 -0
  11. data/ext/Dobjects/Function/extconf.rb +7 -0
  12. data/{split → ext/Dobjects}/Function/function.c +636 -11
  13. data/{split → ext/Dobjects}/Function/joint_qsort.c +0 -0
  14. data/ext/Flate/extconf.rb +26 -0
  15. data/{split → ext}/Flate/flate.c +7 -3
  16. data/{split → ext}/Flate/flate_intern.h +0 -0
  17. data/{split → ext}/Flate/include/flate.h +0 -0
  18. data/ext/Flate/zlib/adler32.c +149 -0
  19. data/ext/Flate/zlib/compress.c +79 -0
  20. data/ext/Flate/zlib/crc32.c +423 -0
  21. data/ext/Flate/zlib/crc32.h +441 -0
  22. data/ext/Flate/zlib/deflate.c +1736 -0
  23. data/ext/Flate/zlib/deflate.h +331 -0
  24. data/ext/Flate/zlib/gzio.c +1026 -0
  25. data/ext/Flate/zlib/infback.c +623 -0
  26. data/ext/Flate/zlib/inffast.c +318 -0
  27. data/ext/Flate/zlib/inffast.h +11 -0
  28. data/ext/Flate/zlib/inffixed.h +94 -0
  29. data/ext/Flate/zlib/inflate.c +1368 -0
  30. data/ext/Flate/zlib/inflate.h +115 -0
  31. data/ext/Flate/zlib/inftrees.c +329 -0
  32. data/ext/Flate/zlib/inftrees.h +55 -0
  33. data/ext/Flate/zlib/trees.c +1219 -0
  34. data/ext/Flate/zlib/trees.h +128 -0
  35. data/ext/Flate/zlib/uncompr.c +61 -0
  36. data/ext/Flate/zlib/zlib.h +1357 -0
  37. data/ext/Flate/zlib/zutil.c +318 -0
  38. data/ext/Flate/zlib/zutil.h +269 -0
  39. data/ext/Tioga/FigureMaker/__shared_axes.c +1373 -0
  40. data/ext/Tioga/FigureMaker/__shared_makers.c +1303 -0
  41. data/{split/Tioga/pdf_font_dicts.c → ext/Tioga/FigureMaker/__shared_pdf_font_dicts.c} +0 -0
  42. data/{split/Tioga/pdfcolor.c → ext/Tioga/FigureMaker/__shared_pdfcolor.c} +0 -0
  43. data/{split/Tioga/pdfcoords.c → ext/Tioga/FigureMaker/__shared_pdfcoords.c} +0 -0
  44. data/{split/Tioga/pdffile.c → ext/Tioga/FigureMaker/__shared_pdffile.c} +0 -0
  45. data/{split/Tioga/pdfimage.c → ext/Tioga/FigureMaker/__shared_pdfimage.c} +0 -0
  46. data/{split/Tioga/pdfpath.c → ext/Tioga/FigureMaker/__shared_pdfpath.c} +0 -0
  47. data/{split/Tioga/pdftext.c → ext/Tioga/FigureMaker/__shared_pdftext.c} +0 -0
  48. data/{split/Tioga/texout.c → ext/Tioga/FigureMaker/__shared_texout.c} +0 -0
  49. data/ext/Tioga/FigureMaker/extconf.rb +7 -0
  50. data/{split/Tioga → ext/Tioga/FigureMaker}/figures.c +14 -2
  51. data/{split/Tioga → ext/Tioga/FigureMaker}/figures.h +0 -0
  52. data/{split/Tioga → ext/Tioga/FigureMaker}/generic.c +1 -2
  53. data/{split/Tioga → ext/Tioga/FigureMaker}/generic.h +0 -1
  54. data/{split/Tioga → ext/Tioga/FigureMaker}/init.c +0 -0
  55. data/{split/Tioga → ext/Tioga/FigureMaker}/pdfs.h +0 -0
  56. data/{split/Tioga → ext/Tioga/FigureMaker/shared}/axes.c +32 -7
  57. data/{split/Tioga → ext/Tioga/FigureMaker/shared}/makers.c +2 -2
  58. data/ext/Tioga/FigureMaker/shared/pdf_font_dicts.c +18253 -0
  59. data/ext/Tioga/FigureMaker/shared/pdfcolor.c +904 -0
  60. data/ext/Tioga/FigureMaker/shared/pdfcoords.c +518 -0
  61. data/ext/Tioga/FigureMaker/shared/pdffile.c +451 -0
  62. data/ext/Tioga/FigureMaker/shared/pdfimage.c +539 -0
  63. data/ext/Tioga/FigureMaker/shared/pdfpath.c +766 -0
  64. data/ext/Tioga/FigureMaker/shared/pdftext.c +710 -0
  65. data/ext/Tioga/FigureMaker/shared/texout.c +533 -0
  66. data/{split/Tioga → ext/Tioga/FigureMaker}/wrappers.c +5 -5
  67. data/{split/Tioga → ext/Tioga/FigureMaker}/wrappers.h +0 -0
  68. data/{split/Dtable → ext/includes}/defs.h +0 -0
  69. data/{split/Dtable → ext/includes}/namespace.h +0 -0
  70. data/{split/Dtable → ext/includes}/safe_double.h +0 -0
  71. data/{split → ext/includes}/symbols.c +0 -1
  72. data/{split/Dtable → ext/includes}/symbols.h +0 -0
  73. data/{split/Dtable/lib → lib/Dobjects}/Dtable_extras.rb +0 -0
  74. data/{split/Dvector/lib → lib/Dobjects}/Dvector_extras.rb +1 -0
  75. data/{split/Function/lib → lib/Dobjects}/Function_extras.rb +0 -0
  76. data/{split/Dvector/lib → lib/Dobjects}/Numeric_extras.rb +0 -0
  77. data/{split/Tioga/lib → lib/Tioga}/Arcs_and_Circles.rb +0 -0
  78. data/{split/Tioga/lib → lib/Tioga}/ColorConstants.rb +0 -0
  79. data/{split/Tioga/lib → lib/Tioga}/Colorbars.rb +0 -0
  80. data/{split/Tioga/lib → lib/Tioga}/Colormaps.rb +0 -0
  81. data/{split/Tioga/lib → lib/Tioga}/Coordinate_Conversions.rb +0 -0
  82. data/{split/Tioga/lib → lib/Tioga}/Creating_Paths.rb +0 -0
  83. data/{split/Tioga/lib → lib/Tioga}/Doc.rb +0 -0
  84. data/{split/Tioga/lib → lib/Tioga}/Executive.rb +0 -0
  85. data/{split/Tioga/lib → lib/Tioga}/FigMkr.rb +13 -70
  86. data/{split/Tioga/lib → lib/Tioga}/FigureConstants.rb +0 -0
  87. data/{split/Tioga/lib → lib/Tioga}/Figures_and_Plots.rb +0 -0
  88. data/{split/Tioga/lib → lib/Tioga}/Images.rb +0 -0
  89. data/{split/Tioga/lib → lib/Tioga}/Legends.rb +0 -0
  90. data/{split/Tioga/lib → lib/Tioga}/MarkerConstants.rb +0 -0
  91. data/{split/Tioga/lib → lib/Tioga}/Markers.rb +0 -0
  92. data/{split/Tioga/lib → lib/Tioga}/Page_Frame_Bounds.rb +0 -0
  93. data/{split/Tioga/lib → lib/Tioga}/Rectangles.rb +0 -0
  94. data/{split/Tioga/lib → lib/Tioga}/Shading.rb +0 -0
  95. data/{split/Tioga/lib → lib/Tioga}/Special_Paths.rb +0 -0
  96. data/{split/Tioga/lib → lib/Tioga}/Strokes.rb +0 -0
  97. data/{split/Tioga/lib → lib/Tioga}/TeX_Text.rb +0 -0
  98. data/{split/Tioga/lib → lib/Tioga}/TexPreamble.rb +0 -0
  99. data/{split/Tioga/lib → lib/Tioga}/Titles_and_Labels.rb +0 -0
  100. data/{split/Tioga/lib → lib/Tioga}/Transparency.rb +0 -0
  101. data/{split/Tioga/lib → lib/Tioga}/Using_Paths.rb +0 -0
  102. data/{split/Tioga/lib → lib/Tioga}/Utils.rb +74 -0
  103. data/{split/Tioga/lib → lib/Tioga}/X_and_Y_Axes.rb +0 -0
  104. data/{split/Tioga/lib → lib/Tioga}/irb_tioga.rb +0 -0
  105. data/{split/Tioga/lib → lib/Tioga}/maker.rb +0 -0
  106. data/{split/Tioga/lib → lib/Tioga}/tioga.rb +0 -0
  107. data/{split/Tioga/lib → lib/Tioga}/tioga_ui.rb +0 -0
  108. data/{split/Tioga/lib → lib/Tioga}/tioga_ui_cmds.rb +0 -0
  109. data/tests/Icon_Test.pdf +0 -0
  110. data/tests/benchmark_dvector_reads.rb +20 -42
  111. data/tests/tc_Dvector.rb +45 -4
  112. data/tests/tc_Flate.rb +4 -5
  113. data/tests/tc_Function.rb +79 -0
  114. data/tests/vg.log +1453 -0
  115. metadata +141 -122
  116. data/split/Dtable/extconf.rb +0 -4
  117. data/split/Dvector/defs.h +0 -39
  118. data/split/Dvector/extconf.rb +0 -4
  119. data/split/Dvector/include/dvector.h +0 -77
  120. data/split/Dvector/namespace.h +0 -59
  121. data/split/Dvector/safe_double.h +0 -104
  122. data/split/Dvector/symbols.h +0 -52
  123. data/split/Flate/defs.h +0 -39
  124. data/split/Flate/extconf.rb +0 -19
  125. data/split/Flate/namespace.h +0 -59
  126. data/split/Flate/safe_double.h +0 -104
  127. data/split/Flate/symbols.h +0 -52
  128. data/split/Function/defs.h +0 -39
  129. data/split/Function/dvector.h +0 -77
  130. data/split/Function/extconf.rb +0 -4
  131. data/split/Function/namespace.h +0 -59
  132. data/split/Function/safe_double.h +0 -104
  133. data/split/Function/symbols.h +0 -52
  134. data/split/Tioga/defs.h +0 -39
  135. data/split/Tioga/dtable.h +0 -35
  136. data/split/Tioga/dvector.h +0 -77
  137. data/split/Tioga/extconf.rb +0 -4
  138. data/split/Tioga/flate.h +0 -98
  139. data/split/Tioga/mk_tioga_sty.rb +0 -53
  140. data/split/Tioga/namespace.h +0 -59
  141. data/split/Tioga/safe_double.h +0 -104
  142. data/split/Tioga/symbols.h +0 -52
  143. data/split/defs.h +0 -39
  144. data/split/extconf.rb +0 -125
  145. data/split/mkmf2.rb +0 -1623
  146. data/split/namespace.h +0 -59
  147. data/split/safe_double.h +0 -104
  148. data/split/symbols.h +0 -52
@@ -0,0 +1,623 @@
1
+ /* infback.c -- inflate using a call-back interface
2
+ * Copyright (C) 1995-2005 Mark Adler
3
+ * For conditions of distribution and use, see copyright notice in zlib.h
4
+ */
5
+
6
+ /*
7
+ This code is largely copied from inflate.c. Normally either infback.o or
8
+ inflate.o would be linked into an application--not both. The interface
9
+ with inffast.c is retained so that optimized assembler-coded versions of
10
+ inflate_fast() can be used with either inflate.c or infback.c.
11
+ */
12
+
13
+ #include "zutil.h"
14
+ #include "inftrees.h"
15
+ #include "inflate.h"
16
+ #include "inffast.h"
17
+
18
+ /* function prototypes */
19
+ local void fixedtables OF((struct inflate_state FAR *state));
20
+
21
+ /*
22
+ strm provides memory allocation functions in zalloc and zfree, or
23
+ Z_NULL to use the library memory allocation functions.
24
+
25
+ windowBits is in the range 8..15, and window is a user-supplied
26
+ window and output buffer that is 2**windowBits bytes.
27
+ */
28
+ int ZEXPORT inflateBackInit_(strm, windowBits, window, version, stream_size)
29
+ z_streamp strm;
30
+ int windowBits;
31
+ unsigned char FAR *window;
32
+ const char *version;
33
+ int stream_size;
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
+ strm->zalloc = zcalloc;
46
+ strm->opaque = (voidpf)0;
47
+ }
48
+ if (strm->zfree == (free_func)0) strm->zfree = zcfree;
49
+ state = (struct inflate_state FAR *)ZALLOC(strm, 1,
50
+ sizeof(struct inflate_state));
51
+ if (state == Z_NULL) return Z_MEM_ERROR;
52
+ Tracev((stderr, "inflate: allocated\n"));
53
+ strm->state = (struct internal_state FAR *)state;
54
+ state->dmax = 32768U;
55
+ state->wbits = windowBits;
56
+ state->wsize = 1U << windowBits;
57
+ state->window = window;
58
+ state->write = 0;
59
+ state->whave = 0;
60
+ return Z_OK;
61
+ }
62
+
63
+ /*
64
+ Return state with length and distance decoding tables and index sizes set to
65
+ fixed code decoding. Normally this returns fixed tables from inffixed.h.
66
+ If BUILDFIXED is defined, then instead this routine builds the tables the
67
+ first time it's called, and returns those tables the first time and
68
+ thereafter. This reduces the size of the code by about 2K bytes, in
69
+ exchange for a little execution time. However, BUILDFIXED should not be
70
+ used for threaded applications, since the rewriting of the tables and virgin
71
+ may not be thread-safe.
72
+ */
73
+ local void fixedtables(state)
74
+ struct inflate_state FAR *state;
75
+ {
76
+ #ifdef BUILDFIXED
77
+ static int virgin = 1;
78
+ static code *lenfix, *distfix;
79
+ static code fixed[544];
80
+
81
+ /* build fixed huffman tables if first call (may not be thread safe) */
82
+ if (virgin) {
83
+ unsigned sym, bits;
84
+ static code *next;
85
+
86
+ /* literal/length table */
87
+ sym = 0;
88
+ while (sym < 144) state->lens[sym++] = 8;
89
+ while (sym < 256) state->lens[sym++] = 9;
90
+ while (sym < 280) state->lens[sym++] = 7;
91
+ while (sym < 288) state->lens[sym++] = 8;
92
+ next = fixed;
93
+ lenfix = next;
94
+ bits = 9;
95
+ inflate_table(LENS, state->lens, 288, &(next), &(bits), state->work);
96
+
97
+ /* distance table */
98
+ sym = 0;
99
+ while (sym < 32) state->lens[sym++] = 5;
100
+ distfix = next;
101
+ bits = 5;
102
+ inflate_table(DISTS, state->lens, 32, &(next), &(bits), state->work);
103
+
104
+ /* do this just once */
105
+ virgin = 0;
106
+ }
107
+ #else /* !BUILDFIXED */
108
+ # include "inffixed.h"
109
+ #endif /* BUILDFIXED */
110
+ state->lencode = lenfix;
111
+ state->lenbits = 9;
112
+ state->distcode = distfix;
113
+ state->distbits = 5;
114
+ }
115
+
116
+ /* Macros for inflateBack(): */
117
+
118
+ /* Load returned state from inflate_fast() */
119
+ #define LOAD() \
120
+ do { \
121
+ put = strm->next_out; \
122
+ left = strm->avail_out; \
123
+ next = strm->next_in; \
124
+ have = strm->avail_in; \
125
+ hold = state->hold; \
126
+ bits = state->bits; \
127
+ } while (0)
128
+
129
+ /* Set state from registers for inflate_fast() */
130
+ #define RESTORE() \
131
+ do { \
132
+ strm->next_out = put; \
133
+ strm->avail_out = left; \
134
+ strm->next_in = next; \
135
+ strm->avail_in = have; \
136
+ state->hold = hold; \
137
+ state->bits = bits; \
138
+ } while (0)
139
+
140
+ /* Clear the input bit accumulator */
141
+ #define INITBITS() \
142
+ do { \
143
+ hold = 0; \
144
+ bits = 0; \
145
+ } while (0)
146
+
147
+ /* Assure that some input is available. If input is requested, but denied,
148
+ then return a Z_BUF_ERROR from inflateBack(). */
149
+ #define PULL() \
150
+ do { \
151
+ if (have == 0) { \
152
+ have = in(in_desc, &next); \
153
+ if (have == 0) { \
154
+ next = Z_NULL; \
155
+ ret = Z_BUF_ERROR; \
156
+ goto inf_leave; \
157
+ } \
158
+ } \
159
+ } while (0)
160
+
161
+ /* Get a byte of input into the bit accumulator, or return from inflateBack()
162
+ with an error if there is no input available. */
163
+ #define PULLBYTE() \
164
+ do { \
165
+ PULL(); \
166
+ have--; \
167
+ hold += (unsigned long)(*next++) << bits; \
168
+ bits += 8; \
169
+ } while (0)
170
+
171
+ /* Assure that there are at least n bits in the bit accumulator. If there is
172
+ not enough available input to do that, then return from inflateBack() with
173
+ an error. */
174
+ #define NEEDBITS(n) \
175
+ do { \
176
+ while (bits < (unsigned)(n)) \
177
+ PULLBYTE(); \
178
+ } while (0)
179
+
180
+ /* Return the low n bits of the bit accumulator (n < 16) */
181
+ #define BITS(n) \
182
+ ((unsigned)hold & ((1U << (n)) - 1))
183
+
184
+ /* Remove n bits from the bit accumulator */
185
+ #define DROPBITS(n) \
186
+ do { \
187
+ hold >>= (n); \
188
+ bits -= (unsigned)(n); \
189
+ } while (0)
190
+
191
+ /* Remove zero to seven bits as needed to go to a byte boundary */
192
+ #define BYTEBITS() \
193
+ do { \
194
+ hold >>= bits & 7; \
195
+ bits -= bits & 7; \
196
+ } while (0)
197
+
198
+ /* Assure that some output space is available, by writing out the window
199
+ if it's full. If the write fails, return from inflateBack() with a
200
+ Z_BUF_ERROR. */
201
+ #define ROOM() \
202
+ do { \
203
+ if (left == 0) { \
204
+ put = state->window; \
205
+ left = state->wsize; \
206
+ state->whave = left; \
207
+ if (out(out_desc, put, left)) { \
208
+ ret = Z_BUF_ERROR; \
209
+ goto inf_leave; \
210
+ } \
211
+ } \
212
+ } while (0)
213
+
214
+ /*
215
+ strm provides the memory allocation functions and window buffer on input,
216
+ and provides information on the unused input on return. For Z_DATA_ERROR
217
+ returns, strm will also provide an error message.
218
+
219
+ in() and out() are the call-back input and output functions. When
220
+ inflateBack() needs more input, it calls in(). When inflateBack() has
221
+ filled the window with output, or when it completes with data in the
222
+ window, it calls out() to write out the data. The application must not
223
+ change the provided input until in() is called again or inflateBack()
224
+ returns. The application must not change the window/output buffer until
225
+ inflateBack() returns.
226
+
227
+ in() and out() are called with a descriptor parameter provided in the
228
+ inflateBack() call. This parameter can be a structure that provides the
229
+ information required to do the read or write, as well as accumulated
230
+ information on the input and output such as totals and check values.
231
+
232
+ in() should return zero on failure. out() should return non-zero on
233
+ failure. If either in() or out() fails, than inflateBack() returns a
234
+ Z_BUF_ERROR. strm->next_in can be checked for Z_NULL to see whether it
235
+ was in() or out() that caused in the error. Otherwise, inflateBack()
236
+ returns Z_STREAM_END on success, Z_DATA_ERROR for an deflate format
237
+ error, or Z_MEM_ERROR if it could not allocate memory for the state.
238
+ inflateBack() can also return Z_STREAM_ERROR if the input parameters
239
+ are not correct, i.e. strm is Z_NULL or the state was not initialized.
240
+ */
241
+ int ZEXPORT inflateBack(strm, in, in_desc, out, out_desc)
242
+ z_streamp strm;
243
+ in_func in;
244
+ void FAR *in_desc;
245
+ out_func out;
246
+ void FAR *out_desc;
247
+ {
248
+ struct inflate_state FAR *state;
249
+ unsigned char FAR *next; /* next input */
250
+ unsigned char FAR *put; /* next output */
251
+ unsigned have, left; /* available input and output */
252
+ unsigned long hold; /* bit buffer */
253
+ unsigned bits; /* bits in bit buffer */
254
+ unsigned copy; /* number of stored or match bytes to copy */
255
+ unsigned char FAR *from; /* where to copy match bytes from */
256
+ code this; /* current decoding table entry */
257
+ code last; /* parent table entry */
258
+ unsigned len; /* length to copy for repeats, bits to drop */
259
+ int ret; /* return code */
260
+ static const unsigned short order[19] = /* permutation of code lengths */
261
+ {16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15};
262
+
263
+ /* Check that the strm exists and that the state was initialized */
264
+ if (strm == Z_NULL || strm->state == Z_NULL)
265
+ return Z_STREAM_ERROR;
266
+ state = (struct inflate_state FAR *)strm->state;
267
+
268
+ /* Reset the state */
269
+ strm->msg = Z_NULL;
270
+ state->mode = TYPE;
271
+ state->last = 0;
272
+ state->whave = 0;
273
+ next = strm->next_in;
274
+ have = next != Z_NULL ? strm->avail_in : 0;
275
+ hold = 0;
276
+ bits = 0;
277
+ put = state->window;
278
+ left = state->wsize;
279
+
280
+ /* Inflate until end of block marked as last */
281
+ for (;;)
282
+ switch (state->mode) {
283
+ case TYPE:
284
+ /* determine and dispatch block type */
285
+ if (state->last) {
286
+ BYTEBITS();
287
+ state->mode = DONE;
288
+ break;
289
+ }
290
+ NEEDBITS(3);
291
+ state->last = BITS(1);
292
+ DROPBITS(1);
293
+ switch (BITS(2)) {
294
+ case 0: /* stored block */
295
+ Tracev((stderr, "inflate: stored block%s\n",
296
+ state->last ? " (last)" : ""));
297
+ state->mode = STORED;
298
+ break;
299
+ case 1: /* fixed block */
300
+ fixedtables(state);
301
+ Tracev((stderr, "inflate: fixed codes block%s\n",
302
+ state->last ? " (last)" : ""));
303
+ state->mode = LEN; /* decode codes */
304
+ break;
305
+ case 2: /* dynamic block */
306
+ Tracev((stderr, "inflate: dynamic codes block%s\n",
307
+ state->last ? " (last)" : ""));
308
+ state->mode = TABLE;
309
+ break;
310
+ case 3:
311
+ strm->msg = (char *)"invalid block type";
312
+ state->mode = BAD;
313
+ }
314
+ DROPBITS(2);
315
+ break;
316
+
317
+ case STORED:
318
+ /* get and verify stored block length */
319
+ BYTEBITS(); /* go to byte boundary */
320
+ NEEDBITS(32);
321
+ if ((hold & 0xffff) != ((hold >> 16) ^ 0xffff)) {
322
+ strm->msg = (char *)"invalid stored block lengths";
323
+ state->mode = BAD;
324
+ break;
325
+ }
326
+ state->length = (unsigned)hold & 0xffff;
327
+ Tracev((stderr, "inflate: stored length %u\n",
328
+ state->length));
329
+ INITBITS();
330
+
331
+ /* copy stored block from input to output */
332
+ while (state->length != 0) {
333
+ copy = state->length;
334
+ PULL();
335
+ ROOM();
336
+ if (copy > have) copy = have;
337
+ if (copy > left) copy = left;
338
+ zmemcpy(put, next, copy);
339
+ have -= copy;
340
+ next += copy;
341
+ left -= copy;
342
+ put += copy;
343
+ state->length -= copy;
344
+ }
345
+ Tracev((stderr, "inflate: stored end\n"));
346
+ state->mode = TYPE;
347
+ break;
348
+
349
+ case TABLE:
350
+ /* get dynamic table entries descriptor */
351
+ NEEDBITS(14);
352
+ state->nlen = BITS(5) + 257;
353
+ DROPBITS(5);
354
+ state->ndist = BITS(5) + 1;
355
+ DROPBITS(5);
356
+ state->ncode = BITS(4) + 4;
357
+ DROPBITS(4);
358
+ #ifndef PKZIP_BUG_WORKAROUND
359
+ if (state->nlen > 286 || state->ndist > 30) {
360
+ strm->msg = (char *)"too many length or distance symbols";
361
+ state->mode = BAD;
362
+ break;
363
+ }
364
+ #endif
365
+ Tracev((stderr, "inflate: table sizes ok\n"));
366
+
367
+ /* get code length code lengths (not a typo) */
368
+ state->have = 0;
369
+ while (state->have < state->ncode) {
370
+ NEEDBITS(3);
371
+ state->lens[order[state->have++]] = (unsigned short)BITS(3);
372
+ DROPBITS(3);
373
+ }
374
+ while (state->have < 19)
375
+ state->lens[order[state->have++]] = 0;
376
+ state->next = state->codes;
377
+ state->lencode = (code const FAR *)(state->next);
378
+ state->lenbits = 7;
379
+ ret = inflate_table(CODES, state->lens, 19, &(state->next),
380
+ &(state->lenbits), state->work);
381
+ if (ret) {
382
+ strm->msg = (char *)"invalid code lengths set";
383
+ state->mode = BAD;
384
+ break;
385
+ }
386
+ Tracev((stderr, "inflate: code lengths ok\n"));
387
+
388
+ /* get length and distance code code lengths */
389
+ state->have = 0;
390
+ while (state->have < state->nlen + state->ndist) {
391
+ for (;;) {
392
+ this = state->lencode[BITS(state->lenbits)];
393
+ if ((unsigned)(this.bits) <= bits) break;
394
+ PULLBYTE();
395
+ }
396
+ if (this.val < 16) {
397
+ NEEDBITS(this.bits);
398
+ DROPBITS(this.bits);
399
+ state->lens[state->have++] = this.val;
400
+ }
401
+ else {
402
+ if (this.val == 16) {
403
+ NEEDBITS(this.bits + 2);
404
+ DROPBITS(this.bits);
405
+ if (state->have == 0) {
406
+ strm->msg = (char *)"invalid bit length repeat";
407
+ state->mode = BAD;
408
+ break;
409
+ }
410
+ len = (unsigned)(state->lens[state->have - 1]);
411
+ copy = 3 + BITS(2);
412
+ DROPBITS(2);
413
+ }
414
+ else if (this.val == 17) {
415
+ NEEDBITS(this.bits + 3);
416
+ DROPBITS(this.bits);
417
+ len = 0;
418
+ copy = 3 + BITS(3);
419
+ DROPBITS(3);
420
+ }
421
+ else {
422
+ NEEDBITS(this.bits + 7);
423
+ DROPBITS(this.bits);
424
+ len = 0;
425
+ copy = 11 + BITS(7);
426
+ DROPBITS(7);
427
+ }
428
+ if (state->have + copy > state->nlen + state->ndist) {
429
+ strm->msg = (char *)"invalid bit length repeat";
430
+ state->mode = BAD;
431
+ break;
432
+ }
433
+ while (copy--)
434
+ state->lens[state->have++] = (unsigned short)len;
435
+ }
436
+ }
437
+
438
+ /* handle error breaks in while */
439
+ if (state->mode == BAD) break;
440
+
441
+ /* build code tables */
442
+ state->next = state->codes;
443
+ state->lencode = (code const FAR *)(state->next);
444
+ state->lenbits = 9;
445
+ ret = inflate_table(LENS, state->lens, state->nlen, &(state->next),
446
+ &(state->lenbits), state->work);
447
+ if (ret) {
448
+ strm->msg = (char *)"invalid literal/lengths set";
449
+ state->mode = BAD;
450
+ break;
451
+ }
452
+ state->distcode = (code const FAR *)(state->next);
453
+ state->distbits = 6;
454
+ ret = inflate_table(DISTS, state->lens + state->nlen, state->ndist,
455
+ &(state->next), &(state->distbits), state->work);
456
+ if (ret) {
457
+ strm->msg = (char *)"invalid distances set";
458
+ state->mode = BAD;
459
+ break;
460
+ }
461
+ Tracev((stderr, "inflate: codes ok\n"));
462
+ state->mode = LEN;
463
+
464
+ case LEN:
465
+ /* use inflate_fast() if we have enough input and output */
466
+ if (have >= 6 && left >= 258) {
467
+ RESTORE();
468
+ if (state->whave < state->wsize)
469
+ state->whave = state->wsize - left;
470
+ inflate_fast(strm, state->wsize);
471
+ LOAD();
472
+ break;
473
+ }
474
+
475
+ /* get a literal, length, or end-of-block code */
476
+ for (;;) {
477
+ this = state->lencode[BITS(state->lenbits)];
478
+ if ((unsigned)(this.bits) <= bits) break;
479
+ PULLBYTE();
480
+ }
481
+ if (this.op && (this.op & 0xf0) == 0) {
482
+ last = this;
483
+ for (;;) {
484
+ this = state->lencode[last.val +
485
+ (BITS(last.bits + last.op) >> last.bits)];
486
+ if ((unsigned)(last.bits + this.bits) <= bits) break;
487
+ PULLBYTE();
488
+ }
489
+ DROPBITS(last.bits);
490
+ }
491
+ DROPBITS(this.bits);
492
+ state->length = (unsigned)this.val;
493
+
494
+ /* process literal */
495
+ if (this.op == 0) {
496
+ Tracevv((stderr, this.val >= 0x20 && this.val < 0x7f ?
497
+ "inflate: literal '%c'\n" :
498
+ "inflate: literal 0x%02x\n", this.val));
499
+ ROOM();
500
+ *put++ = (unsigned char)(state->length);
501
+ left--;
502
+ state->mode = LEN;
503
+ break;
504
+ }
505
+
506
+ /* process end of block */
507
+ if (this.op & 32) {
508
+ Tracevv((stderr, "inflate: end of block\n"));
509
+ state->mode = TYPE;
510
+ break;
511
+ }
512
+
513
+ /* invalid code */
514
+ if (this.op & 64) {
515
+ strm->msg = (char *)"invalid literal/length code";
516
+ state->mode = BAD;
517
+ break;
518
+ }
519
+
520
+ /* length code -- get extra bits, if any */
521
+ state->extra = (unsigned)(this.op) & 15;
522
+ if (state->extra != 0) {
523
+ NEEDBITS(state->extra);
524
+ state->length += BITS(state->extra);
525
+ DROPBITS(state->extra);
526
+ }
527
+ Tracevv((stderr, "inflate: length %u\n", state->length));
528
+
529
+ /* get distance code */
530
+ for (;;) {
531
+ this = state->distcode[BITS(state->distbits)];
532
+ if ((unsigned)(this.bits) <= bits) break;
533
+ PULLBYTE();
534
+ }
535
+ if ((this.op & 0xf0) == 0) {
536
+ last = this;
537
+ for (;;) {
538
+ this = state->distcode[last.val +
539
+ (BITS(last.bits + last.op) >> last.bits)];
540
+ if ((unsigned)(last.bits + this.bits) <= bits) break;
541
+ PULLBYTE();
542
+ }
543
+ DROPBITS(last.bits);
544
+ }
545
+ DROPBITS(this.bits);
546
+ if (this.op & 64) {
547
+ strm->msg = (char *)"invalid distance code";
548
+ state->mode = BAD;
549
+ break;
550
+ }
551
+ state->offset = (unsigned)this.val;
552
+
553
+ /* get distance extra bits, if any */
554
+ state->extra = (unsigned)(this.op) & 15;
555
+ if (state->extra != 0) {
556
+ NEEDBITS(state->extra);
557
+ state->offset += BITS(state->extra);
558
+ DROPBITS(state->extra);
559
+ }
560
+ if (state->offset > state->wsize - (state->whave < state->wsize ?
561
+ left : 0)) {
562
+ strm->msg = (char *)"invalid distance too far back";
563
+ state->mode = BAD;
564
+ break;
565
+ }
566
+ Tracevv((stderr, "inflate: distance %u\n", state->offset));
567
+
568
+ /* copy match from window to output */
569
+ do {
570
+ ROOM();
571
+ copy = state->wsize - state->offset;
572
+ if (copy < left) {
573
+ from = put + copy;
574
+ copy = left - copy;
575
+ }
576
+ else {
577
+ from = put - state->offset;
578
+ copy = left;
579
+ }
580
+ if (copy > state->length) copy = state->length;
581
+ state->length -= copy;
582
+ left -= copy;
583
+ do {
584
+ *put++ = *from++;
585
+ } while (--copy);
586
+ } while (state->length != 0);
587
+ break;
588
+
589
+ case DONE:
590
+ /* inflate stream terminated properly -- write leftover output */
591
+ ret = Z_STREAM_END;
592
+ if (left < state->wsize) {
593
+ if (out(out_desc, state->window, state->wsize - left))
594
+ ret = Z_BUF_ERROR;
595
+ }
596
+ goto inf_leave;
597
+
598
+ case BAD:
599
+ ret = Z_DATA_ERROR;
600
+ goto inf_leave;
601
+
602
+ default: /* can't happen, but makes compilers happy */
603
+ ret = Z_STREAM_ERROR;
604
+ goto inf_leave;
605
+ }
606
+
607
+ /* Return unused input */
608
+ inf_leave:
609
+ strm->next_in = next;
610
+ strm->avail_in = have;
611
+ return ret;
612
+ }
613
+
614
+ int ZEXPORT inflateBackEnd(strm)
615
+ z_streamp strm;
616
+ {
617
+ if (strm == Z_NULL || strm->state == Z_NULL || strm->zfree == (free_func)0)
618
+ return Z_STREAM_ERROR;
619
+ ZFREE(strm, strm->state);
620
+ strm->state = Z_NULL;
621
+ Tracev((stderr, "inflate: end\n"));
622
+ return Z_OK;
623
+ }