                   Log of Changes Made to CFITSIO

Version 3.181 (BETA) - 12 May 2009

   - modified region.c and region.h to add support for additional
     types of region shapes that are supported by ds9: panda, epanda,
     and bpanda.

   - fixed compiler error when using the new _REENTRANT flag, having to 
     do with the an attempted static definition of Fitsio_Lock in 
     several source files, after declaring it to be non-static in fitsio2.h.
    
Version 3.18 (BETA) - 10 April 2009

   - Made extensive changes to make CFITSIO thread safe.  Previously,
     all opened FITS files shared a common pool of memory to store
     the most recently read or written FITS records in the files.
     In a multi-threaded environment different threads could 
     simultaneously read or write to this common area causing
     unpredictable results. This was changed so that every opened
     FITS file has its own private memory area for buffering the
     file. Most of the changes were in buffers.c, fitsio.h, and
     fitsio2.h. Additional changes were made to cfileio.c, mainly
     to put locks around small sections of code when setting up the
     low-level drivers to read or write the FITS file.  Also, locks
     were needed around the GZIP compression and uncompression code
     in compress.c.,  the error message stack access routine in
     fitscore.c, the encode and decode routines in fits_hcompress.c
     and  fits_hdecompress.c, in ricecomp.c,  and  the table row
     selection and table calculator functions. Also, removed the
     'static' declaration of the local variables in pliocomp.c
     which did not appeared to be required and prevented the
     routines from being thread safe.

     As a consequence of having a separate memory buffer for every
     FITS file (by default, about 115 kB per file), CFITSIO may now
     allocate more memory than previously when an application
     program opens multiple FITS files at once.  The read and write
     speed may also be slightly faster, since the buffers are not
     shared between files.

   - Added new families of Fortran wrapper routines to read and
     write values to large tables that have more than 2**31 rows. 
     The arguments that define the first row and first element to
     read or write must be I*8 integers, not ordinary I*4
     integers.  The names of these new routines have 'LL' appended
     to them, so for example, ftgcvb becomes ftgcvbll.

   Fixes
   
   - Corrected an obscure bug in imcompress.c that would have incorrectly 
     written the null values only in the rare case of writing a signed 
     byte array that is then tile compressed using the Hcompress or PLIO
     algorithm.

Version 3.14 - 18 March 2009

  Enhancements

   - modified the tiled-image compression and uncompression code to
     support compressing unsigned 16-bit integer images with PLIO.
     FITS unsigned integer arrays are offset by -32768, but the PLIO
     algorithm does not work with negative integer values.  In this
     case, an offset of 32768 is added to the array before compression,
     and then subtracted again when reading the compressed array.
     IMPORTANT NOTE:  This change is not backward compatible, so
     these PLIO compressed unsigned 16-bit integer images will not be
     read correctly by previous versions of CFITSIO; the pixel values
     will have an offset of +32768.

   - minor changes to the fpack utility to print out more complete
     version information with the -V option, and format the report
     produced by the -T option more compactly.

  Fixes
  
   - Modified imcomp_compress_image (which is called by fpack) so that
     it will preserve any null values (NaNs) if the input image has
     a floating point datatype (BITPIX = -32 or -64).  Null values in
     integer datatype images are handled correctly.

   - Modified imcomp_copy_comp2img so that it does not copy the
     ZBLANK keyword, if present, from the compressed image header
     when uncompressing the image.
     
   - Fixed typo in the Fortran wrapper macro for the ftexist function.

Version 3.13 -  5 January 2009

  Enhancements

   - updated the typedef of LONGLONG in fitsio.h and cfortran.h to
     support the Borland compiler which uses the  __int64 data type.
     
   - added new feature to the extended filename syntax so that when
     performing a filtering operation on specified HDU, if you add
     a '#' character after the name or number of the HDU, then ONLY
     that HDU (and the primary array if the HDU is a table) will be
     copied into the filtered version of the file in memory.  Otherwise,
     by default CFITSIO copies all the HDUs from the input file into
     memory.
     
   - when specifying a section, if the specified number of dimensions
     is less than the number of dimensions in the image, then CFITSIO
     will use the entire dimension, as if a '*' had been specified.
     Thus [1:100] is equivalent to [1:100,*] when specifying a section
     of 2 dimensional image.

   - modified fits_copy_image_section to read/write the section 1 row
     at a time, instead of the whole section, to reduce memory usage.

   - added new stream:// drivers for reading/writing to stdin/stdout.
     This driver is somewhat fragile, but for simple FITS read and
     write operations this driver streams the FITS file on stdin
     or stdout without first copying the entire file in memory, as is
     done when specifying the file name as "-".
   
   - slight modification to ffcopy to make sure that the END keyword
     is correctly written before copying the data.  This is required
     by the new stream driver.
     
   - modified ffgcprll, so that when writing data to an HDU, it first
     checks that the END keyword has been written to the correct place.
     This is required by the new stream driver.

  Fixes
   
   - fixed bug in ffgcls2 when reading an ASCII string column in binary
     tables in cases where the width of the column is greater than 2880 
     characters and when reading more than 1 row at a time.  Similar 
     change was made to ffpcls to fix same problem with writing to 
     columns wider than 2880 characters.
     
   - updated the source files listed in makepc.bat so that it can be
     used to build CFITSIO with the Borland C++ compiler.
     
   - fixed overflow error in ffiblk that could cause writing to Large Files
     (> 2.1 GB) to fail with an error status.
      
   - fixed a bug in the spatial region code (region.c) with the annulus 
     region.   This bug only affected specialized applications which
     directly use the internal region structure; it does not affect
     any CFITSIO functions directly.

   - fixed memory corruption bug in region.c that was triggered if the
     region file contained a large number of excluded regions.

   - got rid of a harmless error message that would appear if filtering
     a FITS table with a GTI file that has zero rows. (eval_f.c)

   - modified fits_read_rgnfile so that it removes the error messages
     from the error stack if it is unable to open the region file as
     a FITS file. (region.c)
     
Version 3.12 - 8 October 2008

   - modified the histogramming code so that the first pixel in the binned
     array is chosen as the reference pixel by default, if no other
     value is previously defined.

   - modified ffitab and ffibin to allow a null pointer to the 
     EXTNAME string, when inserting a table with no name.

Version 3.11 - 19 September 2008

   - optimized the code when tile compressing real*4 images (which get
     scaled to integers).  This produced a modest speed increase.  For 
     best performance, one must specify the absolute q quantization 
     parameter, rather than relative to the noise in the tile (which
     is expensive to compute).

   - modified the FITS region file reading code to check for NaN values,
     which signify the end of the array of points in a polygon region.

   - removed the test for LONGSIZE == 64 from fitsio.h, since it may 
     not be defined.

   - modified imcompress.c to support unconventional floating point FITS 
     images that also have BSCALE and BZERO keywords.  The compressed
     floating point images are linearly scaled twice in this case.

Version 3.10 - 20 August 2008

   - fixed a number of cases, mainly dealing with long input file names
     (> 1024 char), where unsafe usage of strcat and strcpy could have caused
     buffer overflows.  These buffer overflows could cause the application
     to crash, and at least theoretically, could be exploited by a
     malicious user to execute arbitrary code.  There are no known instances
     of this type of malicious attack on CFITSIO applications, and the
     likelihood of such an attack seems remote.  None the less, it would
     be prudent for CFITSIO users to upgrade to this new version to guard
     against this possibility.

   - modified some of the routines to define input character string
     parameters as "const char *" rather than just "char *" to eliminate
     some compiler warnings when the calling routine passes a constant
     string to the CFITSIO routine.  Most of the changes were to the
     keyword name argument in the many routines that read or write keywords.

   - fixed bug when tile-compressing a FITS image which caused all the 
     completely blank keywords in the input header to be deleted from 
     the output compressed image.  Also added a feature to preserve any
     empty FITS blocks in the header (reserved space for future keywords)
     when compressing or uncompressing an image.

   - fixed small bug in the way the default tile size is set in imcompress.c.
     (Fix sent in by Paul Price).

   - added support for reading FITS format region files (in addition
     to the ASCII format that was previously supported).  Thanks to
     Keith Arnaud for modifying region.c to do this.

Version 3.09 - 12 June 2008

   - fixed bug in the calculator function, parse_data, that evaluates 
     expressions then selecting rows or modifying values in table columns.
     This bug only appeared in unusual circumstances
     where the calculated value has a null value (= TNULLn).  The bug
     could cause elements to not be flagged as having a null value, or
     in rare cases could cause valid elements to be flagged as null. This
     only appears to have affected 64-bit platforms (where size(long) = 8).
   
   - fixed typo in imcomp_decompress_tile: call to fffi2r8 should have 
     been to fffi4r8.
     
   - in the imcopy_copy_comp2img routine, moved the call to 
     fits_translate_keywords outside of the 'if' statement.  This could 
     affect reading compressed images that did not have a EXTNAME keyword
     in the header.
     
   - fixed imcomp_compress_tile in imcompress.c to properly support
     writing unsigned integers, in place, to tile compressed images.

   - modified fits_read_compressed_img so that if the calling routine
     specifies nullval = 0, then it will not check for null-valued
     pixels in the compressed FITS image.  This mimics the same
     behavior when reading normal uncompressed FITS images.

Version 3.08 - 15 April 2008 

   - fixed backwards compatibility issue when uncompressing a Rice
     compressed image that was created with previous versions of 
     CFITSIO (this late fix was added on May 18).

   - small change to cfortran.h to add "extern" to the common block 
     definition.  This was done for compatibility with the version
     of cfortran.h that is distributed by the debian project.
   
   - relaxed the requirement that a string valued keyword must have a
     closing quote character.  If the quote is missing, CFITSIO will silently
     append a quote at the end of the keyword record.  This change was made
     because otherwise it is very difficult to correct the keyword
     because CFITSIO would exit with an error before making the fix.
   
   - added a new BYTEPIX compression parameter when tile-compressing 
     images with the Rice algorithm.

   - cached the NAXIS and NAXISn keyword values in the fitsio structure
     for efficiency, to eliminate duplicates reads of these keywords.
   
   - added variants of the Rice compression and uncompression routines to
     support short int images (in addition to the routines that support int).

   - moved the definition of LONGLONG_MIN and LONGLONG_MAX from fitsio2.h
     to fitsio.h, to make it accessible to application programs.

   - make efficiency improvements to fitscore.c, to avoid needless searches
     through the entire header when reading the required keywords that must
     be near the beginning of the header.
     
   - made several improvements to getcol.c to optimize reading of compressed
     and uncompressed images.

   - changed the compression level in the gzip code from 6 to 1.  In most
     cases this will provide nearly the same amount of compression, but is
     significantly faster in some cases.
	   
   - added new "helper routines' to imcompress.c to allow applications to
     specified the "quantize level" and Hcompress scaling and smoothing 
     parameters

   - modified the extended filename syntax to support the "quantize level"
     and Hcompress scaling and smoothing parameters.  The parser in 
     cfileio.c was extensively modified.

   - extensive changes to quantize.c:
       - replace the "nbits" parameter with "quantize level"
       - the quantize level is now relative to the RMS noise in the image
       - the HCOMPRESS scale factor is now relative to the RMS noise
       - added routines to calculate RMS noise in image 
      (these changes require a change to the main file structure in fitsio.h)

   - initialize errno = 0 before the call to strtol in ffext, in case errno
     has previously been set by an unrelated error condition.

   - added the corresponding long name for the ffgkyjj routine to longnam.h.		   

   - changed imcomp_copy_comp2img (in imcompress.c) to not require the
     presence of the EXTNAME keyword in the input compressed image header.

   - modified imcompress.c to only write the UNCOMPRESSED_DATA column
     in tile-compressed images if it is actually needed.  This eliminates
     the need to subsequently delete the column if it is not used 
     (which is almost always the case).

   - found that it is necessary to seek to the EOF of a file after 
     truncating the size of the file, to reestablish a definite
     current location in the file.  The required small changes to 3
     routines: file_truncate (to seek to EOF) and fftrun (to set io_pos) 
     and the truncation routine in drvrmem.c.

   - improved the efficiency when compressing integer images with
     gzip.  Previously, the image was always represented using integer*4
     pixels, which were then compressed.  Now, if the range of pixel
     values can be represented with integer*2 pixels or integer*1 pixels, 
     then that is used.  This change is backward compatible with any 
     compressed images that used the previous method.

   - changed the default tiling pattern when using Hcompress from 
     large squares (200 to 600 pixels wide) to 16 rows of the image.
     This generally requires less memory, compresses faster, and is more
     consistent with the default row by row tiling when using the other
     compression methods.

   - modified imcomp_init_table in imcompress.c to enforce a restriction
     when using the Hcompress algorithm that the 1st 2 dimensions of sll
     image tiles must be at least 4 pixels long.  Hcompress becomes very
     inefficient for smaller dimensions, and does not work at all with
     1D images.
     
   - fixed bug in the Hcompress compression algorithm that could affect
     compression of I*4 images, using non-square compression tiles
     (in the encode64 routine).

Version 3.07 - 6 December 2007  (internal release)

   - fixed bug with the PLIO image compression routine which silently
     produced a corrupted compressed image if the uncompressed image pixels
     were not all in the range 0 to 2**24.  (fixed in November)
     
   - fixed several 'for' loops in imcompress.c which were exceeding the
     bounds of an array by 1.  (fixed in November)

   - fixed a possible, but unlikely, memory overflow issue in iraffits.c.
   
   - added a clarification to the cfortran.doc file that cfortran.h
     may be used and distributed under the terms of the GNU Library
     General Public License.
   
   - fixed bug in the fits_modify_vector_len routine when modifying
     the vector length of a 'X' bit column.
	   
Version 3.06 - 27 August 2007  

   - modified the imcopy.c utility program (to tile-compress images)
     so that it writes the default EXTNAME = 'COMPRESSED_IMAGE'
     keyword in the compressed images, to preserve the behavior of
     earlier versions of imcopy.

   - modified the angsep function in the FITS calculator (in eval.y)
     to use haversines, instead of the 'law of cosines', to provide
     more precision at small angles (< 0.1 arcsec).

Version 3.05 -  July 2007 (internal release only)

   - extensive changes to imcompress.c to fully support implicit data
     type conversion when reading and writing arrays of data to FITS
     images, where the data type of the array is not the same as the
     data type of the FITS image.  This includes support for null pixels,
     and data scaling via the BSCALE and BZERO keywords.

   - rewrote the fits_read_tbl_coord routine in wcssub.c, that gets the 
     standard set of WCS keywords appropriate to a pair of columns in a
     table, to better support the full set of officially approved WCS keywords.  
     
   - made significant changes to histo.c, which creates an image by binning
     columns of a table, to better translate the WCS keywords in the table
     header into the WCS keywords that are appropriate for an image HDU.

   - modified imcompress.c so that when pixels are written to a 
     tile-compressed image, the appropriate BSCALE and BZERO values of
     that image are applied.  This fixes a bug in which writing to
     an unsigned integer datatype image (with BZERO = 32768) was not
     done correctly.
     
Version 3.04 - 3 April 2007

   - The various table calculator routines (fits_select_rows, etc.) implicitly
     assumed that the input table has not been modified immediately prior to
     the call.   To cover cases where the table has been modified a call to 
     ffrdef has been added to ffprs.  IN UNUSUAL CASES THIS CHANGE COULD 
     CAUSE CFITSIO TO BEHAVE DIFFERENTLY THAN IN PREVIOUS VERSIONS.  For
     example, opening a FITS table with this column-editing virtual file
     expression:
         myfile.fits[3][col A==X; B = sqrt(X)]
     no longer works, because the X column does not exist when the 
     sqrt expression is evaluated.  The correct expression in this case is
         myfile.fits[3][col A==X; B = sqrt(A)]
     
   - modified putkey.c to support USHORT_IMG when calling fits_create_img
     to create a signed byte datatype image.
     
   - enhanced the column histogramming function to propagate any TCn_k and
     TPn_k keywords in the table header to the corresponding CDi_j and PCi_j 
     keywords in the image header.
     
   - enhanced the random, randomn, and randomp functions in the lexical
     parser to take a vector column name argument to specify the length
     of the vector of random numbers that should be generated (provided by
     Craig Markwardt, GSFC)

   - enhanced the ffmcrd routine (to modify an existing header card) to
     support long string keywords so that any CONTINUE keywords associated
     with the previous keyword will be deleted.

   - modified the ffgtbp routine to recognize the TDIMn keyword for 
     ASCII string columns in a binary table.  The first dimension is
     taken to be the size of a unit string.   (The TFORMn = 'rAw'
     syntax may also be used to specify the unit string size).
     
   - in fits_img_decompress, the fits_get_img_param function was called
     with an invalid dimension size, which caused a fatal error on at
     least 1 platform.

   - in ffopentest, set the status value before returning in case of error.
   
   - in the drvrnet.c file, the string terminators needed to be changed
     from "\n" to "\r\n" to support the strict interpretation of the
     http and ftp standard that is enforced by some newer web servers.

