                   Log of Changes Made to CFITSIO
                   
Version 4.4.0 - Feb 2024

  - Reorganization of helper utility code; added fitsverify

  - CMakeLists.txt: Changed install location of cfitsio-targets.cmake
    to conform with the one listed in cfitsio-config.cmake.in (i.e.
    including the extra "cfitsio" subdir of lib/cmake).

  - calculator functions that read GTIs do more correct validity
    checking of GTI input files
  
  - fits_insert_rows now works if input table starts with both no rows
    and no columns

  - Can now write internal memory files of size > 2^32 directly to a
    gzip-compressed output file.
    
  - Added support for unsigned long long types to fits_update_key.
  
  - Added ability for Windows builds to handle UTF-8 needed for reading
    filenames with non-ASCII characters.
    
  - Added 2-byte int test to speed.c utility.
  
  - Made fix to http file handler to expand the allowed URL length.
  
Version 4.3.1 - Nov 2023 (patch release)

  - Patch fix needed for modify and delete keyword functions to fully
    conform with v4.3.0 long string keyword read/write enhancements. 
                   
Version 4.3.0 - Jul 2023

  - Bug fix to fits_make_hist[d] that was introduced in 4.2.0.
  
  - Added overflow checking for case of reading images with 8-byte
    float values into 4-byte float arrays.
    
  - fits_write_key_longstr now handles case of writing a long keyword
    in combination with a long keyword value string.
    
  - Add conversion of French locale comma-to-period in corner cases
    appearing in ffr2e and ffd2e functions.
    
  - Increased the precision when writing version number to User-Agent
    strings for http connections.  This is needed to fully conform to
    3-field version string format.

  - Bug fix to GTIOVERLAP() calculator function, which was being
    treated as a boolean value in expressions, and is now correctly
    treated as a floating point result.

  - Bug fix to ARRAY() calculator function, which caused a memory
    overflow error

  - Enhancement to the ARRAY function, such that ARRAY(V,d) can
    apply new dimensions to V, as long as the total number
    of array/vector elements does not change.
    
  - Enhancement of long string keyword read/write functions to fully
    conform with FITS standard specifications for multi-line value
    and comment strings.  Two new functions have been added to 
    implement this: fits_get_key_com_strlen and fits_read_string_key_com.

Version 4.2.0 - Nov 2022
  
  - This release includes patches to security vulnerabilities.  We
    strongly encourage this upgrade, particularly for those running 
    CFITSIO in web accessible applications.
    
  - Fix to fits_read_key function, which was failing to properly read
    keywords declared type TUINT on compilers where sizeof(int) =
    sizeof(long).

  - Added new functions fits_read_cols and fits_write_cols to efficiently 
    read or write multiple columns in a single function call

  - Added new function fits_copy_selrows to copy only selected rows, such
    as the selected rows returned by fits_find_rows

  - Added new calculator functions ERF(X), ERFC(X) and GAMMA(X), which are
    mathematical special functions of the same name

  - Added new calculator function GTIFIND() which reports which GTI row
    brackets a given time sample

  - Added new calculator functions which operate upon vector table
    values NAXIS(V), NAXES(V,n), ELEMENTNUM(V) and AXISELEM(V,n),
    and ARRAY(X,d) which promotes scalar X to a vector or array
    with given dimensions.

  - The CFITSIO histogramming code now handles binning by any
    arbitrary calculator expression rather than just a column name.
    Both the binned columns as well as the optional weights may be
    calculator expressions, enclosed in parentheses.  

  - Binning of vector columns or expressions is now supported, as long
    as all binned inputs (as well as the optional weighting) have the
    same vector dimensions.  Binning of variable-length columns remains
    unsupported.

  - A bug that caused histogram weights from columns that are null values
    to be tallied along with non-null values has been fixed.

  - The CFITSIO calculator and histogramming functionality is now
    fully reentrant and does not require multithreading interlocks.

  - A long-standing segmentation fault bug in the histogramming code
    related to binning any value using the "reciprocal" /XXXX notation
    has been fixed.
    
  - Added mutex locks for thread safety in ftgiou and ftfiou.
  
  - Added several Fortran wrappers to support image read/write when
    'fpixel' and 'nelements' are 8-byte integers.
    
  - Fixed bug which was adding spaces to some cases of long string key
    value output.

Version 4.1.0 - Feb 2022
                   
  - Calls to the zlib inflate() function in zcompress.c now handle
    the Z_BUF_ERROR return value rather than exiting.

  - The SUBTRACTIVE_DITHER_2 option has been removed when using the
    HCOMPRESS algorithm.  
    
  - Updated fits_get_version function to return a float calculated
    from 3 version fields.
                       
  - Added handling of SBYTE_IMG and ULONGLONG_IMG types to the
    fits_resize_img function.
    
  - Updates made to C/Fortran interfacing in cfortran.h and f77_wrap.h
    specifically driven by new Mac/ARM architecture.
    
  - Fix to the fits_insert_col functions to handle columns with
    TULONGLONG data.
                   
Version 4.0.0 - May 2021                   

  - Removed separate directory for zlib/gzip code, and updated
    configuration to check for zlib on the user's system (required).
    When use of cURL is enabled, it may also pull in zlib such
    that user applications may not need to link with it separately.

  - Changed version numbering to 3-field format.
      
  - Added new calculator functions SETNULL(x,y) to allow substitution of
    NULL values into tables, and GTIOVERLAP() for calculating the amount
    of GTI overlap exposure for a time bin.
    
  - Fix added for proper handling of string columns with zero repeat
    count.
    
  - Fix to column filtering expressions which write #NULL values to
    columns of type (J) format.
    
  - Fix to memory clearing when using polygon shapes in region files.
     
  - Fix to fits_str2time function so that it now flags a particular case
    of bad syntax which was previously getting through.
    
  - In ffgclb and ffpclb (read/write byte columns), the "undocumented"
    feature of being able to transfer columns 'A' string columnss as
    byte arrays is now handled correctly, with improved error checking
    via updates to ffgcprll.  More documentation on string handling is
    in cfitsio.tex.

  - Fix bug in 'colfilter' functionality.  When performing a
    column deletion of the form -COLNAM*, and multiple matches
    existed, then none of the matches got deleted.  Now the
    first is deleted as expected.
    
  - Improved handling of corner case in ffpkn functions.

  - In ffgky, modified TULONG case to allow it to read unsigned
    values greater than the 8-byte signed limit.
    
  - Fix to parsing of corner case of extended file syntax.

  - Major updates to CMake configuration.
		   
Version 3.49 - Aug 2020

  - Fix to imcompress.c.  It now turns off quantization if ZSCALE
    and ZZERO columns are missing.  Treatment will be the same as
    if ZQUANTIZ were set to 'NONE', even if ZQUANTIZ is present
    and set to something else.

  - Added mutex to fits_execute_template() function so that the
    creation of files using ASCII templates will be thread safe.
    		   
  - In fpack when using -table flag, replaced warning message with a
    more detailed description mentioning FITS format update.
		   
  - Added flag to CMake builds to disable curl dependency.  Also
    only add CURL_LIBRARIES to CMake link target if curl is found.
		   
  - Minor adjustment to download progress output.
                   
