/*
*class++
*  Name:
*     KeyMap

*  Purpose:
*     Store a set of key/value pairs.

*  Constructor Function:
c     astKeyMap
f     AST_KEYMAP

*  Description:
*     The KeyMap class is used to store a set of values with associated keys
*     which identify the values. The keys are strings. These may be case
*     sensitive or insensitive as selected by the KeyCase attribute, and
*     trailing spaces are ignored. The value associated with a key can be
*     integer (signed 4 and 2 byte, or unsigned 1 byte), floating point
*     (single or double precision),
c     void pointer,
*     character string or AST Object pointer. Each
*     value can be a scalar or a one-dimensional vector. A KeyMap is
*     conceptually similar to a Mapping in that a KeyMap transforms an
*     input into an output - the input is the key, and the output is the
*     value associated with the key. However, this is only a conceptual
*     similarity, and it should be noted that the KeyMap class inherits from
*     the Object class rather than the Mapping class. The methods of the
*     Mapping class cannot be used with a KeyMap.

*  Inheritance:
*     The KeyMap class inherits from the Object class.

*  Attributes:
*     In addition to those attributes common to all Objects, every
*     KeyMap also has the following attributes:
*
*     - KeyCase: Sets the case in which keys are stored
*     - KeyError: Report an error if the requested key does not exist?
*     - SizeGuess: The expected size of the KeyMap.
*     - SortBy: Determines how keys are sorted in a KeyMap.
*     - MapLocked: Prevent new entries being added to the KeyMap?

*  Functions:
c     In addition to those functions applicable to all Objects, the
c     following functions may also be applied to all KeyMaps:
f     In addition to those routines applicable to all Objects, the
f     following routines may also be applied to all KeyMaps:
*
c     - astMapCopy: Copy all entries from one KeyMap into another
c     - astMapCopyEntry: Copy a single entry from one KeyMap into another
c     - astMapDefined: Does a KeyMap contain a defined value for a key?
c     - astMapGet0<X>: Get a named scalar entry from a KeyMap
c     - astMapGet1<X>: Get a named vector entry from a KeyMap
c     - astMapGetC: Get a scalar or vector entry as a single string.
c     - astMapGetElem<X>: Get an element of a named vector entry from a KeyMap
c     - astMapHasKey: Does the KeyMap contain a named entry?
c     - astMapKey: Return the key name at a given index in the KeyMap
c     - astMapLenC: Get the length of a named character entry in a KeyMap
c     - astMapLength: Get the length of a named entry in a KeyMap
c     - astMapPut0<X>: Add a new scalar entry to a KeyMap
c     - astMapPut1<X>: Add a new vector entry to a KeyMap
c     - astMapPutElem<X>: Puts a value into a vector entry in a KeyMap
c     - astMapPutU: Add a new entry to a KeyMap with an undefined value
c     - astMapRemove: Removed a named entry from a KeyMap
c     - astMapRename: Rename an existing entry in a KeyMap
c     - astMapSize: Get the number of entries in a KeyMap
c     - astMapType: Return the data type of a named entry in a map
f     - AST_MAPCOPY: Copy all entries from one KeyMap into another
f     - AST_MAPCOPYENTRY: Copy a single entry from one KeyMap into another
f     - AST_MAPDEFINED: Does a KeyMap contain a defined value for a key?
f     - AST_MAPGET0<X>: Get a named scalar entry from a KeyMap
f     - AST_MAPGET1<X>: Get a named vector entry from a KeyMap
f     - AST_MAPGETC: Get a scalar or vector entry as a single string.
f     - AST_MAPGETELEM<X>: Get an element of a named vector entry from a KeyMap
f     - AST_MAPHASKEY: Does the KeyMap contain a named entry?
f     - AST_MAPKEY: Return the key name at a given index in the KeyMap
f     - AST_MAPLENC: Get the length of a named character entry in a KeyMap
f     - AST_MAPLENGTH: Get the length of a named entry in a KeyMap
f     - AST_MAPPUT0<X>: Add a new scalar entry to a KeyMap
f     - AST_MAPPUT1<X>: Add a new vector entry to a KeyMap
f     - AST_MAPPUTELEM<X>: Puts a value into a vector entry in a KeyMap
f     - AST_MAPPUTU: Add a new entry to a KeyMap with an undefined value
f     - AST_MAPREMOVE: Removed a named entry from a KeyMap
f     - AST_MAPRENAME: Rename an existing entry in a KeyMap
f     - AST_MAPSIZE: Get the number of entries in a KeyMap
f     - AST_MAPTYPE: Return the data type of a named entry in a map

*  Copyright:
*     Copyright (C) 1997-2006 Council for the Central Laboratory of the
*     Research Councils
*     Copyright (C) 2008-2010 Science & Technology Facilities Council.
*     All Rights Reserved.

*  Licence:
*     This program is free software: you can redistribute it and/or
*     modify it under the terms of the GNU Lesser General Public
*     License as published by the Free Software Foundation, either
*     version 3 of the License, or (at your option) any later
*     version.
*
*     This program 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 Lesser General Public License for more details.
*
*     You should have received a copy of the GNU Lesser General
*     License along with this program.  If not, see
*     <http://www.gnu.org/licenses/>.

*  Authors:
*     DSB: B.S. Berry (Starlink)

*  History:
*     12-NOV-2004 (DSB):
*        Original version.
*     5-JAN-2005 (DSB):
*        Added astMapLenC method.
*     17-JAN-2005 (DSB):
*        Remove "void *" arithmetic.
*     25-JAN-2005 (DSB):
*        Added more DEBUG blocks
*     30-SEP-2005 (DSB):
*        Allow an integer to be read from a formatted floating point value.
*     6-DEC-2005 (DSB):
*        Remove astMapGet0C stuff from description of astMapGet1C.
*     14-FEB-2006 (DSB):
*        Override astGetObjSize.
*     1-MAR-2006 (DSB):
*        Replace astSetPermMap within DEBUG blocks by astBeginPM/astEndPM.
*     5-JUN-2006 (DSB):
*        Added support for single precision entries.
*     30-NOV-2007 (DSB):
*        Added SizeGuess attribute.
*     4-DEC-2007 (DSB):
*        Allow size of hash table to grow dynamically as more entries are
*        added to the KeyMap.
*     5-DEC-2007 (DSB):
*        Ensure mapsize is always a power of 2.
*     6-DEC-2007 (DSB):
*        - Define the minium table size rather than the default SizeGuess
*        value, and derive the default SizeGuess value from the minimum
*        table size.
*        - Use "&" rather than "%" to get the hash table index from the
*        full width hash value (& may be faster than %).
*     7-MAR-2008 (DSB):
*         Added support for pointer ("P") entries.
*     31-MAR-2009 (DSB):
*         Remove rounding errors from formatted double values.
*     27-APR-2009 (DSB):
*         Added astMapGetElem<X>.
*     1-SEP-2009 (DSB):
*         Added KeyError attribute.
*     12-FEB-2010 (DSB):
*         When converting an entry value between double and string, treat
*         "<bad>" as the formatted version of AST__BAD.
*     3-MAR-2010 (DSB):
*         Added astMapPutElem<X>.
*     27-APR-2010 (DSB):
*         Added MapLocked attribute.
*     4-MAY-2010 (DSB):
*         - Propagate MapLocked and KeyError attributes to any encapsulated
*         KeyMaps.
*         - Added astMapCopy method.
*         - Added astMapPutU method and AST__UNDEFTYPE data type.
*     11-AUG-2010 (DSB):
*        Added SortBy attribute.
*     12-AUG-2010 (DSB):
*        Speed up access to large KeyMaps.
*     13-AUG-2010 (DSB):
*        - No need to sort all entries when doubling the table size since
*        changing the table size does not change the linked list of sorted
*        entries.
*        - Initialise the sortby attribute to the cleared value, rather
*        than the default value.
*     2-OCT-2010 (DSB):
*        Added support for short int valued entries.
*     24-NOV-2010 (DSB):
*        Fix memory leak in astMapPutElemC and astMapPutElemA.
*     26-NOV-2010 (DSB):
*        Added support for unsigned byte valued entries.
*     3-DEC-2010 (DSB):
*         Added KeyCase attribute.
*     14-JAN-2011 (DSB):
*         Fix bug that prevented zero length strings being stored in a
*         keymap.
*     17-SEP-2012 (DSB):
*         Fix bug that prevented UNDEF entries from being read back in
*         from a dump of a KeyMap.
*     18-MAR-2013 (DSB):
*         Added astMapDefined.
*     18-JUL-2013 (DSB):
*         Added SortBy options "KeyAgeUp" and "KeyAgeDown".
*     9-SEP-2016 (DSB):
*         Guard against memory corruption that could occur after making
*         50 (AST__KEYMAP_CONVERTVALUE_MAX_STRINGS) calls to put a string
*         into a KeyMap using astMapPutElemC.
*     16-MAR-2017 (DSB):
*         Added astMapGetC.
*     12-JUN-2020 (DSB):
*         Added astMapCopyEntry.
*     5-OCT-2020 (DSB):
*         - Move definition of string used to represent AST__BAD values from here
*         (BAD_STRING) to keymap.h (AST__BAD_STRING) so that it can be used in
*         other classes.
*         - Conversion of double to string now uses AST__DBL_DIG decimal places rather
*         than DBL_DIG. This typically gives two extra decimal places. This brings the
*         formatting done within the KeyMap class into line with the formatting done
*         in the Channel class.
*         - The astShow and astWrite methods can now be used on KeyMaps that contain
*         "void pointer" entries. The value shown is the haxadecimal address represented
*         by the pointer and thus will be of little value outside the running application.
*         - A context message including the key name is now reported if an error occurs
*         when freeing a keymap entry.
*         - Fix a bug in astMapKey that caused a good key to be returned even if the supplied
*         index was higher than the number of entries in the keymap.
*     27-MAY-2021 (DSB):
*         Modify astMapGet1<X> so that nval=0 is returned if the value is
*         undefined.
*class--
*/

/* Module Macros. */
/* ============== */
/* Set the name of the class we are implementing. This indicates to
   the header files that define class interfaces that they should make
   "protected" symbols available. */
#define astCLASS KeyMap

/* Minimum size for the hash table. */
#define MIN_TABLE_SIZE 16

/* The maximum number of entries per element of the hash table. If this
   value is exceeded the hash table will be doubled in size. */
#define MAX_ENTRIES_PER_TABLE_ENTRY 10

/* Integer values to represent the different values of the SortBy attribute. */
#define SORTBY_NONE 0
#define SORTBY_AGEUP 1
#define SORTBY_AGEDOWN 2
#define SORTBY_KEYUP 3
#define SORTBY_KEYDOWN 4
#define SORTBY_KEYAGEUP 5
#define SORTBY_KEYAGEDOWN 6


/* Include files. */
/* ============== */
/* Interface definitions. */
/* ---------------------- */

#include "globals.h"             /* Thread-safe global data access */
#include "error.h"               /* Error reporting facilities */
#include "memory.h"              /* Memory management facilities */
#include "object.h"              /* Base Object class */
#include "pointset.h"            /* For AST__BAD */
#include "channel.h"             /* I/O channels */
#include "keymap.h"              /* Interface definition for this class */
#include "globals.h"             /* Thread-safe global data access */

/* Error code definitions. */
/* ----------------------- */
#include "ast_err.h"             /* AST error codes */

/* C header files. */
/* --------------- */
#include <limits.h>
#include <stdarg.h>
#include <stddef.h>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <stdint.h>
#include <inttypes.h>

/* Type Definitions */
/* ================ */

/* This structure is a AstMapEntry holding a scalar int */
typedef struct Entry0I {
   struct AstMapEntry entry; /* The parent Entry information */
   int value;                /* The integer value */
} Entry0I;

/* This structure is a AstMapEntry holding a scalar double */
typedef struct Entry0D {
   struct AstMapEntry entry; /* The parent Entry information */
   double value;             /* The floating point value */
} Entry0D;

/* This structure is a AstMapEntry holding a scalar short int */
typedef struct Entry0S {
   struct AstMapEntry entry; /* The parent Entry information */
   short int value;          /* The short int value */
} Entry0S;

/* This structure is a AstMapEntry holding a scalar 64 bit int */
typedef struct Entry0K {
   struct AstMapEntry entry; /* The parent Entry information */
   int64_t value;          /* The short int value */
} Entry0K;

/* This structure is a AstMapEntry holding a scalar unsigned byte
   (unsigned char) */
typedef struct Entry0B {
   struct AstMapEntry entry; /* The parent Entry information */
   unsigned char value;      /* The byte value */
} Entry0B;

/* This structure is a AstMapEntry holding a scalar float */
typedef struct Entry0F {
   struct AstMapEntry entry; /* The parent Entry information */
   float value;              /* The floating point value */
} Entry0F;

/* This structure is a AstMapEntry holding a scalar string */
typedef struct Entry0C {
   struct AstMapEntry entry; /* The parent Entry information */
   const char *value;        /* The string pointer */
} Entry0C;

/* This structure is a AstMapEntry holding a scalar AST Object */
typedef struct Entry0A {
   struct AstMapEntry entry; /* The parent Entry information */
   AstObject *value;         /* The Object pointer */
   struct AstMapEntry *next; /* Pointer to next AST Object entry */
   struct AstMapEntry *prev; /* Pointer to previous AST Object entry */
} Entry0A;

/* This structure is a AstMapEntry holding a scalar void pointer */
typedef struct Entry0P {
   struct AstMapEntry entry; /* The parent Entry information */
   void *value;              /* The pointer */
} Entry0P;

/* This structure is a AstMapEntry holding a 1D array of ints */
typedef struct Entry1I {
   struct AstMapEntry entry; /* The parent Entry information */
   int *value;               /* The integer values */
} Entry1I;

/* This structure is a AstMapEntry holding a 1D array of doubles */
typedef struct Entry1D {
   struct AstMapEntry entry; /* The parent Entry information */
   double *value;            /* The floating point values */
} Entry1D;

/* This structure is a AstMapEntry holding a 1D array of short ints */
typedef struct Entry1S {
   struct AstMapEntry entry; /* The parent Entry information */
   short int *value;         /* The 64 bit int values */
} Entry1S;

/* This structure is a AstMapEntry holding a 1D array of 64 bit ints */
typedef struct Entry1K {
   struct AstMapEntry entry; /* The parent Entry information */
   int64_t *value;           /* The 64 bit int values */
} Entry1K;

/* This structure is a AstMapEntry holding a 1D array of unsigned bytes */
typedef struct Entry1B {
   struct AstMapEntry entry; /* The parent Entry information */
   unsigned char *value;     /* The byte values */
} Entry1B;

/* This structure is a AstMapEntry holding a 1D array of floats */
typedef struct Entry1F {
   struct AstMapEntry entry; /* The parent Entry information */
   float *value;             /* The floating point values */
} Entry1F;

/* This structure is a AstMapEntry holding a 1D array of strings */
typedef struct Entry1C {
   struct AstMapEntry entry; /* The parent Entry information */
   const char **value;       /* The string pointers */
} Entry1C;

/* This structure is a AstMapEntry holding a 1D array of AST Objects */
typedef struct Entry1A {
   struct AstMapEntry entry; /* The parent Entry information */
   AstObject **value;        /* The Object pointers */
   struct AstMapEntry *next; /* Pointer to next AST Object entry */
   struct AstMapEntry *prev; /* Pointer to previous AST Object entry */
} Entry1A;

/* This structure is a AstMapEntry holding a 1D array of void pointers. */
typedef struct Entry1P {
   struct AstMapEntry entry; /* The parent Entry information */
   void **value;             /* The pointers */
} Entry1P;


/* Module Variables. */
/* ================= */

/* Address of this static variable is used as a unique identifier for
   member of this class. */
static int class_check;

/* Pointers to parent class methods which are extended by this class. */
static size_t (* parent_getobjsize)( AstObject *, int * );
static const char *(* parent_getattrib)( AstObject *, const char *, int * );
static int (* parent_testattrib)( AstObject *, const char *, int * );
static void (* parent_clearattrib)( AstObject *, const char *, int * );
static void (* parent_setattrib)( AstObject *, const char *, int * );

#if defined(THREAD_SAFE)
static int (* parent_managelock)( AstObject *, int, int, AstObject **, int * );
#endif

/* Define macros for accessing each item of thread specific global data. */
#ifdef THREAD_SAFE

/* Define how to initialise thread-specific globals. */
#define GLOBAL_inits \
   globals->Class_Init = 0; \
   globals->GetAttrib_Buff[ 0 ] = 0; \
   globals->ConvertValue_Init = 0; \
   globals->ConvertValue_Istr = 0; \
   globals->ConvertValue_Buff[ 0 ] = 0; \
   globals->MapKey_Init = 0; \
   globals->MapKey_Istr = 0;

/* Create the function that initialises global data for this module. */
astMAKE_INITGLOBALS(KeyMap)

/* Define macros for accessing each item of thread specific global data. */
#define class_init astGLOBAL(KeyMap,Class_Init)
#define class_vtab astGLOBAL(KeyMap,Class_Vtab)
#define getattrib_buff astGLOBAL(KeyMap,GetAttrib_Buff)
#define convertvalue_strings astGLOBAL(KeyMap,ConvertValue_Strings)
#define convertvalue_istr astGLOBAL(KeyMap,ConvertValue_Istr)
#define convertvalue_init astGLOBAL(KeyMap,ConvertValue_Init)
#define convertvalue_buff astGLOBAL(KeyMap,ConvertValue_Buff)
#define mapkey_strings astGLOBAL(KeyMap,MapKey_Strings)
#define mapkey_istr astGLOBAL(KeyMap,MapKey_Istr)
#define mapkey_init astGLOBAL(KeyMap,MapKey_Init)



/* If thread safety is not needed, declare and initialise globals at static
   variables. */
#else

/* Buffer returned by GetAttrib. */ \
static char getattrib_buff[ AST__KEYMAP_GETATTRIB_BUFF_LEN + 1 ];

/* Strings returned by ConvertValue */ \
static char *convertvalue_strings[ AST__KEYMAP_CONVERTVALUE_MAX_STRINGS ];

/* Offset of next string in "ConvertValue_Strings" */ \
static int convertvalue_istr;

/* "ConvertValue_Strings" array initialised? */ \
static int convertvalue_init;

/* ConvertValue string buffer */ \
static char convertvalue_buff[ AST__KEYMAP_CONVERTVALUE_BUFF_LEN + 1 ];

/* Strings returned by MapKey */ \
static char *mapkey_strings[ AST__KEYMAP_MAPKEY_MAX_STRINGS ];

/* Offset of next string in "MapKey_Strings" */ \
static int mapkey_istr;

/* "MapKey_Strings" array initialised? */ \
static int mapkey_init;


/* Define the class virtual function table and its initialisation flag
   as static variables. */
static AstKeyMapVtab class_vtab;   /* Virtual function table */
static int class_init = 0;         /* Virtual function table initialised? */

#endif

/* External Interface Function Prototypes. */
/* ======================================= */
/* The following functions have public prototypes only (i.e. no
   protected prototypes), so we must provide local prototypes for use
   within this module. */
AstKeyMap *astKeyMapId_( const char *, ... );

/* Prototypes for Private Member Functions. */
/* ======================================== */
static AstMapEntry *AddTableEntry( AstKeyMap *, int, AstMapEntry *, int, int * );
static AstMapEntry *CopyMapEntry( AstMapEntry *, int * );
static AstMapEntry *FreeMapEntry( AstMapEntry *, int * );
static AstMapEntry *RemoveTableEntry( AstKeyMap *, int, const char *, int * );
static AstMapEntry *SearchTableEntry( AstKeyMap *, int, const char *, int * );
static const char *ConvertKey( AstKeyMap *, const char *, char *, int, const char *, int * );
static const char *GetKey( AstKeyMap *, int index, int * );
static const char *MapIterate( AstKeyMap *, int, int * );
static const char *MapKey( AstKeyMap *, int index, int * );
static const char *SortByString( int, const char *, int * );
static int CompareEntries( const void *, const void * );
static int ConvertValue( void *, int, void *, int, int * );
static size_t GetObjSize( AstObject *, int * );
static int HashFun( const char *, int, unsigned long *, int * );
static int KeyCmp( const char *, const char * );
static int MapDefined( AstKeyMap *, const char *, int * );
static int MapGet0A( AstKeyMap *, const char *, AstObject **, int * );
static int MapGet0C( AstKeyMap *, const char *, const char **, int * );
static int MapGet0D( AstKeyMap *, const char *, double *, int * );
static int MapGet0S( AstKeyMap *, const char *, short int *, int * );
static int MapGet0B( AstKeyMap *, const char *, unsigned char *, int * );
static int MapGet0F( AstKeyMap *, const char *, float *, int * );
static int MapGet0I( AstKeyMap *, const char *, int *, int * );
static int MapGet0K( AstKeyMap *, const char *, int64_t *, int * );
static int MapGet0P( AstKeyMap *, const char *, void **, int * );
static int MapGet1A( AstKeyMap *, const char *, int, int *, AstObject **, int * );
static int MapGet1C( AstKeyMap *, const char *, int, int, int *, char *, int * );
static int MapGet1D( AstKeyMap *, const char *, int, int *, double *, int * );
static int MapGet1B( AstKeyMap *, const char *, int, int *, unsigned char *, int * );
static int MapGet1S( AstKeyMap *, const char *, int, int *, short int *, int * );
static int MapGet1F( AstKeyMap *, const char *, int, int *, float *, int * );
static int MapGet1I( AstKeyMap *, const char *, int, int *, int *, int * );
static int MapGet1K( AstKeyMap *, const char *, int, int *, int64_t *, int * );
static int MapGet1P( AstKeyMap *, const char *, int, int *, void **, int * );
static int MapGetC( AstKeyMap *, const char *, const char **, int * );
static int MapGetElemA( AstKeyMap *, const char *, int, AstObject **, int * );
static int MapGetElemC( AstKeyMap *, const char *, int, int, char *, int * );
static int MapGetElemD( AstKeyMap *, const char *, int, double *, int * );
static int MapGetElemB( AstKeyMap *, const char *, int, unsigned char *, int * );
static int MapGetElemS( AstKeyMap *, const char *, int, short int *, int * );
static int MapGetElemF( AstKeyMap *, const char *, int, float *, int * );
static int MapGetElemI( AstKeyMap *, const char *, int, int *, int * );
static int MapGetElemK( AstKeyMap *, const char *, int, int64_t *, int * );
static int MapGetElemP( AstKeyMap *, const char *, int, void **, int * );
static int MapHasKey( AstKeyMap *, const char *, int * );
static int MapLenC( AstKeyMap *, const char *, int * );
static int MapLength( AstKeyMap *, const char *, int * );
static int MapSize( AstKeyMap *, int * );
static int MapType( AstKeyMap *, const char *, int * );
static int SortByInt( const char *, const char *, int * );
static size_t SizeOfEntry( AstMapEntry *, int * );
static void AddToObjectList( AstKeyMap *, AstMapEntry *, int * );
static void AddToSortedList( AstKeyMap *, AstMapEntry *, int * );
static void CheckCircle( AstKeyMap *, AstObject *, const char *, int * );
static void Copy( const AstObject *, AstObject *, int * );
static void CopyTableEntry( AstKeyMap *, AstKeyMap *, int, int * );
static void Delete( AstObject *, int * );
static void DoubleTableSize( AstKeyMap *, int * );
static void Dump( AstObject *, AstChannel *, int * );
static void DumpEntry( AstMapEntry *, AstChannel *, int, int * );
static void FreeTableEntry( AstKeyMap *, int itab, int * );
static void InitMapEntry( AstMapEntry *, int, int, int * );
static void MapCopy( AstKeyMap *, AstKeyMap *, int * );
static void MapCopyEntry( AstKeyMap *, const char *, AstKeyMap *, int, int * );
static void MapPut0A( AstKeyMap *, const char *, AstObject *, const char *, int * );
static void MapPut0C( AstKeyMap *, const char *, const char *, const char *, int * );
static void MapPut0D( AstKeyMap *, const char *, double, const char *, int * );
static void MapPut0B( AstKeyMap *, const char *, unsigned char, const char *, int * );
static void MapPut0S( AstKeyMap *, const char *, short int, const char *, int * );
static void MapPut0K( AstKeyMap *, const char *, int64_t, const char *, int * );
static void MapPut0F( AstKeyMap *, const char *, float, const char *, int * );
static void MapPut0I( AstKeyMap *, const char *, int, const char *, int * );
static void MapPut0P( AstKeyMap *, const char *, void *, const char *, int * );
static void MapPut1A( AstKeyMap *, const char *, int, AstObject *const [], const char *, int * );
static void MapPut1C( AstKeyMap *, const char *, int, const char *const [], const char *, int * );
static void MapPut1D( AstKeyMap *, const char *, int, const double *, const char *, int * );
static void MapPut1B( AstKeyMap *, const char *, int, const unsigned char *, const char *, int * );
static void MapPut1S( AstKeyMap *, const char *, int, const short int *, const char *, int * );
static void MapPut1K( AstKeyMap *, const char *, int, const int64_t *, const char *, int * );
static void MapPut1F( AstKeyMap *, const char *, int, const float *, const char *, int * );
static void MapPut1I( AstKeyMap *, const char *, int, const int *, const char *, int * );
static void MapPut1P( AstKeyMap *, const char *, int, void *const [], const char *, int * );
static void MapPutElemA( AstKeyMap *, const char *, int, AstObject *, int * );
static void MapPutElemC( AstKeyMap *, const char *, int, const char *, int * );
static void MapPutElemD( AstKeyMap *, const char *, int, double, int * );
static void MapPutElemB( AstKeyMap *, const char *, int, unsigned char, int * );
static void MapPutElemS( AstKeyMap *, const char *, int, short int, int * );
static void MapPutElemK( AstKeyMap *, const char *, int, int64_t, int * );
static void MapPutElemF( AstKeyMap *, const char *, int, float, int * );
static void MapPutElemI( AstKeyMap *, const char *, int, int, int * );
static void MapPutElemP( AstKeyMap *, const char *, int, void *, int * );
static void MapPutU( AstKeyMap *, const char *, const char *, int * );
static void MapRemove( AstKeyMap *, const char *, int * );
static void MapRename( AstKeyMap *, const char *, const char *, int * );
static void NewTable( AstKeyMap *, int, int * );
static void RemoveFromSortedList( AstKeyMap *, AstMapEntry *, int * );
static void RemoveFromObjectList( AstKeyMap *, AstMapEntry *, int * );
static void SortEntries( AstKeyMap *, int * );

static const char *GetAttrib( AstObject *, const char *, int * );
static int TestAttrib( AstObject *, const char *, int * );
static void ClearAttrib( AstObject *, const char *, int * );
static void SetAttrib( AstObject *, const char *, int * );

static int GetSizeGuess( AstKeyMap *, int * );
static int TestSizeGuess( AstKeyMap *, int * );
static void ClearSizeGuess( AstKeyMap *, int * );
static void SetSizeGuess( AstKeyMap *, int, int * );

static int GetSortBy( AstKeyMap *, int * );
static int TestSortBy( AstKeyMap *, int * );
static void ClearSortBy( AstKeyMap *, int * );
static void SetSortBy( AstKeyMap *, int, int * );

static int GetKeyError( AstKeyMap *, int * );
static int TestKeyError( AstKeyMap *, int * );
static void ClearKeyError( AstKeyMap *, int * );
static void SetKeyError( AstKeyMap *, int, int * );

static int GetKeyCase( AstKeyMap *, int * );
static int TestKeyCase( AstKeyMap *, int * );
static void ClearKeyCase( AstKeyMap *, int * );
static void SetKeyCase( AstKeyMap *, int, int * );

static int GetMapLocked( AstKeyMap *, int * );
static int TestMapLocked( AstKeyMap *, int * );
static void ClearMapLocked( AstKeyMap *, int * );
static void SetMapLocked( AstKeyMap *, int, int * );

#if defined(THREAD_SAFE)
static int ManageLock( AstObject *, int, int, AstObject **, int * );
#endif

/* Member functions. */
/* ================= */
static AstMapEntry *AddTableEntry( AstKeyMap *this, int itab,
                                   AstMapEntry *entry, int keymember,
                                   int *status ){
/*
*  Name:
*     AddTableEntry

*  Purpose:
*     Add an new entry to a linked-list of KeyMap entries.

*  Type:
*     Private function.

*  Synopsis:
*     #include "keymap.h"
*     AstMapEntry *AddTableEntry( AstKeyMap *this, int itab,
*                                 AstMapEntry *entry, int keymember,
*                                 int *status ){

*  Class Membership:
*     KeyMap member function.

*  Description:
*     This function adds the supplied MapEntry to the head of the linked
*     list of MapEntries stored at the specified entry of the hash table.
*     If this results in the linked list having too many entries, then a
*     new larger hash table is allocated and the entries in the existing
*     table are moved into the new table.

*  Parameters:
*     this
*        Pointer to the KeyMap.
*     itab
*        Index of the hash table element to be searched.
*     entry
*        Pointer to the MapEntry to be added.
*     keymember
*        A unique integer identifier for the key that increases
*        monotonically with age of the key. If this is negative,
*        the next available identifier will be used automatically.
*     status
*        Pointer to the inherited status variable.

*  Returned Value:
*     A NULL pointer.

*/

/* Check the global error status. */
   if ( !astOK ) return NULL;

/* Put a pointer to the MapEntry which is currently at the head of the
   linked list in the "next" component of the supplied MapEntry. */
   entry->next = this->table[ itab ];

/* Store the supplied MapEntry pointer in the requested element of the
   hash table. */
   this->table[ itab ] = entry;

/* Increment the length of linked list. */
   this->nentry[ itab ]++;

/* Each new entry added to the KeyMap has a unique member index that is
   never re-used. */
   entry->member = (this->member_count)++;

/* Each key added to the  KeyMap also has a separate unique member index,
   but this index is re-used each time the same key is added into the
   KeyMap. So changing the value associated with a key does not cause the
   keymember value to change. */
   if( keymember >= 0 ) {
      entry->keymember = keymember;
   } else {
      entry->keymember = (this->member_count)++;
   }

/* Insert the supplied MapEntry into a list sorted by key. */
   AddToSortedList( this, entry, status );

/* If the entry is of type AST__OBJECTTYPE, add it to the head of the
   list of AST__OBJECTTYPE entries in the KeyMap. */
   AddToObjectList( this, entry, status );

/* If the population of this table entry is now too large, double the size
   of the table, moving the table entries to appropriate places in the
   new larger table. */
   if( this->nentry[ itab ] > MAX_ENTRIES_PER_TABLE_ENTRY ) {
      DoubleTableSize( this, status );
   }

/* Return a NULL pointer. */
   return NULL;
}

static void AddToObjectList( AstKeyMap *this, AstMapEntry *entry, int *status ){
/*
*  Name:
*     AddToObjectList

*  Purpose:
*     Add AST__OBJECTTYPE entries into a linked-list of such entries.

*  Type:
*     Private function.

*  Synopsis:
*     #include "keymap.h"
*     void AddToObjectList( AstKeyMap *this, AstMapEntry *entry, int *status )

*  Class Membership:
*     KeyMap member function.

*  Description:
*     If the supplied MapEntry holds one or more pointers to AST Objects,
*     then the entry is added to a linked list of such entries.

*  Parameters:
*     this
*        Pointer to the KeyMap.
*     entry
*        Pointer to the MapEntry to be added.
*     status
*        Pointer to the inherited status variable.

*/

/* Local Variables: */
   Entry0A *scalar;         /* Pointer to a scalar AST__OBJECTTYPE entry */
   Entry1A *vector;         /* Pointer to a vector AST__OBJECTTYPE entry */

/* Check the global error status. */
   if ( !astOK ) return;

/* Do nothing if the entry does not hold AST Object pointers. */
   if( entry->type == AST__OBJECTTYPE ) {

/* If the list is not currently empty, add the new entry into the list. */
      if( this->firstA ) {

/* Store a pointer to the new entry as the previous link in the current
   first entry in the list. */
         if( this->firstA->nel == 0 ) {
            scalar = (Entry0A *) this->firstA;
            scalar->prev = entry;
         } else {
            vector = (Entry1A *) this->firstA;
            vector->prev = entry;
         }

/* Store a pointer to the current first entry as the next link in the new
   entry, and nullify the previus link. */
         if( entry->nel == 0 ) {
            scalar = (Entry0A *) entry;
            scalar->next = this->firstA;
            scalar->prev = NULL;
         } else {
            vector = (Entry1A *) entry;
            vector->next = this->firstA;
            vector->prev = NULL;
         }

/* If the list is currently empty, nullify both links in the entry. */
      } else {
         if( entry->nel == 0 ) {
            scalar = (Entry0A *) entry;
            scalar->next = NULL;
            scalar->prev = NULL;
         } else {
            vector = (Entry1A *) entry;
            vector->next = NULL;
            vector->prev = NULL;
         }

      }

/* Store the new entry as the first entry. */
      this->firstA = entry;
   }
}

static void AddToSortedList( AstKeyMap *this, AstMapEntry *entry, int *status ){
/*
*  Name:
*     AddToSortedList

*  Purpose:
*     Add an entry into the linked-list of sorted KeyMap entries.

*  Type:
*     Private function.

*  Synopsis:
*     #include "keymap.h"
*     void AddToSortedList( AstKeyMap *this, AstMapEntry *entry, int *status )

*  Class Membership:
*     KeyMap member function.

*  Description:
*     This function adds the supplied MapEntry into the linked list of
*     sorted MapEntries at a position that maintains the sorted order.

*  Parameters:
*     this
*        Pointer to the KeyMap.
*     entry
*        Pointer to the MapEntry to be added.
*     status
*        Pointer to the inherited status variable.

*/

/* Local Variables: */
   AstMapEntry *hi;         /* MapEntry at high end of current range */
   AstMapEntry *lo;         /* MapEntry at low end of current range */
   AstMapEntry *mid;        /* MapEntry at middle of current range */
   int cmp;                 /* Result of comparing two entries */
   int istep;               /* Step counter */
   int nstep;               /* Number of entries in current range */
   int sortby;              /* How to sort the keys */

/* Check the global error status. */
   if ( !astOK ) return;

/* Get the SortBy value. */
   sortby = astGetSortBy( this );

/* Do nothing if no sorting is required. */
   if( sortby != SORTBY_NONE ) {

/* Get pointers to the entries at the start and end of the sorted list. */
      lo = this->first;
      hi = lo ? lo->sprev : NULL;

/* Store sortby value in the mapentry structures. */
      if( lo ) lo->sortby = sortby;
      if( hi ) hi->sortby = sortby;
      entry->sortby = sortby;

/* If the sorted list is empty, just store the supplied entry at the
   head, and set the links to point back to itself. */
      if( !lo ) {
         this->first = entry;
         entry->sprev = entry;
         entry->snext = entry;

/* If the new entry comes before the first entry or is equal to the first
   entry, record it as the new first entry, and insert it into the linked
   list before the original first entry. */
      } else if( CompareEntries( &entry, &lo ) <= 0 ) {
         this->first = entry;
         entry->snext = lo;
         entry->sprev = hi;
         lo->sprev = entry;
         hi->snext = entry;

/* If the new entry comes after the last entry or is equal to the last
   entry, insert it into the linked list after the last entry. */
      } else if( CompareEntries( &entry, &hi ) >= 0 ) {
         entry->snext = lo;
         entry->sprev = hi;
         lo->sprev = entry;
         hi->snext = entry;

/* If the list only contains two values, insert the new entry into the linked
   list between the existing two entries. */
      } else if( lo->snext == hi ) {
         entry->snext = hi;
         entry->sprev = lo;
         lo->snext = entry;
         hi->sprev = entry;

/* Otherwise we do a binary chop within the existing sorted list to find the
   correct position for the new entry. */
      } else {

/* Get a pointer to the entry mid way between the hi and lo entries. The
   mid entry will be on the upper side of half way if there are an even
   number of entries. */
         nstep = this->nsorted/2;
         mid = lo;
         for( istep = 0; istep < nstep; istep++ ) mid = mid->snext;

/* Loop until we have a pointer to the first entry which is equal to or
   higher than the new entry. */
         while( lo->snext != hi ) {

/* The next step will be half the length of the previous step. Do not
   allow the step size to fall to zero. */
            nstep = ( nstep > 1 ) ? nstep/2 : 1;

/* Compare the new entry with the current mid-way entry. */
            mid->sortby = sortby;
            cmp = CompareEntries( &entry, &mid );

/* If the new entry comes before the mid entry, use the mid entry as the
   next hi entry, and go down the list by the new step size to find the
   new mid-way entry. */
            if( cmp < 0 ) {
               hi = mid;
               for( istep = 0; istep < nstep; istep++ ) mid = mid->sprev;

/* If the new entry comes after the mid entry, use the mid entry as the
   next lo entry, and go up the list by the new step size to find the
   new mid-way entry. */
            } else if( cmp > 0 ) {
               lo = mid;
               for( istep = 0; istep < nstep; istep++ ) mid = mid->snext;

/* If the new entry is equal to the mid entry, use the mid entry as hi
   and set lo to the previous entry. This causes the loop to quit. */
            } else {
               hi = mid;
               lo = mid->sprev;
            }
         }

/* Insert the new entry into the list between lo and hi. */
         entry->sprev = lo;
         entry->snext = hi;
         lo->snext = entry;
         hi->sprev = entry;
      }

/* Increment the number of entries in the sorted list. */
      (this->nsorted)++;
   }
}

static void CheckCircle( AstKeyMap *this, AstObject *obj, const char *method, int *status ) {
/*
*  Name:
*     CheckCircle

*  Purpose:
*     Check for circular dependencies between KeyMaps.

*  Type:
*     Private function.

*  Synopsis:
*     #include "keymap.h"
*     void CheckCircle( AstKeyMap *this, AstObject *obj, const char *method, int *status )

*  Class Membership:
*     KeyMap member function.

*  Description:
*     This function checks that the given AstObject is not a KeyMap which
*     contains "this". If it is, an error is reported.

*  Parameters:
*     this
*        The KeyMap pointer.
*     obj
*        Pointer to the AstObject to be inserted into the KeyMap, or NULL.
*     method
*        Name of method to include in error messages.
*     status
*        Pointer to the inherited status variable.

*/

/* Local Variables: */
   AstKeyMap *keymap;       /* The KeyMap being added to "this" */
   AstObject **vec;         /* Pointer to list of AstObject pointers */
   const char *key;         /* The i'th key within second KeyMap */
   int i;                   /* Index of entry within second KeyMap */
   int j;                   /* Index within the vector of values */
   int len;                 /* No. of AST pointers stored in the entry */
   int nkey;                /* No. of entries in the second KeyMap */

/* Check the global error status. */
   if( !astOK ) return;

/* Return if the AstObject is not a KeyMap. */
   if( obj && astIsAKeyMap( obj ) ) {
      keymap = (AstKeyMap *) obj;

/* First check if the supplied Objects are the same. You cannot store a
   KeyMap as an entry within itself. */
      if( keymap == this ) {
         astError( AST__KYCIR, "%s(%s): Cannot add a %s into another "
                   "%s because they are same %s.", status, method,
                   astGetClass( this ), astGetClass( this ),
                   astGetClass( this ), astGetClass( this ) );

/* Otherwise, loop through all the entries in the KeyMap looking for AstObject
   entries. */
      } else {
         nkey = astMapSize( keymap );
         for( i = 0; i < nkey && astOK; i++ ) {
            key = astMapKey( keymap, i );
            if( astMapType( keymap, key ) == AST__OBJECTTYPE ) {

/* Find the number of AstObject pointers stored in this entry, and
   allocate memory to store a copy of the every pointer. */
               len = astMapLength( keymap, key );
               vec = astMalloc( sizeof( AstObject *) * len );
               if( vec ) {

/* Extract pointers to the AstObjects at this entry, and loop round them. */
                  astMapGet1A( keymap, key, len, &len, vec );
                  for( j = 0; j < len; j++ ) {

/* If this entry is a KeyMap, we need to check if is the same as "this"
   or contains "this". */
                     if( astIsAKeyMap( vec[ j ] ) ) {

/* If it is the same as "this", report an error. */
                        if( vec[ j ] == (AstObject *) this ) {
                           astError( AST__KYCIR, "%s(%s): Cannot add a KeyMap "
                                     "into another KeyMap because the first "
                                     "KeyMap contains the second KeyMap.", status,
                                     method, astGetClass( this ) );
                           break;

/* Otherwise, see if it contains "this". */
                        } else {
                           CheckCircle( this, vec[ j ], method, status );
                        }
                     }

/* Free resources. */
                     vec[ j ] = astAnnul( vec[ j ] );
                  }
                  vec = astFree( vec );
               }
            }
         }
      }
   }
}

static void ClearAttrib( AstObject *this_object, const char *attrib, int *status ) {
/*
*  Name:
*     ClearAttrib

*  Purpose:
*     Clear an attribute value for a KeyMap.

*  Type:
*     Private function.

*  Synopsis:
*     #include "keymap.h"
*     void ClearAttrib( AstObject *this, const char *attrib, int *status )

*  Class Membership:
*     KeyMap member function (over-rides the astClearAttrib protected
*     method inherited from the Mapping class).

*  Description:
*     This function clears the value of a specified attribute for a
*     KeyMap, so that the default value will subsequently be used.

*  Parameters:
*     this
*        Pointer to the KeyMap.
*     attrib
*        Pointer to a null-terminated string specifying the attribute
*        name.  This should be in lower case with no surrounding white
*        space.
*     status
*        Pointer to the inherited status variable.
*/

/* Local Variables: */
   AstKeyMap *this;             /* Pointer to the KeyMap structure */

/* Check the global error status. */
   if ( !astOK ) return;

/* Obtain a pointer to the KeyMap structure. */
   this = (AstKeyMap *) this_object;

/* Check the attribute name and clear the appropriate attribute. */

/* SizeGuess. */
/* ---------- */
   if ( !strcmp( attrib, "sizeguess" ) ) {
      astClearSizeGuess( this );

/* KeyError. */
/* --------- */
   } else if ( !strcmp( attrib, "keyerror" ) ) {
      astClearKeyError( this );

/* KeyCase. */
/* --------- */
   } else if ( !strcmp( attrib, "keycase" ) ) {
      astClearKeyCase( this );

/* MapLocked. */
/* --------- */
   } else if ( !strcmp( attrib, "maplocked" ) ) {
      astClearMapLocked( this );

/* SortBy. */
/* ------- */
   } else if ( !strcmp( attrib, "sortby" ) ) {
      astClearSortBy( this );

/* If the attribute is still not recognised, pass it on to the parent
   method for further interpretation. */
   } else {
      (*parent_clearattrib)( this_object, attrib, status );
   }
}

static void ClearKeyCase( AstKeyMap *this, int *status ) {
/*
*+
*  Name:
*     astClearKeyCase

*  Purpose:
*     Clear the value of the KeyCase attribute for a KeyMap.

*  Type:
*     Protected virtual function.

*  Synopsis:
*     #include "keymap.h"
*     void astSetKeyCase( AstKeyMap *this )

*  Class Membership:
*     KeyMap method.

*  Description:
*     This function Clears the KeyCase attribute of a KeyMap. It reports
*     an error if the KeyMap contains any entries.

*  Parameters:
*     this
*        Pointer to the KeyMap.

*-
*/

/* Local Variables: */
   int defval;                /* Default KeyCase value */
   int itab;                  /* Index into hash table */
   int oldval;                /* Old KeyCase value */

/* Check the global error status. */
   if ( !astOK ) return;

/* Save the old value. */
   oldval = astGetKeyCase( this );

/* Clear it. */
   this->keycase = -1;

/* Get the default value. */
   defval = astGetKeyCase( this );

/* If the old value and the default value are not the same, we must check
   that the KeyMap is empty. If not, restore the old value and report an
   error. */
   if( defval != oldval ) {
      for( itab = 0; itab < this->mapsize; itab++ ) {
         if( this->nentry[ itab ] > 0 ) {
            this->keycase = oldval;
            astError( AST__NOWRT, "astClearAttrib(KeyMap): Illegal attempt to "
                      "clear the KeyCase attribute of a non-empty KeyMap.",
                      status);
            break;
         }
      }
   }
}

static void ClearKeyError( AstKeyMap *this, int *status ) {
/*
*+
*  Name:
*     astClearKeyError

*  Purpose:
*     Clear the value of the KeyError attribute for a KeyMap.

*  Type:
*     Protected virtual function.

*  Synopsis:
*     #include "keymap.h"
*     void astClearKeyError( AstKeyMap *this )

*  Class Membership:
*     KeyMap method.

*  Description:
*     This function clears the value of the KeyError attribute for a
*     KeyMap. It clears the attribute recursively in any KeyMaps
*     contained within the supplied KeyMap.

*  Parameters:
*     this
*        Pointer to the KeyMap.

*-
*/

/* Local Variables: */
   AstMapEntry *next;     /* Pointer to next Entry to copy */
   AstObject **obj_list;  /* List of pointers to AST Object entries */
   int i;                 /* Index into hash table */
   int iel;               /* Index of current vector element */
   int nel;               /* Number of elements in vector */

/* Check the global error status. */
   if ( !astOK ) return;

/* Clear the KeyError value in the supplied KeyMap. */
   this->keyerror = -INT_MAX;

/* Loop round each entry in the hash table. */
   for( i = 0; i < this->mapsize; i++ ) {

/* Get a pointer to the next KeyMap entry. */
      next = this->table[ i ];

/* Loop round all entries in this element of the hash table. */
      while( next && astOK ) {

/* If this entry has an Object data type, see if holds any KeyMaps. */
         if( next->type == AST__OBJECTTYPE ) {

/* Get the number of objects to check, and a pointer to the first. */
            nel = next->nel;
            if( nel == 0 ) {
               obj_list = &( ((Entry0A *)next)->value );
               nel = 1;
            } else {
               obj_list = ((Entry1A *)next)->value;
            }

/* Loop round checking all Objects. */
            for( iel = 0; iel < nel; iel++ ) {

/* If this Object is a KeyMap, clear its KeyError attribute. */
               if( astIsAKeyMap( obj_list[ iel ] ) ) {
                  astClearKeyError( (AstKeyMap *) obj_list[ iel ] );
               }
            }
         }

/* Get a pointer to the next entry. */
         next = next->next;
      }
   }
}

static void ClearMapLocked( AstKeyMap *this, int *status ) {
/*
*+
*  Name:
*     astClearMapLocked

*  Purpose:
*     Clear the value of the MapLocked attribute for a KeyMap.

*  Type:
*     Protected virtual function.

*  Synopsis:
*     #include "keymap.h"
*     void astClearMapLocked( AstKeyMap *this )

*  Class Membership:
*     KeyMap method.

*  Description:
*     This function clears the value of the MapLocked attribute for a
*     KeyMap. It clears the attribute recursively in any KeyMaps
*     contained within the supplied KeyMap.

*  Parameters:
*     this
*        Pointer to the KeyMap.

*-
*/

/* Local Variables: */
   AstMapEntry *next;     /* Pointer to next Entry to copy */
   AstObject **obj_list;  /* List of pointers to AST Object entries */
   int i;                 /* Index into hash table */
   int iel;               /* Index of current vector element */
   int nel;               /* Number of elements in vector */

/* Check the global error status. */
   if ( !astOK ) return;

/* Clear the MapLocked value in the supplied KeyMap. */
   this->maplocked = -INT_MAX;

/* Loop round each entry in the hash table. */
   for( i = 0; i < this->mapsize; i++ ) {

/* Get a pointer to the next KeyMap entry. */
      next = this->table[ i ];

/* Loop round all entries in this element of the hash table. */
      while( next && astOK ) {

/* If this entry has an Object data type, see if holds any KeyMaps. */
         if( next->type == AST__OBJECTTYPE ) {

/* Get the number of objects to check, and a pointer to the first. */
            nel = next->nel;
            if( nel == 0 ) {
               obj_list = &( ((Entry0A *)next)->value );
               nel = 1;
            } else {
               obj_list = ((Entry1A *)next)->value;
            }

/* Loop round checking all Objects. */
            for( iel = 0; iel < nel; iel++ ) {

/* If this Object is a KeyMap, clear its MapLocked attribute. */
               if( astIsAKeyMap( obj_list[ iel ] ) ) {
                  astClearMapLocked( (AstKeyMap *) obj_list[ iel ] );
               }
            }
         }

/* Get a pointer to the next entry. */
         next = next->next;
      }
   }
}

static void ClearSizeGuess( AstKeyMap *this, int *status ) {
/*
*+
*  Name:
*     astClearSizeGuess

*  Purpose:
*     Clear the value of the SizeGuess attribute for a KeyMap.

*  Type:
*     Protected virtual function.

*  Synopsis:
*     #include "keymap.h"
*     void astClearSizeGuess( AstKeyMap *this )

*  Class Membership:
*     KeyMap method.

*  Description:
*     This function clears the value of the SizeGuess attribute for a
*     KeyMap. It reports an error if the KeyMap contains any entries.

*  Parameters:
*     this
*        Pointer to the KeyMap.

*-
*/

/* Local Variables: */
   int empty;                 /* Is the KeyMap empty? */
   int itab;                  /* Index into hash table */

/* Check the global error status. */
   if ( !astOK ) return;

/* See if the KeyMap is empty. */
   empty = 1;
   for( itab = 0; itab < this->mapsize; itab++ ) {
      if( this->nentry[ itab ] > 0 ) {
         empty = 0;
         break;
      }
   }

/* If not report an error. */
   if( !empty ) {
      astError( AST__NOWRT, "astClearAttrib(KeyMap): Illegal attempt to "
                "clear the SizeGuess attribute of a non-empty KeyMap." , status);

/* Otherwise, store the "cleared" value and change the size of the hash
   table. */
   } else {
      this->sizeguess = INT_MAX;
      NewTable( this, MIN_TABLE_SIZE, status );
   }
}

static void ClearSortBy( AstKeyMap *this, int *status ) {
/*
*+
*  Name:
*     astClearSortBy

*  Purpose:
*     Clear the value of the SortBy attribute for a KeyMap.

*  Type:
*     Protected virtual function.

*  Synopsis:
*     #include "keymap.h"
*     void astClearSortBy( AstKeyMap *this )

*  Class Membership:
*     KeyMap method.

*  Description:
*     This function clears the value of the SortBy attribute for a
*     KeyMap.

*  Parameters:
*     this
*        Pointer to the KeyMap.

*-
*/

/* Local Variables: */
   int oldval;            /* The old sortby value */

/* Check the global error status. */
   if ( !astOK ) return;

/* Get the original SortBy value. */
   oldval = astGetSortBy( this );

/* Clear the SortBy value in the supplied KeyMap. */
   this->sortby = -INT_MAX;

/* If the value has changed, re-sort the keys. */
   if( oldval != astGetSortBy( this ) ) SortEntries( this, status );
}

static int CompareEntries( const void *first_void, const void *second_void ) {
/*
*  Name:
*     CompareEntries

*  Purpose:
*     Determine the sorting order of two mapEntries.

*  Type:
*     Private function.

*  Synopsis:
*     #include "keymap.h"
*     int CompareEntries( const void *first, const void *second )

*  Class Membership:
*     KeyMap member function.

*  Description:
*     This function returns a value indicating if the first MapEntry
*     is less than, equal to, or greater than the second MapEntry using
*     the indicated sorting method. It is designed for use with the
*     "qsort" function, and therefore must used "void *" pointers.

*  Parameters:
*     first
*        Pointer to the address of the first MapEntry.
*     second
*        Pointer to the address of the second MapEntry.

*  Returned Value:
*     -1 if "first" is less than "second". This implies that "first"
*     should come before "second" in the sorted list.
*
*     0 if "first" is equal to "second".
*
*     +1 if "first" is greater than "second". This implies that "first"
*     should come after "second" in the sorted list.

*/

/* Local Variables: */
   AstMapEntry *first;   /* Pointer to first MapEntry structure */
   AstMapEntry *second;  /* Pointer to second MapEntry structure */
   int result;           /* Returned value */
   int sortby;           /* Sorting method */

/* Initialise returned value */
   result = 0;

/* Get pointers to the MapEntry structures, and get the sorting method. */
   first = *( (AstMapEntry **) first_void );
   second = *( (AstMapEntry **) second_void );
   sortby = first->sortby;

/* First handle sorting by increasing age of the value */
   if( sortby == SORTBY_AGEUP ) {
      if( first->member < second->member ) {
         result = 1;
      } else if( first->member > second->member ) {
         result = -1;
      } else {
         result = 0;
      }

/* Next handle sorting by decreasing age of the value */
   } else if( sortby == SORTBY_AGEDOWN ) {
      if( first->member < second->member ) {
         result = -1;
      } else if( first->member > second->member ) {
         result = 1;
      } else {
         result = 0;
      }

/* Next handle sorting by increasing age of the key */
   } else if( sortby == SORTBY_KEYAGEUP ) {
      if( first->keymember < second->keymember ) {
         result = 1;
      } else if( first->keymember > second->keymember ) {
         result = -1;
      } else {
         result = 0;
      }

/* Next handle sorting by decreasing age of the key */
   } else if( sortby == SORTBY_KEYAGEDOWN ) {
      if( first->keymember < second->keymember ) {
         result = -1;
      } else if( first->keymember > second->keymember ) {
         result = 1;
      } else {
         result = 0;
      }

/* Next handle sorting by increasing alphabetical position. */
   } else if( sortby == SORTBY_KEYUP ) {
      result = KeyCmp( first->key, second->key );

/* Next handle sorting by decreasing alphabetical position. */
   } else if( sortby == SORTBY_KEYDOWN ) {
      result = KeyCmp( second->key, first->key );

   }

/* Return the result. */
   return result;

}

static const char *ConvertKey( AstKeyMap *this, const char *skey, char *keybuf,
                               int blen, const char *method, int *status ){
/*
*  Name:
*     ConvertValue

*  Purpose:
*     Convert the supplied key to upper case if required.

*  Type:
*     Private function.

*  Synopsis:
*     #include "keymap.h"
*     const char *ConvertKey( AstKeyMap *this, const char *skey, char *keybuf,
*                             int blen, const char *method, int *status )

*  Class Membership:
*     KeyMap member function.

*  Description:
*     This function converts the supplied key string to uppercase if the
*     KeyCase attribute it currently set to zero in the supplied KeyMap.

*  Parameters:
*     this
*        Pointer to the KeyMap.
*     skey
*        Pointer to the supplied key string.
*     keybuf
*        Pointer to a buffer in which to place the converted string. This
*        will only be used if the supplied key string needs to be
*        converted.
*     blen
*        The length of the "keybuf" buffer. This should include room for
*        a terminating null character.
*     method
*        Pointer to a string holding the name of the method to include in
*        any error message.
*     status
*        Pointer to the inherited status variable.

*  Returned Value:
*     If the KeyMap's KeyCase attribute is currently set to a non-zero
*     value, the returned value will be a copy of "skey". Otherwise it
*     will be copy of "keybuf" (the buffer holding the upper case version
*     of the supplied string).

*  Notes:
*     - The valeu of "skey" will be returned if this function is invoked
*     with the global error status set, or if it should fail for any reason.
*/

/* Local Variables: */
   const char *result;
   int len;

/* Initialise. */
   result = skey;

/* Check the global error status and the supplied pointers. */
   if( !astOK ) return result;

/* If the KeyCase attribute is non-zero, return "skey". Otherwise, convert
   the "skey" string to upper case and return "keybuf". Report an error if
   the key is too long. */
   if( !astGetKeyCase( this ) && astOK ) {
      len = astChrLen( skey );
      if( len >= blen ) {
         astError( AST__BIGKEY, "%s(%s): Supplied key '%s' is too long "
                   "(keys must be no more than %d characters long).",
                   status, method, astGetClass( this ), skey, blen - 1 );
      } else {
         astChrCase( skey, keybuf, 1, blen );
         result = keybuf;
      }
   }

/* Return the result. */
   return result;
}

static int ConvertValue( void *raw, int raw_type, void *out, int out_type, int *status ) {
/*
*  Name:
*     ConvertValue

*  Purpose:
*     Convert a value from one KeyMap data type to another.

*  Type:
*     Private function.

*  Synopsis:
*     #include "keymap.h"
*     int ConvertValue( void *raw, int raw_type, void *out, int out_type, int *status )

*  Class Membership:
*     KeyMap member function.

*  Description:
*     This function converts a supplied value from one KeyMap data type to
*     another, if possible.

*  Parameters:
*     raw
*        Pointer to input value.
*     raw_type
*        The data type of the input value.
*     out
*        Pointer to the location at which to store the output value. This
*        may be NULL, in which case the conversion is still performed if
*        possible, but the result of the conversion is thrown away. If the
*        output value is a pointer to a string, it should not be modified
*        by the caller in any way. Neither should it be freed by the caller.
*     out_type
*        The data type of the output value.
*     status
*        Pointer to the inherited status variable.

*  Returned Value:
*     Non-zero if the conversion was performed succesfully, otherwise zero.
*     In the case of the output type being AST__STRINGTYPE, the returned
*     non-zero value will be the length of the formatted string (including
*     the terminating null character). This value will be returned correctly
*     even if "out" is NULL.

*  Notes:
*     - Zero will be returned if this function is invoked with the global
*     error status set, or if it should fail for any reason.
*/

/* Local Variables: */
   AstObject *aval;              /* AstObject pointer value */
   astDECLARE_GLOBALS            /* Declare the thread specific global data */
   const char *cval;             /* Pointer to string value */
   const char *cvalue;           /* Pointer to output string value */
   double dval;                  /* Double precision value */
   float fval;                   /* Single precision value */
   int i;                        /* Loop count */
   int ival;                     /* Integer value */
   int n1;                       /* Number of characters at reduced precision */
   int n2;                       /* Number of characters at full precision */
   int nc;                       /* Number of characters read from string */
   int nval;                     /* Number of values read from string */
   int result;                   /* Returned flag */
   int64_t kval;                 /* 64 bit integer value */
   short int sval;               /* Short int value */
   unsigned char bval;           /* Byte value */

/* Initialise. */
   result = 0;

/* Check the global error status and the supplied pointers. */
   if( !astOK || !raw ) return result;

/* Get a pointer to the structure holding thread-specific global data. */
   astGET_GLOBALS(NULL);

/* If the "convertvalue_strings" array has not been initialised, fill it with
   NULL pointers. */
   if( !convertvalue_init ) {
      convertvalue_init = 1;
      for( i = 0; i < AST__KEYMAP_CONVERTVALUE_MAX_STRINGS; i++ ) convertvalue_strings[ i ] = NULL;
   }

/* Assume conversion is possible */
   result = 1;
   cvalue = NULL;

/* Do nothing if both data types are AST__UNDEFTYPE. */
    if( raw_type == AST__UNDEFTYPE && out_type == AST__UNDEFTYPE ) {

/* Indicate failure if one of the two types is AST__UNDEFTYPE and the
   other is not. */
    } else if( raw_type == AST__UNDEFTYPE || out_type == AST__UNDEFTYPE ) {
      result = 0;

/* Otherwise, consider conversion from "int". */
    } else if( raw_type == AST__INTTYPE ) {
      ival = *( (int *) raw );

/* Consider conversion to "int". */
      if( out_type == AST__INTTYPE ) {
         if( out ) *( (int *) out ) = ival;

/* Consider conversion to "short int". */
      } else if( out_type == AST__SINTTYPE ) {
         if( out ) *( (short int *) out ) = (short int) ival;

/* Consider conversion to "64 bit int". */
      } else if( out_type == AST__KINTTYPE ) {
         if( out ) *( (int64_t *) out ) = (int64_t) ival;

/* Consider conversion to "byte". */
      } else if( out_type == AST__BYTETYPE ) {
         if( out ) *( (unsigned char *) out ) = (unsigned char) ival;

/* Consider conversion to "float". */
      } else if( out_type == AST__FLOATTYPE ) {
         if( out ) *( (float *) out ) = (float) ival;

/* Consider conversion to "double". */
      } else if( out_type == AST__DOUBLETYPE ) {
         if( out ) *( (double *) out ) = (double) ival;

/* Consider conversion to "const char *". */
      } else if( out_type == AST__STRINGTYPE ) {
         (void) sprintf( convertvalue_buff, "%d", ival );
         cvalue = convertvalue_buff;

/* Consider conversion to "AstObject *". */
      } else if( out_type == AST__OBJECTTYPE ) {
         result = 0;

/* Consider conversion to "void *". */
      } else if( out_type == AST__POINTERTYPE ) {
         result = 0;

/* Report an error if the data type is unknown. */
      } else {
         result = 0;
         astError( AST__INTER, "ConvertValue(KeyMap): Illegal map entry data "
                   "type %d encountered (internal AST programming error).", status,
                   out_type );
      }

/* Otherwise, consider conversion from "64 bit int". */
    } else if( raw_type == AST__KINTTYPE ) {
      kval = *( (int64_t *) raw );

/* Consider conversion to "int". */
      if( out_type == AST__INTTYPE ) {
         if( out ) *( (int *) out ) = kval;

/* Consider conversion to "short int". */
      } else if( out_type == AST__SINTTYPE ) {
         if( out ) *( (short int *) out ) = kval;

/* Consider conversion to "64 bit int". */
      } else if( out_type == AST__KINTTYPE ) {
         if( out ) *( (int64_t *) out ) = kval;

/* Consider conversion to "byte". */
      } else if( out_type == AST__BYTETYPE ) {
         if( out ) *( (unsigned char *) out ) = kval;

/* Consider conversion to "float". */
      } else if( out_type == AST__FLOATTYPE ) {
         if( out ) *( (float *) out ) = (float) kval;

/* Consider conversion to "double". */
      } else if( out_type == AST__DOUBLETYPE ) {
         if( out ) *( (double *) out ) = (double) kval;

/* Consider conversion to "const char *". */
      } else if( out_type == AST__STRINGTYPE ) {
         (void) sprintf( convertvalue_buff, "%" PRId64, kval );
         cvalue = convertvalue_buff;

/* Consider conversion to "AstObject *". */
      } else if( out_type == AST__OBJECTTYPE ) {
         result = 0;

/* Consider conversion to "void *". */
      } else if( out_type == AST__POINTERTYPE ) {
         result = 0;

/* Report an error if the data type is unknown. */
      } else {
         result = 0;
         astError( AST__INTER, "ConvertValue(KeyMap): Illegal map entry data "
                   "type %d encountered (internal AST programming error).", status,
                   out_type );
      }

/* Otherwise, consider conversion from "short int". */
    } else if( raw_type == AST__SINTTYPE ) {
      sval = *( (short int *) raw );

/* Consider conversion to "int". */
      if( out_type == AST__INTTYPE ) {
         if( out ) *( (int *) out ) = sval;

/* Consider conversion to "short int". */
      } else if( out_type == AST__SINTTYPE ) {
         if( out ) *( (short int *) out ) = sval;

/* Consider conversion to "64 bit int". */
      } else if( out_type == AST__KINTTYPE ) {
         if( out ) *( (int64_t *) out ) = sval;

/* Consider conversion to "byte". */
      } else if( out_type == AST__BYTETYPE ) {
         if( out ) *( (unsigned char *) out ) = sval;

/* Consider conversion to "float". */
      } else if( out_type == AST__FLOATTYPE ) {
         if( out ) *( (float *) out ) = (float) sval;

/* Consider conversion to "double". */
      } else if( out_type == AST__DOUBLETYPE ) {
         if( out ) *( (double *) out ) = (double) sval;

/* Consider conversion to "const char *". */
      } else if( out_type == AST__STRINGTYPE ) {
         (void) sprintf( convertvalue_buff, "%d", (int) sval );
         cvalue = convertvalue_buff;

/* Consider conversion to "AstObject *". */
      } else if( out_type == AST__OBJECTTYPE ) {
         result = 0;

/* Consider conversion to "void *". */
      } else if( out_type == AST__POINTERTYPE ) {
         result = 0;

/* Report an error if the data type is unknown. */
      } else {
         result = 0;
         astError( AST__INTER, "ConvertValue(KeyMap): Illegal map entry data "
                   "type %d encountered (internal AST programming error).", status,
                   out_type );
      }

/* Otherwise, consider conversion from "byte". */
    } else if( raw_type == AST__BYTETYPE ) {
      bval = *( (unsigned char *) raw );

/* Consider conversion to "int". */
      if( out_type == AST__INTTYPE ) {
         if( out ) *( (int *) out ) = bval;

/* Consider conversion to "short int". */
      } else if( out_type == AST__SINTTYPE ) {
         if( out ) *( (short int *) out ) = bval;

/* Consider conversion to "int64_t". */
      } else if( out_type == AST__KINTTYPE ) {
         if( out ) *( (int64_t *) out ) = bval;

/* Consider conversion to "byte". */
      } else if( out_type == AST__BYTETYPE ) {
         if( out ) *( (unsigned char *) out ) = bval;

/* Consider conversion to "float". */
      } else if( out_type == AST__FLOATTYPE ) {
         if( out ) *( (float *) out ) = (float) bval;

/* Consider conversion to "double". */
      } else if( out_type == AST__DOUBLETYPE ) {
         if( out ) *( (double *) out ) = (double) bval;

/* Consider conversion to "const char *". */
      } else if( out_type == AST__STRINGTYPE ) {
         (void) sprintf( convertvalue_buff, "%d", (int) bval );
         cvalue = convertvalue_buff;

/* Consider conversion to "AstObject *". */
      } else if( out_type == AST__OBJECTTYPE ) {
         result = 0;

/* Consider conversion to "void *". */
      } else if( out_type == AST__POINTERTYPE ) {
         result = 0;

/* Report an error if the data type is unknown. */
      } else {
         result = 0;
         astError( AST__INTER, "ConvertValue(KeyMap): Illegal map entry data "
                   "type %d encountered (internal AST programming error).", status,
                   out_type );
      }

/* Consider conversion from "double". */
   } else if( raw_type == AST__DOUBLETYPE ) {
      dval = *( (double *) raw );

/* Consider conversion to "int". */
      if( out_type == AST__INTTYPE ) {
         if( out ) *( (int *) out ) = (int)( dval + 0.5 );

/* Consider conversion to "short int". */
      } else if( out_type == AST__SINTTYPE ) {
         if( out ) *( (short int *) out ) = (int)( dval + 0.5 );

/* Consider conversion to "64 bit int". */
      } else if( out_type == AST__KINTTYPE ) {
         if( out ) *( (int64_t *) out ) = (int64_t)( dval + 0.5 );

/* Consider conversion to "byte". */
      } else if( out_type == AST__BYTETYPE ) {
         if( out ) *( (unsigned char *) out ) = (int)( dval + 0.5 );

/* Consider conversion to "double". */
      } else if( out_type == AST__DOUBLETYPE ) {
         if( out ) *( (double *) out ) = dval;

/* Consider conversion to "float". */
      } else if( out_type == AST__FLOATTYPE ) {
         if( out ) *( (float *) out ) = (float) dval;

/* Consider conversion to "const char *". If reducing the number of
   decimal places by three produces a saving of 10 or more characters,
   assume the least significant two characters are rounding error. */
      } else if( out_type == AST__STRINGTYPE ) {
         if( dval != AST__BAD ) {
            n1 = sprintf( convertvalue_buff, "%.*g", AST__DBL_DIG - 3, dval );
            n2 = sprintf( convertvalue_buff, "%.*g", AST__DBL_DIG, dval );
            if( n2 - n1 > 9 ) {
               (void) sprintf( convertvalue_buff, "%.*g", AST__DBL_DIG - 3, dval );
            }
            cvalue = convertvalue_buff;
         } else {
            cvalue = AST__BAD_STRING;
         }

/* Consider conversion to "AstObject *". */
      } else if( out_type == AST__OBJECTTYPE ) {
         result = 0;

/* Consider conversion to "void *". */
      } else if( out_type == AST__POINTERTYPE ) {
         result = 0;

/* Report an error if the data type is unknown. */
      } else {
         result = 0;
         astError( AST__INTER, "ConvertValue(KeyMap): Illegal map entry data "
                   "type %d encountered (internal AST programming error).", status,
                   out_type );
      }

/* Consider conversion from "float". */
   } else if( raw_type == AST__FLOATTYPE ) {
      fval = *( (float *) raw );

/* Consider conversion to "int". */
      if( out_type == AST__INTTYPE ) {
         if( out ) *( (int *) out ) = (int)( fval + 0.5 );

/* Consider conversion to "short int". */
      } else if( out_type == AST__SINTTYPE ) {
         if( out ) *( (short int *) out ) = (int)( fval + 0.5 );

/* Consider conversion to "64 bit int". */
      } else if( out_type == AST__KINTTYPE ) {
         if( out ) *( (int64_t *) out ) = (int64_t)( fval + 0.5 );

/* Consider conversion to "byte". */
      } else if( out_type == AST__BYTETYPE ) {
         if( out ) *( (unsigned char *) out ) = (int)( fval + 0.5 );

/* Consider conversion to "double". */
      } else if( out_type == AST__DOUBLETYPE ) {
         if( out ) *( (double *) out ) = (double) fval;

/* Consider conversion to "float". */
      } else if( out_type == AST__FLOATTYPE ) {
         if( out ) *( (float *) out ) = fval;

/* Consider conversion to "const char *". */
      } else if( out_type == AST__STRINGTYPE ) {
         (void) sprintf( convertvalue_buff, "%.*g", FLT_DIG, fval );
         cvalue = convertvalue_buff;

/* Consider conversion to "AstObject *". */
      } else if( out_type == AST__OBJECTTYPE ) {
         result = 0;

/* Consider conversion to "void *". */
      } else if( out_type == AST__POINTERTYPE ) {
         result = 0;

/* Report an error if the data type is unknown. */
      } else {
         result = 0;
         astError( AST__INTER, "ConvertValue(KeyMap): Illegal map entry data "
                   "type %d encountered (internal AST programming error).", status,
                   out_type );
      }

/* Consider conversion from "const char *". */
   } else if( raw_type == AST__STRINGTYPE ) {
      cval = *( (const char **) raw );

/* Consider conversion to "int". */
      if( out_type == AST__INTTYPE ) {
         nc = 0;
         nval = astSscanf( cval, " %d %n", &ival, &nc );
         if( ( nval == 1 ) && ( nc >= (int) strlen( cval ) ) ) {
            if( out ) *( (int *) out ) = ival;
         } else {
            nc = 0;
            nval = astSscanf( cval, " %lf %n", &dval, &nc );
            if( ( nval == 1 ) && ( nc >= (int) strlen( cval ) ) ) {
               if( out ) *( (int *) out ) = (int) ( dval + 0.5 );
            } else {
               result = 0;
            }
         }

/* Consider conversion to "short int". */
      } else if( out_type == AST__SINTTYPE ) {
         nc = 0;
         nval = astSscanf( cval, " %d %n", &ival, &nc );
         if( ( nval == 1 ) && ( nc >= (int) strlen( cval ) ) ) {
            if( out ) *( (short int *) out ) = ival;
         } else {
            nc = 0;
            nval = astSscanf( cval, " %lf %n", &dval, &nc );
            if( ( nval == 1 ) && ( nc >= (int) strlen( cval ) ) ) {
               if( out ) *( (short int *) out ) = (int) ( dval + 0.5 );
            } else {
               result = 0;
            }
         }

/* Consider conversion to "64 bit int". */
      } else if( out_type == AST__KINTTYPE ) {
         nc = 0;
         nval = astSscanf( cval, " %" SCNd64 " %n", &kval, &nc );
         if( ( nval == 1 ) && ( nc >= (int) strlen( cval ) ) ) {
            if( out ) *( (int64_t *) out ) = kval;
         } else {
            nc = 0;
            nval = astSscanf( cval, " %lf %n", &dval, &nc );
            if( ( nval == 1 ) && ( nc >= (int) strlen( cval ) ) ) {
               if( out ) *( (int64_t *) out ) = (int64_t) ( dval + 0.5 );
            } else {
               result = 0;
            }
         }

/* Consider conversion to "byte". */
      } else if( out_type == AST__BYTETYPE ) {
         nc = 0;
         nval = astSscanf( cval, " %d %n", &ival, &nc );
         if( ( nval == 1 ) && ( nc >= (int) strlen( cval ) ) ) {
            if( out ) *( (unsigned char *) out ) = ival;
         } else {
            nc = 0;
            nval = astSscanf( cval, " %lf %n", &dval, &nc );
            if( ( nval == 1 ) && ( nc >= (int) strlen( cval ) ) ) {
               if( out ) *( (unsigned char *) out ) = (int) ( dval + 0.5 );
            } else {
               result = 0;
            }
         }

/* Consider conversion to "double". */
      } else if( out_type == AST__DOUBLETYPE ) {
         nc = 0;
         if( ( astSscanf( cval, " " AST__BAD_STRING " %n", &nc ) == 0 ) &&
             ( nc >= (int) strlen( cval ) ) ) {
            if( out ) *( (double *) out ) = AST__BAD;

         } else if( ( astSscanf( cval, " %lf %n", &dval, &nc ) == 1 ) &&
                     ( nc >= (int) strlen( cval ) ) ) {
            if( out ) *( (double *) out ) = dval;

         } else {
            result = 0;
         }

/* Consider conversion to "float". */
      } else if( out_type == AST__FLOATTYPE ) {
         nc = 0;
         nval = astSscanf( cval, " %f %n", &fval, &nc );
         if( ( nval == 1 ) && ( nc >= (int) strlen( cval ) ) ) {
            if( out ) *( (float *) out ) = fval;
         } else {
            result = 0;
         }

/* Consider conversion to "const char *". */
      } else if( out_type == AST__STRINGTYPE ) {
         cvalue = cval;

/* Consider conversion to "AstObject *". */
      } else if( out_type == AST__OBJECTTYPE ) {
         result = 0;

/* Consider conversion to "void *". */
      } else if( out_type == AST__POINTERTYPE ) {
         result = 0;

/* Report an error if the data type is unknown. */
      } else {
         result = 0;
         astError( AST__INTER, "ConvertValue(KeyMap): Illegal map entry data "
                   "type %d encountered (internal AST programming error).", status,
                   out_type );
      }

/* Consider conversion from "AstObject *". */
   } else if( raw_type == AST__OBJECTTYPE ) {

/* Consider conversion to "int". */
      if( out_type == AST__INTTYPE ) {
         result = 0;

/* Consider conversion to "short int". */
      } else if( out_type == AST__SINTTYPE ) {
         result = 0;

/* Consider conversion to "64 bit int". */
      } else if( out_type == AST__KINTTYPE ) {
         result = 0;

/* Consider conversion to "byte". */
      } else if( out_type == AST__BYTETYPE ) {
         result = 0;

/* Consider conversion to "double". */
      } else if( out_type == AST__DOUBLETYPE ) {
         result = 0;

/* Consider conversion to "float". */
      } else if( out_type == AST__FLOATTYPE ) {
         result = 0;

/* Consider conversion to "const char *". */
      } else if( out_type == AST__STRINGTYPE ) {
         result = 0;

/* Consider conversion to "AstObject *". */
      } else if( out_type == AST__OBJECTTYPE ) {
         aval = *( (AstObject **) raw );
         if( out ) *( (AstObject **) out ) = aval ? astClone( aval ) : NULL;

/* Consider conversion to "void *". */
      } else if( out_type == AST__POINTERTYPE ) {
         result = 0;

/* Report an error if the data type is unknown. */
      } else {
         result = 0;
         astError( AST__INTER, "ConvertValue(KeyMap): Illegal map entry data "
                   "type %d encountered (internal AST programming error).", status,
                   out_type );
      }

/* Consider conversion from "void *". */
   } else if( raw_type == AST__POINTERTYPE ) {

/* Consider conversion to "int". */
      if( out_type == AST__INTTYPE ) {
         result = 0;

/* Consider conversion to "short int". */
      } else if( out_type == AST__SINTTYPE ) {
         result = 0;

/* Consider conversion to "64 bit int". */
      } else if( out_type == AST__KINTTYPE ) {
         result = 0;

/* Consider conversion to "byte". */
      } else if( out_type == AST__BYTETYPE ) {
         result = 0;

/* Consider conversion to "double". */
      } else if( out_type == AST__DOUBLETYPE ) {
         result = 0;

/* Consider conversion to "float". */
      } else if( out_type == AST__FLOATTYPE ) {
         result = 0;

/* Consider conversion to "const char *". */
      } else if( out_type == AST__STRINGTYPE ) {
         result = 0;

/* Consider conversion to "AstObject *". */
      } else if( out_type == AST__OBJECTTYPE ) {
         result = 0;

/* Consider conversion to "void *". */
      } else if( out_type == AST__POINTERTYPE ) {
         if( out ) *( (void **) out ) = *( (void **) raw );

/* Report an error if the data type is unknown. */
      } else {
         result = 0;
         astError( AST__INTER, "ConvertValue(KeyMap): Illegal map entry data "
                   "type %d encountered (internal AST programming error).", status,
                   out_type );
      }

/* Report an error if the data type is unknown. */
   } else {
      result = 0;
      astError( AST__INTER, "ConvertValue(KeyMap): Illegal map entry data "
                "type %d encountered (internal AST programming error).", status,
                raw_type );
   }

/* If the output is a string, store a copy of the resulting string in
   dynamically allocated memory, putting a pointer to the copy into the next
   element of the "convertvalue_strings" array.  (This process also de-allocates
   any previously allocated memory pointed at by this "convertvalue_strings"
   element, so the earlier string is effectively replaced by the new
   one.) */
   if( out_type == AST__STRINGTYPE && astOK && result && cvalue ) {
      result = strlen( cvalue ) + 1;

      astBeginPM;
      convertvalue_strings[ convertvalue_istr ] = astStore( convertvalue_strings[ convertvalue_istr ], cvalue,
                                  (size_t) result );
      astEndPM;

/* If OK, return a pointer to the copy and increment "convertvalue_istr" to use the
   next element of "convertvalue_strings" on the next invocation. Recycle "convertvalue_istr" to
   zero when all elements have been used. */
      if ( astOK ) {
         if( out ) *( (const char **) out ) = convertvalue_strings[ convertvalue_istr++ ];
         if( convertvalue_istr == ( AST__KEYMAP_CONVERTVALUE_MAX_STRINGS - 1 ) ) convertvalue_istr = 0;
      }
   }

/* If an error has occurred, return zero. */
   if( !astOK ) result = 0;

/* Return the result. */
   return result;
}


static AstMapEntry *CopyMapEntry( AstMapEntry *in, int *status ){
/*
*  Name:
*     CopyMapEntry

*  Purpose:
*     Produces a copy of the supplied KeyMap entry.

*  Type:
*     Private function.

*  Synopsis:
*     #include "keymap.h"
*     AstMapEntry *CopyMapEntry( AstMapEntry *in, int *status )

*  Class Membership:
*     KeyMap member function.

*  Description:
*     This function creates a deep copy of the supplied KeyMap entry.

*  Parameters:
*     in
*        Pointer to the MapEntry to be copied. NULL may be supplied in
*        which case NULL will be returned.
*     status
*        Pointer to the inherited status variable.

*  Returned Value:
*     Pointer to the new copy. The link to the next MapEntry in the
*     linked list is set NULL in the returned copy.

*  Notes:
*     - A NULL pointer will be returned if this function is invoked
*     with the global error status set, or if it should fail for any
*     reason.
*/

/* Local Variables: */
   AstMapEntry *result;   /* Returned pointer */
   AstObject **alist;     /* Pointer to list of AST object pointers */
   AstObject *obj;        /* Pointer to AstObject value */
   const char **slist;    /* Pointer to list of text pointers */
   const char *text;      /* Pointer to text string */
   int i;                 /* Loop count */
   int nel;               /* No. of values in entry vector (0 => scalar) */
   int type;              /* Entry data type */
   size_t size;           /* Size of Entry structure */

/* Initialise. */
   result = NULL;

/* Check the global error status and the supplied pointer. */
   if ( !astOK || !in ) return result;

/* Get the size, data type and length of the MapEntry. */
   size = SizeOfEntry( in, status );
   nel = in->nel;
   type = in->type;

/* Do a byte-for-byte copy of the supplied MapEntry. */
   result = astStore( NULL, in, size );

/* Copy or nullify pointers in the AstMapEntry structure. */
   result->next = NULL;
   result->snext = NULL;
   result->sprev = NULL;
   text = in->key;
   result->key = text ? astStore( NULL, text, strlen( text ) + 1 ) : NULL;
   text = in->comment;
   result->comment = text ? astStore( NULL, text, strlen( text ) + 1 ) : NULL;

/* Nothing further to do for undefined values. */
   if( type == AST__UNDEFTYPE ) {

/* Next deal with string entries. */
   } else if( type == AST__STRINGTYPE ) {

/* Scalar valued entries... */
      if( nel == 0 ) {

/* Take a copy of the single string in the input entry. */
         text = ( (Entry0C *) in )->value;
         ( (Entry0C *) result )->value = text ? astStore( NULL, text,
                                                strlen( text ) + 1 ) : NULL;
/* Vector valued entries... */
      } else {

/* Allocate an array to store the string pointers. */
         slist = astMalloc( sizeof(char *)*(size_t)nel );
         ( (Entry1C *) result )->value = slist;

/* Copy the strings. */
         if( slist ) {
            for( i = 0; i < nel; i++ ) {
               text = ( (Entry1C *) in )->value[ i ];
               slist[ i ] = text ? astStore( NULL, text, strlen( text ) + 1 ) : NULL;
            }
         }
      }

/* Similarly deal with AST Object entries. */
   } else if( type == AST__OBJECTTYPE ) {
      if( nel == 0 ) {
         obj = ( (Entry0A *) in )->value;
         ( (Entry0A *) result )->value = obj ? astCopy( obj ) : NULL;
         ( (Entry0A *) result )->next = NULL;
         ( (Entry0A *) result )->prev = NULL;
      } else {
         alist = astMalloc( sizeof(AstObject *)*(size_t)nel );
         ( (Entry1A *) result )->value = alist;
         if( alist ) {
            for( i = 0; i < nel; i++ ) {
               obj = ( (Entry1A *) in )->value[ i ];
               alist[ i ] = obj ? astCopy( obj ) : NULL;
            }
            ( (Entry1A *) result )->next = NULL;
            ( (Entry1A *) result )->prev = NULL;
         }
      }

/* Now deal with integer entries. Scalar entries do not need any further
   action. If this is a vector entry copy the values array. */
   } else if( type == AST__INTTYPE ) {
      if( nel > 0 ) {
         ( (Entry1I *) result )->value = astStore( NULL,
                                                  ( (Entry1I *) in )->value,
                                                  sizeof( int )*(size_t)nel );
      }

/* Now deal with short int entries. Scalar entries do not need any further
   action. If this is a vector entry copy the values array. */
   } else if( type == AST__SINTTYPE ) {
      if( nel > 0 ) {
         ( (Entry1S *) result )->value = astStore( NULL,
                                            ( (Entry1S *) in )->value,
                                            sizeof( short int )*(size_t)nel );
      }

/* Now deal with 64 bit int entries. Scalar entries do not need any further
   action. If this is a vector entry copy the values array. */
   } else if( type == AST__KINTTYPE ) {
      if( nel > 0 ) {
         ( (Entry1K *) result )->value = astStore( NULL,
                                            ( (Entry1K *) in )->value,
                                            sizeof( int64_t )*(size_t)nel );
      }

/* Now deal with byte entries. Scalar entries do not need any further
   action. If this is a vector entry copy the values array. */
   } else if( type == AST__BYTETYPE ) {
      if( nel > 0 ) {
         ( (Entry1B *) result )->value = astStore( NULL,
                                            ( (Entry1B *) in )->value,
                                            sizeof( unsigned char )*(size_t)nel );
      }

/* Similarly deal with floating point entries. */
   } else if( type == AST__DOUBLETYPE ) {
      if( nel > 0 ) {
         ( (Entry1D *) result )->value = astStore( NULL,
                                                  ( (Entry1D *) in )->value,
                                                  sizeof( double )*(size_t)nel );
      }

   } else if( type == AST__FLOATTYPE ) {
      if( nel > 0 ) {
         ( (Entry1F *) result )->value = astStore( NULL,
                                                  ( (Entry1F *) in )->value,
                                                  sizeof( float )*(size_t)nel );
      }

/* Similarly deal with void pointer entries. */
   } else if( type == AST__POINTERTYPE ) {
      if( nel > 0 ) {
         ( (Entry1P *) result )->value = astStore( NULL,
                                                  ( (Entry1P *) in )->value,
                                                  sizeof( void * )*(size_t)nel );
      }

/* Report an error if the data type is unknown. */
   } else {
      astError( AST__INTER, "CopyMapEntry(KeyMap): Illegal map entry data "
                "type %d encountered (internal AST programming error).", status,
                type );
   }

/* If an error has occurred, attempt to delete the returned MapEntry. */
   if( !astOK ) result = FreeMapEntry( result, status );

/* Return the result. */
   return result;
}

static void CopyTableEntry( AstKeyMap *in, AstKeyMap *out, int itab, int *status ){
/*
*  Name:
*     CopyTableEntry

*  Purpose:
*     Produces a deep copy of a hash table element.

*  Type:
*     Private function.

*  Synopsis:
*     #include "keymap.h"
*     void CopyTableEntry( AstKeyMap *in, AstKeyMap *out, int itab, int *status )

*  Class Membership:
*     KeyMap member function.

*  Description:
*     This function creates a deep copy of the linked-list of KeyMap entries
*     stored in the specified element of the input KeyMaps hash table.

*  Parameters:
*     in
*        Pointer to the input KeyMap.
*     out
*        Pointer to the output KeyMap.
*     itab
*        Index of the hash table element to be copied.
*     status
*        Pointer to the inherited status variable.

*/

/* Local Variables: */
   AstMapEntry **link;    /* Address to store foward link */
   AstMapEntry *next;     /* Pointer to next Entry to copy */

/* Check the global error status. */
   if ( !astOK ) return;

/* The "link" variable holds the address of the location at which the
   pointer to the next copied MapEntry should be stored. Initialise this to
   be the address of the required element of the output hash table. */
   link = &( out->table[ itab ] );

/* The "next" variable holds the address of the next MapEntry to be
   copied. Initialise this to the MapEntry at the head of the linked list
   associated with the specified index of the input KeyMaps hash table. */
   next = in->table[ itab ];

/* If the hash table element is empty, store a null pointer and pass on. */
   if( !next ) {
      out->table[ itab ] = NULL;

/* Otherwise copy the liked list. */
   } else {

/* Loop round until we have copied all entries. */
      while( next && astOK ) {

/* Copy the next entry, storing the resulting pointer at the position
   indicated by "link". */
         *link = CopyMapEntry( next, status );

/* If the entry is of type AST__OBJECTTYPE, add it to the head of the
   list of AST__OBJECTTYPE entries in the output KeyMap. */
         AddToObjectList( out, *link, status );

/* Update "link" and "next" */
         next = next->next;
         link = &( (*link)->next );
      }
   }

/* Set the number of entries in the output to be the same as the input. */
   out->nentry[ itab ] = in->nentry[ itab ];

/* If an error has occurred, attempt to delete the returned MapEntry. */
   if( !astOK ) FreeTableEntry( out, itab, status );
}

static void DoubleTableSize( AstKeyMap *this, int *status ) {
/*
*  Name:
*     DoubleTableSize

*  Purpose:
*     Double the size of the hash table in a KeyMap

*  Type:
*     Private function.

*  Synopsis:
*     #include "keymap.h"
*     void DoubleTableSize( AstKeyMap *this, int *status )

*  Class Membership:
*     KeyMap member function.

*  Description:
*     This function creates a new hash table which has twice as many
*     elements as the current hash table, and moves all the entries out
*     of the old table into the new table (at their new positions).

*  Parameters:
*     this
*        The KeyMap pointer.
*     status
*        Pointer to the inherited status variable.

*/

/* Local Variables: */
   AstMapEntry **newtable;
   AstMapEntry *next;
   AstMapEntry *new_next;
   int *newnentry;
   int bitmask;
   int i;
   int newi;
   int newmapsize;

/* Check the global error status. */
   if( !astOK ) return;

/* Determine the new hash table size. Since mapsize starts out as a power
   of 2 (ensured by the NewTable function), the new mapsize will also be
   a power of 2. Also, create a bit mask that can be used to zero the
   upper bits in a full width hash value. */
   newmapsize = 2*this->mapsize;
   bitmask = newmapsize - 1;

/* Create the new arrays, leaving the old arrays intact for the moment. */
   newtable = astMalloc( newmapsize*sizeof( AstMapEntry * ) );
   newnentry = astMalloc( newmapsize*sizeof( int ) );
   if( astOK ) {

/* Initialise the new table. */
      for( i = 0; i < newmapsize; i++ ) {
         newtable[ i ] = NULL;
         newnentry[ i ] = 0;
      }

/* Loop round each of the existing table entries. */
      for( i = 0; i < this->mapsize; i++ ) {

/* The "next" variable holds the address of the next MapEntry to be
   moved. Initialise this to the MapEntry at the head of the linked list
   associated with the specified index of the input KeyMaps hash table. */
         next = this->table[ i ];

/* Loop round until we have moved all entries. */
         while( next && astOK ) {

/* Find the index within the new table at which to store this entry. */
            newi = ( next->hash & bitmask );

/* Save the pointer to the next entry following the current one in the
   linked list. */
            new_next = next->next;

/* Put a pointer to the MapEntry which is currently at the head of the
   linked list in the "next" component of the current MapEntry. */
            next->next = newtable[ newi ];

/* Store the supplied MapEntry pointer in the requested element of the
   hash table. */
            newtable[ newi ] = next;

/* Increment the length of linked list. */
            newnentry[ newi ]++;

/* Use the pointer to the next map entry to be moved. */
            next = new_next;
         }
      }
   }

/* If OK, delete the existing table and use the new table */
   if( astOK ) {
      this->mapsize = newmapsize;

      (void) astFree( this->table );
      this->table = newtable;

      (void) astFree( this->nentry );
      this->nentry = newnentry;

/* If not OK, delete the new table. */
   } else {
      newtable = astFree( newtable );
      newnentry = astFree( newnentry );
   }
}

static void DumpEntry( AstMapEntry *entry, AstChannel *channel, int nentry, int *status ) {
/*
*  Name:
*     DumpEntry

*  Purpose:
*     Dump a single AstMapEntry to a Channel.

*  Type:
*     Private function.

*  Synopsis:
*     void DumpEntry( AstMapEntry *entry, AstChannel *channel, int nentry )

*  Description:
*     This function dumps the supplied MapEntry to the supplied Channel.

*  Parameters:
*     entry
*        Pointer to the MapEntry whose data are being written.
*     channel
*        Pointer to the Channel to which the data are being written.
*     nentry
*        The integer index value to use when describing the MapEntry in
*        the dump.
*/

/* Local Variables: */
   char buff[20];                /* Buffer for item names */
   char pbuff[100];              /* Buffer for pointer values */
   const char *com;              /* Pointer to comment string */
   int index;                    /* Index into vector valued entry */
   int nel;                      /* Number of elements in value */
   int type;                     /* Entry data type */

/* Check the global error status. */
   if ( !astOK ) return;

/* Dump the entry key. */
   (void) sprintf( buff, "Key%d", nentry );
   astWriteString( channel, buff, 1, 1, entry->key, "Item name" );

/* Dump the comment if not blank. */
   if( entry->comment && *(entry->comment) ) {
      (void) sprintf( buff, "Com%d", nentry );
      astWriteString( channel, buff, 1, 1, entry->comment, "Item comment" );
   }

/* Get the data type and the length of the Entry. */
   type = entry->type;
   nel = entry->nel;

/* Dump the entry data type. */
   if( type == AST__STRINGTYPE ) {
      com = "Item data type (string)";

   } else if( type == AST__OBJECTTYPE ) {
      com = "Item data type (AST Object)";

   } else if( type == AST__INTTYPE ) {
      com = "Item data type (int)";

   } else if( type == AST__SINTTYPE ) {
      com = "Item data type (short int)";

   } else if( type == AST__KINTTYPE ) {
      com = "Item data type (64 bit int)";

   } else if( type == AST__BYTETYPE ) {
      com = "Item data type (unsigned byte)";

   } else if( type == AST__DOUBLETYPE ) {
      com = "Item data type (double)";

   } else if( type == AST__FLOATTYPE ) {
      com = "Item data type (float)";

   } else if( type == AST__POINTERTYPE ) {
      com = "Item data type (pointer)";

   } else if( type == AST__UNDEFTYPE ) {
      com = "Item data type (undefined)";

   } else {
      com = "";
      astError( AST__INTER, "DumpEntry(KeyMap): Illegal map entry data "
                "type %d encountered (internal AST programming error).", status,
                type );
   }
   (void) sprintf( buff, "Typ%d", nentry );
   astWriteInt( channel, buff, 1, 1, entry->type, com );

/* Dump the vector length */
   if( entry->nel > 0 ) {
      (void) sprintf( buff, "Nel%d", nentry );
      astWriteInt( channel, buff, 1, 1, entry->nel, "Vector length" );
   }

/* First deal with integer entries. */
   if( type == AST__INTTYPE ) {
      if( entry->nel == 0 ) {
         (void) sprintf( buff, "Val%d", nentry );
         astWriteInt( channel, buff, 1, 1, ((Entry0I *)entry)->value, "Item value" );
      } else {
         com = "Item values";
         for( index = 0; index < nel; index++ ){
            (void) sprintf( buff, "V%d_%d", nentry, index + 1 );
            astWriteInt( channel, buff, 1, 1, ((Entry1I *)entry)->value[ index ], com );
            com = "";
         }
      }

/* Similarly, deal with short int entries. */
   } else if( type == AST__SINTTYPE ) {
      if( entry->nel == 0 ) {
         (void) sprintf( buff, "Val%d", nentry );
         astWriteInt( channel, buff, 1, 1, (int) ((Entry0S *)entry)->value, "Item value" );
      } else {
         com = "Item values";
         for( index = 0; index < nel; index++ ){
            (void) sprintf( buff, "V%d_%d", nentry, index + 1 );
            astWriteInt( channel, buff, 1, 1, (int) ((Entry1S *)entry)->value[ index ], com );
            com = "";
         }
      }

/* Similarly, deal with 64 bit int entries. */
   } else if( type == AST__KINTTYPE ) {
      if( entry->nel == 0 ) {
         (void) sprintf( buff, "Val%d", nentry );
         astWriteInt64( channel, buff, 1, 1, (int64_t) ((Entry0K *)entry)->value, "Item value" );
      } else {
         com = "Item values";
         for( index = 0; index < nel; index++ ){
            (void) sprintf( buff, "V%d_%d", nentry, index + 1 );
            astWriteInt64( channel, buff, 1, 1, (int64_t) ((Entry1K *)entry)->value[ index ], com );
            com = "";
         }
      }

/* Similarly, deal with byte entries. */
   } else if( type == AST__BYTETYPE ) {
      if( entry->nel == 0 ) {
         (void) sprintf( buff, "Val%d", nentry );
         astWriteInt( channel, buff, 1, 1, (int) ((Entry0B *)entry)->value, "Item value" );
      } else {
         com = "Item values";
         for( index = 0; index < nel; index++ ){
            (void) sprintf( buff, "V%d_%d", nentry, index + 1 );
            astWriteInt( channel, buff, 1, 1, (int) ((Entry1B *)entry)->value[ index ], com );
            com = "";
         }
      }

/* Similarly deal with floating point entries. */
   } else if( type == AST__DOUBLETYPE ) {
      if( entry->nel == 0 ) {
         if( ((Entry0D *)entry)->value != AST__BAD ) {
            (void) sprintf( buff, "Val%d", nentry );
            astWriteDouble( channel, buff, 1, 1, ((Entry0D *)entry)->value, "Item value" );
         }
      } else {
         com = "Item values";
         for( index = 0; index < nel; index++ ){
            if( ((Entry1D *)entry)->value[ index ] != AST__BAD ) {
               (void) sprintf( buff, "V%d_%d", nentry, index + 1 );
               astWriteDouble( channel, buff, 1, 1, ((Entry1D *)entry)->value[ index ], com );
               com = "";
            }
         }
      }

/* Similarly deal with single precision floating point entries. */
   } else if( type == AST__FLOATTYPE ) {
      if( entry->nel == 0 ) {
         (void) sprintf( buff, "Val%d", nentry );
         astWriteDouble( channel, buff, 1, 1, (double) ((Entry0F *)entry)->value, "Item value" );
      } else {
         com = "Item values";
         for( index = 0; index < nel; index++ ){
            (void) sprintf( buff, "V%d_%d", nentry, index + 1 );
            astWriteDouble( channel, buff, 1, 1, (double) ((Entry1F *)entry)->value[ index ], com );
            com = "";
         }
      }

/* Do the same for string values. */
   } else if( type == AST__STRINGTYPE ) {
      if( entry->nel == 0 ) {
         (void) sprintf( buff, "Val%d", nentry );
         astWriteString( channel, buff, 1, 1, ((Entry0C *)entry)->value, "Item value" );
      } else {
         com = "Item values";
         for( index = 0; index < nel; index++ ){
            (void) sprintf( buff, "V%d_%d", nentry, index + 1 );
            astWriteString( channel, buff, 1, 1, ((Entry1C *)entry)->value[ index ], com );
            com = "";
         }
      }

/* Do the same for Object values. */
   } else if( type == AST__OBJECTTYPE ) {
      if( entry->nel == 0 ) {
         if( ((Entry0A *)entry)->value ) {
            (void) sprintf( buff, "Val%d", nentry );
            astWriteObject( channel, buff, 1, 1, ((Entry0A *)entry)->value, "Item value" );
         }
      } else {
         com = "Item values";
         for( index = 0; index < nel; index++ ){
            if( ((Entry1A *)entry)->value[ index ] ) {
               (void) sprintf( buff, "V%d_%d", nentry, index + 1 );
               astWriteObject( channel, buff, 1, 1, ((Entry1A *)entry)->value[ index ], com );
               com = "";
            }
         }
      }

/* Void pointer values cannot be dumped. */
   } else if( type == AST__POINTERTYPE ) {
      if( entry->nel == 0 ) {
         (void) sprintf( buff, "Val%d", nentry );
         (void) sprintf( pbuff, "%p", ((Entry0P *)entry)->value );
         astWriteString( channel, buff, 1, 1, pbuff, "Item value" );
      } else {
         com = "Item values";
         for( index = 0; index < nel; index++ ){
            (void) sprintf( buff, "V%d_%d", nentry, index + 1 );
            (void) sprintf( pbuff, "%p", ((Entry1P *)entry)->value[ index ]);
            astWriteString( channel, buff, 1, 1, pbuff, com );
            com = "";
         }
      }

/* Nothing further to do for undefined values. */
   } else if( type == AST__UNDEFTYPE ) {

/* Report an error if the data type is unknown. */
   } else if( astOK ) {
      astError( AST__INTER, "DumpEntry(KeyMap): Illegal map entry data "
                "type %d encountered (internal AST programming error).", status,
                type );
   }
}

static AstMapEntry *FreeMapEntry( AstMapEntry *in, int *status ){
/*
*  Name:
*     FreeMapEntry

*  Purpose:
*     Frees the supplied KeyMap entry.

*  Type:
*     Private function.

*  Synopsis:
*     #include "keymap.h"
*     AstMapEntry *FreeMapEntry( AstMapEntry *in, int *status )

*  Class Membership:
*     KeyMap member function.

*  Description:
*     This function frees resources used by the supplied MapEntry, then
*     frees the MapEntry structure itself and returns a NULL pointer.

*  Parameters:
*     in
*        Pointer to the MapEntry to be freed. NULL may be supplied in
*        which the function returns without action.
*     status
*        Pointer to the inherited status variable.

*  Returned Value:
*     A NULL pointer.

*  Notes:
*     - It is the callers responsibility to ensure that any other MapEntry
*     which refers to the supplied MapEntry (e.g. through the "next" link
*     in the MapEntry structure) is modified to take account of the
*     freeing of the supplied MapEntry.
*     - This function attempts to execute even if it is invoked with the
*     global error status set.
*/

/* Local Variables: */
   AstObject **alist;     /* Pointer to list of AST object pointers */
   AstObject *obj;        /* Pointer to AST object */
   const char **slist;    /* Pointer to list of text pointers */
   int i;                 /* Loop count */
   int nel;               /* No. of values in entry vector (0 => scalar) */
   int old_status;        /* Status value on entry */
   int type;              /* Entry data type */

/* Check the supplied pointer. */
   if( !in ) return NULL;

/* Get the data type and length of the MapEntry. */
   nel = in->nel;
   type = in->type;

/* Record the current status */
   old_status = astStatus;

/* First deal with string entries. */
   if( type == AST__STRINGTYPE ) {

/* For scalar valued entries, free the single string in the input entry. */
      if( nel == 0 ) {
         ( (Entry0C *) in )->value = (const char *) astFree( ( void *) ( (Entry0C *) in )->value );

/* For vector valued entries, free the strings, then free the array storing
   the string pointers. */
      } else {
         slist = ( (Entry1C *) in )->value;
         if( slist ) {
            for( i = 0; i < nel; i++ ) slist[ i ] = astFree( (void *) slist[ i ] );
            ( (Entry1C *) in )->value = astFree( (void *) slist );
         }
      }

/* Similarly deal with AST Object entries. */
   } else if( type == AST__OBJECTTYPE ) {
      if( nel == 0 ) {
         obj = ( (Entry0A *) in )->value;
         if( obj ) ( (Entry0A *) in )->value = astAnnul( obj );
         ( (Entry0A *) in )->next = NULL;
         ( (Entry0A *) in )->prev = NULL;
      } else {
         alist = ( (Entry1A *) in )->value;
         if( alist ) {
            for( i = 0; i < nel; i++ ) {
               if( alist[ i ] ) alist[ i ] = astAnnul( alist[ i ] );
            }
            ( (Entry1A *) in )->value = astFree( alist );
            ( (Entry1A *) in )->next = NULL;
            ( (Entry1A *) in )->prev = NULL;
         }
      }

/* Now deal with integer entries. Scalar entries do not need any further
   action. If this is a vector entry free the values array. */
   } else if( type == AST__INTTYPE ) {
      if( nel > 0 ) ( (Entry1I *) in )->value = astFree( ( (Entry1I *) in )->value );

/* Now deal with short int entries. Scalar entries do not need any further
   action. If this is a vector entry free the values array. */
   } else if( type == AST__SINTTYPE ) {
      if( nel > 0 ) ( (Entry1S *) in )->value = astFree( ( (Entry1S *) in )->value );

/* Now deal with 64 bit int entries. Scalar entries do not need any further
   action. If this is a vector entry free the values array. */
   } else if( type == AST__KINTTYPE ) {
      if( nel > 0 ) ( (Entry1K *) in )->value = astFree( ( (Entry1K *) in )->value );

/* Now deal with byte entries. Scalar entries do not need any further
   action. If this is a vector entry free the values array. */
   } else if( type == AST__BYTETYPE ) {
      if( nel > 0 ) ( (Entry1B *) in )->value = astFree( ( (Entry1B *) in )->value );

/* Similarly deal with void * pointer entries. */
   } else if( type == AST__POINTERTYPE ) {
      if( nel > 0 ) ( (Entry1P *) in )->value = astFree( ( (Entry1P *) in )->value );

/* Similarly deal with floating point entries. */
   } else if( type == AST__DOUBLETYPE ) {
      if( nel > 0 ) ( (Entry1D *) in )->value = astFree( ( (Entry1D *) in )->value );

/* Similarly deal with single precision floating point entries. */
   } else if( type == AST__FLOATTYPE ) {
      if( nel > 0 ) ( (Entry1F *) in )->value = astFree( ( (Entry1F *) in )->value );

/* Nothing further to do for undefined values. */
   } else if( type == AST__UNDEFTYPE ) {

/* Report an error if the data type is unknown. */
   } else {
      astError( AST__INTER, "FreeMapEntry(KeyMap): Illegal map entry data "
                "type %d encountered (internal AST programming error).", status,
                type );
   }

/* Free or nullify pointers in the AstMapEntry structure. */
   in->next = NULL;
   in->snext = NULL;
   in->sprev = NULL;
   in->comment = astFree( (void *) in->comment );

/* If an error has occurred in this function, issue a context message. */
   if( !astOK && old_status == 0 ) {
      astError( astStatus, "astDelete(KeyMap): Error freeing KeyMap entry '%s'.",
                status, in->key );
   }

/* Now free the key and then free the complete AstMapEntry structure. */
   in->key = astFree( (void *) in->key );
   astFree( in );

/* Return a NULL pointer. */
   return NULL;
}

static void FreeTableEntry( AstKeyMap *this, int itab, int *status ){
/*
*  Name:
*     FreeTableEntry

*  Purpose:
*     Frees the linked list of KeyMap entries stored in a given element of
*     the hash table.

*  Type:
*     Private function.

*  Synopsis:
*     #include "keymap.h"
*     void FreeTableEntry( AstKeyMap *this, int itab, int *status )

*  Class Membership:
*     KeyMap member function.

*  Description:
*     This function frees resources used by all the MapEntries in the
*     linked list associated with the specified element of the hash table
*     of the supplied KeyMap.

*  Parameters:
*     this
*        Pointer to the KeyMap
*     itab
*        Index of the hash table element to free.
*     status
*        Pointer to the inherited status variable.

*  Notes:
*     - This function attempts to execute even if it is invoked with the
*     global error status set.
*/

/* Local Variables: */
   AstMapEntry *link;     /* Pointer the next but one MapEntry to be freed */
   AstMapEntry *next;     /* Pointer the next MapEntry to be freed */

/* Check it is safe to proceed. */
   if( this && itab >= 0 && itab < this->mapsize ) {

/* Store a pointer to the MapEntry which is to be freed next. */
      next = this->table[ itab ];

/* Loop round freeing all MapEntries in the linked list. */
      while( next ) {

/* Store a pointer to the MapEntry which will be freed after this one. */
         link = next->next;

/* Free this MapEntry */
         (void) FreeMapEntry( next, status );

/* Set up the next MapEntry to be freed. */
         next = link;
      }

/* Store a NULL pointer in the table element. */
      this->table[ itab ] = NULL;

/* Sets the number of entries in this hash table element to zero. */
      this->nentry[ itab ] = 0;
   }
}

static const char *GetAttrib( AstObject *this_object, const char *attrib, int *status ) {
/*
*  Name:
*     GetAttrib

*  Purpose:
*     Get the value of a specified attribute for a KeyMap.

*  Type:
*     Private function.

*  Synopsis:
*     #include "keymap.h"
*     const char *GetAttrib( AstObject *this, const char *attrib, int *status )

*  Class Membership:
*     KeyMap member function (over-rides the protected astGetAttrib
*     method inherited from the Mapping class).

*  Description:
*     This function returns a pointer to the value of a specified
*     attribute for a KeyMap, formatted as a character string.

*  Parameters:
*     this
*        Pointer to the KeyMap.
*     attrib
*        Pointer to a null-terminated string containing the name of
*        the attribute whose value is required. This name should be in
*        lower case, with all white space removed.
*     status
*        Pointer to the inherited status variable.

*  Returned Value:
*     - Pointer to a null-terminated string containing the attribute
*     value.

*  Notes:
*     - The returned string pointer may point at memory allocated
*     within the KeyMap, or at static memory. The contents of the
*     string may be over-written or the pointer may become invalid
*     following a further invocation of the same function or any
*     modification of the KeyMap. A copy of the string should
*     therefore be made if necessary.
*     - A NULL pointer will be returned if this function is invoked
*     with the global error status set, or if it should fail for any
*     reason.
*/

/* Local Variables: */
   astDECLARE_GLOBALS            /* Declare the thread specific global data */
   AstKeyMap *this;              /* Pointer to the KeyMap structure */
   const char *result;           /* Pointer value to return */
   int ival;                     /* Attribute value */

/* Initialise. */
   result = NULL;

/* Check the global error status. */
   if ( !astOK ) return result;

/* Get a pointer to the structure holding thread-specific global data. */
   astGET_GLOBALS(this_object);

/* Obtain a pointer to the KeyMap structure. */
   this = (AstKeyMap *) this_object;

/* Compare "attrib" with each recognised attribute name in turn,
   obtaining the value of the required attribute. If necessary, write
   the value into "getattrib_buff" as a null-terminated string in an appropriate
   format.  Set "result" to point at the result string. */

/* SizeGuess. */
/* ---------- */
   if ( !strcmp( attrib, "sizeguess" ) ) {
      ival = astGetSizeGuess( this );
      if ( astOK ) {
         (void) sprintf( getattrib_buff, "%d", ival );
         result = getattrib_buff;
      }

/* KeyCase. */
/* --------- */
   } else if ( !strcmp( attrib, "keycase" ) ) {
      ival = astGetKeyCase( this );
      if ( astOK ) {
         (void) sprintf( getattrib_buff, "%d", ival );
         result = getattrib_buff;
      }

/* KeyError. */
/* --------- */
   } else if ( !strcmp( attrib, "keyerror" ) ) {
      ival = astGetKeyError( this );
      if ( astOK ) {
         (void) sprintf( getattrib_buff, "%d", ival );
         result = getattrib_buff;
      }

/* MapLocked. */
/* --------- */
   } else if ( !strcmp( attrib, "maplocked" ) ) {
      ival = astGetMapLocked( this );
      if ( astOK ) {
         (void) sprintf( getattrib_buff, "%d", ival );
         result = getattrib_buff;
      }

/* SortBy. */
/* --------- */
   } else if ( !strcmp( attrib, "sortby" ) ) {
      ival = astGetSortBy( this );
      if ( astOK ) {
         result = SortByString( ival, "astGetAttrib", status );
      }

/* If the attribute name was not recognised, pass it on to the parent
   method for further interpretation. */
   } else {
      result = (*parent_getattrib)( this_object, attrib, status );
   }

/* Return the result. */
   return result;

}

static size_t GetObjSize( AstObject *this_object, int *status ) {
/*
*  Name:
*     GetObjSize

*  Purpose:
*     Return the in-memory size of an Object.

*  Type:
*     Private function.

*  Synopsis:
*     #include "keymap.h"
*     size_t GetObjSize( AstObject *this, int *status )

*  Class Membership:
*     KeyMap member function (over-rides the astGetObjSize protected
*     method inherited from the parent class).

*  Description:
*     This function returns the in-memory size of the supplied KeyMap,
*     in bytes.

*  Parameters:
*     this
*        Pointer to the KeyMap.
*     status
*        Pointer to the inherited status variable.

*  Returned Value:
*     The Object size, in bytes.

*  Notes:
*     - A value of zero will be returned if this function is invoked
*     with the global status set, or if it should fail for any reason.
*/

/* Local Variables: */
   AstKeyMap *this;       /* Pointer to KeyMap structure */
   AstMapEntry *next;     /* Pointer the next MapEntry */
   AstObject **alist;     /* Pointer to list of AST object pointers */
   AstObject *obj;        /* Pointer to AST object */
   const char **slist;    /* Pointer to list of text pointers */
   int i;                 /* Loop count */
   int itab;              /* Table entry index */
   int nel;               /* No. of values in entry vector (0 => scalar) */
   size_t result;         /* Result value to return */
   int type;              /* Entry data type */

/* Initialise. */
   result = 0;

/* Check the global error status. */
   if ( !astOK ) return result;

/* Obtain a pointers to the KeyMap structure. */
   this = (AstKeyMap *) this_object;

/* Invoke the GetObjSize method inherited from the parent class, and then
   add on any components of the class structure defined by thsi class
   which are stored in dynamically allocated memory. */
   result = (*parent_getobjsize)( this_object, status );

   for( itab = 0; itab < this->mapsize; itab++ ) {
      next = this->table[ itab ];
      while( next ) {
         nel = next->nel;
         type = next->type;

         if( type == AST__STRINGTYPE ) {

            if( nel == 0 ) {
               result += astTSizeOf( ( void *) ( (Entry0C *) next )->value );

            } else {
               slist = ( (Entry1C *) next )->value;
               if( slist ) {
                  for( i = 0; i < nel; i++ ) result += astTSizeOf( (void *) slist[ i ] );
                  result += astTSizeOf( (void *) slist );
               }
            }

         } else if( type == AST__OBJECTTYPE ) {
            if( nel == 0 ) {
               obj = ( (Entry0A *) next )->value;
               result += astGetObjSize( obj );
            } else {
               alist = ( (Entry1A *) next )->value;
               if( alist ) {
                  for( i = 0; i < nel; i++ ) {
                     result += astGetObjSize( alist[ i ] );
                  }
                  result += astTSizeOf( alist );
               }
            }

         } else if( type == AST__POINTERTYPE ) {
            if( nel > 0 ) result += astTSizeOf( ( (Entry1P *) next )->value );

         } else if( type == AST__INTTYPE ) {
            if( nel > 0 ) result += astTSizeOf( ( (Entry1I *) next )->value );

         } else if( type == AST__SINTTYPE ) {
            if( nel > 0 ) result += astTSizeOf( ( (Entry1S *) next )->value );

         } else if( type == AST__KINTTYPE ) {
            if( nel > 0 ) result += astTSizeOf( ( (Entry1K *) next )->value );

         } else if( type == AST__BYTETYPE ) {
            if( nel > 0 ) result += astTSizeOf( ( (Entry1B *) next )->value );

         } else if( type == AST__DOUBLETYPE ) {
            if( nel > 0 ) result += astTSizeOf( ( (Entry1D *) next )->value );

         } else if( type == AST__FLOATTYPE ) {
            if( nel > 0 ) result += astTSizeOf( ( (Entry1F *) next )->value );

         } else if( type == AST__UNDEFTYPE ) {

         } else {
            astError( AST__INTER, "astGetObjSize(KeyMap): Illegal map entry data "
                      "type %d encountered (internal AST programming error).", status,
                      type );
         }

         result += astTSizeOf( (void *) next->key );
         result += astTSizeOf( (void *) next->comment );
         result += astTSizeOf( next );

         next = next->next;
      }
   }

/* If an error occurred, clear the result value. */
   if ( !astOK ) result = 0;

/* Return the result, */
   return result;
}

static const char *GetKey( AstKeyMap *this, int index, int *status ) {
/*
*  Name:
*     GetKey

*  Purpose:
*     Get the key at a given index within the KeyMap.

*  Type:
*     Private member function.

*  Synopsis:
*     #include "keymap.h"
*     const char *GetKey( AstKeyMap *this, int index, int *status )

*  Class Membership:
*     KeyMap method.

*  Description:
*     This function returns a string holding the key for the entry with
*     the given index within the KeyMap. The index associated with a
*     given key is determined by the current setting of the SortBy attribute.

*  Parameters:
*     this
*        Pointer to the KeyMap.
*     index
*        The index into the KeyMap. The first entry has index zero, and the last
*        has index "size-1", where "size" is the value returned by the
*        astMapSize function. An error is reported if the supplied index is
*        out of bounds.
*     status
*        Pointer to the inherited status variable.

*  Returned Value:
*        A pointer to a null-terminated string containing the key.

*  Notes:
*     - A NULL pointer will be returned if this function is invoked
*     with the AST error status set, or if it should fail for any
*     reason.
*/

/* Local Variables: */
   AstMapEntry *entry;         /* Pointer to the entry */
   const char *result;         /* Pointer value to return */
   int ifirst;                 /* Index of first entry in this table element */
   int ilast;                  /* Index of last entry in this table element */
   int istep;                  /* Entry count */
   int itab;                   /* Index into hash table */
   int nstep;                  /* No. of entries to skip */
   int sortby;                 /* The value of the SortBy attribute */

/* Initialise. */
   result = NULL;

/* Check the global error status. */
   if ( !astOK ) return result;

/* Get the SortBy value. */
   sortby = astGetSortBy( this );

/* First deal with unsorted keys. */
   if( sortby == SORTBY_NONE ) {

/* Loop round each entry in the hash table. */
      ilast = -1;
      for( itab = 0; itab < this->mapsize; itab++ ) {

/* Find the index of the first and the last Entry in the linked list associated
   with this element of the hash table. */
         ifirst = ilast + 1;
         ilast += this->nentry[ itab ];

/* Pass on if we have not yet reached the element containing the required
   key. */
         if( ilast >= index ) {

/* Find how many steps we need to proceed down the linked list to reach
   the required index. */
            nstep = index - ifirst;

/* Make this many steps down the linked list.*/
            entry = this->table[ itab ];
            for( istep = 0; entry && istep < nstep; istep++ ) entry = entry->next;

/* Return a pointer to the key string, and break out of the loop. */
            if( entry ) result = entry->key;
            break;

         }
      }

/* Now deal with sorted keys. */
   } else {

/* Get a pointer to the first entry in the sorted list. */
      entry = this->first;

/* Move up the sorted list by the required number of entries. */
      for( istep = 0; entry && istep < index; istep++ ) {
         entry = entry->snext;
         if( entry == this->first ) {
            entry = NULL;
            break;
         }
      }

/* Return a pointer to the key string. */
      if( entry ) result = entry->key;
   }

/* Report an error if the element was not found. */
   if( !result && astOK ) {
      astError( AST__MPIND, "astMapKey(%s): Cannot find element "
                "%d (zero-based) of the %s.", status, astGetClass( this ),
                index, astGetClass( this ) );
   }

/* Return the result.*/
   return result;
}

static int GetSizeGuess( AstKeyMap *this, int *status ) {
/*
*+
*  Name:
*     astGetSizeGuess

*  Purpose:
*     Get the value of the SizeGuess attribute for a KeyMap.

*  Type:
*     Protected virtual function.

*  Synopsis:
*     #include "keymap.h"
*     int astGetSizeGuess( AstKeyMap *this )

*  Class Membership:
*     KeyMap method.

*  Description:
*     This function returns the value of the SizeGuess attribute for a
*     KeyMap.

*  Parameters:
*     this
*        Pointer to the KeyMap.

*  Returned Value:
*     The value of the SizeGuess attribute.

*  Notes:
*     - A value of zero is returned if this function is invoked with the
*     global error status set.

*-
*/

/* Local Variables: */
   int result;                /* Returned value */

/* Initialise */
   result = 0;

/* Check the global error status. */
   if ( !astOK ) return result;

/* Return the attribute value using a default if not set. */
   return ( this->sizeguess == INT_MAX ) ?
           MIN_TABLE_SIZE*MAX_ENTRIES_PER_TABLE_ENTRY : this->sizeguess;
}

static int HashFun( const char *key, int bitmask, unsigned long *hash, int *status ){
/*
*  Name:
*     HashFun

*  Purpose:
*     Returns an integer hash code for a string

*  Type:
*     Private function.

*  Synopsis:
*     #include "keymap.h"
*     int HashFun( const char *key, int bitmask, int *hash, int *status )

*  Class Membership:
*     KeyMap member function.

*  Description:
*     This function returns an integer hash code for the supplied string,
*     This is the value that isused as the index into the hash table for
*     the specified key.

*  Parameters:
*     key
*        Pointer to the string. Trailing spaces are ignored.
*     bitmask
*        A bit mask that is used to zero the upper bits of a full width
*        hash value in order to produce the required array index. This
*        should be one less than the length of the hash table.
*     hash
*        Pointer to a location at which to put the full width hash value.
*     status
*        Pointer to the inherited status variable.

*  Returned Value:
*     An integer in the range zero to ( mapsize - 1 ).

*  Notes:
*     - A value of zero is returned if this function is invoked with the
*     global error status set.
*/

/* Local Variables: */
   int c;

/* Check the local error status. */
   if ( !astOK ) return 0;

/* djb2: This hash function was first reported by Dan Bernstein many years
   ago in comp.lang.c Each through the "hile" loop corresponds to
   "hash = hash*33 + c ". Ignore spaces so that trailing spaces used to
   pad F77 character variables will be ignored. */
   *hash = 5381;
   while( (c = *key++) ) {
      if( c != ' ' ) {
         *hash = ((*hash << 5) + *hash) + c;
      }
   }
   return ( *hash & bitmask );
}

void astInitKeyMapVtab_(  AstKeyMapVtab *vtab, const char *name, int *status ) {
/*
*+
*  Name:
*     astInitKeyMapVtab

*  Purpose:
*     Initialise a virtual function table for a KeyMap.

*  Type:
*     Protected function.

*  Synopsis:
*     #include "keymap.h"
*     void astInitKeyMapVtab( AstKeyMapVtab *vtab, const char *name )

*  Class Membership:
*     KeyMap vtab initialiser.

*  Description:
*     This function initialises the component of a virtual function
*     table which is used by the KeyMap class.

*  Parameters:
*     vtab
*        Pointer to the virtual function table. The components used by
*        all ancestral classes will be initialised if they have not already
*        been initialised.
*     name
*        Pointer to a constant null-terminated character string which contains
*        the name of the class to which the virtual function table belongs (it
*        is this pointer value that will subsequently be returned by the Object
*        astClass function).
*-
*/

/* Local Variables: */
   astDECLARE_GLOBALS            /* Pointer to thread-specific global data */
   AstObjectVtab *object;        /* Pointer to Object component of Vtab */

/* Check the local error status. */
   if ( !astOK ) return;

/* Get a pointer to the thread specific global data structure. */
   astGET_GLOBALS(NULL);

/* Initialize the component of the virtual function table used by the
   parent class. */
   astInitObjectVtab( (AstObjectVtab *) vtab, name );

/* Store a unique "magic" value in the virtual function table. This
   will be used (by astIsAKeyMap) to determine if an object belongs
   to this class.  We can conveniently use the address of the (static)
   class_check variable to generate this unique value. */
   vtab->id.check = &class_check;
   vtab->id.parent = &(((AstObjectVtab *) vtab)->id);

/* Initialise member function pointers. */
/* ------------------------------------ */
/* Store pointers to the member functions (implemented here) that provide
   virtual methods for this class. */

   vtab->MapGet0P = MapGet0P;
   vtab->MapGet0A = MapGet0A;
   vtab->MapGet0C = MapGet0C;
   vtab->MapGet0D = MapGet0D;
   vtab->MapGet0F = MapGet0F;
   vtab->MapGet0I = MapGet0I;
   vtab->MapGet0K = MapGet0K;
   vtab->MapGet0B = MapGet0B;
   vtab->MapGet0S = MapGet0S;
   vtab->MapGet1P = MapGet1P;
   vtab->MapGet1A = MapGet1A;
   vtab->MapGet1C = MapGet1C;
   vtab->MapGet1D = MapGet1D;
   vtab->MapGet1F = MapGet1F;
   vtab->MapGet1I = MapGet1I;
   vtab->MapGet1K = MapGet1K;
   vtab->MapGet1B = MapGet1B;
   vtab->MapGet1S = MapGet1S;
   vtab->MapGetC = MapGetC;
   vtab->MapGetElemP = MapGetElemP;
   vtab->MapGetElemA = MapGetElemA;
   vtab->MapGetElemC = MapGetElemC;
   vtab->MapGetElemD = MapGetElemD;
   vtab->MapGetElemF = MapGetElemF;
   vtab->MapGetElemI = MapGetElemI;
   vtab->MapGetElemK = MapGetElemK;
   vtab->MapGetElemS = MapGetElemS;
   vtab->MapGetElemB = MapGetElemB;
   vtab->MapPutElemP = MapPutElemP;
   vtab->MapPutElemA = MapPutElemA;
   vtab->MapPutElemC = MapPutElemC;
   vtab->MapPutElemD = MapPutElemD;
   vtab->MapPutElemF = MapPutElemF;
   vtab->MapPutElemI = MapPutElemI;
   vtab->MapPutElemS = MapPutElemS;
   vtab->MapPutElemK = MapPutElemK;
   vtab->MapPutElemB = MapPutElemB;
   vtab->MapPut0A = MapPut0A;
   vtab->MapPut0P = MapPut0P;
   vtab->MapPut0C = MapPut0C;
   vtab->MapPut0D = MapPut0D;
   vtab->MapPut0F = MapPut0F;
   vtab->MapPut0I = MapPut0I;
   vtab->MapPut0S = MapPut0S;
   vtab->MapPut0K = MapPut0K;
   vtab->MapPut0B = MapPut0B;
   vtab->MapPut1P = MapPut1P;
   vtab->MapPut1A = MapPut1A;
   vtab->MapPut1C = MapPut1C;
   vtab->MapPut1D = MapPut1D;
   vtab->MapPut1F = MapPut1F;
   vtab->MapPut1I = MapPut1I;
   vtab->MapPut1S = MapPut1S;
   vtab->MapPut1K = MapPut1K;
   vtab->MapPut1B = MapPut1B;
   vtab->MapPutU = MapPutU;
   vtab->MapRemove = MapRemove;
   vtab->MapRename = MapRename;
   vtab->MapCopy = MapCopy;
   vtab->MapCopyEntry = MapCopyEntry;
   vtab->MapDefined = MapDefined;
   vtab->MapSize = MapSize;
   vtab->MapLenC = MapLenC;
   vtab->MapLength = MapLength;
   vtab->MapType = MapType;
   vtab->MapHasKey = MapHasKey;
   vtab->MapKey = MapKey;
   vtab->MapIterate = MapIterate;

   vtab->ClearSizeGuess = ClearSizeGuess;
   vtab->SetSizeGuess = SetSizeGuess;
   vtab->GetSizeGuess = GetSizeGuess;
   vtab->TestSizeGuess = TestSizeGuess;

   vtab->ClearSortBy = ClearSortBy;
   vtab->SetSortBy = SetSortBy;
   vtab->GetSortBy = GetSortBy;
   vtab->TestSortBy = TestSortBy;

   vtab->ClearKeyError = ClearKeyError;
   vtab->SetKeyError = SetKeyError;
   vtab->GetKeyError = GetKeyError;
   vtab->TestKeyError = TestKeyError;

   vtab->ClearKeyCase = ClearKeyCase;
   vtab->SetKeyCase = SetKeyCase;
   vtab->GetKeyCase = GetKeyCase;
   vtab->TestKeyCase = TestKeyCase;

   vtab->ClearMapLocked = ClearMapLocked;
   vtab->SetMapLocked = SetMapLocked;
   vtab->GetMapLocked = GetMapLocked;
   vtab->TestMapLocked = TestMapLocked;

/* Save the inherited pointers to methods that will be extended, and
   replace them with pointers to the new member functions. */
   object = (AstObjectVtab *) vtab;

/* Store replacement pointers for methods which will be over-ridden by
   new member functions implemented here. */
   parent_getobjsize = object->GetObjSize;
   object->GetObjSize = GetObjSize;

   parent_clearattrib = object->ClearAttrib;
   object->ClearAttrib = ClearAttrib;
   parent_getattrib = object->GetAttrib;
   object->GetAttrib = GetAttrib;
   parent_setattrib = object->SetAttrib;
   object->SetAttrib = SetAttrib;
   parent_testattrib = object->TestAttrib;
   object->TestAttrib = TestAttrib;

#if defined(THREAD_SAFE)
   parent_managelock = object->ManageLock;
   object->ManageLock = ManageLock;
#endif

/* Declare the destructor, copy constructor and dump function. */
   astSetDelete( vtab, Delete );
   astSetCopy( vtab, Copy );
   astSetDump( vtab, Dump, "KeyMap", "Map of key/value pairs" );

/* If we have just initialised the vtab for the current class, indicate
   that the vtab is now initialised, and store a pointer to the class
   identifier in the base "object" level of the vtab. */
   if( vtab == &class_vtab ) {
      class_init = 1;
      astSetVtabClassIdentifier( vtab, &(vtab->id) );
   }
}

static void InitMapEntry( AstMapEntry *entry, int type, int nel, int *status ){
/*
*  Name:
*     InitMapEntry

*  Purpose:
*     initialise a MapEntry structure to null values.

*  Type:
*     Private function.

*  Synopsis:
*     #include "keymap.h"
*     void InitMapEntry( AstMapEntry *entry, int type, int nel, int *status )

*  Class Membership:
*     KeyMap member function.

*  Description:
*     This function initialises the contents of a MapEntry to null values.

*  Parameters:
*     this
*        Pointer to the MapEntry.
*     type
*        The type of the MapEntry.
*     nel
*        The number of elements in the entry: 0 = scalar, >0 = vector.
*     status
*        Pointer to the inherited status variable.

*/

/* Check the global error status. */
   if( !astOK ) return;

/* Initialise all elements with in the MapEntry structure. */
   entry->next = NULL;
   entry->key = NULL;
   entry->hash = 0;
   entry->type = type;
   entry->nel = nel;
   entry->comment = NULL;
   entry->defined = 0;
   entry->snext = NULL;
   entry->sprev = NULL;
   entry->member = 0;
   entry->keymember = 0;
   entry->sortby = SORTBY_NONE;

   if( type == AST__OBJECTTYPE ) {
      if( nel == 0 ) {
         ( (Entry0A *) entry )->next = NULL;
         ( (Entry0A *) entry )->prev = NULL;
      } else {
         ( (Entry1A *) entry )->next = NULL;
         ( (Entry1A *) entry )->prev = NULL;
      }
   }

}

static int KeyCmp( const char *key1, const char *key2 ) {
/*
*  Name:
*     KeyCmp

*  Purpose:
*     Compares keys for equality.

*  Type:
*     Private function.

*  Synopsis:
*     #include "keymap.h"
*     int KeyCmp( const char *key1, const char *key2 )

*  Class Membership:
*     KeyMap member function.

*  Description:
*     This function compares two strings. It is like strcmp except that it
*     ignores trailing spaces.

*  Parameters:
*     key1
*        Pointer to first string.
*     key2
*        Pointer to second string.

*  Returned Value:
*     One if the keys differ. Zero if they are identical (except for
*     trailing spaces).

*/

/* Local Variables: */
   const char *k1;               /* Pointer to next "key1" character */
   const char *k2;               /* Pointer to next "key2" character */
   int result;                   /* Returned flag */

/* Check the strings are deifned. */
   if ( !key1 || !key2 ) return 0;

/* Get pointers to the first characters to differ, or to the first null
   character, which ever comes first. */
   k1 = key1;
   k2 = key2;
   while( *k1 && ( *k1 == *k2 ) ) {
      k1++;
      k2++;
   }

/* If both characters are null, the strings are identical. If neither is null,
   the string definitely differ. If one is null, we need to check if the
   other one only has spaces to the end of the string. */
   if( *k1 ) {
      if( *k2 ) {
         result = ( *k1 > *k2 ) ? 1 : -1;
      } else {
         while( *k1 == ' ' ) k1++;
         result = ( *k1 == 0 ) ? 0 : 1;
      }
   } else {
      if( *k2 ) {
         while( *k2 == ' ' ) k2++;
         result = ( *k2 == 0 ) ? 0 : -1;
      } else {
         result = 0;
      }
   }

/* Return the result. */
   return result;
}

#if defined(THREAD_SAFE)
static int ManageLock( AstObject *this_object, int mode, int extra,
                       AstObject **fail, int *status ) {
/*
*  Name:
*     ManageLock

*  Purpose:
*     Manage the thread lock on an Object.

*  Type:
*     Private function.

*  Synopsis:
*     #include "object.h"
*     AstObject *ManageLock( AstObject *this, int mode, int extra,
*                            AstObject **fail, int *status )

*  Class Membership:
*     KeyMap member function (over-rides the astManageLock protected
*     method inherited from the parent class).

*  Description:
*     This function manages the thread lock on the supplied Object. The
*     lock can be locked, unlocked or checked by this function as
*     deteremined by parameter "mode". See astLock for details of the way
*     these locks are used.

*  Parameters:
*     this
*        Pointer to the Object.
*     mode
*        An integer flag indicating what the function should do:
*
*        AST__LOCK: Lock the Object for exclusive use by the calling
*        thread. The "extra" value indicates what should be done if the
*        Object is already locked (wait or report an error - see astLock).
*
*        AST__UNLOCK: Unlock the Object for use by other threads.
*
*        AST__CHECKLOCK: Check that the object is locked for use by the
*        calling thread (report an error if not).
*     extra
*        Extra mode-specific information.
*     fail
*        If a non-zero function value is returned, a pointer to the
*        Object that caused the failure is returned at "*fail". This may
*        be "this" or it may be an Object contained within "this". Note,
*        the Object's reference count is not incremented, and so the
*        returned pointer should not be annulled. A NULL pointer is
*        returned if this function returns a value of zero.
*     status
*        Pointer to the inherited status variable.

*  Returned Value:
*    A local status value:
*        0 - Success
*        1 - Could not lock or unlock the object because it was already
*            locked by another thread.
*        2 - Failed to lock a POSIX mutex
*        3 - Failed to unlock a POSIX mutex
*        4 - Bad "mode" value supplied.

*  Notes:
*     - This function attempts to execute even if an error has already
*     occurred.
*/

/* Local Variables: */
   AstKeyMap *this;       /* Pointer to KeyMap structure */
   AstMapEntry *next;     /* Pointer the next MapEntry */
   AstObject **alist;     /* Pointer to list of AST object pointers */
   AstObject *obj;        /* Pointer to AST object */
   int i;                 /* Loop count */
   int nel;               /* No. of values in entry vector (0 => scalar) */
   int result;            /* Returned status value */

/* Initialise */
   result = 0;

/* Check the supplied pointer is not NULL. */
   if( !this_object ) return result;

/* Obtain a pointers to the KeyMap structure. */
   this = (AstKeyMap *) this_object;

/* Invoke the ManageLock method inherited from the parent class. */
   if( !result ) result = (*parent_managelock)( this_object, mode, extra,
                                                fail, status );

/* Invoke the astManageLock method on any Objects contained within
   the supplied Object. */

   next = this->firstA;
   while( next ) {
      nel = next->nel;
      if( nel == 0 ) {
         obj = ( (Entry0A *) next )->value;
         if( !result ) result = astManageLock( obj, mode, extra, fail );
         next = ( (Entry0A *) next)->next;
      } else {
         alist = ( (Entry1A *) next )->value;
         if( alist ) {
            for( i = 0; i < nel; i++ ) {
               if( !result ) result = astManageLock( alist[ i ], mode,
                                                     extra, fail );
            }
         }
         next = ( (Entry1A *) next)->next;
      }
   }

   return result;

}
#endif

static void MapCopy( AstKeyMap *this, AstKeyMap *that, int *status ) {
/*
*++
*  Name:
c     astMapCopy
f     AST_MAPCOPY

*  Purpose:
*     Copy all entries from one KeyMap into another.

*  Type:
*     Public virtual function.

*  Synopsis:
c     #include "keymap.h"
c     void astMapCopy( AstKeyMap *this, AstKeyMap *that )
f     CALL AST_MAPCOPY( THIS, THAT, STATUS )

*  Class Membership:
*     KeyMap method.

*  Description:
c     This function
f     This routine
*     copies all entries from one KeyMap into another.

*  Parameters:
c     this
f     THIS = INTEGER (Given)
*        Pointer to the destination KeyMap.
c     that
f     THAT = INTEGER (Given)
*        Pointer to the source KeyMap.
f     STATUS = INTEGER (Given and Returned)
f        The global status.

*  Notes:
*     - Entries from the source KeyMap will replace any existing entries in
*     the destination KeyMap that have the same key.
*     - The one exception to the above rule is that if a source entry
*     contains a scalar KeyMap entry, and the destination contains a
*     scalar KeyMap entry with the same key, then the source KeyMap entry
*     will be copied into the destination KeyMap entry using this function,
*     rather than simply replacing the destination KeyMap entry.
*     - If the destination entry has a non-zero value for its MapLocked
*     attribute, then an error will be reported if the source KeyMap
*     contains any keys that do not already exist within the destination
*     KeyMap.

*--
*/

/* Local Variables: */
   AstMapEntry *in_entry; /* Pointer to next source entry to copy */
   AstMapEntry *out_entry;/* Pointer to existing destination entry */
   AstObject *in_obj;     /* Pointer for source Object entry */
   AstObject *out_obj;    /* Pointer for destination Object entry */
   const char *key;       /* Key for current entry */
   int i;                 /* Index into source hash table */
   int itab;              /* Index of destination hash table element */
   int keymember;         /* Identifier for key */
   int merged;            /* Were source and destination KeyMaps merged? */
   unsigned long hash;    /* Full width hash value */

/* Check the global error status. */
   if ( !astOK ) return;

/* Loop round all entries in the source hash table. */
   for( i = 0; i < that->mapsize; i++ ) {

/* Get a pointer to the next source KeyMap entry. */
      in_entry = that->table[ i ];

/* Loop round all entries in this element of the source hash table. */
      while( in_entry && astOK ) {

/* Get its key. */
         key = in_entry->key;

/* Search for a destination entry with the same key. */
         itab = HashFun( key, this->mapsize - 1, &hash, status );
         out_entry = SearchTableEntry( this, itab, key, status );

/* If the destination KeyMap does not contain an entry with the current
   key, store a copy of the entry in the destination, or report an error
   if the destination's MapLocked attribute is set. */
         if( !out_entry ) {
            if( astGetMapLocked( this ) ) {
               astError( AST__BADKEY, "astMapCopy(%s): Failed to copy "
                         "item \"%s\": \"%s\" is not a known item.", status,
                         astGetClass( this ), key, key );
            } else {
               out_entry = CopyMapEntry( in_entry, status );
               out_entry = AddTableEntry( this, itab, out_entry, -1, status );
            }

/* If the destination KeyMap contains an entry with the current key... */
         } else {

/* The usual thing is to just replace the existing entry in the
   destination with a copy of the source entry. The one case where this is
   not done is if both entries are scalar KeyMaps. In this case the source
   KeyMap is merged into the destination KeyMap using this function. First
   see if we have this situation, and if so, copy the entries from the
   source KeyMap to the destination KeyMap. */
            merged = 0;
            if( in_entry->nel == 0 || in_entry->nel == 1 ) {
               if( out_entry->nel == 0 || out_entry->nel == 1 ) {
                  if( in_entry->type == AST__OBJECTTYPE &&
                      out_entry->type == AST__OBJECTTYPE ) {

                     if( in_entry->nel == 0 ) {
                        in_obj = ((Entry0A *)in_entry)->value;
                     } else {
                        in_obj = (((Entry1A *)in_entry)->value)[ 0 ];
                     }

                     if( out_entry->nel == 0 ) {
                        out_obj = ((Entry0A *)out_entry)->value;
                     } else {
                        out_obj = (((Entry1A *)out_entry)->value)[ 0 ];
                     }

                     if( astIsAKeyMap( in_obj ) &&
                         astIsAKeyMap( out_obj ) ) {
                        astMapCopy( (AstKeyMap *) out_obj,
                                    (AstKeyMap *) in_obj );
                        merged = 1;
                     }
                  }
               }
            }

/* If the source and desination entries are not KeyMaps, then just remove
   the entry in the desination KeyMap and add a copy of the source entry.
   But retain the original keymember value since we are just changing the
   value of an existing key. */
            if( ! merged ) {
               out_entry = RemoveTableEntry( this, itab, key, status );
               keymember = out_entry->keymember;
               (void) FreeMapEntry( out_entry, status );
               out_entry = CopyMapEntry( in_entry, status );
               out_entry = AddTableEntry( this, itab, out_entry, keymember, status );
            }
         }

/* Update the address of the next MapEntry in the source. */
         in_entry = in_entry->next;
      }
   }
}

static void MapCopyEntry( AstKeyMap *this, const char *skey, AstKeyMap *that,
                          int merge, int *status ) {
/*
*++
*  Name:
c     astMapCopyEntry
f     AST_MAPCOPYENTRY

*  Purpose:
*     Copy a single entry from one KeyMap into another.

*  Type:
*     Public virtual function.

*  Synopsis:
c     #include "keymap.h"
c     void astMapCopyEntry( AstKeyMap *this, const char *key, AstKeyMap *that, int merge )
f     CALL AST_MAPCOPYENTRY( THIS, KEY, THAT, MERGE, STATUS )

*  Class Membership:
*     KeyMap method.

*  Description:
c     This function
f     This routine
*     copies a single entry from one KeyMap into another.

*  Parameters:
c     this
f     THIS = INTEGER (Given)
*        Pointer to the destination KeyMap.
c     key
f     KEY = CHARACTER * ( * ) (Given)
*        The character string identifying the value to be copied. Trailing
*        spaces are ignored. The supplied string is converted to upper
*        case before use if the KeyCase attribute is currently set to zero.
c     that
f     THAT = INTEGER (Given)
*        Pointer to the source KeyMap.
c     merge
f     MERGE = LOGICAL (Given)
*        Indicates what to do if the named entry holds a KeyMap and a KeyMap
*        entry with the same key already exists in the destination
*        KeyMap.
c        If zero,
f        If .FALSE.,
*        the existing destination KeyMap will be deleted and replaced by a copy
*        of the source KeyMap.
c        If non-zero,
f        If .TRUE.,
*        all entries in the source KeyMap will be copied into the existing
*        destination KeyMap using
c        function astMapCopy.
f        routine AST_MAPCOPY.
f     STATUS = INTEGER (Given and Returned)
f        The global status.

*  Notes:
*     - This fuction returns without action if the named entry does not
*     exist in the source KeyMap.
*     - Entries from the source KeyMap will replace any existing entries in
*     the destination KeyMap that have the same key.
*     - If the destination entry has a non-zero value for its MapLocked
*     attribute, then an error will be reported if the source KeyMap
*     contains any keys that do not already exist within the destination
*     KeyMap.

*--
*/

/* Local Variables: */
   AstMapEntry *in_entry; /* Pointer to next source entry to copy */
   AstMapEntry *out_entry;/* Pointer to existing destination entry */
   AstObject *in_obj;     /* Pointer for source Object entry */
   AstObject *out_obj;    /* Pointer for destination Object entry */
   char keybuf[ AST__MXKEYLEN + 1 ]; /* Buffer for upper cas key */
   const char *key;       /* Pointer to key string to use */
   int itab;              /* Index of destination hash table element */
   int keymember;         /* Identifier for key */
   int merged;            /* Were source and destination KeyMaps merged? */
   unsigned long hash;    /* Full width hash value */

/* Check the global error status. */
   if ( !astOK ) return;

/* Convert the supplied key to upper case if required. */
   key = ConvertKey( that, skey, keybuf, AST__MXKEYLEN + 1, "astMapCopyEntry",
                     status );

/* Use the hash function to determine the element of the hash table in
   which the key will be stored. */
   itab = HashFun( key, that->mapsize - 1, &hash, status );

/* Search the relevent table entry for the required MapEntry. */
   in_entry = SearchTableEntry( that, itab, key, status );

/* If found, search for a destination entry with the same key. */
   if( in_entry ) {
      itab = HashFun( key, this->mapsize - 1, &hash, status );
      out_entry = SearchTableEntry( this, itab, key, status );

/* If the destination KeyMap does not contain an entry with the current
   key, store a copy of the entry in the destination, or report an error
   if the destination's MapLocked attribute is set. */
      if( !out_entry ) {
         if( astGetMapLocked( this ) ) {
            astError( AST__BADKEY, "astMapCopyEntry(%s): Failed to copy "
                      "item \"%s\": \"%s\" is not a known item.", status,
                      astGetClass( this ), key, key );
         } else {
            out_entry = CopyMapEntry( in_entry, status );
            out_entry = AddTableEntry( this, itab, out_entry, -1, status );
         }

/* If the destination KeyMap contains an entry with the current key... */
      } else {

/* The usual thing is to just replace the existing entry in the
   destination with a copy of the source entry. The one case where this is
   not done is if "merge" is non-zero and both entries are scalar KeyMaps.
   In this case the source KeyMap is merged into the destination KeyMap using
   function astMapCopy. First see if we have this situation, and if so, copy
   the entries from the source KeyMap to the destination KeyMap. */
         merged = 0;
         if( merge ) {
            if( in_entry->nel == 0 || in_entry->nel == 1 ) {
               if( out_entry->nel == 0 || out_entry->nel == 1 ) {
                  if( in_entry->type == AST__OBJECTTYPE &&
                      out_entry->type == AST__OBJECTTYPE ) {

                     if( in_entry->nel == 0 ) {
                        in_obj = ((Entry0A *)in_entry)->value;
                     } else {
                        in_obj = (((Entry1A *)in_entry)->value)[ 0 ];
                     }

                     if( out_entry->nel == 0 ) {
                        out_obj = ((Entry0A *)out_entry)->value;
                     } else {
                        out_obj = (((Entry1A *)out_entry)->value)[ 0 ];
                     }

                     if( astIsAKeyMap( in_obj ) &&
                         astIsAKeyMap( out_obj ) ) {
                        astMapCopy( (AstKeyMap *) out_obj,
                                    (AstKeyMap *) in_obj );
                        merged = 1;
                     }
                  }
               }
            }
         }

/* If the source and desination entries were not merged, then just remove
   the entry in the desination KeyMap and add a copy of the source entry.
   But retain the original keymember value since we are just changing the
   value of an existing key. */
         if( ! merged ) {
            out_entry = RemoveTableEntry( this, itab, key, status );
            keymember = out_entry->keymember;
            (void) FreeMapEntry( out_entry, status );
            out_entry = CopyMapEntry( in_entry, status );
            out_entry = AddTableEntry( this, itab, out_entry, keymember, status );
         }
      }
   }
}

static const char *MapKey( AstKeyMap *this, int index, int *status ) {
/*
*++
*  Name:
c     astMapKey
f     AST_MAPKEY

*  Purpose:
*     Get the key at a given index within the KeyMap.

*  Type:
*     Public virtual function.

*  Synopsis:
c     #include "keymap.h"
c     const char *astMapKey( AstKeyMap *this, int index )
f     RESULT = AST_MAPKEY( THIS, INDEX, STATUS )

*  Class Membership:
*     KeyMap method.

*  Description:
*     This function returns a string holding the key for the entry with
*     the given index within the KeyMap.
*
*     This function is intended primarily as a means of iterating round all
*     the elements in a KeyMap. For this purpose, the number of entries in
*     the KeyMap should first be found using
c     astMapSize
f     AST_MAPSIZE
*     and this function should then be called in a loop, with the index
*     value going from
c     zero to one less than the size of the KeyMap.
f     one to the size of the KeyMap.
*     The index associated with a given entry is determined by the SortBy
*     attribute.

*  Parameters:
c     this
f     THIS = INTEGER (Given)
*        Pointer to the KeyMap.
c     index
f     INDEX = INTEGER (Given)
*        The index into the KeyMap. The first entry has index
c        zero, and the last has index "size-1", where "size" is the value
c        returned by the astMapSize function.
f        one, and the last has index SIZE, the value returned by the
f        AST_MAPSIZE function.
f     STATUS = INTEGER (Given and Returned)
f        The global status.

*  Returned Value:
c     astMapKey()
c        A pointer to a null-terminated string containing the key.
f     AST_MAPKEY = CHARACTER * ( AST__SZCHR )
f        The key value.

*  Notes:
c     - The returned pointer is guaranteed to remain valid and the
c     string to which it points will not be over-written for a total
c     of 50 successive invocations of this function. After this, the
c     memory containing the string may be re-used, so a copy of the
c     string should be made if it is needed for longer than this.
c     - A NULL pointer will be returned if this function is invoked
c     with the AST error status set, or if it should fail for any
c     reason.
f     - A blank string will be returned if this function is invoked
f     with STATUS set to an error value, or if it should fail for any
f     reason.
*--
*/

/* Local Variables: */
   astDECLARE_GLOBALS            /* Declare the thread specific global data */
   const char *result;           /* Pointer value to return */
   const char *value;            /* Pointer to key value */
   int i;                        /* Loop counter for initialisation */

/* Initialise. */
   result = NULL;

/* Check the global error status. */
   if ( !astOK ) return result;

/* Get a pointer to the structure holding thread-specific global data. */
   astGET_GLOBALS(this);

/* If the "mapkey_strings" array has not been initialised, fill it with
   NULL pointers. */
   if ( !mapkey_init ) {
      mapkey_init = 1;
      for ( i = 0; i < AST__KEYMAP_MAPKEY_MAX_STRINGS; i++ ) mapkey_strings[ i ] = NULL;
   }

/* Obtain a pointer to the required key value. */
   value = GetKey( this, index, status );

/* If OK, store a copy of the resulting string in dynamically
   allocated memory, putting a pointer to the copy into the next
   element of the "mapkey_strings" array.  (This process also de-allocates
   any previously allocated memory pointed at by this "mapkey_strings"
   element, so the earlier string is effectively replaced by the new
   one.) */
   if ( astOK ) {
      astBeginPM;
      mapkey_strings[ mapkey_istr ] = astStore( mapkey_strings[ mapkey_istr ], value,
                                  strlen( value ) + (size_t) 1 );
      astEndPM;

/* If OK, return a pointer to the copy and increment "mapkey_istr" to use the
   next element of "mapkey_strings" on the next invocation. Recycle "mapkey_istr" to
   zero when all elements have been used. */
      if ( astOK ) {
         result = mapkey_strings[ mapkey_istr++ ];
         if ( mapkey_istr == ( AST__KEYMAP_MAPKEY_MAX_STRINGS - 1 ) ) mapkey_istr = 0;
      }
   }

/* Return the result. */
   return result;

}

/*
*++
*  Name:
c     astMapPut0<X>
f     AST_MAPPUT0<X>

*  Purpose:
*     Add a scalar value to a KeyMap.

*  Type:
*     Public virtual function.

*  Synopsis:
c     #include "ast.h"
c     void astMapPut0<X>( AstKeyMap *this, const char *key, <X>type value,
c                         const char *comment );
f     CALL AST_MAPPUT0<X>( THIS, KEY, VALUE, COMMENT, STATUS )

*  Class Membership:
*     KeyMap method.

*  Description:
c     This is a set of functions
f     This is a set of routine
*     for adding scalar values to a KeyMap. You should use a
c     function
f     routine
*     which matches the data type of the data you wish to add to the KeyMap
*     by replacing <X> in the generic
c     function name astMapPut0<X>
f     routine name AST_MAPPUT0<X>
*     by an appropriate 1-character type code (see the "Data Type Codes"
*     section below for the code appropriate to each supported data type).

*  Parameters:
c     this
f     THIS = INTEGER (Given)
*        Pointer to the KeyMap in which to store the supplied value.
c     key
f     KEY = CHARACTER * ( * ) (Given)
*        A character string to be stored with the value, which can later
*        be used to identify the value. Trailing spaces are ignored.
*        The supplied string is converted to upper case before use if the
*        KeyCase attribute is currently set to zero.
c     value
f     VALUE = <X>type (Given)
*        The value to be stored. The data type of this value should match the
*        1-character type code appended to the
c        function name (e.g. if you are using astMapPut0A, the type of this
c        value should be "pointer to AstObject").
f        routine name (e.g. if you are using AST_MAPPUT0A, the type of this
f        value should be "integer pointer for an AstObject").
c     comment
f     COMMENT = CHARACTER * ( * ) (Given)
f        A comment string to be stored with the value.
c        A pointer to a null-terminated comment string to be stored with the
c        value. A NULL pointer may be supplied, in which case no comment is
c        stored.
f     STATUS = INTEGER (Given and Returned)
f        The global status.

*  Notes:
*     - If the supplied key is already in use in the KeyMap, the new value
*     will replace the old value.
*     - If the stored value is an AST Object pointer, the Object's reference
*     count is incremented by this call. Any subsequent changes made to
*     the Object using the returned pointer will be reflected in any
*     any other active pointers for the Object, including any obtained
*     later using
c     astMapget0A.
f     AST_MAPGET0A.
*     The reference count for the Object will be decremented when the
*     KeyMap is destroyed, or the entry is removed or over-written with a
*     different pointer.

*  Data Type Codes:
*     To select the appropriate
c     function, you should replace <X> in the generic function name astMapPut0<X>
f     routine, you should replace <X> in the generic routine name AST_MAPPUT0<X>
*     with a 1-character data type code, so as to match the data type <X>type
*     of the data you are processing, as follows:
c     - D: double
c     - F: float
c     - I: int
c     - K: int64_t
c     - C: "const" pointer to null terminated character string
c     - A: Pointer to AstObject
c     - P: Generic "void *" pointer
c     - S: short int
c     - B: unsigned byte (i.e. unsigned char)
f     - D: DOUBLE PRECISION
f     - R: REAL
f     - I: INTEGER
f     - K: INTEGER*8
f     - C: CHARACTER
f     - A: INTEGER used to identify an AstObject
f     - S: INTEGER*2 (short integer)
f     - B: Unsigned byte
*
c     For example, astMapPut0D would be used to store a "double" value,
c     while astMapPut0I would be used to store an "int", etc.
f     For example, AST_MAPPUT0D would be used to store a DOUBLE PRECISION value,
f     while AST_MAPPUT0I would be used to store an INTEGER, etc.
c
c     Note that KeyMaps containing generic "void *" pointers cannot be
c     written out using astShow or astWrite. An error will be reported if
c     this is attempted.
*--
*/
/* Define a macro to implement the function for a specific data type. */
#define MAKE_MAPPUT0(X,Xtype,Itype,ValExp) \
static void MapPut0##X( AstKeyMap *this, const char *skey, Xtype value, \
                        const char *comment, int *status ) { \
\
/* Local Variables: */ \
   AstMapEntry *mapentry;  /* Pointer to parent MapEntry structure */ \
   AstMapEntry *oldent;    /* Pointer to existing MapEntry */ \
   Entry0##X *entry;       /* Structure holding the data for the new Entry */ \
   const char *key;        /* Pointer to key string to use */ \
   char *p;                /* Pointer to next key character */ \
   char keybuf[ AST__MXKEYLEN + 1 ]; /* Buffer for upper cas key */ \
   int itab;               /* Index of hash table element to use */ \
   int keylen;             /* Length of supplied key string */ \
   int keymember;          /* Identifier for existing key */ \
   int there;              /* Did the entry already exist in the KeyMap? */ \
\
/* Check the global error status. */ \
   if ( !astOK ) return; \
\
/* Perform any necessary checks on the supplied value to be stored. */ \
   CHECK_##X \
\
/* Convert the supplied key to upper case if required. */ \
   key = ConvertKey( this, skey, keybuf, AST__MXKEYLEN + 1, "astMapPut0" #X, \
                     status ); \
\
/* Allocate memory for the new MapEntry. */ \
   entry = astMalloc( sizeof( Entry0##X ) ); \
   if( astOK ) { \
\
/* Initialise the new structure.*/ \
      mapentry = (AstMapEntry *) entry; \
      InitMapEntry( mapentry, Itype, 0, status ); \
\
/* Now store the new values. */ \
      keylen = strlen( key ); \
      mapentry->key = astStore( NULL, key, keylen + 1 ); \
      if( comment ) mapentry->comment = astStore( NULL, comment, strlen( comment ) + 1 ); \
      mapentry->defined = 1; \
      entry->value = ValExp; \
\
/* Terminate the key string to exclude any trailing spaces. */ \
      if( astOK ) { \
         p = (char *) mapentry->key + keylen; \
         while( --p >= mapentry->key ) { \
            if( *p == ' ' ) { \
               *p = 0; \
            } else { \
               break; \
            } \
         } \
      } \
\
/* Use the hash function to determine the element of the hash table in \
   which to store the new entry. */ \
      itab = HashFun( mapentry->key, this->mapsize - 1, &(mapentry->hash), status ); \
\
/* Remove any existing entry with the given key from the table element. \
   First save the key identifier. */ \
      oldent = RemoveTableEntry( this, itab, mapentry->key, status ); \
      if( oldent ) { \
         keymember = oldent->keymember; \
         oldent = FreeMapEntry( oldent, status ); \
         there = 1; \
      } else { \
         keymember = -1; \
         there = 0; \
      } \
\
/* If the KeyMap is locked we report an error if an attempt is made to add a value for \
   a new key. */ \
      if( !there && astGetMapLocked( this ) ) { \
         astError( AST__BADKEY, "astMapPut0" #X "(%s): Failed to add item \"%s\" to a KeyMap: " \
                   "\"%s\" is not a known item.", status, astGetClass( this ), key, key ); \
      } \
\
/* If all has gone OK, store the new entry at the head of the linked list \
   associated with the selected table entry. */ \
      if( astOK ) { \
         mapentry = AddTableEntry( this, itab, mapentry, keymember, status ); \
\
/* If anything went wrong, try to delete the new entry. */ \
      } else { \
         mapentry = FreeMapEntry( mapentry, status ); \
      } \
   } \
}

/* Define macros which perform any necessary checks on the supplied value
   to be stored. For Object entries, check that we are not adding a KeyMap
   which already contains "this". This avoids circular dependencies.
   Other types do not need any checks. */
#define CHECK_A CheckCircle( this, value, "astMapPut0A", status );
#define CHECK_I
#define CHECK_D
#define CHECK_F
#define CHECK_C
#define CHECK_P
#define CHECK_S
#define CHECK_K
#define CHECK_B

/* Expand the above macro to generate a function for each required
   data type. */
MAKE_MAPPUT0(I,int,AST__INTTYPE,value)
MAKE_MAPPUT0(D,double,AST__DOUBLETYPE,value)
MAKE_MAPPUT0(F,float,AST__FLOATTYPE,value)
MAKE_MAPPUT0(C,const char *,AST__STRINGTYPE,astStore(NULL,value,strlen(value)+1))
MAKE_MAPPUT0(A,AstObject *,AST__OBJECTTYPE,(value?astClone(value):NULL))
MAKE_MAPPUT0(P,void *,AST__POINTERTYPE,value)
MAKE_MAPPUT0(S,short int,AST__SINTTYPE,value)
MAKE_MAPPUT0(K,int64_t,AST__KINTTYPE,value)
MAKE_MAPPUT0(B,unsigned char,AST__BYTETYPE,value)

/* Undefine the macro. */
#undef MAKE_MAPPUT0
#undef CHECK_A
#undef CHECK_I
#undef CHECK_S
#undef CHECK_K
#undef CHECK_D
#undef CHECK_F
#undef CHECK_C
#undef CHECK_P
#undef CHECK_B

/*
*++
*  Name:
c     astMapPut1<X>
f     AST_MAPPUT1<X>

*  Purpose:
*     Add a vector value to a KeyMap.

*  Type:
*     Public virtual function.

*  Synopsis:
c     #include "ast.h"
c     void astMapPut1<X>( AstKeyMap *this, const char *key, int size,
c                         const <X>type value[], const char *comment );
f     CALL AST_MAPPUT1<X>( THIS, KEY, SIZE, VALUE, COMMENT, STATUS )

*  Class Membership:
*     KeyMap method.

*  Description:
c     This is a set of functions
f     This is a set of routine
*     for adding vector values to a KeyMap. You should use a
c     function
f     routine
*     which matches the data type of the data you wish to add to the KeyMap
*     by replacing <X> in the generic
c     function name astMapPut1<X>
f     routine name AST_MAPPUT1<X>
*     by an appropriate 1-character type code (see the "Data Type Codes"
*     section below for the code appropriate to each supported data type).

*  Parameters:
c     this
f     THIS = INTEGER (Given)
*        Pointer to the KeyMap in which to store the supplied values.
c     key
f     KEY = CHARACTER * ( * ) (Given)
*        A character string to be stored with the values, which can later
*        be used to identify the values. Trailing spaces are ignored.
*        The supplied string is converted to upper case before use if the
*        KeyCase attribute is currently set to zero.
c     size
f     SIZE = INTEGER (Given)
*        The number of elements in the supplied array of values.
c     value
f     VALUE( * ) = <X>type (Given)
*        The array of values to be stored. The data type of this value should
*        match the 1-character type code appended to the
c        function name (e.g. if you are using astMapPut1A, the type of this
c        value should be "array of pointers to AstObject").
f        routine name (e.g. if you are using AST_MAPPUT1A, the type of this
f        value should be "integer pointer for an AstObject)".
c     comment
f     COMMENT = CHARACTER * ( * ) (Given)
f        A comment string to be stored with the values.
c        A pointer to a null-terminated comment string to be stored with the
c        values. A NULL pointer may be supplied, in which case no comment is
c        stored.
f     STATUS = INTEGER (Given and Returned)
f        The global status.

*  Notes:
*     - If the supplied key is already in use in the KeyMap, the new values
*     will replace the old values.

*  Data Type Codes:
*     To select the appropriate
c     function, you should replace <X> in the generic function name astMapPut1<X>
f     routine, you should replace <X> in the generic routine name AST_MAPPUT1<X>
*     with a 1-character data type code, so as to match the data type <X>type
*     of the data you are processing, as follows:
c     - D: double
c     - F: float
c     - I: int
c     - K: int64_t
c     - C: "const" pointer to null terminated character string
c     - A: Pointer to AstObject
c     - P: Generic "void *" pointer
c     - S: short int
c     - B: Unsigned byte (i.e. char)
f     - D: DOUBLE PRECISION
f     - R: REAL
f     - I: INTEGER
f     - I: INTEGER*8
f     - C: CHARACTER
f     - A: INTEGER used to identify an AstObject
f     - S: INTEGER*2 (short integer)
f     - B: Unsigned byte
*
c     For example, astMapPut1D would be used to store "double" values,
c     while astMapPut1I would be used to store "int", etc.
f     For example, AST_MAPPUT1D would be used to store DOUBLE PRECISION values,
f     while AST_MAPPUT1I would be used to store INTEGER, etc.
c
c     Note that KeyMaps containing generic "void *" pointers cannot be
c     written out using astShow or astWrite. An error will be reported if
c     this is attempted.
*--
*/
/* Define a macro to implement the function for a specific data type. */
#define MAKE_MAPPUT1(X,Xtype,Itype,ValExp) \
static void MapPut1##X( AstKeyMap *this, const char *skey, int size, \
                        Xtype value[], const char *comment, \
                        int *status ) { \
\
/* Local Variables: */ \
   AstMapEntry *mapentry;  /* Pointer to parent MapEntry structure */ \
   AstMapEntry *oldent;    /* Pointer to existing MapEntry */ \
   Entry1##X *entry;       /* Structure holding the data for the new Entry */ \
   char keybuf[ AST__MXKEYLEN + 1 ]; /* Buffer for upper cas key */ \
   const char *key;        /* Pointer to key string to use */ \
   char *p;                /* Pointer to next key character */ \
   int itab;               /* Index of hash table element to use */ \
   int i;                  /* Loop count */ \
   int keylen;             /* Length of supplied key string */ \
   int keymember;          /* Identifier for existing key */ \
   int there;              /* Did the entry already exist in the KeyMap? */ \
\
/* Check the global error status. */ \
   if ( !astOK ) return; \
\
/* Perform any necessary checks on the supplied value to be stored. */ \
   CHECK_##X \
\
/* Convert the supplied key to upper case if required. */ \
   key = ConvertKey( this, skey, keybuf, AST__MXKEYLEN + 1, "astMapPut1" #X, \
                     status ); \
\
/* Allocate memory for the new MapEntry. */ \
   entry = astMalloc( sizeof( Entry1##X ) ); \
   if( astOK ) { \
\
/* Initialise the new structure.*/ \
      mapentry = (AstMapEntry *) entry; \
      InitMapEntry( mapentry, Itype, size, status ); \
\
/* Now store the new values. */ \
      keylen = strlen( key ); \
      mapentry->key = astStore( NULL, key, keylen + 1 ); \
      if( comment ) mapentry->comment = astStore( NULL, comment, strlen( comment ) + 1 ); \
      mapentry->defined = 1; \
      entry->value = astMalloc( sizeof( Xtype )*(size_t)size ); \
\
      if( astOK ) { \
         for( i = 0; i < size; i++ ) { \
            entry->value[ i ] = ValExp; \
         } \
\
/* Terminate the key string to exclude any trailing spaces. */ \
         p = (char *) mapentry->key + keylen; \
         while( --p >= mapentry->key ) { \
            if( *p == ' ' ) { \
               *p = 0; \
            } else { \
               break; \
            } \
         } \
      } \
\
/* Use the hash function to determine the element of the hash table in \
   which to store the new entry. */ \
      itab = HashFun( mapentry->key, this->mapsize - 1, &(mapentry->hash), status ); \
\
/* Remove any existing entry with the given key from the table element. \
   First save the key identifier. */ \
      oldent = RemoveTableEntry( this, itab, mapentry->key, status ); \
      if( oldent ) { \
         keymember = oldent->keymember; \
         oldent = FreeMapEntry( oldent, status ); \
         there = 1; \
      } else { \
         keymember = -1; \
         there = 0; \
      } \
\
/* If the KeyMap is locked we report an error if an attempt is made to add a value for \
   a new key. */ \
      if( !there && astGetMapLocked( this ) ) { \
         astError( AST__BADKEY, "astMapPut1" #X "(%s): Failed to add item \"%s\" to a KeyMap: " \
                   "\"%s\" is not a known item.", status, astGetClass( this ), key, key ); \
      } \
\
/* If all has gone OK, store the new entry at the head of the linked list \
   associated with the selected table entry. */ \
      if( astOK ) { \
         mapentry = AddTableEntry( this, itab, mapentry, keymember, status ); \
\
/* If anything went wrong, try to delete the new entry. */ \
      } else { \
         mapentry = FreeMapEntry( mapentry, status ); \
      } \
   } \
}

/* Define macros which perform any necessary checks on the supplied values
   to be stored. For Object entries, check that we are not adding a KeyMap
   which already contains "this". This avoids circular dependencies.
   Other types do not need any checks. */
#define CHECK_A \
for( i = 0; i < size; i++ ) { \
   CheckCircle( this, value[ i ], "astMapPut1A", status ); \
}
#define CHECK_I
#define CHECK_K
#define CHECK_S
#define CHECK_B
#define CHECK_D
#define CHECK_F
#define CHECK_C
#define CHECK_P

/* Expand the above macro to generate a function for each required
   data type. */
MAKE_MAPPUT1(D,const double,AST__DOUBLETYPE,value[i])
MAKE_MAPPUT1(F,const float,AST__FLOATTYPE,value[i])
MAKE_MAPPUT1(I,const int,AST__INTTYPE,value[i])
MAKE_MAPPUT1(K,const int64_t,AST__KINTTYPE,value[i])
MAKE_MAPPUT1(C,const char *const,AST__STRINGTYPE,astStore(NULL,value[i],strlen(value[i])+1))
MAKE_MAPPUT1(A,AstObject *const,AST__OBJECTTYPE,(value[i]?astClone(value[i]):NULL))
MAKE_MAPPUT1(P,void *const,AST__POINTERTYPE,value[i])
MAKE_MAPPUT1(S,const short int,AST__SINTTYPE,value[i])
MAKE_MAPPUT1(B,const unsigned char,AST__BYTETYPE,value[i])

/* Undefine the macro. */
#undef MAKE_MAPPUT1
#undef CHECK_A
#undef CHECK_I
#undef CHECK_K
#undef CHECK_B
#undef CHECK_S
#undef CHECK_D
#undef CHECK_F
#undef CHECK_C
#undef CHECK_P

void astMapPut1AId_( AstKeyMap *this, const char *skey, int size,
                     AstObject *const value[], const char *comment,
                     int *status ) {
/*
*  Name:
*     astMapPut1AId_

*  Purpose:
*     Add a vector of AstObject pointers to a KeyMap.

*  Type:
*     Private function.

*  Synopsis:
*     #include "ast.h"
*     void astMapPut1A( AstKeyMap *this, const char *key, int size,
*                       AstObject *const value[], const char *comment )

*  Class Membership:
*     KeyMap method.

*  Description:
*     This is the public implementation of the astMapPut1A function
*     It is identical to astMapPut1A_ except that ID values are supplied
*     via the "value" parameter instead of a true C pointers.

*  Parameters:
*     (see astMapPut1<X>)

*/

/* Local Variables: */
   AstMapEntry *mapentry;  /* Pointer to parent MapEntry structure */
   AstMapEntry *oldent;    /* Pointer to existing MapEntry */
   AstObject *op;          /* Object pointer */
   Entry1A *entry;         /* Structure holding the data for the new Entry */
   char *p;                /* Pointer to next key character */
   char keybuf[ AST__MXKEYLEN + 1 ]; /* Buffer for upper cas key */ \
   const char *key;        /* Pointer to key string to use */ \
   int i;                  /* Loop count */
   int itab;               /* Index of hash table element to use */
   int keylen;             /* Length of supplied key string */
   int keymember;          /* Identifier for existing key */
   int there;              /* Did the entry already exist in the KeyMap? */

/* Check the global error status. */
   if ( !astOK ) return;

/* Convert the supplied key to upper case if required. */
   key = ConvertKey( this, skey, keybuf, AST__MXKEYLEN + 1, "astMapPut1A",
                     status );

/* Allocate memory for the new MapEntry. */
   entry = astMalloc( sizeof( Entry1A ) );
   if( astOK ) {

/* Initialise the new structure.*/
      mapentry = (AstMapEntry *) entry;
      InitMapEntry( mapentry, AST__OBJECTTYPE, size, status );

/* Now store the new values. */
      keylen = strlen( key );
      mapentry->key = astStore( NULL, key, keylen + 1 );
      if( comment ) mapentry->comment = astStore( NULL, comment, strlen( comment ) + 1 );
      mapentry->defined = 1;
      entry->value = astMalloc( sizeof( AstObject * )*(size_t)size );

      if( astOK ) {
         for( i = 0; i < size; i++ ) {
            op = value[ i ] ? astMakePointer( value[ i ] ) : NULL;
            entry->value[ i ] = op ? astClone( op ) : NULL;
         }

/* Terminate the key string to exclude any trailing spaces. */ \
         p = (char *) mapentry->key + keylen;
         while( --p >= mapentry->key ) {
            if( *p == ' ' ) {
               *p = 0;
            } else {
               break;
            }
         }
      }

/* Use the hash function to determine the element of the hash table in
   which to store the new entry. */
      itab = HashFun( mapentry->key, this->mapsize - 1, &(mapentry->hash), status );

/* Remove any existing entry with the given key from the table element. */
      oldent = RemoveTableEntry( this, itab, mapentry->key, status );
      if( oldent ) {
         keymember = oldent->keymember;
         oldent = FreeMapEntry( oldent, status );
         there = 1;
      } else {
         there = 0;
         keymember = -1;
      }

/* If the KeyMap is locked we report an error if an attempt is made to add a value for
   a new key. */
      if( !there && astGetMapLocked( this ) ) {
         astError( AST__BADKEY, "astMapPut1A(%s): Failed to add item \"%s\" to a KeyMap: "
                   "\"%s\" is not a known item.", status, astGetClass( this ), key, key );
      }

/* If all has gone OK, store the new entry at the head of the linked list
   associated with the selected table entry. */
      if( astOK ) {
         mapentry = AddTableEntry( this, itab, mapentry, keymember, status );

/* If anything went wrong, try to delete the new entry. */
      } else {
         mapentry = FreeMapEntry( mapentry, status );
      }
   }
}

static void MapPutU( AstKeyMap *this, const char *skey, const char *comment,
                     int *status ) {
/*
*++
*  Name:
c     astMapPutU
f     AST_MAPPUTU

*  Purpose:
*     Add an entry to a KeyMap with an undefined value.

*  Type:
*     Public virtual function.

*  Synopsis:
c     #include "ast.h"
c     void astMapPutU( AstKeyMap *this, const char *key, const char *comment );
f     CALL AST_MAPPUTU( THIS, KEY, COMMENT, STATUS )

*  Class Membership:
*     KeyMap method.

*  Description:
c     This function
f     This routine
*     adds a new entry to a KeyMap, but no value is stored with the
*     entry. The entry therefore has a special data type represented by
*     symbolic constant AST__UNDEFTYPE.
*
*     An example use is to add entries with undefined values to a KeyMap
*     prior to locking them with the MapLocked attribute. Such entries
*     can act as placeholders for values that can be added to the KeyMap
*     later.

*  Parameters:
c     this
f     THIS = INTEGER (Given)
*        Pointer to the KeyMap in which to store the supplied value.
c     key
f     KEY = CHARACTER * ( * ) (Given)
*        A character string to be stored with the value, which can later
*        be used to identify the value. Trailing spaces are ignored.
*        The supplied string is converted to upper case before use if the
*        KeyCase attribute is currently set to zero.
c     comment
f     COMMENT = CHARACTER * ( * ) (Given)
f        A comment string to be stored with the value.
c        A pointer to a null-terminated comment string to be stored with the
c        value. A NULL pointer may be supplied, in which case no comment is
c        stored.
f     STATUS = INTEGER (Given and Returned)
f        The global status.

*  Notes:
*     - If the supplied key is already in use in the KeyMap, the value
*     associated with the key will be removed.

*--
*/

/* Local Variables: */
   AstMapEntry *mapentry;  /* Pointer to parent MapEntry structure */
   AstMapEntry *oldent;    /* Pointer to existing MapEntry */
   char keybuf[ AST__MXKEYLEN + 1 ]; /* Buffer for upper cas key */
   const char *key;        /* Pointer to key string to use */
   char *p;                /* Pointer to next key character */
   int itab;               /* Index of hash table element to use */
   int keylen;             /* Length of supplied key string */
   int keymember;          /* Identifier for existing key */
   int there;              /* Did the entry already exist in the KeyMap? */

/* Check the global error status. */
   if ( !astOK ) return;

/* Convert the supplied key to upper case if required. */
   key = ConvertKey( this, skey, keybuf, AST__MXKEYLEN + 1, "astMapPutU",
                     status );

/* Allocate memory for the new MapEntry. */
   mapentry = astMalloc( sizeof( AstMapEntry ) );
   if( astOK ) {

/* Initialise the new structure.*/
      InitMapEntry( mapentry, AST__UNDEFTYPE, 0, status );

/* Now store the new values. */
      keylen = strlen( key );
      mapentry->key = astStore( NULL, key, keylen + 1 );
      if( comment ) mapentry->comment = astStore( NULL, comment, strlen( comment ) + 1 );
      mapentry->defined = 0;

/* Terminate the key string to exclude any trailing spaces. */
      if( astOK ) {
         p = (char *) mapentry->key + keylen;
         while( --p >= mapentry->key ) {
            if( *p == ' ' ) {
               *p = 0;
            } else {
               break;
            }
         }
      }

/* Use the hash function to determine the element of the hash table in
   which to store the new entry. */
      itab = HashFun( mapentry->key, this->mapsize - 1, &(mapentry->hash), status );

/* Remove any existing entry with the given key from the table element. */
      oldent = RemoveTableEntry( this, itab, mapentry->key, status );
      if( oldent ) {
         keymember = oldent->keymember;
         oldent = FreeMapEntry( oldent, status );
         there = 1;
      } else {
         keymember = -1;
         there = 0;
      }

/* If the KeyMap is locked we report an error if an attempt is made to add a value for
   a new key. */
      if( !there && astGetMapLocked( this ) ) {
         astError( AST__BADKEY, "astMapPutU(%s): Failed to add item \"%s\" to a KeyMap: "
                   "\"%s\" is not a known item.", status, astGetClass( this ), key, key );
      }

/* If all has gone OK, store the new entry at the head of the linked list
   associated with the selected table entry. */
      if( astOK ) {
         mapentry = AddTableEntry( this, itab, mapentry, keymember, status );

/* If anything went wrong, try to delete the new entry. */
      } else {
         mapentry = FreeMapEntry( mapentry, status );
      }
   }
}

/*
*++
*  Name:
c     astMapGet0<X>
f     AST_MAPGET0<X>

*  Purpose:
*     Get a scalar value from a KeyMap.

*  Type:
*     Public virtual function.

*  Synopsis:
c     #include "ast.h"
c     int astMapGet0<X>( AstKeyMap *this, const char *key, <X>type *value );
f     RESULT = AST_MAPGET0<X>( THIS, KEY, VALUE, STATUS )
f     RESULT = AST_MAPGET0C( THIS, KEY, VALUE, L, STATUS )

*  Class Membership:
*     KeyMap method.

*  Description:
*     This is a set of functions for retrieving a scalar value from a KeyMap.
*     You should replace <X> in the generic function name
c     astMapGet0<X>
f     AST_MAPGET0<X>
*     by an appropriate 1-character type code (see the "Data Type Codes"
*     section below for the code appropriate to each supported data type).
*     The stored value is converted to the data type indiced by <X>
*     before being returned (an error is reported if it is not possible to
*     convert the stored value to the requested data type).
f     Note, the version of this function which returns character strings,
f     AST_MAPGET0C, has an extra parameter in which is returned the number
f     of characters written into the supplied CHARACTER variable.

*  Parameters:
c     this
f     THIS = INTEGER (Given)
*        Pointer to the KeyMap.
c     key
f     KEY = CHARACTER * ( * ) (Given)
*        The character string identifying the value to be retrieved. Trailing
*        spaces are ignored. The supplied string is converted to upper
*        case before use if the KeyCase attribute is currently set to zero.
c     value
f     VALUE = <X>type (Returned)
c        A pointer to a buffer in which to return the requested value.
f        The requested value.
*        If the requested key is not found, or if it is found but has an
*        undefined value (see
c        astMapPutU),
f        AST_MAPPUTU),
*        then the contents of the
*        buffer on entry to this function will be unchanged on exit.
c        For pointer types ("A" and "C"), the buffer should be a suitable
c        pointer, and the address of this pointer should be supplied as the
c        "value" parameter.
f     L = INTEGER (Returned)
f        This parameter is only present in the interface for the AST_MAPGET0C
f        function. It is returned holding the number of characters
f        written into the CHARACTER variable supplied for parameter VALUE.
f     STATUS = INTEGER (Given and Returned)
f        The global status.

*  Returned Value:
c     astMapGet0<X>()
f     AST_MAPGET0<X> = LOGICAL
c        A non-zero value
f        .TRUE.
*        is returned if the requested key name was found, and does not have
*        an undefined value (see
c        astMapPutU). Zero
f        AST_MAPPUTU). .FALSE.
*        is returned otherwise.

*  Notes:
*     - No error is reported if the requested key cannot be found in the
*     given KeyMap, but a
c     zero
f     .FALSE.
*     value will be returned as the function value. The supplied buffer
*     will be returned unchanged.
*     - If the stored value is a vector value, then the first value in
*     the vector will be returned.
c     - A string pointer returned by astMapGet0C is guaranteed to remain valid
c     and the string to which it points will not be over-written for a
c     total of 50 successive invocations of this function. After this,
c     the memory containing the string may be re-used, so a copy of
c     the string should be made if it is needed for longer than this. The
c     calling code should never attempt to free the returned pointer
c     (for instance, using astFree).
*     - If the returned value is an AST Object pointer, the Object's reference
*     count is incremented by this call. Any subsequent changes made to
*     the Object using the returned pointer will be reflected in any
*     any other active pointers for the Object. The returned pointer
*     should be annulled using
c     astAnnul
f     AST_ANNUL
*     when it is no longer needed.

*  Data Type Codes:
*     To select the appropriate
c     function, you should replace <X> in the generic function name astMapGet0<X>
f     routine, you should replace <X> in the generic routine name AST_MAPGET0<X>
*     with a 1-character data type code, so as to match the data type <X>type
*     of the data you are processing, as follows:
c     - F: float
c     - D: double
c     - I: int
c     - K: int64_t
c     - C: "const" pointer to null terminated character string
c     - A: Pointer to AstObject
c     - P: Generic "void *" pointer
c     - S: short int
c     - B: Unsigned byte (i.e. word)
f     - D: DOUBLE PRECISION
f     - R: REAL
f     - I: INTEGER
f     - K: INTEGER*8
f     - C: CHARACTER
f     - A: INTEGER used to identify an AstObject
f     - S: INTEGER*2 (short integer)
f     - B: Unsigned byte
*
c     For example, astMapGet0D would be used to get a "double" value,
c     while astMapGet0I would be used to get an "int", etc.
f     For example, AST_MAPGET0D would be used to get a DOUBLE PRECISION value,
f     while AST_MAPGET0I would be used to get an INTEGER, etc.
*--
*/
/* Define a macro to implement the function for a specific data type. */
#define MAKE_MAPGET0(X,Xtype,Itype) \
static int MapGet0##X( AstKeyMap *this, const char *skey, Xtype *value, int *status ) { \
\
/* Local Variables: */ \
   AstMapEntry *mapentry;  /* Pointer to parent MapEntry structure */ \
   const char *key;        /* Pointer to key string to use */ \
   char keybuf[ AST__MXKEYLEN + 1 ]; /* Buffer for upper cas key */ \
   int itab;               /* Index of hash table element to use */ \
   int raw_type;           /* Data type of stored value */ \
   int result;             /* Returned flag */ \
   unsigned long hash;     /* Full width hash value */ \
   void *raw;              /* Pointer to stored value */ \
\
/* Initialise */ \
   result = 0; \
\
/* Check the global error status. */ \
   if ( !astOK ) return result; \
\
/* Convert the supplied key to upper case if required. */ \
   key = ConvertKey( this, skey, keybuf, AST__MXKEYLEN + 1, "astMapGet0" #X, \
                     status ); \
\
/* Use the hash function to determine the element of the hash table in \
   which the key will be stored. */ \
   itab = HashFun( key, this->mapsize - 1, &hash, status ); \
\
/* Search the relevent table entry for the required MapEntry. */ \
   mapentry = SearchTableEntry( this, itab, key, status ); \
\
/* Skip rest if the key was not found. */ \
   if( mapentry ) { \
\
/* Get the address of the raw value, and its data type. */ \
      raw_type = mapentry->type; \
      if( raw_type == AST__INTTYPE ){ \
         if( mapentry->nel == 0 ) { \
            raw = &( ((Entry0I *)mapentry)->value ); \
         } else { \
            raw = ((Entry1I *)mapentry)->value; \
         } \
\
      } else if( raw_type == AST__SINTTYPE ){ \
         if( mapentry->nel == 0 ) { \
            raw = &( ((Entry0S *)mapentry)->value ); \
         } else { \
            raw = ((Entry1S *)mapentry)->value; \
         } \
\
      } else if( raw_type == AST__KINTTYPE ){ \
         if( mapentry->nel == 0 ) { \
            raw = &( ((Entry0K *)mapentry)->value ); \
         } else { \
            raw = ((Entry1K *)mapentry)->value; \
         } \
\
      } else if( raw_type == AST__BYTETYPE ){ \
         if( mapentry->nel == 0 ) { \
            raw = &( ((Entry0B *)mapentry)->value ); \
         } else { \
            raw = ((Entry1B *)mapentry)->value; \
         } \
\
      } else if( raw_type == AST__DOUBLETYPE ){ \
         if( mapentry->nel == 0 ) { \
            raw = &( ((Entry0D *)mapentry)->value ); \
         } else { \
            raw = ((Entry1D *)mapentry)->value; \
         } \
\
      } else if( raw_type == AST__FLOATTYPE ){ \
         if( mapentry->nel == 0 ) { \
            raw = &( ((Entry0F *)mapentry)->value ); \
         } else { \
            raw = ((Entry1F *)mapentry)->value; \
         } \
\
      } else if( raw_type == AST__POINTERTYPE ){ \
         if( mapentry->nel == 0 ) { \
            raw = &( ((Entry0P *)mapentry)->value ); \
         } else { \
            raw = ((Entry1P *)mapentry)->value; \
         } \
\
      } else if( raw_type == AST__STRINGTYPE ){ \
         if( mapentry->nel == 0 ) { \
            raw = &( ((Entry0C *)mapentry)->value ); \
         } else { \
            raw = ((Entry1C *)mapentry)->value; \
         } \
\
      } else if( raw_type == AST__OBJECTTYPE ){ \
         if( mapentry->nel == 0 ) { \
            raw = &( ((Entry0A *)mapentry)->value ); \
         } else { \
            raw = ((Entry1A *)mapentry)->value; \
         } \
\
      } else if( raw_type == AST__UNDEFTYPE ){ \
         raw = NULL; \
\
      } else { \
         raw = NULL; \
         astError( AST__INTER, "astMapGet0<X>(KeyMap): Illegal map entry data " \
                   "type %d encountered (internal AST programming error).", status, \
                   raw_type ); \
      } \
\
/* Convert the value, storing the result the supplied buffer. Report an \
   error if conversion is not possible. */ \
      if( !raw ) { \
         result = 0; \
\
      } else if( !ConvertValue( raw, raw_type, value, Itype, status ) && astOK ){ \
         astError( AST__MPGER, "astMapGet0" #X "(%s): The value of KeyMap key " \
                   "\"%s\" cannot be read using the requested data " \
                   "type.", status,astGetClass( this ), key ); \
\
      } else { \
         result = 1; \
      } \
\
/* If the KeyError attribute is non-zero, report an error if the key is not \
   found */ \
   } else if( astGetKeyError( this ) && astOK ) { \
      astError( AST__MPKER, "astMapGet0" #X "(%s): No value was found for " \
                "%s in the supplied KeyMap.", status, astGetClass( this ), \
                key ); \
   } \
\
/* If an error occurred, return zero. */ \
   if( !astOK ) result = 0; \
\
/* Return the result.*/ \
   return result; \
}

/* Expand the above macro to generate a function for each required
   data type. */
MAKE_MAPGET0(I,int,AST__INTTYPE)
MAKE_MAPGET0(D,double,AST__DOUBLETYPE)
MAKE_MAPGET0(F,float,AST__FLOATTYPE)
MAKE_MAPGET0(C,const char *,AST__STRINGTYPE)
MAKE_MAPGET0(A,AstObject *,AST__OBJECTTYPE)
MAKE_MAPGET0(P,void *,AST__POINTERTYPE)
MAKE_MAPGET0(S,short int,AST__SINTTYPE)
MAKE_MAPGET0(K,int64_t,AST__KINTTYPE)
MAKE_MAPGET0(B,unsigned char,AST__BYTETYPE)

/* Undefine the macro. */
#undef MAKE_MAPGET0

int astMapGet0AId_( AstKeyMap *this, const char *skey, AstObject **value, int *status ) {
/*
*  Name:
*     astMapGet0AId_

*  Purpose:
*     Get a scalar AstObject pointer from a KeyMap.

*  Type:
*     Private function.

*  Synopsis:
*     #include "ast.h"
*     int astMapGet0A( AstKeyMap *this, const char *key, AstObject **value )

*  Class Membership:
*     KeyMap method.

*  Description:
*     This is the public implementation of the astMapGet0A function
*     It is identical to astMapGet0A_ except that an ID value is returned
*     via the "value" parameter instead of a true C pointer. This is required
*     because this conversion cannot be performed by the macro that invokes
*     the function.

*  Parameters:
*     (see astMapGet0<X>)

*/

/* Local Variables: */
   AstMapEntry *mapentry;  /* Pointer to parent MapEntry structure */
   char keybuf[ AST__MXKEYLEN + 1 ]; /* Buffer for upper cas key */ \
   const char *key;        /* Pointer to key string to use */ \
   int itab;               /* Index of hash table element to use */
   int raw_type;           /* Data type of stored value */
   int result;             /* Returned flag */
   unsigned long hash;     /* Full width hash value */
   void *raw;              /* Pointer to stored value */

/* Initialise */
   result = 0;

/* Check the global error status. */
   if ( !astOK ) return result;

/* Convert the supplied key to upper case if required. */
   key = ConvertKey( this, skey, keybuf, AST__MXKEYLEN + 1, "astMapGet0A",
                     status );

/* Use the hash function to determine the element of the hash table in
   which the key will be stored. */
   itab = HashFun( key, this->mapsize - 1, &hash, status );

/* Search the relevent table entry for the required MapEntry. */
   mapentry = SearchTableEntry( this, itab, key, status );

/* Skip rest if the key was not found. */
   if( mapentry ) {

/* Get the address of the raw value, and its data type. */
      raw_type = mapentry->type;
      if( raw_type == AST__INTTYPE ){
         if( mapentry->nel == 0 ) {
            raw = &( ((Entry0I *)mapentry)->value );
         } else {
            raw = ((Entry1I *)mapentry)->value;
         }

      } else if( raw_type == AST__POINTERTYPE ){
         if( mapentry->nel == 0 ) {
            raw = &( ((Entry0P *)mapentry)->value );
         } else {
            raw = ((Entry1P *)mapentry)->value;
         }

      } else if( raw_type == AST__SINTTYPE ){
         if( mapentry->nel == 0 ) {
            raw = &( ((Entry0S *)mapentry)->value );
         } else {
            raw = ((Entry1S *)mapentry)->value;
         }

      } else if( raw_type == AST__KINTTYPE ){
         if( mapentry->nel == 0 ) {
            raw = &( ((Entry0K *)mapentry)->value );
         } else {
            raw = ((Entry1K *)mapentry)->value;
         }

      } else if( raw_type == AST__BYTETYPE ){
         if( mapentry->nel == 0 ) {
            raw = &( ((Entry0B *)mapentry)->value );
         } else {
            raw = ((Entry1B *)mapentry)->value;
         }

      } else if( raw_type == AST__DOUBLETYPE ){
         if( mapentry->nel == 0 ) {
            raw = &( ((Entry0D *)mapentry)->value );
         } else {
            raw = ((Entry1D *)mapentry)->value;
         }

      } else if( raw_type == AST__FLOATTYPE ){
         if( mapentry->nel == 0 ) {
            raw = &( ((Entry0F *)mapentry)->value );
         } else {
            raw = ((Entry1F *)mapentry)->value;
         }

      } else if( raw_type == AST__STRINGTYPE ){
         if( mapentry->nel == 0 ) {
            raw = &( ((Entry0C *)mapentry)->value );
         } else {
            raw = ((Entry1C *)mapentry)->value;
         }

      } else if( raw_type == AST__OBJECTTYPE ){
         if( mapentry->nel == 0 ) {
            raw = &( ((Entry0A *)mapentry)->value );
         } else {
            raw = ((Entry1A *)mapentry)->value;
         }

      } else if( raw_type == AST__UNDEFTYPE ){
         raw = NULL;

      } else {
         raw = NULL;
         astError( AST__INTER, "astMapGet0<X>(KeyMap): Illegal map entry data "
                   "type %d encountered (internal AST programming error).", status,
                   raw_type );
      }

/* Convert the value, storing the result the supplied buffer. Report an
   error if conversion is not possible. */
      if( !raw ) {
         result = 0;

      } else if( !ConvertValue( raw, raw_type, value, AST__OBJECTTYPE, status ) && astOK ){
         astError( AST__MPGER, "astMapGet0A(%s): The value of KeyMap key "
                   "\"%s\" cannot be read using the requested data "
                   "type.", status, astGetClass( this ), key );

      } else {
         result = 1;
      }

/* If the KeyError attribute is non-zero, report an error if the key is not
   found */
   } else if( astGetKeyError( this ) && astOK ) {
      astError( AST__MPKER, "astMapGet0A(%s): No value was found for "
                "%s in the supplied KeyMap.", status, astGetClass( this ),
                key );
   }

/* If required, return an ID value for the Object. */
   if( result && *value ) *value = astMakeId( *value );

/* Return the result.*/
   return result;
}

/*
*++
*  Name:
c     astMapGet1<X>
f     AST_MAPGET1<X>

*  Purpose:
*     Get a vector value from a KeyMap.

*  Type:
*     Public virtual function.

*  Synopsis:
c     #include "ast.h"
c     int astMapGet1<X>( AstKeyMap *this, const char *key, int mxval,
c                        int *nval, <X>type *value )
c     int astMapGet1C( AstKeyMap *this, const char *key, int l, int mxval,
c                      int *nval, const char *value )
f     RESULT = AST_MAPGET1<X>( THIS, KEY, MXVAL, NVAL, VALUE, STATUS )

*  Class Membership:
*     KeyMap method.

*  Description:
*     This is a set of functions for retrieving a vector value from a KeyMap.
*     You should replace <X> in the generic function name
c     astMapGet1<X>
f     AST_MAPGET1<X>
*     by an appropriate 1-character type code (see the "Data Type Codes"
*     section below for the code appropriate to each supported data type).
*     The stored value is converted to the data type indiced by <X>
*     before being returned (an error is reported if it is not possible to
*     convert the stored value to the requested data type).
c     Note, the astMapGet1C function has an extra parameter "l" which
c     specifies the maximum length of each string to be stored in the
c     "value" buffer (see the "astMapGet1C" section below).

*  Parameters:
c     this
f     THIS = INTEGER (Given)
*        Pointer to the KeyMap.
c     key
f     KEY = CHARACTER * ( * ) (Given)
*        The character string identifying the value to be retrieved. Trailing
*        spaces are ignored.
*        The supplied string is converted to upper case before use if the
*        KeyCase attribute is currently set to zero.
c     mxval
f     MXVAL = INTEGER (Given)
*        The number of elements in the
c        "value" array.
f        VALUE array.
c     nval
f     NVAL = INTEGER (Returned)
c        The address of an integer in which to put the
f        The
*        number of elements stored in the
c        "value" array.
*        Any unused elements of the array are left unchanged. Zero is
*        returned if the required KeyMap entry has an undefined value.
c     value
f     VALUE( MXVAL ) = <X>type (Returned)
c        A pointer to an array in which to return the requested values.
f        The requested values.
*        If the requested key is not found, or if it is found but has an
*        undefined value (see
c        astMapPutU),
f        AST_MAPPUTU),
*        then the contents of the
*        buffer on entry to this function will be unchanged on exit.
f     STATUS = INTEGER (Given and Returned)
f        The global status.

*  Returned Value:
c     astMapGet1<X>()
f     AST_MAPGET1<X> = LOGICAL
c        A non-zero value
f        .TRUE.
*        is returned if the requested key name was found, and does not have
*        an undefined value (see
c        astMapPutU). Zero
f        AST_MAPPUTU). .FALSE.
*        is returned otherwise.

*  Notes:
*     - No error is reported if the requested key cannot be found in the
*     given KeyMap, but a
c     zero
f     .FALSE.
*     value will be returned as the function value. The supplied array
*     will be returned unchanged.
*     - If the stored value is a scalar value, then the value will be
*     returned in the first element of the supplied array, and
c     "nval"
f     NVAL
*     will be returned set to 1.

c  astMapGet1C:
c     The "value" buffer supplied to the astMapGet1C function should be a
c     pointer to a character array with "mxval*l" elements, where "l" is
c     the maximum length of a string to be returned. The value of "l"
c     should be supplied as an extra parameter following "key" when
c     invoking astMapGet1C, and should include space for a terminating
c     null character.

*  Data Type Codes:
*     To select the appropriate
c     function, you should replace <X> in the generic function name astMapGet1<X>
f     routine, you should replace <X> in the generic routine name AST_MAPGET1<X>
*     with a 1-character data type code, so as to match the data type <X>type
*     of the data you are processing, as follows:
c     - D: double
c     - F: float
c     - I: int
c     - K: int64_t
c     - C: "const" pointer to null terminated character string
c     - A: Pointer to AstObject
c     - P: Generic "void *" pointer
c     - S: short int
c     - B: Unsigned byte (i.e. char)
f     - D: DOUBLE PRECISION
f     - R: REAL
f     - I: INTEGER
f     - K: INTEGER*8
f     - C: CHARACTER
f     - A: INTEGER used to identify an AstObject
f     - S: INTEGER*2 (short integer)
f     - B: Unsigned byte
*
c     For example, astMapGet1D would be used to get "double" values, while
c     astMapGet1I would be used to get "int" values, etc. For D or I, the
c     supplied "value" parameter should be a pointer to an array of doubles
c     or ints, with "mxval" elements. For C, the supplied "value" parameter
c     should be a pointer to a character string with "mxval*l" elements.
c     For A, the supplied "value" parameter should be a pointer to an
c     array of AstObject pointers.
f     For example, AST_MAPGET1D would be used to get DOUBLE PRECISION values,
f     while AST_MAPGET1I would be used to get INTEGER values, etc.

*--
*/
/* Define a macro to implement the function for a specific data type
(excluding "C" since that needs an extra parameter). */
#define MAKE_MAPGET1(X,Xtype,Itype) \
static int MapGet1##X( AstKeyMap *this, const char *skey, int mxval, int *nval, Xtype *value, int *status ) { \
\
/* Local Variables: */ \
   AstMapEntry *mapentry;  /* Pointer to parent MapEntry structure */ \
   const char *key;        /* Pointer to key string to use */ \
   char keybuf[ AST__MXKEYLEN + 1 ]; /* Buffer for upper cas key */ \
   int i;                  /* Element index */ \
   int itab;               /* Index of hash table element to use */ \
   int nel;                /* Number of elements in raw vector */ \
   int raw_type;           /* Data type of stored value */ \
   int result;             /* Returned flag */ \
   size_t raw_size;        /* Size of a single raw value */ \
   unsigned long hash;     /* Full width hash value */ \
   void *raw;              /* Pointer to stored value */ \
\
/* Initialise */ \
   result = 0; \
   *nval = 0; \
\
/* Check the global error status. */ \
   if ( !astOK ) return result; \
\
/* Convert the supplied key to upper case if required. */ \
   key = ConvertKey( this, skey, keybuf, AST__MXKEYLEN + 1, "astMapGet1" #X, \
                     status ); \
\
/* Use the hash function to determine the element of the hash table in \
   which the key will be stored. */ \
   itab = HashFun( key, this->mapsize - 1, &hash, status ); \
\
/* Search the relevent table entry for the required MapEntry. */ \
   mapentry = SearchTableEntry( this, itab, key, status ); \
\
/* Skip rest if the key was not found. */ \
   if( mapentry ) { \
      result = 1; \
\
/* Get the address of the first raw value, and its data type. Also get \
   the size of each element of the vector. */ \
      nel = mapentry->nel; \
      raw_type = mapentry->type; \
      if( raw_type == AST__INTTYPE ){ \
         raw_size = sizeof( int ); \
         if( nel == 0 ) { \
            raw = &( ((Entry0I *)mapentry)->value ); \
         } else { \
            raw = ((Entry1I *)mapentry)->value; \
         } \
\
      } else if( raw_type == AST__DOUBLETYPE ){ \
         raw_size = sizeof( double ); \
         if( nel == 0 ) { \
            raw = &( ((Entry0D *)mapentry)->value ); \
         } else { \
            raw = ((Entry1D *)mapentry)->value; \
         } \
\
      } else if( raw_type == AST__KINTTYPE ){ \
         raw_size = sizeof( int64_t ); \
         if( nel == 0 ) { \
            raw = &( ((Entry0K *)mapentry)->value ); \
         } else { \
            raw = ((Entry1K *)mapentry)->value; \
         } \
\
      } else if( raw_type == AST__SINTTYPE ){ \
         raw_size = sizeof( short int ); \
         if( nel == 0 ) { \
            raw = &( ((Entry0S *)mapentry)->value ); \
         } else { \
            raw = ((Entry1S *)mapentry)->value; \
         } \
\
      } else if( raw_type == AST__BYTETYPE ){ \
         raw_size = sizeof( unsigned char ); \
         if( nel == 0 ) { \
            raw = &( ((Entry0B *)mapentry)->value ); \
         } else { \
            raw = ((Entry1B *)mapentry)->value; \
         } \
\
      } else if( raw_type == AST__POINTERTYPE ){ \
         raw_size = sizeof( void * ); \
         if( nel == 0 ) { \
            raw = &( ((Entry0P *)mapentry)->value ); \
         } else { \
            raw = ((Entry1P *)mapentry)->value; \
         } \
\
      } else if( raw_type == AST__FLOATTYPE ){ \
         raw_size = sizeof( float ); \
         if( nel == 0 ) { \
            raw = &( ((Entry0F *)mapentry)->value ); \
         } else { \
            raw = ((Entry1F *)mapentry)->value; \
         } \
\
      } else if( raw_type == AST__STRINGTYPE ){ \
         raw_size = sizeof( const char * ); \
         if( nel == 0 ) { \
            raw = &( ((Entry0C *)mapentry)->value ); \
         } else { \
            raw = ((Entry1C *)mapentry)->value; \
         } \
\
      } else if( raw_type == AST__OBJECTTYPE ){ \
         raw_size = sizeof( AstObject * ); \
         if( nel == 0 ) { \
            raw = &( ((Entry0A *)mapentry)->value ); \
         } else { \
            raw = ((Entry1A *)mapentry)->value; \
         } \
\
      } else if( raw_type == AST__UNDEFTYPE ){ \
         raw_size = 0; \
         raw = NULL; \
\
      } else { \
         raw_size = 0; \
         raw = NULL; \
         astError( AST__INTER, "astMapGet1<X>(KeyMap): Illegal map entry data " \
                   "type %d encountered (internal AST programming error).", status, \
                   raw_type ); \
      } \
\
/* Treat scalars as single-value vectors. */ \
      if( nel == 0 ) nel = 1; \
\
/* Ensure no more than "mxval" values are returned. */ \
      if( nel > mxval ) nel = mxval; \
\
/* Return the number of values stored in the buffer. */ \
      if( raw ) *nval = nel; \
\
/* Loop round all values in the vector. */ \
      for( i = 0; i < nel && astOK; i++ ) { \
\
/* Convert the value, storing the result in the supplied buffer. Report an \
   error if conversion is not possible. */ \
         if( !raw ) { \
            result = 0; \
\
         } else if( !ConvertValue( raw, raw_type, value + i, Itype, status ) && astOK ){ \
            astError( AST__MPGER, "astMapGet1" #X "(%s): The value of " \
                      "element %d of KeyMap key \"%s\" cannot be read using " \
                      "the requested data type.", status,astGetClass( this ), i + 1, key ); \
         } \
\
/* Increment the pointers to the next raw value. */ \
         raw = (char *) raw + raw_size; \
      } \
\
/* If the KeyError attribute is non-zero, report an error if the key is not \
   found */ \
   } else if( astGetKeyError( this ) && astOK ) { \
      astError( AST__MPKER, "astMapGet1" #X "(%s): No value was found for " \
                "%s in the supplied KeyMap.", status, astGetClass( this ), \
                key ); \
   } \
\
/* If an error occurred,return zero. */ \
   if( !astOK ) result = 0; \
\
/* Return the result.*/ \
   return result; \
}

/* Expand the above macro to generate a function for each required
   data type (except C which is done differently). */
MAKE_MAPGET1(I,int,AST__INTTYPE)
MAKE_MAPGET1(K,int64_t,AST__KINTTYPE)
MAKE_MAPGET1(D,double,AST__DOUBLETYPE)
MAKE_MAPGET1(F,float,AST__FLOATTYPE)
MAKE_MAPGET1(A,AstObject *,AST__OBJECTTYPE)
MAKE_MAPGET1(P,void *,AST__POINTERTYPE)
MAKE_MAPGET1(S,short int,AST__SINTTYPE)
MAKE_MAPGET1(B,unsigned char,AST__BYTETYPE)

/* Undefine the macro. */
#undef MAKE_MAPGET1


static int MapGet1C( AstKeyMap *this, const char *skey, int l, int mxval,
                     int *nval, char *value, int *status ) {
/*
*  Name:
*     MapGet1C

*  Purpose:
*     Get a vector value from a KeyMap.

*  Type:
*     Private member function.

*  Synopsis:
*     #include "ast.h"
*     int MapGet1C( AstKeyMap *this, const char *key, int l, int mxval,
*                   int *nval, char *value, int *status )

*  Class Membership:
*     KeyMap method.

*  Description:
*     This is the implementation of astMapGet1<X> for <X> = "C". We
*     cannot use the MAKE_MAPGET1 macro for this because the string
*     version of this function has an extra parameter giving the maximum
*     length of each string which can be stored in the supplied buffer.

*  Parameters:
*     (see astMapGet1<X>)
*/

/* Local Variables: */
   AstMapEntry *mapentry;  /* Pointer to parent MapEntry structure */
   char *val;              /* Pointer to next buffer element */
   char keybuf[ AST__MXKEYLEN + 1 ]; /* Buffer for upper cas key */ \
   const char *cvalue;     /* Pointer to converted string */
   const char *key;        /* Pointer to key string to use */ \
   int i;                  /* Element index */
   int itab;               /* Index of hash table element to use */
   int nel;                /* Number of elements in raw vector */
   int raw_type;           /* Data type of stored value */
   int result;             /* Returned flag */
   size_t raw_size;        /* Size of a single raw value */
   unsigned long hash;     /* Full width hash value */
   void *raw;              /* Pointer to stored value */

/* Initialise */
   result = 0;
   *nval = 0;

/* Check the global error status. */
   if ( !astOK ) return result;

/* Convert the supplied key to upper case if required. */
   key = ConvertKey( this, skey, keybuf, AST__MXKEYLEN + 1, "astMapGet1C",
                     status );

/* Use the hash function to determine the element of the hash table in
   which the key will be stored. */
   itab = HashFun( key, this->mapsize - 1, &hash, status );

/* Search the relevent table entry for the required MapEntry. */
   mapentry = SearchTableEntry( this, itab, key, status );

/* Skip rest if the key was not found. */
   if( mapentry ) {
      result = 1;

/* Get the address of the first raw value, and its data type. Also get
   the size of each element of the vector. */
      nel = mapentry->nel;
      raw_type = mapentry->type;
      if( raw_type == AST__INTTYPE ){
         raw_size = sizeof( int );
         if( nel == 0 ) {
            raw = &( ((Entry0I *)mapentry)->value );
         } else {
            raw = ((Entry1I *)mapentry)->value;
         }

      } else if( raw_type == AST__POINTERTYPE ){
         raw_size = sizeof( void * );
         if( nel == 0 ) {
            raw = &( ((Entry0P *)mapentry)->value );
         } else {
            raw = ((Entry1P *)mapentry)->value;
         }

      } else if( raw_type == AST__DOUBLETYPE ){
         raw_size = sizeof( double );
         if( nel == 0 ) {
            raw = &( ((Entry0D *)mapentry)->value );
         } else {
            raw = ((Entry1D *)mapentry)->value;
         }

      } else if( raw_type == AST__SINTTYPE ){
         raw_size = sizeof( short int );
         if( nel == 0 ) {
            raw = &( ((Entry0S *)mapentry)->value );
         } else {
            raw = ((Entry1S *)mapentry)->value;
         }

      } else if( raw_type == AST__KINTTYPE ){
         raw_size = sizeof( int64_t );
         if( nel == 0 ) {
            raw = &( ((Entry0K *)mapentry)->value );
         } else {
            raw = ((Entry1K *)mapentry)->value;
         }

      } else if( raw_type == AST__BYTETYPE ){
         raw_size = sizeof( unsigned char );
         if( nel == 0 ) {
            raw = &( ((Entry0B *)mapentry)->value );
         } else {
            raw = ((Entry1B *)mapentry)->value;
         }

      } else if( raw_type == AST__FLOATTYPE ){
         raw_size = sizeof( float );
         if( nel == 0 ) {
            raw = &( ((Entry0F *)mapentry)->value );
         } else {
            raw = ((Entry1F *)mapentry)->value;
         }

      } else if( raw_type == AST__STRINGTYPE ){
         raw_size = sizeof( const char * );
         if( nel == 0 ) {
            raw = &( ((Entry0C *)mapentry)->value );
         } else {
            raw = ((Entry1C *)mapentry)->value;
         }

      } else if( raw_type == AST__OBJECTTYPE ){
         raw_size = sizeof( AstObject * );
         if( nel == 0 ) {
            raw = &( ((Entry0A *)mapentry)->value );
         } else {
            raw = ((Entry1A *)mapentry)->value;
         }

      } else if( raw_type == AST__UNDEFTYPE ){
         raw_size = 0;
         raw = NULL;

      } else {
         raw_size = 0;
         raw = NULL;
         astError( AST__INTER, "astMapGet1C(KeyMap): Illegal map entry data "
                   "type %d encountered (internal AST programming error).", status,
                   raw_type );
      }

/* Treat scalars as single-value vectors. */
      if( nel == 0 ) nel = 1;

/* Ensure no more than "mxval" values are returned. */
      if( nel > mxval ) nel = mxval;

/* Return the number of values stored in the buffer. */
      if( raw ) *nval = nel;

/* Loop round all values in the vector. */
      val = value;
      for( i = 0; i < nel && astOK; i++ ) {

/* Convert the value, storing the result in the supplied buffer. Report an
   error if conversion is not possible. */
         if( !raw ) {
            result = 0;

         } else if( !ConvertValue( raw, raw_type, &cvalue, AST__STRINGTYPE, status ) && astOK ){
            astError( AST__MPGER, "astMapGet1C(%s): The value of "
                      "element %d of KeyMap key \"%s\" cannot be read using "
                      "the requested data type.", status,astGetClass( this ), i + 1, key );

/* If succesful, copy the string into the supplied buffer, or as much of
   it as will fit. Leave room for a trailing null character. */
         } else {
            strncpy( val, cvalue, l - 1 );
            val[ l - 1 ] = 0;
         }

/* Increment the pointers to the next raw value and the next buffer
   location. */
         raw = (char *) raw + raw_size;
         val += l;
      }

/* If the KeyError attribute is non-zero, report an error if the key is not
   found */
   } else if( astGetKeyError( this ) && astOK ) {
      astError( AST__MPKER, "astMapGet1C(%s): No value was found for "
                "%s in the supplied KeyMap.", status, astGetClass( this ),
                key );
   }

/* If an error occurred,return zero. */
   if( !astOK ) result = 0;

/* Return the result.*/
   return result;
}

int astMapGet1AId_( AstKeyMap *this, const char *skey, int mxval, int *nval,
                    AstObject **value, int *status ) {
/*
*  Name:
*     astMapGet1AId_

*  Purpose:
*     Get a vector of AstObject pointers from a KeyMap.

*  Type:
*     Private function.

*  Synopsis:
*     #include "ast.h"
*     int astMapGet1A( AstKeyMap *this, const char *key, int mxval, int *nval,
*                      AstObject **value )

*  Class Membership:
*     KeyMap method.

*  Description:
*     This is the public implementation of the astMapGet1A function
*     It is identical to astMapGet1A_ except that ID values are returned
*     via the "value" parameter instead of a true C pointers. This is required
*     because this conversion cannot be performed by the macro that invokes
*     the function.

*  Parameters:
*     (see astMapGet1<X>)

*/

/* Local Variables: */
   AstMapEntry *mapentry;  /* Pointer to parent MapEntry structure */
   AstObject *avalue;      /* Pointer to AstObject */
   char keybuf[ AST__MXKEYLEN + 1 ]; /* Buffer for upper cas key */ \
   const char *key;        /* Pointer to key string to use */ \
   int i;                  /* Element index */
   int itab;               /* Index of hash table element to use */
   int nel;                /* Number of elements in raw vector */
   int raw_type;           /* Data type of stored value */
   int result;             /* Returned flag */
   size_t raw_size;        /* Size of a single raw value */
   unsigned long hash;     /* Full width hash value */
   void *raw;              /* Pointer to stored value */

/* Initialise */
   result = 0;
   *nval = 0;

/* Check the global error status. */
   if ( !astOK ) return result;

/* Convert the supplied key to upper case if required. */
   key = ConvertKey( this, skey, keybuf, AST__MXKEYLEN + 1, "astMapGet1A",
                     status );

/* Use the hash function to determine the element of the hash table in
   which the key will be stored. */
   itab = HashFun( key, this->mapsize - 1, &hash, status );

/* Search the relevent table entry for the required MapEntry. */
   mapentry = SearchTableEntry( this, itab, key, status );

/* Skip rest if the key was not found. */
   if( mapentry ) {
      result = 1;

/* Get the address of the first raw value, and its data type. Also get
   the size of each element of the vector. */
      nel = mapentry->nel;
      raw_type = mapentry->type;
      if( raw_type == AST__INTTYPE ){
         raw_size = sizeof( int );
         if( nel == 0 ) {
            raw = &( ((Entry0I *)mapentry)->value );
         } else {
            raw = ((Entry1I *)mapentry)->value;
         }

      } else if( raw_type == AST__DOUBLETYPE ){
         raw_size = sizeof( double );
         if( nel == 0 ) {
            raw = &( ((Entry0D *)mapentry)->value );
         } else {
            raw = ((Entry1D *)mapentry)->value;
         }

      } else if( raw_type == AST__SINTTYPE ){
         raw_size = sizeof( short int );
         if( nel == 0 ) {
            raw = &( ((Entry0S *)mapentry)->value );
         } else {
            raw = ((Entry1S *)mapentry)->value;
         }

      } else if( raw_type == AST__KINTTYPE ){
         raw_size = sizeof( int64_t );
         if( nel == 0 ) {
            raw = &( ((Entry0K *)mapentry)->value );
         } else {
            raw = ((Entry1K *)mapentry)->value;
         }

      } else if( raw_type == AST__BYTETYPE ){
         raw_size = sizeof( unsigned char );
         if( nel == 0 ) {
            raw = &( ((Entry0B *)mapentry)->value );
         } else {
            raw = ((Entry1B *)mapentry)->value;
         }

      } else if( raw_type == AST__POINTERTYPE ){
         raw_size = sizeof( void * );
         if( nel == 0 ) {
            raw = &( ((Entry0P *)mapentry)->value );
         } else {
            raw = ((Entry1P *)mapentry)->value;
         }

      } else if( raw_type == AST__FLOATTYPE ){
         raw_size = sizeof( float );
         if( nel == 0 ) {
            raw = &( ((Entry0F *)mapentry)->value );
         } else {
            raw = ((Entry1F *)mapentry)->value;
         }

      } else if( raw_type == AST__STRINGTYPE ){
         raw_size = sizeof( const char * );
         if( nel == 0 ) {
            raw = &( ((Entry0C *)mapentry)->value );
         } else {
            raw = ((Entry1C *)mapentry)->value;
         }

      } else if( raw_type == AST__OBJECTTYPE ){
         raw_size = sizeof( AstObject * );
         if( nel == 0 ) {
            raw = &( ((Entry0A *)mapentry)->value );
         } else {
            raw = ((Entry1A *)mapentry)->value;
         }

      } else if( raw_type == AST__UNDEFTYPE ){
         raw_size = 0;
         raw = NULL;

      } else {
         raw_size = 0;
         raw = NULL;
         astError( AST__INTER, "astMapGet1A(KeyMap): Illegal map entry data "
                   "type %d encountered (internal AST programming error).",
                   status, raw_type );
      }

/* Treat scalars as single-value vectors. */
      if( nel == 0 ) nel = 1;

/* Ensure no more than "mxval" values are returned. */
      if( nel > mxval ) nel = mxval;

/* Return the number of values stored in the buffer. */
      if( raw ) *nval = nel;

/* Loop round all values in the vector. */
      for( i = 0; i < nel && astOK; i++ ) {

/* Convert the value, storing the result in the supplied buffer. Report an
   error if conversion is not possible. */
         if( !raw ) {
            result = 0;

         } else if( !ConvertValue( raw, raw_type, &avalue, AST__OBJECTTYPE, status ) && astOK ){
            astError( AST__MPGER, "astMapGet1A(%s): The value of "
                      "element %d of KeyMap key \"%s\" cannot be read using "
                      "the requested data type.", status, astGetClass( this ),
                      i + 1, key );

/* If succesful, return an ID value for the Object. */
         } else {
           value[ i ] = avalue ? astMakeId( avalue ) : NULL;
         }

/* Increment the pointers to the next raw value. */
         raw = (char *) raw + raw_size;
      }

/* If the KeyError attribute is non-zero, report an error if the key is not
   found */
   } else if( astGetKeyError( this ) && astOK ) {
      astError( AST__MPKER, "astMapGet1A(%s): No value was found for "
                "%s in the supplied KeyMap.", status, astGetClass( this ),
                key );
   }

/* If an error occurred,return zero. */
   if( !astOK ) result = 0;

/* Return the result.*/
   return result;
}

static int MapGetC( AstKeyMap *this, const char *key, const char **value, int *status ) {
/*
*++
*  Name:
c     astMapGetC
f     AST_MAPGETC

*  Purpose:
*     Get a scalar or vector value from a KeyMap as a single string.

*  Type:
*     Public virtual function.

*  Synopsis:
c     #include "ast.h"
c     int astMapGetC( AstKeyMap *this, const char *key, const char **value );
f     RESULT = AST_MAPGETC( THIS, KEY, VALUE, L, STATUS )

*  Class Membership:
*     KeyMap method.

*  Description:
*     This function gets a named value from a KeyMap as a single string.
*     For scalar values it is equivalent to
c     astMapGet0C.
f     AST_MAPGET0C.
*     If the value is a vector, the returned string is a comma-separated
*     list of the vector elements, enclosed in parentheses.

*  Parameters:
c     this
f     THIS = INTEGER (Given)
*        Pointer to the KeyMap.
c     key
f     KEY = CHARACTER * ( * ) (Given)
*        The character string identifying the value to be retrieved. Trailing
*        spaces are ignored. The supplied string is converted to upper
*        case before use if the KeyCase attribute is currently set to zero.
c     value
f     VALUE = CHARACTER * ( * ) (Returned)
c        Address at which to return a pointer to the required string value.
f        The requested value.
*        If the requested key is not found, or if it is found but has an
*        undefined value (see
c        astMapPutU), then the contents of the supplied pointer
f        AST_MAPPUTU), then the contents of the supplied string
*        are unchanged on exit.
f     L = INTEGER (Returned)
f        This parameter is only present in the interface for the AST_MAPGET0C
f        function. It is returned holding the number of characters
f        written into the CHARACTER variable supplied for parameter VALUE.
f     STATUS = INTEGER (Given and Returned)
f        The global status.

*  Returned Value:
c     astMapGetC()
f     AST_MAPGETC = LOGICAL
c        A non-zero value
f        .TRUE.
*        is returned if the requested key name was found, and does not have
*        an undefined value (see
c        astMapPutU). Zero
f        AST_MAPPUTU). .FALSE.
*        is returned otherwise.

*  Notes:
*     - No error is reported if the requested key cannot be found in the
*     given KeyMap, but a
c     zero
f     .FALSE.
*     value will be returned as the function value. The supplied buffer
*     will be returned unchanged.
c     - The string pointer returned by astMapGetC is guaranteed to remain valid
c     and the string to which it points will not be over-written for a
c     total of 50 successive invocations of this function. After this,
c     the memory containing the string may be re-used, so a copy of
c     the string should be made if it is needed for longer than this. The
c     calling code should never attempt to free the returned pointer
c     (for instance, using astFree).
*--
*/

/* Local Variables: */
   astDECLARE_GLOBALS      /* Declare the thread specific global data */
   char *buf;              /* Buffer for all string values */
   char *cvalue;           /* Pointer to returned string */
   char *pb;               /* Pointer to start of next section of buffer */
   int i;                  /* Loop count */
   int mxlen;              /* Max length of any string in the vector */
   int nval;               /* No. of elements in vector */
   int result = 0;         /* Returned flag */
   int nc;                 /* Current length of total string */

/* Check the global error status. */
   if ( !astOK ) return 0;

/* Get a pointer to the structure holding thread-specific global data. */
   astGET_GLOBALS(this);

/* If the "convertvalue_strings" array has not been initialised, fill it with
   NULL pointers. */
   if( !convertvalue_init ) {
      convertvalue_init = 1;
      for( i = 0; i < AST__KEYMAP_CONVERTVALUE_MAX_STRINGS; i++ ) convertvalue_strings[ i ] = NULL;
   }

/* See how many elements are stored in the requested entry. */
   nval = astMapLength( this, key );

/* If the requested entry does not exist, return without further action. */
   if( nval == 0 ) {
      result = 0;

/* If the requested entry is a scalar, just call astMapGet0C to get the
   required string. */
   } else if( nval == 1 ) {
      result = astMapGet0C( this, key, value );

/* If the requested entry is a vector, use astMapGet1C to get all the
   strings stored in dynamic memory. */
   } else {

/* First get the maximum length of any one string stored in the vector. */
      mxlen = astMapLenC( this, key );

/* Allocate a buffer big enough to hold all elements assuming they are
   all the maximum length. Include room for a terminating null on each
   string. */
      buf = astMalloc( (mxlen + 1)*nval*sizeof( *buf ) );
      if( astOK ) {

/* Store the strings in the buffer. */
         result = astMapGet1C( this, key, mxlen+1, nval, &nval, buf );
         if( result ) {

/* Combine the individual strings into a single comma-delimited list,
   enclosed in parentheses, and stored in dynamic memory. */
            nc = 0;
            cvalue = astAppendString( NULL, &nc, "(" );
            pb = buf;
            for( i = 0; i < nval; i++ ) {
               if( i ) cvalue = astAppendString( cvalue, &nc, "," );
               cvalue = astAppendString( cvalue, &nc, pb );
               pb += mxlen + 1;
            }
            cvalue = astAppendString( cvalue, &nc, ")" );

/* Put a pointer to the total string into the next element of the "convertvalue_strings"
   array, freeing any value already stored in the next element first. */
            if( cvalue && astOK ) {
               (void) astFree( convertvalue_strings[ convertvalue_istr ] );
               convertvalue_strings[ convertvalue_istr ] = cvalue;

/* Increment "convertvalue_istr" to use the next element of "convertvalue_strings" on
   the next invocation. Recycle "convertvalue_istr" to zero when all elements have been
   used. */
              if( ++convertvalue_istr == ( AST__KEYMAP_CONVERTVALUE_MAX_STRINGS - 1 ) )
                  convertvalue_istr = 0;

/* Return a pointer to the striong now stored in the "convertvalue_strings"
   array. */
              *value = cvalue;
            }
         }
      }

/* Free the space used to hold the values buffer. */
      buf = astFree( buf );
   }

/* Return the result. */
   return result;
}


/*
*++
*  Name:
c     astMapGetElem<X>
f     AST_MAPGETELEM<X>

*  Purpose:
*     Get a single element of a vector value from a KeyMap.

*  Type:
*     Public virtual function.

*  Synopsis:
c     #include "ast.h"
c     int astMapGetElem<X>( AstKeyMap *this, const char *key, int elem,
c                           <X>type *value )
c     int astMapGetElemC( AstKeyMap *this, const char *key, int l, int elem,
c                         char *value )
f     RESULT = AST_MAPGETELEM<X>( THIS, KEY, ELEM, VALUE, STATUS )

*  Class Membership:
*     KeyMap method.

*  Description:
*     This is a set of functions for retrieving a single element of a vector
*     value from a KeyMap. You should replace <X> in the generic function name
c     astMapGetElem<X>
f     AST_MAPGETELEM<X>
*     by an appropriate 1-character type code (see the "Data Type Codes"
*     section below for the code appropriate to each supported data type).
*     The stored value is converted to the data type indiced by <X>
*     before being returned (an error is reported if it is not possible to
*     convert the stored value to the requested data type).
c     Note, the astMapGetElemC function has an extra parameter "l" which
c     specifies the maximum length of the string to be stored in the
c     "value" buffer (see the "astMapGetElemC" section below).

*  Parameters:
c     this
f     THIS = INTEGER (Given)
*        Pointer to the KeyMap.
c     key
f     KEY = CHARACTER * ( * ) (Given)
*        The character string identifying the value to be retrieved. Trailing
*        spaces are ignored.
*        The supplied string is converted to upper case before use if the
*        KeyCase attribute is currently set to zero.
c     elem
f     ELEM = INTEGER (Given)
*        The index of the required vector element, starting at
c        zero.
f        one.
*        An error will be reported if the value is outside the range of
*        the vector.
c     value
f     VALUE = <X>type (Returned)
c        A pointer to a buffer in which to return the requested value.
f        The requested value.
*        If the requested key is not found, or if it is found but has an
*        undefined value (see
c        astMapPutU),
f        AST_MAPPUTU),
*        then the contents of the
*        buffer on entry to this function will be unchanged on exit.
f     STATUS = INTEGER (Given and Returned)
f        The global status.

*  Returned Value:
c     astMapGetElem<X>()
f     AST_MAPGETELEM<X> = LOGICAL
c        A non-zero value
f        .TRUE.
*        is returned if the requested key name was found, and does not have
*        an undefined value (see
c        astMapPutU). Zero
f        AST_MAPPUTU). .FALSE.
*        is returned otherwise.

*  Notes:
*     - No error is reported if the requested key cannot be found in the
*     given KeyMap, or if it has an undefined value, but a
c     zero
f     .FALSE.
*     value will be returned as the function value.

c  astMapGetElemC:
c     The "value" buffer supplied to the astMapGetElemC function should be a
c     pointer to a character array with "l" elements, where "l" is the
c     maximum length of the string to be returned. The value of "l"
c     should be supplied as an extra parameter following "key" when
c     invoking astMapGetElemC, and should include space for a terminating
c     null character.

*  Data Type Codes:
*     To select the appropriate
c     function, you should replace <X> in the generic function name
c     astMapGetElem<X>
f     routine, you should replace <X> in the generic routine name
f     AST_MAPGETELEM<X>
*     with a 1-character data type code, so as to match the data type <X>type
*     of the data you are processing, as follows:
c     - D: double
c     - F: float
c     - I: int
c     - K: int64_t
c     - C: "const" pointer to null terminated character string
c     - A: Pointer to AstObject
c     - P: Generic "void *" pointer
c     - S: short int
c     - B: Unsigned byte (i.e. char)
f     - D: DOUBLE PRECISION
f     - R: REAL
f     - I: INTEGER
f     - K: INTEGER*8
f     - C: CHARACTER
f     - A: INTEGER used to identify an AstObject
f     - S: INTEGER*2 (short integer)
f     - B: Unsigned byte
*
c     For example, astMapGetElemD would be used to get a "double" value, while
c     astMapGetElemI would be used to get an "int" value, etc. For D or I, the
c     supplied "value" parameter should be a pointer to a double or int. For
c     C, the supplied "value" parameter should be a pointer to a character
c     string with "l" elements. For A, the supplied "value" parameter should
c     be a pointer to an AstObject pointer.
f     For example, AST_MAPGETELEMD would be used to get a DOUBLE PRECISION
f     value, while AST_MAPGETELEMI would be used to get an INTEGER value, etc.

*--
*/
/* Define a macro to implement the function for a specific data type
(excluding "C" since that needs an extra parameter). */
#define MAKE_MAPGETELEM(X,Xtype,Itype) \
static int MapGetElem##X( AstKeyMap *this, const char *skey, int elem, \
                          Xtype *value, int *status ) { \
\
/* Local Variables: */ \
   AstMapEntry *mapentry;  /* Pointer to parent MapEntry structure */ \
   const char *key;        /* Pointer to key string to use */ \
   char keybuf[ AST__MXKEYLEN + 1 ]; /* Buffer for upper cas key */ \
   int itab;               /* Index of hash table element to use */ \
   int nel;                /* Number of elements in raw vector */ \
   int raw_type;           /* Data type of stored value */ \
   int result;             /* Returned flag */ \
   size_t raw_size;        /* Size of a single raw value */ \
   unsigned long hash;     /* Full width hash value */ \
   void *raw;              /* Pointer to stored value */ \
\
/* Initialise */ \
   result = 0; \
\
/* Check the global error status. */ \
   if ( !astOK ) return result; \
\
/* Convert the supplied key to upper case if required. */ \
   key = ConvertKey( this, skey, keybuf, AST__MXKEYLEN + 1, "astMapGetElem" #X, \
                     status ); \
\
/* Use the hash function to determine the element of the hash table in \
   which the key will be stored. */ \
   itab = HashFun( key, this->mapsize - 1, &hash, status ); \
\
/* Search the relevent table entry for the required MapEntry. */ \
   mapentry = SearchTableEntry( this, itab, key, status ); \
\
/* Skip rest if the key was not found. */ \
   if( mapentry ) { \
      result = 1; \
\
/* Get the address of the first raw value, and its data type. Also get \
   the size of each element of the vector. */ \
      nel = mapentry->nel; \
      raw_type = mapentry->type; \
      if( raw_type == AST__INTTYPE ){ \
         raw_size = sizeof( int ); \
         if( nel == 0 ) { \
            raw = &( ((Entry0I *)mapentry)->value ); \
         } else { \
            raw = ((Entry1I *)mapentry)->value; \
         } \
\
      } else if( raw_type == AST__DOUBLETYPE ){ \
         raw_size = sizeof( double ); \
         if( nel == 0 ) { \
            raw = &( ((Entry0D *)mapentry)->value ); \
         } else { \
            raw = ((Entry1D *)mapentry)->value; \
         } \
\
      } else if( raw_type == AST__KINTTYPE ){ \
         raw_size = sizeof( int64_t ); \
         if( nel == 0 ) { \
            raw = &( ((Entry0K *)mapentry)->value ); \
         } else { \
            raw = ((Entry1K *)mapentry)->value; \
         } \
\
      } else if( raw_type == AST__SINTTYPE ){ \
         raw_size = sizeof( short int ); \
         if( nel == 0 ) { \
            raw = &( ((Entry0S *)mapentry)->value ); \
         } else { \
            raw = ((Entry1S *)mapentry)->value; \
         } \
\
      } else if( raw_type == AST__BYTETYPE ){ \
         raw_size = sizeof( unsigned char ); \
         if( nel == 0 ) { \
            raw = &( ((Entry0B *)mapentry)->value ); \
         } else { \
            raw = ((Entry1B *)mapentry)->value; \
         } \
\
      } else if( raw_type == AST__POINTERTYPE ){ \
         raw_size = sizeof( void * ); \
         if( nel == 0 ) { \
            raw = &( ((Entry0P *)mapentry)->value ); \
         } else { \
            raw = ((Entry1P *)mapentry)->value; \
         } \
\
      } else if( raw_type == AST__FLOATTYPE ){ \
         raw_size = sizeof( float ); \
         if( nel == 0 ) { \
            raw = &( ((Entry0F *)mapentry)->value ); \
         } else { \
            raw = ((Entry1F *)mapentry)->value; \
         } \
\
      } else if( raw_type == AST__STRINGTYPE ){ \
         raw_size = sizeof( const char * ); \
         if( nel == 0 ) { \
            raw = &( ((Entry0C *)mapentry)->value ); \
         } else { \
            raw = ((Entry1C *)mapentry)->value; \
         } \
\
      } else if( raw_type == AST__OBJECTTYPE ){ \
         raw_size = sizeof( AstObject * ); \
         if( nel == 0 ) { \
            raw = &( ((Entry0A *)mapentry)->value ); \
         } else { \
            raw = ((Entry1A *)mapentry)->value; \
         } \
\
      } else if( raw_type == AST__UNDEFTYPE ){ \
         raw = NULL; \
\
      } else { \
         raw_size = 0; \
         raw = NULL; \
         astError( AST__INTER, "astMapGetElem<X>(KeyMap): Illegal map entry " \
                   "data type %d encountered (internal AST programming " \
                   "error).", status, raw_type ); \
      } \
\
/* Treat scalars as single-value vectors. */ \
      if( nel == 0 ) nel = 1; \
\
/* Ensure the requested element is within the bounds of the vector */ \
      if( elem >= nel || elem < 0 ) { \
         if( astOK ) { \
            astError( AST__MPVIN, "astMapGetElem<X>(KeyMap): Illegal " \
                      "zero-based vector index %d supplied for KeyMap " \
                      "entry '%s' - the vector has %d elements.", status, \
                      elem, key, nel ); \
         } \
\
/* Get a pointer to the requested raw value. */ \
      } else if( raw ) { \
         raw = (char *) raw + elem*raw_size; \
\
/* Convert the requested value, storing the result in the supplied buffer. \
   Report an error if conversion is not possible. */ \
         if( !ConvertValue( raw, raw_type, value, Itype, status ) && astOK ){ \
            astError( AST__MPGER, "astMapGetElem" #X "(%s): The value of " \
                      "element %d of KeyMap key \"%s\" cannot be read using " \
                      "the requested data type.", status, astGetClass( this ), \
                      elem + 1, key ); \
         } \
      } \
\
/* If the KeyError attribute is non-zero, report an error if the key is not \
   found */ \
   } else if( astGetKeyError( this ) && astOK ) { \
      astError( AST__MPKER, "astMapGetElem" #X "(%s): No value was found for " \
                "%s in the supplied KeyMap.", status, astGetClass( this ), \
                key ); \
   } \
\
/* If an error occurred,return zero. */ \
   if( !astOK ) result = 0; \
\
/* Return the result.*/ \
   return result; \
}

/* Expand the above macro to generate a function for each required
   data type (except C which is done differently). */
MAKE_MAPGETELEM(I,int,AST__INTTYPE)
MAKE_MAPGETELEM(K,int64_t,AST__KINTTYPE)
MAKE_MAPGETELEM(D,double,AST__DOUBLETYPE)
MAKE_MAPGETELEM(F,float,AST__FLOATTYPE)
MAKE_MAPGETELEM(A,AstObject *,AST__OBJECTTYPE)
MAKE_MAPGETELEM(P,void *,AST__POINTERTYPE)
MAKE_MAPGETELEM(S,short int,AST__SINTTYPE)
MAKE_MAPGETELEM(B,unsigned char,AST__BYTETYPE)

/* Undefine the macro. */
#undef MAKE_MAPGETELEM


static int MapGetElemC( AstKeyMap *this, const char *skey, int l, int elem,
                        char *value, int *status ) {
/*
*  Name:
*     MapGetElemC

*  Purpose:
*     Get a single element of a vector value from a KeyMap.

*  Type:
*     Private member function.

*  Synopsis:
*     #include "ast.h"
*     int MapGetElemC( AstKeyMap *this, const char *key, int l, int elem,
*                      char *value, int *status )

*  Class Membership:
*     KeyMap method.

*  Description:
*     This is the implementation of astMapGetElem<X> for <X> = "C". We
*     cannot use the MAKE_MAPGETELEM macro for this because the string
*     version of this function has an extra parameter giving the maximum
*     length of each string which can be stored in the supplied buffer.

*  Parameters:
*     (see astMapGetElem<X>)
*/

/* Local Variables: */
   AstMapEntry *mapentry;  /* Pointer to parent MapEntry structure */
   const char *key;        /* Pointer to key string to use */
   char keybuf[ AST__MXKEYLEN + 1 ]; /* Buffer for upper cas key */
   const char *cvalue;     /* Pointer to converted string */
   int itab;               /* Index of hash table element to use */
   int nel;                /* Number of elements in raw vector */
   int raw_type;           /* Data type of stored value */
   int result;             /* Returned flag */
   size_t raw_size;        /* Size of a single raw value */
   unsigned long hash;     /* Full width hash value */
   void *raw;              /* Pointer to stored value */

/* Initialise */
   result = 0;

/* Check the global error status. */
   if ( !astOK ) return result;

/* Convert the supplied key to upper case if required. */
   key = ConvertKey( this, skey, keybuf, AST__MXKEYLEN + 1, "astMapGetElemC",
                     status );

/* Use the hash function to determine the element of the hash table in
   which the key will be stored. */
   itab = HashFun( key, this->mapsize - 1, &hash, status );

/* Search the relevent table entry for the required MapEntry. */
   mapentry = SearchTableEntry( this, itab, key, status );

/* Skip rest if the key was not found. */
   if( mapentry ) {
      result = 1;

/* Get the address of the first raw value, and its data type. Also get
   the size of each element of the vector. */
      nel = mapentry->nel;
      raw_type = mapentry->type;
      if( raw_type == AST__INTTYPE ){
         raw_size = sizeof( int );
         if( nel == 0 ) {
            raw = &( ((Entry0I *)mapentry)->value );
         } else {
            raw = ((Entry1I *)mapentry)->value;
         }

      } else if( raw_type == AST__POINTERTYPE ){
         raw_size = sizeof( void * );
         if( nel == 0 ) {
            raw = &( ((Entry0P *)mapentry)->value );
         } else {
            raw = ((Entry1P *)mapentry)->value;
         }

      } else if( raw_type == AST__DOUBLETYPE ){
         raw_size = sizeof( double );
         if( nel == 0 ) {
            raw = &( ((Entry0D *)mapentry)->value );
         } else {
            raw = ((Entry1D *)mapentry)->value;
         }

      } else if( raw_type == AST__SINTTYPE ){
         raw_size = sizeof( short int );
         if( nel == 0 ) {
            raw = &( ((Entry0S *)mapentry)->value );
         } else {
            raw = ((Entry1S *)mapentry)->value;
         }

      } else if( raw_type == AST__KINTTYPE ){
         raw_size = sizeof( int64_t );
         if( nel == 0 ) {
            raw = &( ((Entry0K *)mapentry)->value );
         } else {
            raw = ((Entry1K *)mapentry)->value;
         }

      } else if( raw_type == AST__BYTETYPE ){
         raw_size = sizeof( unsigned char );
         if( nel == 0 ) {
            raw = &( ((Entry0B *)mapentry)->value );
         } else {
            raw = ((Entry1B *)mapentry)->value;
         }

      } else if( raw_type == AST__FLOATTYPE ){
         raw_size = sizeof( float );
         if( nel == 0 ) {
            raw = &( ((Entry0F *)mapentry)->value );
         } else {
            raw = ((Entry1F *)mapentry)->value;
         }

      } else if( raw_type == AST__STRINGTYPE ){
         raw_size = sizeof( const char * );
         if( nel == 0 ) {
            raw = &( ((Entry0C *)mapentry)->value );
         } else {
            raw = ((Entry1C *)mapentry)->value;
         }

      } else if( raw_type == AST__OBJECTTYPE ){
         raw_size = sizeof( AstObject * );
         if( nel == 0 ) {
            raw = &( ((Entry0A *)mapentry)->value );
         } else {
            raw = ((Entry1A *)mapentry)->value;
         }

      } else if( raw_type == AST__UNDEFTYPE ){
         raw = NULL;

      } else {
         raw_size = 0;
         raw = NULL;
         astError( AST__INTER, "astMapGetElemC(KeyMap): Illegal map entry data "
                   "type %d encountered (internal AST programming error).", status,
                   raw_type );
      }

/* Treat scalars as single-value vectors. */
      if( nel == 0 ) nel = 1;

/* Ensure the requested element is within the bounds of the vector */
      if( elem >= nel || elem < 0 ) {
         if( astOK ) {
            astError( AST__MPVIN, "astMapGetElemC(KeyMap): Illegal vector "
                      "index %d supplied for KeyMap entry '%s' - should be "
                      "in the range 1 to %d.", status, elem + 1, key, nel + 1 );
         }

/* Get a pointer to the requested raw value. */
      } else if( raw ){
         raw = (char *) raw + elem*raw_size;

/* Convert the value, storing the result in the supplied buffer. Report an
   error if conversion is not possible. */
         if( !ConvertValue( raw, raw_type, &cvalue, AST__STRINGTYPE, status ) && astOK ){
            astError( AST__MPGER, "astMapGetElemC(%s): The value of "
                      "element %d of KeyMap key \"%s\" cannot be read using "
                      "the requested data type.", status,astGetClass( this ),
                      elem + 1, key );

/* If succesful, copy the string into the supplied buffer, or as much of
   it as will fit. Leave room for a trailing null character. */
         } else {
            strncpy( value, cvalue, l - 1 );
            value[ l - 1 ] = 0;
         }
      }

/* If the KeyError attribute is non-zero, report an error if the key is not
   found */
   } else if( astGetKeyError( this ) && astOK ) {
      astError( AST__MPKER, "astMapGetElemC(%s): No value was found for "
                "%s in the supplied KeyMap.", status, astGetClass( this ),
                key );
   }

/* If an error occurred,return zero. */
   if( !astOK ) result = 0;

/* Return the result.*/
   return result;
}

int astMapGetElemAId_( AstKeyMap *this, const char *skey, int elem,
                       AstObject **value, int *status ) {
/*
*  Name:
*     astMapGetElemAId_

*  Purpose:
*     Get a single element of a vector of AstObject pointers from a KeyMap.

*  Type:
*     Private function.

*  Synopsis:
*     #include "ast.h"
*     int astMapGetElemA( AstKeyMap *this, const char *key, int elem,
*                         AstObject **value )

*  Class Membership:
*     KeyMap method.

*  Description:
*     This is the public implementation of the astMapGetElemA function
*     It is identical to astMapGetElemA_ except that an ID value is returned
*     via the "value" parameter instead of a true C pointer. This is required
*     because this conversion cannot be performed by the macro that invokes
*     the function.

*  Parameters:
*     (see astMapGet1<X>)

*/

/* Local Variables: */
   AstMapEntry *mapentry;  /* Pointer to parent MapEntry structure */
   AstObject *avalue;      /* Pointer to AstObject */
   const char *key;        /* Pointer to key string to use */
   char keybuf[ AST__MXKEYLEN + 1 ]; /* Buffer for upper cas key */
   int itab;               /* Index of hash table element to use */
   int nel;                /* Number of elements in raw vector */
   int raw_type;           /* Data type of stored value */
   int result;             /* Returned flag */
   size_t raw_size;        /* Size of a single raw value */
   unsigned long hash;     /* Full width hash value */
   void *raw;              /* Pointer to stored value */

/* Initialise */
   result = 0;

/* Check the global error status. */
   if ( !astOK ) return result;

/* Convert the supplied key to upper case if required. */
   key = ConvertKey( this, skey, keybuf, AST__MXKEYLEN + 1, "astMapGetElemA",
                     status );

/* Use the hash function to determine the element of the hash table in
   which the key will be stored. */
   itab = HashFun( key, this->mapsize - 1, &hash, status );

/* Search the relevent table entry for the required MapEntry. */
   mapentry = SearchTableEntry( this, itab, key, status );

/* Skip rest if the key was not found. */
   if( mapentry ) {
      result = 1;

/* Get the address of the first raw value, and its data type. Also get
   the size of each element of the vector. */
      nel = mapentry->nel;
      raw_type = mapentry->type;
      if( raw_type == AST__INTTYPE ){
         raw_size = sizeof( int );
         if( nel == 0 ) {
            raw = &( ((Entry0I *)mapentry)->value );
         } else {
            raw = ((Entry1I *)mapentry)->value;
         }

      } else if( raw_type == AST__SINTTYPE ){
         raw_size = sizeof( short int );
         if( nel == 0 ) {
            raw = &( ((Entry0S *)mapentry)->value );
         } else {
            raw = ((Entry1S *)mapentry)->value;
         }

      } else if( raw_type == AST__KINTTYPE ){
         raw_size = sizeof( int64_t );
         if( nel == 0 ) {
            raw = &( ((Entry0K *)mapentry)->value );
         } else {
            raw = ((Entry1K *)mapentry)->value;
         }

      } else if( raw_type == AST__BYTETYPE ){
         raw_size = sizeof( unsigned char );
         if( nel == 0 ) {
            raw = &( ((Entry0B *)mapentry)->value );
         } else {
            raw = ((Entry1B *)mapentry)->value;
         }

      } else if( raw_type == AST__DOUBLETYPE ){
         raw_size = sizeof( double );
         if( nel == 0 ) {
            raw = &( ((Entry0D *)mapentry)->value );
         } else {
            raw = ((Entry1D *)mapentry)->value;
         }

      } else if( raw_type == AST__POINTERTYPE ){
         raw_size = sizeof( void * );
         if( nel == 0 ) {
            raw = &( ((Entry0P *)mapentry)->value );
         } else {
            raw = ((Entry1P *)mapentry)->value;
         }

      } else if( raw_type == AST__FLOATTYPE ){
         raw_size = sizeof( float );
         if( nel == 0 ) {
            raw = &( ((Entry0F *)mapentry)->value );
         } else {
            raw = ((Entry1F *)mapentry)->value;
         }

      } else if( raw_type == AST__STRINGTYPE ){
         raw_size = sizeof( const char * );
         if( nel == 0 ) {
            raw = &( ((Entry0C *)mapentry)->value );
         } else {
            raw = ((Entry1C *)mapentry)->value;
         }

      } else if( raw_type == AST__OBJECTTYPE ){
         raw_size = sizeof( AstObject * );
         if( nel == 0 ) {
            raw = &( ((Entry0A *)mapentry)->value );
         } else {
            raw = ((Entry1A *)mapentry)->value;
         }

      } else if( raw_type == AST__UNDEFTYPE ){
         raw = NULL;

      } else {
         raw_size = 0;
         raw = NULL;
         astError( AST__INTER, "astMapGetElemA(KeyMap): Illegal map entry data "
                   "type %d encountered (internal AST programming error).", status,
                   raw_type );
      }

/* Treat scalars as single-value vectors. */
      if( nel == 0 ) nel = 1;

/* Ensure the requested element is within the bounds of the vector */
      if( elem >= nel || elem < 0 ) {
         if( astOK ) {
            astError( AST__MPVIN, "astMapGetElemA(KeyMap): Illegal vector "
                      "index %d supplied for KeyMap entry '%s' - should be "
                      "in the range 1 to %d.", status, elem + 1, key, nel + 1 );
         }

/* Get a pointer to the requested raw value. */
      } else if( raw ){
         raw = (char *) raw + elem*raw_size;

/* Convert the value, storing the result in the supplied buffer. Report an
   error if conversion is not possible. */
         if( !ConvertValue( raw, raw_type, &avalue, AST__OBJECTTYPE, status ) && astOK ){
            astError( AST__MPGER, "astMapGetElemA(%s): The value of "
                      "element %d of KeyMap key \"%s\" cannot be read using "
                      "the requested data type.", status,astGetClass( this ),
                      elem + 1, key );

/* If succesful, return an ID value for the Object. */
         } else {
            *value = avalue ? astMakeId( avalue ) : NULL;
         }
      }

/* If the KeyError attribute is non-zero, report an error if the key is not
   found */
   } else if( astGetKeyError( this ) && astOK ) {
      astError( AST__MPKER, "astMapGetElemA(%s): No value was found for "
                "%s in the supplied KeyMap.", status, astGetClass( this ),
                key );
   }

/* If an error occurred,return zero. */
   if( !astOK ) result = 0;

/* Return the result.*/
   return result;
}

static int MapDefined( AstKeyMap *this, const char *skey, int *status ) {
/*
*++
*  Name:
c     astMapDefined
f     AST_MAPDEFINED

*  Purpose:
*     Check if a KeyMap contains a defined value for a key.

*  Type:
*     Public virtual function.

*  Synopsis:
c     #include "ast.h"
c     int astMapDefined( AstKeyMap *this, const char *key );
f     RESULT = AST_MAPDEFINED( THIS, KEY, STATUS )

*  Class Membership:
*     KeyMap method.

*  Description:
*     This function checks to see if a KeyMap contains a defined value for
*     a given key. If the key is present in the KeyMap but has an
*     undefined value it returns
c     zero (unlike astMapHasKey which would return non-zero).
f     .FALSE. (unlike AST_MAPHASKEY which would return .TRUE.).

*  Parameters:
c     this
f     THIS = INTEGER (Given)
*        Pointer to the KeyMap.
c     key
f     KEY = CHARACTER * ( * ) (Given)
*        The character string identifying the value to be retrieved. Trailing
*        spaces are ignored. The supplied string is converted to upper
*        case before use if the KeyCase attribute is currently set to zero.
f     STATUS = INTEGER (Given and Returned)
f        The global status.

*  Returned Value:
c     astMapDefined()
f     AST_MAPDEFINED = LOGICAL
c        A non-zero value
f        .TRUE.
*        is returned if the requested key name is present in the KeyMap
*        and has a defined value.

*--
*/

/* Local Variables: */
   AstMapEntry *mapentry;  /* Pointer to parent MapEntry structure */
   const char *key;        /* Pointer to key string to use */
   char keybuf[ AST__MXKEYLEN + 1 ]; /* Buffer for upper cas key */
   int itab;               /* Index of hash table element to use */
   int result;             /* Returned flag */
   unsigned long hash;     /* Full width hash value */

/* Initialise */
   result = 0;

/* Check the global error status. */
   if ( !astOK ) return result;

/* Convert the supplied key to upper case if required. */
   key = ConvertKey( this, skey, keybuf, AST__MXKEYLEN + 1, "astMapDefined",
                     status );

/* Use the hash function to determine the element of the hash table in
   which the key will be stored. */
   itab = HashFun( key, this->mapsize - 1, &hash, status );

/* Search the relevent table entry for the required MapEntry. */
   mapentry = SearchTableEntry( this, itab, key, status );

/* Skip rest if the key was not found. */
   if( mapentry ) {

/* Set the result depending on the entry data type. */
      if( mapentry->type == AST__UNDEFTYPE ){
         result = 0;
      } else {
         result = 1;
      }

/* If the KeyError attribute is non-zero, report an error if the key is not
   found */
   } else if( astGetKeyError( this ) && astOK ) {
      astError( AST__MPKER, "astMapDefined(%s): No value was found for "
                "%s in the supplied KeyMap.", status, astGetClass( this ),
                key );
   }

/* If an error occurred, return zero. */
   if( !astOK ) result = 0;

/* Return the result.*/
   return result;
}

static int MapHasKey( AstKeyMap *this, const char *skey, int *status ) {
/*
*++
*  Name:
c     astMapHasKey
f     AST_MAPHASKEY

*  Purpose:
*     Check if an entry with a given key exists in a KeyMap.

*  Type:
*     Public virtual function.

*  Synopsis:
c     #include "keymap.h"
c     int astMapHasKey( AstKeyMap *this, const char *key )
f     RESULT = AST_MAPHASKEY( THIS, KEY, STATUS )

*  Class Membership:
*     KeyMap method.

*  Description:
*     This function returns a flag indicating if the KeyMap contains an
*     entry with the given key.

*  Parameters:
c     this
f     THIS = INTEGER (Given)
*        Pointer to the KeyMap.
c     key
f     KEY = CHARACTER * ( * ) (Given)
*        The character string identifying the KeyMap entry. Trailing spaces are
*        ignored.
*        The supplied string is converted to upper case before use if the
*        KeyCase attribute is currently set to zero.
f     STATUS = INTEGER (Given and Returned)
f        The global status.

*  Returned Value:
c     astMapHasKey()
f     AST_MAPHASKEY = LOGICAL
c        Non-zero if the key was found, and zero otherwise.
f        .TRUE. if the key was found, and .FALSE. otherwise.

*  Notes:
c     - A non-zero function value
f     - .TRUE.
*     is returned if the key exists but has an undefined value (that is,
*     the returned value does not depend on whether the entry has a
*     defined value or not). See also
c     astMapDefined, which returns zero in such a case.
f     AST_MAPDEFINED, which returns zero in such a case.
*     - A function value of
c     zero
f     .FALSE.
*     will be returned if an error has already occurred, or if this
*     function should fail for any reason.

*--
*/

/* Local Variables: */
   AstMapEntry *mapentry;  /* Pointer to entry in linked list */
   const char *key;        /* Pointer to key string to use */
   char keybuf[ AST__MXKEYLEN + 1 ]; /* Buffer for upper cas key */
   int itab;               /* Index of hash table element to use */
   int result;             /* Returned value */
   unsigned long hash;     /* Full width hash value */

/* Initialise */
   result = 0;

/* Check the global error status. */
   if ( !astOK ) return result;

/* Convert the supplied key to upper case if required. */
   key = ConvertKey( this, skey, keybuf, AST__MXKEYLEN + 1, "astMapHasKey",
                     status );

/* Use the hash function to determine the element of the hash table in
   which the key will be stored. */
   itab = HashFun( key, this->mapsize - 1, &hash, status );

/* Search the relevent table entry for the required MapEntry. */
   mapentry = SearchTableEntry( this, itab, key, status );

/* Set a non-zero return value if the key was found. */
   if( mapentry ) result = 1;

/* If an error has occurred, return zero. */
   if( !astOK ) result = 0;

/* Return the result. */
   return result;

}

static void MapRemove( AstKeyMap *this, const char *skey, int *status ) {
/*
*++
*  Name:
c     astMapRemove
f     AST_MAPREMOVE

*  Purpose:
*     Removed a named entry from a KeyMap.

*  Type:
*     Public virtual function.

*  Synopsis:
c     #include "keymap.h"
c     void astMapRemove( AstKeyMap *this, const char *key )
f     CALL AST_MAPREMOVE( THIS, KEY, STATUS )

*  Class Membership:
*     KeyMap method.

*  Description:
c     This function
f     This routine
*     removes a named entry from a KeyMap. It returns without action if the
*     KeyMap does not contain the specified key.

*  Parameters:
c     this
f     THIS = INTEGER (Given)
*        Pointer to the KeyMap.
c     key
f     KEY = CHARACTER * ( * ) (Given)
*        The character string identifying the value to be retrieved. Trailing
*        spaces are ignored.
*        The supplied string is converted to upper case before use if the
*        KeyCase attribute is currently set to zero.
f     STATUS = INTEGER (Given and Returned)
f        The global status.
*--
*/

/* Local Variables: */
   const char *key;        /* Pointer to key string to use */
   char keybuf[ AST__MXKEYLEN + 1 ]; /* Buffer for upper cas key */
   int itab;               /* Index of hash table element to use */
   unsigned long hash;     /* Full width hash value */

/* Check the global error status. */
   if ( !astOK ) return;

/* Convert the supplied key to upper case if required. */
   key = ConvertKey( this, skey, keybuf, AST__MXKEYLEN + 1, "astMapRemove",
                     status );

/* Use the hash function to determine the element of the hash table in
   which the key will be stored. */
   itab = HashFun( key, this->mapsize - 1, &hash, status );

/* Search the relevent table entry for the required MapEntry and remove it. */
   (void) FreeMapEntry( RemoveTableEntry( this, itab, key, status ), status );
}

static void MapRename( AstKeyMap *this, const char *soldkey, const char *snewkey,
                       int *status ) {
/*
*++
*  Name:
c     astMapRename
f     AST_MAPRENAME

*  Purpose:
*     Rename an existing KeyMap entry.

*  Type:
*     Public virtual function.

*  Synopsis:
c     #include "keymap.h"
c     void astMapRename( AstKeyMap *this, const char *oldkey, const char *newkey )
f     CALL AST_MAPRENAME( THIS, OLDKEY, NEWKEY, STATUS )

*  Class Membership:
*     KeyMap method.

*  Description:
c     This function
f     This routine
*     associated a new key with an existing entry in a KeyMap. It returns
*     without action if the oldkey does not exist in the KeyMap.

*  Parameters:
c     this
f     THIS = INTEGER (Given)
*        Pointer to the KeyMap.
c     oldkey
f     OLDKEY = CHARACTER * ( * ) (Given)
*        The character string identifying the entry to be renamed. Trailing
*        spaces are ignored.
*        The supplied string is converted to upper case before use if the
*        KeyCase attribute is currently set to zero.
c     newkey
f     NEKEY = CHARACTER * ( * ) (Given)
*        The new character string to associated with the renamed entry.
*        Trailing spaces are ignored.
*        The supplied string is converted to upper case before use if the
*        KeyCase attribute is currently set to zero.
f     STATUS = INTEGER (Given and Returned)
f        The global status.
*--
*/

/* Local Variables: */
   AstMapEntry *entry;     /* Pointer to the entry being renamed */
   AstMapEntry *oldent;    /* Pointer to old entry with new name */
   const char *oldkey;     /* Pointer to key string to use */
   char oldkeybuf[ AST__MXKEYLEN + 1 ]; /* Buffer for upper cas key */
   const char *newkey;     /* Pointer to key string to use */
   char newkeybuf[ AST__MXKEYLEN + 1 ]; /* Buffer for upper cas key */
   char *p;                /* Pointer to next key character */
   int itab;               /* Index of hash table element to use */
   int keylen;             /* Length of supplied key string */
   int keymember;          /* Identifier for new key */
   int there;              /* Did the entry already exist in the KeyMap? */
   unsigned long hash;     /* Full width hash value */

/* Check the global error status. */
   if ( !astOK ) return;

/* Convert the supplied keys to upper case if required. */
   oldkey = ConvertKey( this, soldkey, oldkeybuf, AST__MXKEYLEN + 1,
                        "astMapRename", status );
   newkey = ConvertKey( this, snewkey, newkeybuf, AST__MXKEYLEN + 1,
                        "astMapRename", status );

/* Do nothing if the keys are the same. */
   if( strcmp( oldkey, newkey ) ){

/* Use the hash function to determine the element of the hash table in
   which the old key will be stored. */
      itab = HashFun( oldkey, this->mapsize - 1, &hash, status );

/* Search the relevent table entry for the required MapEntry. Remove it
   from the list, but do not free it. */
      entry = RemoveTableEntry( this, itab, oldkey, status );

/* Skip rest if the key was not found. */
      if( entry ) {

/* Store the new key string, and terminate it to exclude any trailing
   spaces. */
         keylen = strlen( newkey );
         entry->key = astStore( (void *) entry->key, newkey, keylen + 1 );
         if( astOK ) {
            p = (char *) entry->key + keylen;
            while( --p >= entry->key ) {
               if( *p == ' ' ) {
                  *p = 0;
               } else {
                  break;
               }
            }
         }

/* Use the hash function to determine the element of the hash table in
   which to store the entry with its new key. */
         itab = HashFun( entry->key, this->mapsize - 1, &(entry->hash), status );

/* Remove and free any existing entry with the given key from the table
   element. */
         oldent = RemoveTableEntry( this, itab, entry->key, status );
         if( oldent ) {
            keymember = oldent->keymember;
            oldent = FreeMapEntry( oldent, status );
            there = 1;
         } else {
            keymember = -1;
            there = 0;
         }

/* If the KeyMap is locked we report an error if an attempt is made to
   introduce a new key. */
         if( !there && astGetMapLocked( this ) ) {
            astError( AST__BADKEY, "astMapRename(%s): Failed to rename item "
                      "\"%s\" in a KeyMap to \"%s\": \"%s\" is not a known "
                      "item.", status, astGetClass( this ), oldkey, newkey,
                      newkey );
         }

/* If all has gone OK, store the renamed entry at the head of the linked list
   associated with the selected table entry. */
         if( astOK ) {
            entry = AddTableEntry( this, itab, entry, keymember, status );

/* If anything went wrong, try to delete the renamed entry. */
         } else {
            entry = FreeMapEntry( entry, status );
         }
      }
   }
}

static int MapSize( AstKeyMap *this, int *status ) {
/*
*++
*  Name:
c     astMapSize
f     AST_MAPSIZE

*  Purpose:
*     Get the number of entries in a KeyMap.

*  Type:
*     Public virtual function.

*  Synopsis:
c     #include "keymap.h"
c     int astMapSize( AstKeyMap *this )
f     RESULT = AST_MAPSIZE( THIS, STATUS )

*  Class Membership:
*     KeyMap method.

*  Description:
*     This function returns the number of entries in a KeyMap.

*  Parameters:
c     this
f     THIS = INTEGER (Given)
*        Pointer to the KeyMap.
f     STATUS = INTEGER (Given and Returned)
f        The global status.

*  Returned Value:
c     astMapSize()
f     AST_MAPSIZE = INTEGER
*        The number of entries in the KeyMap.

*  Notes:
*     - A function value of zero will be returned if an error has already
*     occurred, or if this function should fail for any reason.

*--
*/

/* Local Variables: */
   int itab;               /* Index of hash table element to use */
   int result;             /* Returned value */

/* Initialise */
   result = 0;

/* Check the global error status. */
   if ( !astOK ) return result;

/* Add up the number of entries in all elements of the hash table. */
   for( itab = 0; itab < this->mapsize; itab++ ) result += this->nentry[ itab ];

/* Return the result. */
   return result;

}

static int MapLenC( AstKeyMap *this, const char *skey, int *status ) {
/*
*++
*  Name:
c     astMapLenC
f     AST_MAPLENC

*  Purpose:
*     Get the number of characters in a character entry in a KeyMap.

*  Type:
*     Public virtual function.

*  Synopsis:
c     #include "keymap.h"
c     int astMapLenC( AstKeyMap *this, const char *key )
f     RESULT = AST_MAPLENC( THIS, KEY, STATUS )

*  Class Membership:
*     KeyMap method.

*  Description:
*     This function returns the minimum length that a character variable
*     must have in order to be able to store a specified entry in
*     the supplied KeyMap. If the named entry is a vector entry, then the
*     returned value is the length of the longest element of the vector
*     value.

*  Parameters:
c     this
f     THIS = INTEGER (Given)
*        Pointer to the KeyMap.
c     key
f     KEY = CHARACTER * ( * ) (Given)
*        The character string identifying the KeyMap entry. Trailing
*        spaces are ignored.
*        The supplied string is converted to upper case before use if the
*        KeyCase attribute is currently set to zero.
f     STATUS = INTEGER (Given and Returned)
f        The global status.

*  Returned Value:
c     astMapLenC()
f     AST_MAPLENC = INTEGER
*        The length (i.e. number of characters) of the longest formatted
*        value associated with the named entry.
c        This does not include the trailing null character.

*  Notes:
*     - A function value of zero will be returned without error if the
*     named entry cannot be formatted as a character string.
*     - A function value of zero will be returned if an error has already
*     occurred, or if this function should fail for any reason.

*--
*/

/* Local Variables: */
   AstMapEntry *mapentry;  /* Pointer to parent MapEntry structure */
   const char *key;        /* Pointer to key string to use */
   char keybuf[ AST__MXKEYLEN + 1 ]; /* Buffer for upper cas key */
   int i;                  /* Element index */
   int itab;               /* Index of hash table element to use */
   int l;                  /* Length of formatted vector element */
   int nel;                /* Number of elements in raw vector */
   int raw_type;           /* Data type of stored value */
   int result;             /* Returned value */
   size_t raw_size;        /* Size of a single raw value */
   unsigned long hash;     /* Full width hash value */
   void *raw;              /* Pointer to stored value */

/* Initialise */
   result = 0;

/* Check the global error status. */
   if ( !astOK ) return result;

/* Convert the supplied key to upper case if required. */
   key = ConvertKey( this, skey, keybuf, AST__MXKEYLEN + 1, "astMapLenC",
                     status );

/* Use the hash function to determine the element of the hash table in
   which the key will be stored. */
   itab = HashFun( key, this->mapsize - 1, &hash, status );

/* Search the relevent table entry for the required MapEntry. */
   mapentry = SearchTableEntry( this, itab, key, status );

/* Skip rest if the key was not found. */
   if( mapentry ) {

/* Get the address of the first raw value, and its data type. Also get
   the size of each element of the vector. */
      nel = mapentry->nel;
      raw_type = mapentry->type;
      if( raw_type == AST__INTTYPE ){
         raw_size = sizeof( int );
         if( nel == 0 ) {
            raw = &( ((Entry0I *)mapentry)->value );
         } else {
            raw = ((Entry1I *)mapentry)->value;
         }

      } else if( raw_type == AST__POINTERTYPE ){
         raw_size = sizeof( void * );
         if( nel == 0 ) {
            raw = &( ((Entry0P *)mapentry)->value );
         } else {
            raw = ((Entry1P *)mapentry)->value;
         }

      } else if( raw_type == AST__DOUBLETYPE ){
         raw_size = sizeof( double );
         if( nel == 0 ) {
            raw = &( ((Entry0D *)mapentry)->value );
         } else {
            raw = ((Entry1D *)mapentry)->value;
         }

      } else if( raw_type == AST__SINTTYPE ){
         raw_size = sizeof( short int );
         if( nel == 0 ) {
            raw = &( ((Entry0S *)mapentry)->value );
         } else {
            raw = ((Entry1S *)mapentry)->value;
         }

      } else if( raw_type == AST__KINTTYPE ){
         raw_size = sizeof( int64_t );
         if( nel == 0 ) {
            raw = &( ((Entry0K *)mapentry)->value );
         } else {
            raw = ((Entry1K *)mapentry)->value;
         }

      } else if( raw_type == AST__BYTETYPE ){
         raw_size = sizeof( unsigned char );
         if( nel == 0 ) {
            raw = &( ((Entry0B *)mapentry)->value );
         } else {
            raw = ((Entry1B *)mapentry)->value;
         }

      } else if( raw_type == AST__FLOATTYPE ){
         raw_size = sizeof( float );
         if( nel == 0 ) {
            raw = &( ((Entry0F *)mapentry)->value );
         } else {
            raw = ((Entry1F *)mapentry)->value;
         }

      } else if( raw_type == AST__STRINGTYPE ){
         raw_size = sizeof( const char * );
         if( nel == 0 ) {
            raw = &( ((Entry0C *)mapentry)->value );
         } else {
            raw = ((Entry1C *)mapentry)->value;
         }

      } else if( raw_type == AST__OBJECTTYPE ){
         raw_size = sizeof( AstObject * );
         if( nel == 0 ) {
            raw = &( ((Entry0A *)mapentry)->value );
         } else {
            raw = ((Entry1A *)mapentry)->value;
         }

      } else if( raw_type == AST__UNDEFTYPE ){
         raw_size = 0;
         raw = NULL;

      } else {
         raw_size = 0;
         raw = NULL;
         astError( AST__INTER, "astMapLenC(KeyMap): Illegal map entry data "
                   "type %d encountered (internal AST programming error).", status,
                   raw_type );
      }

/* Treat scalars as single-value vectors. */
      if( nel == 0 ) nel = 1;

/* Skip undefined values. */
      if( raw ) {

/* Initialise the maximum length of any formatted value in the entry. */
         result= 0;

/* Loop round all values in the vector. */
         for( i = 0; i < nel && astOK; i++ ) {

/* Go through the motions of formatting the value. We do not actually
   need the formatted string (just its length) so we provide a NULL pointer
   for the output buffer. The entry is ignored if it cannot be formatted.
   Note, the length returned by ConvertValue includes the terminating null,
   so decrement it first. */
            l = ConvertValue( raw, raw_type, NULL, AST__STRINGTYPE, status );
            if( --l > result ) result = l;

/* Increment the pointer to the next raw value. */
            raw = (char *) raw + raw_size;
         }
      }
   }

/* If an error has occurred, return zero. */
   if( !astOK ) result = 0;

/* Return the result. */
   return result;

}

static int MapLength( AstKeyMap *this, const char *skey, int *status ) {
/*
*++
*  Name:
c     astMapLength
f     AST_MAPLENGTH

*  Purpose:
*     Get the vector length of an entry in a KeyMap.

*  Type:
*     Public virtual function.

*  Synopsis:
c     #include "keymap.h"
c     int astMapLength( AstKeyMap *this, const char *key )
f     RESULT = AST_MAPLENGTH( THIS, KEY, STATUS )

*  Class Membership:
*     KeyMap method.

*  Description:
*     This function returns the vector length of a named entry in a KeyMap,
*     (that is, how many values are associated with the entry).

*  Parameters:
c     this
f     THIS = INTEGER (Given)
*        Pointer to the KeyMap.
c     key
f     KEY = CHARACTER * ( * ) (Given)
*        The character string identifying the KeyMap entry. Trailing
*        spaces are ignored.
*        The supplied string is converted to upper case before use if the
*        KeyCase attribute is currently set to zero.
f     STATUS = INTEGER (Given and Returned)
f        The global status.

*  Returned Value:
c     astMapLength()
f     AST_MAPLENGTH = INTEGER
*        The length of the entry. One for a scalar, greater than one for
*        a vector. A value of zero is returned if the KeyMap does not
*        contain the named entry.

*  Notes:
*     - A function value of zero will be returned if an error has already
*     occurred, or if this function should fail for any reason.

*--
*/

/* Local Variables: */
   AstMapEntry *mapentry;  /* Pointer to entry in linked list */
   const char *key;        /* Pointer to key string to use */
   char keybuf[ AST__MXKEYLEN + 1 ]; /* Buffer for upper cas key */
   int itab;               /* Index of hash table element to use */
   int result;             /* Returned value */
   unsigned long hash;     /* Full width hash value */

/* Initialise */
   result = 0;

/* Check the global error status. */
   if ( !astOK ) return result;

/* Convert the supplied key to upper case if required. */
   key = ConvertKey( this, skey, keybuf, AST__MXKEYLEN + 1, "astMapLength",
                     status );

/* Use the hash function to determine the element of the hash table in
   which the key will be stored. */
   itab = HashFun( key, this->mapsize - 1, &hash, status );

/* Search the relevent table entry for the required MapEntry. */
   mapentry = SearchTableEntry( this, itab, key, status );

/* Skip rest if the key was not found. */
   if( mapentry ) {

/* Store the netry length */
      result = mapentry->nel;

/* Return 1 for a scalar. */
      if( result == 0 ) result = 1;

   }

/* If an error has occurred, return zero. */
   if( !astOK ) result = 0;

/* Return the result. */
   return result;

}

/*
*++
*  Name:
c     astMapPutElem<X>
f     AST_MAPPUTELEM<X>

*  Purpose:
*     Put a value into an element of a vector value in a KeyMap.

*  Type:
*     Public virtual function.

*  Synopsis:
c     #include "ast.h"
c     void astMapPutElem<X>( AstKeyMap *this, const char *key, int elem,
c                            <X>type value )
f     CALL AST_MAPPUTELEM<X>( THIS, KEY, ELEM, VALUE, STATUS )

*  Class Membership:
*     KeyMap method.

*  Description:
*     This is a set of functions for storing a value in a single element of
*     a vector value in a KeyMap. You should replace <X> in the generic
*     function name
c     astMapPutElem<X>
f     AST_MAPPUTELEM<X>
*     by an appropriate 1-character type code (see the "Data Type Codes"
*     section below for the code appropriate to each supported data type).
*     The supplied value is converted from the data type indicated by <X>
*     to the data type of the KeyMap entry before being stored (an error
*     is reported if it is not possible to convert the value to the
*     required data type).

*  Parameters:
c     this
f     THIS = INTEGER (Given)
*        Pointer to the KeyMap.
c     key
f     KEY = CHARACTER * ( * ) (Given)
*        The character string identifying the value to be retrieved. Trailing
*        spaces are ignored.
*        The supplied string is converted to upper case before use if the
*        KeyCase attribute is currently set to zero.
c     elem
f     ELEM = INTEGER (Given)
*        The index of the vector element to modify, starting at
c        zero.
f        one.
c     value
f     VALUE = <X>type (Given)
*        The value to store.
f     STATUS = INTEGER (Given and Returned)
f        The global status.

*  Applicability:
*     KeyMap
*        If the
c        "elem"
f        ELEM
*        index is outside the range of the vector, the length of
*        the vector will be increased by one element and the supplied
*        value will be stored at the end of the vector in the new element.
*     Table
*        If the
c        "elem"
f        ELEM
*        index is outside the range of the vector, an error will be
*        reported. The number of elements in each cell of a column is
*        specified when the column is created using
c        astAddColumn.
f        AST_ADDCOLUMN.

*  Notes:
*     - If the entry originally holds a scalar value, it will be treated
*     like a vector entry of length 1.
*     - If the specified key cannot be found in the given KeyMap, or is
*     found but has an undefined value, a new
*     vector entry with the given name, and data type implied by <X>, is
*     created and the supplied value is stored in its first entry.

*  Data Type Codes:
*     To select the appropriate
c     function, you should replace <X> in the generic function name
c     astMapPutElem<X>
f     routine, you should replace <X> in the generic routine name
f     AST_MAPPUTELEM<X>
*     with a 1-character data type code, so as to match the data type <X>type
*     of the data you are processing, as follows:
c     - D: double
c     - F: float
c     - I: int
c     - K: int64_t
c     - C: "const" pointer to null terminated character string
c     - A: Pointer to AstObject
c     - P: Generic "void *" pointer
c     - S: short int
c     - B: Unsigned byte (i.e. char)
f     - D: DOUBLE PRECISION
f     - R: REAL
f     - I: INTEGER
f     - K: INTEGER*8
f     - C: CHARACTER
f     - A: INTEGER used to identify an AstObject
f     - S: INTEGER*2 (short integer)
f     - B: BYTE (unsigned)
*
c     For example, astMapPutElemD would be used to put a "double" value, while
c     astMapPutElemI would be used to put an "int" value, etc. For D or I, the
c     supplied "value" parameter should be a double or int. For
c     C, the supplied "value" parameter should be a pointer to a character
c     string. For A, the supplied "value" parameter should be an AstObject
c     pointer.
f     For example, AST_MAPPUTELEMD would be used to put a DOUBLE PRECISION
f     value, while AST_MAPPUTELEMI would be used to put an INTEGER value, etc.

*--
*/
/* Define a macro to implement the function for a specific data type
(excluding "C" since that needs an extra parameter). */
#define MAKE_MAPPUTELEM(X,Xtype,Itype) \
static void MapPutElem##X( AstKeyMap *this, const char *skey, int elem, \
                           Xtype value, int *status ) { \
\
/* Local Variables: */ \
   AstMapEntry *mapentry;  /* Pointer to parent MapEntry structure */ \
   const char *key;        /* Pointer to key string to use */ \
   char keybuf[ AST__MXKEYLEN + 1 ]; /* Buffer for upper cas key */ \
   int itab;               /* Index of hash table element to use */ \
   int nel;                /* Number of elements in raw vector */ \
   int new;                /* Was a new uninitialised element created? */ \
   int raw_type;           /* Data type of stored value */ \
   size_t raw_size;        /* Size of a single raw value */ \
   unsigned long hash;     /* Full width hash value */ \
   void *raw;              /* Pointer to stored value */ \
\
/* Check the global error status. */ \
   if ( !astOK ) return; \
\
/* Perform any necessary checks on the supplied value to be stored. */ \
   CHECK_##X \
\
/* Convert the supplied key to upper case if required. */ \
   key = ConvertKey( this, skey, keybuf, AST__MXKEYLEN + 1, "astMapPutElem" #X, \
                     status ); \
\
/* Use the hash function to determine the element of the hash table in \
   which the key will be stored. */ \
   itab = HashFun( key, this->mapsize - 1, &hash, status ); \
\
/* Search the relevent table entry for the required MapEntry. */ \
   mapentry = SearchTableEntry( this, itab, key, status ); \
\
/* If the key was not found, or was found but has an undefined value, create \
   a new one with a single element, \
   and store the supplied value in it. */ \
   if( !mapentry || mapentry->type == AST__UNDEFTYPE ) { \
      astMapPut1##X( this, key, 1, &value, NULL ); \
\
/* If the key was found.... */ \
   } else { \
\
/* Get the current length of the vector (0=>scalar), and the data type. */ \
      nel = mapentry->nel; \
      raw_type = mapentry->type; \
\
/* Do each data type in turn. */ \
      if( raw_type == AST__INTTYPE ){ \
\
/* If the existing entry is scalar, create a new vector entry with the \
   same name, value, data type and comment. Then get a pointer to the new \
   entry, and indicate that we now have a vector entry of length 1. */ \
         if( nel == 0 ) { \
            astMapPut1I( this, key, 1, &( ((Entry0I *)mapentry)->value ), \
                         mapentry->comment ); \
            mapentry = SearchTableEntry( this, itab, key, status ); \
            nel = 1; \
         } \
\
/* Get the address of the first raw value in the vector. Also get \
   the size of each element of the vector. */ \
         raw = ((Entry1I *)mapentry)->value; \
         raw_size = sizeof( int ); \
\
/* Handle other data type in the same way. */ \
      } else if( raw_type == AST__SINTTYPE ){ \
         if( nel == 0 ) { \
            astMapPut1S( this, key, 1, &( ((Entry0S *)mapentry)->value ), \
                         mapentry->comment ); \
            mapentry = SearchTableEntry( this, itab, key, status ); \
            nel = 1; \
         } \
         raw = ((Entry1S *)mapentry)->value; \
         raw_size = sizeof( short int ); \
\
      } else if( raw_type == AST__KINTTYPE ){ \
         if( nel == 0 ) { \
            astMapPut1K( this, key, 1, &( ((Entry0K *)mapentry)->value ), \
                         mapentry->comment ); \
            mapentry = SearchTableEntry( this, itab, key, status ); \
            nel = 1; \
         } \
         raw = ((Entry1K *)mapentry)->value; \
         raw_size = sizeof( int64_t ); \
\
      } else if( raw_type == AST__BYTETYPE ){ \
         if( nel == 0 ) { \
            astMapPut1B( this, key, 1, &( ((Entry0B *)mapentry)->value ), \
                         mapentry->comment ); \
            mapentry = SearchTableEntry( this, itab, key, status ); \
            nel = 1; \
         } \
         raw = ((Entry1B *)mapentry)->value; \
         raw_size = sizeof( unsigned char ); \
\
      } else if( raw_type == AST__DOUBLETYPE ){ \
         if( nel == 0 ) { \
            astMapPut1D( this, key, 1, &( ((Entry0D *)mapentry)->value ), \
                         mapentry->comment ); \
            mapentry = SearchTableEntry( this, itab, key, status ); \
            nel = 1; \
         } \
         raw = ((Entry1D *)mapentry)->value; \
         raw_size = sizeof( double ); \
\
      } else if( raw_type == AST__POINTERTYPE ){ \
         if( nel == 0 ) { \
            astMapPut1P( this, key, 1, &( ((Entry0P *)mapentry)->value ), \
                         mapentry->comment ); \
            mapentry = SearchTableEntry( this, itab, key, status ); \
            nel = 1; \
         } \
         raw = ((Entry1P *)mapentry)->value; \
         raw_size = sizeof( void * ); \
\
      } else if( raw_type == AST__FLOATTYPE ){ \
         if( nel == 0 ) { \
            astMapPut1F( this, key, 1, &( ((Entry0F *)mapentry)->value ), \
                         mapentry->comment ); \
            mapentry = SearchTableEntry( this, itab, key, status ); \
            nel = 1; \
         } \
         raw = ((Entry1F *)mapentry)->value; \
         raw_size = sizeof( float ); \
\
      } else if( raw_type == AST__STRINGTYPE ){ \
         if( nel == 0 ) { \
            astMapPut1C( this, key, 1, &( ((Entry0C *)mapentry)->value ), \
                         mapentry->comment ); \
            mapentry = SearchTableEntry( this, itab, key, status ); \
            nel = 1; \
         } \
         raw = ((Entry1C *)mapentry)->value; \
         raw_size = sizeof( const char * ); \
\
      } else if( raw_type == AST__OBJECTTYPE ){ \
         if( nel == 0 ) { \
            astMapPut1A( this, key, 1, &( ((Entry0A *)mapentry)->value ), \
                         mapentry->comment ); \
            mapentry = SearchTableEntry( this, itab, key, status ); \
            nel = 1; \
         } \
         raw = ((Entry1A *)mapentry)->value; \
         raw_size = sizeof( AstObject * ); \
\
      } else { \
         raw_size = 0; \
         raw = NULL; \
         astError( AST__INTER, "astMapPutElem<X>(KeyMap): Illegal map entry " \
                   "data type %d encountered (internal AST programming " \
                   "error).", status, raw_type ); \
      } \
\
/* If the requested element is outside the bounds of the vector, extend \
   the vector by one element. */ \
      new = ( elem >= nel || elem < 0 ); \
      if( new ) { \
         elem = nel++; \
         raw = astGrow( raw, nel, raw_size ); \
         if( astOK ) { \
            mapentry->nel = nel; \
            if( raw_type == AST__INTTYPE ){ \
               ((Entry1I *)mapentry)->value = (int *) raw; \
            } else if( raw_type == AST__SINTTYPE ){ \
               ((Entry1S *)mapentry)->value = (short int *) raw; \
            } else if( raw_type == AST__KINTTYPE ){ \
               ((Entry1K *)mapentry)->value = (int64_t *) raw; \
            } else if( raw_type == AST__BYTETYPE ){ \
               ((Entry1B *)mapentry)->value = (unsigned char *) raw; \
            } else if( raw_type == AST__DOUBLETYPE ){ \
               ((Entry1D *)mapentry)->value = (double *) raw; \
            } else if( raw_type == AST__POINTERTYPE ){ \
               ((Entry1P *)mapentry)->value = (void *) raw; \
            } else if( raw_type == AST__FLOATTYPE ){ \
               ((Entry1F *)mapentry)->value = (float *) raw; \
            } else if( raw_type == AST__STRINGTYPE ){ \
               ((Entry1C *)mapentry)->value = (const char **) raw; \
            } else if( raw_type == AST__OBJECTTYPE ){ \
               ((Entry1A *)mapentry)->value = (AstObject **) raw; \
            } \
         } \
      } \
\
/* Get a pointer to the requested element. */ \
      if( astOK ) { \
         raw = (char *) raw + elem*raw_size; \
\
/* Free any memory used by the value already in the requested element. */ \
         if( ! new ) { \
            if( raw_type == AST__STRINGTYPE ){ \
               char **cp = (char **) raw; \
               *cp = astFree( *cp ); \
            } else if( raw_type == AST__OBJECTTYPE ){ \
               AstObject **op = (AstObject **) raw; \
               if( *op ) *op = astAnnul( *op ); \
            } \
         } \
\
/* Convert the supplied value, storing the result in the requested element. \
   Report an error if conversion is not possible. */ \
         if( !ConvertValue( &value, Itype, raw, raw_type, status ) && astOK ){ \
            astError( AST__MPPER, "astMapPutElem" #X "(%s): The supplied " \
                      "value cannot be converted to the data type of " \
                      "KeyMap key \"%s\".", status, astGetClass( this ), \
                      key ); \
\
/* For strings, the "raw" value is a copy of a pointer stored in the global \
   "convertvalue_strings" array. These pointers should never be freed other \
   than within the ConvertValue function (otherwise you can end up with \
   spurious "invalid pointer" errors). But the "raw" value will be freed \
   when as part of the KeyMap when the KeyMap is destroyed. So we replace \
   the "raw" value with a new copy. */ \
         } else if( raw_type == AST__STRINGTYPE ){ \
            char **cp = (char **) raw; \
            *cp = astStore( NULL, *cp, strlen( *cp ) + 1 ); \
         } \
      } \
   } \
}

/* Define macros which perform any necessary checks on the supplied value
   to be stored. For Object entries, check that we are not adding a KeyMap
   which already contains "this". This avoids circular dependencies.
   Other types do not need any checks. */
#define CHECK_A CheckCircle( this, value, "astMapPutElemA", status );
#define CHECK_I
#define CHECK_B
#define CHECK_S
#define CHECK_K
#define CHECK_D
#define CHECK_F
#define CHECK_C
#define CHECK_P

/* Expand the above macro to generate a function for each required
   data type. */
MAKE_MAPPUTELEM(I,int,AST__INTTYPE)
MAKE_MAPPUTELEM(D,double,AST__DOUBLETYPE)
MAKE_MAPPUTELEM(F,float,AST__FLOATTYPE)
MAKE_MAPPUTELEM(A,AstObject *,AST__OBJECTTYPE)
MAKE_MAPPUTELEM(P,void *,AST__POINTERTYPE)
MAKE_MAPPUTELEM(C,const char *,AST__STRINGTYPE)
MAKE_MAPPUTELEM(S,short int,AST__SINTTYPE)
MAKE_MAPPUTELEM(K,int64_t,AST__KINTTYPE)
MAKE_MAPPUTELEM(B,unsigned char,AST__BYTETYPE)

/* Undefine the macro. */
#undef MAKE_MAPPUTELEM
#undef CHECK_A
#undef CHECK_I
#undef CHECK_B
#undef CHECK_S
#undef CHECK_K
#undef CHECK_D
#undef CHECK_F
#undef CHECK_C
#undef CHECK_P


static int MapType( AstKeyMap *this, const char *skey, int *status ) {
/*
*++
*  Name:
c     astMapType
f     AST_MAPTYPE

*  Purpose:
*     Get the data type of an entry in a KeyMap.

*  Type:
*     Public virtual function.

*  Synopsis:
c     #include "keymap.h"
c     int astMapType( AstKeyMap *this, const char *key )
f     RESULT = AST_MAPTYPE( THIS, KEY, STATUS )

*  Class Membership:
*     KeyMap method.

*  Description:
*     This function returns a value indicating the data type of a
*     named entry in a KeyMap. This is the data type which was used when the
*     entry was added to the KeyMap.

*  Parameters:
c     this
f     THIS = INTEGER (Given)
*        Pointer to the KeyMap.
c     key
f     KEY = CHARACTER * ( * ) (Given)
*        The character string identifying the KeyMap entry. Trailing
*        spaces are ignored.
*        The supplied string is converted to upper case before use if the
*        KeyCase attribute is currently set to zero.
f     STATUS = INTEGER (Given and Returned)
f        The global status.

*  Returned Value:
c     astMapType()
f     AST_MAPTYPE = INTEGER
*        One of AST__INTTYPE (for integer), AST__SINTTYPE (for
c        short int),
f        INTEGER*2),
*        AST__KINTTYPE (for
c        int64_t),
f        INTEGER*8),
*        AST__BYTETYPE (for unsigned bytes
c        - i.e. unsigned chars
*        ) AST__DOUBLETYPE (for double
*        precision floating point), AST__FLOATTYPE (for single
*        precision floating point), AST__STRINGTYPE (for character string),
*        AST__OBJECTTYPE (for AST Object pointer), AST__POINTERTYPE (for
*        arbitrary C pointer) or AST__UNDEFTYPE (for undefined values
*        created by
c        astMapPutU).
f        AST_MAPPUTU).
*        AST__BADTYPE is returned if the supplied key is not found in the KeyMap.

*  Notes:
*     - A function value of AST__BADTYPE will be returned if an error has
*     already occurred, or if this function should fail for any reason.

*--
*/

/* Local Variables: */
   AstMapEntry *mapentry;  /* Pointer to entry in linked list */
   const char *key;        /* Pointer to key string to use */
   char keybuf[ AST__MXKEYLEN + 1 ]; /* Buffer for upper cas key */
   int itab;               /* Index of hash table element to use */
   int result;             /* Returned value */
   unsigned long hash;     /* Full width hash value */

/* Initialise */
   result = AST__BADTYPE;

/* Check the global error status. */
   if ( !astOK ) return result;

/* Convert the supplied key to upper case if required. */
   key = ConvertKey( this, skey, keybuf, AST__MXKEYLEN + 1, "astMapType",
                     status );

/* Use the hash function to determine the element of the hash table in
   which the key will be stored. */
   itab = HashFun( key, this->mapsize - 1, &hash, status );

/* Search the relevent table entry for the required MapEntry. */
   mapentry = SearchTableEntry( this, itab, key, status );

/* Store the type if found. */
   if( mapentry ) result = mapentry->type;

/* If an error has occurred, return zero. */
   if( !astOK ) result = AST__BADTYPE;

/* Return the result. */
   return result;

}

static const char *MapIterate( AstKeyMap *this, int reset, int *status ) {
/*
*+
*  Name:
*     astMapIterate

*  Purpose:
*     Iterate through the keys in a KeyMap.

*  Type:
*     Protected virtual function.

*  Synopsis:
*     #include "keymap.h"
*     const char *astMapIterate( AstKeyMap *this, int reset, int *status )

*  Class Membership:
*     KeyMap method.

*  Description:
*     If "reset" is non-zero, this function returns a pointer to a string
*     holding the first key in the KeyMap. On subsequent invocation (if
*     reset is zero) it returns a pointer to the next key in the KeyMap. The
*     context is stored within the KeyMap structure, so calls on different
*     KeyMaps can be mixed.
*
*     The order in which keys are returned is determined by the KeyMap
*     SortBy attribute.

*  Parameters:
*     this
*        Pointer to the KeyMap.
*     reset
*        If non-zero, return the first key in the KeyMap. Otherwise,
*        returns the key following the one returned by the previous
*        invocation of this function.

*  Returned Value:
*        A pointer to the null-terminated string holding the next key,
*        or NULL if there are no more keys in the KeyMap. The returned
*        string should NOT be freed or modified.

*  Notes:
*     - A NULL pointer will be returned if this function is invoked
*     with the AST error status set, or if it should fail for any
*     reason.
*/

/* Local Variables: */
   AstMapEntry *entry;         /* Pointer to the entry */
   const char *key;            /* Pointer value to return */
   int itab;                   /* Index into hash table */
   int sortby;                 /* The value of the SortBy attribute */

/* Initialise. */
   key = NULL;

/* Check the global error status. */
   if ( !astOK ) return key;

/* Get the SortBy value. */
   sortby = astGetSortBy( this );

/* First deal with unsorted keys. */
   if( sortby == SORTBY_NONE ) {

/* Get the index of the hash table to check first. Also get a pointer to
   the entry within the hash table to check next. */
      if( reset ){
         itab = 0;
         entry = this->table[ 0 ];
      } else {
         itab = this->iter_itab;
         entry = this->iter_entry;
      }

/* Move through elements of the hash table until we have a non-null entry. */
      while( !entry && ++itab < this->mapsize ) {
         entry = this->table[ itab ];
      }

/* Return a pointer to the key. */
      if( entry ) {
         key = entry->key;

/* Move on to the next entry in the unsorted linked list, saving the context
   in the KeyMap structure. */
         this->iter_itab = itab;
         this->iter_entry = entry->next;
      }

/* Now deal with sorted keys. */
   } else {

/* If starting from the beginning, use the "first" entry. Otherwise, use
   the nxt entry. */
      if( reset ) {
         entry = this->first;
      } else {
         entry = this->iter_entry;
      }

/* If we have an entry, return a pointer to its key, and then update the
   context to point to the next entry in the *sorted* list. */
      if( entry ) {
         key = entry->key;
         this->iter_entry = entry->snext;
      }
   }

/* If no more entries were found, reset the context in the KeyMap
   structure. */
   if( ! key ) {
      this->iter_itab = 0;
      this->iter_entry = NULL;
   }

/* Return the result.*/
   return key;
}

static void NewTable( AstKeyMap *this, int size, int *status ){
/*
*  Name:
*     NewTable

*  Purpose:
*     Create a new hash table.

*  Type:
*     Private function.

*  Synopsis:
*     #include "keymap.h"
*     void NewTable( AstKeyMap *this, int size, int *status )

*  Class Membership:
*     KeyMap member function.

*  Description:
*     This function removes any existing hash table and allocates memory
*     for a new one of the specified size (except that the supplied size
*     is modified to be the next higher power of 2). The table is
*     initialised to indicate that it is empty.

*  Parameters:
*     this
*        Pointer to the KeyMap.
*     size
*        The reuqired size of the hash table.
*     status
*        Pointer to the inherited status variable.

*/

/* Local Variables: */
   int i;

/* Check the global error status. */
   if ( !astOK ) return;

/* Ensure the table size is at least MIN_TABLE_SIZE and is a power of 2. */
   if( size <= MIN_TABLE_SIZE ) {
      size = MIN_TABLE_SIZE;
   } else {
      size = (int) ( 0.5 + pow( 2.0, ceil( log( size )/log( 2.0 ) ) ) );
   }

/* Remove any existing entries. */
   for( i = 0; i < this->mapsize; i++ ) FreeTableEntry( this, i, status );

/* Do nothing more if the table size is not changing. */
   if( size != this->mapsize ) {

/* Modify the size of the existing table. */
      this->mapsize = size;
      this->table = astGrow( this->table, size, sizeof( AstMapEntry * ) );
      this->nentry = astGrow( this->nentry, size, sizeof( int ) );

/* Initialise the new table. */
      if( astOK ) {
         for( i = 0; i < size; i++ ) {
            this->table[ i ] = NULL;
            this->nentry[ i ] = 0;
         }
      }
   }
}

static void RemoveFromObjectList( AstKeyMap *this, AstMapEntry *entry,
                                  int *status ){
/*
*  Name:
*     RemoveFromObjectList

*  Purpose:
*     Remove an entry from the linked-list of AST__OBJECTTYPE entries.

*  Type:
*     Private function.

*  Synopsis:
*     #include "keymap.h"
*     void RemoveFromObjectList( AstKeyMap *this, AstMapEntry *entry,
*                                int *status )

*  Class Membership:
*     KeyMap member function.

*  Description:
*     This function removes the supplied MapEntry from the linked list of
*     AST__OBJECTTYPE entries.

*  Parameters:
*     this
*        Pointer to the KeyMap.
*     entry
*        Pointer to the MapEntry to be removed.
*     status
*        Pointer to the inherited status variable.

*/

/* Local Variables: */
   AstMapEntry *a;          /* Previous entry */
   AstMapEntry *b;          /* Next entry */
   Entry0A *scalar;         /* Pointer to a scalar AST__OBJECTTYPE entry */
   Entry1A *vector;         /* Pointer to a vector AST__OBJECTTYPE entry */

/* Check the global error status. */
   if ( !astOK ) return;

/* Do nothing if the entry does not hold AST Object pointers. */
   if( entry->type == AST__OBJECTTYPE ) {

/* Get pointers to the MapEntries before and after the entry being
   removed. At the same time, nullify both pointers in the entry itself. */
      if( entry->nel == 0 ) {
         scalar = (Entry0A *) entry;
         a = scalar->prev;
         b = scalar->next;
         scalar->prev = NULL;
         scalar->next = NULL;
      } else {
         vector = (Entry1A *) entry;
         a = vector->prev;
         b = vector->next;
         vector->prev = NULL;
         vector->next = NULL;
      }

/* Set the forward link in the previous entry. */
      if( a ) {
         if( a->nel == 0 ) {
            scalar = (Entry0A *) a;
            scalar->next = b;
         } else {
            vector = (Entry1A *) a;
            vector->next = b;
         }

/* If we are removing the list head, store the following entry as the new head. */
      } else {
         this->firstA = b;
      }

/* Set the backward link in the next entry. */
      if( b ) {
         if( b->nel == 0 ) {
            scalar = (Entry0A *) b;
            scalar->prev = a;
         } else {
            vector = (Entry1A *) b;
            vector->prev = a;
         }
      }
   }
}

static void RemoveFromSortedList( AstKeyMap *this, AstMapEntry *entry,
                                  int *status ){
/*
*  Name:
*     RemoveFromSortedList

*  Purpose:
*     Remove an entry from the linked-list of sorted KeyMap entries.

*  Type:
*     Private function.

*  Synopsis:
*     #include "keymap.h"
*     void RemoveFromSortedList( AstKeyMap *this, AstMapEntry *entry,
*                                int *status )

*  Class Membership:
*     KeyMap member function.

*  Description:
*     This function removes the supplied MapEntry from the linked list of
*     sorted MapEntries.

*  Parameters:
*     this
*        Pointer to the KeyMap.
*     entry
*        Pointer to the MapEntry to be removed.
*     status
*        Pointer to the inherited status variable.

*/

/* Local Variables: */
   AstMapEntry *next;       /* Next higher MapEntry */
   AstMapEntry *prev;       /* Next lower MapEntry */

/* Check the global error status. */
   if ( !astOK ) return;

/* Get pointers to the entries on either side of the entry to be removed. */
   next = entry->snext;
   prev = entry->sprev;

/* If the entry is not in the sorted list, abort. */
   if( next && prev ) {

/* Connect the previous to the next, bypassing the entry being removed. */
      next->sprev = prev;
      prev->snext = next;

/* NULLify the next and previous entries stored in the entry being
   removed. */
      entry->snext = NULL;
      entry->sprev = NULL;

/* Decrement the number of entries in the sorted list. */
      (this->nsorted)--;

/* If the entry being removed is the first entry, store a pointer to the new
   first entry. */
      if( this->nsorted == 0 ) {
         this->first = NULL;
      } else if( entry == this->first ) {
         this->first = next;
      }
   }
}

static AstMapEntry *RemoveTableEntry( AstKeyMap *this, int itab,
                                      const char *key, int *status ){
/*
*  Name:
*     RemoveTableEntry

*  Purpose:
*     Remove an entry from a linked-list of KeyMap entries.

*  Type:
*     Private function.

*  Synopsis:
*     #include "keymap.h"
*     AstMapEntry *RemoveTableEntry( AstKeyMap *this, int itab,
*                                    const char *key, int *status )

*  Class Membership:
*     KeyMap member function.

*  Description:
*     This function removes any entries with the specified key from the
*     linked-list of entries stored at the specified entry of the hash
*     table. If the supplied key is found in the list, a pointer to the
*     first removed entry is returned. Otherwise, a NULL pointer is returned.

*  Parameters:
*     this
*        Pointer to the KeyMap.
*     itab
*        Index of the hash table element to be searched.
*     key
*        The key string to be searched for. Trailing spaces are ignored.
*     status
*        Pointer to the inherited status variable.

*  Returned Value:
*     Pointer to the removed Entry, or NULL if no matching entry found.

*/

/* Local Variables: */
   AstMapEntry **link;    /* Address to store foward link */
   AstMapEntry *next;     /* Pointer to next Entry to copy */
   AstMapEntry *result;

/* Initialise */
   result = NULL;

/* Check the global error status. */
   if ( !astOK ) return result;

/* The "next" variable holds the address of the next MapEntry to be
   checked. Initialise this to the MapEntry at the head of the linked
   list associated with the supplied element of the hash table. */
   next = this->table[ itab ];

/* The "link" variable holds the address of the location at which the
   pointer to the MapEntry following the removed MapEntry should be stored.
   Initialise this to be the address of the hash table element. */
   link = &( this->table[ itab ] );

/* Loop round until we have checked all entries. */
   while( next && astOK ) {

/* If the key for the current entry macthes the supplied key... */
      if( !KeyCmp( next->key, key ) ) {

/* Remove the MapEntry from the list sorted by key. */
         RemoveFromSortedList( this, next, status );

/* If the entry is of type AST__OBJECTTYPE, remove it from the
   list of AST__OBJECTTYPE entries. */
         RemoveFromObjectList( this, next, status );

/* Store a pointer to the next MapEntry in the list, replacing the
   original pointer to the MapEntry which is being deleted. */
         *link = next->next;

/* Return a pointer to the first matching MapEntry. Free any subsequent
   matching MapEntries.  */
         if( result ) {
            FreeMapEntry( next, status );
         } else {
            result = next;
         }

/* Decrement the number of entries in the linked list. */
         this->nentry[ itab ]--;

/* Set up the next MapEntry to be freed. */
         next = *link;

/* If the key for the current entry does not match the supplied key... */
      } else {

/* Update the address at which to store the pointer to the next MapEntry
   in the list. */
         link = &(next->next);

/* Update the address of the next MapEntry in the list. */
         next = next->next;
      }
   }

/* Return the result */
   return result;
}

static AstMapEntry *SearchTableEntry( AstKeyMap *this, int itab, const char *key, int *status ){
/*
*  Name:
*     SearchTableEntry

*  Purpose:
*     Search an element of a has table for a given key.

*  Type:
*     Private function.

*  Synopsis:
*     #include "keymap.h"
*     AstMapEntry *SearchTableEntry( AstKeyMap *this, int itab, const char *key, int *status )

*  Class Membership:
*     KeyMap member function.

*  Description:
*     This function searches the specified element of the KeyMaps hash table
*     until an element is found which has a key matching the supplied key.
*     The address of this entry is returned. If no suitable entry is found,
*     then NULL is returned.

*  Parameters:
*     this
*        Pointer to the KeyMap.
*     itab
*        The index of the hash table to be searched.
*     key
*        The key string to be searched for. Trailing spaces are ignored.
*     status
*        Pointer to the inherited status variable.

*  Returned Value:
*     The address of the first MapEntry in the linked list which refers
*     to the given key, or NULL if the key is not found.

*/

/* Local Variables: */
   AstMapEntry *next;     /* Pointer to next Entry to check */
   AstMapEntry *result;   /* Returned pointer */

/* Initialise */
   result = NULL;

/* Check the global error status. */
   if ( !astOK ) return result;

/* The "next" variable holds the address of the next MapEntry to be
   checked. Initialise this to the supplied MapEntry. */
   next = this->table[ itab ];

/* Loop round until we have checked all entries. */
   while( next ) {

/* If the key for the current entry matches the supplied key, store the
   MapEntry pointer and break. */
      if( !KeyCmp( next->key, key ) ) {
         result = next;
         break;
      }

/* Update the address of the next MapEntry in the list. */
      next = next->next;

   }

/* Return the result. */
   return result;
}

static void SetAttrib( AstObject *this_object, const char *setting, int *status ) {
/*
*  Name:
*     SetAttrib

*  Purpose:
*     Set an attribute value for a KeyMap.

*  Type:
*     Private function.

*  Synopsis:
*     #include "keymap.h"
*     void SetAttrib( AstObject *this, const char *setting )

*  Class Membership:
*     KeyMap member function (over-rides the astSetAttrib protected
*     method inherited from the Mapping class).

*  Description:
*     This function assigns an attribute value for a KeyMap, the
*     attribute and its value being specified by means of a string of
*     the form:
*
*        "attribute= value "
*
*     Here, "attribute" specifies the attribute name and should be in
*     lower case with no white space present. The value to the right
*     of the "=" should be a suitable textual representation of the
*     value to be assigned and this will be interpreted according to
*     the attribute's data type.  White space surrounding the value is
*     only significant for string attributes.

*  Parameters:
*     this
*        Pointer to the KeyMap.
*     setting
*        Pointer to a null-terminated string specifying the new attribute
*        value.
*/

/* Local Variables: */
   AstKeyMap *this;             /* Pointer to the KeyMap structure */
   int ival;                    /* Attribute value */
   int len;                     /* Length of setting string */
   int nc;                      /* Number of characters read by astSscanf */

/* Check the global error status. */
   if ( !astOK ) return;

/* Obtain a pointer to the KeyMap structure. */
   this = (AstKeyMap *) this_object;

/* Obtain the length of the setting string. */
   len = (int) strlen( setting );

/* Test for each recognised attribute in turn, using "astSscanf" to parse
   the setting string and extract the attribute value (or an offset to
   it in the case of string values). In each case, use the value set
   in "nc" to check that the entire string was matched. Once a value
   has been obtained, use the appropriate method to set it. */

/* SizeGuess. */
/* ---------- */
   if ( nc = 0,
        ( 1 == astSscanf( setting, "sizeguess= %d %n", &ival, &nc ) )
        && ( nc >= len ) ) {
      astSetSizeGuess( this, ival );

/* KeyCase. */
/* --------- */
   } else if ( nc = 0,
        ( 1 == astSscanf( setting, "keycase= %d %n", &ival, &nc ) )
        && ( nc >= len ) ) {
      astSetKeyCase( this, ival );

/* KeyError. */
/* --------- */
   } else if ( nc = 0,
        ( 1 == astSscanf( setting, "keyerror= %d %n", &ival, &nc ) )
        && ( nc >= len ) ) {
      astSetKeyError( this, ival );

/* MapLocked. */
/* --------- */
   } else if ( nc = 0,
        ( 1 == astSscanf( setting, "maplocked= %d %n", &ival, &nc ) )
        && ( nc >= len ) ) {
      astSetMapLocked( this, ival );

/* SortBy. */
/* ------- */
   } else if ( nc = 0,
        ( 0 == astSscanf( setting, "sortby= %n%*s %n", &ival, &nc ) )
        && ( nc >= len ) ) {
      astSetSortBy( this, SortByInt( setting + ival, "astSetAttrib", status ) );

/* If the attribute is still not recognised, pass it on to the parent
   method for further interpretation. */
   } else {
      (*parent_setattrib)( this_object, setting, status );
   }
}

static void SetKeyCase( AstKeyMap *this, int keycase, int *status ) {
/*
*+
*  Name:
*     astSetKeyCase

*  Purpose:
*     Set the value of the KeyCase attribute for a KeyMap.

*  Type:
*     Protected virtual function.

*  Synopsis:
*     #include "keymap.h"
*     void astSetKeyCase( AstKeyMap *this, int keycase )

*  Class Membership:
*     KeyMap method.

*  Description:
*     This function sets a new value for the KeyCase attribute of a
*     KeyMap. It reports an error if the KeyMap contains any entries.

*  Parameters:
*     this
*        Pointer to the KeyMap.
*     keycase
*        The new attribute value.

*-
*/

/* Local Variables: */
   int ok;                    /* Can the KeyCase value be changed? */
   int itab;                  /* Index into hash table */
   int newval;                /* New KeyCase value */

/* Check the global error status. */
   if ( !astOK ) return;

/* Normalise the new value */
   newval = keycase ? 1 : 0;

/* If the KeyCase value is to be changed, see if the KeyMap is empty. */
   ok = 1;
   if( astGetKeyCase( this ) != newval ) {
      for( itab = 0; itab < this->mapsize; itab++ ) {
         if( this->nentry[ itab ] > 0 ) {
            ok = 0;
            break;
         }
      }
   }

/* If not report an error. */
   if( !ok ) {
      astError( AST__NOWRT, "astSetAttrib(KeyMap): Illegal attempt to "
                "change the KeyCase attribute of a non-empty KeyMap." , status);

/* Otherwise, store the new value. */
   } else {
      this->keycase = newval;
   }
}

static void SetKeyError( AstKeyMap *this, int keyerror, int *status ) {
/*
*+
*  Name:
*     astSetKeyError

*  Purpose:
*     Set the value of the KeyError attribute for a KeyMap.

*  Type:
*     Protected virtual function.

*  Synopsis:
*     #include "keymap.h"
*     void astSetKeyError( AstKeyMap *this, int keyerror )

*  Class Membership:
*     KeyMap method.

*  Description:
*     This function sets the value of the KeyError attribute for a
*     KeyMap. It also sets the attribute recursively in any KeyMaps
*     contained within the supplied KeyMap.

*  Parameters:
*     this
*        Pointer to the KeyMap.
*     keyerror
*        The new value for the attribute.
*-
*/

/* Local Variables: */
   AstMapEntry *next;     /* Pointer to next Entry to copy */
   AstObject **obj_list;  /* List of pointers to AST Object entries */
   int i;                 /* Index into hash table */
   int iel;               /* Index of current vector element */
   int nel;               /* Number of elements in vector */

/* Check the global error status. */
   if ( !astOK ) return;

/* Set the KeyError value in the supplied KeyMap. */
   this->keyerror = keyerror ? 1 : 0;

/* Loop round each entry in the hash table. */
   for( i = 0; i < this->mapsize; i++ ) {

/* Get a pointer to the next KeyMap entry. */
      next = this->table[ i ];

/* Loop round all entries in this element of the hash table. */
      while( next && astOK ) {

/* If this entry has an Object data type, see if holds any KeyMaps. */
         if( next->type == AST__OBJECTTYPE ) {

/* Get the number of objects to check, and a pointer to the first. */
            nel = next->nel;
            if( nel == 0 ) {
               obj_list = &( ((Entry0A *)next)->value );
               nel = 1;
            } else {
               obj_list = ((Entry1A *)next)->value;
            }

/* Loop round checking all Objects. */
            for( iel = 0; iel < nel; iel++ ) {

/* If this Object is a KeyMap, set its KeyError attribute. */
               if( astIsAKeyMap( obj_list[ iel ] ) ) {
                  astSetKeyError( (AstKeyMap *) obj_list[ iel ], keyerror );
               }
            }
         }

/* Get a pointer to the next entry. */
         next = next->next;
      }
   }
}

static void SetMapLocked( AstKeyMap *this, int maplocked, int *status ) {
/*
*+
*  Name:
*     astSetMapLocked

*  Purpose:
*     Set the value of the MapLocked attribute for a KeyMap.

*  Type:
*     Protected virtual function.

*  Synopsis:
*     #include "keymap.h"
*     void astSetMapLocked( AstKeyMap *this, int maplocked )

*  Class Membership:
*     KeyMap method.

*  Description:
*     This function sets the value of the MapLocked attribute for a
*     KeyMap. It also sets the attribute recursively in any KeyMaps
*     contained within the supplied KeyMap.

*  Parameters:
*     this
*        Pointer to the KeyMap.
*     maplocked
*        The new value for the attribute.
*-
*/

/* Local Variables: */
   AstMapEntry *next;     /* Pointer to next Entry to copy */
   AstObject **obj_list;  /* List of pointers to AST Object entries */
   int i;                 /* Index into hash table */
   int iel;               /* Index of current vector element */
   int nel;               /* Number of elements in vector */

/* Check the global error status. */
   if ( !astOK ) return;

/* Set the MapLocked value in the supplied KeyMap. */
   this->maplocked = maplocked ? 1 : 0;

/* Loop round each entry in the hash table. */
   for( i = 0; i < this->mapsize; i++ ) {

/* Get a pointer to the next KeyMap entry. */
      next = this->table[ i ];

/* Loop round all entries in this element of the hash table. */
      while( next && astOK ) {

/* If this entry has an Object data type, see if holds any KeyMaps. */
         if( next->type == AST__OBJECTTYPE ) {

/* Get the number of objects to check, and a pointer to the first. */
            nel = next->nel;
            if( nel == 0 ) {
               obj_list = &( ((Entry0A *)next)->value );
               nel = 1;
            } else {
               obj_list = ((Entry1A *)next)->value;
            }

/* Loop round checking all Objects. */
            for( iel = 0; iel < nel; iel++ ) {

/* If this Object is a KeyMap, set its MapLocked attribute. */
               if( astIsAKeyMap( obj_list[ iel ] ) ) {
                  astSetMapLocked( (AstKeyMap *) obj_list[ iel ], maplocked );
               }
            }
         }

/* Get a pointer to the next entry. */
         next = next->next;
      }
   }
}

static void SetSizeGuess( AstKeyMap *this, int sizeguess, int *status ) {
/*
*+
*  Name:
*     astSetSizeGuess

*  Purpose:
*     Set the value of the SizeGuess attribute for a KeyMap.

*  Type:
*     Protected virtual function.

*  Synopsis:
*     #include "keymap.h"
*     void astSetSizeGuess( AstKeyMap *this, int sizeguess )

*  Class Membership:
*     KeyMap method.

*  Description:
*     This function sets a new value for the SizeGuess attribute of a
*     KeyMap. It reports an error if the KeyMap contains any entries.

*  Parameters:
*     this
*        Pointer to the KeyMap.
*     sizeguess
*        The new attribute value.

*-
*/

/* Local Variables: */
   int empty;                 /* Is the KeyMap empty? */
   int itab;                  /* Index into hash table */

/* Check the global error status. */
   if ( !astOK ) return;

/* See if the KeyMap is empty. */
   empty = 1;
   for( itab = 0; itab < this->mapsize; itab++ ) {
      if( this->nentry[ itab ] > 0 ) {
         empty = 0;
         break;
      }
   }

/* If not report an error. */
   if( !empty ) {
      astError( AST__NOWRT, "astSetAttrib(KeyMap): Illegal attempt to "
                "change the SizeGuess attribute of a non-empty KeyMap." , status);

/* Otherwise, store the new value and change the size of the hash
   table. */
   } else {
      this->sizeguess = sizeguess;
      NewTable( this, sizeguess/MAX_ENTRIES_PER_TABLE_ENTRY, status );
   }
}

static void SetSortBy( AstKeyMap *this, int sortby, int *status ) {
/*
*+
*  Name:
*     astSetSortBy

*  Purpose:
*     Set the value of the SortBy attribute for a KeyMap.

*  Type:
*     Protected virtual function.

*  Synopsis:
*     #include "keymap.h"
*     void astSetSortBy( AstKeyMap *this, int sortby )

*  Class Membership:
*     KeyMap method.

*  Description:
*     This function sets the value of the SortBy attribute for a
*     KeyMap.

*  Parameters:
*     this
*        Pointer to the KeyMap.
*     sortby
*        The new value for the attribute.
*-
*/

/* Local Variables: */
   int oldval;            /* The old sortby value */

/* Check the global error status. */
   if ( !astOK ) return;

/* Get the old SortBy value. */
   oldval = astGetSortBy( this );

/* Set the new SortBy value. */
   this->sortby = sortby;

/* If the value has changed, re-sort the keys. */
   if( oldval != sortby ) SortEntries( this, status );

}

static size_t SizeOfEntry( AstMapEntry *entry, int *status ){
/*
*  Name:
*     SizeOfEntry

*  Purpose:
*     Return the size of the supplied MapEntry structure.

*  Type:
*     Private function.

*  Synopsis:
*     #include "keymap.h"
*     size_t SizeOfEntry( AstMapEntry *entry, int *status )

*  Class Membership:
*     KeyMap member function.

*  Description:
*     This function returns the size of the supplied MapEntry structure.

*  Parameters:
*     entry
*        Pointer to the MapEntry.
*     status
*        Pointer to the inherited status variable.

*  Returned Value:
*     The size of the MapEntry structure. This does not include the size
*     of any data for which pointers are stored in the MapEntry structure.

*  Notes:
*     - A value of zero will be returned if this function is invoked
*     with the global error status set, or if it should fail for any
*     reason.
*/

/* Local Variables: */
   size_t result;         /* Returned value */
   int nel;               /* Entry length */
   int type;              /* Data type */

/* Initialise. */
   result = 0;

/* Check the global error status and the supplied pointer. */
   if ( !astOK || !entry ) return result;

/* Get the data type and length of the MapEntry. */
   type = entry->type;
   nel = entry->nel;

/* Deal with each type. */
   if( type == AST__STRINGTYPE ) {
      result = ( nel == 0 ) ? sizeof( Entry0C ) : sizeof( Entry1C );

   } else if( type == AST__OBJECTTYPE ) {
      result = ( nel == 0 ) ? sizeof( Entry0A ) : sizeof( Entry1A );

   } else if( type == AST__INTTYPE ) {
      result = ( nel == 0 ) ? sizeof( Entry0I ) : sizeof( Entry1I );

   } else if( type == AST__POINTERTYPE ) {
      result = ( nel == 0 ) ? sizeof( Entry0P ) : sizeof( Entry1P );

   } else if( type == AST__SINTTYPE ) {
      result = ( nel == 0 ) ? sizeof( Entry0S ) : sizeof( Entry1S );

   } else if( type == AST__KINTTYPE ) {
      result = ( nel == 0 ) ? sizeof( Entry0K ) : sizeof( Entry1K );

   } else if( type == AST__BYTETYPE ) {
      result = ( nel == 0 ) ? sizeof( Entry0B ) : sizeof( Entry1B );

   } else if( type == AST__DOUBLETYPE ) {
      result = ( nel == 0 ) ? sizeof( Entry0D ) : sizeof( Entry1D );

   } else if( type == AST__FLOATTYPE ) {
      result = ( nel == 0 ) ? sizeof( Entry0F ) : sizeof( Entry1F );

   } else if( type == AST__UNDEFTYPE ) {
      result = sizeof( AstMapEntry );

/* Report an error if the data type is unknown. */
   } else {
      astError( AST__INTER, "SizeOfEntry(KeyMap): Illegal map entry data "
                "type %d encountered (internal AST programming error).", status,
                type );
   }

/* Return the result. */
   return result;
}

static int SortByInt( const char *sortby, const char *method, int *status ){
/*
*  Name:
*     SortByInt

*  Purpose:
*     Get the integer associated with a string SortBy value.

*  Type:
*     Private function.

*  Synopsis:
*     #include "keymap.h"
*     int SortByInt( const char *sortby, const char *method, int *status )

*  Class Membership:
*     KeyMap member function.

*  Description:
*     This function returns the integer associated with the supplied
*     string SortBy value.

*  Parameters:
*     sortby
*        Pointer to the string SortBy value (case insensitive).
*     method
*        Pointer to a string holding the name of the calling method for
*        inclusion in error messages.
*     status
*        Pointer to the inherited status variable.

*  Returned Value:
*     The associated SortBy integer.

*/

/* Local Variables: */
   int result;             /* The returned integer */

/* Initialise. */
   result = SORTBY_NONE;

/* Check the global error status. */
   if ( !astOK ) return result;

/* Check each known value. */
   if( astChrMatch( sortby, "None" ) ) {
      result = SORTBY_NONE;

   } else if( astChrMatch( sortby, "AgeUp" ) ) {
      result = SORTBY_AGEUP;

   } else if( astChrMatch( sortby, "AgeDown" ) ) {
      result = SORTBY_AGEDOWN;

   } else if( astChrMatch( sortby, "KeyAgeUp" ) ) {
      result = SORTBY_KEYAGEUP;

   } else if( astChrMatch( sortby, "KeyAgeDown" ) ) {
      result = SORTBY_KEYAGEDOWN;

   } else if( astChrMatch( sortby, "KeyUp" ) ) {
      result = SORTBY_KEYUP;

   } else if( astChrMatch( sortby, "KeyDown" ) ) {
      result = SORTBY_KEYDOWN;

   } else {
      astError( AST__INTER, "%s(KeyMap): Illegal SortBy value %s "
                "encountered.", status, method, sortby );
   }

/* Return the result. */
   return result;
}

static const char *SortByString( int sortby, const char *method, int *status ){
/*
*  Name:
*     SortByString

*  Purpose:
*     Get the string associated with an integer SortBy value.

*  Type:
*     Private function.

*  Synopsis:
*     #include "keymap.h"
*     const char *SortByString( int sortby, const char *method, int *status )

*  Class Membership:
*     KeyMap member function.

*  Description:
*     This function returns the string associated with the supplied
*     integer SortBy value.

*  Parameters:
*     sortby
*        The integer SortBy value.
*     method
*        Pointer to a string holding the name of the calling method for
*        inclusion in error messages.
*     status
*        Pointer to the inherited status variable.

*  Returned Value:
*     Pointer to the associated SortBy string.

*/

/* Local Variables: */
   const char *result;    /* The returned string */

/* Initialise. */
   result = NULL;

/* Check the global error status. */
   if ( !astOK ) return result;

/* Check each value. */
   if( sortby == SORTBY_NONE ) {
      result = "None";

   } else if( sortby == SORTBY_AGEUP ) {
      result = "AgeUp";

   } else if( sortby == SORTBY_AGEDOWN ) {
      result = "AgeDown";

   } else if( sortby == SORTBY_KEYAGEUP ) {
      result = "KeyAgeUp";

   } else if( sortby == SORTBY_KEYAGEDOWN ) {
      result = "KeyAgeDown";

   } else if( sortby == SORTBY_KEYUP ) {
      result = "KeyUp";

   } else if( sortby == SORTBY_KEYDOWN ) {
      result = "KeyDown";

   } else {
      astError( AST__INTER, "%s(KeyMap): Illegal integer SortBy value %d "
                "encountered (internal AST programming error).", status,
                method, sortby );
   }

/* Return the result. */
   return result;
}

static void SortEntries( AstKeyMap *this, int *status ){
/*
*  Name:
*     SortEntries

*  Purpose:
*     Ensure the entries in a KeyMap are sorted correctly.

*  Type:
*     Private function.

*  Synopsis:
*     #include "keymap.h"
*     void SortEntries( AstKeyMap *this, int *status )

*  Class Membership:
*     KeyMap member function.

*  Description:
*     This function sorts all the entries in the supplied KeyMap in
*     the manner indicated by the SortBy attribute value in the KeyMap.
*     A double linked list is maintained indicating the ordering, with
*     the first entry in the sorted list being pointed to by "this->first".
*     Each entry contains "snext" and "sprev" pointers that point to the
*     next and previous entries in the sorted list. The number of entries
*     in the sorted list (which should usually equal the total number of
*     entries currently in the KeyMap), is stored in "this->nsorted".

*  Parameters:
*     this
*        Pointer to the KeyMap.
*     status
*        Pointer to the inherited status variable.

*/

/* Local Variables: */
   AstMapEntry **ents;
   AstMapEntry **pent;
   AstMapEntry **a;
   AstMapEntry **b;
   AstMapEntry *entry;
   int i;
   int nent;
   int sortby;

/* Check the global error status. */
   if ( !astOK ) return;

/* Empty the sorted list. */
   this->nsorted = 0;
   this->first = NULL;

/* Get the SortBy value. */
   sortby = astGetSortBy( this );

/* Do nothing more if no sorting is required. */
   if( sortby != SORTBY_NONE ) {

/* Get the number of entries in the keyMap. */
      nent = astMapSize( this );

/* Only sort if the KeyMap is not empty. */
      if( nent > 0 ) {

/* Allocate an array with one element for each entry. Each element is a
   pointer to a MapEntry structure. */
         ents = astMalloc( sizeof( *ents )*nent );
         if( astOK ) {

/* Loop round all entries in the hash table. */
            pent = ents;
            for( i = 0; i < this->mapsize; i++ ) {

/* Get a pointer to the next KeyMap entry. */
               entry = this->table[ i ];

/* Loop round all entries in this element of the hash table. */
               while( entry ) {

/* Store the sorting method in the MapEntry. */
                  entry->sortby = sortby;

/* Put a pointer to the MapEntry into the array. */
                  *(pent++) = entry;

/* Update the address of the next MapEntry in the source. */
                  entry = entry->next;
               }
            }

/* No need for sorting if there is only one entry. */
            if( nent == 1 ) {
               ents[ 0 ]->snext = ents[ 0 ];
               ents[ 0 ]->sprev = ents[ 0 ];

/* Sort the array of pointers if there is more than one entry... */
            } else {
               qsort( ents, nent, sizeof( *ents ), CompareEntries );

/* Establish the double linked list. */
               a = ents;
               b = ents + 1;
               for( i = 1; i < nent; i++ ) {
                  (*b)->sprev = *a;
                  (*a)->snext = *b;
                  a = b++;
               }

               b = ents;
               (*b)->sprev = *a;
               (*a)->snext = *b;

            }

/* Store a pointer to the first entry in the sorted list. */
            this->first = ents[ 0 ];

/* Store the number of entrie sin the sorted list. */
            this->nsorted = nent;
         }

/* Free resources. */
         ents = astFree( ents );
      }
   }
}

static int TestAttrib( AstObject *this_object, const char *attrib, int *status ) {
/*
*  Name:
*     TestAttrib

*  Purpose:
*     Test if a specified attribute value is set for a KeyMap.

*  Type:
*     Private function.

*  Synopsis:
*     #include "keymap.h"
*     int TestAttrib( AstObject *this, const char *attrib, int *status )

*  Class Membership:
*     KeyMap member function (over-rides the astTestAttrib protected
*     method inherited from the Mapping class).

*  Description:
*     This function returns a boolean result (0 or 1) to indicate whether
*     a value has been set for one of a KeyMap's attributes.

*  Parameters:
*     this
*        Pointer to the KeyMap.
*     attrib
*        Pointer to a null-terminated string specifying the attribute
*        name.  This should be in lower case with no surrounding white
*        space.
*     status
*        Pointer to the inherited status variable.

*  Returned Value:
*     One if a value has been set, otherwise zero.

*  Notes:
*     - A value of zero will be returned if this function is invoked
*     with the global status set, or if it should fail for any reason.
*/

/* Local Variables: */
   AstKeyMap *this;             /* Pointer to the KeyMap structure */
   int result;                   /* Result value to return */

/* Initialise. */
   result = 0;

/* Check the global error status. */
   if ( !astOK ) return result;

/* Obtain a pointer to the KeyMap structure. */
   this = (AstKeyMap *) this_object;

/* Check the attribute name and test the appropriate attribute. */

/* SizeGuess. */
/* ---------- */
   if ( !strcmp( attrib, "sizeguess" ) ) {
      result = astTestSizeGuess( this );

/* KeyCase. */
/* --------- */
   } else if ( !strcmp( attrib, "keycase" ) ) {
      result = astTestKeyCase( this );

/* KeyError. */
/* --------- */
   } else if ( !strcmp( attrib, "keyerror" ) ) {
      result = astTestKeyError( this );

/* MapLocked. */
/* --------- */
   } else if ( !strcmp( attrib, "maplocked" ) ) {
      result = astTestMapLocked( this );

/* SortBy. */
/* ------- */
   } else if ( !strcmp( attrib, "sortby" ) ) {
      result = astTestSortBy( this );

/* If the attribute is still not recognised, pass it on to the parent
   method for further interpretation. */
   } else {
      result = (*parent_testattrib)( this_object, attrib, status );
   }

/* Return the result, */
   return result;
}

static int TestSizeGuess( AstKeyMap *this, int *status ) {
/*
*+
*  Name:
*     astTestSizeGuess

*  Purpose:
*     Test the value of the SizeGuess attribute for a KeyMap.

*  Type:
*     Protected virtual function.

*  Synopsis:
*     #include "keymap.h"
*     int astTestSizeGuess( AstKeyMap *this )

*  Class Membership:
*     KeyMap method.

*  Description:
*     This function returns a non-zero value if the SizeGuess attribute
*     has been set in a KeyMap.

*  Parameters:
*     this
*        Pointer to the KeyMap.

*  Returned Value:
*     Non-zero if the SizeGuess attribute is set.

*  Notes:
*     - A value of zero is returned if this function is invoked with the
*     global error status set.

*-
*/

/* Local Variables: */
   int result;                /* Returned value */

/* Initialise */
   result = 0;

/* Check the global error status. */
   if ( !astOK ) return result;

/* Return non-zero if the attribute is still set to its "not set" value. */
   return ( this->sizeguess != INT_MAX );
}

/* Functions which access class attributes. */
/* ---------------------------------------- */

/*
*att++
*  Name:
*     SizeGuess

*  Purpose:
*     The expected size of the KeyMap.

*  Type:
*     Public attribute.

*  Synopsis:
*     Integer.

*  Description:
*     This is attribute gives an estimate of the number of entries that
*     will be stored in the KeyMap. It is used to tune the internal
*     properties of the KeyMap for speed and efficiency. A larger value
*     will result in faster access at the expense of increased memory
*     requirements. However if the SizeGuess value is much larger than
*     the actual size of the KeyMap, then there will be little, if any,
*     speed gained by making the SizeGuess even larger. The default value
*     is 300.
*
*     The value of this attribute can only be changed if the KeyMap is
*     empty. Its value can be set conveniently when creating the KeyMap.
*     An error will be reported if an attempt is made to set or clear the
*     attribute when the KeyMap contains any entries.

*  Applicability:
*     KeyMap
*        All KeyMaps have this attribute.
*att--
*/

/*
*att++
*  Name:
*     KeyCase

*  Purpose:
*     Are keys case sensitive?

*  Type:
*     Public attribute.

*  Synopsis:
*     Integer (boolean).

*  Description:
*     This attribute is a boolean value which controls how keys are
*     used. If KeyCase is zero, then key strings supplied to any method
*     are automatically converted to upper case before being used. If
*     KeyCase is non-zero (the default), then supplied key strings are
*     used without modification.
*
*     The value of this attribute can only be changed if the KeyMap is
*     empty. Its value can be set conveniently when creating the KeyMap.
*     An error will be reported if an attempt is made to change the
*     attribute value when the KeyMap contains any entries.

*  Applicability:
*     KeyMap
*        All KeyMaps have this attribute.
*     Table
*        The Table class over-rides this attribute by forcing it to zero.
*        That is, keys within a Table are always case insensitive.
*att--
*/
astMAKE_GET(KeyMap,KeyCase,int,1,(this->keycase == -1 ? 1 : this->keycase))
astMAKE_TEST(KeyMap,KeyCase,( this->keycase != -1 ))

/*
*att++
*  Name:
*     KeyError

*  Purpose:
*     Report an error when getting the value of a non-existant KeyMap entry?

*  Type:
*     Public attribute.

*  Synopsis:
*     Integer (boolean).

*  Description:
*     This attribute is a boolean value which controls how the
c     astMapGet...
f     AST_MAPGET...
*     functions behave if the requested key is not found in the KeyMap.
*     If KeyError is zero (the default), then these functions will return
c     zero
f     .FALSE.
*     but no error will be reported. If KeyError is non-zero, then the
*     same values are returned but an error is also reported.

*  Notes:
*     - When setting a new value for KeyError, the supplied value is
*     propagated to any KeyMaps contained within the supplied KeyMap.
*     - When clearing the KeyError attribute, the attribute is also
*     cleared in any KeyMaps contained within the supplied KeyMap.

*  Applicability:
*     KeyMap
*        All KeyMaps have this attribute.
*att--
*/
astMAKE_GET(KeyMap,KeyError,int,0,( ( this->keyerror != -INT_MAX ) ?
                                   this->keyerror : 0 ))
astMAKE_TEST(KeyMap,KeyError,( this->keyerror != -INT_MAX ))

/*
*att++
*  Name:
*     MapLocked

*  Purpose:
*     Prevent new entries being added to a KeyMap?

*  Type:
*     Public attribute.

*  Synopsis:
*     Integer (boolean).

*  Description:
*     If this boolean attribute is set to
c     a non-zero value,
f     .TRUE.,
*     an error will be reported if an attempt is made to add a new entry
*     to the KeyMap. Note, the value associated with any existing entries
*     can still be changed, but no new entries can be stored in the KeyMap.
*     The default value
c     (zero)
f     (.FALSE.)
*     allows new entries to be added to the KeyMap.

*  Notes:
*     - When setting a new value for MapLocked, the supplied value is
*     propagated to any KeyMaps contained within the supplied KeyMap.
*     - When clearing the MapLocked attribute, the attribute is also
*     cleared in any KeyMaps contained within the supplied KeyMap.

*  Applicability:
*     KeyMap
*        All KeyMaps have this attribute.
*att--
*/
astMAKE_GET(KeyMap,MapLocked,int,0,( ( this->maplocked != -INT_MAX ) ?
                                   this->maplocked : 0 ))
astMAKE_TEST(KeyMap,MapLocked,( this->maplocked != -INT_MAX ))

/*
*att++
*  Name:
*     SortBy

*  Purpose:
*     Determines how keys are sorted in a KeyMap.

*  Type:
*     Public attribute.

*  Synopsis:
*     String.

*  Description:
*     This attribute determines the order in which keys are returned by the
c     astMapKey
f     AST_MAPKEY
*     function. It may take the following values (the default is "None"):
*
*     - "None": The keys are returned in an arbitrary order. This is the
*     fastest method as it avoids the need for a sorted list of keys to
*     be maintained and used.
*
*     - "AgeDown": The keys are returned in the order in which values were
*     stored in the KeyMap, with the key for the most recent value being
*     returned last. If the value of an existing entry is changed, it goes
*     to the end of the list.
*
*     - "AgeUp": The keys are returned in the order in which values were
*     stored in the KeyMap, with the key for the most recent value being
*     returned first. If the value of an existing entry is changed, it goes
*     to the top of the list.
*
*     - "KeyAgeDown": The keys are returned in the order in which they
*     were originally stored in the KeyMap, with the most recent key being
*     returned last. If the value of an existing entry is changed, its
*     position in the list does not change.
*
*     - "KeyAgeUp": The keys are returned in the order in which they
*     were originally stored in the KeyMap, with the most recent key being
*     returned first. If the value of an existing entry is changed, its
*     position in the list does not change.
*
*     - "KeyDown": The keys are returned in alphabetical order, with "A..."
*     being returned last.
*
*     - "KeyUp": The keys are returned in alphabetical order, with "A..."
*     being returned first.

*  Notes:
*     - If a new value is assigned to SortBy (or if SortBy is cleared),
*     all entries currently in the KeyMap are re-sorted according to the
*     new SortBy value.

*  Applicability:
*     KeyMap
*        All KeyMaps have this attribute.
*att--
*/
astMAKE_GET(KeyMap,SortBy,int,SORTBY_NONE,( ( this->sortby != -INT_MAX ) ?
                                           this->sortby : SORTBY_NONE ))
astMAKE_TEST(KeyMap,SortBy,( this->sortby != -INT_MAX ))

/* Copy constructor. */
/* ----------------- */
static void Copy( const AstObject *objin, AstObject *objout, int *status ) {
/*
*  Name:
*     Copy

*  Purpose:
*     Copy constructor for KeyMap objects.

*  Type:
*     Private function.

*  Synopsis:
*     void Copy( const AstObject *objin, AstObject *objout, int *status )

*  Description:
*     This function implements the copy constructor for KeyMap objects.

*  Parameters:
*     objin
*        Pointer to the object to be copied.
*     objout
*        Pointer to the object being constructed.
*     status
*        Pointer to the inherited status variable.

*  Returned Value:
*     void

*  Notes:
*     -  This constructor makes a deep copy.
*/

/* Local Variables: */
   AstKeyMap *in;                  /* Pointer to input KeyMap */
   AstKeyMap *out;                 /* Pointer to output KeyMap */
   int i;                       /* Index into hash table */

/* Check the global error status. */
   if ( !astOK ) return;

/* Obtain pointers to the input and output KeyMap structures. */
   in = (AstKeyMap *) objin;
   out = (AstKeyMap *) objout;

/* For safety, first clear any references to the input memory from
   the output KeyMap. */
   out->table = NULL;
   out->nentry = NULL;
   out->first = NULL;
   out->firstA = NULL;

/* Make copies of the table entries. */
   out->table = astMalloc( sizeof( AstMapEntry * )*( out->mapsize ) );
   out->nentry = astMalloc( sizeof( int )*( out->mapsize ) );

   for( i = 0; i < out->mapsize; i++ ) CopyTableEntry( in, out, i, status );

/* Create the required sorted key list in the new KeyMap. */
   SortEntries( out, status );

/* If an error occurred, clean up by freeing all memory allocated above. */
   if ( !astOK ) {
      for( i = 0; i < out->mapsize; i++ ) FreeTableEntry( out, i, status );
      out->table = astFree( out->table );
      out->nentry = astFree( out->nentry );
   }
}

/* Destructor. */
/* ----------- */
static void Delete( AstObject *obj, int *status ) {
/*
*  Name:
*     Delete

*  Purpose:
*     Destructor for KeyMap objects.

*  Type:
*     Private function.

*  Synopsis:
*     void Delete( AstObject *obj, int *status )

*  Description:
*     This function implements the destructor for KeyMap objects.

*  Parameters:
*     obj
*        Pointer to the object to be deleted.
*     status
*        Pointer to the inherited status variable.

*  Returned Value:
*     void

*  Notes:
*     This function attempts to execute even if the global error status is
*     set.
*/

/* Local Variables: */
   AstKeyMap *this;             /* Pointer to the KeyMap structure */
   int i;                    /* Loop count */

/* Obtain a pointer to the KeyMap structure. */
   this = (AstKeyMap *) obj;

/* Free all allocated memory. */
   for( i = 0; i < this->mapsize; i++ ) FreeTableEntry( this, i, status );

/* Free memory used to hold tables. */
   this->table = astFree( this->table );
   this->nentry = astFree( this->nentry );

/* Nullify other pointers. */
   this->first = NULL;
   this->firstA = NULL;
}

/* Dump function. */
/* -------------- */
static void Dump( AstObject *this_object, AstChannel *channel, int *status ) {
/*
*  Name:
*     Dump

*  Purpose:
*     Dump function for KeyMap objects.

*  Type:
*     Private function.

*  Synopsis:
*     void Dump( AstObject *this, AstChannel *channel, int *status )

*  Description:
*     This function implements the Dump function which writes out data
*     for the KeyMap class to an output Channel.

*  Parameters:
*     this
*        Pointer to the KeyMap whose data are being written.
*     channel
*        Pointer to the Channel to which the data are being written.
*     status
*        Pointer to the inherited status variable.
*/

/* Local Variables: */
   AstKeyMap *this;              /* Pointer to the KeyMap structure */
   AstMapEntry *next;            /* Pointer to the next AstMapEntry to dump */
   int i;                        /* Index into hash table */
   int nentry;                   /* Number of entries dumped so far */
   int set;                      /* Is attribute set? */
   int ival;                     /* Attribute value */

/* Check the global error status. */
   if ( !astOK ) return;

/* Obtain a pointer to the KeyMap structure. */
   this = (AstKeyMap *) this_object;

/* Initialise the number of KeyMap entries dumped so far. */
   nentry = 0;

/* SizeGuess. */
/* ---------- */
   set = TestSizeGuess( this, status );
   ival = set ? GetSizeGuess( this, status ) : astGetSizeGuess( this );
   astWriteInt( channel, "SzGss", set, 0, ival, "Guess at KeyMap size" );

/* SortBy. */
/* ------- */
   set = TestSortBy( this, status );
   ival = set ? GetSortBy( this, status ) : astGetSortBy( this );
   astWriteString( channel, "SortBy", set, 0, SortByString( ival, "astDump",
                                                            status ),
                   "Sorting scheme for keys" );

/* KeyCase. */
/* --------- */
   set = TestKeyCase( this, status );
   ival = set ? GetKeyCase( this, status ) : astGetKeyCase( this );
   astWriteInt( channel, "KyCas", set, 0, ival, "Are keys case sensitive?" );

/* KeyError. */
/* --------- */
   set = TestKeyError( this, status );
   ival = set ? GetKeyError( this, status ) : astGetKeyError( this );
   astWriteInt( channel, "KyErr", set, 0, ival, "Report non-existant keys?" );

/* MapLocked. */
/* --------- */
   set = TestMapLocked( this, status );
   ival = set ? GetMapLocked( this, status ) : astGetMapLocked( this );
   astWriteInt( channel, "MpLck", set, 0, ival, "Prevent addition of new entries?" );

/* MapSize. */
/* -------- */
   astWriteInt( channel, "MapSz", 1, 1, this->mapsize, "Size of hash table" );

/* member count. */
   astWriteInt( channel, "MemCnt", 1, 1, this->member_count, "Total member count" );

/* Loop round each entry in the hash table. */
   for( i = 0; i < this->mapsize; i++ ) {

/* Get a pointer to the next KeyMap entry to dump. */
      next = this->table[ i ];

/* Loop round dumping all KeyMap entries in this element of the hash table. */
      while( next && astOK ) {
         DumpEntry( next, channel, ++nentry, status );

/* Get a pointer to the next entry to dump. */
         next = next->next;

      }
   }
}

/* Standard class functions. */
/* ========================= */
/* Implement the astIsAKeyMap and astCheckKeyMap functions using the macros
   defined for this purpose in the "object.h" header file. */
astMAKE_ISA(KeyMap,Object)
astMAKE_CHECK(KeyMap)

AstKeyMap *astKeyMap_( const char *options, int *status, ...) {
/*
*++
*  Name:
c     astKeyMap
f     AST_KEYMAP

*  Purpose:
*     Create a KeyMap.

*  Type:
*     Public function.

*  Synopsis:
c     #include "keymap.h"
c     AstKeyMap *astKeyMap( const char *options, ... )
f     RESULT = AST_KEYMAP( OPTIONS, STATUS )

*  Class Membership:
*     KeyMap constructor.

*  Description:
*     This function creates a new empty KeyMap and optionally initialises its
*     attributes. Entries can then be added to the KeyMap using the
c     astMapPut0<X> and astMapPut1<X> functions.
f     AST_MAPPUT0<X> and AST_MAPPUT1<X> functions.
*
*     The KeyMap class is used to store a set of values with associated keys
*     which identify the values. The keys are strings. These may be case
*     sensitive or insensitive as selected by the KeyCase attribute, and
*     trailing spaces are ignored. The value associated with a key can be
*     integer (signed 4 and 2 byte, or unsigned 1 byte), floating point
*     (single or double precision),
c     void pointer,
*     character string or AST Object pointer. Each
*     value can be a scalar or a one-dimensional vector. A KeyMap is
*     conceptually similar to a Mapping in that a KeyMap transforms an
*     input into an output - the input is the key, and the output is the
*     value associated with the key. However, this is only a conceptual
*     similarity, and it should be noted that the KeyMap class inherits from
*     the Object class rather than the Mapping class. The methods of the
*     Mapping class cannot be used with a KeyMap.

*  Parameters:
c     options
f     OPTIONS = CHARACTER * ( * ) (Given)
c        Pointer to a null-terminated string containing an optional
c        comma-separated list of attribute assignments to be used for
c        initialising the new KeyMap. The syntax used is identical to
c        that for the astSet function and may include "printf" format
c        specifiers identified by "%" symbols in the normal way.
f        A character string containing an optional comma-separated
f        list of attribute assignments to be used for initialising the
f        new KeyMap. The syntax used is identical to that for the
f        AST_SET routine.
c     ...
c        If the "options" string contains "%" format specifiers, then
c        an optional list of additional arguments may follow it in
c        order to supply values to be substituted for these
c        specifiers. The rules for supplying these are identical to
c        those for the astSet function (and for the C "printf"
c        function).
f     STATUS = INTEGER (Given and Returned)
f        The global status.

*  Returned Value:
c     astKeyMap()
f     AST_MAP = INTEGER
*        A pointer to the new KeyMap.

*  Notes:
*     - A null Object pointer (AST__NULL) will be returned if this
c     function is invoked with the AST error status set, or if it
f     function is invoked with STATUS set to an error value, or if it
*     should fail for any reason.

*  Status Handling:
*     The protected interface to this function includes an extra
*     parameter at the end of the parameter list descirbed above. This
*     parameter is a pointer to the integer inherited status
*     variable: "int *status".

*--
*/

/* Local Variables: */
   astDECLARE_GLOBALS            /* Pointer to thread-specific global data */
   AstKeyMap *new;                 /* Pointer to new KeyMap */
   va_list args;                /* Variable argument list */

/* Get a pointer to the thread specific global data structure. */
   astGET_GLOBALS(NULL);

/* Check the global status. */
   if ( !astOK ) return NULL;

/* Initialise the KeyMap, allocating memory and initialising the
   virtual function table as well if necessary. */
   new = astInitKeyMap( NULL, sizeof( AstKeyMap ), !class_init, &class_vtab, "KeyMap" );

/* If successful, note that the virtual function table has been
   initialised. */
   if ( astOK ) {
      class_init = 1;

/* Obtain the variable argument list and pass it along with the options string
   to the astVSet method to initialise the new KeyMap's attributes. */
      va_start( args, status );
      astVSet( new, options, NULL, args );
      va_end( args );

/* If an error occurred, clean up by deleting the new object. */
      if ( !astOK ) new = astDelete( new );
   }

/* Return a pointer to the new KeyMap. */
   return new;
}

AstKeyMap *astKeyMapId_( const char *options, ... ) {
/*
*  Name:
*     astKeyMapId_

*  Purpose:
*     Create a KeyMap.

*  Type:
*     Private function.

*  Synopsis:
*     #include "keymap.h"
*     AstKeyMap *astKeyMapId_( const char *options, ... )

*  Class Membership:
*     KeyMap constructor.

*  Description:
*     This function implements the external (public) interface to the
*     astKeyMap constructor function. It returns an ID value (instead
*     of a true C pointer) to external users, and must be provided
*     because astKeyMap_ has a variable argument list which cannot be
*     encapsulated in a macro (where this conversion would otherwise
*     occur).
*
*     The variable argument list also prevents this function from
*     invoking astKeyMap_ directly, so it must be a re-implementation
*     of it in all respects, except for the final conversion of the
*     result to an ID value.

*  Parameters:
*     As for astKeyMap_.

*  Returned Value:
*     The ID value associated with the new KeyMap.
*/

/* Local Variables: */
   astDECLARE_GLOBALS            /* Pointer to thread-specific global data */
   AstKeyMap *new;                 /* Pointer to new KeyMap */
   va_list args;                /* Variable argument list */

   int *status;                  /* Pointer to inherited status value */

/* Get a pointer to the inherited status value. */
   status = astGetStatusPtr;

/* Get a pointer to the thread specific global data structure. */
   astGET_GLOBALS(NULL);

/* Check the global status. */
   if ( !astOK ) return NULL;

/* Initialise the KeyMap, allocating memory and initialising the
   virtual function table as well if necessary. */
   new = astInitKeyMap( NULL, sizeof( AstKeyMap ), !class_init, &class_vtab, "KeyMap" );

/* If successful, note that the virtual function table has been
   initialised. */
   if ( astOK ) {
      class_init = 1;

/* Obtain the variable argument list and pass it along with the options string
   to the astVSet method to initialise the new KeyMap's attributes. */
      va_start( args, options );
      astVSet( new, options, NULL, args );
      va_end( args );

/* If an error occurred, clean up by deleting the new object. */
      if ( !astOK ) new = astDelete( new );
   }

/* Return an ID value for the new KeyMap. */
   return astMakeId( new );
}

AstKeyMap *astInitKeyMap_( void *mem, size_t size, int init, AstKeyMapVtab *vtab,
                           const char *name, int *status ) {
/*
*+
*  Name:
*     astInitKeyMap

*  Purpose:
*     Initialise a KeyMap.

*  Type:
*     Protected function.

*  Synopsis:
*     #include "keymap.h"
*     AstKeyMap *astInitKeyMap( void *mem, size_t size, int init, AstKeyMapVtab *vtab,
*                               const char *name )

*  Class Membership:
*     KeyMap initialiser.

*  Description:
*     This function is provided for use by class implementations to initialise
*     a new KeyMap object. It allocates memory (if necessary) to accommodate
*     the KeyMap plus any additional data associated with the derived class.
*     It then initialises a KeyMap structure at the start of this memory. If
*     the "init" flag is set, it also initialises the contents of a virtual
*     function table for a KeyMap at the start of the memory passed via the
*     "vtab" parameter.

*  Parameters:
*     mem
*        A pointer to the memory in which the KeyMap is to be created. This
*        must be of sufficient size to accommodate the KeyMap data
*        (sizeof(KeyMap)) plus any data used by the derived class. If a value
*        of NULL is given, this function will allocate the memory itself using
*        the "size" parameter to determine its size.
*     size
*        The amount of memory used by the KeyMap (plus derived class data).
*        This will be used to allocate memory if a value of NULL is given for
*        the "mem" parameter. This value is also stored in the KeyMap
*        structure, so a valid value must be supplied even if not required for
*        allocating memory.
*     init
*        A logical flag indicating if the KeyMap's virtual function table is
*        to be initialised. If this value is non-zero, the virtual function
*        table will be initialised by this function.
*     vtab
*        Pointer to the start of the virtual function table to be associated
*        with the new KeyMap.
*     name
*        Pointer to a constant null-terminated character string which contains
*        the name of the class to which the new object belongs (it is this
*        pointer value that will subsequently be returned by the astClass
*        method).

*  Returned Value:
*     A pointer to the new KeyMap.

*  Notes:
*     -  A NULL pointer will be returned if this function is invoked with the
*     global error status set, or if it should fail for any reason.
*-
*/

/* Local Variables: */
   AstKeyMap *new;              /* Pointer to the new KeyMap */

/* Check the global error status. */
   if ( !astOK ) return NULL;

/* If necessary, initialise the virtual function table. */
   if ( init ) astInitKeyMapVtab( vtab, name );

/* Initialise an Object structure (the parent class) as the first component
   within the KeyMap structure, allocating memory if necessary. */
   new = (AstKeyMap *) astInitObject( mem, size, 0, (AstObjectVtab *) vtab,
                                      name );

   if ( astOK ) {

/* Initialise the KeyMap data. */
/* ---------------------------- */
/* Initialise all attributes to their "undefined" values. */
      new->sizeguess = INT_MAX;
      new->mapsize = 0;
      new->table = NULL;
      new->nentry = NULL;
      new->keycase = -1;
      new->keyerror = -INT_MAX;
      new->maplocked = -INT_MAX;
      new->sortby = -INT_MAX;
      new->first = NULL;
      new->nsorted = 0;
      new->member_count = 0;
      new->firstA = NULL;
      new->iter_itab = 0;
      new->iter_entry = NULL;

      NewTable( new, MIN_TABLE_SIZE, status );

/* If an error occurred, clean up by deleting the new KeyMap. */
      if ( !astOK ) new = astDelete( new );
   }

/* Return a pointer to the new KeyMap. */
   return new;
}

AstKeyMap *astLoadKeyMap_( void *mem, size_t size, AstKeyMapVtab *vtab,
                           const char *name, AstChannel *channel, int *status ) {
/*
*+
*  Name:
*     astLoadKeyMap

*  Purpose:
*     Load a KeyMap.

*  Type:
*     Protected function.

*  Synopsis:
*     #include "keymap.h"
*     AstKeyMap *astLoadKeyMap( void *mem, size_t size, AstKeyMapVtab *vtab,
*                               const char *name, AstChannel *channel )

*  Class Membership:
*     KeyMap loader.

*  Description:
*     This function is provided to load a new KeyMap using data read
*     from a Channel. It first loads the data used by the parent class
*     (which allocates memory if necessary) and then initialises a
*     KeyMap structure in this memory, using data read from the input
*     Channel.
*
*     If the "init" flag is set, it also initialises the contents of a
*     virtual function table for a KeyMap at the start of the memory
*     passed via the "vtab" parameter.


*  Parameters:
*     mem
*        A pointer to the memory into which the KeyMap is to be
*        loaded.  This must be of sufficient size to accommodate the
*        KeyMap data (sizeof(KeyMap)) plus any data used by derived
*        classes. If a value of NULL is given, this function will
*        allocate the memory itself using the "size" parameter to
*        determine its size.
*     size
*        The amount of memory used by the KeyMap (plus derived class
*        data).  This will be used to allocate memory if a value of
*        NULL is given for the "mem" parameter. This value is also
*        stored in the KeyMap structure, so a valid value must be
*        supplied even if not required for allocating memory.
*
*        If the "vtab" parameter is NULL, the "size" value is ignored
*        and sizeof(AstKeyMap) is used instead.
*     vtab
*        Pointer to the start of the virtual function table to be
*        associated with the new KeyMap. If this is NULL, a pointer
*        to the (static) virtual function table for the KeyMap class
*        is used instead.
*     name
*        Pointer to a constant null-terminated character string which
*        contains the name of the class to which the new object
*        belongs (it is this pointer value that will subsequently be
*        returned by the astGetClass method).
*
*        If the "vtab" parameter is NULL, the "name" value is ignored
*        and a pointer to the string "KeyMap" is used instead.

*  Returned Value:
*     A pointer to the new KeyMap.

*  Notes:
*     - A null pointer will be returned if this function is invoked
*     with the global error status set, or if it should fail for any
*     reason.
*-
*/

/* Local Variables: */
   AstKeyMap *new;           /* Pointer to the new KeyMap */
   AstObject **alist;        /* Pointer to vector of entry values */
   AstObject *aval;          /* AST Object value for an entry */
   astDECLARE_GLOBALS        /* Pointer to thread-specific global data */
   char *com;                /* Pointer to comment string for an entry */
   char *key;                /* Pointer to key string for an entry */
   char *sval;               /* String value for an entry */
   char buff[ 30 ];          /* Buffer for key names */
   const char **slist;       /* Pointer to vector of entry values */
   double *dlist;            /* Pointer to vector of entry values */
   double dval;              /* Floating point value for an entry */
   float *flist;             /* Pointer to vector of entry values */
   int *ilist;               /* Pointer to vector of entry values */
   int index;                /* Index of next array element in a vector entry */
   int ival;                 /* Integer value for an entry */
   int mapsize;              /* Size for new hash table */
   int nel;                  /* Vector length */
   int nentry;               /* Number of KeyMap entries read so far */
   int type;                 /* Data type for an entry */
   short int *wlist;         /* Pointer to vector of entry values */
   short int wval;           /* Short int value for an entry */
   int64_t *klist;           /* Pointer to vector of entry values */
   int64_t kval;             /* 64 bit int value for an entry */
   unsigned char *blist;     /* Pointer to vector of entry values */
   unsigned char bval;       /* Byte value for an entry */

/* Get a pointer to the thread specific global data structure. */
   astGET_GLOBALS(channel);

/* Initialise. */
   new = NULL;

/* Check the global error status. */
   if ( !astOK ) return new;

/* If a NULL virtual function table has been supplied, then this is
   the first loader to be invoked for this KeyMap. In this case the
   KeyMap belongs to this class, so supply appropriate values to be
   passed to the parent class loader (and its parent, etc.). */
   if ( !vtab ) {
      size = sizeof( AstKeyMap );
      vtab = &class_vtab;
      name = "KeyMap";

/* If required, initialise the virtual function table for this class. */
      if ( !class_init ) {
         astInitKeyMapVtab( vtab, name );
         class_init = 1;
      }
   }

/* Invoke the parent class loader to load data for all the ancestral
   classes of the current one, returning a pointer to the resulting
   partly-built KeyMap. */
   new = astLoadObject( mem, size, (AstObjectVtab *) vtab, name, channel );

   if ( astOK ) {

/* Inidicate the KeyMap is empty. */
      new->mapsize = 0;
      new->table = NULL;
      new->nentry = NULL;
      new->firstA = NULL;
      new->iter_itab = 0;
      new->iter_entry = NULL;

/* Read input data. */
/* ================ */
/* Request the input Channel to read all the input data appropriate to
   this class into the internal "values list". */
      astReadClassData( channel, "KeyMap" );

/* Now read each individual data item from this list and use it to
   initialise the appropriate instance variable(s) for this class. */

/* SizeGuess. */
/* ---------- */
      new->sizeguess = astReadInt( channel, "szgss", INT_MAX );
      if ( TestSizeGuess( new, status ) ) SetSizeGuess( new, new->sizeguess, status );

/* KeyCase. */
/* --------- */
      new->keycase = astReadInt( channel, "kycas", -INT_MAX );
      if ( TestKeyCase( new, status ) ) SetKeyCase( new, new->keycase, status );

/* KeyError. */
/* --------- */
      new->keyerror = astReadInt( channel, "kyerr", -INT_MAX );
      if ( TestKeyError( new, status ) ) SetKeyError( new, new->keyerror, status );

/* MapLocked. */
/* --------- */
      new->maplocked = astReadInt( channel, "mplck", -INT_MAX );
      if ( TestMapLocked( new, status ) ) SetMapLocked( new, new->maplocked, status );

/* SortBy. */
/* ------- */
      sval = astReadString( channel, "sortby", " " );
      new->sortby = -INT_MAX;
      if( astOK && strcmp( sval, " " ) ) {
         new->sortby = SortByInt( sval, "astRead", status );
      }
      if( TestSortBy( new, status ) ) SetSortBy( new, new->sortby, status );
      sval = astFree( sval );

/* MapSize. */
/* -------- */
      mapsize = astReadInt( channel, "mapsz", MIN_TABLE_SIZE );
      NewTable( new, mapsize, status );

/* Entries... */
/* ---------- */

/* Initialise the index of the next AstMapEntry to be read. */
      nentry = 0;

/* Read Entries until no more are found */
      while( astOK ) {
         nentry++;

/* Get the entry key. */
         (void) sprintf( buff, "key%d", nentry );
         key = astReadString( channel, buff, NULL );

/* We have finished reading entries if no key was found. */
         if( !key ) break;

/* Get the entry comment. */
         (void) sprintf( buff, "com%d", nentry );
         com = astReadString( channel, buff, NULL );

/* Get the entry data type. */
         (void) sprintf( buff, "typ%d", nentry );
         type = astReadInt( channel, buff, AST__BADTYPE );

         if( type == AST__BADTYPE && astOK ) {
            astError( AST__BDFTS, "astLoadKeyMap(%s): No data type code found "
                      "whilst reading a %s.", status, name, name );

         }

/* Get the vector length. */
         (void) sprintf( buff, "nel%d", nentry );
         nel = astReadInt( channel, buff, 0 );

/* Get the entry member number. Set the KeyMap member count to this value
   so that the next entry added to the KeyMap will get this value as its
   member index. */
         (void) sprintf( buff, "mem%d", nentry );
         new->member_count = astReadInt( channel, buff, 0 );

/* First deal with integer entries. */
         if( type == AST__INTTYPE ) {

/* For scalar entries, use "val<nentry>" to get the value then create a new
   entry and add it to the KeyMap. */
            if( nel == 0 ) {
               (void) sprintf( buff, "val%d", nentry );
               ival = astReadInt( channel, buff, 0 );
               MapPut0I( new, key, ival, com, status );

/* If we must have an array of values... */
            } else {

/* Create an array to hold the values. */
               ilist = astMalloc( sizeof(int)*nel );

/* Loop round reading values. */
               for( index = 0; astOK && index < nel; index++ ) {
                  (void) sprintf( buff, "v%d_%d", nentry, index + 1 );
                  ilist[ index ] = astReadInt( channel, buff, 0 );
               }

/* Create the KeyMap entry. */
               MapPut1I( new, key, nel, ilist, com, status );

/* Free resources. */
               ilist = astFree( ilist );
            }

/* Do the same for short int values. */
         } else if( type == AST__SINTTYPE ) {
            if( nel == 0 ) {
               (void) sprintf( buff, "val%d", nentry );
               wval = (short int) astReadInt( channel, buff, 0 );
               MapPut0S( new, key, wval, com, status );
            } else {
               wlist = astMalloc( sizeof(short int)*nel );
               for( index = 0; astOK && index < nel; index++ ) {
                  (void) sprintf( buff, "v%d_%d", nentry, index + 1 );
                  wlist[ index ] = (short int) astReadInt( channel, buff, 0 );
               }
               MapPut1S( new, key, nel, wlist, com, status );
               wlist = astFree( wlist );
            }

/* Do the same for 64 bit int values. */
         } else if( type == AST__KINTTYPE ) {
            if( nel == 0 ) {
               (void) sprintf( buff, "val%d", nentry );
               kval = astReadInt64( channel, buff, 0 );
               MapPut0K( new, key, kval, com, status );
            } else {
               klist = astMalloc( sizeof(int64_t)*nel );
               for( index = 0; astOK && index < nel; index++ ) {
                  (void) sprintf( buff, "v%d_%d", nentry, index + 1 );
                  klist[ index ] = astReadInt64( channel, buff, 0 );
               }
               MapPut1K( new, key, nel, klist, com, status );
               klist = astFree( klist );
            }

/* Do the same for byte values. */
         } else if( type == AST__BYTETYPE ) {
            if( nel == 0 ) {
               (void) sprintf( buff, "val%d", nentry );
               bval = (unsigned char) astReadInt( channel, buff, 0 );
               MapPut0B( new, key, bval, com, status );
            } else {
               blist = astMalloc( sizeof(unsigned char)*nel );
               for( index = 0; astOK && index < nel; index++ ) {
                  (void) sprintf( buff, "v%d_%d", nentry, index + 1 );
                  blist[ index ] = (unsigned char) astReadInt( channel, buff, 0 );
               }
               MapPut1B( new, key, nel, blist, com, status );
               blist = astFree( blist );
            }

/* Do the same for double values. */
         } else if( type == AST__DOUBLETYPE ) {
            if( nel == 0 ) {
               (void) sprintf( buff, "val%d", nentry );
               dval = astReadDouble( channel, buff, AST__BAD );
               MapPut0D( new, key, dval, com, status );
            } else {
               dlist = astMalloc( sizeof(double)*nel );
               for( index = 0; astOK && index < nel; index++ ) {
                  (void) sprintf( buff, "v%d_%d", nentry, index + 1 );
                  dlist[ index ] = astReadDouble( channel, buff, AST__BAD );
               }
               MapPut1D( new, key, nel, dlist, com, status );
               dlist = astFree( dlist );
            }

/* Do the same for float values. */
         } else if( type == AST__FLOATTYPE ) {
            if( nel == 0 ) {
               (void) sprintf( buff, "val%d", nentry );
               dval = astReadDouble( channel, buff, 0.0 );
               MapPut0F( new, key, (float) dval, com, status );
            } else {
               flist = astMalloc( sizeof(float)*nel );
               for( index = 0; astOK && index < nel; index++ ) {
                  (void) sprintf( buff, "v%d_%d", nentry, index + 1 );
                  flist[ index ] = (float) astReadDouble( channel, buff, 0.0 );
               }
               MapPut1F( new, key, nel, flist, com, status );
               flist = astFree( flist );
            }

/* Do the same for string values. */
         } else if( type == AST__STRINGTYPE ) {
            if( nel == 0 ) {
               (void) sprintf( buff, "val%d", nentry );
               sval = astReadString( channel, buff, "" );
               MapPut0C( new, key, sval, com, status );
               sval = astFree( sval );
            } else {
               slist = astMalloc( sizeof(const char *)*nel );
               for( index = 0; astOK && index < nel; index++ ) {
                  (void) sprintf( buff, "v%d_%d", nentry, index + 1 );
                  slist[ index ] = astReadString( channel, buff, "" );
               }
               MapPut1C( new, key, nel, slist, com, status );
               for( index = 0; astOK && index < nel; index++ ) {
                  slist[ index ] = astFree( (void *) slist[ index ] );
               }
               slist = astFree( slist );
            }

/* Do the same for object values. */
         } else if( type == AST__OBJECTTYPE ) {
            if( nel == 0 ) {
               (void) sprintf( buff, "val%d", nentry );
               aval = astReadObject( channel, buff, NULL );
               MapPut0A( new, key, aval, com, status );
               if( aval ) aval = astAnnul( aval );
            } else {
               alist = astMalloc( sizeof(AstObject *)*nel );
               for( index = 0; astOK && index < nel; index++ ) {
                  (void) sprintf( buff, "v%d_%d", nentry, index + 1 );
                  alist[ index ] = astReadObject( channel, buff, NULL );
               }
               MapPut1A( new, key, nel, alist, com, status );
               for( index = 0; astOK && index < nel; index++ ) {
                  if( alist[ index ] ) alist[ index ] = astAnnul( alist[ index ] );
               }
               alist = astFree( alist );
            }

/* Undef values have no value. */
         } else if( type == AST__UNDEFTYPE ) {
            MapPutU( new, key, com, status );

/* Report an error if the data type is unknown. */
         } else if( astOK ) {
            astError( AST__BDFTS, "astLoadKeyMap(%s): Unknown data type code "
                      "(%d) encountered whilst reading a %s.", status, name, type,
                      name );
         }
/* Free resources. */
         key = astFree( key );
         if( com ) com = astFree( com );

      }

/* Set the final member count for the KeyMap. */
      new->member_count = astReadInt( channel, "memcnt", 0 );

/* If an error occurred, clean up by deleting the new KeyMap. */
      if ( !astOK ) new = astDelete( new );
   }

/* Return the new KeyMap pointer. */
   return new;
}

/* Virtual function interfaces. */
/* ============================ */
/* These provide the external interface to the virtual functions defined by
   this class. Each simply checks the global error status and then locates and
   executes the appropriate member function, using the function pointer stored
   in the object's virtual function table (this pointer is located using the
   astMEMBER macro defined in "object.h").

   Note that the member function may not be the one defined here, as it may
   have been over-ridden by a derived class. However, it should still have the
   same interface. */

#define MAKE_MAPPUT0_(X,Xtype) \
void astMapPut0##X##_( AstKeyMap *this, const char *key, Xtype value, \
                      const char *comment, int *status ){ \
   if ( !astOK ) return; \
   (**astMEMBER(this,KeyMap,MapPut0##X))(this,key,value,comment, status ); \
}
MAKE_MAPPUT0_(D,double)
MAKE_MAPPUT0_(F,float)
MAKE_MAPPUT0_(I,int)
MAKE_MAPPUT0_(K,int64_t)
MAKE_MAPPUT0_(C,const char *)
MAKE_MAPPUT0_(A,AstObject *)
MAKE_MAPPUT0_(P,void *)
MAKE_MAPPUT0_(S,short int)
MAKE_MAPPUT0_(B,unsigned char)
#undef MAKE_MAPPUT0_


#define MAKE_MAPPUT1_(X,Xtype) \
void astMapPut1##X##_( AstKeyMap *this, const char *key, int size, \
                       Xtype value[], const char *comment, \
                       int *status ){ \
   if ( !astOK ) return; \
   (**astMEMBER(this,KeyMap,MapPut1##X))(this,key,size,value,comment, status ); \
}
MAKE_MAPPUT1_(S,const short int)
MAKE_MAPPUT1_(B,const unsigned char)
MAKE_MAPPUT1_(D,const double)
MAKE_MAPPUT1_(F,const float)
MAKE_MAPPUT1_(I,const int)
MAKE_MAPPUT1_(K,const int64_t)
MAKE_MAPPUT1_(C,const char *const)
MAKE_MAPPUT1_(A,AstObject *const)
MAKE_MAPPUT1_(P,void *const)
#undef MAKE_MAPPUT1_

#define MAKE_MAPGET0_(X,Xtype) \
int astMapGet0##X##_( AstKeyMap *this, const char *key, Xtype *value, int *status ){ \
   if ( !astOK ) return 0; \
   return (**astMEMBER(this,KeyMap,MapGet0##X))(this,key,value, status ); \
}
MAKE_MAPGET0_(D,double)
MAKE_MAPGET0_(S,short int)
MAKE_MAPGET0_(B,unsigned char)
MAKE_MAPGET0_(F,float)
MAKE_MAPGET0_(I,int)
MAKE_MAPGET0_(K,int64_t)
MAKE_MAPGET0_(C,const char *)
MAKE_MAPGET0_(A,AstObject *)
MAKE_MAPGET0_(P,void *)
#undef MAKE_MAPGET0_


int astMapGetC_( AstKeyMap *this, const char *key, const char **value, int *status ){ \
   if ( !astOK ) return 0; \
   return (**astMEMBER(this,KeyMap,MapGetC))(this,key,value, status ); \
}


#define MAKE_MAPGET1_(X,Xtype) \
int astMapGet1##X##_( AstKeyMap *this, const char *key, int mxval, int *nval, \
                      Xtype *value, int *status ){ \
   if ( !astOK ) return 0; \
   return (**astMEMBER(this,KeyMap,MapGet1##X))(this,key,mxval,nval,value,status); \
}
MAKE_MAPGET1_(B,unsigned char)
MAKE_MAPGET1_(S,short int)
MAKE_MAPGET1_(D,double)
MAKE_MAPGET1_(F,float)
MAKE_MAPGET1_(I,int)
MAKE_MAPGET1_(K,int64_t)
MAKE_MAPGET1_(A,AstObject *)
MAKE_MAPGET1_(P,void *)
#undef MAKE_MAPGET1_

#define MAKE_MAPGETELEM_(X,Xtype) \
int astMapGetElem##X##_( AstKeyMap *this, const char *key, int elem, \
                         Xtype *value, int *status ){ \
   if ( !astOK ) return 0; \
   return (**astMEMBER(this,KeyMap,MapGetElem##X))(this,key,elem,value,status); \
}
MAKE_MAPGETELEM_(B,unsigned char)
MAKE_MAPGETELEM_(S,short int)
MAKE_MAPGETELEM_(D,double)
MAKE_MAPGETELEM_(F,float)
MAKE_MAPGETELEM_(I,int)
MAKE_MAPGETELEM_(K,int64_t)
MAKE_MAPGETELEM_(A,AstObject *)
MAKE_MAPGETELEM_(P,void *)
#undef MAKE_MAPGETELEM_

int astMapGet1C_( AstKeyMap *this, const char *key, int l, int mxval, int *nval,
                  char *value, int *status ){
   if ( !astOK ) return 0;
   return (**astMEMBER(this,KeyMap,MapGet1C))(this,key,l,mxval,nval,value,status);
}

int astMapGetElemC_( AstKeyMap *this, const char *key, int l, int elem,
                     char *value, int *status ){
   if ( !astOK ) return 0;
   return (**astMEMBER(this,KeyMap,MapGetElemC))(this,key,l,elem,value,status);
}

#define MAKE_MAPPUTELEM_(X,Xtype) \
void astMapPutElem##X##_( AstKeyMap *this, const char *key, int elem, \
                         Xtype value, int *status ){ \
   if ( !astOK ) return; \
   (**astMEMBER(this,KeyMap,MapPutElem##X))(this,key,elem,value,status); \
}
MAKE_MAPPUTELEM_(B,unsigned char)
MAKE_MAPPUTELEM_(S,short int)
MAKE_MAPPUTELEM_(D,double)
MAKE_MAPPUTELEM_(F,float)
MAKE_MAPPUTELEM_(I,int)
MAKE_MAPPUTELEM_(K,int64_t)
MAKE_MAPPUTELEM_(A,AstObject *)
MAKE_MAPPUTELEM_(C,const char *)
MAKE_MAPPUTELEM_(P,void *)
#undef MAKE_MAPPUTELEM_

void astMapPutU_( AstKeyMap *this, const char *key, const char *comment, int *status ){
   if ( !astOK ) return;
   (**astMEMBER(this,KeyMap,MapPutU))(this,key,comment,status);
}

void astMapRemove_( AstKeyMap *this, const char *key, int *status ){
   if ( !astOK ) return;
   (**astMEMBER(this,KeyMap,MapRemove))(this,key,status);
}
void astMapRename_( AstKeyMap *this, const char *oldkey, const char *newkey,
                    int *status ){
   if ( !astOK ) return;
   (**astMEMBER(this,KeyMap,MapRename))(this,oldkey,newkey,status);
}
void astMapCopy_( AstKeyMap *this, AstKeyMap *that, int *status ){
   if ( !astOK ) return;
   (**astMEMBER(this,KeyMap,MapCopy))(this,that,status);
}
void astMapCopyEntry_( AstKeyMap *this, const char *key, AstKeyMap *that,
                       int merge, int *status ){
   if ( !astOK ) return;
   (**astMEMBER(this,KeyMap,MapCopyEntry))(this,key,that,merge,status);
}
int astMapDefined_( AstKeyMap *this, const char *key, int *status ){
   if ( !astOK ) return 0;
   return (**astMEMBER(this,KeyMap,MapDefined))(this,key,status);
}
int astMapSize_( AstKeyMap *this, int *status ){
   if ( !astOK ) return 0;
   return (**astMEMBER(this,KeyMap,MapSize))(this,status);
}
int astMapLenC_( AstKeyMap *this, const char *key, int *status ){
   if ( !astOK ) return 0;
   return (**astMEMBER(this,KeyMap,MapLenC))(this,key,status);
}
int astMapLength_( AstKeyMap *this, const char *key, int *status ){
   if ( !astOK ) return 0;
   return (**astMEMBER(this,KeyMap,MapLength))(this,key,status);
}
int astMapType_( AstKeyMap *this, const char *key, int *status ){
   if ( !astOK ) return 0;
   return (**astMEMBER(this,KeyMap,MapType))(this,key,status);
}
int astMapHasKey_( AstKeyMap *this, const char *key, int *status ){
   if ( !astOK ) return 0;
   return (**astMEMBER(this,KeyMap,MapHasKey))(this,key,status);
}
const char *astMapKey_( AstKeyMap *this, int index, int *status ){
   if ( !astOK ) return NULL;
   return (**astMEMBER(this,KeyMap,MapKey))(this,index,status);
}
const char *astMapIterate_( AstKeyMap *this, int reset, int *status ){
   if ( !astOK ) return NULL;
   return (**astMEMBER(this,KeyMap,MapIterate))(this,reset,status);
}
int astGetSizeGuess_( AstKeyMap *this, int *status ){
   if( !astOK ) return 0;
   return (**astMEMBER(this,KeyMap,GetSizeGuess))(this,status);
}
int astTestSizeGuess_( AstKeyMap *this, int *status ){
   if( !astOK ) return 0;
   return (**astMEMBER(this,KeyMap,TestSizeGuess))(this,status);
}
void astClearSizeGuess_( AstKeyMap *this, int *status ){
   if( !astOK ) return;
   (**astMEMBER(this,KeyMap,ClearSizeGuess))(this,status);
}
void astSetSizeGuess_( AstKeyMap *this, int sizeguess, int *status ){
   if( !astOK ) return;
   (**astMEMBER(this,KeyMap,SetSizeGuess))(this,sizeguess,status);
}

void astClearMapLocked_( AstKeyMap *this, int *status ){
   if( !astOK ) return;
   (**astMEMBER(this,KeyMap,ClearMapLocked))(this,status);
}
void astSetMapLocked_( AstKeyMap *this, int maplocked, int *status ){
   if( !astOK ) return;
   (**astMEMBER(this,KeyMap,SetMapLocked))(this,maplocked,status);
}

void astClearKeyError_( AstKeyMap *this, int *status ){
   if( !astOK ) return;
   (**astMEMBER(this,KeyMap,ClearKeyError))(this,status);
}
void astSetKeyError_( AstKeyMap *this, int keyerror, int *status ){
   if( !astOK ) return;
   (**astMEMBER(this,KeyMap,SetKeyError))(this,keyerror,status);
}

void astClearSortBy_( AstKeyMap *this, int *status ){
   if( !astOK ) return;
   (**astMEMBER(this,KeyMap,ClearSortBy))(this,status);
}
void astSetSortBy_( AstKeyMap *this, int sortby, int *status ){
   if( !astOK ) return;
   (**astMEMBER(this,KeyMap,SetSortBy))(this,sortby,status);
}

void astClearKeyCase_( AstKeyMap *this, int *status ){
   if( !astOK ) return;
   (**astMEMBER(this,KeyMap,ClearKeyCase))(this,status);
}
void astSetKeyCase_( AstKeyMap *this, int keycase, int *status ){
   if( !astOK ) return;
   (**astMEMBER(this,KeyMap,SetKeyCase))(this,keycase,status);
}