Version 3.03 - 11 December 2006

  New Routine
  
  - fits_write_hdu writes the current HDU to a FILE stream (e.g. stdout).
  
  Changes
  
  - modified the region parsing code to support region files where the
    keyword "physical" is on a separate line preceding the region shape
    token. (However, "physical" coordinates are not fully supported, and
    are treated identically to "image" coordinates).
    
  - enhanced the iterator routines to support calculations on 64-bit
    integer columns and images.  Currently, the values are cast to
    double precision when doing the calculations, which can cause a
    loss of precision for integer values greater than about 2**52.

  - added support for accessing FITS files on the computational grid.
    Giuliano Taffoni and Andrea Barisani, at INAF, University of Trieste,
    Italy, implemented the necessary I/O driver routines in drvrgsiftp.c.

  - modified the tiled image compression/uncompression routines to 
    preserve/restore the original CHECKSUM and DATASUM keywords if they
    exist. (saved as ZHECKSUM and ZDATASUM in the compressed image)
  
  - split fits_select_image_section into 2 routines: a higher level routine
    that creates the output file and copies other HDUs from the input file
    to the output file, and a lower level routine that extracts the image
    section from the input image into an output image HDU.
    
  - Improved the error messages that get generated if one tries to 
    use the lexical parser to perform calculations on variable-length
    array columns.

  - added "#define MACHINE NATIVE" in fitsio2.h for all machines where
    BYTESWAPPED == FALSE.  This may improve the file writing performance
    by eliminating the need to allocate a temporary buffer in some cases.

  - modified the configure.in and configure script to fix problems with
    testing if network services are available, which affects the definition
    of the HAVE_NET_SERVICES flag.

  - added explicit type casting to all malloc statements, and deleted 
    declarations of unreferenced variables in the image compression code 
    to suppress compiler warnings.
    
  - fixed incorrect logic in fitsio2.h in the way it determined if numerical
    values are byteswapped or not on MIPS and ARM architectures.

  - added __BORLANDC__ to the list of environments in fitsio.h that don't
    use %lld in printf for longlong integers
    
  - added "#if defined(unix)" around "#include <usistd.h>" statements in
    several C source files, to make them compatible with Windows.
    

Version 3.02 - 18 Sept 2006

  - applied the security patch to the gzip code, available at
    http://security.FreeBSD.org/patches/SA-06:21/gzip.patch
    The insufficient bounds checks in buffer use can cause gzip to crash,
    and may permit the execution of arbitrary code.  The NULL pointer
    deference can cause gzip to crash.  The infinite loop can cause a
    Denial-of-Service situation where gzip uses all available CPU time.

  - added HCOMPRESS as one of the compression algorithm options in the
    tiled image compression code.  (code provided by Richard White (STScI))
    Made other improvements to preserve the exact header structure in the 
    compressed image file so that the compressed-and-then-uncompressed FITS 
    image will be as identical as possible to the original FITS image file.  

  New Routines		   

  - the following new routines were added to support reading and writing
    non-standard extension types:
     fits_write_exthdr - write required keywords for a conforming extension
     fits_write_ext - write data to the extension
     fits_read_ext  - read data from the extension
     
  - added new routines to compute the RMS noise in the background pixels
    of an image: fits_rms_float and fits_rms_short  (take an input
    array of floats or shorts, respectively).

  Fixes

  - added the missing 64-bit integer case to set of "if (datatype)" 
    statements in the routine that returns information about a 
    particular column (ffgbclll).
    
  - fixed a parsing error in ffexts in cases where an extension number
    is followed by a semi-colon and then the column and row number of an
    array in a binary table.  Also removed an extraneous HISTORY keyword
    that was being written when specifying an input image in a table cel.
  
  - modified the routine that reads a table column returning a string
    value (ffgcls) so that if the displayed numerical value is too
    wide to fit in the specified length string, then it will return
    a string of "*" characters instead of the number string.

  - small change to fitsio.h to support a particular Fortran and C
    compiler combination on a SGI Altix system
    
  - added a test in the gunzip code to prevent seg. fault when trying
    to uncompress a corrupted file (at least in some cases).

  - fixed a rarely-occurring bug in the routine that copies a table
    cell into an image; had to call the ffflsh call a few lines earlier.

Version 3.01 - (in FTOOLS 6.1 release)

  - modified fits_copy_image2cell to correctly copy all the appropriate
    header keywords when copying an image into a table cell

  - in eval.y, explicitly included the code for the lgamma function 
    instead of assuming it is available in a system library (e.g., the
    lgamma function is currently not included in MS Visual++ libraries)

  - modified the logic in fits_pixel_filter so that the default data
    type of the output image will be promoted to at least BITPIX = -32
    (a single precision floating point) if the expression that is being
    evaluated resolves to a floating point result.  If the expression 
    resolves to an integer result, the output image will have the same
    BITPIX as the input image.

  - in fits_copy_cell2image, added 5 more WCS keywords to the list of
    keywords related to other columns that should be deleted in the
    output image header.

  - disabled code in cfileio.c that would write HISTORY keywords to the
    output file in fits_copy_image2cell and cell2image, because some tasks
    would not want these extraneous HISTORY keywords.

  - added 2 new random number functions to the CFITSIO parser
    RANDOMN() - produces a normal deviate (mean=0, stddev=1)
    RANDOMP(X) - produces a Poisson deviate for an expected # of counts X

  - in f77_wrap.h, removed the restriction that "g77Fortran" must be 
    defined on 64-bit Itanium machines before assuming that 
    sizeof(long) = 8.  It appears that "long"s are always
    8 bytes long on this machine, regardless of what compilers are used.

  - added test in fitsio.h so that LONGLONG cannot be multiply defined
  
  - modified longnam.h so that both "fits_write_nulrows" and 
    "fits_write_nullrows"  get replace by the string "ffprwu".  This
    fixes a documentation error regarding the long name of this
    routine.

   Bug fixes

  - fixed a potential null character string dereferencing error in the
    the ffphtb and ffphbn routines that write the FITS table keywords.
    This concerned the optional TUNITn keywords.

  - fixed a few issues in fits_copy_cell2image and fits_copy_image2cell
    related to converting some WCS keyword between the image extension
    form and the table cell form of the keyword. (cfileio.c)

  - fixed bug in fits_translate_keyword (fitscore.c) that, e.g.,  caused 
   'EQUINOX' to be translated to EQUINOXA' if the pattern is 'EQUINOXa'

  - fixed 2 bugs that could affect 'tile compressed' floating point
    images that contain NaN pixels (null pixels).  First, the
    ZBLANK keyword was not being written, and second, an integer
    overflow could occur when computing the BZERO offset in the
    compressed array.  (quantize.c and imcompress.c)

