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,331 @@
1
+ /* deflate.h -- internal compression state
2
+ * Copyright (C) 1995-2004 Jean-loup Gailly
3
+ * For conditions of distribution and use, see copyright notice in zlib.h
4
+ */
5
+
6
+ /* WARNING: this file should *not* be used by applications. It is
7
+ part of the implementation of the compression library and is
8
+ subject to change. Applications should only use zlib.h.
9
+ */
10
+
11
+ /* @(#) $Id$ */
12
+
13
+ #ifndef DEFLATE_H
14
+ #define DEFLATE_H
15
+
16
+ #include "zutil.h"
17
+
18
+ /* define NO_GZIP when compiling if you want to disable gzip header and
19
+ trailer creation by deflate(). NO_GZIP would be used to avoid linking in
20
+ the crc code when it is not needed. For shared libraries, gzip encoding
21
+ should be left enabled. */
22
+ #ifndef NO_GZIP
23
+ # define GZIP
24
+ #endif
25
+
26
+ /* ===========================================================================
27
+ * Internal compression state.
28
+ */
29
+
30
+ #define LENGTH_CODES 29
31
+ /* number of length codes, not counting the special END_BLOCK code */
32
+
33
+ #define LITERALS 256
34
+ /* number of literal bytes 0..255 */
35
+
36
+ #define L_CODES (LITERALS+1+LENGTH_CODES)
37
+ /* number of Literal or Length codes, including the END_BLOCK code */
38
+
39
+ #define D_CODES 30
40
+ /* number of distance codes */
41
+
42
+ #define BL_CODES 19
43
+ /* number of codes used to transfer the bit lengths */
44
+
45
+ #define HEAP_SIZE (2*L_CODES+1)
46
+ /* maximum heap size */
47
+
48
+ #define MAX_BITS 15
49
+ /* All codes must not exceed MAX_BITS bits */
50
+
51
+ #define INIT_STATE 42
52
+ #define EXTRA_STATE 69
53
+ #define NAME_STATE 73
54
+ #define COMMENT_STATE 91
55
+ #define HCRC_STATE 103
56
+ #define BUSY_STATE 113
57
+ #define FINISH_STATE 666
58
+ /* Stream status */
59
+
60
+
61
+ /* Data structure describing a single value and its code string. */
62
+ typedef struct ct_data_s {
63
+ union {
64
+ ush freq; /* frequency count */
65
+ ush code; /* bit string */
66
+ } fc;
67
+ union {
68
+ ush dad; /* father node in Huffman tree */
69
+ ush len; /* length of bit string */
70
+ } dl;
71
+ } FAR ct_data;
72
+
73
+ #define Freq fc.freq
74
+ #define Code fc.code
75
+ #define Dad dl.dad
76
+ #define Len dl.len
77
+
78
+ typedef struct static_tree_desc_s static_tree_desc;
79
+
80
+ typedef struct tree_desc_s {
81
+ ct_data *dyn_tree; /* the dynamic tree */
82
+ int max_code; /* largest code with non zero frequency */
83
+ static_tree_desc *stat_desc; /* the corresponding static tree */
84
+ } FAR tree_desc;
85
+
86
+ typedef ush Pos;
87
+ typedef Pos FAR Posf;
88
+ typedef unsigned IPos;
89
+
90
+ /* A Pos is an index in the character window. We use short instead of int to
91
+ * save space in the various tables. IPos is used only for parameter passing.
92
+ */
93
+
94
+ typedef struct internal_state {
95
+ z_streamp strm; /* pointer back to this zlib stream */
96
+ int status; /* as the name implies */
97
+ Bytef *pending_buf; /* output still pending */
98
+ ulg pending_buf_size; /* size of pending_buf */
99
+ Bytef *pending_out; /* next pending byte to output to the stream */
100
+ uInt pending; /* nb of bytes in the pending buffer */
101
+ int wrap; /* bit 0 true for zlib, bit 1 true for gzip */
102
+ gz_headerp gzhead; /* gzip header information to write */
103
+ uInt gzindex; /* where in extra, name, or comment */
104
+ Byte method; /* STORED (for zip only) or DEFLATED */
105
+ int last_flush; /* value of flush param for previous deflate call */
106
+
107
+ /* used by deflate.c: */
108
+
109
+ uInt w_size; /* LZ77 window size (32K by default) */
110
+ uInt w_bits; /* log2(w_size) (8..16) */
111
+ uInt w_mask; /* w_size - 1 */
112
+
113
+ Bytef *window;
114
+ /* Sliding window. Input bytes are read into the second half of the window,
115
+ * and move to the first half later to keep a dictionary of at least wSize
116
+ * bytes. With this organization, matches are limited to a distance of
117
+ * wSize-MAX_MATCH bytes, but this ensures that IO is always
118
+ * performed with a length multiple of the block size. Also, it limits
119
+ * the window size to 64K, which is quite useful on MSDOS.
120
+ * To do: use the user input buffer as sliding window.
121
+ */
122
+
123
+ ulg window_size;
124
+ /* Actual size of window: 2*wSize, except when the user input buffer
125
+ * is directly used as sliding window.
126
+ */
127
+
128
+ Posf *prev;
129
+ /* Link to older string with same hash index. To limit the size of this
130
+ * array to 64K, this link is maintained only for the last 32K strings.
131
+ * An index in this array is thus a window index modulo 32K.
132
+ */
133
+
134
+ Posf *head; /* Heads of the hash chains or NIL. */
135
+
136
+ uInt ins_h; /* hash index of string to be inserted */
137
+ uInt hash_size; /* number of elements in hash table */
138
+ uInt hash_bits; /* log2(hash_size) */
139
+ uInt hash_mask; /* hash_size-1 */
140
+
141
+ uInt hash_shift;
142
+ /* Number of bits by which ins_h must be shifted at each input
143
+ * step. It must be such that after MIN_MATCH steps, the oldest
144
+ * byte no longer takes part in the hash key, that is:
145
+ * hash_shift * MIN_MATCH >= hash_bits
146
+ */
147
+
148
+ long block_start;
149
+ /* Window position at the beginning of the current output block. Gets
150
+ * negative when the window is moved backwards.
151
+ */
152
+
153
+ uInt match_length; /* length of best match */
154
+ IPos prev_match; /* previous match */
155
+ int match_available; /* set if previous match exists */
156
+ uInt strstart; /* start of string to insert */
157
+ uInt match_start; /* start of matching string */
158
+ uInt lookahead; /* number of valid bytes ahead in window */
159
+
160
+ uInt prev_length;
161
+ /* Length of the best match at previous step. Matches not greater than this
162
+ * are discarded. This is used in the lazy match evaluation.
163
+ */
164
+
165
+ uInt max_chain_length;
166
+ /* To speed up deflation, hash chains are never searched beyond this
167
+ * length. A higher limit improves compression ratio but degrades the
168
+ * speed.
169
+ */
170
+
171
+ uInt max_lazy_match;
172
+ /* Attempt to find a better match only when the current match is strictly
173
+ * smaller than this value. This mechanism is used only for compression
174
+ * levels >= 4.
175
+ */
176
+ # define max_insert_length max_lazy_match
177
+ /* Insert new strings in the hash table only if the match length is not
178
+ * greater than this length. This saves time but degrades compression.
179
+ * max_insert_length is used only for compression levels <= 3.
180
+ */
181
+
182
+ int level; /* compression level (1..9) */
183
+ int strategy; /* favor or force Huffman coding*/
184
+
185
+ uInt good_match;
186
+ /* Use a faster search when the previous match is longer than this */
187
+
188
+ int nice_match; /* Stop searching when current match exceeds this */
189
+
190
+ /* used by trees.c: */
191
+ /* Didn't use ct_data typedef below to supress compiler warning */
192
+ struct ct_data_s dyn_ltree[HEAP_SIZE]; /* literal and length tree */
193
+ struct ct_data_s dyn_dtree[2*D_CODES+1]; /* distance tree */
194
+ struct ct_data_s bl_tree[2*BL_CODES+1]; /* Huffman tree for bit lengths */
195
+
196
+ struct tree_desc_s l_desc; /* desc. for literal tree */
197
+ struct tree_desc_s d_desc; /* desc. for distance tree */
198
+ struct tree_desc_s bl_desc; /* desc. for bit length tree */
199
+
200
+ ush bl_count[MAX_BITS+1];
201
+ /* number of codes at each bit length for an optimal tree */
202
+
203
+ int heap[2*L_CODES+1]; /* heap used to build the Huffman trees */
204
+ int heap_len; /* number of elements in the heap */
205
+ int heap_max; /* element of largest frequency */
206
+ /* The sons of heap[n] are heap[2*n] and heap[2*n+1]. heap[0] is not used.
207
+ * The same heap array is used to build all trees.
208
+ */
209
+
210
+ uch depth[2*L_CODES+1];
211
+ /* Depth of each subtree used as tie breaker for trees of equal frequency
212
+ */
213
+
214
+ uchf *l_buf; /* buffer for literals or lengths */
215
+
216
+ uInt lit_bufsize;
217
+ /* Size of match buffer for literals/lengths. There are 4 reasons for
218
+ * limiting lit_bufsize to 64K:
219
+ * - frequencies can be kept in 16 bit counters
220
+ * - if compression is not successful for the first block, all input
221
+ * data is still in the window so we can still emit a stored block even
222
+ * when input comes from standard input. (This can also be done for
223
+ * all blocks if lit_bufsize is not greater than 32K.)
224
+ * - if compression is not successful for a file smaller than 64K, we can
225
+ * even emit a stored file instead of a stored block (saving 5 bytes).
226
+ * This is applicable only for zip (not gzip or zlib).
227
+ * - creating new Huffman trees less frequently may not provide fast
228
+ * adaptation to changes in the input data statistics. (Take for
229
+ * example a binary file with poorly compressible code followed by
230
+ * a highly compressible string table.) Smaller buffer sizes give
231
+ * fast adaptation but have of course the overhead of transmitting
232
+ * trees more frequently.
233
+ * - I can't count above 4
234
+ */
235
+
236
+ uInt last_lit; /* running index in l_buf */
237
+
238
+ ushf *d_buf;
239
+ /* Buffer for distances. To simplify the code, d_buf and l_buf have
240
+ * the same number of elements. To use different lengths, an extra flag
241
+ * array would be necessary.
242
+ */
243
+
244
+ ulg opt_len; /* bit length of current block with optimal trees */
245
+ ulg static_len; /* bit length of current block with static trees */
246
+ uInt matches; /* number of string matches in current block */
247
+ int last_eob_len; /* bit length of EOB code for last block */
248
+
249
+ #ifdef DEBUG
250
+ ulg compressed_len; /* total bit length of compressed file mod 2^32 */
251
+ ulg bits_sent; /* bit length of compressed data sent mod 2^32 */
252
+ #endif
253
+
254
+ ush bi_buf;
255
+ /* Output buffer. bits are inserted starting at the bottom (least
256
+ * significant bits).
257
+ */
258
+ int bi_valid;
259
+ /* Number of valid bits in bi_buf. All bits above the last valid bit
260
+ * are always zero.
261
+ */
262
+
263
+ } FAR deflate_state;
264
+
265
+ /* Output a byte on the stream.
266
+ * IN assertion: there is enough room in pending_buf.
267
+ */
268
+ #define put_byte(s, c) {s->pending_buf[s->pending++] = (c);}
269
+
270
+
271
+ #define MIN_LOOKAHEAD (MAX_MATCH+MIN_MATCH+1)
272
+ /* Minimum amount of lookahead, except at the end of the input file.
273
+ * See deflate.c for comments about the MIN_MATCH+1.
274
+ */
275
+
276
+ #define MAX_DIST(s) ((s)->w_size-MIN_LOOKAHEAD)
277
+ /* In order to simplify the code, particularly on 16 bit machines, match
278
+ * distances are limited to MAX_DIST instead of WSIZE.
279
+ */
280
+
281
+ /* in trees.c */
282
+ void _tr_init OF((deflate_state *s));
283
+ int _tr_tally OF((deflate_state *s, unsigned dist, unsigned lc));
284
+ void _tr_flush_block OF((deflate_state *s, charf *buf, ulg stored_len,
285
+ int eof));
286
+ void _tr_align OF((deflate_state *s));
287
+ void _tr_stored_block OF((deflate_state *s, charf *buf, ulg stored_len,
288
+ int eof));
289
+
290
+ #define d_code(dist) \
291
+ ((dist) < 256 ? _dist_code[dist] : _dist_code[256+((dist)>>7)])
292
+ /* Mapping from a distance to a distance code. dist is the distance - 1 and
293
+ * must not have side effects. _dist_code[256] and _dist_code[257] are never
294
+ * used.
295
+ */
296
+
297
+ #ifndef DEBUG
298
+ /* Inline versions of _tr_tally for speed: */
299
+
300
+ #if defined(GEN_TREES_H) || !defined(STDC)
301
+ extern uch _length_code[];
302
+ extern uch _dist_code[];
303
+ #else
304
+ extern const uch _length_code[];
305
+ extern const uch _dist_code[];
306
+ #endif
307
+
308
+ # define _tr_tally_lit(s, c, flush) \
309
+ { uch cc = (c); \
310
+ s->d_buf[s->last_lit] = 0; \
311
+ s->l_buf[s->last_lit++] = cc; \
312
+ s->dyn_ltree[cc].Freq++; \
313
+ flush = (s->last_lit == s->lit_bufsize-1); \
314
+ }
315
+ # define _tr_tally_dist(s, distance, length, flush) \
316
+ { uch len = (length); \
317
+ ush dist = (distance); \
318
+ s->d_buf[s->last_lit] = dist; \
319
+ s->l_buf[s->last_lit++] = len; \
320
+ dist--; \
321
+ s->dyn_ltree[_length_code[len]+LITERALS+1].Freq++; \
322
+ s->dyn_dtree[d_code(dist)].Freq++; \
323
+ flush = (s->last_lit == s->lit_bufsize-1); \
324
+ }
325
+ #else
326
+ # define _tr_tally_lit(s, c, flush) flush = _tr_tally(s, 0, c)
327
+ # define _tr_tally_dist(s, distance, length, flush) \
328
+ flush = _tr_tally(s, distance, length)
329
+ #endif
330
+
331
+ #endif /* DEFLATE_H */
@@ -0,0 +1,1026 @@
1
+ /* gzio.c -- IO on .gz files
2
+ * Copyright (C) 1995-2005 Jean-loup Gailly.
3
+ * For conditions of distribution and use, see copyright notice in zlib.h
4
+ *
5
+ * Compile this file with -DNO_GZCOMPRESS to avoid the compression code.
6
+ */
7
+
8
+ /* @(#) $Id$ */
9
+
10
+ #include <stdio.h>
11
+
12
+ #include "zutil.h"
13
+
14
+ #ifdef NO_DEFLATE /* for compatibility with old definition */
15
+ # define NO_GZCOMPRESS
16
+ #endif
17
+
18
+ #ifndef NO_DUMMY_DECL
19
+ struct internal_state {int dummy;}; /* for buggy compilers */
20
+ #endif
21
+
22
+ #ifndef Z_BUFSIZE
23
+ # ifdef MAXSEG_64K
24
+ # define Z_BUFSIZE 4096 /* minimize memory usage for 16-bit DOS */
25
+ # else
26
+ # define Z_BUFSIZE 16384
27
+ # endif
28
+ #endif
29
+ #ifndef Z_PRINTF_BUFSIZE
30
+ # define Z_PRINTF_BUFSIZE 4096
31
+ #endif
32
+
33
+ #ifdef __MVS__
34
+ # pragma map (fdopen , "\174\174FDOPEN")
35
+ FILE *fdopen(int, const char *);
36
+ #endif
37
+
38
+ #ifndef STDC
39
+ extern voidp malloc OF((uInt size));
40
+ extern void free OF((voidpf ptr));
41
+ #endif
42
+
43
+ #define ALLOC(size) malloc(size)
44
+ #define TRYFREE(p) {if (p) free(p);}
45
+
46
+ static int const gz_magic[2] = {0x1f, 0x8b}; /* gzip magic header */
47
+
48
+ /* gzip flag byte */
49
+ #define ASCII_FLAG 0x01 /* bit 0 set: file probably ascii text */
50
+ #define HEAD_CRC 0x02 /* bit 1 set: header CRC present */
51
+ #define EXTRA_FIELD 0x04 /* bit 2 set: extra field present */
52
+ #define ORIG_NAME 0x08 /* bit 3 set: original file name present */
53
+ #define COMMENT 0x10 /* bit 4 set: file comment present */
54
+ #define RESERVED 0xE0 /* bits 5..7: reserved */
55
+
56
+ typedef struct gz_stream {
57
+ z_stream stream;
58
+ int z_err; /* error code for last stream operation */
59
+ int z_eof; /* set if end of input file */
60
+ FILE *file; /* .gz file */
61
+ Byte *inbuf; /* input buffer */
62
+ Byte *outbuf; /* output buffer */
63
+ uLong crc; /* crc32 of uncompressed data */
64
+ char *msg; /* error message */
65
+ char *path; /* path name for debugging only */
66
+ int transparent; /* 1 if input file is not a .gz file */
67
+ char mode; /* 'w' or 'r' */
68
+ z_off_t start; /* start of compressed data in file (header skipped) */
69
+ z_off_t in; /* bytes into deflate or inflate */
70
+ z_off_t out; /* bytes out of deflate or inflate */
71
+ int back; /* one character push-back */
72
+ int last; /* true if push-back is last character */
73
+ } gz_stream;
74
+
75
+
76
+ local gzFile gz_open OF((const char *path, const char *mode, int fd));
77
+ local int do_flush OF((gzFile file, int flush));
78
+ local int get_byte OF((gz_stream *s));
79
+ local void check_header OF((gz_stream *s));
80
+ local int destroy OF((gz_stream *s));
81
+ local void putLong OF((FILE *file, uLong x));
82
+ local uLong getLong OF((gz_stream *s));
83
+
84
+ /* ===========================================================================
85
+ Opens a gzip (.gz) file for reading or writing. The mode parameter
86
+ is as in fopen ("rb" or "wb"). The file is given either by file descriptor
87
+ or path name (if fd == -1).
88
+ gz_open returns NULL if the file could not be opened or if there was
89
+ insufficient memory to allocate the (de)compression state; errno
90
+ can be checked to distinguish the two cases (if errno is zero, the
91
+ zlib error is Z_MEM_ERROR).
92
+ */
93
+ local gzFile gz_open (path, mode, fd)
94
+ const char *path;
95
+ const char *mode;
96
+ int fd;
97
+ {
98
+ int err;
99
+ int level = Z_DEFAULT_COMPRESSION; /* compression level */
100
+ int strategy = Z_DEFAULT_STRATEGY; /* compression strategy */
101
+ char *p = (char*)mode;
102
+ gz_stream *s;
103
+ char fmode[80]; /* copy of mode, without the compression level */
104
+ char *m = fmode;
105
+
106
+ if (!path || !mode) return Z_NULL;
107
+
108
+ s = (gz_stream *)ALLOC(sizeof(gz_stream));
109
+ if (!s) return Z_NULL;
110
+
111
+ s->stream.zalloc = (alloc_func)0;
112
+ s->stream.zfree = (free_func)0;
113
+ s->stream.opaque = (voidpf)0;
114
+ s->stream.next_in = s->inbuf = Z_NULL;
115
+ s->stream.next_out = s->outbuf = Z_NULL;
116
+ s->stream.avail_in = s->stream.avail_out = 0;
117
+ s->file = NULL;
118
+ s->z_err = Z_OK;
119
+ s->z_eof = 0;
120
+ s->in = 0;
121
+ s->out = 0;
122
+ s->back = EOF;
123
+ s->crc = crc32(0L, Z_NULL, 0);
124
+ s->msg = NULL;
125
+ s->transparent = 0;
126
+
127
+ s->path = (char*)ALLOC(strlen(path)+1);
128
+ if (s->path == NULL) {
129
+ return destroy(s), (gzFile)Z_NULL;
130
+ }
131
+ strcpy(s->path, path); /* do this early for debugging */
132
+
133
+ s->mode = '\0';
134
+ do {
135
+ if (*p == 'r') s->mode = 'r';
136
+ if (*p == 'w' || *p == 'a') s->mode = 'w';
137
+ if (*p >= '0' && *p <= '9') {
138
+ level = *p - '0';
139
+ } else if (*p == 'f') {
140
+ strategy = Z_FILTERED;
141
+ } else if (*p == 'h') {
142
+ strategy = Z_HUFFMAN_ONLY;
143
+ } else if (*p == 'R') {
144
+ strategy = Z_RLE;
145
+ } else {
146
+ *m++ = *p; /* copy the mode */
147
+ }
148
+ } while (*p++ && m != fmode + sizeof(fmode));
149
+ if (s->mode == '\0') return destroy(s), (gzFile)Z_NULL;
150
+
151
+ if (s->mode == 'w') {
152
+ #ifdef NO_GZCOMPRESS
153
+ err = Z_STREAM_ERROR;
154
+ #else
155
+ err = deflateInit2(&(s->stream), level,
156
+ Z_DEFLATED, -MAX_WBITS, DEF_MEM_LEVEL, strategy);
157
+ /* windowBits is passed < 0 to suppress zlib header */
158
+
159
+ s->stream.next_out = s->outbuf = (Byte*)ALLOC(Z_BUFSIZE);
160
+ #endif
161
+ if (err != Z_OK || s->outbuf == Z_NULL) {
162
+ return destroy(s), (gzFile)Z_NULL;
163
+ }
164
+ } else {
165
+ s->stream.next_in = s->inbuf = (Byte*)ALLOC(Z_BUFSIZE);
166
+
167
+ err = inflateInit2(&(s->stream), -MAX_WBITS);
168
+ /* windowBits is passed < 0 to tell that there is no zlib header.
169
+ * Note that in this case inflate *requires* an extra "dummy" byte
170
+ * after the compressed stream in order to complete decompression and
171
+ * return Z_STREAM_END. Here the gzip CRC32 ensures that 4 bytes are
172
+ * present after the compressed stream.
173
+ */
174
+ if (err != Z_OK || s->inbuf == Z_NULL) {
175
+ return destroy(s), (gzFile)Z_NULL;
176
+ }
177
+ }
178
+ s->stream.avail_out = Z_BUFSIZE;
179
+
180
+ errno = 0;
181
+ s->file = fd < 0 ? F_OPEN(path, fmode) : (FILE*)fdopen(fd, fmode);
182
+
183
+ if (s->file == NULL) {
184
+ return destroy(s), (gzFile)Z_NULL;
185
+ }
186
+ if (s->mode == 'w') {
187
+ /* Write a very simple .gz header:
188
+ */
189
+ fprintf(s->file, "%c%c%c%c%c%c%c%c%c%c", gz_magic[0], gz_magic[1],
190
+ Z_DEFLATED, 0 /*flags*/, 0,0,0,0 /*time*/, 0 /*xflags*/, OS_CODE);
191
+ s->start = 10L;
192
+ /* We use 10L instead of ftell(s->file) to because ftell causes an
193
+ * fflush on some systems. This version of the library doesn't use
194
+ * start anyway in write mode, so this initialization is not
195
+ * necessary.
196
+ */
197
+ } else {
198
+ check_header(s); /* skip the .gz header */
199
+ s->start = ftell(s->file) - s->stream.avail_in;
200
+ }
201
+
202
+ return (gzFile)s;
203
+ }
204
+
205
+ /* ===========================================================================
206
+ Opens a gzip (.gz) file for reading or writing.
207
+ */
208
+ gzFile ZEXPORT gzopen (path, mode)
209
+ const char *path;
210
+ const char *mode;
211
+ {
212
+ return gz_open (path, mode, -1);
213
+ }
214
+
215
+ /* ===========================================================================
216
+ Associate a gzFile with the file descriptor fd. fd is not dup'ed here
217
+ to mimic the behavio(u)r of fdopen.
218
+ */
219
+ gzFile ZEXPORT gzdopen (fd, mode)
220
+ int fd;
221
+ const char *mode;
222
+ {
223
+ char name[46]; /* allow for up to 128-bit integers */
224
+
225
+ if (fd < 0) return (gzFile)Z_NULL;
226
+ sprintf(name, "<fd:%d>", fd); /* for debugging */
227
+
228
+ return gz_open (name, mode, fd);
229
+ }
230
+
231
+ /* ===========================================================================
232
+ * Update the compression level and strategy
233
+ */
234
+ int ZEXPORT gzsetparams (file, level, strategy)
235
+ gzFile file;
236
+ int level;
237
+ int strategy;
238
+ {
239
+ gz_stream *s = (gz_stream*)file;
240
+
241
+ if (s == NULL || s->mode != 'w') return Z_STREAM_ERROR;
242
+
243
+ /* Make room to allow flushing */
244
+ if (s->stream.avail_out == 0) {
245
+
246
+ s->stream.next_out = s->outbuf;
247
+ if (fwrite(s->outbuf, 1, Z_BUFSIZE, s->file) != Z_BUFSIZE) {
248
+ s->z_err = Z_ERRNO;
249
+ }
250
+ s->stream.avail_out = Z_BUFSIZE;
251
+ }
252
+
253
+ return deflateParams (&(s->stream), level, strategy);
254
+ }
255
+
256
+ /* ===========================================================================
257
+ Read a byte from a gz_stream; update next_in and avail_in. Return EOF
258
+ for end of file.
259
+ IN assertion: the stream s has been sucessfully opened for reading.
260
+ */
261
+ local int get_byte(s)
262
+ gz_stream *s;
263
+ {
264
+ if (s->z_eof) return EOF;
265
+ if (s->stream.avail_in == 0) {
266
+ errno = 0;
267
+ s->stream.avail_in = (uInt)fread(s->inbuf, 1, Z_BUFSIZE, s->file);
268
+ if (s->stream.avail_in == 0) {
269
+ s->z_eof = 1;
270
+ if (ferror(s->file)) s->z_err = Z_ERRNO;
271
+ return EOF;
272
+ }
273
+ s->stream.next_in = s->inbuf;
274
+ }
275
+ s->stream.avail_in--;
276
+ return *(s->stream.next_in)++;
277
+ }
278
+
279
+ /* ===========================================================================
280
+ Check the gzip header of a gz_stream opened for reading. Set the stream
281
+ mode to transparent if the gzip magic header is not present; set s->err
282
+ to Z_DATA_ERROR if the magic header is present but the rest of the header
283
+ is incorrect.
284
+ IN assertion: the stream s has already been created sucessfully;
285
+ s->stream.avail_in is zero for the first time, but may be non-zero
286
+ for concatenated .gz files.
287
+ */
288
+ local void check_header(s)
289
+ gz_stream *s;
290
+ {
291
+ int method; /* method byte */
292
+ int flags; /* flags byte */
293
+ uInt len;
294
+ int c;
295
+
296
+ /* Assure two bytes in the buffer so we can peek ahead -- handle case
297
+ where first byte of header is at the end of the buffer after the last
298
+ gzip segment */
299
+ len = s->stream.avail_in;
300
+ if (len < 2) {
301
+ if (len) s->inbuf[0] = s->stream.next_in[0];
302
+ errno = 0;
303
+ len = (uInt)fread(s->inbuf + len, 1, Z_BUFSIZE >> len, s->file);
304
+ if (len == 0 && ferror(s->file)) s->z_err = Z_ERRNO;
305
+ s->stream.avail_in += len;
306
+ s->stream.next_in = s->inbuf;
307
+ if (s->stream.avail_in < 2) {
308
+ s->transparent = s->stream.avail_in;
309
+ return;
310
+ }
311
+ }
312
+
313
+ /* Peek ahead to check the gzip magic header */
314
+ if (s->stream.next_in[0] != gz_magic[0] ||
315
+ s->stream.next_in[1] != gz_magic[1]) {
316
+ s->transparent = 1;
317
+ return;
318
+ }
319
+ s->stream.avail_in -= 2;
320
+ s->stream.next_in += 2;
321
+
322
+ /* Check the rest of the gzip header */
323
+ method = get_byte(s);
324
+ flags = get_byte(s);
325
+ if (method != Z_DEFLATED || (flags & RESERVED) != 0) {
326
+ s->z_err = Z_DATA_ERROR;
327
+ return;
328
+ }
329
+
330
+ /* Discard time, xflags and OS code: */
331
+ for (len = 0; len < 6; len++) (void)get_byte(s);
332
+
333
+ if ((flags & EXTRA_FIELD) != 0) { /* skip the extra field */
334
+ len = (uInt)get_byte(s);
335
+ len += ((uInt)get_byte(s))<<8;
336
+ /* len is garbage if EOF but the loop below will quit anyway */
337
+ while (len-- != 0 && get_byte(s) != EOF) ;
338
+ }
339
+ if ((flags & ORIG_NAME) != 0) { /* skip the original file name */
340
+ while ((c = get_byte(s)) != 0 && c != EOF) ;
341
+ }
342
+ if ((flags & COMMENT) != 0) { /* skip the .gz file comment */
343
+ while ((c = get_byte(s)) != 0 && c != EOF) ;
344
+ }
345
+ if ((flags & HEAD_CRC) != 0) { /* skip the header crc */
346
+ for (len = 0; len < 2; len++) (void)get_byte(s);
347
+ }
348
+ s->z_err = s->z_eof ? Z_DATA_ERROR : Z_OK;
349
+ }
350
+
351
+ /* ===========================================================================
352
+ * Cleanup then free the given gz_stream. Return a zlib error code.
353
+ Try freeing in the reverse order of allocations.
354
+ */
355
+ local int destroy (s)
356
+ gz_stream *s;
357
+ {
358
+ int err = Z_OK;
359
+
360
+ if (!s) return Z_STREAM_ERROR;
361
+
362
+ TRYFREE(s->msg);
363
+
364
+ if (s->stream.state != NULL) {
365
+ if (s->mode == 'w') {
366
+ #ifdef NO_GZCOMPRESS
367
+ err = Z_STREAM_ERROR;
368
+ #else
369
+ err = deflateEnd(&(s->stream));
370
+ #endif
371
+ } else if (s->mode == 'r') {
372
+ err = inflateEnd(&(s->stream));
373
+ }
374
+ }
375
+ if (s->file != NULL && fclose(s->file)) {
376
+ #ifdef ESPIPE
377
+ if (errno != ESPIPE) /* fclose is broken for pipes in HP/UX */
378
+ #endif
379
+ err = Z_ERRNO;
380
+ }
381
+ if (s->z_err < 0) err = s->z_err;
382
+
383
+ TRYFREE(s->inbuf);
384
+ TRYFREE(s->outbuf);
385
+ TRYFREE(s->path);
386
+ TRYFREE(s);
387
+ return err;
388
+ }
389
+
390
+ /* ===========================================================================
391
+ Reads the given number of uncompressed bytes from the compressed file.
392
+ gzread returns the number of bytes actually read (0 for end of file).
393
+ */
394
+ int ZEXPORT gzread (file, buf, len)
395
+ gzFile file;
396
+ voidp buf;
397
+ unsigned len;
398
+ {
399
+ gz_stream *s = (gz_stream*)file;
400
+ Bytef *start = (Bytef*)buf; /* starting point for crc computation */
401
+ Byte *next_out; /* == stream.next_out but not forced far (for MSDOS) */
402
+
403
+ if (s == NULL || s->mode != 'r') return Z_STREAM_ERROR;
404
+
405
+ if (s->z_err == Z_DATA_ERROR || s->z_err == Z_ERRNO) return -1;
406
+ if (s->z_err == Z_STREAM_END) return 0; /* EOF */
407
+
408
+ next_out = (Byte*)buf;
409
+ s->stream.next_out = (Bytef*)buf;
410
+ s->stream.avail_out = len;
411
+
412
+ if (s->stream.avail_out && s->back != EOF) {
413
+ *next_out++ = s->back;
414
+ s->stream.next_out++;
415
+ s->stream.avail_out--;
416
+ s->back = EOF;
417
+ s->out++;
418
+ start++;
419
+ if (s->last) {
420
+ s->z_err = Z_STREAM_END;
421
+ return 1;
422
+ }
423
+ }
424
+
425
+ while (s->stream.avail_out != 0) {
426
+
427
+ if (s->transparent) {
428
+ /* Copy first the lookahead bytes: */
429
+ uInt n = s->stream.avail_in;
430
+ if (n > s->stream.avail_out) n = s->stream.avail_out;
431
+ if (n > 0) {
432
+ zmemcpy(s->stream.next_out, s->stream.next_in, n);
433
+ next_out += n;
434
+ s->stream.next_out = next_out;
435
+ s->stream.next_in += n;
436
+ s->stream.avail_out -= n;
437
+ s->stream.avail_in -= n;
438
+ }
439
+ if (s->stream.avail_out > 0) {
440
+ s->stream.avail_out -=
441
+ (uInt)fread(next_out, 1, s->stream.avail_out, s->file);
442
+ }
443
+ len -= s->stream.avail_out;
444
+ s->in += len;
445
+ s->out += len;
446
+ if (len == 0) s->z_eof = 1;
447
+ return (int)len;
448
+ }
449
+ if (s->stream.avail_in == 0 && !s->z_eof) {
450
+
451
+ errno = 0;
452
+ s->stream.avail_in = (uInt)fread(s->inbuf, 1, Z_BUFSIZE, s->file);
453
+ if (s->stream.avail_in == 0) {
454
+ s->z_eof = 1;
455
+ if (ferror(s->file)) {
456
+ s->z_err = Z_ERRNO;
457
+ break;
458
+ }
459
+ }
460
+ s->stream.next_in = s->inbuf;
461
+ }
462
+ s->in += s->stream.avail_in;
463
+ s->out += s->stream.avail_out;
464
+ s->z_err = inflate(&(s->stream), Z_NO_FLUSH);
465
+ s->in -= s->stream.avail_in;
466
+ s->out -= s->stream.avail_out;
467
+
468
+ if (s->z_err == Z_STREAM_END) {
469
+ /* Check CRC and original size */
470
+ s->crc = crc32(s->crc, start, (uInt)(s->stream.next_out - start));
471
+ start = s->stream.next_out;
472
+
473
+ if (getLong(s) != s->crc) {
474
+ s->z_err = Z_DATA_ERROR;
475
+ } else {
476
+ (void)getLong(s);
477
+ /* The uncompressed length returned by above getlong() may be
478
+ * different from s->out in case of concatenated .gz files.
479
+ * Check for such files:
480
+ */
481
+ check_header(s);
482
+ if (s->z_err == Z_OK) {
483
+ inflateReset(&(s->stream));
484
+ s->crc = crc32(0L, Z_NULL, 0);
485
+ }
486
+ }
487
+ }
488
+ if (s->z_err != Z_OK || s->z_eof) break;
489
+ }
490
+ s->crc = crc32(s->crc, start, (uInt)(s->stream.next_out - start));
491
+
492
+ if (len == s->stream.avail_out &&
493
+ (s->z_err == Z_DATA_ERROR || s->z_err == Z_ERRNO))
494
+ return -1;
495
+ return (int)(len - s->stream.avail_out);
496
+ }
497
+
498
+
499
+ /* ===========================================================================
500
+ Reads one byte from the compressed file. gzgetc returns this byte
501
+ or -1 in case of end of file or error.
502
+ */
503
+ int ZEXPORT gzgetc(file)
504
+ gzFile file;
505
+ {
506
+ unsigned char c;
507
+
508
+ return gzread(file, &c, 1) == 1 ? c : -1;
509
+ }
510
+
511
+
512
+ /* ===========================================================================
513
+ Push one byte back onto the stream.
514
+ */
515
+ int ZEXPORT gzungetc(c, file)
516
+ int c;
517
+ gzFile file;
518
+ {
519
+ gz_stream *s = (gz_stream*)file;
520
+
521
+ if (s == NULL || s->mode != 'r' || c == EOF || s->back != EOF) return EOF;
522
+ s->back = c;
523
+ s->out--;
524
+ s->last = (s->z_err == Z_STREAM_END);
525
+ if (s->last) s->z_err = Z_OK;
526
+ s->z_eof = 0;
527
+ return c;
528
+ }
529
+
530
+
531
+ /* ===========================================================================
532
+ Reads bytes from the compressed file until len-1 characters are
533
+ read, or a newline character is read and transferred to buf, or an
534
+ end-of-file condition is encountered. The string is then terminated
535
+ with a null character.
536
+ gzgets returns buf, or Z_NULL in case of error.
537
+
538
+ The current implementation is not optimized at all.
539
+ */
540
+ char * ZEXPORT gzgets(file, buf, len)
541
+ gzFile file;
542
+ char *buf;
543
+ int len;
544
+ {
545
+ char *b = buf;
546
+ if (buf == Z_NULL || len <= 0) return Z_NULL;
547
+
548
+ while (--len > 0 && gzread(file, buf, 1) == 1 && *buf++ != '\n') ;
549
+ *buf = '\0';
550
+ return b == buf && len > 0 ? Z_NULL : b;
551
+ }
552
+
553
+
554
+ #ifndef NO_GZCOMPRESS
555
+ /* ===========================================================================
556
+ Writes the given number of uncompressed bytes into the compressed file.
557
+ gzwrite returns the number of bytes actually written (0 in case of error).
558
+ */
559
+ int ZEXPORT gzwrite (file, buf, len)
560
+ gzFile file;
561
+ voidpc buf;
562
+ unsigned len;
563
+ {
564
+ gz_stream *s = (gz_stream*)file;
565
+
566
+ if (s == NULL || s->mode != 'w') return Z_STREAM_ERROR;
567
+
568
+ s->stream.next_in = (Bytef*)buf;
569
+ s->stream.avail_in = len;
570
+
571
+ while (s->stream.avail_in != 0) {
572
+
573
+ if (s->stream.avail_out == 0) {
574
+
575
+ s->stream.next_out = s->outbuf;
576
+ if (fwrite(s->outbuf, 1, Z_BUFSIZE, s->file) != Z_BUFSIZE) {
577
+ s->z_err = Z_ERRNO;
578
+ break;
579
+ }
580
+ s->stream.avail_out = Z_BUFSIZE;
581
+ }
582
+ s->in += s->stream.avail_in;
583
+ s->out += s->stream.avail_out;
584
+ s->z_err = deflate(&(s->stream), Z_NO_FLUSH);
585
+ s->in -= s->stream.avail_in;
586
+ s->out -= s->stream.avail_out;
587
+ if (s->z_err != Z_OK) break;
588
+ }
589
+ s->crc = crc32(s->crc, (const Bytef *)buf, len);
590
+
591
+ return (int)(len - s->stream.avail_in);
592
+ }
593
+
594
+
595
+ /* ===========================================================================
596
+ Converts, formats, and writes the args to the compressed file under
597
+ control of the format string, as in fprintf. gzprintf returns the number of
598
+ uncompressed bytes actually written (0 in case of error).
599
+ */
600
+ #ifdef STDC
601
+ #include <stdarg.h>
602
+
603
+ int ZEXPORTVA gzprintf (gzFile file, const char *format, /* args */ ...)
604
+ {
605
+ char buf[Z_PRINTF_BUFSIZE];
606
+ va_list va;
607
+ int len;
608
+
609
+ buf[sizeof(buf) - 1] = 0;
610
+ va_start(va, format);
611
+ #ifdef NO_vsnprintf
612
+ # ifdef HAS_vsprintf_void
613
+ (void)vsprintf(buf, format, va);
614
+ va_end(va);
615
+ for (len = 0; len < sizeof(buf); len++)
616
+ if (buf[len] == 0) break;
617
+ # else
618
+ len = vsprintf(buf, format, va);
619
+ va_end(va);
620
+ # endif
621
+ #else
622
+ # ifdef HAS_vsnprintf_void
623
+ (void)vsnprintf(buf, sizeof(buf), format, va);
624
+ va_end(va);
625
+ len = strlen(buf);
626
+ # else
627
+ len = vsnprintf(buf, sizeof(buf), format, va);
628
+ va_end(va);
629
+ # endif
630
+ #endif
631
+ if (len <= 0 || len >= (int)sizeof(buf) || buf[sizeof(buf) - 1] != 0)
632
+ return 0;
633
+ return gzwrite(file, buf, (unsigned)len);
634
+ }
635
+ #else /* not ANSI C */
636
+
637
+ int ZEXPORTVA gzprintf (file, format, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10,
638
+ a11, a12, a13, a14, a15, a16, a17, a18, a19, a20)
639
+ gzFile file;
640
+ const char *format;
641
+ int a1, a2, a3, a4, a5, a6, a7, a8, a9, a10,
642
+ a11, a12, a13, a14, a15, a16, a17, a18, a19, a20;
643
+ {
644
+ char buf[Z_PRINTF_BUFSIZE];
645
+ int len;
646
+
647
+ buf[sizeof(buf) - 1] = 0;
648
+ #ifdef NO_snprintf
649
+ # ifdef HAS_sprintf_void
650
+ sprintf(buf, format, a1, a2, a3, a4, a5, a6, a7, a8,
651
+ a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20);
652
+ for (len = 0; len < sizeof(buf); len++)
653
+ if (buf[len] == 0) break;
654
+ # else
655
+ len = sprintf(buf, format, a1, a2, a3, a4, a5, a6, a7, a8,
656
+ a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20);
657
+ # endif
658
+ #else
659
+ # ifdef HAS_snprintf_void
660
+ snprintf(buf, sizeof(buf), format, a1, a2, a3, a4, a5, a6, a7, a8,
661
+ a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20);
662
+ len = strlen(buf);
663
+ # else
664
+ len = snprintf(buf, sizeof(buf), format, a1, a2, a3, a4, a5, a6, a7, a8,
665
+ a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20);
666
+ # endif
667
+ #endif
668
+ if (len <= 0 || len >= sizeof(buf) || buf[sizeof(buf) - 1] != 0)
669
+ return 0;
670
+ return gzwrite(file, buf, len);
671
+ }
672
+ #endif
673
+
674
+ /* ===========================================================================
675
+ Writes c, converted to an unsigned char, into the compressed file.
676
+ gzputc returns the value that was written, or -1 in case of error.
677
+ */
678
+ int ZEXPORT gzputc(file, c)
679
+ gzFile file;
680
+ int c;
681
+ {
682
+ unsigned char cc = (unsigned char) c; /* required for big endian systems */
683
+
684
+ return gzwrite(file, &cc, 1) == 1 ? (int)cc : -1;
685
+ }
686
+
687
+
688
+ /* ===========================================================================
689
+ Writes the given null-terminated string to the compressed file, excluding
690
+ the terminating null character.
691
+ gzputs returns the number of characters written, or -1 in case of error.
692
+ */
693
+ int ZEXPORT gzputs(file, s)
694
+ gzFile file;
695
+ const char *s;
696
+ {
697
+ return gzwrite(file, (char*)s, (unsigned)strlen(s));
698
+ }
699
+
700
+
701
+ /* ===========================================================================
702
+ Flushes all pending output into the compressed file. The parameter
703
+ flush is as in the deflate() function.
704
+ */
705
+ local int do_flush (file, flush)
706
+ gzFile file;
707
+ int flush;
708
+ {
709
+ uInt len;
710
+ int done = 0;
711
+ gz_stream *s = (gz_stream*)file;
712
+
713
+ if (s == NULL || s->mode != 'w') return Z_STREAM_ERROR;
714
+
715
+ s->stream.avail_in = 0; /* should be zero already anyway */
716
+
717
+ for (;;) {
718
+ len = Z_BUFSIZE - s->stream.avail_out;
719
+
720
+ if (len != 0) {
721
+ if ((uInt)fwrite(s->outbuf, 1, len, s->file) != len) {
722
+ s->z_err = Z_ERRNO;
723
+ return Z_ERRNO;
724
+ }
725
+ s->stream.next_out = s->outbuf;
726
+ s->stream.avail_out = Z_BUFSIZE;
727
+ }
728
+ if (done) break;
729
+ s->out += s->stream.avail_out;
730
+ s->z_err = deflate(&(s->stream), flush);
731
+ s->out -= s->stream.avail_out;
732
+
733
+ /* Ignore the second of two consecutive flushes: */
734
+ if (len == 0 && s->z_err == Z_BUF_ERROR) s->z_err = Z_OK;
735
+
736
+ /* deflate has finished flushing only when it hasn't used up
737
+ * all the available space in the output buffer:
738
+ */
739
+ done = (s->stream.avail_out != 0 || s->z_err == Z_STREAM_END);
740
+
741
+ if (s->z_err != Z_OK && s->z_err != Z_STREAM_END) break;
742
+ }
743
+ return s->z_err == Z_STREAM_END ? Z_OK : s->z_err;
744
+ }
745
+
746
+ int ZEXPORT gzflush (file, flush)
747
+ gzFile file;
748
+ int flush;
749
+ {
750
+ gz_stream *s = (gz_stream*)file;
751
+ int err = do_flush (file, flush);
752
+
753
+ if (err) return err;
754
+ fflush(s->file);
755
+ return s->z_err == Z_STREAM_END ? Z_OK : s->z_err;
756
+ }
757
+ #endif /* NO_GZCOMPRESS */
758
+
759
+ /* ===========================================================================
760
+ Sets the starting position for the next gzread or gzwrite on the given
761
+ compressed file. The offset represents a number of bytes in the
762
+ gzseek returns the resulting offset location as measured in bytes from
763
+ the beginning of the uncompressed stream, or -1 in case of error.
764
+ SEEK_END is not implemented, returns error.
765
+ In this version of the library, gzseek can be extremely slow.
766
+ */
767
+ z_off_t ZEXPORT gzseek (file, offset, whence)
768
+ gzFile file;
769
+ z_off_t offset;
770
+ int whence;
771
+ {
772
+ gz_stream *s = (gz_stream*)file;
773
+
774
+ if (s == NULL || whence == SEEK_END ||
775
+ s->z_err == Z_ERRNO || s->z_err == Z_DATA_ERROR) {
776
+ return -1L;
777
+ }
778
+
779
+ if (s->mode == 'w') {
780
+ #ifdef NO_GZCOMPRESS
781
+ return -1L;
782
+ #else
783
+ if (whence == SEEK_SET) {
784
+ offset -= s->in;
785
+ }
786
+ if (offset < 0) return -1L;
787
+
788
+ /* At this point, offset is the number of zero bytes to write. */
789
+ if (s->inbuf == Z_NULL) {
790
+ s->inbuf = (Byte*)ALLOC(Z_BUFSIZE); /* for seeking */
791
+ if (s->inbuf == Z_NULL) return -1L;
792
+ zmemzero(s->inbuf, Z_BUFSIZE);
793
+ }
794
+ while (offset > 0) {
795
+ uInt size = Z_BUFSIZE;
796
+ if (offset < Z_BUFSIZE) size = (uInt)offset;
797
+
798
+ size = gzwrite(file, s->inbuf, size);
799
+ if (size == 0) return -1L;
800
+
801
+ offset -= size;
802
+ }
803
+ return s->in;
804
+ #endif
805
+ }
806
+ /* Rest of function is for reading only */
807
+
808
+ /* compute absolute position */
809
+ if (whence == SEEK_CUR) {
810
+ offset += s->out;
811
+ }
812
+ if (offset < 0) return -1L;
813
+
814
+ if (s->transparent) {
815
+ /* map to fseek */
816
+ s->back = EOF;
817
+ s->stream.avail_in = 0;
818
+ s->stream.next_in = s->inbuf;
819
+ if (fseek(s->file, offset, SEEK_SET) < 0) return -1L;
820
+
821
+ s->in = s->out = offset;
822
+ return offset;
823
+ }
824
+
825
+ /* For a negative seek, rewind and use positive seek */
826
+ if (offset >= s->out) {
827
+ offset -= s->out;
828
+ } else if (gzrewind(file) < 0) {
829
+ return -1L;
830
+ }
831
+ /* offset is now the number of bytes to skip. */
832
+
833
+ if (offset != 0 && s->outbuf == Z_NULL) {
834
+ s->outbuf = (Byte*)ALLOC(Z_BUFSIZE);
835
+ if (s->outbuf == Z_NULL) return -1L;
836
+ }
837
+ if (offset && s->back != EOF) {
838
+ s->back = EOF;
839
+ s->out++;
840
+ offset--;
841
+ if (s->last) s->z_err = Z_STREAM_END;
842
+ }
843
+ while (offset > 0) {
844
+ int size = Z_BUFSIZE;
845
+ if (offset < Z_BUFSIZE) size = (int)offset;
846
+
847
+ size = gzread(file, s->outbuf, (uInt)size);
848
+ if (size <= 0) return -1L;
849
+ offset -= size;
850
+ }
851
+ return s->out;
852
+ }
853
+
854
+ /* ===========================================================================
855
+ Rewinds input file.
856
+ */
857
+ int ZEXPORT gzrewind (file)
858
+ gzFile file;
859
+ {
860
+ gz_stream *s = (gz_stream*)file;
861
+
862
+ if (s == NULL || s->mode != 'r') return -1;
863
+
864
+ s->z_err = Z_OK;
865
+ s->z_eof = 0;
866
+ s->back = EOF;
867
+ s->stream.avail_in = 0;
868
+ s->stream.next_in = s->inbuf;
869
+ s->crc = crc32(0L, Z_NULL, 0);
870
+ if (!s->transparent) (void)inflateReset(&s->stream);
871
+ s->in = 0;
872
+ s->out = 0;
873
+ return fseek(s->file, s->start, SEEK_SET);
874
+ }
875
+
876
+ /* ===========================================================================
877
+ Returns the starting position for the next gzread or gzwrite on the
878
+ given compressed file. This position represents a number of bytes in the
879
+ uncompressed data stream.
880
+ */
881
+ z_off_t ZEXPORT gztell (file)
882
+ gzFile file;
883
+ {
884
+ return gzseek(file, 0L, SEEK_CUR);
885
+ }
886
+
887
+ /* ===========================================================================
888
+ Returns 1 when EOF has previously been detected reading the given
889
+ input stream, otherwise zero.
890
+ */
891
+ int ZEXPORT gzeof (file)
892
+ gzFile file;
893
+ {
894
+ gz_stream *s = (gz_stream*)file;
895
+
896
+ /* With concatenated compressed files that can have embedded
897
+ * crc trailers, z_eof is no longer the only/best indicator of EOF
898
+ * on a gz_stream. Handle end-of-stream error explicitly here.
899
+ */
900
+ if (s == NULL || s->mode != 'r') return 0;
901
+ if (s->z_eof) return 1;
902
+ return s->z_err == Z_STREAM_END;
903
+ }
904
+
905
+ /* ===========================================================================
906
+ Returns 1 if reading and doing so transparently, otherwise zero.
907
+ */
908
+ int ZEXPORT gzdirect (file)
909
+ gzFile file;
910
+ {
911
+ gz_stream *s = (gz_stream*)file;
912
+
913
+ if (s == NULL || s->mode != 'r') return 0;
914
+ return s->transparent;
915
+ }
916
+
917
+ /* ===========================================================================
918
+ Outputs a long in LSB order to the given file
919
+ */
920
+ local void putLong (file, x)
921
+ FILE *file;
922
+ uLong x;
923
+ {
924
+ int n;
925
+ for (n = 0; n < 4; n++) {
926
+ fputc((int)(x & 0xff), file);
927
+ x >>= 8;
928
+ }
929
+ }
930
+
931
+ /* ===========================================================================
932
+ Reads a long in LSB order from the given gz_stream. Sets z_err in case
933
+ of error.
934
+ */
935
+ local uLong getLong (s)
936
+ gz_stream *s;
937
+ {
938
+ uLong x = (uLong)get_byte(s);
939
+ int c;
940
+
941
+ x += ((uLong)get_byte(s))<<8;
942
+ x += ((uLong)get_byte(s))<<16;
943
+ c = get_byte(s);
944
+ if (c == EOF) s->z_err = Z_DATA_ERROR;
945
+ x += ((uLong)c)<<24;
946
+ return x;
947
+ }
948
+
949
+ /* ===========================================================================
950
+ Flushes all pending output if necessary, closes the compressed file
951
+ and deallocates all the (de)compression state.
952
+ */
953
+ int ZEXPORT gzclose (file)
954
+ gzFile file;
955
+ {
956
+ gz_stream *s = (gz_stream*)file;
957
+
958
+ if (s == NULL) return Z_STREAM_ERROR;
959
+
960
+ if (s->mode == 'w') {
961
+ #ifdef NO_GZCOMPRESS
962
+ return Z_STREAM_ERROR;
963
+ #else
964
+ if (do_flush (file, Z_FINISH) != Z_OK)
965
+ return destroy((gz_stream*)file);
966
+
967
+ putLong (s->file, s->crc);
968
+ putLong (s->file, (uLong)(s->in & 0xffffffff));
969
+ #endif
970
+ }
971
+ return destroy((gz_stream*)file);
972
+ }
973
+
974
+ #ifdef STDC
975
+ # define zstrerror(errnum) strerror(errnum)
976
+ #else
977
+ # define zstrerror(errnum) ""
978
+ #endif
979
+
980
+ /* ===========================================================================
981
+ Returns the error message for the last error which occurred on the
982
+ given compressed file. errnum is set to zlib error number. If an
983
+ error occurred in the file system and not in the compression library,
984
+ errnum is set to Z_ERRNO and the application may consult errno
985
+ to get the exact error code.
986
+ */
987
+ const char * ZEXPORT gzerror (file, errnum)
988
+ gzFile file;
989
+ int *errnum;
990
+ {
991
+ char *m;
992
+ gz_stream *s = (gz_stream*)file;
993
+
994
+ if (s == NULL) {
995
+ *errnum = Z_STREAM_ERROR;
996
+ return (const char*)ERR_MSG(Z_STREAM_ERROR);
997
+ }
998
+ *errnum = s->z_err;
999
+ if (*errnum == Z_OK) return (const char*)"";
1000
+
1001
+ m = (char*)(*errnum == Z_ERRNO ? zstrerror(errno) : s->stream.msg);
1002
+
1003
+ if (m == NULL || *m == '\0') m = (char*)ERR_MSG(s->z_err);
1004
+
1005
+ TRYFREE(s->msg);
1006
+ s->msg = (char*)ALLOC(strlen(s->path) + strlen(m) + 3);
1007
+ if (s->msg == Z_NULL) return (const char*)ERR_MSG(Z_MEM_ERROR);
1008
+ strcpy(s->msg, s->path);
1009
+ strcat(s->msg, ": ");
1010
+ strcat(s->msg, m);
1011
+ return (const char*)s->msg;
1012
+ }
1013
+
1014
+ /* ===========================================================================
1015
+ Clear the error and end-of-file flags, and do the same for the real file.
1016
+ */
1017
+ void ZEXPORT gzclearerr (file)
1018
+ gzFile file;
1019
+ {
1020
+ gz_stream *s = (gz_stream*)file;
1021
+
1022
+ if (s == NULL) return;
1023
+ if (s->z_err != Z_STREAM_END) s->z_err = Z_OK;
1024
+ s->z_eof = 0;
1025
+ clearerr(s->file);
1026
+ }