fits.h

Go to the documentation of this file.

// # fits.h:
// # Copyright (C) 1993,1994,1995,1996,1997,1999,2000,2001,2003,2004
// # Associated Universities, Inc. Washington DC, USA.
// #
// # This library is free software; you can redistribute it and/or modify it
// # under the terms of the GNU Library General Public License as published by
// # the Free Software Foundation; either version 2 of the License, or (at your
// # option) any later version.
// #
// # This library is distributed in the hope that it will be useful, but WITHOUT
// # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
// # FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Library General Public
// # License for more details.
// #
// # You should have received a copy of the GNU Library General Public License
// # along with this library; if not, write to the Free Software Foundation,
// # Inc., 675 Massachusetts Ave, Cambridge, MA 02139, USA.
// #
// # Correspondence concerning AIPS++ should be addressed as follows:
// #        Internet email: casa-feedback@nrao.edu.
// #        Postal address: AIPS++ Project Office
// #                        National Radio Astronomy Observatory
// #                        520 Edgemont Road
// #                        Charlottesville, VA 22903-2475 USA
 
#if !defined(AIPS_FITS)
#define AIPS_FITS
 
// # Note that aips.h has to come first for the correct definition of off_t.
#include <casacore/casa/aips.h>
#include <cfloat>
#include <climits>
#include <cstdlib>
#include <cctype>
#include <casacore/casa/iostream.h>
#include <casacore/casa/BasicSL/Complex.h>
#include <casacore/casa/BasicSL/IComplex.h>
#include <casacore/fits/FITS/FITSError.h>
 
namespace casacore {  // # NAMESPACE CASACORE - BEGIN
 
// # All FITS code seems to assume longs are 4 bytes. Currently
// # this corresponds to an "int" on all useful platforms.
typedef Int FitsLong;
// # recovered by GYL
 
// # Forward declarations
class ReservedFitsKeywordCollection;
class FitsNameResult;
class FitsValueResult;
class FitsKeyword;
class FitsParse;
 
//<summary> FITS templated helper class </summary>
// <reviewed reviewer="UNKNOWN" date="before2004/08/25" tests="" demos="">
// </reviewed>
//<synopsis>
// NoConvert is a template class that is not intended for
// general use, it is used internally.
//</synopsis>
 
template <class TYPE>
class NoConvert {
 public:
  NoConvert() {}
  void operator=(int) { ; }
};
 
//<summary> FITS helper class </summary>
// <reviewed reviewer="UNKNOWN" date="before2004/08/25" tests="" demos="">
// </reviewed>
//<synopsis>
// FitsLogical is a helper class that is not intended for
// general use.
//</synopsis>
//<example>
// Here is an example of the FitsLogical class.
//<srcblock>
//  FitsLogical x;
//  FitsLogical y(True);
//  FitsLogical z = x;
//  ...
//  x = y; y = False; x.undefine();
//  Bool b;
//  if (x.isdefined())
//      b = x;
//  b = y;  If y is undefined, b will be false.
//</srcblock>
//</example>
class FitsLogical {
  friend ostream &operator<<(ostream &o, const FitsLogical &);
 
 public:
  FitsLogical() : v('\0') {}
  FitsLogical(Bool x) : v(x == True ? 'T' : 'F') {}
  FitsLogical &operator=(Bool x) {
    v = (x == True ? 'T' : 'F');
    return *this;
  }

  void undefine() { v = '\0'; }
  operator Bool() const { return v == 'T'; }
 
 protected:
  char v;
};
 
//<summary> helper class for FITS Binary Tables </summary>
// <reviewed reviewer="UNKNOWN" date="before2004/08/25" tests="" demos="">
// </reviewed>
//<synopsis>
// This class is not intended for general use.  It only has meaning
// in the context of FITS Binary tables.  There its use is incorporated
// into the concept of a FitsField, where FitsBit is given a specialized
// interpretation.
//</synopsis>
 
class FitsBit {
 public:
  FitsBit() : bit_array(0) {}
  FitsBit(unsigned char x) : bit_array(x) {}
  FitsBit &operator=(unsigned char x) {
    bit_array = x;
    return *this;
  }
  operator unsigned char() const { return bit_array; }
 
 protected:
  unsigned char bit_array;
};
 
//<summary>  Variable Length Array Descriptor </summary>
// <reviewed reviewer="UNKNOWN" date="before2004/08/25" tests="" demos="">
// </reviewed>
 
class FitsVADesc {
  friend ostream &operator<<(ostream &o, const FitsVADesc &);
 
 public:
  FitsVADesc() : no_elements(0), rel_offset(0) {}
  FitsVADesc(const FitsVADesc &x) : no_elements(x.no_elements), rel_offset(x.rel_offset) {}
  FitsVADesc &operator=(const FitsVADesc &x) {
    no_elements = x.no_elements;
    rel_offset = x.rel_offset;
    return *this;
  }
  FitsVADesc(int n, int o) : no_elements(n), rel_offset(o) {}
  void set(int n, int o) {
    no_elements = n;
    rel_offset = o;
  }
  int num() const { return no_elements; }
  int offset() const { return rel_offset; }
 
 protected:
  int no_elements;
  int rel_offset;
};
 
//<summary> static functions and enumerations </summary>
// <reviewed reviewer="UNKNOWN" date="before2004/08/25" tests="" demos="">
// </reviewed>
//<synopsis>
// Many of the static functions are utility functions used internally in the
// implementation of the member functions of the FITS classes. They are placed
// in a single class to encapsulate them and to avoid adding many names to the
// global name space. More important, from the user's perspective, are the
// enumerations. They form the basic vocabulary of a FITS application. For example,
// instead of referring to the FITS <src>NAXIS</src> keyword,
// <src>FITS::NAXIS</src> should be used
//</synopsis>
 
class FITS {
 public:
  // FITS I/O Error message types
 
  // Basic FITS Data Types for keywords and data
  enum ValueType {
    NOVALUE = 0,
    LOGICAL = 1,
    BIT = 2,
    CHAR = 3,
    BYTE = 4,
    SHORT = 5,
    LONG = 6,
    FLOAT = 7,
    DOUBLE = 8,
    COMPLEX = 9,
    ICOMPLEX = 10,
    DCOMPLEX = 11,
    VADESC = 12,
    STRING,
    FSTRING,
    REAL
  };  // REAL means either FLOAT or DOUBLE
      // STRING and FSTRING are used internally in parsing keywords
 
