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
File without changes
@@ -0,0 +1,26 @@
1
+ # Flate installation file
2
+ require 'mkmf'
3
+
4
+
5
+
6
+ if have_header("zlib.h") and have_library("z", "compress", "zlib.h")
7
+ puts "Using the system zlib library"
8
+ else
9
+ require 'fileutils'
10
+ puts "Using the private copy of zlib: copying the files from zlib/"
11
+ files = Dir["zlib/*.[ch]"]
12
+ for f in files do
13
+ target = File::basename(f)
14
+ begin
15
+ FileUtils::symlink(f, target)
16
+ rescue NotImplemented => e # For platforms when that isn't implemented
17
+ FileUtils::copy(f, target)
18
+ end
19
+ $distcleanfiles << target
20
+ end
21
+ end
22
+
23
+ # We add include directories
24
+ $INCFLAGS += " -I../includes"
25
+
26
+ create_makefile 'Flate'
@@ -1,12 +1,16 @@
1
1
  /* flate.c -- main file for Ruby extension
2
2
  */
3
3
 
4
- #include "../symbols.h"
5
- #include "../symbols.c"
6
- #include "zlib.h"
4
+ /* Internal files */
5
+ #include "symbols.h"
6
+ #include "symbols.c"
7
7
  #include "flate_intern.h"
8
8
 
9
9
  #include <defs.h>
