tioga 1.11 → 1.13
Sign up to get free protection for your applications and to get access to all the features.
- data/Tioga_README +58 -35
- data/{split/scripts → bin}/tioga +1 -1
- data/{split → ext/Dobjects}/Dtable/dtable.c +81 -15
- data/{split → ext/Dobjects}/Dtable/dtable_intern.h +0 -0
- data/ext/Dobjects/Dtable/extconf.rb +7 -0
- data/{split → ext/Dobjects}/Dtable/include/dtable.h +0 -0
- data/{split → ext/Dobjects}/Dvector/dvector.c +361 -51
- data/{split → ext/Dobjects}/Dvector/dvector_intern.h +0 -0
- data/ext/Dobjects/Dvector/extconf.rb +22 -0
- data/{split/Dtable → ext/Dobjects/Dvector/include}/dvector.h +0 -0
- data/ext/Dobjects/Function/extconf.rb +7 -0
- data/{split → ext/Dobjects}/Function/function.c +636 -11
- data/{split → ext/Dobjects}/Function/joint_qsort.c +0 -0
- data/ext/Flate/extconf.rb +26 -0
- data/{split → ext}/Flate/flate.c +7 -3
- data/{split → ext}/Flate/flate_intern.h +0 -0
- data/{split → ext}/Flate/include/flate.h +0 -0
- data/ext/Flate/zlib/adler32.c +149 -0
- data/ext/Flate/zlib/compress.c +79 -0
- data/ext/Flate/zlib/crc32.c +423 -0
- data/ext/Flate/zlib/crc32.h +441 -0
- data/ext/Flate/zlib/deflate.c +1736 -0
- data/ext/Flate/zlib/deflate.h +331 -0
- data/ext/Flate/zlib/gzio.c +1026 -0
- data/ext/Flate/zlib/infback.c +623 -0
- data/ext/Flate/zlib/inffast.c +318 -0
- data/ext/Flate/zlib/inffast.h +11 -0
- data/ext/Flate/zlib/inffixed.h +94 -0
- data/ext/Flate/zlib/inflate.c +1368 -0
- data/ext/Flate/zlib/inflate.h +115 -0
- data/ext/Flate/zlib/inftrees.c +329 -0
- data/ext/Flate/zlib/inftrees.h +55 -0
- data/ext/Flate/zlib/trees.c +1219 -0
- data/ext/Flate/zlib/trees.h +128 -0
- data/ext/Flate/zlib/uncompr.c +61 -0
- data/ext/Flate/zlib/zlib.h +1357 -0
- data/ext/Flate/zlib/zutil.c +318 -0
- data/ext/Flate/zlib/zutil.h +269 -0
- data/ext/Tioga/FigureMaker/__shared_axes.c +1373 -0
- data/ext/Tioga/FigureMaker/__shared_makers.c +1303 -0
- data/{split/Tioga/pdf_font_dicts.c → ext/Tioga/FigureMaker/__shared_pdf_font_dicts.c} +0 -0
- data/{split/Tioga/pdfcolor.c → ext/Tioga/FigureMaker/__shared_pdfcolor.c} +0 -0
- data/{split/Tioga/pdfcoords.c → ext/Tioga/FigureMaker/__shared_pdfcoords.c} +0 -0
- data/{split/Tioga/pdffile.c → ext/Tioga/FigureMaker/__shared_pdffile.c} +0 -0
- data/{split/Tioga/pdfimage.c → ext/Tioga/FigureMaker/__shared_pdfimage.c} +0 -0
- data/{split/Tioga/pdfpath.c → ext/Tioga/FigureMaker/__shared_pdfpath.c} +0 -0
- data/{split/Tioga/pdftext.c → ext/Tioga/FigureMaker/__shared_pdftext.c} +0 -0
- data/{split/Tioga/texout.c → ext/Tioga/FigureMaker/__shared_texout.c} +0 -0
- data/ext/Tioga/FigureMaker/extconf.rb +7 -0
- data/{split/Tioga → ext/Tioga/FigureMaker}/figures.c +14 -2
- data/{split/Tioga → ext/Tioga/FigureMaker}/figures.h +0 -0
- data/{split/Tioga → ext/Tioga/FigureMaker}/generic.c +1 -2
- data/{split/Tioga → ext/Tioga/FigureMaker}/generic.h +0 -1
- data/{split/Tioga → ext/Tioga/FigureMaker}/init.c +0 -0
- data/{split/Tioga → ext/Tioga/FigureMaker}/pdfs.h +0 -0
- data/{split/Tioga → ext/Tioga/FigureMaker/shared}/axes.c +32 -7
- data/{split/Tioga → ext/Tioga/FigureMaker/shared}/makers.c +2 -2
- data/ext/Tioga/FigureMaker/shared/pdf_font_dicts.c +18253 -0
- data/ext/Tioga/FigureMaker/shared/pdfcolor.c +904 -0
- data/ext/Tioga/FigureMaker/shared/pdfcoords.c +518 -0
- data/ext/Tioga/FigureMaker/shared/pdffile.c +451 -0
- data/ext/Tioga/FigureMaker/shared/pdfimage.c +539 -0
- data/ext/Tioga/FigureMaker/shared/pdfpath.c +766 -0
- data/ext/Tioga/FigureMaker/shared/pdftext.c +710 -0
- data/ext/Tioga/FigureMaker/shared/texout.c +533 -0
- data/{split/Tioga → ext/Tioga/FigureMaker}/wrappers.c +5 -5
- data/{split/Tioga → ext/Tioga/FigureMaker}/wrappers.h +0 -0
- data/{split/Dtable → ext/includes}/defs.h +0 -0
- data/{split/Dtable → ext/includes}/namespace.h +0 -0
- data/{split/Dtable → ext/includes}/safe_double.h +0 -0
- data/{split → ext/includes}/symbols.c +0 -1
- data/{split/Dtable → ext/includes}/symbols.h +0 -0
- data/{split/Dtable/lib → lib/Dobjects}/Dtable_extras.rb +0 -0
- data/{split/Dvector/lib → lib/Dobjects}/Dvector_extras.rb +1 -0
- data/{split/Function/lib → lib/Dobjects}/Function_extras.rb +0 -0
- data/{split/Dvector/lib → lib/Dobjects}/Numeric_extras.rb +0 -0
- data/{split/Tioga/lib → lib/Tioga}/Arcs_and_Circles.rb +0 -0
- data/{split/Tioga/lib → lib/Tioga}/ColorConstants.rb +0 -0
- data/{split/Tioga/lib → lib/Tioga}/Colorbars.rb +0 -0
- data/{split/Tioga/lib → lib/Tioga}/Colormaps.rb +0 -0
- data/{split/Tioga/lib → lib/Tioga}/Coordinate_Conversions.rb +0 -0
- data/{split/Tioga/lib → lib/Tioga}/Creating_Paths.rb +0 -0
- data/{split/Tioga/lib → lib/Tioga}/Doc.rb +0 -0
- data/{split/Tioga/lib → lib/Tioga}/Executive.rb +0 -0
- data/{split/Tioga/lib → lib/Tioga}/FigMkr.rb +13 -70
- data/{split/Tioga/lib → lib/Tioga}/FigureConstants.rb +0 -0
- data/{split/Tioga/lib → lib/Tioga}/Figures_and_Plots.rb +0 -0
- data/{split/Tioga/lib → lib/Tioga}/Images.rb +0 -0
- data/{split/Tioga/lib → lib/Tioga}/Legends.rb +0 -0
- data/{split/Tioga/lib → lib/Tioga}/MarkerConstants.rb +0 -0
- data/{split/Tioga/lib → lib/Tioga}/Markers.rb +0 -0
- data/{split/Tioga/lib → lib/Tioga}/Page_Frame_Bounds.rb +0 -0
- data/{split/Tioga/lib → lib/Tioga}/Rectangles.rb +0 -0
- data/{split/Tioga/lib → lib/Tioga}/Shading.rb +0 -0
- data/{split/Tioga/lib → lib/Tioga}/Special_Paths.rb +0 -0
- data/{split/Tioga/lib → lib/Tioga}/Strokes.rb +0 -0
- data/{split/Tioga/lib → lib/Tioga}/TeX_Text.rb +0 -0
- data/{split/Tioga/lib → lib/Tioga}/TexPreamble.rb +0 -0
- data/{split/Tioga/lib → lib/Tioga}/Titles_and_Labels.rb +0 -0
- data/{split/Tioga/lib → lib/Tioga}/Transparency.rb +0 -0
- data/{split/Tioga/lib → lib/Tioga}/Using_Paths.rb +0 -0
- data/{split/Tioga/lib → lib/Tioga}/Utils.rb +74 -0
- data/{split/Tioga/lib → lib/Tioga}/X_and_Y_Axes.rb +0 -0
- data/{split/Tioga/lib → lib/Tioga}/irb_tioga.rb +0 -0
- data/{split/Tioga/lib → lib/Tioga}/maker.rb +0 -0
- data/{split/Tioga/lib → lib/Tioga}/tioga.rb +0 -0
- data/{split/Tioga/lib → lib/Tioga}/tioga_ui.rb +0 -0
- data/{split/Tioga/lib → lib/Tioga}/tioga_ui_cmds.rb +0 -0
- data/tests/Icon_Test.pdf +0 -0
- data/tests/benchmark_dvector_reads.rb +20 -42
- data/tests/tc_Dvector.rb +45 -4
- data/tests/tc_Flate.rb +4 -5
- data/tests/tc_Function.rb +79 -0
- data/tests/vg.log +1453 -0
- metadata +141 -122
- data/split/Dtable/extconf.rb +0 -4
- data/split/Dvector/defs.h +0 -39
- data/split/Dvector/extconf.rb +0 -4
- data/split/Dvector/include/dvector.h +0 -77
- data/split/Dvector/namespace.h +0 -59
- data/split/Dvector/safe_double.h +0 -104
- data/split/Dvector/symbols.h +0 -52
- data/split/Flate/defs.h +0 -39
- data/split/Flate/extconf.rb +0 -19
- data/split/Flate/namespace.h +0 -59
- data/split/Flate/safe_double.h +0 -104
- data/split/Flate/symbols.h +0 -52
- data/split/Function/defs.h +0 -39
- data/split/Function/dvector.h +0 -77
- data/split/Function/extconf.rb +0 -4
- data/split/Function/namespace.h +0 -59
- data/split/Function/safe_double.h +0 -104
- data/split/Function/symbols.h +0 -52
- data/split/Tioga/defs.h +0 -39
- data/split/Tioga/dtable.h +0 -35
- data/split/Tioga/dvector.h +0 -77
- data/split/Tioga/extconf.rb +0 -4
- data/split/Tioga/flate.h +0 -98
- data/split/Tioga/mk_tioga_sty.rb +0 -53
- data/split/Tioga/namespace.h +0 -59
- data/split/Tioga/safe_double.h +0 -104
- data/split/Tioga/symbols.h +0 -52
- data/split/defs.h +0 -39
- data/split/extconf.rb +0 -125
- data/split/mkmf2.rb +0 -1623
- data/split/namespace.h +0 -59
- data/split/safe_double.h +0 -104
- 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'
|
data/{split → ext}/Flate/flate.c
RENAMED
@@ -1,12 +1,16 @@
|
|
1
1
|
/* flate.c -- main file for Ruby extension
|
2
2
|
*/
|
3
3
|
|
4
|
-
|
5
|
-
#include "
|
6
|
-
#include "
|
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
|
+
}
|