upgrade ast 8.7.1

1 files changed, 3500 insertions, 0 deletions

diff --git a/ast/axis.c b/ast/axis.c
new file mode 100644
index 0000000..6f58b14
--- /dev/null
+++ b/ast/axis.c
@@ -0,0 +1,3500 @@
+/*
+*class++
+*  Name:
+*     Axis
+
+*  Purpose:
+*     Store axis information.
+
+*  Constructor Function:
+*     None.
+
+*  Description:
+*     The Axis class is used to store information associated with a
+*     particular axis of a Frame. It is used internally by the AST
+*     library and has no constructor function. You should encounter it
+c     only within textual output (e.g. from astWrite).
+f     only within textual output (e.g. from AST_WRITE).
+
+*  Inheritance:
+*     The Axis class inherits from the Object class.
+
+*  Copyright:
+*     Copyright (C) 1997-2006 Council for the Central Laboratory of the
+*     Research Councils
+
+*  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:
+*     RFWS: R.F. Warren-Smith (Starlink)
+*     DSB: B.S. Berry (Starlink)
+
+*  History:
+*     1-MAR-1996 (RFWS):
+*        Original version.
+*     10-SEP-1996 (RFWS):
+*        Added I/O facilities.
+*     11-SEP-1996 (RFWS):
+*        Added astAxisGap (written by DSB).
+*     25-FEB-1998 (RFWS):
+*        Added astAxisUnformat.
+*     29-AUG-2001 (DSB):
+*        Added AxisDistance and AxisOffset.
+*     20-OCT-2002 (DSB):
+*        Added Top and Bottom attributes.
+*     8-JAN-2003 (DSB):
+*        - Changed private InitVtab method to protected astInitAxisVtab
+*        method.
+*        - Include descriptive label for units string within a Dump.
+*     24-JAN-2004 (DSB):
+*        - Added astAxisFields.
+*        - Added argument "fmt" to definition of AxisAbbrev.
+*     3-FEB-2004 (DSB):
+*        - Added "log" formatting using the "&" flag character in the
+*        Format string.
+*     15-SEP-2004 (DSB):
+*        - If a format string is set which includes a wildcard precision
+*        value (".*"), then use the Digits value to determine the precision
+*        to be used.
+*        - If the conversion code is of integer type (e.g. "%d") cast value
+*        to integer before printing.
+*     2-FEB-2005 (DSB):
+*        - Avoid using astStore to allocate more storage than is supplied
+*        in the "data" pointer. This can cause access violations since
+*        astStore will then read beyond the end of the "data" area.
+*     15-MAR-2005 (DSB):
+*        - Avoid exponents in log format labels which are close to zero but
+*        not quite zero.
+*     14-FEB-2006 (DSB):
+*        Override astGetObjSize.
+*     30-JUN-2006 (DSB):
+*        Guard against a null "str1" value in AxisAbbrev.
+*     17-APR-2015 (DSB):
+*        Added astAxisCentre.
+*     26-OCT-2016 (DSB):
+*        Added astAxisNormValues.
+*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 Axis
+
+
+/* Header files. */
+/* ============= */
+#include "ast_err.h"             /* Error code definitions */
+
+/* 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"              /* Object interface (parent class) */
+#include "pointset.h"            /* Sets of coordinates (for AST__BAD) */
+#include "channel.h"             /* I/O channels */
+#include "axis.h"                /* Interface definition for this class */
+#include "unit.h"                /* Definitions of physical units */
+#include "globals.h"             /* Thread-safe global data access */
+
+/* C header files. */
+/* --------------- */
+#include <ctype.h>
+#include <errno.h>
+#include <float.h>
+#include <limits.h>
+#include <math.h>
+#include <stdarg.h>
+#include <stddef.h>
+#include <stdio.h>
+#include <stdlib.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 int (* parent_getobjsize)( AstObject *, int * );
+static const char *(* parent_getattrib)( AstObject *, const char *, int * );
+static int (* parent_testattrib)( AstObject *, const char *, int * );
+static void (* parent_clearattrib)( AstObject *, const char *, int * );
+static void (* parent_setattrib)( AstObject *, const char *, int * );
+
+/* Plain text equivalents. */
+static const char *log_txt  = "10^";
+
+/* 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->GetDefaultFormat_Buff[ 0 ] = 0; \
+   globals->AxisFormat_Buff[ 0 ] = 0; \
+   globals->GetAxisNormUnit_Buff[ 0 ] = 0; \
+   globals->GetAttrib_Buff[ 0 ] = 0;
+
+/* Create the function that initialises global data for this module. */
+astMAKE_INITGLOBALS(Axis)
+
+/* Define macros for accessing each item of thread specific global data. */
+#define class_init astGLOBAL(Axis,Class_Init)
+#define class_vtab astGLOBAL(Axis,Class_Vtab)
+#define getdefaultformat_buff astGLOBAL(Axis,GetDefaultFormat_Buff)
+#define axisformat_buff astGLOBAL(Axis,AxisFormat_Buff)
+#define getaxisnormunit_buff astGLOBAL(Axis,GetAxisNormUnit_Buff)
+#define getattrib_buff astGLOBAL(Axis,GetAttrib_Buff)
+
+
+
+/* If thread safety is not needed, declare and initialise globals at static
+   variables. */
+#else
+
+static char getdefaultformat_buff[ AST__AXIS_GETDEFAULTFORMAT_BUFF_LEN + 1 ];
+static char axisformat_buff[ AST__AXIS_GETDEFAULTFORMAT_BUFF_LEN + 1 ];
+static char getaxisnormunit_buff[ AST__AXIS_GETAXISNORMUNIT_BUFF_LEN + 1 ];
+static char getattrib_buff[ AST__AXIS_GETATTRIB_BUFF_LEN + 1 ];
+
+
+/* Define the class virtual function table and its initialisation flag
+   as static variables. */
+static AstAxisVtab 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. */
+AstAxis *astAxisId_( const char *, ... );
+
+/* Prototypes for Private Member Functions. */
+/* ======================================== */
+static const char *AxisAbbrev( AstAxis *, const char *, const char *, const char *, int * );
+static const char *AxisFormat( AstAxis *, double, int * );
+static int GetObjSize( AstObject *, int * );
+static const char *GetAttrib( AstObject *, const char *, int * );
+static const char *GetAxisFormat( AstAxis *, int * );
+static const char *GetAxisLabel( AstAxis *, int * );
+static const char *GetAxisSymbol( AstAxis *, int * );
+static const char *GetAxisUnit( AstAxis *, int * );
+static const char *GetAxisInternalUnit( AstAxis *, int * );
+static const char *GetAxisNormUnit( AstAxis *, int * );
+static const char *GetDefaultFormat( AstAxis *, int * );
+static char *ParseAxisFormat( const char *, int, int *, int *, int *, int *, int * );
+static double AxisDistance( AstAxis *, double, double, int * );
+static double AxisCentre( AstAxis *, double, double, int * );
+static double AxisGap( AstAxis *, double, int *, int * );
+static double AxisOffset( AstAxis *, double, double, int * );
+static int AxisFields( AstAxis *, const char *, const char *, int, char **, int *, double *, int * );
+static int AxisIn( AstAxis *, double, double, double, int, int * );
+static int AxisUnformat( AstAxis *, const char *, double *, int * );
+static int GetAxisDigits( AstAxis *, int * );
+static int GetAxisDirection( AstAxis *, int * );
+static int TestAttrib( AstObject *, const char *, int * );
+static int TestAxisDigits( AstAxis *, int * );
+static int TestAxisDirection( AstAxis *, int * );
+static int TestAxisFormat( AstAxis *, int * );
+static int TestAxisLabel( AstAxis *, int * );
+static int TestAxisSymbol( AstAxis *, int * );
+static int TestAxisUnit( AstAxis *, int * );
+static int TestAxisInternalUnit( AstAxis *, int * );
+static int TestAxisNormUnit( AstAxis *, int * );
+static void AxisNorm( AstAxis *, double *, int * );
+static void AxisNormValues( AstAxis *, int, int, double *, int * );
+static void AxisOverlay( AstAxis *, AstAxis *, int * );
+static void ClearAttrib( AstObject *, const char *, int * );
+static void ClearAxisDigits( AstAxis *, int * );
+static void ClearAxisDirection( AstAxis *, int * );
+static void ClearAxisFormat( AstAxis *, int * );
+static void ClearAxisLabel( AstAxis *, int * );
+static void ClearAxisSymbol( AstAxis *, int * );
+static void ClearAxisUnit( AstAxis *, int * );
+static void Copy( const AstObject *, AstObject *, int * );
+static void Delete( AstObject *, int * );
+static void Dump( AstObject *, AstChannel *, int * );
+static void SetAttrib( AstObject *, const char *, int * );
+static void SetAxisDigits( AstAxis *, int, int * );
+static void SetAxisDirection( AstAxis *, int, int * );
+static void SetAxisFormat( AstAxis *, const char *, int * );
+static void SetAxisLabel( AstAxis *, const char *, int * );
+static void SetAxisSymbol( AstAxis *, const char *, int * );
+static void SetAxisUnit( AstAxis *, const char *, int * );
+
+static double GetAxisTop( AstAxis *, int * );
+static int TestAxisTop( AstAxis *, int * );
+static void ClearAxisTop( AstAxis *, int * );
+static void SetAxisTop( AstAxis *, double, int * );
+
+static double GetAxisBottom( AstAxis *, int * );
+static int TestAxisBottom( AstAxis *, int * );
+static void ClearAxisBottom( AstAxis *, int * );
+static void SetAxisBottom( AstAxis *, double, int * );
+
+
+/* Member functions. */
+/* ================= */
+static const char *AxisAbbrev( AstAxis *this, const char *fmt,
+                               const char *str1, const char *str2, int *status ) {
+/*
+*+
+*  Name:
+*     astAxisAbbrev
+
+*  Purpose:
+*     Abbreviate a formatted Axis value by skipping leading fields.
+
+*  Type:
+*     Protected virtual function.
+
+*  Synopsis:
+*     #include "axis.h"
+*     const char *astAxisAbbrev( AstAxis *this, const char *fmt,
+*                                const char *str1, const char *str2 )
+
+*  Class Membership:
+*     Axis method.
+
+*  Description:
+*     This function compares two Axis values that have been formatted
+*     (using astAxisFormat) and determines if they have any redundant
+*     leading fields (i.e. leading fields in common which can be
+*     suppressed when tabulating the values or plotting them on the
+*     axis of a graph).
+
+*  Parameters:
+*     this
+*        Pointer to the Axis.
+*     fmt
+*        Pointer to a constant null-terminated string containing the
+*        format specifier used to format the two values.
+*     str1
+*        Pointer to a constant null-terminated string containing the
+*        first formatted value. If this is null, the returned pointer
+*        points to the start of the final field in str2.
+*     str2
+*        Pointer to a constant null-terminated string containing the
+*        second formatted value.
+
+*  Returned Value:
+*     A pointer into the "str2" string which locates the first
+*     character in the first field that differs between the two
+*     formatted values.
+*
+*     If the two values have no leading fields in common, the returned
+*     value will point at the start of string "str2". If the two
+*     values are equal, it will point at the terminating null at the
+*     end of this string.
+
+*  Notes:
+*     - This function assumes that the format specification used was
+*     the same when both values were formatted.
+*     - A pointer to the start of "str2" will be returned if this
+*     function is invoked with the global error status set, or if it
+*     should fail for any reason.
+*-
+*/
+
+/* Local Variables: */
+   const char *result;           /* Result pointer to return */
+
+/* Initialise. */
+   result = str2;
+
+/* Check the global error status. */
+   if ( !astOK ) return result;
+
+/* In the Axis class, there is only one field in a formatted value.
+   We return the value of "str2", unless the two strings are
+   identical, in which case we return a pointer to the final null in
+   "str2". */
+   if( str1 && !strcmp( str1, str2 ) ) result += strlen( str2 );
+
+/* Return the result. */
+   return result;
+}
+
+static double AxisDistance( AstAxis *this, double v1, double v2, int *status ) {
+/*
+*+
+*  Name:
+*     astAxisDistance
+
+*  Purpose:
+*     Find the distance between two axis values.
+
+*  Type:
+*     Protected virtual function.
+
+*  Synopsis:
+*     #include "axis.h"
+*     AxisDistance( AstAxis *this, double v1, double v2 )
+
+*  Class Membership:
+*     Axis method.
+
+*  Description:
+*     This function returns a signed value representing the axis increment
+*     from axis value v1 to axis value v2.
+*
+*     For a simple Axis, this is a trivial operation. But for other
+*     derived classes of Axis (such as a SkyAxis) this is not the case.
+
+*  Parameters:
+*     this
+*        Pointer to the Axis.
+*     v1
+*        The first axis value
+*     v2
+*        The second axis value
+
+*  Returned Value:
+*     The axis increment from v1 to v2.
+
+*  Notes:
+*     - A value of AST__BAD is returned if either axis value is AST__BAD.
+*     - A value of AST__BAD will be returned if this function is invoked
+*     with the global error status set, or if it should fail for any
+*     reason.
+*-
+*/
+
+/* Local Variables: */
+   double result;                /* Returned gap size */
+
+/* Initialise. */
+   result = AST__BAD;
+
+/* Check the global error status. */
+   if ( !astOK ) return result;
+
+/* Check both axis values are OK, and form the returned increment. */
+   if( v1 != AST__BAD && v2 != AST__BAD ) result = v2 - v1;
+
+/* Return the result. */
+   return result;
+}
+
+static int AxisFields( AstAxis *this, const char *fmt0, const char *str,
+                       int maxfld, char **fields, int *nc, double *val, int *status ) {
+/*
+*+
+*  Name:
+*     astAxisFields
+
+*  Purpose:
+*     Identify numerical fields within a formatted Axis value.
+
+*  Type:
+*     Protected virtual function.
+
+*  Synopsis:
+*     #include "axis.h"
+*     int astAxisFields( AstAxis *this, const char *fmt0, const char *str,
+*                        int maxfld, char **fields, int *nc, double *val )
+
+*  Class Membership:
+*     Axis member function.
+
+*  Description:
+*     This function identifies the numerical fields within an Axis value
+*     that have been formatted using astAxisFormat. It assumes that the
+*     value was formatted using the supplied format string. It also
+*     returns the equivalent floating point value.
+
+*  Parameters:
+*     this
+*        Pointer to the Axis.
+*     fmt0
+*        Pointer to a constant null-terminated string containing the
+*        format used when creating "str".
+*     str
+*        Pointer to a constant null-terminated string containing the
+*        formatted value.
+*     maxfld
+*        The maximum number of fields to identify within "str".
+*     fields
+*        A pointer to an array of at least "maxfld" character pointers.
+*        Each element is returned holding a pointer to the start of the
+*        corresponding field  in "str" (in the order in which they occur
+*        within "str"), or NULL if no corresponding field can be found.
+*     nc
+*        A pointer to an array of at least "maxfld" integers. Each
+*        element is returned holding the number of characters in the
+*        corresponding field, or zero if no corresponding field can be
+*        found.
+*     val
+*        Pointer to a location at which to store the value
+*        equivalent to the returned field values. If this is NULL,
+*        it is ignored.
+
+*  Returned Value:
+*     The number of fields succesfully identified and returned.
+
+*  Notes:
+*     - Leading and trailing spaces are ignored.
+*     - If the formatted value is not consistent with the supplied format
+*     string, then a value of zero will be returned, "fields" will be
+*     returned holding NULLs, "nc" will be returned holding zeros, and
+*     "val" is returned holding VAL__BAD.
+*     - Fields are counted from the start of the formatted string. If the
+*     string contains more than "maxfld" fields, then trailing fields are
+*     ignored.
+*     - If this function is invoked with the global error status set, or
+*     if it should fail for any reason, then a value of zero will be returned
+*     as the function value, and "fields", "nc" and "val"  will be returned
+*     holding their supplied values
+*-
+*/
+
+/* Local Variables: */
+   char log_esc[ 50 ];           /* Buffer for graphical delimiter string */
+   const char *fmt;              /* Pointer to parsed Format string */
+   const char *log_del;          /* Pointer to delimiter string */
+   const char *p;                /* Pointer to next character */
+   double value;                 /* Equivalent radians value */
+   int ifld;                     /* Field index */
+   int integ;                    /* Cast axis value to integer before printing? */
+   int len;                      /* Length of formatted string */
+   int log;                      /* Format as "10**x"? */
+   int n;                        /* Number of characters read */
+   int neg;                      /* Negate final value? */
+   int result;                   /* Result fields count to return */
+   int sign;                     /* Include leading sign in front of "10**x"? */
+   int space;                    /* Include leading space in front of "10**x"? */
+
+/* Check the global error status. */
+   if ( !astOK ) return 0;
+
+/* Initialise. */
+   result = 0;
+   for( ifld = 0; ifld < maxfld; ifld++ ) {
+      fields[ ifld ] = NULL;
+      nc[ ifld ] = 0;
+   }
+   if( val ) *val = AST__BAD;
+
+/* Parse the Format string. This returns a collection of flags indicating
+   if any AST specific formatting features are specified in the Format
+   string. It also returns a pointer to a new Format string which is a
+   standard C printf format specifier. Currently the only flags are "log"
+   which indicates if the value should be formatted as "10**x" using
+   the graphical escape sequences defined within the Plot class to produce
+   "x" as a superscript of "10", "sign" which is used with log to indicate
+   if a sign should always be included infront of the "10", and "space"
+   which indicates if a leading space should be included infronyt of "10" if
+   no sign is included. */
+   fmt = ParseAxisFormat( fmt0, astGetAxisDigits( this ), &log, &sign,
+                          &space, &integ, status );
+   fmt = astFree( (void *) fmt );
+
+   if( astOK ) {
+
+/* Obtain the length of the formatted string. */
+      len = (int) strlen( str );
+
+/* First deal with "log" format. */
+      if( log ) {
+
+/* We need room for at least 2 fields. */
+         if( maxfld > 1 ) {
+
+/* Return a pointer to the first non-blank character. */
+            p = str;
+            while( *p == ' ' ) p++;
+            fields[ 0 ] = (char *) p;
+
+/* If the first non-blank character is a minus sign, note it and skip it. */
+            neg = 0;
+            if( *p == '-' ) {
+               neg = 1;
+               p++;
+
+/* If the first non-blank character is a plus sign, and skip it. */
+            } else if( *p == '+' ) {
+               p++;
+            }
+
+/* Select the delimter.*/
+            if(  astEscapes( -1 ) ) {
+               astTuneC( "exdel", NULL, log_esc, sizeof( log_esc ) );
+               log_del = log_esc;
+            } else {
+               log_del = log_txt;
+            }
+
+/* Check the remaining string starts with the correct delimiter. If
+   so, store the number of characters in the first field and skip over the
+   delimiter. */
+            n = 0;
+            if( strstr( p, log_del ) == p ) {
+               nc[ 0 ] = p + 2  - fields[ 0 ];
+               p += strlen( log_del );
+
+/* Attempt to read a floating point value from the start of the remaining
+   string. */
+               if( 1 == sscanf( p, "%lg%n", &value, &n ) ) {
+
+/* If succesfull, store the returned values. */
+                  result = 2;
+                  fields[ 1 ] = (char *) p;
+                  nc[ 1 ] = n;
+                  if( val ) {
+                     *val = pow( 10.0, value );
+                     if( neg ) *val = -(*val);
+                  }
+
+/* Otherwise, see if the string starts with <bad> */
+               } else if( strstr( p, "<bad>" ) == p ) {
+
+/* If succesfull, store the returned values. */
+                  result = 2;
+                  fields[ 1 ] = (char *) p;
+                  nc[ 1 ] = 5;
+                  if( val ) *val = 0.0;
+               }
+
+/* Zero is never formatted as an exponent. If the string starts with zero,
+   return a single zero field. */
+            } else if( 1 == sscanf( p, "%lg%n", &value, &n ) ) {
+               if( value == 0.0 ) {
+                  result = 1;
+                  nc[ 0 ] = p + n  - fields[ 0 ];
+                  if( val ) *val = 0.0;
+               }
+            }
+         }
+
+/* Now deal with normal decimal format */
+      } else {
+
+/* Attempt to read a floating point value from the formatted string. */
+         if ( n = 0,
+              ( 1 == sscanf( str, "%lg %n", &value, &n ) )
+              && ( n >= len ) && maxfld > 0 ) {
+
+/* If succesful, return a pointer to the first non-blank character. */
+            p = str;
+            while( *p == ' ' ) p++;
+            fields[ 0 ] = (char *) p;
+
+/* Find the last non-blank character. */
+            p += len;
+            while( p[ -1 ] == ' ' ) p--;
+
+/* Return the number of characters in the field. */
+            nc[ 0 ] = p - fields[ 0 ];
+
+/* Return the field value. */
+            if( val ) *val = value;
+
+/* Indicate that we are returning one field. */
+            result = 1;
+         }
+      }
+   }
+
+/* Return the result. */
+   return result;
+}
+
+static const char *AxisFormat( AstAxis *this, double value, int *status ) {
+/*
+*+
+*  Name:
+*     astAxisFormat
+
+*  Purpose:
+*     Format a coordinate value for an Axis.
+
+*  Type:
+*     Public virtual function.
+
+*  Synopsis:
+*     #include "axis.h"
+*     const char *astAxisFormat( AstAxis *this, double value )
+
+*  Class Membership:
+*     Axis method.
+
+*  Description:
+*     This function returns a pointer to a string containing the formatted
+*     (character) version of a coordinate value for an Axis. The formatting
+*     applied is that specified by a previous invocation of the
+*     astSetAxisFormat method. A suitable default format is applied if
+*     necessary.
+
+*  Parameters:
+*     this
+*        Pointer to the Axis.
+*     value
+*        The coordinate value to be formatted.
+
+*  Returned Value:
+*     A pointer to a null-terminated string containing the formatted value.
+
+*  Notes:
+*     -  The returned string pointer may point at memory allocated within
+*     the Axis object, 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 deletion of the Axis. 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 Constants: */
+#define ERRBUF_LEN 80
+
+/* Local Variables: */
+   astDECLARE_GLOBALS           /* Pointer to thread-specific global data */
+   char *errstat;               /* Pointer for system error message */
+   char errbuf[ ERRBUF_LEN ];   /* Buffer for system error message */
+   char log_esc[ 50 ];          /* Buffer for graphical delimiter string */
+   const char *fmt0;            /* Pointer to original Format string */
+   const char *fmt;             /* Pointer to parsed Format string */
+   const char *log_del;         /* Pointer to delimiter string */
+   const char *result;          /* Pointer to formatted value */
+   double x;                    /* The value to be formatted by sprintf */
+   int integ;                   /* Cast axis value to integer before printing? */
+   int log;                     /* Format as "10**x"? */
+   int nc;                      /* Total number of characters written */
+   int ncc;                     /* Number of characters written */
+   int sign;                    /* Include leading sign in front of "10**x"? */
+   int space;                   /* Include leading space in front of "10**x"? */
+   int stat;                    /* Value of errno after error */
+
+/* Check the global error status. */
+   if ( !astOK ) return NULL;
+
+/* Get a pointer to the thread specific global data structure. */
+   astGET_GLOBALS(this);
+
+/* Initialise. */
+   result = NULL;
+   nc = 0;
+   x = value;
+
+/* Check if a bad coordinate value was supplied and return a pointer to an
+   appropriate string if necessary. */
+   if ( value == AST__BAD ) {
+      result = "<bad>";
+
+/* Otherwise, obtain a pointer to the Format string. Note a private member
+   function is used here in preference to an object method. This is because the
+   syntax of the Format string may be extended by derived classes and we do not
+   want to obtain a string that we cannot interpret here (where we are
+   restricted to C format specifiers capable of formatting double values).
+   Classes that extend the syntax should provide their own astAxisFormat method
+   and may need to store the string in a separate location. The original
+   location should not be re-used as the string it contains may be needed by
+   the Axis astOverlay method when overlaying attributes on to another Axis
+   object. */
+   } else {
+      fmt0 = GetAxisFormat( this, status );
+
+/* Parse the Format string. This returns a collection of flags indicating
+   if any AST specific formatting features are specified in the Format
+   string. It also returns a pointer to a new Format string which is a
+   standard C printf format specifier. Currently the only flags are "log"
+   which indicates if the value should be formatted as "10**x" using
+   the graphical escape sequences defined within the Plot class to produce
+   "x" as a superscript of "10", "sign" which is used with log to indicate
+   if a sign should always be included infront of the "10", and "space"
+   which indicates if a leading space should be included infronyt of "10"
+   if no sign is included. It also modifies ".*" precision fields by
+   replacing the "*" by the current vale of the Digits attribute. */
+      fmt = ParseAxisFormat( fmt0, astGetAxisDigits( this ), &log, &sign,
+                             &space, &integ, status );
+      if( astOK ) {
+
+/* Format zero normally. */
+         if( value == 0.0 ) log = 0;
+
+/* If log format is required, find the value of the exponent "x", and
+   initialise the returned string to hold the exponent and the graphical
+   escape sequence which produces a superscript. Otherwise just format the
+   supplied value. */
+         if( log ) {
+
+            if( sign ) {
+               axisformat_buff[ 0 ] ='+';
+               nc = 1;
+
+            } else if( space ) {
+               axisformat_buff[ 0 ] =' ';
+               nc = 1;
+            }
+
+            if( value > 0 ) {
+               x = log10( integ ? (int) value : value );
+
+            } else {
+               x = log10( integ ? (int) -value : -value );
+               axisformat_buff[ 0 ] ='-';
+               nc = 1;
+            }
+
+            if(  astEscapes( -1 ) ) {
+               astTuneC( "exdel", NULL, log_esc, sizeof( log_esc ) );
+               log_del = log_esc;
+            } else {
+               log_del = log_txt;
+            }
+
+            nc += sprintf( axisformat_buff + nc, "%s", log_del );
+
+/* Round small exponents to zero. */
+            if( fabs( x ) < 1.0E-10 ) x = 0.0;
+         }
+      }
+
+/* Clear errno and attempt to format the value as if the Format string were
+   a standard "sprintf" format. */
+      if ( astOK ) {
+         errno = 0;
+         if( integ ) {
+            ncc = sprintf( axisformat_buff + nc, fmt, (int) x );
+         } else {
+            ncc = sprintf( axisformat_buff + nc, fmt, x );
+         }
+         nc += ncc;
+
+/* If log format is being used, terminate the string with an escape
+   sequence which resets the graphical attributes to what they were at the
+   start of the string. */
+         if( log ) nc += sprintf( axisformat_buff + nc, "%%+" );
+
+/* The possibilities for error detection are limited here, but check if an
+   error value was returned and report an error. Include information from
+   errno if it was set. */
+         if ( ncc < 0 ) {
+            stat = errno;
+            if( stat ) {
+#if HAVE_STRERROR_R
+               strerror_r( stat, errbuf, ERRBUF_LEN );
+               errstat = errbuf;
+#else
+               errstat = strerror( stat );
+#endif
+            } else {
+               *errbuf = 0;
+               errstat = errbuf;
+            }
+            astError( AST__FMTER, "astAxisFormat(%s): Error formatting a "
+                      "coordinate value of %1.*G%s%s.", status, astGetClass( this ),
+                      AST__DBL_DIG, value, stat? " - " : "", errstat );
+            astError( AST__FMTER, "The format string was \"%s\".", status, fmt );
+
+/* Also check that the result buffer did not overflow. If it did, memory will
+   probably have been corrupted but this cannot be prevented with "sprintf".
+   Report the error and abort. */
+         } else if ( nc > AST__AXIS_AXISFORMAT_BUFF_LEN ) {
+            astError( AST__FMTER, "astAxisFormat(%s): Internal buffer "
+                      "overflow while formatting a coordinate value of %1.*G "
+                      "- result exceeds %d characters.", status, astGetClass( this ),
+                      AST__DBL_DIG, value, AST__AXIS_AXISFORMAT_BUFF_LEN );
+            astError( AST__FMTER, "The format string was \"%s\".", status, fmt );
+
+/* If succesfull, return a pointer to the buffer. */
+         } else {
+            result = axisformat_buff;
+         }
+      }
+
+/* Free resources. */
+      fmt = astFree( (void *) fmt );
+
+   }
+
+/* Return the result. */
+   return result;
+
+}
+#undef ERRBUF_LEN
+
+static double AxisCentre( AstAxis *this, double value, double gap, int *status ) {
+/*
+*+
+*  Name:
+*     astAxisCentre
+
+*  Purpose:
+*     Find a "nice" central value for tabulating Axis values.
+
+*  Type:
+*     Protected virtual function.
+
+*  Synopsis:
+*     #include "axis.h"
+*     double astAxisCentre( AstAxis *this, double value, double gap )
+
+*  Class Membership:
+*     Axis method.
+
+*  Description:
+*     This function returns an axis value which produces a nice formatted
+*     value suitable for a major tick mark on a plot axis.
+
+*  Parameters:
+*     this
+*        Pointer to the Axis.
+*     value
+*        An arbitrary axis value in the section that is being plotted.
+*     gap
+*        The gap size.
+
+*  Returned Value:
+*     The nice central axis value.
+
+*  Notes:
+*     - A value of zero is returned if the supplied gap size is zero.
+*     - 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: */
+   double result;                /* Returned central axis value */
+
+/* Initialise. */
+   result = 0.0;
+
+/* Check the global error status. */
+   if ( !astOK ) return result;
+
+/* The returned central value is an integral number of gaps away from the
+   origin and is close to the supplied axis value. This would result in
+   the origin being at a major tick mark. */
+   if( gap != 0.0 && gap != AST__BAD && value != AST__BAD ) {
+      result = gap*floor( 0.5 + value/gap );
+   }
+
+/* Return the result. */
+   return result;
+}
+
+static double AxisGap( AstAxis *this, double gap, int *ntick, int *status ) {
+/*
+*+
+*  Name:
+*     astAxisGap
+
+*  Purpose:
+*     Find a "nice" gap for tabulating Axis values.
+
+*  Type:
+*     Protected virtual function.
+
+*  Synopsis:
+*     #include "axis.h"
+*     double astAxisGap( AstAxis *this, double gap, int *ntick )
+
+*  Class Membership:
+*     Axis method.
+
+*  Description:
+*     This function returns a gap size which produces a nicely spaced
+*     series of formatted Axis values, the returned gap size being as
+*     close as possible to the supplied target gap size. It also
+*     returns a convenient number of divisions into which the gap can
+*     be divided.
+
+*  Parameters:
+*     this
+*        Pointer to the Axis.
+*     gap
+*        The target gap size.
+*     ntick
+*        Address of an int in which to return a convenient number of
+*        divisions into which the gap can be divided.
+
+*  Returned Value:
+*     The nice gap size.
+
+*  Notes:
+*     - A value of zero is returned if the supplied gap size is zero.
+*     - A negative gap size is returned if the supplied gap size is negative.
+*     - 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: */
+   double absgap;                /* Absolute supplied gap size */
+   double b;                     /* Decimal step size */
+   double result;                /* Returned gap size */
+   int index;                    /* Index into tables */
+   int positive;                 /* Value is positive (or zero)? */
+
+/* Local Data: */
+   static double table1[ 10 ] =  /* Table of nice decimal gaps */
+            { 1.0, 2.0, 2.0, 5.0, 5.0, 5.0, 5.0, 10.0, 10.0, 10.0 };
+   static int table2[ 10 ] =     /* Table giving number of divisions */
+            {   5,   4,   4,   5,   5,   5,   5,    5,    5,    5 };
+
+/* Initialise. */
+   result = 0.0;
+
+/* Check the global error status. */
+   if ( !astOK ) return result;
+
+/* Check that the supplied gap size is not zero. */
+   if ( gap != 0.0 ) {
+
+/* Determine if the supplied gap size is positive and obtain its
+   absolute value. */
+      positive = ( gap >= 0.0 );
+      absgap = positive ? gap : -gap;
+
+/* Obtain a value which has a 1 at the position of the most
+   significant decimal digit in the target gap size and zeros at all
+   other positions. */
+      b = pow( 10.0, floor( log10( absgap ) ) );
+
+/* This value is the basic "step size". Find the nearest whole number
+   of steps in the supplied gap, and then use the look-up-table in
+   "table1" to find the closest acceptable gap size. Convert this gap
+   size back to an absolute value by multiplying by the step size. */
+      index = (int) ( absgap / b + 0.5 ) - 1;
+      result = b * table1[ index ];
+
+/* If the target gap was negative, negate the result. */
+      if( !positive ) result = -result;
+
+/* Store the number of divisions in the gap. */
+      if ( ntick ) *ntick = table2[ index ];
+   }
+
+/* Return the result. */
+   return result;
+}
+
+static int AxisIn( AstAxis *this, double lo, double hi, double val, int closed, int *status ){
+/*
+*+
+*  Name:
+*     astAxisIn
+
+*  Purpose:
+*     Test if an axis value lies within a given interval.
+
+*  Type:
+*     Protected virtual function.
+
+*  Synopsis:
+*     #include "axis.h"
+*     int AxisIn( AstAxis *this, double lo, double hi, double val, int closed )
+
+*  Class Membership:
+*     Axis member function.
+
+*  Description:
+*     This function returns non-zero if a given axis values lies within a
+*     given axis interval.
+
+*  Parameters:
+*     this
+*        Pointer to the Axis.
+*     lo
+*        The lower axis limit of the interval.
+*     hi
+*        The upper axis limit of the interval.
+*     val
+*        The axis value to be tested.
+*     closed
+*        If non-zero, then the lo and hi axis values are themselves
+*        considered to be within the interval. Otherwise they are outside.
+
+*  Returned Value:
+*     Non-zero if the test value is inside the interval.
+
+*  Class Applicability:
+*     Axis
+*        Uses simple Euclidean test
+*     SkyAxis
+*        All angles which are numerically between "lo" and "hi" are within
+*        the interval. Angle outside this range are also within the interval
+*        if they can be brought into the range by addition or subtraction
+*        of a multiple of 2.PI.
+*-
+*/
+
+/* For speed, omit the astOK check since no pointers are being used. */
+   if( closed ) {
+      return ( lo <= val && val <= hi );
+   } else {
+      return ( lo < val && val < hi );
+   }
+}
+
+static void AxisNorm( AstAxis *this, double *value, int *status ) {
+/*
+*+
+*  Name:
+*     astAxisNorm
+
+*  Purpose:
+*     Normalise an Axis coordinate value.
+
+*  Type:
+*     Public virtual function.
+
+*  Synopsis:
+*     #include "axis.h"
+*     void astAxisNorm( AstAxis *this, double *value )
+
+*  Class Membership:
+*     Axis method.
+
+*  Description:
+*     This function converts an Axis coordinate value which might
+*     potentially be unsuitable for display to a user (for instance,
+*     may lie outside the expected range of values) into an acceptable
+*     alternative value suitable for display.
+*
+*     Typically, for axes that represent cyclic values such as angles,
+*     this function wraps an arbitrary coordinate value so that it
+*     lies within the first cycle (say zero to 2*pi). For an ordinary
+*     linear Axis, without constraints, this function will typically
+*     return the original value unchanged.
+
+*  Parameters:
+*     this
+*        Pointer to the Axis.
+*     value
+*        Pointer to the coordinate value to be normalised, which will
+*        be modified in place.
+*-
+*/
+
+/* In the Axis class there are no constraints, so simply return
+   without action. */
+   return;
+}
+
+static void AxisNormValues( AstAxis *this, int oper, int nval,
+                            double *values, int *status ){
+/*
+*+
+*  Name:
+*     astAxisNormValues
+
+*  Purpose:
+*     Normalise an array of axis coordinate values.
+
+*  Type:
+*     Public virtual function.
+
+*  Synopsis:
+*     #include "axis.h"
+*     void astAxisNormValues( AstAxis *this, int oper, int nval,
+*                             double *values )
+
+*  Class Membership:
+*     Axis method.
+
+*  Description:
+*     This function modifies a supplied array of axis values so that
+*     they are normalised in the manner indicated by parameter "oper".
+*
+*     For a simple axis, the supplied values are always returned
+*     unchanged regardless of the value of "oper".
+
+*  Parameters:
+*     this
+*        Pointer to the Axis.
+*     oper
+*        Indicates the type of normalisation to be applied. If zero is
+*        supplied, the normalisation will be the same as that performed by
+*        function astAxisNorm. If 1 is supplied, the normalisation will be
+*        chosen automatically so that the resulting list has the smallest
+*        range.
+*     nval
+*        The number of points in the values array.
+*     values
+*        On entry, the axis values to be normalised. Modified on exit to
+*        hold the normalised values.
+*-
+*/
+
+/* In the Axis class there are no constraints, so simply return
+   without action. */
+   return;
+}
+
+static double AxisOffset( AstAxis *this, double v1, double dist, int *status ) {
+/*
+*+
+*  Name:
+*     astAxisOffset
+
+*  Purpose:
+*     Add an increment onto a supplied axis value.
+
+*  Type:
+*     Protected virtual function.
+
+*  Synopsis:
+*     #include "axis.h"
+*     AxisOffset( AstAxis *this, double v1, double dist )
+
+*  Class Membership:
+*     Axis method.
+
+*  Description:
+*     This function returns an axis value formed by adding a signed axis
+*     increment onto a supplied axis value.
+*
+*     For a simple Axis, this is a trivial operation. But for other
+*     derived classes of Axis (such as a SkyAxis) this is not the case.
+
+*  Parameters:
+*     this
+*        Pointer to the Axis.
+*     v1
+*        The supplied axis value
+*     dist
+*        The axis increment
+
+*  Returned Value:
+*     The axis value which is the specified increment away from v1.
+
+*  Notes:
+*     - A value of AST__BAD is returned if either axis value is AST__BAD.
+*     - A value of AST__BAD will be returned if this function is invoked
+*     with the global error status set, or if it should fail for any
+*     reason.
+*-
+*/
+
+/* Local Variables: */
+   double result;                /* Returned gap size */
+
+/* Initialise. */
+   result = AST__BAD;
+
+/* Check the global error status. */
+   if ( !astOK ) return result;
+
+/* Check both axis values are OK, and form the returned axis value. */
+   if( v1 != AST__BAD && dist != AST__BAD ) result = v1 + dist;
+
+/* Return the result. */
+   return result;
+}
+
+static void AxisOverlay( AstAxis *template, AstAxis *result, int *status ) {
+/*
+*+
+*  Name:
+*     astAxisOverlay
+
+*  Purpose:
+*     Overlay the attributes of a template Axis on to another Axis.
+
+*  Type:
+*     Protected virtual function.
+
+*  Synopsis:
+*     #include "axis.h"
+*     void astAxisOverlay( AstAxis *template, AstAxis *result )
+
+*  Class Membership:
+*     Axis method.
+
+*  Description:
+*     This function overlays attributes of one Axis (the "template") on to
+*     another Axis, so as to over-ride selected attributes of that second
+*     Axis. Normally only those attributes which have been specifically set
+*     in the template will be transferred. This implements a form of
+*     defaulting, in which an Axis acquires attributes from the template, but
+*     retains its original attributes (as the default) if new values have not
+*     previously been explicitly set in the template.
+
+*  Parameters:
+*     template
+*        Pointer to the template Axis, for which values should have been
+*        explicitly set for any attribute which is to be transferred.
+*     result
+*        Pointer to the Axis which is to receive the new attribute values.
+
+*  Returned Value:
+*     void
+*-
+*/
+
+/* Check the global error status. */
+   if ( !astOK ) return;
+
+/* Define a macro to overlay a single attribute. This tests if the attribute
+   is set in the template Axis. If it is, its value is obtained and set in the
+   result Axis also. */
+#define OVERLAY(par) \
+   if ( astTestAxis##par( template ) ) { \
+      astSetAxis##par( result, astGetAxis##par( template ) ); \
+   }
+/* Overlay each Axis attribute in turn. */
+   OVERLAY(Digits);
+   OVERLAY(Direction);
+   OVERLAY(Label);
+   OVERLAY(Symbol);
+   OVERLAY(Unit);
+
+/* Handle the Format string slightly differently by using a private member
+   function to obtain it. This is necessary in case derived classes have
+   extended the string syntax (see the AxisFormat function for more
+   details). */
+   if ( TestAxisFormat( template, status ) ) {
+      SetAxisFormat( result, GetAxisFormat( template, status ), status );
+   }
+
+/* Undefine macros local to this function. */
+#undef OVERLAY
+}
+
+static int AxisUnformat( AstAxis *this, const char *string, double *value, int *status ) {
+/*
+*+
+*  Name:
+*     astAxisUnformat
+
+*  Purpose:
+*     Read a formatted coordinate value for an Axis.
+
+*  Type:
+*     Public virtual function.
+
+*  Synopsis:
+*     #include "axis.h"
+*     int astAxisUnformat( AstAxis *this, const char *string, double *value )
+
+*  Class Membership:
+*     Axis method.
+
+*  Description:
+*     This function reads a formatted coordinate value for an Axis
+*     (supplied as a string) and returns the equivalent numerical
+*     value as a double. It also returns the number of characters read
+*     from the string.
+
+*  Parameters:
+*     this
+*        Pointer to the Axis.
+*     string
+*        Pointer to a constant null-terminated string containing the
+*        formatted coordinate value.
+*     value
+*        Pointer to a double in which the coordinate value read will be
+*        returned.
+
+*  Returned Value:
+*     The number of characters read from the string to obtain the
+*     coordinate value.
+
+*  Notes:
+*     - Any white space at the beginning of the string will be
+*     skipped, as also will any trailing white space following the
+*     coordinate value read. The function's return value will reflect
+*     this.
+*     - A function value of zero (and no coordinate value) will be
+*     returned, without error, if the string supplied does not contain
+*     a suitably formatted value.
+*     - The string "<bad>" is recognised as a special case and will
+*     generate the value AST__BAD, without error. The test for this
+*     string is case-insensitive and permits embedded white space.
+*     - A function result of zero will be returned and no coordinate
+*     value will be returned via the "value" pointer if this function
+*     is invoked with the global error status set, or if it should
+*     fail for any reason.
+*-
+*/
+
+/* Local Variables: */
+   double coord;                 /* Coordinate value read */
+   int nc;                       /* Number of characters read */
+
+/* Initialise. */
+   nc = 0;
+
+/* Check the global error status. */
+   if ( !astOK ) return nc;
+
+/* See if the string can be read as a floating point number. If so,
+   return its value. Also obtain the number of characters read,
+   including any leading and trailing white space. */
+   if ( 1 == astSscanf( string, "%lf %n", &coord, &nc ) ) {
+      *value = coord;
+
+/* Otherwise, see if the string starts with "<bad>", allowing mixed
+   case and leading, embedded and trailing white space. If so, return
+   the value AST__BAD. */
+   } else if ( nc = 0,
+               ( 0 == astSscanf( string, " < %*1[Bb] %*1[Aa] %*1[Dd] > %n", &nc )
+               && ( nc > 0 ) ) ) {
+      *value = AST__BAD;
+
+/* If the string cannot be read, return a function result of zero. */
+   } else {
+      nc = 0;
+   }
+
+/* Return the number of characters read. */
+   return nc;
+}
+
+static void ClearAttrib( AstObject *this_object, const char *attrib, int *status ) {
+/*
+*  Name:
+*     ClearAttrib
+
+*  Purpose:
+*     Clear an attribute value for an Axis.
+
+*  Type:
+*     Private function.
+
+*  Synopsis:
+*     #include "axis.h"
+*     void ClearAttrib( AstObject *this, const char *attrib, int *status )
+
+*  Class Membership:
+*     Axis member function (over-rides the astClearAttrib protected
+*     method inherited from the Object class).
+
+*  Description:
+*     This function clears the value of a specified attribute for an
+*     Axis, so that the default value will subsequently be used.
+
+*  Parameters:
+*     this
+*        Pointer to the Axis.
+*     attrib
+*        Pointer to a null-terminated string specifying the attribute
+*        name.  This should be in lower case with no surrounding white
+*        space.
+*     status
+*        Pointer to the inherited status variable.
+*/
+
+/* Local Variables: */
+   AstAxis *this;                /* Pointer to the Axis structure */
+
+/* Check the global error status. */
+   if ( !astOK ) return;
+
+/* Obtain a pointer to the Axis structure. */
+   this = (AstAxis *) this_object;
+
+/* Check the attribute name and clear the appropriate attribute. */
+
+/* Digits. */
+/* ------- */
+   if ( !strcmp( attrib, "digits" ) ) {
+      astClearAxisDigits( this );
+
+/* Direction. */
+/* ---------- */
+   } else if ( !strcmp( attrib, "direction" ) ) {
+      astClearAxisDirection( this );
+
+/* Format. */
+/* ------- */
+   } else if ( !strcmp( attrib, "format" ) ) {
+      astClearAxisFormat( this );
+
+/* Label. */
+/* ------ */
+   } else if ( !strcmp( attrib, "label" ) ) {
+      astClearAxisLabel( this );
+
+/* Top. */
+/* ---- */
+   } else if ( !strcmp( attrib, "top" ) ) {
+      astClearAxisTop( this );
+
+/* Bottom. */
+/* ------- */
+   } else if ( !strcmp( attrib, "bottom" ) ) {
+      astClearAxisBottom( this );
+
+/* Symbol. */
+/* ------- */
+   } else if ( !strcmp( attrib, "symbol" ) ) {
+      astClearAxisSymbol( this );
+
+/* Unit. */
+/* ----- */
+   } else if ( !strcmp( attrib, "unit" ) ) {
+      astClearAxisUnit( this );
+
+/* Read-only attributes. */
+/* --------------------- */
+/* Test if the attribute name matches any of the read-only attributes
+   of this class. If it does, then report an error. */
+   } else if ( !strcmp( attrib, "normunit" ) ||
+               !strcmp( attrib, "internalunit" ) ) {
+      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 );
+   }
+}
+
+static const char *GetAxisInternalUnit( AstAxis *this, int *status ){
+/*
+*+
+*  Name:
+*     astGetAxisInternalUnit
+
+*  Purpose:
+*     Return the unit string for unformatted Axis values
+
+*  Type:
+*     Protected virtual function.
+
+*  Synopsis:
+*     #include "axis.h"
+*     const char *astGetAxisInternalUnit( AstAxis *this ){
+
+*  Class Membership:
+*     Axis method.
+
+*  Description:
+*     This function returns the axis InternalUnit attribute. For basic
+*     axes, the InternalUnit and Unit attributes are the same.
+
+*  Parameters:
+*     this
+*        Pointer to the Axis.
+
+*  Returned Value:
+*     - Pointer to a null-terminated string containing the internal
+*     unit string.
+
+*  Notes:
+*     - The returned pointer points to a static memory buffer. The
+*     contents of this buffer will be over-written on each invocation of
+*     this function. A copy of the returned string should therefore be
+*     taken if it will be needed later.
+*     - 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.
+*-
+*/
+   return astGetAxisUnit( this );
+}
+
+static const char *GetAxisNormUnit( AstAxis *this, int *status ){
+/*
+*+
+*  Name:
+*     astGetAxisNormUnit
+
+*  Purpose:
+*     Return the normalised Unit attribute for an Axis.
+
+*  Type:
+*     Protected virtual function.
+
+*  Synopsis:
+*     #include "axis.h"
+*     const char *astGetAxisNormUnit( AstAxis *this ){
+
+*  Class Membership:
+*     Axis method.
+
+*  Description:
+*     This function normalised and returns the axis Unit attribute.
+*     Normalisation refers to transformations such as "s*(m/s)" -> "m".
+
+*  Parameters:
+*     this
+*        Pointer to the Axis.
+
+*  Returned Value:
+*     - Pointer to a null-terminated string containing the normalised
+*     unit string.
+
+*  Notes:
+*     - The returned pointer points to a static memory buffer. The
+*     contents of this buffer will be over-written on each invocation of
+*     this function. A copy of the returned string should therefore be
+*     taken if it will be needed later.
+*     - 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 */
+   const char *result;       /* Pointer to dynamic memory holding returned text */
+   int nc;                   /* Length of normalised Unit string */
+
+/* Check the global error status. */
+   if ( !astOK ) return NULL;
+
+/* Get a pointer to the thread specific global data structure. */
+   astGET_GLOBALS(this);
+
+/* Get the Axis Unit attrribute and normalise it. */
+   result = astUnitNormaliser( astGetAxisUnit( this ) );
+
+/* If successful, check that the resulting string will fit in the buffer.
+   If not, report an error. */
+   if( result ) {
+      nc = strlen( result );
+      if( nc > AST__AXIS_GETAXISNORMUNIT_BUFF_LEN ) {
+         astError( AST__FMTER, "astGetAxisNormUnit(%s): Internal buffer "
+                      "overflow while normalising the units string '%s' "
+                      "- result exceeds %d characters.", status, astGetClass( this ),
+                      result, AST__AXIS_GETAXISNORMUNIT_BUFF_LEN );
+         result = astFree( (void *) result );
+
+/* If so, copy it into the static buffer and free the dynamic memory returned
+   by astUnitNormaliser. */
+      } else {
+         strcpy( getaxisnormunit_buff, result );
+      }
+      astFree( (void *) result );
+
+      result = getaxisnormunit_buff;
+   }
+
+/* Return the answer. */
+   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 "axis.h"
+*     int GetObjSize( AstObject *this, int *status )
+
+*  Class Membership:
+*     Axis member function (over-rides the astGetObjSize protected
+*     method inherited from the parent class).
+
+*  Description:
+*     This function returns the in-memory size of the supplied Axis,
+*     in bytes.
+
+*  Parameters:
+*     this
+*        Pointer to the Axis.
+*     status
+*        Pointer to the inherited status variable.
+
+*  Returned Value:
+*     The Object size, in bytes.
+
+*  Notes:
+*     - A value of zero will be returned if this function is invoked
+*     with the global status set, or if it should fail for any reason.
+*/
+
+/* Local Variables: */
+   AstAxis *this;             /* Pointer to Axis structure */
+   int result;                /* Result value to return */
+
+/* Initialise. */
+   result = 0;
+
+/* Check the global error status. */
+   if ( !astOK ) return result;
+
+/* Obtain a pointers to the Axis structure. */
+   this = (AstAxis *) this_object;
+
+/* Invoke the GetObjSize method inherited from the parent class, and then
+   add on any components of the class structure defined by thsi class
+   which are stored in dynamically allocated memory. */
+   result = (*parent_getobjsize)( this_object, status );
+
+   result += astTSizeOf( this->label );
+   result += astTSizeOf( this->format );
+   result += astTSizeOf( this->symbol );
+   result += astTSizeOf( this->unit );
+
+/* 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 an Axis.
+
+*  Type:
+*     Private function.
+
+*  Synopsis:
+*     #include "axis.h"
+*     const char *GetAttrib( AstObject *this, const char *attrib, int *status )
+
+*  Class Membership:
+*     Axis member function (over-rides the protected astGetAttrib
+*     method inherited from the Object class).
+
+*  Description:
+*     This function returns a pointer to the value of a specified
+*     attribute for an Axis, formatted as a character string.
+
+*  Parameters:
+*     this
+*        Pointer to the Axis.
+*     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 Axis, 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 Axis. 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 */
+   AstAxis*this;                 /* Pointer to the Axis structure */
+   const char *result;           /* Pointer value to return */
+   double dval;                  /* Double attribute value */
+   int digits;                   /* Digits attribute value */
+   int direction;                /* Direction attribute value */
+
+/* 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 Axis structure. */
+   this = (AstAxis *) this_object;
+
+/* Compare "attrib" with each recognised attribute name in turn,
+   obtaining the value of the required attribute. If necessary, write
+   the value into "getattrib_buff" as a null-terminated string in an
+   appropriate format.  Set "result" to point at the result string. */
+
+/* Digits. */
+/* ------- */
+   if ( !strcmp( attrib, "digits" ) ) {
+      digits = astGetAxisDigits( this );
+      if ( astOK ) {
+         (void) sprintf( getattrib_buff, "%d", digits );
+         result = getattrib_buff;
+      }
+
+/* Direction. */
+/* ---------- */
+   } else if ( !strcmp( attrib, "direction" ) ) {
+      direction = astGetAxisDirection( this );
+      if ( astOK ) {
+         (void) sprintf( getattrib_buff, "%d", direction );
+         result = getattrib_buff;
+      }
+
+/* Top. */
+/* ---- */
+   } else if ( !strcmp( attrib, "top" ) ) {
+      dval = astGetAxisTop( this );
+      if ( astOK ) {
+         (void) sprintf( getattrib_buff, "%.*g", AST__DBL_DIG, dval );
+         result = getattrib_buff;
+      }
+
+/* Bottom. */
+/* ------- */
+   } else if ( !strcmp( attrib, "bottom" ) ) {
+      dval = astGetAxisBottom( this );
+      if ( astOK ) {
+         (void) sprintf( getattrib_buff, "%.*g", AST__DBL_DIG, dval );
+         result = getattrib_buff;
+      }
+
+/* Format. */
+/* ------- */
+   } else if ( !strcmp( attrib, "format" ) ) {
+      result = astGetAxisFormat( this );
+
+/* Label. */
+/* ------ */
+   } else if ( !strcmp( attrib, "label" ) ) {
+      result = astGetAxisLabel( this );
+
+/* Symbol. */
+/* ------- */
+   } else if ( !strcmp( attrib, "symbol" ) ) {
+      result = astGetAxisSymbol( this );
+
+/* Unit. */
+/* ----- */
+   } else if ( !strcmp( attrib, "unit" ) ) {
+      result = astGetAxisUnit( this );
+
+/* NormUnit. */
+/* --------- */
+   } else if ( !strcmp( attrib, "normunit" ) ) {
+      result = astGetAxisNormUnit( this );
+
+/* InternalUnit. */
+/* ------------- */
+   } else if ( !strcmp( attrib, "internalunit" ) ) {
+      result = astGetAxisInternalUnit( this );
+
+/* 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 const char *GetDefaultFormat( AstAxis *this, int *status ){
+/*
+*  Name:
+*     GetDefaultFormat
+
+*  Purpose:
+*     Return a pointer to a string holding the default Format value.
+
+*  Type:
+*     Private function.
+
+*  Synopsis:
+*     #include "axis.h"
+*     const char *GetDefaultFormat( AstAxis *this, int *status )
+
+*  Class Membership:
+*     Axis member function
+
+*  Description:
+*     This function returns a pointer to a string holding the default
+*     Format value, which is based on the current Digits value.
+
+*  Parameters:
+*     this
+*        A pointer to the Axis structure.
+*     status
+*        Pointer to the inherited status variable.
+
+*  Returned Value:
+*     - Pointer to a static null-terminated character string containing
+*     the default Format string.
+
+*  Notes:
+*     - A null string 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 */
+
+/* Check the global error status. */
+   if ( !astOK ) return "";
+
+/* Get a pointer to the thread specific global data structure. */
+   astGET_GLOBALS(this);
+
+/* Create the default format value and store it in the "format_buff"
+   static variable. */
+   (void) sprintf( getdefaultformat_buff, "%%1.%dG", astGetAxisDigits( this ) );
+
+/* Return a pointer to the "format_buff" static variable. */
+   return getdefaultformat_buff;
+}
+
+void astInitAxisVtab_(  AstAxisVtab *vtab, const char *name, int *status ) {
+/*
+*+
+*  Name:
+*     astInitAxisVtab
+
+*  Purpose:
+*     Initialise a virtual function table for an Axis.
+
+*  Type:
+*     Protected function.
+
+*  Synopsis:
+*     #include "axis.h"
+*     void astInitAxisVtab( AstAxisVtab *vtab, const char *name )
+
+*  Class Membership:
+*     Axis vtab initialiser.
+
+*  Description:
+*     This function initialises the component of a virtual function
+*     table which is used by the Axis class.
+
+*  Parameters:
+*     vtab
+*        Pointer to the virtual function table. The components used by
+*        all ancestral classes will be initialised if they have not already
+*        been initialised.
+*     name
+*        Pointer to a constant null-terminated character string which contains
+*        the name of the class to which the virtual function table belongs (it
+*        is this pointer value that will subsequently be returned by the Object
+*        astClass function).
+*-
+*/
+
+/* Local Variables: */
+   astDECLARE_GLOBALS            /* Pointer to thread-specific global data */
+   AstObjectVtab *object;        /* Pointer to Object component of Vtab */
+
+/* Check the local error status. */
+   if ( !astOK ) return;
+
+/* Get a pointer to the thread specific global data structure. */
+   astGET_GLOBALS(NULL);
+
+/* Initialize the component of the virtual function table used by the
+   parent class. */
+   astInitObjectVtab( (AstObjectVtab *) vtab, name );
+
+/* Store a unique "magic" value in the virtual function table. This
+   will be used (by astIsAAxis) to determine if an object belongs
+   to this class.  We can conveniently use the address of the (static)
+   class_check variable to generate this unique value. */
+   vtab->id.check = &class_check;
+   vtab->id.parent = &(((AstObjectVtab *) vtab)->id);
+
+/* Initialise member function pointers. */
+/* ------------------------------------ */
+/* Store pointers to the member functions (implemented here) that provide
+   virtual methods for this class. */
+   vtab->AxisAbbrev = AxisAbbrev;
+   vtab->AxisFields = AxisFields;
+   vtab->AxisFormat = AxisFormat;
+   vtab->AxisDistance = AxisDistance;
+   vtab->AxisOffset = AxisOffset;
+   vtab->AxisCentre = AxisCentre;
+   vtab->AxisGap = AxisGap;
+   vtab->AxisIn = AxisIn;
+   vtab->AxisNorm = AxisNorm;
+   vtab->AxisNormValues = AxisNormValues;
+   vtab->AxisOverlay = AxisOverlay;
+   vtab->AxisUnformat = AxisUnformat;
+   vtab->ClearAxisDigits = ClearAxisDigits;
+   vtab->ClearAxisDirection = ClearAxisDirection;
+   vtab->ClearAxisFormat = ClearAxisFormat;
+   vtab->ClearAxisLabel = ClearAxisLabel;
+   vtab->ClearAxisSymbol = ClearAxisSymbol;
+   vtab->ClearAxisUnit = ClearAxisUnit;
+   vtab->GetAxisDigits = GetAxisDigits;
+   vtab->GetAxisDirection = GetAxisDirection;
+   vtab->GetAxisFormat = GetAxisFormat;
+   vtab->GetAxisLabel = GetAxisLabel;
+   vtab->GetAxisSymbol = GetAxisSymbol;
+   vtab->GetAxisUnit = GetAxisUnit;
+   vtab->GetAxisInternalUnit = GetAxisInternalUnit;
+   vtab->GetAxisNormUnit = GetAxisNormUnit;
+   vtab->SetAxisDigits = SetAxisDigits;
+   vtab->SetAxisDirection = SetAxisDirection;
+   vtab->SetAxisFormat = SetAxisFormat;
+   vtab->SetAxisLabel = SetAxisLabel;
+   vtab->SetAxisSymbol = SetAxisSymbol;
+   vtab->SetAxisUnit = SetAxisUnit;
+   vtab->TestAxisDigits = TestAxisDigits;
+   vtab->TestAxisDirection = TestAxisDirection;
+   vtab->TestAxisFormat = TestAxisFormat;
+   vtab->TestAxisLabel = TestAxisLabel;
+   vtab->TestAxisSymbol = TestAxisSymbol;
+   vtab->TestAxisUnit = TestAxisUnit;
+   vtab->TestAxisInternalUnit = TestAxisInternalUnit;
+   vtab->TestAxisNormUnit = TestAxisNormUnit;
+
+   vtab->ClearAxisTop = ClearAxisTop;
+   vtab->GetAxisTop = GetAxisTop;
+   vtab->SetAxisTop = SetAxisTop;
+   vtab->TestAxisTop = TestAxisTop;
+
+   vtab->ClearAxisBottom = ClearAxisBottom;
+   vtab->GetAxisBottom = GetAxisBottom;
+   vtab->SetAxisBottom = SetAxisBottom;
+   vtab->TestAxisBottom = TestAxisBottom;
+
+/* Save the inherited pointers to methods that will be extended, and replace
+   them with pointers to the new member functions. */
+   object = (AstObjectVtab *) vtab;
+
+   parent_clearattrib = object->ClearAttrib;
+   parent_getobjsize = object->GetObjSize;
+   object->GetObjSize = GetObjSize;
+   object->ClearAttrib = ClearAttrib;
+   parent_getattrib = object->GetAttrib;
+   object->GetAttrib = GetAttrib;
+   parent_setattrib = object->SetAttrib;
+   object->SetAttrib = SetAttrib;
+   parent_testattrib = object->TestAttrib;
+   object->TestAttrib = TestAttrib;
+
+/* Declare the destructor, copy constructor and dump function. */
+   astSetDelete( vtab, Delete );
+   astSetCopy( vtab, Copy );
+   astSetDump( vtab, Dump, "Axis", "Coordinate axis" );
+
+/* If we have just initialised the vtab for the current class, indicate
+   that the vtab is now initialised, and store a pointer to the class
+   identifier in the base "object" level of the vtab. */
+   if( vtab == &class_vtab ) {
+      class_init = 1;
+      astSetVtabClassIdentifier( vtab, &(vtab->id) );
+   }
+}
+
+static char *ParseAxisFormat( const char *fmt0, int digs, int *log, int *sign,
+                              int *lspace, int *integ, int *status ){
+/*
+*  Name:
+*     ParseAxisFormat
+
+*  Purpose:
+*     Parse the Format string for an Axis.
+
+*  Type:
+*     Private function.
+
+*  Synopsis:
+*     #include "axis.h"
+*     char *ParseAxisFormat( const char *fmt0, int digs, int *log, int *sign,
+*                            int *lspace, int *integ, int *status )
+
+*  Class Membership:
+*     Axis member function
+
+*  Description:
+*     This function returns a collection of flags indicating if any AST
+*     specific formatting features are specified in the supplied Format
+*     string. It also returns a pointer to a new Format string which is a
+*     standard C printf format specifier.
+
+*  Parameters:
+*     fmt0
+*        The value of the Format attribute.
+*     digs
+*        The default number of digits of precision to use. This is used
+*        if the given format specifier includes a wildcard precision (".*").
+*        In this case, the returned format specifier will be modified to
+*        include an explicit precision value equal to the supplied value
+*        of "digs".
+*     log
+*        Pointer to an integer in which to store a flag indicating if the
+*        if the axis value should be formatted as "10**x" using the graphical
+*        escape sequences defined within the Plot class to produce "x" as a
+*        superscript of "10". A non-zero value will be returned if the
+*        supplied Format string has a '&' character in its printf <flags>
+*        field (that is, between the leading '%' sign and the optional
+*        printf field width).
+*     sign
+*        Pointer to an integer in which to store a flag indicating if a
+*        sign character ('+' or '-') should always be included in front
+*        of the "10" if "log" is returned non-zero. If "log" is returned
+*        zero, then "sign" will also be zero. If "log" is non-zero, then
+*        a non-zero value for "sign" will be returned if the supplied Format
+*        string has a '+' character in its printf <flags> field (that is,
+*        between the leading '%' sign and the optional printf field width).
+*     lspace
+*        Pointer to an integer in which to store a flag indicating if a
+*        leading space should be included in front of the "10" if "log" is
+*        returned non-zero and "sign" is returned zero. Otherwise, "lspace"
+*        will also be zero. If "log" is non-zero, then a non-zero value for
+*        "lspace" will be returned if the supplied Format string has a ' '
+*        character in its printf <flags> field (that is, between the leading
+*        '%' sign and the optional printf field width).
+*     integ
+*        Pointer to an integer in which to store a flag indicating if the
+*        returned format specifier includes an integer conversion code
+*        (e.g. %d) or floating point conversion code (e.g. "%.7G").
+*     status
+*        Pointer to the inherited status variable.
+
+*  Returned Value:
+*     - Pointer to a dynamically allocated null-terminated string containing
+*     the modified Format string. This will be a copy of the supplied
+*     Format string, but with any '&' flag removed. Any '+' or ' ' flag will
+*     also be removed if "log" is returned as non-zero. An explicit
+*     precision field will be included if the supplied format includes a
+*     ".*" precision field.
+
+*  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: */
+   char *a;             /* Pointer to next char read from original format */
+   char *b;             /* Pointer to next char to write to new format */
+   char *c;             /* Pointer to next char read from original format */
+   char *new;           /* Pointer to new returned string */
+   char *perc;          /* Pointer to percent sign */
+   char *result;        /* Pointer to the returned string */
+   int hash;            /* Was a '#' flag found? */
+   int len;             /* Used length of format string */
+   int minus;           /* Was a '-' flag found? */
+   int plus;            /* Was a '+' flag found? */
+   int rlen;            /* Length of result */
+   int space;           /* Was a ' ' flag found? */
+
+/* Initialise. */
+   result = NULL;
+   *log = 0;
+   *sign = 0;
+   *lspace = 0;
+   *integ = 0;
+
+/* Check the global error status. */
+   if ( !astOK ) return result;
+
+/* Take a copy of the supplied string. Check the pointer can be used
+   safely. */
+   len = astChrLen( fmt0 );
+   result = astStore( NULL, fmt0, len + 1 );
+   if( astOK ) {
+      result[ len ] = 0;
+
+/* Find the first percent sign. Do nothing if none is found. */
+      perc = strchr( result, '%' );
+      if( perc ) {
+
+/* Check each character following the percent sign until one is found
+   which is not a legal printf flag, or a legal AST extension flag. Note
+   which ones are present. */
+         minus = 0;
+         plus = 0;
+         space = 0;
+         hash = 0;
+
+         a = perc;
+         while( ++a ){
+            if( *a == '-' ){
+               minus = 1;
+            } else if( *a == '+' ){
+               plus = 1;
+            } else if( *a == ' ' ){
+               space = 1;
+            } else if( *a == '#' ){
+               hash = 1;
+            } else if( *a == '&' ){
+               *log = 1;
+            } else {
+               break;
+            }
+         }
+
+/* If no '&' flag was found just return the unaltered copy of the
+   supplied Format string. Otherwise, remove any '+' or ' ' flag. */
+         if( *log ) {
+            if( plus ) *sign = 1;
+            if( space ) *lspace = 1;
+
+/* Append any remaining flag characters to the output string. */
+            perc++;
+            if( minus ) *(perc++) = '-';
+            if( hash ) *(perc++) = '#';
+
+/* Copy the remaining characters down to fill up the gap left by the
+   removed flags. */
+            while( *a ) *(perc++) = *(a++);
+
+/* Terminate the returned string. */
+            *perc = 0;
+
+         }
+      }
+   }
+
+/* If the format specifier being returned does include a ".*" precision,
+   replace the "*" with the value of the Digits attribute. */
+   if( result ) {
+
+/* Find the first percent sign. Do nothing if none is found. */
+      a = strchr( result, '%' );
+      if( a ) {
+
+/* Check each character following the percent sign until one is found
+   which is not a legal printf flag. */
+         while( ++a ){
+            if( *a != '-' && *a != '+' && *a != ' ' && *a != '#' ) break;
+         }
+
+/* Skip any field width (a decimal integer) following the flags. */
+         a--;
+         while( ++a ) {
+            if( !isdigit( *a ) ) break;
+         }
+
+/* Get a pointer to the next alphabetic character. This will be the
+   conversion code. If it an integer code, return *integ non-zero. */
+         c = a - 1;
+         while( ++c ) {
+            if( isalpha( *c ) ) {
+               if( *c == 'd' || *c == 'i' || *c == 'u' || *c == 'o' ||
+                   *c == 'x' || *c == 'X' || *c == 'c' ) *integ = 1;
+               break;
+            }
+         }
+
+/* Go back to the end of the field width. If the next two characters are
+   "." and "*", change the asterisk to the supplied "digs" value. */
+         if( a[ 0 ] == '.' && a[ 1 ] == '*' ) {
+
+/* Allocate memory to hold the extended format string (allowing 20
+   characters for formatting the digs value - just in case something like
+   INT_MAX is supplied by mistake), and store the existing string in it. */
+            rlen = strlen( result );
+            new = astMalloc( rlen + 22 );
+            if( new ) memcpy( new, result, rlen + 1 );
+
+/* Put the precision into the new string, following the field width. */
+            b = new + ( a - result );
+            b += sprintf( b, ".%d", digs );
+
+/* Copy the remainder of the original format string to the new format
+   string. */
+            if( a[ 2 ] != 0 ) strcpy( b, a + 2 );
+
+/* Use the new format string in place of the old.*/
+            astFree( result );
+            result = new;
+         }
+      }
+   }
+
+/* Return the result. */
+   return result;
+
+}
+
+static void SetAttrib( AstObject *this_object, const char *setting, int *status ) {
+/*
+*  Name:
+*     SetAttrib
+
+*  Purpose:
+*     Set an attribute value for an Axis.
+
+*  Type:
+*     Private function.
+
+*  Synopsis:
+*     #include "axis.h"
+*     void SetAttrib( AstObject *this, const char *setting, int *status )
+
+*  Class Membership:
+*     Axis member function (over-rides the protected astSetAttrib
+*     method inherited from the Object class).
+
+*  Description:
+*     This function assigns an attribute value for an Axis, 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 Axis.
+*     setting
+*        Pointer to a null terminated string specifying the new
+*        attribute value.
+*     status
+*        Pointer to the inherited status variable.
+*/
+
+/* Local Variables: */
+   AstAxis *this;                /* Pointer to Axis structure */
+   double dval;                  /* Double attribute value */
+   int digits;                   /* Number of digits of precision */
+   int direction;                /* Plot axis in normal direction? */
+   int format;                   /* Offset of Format string */
+   int label;                    /* Offset of Label string */
+   int len;                      /* Length of setting string */
+   int nc;                       /* Number of characters read from setting */
+   int symbol;                   /* Offset of Symbol string */
+   int unit;                     /* Offset of Unit string */
+
+/* Check the global error status. */
+   if ( !astOK ) return;
+
+/* Obtain a pointer to the Axis structure. */
+   this = (AstAxis *) 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. */
+
+/* Digits. */
+/* ------- */
+   if ( nc = 0,
+        ( 1 == astSscanf( setting, "digits= %d %n", &digits, &nc ) )
+        && ( nc >= len ) ) {
+      astSetAxisDigits( this, digits );
+
+/* Direction. */
+/* ---------- */
+   } else if ( nc = 0,
+        ( 1 == astSscanf( setting, "direction= %d %n", &direction, &nc ) )
+        && ( nc >= len ) ) {
+      astSetAxisDirection( this, direction );
+
+/* Top. */
+/* ---- */
+   } else if ( nc = 0,
+        ( 1 == astSscanf( setting, "top= %lg %n", &dval, &nc ) )
+        && ( nc >= len ) ) {
+      astSetAxisTop( this, dval );
+
+/* Bottom. */
+/* ------- */
+   } else if ( nc = 0,
+        ( 1 == astSscanf( setting, "bottom= %lg %n", &dval, &nc ) )
+        && ( nc >= len ) ) {
+      astSetAxisBottom( this, dval );
+
+/* Format. */
+/* ------- */
+   } else if ( nc = 0,
+        ( 0 == astSscanf( setting, "format=%n%*[^\n]%n", &format, &nc ) )
+        && ( nc >= len ) ) {
+      astSetAxisFormat( this, setting + format );
+
+/* Label. */
+/* ------ */
+   } else if ( nc = 0,
+        ( 0 == astSscanf( setting, "label=%n%*[^\n]%n", &label, &nc ) )
+        && ( nc >= len ) ) {
+      astSetAxisLabel( this, setting + label );
+
+/* Symbol. */
+/* ------- */
+   } else if ( nc = 0,
+        ( 0 == astSscanf( setting, "symbol=%n%*[^\n]%n", &symbol, &nc ) )
+        && ( nc >= len ) ) {
+      astSetAxisSymbol( this, setting + symbol );
+
+/* Unit. */
+/* ----- */
+   } else if ( nc = 0,
+        ( 0 == astSscanf( setting, "unit=%n%*[^\n]%n", &unit, &nc ) )
+        && ( nc >= len ) ) {
+      astSetAxisUnit( this, setting + unit );
+
+/* Read-only attributes. */
+/* --------------------- */
+/* 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 ) )
+
+/* Use this macro to report an error if a read-only attribute has been
+   specified. */
+   } else if ( MATCH( "normunit" ) ||
+               MATCH( "internalunit" ) ) {
+      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);
+
+/* Pass any unrecognised attribute setting to the parent method for further
+   interpretation. */
+   } else {
+      (*parent_setattrib)( this_object, setting, status );
+   }
+
+/* Undefine macros local to this function. */
+#undef MATCH
+}
+
+static int TestAttrib( AstObject *this_object, const char *attrib, int *status ) {
+/*
+*  Name:
+*     TestAttrib
+
+*  Purpose:
+*     Test if a specified attribute value is set for an Axis.
+
+*  Type:
+*     Private function.
+
+*  Synopsis:
+*     #include "axis.h"
+*     int TestAttrib( AstObject *this, const char *attrib, int *status )
+
+*  Class Membership:
+*     Axis member function (over-rides the astTestAttrib protected
+*     method inherited from the Object class).
+
+*  Description:
+*     This function returns a boolean result (0 or 1) to indicate
+*     whether a value has been set for one of an Axis' attributes.
+
+*  Parameters:
+*     this
+*        Pointer to the Axis.
+*     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: */
+   AstAxis *this;                /* Pointer to the Axis structure */
+   int result;                   /* Result value to return */
+
+/* Initialise. */
+   result = 0;
+
+/* Check the global error status. */
+   if ( !astOK ) return result;
+
+/* Obtain a pointer to the Axis structure. */
+   this = (AstAxis *) this_object;
+
+/* Check the attribute name and test the appropriate attribute. */
+
+/* Digits. */
+/* ------- */
+   if ( !strcmp( attrib, "digits" ) ) {
+      result = astTestAxisDigits( this );
+
+/* Direction. */
+/* ---------- */
+   } else if ( !strcmp( attrib, "direction" ) ) {
+      result = astTestAxisDirection( this );
+
+/* Top. */
+/* ---- */
+   } else if ( !strcmp( attrib, "top" ) ) {
+      result = astTestAxisTop( this );
+
+/* Bottom. */
+/* ------- */
+   } else if ( !strcmp( attrib, "bottom" ) ) {
+      result = astTestAxisBottom( this );
+
+/* Format. */
+/* ------- */
+   } else if ( !strcmp( attrib, "format" ) ) {
+      result = astTestAxisFormat( this );
+
+/* Label. */
+/* ------ */
+   } else if ( !strcmp( attrib, "label" ) ) {
+      result = astTestAxisLabel( this );
+
+/* Symbol. */
+/* ------- */
+   } else if ( !strcmp( attrib, "symbol" ) ) {
+      result = astTestAxisSymbol( this );
+
+/* Unit. */
+/* ----- */
+   } else if ( !strcmp( attrib, "unit" ) ) {
+      result = astTestAxisUnit( this );
+
+/* InternalUnit. */
+/* --------- */
+   } else if ( !strcmp( attrib, "internalunit" ) ) {
+      result = astTestAxisInternalUnit( this );
+
+/* NormUnit. */
+/* --------- */
+   } else if ( !strcmp( attrib, "normunit" ) ) {
+      result = astTestAxisNormUnit( this );
+
+/* If the attribute is still not recognised, pass it on to the parent
+   method for further interpretation. */
+   } else {
+      result = (*parent_testattrib)( this_object, attrib, status );
+   }
+
+/* Return the result, */
+   return result;
+}
+
+static int TestAxisInternalUnit( AstAxis *this, int *status ){
+/*
+*  Name:
+*     TestAxisInternalUnit
+
+*  Purpose:
+*     Test if a InternalUnit attribute value is set for an Axis.
+
+*  Type:
+*     Private function.
+
+*  Synopsis:
+*     #include "axis.h"
+*     int TestAxisInternalUnit( AstAxis *this, int *status )
+
+*  Class Membership:
+*     Axis member function
+
+*  Description:
+*     This function returns a boolean result (0 or 1) to indicate
+*     whether a value has been set for the InternalUnit string.
+
+*  Parameters:
+*     this
+*        Pointer to the Axis.
+*     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.
+*/
+
+/* Tell the world that we know what value to use for InternalUnit if and
+   only if a value has been set for Unit. */
+   return astTestAxisUnit( this );
+}
+
+static int TestAxisNormUnit( AstAxis *this, int *status ){
+/*
+*  Name:
+*     TestAxisNormUnit
+
+*  Purpose:
+*     Test if a NormUnit attribute value is set for an Axis.
+
+*  Type:
+*     Private function.
+
+*  Synopsis:
+*     #include "axis.h"
+*     int TestAxisNormUnit( AstAxis *this, int *status )
+
+*  Class Membership:
+*     Axis member function
+
+*  Description:
+*     This function returns a boolean result (0 or 1) to indicate
+*     whether a value has been set for the NormUnit string.
+
+*  Parameters:
+*     this
+*        Pointer to the Axis.
+*     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.
+*/
+
+   return astTestAxisUnit( this );
+}
+
+
+/* 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). */
+
+/* Digits. */
+/* ------- */
+/* Clear the Digits value by setting it to -INT_MAX. */
+astMAKE_CLEAR(Axis,AxisDigits,digits,-INT_MAX)
+
+/* Supply a default of 7 digits if no value has been set. */
+astMAKE_GET(Axis,AxisDigits,int,0,( this->digits != -INT_MAX ?
+                                    this->digits : 7 ))
+
+/* Constrain the Digits value being set to be at least 1. */
+astMAKE_SET(Axis,AxisDigits,int,digits,( value > 1 ? value : 1 ))
+
+/* The Digits value is set if it is not -INT_MAX. */
+astMAKE_TEST(Axis,AxisDigits,( this->digits != -INT_MAX ))
+
+/* Direction. */
+/* ---------- */
+/* Clear the Direction value by setting it to -INT_MAX. */
+astMAKE_CLEAR(Axis,AxisDirection,direction,-INT_MAX)
+
+/* Supply a default value of 1 if the Direction value is not set. */
+astMAKE_GET(Axis,AxisDirection,int,0,( this->direction != -INT_MAX ?
+                                       this->direction : 1 ))
+
+/* Set a Direction value of 1 if any non-zero value is supplied. */
+astMAKE_SET(Axis,AxisDirection,int,direction,( value != 0 ))
+
+/* The Direction value is set if it is not -INT_MAX. */
+astMAKE_TEST(Axis,AxisDirection,( this->direction != -INT_MAX ))
+
+/* Top. */
+/* -----*/
+/* Clear the Top Direction value by setting it to AST__BAD. */
+astMAKE_CLEAR(Axis,AxisTop,top,AST__BAD)
+
+/* Supply a default value of DBL_MAX if the Top value is not set.*/
+astMAKE_GET(Axis,AxisTop,double,0,( this->top != AST__BAD ? this->top : DBL_MAX))
+
+/* Set the Top value. */
+astMAKE_SET(Axis,AxisTop,double,top,(value))
+
+/* The Top value is set if it is not AST__BAD. */
+astMAKE_TEST(Axis,AxisTop,( this->top != AST__BAD ))
+
+/* Bottom. */
+/* --------*/
+/* Clear the Bottom Direction value by setting it to AST__BAD. */
+astMAKE_CLEAR(Axis,AxisBottom,bottom,AST__BAD)
+
+/* Supply a default value of -DBL_MAX if the Bottom value is not set.*/
+astMAKE_GET(Axis,AxisBottom,double,0.0,( this->bottom != AST__BAD ? this->bottom : -DBL_MAX))
+
+/* Set the Bottom value. */
+astMAKE_SET(Axis,AxisBottom,double,bottom,(value))
+
+/* The Bottom value is set if it is not AST__BAD. */
+astMAKE_TEST(Axis,AxisBottom,( this->bottom != AST__BAD ))
+
+/* Format. */
+/* ------- */
+/* Clear the Format value by freeing the allocated memory and assigning a NULL
+   pointer. */
+astMAKE_CLEAR(Axis,AxisFormat,format,astFree( this->format ))
+
+/* If the Format value is not set, return a pointer to a default Format
+   string. */
+astMAKE_GET(Axis,AxisFormat,const char *,NULL,( this->format ? this->format :
+            GetDefaultFormat( this, status ) ) )
+
+/* Set a Format value by freeing any previously allocated memory, allocating
+   new memory, storing the string and saving the pointer to the copy. */
+astMAKE_SET(Axis,AxisFormat,const char *,format,astStore( this->format, value,
+                                                strlen( value ) + (size_t) 1 ))
+
+/* The Format value is set if the pointer to it is not NULL. */
+astMAKE_TEST(Axis,AxisFormat,( this->format != NULL ))
+
+/* Label. */
+/* ------ */
+/* Clear the Label value by freeing the allocated memory and assigning a NULL
+   pointer. */
+astMAKE_CLEAR(Axis,AxisLabel,label,astFree( this->label ))
+
+/* If the Label value is not set, supply a default value by way of a pointer
+   to the constant string "Coordinate Axis". */
+astMAKE_GET(Axis,AxisLabel,const char *,NULL,( this->label ? this->label :
+                                               "Coordinate axis" ))
+
+/* Set a Label value by freeing any previously allocated memory, allocating
+   new memory, storing the string and saving the pointer to the copy. */
+astMAKE_SET(Axis,AxisLabel,const char *,label,astStore( this->label, value,
+                                              strlen( value ) + (size_t) 1 ))
+
+/* The Label value is set if the pointer to it is not NULL. */
+astMAKE_TEST(Axis,AxisLabel,( this->label != NULL ))
+
+/* Symbol. */
+/* ------- */
+/* Clear the Symbol value by freeing the allocated memory and assigning a NULL
+   pointer. */
+astMAKE_CLEAR(Axis,AxisSymbol,symbol,astFree( this->symbol ))
+
+/* If the Symbol value is not set, supply a default value by way of a pointer
+   to the constant string "x". */
+astMAKE_GET(Axis,AxisSymbol,const char *,NULL,( this->symbol ? this->symbol :
+                                                               "x" ))
+
+/* Set a Symbol value by freeing any previously allocated memory, allocating
+   new memory, storing the string and saving the pointer to the copy. */
+astMAKE_SET(Axis,AxisSymbol,const char *,symbol,astStore( this->symbol, value,
+                                                strlen( value ) + (size_t) 1 ))
+
+/* The Symbol value is set if the pointer to it is not NULL. */
+astMAKE_TEST(Axis,AxisSymbol,( this->symbol != NULL ))
+
+/* Unit. */
+/* ----- */
+/* Clear the Unit value by freeing the allocated memory and assigning a NULL
+   pointer. */
+astMAKE_CLEAR(Axis,AxisUnit,unit,astFree( this->unit ))
+
+/* If the Unit value is not set, supply a default value by way of a pointer
+   to the constant string "". */
+astMAKE_GET(Axis,AxisUnit,const char *,NULL,( this->unit ? this->unit : "" ))
+
+/* Set a Unit value by freeing any previously allocated memory, allocating
+   new memory, storing the string and saving the pointer to the copy. */
+astMAKE_SET(Axis,AxisUnit,const char *,unit,astStore( this->unit, value,
+                                            strlen( value ) + (size_t) 1 ))
+
+/* The Unit value is set if the pointer to it is not NULL. */
+astMAKE_TEST(Axis,AxisUnit,( this->unit != NULL ))
+
+/* Copy constructor. */
+/* ----------------- */
+static void Copy( const AstObject *objin, AstObject *objout, int *status ) {
+/*
+*  Name:
+*     Copy
+
+*  Purpose:
+*     Copy constructor for Axis objects.
+
+*  Type:
+*     Private function.
+
+*  Synopsis:
+*     void Copy( const AstObject *objin, AstObject *objout, int *status )
+
+*  Description:
+*     This function implements the copy constructor for Axis objects.
+
+*  Parameters:
+*     objin
+*        Pointer to the object to be copied.
+*     objout
+*        Pointer to the object being constructed.
+*     status
+*        Pointer to the inherited status variable.
+
+*  Returned Value:
+*     void
+
+*  Notes:
+*     -  This constructor makes a deep copy.
+*/
+
+/* Local Variables: */
+   AstAxis *in;                  /* Pointer to input Axis */
+   AstAxis *out;                 /* Pointer to output Axis */
+
+/* Check the global error status. */
+   if ( !astOK ) return;
+
+/* Obtain pointers to the input and output Axis structures. */
+   in = (AstAxis *) objin;
+   out = (AstAxis *) objout;
+
+/* For safety, first clear any references to the input memory from
+   the output Axis. */
+   out->format = NULL;
+   out->label = NULL;
+   out->symbol = NULL;
+   out->unit = NULL;
+
+/* Make copies of the allocated strings and Objects. */
+   if ( in->label ) out->label = astStore( NULL, in->label,
+                                 strlen( in->label ) + (size_t) 1 );
+   if ( in->format ) out->format = astStore( NULL, in->format,
+                                   strlen( in->format ) + (size_t) 1 );
+   if ( in->symbol ) out->symbol = astStore( NULL, in->symbol,
+                                   strlen( in->symbol ) + (size_t) 1 );
+   if ( in->unit ) out->unit = astStore( NULL, in->unit,
+                               strlen( in->unit ) + (size_t) 1 );
+
+/* If an error occurred, clean up by freeing all memory allocated above. */
+   if ( !astOK ) {
+      out->format = astFree( out->format );
+      out->label = astFree( out->label );
+      out->symbol = astFree( out->symbol );
+      out->unit = astFree( out->unit );
+   }
+}
+
+/* Destructor. */
+/* ----------- */
+static void Delete( AstObject *obj, int *status ) {
+/*
+*  Name:
+*     Delete
+
+*  Purpose:
+*     Destructor for Axis objects.
+
+*  Type:
+*     Private function.
+
+*  Synopsis:
+*     void Delete( AstObject *obj, int *status )
+
+*  Description:
+*     This function implements the destructor for Axis 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: */
+   AstAxis *this;                /* Pointer to Axis */
+
+/* Obtain a pointer to the Axis structure. */
+   this = (AstAxis *) obj;
+
+/* Free all allocated memory. */
+   this->format = astFree( this->format );
+   this->label = astFree( this->label );
+   this->symbol = astFree( this->symbol );
+   this->unit = astFree( this->unit );
+}
+
+/* Dump function. */
+/* -------------- */
+static void Dump( AstObject *this_object, AstChannel *channel, int *status ) {
+/*
+*  Name:
+*     Dump
+
+*  Purpose:
+*     Dump function for Axis 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 Axis class to an output Channel.
+
+*  Parameters:
+*     this
+*        Pointer to the Axis 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: */
+   AstAxis *this;                /* Pointer to the Axis structure */
+   char comment[ 80 ];           /* Buffer for comment string */
+   const char *sval;             /* Pointer to string value */
+   const char *lab;              /* Pointer to unit label */
+   double dval;                  /* Double value */
+   int ival;                     /* Integer value */
+   int set;                      /* Attribute value set? */
+
+/* Check the global error status. */
+   if ( !astOK ) return;
+
+/* Obtain a pointer to the Axis structure. */
+   this = (AstAxis *) this_object;
+
+/* Write out values representing the instance variables for the
+   Axis class.  Accompany these with appropriate comment strings,
+   possibly depending on the values being written.*/
+
+/* In the case of attributes, we first use the appropriate (private)
+   Test...  member function to see if they are set. If so, we then use
+   the (private) Get... function to obtain the value to be written
+   out.
+
+   For attributes which are not set, we use the astGet... method to
+   obtain the value instead. This will supply a default value
+   (possibly provided by a derived class which over-rides this method)
+   which is more useful to a human reader as it corresponds to the
+   actual default attribute value.  Since "set" will be zero, these
+   values are for information only and will not be read back. */
+
+/* Label. */
+/* ------ */
+   set = TestAxisLabel( this, status );
+   sval = set ? GetAxisLabel( this, status ) : astGetAxisLabel( this );
+   astWriteString( channel, "Label", set, 1, sval, "Axis Label" );
+
+/* Symbol. */
+/* ------- */
+   set = TestAxisSymbol( this, status );
+   sval = set ? GetAxisSymbol( this, status ) : astGetAxisSymbol( this );
+   astWriteString( channel, "Symbol", set, 1, sval, "Axis symbol" );
+
+/* Unit. */
+/* ----- */
+   set = TestAxisUnit( this, status );
+   sval = set ? GetAxisUnit( this, status ) : astGetAxisUnit( this );
+
+/* Get any label associated with the unit string. */
+   lab = astUnitLabel( sval );
+
+/* Construct a comment including the above label (but only if it is not
+   the same as the unit string) . */
+   if( lab && strcmp( lab, sval ) ) {
+      (void) sprintf( comment, "Axis units (%s)", lab );
+   } else {
+      (void) sprintf( comment, "Axis units" );
+   }
+
+/* Write out the Unit value. */
+   astWriteString( channel, "Unit", set, 0, sval, comment );
+
+/* Digits. */
+/* ------- */
+   set = TestAxisDigits( this, status );
+   ival = set ? GetAxisDigits( this, status ) : astGetAxisDigits( this );
+   astWriteInt( channel, "Digits", set, 0, ival,
+                "Default formatting precision" );
+
+/* Format. */
+/* ------- */
+   set = TestAxisFormat( this, status );
+   sval = set ? GetAxisFormat( this, status ) : astGetAxisFormat( this );
+   astWriteString( channel, "Format", set, 0, sval, "Format specifier" );
+
+/* Direction. */
+/* ---------- */
+   set = TestAxisDirection( this, status );
+   ival = set ? GetAxisDirection( this, status ) : astGetAxisDirection( this );
+   astWriteInt( channel, "Dirn", set, 0, ival,
+                ival ? "Plot in conventional direction (hint)" :
+                       "Plot in reverse direction (hint)" );
+/* Top. */
+/* ---- */
+   set = TestAxisTop( this, status );
+   dval = set ? GetAxisTop( this, status ) : astGetAxisTop( this );
+   astWriteDouble( channel, "Top", set, 0, dval, "Maximum legal axis value" );
+
+/* Bottom. */
+/* ------- */
+   set = TestAxisBottom( this, status );
+   dval = set ? GetAxisBottom( this, status ) : astGetAxisBottom( this );
+   astWriteDouble( channel, "Bottom", set, 0, dval, "Minimum legal axis value" );
+}
+
+/* Standard class functions. */
+/* ========================= */
+/* Implement the astIsAAxis and astCheckAxis functions using the macros
+   defined for this purpose in the "object.h" header file. */
+astMAKE_ISA(Axis,Object)
+astMAKE_CHECK(Axis)
+
+AstAxis *astAxis_( const char *options, int *status, ...) {
+/*
+*+
+*  Name:
+*     astAxis
+
+*  Purpose:
+*     Create an Axis.
+
+*  Type:
+*     Public function.
+
+*  Synopsis:
+*     #include "axis.h"
+*     AstAxis *astAxis( const char *options, int *status, ... )
+
+*  Class Membership:
+*     Axis constructor.
+
+*  Description:
+*     This function creates a new Axis and optionally initialises its
+*     attributes.
+
+*  Parameters:
+*     options
+*        Pointer to a null terminated string containing an optional
+*        comma-separated list of attribute assignments to be used for
+*        initialising the new Axis. The syntax used is the same as for the
+*        astSet method and may include "printf" format specifiers identified
+*        by "%" symbols in the normal way.
+*     status
+*        Pointer to the inherited status variable.
+*     ...
+*        If the "options" string contains "%" format specifiers, then an
+*        optional list of arguments may follow it in order to supply values to
+*        be substituted for these specifiers. The rules for supplying these
+*        are identical to those for the astSet method (and for the C "printf"
+*        function).
+
+*  Returned Value:
+*     A pointer to the new Axis.
+
+*  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 */
+   AstAxis *new;                 /* Pointer to new Axis */
+   va_list args;                 /* Variable argument list */
+
+/* Get a pointer to the thread specific global data structure. */
+   astGET_GLOBALS(NULL);
+
+/* Check the global error status. */
+   if ( !astOK ) return NULL;
+
+/* Initialise the Axis, allocating memory and initialising the virtual
+   function table as well if necessary. */
+   new = astInitAxis( NULL, sizeof( AstAxis ), !class_init, &class_vtab,
+                      "Axis" );
+
+/* 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 Axis'
+   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 Axis. */
+   return new;
+}
+
+AstAxis *astAxisId_( const char *options, ... ) {
+/*
+*  Name:
+*     astAxisId_
+
+*  Purpose:
+*     Create an Axis.
+
+*  Type:
+*     Private function.
+
+*  Synopsis:
+*     #include "axis.h"
+*     AstAxis *astAxisId_( const char *options, ... );
+
+*  Class Membership:
+*     Axis constructor.
+
+*  Description:
+*     This function implements the external (public) interface to the
+*     astAxis constructor function. It returns an ID value (instead of
+*     a true C pointer) to external users, and must be provided
+*     because astAxis_ 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 astAxis_ 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 astAxis_.
+
+*  Returned Value:
+*     The ID value associated with the new Axis.
+*/
+
+/* Local Variables: */
+   astDECLARE_GLOBALS            /* Pointer to thread-specific global data */
+   AstAxis *new;                 /* Pointer to new Axis */
+   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 error status. */
+   if ( !astOK ) return NULL;
+
+/* Initialise the Axis, allocating memory and initialising the virtual
+   function table as well if necessary. */
+   new = astInitAxis( NULL, sizeof( AstAxis ), !class_init, &class_vtab,
+                      "Axis" );
+
+/* 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 Axis'
+   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 Axis. */
+   return astMakeId( new );
+}
+
+AstAxis *astInitAxis_( void *mem, size_t size, int init,
+                       AstAxisVtab *vtab, const char *name, int *status ) {
+/*
+*+
+*  Name:
+*     astInitAxis
+
+*  Purpose:
+*     Initialise an Axis.
+
+*  Type:
+*     Protected function.
+
+*  Synopsis:
+*     #include "axis.h"
+*     AstAxis *astInitAxis( void *mem, size_t size, int init,
+*                           AstAxisVtab *vtab, const char *name )
+
+*  Class Membership:
+*     Axis initialiser.
+
+*  Description:
+*     This function is provided for use by class implementations to initialise
+*     a new Axis object. It allocates memory (if necessary) to accommodate
+*     the Axis plus any additional data associated with the derived class.
+*     It then initialises an Axis structure at the start of this memory. If
+*     the "init" flag is set, it also initialises the contents of a virtual
+*     function table for an Axis at the start of the memory passed via the
+*     "vtab" parameter.
+
+*  Parameters:
+*     mem
+*        A pointer to the memory in which the Axis is to be created. This
+*        must be of sufficient size to accommodate the Axis data
+*        (sizeof(Axis)) 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 Axis (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 Axis
+*        structure, so a valid value must be supplied even if not required for
+*        allocating memory.
+*     init
+*        A logical flag indicating if the Axis'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 Axis.
+*     name
+*        Pointer to a constant null-terminated character string which contains
+*        the name of the class to which the new object belongs (it is this
+*        pointer value that will subsequently be returned by the astClass
+*        method).
+
+*  Returned Value:
+*     A pointer to the new Axis.
+
+*  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: */
+   AstAxis *new;                 /* Pointer to new Axis */
+
+/* Check the global status. */
+   if ( !astOK ) return NULL;
+
+/* If necessary, initialise the virtual function table. */
+   if ( init ) astInitAxisVtab( vtab, name );
+
+/* Initialise an Object structure (the parent class) as the first component
+   within the Axis structure, allocating memory if necessary. */
+   new = (AstAxis *) astInitObject( mem, size, 0, (AstObjectVtab *) vtab,
+                                    name );
+
+   if ( astOK ) {
+
+/* Initialise the Axis data. */
+/* ------------------------- */
+/* Initialise all attributes to their "undefined" values. */
+      new->digits = -INT_MAX;
+      new->direction = -INT_MAX;
+      new->format = NULL;
+      new->label = NULL;
+      new->symbol = NULL;
+      new->unit = NULL;
+      new->top = AST__BAD;
+      new->bottom = AST__BAD;
+
+/* If an error occurred, clean up by deleting the new Axis. */
+      if ( !astOK ) new = astDelete( new );
+   }
+
+/* Return a pointer to the new Axis. */
+   return new;
+}
+
+AstAxis *astLoadAxis_( void *mem, size_t size,
+                       AstAxisVtab *vtab, const char *name,
+                       AstChannel *channel, int *status ) {
+/*
+*+
+*  Name:
+*     astLoadAxis
+
+*  Purpose:
+*     Load an Axis.
+
+*  Type:
+*     Protected function.
+
+*  Synopsis:
+*     #include "axis.h"
+*     AstAxis *astLoadAxis( void *mem, size_t size,
+*                           AstAxisVtab *vtab, const char *name,
+*                           AstChannel *channel )
+
+*  Class Membership:
+*     Axis loader.
+
+*  Description:
+*     This function is provided to load a new Axis 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
+*     Axis 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 Axis at the start of the memory
+*     passed via the "vtab" parameter.
+
+
+*  Parameters:
+*     mem
+*        A pointer to the memory into which the Axis is to be
+*        loaded.  This must be of sufficient size to accommodate the
+*        Axis data (sizeof(Axis)) 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 Axis (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 Axis 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(AstAxis) is used instead.
+*     vtab
+*        Pointer to the start of the virtual function table to be
+*        associated with the new Axis. If this is NULL, a pointer
+*        to the (static) virtual function table for the Axis 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 "Axis" is used instead.
+
+*  Returned Value:
+*     A pointer to the new Axis.
+
+*  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 */
+   AstAxis *new;                 /* Pointer to the new Axis */
+
+/* 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 Axis. In this case the
+   Axis belongs to this class, so supply appropriate values to be
+   passed to the parent class loader (and its parent, etc.). */
+   if ( !vtab ) {
+      size = sizeof( AstAxis );
+      vtab = &class_vtab;
+      name = "Axis";
+
+/* If required, initialise the virtual function table for this class. */
+      if ( !class_init ) {
+         astInitAxisVtab( 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 Axis. */
+   new = astLoadObject( mem, size, (AstObjectVtab *) 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, "Axis" );
+
+/* Now read each individual data item from this list and use it to
+   initialise the appropriate instance variable(s) for this class. */
+
+/* In the case of attributes, we first read the "raw" input value,
+   supplying the "unset" value as the default. If a "set" value is
+   obtained, we then use the appropriate (private) Set... member
+   function to validate and set the value properly. */
+
+/* Label. */
+/* ------ */
+/* Note that string values do not require any additional processing. */
+      new->label = astReadString( channel, "label", NULL );
+
+/* Symbol. */
+/* ------- */
+      new->symbol = astReadString( channel, "symbol", NULL );
+
+/* Unit. */
+/* ----- */
+      new->unit = astReadString( channel, "unit", NULL );
+
+/* Digits. */
+/* ------- */
+      new->digits = astReadInt( channel, "digits", -INT_MAX );
+      if ( TestAxisDigits( new, status ) ) SetAxisDigits( new, new->digits, status );
+
+/* Format. */
+/* ------- */
+      new->format = astReadString( channel, "format", NULL );
+
+/* Direction. */
+/* ---------- */
+      new->direction = astReadInt( channel, "dirn", -INT_MAX );
+      if ( TestAxisDirection( new, status ) ) SetAxisDirection( new, new->direction, status );
+
+/* Top. */
+/* ---- */
+      new->top = astReadDouble( channel, "top", AST__BAD );
+      if ( TestAxisTop( new, status ) ) SetAxisTop( new, new->top, status );
+
+/* Bottom. */
+/* ---- */
+      new->bottom = astReadDouble( channel, "bottom", AST__BAD );
+      if ( TestAxisBottom( new, status ) ) SetAxisBottom( new, new->bottom, status );
+
+/* If an error occurred, clean up by deleting the new Axis. */
+      if ( !astOK ) new = astDelete( new );
+   }
+
+/* Return the new Axis 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. */
+
+/* External interfaces for the attribute access functions are generated
+   automatically by the macros that implement the access functions themselves.
+   Hence, we need only provide external interfaces for a few additional
+   functions here. */
+const char *astAxisAbbrev_( AstAxis *this, const char *fmt,
+                            const char *str1, const char *str2, int *status ) {
+   if ( !astOK ) return str2;
+   return (**astMEMBER(this,Axis,AxisAbbrev))( this, fmt, str1, str2, status );
+}
+const char *astAxisFormat_( AstAxis *this, double value, int *status ) {
+   if ( !astOK ) return NULL;
+   return (**astMEMBER(this,Axis,AxisFormat))( this, value, status );
+}
+double astAxisDistance_( AstAxis *this, double v1, double v2, int *status ) {
+   if ( !astOK ) return AST__BAD;
+   return (**astMEMBER(this,Axis,AxisDistance))( this, v1, v2, status );
+}
+double astAxisOffset_( AstAxis *this, double v1, double dist, int *status ) {
+   if ( !astOK ) return AST__BAD;
+   return (**astMEMBER(this,Axis,AxisOffset))( this, v1, dist, status );
+}
+double astAxisCentre_( AstAxis *this, double value, double gap, int *status ) {
+   if ( !astOK ) return 0.0;
+   return (**astMEMBER(this,Axis,AxisCentre))( this, value, gap, status );
+}
+double astAxisGap_( AstAxis *this, double gap, int *ntick, int *status ) {
+   if ( !astOK ) return 0.0;
+   return (**astMEMBER(this,Axis,AxisGap))( this, gap, ntick, status );
+}
+void astAxisNorm_( AstAxis *this, double *value, int *status ) {
+   if ( !astOK ) return;
+   (**astMEMBER(this,Axis,AxisNorm))( this, value, status );
+}
+void astAxisOverlay_( AstAxis *template, AstAxis *result, int *status ) {
+   if ( !astOK ) return;
+   (**astMEMBER(template,Axis,AxisOverlay))( template, result, status );
+}
+int astAxisUnformat_( AstAxis *this, const char *string, double *value, int *status ) {
+   if ( !astOK ) return 0;
+   return (**astMEMBER(this,Axis,AxisUnformat))( this, string, value, status );
+}
+int astAxisFields_( AstAxis *this, const char *fmt, const char *str,
+                    int maxfld, char **fields, int *nc, double *val, int *status ) {
+   if ( !astOK ) return 0;
+   return (**astMEMBER(this,Axis,AxisFields))( this, fmt, str, maxfld, fields, nc, val, status );
+}
+int astAxisIn_( AstAxis *this, double lo, double hi, double val, int closed, int *status ){
+   if ( !astOK ) return 0;
+   return (**astMEMBER(this,Axis,AxisIn))( this, lo, hi, val, closed, status );
+}
+const char *astGetAxisNormUnit_( AstAxis *this, int *status ) {
+   if ( !astOK ) return NULL;
+   return (**astMEMBER(this,Axis,GetAxisNormUnit))( this, status );
+}
+int astTestAxisNormUnit_( AstAxis *this, int *status ) {
+   if ( !astOK ) return 0;
+   return (**astMEMBER(this,Axis,TestAxisNormUnit))( this, status );
+}
+const char *astGetAxisInternalUnit_( AstAxis *this, int *status ) {
+   if ( !astOK ) return NULL;
+   return (**astMEMBER(this,Axis,GetAxisInternalUnit))( this, status );
+}
+int astTestAxisInternalUnit_( AstAxis *this, int *status ) {
+   if ( !astOK ) return 0;
+   return (**astMEMBER(this,Axis,TestAxisInternalUnit))( this, status );
+}
+void astAxisNormValues_( AstAxis *this, int oper, int nval, double *values,
+                         int *status ){
+   if ( !astOK ) return;
+   (**astMEMBER(this,Axis,AxisNormValues))( this, oper, nval, values, status );
+}
+
+
+
+
+
+