  static FITS::ValueType getfitstype(NoConvert<FitsLogical> x) {
    x = 0;
    return FITS::LOGICAL;
  }
  static FITS::ValueType getfitstype(NoConvert<FitsBit> x) {
    x = 0;
    return FITS::BIT;
  }
  static FITS::ValueType getfitstype(NoConvert<char> x) {
    x = 0;
    return FITS::CHAR;
  }
  static FITS::ValueType getfitstype(NoConvert<unsigned char> x) {
    x = 0;
    return FITS::BYTE;
  }
  static FITS::ValueType getfitstype(NoConvert<short> x) {
    x = 0;
    return FITS::SHORT;
  }
  static FITS::ValueType getfitstype(NoConvert<Int> x) {
    x = 0;
    return FITS::LONG;
  }
  static FITS::ValueType getfitstype(NoConvert<long> x) {
    x = 0;
    return FITS::LONG;
  }
  static FITS::ValueType getfitstype(NoConvert<float> x) {
    x = 0;
    return FITS::FLOAT;
  }
  static FITS::ValueType getfitstype(NoConvert<double> x) {
    x = 0;
    return FITS::DOUBLE;
  }
  static FITS::ValueType getfitstype(NoConvert<Complex> x) {
    x = 0;
    return FITS::COMPLEX;
  }
  static FITS::ValueType getfitstype(NoConvert<IComplex> x) {
    x = 0;
    return FITS::ICOMPLEX;
  }
  static FITS::ValueType getfitstype(NoConvert<DComplex> x) {
    x = 0;
    return FITS::DCOMPLEX;
  }
  static FITS::ValueType getfitstype(NoConvert<FitsVADesc> x) {
    x = 0;
    return FITS::VADESC;
  }
 
  static int fitssize(FITS::ValueType t);
  static int localsize(FITS::ValueType t);
 
  // data conversion routines: FITS - local
  static void f2l(FitsLogical *, void *, int);
  static void l2f(void *, FitsLogical *, int);
  static void f2l(FitsBit *, void *, int);
  static void l2f(void *, FitsBit *, int);
  static void f2l(char *, void *, int);
  static void l2f(void *, char *, int);
  static void f2l(unsigned char *, void *, int);
  static void l2f(void *, unsigned char *, int);
  static void f2l(short *, void *, int);
  static void l2f(void *, short *, int);
  static void f2l(Int *, void *, int);
  static void l2f(void *, Int *, int);
  static void f2l(long *, void *, int);
  static void l2f(void *, long *, int);
  static void f2l(float *, void *, int);
  static void l2f(void *, float *, int);
  static void f2l(double *, void *, int);
  static void l2f(void *, double *, int);
  static void f2l(Complex *, void *, int);
  static void l2f(void *, Complex *, int);
  static void f2l(IComplex *, void *, int);
  static void l2f(void *, IComplex *, int);
  static void f2l(DComplex *, void *, int);
  static void l2f(void *, DComplex *, int);
  static void f2l(FitsVADesc *, void *, int);
  static void l2f(void *, FitsVADesc *, int);
  static void swap2(void *, void *, int);
  static void swap4(void *, void *, int);
  static void swap8(void *, void *, int);
 
  // FITS Reserved Names. PZERO is named strangely because it can conflict with
  // a standard #define in sys/param.h.
  enum ReservedName {
    USER_DEF,
    AUTHOR,
    BITPIX,
    BLANK,
    BLOCKED,
    BSCALE,
    BUNIT,
    BZERO,
    CDELT,
    COMMENT,
    CROTA,
    CRPIX,
    CRVAL,
    CTYPE,
    DATAMAX,
    DATAMIN,
    DATE,
    DATE_OBS,
    END,
    EPOCH,
    EQUINOX,
    EXTEND,
    EXTLEVEL,
    EXTNAME,
    EXTVER,
    GCOUNT,
    GROUPS,
    HISTORY,
    INSTRUME,
    NAXIS,
    OBJECT,
    OBSERVER,
    ORIGIN,
    PCOUNT,
    PSCAL,
    PTYPE,
    PZERO_FITS,
    REFERENC,
    SIMPLE,
    SPACES,
    TBCOL,
    TDIM,
    TDISP,
    TELESCOP,
    TFIELDS,
    TFORM,
    THEAP,
    TNULL,
    TSCAL,
    TTYPE,
    TUNIT,
    TZERO,
    XTENSION,
    ERRWORD,
    ALTRPIX,
    DATE_MAP
  };
 
  // Types of FITS Records
  enum FitsRecType {
    InitialState,
    BadBeginningRecord,
    HDURecord,
    UnrecognizableRecord,
    SpecialRecord,
    EndOfFile
  };
 
  // Supported FITS Physical Devices
  enum FitsDevice { Disk, Std, Tape9 };
 
  // Types of FITS Header-Data Units
  enum HDUType {
    NotAHDU,
    PrimaryArrayHDU,
    PrimaryGroupHDU,
    AsciiTableHDU,
    BinaryTableHDU,
    ImageExtensionHDU,
    UnknownExtensionHDU,
    PrimaryTableHDU
  };
 
  // Options on FITS array manipulations
  enum FitsArrayOption { NoOpt = 0, CtoF = 1, FtoC = 2 };
 
  static ReservedFitsKeywordCollection &ResWord;
  static void valstr(ostream &o, const ValueType &ty, const void *val);
  static Bool isa_digit(char c);
  static int digit2bin(char c);
  static Bool isa_text(char c);
  static Bool isa_letter(char);
  static int letter2bin(char);
  static void fstr2str(char *, const char *, int);
  static int str2fstr(char *, const char *, int);
  static void get_name(const char *s, int len, FitsNameResult &result);
  static int get_value_id(const char *s, int l, int &pos);
  static void get_value(const char *s, int len, FitsValueResult &result);
  static int trim_comment(const char *s, int len);
  static int chk_comment(const char *s, int len);
  static int get_comment(const char *s, int len, int &begpos);
  static void get_numeric(const char *s, int len, FitsValueResult &result);
  // utility function to parse the binary table variable array
  // column (i.e. uses the heap) of the form nPt(dddd) where n
  // is either 0 or 1, t is one of the standard FITS binary table
  // column types and dddd is the maximum number of elements used
  // by this column.  If there is a format error in the input
  // string (*s), then valType will have the value NOVALUE and
  // maxelem will be -1.
  static void parse_vatform(const char *s, FITS::ValueType &valType, int &maxelem);
  static constexpr Int minInt = INT_MIN;
  static constexpr Int maxInt = INT_MAX;
  static constexpr float minfloat = FLT_MIN;
  static constexpr float maxfloat = FLT_MAX;
  static constexpr double mindouble = DBL_MIN;
  static constexpr double maxdouble = DBL_MAX;
 
