← Back to branch summary

~ubuntu-branches/ubuntu/wily/hedgewars/wily

« back to all changes in this revision

Viewing changes to misc/libfreetype/src/gzip/zutil.c

  • Committer: Package Import Robot
  • Author(s): Dmitry E. Oboukhov
  • Date: 2011-09-23 10:16:55 UTC
  • mfrom: (1.2.11 upstream)
  • Revision ID: package-import@ubuntu.com-20110923101655-3977th2gc5n0a3pv
Tags: 0.9.16-1
* New upstream version.
 + Downloadable content! Simply click to install any content.
   New voices, hats, maps, themes, translations, music, scripts...
   Hedgewars is now more customisable than ever before! As time goes
   by we will be soliciting community content to feature on this page,
   so remember to check it from time to time. If you decide you want
   to go back to standard Hedgewars, just remove the Data directory
   from your Hedgewars config directory.
 + 3-D rendering! Diorama-like rendering of the game in a variety
   of 3D modes. Let us know which ones work best for you, we didn't
   really have the equipment to test them all.
 + Resizable game window.
 + New utilities! The Time Box will remove one of your hedgehogs
   from the game for a while, protecting from attack until it returns,
   somewhere else on the map. Land spray will allow you to build bridges,
   seal up holes, or just make life unpleasant for your enemies.
 + New single player: Bamboo Thicket, That Sinking Feeling, Newton and
   the Tree and multi-player: The Specialists, Space Invaders,
   Racer - scripts! And a ton more script hooks for scripters
 + New twists on old weapons. Drill strike, seduction and fire have
   been adjusted. Defective mines have been added, rope can attach to
   hogs/crates/barrels again, grenades now have variable bounce (use
   precise key + 1-5). Portal gun is now more usable in flight and
   all game actions are a lot faster.
 + New theme - Golf, dozens of new community hats and a new
   localised Default voice, Ukranian.

Show diffs side-by-side

added added

removed removed

Lines of Context:
misc/libfreetype/src/gzip/zutil.c
 
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
/* @(#) $Id$ */
 
7
 
 
8
#include "zutil.h"
 
9
 
 
10
#ifndef STDC
 
11
extern void exit OF((int));
 
12
#endif
 
13
 
 
14
 
 
15
#ifndef HAVE_MEMCPY
 
16
 
 
17
void zmemcpy(dest, source, len)
 
18
    Bytef* dest;
 
19
    const Bytef* source;
 
20
    uInt  len;
 
21
{
 
22
    if (len == 0) return;
 
23
    do {
 
24
        *dest++ = *source++; /* ??? to be unrolled */
 
25
    } while (--len != 0);
 
26
}
 
27
 
 
28
int zmemcmp(s1, s2, len)
 
29
    const Bytef* s1;
 
30
    const Bytef* s2;
 
31
    uInt  len;
 
32
{
 
33
    uInt j;
 
34
 
 
35
    for (j = 0; j < len; j++) {
 
36
        if (s1[j] != s2[j]) return 2*(s1[j] > s2[j])-1;
 
37
    }
 
38
    return 0;
 
39
}
 
40
 
 
41
void zmemzero(dest, len)
 
42
    Bytef* dest;
 
43
    uInt  len;
 
44
{
 
45
    if (len == 0) return;
 
46
    do {
 
47
        *dest++ = 0;  /* ??? to be unrolled */
 
48
    } while (--len != 0);
 
49
}
 
50
#endif
 
51
 
 
52
#if defined( MSDOS ) && defined( __TURBOC__ ) && !defined( MY_ZCALLOC )
 
53
#if (defined( __BORLANDC__) || !defined(SMALL_MEDIUM)) && !defined(__32BIT__)
 
54
/* Small and medium model in Turbo C are for now limited to near allocation
 
55
 * with reduced MAX_WBITS and MAX_MEM_LEVEL
 
56
 */
 
57
#  define MY_ZCALLOC
 
58
 
 
59
/* Turbo C malloc() does not allow dynamic allocation of 64K bytes
 
60
 * and farmalloc(64K) returns a pointer with an offset of 8, so we
 
61
 * must fix the pointer. Warning: the pointer must be put back to its
 
62
 * original form in order to free it, use zcfree().
 
63
 */
 
64
 
 
65
#define MAX_PTR 10
 
66
/* 10*64K = 640K */
 
67
 
 
68
local int next_ptr = 0;
 
69
 
 
70
typedef struct ptr_table_s {
 
71
    voidpf org_ptr;
 
72
    voidpf new_ptr;
 
73
} ptr_table;
 