Version 3.006 - 20 February 2006  -(first full release of v3)

  - enhanced the 'col' extended filename syntax to support keyword name
    expressions like
       [col error=sqrt(rate); #TUNIT# = 'counts/s'], 
    in which the trailing '#' will be replaced by the column number
    of the most recently referenced column.
    
  - fixed bug in the parse_data iterator work function that caused it
    to fail to return a value of -1 in cases where only a selected
    set of rows were to be processed. (affected Fv)

  - added code to fitsio.h and cfortran.h to typedef LONGLONG to
    the appropriate 8-byte integer data type.  Most compilers now
    support the 'long long' data type, but older MS Visual C++
    compilers used '__int64' instead.

  - made several small changes based on testing by Martin Reinecke:
    o in  eval.y, change 'int undef' to 'long undef'
    o in getcold.c and getcole.c, fixed a couple format conversion 
      specifiers when displaying the value of long long variables.
    o in fitsio.h, modified the definition of USE_LL_SUFFIX in the
      case of Athon64 machines.
    o in fitsio2.h,  defined BYTESWAPPED in the case of SGI machines.
    o in group.c, added 'include unistd.h' to get rid of compiler warning.
      
Version 3.005 - 20 December 2005  (beta)

  - cfortran.h has been enhanced to support 64-bit integer parameters
    when calling C routines from Fortran.  This modification was kindly 
    provided by Martin Reinecke (MPE, Garching).  
    
  - Many new Fortran wrapper routines have been added to support reading
    and writing 64-bit integer values in FITS files.  These new routines
    are documented in the updated version of the 'FITSIO User's Guide' 
    for Fortran programmers.

  - fixed a problem in the fits_get_keyclass routine that caused it
    to not recognize the special COMMENT keywords at the beginning
    of most FITS files that defines the FITS format.

  - added a new check to the ffifile routine that parses the 
    input extended file name, to distinguish between a FITS extension
    name that begins with 'pix', and a pixel filtering operator that 
    begins with the 'pix' keyword.

  - small change to the WCSLIB interface routine, fits_read_wcstab, to
    be more permissive in allowing the TDIMn keyword to be omitted for
    degenerate coordinate array.

Version 3.004 - 16 September 2005 (3rd public beta release)

  - a major enhancement to the CFITSIO virtual file parser was provided
    by Robert Wiegand (GSFC).  One can now specify filtering operations
    that will be applied on the fly to the pixel values in a FITS image. 
    For example [pix sqrt(X)] will create a virtual FITS image where the
    pixel values are the square root of the input image pixels.

  - modified region.c so that it interprets the position angles of regions
    in a SAO style region file in the same way as DS9.  In particular, if
    the region parameters are given in WCS units, then the position angle
    should be relative to the WCS coordinates of the image (increasing CCW
    from West) instead of relative to the X/Y pixel coordinate system.
    This only affects rotated images (e.g. with non-zero CROTA2 keyword)
    with elliptical or rectangular regions.

  - cleaned up fitsio.h and fitsio2.h to make the definition of LONGLONG
    and BYTESWAPPED and MACHINE more logical.
    
  - removed HAVE_LONGLONG everywhere since it is no longer needed (the 
    compiler now must have an 8-byte integer datatype to build CFITSIO).
    
  - added support for the 64-bit IBM AIX platform

  - modified eval.y so that the circle, ellipse, box, and near functions
    can operate on vectors as well as scalars.  This allows region filtering
    on images that are stored in a vector cell in a binary table. 
    (provided by Craig Markwardt, GSFC)

  New Routines
  
  - added new fits_read_wcstab routine that serves as an interface to
    Mark Calabretta's wcslib library for reading WCS information when
    the -TAB table lookup convention is used in the FITS file.

  - added new fits_write_nullrows routine, which writes null values into
    every column of a specified range of rows in a FITS table.

  - added the fits_translate_keyword and fits_translate_keywords utility
    routines for converting the names of keywords when moving columns and
    images around.
    
  - added fits_copy_cell2image and fits_copy_image2cell routines for
    copying an image extension (or primary array) to or from a cell
    in a binary table vector column. 
  
  Bug fixes
  
  - fixed a memory leak in eval.y;  was fixed by changing a call to malloc
    to cmalloc instead.

  - changed the definition of several global variables at the beginning
    of buffers.c to make them 'static' and thus invisible to applications
    programs.

  - in fits_copy_image_cell, added a call to flush the internal buffers
    before reading from the file, in case any records had been modified.

Version 3.003 - 28 July 2005 - 2nd public beta release (used in HEASOFT)

  Enhancements
  
  - enhanced the string column reading routing fits_get_col_str to 
    support cases where the user enters a null pointer (rather than
    a null string) as the nulval parameter.

  - modified the low level ffread and ffwrite routines that physically
    read and write data from the FITS file so that they write the name
    of the file to the CFITSIO error stack if an error occurs.

  - changed the definition of fits_open_file into a macro that will test
    that the version of the fitsio.h include file that was used to 
    build the CFITSIO library is the same version as included when
    compiling the application program.

  - made a simple modification to region.c to support regions files
    of type "linear", for compatibility with ds9 and fv.
    
  - modified the internal ffgpr routine (and renamed it ffgprll) so
    that it returns the TNULL value as a LONGLONG parameter instead
    of 'long'.
    
  - in fits_get_col_display_width, added support for TFORM = 'k'
  
  - modified fitsio.h, fitsio2.h, and f77_wrap.h to add test for (_SX)
    to identify NEC SX supercomputers.

  - modified eval_f.c to treat table columns of TULONG  (unsigned long)
    as a double.  Also added support for TLONGLONG (8-byte integers) as
    a double, which is only a temporary fix, since doubles only have about
    52 bits of precision.

  - changed the 'blank' parameter in the internal ffgphd function to
    to type LONGLONG to support integer*8 FITS images.

  - when reading the TNULL keyword value, now use ffc2jj instead of
    ffc2ii, to support integer*8 values.

  Bug fixes

  - fixed a significant bug when writing character strings to a variable
    length array column of a binary table. This bug would result in some
    unused space in the variable length heap, making the heap somewhat
    larger than necessary.  This in itself is usually a minor issue, since
    the FITS files are perfectly valid, and other software should have
    no problems reading back the characters strings. In some cases, however,
    this problem could cause the program that is writing the table
    to exit with a status = 108 disk read error.

  - modified the standalone imcopy.c utility program to fix a memory allocation
    bug when running on 64-bit platforms where sizeof(long) = 8 bytes.

  - added an immediate 'return' statement to ffgtcl if the input status >0, 
    to prevent a segfault on some platforms.

Version 3.002 - 15 April 2005 - first public beta release

  - in drvrfile.c, if it fails to open the file for some reason, then
    it should reset file_outfile to a null string, to avoid errors on
    a subsequent call to open a file.
 
  - updated fits_get_keyclass to recognize most of the WCS keywords
    defined in the WCS Papers I and II.

Version 3.001 - 15 March 2005  - released with HEASOFT 6.0

  - numerous minor changes to the code to get rid of compiler warning
    messages, mainly dealing with numerical data type casting and the
    subsequent possible loss of precision in the result.

Version 3.000 - 1 March 2005 (internal beta release)

  Enhancements:

   - Made major changes to many of the CFITSIO routines to more generally 
     support Large Files (> 2.1 GB).  These changes are intended to 
     be 100% backward compatible with software that used the previous 
     versions of CFITSIO.  The datatype of many of the integer parameters 
     in the CFITSIO functions has been changed from 'long' to 'LONGLONG', 
     which is typedef'ed to be equivalent to an 8-byte integer datatype on 
     each platform. With these changes, CFITSIO supports the following:
        - integer FITS keywords with absolute values > 2**31
        - FITS files with total sizes > 2**31 bytes
	- FITS tables in which the number of rows, the row width, or
	  the size of the heap is > 2**31 bytes
	- FITS images with dimensions > 2**31 bytes (support is still 
	  somewhat limited, with full support to be added later).

   - added another lexical parser function (thanks to Craig Markwardt,
     GSFC): angsep computes the angular separation between 2 positions
     on the celestial sphere.
  
   - modified the image subset extraction code (e.g., when specifying
     an image subregion when opening the file, such as 
     'myimage.fits[21:40, 81:90]') so that in addition to
     updating the values of the primary WCS keywords CRPIXk, CDELTi, and
     CDj_i in the extracted/binned image, it also looks for and updates 
     any secondary WCS keywords (e.g., 'CRPIX1P').

   - made cosmetic change to group.c, so that when a group table is
     copied, any extra columns will be appended after the last existing
     column, instead of being inserted before the last column.
     
   - modified the routines that read tile compressed images to support
     NULL as the input value for the 'anynul' parameter (meaning the
     calling program does not want the value of 'anynul' returned to it).
      
   - when constructing or parsing a year/month/day character string,
     (e.g, when writing the DATE keyword) the routines now rigorously
     verify that the input day value is valid for the given month 
     (including leap years).

   - added some checks in cfileio.c to detect if some vital parameters
     that are stored in memory have been corrupted.  This can occur if
     a user's program writes to areas of memory that it did not allocate.

   - added the wcsutil_alternate.c source code file which contains
     non-working stubs for the 2 Classic AIPS world coordinate
     conversion routines that are distributed under the GNU General
     Public License.  Users who are unwilling or unable to distribute
     their software under the General Public License may use this 
     alternate source file which has no GPL restrictions, instead
     of wcsutil.c.  This will have no effect on programs that use 
     CFITSIO as long as they do not call the fits_pix_to_world/ffwldp
     or fits_world_to_pix/ffxypx routines.
     
   Bug Fixes
   
   - in ffdtdm (which parses the TDIMn keyword value), the check for
     consistency between the length of the array defined by TDIMn and
     the size of the TFORMn repeat value, is now not performed for variable
     length array columns (which always have repeat = 1).

   - fixed byteswapping problem when writing null values to non-standard
     long integer FITS images with BITPIX = 64 and FITS table columns with
     TFORMn = 'K'.

   - fixed buffer overflow problem in fits_parse_template/ffgthd that
     occurred only if the input template keyword value string was much
     longer than can fit in an 80-char header record.
     
Version 2.510 - 2 December 2004

  New Routines:
  
   - added fits_open_diskfile and fits_create_diskfile routines that simply
     open or create a FITS file with a specified name.  CFITSIO does not
     try to parse the name using the extended filename syntax.
     
   - 2 new C functions, CFITS2Unit and CUnit2FITS, were added to convert
     between the C fitsfile pointer value and the Fortran unit number.
     These functions may be useful in mixed language C and Fortran programs.   
   
  Enhancements:
  
   - added the ability to recognize and open a compressed FITS file
     (compressed with gzip or unix compress) on the stdin standard input
     stream.
  
   - Craig Markwardt (GSFC) provided 2 more lexical parser functions:
     accum(x) and seqdiff(x) that compute the cumulative sum and the
     sequential difference of the values of x.
  
   - modified putcole.c and putcold.c so that when writing arrays of
     pixels to the FITS image or column that contain null values, and
     there are also numerical overflows when converting some of the
     non-null values to the FITS values, CFITSIO will now ignore the
     overflow error until after all the data have been written. Previously,
     in some circumstances CFITSIO would have simply stopped writing any
     data after the first overflow error.     
      
   - modified fitsio2.h to try to eliminate compiler warning messages
     on some platforms about the use of 'long long' constants when 
     defining the value of LONGLONG_MAX (whether to use L or LL
     suffix).

   - modified region.c to support 'physical' regions in addition to
     'image', 'fk4', etc.

   - modified ffiurl (input filename parsing routine) to increase the 
     maximum allowed extension number that can be specified from 9999 
     to 99999 (e.g. 'myfile.fits+99999')

  Bug Fixes:
  
   - added check to fits_create_template to force it to start with
     the primary array in the template file, in case an extension
     number was specified as part of the template FITS file name.
      
Version 2.500 - 28 & 30 July 2004

  New Routine:  
  
   - fits_file_exists tests whether the specified input file, or a 
     compressed version of the file, exists on disk.

  Enhancements:

   - modified the way CFITSIO reads and writes data in COMPLEX ('C') and
     DBLCOMPLEX 'M' columns.  Now, in all cases, when referring to the
     number of elements in the vector, or the value of the offset to a 
     particular element within the vector, CFITSIO considers each pair of
     numbers (the imaginary and real parts) as a single element instead of
     treating each single number as an element. In particular, this changes
     the behavior of fits_write_col_null when writing to complex columns.  
     It also changes the length of the 'nullarray' vector in the
     fits_read_colnull routine;  it is now only 1/2 as long as before.
     Each element of the nullarray is set = 1 if either the real or 
     imaginary parts of the corresponding complex value have a null
     value.(this change was added to version 2.500 on 30 July).

   - Craig Markwardt, at GSFC, provided a number of significant enhancements
     to the CFITSIO lexical parser that is used to evaluate expressions:
     
       - the parser now can operate on bit columns ('X') in a similar
         way as for other numeric columns (e.g., 'B' or 'I' columns)
	 
       - range checking has been implemented, so that the following 
         conditions return a Null value, rather than returning an error:
	 divide by zero, sqrt(negative),  arccos(>1), arcsin(>1),
	 log(negative), log10(negative)
	 
       - new vector functions:  MEDIAN, AVERAGE, STDDEV, and 
         NVALID (returns the number of non-null values in the vector)

       - all the new functions (and SUM, MIN and MAX) ignore null values
       
   - modified the iterator to support variable-length array columns

   - modified configure to support AIX systems that have flock in a non-
     standard location.
     
   - modified configure to remove the -D_FILE_OFFSET_BITS flag when running
     on Mac Darwin systems.  This caused conflicts with the Fortran
     wrappers, and should only be needed in any case when using CFITSIO
     to read/write FITS files greater than 2.1 GB in size.

   - modified fitsio2.h to support compilers that define LONG_LONG_MAX.

   - modified ffrsim (resize an existing image) so that it supports changing
     the datatype to an unsigned integer image using the USHORT_IMG and
     ULONG_IMG definitions.

   - modified the disk file driver (drvrfile.c) so that if an output
     file is specified when opening an ordinary file (e.g. with the syntax
     'myfile.fits(outputfile.fits)' then it will make a copy of the file,
     close the original file and open the copy.  Previously, the
     specified output file would be ignored unless the file was compressed.

   - modified f77_wrap.h and f77_wrap3.c to support the Fortran wrappers
     on 64-bit AMD Opteron machines

  Bug fixes:

   - made small change to ffsrow in eval_f.c to avoid potential array 
     bounds overflow.
     
   - made small change to group.c to fix problem where an 'int' was
     incorrectly being cast to a 'long'.

   - corrected a memory allocation error in the new fits_hdr2str routine
     that was added in version 2.48

   - The on-the-fly row-selection filtering would fail with a segfault
     if the length of a table row (NAXIS1 value) was greater than
     500000 bytes.  A small change to eval_f.c was required to fix this.

Version 2.490 - 11 February 2004

  Bug fixes:

  - fixed a bug that was introduced in the previous release, which caused
    the CFITSIO parser to no longer move to a named extension when opening
    a FITS file, e.g., when opening myfile.fit[events] CFITSIO would just
    open the primary array instead of moving to the EVENTS extension.

  - new group.c file from the INTEGRAL Science Data Center.  It fixes
    a problem when you attach a child to a parent and they are both
    is the same file, but, that parent contains groups in other files.
    In certain cases the attach would not happen because it seemed that
    the new child was already in the parent group.

  - fixed bug in fits_calculator_rng when performing a calculation
    on a range of rows in a table, so that it does not reset the
    value in all the other rows that are not in the range = 0.

  - modified fits_write_chksum so that it updates the TFORMn 
    keywords for any variable length vector table columns BEFORE 
    calculating the CHECKSUM values.  Otherwise the CHECKSUM
    value is invalidated when the HDU is subsequently closed.

Version 2.480 - 28 January 2004

  New Routines:

  - fits_get_img_equivtype - just like fits_get_img_type, except in
    the case of scaled integer images, it returns the 'equivalent' 
    data type that is necessary to store the scaled data values.  

  - fits_hdr2str copies all the header keywords in the current HDU
    into a single long character string.  This is a convenient method
    of passing the header information to other subroutines.
    The user may exclude any specified keywords from the list.

  Enhancements:

  - modified the filename parser so that it accepts extension
    names that begin with digits, as in 'myfile.fits[123TEST]'.
    In this case CFITSIO will try to open the extension with
    EXTNAME = '123TEST' instead of trying to move to the 123rd
    extension in the file.

  - the template keyword parser now preserves the comments on the
    the mandatory FITS keywords if present, otherwise a standard
    default comment is provided.

  - modified the ftp driver file (drvrnet.c) to overcome a timeout
    or hangup problem caused by some firewall software at the user's
    end (Thanks to Bruce O'Neel for this fix).

  - modified iraffits.c to incorporate Doug Mink's latest changes to
    his wcstools library routines.  The biggest change is that now
    the actual image dimensions, rather than the physically stored
    dimensions, are used when converting an IRAF file to FITS.

  Bug fixes:

  - when writing to ASCII FITS tables, the 'elemnum' parameter was
    supposed to be ignored if it did not have the default value of 1.
    In some cases however setting elemnum to a value other than 1 
    could cause the wrong number of rows to be produced in the output
    table.

  - If a cfitsio calculator expression was imported from a text file
    (e.g. using the extended filename syntax 'file.fits[col @file.calc]')
    and if any individual lines in that text file were greater than 
    255 characters long, then a space character would be inserted
    after the 255th character.  This could corrupt the line if the space
    was inserted within a column name or keyword name token.

Version 2.480beta  (used in the FTOOLS 5.3 release, 1 Nov 2003)

  New Routines:

  - fits_get_eqcoltype - just like fits_get_coltype, except in the
    case of scaled integer columns, it returns the 'equivalent' 
    data type that is necessary to store the scaled data values.  

  - fits_split_names - splits an input string containing a comma or
    space delimited list of names (typically file names or column
    names) into individual name tokens.

  Enhancements:

  - changed fhist in histo.c so that it can make histograms of ASCII
    table columns as well as binary table columns (as long as they
    contain numeric data).

  Bug fixes:

  - removed an erroneous reference to listhead.c in makefile.vcc, that is
    used to build the cfitsio dll under Windows.  This caused a 'main'
    routine to be added to the library, which causes problems when linking
    fortran programs to cfitsio under windows.

  - if an error occurs when opening for a 2nd time (with ffopen) a file that
    is already open (e.g., the specified extension doesn't exist), and
    if the file had been modified before attempting to reopen it, then
    the modified buffers may not get written to disk and the internal
    state of the file may become corrupted.  ffclos was modified to
    always set status=0 before calling ffflsh if the file has been 
    concurrently opened more than once.

Version 2.470 - 18 August 2003

  Enhancements:

  - defined 'TSBYTE' to represent the 'signed char' datatype (similar to
    'TBYTE' that represents the 'unsigned char' datatype) and added
    support for this datatype to all the routines that read or write
    data to a FITS image or table.   This was implemented by adding 2
    new C source code files to the package: getcolsb.c and putcolsb.c.

  - Defined a new '1S' shorthand data code for a signed byte column in
    a binary table.  CFITSIO will write TFORMn = '1B' and
    TZEROn = -128 in this case, which is the convention used to
    store signed byte values in a 'B' type column.

  - in fitsio2.h, added test of whether  `__x86_64__` is defined, to 
    support the new AMD Opteron 64-bit processor

  - modified configure to not use the -fast compiler flag on Solaris
    platforms when using the proprietary Solaris cc compiler.  This
    flag causes compilation problems in eval_y.c (compiler just
    hangs forever).

  Bug fixes:

  - In the special case of writing 0 elements to a vector table column
    that contains 0 rows, ffgcpr no longer adds a blank row to the table.
    
  - added error checking code for cases where a ASCII string column
    in a binary table is greater than 28800 characters wide, to avoid
    going into an infinite loop.

  - the fits_get_col_display_width routine was incorrectly returning
    width = 0 for a 'A' binary table column that did not have an 
    explicit vector length character.

Version 2.460 - 20 May 2003

  Enhancements:

  - modified the HTTP driver in drvrnet.c so that CFITSIO can read
    FITS files via a proxy HTTP server.  (This code was contributed by
    Philippe Prugniel, Obs. de Lyon).  To use this feature, the 
    'http_proxy' environment variable must be defined with the
    address (URL) and port number of the proxy server, i.e.,
      > setenv http_proxy http://heasarc.gsfc.nasa.gov:3128
    will use port 3128 on heasarc.gsfc.nasa.gov

  - suppressed some compiler warnings by casting a variable of 
    type 'size_t' to type 'int' in fftkey (in fitscore.c) and
    iraftofits and irafrdimge (in iraffits.c).

Version 2.450 - 30 April 2003

  Enhancements:

  - modified the WCS keyword reading routine (ffgics) to support cases
    where some of the CDi_j keywords are omitted (with an assumed 
    value = 0).

  - Made a change to http_open_network in drvrnet.c to add a 'Host: '
    string to the open request.  This is required by newer HTTP 1.1
    servers (so-called virtual servers).

  - modified ffgcll (read logical table column) to return the illegal
    character value itself if the FITS file contains a logical value that is
    not equal to T, F or zero.  Previously it treated this case the
    same as if the FITS file value was = 0.

  - modified fits_movnam_hdu (ffmnhd) so that it will move to a tile-
    compressed image (that is stored in a binary table) if the input
    desired HDU type is BINARY_TBL as well as if the HDU type = IMAGE_HDU.

  Bug fixes:

  - in the routine that checks the data fill bytes (ffcdfl), the call
    to ffmbyt should not ignore an EOF error when trying to read the bytes.
    This is a little-used routine that is not called by any other CFITSIO
    routine.

  - fits_copy_file was not reporting an error if it hit the End Of File
    while copying the last extension in the input file to the output file.

  - fixed inconsistencies in the virtual file column filter parser
    (ffedit_columns) to properly support expressions which create or
    modify a keyword, instead of a column.  Previously it was only possible
    to modify keywords in a table extension (not an image), and the 
    keyword filtering could cause some of the table columns to not
    get propagated into the virtual file.  Also, spaces are now
    allowed within the specified keyword comment field.

  - ffdtyp was incorrectly returning the data type of FITS keyword
    values of the form '1E-09' (i.e., an exponential value without
    a decimal point) as integer rather than floating point.

  - The enhancement in the previous 2.440 release to allow more files to be
    opened at one time introduced a bug: if ffclos is called with
    a non-zero status value, then any subsequent call to ffopen will likely
    cause a segmentation fault.  The fits_clear_Fptr routine was modified
    to fix this.

  - rearranged the order of some computations in fits_resize_img so as
    to not exceed the range of a 32-bit integer when dealing with 
    large images.

  - the template parser routine, ngp_read_xtension, was testing for
    "ASCIITABLE" instead of "TABLE" as the XTENSION value of an ASCII
    table, and it did not allow for optional trailing spaces in the IMAGE"
    or "TABLE" string value.

Version 2.440 - 8 January 2003

  Enhancements:

  - modified the iterator function, ffiter, to operate on random
    groups files.

  - decoupled the NIOBUF (= 40) parameter from the limit on the number
    FITS files that can be opened, so that more files may be opened
    without the overhead of having to increase the number of NIOBUF
    buffers.  A new NMAXFILES parameter is defined in fitsio2.h which sets
    the maximum number of opened FITS files.  It is set = 300 by default.
    Note however, that the underlying compiler or operating system may
    not allow this many files to be opened at one time.

  - updated the version of cfortran.h that is distributed with CFITSIO from 
    version 3.9 to version 4.4.  This required changes to f77_wrap.h
    and f77_wrap3.c.  The original cfortran.h v4.4 file was modified
    slightly to support CFITSIO and ftools (see comments in the header
    of cfortran.h).

  - modified ffhist so that it copies all the non-structural keywords from
    the original binary table header to the binned image header.

  - modified fits_get_keyclass so that it recognizes EXTNAME =
    COMPRESSED_IMAGE as a special tile compression keyword.

  - modified Makefile.in to support the standard --prefix convention
    for specifying the install target directory.

  Bug fixes:

  - in fits_decompress_img, needed to add a call to ffpscl to turn
    off the BZERO and BSCALE scaling when reading the compressed image.

Version 2.430 - 4 November 2002

  Enhancements:

  - modified fits_create_hdu/ffcrhd so that it returns without doing
    anything and does not generate an error if the current HDU is 
    already an empty HDU.  There is no need in this case to append
    a new empty HDU to the file.

  - new version of group.c (supplied by B. O'Neel at the ISDC) fixes 2
    limitations:  1 - Groups now have 256 characters rather than 160
    for the path lengths in the group tables. - ISDC SPR 1720.  2 -
    Groups now can have backpointers longer than 68 chars using the long
    string convention. - ISDC SPR 1738.

  - small change to f77_wrap.h and f77_wrap3.c to support the fortran
    wrappers on SUN solaris 64-bit sparc systems (see also change to v2.033)

  - small change to find_column in  eval_f.c to support unsigned long
    columns in binary tables (with TZEROn = 2147483648.0)

  - small modification to cfortran.h to support Mac OS-X, (Darwin)

  Bug fixes:

  - When reading tile-compress images, the BSCALE and BZERO scaling
    keywords were not being applied, if present.

  - Previous changes to the error message stack code caused the
    tile compressed image routines to not clean up spurious error
    messages properly.

  - fits_open_image was not skipping over null primary arrays.

Version 2.420 - 19 July 2002

  Enhancements:

  - modified the virtual filename parser to support exponential notation
    when specifying the min, max or binsize in a binning specifier, as in:
    myfile.fits[binr X=1:10:1.0E-01, Y=1:10:1.0E-01]

  - removed the limitation on the maximum number of HDUs in a FITS file 
    (limit used to be 1000 HDUs per file).  Now any number of HDUs
    can be written/read in a FITS file. (BUT files that have huge numbers
    of HDUs can be difficult to manage and are not recommended);

  - modified grparser.c to support HIERARCH keywords, based on 
    code supplied by Richard Mathar (Max-Planck)

  - moved the ffflsh (fits_flush_buffer) from the private to the
    public interface, since this routine may be useful for some  
    applications.  It is much faster than ffflus.

  - small change to the definition of OFF_T in fitsio.h to support
    large files on IBM AIX operating systems.

  Bug fixes:

  - fixed potential problem reading beyond array bounds in ffpkls.  This
    would not have affected the content of any previously generated FITS
    files.

  - in the net driver code in drvrnet.c, the requested protocol string
    was changed from "http/1.0" to "HTTP/1.0" to support apache 1.3.26.

  - When using the virtual file syntax to open a vector cell in a binary
    table as if it were a primary array image, there was a bug
    in fits_copy_image_cell which garbled the data if the vector
    was more than 30000 bytes long.

  - fixed problem that caused fits_report_error to crash under Visual
    C++ on Windows systems.  The fix is to use the '/MD' switch
    on the cl command line, or, in Visual Studio, under project
    settings / C++ select use runtime library multithreaded DLL

  - modified ffpscl so it does not attempt to reset the scaling values
    in the internal structure if the image is tile-compressed.

  - fixed multiple bugs in mem_rawfile_open which affected the case
    where a raw binary file is read and converted on the fly into
    a FITS file.

  - several small changes to group.c to suppress compiler warnings.

Version 2.410 - 22 April 2002 (used in the FTOOLS 5.2 release)

  New Routines:

  - fits_open_data behaves similarly to fits_open_file except that it
    also will move to the first HDU containing significant data if
    and an explicit HDU name or number to open was not specified.
    This is useful for automatically skipping over a null primary
    array when opening the file.

  - fits_open_table and fits_open_image behaves similarly to 
    fits_open_data, except they move to the first table or image
    HDU in the file, respectively.

  - fits_write_errmark and fits_clear_errmark routines can be use
    to write an invisible marker to the CFITSIO error stack, and
    then clear any more recent messages on the stack, back to 
    that mark.  This preserves any older messages on the stack.

  - fits_parse_range utility routine parses a row list string
    and returns integer arrays giving the min and max row in each
    range.

  - fits_delete_rowrange deletes a specified list of rows or row
    ranges.

  - fits_copy_file copies all or part of the HDUs in the input file
    to the output file.

  - added fits_insert_card/ffikey to the publicly defined set
    of routines (previously, it was a private routine).

  Enhancements:

  - changed the default numeric display format in ffgkys from 'E' format
    to 'G' format, and changed the format for 'X' columns to a 
    string of 8 1s or 0s representing each bit value.

  - modified ffflsh so the system 'fflush' call is not made in cases
    where the file was opened with 'READONLY' access.

  - modified the output filename parser so the "-.gz", and "stdout.gz"
    now cause the output file to be initially created in memory,
    and then compressed and written out to the stdout stream when
    the file is closed.

  - modified the routines that delete rows from a table to also 
    update the variable length array heap, to remove any orphaned
    data from the heap.

  - modified ffedit_columns so that wild card characters may be
    used when specifying column names in the 'col' file filter
    specifier (e.g.,  file.fits[col TIME; *RAW] will create a
    virtual table contain only the TIME column and any other columns
    whose name ends with 'RAW').

  - modified the keyword classifier utility, fits_get_keyclass, to
    support cases where the input string is just the keyword name,
    not the entire 80-character card.

  - modified configure.in and configure to see if a proprietary
    C compiler is available (e.g. 'cc'), and only use 'gcc' if not.

  - modified ffcpcl (copy columns from one table to another) so that
    it also copies any WCS keywords related to that column.

  - included an alternate source file that can be used to replace
    compress.c, which is distributed under the GNU General Public
    License.  The alternate file contains non-functional stubs for
    the compression routines, which can be used to make a version of
    CFITSIO that does not have the GPL restrictions (and is also less
    functional since it cannot read or write compressed FITS files).

  - modifications to the iterator routine (ffiter) to support writing
    tile compressed output images.

  - modified ffourl to support the [compress] qualifier when specifying
    the optional output file name. E.g., file.fit(out.file[compress])[3]

  - modified imcomp_compress_tile to fully support implicit data type
    conversion when writing to tile-compressed images.  Previously,
    one could not write a floating point array to an integer compressed
    image.

  - increased the number of internal 2880-byte I/O buffers allocated
    by CFITSIO from 25 to 40, in recognition of the larger amount
    of memory available on typical machines today compared with
    a few years ago.  The number of buffers can be set by the user
    with the NIOBUF parameter in fitsio2.h.  (Setting this too large
    can actually hurt performance).

  - modified the #if statements in fitsio2.h, f77_wrap.h and f77_wrap1.c
    to support the new Itanium 64-bit Intel PC.

  - a couple minor modifications to fitsio.h needed to support the off_t
    datatype on debian linux systems.

  - increased internal buffer sizes in ffshft and ffsrow to improve
    the I/O performance.

  Bug fixes:

  - fits_get_keyclass could sometimes try to append to an unterminated 
    string, causing an overflow of a string array.   

  - fits_create_template no longer worked because of improvements made
    to other routines.  Had to modify ffghdt to not try to rescan
    the header keywords if the file is still empty and contains no
    keywords yet.

  - ffrtnm, which returns the root filename, sometimes did not work 
    properly when testing if the 'filename+n' convention was used for
    specifying an extension number.

  - fixed minor problem in the keyword template parsing routine, ffgthd
    which in rare cases could cause an improperly terminated string to
    be returned.

  - the routine to compare 2 strings, ffcmps, failed to find a match 
    in comparing strings like "*R" and "ERROR" where the match occurs
    on the last character, but where the same matching character occurs
    previously in the 2nd string.

  - the region file reading routine (ffrrgn) did not work correctly if
    the region file (created by POW and perhaps other programs) had an
    'exclude' region (beginning with a '-' sign) as the first region 
    in the file.  In this case all points outside the excluded region
    should be accepted, but in fact no points were being accepted
    in this case.

Version 2.401 - 28 Jan 2002

  - added the imcopy example program to the release (and Makefile)

  Bug fixes:

  - fixed typo in the imcompress code which affected compression
    of 3D datacubes.

  - made small change to fficls (insert column) to allow colums with
    TFORMn = '1PU' and '1PV' to be inserted in a binary table.  The
    'U' and 'V' are codes only used within CFITSIO to represent unsigned
    16-bit and 32-bit integers; They get replaced by '1PI' and '1PJ'
    respectively in the FITS table header, along with the appropriate
    TZEROn keyword.

Version 2.400 - 18 Jan 2002

  (N.B.: Application programs must be recompiled, not just relinked 
     with the new CFITSIO library because of changes made to fitsio.h)

  New Routines:

  - fits_write_subset/ffpss writes a rectangular subset (or the whole
    image) to a FITS image.

  - added a whole new family of routines to read and write arrays of 
    'long long' integers (64-bit) to FITS images or table columns.  The
    new routine names all end in 'jj':  ffpprjj, ffppnjj, ffp2djj,
    ffp3djj, ffppssjj, ffpgpjj, ffpcljj, ffpcnjj. ffgpvjj, ffgpfjj,
    ffg2djj, ffg3djj, ffgsvjj, ffgsfjj, ffggpjj, ffgcvjj, and ffgcfjj.

  - added a set of helper routines that are used in conjunction with
    the new support for tiled image compression.  3 routines set the
    parameters that should be used when CFITSIO compresses an image:
        fits_set_compression_type
        fits_set_tile_dim
        fits_set_noise_bits

      3 corresponding routines report back the current settings:
        fits_get_compression_type
        fits_get_tile_dim
        fits_get_noise_bits

  Enhancements:

  - major enhancement was made to support writing to tile-compressed
    images.  In this format, the image is divided up into a rectangular
    grid of tiles, and each tile of pixels is compressed individually
    and stored in a row of a variable-length array column in a binary
    table.  CFITSIO has been able to transparently read this compressed
    image format ever since version 2.1.  Now all the CFITSIO image
    writing routines also transparently support this format.  There are
    2 ways to force CFITSIO to write compressed images: 1) call the
    fits_set_compression_type routine before writing the image header
    keywords, or 2), specify that the image should be compressed when
    entering the name of the output FITS file, using a new extended
    filename syntax.  (examples: "myfile.fits[compress]" will use the
    default compression parameters, and "myfile.fits[compress GZIP
    100,100] will use the GZIP compression algorithm with 100 x 100
    pixel tiles.

  - added new driver to support creating output .gz compressed fits
    files.  If the name of the output FITS file to be created ends with
    '.gz' then CFITSIO will initially write the FITS file in memory and
    then, when the FITS file is closed, CFITSIO will gzip the entire
    file before writing it out to disk.

  - when over-writing vectors in a variable length array in a binary
    table, if the new vector to be written is less than or equal to
    the length of the previously written vector, then CFITSIO will now
    reuse the existing space in the heap, rather than always appending
    the new array to the end of the heap.

  - modified configure.in to support building cfitsio as a dynamic 
    library on Mac OS X. Use 'make shared' like on other UNIX platforms,
    but a .dylib file will be created instead of .so.  If installed in a 
    nonstandard location, add its location to the DYLD_LIBRARY_PATH 
    environment variable so that the library can be found at run time.

  - made various modifications to better support the  8-byte long integer
    datatype on more platforms.  The 'LONGLONG' datatype is typedef'ed
    to equal 'long long' on most Unix platforms and MacOS, and equal
    to '__int64' on Windows machines.

  - modified configure.in and makefile.in to better support cases 
    where the system has no Fortran compiler and thus the f77 wrapper
    routines should not be compiled.

  - made small modification to eval.y and eval_y.f to get rid of warning
    on some platforms about redefinition of the 'alloca'.

  Bug fixes:

  - other recent bug fixes in ffdblk (delete blocks) caused ffdhdu (delete
    HDU) to fail when trying to replace the primary array with a null
    primary array.

  - fixed bug that prevented inserting a new variable length column
    into a table that already contained variable length data.

  - modified fits_delete_file so that it will delete the file even if
    the input status value is not equal to zero.

  - in fits_resize_image, it was sometimes necessary to call ffrdef to
    force the image structure to be defined.

  - modified the filename parser to support input files with names like:
    "myfile.fits.gz(mem://tmp)" in which the url type is specified for
    the output file but not for the input file itself.  This required
    modifications to ffiurl and ffrtnm.

Version 2.301 -   7 Dec 2001

  Enhancements:

   - modified the http file driver so that if the filename to be opened
     contains a '?' character (most likely a cgi related string) then it
     will not attempt to append a .gz or .Z as it would normally do.

   - added support for the '!' clobber character when specifying
     the output disk file name in CFITSIO's extended filename syntax, e.g.,
     'http://a.b.c.d/myfile.fits.gz(!outfile.fits)'

   - added new device driver which is used when opening a compressed FITS
     file on disk by uncompressing it into memory with READWRITE
     access.  This happens when specifying an output filename
     'mem://'.

   - added 2 other device drivers to open http and ftp files in memory
     with write access.

   - improved the error trapping and reporting in cases where program
     attempts to write to a READONLY file (especially in cases where the
    'file' resides in memory, as is the case when opening an ftp or http
     file.

   - modified the extended filename parser so that it is does not confuse
     the bracket character '[' which is sometimes used in the root name
     of files of type 'http://', as the start of an extname or row filter
     expression.  If the file is of type 'http://', the parser now
     checks to see if the last character in the extended file name is
     a ')' or ']'.  If not, it does not try to parse the file name
     any further.

   - improved the efficiency when writing FITS files in memory, by
     initially allocating enough memory for the entire HDU when it is
     created, rather than incrementally reallocing memory 2880 bytes
     at a time (modified ffrhdu and mem_truncate).  This change also
     means that the program will fail much sooner if it cannot allocate
     enough memory to hold the entire FITS HDU.

  Bug fixes:

   - There was an error in the definition of the Fortran ftphtb wrapper
     routine (writes required ASCII table header keywords) that caused
     it to fail on DEC OSF and other platforms where sizeof(long) = 8.

Version 2.300 - 23 Oct 2001

  New Routines:

   - fits_comp_img and fits_decomp_img are now fully supported and
     documented.  These routine compress and decompress, respective,
     a FITS image using a new algorithm in which the image is first
     divided into a grid of rectangular tiles, then the compressed byte
     stream from each tile is stored in a row of a binary table.
     CFITSIO can transparently read FITS images stored in this
     compressed format.  Compression ratios of 3 - 6 are typically
     achieved.  Large compression ratios are achieved for floating
     point images by throwing away non-significant noise bits in the
     pixel values.

   - fits_test_heap tests the integrity of the binary table heap and
     returns statistics on the amount of unused space in the heap and
     the amount of space that is pointed to by more than 1 descriptor.

   - fits_compress_heap which will reorder the arrays in the binary
     table heap, recovering any unused space.

  Enhancements:

   - made substantial internal changes to the code to support FITS
     files containing 64-bit integer data values.  These files have
     BITPIX = 64 or TFORMn = 'K'.  This new feature in CFITSIO is
     currently only enabled if SUPPORT_64BIT_INTEGERS is defined = 1 in
     the beginning of the fitsio2.h file.  By default support for
     64-bit integers is not enabled.

   - improved the ability to read and return a table column value as a
     formatted string by supporting quasi-legal TDISPn values which
     have a lowercase format code letter, and by completely ignoring
     other unrecognizable TDISPn values.  Previously, unrecognized
     TDISPn values could cause zero length strings to be returned.

   - made fits_write_key_longstr more efficient when writing keywords
     using the long string CONTINUE convention.  It previously did not
     use all the available space on each card when the string to be
     written contained many single quote characters.

   - added a new "CFITSIO Quick Start Guide" which provides all the
     basic information needed to write C programs using CFITSIO.

   - updated the standard COMMENT keywords that are written at the 
     beginning of every primary array to refer to the newly published
     FITS Standard document in Astronomy and Astrophysics.
     Note: because of this change, any FITS file created with this
     version of CFITSIO will not be identical to the same file written
     with a previous version of CFITSIO.

   - replaced the 2 routines in pliocomp.c with new versions provided by
     D Tody and N Zarate.  These routines compress/uncompress image pixels
     using the IRAF pixel list compression algorithm.

   - modified fits_copy_hdu so that when copying a Primary Array
     to an Image extension, the COMMENT cards which give the reference
     to the A&A journal article about FITS are not copied.  In the
     inverse case the COMMENT keywords are inserted in the header.
     
   - modified configure and Makefile.in to add capability to build a
     shared version of the CFITSIO library.  Type 'make shared' or 
     'make libcfitsio.so' to invoke this option.

   - disabled some uninformative error messages on the error stack:
       1) when calling ffclos (and then ffchdu) with input status > 0
       2) when ffmahd tries to move beyond the end of file.
     The returned status value remains the same as before, but the
     annoying error messages no longer get written to the error stack.

   - The syntax for column filtering has been modified so that
     if one only specifies a list of column names, then only those
     columns will be copied into the output file.  This provides a simple
     way to make a copy of a table containing only a specified list of
     columns.  If the column specifier explicitly deletes a column, however,
     than all the other columns will be copied to the filtered input
     file, regardless of whether the columns were listed or not.
     Similarly, if the expression specifies only a column to be modified
     or created, then all the other columns in the table will be
     copied.

      mytable.fit[1][col Time;Rate]  - only the Time and Rate
        columns will be copied to the filtered input file.

      mytable.fit[1][col -Time ] - all but the Time column are copied
        to the filtered input file.

      mytable.fit[1][col Rate;-Time] - same as above.

   - changed a '#if defined' statement in f77_wrap.h and f77_wrap1.c 
     to support the fortran wrappers on 64-bit IBM/RS6000 systems

   - modified group.c so that when attaching one group (the child) to 
     another (the parent), check in each file for the existence of a 
     pointer to the other before adding the link. This is to prevent
     multiple links from forming under all circumstances.

   - modified the filename parser to accept 'STDIN', 'stdin', 
     'STDOUT' and 'stdout' in addition to '-' to mean read the
     file from standard input or write to standard output.

   - Added support for reversing an axis when reading a subsection
     of a compressed image using the extended filename syntax, as in
     myfile.fits+1[-*, *] or myfile.fits+1[600:501,501:600]

   - When copying a compressed image to a uncompressed image, the
     EXTNAME keyword is no longer copied if the value is equal to
     'COMPRESSED_IMAGE'.

   - slight change to the comment field of the DATE keyword to reflect
     the fact that the Unix system date and time is not true UTC time.

  Bug fixes:

   - fits_write_key_longstr was not writing the keyword if a null
     input string value was given.

   - writing data to a variable length column, if that binary table is not
     the last HDU in the FITS file, might overwrite the following HDU.
     Fixed this by changing the order of a couple operations in ffgcpr.

   - deleting a column from a table containing variable length columns
     could cause the last few FITS blocks of the file to be reset = 0.
     This bug occurred as a result of modifications to ffdblk in v2.202.
     This mainly affects users of the 'compress_fits' utility
     program.

   - fixed obscure problem when writing bits to a variable length 'B' 
     column.

   - when reading a subsection of an image, the BSCALE and BZERO pixel
     scaling may not have been applied when reading image pixel values
     (even though the scaling keywords were properly written in the
     header).

   - fits_get_keyclass was not returning 'TYP_STRUCT_KEY' for the
     END keyword.

Version 2.204 - 26 July 2001 

  Bug fixes:

   - Re-write of fits_clean_url in group.c to solve various problems
     with invalid bounds checking.

Version 2.203 -  19 July 2001 (version in FTOOLS v5.1)

  Enhancements:

   - When a row selection or calculator expression is written in
     an external file (and read by CFITSIO with the '@filename' syntax)
     the file can now contain comment lines.  The comment line must
     begin with 2 slash characters as the first 2 characters on the
     line.  CFITSIO will ignore the entire line when reading the
     expression.

  Bug fixes:

   - With previous versions of CFITSIO, the pixel values in a FITS
     image could be read incorrectly in the following case: when
     opening a subset of a FITS image (using the
     'filename.fits[Xmin:Xmax,Ymin:Ymax]' notation) on a PC linux, PC
     Windows, or DEC OSF machine (but not on a SUN or Mac).  This
     problem only occurs when reading more than 8640 bytes of data
     (2160 4-byte integers) at a time, and usually only occurs if the
     reading program reads the pixel data immediately after opening the
     file, without first reading any header keywords.  This error would
     cause strips of zero valued pixels to appear at semi-random
     positions in the image, where each strip usually would be 2880
     bytes long.  This problem does not affect cases where the input
     subsetted image is simply copied to a new output FITS file.


Version 2.202 -  22 May 2001

  Enhancements:

   - revised the logic in the routine that tests if a point is
     within a region:  if the first region is an excluded region,
     then it implicitly assumes a prior include region covering
     the entire detector.  It also now supports cases where a 
     smaller include region is within a prior exclude region.

   - made enhancement to ffgclb (read bytes) so that it can
     also read values from a logical column, returning an array
     of 1s and 0s.  

   - defined 2 new grouping error status values (349, 350) in 
     cfitsio.h and made minor changes to group.c to use these new
     status values.

   - modified fits_open_file so that if it encounters an error while
     trying to move to a user-specified extension (or select a subset
     of the rows in an input table, or make a histogram of the
     column values) it will close the input file instead of leaving
     it open.

   - when using the extended filename syntax to filter the rows in
     an input table, or create a histogram image from the values in
     a table column, CFITSIO now writes HISTORY keywords in the 
     output file to document the filtering expression that was used.

  Bug fixes:

   - ffdblk (called by ffdrow) could overwrite the last FITS block(s) in 
     the file in some cases where one writes data to a variable length
     column and then calls ffdrow to delete rows in the table.  This
     bug was similar to the ffiblk bug that was fixed in v2.033.

   - modified fits_write_col_null to fix a problem which under unusual
     circumstances would cause a End-of-File error when trying to
     read back the value in an ASCII string column, after initializing
     if by writing a null value to it. 

   - fixed obscure bug in the calculator function that caused an
     error when trying to modify the value of a keyword in a HDU
     that does not have a NAXIS2 keyword (e.g., a null primary array).

   - the iterator function (in putcol.c) had a bug when calculating
     the optimum number rows to process in the case where the table
     has very wide rows (>33120 bytes) and the calculator expression
     involves columns from more than one FITS table.  This could
     cause an infinite loop in calls to the ffcalc calculator function.

   - fixed bug in ffmvec, which modifies the length of an 
     existing vector column in a binary table.  If the vector
     was reduced in length, the FITS file could sometimes be left
     in a corrupted state, and in all cases the values in the remaining
     vector elements of that column would be altered.

   - in drvrfile.c, replaced calls to fsetpos and fgetpos with
     fseek and ftell (or fseeko and ftello) because the fpos_t
     filetype used in fsetpos is incompatible with the off_t
     filetype used in fseek, at least on some platforms (Linux 7.0).
     (This fix was inserted into the V2.201 release on April 4).

   - added "#define fits_write_pixnull ffppxn" to longnam.h

Version 2.201 - 15 March 2001

  Enhancements

   - enhanced the keyword reading routines so that they will do
     implicit datatype conversion from a string keyword value
     to a numeric keyword value, if the string consist of a
     valid number enclosed in quotes.  For example, the keyword
     mykey = '37.5' can be read by ffgkye.

   - modified ffiimg so that it is possible to insert a new
     primary array at the beginning of the file.  The original
     primary array is then converted into an IMAGE extension.

   - modified ffcpdt (copy data unit) to support the case where 
     the data unit is being copied between 2 HDUs in the same file.

   - enhanced the fits_read_pix and fits_read_pixnull routines so
     that they support the tiled image compression format that the
     other image reading routines also support.

   - modified the Extended File Name syntax to also accept a 
     minus sign (-) as well as an exclamation point (!) as
     the leading character when specifying a column or or keyword
     to be deleted, as in [col -time] will delete the TIME column.

   - now completely support reading subimages, including pixel
     increments in each dimension, for tile-compressed images
     (where the compressed image tiles are stored in a binary
      table).

  Bug fixes:

   - fixed confusion in the use of the fpos_t and off_t datatypes
     in the fgetpos and fsetpos routines in drvrfile.c which caused
     problems with the Windows VC++ compiler.  (fpos_t is not 
     necessarily identical to off_t)

   - fixed a typo in the fits_get_url function in group.c which 
     caused problems when determining the relative URL to a compressed
     FITS file.

   - included fitsio.h in the shared memory utility program,
     smem.c, in order to define OFF_T. 

   - fixed typo in the datatype of 'nullvalue' in ffgsvi, which caused
     attempts to read subsections of a short integer tiled compressed
     image to fail with a bus error.    

   - fixed bug in ffdkey which sometimes worked incorrectly if one 
     tried to delete a nonexistent keyword beyond the end of the header.

   - fixed problem in fits_select_image_section when it writes a dummy
     value to the last pixel of the section.  If the image contains
     scaled integer pixels, then in some cases the pixel value could end
     up out of range.

   - fixed obscure bug in the ffpcn_ family of routines which gave
     a floating exception when trying to write zero number of pixels to
     a zero length array  (why would anyone do this?)

Version 2.200 - 26 Jan 2001

  Enhancements

   - updated the region filtering code to support the latest region
     file formats that are generated by the POW, SAOtng and ds9
     programs.  Region positions may now be given in HH:MM:SS.s,
     DD:MM:SS.s format, and region sizes may be given arcsec or arcmin
     instead of only in pixel units.  Also changed the logic so that if
     multiple 'include' regions are specified in the region file, they
     are ORed together, instead of ANDed, so that the filtering keeps
     points that are located within any of the 'include' regions, not
     just the intersection of the regions.

   - added support for reading raw binary data arrays by converting
     them on the fly into virtual FITS files.

   - modified ffpmsg, which writes error messages to CFITSIO's internal
     error stack, so that messages > 80 characters long will be wrapped
     around into multiple 80 character messages, instead of just
     being truncated at 80 characters.

   - modified the CFITSIO parser so that expression which involve
     scaled integer columns get cast to double rather than int.

   - Modified the keyword template parsing routine, ffgthd, to
     support the HIERARCH keyword.

   - modified ffainit and ffbinit so that they don't unnecessarily
     allocate 0 bytes of memory if there are no columns (TFIELDS = 0)
     in the table that is being opened.

   - modified fitsio2.h to support NetBSD on Alpha OSF platforms
     (NetBSD does not define the '__unix__' symbol).

   - changed the way OFF_T is defined in fitsio.h for greater
     portability.

   - changed drvrsmem.c so it is compiled only when HAVE_SHMEM_SERVICES
     is defined in order to removed the conditional logic from the Makefile

   - reorganized the CFITSIO User's guide to make it
     clearer and easier for new users to learn the basic routines.

   - fixed ffhdef (which reserves space for more header keywords) so
     that is also updates the start position of the next HDU.  This
     affected the offset values returned by ffghof.

Version 2.100 - 18 Oct 2000

  Enhancements

   - made substantial modification to the code to support Large files,
     i.e., files larger than 2**31 bytes = 2.1GB.  FITS files up to
     6 terabytes in size may now be read and written on platforms
     that support Large files (currently only Solaris).

   - modified ffpcom and ffphis, which write COMMENT and HISTORY 
     keywords, respectively, so that they now use columns 9 - 80, 
     instead of only columns 11 - 80.  Previously, these routines
     avoided using columns 9 and 10, but this is was unnecessarily
     restrictive.

   - modified ffdhdu so that instead of refusing to delete the 
     primary array, it will replace the current primary array 
     with a null primary array containing the bare minimum of
     required keywords and no data.

  New Routines

   - fits_read_pix, fits_read_pixnull, fits_read_subset, and fits_write_pix
     routines were added to enable reading and writing of Large images,
     with more than 2.1e9 pixels.  These new routines are now recommended
     as the basic routines for reading and writing all images.

   - fits_get_hduoff returns the byte offset in the file to
     the start and end of the current HDU.  This routine replaces the
     now obsolete fits_get_hduaddr routine;  it uses 'off_t' instead of
     'long' as the datatype of the arguments and can support offsets
     in files greater than 2.1GB in size.

  Bug fixes:

   - fixed bug in fits_select_image_section that caused an integer
     overflow when reading very large image sections (bigger than
     8192 x 8192 4-byte pixels).

   - improved ffptbb, the low-level table writing routine, so that 
     it will insert additional rows in the table if the table is
     not already big enough.  Previously it would have just over-
     written any HDUs following the table in the FITS file.

   - fixed a bug in the  fits_write_col_bit/ffpclx routine which
     could not write to a bit 'X' column if that was the first column
     in the table to be written to.  This bug would not appear if
     any other datatype column was written to first.

   - non-sensible (but still formally legal) binary table TFORM values
     such as '8A15', or '1A8' or 'A8' would confuse CFITSIO and cause it
     to return a 308 error.  When parsing the TFORMn = 'rAw' value,
     the ffbnfm routine has been modified to ignore the 'w' value in cases 
     where w > r.

   - fixed bug in the blsearch routine in iraffits.c which sometimes
     caused an out-of-bounds string pointer to be returned when searching
     for blank space in the header just before the 'END' keyword.

   - fixed minor problem in ffgtcr in group.c, which sometimes failed
     while trying to move to the end of file before appending a
     grouping table.

   - on Solaris, with Sun CC 5.0, one must check for '__unix' rather
     than '__unix__' or 'unix' as it's symbol.  Needed to modify this
     in drvrfile.c in 3 places.

   - in ffextn, the FITS file would be left open if the named
     extension doesn't exist, thus preventing the file from being
     opened again later with write access.

   - fixed bug in ffiimg that would cause attempts to insert a new
     image extension following a table extension, and in front of any
     other type of extension, to fail.

Version 2.037 - 6 July 2000

  Enhancements

   - added support in the extended filename syntax for flipping
     an image along any axis either by specifying a starting 
     section pixel number greater than the ending pixel number,
     or by using '-*' to flip the whole axis.  Examples:
     "myfile.fits[1:100, 50:10]" or "myfile.fits[-*,*]".

   - when reading a section of an image with the extended filename
     syntax (e.g. image.fits[1:100:2, 1:100:2), any CDi_j WCS keywords
     will be updated if necessary to transfer the world coordinate
     system from the imput image to the output image section.

   - on UNIX platforms, added support for filenames that begin
     with "~/" or "~user/".  The "~" symbol will get expanded
     into a string that gives the user's home directory.

   - changed the filename parser to support disk file names that
     begin with a minus sign.  Previously, the leading minus sign would
     cause CFITSIO to try to read/write the file from/to stdin/stdout.

   - modified the general fits_update_key routine, which writes
     or updates a keyword value, to use the 'G' display format
     instead of the 'E' format for floating point keyword values.
     This will eliminate trailing zeros from appearing in the value.

   - added support for the "-CAR" celestial coordinate projection
     in the ffwldp and ffxypx routines.  The "-CAR" projection is
     the default simplest possible linear projection.

   - added new fits_create_memfile/ffimem routine to create a new
     fits file at a designated memory location.

   - ported f77_wrap.h and f77_wrap1.c so that the Fortran interface
     wrappers work correctly on 64-bit SGI operating systems.  In this
     environment, C 'long's  are 8-bytes long, but Fortran 'integers'
     are still only 4-bytes long, so the words have to be converted
     by the wrappers.

   - minor modification to cfortran.h to automatically detect when it
     is running on a linux platform, and then define f2cFortran in that
     case.  This eliminates the need to define -Df2cFortran on the
     command line.

   - modified group.c to support multiple "/" characters in
     the path name of the file to be opened/created.

   - minor modifications to the parser (eval.y, eval_f.c, eval_y.c)
     to a) add the unary '+' operator, and b) support copying the
     TDIMn keyword from the input to the output image under certain
     circumstances.

   - modified the lexical parser in eval_l.y and eval_l.c to
     support #NULL and #SNULL constants which act to set the
     value to Null.  Support was also added for the C-conditional
     expression: 'boolean ? trueVal : falseVal'.

   - small modification to eval_f.c to write an error message to
     the error stack if numerical overflow occurs when evaluating
     an expression.

   - configure and configure.in now support the egcs g77 compiler
     on Linux platforms.

  Bug fixes:

   - fixed a significant bug when using the extended filename binning
     syntax to generate a 2-dimensional image from a histogram of the
     values in 2 table columns.  This bug would cause table events that
     should have been located in the row just below the bottom row of
     the image (and thus should have been excluded from the histogram)
     to be instead added into the first row of the image.  Similarly,
     the first plane of a 3-D or 4-D data cube would include the events
     that should have been excluded as falling in the previous plane of
     the cube.

   - fixed minor bug when parsing an extended filename that contains
     nested pairs of square brackets (e.g., '[col newcol=oldcol[9]]').

   - fixed bug when reading unsigned integer values from a table or
     image with fits_read_col_uint/ffgcvuk.  This bug only occurred on
     systems like Digital Unix (now Tru64 Unix) in which 'long'
     integers are 8 bytes long, and only when reading more than 7200
     elements at a time.  This bug would generally cause the program to
     crash with a segmentation fault.

   - modified ffgcpr to update 'heapstart' as well as 'numrows' when
     writing more rows beyond the end of the table.  heapstart
     is needed to calculate if more space needs to be inserted in the
     table when inserting columns into the table.

   - modified fficls (insert column), ffmvec, ffdrow and ffdcol to 
     not use the value of the NAXIS2 keyword as the number of rows
     in the table, and instead use the value that is stored in
     an internal structure, because the keyword value may not
     be up to date.

   - Fixed bug in the iterator function that affected the handling
     of null values in string columns in ASCII and binary tables.

   - Reading a subsample of pixels in very large images, (e.g., 
     file = myfile.fits[1:10000:10,1:10000:10],  could cause a
     long integer overflow (value > 2**31) in the computation of the
     starting byte offset in the file, and cause a return error status
     = 304 (negative byte address).  This was fixed by changing the
     order of the arithmetic operations in calculating the value of
     'readptr' in the ffgcli, ffgclj, ffgcle, ffgcld, etc. routines.

   - In version 2.031, a fix to prevent compressed files from being
     opened with write privilege was implemented incorrectly.  The fix
     was intended to not allow a compressed FITS file to be opened
     except when a local uncompressed copy of the file is being
     produced (then the copy is opened with write access), but in fact
     the opposite behavior occurred:  Compressed files could be opened
     with write access, EXCEPT when a local copy is produced.   This
     has been fixed in the mem_compress_open and file_compress_open
     routines.

   - in iraffits.c, a global variable called 'val' caused multiply
     defined symbols warning when linking cfitsio and IRAF libraries.
     This was fixed by making 'val' a local variable within the
     routine.

Version 2.036 - 1 Feb 2000

   - added 2 new generic routines, ffgpf and ffgcf which are analogous
     to ffgpv and ffgcv but return an array of null flag values instead
     of setting null pixels to a reserved value.

   - minor change to eval_y.c and eval.y to "define alloca malloc"
     on all platforms, not just VMS.

   - added support for the unsigned int datatype (TUINT) in the
     generic ffuky routine and changed ffpky so that unsigned ints
     are cast to double instead of long before being written to 
     the header. 

   - modified ffs2c so that if a null string is given as input then
     a null FITS string (2 successive single quotes) will be returned.
     Previously this routine would just return a string with a single
     quote, which could cause an illegal keyword record to be written.

   - The file flush operation on Windows platforms apparently
     changes the internal file position pointer (!) in violation of the
     C standard.  Put a patch into the file_flush routine to explicitly
     seek back to the original file position.

   - changed the name of imcomp_get_compressed_image_parms to
     imcomp_get_compressed_image_par to not exceed the 31 character
     limit on some compilers.

   - modified the filename parser (which is used when moving to a
     named HDU) to support EXTNAME values which contain embedded blanks.

   - modified drvrnet.c to deal with ftp compressed files better so
     that even fits files returned from cgi queries which have the wrong
     mime types and/or wrong types of file names should still decompress.

   - modified ffgics to reduce the tolerance for acceptable skewness
     between the axes, and added a new warning return status = 
     APPROX_WCS_KEY in cases where there is significant skewness
     between the axes.

   - fixed bug in ffgics that affected cases where the first coordinate
     axis was DEC, not RA, and the image was a mirror image of the sky.

   - fixed bug in ffhist when trying to read the default binning
     factor keyword, TDBIN.

   - modified ffhist so that is correctly computes the rotation angle
     in a 2-D image if the first histogram column has a CROTA type
     keyword but the 2nd column does not.

   - modified ffcpcl so that it preserves the comment fields on the
     TTYPE and TFORM keywords when the column is copied to a new file.

   - make small change to configure.in to support FreeBSD Linux 
     by setting CFLAGS = -Df2cFortran instead of -Dg77Fortran. Then
     regenerated configure with autoconf 2.13 instead of 2.12.     

Version 2.035 - 7 Dec 1999 (internal release only, FTOOLS 5.0.2)

   - added new routine called fits_get_keyclass/ffgkcl that returns
     the general class of the keyword, e.g., required structural 
     keyword, WCS keyword, Comment keyword, etc.  15 classes of
     keywords have been defined in fitsio.h

   - added new routine called fits_get_img_parm/ffgipr that is similar
     to ffgphd but it only return the bitpix, naxis, and naxisn values.

   - added 3 new routines that support the long string keyword
     convention: fits_insert_key_longstr, fits_modify_key_longstr
     fits_update_key_longstr.

   - modified ffgphd which reads image header keywords to support
     the new experimental compressed image format.

   - when opening a .Z compressed file, CFITSIO tries to allocate
     memory equal to 3 times the file size, which may be excessive
     in some cases.  This was changed so that if the allocation fails,
     then CFITSIO will try again to allocate only enough memory
     equal to 1 times the file size.  More memory will be allocated
     later if this turns out to be too small.

   - improved the error checking in the fits_insert_key routine
     to check for illegal characters in the keyword.

Version 2.034 - 23 Nov 1999

   - enhanced support for the new 'CD' matrix world coordinate system
     keywords in the ffigics routine.  This routine has been enhanced
     to look for the new 'CD' keywords, if present, and convert them
     back to the old CDELTn and CROTAn values, which are then returned.  
     The routine will also swap the WCS parameters for the 2 axes if
     the declination-like axis is the first WCS axis.

   - modified ffphbn in putkey.c to support the 'U' and 'V" TFORM characters
     (which represent unsigned short and unsigned int columns) in variable
     length array columns.  (previously only supported these types in
     fixed length columns).

   - added checks when reading gzipped files to detect unexpected EOF.
     Previously, the 'inflate_codes' routine would just sit in an infinite 
     loop if the file ended unexpectedly.

   - modified fits_verify_chksum/ffvcks so that checksum keywords with
     a blank value string are treated as undefined, the same as
     if the keyword did not exist at all.

   - fixed ffghtb and ffghbn so that they return the extname value 
     in cases where there are no columns in the table.

   - fixed bug in the ffgtwcs routine (this is a little utility 
     routine to aid in interfacing to Doug Mink's WCS routines);
     it was not correctly padding the length of string-valued keywords
     in the returned string.

   - fixed bug in 'iraffits.c' that prevented Type-2 IRAF images from
     being correctly byte-swapped on PCs and DEC-OSF machines.

   - fixed tiny memory leak in irafncmp in iraffits.c.  Only relevant when
     reading IRAF .imh files.

   - fixed a bug (introduced in version 2.027) that caused the keyword
     reading routines to sometimes not find a matching keyword if the
     input name template used the '*' wildcard as the last character.
     (e.g., if input name = 'COMMENT*' then it would not find the
     'COMMENT' keywords.  (It would have found longer keywords like
     'COMMENTX' correctly). The fix required a minor change to ffgcrd
     in getkey.c

   - modified the routine (ffswap8) that does byteswapping of
     double precision numbers.  Some linux systems have reported floating
     point exceptions because they were trying to interpret the bytes
     as a double before the bytes had been swapped.

   - fixed bug in the calculation of the position of the last byte
     in the string of bits to be read in ffgcxuk and ffgcxui.  This
     bug generally caused no harm, but could cause the routine to
     exit with an invalid error message about trying to read
     beyond the size of the field.

   - If a unix machine did not have '__unix__', 'unix', or  '__unix'
     C preprocessor symbols defined, then CFITSIO would correctly open
     one FITS file, but would not correctly open subsequent files. Instead
     it would think that the same file was being opened multiple times.
     This problem has only been seen on an IBM/AIX machine. The fits_path2url
     and fits_url2path routines in group.c were modified to fix the problem.

   - fixed bug in group.c, which affected WINDOWS platforms only, that 
     caused programs to go into infinite loop when trying to open
     certain files.

   - the ftrsim Fortran wrapper routine to ffrsim was not defined
     correctly, which caused the naxis(2) value to be passed incorrectly
     on Dec OSF machines, where sizeof(long) != sizeof(int).

Version 2.033 - 17 Sept 1999

   - New Feature: enhanced the row selection parser so that comparisons
     between values in different rows of the table are allowed, and the
     string comparisons with <, >, <=, and >= are supported.

   - added new routine the returns the name of the keyword in the
     input keyword record string.  The name is usually the first
     8 characters of the record, except if the HIERARCH convention
     is being used in which case the name may be up to 67 characters
     long.

   - added new routine called fits_null_check/ffnchk that checks to
     see if the current header contains any null (ASCII 0) characters.
     These characters are illegal in FITS headers, but they go undetected
     by the other CFITSIO routines that read the header keywords.

   - the group.c file has been replaced with a new version as supplied
     by the ISDC.  The changes are mainly to support partial URLs and
     absolute URLs more robustly.  Host dependent directory paths are
     now converted to true URLs before being read from/written to
     grouping tables.

   - modified ffnmhd slightly so that it will move to the first extension
     in which either the EXTNAME or the HDUNAME keyword is equal to the
     user-specified name.  Previously, it only checked for HDUNAME if
     the EXTNAME keyword did not exist.

   - made small change to drvrnet.c so that it uncompress files 
     which end in .Z and .gz just as for ftp files.

   - rewrote ffcphd (copy header) to handle the case where the
     input and output HDU are in the same physical FITS file.

   - fixed bug in how long string keyword values (using the CONTINUE
     convention) were read.  If the string keyword value ended in an
     '&' character, then fits_read_key_longstr, fits_modify_key_str,
     and fits_delete_key would interpret the following keyword as
     a continuation, regardless of whether that keyword name was
     'CONTINUE' as required by this convention.  There was also a bug
     in that if the string keyword value was all blanks, then 
     fits_modify_key_str could in certain unusual cases think
     that the keyword ended in an '&' and go into an infinite loop.

   - modified ffgpv so that it calls the higher level ffgpv_ routine
     rather than directly calling the lower level ffgcl_ routine. This
     change is needed to eventually support reading compressed images.

   - added 3 new routines to get the image datatype, image dimensions,
     and image axes length.  These support the case where the image is
     compressed and stored in a binary table.

   - fixed bug in ffiblk that could sometimes cause it to insert a
     new block in a file somewhere in the middle of the data, instead
     of at the end of the HDU.  This fortunately is a rare problem,
     mainly only occurring in certain cases when  inserting rows in a binary 
     table that contains variable length array data (i.e., has a heap).

   - modified fits_write_tdim so that it double checks the TFORMn
     value directly if the column repeat count stored in the internal
     structure is not equal to the product of all the dimensions.

   - fixed bug that prevented ffitab or ffibin from inserting a new
     table after a null primary array (can't read NAXIS2 keyword).
     Required a small change to ffrdef.

   - modified testprog.c so that it will continue to run even if
     it cannot open or process the template file testprog.tpt.

   - modified the logic in lines 1182-1185 of grparser.c so that
     it returns the correct status value in case of an error.

   - added test in fitsio2.h to see if __sparcv9 is defined; this
     identifies a machine running Solaris 7 in 64-bit mode where
     long integers are 64 bits long.

Version 2.032 - 25 May 1999

   - the distribution .tar file was changed so that all the files
     will be untarred into a  subdirectory by default instead of
     into the current directory.

   - modified ffclos so that it always frees the space allocated by
     the fptr pointer, even when another fptr points to the same file.

   - plugged a potential (but rare in practice) memory leak in ffpinit

   - fixed bug in all the ffp3d_ and ffg3d_ routines in cases where
     the data cube that has been allocated in memory has more planes
     than the data cube in the FITS file.

   - modified drvrsmem.c so that it allocates a small shared
     memory segment only if CFITSIO tries to read or write a
     FITS file in shared memory.  Previously it always allocated
     the segment whether it was needed or not.  Also, this small
     segment is removed if 0 shared memory segments remain in 
     the system.

   - put "static" in front of 7 DECLARE macros in compress.c
     because these global variables were causing conflicts with other
     applications programs that had variables with the same names.

   - modified ffasfm to return datatype = TDOUBLE instead of TFLOAT
     if the ASCII table column has TFORMn = 'Ew.d' with d > 6.

   - modified the column reading routines to a) print out the offending
     entry if an error occurs when trying to read a numeric ASCII table
     column, and b) print out the column number that had the error
     (the messages are written to CFITSIOs error stack)

   - major updates to the Fortran FITSIO User's Guide to include many
     new functions that have been added to CFITSIO in the past year.

   - modified fitsio2.h so that the test for __D_FLOAT etc. is only
     made on Alpha VMS machines, to avoid syntax errors on some other
     platforms.

   - modified ffgthd so that it recognizes a floating point value
     that uses the 'd' or 'D' exponent character.

   - removed the range check in fftm2s that returned an error if
     'decimals' was less than zero.  A negative value is OK and is
     used to return only the date and not the time in the string.

Version 2.031 - 31 Mar 1999

   - moved the code that updates the NAXIS2 and PCOUNT keywords from
     ffchdu into the lower lever ffrdef routine.  This ensures that
     other routines which call ffrdef will correctly update these 2
     keywords if required.  Otherwise, for instance, calling 
     fits_write_checksum before closing the HDU could cause the NAXIS2
     keyword (number of rows in the table) to not be updated.

   - fixed bug (introduced in version 2.030) when writing null values
     to a primary array or image extension.  If trying to set more
     than 1 pixel to null at a time, then typically only 1 null would
     be written.  Also fixed related bug when writing null values to
     rows in a table that are beyond the currently defined size of the
     table (the size of the table was not being expanded properly).

   - enhanced the extended filename parser to support '*' in image
     section specifiers, to mean use the whole range of the axis.
     myfile.fits[*,1:100] means use the whole range of the first
     axis and pixels 1 to 100 in the second axis.  Also supports
     an increment, as in myfile.fits[*:2, *:2] to use just the
     odd numbered rows and columns.

   - modified fitscore.c to set the initial max size of the header, when
     first reading it, to the current size of the file, rather than to 
     2 x 10**9 to avoid rare cases where CFITSIO ends up writing a huge 
     file to disk.

   - modified file_compress_open so that it will not allow a compressed
     FITS file to be opened with write access.  Otherwise, a program
     could write to the temporary copy of the uncompressed file, but
     the modification would be lost when the program exits.

Version 2.030 - 24 Feb 1999

   - fixed bug in ffpclu when trying to write a null value to a row
     beyond the current size of the table (wouldn't append new rows
     like it should).

   - major new feature:  enhanced the routines that read ASCII string
     columns in tables so that they can read any table column, including
     logical and numeric valued columns.  The column values are returned
     as a formatted string.  The format is determined by the TDISPn
     keyword if present, otherwise a default format based on the
     datatype of the column is used.

  -  new routine:  fits_get_col_display_width/ffgcdw returns the length
     of the formatted strings that will be returned by the routines that
     read table columns as strings. 

   - major new feature:  added support for specifying an 'image section'
     when opening an image:  e.g,  myfile.fits[1:512:2,2:512:2] to 
     open a 256x256 pixel image consisting of the odd columns and the 
     even numbered rows of the input image.

   - added supporting project files and instructions for building 
     CFITSIO under Windows NT with the Microsoft Visual C++ compiler.

   - changed the variable 'template' to 'templt' in testprog.c since
     it conflicted with a reserved word on some compilers.

   - modified group.c to conditionally include sys/stat.h only on
     unix platforms

   - fixed bug in the ffiter iterator function that caused it to always
     pass 'firstn' = 1 to the work function when reading from the
     primary array or IMAGE extension. It worked correctly for tables.

   - fixed bug in the template header keyword parser (ffgthd) in cases
     where the input template line contains a logical valued keyword
     (T or F) without any following comment string.  It was previously
     interpreting this as a string-valued keyword.

   - modified ffrhdu that reads and opens a new HDU, so that it
     ignores any leading blank characters in the XTENSION name, e.g.,
     XTENSION= '  BINTABLE' will not cause any errors, even though
     this technically violates the FITS Standard.

   - modified ffgtbp that reads the required table keywords to make
     it more lenient and not exit with an error if the THEAP keyword
     in binary tables cannot be read as an integer.  Now it will
     simply ignore this keyword if it cannot be read.

   - added test for 'WIN32' as well as '__WIN32__' in fitsio2.h,
     eval.l and eval_l.c in a preprocessor statement.

   - changed definition of strcasecmp and strncasecmp in fitsio2.h,
     eval.l and eval_l.c to conform to the function prototypes under
     the Alpha VMS v7.1 compiler.

   - corrected the long function names in longnam.h for the new WCS 
     utility functions in wcssubs.c

Version 2.029 - 11 Feb 1999

   - fixed bug in the way NANs and underflows were being detected on
     VAX and Alpha VMS machines.

   - enhanced the filename parser to distinguish between a VMS-style
     directory name (e.g.  disk:[directory]myfile.fits) and a CFITSIO
     filter specifier at the end of the name.

   - modified ffgthd to support the HIERARCH convention for keyword
     names that are longer than 8 characters or contain characters
     that would be illegal in standard FITS keyword names.

   - modified the include statements in grparser.c so that malloc.h 
     and memory.h are only included on the few platforms that really
     need them.

   - modified the file_read routine in drvrfile.c to ignore the last
     record in the FITS file it it only contains a single character that
     is equal to 0, 10 or 32.  Text editors sometimes append a character
     like this to the end of the file, so CFITSIO will ignore it and
     treat it as if it had reached the end of file.

   - minor modifications to fitsio.h to help support the ROOT environment.

   - installed new version of group.c and group.h; the main change
     is to support relative paths (e.g.  "../filename") in the URLs

   - modified the histogramming routines so that it looks for the
     default preferred column axes in a keyword of the form
     CPREF = 'Xcol, Ycol'
     instead of separate keywords of the form
     CPREF1 = 'Xcol'
     CPREF2 = 'Ycol'

   - fixed bug so that if the binning spec is just a single integer,
     as in  [bin 4] then this will be interpreted as meaning to make
     a 2D histogram using the preferred or default axes, with the
     integer taken as the binning factor in both axes.

Version 2.028 - 27 Jan 1999

   - if the TNULLn keyword value was outside the range of a 'I' or 'B'
     column, an overflow would occur when setting the short or char 
     to the TNULLn value, leading to incorrect values being flagged as
     being undefined.  This has been fixed so that CFITSIO will ignore
     TNULLn values that are beyond the range of the column data type.

   - changed a few instances of the string {"\0"} to {'\0'} in the
     file groups.c

   - installed new version of the grparser.c file from the ISDC

   - added new WCS support routines (in wcssub.c) which make it easier
     to call Doug Mink's WCSlib routines for converting between plate
     and sky coordinates.   The CFITSIO routines themselves never
     call a WCSlib routine, so CFITSIO is not dependent on WCSlib.

   - modified  ffopen so that if you use the extended filename
     syntax to both select rows in a table and then bin columns into
     a histogram, then CFITSIO will simply construct an array listing
     the good row numbers to be used when making the histogram,
     instead of making a whole new temporary FITS file containing
     the selected rows.

   - modified ffgphd which parses the primary array header keywords
     when opening a file, to not choke on minor format errors in 
     optional keywords.  Otherwise, this prevents CFITSIO from
     even opening the file.

   - changed a few more variable declarations in compress.c from global
     to static.

Version 2.027 - 12 Jan 1999

   - modified the usage of the output filename specifier so that it,
       a) gives the name of the binned image, if specified, else,
       b) gives the name of column filtered and/or row filtered table, if 
          specified, else
       c) is the name for a local copy of the ftp or http file, else,
       d) is the name for the local uncompressed version of the compressed
          FITS file, else,
       e) the output filename is ignored.

   - fixed minor bug in ffcmps, when comparing 2 strings while using
     a '*' wild card character.

   - fixed bug in ftgthd that affected cases where the template string
     started with a minus sign and contained 2 tokens (to rename a
     keyword).

   - added support for the HIERARCH keyword convention for reading 
     and writing keywords longer than 8 characters or that contain
     ASCII characters not allowed in normal FITS keywords. 

   - modified the extended filename syntax to support opening images
     that are contained in a single cell of a binary table with syntax:
     filename.fits[extname; col_name(row_expression)]

