1 files changed, 291 insertions, 225 deletions

diff --git a/manual.texi b/manual.texi
index e48e656..336776a 100644
--- a/manual.texi
+++ b/manual.texi
@@ -2,10 +2,10 @@
 @setfilename bzip2.info
 
 @ignore
-This file documents bzip2 version 0.9.5, and associated library
+This file documents bzip2 version 1.0, and associated library
 libbzip2, written by Julian Seward (jseward@acm.org).
 
-Copyright (C) 1996-1999 Julian R Seward
+Copyright (C) 1996-2000 Julian R Seward
 
 Permission is granted to make and distribute verbatim copies of
 this manual provided the copyright notice and this permission notice
@@ -30,8 +30,8 @@ END-INFO-DIR-ENTRY
 @titlepage
 @title bzip2 and libbzip2
 @subtitle a program and library for data compression
-@subtitle copyright (C) 1996-1999 Julian Seward
-@subtitle version 0.9.5d of 4 September 1999
+@subtitle copyright (C) 1996-2000 Julian Seward
+@subtitle version 1.0 of 21 March 2000
 @author Julian Seward
 
 @end titlepage
@@ -44,7 +44,7 @@ END-INFO-DIR-ENTRY
 
 This program, @code{bzip2}, 
 and associated library @code{libbzip2}, are
-Copyright (C) 1996-1999 Julian R Seward.  All rights reserved.
+Copyright (C) 1996-2000 Julian R Seward.  All rights reserved.
 
 Redistribution and use in source and binary forms, with or without
 modification, are permitted provided that the following conditions
@@ -82,9 +82,13 @@ Julian Seward, Cambridge, UK.
 
 @code{jseward@@acm.org}
 