Version 3.48 - Mar 2020

  - Now can handle parentheses in path names rather than automatically
    interpreting them as output file specifiers.  

  - Fixed bug in imcompress.c that wasn't properly handling conversion
    between float and double types when reading from a gzip compressed
    float or double image.
    
  - Fixed bug that was preventing use of bracket and parentheses symbols
    in pathnames when opening multiple READWRITE files, even when 
    requesting no-extended-syntax usage. *This fix necessitates a 
    library interface version number change.
    
  - Fixed bug in ffmnhd / fits_movnam_hdu to properly handle wildcard
    syntax.

  - Fixed bug in fits_open_extlist to handle filename[EXT] syntax
    properly.  The hdutype parameter may now be null.  More documentaion
    for this function is in cfitsio.tex.

  - Added new function fits_copy_hdutab to create a new table with the same
    structure as an existing table.

  - fits_copy_col / ffcpcl handles long long integer data types more
    natively to prevent precision loss.

  - histo.c routines now recognize integer columns that have been scaled by
    TSCALn keywords and may be closer to floating point type.
                   
  - Added backward compatibility for very old Rice compressed files which
    were not using the ZVAL2 keyword in the way that later became standard.

  - Change made to cfitsio.pc.in to prevent forcing downstream libraries
    to link against cfitsio's dependencies when using pkgconfig.

Version 3.47 - May 2019

  - Added set of drivers for performing ftps file transfers.

  - Tile sizes for compression may now be specified for any pair of
    axes, where previously 2D tiles where limited to just X and y.
    
  - Fix to ffgsky and ffgkls functions for case of keyword with long
    string values where the final CONTINUE statement ended with '&'.
    If the final CONTINUE also contained a comment, it was being 
    repeated twice when passed back through the 'comm' argument.
      
  - Fix made to ffedit_columns() for case of multiple col filters
    containing wildcards.  Only the first filter was being searched.
                     
  - fits_copy_rows (ffcprw) can now handle 'P'-type variable-length 
    columns.
    
  - Fix made to an obscure case in fits_modify_vector_len, where a 
    wrongly issued EOF error may occur.
                   
  - Added internal fffvcl() function.
                   
Version 3.46 - Oct 2018 (Ftools release)
                   
  - Improved the algorithm for ensuring no tile dimensions are smaller 
    than 4 pixels for HCOMPRESS compression.
                   
  - Added new functions intended to assist in diagnosing (primarily 
    https) download issues: fits_show_download_progress,
    fits_get_timeout, fits_set_timeout.

  - Added the '-O <file>' option to fpack, which previously existed only
    for funpack.  Also added fpack/funpack auto-removal of .bz2 suffix 
    equivalent to what existed for .gz.

  - For the fpack '-table' cases, warning message is now sent to stderr 
    instead of stdout.  This is to allow users to pipe the results from
    stdout in valid FITS format.  (The warning message is otherwise placed
    at the start of the FITS file and therefore corrupts it.)

  - Fix made to the '-P' file prefix option in funpack.

  - Added wildcard deletion syntax for columns, i.e. -COLNAM* will delete
    the first matching column as always; -COLNAM*+ will delete all matching
    columns (or none); exact symmetry with the keyword deletion syntax.

Version 3.45 - May 2018
                   
  - New support for reading and writing unsigned long long datatypes.
    This includes 'implicit datatype conversion' between the unsigned long
    long datatype and all the other datatypes.
    
  - Increased the hardcoded NMAXFILES setting for maximum number of
    open files from 1000 to 10000.
                   
  - Bug fix to fits_calc_binning wrapper function, which wasn't filling
    in the returned float variables.
    
  - Fixed a parsing bug for image subsection and column binning range
    specifiers that was introduced in v3.44.

Version 3.44 - April 2018

  - This release primarily patches security vulnerabilities.  We
    strongly encourage this upgrade, particularly for those running 
    CFITSIO in web accessible applications.
    
    In addition, the following enhancements and fixes were made: 

  - Enhancement to 'template' and 'colfilter' functionality.  It is now
    possible to delete multiple keywords using wildcard syntax. See
    "Column and Keyword Filtering Specification" section of manual for
    details.
  
  - histo.c uses double precision internally for all floating point
    binning; new double-precision subroutines fits_calc_binningd(),
    fits_rebin_wcsd(), and fits_make_histd(); existing
    single-precision histogram functions still work but convert values
    to double-precision internally.

  - new subroutine fits_copy_cols() / ffccls() to copy multiple columns
  
  - Fix in imcompress.c for HCOMPRESS and PLIO compression of unsigned
    short integers.
  
  - Fix to fits_insert_card(ffikey).  It had wrongly been capitalizing
    letters that appeared before an '=' sign on a CONTINUE line.
                   
Version 3.43 - March 2018
                   
The NASA security team requires the following warning to all users of 
CFITSIO:

   =====
   The CFITSIO open source software project contains vulnerabilities 
   that could allow a remote, unauthenticated attacker to take control
   of a server running the CFITSIO software.  These vulnerabilities 
   affect all servers and products running the CFITSIO software.

   The CFITSIO team has released software updates to address these 
   vulnerabilities.  There are no workarounds to address these 
   vulnerabilities.  In all cases, the CFITSIO team is recommending an 
   immediate update to resolve the issues.
   =====

  - Fixed security vulnerabilities.   
 
  - Calls to https driver functions in cfileio.c need to be macro-
     protected by the HAVE_NET_SERVICES variable (as are the http and
     ftp driver function calls).  Otherwise CMake builds on native
     Windows will fail since drvrnet.o is left empty.
                   
   - Bug fix to ffmvec function.  Should be resetting a local colptr
     variable after making a call to ffiblk (which can reallocate Ftpr->
     tableptr).  Originally reported by Willem van Straten.
     
   - Ignore any attempted request to not quantize an image before
     compressing it if the image has integer datatype pixels.
     
   - Improved error message construction throughout CFITSIO.
                   
Version 3.42 - August 2017 (Stand-alone release)
                   
   - added https support to the collection of drivers handled in cfileio.c
     and drvrnet.c.  This also handles the case where http transfers are 
     rerouted to https.  Note that this enhancement introduces a dependency
     on the libcurl development package.  If this package is absent, CFITSIO
     will still build but will not have https capability.
                   
   - made fix to imcomp_init_table function in imcompress.c.  It now writes
     ZSIMPLE keyword only to a compressed image that will be placed in the
     primary header.
     
   - fix made to fits_get_col_display_width for case of a vector column
     of strings. 

