src/zlib/pvpgn_zutil.c

/* zutil.c -- target dependent utility functions for the compression library
 * Copyright (C) 1995-2002 Jean-loup Gailly.
 * For conditions of distribution and use, see copyright notice in zlib.h 
 */

#include "common/setup_before.h"
#include "zlib/pvpgn_zutil.h"

struct internal_state      {int dummy;}; /* for buggy compilers */

#ifndef STDC
extern void exit OF((int));
#endif

const char *pvpgn_z_errmsg[10] = {
"need dictionary",     /* Z_NEED_DICT       2  */
"stream end",          /* Z_STREAM_END      1  */
"",                    /* Z_OK              0  */
"file error",          /* Z_ERRNO         (-1) */
"stream error",        /* Z_STREAM_ERROR  (-2) */
"data error",          /* Z_DATA_ERROR    (-3) */
"insufficient memory", /* Z_MEM_ERROR     (-4) */
"buffer error",        /* Z_BUF_ERROR     (-5) */
"incompatible version",/* Z_VERSION_ERROR (-6) */
""};


const char * ZEXPORT pvpgn_zlibVersion()
{
    return ZLIB_VERSION;
}

#ifdef DEBUG

#  ifndef verbose
#    define verbose 0
#  endif
int pvpgn_z_verbose = verbose;

void pvpgn_z_error (m)
    char *m;
{
    fprintf(stderr, "%s\n", m);
    exit(1);
}
#endif

/* exported to allow conversion of error code to string for compress() and
 * uncompress()
 */
const char * ZEXPORT pvpgn_zError(err)
    int err;
{
    return ERR_MSG(err);
}


#ifndef HAVE_MEMCPY

void pvpgn_zmemcpy(dest, source, len)
    Bytef* dest;
    const Bytef* source;
    uInt  len;
{
    if (len == 0) return;
    do {
        *dest++ = *source++; /* ??? to be unrolled */
    } while (--len != 0);
}

int pvpgn_zmemcmp(s1, s2, len)
    const Bytef* s1;
    const Bytef* s2;
    uInt  len;
{
    uInt j;

    for (j = 0; j < len; j++) {
        if (s1[j] != s2[j]) return 2*(s1[j] > s2[j])-1;
    }
    return 0;
}

void pvpgn_zmemzero(dest, len)
    Bytef* dest;
    uInt  len;
{
    if (len == 0) return;
    do {
        *dest++ = 0;  /* ??? to be unrolled */
    } while (--len != 0);
}
#endif

#ifdef __TURBOC__
#if (defined( __BORLANDC__) || !defined(SMALL_MEDIUM)) && !defined(__32BIT__)
/* Small and medium model in Turbo C are for now limited to near allocation
 * with reduced MAX_WBITS and MAX_MEM_LEVEL
 */
#  define MY_ZCALLOC

/* Turbo C malloc() does not allow dynamic allocation of 64K bytes
 * and farmalloc(64K) returns a pointer with an offset of 8, so we
 * must fix the pointer. Warning: the pointer must be put back to its
 * original form in order to free it, use zcfree().
 */

#define MAX_PTR 10
/* 10*64K = 640K */

local int next_ptr = 0;

typedef struct ptr_table_s {
    voidpf org_ptr;
    voidpf new_ptr;
} ptr_table;

local ptr_table table[MAX_PTR];
/* This table is used to remember the original form of pointers
 * to large buffers (64K). Such pointers are normalized with a zero offset.
 * Since MSDOS is not a preemptive multitasking OS, this table is not
 * protected from concurrent access. This hack doesn't work anyway on
 * a protected system like OS/2. Use Microsoft C instead.
 */

voidpf pvpgn_zcalloc (voidpf opaque, unsigned items, unsigned size)
{
    voidpf buf = opaque; /* just to make some compilers happy */
    ulg bsize = (ulg)items*size;

    /* If we allocate less than 65520 bytes, we assume that farmalloc
     * will return a usable pointer which doesn't have to be normalized.
     */
    if (bsize < 65520L) {
        buf = farmalloc(bsize);
        if (*(ush*)&buf != 0) return buf;
    } else {
        buf = farmalloc(bsize + 16L);
    }
    if (buf == NULL || next_ptr >= MAX_PTR) return NULL;
    table[next_ptr].org_ptr = buf;

    /* Normalize the pointer to seg:0 */
    *((ush*)&buf+1) += ((ush)((uch*)buf-0) + 15) >> 4;
    *(ush*)&buf = 0;
    table[next_ptr++].new_ptr = buf;
    return buf;
}