 private:
  FITS();
  static constexpr double tenpowerD[309] = {
      1.0,     1.0E1,   1.0E2,   1.0E3,   1.0E4,   1.0E5,   1.0E6,   1.0E7,   1.0E8,   1.0E9,
      1.0E10,  1.0E11,  1.0E12,  1.0E13,  1.0E14,  1.0E15,  1.0E16,  1.0E17,  1.0E18,  1.0E19,
      1.0E20,  1.0E21,  1.0E22,  1.0E23,  1.0E24,  1.0E25,  1.0E26,  1.0E27,  1.0E28,  1.0E29,
      1.0E30,  1.0E31,  1.0E32,  1.0E33,  1.0E34,  1.0E35,  1.0E36,  1.0E37,  1.0E38,  1.0E39,
      1.0E40,  1.0E41,  1.0E42,  1.0E43,  1.0E44,  1.0E45,  1.0E46,  1.0E47,  1.0E48,  1.0E49,
      1.0E50,  1.0E51,  1.0E52,  1.0E53,  1.0E54,  1.0E55,  1.0E56,  1.0E57,  1.0E58,  1.0E59,
      1.0E60,  1.0E61,  1.0E62,  1.0E63,  1.0E64,  1.0E65,  1.0E66,  1.0E67,  1.0E68,  1.0E69,
      1.0E70,  1.0E71,  1.0E72,  1.0E73,  1.0E74,  1.0E75,  1.0E76,  1.0E77,  1.0E78,  1.0E79,
      1.0E80,  1.0E81,  1.0E82,  1.0E83,  1.0E84,  1.0E85,  1.0E86,  1.0E87,  1.0E88,  1.0E89,
      1.0E90,  1.0E91,  1.0E92,  1.0E93,  1.0E94,  1.0E95,  1.0E96,  1.0E97,  1.0E98,  1.0E99,
      1.0E100, 1.0E101, 1.0E102, 1.0E103, 1.0E104, 1.0E105, 1.0E106, 1.0E107, 1.0E108, 1.0E109,
      1.0E110, 1.0E111, 1.0E112, 1.0E113, 1.0E114, 1.0E115, 1.0E116, 1.0E117, 1.0E118, 1.0E119,
      1.0E120, 1.0E121, 1.0E122, 1.0E123, 1.0E124, 1.0E125, 1.0E126, 1.0E127, 1.0E128, 1.0E129,
      1.0E130, 1.0E131, 1.0E132, 1.0E133, 1.0E134, 1.0E135, 1.0E136, 1.0E137, 1.0E138, 1.0E139,
      1.0E140, 1.0E141, 1.0E142, 1.0E143, 1.0E144, 1.0E145, 1.0E146, 1.0E147, 1.0E148, 1.0E149,
      1.0E150, 1.0E151, 1.0E152, 1.0E153, 1.0E154, 1.0E155, 1.0E156, 1.0E157, 1.0E158, 1.0E159,
      1.0E160, 1.0E161, 1.0E162, 1.0E163, 1.0E164, 1.0E165, 1.0E166, 1.0E167, 1.0E168, 1.0E169,
      1.0E170, 1.0E171, 1.0E172, 1.0E173, 1.0E174, 1.0E175, 1.0E176, 1.0E177, 1.0E178, 1.0E179,
      1.0E180, 1.0E181, 1.0E182, 1.0E183, 1.0E184, 1.0E185, 1.0E186, 1.0E187, 1.0E188, 1.0E189,
      1.0E190, 1.0E191, 1.0E192, 1.0E193, 1.0E194, 1.0E195, 1.0E196, 1.0E197, 1.0E198, 1.0E199,
      1.0E200, 1.0E201, 1.0E202, 1.0E203, 1.0E204, 1.0E205, 1.0E206, 1.0E207, 1.0E208, 1.0E209,
      1.0E210, 1.0E211, 1.0E212, 1.0E213, 1.0E214, 1.0E215, 1.0E216, 1.0E217, 1.0E218, 1.0E219,
      1.0E220, 1.0E221, 1.0E222, 1.0E223, 1.0E224, 1.0E225, 1.0E226, 1.0E227, 1.0E228, 1.0E229,
      1.0E230, 1.0E231, 1.0E232, 1.0E233, 1.0E234, 1.0E235, 1.0E236, 1.0E237, 1.0E238, 1.0E239,
      1.0E240, 1.0E241, 1.0E242, 1.0E243, 1.0E244, 1.0E245, 1.0E246, 1.0E247, 1.0E248, 1.0E249,
      1.0E250, 1.0E251, 1.0E252, 1.0E253, 1.0E254, 1.0E255, 1.0E256, 1.0E257, 1.0E258, 1.0E259,
      1.0E260, 1.0E261, 1.0E262, 1.0E263, 1.0E264, 1.0E265, 1.0E266, 1.0E267, 1.0E268, 1.0E269,
      1.0E270, 1.0E271, 1.0E272, 1.0E273, 1.0E274, 1.0E275, 1.0E276, 1.0E277, 1.0E278, 1.0E279,
      1.0E280, 1.0E281, 1.0E282, 1.0E283, 1.0E284, 1.0E285, 1.0E286, 1.0E287, 1.0E288, 1.0E289,
      1.0E290, 1.0E291, 1.0E292, 1.0E293, 1.0E294, 1.0E295, 1.0E296, 1.0E297, 1.0E298, 1.0E299,
      1.0E300, 1.0E301, 1.0E302, 1.0E303, 1.0E304, 1.0E305, 1.0E306, 1.0E307, 1.0E308};
  static constexpr float tenpowerF[39] = {
      1.0F,    1.0E1F,  1.0E2F,  1.0E3F,  1.0E4F,  1.0E5F,  1.0E6F,  1.0E7F,  1.0E8F,  1.0E9F,
      1.0E10F, 1.0E11F, 1.0E12F, 1.0E13F, 1.0E14F, 1.0E15F, 1.0E16F, 1.0E17F, 1.0E18F, 1.0E19F,
      1.0E20F, 1.0E21F, 1.0E22F, 1.0E23F, 1.0E24F, 1.0E25F, 1.0E26F, 1.0E27F, 1.0E28F, 1.0E29F,
      1.0E30F, 1.0E31F, 1.0E32F, 1.0E33F, 1.0E34F, 1.0E35F, 1.0E36F, 1.0E37F, 1.0E38F};
  static constexpr int minfltexp = -38;
  static constexpr int maxfltexp = 38;
  static constexpr int mindblexp = -308;
  static constexpr int maxdblexp = 308;
  static constexpr int maxsigdigits = 17;
  static constexpr int maxdigl = 9;    // max digits in a long
  static constexpr int maxexpdig = 3;  // max digits in an exponent
  static double tenD(Int, int);
  static float tenF(Int, int);
  static int ckaccum(double &, Int, int);
  static int ckaccum(float &, Int, int);
};
 
inline FITS::FITS() {}  // just a dummy function to prevent instantiation
inline Bool FITS::isa_digit(char c) { return isdigit(c) ? True : False; }
inline int FITS::digit2bin(char c) { return c - '0'; }
inline Bool FITS::isa_text(char c) { return isprint(c) ? True : False; }
inline Bool FITS::isa_letter(char c) { return isupper(c) ? True : False; }
inline int FITS::letter2bin(char c) { return c - 'A'; }
 
ostream &operator<<(ostream &, const FITS::ValueType &);
 
inline double FITS::tenD(Int numb, int pow) {
  return (pow > 0) ? (((double)numb) * tenpowerD[pow])
                   : ((pow < 0) ? (((double)numb) / tenpowerD[-pow]) : ((double)numb));
}
inline float FITS::tenF(Int numb, int pow) {
  return (pow > 0) ? (((float)numb) * tenpowerF[pow])
                   : ((pow < 0) ? (((float)numb) / tenpowerF[-pow]) : ((float)numb));
}
 
//<summary> reserved FITS keyword </summary>
// <reviewed reviewer="UNKNOWN" date="before2004/08/25" tests="" demos="">
// </reviewed>
 
class ReservedFitsKeyword {
 public:
  const char *aname() const;
  FITS::ReservedName name() const;
  int namesize() const;
  FITS::ValueType type() const;
  Bool isindexed() const;
  Bool isessential() const;
#if defined(TURBOCPP)
  // It is best for the following to be private, but
  // C-Front won't allow an initializer list if they are private.
  // This issue isn't that crucial since functions in
  // ReservedFitsKeywordCollection always return const items.
 private:
#endif
  FITS::ReservedName name_;
  const char *aname_;
  int namesize_;
  FITS::ValueType type_;
  Bool isindexed_;    // 0 = NOT INDEXED, 1 = INDEXED
  Bool isessential_;  // 0 = NO, 1 = YES
};
 
inline const char *ReservedFitsKeyword::aname() const { return aname_; }
inline int ReservedFitsKeyword::namesize() const { return namesize_; }
inline FITS::ValueType ReservedFitsKeyword::type() const { return type_; }
inline Bool ReservedFitsKeyword::isindexed() const { return isindexed_; }
inline Bool ReservedFitsKeyword::isessential() const { return isessential_; }
 
//<summary> collection of reserved FITS keywords </summary>
// <reviewed reviewer="UNKNOWN" date="before2004/08/25" tests="" demos="">
// </reviewed>
 
class ReservedFitsKeywordCollection {
 public:
  const ReservedFitsKeyword &operator[](int i) const;
  int no() const;
  const ReservedFitsKeyword &get(FITS::ReservedName, Bool, FITS::ValueType, const void *, int,
                                 const char *&) const;
  const ReservedFitsKeyword &get(const char *, int, Bool, FITS::ValueType, const void *, int,
                                 const char *&) const;
  const char *aname(FITS::ReservedName) const;
  int essential_name(const char *, int) const;
  const ReservedFitsKeyword &get_essential(int, Bool, FITS::ValueType, const void *, int,
                                           const char *&) const;
  int isreserved(const char *, int) const;
  Bool isunique(int) const;
  Bool requires_value(int) const;
  const ReservedFitsKeyword &userdef_item() const;
  const ReservedFitsKeyword &err_item() const;
  const ReservedFitsKeyword &end_item() const;
  const ReservedFitsKeyword &spaces() const;
  const ReservedFitsKeyword &comment() const;
  const ReservedFitsKeyword &history() const;
  int rules(const ReservedFitsKeyword &, const char *, int, Bool, FITS::ValueType, const void *,
            int, const char *&) const;
 