+@code{http://sourceware.cygnus.com/bzip2}
+
+@code{http://www.cacheprof.org}
+
 @code{http://www.muraroa.demon.co.uk}
 
-@code{bzip2}/@code{libbzip2} version 0.9.5 of 24 May 1999.
+@code{bzip2}/@code{libbzip2} version 1.0 of 21 March 2000.
 
 PATENTS: To the best of my knowledge, @code{bzip2} does not use any patented
 algorithms.  However, I do not have the resources available to carry out
@@ -130,7 +134,7 @@ and nothing else.
 @unnumberedsubsubsec NAME
 @itemize
 @item @code{bzip2}, @code{bunzip2}
-- a block-sorting file compressor, v0.9.5
+- a block-sorting file compressor, v1.0
 @item @code{bzcat} 
 - decompresses files to stdout
 @item @code{bzip2recover}
@@ -431,10 +435,10 @@ I/O error messages are not as helpful as they could be.  @code{bzip2}
 tries hard to detect I/O errors and exit cleanly, but the details of
 what the problem is sometimes seem rather misleading.
 
-This manual page pertains to version 0.9.5 of @code{bzip2}.  Compressed
+This manual page pertains to version 1.0 of @code{bzip2}.  Compressed
 data created by this version is entirely forwards and backwards
-compatible with the previous public releases, versions 0.1pl2 and 0.9.0,
-but with the following exception: 0.9.0 and above can correctly
+compatible with the previous public releases, versions 0.1pl2, 0.9.0 and
+0.9.5, but with the following exception: 0.9.0 and above can correctly
 decompress multiple concatenated compressed files.  0.1pl2 cannot do
 this; it will stop after decompressing just the first file in the
 stream.
@@ -486,6 +490,10 @@ The structure of @code{libbzip2}'s interfaces is similar to
 that of Jean-loup Gailly's and Mark Adler's excellent @code{zlib} 
 library.
 
+All externally visible symbols have names beginning @code{BZ2_}.
+This is new in version 1.0.  The intention is to minimise pollution
+of the namespaces of library clients.
+
 @subsection Low-level summary
 
 This interface provides services for compressing and decompressing
@@ -498,17 +506,17 @@ The low-level part of the library has no global variables and
 is therefore thread-safe.
 
 Six routines make up the low level interface: 
-@code{bzCompressInit}, @code{bzCompress}, and @* @code{bzCompressEnd}
+@code{BZ2_bzCompressInit}, @code{BZ2_bzCompress}, and @* @code{BZ2_bzCompressEnd}
 for compression,
-and a corresponding trio @code{bzDecompressInit}, @* @code{bzDecompress}
-and @code{bzDecompressEnd} for decompression.  
+and a corresponding trio @code{BZ2_bzDecompressInit}, @* @code{BZ2_bzDecompress}
+and @code{BZ2_bzDecompressEnd} for decompression.  
 The @code{*Init} functions allocate
 memory for compression/decompression and do other
 initialisations, whilst the @code{*End} functions close down operations
 and release memory.
 
-The real work is done by @code{bzCompress} and @code{bzDecompress}.  
-These compress/decompress data from a user-supplied input buffer
+The real work is done by @code{BZ2_bzCompress} and @code{BZ2_bzDecompress}.  
+These compress and decompress data from a user-supplied input buffer
 to a user-supplied output buffer.  These buffers can be any size;
 arbitrary quantities of data are handled by making repeated calls
 to these functions.  This is a flexible mechanism allowing a 
@@ -526,10 +534,10 @@ reading files in which the @code{bzip2} data stream is embedded
 within some larger-scale file structure, or where there are
 multiple @code{bzip2} data streams concatenated end-to-end.
 
-For reading files, @code{bzReadOpen}, @code{bzRead}, @code{bzReadClose}
-and @code{bzReadGetUnused} are supplied.  For writing files,
-@code{bzWriteOpen}, @code{bzWrite} and @code{bzWriteFinish} are
-available.
+For reading files, @code{BZ2_bzReadOpen}, @code{BZ2_bzRead},
+@code{BZ2_bzReadClose} and @* @code{BZ2_bzReadGetUnused} are supplied.  For
+writing files, @code{BZ2_bzWriteOpen}, @code{BZ2_bzWrite} and
+@code{BZ2_bzWriteFinish} are available.
 
 As with the low-level library, no global variables are used
 so the library is per se thread-safe.  However, if I/O errors
@@ -539,7 +547,7 @@ the error.  In that case, you'd need a C library which correctly
 supports @code{errno} in a multithreaded environment.
 
 To make the library a little simpler and more portable,
-@code{bzReadOpen} and @code{bzWriteOpen} require you to pass them file
+@code{BZ2_bzReadOpen} and @code{BZ2_bzWriteOpen} require you to pass them file
 handles (@code{FILE*}s) which have previously been opened for reading or
 writing respectively.  That avoids portability problems associated with
 file operations and file attributes, whilst not being much of an
@@ -548,8 +556,8 @@ imposition on the programmer.
 
 
 @subsection Utility functions summary
-For very simple needs, @code{bzBuffToBuffCompress} and
-@code{bzBuffToBuffDecompress} are provided.  These compress
+For very simple needs, @code{BZ2_bzBuffToBuffCompress} and
+@code{BZ2_bzBuffToBuffDecompress} are provided.  These compress
 data in memory from one buffer to another buffer in a single
 function call.  You should assess whether these functions
 fulfill your memory-to-memory compression/decompression
@@ -559,9 +567,9 @@ general but more complex low-level interface.
 Yoshioka Tsuneo (@code{QWF00133@@niftyserve.or.jp} /
 @code{tsuneo-y@@is.aist-nara.ac.jp}) has contributed some functions to
 give better @code{zlib} compatibility.  These functions are
-@code{bzopen}, @code{bzread}, @code{bzwrite}, @code{bzflush},
-@code{bzclose},
-@code{bzerror} and @code{bzlibVersion}.  You may find these functions
+@code{BZ2_bzopen}, @code{BZ2_bzread}, @code{BZ2_bzwrite}, @code{BZ2_bzflush},
+@code{BZ2_bzclose},
+@code{BZ2_bzerror} and @code{BZ2_bzlibVersion}.  You may find these functions
 more convenient for simple file reading and writing, than those in the
 high-level interface.  These functions are not (yet) officially part of
 the library, and are minimally documented here.  If they break, you
@@ -582,6 +590,15 @@ if you are feeling especially paranoid.  I would be interested in
 hearing more about the robustness of the library to corrupted
 compressed data.
 
+Version 1.0 is much more robust in this respect than
+0.9.0 or 0.9.5.  Investigations with Checker (a tool for 
+detecting problems with memory management, similar to Purify)
+indicate that, at least for the few files I tested, all single-bit
+errors in the decompressed data are caught properly, with no
+segmentation faults, no reads of uninitialised data and no 
+out of range reads or writes.  So it's certainly much improved,
+although I wouldn't claim it to be totally bombproof.
+
 The file @code{bzlib.h} contains all definitions needed to use
 the library.  In particular, you should definitely not include
 @code{bzlib_private.h}.
@@ -598,7 +615,7 @@ The requested action was completed successfully.
 @item BZ_RUN_OK
 @itemx BZ_FLUSH_OK
 @itemx BZ_FINISH_OK
-In @code{bzCompress}, the requested flush/finish/nothing-special action
+In @code{BZ2_bzCompress}, the requested flush/finish/nothing-special action
 was completed successfully.
 @item BZ_STREAM_END
 Compression of data was completed, or the logical stream end was
@@ -607,6 +624,16 @@ detected during decompression.
 
 The following return values indicate an error of some kind.
 @table @code
+@item BZ_CONFIG_ERROR
+Indicates that the library has been improperly compiled on your
+platform -- a major configuration error.  Specifically, it means
+that @code{sizeof(char)}, @code{sizeof(short)} and @code{sizeof(int)}
+are not 1, 2 and 4 respectively, as they should be.  Note that the 
+library should still work properly on 64-bit platforms which follow
+the LP64 programming model -- that is, where @code{sizeof(long)}
+and @code{sizeof(void*)} are 8.  Under LP64, @code{sizeof(int)} is
+still 4, so @code{libbzip2}, which doesn't use the @code{long} type,
+is OK.
 @item BZ_SEQUENCE_ERROR
 When using the library, it is important to call the functions in the
 correct sequence and with data structures (buffers etc) in the correct
@@ -624,10 +651,10 @@ making.
 @item BZ_MEM_ERROR
 Returned when a request to allocate memory failed.  Note that the
 quantity of memory needed to decompress a stream cannot be determined
-until the stream's header has been read.  So @code{bzDecompress} and
-@code{bzRead} may return @code{BZ_MEM_ERROR} even though some of
+until the stream's header has been read.  So @code{BZ2_bzDecompress} and
+@code{BZ2_bzRead} may return @code{BZ_MEM_ERROR} even though some of
 the compressed data has been read.  The same is not true for
-compression; once @code{bzCompressInit} or @code{bzWriteOpen} have
+compression; once @code{BZ2_bzCompressInit} or @code{BZ2_bzWriteOpen} have
 successfully completed, @code{BZ_MEM_ERROR} cannot occur.
 @item BZ_DATA_ERROR
 Returned when a data integrity error is detected during decompression.
@@ -639,19 +666,19 @@ As a special case of @code{BZ_DATA_ERROR}, it is sometimes useful to
 know when the compressed stream does not start with the correct
 magic bytes (@code{'B' 'Z' 'h'}).  
 @item BZ_IO_ERROR
-Returned by @code{bzRead} and @code{bzRead} when there is an error
-reading or writing in the compressed file, and by @code{bzReadOpen}
-and @code{bzWriteOpen} for attempts to use a file for which the
+Returned by @code{BZ2_bzRead} and @code{BZ2_bzWrite} when there is an error
+reading or writing in the compressed file, and by @code{BZ2_bzReadOpen}
+and @code{BZ2_bzWriteOpen} for attempts to use a file for which the
 error indicator (viz, @code{ferror(f)}) is set.
 On receipt of @code{BZ_IO_ERROR}, the caller should consult
 @code{errno} and/or @code{perror} to acquire operating-system
 specific information about the problem.
 @item BZ_UNEXPECTED_EOF
-Returned by @code{bzRead} when the compressed file finishes
+Returned by @code{BZ2_bzRead} when the compressed file finishes
 before the logical end of stream is detected.
 @item BZ_OUTBUFF_FULL
-Returned by @code{bzBuffToBuffCompress} and
-@code{bzBuffToBuffDecompress} to indicate that the output data
+Returned by @code{BZ2_bzBuffToBuffCompress} and
+@code{BZ2_bzBuffToBuffDecompress} to indicate that the output data
 will not fit into the output buffer provided.
 @end table
 
@@ -659,17 +686,19 @@ will not fit into the output buffer provided.
 
 @section Low-level interface
 
-@subsection @code{bzCompressInit}
+@subsection @code{BZ2_bzCompressInit}
 @example
 typedef 
    struct @{
       char *next_in;
       unsigned int avail_in;
-      unsigned int total_in;
+      unsigned int total_in_lo32;
+      unsigned int total_in_hi32;
 
       char *next_out;
       unsigned int avail_out;
-      unsigned int total_out;
+      unsigned int total_out_lo32;
+      unsigned int total_out_hi32;
 
       void *state;
 
@@ -679,10 +708,10 @@ typedef
    @} 
    bz_stream;
 
-int bzCompressInit ( bz_stream *strm, 
-                     int blockSize100k, 
-                     int verbosity,
-                     int workFactor );
+int BZ2_bzCompressInit ( bz_stream *strm, 
+                         int blockSize100k, 
+                         int verbosity,
+                         int workFactor );
 
 @end example
 
@@ -712,14 +741,19 @@ If you don't want to use a custom memory allocator, set @code{bzalloc},
 and the library will then use the standard @code{malloc}/@code{free}
 routines.
 
-Before calling @code{bzCompressInit}, fields @code{bzalloc}, 
+Before calling @code{BZ2_bzCompressInit}, fields @code{bzalloc}, 
 @code{bzfree} and @code{opaque} should
 be filled appropriately, as just described.  Upon return, the internal
-state will have been allocated and initialised, and @code{total_in} and 
-@code{total_out} will have been set to zero.  
-These last two fields are used by the library
+state will have been allocated and initialised, and @code{total_in_lo32}, 
+@code{total_in_hi32}, @code{total_out_lo32} and 
+@code{total_out_hi32} will have been set to zero.  
+These four fields are used by the library
 to inform the caller of the total amount of data passed into and out of
 the library, respectively.  You should not try to change them.
+As of version 1.0, 64-bit counts are maintained, even on 32-bit
+platforms, using the @code{_hi32} fields to store the upper 32 bits
+of the count.  So, for example, the total amount of data in
+is @code{(total_in_hi32 << 32) + total_in_lo32}.
 
 Parameter @code{blockSize100k} specifies the block size to be used for
 compression.  It should be a value between 1 and 9 inclusive, and the
@@ -761,6 +795,8 @@ mechanism would render the parameter obsolete.
 
 Possible return values:
 @display
+      @code{BZ_CONFIG_ERROR}
+         if the library has been mis-compiled
       @code{BZ_PARAM_ERROR} 
          if @code{strm} is @code{NULL} 
          or @code{blockSize} < 1 or @code{blockSize} > 9
@@ -773,86 +809,86 @@ Possible return values:
 @end display
 Allowable next actions:
 @display
-      @code{bzCompress} 
+      @code{BZ2_bzCompress} 
          if @code{BZ_OK} is returned
       no specific action needed in case of error
 @end display
 
-@subsection @code{bzCompress}
+@subsection @code{BZ2_bzCompress}
 @example
-   int bzCompress ( bz_stream *strm, int action );
+   int BZ2_bzCompress ( bz_stream *strm, int action );
 @end example
 Provides more input and/or output buffer space for the library.  The
-caller maintains input and output buffers, and calls @code{bzCompress} to
+caller maintains input and output buffers, and calls @code{BZ2_bzCompress} to
 transfer data between them.
 
-Before each call to @code{bzCompress}, @code{next_in} should point at
+Before each call to @code{BZ2_bzCompress}, @code{next_in} should point at
 the data to be compressed, and @code{avail_in} should indicate how many
-bytes the library may read.  @code{bzCompress} updates @code{next_in},
+bytes the library may read.  @code{BZ2_bzCompress} updates @code{next_in},
 @code{avail_in} and @code{total_in} to reflect the number of bytes it
 has read.
 
 Similarly, @code{next_out} should point to a buffer in which the
 compressed data is to be placed, with @code{avail_out} indicating how
-much output space is available.  @code{bzCompress} updates
+much output space is available.  @code{BZ2_bzCompress} updates
 @code{next_out}, @code{avail_out} and @code{total_out} to reflect the
 number of bytes output.
 
 You may provide and remove as little or as much data as you like on each
-call of @code{bzCompress}.  In the limit, it is acceptable to supply and
+call of @code{BZ2_bzCompress}.  In the limit, it is acceptable to supply and
 remove data one byte at a time, although this would be terribly
 inefficient.  You should always ensure that at least one byte of output
 space is available at each call.
 
-A second purpose of @code{bzCompress} is to request a change of mode of the
+A second purpose of @code{BZ2_bzCompress} is to request a change of mode of the
 compressed stream.  
 
 Conceptually, a compressed stream can be in one of four states: IDLE,
 RUNNING, FLUSHING and FINISHING.  Before initialisation
-(@code{bzCompressInit}) and after termination (@code{bzCompressEnd}), a
+(@code{BZ2_bzCompressInit}) and after termination (@code{BZ2_bzCompressEnd}), a
 stream is regarded as IDLE.
 
-Upon initialisation (@code{bzCompressInit}), the stream is placed in the
-RUNNING state.  Subsequent calls to @code{bzCompress} should pass
+Upon initialisation (@code{BZ2_bzCompressInit}), the stream is placed in the
+RUNNING state.  Subsequent calls to @code{BZ2_bzCompress} should pass
 @code{BZ_RUN} as the requested action; other actions are illegal and
 will result in @code{BZ_SEQUENCE_ERROR}.
 
 At some point, the calling program will have provided all the input data
 it wants to.  It will then want to finish up -- in effect, asking the
 library to process any data it might have buffered internally.  In this
-state, @code{bzCompress} will no longer attempt to read data from
+state, @code{BZ2_bzCompress} will no longer attempt to read data from
 @code{next_in}, but it will want to write data to @code{next_out}.
 Because the output buffer supplied by the user can be arbitrarily small,
 the finishing-up operation cannot necessarily be done with a single call
-of @code{bzCompress}.
+of @code{BZ2_bzCompress}.
 
 Instead, the calling program passes @code{BZ_FINISH} as an action to
-@code{bzCompress}.  This changes the stream's state to FINISHING.  Any
+@code{BZ2_bzCompress}.  This changes the stream's state to FINISHING.  Any
 remaining input (ie, @code{next_in[0 .. avail_in-1]}) is compressed and
-transferred to the output buffer.  To do this, @code{bzCompress} must be
+transferred to the output buffer.  To do this, @code{BZ2_bzCompress} must be
 called repeatedly until all the output has been consumed.  At that
-point, @code{bzCompress} returns @code{BZ_STREAM_END}, and the stream's
-state is set back to IDLE.  @code{bzCompressEnd} should then be
+point, @code{BZ2_bzCompress} returns @code{BZ_STREAM_END}, and the stream's
+state is set back to IDLE.  @code{BZ2_bzCompressEnd} should then be
 called.
 
 Just to make sure the calling program does not cheat, the library makes
 a note of @code{avail_in} at the time of the first call to
-@code{bzCompress} which has @code{BZ_FINISH} as an action (ie, at the
+@code{BZ2_bzCompress} which has @code{BZ_FINISH} as an action (ie, at the
 time the program has announced its intention to not supply any more
 input).  By comparing this value with that of @code{avail_in} over
-subsequent calls to @code{bzCompress}, the library can detect any
+subsequent calls to @code{BZ2_bzCompress}, the library can detect any
 attempts to slip in more data to compress.  Any calls for which this is
 detected will return @code{BZ_SEQUENCE_ERROR}.  This indicates a
 programming mistake which should be corrected.
 
 Instead of asking to finish, the calling program may ask
-@code{bzCompress} to take all the remaining input, compress it and
+@code{BZ2_bzCompress} to take all the remaining input, compress it and
 terminate the current (Burrows-Wheeler) compression block.  This could
 be useful for error control purposes.  The mechanism is analogous to
-that for finishing: call @code{bzCompress} with an action of
+that for finishing: call @code{BZ2_bzCompress} with an action of
 @code{BZ_FLUSH}, remove output data, and persist with the
 @code{BZ_FLUSH} action until the value @code{BZ_RUN} is returned.  As
-with finishing, @code{bzCompress} detects any attempt to provide more
+with finishing, @code{BZ2_bzCompress} detects any attempt to provide more
 input data once the flush has begun.
 
 Once the flush is complete, the stream returns to the normal RUNNING
@@ -863,11 +899,11 @@ which shows which actions are allowable in each state, what action
 will be taken, what the next state is, and what the non-error return
 values are.  Note that you can't explicitly ask what state the
 stream is in, but nor do you need to -- it can be inferred from the
-values returned by @code{bzCompress}.
+values returned by @code{BZ2_bzCompress}.
 @display
 IDLE/@code{any}           
-      Illegal.  IDLE state only exists after @code{bzCompressEnd} or
-      before @code{bzCompressInit}.
+      Illegal.  IDLE state only exists after @code{BZ2_bzCompressEnd} or
+      before @code{BZ2_bzCompressInit}.
       Return value = @code{BZ_SEQUENCE_ERROR}
 
 RUNNING/@code{BZ_RUN}     
@@ -917,21 +953,21 @@ FINISHING/other
 That still looks complicated?  Well, fair enough.  The usual sequence
 of calls for compressing a load of data is:
 @itemize @bullet
-@item Get started with @code{bzCompressInit}.
+@item Get started with @code{BZ2_bzCompressInit}.
 @item Shovel data in and shlurp out its compressed form using zero or more
-calls of @code{bzCompress} with action = @code{BZ_RUN}.
+calls of @code{BZ2_bzCompress} with action = @code{BZ_RUN}.
 @item Finish up.  
-Repeatedly call @code{bzCompress} with action = @code{BZ_FINISH}, 
+Repeatedly call @code{BZ2_bzCompress} with action = @code{BZ_FINISH}, 
 copying out the compressed output, until @code{BZ_STREAM_END} is returned.
-@item Close up and go home.  Call @code{bzCompressEnd}.
+@item Close up and go home.  Call @code{BZ2_bzCompressEnd}.
 @end itemize
 If the data you want to compress fits into your input buffer all
-at once, you can skip the calls of @code{bzCompress ( ..., BZ_RUN )} and 
-just do the @code{bzCompress ( ..., BZ_FINISH )} calls.
+at once, you can skip the calls of @code{BZ2_bzCompress ( ..., BZ_RUN )} and 
+just do the @code{BZ2_bzCompress ( ..., BZ_FINISH )} calls.
 
-All required memory is allocated by @code{bzCompressInit}.  The
+All required memory is allocated by @code{BZ2_bzCompressInit}.  The
 compression library can accept any data at all (obviously).  So you
-shouldn't get any error return values from the @code{bzCompress} calls.
+shouldn't get any error return values from the @code{BZ2_bzCompress} calls.
 If you do, they will be @code{BZ_SEQUENCE_ERROR}, and indicate a bug in
 your programming.
 
@@ -941,9 +977,9 @@ Trivial other possible return values:
          if @code{strm} is @code{NULL}, or @code{strm->s} is @code{NULL}
 @end display
 
-@subsection @code{bzCompressEnd}
+@subsection @code{BZ2_bzCompressEnd}
 @example
-int bzCompressEnd ( bz_stream *strm );
+int BZ2_bzCompressEnd ( bz_stream *strm );
 @end example
 Releases all memory associated with a compression stream.
 
@@ -954,11 +990,11 @@ Possible return values:
 @end display
 
 
-@subsection @code{bzDecompressInit}
+@subsection @code{BZ2_bzDecompressInit}
 @example
-int bzDecompressInit ( bz_stream *strm, int verbosity, int small );
+int BZ2_bzDecompressInit ( bz_stream *strm, int verbosity, int small );
 @end example
-Prepares for decompression.  As with @code{bzCompressInit}, a
+Prepares for decompression.  As with @code{BZ2_bzCompressInit}, a
 @code{bz_stream} record should be allocated and initialised before the
 call.  Fields @code{bzalloc}, @code{bzfree} and @code{opaque} should be
 set if a custom memory allocator is required, or made @code{NULL} for
@@ -966,7 +1002,7 @@ the normal @code{malloc}/@code{free} routines.  Upon return, the internal
 state will have been initialised, and @code{total_in} and
 @code{total_out} will be zero.
 
-For the meaning of parameter @code{verbosity}, see @code{bzCompressInit}.
+For the meaning of parameter @code{verbosity}, see @code{BZ2_bzCompressInit}.
 
 If @code{small} is nonzero, the library will use an alternative
 decompression algorithm which uses less memory but at the cost of
@@ -976,11 +1012,13 @@ more information on memory management.
 
 Note that the amount of memory needed to decompress
 a stream cannot be determined until the stream's header has been read,
-so even if @code{bzDecompressInit} succeeds, a subsequent
-@code{bzDecompress} could fail with @code{BZ_MEM_ERROR}.
+so even if @code{BZ2_bzDecompressInit} succeeds, a subsequent
+@code{BZ2_bzDecompress} could fail with @code{BZ_MEM_ERROR}.
 
 Possible return values:
 @display
+      @code{BZ_CONFIG_ERROR}
+         if the library has been mis-compiled
       @code{BZ_PARAM_ERROR}
          if @code{(small != 0 && small != 1)}
          or @code{(verbosity < 0 || verbosity > 4)}
@@ -990,54 +1028,54 @@ Possible return values:
 
 Allowable next actions:
 @display
-      @code{bzDecompress}
+      @code{BZ2_bzDecompress}
          if @code{BZ_OK} was returned
       no specific action required in case of error
 @end display
 
  
 
-@subsection @code{bzDecompress}
+@subsection @code{BZ2_bzDecompress}
 @example
-int bzDecompress ( bz_stream *strm );
+int BZ2_bzDecompress ( bz_stream *strm );
 @end example
 Provides more input and/out output buffer space for the library.  The
-caller maintains input and output buffers, and uses @code{bzDecompress}
+caller maintains input and output buffers, and uses @code{BZ2_bzDecompress}
 to transfer data between them.
 
-Before each call to @code{bzDecompress}, @code{next_in} 
+Before each call to @code{BZ2_bzDecompress}, @code{next_in} 
 should point at the compressed data,
 and @code{avail_in} should indicate how many bytes the library
-may read.  @code{bzDecompress} updates @code{next_in}, @code{avail_in} 
+may read.  @code{BZ2_bzDecompress} updates @code{next_in}, @code{avail_in} 
 and @code{total_in}
 to reflect the number of bytes it has read.
 
 Similarly, @code{next_out} should point to a buffer in which the uncompressed
 output is to be placed, with @code{avail_out} indicating how much output space
-is available.  @code{bzCompress} updates @code{next_out},
+is available.  @code{BZ2_bzCompress} updates @code{next_out},
 @code{avail_out} and @code{total_out} to reflect
 the number of bytes output.
 
 You may provide and remove as little or as much data as you like on
-each call of @code{bzDecompress}.  
+each call of @code{BZ2_bzDecompress}.  
 In the limit, it is acceptable to
 supply and remove data one byte at a time, although this would be
 terribly inefficient.  You should always ensure that at least one
 byte of output space is available at each call.
 
-Use of @code{bzDecompress} is simpler than @code{bzCompress}.
+Use of @code{BZ2_bzDecompress} is simpler than @code{BZ2_bzCompress}.
 
 You should provide input and remove output as described above, and
-repeatedly call @code{bzDecompress} until @code{BZ_STREAM_END} is
+repeatedly call @code{BZ2_bzDecompress} until @code{BZ_STREAM_END} is
 returned.  Appearance of @code{BZ_STREAM_END} denotes that
-@code{bzDecompress} has detected the logical end of the compressed
-stream.  @code{bzDecompress} will not produce @code{BZ_STREAM_END} until
+@code{BZ2_bzDecompress} has detected the logical end of the compressed
+stream.  @code{BZ2_bzDecompress} will not produce @code{BZ_STREAM_END} until
 all output data has been placed into the output buffer, so once
 @code{BZ_STREAM_END} appears, you are guaranteed to have available all
-the decompressed output, and @code{bzDecompressEnd} can safely be
+the decompressed output, and @code{BZ2_bzDecompressEnd} can safely be
 called.
 
-If case of an error return value, you should call @code{bzDecompressEnd}
+If case of an error return value, you should call @code{BZ2_bzDecompressEnd}
 to clean up and release memory.
 
 Possible return values:
@@ -1059,16 +1097,16 @@ Possible return values:
 @end display
 Allowable next actions:
 @display
-      @code{bzDecompress}
+      @code{BZ2_bzDecompress}
          if @code{BZ_OK} was returned
-      @code{bzDecompressEnd}
+      @code{BZ2_bzDecompressEnd}
          otherwise
 @end display
 
 
-@subsection @code{bzDecompressEnd}
+@subsection @code{BZ2_bzDecompressEnd}
 @example
-int bzDecompressEnd ( bz_stream *strm );
+int BZ2_bzDecompressEnd ( bz_stream *strm );
 @end example
 Releases all memory associated with a decompression stream.
 
@@ -1107,16 +1145,16 @@ This interface provides functions for reading and writing
   given on a per-function basis below.
 @item If @code{bzerror} indicates an error 
   (ie, anything except @code{BZ_OK} and @code{BZ_STREAM_END}),
-  you should immediately call @code{bzReadClose} (or @code{bzWriteClose},
+  you should immediately call @code{BZ2_bzReadClose} (or @code{BZ2_bzWriteClose},
   depending on whether you are attempting to read or to write)
   to free up all resources associated
   with the stream.  Once an error has been indicated, behaviour of all calls
-  except @code{bzReadClose} (@code{bzWriteClose}) is undefined.  
+  except @code{BZ2_bzReadClose} (@code{BZ2_bzWriteClose}) is undefined.  
   The implication is that (1) @code{bzerror} should
   be checked after each call, and (2) if @code{bzerror} indicates an error, 
-  @code{bzReadClose} (@code{bzWriteClose}) should then be called to clean up.
+  @code{BZ2_bzReadClose} (@code{BZ2_bzWriteClose}) should then be called to clean up.
 @item The @code{FILE*} arguments passed to
-   @code{bzReadOpen}/@code{bzWriteOpen}  
+   @code{BZ2_bzReadOpen}/@code{BZ2_bzWriteOpen}  
   should be set to binary mode.
   Most Unix systems will do this by default, but other platforms,
   including Windows and Mac, will not.  If you omit this, you may
@@ -1130,13 +1168,13 @@ This interface provides functions for reading and writing
 
 
 
-@subsection @code{bzReadOpen}
+@subsection @code{BZ2_bzReadOpen}
 @example
    typedef void BZFILE;
 
-   BZFILE *bzReadOpen ( int *bzerror, FILE *f, 
-                        int small, int verbosity,
-                        void *unused, int nUnused );
+   BZFILE *BZ2_bzReadOpen ( int *bzerror, FILE *f, 
+                            int small, int verbosity,
+                            void *unused, int nUnused );
 @end example
 Prepare to read compressed data from file handle @code{f}.  @code{f}
 should refer to a file which has been opened for reading, and for which
@@ -1144,7 +1182,7 @@ the error indicator (@code{ferror(f)})is not set.  If @code{small} is 1,
 the library will try to decompress using less memory, at the expense of
 speed.
 
-For reasons explained below, @code{bzRead} will decompress the
+For reasons explained below, @code{BZ2_bzRead} will decompress the
 @code{nUnused} bytes starting at @code{unused}, before starting to read
 from the file @code{f}.  At most @code{BZ_MAX_UNUSED} bytes may be
 supplied like this.  If this facility is not required, you should pass
@@ -1152,15 +1190,17 @@ supplied like this.  If this facility is not required, you should pass
 respectively.
 
 For the meaning of parameters @code{small} and @code{verbosity},
-see @code{bzDecompressInit}.
+see @code{BZ2_bzDecompressInit}.
 
 The amount of memory needed to decompress a file cannot be determined
 until the file's header has been read.  So it is possible that
-@code{bzReadOpen} returns @code{BZ_OK} but a subsequent call of
-@code{bzRead} will return @code{BZ_MEM_ERROR}.
+@code{BZ2_bzReadOpen} returns @code{BZ_OK} but a subsequent call of
+@code{BZ2_bzRead} will return @code{BZ_MEM_ERROR}.
 
 Possible assignments to @code{bzerror}:
 @display
+      @code{BZ_CONFIG_ERROR}
+         if the library has been mis-compiled
       @code{BZ_PARAM_ERROR}
          if @code{f} is @code{NULL} 
          or @code{small} is neither @code{0} nor @code{1}                 
@@ -1184,16 +1224,16 @@ Possible return values:
 
 Allowable next actions:
 @display
-      @code{bzRead}
+      @code{BZ2_bzRead}
          if @code{bzerror} is @code{BZ_OK}   
-      @code{bzClose} 
+      @code{BZ2_bzClose} 
          otherwise
 @end display
 
 
-@subsection @code{bzRead}
+@subsection @code{BZ2_bzRead}
 @example
-   int bzRead ( int *bzerror, BZFILE *b, void *buf, int len );
+   int BZ2_bzRead ( int *bzerror, BZFILE *b, void *buf, int len );
 @end example
 Reads up to @code{len} (uncompressed) bytes from the compressed file 
 @code{b} into
@@ -1204,7 +1244,7 @@ was detected, @code{bzerror} will be set to @code{BZ_STREAM_END},
 and the number
 of bytes read is returned.  All other @code{bzerror} values denote an error.
 
-@code{bzRead} will supply @code{len} bytes,
+@code{BZ2_bzRead} will supply @code{len} bytes,
 unless the logical stream end is detected
 or an error occurs.  Because of this, it is possible to detect the 
 stream end by observing when the number of bytes returned is 
@@ -1213,20 +1253,20 @@ requested.  Nevertheless, this is regarded as inadvisable; you should
 instead check @code{bzerror} after every call and watch out for
 @code{BZ_STREAM_END}.
 
-Internally, @code{bzRead} copies data from the compressed file in chunks
+Internally, @code{BZ2_bzRead} copies data from the compressed file in chunks
 of size @code{BZ_MAX_UNUSED} bytes
 before decompressing it.  If the file contains more bytes than strictly
-needed to reach the logical end-of-stream, @code{bzRead} will almost certainly
+needed to reach the logical end-of-stream, @code{BZ2_bzRead} will almost certainly
 read some of the trailing data before signalling @code{BZ_SEQUENCE_END}.
 To collect the read but unused data once @code{BZ_SEQUENCE_END} has 
-appeared, call @code{bzReadGetUnused} immediately before @code{bzReadClose}.
+appeared, call @code{BZ2_bzReadGetUnused} immediately before @code{BZ2_bzReadClose}.
 
 Possible assignments to @code{bzerror}:
 @display
       @code{BZ_PARAM_ERROR}
          if @code{b} is @code{NULL} or @code{buf} is @code{NULL} or @code{len < 0}
       @code{BZ_SEQUENCE_ERROR} 
-         if @code{b} was opened with @code{bzWriteOpen}
+         if @code{b} was opened with @code{BZ2_bzWriteOpen}
       @code{BZ_IO_ERROR} 
          if there is an error reading from the compressed file
       @code{BZ_UNEXPECTED_EOF} 
@@ -1254,28 +1294,28 @@ Possible return values:
 
 Allowable next actions:
 @display
-      collect data from @code{buf}, then @code{bzRead} or @code{bzReadClose}
+      collect data from @code{buf}, then @code{BZ2_bzRead} or @code{BZ2_bzReadClose}
          if @code{bzerror} is @code{BZ_OK} 
-      collect data from @code{buf}, then @code{bzReadClose} or @code{bzReadGetUnused} 
+      collect data from @code{buf}, then @code{BZ2_bzReadClose} or @code{BZ2_bzReadGetUnused} 
          if @code{bzerror} is @code{BZ_SEQUENCE_END}   
-      @code{bzReadClose} 
+      @code{BZ2_bzReadClose} 
          otherwise
 @end display
 
 
 
-@subsection @code{bzReadGetUnused}
+@subsection @code{BZ2_bzReadGetUnused}
 @example
-   void bzReadGetUnused ( int* bzerror, BZFILE *b, 
-                          void** unused, int* nUnused );
+   void BZ2_bzReadGetUnused ( int* bzerror, BZFILE *b, 
+                              void** unused, int* nUnused );
 @end example
 Returns data which was read from the compressed file but was not needed
 to get to the logical end-of-stream.  @code{*unused} is set to the address
 of the data, and @code{*nUnused} to the number of bytes.  @code{*nUnused} will
 be set to a value between @code{0} and @code{BZ_MAX_UNUSED} inclusive.
 
-This function may only be called once @code{bzRead} has signalled 
-@code{BZ_STREAM_END} but before @code{bzReadClose}.
+This function may only be called once @code{BZ2_bzRead} has signalled 
+@code{BZ_STREAM_END} but before @code{BZ2_bzReadClose}.
 
 Possible assignments to @code{bzerror}:
 @display
@@ -1284,31 +1324,31 @@ Possible assignments to @code{bzerror}:
          or @code{unused} is @code{NULL} or @code{nUnused} is @code{NULL}
       @code{BZ_SEQUENCE_ERROR} 
          if @code{BZ_STREAM_END} has not been signalled
-         or if @code{b} was opened with @code{bzWriteOpen}
+         or if @code{b} was opened with @code{BZ2_bzWriteOpen}
      @code{BZ_OK}
          otherwise
 @end display
 
 Allowable next actions:
 @display 
-      @code{bzReadClose}
+      @code{BZ2_bzReadClose}
 @end display
 
 
-@subsection @code{bzReadClose}
+@subsection @code{BZ2_bzReadClose}
 @example
-   void bzReadClose ( int *bzerror, BZFILE *b );
+   void BZ2_bzReadClose ( int *bzerror, BZFILE *b );
 @end example
 Releases all memory pertaining to the compressed file @code{b}.  
-@code{bzReadClose} does not call @code{fclose} on the underlying file
+@code{BZ2_bzReadClose} does not call @code{fclose} on the underlying file
 handle, so you should do that yourself if appropriate.
-@code{bzReadClose} should be called to clean up after all error
+@code{BZ2_bzReadClose} should be called to clean up after all error
 situations.
 
 Possible assignments to @code{bzerror}:
 @display
       @code{BZ_SEQUENCE_ERROR} 
-         if @code{b} was opened with @code{bzOpenWrite} 
+         if @code{b} was opened with @code{BZ2_bzOpenWrite} 
       @code{BZ_OK} 
          otherwise
 @end display
@@ -1320,11 +1360,11 @@ Allowable next actions:
 
 
 
-@subsection @code{bzWriteOpen}
+@subsection @code{BZ2_bzWriteOpen}
 @example
-   BZFILE *bzWriteOpen ( int *bzerror, FILE *f, 
-                         int blockSize100k, int verbosity,
-                         int workFactor );
+   BZFILE *BZ2_bzWriteOpen ( int *bzerror, FILE *f, 
+                             int blockSize100k, int verbosity,
+                             int workFactor );
 @end example
 Prepare to write compressed data to file handle @code{f}.  
 @code{f} should refer to
@@ -1333,14 +1373,16 @@ indicator (@code{ferror(f)})is not set.
 
 For the meaning of parameters @code{blockSize100k},
 @code{verbosity} and @code{workFactor}, see
-@* @code{bzCompressInit}.
+@* @code{BZ2_bzCompressInit}.
 
 All required memory is allocated at this stage, so if the call
 completes successfully, @code{BZ_MEM_ERROR} cannot be signalled by a
-subsequent call to @code{bzWrite}.
+subsequent call to @code{BZ2_bzWrite}.
 
 Possible assignments to @code{bzerror}:
 @display 
+      @code{BZ_CONFIG_ERROR}
+         if the library has been mis-compiled
       @code{BZ_PARAM_ERROR} 
          if @code{f} is @code{NULL} 
          or @code{blockSize100k < 1} or @code{blockSize100k > 9}
@@ -1362,18 +1404,18 @@ Possible return values:
 
 Allowable next actions:
 @display
-      @code{bzWrite} 
+      @code{BZ2_bzWrite} 
          if @code{bzerror} is @code{BZ_OK} 
-         (you could go directly to @code{bzWriteClose}, but this would be pretty pointless)
-      @code{bzWriteClose} 
+         (you could go directly to @code{BZ2_bzWriteClose}, but this would be pretty pointless)
+      @code{BZ2_bzWriteClose} 
          otherwise
 @end display
 
 
 
-@subsection @code{bzWrite}
+@subsection @code{BZ2_bzWrite}
 @example
-   void bzWrite ( int *bzerror, BZFILE *b, void *buf, int len );
+   void BZ2_bzWrite ( int *bzerror, BZFILE *b, void *buf, int len );
 @end example
 Absorbs @code{len} bytes from the buffer @code{buf}, eventually to be
 compressed and written to the file.
@@ -1383,7 +1425,7 @@ Possible assignments to @code{bzerror}:
       @code{BZ_PARAM_ERROR} 
          if @code{b} is @code{NULL} or @code{buf} is @code{NULL} or @code{len < 0}
       @code{BZ_SEQUENCE_ERROR} 
-         if b was opened with @code{bzReadOpen}
+         if b was opened with @code{BZ2_bzReadOpen}
       @code{BZ_IO_ERROR} 
          if there is an error writing the compressed file.
       @code{BZ_OK} 
@@ -1393,22 +1435,29 @@ Possible assignments to @code{bzerror}:
 
 
 
-@subsection @code{bzWriteClose}
+@subsection @code{BZ2_bzWriteClose}
 @example
-   int bzWriteClose ( int *bzerror, BZFILE* f,
-                      int abandon,
-                      unsigned int* nbytes_in,
-                      unsigned int* nbytes_out );
+   void BZ2_bzWriteClose ( int *bzerror, BZFILE* f,
+                           int abandon,
+                           unsigned int* nbytes_in,
+                           unsigned int* nbytes_out );
+
+   void BZ2_bzWriteClose64 ( int *bzerror, BZFILE* f,
+                             int abandon,
+                             unsigned int* nbytes_in_lo32,
+                             unsigned int* nbytes_in_hi32,
+                             unsigned int* nbytes_out_lo32,
+                             unsigned int* nbytes_out_hi32 );
 @end example
 
 Compresses and flushes to the compressed file all data so far supplied
-by @code{bzWrite}.  The logical end-of-stream markers are also written, so
-subsequent calls to @code{bzWrite} are illegal.  All memory associated 
+by @code{BZ2_bzWrite}.  The logical end-of-stream markers are also written, so
+subsequent calls to @code{BZ2_bzWrite} are illegal.  All memory associated 
 with the compressed file @code{b} is released.  
 @code{fflush} is called on the
 compressed file, but it is not @code{fclose}'d.
 
-If @code{bzWriteClose} is called to clean up after an error, the only
+If @code{BZ2_bzWriteClose} is called to clean up after an error, the only
 action is to release the memory.  The library records the error codes
 issued by previous calls, so this situation will be detected
 automatically.  There is no attempt to complete the compression
@@ -1418,12 +1467,17 @@ value to @code{abandon}.
 
 If @code{nbytes_in} is non-null, @code{*nbytes_in} will be set to be the
 total volume of uncompressed data handled.  Similarly, @code{nbytes_out}
-will be set to the total volume of compressed data written.
+will be set to the total volume of compressed data written.  For 
+compatibility with older versions of the library, @code{BZ2_bzWriteClose}
+only yields the lower 32 bits of these counts.  Use
+@code{BZ2_bzWriteClose64} if you want the full 64 bit counts.  These
+two functions are otherwise absolutely identical.
+
 
 Possible assignments to @code{bzerror}:
 @display
       @code{BZ_SEQUENCE_ERROR} 
-         if @code{b} was opened with @code{bzReadOpen}
+         if @code{b} was opened with @code{BZ2_bzReadOpen}
       @code{BZ_IO_ERROR} 
          if there is an error writing the compressed file
       @code{BZ_OK} 
@@ -1442,26 +1496,26 @@ The calling application can write its own data before and after the
 compressed data stream, using that same file handle.
 @item Reading is more complex, and the facilities are not as general
 as they could be since generality is hard to reconcile with efficiency.
-@code{bzRead} reads from the compressed file in blocks of size
+@code{BZ2_bzRead} reads from the compressed file in blocks of size
 @code{BZ_MAX_UNUSED} bytes, and in doing so probably will overshoot
 the logical end of compressed stream.
 To recover this data once decompression has
-ended, call @code{bzReadGetUnused} after the last call of @code{bzRead}
+ended, call @code{BZ2_bzReadGetUnused} after the last call of @code{BZ2_bzRead}
 (the one returning @code{BZ_STREAM_END}) but before calling
-@code{bzReadClose}.
+@code{BZ2_bzReadClose}.
 @end itemize
 
 This mechanism makes it easy to decompress multiple @code{bzip2}
-streams placed end-to-end.  As the end of one stream, when @code{bzRead}
-returns @code{BZ_STREAM_END}, call @code{bzReadGetUnused} to collect the
+streams placed end-to-end.  As the end of one stream, when @code{BZ2_bzRead}
+returns @code{BZ_STREAM_END}, call @code{BZ2_bzReadGetUnused} to collect the
 unused data (copy it into your own buffer somewhere).  
 That data forms the start of the next compressed stream.
-To start uncompressing that next stream, call @code{bzReadOpen} again,
+To start uncompressing that next stream, call @code{BZ2_bzReadOpen} again,
 feeding in the unused data via the @code{unused}/@code{nUnused}
 parameters.
 Keep doing this until @code{BZ_STREAM_END} return coincides with the
 physical end of file (@code{feof(f)}).  In this situation
-@code{bzReadGetUnused}
+@code{BZ2_bzReadGetUnused}
 will of course return no data.
 
 This should give some feel for how the high-level interface can be used.
@@ -1482,22 +1536,22 @@ f = fopen ( "myfile.bz2", "w" );
 if (!f) @{
    /* handle error */
 @}
-b = bzWriteOpen ( &bzerror, f, 9 );
+b = BZ2_bzWriteOpen ( &bzerror, f, 9 );
 if (bzerror != BZ_OK) @{
-   bzWriteClose ( b );
+   BZ2_bzWriteClose ( b );
    /* handle error */
 @}
 
 while ( /* condition */ ) @{
    /* get data to write into buf, and set nBuf appropriately */
-   nWritten = bzWrite ( &bzerror, b, buf, nBuf );
+   nWritten = BZ2_bzWrite ( &bzerror, b, buf, nBuf );
    if (bzerror == BZ_IO_ERROR) @{ 
-      bzWriteClose ( &bzerror, b );
+      BZ2_bzWriteClose ( &bzerror, b );
       /* handle error */
    @}
 @}
 
-bzWriteClose ( &bzerror, b );
+BZ2_bzWriteClose ( &bzerror, b );
 if (bzerror == BZ_IO_ERROR) @{
    /* handle error */
 @}
@@ -1515,39 +1569,39 @@ f = fopen ( "myfile.bz2", "r" );
 if (!f) @{
    /* handle error */
 @}
-b = bzReadOpen ( &bzerror, f, 0, NULL, 0 );
+b = BZ2_bzReadOpen ( &bzerror, f, 0, NULL, 0 );
 if (bzerror != BZ_OK) @{
-   bzReadClose ( &bzerror, b );
+   BZ2_bzReadClose ( &bzerror, b );
    /* handle error */
 @}
 
 bzerror = BZ_OK;
 while (bzerror == BZ_OK && /* arbitrary other conditions */) @{
-   nBuf = bzRead ( &bzerror, b, buf, /* size of buf */ );
+   nBuf = BZ2_bzRead ( &bzerror, b, buf, /* size of buf */ );
    if (bzerror == BZ_OK) @{
       /* do something with buf[0 .. nBuf-1] */
    @}
 @}
 if (bzerror != BZ_STREAM_END) @{
-   bzReadClose ( &bzerror, b );
+   BZ2_bzReadClose ( &bzerror, b );
    /* handle error */
 @} else @{
-   bzReadClose ( &bzerror );
+   BZ2_bzReadClose ( &bzerror );
 @}
 @end example
 
 
 
 @section Utility functions
-@subsection @code{bzBuffToBuffCompress}
+@subsection @code{BZ2_bzBuffToBuffCompress}
 @example
-   int bzBuffToBuffCompress( char*         dest,
-                             unsigned int* destLen,
-                             char*         source,
-                             unsigned int  sourceLen,
-                             int           blockSize100k,
-                             int           verbosity,
-                             int           workFactor );
+   int BZ2_bzBuffToBuffCompress( char*         dest,
+                                 unsigned int* destLen,
+                                 char*         source,
+                                 unsigned int  sourceLen,
+                                 int           blockSize100k,
+                                 int           verbosity,
+                                 int           workFactor );
 @end example
 Attempts to compress the data in @code{source[0 .. sourceLen-1]}
 into the destination buffer, @code{dest[0 .. *destLen-1]}.
@@ -1563,17 +1617,19 @@ additional calls to provide extra input data.  If you want that kind of
 mechanism, use the low-level interface.
 
 For the meaning of parameters @code{blockSize100k}, @code{verbosity}
-and @code{workFactor}, @* see @code{bzCompressInit}.
+and @code{workFactor}, @* see @code{BZ2_bzCompressInit}.
 
 To guarantee that the compressed data will fit in its buffer, allocate
 an output buffer of size 1% larger than the uncompressed data, plus
 six hundred extra bytes.
 
-@code{bzBuffToBuffDecompress} will not write data at or
+@code{BZ2_bzBuffToBuffDecompress} will not write data at or
 beyond @code{dest[*destLen]}, even in case of buffer overflow.
 
 Possible return values:
 @display
+      @code{BZ_CONFIG_ERROR}
+         if the library has been mis-compiled
       @code{BZ_PARAM_ERROR} 
          if @code{dest} is @code{NULL} or @code{destLen} is @code{NULL}
          or @code{blockSize100k < 1} or @code{blockSize100k > 9}
@@ -1589,14 +1645,14 @@ Possible return values:
 
 
 
-@subsection @code{bzBuffToBuffDecompress}
+@subsection @code{BZ2_bzBuffToBuffDecompress}
 @example
-   int bzBuffToBuffDecompress ( char*         dest,
-                                unsigned int* destLen,
-                                char*         source,
-                                unsigned int  sourceLen,
-                                int           small,
-                                int           verbosity );
+   int BZ2_bzBuffToBuffDecompress ( char*         dest,
+                                    unsigned int* destLen,
+                                    char*         source,
+                                    unsigned int  sourceLen,
+                                    int           small,
+                                    int           verbosity );
 @end example
 Attempts to decompress the data in @code{source[0 .. sourceLen-1]}
 into the destination buffer, @code{dest[0 .. *destLen-1]}.
@@ -1606,11 +1662,11 @@ returned.  If the compressed data won't fit, @code{*destLen}
 is unchanged, and @code{BZ_OUTBUFF_FULL} is returned.
 
 @code{source} is assumed to hold a complete @code{bzip2} format
-data stream.  @code{bzBuffToBuffDecompress} tries to decompress
+data stream.  @* @code{BZ2_bzBuffToBuffDecompress} tries to decompress
 the entirety of the stream into the output buffer.
 
 For the meaning of parameters @code{small} and @code{verbosity},
-see @code{bzDecompressInit}.
+see @code{BZ2_bzDecompressInit}.
 
 Because the compression ratio of the compressed data cannot be known in
 advance, there is no easy way to guarantee that the output buffer will
@@ -1618,11 +1674,13 @@ be big enough.  You may of course make arrangements in your code to
 record the size of the uncompressed data, but such a mechanism is beyond
 the scope of this library.
 
-@code{bzBuffToBuffDecompress} will not write data at or
+@code{BZ2_bzBuffToBuffDecompress} will not write data at or
 beyond @code{dest[*destLen]}, even in case of buffer overflow.
 
 Possible return values:
 @display
+      @code{BZ_CONFIG_ERROR}
+         if the library has been mis-compiled
       @code{BZ_PARAM_ERROR} 
          if @code{dest} is @code{NULL} or @code{destLen} is @code{NULL}
          or @code{small != 0 && small != 1}
@@ -1646,40 +1704,40 @@ Possible return values:
 @section @code{zlib} compatibility functions
 Yoshioka Tsuneo has contributed some functions to
 give better @code{zlib} compatibility.  These functions are
-@code{bzopen}, @code{bzread}, @code{bzwrite}, @code{bzflush},
-@code{bzclose},
-@code{bzerror} and @code{bzlibVersion}.
+@code{BZ2_bzopen}, @code{BZ2_bzread}, @code{BZ2_bzwrite}, @code{BZ2_bzflush},
+@code{BZ2_bzclose},
+@code{BZ2_bzerror} and @code{BZ2_bzlibVersion}.
 These functions are not (yet) officially part of
 the library.  If they break, you get to keep all the pieces.
 Nevertheless, I think they work ok.
 @example
 typedef void BZFILE;
 
-const char * bzlibVersion ( void );
+const char * BZ2_bzlibVersion ( void );
 @end example
 Returns a string indicating the library version.
 @example
-BZFILE * bzopen  ( const char *path, const char *mode );
-BZFILE * bzdopen ( int        fd,    const char *mode );
+BZFILE * BZ2_bzopen  ( const char *path, const char *mode );
+BZFILE * BZ2_bzdopen ( int        fd,    const char *mode );
 @end example
 Opens a @code{.bz2} file for reading or writing, using either its name
 or a pre-existing file descriptor. 
 Analogous to @code{fopen} and @code{fdopen}.
 @example         
-int bzread  ( BZFILE* b, void* buf, int len );
-int bzwrite ( BZFILE* b, void* buf, int len );
+int BZ2_bzread  ( BZFILE* b, void* buf, int len );
+int BZ2_bzwrite ( BZFILE* b, void* buf, int len );
 @end example
 Reads/writes data from/to a previously opened @code{BZFILE}.
 Analogous to @code{fread} and @code{fwrite}.
 @example
-int  bzflush ( BZFILE* b );
-void bzclose ( BZFILE* b );
+int  BZ2_bzflush ( BZFILE* b );
+void BZ2_bzclose ( BZFILE* b );
 @end example
-Flushes/closes a @code{BZFILE}.  @code{bzflush} doesn't actually do
+Flushes/closes a @code{BZFILE}.  @code{BZ2_bzflush} doesn't actually do
 anything.  Analogous to @code{fflush} and @code{fclose}.
 
 @example 
-const char * bzerror ( BZFILE *b, int *errnum )
+const char * BZ2_bzerror ( BZFILE *b, int *errnum )
 @end example
 Returns a string describing the more recent error status of
 @code{b}, and also sets @code{*errnum} to its numerical value.
@@ -1695,9 +1753,9 @@ by compiling the library with preprocessor symbol @code{BZ_NO_STDIO}
 defined.  Doing this gives you a library containing only the following
 eight functions:
 
-@code{bzCompressInit}, @code{bzCompress}, @code{bzCompressEnd} @*
-@code{bzDecompressInit}, @code{bzDecompress}, @code{bzDecompressEnd} @*
-@code{bzBuffToBuffCompress}, @code{bzBuffToBuffDecompress}
+@code{BZ2_bzCompressInit}, @code{BZ2_bzCompress}, @code{BZ2_bzCompressEnd} @*
+@code{BZ2_bzDecompressInit}, @code{BZ2_bzDecompress}, @code{BZ2_bzDecompressEnd} @*
+@code{BZ2_bzBuffToBuffCompress}, @code{BZ2_bzBuffToBuffDecompress}
 
 When compiled like this, all functions will ignore @code{verbosity}
 settings.
@@ -1710,14 +1768,14 @@ was compiled with @code{BZ_NO_STDIO} set.
 
 For a normal compile, an assertion failure yields the message
 @example
-   bzip2/libbzip2, v0.9.5: internal error number N.
-   This is a bug in bzip2/libbzip2, v0.9.5.  Please report
-   it to me at: jseward@@acm.org.  If this happened when
-   you were using some program which uses libbzip2 as a
+   bzip2/libbzip2: internal error number N.
+   This is a bug in bzip2/libbzip2, 1.0 of 21-Mar-2000.
+   Please report it to me at: jseward@@acm.org.  If this happened
+   when you were using some program which uses libbzip2 as a
    component, you should also report this bug to the author(s)
    of that program.  Please make an effort to report this bug;
    timely and accurate bug reports eventually lead to higher
-   quality software.  Thanks.  Julian Seward, 24 May 1999.
+   quality software.  Thanks.  Julian Seward, 21 March 2000.
 @end example
 where @code{N} is some error code number.  @code{exit(3)}
 is then called.
@@ -1781,7 +1839,7 @@ These are just some random thoughts of mine.  Your mileage may
 vary.
 
 @section Limitations of the compressed file format
-@code{bzip2-0.9.5} and @code{0.9.0}
+@code{bzip2-1.0}, @code{0.9.5} and @code{0.9.0}
 use exactly the same file format as the previous
 version, @code{bzip2-0.1}.  This decision was made in the interests of
 stability.  Creating yet another incompatible compressed file format
@@ -1860,7 +1918,7 @@ require some careful design of compressed file formats.
 
 @section Portability issues
 After some consideration, I have decided not to use
-GNU @code{autoconf} to configure 0.9.5.
+GNU @code{autoconf} to configure 0.9.5 or 1.0.
 
 @code{autoconf}, admirable and wonderful though it is, 
 mainly assists with portability problems between Unix-like
@@ -1925,7 +1983,7 @@ If you get problems, try using the flags
 @code{-O2} @code{-fomit-frame-pointer} @code{-fno-strength-reduce}.
 You should specifically @emph{not} use @code{-funroll-loops}.
 
-You may notice that the Makefile runs four tests as part of
+You may notice that the Makefile runs six tests as part of
 the build process.  If the program passes all of these, it's
 a pretty good (but not 100%) indication that the compiler has
 done its job correctly.
@@ -2000,6 +2058,7 @@ memory but gets pretty good compression, and has minimal latency,
 consider Jean-loup
 Gailly's and Mark Adler's work, @code{zlib-1.1.2} and
 @code{gzip-1.2.4}.  Look for them at
+
 @code{http://www.cdrom.com/pub/infozip/zlib} and
 @code{http://www.gzip.org} respectively.
 
@@ -2140,7 +2199,14 @@ available from:
 @example
 http://www.cs.arizona.edu/people/gene/PAPERS/suffix.ps
 @end example
-
+Finally, the following paper documents some recent investigations
+I made into the performance of sorting algorithms:
+@example
+Julian Seward:
+   On the Performance of BWT Sorting Algorithms
+   Proceedings of the IEEE Data Compression Conference 2000
+     Snowbird, Utah.  28-30 March 2000.
+@end example
 
 
 @contents