update ast 8.6.2

1 files changed, 0 insertions, 12592 deletions

diff --git a/ast/skyframe.c b/ast/skyframe.c
deleted file mode 100644
index 1c20839..0000000
--- a/ast/skyframe.c
+++ /dev/null
@@ -1,12592 +0,0 @@
-/*
-*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 );
-}
-
-
-
-
-
-
-