Version 2.026 - 23 Dec 1998

   - modified the group parser to:
     a) support CFITSIO_INCLUDE_FILES environment variable, which can
     point to the location of template files, and, 
     b) the FITS file parameter passed to the parser no longer has to point
     to an empty file.  If there are already HDUs in the file, then the
     parser appends new HDUs to the end of the file.

   - make a small change to the drvrnet.c file to accommodate creating
     a static version of the CFITSIO library.

   - added 2 new routines to read consecutive bits as an unsigned integer 
     from a Bit 'X' or Byte 'B' column (ffgcxui and ffgcxuk).

   - modified the logic for determining histogram boundaries in ffhisto
     to add one more bin by default, to catch values that are right on
     the upper boundary of the histogram, or are in the last partial bin.

   - modified cfitsio2.h to support the new Solaris 7 64-bit mode operating
     system.

   - Add utility routine, CFits2Unit, to the Fortran wrappers which searches
     the gFitsFiles array for a fptr, returning its element (Fortran unit
     number), or allocating a new element if one doesn't already
     exists... for C calling Fortran calling CFITSIO.

   - modified configure so that it does not use the compiler optimizer
     when using gcc 2.8.x on Linux

   - (re)added the fitsio.* documentation files that describe the
     Fortran-callable FITSIO interface to the C routines.

   - modified the lexical parser in eval_f.c to fix bug in null detections
     and bug in ffsrow when nrows = 0.

   - modified ffcalc so that it creates a TNULLn keyword if appropriate 
     when a new column is created.  Also fixed detection of OVERFLOWs
     so that it ignores null values.

   - added hyperbolic trig and rounding functions to
     the lexical parser in the eval* files.

   - improved error message that gets written when the group number is
     out of range when reading a 'random groups' array.

   - added description of shared memory, grouping, and template parsing
     error messages to ffgerr and to the User's Guide.  Moved the error
     code definitions from drvsmem.h to fitsio.h.

   - modified grparser.c to compile correctly on Alpha/OSF machines

   - modified drvrnet.c to eliminate compiler warnings

   - Modified Makefile.in to include targets for building all the sample
     programs that are included with CFITSIO.