Version 3.42 - March 2017 (Ftools release only)

   - in ftp_open_network and in ftp_file_exist, added code to repeatedly
     attempt to make a ftp connection if the ftp server does not respond
     to the first request. (some ftp servers don't appear to be 100% reliable).

   - in drvrnet.c added many calls to 'fclose' to close unneeded files,
     to avoid exceeding the maximum allowed number of files that can be 
     open at once.
     
   - made substantial changes to the ftp_checkfile and http_checkfile routines
     to streamline the process of checking for the existence of a .gz or .Z
     compressed version of the file before opening the uncompressed file
     (when using http or ftp to open the file). 

   - modified the code in ftp_open_network to send "\r\n" as end-of-line
     characters instead of just "\n".  Some ftp servers (in particular,
     at heasarc.gsfc.nasa.gov) now require both characters, otherwise the
     network connection simply hangs.
     
   - modified the http_open_network routine to handle HTTP 301 or 302 redirects
     to a FTP url.  This is needed to support the new configuration on
     the heasarc HTTP server which sometimes redirects http URLS to a ftp URL.

Version 3.41 - November 2016

   - The change made in version 3.40 to include strings.h caused problems on
     Windows (and other) platforms, so this change was backed out. The reason
     for including it was to define the strcasecmp and strcasencmp functions, so
     as an alternative, new equivalent functions called fits_strcasecmp and
     fits_strncasecmp have been added to CFITSIO.as a substitute. All the
     previous calls to the str[n]casecmp functions have been changed to
     now call fits_str[n]casecmp. In addition, the previously defined 
     ngp_strcasecmp function (in grparser.c) has been removed and the calls to
     it have been changed to fits_strcasecmp.
     
   - The speed.c utility program was changed to correctly call 
     the gettimeofday function with a NULL second arguement. 

Version 3.40 - October 2016

   - fixed a bug when writing long string keywords with the CONTINUE convention
     which caused the CONTINUE'd strings to only be 16 characters long, instead
     of using up all the available space in the 80-character header record.

   - fixed a missing 'defined' keyword in fitsio.h.

   - replaced all calls to strtok (which is not threadsafe) with a new ffstrtok
     function which internally calls the threadsafe strtok_r function.  One 
     byproduct of this change is that <strings.h> must also be included
     in several of the C source code files.

   - modified the ffphbn function in putkey.c to support TFORM specifiers that
     use lowercase 'p' (instead of uppercase) when referring to a variable-length
     array column.

   - modified the lexical parser in eval.y and eval_y.c to support bit array 
     columns (with TFORMn = 'X') with greater than 256 elements. Fix to bitcmp 
     function:  The internal 'stream' array is now
     allocated dynamically rather than statically fixed at size 256.
     This was failing when users attempted a row filtering of a bitcol
     that was wider than 256X. In bitlgte, bitand, and bitor functions, replaced 
     static stream[256] array allocation with dynamic allocation.  

   - modified the ffiter function in putcol.c to fix a problem which could
     cause the iterator function to incorrectly deal with null values.  This
     only affected TLONG type columns in cases where sizeof(long) = 8, as well
     as for TLONGLONG type columns.

   - Fix made to uncompress2mem function in zcomprss.c for case where output
     uncompressed file expands to over the 2^32 (4Gb) limit.  It now
     checks for this case at the start, and implements a 4Gb paging
     system through the output buffer.  The problem was specifically
     caused by the d_stream.avail_out member being of 4-byte type uInt,
     and thus unable to handle any memory position values above 4Gb. 

   - fixed a bug in fpackutil.c when using the -i2f (integer to float) option
     in fpack to compress an integer image that is scaled with non-default values
     for BSCALE and BZERO. This required an additional call to ffrhdu to reset
     the internal structures that describe the input FITS file.

   - modified fits_uncompress_table in imcompress.c to silently ignore the
     ZTILELEN keyword value if it larger than the number of rows in the table
     
   - Tweak strcasecmp/strncasecmp ifdefs to exclude 64-bit MINGW
     environment, as it does not lack those functions. (eval_l.c,
     fitsio2.h)

   - CMakeLists.txt: Set M_LIB to "" for MINGW build environment (in
     addition to MSVC).

   - Makefile.in: Add *.dSYM (non-XCode gcc leftovers on Macs) to
     clean list.  Install libs by name rather than using a wildcard.

   - configure: Fix rpath token usage for XCode vs. non-XCode gcc on Macs.


Version 3.39 - April 2016

   - added 2 new routines suggested by Eric Mandel:
      ffhisto3 is similar to ffhisto2, except that it does not close the
         original file.
      fits_open_extlist is similar to fits_open_data except that it opens
         the FITS file and then moves to the first extension in the user-input
	 list of 'interesting' extensions.

   - in ffpsvc and ffprec, it is necessary to treat CONTINUE, COMMENT, HISTORY,
     and blank name keywords as a special case which must be treated differently
     from other keywords because they have no value field and, by definition,
     have keyword names that are strictly limited in length.
     
   - added the Fortran wrapper routines for the 2 new string keyword reading
     routines (FTGSKY and FTGKSL), and documented all the routines in the
     FITSIO and CFITSIO users guides.

   - in ffinttyp, added explicit initialization of the input 'negative' 
     argument to 0.

   - added new routine to return the length of the keyword value string:
         fits_get_key_strlen / ffgksl.  
     This is primarily intended for use with string keywords
     that use the CONTINUE convention to continue the
     value over multiple header records, but this routine can be used
     to get the length of the value string for any type keyword.

   - added new routine to read string-valued keywords:
          fits_read_string_key / ffgsky
     This routine supports normal string keywords as well as long string
     keywords that use the CONTINUE convention. In many cases this routine
     may be more convenient to use then the older fits_read_key_longstr
     routine.

   - changed the prototype of fits_register_driver in fitsio2.h so that the
     pointer definition argument does not have the same name as the pointer
     itself (to work around a bug in the pgcc compiler).
     
   - added the missing FTDTDM fortran wrapper definition to f77_wrap3.c.
   
   - modified Makefile.in and configure.in to add LDFLAGS_BIN for task linker
     flages, which will be the same as LDFLAGS except on newer Mac OS X where
     an rpath flag is added.

   - modified Makefile.in to add a new "make utils" command which will build
     fpack, funpack, cookbook, fitscopy, imcopy, smem, speed, and testprog.
     These programs will be installed into $prfix/bin.

   - fixed a bug when attempting to modify the values in a variable-length
     bit ("X") column in a binary table.

   - reinstated the ability to write HIERARCH keywords that contain characters
     that would not be allowed in a normal 8-character keyword name, which had
     been disabled in the previous release.

Version 3.38 - February 2016

   - CRITICAL BUG FIX:
     The Intel 15 and 16 compilers (and potentially other compilers) may silently
     produce incorrect assembly code when compiling CFITSIO with the -O2 (or
     higher) optimization flag. In particular, this problem could cause  CFITSIO
     to incorrectly read the values of arrays of 32-bit integers in a  FITS file
     (i.e., images with BITPIX = 32 or table columns with TFORM = 'J')  when the
     array is being read into a 'long' integer array in cases where the long
     array elements are 8 bytes long. 

     One way to test if a particular system is affected by this problem is to
     compile CFITSIO V3.37 (or earlier) with optimization enabled, and then
     compare the output of the testprog.c program with the testprog.out file
     that is distributed with CFITSIO. If there are any  differences in the
     files, then this system might be affected by this bug. Further tests 
     should be performed to determine the exact cause.

     The root cause of this problem was traced to the fact that CFITSIO was
     aliasing an array of 32-bit integers and an array of 64-bit integers to the
     same memory location in order to obtain better data I/O efficiency when
     reading FITS files.  When CFITSIO modified the values in these arrays, it
     was essential that the processing be done in strict sequential order from
     one end of the array to the other end, as was implicit in the C code
     algorithm. In this case, however, the compiler adopted certain  loop
     optimization techniques that produced assembly code that violated  this
     assumption.  Technically, the CFITSIO code violates the "strict aliasing"
     assumption in ANSI C99, therefore the affected CFITSIO routines have been
     modified so that the aliasing of different data types to the same memory
     location no longer occurs.

   - fixed problem in configure and configure.in which caused the programs that
     are distributed with CFITSIO (most notably, fack and funpack) to be build
     without using any compiler optimization options, which could make them
     run more slowly than expected.

   - in imcompress.c, fixed bug where the rowspertile variable (declared as 'long')
     was mistakenly declared as a TLONGLONG variable in a call to fits_write_key.
     This could have caused the ZTILELEN keyword to be written incorrectly in
     the header of tile-compressed FITS tables on systems where sizeof(long) = 4.

   - in imcompress.c, implemented a new set of routines that safely convert
     shorter integer arrays into a longer integer arrays (e.g. short to int)
     where both arrays are aliased to the same memory location.  These
     special routines were needed to guard against certain compiler optimization
     techniques that could produce incorrect code.
 
   - modified the 4 FnNoise5_(type) routines in quantize.c to correctly 
     count the number of non-null pixels in the input array.  Previously the
     count could be inaccurate if the image mainly consisted of null pixels.
     This could have caused certain floating point image tiles to be 
     quantized during the image compression process, when in fact the tile
     did not satisfy all the criteria to be safely quantized.
     
   - in imcomp_copy_comp2img, added THEAP to the list of binary table 
     keywords that may be present in the header of a compressed image 
     and should not be copied to the uncompressed image header.
 
   - modified fits_copy_col to check that when copying a vector column, the
     vector length in the output column is the same as in the input column.
     Also modified the code to support the case where a column is being copied
     to an earlier position in the same table (which shifts the input column
     over 1 space).

   - added configure option (--with-bzip2) to support reading bzip2 compressed 
     FITS files.  This also required modifications to drvrmem.c and drvrfile.c
     This depends on having the bzlib library installed on the 
     local machine.  This patch was submitted by Dustin Lang.
     
   - replaced calls to 'memcpy' by 'memmove' in getcolb.c, getcold.c,
     getcole.c, and getcoli.c to support cases where the 2 memory areas 
     overlap. (submitted by Aurelien Jarno)

   - modified the FITS keyword reading and writing routines to potentially
     support keywords with names longer than 8-characters.  This was implemented
     in anticipation of a new experimental FITS convention which allows longer 
     keyword names.

   - in fits_quantize_double in quantize.c, test if iseed == N_RANDOM,
     to avoid the (unlikely) possibility of overflowing the random number
     array bounds. (The corresponding fits_quantize_float routine already
     performed this test).

   - in the FnNoise5_short routine in quantize.c, change the first 'if' 
     statement from "if (nx < 5)" to "if )nx < 9)", in order to support the
     (very rare) case where the tile is from 5 to 8 pixels wide.  Also make 
     the same change in the 3 other similar FnNoise5_* routines.

   - in the qtree_bitins64 routine in fits_hdecompress.c, must declare the
     plane_val variable as 'LONGLONG' instead of int.  This bug could have 
     caused integer overflow errors when uncompressing integer*4 images that
     had been compressed with the Hcompress algorithm, but only in cases
     where the image contains large regions of pixels whose values are close
     to the maximum integer*4 value of 2**31. 

   - in fits_hcompress.c, call the calloc function instead of malloc when
     allocating the signbits array, to eliminate the need to individually
     set each byte to zero.

   - in the ffinit routine, and in a couple other routines that call ffinit,
     initialize the *fptr input parameter to NULL, even if the input
     status parameter value is greater than zero.  This helps prevent
     errors later on if that fptr value is passed to ffclos.

   - modified ftcopy, in edithdu.c, to only abort if status > 0 rather
     than if status != 0. This had caused a problem in funpack in rare
     circumstances.

   - in imcompress.c changed all the calls to ffgdes to ffgdesll, to support
     compressed files greater than 2.1 GB in size.

   - fixed bug in ffeqtyll when it is called with 4th and 5th arguments 
     set to NULL.

   - in fitsio.h, added the standard C++ guard around the declaration of the
     function fits_read_wcstab.  (reported by Tammo Jan Dijkema, Astron.)

   - in fitsio.h, changed the prototype variable name "zero" to "zeroval" to
     avoid conflict in code that uses a literal definition of 'zero' to mean 0.

   - tweaked Makefile.in and configure.in to use LDFLAGS instead of CFLAGS 
     for linking, use Macros for library name, and let fpack and funpack 
     link with shared library.

   - modified an 'ifdef' statement in cfileio.c to test for '__GLIBC__'
     instead of 'linux' when initializing support for multi-threading.

   - modified ffeqtyll to return an effective column data type of TDOUBLE
     in the case of a 'K' (64-bit integer) column that has non-integer
     TSCALn or TZEROn keywords.
     
   - modified ffgcls (which returns the value in a column as a formatted string)
     so that when reading a 'K' (TLONGLONG) column it returns a long long integer
     value if the column is not scaled, but returns a double floating point
     value if the column has non-integer TSCALn or TZEROn values.

   - modified fitsio.h to correctly define "OFF_T long long" when using
     the Borland compiler

   - converted the 'end of line' characters in simplerng.c file to the unix
     style, instead of PC DOS.

   - updated CMakeLists.txt CMake build file which is primarily used to
     build CFITSIO on Windows machines.

   - modified fits_get_keyclass to recognize ZQUANTIZ and ZDITHER0 as
     TYP_CMPRS_KEY type keywords, i.e., keywords used in tile compressed
     image files.

   - added test to see if HAVE_UNISTD_H is defined, as a condition for 
     including unistd.h in drvrfile.c drvrnet.c, drvrsmem.c, and group.c.

   - modified the CMakelist.txt file to fix several issues (primarily for
     building CFITSIO on Windows machines)..

   - fixed bug when reading tile-compressed images that were compressed with
     the IRAF PLIO algorithm.  This bug did not affect fpack or funpack, but
     other software that reads the compressed image could be affected.  The 
     bug would cause the data values to be offset by 32768 from the actual 
     pixel values.

Version 3.37 - 3 June 2014

   - replaced the random Gaussian and Poissonian distribution functions with
     new code written by Craig Markwardt derived from public domain C++ functions 
     written by John D Cook.

   - patched fitsio2.h to support CFITSIO on AArch64 (64-bit ARM)
     architecture (both big and little endian).  Supplied by
     Marcin Juszkiewicz and Sergio Pascual Ramirez, with further update
     by Michel Normand.
     
   - fixed bug in fpackutil.c that caused fpack to exit prematurely if
     the FZALGOR directive keyword was present in the HDU header.

Version 3.36 - 6 December 2013

   - added 9 Dec: small change to the fileseek function in drvrfile.c to
     support large files > 2 GB when building CFITSIO with MinGW on Windows

   - reorganized the CFITSIO code directory structure; added a 'docs'
     subdirectory for all the documentation, and a 'zlib' directory
     for the zlib/gzip file compression code.

   - made major changes to the compression code for FITS binary table
     to support all types of columns, including variable-length arrays.
     This code is mainly used via the fpack and funpack programs.

   - increased the number of FITS files that can be opened as one
     time to 1000, as defined by NMAXFILES in fitsio2.h.

   - made small configuration changes to configure.in, configure,
     fitsio.h, and drvrfile.c to support large files (64-bit file 
     offsets} when using the mingw-w64 compiler (provided by 
     Benjamin Gilbert).

   - made small change to fits_delete_file to more completely ignore
     any non-zero input status value.

   - fixed a logic error in a 'if' test when parsing a keyword name
     in the ngp_keyword_is_write function in grparser.c (provided
     by David Binderman).

   - when specifying the image compression parameters as part of the
     compressed image file name (using the "[compress]" qualifier
     after the name of the file), the quantization level value, if
     specified, was not being recognized by the CFITSIO compression
     routines. The image would always be compressed with the default
     quantization level of 4.0, regardless of what was specified.  This
     affected the imcopy program, and potentially other user-generated
     application programs that used this method to specify the
     compression parameters.  This bug did not affect fpack or
     funpack.   This was fixed in the imcomp_get_compressed_image_par
     routine in the imcompress.c file. (reported by Sean Peters)

   - defined a new CFITS_API macro in fitsio.h which is used to export the
     public symbols when building CFITSIO on Windows systems with CMake. This
     works in conjunction with the new Windows CMake build procedure that
     is described in the README.win32 file. This complete revamping of the
     way CFITSIO is built under Windows now supports building 64-bit
     versions of the library.  Thanks to Daniel Kaneider (Luminance HDR
     Team) for providing these new  CMake build procedures.

   - modified the way that the low-level file_create routine works when
     running in the Hera environment to ensure that the FITS file that is 
     created is within the allow user data disk area.

   - modified fits_get_compression_type so that it does not return an error
     if the HDU is a normal FITS IMAGE extension, and is not a tile-compressed
     image.

   - modified the low-level ffgcl* and ffpcl* routines to ensure that they
     never try ro read or write more than 2**31 bytes from disk at one time,
     as might happen with very large images, to avoid integer overflow errors.
     Fix kindly provided by Fred Gutsche at NanoFocus AG (www.nanofocus.de).
     
   - modified Makefile.in so that doing 'make distclean' does not delete
     new config.sub and config.guess files that were recently added.

   - adopted a patch from Debian in zcompress.c to "define" the values of
     GZBUFSIZE and BUFFINCR, instead of exporting the symbols as 'int's.

Version 3.35 - 26 June 2013  (1st beta release was on 24 May)
		   
   - fixed problem with the default tile size when compressing images with
     fpack using the Hcompress algorithm.

   - fixed returned value ("status" instead of "*status") 

   - in imcompress.c, declared some arrays that are used to store the dimensions
     of the image from 'int' to 'long', to support very large images (at least
     on systems where sizeof(long) = 8),

   - modified the routines that convert a string value to a float or double
     to prevent them from returning a NaN or Inf value if the
     string is "NaN" or "Inf" (as can happen with gcc implementation of the
     strtod function).

   - removed/replaced the use of the assert() functions when locking or
     unlocking threads because they did not work correctly if NDEBUG is
     defined.

   - made modifications to the way the command-line file filters are parsed to
     1) remove the 1024-character limit when specifying a column filter,
     2) fixed a potential character buffer-overflow risk in fits_get_token, and
     3) improved the parsing logic to remove any possible of confusing
     2 slash characters ("//") in the string as the beginning of a 
     comment string.

   - modified configure and Makefile.in so that when building CFITSIO
     as a shared library on linux or Mac platforms, it will use the SONAME
     convention to indicate whether each new release of the CFITSIO
     library is binary-compatible with the previous version.  Application
     programs that link with the shared library will not need to be
     recompiled as long as the versions are compatible.  In practice,
     this means that the shared library binary file that is created (on
     Linux systems) will have a name like 'libcfitsio.so.I.J.K', where I is the
     SONAME version number, J is the major CFITSIO version number (e.g. 3),
     and K is the minor CFITSIO version number (e.g., 34).  Two link
     files will also be created such that
       libcfitsio.so -> libcfitsio.so.I, and
       libcfitsio.so.I -> libcfitsio.I.J.K
     Application programs will still run correctly with the new version of
     CFITSIO as long as the 'I' version number remains the same, but the
     applications will fail to run if the 'I' number changes, thus alerting
     the user that the application must be rebuilt.

   - fixed bug in fits_insert_col when computing the new table row width
     when inserting a '1Q' variable length array column.

  - modified the image compression routines so that the output compressed
     image (stored in a FITS binary table) uses the '1Q' variable length
     array format (instead of '1P') when the input file is larger than 4 GB.

   - added support for "compression directive" keywords which indicate how
     that HDU should be compressed (e.g., which compression algorithm to use,
     what tiling pattern to use, etc.).  The values of these keywords will
     override the compression parameters that were specified on the command 
     line when running the fpack FITS file compression program.

   - globally changed the variable and/or subroutine name "dither_offset" 
     to "dither_seed" and "quantize_dither" to "quantize_method" so
     that the names more accurately reflects their purpose.

   - added support for a new SUBTRACTIVE_DITHER_2 method when compressing
     floating point images.  The only difference with the previous method
     is that pixels with a value exactly equal to 0.0 will not be dithered,
     and instead will be exactly preserved when the image is compressed.

   - added support for an alias of "RICE_ONE" for "RICE_1" as the value
     of the ZCMPTYPE keyword, which gives the name of the image compression
     algorithm.  This alias is used if the new SUBTRACTIVE_DITHER_2 option
     is used, to prevent old versions of funpack from creating a corrupted
     uncompressed image file.  Only newer versions of funpack will recognize
     this alias and be able to uncompress the image. 
   
   - made performance improvement to fits_read_compressed_img so that 
     when reading a section of an compressed image that includes only 
     every nth pixel in some dimension, it will only uncompressed a tile 
     if there are actually any pixels of interest in that tile.

   - fixed several issues with the beta FITS binary table compression code
     that is used by fpack:  added support for zero-length vector columns,
     made improvements to the output report when using the -T option in fpack,
     changed the default table compression method to 'Rice' instead of 
     'Best', and now writes the 'ZTILELEN' keyword to document the number
     of table rows in each tile.

   - fixed error in ffbinit in calculating the total length of the binary
     table extension if the THEAP keyword was used to override the
     default starting location of the heap.