 private:
  static constexpr int no_items = 56;  // number of entries in the table
                                       //   Discussion of Reserved FitsKeyword Table
                                       //
  //    1. The reserved name itself (name_) is not unique;  there may
  //       be more than one entry with the same reserved name.
  //    2. The combination of reserved name, the data type, and whether
  //       it is indexed or not (name_, type_, isindexed_) is unique
  //       within the table.
  //    3. The table is sorted by reserved name + type + isindexed.
  static constexpr ReservedFitsKeyword resword[56] = {
      //        key            aname      namesize         isindexed           Section
      //         |               |           |  type           | isessential   in|NOST
      //        \|/             \|/         \|/\|/            \|/     \|/      \|/
      //         ------          ------      -  -------        -----  -----    ------------
      /*  0 */ {FITS::USER_DEF, "", 0, FITS::NOVALUE, False, False},
      /*  1 */ {FITS::AUTHOR, "AUTHOR", 6, FITS::STRING, False, False},      // 5.2.2.3
      /*  2 */ {FITS::BITPIX, "BITPIX", 6, FITS::LONG, False, True},         // 5.2.1.1
      /*  3 */ {FITS::BLANK, "BLANK", 5, FITS::LONG, False, False},          // 5.2.2.5
      /*  4 */ {FITS::BLOCKED, "BLOCKED", 7, FITS::LOGICAL, False, False},   // 5.2.2.1
      /*  5 */ {FITS::BSCALE, "BSCALE", 6, FITS::REAL, False, False},        // 5.2.2.5
      /*  6 */ {FITS::BUNIT, "BUNIT", 5, FITS::STRING, False, False},        // 5.2.2.5
      /*  7 */ {FITS::BZERO, "BZERO", 5, FITS::REAL, False, False},          // 5.2.2.5
      /*  8 */ {FITS::CDELT, "CDELT", 5, FITS::REAL, True, False},           // 5.2.2.5
      /*  9 */ {FITS::COMMENT, "COMMENT", 7, FITS::NOVALUE, False, False},   // 5.2.2.4
      /* 10 */ {FITS::CROTA, "CROTA", 5, FITS::REAL, True, False},           // 5.2.2.5
      /* 11 */ {FITS::CRPIX, "CRPIX", 5, FITS::REAL, True, False},           // 5.2.2.5
      /* 12 */ {FITS::CRVAL, "CRVAL", 5, FITS::REAL, True, False},           // 5.2.2.5
      /* 13 */ {FITS::CTYPE, "CTYPE", 5, FITS::STRING, True, False},         // 5.2.2.5
      /* 14 */ {FITS::DATAMAX, "DATAMAX", 7, FITS::REAL, False, False},      // 5.2.2.5
      /* 15 */ {FITS::DATAMIN, "DATAMIN", 7, FITS::REAL, False, False},      // 5.2.2.5
      /* 16 */ {FITS::DATE, "DATE", 4, FITS::STRING, False, False},          // 5.2.2.1
      /* 17 */ {FITS::DATE_OBS, "DATE-OBS", 8, FITS::STRING, False, False},  // 5.2.2.2
      /* 18 */ {FITS::END, "END", 3, FITS::NOVALUE, False, True},            // 5.2.1.1
      /* 19 */ {FITS::EPOCH, "EPOCH", 5, FITS::REAL, False, False},          // 5.2.2.2
      /* 20 */ {FITS::EQUINOX, "EQUINOX", 7, FITS::REAL, False, False},      // 5.2.2.2
      /* 21 */ {FITS::EXTEND, "EXTEND", 6, FITS::LOGICAL, False, True},      // 5.2.1.2
      /* 22 */ {FITS::EXTLEVEL, "EXTLEVEL", 8, FITS::LONG, False, False},    // 5.2.2.6
      /* 23 */ {FITS::EXTNAME, "EXTNAME", 7, FITS::STRING, False, False},    // 5.2.2.6
      /* 24 */ {FITS::EXTVER, "EXTVER", 6, FITS::LONG, False, False},        // 5.2.2.6
      /* 25 */ {FITS::GCOUNT, "GCOUNT", 6, FITS::LONG, False, True},         // 5.2.1.2
      /* 26 */ {FITS::GROUPS, "GROUPS", 6, FITS::LOGICAL, False, True},      // 7.1.1.6
      /* 27 */ {FITS::HISTORY, "HISTORY", 7, FITS::NOVALUE, False, False},   // 5.2.2.4
      /* 28 */ {FITS::INSTRUME, "INSTRUME", 8, FITS::STRING, False, False},  // 5.2.2.2
      /* 29 */ {FITS::NAXIS, "NAXIS", 5, FITS::LONG, False, True},           // 5.2.1.1
      /* 30 */ {FITS::NAXIS, "NAXIS", 5, FITS::LONG, True, True},            // 5.2.1.1
      /* 31 */ {FITS::OBJECT, "OBJECT", 6, FITS::STRING, False, False},      // 5.2.2.2
      /* 32 */ {FITS::OBSERVER, "OBSERVER", 8, FITS::STRING, False, False},  // 5.2.2.2
      /* 33 */ {FITS::ORIGIN, "ORIGIN", 6, FITS::STRING, False, False},      // 5.2.2.1
      /* 34 */ {FITS::PCOUNT, "PCOUNT", 6, FITS::LONG, False, True},         // 5.2.1.2
      /* 35 */ {FITS::PSCAL, "PSCAL", 5, FITS::REAL, True, False},           // 7.1.2.2
      /* 36 */ {FITS::PTYPE, "PTYPE", 5, FITS::STRING, True, False},         // 7.1.2.1
      /* 37 */ {FITS::PZERO_FITS, "PZERO", 5, FITS::REAL, True, False},      // 7.1.2.3
      /* 38 */ {FITS::REFERENC, "REFERENC", 8, FITS::STRING, False, False},  // 5.2.2.3
      /* 39 */ {FITS::SIMPLE, "SIMPLE", 6, FITS::LOGICAL, False, True},      // 5.2.1.1
      /* 40 */ {FITS::SPACES, "        ", 8, FITS::NOVALUE, False, False},   // 5.2.2.4
      /* 41 */ {FITS::TBCOL, "TBCOL", 5, FITS::LONG, True, False},           // 8.1.1
      /* 42 */ {FITS::TDIM, "TDIM", 4, FITS::STRING, True, False},           // A.4, A.9.1
      /* 43 */ {FITS::TDISP, "TDISP", 5, FITS::STRING, True, False},         // A.4
      /* 44 */ {FITS::TELESCOP, "TELESCOP", 8, FITS::STRING, False, False},  // 5.2.2.2
      /* 45 */ {FITS::TFIELDS, "TFIELDS", 7, FITS::LONG, False, False},      // 8.1.1
      /* 46 */ {FITS::TFORM, "TFORM", 5, FITS::STRING, True, False},         // 8.1.1
      /* 47 */ {FITS::THEAP, "THEAP", 5, FITS::LONG, False, False},          // A.4, A.9.2
      /* 48 */ {FITS::TNULL, "TNULL", 5, FITS::STRING, True, False},         // 8.1.2
      /* 49 */ {FITS::TNULL, "TNULL", 5, FITS::LONG, True, False},           // A.4
      /* 50 */ {FITS::TSCAL, "TSCAL", 5, FITS::REAL, True, False},           // 8.1.2
      /* 51 */ {FITS::TTYPE, "TTYPE", 5, FITS::STRING, True, False},         // 8.1.2
      /* 52 */ {FITS::TUNIT, "TUNIT", 5, FITS::STRING, True, False},         // 8.1.2
      /* 53 */ {FITS::TZERO, "TZERO", 5, FITS::REAL, True, False},           // 8.1.2
      /* 54 */ {FITS::XTENSION, "XTENSION", 8, FITS::STRING, False, True},   // 5.2.1.2
      /* 55 */ {FITS::ERRWORD, "", 0, FITS::NOVALUE, False, False}           // last
  };
  static constexpr const ReservedFitsKeyword &user_def_item = resword[0];  // user-defined keyword
  static constexpr const ReservedFitsKeyword &error_item = resword[55];    // error in keyword
  static constexpr const ReservedFitsKeyword &end__item = resword[18];
  static constexpr const ReservedFitsKeyword &spaces_item = resword[40];
  static constexpr const ReservedFitsKeyword &comment_item = resword[9];
  static constexpr const ReservedFitsKeyword &history_item = resword[27];
  // alphabetic index to table
  static constexpr int resalpha[26] = {
      // A  B  C   D   E  F   G   H   I  J  K  L  M   N   O   P  Q   R
      1, 2, 8, 14, 18, 0, 25, 27, 28, 0, 0, 0, 0, 29, 31, 34, 0, 38,
      //  S   T  U  V  W   X  Y  Z
      39, 41, 0, 0, 0, 54, 0, 0};
  const ReservedFitsKeyword &match(int, const char *, int, Bool, FITS::ValueType, const void *, int,
                                   const char *&) const;
};
 
inline const ReservedFitsKeyword &ReservedFitsKeywordCollection::operator[](int i) const {
  return resword[i];
}
inline int ReservedFitsKeywordCollection::no() const { return no_items; }
inline Bool ReservedFitsKeywordCollection::isunique(int i) const {
  return (Bool)(resword[i + 1].name() != resword[i].name());
}
inline const ReservedFitsKeyword &ReservedFitsKeywordCollection::userdef_item() const {
  return user_def_item;
}
inline const ReservedFitsKeyword &ReservedFitsKeywordCollection::err_item() const {
  return error_item;
}
inline const ReservedFitsKeyword &ReservedFitsKeywordCollection::end_item() const {
  return end__item;
}
inline const ReservedFitsKeyword &ReservedFitsKeywordCollection::spaces() const {
  return spaces_item;
}
inline const ReservedFitsKeyword &ReservedFitsKeywordCollection::comment() const {
  return comment_item;
}
inline const ReservedFitsKeyword &ReservedFitsKeywordCollection::history() const {
  return history_item;
}
 
//<summary> analyse the name of a header card </summary>
// <reviewed reviewer="UNKNOWN" date="before2004/08/25" tests="" demos="">
// </reviewed>
//<synopsis>
// Analyse the name of a header card
//</synopsis>
 
class FitsNameResult {
 public:
  Bool isaname;   // 1 if there is a name present, otherwise 0
  int begpos;     // beginning position of name
  int endpos;     // ending position of name
  Bool isaindex;  // whether an index is present or not
  int index;      // index if present
  int len;        // length of name without index
  enum ErrMsg { OK = 0, NO_0_NDX };
  ErrMsg err;
};
 
//<summary> analyse the value of a header card </summary>
// <reviewed reviewer="UNKNOWN" date="before2004/08/25" tests="" demos="">
// </reviewed>
//<synopsis>
// Analyse the value of a header card
//</synopsis>
 
class FitsValueResult {
 public:
  FITS::ValueType type;
  union {
    Bool b;
    int s[2];  // for strings, s[0] is offset, s[1] length
    Int l;
    float f;
    double d;
  };
  Complex c;
  IComplex lc;
  DComplex dc;
  int begpos;          // beginning position of value
  int endpos;          // ending position of value
  Bool isa_point;      // 1 if a point, otherwise 0
  int pointpos;        // position of point, if any
  int no_sig;          // number of significant digits
  const char *errmsg;  // error message, if any
};
 
//<summary> parse a header card </summary>
// <reviewed reviewer="UNKNOWN" date="before2004/08/25" tests="" demos="">
// </reviewed>
//<synopsis>
//  parse a header card
//</synopsis>
 
class FitsParse {
  friend class FitsKeywordList;
 