Version 2.025 - 1 Dec 1998

   - modified ffgphd and ffgtbp so that they ignores BLANK and TNULLn keywords
     that  do not have a valid integer value.  Also, any error while reading
     the BSCALE, BZERO, TSCALn, or TZEROn keywords will be ignored.  
     Previously, CFITSIO would have simply refused to read an HDU that had 
     such an invalid keyword.

   - modified the parser in eval_f.c to accept out of order times in GTIs

   - updated cfitsio_mac.sit.hqx to fix bad target parameters for Mac's
     speed test program

   - modified template parser in grparser.c to: 1) not write GRPNAME keyword
     twice, and 2) assign correct value for EXTVERS keyword.

   - fixed minor bugs in group.c; mainly would only affect users of the
     INTEGRAL Data Access Layer.

   - temporarily removed the prototype for ffiwcs from fitsio.h until
     full WCS support is added to CFITSIO in the near future.

   - modified the HTTP driver to send a User-Agent string:
     HEASARC/CFITSIO/<version number>

   - declared local variables in compress.c as 'static' to avoid
     conflicts with other libraries.

Version 2.024 - 9 Nov 1998

   - added new function fits_url_type which returns the driver prefix string
     associated with a particular FITS file pointer.

Version 2.023 - 1 Nov 1998 - first full release of CFITSIO 2.0

   - slightly modified the way real keyword values are formatted, to ensure
     that it includes a decimal point.  E.g.,  '1.0E-09' instead of '1E-09'

   - added new function to support template files when creating new FITS files.

   - support the TCROTn WCS keyword in tables, when reading the WCS keywords.

   - modified the iterator to support null values in logical columns in
     binary tables.

   - fixed bug in iterator to support null values in integer columns in
     ASCII tables.

   - changed the values for FLOATNULLVALUE and DOUBLENULLVALUE to make them
     less likely to duplicate actual values in the data.

   - fixed major bug when freeing memory in the iterator function.  It caused
     mysterious crashes on a few platforms, but had no effect on most others.

   - added support for reading IRAF format image (.imh files)

   - added more error checking to return an error if the size of the FITS
     file exceeds the largest value of a long integer (2.1 GB on 32-bit
     platforms).

   - CFITSIO now will automatically insert space for additional table rows
     or add space to the data heap, if one writes beyond the current end
     of the table or heap.  This prevents any HDUs which might follow
     the current HDU from being overwritten.  It is thus no longer necessary
     to explicitly call fits_insert_rows before writing new rows of data
     to the FITS file.

   - CFITSIO now automatically keeps track of the number of rows that have
     been written to a FITS table, and updates the NAXIS2 keyword accordingly
     when the table is closed.  It is no longer necessary for the application
     program to updated NAXIS2.  

   - When reading from a FITS table, CFITSIO will now return an error if the
     application tries to read beyond the end of the table. 

   - added 2 routines to get the number of rows or columns in a table.

   - improved the undocumented feature that allows a '20A' column to be
     read as though it were a '20B' column by fits_read_col_byt.  

   - added overflow error checking when reading keywords.  Previously, the
     returned value could be silently truncated to the maximum allowed value
     for that data type.  Now an error status is returned whenever an 
     overflow occurs.

   - added new set of routines dealing with hierarchical groups of files.
     These were provided by Don Jennings of the INTEGRAL Science Data Center.

   - added new URL parsing routines.

   - changed the calling sequence to ffghad (get HDU address) from
     ffghad(fitsfile *fptr, > long *headstart, long *dataend) to
     ffghad(fitsfile *fptr, > long *headstart, long datastart, 
            long *dataend, int *status) 

   - major modification to support opening the same FITS file more
     than once.  Now one can open the same file multiple times and
     read and write simultaneously to different HDUs within the file.
     fits_open_file automatically detects if the file is already opened.

   - added the ability to clobber/overwrite an existing file
     with the same name when creating a new output file.  Just
     precede the output file name with '!' (an exclamation mark)

   - changed the ffpdat routine which writes the DATE keyword
     to use the new 'YYYY-MM-DDThh:mm:ss' format.

   - added several new routines to create or parse the new date/time
     format string.

   - changed ifdef for DECFortran in f77_wrap.h and f77_wrap1.c:
     expanded to recognize Linux/Alpha

   - added new lexical parsing routines (from Peter Wilson):
     eval_l.c, eval_y.c, eval_f.c, eval_defs.h, and eval_tab.h.
     These are used when doing on-the-fly table row selections.

   - added new family of routines to support reading and writing
     'unsigned int' data type values in keywords, images or tables.

   - restructured all the putcol and getcol routines to provide
     simpler and more robust support for machines which have
     sizeof(long) = 8.  Defined a new datatype INT32BIT which is
     always 32 bits long (platform independent) and is used internally
     in CFITSIO when reading or writing BITPIX = 32 images or 'J'
     columns.  This eliminated the need for specialize routines like
     ffswaplong, ffunswaplong, and ffpacklong.

   - overhauled cfileio.c (and other files) to use loadable drivers for
     doing data I/O to different devices.  Now CFITSIO support network 
     access to ftp:// and http:// files, and to shared memory files.

   - removed the ffsmem routine and replaced it with ffomem.  This will
     only affect software that reads an existing file in core memory.
     (written there by some other process).

   - modified all the ffgkn[] routines (get an array of keywords) so
     that the 'nfound' parameter is = the number of keywords returned,
     not the highest index value on the returned keywords.  This makes
     no difference if the starting index value to look for = 1.
     This change is not backward compatible with previous versions
     of CFITSIO, but is the way that FITSIO behaved.

   - added new error code = 1 for any application error external
     to CFITSIO.  Also reports "unknown error status" if the
     value doesn't match a known CFITSIO error.