Version 3.34 - 20 March 2013

   - modified configure and configure.in to support cross-compiled cfitsio 
     as a static library for Windows on a Linux platform using MXE 
     (http://mxe.cc) - a build environment for mingw32. (contributed by 
     Niels Kristian Bech Jensen)

   - added conditional compilation statementsfor the mingw32 environment in 
     drvrfile.c because mingw32 does not include the ftello and fseeko functions. 
     (contributed by Niels Kristian Bech Jensen)

   - fixed a potential bug in ffcpcl (routine to copy a column from one table
     to another table) when dealing with the rare case of a '0X' column (zero
     length bit column).

   - fixed an issue in the routines that update or modify string-valued
     keyword values, as a result of the change to ffc2s in the previous 
     release.  These routines would exit with a 204 error status if the 
     current value of the keyword to be updated or modified is null.

   - fixed typo in the previous modification that was intended to ignore
     numerical overflows in Hcompress when decompressing an image.

   - moved the 'startcol' static variable out of the ffgcnn routine and
     instead added it as a member of the 'FITSfile' structure that is defined
     in fitsio.h.  This removes a possible race condition in ffgcnn in 
     multi-threaded environments.

Version 3.33 - 14 Feb 2013

   - modified the imcomp_decompress_tile routine to ignore any numerical 
     overflows that might occur when using Hcompress to decompress the
     image.  If Hcompress is used in its 'lossy' mode, the uncompressed
     image pixel values may slightly exceed the range of an integer*2 
     variable. This is generally of no consequence, so we can safely ignore
     any overflows in this case and just clip the values to the legal range.

   - the default tiling pattern when writing a tile-compressed image
     has been changed.  The old behavior was to compress the whole image
     as one single large tile.  This is often not optimal when dealing
     with large images, so the new default behavior is to treat each
     row of the image as one tile.  This is the same default behavior
     as in the standalone fpack program.  The default tile size can
     be overridden by calling fits_set_tile_dim.

   - fixed bug that resulted in a corrupted output FITS image when
     attempting to write a float or double array of values to a 
     tile-compressed integer data type image.  CFITSIO does not support
     implicit data type conversion in this case and now correctly
     returns an appropriate error status. 

   - modified ricecomp.c to define the nonzero_count lookup table as an 
     external variable, rather then dynamically allocating it within the
     3 routines that use it.  This simplifies the code and eliminates the
     need for special thread locking and unlocking statements. (Thanks to
     Lars Kr. Lundin for this suggestion). 

   - modified how the uncompressed size of a gzipped file is computed in the
     mem_compress_open routine in drvrmem.c.  Since gzip only uses 4 bytes
     in the compressed file header to store the original file size, one may
     need to apply a modulo 2^32 byte correction in some cases.  The logic
     here was modified to allow for corner cases (e.g., very small files, and 
     when running on 32-bit platforms that do not support files larger than
     2^31 bytes in size). 

   - added new public routine to construct a 80 keyword record from the 3 input
     component strings, i.e, the keyword name string, the value string, and
     the comment string: fits_make_key/ffmkky.  (This was already an undocumented
     internal routine in previous versions of CFITSIO).

   - modified ffc2s so that if the input keyword value string is a null string,
     then it will return a VALUE_UNDEFINED (204) status value.  This makes it
     consistent with the behavior when attempting to read a null keyword 
     (which has no value) as a logical or as a number (which also returns
     the 204 error).  This should only affect cases where the header keyword
     does not have an equal sign followed by a space character in columns 9
     and 10 of the header record.

   - Changed the "char *" parameter declarations to "const char *" in many 
     of the routines (mainly the routines that modify or update keywords) to
     avoid compiler warnings or errors from C++ programs that tend to be more
     rigorous about using "const char *" when appropriate.

   - added support for caching uncompressed image tiles, so that the tile does
     not need to be uncompressed again if the application program wants 
     to read more data from the same tile. This required changes to the
     main FITS file structure that is defined in fitsio.h, as well as
     changes to imcompress.c.

   - enhanced the previous modification to drvrfile.c to handle additional user
     cases when running in the HEASARC's Hera environment.

