upgrade ast 8.7.1

1 files changed, 0 insertions, 5246 deletions

diff --git a/ast/table.c b/ast/table.c
deleted file mode 100644
index 0d283bc..0000000
--- a/ast/table.c
+++ /dev/null
@@ -1,5246 +0,0 @@
-/*
-*class++
-*  Name:
-*     Table
-
-*  Purpose:
-*     A 2-dimensional table of values.
-
-*  Constructor Function:
-c     astTable
-f     AST_TABLE
-
-*  Description:
-*     The Table class is a type of KeyMap that represents a two-dimensional
-*     table of values. The
-c     astMapGet... and astMapPut...
-f     AST_MAPGET... and AST_MAPPUT...
-*     methods provided by the KeyMap class should be used for storing and
-*     retrieving values from individual cells within a Table. Each entry
-*     in the KeyMap represents a single cell of the table and has an
-*     associated key of the form "<COL>(i)" where "<COL>" is the
-*     upper-case name of a table column and "i" is the row index (the
-*     first row is row 1). Keys of this form should always be used when
-*     using KeyMap methods to access entries within a Table.
-*
-*     Columns must be declared using the
-c     astAddColumn
-f     AST_ADDCOLUMN
-*     method before values can be stored within them. This also fixes the
-*     type and shape of the values that may be stored in any cell of the
-*     column. Cells may contain scalar or vector values of any data type
-*     supported by the KeyMap class. Multi-dimensional arrays may also be
-*     stored, but these must be vectorised when storing and retrieving
-*     them within a table cell. All cells within a single column must
-*     have the same type and shape, as specified when the column is added
-*     to the Table.
-*
-*     Tables may have parameters that describe global properties of the
-*     entire table. These are stored as entries in the parent KeyMap and
-*     can be access using the get and set method of the KeyMap class.
-*     However, parameters must be declared using the
-c     astAddParameter
-f     AST_ADDPARAMETER
-*     method before being accessed.
-*
-*     Note - since accessing entries within a KeyMap is a relatively slow
-*     process, it is not recommended to use the Table class to store
-*     very large tables.
-
-*  Inheritance:
-*     The Table class inherits from the KeyMap class.
-
-*  Attributes:
-*     In addition to those attributes common to all KeyMaps, every
-*     Table also has the following attributes:
-*
-*     - ColumnLenC(column): The largest string length of any value in a column
-*     - ColumnLength(column): The number of elements in each value in a column
-*     - ColumnNdim(column): The number of axes spanned by each value in a column
-*     - ColumnType(column): The data type of each value in a column
-*     - ColumnUnit(column): The unit string describing each value in a column
-*     - Ncolumn: The number of columns currently in the Table
-*     - Nrow: The number of rows currently in the Table
-*     - Nparameter: The number of global parameters currently in the Table
-
-*  Functions:
-c     In addition to those functions applicable to all KeyMaps, the
-c     following functions may also be applied to all Tables:
-f     In addition to those routines applicable to all KeyMaps, the
-f     following routines may also be applied to all Tables:
-*
-c     - astAddColumn: Add a new column definition to a Table
-c     - astAddParameter: Add a new global parameter definition to a Table
-c     - astColumnName: Return the name of the column with a given index
-c     - astColumnShape: Return the shape of the values in a named column
-c     - astHasColumn: Checks if a column exists in a Table
-c     - astHasParameter: Checks if a global parameter exists in a Table
-c     - astParameterName: Return the name of the parameter with a given index
-c     - astPurgeRows: Remove all empty rows from a Table
-c     - astRemoveColumn: Remove a column from a Table
-c     - astRemoveParameter: Remove a global parameter from a Table
-c     - astRemoveRow: Remove a row from a Table
-f     - AST_ADDCOLUMN: Add a new column definition to a Table
-f     - AST_ADDPARAMETER: Add a new global parameter definition to a Table
-f     - AST_COLUMNNAME: Return the name of the column with a given index
-f     - AST_COLUMNSHAPE: Return the shape of the values in a named column
-f     - AST_HASCOLUMN: Checks if a column exists in a Table
-f     - AST_HASPARAMETER: Checks if a global parameter exists in a Table
-f     - AST_PARAMETERNAME: Return the name of the parameter with a given index
-f     - AST_PURGEROWS: Remove all empty rows from a Table
-f     - AST_REMOVECOLUMN: Remove a column from a Table
-f     - AST_REMOVEPARAMETER: Remove a global parameter from a Table
-f     - AST_REMOVEROW: Remove a row from a Table
-
-*  Copyright:
-*     Copyright (C) 2010-2011 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: David S. Berry (Starlink)
-
-*  History:
-*     22-NOV-2010 (DSB):
-*        Original version.
-*     13-MAY-2011 (DSB):
-*        Added support for table parameters.
-*     16-NOV-2013 (DSB):
-*        Fix bug in forming keys in GetColumnLenC.
-*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 Table
-
-/* Fixed KeyMap entry names */
-#define LENGTH "Length"
-#define NAME "Name"
-#define NROW "Nrow"
-#define SHAPE "Shape"
-#define SIZE "Size"
-#define TYPE "Type"
-#define UNIT "Unit"
-
-/* A function macro that puts quotes around a value */
-#define STRING(w) #w
-
-/* Include files. */
-/* ============== */
-/* Interface definitions. */
-/* ---------------------- */
-
-#include "globals.h"             /* Thread-safe global data access */
-#include "error.h"               /* Error reporting facilities */
-#include "memory.h"              /* Memory allocation facilities */
-#include "object.h"              /* Base Object class */
-#include "keymap.h"              /* Coordinate keymaps (parent class) */
-#include "channel.h"             /* I/O channels */
-#include "table.h"               /* Interface definition for this class */
-
-
-/* Error code definitions. */
-/* ----------------------- */
-#include "ast_err.h"             /* AST error codes */
-
-/* C header files. */
-/* --------------- */
-#include <ctype.h>
-#include <stdarg.h>
-#include <stddef.h>
-#include <stdio.h>
-#include <string.h>
-
-
-/* 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 const char *(* parent_getattrib)( AstObject *, const char *, int * );
-static void (* parent_setkeycase)( AstKeyMap *, int, int * );
-static void (* parent_clearkeycase)( AstKeyMap *, int * );
-static int (* parent_equal)( AstObject *, AstObject *, int * );
-static int (* parent_getobjsize)( AstObject *, int * );
-static int (* parent_mapget0a)( AstKeyMap *, const char *, AstObject * *, int *);
-static int (* parent_mapget0c)( AstKeyMap *, const char *, const char **, int *);
-static int (* parent_mapget0d)( AstKeyMap *, const char *, double *, int *);
-static int (* parent_mapget0f)( AstKeyMap *, const char *, float *, int *);
-static int (* parent_mapget0i)( AstKeyMap *, const char *, int *, int *);
-static int (* parent_mapget0p)( AstKeyMap *, const char *, void **, int *);
-static int (* parent_mapget0b)( AstKeyMap *, const char *, unsigned char *, int *);
-static int (* parent_mapget0s)( AstKeyMap *, const char *, short int *, int *);
-static int (* parent_mapget1a)( AstKeyMap *, const char *, int, int *, AstObject **, int * );
-static int (* parent_mapget1c)( AstKeyMap *, const char *, int, int, int *, char *, int * );
-static int (* parent_mapget1d)( AstKeyMap *, const char *, int, int *, double *, int * );
-static int (* parent_mapget1f)( AstKeyMap *, const char *, int, int *, float *, int * );
-static int (* parent_mapget1i)( AstKeyMap *, const char *, int, int *, int *, int * );
-static int (* parent_mapget1p)( AstKeyMap *, const char *, int, int *, void **, int * );
-static int (* parent_mapget1s)( AstKeyMap *, const char *, int, int *, short int *, int * );
-static int (* parent_mapget1b)( AstKeyMap *, const char *, int, int *, unsigned char *, int * );
-static int (* parent_mapgetelema)( AstKeyMap *, const char *, int, AstObject **, int * );
-static int (* parent_mapgetelemc)( AstKeyMap *, const char *, int, int, char *, int * );
-static int (* parent_mapgetelemd)( AstKeyMap *, const char *, int, double *, int * );
-static int (* parent_mapgetelemf)( AstKeyMap *, const char *, int, float *, int * );
-static int (* parent_mapgetelemi)( AstKeyMap *, const char *, int, int *, int * );
-static int (* parent_mapgetelemp)( AstKeyMap *, const char *, int, void **, int * );
-static int (* parent_mapgetelems)( AstKeyMap *, const char *, int, short int *, int * );
-static int (* parent_mapgetelemb)( AstKeyMap *, const char *, int, unsigned char *, int * );
-static int (* parent_testattrib)( AstObject *, const char *, int * );
-static void (* parent_clearattrib)( AstObject *, const char *, int * );
-static void (* parent_mapput0a)( AstKeyMap *, const char *, AstObject *, const char *, int *);
-static void (* parent_mapput0c)( AstKeyMap *, const char *, const char *, const char *, int *);
-static void (* parent_mapput0d)( AstKeyMap *, const char *, double, const char *, int *);
-static void (* parent_mapput0f)( AstKeyMap *, const char *, float, const char *, int *);
-static void (* parent_mapput0i)( AstKeyMap *, const char *, int, const char *, int *);
-static void (* parent_mapput0p)( AstKeyMap *, const char *, void *, const char *, int *);
-static void (* parent_mapput0b)( AstKeyMap *, const char *, unsigned char, const char *, int *);
-static void (* parent_mapput0s)( AstKeyMap *, const char *, short int, const char *, int *);
-static void (* parent_mapput1a)( AstKeyMap *, const char *, int, AstObject *const [], const char *, int * );
-static void (* parent_mapput1c)( AstKeyMap *, const char *, int, const char *const [], const char *, int * );
-static void (* parent_mapput1d)( AstKeyMap *, const char *, int, const double *, const char *, int * );
-static void (* parent_mapput1f)( AstKeyMap *, const char *, int, const float *, const char *, int * );
-static void (* parent_mapput1i)( AstKeyMap *, const char *, int, const int *, const char *, int * );
-static void (* parent_mapput1p)( AstKeyMap *, const char *, int, void *const [], const char *, int * );
-static void (* parent_mapput1b)( AstKeyMap *, const char *, int, const unsigned char *, const char *, int * );
-static void (* parent_mapput1s)( AstKeyMap *, const char *, int, const short int *, const char *, int * );
-static void (* parent_mapputelema)( AstKeyMap *, const char *, int, AstObject *, int * );
-static void (* parent_mapputelemc)( AstKeyMap *, const char *, int, const char *, int * );
-static void (* parent_mapputelemd)( AstKeyMap *, const char *, int, double, int * );
-static void (* parent_mapputelemf)( AstKeyMap *, const char *, int, float, int * );
-static void (* parent_mapputelemi)( AstKeyMap *, const char *, int, int, int * );
-static void (* parent_mapputelemp)( AstKeyMap *, const char *, int, void *, int * );
-static void (* parent_mapputelemb)( AstKeyMap *, const char *, int, unsigned char, int * );
-static void (* parent_mapputelems)( AstKeyMap *, const char *, int, short int, int * );
-static void (* parent_mapremove)( AstKeyMap *, const char *, int * );
-static void (* parent_setattrib)( AstObject *, const char *, int * );
-static void (* parent_mapputu)( AstKeyMap *, const char *, 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;
-
-/* Create the function that initialises global data for this module. */
-astMAKE_INITGLOBALS(Table)
-
-/* Define macros for accessing each item of thread specific global data. */
-#define class_init astGLOBAL(Table,Class_Init)
-#define class_vtab astGLOBAL(Table,Class_Vtab)
-#define getattrib_buff astGLOBAL(Table,GetAttrib_Buff)
-
-
-
-/* If thread safety is not needed, declare and initialise globals at static
-   variables. */
-#else
-
-static char getattrib_buff[ 101 ];
-
-/* Define the class virtual function table and its initialisation flag
-   as static variables. */
-static AstTableVtab 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. */
-AstTable *astTableId_( const char *, ... );
-
-/* Prototypes for Private Member Functions. */
-/* ======================================== */
-static AstKeyMap *ColumnProps( AstTable *, int * );
-static AstKeyMap *ParameterProps( AstTable *, int * );
-static const char *ColumnName( AstTable *, int index, int * );
-static const char *ParameterName( AstTable *, int index, int * );
-static const char *GetColumnUnit( AstTable *, const char *, int * );
-static const char *TypeString( int );
-static int Equal( AstObject *, AstObject *, int * );
-static int GetColumnLenC( AstTable *, const char *, int * );
-static int GetColumnLength( AstTable *, const char *, int * );
-static int GetColumnNdim( AstTable *, const char *, int * );
-static int GetColumnType( AstTable *, const char *, int * );
-static int GetNcolumn( AstTable *, int * );
-static int GetNparameter( AstTable *, int * );
-static int GetObjSize( AstObject *, int * );
-static int HasColumn( AstTable *, const char *, int *);
-static int HasParameter( AstTable *, const char *, int *);
-static int MapGet0A( AstKeyMap *, const char *, AstObject **, int * );
-static int MapGet0B( AstKeyMap *, const char *, unsigned char *, int * );
-static int MapGet0C( AstKeyMap *, const char *, const char **, int * );
-static int MapGet0D( AstKeyMap *, const char *, double *, int * );
-static int MapGet0F( AstKeyMap *, const char *, float *, int * );
-static int MapGet0I( AstKeyMap *, const char *, int *, int * );
-static int MapGet0P( AstKeyMap *, const char *, void **, int * );
-static int MapGet0S( AstKeyMap *, const char *, short int *, int * );
-static int MapGet1A( AstKeyMap *, const char *, int, int *, AstObject **, int * );
-static int MapGet1B( AstKeyMap *, const char *, int, int *, unsigned char *, int * );
-static int MapGet1C( AstKeyMap *, const char *, int, int, int *, char *, int * );
-static int MapGet1D( AstKeyMap *, const char *, int, int *, double *, int * );
-static int MapGet1F( AstKeyMap *, const char *, int, int *, float *, int * );
-static int MapGet1I( AstKeyMap *, const char *, int, int *, int *, int * );
-static int MapGet1P( AstKeyMap *, const char *, int, int *, void **, int * );
-static int MapGet1S( AstKeyMap *, const char *, int, int *, short int *, int * );
-static int MapGetElemA( AstKeyMap *, const char *, int, AstObject **, int * );
-static int MapGetElemB( AstKeyMap *, const char *, int, unsigned char *, int * );
-static int MapGetElemC( AstKeyMap *, const char *, int, int, char *, int * );
-static int MapGetElemD( AstKeyMap *, const char *, int, double *, int * );
-static int MapGetElemF( AstKeyMap *, const char *, int, float *, int * );
-static int MapGetElemI( AstKeyMap *, const char *, int, int *, int * );
-static int MapGetElemP( AstKeyMap *, const char *, int, void **, int * );
-static int MapGetElemS( AstKeyMap *, const char *, int, short int *, int * );
-static int ParseKey( AstTable *, const char *, int, char *, int *, AstKeyMap **, const char *, int * );
-static void AddColumn( AstTable *, const char *, int, int, int *, const char *, int * );
-static void AddParameter( AstTable *, const char *, int * );
-static void ColumnShape( AstTable *, const char *, int, int *, int *, int *);
-static void Copy( const AstObject *, AstObject *, int * );
-static void Delete( AstObject *, int * );
-static void Dump( AstObject *, AstChannel *, int * );
-static void MapPut0A( AstKeyMap *, const char *, AstObject *, const char *, int * );
-static void MapPut0B( AstKeyMap *, const char *, unsigned char, 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 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 MapPut0S( AstKeyMap *, const char *, short int, const char *, int * );
-static void MapPut1A( AstKeyMap *, const char *, int, AstObject *const [], const char *, int * );
-static void MapPut1B( AstKeyMap *, const char *, int, const unsigned char *, 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 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 MapPut1S( AstKeyMap *, const char *, int, const short int *, const char *, int * );
-static void MapPutElemA( AstKeyMap *, const char *, int, AstObject *, int * );
-static void MapPutElemB( AstKeyMap *, const char *, int, unsigned char, int * );
-static void MapPutElemC( AstKeyMap *, const char *, int, const char *, int * );
-static void MapPutElemD( AstKeyMap *, const char *, int, double, 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 MapPutElemS( AstKeyMap *, const char *, int, short int, int * );
-static void MapPutU( AstKeyMap *, const char *, const char *, int * );
-static void PurgeRows( AstTable *, int * );
-static void RemoveColumn( AstTable *, const char *, int * );
-static void RemoveParameter( AstTable *, const char *, int * );
-static void RemoveRow( AstTable *, int, int * );
-static void SetKeyCase( AstKeyMap *, int, int * );
-static void ClearKeyCase( AstKeyMap *, int * );
-
-#if defined(THREAD_SAFE)
-static int ManageLock( AstObject *, int, int, AstObject **, int * );
-#endif
-
-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 GetNrow( AstTable *, int * );
-static void SetNrow( AstTable *, int, int * );
-
-static int GetNcolumn( AstTable *, int * );
-static int GetNparameter( AstTable *, int * );
-
-
-/* Member functions. */
-/* ================= */
-static void AddColumn( AstTable *this, const char *name, int type,
-                       int ndim, int *dims, const char *unit, int *status ) {
-/*
-*++
-*  Name:
-c     astAddColumn
-f     AST_ADDCOLUMN
-
-*  Purpose:
-*     Add a new column definition to a table.
-
-*  Type:
-*     Public virtual function.
-
-*  Synopsis:
-c     #include "table.h"
-c     void astAddColumn( AstTable *this, const char *name, int type, int ndim,
-c                        int *dims, const char *unit )
-f     CALL AST_ADDCOLUMN( THIS, NAME, TYPE, NDIM, DIMS, UNIT, STATUS )
-
-*  Class Membership:
-*     Table method.
-
-*  Description:
-*     Adds the definition of a new column to the supplied table. Initially,
-*     the column is empty. Values may be added subsequently using the
-*     methods of the KeyMap class.
-
-*  Parameters:
-c     this
-f     THIS = INTEGER (Given)
-*        Pointer to the Table.
-c     name
-f     NAME = CHARACTER * ( * ) (Given)
-*        The column name. Trailing spaces are ignored (all other spaces
-*        are significant). The supplied string is converted to upper case.
-c     type
-f     TYPE = INTEGER (Given)
-*        The data type associated with the column. See "Applicability:"
-*        below.
-c     ndim
-f     NDIM = INTEGER (Given)
-*        The number of dimensions spanned by the values stored in a single
-*        cell of the column. Zero if the column holds scalar values.
-c     dims
-f     DIMS( NDIM ) = INTEGER (Given)
-*        An array holding the the lengths of each of the axes spanned by
-*        the values stored in a single cell of the column. Ignored if the
-*        column holds scalara values.
-c     unit
-f     UNIT = CHARACTER * ( * ) (Given)
-*        A string specifying the units of the column. Supply a blank
-*        string if the column is unitless.
-f     STATUS = INTEGER (Given and Returned)
-f        The global status.
-
-*  Applicability:
-*     Table
-*        Tables can hold columns with any of the following data types -
-*        AST__INTTYPE (for integer), AST__SINTTYPE (for
-c        short int),
-f        INTEGER*2),
-*        AST__BYTETYPE (for
-c        unsigned bytes - i.e. unsigned chars),
-f        bytes),
-*        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).
-*     FitsTable
-*        FitsTables can hold columns with any of the following data types -
-*        AST__INTTYPE (for integer), AST__SINTTYPE (for
-c        short int),
-f        INTEGER*2),
-*        AST__BYTETYPE (for
-c        unsigned bytes - i.e. unsigned chars),
-f        bytes),
-*        AST__DOUBLETYPE (for double
-*        precision floating point), AST__FLOATTYPE (for single
-*        precision floating point), AST__STRINGTYPE (for character string).
-
-*  Notes:
-*     - This
-c     function
-f     routine
-*     returns without action if a column already exists in the Table
-*     with the supplied name and properties. However an error is
-*     reported if any of the properties differ.
-
-*--
-*/
-
-/* Local Variables: */
-   AstKeyMap *cols;      /* KeyMap holding all column details */
-   AstKeyMap *col_km;    /* KeyMap holding new column details */
-   const char *oldunit;  /* Pointer to the old coumn unit string */
-   int *olddims;         /* Shape of pre-existing column */
-   int idim;             /* Axis index */
-   int namlen;           /* Used length of "name" */
-   int nval;             /* Number of values returned */
-   int oldtype;          /* Data type of pre-existing column */
-
-/* Check the global error status. */
-   if ( !astOK ) return;
-
-/* Verify supplied values. */
-   namlen = astChrLen( name );
-   if( namlen == 0 ) {
-      astError( AST__BADKEY, "astAddColumn(%s): Illegal blank column name "
-               "supplied.", status, astGetClass( this ) );
-
-   } else if( namlen > AST__MXCOLNAMLEN ) {
-      astError( AST__BADKEY, "astAddColumn(%s): Column name '%s' is too "
-               "long (must be no more than %d characters).", status,
-               astGetClass( this ), name, AST__MXCOLNAMLEN );
-
-   } else if( ndim < 0 ) {
-      astError( AST__NAXIN, "astAddColumn(%s): No of axes (%d) for values in "
-               "new column %s is invalid.", status, astGetClass( this ),
-               ndim, name );
-
-   } else if( TypeString( type ) == NULL ) {
-      astError( AST__NAXIN, "astAddColumn(%s): Bad data type supplied (%d) "
-                "for new column %s.", status, astGetClass( this ), type,
-                name );
-
-   } else {
-      for( idim = 0; idim < ndim; idim++ ) {
-         if( dims[ idim ] < 1 ) {
-            astError( AST__DIMIN, "astAddColumn(%s): Length of axis %d (%d) "
-                      "for new column %s is invalid.", status,
-                      astGetClass( this ), idim + 1, dims[ idim ], name );
-            break;
-         }
-      }
-   }
-
-/* If there is already a column with the given name, check its properties
-   match the supplied properties. */
-   if( astOK ) {
-      cols = astColumnProps( this );
-      if( astMapGet0A( cols, name, &col_km ) ) {
-
-         astMapGet0I( col_km, TYPE, &oldtype );
-         if( oldtype != type && astOK ) {
-            astError( AST__OLDCOL, "astAddColumn(%s): A column called "
-                      "%s already exists in the table with a different "
-                      "data type (%s).", status, astGetClass( this ),
-                      name, TypeString( oldtype ) );
-         }
-
-         if( !astMapGet0C( col_km, UNIT, &oldunit ) ) oldunit = "";
-         if( strcmp( oldunit, unit ) && astOK ) {
-            astError( AST__OLDCOL, "astAddColumn(%s): A column called "
-                      "%s already exists in the table with a different "
-                      "unit string ('%s').", status, astGetClass( this ),
-                      name, oldunit );
-         }
-
-         if( ndim != astMapLength( col_km, SHAPE ) && astOK ) {
-            astError( AST__OLDCOL, "astAddColumn(%s): A column called "
-                      "%s already exists in the table with a different "
-                      "number of axes (%d).", status, astGetClass( this ),
-                      name, astMapLength( col_km, SHAPE ) );
-         }
-
-         if( ndim > 0 && astOK ) {
-            olddims = astMalloc( sizeof( int )*ndim );
-            (void) astMapGet1I( col_km, SHAPE, ndim, &nval, olddims );
-            for( idim = 0; idim < ndim && astOK; idim++ ) {
-               if( dims[ idim ] != olddims[ idim ] ) {
-                  astError( AST__OLDCOL, "astAddColumn(%s): A column called "
-                            "%s already exists in the table with a different "
-                            "shape.", status, astGetClass( this ), name );
-               }
-            }
-            olddims = astFree( olddims );
-         }
-
-/* Otherwise, add a new column to the table. */
-      } else {
-
-/* Add a suitable entry describing the column to the Columns KeyMap. */
-         col_km = astKeyMap( " ", status );
-         astMapPut0C( col_km, NAME, name, NULL );
-         astMapPut0I( col_km, TYPE, type, NULL );
-         if( ndim ) astMapPut1I( col_km, SHAPE, ndim, dims, NULL );
-         astMapPut0C( col_km, UNIT, unit, NULL );
-
-/* Put the column KeyMap into the KeyMap holding details of all columns.
-   Use the column name as the key. */
-         astMapPut0A( cols, name, col_km, NULL );
-      }
-
-/* Annul the local KeyMap pointers. */
-      col_km = astAnnul( col_km );
-      cols = astAnnul( cols );
-   }
-}
-
-static void AddParameter( AstTable *this, const char *name, int *status ) {
-/*
-*++
-*  Name:
-c     astAddParameter
-f     AST_ADDPARAMETER
-
-*  Purpose:
-*     Add a new global parameter definition to a table.
-
-*  Type:
-*     Public virtual function.
-
-*  Synopsis:
-c     #include "table.h"
-c     void astAddParameter( AstTable *this, const char *name )
-f     CALL AST_ADDPARAMETER( THIS, NAME, STATUS )
-
-*  Class Membership:
-*     Table method.
-
-*  Description:
-*     Adds the definition of a new global parameter to the supplied
-*     table. Note, this does not store a value for the parameter. To get
-*     or set the parameter value, the methods of the paremt KeyMap class
-*     should be used, using the name of the parameter as the key.
-
-*  Parameters:
-c     this
-f     THIS = INTEGER (Given)
-*        Pointer to the Table.
-c     name
-f     NAME = CHARACTER * ( * ) (Given)
-*        The parameter name. Trailing spaces are ignored (all other spaces
-*        are significant). The supplied string is converted to upper case.
-f     STATUS = INTEGER (Given and Returned)
-f        The global status.
-
-*  Notes:
-*     - Unlike columns, the definition of a parameter does not specify its type,
-*     size or dimensionality.
-
-*--
-*/
-
-/* Local Variables: */
-   AstKeyMap *pars;      /* KeyMap holding all parameter details */
-   int namlen;           /* Used length of "name" */
-
-/* Check the global error status. */
-   if ( !astOK ) return;
-
-/* Verify supplied values. */
-   namlen = astChrLen( name );
-   if( namlen == 0 ) {
-      astError( AST__BADKEY, "astAddParameter(%s): Illegal blank parameter name "
-               "supplied.", status, astGetClass( this ) );
-
-   } else if( namlen > AST__MXCOLNAMLEN ) {
-      astError( AST__BADKEY, "astAddParameter(%s): Parameter name '%s' is too "
-               "long (must be no more than %d characters).", status,
-               astGetClass( this ), name, AST__MXCOLNAMLEN );
-   }
-
-/* Do nothing if there is already a parameter with the given name. */
-   if( astOK ) {
-      pars = astParameterProps( this );
-      if( !astMapHasKey( pars, name ) ) {
-
-/* Add a suitable entry to the Parameters KeyMap. The value is arbitrary
-   and currently unused. */
-         astMapPut0I( pars, name, 1, NULL );
-      }
-
-/* Annul the local KeyMap pointer. */
-      pars = astAnnul( pars );
-   }
-}
-
-static void ClearAttrib( AstObject *this_object, const char *attrib, int *status ) {
-/*
-*  Name:
-*     ClearAttrib
-
-*  Purpose:
-*     Clear an attribute value for a Table.
-
-*  Type:
-*     Private function.
-
-*  Synopsis:
-*     #include "table.h"
-*     void ClearAttrib( AstObject *this, const char *attrib )
-
-*  Class Membership:
-*     Table member function (over-rides the astClearAttrib protected
-*     method inherited from the KeyMap class).
-
-*  Description:
-*     This function clears the value of a specified attribute for a
-*     Table, so that the default value will subsequently be used.
-
-*  Parameters:
-*     this
-*        Pointer to the Table.
-*     attrib
-*        Pointer to a null terminated string specifying the attribute
-*        name.  This should be in lower case with no surrounding white
-*        space.
-*/
-
-/* Local Variables: */
-   AstTable *this;
-   int nc;
-   int len;
-
-/* Check the global error status. */
-   if ( !astOK ) return;
-
-/* Obtain a pointer to the Table structure. */
-   this = (AstTable *) this_object;
-
-/* Get the length of the attribute string. */
-   len = strlen( attrib );
-
-/* Check the attribute name and clear the appropriate attribute. */
-   /* None yet */
-
-/* Define a macro to see if the attribute string matches any of the
-   read-only column attributes of this class. */
-#define MATCH(attr) \
-        ( nc = 0, ( 0 == astSscanf( attrib, attr "(%*s)%n", &nc ) ) && \
-                  ( nc >= len ) )
-
-/* If the name was not recognised, test if it matches any of the
-   read-only attributes of this class. If it does, then report an
-   error. */
-   if ( !strcmp( attrib, "nrow" ) ||
-        !strcmp( attrib, "ncolumn" ) ||
-        !strcmp( attrib, "nparameter" ) ||
-        MATCH( "columnlenc" ) ||
-        MATCH( "columnlength" ) ||
-        MATCH( "columnndim" ) ||
-        MATCH( "columntype" ) ||
-        MATCH( "columnunit" ) ) {
-      astError( AST__NOWRT, "astClear: Invalid attempt to clear the \"%s\" "
-                "value for a %s.", status, attrib, astGetClass( this ) );
-      astError( AST__NOWRT, "This is a read-only attribute." , status);
-
-/* If the attribute is still not recognised, pass it on to the parent
-   method for further interpretation. */
-   } else {
-      (*parent_clearattrib)( this_object, attrib, status );
-   }
-
-#undef MATCH
-
-}
-
-static void ClearKeyCase( AstKeyMap *this, int *status ) {
-/*
-*  Name:
-*     ClearKeyCase
-
-*  Purpose:
-*     Clear the KeyCase attribute value for a Table.
-
-*  Type:
-*     Private function.
-
-*  Synopsis:
-*     #include "keymape.h"
-*     void ClearKeyCase( AstKeyMap *this, int *status )
-
-*  Class Membership:
-*     Table member function (over-rides the astClearKeyCase protected
-*     method inherited from the KeyMap class).
-
-*  Description:
-*     This function clears the value of the KeyCase attribute for a
-*     Table. For a Table, the KeyCase attribute cannot be changed so this
-*     function exits without action.
-
-*  Parameters:
-*     this
-*        Pointer to the Table.
-*/
-
-}
-
-static const char *ColumnName( AstTable *this, int index, int *status ) {
-/*
-*++
-*  Name:
-c     astColumnName
-f     AST_COLUMNNAME
-
-*  Purpose:
-*     Get the name of the column at a given index within the Table.
-
-*  Type:
-*     Public virtual function.
-
-*  Synopsis:
-c     #include "table.h"
-c     const char *astColumnName( AstTable *this, int index )
-f     RESULT = AST_COLUMNNAME( THIS, INDEX, STATUS )
-
-*  Class Membership:
-*     Table method.
-
-*  Description:
-*     This function returns a string holding the name of the column with
-*     the given index within the Table.
-*
-*     This function is intended primarily as a means of iterating round all
-*     the columns in a Table. For this purpose, the number of columns in
-*     the Table is given by the Ncolumn attribute of the Table. This function
-*     could then be called in a loop, with the index value going from
-c     zero to one less than Ncolumn.
-f     one to Ncolumn.
-*
-*     Note, the index associated with a column decreases monotonically with
-*     the age of the column: the oldest Column in the Table will have index
-*     one, and the Column added most recently to the Table will have the
-*     largest index.
-
-*  Parameters:
-c     this
-f     THIS = INTEGER (Given)
-*        Pointer to the Table.
-c     index
-f     INDEX = INTEGER (Given)
-*        The index into the list of columns. The first column has index
-*        one, and the last has index "Ncolumn".
-f     STATUS = INTEGER (Given and Returned)
-f        The global status.
-
-*  Returned Value:
-c     astColumnName()
-c        A pointer to a null-terminated string containing the
-f     AST_COLUMNNAME = CHARACTER * ( AST__SZCHR )
-f        The
-*        upper case column name.
-
-*  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: */
-   AstKeyMap *cols;        /* KeyMap holding column definitions */
-   const char *result;
-
-/* Check the global error status. */
-   if ( !astOK ) return NULL;
-
-/* Get apointer to the KeyMap holding all column definitions. */
-   cols = astColumnProps( this );
-
-/* Issue a more useful error message than that issued by astMapKey if the
-   index is invalid. */
-   if( index < 1 || index > astMapSize( cols ) ) {
-      astError( AST__MPIND, "astColumnName(%s): Cannot find column "
-                "%d (zero-based) of the %s - invalid index.", status,
-                astGetClass( this ), index, astGetClass( this ) );
-   }
-
-/* Get the column name. */
-   result = astMapKey( cols, index - 1 );
-
-/* Free resources. */
-   cols = astAnnul( cols );
-
-/* Return a pointer to the required column name. */
-   return result;
-}
-
-static AstKeyMap *ColumnProps( AstTable *this, int *status ) {
-/*
-*+
-*  Name:
-*     astColumnProps
-
-*  Purpose:
-*     Returns a pointer to the KeyMap holding column properties.
-
-*  Type:
-*     Protected virtual function.
-
-*  Synopsis:
-*     #include "table.h"
-*     AstKeyMap *astColumnProps( AstTable *this )
-
-*  Class Membership:
-*     Table method.
-
-*  Description:
-*     This function returns a pointer to the KeyMap that holds
-*     definitions of all the coumns added to the Table.
-
-*  Parameters:
-*     this
-*        Pointer to the Table.
-
-*  Returned Value:
-*        A pointer to the KeyMap. It shpould be annulled using astAnnul
-*        when no longer needed.
-
-*-
-*/
-
-/* Check the global error status. */
-   if ( !astOK ) return NULL;
-
-/* Return a cloned pointer to the required KeyMap. */
-   return astClone( this->columns );
-}
-
-static void ColumnShape( AstTable *this, const char *column, int mxdim,
-                         int *ndim, int *dims, int *status ){
-/*
-*++
-*  Name:
-c     astColumnShape
-f     AST_COLUMNSHAPE
-
-*  Purpose:
-*     Returns the shape of the values in a named column.
-
-*  Type:
-*     Public virtual function.
-
-*  Synopsis:
-c     #include "table.h"
-c     void astColumnShape( AstTable *this, const char *column, int mxdim,
-c                          int *ndim, int *dims )
-f     CALL AST_COLUMNSHAPE( THIS, COLUMN, MXDIM, NDIM, DIMS, STATUS )
-
-*  Class Membership:
-*     Table method.
-
-*  Description:
-c     This function
-f     This routine
-*     returns the number of dimensions spaned by each value in a named
-*     column of a Table, together with the length of each dimension.
-*     These are the values supplied when the column was created using
-c     astAddColumn.
-f     AST_ADDCOLUMN.
-
-*  Parameters:
-c     this
-f     THIS = INTEGER (Given)
-*        Pointer to the Table.
-c     column
-f     COLUMN = CHARACTER * ( * ) (Given)
-*        The character string holding the upper case name of the column. Trailing
-*        spaces are ignored.
-c     mxdim
-f     MXDIM = INTEGER (Given)
-*        The length of the
-c        "dims" array.
-f        DIMS array.
-c     ndim
-f     NDIM = INTEGER (Returned)
-c        Pointer to an int in which to return the
-f        The
-*        number of dimensions spanned by values in the named column.
-*        This will be zero if the column contains scalar values.
-c     dims
-f     DIMS( MXDIM ) = INTEGER (Returned)
-c        Pointer to an
-f        An
-*        array in which to return the length of each dimension. Any
-*        excess trailing elements will be filled with the value 1.
-f     STATUS = INTEGER (Given and Returned)
-f        The global status.
-
-*  Notes:
-*     - No error is reported if the requested column cannot be found in the
-*     given Table. A value of zero is returned for
-c     "ndim" and the supplied values in "dims"
-f     NDIM and the supplied values in DIMS
-*     are left unchanged.
-*     - A value of zero is returned for
-c     "ndim"
-f     NDIM
-*     if an error occurs.
-
-*--
-*/
-
-/* Local Variables: */
-   AstKeyMap *cols;        /* Pointer to KeyMap holding all column info */
-   AstKeyMap *col_km;      /* Pointer to KeyMap holding requested column info */
-   int idim;               /* Axis index */
-
-/* Initialise */
-   *ndim = 0;
-
-/* Check the inherited status. */
-   if( !astOK ) return;
-
-
-/* Get the KeyMap holding information about the requested column. */
-   cols = astColumnProps( this );
-   if( astMapGet0A( cols, column, &col_km ) ) {
-
-/* Get the shape of the column values. */
-      (void) astMapGet1I( col_km, SHAPE, mxdim, ndim, dims );
-
-/* Fill excess array elements with 1. */
-      for( idim = *ndim; idim < mxdim; idim++ ) dims[ idim ] = 1;
-
-/* Free resources. */
-      col_km = astAnnul( col_km );
-   }
-   cols = astAnnul( cols );
-
-/* If an error has occurred, set ndim to zero. */
-   if( !astOK ) *ndim = 0;
-
-}
-
-static int Equal( AstObject *this_object, AstObject *that_object, int *status ) {
-/*
-*  Name:
-*     Equal
-
-*  Purpose:
-*     Test if two Tables are equivalent.
-
-*  Type:
-*     Private function.
-
-*  Synopsis:
-*     #include "table.h"
-*     int Equal( AstObject *this, AstObject *that, int *status )
-
-*  Class Membership:
-*     Table member function (over-rides the astEqual protected
-*     method inherited from the astKeyMap class).
-
-*  Description:
-*     This function returns a boolean result (0 or 1) to indicate whether
-*     two Tables are equivalent.
-
-*  Parameters:
-*     this
-*        Pointer to the first Object (a Table).
-*     that
-*        Pointer to the second Object.
-*     status
-*        Pointer to the inherited status variable.
-
-*  Returned Value:
-*     One if the Tables are equivalent, zero otherwise.
-
-*  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_km;
-   AstKeyMap *that_km;
-   AstTable *that;
-   AstTable *this;
-   int result;
-
-/* Initialise. */
-   result = 0;
-
-/* Check the global error status. */
-   if ( !astOK ) return result;
-
-/* Obtain pointers to the two Table structures. */
-   this = (AstTable *) this_object;
-   that = (AstTable *) that_object;
-
-/* Check the second object is a Table. We know the first is a
-   Table since we have arrived at this implementation of the virtual
-   function. */
-   if( astIsATable( that ) ) {
-
-/* Check the Tables are equal when compared as KeyMaps. */
-      if( (*parent_equal)( this_object, that_object, status ) ) {
-
-/* Check the Columns KeyMaps are equal.  */
-         this_km = astColumnProps( this );
-         that_km = astColumnProps( that );
-         result = astEqual( this_km, that_km );
-         this_km = astAnnul( this_km );
-         that_km = astAnnul( that_km );
-
-/* Check the Parameter KeyMaps are equal.  */
-         this_km = astParameterProps( this );
-         that_km = astParameterProps( that );
-         result = astEqual( this_km, that_km );
-         this_km = astAnnul( this_km );
-         that_km = astAnnul( that_km );
-      }
-   }
-
-/* If an error occurred, clear the result value. */
-   if ( !astOK ) result = 0;
-
-/* Return the result, */
-   return result;
-}
-
-static const char *GetAttrib( AstObject *this_object, const char *attrib, int *status ) {
-/*
-*  Name:
-*     GetAttrib
-
-*  Purpose:
-*     Get the value of a specified attribute for a Table.
-
-*  Type:
-*     Private function.
-
-*  Synopsis:
-*     #include "table.h"
-*     const char *GetAttrib( AstObject *this, const char *attrib, int *status )
-
-*  Class Membership:
-*     Table member function (over-rides the protected astGetAttrib
-*     method inherited from the KeyMap class).
-
-*  Description:
-*     This function returns a pointer to the value of a specified
-*     attribute for a Table, formatted as a character string.
-
-*  Parameters:
-*     this
-*        Pointer to the Table.
-*     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 Table, 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 Table. 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            /* Pointer to thread-specific global data */
-   char cname[ AST__MXCOLNAMLEN + 1 ]; /* Column name */
-   AstTable *this;               /* Pointer to the Table structure */
-   const char *result;           /* Pointer value to return */
-   int ival;                     /* Int attribute value */
-   int len;                      /* Length of attrib string */
-   int nc;                       /* No. characters read by astSscanf */
-
-/* Initialise. */
-   result = NULL;
-
-/* Check the global error status. */
-   if ( !astOK ) return result;
-
-/* Get a pointer to the thread specific global data structure. */
-   astGET_GLOBALS(this_object);
-
-/* Obtain a pointer to the Table structure. */
-   this = (AstTable *) this_object;
-
-/* Obtain the length of the attrib string. */
-   len = strlen( attrib );
-
-/* 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. */
-
-/* Table properties */
-/* ================ */
-
-/* Ncolumn */
-/* ------- */
-   if( !strcmp( attrib, "ncolumn" ) ) {
-      ival = astGetNcolumn( this );
-      if ( astOK ) {
-         (void) sprintf( getattrib_buff, "%d", ival );
-         result = getattrib_buff;
-      }
-
-/* Nrow */
-/* ---- */
-   } else if( !strcmp( attrib, "nrow" ) ) {
-      ival = astGetNrow( this );
-      if ( astOK ) {
-         (void) sprintf( getattrib_buff, "%d", ival );
-         result = getattrib_buff;
-      }
-
-/* Nparameter */
-/* ---------- */
-   } else if( !strcmp( attrib, "nparameter" ) ) {
-      ival = astGetNparameter( this );
-      if ( astOK ) {
-         (void) sprintf( getattrib_buff, "%d", ival );
-         result = getattrib_buff;
-      }
-
-
-
-/* Column properties */
-/* ================= */
-
-/* A macro that gives the scannf pattern to test for a given column
-   property. Needed since the buffer length is defined by a macro
-   (AST__MXCOLNAMLEN). */
-#define PATTERN(cnam,blen) #cnam "(%" STRING(blen) "[^()])%n"
-
-/* ColumnNdim */
-   } else if ( nc = 0,
-             ( 1 == astSscanf( attrib, PATTERN(columnndim,AST__MXCOLNAMLEN),
-                               cname, &nc ) ) && ( nc >= len ) ) {
-      ival = astGetColumnNdim( this, cname );
-      if ( astOK ) {
-         (void) sprintf( getattrib_buff, "%d", ival );
-         result = getattrib_buff;
-      }
-
-/* ColumnLenC */
-   } else if ( nc = 0,
-             ( 1 == astSscanf( attrib, PATTERN(columnlenc,AST__MXCOLNAMLEN),
-                               cname, &nc ) ) && ( nc >= len ) ) {
-      ival = astGetColumnLenC( this, cname );
-      if ( astOK ) {
-         (void) sprintf( getattrib_buff, "%d", ival );
-         result = getattrib_buff;
-      }
-
-/* ColumnType */
-   } else if ( nc = 0,
-             ( 1 == astSscanf( attrib, PATTERN(columntype,AST__MXCOLNAMLEN),
-                               cname, &nc ) ) && ( nc >= len ) ) {
-      ival = astGetColumnType( this, cname );
-      if ( astOK ) {
-         (void) sprintf( getattrib_buff, "%d", ival );
-         result = getattrib_buff;
-      }
-
-/* ColumnLength */
-   } else if ( nc = 0,
-             ( 1 == astSscanf( attrib, PATTERN(columnlength,AST__MXCOLNAMLEN),
-                               cname, &nc ) ) && ( nc >= len ) ) {
-      ival = astGetColumnLength( this, cname );
-      if ( astOK ) {
-         (void) sprintf( getattrib_buff, "%d", ival );
-         result = getattrib_buff;
-      }
-
-/* ColumnUnit */
-   } else if ( nc = 0,
-             ( 1 == astSscanf( attrib, PATTERN(columnunit,AST__MXCOLNAMLEN),
-                               cname, &nc ) ) && ( nc >= len ) ) {
-      result = astGetColumnUnit( this, cname );
-
-#undef PATTERN
-
-
-/* Unknown attributes */
-/* ================== */
-
-/* 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 int GetColumnLenC( AstTable *this, const char *column, int *status ) {
-/*
-*+
-*  Name:
-*     astGetColumnLenC
-
-*  Purpose:
-*     Get the maximum formatted length of any value in a column.
-
-*  Type:
-*     Protected virtual function.
-
-*  Synopsis:
-*     #include "table.h"
-*     int astGetColumnLenC( AstTable *this, const char *column )
-
-*  Class Membership:
-*     Table method.
-
-*  Description:
-*     This function returns the minimum length which a character variable
-*     must have in order to be able to store the longest value currently
-*     present (at any row) in a specified column of the supplied Table. If
-*     the named column holds vector values, then the returned value is
-*     the length of the longest element of the vector value.
-
-*  Parameters:
-*     this
-*        Pointer to the Table.
-*     column
-*        The character string holding the upper-case name of the column.
-*        Trailing spaces are ignored. An error is reported if the supplied
-*        column is not found in the Table.
-
-*  Returned Value:
-*     The length (i.e. number of characters) of the longest formatted
-*     value associated with the named column. This does not include the
-*     trailing null character.
-
-*  Notes:
-*     - Automatic data type conversion occurs if the named column holds
-*     numerical values.
-*     - An error will be reported if named column does not exist or 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: */
-   AstKeyMap *cols;        /* KeyMap holding column definitions */
-   char key[ AST__MXCOLKEYLEN ]; /* Current cell key string */
-   int irow;               /* Current row index */
-   int len;                /* Length needed to format current cell */
-   int nrow;               /* Number of rows in table */
-   int result;             /* Returned value */
-
-/* Initialise */
-   result = 0;
-
-/* Check the global error status. */
-   if ( !astOK ) return result;
-
-/* Get the KeyMap holding information about all columns. */
-   cols = astColumnProps( this );
-
-/* Check the table contains the requested column. */
-   if( astMapHasKey( cols, column ) ) {
-
-/* Loop round all rows in the table. */
-      nrow = astGetNrow( this );
-      for( irow = 1; irow <= nrow; irow++ ) {
-
-/* Format the cell name. */
-         sprintf( key, "%.*s(%d)", (int) astChrLen(column), column, irow );
-
-/* Get the maximum length needed to format a string in the current
-   row/column. */
-         len = astMapLenC( this, key );
-
-/* Return the largest value found for any row. */
-         if( len > result ) result = len;
-      }
-
-/* Report an error if the column does not exist. */
-   } else if( astOK ) {
-      astError( AST__BADCOL, "astGetColumnLenC(%s): No column named '%s' "
-                "exists in the table.", status, astGetClass( this ), column );
-   }
-
-/* Free resources */
-   cols = astAnnul( cols );
-
-/* Return AST__BADTYPE if an error occurred. */
-   if( !astOK ) result = 0;
-
-/* Return the result. */
-   return result;
-}
-
-static int GetColumnLength( AstTable *this, const char *column, int *status ) {
-/*
-*+
-*  Name:
-*     astGetColumnLength
-
-*  Purpose:
-*     Get the number of elements in each value in a column.
-
-*  Type:
-*     Protected virtual function.
-
-*  Synopsis:
-*     #include "table.h"
-*     int astGetColumnLength( AstTable *this, const char *column )
-
-*  Class Membership:
-*     Table method.
-
-*  Description:
-*     This function returns the number of elements in each value stored
-*     in a named column. Each value can be a scalar (in which case the
-*     ColumnLength attribute has a value of 1), or a multi-dimensional
-*     array ( in which case the ColumnLength value is equal to the
-*     product of the array dimensions).
-
-*  Parameters:
-*     this
-*        Pointer to the Table.
-*     column
-*        The character string holding the upper-case name of the column.
-*        Trailing spaces are ignored. An error is reported if the supplied
-*        column is not found in the Table.
-
-*  Returned Value:
-*     The number of elements in each column value.
-
-*  Notes:
-*     - An error will be reported if named column does not exist or 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: */
-   AstKeyMap *col_km;      /* KeyMap holding requested column definition */
-   AstKeyMap *cols;        /* KeyMap holding all column definitions */
-   int *dims;              /* Pointer to array holding dimensions */
-   int idim;               /* Index of dimension */
-   int ndim;               /* Number of dimensions */
-   int result;             /* Returned value */
-
-/* Initialise */
-   result = 0;
-
-/* Check the global error status. */
-   if ( !astOK ) return result;
-
-/* Get the KeyMap holding information about all columns. */
-   cols = astColumnProps( this );
-
-/* Get the KeyMap holding information about the requested column. */
-   if( astMapGet0A( cols, column, &col_km ) ) {
-
-/* If the Column properties includes the length, return it. Otherwise,
-   calculate the length and store it in the KeyMap as a column property. */
-      if( ! astMapGet0I( col_km, LENGTH, &result ) ) {
-
-/* Get the number of axes spanned by each column value, and allocate an
-   array big enough to hold the dimensions of these axes. */
-         ndim = astMapLength( col_km, SHAPE );
-         dims = astMalloc( sizeof( int )*ndim );
-         if( astOK ) {
-
-/* Get the dimensions. */
-            astMapGet1I( col_km, SHAPE, ndim, &ndim, dims );
-
-/* Find the number of elements. */
-            result = 1;
-            for( idim = 0; idim < ndim; idim++ ) {
-               result *= dims[ idim ];
-            }
-
-/* Store the result in the column KeyMap. */
-            astMapPut0I( col_km, LENGTH, result, NULL );
-         }
-         dims = astFree( dims );
-      }
-
-/* Free resources */
-      col_km = astAnnul( col_km );
-
-/* Report an error if the column does not exist. */
-   } else if( astOK ) {
-      astError( AST__BADCOL, "astGetColumnLength(%s): No column named '%s' "
-                "exists in the table.", status, astGetClass( this ), column );
-   }
-
-/* Free resources */
-   cols = astAnnul( cols );
-
-/* Return AST__BADTYPE if an error occurred. */
-   if( !astOK ) result = 0;
-
-/* Return the result. */
-   return result;
-}
-
-static int GetColumnNdim( AstTable *this, const char *column, int *status ) {
-/*
-*+
-*  Name:
-*     astGetColumnNdim
-
-*  Purpose:
-*     Get the number of dimensions for a column in a Table.
-
-*  Type:
-*     Protected virtual function.
-
-*  Synopsis:
-*     #include "table.h"
-*     int astGetColumnNdim( AstTable *this, const char *column )
-
-*  Class Membership:
-*     Table method.
-
-*  Description:
-*     This function attribute holds the number of axes spanned by each value
-*     in a column. If each cell in the column is a scalar, ColumnNdim will
-*     be zero. If each cell in the column is a 1D spectrum, ColumnNdim will
-*     be one. If each cell in the column is a 2D image, ColumnNdim will be
-*     two, etc.
-
-*  Parameters:
-*     this
-*        Pointer to the Table.
-*     column
-*        The character string holding the upper-case name of the column.
-*        Trailing spaces are ignored. An error is reported if the supplied
-*        column is not found in the Table.
-
-*  Returned Value:
-*     The number of dimensions - zero for a scalar.
-
-*  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: */
-   AstKeyMap *cols;        /* KeyMap holding column definitions */
-   AstKeyMap *col_km;      /* Pointer to KeyMap holding column info */
-   int result;             /* Returned value */
-
-/* Initialise */
-   result = 0;
-
-/* Check the global error status. */
-   if ( !astOK ) return result;
-
-/* Get the KeyMap holding information about all columns. */
-   cols = astColumnProps( this );
-
-/* Get the KeyMap holding information about the requested column. */
-   if( astMapGet0A( cols, column, &col_km ) ) {
-
-/* Get the number of dimensions. */
-      result = astMapLength( col_km, SHAPE );
-
-/* Free resources */
-      col_km = astAnnul( col_km );
-
-/* Report an error if the column does not exist. */
-   } else if( astOK ) {
-      astError( AST__BADCOL, "astGetColumnNdim(%s): No column named '%s' "
-                "exists in the table.", status, astGetClass( this ), column );
-   }
-   cols = astAnnul( cols );
-
-/* Return AST__BADTYPE if an error occurred. */
-   if( !astOK ) result = 0;
-
-/* Return the result. */
-   return result;
-}
-
-static int GetColumnType( AstTable *this, const char *column, int *status ) {
-/*
-*+
-*  Name:
-*     astGetColumnType
-
-*  Purpose:
-*     Get the data type of a column in a Table.
-
-*  Type:
-*     Protected virtual function.
-
-*  Synopsis:
-*     #include "table.h"
-*     int astGetColumnType( AstTable *this, const char *column )
-
-*  Class Membership:
-*     Table method.
-
-*  Description:
-*     This function returns a value indicating the data type of a
-*     named column in a Table. This is the data type which was used
-*     when the column was added to the Table using astAddColumn.
-
-*  Parameters:
-*     this
-*        Pointer to the Table.
-*     column
-*        The character string holding the upper-case name of the column.
-*        Trailing spaces are ignored. An error is reported if the supplied
-*        column is not found in the Table.
-
-*  Returned Value:
-*     One of AST__INTTYPE (for integer), AST__SINTTYPE (for short int),
-*     AST__BYTETYPE (for unsigned bytes - 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 astMapPutU).
-
-*  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: */
-   AstKeyMap *cols;        /* Pointer to KeyMap holding all column info */
-   AstKeyMap *col_km;      /* Pointer to KeyMap holding requested column info */
-   int result;             /* Returned value */
-
-/* Initialise */
-   result = AST__BADTYPE;
-
-/* Check the global error status. */
-   if ( !astOK ) return result;
-
-/* Get the KeyMap holding information about the requested column. */
-   cols = astColumnProps( this );
-   if( astMapGet0A( cols, column, &col_km ) ) {
-
-/* Get the column data type. */
-      (void) astMapGet0I( col_km, TYPE, &result );
-
-/* Annul the KeyMap pointer. */
-      col_km = astAnnul( col_km );
-
-/* Report an error if the column does not exist. */
-   } else if( astOK ) {
-      astError( AST__BADCOL, "astGetColumnType(%s): No column named '%s' "
-                "exists in the table.", status, astGetClass( this ), column );
-   }
-   cols = astAnnul( cols );
-
-/* Return AST__BADTYPE if an error occurred. */
-   if( !astOK ) result = AST__BADTYPE;
-
-/* Return the result. */
-   return result;
-}
-
-static const char *GetColumnUnit( AstTable *this, const char *column, int *status ) {
-/*
-*+
-*  Name:
-*     astGetColumnUnit
-
-*  Purpose:
-*     Get the unit string for a column in a Table.
-
-*  Type:
-*     Protected virtual function.
-
-*  Synopsis:
-*     #include "table.h"
-*     const char *astGetColumnUnit( AstTable *this, const char *column )
-
-*  Class Membership:
-*     Table method.
-
-*  Description:
-*     This function returns the unit string for a named column in a Table.
-*     This is the unit string that was provided when the column was added to
-*     the Table using astAddColumn.
-
-*  Parameters:
-*     this
-*        Pointer to the Table.
-*     column
-*        The character string holding the upper-case name of the column.
-*        Trailing spaces are ignored. An error is reported if the supplied
-*        column is not found in the Table.
-
-*  Returned Value:
-*     A pointer to a null-terminated string containing the column units.
-
-*-
-*/
-
-/* Local Variables: */
-   AstKeyMap *col_km;    /* Pointer to KeyMap holding requested column info */
-   AstKeyMap *cols;      /* Pointer to KeyMap holding all column info */
-   const char *result;   /* Returned value */
-
-/* Initialise */
-   result = NULL;
-
-/* Check the global error status. */
-   if ( !astOK ) return result;
-
-/* Get the KeyMap holding information about the requested column. */
-   cols = astColumnProps( this );
-   if( astMapGet0A( cols, column, &col_km ) ) {
-
-/* Get the column unit string. */
-      (void) astMapGet0C( col_km, UNIT, &result );
-
-/* Annul the KeyMap pointer. */
-      col_km = astAnnul( col_km );
-
-/* Report an error if the column does not exist. */
-   } else if( astOK ) {
-      astError( AST__BADCOL, "astGetColumnUnit(%s): No column named '%s' "
-                "exists in the table.", status, astGetClass( this ), column );
-   }
-   cols = astAnnul( cols );
-
-/* Return NULL if an error occurred. */
-   if( !astOK ) result = NULL;
-
-/* Return the result. */
-   return result;
-}
-
-static int GetNcolumn( AstTable *this, int *status ) {
-/*
-*+
-*  Name:
-*     astGetNcolumn
-
-*  Purpose:
-*     Get the number of columns in a Table.
-
-*  Type:
-*     Protected virtual function.
-
-*  Synopsis:
-*     #include "table.h"
-*     int astGetNcolumn( AstTable *this )
-
-*  Class Membership:
-*     Table method.
-
-*  Description:
-*     This function returns the number of columns currently in the Table.
-
-*  Parameters:
-*     this
-*        Pointer to the Table.
-
-*  Returned Value:
-*     Number of columns.
-
-*  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: */
-   AstKeyMap *cols;
-   int result;
-
-/* Check the global error status. */
-   if ( !astOK ) return 0;
-
-/* Get a pointer to the KeyMap holding the column definitions. */
-   cols = astColumnProps( this );
-
-/* Get the number of column definitions in the KeyMap. */
-   result = astMapSize( cols );
-
-/* Annul the KeyMap pointer. */
-   cols = astAnnul( cols );
-
-/* Return the result. */
-   return result;
-}
-
-static int GetNparameter( AstTable *this, int *status ) {
-/*
-*+
-*  Name:
-*     astGetNparameter
-
-*  Purpose:
-*     Get the number of global parameters in a Table.
-
-*  Type:
-*     Protected virtual function.
-
-*  Synopsis:
-*     #include "table.h"
-*     int astGetNparameter( AstTable *this )
-
-*  Class Membership:
-*     Table method.
-
-*  Description:
-*     This function returns the number of global parameters currently in the Table.
-
-*  Parameters:
-*     this
-*        Pointer to the Table.
-
-*  Returned Value:
-*     Number of parameters.
-
-*  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: */
-   AstKeyMap *pars;
-   int result;
-
-/* Check the global error status. */
-   if ( !astOK ) return 0;
-
-/* Get a pointer to the KeyMap holding the parameter definitions. */
-   pars = astParameterProps( this );
-
-/* Get the number of parameter definitions in the KeyMap. */
-   result = astMapSize( pars );
-
-/* Annul the KeyMap pointer. */
-   pars = astAnnul( pars );
-
-/* Return the result. */
-   return result;
-}
-
-static int GetObjSize( AstObject *this_object, int *status ) {
-/*
-*  Name:
-*     GetObjSize
-
-*  Purpose:
-*     Return the in-memory size of an Object.
-
-*  Type:
-*     Private function.
-
-*  Synopsis:
-*     #include "table.h"
-*     int GetObjSize( AstObject *this, int *status )
-
-*  Class Membership:
-*     Table member function (over-rides the astGetObjSize protected
-*     method inherited from the parent class).
-
-*  Description:
-*     This function returns the in-memory size of the supplied Tables,
-*     in bytes.
-
-*  Parameters:
-*     this
-*        Pointer to the Table.
-*     status
-*        Pointer to the inherited status variable.
-
-*  Returned Value:
-*     The Table 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 *km;             /* KeyMap holding column/parameter definitions */
-   AstTable *this;            /* Pointer to Table structure */
-   int result;                /* Result value to return */
-
-/* Initialise. */
-   result = 0;
-
-/* Check the global error status. */
-   if ( !astOK ) return result;
-
-/* Obtain a pointers to the Table structure. */
-   this = (AstTable *) this_object;
-
-/* Invoke the GetObjSize method inherited from the parent KeyMap class, and
-   then add on any components of the class structure defined by this class
-   which are stored in dynamically allocated memory. */
-   result = (*parent_getobjsize)( this_object, status );
-
-   km = astColumnProps( this );
-   result += astGetObjSize( km );
-   km = astAnnul( km );
-
-   km = astParameterProps( this );
-   result += astGetObjSize( km );
-   km = astAnnul( km );
-
-/* If an error occurred, clear the result value. */
-   if ( !astOK ) result = 0;
-
-/* Return the result, */
-   return result;
-}
-
-static int HasColumn( AstTable *this, const char *column, int *status ){
-/*
-*++
-*  Name:
-c     astHasColumn
-f     AST_HASCOLUMN
-
-*  Purpose:
-*     Returns a flag indicating if a column is present in a Table.
-
-*  Type:
-*     Public virtual function.
-
-*  Synopsis:
-c     #include "table.h"
-c     int astHasColumn( AstTable *this, const char *column )
-f     RESULT = AST_HASCOLUMN( THIS, COLUMN, STATUS )
-
-*  Class Membership:
-*     Table method.
-
-*  Description:
-c     This function
-f     This routine
-*     returns a flag indicating if a named column exists in a Table, for
-*     instance, by having been added to to the Table using
-c     astAddColumn.
-f     AST_ADDCOLUMN.
-
-*  Parameters:
-c     this
-f     THIS = INTEGER (Given)
-*        Pointer to the Table.
-c     column
-f     COLUMN = CHARACTER * ( * ) (Given)
-*        The character string holding the upper case name of the column. Trailing
-*        spaces are ignored.
-f     STATUS = INTEGER (Given and Returned)
-f        The global status.
-
-*  Notes:
-*     - A value of
-c     zero
-f     .FALSE.
-*     is returned for if an error occurs.
-
-*--
-*/
-
-/* Local Variables: */
-   AstKeyMap *cols;
-   int result;
-
-/* Initialise */
-   result = 0;
-
-/* Check the inherited status. */
-   if( !astOK ) return result;
-
-/* Get the KeyMap holding information about all columns. */
-   cols = astColumnProps( this );
-
-/* Seeif it contains an entry for the named column. */
-   result = astMapHasKey( cols, column );
-
-/* Free resources. */
-   cols = astAnnul( cols );
-
-/* If an error has occurred, return zero. */
-   if( !astOK ) result = 0;
-   return result;
-}
-
-static int HasParameter( AstTable *this, const char *parameter, int *status ){
-/*
-*++
-*  Name:
-c     astHasParameter
-f     AST_HASPARAMETER
-
-*  Purpose:
-*     Returns a flag indicating if a named global parameter is present in a Table.
-
-*  Type:
-*     Public virtual function.
-
-*  Synopsis:
-c     #include "table.h"
-c     int astHasParameter( AstTable *this, const char *parameter )
-f     RESULT = AST_HASPARAMETER( THIS, PARAMETER, STATUS )
-
-*  Class Membership:
-*     Table method.
-
-*  Description:
-c     This function
-f     This routine
-*     returns a flag indicating if a named parameter exists in a Table, for
-*     instance, by having been added to to the Table using
-c     astAddParameter.
-f     AST_ADDPARAMETER.
-
-*  Parameters:
-c     this
-f     THIS = INTEGER (Given)
-*        Pointer to the Table.
-c     parameter
-f     PARAMETER = CHARACTER * ( * ) (Given)
-*        The character string holding the upper case name of the parameter. Trailing
-*        spaces are ignored.
-f     STATUS = INTEGER (Given and Returned)
-f        The global status.
-
-*  Notes:
-*     - A value of
-c     zero
-f     .FALSE.
-*     is returned for if an error occurs.
-
-*--
-*/
-
-/* Local Variables: */
-   AstKeyMap *pars;
-   int result;
-
-/* Initialise */
-   result = 0;
-
-/* Check the inherited status. */
-   if( !astOK ) return result;
-
-/* Get the KeyMap holding information about all parameters. */
-   pars = astParameterProps( this );
-
-/* See if it contains an entry for the named parameter. */
-   result = astMapHasKey( pars, parameter );
-
-/* Free resources. */
-   pars = astAnnul( pars );
-
-/* If an error has occurred, return zero. */
-   if( !astOK ) result = 0;
-   return result;
-}
-
-void astInitTableVtab_(  AstTableVtab *vtab, const char *name, int *status ) {
-/*
-*+
-*  Name:
-*     astInitTableVtab
-
-*  Purpose:
-*     Initialise a virtual function table for a Table.
-
-*  Type:
-*     Protected function.
-
-*  Synopsis:
-*     #include "table.h"
-*     void astInitTableVtab( AstTableVtab *vtab, const char *name )
-
-*  Class Membership:
-*     Table vtab initialiser.
-
-*  Description:
-*     This function initialises the component of a virtual function
-*     table which is used by the Table 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 */
-   AstKeyMapVtab *keymap;        /* Pointer to KeyMap 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. */
-   astInitKeyMapVtab( (AstKeyMapVtab *) vtab, name );
-
-/* Store a unique "magic" value in the virtual function table. This
-   will be used (by astIsATable) 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 = &(((AstKeyMapVtab *) vtab)->id);
-
-/* Initialise member function pointers. */
-/* ------------------------------------ */
-/* Store pointers to the member functions (implemented here) that provide
-   virtual methods for this class. */
-   vtab->AddColumn = AddColumn;
-   vtab->AddParameter = AddParameter;
-   vtab->ColumnName = ColumnName;
-   vtab->ParameterName = ParameterName;
-   vtab->ColumnProps = ColumnProps;
-   vtab->ColumnShape = ColumnShape;
-   vtab->GetColumnLenC = GetColumnLenC;
-   vtab->GetColumnLength = GetColumnLength;
-   vtab->GetColumnNdim = GetColumnNdim;
-   vtab->GetColumnType = GetColumnType;
-   vtab->GetColumnUnit = GetColumnUnit;
-   vtab->GetNcolumn = GetNcolumn;
-   vtab->GetNparameter = GetNparameter;
-   vtab->GetNrow = GetNrow;
-   vtab->HasColumn = HasColumn;
-   vtab->HasParameter = HasParameter;
-   vtab->ParameterProps = ParameterProps;
-   vtab->PurgeRows = PurgeRows;
-   vtab->RemoveColumn = RemoveColumn;
-   vtab->RemoveParameter = RemoveParameter;
-   vtab->RemoveRow = RemoveRow;
-   vtab->SetNrow = SetNrow;
-
-/* Save the inherited pointers to methods that will be extended, and
-   replace them with pointers to the new member functions. */
-   object = (AstObjectVtab *) vtab;
-   keymap = (AstKeyMapVtab *) vtab;
-
-   parent_equal = object->Equal;
-   object->Equal = Equal;
-
-   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
-
-   parent_mapremove = keymap->MapRemove;
-
-/* Define convenience macros for overriding methods inherited from the
-   parent KeyMap class using all data type supported by KeyMap. */
-#define OVERRIDE(method,code,methodlc,codelc) \
-   parent_##methodlc##codelc = keymap->method##code; \
-   keymap->method##code = method##code; \
-
-#define OVERRIDE_METHOD(method,methodlc) \
-   OVERRIDE(method,A,methodlc,a) \
-   OVERRIDE(method,P,methodlc,p) \
-   OVERRIDE(method,C,methodlc,c) \
-   OVERRIDE(method,D,methodlc,d) \
-   OVERRIDE(method,F,methodlc,f) \
-   OVERRIDE(method,I,methodlc,i) \
-   OVERRIDE(method,S,methodlc,s) \
-   OVERRIDE(method,B,methodlc,b)
-
-/* Use these macros to override the required methods. */
-   OVERRIDE_METHOD(MapPut0,mapput0)
-   OVERRIDE_METHOD(MapGet0,mapget0)
-   OVERRIDE_METHOD(MapPut1,mapput1)
-   OVERRIDE_METHOD(MapGet1,mapget1)
-   OVERRIDE_METHOD(MapPutElem,mapputelem)
-   OVERRIDE_METHOD(MapGetElem,mapgetelem)
-   OVERRIDE(MapPut,U,mapput,u)
-   OVERRIDE(SetKeyCase,,setkeycase,)
-   OVERRIDE(ClearKeyCase,,clearkeycase,)
-
-/* Remove the macros. */
-#undef OVERRIDE_METHOD
-#undef OVERRIDE
-
-/* Store replacement pointers for methods which will be over-ridden by
-   new member functions implemented here. */
-
-/* Declare the copy constructor, destructor and class dump function. */
-   astSetCopy( vtab, Copy );
-   astSetDelete( vtab, Delete );
-   astSetDump( vtab, Dump, "Table", "Two-dimensional table of data values" );
-
-/* 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) );
-   }
-}
-
-#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:
-*     Table 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: */
-   AstTable *this;         /* Pointer to Table structure */
-   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 Table structure. */
-   this = (AstTable *) 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. */
-   if( !result && this->columns ) result = astManageLock( this->columns, mode, extra,
-                                                          fail );
-
-   if( !result && this->parameters ) result = astManageLock( this->parameters, mode, extra,
-                                                             fail );
-
-/* Return the result. */
-   return result;
-}
-#endif
-
-/*
-*  Name:
-*     MapGet0<X>
-
-*  Purpose:
-*     Get a scalar value from a cell of a Table.
-
-*  Type:
-*     Private function.
-
-*  Synopsis:
-*     #include "table.h"
-*     int MapGet0<X>( AstKeyMap *this, const char *key, <X>type *value );
-
-*  Class Membership:
-*     Table member function (over-rides the astMapGet0<X> method inherited
-*     from the KeyMap class).
-
-*  Description:
-*     This is a set of functions for retrieving a scalar value from a
-*     cell of a Table. You should replace <X> in the generic function name
-*     MapGet0<X> by an appropriate 1-character type code (see the "Data
-*     Type Codes" section in the astMapGet0<X> docs). 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).
-
-*  Parameters:
-*     this
-*        Pointer to the Table.
-*     key
-*        A character string identifying the cell from which the value is
-*        to be retrieved. It should have the form "COLNAME(irow)", where
-*        "COLNAME" is replaced by the name of a column that has been
-*        defined previously using the astAddColumn method, and "irow" is
-*        an integer row index (the first row is row 1).
-*     value
-*        A pointer to a buffer in which to return the requested value.
-*        If the requested cell is not found, or if it is found but has an
-*        undefined value (see astMapPutU), then the contents of the buffer
-*        on entry to this function will be unchanged on exit. For pointer
-*        types ("A" and "C"), the buffer should be a suitable pointer, and
-*        the address of this pointer should be supplied as the "value"
-*        parameter.
-*     status
-*        Pointer to inherited status value.
-
-*  Returned Value:
-*     A non-zero value is returned if the requested key name was found, and
-*     does not have an undefined value (see astMapPutU). Zero is returned
-*     otherwise.
-
-*  Notes:
-*     - No error is reported if the requested cell cannot be found in the
-*     given KeyMap, but a zero value will be returned as the function value.
-*     The supplied buffer will be returned unchanged.
-*     - Key names are case insensitive, and white space is considered
-*     significant.
-*     - If the stored value is a vector value, then the first value in
-*     the vector will be returned.
-*     - A string pointer returned by astMapGet0C is guaranteed to remain
-*     valid and the string to which it points will not be over-written for
-*     a total of 50 successive invocations of this function. After this,
-*     the memory containing the string may be re-used, so a copy of
-*     the string should be made if it is needed for longer than this.
-*     - 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 astAnnul when it is no longer needed.
-*/
-
-/* Define a macro to implement the function for a specific data type. */
-#define MAKE_MAPGET0(X,Xlc,Xtype,Itype) \
-static int MapGet0##X( AstKeyMap *this_keymap, const char *key, Xtype *value, \
-                       int *status ) { \
-\
-/* Local Variables: */ \
-   AstTable *this;     /* Pointer to Table structure */ \
-   char colname[ AST__MXCOLNAMLEN + 1 ]; /* Column name read from string */ \
-   int irow;           /* Row index within key string */ \
-   int result;         /* Returned flag */ \
-\
-/* Initialise */ \
-   result = 0; \
-\
-/* Check the global error status. */ \
-   if ( !astOK ) return result; \
-\
-/* Get a pointer to the Table structure. */ \
-   this = (AstTable *) this_keymap; \
-\
-/* If the key is the name of a global table parameter, use the parent \
-   method to get the value of hte parameter. */ \
-   if( astHasParameter( this, key ) ) { \
-      result = (*parent_mapget0##Xlc)( this_keymap, key, value, status ); \
-\
-/* Check the supplied key looks like a table cell key, and get the \
-   the column name and the row number. Also checks that the table \
-   contains a column with the specified name. */ \
-   } else if( ParseKey( this, key, astGetKeyError( this ), colname, &irow, \
-                        NULL, "astMapGet0" #X, status ) ) { \
-\
-/* If the row index is larger than the current number of rows in the \
-   table, do nothing more. */ \
-      if( irow <= astGetNrow( this ) ){ \
-\
-/* Use the astMapGet0<X> method in the parent keyMap class to get the \
-   cell contents. */ \
-         result = (*parent_mapget0##Xlc)( this_keymap, key, value, status ); \
-      } \
-   } \
-\
-/* 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,i,int,AST__INTTYPE)
-MAKE_MAPGET0(D,d,double,AST__DOUBLETYPE)
-MAKE_MAPGET0(F,f,float,AST__FLOATTYPE)
-MAKE_MAPGET0(C,c,const char *,AST__STRINGTYPE)
-MAKE_MAPGET0(A,a,AstObject *,AST__OBJECTTYPE)
-MAKE_MAPGET0(P,p,void *,AST__POINTERTYPE)
-MAKE_MAPGET0(S,s,short int,AST__SINTTYPE)
-MAKE_MAPGET0(B,b,unsigned char,AST__BYTETYPE)
-
-/* Undefine the macro. */
-#undef MAKE_MAPGET0
-
-/*
-*  Name:
-*     MapGet1<X>
-
-*  Purpose:
-*     Get a vector value from a cell of a Table.
-
-*  Type:
-*     Private function.
-
-*  Synopsis:
-*     #include "table.h"
-*     int MapGet1<X>( AstKeyMap *this, const char *key, int mxval,
-*                     int *nval, <X>type *value )
-*     int MapGet1C( AstKeyMap *this, const char *key, int l, int mxval,
-*                   int *nval, const char *value )
-
-*  Class Membership:
-*     Table member function (over-rides the astMapGet1<X> method inherited
-*     from the KeyMap class).
-
-*  Description:
-*     This is a set of functions for retrieving a vector value from a
-*     cell of a Table. You should replace <X> in the generic function name
-*     MapGet1<X> by an appropriate 1-character type code (see the "Data
-*     Type Codes" section in the astMapGet1<X> docs). 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).
-*
-*     Note, the MapGet1C function has an extra parameter "l" which
-*     specifies the maximum length of each string to be stored in the
-*     "value" buffer (see the "astMapGet1C" docs).
-
-*  Parameters:
-*     this
-*        Pointer to the Table.
-*     key
-*        A character string identifying the cell from which the value is
-*        to be retrieved. It should have the form "COLNAME(irow)", where
-*        "COLNAME" is replaced by the name of a column that has been
-*        defined previously using the astAddColumn method, and "irow" is
-*        an integer row index (the first row is row 1).
-*     mxval
-*        The number of elements in the "value" array.
-*     nval
-*        The address of an integer in which to put the number of elements
-*        stored in the "value" array. Any unused elements of the array are
-*        left unchanged.
-*     value
-*        A pointer to an array in which to return the requested values.
-*        If the requested cell is not found, or if it is found but has an
-*        undefined value (see astMapPutU), then the contents of the buffer
-*        on entry to this function will be unchanged on exit.
-*     status
-*        Pointer to inherited status value.
-
-*  Returned Value:
-*     A non-zero value is returned if the requested key name was found, and
-*     does not have an undefined value (see astMapPutU). Zero is returned
-*     otherwise.
-
-*  MapGet1C:
-*     The "value" buffer supplied to the MapGet1C function should be a
-*     pointer to a character array with "mxval*l" elements, where "l" is
-*     the maximum length of a string to be returned. The value of "l"
-*     should be supplied as an extra parameter following "key" when
-*     invoking MapGet1C, and should include space for a terminating
-*     null character.
-
-*  Notes:
-*     - No error is reported if the requested cell cannot be found in the
-*     given KeyMap, but a zero value will be returned as the function value.
-*     The supplied buffer will be returned unchanged.
-*     - Key names are case insensitive, and white space is considered
-*     significant.
-*     - If the stored value is a scalar value, then the value will be
-*     returned in the first element of the supplied array, and "nval"
-*     will be returned set to 1.
-*/
-
-/* Define a macro to implement the function for a specific data type
-   (excluding "C" since that needs an extra parameter). */
-#define MAKE_MAPGET1(X,Xlc,Xtype,Itype) \
-static int MapGet1##X( AstKeyMap *this_keymap, const char *key, int mxval, int *nval, \
-                       Xtype *value, int *status ) { \
-\
-/* Local Variables: */ \
-   AstTable *this;     /* Pointer to Table structure */ \
-   char colname[ AST__MXCOLNAMLEN + 1 ]; /* Column name read from string */ \
-   int irow;           /* Row index within key string */ \
-   int result;         /* Returned flag */ \
-\
-/* Initialise */ \
-   result = 0; \
-\
-/* Check the global error status. */ \
-   if ( !astOK ) return result; \
-\
-/* Get a pointer to the Table structure. */ \
-   this = (AstTable *) this_keymap; \
-\
-/* If the key is the name of a global table parameter, use the parent \
-   method to get the value of hte parameter. */ \
-   if( astHasParameter( this, key ) ) { \
-      result = (*parent_mapget1##Xlc)( this_keymap, key, mxval, nval, \
-                value, status ); \
-\
-/* Check the supplied key looks like a table cell key, and get the \
-   the column name and the row number. Also checks that the table \
-   contains a column with the specified name. */ \
-   } else if( ParseKey( this, key, astGetKeyError( this ), colname, &irow, \
-                 NULL, "astMapGet1" #X, status ) ) { \
-\
-/* If the row index is larger than the current number of rows in the \
-   table, do nothing more. */ \
-      if( irow <= astGetNrow( this ) ){ \
-\
-/* Use the astMapGet1<X> method in the parent keyMap class to get the \
-   cell contents. */ \
-         result = (*parent_mapget1##Xlc)( this_keymap, key, mxval, nval, \
-                   value, status ); \
-      } \
-   } \
-\
-/* 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_MAPGET1(I,i,int,AST__INTTYPE)
-MAKE_MAPGET1(D,d,double,AST__DOUBLETYPE)
-MAKE_MAPGET1(F,f,float,AST__FLOATTYPE)
-MAKE_MAPGET1(A,a,AstObject *,AST__OBJECTTYPE)
-MAKE_MAPGET1(P,p,void *,AST__POINTERTYPE)
-MAKE_MAPGET1(S,s,short int,AST__SINTTYPE)
-MAKE_MAPGET1(B,b,unsigned char,AST__BYTETYPE)
-
-/* Undefine the macro. */
-#undef MAKE_MAPGET1
-
-
-static int MapGet1C( AstKeyMap *this_keymap, const char *key, int l, int mxval,
-                     int *nval, char *value, int *status ) {
-/*
-*  Name:
-*     MapGet1C
-
-*  Purpose:
-*     Get a vector value from a cell of a Table.
-
-*  Type:
-*     Private function.
-
-*  Synopsis:
-*     #include "table.h"
-*     int MapGet1C( AstKeyMap *this, const char *key, int l, int mxval,
-*                   int *nval, const char *value )
-
-*  Class Membership:
-*     Table member function (over-rides the astMapGet1C method inherited
-*     from the KeyMap class).
-
-*  Description:
-*     This is the implementation of MapGet1<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 MapGet1<X>)
-*/
-
-/* Local Variables: */
-   AstTable *this;     /* Pointer to Table structure */
-   char colname[ AST__MXCOLNAMLEN + 1 ]; /* Column name read from string */
-   int irow;           /* Row index within key string */
-   int result;         /* Returned flag */
-
-/* Initialise */
-   result = 0;
-
-/* Check the global error status. */
-   if ( !astOK ) return result;
-
-/* Get a pointer to the Table structure. */
-   this = (AstTable *) this_keymap;
-
-/* If the key is the name of a global table parameter, use the parent
-   method to get the value of hte parameter. */
-   if( astHasParameter( this, key ) ) {
-      result = (*parent_mapget1c)( this_keymap, key, l, mxval, nval,
-                value, status );
-
-/* Check the supplied key looks like a table cell key, and get the
-   the column name and the row number. Also checks that the table
-   contains a column with the specified name. */
-   } else if( ParseKey( this, key, astGetKeyError( this ), colname, &irow,
-                        NULL, "astMapGet1C", status ) ) {
-
-/* If the row index is larger than the current number of rows in the
-   table, do nothing more. */
-      if( irow <= astGetNrow( this ) ){
-
-/* Use the astMapGet1<X> method in the parent keyMap class to get the
-   cell contents. */
-         result = (*parent_mapget1c)( this_keymap, key, l, mxval, nval,
-                   value, status );
-      }
-   }
-
-/* If an error occurred, return zero. */
-   if( !astOK ) result = 0;
-
-/* Return the result.*/
-   return result;
-}
-
-/*
-*  Name:
-*     MapGetElem<X>
-
-*  Purpose:
-*     Get a single element of a vector value from a cell of a Table.
-
-*  Type:
-*     Private function.
-
-*  Synopsis:
-*     #include "table.h"
-*     int MapGetElem<X>( AstKeyMap *this, const char *key, int elem,
-*                        <X>type *value, int *status )
-*     int MapGetElemC( AstKeyMap *this, const char *key, int l, int elem,
-*                      char *value, int *status )
-
-*  Class Membership:
-*     Table member function (over-rides the astMapGetElem<X> method inherited
-*     from the KeyMap class).
-
-*  Description:
-*     This is a set of functions for retrieving a single element of a vector
-*     value from a cell of a Table. You should replace <X> in the generic
-*     function name MapGetElem<X> by an appropriate 1-character type code
-*     (see the "Data Type Codes" section in the astMapGetElem<X> docs). 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).
-*
-*     Note, the MapGetElemC function has an extra parameter "l" which
-*     specifies the maximum length of each string to be stored in the
-*     "value" buffer (see the "MapGetElemC" docs).
-
-*  Parameters:
-*     this
-*        Pointer to the Table.
-*     key
-*        A character string identifying the cell from which the value is
-*        to be retrieved. It should have the form "COLNAME(irow)", where
-*        "COLNAME" is replaced by the name of a column that has been
-*        defined previously using the astAddColumn method, and "irow" is
-*        an integer row index (the first row is row 1).
-*     elem
-*        The index of the vector element to modify, starting at zero.
-*        If the index is outside the range of the vector, an error will
-*        be reported.
-*     value
-*        A pointer to a buffer in which to return the requested values.
-*        If the requested cell is not found, or if it is found but has an
-*        undefined value (see astMapPutU), then the contents of the buffer
-*        on entry to this function will be unchanged on exit.
-*     status
-*        Pointer to inherited status value.
-
-*  Returned Value:
-*     A non-zero value is returned if the requested key name was found, and
-*     does not have an undefined value (see astMapPutU). Zero is returned
-*     otherwise.
-
-*  MapGetElemC:
-*     The "value" buffer supplied to the MapGetElemC function should be a
-*     pointer to a character array with "l" elements, where "l" is
-*     the maximum length of a string to be returned. The value of "l"
-*     should be supplied as an extra parameter following "key" when
-*     invoking MapGetElemC, and should include space for a terminating
-*     null character.
-
-*  Notes:
-*     - No error is reported if the requested cell cannot be found in the
-*     given KeyMap, but a zero value will be returned as the function value.
-*     The supplied buffer will be returned unchanged.
-*     - Key names are case insensitive, and white space is considered
-*     significant.
-*     - If the stored value is a scalar value, then the value will be
-*     returned in the first element of the supplied array, and "nval"
-*     will be returned set to 1.
-*/
-
-/* Define a macro to implement the function for a specific data type
-(excluding "C" since that needs an extra parameter). */
-#define MAKE_MAPGETELEM(X,Xlc,Xtype,Itype) \
-static int MapGetElem##X( AstKeyMap *this_keymap, const char *key, int elem, \
-                          Xtype *value, int *status ) { \
-\
-/* Local Variables: */ \
-   AstTable *this;     /* Pointer to Table structure */ \
-   char colname[ AST__MXCOLNAMLEN + 1 ]; /* Column name read from string */ \
-   int irow;           /* Row index within key string */ \
-   int result;         /* Returned flag */ \
-\
-/* Initialise */ \
-   result = 0; \
-\
-/* Check the global error status. */ \
-   if ( !astOK ) return result; \
-\
-/* Get a pointer to the Table structure. */ \
-   this = (AstTable *) this_keymap; \
-\
-/* If the key is the name of a global table parameter, use the parent \
-   method to get the value of hte parameter. */ \
-   if( astHasParameter( this, key ) ) { \
-      result = (*parent_mapgetelem##Xlc)( this_keymap, key, elem, \
-                                          value, status ); \
-\
-/* Check the supplied key looks like a table cell key, and get the \
-   the column name and the row number. Also checks that the table \
-   contains a column with the specified name. */ \
-   } else if( ParseKey( this, key, astGetKeyError( this ), colname, &irow, \
-                        NULL, "astMapGetElem" #X, status ) ) { \
-\
-/* If the row index is larger than the current number of rows in the \
-   table, do nothing more. */ \
-      if( irow <= astGetNrow( this ) ){ \
-\
-/* Use the astMapGetElem<X> method in the parent keyMap class to get the \
-   cell contents. */ \
-         result = (*parent_mapgetelem##Xlc)( this_keymap, key, elem, \
-                                             value, status ); \
-      } \
-   } \
-\
-/* 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_MAPGETELEM(I,i,int,AST__INTTYPE)
-MAKE_MAPGETELEM(D,d,double,AST__DOUBLETYPE)
-MAKE_MAPGETELEM(F,f,float,AST__FLOATTYPE)
-MAKE_MAPGETELEM(A,a,AstObject *,AST__OBJECTTYPE)
-MAKE_MAPGETELEM(P,p,void *,AST__POINTERTYPE)
-MAKE_MAPGETELEM(S,s,short int,AST__SINTTYPE)
-MAKE_MAPGETELEM(B,b,unsigned char,AST__BYTETYPE)
-
-/* Undefine the macro. */
-#undef MAKE_MAPGETELEM
-
-static int MapGetElemC( AstKeyMap *this_keymap, const char *key, int l,
-                        int elem, char *value, int *status ) {
-/*
-*  Name:
-*     MapGetElemC
-
-*  Purpose:
-*     Get a single element of a vector value from a cell of a Table.
-
-*  Type:
-*     Private function.
-
-*  Synopsis:
-*     #include "table.h"
-*     int MapGetElemC( AstKeyMap *this, const char *key, int l, int elem,
-*                      char *value, int *status )
-
-*  Class Membership:
-*     Table member function (over-rides the astMapGetElemC method inherited
-*     from the KeyMap class).
-
-*  Description:
-*     This is the implementation of MapGetElem<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 MapGetElem<X>)
-*/
-
-/* Local Variables: */
-   AstTable *this;     /* Pointer to Table structure */
-   char colname[ AST__MXCOLNAMLEN + 1 ]; /* Column name read from string */
-   int irow;           /* Row index within key string */
-   int result;         /* Returned flag */
-
-/* Initialise */
-   result = 0;
-
-/* Check the global error status. */
-   if ( !astOK ) return result;
-
-/* Get a pointer to the Table structure. */
-   this = (AstTable *) this_keymap;
-
-/* If the key is the name of a global table parameter, use the parent
-   method to get the value of hte parameter. */
-   if( astHasParameter( this, key ) ) {
-      result = (*parent_mapgetelemc)( this_keymap, key, l, elem,
-                                      value, status );
-
-/* Check the supplied key looks like a table cell key, and get the
-   the column name and the row number. Also checks that the table
-   contains a column with the specified name. */
-   } else if( ParseKey( this, key, astGetKeyError( this ), colname, &irow,
-                        NULL, "astMapGetElemC", status ) ) {
-
-/* If the row index is larger than the current number of rows in the
-   table, do nothing more. */
-      if( irow <= astGetNrow( this ) ){
-
-/* Use the astMapGetElem<X> method in the parent keyMap class to get the
-   cell contents. */
-         result = (*parent_mapgetelemc)( this_keymap, key, l, elem,
-                                         value, status );
-      }
-   }
-
-/* If an error occurred, return zero. */
-   if( !astOK ) result = 0;
-
-/* Return the result.*/
-   return result;
-}
-
-/*
-*  Name:
-*     MapPut0<X>
-
-*  Purpose:
-*     Stores a scalar value in a cell of a Table.
-
-*  Type:
-*     Private function.
-
-*  Synopsis:
-*     #include "table.h"
-*     void MapPut0<X>( AstKeyMap *this, const char *key, <X>type value,
-*                      const char *comment, int *status )
-
-*  Class Membership:
-*     Table member function (over-rides the astMapPut0<X> method inherited
-*     from the KeyMap class).
-
-*  Description:
-*     This is a set of functions for storing a scalar value in a cell of
-*     a Table. You should use a function which matches the data type of the
-*     data you wish to add to the Table by replacing <X> in the generic
-*     function name MapPut0<X> by an appropriate 1-character type code (see
-*     the "Data Type Codes" section in the astMapPut0<X> docs).
-
-*  Parameters:
-*     this
-*        Pointer to the Table in which to store the supplied value.
-*     key
-*        A character string identifying the cell in which the value is
-*        to be stored. It should have the form "COLNAME(irow)", where
-*        "COLNAME" is replaced by the name of a column that has been
-*        defined previously using the astAddColumn method, and "irow" is
-*        an integer row index (the first row is row 1).
-*     value
-*        The value to be stored. The data type of this value should match
-*        the 1-character type code appended to the function name (e.g. if
-*        you are using astMapPut0A, the type of this value should be "pointer
-*        to AstObject"). An error will be reported if this data type is
-*        different to the data type assigned to the column when it was
-*        created via astAddColumn.
-*     comment
-*        A pointer to a null-terminated comment string to be stored with the
-*        value. A NULL pointer may be supplied, in which case no comment is
-*        stored.
-*     status
-*        Pointer to inherited status value.
-
-*  Notes:
-*     - Key names are case insensitive, and white space is considered
-*     significant.
-*     - The new value will replace any old value already stored in the
-*     Table for the specified cell.
-*     - 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 astMapget0A. 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.
-
-*/
-/* Define a macro to implement the function for a specific data type. */
-#define MAKE_MAPPUT0(X,Xlc,Xtype,Itype,ValExp) \
-static void MapPut0##X( AstKeyMap *this_keymap, const char *key, Xtype value, \
-                        const char *comment, int *status ) { \
-\
-/* Local Variables: */ \
-   AstKeyMap *col_km;  /* KeyMap holding details of the requested column */ \
-   AstTable *this;     /* Pointer to Table structure */ \
-   char colname[ AST__MXCOLNAMLEN + 1 ]; /* Column name read from string */ \
-   int irow;           /* Row index within key string */ \
-   int type;           /* Data type of the requested column */ \
-\
-/* Check the global error status. */ \
-   if ( !astOK ) return; \
-\
-/* Get a pointer to the Table structure. */ \
-   this = (AstTable *) this_keymap; \
-\
-/* If the key is the name of a global table parameter, use the parent \
-   method to put the value of the parameter. */ \
-   if( astHasParameter( this, key ) ) { \
-      (*parent_mapput0##Xlc)( this_keymap, key, value, comment, status ); \
-\
-/* Check the supplied key looks like a table cell key, and get the \
-   the column name and the row number. Also checks that the table \
-   contains a column with the specified name. */ \
-   } else if( ParseKey( this, key, 1, colname, &irow, &col_km, "astMapPut0" #X, \
-                        status ) ) { \
-\
-/* Check the column holds scalar values of the type implied by the <X> \
-   code in the function name. */ \
-      (void) astMapGet0I( col_km, TYPE, &type ); \
-      if( type != Itype && astOK ) { \
-         astError( AST__BADTYP, "astMapPut0" #X "(%s): Failed to store a " \
-                   #Xtype " value for cell \"%s\": column %s holds %s " \
-                   "values.", status, astGetClass( this ), key, colname, \
-                   TypeString( type ) ); \
-      } \
-\
-      if( astMapHasKey( col_km, SHAPE ) && astOK ) { \
-         astError( AST__BADTYP, "astMapPut0" #X "(%s): Failed to store a " \
-                   "scalar value for cell \"%s\": column %s holds vector " \
-                   " values.", status, astGetClass( this ), key, colname ); \
-      } \
-\
-/* If the row index is larger than the current number of rows in the \
-   table, update the number of rows in the table. */ \
-      if( irow > astGetNrow( this ) ) astSetNrow( this, irow ); \
-\
-/* Use the astMapPut0<X> method in the parent keyMap class to store the \
-   new cell contents. */ \
-      (*parent_mapput0##Xlc)( this_keymap, key, value, comment, status ); \
-\
-/* Free resources. */ \
-      col_km = astAnnul( col_km ); \
-   } \
-}
-
-/* Expand the above macro to generate a function for each required
-   data type. */
-MAKE_MAPPUT0(I,i,int,AST__INTTYPE,value)
-MAKE_MAPPUT0(D,d,double,AST__DOUBLETYPE,value)
-MAKE_MAPPUT0(F,f,float,AST__FLOATTYPE,value)
-MAKE_MAPPUT0(C,c,const char *,AST__STRINGTYPE,astStore(NULL,value,strlen(value)+1))
-MAKE_MAPPUT0(A,a,AstObject *,AST__OBJECTTYPE,(value?astClone(value):NULL))
-MAKE_MAPPUT0(P,p,void *,AST__POINTERTYPE,value)
-MAKE_MAPPUT0(S,s,short int,AST__SINTTYPE,value)
-MAKE_MAPPUT0(B,b,unsigned char,AST__BYTETYPE,value)
-
-/* Undefine the macro. */
-#undef MAKE_MAPPUT0
-
-/*
-*  Name:
-*     MapPut1<X>
-
-*  Purpose:
-*     Stores a vectorised value in a cell of a Table.
-
-*  Type:
-*     Private function.
-
-*  Synopsis:
-*     #include "table.h"
-*     void MapPut1<X>( AstKeyMap *this, const char *key, int size,
-*                      const <X>type value[], const char *comment,
-*                      int *status );
-
-*  Class Membership:
-*     Table member function (over-rides the astMapPut1<X> method inherited
-*     from the KeyMap class).
-
-*  Description:
-*     This is a set of functions for storing a vectorised value in a cell of
-*     a Table. You should use a function which matches the data type of the
-*     data you wish to add to the Table by replacing <X> in the generic
-*     function name MapPut1<X> by an appropriate 1-character type code (see
-*     the "Data Type Codes" section in the astMapPut1<X> docs).
-
-*  Parameters:
-*     this
-*        Pointer to the Table in which to store the supplied value.
-*     key
-*        A character string identifying the cell in which the value is
-*        to be stored. It should have the form "COLNAME(irow)", where
-*        "COLNAME" is replaced by the name of a column that has been
-*        defined previously using the astAddColumn method, and "irow" is
-*        an integer row index (the first row is row 1).
-*     size
-*        The number of elements in the supplied array of values.
-*     value
-*        The value to be stored. The data type of this value should match
-*        the 1-character type code appended to the function name (e.g. if
-*        you are using astMapPut0A, the type of this value should be "pointer
-*        to AstObject"). An error will be reported if this data type is
-*        different to the data type assigned to the column when it was
-*        created via astAddColumn.
-*     comment
-*        A pointer to a null-terminated comment string to be stored with the
-*        value. A NULL pointer may be supplied, in which case no comment is
-*        stored.
-*     status
-*        Pointer to inherited status value.
-
-*  Notes:
-*     - Key names are case insensitive, and white space is considered
-*     significant.
-*     - The new value will replace any old value already stored in the
-*     Table for the specified cell.
-
-*/
-
-/* Define a macro to implement the function for a specific data type. */
-#define MAKE_MAPPUT1(X,Xlc,Xtype,Itype,ValExp) \
-static void MapPut1##X( AstKeyMap *this_keymap, const char *key, int size, \
-                        Xtype value[], const char *comment, \
-                        int *status ) { \
-\
-/* Local Variables: */ \
-   AstTable *this;     /* Pointer to Table structure */ \
-   char colname[ AST__MXCOLNAMLEN + 1 ]; /* Column name read from string */ \
-   int irow;           /* Row index within key string */ \
-\
-/* Check the global error status. */ \
-   if ( !astOK ) return; \
-\
-/* Get a pointer to the Table structure. */ \
-   this = (AstTable *) this_keymap; \
-\
-/* If the key is the name of a global table parameter, use the parent \
-   method to put the value of the parameter. */ \
-   if( astHasParameter( this, key ) ) { \
-      (*parent_mapput1##Xlc)( this_keymap, key, size, value, \
-                              comment, status ); \
-\
-/* Check the supplied key looks like a table cell key, and get the \
-   the column name and the row number. Also checks that the table \
-   contains a column with the specified name. */ \
-   } else if( ParseKey( this, key, 1, colname, &irow, NULL, "astMapPut1" #X, \
-                        status ) ) { \
-\
-/* Check the column holds vector values of the type implied by the <X> \
-   code in the function name. */ \
-      if(  astGetColumnType( this, colname ) != Itype && astOK ) { \
-         astError( AST__BADTYP, "astMapPut1" #X "(%s): Failed to store " \
-                   #Xtype " values for cell \"%s\": column %s holds %s values.", \
-                   status, astGetClass( this ), key, colname, \
-                   TypeString( astGetColumnType( this, colname ) ) ); \
-      } \
-\
-/* Check the column holds vectors with length equal to the supplied vector. */ \
-      if( astGetColumnLength( this, colname ) != size && astOK ) { \
-         astError( AST__BADTYP, "astMapPut1" #X "(%s): Failed to " \
-                   "store a vector value for cell \"%s\": column " \
-                   "%s needs %d values per cell but %d were supplied.", \
-                   status, astGetClass( this ), key, colname, \
-                   astGetColumnLength( this, colname ), size ); \
-      } \
-\
-/* If all is OK, update the number of rows in the table if required, and \
-   store the vector in the parent KeyMap. */ \
-      if( astOK ) { \
-         if( irow > astGetNrow( this ) ) astSetNrow( this, irow ); \
-         (*parent_mapput1##Xlc)( this_keymap, key, size, value, \
-                                 comment, status ); \
-      } \
-\
-   } \
-}
-
-/* Expand the above macro to generate a function for each required
-   data type. */
-MAKE_MAPPUT1(D,d,const double,AST__DOUBLETYPE,value[i])
-MAKE_MAPPUT1(F,f,const float,AST__FLOATTYPE,value[i])
-MAKE_MAPPUT1(I,i,const int,AST__INTTYPE,value[i])
-MAKE_MAPPUT1(C,c,const char *const,AST__STRINGTYPE,astStore(NULL,value[i],strlen(value[i])+1))
-MAKE_MAPPUT1(A,a,AstObject *const,AST__OBJECTTYPE,(value[i]?astClone(value[i]):NULL))
-MAKE_MAPPUT1(P,p,void *const,AST__POINTERTYPE,value[i])
-MAKE_MAPPUT1(S,s,const short int,AST__SINTTYPE,value[i])
-MAKE_MAPPUT1(B,b,const unsigned char,AST__BYTETYPE,value[i])
-
-/* Undefine the macro. */
-#undef MAKE_MAPPUT1
-
-/*
-*  Name:
-*     MapPutElem<X>
-
-*  Purpose:
-*     Put a value into an element of a vector value in a cell of a Table.
-
-*  Type:
-*     Private function.
-
-*  Synopsis:
-*     #include "table.h"
-*     void MapPutElem<X>( AstKeyMap *this, const char *key, int elem,
-*                         <X>type *value, int *status )
-
-*  Class Membership:
-*     Table member function (over-rides the astMapPutElem<X> method inherited
-*     from the KeyMap class).
-
-*  Description:
-*     This is a set of functions for storing a value in a single element
-*     of a vector value stored in a cell of a Table. You should use a
-*     function which matches the data type of the data you wish to add to
-*     the Table by replacing <X> in the generic function name MapPutElem<X>
-*     by an appropriate 1-character type code (see the "Data Type Codes"
-*     section in the astMapPutElem<X> docs).
-
-*  Parameters:
-*     this
-*        Pointer to the Table in which to store the supplied value.
-*     key
-*        A character string identifying the cell in which the value is
-*        to be stored. It should have the form "COLNAME(irow)", where
-*        "COLNAME" is replaced by the name of a column that has been
-*        defined previously using the astAddColumn method, and "irow" is
-*        an integer row index (the first row is row 1).
-*     elem
-*        The index of the vector element to modify, starting at zero.
-*        If the index is outside the range of the vector, an error will
-*        be reported.
-*     value
-*        The value to be stored. The data type of this value should match
-*        the 1-character type code appended to the function name (e.g. if
-*        you are using astMapPut0A, the type of this value should be "pointer
-*        to AstObject"). An error will be reported if this data type is
-*        different to the data type assigned to the column when it was
-*        created via astAddColumn.
-*     status
-*        Pointer to inherited status value.
-
-*  Notes:
-*     - Key names are case insensitive, and white space is considered
-*     significant.
-*     - The new value will replace any old value already stored in the
-*     Table for the specified cell.
-*     - 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 astMapget0A. 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.
-
-*/
-/* Define a macro to implement the function for a specific data type. */
-
-#define MAKE_MAPPUTELEM(X,Xlc,Xtype,Itype) \
-static void MapPutElem##X( AstKeyMap *this_keymap, const char *key, int elem, \
-                           Xtype value, int *status ) { \
-\
-/* Local Variables: */ \
-   AstTable *this;     /* Pointer to Table structure */ \
-   char colname[ AST__MXCOLNAMLEN + 1 ]; /* Column name read from string */ \
-   int irow;           /* Row index within key string */ \
-   int type;           /* Data type of the requested column */ \
-\
-/* Check the global error status. */ \
-   if ( !astOK ) return; \
-\
-/* Get a pointer to the Table structure. */ \
-   this = (AstTable *) this_keymap; \
-\
-/* If the key is the name of a global table parameter, use the parent \
-   method to put the value of the parameter. */ \
-   if( astHasParameter( this, key ) ) { \
-      (*parent_mapputelem##Xlc)( this_keymap, key, elem, value, \
-                                 status ); \
-\
-/* Check the supplied key looks like a table cell key, and get the \
-   the column name and the row number. Also checks that the table \
-   contains a column with the specified name. */ \
-   } else if( ParseKey( this, key, 1, colname, &irow, NULL, "astMapPutElem" #X, \
-                        status ) ) { \
-\
-/* Check the column holds vector values of the type implied by the <X> \
-   code in the function name. */ \
-      type = astGetColumnType( this, colname ); \
-      if(  type != Itype && astOK ) { \
-         astError( AST__BADTYP, "astMapPutElem" #X "(%s): Failed to store a " \
-                   #Xtype " value in cell \"%s\": column %s holds %s values.", \
-                   status, astGetClass( this ), key, colname, \
-                   TypeString( type ) ); \
-      } \
-\
-/* Check the column holds vectors with length equal to the supplied vector. */ \
-      if( astGetColumnLength( this, colname ) <= elem && astOK ) { \
-         astError( AST__BADTYP, "astMapPutElem" #X "(%s): Failed to " \
-                   "store a value for element %d (zero-based) of " \
-                   "cell \"%s\": column %s has only %d values per " \
-                   "cell.", status, astGetClass( this ), elem, key, \
-                   colname, astGetColumnLength( this, colname ) ); \
-      } \
-\
-/* If all is OK, update the number of rows in the table if required, and \
-   store the value in the parent KeyMap. */ \
-      if( astOK ) { \
-         if( irow > astGetNrow( this ) ) astSetNrow( this, irow ); \
-         (*parent_mapputelem##Xlc)( this_keymap, key, elem, value, \
-                                    status ); \
-      } \
-   } \
-}
-
-/* Expand the above macro to generate a function for each required
-   data type. */
-MAKE_MAPPUTELEM(I,i,int,AST__INTTYPE)
-MAKE_MAPPUTELEM(D,d,double,AST__DOUBLETYPE)
-MAKE_MAPPUTELEM(F,f,float,AST__FLOATTYPE)
-MAKE_MAPPUTELEM(A,a,AstObject *,AST__OBJECTTYPE)
-MAKE_MAPPUTELEM(P,p,void *,AST__POINTERTYPE)
-MAKE_MAPPUTELEM(C,c,const char *,AST__STRINGTYPE)
-MAKE_MAPPUTELEM(S,s,short int,AST__SINTTYPE)
-MAKE_MAPPUTELEM(B,b,unsigned char,AST__BYTETYPE)
-
-/* Undefine the macro. */
-#undef MAKE_MAPPUTELEM
-
-static void MapPutU( AstKeyMap *this_keymap, const char *key, const char *comment,
-                     int *status ) {
-/*
-*  Name:
-*     MapPutU
-
-*  Purpose:
-*     Stores a undefined value in a cell of a Table.
-
-*  Type:
-*     Private function.
-
-*  Synopsis:
-*     #include "table.h"
-*     void MapPutU( AstKeyMap *this, const char *key, const char *comment,
-*                   int *status )
-
-*  Class Membership:
-*     Table member function (over-rides the astMapPutU method inherited
-*     from the KeyMap class).
-
-*  Description:
-*     This function adds a new cell to a Table, but no value is stored with
-*     the cell. The cell therefore has a special data type represented by
-*     symbolic constant AST__UNDEFTYPE.
-*
-*     An example use is to add cells with undefined values to a Table
-*     prior to locking them with the MapLocked attribute. Such cells
-*     can act as placeholders for values that can be added to the KeyMap
-*     later.
-
-*  Parameters:
-*     this
-*        Pointer to the Table in which to store the supplied value.
-*     key
-*        A character string identifying the cell in which the value is
-*        to be stored. It should have the form "COLNAME(irow)", where
-*        "COLNAME" is replaced by the name of a column that has been
-*        defined previously using the astAddColumn method, and "irow" is
-*        an integer row index (the first row is row 1).
-*     comment
-*        A pointer to a null-terminated comment string to be stored with the
-*        value. A NULL pointer may be supplied, in which case no comment is
-*        stored.
-*     status
-*        Pointer to inherited status value.
-
-*  Notes:
-*     - Key names are case insensitive, and white space is considered
-*     significant.
-*     - The new undefined value will replace any old value already stored in
-*     the Table for the specified cell.
-
-*/
-
-/* Local Variables: */
-   AstTable *this;     /* Pointer to Table structure */
-   char colname[ AST__MXCOLNAMLEN + 1 ]; /* Column name read from string */
-   int irow;           /* Row index within key string */
-
-/* Check the global error status. */
-   if ( !astOK ) return;
-
-/* Get a pointer to the Table structure. */
-   this = (AstTable *) this_keymap;
-
-/* If the key is the name of a global table parameter, use the parent
-   method to put the value of the parameter. */
-   if( astHasParameter( this, key ) ) {
-      (*parent_mapputu)( this_keymap, key, comment, status );
-
-/* Check the supplied key looks like a table cell key, and get the
-   the column name and the row number. Also checks that the table
-   contains a column with the specified name. */
-   } else if( ParseKey( this, key, 1, colname, &irow, NULL, "astMapPutU",
-                        status ) ) {
-
-/* If the row index is larger than the current number of rows in the
-   table, update the number of rows in the table. */
-      if( irow > astGetNrow( this ) ) astSetNrow( this, irow );
-
-/* Use the astMapPutU method in the parent keyMap class to store the
-   new cell contents. */
-      (*parent_mapputu)( this_keymap, key, comment, status );
-   }
-}
-
-static const char *ParameterName( AstTable *this, int index, int *status ) {
-/*
-*++
-*  Name:
-c     astParameterName
-f     AST_PARAMETERNAME
-
-*  Purpose:
-*     Get the name of the global parameter at a given index within the Table.
-
-*  Type:
-*     Public virtual function.
-
-*  Synopsis:
-c     #include "table.h"
-c     const char *astParameterName( AstTable *this, int index )
-f     RESULT = AST_PARAMETERNAME( THIS, INDEX, STATUS )
-
-*  Class Membership:
-*     Table method.
-
-*  Description:
-*     This function returns a string holding the name of the global parameter with
-*     the given index within the Table.
-*
-*     This function is intended primarily as a means of iterating round all
-*     the parameters in a Table. For this purpose, the number of parameters in
-*     the Table is given by the Nparameter attribute of the Table. This function
-*     could then be called in a loop, with the index value going from
-c     zero to one less than Nparameter.
-f     one to Nparameter.
-*
-*     Note, the index associated with a parameter decreases monotonically with
-*     the age of the parameter: the oldest Parameter in the Table will have index
-*     one, and the Parameter added most recently to the Table will have the
-*     largest index.
-
-*  Parameters:
-c     this
-f     THIS = INTEGER (Given)
-*        Pointer to the Table.
-c     index
-f     INDEX = INTEGER (Given)
-*        The index into the list of parameters. The first parameter has index
-*        one, and the last has index "Nparameter".
-f     STATUS = INTEGER (Given and Returned)
-f        The global status.
-
-*  Returned Value:
-c     astParameterName()
-c        A pointer to a null-terminated string containing the
-f     AST_PARAMETERNAME = CHARACTER * ( AST__SZCHR )
-f        The
-*        upper case parameter name.
-
-*  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: */
-   AstKeyMap *pars;        /* KeyMap holding parameter definitions */
-   const char *result;
-
-/* Check the global error status. */
-   if ( !astOK ) return NULL;
-
-/* Get apointer to the KeyMap holding all parameter definitions. */
-   pars = astParameterProps( this );
-
-/* Issue a more useful error message than that issued by astMapKey if the
-   index is invalid. */
-   if( index < 1 || index > astMapSize( pars ) ) {
-      astError( AST__MPIND, "astParameterName(%s): Cannot find parameter "
-                "%d (zero-based) of the %s - invalid index.", status,
-                astGetClass( this ), index, astGetClass( this ) );
-   }
-
-/* Get the parameter name. */
-   result = astMapKey( pars, index - 1 );
-
-/* Free resources. */
-   pars = astAnnul( pars );
-
-/* Return a pointer to the required parameter name. */
-   return result;
-}
-
-static AstKeyMap *ParameterProps( AstTable *this, int *status ) {
-/*
-*+
-*  Name:
-*     astParameterProps
-
-*  Purpose:
-*     Returns a pointer to the KeyMap holding parameter properties.
-
-*  Type:
-*     Protected virtual function.
-
-*  Synopsis:
-*     #include "table.h"
-*     AstKeyMap *astParameterProps( AstTable *this )
-
-*  Class Membership:
-*     Table method.
-
-*  Description:
-*     This function returns a pointer to the KeyMap that holds
-*     definitions of all the parameters added to the Table.
-
-*  Parameters:
-*     this
-*        Pointer to the Table.
-
-*  Returned Value:
-*        A pointer to the KeyMap. It should be annulled using astAnnul
-*        when no longer needed.
-
-*-
-*/
-
-/* Check the global error status. */
-   if ( !astOK ) return NULL;
-
-/* Return a cloned pointer to the required KeyMap. */
-   return astClone( this->parameters );
-}
-
-static int ParseKey( AstTable *this, const char *key, int report,
-                     char colname[ AST__MXCOLNAMLEN + 1 ], int *irow,
-                     AstKeyMap **col_km, const char *method, int *status ){
-/*
-*  Name:
-*     ParseKey
-
-*  Purpose:
-*     Find the column name and row index in a KeyMap key.
-
-*  Type:
-*     Private function.
-
-*  Synopsis:
-*     #include "table.h"
-*     int ParseKey( AstTable *this, const char *key, int report,
-*                   char colname[ AST__MXCOLNAMLEN + 1 ], int *irow,
-*                   AstKeyMap **col_km, const char *method, int *status )
-
-*  Class Membership:
-*     Table member function
-
-*  Description:
-*     This function checks that the supplied KeyMap key conforms to the
-*     format expected for Table cells: i.e. "COLNAME(irow)", where
-*     "COLNAME" is the name of a column and "irow" is an integer row
-*     index (the first row is row 1), An error is reported if this is
-*     not the case.
-
-*  Parameters:
-*     this
-*        Pointer to the table.
-*     key
-*        The key string to test.
-*     report
-*        If non-zero, an error will be reported if the key does not
-*        correspond to a cell of an existing column. Otherwise, no
-*        error will be reported.
-*     colname
-*        A buffer in which to return the column name.
-*     irow
-*        Address of an int in which to return the row index.
-*     col_km
-*        Address of a KeyMap pointer in which to return a pointer to the
-*        KeyMap holding the information about the column. The returned
-*        KeyMap pointer should be annulled using astAnnul when no lngerr
-*        needed. If "col_km" is NULL, no KeyMap pointer is returned.
-*     method
-*        Pointer to a string holding the name of the method to include in
-*        any error message.
-*     status
-*        Address of the inherited status value.
-
-*  Returned Value:
-*     Zero is returned if the key is not a valid Table cell key, or if an
-*     error occurs.
-
-*/
-
-/* Local Variables: */
-   AstKeyMap *cols;    /* KeyMap holding column definitions */
-   int result;         /* Returned flag */
-   int collen;         /* Length of column name */
-   int nctot;          /* Number of characters read */
-
-/* Initialise */
-   result = 0;
-
-/* Check the global error status. */
-   if ( !astOK ) return result;
-
-/* Check the supplied key looks like a table cell key, and extract the
-   column name and row number. */
-   nctot = 0;
-   if( 1 == astSscanf( key, "%*[^(]%n(%d) %n", &collen, irow, &nctot )
-       && ( nctot >= strlen( key ) ) ) {
-
-/* Check the column name is not too long. */
-      if( collen > AST__MXCOLNAMLEN ) {
-         if( report ) {
-            astError( AST__BADKEY, "%s(%s): Failed to store a value for cell "
-                      "\"%s\": column name is too long.", status, method,
-                      astGetClass( this ), key );
-         }
-
-/* Check the row index is positive. */
-      } else if( *irow < 1 ) {
-         if( report ) {
-            astError( AST__BADKEY, "%s(%s): Failed to store a value for cell "
-                      "\"%s\": row index %d is invalid.", status, method,
-                      astGetClass( this ), key, *irow );
-         }
-
-/* If the key looks OK so far... */
-      } else {
-
-/* Convert the column name to upper case and store in the returned buffer. */
-         astChrCase( key, colname, 1, collen + 1 );
-         colname[ collen ] = 0;
-
-/* check that the column exists in the Table, returning a pointer to the
-   column KeyMap is reequired. */
-         cols = astColumnProps( this );
-         if( col_km ) {
-            result = astMapGet0A( cols, colname, col_km );
-         } else {
-            result = astMapHasKey( cols, colname );
-         }
-         cols = astAnnul( cols );
-
-/* Report an error if the table does not contain the specified column. */
-         if( !result && astOK && report) {
-            astError( AST__BADKEY, "%s(%s): Failed to store a value for "
-                      "cell \"%s\": the table does not contain a column "
-                      "called '%s'.", status, method, astGetClass( this ),
-                      key, colname );
-         }
-      }
-
-/* Report an error if the cell key has the wrong format. */
-   } else if( report ) {
-      astError( AST__BADKEY, "%s(%s): Failed to store a value for cell "
-                "\"%s\": the cell name is invalid.", status, method,
-                astGetClass( this ), key );
-   }
-
-/* Return the result.*/
-   return result;
-}
-
-static void PurgeRows( AstTable *this, int *status ) {
-/*
-*++
-*  Name:
-c     astPurgeRows
-f     AST_PURGEROWS
-
-*  Purpose:
-*     Remove all empty rows from a table.
-
-*  Type:
-*     Public virtual function.
-
-*  Synopsis:
-c     #include "table.h"
-c     void astPurgeRows( AstTable *this )
-f     CALL AST_PURGEROWS( THIS, STATUS )
-
-*  Class Membership:
-*     Table method.
-
-*  Description:
-*     This function removes all empty rows from the Table, renaming
-*     the key associated with each table cell accordingly.
-
-*  Parameters:
-c     this
-f     THIS = INTEGER (Given)
-*        Pointer to the Table.
-f     STATUS = INTEGER (Given and Returned)
-f        The global status.
-
-*--
-*/
-
-/* Local Variables: */
-   char newkey[ AST__MXCOLKEYLEN + 1 ]; /* New cell key string */
-   char oldkey[ AST__MXCOLKEYLEN + 1 ]; /* Old cell key string */
-   const char *col;              /* Column name */
-   const char *key;              /* Pointer to key string */
-   const char *op;               /* Pointer to opening parenthesis */
-   int *w1;                      /* Work space pointer */
-   int icol;                     /* Column index */
-   int inew;                     /* New row index */
-   int iold;                     /* Old row index */
-   int ncol;                     /* Number of columns in table */
-   int nrow;                     /* Number of rows in table */
-   int reset;                    /* Start a new pass through the KeyMap? */
-
-/* Check the global error status. */
-   if ( !astOK ) return;
-
-/* Get the number of rows in the table. */
-   nrow = astGetNrow( this );
-
-/* Create workspace to hold the number of defined values stored in each
-   row. Initialise every row to have zero defined values. */
-   w1 = astCalloc( nrow, sizeof( int ) );
-   if( astOK ) {
-
-/* Iterate round all keys in the KeyMap. */
-      reset = 1;
-      while( ( key = astMapIterate( this, reset ) ) && astOK ) {
-         reset = 0;
-
-/* Extract the row number from the key. */
-         op = strchr( key, '(' );
-         if( !op || astSscanf( op + 1, "%d", &iold ) != 1 ||
-             iold > nrow ) {
-            astError( AST__INTER, "astPurgeRows(%s): Illegal key '%s' "
-                      "found in a %s (internal programming error).",
-                      status, astGetClass( this ), key, astGetClass( this ) );
-
-/* Increment the number of values in this row. Note row indices are
-   one-based. */
-         } else {
-            w1[ iold - 1 ]++;
-         }
-      }
-
-/* Loop round all columns in the Table. */
-      ncol = astGetNcolumn( this );
-      inew = nrow;
-      for( icol = 1; icol <= ncol; icol++ ) {
-
-/* Get the column name */
-         col = astColumnName( this, icol );
-
-/* Loop round all the old row numbers. Skip empty rows.*/
-         inew = 0;
-         for( iold = 0; iold < nrow; iold++ ) {
-            if( w1[ iold ] > 0 ) {
-
-/* Increment the row number to use in place of the old row number. If the
-   old and new row numbers are the same, we do not need to rename the cell. */
-               if( iold != inew++ ) {
-
-/* For the old and new cell names */
-                  sprintf( oldkey, "%s(%d)", col, iold + 1 );
-                  sprintf( newkey, "%s(%d)", col, inew );
-
-/* Rename the KeyMap entry. */
-                  astMapRename( this, oldkey, newkey );
-               }
-            }
-         }
-
-/* If all rows were used, we do not need to check any more columns. */
-         if( iold == inew ) break;
-      }
-
-/* Store the new number of rows. */
-      astSetNrow( this, inew );
-   }
-
-/* Free resources. */
-   w1 = astFree( w1 );
-
-}
-
-static void RemoveColumn( AstTable *this, const char *name, int *status ) {
-/*
-*++
-*  Name:
-c     astRemoveColumn
-f     AST_REMOVECOLUMN
-
-*  Purpose:
-*     Remove a column from a table.
-
-*  Type:
-*     Public virtual function.
-
-*  Synopsis:
-c     #include "table.h"
-c     void astRemoveColumn( AstTable *this, const char *name )
-f     CALL AST_REMOVECOLUMN( THIS, NAME, STATUS )
-
-*  Class Membership:
-*     Table method.
-
-*  Description:
-*     This function removes a specified column from the supplied table.
-*     The
-c     function
-f     routine
-*     returns without action if the named column does not exist in the
-*     Table (no error is reported).
-
-*  Parameters:
-c     this
-f     THIS = INTEGER (Given)
-*        Pointer to the Table.
-c     name
-f     NAME = CHARACTER * ( * ) (Given)
-*        The column name. Trailing spaces are ignored (all other spaces
-*        are significant). Case is significant.
-f     STATUS = INTEGER (Given and Returned)
-f        The global status.
-
-*--
-*/
-
-/* Local Variables: */
-   AstKeyMap *cols;      /* KeyMap holding column definitions */
-   char key[ AST__MXCOLKEYLEN + 1 ]; /* Cell key string */
-   int irow;             /* Row index */
-   int namlen;           /* Used length of "name" */
-   int nrow;             /* Number of rows in table */
-
-/* Check the global error status. */
-   if ( !astOK ) return;
-
-/* Verify supplied values. */
-   namlen = astChrLen( name );
-   if( namlen == 0 ) {
-      astError( AST__BADKEY, "astRemoveColumn(%s): Illegal blank column name "
-               "supplied.", status, astGetClass( this ) );
-   }
-
-/* Get the number of rows in the table. */
-   nrow = astGetNrow( this );
-
-/* If there is no column with the given name in the Table, do nothing more. */
-   cols = astColumnProps( this );
-   if( astOK && astMapHasKey( cols, name ) ) {
-
-/* Remove the column description from the columns keymap. */
-      astMapRemove( cols, name );
-
-/* Remove any column cells with defined values from the parent KeyMap. */
-      for( irow = 1; irow <= nrow; irow++ ) {
-         sprintf( key, "%.*s(%d)", namlen, name, irow );
-         (*parent_mapremove)( (AstKeyMap *) this, key, status );
-      }
-   }
-   cols = astAnnul( cols );
-}
-
-static void RemoveParameter( AstTable *this, const char *name, int *status ) {
-/*
-*++
-*  Name:
-c     astRemoveParameter
-f     AST_REMOVEPARAMETER
-
-*  Purpose:
-*     Remove a global parameter from a table.
-
-*  Type:
-*     Public virtual function.
-
-*  Synopsis:
-c     #include "table.h"
-c     void astRemoveParameter( AstTable *this, const char *name )
-f     CALL AST_REMOVEPARAMETER( THIS, NAME, STATUS )
-
-*  Class Membership:
-*     Table method.
-
-*  Description:
-*     This function removes a specified global parameter from the supplied table.
-*     The
-c     function
-f     routine
-*     returns without action if the named parameter does not exist in the
-*     Table (no error is reported).
-
-*  Parameters:
-c     this
-f     THIS = INTEGER (Given)
-*        Pointer to the Table.
-c     name
-f     NAME = CHARACTER * ( * ) (Given)
-*        The parameter name. Trailing spaces are ignored (all other spaces
-*        are significant). Case is significant.
-f     STATUS = INTEGER (Given and Returned)
-f        The global status.
-
-*--
-*/
-
-/* Local Variables: */
-   AstKeyMap *pars;      /* KeyMap holding parameter definitions */
-
-/* Check the global error status. */
-   if ( !astOK ) return;
-
-/* Verify supplied values. */
-   if( astChrLen( name ) == 0 ) {
-      astError( AST__BADKEY, "astRemoveParameter(%s): Illegal blank parameter name "
-               "supplied.", status, astGetClass( this ) );
-   }
-
-/* If there is no parameter with the given name in the Table, do nothing more. */
-   pars = astParameterProps( this );
-   if( astOK && astMapHasKey( pars, name ) ) {
-
-/* Remove the parameter description from the parameters keymap. */
-      astMapRemove( pars, name );
-
-/* Remove any entry holding the parameter value from the parent KeyMap. */
-      (*parent_mapremove)( (AstKeyMap *) this, name, status );
-   }
-   pars = astAnnul( pars );
-}
-
-static void RemoveRow( AstTable *this, int index, int *status ) {
-/*
-*++
-*  Name:
-c     astRemoveRow
-f     AST_REMOVEROW
-
-*  Purpose:
-*     Remove a row from a table.
-
-*  Type:
-*     Public virtual function.
-
-*  Synopsis:
-c     #include "table.h"
-c     void astRemoveRow( AstTable *this, int index )
-f     CALL AST_REMOVEROW( THIS, INDEX, STATUS )
-
-*  Class Membership:
-*     Table method.
-
-*  Description:
-*     This function removes a specified row from the supplied table.
-*     The
-c     function
-f     routine
-*     returns without action if the row does not exist in the
-*     Table (no error is reported).
-
-*  Parameters:
-c     this
-f     THIS = INTEGER (Given)
-*        Pointer to the Table.
-c     index
-f     INDEX = INTEGER (Given)
-*        The index of the row to be removed. The first row has index 1.
-f     STATUS = INTEGER (Given and Returned)
-f        The global status.
-
-*--
-*/
-
-/* Local Variables: */
-   AstKeyMap *cols;              /* KeyMap holding column definitions */
-   char key[ AST__MXCOLKEYLEN + 1 ]; /* Cell key string */
-   const char *col;              /* Column name */
-   int icol;                     /* Column index */
-   int ncol;                     /* Number of columns in table */
-   int nrow;                     /* Number of rows in table */
-
-/* Check the global error status. */
-   if ( !astOK ) return;
-
-/* Get the number of rows in the table. */
-   nrow = astGetNrow( this );
-
-/* Do nothing if the specified row is out of bounds. */
-   if( index > 0 && index <= nrow ) {
-
-/* Loop round all columns in the table. */
-      cols = astColumnProps( this );
-      ncol = astMapSize( cols );
-      for( icol = 0; icol < ncol; icol++ ) {
-         col = astMapKey( cols, icol );
-
-/* Remove the cell of the current column at the requested row. */
-         sprintf( key, "%s(%d)", col, index );
-         (*parent_mapremove)( (AstKeyMap *) this, key, status );
-      }
-      cols = astAnnul( cols );
-
-/* If the removed row was the last row, reduce the number of rows in the
-   Table. */
-      if( index == nrow ) astSetNrow( this, index - 1 );
-   }
-}
-
-static void SetAttrib( AstObject *this_object, const char *setting, int *status ) {
-/*
-*  Name:
-*     SetAttrib
-
-*  Purpose:
-*     Set an attribute value for a Table.
-
-*  Type:
-*     Private function.
-
-*  Synopsis:
-*     #include "table.h"
-*     void SetAttrib( AstObject *this, const char *setting, int *status )
-
-*  Class Membership:
-*     Table member function (over-rides the astSetAttrib protected
-*     method inherited from the KeyMap class).
-
-*  Description:
-*     This function assigns an attribute value for a Table, 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 Table.
-*     setting
-*        Pointer to a null terminated string specifying the new attribute
-*        value.
-*     status
-*        Pointer to the inherited status variable.
-*/
-
-/* Local Variables: */
-   AstTable *this;               /* Pointer to the Table structure */
-   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 Table structure. */
-   this = (AstTable *) 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. */
-   /* None as yet */
-
-/* Define a macro to see if the setting string matches any of the
-   read-only attributes of this class. */
-#define MATCH(attrib) \
-        ( nc = 0, ( 0 == astSscanf( setting, attrib "=%*[^\n]%n", &nc ) ) && \
-                  ( nc >= len ) )
-
-#define MATCH2(attrib) \
-        ( nc = 0, ( 0 == astSscanf( setting, attrib "(%*s) =%*[^\n]%n", &nc ) ) && \
-                  ( nc >= len ) )
-
-/* If the attribute was not recognised, use this macro to report an error
-   if a read-only attribute has been specified. */
-   if ( MATCH( "ncolumn" ) ||
-        MATCH( "nparameter" ) ||
-        MATCH( "nrow" ) ||
-        MATCH2( "columnlenc" ) ||
-        MATCH2( "columnlength" ) ||
-        MATCH2( "columnndim" ) ||
-        MATCH2( "columntype" ) ||
-        MATCH2( "columnunit" ) ) {
-      astError( AST__NOWRT, "astSet: The setting \"%s\" is invalid for a %s.", status,
-                setting, astGetClass( this ) );
-      astError( AST__NOWRT, "This is a read-only attribute." , 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 );
-   }
-
-/* Undefine macros local to this function. */
-#undef MATCH
-#undef MATCH2
-}
-
-static void SetKeyCase( AstKeyMap *this, int keycase, int *status ) {
-/*
-*  Name:
-*     SetKeyCase
-
-*  Purpose:
-*     Set a value for the KeyCase attribute value for a Table.
-
-*  Type:
-*     Private function.
-
-*  Synopsis:
-*     #include "keymape.h"
-*     void SetKeyCase( AstKeyMap *this, int keycase, int *status )
-
-*  Class Membership:
-*     Table member function (over-rides the astSetKeyCase protected
-*     method inherited from the KeyMap class).
-
-*  Description:
-*     This function assigns a new valeu to the KeyCase attribute for a
-*     Table. For a Table, the KeyCase attribute cannot be changed so this
-*     function exits without action.
-
-*  Parameters:
-*     this
-*        Pointer to the Table.
-*     keycase
-*        The new value to set.
-*/
-
-}
-
-static int TestAttrib( AstObject *this_object, const char *attrib, int *status ) {
-/*
-*  Name:
-*     TestAttrib
-
-*  Purpose:
-*     Test if a specified attribute value is set for a Table.
-
-*  Type:
-*     Private function.
-
-*  Synopsis:
-*     #include "table.h"
-*     int TestAttrib( AstObject *this, const char *attrib, int *status )
-
-*  Class Membership:
-*     Table member function (over-rides the astTestAttrib protected
-*     method inherited from the KeyMap class).
-
-*  Description:
-*     This function returns a boolean result (0 or 1) to indicate whether
-*     a value has been set for one of a Table's attributes.
-
-*  Parameters:
-*     this
-*        Pointer to the Table.
-*     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: */
-   int len;                      /* Length of attribute string */
-   int nc;                       /* Number of characters read by astSscanf */
-   int result;                   /* Result value to return */
-
-/* Initialise. */
-   result = 0;
-
-/* Check the global error status. */
-   if ( !astOK ) return result;
-
-/* Get the length of the attribute string. */
-   len = strlen( attrib );
-
-/* Check the attribute name and test the appropriate attribute. */
-   /* None as yet */
-
-/* Define a macro to see if the attribute string matches any of the
-   read-only column attributes of this class. */
-#define MATCH(attr) \
-        ( nc = 0, ( 0 == astSscanf( attrib, attr "(%*s)%n", &nc ) ) && \
-                  ( nc >= len ) )
-
-/* If the name is not recognised, test if it matches any of the
-   read-only attributes of this class. If it does, then return
-   zero. */
-   if ( !strcmp( attrib, "ncolumn" ) ||
-        !strcmp( attrib, "nparameter" ) ||
-        !strcmp( attrib, "nrow" ) ||
-        MATCH( "columnlenc" ) ||
-        MATCH( "columnlength" ) ||
-        MATCH( "columnndim" ) ||
-        MATCH( "columntype" ) ||
-        MATCH( "columnunit" ) ) {
-      result = 0;
-
-/* 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;
-
-#undef MATCH
-}
-
-static const char *TypeString( int type ) {
-/*
-*  Name:
-*     TypeString
-
-*  Purpose:
-*     Return a pointer to a string describing a data type.
-
-*  Type:
-*     Private function.
-
-*  Synopsis:
-*      const char *TypeString( int type );
-
-*  Description:
-*     This function returns a pointer to a string describing a data type.
-
-*  Parameters:
-*     type
-*        The integer data type code.
-
-*  Returned Value:
-*     Pointer to a a string descirbing the data type (typically the C
-*     data type).
-
-*/
-
-/* Local Variables: */
-   const char *result;
-
-/* Compare the supplied type code against each supported value. */
-   if( type == AST__INTTYPE ) {
-      result = "int";
-
-   } else if( type == AST__BYTETYPE ) {
-      result = "byte";
-
-   } else if( type == AST__DOUBLETYPE ) {
-      result = "double";
-
-   } else if( type == AST__STRINGTYPE ) {
-      result = "string";
-
-   } else if( type == AST__OBJECTTYPE ) {
-      result = "Object";
-
-   } else if( type == AST__FLOATTYPE ) {
-      result = "float";
-
-   } else if( type == AST__POINTERTYPE ) {
-      result = "pointer";
-
-   } else if( type == AST__SINTTYPE ) {
-      result = "short int";
-
-   } else if( type == AST__UNDEFTYPE ) {
-      result = "undefined";
-
-   } else {
-      result = NULL;
-   }
-
-/* Return the result. */
-   return result;
-}
-
-
-/* Functions which access class attributes. */
-/* ---------------------------------------- */
-/* Implement member functions to access the attributes associated with
-   this class using the macros defined for this purpose in the
-   "object.h" file. For a description of each attribute, see the class
-   interface (in the associated .h file). */
-
-/*
-*att++
-*  Name:
-*     ColumnLenC(column)
-
-*  Purpose:
-*     The largest string length of any value in a column
-
-*  Type:
-*     Public attribute.
-
-*  Synopsis:
-*     Integer, read-only.
-
-*  Description:
-*     This attribute holds the minimum length which a character variable
-*     must have in order to be able to store the longest value currently
-*     present (at any row) in a specified column of the supplied Table.
-c     This does not include room for a trailing null character.
-*     The required column name should be placed inside the parentheses in
-*     the attribute name. If the named column holds vector values, then
-*     the attribute value is the length of the longest element of the
-*     vector value.
-
-*  Applicability:
-*     Table
-*        All Tables have this attribute.
-
-*  Notes:
-*     - If the named column holds numerical values, the length returned
-*     is the length of the largest string that would be generated if the
-*     column values were accessed as strings.
-
-*att--
-*/
-
-/*
-*att++
-*  Name:
-*     ColumnLength(column)
-
-*  Purpose:
-*     The number of elements in each value in a column
-
-*  Type:
-*     Public attribute.
-
-*  Synopsis:
-*     Integer, read-only.
-
-*  Description:
-*     This attribute holds the number of elements in each value stored
-*     in a named column. Each value can be a scalar (in which case the
-*     ColumnLength attribute has a value of 1), or a multi-dimensional
-*     array ( in which case the ColumnLength value is equal to the
-*     product of the array dimensions).
-
-*  Applicability:
-*     Table
-*        All Tables have this attribute.
-
-*att--
-*/
-
-/*
-*att++
-*  Name:
-*     ColumnNdim(column)
-
-*  Purpose:
-*     The number of axes spanned by each value in a column
-
-*  Type:
-*     Public attribute.
-
-*  Synopsis:
-*     Integer, read-only.
-
-*  Description:
-*     This attribute holds the number of axes spanned by each value in a
-*     column. If each cell in the column is a scalar, ColumnNdim will be
-*     zero. If each cell in the column is a 1D spectrum, ColumnNdim will
-*     be one. If each cell in the column is a 2D image, ColumnNdim will be
-*     two, etc. The required column name should be placed inside the
-*     parentheses in the attribute name.
-
-*  Applicability:
-*     Table
-*        All Tables have this attribute.
-
-*att--
-*/
-
-/*
-*att++
-*  Name:
-*     ColumnType(column)
-
-*  Purpose:
-*     The data type of each value in a column
-
-*  Type:
-*     Public attribute.
-
-*  Synopsis:
-*     Integer, read-only.
-
-*  Description:
-*     This attribute holds a integer value indicating the data type of
-*     a named column in a Table. This is the data type which was used
-*     when the column was added to the Table using astAddColumn. The
-*     required column name should be placed inside the parentheses in
-*     the attribute name.
-*
-*     The attribute value will be one of AST__INTTYPE (for integer),
-*     AST__SINTTYPE (for
-c     short int),
-f     INTEGER*2),
-*     AST__BYTETYPE (for
-c     unsigned bytes - i.e. unsigned chars),
-f     bytes),
-*     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).
-
-*  Applicability:
-*     Table
-*        All Tables have this attribute.
-
-*att--
-*/
-
-/*
-*att++
-*  Name:
-*     Ncolumn
-
-*  Purpose:
-*     The number of columns in the table.
-
-*  Type:
-*     Public attribute.
-
-*  Synopsis:
-*     Integer, read-only.
-
-*  Description:
-*     This attribute holds the number of columns currently in the table. Columns
-*     are added and removed using the
-c     astAddColumn and astRemoveColumn
-f     AST_ADDCOLUMN and AST_REMOVECOLUMN
-*     functions.
-
-*  Applicability:
-*     Table
-*        All Tables have this attribute.
-
-*att--
-*/
-
-/*
-*att++
-*  Name:
-*     Nparameter
-
-*  Purpose:
-*     The number of global parameters in the table.
-
-*  Type:
-*     Public attribute.
-
-*  Synopsis:
-*     Integer, read-only.
-
-*  Description:
-*     This attribute holds the number of global parameters currently in the table.
-*     Parameters are added and removed using the
-c     astAddParameter and astRemoveParameter
-f     AST_ADDPARAMETER and AST_REMOVEPARAMETER
-*     functions.
-
-*  Applicability:
-*     Table
-*        All Tables have this attribute.
-
-*att--
-*/
-
-/*
-*att++
-*  Name:
-*     Nrow
-
-*  Purpose:
-*     The number of rows in the table.
-
-*  Type:
-*     Public attribute.
-
-*  Synopsis:
-*     Integer, read-only.
-
-*  Description:
-*     This attribute holds the index of the last row to which any
-*     contents have been added using any of the
-*     astMapPut...
-*     AST_MAPPUT...
-*     functions. The first row has index 1.
-
-*  Applicability:
-*     Table
-*        All Tables have this attribute.
-
-*att--
-*/
-astMAKE_GET(Table,Nrow,int,0,this->nrow)
-astMAKE_SET(Table,Nrow,int,nrow,value)
-
-
-
-/* Copy constructor. */
-/* ----------------- */
-static void Copy( const AstObject *objin, AstObject *objout, int *status ) {
-/*
-*  Name:
-*     Copy
-
-*  Purpose:
-*     Copy constructor for Table objects.
-
-*  Type:
-*     Private function.
-
-*  Synopsis:
-*     void Copy( const AstObject *objin, AstObject *objout, int *status )
-
-*  Description:
-*     This function implements the copy constructor for Table 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, including a copy of the component
-*     Mappings within the Table.
-*/
-
-/* Local Variables: */
-   AstTable *in;                /* Pointer to input Table */
-   AstTable *out;               /* Pointer to output Table */
-
-/* Check the global error status. */
-   if ( !astOK ) return;
-
-/* Obtain pointers to the input and output Tables. */
-   in = (AstTable *) objin;
-   out = (AstTable *) objout;
-
-/* Make copies of the component KeyMaps and store pointers to them in the
-   output Table structure. */
-   out->columns = in->columns ? astCopy( in->columns ) : NULL;
-   out->parameters = in->parameters ? astCopy( in->parameters ) : NULL;
-}
-
-
-/* Destructor. */
-/* ----------- */
-static void Delete( AstObject *obj, int *status ) {
-/*
-*  Name:
-*     Delete
-
-*  Purpose:
-*     Destructor for Table objects.
-
-*  Type:
-*     Private function.
-
-*  Synopsis:
-*     void Delete( AstObject *obj, int *status )
-
-*  Description:
-*     This function implements the destructor for Table 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: */
-   AstTable *this;              /* Pointer to Table */
-
-/* Obtain a pointer to the Table structure. */
-   this = (AstTable *) obj;
-
-/* Annul the pointers to the component KeyMaps. */
-   if( this->columns ) this->columns = astAnnul( this->columns );
-   if( this->parameters ) this->parameters = astAnnul( this->parameters );
-
-}
-
-
-/* Dump function. */
-/* -------------- */
-static void Dump( AstObject *this_object, AstChannel *channel, int *status ) {
-/*
-*  Name:
-*     Dump
-
-*  Purpose:
-*     Dump function for Table 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 Table class to an output Channel.
-
-*  Parameters:
-*     this
-*        Pointer to the Table 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: */
-   AstTable *this;             /* Pointer to the Table structure */
-
-/* Check the global error status. */
-   if ( !astOK ) return;
-
-/* Obtain a pointer to the Table structure. */
-   this = (AstTable *) this_object;
-
-/* Write out values representing the instance variables for the Table
-   class.  Note, the primitive data in the Table will be written out
-   by the parent KeyMap Dump function. This function deals just with the
-   extra information held in the Table structure. */
-
-/* Write out the number of rows in the table. */
-   astWriteInt( channel, "Nrow", 1, 1, astGetNrow( this ),
-                "Number of rows in table" );
-
-/* Write out the KeyMap holding definitions of each column. */
-   if( this->columns ) {
-      astWriteObject( channel, "Columns", 1, 0, this->columns, "KeyMap holding "
-                      "column definitions" );
-   }
-
-/* Write out the KeyMap holding definitions of each global parameter. */
-   if( this->parameters ) {
-      astWriteObject( channel, "Params", 1, 0, this->parameters, "KeyMap holding "
-                      "parameter definitions" );
-   }
-}
-
-
-
-
-
-
-/* Standard class functions. */
-/* ========================= */
-/* Implement the astIsATable and astCheckTable functions using the macros
-   defined for this purpose in the "object.h" header file. */
-astMAKE_ISA(Table,KeyMap)
-astMAKE_CHECK(Table)
-
-AstTable *astTable_( const char *options, int *status, ...) {
-/*
-*++
-*  Name:
-c     astTable
-f     AST_TABLE
-
-*  Purpose:
-*     Create a Table.
-
-*  Type:
-*     Public function.
-
-*  Synopsis:
-c     #include "table.h"
-c     AstTable *astTable( const char *options, ... )
-f     RESULT = AST_TABLE( OPTIONS, STATUS )
-
-*  Class Membership:
-*     Table constructor.
-
-*  Description:
-*     This function creates a new empty Table and optionally initialises
-*     its attributes.
-*
-*     The Table class is a type of KeyMap that represents a two-dimensional
-*     table of values. The
-c     astMapGet... and astMapPut...
-f     AST_MAPGET... and AST_MAPPUT...
-*     methods provided by the KeyMap class should be used for storing and
-*     retrieving values from individual cells within a Table. Each entry
-*     in the KeyMap represents a single cell of the table and has an
-*     associated key of the form "<COL>(i)" where "<COL>" is the name of a
-*     table column and "i" is the row index (the first row is row 1). Keys
-*     of this form should always be used when using KeyMap methods to access
-*     entries within a Table.
-*
-*     Columns must be declared using the
-c     astAddColumn
-f     AST_ADDCOLUMN
-*     method before values can be stored within them. This also fixes the
-*     type and shape of the values that may be stored in any cell of the
-*     column. Cells may contain scalar or vector values of any data type
-*     supported by the KeyMap class. Multi-dimensional arrays may also be
-*     stored, but these must be vectorised when storing and retrieving
-*     them within a table cell. All cells within a single column must
-*     have the same type and shape (specified when the column is declared).
-*
-*     Tables may have parameters that describe global properties of the
-*     entire table. These are stored as entries in the parent KeyMap and
-*     can be access using the get and set method of the KeyMap class.
-*     However, parameters must be declared using the
-c     astAddParameter
-f     AST_ADDPARAMETER
-*     method before being accessed.
-*
-*     Note - since accessing entries within a KeyMap is a relatively slow
-*     process, it is not recommended to use the Table class to store
-*     very large tables.
-
-*  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 Table. 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 Table. 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     astTable()
-f     AST_TABLE = INTEGER
-*        A pointer to the new Table.
-
-*  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 described above. This
-*     parameter is a pointer to the integer inherited status
-*     variable: "int *status".
-
-*--
-*/
-
-/* Local Variables: */
-   astDECLARE_GLOBALS            /* Pointer to thread-specific global data */
-   AstTable *new;              /* Pointer to new Table */
-   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 Table, allocating memory and initialising the
-   virtual function table as well if necessary. */
-   new = astInitTable( NULL, sizeof( AstTable ), !class_init, &class_vtab,
-                       "Table" );
-
-/* 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 Table'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 Table. */
-   return new;
-}
-
-AstTable *astTableId_( const char *options, ... ) {
-/*
-*  Name:
-*     astTableId_
-
-*  Purpose:
-*     Create a Table.
-
-*  Type:
-*     Private function.
-
-*  Synopsis:
-*     #include "table.h"
-*     AstTable *astTableId_( const char *options, ... )
-
-*  Class Membership:
-*     Table constructor.
-
-*  Description:
-*     This function implements the external (public) interface to the
-*     astTable constructor function. It returns an ID value (instead
-*     of a true C pointer) to external users, and must be provided
-*     because astTable_ 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 astTable_ 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 astTable_.
-
-*  Returned Value:
-*     The ID value associated with the new Table.
-*/
-
-/* Local Variables: */
-   astDECLARE_GLOBALS            /* Pointer to thread-specific global data */
-   AstTable *new;                /* Pointer to new Table */
-   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 Table, allocating memory and initialising the
-   virtual function table as well if necessary. */
-   new = astInitTable( NULL, sizeof( AstTable ), !class_init, &class_vtab,
-                         "Table" );
-
-/* 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 Table'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 Table. */
-   return astMakeId( new );
-}
-
-AstTable *astInitTable_( void *mem, size_t size, int init,
-                         AstTableVtab *vtab, const char *name, int *status ) {
-/*
-*+
-*  Name:
-*     astInitTable
-
-*  Purpose:
-*     Initialise a Table.
-
-*  Type:
-*     Protected function.
-
-*  Synopsis:
-*     #include "table.h"
-*     AstTable *astInitTable( void *mem, size_t size, int init,
-*                                 AstTableVtab *vtab, const char *name )
-
-*  Class Membership:
-*     Table initialiser.
-
-*  Description:
-*     This function is provided for use by class implementations to initialise
-*     a new Table object. It allocates memory (if necessary) to accommodate
-*     the Table plus any additional data associated with the derived class.
-*     It then initialises a Table 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 Table at the start of the memory passed via the
-*     "vtab" parameter.
-
-*  Parameters:
-*     mem
-*        A pointer to the memory in which the Table is to be initialised.
-*        This must be of sufficient size to accommodate the Table data
-*        (sizeof(Table)) 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 Table (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 Table
-*        structure, so a valid value must be supplied even if not required for
-*        allocating memory.
-*     init
-*        A logical flag indicating if the Table'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 Table.
-*     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).
-
-*  Returned Value:
-*     A pointer to the new Table.
-
-*  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: */
-   AstTable *new;              /* Pointer to new Table */
-
-/* Check the global status. */
-   if ( !astOK ) return NULL;
-
-/* If necessary, initialise the virtual function table. */
-   if ( init ) astInitTableVtab( vtab, name );
-
-/* Initialise. */
-   new = NULL;
-
-/* Initialise a KeyMap structure (the parent class) as the first component
-   within the Table structure, allocating memory if necessary. Specify that
-   the KeyMap should be defined in both the forward and inverse directions. */
-   new = (AstTable *) astInitKeyMap( mem, size, 0, (AstKeyMapVtab *) vtab,
-                                     name );
-   if ( astOK ) {
-
-/* Initialise the Table data. */
-/* ---------------------------- */
-      new->nrow = 0;
-      new->columns = astKeyMap( "KeyCase=0,Sortby=AgeDown", status );
-      new->parameters = astKeyMap( "KeyCase=0,Sortby=AgeDown", status );
-
-/* Tables require the KeyCase attribute to be zero. */
-      (*parent_setkeycase)( (AstKeyMap *) new, 0, status );
-
-/* If an error occurred, clean up by deleting the new Table. */
-      if ( !astOK ) new = astDelete( new );
-   }
-
-/* Return a pointer to the new Table. */
-   return new;
-}
-
-AstTable *astLoadTable_( void *mem, size_t size, AstTableVtab *vtab,
-                         const char *name, AstChannel *channel, int *status ) {
-/*
-*+
-*  Name:
-*     astLoadTable
-
-*  Purpose:
-*     Load a Table.
-
-*  Type:
-*     Protected function.
-
-*  Synopsis:
-*     #include "table.h"
-*     AstTable *astLoadTable( void *mem, size_t size, AstTableVtab *vtab,
-*                             const char *name, AstChannel *channel )
-
-*  Class Membership:
-*     Table loader.
-
-*  Description:
-*     This function is provided to load a new Table 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
-*     Table 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 Table at the start of the memory
-*     passed via the "vtab" parameter.
-
-
-*  Parameters:
-*     mem
-*        A pointer to the memory into which the Table is to be
-*        loaded.  This must be of sufficient size to accommodate the
-*        Table data (sizeof(Table)) 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 Table (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 Table 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(AstTable) is used instead.
-*     vtab
-*        Pointer to the start of the virtual function table to be
-*        associated with the new Table. If this is NULL, a pointer
-*        to the (static) virtual function table for the Table 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 "Table" is used instead.
-
-*  Returned Value:
-*     A pointer to the new Table.
-
-*  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: */
-   astDECLARE_GLOBALS            /* Pointer to thread-specific global data */
-   AstTable *new;                /* Pointer to the new Table */
-
-/* Initialise. */
-   new = NULL;
-
-/* Check the global error status. */
-   if ( !astOK ) return new;
-
-/* Get a pointer to the thread specific global data structure. */
-   astGET_GLOBALS(channel);
-
-/* If a NULL virtual function table has been supplied, then this is
-   the first loader to be invoked for this Table. In this case the
-   Table belongs to this class, so supply appropriate values to be
-   passed to the parent class loader (and its parent, etc.). */
-   if ( !vtab ) {
-      size = sizeof( AstTable );
-      vtab = &class_vtab;
-      name = "Table";
-
-/* If required, initialise the virtual function table for this class. */
-      if ( !class_init ) {
-         astInitTableVtab( 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 Table. */
-   new = astLoadKeyMap( mem, size, (AstKeyMapVtab *) vtab, name,
-                         channel );
-
-   if ( astOK ) {
-
-/* Read input data. */
-/* ================ */
-/* Request the input Channel to read all the input data appropriate to
-   this class into the internal "values list". */
-      astReadClassData( channel, "Table" );
-
-/* Now read each individual data item from this list and use it to
-   initialise the appropriate instance variable(s) for this class. */
-
-/* The number of rows. */
-      new->nrow = astReadInt( channel, "nrow", 0 );
-
-/* KeyMap holding columns definitions. */
-      new->columns = astReadObject( channel, "columns", NULL );
-
-/* KeyMap holding parameter definitions. */
-      new->parameters = astReadObject( channel, "params", NULL );
-
-/* If an error occurred, clean up by deleting the new Table. */
-      if ( !astOK ) new = astDelete( new );
-   }
-
-/* Return the new Table 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. */
-
-void astAddColumn_( AstTable *this, const char *name, int type,
-                    int ndim, int *dims, const char *unit, int *status ) {
-   if ( !astOK ) return;
-   (**astMEMBER(this,Table,AddColumn))(this,name,type,ndim,dims,unit,status);
-}
-void astAddParameter_( AstTable *this, const char *name, int *status ) {
-   if ( !astOK ) return;
-   (**astMEMBER(this,Table,AddParameter))(this,name,status);
-}
-void astRemoveColumn_( AstTable *this, const char *name, int *status ){
-   if ( !astOK ) return;
-   (**astMEMBER(this,Table,RemoveColumn))(this,name,status);
-}
-void astRemoveParameter_( AstTable *this, const char *name, int *status ){
-   if ( !astOK ) return;
-   (**astMEMBER(this,Table,RemoveParameter))(this,name,status);
-}
-void astRemoveRow_( AstTable *this, int index, int *status ){
-   if ( !astOK ) return;
-   (**astMEMBER(this,Table,RemoveRow))(this,index,status);
-}
-void astPurgeRows_( AstTable *this, int *status ){
-   if ( !astOK ) return;
-   (**astMEMBER(this,Table,PurgeRows))(this,status);
-}
-int astGetNcolumn_( AstTable *this, int *status ) {
-   if ( !astOK ) return 0;
-   return (**astMEMBER(this,Table,GetNcolumn))( this, status );
-}
-int astGetNparameter_( AstTable *this, int *status ) {
-   if ( !astOK ) return 0;
-   return (**astMEMBER(this,Table,GetNparameter))( this, status );
-}
-const char *astColumnName_( AstTable *this, int index, int *status ){
-   if ( !astOK ) return NULL;
-   return (**astMEMBER(this,Table,ColumnName))(this,index,status);
-}
-const char *astParameterName_( AstTable *this, int index, int *status ){
-   if ( !astOK ) return NULL;
-   return (**astMEMBER(this,Table,ParameterName))(this,index,status);
-}
-int astGetColumnType_( AstTable *this, const char *column, int *status ){
-   if ( !astOK ) return 0;
-   return (**astMEMBER(this,Table,GetColumnType))(this,column,status);
-}
-const char *astGetColumnUnit_( AstTable *this, const char *column, int *status ){
-   if ( !astOK ) return NULL;
-   return (**astMEMBER(this,Table,GetColumnUnit))(this,column,status);
-}
-int astGetColumnLenC_( AstTable *this, const char *column, int *status ){
-   if ( !astOK ) return 0;
-   return (**astMEMBER(this,Table,GetColumnLenC))(this,column,status);
-}
-int astGetColumnLength_( AstTable *this, const char *column, int *status ){
-   if ( !astOK ) return 0;
-   return (**astMEMBER(this,Table,GetColumnLength))(this,column,status);
-}
-int astGetColumnNdim_( AstTable *this, const char *column, int *status ){
-   if ( !astOK ) return 0;
-   return (**astMEMBER(this,Table,GetColumnNdim))(this,column,status);
-}
-void astColumnShape_( AstTable *this, const char *column, int mxdim,
-                      int *ndim, int *dims, int *status ){
-   if ( !astOK ) return;
-   (**astMEMBER(this,Table,ColumnShape))( this, column, mxdim, ndim,
-                                          dims, status );
-}
-AstKeyMap *astColumnProps_( AstTable *this, int *status ){
-   if ( !astOK ) return NULL;
-   return (**astMEMBER(this,Table,ColumnProps))(this,status);
-}
-AstKeyMap *astParameterProps_( AstTable *this, int *status ){
-   if ( !astOK ) return NULL;
-   return (**astMEMBER(this,Table,ParameterProps))(this,status);
-}
-int astHasColumn_( AstTable *this, const char *column, int *status ){
-   if ( !astOK ) return 0;
-   return (**astMEMBER(this,Table,HasColumn))(this,column,status);
-}
-int astHasParameter_( AstTable *this, const char *parameter, int *status ){
-   if ( !astOK ) return 0;
-   return (**astMEMBER(this,Table,HasParameter))(this,parameter,status);
-}