Документ взят из кэша поисковой машины. Адрес оригинального документа : http://www.astro.louisville.edu/software/sbig/archive/xmccd-4.1/xmccd-4.1e/libcfitsio/libcfitsio-3.310/changes.txt Дата изменения: Wed Jul 18 22:03:12 2012 Дата индексирования: Thu Feb 27 22:51:50 2014 Кодировка: Поисковые слова: europa

Log of Changes Made to CFITSIO

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 secrity 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.

- Implimented 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 chracters).

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 histrogram image will have a floating
point datatype, not the default integer datatype as is the case when no
weigth 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 convension, 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 chracters)

- 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 writen 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 chracter.

- 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 casee 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 explicted 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 " statements in
several C source files, to make them compatible with Windows.


Version 3.02 - 18 Sept 2006

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

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

New Routines

- the following new routines were added to support reading and writing
non-standard extension types:
fits_write_exthdr - write required keywords for a conforming extension
fits_write_ext - write data to the extension
fits_read_ext - read data from the extension

- added new routines to compute the RMS noise in the background pixels
of an image: fits_rms_float and fits_rms_short (take an input
array of floats or shorts, respectively).

Fixes

- added the missing 64-bit integer case to set of "if (datatype)"
statements in the routine that returns information about a
particular column (ffgbclll).

- fixed a parsing error in ffexts in cases where an extension number
is followed by a semi-colon and then the column and row number of an
array in a binary table. Also removed an extraneous HISTORY keyword
that was being written when specifying an input image in a table cel.

- modified the routine that reads a table column returning a string
value (ffgcls) so that if the displayed numerical value is too
wide to fit in the specified length string, then it will return
a string of "*" characters instead of the number string.

- small change to fitsio.h to support a particular Fortran and C
compiler combination on a SGI Altix system

- added a test in the gunzip code to prevent seg. fault when trying
to uncompress a corrupted file (at least in some cases).

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

Version 3.01 - (in FTOOLS 6.1 release)

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

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

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

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

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

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

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

- added test in fitsio.h so that LONGLONG cannot be multiply defined

- modified longnam.h so that both "fits_write_nulrows" and
"fits_write_nullrows" get replace by the string "ffprwu". This
fixes a documentation error regarding the long name of this
routine.

Bug fixes

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

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

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

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

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