Version 3.32 - Oct 2012

   - fixed flaw in the way logical columns (TFORM = 'L') in binary tables 
     were read which caused an illegal value of 1 in the column to be interpreted
     as a 'T' (TRUE) value.

   - extended the column filtering syntax in the CFITSIO file name parser to
     enable users and scripts to append new COMMENT or HISTORY keyword into the
     header of the filtered file (provided by Craig Markwardt).  For example,
     fcopy "infile.fits[col #HISTORY='Processed on 2012-10-05']" outfile.fits
     will append this header keyword: "HISTORY Processed on 2012-10-05"

   - small change to the code that opens and reads an ASCII region file to
     return an error if the file is empty.

   - fixed obscure sign propagation error when attempting to read the
     uncompressed size of a gzipped FITS file.  This resulted in a memory
     allocation error if the gzipped file had an uncompressed file
     size between 2^31 and 2^32 bytes.  Fix supplied by Gudlaugur Johannesson 
     (Stanford).

Version 3.31 - 18 July 2012

   - enhanced the CFITSIO column filtering syntax to allow the comma, in addition
     to the semi-colon, to be used to separate clauses, for example:
     [col X,Y;Z = max(X,Y)].  This was done because users are not allowed to
     enter the semi-colon character in the on-line Hera data processing
     system due to computer security concerns.

   - enhanced the CFITSIO extended filename syntax to allow specifying image
     compression parameters (e.g. '[compress Rice]') when opening an existing
     FITS file with write access.  The specified compression parameters will
     be used by default if more images are appended to the existing file.

   - modified drvrfile.c to do additional file security checks when CFITSIO
     is running within the HEASARC's Hera software system.  In this case
     CFITSIO will not allow FITS files to be created outside of the user's
     individual Hera data directory area.

   - fixed an issue in fpack and funpack on Windows machines, caused by
     the fact that the 'rename' function behaves differently on Windows
     in that it does not clobber an existing file, as it does on Unix
     platforms.

   - fixed bug in the way byte-swapping was being performed when writing 
     integer*8 null values to an image or binary table column.  

   - added the missing macro definition for fffree to fitsio.h.

   - modified the low level table read and write functions in getcol*.c and 
     putcol*.c to remove the 32-bit limitation on the number of elements. 
     These routines now support reading and writing more than 2**31 elements
     at one time. Thanks to Keh-Cheng Chu (Stanford U.) for the patch.

   - modified Makefile.in so that the shared libcfitsio.so is linked against 
     pthreads and libm.