10
+ /* End of internal include files */
11
+
12
+ #include "zlib.h"
13
+
10
14
  /*
11
15
  Copyright (C) 2005 Bill Paxton
12
16
 
File without changes
File without changes
@@ -0,0 +1,149 @@
1
+ /* adler32.c -- compute the Adler-32 checksum of a data stream
2
+ * Copyright (C) 1995-2004 Mark Adler
3
+ * For conditions of distribution and use, see copyright notice in zlib.h
4
+ */
5
+
6
+ /* @(#) $Id$ */
7
+
8
+ #define ZLIB_INTERNAL
9
+ #include "zlib.h"
10
+
11
+ #define BASE 65521UL /* largest prime smaller than 65536 */
12
+ #define NMAX 5552
13
+ /* NMAX is the largest n such that 255n(n+1)/2 + (n+1)(BASE-1) <= 2^32-1 */
14
+
15
+ #define DO1(buf,i) {adler += (buf)[i]; sum2 += adler;}
16
+ #define DO2(buf,i) DO1(buf,i); DO1(buf,i+1);
17
+ #define DO4(buf,i) DO2(buf,i); DO2(buf,i+2);
18
+ #define DO8(buf,i) DO4(buf,i); DO4(buf,i+4);
19
+ #define DO16(buf) DO8(buf,0); DO8(buf,8);
20
+
21
+ /* use NO_DIVIDE if your processor does not do division in hardware */
22
+ #ifdef NO_DIVIDE
23
+ # define MOD(a) \
24
+ do { \
25
+ if (a >= (BASE << 16)) a -= (BASE << 16); \
26
+ if (a >= (BASE << 15)) a -= (BASE << 15); \
27
+ if (a >= (BASE << 14)) a -= (BASE << 14); \
28
+ if (a >= (BASE << 13)) a -= (BASE << 13); \
29
+ if (a >= (BASE << 12)) a -= (BASE << 12); \
30
+ if (a >= (BASE << 11)) a -= (BASE << 11); \
31
+ if (a >= (BASE << 10)) a -= (BASE << 10); \
32
+ if (a >= (BASE << 9)) a -= (BASE << 9); \
33
+ if (a >= (BASE << 8)) a -= (BASE << 8); \
34
+ if (a >= (BASE << 7)) a -= (BASE << 7); \
35
+ if (a >= (BASE << 6)) a -= (BASE << 6); \
36
+ if (a >= (BASE << 5)) a -= (BASE << 5); \
37
+ if (a >= (BASE << 4)) a -= (BASE << 4); \
38
+ if (a >= (BASE << 3)) a -= (BASE << 3); \
39
+ if (a >= (BASE << 2)) a -= (BASE << 2); \
40
+ if (a >= (BASE << 1)) a -= (BASE << 1); \
41
+ if (a >= BASE) a -= BASE; \
42
+ } while (0)
43
+ # define MOD4(a) \
44
+ do { \
45
+ if (a >= (BASE << 4)) a -= (BASE << 4); \
46
+ if (a >= (BASE << 3)) a -= (BASE << 3); \
47
+ if (a >= (BASE << 2)) a -= (BASE << 2); \
48
+ if (a >= (BASE << 1)) a -= (BASE << 1); \
49
+ if (a >= BASE) a -= BASE; \
50
+ } while (0)
51
+ #else
52
+ # define MOD(a) a %= BASE
53
+ # define MOD4(a) a %= BASE
54
+ #endif
55
+
56
+ /* ========================================================================= */
57
+ uLong ZEXPORT adler32(adler, buf, len)
58
+ uLong adler;
59
+ const Bytef *buf;
60
+ uInt len;
61
+ {
62
+ unsigned long sum2;
63
+ unsigned n;
64
+
65
+ /* split Adler-32 into component sums */
66
+ sum2 = (adler >> 16) & 0xffff;
67
+ adler &= 0xffff;
68
+
69
+ /* in case user likes doing a byte at a time, keep it fast */
70
+ if (len == 1) {
71
+ adler += buf[0];
72
+ if (adler >= BASE)
73
+ adler -= BASE;
74
+ sum2 += adler;
75
+ if (sum2 >= BASE)
76
+ sum2 -= BASE;
77
+ return adler | (sum2 << 16);
78
+ }
79
+
80
+ /* initial Adler-32 value (deferred check for len == 1 speed) */
81
+ if (buf == Z_NULL)
82
+ return 1L;
83
+
84
+ /* in case short lengths are provided, keep it somewhat fast */
85
+ if (len < 16) {
86
+ while (len--) {
87
+ adler += *buf++;
88
+ sum2 += adler;
89
+ }
90
+ if (adler >= BASE)
91
+ adler -= BASE;
92
+ MOD4(sum2); /* only added so many BASE's */
93
+ return adler | (sum2 << 16);
94
+ }
95
+
96
+ /* do length NMAX blocks -- requires just one modulo operation */
97
+ while (len >= NMAX) {
98
+ len -= NMAX;
99
+ n = NMAX / 16; /* NMAX is divisible by 16 */
100
+ do {
101
+ DO16(buf); /* 16 sums unrolled */
102
+ buf += 16;
103
+ } while (--n);
104
+ MOD(adler);
105
+ MOD(sum2);
106
+ }
107
+
108
+ /* do remaining bytes (less than NMAX, still just one modulo) */
109
+ if (len) { /* avoid modulos if none remaining */
110
+ while (len >= 16) {
111
+ len -= 16;
112
+ DO16(buf);
113
+ buf += 16;
114
+ }
115
+ while (len--) {
116
+ adler += *buf++;
117
+ sum2 += adler;
118
+ }
119
+ MOD(adler);
120
+ MOD(sum2);
121
+ }
122
+
123
+ /* return recombined sums */
124
+ return adler | (sum2 << 16);
125
+ }
126
+
127
+ /* ========================================================================= */
128
+ uLong ZEXPORT adler32_combine(adler1, adler2, len2)
129
+ uLong adler1;
130
+ uLong adler2;
131
+ z_off_t len2;
132
+ {
133
+ unsigned long sum1;
134
+ unsigned long sum2;
135
+ unsigned rem;
136
+
137
+ /* the derivation of this formula is left as an exercise for the reader */
138
+ rem = (unsigned)(len2 % BASE);
139
+ sum1 = adler1 & 0xffff;
140
+ sum2 = rem * sum1;
141
+ MOD(sum2);
142
+ sum1 += (adler2 & 0xffff) + BASE - 1;
143
+ sum2 += ((adler1 >> 16) & 0xffff) + ((adler2 >> 16) & 0xffff) + BASE - rem;
144
+ if (sum1 > BASE) sum1 -= BASE;
145
+ if (sum1 > BASE) sum1 -= BASE;
146
+ if (sum2 > (BASE << 1)) sum2 -= (BASE << 1);
147
+ if (sum2 > BASE) sum2 -= BASE;
148
+ return sum1 | (sum2 << 16);
149
+ }
@@ -0,0 +1,79 @@
1
+ /* compress.c -- compress a memory buffer
2
+ * Copyright (C) 1995-2003 Jean-loup Gailly.
3
+ * For conditions of distribution and use, see copyright notice in zlib.h
4
+ */
5
+
6
+ /* @(#) $Id$ */
7
+
8
+ #define ZLIB_INTERNAL
9
+ #include "zlib.h"
10
+
11
+ /* ===========================================================================
12
+ Compresses the source buffer into the destination buffer. The level
13
+ parameter has the same meaning as in deflateInit. sourceLen is the byte
14
+ length of the source buffer. Upon entry, destLen is the total size of the
15
+ destination buffer, which must be at least 0.1% larger than sourceLen plus
16
+ 12 bytes. Upon exit, destLen is the actual size of the compressed buffer.
17
+
18
+ compress2 returns Z_OK if success, Z_MEM_ERROR if there was not enough
19
+ memory, Z_BUF_ERROR if there was not enough room in the output buffer,
20
+ Z_STREAM_ERROR if the level parameter is invalid.
21
+ */
22
+ int ZEXPORT compress2 (dest, destLen, source, sourceLen, level)
23
+ Bytef *dest;
24
+ uLongf *destLen;
25
+ const Bytef *source;
26
+ uLong sourceLen;
27
+ int level;
28
+ {
29
+ z_stream stream;
30
+ int err;
31
+
32
+ stream.next_in = (Bytef*)source;
33
+ stream.avail_in = (uInt)sourceLen;
34
+ #ifdef MAXSEG_64K
35
+ /* Check for source > 64K on 16-bit machine: */
36
+ if ((uLong)stream.avail_in != sourceLen) return Z_BUF_ERROR;
37
+ #endif
38
+ stream.next_out = dest;
39
+ stream.avail_out = (uInt)*destLen;
40
+ if ((uLong)stream.avail_out != *destLen) return Z_BUF_ERROR;
41
+
42
+ stream.zalloc = (alloc_func)0;
43
+ stream.zfree = (free_func)0;
44
+ stream.opaque = (voidpf)0;
45
+
46
+ err = deflateInit(&stream, level);
47
+ if (err != Z_OK) return err;
48
+
49
+ err = deflate(&stream, Z_FINISH);
50
+ if (err != Z_STREAM_END) {
51
+ deflateEnd(&stream);
52
+ return err == Z_OK ? Z_BUF_ERROR : err;
53
+ }
54
+ *destLen = stream.total_out;
55
+
56
+ err = deflateEnd(&stream);
57
+ return err;
58
+ }
59
+
60
+ /* ===========================================================================
61
+ */
62
+ int ZEXPORT compress (dest, destLen, source, sourceLen)
63
+ Bytef *dest;
64
+ uLongf *destLen;
65
+ const Bytef *source;
66
+ uLong sourceLen;
67
+ {
68
+ return compress2(dest, destLen, source, sourceLen, Z_DEFAULT_COMPRESSION);
69
+ }
70
+
71
+ /* ===========================================================================
72
+ If the default memLevel or windowBits for deflateInit() is changed, then
73
+ this function needs to be updated.
74
+ */
75
+ uLong ZEXPORT compressBound (sourceLen)
76
+ uLong sourceLen;
77
+ {
78
+ return sourceLen + (sourceLen >> 12) + (sourceLen >> 14) + 11;
79
+ }
@@ -0,0 +1,423 @@
1
+ /* crc32.c -- compute the CRC-32 of a data stream
2
+ * Copyright (C) 1995-2005 Mark Adler
3
+ * For conditions of distribution and use, see copyright notice in zlib.h
4
+ *
5
+ * Thanks to Rodney Brown <rbrown64@csc.com.au> for his contribution of faster
6
+ * CRC methods: exclusive-oring 32 bits of data at a time, and pre-computing
7
+ * tables for updating the shift register in one step with three exclusive-ors
8
+ * instead of four steps with four exclusive-ors. This results in about a
9
+ * factor of two increase in speed on a Power PC G4 (PPC7455) using gcc -O3.
10
+ */
11
+
12
+ /* @(#) $Id$ */
13
+
14
+ /*
15
+ Note on the use of DYNAMIC_CRC_TABLE: there is no mutex or semaphore
16
+ protection on the static variables used to control the first-use generation
17
+ of the crc tables. Therefore, if you #define DYNAMIC_CRC_TABLE, you should
18
+ first call get_crc_table() to initialize the tables before allowing more than
19
+ one thread to use crc32().
20
+ */
21
+
22
+ #ifdef MAKECRCH
23
+ # include <stdio.h>
24
+ # ifndef DYNAMIC_CRC_TABLE
25
+ # define DYNAMIC_CRC_TABLE
26
+ # endif /* !DYNAMIC_CRC_TABLE */
27
+ #endif /* MAKECRCH */
28
+
29
+ #include "zutil.h" /* for STDC and FAR definitions */
30
+
31
+ #define local static
32
+
33
+ /* Find a four-byte integer type for crc32_little() and crc32_big(). */
34
+ #ifndef NOBYFOUR
35
+ # ifdef STDC /* need ANSI C limits.h to determine sizes */
36
+ # include <limits.h>
37
+ # define BYFOUR
38
+ # if (UINT_MAX == 0xffffffffUL)
39
+ typedef unsigned int u4;
40
+ # else
41
+ # if (ULONG_MAX == 0xffffffffUL)
42
+ typedef unsigned long u4;
43
+ # else
44
+ # if (USHRT_MAX == 0xffffffffUL)
45
+ typedef unsigned short u4;
46
+ # else
47
+ # undef BYFOUR /* can't find a four-byte integer type! */
48
+ # endif
49
+ # endif
50
+ # endif
51
+ # endif /* STDC */
52
+ #endif /* !NOBYFOUR */
53
+
54
+ /* Definitions for doing the crc four data bytes at a time. */
55
+ #ifdef BYFOUR
56
+ # define REV(w) (((w)>>24)+(((w)>>8)&0xff00)+ \
57
+ (((w)&0xff00)<<8)+(((w)&0xff)<<24))
58
+ local unsigned long crc32_little OF((unsigned long,
59
+ const unsigned char FAR *, unsigned));
60
+ local unsigned long crc32_big OF((unsigned long,
61
+ const unsigned char FAR *, unsigned));
62
+ # define TBLS 8
63
+ #else
64
+ # define TBLS 1
65
+ #endif /* BYFOUR */
66
+
67
+ /* Local functions for crc concatenation */
68
+ local unsigned long gf2_matrix_times OF((unsigned long *mat,
69
+ unsigned long vec));
70
+ local void gf2_matrix_square OF((unsigned long *square, unsigned long *mat));
71
+
72
+ #ifdef DYNAMIC_CRC_TABLE
73
+
74
+ local volatile int crc_table_empty = 1;
75
+ local unsigned long FAR crc_table[TBLS][256];
76
+ local void make_crc_table OF((void));
77
+ #ifdef MAKECRCH
78
+ local void write_table OF((FILE *, const unsigned long FAR *));
79
+ #endif /* MAKECRCH */
80
+ /*
81
+ Generate tables for a byte-wise 32-bit CRC calculation on the polynomial:
82
+ x^32+x^26+x^23+x^22+x^16+x^12+x^11+x^10+x^8+x^7+x^5+x^4+x^2+x+1.
83
+
84
+ Polynomials over GF(2) are represented in binary, one bit per coefficient,
85
+ with the lowest powers in the most significant bit. Then adding polynomials
86
+ is just exclusive-or, and multiplying a polynomial by x is a right shift by
87
+ one. If we call the above polynomial p, and represent a byte as the
88
+ polynomial q, also with the lowest power in the most significant bit (so the
89
+ byte 0xb1 is the polynomial x^7+x^3+x+1), then the CRC is (q*x^32) mod p,
90
+ where a mod b means the remainder after dividing a by b.
91
+
92
+ This calculation is done using the shift-register method of multiplying and
93
+ taking the remainder. The register is initialized to zero, and for each
94
+ incoming bit, x^32 is added mod p to the register if the bit is a one (where
95
+ x^32 mod p is p+x^32 = x^26+...+1), and the register is multiplied mod p by
96
+ x (which is shifting right by one and adding x^32 mod p if the bit shifted
97
+ out is a one). We start with the highest power (least significant bit) of
98
+ q and repeat for all eight bits of q.
99
+
100
+ The first table is simply the CRC of all possible eight bit values. This is
101
+ all the information needed to generate CRCs on data a byte at a time for all
102
+ combinations of CRC register values and incoming bytes. The remaining tables
103
+ allow for word-at-a-time CRC calculation for both big-endian and little-
104
+ endian machines, where a word is four bytes.
105
+ */
106
+ local void make_crc_table()
107
+ {
108
+ unsigned long c;
109
+ int n, k;
110
+ unsigned long poly; /* polynomial exclusive-or pattern */
111
+ /* terms of polynomial defining this crc (except x^32): */
112
+ static volatile int first = 1; /* flag to limit concurrent making */
113
+ static const unsigned char p[] = {0,1,2,4,5,7,8,10,11,12,16,22,23,26};
114
+
115
+ /* See if another task is already doing this (not thread-safe, but better
116
+ than nothing -- significantly reduces duration of vulnerability in
117
+ case the advice about DYNAMIC_CRC_TABLE is ignored) */
118
+ if (first) {
119
+ first = 0;
120
+
121
+ /* make exclusive-or pattern from polynomial (0xedb88320UL) */
122
+ poly = 0UL;
123
+ for (n = 0; n < sizeof(p)/sizeof(unsigned char); n++)
124
+ poly |= 1UL << (31 - p[n]);
125
+
126
+ /* generate a crc for every 8-bit value */
127
+ for (n = 0; n < 256; n++) {
128
+ c = (unsigned long)n;
129
+ for (k = 0; k < 8; k++)
130
+ c = c & 1 ? poly ^ (c >> 1) : c >> 1;
131
+ crc_table[0][n] = c;
132
+ }
133
+
134
+ #ifdef BYFOUR
135
+ /* generate crc for each value followed by one, two, and three zeros,
136
+ and then the byte reversal of those as well as the first table */
137
+ for (n = 0; n < 256; n++) {
138
+ c = crc_table[0][n];
139
+ crc_table[4][n] = REV(c);
140
+ for (k = 1; k < 4; k++) {
141
+ c = crc_table[0][c & 0xff] ^ (c >> 8);
142
+ crc_table[k][n] = c;
143
+ crc_table[k + 4][n] = REV(c);
144
+ }
145
+ }
146
+ #endif /* BYFOUR */
147
+
148
+ crc_table_empty = 0;
149
+ }
150
+ else { /* not first */
151
+ /* wait for the other guy to finish (not efficient, but rare) */
152
+ while (crc_table_empty)
153
+ ;
154
+ }
155
+
156
+ #ifdef MAKECRCH
157
+ /* write out CRC tables to crc32.h */
158
+ {
159
+ FILE *out;
160
+
161
+ out = fopen("crc32.h", "w");
162
+ if (out == NULL) return;
163
+ fprintf(out, "/* crc32.h -- tables for rapid CRC calculation\n");
164
+ fprintf(out, " * Generated automatically by crc32.c\n */\n\n");
165
+ fprintf(out, "local const unsigned long FAR ");
166
+ fprintf(out, "crc_table[TBLS][256] =\n{\n {\n");
167
+ write_table(out, crc_table[0]);
168
+ # ifdef BYFOUR
169
+ fprintf(out, "#ifdef BYFOUR\n");
170
+ for (k = 1; k < 8; k++) {
171
+ fprintf(out, " },\n {\n");
172
+ write_table(out, crc_table[k]);
173
+ }
174
+ fprintf(out, "#endif\n");
175
+ # endif /* BYFOUR */
176
+ fprintf(out, " }\n};\n");
177
+ fclose(out);
178
+ }
179
+ #endif /* MAKECRCH */
180
+ }
181
+
182
+ #ifdef MAKECRCH
183
+ local void write_table(out, table)
184
+ FILE *out;
185
+ const unsigned long FAR *table;
186
+ {
187
+ int n;
188
+
189
+ for (n = 0; n < 256; n++)
190
+ fprintf(out, "%s0x%08lxUL%s", n % 5 ? "" : " ", table[n],
191
+ n == 255 ? "\n" : (n % 5 == 4 ? ",\n" : ", "));
192
+ }
193
+ #endif /* MAKECRCH */
194
+
195
+ #else /* !DYNAMIC_CRC_TABLE */
196
+ /* ========================================================================
197
+ * Tables of CRC-32s of all single-byte values, made by make_crc_table().
198
+ */
199
+ #include "crc32.h"
200
+ #endif /* DYNAMIC_CRC_TABLE */
201
+
202
+ /* =========================================================================
203
+ * This function can be used by asm versions of crc32()
204
+ */
205
+ const unsigned long FAR * ZEXPORT get_crc_table()
206
+ {
207
+ #ifdef DYNAMIC_CRC_TABLE
208
+ if (crc_table_empty)
209
+ make_crc_table();
210
+ #endif /* DYNAMIC_CRC_TABLE */
211
+ return (const unsigned long FAR *)crc_table;
212
+ }
213
+
214
+ /* ========================================================================= */
215
+ #define DO1 crc = crc_table[0][((int)crc ^ (*buf++)) & 0xff] ^ (crc >> 8)
216
+ #define DO8 DO1; DO1; DO1; DO1; DO1; DO1; DO1; DO1
217
+
218
+ /* ========================================================================= */
219
+ unsigned long ZEXPORT crc32(crc, buf, len)
220
+ unsigned long crc;
221
+ const unsigned char FAR *buf;
222
+ unsigned len;
223
+ {
224
+ if (buf == Z_NULL) return 0UL;
225
+
226
+ #ifdef DYNAMIC_CRC_TABLE
227
+ if (crc_table_empty)
228
+ make_crc_table();
229
+ #endif /* DYNAMIC_CRC_TABLE */
230
+
231
+ #ifdef BYFOUR
232
+ if (sizeof(void *) == sizeof(ptrdiff_t)) {
233
+ u4 endian;
234
+
235
+ endian = 1;
236
+ if (*((unsigned char *)(&endian)))
237
+ return crc32_little(crc, buf, len);
238
+ else
239
+ return crc32_big(crc, buf, len);
240
+ }
241
+ #endif /* BYFOUR */
242
+ crc = crc ^ 0xffffffffUL;
243
+ while (len >= 8) {
244
+ DO8;
245
+ len -= 8;
246
+ }
247
+ if (len) do {
248
+ DO1;
249
+ } while (--len);
250
+ return crc ^ 0xffffffffUL;
251
+ }
252
+
253
+ #ifdef BYFOUR
254
+
255
+ /* ========================================================================= */
256
+ #define DOLIT4 c ^= *buf4++; \
257
+ c = crc_table[3][c & 0xff] ^ crc_table[2][(c >> 8) & 0xff] ^ \
258
+ crc_table[1][(c >> 16) & 0xff] ^ crc_table[0][c >> 24]
259
+ #define DOLIT32 DOLIT4; DOLIT4; DOLIT4; DOLIT4; DOLIT4; DOLIT4; DOLIT4; DOLIT4
260
+
261
+ /* ========================================================================= */
262
+ local unsigned long crc32_little(crc, buf, len)
263
+ unsigned long crc;
264
+ const unsigned char FAR *buf;
265
+ unsigned len;
266
+ {
267
+ register u4 c;
268
+ register const u4 FAR *buf4;
269
+
270
+ c = (u4)crc;
271
+ c = ~c;
272
+ while (len && ((ptrdiff_t)buf & 3)) {
273
+ c = crc_table[0][(c ^ *buf++) & 0xff] ^ (c >> 8);
274
+ len--;
275
+ }
276
+
277
+ buf4 = (const u4 FAR *)(const void FAR *)buf;
278
+ while (len >= 32) {
279
+ DOLIT32;
280
+ len -= 32;
281
+ }
282
+ while (len >= 4) {
283
+ DOLIT4;
284
+ len -= 4;
285
+ }
286
+ buf = (const unsigned char FAR *)buf4;
287
+
288
+ if (len) do {
289
+ c = crc_table[0][(c ^ *buf++) & 0xff] ^ (c >> 8);
290
+ } while (--len);
291
+ c = ~c;
292
+ return (unsigned long)c;
293
+ }
294
+
295
+ /* ========================================================================= */
296
+ #define DOBIG4 c ^= *++buf4; \
297
+ c = crc_table[4][c & 0xff] ^ crc_table[5][(c >> 8) & 0xff] ^ \
298
+ crc_table[6][(c >> 16) & 0xff] ^ crc_table[7][c >> 24]
299
+ #define DOBIG32 DOBIG4; DOBIG4; DOBIG4; DOBIG4; DOBIG4; DOBIG4; DOBIG4; DOBIG4
300
+
301
+ /* ========================================================================= */
302
+ local unsigned long crc32_big(crc, buf, len)
303
+ unsigned long crc;
304
+ const unsigned char FAR *buf;
305
+ unsigned len;
306
+ {
307
+ register u4 c;
308
+ register const u4 FAR *buf4;
309
+
310
+ c = REV((u4)crc);
311
+ c = ~c;
312
+ while (len && ((ptrdiff_t)buf & 3)) {
313
+ c = crc_table[4][(c >> 24) ^ *buf++] ^ (c << 8);
314
+ len--;
315
+ }
316
+
317
+ buf4 = (const u4 FAR *)(const void FAR *)buf;
318
+ buf4--;
319
+ while (len >= 32) {
320
+ DOBIG32;
321
+ len -= 32;
322
+ }
323
+ while (len >= 4) {
324
+ DOBIG4;
325
+ len -= 4;
326
+ }
327
+ buf4++;
328
+ buf = (const unsigned char FAR *)buf4;
329
+
330
+ if (len) do {
331
+ c = crc_table[4][(c >> 24) ^ *buf++] ^ (c << 8);
332
+ } while (--len);
333
+ c = ~c;
334
+ return (unsigned long)(REV(c));
335
+ }
336
+
337
+ #endif /* BYFOUR */
338
+
339
+ #define GF2_DIM 32 /* dimension of GF(2) vectors (length of CRC) */
340
+
341
+ /* ========================================================================= */
342
+ local unsigned long gf2_matrix_times(mat, vec)
343
+ unsigned long *mat;
344
+ unsigned long vec;
345
+ {
346
+ unsigned long sum;
347
+
348
+ sum = 0;
349
+ while (vec) {
350
+ if (vec & 1)
351
+ sum ^= *mat;
352
+ vec >>= 1;
353
+ mat++;
354
+ }
355
+ return sum;
356
+ }
357
+
358
+ /* ========================================================================= */
359
+ local void gf2_matrix_square(square, mat)
360
+ unsigned long *square;
361
+ unsigned long *mat;
362
+ {
363
+ int n;
364
+
365
+ for (n = 0; n < GF2_DIM; n++)
366
+ square[n] = gf2_matrix_times(mat, mat[n]);
367
+ }
368
+
369
+ /* ========================================================================= */
370
+ uLong ZEXPORT crc32_combine(crc1, crc2, len2)
371
+ uLong crc1;
372
+ uLong crc2;
373
+ z_off_t len2;
374
+ {
375
+ int n;
376
+ unsigned long row;
377
+ unsigned long even[GF2_DIM]; /* even-power-of-two zeros operator */
378
+ unsigned long odd[GF2_DIM]; /* odd-power-of-two zeros operator */
379
+
380
+ /* degenerate case */
381
+ if (len2 == 0)
382
+ return crc1;
383
+
384
+ /* put operator for one zero bit in odd */
385
+ odd[0] = 0xedb88320L; /* CRC-32 polynomial */
386
+ row = 1;
387
+ for (n = 1; n < GF2_DIM; n++) {
388
+ odd[n] = row;
389
+ row <<= 1;
390
+ }
391
+
392
+ /* put operator for two zero bits in even */
393
+ gf2_matrix_square(even, odd);
394
+
395
+ /* put operator for four zero bits in odd */
396
+ gf2_matrix_square(odd, even);
397
+
398
+ /* apply len2 zeros to crc1 (first square will put the operator for one
399
+ zero byte, eight zero bits, in even) */
400
+ do {
401
+ /* apply zeros operator for this bit of len2 */
402
+ gf2_matrix_square(even, odd);
403
+ if (len2 & 1)
404
+ crc1 = gf2_matrix_times(even, crc1);
405
+ len2 >>= 1;
406
+
407
+ /* if no more bits set, then done */
408
+ if (len2 == 0)
409
+ break;
410
+
411
+ /* another iteration of the loop with odd and even swapped */
412
+ gf2_matrix_square(odd, even);
413
+ if (len2 & 1)
414
+ crc1 = gf2_matrix_times(odd, crc1);
415
+ len2 >>= 1;
416
+
417
+ /* if no more bits set, then done */
418
+ } while (len2 != 0);
419
+
420
+ /* return combined crc */
421
+ crc1 ^= crc2;
422
+ return crc1;
423
+ }