Version 1.42 - 30 April 1998 (included in FTOOLS 4.1 release)

   - modified the routines which read a FITS float values into
     a float array, or read FITS double values into a double array,
     so that the array value is also explicitly set in addition
     to setting the array of flag values, if the FITS value is a NaN.
     This ensures that no NaN values get passed back to the calling
     program, which can cause serious problems on some platforms (OSF).

   - added calls to ffrdef at the beginning of the insert
     or delete rows or columns routines in editcol.c to make sure
     that CFITSIO has correctly initialized the HDU information.

   - added new routine ffdrws to delete a list of rows in a table

   - added ffcphd to copy the header keywords from one hdu to another

   - made the anynul parameter in the ffgcl* routines optional
     by first checking to see if the pointer is not null before
     initializing it.

   - modified ffbinit and ffainit to ignore minor format
     errors in header keywords so that cfitsio can at least
     move to an extension that contains illegal keywords.

   - modified all the ffgcl* routines to simply return without
     error if nelem = 0.

   - added check to ffclose to check the validity of the fitsfile
     pointer before closing it.  This should prevent program crashes
     when someone tries to close the same file more than once.

   - replaced calls to strcmp and strncmp with macros FSTRCMP and
     FSTRNCMP in a few places to improve performance when reading
     header keywords (suggested by Mike Noble)

  Bug Fixes:

   - fixed typo in macro definition of error 504 in the file fitsio.h.

   - in ffopen, reserved space for 4 more characters in the input
     file name in case a '.zip' suffix needs to be added.

   - small changes to ffpclx to fix problems when writing bit (X) data
     columns beyond the current end of file.

   - fixed small bug in ffcrhd where a dummy pointer was not initialized

   - initialized the dummy variable in ffgcfe and ffgcfd which
     was causing crashes under OSF in some cases.

   - increased the length of the allocated string ffgkls by 2
     to support the case of reading a numeric keyword as a string
     which doesn't have the enclosing quote characters.