74
 
 
75
local ptr_table table[MAX_PTR];
 
76
/* This table is used to remember the original form of pointers
 
77
 * to large buffers (64K). Such pointers are normalized with a zero offset.
 
78
 * Since MSDOS is not a preemptive multitasking OS, this table is not
 
79
 * protected from concurrent access. This hack doesn't work anyway on
 
80
 * a protected system like OS/2. Use Microsoft C instead.
 
81
 */
 
82
 
 
83
voidpf zcalloc (voidpf opaque, unsigned items, unsigned size)
 
84
{
 
85
    voidpf buf = opaque; /* just to make some compilers happy */
 
86
    ulg bsize = (ulg)items*size;
 
87
 
 
88
    /* If we allocate less than 65520 bytes, we assume that farmalloc
 
89
     * will return a usable pointer which doesn't have to be normalized.
 
90
     */
 
91
    if (bsize < 65520L) {
 
92
        buf = farmalloc(bsize);
 
93
        if (*(ush*)&buf != 0) return buf;
 
94
    } else {
 
95
        buf = farmalloc(bsize + 16L);
 
96
    }
 
97
    if (buf == NULL || next_ptr >= MAX_PTR) return NULL;
 
98
    table[next_ptr].org_ptr = buf;
 
99
 
 
100
    /* Normalize the pointer to seg:0 */
 
101
    *((ush*)&buf+1) += ((ush)((uch*)buf-0) + 15) >> 4;
 
102
    *(ush*)&buf = 0;
 
103
    table[next_ptr++].new_ptr = buf;
 
104
    return buf;
 
105
}
 
106
 
 
107
void  zcfree (voidpf opaque, voidpf ptr)
 
108
{
 
109
    int n;
 
110
    if (*(ush*)&ptr != 0) { /* object < 64K */
 
111
        farfree(ptr);
 
112
        return;
 
113
    }
 
114
    /* Find the original pointer */
 
115
    for (n = 0; n < next_ptr; n++) {
 
116
        if (ptr != table[n].new_ptr) continue;
 
117
 
 
118
        farfree(table[n].org_ptr);
 
119
        while (++n < next_ptr) {
 
120
            table[n-1] = table[n];
 
121
        }
 
122
        next_ptr--;
 
123
        return;
 
124
    }
 
125
    ptr = opaque; /* just to make some compilers happy */
 
126
    Assert(0, "zcfree: ptr not found");
 
127
}
 
128
#endif
 
129
#endif /* MSDOS && __TURBOC__ */
 
130
 
 
131
 
 
132
#if defined(M_I86) && !defined(__32BIT__) && !defined( MY_ZCALLOC )
 
133
/* Microsoft C in 16-bit mode */
 
134
 
 
135
#  define MY_ZCALLOC
 
136
 
 
137
#if (!defined(_MSC_VER) || (_MSC_VER <= 600))
 
138
#  define _halloc  halloc
 
139
#  define _hfree   hfree
 
140
#endif
 
141
 
 
142
voidpf zcalloc (voidpf opaque, unsigned items, unsigned size)
 
143
{
 
144
    if (opaque) opaque = 0; /* to make compiler happy */
 
145
    return _halloc((long)items, size);
 
146
}
 
147
 
 
148
void  zcfree (voidpf opaque, voidpf ptr)
 
149
{
 
150
    if (opaque) opaque = 0; /* to make compiler happy */
 
151
    _hfree(ptr);
 
152
}
 
153
 
 
154
#endif /* MSC */
 
155
 
 
156
 
 
157
#ifndef MY_ZCALLOC /* Any system without a special alloc function */
 
158
 
 
159
#ifndef STDC
 
160
extern voidp  ft_scalloc OF((uInt items, uInt size));
 
161
extern void   ft_sfree   OF((voidpf ptr));
 
162
#endif
 
163
 
 
164
voidpf zcalloc (opaque, items, size)
 
165
    voidpf opaque;
 
166
    unsigned items;
 
167
    unsigned size;
 
168
{
 
169
    if (opaque) items += size - size; /* make compiler happy */
 
170
    return (voidpf)ft_scalloc(items, size);
 
171
}
 
172
 
 
173
void  zcfree (opaque, ptr)
 
174
    voidpf opaque;
 
175
    voidpf ptr;
 
176
{
 
177
    ft_sfree(ptr);
 
178
    if (opaque) return; /* make compiler happy */
 
179
}
 
180
 
 
181
#endif /* MY_ZCALLOC */