upgrade ast 8.7.1

1 files changed, 12592 insertions, 0 deletions

diff --git a/ast/skyframe.c b/ast/skyframe.c
new file mode 100644
index 0000000..1c20839
--- /dev/null
+++ b/ast/skyframe.c
@@ -0,0 +1,12592 @@
+/*
+*class++
+*  Name:
+*     SkyFrame
+
+*  Purpose:
+*     Celestial coordinate system description.
+
+*  Constructor Function:
+c     astSkyFrame
+f     AST_SKYFRAME
+
+*  Description:
+*     A SkyFrame is a specialised form of Frame which describes
+*     celestial longitude/latitude coordinate systems. The particular
+*     celestial coordinate system to be represented is specified by
+*     setting the SkyFrame's System attribute (currently, the default
+*     is ICRS) qualified, as necessary, by a mean Equinox value and/or
+*     an Epoch.
+*
+*     For each of the supported celestial coordinate systems, a SkyFrame
+*     can apply an optional shift of origin to create a coordinate system
+*     representing offsets within the celestial coordinate system from some
+*     specified reference point. This offset coordinate system can also be
+*     rotated to define new longitude and latitude axes. See attributes
+*     SkyRef, SkyRefIs, SkyRefP and AlignOffset.
+*
+*     All the coordinate values used by a SkyFrame are in
+*     radians. These may be formatted in more conventional ways for
+c     display by using astFormat.
+f     display by using AST_FORMAT.
+*     For a SkyFrame, the Unit attribute describes the formatted value of
+*     a SkyFrame axis, and may for instance be "h:m:s", indicating that a
+*     formatted axis value contains colon-separated fields for hours, minutes
+*     and seconds. On the other hand, the InternalUnit attribute for a
+*     SkyFrame is always set to "rad" (i.e. radians), indicating that the
+*     unformatted (i.e. floating point) axis values used by application code
+*     are always in units of radians
+
+*  Inheritance:
+*     The SkyFrame class inherits from the Frame class.
+
+*  Attributes:
+*     In addition to those attributes common to all Frames, every
+*     SkyFrame also has the following attributes:
+*
+*     - AlignOffset: Align SkyFrames using the offset coordinate system?
+*     - AsTime(axis): Format celestial coordinates as times?
+*     - Equinox: Epoch of the mean equinox
+*     - IsLatAxis: Is the specified axis the latitude axis?
+*     - IsLonAxis: Is the specified axis the longitude axis?
+*     - LatAxis: Index of the latitude axis
+*     - LonAxis: Index of the longitude axis
+*     - NegLon: Display longitude values in the range [-pi,pi]?
+*     - Projection: Sky projection description.
+*     - SkyRef: Position defining location of the offset coordinate system
+*     - SkyRefIs: Selects the nature of the offset coordinate system
+*     - SkyRefP: Position defining orientation of the offset coordinate system
+*     - SkyTol: Smallest significant shift in sky coordinates
+
+*  Functions:
+*     In addition to those
+c     functions
+f     routines
+*     applicable to all Frames, the following
+c     functions
+f     routines
+*     may also be applied to all SkyFrames:
+*
+c     - astSkyOffsetMap: Obtain a Mapping from absolute to offset coordinates
+f     - AST_SKYOFFSETMAP: Obtain a Mapping from absolute to offset coordinates
+
+*  Copyright:
+*     Copyright (C) 1997-2006 Council for the Central Laboratory of the
+*     Research Councils
+*     Copyright (C) 2010 Science & Technology Facilities Council.
+*     All Rights Reserved.
+
+*  Licence:
+*     This program is free software: you can redistribute it and/or
+*     modify it under the terms of the GNU Lesser General Public
+*     License as published by the Free Software Foundation, either
+*     version 3 of the License, or (at your option) any later
+*     version.
+*
+*     This program is distributed in the hope that it will be useful,
+*     but WITHOUT ANY WARRANTY; without even the implied warranty of
+*     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+*     GNU Lesser General Public License for more details.
+*
+*     You should have received a copy of the GNU Lesser General
+*     License along with this program.  If not, see
+*     <http://www.gnu.org/licenses/>.
+
+*  Authors:
+*     RFWS: R.F. Warren-Smith (Starlink)
+*     DSB: David S. Berry (Starlink)
+*     BEC: Brad Cavanagh (JAC, Hawaii)
+
+*  History:
+*     4-MAR-1996 (RFWS):
+*        Original version.
+*     17-MAY-1996 (RFWS):
+*        Tidied up, etc.
+*     31-JUL-1996 (RFWS):
+*        Added support for attributes and a public interface.
+*     11-SEP-1996 (RFWS):
+*        Added Gap (written by DSB).
+*     24-SEP-1996 (RFWS):
+*        Added I/O facilities.
+*     27-FEB-1997 (RFWS):
+*        Improved the public prologues.
+*     27-MAY-1997 (RFWS):
+*        Modified to use a new public interface to the SlaMap class
+*        and to use the astSimplify method to remove redundant
+*        conversions.
+*     16-JUN-1997 (RFWS):
+*        Fixed bug in axis associations returned by astMatch if axes
+*        were swapped.
+*     16-JUL-1997 (RFWS):
+*        Added Projection attribute.
+*     14-NOV-1997 (RFWS):
+*        Corrected the omission of axis permutations from astNorm.
+*     21-JAN-1998 (RFWS):
+*        Ensure that Title and Domain values appropriate to a SkyFrame
+*        are preserved if a Frame result is generated by SubFrame.
+*     26-FEB-1998 (RFWS):
+*        Over-ride the astUnformat method.
+*     3-APR-2001 (DSB):
+*        Added "Unknown" option for the System attribute. Added read-only
+*        attributes LatAxis and LonAxis.
+*     21-JUN-2001 (DSB):
+*        Added astAngle and astOffset2.
+*     4-SEP-2001 (DSB):
+*        Added NegLon attribute, and astResolve method.
+*     9-SEP-2001 (DSB):
+*        Added astBear method.
+*     21-SEP-2001 (DSB):
+*        Removed astBear method.
+*     10-OCT-2002 (DSB):
+*        Moved definitions of macros for SkyFrame system values from
+*        this file into skyframe.h.
+*     24-OCT-2002 (DSB):
+*        Modified MakeSkyMapping so that any two SkyFrames with system=unknown
+*        are assumed to be related by a UnitMap. previously, they were
+*        considered to be unrelated, resulting in no ability to convert from
+*        one to the other. This could result for instance in astConvert
+*        being unable to find a maping from a SkyFrame to itself.
+*     15-NOV-2002 (DSB):
+*        Moved System and Epoch attributes to the Frame class.
+*     8-JAN-2003 (DSB):
+*        Changed private InitVtab method to protected astInitSkyFrameVtab
+*        method.
+*     11-JUN-2003 (DSB):
+*        Added ICRS option for System attribute, and made it the default
+*        in place of FK5.
+*     27-SEP-2003 (DSB):
+*        Added HELIOECLIPTIC option for System attribute.
+*     19-APR-2004 (DSB):
+*        Added SkyRef, SkyRefIs, SkyRefP and AlignOffset attributes.
+*     8-SEP-2004 (DSB):
+*        Added astResolvePoints method.
+*     2-DEC-2004 (DSB):
+*        Added System "J2000"
+*     27-JAN-2005 (DSB):
+*        Fix memory leaks in astLoadSkyFrame_ and Match.
+*     7-APR-2005 (DSB):
+*        Allow SkyRefIs to be set to "Ignored".
+*     12-MAY-2005 (DSB):
+*        Override astNormBox method.
+*     15-AUG-2005 (DSB):
+*        Added AZEL system.
+*     13-SEP-2005 (DSB):
+*        Override astClearSystem so that SkyRef/SkyRefPcan be converted
+*        from the original System to the default System.
+*     19-SEP-2005 (DSB):
+*        Changed default for SkyRefIs from ORIGIN to IGNORED.
+*     14-FEB-2006 (DSB):
+*        Override astGetObjSize.
+*     22-FEB-2006 (DSB):
+*        Store the Local Apparent Sidereal Time in the SkyFrame structure
+*        in order to avoid expensive re-computations.
+*     22-AUG-2006 (DSB):
+*        Ensure the cached Local Apparent Siderial Time is initialised
+*        when initialising or loading a SkyFrame.
+*     22-SEP-2006 (DSB):
+*        Report an error in SetSystem if it is not possible to convert
+*        from old to new systems.
+*     3-OCT-2006 (DSB):
+*        Added Equation of Equinoxes to the SkyFrame structure.
+*     6-OCT-2006 (DSB):
+*        - Guard against annulling null pointers in subFrame.
+*        - Add Dut1 attribute
+*        - Use linear approximation for LAST over short periods (less
+*          than 0.001 of a day)
+*        - Remove Equation of Equinoxes from the SkyFrame structure.
+*     10-OCT-2006 (DSB):
+*        Use "AlOff" instead of "AlignOffset" as the external channel name
+*        for the AlignOffset attribute. The longer form exceeded the
+*        limit that can be used by the Channel class.
+*     14-OCT-2006 (DSB):
+*        - Move Dut1 attribute to the Frame class.
+*        - Use the TimeFrame class to do the TDB->LAST conversions.
+*     17-JAN-2007 (DSB):
+*        - Use a UnitMap to align offset coordinate systems in two
+*        SkyFrames, regardless of other attribute values.
+*        - Only align in offset coordinates if both target and template
+*        have a non-zero value for AlignOffset.
+*     23-JAN-2007 (DSB):
+*        Modified so that a SkyFrame can be used as a template to find a
+*        SkyFrame contained within a CmpFrame. This involves changes in
+*        Match and the removal of the local versions of SetMaxAxes and
+*        SetMinAxes.
+*     4-JUL-2007 (DSB):
+*        Modified GetLast to use the correct solar to sidereal conversion
+*        factor. As a consequence the largest acceptable epoch gap before
+*        the LAST needs to be recalculated has been increased.
+*     11-JUL-2007 (DSB):
+*        Override astSetEpoch and astClearEpoch by implementations which
+*        update the LAST value stored in the SkyFrame.
+*     7-AUG-2007 (DSB):
+*        - Set a value for the CentreZero attribute when extracting a
+*        SkyAxis from a SkyFrame in function SubFrame.
+*        - In SubFrame, clear extended attributes such as System after
+*        all axis attributes have been "fixated.
+*     30-AUG-2007 (DSB):
+*        Override astSetDut1 and astClearDut1 by implementations which
+*        update the LAST value stored in the SkyFrame.
+*     31-AUG-2007 (DSB):
+*        - Cache the magnitude of the diurnal aberration vector in the
+*        SkyFrame structure for use when correcting for diurnal aberration.
+*        - Modify the azel conversions to include correction for diurnal
+*        aberration.
+*        - Override astClearObsLat and astSetObsLat by implementations which
+*        reset the magnitude of the diurnal aberration vector.
+*     3-SEP-2007 (DSB):
+*        In SubFrame, since AlignSystem is extended by the SkyFrame class
+*        it needs to be cleared before invoking the parent SubFrame
+*        method in cases where the result Frame is not a SkyFrame.
+*     2-OCT-2007 (DSB):
+*        In Overlay, clear AlignSystem as well as System before calling
+*        the parent overlay method.
+*     10-OCT-2007 (DSB):
+*        In MakeSkyMapping, correct the usage of variables "system" and
+*        "align_sys" when aligning in AZEL.
+*     18-OCT-2007 (DSB):
+*        Compare target and template AlignSystem values in Match, rather
+*        than comparing target and result AlignSystem values in MakeSkyMapping
+*        (since result is basically a copy of target).
+*     27-NOV-2007 (DSB):
+*        - Modify SetSystem to ensure that SkyRef and SkyRefP position are
+*        always transformed as absolute values, rather than as offset
+*        values.
+*        - Modify SubMatch so that a value of zero is assumed for
+*        AlignOffset when restoring thre integrity of a FrameSet.
+*     15-DEC-2008 (DSB):
+*        Improve calculation of approximate Local Apparent Sidereal time
+*        by finding and using the ratio of solar to sidereal time
+*        independently for each approximation period.
+*     14-JAN-2009 (DSB):
+*        Override the astIntersect method.
+*     21-JAN-2009 (DSB):
+*        Fix mis-use of results buffers for GetFormat and GetAttrib.
+*     16-JUN-2009 (DSB):
+*        All sky coordinate systems currently supported by SkyFrame are
+*        left handed. So fix GetDirection method to return zero for all
+*        longitude axes and 1 for all latitude axes.
+*     18-JUN-2009 (DSB):
+*        Incorporate the new ObsAlt attribute.
+*     23-SEP-2009 (DSB):
+*        Allow some rounding error when checking for changes in SetObsLon
+*        and SetDut1. This reduces the number of times the expensive
+*        calculation of LAST is performed.
+*     24-SEP-2009 (DSB);
+*        Create a static cache of LAST values stored in the class virtual
+*        function table. These are used in preference to calculating a new
+*        value from scratch.
+*     25-SEP-2009 (DSB);
+*        Do not calculate LAST until it is needed.
+*     12-OCT-2009 (DSB);
+*        - Handle 2.PI->0 discontinuity in cached LAST values.
+*     12-OCT-2009 (BEC);
+*        - Fix bug in caching LAST value.
+*     31-OCT-2009 (DSB);
+*        Correct SetCachedLAST to handle cases where the epoch to be
+*        stored is smaller than any epoch already in the table.
+*     24-NOV-2009 (DSB):
+*        - In CalcLast, only use end values form the table of stored
+*        LAST values if the corresponding epochs are within 0.001 of
+*        a second of the required epoch (this tolerance used to be
+*        0.1 seconds).
+*        - Do not clear the cached LAST value in SetEpoch and ClearEpoch.
+*     8-MAR-2010 (DSB):
+*        Add astSkyOffsetMap method.
+*     7-APR-2010 (DSB):
+*        Add IsLatAxis and IsLonAxis attributes.
+*     11-MAY-2010 (DSB):
+*        In SetSystem, clear SkyRefP as well as SkyRef.
+*     22-MAR-2011 (DSB):
+*        Override astFrameGrid method.
+*     29-APR-2011 (DSB):
+*        Prevent astFindFrame from matching a subclass template against a
+*        superclass target.
+*     23-MAY-2011 (DSB):
+*        Truncate returned PointSet in function FrameGrid to exclude unused points.
+*     24-MAY-2011 (DSB):
+*        When clearing or setting the System attribute, clear SkyRef rather
+*        than reporting an error if the Mapping from the old System to the
+*        new System is unknown.
+*     30-NOV-2011 (DSB):
+*        When aligning two SkyFrames in the system specified by AlignSystem,
+*        do not assume inappropriate default equinox values for systems
+*        that are not referred to the equinox specified by the Equinox attribute.
+*     26-APR-2012 (DSB):
+*        - Correct Dump function so that any axis permutation is taken into
+*        account when dumping SkyFrame attributes that have a separate value
+*        for each axis (e.g. SkyRef and SkyRefP).
+*        - Take axis permutation into account when setting a new value
+*        for attributes that have a separate value for each axis (e.g.
+*        SkyRef and SkyRefP).
+*        - Remove the code that overrides ClearEpoch and SetEpoch (these
+*        overrides have not been needed since the changes made on
+*        24/11/2009).
+*     27-APR-2012 (DSB):
+*        - Correct astLoadSkyFrame function so that any axis permutation is
+*        taken into account when loading SkyFrame attributes that have a
+*        separate value for each axis.
+*     25-JUL-2013 (DSB):
+*        Use a single table of cached LAST values for all threads, rather
+*        than a separate table for each thread. The problem with a table per
+*        thread  is that if you have N threads, each table contains only
+*        one N'th of the total number of cached values, resulting in
+*        poorer accuracy, and small variations in interpolated LAST value
+*        depending on the way the cached values are distributed amongst the
+*        N threads.
+*     6-AST-2013 (DSB):
+*        Fix the use of the read-write lock that is used to serialise
+*        access to the table of cached LAST values. This bug could
+*        cause occasional problems where an AST pointer would became
+*        invalid for no apparent reason.
+*     21-FEB-2014 (DSB):
+*        Rounding errors in the SkyLineDef constructor could result in the line
+*        between coincident points being given a non-zero length.
+*     6-JUL-2015 (DSB):
+*        Added SkyTol attribute.
+*     3-FEB-2017 (GSB):
+*        Override astSetDtai and astClearDtai.
+*     6-APR-2017 (GSB):
+*        Added dtai to AstSkyLastTable.
+*     10-APR-2017 (GSB):
+*        Added macro to test floating point equality and used it for Dtai.
+*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 SkyFrame
+
+/* Define the first and last acceptable System values. */
+#define FIRST_SYSTEM AST__FK4
+#define LAST_SYSTEM AST__AZEL
+
+/* Speed of light (AU per day) (from SLA_AOPPA) */
+#define C 173.14463331
+
+/* Ratio between solar and sidereal time (from SLA_AOPPA) */
+#define SOLSID 1.00273790935
+
+/* Define values for the different values of the SkyRefIs attribute. */
+#define POLE_STRING "Pole"
+#define ORIGIN_STRING "Origin"
+#define IGNORED_STRING "Ignored"
+
+/* Define other numerical constants for use in this module. */
+#define GETATTRIB_BUFF_LEN 200
+#define GETFORMAT_BUFF_LEN 50
+#define GETLABEL_BUFF_LEN 40
+#define GETSYMBOL_BUFF_LEN 20
+#define GETTITLE_BUFF_LEN 200
+
+/* A macro which returns a flag indicating if the supplied system is
+   references to the equinox specified by the Equinox attribute. */
+#define EQREF(system) \
+((system==AST__FK4||system==AST__FK4_NO_E||system==AST__FK5||system==AST__ECLIPTIC)?1: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))))
+
+/*
+*
+*  Name:
+*     MAKE_CLEAR
+
+*  Purpose:
+*     Implement a method to clear a single value in a multi-valued attribute.
+
+*  Type:
+*     Private macro.
+
+*  Synopsis:
+*     #include "skyframe.h"
+*     MAKE_CLEAR(attr,component,assign,nval)
+
+*  Class Membership:
+*     Defined by the SkyFrame class.
+
+*  Description:
+*     This macro expands to an implementation of a private member function of
+*     the form:
+*
+*        static void Clear<Attribute>( AstSkyFrame *this, int axis )
+*
+*     and an external interface function of the form:
+*
+*        void astClear<Attribute>_( AstSkyFrame *this, int axis )
+*
+*     which implement a method for clearing a single value in a specified
+*     multi-valued attribute for an axis of a SkyFrame.
+
+*  Parameters:
+*     attr
+*        The name of the attribute to be cleared, as it appears in the function
+*        name (e.g. Label in "astClearLabelAt").
+*     component
+*        The name of the class structure component that holds the attribute
+*        value.
+*     assign
+*        An expression that evaluates to the value to assign to the component
+*        to clear its value.
+*     nval
+*        Specifies the number of values in the multi-valued attribute. The
+*        "axis" values supplied to the created function should be in the
+*        range zero to (nval - 1).
+
+*  Notes:
+*     -  To avoid problems with some compilers, you should not leave any white
+*     space around the macro arguments.
+*
+*/
+
+/* Define the macro. */
+#define MAKE_CLEAR(attr,component,assign,nval) \
+\
+/* Private member function. */ \
+/* ------------------------ */ \
+static void Clear##attr( AstSkyFrame *this, int axis, int *status ) { \
+\
+   int axis_p; \
+\
+/* Check the global error status. */ \
+   if ( !astOK ) return; \
+\
+/* Validate and permute the axis index. */ \
+   axis_p = astValidateAxis( this, axis, 1, "astClear" #attr ); \
+\
+/* Assign the "clear" value. */ \
+   if( astOK ) { \
+      this->component[ axis_p ] = (assign); \
+   } \
+} \
+\
+/* External interface. */ \
+/* ------------------- */ \
+void astClear##attr##_( AstSkyFrame *this, int axis, int *status ) { \
+\
+/* Check the global error status. */ \
+   if ( !astOK ) return; \
+\
+/* Invoke the required method via the virtual function table. */ \
+   (**astMEMBER(this,SkyFrame,Clear##attr))( this, axis, status ); \
+}
+
+
+/*
+*
+*  Name:
+*     MAKE_GET
+
+*  Purpose:
+*     Implement a method to get a single value in a multi-valued attribute.
+
+*  Type:
+*     Private macro.
+
+*  Synopsis:
+*     #include "skyframe.h"
+*     MAKE_GET(attr,type,bad_value,assign,nval)
+
+*  Class Membership:
+*     Defined by the SkyFrame class.
+
+*  Description:
+*     This macro expands to an implementation of a private member function of
+*     the form:
+*
+*        static <Type> Get<Attribute>( AstSkyFrame *this, int axis )
+*
+*     and an external interface function of the form:
+*
+*        <Type> astGet<Attribute>_( AstSkyFrame *this, int axis )
+*
+*     which implement a method for getting a single value from a specified
+*     multi-valued attribute for an axis of a SkyFrame.
+
+*  Parameters:
+*     attr
+*        The name of the attribute whose value is to be obtained, as it
+*        appears in the function name (e.g. Label in "astGetLabel").
+*     type
+*        The C type of the attribute.
+*     bad_value
+*        A constant value to return if the global error status is set, or if
+*        the function fails.
+*     assign
+*        An expression that evaluates to the value to be returned. This can
+*        use the string "axis" to represent the zero-based value index.
+*     nval
+*        Specifies the number of values in the multi-valued attribute. The
+*        "axis" values supplied to the created function should be in the
+*        range zero to (nval - 1).
+
+*  Notes:
+*     -  To avoid problems with some compilers, you should not leave any white
+*     space around the macro arguments.
+*
+*/
+
+/* Define the macro. */
+#define MAKE_GET(attr,type,bad_value,assign,nval) \
+\
+/* Private member function. */ \
+/* ------------------------ */ \
+static type Get##attr( AstSkyFrame *this, int axis, int *status ) { \
+   int axis_p;                   /* Permuted axis index */ \
+   type result;                  /* Result to be returned */ \
+\
+/* Initialise */\
+   result = (bad_value); \
+\
+/* Check the global error status. */ \
+   if ( !astOK ) return result; \
+\
+/* Validate and permute the axis index. */ \
+   axis_p = astValidateAxis( this, axis, 1, "astGet" #attr ); \
+\
+/* Assign the result value. */ \
+   if( astOK ) { \
+      result = (assign); \
+   } \
+\
+/* Check for errors and clear the result if necessary. */ \
+   if ( !astOK ) result = (bad_value); \
+\
+/* Return the result. */ \
+   return result; \
+} \
+/* External interface. */ \
+/* ------------------- */  \
+type astGet##attr##_( AstSkyFrame *this, int axis, int *status ) { \
+\
+/* Check the global error status. */ \
+   if ( !astOK ) return (bad_value); \
+\
+/* Invoke the required method via the virtual function table. */ \
+   return (**astMEMBER(this,SkyFrame,Get##attr))( this, axis, status ); \
+}
+
+/*
+*
+*  Name:
+*     MAKE_SET
+
+*  Purpose:
+*     Implement a method to set a single value in a multi-valued attribute
+*     for a SkyFrame.
+
+*  Type:
+*     Private macro.
+
+*  Synopsis:
+*     #include "skyframe.h"
+*     MAKE_SET(attr,type,component,assign,nval)
+
+*  Class Membership:
+*     Defined by the SkyFrame class.
+
+*  Description:
+*     This macro expands to an implementation of a private member function of
+*     the form:
+*
+*        static void Set<Attribute>( AstSkyFrame *this, int axis, <Type> value )
+*
+*     and an external interface function of the form:
+*
+*        void astSet<Attribute>_( AstSkyFrame *this, int axis, <Type> value )
+*
+*     which implement a method for setting a single value in a specified
+*     multi-valued attribute for a SkyFrame.
+
+*  Parameters:
+*      attr
+*         The name of the attribute to be set, as it appears in the function
+*         name (e.g. Label in "astSetLabelAt").
+*      type
+*         The C type of the attribute.
+*      component
+*         The name of the class structure component that holds the attribute
+*         value.
+*      assign
+*         An expression that evaluates to the value to be assigned to the
+*         component.
+*      nval
+*         Specifies the number of values in the multi-valued attribute. The
+*         "axis" values supplied to the created function should be in the
+*         range zero to (nval - 1).
+
+*  Notes:
+*     -  To avoid problems with some compilers, you should not leave any white
+*     space around the macro arguments.
+*-
+*/
+
+/* Define the macro. */
+#define MAKE_SET(attr,type,component,assign,nval) \
+\
+/* Private member function. */ \
+/* ------------------------ */ \
+static void Set##attr( AstSkyFrame *this, int axis, type value, int *status ) { \
+\
+   int axis_p; \
+\
+/* Check the global error status. */ \
+   if ( !astOK ) return; \
+\
+/* Validate and permute the axis index. */ \
+   axis_p = astValidateAxis( this, axis, 1, "astSet" #attr ); \
+\
+/* Store the new value in the structure component. */ \
+   if( astOK ) { \
+      this->component[ axis_p ] = (assign); \
+   } \
+} \
+\
+/* External interface. */ \
+/* ------------------- */ \
+void astSet##attr##_( AstSkyFrame *this, int axis, type value, int *status ) { \
+\
+/* Check the global error status. */ \
+   if ( !astOK ) return; \
+\
+/* Invoke the required method via the virtual function table. */ \
+   (**astMEMBER(this,SkyFrame,Set##attr))( this, axis, value, status ); \
+}
+
+/*
+*
+*  Name:
+*     MAKE_TEST
+
+*  Purpose:
+*     Implement a method to test if a single value has been set in a
+*     multi-valued attribute for a class.
+
+*  Type:
+*     Private macro.
+
+*  Synopsis:
+*     #include "skyframe.h"
+*     MAKE_TEST(attr,assign,nval)
+
+*  Class Membership:
+*     Defined by the SkyFrame class.
+
+*  Description:
+*     This macro expands to an implementation of a private member function of
+*     the form:
+*
+*        static int Test<Attribute>( AstSkyFrame *this, int axis )
+*
+*     and an external interface function of the form:
+*
+*        int astTest<Attribute>_( AstSkyFrame *this, int axis )
+*
+*     which implement a method for testing if a single value in a specified
+*     multi-valued attribute has been set for a class.
+
+*  Parameters:
+*      attr
+*         The name of the attribute to be tested, as it appears in the function
+*         name (e.g. Label in "astTestLabelAt").
+*      assign
+*         An expression that evaluates to 0 or 1, to be used as the returned
+*         value. This can use the string "axis" to represent the zero-based
+*         index of the value within the attribute.
+*      nval
+*         Specifies the number of values in the multi-valued attribute. The
+*         "axis" values supplied to the created function should be in the
+*         range zero to (nval - 1).
+
+*  Notes:
+*     -  To avoid problems with some compilers, you should not leave any white
+*     space around the macro arguments.
+*-
+*/
+
+/* Define the macro. */
+#define MAKE_TEST(attr,assign,nval) \
+\
+/* Private member function. */ \
+/* ------------------------ */ \
+static int Test##attr( AstSkyFrame *this, int axis, int *status ) { \
+   int result;                   /* Value to return */ \
+   int axis_p;                   /* Permuted axis index */ \
+\
+/* Initialise */ \
+   result =0; \
+\
+/* Check the global error status. */ \
+   if ( !astOK ) return result; \
+\
+/* Validate and permute the axis index. */ \
+   axis_p = astValidateAxis( this, axis, 1, "astTest" #attr ); \
+\
+/* Assign the result value. */ \
+   if( astOK ) { \
+      result = (assign); \
+   } \
+\
+/* Check for errors and clear the result if necessary. */ \
+   if ( !astOK ) result = 0; \
+\
+/* Return the result. */ \
+   return result; \
+} \
+/* External interface. */ \
+/* ------------------- */ \
+int astTest##attr##_( AstSkyFrame *this, int axis, int *status ) { \
+\
+/* Check the global error status. */ \
+   if ( !astOK ) return 0; \
+\
+/* Invoke the required method via the virtual function table. */ \
+   return (**astMEMBER(this,SkyFrame,Test##attr))( this, axis, status ); \
+}
+
+
+/* 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 "globals.h"             /* Thread-safe global data access */
+#include "object.h"              /* Base Object class */
+#include "pointset.h"            /* Sets of points (for AST__BAD) */
+#include "unitmap.h"             /* Unit Mappings */
+#include "permmap.h"             /* Coordinate permutations */
+#include "cmpmap.h"              /* Compound Mappings */
+#include "slamap.h"              /* SLALIB sky coordinate Mappings */
+#include "timemap.h"             /* Time conversions */
+#include "skyaxis.h"             /* Sky axes */
+#include "frame.h"               /* Parent Frame class */
+#include "matrixmap.h"           /* Matrix multiplication */
+#include "sphmap.h"              /* Cartesian<->Spherical transformations */
+#include "skyframe.h"            /* Interface definition for this class */
+#include "pal.h"                 /* SLALIB library interface */
+#include "wcsmap.h"              /* Factors of PI */
+#include "timeframe.h"           /* Time system transformations */
+
+/* Error code definitions. */
+/* ----------------------- */
+#include "ast_err.h"             /* AST error codes */
+
+/* C header files. */
+/* --------------- */
+#include <ctype.h>
+#include <float.h>
+#include <limits.h>
+#include <math.h>
+#include <stdarg.h>
+#include <stddef.h>
+#include <stdio.h>
+#include <string.h>
+
+/* Type Definitions. */
+/* ================= */
+
+/* Cached Line structure. */
+/* ---------------------- */
+/* This structure contains information describing a line segment within a
+   SkyFrame. It differs from the AstLineDef defined in frame.h because
+   positions are represented by 3D (x,y,z) cartesian coords rather than
+   2D (long,lat) coords. */
+
+typedef struct SkyLineDef {
+   AstFrame *frame;            /* Pointer to Frame in which the line is defined */
+   double length;              /* Line length */
+   int infinite;               /* Disregard the start and end of the line? */
+   double start[3];            /* Unit vector defining start of line */
+   double end[3];              /* Unit vector defining end of line */
+   double dir[3];              /* Unit vector defining line direction */
+   double q[3];                /* Unit vector perpendicular to line */
+   double start_2d[2];
+   double end_2d[2];
+} SkyLineDef;
+
+/* 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 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_getformat)( AstFrame *, int, 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_gap)( AstFrame *, int, double, int *, int * );
+static double (* parent_getbottom)( AstFrame *, int, int * );
+static double (* parent_getepoch)( AstFrame *, int * );
+static double (* parent_gettop)( AstFrame *, int, int * );
+static int (* parent_getdirection)( AstFrame *, int, int * );
+static int (* parent_getobjsize)( AstObject *, 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_testformat)( AstFrame *, int, int * );
+static int (* parent_unformat)( AstFrame *, int, const char *, double *, int * );
+static void (* parent_clearattrib)( AstObject *, const char *, int * );
+static void (* parent_cleardtai)( AstFrame *, int * );
+static void (* parent_cleardut1)( AstFrame *, int * );
+static void (* parent_clearformat)( AstFrame *, int, int * );
+static void (* parent_clearobsalt)( AstFrame *, int * );
+static void (* parent_clearobslat)( AstFrame *, int * );
+static void (* parent_clearobslon)( AstFrame *, 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_setdtai)( AstFrame *, double, int * );
+static void (* parent_setdut1)( AstFrame *, double, int * );
+static void (* parent_setformat)( AstFrame *, int, const char *, int * );
+static void (* parent_setobsalt)( AstFrame *, double, int * );
+static void (* parent_setobslat)( AstFrame *, double, int * );
+static void (* parent_setobslon)( AstFrame *, double, int * );
+static void (* parent_setsystem)( AstFrame *, AstSystemType, int * );
+
+/* Factors for converting between hours, degrees and radians. */
+static double hr2rad;
+static double deg2rad;
+static double pi;
+static double piby2;
+
+/* Table of cached Local Apparent Sidereal Time values and corresponding
+   epochs. */
+static int nlast_tables = 0;
+static AstSkyLastTable **last_tables = NULL;
+
+
+/* Define macros for accessing each item of thread specific global data. */
+#ifdef THREAD_SAFE
+
+/* Define how to initialise thread-specific globals. */
+#define GLOBAL_inits \
+   globals->Class_Init = 0; \
+   globals->GetAttrib_Buff[ 0 ] = 0; \
+   globals->GetFormat_Buff[ 0 ] = 0; \
+   globals->GetLabel_Buff[ 0 ] = 0; \
+   globals->GetSymbol_Buff[ 0 ] = 0; \
+   globals->GetTitle_Buff[ 0 ] = 0; \
+   globals->GetTitle_Buff2[ 0 ] = 0; \
+   globals->TDBFrame = NULL; \
+   globals->LASTFrame = NULL; \
+
+/* Create the function that initialises global data for this module. */
+astMAKE_INITGLOBALS(SkyFrame)
+
+/* Define macros for accessing each item of thread specific global data. */
+#define class_init astGLOBAL(SkyFrame,Class_Init)
+#define class_vtab astGLOBAL(SkyFrame,Class_Vtab)
+#define getattrib_buff astGLOBAL(SkyFrame,GetAttrib_Buff)
+#define getformat_buff astGLOBAL(SkyFrame,GetFormat_Buff)
+#define getlabel_buff astGLOBAL(SkyFrame,GetLabel_Buff)
+#define getsymbol_buff astGLOBAL(SkyFrame,GetSymbol_Buff)
+#define gettitle_buff astGLOBAL(SkyFrame,GetTitle_Buff)
+#define gettitle_buff2 astGLOBAL(SkyFrame,GetTitle_Buff2)
+#define tdbframe astGLOBAL(SkyFrame,TDBFrame)
+#define lastframe astGLOBAL(SkyFrame,LASTFrame)
+
+
+
+static pthread_mutex_t mutex2 = PTHREAD_MUTEX_INITIALIZER;
+#define LOCK_MUTEX2 pthread_mutex_lock( &mutex2 );
+#define UNLOCK_MUTEX2 pthread_mutex_unlock( &mutex2 );
+
+/* A read-write lock used to protect the table of cached LAST values so
+   that multiple threads can read simultaneously so long as no threads are
+   writing to the table. */
+static pthread_rwlock_t rwlock1=PTHREAD_RWLOCK_INITIALIZER;
+#define LOCK_WLOCK1 pthread_rwlock_wrlock( &rwlock1 );
+#define LOCK_RLOCK1 pthread_rwlock_rdlock( &rwlock1 );
+#define UNLOCK_RWLOCK1 pthread_rwlock_unlock( &rwlock1 );
+
+/* If thread safety is not needed, declare and initialise globals at static
+   variables. */
+#else
+
+/* Buffer returned by GetAttrib. */
+static char getattrib_buff[ GETATTRIB_BUFF_LEN + 1 ];
+
+/* Buffer returned by GetFormat. */
+static char getformat_buff[ GETFORMAT_BUFF_LEN + 1 ];
+
+/* Default GetLabel string buffer */
+static char getlabel_buff[ GETLABEL_BUFF_LEN + 1 ];
+
+/* Default GetSymbol buffer */
+static char getsymbol_buff[ GETSYMBOL_BUFF_LEN + 1 ];
+
+/* Default Title string buffer */
+static char gettitle_buff[ AST__SKYFRAME_GETTITLE_BUFF_LEN + 1 ];
+static char gettitle_buff2[ AST__SKYFRAME_GETTITLE_BUFF_LEN + 1 ];
+
+/* TimeFrames for doing TDB<->LAST conversions. */
+static AstTimeFrame *tdbframe = NULL;
+static AstTimeFrame *lastframe = NULL;
+
+
+/* Define the class virtual function table and its initialisation flag
+   as static variables. */
+static AstSkyFrameVtab class_vtab;   /* Virtual function table */
+static int class_init = 0;       /* Virtual function table initialised? */
+
+#define LOCK_MUTEX2
+#define UNLOCK_MUTEX2
+
+#define LOCK_WLOCK1
+#define LOCK_RLOCK1
+#define UNLOCK_RWLOCK1
+
+#endif
+
+
+/* Prototypes for Private Member Functions. */
+/* ======================================== */
+static AstLineDef *LineDef( AstFrame *, const double[2], const double[2], int * );
+static AstMapping *SkyOffsetMap( AstSkyFrame *, int * );
+static AstPointSet *FrameGrid( AstFrame *, int, const double *, const double *, int * );
+static AstPointSet *ResolvePoints( AstFrame *, const double [], const double [], AstPointSet *, AstPointSet *, int * );
+static AstSystemType GetAlignSystem( AstFrame *, int * );
+static AstSystemType GetSystem( AstFrame *, int * );
+static AstSystemType SystemCode( AstFrame *, const char *, int * );
+static AstSystemType ValidateSystem( AstFrame *, AstSystemType, const char *, int * );
+static const char *Format( AstFrame *, int, double, int * );
+static const char *GetAttrib( AstObject *, const char *, int * );
+static const char *GetDomain( AstFrame *, int * );
+static const char *GetFormat( AstFrame *, int, int * );
+static const char *GetLabel( AstFrame *, int, int * );
+static const char *GetProjection( AstSkyFrame *, int * );
+static const char *GetSymbol( AstFrame *, int, int * );
+static const char *GetTitle( AstFrame *, int * );
+static const char *GetUnit( AstFrame *, int, int * );
+static const char *SystemString( AstFrame *, AstSystemType, int * );
+static double Angle( AstFrame *, const double[], const double[], const double[], int * );
+static double CalcLAST( AstSkyFrame *, double, double, double, double, double, double, int * );
+static double Distance( AstFrame *, const double[], const double[], int * );
+static double Gap( AstFrame *, int, double, int *, int * );
+static double GetBottom( AstFrame *, int, int * );
+static double GetCachedLAST( AstSkyFrame *, double, double, double, double, double, double, int * );
+static double GetEpoch( AstFrame *, int * );
+static double GetEquinox( AstSkyFrame *, int * );
+static void SetCachedLAST( AstSkyFrame *, double, double, double, double, double, double, double, int * );
+static void SetLast( AstSkyFrame *, int * );
+static double GetTop( AstFrame *, int, int * );
+static double Offset2( AstFrame *, const double[2], double, double, double[2], int * );
+static double GetDiurab( AstSkyFrame *, int * );
+static double GetLAST( AstSkyFrame *, int * );
+static int GetActiveUnit( AstFrame *, int * );
+static int GetAsTime( AstSkyFrame *, int, int * );
+static int GetDirection( AstFrame *, int, int * );
+static int GetIsLatAxis( AstSkyFrame *, int, int * );
+static int GetIsLonAxis( AstSkyFrame *, int, int * );
+static int GetLatAxis( AstSkyFrame *, int * );
+static int GetLonAxis( AstSkyFrame *, int * );
+static int GetNegLon( AstSkyFrame *, int * );
+static int GetObjSize( AstObject *, int * );
+static int IsEquatorial( AstSystemType, int * );
+static int LineContains( AstFrame *, AstLineDef *, int, double *, int * );
+static int LineCrossing( AstFrame *, AstLineDef *, AstLineDef *, double **, int * );
+static int LineIncludes( SkyLineDef *, double[3], int * );
+static int MakeSkyMapping( AstSkyFrame *, AstSkyFrame *, AstSystemType, 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 int TestAsTime( AstSkyFrame *, int, int * );
+static int TestAttrib( AstObject *, const char *, int * );
+static int TestEquinox( AstSkyFrame *, int * );
+static int TestNegLon( AstSkyFrame *, int * );
+static int TestProjection( AstSkyFrame *, int * );
+static int TestSlaUnit( AstSkyFrame *, AstSkyFrame *, AstSlaMap *, int * );
+static int Unformat( AstFrame *, int, const char *, double *, int * );
+static void ClearAsTime( AstSkyFrame *, int, int * );
+static void ClearAttrib( AstObject *, const char *, int * );
+static void ClearDtai( AstFrame *, int * );
+static void ClearDut1( AstFrame *, int * );
+static void ClearEquinox( AstSkyFrame *, int * );
+static void ClearNegLon( AstSkyFrame *, int * );
+static void ClearObsAlt( AstFrame *, int * );
+static void ClearObsLat( AstFrame *, int * );
+static void ClearObsLon( AstFrame *, int * );
+static void ClearProjection( AstSkyFrame *, int * );
+static void ClearSystem( AstFrame *, int * );
+static void Copy( const AstObject *, AstObject *, int * );
+static void Delete( AstObject *, int * );
+static void Dump( AstObject *, AstChannel *, int * );
+static void Intersect( AstFrame *, const double[2], const double[2], const double[2], const double[2], double[2], int * );
+static void LineOffset( AstFrame *, AstLineDef *, double, double, double[2], int * );
+static void MatchAxesX( AstFrame *, AstFrame *, int *, int * );
+static void Norm( AstFrame *, double[], int * );
+static void NormBox( AstFrame *, double[], double[], AstMapping *, int * );
+static void Offset( AstFrame *, const double[], const double[], double, double[], int * );
+static void Overlay( AstFrame *, const int *, AstFrame *, int * );
+static void Resolve( AstFrame *, const double [], const double [], const double [], double [], double *, double *, int * );
+static void SetAsTime( AstSkyFrame *, int, int, int * );
+static void SetAttrib( AstObject *, const char *, int * );
+static void SetDtai( AstFrame *, double, int * );
+static void SetDut1( AstFrame *, double, int * );
+static void SetEquinox( AstSkyFrame *, double, int * );
+static void SetNegLon( AstSkyFrame *, int, int * );
+static void SetObsAlt( AstFrame *, double, int * );
+static void SetObsLat( AstFrame *, double, int * );
+static void SetObsLon( AstFrame *, double, int * );
+static void SetProjection( AstSkyFrame *, const char *, int * );
+static void SetSystem( AstFrame *, AstSystemType, int * );
+static void Shapp( double, double *, double *, double, double *, int * );
+static void Shcal( double, double, double, double *, double *, int * );
+static void VerifyMSMAttrs( AstSkyFrame *, AstSkyFrame *, int, const char *, const char *, int * );
+
+static double GetSkyRef( AstSkyFrame *, int, int * );
+static int TestSkyRef( AstSkyFrame *, int, int * );
+static void SetSkyRef( AstSkyFrame *, int, double, int * );
+static void ClearSkyRef( AstSkyFrame *, int, int * );
+
+static double GetSkyRefP( AstSkyFrame *, int, int * );
+static int TestSkyRefP( AstSkyFrame *, int, int * );
+static void SetSkyRefP( AstSkyFrame *, int, double, int * );
+static void ClearSkyRefP( AstSkyFrame *, int, int * );
+
+static int GetSkyRefIs( AstSkyFrame *, int * );
+static int TestSkyRefIs( AstSkyFrame *, int * );
+static void SetSkyRefIs( AstSkyFrame *, int, int * );
+static void ClearSkyRefIs( AstSkyFrame *, int * );
+
+static int GetAlignOffset( AstSkyFrame *, int * );
+static int TestAlignOffset( AstSkyFrame *, int * );
+static void SetAlignOffset( AstSkyFrame *, int, int * );
+static void ClearAlignOffset( AstSkyFrame *, int * );
+
+static double GetSkyTol( AstSkyFrame *, int * );
+static int TestSkyTol( AstSkyFrame *, int * );
+static void SetSkyTol( AstSkyFrame *, double, int * );
+static void ClearSkyTol( AstSkyFrame *, int * );
+
+/* Member functions. */
+/* ================= */
+static double Angle( AstFrame *this_frame, const double a[],
+                     const double b[], const double c[], int *status ) {
+/*
+*  Name:
+*     Angle
+
+*  Purpose:
+*     Calculate the angle subtended by two points at a third point.
+
+*  Type:
+*     Private function.
+
+*  Synopsis:
+*     #include "skyframe.h"
+*     double Angle( AstFrame *this_frame, const double a[],
+*                   const double b[], const double c[], int *status )
+
+*  Class Membership:
+*     SkyFrame member function (over-rides the astAngle method
+*     inherited from the Frame class).
+
+*  Description:
+*     This function finds the angle at point B between the line
+*     joining points A and B, and the line joining points C
+*     and B. These lines will in fact be geodesic curves (great circles).
+
+*  Parameters:
+*     this
+*        Pointer to the SkyFrame.
+*     a
+*        An array of double, with one element for each SkyFrame axis,
+*        containing the coordinates of the first point.
+*     b
+*        An array of double, with one element for each SkyFrame axis,
+*        containing the coordinates of the second point.
+*     c
+*        An array of double, with one element for each SkyFrame axis,
+*        containing the coordinates of the third point.
+*     status
+*        Pointer to the inherited status variable.
+
+*  Returned Value:
+*     The angle in radians, from the line AB to the line CB, in
+*     the range $\pm \pi$ with positive rotation is in the same sense
+*     as rotation from axis 2 to axis 1.
+
+*  Notes:
+*     - This function will return a "bad" result value (AST__BAD) if
+*     any of the input coordinates has this value.
+*     - A "bad" value will also be returned if points A and B are
+*     co-incident, or if points B and C are co-incident.
+*     - A "bad" value will also be returned if this function is
+*     invoked with the AST error status set, or if it should fail for
+*     any reason.
+*/
+
+   AstSkyFrame *this;            /* Pointer to SkyFrame structure */
+   const int *perm;              /* Axis permutation array */
+   double aa[ 2 ];               /* Permuted a coordinates */
+   double anga;                  /* Angle from north to the line BA */
+   double angc;                  /* Angle from north to the line BC */
+   double bb[ 2 ];               /* Permuted b coordinates */
+   double cc[ 2 ];               /* Permuted c coordinates */
+   double result;                /* Value to return */
+
+/* Initialise. */
+   result = AST__BAD;
+
+/* Check the global error status. */
+   if ( !astOK ) return result;
+
+/* Obtain a pointer to the SkyFrame structure. */
+   this = (AstSkyFrame *) this_frame;
+
+/* Obtain a pointer to the SkyFrame's axis permutation array. */
+   perm = astGetPerm( this );
+   if ( astOK ) {
+
+/* Check that all supplied coordinates are OK. */
+      if ( ( a[ 0 ] != AST__BAD ) && ( a[ 1 ] != AST__BAD ) &&
+           ( b[ 0 ] != AST__BAD ) && ( b[ 1 ] != AST__BAD ) &&
+           ( c[ 0 ] != AST__BAD ) && ( c[ 1 ] != AST__BAD ) ) {
+
+/* Apply the axis permutation array to obtain the coordinates of the
+   three points in the required (longitude,latitude) order. */
+         aa[ perm[ 0 ] ] = a[ 0 ];
+         aa[ perm[ 1 ] ] = a[ 1 ];
+         bb[ perm[ 0 ] ] = b[ 0 ];
+         bb[ perm[ 1 ] ] = b[ 1 ];
+         cc[ perm[ 0 ] ] = c[ 0 ];
+         cc[ perm[ 1 ] ] = c[ 1 ];
+
+/* Check that A and B are not co-incident. */
+         if( aa[ 0 ] != bb[ 0 ] || aa[ 1 ] != bb[ 1 ] ) {
+
+/* Check that C and B are not co-incident. */
+            if( cc[ 0 ] != bb[ 0 ] || cc[ 1 ] != bb[ 1 ] ) {
+
+/* Find the angle from north to the line BA. */
+               anga = palDbear( bb[ 0 ], bb[ 1 ], aa[ 0 ], aa[ 1 ] );
+
+/* Find the angle from north to the line BC. */
+               angc = palDbear( bb[ 0 ], bb[ 1 ], cc[ 0 ], cc[ 1 ] );
+
+/* Find the difference. */
+               result = angc - anga;
+
+/* This value is the angle from north, but we want the angle from axis 2.
+   If the axes have been swapped so that axis 2 is actually the longitude
+   axis, then we need to correct this result. */
+               if( perm[ 0 ] != 0 ) result = piby2 - result;
+
+/* Fold the result into the range +/- PI. */
+               result = palDrange( result );
+            }
+         }
+      }
+   }
+
+/* Return the result. */
+   return result;
+}
+
+static double CalcLAST( AstSkyFrame *this, double epoch, double obslon,
+                        double obslat, double obsalt, double dut1, double dtai,
+                        int *status ) {
+/*
+*  Name:
+*     CalcLAST
+
+*  Purpose:
+*     Calculate the Local Appearent Sidereal Time for a SkyFrame.
+
+*  Type:
+*     Private function.
+
+*  Synopsis:
+*     #include "skyframe.h"
+*     double CalcLAST( AstSkyFrame *this, double epoch, double obslon,
+*                      double obslat, double obsalt, double dut1, double dtai,
+*                      int *status )
+
+*  Class Membership:
+*     SkyFrame member function.
+
+*  Description:
+*     This function calculates and returns the Local Apparent Sidereal Time
+*     at the given epoch, etc.
+
+*  Parameters:
+*     this
+*        Pointer to the SkyFrame.
+*     epoch
+*        The epoch (MJD).
+*     obslon
+*        Observatory geodetic longitude (radians)
+*     obslat
+*        Observatory geodetic latitude (radians)
+*     obsalt
+*        Observatory geodetic altitude (metres)
+*     dut1
+*        The UT1-UTC correction, in seconds.
+*     dtai
+*        The TAI-UTC correction, in seconds.
+*     status
+*        Pointer to the inherited status variable.
+
+*  Returned Value:
+*    The Local Apparent Sidereal Time, in radians.
+
+*  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: */
+   astDECLARE_GLOBALS /* Declare the thread specific global data */
+   AstFrameSet *fs;   /* Mapping from TDB offset to LAST offset */
+   double epoch0;     /* Supplied epoch value */
+   double result;     /* Returned LAST value */
+
+/* Get a pointer to the structure holding thread-specific global data. */
+   astGET_GLOBALS(this);
+
+/* Check the global error status. */
+   if ( !astOK ) return AST__BAD;
+
+/* See if the required LAST value can be determined from the cached LAST
+   values in the SkyFrame virtual function table. */
+   result = GetCachedLAST( this, epoch, obslon, obslat, obsalt, dut1, dtai,
+                           status );
+
+/* If not, we do an exact calculation from scratch. */
+   if( result == AST__BAD ) {
+
+/* If not yet done, create two TimeFrames. Note, this is done here
+   rather than in astInitSkyFrameVtab in order to avoid infinite vtab
+   initialisation loops (caused by the TimeFrame class containing a
+   static SkyFrame). */
+      if( ! tdbframe ) {
+         astBeginPM;
+         tdbframe = astTimeFrame( "system=mjd,timescale=tdb", status );
+         lastframe = astTimeFrame( "system=mjd,timescale=last", status );
+         astEndPM;
+      }
+
+/* For better accuracy, use this integer part of the epoch as the origin of
+   the two TimeFrames. */
+      astSetTimeOrigin( tdbframe, (int) epoch );
+      astSetTimeOrigin( lastframe, (int) epoch );
+
+/* Convert the absolute Epoch value to an offset from the above origin. */
+      epoch0 = epoch;
+      epoch -= (int) epoch;
+
+/* Store the observers position in the two TimeFrames. */
+      astSetObsLon( tdbframe, obslon );
+      astSetObsLon( lastframe, obslon );
+
+      astSetObsLat( tdbframe, obslat );
+      astSetObsLat( lastframe, obslat );
+
+      astSetObsAlt( tdbframe, obsalt );
+      astSetObsAlt( lastframe, obsalt );
+
+/* Store the DUT1 value. */
+      astSetDut1( tdbframe, dut1 );
+      astSetDut1( lastframe, dut1 );
+
+/* Store the DTAI value. */
+      if ( dtai == AST__BAD ) {
+         astClearDtai( tdbframe );
+         astClearDtai( lastframe );
+      }
+      else {
+         astSetDtai( tdbframe, dtai );
+         astSetDtai( lastframe, dtai );
+      }
+
+/* Get the conversion from tdb mjd offset to last mjd offset. */
+      fs = astConvert( tdbframe, lastframe, "" );
+
+/* Use it to transform the SkyFrame Epoch from TDB offset to LAST offset. */
+      astTran1( fs, 1, &epoch, 1, &epoch );
+      fs = astAnnul( fs );
+
+/* Convert the LAST offset from days to radians. */
+      result = ( epoch - (int) epoch )*2*AST__DPI;
+
+/* Cache the new LAST value in the SkyFrame virtual function table. */
+      SetCachedLAST( this, result, epoch0, obslon, obslat, obsalt, dut1, dtai,
+                     status );
+   }
+
+/* Return the required LAST value. */
+   return result;
+}
+
+static void ClearAsTime( AstSkyFrame *this, int axis, int *status ) {
+/*
+*  Name:
+*     ClearAsTime
+
+*  Purpose:
+*     Clear the value of the AsTime attribute for a SkyFrame's axis.
+
+*  Type:
+*     Private function.
+
+*  Synopsis:
+*     #include "skyframe.h"
+*     void ClearAsTime( AstSkyFrame *this, int axis, int *status )
+
+*  Class Membership:
+*     SkyFrame member function.
+
+*  Description:
+*     This function clears any value that has been set for the AsTime
+*     attribute for a specified axis of a SkyFrame. This attribute indicates
+*     whether axis values should be formatted as times (as opposed to angles)
+*     by default.
+
+*  Parameters:
+*     this
+*        Pointer to the SkyFrame.
+*     axis
+*        Index of the axis for which the value is to be cleared (zero based).
+*     status
+*        Pointer to the inherited status variable.
+
+*  Returned Value:
+*     void.
+*/
+
+/* Local Variables: */
+   AstAxis *ax;                  /* Pointer to Axis object */
+
+/* Check the global error status. */
+   if ( !astOK ) return;
+
+/* Validate the axis index. */
+   (void) astValidateAxis( this, axis, 1, "astClearAsTime" );
+
+/* Obtain a pointer to the Axis object. */
+   ax = astGetAxis( this, axis );
+
+/* If the Axis is a SkyAxis, clear the AsTime attribute (if it is not a
+   SkyAxis, it will not have this attribute anyway). */
+   if ( astIsASkyAxis( ax ) ) astClearAxisAsTime( ax );
+
+/* Annul the Axis pointer. */
+   ax = astAnnul( ax );
+}
+
+static void ClearAttrib( AstObject *this_object, const char *attrib, int *status ) {
+/*
+*  Name:
+*     ClearAttrib
+
+*  Purpose:
+*     Clear an attribute value for a SkyFrame.
+
+*  Type:
+*     Private function.
+
+*  Synopsis:
+*     #include "skyframe.h"
+*     void ClearAttrib( AstObject *this, const char *attrib, int *status )
+
+*  Class Membership:
+*     SkyFrame 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
+*     SkyFrame, so that the default value will subsequently be used.
+
+*  Parameters:
+*     this
+*        Pointer to the SkyFrame.
+*     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: */
+   AstSkyFrame *this;            /* Pointer to the SkyFrame structure */
+   int axis;                     /* SkyFrame axis number */
+   int len;                      /* Length of attrib string */
+   int nc;                       /* No. characters read by astSscanf */
+
+/* Check the global error status. */
+   if ( !astOK ) return;
+
+/* Obtain a pointer to the SkyFrame structure. */
+   this = (AstSkyFrame *) this_object;
+
+/* Obtain the length of the "attrib" string. */
+   len = strlen( attrib );
+
+/* Check the attribute name and clear the appropriate attribute. */
+
+/* AsTime(axis). */
+/* ------------- */
+   if ( nc = 0,
+        ( 1 == astSscanf( attrib, "astime(%d)%n", &axis, &nc ) )
+        && ( nc >= len ) ) {
+      astClearAsTime( this, axis - 1 );
+
+/* Equinox. */
+/* -------- */
+   } else if ( !strcmp( attrib, "equinox" ) ) {
+      astClearEquinox( this );
+
+/* NegLon. */
+/* ------- */
+   } else if ( !strcmp( attrib, "neglon" ) ) {
+      astClearNegLon( this );
+
+/* Projection. */
+/* ----------- */
+   } else if ( !strcmp( attrib, "projection" ) ) {
+      astClearProjection( this );
+
+/* SkyRef. */
+/* ------- */
+   } else if ( !strcmp( attrib, "skyref" ) ) {
+      astClearSkyRef( this, 0 );
+      astClearSkyRef( this, 1 );
+
+/* SkyTol. */
+/* ------- */
+   } else if ( !strcmp( attrib, "skytol" ) ) {
+      astClearSkyTol( this );
+
+/* SkyRef(axis). */
+/* ------------- */
+   } else if ( nc = 0,
+        ( 1 == astSscanf( attrib, "skyref(%d)%n", &axis, &nc ) )
+        && ( nc >= len ) ) {
+      astClearSkyRef( this, axis - 1 );
+
+/* SkyRefP. */
+/* -------- */
+   } else if ( !strcmp( attrib, "skyrefp" ) ) {
+      astClearSkyRefP( this, 0 );
+      astClearSkyRefP( this, 1 );
+
+/* SkyRefP(axis). */
+/* ------------- */
+   } else if ( nc = 0,
+        ( 1 == astSscanf( attrib, "skyrefp(%d)%n", &axis, &nc ) )
+        && ( nc >= len ) ) {
+      astClearSkyRefP( this, axis - 1 );
+
+/* SkyRefIs. */
+/* --------- */
+   } else if ( !strcmp( attrib, "skyrefis" ) ) {
+      astClearSkyRefIs( this );
+
+/* AlignOffset. */
+/* ------------ */
+   } else if ( !strcmp( attrib, "alignoffset" ) ) {
+      astClearAlignOffset( this );
+
+/* If the name was not recognised, test if it matches any of the
+   read-only attributes of this class. If it does, then report an
+   error. */
+   } else if ( !strncmp( attrib, "islataxis", 9 ) ||
+               !strncmp( attrib, "islonaxis", 9 ) ||
+               !strcmp( attrib, "lataxis" ) ||
+               !strcmp( attrib, "lonaxis" ) ) {
+      astError( AST__NOWRT, "astClear: Invalid attempt to clear the \"%s\" "
+                "value for a %s.", status, attrib, astGetClass( this ) );
+      astError( AST__NOWRT, "This is a read-only attribute." , status);
+
+/* If the attribute is not recognised, pass it on to the parent method
+   for further interpretation. */
+   } else {
+      (*parent_clearattrib)( this_object, attrib, status );
+   }
+}
+
+static void ClearDtai( AstFrame *this, int *status ) {
+/*
+*  Name:
+*     ClearDtai
+
+*  Purpose:
+*     Clear the value of the Dtai attribute for a SkyFrame.
+
+*  Type:
+*     Private function.
+
+*  Synopsis:
+*     #include "skyframe.h"
+*     void ClearDtai( AstFrame *this, int *status )
+
+*  Class Membership:
+*     SkyFrame member function (over-rides the astClearDtai method
+*     inherited from the Frame class).
+
+*  Description:
+*     This function clears the Dtai value and updates the LAST value
+*     stored in the SkyFrame.
+
+*  Parameters:
+*     this
+*        Pointer to the SkyFrame.
+*     status
+*        Pointer to the inherited status variable.
+
+*/
+
+/* Local Variables: */
+   double orig;
+
+/* Check the global error status. */
+   if ( !astOK ) return;
+
+/* Note the original value */
+   orig = astGetDtai( this );
+
+/* Invoke the parent method to clear the Frame Dtai */
+   (*parent_cleardtai)( this, status );
+
+/* If the DTAI value has changed significantly, indicate that the LAST value
+   will need to be re-calculated when it is next needed. */
+   if( ! EQUAL( orig, astGetDtai( this ), 1.0E-6 ) ) {
+      ( (AstSkyFrame *) this )->last = AST__BAD;
+      ( (AstSkyFrame *) this )->eplast = AST__BAD;
+      ( (AstSkyFrame *) this )->klast = AST__BAD;
+   }
+}
+
+static void ClearDut1( AstFrame *this, int *status ) {
+/*
+*  Name:
+*     ClearDut1
+
+*  Purpose:
+*     Clear the value of the Dut1 attribute for a SkyFrame.
+
+*  Type:
+*     Private function.
+
+*  Synopsis:
+*     #include "skyframe.h"
+*     void ClearDut1( AstFrame *this, int *status )
+
+*  Class Membership:
+*     SkyFrame member function (over-rides the astClearDut1 method
+*     inherited from the Frame class).
+
+*  Description:
+*     This function clears the Dut1 value and updates the LAST value
+*     stored in the SkyFrame.
+
+*  Parameters:
+*     this
+*        Pointer to the SkyFrame.
+*     status
+*        Pointer to the inherited status variable.
+
+*/
+
+/* Local Variables: */
+   double orig;
+
+/* Check the global error status. */
+   if ( !astOK ) return;
+
+/* Note the original value */
+   orig = astGetDut1( this );
+
+/* Invoke the parent method to clear the Frame Dut1 */
+   (*parent_cleardut1)( this, status );
+
+/* If the DUT1 value has changed significantly, indicate that the LAST value
+   will need to be re-calculated when it is next needed. */
+   if( fabs( orig - astGetDut1( this ) ) > 1.0E-6 ) {
+      ( (AstSkyFrame *) this )->last = AST__BAD;
+      ( (AstSkyFrame *) this )->eplast = AST__BAD;
+      ( (AstSkyFrame *) this )->klast = AST__BAD;
+   }
+}
+
+static void ClearObsAlt( AstFrame *this, int *status ) {
+/*
+*  Name:
+*     ClearObsAlt
+
+*  Purpose:
+*     Clear the value of the ObsAlt attribute for a SkyFrame.
+
+*  Type:
+*     Private function.
+
+*  Synopsis:
+*     #include "skyframe.h"
+*     void ClearObsAlt( AstFrame *this, int *status )
+
+*  Class Membership:
+*     SkyFrame member function (over-rides the astClearObsAlt method
+*     inherited from the Frame class).
+
+*  Description:
+*     This function clears the ObsAlt value.
+
+*  Parameters:
+*     this
+*        Pointer to the SkyFrame.
+*     status
+*        Pointer to the inherited status variable.
+
+*/
+
+/* Local Variables: */
+   double orig;
+
+/* Check the global error status. */
+   if ( !astOK ) return;
+
+/* Note the original value */
+   orig = astGetObsAlt( this );
+
+/* Invoke the parent method to clear the Frame ObsAlt. */
+   (*parent_clearobsalt)( this, status );
+
+/* If the altitude has changed significantly, indicate that the LAST value
+   and magnitude of the diurnal aberration vector will need to be
+   re-calculated when next needed. */
+   if( fabs( orig - astGetObsAlt( this ) ) > 0.001 ) {
+      ( (AstSkyFrame *) this )->last = AST__BAD;
+      ( (AstSkyFrame *) this )->eplast = AST__BAD;
+      ( (AstSkyFrame *) this )->klast = AST__BAD;
+      ( (AstSkyFrame *) this )->diurab = AST__BAD;
+   }
+}
+
+static void ClearObsLat( AstFrame *this, int *status ) {
+/*
+*  Name:
+*     ClearObsLat
+
+*  Purpose:
+*     Clear the value of the ObsLat attribute for a SkyFrame.
+
+*  Type:
+*     Private function.
+
+*  Synopsis:
+*     #include "skyframe.h"
+*     void ClearObsLat( AstFrame *this, int *status )
+
+*  Class Membership:
+*     SkyFrame member function (over-rides the astClearObsLat method
+*     inherited from the Frame class).
+
+*  Description:
+*     This function clears the ObsLat value.
+
+*  Parameters:
+*     this
+*        Pointer to the SkyFrame.
+*     status
+*        Pointer to the inherited status variable.
+
+*/
+
+/* Local Variables: */
+   double orig;
+
+/* Check the global error status. */
+   if ( !astOK ) return;
+
+/* Note the original value */
+   orig = astGetObsLat( this );
+
+/* Invoke the parent method to clear the Frame ObsLat. */
+   (*parent_clearobslat)( this, status );
+
+/* If the altitude has changed significantly, indicate that the LAST value
+   and magnitude of the diurnal aberration vector will need to be
+   re-calculated when next needed. */
+   if( fabs( orig - astGetObsLat( this ) ) > 1.0E-8 ) {
+      ( (AstSkyFrame *) this )->last = AST__BAD;
+      ( (AstSkyFrame *) this )->eplast = AST__BAD;
+      ( (AstSkyFrame *) this )->klast = AST__BAD;
+      ( (AstSkyFrame *) this )->diurab = AST__BAD;
+   }
+}
+
+static void ClearObsLon( AstFrame *this, int *status ) {
+/*
+*  Name:
+*     ClearObsLon
+
+*  Purpose:
+*     Clear the value of the ObsLon attribute for a SkyFrame.
+
+*  Type:
+*     Private function.
+
+*  Synopsis:
+*     #include "skyframe.h"
+*     void ClearObsLon( AstFrame *this, int *status )
+
+*  Class Membership:
+*     SkyFrame member function (over-rides the astClearObsLon method
+*     inherited from the Frame class).
+
+*  Description:
+*     This function clears the ObsLon value.
+
+*  Parameters:
+*     this
+*        Pointer to the SkyFrame.
+*     status
+*        Pointer to the inherited status variable.
+
+*/
+
+/* Local Variables: */
+   double orig;
+
+/* Check the global error status. */
+   if ( !astOK ) return;
+
+/* Note the original value */
+   orig = astGetObsLon( this );
+
+/* Invoke the parent method to clear the Frame ObsLon. */
+   (*parent_clearobslon)( this, status );
+
+/* If the longitude has changed significantly, indicate that the LAST value
+   will need to be re-calculated when it is next needed. */
+   if( fabs( orig - astGetObsLon( this ) ) > 1.0E-8 ) {
+      ( (AstSkyFrame *) this )->last = AST__BAD;
+      ( (AstSkyFrame *) this )->eplast = AST__BAD;
+      ( (AstSkyFrame *) this )->klast = AST__BAD;
+   }
+}
+
+static void ClearSystem( AstFrame *this_frame, int *status ) {
+/*
+*  Name:
+*     ClearSystem
+
+*  Purpose:
+*     Clear the System attribute for a SkyFrame.
+
+*  Type:
+*     Private function.
+
+*  Synopsis:
+*     #include "skyframe.h"
+*     void ClearSystem( AstFrame *this_frame, int *status )
+
+*  Class Membership:
+*     SkyFrame member function (over-rides the astClearSystem protected
+*     method inherited from the Frame class).
+
+*  Description:
+*     This function clears the System attribute for a SkyFrame.
+
+*  Parameters:
+*     this
+*        Pointer to the SkyFrame.
+*     status
+*        Pointer to the inherited status variable.
+
+*/
+
+/* Local Variables: */
+   AstFrameSet *fs;              /* FrameSet to be used as the Mapping */
+   AstSkyFrame *sfrm;            /* Copy of original SkyFrame */
+   AstSkyFrame *this;            /* Pointer to SkyFrame structure */
+   double xin[ 2 ];              /* Axis 0 values */
+   double yin[ 2 ];              /* Axis 1 values */
+   double xout[ 2 ];             /* Axis 0 values */
+   double yout[ 2 ];             /* Axis 1 values */
+   int skyref_set;               /* Is either SkyRef attribute set? */
+   int skyrefp_set;              /* Is either SkyRefP attribute set? */
+
+/* Check the global error status. */
+   if ( !astOK ) return;
+
+/* Obtain a pointer to the SkyFrame structure. */
+   this = (AstSkyFrame *) this_frame;
+
+/* See if either the SkyRef or SkyRefP attribute is set. */
+   skyref_set = astTestSkyRef( this, 0 ) || astTestSkyRef( this, 1 );
+   skyrefp_set = astTestSkyRefP( this, 0 ) || astTestSkyRefP( this, 1 );
+
+/* If so, we will need to transform their values into the new coordinate
+   system. Save a copy of the SkyFrame with its original System value. */
+   sfrm = ( skyref_set || skyrefp_set )?astCopy( this ):NULL;
+
+/* Use the parent method to clear the System value. */
+   (*parent_clearsystem)( this_frame, status );
+
+/* Now modify the SkyRef and SkyRefP attributes if necessary. */
+   if( sfrm ) {
+
+/* Save the SkyRef and SkyRefP values. */
+      xin[ 0 ] = astGetSkyRef( sfrm, 0 );
+      xin[ 1 ] = astGetSkyRefP( sfrm, 0 );
+      yin[ 0 ] = astGetSkyRef( sfrm, 1 );
+      yin[ 1 ] = astGetSkyRefP( sfrm, 1 );
+
+/* Clear the SkyRef values to avoid infinite recursion in the following
+   call to astConvert. */
+      if( skyref_set ) {
+         astClearSkyRef( sfrm, 0 );
+         astClearSkyRef( sfrm, 1 );
+         astClearSkyRef( this, 0 );
+         astClearSkyRef( this, 1 );
+      }
+
+/* Get the Mapping from the original System to the default System. Invoking
+   astConvert will recursively invoke ClearSystem again. This is why we need
+   to be careful to ensure that SkyRef is cleared above - doing so ensure
+   we do not end up with infinite recursion. */
+      fs = astConvert( sfrm, this, "" );
+
+/* Check the Mapping was found. */
+      if( fs ) {
+
+/* Use the Mapping to find the SkyRef and SkyRefP positions in the default
+   coordinate system. */
+         astTran2( fs, 2, xin, yin, 1, xout, yout );
+
+/* Store the values as required. */
+         if( skyref_set ) {
+            astSetSkyRef( this, 0, xout[ 0 ] );
+            astSetSkyRef( this, 1, yout[ 0 ] );
+         }
+
+         if( skyrefp_set ) {
+            astSetSkyRefP( this, 0, xout[ 1 ] );
+            astSetSkyRefP( this, 1, yout[ 1 ] );
+         }
+
+/* Free resources. */
+         fs = astAnnul( fs );
+
+/* If the Mapping is not defined, we cannot convert the SkyRef or SkyRefP
+   positions in the new Frame so clear them. */
+      } else {
+         if( skyref_set ) {
+            astClearSkyRef( this, 0 );
+            astClearSkyRef( this, 1 );
+         }
+         if( skyrefp_set ) {
+            astClearSkyRefP( this, 0 );
+            astClearSkyRefP( this, 1 );
+         }
+      }
+
+/* Free resources. */
+      sfrm = astAnnul( sfrm );
+   }
+}
+
+static double Distance( AstFrame *this_frame,
+                        const double point1[], const double point2[], int *status ) {
+/*
+*  Name:
+*     Distance
+
+*  Purpose:
+*     Calculate the distance between two points.
+
+*  Type:
+*     Private function.
+
+*  Synopsis:
+*     #include "skyframe.h"
+*     double Distance( AstFrame *this,
+*                      const double point1[], const double point2[], int *status )
+
+*  Class Membership:
+*     SkyFrame member function (over-rides the astDistance method
+*     inherited from the Frame class).
+
+*  Description:
+*     This function finds the distance between two points whose
+*     SkyFrame coordinates are given. The distance calculated is that
+*     along the geodesic curve (i.e. great circle) that joins the two
+*     points.
+
+*  Parameters:
+*     this
+*        Pointer to the SkyFrame.
+*     point1
+*        An array of double, with one element for each SkyFrame axis,
+*        containing the coordinates of the first point.
+*     point2
+*        An array of double, with one element for each SkyFrame axis,
+*        containing the coordinates of the second point.
+*     status
+*        Pointer to the inherited status variable.
+
+*  Returned Value:
+*     The distance between the two points, in radians.
+
+*  Notes:
+*     - This function will return a "bad" result value (AST__BAD) if
+*     any of the input coordinates has this value.
+*     - A "bad" value will also be returned if this function is
+*     invoked with the AST error status set or if it should fail for
+*     any reason.
+*/
+
+/* Local Variables: */
+   AstSkyFrame *this;            /* Pointer to SkyFrame structure */
+   const int *perm;              /* Axis permutation array */
+   double p1[ 2 ];               /* Permuted point1 coordinates */
+   double p2[ 2 ];               /* Permuted point2 coordinates */
+   double result;                /* Value to return */
+
+/* Initialise. */
+   result = AST__BAD;
+
+/* Check the global error status. */
+   if ( !astOK ) return result;
+
+/* Obtain a pointer to the SkyFrame structure. */
+   this = (AstSkyFrame *) this_frame;
+
+/* Obtain a pointer to the SkyFrame's axis permutation array. */
+   perm = astGetPerm( this );
+   if ( astOK ) {
+
+/* Check that all supplied coordinates are OK. */
+      if ( ( point1[ 0 ] != AST__BAD ) && ( point1[ 1 ] != AST__BAD ) &&
+           ( point2[ 0 ] != AST__BAD ) && ( point2[ 1 ] != AST__BAD ) ) {
+
+/* Apply the axis permutation array to obtain the coordinates of the
+   two points in the required (longitude,latitude) order. */
+         p1[ perm[ 0 ] ] = point1[ 0 ];
+         p1[ perm[ 1 ] ] = point1[ 1 ];
+         p2[ perm[ 0 ] ] = point2[ 0 ];
+         p2[ perm[ 1 ] ] = point2[ 1 ];
+
+/* Calculate the great circle distance between the points in radians. */
+         result = palDsep( p1[ 0 ], p1[ 1 ], p2[ 0 ], p2[ 1 ] );
+      }
+   }
+
+/* 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 SkyFrame axis.
+
+*  Type:
+*     Private function.
+
+*  Synopsis:
+*     #include "skyframe.h"
+*     const char *Format( AstFrame *this, int axis, double value, int *status )
+
+*  Class Membership:
+*     SkyFrame 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 SkyFrame axis. The
+*     formatting applied is that specified by a previous invocation of the
+*     astSetFormat method. A suitable default format is applied if necessary,
+*     and this may depend on which sky coordinate system the SkyFrame
+*     describes.
+
+*  Parameters:
+*     this
+*        Pointer to the SkyFrame.
+*     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: */
+   AstSkyFrame *this;            /* Pointer to the SkyFrame structure */
+   const char *result;           /* Pointer value to return */
+   int format_set;               /* Format attribute set? */
+
+/* Check the global error status. */
+   if ( !astOK ) return NULL;
+
+/* Obtain a pointer to the SkyFrame structure. */
+   this = (AstSkyFrame *) this_frame;
+
+/* Validate the axis index. */
+   (void) astValidateAxis( this, axis, 1, "astFormat" );
+
+/* Determine if a Format value has been set for the axis and set a temporary
+   value if it has not. Use the GetFormat member function for this class
+   together with member functions inherited from the parent class (rather than
+   using the object's methods directly) because if any of these methods have
+   been over-ridden by a derived class the Format string syntax may no longer
+   be compatible with this class. */
+   format_set = (*parent_testformat)( this_frame, axis, status );
+   if ( !format_set ) {
+      (*parent_setformat)( this_frame, axis, GetFormat( this_frame, axis, status ), status );
+   }
+
+/* Use the Format member function inherited from the parent class to format the
+   value and return a pointer to the resulting string. */
+   result = (*parent_format)( this_frame, axis, value, status );
+
+/* If necessary, clear any temporary Format value that was set above. */
+   if ( !format_set ) (*parent_clearformat)( this_frame, axis, status );
+
+/* If an error occurred, clear the returned value. */
+   if ( !astOK ) result = NULL;
+
+/* Return the result. */
+   return result;
+}
+
+static AstPointSet *FrameGrid( AstFrame *this_object, int size, const double *lbnd,
+                               const double *ubnd, int *status ){
+/*
+*  Name:
+*     FrameGrid
+
+*  Purpose:
+*     Return a grid of points covering a rectangular area of a Frame.
+
+*  Type:
+*     Private function.
+
+*  Synopsis:
+*     #include "skyframe.h"
+*     AstPointSet *FrameGrid( AstFrame *this_frame, int size,
+*                             const double *lbnd, const double *ubnd,
+*                             int *status )
+
+*  Class Membership:
+*     SkyFrame member function (over-rides the protected astFrameGrid
+*     method inherited from the Frame class).
+
+*  Description:
+*     This function returns a PointSet containing positions spread
+*     approximately evenly throughtout a specified rectangular area of
+*     the Frame.
+
+*  Parameters:
+*     this
+*        Pointer to the Frame.
+*     size
+*        The preferred number of points in the returned PointSet. The
+*        actual number of points in the returned PointSet may be
+*        different, but an attempt is made to stick reasonably closely to
+*        the supplied value.
+*     lbnd
+*        Pointer to an array holding the lower bound of the rectangular
+*        area on each Frame axis. The array should have one element for
+*        each Frame axis.
+*     ubnd
+*        Pointer to an array holding the upper bound of the rectangular
+*        area on each Frame axis. The array should have one element for
+*        each Frame axis.
+
+*  Returned Value:
+*     A pointer to a new PointSet holding the grid of points.
+
+*  Notes:
+*     - A NULL pointer is returned if an error occurs.
+*/
+
+/* Local Variables: */
+   AstPointSet *result;
+   AstSkyFrame *this;
+   double **ptr;
+   double box_area;
+   double cl;
+   double dlon;
+   double hilat;
+   double hilon;
+   double inclon;
+   double lat_size;
+   double lat;
+   double lon;
+   double lolon;
+   double lon_size;
+   double lolat;
+   double totlen;
+   int ilat;
+   int ilon;
+   int imer;
+   int ip;
+   int ipar;
+   int ipmax;
+   int nmer;
+   int npar;
+
+/* Initialise. */
+   result = NULL;
+
+/* Check the global error status. */
+   if ( !astOK ) return result;
+
+/* Obtain a pointer to the SkyFrame structure. */
+   this = (AstSkyFrame *) this_object;
+
+/* Get the zero-based indices of the longitude and latitude axes. */
+   ilon = astGetLonAxis( this );
+   ilat = 1 - ilon;
+
+/* The latitude bounds may not be the right way round so check for it. */
+   if( lbnd[ ilat ] <= ubnd[ ilat ] ) {
+      lolat = lbnd[ ilat ];
+      hilat = ubnd[ ilat ];
+   } else {
+      lolat = ubnd[ ilat ];
+      hilat = lbnd[ ilat ];
+   }
+
+/* Check all bounds are good. Also check the size is positive. */
+   lolon = lbnd[ ilon ];
+   hilon = ubnd[ ilon ];
+   if( size > 0 && lolat != AST__BAD && hilat != AST__BAD &&
+       lolon != AST__BAD && hilon != AST__BAD ) {
+
+/* Ensure the longitude bounds are in the range 0-2PI. */
+      lolon = palDranrm( lolon );
+      hilon = palDranrm( hilon );
+
+/* If the upper longitude limit is less than the lower limit, add 2.PI */
+      if( hilon <= lolon &&
+          ubnd[ ilon ] != lbnd[ ilon ] ) hilon += 2*AST__DPI;
+
+/* Get the total area of the box in steradians. */
+      dlon = hilon - lolon;
+      box_area = fabs( dlon*( sin( hilat ) - sin( lolat ) ) );
+
+/* Get the nominal size of a square grid cell, in radians. */
+      lat_size = sqrt( box_area/size );
+
+/* How many parallels should we use to cover the box? Ensure we use at
+   least two. These parallels pass through the centre of the grid cells. */
+      npar = (int)( 0.5 + ( hilat - lolat )/lat_size );
+      if( npar < 2 ) npar = 2;
+
+/* Find the actual sample size implied by this number of parallels. */
+      lat_size = ( hilat - lolat )/npar;
+
+/* Find the total arc length of the parallels. */
+      totlen = 0.0;
+      lat = lolat + 0.5*lat_size;
+      for( ipar = 0; ipar < npar; ipar++ ) {
+         totlen += dlon*cos( lat );
+         lat += lat_size;
+      }
+
+/* If we space "size" samples evenly over this total arc-length, what is
+   the arc-distance between samples? */
+      lon_size = totlen/size;
+
+/* Create a PointSet in which to store the grid. Make it bigger than
+   necessary in order to leave room for extra samples caused by integer
+   truncation. */
+      ipmax = 2*size;
+      result = astPointSet( ipmax, 2, " ", status );
+      ptr = astGetPoints( result );
+      if( astOK ) {
+
+/* Loop over all the parallels. */
+         ip = 0;
+         lat = lolat + 0.5*lat_size;
+         for( ipar = 0; ipar < npar; ipar++ ) {
+
+/* Get the longitude increment between samples on this parallel. */
+            cl = cos( lat );
+            inclon = ( cl != 0.0 ) ? lon_size/cl : 0.0;
+
+/* Get the number of longitude samples for this parallel. Reduce it if
+   it would extend beyond the end of the PointSet. */
+            nmer = dlon/inclon;
+            if( ip + nmer >= ipmax ) nmer = ipmax - ip;
+
+/* Adjust the longitude increment to take up any slack caused by the
+   above integer division. */
+            inclon = dlon/nmer;
+
+/* Produce the samples for the current parallel. */
+            lon = lolon + 0.5*inclon;
+            for( imer = 0; imer < nmer; imer++ ) {
+               ptr[ ilon ][ ip ] = lon;
+               ptr[ ilat ][ ip ] = lat;
+
+               lon += inclon;
+               ip++;
+            }
+
+/* Get the latitude on the next parallel. */
+            lat += lat_size;
+         }
+
+/* Truncate the PointSet to exclude unused elements at the end. */
+         astSetNpoint( result, ip );
+      }
+
+/* Report error if supplied values were bad. */
+   } else if( astOK ) {
+      if( size < 1 ) {
+         astError( AST__ATTIN, "astFrameGrid(%s): The supplied grid "
+                   "size (%d) is invalid (programming error).",
+                   status, astGetClass( this ), size );
+      } else {
+         astError( AST__ATTIN, "astFrameGrid(%s): One of more of the "
+                   "supplied bounds is AST__BAD (programming error).",
+                   status, astGetClass( this ) );
+      }
+   }
+
+/* Annul the returned PointSet if an error has occurred. */
+   if( !astOK ) result = astAnnul( result );
+
+/* Return the PointSet holding the grid. */
+   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 SkyFrame axis values.
+
+*  Type:
+*     Private function.
+
+*  Synopsis:
+*     #include "skyframe.h"
+*     double Gap( AstFrame *this, int axis, double gap, int *ntick, int *status )
+
+*  Class Membership:
+*     SkyFrame member function (over-rides the protected astGap method
+*     inherited from the Frame class).
+
+*  Description:
+*     This function returns a gap size which produces a nicely spaced
+*     series of formatted values for a SkyFrame 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 SkyFrame.
+*     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: */
+   AstSkyFrame *this;            /* Pointer to the SkyFrame structure */
+   double result;                /* Gap value to return */
+   int format_set;               /* Format attribute set? */
+
+/* Check the global error status. */
+   if ( !astOK ) return 0.0;
+
+/* Obtain a pointer to the SkyFrame structure. */
+   this = (AstSkyFrame *) this_frame;
+
+/* Validate the axis index. */
+   (void) astValidateAxis( this, axis, 1, "astGap" );
+
+/* Determine if a Format value has been set for the axis and set a
+   temporary value if it has not. Use the GetFormat member function
+   for this class together with member functions inherited from the
+   parent class (rather than using the object's methods directly)
+   because if any of these methods have been over-ridden by a derived
+   class the Format string syntax may no longer be compatible with
+   this class. */
+   format_set = (*parent_testformat)( this_frame, axis, status );
+   if ( !format_set ) {
+      (*parent_setformat)( this_frame, axis, GetFormat( this_frame, axis, status ), status );
+   }
+
+/* Use the Gap member function inherited from the parent class to find
+   the gap size. */
+   result = (*parent_gap)( this_frame, axis, gap, ntick, status );
+
+/* If necessary, clear any temporary Format value that was set above. */
+   if ( !format_set ) (*parent_clearformat)( this_frame, axis, status );
+
+/* If an error occurred, clear the returned value. */
+   if ( !astOK ) result = 0.0;
+
+/* Return the result. */
+   return result;
+}
+
+static int GetObjSize( AstObject *this_object, int *status ) {
+/*
+*  Name:
+*     GetObjSize
+
+*  Purpose:
+*     Return the in-memory size of an Object.
+
+*  Type:
+*     Private function.
+
+*  Synopsis:
+*     #include "skyframe.h"
+*     int GetObjSize( AstObject *this, int *status )
+
+*  Class Membership:
+*     SkyFrame member function (over-rides the astGetObjSize protected
+*     method inherited from the parent class).
+
+*  Description:
+*     This function returns the in-memory size of the supplied SkyFrame,
+*     in bytes.
+
+*  Parameters:
+*     this
+*        Pointer to the SkyFrame.
+*     status
+*        Pointer to the inherited status variable.
+
+*  Returned Value:
+*     The Object size, in bytes.
+
+*  Notes:
+*     - A value of zero will be returned if this function is invoked
+*     with the global status set, or if it should fail for any reason.
+*/
+
+/* Local Variables: */
+   AstSkyFrame *this;         /* Pointer to SkyFrame structure */
+   int result;                /* Result value to return */
+
+/* Initialise. */
+   result = 0;
+
+/* Check the global error status. */
+   if ( !astOK ) return result;
+
+/* Obtain a pointers to the SkyFrame structure. */
+   this = (AstSkyFrame *) this_object;
+
+/* Invoke the GetObjSize method inherited from the parent class, and then
+   add on any components of the class structure defined by thsi class
+   which are stored in dynamically allocated memory. */
+   result = (*parent_getobjsize)( this_object, status );
+   result += astTSizeOf( this->projection );
+
+/* If an error occurred, clear the result value. */
+   if ( !astOK ) result = 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 SkyFrame.
+
+*  Type:
+*     Private function.
+
+*  Synopsis:
+*     #include "skyframe.h"
+*     int GetActiveUnit( AstFrame *this_frame, int *status )
+
+*  Class Membership:
+*     SkyFrame 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
+*    SkyFrame, which is always 0.
+
+*  Parameters:
+*     this
+*        Pointer to the SkyFrame.
+*     status
+*        Pointer to the inherited status variable.
+
+*  Returned Value:
+*     The value to use for the ActiveUnit flag (0).
+
+*/
+   return 0;
+}
+
+static int GetAsTime( AstSkyFrame *this, int axis, int *status ) {
+/*
+*  Name:
+*     GetAsTime
+
+*  Purpose:
+*     Obtain the value of the AsTime attribute for a SkyFrame's axis.
+
+*  Type:
+*     Private function.
+
+*  Synopsis:
+*     #include "skyframe.h"
+*     int GetAsTime( AstSkyFrame *this, int axis, int *status )
+
+*  Class Membership:
+*     SkyFrame member function.
+
+*  Description:
+*     This function returns the boolean value of the AsTime attribute for a
+*     specified axis of a SkyFrame. This value indicates whether axis values
+*     should be formatted as times (as opposed to angles) by default.
+
+*  Parameters:
+*     this
+*        Pointer to the SkyFrame.
+*     axis
+*        Index of the axis for which information is required (zero based).
+*     status
+*        Pointer to the inherited status variable.
+
+*  Returned Value:
+*     Zero or one, according to the setting of the AsTime attribute (if no
+*     value has previously been set, a suitable default is returned).
+
+*  Notes:
+*     -  A value of zero will be returned if this function is invoked with the
+*     global error status set, or if it should fail for any reason.
+*/
+
+/* Local Variables: */
+   AstAxis *ax;                  /* Pointer to Axis object */
+   int axis_p;                   /* Permuted axis index */
+   int result;                   /* Result to be returned */
+
+/* Check the global error status. */
+   if ( !astOK ) return 0;
+
+/* Initialise. */
+   result = 0;
+
+/* Validate and permute the axis index. */
+   axis_p = astValidateAxis( this, axis, 1, "astGetAsTime" );
+
+/* Obtain a pointer to the required Axis object. */
+   ax = astGetAxis( this, axis );
+
+/* Determine if the AsTime attribute has been set for the axis (this can only
+   be the case if the object is a SkyAxis). If the attribute is set, obtain its
+   value. */
+   if ( astIsASkyAxis( ax ) && astTestAxisAsTime( ax ) ) {
+      result = astGetAxisAsTime( ax );
+
+/* Otherwise, check which (permuted) axis is involved. Only the first
+   (longitude) axis may be displayed as a time by default. */
+   } else if ( axis_p == 0 ) {
+
+/* Test for those coordinate systems which normally have their longitude axes
+   displayed as times (basically, those that involve the Earth's equator) and
+   set the returned value appropriately. */
+      result = IsEquatorial( astGetSystem( this ), status );
+   }
+
+/* Annul the Axis object pointer. */
+   ax = astAnnul( ax );
+
+/* Return the result. */
+   return result;
+}
+
+static const char *GetAttrib( AstObject *this_object, const char *attrib, int *status ) {
+/*
+*  Name:
+*     GetAttrib
+
+*  Purpose:
+*     Get the value of a specified attribute for a SkyFrame.
+
+*  Type:
+*     Private function.
+
+*  Synopsis:
+*     #include "skyframe.h"
+*     const char *GetAttrib( AstObject *this, const char *attrib, int *status )
+
+*  Class Membership:
+*     SkyFrame 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 SkyFrame, formatted as a character string.
+
+*  Parameters:
+*     this
+*        Pointer to the SkyFrame.
+*     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 SkyFrame, 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 SkyFrame. A copy of the string should
+*     therefore be made if necessary.
+*     - A NULL pointer will be returned if this function is invoked
+*     with the global error status set, or if it should fail for any
+*     reason.
+*/
+
+/* Local Variables: */
+   astDECLARE_GLOBALS            /* Declare the thread specific global data */
+   AstSkyFrame *this;            /* Pointer to the SkyFrame structure */
+   const char *cval;             /* Pointer to character attribute value */
+   const char *result;           /* Pointer value to return */
+   double dval;                  /* Floating point attribute value */
+   double equinox;               /* Equinox attribute value (as MJD) */
+   int as_time;                  /* AsTime attribute value */
+   int axis;                     /* SkyFrame axis number */
+   int ival;                     /* Integer attribute value */
+   int len;                      /* Length of attrib string */
+   int nc;                       /* No. characters read by astSscanf */
+   int neglon;                   /* Display long. values as [-pi,pi]? */
+
+/* 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 SkyFrame structure. */
+   this = (AstSkyFrame *) 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. */
+
+/* AsTime(axis). */
+/* ------------- */
+   if ( nc = 0,
+        ( 1 == astSscanf( attrib, "astime(%d)%n", &axis, &nc ) )
+        && ( nc >= len ) ) {
+      as_time = astGetAsTime( this, axis - 1 );
+      if ( astOK ) {
+         (void) sprintf( getattrib_buff, "%d", as_time );
+         result = getattrib_buff;
+      }
+
+/* Equinox. */
+/* -------- */
+   } else if ( !strcmp( attrib, "equinox" ) ) {
+      equinox = astGetEquinox( this );
+      if ( astOK ) {
+
+/* Format the Equinox as decimal years. Use a Besselian epoch if it
+   will be less than 1984.0, otherwise use a Julian epoch. */
+         result = astFmtDecimalYr( ( equinox < palEpj2d( 1984.0 ) ) ?
+                                   palEpb( equinox ) : palEpj( equinox ),
+                                   AST__DBL_DIG );
+      }
+
+/* IsLatAxis(axis) */
+/* --------------- */
+   } else if ( nc = 0,
+               ( 1 == astSscanf( attrib, "islataxis(%d)%n", &axis, &nc ) )
+               && ( nc >= len ) ) {
+      ival = astGetIsLatAxis( this, axis - 1 );
+      if ( astOK ) {
+         (void) sprintf( getattrib_buff, "%d", ival );
+         result = getattrib_buff;
+      }
+
+/* IsLonAxis(axis) */
+/* --------------- */
+   } else if ( nc = 0,
+               ( 1 == astSscanf( attrib, "islonaxis(%d)%n", &axis, &nc ) )
+               && ( nc >= len ) ) {
+      ival = astGetIsLonAxis( this, axis - 1 );
+      if ( astOK ) {
+         (void) sprintf( getattrib_buff, "%d", ival );
+         result = getattrib_buff;
+      }
+
+/* LatAxis */
+/* -------- */
+   } else if ( !strcmp( attrib, "lataxis" ) ) {
+      axis = astGetLatAxis( this );
+      if ( astOK ) {
+         (void) sprintf( getattrib_buff, "%d", axis + 1 );
+         result = getattrib_buff;
+      }
+
+/* LonAxis */
+/* -------- */
+   } else if ( !strcmp( attrib, "lonaxis" ) ) {
+      axis = astGetLonAxis( this );
+      if ( astOK ) {
+         (void) sprintf( getattrib_buff, "%d", axis + 1 );
+         result = getattrib_buff;
+      }
+
+/* NegLon */
+/* ------ */
+   } else if ( !strcmp( attrib, "neglon" ) ) {
+      neglon = astGetNegLon( this );
+      if ( astOK ) {
+         (void) sprintf( getattrib_buff, "%d", neglon );
+         result = getattrib_buff;
+      }
+
+/* SkyTol */
+/* ------ */
+   } else if ( !strcmp( attrib, "skytol" ) ) {
+      dval = astGetSkyTol( this );
+      if ( astOK ) {
+         (void) sprintf( getattrib_buff, "%.*g", AST__DBL_DIG, dval );
+         result = getattrib_buff;
+      }
+
+/* Projection. */
+/* ----------- */
+   } else if ( !strcmp( attrib, "projection" ) ) {
+      result = astGetProjection( this );
+
+/* SkyRef. */
+/* ------- */
+   } else if ( !strcmp( attrib, "skyref" ) ) {
+      cval = astFormat( this, 0, astGetSkyRef( this, 0 ) );
+      if ( astOK ) {
+         nc = sprintf( getattrib_buff, "%s, ", cval );
+         cval = astFormat( this, 1, astGetSkyRef( this, 1 ) );
+         if ( astOK ) {
+            (void) sprintf( getattrib_buff + nc, "%s", cval );
+            result = getattrib_buff;
+         }
+      }
+
+/* SkyRef(axis). */
+/* ------------- */
+   } else if ( nc = 0,
+        ( 1 == astSscanf( attrib, "skyref(%d)%n", &axis, &nc ) )
+        && ( nc >= len ) ) {
+      dval = astGetSkyRef( this, axis - 1 );
+      if ( astOK ) {
+         (void) sprintf( getattrib_buff, "%.*g", AST__DBL_DIG, dval );
+         result = getattrib_buff;
+      }
+
+/* SkyRefP. */
+/* -------- */
+   } else if ( !strcmp( attrib, "skyrefp" ) ) {
+      cval = astFormat( this, 0, astGetSkyRefP( this, 0 ) );
+      if ( astOK ) {
+         nc = sprintf( getattrib_buff, "%s, ", cval );
+         cval = astFormat( this, 1, astGetSkyRefP( this, 1 ) );
+         if ( astOK ) {
+            (void) sprintf( getattrib_buff + nc, "%s", cval );
+            result = getattrib_buff;
+         }
+      }
+
+/* SkyRefP(axis). */
+/* -------------- */
+   } else if ( nc = 0,
+        ( 1 == astSscanf( attrib, "skyrefp(%d)%n", &axis, &nc ) )
+        && ( nc >= len ) ) {
+      dval = astGetSkyRefP( this, axis - 1 );
+      if ( astOK ) {
+         (void) sprintf( getattrib_buff, "%.*g", AST__DBL_DIG, dval );
+         result = getattrib_buff;
+      }
+
+/* SkyRefIs. */
+/* --------- */
+   } else if ( !strcmp( attrib, "skyrefis" ) ) {
+      ival = astGetSkyRefIs( this );
+      if ( astOK ) {
+         if( ival == AST__POLE_REF ){
+            result = POLE_STRING;
+         } else if( ival == AST__IGNORED_REF ){
+            result = IGNORED_STRING;
+         } else {
+            result = ORIGIN_STRING;
+         }
+      }
+
+/* AlignOffset */
+/* ----------- */
+   } else if ( !strcmp( attrib, "alignoffset" ) ) {
+      ival = astGetAlignOffset( this );
+      if ( astOK ) {
+         (void) sprintf( getattrib_buff, "%d", ival );
+         result = getattrib_buff;
+      }
+
+/* If the attribute name was not recognised, pass it on to the parent
+   method for further interpretation. */
+   } else {
+      result = (*parent_getattrib)( this_object, attrib, status );
+   }
+
+/* Return the result. */
+   return result;
+}
+
+static int GetDirection( AstFrame *this_frame, int axis, int *status ) {
+/*
+*  Name:
+*     GetDirection
+
+*  Purpose:
+*     Obtain the value of the Direction attribute for a SkyFrame axis.
+
+*  Type:
+*     Private function.
+
+*  Synopsis:
+*     #include "skyframe.h"
+*     int GetDirection( AstFrame *this_frame, int axis, int *status )
+
+*  Class Membership:
+*     SkyFrame member function (over-rides the astGetDirection method inherited
+*     from the Frame class).
+
+*  Description:
+*     This function returns the value of the Direction attribute for a
+*     specified axis of a SkyFrame. A suitable default value is returned if no
+*     Direction value has previously been set.
+
+*  Parameters:
+*     this
+*        Pointer to the SkyFrame.
+*     axis
+*        Axis index (zero-based) identifying the axis for which information is
+*        required.
+*     status
+*        Pointer to the inherited status variable.
+
+*  Returned Value:
+*     Zero or one, depending on the Direction attribute value.
+
+*  Notes:
+*     -  A value of zero will be returned if this function is invoked with the
+*     global error status set, or if it should fail for any reason.
+*/
+
+/* Local Variables: */
+   AstSkyFrame *this;            /* Pointer to the SkyFrame structure */
+   int axis_p;                   /* Permuted axis index */
+   int result;                   /* Result to be returned */
+
+/* Check the global error status. */
+   if ( !astOK ) return 0;
+
+/* Initialise. */
+   result = 0;
+
+/* Obtain a pointer to the SkyFrame structure. */
+   this = (AstSkyFrame *) this_frame;
+
+/* Validate and permute the axis index. */
+   axis_p = astValidateAxis( this, axis, 1, "astGetDirection" );
+
+/* Check if a value has been set for the axis Direction attribute. If so,
+   obtain its value. */
+   if ( astTestDirection( this, axis ) ) {
+      result = (*parent_getdirection)( this_frame, axis, status );
+
+/* Otherwise, we will generate a default Direction value. Currently all
+   systems supported by SkyFrame are left handed, so all longitude axes
+   are reversed and all latitude axes are not reversed. */
+   } else if( axis_p == 0 ) {
+      result = 0;
+   } else {
+      result = 1;
+   }
+
+/* If an error occurred, clear the result value. */
+   if ( !astOK ) result = 0;
+
+/* Return the result. */
+   return result;
+}
+
+static double GetBottom( AstFrame *this_frame, int axis, int *status ) {
+/*
+*  Name:
+*     GetBottom
+
+*  Purpose:
+*     Obtain the value of the Bottom attribute for a SkyFrame axis.
+
+*  Type:
+*     Private function.
+
+*  Synopsis:
+*     #include "skyframe.h"
+*     double GetBottom( AstFrame *this_frame, int axis, int *status )
+
+*  Class Membership:
+*     SkyFrame member function (over-rides the astGetBottom method inherited
+*     from the Frame class).
+
+*  Description:
+*     This function returns the value of the Bottom attribute for a
+*     specified axis of a SkyFrame. A suitable default value is returned if no
+*     value has previously been set.
+
+*  Parameters:
+*     this
+*        Pointer to the SkyFrame.
+*     axis
+*        Axis index (zero-based) identifying the axis for which information is
+*        required.
+*     status
+*        Pointer to the inherited status variable.
+
+*  Returned Value:
+*     The Bottom value to use.
+
+*  Notes:
+*     -  A value of -DBL_MAX will be returned if this function is invoked
+*     with the global error status set, or if it should fail for any reason.
+*/
+
+/* Local Variables: */
+   AstSkyFrame *this;            /* Pointer to the SkyFrame structure */
+   int axis_p;                   /* Permuted axis index */
+   double result;                /* Result to be returned */
+
+/* Check the global error status. */
+   if ( !astOK ) return -DBL_MAX;
+
+/* Initialise. */
+   result = -DBL_MAX;
+
+/* Obtain a pointer to the SkyFrame structure. */
+   this = (AstSkyFrame *) this_frame;
+
+/* Validate and permute the axis index. */
+   axis_p = astValidateAxis( this, axis, 1, "astGetBottom" );
+
+/* Check if a value has been set for the axis Bottom attribute. If so,
+   obtain its value. */
+   if ( astTestBottom( this, axis ) ) {
+      result = (*parent_getbottom)( this_frame, axis, status );
+
+/* Otherwise, we will return a default Bottom value appropriate to the
+   SkyFrame class. */
+   } else {
+
+/* If it is a latitude axis return -pi/2. */
+      if( axis_p == 1 ) {
+         result = -piby2;
+
+/* If it is a longitude value return -DBL_MAX (i.e. no lower limit). */
+      } else {
+         result = -DBL_MAX;
+      }
+   }
+
+/* If an error occurred, clear the result value. */
+   if ( !astOK ) result = -DBL_MAX;
+
+/* Return the result. */
+   return result;
+}
+
+static double GetCachedLAST( AstSkyFrame *this, double epoch, double obslon,
+                             double obslat, double obsalt, double dut1,
+                             double dtai, int *status ) {
+/*
+*  Name:
+*     GetCachedLAST
+
+*  Purpose:
+*     Attempt to get a LAST value from the cache in the SkyFrame vtab.
+
+*  Type:
+*     Private function.
+
+*  Synopsis:
+*     #include "skyframe.h"
+*     double GetCachedLAST( AstSkyFrame *this, double epoch, double obslon,
+*                           double obslat, double obsalt, double dut1,
+*                           double dtai, int *status )
+
+*  Class Membership:
+*     SkyFrame member function.
+
+*  Description:
+*     This function searches the static cache of LAST values held in the
+*     SkyFrame virtual function table for a value that corresponds to the
+*     supplied parameter values. If one is found, it is returned.
+*     Otherwise AST__BAD is found.
+
+*  Parameters:
+*     this
+*        Pointer to the SkyFrame.
+*     epoch
+*        The epoch (MJD).
+*     obslon
+*        Observatory geodetic longitude (radians)
+*     obslat
+*        Observatory geodetic latitude (radians)
+*     obsalt
+*        Observatory geodetic altitude (metres)
+*     dut1
+*        The UT1-UTC correction, in seconds.
+*     dtai
+*        The TAI-UTC correction, in seconds.
+*     status
+*        Pointer to the inherited status variable.
+
+*  Returned Value:
+*    The Local Apparent Sidereal Time, in radians.
+
+*  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: */
+   astDECLARE_GLOBALS
+   AstSkyLastTable *table;
+   double *ep;
+   double *lp;
+   double dep;
+   double result;
+   int ihi;
+   int ilo;
+   int itable;
+   int itest;
+
+/* Get a pointer to the structure holding thread-specific global data. */
+   astGET_GLOBALS(this);
+
+/* Initialise */
+   result = AST__BAD;
+
+/* Check the global error status. */
+   if ( !astOK ) return result;
+
+/* Wait until the table is not being written to by any thread. This also
+   prevents a thread from writing to the table whilst we are reading it. */
+   LOCK_RLOCK1
+
+/* Loop round every LAST table held in the vtab. Each table refers to a
+   different observatory position and/or DUT1 and/or DTAI value. */
+   for( itable = 0; itable < nlast_tables; itable++ ) {
+      table = last_tables[ itable ];
+
+/* See if the table refers to the given position, dut1 and dtai value, allowing
+   some small tolerance. */
+      if( fabs( table->obslat - obslat ) < 2.0E-7 &&
+          fabs( table->obslon - obslon ) < 2.0E-7 &&
+          fabs( table->obsalt - obsalt ) < 1.0 &&
+          fabs( table->dut1 - dut1 ) < 1.0E-5 &&
+          EQUAL( table->dtai, dtai, 1.0E-5 ) ) {
+
+/* Get pointers to the array of epoch and corresponding LAST values in
+   the table. */
+         ep = table->epoch;
+         lp = table->last;
+
+/* The values in the epoch array are monotonic increasing. Do a binary chop
+   within the table's epoch array to find the earliest entry that has a
+   value equal to or greater than the supplied epoch value. */
+         ilo = 0;
+         ihi = table->nentry - 1;
+         while( ihi > ilo ) {
+            itest = ( ilo + ihi )/2;
+            if( ep[ itest ] >= epoch ) {
+               ihi = itest;
+            } else {
+               ilo = itest + 1;
+            }
+         }
+
+/* Get the difference between the epoch at the entry selected above and
+   the requested epoch. */
+         dep = ep[ ilo ] - epoch;
+
+/* If the entry selected above is the first entry in the table, it can
+   only be used if it is within 0.001 second of the requested epoch. */
+         if( ilo == 0 ) {
+            if( fabs( dep ) < 0.001/86400.0 ) {
+               result = lp[ 0 ];
+            }
+
+/* If the list of epoch values contained no value that was greater than
+   the supplied epoch value, then we can use the last entry if
+   it is no more than 0.001 second away from the requested epoch. */
+         } else if( dep <= 0.0 ) {
+            if( fabs( dep ) < 0.001/86400.0 ) {
+                result = lp[ ilo ];
+            }
+
+
+/* Otherwise, see if the entry selected above is sufficiently close to
+   its lower neighbour (i.e. closer than 0.4 days) to allow a reasonably
+   accurate LAST value to be determined by interpolation. */
+         } else if( ep[ ilo ] - ep[ ilo - 1 ] < 0.4 ) {
+            ep += ilo - 1;
+            lp += ilo - 1;
+            result = *lp + ( epoch - *ep )*( lp[ 1 ] - *lp )/( ep[ 1 ] - *ep );
+
+/* If the neighbouring point is too far away for interpolation to be
+   reliable, then we can only use the point if it is within 0.001 seconds of
+   the requested epoch. */
+         } else if( fabs( dep ) < 0.001/86400.0 ) {
+            result = lp[ ilo ];
+         }
+
+/* If we have found the right table, we do not need to look at any other
+   tables, so leave the table loop. */
+         break;
+      }
+   }
+
+/* Indicate that threads may now write to the table. */
+   UNLOCK_RWLOCK1
+
+/* Ensure the returned value is within the range 0 - 2.PI. */
+   if( result != AST__BAD ) {
+      while( result > 2*AST__DPI ) result -= 2*AST__DPI;
+      while( result < 0.0 ) result += 2*AST__DPI;
+   }
+
+/* Return the required LAST value. */
+   return result;
+}
+
+static double GetEpoch( AstFrame *this_frame, int *status ) {
+/*
+*  Name:
+*     GetEpoch
+
+*  Purpose:
+*     Obtain the value of the Epoch attribute for a SkyFrame axis.
+
+*  Type:
+*     Private function.
+
+*  Synopsis:
+*     #include "skyframe.h"
+*     double GetEpoch( AstFrame *this_frame, int *status )
+
+*  Class Membership:
+*     SkyFrame member function (over-rides the astGetEpoch method inherited
+*     from the Frame class).
+
+*  Description:
+*     This function returns the value of the Epoch attribute for a
+*     SkyFrame. A suitable default value is returned if no value has
+*     previously been set.
+
+*  Parameters:
+*     this
+*        Pointer to the SkyFrame.
+*     status
+*        Pointer to the inherited status variable.
+
+*  Returned Value:
+*     The Epoch value to use.
+
+*  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: */
+   AstSkyFrame *this;            /* Pointer to the SkyFrame structure */
+   AstSystemType system;         /* System attribute */
+   double result;                /* Result to be returned */
+
+/* Check the global error status. */
+   if ( !astOK ) return AST__BAD;
+
+/* Initialise. */
+   result = AST__BAD;
+
+/* Obtain a pointer to the SkyFrame structure. */
+   this = (AstSkyFrame *) this_frame;
+
+/* Check if a value has been set for the Epoch attribute. If so, obtain its
+   value. */
+   if ( astTestEpoch( this ) ) {
+      result = (*parent_getepoch)( this_frame, status );
+
+/* Otherwise, we will return a default Epoch value appropriate to the
+   SkyFrame class. */
+   } else {
+
+/* Provide a default value of B1950.0 or J2000.0 depending on the System
+   setting. */
+      system = astGetSystem( this );
+      if( system  == AST__FK4 || system == AST__FK4_NO_E ) {
+         result = palEpb2d( 1950.0 );
+      } else {
+         result = palEpj2d( 2000.0 );
+      }
+   }
+
+/* If an error occurred, clear the result value. */
+   if ( !astOK ) result = AST__BAD;
+
+/* Return the result. */
+   return result;
+}
+
+static double GetTop( AstFrame *this_frame, int axis, int *status ) {
+/*
+*  Name:
+*     GetTop
+
+*  Purpose:
+*     Obtain the value of the Top attribute for a SkyFrame axis.
+
+*  Type:
+*     Private function.
+
+*  Synopsis:
+*     #include "skyframe.h"
+*     double GetTop( AstFrame *this_frame, int axis, int *status )
+
+*  Class Membership:
+*     SkyFrame member function (over-rides the astGetTop method inherited
+*     from the Frame class).
+
+*  Description:
+*     This function returns the value of the Top attribute for a
+*     specified axis of a SkyFrame. A suitable default value is returned if no
+*     value has previously been set.
+
+*  Parameters:
+*     this
+*        Pointer to the SkyFrame.
+*     axis
+*        Axis index (zero-based) identifying the axis for which information is
+*        required.
+*     status
+*        Pointer to the inherited status variable.
+
+*  Returned Value:
+*     The Top value to use.
+
+*  Notes:
+*     -  A value of DBL_MAX will be returned if this function is invoked
+*     with the global error status set, or if it should fail for any reason.
+*/
+
+/* Local Variables: */
+   AstSkyFrame *this;            /* Pointer to the SkyFrame structure */
+   int axis_p;                   /* Permuted axis index */
+   double result;                /* Result to be returned */
+
+/* Check the global error status. */
+   if ( !astOK ) return DBL_MAX;
+
+/* Initialise. */
+   result = DBL_MAX;
+
+/* Obtain a pointer to the SkyFrame structure. */
+   this = (AstSkyFrame *) this_frame;
+
+/* Validate and permute the axis index. */
+   axis_p = astValidateAxis( this, axis, 1, "astGetTop" );
+
+/* Check if a value has been set for the axis Top attribute. If so,
+   obtain its value. */
+   if ( astTestTop( this, axis ) ) {
+      result = (*parent_gettop)( this_frame, axis, status );
+
+/* Otherwise, we will return a default Top value appropriate to the
+   SkyFrame class. */
+   } else {
+
+/* If this is a latitude axis return pi/2. */
+      if( axis_p == 1 ) {
+         result = piby2;
+
+/* If it is a longitude value return DBL_MAX (i.e. no upper limit). */
+      } else {
+         result = DBL_MAX;
+      }
+   }
+
+/* If an error occurred, clear the result value. */
+   if ( !astOK ) result = DBL_MAX;
+
+/* 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 SkyFrame.
+
+*  Type:
+*     Private function.
+
+*  Synopsis:
+*     #include "skyframe.h"
+*     const char *GetDomain( AstFrame *this, int *status )
+
+*  Class Membership:
+*     SkyFrame 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 SkyFrame.
+
+*  Parameters:
+*     this
+*        Pointer to the SkyFrame.
+*     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 SkyFrame.
+*     - 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: */
+   AstSkyFrame *this;            /* Pointer to SkyFrame 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 SkyFrame structure. */
+   this = (AstSkyFrame *) 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 = "SKY";
+   }
+
+/* Return the result. */
+   return result;
+}
+
+static const char *GetFormat( AstFrame *this_frame, int axis, int *status ) {
+/*
+*  Name:
+*     GetFormat
+
+*  Purpose:
+*     Access the Format string for a SkyFrame axis.
+
+*  Type:
+*     Private function.
+
+*  Synopsis:
+*     #include "skyframe.h"
+*     const char *GetFormat( AstFrame *this, int axis )
+
+*  Class Membership:
+*     SkyFrame member function (over-rides the astGetFormat method inherited
+*     from the Frame class).
+
+*  Description:
+*     This function returns a pointer to the Format string for a specified axis
+*     of a SkyFrame. A pointer to a suitable default string is returned if no
+*     Format value has previously been set.
+
+*  Parameters:
+*     this
+*        Pointer to the SkyFrame.
+*     axis
+*        Axis index (zero-based) identifying the axis for which information is
+*        required.
+
+*  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 */
+   AstAxis *ax;                  /* Pointer to Axis object */
+   AstSkyFrame *this;            /* Pointer to the SkyFrame structure */
+   const char *result;           /* Pointer value to return */
+   int as_time;                  /* Value of AsTime attribute */
+   int as_time_set;              /* AsTime attribute set? */
+   int axis_p;                   /* Permuted axis index */
+   int digits;                   /* Number of digits of precision */
+   int is_latitude;              /* Value of IsLatitude attribute */
+   int is_latitude_set;          /* IsLatitude attribute set? */
+   int parent;                   /* Use parent method? */
+   int skyaxis;                  /* Is the Axis a SkyAxis? */
+
+/* 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;
+   as_time_set = 0;
+   is_latitude = 0;
+   is_latitude_set = 0;
+
+/* Obtain a pointer to the SkyFrame structure. */
+   this = (AstSkyFrame *) this_frame;
+
+/* Validate and permute the axis index. */
+   axis_p = astValidateAxis( this, axis, 1, "astGetFormat" );
+
+/* Obtain a pointer to the Axis structure. */
+   ax = astGetAxis( this, axis );
+
+/* Decide whether the parent astGetFormat method is able to provide the format
+   string we require. We must use the parent method if the Axis is not a
+   SkyAxis, because the syntax of the Format string would become unsuitable
+   for use with the Axis astFormat method if it was over-ridden here. We also
+   use the parent method to return a Format pointer if an explicit Format
+   string has already been set. */
+   skyaxis = astIsASkyAxis( ax );
+   parent = ( !skyaxis || (*parent_testformat)( this_frame, axis, status ) );
+
+/* If neither of the above conditions apply, we may still be able to use the
+   parent method if the Axis (actually a SkyAxis) is required to behave as a
+   normal RA or DEC axis, as this is the standard behaviour provided by the
+   SkyAxis class. Examine the SkyFrame's System attribute to determine if its
+   axes should behave in this way. */
+   if ( !parent ) parent = IsEquatorial( astGetSystem( this ), status );
+
+/* If using the parent method and dealing with a SkyAxis, determine the
+   settings of any attributes that may affect the Format string. */
+   if ( astOK ) {
+      if ( parent ) {
+         if ( skyaxis ) {
+            as_time_set = astTestAsTime( this, axis );
+            is_latitude_set = astTestAxisIsLatitude( ax );
+            is_latitude = astGetAxisIsLatitude( ax );
+
+/* If no AsTime value is set for the axis, set a temporary value as determined
+   by the astGetAsTime method, which supplies suitable defaults for the axes of
+   a SkyFrame. */
+            if ( !as_time_set ) {
+               astSetAsTime( this, axis, astGetAsTime( this, axis ) );
+	    }
+
+/* Temporarly over-ride the SkyAxis IsLatitude attribute, regardless of its
+   setting, as the second axis of a SkyFrame is always the latitude axis. */
+            astSetAxisIsLatitude( ax, axis_p == 1 );
+         }
+
+/* Invoke the parent method to obtain a pointer to the Format string. */
+         result = (*parent_getformat)( this_frame, axis, status );
+
+/* Now restore the attributes that were temporarily over-ridden above to their
+   previous states. */
+         if ( skyaxis ) {
+            if ( !as_time_set ) astClearAsTime( this, axis );
+            if ( !is_latitude_set ) {
+               astClearAxisIsLatitude( ax );
+            } else {
+               astSetAxisIsLatitude( ax, is_latitude );
+            }
+         }
+
+/* If the parent method is unsuitable, we must construct a new Format string
+   here. This affects only those coordinate systems whose axes do not behave
+   like standard RA/DEC axes (e.g. typically ecliptic, galactic and
+   supergalactic coordinates). For these, we format values as decimal degrees
+   (or decimal hours if the AsTime attribute is set). Obtain the AsTime
+   value. */
+      } else {
+         as_time = astGetAsTime( this, axis );
+
+/* Determine how many digits of precision to use. This is obtained from the
+   SkyAxis Digits attribute (if set), otherwise from the Digits attribute of
+   the enclosing SkyFrame. */
+         if ( astTestAxisDigits( ax ) ) {
+            digits = astGetAxisDigits( ax );
+         } else {
+            digits = astGetDigits( this );
+         }
+
+/* If a time format is required, generate a Format string using decimal
+   hours. */
+         if ( astOK ) {
+            if ( as_time ) {
+               if ( digits <= 2 ) {
+                  result = "h";
+               } else {
+                  (void) sprintf( getformat_buff, "h.%d", digits - 2 );
+                  result = getformat_buff;
+               }
+
+/* Otherwise use decimal degrees. */
+            } else {
+               if ( digits <= 3 ) {
+                  result = "d";
+               } else {
+                  (void) sprintf( getformat_buff, "d.%d", digits - 3 );
+                  result = getformat_buff;
+               }
+	    }
+	 }
+      }
+   }
+
+/* Annul the Axis pointer. */
+   ax = astAnnul( ax );
+
+/* If an error occurred, clear the returned value. */
+   if ( !astOK ) result = NULL;
+
+/* Return the result. */
+   return result;
+}
+
+static const char *GetLabel( AstFrame *this, int axis, int *status ) {
+/*
+*  Name:
+*     GetLabel
+
+*  Purpose:
+*     Access the Label string for a SkyFrame axis.
+
+*  Type:
+*     Private function.
+
+*  Synopsis:
+*     #include "skyframe.h"
+*     const char *GetLabel( AstFrame *this, int axis, int *status )
+
+*  Class Membership:
+*     SkyFrame 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 SkyFrame.
+
+*  Parameters:
+*     this
+*        Pointer to the SkyFrame.
+*     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 */
+   AstSystemType system;         /* Code identifying type of sky coordinates */
+   const char *result;           /* Pointer to label string */
+   int axis_p;                   /* Permuted axis index */
+
+/* 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 and permute the axis index. */
+   axis_p = 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, identify the sky coordinate system described by the SkyFrame. */
+   } else {
+      system = astGetSystem( this );
+
+/* If OK, supply a pointer to a suitable default label string. */
+      if ( astOK ) {
+
+/* Equatorial coordinate systems. */
+         if ( IsEquatorial( system, status ) ) {
+	    result = ( axis_p == 0 ) ? "Right ascension" :
+	                               "Declination";
+
+/* Ecliptic coordinates. */
+         } else if ( system == AST__ECLIPTIC ) {
+	    result = ( axis_p == 0 ) ? "Ecliptic longitude" :
+                                       "Ecliptic latitude";
+
+/* Helio-ecliptic coordinates. */
+         } else if ( system == AST__HELIOECLIPTIC ) {
+	    result = ( axis_p == 0 ) ? "Helio-ecliptic longitude" :
+                                       "Helio-ecliptic latitude";
+
+/* AzEl coordinates. */
+         } else if ( system == AST__AZEL ) {
+	    result = ( axis_p == 0 ) ? "Azimuth" :
+                                       "Elevation";
+
+/* Galactic coordinates. */
+         } else if ( system == AST__GALACTIC ) {
+	    result = ( axis_p == 0 ) ? "Galactic longitude" :
+                                       "Galactic latitude";
+
+/* Supergalactic coordinates. */
+         } else if ( system == AST__SUPERGALACTIC ) {
+	    result = ( axis_p == 0 ) ? "Supergalactic longitude" :
+                                       "Supergalactic latitude";
+
+/* Unknown spherical coordinates. */
+         } else if ( system == AST__UNKNOWN ) {
+	    result = ( axis_p == 0 ) ? "Longitude" :
+                                       "Latitude";
+
+/* Report an error if the coordinate system was not recognised. */
+         } else {
+	    astError( AST__SCSIN, "astGetLabel(%s): Corrupt %s contains "
+		      "invalid sky coordinate system identification code "
+		      "(%d).", status, astGetClass( this ), astGetClass( this ),
+		      (int) system );
+         }
+
+/* If the SkyRef attribute has a set value, append " offset" to the label. */
+         if( astGetSkyRefIs( this ) != AST__IGNORED_REF &&
+             ( astTestSkyRef( this, 0 ) || astTestSkyRef( this, 1 ) ) ) {
+            sprintf( getlabel_buff, "%s offset", result );
+            result = getlabel_buff;
+         }
+      }
+   }
+
+/* Return the result. */
+   return result;
+}
+
+static double GetDiurab( AstSkyFrame *this, int *status ) {
+/*
+*  Name:
+*     GetDiurab
+
+*  Purpose:
+*     Return the magnitude of the diurnal aberration vector.
+
+*  Type:
+*     Private function.
+
+*  Synopsis:
+*     #include "skyframe.h"
+*     double GetDiurab( AstSkyFrame *this, int *status )
+
+*  Class Membership:
+*     SkyFrame member function
+
+*  Description:
+*     This function returns the  magnitude of the diurnal aberration
+*     vector.
+
+*  Parameters:
+*     this
+*        Pointer to the SkyFrame.
+*     status
+*        Pointer to the inherited status variable.
+
+*  Returned Value:
+*     The magnitude of the diurnal aberration vector.
+
+*/
+
+/* Local Variables: */
+   double uau;
+   double vau;
+
+/* Check the global error status. */
+   if ( !astOK ) return AST__BAD;
+
+/* If the magnitude of the diurnal aberration vector has not yet been
+   found, find it now, and cache it in the SkyFrame structure. The cached
+   value will be reset to AST__BAD if the ObsLat attribute value is
+   changed. This code is transliterated from SLA_AOPPA. */
+   if( this->diurab == AST__BAD ) {
+      palGeoc( astGetObsLat( this ), astGetObsAlt( this ), &uau, &vau );
+      this->diurab = 2*AST__DPI*uau*SOLSID/C;
+   }
+
+/* Return the result, */
+   return this->diurab;
+}
+
+static double GetLAST( AstSkyFrame *this, int *status ) {
+/*
+*  Name:
+*     GetLAST
+
+*  Purpose:
+*     Return the Local Apparent Sidereal Time for the SkyFrame.
+
+*  Type:
+*     Private function.
+
+*  Synopsis:
+*     #include "skyframe.h"
+*     double GetLAST( AstSkyFrame *this, int *status )
+
+*  Class Membership:
+*     SkyFrame member function
+
+*  Description:
+*     This function returns the Local Apparent Sidereal Time (LAST)
+*     at the moment intime given by the Epoch attribute of the SkyFrame.
+
+*  Parameters:
+*     this
+*        Pointer to the SkyFrame.
+*     status
+*        Pointer to the inherited status variable.
+
+*  Returned Value:
+*     The LAST value.
+
+*/
+
+/* Local Variables: */
+   double dlast;                 /* Change in LAST */
+   double epoch;                 /* Epoch (TDB MJD) */
+   double last1;                 /* LAST at end of current interval */
+   double result;                /* Result value to return */
+   double delta_epoch;           /* Change in Epoch */
+
+/* Initialise. */
+   result = 0;
+
+/* Check the global error status. */
+   if ( !astOK ) return result;
+
+/* The "last" component of the SkyFrame structure holds the accurate
+   LAST at the moment in time given by the "eplast" (a TDB MJD) component
+   of the SkyFrame structure. If the current value of the SkyFrame's
+   Epoch attribute is not much different to "eplast" (within 0.4 of a day),
+   then the returned LAST value is the "last" value plus the difference
+   between Epoch and "eplast", converted from solar to sidereal time,
+   then converted to radians. This approximation seems to be good to less
+   than a tenth of an arcsecond. If this approximation cannot be used,
+   invoke SetLast to recalculate the accurate LAST and update the "eplast"
+   and "last" values. */
+   if( this->eplast != AST__BAD ) {
+      epoch = astGetEpoch( this );
+      delta_epoch = epoch - this->eplast;
+
+/* Return the current LAST value if the epoch has not changed. */
+      if( delta_epoch == 0.0 ) {
+         result = this->last;
+
+/* If the previous full calculation of LAST was less than 0.4 days ago,
+   use a linear approximation to LAST. */
+      } else if( fabs( delta_epoch ) < 0.4 ) {
+
+/* If we do not know the ratio of sidereal to solar time at the current
+   epoch, calculate it now. This involves a full calculation of LAST at
+   the end of the current linear approximation period. */
+         if( this->klast == AST__BAD ) {
+            last1 = CalcLAST( this, this->eplast + 0.4, astGetObsLon( this ),
+                              astGetObsLat( this ), astGetObsAlt( this ),
+                              astGetDut1( this ), astGetDtai( this ), status );
+
+/* Ensure the change in LAST is positive so that we get a positive ratio. */
+            dlast = last1 - this->last;
+            if( dlast < 0.0 ) dlast += 2*AST__DPI;
+            this->klast = 2*AST__DPI*0.4/dlast;
+         }
+
+/* Now use the ratio of solar to sidereal time to calculate the linear
+   approximation to LAST. */
+         result = this->last + 2*AST__DPI*delta_epoch/this->klast;
+
+/* If the last accurate calculation of LAST was more than 0.4 days ago,
+   do a full accurate calculation. */
+      } else {
+         SetLast( this, status );
+         result = this->last;
+      }
+
+/* If we have not yet done an accurate calculation of LAST, do one now. */
+   } else {
+      SetLast( this, status );
+      result = this->last;
+   }
+
+/* Return the result, */
+   return result;
+}
+
+static int GetIsLatAxis( AstSkyFrame *this, int axis, int *status ) {
+/*
+*  Name:
+*     GetIsLatAxis
+
+*  Purpose:
+*     Test an axis to see if it is a latitude axis.
+
+*  Type:
+*     Private function.
+
+*  Synopsis:
+*     #include "skyframe.h"
+*     int GetIsLatAxis( AstSkyFrame *this, int axis, int *status )
+
+*  Class Membership:
+*     SkyFrame member function.
+
+*  Description:
+*     This function tests if a SkyFrame axis is a celestial latitude axis.
+
+*  Parameters:
+*     this
+*        Pointer to the SkyFrame.
+*     axis
+*        Zero based axis index.
+*     status
+*        Pointer to the inherited status variable.
+
+*  Returned Value:
+*     One if the supplied axis is a celestial latitude axis, and zero
+*     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.
+*/
+
+/* Local Variables: */
+   int result;                   /* Result to be returned */
+
+/* Check the global error status. */
+   if ( !astOK ) return 0;
+
+/* Get the index of the latitude axis and compare to the supplied axis
+   index. */
+   result = ( axis == astGetLatAxis( this ) );
+
+/* Return the result. */
+   return astOK ? result : 0;
+
+}
+
+static int GetIsLonAxis( AstSkyFrame *this, int axis, int *status ) {
+/*
+*  Name:
+*     GetIsLonAxis
+
+*  Purpose:
+*     Test an axis to see if it is a longitude axis.
+
+*  Type:
+*     Private function.
+
+*  Synopsis:
+*     #include "skyframe.h"
+*     int GetIsLonAxis( AstSkyFrame *this, int axis, int *status )
+
+*  Class Membership:
+*     SkyFrame member function.
+
+*  Description:
+*     This function tests if a SkyFrame axis is a celestial longitude axis.
+
+*  Parameters:
+*     this
+*        Pointer to the SkyFrame.
+*     axis
+*        Zero based axis index.
+*     status
+*        Pointer to the inherited status variable.
+
+*  Returned Value:
+*     One if the supplied axis is a celestial longitude axis, and zero
+*     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.
+*/
+
+/* Local Variables: */
+   int result;                   /* Result to be returned */
+
+/* Check the global error status. */
+   if ( !astOK ) return 0;
+
+/* Get the index of the longitude axis and compare to the supplied axis
+   index. */
+   result = ( axis == astGetLonAxis( this ) );
+
+/* Return the result. */
+   return astOK ? result : 0;
+
+}
+
+static int GetLatAxis( AstSkyFrame *this, int *status ) {
+/*
+*  Name:
+*     GetLatAxis
+
+*  Purpose:
+*     Obtain the index of the latitude axis of a SkyFrame.
+
+*  Type:
+*     Private function.
+
+*  Synopsis:
+*     #include "skyframe.h"
+*     int GetLatAxis( AstSkyFrame *this, int *status )
+
+*  Class Membership:
+*     SkyFrame member function.
+
+*  Description:
+*     This function returns the zero-based index of the latitude axis of
+*     a SkyFrame, taking into account any current axis permutation.
+
+*  Parameters:
+*     this
+*        Pointer to the SkyFrame.
+*     status
+*        Pointer to the inherited status variable.
+
+*  Returned Value:
+*     The zero based axis index (0 or 1) of the latitude axis.
+
+*  Notes:
+*     -  A value of one will be returned if this function is invoked with the
+*     global error status set, or if it should fail for any reason.
+*/
+
+/* Local Variables: */
+   int result;                   /* Result to be returned */
+   const int *perm;              /* Axis permutation array */
+
+/* Check the global error status. */
+   if ( !astOK ) return 1;
+
+/* Initialise. */
+   result = 1;
+
+/* Obtain a pointer to the SkyFrame's axis permutation array. */
+   perm = astGetPerm( this );
+   if ( astOK ) {
+
+/* Identify the latitude axis. */
+      if( perm[ 0 ] == 1 ) {
+         result = 0;
+      } else {
+         result = 1;
+      }
+
+   }
+
+/* Return the result. */
+   return result;
+
+}
+
+static int GetLonAxis( AstSkyFrame *this, int *status ) {
+/*
+*  Name:
+*     GetLonAxis
+
+*  Purpose:
+*     Obtain the index of the longitude axis of a SkyFrame.
+
+*  Type:
+*     Private function.
+
+*  Synopsis:
+*     #include "skyframe.h"
+*     int GetLonAxis( AstSkyFrame *this, int *status )
+
+*  Class Membership:
+*     SkyFrame member function.
+
+*  Description:
+*     This function returns the zero-based index of the longitude axis of
+*     a SkyFrame, taking into account any current axis permutation.
+
+*  Parameters:
+*     this
+*        Pointer to the SkyFrame.
+*     status
+*        Pointer to the inherited status variable.
+
+*  Returned Value:
+*     The zero based axis index (0 or 1) of the longitude axis.
+
+*  Notes:
+*     -  A value of zero will be returned if this function is invoked with the
+*     global error status set, or if it should fail for any reason.
+*/
+
+/* Local Variables: */
+   int result;                   /* Result to be returned */
+   const int *perm;              /* Axis permutation array */
+
+/* Check the global error status. */
+   if ( !astOK ) return 0;
+
+/* Initialise. */
+   result = 0;
+
+/* Obtain a pointer to the SkyFrame's axis permutation array. */
+   perm = astGetPerm( this );
+   if ( astOK ) {
+
+/* Identify the longitude axis. */
+      if( perm[ 0 ] == 0 ) {
+         result = 0;
+      } else {
+         result = 1;
+      }
+
+   }
+
+/* Return the result. */
+   return result;
+
+}
+
+static double GetSkyRefP( AstSkyFrame *this, int axis, int *status ) {
+/*
+*  Name:
+*     GetSkyRefP
+
+*  Purpose:
+*     Obtain the value of the SkyRefP attribute for a SkyFrame axis.
+
+*  Type:
+*     Private function.
+
+*  Synopsis:
+*     #include "skyframe.h"
+*     double GetSkyRefP( AstSkyFrame *this, int axis, int *status )
+
+*  Class Membership:
+*     SkyFrame member function.
+
+*  Description:
+*     This function returns the value of the SkyRefP attribute for a
+*     SkyFrame axis, providing suitable defaults.
+
+*  Parameters:
+*     this
+*        Pointer to the SkyFrame.
+*     axis
+*        Axis index (zero-based) identifying the axis for which information is
+*        required.
+*     status
+*        Pointer to the inherited status variable.
+
+*  Returned Value:
+*     The SkyRefP value to be used.
+
+*  Notes:
+*     -  A value of zero will be returned if this function is invoked with the
+*     global error status set, or if it should fail for any reason.
+*/
+
+/* Local Variables: */
+   double result;                /* Returned value */
+   int axis_p;                   /* Permuted axis index */
+
+/* Initialise. */
+   result = 0.0;
+
+/* Check the global error status. */
+   if ( !astOK ) return result;
+
+/* Validate and permute the axis index. */
+   axis_p = astValidateAxis( this, axis, 1, "astGetSkyRefP" );
+
+/* Check if a value has been set for the required axis. If so, return it. */
+   if( this->skyrefp[ axis_p ] != AST__BAD ) {
+      result = this->skyrefp[ axis_p ];
+
+/* Otherwise, return the default value */
+   } else {
+
+/* The default longitude value is always zero. */
+      if( axis_p == 0 ) {
+         result= 0.0;
+
+/* The default latitude value depends on SkyRef. The usual default is the
+   north pole. The exception to this is if the SkyRef attribute identifies
+   either the north or the south pole, in which case the origin is used as
+   the default. Allow some tolerance. */
+      } else if( fabs( cos( this->skyref[ 1 ] ) ) > 1.0E-10 ) {
+         result = pi/2;
+
+      } else {
+         result = 0.0;
+      }
+   }
+
+/* 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 SkyFrame axis.
+
+*  Type:
+*     Private function.
+
+*  Synopsis:
+*     #include "skyframe.h"
+*     const char *GetSymbol( AstFrame *this, int axis, int *status )
+
+*  Class Membership:
+*     SkyFrame 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 SkyFrame.
+
+*  Parameters:
+*     this
+*        Pointer to the SkyFrame.
+*     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 */
+   AstSystemType system;         /* Code identifying type of sky coordinates */
+   const char *result;           /* Pointer to symbol string */
+   int axis_p;                   /* Permuted axis index */
+
+/* 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 and permute the axis index. */
+   axis_p = 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 SkyFrame. */
+   } else {
+      system = astGetSystem( this );
+
+/* If OK, supply a pointer to a suitable default Symbol string. */
+      if ( astOK ) {
+
+/* Equatorial coordinate systems. */
+         if ( IsEquatorial( system, status ) ) {
+	    result = ( axis_p == 0 ) ? "RA" : "Dec";
+
+/* Ecliptic coordinates. */
+         } else if ( system == AST__ECLIPTIC ) {
+	    result = ( axis_p == 0 ) ? "Lambda" : "Beta";
+
+/* Helio-ecliptic coordinates. */
+         } else if ( system == AST__HELIOECLIPTIC ) {
+	    result = ( axis_p == 0 ) ? "Lambda" : "Beta";
+
+/* AzEl coordinates. */
+         } else if ( system == AST__AZEL ) {
+	    result = ( axis_p == 0 ) ? "Az" : "El";
+
+/* Galactic coordinates. */
+         } else if ( system == AST__GALACTIC ) {
+	    result = ( axis_p == 0 ) ? "l" : "b";
+
+/* Supergalactic coordinates. */
+         } else if ( system == AST__SUPERGALACTIC ) {
+	    result = ( axis_p == 0 ) ? "SGL" : "SGB";
+
+/* Unknown spherical coordinates. */
+         } else if ( system == AST__UNKNOWN ) {
+	    result = ( axis_p == 0 ) ? "Lon" : "Lat";
+
+/* Report an error if the coordinate system was not recognised. */
+         } else {
+	    astError( AST__SCSIN, "astGetSymbol(%s): Corrupt %s contains "
+		      "invalid sky coordinate system identification code "
+		      "(%d).", status, astGetClass( this ), astGetClass( this ),
+		      (int) system );
+         }
+
+/* If the SkyRef attribute had a set value, prepend "D" (for "delta") to the
+   Symbol. */
+         if( astGetSkyRefIs( this ) != AST__IGNORED_REF &&
+             ( astTestSkyRef( this, 0 ) || astTestSkyRef( this, 1 ) ) ) {
+            sprintf( getsymbol_buff, "D%s", result );
+            result = getsymbol_buff;
+         }
+      }
+   }
+
+/* Return the result. */
+   return result;
+}
+
+static AstSystemType GetAlignSystem( AstFrame *this_frame, int *status ) {
+/*
+*  Name:
+*     GetAlignSystem
+
+*  Purpose:
+*     Obtain the AlignSystem attribute for a SkyFrame.
+
+*  Type:
+*     Private function.
+
+*  Synopsis:
+*     #include "skyframe.h"
+*     AstSystemType GetAlignSystem( AstFrame *this_frame, int *status )
+
+*  Class Membership:
+*     SkyFrame member function (over-rides the astGetAlignSystem protected
+*     method inherited from the Frame class).
+
+*  Description:
+*     This function returns the AlignSystem attribute for a SkyFrame.
+
+*  Parameters:
+*     this
+*        Pointer to the SkyFrame.
+*     status
+*        Pointer to the inherited status variable.
+
+*  Returned Value:
+*     The AlignSystem value.
+
+*/
+
+/* Local Variables: */
+   AstSkyFrame *this;            /* Pointer to SkyFrame structure */
+   AstSystemType result;         /* Value to return */
+
+/* Initialise. */
+   result = AST__BADSYSTEM;
+
+/* Check the global error status. */
+   if ( !astOK ) return result;
+
+/* Obtain a pointer to the SkyFrame structure. */
+   this = (AstSkyFrame *) 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__ICRS;
+   }
+
+/* Return the result. */
+   return result;
+}
+
+static AstSystemType GetSystem( AstFrame *this_frame, int *status ) {
+/*
+*  Name:
+*     GetSystem
+
+*  Purpose:
+*     Obtain the System attribute for a SkyFrame.
+
+*  Type:
+*     Private function.
+
+*  Synopsis:
+*     #include "skyframe.h"
+*     AstSystemType GetSystem( AstFrame *this_frame, int *status )
+
+*  Class Membership:
+*     SkyFrame member function (over-rides the astGetSystem protected
+*     method inherited from the Frame class).
+
+*  Description:
+*     This function returns the System attribute for a SkyFrame.
+
+*  Parameters:
+*     this
+*        Pointer to the SkyFrame.
+*     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: */
+   AstSkyFrame *this;            /* Pointer to SkyFrame structure */
+   AstSystemType result;         /* Value to return */
+
+/* Initialise. */
+   result = AST__BADSYSTEM;
+
+/* Check the global error status. */
+   if ( !astOK ) return result;
+
+/* Obtain a pointer to the SkyFrame structure. */
+   this = (AstSkyFrame *) 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__ICRS;
+   }
+
+/* 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 SkyFrame.
+
+*  Type:
+*     Private function.
+
+*  Synopsis:
+*     #include "skyframe.h"
+*     const char *GetTitle( AstFrame *this_frame, int *status )
+
+*  Class Membership:
+*     SkyFrame member function (over-rides the astGetTitle method inherited
+*     from the Frame class).
+
+*  Description:
+*     This function returns a pointer to the Title string for a SkyFrame.
+*     A pointer to a suitable default string is returned if no Title value has
+*     previously been set.
+
+*  Parameters:
+*     this
+*        Pointer to the SkyFrame.
+*     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 */
+   AstSkyFrame *this;            /* Pointer to SkyFrame structure */
+   AstSystemType system;         /* Code identifying type of sky coordinates */
+   const char *extra;            /* Pointer to extra information */
+   const char *p;                /* Character pointer */
+   const char *projection;       /* Pointer to sky projection description */
+   const char *result;           /* Pointer to result string */
+   const char *word;             /* Pointer to critical word */
+   double epoch;                 /* Value of Epoch attribute */
+   double equinox;               /* Value of Equinox attribute */
+   int lextra;                   /* Length of extra information */
+   int offset;                   /* Using offset coordinate system? */
+   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;
+   pos = 0;
+
+/* Obtain a pointer to the SkyFrame structure. */
+   this = (AstSkyFrame *) 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
+   SkyFrame's attributes that determine what this string will be. */
+   } else {
+      epoch = astGetEpoch( this );
+      equinox = astGetEquinox( this );
+      projection = astGetProjection( this );
+      system = astGetSystem( this );
+
+/* See if an offset coordinate system is being used.*/
+      offset = ( astTestSkyRef( this, 0 ) || astTestSkyRef( this, 1 ) )
+               && ( astGetSkyRefIs( this ) != AST__IGNORED_REF );
+
+/* Use this to determine if the word "coordinates" or "offsets" should be
+   used.*/
+      word = offset ? "offsets" : "coordinates";
+
+/* Classify the coordinate system type and create an appropriate Title
+   string.  (Note that when invoking the astFmtDecimalYr function we must
+   use a separate sprintf on each occasion so as not to over-write its
+   internal buffer before the result string has been used.) */
+      if ( astOK ) {
+         result = gettitle_buff;
+         switch ( system ) {
+
+/* FK4 equatorial coordinates. */
+/* --------------------------- */
+/* Display the Equinox and Epoch values. */
+	 case AST__FK4:
+	    pos = sprintf( gettitle_buff, "FK4 equatorial %s", word );
+            if( astTestEquinox( this ) || astGetUseDefs( this ) ) {
+   	       pos += sprintf( gettitle_buff + pos, "; mean equinox B%s",
+		               astFmtDecimalYr( palEpb( equinox ), 9 ) );
+            }
+            if( astTestEpoch( this ) || astGetUseDefs( this ) ) {
+               pos += sprintf( gettitle_buff + pos,
+                               "; epoch B%s", astFmtDecimalYr( palEpb( epoch ), 9 ) );
+            }
+	    break;
+
+/* FK4 coordinates with no E-terms of aberration. */
+/* ---------------------------------------------- */
+/* Display the Equinox and Epoch values. */
+	 case AST__FK4_NO_E:
+	    pos = sprintf( gettitle_buff, "FK4 equatorial %s; no E-terms", word );
+            if( astTestEquinox( this ) || astGetUseDefs( this ) ) {
+   	       pos += sprintf( gettitle_buff + pos, "; mean equinox B%s",
+		               astFmtDecimalYr( palEpb( equinox ), 9 ) );
+            }
+            if( astTestEpoch( this ) || astGetUseDefs( this ) ) {
+               pos += sprintf( gettitle_buff + pos,
+                               "; epoch B%s", astFmtDecimalYr( palEpb( epoch ), 9 ) );
+            }
+	    break;
+
+/* FK5 equatorial coordinates. */
+/* --------------------------- */
+/* Display only the Equinox value. */
+	 case AST__FK5:
+	    pos = sprintf( gettitle_buff, "FK5 equatorial %s", word );
+            if( astTestEquinox( this ) || astGetUseDefs( this ) ) {
+   	       pos += sprintf( gettitle_buff + pos, "; mean equinox J%s",
+		               astFmtDecimalYr( palEpj( equinox ), 9 ) );
+            }
+	    break;
+
+/* J2000 equatorial coordinates. */
+/* ----------------------------- */
+/* Based on the dynamically determined mean equator and equinox of J2000,
+   rather than on a model such as FK4 or FK5 */
+	 case AST__J2000:
+	    pos = sprintf( gettitle_buff, "J2000 equatorial %s", word );
+	    break;
+
+/* ICRS coordinates. */
+/* ----------------- */
+/* ICRS is only like RA/Dec by co-incidence, it is not really an
+   equatorial system by definition. */
+	 case AST__ICRS:
+	    pos = sprintf( gettitle_buff, "ICRS %s", word );
+	    break;
+
+/* AzEl coordinates. */
+/* ----------------- */
+	 case AST__AZEL:
+	    pos = sprintf( gettitle_buff, "Horizon (Azimuth/Elevation) %s", word );
+	    break;
+
+/* Geocentric apparent equatorial coordinates. */
+/* ------------------------------------------ */
+/* Display only the Epoch value. */
+	 case AST__GAPPT:
+	    pos = sprintf( gettitle_buff,
+                           "Geocentric apparent equatorial %s; "
+                           "; epoch J%s", word, astFmtDecimalYr( palEpj( epoch ), 9 ) );
+	    break;
+
+/* Ecliptic coordinates. */
+/* --------------------- */
+/* Display only the Equinox value. */
+	 case AST__ECLIPTIC:
+	    pos = sprintf( gettitle_buff, "Ecliptic %s", word );
+            if( astTestEquinox( this ) || astGetUseDefs( this ) ) {
+   	       pos += sprintf( gettitle_buff + pos, "; mean equinox J%s",
+		               astFmtDecimalYr( palEpj( equinox ), 9 ) );
+            }
+	    break;
+
+/* Helio-ecliptic coordinates. */
+/* --------------------------- */
+/* Display only the Epoch value (equinox is fixed). */
+	 case AST__HELIOECLIPTIC:
+	    pos = sprintf( gettitle_buff, "Helio-ecliptic %s; mean equinox J2000", word );
+            if( astTestEpoch( this ) || astGetUseDefs( this ) ) {
+   	       pos += sprintf( gettitle_buff + pos, "; epoch J%s",
+		               astFmtDecimalYr( palEpj( epoch ), 9 ) );
+            }
+	    break;
+
+/* Galactic coordinates. */
+/* --------------------- */
+/* Do not display an Equinox or Epoch value. */
+	 case AST__GALACTIC:
+	    pos = sprintf( gettitle_buff, "IAU (1958) galactic %s", word );
+	    break;
+
+/* Supergalactic coordinates. */
+/* -------------------------- */
+/* Do not display an Equinox or Epoch value. */
+	 case AST__SUPERGALACTIC:
+	    pos = sprintf( gettitle_buff,
+                           "De Vaucouleurs supergalactic %s", word );
+	    break;
+
+/* Unknown coordinates. */
+/* -------------------------- */
+	 case AST__UNKNOWN:
+	    pos = sprintf( gettitle_buff,
+                           "Spherical %s", word );
+	    break;
+
+/* Report an error if the coordinate system was not recognised. */
+	 default:
+	    astError( AST__SCSIN, "astGetTitle(%s): Corrupt %s contains "
+		      "invalid sky coordinate system identification code "
+		      "(%d).", status, astGetClass( this ), astGetClass( this ),
+		     (int) system );
+	    break;
+         }
+
+/* If OK, we add either a description of the sky projection, or (if used)
+   a description of the origin or pole of the offset coordinate system.
+   We include only one of these two strings in order to keep the length
+   of the title down to a reasonable value.*/
+         if ( astOK ) {
+
+/* If the SkyRef attribute has set values, create a description of the offset
+   coordinate system. */
+            if( offset ){
+               word = ( astGetSkyRefIs( this ) == AST__POLE_REF )?"pole":"origin";
+               lextra = sprintf( gettitle_buff2, "%s at %s ", word,
+                           astFormat( this, 0, astGetSkyRef( this, 0 ) ) );
+               lextra += sprintf( gettitle_buff2 + lextra, "%s",
+                           astFormat( this, 1, astGetSkyRef( this, 1 ) ) );
+               extra = gettitle_buff2;
+
+/* Otherwise, get the sky projection description. */
+            } else {
+               extra = projection;
+
+/* Determine the length of the extra information, after removing trailing
+   white space. */
+               for ( lextra = (int) strlen( extra ); lextra > 0; lextra-- ) {
+                  if ( !isspace( extra[ lextra - 1 ] ) ) break;
+               }
+            }
+
+/* If non-blank extra information is available, append it to the title string,
+   checking that the end of the buffer is not over-run. */
+            if ( lextra ) {
+               p = "; ";
+               while ( ( pos < AST__SKYFRAME_GETTITLE_BUFF_LEN ) && *p ) gettitle_buff[ pos++ ] = *p++;
+               p = extra;
+               while ( ( pos < AST__SKYFRAME_GETTITLE_BUFF_LEN ) &&
+                       ( p < ( extra + lextra ) ) ) gettitle_buff[ pos++ ] = *p++;
+               if( extra == projection ) {
+                  p = " projection";
+                  while ( ( pos < AST__SKYFRAME_GETTITLE_BUFF_LEN ) && *p ) gettitle_buff[ pos++ ] = *p++;
+               }
+               gettitle_buff[ pos ] = '\0';
+            }
+         }
+      }
+   }
+
+/* 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 SkyFrame's axis.
+
+*  Type:
+*     Private function.
+
+*  Synopsis:
+*     #include "skyframe.h"
+*     const char *GetUnit( AstFrame *this_frame, int axis )
+
+*  Class Membership:
+*     SkyFrame 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 SkyFrame. If the Unit attribute has not been set for the axis, a
+*     pointer to a suitable default string is returned instead. This string may
+*     depend on the value of the Format attribute for the axis and, in turn, on
+*     the type of sky coordinate system that the SkyFrame describes.
+
+*  Parameters:
+*     this
+*        Pointer to the SkyFrame.
+*     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: */
+   AstSkyFrame *this;            /* Pointer to the SkyFrame structure */
+   const char *result;           /* Pointer value to return */
+   int format_set;               /* Format attribute set? */
+
+/* Check the global error status. */
+   if ( !astOK ) return NULL;
+
+/* Obtain a pointer to the SkyFrame structure. */
+   this = (AstSkyFrame *) this_frame;
+
+/* Validate the axis index. */
+   (void) astValidateAxis( this, axis, 1, "astGetUnit" );
+
+/* The Unit value may depend on the value of the Format attribute, so
+   determine if a Format value has been set for the axis and set a
+   temporary value if it has not. Use the GetFormat member function
+   for this class together with member functions inherited from the
+   parent class (rather than using the object's methods directly)
+   because if any of these methods have been over-ridden by a derived
+   class the Format string syntax may no longer be compatible with
+   this class. */
+   format_set = (*parent_testformat)( this_frame, axis, status );
+   if ( !format_set ) {
+      (*parent_setformat)( this_frame, axis, GetFormat( this_frame, axis, status ), status );
+   }
+
+/* Use the parent GetUnit method to return a pointer to the required Unit
+   string. */
+   result = (*parent_getunit)( this_frame, axis, status );
+
+/* If necessary, clear any temporary Format value that was set above. */
+   if ( !format_set ) (*parent_clearformat)( this_frame, axis, status );
+
+/* If an error occurred, clear the returned value. */
+   if ( !astOK ) result = NULL;
+
+/* Return the result. */
+   return result;
+}
+
+void astInitSkyFrameVtab_(  AstSkyFrameVtab *vtab, const char *name, int *status ) {
+/*
+*+
+*  Name:
+*     astInitSkyFrameVtab
+
+*  Purpose:
+*     Initialise a virtual function table for a SkyFrame.
+
+*  Type:
+*     Protected function.
+
+*  Synopsis:
+*     #include "skyframe.h"
+*     void astInitSkyFrameVtab( AstSkyFrameVtab *vtab, const char *name )
+
+*  Class Membership:
+*     SkyFrame vtab initialiser.
+
+*  Description:
+*     This function initialises the component of a virtual function
+*     table which is used by the SkyFrame 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 */
+   AstObjectVtab *object;        /* Pointer to Object component of Vtab */
+   int stat;                     /* SLALIB status */
+
+/* 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 astIsASkyFrame) 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->ClearAsTime = ClearAsTime;
+   vtab->ClearEquinox = ClearEquinox;
+   vtab->ClearNegLon = ClearNegLon;
+   vtab->ClearProjection = ClearProjection;
+   vtab->GetAsTime = GetAsTime;
+   vtab->GetEquinox = GetEquinox;
+   vtab->GetNegLon = GetNegLon;
+   vtab->GetIsLatAxis = GetIsLatAxis;
+   vtab->GetIsLonAxis = GetIsLonAxis;
+   vtab->GetLatAxis = GetLatAxis;
+   vtab->GetLonAxis = GetLonAxis;
+   vtab->GetProjection = GetProjection;
+   vtab->SetAsTime = SetAsTime;
+   vtab->SetEquinox = SetEquinox;
+   vtab->SetNegLon = SetNegLon;
+   vtab->SetProjection = SetProjection;
+   vtab->SkyOffsetMap = SkyOffsetMap;
+   vtab->TestAsTime = TestAsTime;
+   vtab->TestEquinox = TestEquinox;
+   vtab->TestNegLon = TestNegLon;
+   vtab->TestProjection = TestProjection;
+
+   vtab->TestSkyTol = TestSkyTol;
+   vtab->SetSkyTol = SetSkyTol;
+   vtab->GetSkyTol = GetSkyTol;
+   vtab->ClearSkyTol = ClearSkyTol;
+
+   vtab->TestSkyRef = TestSkyRef;
+   vtab->SetSkyRef = SetSkyRef;
+   vtab->GetSkyRef = GetSkyRef;
+   vtab->ClearSkyRef = ClearSkyRef;
+
+   vtab->TestSkyRefP = TestSkyRefP;
+   vtab->SetSkyRefP = SetSkyRefP;
+   vtab->GetSkyRefP = GetSkyRefP;
+   vtab->ClearSkyRefP = ClearSkyRefP;
+
+   vtab->TestSkyRefIs = TestSkyRefIs;
+   vtab->SetSkyRefIs = SetSkyRefIs;
+   vtab->GetSkyRefIs = GetSkyRefIs;
+   vtab->ClearSkyRefIs = ClearSkyRefIs;
+
+   vtab->TestAlignOffset = TestAlignOffset;
+   vtab->SetAlignOffset = SetAlignOffset;
+   vtab->GetAlignOffset = GetAlignOffset;
+   vtab->ClearAlignOffset = ClearAlignOffset;
+
+/* 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_getobjsize = object->GetObjSize;
+   object->GetObjSize = GetObjSize;
+
+   parent_clearattrib = object->ClearAttrib;
+   object->ClearAttrib = ClearAttrib;
+   parent_getattrib = object->GetAttrib;
+   object->GetAttrib = GetAttrib;
+   parent_setattrib = object->SetAttrib;
+   object->SetAttrib = SetAttrib;
+   parent_testattrib = object->TestAttrib;
+   object->TestAttrib = TestAttrib;
+
+   parent_gettop = frame->GetTop;
+   frame->GetTop = GetTop;
+
+   parent_setobsalt = frame->SetObsAlt;
+   frame->SetObsAlt = SetObsAlt;
+
+   parent_setobslat = frame->SetObsLat;
+   frame->SetObsLat = SetObsLat;
+
+   parent_setobslon = frame->SetObsLon;
+   frame->SetObsLon = SetObsLon;
+
+   parent_clearobslon = frame->ClearObsLon;
+   frame->ClearObsLon = ClearObsLon;
+
+   parent_clearobsalt = frame->ClearObsAlt;
+   frame->ClearObsAlt = ClearObsAlt;
+
+   parent_clearobslat = frame->ClearObsLat;
+   frame->ClearObsLat = ClearObsLat;
+
+   parent_getbottom = frame->GetBottom;
+   frame->GetBottom = GetBottom;
+
+   parent_getepoch = frame->GetEpoch;
+   frame->GetEpoch = GetEpoch;
+
+   parent_format = frame->Format;
+   frame->Format = Format;
+   parent_gap = frame->Gap;
+   frame->Gap = Gap;
+   parent_getdirection = frame->GetDirection;
+   frame->GetDirection = GetDirection;
+   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_getformat = frame->GetFormat;
+   frame->GetFormat = GetFormat;
+   parent_getlabel = frame->GetLabel;
+   frame->GetLabel = GetLabel;
+   parent_getsymbol = frame->GetSymbol;
+   frame->GetSymbol = GetSymbol;
+   parent_gettitle = frame->GetTitle;
+   frame->GetTitle = GetTitle;
+   parent_getunit = frame->GetUnit;
+   frame->GetUnit = GetUnit;
+   parent_match = frame->Match;
+   frame->Match = Match;
+   parent_overlay = frame->Overlay;
+   frame->Overlay = Overlay;
+   parent_subframe = frame->SubFrame;
+   frame->SubFrame = SubFrame;
+   parent_unformat = frame->Unformat;
+   frame->Unformat = Unformat;
+
+   parent_setdtai = frame->SetDtai;
+   frame->SetDtai = SetDtai;
+   parent_setdut1 = frame->SetDut1;
+   frame->SetDut1 = SetDut1;
+
+   parent_cleardtai = frame->ClearDtai;
+   frame->ClearDtai = ClearDtai;
+   parent_cleardut1 = frame->ClearDut1;
+   frame->ClearDut1 = ClearDut1;
+
+/* Store replacement pointers for methods which will be over-ridden by new
+   member functions implemented here. */
+   frame->Angle = Angle;
+   frame->Distance = Distance;
+   frame->FrameGrid = FrameGrid;
+   frame->Intersect = Intersect;
+   frame->Norm = Norm;
+   frame->NormBox = NormBox;
+   frame->Resolve = Resolve;
+   frame->ResolvePoints = ResolvePoints;
+   frame->Offset = Offset;
+   frame->Offset2 = Offset2;
+   frame->ValidateSystem = ValidateSystem;
+   frame->SystemString = SystemString;
+   frame->SystemCode = SystemCode;
+   frame->LineDef = LineDef;
+   frame->LineContains = LineContains;
+   frame->LineCrossing = LineCrossing;
+   frame->LineOffset = LineOffset;
+   frame->GetActiveUnit = GetActiveUnit;
+   frame->TestActiveUnit = TestActiveUnit;
+   frame->MatchAxesX = MatchAxesX;
+
+/* Store pointers to inherited methods that will be invoked explicitly
+   by this class. */
+   parent_clearformat = frame->ClearFormat;
+   parent_setformat = frame->SetFormat;
+   parent_testformat = frame->TestFormat;
+
+/* Declare the copy constructor, destructor and class dump
+   function. */
+   astSetCopy( vtab, Copy );
+   astSetDelete( vtab, Delete );
+   astSetDump( vtab, Dump, "SkyFrame",
+               "Description of celestial coordinate system" );
+
+/* Initialize constants for converting between hours, degrees and
+   radians, etc.. */
+   LOCK_MUTEX2
+   palDtf2r( 1, 0, 0.0, &hr2rad, &stat );
+   palDaf2r( 1, 0, 0.0, &deg2rad, &stat );
+   palDaf2r( 180, 0, 0.0, &pi, &stat );
+   piby2 = 0.5*pi;
+   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 void Intersect( AstFrame *this_frame, const double a1[2],
+                       const double a2[2], const double b1[2],
+                       const double b2[2], double cross[2],
+                       int *status ) {
+/*
+*  Name:
+*     Intersect
+
+*  Purpose:
+*     Find the point of intersection between two geodesic curves.
+
+*  Type:
+*     Private function.
+
+*  Synopsis:
+*     #include "skyframe.h"
+*     void Intersect( AstFrame *this_frame, const double a1[2],
+*                      const double a2[2], const double b1[2],
+*                      const double b2[2], double cross[2],
+*                      int *status )
+
+*  Class Membership:
+*     SkyFrame member function (over-rides the astIntersect method
+*     inherited from the Frame class).
+
+*  Description:
+*     This function finds the coordinate values at the point of
+*     intersection between two geodesic curves. Each curve is specified
+*     by two points on the curve.
+
+*  Parameters:
+*     this
+*        Pointer to the SkyFrame.
+*     a1
+*        An array of double, with one element for each Frame axis.
+*        This should contain the coordinates of a point on the first
+*        geodesic curve.
+*     a2
+*        An array of double, with one element for each Frame axis.
+*        This should contain the coordinates of a second point on the
+*        first geodesic curve.
+*     b1
+*        An array of double, with one element for each Frame axis.
+*        This should contain the coordinates of a point on the second
+*        geodesic curve.
+*     b2
+*        An array of double, with one element for each Frame axis.
+*        This should contain the coordinates of a second point on
+*        the second geodesic curve.
+*     cross
+*        An array of double, with one element for each Frame axis
+*        in which the coordinates of the required intersection
+*        point will be returned. These will be AST__BAD if the curves do
+*        not intersect.
+*     status
+*        Pointer to the inherited status variable.
+
+*  Notes:
+*     - The geodesic curve used by this function is the path of
+*     shortest distance between two points, as defined by the
+*     astDistance function.
+*     - This function will return "bad" coordinate values (AST__BAD)
+*     if any of the input coordinates has this value.
+*     - For SkyFrames each curve will be a great circle, and in general
+*     each pair of curves will intersect at two diametrically opposite
+*     points on the sky. The returned position is the one which is
+*     closest to point "a1".
+*/
+
+/* Local Variables: */
+   AstSkyFrame *this;          /* Pointer to the SkyFrame structure */
+   const int *perm;            /* Pointer to axis permutation array */
+   double aa1[ 2 ];            /* Permuted coordinates for a1 */
+   double aa2[ 2 ];            /* Permuted coordinates for a2 */
+   double bb1[ 2 ];            /* Permuted coordinates for b1 */
+   double bb2[ 2 ];            /* Permuted coordinates for b2 */
+   double cc[ 2 ];             /* Permuted coords at intersection */
+   double d1;                  /* Cos(distance from a1 to vp) */
+   double d2;                  /* Cos(distance from a1 to -vp) */
+   double na[ 3 ];             /* Normal to the a1/a2 great circle */
+   double nb[ 3 ];             /* Normal to the b1/b2 great circle */
+   double va1[ 3 ];            /* Vector pointing at a1 */
+   double va2[ 3 ];            /* Vector pointing at a2 */
+   double vb1[ 3 ];            /* Vector pointing at b1 */
+   double vb2[ 3 ];            /* Vector pointing at b2 */
+   double vmod;                /* Length of "vp" */
+   double vp[ 3 ];             /* Vector pointing at the intersection */
+   double vpn[ 3 ];            /* Normalised vp */
+   int iaxis;                  /* Axis index */
+
+/* Initialise. */
+   cross[ 0 ] = AST__BAD;
+   cross[ 1 ] = AST__BAD;
+
+/* Check the global error status. */
+   if ( !astOK ) return;
+
+/* Obtain a pointer to the SkyFrame structure. */
+   this = (AstSkyFrame *) this_frame;
+
+/* Check that all supplied values are OK. */
+   if ( ( a1[ 0 ] != AST__BAD ) && ( a1[ 1 ] != AST__BAD ) &&
+        ( a2[ 0 ] != AST__BAD ) && ( a2[ 1 ] != AST__BAD ) &&
+        ( b1[ 0 ] != AST__BAD ) && ( b1[ 1 ] != AST__BAD ) &&
+        ( b2[ 0 ] != AST__BAD ) && ( b2[ 1 ] != AST__BAD ) ) {
+
+/* Obtain a pointer to the SkyFrame's axis permutation array. */
+      perm = astGetPerm( this );
+      if ( astOK ) {
+
+/* Apply the axis permutation array to obtain the coordinates of
+   the points in the required (longitude,latitude) order. */
+         for( iaxis = 0; iaxis < 2; iaxis++ ) {
+            aa1[ perm[ iaxis ] ] = a1[ iaxis ];
+            aa2[ perm[ iaxis ] ] = a2[ iaxis ];
+            bb1[ perm[ iaxis ] ] = b1[ iaxis ];
+            bb2[ perm[ iaxis ] ] = b2[ iaxis ];
+         }
+
+/* Convert each (lon,lat) pair into a unit length 3-vector. */
+         palDcs2c( aa1[ 0 ], aa1[ 1 ], va1 );
+         palDcs2c( aa2[ 0 ], aa2[ 1 ], va2 );
+         palDcs2c( bb1[ 0 ], bb1[ 1 ], vb1 );
+         palDcs2c( bb2[ 0 ], bb2[ 1 ], vb2 );
+
+/* Find the normal vectors to the two great cicles. */
+         palDvxv( va1, va2, na );
+         palDvxv( vb1, vb2, nb );
+
+/* The cross product of the two normal vectors points to one of the
+   two diametrically opposite intersections. */
+         palDvxv( na, nb, vp );
+
+/* Normalise the "vp" vector, also obtaining its original modulus. */
+         palDvn( vp, vpn, &vmod );
+         if( vmod != 0.0 ) {
+
+/* We want the intersection which is closest to "a1". The dot product
+   gives the cos(distance) between two positions. So find the dot
+   product between "a1" and "vpn", and then between "a1" and the point
+   diametrically opposite "vpn". */
+            d1 = palDvdv( vpn, va1 );
+            vpn[ 0 ] = -vpn[ 0 ];
+            vpn[ 1 ] = -vpn[ 1 ];
+            vpn[ 2 ] = -vpn[ 2 ];
+            d2 = palDvdv( vpn, va1 );
+
+/* Revert to "vpn" if it is closer to "a1". */
+            if( d1 > d2 ) {
+               vpn[ 0 ] = -vpn[ 0 ];
+               vpn[ 1 ] = -vpn[ 1 ];
+               vpn[ 2 ] = -vpn[ 2 ];
+            }
+
+/* Convert the vector back into a (lon,lat) pair, and put the longitude
+   into the range 0 to 2.pi. */
+            palDcc2s( vpn, cc, cc + 1 );
+            *cc = palDranrm( *cc );
+
+/* Permute the result coordinates to undo the effect of the SkyFrame
+   axis permutation array. */
+            cross[ 0 ] = cc[ perm[ 0 ] ];
+            cross[ 1 ] = cc[ perm[ 1 ] ];
+         }
+      }
+   }
+}
+
+static int IsEquatorial( AstSystemType system, int *status ) {
+/*
+*  Name:
+*     IsEquatorial
+
+*  Purpose:
+*     Test for an equatorial sky coordinate system.
+
+*  Type:
+*     Private function.
+
+*  Synopsis:
+*     #include "skyframe.h"
+*     int IsEquatorial( AstSystemType system, int *status )
+
+*  Class Membership:
+*     SkyFrame member function.
+
+*  Description:
+*     This function returns a boolean value to indicate if a sky coordinate
+*     system is equatorial.
+
+*  Parameters:
+*     system
+*        Code to identify the sky coordinate system.
+*     status
+*        Pointer to the inherited status variable.
+
+*  Returned Value:
+*     Non-zero if the sky coordinate system is equatorial, otherwise zero.
+
+*  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: */
+   int result;                   /* Result value to return */
+
+/* Check the global error status. */
+   if ( !astOK ) return 0;
+
+/* Determine if the sky coordinate system is an equatorial one. Note,
+   ICRS is not equatorial by definition, but is included here because it
+   is normally treated as an equatorial system in terms of the axis
+   labels, formats, etc. */
+   result = ( ( system == AST__FK4 ) ||
+              ( system == AST__FK4_NO_E ) ||
+              ( system == AST__ICRS ) ||
+              ( system == AST__FK5 ) ||
+              ( system == AST__J2000 ) ||
+              ( system == AST__GAPPT ) );
+
+/* Return the result. */
+   return result;
+}
+
+static int LineContains( AstFrame *this, AstLineDef *l, int def, double *point, int *status ) {
+/*
+*  Name:
+*     LineContains
+
+*  Purpose:
+*     Determine if a line contains a point.
+
+*  Type:
+*     Private function.
+
+*  Synopsis:
+*     #include "skyframe.h"
+*     int LineContains( AstFrame *this, AstLineDef *l, int def, double *point, int *status )
+
+*  Class Membership:
+*     SkyFrame member function (over-rides the protected astLineContains
+*     method inherited from the Frame class).
+
+*  Description:
+*     This function determines if the supplied point is on the supplied
+*     line within the supplied Frame. The start point of the line is
+*     considered to be within the line, but the end point is not. The tests
+*     are that the point of closest approach of the line to the point should
+*     be between the start and end, and that the distance from the point to
+*     the point of closest aproach should be less than 1.0E-7 of the length
+*     of the line.
+
+*  Parameters:
+*     this
+*        Pointer to the Frame.
+*     l
+*        Pointer to the structure defining the line.
+*     def
+*        Should be set non-zero if the "point" array was created by a
+*        call to astLineCrossing (in which case it may contain extra
+*        information following the axis values),and zero otherwise.
+*     point
+*        Point to an array containing the axis values of the point to be
+*        tested, possibly followed by extra cached information (see "def").
+*     status
+*        Pointer to the inherited status variable.
+
+*  Returned Value:
+*     A non-zero value is returned if the line contains the point.
+
+*  Notes:
+*     - The pointer supplied for "l" should have been created using the
+*     astLineDef method. These structures contained cached information about
+*     the lines which improve the efficiency of this method when many
+*     repeated calls are made. An error will be reported if the structure
+*     does not refer to the Frame specified by "this".
+*     - 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: */
+   SkyLineDef *sl;               /* SkyLine information */
+   const int *perm;              /* Pointer to axis permutation array */
+   double *b;                    /* Pointer to Cartesian coords array */
+   double bb[3];                 /* Buffer for Cartesian coords */
+   double p1[2];                 /* Buffer for Spherical coords */
+   double t1, t2;
+   int result;                   /* Returned value */
+
+/* Initialise */
+   result =0;
+
+/* Check the global error status. */
+   if ( !astOK ) return result;
+
+/* Check that the line refers to the supplied Frame. */
+   if( l->frame != this ) {
+      astError( AST__INTER, "astLineContains(%s): The supplied line does "
+                "not relate to the supplied %s (AST internal programming "
+                "error).", status, astGetClass( this ), astGetClass( this ) );
+
+/* Check the axis values are good */
+   } else if( point[ 0 ] != AST__BAD && point[ 1 ] != AST__BAD ){
+
+/* Get a pointer to an array holding the corresponding Cartesian coords. */
+      if( def ) {
+         b = point + 2;
+
+      } else {
+         perm = astGetPerm( this );
+         if ( perm ) {
+            p1[ perm[ 0 ] ] = point[ 0 ];
+            p1[ perm[ 1 ] ] = point[ 1 ];
+            palDcs2c( p1[ 0 ], p1[ 1 ], bb );
+            b = bb;
+         } else {
+            b = NULL;
+         }
+      }
+
+/* Recast the supplied AstLineDef into a SkyLineDef to get the different
+   structure (we know from the above check on the Frame that it is safe to
+   do this). */
+      sl = (SkyLineDef *) l;
+
+/* Check that the point of closest approach of the line to the point is
+   within the limits of the line. */
+      if( LineIncludes( sl, b, status ) ){
+
+/* Check that the point is 90 degrees away from the pole of the great
+   circle containing the line. */
+        t1 = palDvdv( sl->q, b );
+        t2 = 1.0E-7*sl->length;
+        if( t2 < 1.0E-10 ) t2 = 1.0E-10;
+        if( fabs( t1 ) <= t2 ) result = 1;
+     }
+   }
+
+/* Return the result. */
+   return result;
+}
+
+static int LineCrossing( AstFrame *this, AstLineDef *l1, AstLineDef *l2,
+                         double **cross, int *status ) {
+/*
+*  Name:
+*     LineCrossing
+
+*  Purpose:
+*     Determine if two lines cross.
+
+*  Type:
+*     Private function.
+
+*  Synopsis:
+*     #include "skyframe.h"
+*     int LineCrossing( AstFrame *this, AstLineDef *l1, AstLineDef *l2,
+*                       double **cross, int *status )
+
+*  Class Membership:
+*     SkyFrame member function (over-rides the protected astLineCrossing
+*     method inherited from the Frame class).
+
+*  Description:
+*     This function determines if the two suplied line segments cross,
+*     and if so returns the axis values at the point where they cross.
+*     A flag is also returned indicating if the crossing point occurs
+*     within the length of both line segments, or outside one or both of
+*     the line segments.
+
+*  Parameters:
+*     this
+*        Pointer to the Frame.
+*     l1
+*        Pointer to the structure defining the first line.
+*     l2
+*        Pointer to the structure defining the second line.
+*     cross
+*        Pointer to a location at which to put a pointer to a dynamically
+*        alocated array containing the axis values at the crossing. If
+*        NULL is supplied no such array is returned. Otherwise, the returned
+*        array should be freed using astFree when no longer needed. If the
+*        lines are parallel (i.e. do not cross) then AST__BAD is returned for
+*        all axis values. Note usable axis values are returned even if the
+*        lines cross outside the segment defined by the start and end points
+*        of the lines. The order of axes in the returned array will take
+*        account of the current axis permutation array if appropriate. Note,
+*        sub-classes such as SkyFrame may append extra values to the end
+*        of the basic frame axis values. A NULL pointer is returned if an
+*        error occurs.
+*     status
+*        Pointer to the inherited status variable.
+
+*  Returned Value:
+*     A non-zero value is returned if the lines cross at a point which is
+*     within the [start,end) segment of both lines. If the crossing point
+*     is outside this segment on either line, or if the lines are parallel,
+*     zero is returned. Note, the start point is considered to be inside
+*     the length of the segment, but the end point is outside.
+
+*  Notes:
+*     - The pointers supplied for "l1" and "l2" should have been created
+*     using the astLineDef method. These structures contained cached
+*     information about the lines which improve the efficiency of this method
+*     when many repeated calls are made. An error will be reported if
+*     either structure does not refer to the Frame specified by "this".
+*     - 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: */
+   SkyLineDef *sl1;              /* SkyLine information for line 1 */
+   SkyLineDef *sl2;              /* SkyLine information for line 2 */
+   const int *perm;              /* Pointer to axis permutation array */
+   double *crossing;             /* Pointer to returned array */
+   double *b;                    /* Pointer to Cartesian coords */
+   double len;                   /* Vector length */
+   double p[ 2 ];                /* Temporary (lon,lat) pair */
+   double temp[ 3 ];             /* Temporary vector */
+   int result;                   /* Returned value */
+
+/* Initialise */
+   result = 0;
+   if( cross ) *cross = NULL;
+
+/* Check the global error status. */
+   if ( !astOK ) return result;
+
+/* Allocate returned array (2 elements for the lon and lat values, plus 3
+   for the corresponding (x,y,z) coords). */
+   crossing = astMalloc( sizeof(double)*5 );
+
+/* Check that both lines refer to the supplied Frame. */
+   if( l1->frame != this ) {
+      astError( AST__INTER, "astLineCrossing(%s): First supplied line does "
+                "not relate to the supplied %s (AST internal programming "
+                "error).", status, astGetClass( this ), astGetClass( this ) );
+
+   } else if( l2->frame != this ) {
+      astError( AST__INTER, "astLineCrossing(%s): Second supplied line does "
+                "not relate to the supplied %s (AST internal programming "
+                "error).", status, astGetClass( this ), astGetClass( this ) );
+
+/* Recast the supplied AstLineDefs into a SkyLineDefs to get the different
+   structure (we know from the above check on the Frame that it is safe to
+   do this). */
+   } else if( crossing ){
+      sl1 = (SkyLineDef *) l1;
+      sl2 = (SkyLineDef *) l2;
+
+/* Point of intersection of the two great circles is perpendicular to the
+   pole vectors of both great circles. Put the Cartesian coords in elements
+   2 to 4 of the returned array. */
+      palDvxv( sl1->q, sl2->q, temp );
+      b = crossing + 2;
+      palDvn( temp, b, &len );
+
+/* See if this point is within the length of both arcs. If so return it. */
+      if( LineIncludes( sl2, b, status ) && LineIncludes( sl1, b, status ) ) {
+         result = 1;
+
+/* If not, see if the negated b vector is within the length of both arcs.
+   If so return it. Otherwise, we return zero. */
+      } else {
+         b[ 0 ] *= -1.0;
+         b[ 1 ] *= -1.0;
+         b[ 2 ] *= -1.0;
+         if( LineIncludes( sl2, b, status ) && LineIncludes( sl1, b, status ) ) result = 1;
+      }
+
+/* Store the spherical coords in elements 0 and 1 of the returned array. */
+      palDcc2s( b, p, p + 1 );
+
+/* Permute the spherical axis value into the order used by the SkyFrame. */
+      perm = astGetPerm( this );
+      if( perm ){
+         crossing[ 0 ] = p[ perm[ 0 ] ];
+         crossing[ 1 ] = p[ perm[ 1 ] ];
+      }
+   }
+
+/* If an error occurred, return 0. */
+   if( !astOK ) {
+      result = 0;
+      crossing = astFree( crossing );
+   }
+
+/* Return the array */
+   if( cross ) {
+      *cross = crossing;
+   } else {
+      crossing = astFree( crossing );
+   }
+
+/* Return the result. */
+   return result;
+}
+
+static AstLineDef *LineDef( AstFrame *this, const double start[2],
+                            const double end[2], int *status ) {
+/*
+*  Name:
+*     LineDef
+
+*  Purpose:
+*     Creates a structure describing a line segment in a 2D Frame.
+
+*  Type:
+*     Private function.
+
+*  Synopsis:
+*     #include "skyframe.h"
+*     AstLineDef *LineDef( AstFrame *this, const double start[2],
+*                          const double end[2], int *status )
+
+*  Class Membership:
+*     SkyFrame member function (over-rides the protected astLineDef
+*     method inherited from the Frame class).
+
+*  Description:
+*     This function creates a structure containing information describing a
+*     given line segment within the supplied 2D Frame. This may include
+*     information which allows other methods such as astLineCrossing to
+*     function more efficiently. Thus the returned structure acts as a
+*     cache to store intermediate values used by these other methods.
+
+*  Parameters:
+*     this
+*        Pointer to the Frame. Must have 2 axes.
+*     start
+*        An array of 2 doubles marking the start of the line segment.
+*     end
+*        An array of 2 doubles marking the end of the line segment.
+*     status
+*        Pointer to the inherited status variable.
+
+*  Returned Value:
+*     Pointer to the memory structure containing the description of the
+*     line. This structure should be freed using astFree when no longer
+*     needed. A NULL pointer is returned (without error) if any of the
+*     supplied axis values are AST__BAD.
+
+*  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: */
+   SkyLineDef *result;           /* Returned value */
+   const int *perm;              /* Axis permutation array */
+   double le;                    /* Length of end vector */
+   double len;                   /* Permuted point1 coordinates */
+   double ls;                    /* Length of start vector */
+   double p1[ 2 ];               /* Permuted point1 coordinates */
+   double p2[ 2 ];               /* Permuted point2 coordinates */
+   double temp[3];               /* Cartesian coords at offset position */
+
+/* Initialise */
+   result = NULL;
+
+/* Check the global error status. */
+   if ( !astOK ) return NULL;
+
+/* Check the axis values are good */
+   if( start[ 0 ] != AST__BAD && start[ 1 ] != AST__BAD &&
+       end[ 0 ] != AST__BAD && end[ 1 ] != AST__BAD ) {
+
+/* Allocate memory for the returned structure. */
+      result = astMalloc( sizeof( SkyLineDef ) );
+
+/* Obtain a pointer to the SkyFrame's axis permutation array. */
+      perm = astGetPerm( this );
+      if ( perm ) {
+
+/* Apply the axis permutation array to obtain the coordinates of the two
+   input points in the required (longitude,latitude) order. */
+         p1[ perm[ 0 ] ] = start[ 0 ];
+         p1[ perm[ 1 ] ] = start[ 1 ];
+         p2[ perm[ 0 ] ] = end[ 0 ];
+         p2[ perm[ 1 ] ] = end[ 1 ];
+
+/* Convert each point into a 3-vector of unit length and store in the
+   returned structure. */
+         palDcs2c( p1[ 0 ], p1[ 1 ], result->start );
+         palDcs2c( p2[ 0 ], p2[ 1 ], result->end );
+
+/* Calculate the great circle distance between the points in radians and
+   store in the result structure. Correct for rounding errors in palDcs2c
+   that can result in the vectors not having exactly unit length. */
+         result->length = palDvdv( result->start, result->end );
+         ls = result->start[0]*result->start[0] +
+              result->start[1]*result->start[1] +
+              result->start[2]*result->start[2];
+         le = result->end[0]*result->end[0] +
+              result->end[1]*result->end[1] +
+              result->end[2]*result->end[2];
+         result->length = acos( result->length/sqrt( ls*le ) );
+
+/* Find a unit vector representing the pole of the system in which the
+   equator is given by the great circle. This is such that going the
+   short way from the start to the end, the pole is to the left of the
+   line as seen by the observer (i.e. from the centre of the sphere).
+   If the line has zero length, or 180 degrees length, the pole is
+   undefined, so we use an arbitrary value. */
+         if( result->length == 0.0 || result->length > pi - 5.0E-11 ) {
+            palDcs2c( p1[ 0 ] + 0.01, p1[ 1 ] + 0.01, temp );
+            palDvxv( temp, result->start, result->dir );
+         } else {
+            palDvxv( result->end, result->start, result->dir );
+         }
+         palDvn( result->dir, result->q, &len );
+
+/* Also store a point which is 90 degrees along the great circle from the
+   start. */
+         palDvxv( result->start, result->q, result->dir );
+
+/* Store a pointer to the defining SkyFrame. */
+         result->frame = this;
+
+/* Indicate that the line is considered to be terminated at the start and
+   end points. */
+         result->infinite = 0;
+
+/* Normalise the spherical start and end positions stored in the returned
+   structure. */
+         result->start_2d[ 0 ] = start[ 0 ];
+         result->start_2d[ 1 ] = start[ 1 ];
+         result->end_2d[ 0 ] = end[ 0 ];
+         result->end_2d[ 1 ] = end[ 1 ];
+
+         astNorm( this, result->start_2d );
+         astNorm( this, result->end_2d );
+      }
+   }
+
+/* Free the returned pointer if an error occurred. */
+   if( !astOK ) result = astFree( result );
+
+/* Return a pointer to the output structure. */
+   return (AstLineDef *) result;
+}
+
+static int LineIncludes( SkyLineDef *l, double point[3], int *status ) {
+/*
+*  Name:
+*     LineIncludes
+
+*  Purpose:
+*     Determine if a line includes a point which is known to be in the
+*     great circle.
+
+*  Type:
+*     Private function.
+
+*  Synopsis:
+*     #include "skyframe.h"
+*     int LineIncludes( SkyLineDef *l, double point[3], int *status )
+
+*  Class Membership:
+*     SkyFrame member function (over-rides the protected astLineIncludes
+*     method inherited from the Frame class).
+
+*  Description:
+*     The supplied point is assumed to be a point on the great circle of
+*     which the supplied line is a segment. This function returns true if
+*     "point" is within the bounds of the segment (the end point of the
+*     line is assumed * not to be part of the segment).
+
+*  Parameters:
+*     l
+*        Pointer to the structure defining the line.
+*     point
+*        An array holding the Cartesian coords of the point to be tested.
+*     status
+*        Pointer to the inherited status variable.
+
+*  Returned Value:
+*     A non-zero value is returned if the line includes the point.
+
+*  Notes:
+*     - Zero will be returned if this function is invoked with the global
+*     error status set, or if it should fail for any reason.
+*/
+
+/* Local Variables: */
+   double t1, t2, t3;
+
+/* Check the global error status. */
+   if ( !astOK ) return 0;
+
+/* If the line is of infite length, it is assumed to include the supplied
+   point. */
+   if( l->infinite ) return 1;
+
+/* Otherwise, get the unsigned distance of the point from the start of the
+   line in the range 0 - 180 degs. Check it is less than the line length.
+   Then check that the point is not more than 90 degs away from the quarter
+   point. */
+   t1 = palDvdv( l->start, point );
+   t2 = acos( t1 );
+   t3 = palDvdv( l->dir, point );
+   return ( ((l->length > 0) ? t2 < l->length : t2 == 0.0 ) && t3 >= -1.0E-8 );
+}
+
+static void LineOffset( AstFrame *this, AstLineDef *line, double par,
+                        double prp, double point[2], int *status ){
+/*
+*  Name:
+*     LineOffset
+
+*  Purpose:
+*     Find a position close to a line.
+
+*  Type:
+*     Private function.
+
+*  Synopsis:
+*     #include "skyframe.h"
+*     void LineOffset( AstFrame *this, AstLineDef *line, double par,
+*                      double prp, double point[2], int *status )
+
+*  Class Membership:
+*     SkyFrame member function (over-rides the protected astLineOffset
+*     method inherited from the Frame class).
+
+*  Description:
+*     This function returns a position formed by moving a given distance along
+*     the supplied line, and then a given distance away from the supplied line.
+
+*  Parameters:
+*     this
+*        Pointer to the Frame.
+*     line
+*        Pointer to the structure defining the line.
+*     par
+*        The distance to move along the line from the start towards the end.
+*     prp
+*        The distance to move at right angles to the line. Positive
+*        values result in movement to the left of the line, as seen from
+*        the observer, when moving from start towards the end.
+*     status
+*        Pointer to the inherited status variable.
+
+*  Notes:
+*     - The pointer supplied for "line" should have been created using the
+*     astLineDef method. This structure contains cached information about the
+*     line which improves the efficiency of this method when many repeated
+*     calls are made. An error will be reported if the structure does not
+*     refer to the Frame specified by "this".
+*-
+*/
+
+/* Local Variables; */
+    SkyLineDef *sl;
+    const int *perm;
+    double c;
+    double nx;
+    double ny;
+    double nz;
+    double p[2];
+    double s;
+    double v[3];
+
+/* Check the global error status. */
+   if ( !astOK ) return;
+
+/* Check that the line refers to the supplied Frame. */
+   if( line->frame != this ) {
+      astError( AST__INTER, "astLineOffset(%s): The supplied line does "
+                "not relate to the supplied %s (AST internal programming "
+                "error).", status, astGetClass( this ), astGetClass( this ) );
+
+/* This implementation uses spherical geometry. */
+   } else {
+
+/* Get a pointer to the SkyLineDef structure. */
+      sl = (SkyLineDef *) line;
+
+/* Move a distance par from start to end. */
+      c = cos( par );
+      s = sin( par );
+      nx = c * sl->start[ 0 ] + s * sl->dir[ 0 ];
+      ny = c * sl->start[ 1 ] + s * sl->dir[ 1 ];
+      nz = c * sl->start[ 2 ] + s * sl->dir[ 2 ];
+
+/* Move a distance prp from this point towards the pole point. */
+      if( prp != 0.0 ) {
+         c = cos( prp );
+         s = sin( prp );
+         v[ 0 ] = c * nx + s * sl->q[ 0 ];
+         v[ 1 ] = c * ny + s * sl->q[ 1 ];
+         v[ 2 ] = c * nz + s * sl->q[ 2 ];
+      } else {
+         v[ 0 ] = nx;
+         v[ 1 ] = ny;
+         v[ 2 ] = nz;
+      }
+
+/* Convert to lon/lat */
+      palDcc2s( v, p, p + 1 );
+
+/* Permute the spherical axis value into the order used by the SkyFrame. */
+      perm = astGetPerm( this );
+      if( perm ){
+         point[ 0 ] = p[ perm[ 0 ] ];
+         point[ 1 ] = p[ perm[ 1 ] ];
+      }
+   }
+}
+
+static int MakeSkyMapping( AstSkyFrame *target, AstSkyFrame *result,
+                           AstSystemType align_sys, AstMapping **map, int *status ) {
+/*
+*  Name:
+*     MakeSkyMapping
+
+*  Purpose:
+*     Generate a Mapping between two SkyFrames.
+
+*  Type:
+*     Private function.
+
+*  Synopsis:
+*     #include "skyframe.h"
+*     int MakeSkyMapping( AstSkyFrame *target, AstSkyFrame *result,
+*                         AstSystemType align_sys, AstMapping **map, int *status )
+
+*  Class Membership:
+*     SkyFrame member function.
+
+*  Description:
+*     This function takes two SkyFrames and generates a Mapping that
+*     converts between them, taking account of differences in their
+*     coordinate systems, equinox value, epoch, etc. (but not allowing
+*     for any axis permutations).
+
+*  Parameters:
+*     target
+*        Pointer to the first SkyFrame.
+*     result
+*        Pointer to the second SkyFrame.
+*     align_sys
+*        The system in which to align the two SkyFrames.
+*     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
+*     SkyFrames are sufficiently un-related that no meaningful Mapping
+*     can be produced.
+
+*  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 Constants: */
+#define MAX_ARGS 4               /* Max arguments for an SlaMap conversion */
+
+/* Local Variables: */
+   AstMapping *omap;             /* Mapping from coorinates to offsets */
+   AstMapping *tmap2;            /* Temporary Mapping */
+   AstMapping *tmap;             /* Temporary Mapping */
+   AstSlaMap *slamap;            /* Pointer to SlaMap */
+   AstSystemType result_system;  /* Code to identify result coordinate system */
+   AstSystemType system;         /* Code to identify coordinate system */
+   AstSystemType target_system;  /* Code to identify target coordinate system */
+   double args[ MAX_ARGS ];      /* Conversion argument array */
+   double epoch;                 /* Epoch as Modified Julian Date */
+   double epoch_B;               /* Besselian epoch as decimal years */
+   double epoch_J;               /* Julian epoch as decimal years */
+   double equinox;               /* Equinox as Modified Julian Date */
+   double equinox_B;             /* Besselian equinox as decimal years */
+   double equinox_J;             /* Julian equinox as decimal years */
+   double diurab;                /* Magnitude of diurnal aberration vector */
+   double last;                  /* Local Apparent Sidereal Time */
+   double lat;                   /* Observers latitude */
+   double result_epoch;          /* Result frame Epoch */
+   double result_equinox;        /* Result frame Epoch */
+   double target_epoch;          /* Target frame Epoch */
+   double target_equinox;        /* Target frame Epoch */
+   int isunit;                   /* Is the SlaMap effectively a unit mapping? */
+   int match;                    /* Mapping can be generated? */
+   int step1;                    /* Convert target to FK5 J2000? */
+   int step2;                    /* Convert FK5 J2000 to align sys? */
+   int step3;                    /* Convert align sys to FK5 J2000? */
+   int step4;                    /* Convert FK5 J2000 to result? */
+
+/* Check the global error status. */
+   if ( !astOK ) return 0;
+
+/* Initialise the returned values. */
+   match = 1;
+   *map = NULL;
+
+/* Initialise variables to avoid "used of uninitialised variable"
+   messages from dumb compilers. */
+   epoch_B = 0.0;
+   epoch_J = 0.0;
+   equinox_B = 0.0;
+   equinox_J = 0.0;
+
+/* Get the two epoch values. */
+   result_epoch = astGetEpoch( result );
+   target_epoch = astGetEpoch( target );
+
+/* Get the two equinox values. */
+   result_equinox = astGetEquinox( result );
+   target_equinox = astGetEquinox( target );
+
+/* Get the two system values. */
+   result_system = astGetSystem( result );
+   target_system = astGetSystem( target );
+
+/* If either system is not references to the equinox given by the Equinox
+   attribute, then use the equinox of the other system rather than
+   adopting the arbitrary default of J2000. */
+   if( !EQREF(result_system) ) result_equinox = target_equinox;
+   if( !EQREF(target_system) ) target_equinox = result_equinox;
+
+/* If both systems are unknown, assume they are the same. Return a UnitMap.
+   We need to do this, otherwise a simple change of Title (for instance)
+   will result in a FrameSet whose current Frame has System=AST__UNKNOWN
+   loosing its integrity. */
+   if( target_system == AST__UNKNOWN && result_system == AST__UNKNOWN ) {
+      *map = (AstMapping *) astUnitMap( 2, "", status );
+      return 1;
+   }
+
+/* The total Mapping is divided into two parts in series; the first part
+   converts from the target SkyFrame to the alignment system, using the
+   Epoch and Equinox of the target Frame, the second part converts from
+   the alignment system to the result SkyFrame, using the Epoch and Equinox
+   of the result Frame. Each of these parts has an arbitrary input and an
+   output system, and therefore could be implemented using a collection
+   of NxN conversions. To reduce the complexity, each part is implement
+   by converting from the input system to FK5 J2000, and then from FK5
+   J2000 to the output system. This scheme required only N conversions
+   rather than NxN. Thus overall the total Mapping is made up of 4 steps
+   in series. Some of these steps may be ommitted if they are effectively
+   a UnitMap. Determine which steps need to be included. Assume all need
+   to be done to begin with. */
+   step1 = 1;
+   step2 = 1;
+   step3 = 1;
+   step4 = 1;
+
+/* If the target system is the same as the alignment system, neither of the
+   first 2 steps need be done. */
+   if( target_system == align_sys ) {
+      step1 = 0;
+      step2 = 0;
+   }
+
+/* If the result system is the same as the alignment system, neither of the
+   last 2 steps need be done. */
+   if( result_system == align_sys ) {
+      step3 = 0;
+      step4 = 0;
+   }
+
+/* If the two epochs are the same, or if the alignment system is FK5 J2000,
+   steps 2 and 3 are not needed. */
+   if( step2 && step3 ) {
+      if( align_sys == AST__FK5 || result_epoch == target_epoch ) {
+      step2 = 0;
+      step3 = 0;
+      }
+   }
+
+/* None are needed if the target and result SkyFrames have the same
+   System, Epoch and Equinox. */
+   if(  result_system == target_system &&
+        result_epoch == target_epoch &&
+        result_equinox == target_equinox ) {
+      step1 = 0;
+      step2 = 0;
+      step3 = 0;
+      step4 = 0;
+   }
+
+/* Create an initial (null) SlaMap. */
+   slamap = astSlaMap( 0, "", status );
+
+/* Define local macros as shorthand for adding sky coordinate
+   conversions to this SlaMap.  Each macro simply stores details of
+   the additional arguments in the "args" array and then calls
+   astSlaAdd. The macros differ in the number of additional argument
+   values. */
+   #define TRANSFORM_0(cvt) \
+           astSlaAdd( slamap, cvt, 0, NULL );
+
+   #define TRANSFORM_1(cvt,arg0) \
+           args[ 0 ] = arg0; \
+           astSlaAdd( slamap, cvt, 1, args );
+
+   #define TRANSFORM_2(cvt,arg0,arg1) \
+           args[ 0 ] = arg0; \
+           args[ 1 ] = arg1; \
+           astSlaAdd( slamap, cvt, 2, args );
+
+   #define TRANSFORM_3(cvt,arg0,arg1,arg2) \
+           args[ 0 ] = arg0; \
+           args[ 1 ] = arg1; \
+           args[ 2 ] = arg2; \
+           astSlaAdd( slamap, cvt, 3, args );
+
+   #define TRANSFORM_4(cvt,arg0,arg1,arg2,arg3) \
+           args[ 0 ] = arg0; \
+           args[ 1 ] = arg1; \
+           args[ 2 ] = arg2; \
+           args[ 3 ] = arg3; \
+           astSlaAdd( slamap, cvt, 4, args );
+
+/* Convert _to_ FK5 J2000.0 coordinates. */
+/* ===================================== */
+/* The overall conversion is formulated in four phases. In this first
+   phase, we convert from the target coordinate system to intermediate sky
+   coordinates expressed using the FK5 system, mean equinox J2000.0. */
+
+/* Obtain the sky coordinate system, equinox, epoch, etc, of the target
+   SkyFrame. */
+   system = target_system;
+   equinox = target_equinox;
+   epoch = target_epoch;
+   last = GetLAST( target, status );
+   diurab = GetDiurab( target, status );
+   lat = astGetObsLat( target );
+   if( astOK && step1 ) {
+
+/* Convert the equinox and epoch values (stored as Modified Julian
+   Dates) into the equivalent Besselian and Julian epochs (as decimal
+   years). */
+      equinox_B = palEpb( equinox );
+      equinox_J = palEpj( equinox );
+      epoch_B = palEpb( epoch );
+      epoch_J = palEpj( epoch );
+
+/* Formulate the conversion... */
+
+/* From FK4. */
+/* --------- */
+/* If necessary, apply the old-style FK4 precession model to bring the
+   equinox to B1950.0, with rigorous handling of the E-terms of
+   aberration. Then convert directly to FK5 J2000.0 coordinates. */
+      if ( system == AST__FK4 ) {
+         VerifyMSMAttrs( target, result, 1, "Equinox Epoch", "astMatch", status );
+         if ( equinox_B != 1950.0 ) {
+            TRANSFORM_1( "SUBET", equinox_B )
+            TRANSFORM_2( "PREBN", equinox_B, 1950.0 )
+            TRANSFORM_1( "ADDET", 1950.0 )
+         }
+         TRANSFORM_1( "FK45Z", epoch_B )
+
+/* From FK4 with no E-terms. */
+/* ------------------------- */
+/* This is the same as above, except that we do not need to subtract
+      the E-terms initially as they are already absent. */
+      } else if ( system == AST__FK4_NO_E ) {
+         VerifyMSMAttrs( target, result, 1, "Equinox Epoch", "astMatch", status );
+         if ( equinox_B != 1950.0 ) {
+            TRANSFORM_2( "PREBN", equinox_B, 1950.0 )
+         }
+         TRANSFORM_1( "ADDET", 1950.0 )
+         TRANSFORM_1( "FK45Z", epoch_B )
+
+/* From FK5. */
+/* --------- */
+/* We simply need to apply a precession correction for the change of
+   equinox.  Omit even this if the equinox is already J2000.0. */
+      } else if ( system == AST__FK5 ) {
+         VerifyMSMAttrs( target, result, 1, "Equinox", "astMatch", status );
+         if ( equinox_J != 2000.0 ) {
+            TRANSFORM_2( "PREC", equinox_J, 2000.0 );
+         }
+
+/* From J2000. */
+/* ----------- */
+/* Convert from J2000 to ICRS, then from ICRS to FK5. */
+      } else if ( system == AST__J2000 ) {
+         VerifyMSMAttrs( target, result, 1, "Epoch", "astMatch", status );
+         TRANSFORM_0( "J2000H" )
+         TRANSFORM_1( "HFK5Z", epoch_J );
+
+/* From geocentric apparent. */
+/* ------------------------- */
+/* This conversion is supported directly by SLALIB. */
+      } else if ( system == AST__GAPPT ) {
+         VerifyMSMAttrs( target, result, 1, "Epoch", "astMatch", status );
+         TRANSFORM_2( "AMP", epoch, 2000.0 )
+
+/* From ecliptic coordinates. */
+/* -------------------------- */
+/* This conversion is supported directly by SLALIB. */
+      } else if ( system == AST__ECLIPTIC ) {
+         VerifyMSMAttrs( target, result, 1, "Equinox", "astMatch", status );
+         TRANSFORM_1( "ECLEQ", equinox )
+
+/* From helio-ecliptic coordinates. */
+/* -------------------------------- */
+      } else if ( system == AST__HELIOECLIPTIC ) {
+         VerifyMSMAttrs( target, result, 1, "Epoch", "astMatch", status );
+         TRANSFORM_1( "HEEQ", epoch )
+
+/* From galactic coordinates. */
+/* -------------------------- */
+/* This conversion is supported directly by SLALIB. */
+      } else if ( system == AST__GALACTIC ) {
+         TRANSFORM_0( "GALEQ" )
+
+/* From ICRS. */
+/* ---------- */
+/* This conversion is supported directly by SLALIB. */
+      } else if ( system == AST__ICRS ) {
+         VerifyMSMAttrs( target, result, 1, "Epoch", "astMatch", status );
+         TRANSFORM_1( "HFK5Z", epoch_J );
+
+/* From supergalactic coordinates. */
+/* ------------------------------- */
+/* Convert to galactic coordinates and then to FK5 J2000.0
+      equatorial. */
+      } else if ( system == AST__SUPERGALACTIC ) {
+         TRANSFORM_0( "SUPGAL" )
+         TRANSFORM_0( "GALEQ" )
+
+/* From AzEl. */
+/* ---------- */
+/* Rotate from horizon to equator (H2E), shift hour angle into RA (H2R),
+      go from geocentric apparent to FK5 J2000. */
+      } else if ( system == AST__AZEL ) {
+         VerifyMSMAttrs( target, result, 1, "ObsLon ObsLat Epoch", "astMatch", status );
+         TRANSFORM_2( "H2E", lat, diurab )
+         TRANSFORM_1( "H2R", last )
+         TRANSFORM_2( "AMP", epoch, 2000.0 )
+
+/* From unknown coordinates. */
+/* ------------------------- */
+/* No conversion is possible. */
+      } else if ( system == AST__UNKNOWN ) {
+         match = 0;
+      }
+   }
+
+/* Convert _from_ FK5 J2000.0 coordinates _to_ the alignment system. */
+/* ============================================================ */
+/* In this second phase, we convert to the system given by the align_sys
+   argument (if required), still using the properties of the target Frame. */
+   if ( astOK && match && step2 ) {
+
+/* Align in FK4. */
+/* --------------- */
+/* Convert directly from FK5 J2000.0 to FK4 B1950.0 coordinates at the
+   appropriate epoch. Then, if necessary, apply the old-style FK4
+   precession model to bring the equinox to that required, with
+   rigorous handling of the E-terms of aberration. */
+      if ( align_sys == AST__FK4 ) {
+         VerifyMSMAttrs( target, result, 1, "Equinox Epoch", "astMatch", status );
+         TRANSFORM_1( "FK54Z", epoch_B )
+         if ( equinox_B != 1950.0 ) {
+            TRANSFORM_1( "SUBET", 1950.0 )
+            TRANSFORM_2( "PREBN", 1950.0, equinox_B )
+            TRANSFORM_1( "ADDET", equinox_B )
+         }
+
+/* Align in FK4 with no E-terms. */
+/* ------------------------------- */
+/* This is the same as above, except that we do not need to add the
+   E-terms at the end. */
+      } else if ( align_sys == AST__FK4_NO_E ) {
+         VerifyMSMAttrs( target, result, 1, "Equinox Epoch", "astMatch", status );
+         TRANSFORM_1( "FK54Z", epoch_B )
+         TRANSFORM_1( "SUBET", 1950.0 )
+         if ( equinox_B != 1950.0 ) {
+            TRANSFORM_2( "PREBN", 1950.0, equinox_B )
+         }
+
+/* Align in FK5. */
+/* ------------- */
+/* We simply need to apply a precession correction for the change of
+   equinox.  Omit even this if the required equinox is J2000.0. */
+      } else if ( align_sys == AST__FK5 ) {
+         VerifyMSMAttrs( target, result, 1, "Equinox", "astMatch", status );
+         if ( equinox_J != 2000.0 ) {
+            TRANSFORM_2( "PREC", 2000.0, equinox_J )
+         }
+
+/* Align in J2000. */
+/* --------------- */
+/* Mov from FK5 to ICRS, and from ICRS to J2000. */
+      } else if ( align_sys == AST__J2000 ) {
+         VerifyMSMAttrs( target, result, 1, "Epoch", "astMatch", status );
+         TRANSFORM_1( "FK5HZ", epoch_J )
+         TRANSFORM_0( "HJ2000" )
+
+/* Align in geocentric apparent. */
+/* ------------------------------- */
+/* This conversion is supported directly by SLALIB. */
+      } else if ( align_sys == AST__GAPPT ) {
+         VerifyMSMAttrs( target, result, 1, "Epoch", "astMatch", status );
+         TRANSFORM_2( "MAP", 2000.0, epoch )
+
+/* Align in ecliptic coordinates. */
+/* -------------------------------- */
+/* This conversion is supported directly by SLALIB. */
+      } else if ( align_sys == AST__ECLIPTIC ) {
+         VerifyMSMAttrs( target, result, 1, "Equinox", "astMatch", status );
+         TRANSFORM_1( "EQECL", equinox )
+
+/* Align in helio-ecliptic coordinates. */
+/* ------------------------------------ */
+      } else if ( align_sys == AST__HELIOECLIPTIC ) {
+         VerifyMSMAttrs( target, result, 1, "Epoch", "astMatch", status );
+         TRANSFORM_1( "EQHE", epoch )
+
+/* Align in galactic coordinates. */
+/* -------------------------------- */
+/* This conversion is supported directly by SLALIB. */
+      } else if ( align_sys == AST__GALACTIC ) {
+         TRANSFORM_0( "EQGAL" )
+
+/* Align in ICRS. */
+/* -------------- */
+/* This conversion is supported directly by SLALIB. */
+      } else if ( align_sys == AST__ICRS ) {
+         VerifyMSMAttrs( target, result, 1, "Epoch", "astMatch", status );
+         TRANSFORM_1( "FK5HZ", epoch_J )
+
+/* Align in supergalactic coordinates. */
+/* ------------------------------------- */
+/* Convert to galactic coordinates and then to supergalactic. */
+      } else if ( align_sys == AST__SUPERGALACTIC ) {
+         TRANSFORM_0( "EQGAL" )
+         TRANSFORM_0( "GALSUP" )
+
+/* Align in AzEl coordinates. */
+/* -------------------------- */
+/* Go from FK5 J2000 to geocentric apparent (MAP), shift RA into hour angle
+   (R2H), rotate from equator to horizon (E2H). */
+      } else if ( align_sys == AST__AZEL ) {
+         VerifyMSMAttrs( target, result, 1, "ObsLon ObsLat Epoch", "astMatch", status );
+         TRANSFORM_2( "MAP", 2000.0, epoch )
+         TRANSFORM_1( "R2H", last )
+         TRANSFORM_2( "E2H", lat, diurab )
+
+/* Align in unknown coordinates. */
+/* ------------------------------- */
+/* No conversion is possible. */
+      } else if ( align_sys == AST__UNKNOWN ) {
+         match = 0;
+      }
+   }
+
+/* Convert _from_ the alignment system _to_ FK5 J2000.0 coordinates */
+/* =========================================================== */
+/* In this third phase, we convert from the alignment system (if required)
+   to the intermediate FK5 J2000 system, using the properties of the
+   result SkyFrame. */
+
+/* Obtain the sky coordinate system, equinox, epoch, etc, of the result
+   SkyFrame. */
+   system = result_system;
+   equinox = result_equinox;
+   epoch = result_epoch;
+   diurab = GetDiurab( result, status );
+   last = GetLAST( result, status );
+   lat = astGetObsLat( result );
+
+/* Convert the equinox and epoch values (stored as Modified Julian
+   Dates) into the equivalent Besselian and Julian epochs (as decimal
+   years). */
+   if( astOK ) {
+      equinox_B = palEpb( equinox );
+      equinox_J = palEpj( equinox );
+      epoch_B = palEpb( epoch );
+      epoch_J = palEpj( epoch );
+   }
+
+/* Check we need to do the conversion. */
+   if ( astOK && match && step3 ) {
+
+/* Formulate the conversion... */
+
+/* From FK4. */
+/* --------- */
+/* If necessary, apply the old-style FK4 precession model to bring the
+   equinox to B1950.0, with rigorous handling of the E-terms of
+   aberration. Then convert directly to FK5 J2000.0 coordinates. */
+      if ( align_sys == AST__FK4 ) {
+         VerifyMSMAttrs( target, result, 3, "Equinox Epoch", "astMatch", status );
+         if ( equinox_B != 1950.0 ) {
+            TRANSFORM_1( "SUBET", equinox_B )
+            TRANSFORM_2( "PREBN", equinox_B, 1950.0 )
+            TRANSFORM_1( "ADDET", 1950.0 )
+         }
+         TRANSFORM_1( "FK45Z", epoch_B )
+
+/* From FK4 with no E-terms. */
+/* ------------------------- */
+/* This is the same as above, except that we do not need to subtract
+   the E-terms initially as they are already absent. */
+      } else if ( align_sys == AST__FK4_NO_E ) {
+         VerifyMSMAttrs( target, result, 3, "Equinox Epoch", "astMatch", status );
+         if ( equinox_B != 1950.0 ) {
+            TRANSFORM_2( "PREBN", equinox_B, 1950.0 )
+         }
+         TRANSFORM_1( "ADDET", 1950.0 )
+         TRANSFORM_1( "FK45Z", epoch_B )
+
+/* From FK5. */
+/* --------- */
+/* We simply need to apply a precession correction for the change of
+   equinox.  Omit even this if the equinox is already J2000.0. */
+      } else if ( align_sys == AST__FK5 ) {
+         VerifyMSMAttrs( target, result, 3, "Equinox", "astMatch", status );
+         if ( equinox_J != 2000.0 ) {
+            TRANSFORM_2( "PREC", equinox_J, 2000.0 );
+         }
+
+/* From geocentric apparent. */
+/* ------------------------- */
+/* This conversion is supported directly by SLALIB. */
+      } else if ( align_sys == AST__GAPPT ) {
+         VerifyMSMAttrs( target, result, 3, "Epoch", "astMatch", status );
+         TRANSFORM_2( "AMP", epoch, 2000.0 )
+
+/* From ecliptic coordinates. */
+/* -------------------------- */
+/* This conversion is supported directly by SLALIB. */
+      } else if ( align_sys == AST__ECLIPTIC ) {
+         VerifyMSMAttrs( target, result, 3, "Equinox", "astMatch", status );
+         TRANSFORM_1( "ECLEQ", equinox )
+
+/* From helio-ecliptic coordinates. */
+/* -------------------------------- */
+      } else if ( align_sys == AST__HELIOECLIPTIC ) {
+         VerifyMSMAttrs( target, result, 3, "Epoch", "astMatch", status );
+         TRANSFORM_1( "HEEQ", epoch )
+
+/* From galactic coordinates. */
+/* -------------------------- */
+/* This conversion is supported directly by SLALIB. */
+      } else if ( align_sys == AST__GALACTIC ) {
+         TRANSFORM_0( "GALEQ" )
+
+/* From ICRS. */
+/* ---------- */
+/* This conversion is supported directly by SLALIB. */
+      } else if ( align_sys == AST__ICRS ) {
+         VerifyMSMAttrs( target, result, 3, "Epoch", "astMatch", status );
+         TRANSFORM_1( "HFK5Z", epoch_J )
+
+/* From J2000. */
+/* ----------- */
+/* From J2000 to ICRS, and from ICRS to FK5. */
+      } else if ( align_sys == AST__J2000 ) {
+         VerifyMSMAttrs( target, result, 3, "Epoch", "astMatch", status );
+         TRANSFORM_0( "J2000H" )
+         TRANSFORM_1( "HFK5Z", epoch_J )
+
+/* From supergalactic coordinates. */
+/* ------------------------------- */
+/* Convert to galactic coordinates and then to FK5 J2000.0
+      equatorial. */
+      } else if ( align_sys == AST__SUPERGALACTIC ) {
+         TRANSFORM_0( "SUPGAL" )
+         TRANSFORM_0( "GALEQ" )
+
+/* From AzEl. */
+/* ---------- */
+/* Rotate from horizon to equator (H2E), shift hour angle into RA (H2R),
+      go from geocentric apparent to FK5 J2000. */
+      } else if ( align_sys == AST__AZEL ) {
+         VerifyMSMAttrs( target, result, 3, "ObsLon ObsLat Epoch", "astMatch", status );
+         TRANSFORM_2( "H2E", lat, diurab )
+         TRANSFORM_1( "H2R", last )
+         TRANSFORM_2( "AMP", epoch, 2000.0 )
+
+/* From unknown coordinates. */
+/* ------------------------------- */
+/* No conversion is possible. */
+      } else if ( align_sys == AST__UNKNOWN ) {
+         match = 0;
+      }
+   }
+
+/* Convert _from_ FK5 J2000.0 coordinates. */
+/* ======================================= */
+/* In this fourth and final phase, we convert to the result coordinate
+   system from the intermediate FK5 J2000 sky coordinates generated above. */
+   if ( astOK && match && step4 ) {
+
+/* To FK4. */
+/* ------- */
+/* Convert directly from FK5 J2000.0 to FK4 B1950.0 coordinates at the
+   appropriate epoch. Then, if necessary, apply the old-style FK4
+   precession model to bring the equinox to that required, with
+   rigorous handling of the E-terms of aberration. */
+      if ( system == AST__FK4 ) {
+         VerifyMSMAttrs( target, result, 3, "Equinox Epoch", "astMatch", status );
+         TRANSFORM_1( "FK54Z", epoch_B )
+         if ( equinox_B != 1950.0 ) {
+            TRANSFORM_1( "SUBET", 1950.0 )
+            TRANSFORM_2( "PREBN", 1950.0, equinox_B )
+            TRANSFORM_1( "ADDET", equinox_B )
+         }
+
+/* To FK4 with no E-terms. */
+/* ----------------------- */
+/* This is the same as above, except that we do not need to add the
+   E-terms at the end. */
+      } else if ( system == AST__FK4_NO_E ) {
+         VerifyMSMAttrs( target, result, 3, "Equinox Epoch", "astMatch", status );
+         TRANSFORM_1( "FK54Z", epoch_B )
+         TRANSFORM_1( "SUBET", 1950.0 )
+         if ( equinox_B != 1950.0 ) {
+            TRANSFORM_2( "PREBN", 1950.0, equinox_B )
+         }
+
+/* To FK5. */
+/* ------- */
+/* We simply need to apply a precession correction for the change of
+   equinox.  Omit even this if the required equinox is J2000.0. */
+      } else if ( system == AST__FK5 ) {
+         VerifyMSMAttrs( target, result, 3, "Equinox", "astMatch", status );
+         if ( equinox_J != 2000.0 ) {
+            TRANSFORM_2( "PREC", 2000.0, equinox_J )
+         }
+
+/* To geocentric apparent. */
+/* ----------------------- */
+/* This conversion is supported directly by SLALIB. */
+      } else if ( system == AST__GAPPT ) {
+         VerifyMSMAttrs( target, result, 3, "Epoch", "astMatch", status );
+         TRANSFORM_2( "MAP", 2000.0, epoch )
+
+/* To ecliptic coordinates. */
+/* ------------------------ */
+/* This conversion is supported directly by SLALIB. */
+      } else if ( system == AST__ECLIPTIC ) {
+         VerifyMSMAttrs( target, result, 3, "Equinox", "astMatch", status );
+         TRANSFORM_1( "EQECL", equinox )
+
+/* To helio-ecliptic coordinates. */
+/* ------------------------------ */
+      } else if ( system == AST__HELIOECLIPTIC ) {
+         VerifyMSMAttrs( target, result, 3, "Epoch", "astMatch", status );
+         TRANSFORM_1( "EQHE", epoch )
+
+/* To galactic coordinates. */
+/* ------------------------ */
+/* This conversion is supported directly by SLALIB. */
+      } else if ( system == AST__GALACTIC ) {
+         TRANSFORM_0( "EQGAL" )
+
+/* To ICRS. */
+/* -------- */
+/* This conversion is supported directly by SLALIB. */
+      } else if ( system == AST__ICRS ) {
+         VerifyMSMAttrs( target, result, 3, "Epoch", "astMatch", status );
+         TRANSFORM_1( "FK5HZ", epoch_J )
+
+/* To J2000. */
+/* --------- */
+/* From FK5 to ICRS, then from ICRS to J2000. */
+      } else if ( system == AST__J2000 ) {
+         VerifyMSMAttrs( target, result, 3, "Epoch", "astMatch", status );
+         TRANSFORM_1( "FK5HZ", epoch_J )
+         TRANSFORM_0( "HJ2000" )
+
+/* To supergalactic coordinates. */
+/* ----------------------------- */
+/* Convert to galactic coordinates and then to supergalactic. */
+      } else if ( system == AST__SUPERGALACTIC ) {
+         TRANSFORM_0( "EQGAL" )
+         TRANSFORM_0( "GALSUP" )
+
+/* To AzEl */
+/* ------- */
+/* Go from FK5 J2000 to geocentric apparent (MAP), shift RA into hour angle
+   (R2H), rotate from equator to horizon (E2H). */
+      } else if ( system == AST__AZEL ) {
+         VerifyMSMAttrs( target, result, 3, "ObsLon ObsLat Epoch", "astMatch", status );
+         TRANSFORM_2( "MAP", 2000.0, epoch )
+         TRANSFORM_1( "R2H", last )
+         TRANSFORM_2( "E2H", lat, diurab )
+
+/* To unknown coordinates. */
+/* ----------------------------- */
+/* No conversion is possible. */
+      } else if ( system == AST__UNKNOWN ) {
+         match = 0;
+      }
+   }
+
+/* See of the slamap created above is effectively a unit mapping to
+   within the tolerance of the more accurate SkyFrame (target or result). */
+   isunit = TestSlaUnit( target, result, slamap, status );
+
+/* Now need to take account of the possibility that the input or output
+   SkyFrame may represent an offset system rather than a coordinate system.
+   Form the Mapping from the target coordinate system to the associated
+   offset system. A UnitMap is returned if the target does not use an
+   offset system. */
+   omap = SkyOffsetMap( target, status );
+
+/* Invert it to get the Mapping from the actual used system (whther
+   offsets or coordinates) to the coordinate system. */
+   astInvert( omap );
+
+/* Combine it with the slamap created earlier, so that its coordinate
+   outputs feed the inputs of the slamap. We only do this if the slamap
+   is not effectively a unit mapping. Annul redundant pointers afterwards. */
+   if( ! isunit ) {
+      tmap = (AstMapping *) astCmpMap( omap, slamap, 1, "", status );
+   } else {
+      tmap = astClone( omap );
+   }
+   omap = astAnnul( omap );
+   slamap =astAnnul( slamap );
+
+/* Now form the Mapping from the result coordinate system to the associated
+   offset system. A UnitMap is returned if the result does not use an
+   offset system. */
+   omap = SkyOffsetMap( result, status );
+
+/* Combine it with the above CmpMap, so that the CmpMap outputs feed the
+   new Mapping inputs. Annul redundant pointers afterwards. */
+   tmap2 = (AstMapping *) astCmpMap( tmap, omap, 1, "", status );
+   omap =astAnnul( omap );
+   tmap =astAnnul( tmap );
+
+/* Simplify the Mapping produced above (this eliminates any redundant
+   conversions) and annul the original pointer. */
+   *map = astSimplify( tmap2 );
+   tmap2 = astAnnul( tmap2 );
+
+/* If an error occurred, annul the returned Mapping and clear the
+   returned values. */
+   if ( !astOK ) {
+      *map = astAnnul( *map );
+      match = -1;
+   }
+
+/* Return the result. */
+   return match;
+
+/* Undefine macros local to this function. */
+#undef MAX_ARGS
+#undef TRANSFORM_0
+#undef TRANSFORM_1
+#undef TRANSFORM_2
+#undef TRANSFORM_3
+}
+
+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 "skyframe.h"
+*     int Match( AstFrame *template, AstFrame *target, int matchsub,
+*                int **template_axes, int **target_axes,
+*                AstMapping **map, AstFrame **result, int *status )
+
+*  Class Membership:
+*     SkyFrame member function (over-rides the protected astMatch method
+*     inherited from the Frame class).
+
+*  Description:
+*     This function matches a "template" SkyFrame 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 SkyFrame. 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 SkyFrame axis from which
+*        it is derived. If it is not derived from any template SkyFrame 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 SkyFrame class object to
+*     any other class of Frame. A SkyFrame will match any class of SkyFrame
+*     (i.e. possibly from a derived class) but will not match a less
+*     specialised class of Frame.
+*/
+
+/* Local Variables: */
+   AstFrame *frame0;          /* Pointer to Frame underlying axis 0 */
+   AstFrame *frame1;          /* Pointer to Frame underlying axis 1 */
+   AstSkyFrame *template;     /* Pointer to template SkyFrame structure */
+   int iaxis;                 /* Axis index */
+   int iaxis0;                /* Axis index underlying axis 0 */
+   int iaxis1;                /* Axis index underlying axis 1 */
+   int match;                 /* Coordinate conversion possible? */
+   int swap1;                 /* Template axes swapped? */
+   int swap2;                 /* Target axes swapped? */
+   int swap;                  /* Additional axis swap needed? */
+   int target_axis0;          /* Index of 1st SkyFrame axis in the target */
+   int target_axis1;          /* Index of 2nd SkyFrame 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;
+
+/* Initialise variables to avoid "used of uninitialised variable"
+   messages from dumb compilers. */
+   swap = 0;
+   target_axis0 = -1;
+   target_axis1 = -1;
+
+/* Obtain a pointer to the template SkyFrame structure. */
+   template = (AstSkyFrame *) 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 (2) 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 SkyFrame axis is found. */
+   if ( match && astOK ) {
+
+      match = 0;
+      for( iaxis = 0; iaxis < target_naxes; iaxis++ ) {
+         astPrimaryFrame( target, iaxis, &frame0, &iaxis0 );
+         if( astIsASkyFrame( frame0 ) ) {
+            target_axis0 = iaxis;
+            match = 1;
+            break;
+         } else {
+            frame0 = astAnnul( frame0 );
+         }
+      }
+
+/* Check at least one SkyFrame axis was found it the target. */
+      if( match ) {
+
+/* If so, search the remaining target axes for another axis that is
+   derived from the same SkyFrame. */
+         match = 0;
+         for( iaxis++ ; iaxis < target_naxes; iaxis++ ) {
+            astPrimaryFrame( target, iaxis, &frame1, &iaxis1 );
+            if( frame1 == frame0 ) {
+               target_axis1 = iaxis;
+               frame1 = astAnnul( frame1 );
+               match = 1;
+               break;
+            } else {
+               frame1 = astAnnul( frame1 );
+            }
+         }
+
+/* Annul the remaining Frame pointer used in the above tests. */
+         frame0 = astAnnul( frame0 );
+      }
+
+/* If this test is passed, we can now test that the underlying axis indices
+   are 0 and 1, in either order. This then ensures that we have a
+   single SkyFrame (not a compound Frame) with both axes present. */
+      if ( match && astOK ) {
+         match = ( ( ( iaxis0 == 0 ) && ( iaxis1 == 1 ) ) ||
+                   ( ( iaxis1 == 0 ) && ( iaxis0 == 1 ) ) );
+      }
+
+   }
+
+/* If a possible match has been detected, we must now decide how the
+   order of the axes in the result Frame relates to the order of axes
+   in the target Frame. There are two factors involved. The first
+   depends on whether the axis permutation array for the template
+   SkyFrame (whose method we are executing) causes an axis
+   reversal. Determine this by permuting axis index zero. */
+   if ( astOK && match ) {
+      swap1 = ( astValidateAxis( template, 0, 1, "astMatch" ) != 0 );
+
+/* The second factor depends on whether the axes of the underlying
+   primary SkyFrame are reversed when seen in the target Frame. */
+      swap2 = ( iaxis0 != 0 );
+
+/* Combine these to determine if an additional axis swap will be
+   needed. */
+      swap = ( swap1 != swap2 );
+
+/* Now check to see if this additional swap is permitted by the
+   template's Permute attribute. */
+      match = ( !swap || astGetPermute( template ) );
+   }
+
+/* If the Frames still match, we next set up the axis association
+   arrays. */
+   if ( astOK && match ) {
+
+/* If the target axis order is to be preserved, then the target axis
+   association involves no permutation but the template axis
+   association may involve an axis swap. */
+      if ( astGetPreserveAxes( template ) ) {
+         (*template_axes)[ 0 ] = swap;
+         (*template_axes)[ 1 ] = !swap;
+         (*target_axes)[ 0 ] = target_axis0;
+         (*target_axes)[ 1 ] = target_axis1;
+
+/* Otherwise, any swap applies to the target axis association
+   instead. */
+      } else {
+         (*template_axes)[ 0 ] = 0;
+         (*template_axes)[ 1 ] = 1;
+         (*target_axes)[ 0 ] = swap ? target_axis1 : target_axis0;
+         (*target_axes)[ 1 ] = swap ? target_axis0 : target_axis1;
+      }
+
+/* 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, 2, *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 MatchAxesX( AstFrame *frm2_frame, AstFrame *frm1, int *axes,
+                        int *status ) {
+/*
+*  Name:
+*     MatchAxesX
+
+*  Purpose:
+*     Find any corresponding axes in two Frames.
+
+*  Type:
+*     Private function.
+
+*  Synopsis:
+*     #include "skyframe.h"
+*     void MatchAxesX( AstFrame *frm2, AstFrame *frm1, int *axes )
+*                      int *status )
+
+*  Class Membership:
+*     SkyFrame member function (over-rides the protected astMatchAxesX
+*     method inherited from the Frame class).
+
+*     This function looks for corresponding axes within two supplied
+*     Frames. An array of integers is returned that contains an element
+*     for each axis in the second supplied Frame. An element in this array
+*     will be set to zero if the associated axis within the second Frame
+*     has no corresponding axis within the first Frame. Otherwise, it
+*     will be set to the index (a non-zero positive integer) of the
+*     corresponding axis within the first supplied Frame.
+
+*  Parameters:
+*     frm2
+*        Pointer to the second Frame.
+*     frm1
+*        Pointer to the first Frame.
+*     axes
+*        Pointer to an integer array in which to return the indices of
+*        the axes (within the first Frame) that correspond to each axis
+*        within the second Frame. Axis indices start at 1. A value of zero
+*        will be stored in the returned array for each axis in the second
+*        Frame that has no corresponding axis in the first Frame.
+*
+*        The number of elements in this array must be greater than or
+*        equal to the number of axes in the second Frame.
+*     status
+*        Pointer to inherited status value.
+
+*  Notes:
+*     -  Corresponding axes are identified by the fact that a Mapping
+*     can be found between them using astFindFrame or astConvert. Thus,
+*     "corresponding axes" are not necessarily identical. For instance,
+*     SkyFrame axes in two Frames will match even if they describe
+*     different celestial coordinate systems
+*/
+
+/* Local Variables: */
+   AstFrame *resfrm;
+   AstMapping *resmap;
+   AstSkyFrame *frm2;
+   int *frm2_axes;
+   int *frm1_axes;
+   int max_axes;
+   int min_axes;
+   int preserve_axes;
+
+/* Check the global error status. */
+   if ( !astOK ) return;
+
+/* Get a pointer to the SkyFrame. */
+   frm2 = (AstSkyFrame *) frm2_frame;
+
+/* Temporarily ensure that the PreserveAxes attribute is non-zero in
+   the first supplied Frame. This means thte result Frame returned by
+   astMatch below will have the axis count and order of the target Frame
+   (i.e. "pfrm"). */
+   if( astTestPreserveAxes( frm1 ) ) {
+      preserve_axes = astGetPreserveAxes( frm1 ) ? 1 : 0;
+   } else {
+      preserve_axes = -1;
+   }
+   astSetPreserveAxes( frm1, 1 );
+
+/* Temporarily ensure that the MaxAxes and MinAxes attributes in the
+   first supplied Frame are set so the Frame can be used as a template
+   in astMatch for matching any number of axes. */
+   if( astTestMaxAxes( frm1 ) ) {
+      max_axes = astGetMaxAxes( frm1 );
+   } else {
+      max_axes = -1;
+   }
+   astSetMaxAxes( frm1, 10000 );
+
+   if( astTestMinAxes( frm1 ) ) {
+      min_axes = astGetMinAxes( frm1 );
+   } else {
+      min_axes = -1;
+   }
+   astSetMinAxes( frm1, 1 );
+
+/* Attempt to find a sub-frame within the first supplied Frame that
+   corresponds to the supplied SkyFrame. */
+   if( astMatch( frm1, frm2, 1, &frm1_axes, &frm2_axes, &resmap, &resfrm ) ) {
+
+/* If successfull, Store the one-based index within "frm1" of the
+   corresponding axes. */
+      axes[ 0 ] = frm1_axes[ 0 ] + 1;
+      axes[ 1 ] = frm1_axes[ 1 ] + 1;
+
+/* Free resources */
+      frm1_axes = astFree( frm1_axes );
+      frm2_axes = astFree( frm2_axes );
+      resmap = astAnnul( resmap );
+      resfrm = astAnnul( resfrm );
+
+/* If no corresponding SkyFrame was found store zeros in the returned array. */
+   } else {
+      axes[ 0 ] = 0;
+      axes[ 1 ] = 0;
+   }
+
+/* Re-instate the original attribute values in the first supplied Frame. */
+   if( preserve_axes == -1 ) {
+      astClearPreserveAxes( frm1 );
+   } else {
+      astSetPreserveAxes( frm1, preserve_axes );
+   }
+
+   if( max_axes == -1 ) {
+      astClearMaxAxes( frm1 );
+   } else {
+      astSetMaxAxes( frm1, max_axes );
+   }
+
+   if( min_axes == -1 ) {
+      astClearMinAxes( frm1 );
+   } else {
+      astSetMinAxes( frm1, min_axes );
+   }
+}
+
+static void Norm( AstFrame *this_frame, double value[], int *status ) {
+/*
+*  Name:
+*     Norm
+
+*  Purpose:
+*     Normalise a set of SkyFrame coordinates.
+
+*  Type:
+*     Private function.
+
+*  Synopsis:
+*     #include "skyframe.h"
+*     void Norm( AstAxis *this, double value[], int *status )
+
+*  Class Membership:
+*     SkyFrame member function (over-rides the astNorm method inherited
+*     from the Frame class).
+
+*  Description:
+*     This function converts a set of SkyFrame coordinate values,
+*     which might potentially be unsuitable for display to a user (for
+*     instance, may lie outside the expected range of values) into a
+*     set of acceptable alternative values suitable for display.
+*
+*     This is done by wrapping coordinates so that the latitude lies
+*     in the range (-pi/2.0) <= latitude <= (pi/2.0). If the NegLon
+*     attribute is zero (the default), then the wrapped longitude value
+*     lies in the range 0.0 <= longitude < (2.0*pi). Otherwise, it lies
+*     in the range -pi <= longitude < pi.
+
+*  Parameters:
+*     this
+*        Pointer to the SkyFrame.
+*     value
+*        An array of double, with one element for each SkyFrame axis.
+*        This should contain the initial set of coordinate values,
+*        which will be modified in place.
+*     status
+*        Pointer to the inherited status variable.
+*/
+
+/* Local Variables: */
+   AstSkyFrame *this;            /* Pointer to the SkyFrame structure */
+   const int *perm;              /* Axis permutation array */
+   double sky_lat;               /* Sky latitude value */
+   double sky_long;              /* Sky longitude value */
+   double v[ 2 ];                /* Permuted value coordinates */
+
+/* Check the global error status. */
+   if ( !astOK ) return;
+
+/* Obtain a pointer to the SkyFrame structure. */
+   this = (AstSkyFrame *) this_frame;
+
+/* Obtain a pointer to the SkyFrame's axis permutation array. */
+   perm = astGetPerm( this );
+   if ( astOK ) {
+
+/* Obtain the sky longitude and latitude values, allowing for any axis
+   permutation. */
+      v[ perm[ 0 ] ] = value[ 0 ];
+      v[ perm[ 1 ] ] = value[ 1 ];
+      sky_long = v[ 0 ];
+      sky_lat = v[ 1 ];
+
+/* Test if both values are OK (i.e. not "bad"). */
+      if ( ( sky_long != AST__BAD ) && ( sky_lat != AST__BAD ) ) {
+
+/* Fold the longitude value into the range 0 to 2*pi and the latitude into
+   the range -pi to +pi. */
+         sky_long = palDranrm( sky_long );
+         sky_lat = palDrange( sky_lat );
+
+/* If the latitude now exceeds pi/2, shift the longitude by pi in whichever
+   direction will keep it in the range 0 to 2*pi. */
+         if ( sky_lat > ( pi / 2.0 ) ) {
+            sky_long += ( sky_long < pi ) ? pi : -pi;
+
+/* Reflect the latitude value through the pole, so it lies in the range 0 to
+   pi/2. */
+            sky_lat = pi - sky_lat;
+
+/* If the latitude is less than -pi/2, shift the longitude in the same way
+   as above. */
+         } else if ( sky_lat < -( pi / 2.0 ) ) {
+            sky_long += ( sky_long < pi ) ? pi : -pi;
+
+/* But reflect the latitude through the other pole, so it lies in the range
+   -pi/2 to 0. */
+            sky_lat = -pi - sky_lat;
+         }
+
+/* If only the longitude value is valid, wrap it into the range 0 to 2*pi. */
+      } else if ( sky_long != AST__BAD ) {
+         sky_long = palDranrm( sky_long );
+
+/* If only the latitude value is valid, wrap it into the range -pi to +pi. */
+      } else if ( sky_lat != AST__BAD ) {
+         sky_lat = palDrange( sky_lat );
+
+/* Then refect through one of the poles (as above), if necessary, to move it
+   into the range -pi/2 to +pi/2. */
+         if ( sky_lat > ( pi / 2.0 ) ) {
+            sky_lat = pi - sky_lat;
+         } else if ( sky_lat < -( pi / 2.0 ) ) {
+            sky_lat = -pi - sky_lat;
+         }
+      }
+
+/* Convert 2*pi longitude into zero. Allow for a small error. */
+      if ( fabs( sky_long - ( 2.0 * pi ) ) <=
+          ( 2.0 * pi ) * ( DBL_EPSILON * (double) FLT_RADIX ) ) sky_long = 0.0;
+
+/* If the NegLon attribute is set, and the longitude value is good,
+   convert it into the range -pi to +pi. */
+      if( sky_long != AST__BAD && astGetNegLon( this ) ) {
+         sky_long = palDrange( sky_long );
+      }
+
+/* Return the new values, allowing for any axis permutation. */
+      v[ 0 ] = sky_long;
+      v[ 1 ] = sky_lat;
+      value[ 0 ] = v[ perm[ 0 ] ];
+      value[ 1 ] = v[ perm[ 1 ] ];
+   }
+}
+
+static void NormBox( AstFrame *this_frame, double lbnd[], double ubnd[],
+                     AstMapping *reg, int *status ) {
+/*
+*  Name:
+*     NormBox
+
+*  Purpose:
+*     Extend a box to include effect of any singularities in the Frame.
+
+*  Type:
+*     Private function.
+
+*  Synopsis:
+*     #include "skyframe.h"
+*     void astNormBox( AstFrame *this, double lbnd[], double ubnd[],
+*                      AstMapping *reg, int *status )
+
+*  Class Membership:
+*     SkyFrame member function (over-rides the astNormBox method inherited
+*     from the Frame class).
+
+*  Description:
+*     This function modifies a supplied box to include the effect of any
+*     singularities in the co-ordinate system represented by the Frame.
+*     For a normal Cartesian coordinate system, the box will be returned
+*     unchanged. Other classes of Frame may do other things. For instance,
+*     a SkyFrame will check to see if the box contains either the north
+*     or south pole and extend the box appropriately.
+
+*  Parameters:
+*     this
+*        Pointer to the Frame.
+*     lbnd
+*        An array of double, with one element for each Frame axis
+*        (Naxes attribute). Initially, this should contain a set of
+*        lower axis bounds for the box. They will be modified on exit
+*        to include the effect of any singularities within the box.
+*     ubnd
+*        An array of double, with one element for each Frame axis
+*        (Naxes attribute). Initially, this should contain a set of
+*        upper axis bounds for the box. They will be modified on exit
+*        to include the effect of any singularities within the box.
+*     reg
+*        A Mapping which should be used to test if any singular points are
+*        inside or outside the box. The Mapping should leave an input
+*        position unchanged if the point is inside the box, and should
+*        set all bad if the point is outside the box.
+*     status
+*        Pointer to the inherited status variable.
+*/
+
+/* Local Variables: */
+   AstSkyFrame *this;            /* Pointer to the SkyFrame structure */
+   const int *perm;              /* Axis permutation array */
+   double lb[ 2 ];               /* Permuted lower bounds */
+   double t;                     /* Temporary storage */
+   double t2;                    /* Temporary storage */
+   double ub[ 2 ];               /* Permuted upper bounds */
+   double x[2];                  /* 1st axis values at poles */
+   double xo[2];                 /* Tested 1st axis values at poles */
+   double y[2];                  /* 2nd axis values at poles */
+   double yo[2];                 /* Tested 2nd axis values at poles */
+
+/* Check the global error status. */
+   if ( !astOK ) return;
+
+/* Obtain a pointer to the SkyFrame structure. */
+   this = (AstSkyFrame *) this_frame;
+
+/* Obtain a pointer to the SkyFrame's axis permutation array. */
+   perm = astGetPerm( this );
+   if( perm ) {
+
+/* Obtain the sky longitude and latitude limits, allowing for any axis
+   permutation. */
+      lb[ perm[ 0 ] ] = lbnd[ 0 ];
+      lb[ perm[ 1 ] ] = lbnd[ 1 ];
+      ub[ perm[ 0 ] ] = ubnd[ 0 ];
+      ub[ perm[ 1 ] ] = ubnd[ 1 ];
+
+/* Use the supplied Mapping to test if box includes either pole. */
+      if( perm[ 0 ] == 0 ) {
+         x[ 0 ] = 0.0;
+         y[ 0 ] = AST__DPIBY2;
+         x[ 1 ] = 0.0;
+         y[ 1 ] = -AST__DPIBY2;
+      } else {
+         x[ 0 ] = AST__DPIBY2;
+         y[ 0 ] = 0.0;
+         x[ 1 ] = -AST__DPIBY2;
+         y[ 1 ] = 0.0;
+      }
+      astTran2( reg, 2, x, y, 1, xo, yo );
+
+/* If the box includes the north pole... */
+      if( xo[ 0 ] != AST__BAD ) {
+
+/* Find the lowest latitude after normalisation. */
+         if( ub[ 1 ] != AST__BAD &&  lb[ 1 ] != AST__BAD ){
+            t = palDrange( ub[ 1 ] );
+            t2 = palDrange( lb[ 1 ] );
+            if( t2 < t ) t = t2;
+         } else {
+            t = AST__BAD;
+         }
+
+/* Set the lower returned limit to this value and the upper returned limit
+   to +90 degs */
+         lb[ 1 ] = t;
+         ub[ 1 ] = AST__DPIBY2;
+
+/* Set the longitude range to 0 to 2PI */
+         lb[ 0 ] = 0;
+         ub[ 0 ] = 2*AST__DPI;
+
+      }
+
+/* If the box includes the south pole... */
+      if( xo[ 1 ] != AST__BAD ) {
+
+/* Find the highest latitude after normalisation. */
+         if( ub[ 1 ] != AST__BAD &&  lb[ 1 ] != AST__BAD ){
+            t = palDrange( ub[ 1 ] );
+            t2 = palDrange( lb[ 1 ] );
+            if( t2 > t ) t = t2;
+         } else {
+            t = AST__BAD;
+         }
+
+/* Set the upper returned limit to this value and the lower returned limit
+   to -90 degs */
+         lb[ 1 ] = -AST__DPIBY2;
+         ub[ 1 ] = t;
+
+/* Set the longitude range to 0 to 2PI */
+         lb[ 0 ] = 0;
+         ub[ 0 ] = 2*AST__DPI;
+      }
+
+/* Return the modified limits. */
+      lbnd[ 0 ] = lb[ perm[ 0 ] ];
+      lbnd[ 1 ] = lb[ perm[ 1 ] ];
+      ubnd[ 0 ] = ub[ perm[ 0 ] ];
+      ubnd[ 1 ] = ub[ perm[ 1 ] ];
+   }
+}
+
+static void Offset( AstFrame *this_frame, const double point1[],
+                    const double point2[], double offset, double point3[], int *status ) {
+/*
+*  Name:
+*     Offset
+
+*  Purpose:
+*     Calculate an offset along a geodesic curve.
+
+*  Type:
+*     Private function.
+
+*  Synopsis:
+*     #include "skyframe.h"
+*     void Offset( AstFrame *this,
+*                  const double point1[], const double point2[],
+*                  double offset, double point3[], int *status )
+
+*  Class Membership:
+*     SkyFrame member function (over-rides the astOffset method
+*     inherited from the Frame class).
+
+*  Description:
+*     This function finds the SkyFrame coordinate values of a point
+*     which is offset a specified distance along the geodesic curve
+*     (i.e. great circle) between two other points.
+
+*  Parameters:
+*     this
+*        Pointer to the SkyFrame.
+*     point1
+*        An array of double, with one element for each SkyFrame axis.
+*        This should contain the coordinates of the point marking the
+*        start of the geodesic curve.
+*     point2
+*        An array of double, with one element for each SkyFrame axis.
+*        This should contain the coordinates of the point marking the
+*        end of the geodesic curve.
+*     offset
+*        The required offset from the first point along the geodesic
+*        curve, in radians. If this is positive, it will be towards
+*        the second point. If it is negative, it will be in the
+*        opposite direction. This offset need not imply a position
+*        lying between the two points given, as the curve will be
+*        extrapolated if necessary.
+*     point3
+*        An array of double, with one element for each SkyFrame axis
+*        in which the coordinates of the required point will be
+*        returned.
+*     status
+*        Pointer to the inherited status variable.
+
+*  Notes:
+*     - The geodesic curve used by this function is the path of
+*     shortest distance between two points, as defined by the
+*     astDistance function.
+*     - This function will return "bad" coordinate values (AST__BAD)
+*     if any of the input coordinates has this value.
+*     - "Bad" coordinate values will also be returned if the two
+*     points supplied are coincident (or otherwise fail to uniquely
+*     specify a geodesic curve) but the requested offset is non-zero.
+*/
+
+/* Local Variables: */
+   AstSkyFrame *this;            /* Pointer to the SkyFrame structure */
+   const int *perm;              /* Pointer to axis permutation array */
+   double mrot[ 3 ][ 3 ];        /* Rotation matrix */
+   double p1[ 2 ];               /* Permuted coordinates for point1 */
+   double p2[ 2 ];               /* Permuted coordinates for point2 */
+   double p3[ 2 ];               /* Permuted coordinates for point3 */
+   double scale;                 /* Scale factor */
+   double v1[ 3 ];               /* 3-vector for p1 */
+   double v2[ 3 ];               /* 3-vector for p2 */
+   double v3[ 3 ];               /* 3-vector for p3 */
+   double vmod;                  /* Modulus of vector */
+   double vrot[ 3 ];             /* Vector along rotation axis */
+
+/* Check the global error status. */
+   if ( !astOK ) return;
+
+/* Obtain a pointer to the SkyFrame structure. */
+   this = (AstSkyFrame *) this_frame;
+
+/* Obtain a pointer to the SkyFrame's axis permutation array. */
+   perm = astGetPerm( this );
+   if ( astOK ) {
+
+/* Check that all supplied coordinates are OK. If not, generate "bad"
+   output coordinates. */
+      if ( ( point1[ 0 ] == AST__BAD ) || ( point1[ 1 ] == AST__BAD ) ||
+           ( point2[ 0 ] == AST__BAD ) || ( point2[ 1 ] == AST__BAD ) ) {
+         point3[ 0 ] = AST__BAD;
+         point3[ 1 ] = AST__BAD;
+
+/* Otherwise, apply the axis permutation array to obtain the
+   coordinates of the two input points in the required
+   (longitude,latitude) order. */
+      } else {
+         p1[ perm[ 0 ] ] = point1[ 0 ];
+         p1[ perm[ 1 ] ] = point1[ 1 ];
+         p2[ perm[ 0 ] ] = point2[ 0 ];
+         p2[ perm[ 1 ] ] = point2[ 1 ];
+
+/* Convert each point into a 3-vector of unit length. */
+         palDcs2c( p1[ 0 ], p1[ 1 ], v1 );
+         palDcs2c( p2[ 0 ], p2[ 1 ], v2 );
+
+/* Find the cross product between these two vectors (the vector order
+   is reversed here to compensate for the sense of rotation introduced
+   by palDav2m and palDmxv below). */
+         palDvxv( v2, v1, v3 );
+
+/* Normalise the cross product vector, also obtaining its original
+   modulus. */
+         palDvn( v3, vrot, &vmod );
+
+/* If the original modulus was zero, the input points are either
+   coincident or diametrically opposite, so do not uniquely define a
+   great circle. In either case, we can only generate output
+   coordinates if the offset required is an exact multiple of pi. If
+   it is, generate the 3-vector that results from rotating the first
+   input point through this angle. */
+         if ( vmod == 0.0 ) {
+            if ( sin( offset ) == 0.0 ) {
+               scale = cos( offset );
+               v3[ 0 ] = v1[ 0 ] * scale;
+               v3[ 1 ] = v1[ 1 ] * scale;
+               v3[ 2 ] = v1[ 2 ] * scale;
+
+/* Convert the 3-vector back into spherical cooordinates and then
+   constrain the longitude result to lie in the range 0 to 2*pi
+   (palDcc2s doesn't do this itself). */
+               palDcc2s( v3, &p3[ 0 ], &p3[ 1 ] );
+               p3[ 0 ] = palDranrm( p3[ 0 ] );
+
+/* If the offset was not a multiple of pi, generate "bad" output
+   coordinates. */
+            } else {
+               p3[ 0 ] = AST__BAD;
+               p3[ 1 ] = AST__BAD;
+            }
+
+/* If the two input points define a great circle, scale the normalised
+   cross product vector to make its length equal to the required
+   offset (angle) between the first input point and the result. */
+         } else {
+            vrot[ 0 ] *= offset;
+            vrot[ 1 ] *= offset;
+            vrot[ 2 ] *= offset;
+
+/* Generate the rotation matrix that implements this rotation and use
+   it to rotate the first input point (3-vector) to give the required
+   result (3-vector). */
+            palDav2m( vrot, mrot );
+            palDmxv( mrot, v1, v3 );
+
+/* Convert the 3-vector back into spherical cooordinates and then
+   constrain the longitude result to lie in the range 0 to 2*pi. */
+            palDcc2s( v3, &p3[ 0 ], &p3[ 1 ] );
+            p3[ 0 ] = palDranrm( p3[ 0 ] );
+         }
+
+/* Permute the result coordinates to undo the effect of the SkyFrame
+   axis permutation array. */
+         point3[ 0 ] = p3[ perm[ 0 ] ];
+         point3[ 1 ] = p3[ perm[ 1 ] ];
+      }
+   }
+}
+
+static AstMapping *SkyOffsetMap( AstSkyFrame *this, int *status ){
+/*
+*++
+*  Name:
+c     astSkyOffsetMap
+f     AST_SKYOFFSETMAP
+
+*  Purpose:
+*     Returns a Mapping which goes from absolute coordinates to offset
+*     coordinates.
+
+*  Type:
+*     Public virtual function.
+
+*  Synopsis:
+c     #include "skyframe.h"
+c     AstMapping *astSkyOffsetMap( AstSkyFrame *this )
+f     RESULT = AST_SKYOFFSETMAP( THIS, STATUS )
+
+*  Class Membership:
+*     SkyFrame method.
+
+*  Description:
+*     This function returns a Mapping in which the forward transformation
+*     transforms a position in the coordinate system given by the System
+*     attribute of the supplied SkyFrame, into the offset coordinate system
+*     specified by the SkyRef, SkyRefP and SkyRefIs attributes of the
+*     supplied SkyFrame.
+*
+*     A UnitMap is returned if the SkyFrame does not define an offset
+*     coordinate system.
+
+*  Parameters:
+c     this
+f     THIS = INTEGER (Given)
+*        Pointer to the SkyFrame.
+f     STATUS = INTEGER (Given and Returned)
+f        The global status.
+
+*  Returned Value:
+c     astSkyOffsetMap()
+f     AST_SKYOFFSETMAP = INTEGER
+*        Pointer to the returned Mapping.
+
+*  Notes:
+*     - A null Object pointer (AST__NULL) will be returned if this
+c     function is invoked with the AST error status set, or if it
+f     function is invoked with STATUS set to an error value, or if it
+*     should fail for any reason.
+*--
+*/
+
+/* Local Variables: */
+   AstCmpMap *map3;            /* Partial Mapping. */
+   AstMapping *result;         /* The returned Mapping. */
+   AstMatrixMap *map1;         /* Spherical rotation in 3D cartesian space */
+   AstSphMap *map2;            /* 3D Cartesian to 2D spherical Mapping */
+   double *vx;                 /* Pointer to x unit vector. */
+   double *vy;                 /* Pointer to y unit vector. */
+   double *vz;                 /* Pointer to z unit vector. */
+   double mat[ 9 ];            /* Spherical rotation matrix */
+   double vmod;                /* Length of vector (+ve) */
+   double vp[ 3 ];             /* Unit vector representin SkyRefP position. */
+   int lataxis;                /* Index of the latitude axis */
+   int lonaxis;                /* Index of the longitude axis */
+
+/* Initialise. */
+   result = NULL;
+
+/* Check the global error status. */
+   if ( !astOK ) return result;
+
+/* Return a UnitMap if the offset coordinate system is not defined. */
+   if( astGetSkyRefIs( this ) == AST__IGNORED_REF ||
+       ( !astTestSkyRef( this, 0 ) && !astTestSkyRef( this, 1 ) ) ) {
+      result = (AstMapping *) astUnitMap( 2, "", status );
+
+/* Otherwise... */
+   } else {
+
+/* Get the longitude and latitude at the reference point and at a point
+   on the primary meridian. */
+      lataxis = astGetLatAxis( this );
+      lonaxis = 1 - lataxis;
+
+/* Initialise pointers to the rows of the 3x3 matrix. Each row will be
+   used to store a unit vector. */
+      vx = mat;
+      vy = mat + 3;
+      vz = mat + 6;
+
+/* The following trig converts between (longitude,latitude) and (x,y,z)
+   on a unit sphere, in which (0,0) is at (1,0,0), (0,pi/2) is (0,0,1)
+   and (pi/2,0) is at (0,1,0). */
+
+/* First deal with cases where the SkyRef attribute holds the standard
+   coords at the origin of the offset coordinate system. */
+      if( astGetSkyRefIs( this ) == AST__ORIGIN_REF ) {
+
+/* Convert each point into a 3-vector of unit length. The SkyRef position
+   defines the X axis in the offset coord system. */
+         palDcs2c( astGetSkyRef( this, lonaxis ), astGetSkyRef( this, lataxis ), vx );
+         palDcs2c( astGetSkyRefP( this, lonaxis ), astGetSkyRefP( this, lataxis ), vp );
+
+/* The Y axis is perpendicular to both the X axis and the skyrefp
+   position. That is, it is parallel to the cross product of the 2 above
+   vectors.*/
+         palDvxv( vp, vx, vy );
+
+/* Normalize the y vector. */
+         palDvn( vy, vy, &vmod );
+
+/* Report an error if the modulus of the vector is zero.*/
+         if( vmod == 0.0 ) {
+            astError( AST__BADOC, "astConvert(%s): The position specified by the SkyRefP "
+                      "attribute is either coincident, with or opposite to, the "
+                      "position specified by the SkyRef attribute.", status, astGetClass( this ) );
+
+/* If OK, form the Z axis as the cross product of the x and y axes. */
+         } else {
+            palDvxv( vx, vy, vz );
+
+         }
+
+/* Now deal with cases where the SkyRef attribute holds the standard
+   coords at the north pole of the offset coordinate system. */
+      } else {
+
+/* Convert each point into a 3-vector of unit length. The SkyRef position
+   defines the Z axis in the offset coord system. */
+         palDcs2c( astGetSkyRef( this, lonaxis ), astGetSkyRef( this, lataxis ), vz );
+         palDcs2c( astGetSkyRefP( this, lonaxis ), astGetSkyRefP( this, lataxis ), vp );
+
+/* The Y axis is perpendicular to both the Z axis and the skyrefp
+   position. That is, it is parallel to the cross product of the 2 above
+   vectors.*/
+         palDvxv( vz, vp, vy );
+
+/* Normalize the y vector. */
+         palDvn( vy, vy, &vmod );
+
+/* Report an error if the modulus of the vector is zero.*/
+         if( vmod == 0.0 ) {
+            astError( AST__BADOC, "astConvert(%s): The position specified by the SkyRefP "
+                      "attribute is either coincident, with or opposite to, the "
+                      "position specified by the SkyRef attribute.", status, astGetClass( this ) );
+
+/* If OK, form the X axis as the cross product of the y and z axes. */
+         } else {
+            palDvxv( vy, vz, vx );
+         }
+      }
+
+/* Create a MatrixMap which implements the above spherical rotation. Each
+   row in this matrix represents one of the unit axis vectors found above. */
+      map1 = astMatrixMap( 3, 3, 0, mat, "", status );
+
+/* Create a 3D cartesian to 2D spherical Mapping. */
+      map2 = astSphMap( "UnitRadius=1", status );
+
+/* Form a series CmpMap which converts from 2D (long,lat) in the base
+   System to 2D (long,lat) in the offset coordinate system. */
+      map3 = astCmpMap( map1, map2, 1, "", status );
+      astInvert( map2 );
+      result = (AstMapping *) astCmpMap( map2, map3, 1, "", status );
+
+/* Free resources. */
+      map1 = astAnnul( map1 );
+      map2 = astAnnul( map2 );
+      map3 = astAnnul( map3 );
+   }
+
+/* Annul the returned Mapping if anything has gone wrong. */
+   if( !astOK ) result = astAnnul( result );
+
+/* Return the result. */
+   return result;
+
+}
+
+static double Offset2( AstFrame *this_frame, const double point1[2],
+                       double angle, double offset, double point2[2], int *status ) {
+/*
+*  Name:
+*     Offset2
+
+*  Purpose:
+*     Calculate an offset along a geodesic curve at a given bearing.
+
+*  Type:
+*     Private function.
+
+*  Synopsis:
+*     #include "skyframe.h"
+*     double Offset2( AstFrame *this_frame, const double point1[2],
+*                     double angle, double offset, double point2[2], int *status )
+
+*  Class Membership:
+*     SkyFrame member function (over-rides the astOffset2 method
+*     inherited from the Frame class).
+
+*  Description:
+*     This function finds the SkyFrame coordinate values of a point
+*     which is offset a specified distance along the geodesic curve
+*     (i.e. great circle) at a given angle from a given starting point.
+
+*  Parameters:
+*     this
+*        Pointer to the SkyFrame.
+*     point1
+*        An array of double, with one element for each SkyFrame axis.
+*        This should contain the coordinates of the point marking the
+*        start of the geodesic curve.
+*     angle
+*        The angle (in radians) from the positive direction of the second
+*        axis, to the direction of the required position, as seen from
+*        the starting position. Positive rotation is in the sense of
+*        rotation from the positive direction of axis 2 to the positive
+*        direction of axis 1.
+*     offset
+*        The required offset from the first point along the geodesic
+*        curve, in radians. If this is positive, it will be towards
+*        the given angle. If it is negative, it will be in the
+*        opposite direction.
+*     point2
+*        An array of double, with one element for each SkyFrame axis
+*        in which the coordinates of the required point will be
+*        returned.
+*     status
+*        Pointer to the inherited status variable.
+
+*  Returned Value:
+*     The direction of the geodesic curve at the end point. That is, the
+*     angle (in radians) between the positive direction of the second
+*     axis and the continuation of the geodesic curve at the requested
+*     end point. Positive rotation is in the sense of rotation from
+*     the positive direction of axis 2 to the positive direction of axis
+*     1.
+
+*  Notes:
+*     - The geodesic curve used by this function is the path of
+*     shortest distance between two points, as defined by the
+*     astDistance function.
+*     - This function will return "bad" coordinate values (AST__BAD)
+*     if any of the input coordinates has this value.
+*/
+
+/* Local Variables: */
+   AstSkyFrame *this;          /* Pointer to the SkyFrame structure */
+   const int *perm;            /* Pointer to axis permutation array */
+   double p1[ 2 ];             /* Permuted coordinates for point1 */
+   double p2[ 2 ];             /* Permuted coordinates for point2 */
+   double result;              /* The returned answer */
+   double cosoff;              /* Cosine of offset */
+   double cosa1;               /* Cosine of longitude at start */
+   double cosb1;               /* Cosine of latitude at start */
+   double pa;                  /* A position angle measured from north */
+   double q1[ 3 ];             /* Vector PI/2 away from R4 in meridian of R4 */
+   double q2[ 3 ];             /* Vector PI/2 away from R4 on equator */
+   double q3[ 3 ];             /* Vector PI/2 away from R4 on great circle */
+   double r0[ 3 ];             /* Reference position vector */
+   double r3[ 3 ];             /* Vector PI/2 away from R0 on great circle */
+   double sinoff;              /* Sine of offset */
+   double sina1;               /* Sine of longitude at start */
+   double sinb1;               /* Sine of latitude at start */
+
+/* Initialise. */
+   result = AST__BAD;
+
+/* Check the global error status. */
+   if ( !astOK ) return result;
+
+/* Obtain a pointer to the SkyFrame structure. */
+   this = (AstSkyFrame *) this_frame;
+
+/* Obtain a pointer to the SkyFrame's axis permutation array. */
+   perm = astGetPerm( this );
+   if ( astOK ) {
+
+/* Check that all supplied values are OK. If not, generate "bad"
+   output coordinates. */
+      if ( ( point1[ 0 ] == AST__BAD ) || ( point1[ 1 ] == AST__BAD ) ||
+           ( angle == AST__BAD ) || ( offset == AST__BAD ) ) {
+         point2[ 0 ] = AST__BAD;
+         point2[ 1 ] = AST__BAD;
+
+/* Otherwise, apply the axis permutation array to obtain the
+   coordinates of the starting point in the required (longitude,latitude)
+   order. */
+      } else {
+         p1[ perm[ 0 ] ] = point1[ 0 ];
+         p1[ perm[ 1 ] ] = point1[ 1 ];
+
+/* If the axes are permuted, convert the supplied angle into a position
+   angle. */
+         pa = ( perm[ 0 ] == 0 )? angle: piby2 - angle;
+
+/* Use Shcal to calculate the required vectors R0 (representing
+   the reference point) and R3 (representing the point which is 90
+   degrees away from the reference point, along the required great
+   circle). The XY plane defines zero latitude, Z is in the direction
+   of increasing latitude, X is towards zero longitude, and Y is
+   towards longitude 90 degrees. */
+         Shcal( p1[ 0 ], p1[ 1 ], pa, r0, r3, status );
+
+/* Use Shapp to use R0 and R3 to calculate the new position. */
+         Shapp( offset, r0, r3,  p1[ 0 ], p2, status );
+
+/* Normalize the result. */
+         astNorm( this, p2 );
+
+/* Create the vector Q1 representing the point in the meridian of the
+   required point which has latitude 90 degrees greater than the
+   required point. */
+         sina1 = sin( p2[ 0 ] );
+         cosa1 = cos( p2[ 0 ] );
+         sinb1 = sin( p2[ 1 ] );
+         cosb1 = cos( p2[ 1 ] );
+
+         q1[ 0 ] = -sinb1*cosa1;
+         q1[ 1 ] = -sinb1*sina1;
+         q1[ 2 ] = cosb1;
+
+/* Create the vector Q2 representing the point on the equator (i.e. a
+   latitude of zero), which has a longitude 90 degrees to the west of
+   the required point. */
+         q2[ 0 ] = -sina1;
+         q2[ 1 ] =  cosa1;
+         q2[ 2 ] =  0.0;
+
+/* Create the vector Q3 representing the point which is 90 degrees away
+   from the required point, along the required great circle. */
+         cosoff = cos( offset );
+         sinoff = sin( offset );
+
+         q3[ 0 ] = -sinoff*r0[ 0 ] + cosoff*r3[ 0 ];
+         q3[ 1 ] = -sinoff*r0[ 1 ] + cosoff*r3[ 1 ];
+         q3[ 2 ] = -sinoff*r0[ 2 ] + cosoff*r3[ 2 ];
+
+/* Calculate the position angle of the great circle at the required
+   point. */
+         pa = atan2( palDvdv( q3, q2 ), palDvdv( q3, q1 ) );
+
+/* Convert this from a pa into the required angle. */
+         result = ( perm[ 0 ] == 0 )? pa: piby2 - pa;
+
+/* Ensure that the end angle is in the range 0 to 2*pi. */
+         result = palDranrm( result );
+
+/* Permute the result coordinates to undo the effect of the SkyFrame
+   axis permutation array. */
+         point2[ 0 ] = p2[ perm[ 0 ] ];
+         point2[ 1 ] = p2[ perm[ 1 ] ];
+      }
+   }
+
+/* Return the result. */
+   return result;
+
+}
+
+static void Overlay( AstFrame *template, const int *template_axes,
+                     AstFrame *result, int *status ) {
+/*
+*  Name:
+*     Overlay
+
+*  Purpose:
+*     Overlay the attributes of a template SkyFrame on to another Frame.
+
+*  Type:
+*     Private function.
+
+*  Synopsis:
+*     #include "skyframe.h"
+*     void Overlay( AstFrame *template, const int *template_axes,
+*                   AstFrame *result, int *status )
+
+*  Class Membership:
+*     SkyFrame member function (over-rides the protected astOverlay method
+*     inherited from the Frame class).
+
+*  Description:
+*     This function overlays attributes of a SkyFrame (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 SkyFrame and a change of sky
+*     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 SkyFrame, 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 SkyFrame, or from a class derived from it, then attributes may
+*     exist in the template SkyFrame 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 sky cordinates */
+   AstSystemType old_system;     /* Code identifying old sky coordinates */
+   int axis;                     /* Loop counter for result SkyFrame axes */
+   int skyref_changed;           /* Has the SkyRef attribute changed? */
+   int reset_system;             /* Was the template System value cleared? */
+   int skyframe;                 /* Result Frame is a SkyFrame? */
+   int tax0;                     /* Template axis for result axis 0 */
+   int tax1;                     /* Template axis for result axis 1 */
+
+/* Check the global error status. */
+   if ( !astOK ) return;
+
+/* Indicate that we do not need to reset the System attribute of the
+   template. */
+   reset_system = 0;
+   new_system = AST__UNKNOWN;
+
+/* If the result Frame is a SkyFrame, we must test to see if overlaying its
+   System attribute will change the type of sky coordinate system it
+   describes. Determine the value of this attribute for the result and template
+   SkyFrames. We also need to do this if either SkyRef attribute would
+   change. */
+   skyframe = astIsASkyFrame( result );
+   if ( skyframe ) {
+      old_system = astGetSystem( result );
+      new_system = astGetSystem( template );
+      skyref_changed = ( astGetSkyRef( result, 0 ) !=
+                         astGetSkyRef( template, 0 ) ) ||
+                       ( astGetSkyRef( result, 1 ) !=
+                         astGetSkyRef( template, 1 ) );
+
+/* If the coordinate system will change, any value already set for the result
+   SkyFrame's Title will no longer be appropriate, so clear it. */
+      if ( new_system != old_system || skyref_changed ) {
+         astClearTitle( result );
+
+/* Test if the old and new sky coordinate systems are similar enough to make
+   use of the same axis attribute values (e.g. if they are both equatorial
+   systems, then they can both use the same axis labels, etc.,so long as
+   the SKyRefIs value has not changed). */
+         if ( IsEquatorial( new_system, status ) != IsEquatorial( old_system, status ) ||
+              skyref_changed ) {
+
+/* If necessary, clear inappropriate values for all those axis attributes
+   whose access functions are over-ridden by this class (these access functions
+   will then provide suitable defaults appropriate to the new coordinate system
+   instead). */
+            for ( axis = 0; axis < 2; axis++ ) {
+               astClearAsTime( result, axis );
+               astClearDirection( result, axis );
+               astClearFormat( result, axis );
+               astClearLabel( result, axis );
+               astClearSymbol( result, axis );
+               astClearUnit( result, axis );
+            }
+         }
+      }
+
+/* If the result Frame is not a SkyFrame, 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 ) ) {
+         new_system = astGetSystem( template );
+         astClearSystem( template );
+         new_alignsystem = astGetAlignSystem( template );
+         astClearAlignSystem( template );
+         reset_system = 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( reset_system ) {
+      astSetSystem( template, new_system );
+      astSetAlignSystem( template, new_alignsystem );
+   }
+
+/* Check if the result Frame is a SkyFrame or from a class derived from
+   SkyFrame. If not, we cannot transfer SkyFrame attributes to it as it is
+   insufficiently specialised. In this case simply omit these attributes. */
+   if ( skyframe && astOK ) {
+
+/* Define a macro that tests whether an attribute is set in the template and,
+   if so, transfers its value to the result. */
+#define OVERLAY(attr) \
+   if ( astTest##attr( template ) ) { \
+      astSet##attr( result, astGet##attr( template ) ); \
+   }
+
+/* Store template axis indices */
+   if( template_axes ) {
+      tax0 = template_axes[ 0 ];
+      tax1 = template_axes[ 1 ];
+   } else {
+      tax0 = 0;
+      tax1 = 1;
+   }
+
+/* Define a similar macro that does the same for SkyFrame specific axis
+   attributes. */
+#define OVERLAY2(attr) \
+   if( astTest##attr( template, tax0 ) ) { \
+      astSet##attr( result, 0, astGet##attr( template, tax0 ) ); \
+   } \
+   if( astTest##attr( template, tax1 ) ) { \
+      astSet##attr( result, 1, astGet##attr( template, tax1 ) ); \
+   }
+
+/* Use the macro to transfer each SkyFrame attribute in turn. */
+      OVERLAY(Equinox);
+      OVERLAY(Projection);
+      OVERLAY(NegLon);
+      OVERLAY(SkyTol);
+      OVERLAY(AlignOffset);
+      OVERLAY(SkyRefIs);
+      OVERLAY2(SkyRef);
+      OVERLAY2(SkyRefP);
+   }
+
+/* Undefine macros local to this function. */
+#undef OVERLAY
+#undef OVERLAY2
+}
+
+static void Resolve( AstFrame *this_frame, const double point1[],
+                     const double point2[], const double point3[],
+                     double point4[], double *d1, double *d2, int *status ){
+/*
+*  Name:
+*     Resolve
+
+*  Purpose:
+*     Resolve a vector into two orthogonal components
+
+*  Type:
+*     Private function.
+
+*  Synopsis:
+*     #include "skyframe.h"
+*     void Resolve( AstFrame *this, const double point1[],
+*                   const double point2[], const double point3[],
+*                   double point4[], double *d1, double *d2, int *status )
+
+*  Class Membership:
+*     SkyFrame member function (over-rides the astResolve method
+*     inherited from the Frame class).
+
+*  Description:
+*     This function resolves a vector into two perpendicular components.
+*     The vector from point 1 to point 2 is used as the basis vector.
+*     The vector from point 1 to point 3 is resolved into components
+*     parallel and perpendicular to this basis vector. The lengths of the
+*     two components are returned, together with the position of closest
+*     aproach of the basis vector to point 3.
+*
+*     Each vector is a geodesic curve. For a SkyFrame, these are great
+*     circles on the celestial sphere.
+
+*  Parameters:
+*     this
+*        Pointer to the Frame.
+*     point1
+*        An array of double, with one element for each Frame axis
+*        (Naxes attribute). This marks the start of the basis vector,
+*        and of the vector to be resolved.
+*     point2
+*        An array of double, with one element for each Frame axis
+*        (Naxes attribute). This marks the end of the basis vector.
+*     point3
+*        An array of double, with one element for each Frame axis
+*        (Naxes attribute). This marks the end of the vector to be
+*        resolved.
+*     point4
+*        An array of double, with one element for each Frame axis
+*        in which the coordinates of the point of closest approach of the
+*        basis vector to point 3 will be returned.
+*     d1
+*        The address of a location at which to return the distance from
+*        point 1 to point 4 (that is, the length of the component parallel
+*        to the basis vector). Positive values are in the same sense as
+*        movement from point 1 to point 2.
+*     d2
+*        The address of a location at which to return the distance from
+*        point 4 to point 3 (that is, the length of the component
+*        perpendicular to the basis vector). The returned value is always
+*        positive.
+*     status
+*        Pointer to the inherited status variable.
+
+*  Notes:
+*     - This function will return "bad" coordinate values (AST__BAD)
+*     if any of the input coordinates has this value, or if the required
+*     output values are undefined.
+*/
+
+/* Local Variables: */
+   AstSkyFrame *this;            /* Pointer to the SkyFrame structure */
+   const int *perm;              /* Pointer to axis permutation array */
+   double n1[ 3 ];               /* Unit normal to grt crcl thru p1 and p2 */
+   double n2[ 3 ];               /* Unit normal to grt crcl thru p3 and p4 */
+   double p1[ 2 ];               /* Permuted coordinates for point1 */
+   double p2[ 2 ];               /* Permuted coordinates for point2 */
+   double p3[ 2 ];               /* Permuted coordinates for point3 */
+   double p4[ 2 ];               /* Permuted coordinates for point4 */
+   double v1[ 3 ];               /* 3-vector for p1 */
+   double v2[ 3 ];               /* 3-vector for p2 */
+   double v3[ 3 ];               /* 3-vector for p3 */
+   double v4[ 3 ];               /* 3-vector for p4 */
+   double v5[ 3 ];               /* 3-vector 90 degs away from p1 */
+   double vmod;                  /* Modulus of vector */
+   double vtemp[ 3 ];            /* Temporary vector workspace */
+
+/* Check the global error status. */
+   if ( !astOK ) return;
+
+/* Obtain a pointer to the SkyFrame structure. */
+   this = (AstSkyFrame *) this_frame;
+
+/* Store initial bad output values. */
+   point4[ 0 ] = AST__BAD;
+   point4[ 1 ] = AST__BAD;
+   *d1 = AST__BAD;
+   *d2 = AST__BAD;
+
+/* Check that all supplied values are OK. */
+   if ( ( point1[ 0 ] != AST__BAD ) && ( point1[ 1 ] != AST__BAD ) &&
+        ( point2[ 0 ] != AST__BAD ) && ( point2[ 1 ] != AST__BAD ) &&
+        ( point3[ 0 ] != AST__BAD ) && ( point3[ 1 ] != AST__BAD ) ) {
+
+/* If so, obtain a pointer to the SkyFrame's axis permutation array. */
+      perm = astGetPerm( this );
+      if ( astOK ) {
+
+/* Apply the axis permutation array to obtain the coordinates of the
+   three supplied point in the required (longitude,latitude) order. */
+         p1[ perm[ 0 ] ] = point1[ 0 ];
+         p1[ perm[ 1 ] ] = point1[ 1 ];
+         p2[ perm[ 0 ] ] = point2[ 0 ];
+         p2[ perm[ 1 ] ] = point2[ 1 ];
+         p3[ perm[ 0 ] ] = point3[ 0 ];
+         p3[ perm[ 1 ] ] = point3[ 1 ];
+
+/* Convert each point into a 3-vector of unit length. */
+         palDcs2c( p1[ 0 ], p1[ 1 ], v1 );
+         palDcs2c( p2[ 0 ], p2[ 1 ], v2 );
+         palDcs2c( p3[ 0 ], p3[ 1 ], v3 );
+
+/* Find the cross product between the first two vectors, and normalize is.
+   This is the unit normal to the great circle plane defining parallel
+   distance. */
+         palDvxv( v2, v1, vtemp );
+         palDvn( vtemp, n1, &vmod );
+
+/* Return with bad values if the normal is undefined (i.e. if the first two
+   vectors are identical or diametrically opposite). */
+         if( vmod > 0.0 ) {
+
+/* Now take the cross product of the normal vector and v1. This gives a
+   point, v5, on the great circle which is 90 degrees away from v1, in the
+   direction of v2. */
+            palDvxv( v1, n1, v5 );
+
+/* Find the cross product of the outlying point (point 3), and the vector
+   n1 found above, and normalize it. This is the unit normal to the great
+   circle plane defining perpendicular distance. */
+            palDvxv( v3, n1, vtemp );
+            palDvn( vtemp, n2, &vmod );
+
+/* Return with bad values if the normal is undefined (i.e. if the
+   outlying point is normal to the great circle defining the basis
+   vector). */
+            if( vmod > 0.0 ) {
+
+/* The point of closest approach, point 4, is the point which is normal
+   to both normal vectors (i.e. the intersection of the two great circles).
+   This is the cross product of n1 and n2. No need to normalize this time
+   since both n1 and n2 are unit vectors, and so v4 will already be a
+   unit vector. */
+               palDvxv( n1, n2, v4 );
+
+/* The dot product of v4 and v1 is the cos of the parallel distance,
+   d1, whilst the dot product of v4 and v5 is the sin of the parallel
+   distance. Use these to get the parallel distance with the correct
+   sign, in the range -PI to +PI. */
+               *d1 = atan2( palDvdv( v4, v5 ), palDvdv( v4, v1 ) );
+
+/* The dot product of v4 and v3 is the cos of the perpendicular distance,
+   d2, whilst the dot product of n1 and v3 is the sin of the perpendicular
+   distance. Use these to get the perpendicular distance. */
+               *d2 = fabs( atan2( palDvdv( v3, n1 ), palDvdv( v3, v4 ) ) );
+
+/* Convert the 3-vector representing the intersection of the two planes
+   back into spherical cooordinates and then constrain the longitude result
+   to lie in the range 0 to 2*pi. */
+               palDcc2s( v4, &p4[ 0 ], &p4[ 1 ] );
+               p4[ 0 ] = palDranrm( p4[ 0 ] );
+
+/* Permute the result coordinates to undo the effect of the SkyFrame
+   axis permutation array. */
+               point4[ 0 ] = p4[ perm[ 0 ] ];
+               point4[ 1 ] = p4[ perm[ 1 ] ];
+            }
+         }
+      }
+   }
+
+   return;
+
+}
+
+static AstPointSet *ResolvePoints( AstFrame *this_frame, const double point1[],
+                                   const double point2[], AstPointSet *in,
+                                   AstPointSet *out, int *status ) {
+/*
+*  Name:
+*     ResolvePoints
+
+*  Purpose:
+*     Resolve a set of vectors into orthogonal components
+
+*  Type:
+*     Private function.
+
+*  Synopsis:
+*     #include "frame.h"
+*     AstPointSet *astResolvePoints( AstFrame *this, const double point1[],
+*                                    const double point2[], AstPointSet *in,
+*                                    AstPointSet *out )
+
+*  Class Membership:
+*     SkyFrame member function (over-rides the astResolvePoints method
+*     inherited from the Frame class).
+
+*  Description:
+*     This function takes a Frame and a set of vectors encapsulated
+*     in a PointSet, and resolves each one into two orthogonal components,
+*     returning these two components in another PointSet.
+*
+*     This is exactly the same as the public astResolve method, except
+*     that this method allows many vectors to be processed in a single call,
+*     thus reducing the computational cost of overheads of many
+*     individual calls to astResolve.
+
+*  Parameters:
+*     this
+*        Pointer to the Frame.
+*     point1
+*        An array of double, with one element for each Frame axis
+*        (Naxes attribute). This marks the start of the basis vector,
+*        and of the vectors to be resolved.
+*     point2
+*        An array of double, with one element for each Frame axis
+*        (Naxes attribute). This marks the end of the basis vector.
+*     in
+*        Pointer to the PointSet holding the ends of the vectors to be
+*        resolved.
+*     out
+*        Pointer to a PointSet which will hold the length of the two
+*        resolved components. A NULL value may also be given, in which
+*        case a new PointSet will be created by this function.
+
+*  Returned Value:
+*     Pointer to the output (possibly new) PointSet. The first axis will
+*     hold the lengths of the vector components parallel to the basis vector.
+*     These values will be signed (positive values are in the same sense as
+*     movement from point 1 to point 2. The second axis will hold the lengths
+*     of the vector components perpendicular to the basis vector. These
+*     values will be signed only if the Frame is 2-dimensional, in which
+*     case a positive value indicates that rotation from the basis vector
+*     to the tested vector is in the same sense as rotation from the first
+*     to the second axis of the Frame.
+
+*  Notes:
+*     - The number of coordinate values per point in the input
+*     PointSet must match the number of axes in the supplied Frame.
+*     - If an output PointSet is supplied, it must have space for
+*     sufficient number of points and 2 coordinate values per point.
+*     - 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.
+*     - We assume spherical geometry throughout this function.
+*/
+
+/* Local Variables: */
+   AstPointSet *result;          /* Pointer to output PointSet */
+   AstSkyFrame *this;            /* Pointer to SkyFrame structure */
+   const int *perm;              /* Pointer to axis permutation array */
+   double **ptr_in;              /* Pointers to input axis values */
+   double **ptr_out;             /* Pointers to returned axis values */
+   double *d1;                   /* Pointer to next parallel component value */
+   double *d2;                   /* Pointer to next perpendicular component value */
+   double *point3x;              /* Pointer to next first axis value */
+   double *point3y;              /* Pointer to next second axis value */
+   double n1[ 3 ];               /* Unit normal to grt crcl thru p1 and p2 */
+   double n2[ 3 ];               /* Unit normal to grt crcl thru p3 and p4 */
+   double p1[ 2 ];               /* Permuted coordinates for point1 */
+   double p2[ 2 ];               /* Permuted coordinates for point2 */
+   double p3[ 2 ];               /* Permuted coordinates for point3 */
+   double sign;                  /* Sign for perpendicular distances */
+   double v1[ 3 ];               /* 3-vector for p1 */
+   double v2[ 3 ];               /* 3-vector for p2 */
+   double v3[ 3 ];               /* 3-vector for p3 */
+   double v4[ 3 ];               /* 3-vector for p4 */
+   double v5[ 3 ];               /* 3-vector 90 degs away from p1 */
+   double vmod;                  /* Modulus of vector */
+   double vtemp[ 3 ];            /* Temporary vector workspace */
+   int ipoint;                   /* Index of next point */
+   int ncoord_in;                /* Number of input PointSet coordinates */
+   int ncoord_out;               /* Number of coordinates in output PointSet */
+   int npoint;                   /* Number of points to transform */
+   int npoint_out;               /* Number of points in output PointSet */
+   int ok;                       /* OK to proceed? */
+
+/* Initialise. */
+   result = NULL;
+
+/* Check the global error status. */
+   if ( !astOK ) return result;
+
+/* Get a pointer to the SkyFrame structure. */
+   this = (AstSkyFrame *) this_frame;
+
+/* Obtain the number of input vectors to resolve and the number of coordinate
+   values per vector. */
+   npoint = astGetNpoint( in );
+   ncoord_in = astGetNcoord( in );
+
+/* If OK, check that the number of input coordinates matches the number
+   required by the Frame. Report an error if these numbers do not match. */
+   if ( astOK && ( ncoord_in != 2 ) ) {
+      astError( AST__NCPIN, "astResolvePoints(%s): Bad number of coordinate "
+                "values (%d) in input %s.", status, astGetClass( this ), ncoord_in,
+                astGetClass( in ) );
+      astError( AST__NCPIN, "The %s given requires 2 coordinate values for "
+                "each input point.", status, astGetClass( this ) );
+   }
+
+/* If still OK, and a non-NULL pointer has been given for the output PointSet,
+   then obtain the number of points and number of coordinates per point for
+   this PointSet. */
+   if ( astOK && out ) {
+      npoint_out = astGetNpoint( out );
+      ncoord_out = astGetNcoord( out );
+
+/* Check that the dimensions of this PointSet are adequate to accommodate the
+   output coordinate values and report an error if they are not. */
+      if ( astOK ) {
+         if ( npoint_out < npoint ) {
+            astError( AST__NOPTS, "astResolvePoints(%s): Too few points (%d) in "
+                      "output %s.", status, astGetClass( this ), npoint_out,
+                      astGetClass( out ) );
+            astError( AST__NOPTS, "The %s needs space to hold %d transformed "
+                      "point(s).", status, astGetClass( this ), npoint );
+         } else if ( ncoord_out < 2 ) {
+            astError( AST__NOCTS, "astResolvePoints(%s): Too few coordinate "
+                      "values per point (%d) in output %s.", status,
+                      astGetClass( this ), ncoord_out, astGetClass( out ) );
+            astError( AST__NOCTS, "The %s supplied needs space to store 2 "
+                      "coordinate value(s) per transformed point.", status,
+                      astGetClass( this ) );
+         }
+      }
+   }
+
+/* If all the validation stages are passed successfully, and a NULL output
+   pointer was given, then create a new PointSet to encapsulate the output
+   coordinate data. */
+   if ( astOK ) {
+      if ( !out ) {
+         result = astPointSet( npoint, 2, "", status );
+
+/* Otherwise, use the PointSet supplied. */
+      } else {
+         result = out;
+      }
+   }
+
+/* Get pointers to the input and output axis values */
+   ptr_in = astGetPoints( in );
+   ptr_out = astGetPoints( result );
+
+/* Obtain a pointer to the SkyFrame's axis permutation array. */
+   perm = astGetPerm( this );
+
+/* If the axes have been swapped we need to swap the sign of the returned
+   perpendicular distances. */
+   sign = ( perm[ 0 ] == 0 ) ? -1.0 : 1.0;
+
+/* Check pointers can be used safely */
+   if( astOK ) {
+
+/* Apply the axis permutation array to obtain the coordinates of the
+   two supplied points in the required (longitude,latitude) order. */
+      p1[ perm[ 0 ] ] = point1[ 0 ];
+      p1[ perm[ 1 ] ] = point1[ 1 ];
+      p2[ perm[ 0 ] ] = point2[ 0 ];
+      p2[ perm[ 1 ] ] = point2[ 1 ];
+
+/* Convert these points into 3-vectors of unit length. */
+      palDcs2c( p1[ 0 ], p1[ 1 ], v1 );
+      palDcs2c( p2[ 0 ], p2[ 1 ], v2 );
+
+/* Find the cross product between the vectors, and normalize it. This is the
+   unit normal to the great circle plane defining parallel distance. */
+      palDvxv( v2, v1, vtemp );
+      palDvn( vtemp, n1, &vmod );
+
+/* Return with bad values if the normal is undefined (i.e. if the first two
+   vectors are identical or diametrically opposite). */
+      ok = 0;
+      if( vmod > 0.0 ) {
+         ok = 1;
+
+/* Now take the cross product of the normal vector and v1. This gives a
+   point, v5, on the great circle which is 90 degrees away from v1, in the
+   direction of v2. */
+         palDvxv( v1, n1, v5 );
+      }
+
+/* Store pointers to the first two axis arrays in the returned PointSet. */
+      d1 = ptr_out[ 0 ];
+      d2 = ptr_out[ 1 ];
+
+/* Store pointers to the axis values in the supplied PointSet. */
+      point3x = ptr_in[ 0 ];
+      point3y = ptr_in[ 1 ];
+
+/* Check supplied values can be used */
+      if( ok ) {
+
+/* Loop round each supplied vector. */
+         for( ipoint = 0; ipoint < npoint; ipoint++, d1++, d2++,
+                                           point3x++, point3y++ ) {
+
+/* Store bad output values if either input axis value is bad. */
+            if( *point3x == AST__BAD || *point3y == AST__BAD ){
+               *d1 = AST__BAD;
+               *d2 = AST__BAD;
+
+/* If both are good... */
+            } else {
+
+/* Apply the axis permutation array to obtain the coordinates in the
+   required (longitude,latitude) order. */
+               p3[ perm[ 0 ] ] = *point3x;
+               p3[ perm[ 1 ] ] = *point3y;
+
+/* Convert into a 3-vector of unit length. */
+               palDcs2c( p3[ 0 ], p3[ 1 ], v3 );
+
+/* Find the cross product of the outlying point (point 3), and the vector
+   n1 found above, and normalize it. This is the unit normal to the great
+   circle plane defining perpendicular distance. */
+               palDvxv( v3, n1, vtemp );
+               palDvn( vtemp, n2, &vmod );
+
+/* Return with bad values if the normal is undefined (i.e. if the
+   outlying point is normal to the great circle defining the basis
+   vector). */
+               if( vmod <= 0.0 ) {
+                  *d1 = AST__BAD;
+                  *d2 = AST__BAD;
+               } else {
+
+/* The point of closest approach, point 4, is the point which is normal
+   to both normal vectors (i.e. the intersection of the two great circles).
+   This is the cross product of n1 and n2. No need to normalize this time
+   since both n1 and n2 are unit vectors, and so v4 will already be a
+   unit vector. */
+                  palDvxv( n1, n2, v4 );
+
+/* The dot product of v4 and v1 is the cos of the parallel distance,
+   d1, whilst the dot product of v4 and v5 is the sin of the parallel
+   distance. Use these to get the parallel distance with the correct
+   sign, in the range -PI to +PI. */
+                  *d1 = atan2( palDvdv( v4, v5 ), palDvdv( v4, v1 ) );
+
+/* The dot product of v4 and v3 is the cos of the perpendicular distance,
+   d2, whilst the dot product of n1 and v3 is the sin of the perpendicular
+   distance. Use these to get the perpendicular distance. */
+                  *d2 = sign*atan2( palDvdv( v3, n1 ), palDvdv( v3, v4 ) );
+               }
+            }
+         }
+
+/* If supplied values cannot be used, fill the returned PointSet with bad
+   values */
+      } else {
+         for( ipoint = 0; ipoint < npoint; ipoint++, d1++, d2++ ) {
+            *d1 = AST__BAD;
+            *d2 = AST__BAD;
+         }
+      }
+   }
+
+/* Annul the returned PointSet if an error occurred. */
+   if( !astOK ) result = astAnnul( result );
+
+/* Return a pointer to the output PointSet. */
+   return result;
+}
+
+static void SetAsTime( AstSkyFrame *this, int axis, int value, int *status ) {
+/*
+*  Name:
+*     SetAsTime
+
+*  Purpose:
+*     Set a value for the AsTime attribute for a SkyFrame's axis.
+
+*  Type:
+*     Private function.
+
+*  Synopsis:
+*     #include "skyframe.h"
+*     void SetAsTime( AstSkyFrame *this, int axis, int value, int *status )
+
+*  Class Membership:
+*     SkyFrame member function.
+
+*  Description:
+*     This function sets the boolean value of the AsTime attribute for a
+*     specified axis of a SkyFrame. This value indicates whether axis values
+*     should be formatted as times (as opposed to angles) by default.
+
+*  Parameters:
+*     this
+*        Pointer to the SkyFrame.
+*     axis
+*        Index of the axis for which a value is to be set (zero based).
+*     value
+*        The boolean value to be set.
+*     status
+*        Pointer to the inherited status variable.
+
+*  Returned Value:
+*     void.
+*/
+
+/* Local Variables: */
+   AstAxis *ax;                  /* Pointer to Axis object */
+   AstSkyAxis *new_ax;           /* Pointer to new SkyAxis object */
+
+/* Check the global error status. */
+   if ( !astOK ) return;
+
+/* Validate the axis index. */
+   (void) astValidateAxis( this, axis, 1, "astSetAsTime" );
+
+/* Obtain a pointer to the Axis object. */
+   ax = astGetAxis( this, axis );
+
+/* Check if the Axis object is a SkyAxis. If not, we will replace it with
+   one. */
+   if ( !astIsASkyAxis( ax ) ) {
+
+/* Create a new SkyAxis and overlay the attributes of the original Axis. */
+      new_ax = astSkyAxis( "", status );
+      astAxisOverlay( ax, new_ax );
+
+/* Modify the SkyFrame to use the new Skyaxis and annul the original Axis
+   pointer. Retain a pointer to the new SkyAxis. */
+      astSetAxis( this, axis, new_ax );
+      ax = astAnnul( ax );
+      ax = (AstAxis *) new_ax;
+   }
+
+/* Set a value for the Axis AsTime attribute. */
+   astSetAxisAsTime( ax, value );
+
+/* Annul the Axis pointer. */
+   ax = astAnnul( ax );
+}
+
+static void SetAttrib( AstObject *this_object, const char *setting, int *status ) {
+/*
+*  Name:
+*     SetAttrib
+
+*  Purpose:
+*     Set an attribute value for a SkyFrame.
+
+*  Type:
+*     Private function.
+
+*  Synopsis:
+*     #include "skyframe.h"
+*     void SetAttrib( AstObject *this, const char *setting, int *status )
+
+*  Class Membership:
+*     SkyFrame member function (extends the astSetAttrib method inherited from
+*     the Mapping class).
+
+*  Description:
+*     This function assigns an attribute value for a SkyFrame, 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 SkyFrame.
+*     setting
+*        Pointer to a null terminated string specifying the new attribute
+*        value.
+*     status
+*        Pointer to the inherited status variable.
+
+*  Returned Value:
+*     void
+
+*  Attributes:
+*     As well as those attributes inherited from the parent class, this
+*     function also accepts values for the following additional attributes:
+*
+*        Equinox (double, read as a string)
+
+*  Notes:
+*     This protected method is intended to be invoked by the Object astSet
+*     method and makes additional attributes accessible to it.
+*/
+
+/* Local Vaiables: */
+   AstSkyFrame *this;            /* Pointer to the SkyFrame structure */
+   double dval;                  /* Floating point attribute value */
+   double dval1;                 /* Floating point attribute value */
+   double dval2;                 /* Floating point attribute value */
+   double mjd;                   /* Modified Julian Date */
+   int astime;                   /* Value of AsTime attribute */
+   int axis;                     /* Axis index */
+   int equinox;                  /* Offset of Equinox attribute value */
+   int ival;                     /* Integer attribute value */
+   int len;                      /* Length of setting string */
+   int nc;                       /* Number of characters read by astSscanf */
+   int neglon;                   /* Display -ve longitudes? */
+   int ok;                       /* Can string be used? */
+   int offset;                   /* Offset of start of attribute value */
+   int projection;               /* Offset of projection attribute value */
+
+/* Check the global error status. */
+   if ( !astOK ) return;
+
+/* Obtain a pointer to the SkyFrame structure. */
+   this = (AstSkyFrame *) 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. */
+
+/* AsTime(axis). */
+/* ------------- */
+   if ( nc = 0,
+        ( 2 == astSscanf( setting, "astime(%d)= %d %n", &axis, &astime, &nc ) )
+        && ( nc >= len ) ) {
+      astSetAsTime( this, axis - 1, astime );
+
+/* Equinox. */
+/* -------- */
+   } else if ( nc = 0,
+               ( 0 == astSscanf( setting, "equinox=%n%*[^\n]%n",
+                              &equinox, &nc ) ) && ( nc >= len ) ) {
+
+/* Convert the Equinox value to a Modified Julian Date before use. */
+      mjd = astReadDateTime( setting + equinox );
+      if ( astOK ) {
+         astSetEquinox( this, mjd );
+
+/* Report contextual information if the conversion failed. */
+      } else {
+         astError( AST__ATTIN, "astSetAttrib(%s): Invalid equinox value "
+                   "\"%s\" given for sky coordinate system.", status,
+                   astGetClass( this ), setting + equinox );
+      }
+
+/* NegLon. */
+/* ------- */
+   } else if ( nc = 0,
+             ( 1 == astSscanf( setting, "neglon= %d %n", &neglon, &nc ) )
+               && ( nc >= len ) ) {
+      astSetNegLon( this, neglon );
+
+/* SkyTol. */
+/* ------- */
+   } else if ( nc = 0,
+             ( 1 == astSscanf( setting, "skytol= %lg %n", &dval, &nc ) )
+               && ( nc >= len ) ) {
+      astSetSkyTol( this, dval );
+
+/* Projection. */
+/* ----------- */
+   } else if ( nc = 0,
+               ( 0 == astSscanf( setting, "projection=%n%*[^\n]%n",
+                              &projection, &nc ) )
+               && ( nc >= len ) ) {
+      astSetProjection( this, setting + projection );
+
+/* SkyRef. */
+/* ------- */
+   } else if ( nc = 0,
+               ( 0 == astSscanf( setting, "skyref=%n%*[^\n]%n",
+                                 &offset, &nc ) )
+               && ( nc >= len ) ) {
+      ok = 0;
+      nc = astUnformat( this, 0, setting + offset, &dval1 );
+      if( setting[ offset + nc ] == ',' ) {
+         nc++;
+         nc += astUnformat( this, 1, setting + offset + nc, &dval2 );
+         if( nc == strlen( setting + offset ) ) {
+            astSetSkyRef( this, 0, dval1 );
+            astSetSkyRef( this, 1, dval2 );
+            ok = 1;
+         }
+      }
+
+      if( !ok && astOK ) {
+         astError( AST__BADOC, "astSetAttrib(%s): Invalid axis values string "
+                   "\"%.*s\" given for SkyRef attribute.", status, astGetClass( this ),
+                   (int) astChrLen( setting + offset ), setting + offset );
+      }
+
+/* SkyRef(axis). */
+/* ------------- */
+   } else if ( nc = 0,
+               ( 2 == astSscanf( setting, "skyref(%d)= %lg %n",
+                                 &axis, &dval, &nc ) )
+               && ( nc >= len ) ) {
+      astSetSkyRef( this, axis - 1, dval );
+
+/* SkyRefIs. */
+/* --------- */
+   } else if ( nc = 0,
+               ( 0 == astSscanf( setting, "skyrefis=%n%*[^\n]%n",
+                              &offset, &nc ) )
+               && ( nc >= len ) ) {
+
+      if( astChrMatch( setting + offset, POLE_STRING ) ) {
+         astSetSkyRefIs( this, AST__POLE_REF );
+
+      } else if( astChrMatch( setting + offset, ORIGIN_STRING ) ) {
+         astSetSkyRefIs( this, AST__ORIGIN_REF );
+
+      } else if( astChrMatch( setting + offset, IGNORED_STRING ) ) {
+         astSetSkyRefIs( this, AST__IGNORED_REF );
+
+      } else if( astOK ) {
+         astError( AST__OPT, "astSet(%s): option '%s' is unknown in '%s'.", status,
+                   astGetClass( this ), setting+offset, setting );
+      }
+
+/* SkyRefP. */
+/* -------- */
+   } else if ( nc = 0,
+               ( 0 == astSscanf( setting, "skyrefp=%n%*[^\n]%n",
+                                 &offset, &nc ) )
+               && ( nc >= len ) ) {
+
+      ok = 0;
+      nc = astUnformat( this, 0, setting + offset, &dval1 );
+      if( setting[ offset + nc ] == ',' ) {
+         nc++;
+         nc += astUnformat( this, 1, setting + offset + nc, &dval2 );
+         if( nc == strlen( setting + offset ) ) {
+            astSetSkyRefP( this, 0, dval1 );
+            astSetSkyRefP( this, 1, dval2 );
+            ok = 1;
+         }
+      }
+
+      if( !ok && astOK ) {
+         astError( AST__BADOC, "astSetAttrib(%s): Invalid axis values string "
+                   "\"%.*s\" given for SkyRefP attribute.", status, astGetClass( this ),
+                   (int) astChrLen( setting + offset ), setting + offset );
+      }
+
+
+/* SkyRefP(axis). */
+/* -------------- */
+   } else if ( nc = 0,
+               ( 2 == astSscanf( setting, "skyrefp(%d)= %lg %n",
+                                 &axis, &dval, &nc ) )
+               && ( nc >= len ) ) {
+      astSetSkyRefP( this, axis - 1, dval );
+
+/* AlignOffset. */
+/* ------------ */
+   } else if ( nc = 0,
+             ( 1 == astSscanf( setting, "alignoffset= %d %n", &ival, &nc ) )
+               && ( nc >= len ) ) {
+      astSetAlignOffset( this, ival );
+
+/* Define a macro to see if the setting string matches any of the
+   read-only attributes of this class. */
+#define MATCH(attrib) \
+        ( nc = 0, ( 0 == astSscanf( setting, attrib "=%*[^\n]%n", &nc ) ) && \
+                  ( nc >= len ) )
+
+/* If the attribute was not recognised, use this macro to report an error
+   if a read-only attribute has been specified. */
+   } else if ( !strncmp( setting, "islataxis", 9 ) ||
+               !strncmp( setting, "islonaxis", 9 ) ||
+               MATCH( "lataxis" ) ||
+               MATCH( "lonaxis" ) ) {
+      astError( AST__NOWRT, "astSet: The setting \"%s\" is invalid for a %s.", status,
+                setting, astGetClass( this ) );
+      astError( AST__NOWRT, "This is a read-only attribute." , status);
+
+/* Pass any unrecognised setting to the parent method for further
+   interpretation. */
+   } else {
+      (*parent_setattrib)( this_object, setting, status );
+   }
+}
+
+static void SetCachedLAST( AstSkyFrame *this, double last, double epoch,
+                           double obslon, double obslat, double obsalt,
+                           double dut1, double dtai, int *status ) {
+/*
+*  Name:
+*     SetCachedLAST
+
+*  Purpose:
+*     Store a LAST value in the cache in the SkyFrame vtab.
+
+*  Type:
+*     Private function.
+
+*  Synopsis:
+*     #include "skyframe.h"
+*     void SetCachedLAST( AstSkyFrame *this, double last, double epoch,
+*                         double obslon, double obslat, double obsalt,
+*                         double dut1, double dtai, int *status )
+
+*  Class Membership:
+*     SkyFrame member function.
+
+*  Description:
+*     This function stores the supplied LAST value in a cache in the
+*     SkyFrame virtual function table for later use by GetCachedLAST.
+
+*  Parameters:
+*     this
+*        Pointer to the SkyFrame.
+*     last
+*        The Local Apparent Sidereal Time (radians).
+*     epoch
+*        The epoch (MJD).
+*     obslon
+*        Observatory geodetic longitude (radians)
+*     obslat
+*        Observatory geodetic latitude (radians)
+*     obsalt
+*        Observatory geodetic altitude (metres)
+*     dut1
+*        The UT1-UTC correction, in seconds.
+*     dtai
+*        The TAI-UTC correction, in seconds.
+*     status
+*        Pointer to the inherited status variable.
+
+*/
+
+/* Local Variables: */
+   astDECLARE_GLOBALS
+   AstSkyLastTable *table;
+   double *ep;
+   double *lp;
+   double lp_ref;
+   int i;
+   int itable;
+
+/* Get a pointer to the structure holding thread-specific global data. */
+   astGET_GLOBALS(this);
+
+/* Initialise */
+   table = NULL;
+
+/* Check the global error status. */
+   if ( !astOK ) return;
+
+/* Ensure no threads are allowed to read the table whilst we are writing
+   to it. */
+   LOCK_WLOCK1
+
+/* Loop round every LAST table held in the vtab. Each table refers to a
+   different observatory position and/or DUT1 and/or DTAI value. */
+   for( itable = 0; itable < nlast_tables; itable++ ) {
+      table = last_tables[ itable ];
+
+/* See if the table refers to the given position, dut1 and dtai value, allowing
+   some small tolerance. If it does, leave the loop. */
+      if( fabs( table->obslat - obslat ) < 2.0E-7 &&
+          fabs( table->obslon - obslon ) < 2.0E-7 &&
+          fabs( table->obsalt - obsalt ) < 1.0 &&
+          fabs( table->dut1 - dut1 ) < 1.0E-5 &&
+          EQUAL( table->dtai, dtai, 1.0E-5 ) ) break;
+
+/* Ensure "table" ends up NULL if no suitable table is found. */
+      table = NULL;
+   }
+
+/* If no table was found, create one now, and add it into the vtab cache. */
+   if( !table ) {
+
+      astBeginPM;
+      table = astMalloc( sizeof( AstSkyLastTable ) );
+      itable = nlast_tables++;
+      last_tables = astGrow( last_tables, nlast_tables,
+                                   sizeof( AstSkyLastTable * ) );
+      astEndPM;
+
+      if( astOK ) {
+         last_tables[ itable ] = table;
+         table->obslat = obslat;
+         table->obslon = obslon;
+         table->obsalt = obsalt;
+         table->dut1 = dut1;
+         table->dtai = dtai;
+         table->nentry = 1;
+
+         astBeginPM;
+         table->epoch = astMalloc( sizeof( double ) );
+         table->last = astMalloc( sizeof( double ) );
+         astEndPM;
+
+         if( astOK ) {
+            table->epoch[ 0 ] = epoch;
+            table->last[ 0 ] = last;
+         }
+      }
+
+
+/* If we have a table, add the new point into it. */
+   } else {
+
+/* Extend the epoch and last arrays. */
+      astBeginPM;
+      table->epoch = astGrow( table->epoch, ++(table->nentry), sizeof( double ) );
+      table->last = astGrow( table->last, table->nentry, sizeof( double ) );
+      astEndPM;
+
+/* Check memory allocation was successful. */
+      if( astOK ) {
+
+/* Get pointers to the last original elements in the arrays of epoch and
+   corresponding LAST values in the table. */
+         ep = table->epoch + table->nentry - 2;
+         lp = table->last + table->nentry - 2;
+
+/* Starting from the end of the arrays, shuffle all entries up one
+   element until an element is found which is less than the supplied epoch
+   value. This maintains the epoch array in monotonic increasing order. */
+         for( i = table->nentry - 2; i >= 0; i--,ep--,lp-- ) {
+            if( *ep <= epoch ) break;
+            ep[ 1 ] = *ep;
+            lp[ 1 ] = *lp;
+         }
+
+/* Store the new epoch and LAST value. Add or subtract 2.PI as needed
+   from the new LAST value to ensure it is continuous with an adjacent
+   LAST value. This is needed for interpolation between the two values
+   to be meaningful.  */
+         ep[ 1 ] = epoch;
+
+/* For most cases, compare with the previous LAST value. If the new epoch
+   value is smaller than any epoch already in the table, there will be no
+   previous LAST value. So compare with the next value instead. */
+         if( i >= 0 ) {
+            lp_ref = lp[ 0 ];
+         } else {
+            lp_ref = lp[ 2 ];
+         }
+
+         if( last > lp_ref + AST__DPI ) {
+            lp[ 1 ] = last - 2*AST__DPI;
+
+         } else if( last < lp_ref - AST__DPI ) {
+            lp[ 1 ] = last + 2*AST__DPI;
+
+         } else {
+            lp[ 1 ] = last;
+         }
+      }
+   }
+
+/* Indicate other threads are now allowed to read the table. */
+   UNLOCK_RWLOCK1
+
+}
+
+static void SetDtai( AstFrame *this_frame, double val, int *status ) {
+/*
+*  Name:
+*     SetDtai
+
+*  Purpose:
+*     Set the value of the Dtai attribute for a SkyFrame.
+
+*  Type:
+*     Private function.
+
+*  Synopsis:
+*     #include "skyframe.h"
+*     void SetDtai( AstFrame *this, double val, int *status )
+
+*  Class Membership:
+*     SkyFrame member function (over-rides the astSetDtai method
+*     inherited from the Frame class).
+
+*  Description:
+*     This function clears the Dtai value and updates the LAST value
+*     stored in the SkyFrame.
+
+*  Parameters:
+*     this
+*        Pointer to the SkyFrame.
+*     val
+*        New Dtai value.
+*     status
+*        Pointer to the inherited status variable.
+
+*/
+
+/* Local Variables: */
+   AstSkyFrame *this;
+   double orig;
+
+/* Check the global error status. */
+   if ( !astOK ) return;
+
+/* Obtain a pointer to the SkyFrame structure. */
+   this = (AstSkyFrame *) this_frame;
+
+/* Note the original Dtai value. */
+   orig = astGetDtai( this );
+
+/* Invoke the parent method to set the Frame Dtai value. */
+   (*parent_setdtai)( this_frame, val, status );
+
+/* If the DTAI value has changed significantly, indicate that the LAST value
+   will need to be re-calculated when it is next needed. */
+   if( ! EQUAL( orig, val, 1.0E-6 ) ) {
+      this->last = AST__BAD;
+      this->eplast = AST__BAD;
+      this->klast = AST__BAD;
+   }
+}
+
+static void SetDut1( AstFrame *this_frame, double val, int *status ) {
+/*
+*  Name:
+*     SetDut1
+
+*  Purpose:
+*     Set the value of the Dut1 attribute for a SkyFrame.
+
+*  Type:
+*     Private function.
+
+*  Synopsis:
+*     #include "skyframe.h"
+*     void SetDut1( AstFrame *this, double val, int *status )
+
+*  Class Membership:
+*     SkyFrame member function (over-rides the astSetDut1 method
+*     inherited from the Frame class).
+
+*  Description:
+*     This function clears the Dut1 value and updates the LAST value
+*     stored in the SkyFrame.
+
+*  Parameters:
+*     this
+*        Pointer to the SkyFrame.
+*     val
+*        New Dut1 value.
+*     status
+*        Pointer to the inherited status variable.
+
+*/
+
+/* Local Variables: */
+   AstSkyFrame *this;
+   double orig;
+
+/* Check the global error status. */
+   if ( !astOK ) return;
+
+/* Obtain a pointer to the SkyFrame structure. */
+   this = (AstSkyFrame *) this_frame;
+
+/* Note the original Dut1 value. */
+   orig = astGetDut1( this );
+
+/* Invoke the parent method to set the Frame Dut1 value. */
+   (*parent_setdut1)( this_frame, val, status );
+
+/* If the DUT1 value has changed significantly, indicate that the LAST value
+   will need to be re-calculated when it is next needed. */
+   if( fabs( orig - val ) > 1.0E-6 ) {
+      this->last = AST__BAD;
+      this->eplast = AST__BAD;
+      this->klast = AST__BAD;
+   }
+}
+
+static void SetLast( AstSkyFrame *this, int *status ) {
+/*
+*  Name:
+*     SetLast
+
+*  Purpose:
+*     Set the Local Appearent Sidereal Time for a SkyFrame.
+
+*  Type:
+*     Private function.
+
+*  Synopsis:
+*     #include "skyframe.h"
+*     void SetLast( AstSkyFrame *this, int *status )
+
+*  Class Membership:
+*     SkyFrame member function.
+
+*  Description:
+*     This function sets the Local Apparent Sidereal Time at the epoch
+*     and geographical longitude given by the current values of the Epoch
+*     and ObsLon attributes associated with the supplied SkyFrame.
+
+*  Parameters:
+*     this
+*        Pointer to the SkyFrame.
+*     status
+*        Pointer to the inherited status variable.
+
+*  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: */
+   double epoch;      /* Epoch as a TDB MJD */
+
+/* Check the global error status. */
+   if ( !astOK ) return;
+
+/* Get the SkyFrame Epoch as a TDB MJD. */
+   epoch = astGetEpoch( this );
+
+/* Calculate the LAST value (in rads) and store in the SkyFrame structure. */
+   this->last = CalcLAST( this, epoch, astGetObsLon( this ),
+                          astGetObsLat( this ), astGetObsAlt( this ),
+                          astGetDut1( this ), astGetDtai( this ), status );
+
+/* Save the TDB MJD to which this LAST corresponds. */
+   this->eplast = epoch;
+
+/* The ratio between solar and sidereal time is a slowly varying function
+   of epoch. The GetLAST function returns a fast approximation to LAST
+   by using the ratio between solar and sidereal time. Indicate that
+   GetLAST should re-calculate the ratio by setting the ratio value bad. */
+   this->klast = AST__BAD;
+}
+
+static void SetObsAlt( AstFrame *this, double val, int *status ) {
+/*
+*  Name:
+*     SetObsAlt
+
+*  Purpose:
+*     Set the value of the ObsAlt attribute for a SkyFrame.
+
+*  Type:
+*     Private function.
+
+*  Synopsis:
+*     #include "skyframe.h"
+*     void SetObsAlt( AstFrame *this, double val, int *status )
+
+*  Class Membership:
+*     SkyFrame member function (over-rides the astSetObsAlt method
+*     inherited from the Frame class).
+
+*  Description:
+*     This function sets the ObsAlt value.
+
+*  Parameters:
+*     this
+*        Pointer to the SkyFrame.
+*     val
+*        New ObsAlt value.
+*     status
+*        Pointer to the inherited status variable.
+
+*/
+
+/* Local Variables: */
+   double orig;
+
+/* Check the global error status. */
+   if ( !astOK ) return;
+
+/* Note the original ObsAlt value. */
+   orig = astGetObsAlt( this );
+
+/* Invoke the parent method to set the Frame ObsAlt. */
+   (*parent_setobsalt)( this, val, status );
+
+/* If the altitude has changed significantly, indicate that the LAST value
+   and magnitude of the diurnal aberration vector will need to be
+   re-calculated when next needed. */
+   if( fabs( orig - val ) > 0.001 ) {
+      ( (AstSkyFrame *) this )->last = AST__BAD;
+      ( (AstSkyFrame *) this )->eplast = AST__BAD;
+      ( (AstSkyFrame *) this )->klast = AST__BAD;
+      ( (AstSkyFrame *) this )->diurab = AST__BAD;
+   }
+}
+
+static void SetObsLat( AstFrame *this, double val, int *status ) {
+/*
+*  Name:
+*     SetObsLat
+
+*  Purpose:
+*     Set the value of the ObsLat attribute for a SkyFrame.
+
+*  Type:
+*     Private function.
+
+*  Synopsis:
+*     #include "skyframe.h"
+*     void SetObsLat( AstFrame *this, double val, int *status )
+
+*  Class Membership:
+*     SkyFrame member function (over-rides the astSetObsLat method
+*     inherited from the Frame class).
+
+*  Description:
+*     This function sets the ObsLat value.
+
+*  Parameters:
+*     this
+*        Pointer to the SkyFrame.
+*     val
+*        New ObsLat value.
+*     status
+*        Pointer to the inherited status variable.
+
+*/
+
+/* Local Variables: */
+   double orig;
+
+/* Check the global error status. */
+   if ( !astOK ) return;
+
+/* Note the original ObsLat value. */
+   orig = astGetObsLat( this );
+
+/* Invoke the parent method to set the Frame ObsLat. */
+   (*parent_setobslat)( this, val, status );
+
+/* If the altitude has changed significantly, indicate that the LAST value
+   and magnitude of the diurnal aberration vector will need to be
+   re-calculated when next needed. */
+   if( fabs( orig - val ) > 1.0E-8 ) {
+      ( (AstSkyFrame *) this )->last = AST__BAD;
+      ( (AstSkyFrame *) this )->eplast = AST__BAD;
+      ( (AstSkyFrame *) this )->klast = AST__BAD;
+      ( (AstSkyFrame *) this )->diurab = AST__BAD;
+   }
+}
+
+static void SetObsLon( AstFrame *this, double val, int *status ) {
+/*
+*  Name:
+*     SetObsLon
+
+*  Purpose:
+*     Set the value of the ObsLon attribute for a SkyFrame.
+
+*  Type:
+*     Private function.
+
+*  Synopsis:
+*     #include "skyframe.h"
+*     void SetObsLon( AstFrame *this, double val, int *status )
+
+*  Class Membership:
+*     SkyFrame member function (over-rides the astSetObsLon method
+*     inherited from the Frame class).
+
+*  Description:
+*     This function sets the ObsLon value.
+
+*  Parameters:
+*     this
+*        Pointer to the SkyFrame.
+*     val
+*        New ObsLon value.
+*     status
+*        Pointer to the inherited status variable.
+
+*/
+
+/* Local Variables: */
+   double orig;
+
+/* Check the global error status. */
+   if ( !astOK ) return;
+
+/* Note the original ObsLon value. */
+   orig = astGetObsLon( this );
+
+/* Invoke the parent method to set the Frame ObsLon. */
+   (*parent_setobslon)( this, val, status );
+
+/* If the longitude has changed significantly, indicate that the LAST value
+   will need to be re-calculated when it is next needed. */
+   if( fabs( orig - val ) > 1.0E-8 ) {
+      ( (AstSkyFrame *) this )->last = AST__BAD;
+      ( (AstSkyFrame *) this )->eplast = AST__BAD;
+      ( (AstSkyFrame *) this )->klast = AST__BAD;
+   }
+}
+
+static void SetSystem( AstFrame *this_frame, AstSystemType system, int *status ) {
+/*
+*  Name:
+*     SetSystem
+
+*  Purpose:
+*     Set the System attribute for a SkyFrame.
+
+*  Type:
+*     Private function.
+
+*  Synopsis:
+*     #include "skyframe.h"
+*     void SetSystem( AstFrame *this_frame, AstSystemType system, int *status )
+
+*  Class Membership:
+*     SkyFrame member function (over-rides the astSetSystem protected
+*     method inherited from the Frame class).
+
+*  Description:
+*     This function assigns a new value to the System attribute for a SkyFrame.
+
+*  Parameters:
+*     this
+*        Pointer to the SkyFrame.
+*     system
+*        The new System value.
+*     status
+*        Pointer to the inherited status variable.
+
+*/
+
+/* Local Variables: */
+   AstFrameSet *fs;              /* FrameSet to be used as the Mapping */
+   AstSkyFrame *sfrm;            /* Copy of original SkyFrame */
+   AstSkyFrame *this;            /* Pointer to SkyFrame structure */
+   double xin[ 2 ];              /* Axis 0 values */
+   double xout[ 2 ];             /* Axis 0 values */
+   double yin[ 2 ];              /* Axis 1 values */
+   double yout[ 2 ];             /* Axis 1 values */
+   int aloff;                    /* The AlignOffset attribute value */
+   int aloff_set;                /* Is the AlignOffset attribute set? */
+   int skyref_set;               /* Is either SkyRef attribute set? */
+   int skyrefis;                 /* The SkyRefIs attribute value */
+   int skyrefis_set;             /* Is the SkyRefIs attribute set? */
+   int skyrefp_set;              /* Is either SkyRefP attribute set? */
+
+/* Check the global error status. */
+   if ( !astOK ) return;
+
+/* Obtain a pointer to the SkyFrame structure. */
+   this = (AstSkyFrame *) this_frame;
+
+/* See if either the SkyRef or SkyRefP attribute is set. */
+   skyref_set = astTestSkyRef( this, 0 ) || astTestSkyRef( this, 1 );
+   skyrefp_set = astTestSkyRefP( this, 0 ) || astTestSkyRefP( this, 1 );
+
+/* If so, we will need to transform their values into the new coordinate
+   system. Save a copy of the SkyFrame with its original System value. */
+   sfrm = ( skyref_set || skyrefp_set )?astCopy( this ):NULL;
+
+/* Use the parent method to set the new System value. */
+   (*parent_setsystem)( this_frame, system, status );
+
+/* Now modify the SkyRef and SkyRefP attributes if necessary. */
+   if( sfrm ) {
+
+/* Save the AlignOffset, SkyRefIs, SkyRef and SkyRefP values. */
+      aloff_set = astTestAlignOffset( sfrm );
+      aloff = astGetAlignOffset( sfrm );
+      skyrefis_set = astTestSkyRefIs( sfrm );
+      skyrefis = astGetSkyRefIs( sfrm );
+
+      xin[ 0 ] = astGetSkyRef( sfrm, 0 );
+      xin[ 1 ] = astGetSkyRefP( sfrm, 0 );
+      yin[ 0 ] = astGetSkyRef( sfrm, 1 );
+      yin[ 1 ] = astGetSkyRefP( sfrm, 1 );
+
+/* Clear the SkyRef and SkyRefP values to avoid infinite recursion in the
+   following call to astConvert. */
+      if( skyref_set ) {
+         astClearSkyRef( sfrm, 0 );
+         astClearSkyRef( sfrm, 1 );
+         astClearSkyRef( this, 0 );
+         astClearSkyRef( this, 1 );
+      }
+
+      if( skyrefp_set ) {
+         astClearSkyRefP( sfrm, 0 );
+         astClearSkyRefP( sfrm, 1 );
+         astClearSkyRefP( this, 0 );
+         astClearSkyRefP( this, 1 );
+      }
+
+/* Also set AlignOffset and SkyRefIs so that the following call to
+   astConvert does not align in offset coords. */
+      astSetAlignOffset( sfrm, 0 );
+      astSetSkyRefIs( sfrm, AST__IGNORED_REF );
+
+/* Get the Mapping from the original System to the new System. Invoking
+   astConvert will recursively invoke SetSystem again. This is why we need
+   to be careful to ensure that SkyRef and SKyRefP are cleared above - doing
+   so ensure we do not end up with infinite recursion. */
+      fs = astConvert( sfrm, this, "" );
+
+/* If the conversion is not possible, clear the SkyRef and SkyRefP
+   values. */
+      if( !fs ) {
+         if( skyref_set ) {
+            astClearSkyRef( this, 0 );
+            astClearSkyRef( this, 1 );
+         }
+         if( skyrefp_set ) {
+            astClearSkyRefP( this, 0 );
+            astClearSkyRefP( this, 1 );
+         }
+
+/* Use the Mapping to find the SkyRef and SkyRefP positions in the new
+   coordinate system. */
+      } else {
+         astTran2( fs, 2, xin, yin, 1, xout, yout );
+
+/* Store the values as required. */
+         if( skyref_set ) {
+            astSetSkyRef( this, 0, xout[ 0 ] );
+            astSetSkyRef( this, 1, yout[ 0 ] );
+         }
+
+         if( skyrefp_set ) {
+            astSetSkyRefP( this, 0, xout[ 1 ] );
+            astSetSkyRefP( this, 1, yout[ 1 ] );
+         }
+
+/* Restore the original SkyRefIs and AlignOffset values. */
+         if( aloff_set ) {
+            astSetAlignOffset( this, aloff );
+         } else {
+            astClearAlignOffset( this );
+         }
+
+         if( skyrefis_set ) {
+            astSetSkyRefIs( this, skyrefis );
+         } else {
+            astClearSkyRefIs( this );
+         }
+
+/* Free resources. */
+         fs = astAnnul( fs );
+      }
+      sfrm = astAnnul( sfrm );
+   }
+}
+
+static void Shapp( double dist, double *r0, double *r3, double a0,
+                   double *p4, int *status ){
+/*
+*  Name:
+*     Shapp
+
+*  Purpose:
+*     Use the vectors calculated by Shcal to find a sky position
+*     which is offset along a given position angle.
+
+*  Type:
+*     Private function.
+
+*  Synopsis:
+*     #include "skyframe.h"
+*     void Shapp( double dist, double *r0, double *r3, double a0,
+*                 double *p4, int *status )
+
+*  Class Membership:
+*     SkyFrame member function.
+
+*  Description:
+*     This function uses the vectors R0 and R3 calculated previously by
+*     Shcal to find the sky position which is offset away from the
+*     "reference" position (see function Offset2) by a given arc
+*     distance, along a given great circle.
+*
+*     No checks are made for AST__BAD values.
+
+*  Parameters:
+*     dist
+*        The arc distance to move away from the reference position
+*        in the given direction, in radians.
+*     r0
+*        Pointer to an array holding the 3-vector representing the reference
+*        position.
+*     r3
+*        Pointer to an array holding the 3-vector representing the
+*        point which is 90 degrees away from the reference point, along
+*        the required great circle.
+*     a0
+*        The sky longitude of the reference position, in radians.
+*     p4
+*        Pointer to an array of 2 doubles in which to put the sky longitude
+*        and latitude of the required point, in radians.
+*     status
+*        Pointer to the inherited status variable.
+
+*/
+
+/* Local Variables: */
+   double cosdst;            /* Cosine of DIST */
+   double r4[ 3 ];           /* Required position vector */
+   double sindst;            /* Sine of DIST */
+
+/* Check the global error status. */
+   if ( !astOK ) return;
+
+/* Store commonly used values. */
+   sindst = sin( dist );
+   cosdst = cos( dist );
+
+/* The vector R4 representing the required point is produced as a
+   linear sum of R0 and R3. */
+   r4[ 0 ] = cosdst*r0[ 0 ] + sindst*r3[ 0 ];
+   r4[ 1 ] = cosdst*r0[ 1 ] + sindst*r3[ 1 ];
+   r4[ 2 ] = cosdst*r0[ 2 ] + sindst*r3[ 2 ];
+
+/* Create the longitude of the required point. If this point is at
+   a pole it is assigned the same longitude as the reference point. */
+   if( r4[ 0 ] != 0.0 || r4[ 1 ] != 0.0 ) {
+      p4[ 0 ] = atan2( r4[ 1 ], r4[ 0 ] );
+   } else {
+      p4[ 0 ] = a0;
+   }
+
+/* Create the latitude of the required point. */
+   if( r4[ 2 ] > 1.0 ) {
+      r4[ 2 ] = 1.0;
+   } else if( r4[ 2 ] < -1.0 ) {
+      r4[ 2 ] = -1.0;
+   }
+   p4[ 1 ] = asin( r4[ 2 ] );
+
+}
+
+static void Shcal( double a0, double b0, double angle, double *r0,
+                   double *r3, int *status ) {
+/*
+*  Name:
+*     Shcal
+
+*  Purpose:
+*     Calculate vectors required by Offset2.
+
+*  Type:
+*     Private function.
+
+*  Synopsis:
+*     #include "skyframe.h"
+*     void Shcal( double a0, double b0, double angle, double *r0,
+*                 double *r3, int *status )
+
+*  Class Membership:
+*     SkyFrame member function.
+
+*  Description:
+*     This function calculates the 3-vector R0, representing the given
+*     sky position (A0,B0), and the 3-vector R3, representing the sky
+*     position which is 90 degrees away from R0, along a great circle
+*     passing through R0 at a position angle given by ANGLE. Each
+*     3-vector holds Cartesian (X,Y,Z) values with origin at the centre
+*     of the celestial sphere. The XY plane is the "equator", the Z
+*     axis is in the direction of the "north pole", X is towards zero
+*     longitude (A=0), and Y is towards longitude 90 degrees.
+*
+*     No checks are made for AST__BAD input values.
+
+*  Parameters:
+*     a0
+*        The sky longitude of the given position, in radians.
+*     b0
+*        The sky latitude of the given position, in radians.
+*     angle
+*        The position angle of a great circle passing through the given
+*        position.  That is, the angle from north to the required
+*        direction, in radians. Positive angles are in the sense of
+*        rotation from north to east.
+*     r0
+*        A pointer to an array to receive 3-vector R0. See above.
+*     r3
+*        A pointer to an array to receive 3-vector R3. See above.
+*     status
+*        Pointer to the inherited status variable.
+
+*/
+
+/* Local Variables: */
+   double cosa0;         /* Cosine of A0 */
+   double cosb0;         /* Cosine of B0 */
+   double cospa;         /* Cosine of ANGLE */
+   double r1[ 3 ];       /* Vector PI/2 away from R0 in meridian of R0 */
+   double r2[ 3 ];       /* Vector PI/2 away from R0 on equator */
+   double sinpa;         /* Sine of ANGLE */
+   double sina0;         /* Sine of A0 */
+   double sinb0;         /* Sine of B0 */
+
+/* Check the global error status. */
+   if ( !astOK ) return;
+
+/* Store commonly used values. */
+   sina0 = sin( a0 );
+   cosa0 = cos( a0 );
+   sinb0 = sin( b0 );
+   cosb0 = cos( b0 );
+   sinpa = sin( angle );
+   cospa = cos( angle );
+
+/* Create the vector R0 representing the given point. The XY plane
+   defines zero latitude, Z is in the direction of increasing latitude,
+   X is towards zero longitude, and Y is towards longitude 90 degrees. */
+   r0[ 0 ] =  cosb0*cosa0;
+   r0[ 1 ] =  cosb0*sina0;
+   r0[ 2 ] =  sinb0;
+
+/* Create the vector R1 representing the point in the meridian of the
+   given point which has latitude 90 degrees greater than the
+   given point. */
+   r1[ 0 ] = -sinb0*cosa0;
+   r1[ 1 ] = -sinb0*sina0;
+   r1[ 2 ] =  cosb0;
+
+/* Create the vector R2 representing the point on the equator (i.e. a
+   latitude of zero), which has a longitude 90 degrees to the west of
+   the given point. */
+   r2[ 0 ] = -sina0;
+   r2[ 1 ] =  cosa0;
+   r2[ 2 ] =  0.0;
+
+/* Create the vector R3 representing the point which is 90 degrees away
+   from the given point, along the required great circle. */
+   r3[ 0 ] =  cospa*r1[ 0 ] + sinpa*r2[ 0 ];
+   r3[ 1 ] =  cospa*r1[ 1 ] + sinpa*r2[ 1 ];
+   r3[ 2 ] =  cospa*r1[ 2 ] + sinpa*r2[ 2 ];
+
+/* Return */
+   return;
+}
+
+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 SkyFrame and convert to the new coordinate system.
+
+*  Type:
+*     Private function.
+
+*  Synopsis:
+*     #include "skyframe.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:
+*     SkyFrame 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" SkyFrame 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 SkyFrame, 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 SkyFrame. 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
+*        SkyFrame 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 SkyFrame
+*     object. This results in another object of the same class only if both
+*     axes of the SkyFrame are selected, once each. Otherwise, the result is a
+*     Frame class object which inherits the SkyFrame's axis information (if
+*     appropriate) but none of the other properties of a SkyFrame.
+*     -  In the event that a SkyFrame results, the returned Mapping will take
+*     proper account of the relationship between the target and result sky
+*     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: */
+   AstAxis *ax;                  /* Pointer to result Frame Axis object */
+   AstMapping *tmpmap;           /* Temporary Mapping pointer */
+   AstPermMap *permmap;          /* Pointer to PermMap */
+   AstSkyFrame *target;          /* Pointer to the SkyFrame structure */
+   AstSkyFrame *temp;            /* Pointer to copy of target SkyFrame */
+   AstSystemType align_sys;      /* System in which to align the SkyFrames */
+   int match;                    /* Coordinate conversion is possible? */
+   int perm[ 2 ];                /* Permutation array for axis swap */
+   int result_swap;              /* Swap result SkyFrame coordinates? */
+   int set_usedefs;              /* Set the returned UseDefs attribute zero?*/
+   int target_axis;              /* Target SkyFrame axis index */
+   int target_swap;              /* Swap target SkyFrame coordinates? */
+
+/* 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 SkyFrame structure. */
+   target = (AstSkyFrame *) target_frame;
+
+/* Result is a SkyFrame. */
+/* --------------------- */
+/* Check if the result Frame is to have two axes obtained by selecting
+   both of the target SkyFrame axes, in either order. If so, the
+   result will also be a SkyFrame. */
+   if ( ( result_naxes == 2 ) &&
+        ( ( ( target_axes[ 0 ] == 0 ) && ( target_axes[ 1 ] == 1 ) ) ||
+          ( ( target_axes[ 0 ] == 1 ) && ( target_axes[ 1 ] == 0 ) ) ) ) {
+
+/* If a template has not been supplied, or is the same object as the
+   target, we are simply extracting axes from the supplied SkyFrame. In
+   this case we temporarily force the UseDefs attribute to 1 so that (for
+   instance) the astPickAxes method can function correctly. E.g. if you
+   have a SkyFrame with no set Epoch and UseDefs set zero,  and you try to
+   swap the axes, the attempt would fail because MakeSkyMapping would be
+   unable to determine the Mapping from original to swapped SkyFrame,
+   because of the lack of an Epoch value. */
+      set_usedefs = 0;
+      if( !template || template == target_frame ) {
+         if( !astGetUseDefs( target ) ) {
+            astClearUseDefs( target );
+            set_usedefs = 1;
+         }
+      }
+
+/* Form the result from a copy of the target and then permute its axes
+   into the order required. */
+      *result = astCopy( target );
+      astPermAxes( *result, target_axes );
+
+/* If required, overlay the template attributes on to the result SkyFrame.
+   Also get the system in which to align the two SkyFrames. This is the
+   value of the AlignSystem attribute from the template (if there is a
+   template). */
+      if ( template ) {
+         astOverlay( template, template_axes, *result );
+         align_sys = astGetAlignSystem( template );
+
+      } else {
+         align_sys = astGetAlignSystem( target );
+      }
+
+/* See whether alignment occurs in offset coordinates or absolute
+   coordinates. If the current call to this function is part of the
+   process of restoring a FrameSet's integrity following changes to
+   the FrameSet's current Frame, then we ignore the setting of the
+   AlignOffset attributes and use 0. This ensures that when the System
+   attribute (for instance) is changed via a FrameSet pointer, the
+   Mappings within the FrameSet are modified to produce offsets in the
+   new System. If we are not currently restoring a FrameSet's integrity,
+   then we align in offsets if the template is a SkyFrame and both template
+   and target want alignment to occur in the offset coordinate system. In
+   this case we use a UnitMap to connect them. */
+      if( ( astGetFrameFlags( target_frame ) & AST__INTFLAG ) == 0 ) {
+         if( astGetAlignOffset( target ) &&
+             astGetSkyRefIs( target ) != AST__IGNORED_REF &&
+             template && astIsASkyFrame( template ) ){
+            if( astGetAlignOffset( (AstSkyFrame *) template ) &&
+                astGetSkyRefIs( (AstSkyFrame *) template ) != AST__IGNORED_REF ) {
+               match = 1;
+               *map = (AstMapping *) astUnitMap( 2, "", status );
+            }
+         }
+      }
+
+/* Otherwise, generate a Mapping that takes account of changes in the sky
+   coordinate system (equinox, epoch, etc.) between the target SkyFrame and
+   the result SkyFrame. If this Mapping can be generated, set "match" to
+   indicate that coordinate conversion is possible. */
+      if( ! *map ) {
+         match = ( MakeSkyMapping( target, (AstSkyFrame *) *result,
+                                   align_sys, map, status ) != 0 );
+      }
+
+/* If required, re-instate the original zero value of UseDefs. */
+      if( set_usedefs ) {
+         astSetUseDefs( target, 0 );
+         astSetUseDefs( *result, 0 );
+      }
+
+/* If a Mapping has been obtained, it will expect coordinate values to be
+   supplied in (longitude,latitude) pairs. Test whether we need to swap the
+   order of the target SkyFrame coordinates to conform with this. */
+      if ( astOK && match ) {
+         target_swap = ( astValidateAxis( target, 0, 1, "astSubFrame" ) != 0 );
+
+/* Coordinates will also be delivered in (longitude,latitude) pairs, so check
+   to see whether the result SkyFrame coordinate order should be swapped. */
+         result_swap = ( target_swap != ( target_axes[ 0 ] != 0 ) );
+
+/* If either set of coordinates needs swapping, create a PermMap that
+   will swap a pair of coordinates. */
+         permmap = NULL;
+         if ( target_swap || result_swap ) {
+            perm[ 0 ] = 1;
+            perm[ 1 ] = 0;
+            permmap = astPermMap( 2, perm, 2, perm, NULL, "", status );
+         }
+
+/* If necessary, prefix this PermMap to the main Mapping. */
+         if ( target_swap ) {
+            tmpmap = (AstMapping *) astCmpMap( permmap, *map, 1, "", status );
+            *map = astAnnul( *map );
+            *map = tmpmap;
+         }
+
+/* Also, if necessary, append it to the main Mapping. */
+         if ( result_swap ) {
+            tmpmap = (AstMapping *) astCmpMap( *map, permmap, 1, "", status );
+            *map = astAnnul( *map );
+            *map = tmpmap;
+         }
+
+/* Annul the pointer to the PermMap (if created). */
+         if ( permmap ) permmap = astAnnul( permmap );
+      }
+
+/* Result is not a SkyFrame. */
+/* ------------------------- */
+/* 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 SkyFrame, default attribute values may differ
+   if the methods for obtaining them were over-ridden by the SkyFrame
+   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 SkyFrame. 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
+   SkyFrame class. */
+      SET(Domain)
+      SET(Title)
+
+/* Now loop to set explicit attribute values for each axis. */
+      for ( target_axis = 0; target_axis < 2; target_axis++ ) {
+
+/* Define a macro to test if an axis attribute is set. If not, set it
+   explicitly to its default value. */
+#define SET_AXIS(attribute) \
+   if ( !astTest##attribute( temp, target_axis ) ) { \
+      astSet##attribute( temp, target_axis, \
+                         astGet##attribute( temp, target_axis ) ); \
+   }
+
+/* Use this macro to set explicit values for all the axis attributes
+   for which the SkyFrame class over-rides the default value. */
+         SET_AXIS(AsTime)
+         SET_AXIS(Format)
+         SET_AXIS(Label)
+         SET_AXIS(Symbol)
+         SET_AXIS(Unit)
+
+/* Now handle axis attributes for which there are no SkyFrame access
+   methods.  For these we require a pointer to the temporary
+   SkyFrame's Axis object. */
+         ax = astGetAxis( temp, target_axis );
+
+/* Set an explicit value for the IsLatitude and CentreZero attributes. */
+         if( astValidateAxis( temp, target_axis, 1, "astSubFrame" ) == 1 ) {
+            astSetAxisIsLatitude( ax, 1 );
+            astSetAxisCentreZero( ax, 1 );
+
+         } else {
+            astSetAxisIsLatitude( ax, 0 );
+            astSetAxisCentreZero( ax, astGetNegLon( temp ) );
+         }
+
+/* Annul the Axis object pointer. */
+         ax = astAnnul( ax );
+      }
+
+/* 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 SkyFrame. */
+      temp = astDelete( temp );
+   }
+
+/* Ensure the returned Frame does not have active units. */
+   astSetActiveUnit( *result, 0 );
+
+/* 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 "skyframe.h"
+*     AstSystemType SystemCode( AstFrame *this, const char *system, int *status )
+
+*  Class Membership:
+*     SkyFrame 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 sky coordinate system into a SkyFrame
+*     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( "FK4", system ) ) {
+      result = AST__FK4;
+
+   } else if ( astChrMatch( "FK4_NO_E", system ) ||
+               astChrMatch( "FK4-NO-E", system ) ) {
+      result = AST__FK4_NO_E;
+
+   } else if ( astChrMatch( "FK5", system ) ||
+               astChrMatch( "Equatorial", system ) ) {
+      result = AST__FK5;
+
+   } else if ( astChrMatch( "J2000", system ) ) {
+      result = AST__J2000;
+
+   } else if ( astChrMatch( "ICRS", system ) ) {
+      result = AST__ICRS;
+
+   } else if ( astChrMatch( "AZEL", system ) ) {
+      result = AST__AZEL;
+
+   } else if ( astChrMatch( "GAPPT", system ) ||
+               astChrMatch( "GEOCENTRIC", system ) ||
+               astChrMatch( "APPARENT", system ) ) {
+         result = AST__GAPPT;
+
+   } else if ( astChrMatch( "ECLIPTIC", system ) ) {
+      result = AST__ECLIPTIC;
+
+   } else if ( astChrMatch( "HELIOECLIPTIC", system ) ) {
+      result = AST__HELIOECLIPTIC;
+
+   } else if ( astChrMatch( "GALACTIC", system ) ) {
+      result = AST__GALACTIC;
+
+   } else if ( astChrMatch( "SUPERGALACTIC", system ) ) {
+      result = AST__SUPERGALACTIC;
+
+   } else if ( astChrMatch( "UNKNOWN", system ) ) {
+      result = AST__UNKNOWN;
+   }
+
+/* Return the result. */
+   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 "skyframe.h"
+*     const char *SystemString( AstFrame *this, AstSystemType system, int *status )
+
+*  Class Membership:
+*     SkyFrame member function (over-rides the astSystemString method
+*     inherited from the Frame class).
+
+*  Description:
+*     This function converts a SkyFrame 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__FK4:
+      result = "FK4";
+      break;
+
+   case AST__FK4_NO_E:
+      result = "FK4-NO-E";
+      break;
+
+   case AST__FK5:
+      result = "FK5";
+      break;
+
+   case AST__J2000:
+      result = "J2000";
+      break;
+
+   case AST__ICRS:
+      result = "ICRS";
+      break;
+
+   case AST__GAPPT:
+      result = "GAPPT";
+      break;
+
+   case AST__AZEL:
+      result = "AZEL";
+      break;
+
+   case AST__ECLIPTIC:
+      result = "ECLIPTIC";
+      break;
+
+   case AST__HELIOECLIPTIC:
+      result = "HELIOECLIPTIC";
+      break;
+
+   case AST__GALACTIC:
+      result = "GALACTIC";
+      break;
+
+   case AST__SUPERGALACTIC:
+      result = "SUPERGALACTIC";
+      break;
+
+   case AST__UNKNOWN:
+      result = "Unknown";
+      break;
+   }
+
+/* Return the result pointer. */
+   return result;
+}
+
+static int TestActiveUnit( AstFrame *this_frame, int *status ) {
+/*
+*  Name:
+*     TestActiveUnit
+
+*  Purpose:
+*     Test the ActiveUnit flag for a SkyFrame.
+
+*  Type:
+*     Private function.
+
+*  Synopsis:
+*     #include "skyframe.h"
+*     int TestActiveUnit( AstFrame *this_frame, int *status )
+
+*  Class Membership:
+*     SkyFrame 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 SkyFrame,
+*    which is always "unset".
+
+*  Parameters:
+*     this
+*        Pointer to the SkyFrame.
+*     status
+*        Pointer to the inherited status variable.
+
+*  Returned Value:
+*     The result of the test (0).
+
+*/
+   return 0;
+}
+
+static int TestAsTime( AstSkyFrame *this, int axis, int *status ) {
+/*
+*  Name:
+*     TestAsTime
+
+*  Purpose:
+*     Determine if a value has been set for a SkyFrame's AsTime attribute.
+
+*  Type:
+*     Private function.
+
+*  Synopsis:
+*     #include "skyframe.h"
+*     int TestAsTime( AstSkyFrame *this, int axis, int *status )
+
+*  Class Membership:
+*     SkyFrame member function.
+
+*  Description:
+*     This function returns a boolean value to indicate if a value has
+*     previously been set for the AsTime attribute for a specified axis of a
+*     SkyFrame. This attribute indicates whether axis values should be
+*     formatted as times (as opposed to angles) by default.
+
+*  Parameters:
+*     this
+*        Pointer to the SkyFrame.
+*     axis
+*        Index of the axis for which information is required (zero based).
+*     status
+*        Pointer to the inherited status variable.
+
+*  Returned Value:
+*     Zero or one, according to whether the AsTime attribute has been set.
+
+*  Notes:
+*     -  A value of zero will be returned if this function is invoked with the
+*     global error status set, or if it should fail for any reason.
+*/
+
+/* Local Variables. */
+   AstAxis *ax;                  /* Pointer to Axis object */
+   int result;                   /* Result to be returned */
+
+/* Check the global error status. */
+   if ( !astOK ) return 0;
+
+/* Validate the axis index. */
+   (void) astValidateAxis( this, axis, 1, "astTestAsTime" );
+
+/* Obtain a pointer to the Axis object. */
+   ax = astGetAxis( this, axis );
+
+/* Determine if the AsTime attribute has been set for it (it cannot have been
+   set unless the object is a SkyAxis). */
+   result = ( astIsASkyAxis( ax ) && astTestAxisAsTime( ax ) );
+
+/* Annul the Axis pointer. */
+   ax = astAnnul( ax );
+
+/* Return the result. */
+   return result;
+}
+
+static int TestAttrib( AstObject *this_object, const char *attrib, int *status ) {
+/*
+*  Name:
+*     TestAttrib
+
+*  Purpose:
+*     Test if a specified attribute value is set for a SkyFrame.
+
+*  Type:
+*     Private function.
+
+*  Synopsis:
+*     #include "skyframe.h"
+*     int TestAttrib( AstObject *this, const char *attrib, int *status )
+
+*  Class Membership:
+*     SkyFrame 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 SkyFrame's attributes.
+
+*  Parameters:
+*     this
+*        Pointer to the SkyFrame.
+*     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: */
+   AstSkyFrame *this;            /* Pointer to the SkyFrame structure */
+   int axis;                     /* SkyFrame axis number */
+   int len;                      /* Length of attrib string */
+   int nc;                       /* No. characters read by astSscanf */
+   int result;                   /* Result value to return */
+
+/* Initialise. */
+   result = 0;
+
+/* Check the global error status. */
+   if ( !astOK ) return result;
+
+/* Obtain a pointer to the SkyFrame structure. */
+   this = (AstSkyFrame *) this_object;
+
+/* Obtain the length of the attrib string. */
+   len = strlen( attrib );
+
+/* Check the attribute name and test the appropriate attribute. */
+
+/* AsTime(axis). */
+/* ------------- */
+   if ( nc = 0,
+        ( 1 == astSscanf( attrib, "astime(%d)%n", &axis, &nc ) )
+        && ( nc >= len ) ) {
+      result = astTestAsTime( this, axis - 1 );
+
+/* Equinox. */
+/* -------- */
+   } else if ( !strcmp( attrib, "equinox" ) ) {
+      result = astTestEquinox( this );
+
+/* NegLon. */
+/* ------- */
+   } else if ( !strcmp( attrib, "neglon" ) ) {
+      result = astTestNegLon( this );
+
+/* SkyTol. */
+/* ------- */
+   } else if ( !strcmp( attrib, "skytol" ) ) {
+      result = astTestSkyTol( this );
+
+/* Projection. */
+/* ----------- */
+   } else if ( !strcmp( attrib, "projection" ) ) {
+      result = astTestProjection( this );
+
+/* SkyRefIs. */
+/* --------- */
+   } else if ( !strcmp( attrib, "skyrefis" ) ) {
+      result = astTestSkyRefIs( this );
+
+/* SkyRef. */
+/* ------- */
+   } else if ( !strcmp( attrib, "skyref" ) ) {
+      result = astTestSkyRef( this, 0 ) || astTestSkyRef( this, 1 );
+
+/* SkyRef(axis). */
+/* ------------- */
+   } else if ( nc = 0,
+        ( 1 == astSscanf( attrib, "skyref(%d)%n", &axis, &nc ) )
+        && ( nc >= len ) ) {
+      result = astTestSkyRef( this, axis - 1 );
+
+/* SkyRefP. */
+/* -------- */
+   } else if ( !strcmp( attrib, "skyrefp" ) ) {
+      result = astTestSkyRefP( this, 0 ) || astTestSkyRefP( this, 1 );
+
+/* SkyRefP(axis). */
+/* ------------- */
+   } else if ( nc = 0,
+        ( 1 == astSscanf( attrib, "skyrefp(%d)%n", &axis, &nc ) )
+        && ( nc >= len ) ) {
+      result = astTestSkyRefP( this, axis - 1 );
+
+/* AlignOffset */
+/* ----------- */
+   } else if ( !strcmp( attrib, "alignoffset" ) ) {
+      result = astTestAlignOffset( this );
+
+/* If the name is not recognised, test if it matches any of the
+   read-only attributes of this class. If it does, then return
+   zero. */
+   } else if ( !strncmp( attrib, "islataxis", 9 ) ||
+               !strncmp( attrib, "islonaxis", 9 ) ||
+               !strcmp( attrib, "lataxis" ) ||
+               !strcmp( attrib, "lonaxis" ) ) {
+      result = 0;
+
+/* 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 int TestSlaUnit( AstSkyFrame *sf1, AstSkyFrame *sf2, AstSlaMap *slamap,
+                        int *status ){
+/*
+*  Name:
+*     Unformat
+
+*  Purpose:
+*     See if a slamap is effectively a unit mapping.
+
+*  Type:
+*     Private function.
+
+*  Synopsis:
+*     #include "skyframe.h"
+*     int TestSlaUnit( AstSkyFrame *sf1, AstSkyFrame *sf2, AstSlaMap *slamap,
+*                      int *status )
+
+*  Class Membership:
+*     SkyFrame member function.
+
+*  Description:
+*     This function tests a SlaMap to see if it is effectively a unit
+*     transformatuon to within a tolerance given by the smaller tolerance
+*     of the two supplied SkyFrames.
+
+*  Parameters:
+*     sf1
+*        Pointer to the first SkyFrame.
+*     sf2
+*        Pointer to the second SkyFrame (may be NULL)
+*     slamap
+*        Pointer to the SlaMap to test.
+*     status
+*        Pointer to the inherited status variable.
+
+*  Returned Value:
+*     Non-zero if the SlaMap is effectively a unit mapping, and zero
+*     otherwise.
+
+*/
+
+/*  Number of test points. */
+#define NTEST 14
+
+/* Local Variables: */
+   double maxshift;            /* Max. shift produced by slamap (rads) */
+   double olat[NTEST];         /* Transformed latitudes */
+   double olon[NTEST];         /* Transformed longitudes */
+   double shift;               /* Shift produced by slamap (rads) */
+   double tol2;                /* Second tolerance (in radians) */
+   double tol;                 /* Used tolerance (in radians) */
+   int i;                      /* Loop count */
+   int result;                 /* Returned flag */
+
+/* A grid of lon/lat points covering the sphere. */
+   double lat[ NTEST ] = { 0.0,  0.0,  0.0,  0.0,
+                           0.8,  0.8,  0.8,  0.8,
+                          -0.8, -0.8, -0.8, -0.8,
+                           1.570796, -1.570796 };
+   double lon[ NTEST ] = { 0.0,  1.57,  3.14,  4.71,
+                           0.8,  2.37,  3.94,  5.51,
+                           0.8,  2.37,  3.94,  5.51,
+                           0.0, 0.0 };
+
+/* Initialise. */
+   result = 0;
+
+/* Check the global error status. */
+   if ( !astOK ) return result;
+
+/* If the SlaMap is empty (i.e. has no conversions in it), then is it a
+   UnitMap. So save time by not transforming the test values. */
+   if( astSlaIsEmpty( slamap ) ) {
+      result = 1;
+
+/* Otherwise, get the smaller of the tolerances associated with the
+   supplied SkyFrames, in radians. */
+   } else {
+      tol = astGetSkyTol( sf1 );
+      if( sf2 ) {
+         tol2 = astGetSkyTol( sf2 );
+         if( tol2 < tol ) tol = tol2;
+      }
+
+/* If the tolerance is zero, there is no need to do the test. */
+      if( tol > 0.0 ) {
+
+/* Transform the test point using the SlaMap. */
+         astTran2( slamap, NTEST, lon, lat, 1, olon, olat );
+
+/* Find the maximum shift produced by the SlaMap at any of the test
+   positions. Again, to avoid the slow-down produced by checking for
+   axis permutation, use palDsep rather than astDistance. */
+         maxshift = 0.0;
+         for( i = 0; i < NTEST; i++ ) {
+            shift = palDsep( lon[ i ], lat[ i ], olon[ i ], olat[ i ] );
+            if( shift > maxshift ) maxshift = shift;
+         }
+
+/* Convert the max shift to arc-seconds and do the check. */
+         result = ( maxshift*AST__DR2D*3600 < tol );
+      }
+   }
+
+   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 SkyFrame axis.
+
+*  Type:
+*     Private function.
+
+*  Synopsis:
+*     #include "skyframe.h"
+*     int Unformat( AstFrame *this, int axis, const char *string,
+*                   double *value, int *status )
+
+*  Class Membership:
+*     SkyFrame member function (over-rides the public astUnformat
+*     method inherited from the Frame class).
+
+*  Description:
+*     This function reads a formatted coordinate value for a SkyFrame
+*     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 SkyFrame.
+*     axis
+*        The number of the SkyFrame 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 (in radians).
+*     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: */
+   AstSkyFrame *this;            /* Pointer to the SkyFrame structure */
+   double coord;                 /* Coordinate value read */
+   int format_set;               /* Format attribute set? */
+   int nc;                       /* Number of characters read */
+
+/* Initialise. */
+   nc = 0;
+
+/* Check the global error status. */
+   if ( !astOK ) return nc;
+
+/* Obtain a pointer to the SkyFrame structure. */
+   this = (AstSkyFrame *) this_frame;
+
+/* Validate the axis index. */
+   (void) astValidateAxis( this, axis, 1, "astUnformat" );
+
+/* Determine if a Format value has been set for the axis and set a
+   temporary value if it has not. Use the GetFormat member function
+   for this class together with member functions inherited from the
+   parent class (rather than using the object's methods directly)
+   because if any of these methods have been over-ridden by a derived
+   class the Format string syntax may no longer be compatible with
+   this class. */
+   format_set = (*parent_testformat)( this_frame, axis, status );
+   if ( !format_set ) {
+      (*parent_setformat)( this_frame, axis, GetFormat( this_frame, axis, status ), status );
+   }
+
+/* Use the Unformat member function inherited from the parent class to
+   read the coordinate value. */
+   nc = (*parent_unformat)( this_frame, axis, string, &coord, status );
+
+/* If necessary, clear any temporary Format value that was set above. */
+   if ( !format_set ) (*parent_clearformat)( this_frame, axis, status );
+
+/* If an error occurred, clear the number of characters read. */
+   if ( !astOK ) {
+      nc = 0;
+
+/* Otherwise, if characters were read, return the coordinate value. */
+   } else if ( nc ) {
+      *value = coord;
+   }
+
+/* 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 "frame.h"
+*     int ValidateSystem( AstFrame *this, AstSystemType system,
+*                         const char *method, int *status )
+
+*  Class Membership:
+*     SkyFrame 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 VerifyMSMAttrs( AstSkyFrame *target, AstSkyFrame *result,
+                            int which, const char *attrs, const char *method, int *status ) {
+/*
+*  Name:
+*     VerifyMSMAttrs
+
+*  Purpose:
+*     Verify that usable attribute values are available.
+
+*  Type:
+*     Private function.
+
+*  Synopsis:
+*     #include "skyframe.h"
+*      void VerifyMSMAttrs( AstSkyFrame *target, AstSkyFrame *result,
+*                           int which, const char *attrs, const char *method, int *status )
+
+*  Class Membership:
+*     SkyFrame 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
+*     in the SkyFrame indicated by "which" or 2) the UseDefs attribute of the
+*     "which" SkyFrame 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.
+*
+*     The displayed error message assumes that tjis function was called
+*     as part of the process of producing a Mapping from "target" to "result".
+
+*  Parameters:
+*     target
+*        Pointer to the target SkyFrame.
+*     result
+*        Pointer to the result SkyFrame.
+*     which
+*        If 2, both the target and result SkyFrames are checked for the
+*        supplied attributes. If less than 2, only the target SkyFrame is
+*        checked. If greater than 2, only the result SkyFrame is checked.
+*     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 *p;
+   const char *desc;
+   int len;
+   int set1;
+   int set2;
+   int state;
+   int usedef1;
+   int usedef2;
+
+/* Check inherited status */
+   if( !astOK ) return;
+
+/* Get the UseDefs attributes of the two SkyFrames. */
+   usedef1 = astGetUseDefs( target );
+   usedef2 = astGetUseDefs( result );
+
+/* If both SkyFrames have 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 for either SkyFrame. */
+   if( !usedef1 || !usedef2 ) {
+
+/* Stop compiler warnings about uninitialised variables */
+      a = NULL;
+      desc = NULL;
+      len = 0;
+      set1 = 0;
+      set2 = 0;
+
+/* 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( "Equinox", a, len ) ) {
+                     set1 = astTestEquinox( target );
+                     set2 = astTestEquinox( result );
+                     desc = "reference equinox";
+
+                  } else if( !strncmp( "Dtai", a, len ) ) {
+                     set1 = astTestDtai( target );
+                     set2 = astTestDtai( result );
+                     desc = "TAI-UTC correction";
+
+                  } else if( !strncmp( "Dut1", a, len ) ) {
+                     set1 = astTestDut1( target );
+                     set2 = astTestDut1( result );
+                     desc = "UT1-UTC correction";
+
+                  } else if( !strncmp( "Epoch", a, len ) ) {
+                     set1 = astTestEpoch( target );
+                     set2 = astTestEpoch( result );
+                     desc = "epoch of observation";
+
+                  } else if( !strncmp( "ObsLon", a, len ) ) {
+                     set1 = astTestObsLon( target );
+                     set2 = astTestObsLon( result );
+                     desc = "longitude of observer";
+
+                  } else if( !strncmp( "ObsLat", a, len ) ) {
+                     set1 = astTestObsLat( target );
+                     set2 = astTestObsLat( result );
+                     desc = "latitude of observer";
+
+                  } else if( !strncmp( "ObsAlt", a, len ) ) {
+                     set1 = astTestObsAlt( target );
+                     set2 = astTestObsAlt( result );
+                     desc = "altitude of observer";
+
+                  } else {
+                     astError( AST__INTER, "VerifyMSMAttrs(SkyFrame): "
+                               "Unknown attribute name \"%.*s\" supplied (AST "
+                               "internal programming error).", status, len, a );
+                  }
+
+/* If the attribute is not set in the target but should be, report an
+   error. */
+                  if( !usedef1 && !set1 && which < 3 ) {
+                     astClearTitle( target );
+                     astClearTitle( result );
+                     astError( AST__NOVAL, "%s(%s): Cannot convert "
+                               "celestial coordinates from %s to %s.", status,
+                               method, astGetClass( target ),
+                               astGetC( target, "Title" ),
+                               astGetC( result, "Title" ) );
+                     astError( AST__NOVAL, "No value has been set for "
+                               "the \"%.*s\" attribute (%s) in the input %s.", status,
+                               len, a, desc, astGetClass( target ) );
+                     break;
+                  }
+
+/* If the attribute is not set in the result but should be, report an
+   error. */
+                  if( !usedef2 && !set2 && which > 1 ) {
+                     astClearTitle( target );
+                     astClearTitle( result );
+                     astError( AST__NOVAL, "%s(%s): Cannot convert "
+                               "celestial coordinates from %s to %s.", status,
+                               method, astGetClass( result ),
+                               astGetC( target, "Title" ),
+                               astGetC( result, "Title" ) );
+                     astError( AST__NOVAL, "No value has been set for "
+                               "the \"%.*s\" attribute (%s) in the output %s.", status,
+                               len, a, desc, astGetClass( result ) );
+                     break;
+                  }
+
+/* Continue the word search algorithm. */
+               }
+               len = 0;
+               state = 0;
+            } else {
+               len++;
+            }
+         }
+         if( !*(p++) ) break;
+      }
+   }
+}
+
+/* Functions which access class attributes. */
+/* ---------------------------------------- */
+/*
+*att++
+*  Name:
+*     AlignOffset
+
+*  Purpose:
+*     Align SkyFrames using the offset coordinate system?
+
+*  Type:
+*     Public attribute.
+
+*  Synopsis:
+*     Integer (boolean).
+
+*  Description:
+*     This attribute is a boolean value which controls how a SkyFrame
+*     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)
+*     SkyFrame. It determines the coordinate system in which the two
+*     SkyFrames are aligned if a match occurs.
+*
+*     If the template and target SkyFrames both have defined offset coordinate
+*     systems (i.e. the SkyRefIs attribute is set to either "Origin" or "
+*     Pole"), and they both have a non-zero value for AlignOffset, then
+*     alignment occurs within the offset coordinate systems (that is, a
+*     UnitMap will always be used to align the two SkyFrames). If either
+*     the template or target SkyFrame has zero (the default value) for
+*     AlignOffset, or if either SkyFrame has SkyRefIs set to "Ignored", then
+*     alignment occurring within the coordinate system specified by the
+*     AlignSystem attribute.
+
+*  Applicability:
+*     SkyFrame
+*        All SkyFrames have this attribute.
+*att--
+*/
+astMAKE_CLEAR(SkyFrame,AlignOffset,alignoffset,-INT_MAX)
+astMAKE_GET(SkyFrame,AlignOffset,int,0,( ( this->alignoffset != -INT_MAX ) ?
+                                           this->alignoffset : 0 ))
+astMAKE_SET(SkyFrame,AlignOffset,int,alignoffset,( value != 0 ))
+astMAKE_TEST(SkyFrame,AlignOffset,( this->alignoffset != -INT_MAX ))
+
+/*
+*att++
+*  Name:
+*     AsTime(axis)
+
+*  Purpose:
+*     Format celestal coordinates as times?
+
+*  Type:
+*     Public attribute.
+
+*  Synopsis:
+*     Integer (boolean).
+
+*  Description:
+*     This attribute specifies the default style of formatting to be
+c     used (e.g. by astFormat) for the celestial coordinate values
+f     used (e.g. by AST_FORMAT) for the celestial coordinate values
+*     described by a SkyFrame. It takes a separate boolean value for
+*     each SkyFrame axis so that, for instance, the setting
+*     "AsTime(2)=0" specifies the default formatting style for
+*     celestial latitude values.
+*
+*     If the AsTime attribute for a SkyFrame axis is zero, then
+*     coordinates on that axis will be formatted as angles by default
+*     (using degrees, minutes and seconds), otherwise they will be
+*     formatted as times (using hours, minutes and seconds).
+*
+*     The default value of AsTime is chosen according to the sky
+*     coordinate system being represented, as determined by the
+*     SkyFrame's System attribute. This ensures, for example, that
+*     right ascension values will be formatted as times by default,
+*     following normal conventions.
+
+*  Applicability:
+*     SkyFrame
+*        All SkyFrames have this attribute.
+
+*  Notes:
+*     - The AsTime attribute operates by changing the default value of
+*     the corresponding Format(axis) attribute. This, in turn, may
+*     also affect the value of the Unit(axis) attribute.
+*     - Only the default style of formatting is affected by the AsTime
+*     value. If an explicit Format(axis) value is set, it will
+*     over-ride any effect from the AsTime attribute.
+*att--
+*/
+
+/*
+*att++
+*  Name:
+*     Equinox
+
+*  Purpose:
+*     Epoch of the mean equinox.
+
+*  Type:
+*     Public attribute.
+
+*  Synopsis:
+*     Floating point.
+
+*  Description:
+*     This attribute is used to qualify those celestial coordinate
+*     systems described by a SkyFrame which are notionally based on
+*     the ecliptic (the plane of the Earth's orbit around the Sun)
+*     and/or the Earth's equator.
+*
+*     Both of these planes are in motion and their positions are
+*     difficult to specify precisely. In practice, therefore, a model
+*     ecliptic and/or equator are used instead. These, together with
+*     the point on the sky that defines the coordinate origin (the
+*     intersection of the two planes termed the "mean equinox") move
+*     with time according to some model which removes the more rapid
+*     fluctuations. The SkyFrame class supports both the FK4 and
+*     FK5 models.
+*
+*     The position of a fixed source expressed in any of these
+*     coordinate systems will appear to change with time due to
+*     movement of the coordinate system itself (rather than motion of
+*     the source).  Such coordinate systems must therefore be
+*     qualified by a moment in time (the "epoch of the mean equinox"
+*     or "equinox" for short) which allows the position of the model
+*     coordinate system on the sky to be determined. This is the role
+*     of the Equinox attribute.
+*
+*     The Equinox attribute is stored as a Modified Julian Date, but
+*     when setting or getting its value you may use the same formats
+*     as for the Epoch attribute (q.v.).
+*
+*     The default Equinox value is B1950.0 (Besselian) for the old
+*     FK4-based coordinate systems (see the System attribute) and
+*     J2000.0 (Julian) for all others.
+
+*  Applicability:
+*     SkyFrame
+*        All SkyFrames have this attribute.
+
+*  Notes:
+*     - Care must be taken to distinguish the Equinox value, which
+*     relates to the definition of a time-dependent coordinate system
+*     (based on solar system reference planes which are in motion),
+*     from the superficially similar Epoch value. The latter is used
+*     to qualify coordinate systems where the positions of sources
+*     change with time (or appear to do so) for a variety of other
+*     reasons, such as aberration of light caused by the observer's
+*     motion, etc.
+*     - See the description of the System attribute for details of
+*     which qualifying attributes apply to each celestial coordinate
+*     system.
+*att--
+*/
+/* Clear the Equinox value by setting it to AST__BAD. */
+astMAKE_CLEAR(SkyFrame,Equinox,equinox,AST__BAD)
+
+/* Provide a default value of B1950.0 or J2000.0 depending on the System
+   setting. */
+astMAKE_GET(SkyFrame,Equinox,double,AST__BAD,(
+            ( this->equinox != AST__BAD ) ? this->equinox :
+               ( ( ( astGetSystem( this ) == AST__FK4 ) ||
+                   ( astGetSystem( this ) == AST__FK4_NO_E ) ) ?
+                    palEpb2d( 1950.0 ) : palEpj2d( 2000.0 ) ) ))
+
+/* Allow any Equinox value to be set, unless the System is Helio-ecliptic
+   (in which case clear the value so that J2000 is used). */
+astMAKE_SET(SkyFrame,Equinox,double,equinox,((astGetSystem(this)!=AST__HELIOECLIPTIC)?value:AST__BAD))
+
+/* An Equinox value is set if it is not equal to AST__BAD. */
+astMAKE_TEST(SkyFrame,Equinox,( this->equinox != AST__BAD ))
+
+
+/*
+*att++
+*  Name:
+*     IsLatAxis(axis)
+
+*  Purpose:
+*     Is the specified celestial axis a latitude axis?
+
+*  Type:
+*     Public attribute.
+
+*  Synopsis:
+*     Integer (boolean), read-only.
+
+*  Description:
+*     This is a read-only boolean attribute that indicates the nature of
+*     the specified axis. The attribute has a non-zero value if the
+*     specified axis is a celestial latitude axis (Declination, Galactic
+*     latitude, etc), and is zero otherwise.
+
+*  Applicability:
+*     SkyFrame
+*        All SkyFrames have this attribute.
+
+*  Notes:
+*     - When specifying this attribute by name, it should be
+*     subscripted with the number of the SkyFrame axis to be tested.
+*att--
+*/
+
+/*
+*att++
+*  Name:
+*     IsLonAxis(axis)
+
+*  Purpose:
+*     Is the specified celestial axis a longitude axis?
+
+*  Type:
+*     Public attribute.
+
+*  Synopsis:
+*     Integer (boolean), read-only.
+
+*  Description:
+*     This is a read-only boolean attribute that indicates the nature of
+*     the specified axis. The attribute has a non-zero value if the
+*     specified axis is a celestial longitude axis (Right Ascension, Galactic
+*     longitude, etc), and is zero otherwise.
+
+*  Applicability:
+*     SkyFrame
+*        All SkyFrames have this attribute.
+
+*  Notes:
+*     - When specifying this attribute by name, it should be
+*     subscripted with the number of the SkyFrame axis to be tested.
+*att--
+*/
+
+/*
+*att++
+*  Name:
+*     LatAxis
+
+*  Purpose:
+*     Index of the latitude axis.
+
+*  Type:
+*     Public attribute.
+
+*  Synopsis:
+*     Integer.
+
+*  Description:
+*     This read-only attribute gives the index (1 or 2) of the latitude
+*     axis within the SkyFrame (taking into account any current axis
+*     permutations).
+
+*  Applicability:
+*     SkyFrame
+*        All SkyFrames have this attribute.
+
+*att--
+*/
+
+/*
+*att++
+*  Name:
+*     LonAxis
+
+*  Purpose:
+*     Index of the longitude axis.
+
+*  Type:
+*     Public attribute.
+
+*  Synopsis:
+*     Integer.
+
+*  Description:
+*     This read-only attribute gives the index (1 or 2) of the longitude
+*     axis within the SkyFrame (taking into account any current axis
+*     permutations).
+
+*  Applicability:
+*     SkyFrame
+*        All SkyFrames have this attribute.
+
+*att--
+*/
+
+/*
+*att++
+*  Name:
+*     NegLon
+
+*  Purpose:
+*     Display negative longitude values?
+
+*  Type:
+*     Public attribute.
+
+*  Synopsis:
+*     Integer (boolean).
+
+*  Description:
+*     This attribute is a boolean value which controls how longitude values
+c     are normalized for display by astNorm.
+f     are normalized for display by AST_NORM.
+*
+*     If the NegLon attribute is zero, then normalized
+*     longitude values will be in the range zero to 2.pi. If NegLon is
+*     non-zero, then normalized longitude values will be in the range -pi
+*     to pi.
+*
+*     The default value depends on the current value of the SkyRefIs
+*     attribute, If SkyRefIs has a value of "Origin", then the default for
+*     NegLon is one, otherwise the default is zero.
+
+*  Applicability:
+*     SkyFrame
+*        All SkyFrames have this attribute.
+*att--
+*/
+/* Clear the NegLon value by setting it to -INT_MAX. */
+astMAKE_CLEAR(SkyFrame,NegLon,neglon,-INT_MAX)
+
+/* Supply a default of 0 for absolute coords and 1 for offset coords if
+   no NegLon value has been set. */
+astMAKE_GET(SkyFrame,NegLon,int,0,( ( this->neglon != -INT_MAX ) ?
+this->neglon : (( astGetSkyRefIs( this ) == AST__ORIGIN_REF )? 1 : 0)))
+
+/* Set a NegLon value of 1 if any non-zero value is supplied. */
+astMAKE_SET(SkyFrame,NegLon,int,neglon,( value != 0 ))
+
+/* The NegLon value is set if it is not -INT_MAX. */
+astMAKE_TEST(SkyFrame,NegLon,( this->neglon != -INT_MAX ))
+
+/*
+*att++
+*  Name:
+*     SkyTol
+
+*  Purpose:
+*     The smallest significant shift in sky coordinates.
+
+*  Type:
+*     Public attribute.
+
+*  Synopsis:
+*     Floating point.
+
+*  Description:
+*     This attribute indicates the accuracy of the axis values that will
+*     be represented by the SkyFrame. If the arc-distance between two
+*     positions within the SkyFrame is smaller than the value of SkyTol,
+*     then the two positions will (for the puposes indicated below) be
+*     considered to be co-incident.
+*
+*     This value is used only when constructing the Mapping between
+*     two different SkyFrames (for instance, when calling
+c     astConvert or astFindFrame).
+f     AST_CONVERT or AST_FINDFRAME).
+*     If the transformation between the two SkyFrames causes positions to
+*     shift by less than SkyTol arc-seconds, then the transformation is
+*     replaced by a UnitMap.  This could in certain circumatances allow
+*     major simplifications to be made to the transformation between
+*     any pixel grids associated with the two SkyFrames (for instance, if
+*     each SkyFrame is part of the WCS FrameSet associated with an image).
+*
+*     A common case is when two SkyFrames use the FK5 system, but have
+*     slightly different Epoch values. If the AlignSystem attribute has
+*     its default value of "ICRS", then the transformation between the
+*     two SkyFrames will include a very small rotation (FK5 rotates with
+*     respect to ICRS as a rate of about 0.0005 arc-seconds per year). In
+*     most circumstances such a small rotation is insignificant. Setting
+*     SkyTol to some suitably small non-zero value will cause this
+*     rotation to be ignored, allowing much simpler transformations to
+*     be used.
+*
+*     The test to determine the shift introduced by transforming between
+*     the two SkyFrames is performed by transforming a set of 14 position
+*     spread evenly over the whole sky. The largest shift produced at any
+*     of these 14 positions is compared to the value of SkyTol.
+*
+*     The SkyTol value is in units of arc-seconds, and the default value
+*     is 0.001.
+
+*  Applicability:
+*     SkyFrame
+*        All SkyFrames have this attribute.
+*att--
+*/
+astMAKE_CLEAR(SkyFrame,SkyTol,skytol,AST__BAD)
+astMAKE_GET(SkyFrame,SkyTol,double,0.001,((this->skytol!=AST__BAD)?this->skytol:0.001))
+astMAKE_SET(SkyFrame,SkyTol,double,skytol,fabs(value))
+astMAKE_TEST(SkyFrame,SkyTol,(this->skytol!=AST__BAD))
+
+/*
+*att++
+*  Name:
+*     Projection
+
+*  Purpose:
+*     Sky projection description.
+
+*  Type:
+*     Public attribute.
+
+*  Synopsis:
+*     String.
+
+*  Description:
+*     This attribute provides a place to store a description of the
+*     type of sky projection used when a SkyFrame is attached to a
+*     2-dimensional object, such as an image or plotting surface. For
+*     example, typical values might be "orthographic", "Hammer-Aitoff"
+*     or "cylindrical equal area".
+*
+*     The Projection value is purely descriptive and does not affect
+*     the celestial coordinate system represented by the SkyFrame in
+*     any way. If it is set to a non-blank string, the description
+*     provided may be used when forming the default value for the
+*     SkyFrame's Title attribute (so that typically it will appear in
+*     graphical output, for instance). The default value is an empty
+*     string.
+
+*  Applicability:
+*     SkyFrame
+*        All SkyFrames have this attribute.
+*att--
+*/
+/* Clear the Projection value by freeing the allocated memory and
+   assigning a NULL pointer. */
+astMAKE_CLEAR(SkyFrame,Projection,projection,astFree( this->projection ))
+
+/* If the Projection value is not set, return a pointer to an empty
+   string. */
+astMAKE_GET(SkyFrame,Projection,const char *,NULL,( this->projection ?
+                                                    this->projection : "" ))
+
+/* Set a Projection value by freeing any previously allocated memory,
+   allocating new memory, storing the string and saving the pointer to
+   the copy. */
+astMAKE_SET(SkyFrame,Projection,const char *,projection,astStore(
+                     this->projection, value, strlen( value ) + (size_t) 1 ))
+
+/* The Projection value is set if the pointer to it is not NULL. */
+astMAKE_TEST(SkyFrame,Projection,( this->projection != NULL ))
+
+/*
+*att++
+*  Name:
+*     SkyRefIs
+
+*  Purpose:
+*     Selects the nature of the offset coordinate system.
+
+*  Type:
+*     Public attribute.
+
+*  Synopsis:
+*     String.
+
+*  Description:
+*     This attribute controls how the values supplied for the SkyRef and
+*     SkyRefP attributes are used. These three attributes together allow
+*     a SkyFrame to represent offsets relative to some specified origin
+*     or pole within the coordinate system specified by the System attribute,
+*     rather than absolute axis values. SkyRefIs can take one of the
+*     case-insensitive values "Origin", "Pole" or "Ignored".
+*
+*     If SkyRefIs is set to "Origin", then the coordinate system
+*     represented by the SkyFrame is modified to put the origin of longitude
+*     and latitude at the position specified by the SkyRef attribute.
+*
+*     If SkyRefIs is set to "Pole", then the coordinate system represented
+*     by the SkyFrame is modified to put the north pole at the position
+*     specified by the SkyRef attribute.
+*
+*     If SkyRefIs is set to "Ignored" (the default), then any value set for the
+*     SkyRef attribute is ignored, and the SkyFrame represents the coordinate
+*     system specified by the System attribute directly without any rotation.
+
+*  Applicability:
+*     SkyFrame
+*        All SkyFrames have this attribute.
+
+*att--
+*/
+astMAKE_CLEAR(SkyFrame,SkyRefIs,skyrefis,AST__BAD_REF)
+astMAKE_SET(SkyFrame,SkyRefIs,int,skyrefis,value)
+astMAKE_TEST(SkyFrame,SkyRefIs,( this->skyrefis != AST__BAD_REF ))
+astMAKE_GET(SkyFrame,SkyRefIs,int,AST__IGNORED_REF,(this->skyrefis == AST__BAD_REF ? AST__IGNORED_REF : this->skyrefis))
+
+/*
+*att++
+*  Name:
+*     SkyRef(axis)
+
+*  Purpose:
+*     Position defining the offset coordinate system.
+
+*  Type:
+*     Public attribute.
+
+*  Synopsis:
+*     Floating point.
+
+*  Description:
+*     This attribute allows a SkyFrame to represent offsets, rather than
+*     absolute axis values, within the coordinate system specified by the
+*     System attribute. If supplied, SkyRef should be set to hold the
+*     longitude and latitude of a point within the coordinate system
+*     specified by the System attribute. The coordinate system represented
+*     by the SkyFrame will then be rotated in order to put the specified
+*     position at either the pole or the origin of the new coordinate system
+*     (as indicated by the SkyRefIs attribute). The orientation of the
+*     modified coordinate system is then controlled using the SkyRefP
+*     attribute.
+*
+*     If an integer axis index is included in the attribute name (e.g.
+*     "SkyRef(1)") then the attribute value should be supplied as a single
+*     floating point axis value, in radians, when setting a value for the
+*     attribute, and will be returned in the same form when getting the value
+*     of the attribute. In this case the integer axis index should be "1"
+*     or "2" (the values to use for longitude and latitude axes are
+*     given by the LonAxis and LatAxis attributes).
+*
+*     If no axis index is included in the attribute name (e.g. "SkyRef") then
+*     the attribute value should be supplied as a character string
+*     containing two formatted axis values (an axis 1 value followed by a
+*     comma, followed by an axis 2 value). The same form
+*     will be used when getting the value of the attribute.
+*
+*     The default values for SkyRef are zero longitude and zero latitude.
+
+*  Aligning SkyFrames with Offset Coordinate Systems:
+*     The offset coordinate system within a SkyFrame should normally be
+*     considered as a superficial "re-badging" of the axes of the coordinate
+*     system specified by the System attribute - it merely provides an
+*     alternative numerical "label" for each position in the System coordinate
+*     system. The SkyFrame retains full knowledge of the celestial coordinate
+*     system on which the offset coordinate system is based (given by the
+*     System attribute). For instance, the SkyFrame retains knowledge of the
+*     way that one celestial coordinate system may "drift" with respect to
+*     another over time. Normally, if you attempt to align two SkyFrames (e.g.
+f     using the AST_CONVERT or AST_FINDFRAME routine),
+c     using the astConvert or astFindFrame routine),
+*     the effect of any offset coordinate system defined in either SkyFrame
+*     will be removed, resulting in alignment being performed in the
+*     celestial coordinate system given by the AlignSystem attribute.
+*     However, by setting the AlignOffset attribute to a non-zero value, it
+*     is possible to change this behaviour so that the effect of the offset
+*     coordinate system is not removed when aligning two SkyFrames.
+
+*  Applicability:
+*     SkyFrame
+*        All SkyFrames have this attribute.
+
+*  Notes:
+*     - If the System attribute of the SkyFrame is changed, any position
+*     given for SkyRef is transformed into the new System.
+*     - If a value has been assigned to SkyRef attribute, then
+*     the default values for certain attributes are changed as follows:
+*     the default axis Labels for the SkyFrame are modified by appending
+*     " offset" to the end, the default axis Symbols for the SkyFrame are
+*     modified by prepending the character "D" to the start, and the
+*     default title is modified by replacing the projection information by the
+*     origin information.
+
+*att--
+*/
+MAKE_CLEAR(SkyRef,skyref,AST__BAD,2)
+MAKE_SET(SkyRef,double,skyref,value,2)
+MAKE_TEST(SkyRef,( this->skyref[axis_p] != AST__BAD ),2)
+MAKE_GET(SkyRef,double,0.0,((this->skyref[axis_p]!=AST__BAD)?this->skyref[axis_p]:0.0),2)
+
+/*
+*att++
+*  Name:
+*     SkyRefP(axis)
+
+*  Purpose:
+*     Position on primary meridian of offset coordinate system.
+
+*  Type:
+*     Public attribute.
+
+*  Synopsis:
+*     Floating point.
+
+*  Description:
+*     This attribute is used to control the orientation of the offset
+*     coordinate system defined by attributes SkyRef and SkyRefIs. If used,
+*     it should be set to hold the longitude and latitude of a point within
+*     the coordinate system specified by the System attribute. The offset
+*     coordinate system represented by the SkyFrame will then be rotated in
+*     order to put the position supplied for SkyRefP on the zero longitude
+*     meridian. This rotation is about an axis from the centre of the
+*     celestial sphere to the point specified by the SkyRef attribute.
+*     The default value for SkyRefP is usually the north pole (that is, a
+*     latitude of +90 degrees in the coordinate system specified by the System
+*     attribute). The exception to this is if the SkyRef attribute is
+*     itself set to either the north or south pole. In these cases the
+*     default for SkyRefP is the origin (that is, a (0,0) in the coordinate
+*     system specified by the System attribute).
+*
+*     If an integer axis index is included in the attribute name (e.g.
+*     "SkyRefP(1)") then the attribute value should be supplied as a single
+*     floating point axis value, in radians, when setting a value for the
+*     attribute, and will be returned in the same form when getting the value
+*     of the attribute. In this case the integer axis index should be "1"
+*     or "2" (the values to use for longitude and latitude axes are
+*     given by the LonAxis and LatAxis attributes).
+*
+*     If no axis index is included in the attribute name (e.g. "SkyRefP") then
+*     the attribute value should be supplied as a character string
+*     containing two formatted axis values (an axis 1 value followed by a
+*     comma, followed by an axis 2 value). The same form
+*     will be used when getting the value of the attribute.
+
+*  Applicability:
+*     SkyFrame
+*        All SkyFrames have this attribute.
+
+*  Notes:
+*     - If the position given by the SkyRef attribute defines the origin
+*     of the offset coordinate system (that is, if the SkyRefIs attribute
+*     is set to "origin"), then there will in general be two orientations
+*     which will put the supplied SkyRefP position on the zero longitude
+*     meridian. The orientation which is actually used is the one which
+*     gives the SkyRefP position a positive latitude in the offset coordinate
+*     system (the other possible orientation would give the SkyRefP position
+*     a negative latitude).
+*     - An error will be reported if an attempt is made to use a
+*     SkyRefP value which is co-incident with SkyRef or with the point
+*     diametrically opposite to SkyRef on the celestial sphere. The
+*     reporting of this error is deferred until the SkyRef and SkyRefP
+*     attribute values are used within a calculation.
+*     - If the System attribute of the SkyFrame is changed, any position
+*     given for SkyRefP is transformed into the new System.
+
+*att--
+*/
+MAKE_CLEAR(SkyRefP,skyrefp,AST__BAD,2)
+MAKE_SET(SkyRefP,double,skyrefp,value,2)
+MAKE_TEST(SkyRefP,( this->skyrefp[axis_p] != AST__BAD ),2)
+
+/* Copy constructor. */
+/* ----------------- */
+static void Copy( const AstObject *objin, AstObject *objout, int *status ) {
+/*
+*  Name:
+*     Copy
+
+*  Purpose:
+*     Copy constructor for SkyFrame objects.
+
+*  Type:
+*     Private function.
+
+*  Synopsis:
+*     void Copy( const AstObject *objin, AstObject *objout, int *status )
+
+*  Description:
+*     This function implements the copy constructor for SkyFrame objects.
+
+*  Parameters:
+*     objin
+*        Pointer to the object to be copied.
+*     objout
+*        Pointer to the object being constructed.
+*     status
+*        Pointer to the inherited status variable.
+
+*  Notes:
+*     -  This constructor makes a deep copy.
+*/
+
+/* Local Variables: */
+   AstSkyFrame *in;              /* Pointer to input SkyFrame */
+   AstSkyFrame *out;             /* Pointer to output SkyFrame */
+
+/* Check the global error status. */
+   if ( !astOK ) return;
+
+/* Obtain pointers to the input and output SkyFrames. */
+   in = (AstSkyFrame *) objin;
+   out = (AstSkyFrame *) objout;
+
+/* For safety, first clear any references to the input memory from
+   the output SkyFrame. */
+   out->projection = NULL;
+
+/* If necessary, allocate memory in the output SkyFrame and store a
+   copy of the input Projection string. */
+   if ( in->projection ) out->projection = astStore( NULL, in->projection,
+                                      strlen( in->projection ) + (size_t) 1 );
+
+/* If an error occurred, free any allocated memory. */
+   if ( !astOK ) {
+      out->projection = astFree( out->projection );
+   }
+}
+
+/* Destructor. */
+/* ----------- */
+static void Delete( AstObject *obj, int *status ) {
+/*
+*  Name:
+*     Delete
+
+*  Purpose:
+*     Destructor for SkyFrame objects.
+
+*  Type:
+*     Private function.
+
+*  Synopsis:
+*     void Delete( AstObject *obj, int *status )
+
+*  Description:
+*     This function implements the destructor for SkyFrame objects.
+
+*  Parameters:
+*     obj
+*        Pointer to the object to be deleted.
+*     status
+*        Pointer to the inherited status variable.
+
+*  Notes:
+*     This function attempts to execute even if the global error status is
+*     set.
+*/
+
+/* Local Variables: */
+   AstSkyFrame *this;            /* Pointer to SkyFrame */
+
+/* Obtain a pointer to the SkyFrame structure. */
+   this = (AstSkyFrame *) obj;
+
+/* Free the memory used for the Projection string if necessary. */
+   this->projection = astFree( this->projection );
+}
+
+/* Dump function. */
+/* -------------- */
+static void Dump( AstObject *this_object, AstChannel *channel, int *status ) {
+/*
+*  Name:
+*     Dump
+
+*  Purpose:
+*     Dump function for SkyFrame 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 SkyFrame class to an output Channel.
+
+*  Parameters:
+*     this
+*        Pointer to the SkyFrame 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: */
+   AstSkyFrame *this;            /* Pointer to the SkyFrame structure */
+   AstSystemType system;         /* System attribute value */
+   char buf[ 100 ];              /* Comment buffer */
+   char key[ 10 ];               /* Buffer for keywords */
+   const char *sval;             /* Pointer to string value */
+   const int *perm;              /* Pointer to axis permutation array */
+   double dval;                  /* Double value */
+   int bessyr;                   /* Use a Besselian year value ?*/
+   int helpful;                  /* Helpful to display un-set value? */
+   int invperm[ 2 ];             /* Inverse permutation array */
+   int ival;                     /* Integer value */
+   int set;                      /* Attribute value set? */
+   int axis;                     /* External (i.e. permuted) zero-based axis index */
+   int axis_p;                   /* Internal zero-based axis index */
+
+/* Check the global error status. */
+   if ( !astOK ) return;
+
+/* Obtain a pointer to the SkyFrame structure. */
+   this = (AstSkyFrame *) this_object;
+
+/* Get a pointer to the SkyFrame's axis permutation array (using a method,
+   to allow for any over-ride by a derived class). */
+   perm = astGetPerm( this );
+
+/* Generate an inverse axis permutation array from the forward permutation
+   values. This will be used to determine which axis should be enquired
+   about (using possibly over-ridden methods) to obtain data to
+   correspond with a particular internal value (i.e. instance variable)
+   relating to an axis. This step is needed so that the effect of any
+   axis permutation can be un-done before values are written out, as
+   output values are written by this function in un-permuted order. */
+   for ( axis = 0; axis < 2; axis++ ) invperm[ perm[ axis ] ] = axis;
+
+/* Write out values representing the instance variables for the
+   SkyFrame 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. */
+
+/* Projection. */
+/* ----------- */
+   set = TestProjection( this, status );
+   sval = set ? GetProjection( this, status ) : astGetProjection( this );
+   astWriteString( channel, "Proj", set, 0, sval,
+                   "Description of sky projection" );
+
+/* NegLon. */
+/* ------- */
+   set = TestNegLon( this, status );
+   ival = set ? GetNegLon( this, status ) : astGetNegLon( this );
+   astWriteInt( channel, "NegLon", set, 0, ival,
+                ival ? "Display negative longitude values" :
+                       "Display positive longitude values" );
+
+/* SkyTol. */
+/* ------- */
+   set = TestSkyTol( this, status );
+   dval = set ? GetSkyTol( this, status ) : astGetSkyTol( this );
+   astWriteDouble( channel, "SkyTol", set, 1, dval,
+                   "Smallest significant separation [arc-sec]");
+
+/* Equinox. */
+/* -------- */
+   set = TestEquinox( this, status );
+   dval = set ? GetEquinox( this, status ) : astGetEquinox( this );
+
+/* Decide whether the Equinox value is relevant to the current
+   coordinate system. */
+   system = astGetSystem( this );
+   helpful = ( ( system == AST__FK4 ) ||
+               ( system == AST__FK4_NO_E ) ||
+               ( system == AST__FK5 ) ||
+               ( system == AST__ECLIPTIC ) );
+
+/* Convert MJD to Besselian or Julian years, depending on the value. */
+   bessyr = ( dval < palEpj2d( 1984.0 ) );
+   dval = bessyr ? palEpb( dval ) : palEpj( dval );
+   astWriteDouble( channel, "Eqnox", set, helpful, dval,
+                   bessyr ? "Besselian epoch of mean equinox" :
+                            "Julian epoch of mean equinox" );
+
+/* SkyRefIs. */
+/* --------- */
+   set = TestSkyRefIs( this, status );
+   ival = set ? GetSkyRefIs( this, status ) : astGetSkyRefIs( this );
+   if( ival == AST__POLE_REF ) {
+      astWriteString( channel, "SRefIs", set, 0, POLE_STRING,
+                      "Rotated to put pole at ref. pos." );
+
+   } else if( ival == AST__IGNORED_REF ) {
+      astWriteString( channel, "SRefIs", set, 0, IGNORED_STRING,
+                      "Not rotated (ref. pos. is ignored)" );
+
+   } else {
+      astWriteString( channel, "SRefIs", set, 0, ORIGIN_STRING,
+                      "Rotated to put origin at ref. pos." );
+   }
+
+/* SkyRef. */
+/* ------- */
+/* The inverse axis permutation array is used to obtain the axis index
+   to use when accessing the SkyRef attribute. This reverses the effect
+   of the SkyFrame's axis permutation array and yields a value appropriate
+   to the axis with internal index "axis". */
+   for ( axis_p = 0; axis_p < 2; axis_p++ ) {
+      axis = invperm[ axis_p ];
+
+      set = TestSkyRef( this, axis, status );
+      dval = set ? GetSkyRef( this, axis, status ) : astGetSkyRef( this, axis );
+      sprintf( buf, "Ref. pos. %s %s", astGetSymbol( this, axis ),
+               astFormat( this, axis, dval ) );
+      sprintf( key, "SRef%d", axis_p + 1 );
+      astWriteDouble( channel, key, set, 0, dval, buf );
+   }
+
+/* SkyRefP. */
+/* -------- */
+   for ( axis_p = 0; axis_p < 2; axis_p++ ) {
+      axis = invperm[ axis_p ];
+
+      set = TestSkyRefP( this, axis, status );
+      dval = set ? GetSkyRefP( this, axis, status ) : astGetSkyRefP( this, axis );
+      sprintf( buf, "Ref. north %s %s", astGetSymbol( this, axis ),
+               astFormat( this, axis, dval ) );
+      sprintf( key, "SRefP%d", axis_p + 1 );
+      astWriteDouble( channel, key, set, 0, dval, buf );
+   }
+
+/* AlignOffset. */
+/* ------------ */
+   set = TestAlignOffset( this, status );
+   ival = set ? GetAlignOffset( this, status ) : astGetAlignOffset( this );
+   astWriteInt( channel, "AlOff", set, 0, ival,
+                ival ? "Align in offset coords" :
+                       "Align in system coords" );
+}
+
+/* Standard class functions. */
+/* ========================= */
+/* Implement the astIsASkyFrame and astCheckSkyFrame functions using the macros
+   defined for this purpose in the "object.h" header file. */
+astMAKE_ISA(SkyFrame,Frame)
+astMAKE_CHECK(SkyFrame)
+
+AstSkyFrame *astSkyFrame_( const char *options, int *status, ...) {
+/*
+*+
+*  Name:
+*     astSkyFrame
+
+*  Purpose:
+*     Create a SkyFrame.
+
+*  Type:
+*     Protected function.
+
+*  Synopsis:
+*     #include "skyframe.h"
+*     AstSkyFrame *astSkyFrame( const char *options, int *status, ... )
+
+*  Class Membership:
+*     SkyFrame constructor.
+
+*  Description:
+*     This function creates a new SkyFrame 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 SkyFrame. 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 SkyFrame.
+
+*  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 SkyFrame constructor which
+*     is available via the protected interface to the SkyFrame class.
+*     A public interface is provided by the astSkyFrameId_ function.
+*/
+
+/* Local Variables: */
+   astDECLARE_GLOBALS            /* Pointer to thread-specific global data */
+   AstSkyFrame *new;             /* Pointer to new SkyFrame */
+   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 SkyFrame, allocating memory and initialising the virtual
+   function table as well if necessary. */
+   new = astInitSkyFrame( NULL, sizeof( AstSkyFrame ), !class_init, &class_vtab,
+                          "SkyFrame" );
+
+/* 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 SkyFrame's attributes. */
+      va_start( args, status );
+      astVSet( new, options, NULL, args );
+      va_end( args );
+
+/* If an error occurred, clean up by deleting the new object. */
+      if ( !astOK ) new = astDelete( new );
+   }
+
+/* Return a pointer to the new SkyFrame. */
+   return new;
+}
+
+AstSkyFrame *astInitSkyFrame_( void *mem, size_t size, int init,
+                               AstSkyFrameVtab *vtab, const char *name, int *status ) {
+/*
+*+
+*  Name:
+*     astInitSkyFrame
+
+*  Purpose:
+*     Initialise a SkyFrame.
+
+*  Type:
+*     Protected function.
+
+*  Synopsis:
+*     #include "skyframe.h"
+*     AstSkyFrame *astInitSkyFrame( void *mem, size_t size, int init,
+*                                   AstFrameVtab *vtab, const char *name )
+
+*  Class Membership:
+*     SkyFrame initialiser.
+
+*  Description:
+*     This function is provided for use by class implementations to initialise
+*     a new SkyFrame object. It allocates memory (if necessary) to accommodate
+*     the SkyFrame plus any additional data associated with the derived class.
+*     It then initialises a SkyFrame 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 SkyFrame at the start of the memory passed via the
+*     "vtab" parameter.
+
+*  Parameters:
+*     mem
+*        A pointer to the memory in which the SkyFrame is to be created. This
+*        must be of sufficient size to accommodate the SkyFrame data
+*        (sizeof(SkyFrame)) 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 SkyFrame (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 SkyFrame
+*        structure, so a valid value must be supplied even if not required for
+*        allocating memory.
+*     init
+*        A logical flag indicating if the SkyFrame'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 SkyFrame.
+*     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 SkyFrame.
+
+*  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: */
+   AstSkyAxis *ax;               /* Pointer to SkyAxis object */
+   AstSkyFrame *new;             /* Pointer to the new SkyFrame */
+   int axis;                     /* Loop counter for axes */
+
+/* Check the global status. */
+   if ( !astOK ) return NULL;
+
+/* If necessary, initialise the virtual function table. */
+   if ( init ) astInitSkyFrameVtab( vtab, name );
+
+/* Initialise a Frame structure (the parent class) as the first component
+   within the SkyFrame structure, allocating memory if necessary. */
+   new = (AstSkyFrame *) astInitFrame( mem, size, 0,
+                                       (AstFrameVtab *) vtab, name, 2 );
+
+      if ( astOK ) {
+
+/* Initialise the SkyFrame data. */
+/* ----------------------------- */
+/* Initialise all attributes to their "undefined" values. */
+      new->equinox = AST__BAD;
+      new->projection = NULL;
+      new->neglon = -INT_MAX;
+      new->skytol = AST__BAD;
+      new->alignoffset = -INT_MAX;
+      new->skyrefis = AST__BAD_REF;
+      new->skyref[ 0 ] = AST__BAD;
+      new->skyref[ 1 ] = AST__BAD;
+      new->skyrefp[ 0 ] = AST__BAD;
+      new->skyrefp[ 1 ] = AST__BAD;
+      new->last = AST__BAD;
+      new->eplast = AST__BAD;
+      new->klast = AST__BAD;
+      new->diurab = AST__BAD;
+
+/* Loop to replace the Axis object associated with each SkyFrame axis with
+   a SkyAxis object instead. */
+      for ( axis = 0; axis < 2; axis++ ) {
+
+/* Create the new SkyAxis, assign it to the required SkyFrame axis and then
+   annul the SkyAxis pointer. */
+         ax = astSkyAxis( "", status );
+         astSetAxis( new, axis, ax );
+         ax = astAnnul( ax );
+      }
+
+/* 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;
+}
+
+AstSkyFrame *astLoadSkyFrame_( void *mem, size_t size,
+                               AstSkyFrameVtab *vtab, const char *name,
+                               AstChannel *channel, int *status ) {
+/*
+*+
+*  Name:
+*     astLoadSkyFrame
+
+*  Purpose:
+*     Load a SkyFrame.
+
+*  Type:
+*     Protected function.
+
+*  Synopsis:
+*     #include "skyframe.h"
+*     AstSkyFrame *astLoadSkyFrame( void *mem, size_t size,
+*                                    AstSkyFrameVtab *vtab, const char *name,
+*                                    AstChannel *channel )
+
+*  Class Membership:
+*     SkyFrame loader.
+
+*  Description:
+*     This function is provided to load a new SkyFrame 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
+*     SkyFrame structure in this memory, using data read from the
+*     input Channel.
+
+*  Parameters:
+*     mem
+*        A pointer to the memory into which the SkyFrame is to be
+*        loaded.  This must be of sufficient size to accommodate the
+*        SkyFrame data (sizeof(SkyFrame)) 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 SkyFrame (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 SkyFrame 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(AstSkyFrame) is used instead.
+*     vtab
+*        Pointer to the start of the virtual function table to be
+*        associated with the new SkyFrame. If this is NULL, a pointer
+*        to the (static) virtual function table for the SkyFrame 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 "SkyFrame" is used instead.
+
+*  Returned Value:
+*     A pointer to the new SkyFrame.
+
+*  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: */
+   AstSkyFrame *new;             /* Pointer to the new SkyFrame */
+   astDECLARE_GLOBALS            /* Pointer to thread-specific global data */
+   char *sval;                   /* Pointer to string value */
+   const int *perm;              /* Pointer to axis permutation array */
+   double dval;                  /* Floating point attribute value */
+   int axis;                     /* External axis index */
+   int invperm[ 2 ];             /* Inverse permutation array */
+
+/* Initialise. */
+   new = NULL;
+
+/* Get a pointer to the thread specific global data structure. */
+   astGET_GLOBALS(channel);
+
+/* 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 SkyFrame. In this case the
+   SkyFrame belongs to this class, so supply appropriate values to be
+   passed to the parent class loader (and its parent, etc.). */
+   if ( !vtab ) {
+      size = sizeof( AstSkyFrame );
+      vtab = &class_vtab;
+      name = "SkyFrame";
+
+/* If required, initialise the virtual function table for this class. */
+      if ( !class_init ) {
+         astInitSkyFrameVtab( 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 SkyFrame. */
+   new = astLoadFrame( mem, size, (AstFrameVtab *) vtab, name,
+                       channel );
+
+   if ( astOK ) {
+
+/* Get a pointer to the SkyFrame's axis permutation array (using a method,
+   to allow for any over-ride by a derived class). */
+      perm = astGetPerm( new );
+
+/* Generate an inverse axis permutation array from the forward permutation
+   values. This will be used to determine which axis should be enquired
+   about (using possibly over-ridden methods) to obtain data to
+   correspond with a particular internal value (i.e. instance variable)
+   relating to an axis. This step is needed so that the effect of any
+   axis permutation can be un-done before values are written out, as
+   output values are written by this function in un-permuted order. */
+      for( axis = 0; axis < 2; axis++ ) invperm[ perm[ axis ] ] = axis;
+
+/* Read input data. */
+/* ================ */
+/* Request the input Channel to read all the input data appropriate to
+   this class into the internal "values list". */
+      astReadClassData( channel, "SkyFrame" );
+
+/* 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. */
+
+/* The attributes defining the offset coordinate system must be loaded
+   before the System attrivbute, since SetSystem uses them. */
+
+/* AlignOffset */
+/* ----------- */
+      new->alignoffset = astReadInt( channel, "aloff", -INT_MAX );
+      if ( TestAlignOffset( new, status ) ) SetAlignOffset( new, new->alignoffset, status );
+
+/* SkyRefIs. */
+/* --------- */
+      sval = astReadString( channel, "srefis", " " );
+      if( sval ){
+         new->skyrefis = AST__BAD_REF;
+         if( astChrMatch( sval, POLE_STRING ) ) {
+            new->skyrefis = AST__POLE_REF;
+         } else if( astChrMatch( sval, ORIGIN_STRING ) ) {
+            new->skyrefis = AST__ORIGIN_REF;
+         } else if( astChrMatch( sval, IGNORED_STRING ) ) {
+            new->skyrefis = AST__IGNORED_REF;
+         } else if( !astChrMatch( sval, " " ) && astOK ){
+	    astError( AST__INTER, "astRead(SkyFrame): Corrupt SkyFrame contains "
+		      "invalid SkyRefIs attribute value (%s).", status, sval );
+         }
+         if( TestSkyRefIs( new, status ) ) SetSkyRefIs( new, new->skyrefis, status );
+         sval = astFree( sval );
+      }
+
+/* SkyRef. */
+/* ------- */
+      new->skyref[ 0 ] = astReadDouble( channel, "sref1", AST__BAD );
+      axis = invperm[ 0 ];
+      if ( TestSkyRef( new, axis, status ) ) SetSkyRef( new, axis, new->skyref[ 0 ], status );
+
+      new->skyref[ 1 ] = astReadDouble( channel, "sref2", AST__BAD );
+      axis = invperm[ 1 ];
+      if ( TestSkyRef( new, axis, status ) ) SetSkyRef( new, axis, new->skyref[ 1 ], status );
+
+/* SkyRefP. */
+/* -------- */
+      new->skyrefp[ 0 ] = astReadDouble( channel, "srefp1", AST__BAD );
+      axis = invperm[ 0 ];
+      if ( TestSkyRefP( new, axis, status ) ) SetSkyRefP( new, axis, new->skyrefp[ 0 ], status );
+
+      new->skyrefp[ 1 ] = astReadDouble( channel, "srefp2", AST__BAD );
+      axis = invperm[ 1 ];
+      if ( TestSkyRefP( new, axis, status ) ) SetSkyRefP( new, axis, new->skyrefp[ 1 ], status );
+
+/* System. */
+/* ------- */
+/* The System attribute is now part of the Frame class, but this code is
+   retained to allow this version of AST to read SkyFrames dumped by
+   previous versions.  */
+
+/* Check a value has not already been assigned to the Frames System
+   attribute.  */
+      if( !astTestSystem( new ) ){
+
+/* Read the external representation as a string. */
+         sval = astReadString( channel, "system", NULL );
+
+/* If a value was read, use the SetAttrib method to validate and store the
+   new value in the correct place, then free the string. */
+         if ( sval ) {
+            astSet( new, "System=%s", status, sval);
+            sval = astFree( sval );
+         }
+      }
+
+/* Epoch. */
+/* ------ */
+/* The Epoch attribute is now part of the Frame class, but this code is
+   retained to allow this version of AST to read SkyFrames dumped by
+   previous versions.  */
+
+/* Check a value has not already been assigned to the Frames Epoch
+   attribute.  */
+      if( !astTestEpoch( new ) ){
+
+/* Get the value. */
+         dval = astReadDouble( channel, "epoch", AST__BAD );
+
+/* If a value was read, use the SetAttrib method to validate and store the
+   new value in the correct place. */
+         if( dval != AST__BAD ) {
+            if( dval < 1984.0 ) {
+               astSet( new, "Epoch=B%.*g", status, AST__DBL_DIG, dval);
+            } else {
+               astSet( new, "Epoch=J%.*g", status, AST__DBL_DIG, dval);
+            }
+         }
+      }
+
+/* Projection. */
+/* ----------- */
+      new->projection = astReadString( channel, "proj", NULL );
+
+/* Equinox. */
+/* -------- */
+/* Interpret this as Besselian or Julian depending on its value. */
+      new->equinox = astReadDouble( channel, "eqnox", AST__BAD );
+      if ( TestEquinox( new, status ) ) {
+         SetEquinox( new, ( new->equinox < 1984.0 ) ? palEpb2d( new->equinox ) :
+                                                      palEpj2d( new->equinox ), status );
+      }
+
+/* NegLon. */
+/* ------- */
+      new->neglon = astReadInt( channel, "neglon", -INT_MAX );
+      if ( TestNegLon( new, status ) ) SetNegLon( new, new->neglon, status );
+
+/* SkyTol. */
+/* ------- */
+      new->skytol = astReadDouble( channel, "skytol", AST__BAD );
+      if ( TestSkyTol( new, status ) ) SetSkyTol( new, new->skytol, status );
+
+/* Other values */
+/* ------------ */
+      new->last = AST__BAD;
+      new->eplast = AST__BAD;
+      new->klast = AST__BAD;
+      new->diurab = AST__BAD;
+
+/* If an error occurred, clean up by deleting the new SkyFrame. */
+      if ( !astOK ) new = astDelete( new );
+   }
+
+/* Return the new SkyFrame 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 astClearAsTime_( AstSkyFrame *this, int axis, int *status ) {
+   if ( !astOK ) return;
+   (**astMEMBER(this,SkyFrame,ClearAsTime))( this, axis, status );
+}
+int astGetAsTime_( AstSkyFrame *this, int axis, int *status ) {
+   if ( !astOK ) return 0;
+   return (**astMEMBER(this,SkyFrame,GetAsTime))( this, axis, status );
+}
+void astSetAsTime_( AstSkyFrame *this, int axis, int value, int *status ) {
+   if ( !astOK ) return;
+   (**astMEMBER(this,SkyFrame,SetAsTime))( this, axis, value, status );
+}
+int astTestAsTime_( AstSkyFrame *this, int axis, int *status ) {
+   if ( !astOK ) return 0;
+   return (**astMEMBER(this,SkyFrame,TestAsTime))( this, axis, status );
+}
+int astGetIsLatAxis_( AstSkyFrame *this, int axis, int *status ) {
+   if ( !astOK ) return 0;
+   return (**astMEMBER(this,SkyFrame,GetIsLatAxis))( this, axis, status );
+}
+int astGetIsLonAxis_( AstSkyFrame *this, int axis, int *status ) {
+   if ( !astOK ) return 0;
+   return (**astMEMBER(this,SkyFrame,GetIsLonAxis))( this, axis, status );
+}
+int astGetLatAxis_( AstSkyFrame *this, int *status ) {
+   if ( !astOK ) return 1;
+   return (**astMEMBER(this,SkyFrame,GetLatAxis))( this, status );
+}
+int astGetLonAxis_( AstSkyFrame *this, int *status ) {
+   if ( !astOK ) return 0;
+   return (**astMEMBER(this,SkyFrame,GetLonAxis))( this, status );
+}
+double astGetSkyRefP_( AstSkyFrame *this, int axis, int *status ) {
+   if ( !astOK ) return 0.0;
+   return (**astMEMBER(this,SkyFrame,GetSkyRefP))( this, axis, status );
+}
+AstMapping *astSkyOffsetMap_( AstSkyFrame *this, int *status ) {
+   if ( !astOK ) return NULL;
+   return (**astMEMBER(this,SkyFrame,SkyOffsetMap))( 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. */
+AstSkyFrame *astSkyFrameId_( const char *, ... );
+
+/* Special interface function implementations. */
+/* ------------------------------------------- */
+AstSkyFrame *astSkyFrameId_( const char *options, ... ) {
+/*
+*++
+*  Name:
+c     astSkyFrame
+f     AST_SKYFRAME
+
+*  Purpose:
+*     Create a SkyFrame.
+
+*  Type:
+*     Public function.
+
+*  Synopsis:
+c     #include "skyframe.h"
+c     AstSkyFrame *astSkyFrame( const char *options, ... )
+f     RESULT = AST_SKYFRAME( OPTIONS, STATUS )
+
+*  Class Membership:
+*     SkyFrame constructor.
+
+*  Description:
+*     This function creates a new SkyFrame and optionally initialises
+*     its attributes.
+*
+*     A SkyFrame is a specialised form of Frame which describes
+*     celestial longitude/latitude coordinate systems. The particular
+*     celestial coordinate system to be represented is specified by
+*     setting the SkyFrame's System attribute (currently, the default
+*     is ICRS) qualified, as necessary, by a mean Equinox value and/or
+*     an Epoch.
+*
+*     For each of the supported celestial coordinate systems, a SkyFrame
+*     can apply an optional shift of origin to create a coordinate system
+*     representing offsets within the celestial coordinate system from some
+*     specified point. This offset coordinate system can also be rotated to
+*     define new longitude and latitude axes. See attributes SkyRef, SkyRefIs
+*     and SkyRefP
+*
+*     All the coordinate values used by a SkyFrame are in
+*     radians. These may be formatted in more conventional ways for
+c     display by using astFormat.
+f     display by using AST_FORMAT.
+
+*  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 SkyFrame. 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 SkyFrame. 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     astSkyFrame()
+f     AST_SKYFRAME = INTEGER
+*        A pointer to the new SkyFrame.
+
+*  Examples:
+c     frame = astSkyFrame( "" );
+c        Creates a SkyFrame to describe the default ICRS celestial
+c        coordinate system.
+c     frame = astSkyFrame( "System = FK5, Equinox = J2005, Digits = 10" );
+c        Creates a SkyFrame to describe the FK5 celestial
+c        coordinate system, with a mean Equinox of J2005.0.
+c        Because especially accurate coordinates will be used,
+c        additional precision (10 digits) has been requested. This will
+c        be used when coordinate values are formatted for display.
+c     frame = astSkyFrame( "System = FK4, Equinox = 1955-sep-2" );
+c        Creates a SkyFrame to describe the old FK4 celestial
+c        coordinate system.  A default Epoch value (B1950.0) is used,
+c        but the mean Equinox value is given explicitly as "1955-sep-2".
+c     frame = astSkyFrame( "System = GAPPT, Epoch = %s", date );
+c        Creates a SkyFrame to describe the Geocentric Apparent
+c        celestial coordinate system. The Epoch value, which specifies
+c        the date of observation, is obtained from a date/time string
+c        supplied via the string pointer "date".
+f     FRAME = AST_SKYFRAME( ' ', STATUS )
+f        Creates a SkyFrame to describe the default ICRS celestial
+f        coordinate system.
+f     FRAME = AST_SKYFRAME( 'System = FK5, Equinox = J2005, Digits = 10', STATUS )
+f        Creates a SkyFrame to describe the FK5 celestial
+f        coordinate system, with a mean Equinox of J2005.0.
+f        Because especially accurate coordinates will be used,
+f        additional precision (10 digits) has been requested. This will
+f        be used when coordinate values are formatted for display.
+f     FRAME = AST_SKYFRAME( 'System = FK4, Equinox = 1955-SEP-2', STATUS )
+f        Creates a SkyFrame to describe the old FK4 celestial
+f        coordinate system.  A default Epoch value (B1950.0) is used,
+f        but the mean Equinox value is given explicitly as "1955-SEP-2".
+f     FRAME = AST_SKYFRAME( 'System = GAPPT, Epoch = ' // DATE, STATUS )
+f        Creates a SkyFrame to describe the Geocentric Apparent
+f        celestial coordinate system. The Epoch value, which specifies
+f        the date of observation, is obtained from a date/time string
+f        contained in the character variable DATE.
+
+*  Notes:
+*     - Currently, the default celestial coordinate system is
+*     ICRS. However, this default may change in future as new
+*     astrometric standards evolve. The intention is to track the most
+*     modern appropriate standard. For this reason, you should use the
+*     default only if this is what you intend (and can tolerate any
+*     associated slight change in behaviour with future versions of
+*     this function). If you intend to use the ICRS system
+*     indefinitely, then you should specify it explicitly using an
+c     "options" value of "System=ICRS".
+f     OPTIONS value of "System=ICRS".
+*     - Whichever celestial coordinate system is represented, it will
+*     have two axes.  The first of these will be the longitude axis
+*     and the second will be the latitude axis. This order can be
+c     changed using astPermAxes if required.
+f     changed using AST_PERMAXES if required.
+*     - When conversion between two SkyFrames is requested (as when
+c     supplying SkyFrames to astConvert),
+f     supplying SkyFrames AST_CONVERT),
+*     account will be taken of the nature of the celestial coordinate
+*     systems they represent, together with any qualifying mean Equinox or
+*     Epoch values, etc. The AlignSystem attribute will also be taken into
+*     account. The results will therefore fully reflect the
+*     relationship between positions on the sky measured in the two
+*     systems.
+*     - 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 astSkyFrame constructor function. It returns an ID value
+*     (instead of a true C pointer) to external users, and must be
+*     provided because astSkyFrame_ 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 astSkyFrame_ 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 */
+   AstSkyFrame *new;             /* Pointer to new SkyFrame */
+   va_list args;                 /* Variable argument list */
+
+   int *status;                  /* Pointer to inherited status value */
+
+/* Get a pointer to the inherited status value. */
+   status = astGetStatusPtr;
+
+/* Get a pointer to the thread specific global data structure. */
+   astGET_GLOBALS(NULL);
+
+/* Check the global status. */
+   if ( !astOK ) return NULL;
+
+/* Initialise the SkyFrame, allocating memory and initialising the virtual
+   function table as well if necessary. */
+   new = astInitSkyFrame( NULL, sizeof( AstSkyFrame ), !class_init, &class_vtab,
+                          "SkyFrame" );
+
+/* 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 SkyFrame's attributes. */
+      va_start( args, options );
+      astVSet( new, options, NULL, args );
+      va_end( args );
+
+/* If an error occurred, clean up by deleting the new object. */
+      if ( !astOK ) new = astDelete( new );
+   }
+
+/* Return an ID value for the new SkyFrame. */
+   return astMakeId( new );
+}
+
+
+
+
+
+
+