void  pvpgn_zcfree (voidpf opaque, voidpf ptr)
{
    int n;
    if (*(ush*)&ptr != 0) { /* object < 64K */
        farfree(ptr);
        return;
    }
    /* Find the original pointer */
    for (n = 0; n < next_ptr; n++) {
        if (ptr != table[n].new_ptr) continue;

        farfree(table[n].org_ptr);
        while (++n < next_ptr) {
            table[n-1] = table[n];
        }
        next_ptr--;
        return;
    }
    ptr = opaque; /* just to make some compilers happy */
    Assert(0, "zcfree: ptr not found");
}
#endif
#endif /* __TURBOC__ */


#if defined(M_I86) && !defined(__32BIT__)
/* Microsoft C in 16-bit mode */

#  define MY_ZCALLOC

#if (!defined(_MSC_VER) || (_MSC_VER <= 600))
#  define _halloc  halloc
#  define _hfree   hfree
#endif

voidpf pvpgn_zcalloc (voidpf opaque, unsigned items, unsigned size)
{
    if (opaque) opaque = 0; /* to make compiler happy */
    return _halloc((long)items, size);
}

void  pvpgn_zcfree (voidpf opaque, voidpf ptr)
{
    if (opaque) opaque = 0; /* to make compiler happy */
    _hfree(ptr);
}

#endif /* MSC */


#ifndef MY_ZCALLOC /* Any system without a special alloc function */

#ifndef STDC
extern voidp  calloc OF((uInt items, uInt size));
extern void   free   OF((voidpf ptr));
#endif

voidpf pvpgn_zcalloc (opaque, items, size)
    voidpf opaque;
    unsigned items;
    unsigned size;
{
    if (opaque) items += size - size; /* make compiler happy */
    return (voidpf)calloc(items, size);
}

void  pvpgn_zcfree (opaque, ptr)
    voidpf opaque;
    voidpf ptr;
{
    free(ptr);
    if (opaque) return; /* make compiler happy */
}