Version 3.30 - 11 April 2012

  Enhancements

   - Added new routine called fits_is_reentrant which returns 1 or 0 depending on
     whether or not CFITSIO was compiled with the -D_REENTRANT directive.  This can
     be used to determine if it is safe to use CFITSIO in multi-threaded programs.

   - Implemented much faster byte-swapping algorithms in swapproc.c based on code
     provided by Julian Taylor at ESO, Garching.  These routines significantly 
     improve the FITS image read and write speed (by more than a factor of 2 in 
     some cases) on little-endian machines (e.g., Linux and Microsoft Windows and
     Macs running on x86 CPUs) where byte-swapping is required when reading and 
     writing data in FITS files.  This has no effect on big-endian machines 
     (e.g. Motorola CPUs and some IBM systems).  Even faster byte-swapping
     performance can be achieved in some cases by invoking the new "--enable-sse2" 
     or "--enable-ssse3" configure options when building CFITSIO on machines that
     have CPUs and compilers that support the SSE2 and SSSE3 machine instructions.

   - added additional support for implicit data type conversion in cases where
     the floating point image has been losslessly compressed with gzip.  The
     pixels in these compressed images can now be read back as arrays of short, 
     int, and long integers as well as single and double precision floating-point.

   - modified fitsio2.h and f77_wrap.h to recognize IBM System z mainframes by
     testing if __s390x__ or __s390__ is defined.

   - small change to ffgcrd in getkey.c so that it supports reading a blank
     keyword (e.g., a keyword whose name simply contains 8 space characters).

   Bug Fixes

   - fixed a bug in imcomp_decompress_tile that caused the tile-compressed image 
     to be uncompressed incorrectly (even though the tile-compressed image itself
     was written correctly) under the following specific conditions:
      - the original FITS image has a "float" datatype (R*4) 
      - one or more of the image tiles cannot be compressed using the standard
        quantization method  and instead are losslessly compressed with gzip
      - the pixels in these tiles are not all equal to zero (this bug does
        affect tiles where all the pixels are equal to zero)
      - the program that is reading the compressed image uses CFITSIO's
        "implicit datatype conversion" feature to read the "float" image
        back into an array of "double" pixel values.
      If all these conditions are met, then the returned pixel values in the
      affected image tiles will be garbage, with values often ranging 
      up to 10**34.  Note that this bug does not affect the fpack/funpack
      programs, because funpack does not use CFITSIO's implicit datatype
      conversion feature when uncompressing the image.

