Mercurial > hg > sv-dependency-builds

annotate src/bzip2-1.0.6/bzlib_private.h @ 169:223a55898ab9 tip default

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Add null config files
author Chris Cannam <cannam@all-day-breakfast.com>
date Mon, 02 Mar 2020 14:03:47 +0000
parents 8a15ff55d9af
children
rev   line source
cannam@89 1
cannam@89 2 /*-------------------------------------------------------------*/
cannam@89 3 /*--- Private header file for the library. ---*/
cannam@89 4 /*--- bzlib_private.h ---*/
cannam@89 5 /*-------------------------------------------------------------*/
cannam@89 6
cannam@89 7 /* ------------------------------------------------------------------
cannam@89 8 This file is part of bzip2/libbzip2, a program and library for
cannam@89 9 lossless, block-sorting data compression.
cannam@89 10
cannam@89 11 bzip2/libbzip2 version 1.0.6 of 6 September 2010
cannam@89 12 Copyright (C) 1996-2010 Julian Seward <jseward@bzip.org>
cannam@89 13
cannam@89 14 Please read the WARNING, DISCLAIMER and PATENTS sections in the
cannam@89 15 README file.
cannam@89 16
cannam@89 17 This program is released under the terms of the license contained
cannam@89 18 in the file LICENSE.
cannam@89 19 ------------------------------------------------------------------ */
cannam@89 20
cannam@89 21
cannam@89 22 #ifndef _BZLIB_PRIVATE_H
cannam@89 23 #define _BZLIB_PRIVATE_H
cannam@89 24
cannam@89 25 #include <stdlib.h>
cannam@89 26
cannam@89 27 #ifndef BZ_NO_STDIO
cannam@89 28 #include <stdio.h>
cannam@89 29 #include <ctype.h>
cannam@89 30 #include <string.h>
cannam@89 31 #endif
cannam@89 32
cannam@89 33 #include "bzlib.h"
cannam@89 34
cannam@89 35
cannam@89 36
cannam@89 37 /*-- General stuff. --*/
cannam@89 38
cannam@89 39 #define BZ_VERSION "1.0.6, 6-Sept-2010"
cannam@89 40
cannam@89 41 typedef char Char;
cannam@89 42 typedef unsigned char Bool;
cannam@89 43 typedef unsigned char UChar;
cannam@89 44 typedef int Int32;
cannam@89 45 typedef unsigned int UInt32;
cannam@89 46 typedef short Int16;
cannam@89 47 typedef unsigned short UInt16;
cannam@89 48
cannam@89 49 #define True ((Bool)1)
cannam@89 50 #define False ((Bool)0)
cannam@89 51
cannam@89 52 #ifndef __GNUC__
cannam@89 53 #define __inline__ /* */
cannam@89 54 #endif
cannam@89 55
cannam@89 56 #ifndef BZ_NO_STDIO
cannam@89 57
cannam@89 58 extern void BZ2_bz__AssertH__fail ( int errcode );
cannam@89 59 #define AssertH(cond,errcode) \
cannam@89 60 { if (!(cond)) BZ2_bz__AssertH__fail ( errcode ); }
cannam@89 61
cannam@89 62 #if BZ_DEBUG
cannam@89 63 #define AssertD(cond,msg) \
cannam@89 64 { if (!(cond)) { \
cannam@89 65 fprintf ( stderr, \
cannam@89 66 "\n\nlibbzip2(debug build): internal error\n\t%s\n", msg );\
cannam@89 67 exit(1); \
cannam@89 68 }}
cannam@89 69 #else
cannam@89 70 #define AssertD(cond,msg) /* */
cannam@89 71 #endif
cannam@89 72
cannam@89 73 #define VPrintf0(zf) \
cannam@89 74 fprintf(stderr,zf)
cannam@89 75 #define VPrintf1(zf,za1) \
cannam@89 76 fprintf(stderr,zf,za1)
cannam@89 77 #define VPrintf2(zf,za1,za2) \
cannam@89 78 fprintf(stderr,zf,za1,za2)
cannam@89 79 #define VPrintf3(zf,za1,za2,za3) \
cannam@89 80 fprintf(stderr,zf,za1,za2,za3)
cannam@89 81 #define VPrintf4(zf,za1,za2,za3,za4) \
cannam@89 82 fprintf(stderr,zf,za1,za2,za3,za4)
cannam@89 83 #define VPrintf5(zf,za1,za2,za3,za4,za5) \
cannam@89 84 fprintf(stderr,zf,za1,za2,za3,za4,za5)
cannam@89 85
cannam@89 86 #else
cannam@89 87
cannam@89 88 extern void bz_internal_error ( int errcode );
cannam@89 89 #define AssertH(cond,errcode) \
cannam@89 90 { if (!(cond)) bz_internal_error ( errcode ); }
cannam@89 91 #define AssertD(cond,msg) do { } while (0)
cannam@89 92 #define VPrintf0(zf) do { } while (0)
cannam@89 93 #define VPrintf1(zf,za1) do { } while (0)
cannam@89 94 #define VPrintf2(zf,za1,za2) do { } while (0)
cannam@89 95 #define VPrintf3(zf,za1,za2,za3) do { } while (0)
cannam@89 96 #define VPrintf4(zf,za1,za2,za3,za4) do { } while (0)
cannam@89 97 #define VPrintf5(zf,za1,za2,za3,za4,za5) do { } while (0)
cannam@89 98
cannam@89 99 #endif
cannam@89 100
cannam@89 101
cannam@89 102 #define BZALLOC(nnn) (strm->bzalloc)(strm->opaque,(nnn),1)
cannam@89 103 #define BZFREE(ppp) (strm->bzfree)(strm->opaque,(ppp))
cannam@89 104
cannam@89 105
cannam@89 106 /*-- Header bytes. --*/
cannam@89 107
cannam@89 108 #define BZ_HDR_B 0x42 /* 'B' */
cannam@89 109 #define BZ_HDR_Z 0x5a /* 'Z' */
cannam@89 110 #define BZ_HDR_h 0x68 /* 'h' */
cannam@89 111 #define BZ_HDR_0 0x30 /* '0' */
cannam@89 112
cannam@89 113 /*-- Constants for the back end. --*/
cannam@89 114
cannam@89 115 #define BZ_MAX_ALPHA_SIZE 258
cannam@89 116 #define BZ_MAX_CODE_LEN 23
cannam@89 117
cannam@89 118 #define BZ_RUNA 0
cannam@89 119 #define BZ_RUNB 1
cannam@89 120
cannam@89 121 #define BZ_N_GROUPS 6
cannam@89 122 #define BZ_G_SIZE 50
cannam@89 123 #define BZ_N_ITERS 4
cannam@89 124
cannam@89 125 #define BZ_MAX_SELECTORS (2 + (900000 / BZ_G_SIZE))
cannam@89 126
cannam@89 127
cannam@89 128
cannam@89 129 /*-- Stuff for randomising repetitive blocks. --*/
cannam@89 130
cannam@89 131 extern Int32 BZ2_rNums[512];
cannam@89 132
cannam@89 133 #define BZ_RAND_DECLS \
cannam@89 134 Int32 rNToGo; \
cannam@89 135 Int32 rTPos \
cannam@89 136
cannam@89 137 #define BZ_RAND_INIT_MASK \
cannam@89 138 s->rNToGo = 0; \
cannam@89 139 s->rTPos = 0 \
cannam@89 140
cannam@89 141 #define BZ_RAND_MASK ((s->rNToGo == 1) ? 1 : 0)
cannam@89 142
cannam@89 143 #define BZ_RAND_UPD_MASK \
cannam@89 144 if (s->rNToGo == 0) { \
cannam@89 145 s->rNToGo = BZ2_rNums[s->rTPos]; \
cannam@89 146 s->rTPos++; \
cannam@89 147 if (s->rTPos == 512) s->rTPos = 0; \
cannam@89 148 } \
cannam@89 149 s->rNToGo--;
cannam@89 150
cannam@89 151
cannam@89 152
cannam@89 153 /*-- Stuff for doing CRCs. --*/
cannam@89 154
cannam@89 155 extern UInt32 BZ2_crc32Table[256];
cannam@89 156
cannam@89 157 #define BZ_INITIALISE_CRC(crcVar) \
cannam@89 158 { \
cannam@89 159 crcVar = 0xffffffffL; \
cannam@89 160 }
cannam@89 161
cannam@89 162 #define BZ_FINALISE_CRC(crcVar) \
cannam@89 163 { \
cannam@89 164 crcVar = ~(crcVar); \
cannam@89 165 }
cannam@89 166
cannam@89 167 #define BZ_UPDATE_CRC(crcVar,cha) \
cannam@89 168 { \
cannam@89 169 crcVar = (crcVar << 8) ^ \
cannam@89 170 BZ2_crc32Table[(crcVar >> 24) ^ \
cannam@89 171 ((UChar)cha)]; \
cannam@89 172 }
cannam@89 173
cannam@89 174
cannam@89 175
cannam@89 176 /*-- States and modes for compression. --*/
cannam@89 177
cannam@89 178 #define BZ_M_IDLE 1
cannam@89 179 #define BZ_M_RUNNING 2
cannam@89 180 #define BZ_M_FLUSHING 3
cannam@89 181 #define BZ_M_FINISHING 4
cannam@89 182
cannam@89 183 #define BZ_S_OUTPUT 1
cannam@89 184 #define BZ_S_INPUT 2
cannam@89 185
cannam@89 186 #define BZ_N_RADIX 2
cannam@89 187 #define BZ_N_QSORT 12
cannam@89 188 #define BZ_N_SHELL 18
cannam@89 189 #define BZ_N_OVERSHOOT (BZ_N_RADIX + BZ_N_QSORT + BZ_N_SHELL + 2)
cannam@89 190
cannam@89 191
cannam@89 192
cannam@89 193
cannam@89 194 /*-- Structure holding all the compression-side stuff. --*/
cannam@89 195
cannam@89 196 typedef
cannam@89 197 struct {
cannam@89 198 /* pointer back to the struct bz_stream */
cannam@89 199 bz_stream* strm;
cannam@89 200
cannam@89 201 /* mode this stream is in, and whether inputting */
cannam@89 202 /* or outputting data */
cannam@89 203 Int32 mode;
cannam@89 204 Int32 state;
cannam@89 205
cannam@89 206 /* remembers avail_in when flush/finish requested */
cannam@89 207 UInt32 avail_in_expect;
cannam@89 208
cannam@89 209 /* for doing the block sorting */
cannam@89 210 UInt32* arr1;
cannam@89 211 UInt32* arr2;
cannam@89 212 UInt32* ftab;
cannam@89 213 Int32 origPtr;
cannam@89 214
cannam@89 215 /* aliases for arr1 and arr2 */
cannam@89 216 UInt32* ptr;
cannam@89 217 UChar* block;
cannam@89 218 UInt16* mtfv;
cannam@89 219 UChar* zbits;
cannam@89 220
cannam@89 221 /* for deciding when to use the fallback sorting algorithm */
cannam@89 222 Int32 workFactor;
cannam@89 223
cannam@89 224 /* run-length-encoding of the input */
cannam@89 225 UInt32 state_in_ch;
cannam@89 226 Int32 state_in_len;
cannam@89 227 BZ_RAND_DECLS;
cannam@89 228
cannam@89 229 /* input and output limits and current posns */
cannam@89 230 Int32 nblock;
cannam@89 231 Int32 nblockMAX;
cannam@89 232 Int32 numZ;
cannam@89 233 Int32 state_out_pos;
cannam@89 234
cannam@89 235 /* map of bytes used in block */
cannam@89 236 Int32 nInUse;
cannam@89 237 Bool inUse[256];
cannam@89 238 UChar unseqToSeq[256];
cannam@89 239
cannam@89 240 /* the buffer for bit stream creation */
cannam@89 241 UInt32 bsBuff;
cannam@89 242 Int32 bsLive;
cannam@89 243
cannam@89 244 /* block and combined CRCs */
cannam@89 245 UInt32 blockCRC;
cannam@89 246 UInt32 combinedCRC;
cannam@89 247
cannam@89 248 /* misc administratium */
cannam@89 249 Int32 verbosity;
cannam@89 250 Int32 blockNo;
cannam@89 251 Int32 blockSize100k;
cannam@89 252
cannam@89 253 /* stuff for coding the MTF values */
cannam@89 254 Int32 nMTF;
cannam@89 255 Int32 mtfFreq [BZ_MAX_ALPHA_SIZE];
cannam@89 256 UChar selector [BZ_MAX_SELECTORS];
cannam@89 257 UChar selectorMtf[BZ_MAX_SELECTORS];
cannam@89 258
cannam@89 259 UChar len [BZ_N_GROUPS][BZ_MAX_ALPHA_SIZE];
cannam@89 260 Int32 code [BZ_N_GROUPS][BZ_MAX_ALPHA_SIZE];
cannam@89 261 Int32 rfreq [BZ_N_GROUPS][BZ_MAX_ALPHA_SIZE];
cannam@89 262 /* second dimension: only 3 needed; 4 makes index calculations faster */
cannam@89 263 UInt32 len_pack[BZ_MAX_ALPHA_SIZE][4];
cannam@89 264
cannam@89 265 }
cannam@89 266 EState;
cannam@89 267
cannam@89 268
cannam@89 269
cannam@89 270 /*-- externs for compression. --*/
cannam@89 271
cannam@89 272 extern void
cannam@89 273 BZ2_blockSort ( EState* );
cannam@89 274
cannam@89 275 extern void
cannam@89 276 BZ2_compressBlock ( EState*, Bool );
cannam@89 277
cannam@89 278 extern void
cannam@89 279 BZ2_bsInitWrite ( EState* );
cannam@89 280
cannam@89 281 extern void
cannam@89 282 BZ2_hbAssignCodes ( Int32*, UChar*, Int32, Int32, Int32 );
cannam@89 283
cannam@89 284 extern void
cannam@89 285 BZ2_hbMakeCodeLengths ( UChar*, Int32*, Int32, Int32 );
cannam@89 286
cannam@89 287
cannam@89 288
cannam@89 289 /*-- states for decompression. --*/
cannam@89 290
cannam@89 291 #define BZ_X_IDLE 1
cannam@89 292 #define BZ_X_OUTPUT 2
cannam@89 293
cannam@89 294 #define BZ_X_MAGIC_1 10
cannam@89 295 #define BZ_X_MAGIC_2 11
cannam@89 296 #define BZ_X_MAGIC_3 12
cannam@89 297 #define BZ_X_MAGIC_4 13
cannam@89 298 #define BZ_X_BLKHDR_1 14
cannam@89 299 #define BZ_X_BLKHDR_2 15
cannam@89 300 #define BZ_X_BLKHDR_3 16
cannam@89 301 #define BZ_X_BLKHDR_4 17
cannam@89 302 #define BZ_X_BLKHDR_5 18
cannam@89 303 #define BZ_X_BLKHDR_6 19
cannam@89 304 #define BZ_X_BCRC_1 20
cannam@89 305 #define BZ_X_BCRC_2 21
cannam@89 306 #define BZ_X_BCRC_3 22
cannam@89 307 #define BZ_X_BCRC_4 23
cannam@89 308 #define BZ_X_RANDBIT 24
cannam@89 309 #define BZ_X_ORIGPTR_1 25
cannam@89 310 #define BZ_X_ORIGPTR_2 26
cannam@89 311 #define BZ_X_ORIGPTR_3 27
cannam@89 312 #define BZ_X_MAPPING_1 28
cannam@89 313 #define BZ_X_MAPPING_2 29
cannam@89 314 #define BZ_X_SELECTOR_1 30
cannam@89 315 #define BZ_X_SELECTOR_2 31
cannam@89 316 #define BZ_X_SELECTOR_3 32
cannam@89 317 #define BZ_X_CODING_1 33
cannam@89 318 #define BZ_X_CODING_2 34
cannam@89 319 #define BZ_X_CODING_3 35
cannam@89 320 #define BZ_X_MTF_1 36
cannam@89 321 #define BZ_X_MTF_2 37
cannam@89 322 #define BZ_X_MTF_3 38
cannam@89 323 #define BZ_X_MTF_4 39
cannam@89 324 #define BZ_X_MTF_5 40
cannam@89 325 #define BZ_X_MTF_6 41
cannam@89 326 #define BZ_X_ENDHDR_2 42
cannam@89 327 #define BZ_X_ENDHDR_3 43
cannam@89 328 #define BZ_X_ENDHDR_4 44
cannam@89 329 #define BZ_X_ENDHDR_5 45
cannam@89 330 #define BZ_X_ENDHDR_6 46
cannam@89 331 #define BZ_X_CCRC_1 47
cannam@89 332 #define BZ_X_CCRC_2 48
cannam@89 333 #define BZ_X_CCRC_3 49
cannam@89 334 #define BZ_X_CCRC_4 50
cannam@89 335
cannam@89 336
cannam@89 337
cannam@89 338 /*-- Constants for the fast MTF decoder. --*/
cannam@89 339
cannam@89 340 #define MTFA_SIZE 4096
cannam@89 341 #define MTFL_SIZE 16
cannam@89 342
cannam@89 343
cannam@89 344
cannam@89 345 /*-- Structure holding all the decompression-side stuff. --*/
cannam@89 346
cannam@89 347 typedef
cannam@89 348 struct {
cannam@89 349 /* pointer back to the struct bz_stream */
cannam@89 350 bz_stream* strm;
cannam@89 351
cannam@89 352 /* state indicator for this stream */
cannam@89 353 Int32 state;
cannam@89 354
cannam@89 355 /* for doing the final run-length decoding */
cannam@89 356 UChar state_out_ch;
cannam@89 357 Int32 state_out_len;
cannam@89 358 Bool blockRandomised;
cannam@89 359 BZ_RAND_DECLS;
cannam@89 360
cannam@89 361 /* the buffer for bit stream reading */
cannam@89 362 UInt32 bsBuff;
cannam@89 363 Int32 bsLive;
cannam@89 364
cannam@89 365 /* misc administratium */
cannam@89 366 Int32 blockSize100k;
cannam@89 367 Bool smallDecompress;
cannam@89 368 Int32 currBlockNo;
cannam@89 369 Int32 verbosity;
cannam@89 370
cannam@89 371 /* for undoing the Burrows-Wheeler transform */
cannam@89 372 Int32 origPtr;
cannam@89 373 UInt32 tPos;
cannam@89 374 Int32 k0;
cannam@89 375 Int32 unzftab[256];
cannam@89 376 Int32 nblock_used;
cannam@89 377 Int32 cftab[257];
cannam@89 378 Int32 cftabCopy[257];
cannam@89 379
cannam@89 380 /* for undoing the Burrows-Wheeler transform (FAST) */
cannam@89 381 UInt32 *tt;
cannam@89 382
cannam@89 383 /* for undoing the Burrows-Wheeler transform (SMALL) */
cannam@89 384 UInt16 *ll16;
cannam@89 385 UChar *ll4;
cannam@89 386
cannam@89 387 /* stored and calculated CRCs */
cannam@89 388 UInt32 storedBlockCRC;
cannam@89 389 UInt32 storedCombinedCRC;
cannam@89 390 UInt32 calculatedBlockCRC;
cannam@89 391 UInt32 calculatedCombinedCRC;
cannam@89 392
cannam@89 393 /* map of bytes used in block */
cannam@89 394 Int32 nInUse;
cannam@89 395 Bool inUse[256];
cannam@89 396 Bool inUse16[16];
cannam@89 397 UChar seqToUnseq[256];
cannam@89 398
cannam@89 399 /* for decoding the MTF values */
cannam@89 400 UChar mtfa [MTFA_SIZE];
cannam@89 401 Int32 mtfbase[256 / MTFL_SIZE];
cannam@89 402 UChar selector [BZ_MAX_SELECTORS];
cannam@89 403 UChar selectorMtf[BZ_MAX_SELECTORS];
cannam@89 404 UChar len [BZ_N_GROUPS][BZ_MAX_ALPHA_SIZE];
cannam@89 405
cannam@89 406 Int32 limit [BZ_N_GROUPS][BZ_MAX_ALPHA_SIZE];
cannam@89 407 Int32 base [BZ_N_GROUPS][BZ_MAX_ALPHA_SIZE];
cannam@89 408 Int32 perm [BZ_N_GROUPS][BZ_MAX_ALPHA_SIZE];
cannam@89 409 Int32 minLens[BZ_N_GROUPS];
cannam@89 410
cannam@89 411 /* save area for scalars in the main decompress code */
cannam@89 412 Int32 save_i;
cannam@89 413 Int32 save_j;
cannam@89 414 Int32 save_t;
cannam@89 415 Int32 save_alphaSize;
cannam@89 416 Int32 save_nGroups;
cannam@89 417 Int32 save_nSelectors;
cannam@89 418 Int32 save_EOB;
cannam@89 419 Int32 save_groupNo;
cannam@89 420 Int32 save_groupPos;
cannam@89 421 Int32 save_nextSym;
cannam@89 422 Int32 save_nblockMAX;
cannam@89 423 Int32 save_nblock;
cannam@89 424 Int32 save_es;
cannam@89 425 Int32 save_N;
cannam@89 426 Int32 save_curr;
cannam@89 427 Int32 save_zt;
cannam@89 428 Int32 save_zn;
cannam@89 429 Int32 save_zvec;
cannam@89 430 Int32 save_zj;
cannam@89 431 Int32 save_gSel;
cannam@89 432 Int32 save_gMinlen;
cannam@89 433 Int32* save_gLimit;
cannam@89 434 Int32* save_gBase;
cannam@89 435 Int32* save_gPerm;
cannam@89 436
cannam@89 437 }
cannam@89 438 DState;
cannam@89 439
cannam@89 440
cannam@89 441
cannam@89 442 /*-- Macros for decompression. --*/
cannam@89 443
cannam@89 444 #define BZ_GET_FAST(cccc) \
cannam@89 445 /* c_tPos is unsigned, hence test < 0 is pointless. */ \
cannam@89 446 if (s->tPos >= (UInt32)100000 * (UInt32)s->blockSize100k) return True; \
cannam@89 447 s->tPos = s->tt[s->tPos]; \
cannam@89 448 cccc = (UChar)(s->tPos & 0xff); \
cannam@89 449 s->tPos >>= 8;
cannam@89 450
cannam@89 451 #define BZ_GET_FAST_C(cccc) \
cannam@89 452 /* c_tPos is unsigned, hence test < 0 is pointless. */ \
cannam@89 453 if (c_tPos >= (UInt32)100000 * (UInt32)ro_blockSize100k) return True; \
cannam@89 454 c_tPos = c_tt[c_tPos]; \
cannam@89 455 cccc = (UChar)(c_tPos & 0xff); \
cannam@89 456 c_tPos >>= 8;
cannam@89 457
cannam@89 458 #define SET_LL4(i,n) \
cannam@89 459 { if (((i) & 0x1) == 0) \
cannam@89 460 s->ll4[(i) >> 1] = (s->ll4[(i) >> 1] & 0xf0) | (n); else \
cannam@89 461 s->ll4[(i) >> 1] = (s->ll4[(i) >> 1] & 0x0f) | ((n) << 4); \
cannam@89 462 }
cannam@89 463
cannam@89 464 #define GET_LL4(i) \
cannam@89 465 ((((UInt32)(s->ll4[(i) >> 1])) >> (((i) << 2) & 0x4)) & 0xF)
cannam@89 466
cannam@89 467 #define SET_LL(i,n) \
cannam@89 468 { s->ll16[i] = (UInt16)(n & 0x0000ffff); \
cannam@89 469 SET_LL4(i, n >> 16); \
cannam@89 470 }
cannam@89 471
cannam@89 472 #define GET_LL(i) \
cannam@89 473 (((UInt32)s->ll16[i]) | (GET_LL4(i) << 16))
cannam@89 474
cannam@89 475 #define BZ_GET_SMALL(cccc) \
cannam@89 476 /* c_tPos is unsigned, hence test < 0 is pointless. */ \
cannam@89 477 if (s->tPos >= (UInt32)100000 * (UInt32)s->blockSize100k) return True; \
cannam@89 478 cccc = BZ2_indexIntoF ( s->tPos, s->cftab ); \
cannam@89 479 s->tPos = GET_LL(s->tPos);
cannam@89 480
cannam@89 481
cannam@89 482 /*-- externs for decompression. --*/
cannam@89 483
cannam@89 484 extern Int32
cannam@89 485 BZ2_indexIntoF ( Int32, Int32* );
cannam@89 486
cannam@89 487 extern Int32
cannam@89 488 BZ2_decompress ( DState* );
cannam@89 489
cannam@89 490 extern void
cannam@89 491 BZ2_hbCreateDecodeTables ( Int32*, Int32*, Int32*, UChar*,
cannam@89 492 Int32, Int32, Int32 );
cannam@89 493
cannam@89 494
cannam@89 495 #endif
cannam@89 496
cannam@89 497
cannam@89 498 /*-- BZ_NO_STDIO seems to make NULL disappear on some platforms. --*/
cannam@89 499
cannam@89 500 #ifdef BZ_NO_STDIO
cannam@89 501 #ifndef NULL
cannam@89 502 #define NULL 0
cannam@89 503 #endif
cannam@89 504 #endif
cannam@89 505
cannam@89 506
cannam@89 507 /*-------------------------------------------------------------*/
cannam@89 508 /*--- end bzlib_private.h ---*/
cannam@89 509 /*-------------------------------------------------------------*/