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,115 @@
1
+ /* inflate.h -- internal inflate state definition
2
+ * Copyright (C) 1995-2004 Mark Adler
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
+ /* define NO_GZIP when compiling if you want to disable gzip header and
12
+ trailer decoding by inflate(). NO_GZIP would be used to avoid linking in
13
+ the crc code when it is not needed. For shared libraries, gzip decoding
14
+ should be left enabled. */
15
+ #ifndef NO_GZIP
16
+ # define GUNZIP
17
+ #endif
18
+
19
+ /* Possible inflate modes between inflate() calls */
20
+ typedef enum {
21
+ HEAD, /* i: waiting for magic header */
22
+ FLAGS, /* i: waiting for method and flags (gzip) */
23
+ TIME, /* i: waiting for modification time (gzip) */
24
+ OS, /* i: waiting for extra flags and operating system (gzip) */
25
+ EXLEN, /* i: waiting for extra length (gzip) */
26
+ EXTRA, /* i: waiting for extra bytes (gzip) */
27
+ NAME, /* i: waiting for end of file name (gzip) */
28
+ COMMENT, /* i: waiting for end of comment (gzip) */
29
+ HCRC, /* i: waiting for header crc (gzip) */
30
+ DICTID, /* i: waiting for dictionary check value */
31
+ DICT, /* waiting for inflateSetDictionary() call */
32
+ TYPE, /* i: waiting for type bits, including last-flag bit */
33
+ TYPEDO, /* i: same, but skip check to exit inflate on new block */
34
+ STORED, /* i: waiting for stored size (length and complement) */
35
+ COPY, /* i/o: waiting for input or output to copy stored block */
36
+ TABLE, /* i: waiting for dynamic block table lengths */
37
+ LENLENS, /* i: waiting for code length code lengths */
38
+ CODELENS, /* i: waiting for length/lit and distance code lengths */
39
+ LEN, /* i: waiting for length/lit code */
40
+ LENEXT, /* i: waiting for length extra bits */
41
+ DIST, /* i: waiting for distance code */
42
+ DISTEXT, /* i: waiting for distance extra bits */
43
+ MATCH, /* o: waiting for output space to copy string */
44
+ LIT, /* o: waiting for output space to write literal */
45
+ CHECK, /* i: waiting for 32-bit check value */
46
+ LENGTH, /* i: waiting for 32-bit length (gzip) */
47
+ DONE, /* finished check, done -- remain here until reset */
48
+ BAD, /* got a data error -- remain here until reset */
49
+ MEM, /* got an inflate() memory error -- remain here until reset */
50
+ SYNC /* looking for synchronization bytes to restart inflate() */
51
+ } inflate_mode;
52
+
53
+ /*
54
+ State transitions between above modes -
55
+
56
+ (most modes can go to the BAD or MEM mode -- not shown for clarity)
57
+
58
+ Process header:
59
+ HEAD -> (gzip) or (zlib)
60
+ (gzip) -> FLAGS -> TIME -> OS -> EXLEN -> EXTRA -> NAME
61
+ NAME -> COMMENT -> HCRC -> TYPE
62
+ (zlib) -> DICTID or TYPE
63
+ DICTID -> DICT -> TYPE
64
+ Read deflate blocks:
65
+ TYPE -> STORED or TABLE or LEN or CHECK
66
+ STORED -> COPY -> TYPE
67
+ TABLE -> LENLENS -> CODELENS -> LEN
68
+ Read deflate codes:
69
+ LEN -> LENEXT or LIT or TYPE
70
+ LENEXT -> DIST -> DISTEXT -> MATCH -> LEN
71
+ LIT -> LEN
72
+ Process trailer:
73
+ CHECK -> LENGTH -> DONE
74
+ */
75
+
76
+ /* state maintained between inflate() calls. Approximately 7K bytes. */
77
+ struct inflate_state {
78
+ inflate_mode mode; /* current inflate mode */
79
+ int last; /* true if processing last block */
80
+ int wrap; /* bit 0 true for zlib, bit 1 true for gzip */
81
+ int havedict; /* true if dictionary provided */
82
+ int flags; /* gzip header method and flags (0 if zlib) */
83
+ unsigned dmax; /* zlib header max distance (INFLATE_STRICT) */
84
+ unsigned long check; /* protected copy of check value */
85
+ unsigned long total; /* protected copy of output count */
86
+ gz_headerp head; /* where to save gzip header information */
87
+ /* sliding window */
88
+ unsigned wbits; /* log base 2 of requested window size */
89
+ unsigned wsize; /* window size or zero if not using window */
90
+ unsigned whave; /* valid bytes in the window */
91
+ unsigned write; /* window write index */
92
+ unsigned char FAR *window; /* allocated sliding window, if needed */
93
+ /* bit accumulator */
94
+ unsigned long hold; /* input bit accumulator */
95
+ unsigned bits; /* number of bits in "in" */
96
+ /* for string and stored block copying */
97
+ unsigned length; /* literal or length of data to copy */
98
+ unsigned offset; /* distance back to copy string from */
99
+ /* for table and code decoding */
100
+ unsigned extra; /* extra bits needed */
101
+ /* fixed and dynamic code tables */
102
+ code const FAR *lencode; /* starting table for length/literal codes */
103
+ code const FAR *distcode; /* starting table for distance codes */
104
+ unsigned lenbits; /* index bits for lencode */
105
+ unsigned distbits; /* index bits for distcode */
106
+ /* dynamic table building */
107
+ unsigned ncode; /* number of code length code lengths */
108
+ unsigned nlen; /* number of length code lengths */
109
+ unsigned ndist; /* number of distance code lengths */
110
+ unsigned have; /* number of code lengths in lens[] */
111
+ code FAR *next; /* next available space in codes[] */
112
+ unsigned short lens[320]; /* temporary storage for code lengths */
113
+ unsigned short work[288]; /* work area for code table building */
114
+ code codes[ENOUGH]; /* space for code tables */
115
+ };
@@ -0,0 +1,329 @@
1
+ /* inftrees.c -- generate Huffman trees for efficient decoding
2
+ * Copyright (C) 1995-2005 Mark Adler
3
+ * For conditions of distribution and use, see copyright notice in zlib.h
4
+ */
5
+
6
+ #include "zutil.h"
7
+ #include "inftrees.h"
8
+
9
+ #define MAXBITS 15
10
+
11
+ const char inflate_copyright[] =
12
+ " inflate 1.2.3 Copyright 1995-2005 Mark Adler ";
13
+ /*
14
+ If you use the zlib library in a product, an acknowledgment is welcome
15
+ in the documentation of your product. If for some reason you cannot
16
+ include such an acknowledgment, I would appreciate that you keep this
17
+ copyright string in the executable of your product.
18
+ */
19
+
20
+ /*
21
+ Build a set of tables to decode the provided canonical Huffman code.
22
+ The code lengths are lens[0..codes-1]. The result starts at *table,
23
+ whose indices are 0..2^bits-1. work is a writable array of at least
24
+ lens shorts, which is used as a work area. type is the type of code
25
+ to be generated, CODES, LENS, or DISTS. On return, zero is success,
26
+ -1 is an invalid code, and +1 means that ENOUGH isn't enough. table
27
+ on return points to the next available entry's address. bits is the
28
+ requested root table index bits, and on return it is the actual root
29
+ table index bits. It will differ if the request is greater than the
30
+ longest code or if it is less than the shortest code.
31
+ */
32
+ int inflate_table(type, lens, codes, table, bits, work)
33
+ codetype type;
34
+ unsigned short FAR *lens;
35
+ unsigned codes;
36
+ code FAR * FAR *table;
37
+ unsigned FAR *bits;
38
+ unsigned short FAR *work;
39
+ {
40
+ unsigned len; /* a code's length in bits */
41
+ unsigned sym; /* index of code symbols */
42
+ unsigned min, max; /* minimum and maximum code lengths */
43
+ unsigned root; /* number of index bits for root table */
44
+ unsigned curr; /* number of index bits for current table */
45
+ unsigned drop; /* code bits to drop for sub-table */
46
+ int left; /* number of prefix codes available */
47
+ unsigned used; /* code entries in table used */
48
+ unsigned huff; /* Huffman code */
49
+ unsigned incr; /* for incrementing code, index */
50
+ unsigned fill; /* index for replicating entries */
51
+ unsigned low; /* low bits for current root entry */
52
+ unsigned mask; /* mask for low root bits */
53
+ code this; /* table entry for duplication */
54
+ code FAR *next; /* next available space in table */
55
+ const unsigned short FAR *base; /* base value table to use */
56
+ const unsigned short FAR *extra; /* extra bits table to use */
57
+ int end; /* use base and extra for symbol > end */
58
+ unsigned short count[MAXBITS+1]; /* number of codes of each length */
59
+ unsigned short offs[MAXBITS+1]; /* offsets in table for each length */
60
+ static const unsigned short lbase[31] = { /* Length codes 257..285 base */
61
+ 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 15, 17, 19, 23, 27, 31,
62
+ 35, 43, 51, 59, 67, 83, 99, 115, 131, 163, 195, 227, 258, 0, 0};
63
+ static const unsigned short lext[31] = { /* Length codes 257..285 extra */
64
+ 16, 16, 16, 16, 16, 16, 16, 16, 17, 17, 17, 17, 18, 18, 18, 18,
65
+ 19, 19, 19, 19, 20, 20, 20, 20, 21, 21, 21, 21, 16, 201, 196};
66
+ static const unsigned short dbase[32] = { /* Distance codes 0..29 base */
67
+ 1, 2, 3, 4, 5, 7, 9, 13, 17, 25, 33, 49, 65, 97, 129, 193,
68
+ 257, 385, 513, 769, 1025, 1537, 2049, 3073, 4097, 6145,
69
+ 8193, 12289, 16385, 24577, 0, 0};
70
+ static const unsigned short dext[32] = { /* Distance codes 0..29 extra */
71
+ 16, 16, 16, 16, 17, 17, 18, 18, 19, 19, 20, 20, 21, 21, 22, 22,
72
+ 23, 23, 24, 24, 25, 25, 26, 26, 27, 27,
73
+ 28, 28, 29, 29, 64, 64};
74
+
75
+ /*
76
+ Process a set of code lengths to create a canonical Huffman code. The
77
+ code lengths are lens[0..codes-1]. Each length corresponds to the
78
+ symbols 0..codes-1. The Huffman code is generated by first sorting the
79
+ symbols by length from short to long, and retaining the symbol order
80
+ for codes with equal lengths. Then the code starts with all zero bits
81
+ for the first code of the shortest length, and the codes are integer
82
+ increments for the same length, and zeros are appended as the length
83
+ increases. For the deflate format, these bits are stored backwards
84
+ from their more natural integer increment ordering, and so when the
85
+ decoding tables are built in the large loop below, the integer codes
86
+ are incremented backwards.
87
+
88
+ This routine assumes, but does not check, that all of the entries in
89
+ lens[] are in the range 0..MAXBITS. The caller must assure this.
90
+ 1..MAXBITS is interpreted as that code length. zero means that that
91
+ symbol does not occur in this code.
92
+
93
+ The codes are sorted by computing a count of codes for each length,
94
+ creating from that a table of starting indices for each length in the
95
+ sorted table, and then entering the symbols in order in the sorted
96
+ table. The sorted table is work[], with that space being provided by
97
+ the caller.
98
+
99
+ The length counts are used for other purposes as well, i.e. finding
100
+ the minimum and maximum length codes, determining if there are any
101
+ codes at all, checking for a valid set of lengths, and looking ahead
102
+ at length counts to determine sub-table sizes when building the
103
+ decoding tables.
104
+ */
105
+
106
+ /* accumulate lengths for codes (assumes lens[] all in 0..MAXBITS) */
107
+ for (len = 0; len <= MAXBITS; len++)
108
+ count[len] = 0;
109
+ for (sym = 0; sym < codes; sym++)
110
+ count[lens[sym]]++;
111
+
112
+ /* bound code lengths, force root to be within code lengths */
113
+ root = *bits;
114
+ for (max = MAXBITS; max >= 1; max--)
115
+ if (count[max] != 0) break;
116
+ if (root > max) root = max;
117
+ if (max == 0) { /* no symbols to code at all */
118
+ this.op = (unsigned char)64; /* invalid code marker */
119
+ this.bits = (unsigned char)1;
120
+ this.val = (unsigned short)0;
121
+ *(*table)++ = this; /* make a table to force an error */
122
+ *(*table)++ = this;
123
+ *bits = 1;
124
+ return 0; /* no symbols, but wait for decoding to report error */
125
+ }
126
+ for (min = 1; min <= MAXBITS; min++)
127
+ if (count[min] != 0) break;
128
+ if (root < min) root = min;
129
+
130
+ /* check for an over-subscribed or incomplete set of lengths */
131
+ left = 1;
132
+ for (len = 1; len <= MAXBITS; len++) {
133
+ left <<= 1;
134
+ left -= count[len];
135
+ if (left < 0) return -1; /* over-subscribed */
136
+ }
137
+ if (left > 0 && (type == CODES || max != 1))
138
+ return -1; /* incomplete set */
139
+
140
+ /* generate offsets into symbol table for each length for sorting */
141
+ offs[1] = 0;
142
+ for (len = 1; len < MAXBITS; len++)
143
+ offs[len + 1] = offs[len] + count[len];
144
+
145
+ /* sort symbols by length, by symbol order within each length */
146
+ for (sym = 0; sym < codes; sym++)
147
+ if (lens[sym] != 0) work[offs[lens[sym]]++] = (unsigned short)sym;
148
+
149
+ /*
150
+ Create and fill in decoding tables. In this loop, the table being
151
+ filled is at next and has curr index bits. The code being used is huff
152
+ with length len. That code is converted to an index by dropping drop
153
+ bits off of the bottom. For codes where len is less than drop + curr,
154
+ those top drop + curr - len bits are incremented through all values to
155
+ fill the table with replicated entries.
156
+
157
+ root is the number of index bits for the root table. When len exceeds
158
+ root, sub-tables are created pointed to by the root entry with an index
159
+ of the low root bits of huff. This is saved in low to check for when a
160
+ new sub-table should be started. drop is zero when the root table is
161
+ being filled, and drop is root when sub-tables are being filled.
162
+
163
+ When a new sub-table is needed, it is necessary to look ahead in the
164
+ code lengths to determine what size sub-table is needed. The length
165
+ counts are used for this, and so count[] is decremented as codes are
166
+ entered in the tables.
167
+
168
+ used keeps track of how many table entries have been allocated from the
169
+ provided *table space. It is checked when a LENS table is being made
170
+ against the space in *table, ENOUGH, minus the maximum space needed by
171
+ the worst case distance code, MAXD. This should never happen, but the
172
+ sufficiency of ENOUGH has not been proven exhaustively, hence the check.
173
+ This assumes that when type == LENS, bits == 9.
174
+
175
+ sym increments through all symbols, and the loop terminates when
176
+ all codes of length max, i.e. all codes, have been processed. This
177
+ routine permits incomplete codes, so another loop after this one fills
178
+ in the rest of the decoding tables with invalid code markers.
179
+ */
180
+
181
+ /* set up for code type */
182
+ switch (type) {
183
+ case CODES:
184
+ base = extra = work; /* dummy value--not used */
185
+ end = 19;
186
+ break;
187
+ case LENS:
188
+ base = lbase;
189
+ base -= 257;
190
+ extra = lext;
191
+ extra -= 257;
192
+ end = 256;
193
+ break;
194
+ default: /* DISTS */
195
+ base = dbase;
196
+ extra = dext;
197
+ end = -1;
198
+ }
199
+
200
+ /* initialize state for loop */
201
+ huff = 0; /* starting code */
202
+ sym = 0; /* starting code symbol */
203
+ len = min; /* starting code length */
204
+ next = *table; /* current table to fill in */
205
+ curr = root; /* current table index bits */
206
+ drop = 0; /* current bits to drop from code for index */
207
+ low = (unsigned)(-1); /* trigger new sub-table when len > root */
208
+ used = 1U << root; /* use root table entries */
209
+ mask = used - 1; /* mask for comparing low */
210
+
211
+ /* check available table space */
212
+ if (type == LENS && used >= ENOUGH - MAXD)
213
+ return 1;
214
+
215
+ /* process all codes and make table entries */
216
+ for (;;) {
217
+ /* create table entry */
218
+ this.bits = (unsigned char)(len - drop);
219
+ if ((int)(work[sym]) < end) {
220
+ this.op = (unsigned char)0;
221
+ this.val = work[sym];
222
+ }
223
+ else if ((int)(work[sym]) > end) {
224
+ this.op = (unsigned char)(extra[work[sym]]);
225
+ this.val = base[work[sym]];
226
+ }
227
+ else {
228
+ this.op = (unsigned char)(32 + 64); /* end of block */
229
+ this.val = 0;
230
+ }
231
+
232
+ /* replicate for those indices with low len bits equal to huff */
233
+ incr = 1U << (len - drop);
234
+ fill = 1U << curr;
235
+ min = fill; /* save offset to next table */
236
+ do {
237
+ fill -= incr;
238
+ next[(huff >> drop) + fill] = this;
239
+ } while (fill != 0);
240
+
241
+ /* backwards increment the len-bit code huff */
242
+ incr = 1U << (len - 1);
243
+ while (huff & incr)
244
+ incr >>= 1;
245
+ if (incr != 0) {
246
+ huff &= incr - 1;
247
+ huff += incr;
248
+ }
249
+ else
250
+ huff = 0;
251
+
252
+ /* go to next symbol, update count, len */
253
+ sym++;
254
+ if (--(count[len]) == 0) {
255
+ if (len == max) break;
256
+ len = lens[work[sym]];
257
+ }
258
+
259
+ /* create new sub-table if needed */
260
+ if (len > root && (huff & mask) != low) {
261
+ /* if first time, transition to sub-tables */
262
+ if (drop == 0)
263
+ drop = root;
264
+
265
+ /* increment past last table */
266
+ next += min; /* here min is 1 << curr */
267
+
268
+ /* determine length of next table */
269
+ curr = len - drop;
270
+ left = (int)(1 << curr);
271
+ while (curr + drop < max) {
272
+ left -= count[curr + drop];
273
+ if (left <= 0) break;
274
+ curr++;
275
+ left <<= 1;
276
+ }
277
+
278
+ /* check for enough space */
279
+ used += 1U << curr;
280
+ if (type == LENS && used >= ENOUGH - MAXD)
281
+ return 1;
282
+
283
+ /* point entry in root table to sub-table */
284
+ low = huff & mask;
285
+ (*table)[low].op = (unsigned char)curr;
286
+ (*table)[low].bits = (unsigned char)root;
287
+ (*table)[low].val = (unsigned short)(next - *table);
288
+ }
289
+ }
290
+
291
+ /*
292
+ Fill in rest of table for incomplete codes. This loop is similar to the
293
+ loop above in incrementing huff for table indices. It is assumed that
294
+ len is equal to curr + drop, so there is no loop needed to increment
295
+ through high index bits. When the current sub-table is filled, the loop
296
+ drops back to the root table to fill in any remaining entries there.
297
+ */
298
+ this.op = (unsigned char)64; /* invalid code marker */
299
+ this.bits = (unsigned char)(len - drop);
300
+ this.val = (unsigned short)0;
301
+ while (huff != 0) {
302
+ /* when done with sub-table, drop back to root table */
303
+ if (drop != 0 && (huff & mask) != low) {
304
+ drop = 0;
305
+ len = root;
306
+ next = *table;
307
+ this.bits = (unsigned char)len;
308
+ }
309
+
310
+ /* put invalid code marker in table */
311
+ next[huff >> drop] = this;
312
+
313
+ /* backwards increment the len-bit code huff */
314
+ incr = 1U << (len - 1);
315
+ while (huff & incr)
316
+ incr >>= 1;
317
+ if (incr != 0) {
318
+ huff &= incr - 1;
319
+ huff += incr;
320
+ }
321
+ else
322
+ huff = 0;
323
+ }
324
+
325
+ /* set return parameters */
326
+ *table += used;
327
+ *bits = root;
328
+ return 0;
329
+ }
@@ -0,0 +1,55 @@
1
+ /* inftrees.h -- header to use inftrees.c
2
+ * Copyright (C) 1995-2005 Mark Adler
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
+ /* Structure for decoding tables. Each entry provides either the
12
+ information needed to do the operation requested by the code that
13
+ indexed that table entry, or it provides a pointer to another
14
+ table that indexes more bits of the code. op indicates whether
15
+ the entry is a pointer to another table, a literal, a length or
16
+ distance, an end-of-block, or an invalid code. For a table
17
+ pointer, the low four bits of op is the number of index bits of
18
+ that table. For a length or distance, the low four bits of op
19
+ is the number of extra bits to get after the code. bits is
20
+ the number of bits in this code or part of the code to drop off
21
+ of the bit buffer. val is the actual byte to output in the case
22
+ of a literal, the base length or distance, or the offset from
23
+ the current table to the next table. Each entry is four bytes. */
24
+ typedef struct {
25
+ unsigned char op; /* operation, extra bits, table bits */
26
+ unsigned char bits; /* bits in this part of the code */
27
+ unsigned short val; /* offset in table or code value */
28
+ } code;
29
+
30
+ /* op values as set by inflate_table():
31
+ 00000000 - literal
32
+ 0000tttt - table link, tttt != 0 is the number of table index bits
33
+ 0001eeee - length or distance, eeee is the number of extra bits
34
+ 01100000 - end of block
35
+ 01000000 - invalid code
36
+ */
37
+
38
+ /* Maximum size of dynamic tree. The maximum found in a long but non-
39
+ exhaustive search was 1444 code structures (852 for length/literals
40
+ and 592 for distances, the latter actually the result of an
41
+ exhaustive search). The true maximum is not known, but the value
42
+ below is more than safe. */
43
+ #define ENOUGH 2048
44
+ #define MAXD 592
45
+
46
+ /* Type of code to build for inftable() */
47
+ typedef enum {
48
+ CODES,
49
+ LENS,
50
+ DISTS
51
+ } codetype;
52
+
53
+ extern int inflate_table OF((codetype type, unsigned short FAR *lens,
54
+ unsigned codes, code FAR * FAR *table,
55
+ unsigned FAR *bits, unsigned short FAR *work));