- enhanced the 'col' extended filename syntax to support keyword name
expressions like
[col error=sqrt(rate); #TUNIT# = 'counts/s'],
in which the trailing '#' will be replaced by the column number
of the most recently referenced column.

- fixed bug in the parse_data iterator work function that caused it
to fail to return a value of -1 in cases where only a selected
set of rows were to be processed. (affected Fv)

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

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

Version 3.005 - 20 December 2005 (beta)

- cfortran.h has been enhanced to support 64-bit integer parameters
when calling C routines from Fortran. This modification was kindly
provided by Martin Reinecke (MPE, Garching).

- Many new Fortran wrapper routines have been added to support reading
and writing 64-bit integer values in FITS files. These new routines
are documented in the updated version of the 'FITSIO User's Guide'
for Fortran programmers.

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

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

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

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

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

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

- cleaned up fitsio.h and fitsio2.h to make the definition of LONGLONG
and BYTESWAPPED and MACHINE more logical.

- removed HAVE_LONGLONG everywhere since it is no longer needed (the
compiler now must have an 8-byte integer datatype to build CFITSIO).

- added support for the 64-bit IBM AIX platform

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

New Routines

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

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

- added the fits_translate_keyword and fits_translate_keywords utility
routines for converting the names of keywords when moving columns and
images around.

- added fits_copy_cell2image and fits_copy_image2cell routines for
copying an image extension (or primary array) to or from a cell
in a binary table vector column.

Bug fixes

- fixed a memory leak in eval.y; was fixed by changing a call to malloc
to cmalloc instead.

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

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

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

Enhancements

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

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

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

- made a simple modification to region.c to support regions files
of type "linear", for compatibility with ds9 and fv.

- modified the internal ffgpr routine (and renamed it ffgprll) so
that it returns the TNULL value as a LONGLONG parameter instead
of 'long'.

- in fits_get_col_display_width, added support for TFORM = 'k'

- modified fitsio.h, fitsio2.h, and f77_wrap.h to add test for (_SX)
to identify NEC SX supercomputers.

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

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

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

Bug fixes

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

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

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

Version 3.002 - 15 April 2005 - first public beta release

- in drvrfile.c, if it fails to open the file for some reason, then
it should reset file_outfile to a null string, to avoid errors on
a subsequent call to open a file.

- updated fits_get_keyclass to recognize most of the WCS keywords
defined in the WCS Papers I and II.

Version 3.001 - 15 March 2005 - released with HEASOFT 6.0

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

Version 3.000 - 1 March 2005 (internal beta release)

Enhancements:

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

- added another lexical parser function (thanks to Craig Markwardt,
GSFC): angsep computes the angular separation between 2 positions
on the celestial sphere.

- modified the image subset extraction code (e.g., when specifying
an image subregion when opening the file, such as
'myimage.fits[21:40, 81:90]') so that in addition to
updating the values of the primary WCS keywords CRPIXk, CDELTi, and
CDj_i in the extracted/binned image, it also looks for and updates
any secondary WCS keywords (e.g., 'CRPIX1P').

- made cosmetic change to group.c, so that when a group table is
copied, any extra columns will be appended after the last existing
column, instead of being inserted before the last column.

- modified the routines that read tile compressed images to support
NULL as the input value for the 'anynul' parameter (meaning the
calling program does not want the value of 'anynul' returned to it).

- when constructing or parsing a year/month/day character string,
(e.g, when writing the DATE keyword) the routines now rigorously
verify that the input day value is valid for the given month
(including leap years).

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

- added the wcsutil_alternate.c source code file which contains
non-working stubs for the 2 Classic AIPS world coordinate
conversion routines that are distributed under the GNU General
Public License. Users who are unwilling or unable to distribute
their software under the General Public License may use this
alternate source file which has no GPL restrictions, instead
of wcsutil.c. This will have no effect on programs that use
CFITSIO as long as they do not call the fits_pix_to_world/ffwldp
or fits_world_to_pix/ffxypx routines.

Bug Fixes

- in ffdtdm (which parses the TDIMn keyword value), the check for
consistency between the length of the array defined by TDIMn and
the size of the TFORMn repeat value, is now not performed for variable
length array columns (which always have repeat = 1).

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

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

Version 2.510 - 2 December 2004

New Routines:

- added fits_open_diskfile and fits_create_diskfile routines that simply
open or create a FITS file with a specified name. CFITSIO does not
try to parse the name using the extended filename syntax.

- 2 new C functions, CFITS2Unit and CUnit2FITS, were added to convert
between the C fitsfile pointer value and the Fortran unit number.
These functions may be useful in mixed language C and Fortran programs.

Enhancements:

- added the ability to recognize and open a compressed FITS file
(compressed with gzip or unix compress) on the stdin standard input
stream.

- Craig Markwardt (GSFC) provided 2 more lexical parser functions:
accum(x) and seqdiff(x) that compute the cumulative sum and the
sequential difference of the values of x.

- modified putcole.c and putcold.c so that when writing arrays of
pixels to the FITS image or column that contain null values, and
there are also numerical overflows when converting some of the
non-null values to the FITS values, CFITSIO will now ignore the
overflow error until after all the data have been written. Previously,
in some circumstances CFITSIO would have simply stopped writing any
data after the first overflow error.

- modified fitsio2.h to try to eliminate compiler warning messages
on some platforms about the use of 'long long' constants when
defining the value of LONGLONG_MAX (whether to use L or LL
suffix).

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

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

Bug Fixes:

- added check to fits_create_template to force it to start with
the primary array in the template file, in case an extension
number was specified as part of the template FITS file name.

Version 2.500 - 28 & 30 July 2004

New Routine:

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

Enhancements:

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

- Craig Markwardt, at GSFC, provided a number of significant enhancements
to the CFITSIO lexical parser that is used to evaluate expressions:

- the parser now can operate on bit columns ('X') in a similar
way as for other numeric columns (e.g., 'B' or 'I' columns)

- range checking has been implemented, so that the following
conditions return a Null value, rather than returning an error:
divide by zero, sqrt(negative), arccos(>1), arcsin(>1),
log(negative), log10(negative)

- new vector functions: MEDIAN, AVERAGE, STDDEV, and
NVALID (returns the number of non-null values in the vector)

- all the new functions (and SUM, MIN and MAX) ignore null values

- modified the iterator to support variable-length array columns

- modified configure to support AIX systems that have flock in a non-
standard location.

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

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

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

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

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

Bug fixes:

- made small change to ffsrow in eval_f.c to avoid potential array
bounds overflow.

- made small change to group.c to fix problem where an 'int' was
incorrectly being cast to a 'long'.

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

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

Version 2.490 - 11 February 2004

Bug fixes:

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

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

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

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

Version 2.480 - 28 January 2004

New Routines:

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

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

Enhancements:

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

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

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

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

Bug fixes:

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

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

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

New Routines:

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

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

Enhancements:

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

Bug fixes:

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

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

Version 2.470 - 18 August 2003

Enhancements:

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

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

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

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

Bug fixes:

- In the special case of writing 0 elements to a vector table column
that contains 0 rows, ffgcpr no longer adds a blank row to the table.

- added error checking code for cases where a ASCII string column
in a binary table is greater than 28800 characters wide, to avoid
going into an infinite loop.

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

Version 2.460 - 20 May 2003

Enhancements:

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

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

Version 2.450 - 30 April 2003

Enhancements:

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

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

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

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

Bug fixes:

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

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

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

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

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

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

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

Version 2.440 - 8 January 2003

Enhancements:

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

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

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

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

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

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

Bug fixes:

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

Version 2.430 - 4 November 2002

Enhancements:

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

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

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

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

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

Bug fixes:

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

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

- fits_open_image was not skipping over null primary arrays.

Version 2.420 - 19 July 2002

Enhancements:

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

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

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

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

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

Bug fixes:

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

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

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

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

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

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

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

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

New Routines:

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

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

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

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

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

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

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

Enhancements:

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Bug fixes:

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

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

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

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

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

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

Version 2.401 - 28 Jan 2002

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

Bug fixes:

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

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

Version 2.400 - 18 Jan 2002

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

New Routines:

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

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

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

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

Enhancements:

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

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

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

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

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

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

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

Bug fixes:

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

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

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

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

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

Version 2.301 - 7 Dec 2001

Enhancements:

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

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

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

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

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

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

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

Bug fixes:

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

Version 2.300 - 23 Oct 2001

New Routines:

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

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

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

Enhancements:

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

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

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

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

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

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

- modified fits_copy_hdu so that when copying a Primary Array
to an Image extension, the COMMENT cards which give the reference
to the A&A journal article about FITS are not copied. In the
inverse case the COMMENT keywords are inserted in the header.

- modified configure and Makefile.in to add capability to build a
shared version of the CFITSIO library. Type 'make shared' or
'make libcfitsio.so' to invoke this option.

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

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

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

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

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

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

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

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

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

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

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

Bug fixes:

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

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

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

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

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

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

Version 2.204 - 26 July 2001

Bug fixes:

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

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

Enhancements:

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

Bug fixes:

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


Version 2.202 - 22 May 2001

Enhancements:

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

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

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

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

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

Bug fixes:

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

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

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

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

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

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

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

Version 2.201 - 15 March 2001

Enhancements

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

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

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

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

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

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

Bug fixes:

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

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

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

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

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

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

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

Version 2.200 - 26 Jan 2001

Enhancements

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

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

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

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

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

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

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

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

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

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

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

Version 2.100 - 18 Oct 2000

Enhancements

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

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

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

New Routines

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

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

Bug fixes:

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

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

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

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

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

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

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

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

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

Version 2.037 - 6 July 2000

Enhancements

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Bug fixes:

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

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

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

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

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

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

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

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

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

Version 2.036 - 1 Feb 2000

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Version 2.034 - 23 Nov 1999

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Version 2.033 - 17 Sept 1999

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Version 2.032 - 25 May 1999

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

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

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

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

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

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

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

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

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

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

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

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

Version 2.031 - 31 Mar 1999

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

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

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

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

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

Version 2.030 - 24 Feb 1999

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Version 2.029 - 11 Feb 1999

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

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

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

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

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

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

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

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

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

Version 2.028 - 27 Jan 1999

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

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

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

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

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

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

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

Version 2.027 - 12 Jan 1999

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

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

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

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

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

Version 2.026 - 23 Dec 1998

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

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

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

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

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

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

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

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

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

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

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

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

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

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

- modified drvrnet.c to eliminate compiler warnings

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

Version 2.025 - 1 Dec 1998

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

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

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

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

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

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

- modified the HTTP driver to send a User-Agent string:
HEASARC/CFITSIO/

- 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