#endif /* MY_ZCALLOC */
1	/* zutil.c -- target dependent utility functions for the compression library
2	* Copyright (C) 1995-2002 Jean-loup Gailly.
3	* For conditions of distribution and use, see copyright notice in zlib.h
4	*/
5
6	#include "common/setup_before.h"
7	#include "zlib/pvpgn_zutil.h"
8
9	struct internal_state {int dummy;}; /* for buggy compilers */
10
11	#ifndef STDC
12	extern void exit OF((int));
13	#endif
14
15	const char *pvpgn_z_errmsg[10] = {
16	"need dictionary", /* Z_NEED_DICT 2 */
17	"stream end", /* Z_STREAM_END 1 */
18	"", /* Z_OK 0 */
19	"file error", /* Z_ERRNO (-1) */
20	"stream error", /* Z_STREAM_ERROR (-2) */
21	"data error", /* Z_DATA_ERROR (-3) */
22	"insufficient memory", /* Z_MEM_ERROR (-4) */
23	"buffer error", /* Z_BUF_ERROR (-5) */
24	"incompatible version",/* Z_VERSION_ERROR (-6) */
25	""};
26
27
28	const char * ZEXPORT pvpgn_zlibVersion()
29	{
30	return ZLIB_VERSION;
31	}
32
33	#ifdef DEBUG
34
35	# ifndef verbose
36	# define verbose 0
37	# endif
38	int pvpgn_z_verbose = verbose;
39
40	void pvpgn_z_error (m)
41	char *m;
42	{
43	fprintf(stderr, "%s\n", m);
44	exit(1);
45	}
46	#endif
47
48	/* exported to allow conversion of error code to string for compress() and
49	* uncompress()
50	*/
51	const char * ZEXPORT pvpgn_zError(err)
52	int err;
53	{
54	return ERR_MSG(err);
55	}
56
57
58	#ifndef HAVE_MEMCPY
59
60	void pvpgn_zmemcpy(dest, source, len)
61	Bytef* dest;
62	const Bytef* source;
63	uInt len;
64	{
65	if (len == 0) return;
66	do {
67	dest++ = source++; /* ??? to be unrolled */
68	} while (--len != 0);
69	}
70
71	int pvpgn_zmemcmp(s1, s2, len)
72	const Bytef* s1;
73	const Bytef* s2;
74	uInt len;
75	{
76	uInt j;
77
78	for (j = 0; j < len; j++) {
79	if (s1[j] != s2[j]) return 2*(s1[j] > s2[j])-1;
80	}
81	return 0;
82	}
83
84	void pvpgn_zmemzero(dest, len)
85	Bytef* dest;
86	uInt len;
87	{
88	if (len == 0) return;
89	do {
90	dest++ = 0; / ??? to be unrolled */
91	} while (--len != 0);
92	}
93	#endif
94
95	#ifdef __TURBOC__
96	#if (defined( __BORLANDC__) \|\| !defined(SMALL_MEDIUM)) && !defined(__32BIT__)
97	/* Small and medium model in Turbo C are for now limited to near allocation
98	* with reduced MAX_WBITS and MAX_MEM_LEVEL
99	*/
100	# define MY_ZCALLOC
101
102	/* Turbo C malloc() does not allow dynamic allocation of 64K bytes
103	* and farmalloc(64K) returns a pointer with an offset of 8, so we
104	* must fix the pointer. Warning: the pointer must be put back to its
105	* original form in order to free it, use zcfree().
106	*/
107
108	#define MAX_PTR 10
109	/* 1064K = 640K /
110
111	local int next_ptr = 0;
112
113	typedef struct ptr_table_s {
114	voidpf org_ptr;
115	voidpf new_ptr;
116	} ptr_table;
117
118	local ptr_table table[MAX_PTR];
119	/* This table is used to remember the original form of pointers
120	* to large buffers (64K). Such pointers are normalized with a zero offset.
121	* Since MSDOS is not a preemptive multitasking OS, this table is not
122	* protected from concurrent access. This hack doesn't work anyway on
123	* a protected system like OS/2. Use Microsoft C instead.
124	*/
125
126	voidpf pvpgn_zcalloc (voidpf opaque, unsigned items, unsigned size)
127	{
128	voidpf buf = opaque; /* just to make some compilers happy */
129	ulg bsize = (ulg)items*size;
130
131	/* If we allocate less than 65520 bytes, we assume that farmalloc
132	* will return a usable pointer which doesn't have to be normalized.
133	*/
134	if (bsize < 65520L) {
135	buf = farmalloc(bsize);
136	if ((ush)&buf != 0) return buf;
137	} else {
138	buf = farmalloc(bsize + 16L);
139	}
140	if (buf == NULL \|\| next_ptr >= MAX_PTR) return NULL;
141	table[next_ptr].org_ptr = buf;
142
143	/* Normalize the pointer to seg:0 */
144	((ush)&buf+1) += ((ush)((uch*)buf-0) + 15) >> 4;
145	(ush)&buf = 0;
146	table[next_ptr++].new_ptr = buf;
147	return buf;
148	}
149
150	void pvpgn_zcfree (voidpf opaque, voidpf ptr)
151	{
152	int n;
153	if ((ush)&ptr != 0) { /* object < 64K */
154	farfree(ptr);
155	return;
156	}
157	/* Find the original pointer */
158	for (n = 0; n < next_ptr; n++) {
159	if (ptr != table[n].new_ptr) continue;
160
161	farfree(table[n].org_ptr);
162	while (++n < next_ptr) {
163	table[n-1] = table[n];
164	}
165	next_ptr--;
166	return;
167	}
168	ptr = opaque; /* just to make some compilers happy */
169	Assert(0, "zcfree: ptr not found");
170	}
171	#endif
172	#endif /* __TURBOC__ */
173
174
175	#if defined(M_I86) && !defined(__32BIT__)
176	/* Microsoft C in 16-bit mode */
177
178	# define MY_ZCALLOC
179
180	#if (!defined(_MSC_VER) \|\| (_MSC_VER <= 600))
181	# define _halloc halloc
182	# define _hfree hfree
183	#endif
184
185	voidpf pvpgn_zcalloc (voidpf opaque, unsigned items, unsigned size)
186	{
187	if (opaque) opaque = 0; /* to make compiler happy */
188	return _halloc((long)items, size);
189	}
190
191	void pvpgn_zcfree (voidpf opaque, voidpf ptr)
192	{
193	if (opaque) opaque = 0; /* to make compiler happy */
194	_hfree(ptr);
195	}
196
197	#endif /* MSC */
198
199
200	#ifndef MY_ZCALLOC /* Any system without a special alloc function */
201
202	#ifndef STDC
203	extern voidp calloc OF((uInt items, uInt size));
204	extern void free OF((voidpf ptr));
205	#endif
206
207	voidpf pvpgn_zcalloc (opaque, items, size)
208	voidpf opaque;
209	unsigned items;
210	unsigned size;
211	{
212	if (opaque) items += size - size; /* make compiler happy */
213	return (voidpf)calloc(items, size);
214	}
215
216	void pvpgn_zcfree (opaque, ptr)
217	voidpf opaque;
218	voidpf ptr;
219	{
220	free(ptr);
221	if (opaque) return; /* make compiler happy */
222	}
223
224	#endif /* MY_ZCALLOC */
webmaster@leafok.com	ViewVC Help
Powered by ViewVC 1.3.0-beta1