 public:
  FitsKeyword &parse(const char *, int);  // Parsing one string
  int no_errs() const;
  const char *err(int) const;
 
 private:
  FitsParse(int = 10);
  ~FitsParse();
  int no_errs_;
  const int max_errs;
  const char **err_;
  int seterr(const char *);
  FitsKeyword &mkerr(const char *s, int len);
};
 
inline FitsParse::~FitsParse() { delete[] err_; }
inline int FitsParse::no_errs() const { return no_errs_; }
inline const char *FitsParse::err(int i) const { return err_[i]; }
inline int FitsParse::seterr(const char *s) {
  return no_errs_ < max_errs ? (err_[no_errs_++] = s, 0) : -1;
}
 
//<summary> FITS keyword </summary>
// <reviewed reviewer="UNKNOWN" date="before2004/08/25" tests="" demos="">
// </reviewed>
//<synopsis>
// A FITS keyword contains a name, a value and a comment.
//</synopsis>
class FitsKeyword {
  friend class FitsKeywordList;
  friend class FitsParse;
  // A word about friends:  FitsKeywordList accesses the next and prev
  // pointers and the FitsKeyword constructors.
  // FitsParse only accesses the FitsKeyword constructors.
 
 public:
  FitsKeyword(const FitsKeyword &);
  FitsKeyword &operator=(const FitsKeyword &);
  ~FitsKeyword();
 