Version 1.4 - 6 Feb 1998 

   - major restructuring of the CFITSIO User's Guide

   - added the new 'iterator' function.  The fortran wrapper is
     in f77_iter.c for now.

   - enhanced ffcrtb so that it writes a dummy primary array
     if none currently exists before appending the table.

   - removed the ffgcl routine and replaced it with ffgcvl 

   - modified ffpcnl to just take a single input null value instead
     of an entire array of null value flags.

   - modified ffcmps and ffgnxk so that, for example, the string 'rate' 
     is not considered a match to the string 'rate2', and 'rate*'
     is a match to the string 'rate'.

   - modified ffgrsz to also work with images, in which case
     it returns the optimum number of pixels to process at
     one time.

   - modified ffgthd to support null valued keywords

   - added a new source file 'f77_wrap.c' that includes all the
     Fortran77 wrapper routines for calling CFITSIO.  This will
     eventually replace the Fortran FITSIO library.

   - added new routines:
     ffppn - generic write primary array with null values
     ffpprn - write null values to primary array

     ffuky - 'update' a keyword value, with any specified datatype.

     ffrprt - write out report of error status and error messages
     ffiter - apply a user function iteratively to all the rows of a table
     ffpkyc - write complex-valued keyword
     ffpkym - write double complex-valued keyword
     ffpkfc - write complex-valued keyword in fixed format
     ffpkfm - write double complex-valued keyword in fixed format

     ffgkyc - read complex-valued keyword
     ffgkym - read double complex-valued keyword

     ffmkyc - modify complex-valued keyword
     ffmkym - modify double complex-valued keyword
     ffmkfc - modify complex-valued keyword in fixed format
     ffmkfm - modify double complex-valued keyword in fixed format

     ffukyc - update complex-valued keyword
     ffukym - update double complex-valued keyword
     ffukfc - update complex-valued keyword in fixed format
     ffukfm - update double complex-valued keyword in fixed format

     ffikyc - insert complex-valued keyword
     ffikym - insert double complex-valued keyword
     ffikfc - insert complex-valued keyword in fixed format
     ffikfm - insert double complex-valued keyword in fixed format

     ffpktp - write or modify keywords using ASCII template file
     ffcpcl - copy a column from one table to another
     ffcpky - copy an indexed keyword from one HDU to another
     ffpcnl - write logical values, including nulls, to binary table
     ffpcns - write string values,  including nulls, to table
     ffmnhd - move to HDU with given exttype, EXTNAME and EXTVERS values
     ffthdu - return the total number of HDUs in the file
     ffghdt - return the type of the  CHDU
     ffflnm - return the name of the open FITS file
     ffflmd - return the mode of the file (READONLY or READWRITE)

   - modified ffmahd and ffmrhd (to move to a new extension) so that
     a null pointer may be given for the returned HDUTYPE argument.

   - worked around a bug in the Mac CWpro2 compiler by changing all
     the statements like "#if BYTESWAPPED == TRUE" to "if BYTESWAPPED".

   - modified ffitab (insert new ASCII table) to allow tables with
     zero number of columns

   - modified Makefile.in and configure to define the -Dg77Fortran
     CFLAGS variable on Linux platforms.  This is needed to 
     compile the new f77_wrap.c file (which includes cfortran.h)

  Bug Fixes:

   - fixed small bug in ffgrz (get optimum row size) which sometimes
     caused it to return slightly less than the maximum optimum size.
     This bug would have done no harm to application programs.

   - fixed bug in ffpclk and ffgclk to add an 'else' case
     if size of int is not equal to size of short or size of long.

   - added test to ffgkls to check if the input string is not null before
     allocating memory for it.

