update ast 8.6.2

1 files changed, 7530 insertions, 0 deletions

diff --git a/ast/timeframe.c b/ast/timeframe.c
new file mode 100644
index 0000000..8d0906a
--- /dev/null
+++ b/ast/timeframe.c
@@ -0,0 +1,7530 @@
+/*
+*class++
+*  Name:
+*     TimeFrame
+
+*  Purpose:
+*     Time coordinate system description.
+
+*  Constructor Function:
+c     astTimeFrame
+f     AST_TIMEFRAME
+
+*  Description:
+*     A TimeFrame is a specialised form of one-dimensional Frame which
+*     represents various coordinate systems used to describe positions in
+*     time.
+*
+*     A TimeFrame represents a moment in time as either an Modified Julian
+*     Date (MJD), a Julian Date (JD), a Besselian epoch or a Julian epoch,
+*     as determined by the System attribute. Optionally, a zero point can be
+*     specified (using attribute TimeOrigin) which results in the TimeFrame
+*     representing time offsets from the specified zero point.
+*
+*     Even though JD and MJD are defined as being in units of days, the
+*     TimeFrame class allows other units to be used (via the Unit attribute)
+*     on the basis of simple scalings (60 seconds = 1 minute, 60 minutes = 1
+*     hour, 24 hours = 1 day, 365.25 days = 1 year). Likewise, Julian epochs
+*     can be described in units other than the usual years. Besselian epoch
+*     are always represented in units of (tropical) years.
+*
+*     The TimeScale attribute allows the time scale to be specified (that
+*     is, the physical process used to define the rate of flow of time).
+*     MJD, JD and Julian epoch can be used to represent a time in any
+*     supported time scale. However, Besselian epoch may only be used with the
+*     "TT" (Terrestrial Time) time scale. The list of supported time scales
+*     includes universal time and siderial time. Strictly, these represent
+*     angles rather than time scales, but are included in the list since
+*     they are in common use and are often thought of as time scales.
+*
+*     When a time value is formatted it can be formated either as a simple
+*     floating point value, or as a Gregorian date (see the Format
+*     attribute).
+
+*  Inheritance:
+*     The TimeFrame class inherits from the Frame class.
+
+*  Attributes:
+*     In addition to those attributes common to all Frames, every
+*     TimeFrame also has the following attributes:
+*
+*     - AlignTimeScale: Time scale in which to align TimeFrames
+*     - LTOffset: The offset of Local Time from UTC, in hours.
+*     - TimeOrigin: The zero point for TimeFrame axis values
+*     - TimeScale: The timescale used by the TimeFrame
+*
+*     Several of the Frame attributes inherited by the TimeFrame class
+*     refer to a specific axis of the Frame (for instance Unit(axis),
+*     Label(axis), etc). Since a TimeFrame is strictly one-dimensional,
+*     it allows these attributes to be specified without an axis index.
+*     So for instance, "Unit" is allowed in place of "Unit(1)".
+
+*  Functions:
+c     In addition to those functions applicable to all Frames, the
+c     following functions may also be applied to all TimeFrames:
+f     In addition to those routines applicable to all Frames, the
+f     following routines may also be applied to all TimeFrames:
+*
+c     - astCurrentTime: Return the current system time
+f     - AST_CURRENTTIME: Return the current system time
+
+*  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:
+*     NG: Norman Gray (Starlink)
+*     DSB: David Berry (Starlink)
+
+*  History:
+*     XX-Aug-2003 (NG):
+*        Original version, drawing heavily on specframe.c.
+*     20-MAY-2005 (NG):
+*        Merged into main AST system.
+*     25-MAY-2005 (DSB):
+*        Extensive modifications to add extra timescales, unit support,
+*        support for relative times, etc, and to make it more like the
+*        other AST Frame classes.
+*     12-AUG-2005 (DSB):
+*        Remove ClockLon and ClockLat attributes. Use the new ObsLon and
+*        ObsLat attributes in the parent Frame class instead. Note, for
+*        backward compatibility the public attribute accessors and the
+*        astLoadTimeFrame functions still recogonise ClockLon and ClockLat,
+*        but use the ObsLat/ObsLon attributes internally.
+*     1-MAR-2006 (DSB):
+*        Replace astSetPermMap within DEBUG blocks by astBeginPM/astEndPM.
+*     29-JUN-2006 (DSB):
+*        - Activate astAbbrev function for abbreviating leading fields in
+*        plot labels.
+*        - Include TimeOrigin in default Label.
+*     30-JUN-2006 (DSB):
+*        When splitting a date/time string into fields, allow each field
+*        to include a decimal point.
+*     30-JUN-2006 (DSB):
+*        Allow astAbbrev to have a null "str1" value.
+*     16-OCT-2006 (DSB):
+*        Allow conversions between UTC and UT1 (using the new Frame attribute
+*     1-NOV-2006 (DSB):
+*        Correct sign of longitude passed to TimeMap contrutcorss in
+*        function MakeMap.
+*     31-JAN-2007 (DSB):
+*        Modified so that a TimeFrame can be used as a template to find a
+*        TimeFrame contained within a CmpFrame. This involves changes in
+*        Match and the removal of the local versions of SetMaxAxes and
+*        SetMinAxes.
+*     3-SEP-2007 (DSB):
+*        In SubFrame, since AlignSystem is extended by the TimeFrame class
+*        it needs to be cleared before invoking the parent SubFrame
+*        method in cases where the result Frame is not a TimeFrame.
+*     2-OCT-2007 (DSB):
+*        In Overlay, clear AlignSystem as well as System before calling
+*        the parent overlay method.
+*     2-OCT-2007 (DSB):
+*        Added "LT" (Local Time) time scale.
+*     9-DEC-2008 (DSB):
+*        Ensure Format string pointer is used correctly.
+*     19-JAN-2009 (DSB):
+*        Ensure "<bad>" is returned by astFormat if the axis value is bad.
+*     31-MAR-2009 (DSB):
+*        Extend TimeFrame "iso" Format to allow it to specify the character to
+*        place between the time and date strings.
+*     15-APR-2009 (DSB):
+*        Increase the number of nice calendar time axis gaps allowed by
+*        the Gap function. Previously, there was a jump from 1 day to 1
+*        year making it difficult to plot calendar axes covering time
+*        ranges of the order of 0.5 to 2 years. Now, nice numbers of days
+*        are allowed as intermediate gaps. Since months do not all have
+*        the same number of days, this means that the day number at major
+*        ticks will bounce around a bit.
+*     29-APR-2011 (DSB):
+*        Prevent astFindFrame from matching a subclass template against a
+*        superclass target.
+*     16-APR-2015 (DSB):
+*        Add more choices when chosing gaps on time axes.
+*     17-APR-2015 (DSB):
+*        - Added Centre.
+*        - Remove some "set but unused" variables.
+*     21-APR-2016 (DSB):
+*        - Over-ride astFields.
+*     5-APR-2017 (GSB):
+*        - Pass DTAI to astAddTime for UTCTOTAI and TAITOUTC conversions and
+*          check whether there is a relevant DTAI difference in
+*          MakeTimeMapping.
+*     7-APR-2017 (GSB):
+*        - Add LT to macro defining scales depending on DTAI.
+*     10-APR-2017 (GSB):
+*        - Added macro to test floating point equality and used it for Dtai.
+*     27-APR-2017 (DSB):
+*        Conversions between TT and TDB now require DTAI as an argument.
+*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 TimeFrame
+
+/* Define the first and last acceptable System values. */
+#define FIRST_SYSTEM AST__MJD
+#define LAST_SYSTEM AST__BEPOCH
+
+/* Define the first and last acceptable TimeScale values. */
+#define FIRST_TS AST__TAI
+#define LAST_TS AST__LT
+
+/* The supported time scales fall into two groups. Time scales in the
+   first group depend on the clock position. That is, transformation
+   between a time scale in one group and a timescale in the other group
+   requires the clock position, as does transformation between two time
+   scales within the first group. Define a macro which tests if a given
+   timescale belongs to the first group. */
+#define CLOCK_SCALE(ts) \
+      ( ( ts == AST__LMST || \
+          ts == AST__LAST || \
+          ts == AST__TDB || \
+          ts == AST__TCB ) ? 1 : 0 )
+
+
+/* Define a macro which tests if a given timescale requires a Dut1 value
+   in order to convert from the timescale to UTC. */
+#define DUT1_SCALE(ts) \
+      ( ( ts == AST__LMST || \
+          ts == AST__LAST || \
+          ts == AST__GMST || \
+          ts == AST__UT1 ) ? 1 : 0 )
+
+/* Timescales can be divided up into 3 groups such that conversion from a
+   timescale in one group to a timescale in any other group requires the
+   DTAI value, but conversion between timescales in the same group does not
+   require the DTAI value. Define a macro that returns the group number
+   (1, 2 or 3) for a specific timescale. */
+#define DTAI_SCALE(ts) \
+      ( ( ts == AST__LMST || \
+          ts == AST__LAST || \
+          ts == AST__GMST || \
+          ts == AST__UT1 || \
+          ts == AST__UTC || \
+          ts == AST__LT ) ? 1 : \
+          ( ( ts == AST__TAI || ts == AST__TT ) ? 2 : 3 ) )
+
+/* Define a macro which tests if a given timescale requires a LTOffset value
+   in order to convert from the timescale to UTC. */
+#define LTOFFSET_SCALE(ts) \
+      ( ( ts == AST__LT ) ? 1 : 0 )
+
+/* The Unix epoch (00:00:00 UTC 1 January 1970 AD) as an absolute MJD in
+   the UTC timescale. */
+#define UNIX_EPOCH 40587.0
+
+/* Check for floating point equality (within the given tolerance), taking
+   bad values into account. */
+#define EQUAL(aa,bb,tol) (((aa)==AST__BAD)?(((bb)==AST__BAD)?1:0):(((bb)==AST__BAD)?0:(fabs((aa)-(bb))<=(tol))))
+
+/* Header files. */
+/* ============= */
+/* Interface definitions. */
+/* ---------------------- */
+
+#include "globals.h"             /* Thread-safe global data access */
+#include "error.h"               /* Error reporting facilities */
+#include "memory.h"              /* Memory allocation facilities */
+#include "unit.h"                /* Units management facilities */
+#include "globals.h"             /* Thread-safe global data access */
+#include "object.h"              /* Base Object class */
+#include "timemap.h"             /* Time coordinate Mappings */
+#include "frame.h"               /* Parent Frame class */
+#include "timeframe.h"           /* Interface definition for this class */
+#include "mapping.h"             /* Coordinate Mappings */
+#include "cmpmap.h"              /* Compound Mappings */
+#include "unitmap.h"             /* Unit Mappings */
+#include "shiftmap.h"            /* Shift of origins */
+#include "pal.h"              /* SlaLib interface */
+
+
+/* Error code definitions. */
+/* ----------------------- */
+#include "ast_err.h"             /* AST error codes */
+
+/* C header files. */
+/* --------------- */
+#include <stdarg.h>
+#include <stdio.h>
+#include <string.h>
+#include <ctype.h>
+#include <stddef.h>
+#include <math.h>
+#include <time.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 used or extended by this
+   class. */
+static AstSystemType (* parent_getalignsystem)( AstFrame *, int * );
+static AstSystemType (* parent_getsystem)( AstFrame *, int * );
+static double (* parent_centre)( AstFrame *, int, double, double, int * );
+static double (* parent_gap)( AstFrame *, int, double, int *, int * );
+static const char *(* parent_abbrev)( AstFrame *, int, const char *, const char *, const char *, int * );
+static const char *(* parent_format)( AstFrame *, int, double, int * );
+static const char *(* parent_getattrib)( AstObject *, const char *, int * );
+static const char *(* parent_getdomain)( AstFrame *, int * );
+static const char *(* parent_getlabel)( AstFrame *, int, int * );
+static const char *(* parent_getsymbol)( AstFrame *, int, int * );
+static const char *(* parent_gettitle)( AstFrame *, int * );
+static const char *(* parent_getunit)( AstFrame *, int, int * );
+static double (* parent_getepoch)( AstFrame *, int * );
+static int (* parent_fields)( AstFrame *, int, const char *, const char *, int, char **, int *, double *, int * );
+static int (* parent_match)( AstFrame *, AstFrame *, int, int **, int **, AstMapping **, AstFrame **, int * );
+static int (* parent_subframe)( AstFrame *, AstFrame *, int, const int *, const int *, AstMapping **, AstFrame **, int * );
+static int (* parent_testattrib)( AstObject *, const char *, int * );
+static int (* parent_unformat)( AstFrame *, int, const char *, double *, int * );
+static void (* parent_clearattrib)( AstObject *, const char *, int * );
+static void (* parent_clearsystem)( AstFrame *, int * );
+static void (* parent_overlay)( AstFrame *, const int *, AstFrame *, int * );
+static void (* parent_setattrib)( AstObject *, const char *, int * );
+static void (* parent_setsystem)( AstFrame *, AstSystemType, int * );
+static void (* parent_setunit)( AstFrame *, int, const char *, int * );
+
+/* The Unix epoch (00:00:00 UTC 1 January 1970 AD) as an absolute MJD in
+   the TAI timescale. */
+static double tai_epoch;
+
+/* 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->Format_Buff[ 0 ] = 0; \
+   globals->GetAttrib_Buff[ 0 ] = 0; \
+   globals->GetLabel_Buff[ 0 ] = 0; \
+   globals->GetSymbol_Buff[ 0 ] = 0; \
+   globals->GetTitle_Buff[ 0 ] = 0; \
+
+/* Create the function that initialises global data for this module. */
+astMAKE_INITGLOBALS(TimeFrame)
+
+/* Define macros for accessing each item of thread specific global data. */
+#define class_init astGLOBAL(TimeFrame,Class_Init)
+#define class_vtab astGLOBAL(TimeFrame,Class_Vtab)
+#define format_buff astGLOBAL(TimeFrame,Format_Buff)
+#define getattrib_buff astGLOBAL(TimeFrame,GetAttrib_Buff)
+#define getlabel_buff astGLOBAL(TimeFrame,GetLabel_Buff)
+#define getsymbol_buff astGLOBAL(TimeFrame,GetSymbol_Buff)
+#define gettitle_buff astGLOBAL(TimeFrame,GetTitle_Buff)
+
+
+
+static pthread_mutex_t mutex2 = PTHREAD_MUTEX_INITIALIZER;
+#define LOCK_MUTEX2 pthread_mutex_lock( &mutex2 );
+#define UNLOCK_MUTEX2 pthread_mutex_unlock( &mutex2 );
+
+/* If thread safety is not needed, declare and initialise globals at static
+   variables. */
+#else
+
+/* Buffers for strings returned by various functions. */
+static char getattrib_buff[ AST__TIMEFRAME_GETATTRIB_BUFF_LEN + 1 ];
+static char format_buff[ AST__TIMEFRAME_FORMAT_BUFF_LEN + 1 ];
+static char getlabel_buff[ AST__TIMEFRAME_GETLABEL_BUFF_LEN + 1 ];
+static char getsymbol_buff[ AST__TIMEFRAME_GETSYMBOL_BUFF_LEN + 1 ];
+static char gettitle_buff[ AST__TIMEFRAME_GETTITLE_BUFF_LEN + 1 ];
+
+
+/* Define the class virtual function table and its initialisation flag
+   as static variables. */
+static AstTimeFrameVtab class_vtab;   /* Virtual function table */
+static int class_init = 0;       /* Virtual function table initialised? */
+
+#define LOCK_MUTEX2
+#define UNLOCK_MUTEX2
+
+#endif
+
+
+/* Prototypes for Private Member Functions. */
+/* ======================================== */
+static AstMapping *MakeMap( AstTimeFrame *, AstSystemType, AstSystemType, AstTimeScaleType, AstTimeScaleType, double, double, const char *, const char *, const char *, int * );
+static AstSystemType GetAlignSystem( AstFrame *, int * );
+static AstSystemType SystemCode( AstFrame *, const char *, int * );
+static AstSystemType ValidateSystem( AstFrame *, AstSystemType, const char *, int * );
+static AstTimeScaleType TimeScaleCode( const char *, int * );
+static const char *DefUnit( AstSystemType, const char *, const char *, int * );
+static const char *Format( AstFrame *, int, double, int * );
+static const char *GetDomain( AstFrame *, int * );
+static const char *GetLabel( AstFrame *, int, int * );
+static const char *GetSymbol( AstFrame *, int, int * );
+static const char *GetTitle( AstFrame *, int * );
+static const char *GetUnit( AstFrame *, int, int * );
+static const char *SystemLabel( AstSystemType, int * );
+static const char *SystemString( AstFrame *, AstSystemType, int * );
+static const char *TimeScaleString( AstTimeScaleType, int * );
+static double CurrentTime( AstTimeFrame *, int * );
+static double FromMJD( AstTimeFrame *, double, int * );
+static double GetEpoch( AstFrame *, int * );
+static double GetTimeOriginCur( AstTimeFrame *, int * );
+static double ToMJD( AstSystemType, double, int * );
+static double ToUnits( AstTimeFrame *, const char *, double, const char *, int * );
+static int DateFormat( const char *, int *, char *, int * );
+static int Fields( AstFrame *, int, const char *, const char *, int, char **, int *, double *, int * );
+static int GetActiveUnit( AstFrame *, int * );
+static int MakeTimeMapping( AstTimeFrame *, AstTimeFrame *, AstTimeFrame *, int, AstMapping **, int * );
+static int Match( AstFrame *, AstFrame *, int, int **, int **, AstMapping **, AstFrame **, int * );
+static int SubFrame( AstFrame *, AstFrame *, int, const int *, const int *, AstMapping **, AstFrame **, int * );
+static int TestActiveUnit( AstFrame *, int * );
+static void Dump( AstObject *, AstChannel *, int * );
+static void OriginScale( AstTimeFrame *, AstTimeScaleType, const char *, int * );
+static void OriginSystem( AstTimeFrame *, AstSystemType, const char *, int * );
+static void Overlay( AstFrame *, const int *, AstFrame *, int * );
+static void SetUnit( AstFrame *, int, const char *, int * );
+static void VerifyAttrs( AstTimeFrame *, const char *, const char *, const char *, int * );
+static AstMapping *ToMJDMap( AstSystemType, double, int * );
+static int Unformat( AstFrame *, int, const char *, double *, int * );
+static const char *Abbrev( AstFrame *, int, const char *, const char *, const char *, int * );
+static double Centre( AstFrame *, int, double, double, int * );
+static double Gap( AstFrame *, int, double, int *, int * );
+
+static AstSystemType GetSystem( AstFrame *, int * );
+static void SetSystem( AstFrame *, AstSystemType, int * );
+static void ClearSystem( AstFrame *, int * );
+
+static double GetTimeOrigin( AstTimeFrame *, int * );
+static int TestTimeOrigin( AstTimeFrame *, int * );
+static void ClearTimeOrigin( AstTimeFrame *, int * );
+static void SetTimeOrigin( AstTimeFrame *, double, int * );
+
+static double GetLTOffset( AstTimeFrame *, int * );
+static int TestLTOffset( AstTimeFrame *, int * );
+static void ClearLTOffset( AstTimeFrame *, int * );
+static void SetLTOffset( AstTimeFrame *, double, int * );
+
+static const char *GetAttrib( AstObject *, const char *, int * );
+static int TestAttrib( AstObject *, const char *, int * );
+static void ClearAttrib( AstObject *, const char *, int * );
+static void SetAttrib( AstObject *, const char *, int * );
+
+static AstTimeScaleType GetAlignTimeScale( AstTimeFrame *, int * );
+static int TestAlignTimeScale( AstTimeFrame *, int * );
+static void ClearAlignTimeScale( AstTimeFrame *, int * );
+static void SetAlignTimeScale( AstTimeFrame *, AstTimeScaleType, int * );
+
+static AstTimeScaleType GetTimeScale( AstTimeFrame *, int * );
+static int TestTimeScale( AstTimeFrame *, int * );
+static void ClearTimeScale( AstTimeFrame *, int * );
+static void SetTimeScale( AstTimeFrame *, AstTimeScaleType, int * );
+
+/* Member functions. */
+/* ================= */
+static const char *Abbrev( AstFrame *this_frame, int axis,  const char *fmt,
+                           const char *str1, const char *str2, int *status ) {
+/*
+*  Name:
+*     Abbrev
+
+*  Purpose:
+*     Abbreviate a formatted Frame axis value by skipping leading fields.
+
+*  Type:
+*     Private function.
+
+*  Synopsis:
+*     #include "timeframe.h"
+*     const char *Abbrev( AstFrame *this, int axis, const char *fmt,
+*                         const char *str1, const char *str2, int *status )
+
+*  Class Membership:
+*     TimeFrame member function (over-rides the astAbbrev protected
+*     method inherited from the Frame class).
+
+*  Description:
+*     This function compares two Frame axis values that have been
+*     formatted (using astFormat) 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 Frame.
+*     axis
+*        The number of the Frame axis for which the values have been
+*        formatted (axis numbering starts at zero for the first axis).
+*     fmt
+*        Pointer to a constant null-terminated string containing the
+*        format specification 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.
+*     status
+*        Pointer to the inherited status variable.
+
+*  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 and that they both
+*     apply to the same Frame axis.
+*     - 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 *p1;
+   const char *p2;
+   const char *result;
+   int df;
+   int nc1;
+   int nc2;
+   int ndp;
+
+/* Initialise. */
+   result = str2;
+
+/* Check the global error status. */
+   if ( !astOK ) return result;
+
+/* Validate the axis index. */
+   astValidateAxis( this_frame, axis, 1, "astAbbrev" );
+
+/* Use the parent astAbbrev function unless the Format attribute indicates
+   that axis values are to be formatted as multi-field date/time strings. */
+   df = DateFormat( fmt, &ndp, NULL, status );
+   if( !df ) {
+      result = (*parent_abbrev)( this_frame, axis,  fmt, str1, str2, status );
+
+/* Otherwise, if no "str1" string was supplied find the start of the
+   last field in "str2". */
+   } else if( !str1 ){
+
+/* Initialise a pointer to the start of the next field in the "str2" string
+   (skip leading spaces). */
+      p2 = str2;
+      while( *p2 && isspace( *p2 ) ) p2++;
+
+/* Check the entire string, saving the start of the next field as the
+   returned pointer. */
+      while( *p2 ) {
+         result = p2;
+
+/* Each field in a date/time field consists of digits only (and maybe a
+   decimal point). Find the number of leading digits/dots in this field
+   and increment the point to the following character (the first delimiter
+   character). */
+         p2 += strspn( p2, "0123456789." );
+
+/* Skip inter-field (non-numeric) delimiters. */
+         p2 += strcspn( p2, "0123456789." );
+      }
+
+/* Otherwise, if an "str1" string was supplied find the start of the
+   first differing field in "str2". */
+   } else {
+
+/* Initialise pointers to the start of the next field in each string
+   (skip leading spaces). */
+      p1 = str1;
+      p2 = str2;
+      while( *p1 && isspace( *p1 ) ) p1++;
+      while( *p2 && isspace( *p2 ) ) p2++;
+
+/* Check the entire string */
+      result = p2;
+      while( *p1 && *p2 ) {
+
+/* Each field in a date/time field consists of digits only (and maybe a
+   decimal point). Find the number of leading digits/dots in each string */
+         nc1 = strspn( p1, "0123456789." );
+         nc2 = strspn( p2, "0123456789." );
+
+/* If the next field has different lengths in the two strings, or of the
+   content of the fields differ, break out of th eloop, leaving "result"
+   pointing to the start of the current field. */
+         if( nc1 != nc2 || strncmp( p1, p2, nc1 ) ) {
+            break;
+
+/* If the next field is identical in the two strings, skip to the
+   character following the end of the field. */
+         } else {
+            p1 += nc1;
+            p2 += nc2;
+
+/* Skip inter-field (non-numeric) delimiters. */
+            p1 += strcspn( p1, "0123456789." );
+            p2 += strcspn( p2, "0123456789." );
+         }
+
+/* Prepare to check the next field. */
+         result = p2;
+      }
+   }
+
+/* If an error occurred, clear the returned value. */
+   if ( !astOK ) result = str2;
+
+/* Return the result. */
+   return result;
+}
+
+static double Centre( AstFrame *this_frame, int axis, double value,
+                      double gap, int *status ) {
+/*
+*  Name:
+*     Centre
+
+*  Purpose:
+*     Find a "nice" central value for tabulating Frame axis values.
+
+*  Type:
+*     Private function.
+
+*  Synopsis:
+*     #include "timeframe.h"
+*     double Centre( AstFrame *this_frame, int axis, double value,
+*                    double gap, int *status )
+
+*  Class Membership:
+*     TimeFrame member function (over-rides the protected astCentre method
+*     inherited from the Frame class).
+
+*  Description:
+*     This function returns an axis value which produces a nice formatted
+*     value suitable for a major tick mark on a plot axis, close to the
+*     supplied axis value.
+
+*  Parameters:
+*     this
+*        Pointer to the Frame.
+*     axis
+*        The number of the axis (zero-based) for which a central value
+*        is to be found.
+*     value
+*        An arbitrary axis value in the section that is being plotted.
+*     gap
+*        The gap size.
+
+*  Returned Value:
+*     The nice central axis value.
+
+*  Notes:
+*     - The supplied axis value is returned if the supplied gap size is
+*     zero, or if this function is invoked with the global error status
+*     set, or if it should fail for any reason.
+*/
+
+/* Local Variables: */
+   AstTimeFrame *this;
+   char *date1;
+   char *date2;
+   char *f1;
+   char *f2;
+   char *fres;
+   char *p1;
+   char *p2;
+   char *pres;
+   const char *fmt;
+   const char *date;
+   double result;
+   int df;
+   int fmod;
+   int nc1;
+   int nc2;
+   int ndp;
+   int nres;
+   int v1;
+   int v2;
+
+/* Initialise. */
+   result = value;
+
+/* Check the global error status. */
+   if ( !astOK ) return result;
+
+/* Validate the axis index. */
+   astValidateAxis( this_frame, axis, 1, "astCentre" );
+
+/* Obtain a pointer to the TimeFrame structure. */
+   this = (AstTimeFrame *) this_frame;
+
+/* Use the parent astCentre function unless the Format attribute indicates
+   that axis values are to be formatted as multi-field date/time strings. */
+   fmt = astGetFormat( this, 0 );
+   df = DateFormat( fmt, &ndp, NULL, status );
+   if( !df ) {
+      result = (*parent_centre)( this_frame, axis, value, gap, status );
+
+/* Otherwise. */
+   } else {
+
+/* Format time values one gap above the supplied axis value and one gap below
+   it. Take copies of each string since the astFormat buffer will be
+   over-written by each call. */
+      date = astFormat( this, 0, value - gap );
+      if( date ) date1 = astStore( NULL, date, strlen( date ) + 1 );
+      date = astFormat( this, 0, value + gap );
+      if( date ) date2 = astStore( NULL, date, strlen( date ) + 1 );
+      if( astOK ) {
+
+/* Initialise a formatted version of the returned central value to be
+   equal to "date1". */
+         nres = strlen( date1 );
+         fres = astStore( NULL, date1, nres + 1 );
+
+/* Loop over all characters within the first date. */
+         fmod = 0;
+         nc1 = 0;
+         f1 = NULL;
+         p1 = date1;
+         nc2 = 0;
+         f2 = NULL;
+         p2 = date2;
+         while( 1 ) {
+
+/* If we have not yet found the length of the next numerical field in
+   date1, continue looking for it. */
+            if( !nc1 ) {
+
+/* If we are currently looking for the start of a numerical field, indicate
+   we have found one if the current character is a digit. */
+               if( !f1 ) {
+                  if( isdigit( *p1 ) ) f1 = p1;
+
+/* If we are currently looking for the end of a numeric field, we have
+   found the end if the current character is not a digit. */
+               } else {
+                  if( !isdigit( *p1 ) ) {
+                     nc1 = p1 - f1;
+                  }
+               }
+
+/* Look at the next character */
+               p1++;
+            }
+
+/* If we have not yet found the length of the next numerical field in
+   date2, continue looking for it. */
+            if( !nc2 ) {
+
+/* If we are currently looking for the start of a numerical field, indicate
+   we have found one if the current character is a digit. */
+               if( !f2 ) {
+                  if( isdigit( *p2 ) ) f2 = p2;
+
+/* If we are currently looking for the end of a numeric field, we have
+   found the end if the current character is not a digit. */
+               } else {
+                  if( !isdigit( *p2 ) ) {
+                     nc2 = p2 - f2;
+                  }
+               }
+
+/* Look at the next character */
+               p2++;
+            }
+
+/* If we have found the next numerical field in both dates, convert them
+   to integers. */
+            if( nc1 && nc2 ) {
+               v1 = atoi( f1 );
+               v2 = atoi( f2 );
+
+/* If the values are different, replace this field and all subsequent
+   fields with zeros in the formatted version of the returned central
+   value, and leave the loop. */
+               if( v1 != v2 ) {
+
+                  pres = fres + ( f1 - date1 ) - 1;
+                  while( *(++pres) ) {
+                     if( isdigit( *pres ) ) *pres = '0';
+                  }
+                  fmod = 1;
+
+                  break;
+               }
+
+/* Prepare to look for the next numerical field in both strings. */
+               nc1 = nc2 = 0;
+               f1 = f2 = NULL;
+
+/* If either string has been exhausted, leave the loop. */
+               if( !*p1 || !*p2 ) break;
+            }
+         }
+
+/* If the formatted "nice" value was changed, unformatted it to get the
+   returned axis value. Otherwise we rettina the returned value set
+   earlier. */
+         if( fmod ) {
+            if( astUnformat( this, 0, fres, &result ) != nres && astOK ) {
+               astError( AST__INTER, "astCentre(%s): Error unformatting "
+                         "the central time axis value '%s' (internal AST "
+                         "programming error).", status, astClass( this ), fres );
+            }
+         }
+
+/* Free resources. */
+         fres = astFree( fres );
+      }
+      date1 = astFree( date1 );
+      date2 = astFree( date2 );
+   }
+
+/* If an error occurred, clear the returned value. */
+   if ( !astOK ) result = 0.0;
+
+/* Return the result. */
+   return result;
+}
+
+static int DateFormat( const char *fmt, int *ndp, char *sep, int *status ){
+/*
+*  Name:
+*     DateFormat
+
+*  Purpose:
+*     Determine if TimeFrame values should be formatted as a date.
+
+*  Type:
+*     Private function.
+
+*  Synopsis:
+*     #include "timeframe.h"
+*     int DateFormat( const char *fmt, int *ndp, char *sep, int *status )
+
+*  Class Membership:
+*     TimeFrame member function
+
+*  Description:
+*    This function returns a flag indicating if the supplied Format string
+*    requires the TimeFrame value to be formatted as a date and/or time of
+*    day.
+
+*  Parameters:
+*     fmt
+*        Pointer to Format string.
+*     ndp
+*        A pointer to an integer in which is returned a value indicating
+*        if a time is required as well as a date. A value of -1 will be
+*        returned in no time is required, otherwise the returned value will
+*        equal the number of decimal places required for the seconds field.
+*     sep
+*        A pointer to a char in which is returned the character that
+*        should be used to separate the date and time fields. Ignored if
+*        NULL.
+*     status
+*        Pointer to the inherited status variable.
+
+*  Returned Value:
+*     Non-zero if the formatted TimeFrame value should include a date.
+
+*/
+
+/* Local Variables: */
+   const char *c;
+   int nc;
+   int result;
+
+/* Initialise  */
+   result = 0;
+   *ndp = -1;
+
+/* Check the Format string */
+   if( fmt ) {
+
+/* Find the first non-white character */
+      c = fmt;
+      while( *c && isspace( *c ) ) c++;
+
+/* If the first non-white character starts the string "iso"
+   assume a date is required. If so see if a time is also required
+   (indicated by 1 dot following) and how many seconds of precision are
+   required (the interegr following the dot). */
+      if( !strncmp( c, "iso", 3 ) ) {
+         result = 1;
+         if( astSscanf( c, "iso.%d%n", ndp, &nc ) == 1 ) {
+
+/* Check the separate character (if any) at the end of the format string.
+   Only "T" is allowed. A space is used if no separator is given. */
+            if( sep ) *sep = ( c[ nc ] == 'T' || c[ nc ] == 't' ) ? 'T' : ' ';
+
+         } else {
+            *ndp = -1;
+         }
+      }
+   }
+
+   return result;
+}
+
+static void ClearAttrib( AstObject *this_object, const char *attrib, int *status ) {
+/*
+*  Name:
+*     ClearAttrib
+
+*  Purpose:
+*     Clear an attribute value for a TimeFrame.
+
+*  Type:
+*     Private function.
+
+*  Synopsis:
+*     #include "timeframe.h"
+*     void ClearAttrib( AstObject *this, const char *attrib, int *status )
+
+*  Class Membership:
+*     TimeFrame member function (over-rides the astClearAttrib protected
+*     method inherited from the Frame class).
+
+*  Description:
+*     This function clears the value of a specified attribute for a
+*     TimeFrame, so that the default value will subsequently be used.
+
+*  Parameters:
+*     this
+*        Pointer to the TimeFrame.
+*     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.
+
+*  Notes:
+*     - This function uses one-based axis numbering so that it is
+*     suitable for external (public) use.
+*/
+
+/* Local Variables: */
+   AstTimeFrame *this;           /* Pointer to the TimeFrame structure */
+   char *new_attrib;             /* Pointer value to new attribute name */
+   int len;                      /* Length of attrib string */
+
+/* Check the global error status. */
+   if ( !astOK ) return;
+
+/* Obtain a pointer to the TimeFrame structure. */
+   this = (AstTimeFrame *) this_object;
+
+/* Obtain the length of the "attrib" string. */
+   len = strlen( attrib );
+
+/* Check the attribute name and clear the appropriate attribute. */
+
+/* First look for axis attributes defined by the Frame class. Since a
+   TimeFrame has only 1 axis, we allow these attributes to be specified
+   without a trailing "(axis)" string. */
+   if ( !strcmp( attrib, "direction" ) ||
+        !strcmp( attrib, "bottom" ) ||
+        !strcmp( attrib, "top" ) ||
+        !strcmp( attrib, "format" ) ||
+        !strcmp( attrib, "label" ) ||
+        !strcmp( attrib, "symbol" ) ||
+        !strcmp( attrib, "unit" ) ) {
+
+/* Create a new attribute name from the original by appending the string
+   "(1)" and then use the parent ClearAttrib method. */
+      new_attrib = astMalloc( len + 4 );
+      if( new_attrib ) {
+         memcpy( new_attrib, attrib, len );
+         memcpy( new_attrib + len, "(1)", 4 );
+         (*parent_clearattrib)( this_object, new_attrib, status );
+         new_attrib = astFree( new_attrib );
+      }
+
+/* AlignTimeScale. */
+/* --------------- */
+   } else if ( !strcmp( attrib, "aligntimescale" ) ) {
+      astClearAlignTimeScale( this );
+
+/* ClockLat. */
+/* --------- */
+/* Retained for backward compatibility with older versions of AST in which
+   TimeFrame had ClockLon/Lat attributes (now ObsLon/Lat are used instead). */
+   } else if ( !strcmp( attrib, "clocklat" ) ) {
+      astClearAttrib( this, "obslat" );
+
+/* ClockLon. */
+/* --------- */
+/* Retained for backward compatibility with older versions of AST in which
+   TimeFrame had ClockLon/Lat attributes (now ObsLon/Lat are used instead). */
+   } else if ( !strcmp( attrib, "clocklon" ) ) {
+      astClearAttrib( this, "obslon" );
+
+/* LTOffset. */
+/* --------- */
+   } else if ( !strcmp( attrib, "ltoffset" ) ) {
+      astClearLTOffset( this );
+
+/* TimeOrigin. */
+/* ---------- */
+   } else if ( !strcmp( attrib, "timeorigin" ) ) {
+      astClearTimeOrigin( this );
+
+/* TimeScale. */
+/* ---------- */
+   } else if ( !strcmp( attrib, "timescale" ) ) {
+      astClearTimeScale( this );
+
+/* If the attribute is not recognised, pass it on to the parent method
+   for further interpretation. */
+   } else {
+      (*parent_clearattrib)( this_object, attrib, status );
+   }
+}
+
+static void ClearSystem( AstFrame *this_frame, int *status ) {
+/*
+*  Name:
+*     ClearSystem
+
+*  Purpose:
+*     Clear the System attribute for a TimeFrame.
+
+*  Type:
+*     Private function.
+
+*  Synopsis:
+*     #include "timeframe.h"
+*     void ClearSystem( AstFrame *this_frame, int *status )
+
+*  Class Membership:
+*     TimeFrame member function (over-rides the astClearSystem protected
+*     method inherited from the Frame class).
+
+*  Description:
+*     This function clears the System attribute for a TimeFrame.
+
+*  Parameters:
+*     this
+*        Pointer to the TimeFrame.
+*     status
+*        Pointer to the inherited status variable.
+
+*/
+
+/* Local Variables: */
+   AstSystemType oldsys;         /* System before clearing */
+   AstTimeFrame *this;           /* Pointer to TimeFrame structure */
+
+/* Check the global error status. */
+   if ( !astOK ) return;
+
+/* Obtain a pointer to the TimeFrame structure. */
+   this = (AstTimeFrame *) this_frame;
+
+/* Save the original system */
+   oldsys = astGetSystem( this_frame );
+
+/* Use the parent ClearSystem method to clear the System value. */
+   (*parent_clearsystem)( this_frame, status );
+
+/* Do nothing more if the system has not actually changed. */
+   if( astGetSystem( this_frame ) != oldsys ) {
+
+/* Modify the TimeOrigin value to use the new System */
+      OriginSystem( this, oldsys, "astClearSystem", status );
+
+/* Clear attributes which have system-specific defaults. */
+      astClearLabel( this_frame, 0 );
+      astClearSymbol( this_frame, 0 );
+      astClearTitle( this_frame );
+
+/* If the old system was BEPOCH also clear units and timescale. This is
+   because we need to ensure that TimeScale=TT and Unit=yr will be used
+   in future (these are the only acceptable values for System=BEPOCH). */
+      if( oldsys == AST__BEPOCH ) {
+         astClearUnit( this_frame, 0 );
+         astClearTimeScale( (AstTimeFrame *) this_frame );
+      }
+   }
+}
+
+static void ClearTimeScale( AstTimeFrame *this, int *status ) {
+/*
+*+
+*  Name:
+*     astClearTimeScale
+
+*  Purpose:
+*     Clear the TimeScale attribute for a TimeFrame.
+
+*  Type:
+*     Protected function.
+
+*  Synopsis:
+*     #include "timeframe.h"
+*     void astClearTimeScale( AstTimeFrame *this )
+
+*  Class Membership:
+*     TimeFrame virtual function
+
+*  Description:
+*     This function clears the TimeScale attribute for a TimeFrame.
+
+*  Parameters:
+*     this
+*        Pointer to the TimeFrame.
+
+*-
+*/
+
+/* Check the global error status. */
+   if ( !astOK ) return;
+
+/* If the System is currently set to BEPOCH, then the TimeScale will
+   either be set to TT or will be unset (since SetTimeScale will not
+   allow any other value than TT if the System is BEPOCH). Therefore, if
+   System is BEPOCH, we will not need to modify the TimeOrigin value,
+   since it will already be appropriate. Otherwise, we modify the
+   TimeOrigin value stored in the TimeFrame structure to refer to the
+   default timescale (TAI or TT). */
+   if( astGetSystem( this ) != AST__BEPOCH ) OriginScale( this, AST__TAI,
+                                                     "astClearTimeScale", status );
+
+/* Store a bad value for the timescale in the TimeFrame structure. */
+   this->timescale = AST__BADTS;
+}
+
+static double CurrentTime( AstTimeFrame *this, int *status ){
+/*
+*++
+*  Name:
+c     astCurrentTime
+f     AST_CURRENTTIME
+
+*  Purpose:
+*     Return the current system time.
+
+*  Type:
+*     Public virtual function.
+
+*  Synopsis:
+c     #include "timeframe.h"
+c     double astCurrentTime( AstTimeFrame *this )
+f     RESULT = AST_CURRENTTIME( THIS, STATUS )
+
+*  Class Membership:
+*     TimeFrame method.
+
+*  Description:
+c     This function
+f     This routine
+*     returns the current system time, represented in the form specified
+*     by the supplied TimeFrame. That is, the returned floating point
+*     value should be interpreted using the attribute values of the
+*     TimeFrame. This includes System, TimeOrigin, LTOffset, TimeScale,
+*     and Unit.
+
+*  Parameters:
+c     this
+f     THIS = INTEGER (Given)
+*        Pointer to the TimeFrame.
+f     STATUS = INTEGER (Given and Returned)
+f        The global status.
+
+*  Returned Value:
+c     astCurrentTime()
+f     AST_CURRENTTIME = DOUBLE
+c        A TimeFrame axis value representing the current system time.
+
+*  Notes:
+*     - Values of AST__BAD will be returned if this function is
+c     invoked with the AST error status set, or if it should fail for
+f     invoked with STATUS set to an error value, or if it should fail for
+*     any reason.
+*     - It is assumes that the system time (returned by the C time()
+*     function) follows the POSIX standard, representing a continuous
+*     monotonic increasing count of SI seconds since the epoch 00:00:00
+*     UTC 1 January 1970 AD (equivalent to TAI with a constant offset).
+*     Resolution is one second.
+*     - An error will be reported if the TimeFrame has a TimeScale value
+*     which cannot be converted to TAI (e.g. "angular" systems such as
+*     UT1, GMST, LMST and LAST).
+*     - Any inaccuracy in the system clock will be reflected in the value
+*     returned by this function.
+*--
+*/
+
+/* Local Constants: */
+
+/* Local Variables: */
+   AstMapping *map;
+   double result;
+   double systime;
+
+/* Initialise. */
+   result = AST__BAD;
+
+/* Check the global error status. */
+   if ( !astOK ) return result;
+
+/* Get a Mapping from the system time (TAI seconds relative to "tai_epoch")
+   to the system represented by the supplied TimeFrame. */
+   map = MakeMap( this, AST__MJD, astGetSystem( this ),
+                  AST__TAI, astGetTimeScale( this ),
+                  tai_epoch, astGetTimeOrigin( this ),
+                  "s", astGetUnit( this, 0 ), "astCurrentTime", status );
+   if( !map ) {
+      astError( AST__INCTS, "astCurrentTime(%s): Cannot convert the "
+                "current system time to the required timescale (%s).", status,
+                astGetClass( this ),
+                TimeScaleString( astGetTimeScale( this ), status ) );
+
+/* Get the system time. The "time" function returns a "time_t" which may be
+   encoded in any way. We use "difftime" to convert this into a floating
+   point number of seconds by taking the difference between the current
+   time and zero time. This assumes nothing about the structure of a
+  "time_t" except that zero can be cast into a time_t representing
+   the epoch. */
+   } else {
+      systime = difftime( time( NULL ), (time_t) 0 );
+
+/* Use the Mapping to convert the time into the requied system. */
+      astTran1( map, 1, &systime, 1, &result );
+
+/* Free resources */
+      map = astAnnul( map );
+   }
+
+/* Set result to AST__BAD if an error occurred. */
+   if( !astOK ) result = AST__BAD;
+
+/* Return the result. */
+   return result;
+}
+
+static const char *DefUnit( AstSystemType system, const char *method,
+                            const char *class, int *status ){
+/*
+*  Name:
+*     DefUnit
+
+*  Purpose:
+*     Return the default units for a time coordinate system type.
+
+*  Type:
+*     Private function.
+
+*  Synopsis:
+*     #include "timeframe.h"
+*     const char *DefUnit( AstSystemType system, const char *method,
+*                          const char *class, int *status )
+
+*  Class Membership:
+*     TimeFrame member function.
+
+*  Description:
+*     This function returns a textual representation of the default
+*     units associated with the specified time coordinate system.
+
+*  Parameters:
+*     system
+*        The time coordinate system.
+*     method
+*        Pointer to a string holding the name of the calling method.
+*        This is only for use in constructing error messages.
+*     class
+*        Pointer to a string holding the name of the supplied object class.
+*        This is only for use in constructing error messages.
+*     status
+*        Pointer to the inherited status variable.
+
+*  Returned Value:
+*     A string describing the default units. This string follows the
+*     units syntax described in FITS WCS paper I "Representations of world
+*     coordinates in FITS" (Greisen & Calabretta).
+
+*  Notes:
+*     - A NULL pointer is 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;           /* Value to return */
+
+/* Initialize */
+   result = NULL;
+
+/* Check the global error status. */
+   if ( !astOK ) return result;
+
+/* Get an identifier for the default units. */
+   if( system == AST__MJD ) {
+      result = "d";
+   } else if( system == AST__JD ) {
+      result = "d";
+   } else if( system == AST__BEPOCH ) {
+      result = "yr";
+   } else if( system == AST__JEPOCH ) {
+      result = "yr";
+
+/* Report an error if the coordinate system was not recognised. */
+   } else {
+      astError( AST__SCSIN, "%s(%s): Corrupt %s contains illegal System "
+                "identification code (%d).", status, method, class, class,
+                (int) system );
+   }
+
+/* Return the result. */
+   return result;
+}
+
+static int Fields( AstFrame *this_frame, int axis, const char *fmt,
+                   const char *str, int maxfld, char **fields,
+                   int *nc, double *val, int *status ) {
+/*
+*  Name:
+*     Fields
+
+*  Purpose:
+*     Identify numerical fields within a formatted Axis value.
+
+*  Type:
+*     Protected virtual function.
+
+*  Synopsis:
+*     #include "frame.h"
+*     int Fields( AstFrame *this, int axis, const char *fmt,
+*                 const char *str, int maxfld, char **fields,
+*                 int *nc, double *val )
+
+*  Class Membership:
+*     TimeFrame member function (over-rides the astFields protected
+*     method inherited from the Frame class).
+
+*  Description:
+*     This function identifies the numerical fields within a Frame axis
+*     value that has 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 Frame.
+*     axis
+*        The number of the Frame axis for which the values have been
+*        formatted (axis numbering starts at zero for the first axis).
+*     fmt
+*        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.
+*/
+
+/* Local Variables: */
+   AstTimeFrame *this;
+   char *p;
+   int bad;
+   int df;
+   int ifld;
+   int ndp;
+   int result;
+   int state;
+
+/* Initialise. */
+   result = 0;
+
+/* Check the global error status. */
+   if ( !astOK ) return result;
+
+/* Obtain a pointer to the TimeFrame structure. */
+   this = (AstTimeFrame *) this_frame;
+
+/* Validate the axis index. */
+   (void) astValidateAxis( this, axis, 1, "astFields" );
+
+/* Call the method inherited from the parent Frame class, unless the
+   format string indicates date-time formatting. */
+   df = DateFormat( fmt, &ndp, NULL, status );
+   if( !df ) {
+      result = (*parent_fields)( this_frame, axis, fmt, str, maxfld, fields,
+                                 nc, val, status );
+
+/* Now handle date/time formats.... */
+   } else {
+
+/* Initialise. */
+      for( ifld = 0; ifld < maxfld; ifld++ ) {
+         fields[ ifld ] = NULL;
+         nc[ ifld ] = 0;
+      }
+      if( val ) *val = AST__BAD;
+
+/* The formatted string should always include a date in ISO format - three
+   integer fields separated by dashes. Loop round each character until
+   all characters have been read, or the max number of fields have been
+   obtained, or it is shown that the string is badly formatted. */
+      bad = 0;
+      state = 0;
+      ifld = 0;
+      p = (char *) str - 1;
+      while( *(++p)  && ifld < maxfld && !bad ){
+
+/* Looking for the start of the year field. */
+         if( state == 0 ) {
+            if( isdigit( *p ) ) {
+               fields[ ifld ] = p;
+               nc[ ifld ] = 1;
+               state = 1;
+            } else if( !isspace( *p ) ) {
+               bad = 1;
+            }
+
+/* Looking for the end of the year field. */
+         } else if( state == 1 ) {
+            if( isdigit( *p ) ) {
+               nc[ ifld ]++;
+            } else if( *p != '-' ){
+               bad = 1;
+            } else {
+               state = 2;
+               ifld++;
+            }
+
+/* Looking for the start of the month field. */
+         } else if( state == 2 ) {
+            if( isdigit( *p ) ) {
+               fields[ ifld ] = p;
+               nc[ ifld ] = 1;
+               state = 3;
+            } else {
+               bad = 1;
+            }
+
+/* Looking for the end of the month field. */
+         } else if( state == 3 ) {
+            if( isdigit( *p ) ) {
+               nc[ ifld ]++;
+            } else if( *p != '-' ){
+               bad = 1;
+            } else {
+               state = 4;
+               ifld++;
+            }
+
+/* Looking for the start of the day field. */
+         } else if( state == 4 ) {
+            if( isdigit( *p ) ) {
+               fields[ ifld ] = p;
+               nc[ ifld ] = 1;
+               state = 5;
+            } else {
+               bad = 1;
+            }
+
+/* Looking for the end of the day field. */
+         } else if( state == 5 ) {
+            if( isdigit( *p ) ) {
+               nc[ ifld ]++;
+            } else if( *p != ' ' && *p != 'T' ){
+               bad = 1;
+            } else {
+               state = 6;
+               ifld++;
+            }
+
+/* Looking for the start of the hour field. */
+         } else if( state == 6 ) {
+            if( isdigit( *p ) ) {
+               fields[ ifld ] = p;
+               nc[ ifld ] = 1;
+               state = 7;
+            } else {
+               bad = 1;
+            }
+
+/* Looking for the end of the hour field. */
+         } else if( state == 7 ) {
+            if( isdigit( *p ) ) {
+               nc[ ifld ]++;
+            } else if( *p != ':' ){
+               bad = 1;
+            } else {
+               state = 8;
+               ifld++;
+            }
+
+/* Looking for the start of the minute field. */
+         } else if( state == 8 ) {
+            if( isdigit( *p ) ) {
+               fields[ ifld ] = p;
+               nc[ ifld ] = 1;
+               state = 9;
+            } else {
+               bad = 1;
+            }
+
+/* Looking for the end of the minute field. */
+         } else if( state == 9 ) {
+            if( isdigit( *p ) ) {
+               nc[ ifld ]++;
+            } else if( *p != ':' ){
+               bad = 1;
+            } else {
+               state = 10;
+               ifld++;
+            }
+
+/* Looking for the start of the integer part of the seconds field. */
+         } else if( state == 10 ) {
+            if( isdigit( *p ) ) {
+               fields[ ifld ] = p;
+               nc[ ifld ] = 1;
+               state = 11;
+            } else {
+               bad = 1;
+            }
+
+/* Looking for the end of the integer part of the seconds field. */
+         } else if( state == 11 ) {
+            if( isdigit( *p ) ) {
+               nc[ ifld ]++;
+            } else if( *p != '.' ){
+               bad = 1;
+            } else {
+               state = 12;
+               ifld++;
+            }
+
+/* Looking for the start of the decimal part of the seconds field. */
+         } else if( state == 12 ) {
+            if( isdigit( *p ) ) {
+               fields[ ifld ] = p;
+               nc[ ifld ] = 1;
+               state = 13;
+            } else {
+               bad = 1;
+            }
+
+/* Looking for the end of the decimal part of the seconds field. */
+         } else if( state == 13 ) {
+            if( isdigit( *p ) ) {
+               nc[ ifld ]++;
+            } else if( !isspace( *p ) ){
+               bad = 1;
+            }
+
+         } else {
+            bad = 1;
+         }
+      }
+
+/* If he string is badly formatted, return null values. */
+      if( bad ) {
+         result = 0;
+         for( ifld = 0; ifld < maxfld; ifld++ ) {
+            fields[ ifld ] = NULL;
+            nc[ ifld ] = 0;
+         }
+
+/* Otherwise, unformat the string if required. */
+      } else if( val ) {
+         (void) astUnformat( this, axis, str, val );
+      }
+   }
+
+/* If an error occurred, clear the returned value. */
+   if ( !astOK ) result = 0;
+
+/* Return the result. */
+   return result;
+}
+
+static const char *Format( AstFrame *this_frame, int axis, double value, int *status ) {
+/*
+*  Name:
+*     Format
+
+*  Purpose:
+*     Format a coordinate value for a TimeFrame axis.
+
+*  Type:
+*     Private function.
+
+*  Synopsis:
+*     #include "timeframe.h"
+*     const char *Format( AstFrame *this, int axis, double value, int *status )
+
+*  Class Membership:
+*     TimeFrame member function (over-rides the astFormat method inherited
+*     from the Frame class).
+
+*  Description:
+*     This function returns a pointer to a string containing the formatted
+*     (character) version of a coordinate value for a TimeFrame axis. The
+*     formatting applied is that specified by a previous invocation of the
+*     astSetFormat method. A suitable default format is applied if necessary.
+
+*  Parameters:
+*     this
+*        Pointer to the TimeFrame.
+*     axis
+*        The number of the axis (zero-based) for which formatting is to be
+*        performed.
+*     value
+*        The coordinate value to be formatted, in radians.
+*     status
+*        Pointer to the inherited status variable.
+
+*  Returned Value:
+*     A pointer to a null-terminated string containing the formatted value.
+
+*  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
+   AstMapping *map;
+   AstSystemType sys;
+   AstTimeFrame *this;
+   AstTimeScaleType ts;
+   char *d;
+   char sep;
+   char tbuf[ 100 ];
+   char sign[ 2 ];
+   const char *fmt;
+   const char *result;
+   const char *u;
+   double fd;
+   double mjd;
+   double off;
+   int df;
+   int id;
+   int ihmsf[ 4 ];
+   int im;
+   int iy;
+   int j;
+   int ndp;
+
+/* Initialise */
+   result = NULL;
+
+/* Check the global error status. */
+   if ( !astOK ) return result;
+
+/* Get a pointer to the structure holding thread-specific global data. */
+   astGET_GLOBALS(this_frame);
+
+/* Obtain a pointer to the TimeFrame structure. */
+   this = (AstTimeFrame *) this_frame;
+
+/* Validate the axis index. */
+   (void) astValidateAxis( this, axis, 1, "astFormat" );
+
+/* Check if a bad coordinate value was supplied and return a pointer to an
+   appropriate string if necessary. */
+   if ( value == AST__BAD ) {
+      result = "<bad>";
+   } else {
+
+/* If the format string does not indicate a date/time format, invoke the
+   parent Format method. */
+      fmt = astGetFormat( this, 0 );
+      df = DateFormat( fmt, &ndp, &sep, status );
+      if( !df ) {
+         result = (*parent_format)( this_frame, axis, value, status );
+
+/* Otherwise, format the value as a date/time */
+      } else {
+
+/* Convert the value to an absolute MJD in units of days. */
+         ts = astGetTimeScale( this );
+         sys = astGetSystem( this );
+         off = astGetTimeOrigin( this );
+         u = astGetUnit( this, 0 );
+         map = MakeMap( this, sys, AST__MJD, ts, ts, off, 0.0, u, "d",
+                        "astFormat", status );
+         if( map ) {
+            astTran1( map, 1, &value, 1, &mjd );
+            map = astAnnul( map );
+
+/* If no time fields will be produced, round to the nearest day. */
+            if( ndp < 0 ) mjd = (int) ( mjd + 0.5 );
+
+/* Convert the MJD into a set of numeric date fields, plus day fraction,
+   and format them. */
+            palDjcl( mjd, &iy, &im, &id, &fd, &j );
+            d = format_buff;
+            d += sprintf( d, "%4d-%2.2d-%2.2d", iy, im, id );
+
+/* If required, convert the day fraction into a set of numerical time
+   fields. */
+            if( ndp >= 0 ) {
+               palDd2tf( ndp, fd, sign, ihmsf );
+
+/* Format the time fields. */
+               if( ndp > 0 ) {
+                  (void) sprintf( tbuf, "%c%2.2d:%2.2d:%2.2d.%*.*d", sep,
+                                  ihmsf[0], ihmsf[1], ihmsf[2], ndp, ndp,
+                                  ihmsf[3] );
+               } else {
+                  (void) sprintf( tbuf, "%c%2.2d:%2.2d:%2.2d", sep, ihmsf[0],
+                                  ihmsf[1], ihmsf[2] );
+               }
+
+/* Add in the formatted time. */
+               d += sprintf( d, "%s", tbuf );
+
+            }
+            result = format_buff;
+         }
+      }
+   }
+
+/* If an error occurred, clear the returned value. */
+   if ( !astOK ) result = NULL;
+
+/* Return the result. */
+   return result;
+}
+
+static double FromMJD( AstTimeFrame *this, double oldval, int *status ){
+/*
+*
+*  Name:
+*     FromMJD
+
+*  Purpose:
+*     Convert a supplied MJD value to the System of the supplied TimeFrame.
+
+*  Type:
+*     Private function.
+
+*  Synopsis:
+*     #include "timeframe.h"
+*     double FromMJD( AstTimeFrame *this, double oldval, int *status )
+
+*  Class Membership:
+*     TimeFrame member function
+
+*  Description:
+*     This function converts the supplied time value from an MJD to
+*     the System of the supplied TimeFrame.
+
+*  Parameters:
+*     this
+*        Pointer to the TimeFrame.
+*     oldval
+*        The value to be converted. It is assume to be an absolute MJD
+*        value (i.e. zero offset) in units of days.
+*     status
+*        Pointer to the inherited status variable.
+
+*  Returned Value:
+*     The converted value (with zero offset), in the default units
+*     associated with the System of "this".
+
+*/
+
+/* Local Variables: */
+   AstTimeMap *timemap;
+   AstSystemType newsys;
+   double args[ 2 ];
+   double result;
+
+/* Initialise. */
+   result = AST__BAD;
+
+/* Check the global error status. */
+   if ( !astOK ) return result;
+
+/* Get the System attribute from the supplied TimeFrame. */
+   newsys = astGetSystem( this );
+
+/* If this is MJD just return the value unchanged. */
+   if( newsys == AST__MJD ) {
+      result = oldval;
+
+/* Otherwise create a TimeMap wich converts from the MJD to the required
+   system, and use it to transform the supplied value. */
+   } else {
+      timemap = astTimeMap( 0, "", status );
+
+/* The supplied and returned values are assumed to have zero offset.*/
+      args[ 0 ] = 0.0;
+      args[ 1 ] = 0.0;
+
+/* If required, add a TimeMap conversion which converts from MJD to the
+   new system. */
+      if( newsys == AST__JD ) {
+         astTimeAdd( timemap, "MJDTOJD", 2, args );
+
+      } else if( newsys == AST__JEPOCH ) {
+         astTimeAdd( timemap, "MJDTOJEP", 2, args );
+
+      } else if( newsys == AST__BEPOCH ) {
+         astTimeAdd( timemap, "MJDTOBEP", 2, args );
+      }
+
+/* Use the TimeMap to convert the supplied value. */
+      astTran1( timemap, 1, &oldval, 1, &result );
+
+/* Free resources */
+      timemap = astAnnul( timemap );
+
+   }
+
+/* Return the result */
+   return result;
+}
+
+
+static double Gap( AstFrame *this_frame, int axis, double gap, int *ntick, int *status ) {
+/*
+*  Name:
+*     Gap
+
+*  Purpose:
+*     Find a "nice" gap for tabulating Frame axis values.
+
+*  Type:
+*     Private function.
+
+*  Synopsis:
+*     #include "timeframe.h"
+*     double Gap( AstFrame *this, int axis, double gap, int *ntick, int *status )
+
+*  Class Membership:
+*     TimeFrame member function (over-rides the astGap protected
+*     method inherited from the Frame class).
+
+*  Description:
+*     This function returns a gap size which produces a nicely spaced
+*     series of formatted values for a Frame axis, 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 Frame.
+*     axis
+*        The number of the axis (zero-based) for which a gap is to be found.
+*     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.
+*     status
+*        Pointer to the inherited status variable.
+
+*  Returned Value:
+*     The nice gap size.
+
+*  Notes:
+*     - A value of zero is returned if the target 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: */
+   AstMapping *map;
+   AstTimeFrame *this;
+   AstTimeScaleType ts;
+   const char *fmt;
+   double mjdgap;
+   double result;
+   double xin[2];
+   double xout[2];
+   int df;
+   int ndp;
+
+/* Initialise. */
+   result = 0.0;
+
+/* Check the global error status. */
+   if ( !astOK ) return result;
+
+/* Validate the axis index. */
+   astValidateAxis( this_frame, axis, 1, "astGap" );
+
+/* Obtain a pointer to the TimeFrame structure. */
+   this = (AstTimeFrame *) this_frame;
+
+/* Use the parent astGap function unless the Format attribute indicates
+   that axis values are to be formatted as multi-field date/time strings. */
+   fmt = astGetFormat( this, 0 );
+   df = DateFormat( fmt, &ndp, NULL, status );
+   if( !df ) {
+      result = (*parent_gap)( this_frame, axis, gap, ntick, status );
+
+/* Otherwise. */
+   } else {
+
+/* Get a Mapping which converts TimeFrame values to MJD values. */
+      ts = astGetTimeScale( this );
+      map = MakeMap( this, astGetSystem( this ), AST__MJD, ts, ts,
+                     astGetTimeOrigin( this ), 0.0, astGetUnit( this, 0 ),
+                     "d", "astGap", status );
+      if( map ) {
+
+/* Use it to transform two TimeFrame times to MJD. The first is the
+   current time, and the second is the current time plus the target gap. */
+         xin[ 0 ] = astCurrentTime( this );
+         xin[ 1 ] = xin[ 0 ] + gap;
+         astTran1( map, 2, xin, 1, xout );
+
+/* Find the target MJD gap. */
+         mjdgap = xout[ 1 ] - xout[ 0 ];
+
+/* If it is 1 year or more, use the parent astGap method to find a nice
+   number of years, and convert back to days. */
+         if( mjdgap >= 365.25 ) {
+            mjdgap = 365.25*(*parent_gap)( this_frame, axis, mjdgap/365.25, ntick, status );
+
+/* If it is more than 270 days days use 1 year. */
+         } else if( mjdgap > 270.0 ) {
+            mjdgap = 365.25;
+            *ntick = 4;
+
+/* If it is more than 150 days days use 180 days (roughly half a year).
+   Use 6 divisions (30 days each, or roughly 1 month). */
+         } else if( mjdgap > 150.0 ) {
+            mjdgap = 180.0;
+            *ntick = 6;
+
+/* If it is more than 90 days days use 120 days (roughly 4 months). */
+         } else if( mjdgap > 90.0 ) {
+            mjdgap = 120.0;
+            *ntick = 4;
+
+/* If it is more than 45 days days use 60 days (roughly 2 months). */
+         } else if( mjdgap > 45.0 ) {
+            mjdgap = 60.0;
+            *ntick = 2;
+
+/* If it is more than 22 days days use 30 days (roughly one month). Use 3
+   ten day divisions. */
+         } else if( mjdgap > 22.0 ) {
+            mjdgap = 30.0;
+            *ntick = 3;
+
+/* If it is more than 12 days days use 15 days (roughly half a month). */
+         } else if( mjdgap > 12.0 ) {
+            mjdgap = 15.0;
+            *ntick = 3;
+
+/* If it is more than 7.5 days days use 10 days, with 5 two-day divisions. */
+         } else if( mjdgap > 7.5 ) {
+            mjdgap = 10.0;
+            *ntick = 5;
+
+/* If it is more than 4.5 days days use 5 days. */
+         } else if( mjdgap > 4.5 ) {
+            mjdgap = 5.0;
+            *ntick = 5;
+
+/* If it is more than 3 days days use 4 days. */
+         } else if( mjdgap > 3.0 ) {
+            mjdgap = 4.0;
+            *ntick = 4;
+
+/* If it is more than 1.5 days days use 2 days. */
+         } else if( mjdgap > 1.5 ) {
+            mjdgap = 2.0;
+            *ntick = 2;
+
+/* If it is more than 0.5 of a day use 1 day. */
+         } else if( mjdgap > 0.5 ) {
+            mjdgap = 1.0;
+            *ntick = 4;
+
+/* Otherwise, if the format indicates that no time field is allowed,
+   use 1 day. */
+         } else if( ndp < 0 ) {
+            mjdgap = 1.0;
+            *ntick = 2;
+
+/* Otherwise (i.e. if the target gap is 0.5 day or less and the format
+   indicates that a time field is allowed), choose a value which looks
+   nice. */
+         } else if( mjdgap >= 6.0/24.0 ) {    /* 12 hours */
+            mjdgap = 12.0/24.0;
+            *ntick = 4;
+
+         } else if( mjdgap >= 3.0/24.0 ) {     /* 6 hours */
+            mjdgap = 6.0/24.0;
+            *ntick = 3;
+
+         } else if( mjdgap >= 1.0/24.0 ) {     /* 2 hours */
+            mjdgap = 2.0/24.0;
+            *ntick = 4;
+
+         } else if( mjdgap >= 30.0/1440.0 ) {     /* 1 hour */
+            mjdgap = 60.0/1440.0;
+            *ntick = 4;
+
+         } else if( mjdgap >= 15.0/1440.0 ) {  /* 30 minutes */
+            mjdgap = 30.0/1440.0;
+            *ntick = 3;
+
+         } else if( mjdgap >= 5.0/1440.0 ) {  /* 10 minutes */
+            mjdgap = 10.0/1440.0;
+            *ntick = 5;
+
+         } else if( mjdgap >= 2.5/1440.0 ) {  /* 5 minutes */
+            mjdgap = 5.0/1440.0;
+            *ntick = 5;
+
+         } else if( mjdgap >= 1.0/1440.0 ) {  /* 2 minutes */
+            mjdgap = 2.0/1440.0;
+            *ntick = 4;
+
+         } else if( mjdgap >= 0.5/1440.0 ) {   /* 1 minute */
+            mjdgap = 1.0/1440.0;
+            *ntick = 4;
+
+         } else if( mjdgap >= 15.0/86400.0 ) { /* 30 seconds */
+            mjdgap = 30.0/86400.0;
+            *ntick = 3;
+
+         } else if( mjdgap >= 5.0/86400.0 ) { /* 10 seconds */
+            mjdgap = 10.0/86400.0;
+            *ntick = 5;
+
+         } else if( mjdgap >= 2.5/86400.0 ) { /* 5 seconds */
+            mjdgap = 5.0/86400.0;
+            *ntick = 5;
+
+         } else if( mjdgap >= 1.0/86400.0 ) { /* 2 seconds */
+            mjdgap = 2.0/86400.0;
+            *ntick = 4;
+
+         } else if( mjdgap >= 0.5/86400.0 ) {  /* 1 second */
+            mjdgap = 1.0/86400.0;
+            *ntick = 4;
+
+         } else {                              /* Less than 1 second */
+            mjdgap = 86400.0*(*parent_gap)( this_frame, axis, mjdgap/86400.0, ntick, status );
+
+         }
+
+/* Convert the MJD gap back into the system of the supplied TimeFrame. */
+         xout[ 1 ] = xout[ 0 ] + mjdgap;
+         astTran1( map, 2, xout, 0, xin );
+         result = xin[ 1 ] - xin[ 0 ];
+
+/* Free resources */
+         map = astAnnul( map );
+
+/* If no Mapping could be found, use the parent astGap method. */
+      } else {
+         result = (*parent_gap)( this_frame, axis, gap, ntick, status );
+      }
+   }
+
+/* If an error occurred, clear the returned value. */
+   if ( !astOK ) result = 0.0;
+
+/* Return the result. */
+   return result;
+}
+
+static int GetActiveUnit( AstFrame *this_frame, int *status ) {
+/*
+*  Name:
+*     GetActiveUnit
+
+*  Purpose:
+*     Obtain the value of the ActiveUnit flag for a TimeFrame.
+
+*  Type:
+*     Private function.
+
+*  Synopsis:
+*     #include "timeframe.h"
+*     int GetActiveUnit( AstFrame *this_frame, int *status )
+
+*  Class Membership:
+*     TimeFrame member function (over-rides the astGetActiveUnit protected
+*     method inherited from the Frame class).
+
+*  Description:
+*    This function returns the value of the ActiveUnit flag for a
+*    TimeFrame, which is always 1.
+
+*  Parameters:
+*     this
+*        Pointer to the TimeFrame.
+*     status
+*        Pointer to the inherited status variable.
+
+*  Returned Value:
+*     The value to use for the ActiveUnit flag (1).
+
+*/
+   return 1;
+}
+
+static const char *GetAttrib( AstObject *this_object, const char *attrib, int *status ) {
+/*
+*  Name:
+*     GetAttrib
+
+*  Purpose:
+*     Get the value of a specified attribute for a TimeFrame.
+
+*  Type:
+*     Private function.
+
+*  Synopsis:
+*     #include "timeframe.h"
+*     const char *GetAttrib( AstObject *this, const char *attrib, int *status )
+
+*  Class Membership:
+*     TimeFrame member function (over-rides the protected astGetAttrib
+*     method inherited from the Frame class).
+
+*  Description:
+*     This function returns a pointer to the value of a specified
+*     attribute for a TimeFrame, formatted as a character string.
+
+*  Parameters:
+*     this
+*        Pointer to the TimeFrame.
+*     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:
+*     - This function uses one-based axis numbering so that it is
+*     suitable for external (public) use.
+*     - The returned string pointer may point at memory allocated
+*     within the TimeFrame, 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 TimeFrame. 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: */
+   AstTimeFrame *this;           /* Pointer to the TimeFrame structure */
+   AstTimeScaleType ts;          /* Time scale */
+   astDECLARE_GLOBALS            /* Declare the thread specific global data */
+   char *new_attrib;             /* Pointer value to new attribute name */
+   const char *result;           /* Pointer value to return */
+   double dval;                  /* Attribute value */
+   int len;                      /* Length of attrib string */
+
+/* Initialise. */
+   result = NULL;
+
+/* Check the global error status. */
+   if ( !astOK ) return result;
+
+/* Get a pointer to the structure holding thread-specific global data. */
+   astGET_GLOBALS(this_object);
+
+/* Obtain a pointer to the TimeFrame structure. */
+   this = (AstTimeFrame *) this_object;
+
+/* Obtain the length of the attrib string. */
+   len = strlen( attrib );
+
+/* Compare "attrib" with each recognised attribute name in turn,
+   obtaining the value of the required attribute. If necessary, write
+   the value into "getattrib_buff" as a null-terminated string in an appropriate
+   format.  Set "result" to point at the result string. */
+
+/* First look for axis attributes defined by the Frame class. Since a
+   TimeFrame has only 1 axis, we allow these attributes to be specified
+   without a trailing "(axis)" string. */
+   if ( !strcmp( attrib, "direction" ) ||
+        !strcmp( attrib, "bottom" ) ||
+        !strcmp( attrib, "top" ) ||
+        !strcmp( attrib, "format" ) ||
+        !strcmp( attrib, "label" ) ||
+        !strcmp( attrib, "symbol" ) ||
+        !strcmp( attrib, "unit" ) ) {
+
+/* Create a new attribute name from the original by appending the string
+   "(1)" and then use the parent GetAttrib method. */
+      new_attrib = astMalloc( len + 4 );
+      if( new_attrib ) {
+         memcpy( new_attrib, attrib, len );
+         memcpy( new_attrib + len, "(1)", 4 );
+         result = (*parent_getattrib)( this_object, new_attrib, status );
+         new_attrib = astFree( new_attrib );
+      }
+
+/* AlignTimeScale. */
+/* --------------- */
+/* Obtain the AlignTimeScale code and convert to a string. */
+   } else if ( !strcmp( attrib, "aligntimescale" ) ) {
+      ts = astGetAlignTimeScale( this );
+      if ( astOK ) {
+         result = TimeScaleString( ts, status );
+
+/* Report an error if the value was not recognised. */
+         if ( !result ) {
+            astError( AST__SCSIN,
+                     "astGetAttrib(%s): Corrupt %s contains invalid AlignTimeScale "
+                     "identification code (%d).", status, astGetClass( this ),
+                     astGetClass( this ), (int) ts );
+         }
+      }
+
+/* ClockLat. */
+/* ------- */
+   } else if ( !strcmp( attrib, "clocklat" ) ) {
+      result = astGetAttrib( this, "obslat" );
+
+/* ClockLon. */
+/* ------- */
+   } else if ( !strcmp( attrib, "clocklon" ) ) {
+      result = astGetAttrib( this, "obslon" );
+
+/* TimeOrigin. */
+/* ----------- */
+   } else if ( !strcmp( attrib, "timeorigin" ) ) {
+      dval = GetTimeOriginCur( this, status );
+      if( astOK ) {
+         (void) sprintf( getattrib_buff, "%.*g", AST__DBL_DIG, dval );
+         result = getattrib_buff;
+      }
+
+/* LTOffset. */
+/* --------- */
+   } else if ( !strcmp( attrib, "ltoffset" ) ) {
+      dval = astGetLTOffset( this );
+      if( astOK ) {
+         (void) sprintf( getattrib_buff, "%.*g", AST__DBL_DIG, dval );
+         result = getattrib_buff;
+      }
+
+/* TimeScale. */
+/* ---------- */
+/* Obtain the TimeScale code and convert to a string. */
+   } else if ( !strcmp( attrib, "timescale" ) ) {
+      ts = astGetTimeScale( this );
+      if ( astOK ) {
+         result = TimeScaleString( ts, status );
+
+/* Report an error if the value was not recognised. */
+         if ( !result ) {
+            astError( AST__SCSIN,
+                     "astGetAttrib(%s): Corrupt %s contains invalid TimeScale "
+                     "identification code (%d).", status, astGetClass( this ),
+                     astGetClass( this ), (int) ts );
+         }
+      }
+
+/* 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 double GetTimeOriginCur( AstTimeFrame *this, int *status ) {
+/*
+*  Name:
+*     GetTimeOriginCur
+
+*  Purpose:
+*     Obtain the TimeOrigin attribute for a TimeFrame in current units.
+
+*  Type:
+*     Private function.
+
+*  Synopsis:
+*     #include "timeframe.h"
+*     double GetTimeOriginCur( AstTimeFrame *this, int *status )
+
+*  Class Membership:
+*     TimeFrame virtual function
+
+*  Description:
+*     This function returns the TimeOrigin attribute for a TimeFrame, in
+*     the current units of the TimeFrame. The protected astGetTimeOrigin
+*     method can be used to obtain the time origin in the default units of
+*     the TimeFrame's System.
+
+*  Parameters:
+*     this
+*        Pointer to the TimeFrame.
+*     status
+*        Pointer to the inherited status variable.
+
+*  Returned Value:
+*     The TimeOrigin value, in the units, system and timescale specified
+*     by the current values of the Unit, System and TimeScale attributes
+*     within "this".
+
+*  Notes:
+*     - AST__BAD is returned if this function is invoked with
+*     the global error status set or if it should fail for any reason.
+*/
+
+/* Local Variables: */
+   AstMapping *map;
+   const char *cur;
+   const char *def;
+   double result;
+   double defval;
+
+/* Initialise. */
+   result = AST__BAD;
+
+/* Check the global error status. */
+   if ( !astOK ) return result;
+
+/* Get the value in the default units */
+   result = astGetTimeOrigin( this );
+
+/* If non-zero we convert to the current units.*/
+   if( result != 0.0 && result != AST__BAD ) {
+
+/* Get the default units for the TimeFrame's System. */
+      def = DefUnit( astGetSystem( this ), "astGetTimeOrigin", "TimeFrame", status );
+
+/* Get the current units from the TimeFrame. */
+      cur = astGetUnit( this, 0 );
+
+/* If the units differ, get a Mapping from default to current units. */
+      if( cur && def ){
+         if( strcmp( cur, def ) ) {
+            map = astUnitMapper( def, cur, NULL, NULL );
+
+/* Report an error if the units are incompatible. */
+            if( !map ) {
+               astError( AST__BADUN, "%s(%s): The current units (%s) are not suitable "
+                         "for a TimeFrame.", status, "astGetTimeOrigin", astGetClass( this ),
+                         cur );
+
+/* Otherwise, transform the stored origin value.*/
+            } else {
+               defval = result;
+               astTran1( map, 1, &defval, 1, &result );
+               map = astAnnul( map );
+            }
+         }
+      }
+   }
+
+/* Return the result. */
+   return result;
+}
+
+static const char *GetDomain( AstFrame *this_frame, int *status ) {
+/*
+*  Name:
+*     GetDomain
+
+*  Purpose:
+*     Obtain a pointer to the Domain attribute string for a TimeFrame.
+
+*  Type:
+*     Private function.
+
+*  Synopsis:
+*     #include "timeframe.h"
+*     const char *GetDomain( AstFrame *this, int *status )
+
+*  Class Membership:
+*     TimeFrame member function (over-rides the astGetDomain protected
+*     method inherited from the Frame class).
+
+*  Description:
+*    This function returns a pointer to the Domain attribute string
+*    for a TimeFrame.
+
+*  Parameters:
+*     this
+*        Pointer to the TimeFrame.
+*     status
+*        Pointer to the inherited status variable.
+
+*  Returned Value:
+*     A pointer to a constant null-terminated string containing the
+*     Domain value.
+
+*  Notes:
+*     - The returned pointer or the string it refers to may become
+*     invalid following further invocation of this function or
+*     modification of the TimeFrame.
+*     - A NULL pointer is returned if this function is invoked with
+*     the global error status set or if it should fail for any reason.
+*/
+
+/* Local Variables: */
+   AstTimeFrame *this;           /* Pointer to TimeFrame structure */
+   const char *result;           /* Pointer value to return */
+
+/* Initialise. */
+   result = NULL;
+
+/* Check the global error status. */
+   if ( !astOK ) return result;
+
+/* Obtain a pointer to the TimeFrame structure. */
+   this = (AstTimeFrame *) this_frame;
+
+/* If a Domain attribute string has been set, invoke the parent method
+   to obtain a pointer to it. */
+   if ( astTestDomain( this ) ) {
+      result = (*parent_getdomain)( this_frame, status );
+
+/* Otherwise, provide a pointer to a suitable default string. */
+   } else {
+      result = "TIME";
+   }
+
+/* Return the result. */
+   return result;
+}
+
+static double GetEpoch( AstFrame *this_frame, int *status ) {
+/*
+*  Name:
+*     GetEpoch
+
+*  Purpose:
+*     Get a value for the Epoch attribute of a TimeFrame.
+
+*  Type:
+*     Private function.
+
+*  Synopsis:
+*     #include "timeframe.h"
+*     double GetEpoch( AstFrame *this, int *status )
+
+*  Class Membership:
+*     TimeFrame member function (over-rides the astGetEpoch method
+*     inherited from the Frame class).
+
+*  Description:
+*     This function returns a value for the Epoch attribute of a
+*     TimeFrame.
+
+*  Parameters:
+*     this
+*        Pointer to the TimeFrame.
+*     status
+*        Pointer to the inherited status variable.
+
+*  Returned Value:
+*     The Epoch attribute value.
+
+*  Notes:
+*     - 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: */
+   AstMapping *map;
+   AstSystemType sys;
+   AstTimeFrame *this;
+   AstTimeScaleType ts;
+   const char *u;
+   double oldval;
+   double result;
+
+/* Initialise. */
+   result = AST__BAD;
+
+/* Check the global error status. */
+   if ( !astOK ) return result;
+
+/* Obtain a pointer to the TimeFrame structure. */
+   this = (AstTimeFrame *) this_frame;
+
+/* If an Epoch attribute value has been set, invoke the parent method
+   to obtain it. */
+   if ( astTestEpoch( this ) ) {
+      result = (*parent_getepoch)( this_frame, status );
+
+/* Otherwise, if the TimeOrigin value is set in the TimeFrame,
+   return it, converted to an absolute TDB MJD. */
+   } else if( astTestTimeOrigin( this ) ){
+
+/* Get the required properties of the TimeFrame. */
+      oldval = astGetTimeOrigin( this );
+      ts = astGetTimeScale( this );
+      sys = astGetSystem( this );
+      u = DefUnit( sys, "astGetEpoch", "TimeFrame", status );
+
+/* Epoch is defined as a TDB value. If the timescale is stored in an angular
+   timescale such as UT1, then we would not normally be able to convert it
+   to TDB since knowledge of DUT1 is required (the difference between UTC
+   and UT1). Since the default Epoch value is not critical we assume a DUT1
+   value of zero in this case. We first map the stored value to UT1 then
+   from UTC to TDB (using the approximation UT1 == UTC). */
+      if( ts == AST__UT1 || ts == AST__GMST ||
+          ts == AST__LAST || ts == AST__LMST ) {
+         map = MakeMap( this, sys, AST__MJD, ts, AST__UT1, 0.0, 0.0, u,
+                        "d", "astGetEpoch", status );
+         if( map ) {
+            astTran1( map, 1, &oldval, 1, &result );
+            map = astAnnul( map );
+
+/* Update the values to use when converting to TBD. */
+            oldval = result;
+            ts = AST__UTC;
+            sys = AST__MJD;
+            u = "d";
+
+         } else if( astOK ) {
+            astError( AST__INTER, "astGetEpoch(%s): No Mapping from %s to "
+                      "UT1 (AST internal programming error).", status,
+                      astGetClass( this ), TimeScaleString(  ts, status ) );
+         }
+      }
+
+/* Now convert to TDB */
+      map = MakeMap( this, sys, AST__MJD, ts, AST__TDB, 0.0, 0.0, u,
+                     "d", "astGetEpoch", status );
+      if( map ) {
+         oldval = astGetTimeOrigin( this );
+         astTran1( map, 1, &oldval, 1, &result );
+         map = astAnnul( map );
+
+      } else if( astOK ) {
+         astError( AST__INTER, "astGetEpoch(%s): No Mapping from %s to "
+                   "TDB (AST internal programming error).", status,
+                   astGetClass( this ), TimeScaleString(  ts, status ) );
+      }
+
+/* Otherwise, return the default Epoch value from the parent Frame. */
+   } else {
+      result =  (*parent_getepoch)( this_frame, status );
+   }
+
+/* Return the result. */
+   return result;
+}
+
+static const char *GetLabel( AstFrame *this, int axis, int *status ) {
+/*
+*  Name:
+*     GetLabel
+
+*  Purpose:
+*     Access the Label string for a TimeFrame axis.
+
+*  Type:
+*     Private function.
+
+*  Synopsis:
+*     #include "timeframe.h"
+*     const char *GetLabel( AstFrame *this, int axis, int *status )
+
+*  Class Membership:
+*     TimeFrame member function (over-rides the astGetLabel method inherited
+*     from the Frame class).
+
+*  Description:
+*     This function returns a pointer to the Label string for a specified axis
+*     of a TimeFrame.
+
+*  Parameters:
+*     this
+*        Pointer to the TimeFrame.
+*     axis
+*        Axis index (zero-based) identifying the axis for which information is
+*        required.
+*     status
+*        Pointer to the inherited status variable.
+
+*  Returned Value:
+*     Pointer to a constant null-terminated character string containing the
+*     requested information.
+
+*  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            /* Declare the thread specific global data */
+   AstMapping *map;              /* Mapping between units */
+   AstSystemType system;         /* Code identifying type of time coordinates */
+   char *new_lab;                /* Modified label string */
+   const char *fmt;              /* Pointer to original Format string */
+   const char *result;           /* Pointer to label string */
+   double ltoff;                 /* Local Time offset from UTC (hours) */
+   double orig;                  /* Time origin (seconds) */
+   int fmtSet;                   /* Was Format attribute set? */
+   int ndp;                      /* Number of decimal places for seconds field */
+
+/* Check the global error status. */
+   if ( !astOK ) return NULL;
+
+/* Get a pointer to the structure holding thread-specific global data. */
+   astGET_GLOBALS(this);
+
+/* Initialise. */
+   result = NULL;
+
+/* Validate the axis index. */
+   astValidateAxis( this, axis, 1, "astGetLabel" );
+
+/* Check if a value has been set for the required axis label string. If so,
+   invoke the parent astGetLabel method to obtain a pointer to it. */
+   if ( astTestLabel( this, axis ) ) {
+      result = (*parent_getlabel)( this, axis, status );
+
+/* Otherwise, provide a suitable default label. */
+   } else {
+
+/* If the Format attribute indicates that time values will be formatted
+   as dates, then choose a suitable label. */
+      fmt = astGetFormat( this, 0 );
+      if( DateFormat( fmt, &ndp, NULL, status ) ) {
+         result = ( ndp >= 0 ) ? "Date/Time" : "Date";
+
+/* Otherwise, identify the time coordinate system described by the
+   TimeFrame. */
+      } else {
+         system = astGetSystem( this );
+
+/* If OK, supply a pointer to a suitable default label string. */
+         if ( astOK ) {
+            result = strcpy( getlabel_buff, SystemLabel( system, status ) );
+            getlabel_buff[ 0 ] = toupper( getlabel_buff[ 0 ] );
+
+/* If a non-zero TimeOrigin has been specified, include the offset now as a
+   date/time string. */
+            orig = astGetTimeOrigin( this );
+            if( orig != 0.0 ) {
+
+/* Save the Format attribute, and then temporarily set it to give a date/time
+   string. */
+               fmt = astStore( NULL, fmt, strlen( fmt ) + 1 );
+               fmtSet = astTestFormat( this, 0 );
+               astSetFormat( this, 0, "iso.0" );
+
+/* Format the origin value as an absolute time and append it to the
+   returned label string. Note, the origin always corresponds to a
+   TimeFrame axis value of zero. */
+               sprintf( getlabel_buff + strlen( getlabel_buff ), " offset from %s",
+                        astFormat( this, 0, 0.0 ) );
+
+/* Re-instate the original Format value. */
+               if( fmtSet ) {
+                  astSetFormat( this, 0, fmt );
+               } else {
+                  astClearFormat( this, 0 );
+               }
+
+/* Free the memory holding the copy of the format string. */
+               fmt = astFree( (char *) fmt );
+
+/* If the time of day is "00:00:00", remove it. */
+               if( !strcmp( getlabel_buff + strlen( getlabel_buff ) - 8, "00:00:00" ) ) {
+                  getlabel_buff[ strlen( getlabel_buff ) - 8 ] = 0;
+               }
+            }
+
+/* Modify this default to take account of the current value of the Unit
+   attribute, if set. */
+            if( astTestUnit( this, axis ) ) {
+
+/* Find a Mapping from the default Units for the current System, to the
+   units indicated by the Unit attribute. This Mapping is used to modify
+   the existing default label appropriately. For instance, if the default
+   units is "yr" and the actual units is "log(yr)", then the default label
+   of "Julian epoch" is changed to "log( Julian epoch )". */
+               map = astUnitMapper( DefUnit( system, "astGetLabel",
+                                             astGetClass( this ), status ),
+                                    astGetUnit( this, axis ), result,
+                                    &new_lab );
+               if( new_lab ) {
+                  result = strcpy( getlabel_buff, new_lab );
+                  new_lab = astFree( new_lab );
+               }
+
+/* Annul the unused Mapping. */
+               if( map ) map = astAnnul( map );
+            }
+         }
+      }
+
+/* If the time is a Local Time, indicate the offset from UTC. */
+      if( astGetTimeScale( this ) == AST__LT ) {
+         ltoff = astGetLTOffset( this );
+         if( ltoff >= 0.0 ) {
+            sprintf( getlabel_buff, "%s (UTC+%g)", result, ltoff );
+         } else {
+            sprintf( getlabel_buff, "%s (UTC-%g)", result, -ltoff );
+         }
+         result = getlabel_buff;
+      }
+   }
+
+/* Return the result. */
+   return result;
+}
+
+static const char *GetSymbol( AstFrame *this, int axis, int *status ) {
+/*
+*  Name:
+*     GetSymbol
+
+*  Purpose:
+*     Obtain a pointer to the Symbol string for a TimeFrame axis.
+
+*  Type:
+*     Private function.
+
+*  Synopsis:
+*     #include "timeframe.h"
+*     const char *GetSymbol( AstFrame *this, int axis, int *status )
+
+*  Class Membership:
+*     TimeFrame member function (over-rides the astGetSymbol method inherited
+*     from the Frame class).
+
+*  Description:
+*     This function returns a pointer to the Symbol string for a specified axis
+*     of a TimeFrame.
+
+*  Parameters:
+*     this
+*        Pointer to the TimeFrame.
+*     axis
+*        Axis index (zero-based) identifying the axis for which information is
+*        required.
+*     status
+*        Pointer to the inherited status variable.
+
+*  Returned Value:
+*     Pointer to a constant null-terminated character string containing the
+*     requested information.
+
+*  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            /* Declare the thread specific global data */
+   AstMapping *map;              /* Mapping between units */
+   AstSystemType system;         /* Code identifying type of sky coordinates */
+   char *new_sym;                /* Modified symbol string */
+   const char *result;           /* Pointer to symbol string */
+
+/* Check the global error status. */
+   if ( !astOK ) return NULL;
+
+/* Get a pointer to the structure holding thread-specific global data. */
+   astGET_GLOBALS(this);
+
+/* Initialise. */
+   result = NULL;
+
+/* Validate the axis index. */
+   astValidateAxis( this, axis, 1, "astGetSymbol" );
+
+/* Check if a value has been set for the required axis symbol string. If so,
+   invoke the parent astGetSymbol method to obtain a pointer to it. */
+   if ( astTestSymbol( this, axis ) ) {
+      result = (*parent_getsymbol)( this, axis, status );
+
+/* Otherwise, identify the sky coordinate system described by the TimeFrame. */
+   } else {
+      system = astGetSystem( this );
+
+/* If OK, supply a pointer to a suitable default Symbol string. */
+      if ( astOK ) {
+
+         if( system == AST__MJD ) {
+	    result = "MJD";
+         } else if( system == AST__JD ) {
+	    result = "JD";
+         } else if( system == AST__BEPOCH ) {
+	    result = "BEP";
+         } else if( system == AST__JEPOCH ) {
+	    result = "JEP";
+
+/* Report an error if the coordinate system was not recognised. */
+         } else {
+	    astError( AST__SCSIN, "astGetSymbol(%s): Corrupt %s contains "
+		      "invalid System identification code (%d).", status,
+                      astGetClass( this ), astGetClass( this ), (int) system );
+         }
+
+/* Modify this default to take account of the current value of the Unit
+   attribute, if set. */
+         if( astTestUnit( this, axis ) ) {
+
+/* Find a Mapping from the default Units for the current System, to the
+   units indicated by the Unit attribute. This Mapping is used to modify
+   the existing default symbol appropriately. For instance, if the default
+   units is "yr" and the actual units is "log(yr)", then the default symbol
+   of "JEP" is changed to "log( JEP )". */
+            map = astUnitMapper( DefUnit( system, "astGetSymbol",
+                                          astGetClass( this ), status ),
+                                 astGetUnit( this, axis ), result,
+                                 &new_sym );
+            if( new_sym ) {
+               result = strcpy( getsymbol_buff, new_sym );
+               new_sym = astFree( new_sym );
+            }
+
+/* Annul the unused Mapping. */
+            if( map ) map = astAnnul( map );
+
+         }
+      }
+   }
+
+/* Return the result. */
+   return result;
+}
+
+static AstSystemType GetAlignSystem( AstFrame *this_frame, int *status ) {
+/*
+*  Name:
+*     GetAlignSystem
+
+*  Purpose:
+*     Obtain the AlignSystem attribute for a TimeFrame.
+
+*  Type:
+*     Private function.
+
+*  Synopsis:
+*     #include "Specframe.h"
+*     AstSystemType GetAlignSystem( AstFrame *this_frame, int *status )
+
+*  Class Membership:
+*     TimeFrame member function (over-rides the astGetAlignSystem protected
+*     method inherited from the Frame class).
+
+*  Description:
+*     This function returns the AlignSystem attribute for a TimeFrame.
+
+*  Parameters:
+*     this
+*        Pointer to the TimeFrame.
+*     status
+*        Pointer to the inherited status variable.
+
+*  Returned Value:
+*     The AlignSystem value.
+
+*/
+
+/* Local Variables: */
+   AstTimeFrame *this;           /* Pointer to TimeFrame structure */
+   AstSystemType result;         /* Value to return */
+
+/* Initialise. */
+   result = AST__BADSYSTEM;
+
+/* Check the global error status. */
+   if ( !astOK ) return result;
+
+/* Obtain a pointer to the TimeFrame structure. */
+   this = (AstTimeFrame *) this_frame;
+
+/* If a AlignSystem attribute has been set, invoke the parent method to obtain
+   it. */
+   if ( astTestAlignSystem( this ) ) {
+      result = (*parent_getalignsystem)( this_frame, status );
+
+/* Otherwise, provide a suitable default. */
+   } else {
+      result = AST__MJD;
+   }
+
+/* Return the result. */
+   return result;
+}
+
+static AstTimeScaleType GetAlignTimeScale( AstTimeFrame *this, int *status ) {
+/*
+*+
+*  Name:
+*     astGetAlignTimeScale
+
+*  Purpose:
+*     Obtain the AlignTimeScale attribute for a TimeFrame.
+
+*  Type:
+*     Protected function.
+
+*  Synopsis:
+*     #include "timeframe.h"
+*     AstTimeScaleType GetAlignTimeScale( AstTimeFrame *this )
+
+*  Class Membership:
+*     TimeFrame virtual function
+
+*  Description:
+*     This function returns the System attribute for a TimeFrame.
+
+*  Parameters:
+*     this
+*        Pointer to the TimeFrame.
+
+*  Returned Value:
+*     The System value.
+
+*  Notes:
+*     - AST__BADTS is returned if this function is invoked with
+*     the global error status set or if it should fail for any reason.
+*-
+*/
+
+/* Local Variables: */
+   AstTimeScaleType result;
+   AstTimeScaleType ts;
+
+/* Initialise. */
+   result = AST__BADTS;
+
+/* Check the global error status. */
+   if ( !astOK ) return result;
+
+/* If a value has been set, return it. */
+   if( this->aligntimescale != AST__BADTS ) {
+      result = this->aligntimescale;
+
+/* Otherwise, return a default depending on the current TimeScale value */
+   } else {
+      ts = astGetTimeScale( this );
+      if ( ts == AST__UT1 || ts == AST__LAST || ts == AST__LMST || ts == AST__GMST ) {
+         result = AST__UT1;
+      } else {
+         result = AST__TAI;
+      }
+
+   }
+
+/* Return the result. */
+   return result;
+}
+
+static AstSystemType GetSystem( AstFrame *this_frame, int *status ) {
+/*
+*  Name:
+*     GetSystem
+
+*  Purpose:
+*     Obtain the System attribute for a TimeFrame.
+
+*  Type:
+*     Private function.
+
+*  Synopsis:
+*     #include "timeframe.h"
+*     AstSystemType GetSystem( AstFrame *this_frame, int *status )
+
+*  Class Membership:
+*     TimeFrame member function (over-rides the astGetSystem protected
+*     method inherited from the Frame class).
+
+*  Description:
+*     This function returns the System attribute for a TimeFrame.
+
+*  Parameters:
+*     this
+*        Pointer to the TimeFrame.
+*     status
+*        Pointer to the inherited status variable.
+
+*  Returned Value:
+*     The System value.
+
+*  Notes:
+*     - AST__BADSYSTEM is returned if this function is invoked with
+*     the global error status set or if it should fail for any reason.
+*/
+
+/* Local Variables: */
+   AstTimeFrame *this;           /* Pointer to TimeFrame structure */
+   AstSystemType result;         /* Value to return */
+
+/* Initialise. */
+   result = AST__BADSYSTEM;
+
+/* Check the global error status. */
+   if ( !astOK ) return result;
+
+/* Obtain a pointer to the TimeFrame structure. */
+   this = (AstTimeFrame *) this_frame;
+
+/* If a System attribute has been set, invoke the parent method to obtain
+   it. */
+   if ( astTestSystem( this ) ) {
+      result = (*parent_getsystem)( this_frame, status );
+
+/* Otherwise, provide a suitable default. */
+   } else {
+      result = AST__MJD;
+   }
+
+/* Return the result. */
+   return result;
+}
+
+static AstTimeScaleType GetTimeScale( AstTimeFrame *this, int *status ) {
+/*
+*+
+*  Name:
+*     astGetTimeScale
+
+*  Purpose:
+*     Obtain the TimeScale attribute for a TimeFrame.
+
+*  Type:
+*     Protected function.
+
+*  Synopsis:
+*     #include "timeframe.h"
+*     AstTimeScaleType GetTimeScale( AstTimeFrame *this )
+
+*  Class Membership:
+*     TimeFrame virtual function
+
+*  Description:
+*     This function returns the System attribute for a TimeFrame.
+
+*  Parameters:
+*     this
+*        Pointer to the TimeFrame.
+
+*  Returned Value:
+*     The System value.
+
+*  Notes:
+*     - AST__BADTS is returned if this function is invoked with
+*     the global error status set or if it should fail for any reason.
+*-
+*/
+
+/* Local Variables: */
+   AstTimeScaleType result;
+
+/* Initialise. */
+   result = AST__BADTS;
+
+/* Check the global error status. */
+   if ( !astOK ) return result;
+
+/* If a value has been set, return it. */
+   if( this->timescale != AST__BADTS ) {
+      result = this->timescale;
+
+/* Otherwise, return a default depending on the current System value. */
+   } else {
+      if ( astGetSystem( this ) == AST__BEPOCH ) {
+         result = AST__TT;
+      } else {
+         result = AST__TAI;
+      }
+
+   }
+
+/* Return the result. */
+   return result;
+}
+
+static const char *GetTitle( AstFrame *this_frame, int *status ) {
+/*
+*  Name:
+*     GetTitle
+
+*  Purpose:
+*     Obtain a pointer to the Title string for a TimeFrame.
+
+*  Type:
+*     Private function.
+
+*  Synopsis:
+*     #include "timeframe.h"
+*     const char *GetTitle( AstFrame *this_frame, int *status )
+
+*  Class Membership:
+*     TimeFrame member function (over-rides the astGetTitle method inherited
+*     from the Frame class).
+
+*  Description:
+*     This function returns a pointer to the Title string for a TimeFrame.
+*     A pointer to a suitable default string is returned if no Title value has
+*     previously been set.
+
+*  Parameters:
+*     this
+*        Pointer to the TimeFrame.
+*     status
+*        Pointer to the inherited status variable.
+
+*  Returned Value:
+*     Pointer to a null-terminated character string containing the requested
+*     information.
+
+*  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            /* Declare the thread specific global data */
+   AstSystemType system;         /* Code identifying type of coordinates */
+   AstTimeScaleType ts;          /* Time scale value */
+   AstTimeFrame *this;           /* Pointer to TimeFrame structure */
+   const char *fmt;              /* Pointer to original Format string */
+   const char *result;           /* Pointer to result string */
+   double ltoff;                 /* Local Time offset from UTC (hours) */
+   double orig;                  /* Time origin (seconds) */
+   int fmtSet;                   /* Was Format attribute set? */
+   int nc;                       /* No. of characters added */
+   int ndp;                      /* Number of decimal places */
+   int pos;                      /* Buffer position to enter text */
+
+/* Check the global error status. */
+   if ( !astOK ) return NULL;
+
+/* Get a pointer to the structure holding thread-specific global data. */
+   astGET_GLOBALS(this_frame);
+
+/* Initialise. */
+   result = NULL;
+
+/* Obtain a pointer to the TimeFrame structure. */
+   this = (AstTimeFrame *) this_frame;
+
+/* See if a Title string has been set. If so, use the parent astGetTitle
+   method to obtain a pointer to it. */
+   if ( astTestTitle( this ) ) {
+      result = (*parent_gettitle)( this_frame, status );
+
+/* Otherwise, we will generate a default Title string. Obtain the values of the
+   TimeFrame's attributes that determine what this string will be. */
+   } else {
+      system = astGetSystem( this );
+      orig = GetTimeOriginCur( this, status );
+      ts = astGetTimeScale( this );
+      if ( astOK ) {
+         result = gettitle_buff;
+
+/* Begin with the system's default label. */
+         pos = sprintf( gettitle_buff, "%s", SystemLabel( system, status ) );
+         gettitle_buff[ 0 ] = toupper( gettitle_buff[ 0 ] );
+
+/* Append the time scale code, if a value has been set for the timescale.
+   Do not do this if the system is BEPOCH since BEPOCH can only be used
+   with the TT timescale. */
+         if( system != AST__BEPOCH && astTestTimeScale( this ) ) {
+            nc = sprintf( gettitle_buff + pos, " [%s", TimeScaleString( ts, status ) );
+            pos += nc;
+
+/* For Local Time, include the offset from UTC. */
+            if( ts == AST__LT ) {
+               ltoff = astGetLTOffset( this );
+               if( ltoff >= 0.0 ) {
+                  nc = sprintf( gettitle_buff + pos, " (UTC+%g)", ltoff );
+               } else {
+                  nc = sprintf( gettitle_buff + pos, " (UTC-%g)", -ltoff );
+               }
+               pos += nc;
+            }
+
+/* Close the brackets. */
+            nc = sprintf( gettitle_buff + pos, "]" );
+            pos += nc;
+         }
+
+/* If a non-zero offset has been specified, and the Format attribute does
+   not indicate a date string (which is always absolute), include the
+   offset now as a date/time string. */
+         fmt = astGetFormat( this, 0 );
+         if( orig != 0.0 && !DateFormat( fmt, &ndp, NULL, status ) ) {
+
+/* Save the Format attribute, and then temporarily set it to give a date/time
+   string. */
+            fmt = astStore( NULL, fmt, strlen( fmt ) + 1 );
+            fmtSet = astTestFormat( this, 0 );
+            astSetFormat( this, 0, "iso.0" );
+
+/* Format the origin value as an absolute time and append it to the
+   returned title string. Note, the origin always corresponds to a
+   TimeFrame axis value of zero. */
+            nc = sprintf( gettitle_buff+pos, " offset from %s",
+                          astFormat( this, 0, 0.0 ) );
+            pos += nc;
+
+/* Re-instate the original Format value. */
+            if( fmtSet ) {
+               astSetFormat( this, 0, fmt );
+            } else {
+               astClearFormat( this, 0 );
+            }
+
+/* Free the Format string copy. */
+            fmt = astFree( (char *) fmt );
+
+         }
+      }
+   }
+
+/* If an error occurred, clear the returned pointer value. */
+   if ( !astOK ) result = NULL;
+
+/* Return the result. */
+   return result;
+}
+
+static const char *GetUnit( AstFrame *this_frame, int axis, int *status ) {
+/*
+*  Name:
+*     GetUnit
+
+*  Purpose:
+*     Obtain a pointer to the Unit string for a TimeFrame's axis.
+
+*  Type:
+*     Private function.
+
+*  Synopsis:
+*     #include "timeframe.h"
+*     const char *GetUnit( AstFrame *this_frame, int axis )
+
+*  Class Membership:
+*     TimeFrame member function (over-rides the astGetUnit method inherited
+*     from the Frame class).
+
+*  Description:
+*     This function returns a pointer to the Unit string for a specified axis
+*     of a TimeFrame. If the Unit attribute has not been set for the axis, a
+*     pointer to a suitable default string is returned instead.
+
+*  Parameters:
+*     this
+*        Pointer to the TimeFrame.
+*     axis
+*        The number of the axis (zero-based) for which information is required.
+
+*  Returned Value:
+*     A pointer to a null-terminated string containing the Unit value.
+
+*  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: */
+   AstTimeFrame *this;           /* Pointer to the TimeFrame structure */
+   AstSystemType system;         /* The TimeFrame's System value */
+   const char *result;           /* Pointer value to return */
+
+/* Check the global error status. */
+   if ( !astOK ) return NULL;
+
+/* Obtain a pointer to the TimeFrame structure. */
+   this = (AstTimeFrame *) this_frame;
+
+/* Validate the axis index. */
+   astValidateAxis( this, axis, 1, "astGetUnit" );
+
+/* If a value has been set for the Unit attribute, use the parent
+   GetUnit method to return a pointer to the required Unit string. */
+   if( astTestUnit( this, axis ) ){
+      result = (*parent_getunit)( this_frame, axis, status );
+
+/* Otherwise, identify the time coordinate system described by the
+   TimeFrame. */
+   } else {
+      system = astGetSystem( this );
+
+/* Return a string describing the default units. */
+      result = DefUnit( system, "astGetUnit", astGetClass( this ), status );
+   }
+
+/* If an error occurred, clear the returned value. */
+   if ( !astOK ) result = NULL;
+
+/* Return the result. */
+   return result;
+}
+
+void astInitTimeFrameVtab_(  AstTimeFrameVtab *vtab, const char *name, int *status ) {
+/*
+*+
+*  Name:
+*     astInitTimeFrameVtab
+
+*  Purpose:
+*     Initialise a virtual function table for a TimeFrame.
+
+*  Type:
+*     Protected function.
+
+*  Synopsis:
+*     #include "timeframe.h"
+*     void astInitTimeFrameVtab( AstTimeFrameVtab *vtab, const char *name )
+
+*  Class Membership:
+*     TimeFrame vtab initialiser.
+
+*  Description:
+*     This function initialises the component of a virtual function
+*     table which is used by the TimeFrame 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 */
+   AstFrameVtab *frame;          /* Pointer to Frame component of Vtab */
+   AstMapping *map;              /* Temporary Maping */
+   AstObjectVtab *object;        /* Pointer to Object component of Vtab */
+   double utc_epoch;             /* Unix epoch as a UTC MJD */
+
+/* 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. */
+   astInitFrameVtab( (AstFrameVtab *) vtab, name );
+
+/* Store a unique "magic" value in the virtual function table. This
+   will be used (by astIsATimeFrame) 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 = &(((AstFrameVtab *) vtab)->id);
+
+/* Initialise member function pointers. */
+/* ------------------------------------ */
+/* Store pointers to the member functions (implemented here) that
+   provide virtual methods for this class. */
+
+   vtab->ClearAlignTimeScale = ClearAlignTimeScale;
+   vtab->TestAlignTimeScale = TestAlignTimeScale;
+   vtab->GetAlignTimeScale = GetAlignTimeScale;
+   vtab->SetAlignTimeScale = SetAlignTimeScale;
+
+   vtab->ClearTimeOrigin = ClearTimeOrigin;
+   vtab->TestTimeOrigin = TestTimeOrigin;
+   vtab->GetTimeOrigin = GetTimeOrigin;
+   vtab->SetTimeOrigin = SetTimeOrigin;
+
+   vtab->ClearLTOffset = ClearLTOffset;
+   vtab->TestLTOffset = TestLTOffset;
+   vtab->GetLTOffset = GetLTOffset;
+   vtab->SetLTOffset = SetLTOffset;
+
+   vtab->ClearTimeScale = ClearTimeScale;
+   vtab->TestTimeScale = TestTimeScale;
+   vtab->GetTimeScale = GetTimeScale;
+   vtab->SetTimeScale = SetTimeScale;
+
+   vtab->CurrentTime = CurrentTime;
+
+/* Save the inherited pointers to methods that will be extended, and
+   replace them with pointers to the new member functions. */
+   object = (AstObjectVtab *) vtab;
+   frame = (AstFrameVtab *) vtab;
+
+   parent_clearattrib = object->ClearAttrib;
+   object->ClearAttrib = ClearAttrib;
+   parent_getattrib = object->GetAttrib;
+   object->GetAttrib = GetAttrib;
+   parent_setattrib = object->SetAttrib;
+   object->SetAttrib = SetAttrib;
+   parent_testattrib = object->TestAttrib;
+   object->TestAttrib = TestAttrib;
+
+   parent_getdomain = frame->GetDomain;
+   frame->GetDomain = GetDomain;
+
+   parent_getsystem = frame->GetSystem;
+   frame->GetSystem = GetSystem;
+   parent_setsystem = frame->SetSystem;
+   frame->SetSystem = SetSystem;
+   parent_clearsystem = frame->ClearSystem;
+   frame->ClearSystem = ClearSystem;
+
+   parent_getalignsystem = frame->GetAlignSystem;
+   frame->GetAlignSystem = GetAlignSystem;
+
+   parent_getlabel = frame->GetLabel;
+   frame->GetLabel = GetLabel;
+
+   parent_getsymbol = frame->GetSymbol;
+   frame->GetSymbol = GetSymbol;
+
+   parent_gettitle = frame->GetTitle;
+   frame->GetTitle = GetTitle;
+
+   parent_getepoch = frame->GetEpoch;
+   frame->GetEpoch = GetEpoch;
+
+   parent_getunit = frame->GetUnit;
+   frame->GetUnit = GetUnit;
+
+   parent_setunit = frame->SetUnit;
+   frame->SetUnit = SetUnit;
+
+   parent_match = frame->Match;
+   frame->Match = Match;
+
+   parent_overlay = frame->Overlay;
+   frame->Overlay = Overlay;
+
+   parent_subframe = frame->SubFrame;
+   frame->SubFrame = SubFrame;
+
+   parent_format = frame->Format;
+   frame->Format = Format;
+
+   parent_unformat = frame->Unformat;
+   frame->Unformat = Unformat;
+
+   parent_abbrev = frame->Abbrev;
+   frame->Abbrev = Abbrev;
+
+   parent_fields = frame->Fields;
+   frame->Fields = Fields;
+
+   parent_gap = frame->Gap;
+   frame->Gap = Gap;
+
+   parent_centre = frame->Centre;
+   frame->Centre = Centre;
+
+/* Store replacement pointers for methods which will be over-ridden by new
+   member functions implemented here. */
+   frame->GetActiveUnit = GetActiveUnit;
+   frame->TestActiveUnit = TestActiveUnit;
+   frame->ValidateSystem = ValidateSystem;
+   frame->SystemString = SystemString;
+   frame->SystemCode = SystemCode;
+
+/* Declare the copy constructor, destructor and class dump
+   function. */
+   astSetDump( vtab, Dump, "TimeFrame",
+               "Description of time coordinate system" );
+
+/* Convert the Unix Epoch (00:00:00 UTC 1 January 1970 AD) from UTC to TAI. */
+   LOCK_MUTEX2
+   map = MakeMap( NULL, AST__MJD, AST__MJD, AST__UTC, AST__TAI,
+                  0.0, 0.0, "d", "d", "astInitTimeFrameVtab", status );
+   utc_epoch = UNIX_EPOCH;
+   astTran1( map, 1, &utc_epoch, 1, &tai_epoch );
+   map = astAnnul( map );
+   UNLOCK_MUTEX2
+
+/* 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 AstMapping *MakeMap( AstTimeFrame *this, AstSystemType sys1,
+                            AstSystemType sys2, AstTimeScaleType ts1,
+                            AstTimeScaleType ts2, double off1, double off2,
+                            const char *unit1, const char *unit2,
+                            const char *method, int *status ){
+/*
+*  Name:
+*     MakeMap
+
+*  Purpose:
+*     Make a Mapping between stated timescales and systems.
+
+*  Type:
+*     Private function.
+
+*  Synopsis:
+*     #include "timeframe.h"
+*     AstMapping *MakeMap( AstTimeFrame *this, AstSystemType sys1,
+*                          AstSystemType sys2, AstTimeScaleType ts1,
+*                          AstTimeScaleType ts2, double off1, double off2,
+*                          const char *unit1, const char unit2,
+*                          const char *method, int *status )
+
+*  Class Membership:
+*     TimeFrame member function
+
+*  Description:
+*     This function creates a Mapping from a stated pair of System and
+*     TimeScale to another stated pair.
+
+*  Parameters:
+*     this
+*        A TimeFrame which specifies extra attributes (the clock position,
+*        time zone, etc) for both input and output.
+*     sys1
+*        The input System.
+*     sys2
+*        The output System.
+*     ts1
+*        The input System.
+*     ts2
+*        The output System.
+*     off1
+*        The axis offset used with the input, in the defaults units
+*        associated with "sys1".
+*     off2
+*        The axis offset used with the output, in the defaults units
+*        associated with "sys2".
+*     unit1
+*        The input units.
+*     unit2
+*        The output units.
+*     method
+*        A string containing the method name to include in error messages.
+*     status
+*        Pointer to the inherited status variable.
+
+*  Returned Value:
+*     A pointer to the new Mapping. NULL if the timescales were
+*     incompatible.
+
+*/
+
+
+/* Local Variables: */
+   AstMapping *result;
+   AstMapping *tmap;
+   AstMapping *tmap2;
+   AstMapping *umap;
+   AstMapping *umap1;
+   AstMapping *umap2;
+   AstTimeMap *timemap;
+   const char *du;
+   double args[ 5 ];
+   double args_lt[ 1 ];
+   double args_ut[ 1 ];
+   double args_tai[ 2 ];
+   double shift;
+
+/* Check the global error status. */
+   result = NULL;
+   if ( !astOK ) return result;
+
+/* If the timescales are equal... */
+   if( ts1 == ts2 ) {
+
+/* and the time systems are equal... */
+      if( sys1 == sys2 ) {
+
+/* and the time offsets are equal... */
+         if( astEQUALS( off1, off2, 1.0E3 ) ) {
+
+/* and the units are equal, return a UnitMap. */
+            if( !strcmp( unit1, unit2 ) ) {
+               result = (AstMapping *) astUnitMap( 1, "", status );
+
+/* If only the units differ, return the appropriate units Mapping. */
+            } else {
+               result = astUnitMapper( unit1, unit2, NULL, NULL );
+            }
+
+/* If the time offsets differ... */
+         } else {
+
+/* Transform the difference in offsets from the default units associated
+   with the (common) system, to the units associated with the output. */
+            shift = off1 - off2;
+            du = DefUnit( sys1, method, "TimeFrame", status );
+            if( du && strcmp( du, unit2 ) && shift != 0.0 ) {
+               umap = astUnitMapper( DefUnit( sys1, method, "TimeFrame", status ),
+                                     unit2, NULL, NULL );
+               astTran1( umap, 1, &shift, 1, &shift );
+               umap = astAnnul( umap );
+            }
+
+/* Create a ShiftMap to apply the shift. */
+            result = (AstMapping *) astShiftMap( 1, &shift, "", status );
+
+/* If the input and output units also differ, include the appropriate units
+   Mapping. */
+            if( strcmp( unit1, unit2 ) ) {
+               umap = astUnitMapper( unit1, unit2, NULL, NULL );
+               tmap = (AstMapping *) astCmpMap( umap, result, 1, "", status );
+               umap = astAnnul( umap );
+               (void) astAnnul( result );
+               result = tmap;
+            }
+         }
+      }
+   }
+
+/* If the systems and/or timescales differ, we convert first from the
+   input frame to a common frame, then from the common frame to the output
+   frame. */
+   if( !result ) {
+
+/* First, a Mapping from the input units to the default units for the
+   input System (these are the units expected by the TimeMap conversions). */
+      umap1 = astUnitMapper( unit1, DefUnit( sys1, method, "TimeFrame", status ),
+                             NULL, NULL );
+
+/* Now create a null TimeMap. */
+      timemap = astTimeMap( 0, "", status );
+
+/* Store the input time offsets to use. They correspond to the same moment in
+   time (the second is the MJD equivalent of the first). */
+      args[ 0 ] = off1;
+      args[ 1 ] = ToMJD( sys1, off1, status );
+
+/* Add a conversion from the input System to MJD. */
+      if( sys1 == AST__JD ) {
+         astTimeAdd( timemap, "JDTOMJD", 2, args );
+
+      } else if( sys1 == AST__JEPOCH ) {
+         astTimeAdd( timemap, "JEPTOMJD", 2, args );
+
+      } else if( sys1 == AST__BEPOCH ) {
+         astTimeAdd( timemap, "BEPTOMJD", 2, args );
+      }
+
+/* All timescale conversions except UTTOUTC and UTCTOUT require the input (MJD)
+   offset as the first argument. In general, the observers longitude, latitude
+   and altitude are also needed. The Frame class stores longitude values in a
+   +ve eastwards sense, but the TimeMap class needs +ve westwards, so negate
+   the longitude. */
+      args[ 0 ] = args[ 1 ];
+      args[ 1 ] = this ? -astGetObsLon( this ) : 0.0;
+      args[ 2 ] = this ? astGetObsLat( this ) : 0.0;
+      args[ 3 ] = this ? astGetObsAlt( this ) : 0.0;
+
+/* Currently the only conversion that take 5 arguments require the DTAI
+   value as the 5th argument. */
+      args[ 4 ] = this ? astGetDtai( this ) : AST__BAD;
+
+/* The UTTOUTC and UTCTOUT conversions required just the DUT1 value. */
+      args_ut[ 0 ] = this ? astGetDut1( this ) : 0.0;
+
+/* The LTTOUTC and UTCTOLT conversions required just the time zone
+   correction. */
+      args_lt[ 0 ] = this ? astGetLTOffset( this ) : 0.0;
+
+/* The UTCTOTAI and TAITOUTC conversions require the input offset and DTAI. */
+      args_tai[ 0 ] = args[ 0 ];
+      args_tai[ 1 ] = this ? astGetDtai( this ) : AST__BAD;
+
+/* If the input and output timescales differ, now add a conversion from the
+   input timescale to TAI. */
+      if( ts1 != ts2 ) {
+         if( ts1 == AST__TAI ) {
+
+         } else if( ts1 == AST__UTC ) {
+            astTimeAdd( timemap, "UTCTOTAI", 2, args_tai );
+
+         } else if( ts1 == AST__TT ) {
+            astTimeAdd( timemap, "TTTOTAI", 1, args );
+
+         } else if( ts1 == AST__TDB ) {
+            astTimeAdd( timemap, "TDBTOTT", 5, args );
+            astTimeAdd( timemap, "TTTOTAI", 1, args );
+
+         } else if( ts1 == AST__TCG ) {
+            astTimeAdd( timemap, "TCGTOTT", 1, args );
+            astTimeAdd( timemap, "TTTOTAI", 1, args );
+
+         } else if( ts1 == AST__LT ) {
+            astTimeAdd( timemap, "LTTOUTC", 1, args_lt );
+            astTimeAdd( timemap, "UTCTOTAI", 2, args_tai );
+
+         } else if( ts1 == AST__TCB ) {
+            astTimeAdd( timemap, "TCBTOTDB", 1, args );
+            astTimeAdd( timemap, "TDBTOTT", 5, args );
+            astTimeAdd( timemap, "TTTOTAI", 1, args );
+
+         } else if( ts1 == AST__UT1 ) {
+            astTimeAdd( timemap, "UTTOUTC", 1, args_ut );
+            astTimeAdd( timemap, "UTCTOTAI", 2, args_tai );
+
+         } else if( ts1 == AST__GMST ) {
+            astTimeAdd( timemap, "GMSTTOUT", 1, args );
+            astTimeAdd( timemap, "UTTOUTC", 1, args_ut );
+            astTimeAdd( timemap, "UTCTOTAI", 2, args_tai );
+
+         } else if( ts1 == AST__LAST ) {
+            astTimeAdd( timemap, "LASTTOLMST", 3, args );
+            astTimeAdd( timemap, "LMSTTOGMST", 3, args );
+            astTimeAdd( timemap, "GMSTTOUT", 1, args );
+            astTimeAdd( timemap, "UTTOUTC", 1, args_ut );
+            astTimeAdd( timemap, "UTCTOTAI", 2, args_tai );
+
+         } else if( ts1 == AST__LMST ) {
+            astTimeAdd( timemap, "LMSTTOGMST", 3, args );
+            astTimeAdd( timemap, "GMSTTOUT", 1, args );
+            astTimeAdd( timemap, "UTTOUTC", 1, args_ut );
+            astTimeAdd( timemap, "UTCTOTAI", 2, args_tai );
+         }
+
+/* Now add a conversion from TAI to the output timescale. */
+         if( ts2 == AST__TAI ) {
+
+         } else if( ts2 == AST__UTC ) {
+            astTimeAdd( timemap, "TAITOUTC", 2, args_tai );
+
+         } else if( ts2 == AST__TT ) {
+            astTimeAdd( timemap, "TAITOTT", 1, args );
+
+         } else if( ts2 == AST__TDB ) {
+            astTimeAdd( timemap, "TAITOTT", 1, args );
+            astTimeAdd( timemap, "TTTOTDB", 5, args );
+
+         } else if( ts2 == AST__TCG ) {
+            astTimeAdd( timemap, "TAITOTT", 1, args );
+            astTimeAdd( timemap, "TTTOTCG", 1, args );
+
+         } else if( ts2 == AST__TCB ) {
+            astTimeAdd( timemap, "TAITOTT", 1, args );
+            astTimeAdd( timemap, "TTTOTDB", 5, args );
+            astTimeAdd( timemap, "TDBTOTCB", 1, args );
+
+         } else if( ts2 == AST__UT1 ) {
+            astTimeAdd( timemap, "TAITOUTC", 2, args_tai );
+            astTimeAdd( timemap, "UTCTOUT", 1, args_ut );
+
+         } else if( ts2 == AST__GMST ) {
+            astTimeAdd( timemap, "TAITOUTC", 2, args_tai );
+            astTimeAdd( timemap, "UTCTOUT", 1, args_ut );
+            astTimeAdd( timemap, "UTTOGMST", 1, args );
+
+         } else if( ts2 == AST__LAST ) {
+            astTimeAdd( timemap, "TAITOUTC", 2, args_tai );
+            astTimeAdd( timemap, "UTCTOUT", 1, args_ut );
+            astTimeAdd( timemap, "UTTOGMST", 1, args );
+            astTimeAdd( timemap, "GMSTTOLMST", 3, args );
+            astTimeAdd( timemap, "LMSTTOLAST", 3, args );
+
+         } else if( ts2 == AST__LMST ) {
+            astTimeAdd( timemap, "TAITOUTC", 2, args_tai );
+            astTimeAdd( timemap, "UTCTOUT", 1, args_ut );
+            astTimeAdd( timemap, "UTTOGMST", 1, args );
+            astTimeAdd( timemap, "GMSTTOLMST", 3, args );
+
+         } else if( ts2 == AST__LT ) {
+            astTimeAdd( timemap, "TAITOUTC", 2, args_tai );
+            astTimeAdd( timemap, "UTCTOLT", 1, args_lt );
+
+         }
+      }
+
+/* Add a conversion from MJD to the output System, if needed. */
+      args[ 1 ] = off2;
+      if( sys2 == AST__MJD ) {
+         if( args[ 0 ] != off2 ) astTimeAdd( timemap, "MJDTOMJD", 2, args );
+
+      } else if( sys2 == AST__JD ) {
+         astTimeAdd( timemap, "MJDTOJD", 2, args );
+
+      } else if( sys2 == AST__JEPOCH ) {
+         astTimeAdd( timemap, "MJDTOJEP", 2, args );
+
+      } else if( sys2 == AST__BEPOCH ) {
+         astTimeAdd( timemap, "MJDTOBEP", 2, args );
+      }
+
+/* Now, create a Mapping from the default units for the output System (these
+   are the units produced by the TimeMap conversions) to the requested
+   output units. */
+      umap2 = astUnitMapper( DefUnit( sys2, method, "TimeFrame", status ), unit2,
+                             NULL, NULL );
+
+/* If OK, combine the Mappings in series. Note, umap1 and umap2 should
+   always be non-NULL because the suitablity of units strings is checked
+   within OriginSystem - called from within SetSystem. */
+      if( umap1 && umap2 ) {
+         tmap = (AstMapping *) astCmpMap( umap1, timemap, 1, "", status );
+         tmap2 = (AstMapping *) astCmpMap( tmap, umap2, 1, "", status );
+         tmap = astAnnul( tmap );
+         result = astSimplify( tmap2 );
+         tmap2 = astAnnul( tmap2 );
+      }
+
+/* Free remaining resources */
+      if( umap1 ) umap1 = astAnnul( umap1 );
+      if( umap2 ) umap2 = astAnnul( umap2 );
+      timemap = astAnnul( timemap );
+   }
+
+/* Return NULL if an error has occurred. */
+   if( !astOK ) result = astAnnul( result );
+
+/* Return the result. */
+   return result;
+
+}
+
+static int MakeTimeMapping( AstTimeFrame *target, AstTimeFrame *result,
+                            AstTimeFrame *align_frm, int report,
+                            AstMapping **map, int *status ) {
+/*
+*  Name:
+*     MakeTimeMapping
+
+*  Purpose:
+*     Generate a Mapping between two TimeFrames.
+
+*  Type:
+*     Private function.
+
+*  Synopsis:
+*     #include "timeframe.h"
+*     int MakeTimeMapping( AstTimeFrame *target, AstTimeFrame *result,
+*                          AstTimeFrame *align_frm, int report,
+*                          AstMapping **map, int *status ) {
+
+*  Class Membership:
+*     TimeFrame member function.
+
+*  Description:
+*     This function takes two TimeFrames and generates a Mapping that
+*     converts between them, taking account of differences in their
+*     coordinate systems, offsets, timescales, units, etc.
+
+*  Parameters:
+*     target
+*        Pointer to the first TimeFrame.
+*     result
+*        Pointer to the second TimeFrame.
+*     align_frm
+*        A TimeFrame defining the system and time scale in which to
+*        align the target and result TimeFrames. The AlignSystem and
+*        AlignTimeScale attributes are used for this purpose.
+*     report
+*        Should errors be reported if no match is possible? These reports
+*        will describe why no match was possible.
+*     map
+*        Pointer to a location which is to receive a pointer to the
+*        returned Mapping. The forward transformation of this Mapping
+*        will convert from "target" coordinates to "result"
+*        coordinates, and the inverse transformation will convert in
+*        the opposite direction (all coordinate values in radians).
+*     status
+*        Pointer to the inherited status variable.
+
+*  Returned Value:
+*     Non-zero if the Mapping could be generated, or zero if the two
+*     TimeFrames are sufficiently un-related that no meaningful Mapping
+*     can be produced (albeit an "unmeaningful" Mapping will be returned
+*     in this case, which will need to be annulled).
+
+*  Notes:
+*     A value of zero is returned if this function is invoked with the
+*     global error status set or if it should fail for any reason.
+*/
+
+/* Local Variables: */
+   AstMapping *map1;             /* Intermediate Mapping */
+   AstMapping *map2;             /* Intermediate Mapping */
+   AstMapping *tmap;             /* Intermediate Mapping */
+   AstSystemType sys1;           /* Code to identify input system */
+   AstSystemType sys2;           /* Code to identify output system */
+   AstTimeScaleType align_ts;    /* Alignment time scale */
+   AstTimeScaleType ts1;         /* Input time scale */
+   AstTimeScaleType ts2;         /* Output time scale */
+   const char *align_unit;       /* Units used for alignment */
+   const char *u1;               /* Input target units */
+   const char *u2;               /* Output target units */
+   double align_off;             /* Axis offset */
+   double ltoff1;                /* Input axis Local Time offset */
+   double ltoff2;                /* Output axis Local Time offset */
+   double off1;                  /* Input axis offset */
+   double off2;                  /* Output axis offset */
+   int arclk;                    /* Align->result depends on clock position? */
+   int ardtai;                   /* Align->result depends on Dtai? */
+   int ardut;                    /* Align->result depends on Dut1? */
+   int arlto;                    /* Align->result depends on LT offset? */
+   int clkdiff;                  /* Do target and result clock positions differ? */
+   int dtaidiff;                 /* Do target and result Dtai values differ? */
+   int dut1diff;                 /* Do target and result Dut1 values differ? */
+   int ltodiff;                  /* Do target and result LTOffset values differ? */
+   int match;                    /* Mapping can be generated? */
+   int taclk;                    /* Target->align depends on clock position? */
+   int tadut;                    /* Target->align depends on Dut1? */
+   int tadtai;                   /* Target->align depends on Dtai? */
+   int talto;                    /* Target->align depends on LT offset? */
+
+/* Check the global error status. */
+   if ( !astOK ) return 0;
+
+/* Initialise the returned values. */
+   match = 0;
+   *map = NULL;
+
+/* Get the required properties of the input (target) TimeFrame */
+   sys1 = astGetSystem( target );
+   ts1 = astGetTimeScale( target );
+   off1 = astGetTimeOrigin( target );
+   u1 = astGetUnit( target, 0 );
+   ltoff1= astGetLTOffset( target );
+
+/* Get the required properties of the output (result) TimeFrame */
+   sys2 = astGetSystem( result );
+   ts2 = astGetTimeScale( result );
+   off2 = astGetTimeOrigin( result );
+   u2 = astGetUnit( result, 0 );
+   ltoff2= astGetLTOffset( result );
+
+/* Get the timescale in which alignment is to be performed. The alignment
+   System does not matter since they all supported time systems are linearly
+   related, and so the choice of alignment System has no effect on the total
+   Mapping. We arbitrarily choose MJD as the alignment System (if needed). */
+   align_ts = astGetAlignTimeScale( align_frm );
+
+/* The main difference between this function and the MakeMap function is
+   that this function takes account of the requested alignment frame. But
+   the alignment Frame only makes a difference to the overall Mapping if
+   1) the observer's positions are different in the target and result Frame,
+   and 2) one or both of the Mappings to or from the alignment frame depends
+   on the observer's position. If either of these 2 conditions is not met,
+   then the alignment frame can be ignored, and the simpler MakeMap function
+   can be called. See if the observer's positions differ. */
+   clkdiff = ( astGetObsLon( target ) != astGetObsLon( result ) ||
+               astGetObsLat( target ) != astGetObsLat( result ) ||
+               astGetObsAlt( target ) != astGetObsAlt( result ) );
+
+/* See if the Mapping from target to alignment frame depends on the
+   observer's position. */
+   taclk = CLOCK_SCALE( ts1 ) || CLOCK_SCALE( align_ts );
+
+/* See if the Mapping from alignment to result frame depends on the
+   observer's position. */
+   arclk = CLOCK_SCALE( align_ts ) || CLOCK_SCALE( ts2 );
+
+/* In addition, the alignment frame is significant if either of the Mappings
+   depends on DUT1 and the values of the DUT1 attribute are different for the
+   two TimeFrames.  Or if DTAI differs and is similarly relevant. */
+   dut1diff = ( astGetDut1( target ) != astGetDut1( result ) );
+   tadut = DUT1_SCALE( ts1 ) != DUT1_SCALE( align_ts );
+   ardut = DUT1_SCALE( align_ts ) != DUT1_SCALE( ts2 );
+
+   dtaidiff = ! EQUAL( astGetDtai( target ), astGetDtai( result ), 1.0E-6 );
+   tadtai = DTAI_SCALE( ts1 ) != DTAI_SCALE( align_ts );
+   ardtai = DTAI_SCALE( align_ts ) != DTAI_SCALE( ts2 );
+
+/* In addition, the alignment frame is significant if either of the Mappings
+   depends on LTOffset and the values of the LTOffset attribute are different
+   for the two TimeFrames. */
+   ltodiff = ( ltoff1 != ltoff2 );
+   talto = LTOFFSET_SCALE( ts1 ) != LTOFFSET_SCALE( align_ts );
+   arlto = LTOFFSET_SCALE( align_ts ) != LTOFFSET_SCALE( ts2 );
+
+/* If the alignment frame can be ignored, use MakeMap */
+   if( ( !clkdiff || !( taclk || arclk ) ) &&
+       ( !ltodiff || !( talto || arlto ) ) &&
+       ( !dut1diff || !( tadut || ardut ) ) &&
+       ( !dtaidiff || !( tadtai || ardtai ) ) ) {
+      *map = MakeMap( target, sys1, sys2, ts1, ts2, off1, off2, u1, u2,
+                      "astSubFrame", status );
+      if( *map ) match = 1;
+
+/* Otherwise, we create the Mapping in two parts; first a Mapping from
+   the target Frame to the alignment Frame (using the target clock, dtai, dut1
+   and ltoffset), then a Mapping from the alignment Frame to the results
+   Frame (using the result clock, dtai, dut1 and ltoffset). */
+   } else {
+
+/* Create a Mapping from target units/system/timescale/offset to MJD in
+   the alignment timescale with default units and offset equal to the MJD
+   equivalent of the target offset. */
+      align_off = ToMJD( sys1, off1, status );
+      align_unit = DefUnit( AST__MJD, "MakeTimeMap", "TimeFrame", status );
+      map1 = MakeMap( target, sys1, AST__MJD, ts1, align_ts, off1, align_off,
+                      u1, align_unit, "MakeTimeMap", status );
+
+/* Report an error if the timescales were incompatible. */
+      if( !map1 ){
+         match = 0;
+         if( report && astOK ) {
+            astError( AST__INCTS, "astMatch(%s): Alignment in requested "
+                   "timescale (%s) is not possible since one or both of the "
+                   "TimeFrames being aligned refer to the %s timescale.", status,
+                   astGetClass( target ), TimeScaleString( align_ts, status ),
+                   TimeScaleString( ts1, status ) );
+         }
+      }
+
+/* We now create a Mapping that converts from the alignment System (MJD),
+   TimeScale and offset to the result coordinate system. */
+      map2 = MakeMap( result, AST__MJD, sys2, align_ts, ts2, align_off, off2,
+                      align_unit, u2, "MakeTimeMap", status );
+
+/* Report an error if the timescales were incompatible. */
+      if( !map2 ){
+         match = 0;
+         if( report && astOK ) {
+            astError( AST__INCTS, "astMatch(%s): Alignment in requested "
+                   "timescale (%s) is not possible since one or both of the "
+                   "TimeFrames being aligned refer to the %s timescale.", status,
+                   astGetClass( result ), TimeScaleString( align_ts, status ),
+                   TimeScaleString( ts2, status ) );
+         }
+      }
+
+/* Combine these two Mappings. */
+      if( map1 && map2 ) {
+         match = 1;
+         tmap = (AstMapping *) astCmpMap( map1, map2, 1, "", status );
+         *map = astSimplify( tmap );
+         tmap = astAnnul( tmap );
+      }
+
+/* Free resources. */
+      if( map1 ) map1 = astAnnul( map1 );
+      if( map2 ) map2 = astAnnul( map2 );
+   }
+
+/* If an error occurred, annul the returned Mapping and clear the returned
+   values. */
+   if ( !astOK ) {
+      *map = astAnnul( *map );
+      match = 0;
+   }
+
+/* Return the result. */
+   return match;
+}
+
+static int Match( AstFrame *template_frame, AstFrame *target, int matchsub,
+                  int **template_axes, int **target_axes, AstMapping **map,
+                  AstFrame **result, int *status ) {
+/*
+*  Name:
+*     Match
+
+*  Purpose:
+*     Determine if conversion is possible between two coordinate systems.
+
+*  Type:
+*     Private function.
+
+*  Synopsis:
+*     #include "timeframe.h"
+*     int Match( AstFrame *template, AstFrame *target, int matchsub,
+*                int **template_axes, int **target_axes,
+*                AstMapping **map, AstFrame **result, int *status )
+
+*  Class Membership:
+*     TimeFrame member function (over-rides the protected astMatch method
+*     inherited from the Frame class).
+
+*  Description:
+*     This function matches a "template" TimeFrame to a "target" Frame and
+*     determines whether it is possible to convert coordinates between them.
+*     If it is, a mapping that performs the transformation is returned along
+*     with a new Frame that describes the coordinate system that results when
+*     this mapping is applied to the "target" coordinate system. In addition,
+*     information is returned to allow the axes in this "result" Frame to be
+*     associated with the corresponding axes in the "target" and "template"
+*     Frames from which they are derived.
+
+*  Parameters:
+*     template
+*        Pointer to the template TimeFrame. This describes the coordinate
+*        system (or set of possible coordinate systems) into which we wish to
+*        convert our coordinates.
+*     target
+*        Pointer to the target Frame. This describes the coordinate system in
+*        which we already have coordinates.
+*     matchsub
+*        If zero then a match only occurs if the template is of the same
+*        class as the target, or of a more specialised class. If non-zero
+*        then a match can occur even if this is not the case.
+*     template_axes
+*        Address of a location where a pointer to int will be returned if the
+*        requested coordinate conversion is possible. This pointer will point
+*        at a dynamically allocated array of integers with one element for each
+*        axis of the "result" Frame (see below). It must be freed by the caller
+*        (using astFree) when no longer required.
+*
+*        For each axis in the result Frame, the corresponding element of this
+*        array will return the index of the template TimeFrame axis from
+*        which it is derived. If it is not derived from any template
+*        TimeFrame axis, a value of -1 will be returned instead.
+*     target_axes
+*        Address of a location where a pointer to int will be returned if the
+*        requested coordinate conversion is possible. This pointer will point
+*        at a dynamically allocated array of integers with one element for each
+*        axis of the "result" Frame (see below). It must be freed by the caller
+*        (using astFree) when no longer required.
+*
+*        For each axis in the result Frame, the corresponding element of this
+*        array will return the index of the target Frame axis from which it
+*        is derived. If it is not derived from any target Frame axis, a value
+*        of -1 will be returned instead.
+*     map
+*        Address of a location where a pointer to a new Mapping will be
+*        returned if the requested coordinate conversion is possible. If
+*        returned, the forward transformation of this Mapping may be used to
+*        convert coordinates between the "target" Frame and the "result"
+*        Frame (see below) and the inverse transformation will convert in the
+*        opposite direction.
+*     result
+*        Address of a location where a pointer to a new Frame will be returned
+*        if the requested coordinate conversion is possible. If returned, this
+*        Frame describes the coordinate system that results from applying the
+*        returned Mapping (above) to the "target" coordinate system. In
+*        general, this Frame will combine attributes from (and will therefore
+*        be more specific than) both the target and the template Frames. In
+*        particular, when the template allows the possibility of transformaing
+*        to any one of a set of alternative coordinate systems, the "result"
+*        Frame will indicate which of the alternatives was used.
+*     status
+*        Pointer to the inherited status variable.
+
+*  Returned Value:
+*     A non-zero value is returned if the requested coordinate conversion is
+*     possible. Otherwise zero is returned (this will not in itself result in
+*     an error condition).
+
+*  Notes:
+*     -  A value of zero will be returned if this function is invoked with the
+*     global error status set, or if it should fail for any reason.
+
+*  Implementation Notes:
+*     This implementation addresses the matching of a TimeFrame class
+*     object to any other class of Frame. A TimeFrame will match any class
+*     of TimeFrame (i.e. possibly from a derived class) but will not match
+*     a less specialised class of Frame.
+*/
+
+   AstFrame *frame0;             /* Pointer to Frame underlying axis 0 */
+   AstTimeFrame *template;       /* Pointer to template TimeFrame structure */
+   int iaxis0;                   /* Axis index underlying axis 0 */
+   int iaxis;                    /* Axis index */
+   int match;                    /* Coordinate conversion possible? */
+   int target_axis0;             /* Index of TimeFrame axis in the target */
+   int target_naxes;             /* Number of target axes */
+
+/* Initialise the returned values. */
+   *template_axes = NULL;
+   *target_axes = NULL;
+   *map = NULL;
+   *result = NULL;
+   match = 0;
+
+/* Check the global error status. */
+   if ( !astOK ) return match;
+
+/* Obtain a pointer to the template TimeFrame structure. */
+   template = (AstTimeFrame *) template_frame;
+
+/* Obtain the number of axes in the target Frame. */
+   target_naxes = astGetNaxes( target );
+
+/* The first criterion for a match is that the template matches as a
+   Frame class object. This ensures that the number of axes (1) and
+   domain, etc. of the target Frame are suitable. Invoke the parent
+   "astMatch" method to verify this. */
+   match = (*parent_match)( template_frame, target, matchsub,
+                            template_axes, target_axes, map, result, status );
+
+/* If a match was found, annul the returned objects, which are not
+   needed, but keep the memory allocated for the axis association
+   arrays, which we will re-use. */
+   if ( astOK && match ) {
+      *map = astAnnul( *map );
+      *result = astAnnul( *result );
+   }
+
+/* If OK so far, obtain pointers to the primary Frames which underlie
+   all target axes. Stop when a TimeFrame axis is found. */
+   if ( match && astOK ) {
+      match = 0;
+      for( iaxis = 0; iaxis < target_naxes; iaxis++ ) {
+         astPrimaryFrame( target, iaxis, &frame0, &iaxis0 );
+         if( astIsATimeFrame( frame0 ) ) {
+            frame0 = astAnnul( frame0 );
+            target_axis0 = iaxis;
+            match = 1;
+            break;
+         } else {
+            frame0 = astAnnul( frame0 );
+         }
+      }
+   }
+
+/* Check at least one TimeFrame axis was found it the target. Store the
+   axis associataions. */
+   if( match && astOK ) {
+      (*template_axes)[ 0 ] = 0;
+      (*target_axes)[ 0 ] = target_axis0;
+
+/* Use the target's "astSubFrame" method to create a new Frame (the
+   result Frame) with copies of the target axes in the required
+   order. This process also overlays the template attributes on to the
+   target Frame and returns a Mapping between the target and result
+   Frames which effects the required coordinate conversion. */
+      match = astSubFrame( target, template, 1, *target_axes, *template_axes,
+                           map, result );
+   }
+
+/* If an error occurred, or conversion to the result Frame's coordinate
+   system was not possible, then free all memory, annul the returned
+   objects, and reset the returned value. */
+   if ( !astOK || !match ) {
+      *template_axes = astFree( *template_axes );
+      *target_axes = astFree( *target_axes );
+      if( *map ) *map = astAnnul( *map );
+      if( *result ) *result = astAnnul( *result );
+      match = 0;
+   }
+
+/* Return the result. */
+   return match;
+}
+
+static void OriginScale( AstTimeFrame *this, AstTimeScaleType newts,
+                         const char *method, int *status ){
+/*
+*  Name:
+*     OriginScale
+
+*  Purpose:
+*     Convert the TimeOrigin in a TimeFrame to a new timescale.
+
+*  Type:
+*     Private function.
+
+*  Synopsis:
+*     #include "timeframe.h"
+*     void OriginScale( AstTimeFrame *this, AstTimeScaleType newts,
+*                       const char *method, int *status )
+
+*  Class Membership:
+*     TimeFrame member function
+
+*  Description:
+*     This function converts the value of the TimeOrigin attribute stored
+*     within a supplied TimeFrame from the timescale currently associated
+*     with the TimeFrame, to the new timescale indicated by "newts".
+
+*  Parameters:
+*     this
+*        Point to the TimeFrame. On entry, the TimeOrigin value is
+*        assumed to refer to the timescale given by the astGetTimeScale
+*        method. On exit, the TimeOrigin value refers to the timescale
+*        supplied in "newts". The TimeScale attribute of the TimeFrame
+*        should then be modified in order to keep things consistent.
+*     newts
+*        The timescale to which the TimeOrigin value stored within "this"
+*        should refer on exit.
+*     method
+*        Pointer to a string holding the name of the method to be
+*        included in any error messages.
+*     status
+*        Pointer to the inherited status variable.
+
+*/
+
+
+/* Local Variables: */
+   AstMapping *map;
+   AstSystemType sys;
+   AstTimeScaleType oldts;
+   const char *u;
+   double newval;
+   double oldval;
+
+/* Check the global error status. */
+   if ( !astOK ) return;
+
+/* Do nothing if the TimeOrigin attribute has not been assigned a value. */
+   if( astTestTimeOrigin( this ) ) {
+
+/* Do nothing if the Scale will not change. */
+      oldts = astGetTimeScale( this );
+      if( newts != oldts ) {
+
+/* Create a Mapping to perform the TimeScale change. */
+         sys = astGetSystem( this );
+         u = DefUnit( sys, method, "TimeFrame", status ),
+         map = MakeMap( this, sys, sys, oldts, newts, 0.0, 0.0, u, u,
+                        method, status );
+
+/* Use the Mapping to convert the stored TimeOrigin value. */
+         if( map ) {
+            oldval = astGetTimeOrigin( this );
+            astTran1( map, 1, &oldval, 1, &newval );
+
+/* Store the new value */
+            astSetTimeOrigin( this, newval );
+
+/* Free resources */
+            map = astAnnul( map );
+
+         } else if( astOK ) {
+            astError( AST__INCTS, "%s(%s): Cannot convert the TimeOrigin "
+                      "value to a different timescale because of "
+                      "incompatible time scales.", status, method,
+                      astGetClass( this ) );
+         }
+      }
+   }
+}
+
+static void OriginSystem( AstTimeFrame *this, AstSystemType oldsys,
+                          const char *method, int *status ){
+/*
+*  Name:
+*     OriginSystem
+
+*  Purpose:
+*     Convert the TimeOrigin in a TimeFrame to a new System.
+
+*  Type:
+*     Private function.
+
+*  Synopsis:
+*     #include "timeframe.h"
+*     void OriginSystem( AstTimeFrame *this, AstSystemType oldsys,
+*                        const char *method, int *status )
+
+*  Class Membership:
+*     TimeFrame member function
+
+*  Description:
+*     This function converts the value of the TimeOrigin attribute stored
+*     within a supplied TimeFrame from its original System, etc, to the
+*     System, etc, currently associated with the TimeFrame.
+
+*  Parameters:
+*     this
+*        Point to the TimeFrame. On entry, the TimeOrigin value is
+*        assumed to refer to the System given by "oldsys", etc. On exit, the
+*        TimeOrigin value refers to the System returned by the astGetSystem
+*        method, etc.
+*     oldsys
+*        The System to which the TimeOrigin value stored within "this"
+*        refers on entry.
+*     method
+*        A string containing the method name for error messages.
+*     status
+*        Pointer to the inherited status variable.
+
+*/
+
+/* Local Variables: */
+   AstMapping *map;
+   AstSystemType newsys;
+   AstTimeScaleType ts;
+   const char *oldu;
+   const char *newu;
+   double newval;
+   double oldval;
+
+/* Check the global error status. */
+   if ( !astOK ) return;
+
+/* Do nothing if the TimeOrigin attribute has not been assigned a value. */
+   if( astTestTimeOrigin( this ) ) {
+
+/* Do nothing if the System has not changed. */
+      newsys = astGetSystem( this );
+      if( oldsys != newsys ) {
+
+/* Create a Mapping to perform the System change. */
+         ts = astGetTimeScale( this );
+         oldu = DefUnit( oldsys, method, "TimeFrame", status ),
+         newu = DefUnit( newsys, method, "TimeFrame", status ),
+         map = MakeMap( this, oldsys, newsys, ts, ts, 0.0, 0.0, oldu, newu,
+                        method, status );
+
+/* Use the Mapping to convert the stored TimeOrigin value. */
+         if( map ) {
+            oldval = astGetTimeOrigin( this );
+            astTran1( map, 1, &oldval, 1, &newval );
+
+/* Store the new value */
+            astSetTimeOrigin( this, newval );
+
+/* Free resources */
+            map = astAnnul( map );
+
+         } else if( astOK ) {
+            astError( AST__INCTS, "%s(%s): Cannot convert the TimeOrigin "
+                      "value to a different System because of incompatible "
+                      "time scales.", status, method, astGetClass( this ) );
+         }
+      }
+   }
+}
+
+static void Overlay( AstFrame *template, const int *template_axes,
+                     AstFrame *result, int *status ) {
+/*
+*  Name:
+*     Overlay
+
+*  Purpose:
+*     Overlay the attributes of a template TimeFrame on to another Frame.
+
+*  Type:
+*     Private function.
+
+*  Synopsis:
+*     #include "timeframe.h"
+*     void Overlay( AstFrame *template, const int *template_axes,
+*                   AstFrame *result, int *status )
+
+*  Class Membership:
+*     TimeFrame member function (over-rides the protected astOverlay method
+*     inherited from the Frame class).
+
+*  Description:
+*     This function overlays attributes of a TimeFrame (the "template") on to
+*     another Frame, so as to over-ride selected attributes of that second
+*     Frame. Normally only those attributes which have been specifically set
+*     in the template will be transferred. This implements a form of
+*     defaulting, in which a Frame 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.
+*
+*     Note that if the result Frame is a TimeFrame and a change of time
+*     coordinate system occurs as a result of overlaying its System
+*     attribute, then some of its original attribute values may no
+*     longer be appropriate (e.g. the Title, or attributes describing
+*     its axes). In this case, these will be cleared before overlaying
+*     any new values.
+
+*  Parameters:
+*     template
+*        Pointer to the template TimeFrame, for which values should have been
+*        explicitly set for any attribute which is to be transferred.
+*     template_axes
+*        Pointer to an array of int, with one element for each axis of the
+*        "result" Frame (see below). For each axis in the result frame, the
+*        corresponding element of this array should contain the (zero-based)
+*        index of the template axis to which it corresponds. This array is used
+*        to establish from which template axis any axis-dependent attributes
+*        should be obtained.
+*
+*        If any axis in the result Frame is not associated with a template
+*        axis, the corresponding element of this array should be set to -1.
+*
+*        If a NULL pointer is supplied, the template and result axis
+*        indices are assumed to be identical.
+*     result
+*        Pointer to the Frame which is to receive the new attribute values.
+*     status
+*        Pointer to the inherited status variable.
+
+*  Returned Value:
+*     void
+
+*  Notes:
+*     -  In general, if the result Frame is not from the same class as the
+*     template TimeFrame, or from a class derived from it, then attributes may
+*     exist in the template TimeFrame which do not exist in the result Frame.
+*     In this case, these attributes will not be transferred.
+*/
+
+
+/* Local Variables: */
+   AstSystemType new_alignsystem;/* Code identifying new alignment coords */
+   AstSystemType new_system;     /* Code identifying new cordinates */
+   AstSystemType old_system;     /* Code identifying old coordinates */
+   int resetSystem;              /* Was the template System value cleared? */
+   int timeframe;                /* Result Frame is a TimeFrame? */
+
+/* Check the global error status. */
+   if ( !astOK ) return;
+
+/* Get the old and new systems. */
+   old_system = astGetSystem( result );
+   new_system = astGetSystem( template );
+
+/* If the result Frame is a TimeFrame, we must test to see if overlaying its
+   System attribute will change the type of coordinate system it describes.
+   Determine the value of this attribute for the result and template
+   TimeFrames. */
+   resetSystem = 0;
+   timeframe = astIsATimeFrame( result );
+   if( timeframe ) {
+
+/* If the coordinate system will change, any value already set for the result
+   TimeFrame's Title, etc,  will no longer be appropriate, so clear it. */
+      if ( new_system != old_system ) {
+         astClearTitle( result );
+         astClearLabel( result, 0 );
+         astClearSymbol( result, 0 );
+      }
+
+/* If the result Frame is not a TimeFrame, we must temporarily clear the
+   System and AlignSystem values since the values used by this class are only
+   appropriate to this class. */
+   } else {
+      if( astTestSystem( template ) ) {
+         astClearSystem( template );
+
+         new_alignsystem = astGetAlignSystem( template );
+         astClearAlignSystem( template );
+
+         resetSystem = 1;
+      }
+   }
+
+/* Invoke the parent class astOverlay method to transfer attributes inherited
+   from the parent class. */
+   (*parent_overlay)( template, template_axes, result, status );
+
+/* Reset the System and AlignSystem values if necessary */
+   if( resetSystem ) {
+      astSetSystem( template, new_system );
+      astSetAlignSystem( template, new_alignsystem );
+   }
+
+/* Check if the result Frame is a TimeFrame or from a class derived from
+   TimeFrame. If not, we cannot transfer TimeFrame attributes to it as it is
+   insufficiently specialised. In this case simply omit these attributes. */
+   if ( timeframe && astOK ) {
+
+/* Define macros that test whether an attribute is set in the template and,
+   if so, transfers its value to the result. */
+#define OVERLAY(attribute) \
+   if ( astTest##attribute( template ) ) { \
+      astSet##attribute( result, astGet##attribute( template ) ); \
+   }
+
+/* Use the macro to transfer each TimeFrame attribute in turn. Note,
+   SourceVRF must be overlayed before SourceVel. Otherwise the stored value
+   for SourceVel would be changed from the default SourceVRF to the specified
+   SourceVRF when SourceVRF was overlayed. */
+      OVERLAY(AlignTimeScale)
+      OVERLAY(LTOffset)
+      OVERLAY(TimeOrigin)
+      OVERLAY(TimeScale)
+   }
+
+/* Undefine macros local to this function. */
+#undef OVERLAY
+}
+
+static void SetAttrib( AstObject *this_object, const char *setting, int *status ) {
+/*
+*  Name:
+*     SetAttrib
+
+*  Purpose:
+*     Set an attribute value for a TimeFrame.
+
+*  Type:
+*     Private function.
+
+*  Synopsis:
+*     #include "timeframe.h"
+*     void SetAttrib( AstObject *this, const char *setting, int *status )
+
+*  Class Membership:
+*     TimeFrame member function (extends the astSetAttrib method inherited from
+*     the Mapping class).
+
+*  Description:
+*     This function assigns an attribute value for a TimeFrame, 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 TimeFrame.
+*     setting
+*        Pointer to a null terminated string specifying the new attribute
+*        value.
+*     status
+*        Pointer to the inherited status variable.
+
+*  Returned Value:
+*     void
+
+*  Notes:
+*     This protected method is intended to be invoked by the Object astSet
+*     method and makes additional attributes accessible to it.
+*/
+
+/* Local Vaiables: */
+   AstTimeFrame *this;           /* Pointer to the TimeFrame structure */
+   AstTimeScaleType ts;          /* time scale type code */
+   char *a;                      /* Pointer to next character */
+   char *new_setting;            /* Pointer value to new attribute setting */
+   double dval;                  /* Double atribute value */
+   double mjd;                   /* MJD read from setting */
+   double origin;                /* TimeOrigin value */
+   int len;                      /* Length of setting string */
+   int namelen;                  /* Length of attribute name in setting */
+   int nc;                       /* Number of characters read by astSscanf */
+   int off;                      /* Offset of attribute value */
+   int rep;                      /* Original error reporting state */
+
+/* Check the global error status. */
+   if ( !astOK ) return;
+
+/* Obtain a pointer to the TimeFrame structure. */
+   this = (AstTimeFrame *) this_object;
+
+/* Obtain the length of the setting string. */
+   len = 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. */
+
+/* First look for axis attributes defined by the Frame class. Since a
+   TimeFrame has only 1 axis, we allow these attributes to be specified
+   without a trailing "(axis)" string. */
+   if ( !strncmp( setting, "direction=", 10 ) ||
+        !strncmp( setting, "bottom=", 7 ) ||
+        !strncmp( setting, "top=", 4 ) ||
+        !strncmp( setting, "format=", 7 ) ||
+        !strncmp( setting, "label=", 6 ) ||
+        !strncmp( setting, "symbol=", 7 ) ||
+        !strncmp( setting, "unit=", 5 ) ) {
+
+/* Create a new setting string from the original by appending the string
+   "(1)" to the end of the attribute name and then use the parent SetAttrib
+   method. */
+      new_setting = astMalloc( len + 4 );
+      if( new_setting ) {
+         memcpy( new_setting, setting, len + 1 );
+         a = strchr( new_setting, '=' );
+         namelen = a - new_setting;
+         memcpy( a, "(1)", 4 );
+         a += 3;
+         strcpy( a, setting + namelen );
+         (*parent_setattrib)( this_object, new_setting, status );
+         new_setting = astFree( new_setting );
+      }
+
+/* AlignTimeScale. */
+/* --------------- */
+   } else if ( nc = 0,
+        ( 0 == astSscanf( setting, "aligntimescale=%n%*s %n", &off, &nc ) )
+        && ( nc >= len ) ) {
+
+/* Convert the string to a TimeScale code before use. */
+      ts = TimeScaleCode( setting + off, status );
+      if ( ts != AST__BADTS ) {
+         astSetAlignTimeScale( this, ts );
+
+/* Report an error if the string value wasn't recognised. */
+      } else {
+         astError( AST__ATTIN, "astSetAttrib(%s): Invalid time scale "
+                   "description \"%s\".", status, astGetClass( this ), setting+off );
+      }
+
+/* ClockLat. */
+/* ------- */
+   } else if ( nc = 0,
+              ( 0 == astSscanf( setting, "clocklat=%n%*s %n", &off, &nc ) )
+              && ( nc >= 7 ) ) {
+      new_setting = astMalloc( sizeof( char )*(size_t) len + 1 );
+      new_setting[ 0 ] = 'o';
+      new_setting[ 1 ] = 'b';
+      new_setting[ 2 ] = 's';
+      strcpy( new_setting + 3, setting + 5 );
+      astSetAttrib( this, new_setting );
+      new_setting = astFree( new_setting );
+
+/* ClockLon. */
+/* ------- */
+   } else if ( nc = 0,
+              ( 0 == astSscanf( setting, "clocklon=%n%*s %n", &off, &nc ) )
+              && ( nc >= 7 ) ) {
+      new_setting = astMalloc( sizeof( char )*(size_t) len + 1 );
+      new_setting[ 0 ] = 'o';
+      new_setting[ 1 ] = 'b';
+      new_setting[ 2 ] = 's';
+      strcpy( new_setting + 3, setting + 5 );
+      astSetAttrib( this, new_setting );
+      new_setting = astFree( new_setting );
+
+/* LTOffset */
+/* -------- */
+   } else if ( nc = 0,
+        ( 1 == astSscanf( setting, "ltoffset= %lg %n", &dval, &nc ) )
+        && ( nc >= len ) ) {
+      astSetLTOffset( this, dval );
+
+/* TimeOrigin */
+/* ---------- */
+
+/* Floating-point without any units indication - assume the current Unit
+   value. */
+   } else if ( nc = 0,
+        ( 1 == astSscanf( setting, "timeorigin= %lg %n", &dval, &nc ) )
+        && ( nc >= len ) ) {
+
+      astSetTimeOrigin( this, ToUnits( this, astGetUnit( this, 0 ), dval,
+                                       "astSetTimeOrigin", status ) );
+
+/* Floating-point with units. */
+   } else if ( nc = 0,
+        ( 1 == astSscanf( setting, "timeorigin= %lg %n%*s %n", &dval, &off, &nc ) )
+        && ( nc >= len ) ) {
+
+/* Defer error reporting in case a date string was given which starts
+   with a floating point number, then convert the supplied value to the
+   default units for the TimeFrame's System. */
+      rep = astReporting( 0 );
+      origin = ToUnits( this, setting + off, dval, "astSetTimeOrigin", status );
+      if( !astOK ) astClearStatus;
+      astReporting( rep );
+
+/* If the origin was converted, store it. */
+      if( origin != AST__BAD ) {
+         astSetTimeOrigin( this, origin );
+
+/* Otherwise, interpret the string as a date. Convert first to MJD then to
+   default system. */
+      } else if ( nc = 0,
+           ( 0 == astSscanf( setting, "timeorigin=%n%*[^\n]%n", &off, &nc ) )
+           && ( nc >= len ) ) {
+         mjd = astReadDateTime( setting + off );
+         if ( astOK ) {
+            astSetTimeOrigin( this, FromMJD( this, mjd, status ) );
+
+/* Report contextual information if the conversion failed. */
+         } else {
+            astError( AST__ATTIN, "astSetAttrib(%s): Invalid TimeOrigin value "
+                      "\"%s\" given.", status, astGetClass( this ), setting + off );
+         }
+      }
+
+/* String (assumed to be a date). Convert first to MJD then to default
+   system. */
+   } else if ( nc = 0,
+        ( 0 == astSscanf( setting, "timeorigin=%n%*[^\n]%n", &off, &nc ) )
+        && ( nc >= len ) ) {
+      mjd = astReadDateTime( setting + off );
+      if ( astOK ) {
+         astSetTimeOrigin( this, FromMJD( this, mjd, status ) );
+
+/* Report contextual information if the conversion failed. */
+      } else {
+         astError( AST__ATTIN, "astSetAttrib(%s): Invalid TimeOrigin value "
+                   "\"%s\" given.", status, astGetClass( this ), setting + off );
+      }
+
+/* TimeScale. */
+/* ---------- */
+   } else if ( nc = 0,
+              ( 0 == astSscanf( setting, "timescale=%n%*s %n", &off, &nc ) )
+              && ( nc >= len ) ) {
+
+/* Convert the string to a TimeScale code before use. */
+      ts = TimeScaleCode( setting + off, status );
+      if ( ts != AST__BADTS ) {
+         astSetTimeScale( this, ts );
+
+/* Report an error if the string value wasn't recognised. */
+      } else {
+         astError( AST__ATTIN, "astSetAttrib(%s): Invalid time scale "
+                   "description \"%s\".", status, astGetClass( this ), setting + off );
+      }
+
+/* Pass any unrecognised setting to the parent method for further
+   interpretation. */
+   } else {
+      (*parent_setattrib)( this_object, setting, status );
+   }
+}
+
+static void SetSystem( AstFrame *this_frame, AstSystemType newsys, int *status ) {
+/*
+*  Name:
+*     SetSystem
+
+*  Purpose:
+*     Set the System attribute for a TimeFrame.
+
+*  Type:
+*     Private function.
+
+*  Synopsis:
+*     #include "timeframe.h"
+*     void SetSystem( AstFrame *this_frame, AstSystemType newsys, int *status )
+
+*  Class Membership:
+*     TimeFrame member function (over-rides the astSetSystem protected
+*     method inherited from the Frame class).
+
+*  Description:
+*     This function sets the System attribute for a TimeFrame.
+
+*  Parameters:
+*     this
+*        Pointer to the TimeFrame.
+*     newsys
+*        The new System value to be stored.
+*     status
+*        Pointer to the inherited status variable.
+
+*/
+
+/* Local Variables: */
+   AstTimeFrame *this;           /* Pointer to TimeFrame structure */
+   AstSystemType oldsys;         /* Original System value */
+
+/* Check the global error status. */
+   if ( !astOK ) return;
+
+/* Obtain a pointer to the TimeFrame structure. */
+   this = (AstTimeFrame *) this_frame;
+
+/* If we are changing the System to BEPOCH, set the Unit attribute to
+   "yr" and TimeScale to "TT". */
+   if( newsys == AST__BEPOCH ) {
+      astSetUnit( this_frame, 0, "yr" );
+      astSetTimeScale( (AstTimeFrame *) this_frame, AST__TT );
+   }
+
+/* Save the original System value */
+   oldsys = astGetSystem( this_frame );
+
+/* Use the parent SetSystem method to store the new System value. */
+   (*parent_setsystem)( this_frame, newsys, status );
+
+/* If the system has changed... */
+   if( oldsys != newsys ) {
+
+/* Modify the stored TimeOrigin. */
+      OriginSystem( this, oldsys, "astSetSystem", status );
+
+/* Clear all attributes which have system-specific defaults. */
+      astClearLabel( this_frame, 0 );
+      astClearSymbol( this_frame, 0 );
+      astClearTitle( this_frame );
+   }
+}
+
+static void SetTimeScale( AstTimeFrame *this, AstTimeScaleType value, int *status ) {
+/*
+*+
+*  Name:
+*     astSetTimeScale
+
+*  Purpose:
+*     Set the TimeScale attribute for a TimeFrame.
+
+*  Type:
+*     Protected function.
+
+*  Synopsis:
+*     #include "timeframe.h"
+*     void astSetTimeScale( AstTimeFrame *this, AstTimeScaleType value )
+
+*  Class Membership:
+*     TimeFrame virtual function
+
+*  Description:
+*     This function set a new value for the TimeScale attribute for a
+*     TimeFrame.
+
+*  Parameters:
+*     this
+*        Pointer to the TimeFrame.
+*     value
+*        The new value.
+
+*-
+*/
+
+/* Check the global error status. */
+   if ( !astOK ) return;
+
+/* Verify the supplied timescale value */
+   if( value < FIRST_TS || value > LAST_TS ) {
+      astError( AST__ATTIN, "%s(%s): Bad value (%d) given for TimeScale "
+                "attribute.", status, "astSetTimeScale", astGetClass( this ),
+                (int) value );
+
+/* Report an error if System is set to BEPOCH and an in appropriate
+   TimeScale was supplied. */
+   } else if( astGetSystem( this ) == AST__BEPOCH &&
+              value != AST__TT ) {
+      astError( AST__ATTIN, "%s(%s): Supplied TimeScale (%s) cannot be "
+                "used because the %s represents Besselian Epoch which "
+                "is defined in terms of TT.", status, "astSetTimeScale",
+                astGetClass( this ), TimeScaleString( value, status ),
+                astGetClass( this ) );
+
+/* Otherwise set the new TimeScale */
+   } else {
+
+/* Modify the TimeOrigin value stored in the TimeFrame structure to refer
+   to the new timescale. */
+      OriginScale( this, value, "astSetTimeScale", status );
+
+/* Store the new value for the timescale in the TimeFrame structure. */
+      this->timescale = value;
+
+   }
+}
+
+static void SetUnit( AstFrame *this_frame, int axis, const char *value, int *status ) {
+/*
+*  Name:
+*     SetUnit
+
+*  Purpose:
+*     Set a pointer to the Unit string for a TimeFrame's axis.
+
+*  Type:
+*     Private function.
+
+*  Synopsis:
+*     #include "timeframe.h"
+*     void SetUnit( AstFrame *this_frame, int axis, const char *value )
+
+*  Class Membership:
+*     TimeFrame member function (over-rides the astSetUnit method inherited
+*     from the Frame class).
+
+*  Description:
+*     This function stores a pointer to the Unit string for a specified axis
+*     of a TimeFrame. It also stores the string in the "usedunits" array
+*     in the TimeFrame structure, in the element associated with the
+*     current System.
+
+*  Parameters:
+*     this
+*        Pointer to the TimeFrame.
+*     axis
+*        The number of the axis (zero-based) for which information is required.
+*     unit
+*        The new string to store.
+*/
+
+/* Local Variables: */
+   AstTimeFrame *this;
+
+/* Check the global error status. */
+   if ( !astOK ) return;
+
+/* Obtain a pointer to the TimeFrame structure. */
+   this = (AstTimeFrame *) this_frame;
+
+/* Validate the axis index. */
+   astValidateAxis( this, axis, 1, "astSetUnit" );
+
+/* Report an error if System is set to BEPOCH and an in appropriate
+   Unit was supplied. */
+   if( astGetSystem( this ) == AST__BEPOCH && strcmp( "yr", value ) ) {
+      astError( AST__ATTIN, "astSetUnit(%s): Supplied Unit (%s) cannot "
+                "be used because the %s represents Besselian Epoch which "
+                "is defined in units of years (yr).", status, astGetClass( this ),
+                value, astGetClass( this ) );
+
+/* Otherwise use the parent SetUnit method to store the value in the Axis
+   structure */
+   } else {
+      (*parent_setunit)( this_frame, axis, value, status );
+   }
+}
+
+static AstTimeScaleType TimeScaleCode( const char *ts, int *status ) {
+/*
+*  Name:
+*     TimeScaleCode
+
+*  Purpose:
+*     Convert a string into a time scale type code.
+
+*  Type:
+*     Private function.
+
+*  Synopsis:
+*     #include "timeframe.h"
+*     AstTimeScaleType TimeScaleCode( const char *ts )
+
+*  Class Membership:
+*     TimeFrame member function.
+
+*  Description:
+*     This function converts a string used for the external description of
+*     a time scale into a TimeFrame time scale type code  (TimeScale attribute
+*     value). It is the inverse of the TimeScaleString function.
+
+*  Parameters:
+*     ts
+*        Pointer to a constant null-terminated string containing the
+*        external description of the time scale.
+
+*  Returned Value:
+*     The TimeScale type code.
+
+*  Notes:
+*     - A value of AST__BADTS is returned if the time scale
+*     description was not recognised. This does not produce an error.
+*     - A value of AST__BADTS is also returned if this function
+*     is invoked with the global error status set or if it should fail
+*     for any reason.
+*/
+
+/* Local Variables: */
+   AstTimeScaleType result;      /* Result value to return */
+
+/* Initialise. */
+   result = AST__BADTS;
+
+/* Check the global error status. */
+   if ( !astOK ) return result;
+
+/* Match the timescale string against each possibility and assign the
+   result. */
+   if ( astChrMatch( "TAI", ts ) ) {
+      result = AST__TAI;
+
+   } else if ( astChrMatch( "UTC", ts ) ) {
+      result = AST__UTC;
+
+   } else if ( astChrMatch( "UT1", ts ) ) {
+      result = AST__UT1;
+
+   } else if ( astChrMatch( "GMST", ts ) ) {
+      result = AST__GMST;
+
+   } else if ( astChrMatch( "LAST", ts ) ) {
+      result = AST__LAST;
+
+   } else if ( astChrMatch( "LMST", ts ) ) {
+      result = AST__LMST;
+
+   } else if ( astChrMatch( "TT", ts ) ) {
+      result = AST__TT;
+
+   } else if ( astChrMatch( "TDB", ts ) ) {
+      result = AST__TDB;
+
+   } else if ( astChrMatch( "TCG", ts ) ) {
+      result = AST__TCG;
+
+   } else if ( astChrMatch( "TCB", ts ) ) {
+      result = AST__TCB;
+
+   } else if ( astChrMatch( "LT", ts ) ) {
+      result = AST__LT;
+
+   }
+
+/* Return the result. */
+   return result;
+}
+
+static const char *TimeScaleString( AstTimeScaleType ts, int *status ) {
+/*
+*  Name:
+*     TimeScaleString
+
+*  Purpose:
+*     Convert a time scale type code into a string.
+
+*  Type:
+*     Private function.
+
+*  Synopsis:
+*     #include "timeframe.h"
+*     const char *TimeScaleString( AstTimeScaleType ts, int *status )
+
+*  Class Membership:
+*     TimeFrame member function.
+
+*  Description:
+*     This function converts a TimeFrame time scale type code (TimeScale
+*     attribute value) into a string suitable for use as an external
+*     representation of the time scale type.
+
+*  Parameters:
+*     ts
+*        The time scale type code.
+*     status
+*        Pointer to the inherited status variable.
+
+*  Returned Value:
+*     Pointer to a constant null-terminated string containing the
+*     textual equivalent of the type code supplied.
+
+*  Notes:
+*     - A NULL pointer value is returned if the time scale
+*     code was not recognised. This does not produce an error.
+*     - A NULL pointer value is also 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;           /* Pointer value to return */
+
+/* Initialise. */
+   result = NULL;
+
+/* Check the global error status. */
+   if ( !astOK ) return result;
+
+/* Match the timescale value against each possibility and convert to a
+   string pointer. */
+   switch ( ts ) {
+
+   case AST__TAI:
+      result = "TAI";
+      break;
+
+   case AST__UTC:
+      result = "UTC";
+      break;
+
+   case AST__UT1:
+      result = "UT1";
+      break;
+
+   case AST__GMST:
+      result = "GMST";
+      break;
+
+   case AST__LAST:
+      result = "LAST";
+      break;
+
+   case AST__LMST:
+      result = "LMST";
+      break;
+
+   case AST__TT:
+      result = "TT";
+      break;
+
+   case AST__TDB:
+      result = "TDB";
+      break;
+
+   case AST__TCB:
+      result = "TCB";
+      break;
+
+   case AST__TCG:
+      result = "TCG";
+      break;
+
+   case AST__LT:
+      result = "LT";
+      break;
+
+   }
+
+/* Return the result pointer. */
+   return result;
+}
+
+static int SubFrame( AstFrame *target_frame, AstFrame *template,
+                     int result_naxes, const int *target_axes,
+                     const int *template_axes, AstMapping **map,
+                     AstFrame **result, int *status ) {
+/*
+*  Name:
+*     SubFrame
+
+*  Purpose:
+*     Select axes from a TimeFrame and convert to the new coordinate
+*     system.
+
+*  Type:
+*     Private function.
+
+*  Synopsis:
+*     #include "timeframe.h"
+*     int SubFrame( AstFrame *target, AstFrame *template,
+*                   int result_naxes, const int *target_axes,
+*                   const int *template_axes, AstMapping **map,
+*                   AstFrame **result, int *status )
+
+*  Class Membership:
+*     TimeFrame member function (over-rides the protected astSubFrame
+*     method inherited from the Frame class).
+
+*  Description:
+*     This function selects a requested sub-set (or super-set) of the axes
+*     from a "target" TimeFrame and creates a new Frame with copies of
+*     the selected axes assembled in the requested order. It then
+*     optionally overlays the attributes of a "template" Frame on to the
+*     result. It returns both the resulting Frame and a Mapping that
+*     describes how to convert between the coordinate systems described by
+*     the target and result Frames. If necessary, this Mapping takes
+*     account of any differences in the Frames' attributes due to the
+*     influence of the template.
+
+*  Parameters:
+*     target
+*        Pointer to the target TimeFrame, from which axes are to be
+*        selected.
+*     template
+*        Pointer to the template Frame, from which new attributes for the
+*        result Frame are to be obtained. Optionally, this may be NULL, in
+*        which case no overlaying of template attributes will be performed.
+*     result_naxes
+*        Number of axes to be selected from the target Frame. This number may
+*        be greater than or less than the number of axes in this Frame (or
+*        equal).
+*     target_axes
+*        Pointer to an array of int with result_naxes elements, giving a list
+*        of the (zero-based) axis indices of the axes to be selected from the
+*        target TimeFrame. The order in which these are given determines
+*        the order in which the axes appear in the result Frame. If any of the
+*        values in this array is set to -1, the corresponding result axis will
+*        not be derived from the target Frame, but will be assigned default
+*        attributes instead.
+*     template_axes
+*        Pointer to an array of int with result_naxes elements. This should
+*        contain a list of the template axes (given as zero-based axis indices)
+*        with which the axes of the result Frame are to be associated. This
+*        array determines which axes are used when overlaying axis-dependent
+*        attributes of the template on to the result. If any element of this
+*        array is set to -1, the corresponding result axis will not receive any
+*        template attributes.
+*
+*        If the template argument is given as NULL, this array is not used and
+*        a NULL pointer may also be supplied here.
+*     map
+*        Address of a location to receive a pointer to the returned Mapping.
+*        The forward transformation of this Mapping will describe how to
+*        convert coordinates from the coordinate system described by the target
+*        TimeFrame to that described by the result Frame. The inverse
+*        transformation will convert in the opposite direction.
+*     result
+*        Address of a location to receive a pointer to the result Frame.
+*     status
+*        Pointer to the inherited status variable.
+
+*  Returned Value:
+*     A non-zero value is returned if coordinate conversion is possible
+*     between the target and the result Frame. Otherwise zero is returned and
+*     *map and *result are returned as NULL (but this will not in itself
+*     result in an error condition). In general, coordinate conversion should
+*     always be possible if no template Frame is supplied but may not always
+*     be possible otherwise.
+
+*  Notes:
+*     -  A value of zero will be returned if this function is invoked with the
+*     global error status set, or if it should fail for any reason.
+
+*  Implementation Notes:
+*     -  This implementation addresses the selection of axes from a
+*     TimeFrame object. This results in another object of the same class
+*     only if the single TimeFrame axis is selected exactly once.
+*     Otherwise, the result is a Frame class object which inherits the
+*     TimeFrame's axis information (if appropriate) but none of the other
+*     properties of a TimeFrame.
+*     -  In the event that a TimeFrame results, the returned Mapping will
+*     take proper account of the relationship between the target and result
+*     coordinate systems.
+*     -  In the event that a Frame class object results, the returned Mapping
+*     will only represent a selection/permutation of axes.
+
+*  Implementation Deficiencies:
+*     -  Any axis selection is currently permitted. Probably this should be
+*     restricted so that each axis can only be selected once. The
+*     astValidateAxisSelection method will do this but currently there are bugs
+*     in the CmpFrame class that cause axis selections which will not pass this
+*     test. Install the validation when these are fixed.
+*/
+
+/* Local Variables: */
+   AstTimeFrame *target;      /* Pointer to the TimeFrame structure */
+   AstTimeFrame *temp;        /* Pointer to copy of target TimeFrame */
+   AstTimeFrame *align_frm;   /* Frame in which to align the TimeFrames */
+   int match;                 /* Coordinate conversion is possible? */
+
+/* Initialise the returned values. */
+   *map = NULL;
+   *result = NULL;
+   match = 0;
+
+/* Check the global error status. */
+   if ( !astOK ) return match;
+
+/* Obtain a pointer to the target TimeFrame structure. */
+   target = (AstTimeFrame *) target_frame;
+
+/* Result is a TimeFrame. */
+/* -------------------------- */
+/* Check if the result Frame is to have one axis obtained by selecting
+   the single target TimeFrame axis. If so, the result will also be
+   a TimeFrame. */
+   if ( ( result_naxes == 1 ) && ( target_axes[ 0 ] == 0 ) ) {
+
+/* Form the result from a copy of the target. */
+      *result = astCopy( target );
+
+/* If required, overlay the template attributes on to the result TimeFrame.
+   Also choose the Frame which defined the alignment system and time scale
+   (via its AlignSystem and AlignTimeScale attributes) in which to align the
+   two TimeFrames. This is the template (if there is a template). */
+      if ( template ) {
+         astOverlay( template, template_axes, *result );
+         if( astIsATimeFrame( template ) ) {
+            align_frm = astClone( template );
+         } else {
+            align_frm = astClone( target );
+         }
+
+/* If no template was supplied, align in the System and TimeScale of the
+   target. */
+      } else {
+         VerifyAttrs( target, "convert between different time systems",
+                      "TimeScale", "astMatch", status );
+         align_frm = astClone( target );
+      }
+
+/* Generate a Mapping that takes account of changes in the sky coordinate
+   system (equinox, epoch, etc.) between the target TimeFrame and the result
+   TimeFrame. If this Mapping can be generated, set "match" to indicate that
+   coordinate conversion is possible. */
+      match = ( MakeTimeMapping( target, (AstTimeFrame *) *result,
+                align_frm, 0, map, status ) != 0 );
+
+/* Free resources. */
+      align_frm = astAnnul( align_frm );
+
+/* Result is not a TimeFrame. */
+/* ------------------------------ */
+/* In this case, we select axes as if the target were from the Frame
+   class.  However, since the resulting data will then be separated
+   from their enclosing TimeFrame, default attribute values may differ
+   if the methods for obtaining them were over-ridden by the TimeFrame
+   class. To overcome this, we ensure that these values are explicitly
+   set for the result Frame (rather than relying on their defaults). */
+   } else {
+
+/* Make a temporary copy of the target TimeFrame. We will explicitly
+   set the attribute values in this copy so as not to modify the original. */
+      temp = astCopy( target );
+
+/* Define a macro to test if an attribute is set. If not, set it
+   explicitly to its default value. */
+#define SET(attribute) \
+   if ( !astTest##attribute( temp ) ) { \
+      astSet##attribute( temp, astGet##attribute( temp ) ); \
+   }
+
+/* Set attribute values which apply to the Frame as a whole and which
+   we want to retain, but whose defaults are over-ridden by the
+   TimeFrame class. */
+      SET(Domain)
+      SET(Title)
+
+/* Define a macro to test if an attribute is set for axis zero (the only
+   axis of a TimeFrame). If not, set it explicitly to its default value. */
+#define SET_AXIS(attribute) \
+   if ( !astTest##attribute( temp, 0 ) ) { \
+      astSet##attribute( temp, 0, \
+                         astGet##attribute( temp, 0 ) ); \
+   }
+
+/* Use this macro to set explicit values for all the axis attributes
+   for which the TimeFrame class over-rides the default value. */
+      SET_AXIS(Label)
+      SET_AXIS(Symbol)
+      SET_AXIS(Unit)
+
+/* Clear attributes which have an extended range of values allowed by
+   this class. */
+      astClearSystem( temp );
+      astClearAlignSystem( temp );
+
+/* Invoke the astSubFrame method inherited from the Frame class to
+   produce the result Frame by selecting the required set of axes and
+   overlaying the template Frame's attributes. */
+      match = (*parent_subframe)( (AstFrame *) temp, template,
+                                  result_naxes, target_axes, template_axes,
+                                  map, result, status );
+
+/* Delete the temporary copy of the target TimeFrame. */
+      temp = astDelete( temp );
+   }
+
+/* If an error occurred or no match was found, annul the returned
+   objects and reset the returned result. */
+   if ( !astOK || !match ) {
+      if( *map ) *map = astAnnul( *map );
+      if( *result ) *result = astAnnul( *result );
+      match = 0;
+   }
+
+/* Return the result. */
+   return match;
+
+/* Undefine macros local to this function. */
+#undef SET
+#undef SET_AXIS
+}
+
+static AstSystemType SystemCode( AstFrame *this, const char *system, int *status ) {
+/*
+*  Name:
+*     SystemCode
+
+*  Purpose:
+*     Convert a string into a coordinate system type code.
+
+*  Type:
+*     Private function.
+
+*  Synopsis:
+*     #include "timeframe.h"
+*     AstSystemType SystemCode( AstFrame *this, const char *system, int *status )
+
+*  Class Membership:
+*     TimeFrame member function (over-rides the astSystemCode method
+*     inherited from the Frame class).
+
+*  Description:
+*     This function converts a string used for the external description of
+*     a coordinate system into a TimeFrame coordinate system type code
+*     (System attribute value). It is the inverse of the astSystemString
+*     function.
+
+*  Parameters:
+*     this
+*        The Frame.
+*     system
+*        Pointer to a constant null-terminated string containing the
+*        external description of the sky coordinate system.
+*     status
+*        Pointer to the inherited status variable.
+
+*  Returned Value:
+*     The System type code.
+
+*  Notes:
+*     - A value of AST__BADSYSTEM is returned if the sky coordinate
+*     system description was not recognised. This does not produce an
+*     error.
+*     - A value of AST__BADSYSTEM is also returned if this function
+*     is invoked with the global error status set or if it should fail
+*     for any reason.
+*/
+
+/* Local Variables: */
+   AstSystemType result;      /* Result value to return */
+
+/* Initialise. */
+   result = AST__BADSYSTEM;
+
+/* Check the global error status. */
+   if ( !astOK ) return result;
+
+/* Match the "system" string against each possibility and assign the
+   result. */
+   if ( astChrMatch( "MJD", system ) || astChrMatch( "Modified Julian Date", system ) ) {
+      result = AST__MJD;
+
+   } else if ( astChrMatch( "JD", system ) || astChrMatch( "Julian Date", system ) ) {
+      result = AST__JD;
+
+   } else if ( astChrMatch( "BEPOCH", system ) || astChrMatch( "Besselian Epoch", system ) ) {
+      result = AST__BEPOCH;
+
+   } else if ( astChrMatch( "JEPOCH", system ) || astChrMatch( "Julian Epoch", system ) ) {
+      result = AST__JEPOCH;
+
+   }
+
+/* Return the result. */
+   return result;
+}
+
+static const char *SystemLabel( AstSystemType system, int *status ) {
+/*
+*  Name:
+*     SystemLabel
+
+*  Purpose:
+*     Return a label for a coordinate system type code.
+
+*  Type:
+*     Private function.
+
+*  Synopsis:
+*     #include "timeframe.h"
+*     const char *SystemLabel( AstSystemType system, int *status )
+
+*  Class Membership:
+*     TimeFrame member function.
+
+*  Description:
+*     This function converts a TimeFrame coordinate system type code
+*     (System attribute value) into a descriptive string for human readers.
+
+*  Parameters:
+*     system
+*        The coordinate system type code.
+*     status
+*        Pointer to the inherited status variable.
+
+*  Returned Value:
+*     Pointer to a constant null-terminated string containing the
+*     textual equivalent of the type code supplied.
+
+*  Notes:
+*     - A NULL pointer value is returned if the sky coordinate system
+*     code was not recognised. This does not produce an error.
+*     - A NULL pointer value is also 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;           /* Pointer value to return */
+
+/* Initialise. */
+   result = NULL;
+
+/* Check the global error status. */
+   if ( !astOK ) return result;
+
+/* Match the "system" value against each possibility and convert to a
+   string pointer. */
+   switch ( system ) {
+
+   case AST__MJD:
+      result = "Modified Julian Date";
+      break;
+
+   case AST__JD:
+      result = "Julian Date";
+      break;
+
+   case AST__JEPOCH:
+      result = "Julian Epoch";
+      break;
+
+   case AST__BEPOCH:
+      result = "Besselian Epoch";
+      break;
+
+   }
+
+/* Return the result pointer. */
+   return result;
+}
+
+static const char *SystemString( AstFrame *this, AstSystemType system, int *status ) {
+/*
+*  Name:
+*     SystemString
+
+*  Purpose:
+*     Convert a coordinate system type code into a string.
+
+*  Type:
+*     Private function.
+
+*  Synopsis:
+*     #include "timeframe.h"
+*     const char *SystemString( AstFrame *this, AstSystemType system, int *status )
+
+*  Class Membership:
+*     TimeFrame member function (over-rides the astSystemString method
+*     inherited from the Frame class).
+
+*  Description:
+*     This function converts a TimeFrame coordinate system type code
+*     (System attribute value) into a string suitable for use as an
+*     external representation of the coordinate system type.
+
+*  Parameters:
+*     this
+*        The Frame.
+*     system
+*        The coordinate system type code.
+*     status
+*        Pointer to the inherited status variable.
+
+*  Returned Value:
+*     Pointer to a constant null-terminated string containing the
+*     textual equivalent of the type code supplied.
+
+*  Notes:
+*     - A NULL pointer value is returned if the sky coordinate system
+*     code was not recognised. This does not produce an error.
+*     - A NULL pointer value is also 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;           /* Pointer value to return */
+
+/* Initialise. */
+   result = NULL;
+
+/* Check the global error status. */
+   if ( !astOK ) return result;
+
+/* Match the "system" value against each possibility and convert to a
+   string pointer. (Where possible, return the same string as would be
+   used in the FITS WCS representation of the coordinate system). */
+   switch ( system ) {
+
+   case AST__MJD:
+      result = "MJD";
+      break;
+
+   case AST__JD:
+      result = "JD";
+      break;
+
+   case AST__JEPOCH:
+      result = "JEPOCH";
+      break;
+
+   case AST__BEPOCH:
+      result = "BEPOCH";
+      break;
+   }
+
+/* Return the result pointer. */
+   return result;
+}
+
+static int TestActiveUnit( AstFrame *this_frame, int *status ) {
+/*
+*  Name:
+*     TestActiveUnit
+
+*  Purpose:
+*     Test the ActiveUnit flag for a TimeFrame.
+
+*  Type:
+*     Private function.
+
+*  Synopsis:
+*     #include "timeframe.h"
+*     int TestActiveUnit( AstFrame *this_frame, int *status )
+
+*  Class Membership:
+*     TimeFrame member function (over-rides the astTestActiveUnit protected
+*     method inherited from the Frame class).
+
+*  Description:
+*    This function test the value of the ActiveUnit flag for a TimeFrame,
+*    which is always "unset".
+
+*  Parameters:
+*     this
+*        Pointer to the TimeFrame.
+*     status
+*        Pointer to the inherited status variable.
+
+*  Returned Value:
+*     The result of the test (0).
+
+*/
+   return 0;
+}
+
+static int TestAttrib( AstObject *this_object, const char *attrib, int *status ) {
+/*
+*  Name:
+*     TestAttrib
+
+*  Purpose:
+*     Test if a specified attribute value is set for a TimeFrame.
+
+*  Type:
+*     Private function.
+
+*  Synopsis:
+*     #include "timeframe.h"
+*     int TestAttrib( AstObject *this, const char *attrib, int *status )
+
+*  Class Membership:
+*     TimeFrame member function (over-rides the astTestAttrib protected
+*     method inherited from the Frame class).
+
+*  Description:
+*     This function returns a boolean result (0 or 1) to indicate whether
+*     a value has been set for one of a TimeFrame's attributes.
+
+*  Parameters:
+*     this
+*        Pointer to the TimeFrame.
+*     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:
+*     - This function uses one-based axis numbering so that it is
+*     suitable for external (public) use.
+*     - 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: */
+   AstTimeFrame *this;           /* Pointer to the TimeFrame structure */
+   char *new_attrib;             /* Pointer value to new attribute name */
+   int len;                      /* Length of attrib string */
+   int result;                   /* Result value to return */
+
+/* Initialise. */
+   result = 0;
+
+/* Check the global error status. */
+   if ( !astOK ) return result;
+
+/* Obtain a pointer to the TimeFrame structure. */
+   this = (AstTimeFrame *) this_object;
+
+/* Obtain the length of the attrib string. */
+   len = strlen( attrib );
+
+/* Check the attribute name and test the appropriate attribute. */
+
+/* First look for axis attributes defined by the Frame class. Since a
+   TimeFrame has only 1 axis, we allow these attributes to be specified
+   without a trailing "(axis)" string. */
+   if ( !strcmp( attrib, "direction" ) ||
+        !strcmp( attrib, "bottom" ) ||
+        !strcmp( attrib, "top" ) ||
+        !strcmp( attrib, "format" ) ||
+        !strcmp( attrib, "label" ) ||
+        !strcmp( attrib, "symbol" ) ||
+        !strcmp( attrib, "unit" ) ) {
+
+/* Create a new attribute name from the original by appending the string
+   "(1)" and then use the parent TestAttrib method. */
+      new_attrib = astMalloc( len + 4 );
+      if( new_attrib ) {
+         memcpy( new_attrib, attrib, len );
+         memcpy( new_attrib + len, "(1)", 4 );
+         result = (*parent_testattrib)( this_object, new_attrib, status );
+         new_attrib = astFree( new_attrib );
+      }
+
+/* AlignTimeScale. */
+/* --------------- */
+   } else if ( !strcmp( attrib, "aligntimescale" ) ) {
+      result = astTestAlignTimeScale( this );
+
+/* ClockLat. */
+/* ------- */
+   } else if ( !strcmp( attrib, "clocklat" ) ) {
+      result = astTestAttrib( this, "obslat" );
+
+/* ClockLon. */
+/* ------- */
+   } else if ( !strcmp( attrib, "clocklon" ) ) {
+      result = astTestAttrib( this, "obslon" );
+
+/* LTOffset. */
+/* --------- */
+   } else if ( !strcmp( attrib, "ltoffset" ) ) {
+      result = astTestLTOffset( this );
+
+/* TimeOrigin. */
+/* --------- */
+   } else if ( !strcmp( attrib, "timeorigin" ) ) {
+      result = astTestTimeOrigin( this );
+
+/* TimeScale. */
+/* ---------- */
+   } else if ( !strcmp( attrib, "timescale" ) ) {
+      result = astTestTimeScale( this );
+
+/* If the attribute is 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 double ToMJD( AstSystemType oldsys, double oldval, int *status ){
+/*
+*  Name:
+*     ToMJD
+
+*  Purpose:
+*     Convert a time value from TimeFrame's System to MJD.
+
+*  Type:
+*     Private function.
+
+*  Synopsis:
+*     #include "timeframe.h"
+*     double ToMJD( AstSystemType oldsys, double oldval, int *status ){
+
+*  Class Membership:
+*     TimeFrame member function
+
+*  Description:
+*     This function converts the supplied value from the supplied System
+*     to an MJD.
+
+*  Parameters:
+*     oldsys
+*        The System in which the oldval is supplied.
+*     oldval
+*        The value to convert, assumed to be in the default units
+*        associated with "oldsys".
+*     status
+*        Pointer to the inherited status variable.
+
+*  Returned Value:
+*     The MJD value corresponding to "oldval"
+
+*  Notes:
+*     - Both old and new value are assumed to be absolute (i.e. have zero
+*     offset).
+
+*/
+
+/* Local Variables; */
+   AstMapping *map;
+   double result;
+
+/* Initialise. */
+   result = AST__BAD;
+
+/* Check the global error status. */
+   if ( !astOK ) return result;
+
+/* If the old system is MJD just return the value unchanged. */
+   if( oldsys == AST__MJD ) {
+      result = oldval;
+
+/* Otherwise create a TimeMap wich converts from the TimeFrame system to
+   MJD, and use it to transform the supplied value. */
+   } else {
+      map = ToMJDMap( oldsys, 0.0, status );
+
+/* Use the TimeMap to convert the supplied value. */
+      astTran1( map, 1, &oldval, 1, &result );
+
+/* Free resources */
+      map = astAnnul( map );
+
+   }
+
+/* Return the result */
+   return result;
+}
+
+static AstMapping *ToMJDMap( AstSystemType oldsys, double off, int *status ){
+/*
+*  Name:
+*     ToMJDMap
+
+*  Purpose:
+*     Create a Mapping from a specified System to MJD.
+
+*  Type:
+*     Private function.
+
+*  Synopsis:
+*     #include "timeframe.h"
+*     AstMapping *ToMJDMap( AstSystemType oldsys, double off, int *status ){
+
+*  Class Membership:
+*     TimeFrame member function
+
+*  Description:
+*     This function creates a Mapping which converts from the supplied
+*     system and offset to absolute MJD.
+
+*  Parameters:
+*     oldsys
+*        The System in which the oldval is supplied.
+*     off
+*        The axis offset used with the old System, assumed to be in the
+*        default system associated with oldsys.
+*     status
+*        Pointer to the inherited status variable.
+
+*  Returned Value:
+*     The Mapping.
+
+*/
+
+/* Local Variables; */
+   AstTimeMap *timemap;
+   double args[ 2 ];
+
+/* Check the global error status. */
+   if ( !astOK ) return NULL;
+
+/* Create a null TimeMap */
+   timemap = astTimeMap( 0, "", status );
+
+/* Set the offsets for the supplied and returned values. */
+   args[ 0 ] = off;
+   args[ 1 ] = 0.0;
+
+/* If required, add a TimeMap conversion which converts from the TimeFrame
+   system to MJD. */
+   if( oldsys == AST__MJD ) {
+/*      if( off != 0.0 ) astTimeAdd( timemap, "MJDTOMJD", 2, args ); */
+      astTimeAdd( timemap, "MJDTOMJD", 2, args );
+
+   } else if( oldsys == AST__JD ) {
+      astTimeAdd( timemap, "JDTOMJD", 2, args );
+
+   } else if( oldsys == AST__JEPOCH ) {
+      astTimeAdd( timemap, "JEPTOMJD", 2, args );
+
+   } else if( oldsys == AST__BEPOCH ) {
+      astTimeAdd( timemap, "BEPTOMJD", 2, args );
+   }
+
+/* Return the result */
+   return (AstMapping *) timemap;
+}
+
+static double ToUnits( AstTimeFrame *this, const char *oldunit, double oldval,
+                       const char *method, int *status ){
+/*
+*
+*  Name:
+*     ToUnits
+
+*  Purpose:
+*     Convert a supplied time value to the default units of the supplied TimeFrame.
+
+*  Type:
+*     Private function.
+
+*  Synopsis:
+*     #include "timeframe.h"
+*     double ToUnits( AstTimeFrame *this, const char *oldunit, double oldval,
+*                     const char *method, int *status )
+
+*  Class Membership:
+*     TimeFrame member function
+
+*  Description:
+*     This function converts the supplied time value from the supplied
+*     units to the default units associated with the supplied TimeFrame's
+*     System.
+
+*  Parameters:
+*     this
+*        Pointer to the TimeFrame.
+*     oldunit
+*        The units in which "oldval" is supplied.
+*     oldval
+*        The value to be converted.
+*     method
+*        Pointer to a string holding the name of the method to be
+*        included in any error messages.
+*     status
+*        Pointer to the inherited status variable.
+
+*  Returned Value:
+*     The converted value.
+
+*/
+
+/* Local Variables: */
+   AstMapping *map;
+   const char *defunit;
+   double result;
+
+/* Initialise. */
+   result = AST__BAD;
+
+/* Check the global error status. */
+   if ( !astOK ) return result;
+
+/* Get default units associated with the System attribute of the supplied
+   TimeFrame, and find a Mapping from the old units to the default. */
+   defunit = DefUnit( astGetSystem( this ), method, "TimeFrame", status );
+   map = astUnitMapper( oldunit, defunit, NULL, NULL );
+   if( map ) {
+
+/* Use the Mapping to convert the supplied value. */
+      astTran1( map, 1, &oldval, 1, &result );
+
+/* Free resources. */
+      map = astAnnul( map );
+
+/* Report an error if no conversion is possible. */
+   } else if( astOK ){
+      astError( AST__BADUN, "%s(%s): Cannot convert the supplied attribute "
+                "value from units of %s to %s.", status, method, astGetClass( this ),
+                 oldunit, defunit );
+   }
+
+/* Return the result */
+   return result;
+}
+
+static int Unformat( AstFrame *this_frame, int axis, const char *string,
+                     double *value, int *status ) {
+/*
+*  Name:
+*     Unformat
+
+*  Purpose:
+*     Read a formatted coordinate value for a TimeFrame axis.
+
+*  Type:
+*     Private function.
+
+*  Synopsis:
+*     #include "timeframe.h"
+*     int Unformat( AstFrame *this, int axis, const char *string,
+*                   double *value, int *status )
+
+*  Class Membership:
+*     TimeFrame member function (over-rides the public astUnformat
+*     method inherited from the Frame class).
+
+*  Description:
+*     This function reads a formatted coordinate value for a TimeFrame
+*     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 TimeFrame.
+*     axis
+*        The number of the TimeFrame axis for which the coordinate
+*        value is to be read (axis numbering starts at zero for the
+*        first 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.
+*     status
+*        Pointer to the inherited status variable.
+
+*  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: */
+   AstMapping *map;
+   AstTimeFrame *this;
+   AstTimeScaleType ts1;
+   AstTimeScaleType ts2;
+   const char *c;
+   char *old_fmt;
+   char *str;
+   const char *txt;
+   double mjd;
+   double val1;
+   int l;
+   int lt;
+   int nc1;
+   int nc;
+   int ndp;
+   int rep;
+
+/* Initialise. */
+   nc = 0;
+
+/* Check the global error status. */
+   if ( !astOK ) return nc;
+
+/* Obtain a pointer to the TimeFrame structure. */
+   this = (AstTimeFrame *) this_frame;
+
+/* Validate the axis index. */
+   (void) astValidateAxis( this, axis, 1, "astUnformat" );
+
+/* First attempt to read the value using the parent unformat method, and
+   note how many characters were used. We temporarily clear the Format
+   attribute if it has been set to a date format, since the parent Frame
+   class does not understand date format.*/
+   txt = astGetFormat( this, axis );
+   if( DateFormat( txt, &ndp, NULL, status ) ) {
+       old_fmt = astStore( NULL, txt, strlen( txt ) + 1 );
+       astClearFormat( this, axis );
+   } else {
+       old_fmt = NULL;
+   }
+
+   nc1 = (*parent_unformat)( this_frame, axis, string, &val1, status );
+
+/* Re-instate the original Format */
+   if( old_fmt ) {
+      astSetFormat( this,axis, old_fmt );
+      old_fmt = astFree( old_fmt );
+   }
+
+/* The astReadDateTime function (defined within frame.c) does not allow
+   for any extra text to be appended to the end of the formatted date/time
+   (AST__BAD is returned if any such extra text is present). But astUnformat
+   is contracted to allow such text. So we need to make multiple attempts
+   at reading the date/time in order to find the longest leading string
+   which gives a non-bad value. First take a copy of the supplied string
+   si we can terminate it at any point we wish. */
+   l = astChrLen( string );
+   str = astStore( NULL, string, l + 1 );
+
+/* Now attempt to read an ISO date from the start of the string. We
+   switch off error reporting to avoid reports of unsuitable syntax. */
+   rep = astReporting( 0 );
+
+/* Attempt to read a date/time from the whol string. If this fails
+   terminate the string in order to make it one character shorter and try
+   again. */
+   for( lt = l; lt > 0; lt-- ) {
+      str[ lt ] = 0;
+      mjd = astReadDateTime( str );
+      if( !astOK ) astClearStatus;
+      if( mjd != AST__BAD ) break;
+   }
+
+/* Re-instate error reporting. */
+   astReporting( rep );
+
+/* Free resources. */
+   str = astFree( str );
+
+/* If the whole non-blank start of the string was consumed, add on any
+   trailing white space. */
+   if( lt >= l ) lt = strlen( string );
+
+/* If no date/time could be read, or if reading the value as a
+   floating point value was at least as good, return the floating point
+   value (assumed to be in the system and units of the TimeFrame. */
+   if( mjd == AST__BAD || nc1 >= l ) {
+      *value = val1;
+      nc = nc1;
+
+/* Otherwise, if a date/time was read convert it to the TimeFrame system,
+   etc. */
+   } else if( mjd != AST__BAD ) {
+
+/* Save the number of character read from the supplied string. */
+      nc = lt;
+
+/* We require a value in the timescale of the supplied TimeFrame. Get
+   this TimeScale. */
+      ts2 = astGetTimeScale( this );
+
+/* If the supplied string gave the date/time as a Besselian epoch, the
+   input timescale is TT, otherwise it is assumed to be the TimeScale of
+   the TimeFrame. Locate the first non-space character. */
+      c = string;
+      while( *c && isspace( *c ) ) c++;
+
+/* If the first non-space is a "B", assuming a TT timescale. Otherwise
+   assume the timescale of the supplied TimeFrame. */
+      ts1 = ( *c == 'B' || *c == 'b' ) ? AST__TT : ts2;
+
+/* Create the Mapping and use it to transform the mjd value. */
+      map = MakeMap( this, AST__MJD, astGetSystem( this ), ts1, ts2,
+                     0.0, astGetTimeOrigin( this ), "d",
+                     astGetUnit( this, 0 ), "astFormat", status );
+      if( map ) {
+         astTran1( map, 1, &mjd, 1, value );
+         map = astAnnul( map );
+      } else {
+         astError( AST__INCTS, "astUnformat(%s): Cannot convert the "
+                "supplied date/time string (%s) to the required "
+                "timescale (%s).", status, astGetClass( this ), string,
+                TimeScaleString( ts2, status ) );
+      }
+   }
+
+/* Return the number of characters read. */
+   return nc;
+}
+
+static int ValidateSystem( AstFrame *this, AstSystemType system, const char *method, int *status ) {
+/*
+*
+*  Name:
+*     ValidateSystem
+
+*  Purpose:
+*     Validate a value for a Frame's System attribute.
+
+*  Type:
+*     Protected virtual function.
+
+*  Synopsis:
+*     #include "timeframe.h"
+*     int ValidateSystem( AstFrame *this, AstSystemType system,
+*                         const char *method, int *status )
+
+*  Class Membership:
+*     TimeFrame member function (over-rides the astValidateSystem method
+*     inherited from the Frame class).
+
+*  Description:
+*     This function checks the validity of the supplied system value.
+*     If the value is valid, it is returned unchanged. Otherwise, an
+*     error is reported and a value of AST__BADSYSTEM is returned.
+
+*  Parameters:
+*     this
+*        Pointer to the Frame.
+*     system
+*        The system value to be checked.
+*     method
+*        Pointer to a constant null-terminated character string
+*        containing the name of the method that invoked this function
+*        to validate an axis index. This method name is used solely
+*        for constructing error messages.
+*     status
+*        Pointer to the inherited status variable.
+
+*  Returned Value:
+*     The validated system value.
+
+*  Notes:
+*     - A value of AST__BADSYSTEM will be returned if this function is invoked
+*     with the global error status set, or if it should fail for any
+*     reason.
+*/
+
+/* Local Variables: */
+   AstSystemType result;              /* Validated system value */
+
+/* Initialise. */
+   result = AST__BADSYSTEM;
+
+/* Check the global error status. */
+   if ( !astOK ) return result;
+
+/* If the value is out of bounds, report an error. */
+   if ( system < FIRST_SYSTEM || system > LAST_SYSTEM ) {
+         astError( AST__AXIIN, "%s(%s): Bad value (%d) given for the System "
+                   "or AlignSystem attribute of a %s.", status, method,
+                   astGetClass( this ), (int) system, astGetClass( this ) );
+
+/* Otherwise, return the supplied value. */
+   } else {
+      result = system;
+   }
+
+/* Return the result. */
+   return result;
+}
+
+static void VerifyAttrs( AstTimeFrame *this, const char *purp,
+                         const char *attrs, const char *method, int *status ) {
+/*
+*  Name:
+*     VerifyAttrs
+
+*  Purpose:
+*     Verify that usable attribute values are available.
+
+*  Type:
+*     Private function.
+
+*  Synopsis:
+*     #include "timeframe.h"
+*     void VerifyAttrs( AstTimeFrame *this, const char *purp,
+*                       const char *attrs, const char *method, int *status  )
+
+*  Class Membership:
+*     TimeFrame member function
+
+*  Description:
+*     This function tests each attribute listed in "attrs". It returns
+*     without action if 1) an explicit value has been set for each attribute
+*     or 2) the UseDefs attribute of the supplied TimeFrame is non-zero.
+*
+*     If UseDefs is zero (indicating that default values should not be
+*     used for attributes), and any of the named attributes does not have
+*     an explicitly set value, then an error is reported.
+
+*  Parameters:
+*     this
+*        Pointer to the TimeFrame.
+*     purp
+*        Pointer to a text string containing a message which will be
+*        included in any error report. This shouldindicate the purpose
+*        for which the attribute value is required.
+*     attrs
+*        A string holding a space separated list of attribute names.
+*     method
+*        A string holding the name of the calling method for use in error
+*        messages.
+*     status
+*        Pointer to the inherited status variable.
+
+*/
+
+/* Local Variables: */
+   const char *a;
+   const char *desc;
+   const char *p;
+   int len;
+   int set;
+   int state;
+
+/* Check inherited status */
+   if( !astOK ) return;
+
+/* Stop compiler warnings about uninitialised variables */
+   a = NULL;
+   desc = NULL;
+   len = 0;
+   set = 0;
+
+/* If the TimeFrame has a non-zero value for its UseDefs attribute, then
+   all attributes are assumed to have usable values, since the defaults
+   will be used if no explicit value has been set. So we only need to do
+   any checks if UseDefs is zero. */
+   if( !astGetUseDefs( this ) ) {
+
+/* Loop round the "attrs" string identifying the start and length of each
+   non-blank word in the string. */
+      state = 0;
+      p = attrs;
+      while( 1 ) {
+         if( state == 0 ) {
+            if( !isspace( *p ) ) {
+               a = p;
+               len = 1;
+               state = 1;
+            }
+         } else {
+            if( isspace( *p ) || !*p ) {
+
+/* The end of a word has just been reached. Compare it to each known
+   attribute value. Get a flag indicating if the attribute has a set
+   value, and a string describing the attribute.*/
+               if( len > 0 ) {
+
+                  if( !strncmp( "ObsLat", a, len ) ) {
+                     set = astTestObsLat( this );
+                     desc = "observer latitude";
+
+                  } else if( !strncmp( "ObsLon", a, len ) ) {
+                     set = astTestObsLon( this );
+                     desc = "observer longitude";
+
+                  } else if( !strncmp( "ObsAlt", a, len ) ) {
+                     set = astTestObsAlt( this );
+                     desc = "observer altitude";
+
+                  } else if( !strncmp( "Dtai", a, len ) ) {
+                     set = astTestDtai( this );
+                     desc = "TAI-UTC correction";
+
+                  } else if( !strncmp( "Dut1", a, len ) ) {
+                     set = astTestDut1( this );
+                     desc = "UT1-UTC correction";
+
+                  } else if( !strncmp( "TimeOrigin", a, len ) ) {
+                     set = astTestTimeOrigin( this );
+                     desc = "time offset";
+
+                  } else if( !strncmp( "LTOffset", a, len ) ) {
+                     set = astTestLTOffset( this );
+                     desc = "local time offset";
+
+                  } else if( !strncmp( "TimeScale", a, len ) ) {
+                     set = astTestTimeScale( this );
+                     desc = "time scale";
+
+                  } else {
+                     astError( AST__INTER, "VerifyAttrs(TimeFrame): "
+                               "Unknown attribute name \"%.*s\" supplied (AST "
+                               "internal programming error).", status, len, a );
+                  }
+
+/* If the attribute does not have a set value, report an error. */
+                  if( !set && astOK ) {
+                     astError( AST__NOVAL, "%s(%s): Cannot %s.", status, method,
+                               astGetClass( this ), purp );
+                     astError( AST__NOVAL, "No value has been set for "
+                               "the AST \"%.*s\" attribute (%s).", status, len, a,
+                               desc );
+                  }
+
+/* Continue the word search algorithm. */
+               }
+               len = 0;
+               state = 0;
+            } else {
+               len++;
+            }
+         }
+         if( !*(p++) ) break;
+      }
+   }
+}
+
+/* Functions which access class attributes. */
+/* ---------------------------------------- */
+
+/*
+*att++
+*  Name:
+*     TimeOrigin
+
+*  Purpose:
+*     The zero point for TimeFrame axis values
+
+*  Type:
+*     Public attribute.
+
+*  Synopsis:
+*     Floating point.
+
+*  Description:
+*     This specifies the origin from which all time values are measured.
+*     The default value (zero) results in the TimeFrame describing
+*     absolute time values in the system given by the System attribute
+*     (e.g. MJD, Julian epoch, etc). If a TimeFrame is to be used to
+*     describe elapsed time since some origin, the TimeOrigin attribute
+*     should be set to hold the required origin value. The TimeOrigin value
+*     stored inside the TimeFrame structure is modified whenever TimeFrame
+*     attribute values are changed so that it refers to the original moment
+*     in time.
+*
+*  Input Formats:
+*     The formats accepted when setting a TimeOrigin value are listed
+*     below. They are all case-insensitive and are generally tolerant
+*     of extra white space and alternative field delimiters:
+*
+*     - Besselian Epoch: Expressed in decimal years, with or without
+*     decimal places ("B1950" or "B1976.13" for example).
+*
+*     - Julian Epoch: Expressed in decimal years, with or without
+*     decimal places ("J2000" or "J2100.9" for example).
+*
+*     - Units: An unqualified decimal value is interpreted as a value in
+*     the system specified by the TimeFrame's System attribute, in the
+*     units given by the TimeFrame's Unit attribute. Alternatively, an
+*     appropriate unit string can be appended to the end of the floating
+*     point value ("123.4 d" for example), in which case the supplied value
+*     is scaled into the units specified by the Unit attribute.
+*
+*     - Julian Date: With or without decimal places ("JD 2454321.9" for
+*     example).
+*
+*     - Modified Julian Date: With or without decimal places
+*     ("MJD 54321.4" for example).
+*
+*     - Gregorian Calendar Date: With the month expressed either as an
+*     integer or a 3-character abbreviation, and with optional decimal
+*     places to represent a fraction of a day ("1996-10-2" or
+*     "1996-Oct-2.6" for example). If no fractional part of a day is
+*     given, the time refers to the start of the day (zero hours).
+*
+*     - Gregorian Date and Time: Any calendar date (as above) but with
+*     a fraction of a day expressed as hours, minutes and seconds
+*     ("1996-Oct-2 12:13:56.985" for example). The date and time can be
+*     separated by a space or by a "T" (as used by ISO8601 format).
+
+*  Output Format:
+*     When enquiring TimeOrigin values, the returned formatted floating
+*     point value represents a value in the TimeFrame's System, in the unit
+*     specified by the TimeFrame's Unit attribute.
+
+*  Applicability:
+*     TimeFrame
+*        All TimeFrames have this attribute.
+
+*att--
+*/
+/* The time origin, stored internally in the default units associated
+   with the current System value. Clear the TimeOrigin value  by setting it
+   to AST__BAD, which gives 0.0 as the default value. Any value is acceptable. */
+astMAKE_CLEAR(TimeFrame,TimeOrigin,timeorigin,AST__BAD)
+astMAKE_GET(TimeFrame,TimeOrigin,double,0.0,((this->timeorigin!=AST__BAD)?this->timeorigin:0.0))
+astMAKE_SET(TimeFrame,TimeOrigin,double,timeorigin,value)
+astMAKE_TEST(TimeFrame,TimeOrigin,( this->timeorigin != AST__BAD ))
+
+/*
+*att++
+*  Name:
+*     LTOffset
+
+*  Purpose:
+*     The offset from UTC to Local Time, in hours.
+
+*  Type:
+*     Public attribute.
+
+*  Synopsis:
+*     Floating point.
+
+*  Description:
+*     This specifies the offset from UTC to Local Time, in hours (fractional
+*     hours can be supplied). It is positive for time zones east of Greenwich.
+*     AST uses the figure as given, without making any attempt to correct for
+*     daylight saving. The default value is zero.
+
+*  Applicability:
+*     TimeFrame
+*        All TimeFrames have this attribute.
+
+*att--
+*/
+astMAKE_CLEAR(TimeFrame,LTOffset,ltoffset,AST__BAD)
+astMAKE_GET(TimeFrame,LTOffset,double,0.0,((this->ltoffset!=AST__BAD)?this->ltoffset:0.0))
+astMAKE_SET(TimeFrame,LTOffset,double,ltoffset,value)
+astMAKE_TEST(TimeFrame,LTOffset,( this->ltoffset != AST__BAD ))
+
+/*
+*att++
+*  Name:
+*     AlignTimeScale
+
+*  Purpose:
+*     Time scale to use when aligning TimeFrames.
+
+*  Type:
+*     Public attribute.
+
+*  Synopsis:
+*     String.
+
+*  Description:
+*     This attribute controls how a TimeFrame behaves when it is used (by
+c     astFindFrame or astConvert) as a template to match another (target)
+f     AST_FINDFRAME or AST_CONVERT) as a template to match another (target)
+*     TimeFrame. It identifies the time scale in which alignment is
+*     to occur. See the TimeScale attribute for a desription of the values
+*     which may be assigned to this attribute. The default AlignTimeScale
+*     value depends on the current value of TimeScale: if TimeScale is
+*     UT1, GMST, LMST or LAST, the default for AlignTimeScale is UT1, for all
+*     other TimeScales the default is TAI.
+*
+c     When astFindFrame or astConvert is used on two TimeFrames (potentially
+f     When AST_FindFrame or AST_CONVERT is used on two TimeFrames (potentially
+*     describing different time coordinate systems), it returns a Mapping
+*     which can be used to transform a position in one TimeFrame into the
+*     corresponding position in the other. The Mapping is made up of the
+*     following steps in the indicated order:
+*
+*     - Map values from the system used by the target (MJD, JD, etc) to the
+*     system specified by the AlignSystem attribute.
+*
+*     - Map these values from the target's time scale to the time scale
+*     specified by the AlignTimeScale attribute.
+*
+*     - Map these values from the time scale specified by the AlignTimeScale
+*     attribute, to the template's time scale.
+*
+*     - Map these values from the system specified by the AlignSystem
+*     attribute, to the system used by the template.
+
+*  Applicability:
+*     TimeFrame
+*        All TimeFrames have this attribute.
+
+*att--
+*/
+astMAKE_TEST(TimeFrame,AlignTimeScale,( this->aligntimescale != AST__BADTS ))
+astMAKE_CLEAR(TimeFrame,AlignTimeScale,aligntimescale,AST__BADTS)
+astMAKE_SET(TimeFrame,AlignTimeScale,AstTimeScaleType,aligntimescale,(
+            ( ( value >= FIRST_TS ) && ( value <= LAST_TS ) ) ?
+                 value :
+                 ( astError( AST__ATTIN, "%s(%s): Bad value (%d) "
+                             "given for AlignTimeScale attribute.", status,
+                             "astSetAlignTimeScale", astGetClass( this ), (int) value ),
+
+/* Leave the value unchanged on error. */
+                                            this->aligntimescale ) ) )
+
+/*
+*att++
+*  Name:
+*     TimeScale
+
+*  Purpose:
+*     Time scale.
+
+*  Type:
+*     Public attribute.
+
+*  Synopsis:
+*     String.
+
+*  Description:
+*     This attribute identifies the time scale to which the time axis values
+*     of a TimeFrame refer, and may take any of the values listed in the
+*     "Time Scales" section (below).
+*
+*     The default TimeScale value depends on the current System value; if
+*     the current TimeFrame system is "Besselian epoch" the default is
+*     "TT", otherwise it is "TAI". Note, if the System attribute is set
+*     so that the TimeFrame represents Besselian Epoch, then an error
+*     will be reported if an attempt is made to set the TimeScale to
+*     anything other than TT.
+*
+*     Note, the supported time scales fall into two groups. The first group
+*     containing  UT1, GMST, LAST and LMST define time in terms of the
+*     orientation of the earth. The second group (containing all the remaining
+*     time scales) define time in terms of an atomic process. Since the rate of
+*     rotation of the earth varies in an unpredictable way, conversion between
+*     two timescales in different groups relies on a value being supplied for
+*     the Dut1 attribute (defined by the parent Frame class). This attribute
+*     specifies the difference between the UT1 and UTC time scales, in seconds,
+*     and defaults to zero. See the documentation for the Dut1 attribute for
+*     further details.
+
+*  Applicability:
+*     TimeFrame
+*        All TimeFrames have this attribute.
+
+*  Time Scales:
+*     The TimeFrame class supports the following TimeScale values (all are
+*     case-insensitive):
+*
+*     - "TAI" - International Atomic Time
+*     - "UTC" - Coordinated Universal Time
+*     - "UT1" - Universal Time
+*     - "GMST" - Greenwich Mean Sidereal Time
+*     - "LAST" - Local Apparent Sidereal Time
+*     - "LMST" - Local Mean Sidereal Time
+*     - "TT" - Terrestrial Time
+*     - "TDB" - Barycentric Dynamical Time
+*     - "TCB" - Barycentric Coordinate Time
+*     - "TCG" - Geocentric Coordinate Time
+*     - "LT" - Local Time (the offset from UTC is given by attribute LTOffset)
+*
+*     An very informative description of these and other time scales is
+*     available at http://www.ucolick.org/~sla/leapsecs/timescales.html.
+
+*  UTC Warnings:
+*     UTC should ideally be expressed using separate hours, minutes and
+*     seconds fields (or at least in seconds for a given date) if leap seconds
+*     are to be taken into account. Since the TimeFrame class represents
+*     each moment in time using a single floating point number (the axis value)
+*     there will be an ambiguity during a leap second. Thus an error of up to
+*     1 second can result when using AST to convert a UTC time to another
+*     time scale if the time occurs within a leap second. Leap seconds
+*     occur at most twice a year, and are introduced to take account of
+*     variation in the rotation of the earth. The most recent leap second
+*     occurred on 1st January 1999. Although in the vast majority of cases
+*     leap second ambiguities won't matter, there are potential problems in
+*     on-line data acquisition systems and in critical applications involving
+*     taking the difference between two times.
+
+*att--
+*/
+astMAKE_TEST(TimeFrame,TimeScale,( this->timescale != AST__BADTS ))
+
+/* Copy constructor. */
+/* ----------------- */
+
+/* Destructor. */
+/* ----------- */
+
+/* Dump function. */
+/* -------------- */
+static void Dump( AstObject *this_object, AstChannel *channel, int *status ) {
+/*
+*  Name:
+*     Dump
+
+*  Purpose:
+*     Dump function for TimeFrame 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 TimeFrame class to an output Channel.
+
+*  Parameters:
+*     this
+*        Pointer to the TimeFrame 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: */
+   AstTimeFrame *this;           /* Pointer to the TimeFrame structure */
+   AstTimeScaleType ts;          /* TimeScale attribute value */
+   const char *sval;             /* Pointer to string value */
+   double dval;                  /* Double value */
+   int set;                      /* Attribute value set? */
+
+/* Check the global error status. */
+   if ( !astOK ) return;
+
+/* Obtain a pointer to the TimeFrame structure. */
+   this = (AstTimeFrame *) this_object;
+
+/* Write out values representing the instance variables for the
+   TimeFrame 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. */
+
+/* TimeScale. */
+/* ---------- */
+   set = TestTimeScale( this, status );
+   ts = set ? GetTimeScale( this, status ) : astGetTimeScale( this );
+
+/* If set, convert explicitly to a string for the external
+   representation. */
+   sval = "";
+   if ( set ) {
+      if ( astOK ) {
+         sval = TimeScaleString( ts, status );
+
+/* Report an error if the TimeScale value was not recognised. */
+         if ( !sval ) {
+            astError( AST__SCSIN,
+                     "%s(%s): Corrupt %s contains invalid time scale "
+                     "identification code (%d).", status, "astWrite",
+                     astGetClass( channel ), astGetClass( this ), (int) ts );
+         }
+      }
+
+/* If not set, use astGetAttrib which returns a string value using
+   (possibly over-ridden) methods. */
+   } else {
+      sval = astGetAttrib( this_object, "timescale" );
+   }
+
+/* Write out the value. */
+   astWriteString( channel, "TmScl", set, 1, sval, "Time scale" );
+
+/* AlignTimeScale. */
+/* --------------- */
+   set = TestAlignTimeScale( this, status );
+   ts = set ? GetAlignTimeScale( this, status ) : astGetAlignTimeScale( this );
+
+/* If set, convert explicitly to a string for the external representation. */
+   if ( set ) {
+      if ( astOK ) {
+         sval = TimeScaleString( ts, status );
+
+/* Report an error if the TimeScale value was not recognised. */
+         if ( !sval ) {
+            astError( AST__SCSIN,
+                     "%s(%s): Corrupt %s contains invalid alignment time "
+                     "scale identification code (%d).", status, "astWrite",
+                     astGetClass( channel ), astGetClass( this ), (int) ts );
+         }
+      }
+
+/* If not set, use astGetAttrib which returns a string value using
+   (possibly over-ridden) methods. */
+   } else {
+      sval = astGetAttrib( this_object, "aligntimescale" );
+   }
+
+/* Write out the value. */
+   astWriteString( channel, "ATmScl", set, 0, sval, "Alignment time scale" );
+
+/* TimeOrigin. */
+/* ----------- */
+   set = TestTimeOrigin( this, status );
+   dval = set ? GetTimeOrigin( this, status ) : astGetTimeOrigin( this );
+   astWriteDouble( channel, "TmOrg", set, 0, dval, "Time offset" );
+
+/* LTOffset. */
+/* --------- */
+   set = TestLTOffset( this, status );
+   dval = set ? GetLTOffset( this, status ) : astGetLTOffset( this );
+   astWriteDouble( channel, "LTOff", set, 0, dval, "Local Time offset from UTC" );
+
+}
+
+/* Standard class functions. */
+/* ========================= */
+/* Implement the astIsATimeFrame and astCheckTimeFrame functions using the
+   macros defined for this purpose in the "object.h" header file. */
+astMAKE_ISA(TimeFrame,Frame)
+astMAKE_CHECK(TimeFrame)
+
+AstTimeFrame *astTimeFrame_( const char *options, int *status, ...) {
+/*
+*+
+*  Name:
+*     astTimeFrame
+
+*  Purpose:
+*     Create a TimeFrame.
+
+*  Type:
+*     Protected function.
+
+*  Synopsis:
+*     #include "timeframe.h"
+*     AstTimeFrame *astTimeFrame( const char *options, int *status, ... )
+
+*  Class Membership:
+*     TimeFrame constructor.
+
+*  Description:
+*     This function creates a new TimeFrame 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 TimeFrame. 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 TimeFrame.
+
+*  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.
+*-
+
+*  Implementation Notes:
+*     - This function implements the basic TimeFrame constructor which
+*     is available via the protected interface to the TimeFrame class.
+*     A public interface is provided by the astTimeFrameId_ function.
+*/
+
+/* Local Variables: */
+   astDECLARE_GLOBALS            /* Pointer to thread-specific global data */
+   AstMapping *um;               /* Mapping from default to actual units */
+   AstTimeFrame *new;            /* Pointer to new TimeFrame */
+   AstSystemType s;              /* System */
+   const char *u;                /* Units string */
+   va_list args;                 /* Variable argument list */
+
+/* Get a pointer to the thread specific global data structure. */
+   astGET_GLOBALS(NULL);
+
+/* Check the global status. */
+   if ( !astOK ) return NULL;
+
+/* Initialise the TimeFrame, allocating memory and initialising the virtual
+   function table as well if necessary. */
+   new = astInitTimeFrame( NULL, sizeof( AstTimeFrame ), !class_init,
+                           &class_vtab, "TimeFrame" );
+
+/* 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 TimeFrame's attributes. */
+      va_start( args, status );
+      astVSet( new, options, NULL, args );
+      va_end( args );
+
+/* Check the Units are appropriate for the System. */
+      u = astGetUnit( new, 0 );
+      s = astGetSystem( new );
+      um = astUnitMapper( DefUnit( s, "astTimeFrame", "TimeFrame", status ),
+                          u, NULL, NULL );
+      if( um ) {
+         um = astAnnul( um );
+      } else {
+         astError( AST__BADUN, "astTimeFrame: Inappropriate units (%s) "
+                   "specified for a %s axis.", status, u, SystemLabel( s, status ) );
+      }
+
+/* If an error occurred, clean up by deleting the new object. */
+      if ( !astOK ) new = astDelete( new );
+   }
+
+/* Return a pointer to the new TimeFrame. */
+   return new;
+}
+
+AstTimeFrame *astInitTimeFrame_( void *mem, size_t size, int init,
+                                 AstTimeFrameVtab *vtab, const char *name, int *status ) {
+/*
+*+
+*  Name:
+*     astInitTimeFrame
+
+*  Purpose:
+*     Initialise a TimeFrame.
+
+*  Type:
+*     Protected function.
+
+*  Synopsis:
+*     #include "timeframe.h"
+*     AstTimeFrame *astInitTimeFrame( void *mem, size_t size, int init,
+*                                     AstFrameVtab *vtab, const char *name )
+
+*  Class Membership:
+*     TimeFrame initialiser.
+
+*  Description:
+*     This function is provided for use by class implementations to
+*     initialise a new TimeFrame object. It allocates memory (if
+*     necessary) to accommodate the TimeFrame plus any additional data
+*     associated with the derived class. It then initialises a
+*     TimeFrame structure at the start of this memory. If the "init"
+*     flag is set, it also initialises the contents of a virtual function
+*     table for a TimeFrame at the start of the memory passed via the
+*     "vtab" parameter.
+
+*  Parameters:
+*     mem
+*        A pointer to the memory in which the TimeFrame is to be
+*	created. This must be of sufficient size to accommodate the
+*	TimeFrame data (sizeof(TimeFrame)) 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 TimeFrame (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 TimeFrame structure, so a valid value must be supplied
+*	even if not required for allocating memory.
+*     init
+*        A logical flag indicating if the TimeFrame'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 TimeFrame.
+*     name
+*        Pointer to a constant null-terminated character string which
+*	contains the name of the class to which the new object belongs
+*	(it is this pointer value that will subsequently be returned by
+*	the astGetClass method).
+
+*  Returned Value:
+*     A pointer to the new TimeFrame.
+
+*  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: */
+   AstTimeFrame *new;        /* Pointer to the new TimeFrame */
+
+/* Check the global status. */
+   if ( !astOK ) return NULL;
+
+/* If necessary, initialise the virtual function table. */
+   if ( init ) astInitTimeFrameVtab( vtab, name );
+
+/* Initialise a 1D Frame structure (the parent class) as the first component
+   within the TimeFrame structure, allocating memory if necessary. */
+   new = (AstTimeFrame *) astInitFrame( mem, size, 0,
+                                        (AstFrameVtab *) vtab, name, 1 );
+
+   if ( astOK ) {
+
+/* Initialise the TimeFrame data. */
+/* ----------------------------- */
+/* Initialise all attributes to their "undefined" values. */
+      new->timeorigin = AST__BAD;
+      new->ltoffset = AST__BAD;
+      new->timescale = AST__BADTS;
+      new->aligntimescale = AST__BADTS;
+
+/* If an error occurred, clean up by deleting the new object. */
+      if ( !astOK ) new = astDelete( new );
+
+   }
+
+/* Return a pointer to the new object. */
+   return new;
+}
+
+AstTimeFrame *astLoadTimeFrame_( void *mem, size_t size,
+                                 AstTimeFrameVtab *vtab,
+                                 const char *name, AstChannel *channel, int *status ) {
+/*
+*+
+*  Name:
+*     astLoadTimeFrame
+
+*  Purpose:
+*     Load a TimeFrame.
+
+*  Type:
+*     Protected function.
+
+*  Synopsis:
+*     #include "timeframe.h"
+*     AstTimeFrame *astLoadTimeFrame( void *mem, size_t size,
+*                                      AstTimeFrameVtab *vtab,
+*                                      const char *name, AstChannel *channel )
+
+*  Class Membership:
+*     TimeFrame loader.
+
+*  Description:
+*     This function is provided to load a new TimeFrame 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
+*     TimeFrame structure in this memory, using data read from the
+*     input Channel.
+
+*  Parameters:
+*     mem
+*        A pointer to the memory into which the TimeFrame is to be
+*        loaded.  This must be of sufficient size to accommodate the
+*        TimeFrame data (sizeof(TimeFrame)) 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 TimeFrame (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 TimeFrame 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(AstTimeFrame) is used instead.
+*     vtab
+*        Pointer to the start of the virtual function table to be
+*        associated with the new TimeFrame. If this is NULL, a pointer
+*        to the (static) virtual function table for the TimeFrame 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 "TimeFrame" is used instead.
+
+*  Returned Value:
+*     A pointer to the new TimeFrame.
+
+*  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 */
+   AstTimeFrame *new;            /* Pointer to the new TimeFrame */
+   char *sval;                   /* Pointer to string value */
+   double obslat;                /* Value for ObsLat attribute */
+   double obslon;                /* Value for ObsLon attribute */
+
+/* Get a pointer to the thread specific global data structure. */
+   astGET_GLOBALS(channel);
+
+/* Initialise. */
+   new = NULL;
+
+/* Check the global error status. */
+   if ( !astOK ) return new;
+
+/* If a NULL virtual function table has been supplied, then this is
+   the first loader to be invoked for this TimeFrame. In this case the
+   TimeFrame belongs to this class, so supply appropriate values to be
+   passed to the parent class loader (and its parent, etc.). */
+   if ( !vtab ) {
+      size = sizeof( AstTimeFrame );
+      vtab = &class_vtab;
+      name = "TimeFrame";
+
+/* If required, initialise the virtual function table for this class. */
+      if ( !class_init ) {
+         astInitTimeFrameVtab( 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 TimeFrame. */
+   new = astLoadFrame( mem, size, (AstFrameVtab *) 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, "TimeFrame" );
+
+/* 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. */
+
+/* TimeScale. */
+/* ---------- */
+/* Set the default and read the external representation as a string. */
+       new->timescale = AST__BADTS;
+       sval = astReadString( channel, "tmscl", NULL );
+
+/* If a value was read, convert from a string to a TimeScale code. */
+       if ( sval ) {
+          if ( astOK ) {
+             new->timescale = TimeScaleCode( sval, status );
+
+/* Report an error if the value wasn't recognised. */
+             if ( new->timescale == AST__BADTS ) {
+                astError( AST__ATTIN,
+                          "astRead(%s): Invalid time scale description "
+                          "\"%s\".", status, astGetClass( channel ), sval );
+             }
+          }
+
+/* Free the string value. */
+          sval = astFree( sval );
+       }
+
+/* AlignTimeScale. */
+/* --------------- */
+/* Set the default and read the external representation as a string. */
+       new->aligntimescale = AST__BADTS;
+       sval = astReadString( channel, "atmscl", NULL );
+
+/* If a value was read, convert from a string to a TimeScale code. */
+       if ( sval ) {
+          if ( astOK ) {
+             new->aligntimescale = TimeScaleCode( sval, status );
+
+/* Report an error if the value wasn't recognised. */
+             if ( new->aligntimescale == AST__BADTS ) {
+                astError( AST__ATTIN,
+                          "astRead(%s): Invalid alignment time scale "
+                          "description \"%s\".", status, astGetClass( channel ), sval );
+             }
+          }
+
+/* Free the string value. */
+          sval = astFree( sval );
+       }
+
+/* ClockLat. */
+/* --------- */
+/* Retained for backward compatibility with older versions of AST in
+   which TimeFrame had a ClockLat attribute (now ObsLat is used instead). */
+      if( !astTestObsLat( new ) ) {
+         obslat = astReadDouble( channel, "cllat", AST__BAD );
+         if ( obslat != AST__BAD ) astSetObsLat( new, obslat );
+      }
+
+/* ClockLon. */
+/* ------- */
+/* Retained for backward compatibility with older versions of AST in
+   which TimeFrame had a ClockLon attribute (now ObsLon is used instead). */
+      if( !astTestObsLon( new ) ) {
+         obslon = astReadDouble( channel, "cllon", AST__BAD );
+         if ( obslon != AST__BAD ) astSetObsLon( new, obslon );
+      }
+
+/* TimeOrigin. */
+/* --------- */
+      new->timeorigin = astReadDouble( channel, "tmorg", AST__BAD );
+      if ( TestTimeOrigin( new, status ) ) SetTimeOrigin( new, new->timeorigin, status );
+
+/* LTOffset. */
+/* --------- */
+      new->ltoffset = astReadDouble( channel, "ltoff", AST__BAD );
+      if ( TestLTOffset( new, status ) ) SetLTOffset( new, new->ltoffset, status );
+
+/* If an error occurred, clean up by deleting the new TimeFrame. */
+      if ( !astOK ) new = astDelete( new );
+   }
+
+/* Return the new TimeFrame pointer. */
+   return new;
+}
+
+/* Virtual function interfaces. */
+/* ============================ */
+/* These provide the external interface to the virtual functions defined by
+   this class. Each simply checks the global error status and then locates and
+   executes the appropriate member function, using the function pointer stored
+   in the object's virtual function table (this pointer is located using the
+   astMEMBER macro defined in "object.h").
+
+   Note that the member function may not be the one defined here, as it may
+   have been over-ridden by a derived class. However, it should still have the
+   same interface. */
+
+void astSetTimeScale_( AstTimeFrame *this, AstTimeScaleType value, int *status ){
+   if ( !astOK ) return;
+   (**astMEMBER(this,TimeFrame,SetTimeScale))(this,value, status );
+}
+
+void astClearTimeScale_( AstTimeFrame *this, int *status ){
+   if ( !astOK ) return;
+   (**astMEMBER(this,TimeFrame,ClearTimeScale))(this, status );
+}
+
+AstTimeScaleType astGetAlignTimeScale_( AstTimeFrame *this, int *status ) {
+   if ( !astOK ) return AST__BADTS;
+   return (**astMEMBER(this,TimeFrame,GetAlignTimeScale))(this, status );
+}
+
+AstTimeScaleType astGetTimeScale_( AstTimeFrame *this, int *status ) {
+   if ( !astOK ) return AST__BADTS;
+   return (**astMEMBER(this,TimeFrame,GetTimeScale))(this, status );
+}
+
+double astCurrentTime_( AstTimeFrame *this, int *status ){
+   if ( !astOK ) return AST__BAD;
+   return (**astMEMBER(this,TimeFrame,CurrentTime))(this, status );
+}
+
+
+
+/* Special public interface functions. */
+/* =================================== */
+/* These provide the public interface to certain special functions
+   whose public interface cannot be handled using macros (such as
+   astINVOKE) alone. In general, they are named after the
+   corresponding protected version of the function, but with "Id"
+   appended to the name. */
+
+/* Public 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. */
+AstTimeFrame *astTimeFrameId_( const char *, ... );
+
+/* Special interface function implementations. */
+/* ------------------------------------------- */
+AstTimeFrame *astTimeFrameId_( const char *options, ... ) {
+/*
+*++
+*  Name:
+c     astTimeFrame
+f     AST_TIMEFRAME
+
+*  Purpose:
+*     Create a TimeFrame.
+
+*  Type:
+*     Public function.
+
+*  Synopsis:
+c     #include "timeframe.h"
+c     AstTimeFrame *astTimeFrame( const char *options, ... )
+f     RESULT = AST_TIMEFRAME( OPTIONS, STATUS )
+
+*  Class Membership:
+*     TimeFrame constructor.
+
+*  Description:
+*     This function creates a new TimeFrame and optionally initialises
+*     its attributes.
+*
+*     A TimeFrame is a specialised form of one-dimensional Frame which
+*     represents various coordinate systems used to describe positions in
+*     time.
+*
+*     A TimeFrame represents a moment in time as either an Modified Julian
+*     Date (MJD), a Julian Date (JD), a Besselian epoch or a Julian epoch,
+*     as determined by the System attribute. Optionally, a zero point can be
+*     specified (using attribute TimeOrigin) which results in the TimeFrame
+*     representing time offsets from the specified zero point.
+*
+*     Even though JD and MJD are defined as being in units of days, the
+*     TimeFrame class allows other units to be used (via the Unit attribute)
+*     on the basis of simple scalings (60 seconds = 1 minute, 60 minutes = 1
+*     hour, 24 hours = 1 day, 365.25 days = 1 year). Likewise, Julian epochs
+*     can be described in units other than the usual years. Besselian epoch
+*     are always represented in units of (tropical) years.
+*
+*     The TimeScale attribute allows the time scale to be specified (that
+*     is, the physical proces used to define the rate of flow of time).
+*     MJD, JD and Julian epoch can be used to represent a time in any
+*     supported time scale. However, Besselian epoch may only be used with the
+*     "TT" (Terrestrial Time) time scale. The list of supported time scales
+*     includes universal time and siderial time. Strictly, these represent
+*     angles rather than time scales, but are included in the list since
+*     they are in common use and are often thought of as time scales.
+*
+*     When a time value is formatted it can be formated either as a simple
+*     floating point value, or as a Gregorian date (see the Format
+*     attribute).
+
+*  Parameters:
+c     options
+f     OPTIONS = CHARACTER * ( * ) (Given)
+c        Pointer to a null-terminated string containing an optional
+c        comma-separated list of attribute assignments to be used for
+c        initialising the new TimeFrame. The syntax used is identical to
+c        that for the astSet function and may include "printf" format
+c        specifiers identified by "%" symbols in the normal way.
+c        If no initialisation is required, a zero-length string may be
+c        supplied.
+f        A character string containing an optional comma-separated
+f        list of attribute assignments to be used for initialising the
+f        new TimeFrame. The syntax used is identical to that for the
+f        AST_SET routine. If no initialisation is required, a blank
+f        value may be supplied.
+c     ...
+c        If the "options" string contains "%" format specifiers, then
+c        an optional list of additional arguments may follow it in
+c        order to supply values to be substituted for these
+c        specifiers. The rules for supplying these are identical to
+c        those for the astSet function (and for the C "printf"
+c        function).
+f     STATUS = INTEGER (Given and Returned)
+f        The global status.
+
+*  Returned Value:
+c     astTimeFrame()
+f     AST_TIMEFRAME = INTEGER
+*        A pointer to the new TimeFrame.
+
+*  Notes:
+*     - When conversion between two TimeFrames is requested (as when
+c     supplying TimeFrames to astConvert),
+f     supplying TimeFrames AST_CONVERT),
+*     account will be taken of the nature of the time coordinate systems
+*     they represent, together with any qualifying time scale, offset,
+*     unit, etc. The AlignSystem and AlignTimeScale attributes will also be
+*     taken into account.
+*     - A null Object pointer (AST__NULL) will be returned if this
+c     function is invoked with the AST error status set, or if it
+f     function is invoked with STATUS set to an error value, or if it
+*     should fail for any reason.
+*--
+
+*  Implementation Notes:
+*     - This function implements the external (public) interface to
+*     the astTimeFrame constructor function. It returns an ID value
+*     (instead of a true C pointer) to external users, and must be
+*     provided because astTimeFrame_ 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 astTimeFrame_ 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.
+*/
+
+/* Local Variables: */
+   astDECLARE_GLOBALS            /* Pointer to thread-specific global data */
+   AstMapping *um;               /* Mapping from default to actual units */
+   AstTimeFrame *new;            /* Pointer to new TimeFrame */
+   AstSystemType s;              /* System */
+   const char *u;                /* Units string */
+   va_list args;                 /* Variable argument list */
+
+   int *status;                  /* Pointer to inherited status value */
+
+/* Get a pointer to the thread specific global data structure. */
+   astGET_GLOBALS(NULL);
+
+/* Get a pointer to the inherited status value. */
+   status = astGetStatusPtr;
+
+/* Check the global status. */
+   if ( !astOK ) return NULL;
+
+/* Initialise the TimeFrame, allocating memory and initialising the virtual
+   function table as well if necessary. */
+   new = astInitTimeFrame( NULL, sizeof( AstTimeFrame ), !class_init,
+                           &class_vtab, "TimeFrame" );
+
+/* 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 TimeFrame's attributes. */
+      va_start( args, options );
+      astVSet( new, options, NULL, args );
+      va_end( args );
+
+/* Check the Units are appropriate for the System. */
+      u = astGetUnit( new, 0 );
+      s = astGetSystem( new );
+      um = astUnitMapper( DefUnit( s, "astTimeFrame", "TimeFrame", status ),
+                          u, NULL, NULL );
+      if( um ) {
+         um = astAnnul( um );
+      } else {
+         astError( AST__BADUN, "astTimeFrame: Inappropriate units (%s) "
+                   "specified for a %s axis.", status, u, SystemLabel( s, status ) );
+      }
+
+/* If an error occurred, clean up by deleting the new object. */
+      if ( !astOK ) new = astDelete( new );
+   }
+
+/* Return an ID value for the new TimeFrame. */
+   return astMakeId( new );
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+