  //<group>
  // get info about the name
  const char *name() const;
  int namelen() const;
  Bool isreserved() const;
  Bool isindexed() const;
  const ReservedFitsKeyword &kw() const;
  int index() const;
  //</group>
 
  //<group>
  // access the keyword comment
  const char *comm() const;
  int commlen() const;
  //</group>
 
  // access the error status
  int err() const;
 
  // the datatype of the keyword
  FITS::ValueType type() const;
 
  // access the value of the keyword
  //<group>
  Bool asBool() const;
  const char *asString() const;
  int valStrlen() const;
  Int asInt() const;
  float asFloat() const;
  double asDouble() const;
  IComplex asIComplex() const;
  Complex asComplex() const;
  DComplex asDComplex() const;
  const void *value() const;
  //</group>
 
  // change the value of the keyword
  //<group>
  FitsKeyword &operator=(Bool);
  FitsKeyword &operator=(const char *);
  FitsKeyword &operator=(Int);
  FitsKeyword &operator=(float);
  FitsKeyword &operator=(double);
  FitsKeyword &operator=(IComplex);
  FitsKeyword &operator=(Complex);
  FitsKeyword &operator=(DComplex);
  //</group>
 
  // change the comment of the keyword
  void comm(const char *);
 
  // change the name of the keyword
  void name(const char *);
 
 private:
  FitsKeyword *next_;
  FitsKeyword *prev_;
 
  //<group>
  // the keyword name
  // if name_ is 0, keyword is not a user defined name
  // if ndx is 0, there is no index
  char *name_;
  const ReservedFitsKeyword *kw_;
  int ndx;
  short namelen_;
  //</group>
 
  //<group>
  // the keyword comment
  // if comm_ is 0, there is no comment
  char *comm_;
  short commlen_;
  //</group>
 
  //<group>
  // the keyword value
  FITS::ValueType type_;
  union {
    Bool bval;
    Int ival;
    float fval;
    double dval;
  };
  void *val;       // pointer to allocated value, if any
  short vallen;    // only used for string data
  void del_val();  // does an appropriate delete based on type
  //</group>
 
  void init(const FitsKeyword &);
  void setval(const FITS::ValueType &, const void *, int);
  void setcomm(const char *, int);
  static void err(const char *, const FITS::ValueType &, const void *, const char *);
  static void memchk(void *);
 
  //<group>
  // private constructors for use by friends
 
  // constructs user-defined keywords
  // parms: name, namelen, type, val, vallen, comm, commlen
  FitsKeyword(const char *, int, FITS::ValueType, const void *, int, const char *, int);
  // constructs reserved keywords
  // parms: resword, index, val, vallen, comm, commlen
  FitsKeyword(const ReservedFitsKeyword *, int, FITS::ValueType, const void *, int, const char *,
              int);
  //</group>
};
 
ostream &operator<<(ostream &, const FitsKeyword &);
 
inline FitsKeyword::FitsKeyword(const FitsKeyword &k)
    : next_(0), prev_(0), name_(0), kw_(0), comm_(0), val(0) {
  init(k);
}
inline FitsKeyword &FitsKeyword::operator=(const FitsKeyword &k) {
  delete[] name_;
  delete[] comm_;
  del_val();
  init(k);
  return *this;
}
inline FitsKeyword::~FitsKeyword() {
  delete[] name_;
  delete[] comm_;
  del_val();
}
 
inline const ReservedFitsKeyword &FitsKeyword::kw() const { return *kw_; }
inline Bool FitsKeyword::isreserved() const {
  return (kw().name() != FITS::ERRWORD && kw().name() != FITS::USER_DEF) ? True : False;
}
inline const char *FitsKeyword::name() const {
  return isreserved() ? kw().aname() : (namelen_ ? name_ : "");
}
inline int FitsKeyword::namelen() const { return namelen_; }
inline Bool FitsKeyword::isindexed() const { return ndx > 0 ? True : False; }
inline int FitsKeyword::index() const { return ndx; }
 
inline const char *FitsKeyword::comm() const { return comm_ ? comm_ : ""; }
inline int FitsKeyword::commlen() const { return commlen_; }
inline int FitsKeyword::err() const { return (kw().name() == FITS::ERRWORD); }
inline FITS::ValueType FitsKeyword::type() const { return type_; }
 
inline Bool FitsKeyword::asBool() const { return bval; }
inline const char *FitsKeyword::asString() const { return vallen ? (const char *)val : ""; }
inline int FitsKeyword::valStrlen() const { return vallen; }
inline Int FitsKeyword::asInt() const {
  if (type() != FITS::LONG) {
    cerr << "Unexpected keyword type in FitsKeyword::asInt()\n";
    exit(1);
  }
  return ival;
}
inline float FitsKeyword::asFloat() const {
  switch (type()) {
    case FITS::BYTE:
    case FITS::SHORT:
    case FITS::LONG:
      return (float)ival;
    case FITS::FLOAT:
      return fval;
    case FITS::DOUBLE:
      return (float)dval;
    default:
      cerr << "Unexpected keyword type in asFloat()\n";
      exit(1);
  }
  return 0.0;
}
inline double FitsKeyword::asDouble() const {
  switch (type()) {
    case FITS::BYTE:
    case FITS::SHORT:
    case FITS::LONG:
      return (double)ival;
    case FITS::FLOAT:
      return (double)fval;
    case FITS::DOUBLE:
      return dval;
    default:
      cerr << "Unexpected keyword type in asDouble()\n";
      exit(1);
  }
  return 0.0;
}
inline IComplex FitsKeyword::asIComplex() const { return *((IComplex *)val); }
inline Complex FitsKeyword::asComplex() const { return *((Complex *)val); }
inline DComplex FitsKeyword::asDComplex() const { return *((DComplex *)val); }
 
inline FitsKeyword &FitsKeyword::operator=(Bool x) {
  bval = x;
  type_ = FITS::LOGICAL;
  return *this;
}
inline FitsKeyword &FitsKeyword::operator=(Int x) {
  ival = x;
  type_ = FITS::LONG;
  return *this;
}
inline FitsKeyword &FitsKeyword::operator=(float x) {
  fval = x;
  type_ = FITS::FLOAT;
  return *this;
}
inline FitsKeyword &FitsKeyword::operator=(double x) {
  dval = x;
  type_ = FITS::DOUBLE;
  return *this;
}
inline FitsKeyword &FitsKeyword::operator=(IComplex x) {
  *((IComplex *)val) = x;
  type_ = FITS::ICOMPLEX;
  return *this;
}
inline FitsKeyword &FitsKeyword::operator=(Complex x) {
  *((Complex *)val) = x;
  type_ = FITS::COMPLEX;
  return *this;
}
inline FitsKeyword &FitsKeyword::operator=(DComplex x) {
  *((DComplex *)val) = x;
  type_ = FITS::DCOMPLEX;
  return *this;
}
 
class ConstFitsKeywordList;  // forward declaration
 
//<summary> linked list of FITS keywords </summary>
// <reviewed reviewer="UNKNOWN" date="before2004/08/25" tests="" demos="">
// </reviewed>
//<synopsis>
// A linked list of FITS keywords.
//</synopsis>
 
class FitsKeywordList {
 public:
  FitsKeywordList();
  ~FitsKeywordList();
  FitsKeywordList(const FitsKeywordList &);
  FitsKeywordList(ConstFitsKeywordList &);
  FitsKeywordList &operator=(const FitsKeywordList &);
 