Version 1.32 - 21 November 1997 (internal release only)

   - fixed bug in the memory deallocation (free) statements
     in the ffopen routine in the cfileio.c file.

   - modified ffgphd to tolerate minor violations of the FITS 
     standard in the format of the XTENSION = 'IMAGE   '
     keyword when reading FITS files.  Extra trailing spaces
     are now allowed in the keyword value.  (FITS standard
     will be changed so that this is not a violation).

Version 1.31 - 4 November 1997 (internal release only)

  Enhancements:

   - added support for directly reading compressed FITS files
     by copying the algorithms from the gzip program. This 
     supports the Unix compress, gzip and pkzip algorithms.

   - modified ffiimg, ffitab, and ffibin (insert HDUs into
     a FITS file) so that if the inserted HDU is at the end of
     the FITS file, then it simply appends a new empty HDU
     and writes the required keywords.  This allows space
     to be reserved for additional keywords in the header
     if desired.

   - added the ffchfl and ffcdfl routines to check the header and
     data fill values, for compatibility with the Fortran FITSIO
     library.

   - added the ffgsdt routine to return the system date
     for compatibility with the Fortran FITSIO library.

   - added a diagnostic error message (written to the error stack)
     if the routines that read data from image or column fail.

   - modified ffgclb so that it simply copies the bytes from 
     an ASCII 'nA' or 'An' format column into the user's byte
     array.  Previously, CFITSIO would return an error when 
     trying to read an 'A' column with ffgclb.

   - modified ffpclb so that it simply copies the input array 
     of bytes to an ASCII 'nA' or 'An' format column.
     Previously, CFITSIO would return an error when 
     trying to write to an 'A' column with ffpclb.

  Bug Fixes:

   - ffgkls was allocating one too few bytes when reading continued
     string keyword values. 

   - in testprog.c added code to properly free the memory that
     had been allocated for string arrays.

   - corrected typographical errors in the User's Guide.

Version 1.30 - 11 September 1997

   - major overhaul to support reading and writing FITS files
     in memory.   The new routines fits_set_mem_buff and 
     fits_write_mem_buff have been added to initialize and
     copy out the memory buffer, respectively.

   - added support for reading FITS files piped in on 'stdin'
     and piped out on 'stdout'.  Just specify the file name as '-'
     when opening or creating the FITS file.

   - added support for 64-bit SGI IRIX machines.  This required
     adding routines to pack and unpack 32-bit integers into
     64-bit integers.

   - cleaned up the code that supports G_FLOAT and IEEE_FLOAT
     on Alpha VMS systems.  Now, the type of float is determined
     at compile time, not run time.

  Bug Fixes:

   - replaced the malloc calls in the error message stack routines
     with a static fixed size array.  The malloc's cause more
     problems than they solved, and were prone to cause memory
     leaks if users don't clear the error message stack when
     closing the FITS file.

   - when writing float or double keywords, test that the value
     is not a special IEEE value such as a NaN.  Some
     compilers would write the string 'NaN' in this case into
     the output value string.

   - fixed bug in ffiblk, to ignore EOF status return if it is
     inserting blocks at the end of the file.

   - removed the 'l' from printf format string that is constructed
     in the ffcfmt routine.  This 'l' is non-standard and causes problems
     with the Metrowerks compiler on a Mac.

   - the default null value in images was mistakenly being set
     equal to NO_NULL = 314, rather than NULL_UNDEFINED = 1234554321
     in the ffgphd routine.

   - check status value in ffgkls to make sure the keyword exists
     before allocating memory for the value string.

   - fixed the support for writing and reading unsigned long integer
     keyword values in ffpky and ffgky by internally treating
     the values as doubles.  This required changes to ffc2r and
     ffc2d as well.

   - added explicit cast to 'double' in one place in putcolb.c and
     6 places in pubcolui.c, to get rid of warning messages issued
     by one compiler.

   - in ffbinit and ffainit, it is necessary to test that tfield > 0
     before trying to allocate memory with calloc.  Otherwise, some
     compilers return a null pointer which CFITSIO interprets to 
     mean the memory allocation failed.

   - had to explicitly cast the null buffer pointer to a char
     pointer (cptr = (char *)buffer;) in 4 places in the buffers.c
     file to satisfy a picky C++ compiler.

   - changed the test for an ALPHA VMS system to see if
     '__VMS' is defined, rather than 'VMS'.  The latter
     is not defined by at least one C++ compiler.

   - modified ffpcls so that it can write a null string to
     a variable length string column, without going into
     an infinite loop.

   - fixed bug in ffgcfl that caused the 'next' variable to be
     incremented twice.

   - fixed bug in ffgcpr that caused it write 2x the number of
     complex elements into the descriptor when writing to
     a complex or double complex variable length array column.

   - added call to ffrdef at the end of ffrsim to ensure that
     the internal structures are updated to correspond to the
     modified header keywords

Version 1.25 - 7 July 1997

   - improved the efficiency of the ffiblk routine, when inserting
     more than one block into the file.

   - fixed bug in ffwend that in rare instances caused the beginning
     of the following extension to be overwritten by blank fill.

   - added new routine to modify the size of an existing primary
     array or image extension: fits_resize_img/ffrsim.

   - added support for null-valued keywords, e.g., keywords that
     have no defined value.  These keywords have an equal sign and
     space in columns 9-10, but have not value string.  Example:
     KEYNAME =                      / null-valued keyword
     Support for this feature required the following changes:
       - modified ffpsvc to return a null value string without error
       - modified ffc2[ilrd] to return error VALUE_UNDEFINED in this case
       - modified ffgkn[sljed] to continue reading additional keywords
         even if one or more keywords have undefined values.
       - added 4 new routines:  ffpkyu, ffikyu, ffmkyu, ffukyu to
         write, insert, modify, or update an undefined keyword

   - a new makefile.os2 file was added, for building CFITSIO
     on OS/2 systems.

   - modified ffgtkn so that if it finds an unexpected keyword
     name, the returned error status = BAD_ORDER instead of
     NOT_POS_INT.

   - added 2 new routines, fits_write_key_unit/ffpunt and
     fits_read_key_unit/ffgunt to write/read the physical
     units of a keyword value.  These routines use a local
     FITS convention for storing the units in square brackets
     following the '/' comment field separator, as in:
     VELOCITY=                   12 / [km/s] orbit speed 
     The testprog.c program was modified to test these
     new routines.

   - in the test of Alpha OSF/1 machines in fitsio2.h,
     change 'defined(unix)' to 'defined(__unix__)' which
     appears to be a more robust test.

   - remove test for linux environment variable from fitsio2.h

Version 1.24 - 2 May 1997

   - fixed bug in ffpbyt that incorrectly computed the current
     location in the FITS file when writing > 10000 bytes.

   - changed the datatype of the 'nbytes' parameter in ffpbyt 
     from 'int' to 'long'.   Made corresponding datatype change
     to some internal variables in ffshft.

   - changed '(unsigned short *)' to '(short *)' in getcolui.c, and
     changed '(unsigned long *)'  to '(long *)'  in getcoluj.c, to
     work around problem with the VAX/VMS cc compiler.

Version 1.23 - 24 April 1997

   - modified ffcins and ffdins (in editcol.c) to simply return 
     without error if there are no (zero) rows in the table.

Version 1.22 - 18 April 1997

   - fixed bug in ffgcpr that caused it to think that all values were
     undefined in ASCII tables columns that have TNULLn = '        '
     (i.e., the TNULLn keyword value is a string of blanks.

   - fixed bug in the ffgcl[bdeijk,ui,uj] family of routines
     when parsing a numeric value in an ASCII table.  The
     returned values would have the decimal place shifted to
     the left if the table field contained an explicit decimal
     point followed by blanks.  Example:  in an F5.2 column,
     the value '16.  ' would be returned as 0.16.  If the
     trailing zeros were present, then cfitsio returned the
     correct value (e.g.,  '16.00' returns 16.).

   - fixed another bug in the ffgcl[bdeijk,ui,uj] family of routines
     that caused them to misread values in an ASCII table in rows
     following an undefined value when all the values were read
     at once in a single call to the routine.

Version 1.21 - 26 March 1997

   - added general support for reading and writing unsigned integer
     keywords, images, and binary table column values.

   - fixed bug in the way the column number was used in ffgsve and
     similar routines.  This bug caused cfitsio to read (colnum - 1)
     rather than the desired column.

   - fixed a bug in ftgkls that prevented it from reading more than one
     continuation line of a long string keyword value.

   - fixed the definition of fits_write_longwarn in longnam.h

Version 1.20 - 29 Jan 1997

   - when creating a binary table with variable length vector columns, if the
     calling routine does not specify a value for the maximum length of
     the vector (e.g.,  TFORMn = '1PE(400)')  then cfitsio will automatically
     calculate the maximum value and append it to the TFORM value
     when the binary table is first closed.

   - added the set of routines to do coordinate system transformations

   - added support for wildcards ('*', '?', and '#') in the input
     keyword name when reading, modifying, or deleting keywords.

   - added new general keyword reading routine, ffgnxk, to return
     the next keyword whose name matches a list of template names,
     but does not match any names on a second template list.

   - modified ftgrec so that it simply moves to the beginning
     of the header if the input keyword number = 0

   - added check in ffdelt to make sure the input fits file pointer is
     not already null

   - added check in ffcopy to make sure the output HDU does not
     already contain any keywords (it must be empty).

   - modified ffgcls so that it does not test if each string column
     value equals the null string value if the null string value
     is longer than the width of the column.

   - fixed bug in ftgtdm that caused it to fail if the TDIMn 
     keyword did not exist in the FITS file

   - modified testprog.c to include tests of keyword wildcards
     and the WCS coordinate transformation routines.

   - added a test for 'EMX' in fitsio2.h so that cfitsio builds 
     correctly on a PC running OS/2.

Version 1.11 - 04 Dec 1996

   - modified the testprog.c program that is included with the
     distribution, so that the output FITS file is identical to
     that produced by the Fortran FITSIO test program.

   - changed all instances of the 'extname' variable to 'extnm'
     to avoid a conflict with the -Dextname switch in cfortran.h
     on HP machines.

   - in all the routines like ffi4fi1, which convert an array
     of values to integers just prior to writing them to the FITS
     file, the integer value is now rounded to the nearest integer
     rather than truncated. (ffi4fi1, ffi4fi2, ffi4fi4, etc)

   - changed ffgcfl (and hence ffgcl) so that the input value
     of the logical array element is not changed if the corresponding
     FITS value is undefined.

   - in ffgacl, the returned value of TBCOL was off by 1 (too small)

   - fixed the comment of EXTNAME keyword to read 'binary table'
     instead of 'ASCII table' in the header of binary tables.

Version 1.101 - 17 Nov 1996

   - Made major I/O efficiency improvements by adding internal buffers
     rather than directly reading or writing to disk.  Access to 
     columns in binary tables is now 50 - 150 times faster.  Access to
     FITS image is also slightly faster.

   - made significant speed improvements when reading numerical data
     in FITS ASCII tables by writing my own number parsing routines
     rather than using the sscanf C library routine.  This change
     requires that the -lm argument now be included when linking
     a program that calls cfitsio (under UNIX).

   - regrouped the source files into logically related sets of routines.
     The Makefile now runs much faster since every single routine is
     not split into a separate file.

   - now use the memcpy function, rather than a 'for' loop in several
     places for added efficiency

   - redesigned the low-level binary table read and write routines
     (ffpbytoff and ffgbytoff) for greater efficiency.

   - added a new error status: 103 = too many open FITS files.

   - added a 'extern "C"' statement around the function prototypes
     in fitsio.h, to support use of cfitsio by C++ compilers.

   - fixed routines for writing or reading fixed-length substrings
     within a binary table ASCII column, with TFORM values of
     of the form 'rAw' where 'r' is the total width of the ASCII
     column and 'w' is the width of a substring within the column.

   - no longer automatically rewrite the END card and following fill
     values if they are already correct.

   - all the 'get keyword value and comment' routines have been changed 
     so that the comment is not returned if the input pointer is NULL.

   - added new routine to return the optimum number of tables rows
     that should be read or written at one time for optimum efficiency.

   - modified the way numerical values in ASCII tables are parsed so
     that embedded spaces in the value are ignored, and implicit
     decimal points are now supported.   (e.g, the string '123E 12'
     in a 'E10.2' format column will be interpreted as 1.23 * 10**12).

   - modified ffpcl and ffgcl to support binary table columns of
     all datatype (added logical, bit, complex, and double complex)

   - when writing numerical data to ASCII table columns, the ffpcl_
     routines now return an overflow error if a value is too large
     to be expressed in the column format.

   - closed small memory leak in ffpcls.

   - initialized the 'incre' variable in ffgcpr to eliminate compiler warning.

Version 1.04 - 17 Sept 1996

   - added README.MacOS and cfitsio_mac.sit.hqx to the distribution
     to support the Mac platforms.

   - fixed bug in ffpdfl that caused an EOF error (107) when a program
     creates a new extension that is an exact multiple of 2880 bytes long,
     AND the program does not write a value to the last element
     in the table or image.

   - fixed bug in all the ffgsf* and ffgcv* routines which caused
     core dumps when reading null values in a table.

Version 1.03 - 20 August 1996

   - added full support for reading and writing the C 'int'
     data type.  This was a problem on Alpha/OSF where short,
     int, and long datatypes are 2, 4, and 8 bytes long, respectively.

   - cleaned up the code in the byte-swapping routines.

   - renamed the file 'longname.h' to 'longnam.h' to avoid conflict
     with a file with the same name in another unrelated package.

Version 1.02 - 15 August 1996

   - ffgtbp was not correctly reading the THEAP keyword, hence would
     not correctly read variable length data in binary tables if
     the heap was not at the default starting location (i.e., 
     starting immediately after the fixed length table).

   - now force the cbuff variable in ffpcl_ and ffgcl_ to be
     aligned on a double word boundary.  Non-alignment can
     cause program to crash on some systems.

Version 1.01 - 12 August 1996

   - initial public release