Version 3.29 - 2 December 2011

  Enhancements

   - modified Makefile.in to allow configure to override the lib and include
     destination directories.
		   
   - added (or restored actually) support for tile compression of 1-byte integer 
     images in imcomp_compress_tile.  Support for that data type was overlooked
     during recent updates to this routine.

   - modified the fits_get_token command-line parsing routine to perform more
     rigorous checks to determine if the token can be interpreted as a number 
     or not.

   - made small modification to fpack.c to not allow the -i2f option (convert
     image from integer to floating point) with the "-g -q 0" option (do lossless 
     gzip compression).  It is more efficient to simply use the -g option alone.

   - made modifications to fitsio.h and drvrfile.c to support reading and
     writing large FITS files (> 2.1 GB) when building CFITSIO using 
     Microsoft Visual C++ on Windows platforms.

   - added new WCS routine (ffgicsa) which returns the WCS keyword values
     for a particular WCS version ('A' - 'Z').

   Bug Fixes

   - fixed a problem with multi-threaded apps that open/close FITS files
     simultaneously by putting mutex locks around the call to
     fits_already_open and in fits_clear_Fptr.

   - fixed a bug when using the 'regfilter' function to select a subset of the
     rows in a FITS table that have coordinates that lie within a specified
     spatial region on the sky.  This bug only affects the rarely used panda
     (and epanda and bpanda) region shapes in which the region is defined by
     the intersection of an annulus  and a pie-shaped wedge.  The previous code
     (starting with version 3.181 of CFITSIO where support for the panda region
     was first introduced) only worked correctly if the 2 angles that define
     the wedge have values between -180 and +180.  If not, then fewer rows than
     expected may have been selected from the table.

   - fixed the extended filename parser so that when creating a histogram by
     binning 2 table columns, if a keyword or column name is given as the
     weighting factor,  then the output histogram image will have a floating
     point datatype, not the default integer datatype as is the case when no
     weight is specified (e.g. with a filename like 
     "myfile.fits[bin x,y; weight_column]"

   - added fix to the code in imcompress.c to work around a problem with
     dereferencing the value of a pointer, in cases where the address of 
     that pointer has not been defined (e.g., the nulval variable).

    - modified the byte shuffling algorithm in fits_shuffle_8bytes to work
     around a strange bug in the proprietary SunStudioExpress C compiler
     under OpenSolaris.

   - removed spurious messages on the CFITSIO error stack when opening a
     FITS file with FTP (in drvrnet.c);

Version 3.28 - 12 May 2011

   - added an enhancement to the tiled-image compression method when compressing
     floating-point image using the standard (lossy) quantization method.  In 
     cases where an image tile cannot be quantized,  The floating-point pixel values
     will be losslessly compressed with gzip before writing them to the tile-
     compressed file.  Previously, the uncompressed pixel values would have
     been written to the file, which obviously requires more disk space. 

   - made significant internal changes to the structure of the tile compression
     and uncompression routines in imcompress.c to make them more modular and
     easier to maintain.

   - modified configure.in and configure to force it to build a Universal 
     binary on Mac OS X.

   - modified the ffiter function in putcol.c to properly clean up allocated
     memory if an error occurs.
     
   - in quantize.c, when searching for the min and max values in a float array,
     initialize the max value to -FLT_MAX instead of FLT_MIN (and similarly
     for double array). 

Version 3.27 - 3 March 2011

  Enhancements

    - added new routines fits_read_str and fits_delete_str which read or
      delete, respectively, a header keyword record that contains a specified 
      character string.

    - added a new routine called fits_free_memory which frees the memory
      that fits_read_key_longstr allocated for the long string keyword value.

    - enhanced the ffmkky routine in fitscore.c to not put a space before the
      equals sign when writing long string-valued keywords using the ESO
      HIERARCH keyword convention, if that extra character is needed to
      fit the length of the keyword name + value string within the 80-character
      FITS keyword record.

    - made small change to fits_translate_keyword to support translation of
      blank keywords (where the name = 8 blank characters)

    - modified fpack so that it uses the minimum of the 2nd, 3rd, and 5th order
      MAD noise values when quantizing and compressing a floating point image.
      This is more conservative than just using the 3rd order MAD value alone.

    - added new routine imcomp_copy_prime2img to imcompress.c that is used by
      funpack to copy any keywords that may have been added to the primary
      array of the compressed image file (a null image) back into the header of 
      the uncompressed image.

    - enhanced the fits_quantize_float and fits_quantize_double routines in
      quantize.c to also compress the tile if it is completely filled with
      null values.  Previously, this type of tile would have been written 
      to the output compressed image without any compression.

    - enhanced imcomp_decompress_tile to support implicit datatype conversion
      when reading a losslessly compressed (with gzip) real*4 image into an
      array of real*8 values.  

    - in imcompress.c, removed possible attempt to free memory that had not 
      been allocated.


Version 3.26 - 30 December 2010

  Enhancements

   - defined 2 new macros in fitsio.h:  
       #define CFITSIO_MAJOR 3
       #define CFITSIO_MINOR 26
     These may be used within other macros to detect the CFITSIO
     version number at compile time.
     
   - modified group.c to initialize the output URL to a null string in 
     fits_url2relurl.  Also added more robust tests to see if 2 file
     pointers point to the same file.

   - enhanced the template keyword parsing code in grparser.c to support
     the 'D' exponent character in the ASCII representation of floating
     point keyword values (as in TVAL = 1.23D03).  Previously, the parser
     would have written this keyword with a string value (TVAL = '1.23D03').

   - modified the low-level routines that write a keyword record to a FITS 
     header so that they silently replace any illegal characters (ASCII 
     values less than 32 or greater than 126) with an ASCII space character.
     Previously, these routines would have returned with an error when
     encountering these illegal characters in the keyword record (most commonly 
     tab, carriage return, and line feed characters).

   - made substantial internal changes to imcompress.c in preparation for
     possible future support for compression methods for FITS tables analogous
     to the tiled image compression method.

   - replaced all the source code in CFITSIO that was distributed under the
     GNU General Public License with freely available code.  In particular,
     the  gzip file compression and uncompression code was replaced by the
     zlib compression library.  Thus, beginning with this version 3.26 of CFITSIO,
     other software applications may freely use CFITSIO without necessarily
     incurring any GNU licensing requirement.  See the License.txt file for
     the CFITSIO licensing requirements.

   - added support for using cfitsio in different 'locales' which use a
     comma, not a period, as the decimal point character in ASCII 
     representation of a floating point number (e.g., France).  This
     affects how floating point keyword values and floating point numbers
     in ASCII tables are read and written with the 'printf' and 'strtod'
     functions.

   - added a new utility routine called fits_copy_rows/ffcprw that copies
     a specified range of rows from one table to another.

   - enhanced the test for illegal ASCII characters in a header (fftrec) to
     print out the name of the offending character (e.g TAB or Line Feed) as
     well as the Hex value of the character.
     
   - modified ffgtbc (in fitscore.c) to support nonstandard vector variable
     length array columns in binary tables (e.g. with TFORMn = 2000PE(500)').
     
   - modified the configure file to add "-lm" when linking CFITSIO on
     Solaris machines.
     
   - added new routine, fits_get_inttype, to parse an integer keyword value
     string and return the minimum integer datatype (TBYTE, TSHORT, TLONG, 
     TLONGLONG) required to store the integer value.

   - added new routine, fits_convert_hdr2str, which is similar to fits_hdr2str
     except that if the input HDU is a tile compressed image (stored 
     in a binary table) then it will first convert that header back to 
     that of a normal uncompressed FITS image before concatenating the header
     keyword records.

   - modified the file template reading routine (ngp_line_from_file in 
     grparser.c) so that it ignores any carriage return characters (\r)
     in the line, that might be present, e.g. if the file was created on a 
     Windows machine that uses \r\n as end of line characters.

   - modified the ffoptplt routine in cfileio.c to check if the PCOUNT
     keyword in the template file has a non-zero value, and if so, resets
     it to zero in the newly created file.

   Bug Fixes
   
   - fixed a bug when uncompressing floating-point images that contain Nan
     values on some 64-bit platforms.
     
   - fixed a bug when updating the value of the CRPIXn world coordinate 
     system keywords when extracting a subimage from larger FITS image, using the
     extended CFITSIO syntax (e.g.  myimage[1:500:2, 1:500:2]).  This bug only 
     affects cases where the pixel increment value is not equal to 1, and caused
     the coordinate grid to be shifted by between 0.25 pixels (in the case of
     a pixel increment of 2) and 0.5 pixels (for large pixel increment values).

   - fixed a potential string buffer overflow error in the ffmkls routine
     that modifies the value and comment strings in a keyword that uses
     the HEASARC long string keyword convention. 

   - fixed a bug in imcompress.c that could cause programs to abort on 64-bit 
     machines when using gzip to tile-compress images.  Changed the declaration
     of clen in imcomp_compress_tile from int to size_t.

Version 3.25 - 9 June 2010

   - fixed bug that was introduced in version 3.13 that broke the ability
     to reverse an image section along the y-axis with an image section
     specifier like this: myimage.fits[*,-*].  This bug caused the output
     image to be filled with zeros.

   - fixed typo in the definition of the ftgprh Fortran wrapper routine
     in f77_wrap3.c.

   - modified the cfitsio.pc.in configuration file to make the lib path
     a variable instead of hard coding the path.   The provides more
     flexibility for projects such as suse and fedora when building CFITSIO.

   - fixed bug in imcomp_compress_tile in imcompress.c which caused
     null pixel values to be written incorrectly in the rare case where 
     the floating-point tile of pixels could not be quantized into integers.

   - modified imcompress.c to add a new specialized routine to uncompress
     an input image and then write it to a output image on a tile by tile basis.
     This appears to be faster than the old method of uncompressing the
     whole image into memory before writing it out.  It also supports
     large images with more than 2**31 pixels.

   - made trivial changes to 2 statements in drvrfile.c to suppress 
     nuisance compiler warnings.

   - some compilers define CLOCKS_PER_SEC as a double instead of an integer,
     so added an explicit integer type conversion to 2 statements in
     imcompress.c that used this macro.
     
   - removed debugging printf statements in drvrnet.c (15 July)

Version 3.24 - 26 January 2010

   - modified fits_translate_keywords so that it silently ignores any
     illegal ASCII characters in the value or comment fields of the input
     FITS file. Otherwise, fpack would abort without compressing input
     files that contained this minor violation of the FITS rules.

   - added support for Super H cpu in fitsio2.h
   
   - updated funpack to correctly handle the -S option, and to use a
     more robust algorithm for creating temporary output files.
   
   - modified the imcomp_compress_tile routine to support the NOCOMPRESS
     debugging option for real*4 images.

Version 3.23 - 7 January 2010

   - reduced the default value for the floating point image quantization
     parameter (q) from 16 to 4.  This parameter is used when tile compressing
     floating point images.  This change will increase the average compression
     ratio for floating point images from about 4.6 to about 6.5 without losing 
     any significant information in the image.
     
   - enhanced the template keyword parsing routine to reject a header
     template string that only contains a sequence of dashes.

   - enhanced the ASCII region file reading routine to allow tabs as well
     as spaces between fields in the file.

   - got rid of bogus error message when calling fits_update_key_longstr

   - Made the error message more explicit when CFITSIO tries to write
     to a GZIP compressed file.  Instead of just stating "cannot write
     to a READONLY file", it will say "cannot write to a GZIP compressed
     file".

Version 3.22 - 28 October 2009

   - added an option (in imcompress.c) to losslessly compress floating
     point images, rather than using the default integer scaling method.
     This option is almost never useful in practice for astronomical 
     images (because the amount of compression is so poor), but it has 
     been added for test comparison purposes.

   - enhanced the dithering option when quantizing and compressing
     floating point images so that a random dithering starting point
     is used, so that the same dithering pattern does not get used for
     every image.

   - modified the architecture setup section of fitsio2.h to support the
     64-core 8x8-architecture Tile64 platform (thanks to Ken Mighell, NOAO)

   Fixes

   - fixed a problem that was introduced in version 3.13 of CFITSIO
     in cases where a program writes it own END keyword to the header
     instead of letting CFITSIO do it, as is strongly recommended.  In
     one case this caused CFITSIO to rewrite the END keyword and any
     blank fill keywords in the header many times, causing a 
     noticeable slow-down in the FITS file writing speed.

Version 3.21 - 24 September 2009

   - fixed bug in cfileio.c  that caused CFITSIO to crash with a bus error
     on Mac OS X if CFITSIO was compiled with multi-threaded support (with
     the  --enable-reentrant configure option). The Mac requires an
     additional thread initialization step that is not required on Linux
     machines.  Even with this fix, occasional bus errors have been seen on
     some Mac platforms, The bus errors are seen when running the
     thread_test.c program.  The bus errors are very intermittent, and occur
     less than about 1% of the time, on the affected platforms. 
     These bus errors have not been seen on Linux platforms. 

   - fixed invalid C comment delimiter ("//*" should have been "/*")
     in imcompress.c.

   - Increased the CFITSIO version number string length
     in fpackutil.c, to fix problem on some platforms when running
     fpack -V or funpack -V.   Also modified the output format of the
     fpack -L command.

Version 3.20 - 31 August 2009

   - modified configure.in and configure so that it will build the Fortran
     interface routines by default, even if no Fortran compiler is found
     in the user's path. Building the interface routines may be disabled 
     by specifying FC="none".  This was done at the request of users who
     obtained CFITSIO from some other standard linux distributions, where
     CFITSIO was apparently built in an environment that had no Fortran 
     compiler and hence did not build the Fortran wrappers.

   - modified ffchdu (close HDU) so that it calls the routine to update
     the maximum length of variable length table columns in the TFORM
     values in all cases  where the values may have changed.  Previously
     it would not update the values if a value was already specified in
     the TFORM value.

   - added 2 new string manipulation functions to the CFITSIO parser 
     (contributed by Craig Markwardt): strmid extracts a substring
     from a string, and strstr searches for a substring within a string.

   - removed the code in quantize.c that treated "floating-point integer" 
     images as a special case (it would just do a datatype conversion from
     float to int, and not otherwise quantize the pixel values).  This 
     caused complications with the new subtractive dithering feature.

   - enhanced the code for converting floating point images to quantized
     scaled integer prior to tile-compressing them, to apply a random
     subtractive dithering, which improves the photometric accuracy
     of the compressed images.
   
   - added new internal routine, iraf_delete_file, for use by fpack to
     delete a pair of IRAF format header and pixel files.

   - small change in cfileio.c in the way it recognizes an IRAF format
     .imh file.  Instead of just requiring that the filename contain the
     ".imh" string, that string must occur at the end of the file name.

   - fixed bug in the code that is used when tile-compressing real*4 FITS 
     images, which quantizes the floating point pixel values into
     integer levels.  The bug would only appear in the fairly rare
     circumstance of tile compressing a floating point image that contains
     null pixels (NaNs) and only when using the lossy Hcompress algorithm
     (with the s parameter not equal to 1).  This could cause underflow of
     low valued pixels, causing them to appear as very large pixel values
     (e.g., > 10**30)  in the compressed image

   - changed the "if defined" blocks in fitsio.h, fitsio2.h and f77_wrap.h
     to correctly set the length of long variables on sparc64 machines.
     Patch contributed by Matthew Truch (U. Penn).

   - modified the HTTP file access code in drvrnet.c to support basic
     HTTP authentication, where the user supplies a user name and
     password.  The CFITSIO filename format in this case is:
     "http://username:password@hostname/..."
     Thanks to Jochen Liske (ESO) for the suggestion and the code.

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 input 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