  // Convert the list to a string containing the 80-byte FITS headers.
  std::string toString() const;
 
  // delete the current keyword (the thing returned by curr()) from the list
  void del();
 
  // Add (make) a reserved keyword with the given value and optional comment
  // The comment will be truncated if necessary to fit the available space.
  // String values must be less than 69 characters.  String values longer than
  // that will result in an ERROR keyword instead of the desired keyword.
  // <group>
  void mk(FITS::ReservedName k, Bool v, const char *c = 0);
  void mk(FITS::ReservedName k, const char *v = 0, const char *c = 0);
  void mk(FITS::ReservedName k, Int v, const char *c = 0);
  void mk(FITS::ReservedName k, long v, const char *c = 0);
  void mk(FITS::ReservedName k, double v, const char *c = 0);
  // </group>
 
  // Add (make) an indexed reserved keyword with the given value and optional comment
  // The comment will be truncated if necessary to fit the available space.
  // String values must be less than 69 characters.  String values longer than
  // that will result in an ERROR keyword instead of the desired keyword.
  // <group>
  void mk(int n, FITS::ReservedName k, Bool v, const char *c = 0);
  void mk(int n, FITS::ReservedName k, const char *v, const char *c = 0);
  void mk(int n, FITS::ReservedName k, Int v, const char *c = 0);
  void mk(int n, FITS::ReservedName k, long v, const char *c = 0);
  void mk(int n, FITS::ReservedName k, double v, const char *c = 0);
  // </group>
 
  // Add (make) a user defined keyword with the given name, value and optional comment.
  // The comment will be truncated if necessary to fit the available space.
  // The name must be no longer than 8 characters.  Names longer than that will
  // result in an ERROR keyword instead of the desired keyword.
  // String values must no longer than 69 characters.  String values longer than
  // that will result in an ERROR keyword instead of the desired keyword.
  // <group>
  void mk(const char *n, Bool v, const char *c = 0);
  void mk(const char *n, const char *v = 0, const char *c = 0);
  void mk(const char *n, Int v, const char *c = 0);
  void mk(const char *n, long v, const char *c = 0);
  void mk(const char *n, float v, const char *c = 0);
  void mk(const char *n, double v, const char *c = 0);
  void mk(const char *n, Int r, Int i, const char *c = 0);
  void mk(const char *n, float r, float i, const char *c = 0);
  void mk(const char *n, double r, double i, const char *c = 0);
  // </group>
 
  // add a spaces line
  void spaces(const char *n = 0, const char *c = 0);
 
  // add a comment card
  void comment(const char *n = 0, const char *c = 0);
 
  // add a history card
  void history(const char *c = 0);
 
  // add the end card.  This must be at the end of the list.
  void end();
 
  // Retrieve specific keywords -- these also set the current mark
  //<group>
  // return the i-th keyword -- keyword numbering starts with 0
  FitsKeyword *operator()(int);
  // return first and next non-indexed reserved keyword
  FitsKeyword *operator()(const FITS::ReservedName &);
  FitsKeyword *next(const FITS::ReservedName &);
  // return first and next indexed reserved keyword
  FitsKeyword *operator()(const FITS::ReservedName &, int);
  FitsKeyword *next(const FITS::ReservedName &, int);
  // return first and next user-defined keyword
  FitsKeyword *operator()(const char *);
  FitsKeyword *next(const char *);
  //</group>
 
  //<group>
  Bool isempty() const;
  void first();
  void last();
  FitsKeyword *next();
  FitsKeyword *prev();
  FitsKeyword *curr();
  //</group>
 
  //<group>
  void delete_all();
  int rules(FitsKeyword &, FITSErrorHandler errhandler = FITSError::defaultHandler);
  int rules(FITSErrorHandler errhandler = FITSError::defaultHandler);
  Bool basic_rules();
  //</group>
 
  //<group>
  // For parsing a single string
  void parse(const char *, int);
  int no_parse_errs() const;
  const char *parse_err(int) const;
  //</group>
 
  void insert(FitsKeyword &);
 
 private:
  FitsKeyword *beg_;
  FitsKeyword *end_;
  FitsKeyword *pos;
  int total;
  int cursor;
  FitsKeyword &make(const char *nm, FITS::ValueType t, const void *v, const char *c);
  FitsKeyword &make(FITS::ReservedName nm, FITS::ValueType t, const void *v, const char *c);
  FitsKeyword &make(int ind, FITS::ReservedName nm, FITS::ValueType t, const void *v,
                    const char *c);
  // construct an error keyword - this happens when a name is invalid (NULL
  // or more than 8 characters) or a string value is too long (more than
  // 69 characters).  It is the responsibility of the caller to the
  // several mk functions to ensure that that doesn't happen.  By the time
  // it gets here, it is assumed that such problems are true errors.
  // This is used by the private make functions.
  FitsKeyword &makeErrKeyword(const char *name, FITS::ValueType type, const void *val,
                              const char *errmsg);
  FitsParse card;
};
 
ostream &operator<<(ostream &o, FitsKeywordList &);  // print the entire list
 
inline FitsKeywordList::FitsKeywordList() : beg_(0), end_(0), pos(0), total(0), cursor(0) {}
inline FitsKeywordList::~FitsKeywordList() { delete_all(); }
inline Bool FitsKeywordList::isempty() const { return total == 0 ? True : False; }
inline void FitsKeywordList::first() {
  cursor = 0;
  pos = beg_;
}
inline void FitsKeywordList::last() {
  cursor = total;
  pos = end_;
}
inline FitsKeyword *FitsKeywordList::curr() { return pos; }
inline FitsKeyword *FitsKeywordList::operator()(const FITS::ReservedName &n) {
  first();
  return next(n);
}
inline FitsKeyword *FitsKeywordList::operator()(const FITS::ReservedName &n, int ndx) {
  first();
  return next(n, ndx);
}
inline FitsKeyword *FitsKeywordList::operator()(const char *w) {
  first();
  return next(w);
}
inline void FitsKeywordList::parse(const char *s, int l) { insert(card.parse(s, l)); }
inline int FitsKeywordList::no_parse_errs() const { return card.no_errs(); }
inline const char *FitsKeywordList::parse_err(int n) const { return card.err(n); }
 
// FitsKeyword constructors for non-indexed Reserved keywords
inline void FitsKeywordList::mk(FITS::ReservedName k, Bool v, const char *c) {
  insert(make(k, FITS::LOGICAL, &v, c));
}
inline void FitsKeywordList::mk(FITS::ReservedName k, const char *v, const char *c) {
  insert(make(k, FITS::STRING, v, c));
}
inline void FitsKeywordList::mk(FITS::ReservedName k, Int v, const char *c) {
  insert(make(k, FITS::LONG, &v, c));
}
inline void FitsKeywordList::mk(FITS::ReservedName k, long v, const char *c) {
  insert(make(k, FITS::LONG, &v, c));
}
inline void FitsKeywordList::mk(FITS::ReservedName k, double v, const char *c) {
  insert(make(k, FITS::DOUBLE, &v, c));
}
// FitsKeyword constructors for indexed Reserved keywords
inline void FitsKeywordList::mk(int n, FITS::ReservedName k, Bool v, const char *c) {
  Bool tmp;
  tmp = v;
  insert(make(n, k, FITS::LOGICAL, &tmp, c));
}
inline void FitsKeywordList::mk(int n, FITS::ReservedName k, const char *v, const char *c) {
  insert(make(n, k, FITS::STRING, v, c));
}
inline void FitsKeywordList::mk(int n, FITS::ReservedName k, Int v, const char *c) {
  insert(make(n, k, FITS::LONG, &v, c));
}
inline void FitsKeywordList::mk(int n, FITS::ReservedName k, long v, const char *c) {
  insert(make(n, k, FITS::LONG, &v, c));
}
inline void FitsKeywordList::mk(int n, FITS::ReservedName k, double v, const char *c) {
  insert(make(n, k, FITS::DOUBLE, &v, c));
}
// FitsKeyword constructors for User-Defined keywords
inline void FitsKeywordList::mk(const char *n, Bool v, const char *c) {
  Bool tmp;
  tmp = v;
  insert(make(n, FITS::LOGICAL, &tmp, c));
}
inline void FitsKeywordList::mk(const char *n, const char *v, const char *c) {
  insert(make(n, FITS::STRING, v, c));
}
inline void FitsKeywordList::mk(const char *n, Int v, const char *c) {
  insert(make(n, FITS::LONG, &v, c));
}
inline void FitsKeywordList::mk(const char *n, long v, const char *c) {
  insert(make(n, FITS::LONG, &v, c));
}
inline void FitsKeywordList::mk(const char *n, float v, const char *c) {
  insert(make(n, FITS::FLOAT, &v, c));
}
inline void FitsKeywordList::mk(const char *n, double v, const char *c) {
  insert(make(n, FITS::DOUBLE, &v, c));
}
inline void FitsKeywordList::mk(const char *n, Int r, Int i, const char *c) {
  IComplex v(r, i);
  insert(make(n, FITS::ICOMPLEX, &v, c));
}
inline void FitsKeywordList::mk(const char *n, float r, float i, const char *c) {
  Complex v(r, i);
  insert(make(n, FITS::COMPLEX, &v, c));
}
inline void FitsKeywordList::mk(const char *n, double r, double i, const char *c) {
  DComplex v(r, i);
  insert(make(n, FITS::DCOMPLEX, &v, c));
}
// Additional keyword constructors for commentary, etc.
inline void FitsKeywordList::spaces(const char *n, const char *c) {
  insert((n == 0
              ? make(FITS::SPACES, FITS::NOVALUE, 0, c)
              : (c == 0 ? make(FITS::SPACES, FITS::NOVALUE, 0, n) : make(n, FITS::NOVALUE, 0, c))));
}
inline void FitsKeywordList::comment(const char *n, const char *c) {
  insert((
      n == 0 ? make(FITS::COMMENT, FITS::NOVALUE, 0, c)
             : (c == 0 ? make(FITS::COMMENT, FITS::NOVALUE, 0, n) : make(n, FITS::NOVALUE, 0, c))));
}
inline void FitsKeywordList::history(const char *c) {
  insert(make(FITS::HISTORY, FITS::NOVALUE, 0, c));
}
inline void FitsKeywordList::end() { insert(make(FITS::END, FITS::NOVALUE, 0, 0)); }
 
//<summary> list of read-only FITS keywords </summary>
// <reviewed reviewer="UNKNOWN" date="before2004/08/25" tests="" demos="">
// </reviewed>
 
class ConstFitsKeywordList {
 public:
  ConstFitsKeywordList(FitsKeywordList &x) : kw(x) {}
 
  const FitsKeyword *operator()(int n) { return kw(n); }
  const FitsKeyword *operator()(const FITS::ReservedName &x) { return kw(x); }
  const FitsKeyword *next(const FITS::ReservedName &x) { return kw.next(x); }
  const FitsKeyword *operator()(const FITS::ReservedName &x, int n) { return kw(x, n); }
  const FitsKeyword *next(const FITS::ReservedName &x, int n) { return kw.next(x, n); }
  const FitsKeyword *operator()(const char *x) { return kw(x); }
  const FitsKeyword *next(const char *x) { return kw.next(x); }
 
  Bool isempty() const { return kw.isempty(); }
  void first() { kw.first(); }
  void last() { kw.last(); }
  const FitsKeyword *next() { return kw.next(); }
  const FitsKeyword *prev() { return kw.prev(); }
  const FitsKeyword *curr() { return kw.curr(); }
 
 private:
  FitsKeywordList &kw;
};
 
//<summary> translator between Keyword lists and fixed FITS cars </summary>
// <reviewed reviewer="UNKNOWN" date="before2004/08/25" tests="" demos="">
// </reviewed>
//<synopsis>
// also contains the parser ???
//</synopsis>
 
class FitsKeyCardTranslator {
 public:
  FitsKeyCardTranslator(int = 100);
  ~FitsKeyCardTranslator();
  FitsKeywordList &parse(const char *, FitsKeywordList &, int, FITSErrorHandler, Bool);
  int build(char *, FitsKeywordList &);
  int no_errs() const;
  const char *err(int) const;
  int err_cardno(int) const;
  static void fmtcard(char *, const FitsKeyword &);
 
 private:
  int cardno;  // the current card number within record
  static constexpr int FitsCardSize = 80;
  static constexpr int FitsMaxCard = 36;
  static constexpr int FitsRecSize = 2880;
  int max_errs;
  int no_errs_;
  const char **err_;
  int *err_cardno_;
  char *blanks;
};
 
inline FitsKeyCardTranslator::~FitsKeyCardTranslator() {
  delete[] err_;
  delete[] err_cardno_;
  delete[] blanks;
}
inline int FitsKeyCardTranslator::no_errs() const { return no_errs_; }
inline const char *FitsKeyCardTranslator::err(int i) const { return err_[i]; }
inline int FitsKeyCardTranslator::err_cardno(int i) const { return err_cardno_[i]; }
 
// <summary>Utility functions for floating point values</summary>
// <reviewed reviewer="UNKNOWN" date="before2004/08/25" tests="" demos="">
// </reviewed>
class FitsFPUtil {
 public:
  // These functions are useful to tell if some type is a floating point type.
  // This is useful in a templated function, where the processing can vary
  // depending on whether the type is FP or not (e.g. blank handling).
  // <group>
  static Bool isFP(const float *);
  static Bool isFP(const double *);
  static Bool isFP(const void *);
  // </group>
 
  // For blanking purposes, we need to be able to get a NaN. The NaN we set
  // is all bits on.
  // <group>
  static void setNaN(double &val);
  static void setNaN(float &val);
  // </group>
};
 
}  // namespace casacore
 
#endif