upgrade ast 8.7.1

1 files changed, 0 insertions, 13337 deletions

diff --git a/ast/frameset.c b/ast/frameset.c
deleted file mode 100644
index 8795790..0000000
--- a/ast/frameset.c
+++ /dev/null
@@ -1,13337 +0,0 @@
-/*
-*class++
-*  Name:
-*     FrameSet
-
-*  Purpose:
-*     Set of inter-related coordinate systems.
-
-*  Constructor Function:
-c     astFrameSet
-f     AST_FRAMESET
-
-*  Description:
-*     A FrameSet consists of a set of one or more Frames (which
-*     describe coordinate systems), connected together by Mappings
-*     (which describe how the coordinate systems are inter-related). A
-*     FrameSet makes it possible to obtain a Mapping between any pair
-*     of these Frames (i.e. to convert between any of the coordinate
-*     systems which it describes).  The individual Frames are
-*     identified within the FrameSet by an integer index, with Frames
-*     being numbered consecutively from one as they are added to the
-*     FrameSet.
-*
-*     Every FrameSet has a "base" Frame and a "current" Frame (which
-*     are allowed to be the same). Any of the Frames may be nominated
-*     to hold these positions, and the choice is determined by the
-*     values of the FrameSet's Base and Current attributes, which hold
-*     the indices of the relevant Frames.  By default, the first Frame
-*     added to a FrameSet is its base Frame, and the last one added is
-*     its current Frame.
-*
-*     The base Frame describes the "native" coordinate system of
-*     whatever the FrameSet is used to calibrate (e.g. the pixel
-*     coordinates of an image) and the current Frame describes the
-*     "apparent" coordinate system in which it should be viewed
-*     (e.g. displayed, etc.). Any further Frames represent a library
-*     of alternative coordinate systems, which may be selected by
-*     making them current.
-*
-*     When a FrameSet is used in a context that requires a Frame,
-*     (e.g. obtaining its Title value, or number of axes), the current
-*     Frame is used. A FrameSet may therefore be used in place of its
-*     current Frame in most situations.
-*
-*     When a FrameSet is used in a context that requires a Mapping,
-*     the Mapping used is the one between its base Frame and its
-*     current Frame. Thus, a FrameSet may be used to convert "native"
-*     coordinates into "apparent" ones, and vice versa. Like any
-c     Mapping, a FrameSet may also be inverted (see astInvert), which
-f     Mapping, a FrameSet may also be inverted (see AST_INVERT), which
-*     has the effect of interchanging its base and current Frames and
-*     hence of reversing the Mapping between them.
-*
-*     Regions may be added into a FrameSet (since a Region is a type of
-*     Frame), either explicitly or as components within CmpFrames. In
-*     this case the Mapping between a pair of Frames within a FrameSet
-*     will include the masking effects produced by any Regions included
-*     in the path between the Frames.
-
-*  Inheritance:
-*     The FrameSet class inherits from the Frame class.
-
-*  Attributes:
-*     In addition to those attributes common to all Frames, every
-*     FrameSet also has the following attributes:
-*
-*     - AllVariants: List of all variant mappings stored with current Frame
-*     - Base: FrameSet base Frame index
-*     - Current: FrameSet current Frame index
-*     - Nframe: Number of Frames in a FrameSet
-*     - Variant: Name of variant mapping in use by current Frame
-
-*     Every FrameSet also inherits any further attributes that belong
-*     to its current Frame, regardless of that Frame's class. (For
-*     example, the Equinox attribute, defined by the SkyFrame class, is
-*     inherited by any FrameSet which has a SkyFrame as its current
-*     Frame.) The set of attributes belonging to a FrameSet may therefore
-*     change when a new current Frame is selected.
-
-*  Functions:
-c     In addition to those functions applicable to all Frames, the
-c     following functions may also be applied to all FrameSets:
-f     In addition to those routines applicable to all Frames, the
-f     following routines may also be applied to all FrameSets:
-*
-c     - astAddFrame: Add a Frame to a FrameSet to define a new coordinate
-c     system
-c     - astAddVariant: Add a variant Mapping to the current Frame
-c     - astGetFrame: Obtain a pointer to a specified Frame in a FrameSet
-c     - astGetMapping: Obtain a Mapping between two Frames in a FrameSet
-c     - astMirrorVariants: Make the current Frame mirror variant Mappings in another Frame
-c     - astRemapFrame: Modify a Frame's relationship to the other Frames in a
-c     FrameSet
-c     - astRemoveFrame: Remove a Frame from a FrameSet
-f     - AST_ADDFRAME: Add a Frame to a FrameSet to define a new coordinate
-f     system
-f     - AST_ADDVARIANT: Add a variant Mapping to the current Frame
-f     - AST_GETFRAME: Obtain a pointer to a specified Frame in a FrameSet
-f     - AST_GETMAPPING: Obtain a Mapping between two Frames in a FrameSet
-f     - AST_MIRRORVARIANTS: Make the current Frame mirror variant Mappings in another Frame
-f     - AST_REMAPFRAME: Modify a Frame's relationship to the other Frames in a
-f     FrameSet
-f     - AST_REMOVEFRAME: Remove a Frame from a FrameSet
-
-*  Copyright:
-*     Copyright (C) 1997-2006 Council for the Central Laboratory of the
-*     Research Councils
-
-*  Licence:
-*     This program is free software: you can redistribute it and/or
-*     modify it under the terms of the GNU Lesser General Public
-*     License as published by the Free Software Foundation, either
-*     version 3 of the License, or (at your option) any later
-*     version.
-*
-*     This program is distributed in the hope that it will be useful,
-*     but WITHOUT ANY WARRANTY; without even the implied warranty of
-*     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-*     GNU Lesser General Public License for more details.
-*
-*     You should have received a copy of the GNU Lesser General
-*     License along with this program.  If not, see
-*     <http://www.gnu.org/licenses/>.
-
-*  Authors:
-*     RFWS: R.F. Warren-Smith (Starlink)
-
-*  History:
-*     16-FEB-1996 (RFWS):
-*        Original version.
-*     5-JUN-1996 (RFWS):
-*        Tidied up, etc.
-*     2-JUL-1996 (RFWS):
-*        Fixed bug in astRemoveFrame which caused the base/current
-*        Frame index to be wrong.
-*     12-JUL-1996 (RFWS):
-*        Over-ride the astReportPoints method to provide
-*        Frame-specific formatting.
-*     12-AUG-1996 (RFWS):
-*        Upgraded to provide a public interface, plus improvements to
-*        astAlign and the handling of nodes as Frames are
-*        added/removed.
-*     11-SEP-1996 (RFWS):
-*        Added Gap.
-*     25-SEP-1996 (RFWS):
-*        Added I/O facilities.
-*     30-MAY-1997 (RFWS):
-*        Add special treatment for the ID attribute (which is not
-*        derived from the current Frame).
-*     10-JUN-1997 (RFWS):
-*        Rationalised the astConvert implementation.
-*     11-JUN-1997 (RFWS):
-*        Added the FindFrame implementation.
-*     27-JUN-1997 (RFWS):
-*        Fixed bug which caused certain Mapping attributes to be
-*        handled by the current Frame instead of by the member
-*        functions defined by this class.
-*     3-JUL-1997 (RFWS):
-*        Fixed bug: failing to extend the invert array in
-*        astRemapFrame.
-*     10-JUL-1997 (RFWS):
-*        Over-ride the astSimplify method.
-*     14-NOV-1997 (RFWS):
-*        Fixed error in loop implementing search over domains in
-*        FindFrame.
-*     20-NOV-1997 (RFWS):
-*        Fixed bug in default Base and Current attribute values when a
-*        FrameSet has been inverted.
-*     20-NOV-1997 (RFWS):
-*        Modified astConvert to use the current Frame of the "to"
-*        FrameSet as the destination coordinate system (instead of the
-*        base Frame) and to modify its Base attribute instead of its
-*        Current attribute.
-*     22-DEC-1997 (RFWS):
-*        Further modified astConvert to convert from the Current Frame
-*        of the "from" FrameSet and to modify its Base
-*        attribute. Frame search order also reversed if the Invert
-*        attribute is non-zero for either FrameSet.
-*     19-JAN-1998 (RFWS):
-*        Installed the TidyNodes function.
-*     20-JAN-1998 (RFWS):
-*        Implemented preservation of FrameSet integrity when attribute
-*        values associated with the current Frame are modified.
-*     24-FEB-1998 (RFWS):
-*        Added the ForceCopy function to allow integrity to be preserved
-*        when there are multiple references to the same Frame.
-*     25-FEB-1998 (RFWS):
-*        Over-ride the astUnformat method.
-*     24-MAR-1998 (RFWS):
-*        Fixed unterminated comment causing problems in CombineMaps.
-*     6-APR-1998 (RFWS):
-*        Fixed another unterminated comment in CombineMaps.
-*     27-MAY-1998 (RFWS):
-*        Fixed bug: failure to record new invert flag value after
-*        simplifying a CmpMap in TidyNodes.
-*     17-DEC-2002 (DSB):
-*        Override accessors for Frame attributes Top, Bottom, Epoch,
-*        System, AlignSystem and ActiveUnit.
-*     8-JAN-2003 (DSB):
-*        Changed private InitVtab method to protected astInitFrameSetVtab
-*        method.
-*     24-JAN-2004 (DSB):
-*        o  Override the astFields method.
-*        o  Add argument "fmt" to Abbrev.
-*     23-MAR-2004 (DSB):
-*        Modified astGetMapping and Span to include the clipping effect of
-*        any Regions in the path between the two supplied Frames.
-*     24-AUG-2004 (DSB):
-*        - Override various methods inherited from Frame (astAngle,
-*	astAxAngle, astAxDistance, astAxOffset, astCheckPerm, astOffset2,
-*	astResolve, astSystemCode, astSystemString, astValidateSystem,
-*	astValidateAxisSelection). These should have been overridden a
-*       long time ago!
-*     8-SEP-2004 (DSB):
-*       Override astResolvePoints.
-*     12-MAY-2005 (DSB):
-*        Override astNormBox method.
-*     12-AUG-2005 (DSB):
-*        Override ObsLat and ObsLon accessor methods.
-*     14-FEB-2006 (DSB):
-*        Override astGetObjSize.
-*     15-MAY-2006 (DSB):
-*        Override astEqual.
-*     30-JUN-2006 (DSB):
-*        Allow astAbbrev to have a null "str1" value.
-*     22-JUN-2007 (DSB):
-*        Modify VSet to avoid using the args va_list twice since the
-*        first use (by the parent VSet function) invalidates the va_list
-*        causing a segvio to be generated by the second use (when
-*        formatting an error message).
-*     11-JAN-2008 (DSB):
-*        Override the astRate method.
-*     17-NOV-2008 (DSB):
-*        Correct parent class in invocation of astMAKE_ISA.
-*     14-JAN-2009 (DSB):
-*        Override the astIntersect method.
-*     18-JUN-2009 (DSB):
-*        Override ObsAlt accessor methods.
-*     30-OCT-2009 (DSB):
-*        Make the Ident attribute relate to the FrameSet, not the current
-*        Frame.
-*     22-MAR-2011 (DSB):
-*        Override astFrameGrid method.
-*     29-APR-2011 (DSB):
-*        Prevent astFindFrame from matching a subclass template against a
-*        superclass target.
-*     2-SEP-2011 (DSB):
-*        Fix FrameSet implememntation of astEqual (mapping comparison
-*        tests were logically inverted).
-*     3-OCT-2012 (DSB):
-*        Fix bug in AppendAxes that could cause internal Mappings to
-*        be inverted unintentionally when astAddFrame is called with
-*        iframe=AST__ALLFRAMES.
-*     29-APR-2013 (DSB):
-*        Added attributes AllVariants and Variant. Also added methods
-*        astAddVariant and astMirrorVariants.
-*     25-SEP-2014 (DSB):
-*        Allow Base and Current attributes to be specified by giving a
-*        Domain name.
-*     17-APR-2015 (DSB):
-*        Added Centre.
-*     28-APR-2015 (DSB):
-*        astAdFrame now takes deep copies of the supplied mapping and
-*        frame, rather than just cloning their pointers. So the modified
-*        FrameSet is now independent of the supplied Mapping and Frame
-*        objects.
-*     26-OCT-2016 (DSB):
-*        Override the AxNorm method.
-*     07-APR-2017 (GSB):
-*        Override Dtai and Dut1 accessor methods.
-*     07-NOV-2017 (GSB):
-*        In AddFrame, check to see if a FrameSet is supplied in place of
-*        a Mapping and if so, use the FrameSet's base -> current Mapping
-*        instead.
-*     11-DEC-2017 (DSB):
-*        Added method astGetNode.
-*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 FrameSet
-
-#define GETALLVARIANTS_BUFF_LEN 200
-
-/*
-*  Name:
-*     MAKE_CLEAR
-
-*  Purpose:
-*     Define a function to clear an attribute value for a FrameSet.
-
-*  Type:
-*     Private macro.
-
-*  Synopsis:
-*     #include "frameset.h"
-*     MAKE_CLEAR(attribute)
-
-*  Class Membership:
-*     Defined by the FrameSet class.
-
-*  Description:
-*     This macro expands to an implementation of a private member function
-*     of the form:
-*
-*        static void Clear<Attribute>( AstFrame *this )
-*
-*     that clears the value of a specified attribute for the current Frame
-*     of a FrameSet (this). This function is intended to over-ride the
-*     astClear<Attribute> method inherited from the Frame class.
-
-*  Parameters:
-*     attribute
-*        Name of the attribute, as it appears in the function name.
-*/
-
-/* Define the macro. */
-#define MAKE_CLEAR(attribute) \
-static void Clear##attribute( AstFrame *this_frame, int *status ) { \
-\
-/* Local Variables: */ \
-   AstFrame *fr;                 /* Pointer to current Frame */ \
-   AstFrameSet *this;            /* Pointer to the FrameSet structure */ \
-\
-/* Check the global error status. */ \
-   if ( !astOK ) return; \
-\
-/* Obtain a pointer to the FrameSet structure. */ \
-   this = (AstFrameSet *) this_frame; \
-\
-/* Obtain a pointer to the current Frame and invoke its astClear<Attribute> \
-   method. Annul the Frame pointer afterwards. */ \
-   fr = astGetFrame( this, AST__CURRENT ); \
-   astClear##attribute( fr ); \
-   fr = astAnnul( fr ); \
-}
-
-/*
-*  Name:
-*     MAKE_CLEAR_AXIS
-
-*  Purpose:
-*     Define a function to clear an attribute value for a FrameSet axis.
-
-*  Type:
-*     Private macro.
-
-*  Synopsis:
-*     #include "frameset.h"
-*     MAKE_CLEAR_AXIS(attribute)
-
-*  Class Membership:
-*     Defined by the FrameSet class.
-
-*  Description:
-*     This macro expands to an implementation of a private member function
-*     of the form:
-*
-*        static void Clear<Attribute>( AstFrame *this, int axis )
-*
-*     that clears the value of a specified attribute for an axis of
-*     the current Frame of a FrameSet (this). This function is
-*     intended to over-ride the astClear<Attribute> method inherited
-*     from the Frame class.
-
-*  Parameters:
-*     attribute
-*        Name of the attribute, as it appears in the function name.
-*/
-
-/* Define the macro. */
-#define MAKE_CLEAR_AXIS(attribute) \
-static void Clear##attribute( AstFrame *this_frame, int axis, int *status ) { \
-\
-/* Local Variables: */ \
-   AstFrame *fr;                 /* Pointer to current Frame */ \
-   AstFrameSet *this;            /* Pointer to the FrameSet structure */ \
-\
-/* Check the global error status. */ \
-   if ( !astOK ) return; \
-\
-/* Obtain a pointer to the FrameSet structure. */ \
-   this = (AstFrameSet *) this_frame; \
-\
-/* Validate the axis index supplied. */ \
-   (void) astValidateAxis( this, axis, 1, "astClear" #attribute ); \
-\
-/* Obtain a pointer to the FrameSet's current Frame and invoke its \
-   astClear<Attribute> method. Annul the Frame pointer afterwards. */ \
-   fr = astGetFrame( this, AST__CURRENT ); \
-   astClear##attribute( fr, axis ); \
-   fr = astAnnul( fr ); \
-}
-
-/*
-*  Name:
-*     MAKE_GET
-
-*  Purpose:
-*     Define a function to get an attribute value for a FrameSet.
-
-*  Type:
-*     Private macro.
-
-*  Synopsis:
-*     #include "frameset.h"
-*     MAKE_GET(attribute,type)
-
-*  Class Membership:
-*     Defined by the FrameSet class.
-
-*  Description:
-*     This macro expands to an implementation of a private member function
-*     of the form:
-*
-*        static <type> Get<Attribute>( AstFrame *this )
-*
-*     that gets the value of a specified attribute for the current Frame
-*     of a FrameSet (this). This function is intended to over-ride the
-*     astGet<Attribute> method inherited from the Frame class.
-
-*  Parameters:
-*     attribute
-*        Name of the attribute, as it appears in the function name.
-*     type
-*        The C type of the attribute.
-*/
-
-/* Define the macro. */
-#define MAKE_GET(attribute,type) \
-static type Get##attribute( AstFrame *this_frame, int *status ) { \
-\
-/* Local Variables: */ \
-   AstFrame *fr;                 /* Pointer to current Frame */ \
-   AstFrameSet *this;            /* Pointer to the FrameSet structure */ \
-   type result;                  /* Value to return */ \
-\
-/* Check the global error status. */ \
-   if ( !astOK ) return (type) 0; \
-\
-/* Obtain a pointer to the FrameSet structure. */ \
-   this = (AstFrameSet *) this_frame; \
-\
-/* Obtain a pointer to the current Frame and invoke its \
-   astGet<Attribute> method.  Annul the Frame pointer afterwards. */ \
-   fr = astGetFrame( this, AST__CURRENT ); \
-   result = astGet##attribute( fr ); \
-   fr = astAnnul( fr ); \
-\
-/* If an error occurred, clear the result value. */ \
-   if ( !astOK ) result = (type) 0; \
-\
-/* Return the result. */ \
-   return result; \
-}
-
-/*
-*  Name:
-*     MAKE_GET_AXIS
-
-*  Purpose:
-*     Define a function to get an attribute value for a FrameSet axis.
-
-*  Type:
-*     Private macro.
-
-*  Synopsis:
-*     #include "frameset.h"
-*     MAKE_GET_AXIS(attribute,type)
-
-*  Class Membership:
-*     Defined by the FrameSet class.
-
-*  Description:
-*     This macro expands to an implementation of a private member function
-*     of the form:
-*
-*        static <type> Get<Attribute>( AstFrame *this, int axis )
-*
-*     that gets the value of a specified attribute for an axis of the
-*     current Frame of a FrameSet (this). This function is intended to
-*     over-ride the astGet<Attribute> method inherited from the Frame
-*     class.
-
-*  Parameters:
-*     attribute
-*        Name of the attribute, as it appears in the function name.
-*     type
-*        The C type of the attribute.
-*/
-
-/* Define the macro. */
-#define MAKE_GET_AXIS(attribute,type) \
-static type Get##attribute( AstFrame *this_frame, int axis, int *status ) { \
-\
-/* Local Variables: */ \
-   AstFrame *fr;                 /* Pointer to current Frame */ \
-   AstFrameSet *this;            /* Pointer to the FrameSet structure */ \
-   type result;                  /* Value to return */ \
-\
-/* Check the global error status. */ \
-   if ( !astOK ) return (type) 0; \
-\
-/* Obtain a pointer to the FrameSet structure. */ \
-   this = (AstFrameSet *) this_frame; \
-\
-/* Validate the axis index supplied. */ \
-   (void) astValidateAxis( this, axis, 1, "astGet" #attribute ); \
-\
-/* Obtain a pointer to the FrameSet's current Frame and invoke its \
-   astGet<Attribute> method.  Annul the Frame pointer afterwards. */ \
-   fr = astGetFrame( this, AST__CURRENT ); \
-   result = astGet##attribute( fr, axis ); \
-   fr = astAnnul( fr ); \
-\
-/* If an error occurred, clear the result value. */ \
-   if ( !astOK ) result = (type) 0; \
-\
-/* Return the result. */ \
-   return result; \
-}
-
-/*
-*  Name:
-*     MAKE_SET
-
-*  Purpose:
-*     Define a function to set an attribute value for a FrameSet.
-
-*  Type:
-*     Private macro.
-
-*  Synopsis:
-*     #include "frameset.h"
-*     MAKE_SET(attribute,type)
-
-*  Class Membership:
-*     Defined by the FrameSet class.
-
-*  Description:
-*     This macro expands to an implementation of a private member function
-*     of the form:
-*
-*        static void Set<Attribute>( AstFrame *this, <type> value )
-*
-*     that sets the value of a specified attribute for the current Frame
-*     of a FrameSet (this). This function is intended to over-ride the
-*     astSet<Attribute> method inherited from the Frame class.
-
-*  Parameters:
-*     attribute
-*        Name of the attribute, as it appears in the function name.
-*     type
-*        The C type of the attribute.
-*/
-
-/* Define the macro. */
-#define MAKE_SET(attribute,type) \
-static void Set##attribute( AstFrame *this_frame, type value, int *status ) { \
-\
-/* Local Variables: */ \
-   AstFrame *fr;                 /* Pointer to current Frame */ \
-   AstFrameSet *this;            /* Pointer to the FrameSet structure */ \
-\
-/* Check the global error status. */ \
-   if ( !astOK ) return; \
-\
-/* Obtain a pointer to the FrameSet structure. */ \
-   this = (AstFrameSet *) this_frame; \
-\
-/* Obtain a pointer to the FrameSet's current Frame and invoke its \
-   astSet<Attribute> method.  Annul the Frame pointer afterwards. */ \
-   fr = astGetFrame( this, AST__CURRENT ); \
-   astSet##attribute( fr, value ); \
-   fr = astAnnul( fr ); \
-}
-
-/*
-*  Name:
-*     MAKE_SET_AXIS
-
-*  Purpose:
-*     Define a function to set an attribute value for a FrameSet axis.
-
-*  Type:
-*     Private macro.
-
-*  Synopsis:
-*     #include "frameset.h"
-*     MAKE_SET_AXIS(attribute,type)
-
-*  Class Membership:
-*     Defined by the FrameSet class.
-
-*  Description:
-*     This macro expands to an implementation of a private member function
-*     of the form:
-*
-*        static void Set<Attribute>( AstFrame *this, int axis, <type> value )
-*
-*     that sets the value of a specified attribute for an axis of the
-*     current Frame of a FrameSet (this). This function is intended to
-*     over-ride the astSet<Attribute> method inherited from the Frame
-*     class.
-
-*  Parameters:
-*     attribute
-*        Name of the attribute, as it appears in the function name.
-*     type
-*        The C type of the attribute.
-*/
-
-/* Define the macro. */
-#define MAKE_SET_AXIS(attribute,type) \
-static void Set##attribute( AstFrame *this_frame, int axis, type value, int *status ) { \
-\
-/* Local Variables: */ \
-   AstFrame *fr;                 /* Pointer to current Frame */ \
-   AstFrameSet *this;            /* Pointer to the FrameSet structure */ \
-\
-/* Check the global error status. */ \
-   if ( !astOK ) return; \
-\
-/* Obtain a pointer to the FrameSet structure. */ \
-   this = (AstFrameSet *) this_frame; \
-\
-/* Validate the axis index supplied. */ \
-   (void) astValidateAxis( this, axis, 1, "astSet" #attribute ); \
-\
-/* Obtain a pointer to the FrameSet's current Frame and invoke its \
-   astSet<Attribute> method.  Annul the Frame pointer afterwards. */ \
-   fr = astGetFrame( this, AST__CURRENT ); \
-   astSet##attribute( fr, axis, value ); \
-   fr = astAnnul( fr ); \
-}
-
-/*
-*  Name:
-*     MAKE_TEST
-
-*  Purpose:
-*     Define a function to test if an attribute value is set for a FrameSet.
-
-*  Type:
-*     Private macro.
-
-*  Synopsis:
-*     #include "frameset.h"
-*     MAKE_TEST(attribute)
-
-*  Class Membership:
-*     Defined by the FrameSet class.
-
-*  Description:
-*     This macro expands to an implementation of a private member function
-*     of the form:
-*
-*        static int Test<Attribute>( AstFrame *this )
-*
-*     that returns a boolean result (0 or 1) to indicate if the value
-*     of a specified attribute for the current Frame of a FrameSet
-*     (this) is set. This function is intended to over-ride the
-*     astTest<Attribute> method inherited from the Frame class.
-
-*  Parameters:
-*     attribute
-*        Name of the attribute, as it appears in the function name.
-*/
-
-/* Define the macro. */
-#define MAKE_TEST(attribute) \
-static int Test##attribute( AstFrame *this_frame, int *status ) { \
-\
-/* Local Variables: */ \
-   AstFrame *fr;                 /* Pointer to current Frame */ \
-   AstFrameSet *this;            /* Pointer to FrameSet structure */ \
-   int result;                   /* Result to return */ \
-\
-/* Check the global error status. */ \
-   if ( !astOK ) return 0; \
-\
-/* Obtain a pointer to the FrameSet structure. */ \
-   this = (AstFrameSet *) this_frame; \
-\
-/* Obtain a pointer to the FrameSet's current Frame and invoke its \
-   astTest<Attribute> method.  Annul the Frame pointer afterwards. */ \
-   fr = astGetFrame( this, AST__CURRENT ); \
-   result = astTest##attribute( fr ); \
-   fr = astAnnul( fr ); \
-\
-/* If an error occurred, clear the result value. */ \
-   if ( !astOK ) result = 0; \
-\
-/* Return the result. */ \
-   return result; \
-}
-
-/*
-*  Name:
-*     MAKE_TEST_AXIS
-
-*  Purpose:
-*     Define a function to test if an attribute value is set for a FrameSet
-*     axis.
-
-*  Type:
-*     Private macro.
-
-*  Synopsis:
-*     #include "frameset.h"
-*     MAKE_TEST_AXIS(attribute)
-
-*  Class Membership:
-*     Defined by the FrameSet class.
-
-*  Description:
-*     This macro expands to an implementation of a private member function
-*     of the form:
-*
-*        static int Test<Attribute>( AstFrame *this, int axis )
-*
-*     that returns a boolean result (0 or 1) to indicate if the value
-*     of a specified attribute for an axis of the current Frame of a
-*     FrameSet (this) is set. This function is intended to over-ride
-*     the astTest<Attribute> method inherited from the Frame class.
-
-*  Parameters:
-*     attribute
-*        Name of the attribute, as it appears in the function name.
-*/
-
-/* Define the macro. */
-#define MAKE_TEST_AXIS(attribute) \
-static int Test##attribute( AstFrame *this_frame, int axis, int *status ) { \
-\
-/* Local Variables: */ \
-   AstFrame *fr;                 /* Pointer to current Frame */ \
-   AstFrameSet *this;            /* Pointer to the FrameSet structure */ \
-   int result;                   /* Value to return */ \
-\
-/* Check the global error status. */ \
-   if ( !astOK ) return 0; \
-\
-/* Obtain a pointer to the FrameSet structure. */ \
-   this = (AstFrameSet *) this_frame; \
-\
-/* Validate the axis index supplied. */ \
-   (void) astValidateAxis( this, axis, 1, "astTest" #attribute ); \
-\
-/* Obtain a pointer to the FrameSet's current Frame and invoke its \
-   astTest<Attribute> method.  Annul the Frame pointer afterwards. */ \
-   fr = astGetFrame( this, AST__CURRENT ); \
-   result = astTest##attribute( fr, axis ); \
-   fr = astAnnul( fr ); \
-\
-/* If an error occurred, clear the result value. */ \
-   if ( !astOK ) result = 0; \
-\
-/* Return the result. */ \
-   return result; \
-}
-
-/* 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 "object.h"              /* Base Object class */
-#include "mapping.h"             /* Coordinate Mappings */
-#include "unitmap.h"             /* Unit Mappings */
-#include "permmap.h"             /* Coordinate permutation Mappings */
-#include "cmpmap.h"              /* Compound Mappings */
-#include "frame.h"               /* Parent Frame class */
-#include "frameset.h"            /* Interface definition for this class */
-#include "cmpframe.h"            /* Compound coordinate frames */
-
-/* Error code definitions. */
-/* ----------------------- */
-#include "ast_err.h"             /* AST error codes */
-
-/* C header files. */
-/* --------------- */
-#include <ctype.h>
-#include <limits.h>
-#include <stdarg.h>
-#include <stddef.h>
-#include <stdio.h>
-#include <string.h>
-
-/* Module Variables. */
-/* ================= */
-
-/* Address of this static variable is used as a unique identifier for
-   member of this class. */
-static int class_check;
-
-/* Pointers to parent class methods which are extended by this class. */
-static int (* parent_getobjsize)( AstObject *, int * );
-static void (* parent_clear)( AstObject *, const char *, int * );
-static int (* parent_getusedefs)( AstObject *, int * );
-static void (* parent_vset)( AstObject *, const char *, char **, va_list, int * );
-
-#if defined(THREAD_SAFE)
-static int (* parent_managelock)( AstObject *, int, int, AstObject **, int * );
-#endif
-
-/* Define macros for accessing each item of thread specific global data. */
-#ifdef THREAD_SAFE
-
-/* Define how to initialise thread-specific globals. */
-#define GLOBAL_inits \
-   globals->Class_Init = 0; \
-   globals->GetAttrib_Buff[ 0 ] = 0; \
-   globals->Integrity_Frame = NULL; \
-   globals->Integrity_Method = ""; \
-   globals->Integrity_Lost = 0; \
-   globals->GetAllVariants_Buff[ 0 ] = 0; \
-
-/* Create the function that initialises global data for this module. */
-astMAKE_INITGLOBALS(FrameSet)
-
-/* Define macros for accessing each item of thread specific global data. */
-#define class_init astGLOBAL(FrameSet,Class_Init)
-#define class_vtab astGLOBAL(FrameSet,Class_Vtab)
-#define getattrib_buff astGLOBAL(FrameSet,GetAttrib_Buff)
-#define integrity_frame astGLOBAL(FrameSet,Integrity_Frame)
-#define integrity_method astGLOBAL(FrameSet,Integrity_Method)
-#define integrity_lost astGLOBAL(FrameSet,Integrity_Lost)
-#define getallvariants_buff astGLOBAL(FrameSet,GetAllVariants_Buff)
-
-
-
-/* If thread safety is not needed, declare and initialise globals at static
-   variables. */
-#else
-
-/* Buffer returned by GetAttrib. */
-static char getattrib_buff[ AST__FRAMESET_GETATTRIB_BUFF_LEN + 1 ];
-
-/* Variables associated with preserving FrameSet integrity. */
-static AstFrame *integrity_frame = NULL; /* Pointer to copy of current Frame */
-static const char *integrity_method = ""; /* Name of method being used */
-static int integrity_lost = 0;   /* Current Frame modified? */
-
-
-/* Define the class virtual function table and its initialisation flag
-   as static variables. */
-static AstFrameSetVtab class_vtab;   /* Virtual function table */
-static int class_init = 0;       /* Virtual function table initialised? */
-
-/* String buffers. */
-static char getallvariants_buff[ AST__FRAMESET_GETALLVARIANTS_BUFF_LEN + 1 ];
-
-#endif
-
-
-/* Prototypes for Private Member Functions. */
-/* ======================================== */
-static AstAxis *GetAxis( AstFrame *, int, int * );
-static AstFrame *GetFrame( AstFrameSet *, int, int * );
-static AstFrame *PickAxes( AstFrame *, int, const int[], AstMapping **, int * );
-static AstFrameSet *Convert( AstFrame *, AstFrame *, const char *, int * );
-static AstFrameSet *ConvertX( AstFrame *, AstFrame *, const char *, int * );
-static AstFrameSet *FindFrame( AstFrame *, AstFrame *, const char *, int * );
-static AstLineDef *LineDef( AstFrame *, const double[2], const double[2], int * );
-static AstMapping *CombineMaps( AstMapping *, int, AstMapping *, int, int, int * );
-static AstMapping *GetMapping( AstFrameSet *, int, int, int * );
-static AstMapping *RemoveRegions( AstMapping *, int * );
-static AstMapping *Simplify( AstMapping *, int * );
-static AstObject *Cast( AstObject *, AstObject *, int * );
-static AstPointSet *FrameGrid( AstFrame *, int, const double *, const double *, int * );
-static AstPointSet *ResolvePoints( AstFrame *, const double [], const double [], AstPointSet *, AstPointSet *, int * );
-static AstPointSet *Transform( AstMapping *, AstPointSet *, int, AstPointSet *, int * );
-static AstSystemType SystemCode( AstFrame *, const char *, int * );
-static AstSystemType ValidateSystem( AstFrame *, AstSystemType, const char *, int * );
-static const char *Abbrev( AstFrame *, int, const char *, const char *, 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 *GetSymbol( AstFrame *, int, int * );
-static const char *GetTitle( AstFrame *, int * );
-static const char *GetUnit( AstFrame *, int, int * );
-static const char *GetAllVariants( AstFrameSet *, int * );
-static const char *SystemString( AstFrame *, AstSystemType, int * );
-static const int *GetPerm( AstFrame *, int * );
-static double Angle( AstFrame *, const double[], const double[], const double[], int * );
-static double AxAngle( AstFrame *, const double[], const double[], int, int * );
-static double AxDistance( AstFrame *, int, double, double, int * );
-static double AxOffset( AstFrame *, int, double, double, int * );
-static double Distance( AstFrame *, const double[], const double[], int * );
-static double Centre( AstFrame *, int, double, double, int * );
-static double Gap( AstFrame *, int, double, int *, int * );
-static double Offset2( AstFrame *, const double[2], double, double, double[2], int * );
-static double Rate( AstMapping *, double *, int, int, int * );
-static int *MapSplit( AstMapping *, int, const int *, AstMapping **, int * );
-static int Equal( AstObject *, AstObject *, int * );
-static int Fields( AstFrame *, int, const char *, const char *, int, char **, int *, double *, int * );
-static int ForceCopy( AstFrameSet *, int, int * );
-static int GetActiveUnit( AstFrame *, int * );
-static int GetBase( AstFrameSet *, int * );
-static int GetCurrent( AstFrameSet *, int * );
-static int GetDigits( AstFrame *, int * );
-static int GetDirection( AstFrame *, int, int * );
-static int GetIsLinear( AstMapping *, int * );
-static int GetMatchEnd( AstFrame *, int * );
-static int GetMaxAxes( AstFrame *, int * );
-static int GetMinAxes( AstFrame *, int * );
-static int GetNaxes( AstFrame *, int * );
-static int GetNframe( AstFrameSet *, int * );
-static int GetNin( AstMapping *, int * );
-static int GetNode( AstFrameSet *, int, int *, int *, AstMapping **, int *, int * );
-static int GetNout( AstMapping *, int * );
-static int GetObjSize( AstObject *, int * );
-static int GetPermute( AstFrame *, int * );
-static int GetPreserveAxes( AstFrame *, int * );
-static int GetTranForward( AstMapping *, int * );
-static int GetTranInverse( AstMapping *, int * );
-static int GetVarFrm( AstFrameSet *, int, int * );
-static int IsUnitFrame( AstFrame *, int * );
-static int LineContains( AstFrame *, AstLineDef *, int, double *, int * );
-static int LineCrossing( AstFrame *, AstLineDef *, AstLineDef *, double **, int * );
-static int Match( AstFrame *, AstFrame *, int, int **, int **, AstMapping **, AstFrame **, int * );
-static int Span( AstFrameSet *, AstFrame **, int, int, int, AstMapping **, int *, int * );
-static int SubFrame( AstFrame *, AstFrame *, int, const int *, const int *, AstMapping **, AstFrame **, int * );
-static int TestActiveUnit( AstFrame *, int * );
-static int TestAttrib( AstObject *, const char *, int * );
-static int TestBase( AstFrameSet *, int * );
-static int TestCurrent( AstFrameSet *, int * );
-static int TestDigits( AstFrame *, int * );
-static int TestDirection( AstFrame *, int, int * );
-static int TestDomain( AstFrame *, int * );
-static int TestFormat( AstFrame *, int, int * );
-static int TestLabel( AstFrame *, int, int * );
-static int TestMatchEnd( AstFrame *, int * );
-static int TestMaxAxes( AstFrame *, int * );
-static int TestMinAxes( AstFrame *, int * );
-static int TestPermute( AstFrame *, int * );
-static int TestPreserveAxes( AstFrame *, int * );
-static int TestSymbol( AstFrame *, int, int * );
-static int TestTitle( AstFrame *, int * );
-static int TestUnit( AstFrame *, int, int * );
-static int Unformat( AstFrame *, int, const char *, double *, int * );
-static int ValidateAxis( AstFrame *, int, int, const char *, int * );
-static int ValidateFrameIndex( AstFrameSet *, int, const char *, int * );
-static void AddFrame( AstFrameSet *, int, AstMapping *, AstFrame *, int * );
-static void AppendAxes( AstFrameSet *, AstFrame *, int * );
-static void AxNorm( AstFrame *, int, int, int, double *, int * );
-static void CheckPerm( AstFrame *, const int *, const char *, int * );
-static void Clear( AstObject *, const char *, int * );
-static void ClearAttrib( AstObject *, const char *, int * );
-static void ClearBase( AstFrameSet *, int * );
-static void ClearCurrent( AstFrameSet *, int * );
-static void ClearDigits( AstFrame *, int * );
-static void ClearDirection( AstFrame *, int, int * );
-static void ClearDomain( AstFrame *, int * );
-static void ClearFormat( AstFrame *, int, int * );
-static void ClearLabel( AstFrame *, int, int * );
-static void ClearMatchEnd( AstFrame *, int * );
-static void ClearMaxAxes( AstFrame *, int * );
-static void ClearMinAxes( AstFrame *, int * );
-static void ClearPermute( AstFrame *, int * );
-static void ClearPreserveAxes( AstFrame *, int * );
-static void ClearSymbol( AstFrame *, int, int * );
-static void ClearTitle( AstFrame *, int * );
-static void ClearUnit( AstFrame *, int, 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 MatchAxes( AstFrame *, AstFrame *, int *, 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 PermAxes( AstFrame *, const int[], int * );
-static void PrimaryFrame( AstFrame *, int, AstFrame **, int *, int * );
-static void RecordIntegrity( AstFrameSet *, int * );
-static void AddVariant( AstFrameSet *, AstMapping *, const char *, int * );
-static void MirrorVariants( AstFrameSet *, int, int * );
-static void RemapFrame( AstFrameSet *, int, AstMapping *, int * );
-static void RemoveFrame( AstFrameSet *, int, int * );
-static void RemoveMirrors( AstFrameSet *, int, int * );
-static void ReportPoints( AstMapping *, int, AstPointSet *, AstPointSet *, int * );
-static void Resolve( AstFrame *, const double [], const double [], const double [], double [], double *, double *, int * );
-static void RestoreIntegrity( AstFrameSet *, int * );
-static void SetActiveUnit( AstFrame *, int, int * );
-static void SetAttrib( AstObject *, const char *, int * );
-static void SetAxis( AstFrame *, int, AstAxis *, int * );
-static void SetBase( AstFrameSet *, int, int * );
-static void SetCurrent( AstFrameSet *, int, int * );
-static void SetDigits( AstFrame *, int, int * );
-static void SetDirection( AstFrame *, int, int, int * );
-static void SetDomain( AstFrame *, const char *, int * );
-static void SetFormat( AstFrame *, int, const char *, int * );
-static void SetLabel( AstFrame *, int, const char *, int * );
-static void SetMatchEnd( AstFrame *, int, int * );
-static void SetMaxAxes( AstFrame *, int, int * );
-static void SetMinAxes( AstFrame *, int, int * );
-static void SetPermute( AstFrame *, int, int * );
-static void SetPreserveAxes( AstFrame *, int, int * );
-static void SetSymbol( AstFrame *, int, const char *, int * );
-static void SetTitle( AstFrame *, const char *, int * );
-static void SetUnit( AstFrame *, int, const char *, int * );
-static void TidyNodes( AstFrameSet *, int * );
-static void VSet( AstObject *, const char *, char **, va_list, int * );
-static void ValidateAxisSelection( AstFrame *, int, const int *, const char *, int * );
-
-static double GetBottom( AstFrame *, int, int * );
-static int TestBottom( AstFrame *, int, int * );
-static void ClearBottom( AstFrame *, int, int * );
-static void SetBottom( AstFrame *, int, double, int * );
-
-static double GetTop( AstFrame *, int, int * );
-static int TestTop( AstFrame *, int, int * );
-static void ClearTop( AstFrame *, int, int * );
-static void SetTop( AstFrame *, int, double, int * );
-
-static double GetEpoch( AstFrame *, int * );
-static int TestEpoch( AstFrame *, int * );
-static void ClearEpoch( AstFrame *, int * );
-static void SetEpoch( AstFrame *, double, int * );
-
-static double GetDtai( AstFrame *, int * );
-static int TestDtai( AstFrame *, int * );
-static void ClearDtai( AstFrame *, int * );
-static void SetDtai( AstFrame *, double, int * );
-
-static double GetDut1( AstFrame *, int * );
-static int TestDut1( AstFrame *, int * );
-static void ClearDut1( AstFrame *, int * );
-static void SetDut1( AstFrame *, double, int * );
-
-static double GetObsAlt( AstFrame *, int * );
-static int TestObsAlt( AstFrame *, int * );
-static void ClearObsAlt( AstFrame *, int * );
-static void SetObsAlt( AstFrame *, double, int * );
-
-static double GetObsLat( AstFrame *, int * );
-static int TestObsLat( AstFrame *, int * );
-static void ClearObsLat( AstFrame *, int * );
-static void SetObsLat( AstFrame *, double, int * );
-
-static double GetObsLon( AstFrame *, int * );
-static int TestObsLon( AstFrame *, int * );
-static void ClearObsLon( AstFrame *, int * );
-static void SetObsLon( AstFrame *, double, int * );
-
-static int GetUseDefs( AstObject *, int * );
-
-static AstSystemType GetSystem( AstFrame *, int * );
-static int TestSystem( AstFrame *, int * );
-static void ClearSystem( AstFrame *, int * );
-static void SetSystem( AstFrame *, AstSystemType, int * );
-
-static AstSystemType GetAlignSystem( AstFrame *, int * );
-static int TestAlignSystem( AstFrame *, int * );
-static void ClearAlignSystem( AstFrame *, int * );
-static void SetAlignSystem( AstFrame *, AstSystemType, int * );
-
-static const char *GetVariant( AstFrameSet *, int * );
-static int TestVariant( AstFrameSet *, int * );
-static void ClearVariant( AstFrameSet *, int * );
-static void SetVariant( AstFrameSet *, const char *, int * );
-
-#if defined(THREAD_SAFE)
-static int ManageLock( AstObject *, int, int, AstObject **, int * );
-#endif
-
-/* Member functions. */
-/* ================= */
-static const char *Abbrev( AstFrame *this_frame, int axis, const char *fmt,
-                           const char *str1, const char *str2, int *status ) {
-/*
-*  Name:
-*     Abbrev
-
-*  Purpose:
-*     Abbreviate a formatted FrameSet axis value by skipping leading fields.
-
-*  Type:
-*     Private function.
-
-*  Synopsis:
-*     #include "frameset.h"
-*     const char *Abbrev( AstFrame *this, int axis, const char *fmt,
-*                         const char *str1, const char *str2, int *status )
-
-*  Class Membership:
-*     FrameSet member function (over-rides the protected astAbbrev
-*     method inherited from the Frame class).
-
-*  Description:
-*     This function compares two FrameSet axis values that have been
-*     formatted (using astFormat) and determines if they have any
-*     redundant leading fields (i.e. leading fields in common which
-*     can be suppressed when tabulating the values or plotting them on
-*     the axis of a graph).
-
-*  Parameters:
-*     this
-*        Pointer to the FrameSet.
-*     axis
-*        The number of the FrameSet axis for which the values have
-*        been formatted (axis numbering starts at zero for the first
-*        axis).
-*     fmt
-*        Pointer to a constant null-terminated string containing the
-*        format specification used to format the two values.
-*     str1
-*        Pointer to a constant null-terminated string containing the
-*        first formatted value. If this is null, the returned pointer
-*        points to the start of the final field in str2.
-*     str2
-*        Pointer to a constant null-terminated string containing the
-*        second formatted value.
-*     status
-*        Pointer to the inherited status variable.
-
-*  Returned Value:
-*     A pointer into the "str2" string which locates the first
-*     character in the first field that differs between the two
-*     formatted values.
-*
-*     If the two values have no leading fields in common, the returned
-*     value will point at the start of string "str2". If the two
-*     values are equal, it will point at the terminating null at the
-*     end of this string.
-
-*  Notes:
-*     - This function assumes that the format specification used was
-*     the same when both values were formatted and that they both
-*     apply to the same FrameSet axis.
-*     - A pointer to the start of "str2" will be returned if this
-*     function is invoked with the global error status set, or if it
-*     should fail for any reason.
-*/
-
-/* Local Variables: */
-   AstFrame *fr;                 /* Pointer to current Frame */
-   AstFrameSet *this;            /* Pointer to the FrameSet structure */
-   const char *result;           /* Pointer value to return */
-
-/* Check the global error status. */
-   if ( !astOK ) return str2;
-
-/* Obtain a pointer to the FrameSet structure. */
-   this = (AstFrameSet *) this_frame;
-
-/* Validate the axis index. */
-   (void) astValidateAxis( this, axis, 1, "astAbbrev" );
-
-/* Obtain a pointer to the FrameSet's current Frame and invoke this
-   Frame's astAbbrev method to perform the processing. Annul the Frame
-   pointer afterwards. */
-   fr = astGetFrame( this, AST__CURRENT );
-   result = astAbbrev( fr, axis, fmt, str1, str2 );
-   fr = astAnnul( fr );
-
-/* If an error occurred, clear the result. */
-   if ( !astOK ) result = str2;
-
-/* Return the result. */
-   return result;
-}
-
-static void AddFrame( AstFrameSet *this, int iframe, AstMapping *map0,
-                      AstFrame *frame, int *status ) {
-/*
-*++
-*  Name:
-c     astAddFrame
-f     AST_ADDFRAME
-
-*  Purpose:
-*     Add a Frame to a FrameSet to define a new coordinate system.
-
-*  Type:
-*     Public virtual function.
-
-*  Synopsis:
-c     #include "frameset.h"
-c     void astAddFrame( AstFrameSet *this, int iframe, AstMapping *map,
-c                       AstFrame *frame )
-f     CALL AST_ADDFRAME( THIS, IFRAME, MAP, FRAME, STATUS )
-
-*  Class Membership:
-*     FrameSet method.
-
-*  Description:
-c     This function adds a new Frame and an associated Mapping to a
-f     This routine adds a new Frame and an associated Mapping to a
-*     FrameSet so as to define a new coordinate system, derived from
-*     one which already exists within the FrameSet. The new Frame then
-*     becomes the FrameSet's current Frame.
-*
-c     This function
-f     This routine
-*     may also be used to merge two FrameSets, or to append extra axes
-*     to every Frame in a FrameSet.
-
-*  Parameters:
-c     this
-f     THIS = INTEGER (Given)
-*        Pointer to the FrameSet.
-c     iframe
-f     IFRAME = INTEGER (Given)
-*        The index of the Frame within the FrameSet which describes
-*        the coordinate system upon which the new one is to be based.
-*        This value should lie in the range from 1 to the number of
-*        Frames already in the FrameSet (as given by its Nframe
-*        attribute). As a special case, AST__ALLFRAMES may be supplied,
-*        in which case the axes defined by the supplied Frame are appended
-*        to every Frame in the FrameSet (see the Notes section for details).
-c     map
-f     MAP = INTEGER (Given)
-*        Pointer to a Mapping which describes how to convert
-*        coordinates from the old coordinate system (described by the
-c        Frame with index "iframe") into coordinates in the new
-f        Frame with index IFRAME) into coordinates in the new
-*        system. The Mapping's forward transformation should perform
-*        this conversion, and its inverse transformation should
-*        convert in the opposite direction. The supplied Mapping is ignored
-c        if parameter "iframe"is equal to AST__ALLFRAMES.
-f        if parameter IFRAME is equal to AST__ALLFRAMES.
-c     frame
-f     FRAME = INTEGER (Given)
-*        Pointer to a Frame that describes the new coordinate system.
-*        Any class of Frame may be supplied (including Regions and
-*        FrameSets).
-*
-c        This function may also be used to merge two FrameSets by
-c        supplying a pointer to a second FrameSet for this parameter
-f        This routine may also be used to merge two FrameSets by
-f        supplying a pointer to a second FrameSet for this argument
-*        (see the Notes section for details).
-f     STATUS = INTEGER (Given and Returned)
-f        The global status.
-
-*  Notes:
-*     - Deep copies of the supplied
-c     "mapping" and "frame"
-f     MAPPING and FRAME
-*     objects are stored within the modified FrameSet. So any changes made
-*     to the FrameSet after calling this method will have no effect on the
-*     supplied Mapping and Frame objects.
-*     - A value of AST__BASE or AST__CURRENT may be given for the
-c     "iframe" parameter to specify the base Frame or the current
-f     IFRAME argument to specify the base Frame or the current
-*     Frame respectively.
-c     - This function sets the value of the Current attribute for the
-f     - This routine sets the value of the Current attribute for the
-*     FrameSet so that the new Frame subsequently becomes the current
-*     Frame.
-*     - The number of input coordinate values accepted by the supplied
-*     Mapping (its Nin attribute) must match the number of axes in the
-c     Frame identified by the "iframe" parameter. Similarly, the
-f     Frame identified by the IFRAME argument. Similarly, the
-*     number of output coordinate values generated by this Mapping
-*     (its Nout attribute) must match the number of axes in the new
-*     Frame.
-*     - As a special case, if a pointer to a FrameSet is given for the
-c     "frame" parameter, this is treated as a request to merge a pair of
-f     FRAME argument, this is treated as a request to merge a pair of
-*     FrameSets.  This is done by appending all the new Frames (in the
-c     "frame" FrameSet) to the original FrameSet, while preserving
-f     FRAME FrameSet) to the original FrameSet, while preserving
-*     their order and retaining all the inter-relationships
-*     (i.e. Mappings) between them. The two sets of Frames are
-*     inter-related within the merged FrameSet by using the Mapping
-*     supplied. This should convert between the Frame identified by
-c     the "iframe" parameter (in the original FrameSet) and the current
-c     Frame of the "frame" FrameSet. This latter Frame becomes the
-f     the IFRAME argument (in the original FrameSet) and the current
-f     Frame of the FRAME FrameSet. This latter Frame becomes the
-*     current Frame in the merged FrameSet.
-*     - As another special case, if a value of AST__ALLFRAMES is supplied
-*     for parameter
-c     "iframe",
-f     IFRAME,
-*     then the supplied Mapping is ignored, and the axes defined by the
-*     supplied Frame are appended to each Frame in the FrameSet. In detail,
-*     each Frame in the FrameSet is replaced by a CmpFrame containing the
-*     original Frame and the Frame specified by parameter
-c     "frame".
-f     FRAME.
-*     In addition, each Mapping in the FrameSet is replaced by a CmpMap
-*     containing the original Mapping and a UnitMap in parallel. The Nin and
-*     Nout attributes of the UnitMap are set equal to the number of axes
-*     in the supplied Frame. Each new CmpMap is simplified using
-c     astSimplify
-f     AST_SIMPLIFY
-*     before being stored in the FrameSet.
-
-*--
-*/
-
-/* Local Variables: */
-   AstFrame *fr;                 /* Pointer to Frame identified by "iframe" */
-   AstFrameSet *frameset;        /* Pointer to new FrameSet (if given) */
-   AstMapping *inode_map;        /* Temporarily saved Mapping pointer */
-   AstMapping *map;              /* The supplied Mapping */
-   AstMapping *next_map;         /* Temporarily saved Mapping pointer */
-   int current;                  /* Current Frame index in merged FrameSet */
-   int current_node;             /* Node number for current Frame */
-   int ifr;                      /* Loop counter for Frames */
-   int inode;                    /* Loop counter for nodes */
-   int inode_invert;             /* Temporarily saved invert flag value */
-   int inode_link;               /* Temporarily saved link value */
-   int naxes;                    /* Number of Frame axes */
-   int ncoord;                   /* Number of Mapping coordinates per point */
-   int next;                     /* Number of next node in path */
-   int next_invert;              /* Temporarily saved invert flag value */
-   int next_link;                /* Temporarily saved link value */
-   int nframe;                   /* Number of Frames in merged FrameSet */
-   int nnode;                    /* Number of nodes in merged FrameSet */
-   int node_zero;                /* Location of "node zero" after merging */
-
-/* Check the global error status. */
-   if ( !astOK ) return;
-
-/* First handle cases where we are appending axes to the existing
-   Frames in a FrameSet. */
-   if( iframe == AST__ALLFRAMES ) {
-      AppendAxes( this, frame, status );
-      return;
-   }
-
-/* Now handle cases where we are adding a new Frame into the FrameSet.
-   Initialise variables to avoid "used of uninitialised variable"
-   messages from dumb compilers. */
-   inode_map = NULL;
-   next_map = NULL;
-   inode_invert = 0;
-   next = 0;
-   next_invert = 0;
-   next_link = 0;
-
-/* If a FrameSet was supplied instead of a Mapping, use the Mapping from
-   its base Frame to its current Frame. */
-   if( astIsAFrameSet( map0 ) ) {
-      map = astGetMapping( map0, AST__BASE, AST__CURRENT );
-   } else {
-      map = astClone( map0 );
-   }
-
-/* Validate and translate the Frame index supplied. */
-   iframe = astValidateFrameIndex( this, iframe, "astAddFrame" );
-
-/* Obtain a pointer to the Frame from which the new coordinate system
-   will be derived and determine how many axes it has. Annul the Frame
-   pointer afterwards. */
-   if ( astOK ) {
-      fr = astGetFrame( this, iframe );
-      naxes = astGetNaxes( fr );
-      fr = astAnnul( fr );
-
-/* Obtain the number of input coordinate values per point for the
-   Mapping supplied and check that this matches the number of axes
-   obtained above. Report an error if it does not. */
-      ncoord = astGetNin( map );
-      if ( astOK && ( naxes != ncoord ) ) {
-         astError( AST__NCPIN, "astAddFrame(%s): Bad number of %s input "
-                   "coordinate values (%d).", status, astGetClass( this ),
-                   astGetClass( map ), ncoord );
-         astError( AST__NCPIN, "The %s given should accept %d coordinate "
-                   "value%s for each input point.", status, astGetClass( map ), naxes,
-                   ( naxes == 1 ) ? "" : "s" );
-      }
-   }
-
-/* Similarly, obtain the number of output coordinate values per point
-   for the Mapping and check that this equals the number of axes for
-   the Frame supplied. Report an error if necessary. */
-   if ( astOK ) {
-      ncoord = astGetNout( map );
-      naxes = astGetNaxes( frame );
-      if ( astOK && ( ncoord != naxes ) ) {
-         astError( AST__NCPIN, "astAddFrame(%s): Bad number of %s output "
-                   "coordinate values (%d).", status, astGetClass( this ),
-                   astGetClass( map ), ncoord );
-         astError( AST__NCPIN, "The %s given should generate %d "
-                   "coordinate value%s for each output point.", status,
-                   astGetClass( map ), naxes, ( naxes == 1 ) ? "" : "s" );
-      }
-   }
-
-/* Normal Frame supplied. */
-/* ====================== */
-/* Check that the Frame supplied is not a FrameSet (handling a
-   FrameSet is a special case which is addressed later). */
-   if ( !astIsAFrameSet( frame ) && astOK ) {
-
-/* Increase the size of the FrameSet's arrays to accommodate one new
-   Frame. */
-      this->frame = astGrow( this->frame, this->nframe + 1,
-                             sizeof( AstFrame * ) );
-      this->varfrm = astGrow( this->varfrm, this->nframe + 1,
-                             sizeof( int ) );
-      this->node = astGrow( this->node, this->nframe + 1, sizeof( int ) );
-      this->map = astGrow( this->map, this->nnode, sizeof( AstMapping * ) );
-      this->link = astGrow( this->link, this->nnode, sizeof( int ) );
-      this->invert = astGrow( this->invert, this->nnode, sizeof( int ) );
-      if ( astOK ) {
-
-/* Copy pointers to the Frame and Mapping supplied and store these pointers
-   in the FrameSet arrays. */
-         this->frame[ this->nframe ] = astCopy( frame );
-         this->map[ this->nnode - 1 ] = astCopy( map );
-
-/* Indicate the Frame does not reflect the variant Mappings of any other
-   Frame. */
-         this->varfrm[ this->nframe ] = 0;
-
-/* Associate the Frame with the Mapping via the "node" array. */
-         this->node[ this->nframe ] = this->nnode;
-
-/* Add a "link" value which identifies the node from which the new
-   node is derived and store the current value of the Invert attribute
-   for the Mapping. */
-         this->link[ this->nnode - 1 ] = this->node[ iframe - 1 ];
-         this->invert[ this->nnode - 1 ] = astGetInvert( map );
-
-/* If successful, increment the FrameSet's Frame and node counts and
-   set the Current attribute so that the new Frame becomes the current
-   Frame. */
-         if ( astOK ) {
-            this->nframe++;
-            this->nnode++;
-            astSetCurrent( this, this->nframe );
-
-/* If an error occurred while filling the FrameSet's arrays, clear any values
-   that may have been added, annulling any copied pointers. */
-         } else {
-            this->frame[ this->nframe ] =
-                  astAnnul( this->frame[ this->nframe ] );
-            this->node[ this->nframe ] = -1;
-            this->map[ this->nnode - 1 ] =
-                  astAnnul( this->map[ this->nnode - 1 ] );
-            this->link[ this->nnode - 1 ] = -1;
-	 }
-      }
-
-/* FrameSet supplied. */
-/* ================== */
-/* If the Frame supplied is a FrameSet, we handle this as a special
-   case by merging the two FrameSets (so that the final result
-   contains references to all the Frames from both FrameSets). */
-   } else if ( astOK ) {
-
-/* Obtain a pointer to the FrameSet structure containing the new Frame
-   references and calculate how many Frames and nodes the combined
-   FrameSet will contain. */
-      frameset = (AstFrameSet *) frame;
-      nframe = this->nframe + frameset->nframe;
-      nnode = this->nnode + frameset->nnode;
-
-/* Extend the original FrameSet's arrays to accommodate the new Frames
-   and nodes. */
-      this->frame = astGrow( this->frame, nframe, sizeof( AstFrame * ) );
-      this->varfrm = astGrow( this->varfrm, nframe, sizeof( int ) );
-      this->node = astGrow( this->node, nframe, sizeof( int ) );
-      this->map = astGrow( this->map, nnode - 1, sizeof( AstMapping * ) );
-      this->link = astGrow( this->link, nnode - 1, sizeof( int ) );
-      this->invert = astGrow( this->invert, nnode - 1, sizeof( int ) );
-
-/* If OK, loop to transfer the new Frame data into the new array
-   elements, cloning each Frame pointer. Increment each "node" value
-   to allow for the new node numbering which will apply when the new
-   node data is appended to the new arrays. */
-      if ( astOK ) {
-         for ( ifr = 1; ifr <= frameset->nframe; ifr++ ) {
-            this->frame[ this->nframe + ifr - 1 ] =
-               astCopy( frameset->frame[ ifr - 1 ] );
-            this->node[ this->nframe + ifr - 1 ] =
-               frameset->node[ ifr - 1 ] + this->nnode;
-            if( frameset->varfrm[ ifr - 1 ] > 0 ) {
-               this->varfrm[ this->nframe + ifr - 1 ] =
-                  frameset->varfrm[ ifr - 1 ] + this->nframe;
-            } else {
-               this->varfrm[ this->nframe + ifr - 1 ] = 0;
-            }
-         }
-
-/* Similarly, transfer the new node data, cloning each Mapping
-   pointer. Increment each "link" value to allow for the new node
-   numbering. */
-         for ( inode = 1; inode < frameset->nnode; inode++ ) {
-            this->map[ this->nnode + inode - 1 ] =
-               astCopy( frameset->map[ inode - 1 ] );
-            this->link[ this->nnode + inode - 1 ] =
-               frameset->link[ inode - 1 ] + this->nnode;
-            this->invert[ this->nnode + inode - 1 ] =
-               frameset->invert[ inode - 1 ];
-         }
-
-/* In transferring the node data (above), we left an empty array
-   element which will later be filled with data corresponding to node
-   zero in the new FrameSet (there are no data to be copied for this
-   node). Initialise the data for this element to null values. */
-         this->map[ this->nnode - 1 ] = NULL;
-         this->link[ this->nnode - 1 ] = -1;
-         this->invert[ this->nnode - 1 ] = -1;
-
-/* Determine which is the current Frame in the new FrameSet and
-   convert this into the corresponding Frame number in the combined
-   one. */
-         current = astGetCurrent( frameset ) + this->nframe;
-
-/* We must now form a new link between this Frame and Frame "iframe"
-   (using the Mapping supplied) in order to inter-relate the Frames
-   from the two FrameSets. However, this cannot be done immediately
-   because in general the node corresponding to Frame "current" will
-   already have a link pointing to another node. Moreover, the node
-   which was originally node zero (in the new FrameSet) still has
-   no data in our merged FrameSet.
-
-   To overcome this, we must re-structure the links within the
-   transferred data.  We do this by starting at the node corresponding
-   to Frame "current" and working back through each link until the
-   original node zero is reached. At each step along this path, we
-   reverse the direction of the link. This involves shifting the
-   associated data by one step along the path, so that it becomes
-   associated with the next node. This results in the final
-   (initialised-to-null) node acquiring some data, and the starting
-   node being left free to receive our new link.
-
-   We compensate for reversing the links by reversing the sense of the
-   "invert" flag associated with each Mapping along the path, so that
-   the overall structure of the FrameSet is unchanged. */
-
-/* Identify the starting node (the one corresponding to Frame
-   "current"). */
-         if ( astOK ) {
-            current_node = this->node[ current - 1 ];
-
-/* Obtain the value which a "link" element will now have if it
-   originally identified node zero in the new FrameSet. We will use
-   this value to detect the end of the path. */
-            node_zero = this->nnode;
-
-/* If we are not already at "node zero", save the data for the current
-   node. */
-            if ( current_node != node_zero ) {
-               inode_map = this->map[ current_node - 1 ];
-               inode_link = this->link[ current_node - 1 ];
-               inode_invert = this->invert[ current_node - 1 ];
-
-/* Reset the node's data to null values (pending setting up the new
-   link using the Mapping supplied). */
-               this->map[ current_node - 1 ] = NULL;
-               this->link[ current_node - 1 ] = -1;
-               this->invert[ current_node - 1 ] = -1;
-
-/* Identify the next node in the path. */
-               next = inode_link;
-            }
-
-/* Follow the path until "node zero" is reached. */
-            inode = current_node;
-            while( inode != node_zero ) {
-
-/* If the next node on the path is not "node zero", save its data
-   (because we are about to write over it). */
-               if ( next != node_zero ) {
-                  next_map = this->map[ next - 1 ];
-                  next_link = this->link[ next - 1 ];
-                  next_invert = this->invert[ next - 1 ];
-               }
-
-/* Reverse the link from the current node to the "next" node. This
-   involves transferring the "map" and "invert" values to the "next"
-   node and inverting the sense of the latter to compensate. Make the
-   "next" node point back to the current one. */
-               this->map[ next - 1 ] = inode_map;
-               this->link[ next - 1 ] = inode;
-               this->invert[ next - 1 ] = !inode_invert;
-
-/* Move on to consider the next node. */
-               inode = next;
-
-/* If we have not reached "node zero" yet, transfer the node data we
-   saved above into the variables from which it will be transferred to
-   the following node on the next pass through this loop. */
-               if ( inode != node_zero ) {
-                  inode_map = next_map;
-                  inode_link = next_link;
-                  inode_invert = next_invert;
-
-/* Identify the node that follows the next one. */
-                  next = inode_link;
-               }
-            }
-
-/* Once the necessary links have been re-structured, establish the new
-   link that inter-relates the Frames from the two FrameSets. */
-            this->map[ current_node - 1 ] = astCopy( map );
-            this->link[ current_node - 1 ] = this->node[ iframe - 1 ];
-            this->invert[ current_node - 1 ] = astGetInvert( map );
-         }
-
-/* If successful, update the Frame and node counts and make the
-   appropriate Frame current. */
-         if ( astOK ) {
-            this->nframe = nframe;
-            this->nnode = nnode;
-            astSetCurrent( this, current );
-
-/* If an error occurred, loop through all the new Frame and node array
-   elements and clear them, ensuring that any remaining Object
-   pointers are annulled. */
-         } else {
-            for ( ifr = 1; ifr <= frameset->nframe; ifr++ ) {
-               this->frame[ this->nframe + ifr - 1 ] =
-                  astAnnul( this->frame[ this->nframe + ifr - 1 ] );
-               this->node[ this->nframe + ifr - 1 ] = -1;
-               this->varfrm[ this->nframe + ifr - 1 ] = 0;
-            }
-            for ( inode = 0; inode < frameset->nnode; inode++ ) {
-               this->map[ this->nnode + inode - 1 ] =
-                  astAnnul( this->map[ this->nnode + inode - 1 ] );
-               this->link[ this->nnode + inode - 1 ] = -1;
-               this->invert[ this->nnode + inode - 1 ] = -1;
-            }
-         }
-      }
-   }
-
-/* Annul the local pointer to the supplied Mapping. */
-   map = astAnnul( map );
-}
-
-static void AddVariant( AstFrameSet *this, AstMapping *map,
-                        const char *name, int *status ) {
-/*
-*++
-*  Name:
-c     astAddVariant
-f     AST_ADDVARIANT
-
-*  Purpose:
-*     Store a new variant Mapping for the current Frame in a FrameSet.
-
-*  Type:
-*     Public virtual function.
-
-*  Synopsis:
-c     #include "frameset.h"
-c     void astAddVariant( AstFrameSet *this, AstMapping *map,
-c                         const char *name )
-f     CALL AST_ADDVARIANT( THIS, MAP, NAME, STATUS )
-
-*  Class Membership:
-*     FrameSet method.
-
-*  Description:
-c     This function
-f     This routine
-*     allows a new variant Mapping to be stored with the current Frame
-*     in a FrameSet. See the "Variant" attribute for more details. It can
-*     also be used to rename the currently selected variant Mapping.
-
-*  Parameters:
-c     this
-f     THIS = INTEGER (Given)
-*        Pointer to the FrameSet.
-c     map
-f     MAP = INTEGER (Given)
-*        Pointer to a Mapping which describes how to convert
-*        coordinates from the current Frame to the new variant of the
-*        current Frame. If
-c        NULL
-f        AST__NULL
-*        is supplied, then the name associated with the currently selected
-*        variant of the current Frame is set to the value supplied for
-c        "name", but no new variant is added.
-f        NAME, but no new variant is added.
-c     name
-f     NAME = CHARACTER * ( * ) (Given)
-*        The name to associate with the new variant Mapping (or the currently
-*        selected variant Mapping if
-c        "map" is NULL).
-f        MAP is AST__NULL).
-f     STATUS = INTEGER (Given and Returned)
-f        The global status.
-
-*  Notes:
-*     - The newly added Variant becomes the current variant on exit (this is
-*     equivalent to setting the Variant attribute to the value supplied for
-c     "name).
-f     NAME).
-*     - An error is reported if a variant with the supplied name already
-*     exists in the current Frame.
-*     - An error is reported if the current Frame is a mirror for the
-*     variant Mappings in another Frame. This is only the case if the
-c     astMirrorVariants function
-f     AST_MIRRORVARIANTS routine
-*     has been called to make the current Frame act as a mirror.
-
-*--
-*/
-
-/* Local Variables: */
-   AstCmpMap *map2;
-   AstFrame *frm;
-   AstFrame *tfrm;
-   AstFrame *vfrm;
-   AstFrameSet *tfs;
-   AstFrameSet *vfs;
-   AstMapping *map1;
-   AstMapping *map3;
-   char *myname;
-   const char *dom;
-   int icur;
-   int ifrm;
-   int new;
-   int nfrm;
-
-/* Check the global error status. */
-   if ( !astOK ) return;
-
-/* Get the one-based index of the current Frame. */
-   icur = astGetCurrent( this );
-
-/* Report an error if the current Frame is just a mirror. */
-   if( this->varfrm[ icur - 1 ] > 0 && astOK ) {
-      astError( AST__MIRRO, "astAddVariant(%s): Illegal attempt to "
-                "add a variant Mapping to a mirror Frame (programming "
-                "error).", status, astGetClass( this ) );
-   }
-
-/* Get a copy of the supplied string and clean it. */
-   myname = astStore( NULL, name, strlen( name ) + 1 );
-   astRemoveLeadingBlanks( myname );
-   astChrCase( NULL, myname, 1, 0 );
-   if( astOK ) {
-      myname[ astChrLen( myname ) ] = 0;
-
-/* Get the Variants FrameSet for the current Frame in "this". */
-      frm = astGetFrame( this, icur );
-      vfs = astGetFrameVariants( frm );
-
-/* If current Frame of this has no Variant FrameSet, create a Variants
-   FrameSet containing a copy of the current Frame (retain its Domain
-   as the default variant name). */
-      if( !vfs ) {
-         tfrm = astCopy( frm );
-         vfs = astFrameSet( tfrm, " ", status );
-         tfrm = astAnnul( tfrm );
-         new = 1;
-      } else {
-         new = 0;
-      }
-
-/* Check the Variants FrameSet does not already contain a Frame with
-   a Domain equal to the supplied name. */
-      nfrm = astGetNframe( vfs );
-      for( ifrm = 0; ifrm < nfrm && astOK; ifrm++ ) {
-         vfrm = astGetFrame( vfs, ifrm + 1 );
-         dom = astGetDomain( vfrm );
-         if( astOK && !strcmp( dom, myname ) ) {
-            astError( AST__BDVNM, "astAddVariant(%s): Cannot add a "
-                      "variant %s Frame with name '%s' because one "
-                      "already exists in the %s (programming "
-                      "error).", status, astGetClass( this ),
-                      astGetDomain( frm ), myname,  astGetClass( this ) );
-         }
-         vfrm = astAnnul( vfrm );
-      }
-
-/* If no Mapping was supplied, just set the name of the currently
-   selected variant. The names are stored in the Domain attribute of
-   the Frames in the variants FrameSet, so set teh DOmain for the current
-   Frame. */
-      if( !map ){
-         vfrm = astGetFrame( vfs, AST__CURRENT );
-         astSetDomain( vfrm, name );
-         vfrm = astAnnul( vfrm );
-
-/* If a Mapping was supplied.... */
-      } else {
-
-/* Get the Mapping from the current Frame in the variants FrameSet to the
-   current Frame in "this". Temporarily match the Domains so that
-   astConvert can work. */
-         vfrm = astGetFrame( vfs, AST__CURRENT );
-         dom = astGetDomain( frm );
-         if( dom ) dom = astStore( NULL, dom, strlen( dom ) + 1 );
-         astSetDomain( frm, astGetDomain( vfrm ) );
-         tfs = astConvert( vfrm, frm, "" );
-         astSetDomain( frm, dom );
-         if( tfs ) {
-            map1 = astGetMapping( tfs, AST__BASE, AST__CURRENT );
-            tfs = astAnnul( tfs );
-
-/* Concatenate it with the supplied Mapping to get the mapping from the
-   current Frame in the Variants FrameSet to the new variant Frame. */
-            map2 = astCmpMap( map1, map, 1, " ", status );
-            map3 = astSimplify( map2 );
-
-/* Add a copy of parent Frame into Variants FrameSet, using the above
-   mapping to connect it to the original current Variants Frame. Set
-   its Domain to the supplied name. Re-instate the original current Frame
-   afterwards. Remove the variant frame info before adding it. */
-            (void) astAnnul( vfrm );
-            vfrm = astCopy( frm );
-            astSetFrameVariants( vfrm, NULL );
-            astSetDomain( vfrm, name );
-            icur = astGetCurrent( vfs );
-            astAddFrame( vfs, AST__CURRENT, map3, vfrm );
-            astSetCurrent( vfs, icur );
-
-/* Free resources. */
-            map1 = astAnnul( map1 );
-            map2 = astAnnul( map2 );
-            map3 = astAnnul( map3 );
-
-/* Report an error if a Mapping cannot be found from the new variant Frame
-   to the current Frame in "this". */
-         } else if( astOK ) {
-            astError( AST__INTER, "astAddVariant(%s): Cannot convert "
-                      "from a %s with Domain '%s' to a %s with Domain "
-                      "'%s' (internal programming error).", status,
-                      astGetClass( this ), astGetClass( vfrm ),
-                      astGetDomain( vfrm ), astGetClass( frm ),
-                      astGetDomain( frm ) );
-         }
-
-/* Free resources. */
-         dom = astFree( (void *) dom );
-         vfrm = astAnnul( vfrm );
-      }
-
-/* If all is well, and the Variants FrameSet is new, store a pointer to
-   it in the current Frame of "this". */
-      if( new ) astSetFrameVariants( frm, vfs );
-
-/* Make the new Variant the current variant. */
-      if( map ) astSetVariant( this, name );
-
-/* Free remaining resources. */
-      frm = astAnnul( frm );
-      vfs = astAnnul( vfs );
-   }
-   myname = astFree( myname );
-}
-
-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 "frameset.h"
-*     double Angle( AstFrame *this, const double a[], const double b[],
-*                   const double c[], int *status )
-
-*  Class Membership:
-*     FrameSet member function (over-rides the protected 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 appropriate to the Frame in use. For instance, in
-*     SkyFrame, they will be great circles.
-
-*  Parameters:
-*     this
-*        Pointer to the Frame.
-*     a
-*        An array of double, with one element for each Frame axis
-*        (Naxes attribute) containing the coordinates of the first point.
-*     b
-*        An array of double, with one element for each Frame axis
-*        (Naxes attribute) containing the coordinates of the second point.
-*     c
-*        An array of double, with one element for each Frame axis
-*        (Naxes attribute) containing the coordinates of the third point.
-*     status
-*        Pointer to the inherited status variable.
-
-*  Returned Value:
-*     astAngle
-*        The angle in radians, from the line AB to the line CB. If the
-*        Frame is 2-dimensional, it will be in the range $\pm \pi$,
-*        and positive rotation is in the same sense as rotation from
-*        the positive direction of axis 2 to the positive direction of
-*        axis 1. If the Frame has more than 2 axes, a positive value will
-*        always be returned in the range zero to $\pi$.
-
-*  Notes:
-*     - A value of AST__BAD will also be returned if points A and B are
-*     co-incident, or if points B and C are co-incident.
-*     - A value of AST__BAD 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: */
-   AstFrame *fr;                 /* Pointer to current Frame */
-   AstFrameSet *this;            /* Pointer to the FrameSet structure */
-   double result;                /* Value to return */
-
-/* Check the global error status. */
-   if ( !astOK ) return AST__BAD;
-
-/* Obtain a pointer to the FrameSet structure. */
-   this = (AstFrameSet *) this_frame;
-
-/* Obtain a pointer to the FrameSet's current Frame and invoke this
-   Frame's astAngle method. Annul the Frame pointer afterwards. */
-   fr = astGetFrame( this, AST__CURRENT );
-   result = astAngle( fr, a, b, c );
-   fr = astAnnul( fr );
-
-/* If an error occurred, clear the result. */
-   if ( !astOK ) result = AST__BAD;
-
-/* Return the result. */
-   return result;
-}
-
-static void AppendAxes( AstFrameSet *this, AstFrame *frame, int *status ) {
-/*
-*  Name:
-*     AppendAxes
-
-*  Purpose:
-*     Append axes to every Frame in a FrameSet.
-
-*  Type:
-*     Private function.
-
-*  Synopsis:
-*     #include "frameset.h"
-*     void AppendAxes( AstFrameSet *this, AstFrame *frame, int *status )
-
-*  Class Membership:
-*     FrameSet member function
-
-*  Description:
-*     This function replaces every Frame in the FrameSet with a CmpFrame
-*     holding the original Frame and the supplied Frame. It also replaces
-*     every Mapping in the FrameSet with a parallel CmpMap holding the
-*     original Mapping and a UnitMap. The Nin and Nout attributes of every
-*     UnitMap are equal to the number of axes in the supplied Frame. Each
-*     CmpMap is simplified before being stored in the FrameSet.
-
-
-*  Parameters:
-*     this
-*        Pointer to the Frame.
-*     frame
-*        Pointer to a Frame holding the new axes to add to every Frame in
-*        the FrameSet.
-*     status
-*        Pointer to the inherited status variable.
-
-*/
-
-/* Local Variables: */
-   AstCmpFrame *frm;             /* Pointer to new Frame */
-   AstCmpMap *map;               /* UnitMap to new Mapping */
-   AstUnitMap *umap;             /* UnitMap to feed the new axes */
-   int iframe;                   /* Frame index */
-   int imap;                     /* Mapping index */
-   int inv_orig;                 /* Original value of Invert attribute */
-
-/* Check the global error status. */
-   if ( !astOK ) return;
-
-/* Loop round every Frame in the FrameSet. */
-   for ( iframe = 0; iframe < this->nframe; iframe++ ) {
-
-/* Create a CmpFrame holding the original Frame and the new Frame. */
-      frm = astCmpFrame( this->frame[ iframe ], frame, " ", status );
-
-/* Annul the original Frame pointer and store the new CmpFrame pointer. */
-      (void) astAnnul( this->frame[ iframe ] );
-      this->frame[ iframe ] = (AstFrame *) frm;
-   }
-
-/* Create a UnitMap with the number of inputs and outputs equal to the
-   number of axes in the supplied Frame. */
-   umap = astUnitMap( astGetNaxes( frame ), " ", status );
-
-/* Loop round every Mapping in the FrameSet. */
-   for ( imap = 0; imap < this->nnode - 1; imap++ ) {
-
-/* The Invert attribute of the Mapping may have been changed via a
-   different pointer since it was first added into the FrameSet. To
-   ensure that the FrameSet continues to behave as was originally
-   intended, we set the Invert attribute back to the value it had when
-   the Mapping was first added into the FrameSet. First, note the
-   current value of the Invert flag so that it can be re-instated later. */
-      inv_orig = astGetInvert( this->map[ imap ] );
-      astSetInvert( this->map[ imap ], this->invert[ imap ] );
-
-/*  Create a parallel CmpMap holding the original Mapping and the UnitMap. */
-      map = astCmpMap( this->map[ imap ], umap, 0, " ", status );
-
-/* Re-instate the original value for the Invert flag, and then annul the
-   original Mapping pointer. */
-      astSetInvert( this->map[ imap ], inv_orig );
-      (void) astAnnul( this->map[ imap ] );
-
-/* Simplify the new Mapping, and store it in the FrameSet. */
-      this->map[ imap ] = astSimplify( map );
-
-/* Store a copy of the Invert attribute that should be used with this
-   Mapping within the FrameSet (just in case it  is modified via some
-   excternal reference). */
-      this->invert[ imap ] = astGetInvert( this->map[ imap ] );
-
-/* Annul the un-simplified Mapping pointer. */
-      map = astAnnul( map );
-   }
-
-/* Annul the UnitMap pointer. */
-   umap = astAnnul( umap );
-}
-
-static double AxAngle( AstFrame *this_frame, const double a[], const double b[], int axis, int *status ) {
-/*
-*  Name:
-*     AxAngle
-
-*  Purpose:
-*     Returns the angle from an axis, to a line through two points.
-
-*  Type:
-*     Private function.
-
-*  Synopsis:
-*     #include "frameset.h"
-*     double AxAngle( AstFrame *this, const double a[], const double b[], int axis, int *status )
-
-*  Class Membership:
-*     FrameSet member function (over-rides the protected astAxAngle
-*     method inherited from the Frame class).
-
-*  Description:
-*     This function finds the angle, as seen from point A, between the positive
-*     direction of a specified axis, and the geodesic curve joining point
-*     A to point B.
-
-*  Parameters:
-*     this
-*        Pointer to the Frame.
-*     a
-*        An array of double, with one element for each Frame axis
-*        (Naxes attribute) containing the coordinates of the first point.
-*     b
-*        An array of double, with one element for each Frame axis
-*        (Naxes attribute) containing the coordinates of the second point.
-*     axis
-*        The number of the Frame axis from which the angle is to be
-*        measured (one-based).
-*     status
-*        Pointer to the inherited status variable.
-
-*  Returned Value:
-*        The angle in radians, from the positive direction of the
-*        specified axis, to the line AB. If the Frame is 2-dimensional,
-*        it will be in the range $\pm \pi$, and positive rotation is in
-*        the same sense as rotation from the positive direction of axis 2
-*        to the positive direction of axis 1. If the Frame has more than 2
-*        axes, a positive value will always be returned in the range zero
-*        to $\pi$.
-
-*  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, or if the require
-*     position angle is undefined.
-*/
-
-/* Local Variables: */
-   AstFrame *fr;                 /* Pointer to current Frame */
-   AstFrameSet *this;            /* Pointer to the FrameSet structure */
-   double result;                /* Value to return */
-
-/* Check the global error status. */
-   if ( !astOK ) return AST__BAD;
-
-/* Obtain a pointer to the FrameSet structure. */
-   this = (AstFrameSet *) this_frame;
-
-/* Validate the axis index. */
-   (void) astValidateAxis( this, axis - 1, 1, "astAxAngle" );
-
-/* Obtain a pointer to the FrameSet's current Frame and invoke the
-   astAxAngle method for this Frame. Annul the Frame pointer
-   afterwards. */
-   fr = astGetFrame( this, AST__CURRENT );
-   result = astAxAngle( fr, a, b, axis );
-   fr = astAnnul( fr );
-
-/* If an error occurred, clear the result value. */
-   if ( !astOK ) result = AST__BAD;
-
-/* Return the result. */
-   return result;
-}
-
-static double AxDistance( AstFrame *this_frame, int axis, double v1, double v2, int *status ) {
-/*
-*  Name:
-*     AxDistance
-
-*  Purpose:
-*     Find the distance between two axis values.
-
-*  Type:
-*     Private function.
-
-*  Synopsis:
-*     #include "frameset.h"
-*     double AxDistance( AstFrame *this, int axis, double v1, double v2, int *status )
-
-*  Class Membership:
-*     FrameSet member function (over-rides the protected astAxDistance
-*     method inherited from the Frame class).
-
-*  Description:
-*     This function returns a signed value representing the axis increment
-*     from axis value v1 to axis value v2.
-*
-*     For a simple Frame, this is a trivial operation returning the
-*     difference between the two axis values. But for other derived classes
-*     of Frame (such as a SkyFrame) this is not the case.
-
-*  Parameters:
-*     this
-*        Pointer to the Frame.
-*     axis
-*        The index of the axis to which the supplied values refer. The
-*        first axis has index 1.
-*     v1
-*        The first axis value.
-*     v2
-*        The second axis value.
-*     status
-*        Pointer to the inherited status variable.
-
-*  Returned Value:
-*     The distance between the two axis values.
-
-*  Notes:
-*     - This function will return a "bad" result value (AST__BAD) if
-*     any of the input vaues 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: */
-   AstFrame *fr;                 /* Pointer to current Frame */
-   AstFrameSet *this;            /* Pointer to the FrameSet structure */
-   double result;                /* Value to return */
-
-/* Check the global error status. */
-   if ( !astOK ) return AST__BAD;
-
-/* Obtain a pointer to the FrameSet structure. */
-   this = (AstFrameSet *) this_frame;
-
-/* Validate the axis index. */
-   (void) astValidateAxis( this, axis - 1, 1, "astAxDistance" );
-
-/* Obtain a pointer to the FrameSet's current Frame and invoke the
-   astAxDistance method for this Frame. Annul the Frame pointer
-   afterwards. */
-   fr = astGetFrame( this, AST__CURRENT );
-   result = astAxDistance( fr, axis, v1, v2 );
-   fr = astAnnul( fr );
-
-/* If an error occurred, clear the result value. */
-   if ( !astOK ) result = AST__BAD;
-
-/* Return the result. */
-   return result;
-}
-
-static void AxNorm( AstFrame *this_frame, int axis, int oper, int nval,
-                    double *values, int *status ){
-/*
-*  Name:
-*     AxNorm
-
-*  Purpose:
-*     Normalise an array of axis values.
-
-*  Type:
-*     Private function.
-
-*  Synopsis:
-*     #include "frameset.h"
-*     void AxNorm( AstFrame *this, int axis, int oper, int nval,
-*                  double *values, int *status )
-
-*  Class Membership:
-*     FrameSet member function (over-rides the protected astAxNorm
-*     method inherited from the Frame class).
-
-*  Description:
-*     This function modifies a supplied array of axis values so that
-*     they are normalised in the manner indicated by parameter "oper".
-*
-*     No normalisation is possible for a simple Frame and so the supplied
-*     values are returned unchanged. However, this may not be the case for
-*     specialised sub-classes of Frame. For instance, a SkyFrame has a
-*     discontinuity at zero longitude and so a longitude value can be
-*     expressed in the range [-Pi,+PI] or the range [0,2*PI].
-
-*  Parameters:
-*     this
-*        Pointer to the Frame.
-*     axis
-*        The index of the axis to which the supplied values refer. The
-*        first axis has index 1.
-*     oper
-*        Indicates the type of normalisation to be applied. If zero is
-*        supplied, the normalisation will be the same as that performed by
-*        function astNorm. If 1 is supplied, the normalisation will be
-*        chosen automatically so that the resulting list has the smallest
-*        range.
-*     nval
-*        The number of points in the values array.
-*     values
-*        On entry, the axis values to be normalised. Modified on exit to
-*        hold the normalised values.
-*     status
-*        Pointer to the inherited status variable.
-
-*/
-
-/* Local Variables: */
-   AstFrame *fr;                 /* Pointer to current Frame */
-   AstFrameSet *this;            /* Pointer to the FrameSet structure */
-
-/* Check the global error status. */
-   if ( !astOK ) return;
-
-/* Obtain a pointer to the FrameSet structure. */
-   this = (AstFrameSet *) this_frame;
-
-/* Validate the axis index. */
-   (void) astValidateAxis( this, axis - 1, 1, "astAxNorm" );
-
-/* Obtain a pointer to the FrameSet's current Frame and invoke the
-   astAxNorm method for this Frame. Annul the Frame pointer
-   afterwards. */
-   fr = astGetFrame( this, AST__CURRENT );
-   astAxNorm( fr, axis, oper, nval, values );
-   fr = astAnnul( fr );
-}
-
-static double AxOffset( AstFrame *this_frame, int axis, double v1, double dist, int *status ) {
-/*
-*  Name:
-*     AxOffset
-
-*  Purpose:
-*     Add an increment onto a supplied axis value.
-
-*  Type:
-*     Private function.
-
-*  Synopsis:
-*     #include "frameset.h"
-*     double AxOffset( AstFrame *this, int axis, double v1, double dist, int *status )
-
-*  Class Membership:
-*     FrameSet member function (over-rides the protected astAxOffset
-*     method inherited from the Frame class).
-
-*  Description:
-*     This function returns an axis value formed by adding a signed axis
-*     increment onto a supplied axis value.
-*
-*     For a simple Frame, this is a trivial operation returning the
-*     sum of the two supplied values. But for other derived classes
-*     of Frame (such as a SkyFrame) this is not the case.
-
-*  Parameters:
-*     this
-*        Pointer to the Frame.
-*     axis
-*        The index of the axis to which the supplied values refer. The
-*        first axis has index 1.
-*     v1
-*        The original axis value.
-*     dist
-*        The axis increment to add to the original axis value.
-*     status
-*        Pointer to the inherited status variable.
-
-*  Returned Value:
-*     The incremented axis value.
-
-*  Notes:
-*     - This function will return a "bad" result value (AST__BAD) if
-*     any of the input vaues 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: */
-   AstFrame *fr;                 /* Pointer to current Frame */
-   AstFrameSet *this;            /* Pointer to the FrameSet structure */
-   double result;                /* Value to return */
-
-/* Check the global error status. */
-   if ( !astOK ) return AST__BAD;
-
-/* Obtain a pointer to the FrameSet structure. */
-   this = (AstFrameSet *) this_frame;
-
-/* Validate the axis index. */
-   (void) astValidateAxis( this, axis - 1, 1, "astAxOffset" );
-
-/* Obtain a pointer to the FrameSet's current Frame and invoke the
-   astAxOffset method for this Frame. Annul the Frame pointer
-   afterwards. */
-   fr = astGetFrame( this, AST__CURRENT );
-   result = astAxOffset( fr, axis, v1, dist );
-   fr = astAnnul( fr );
-
-/* If an error occurred, clear the result value. */
-   if ( !astOK ) result = AST__BAD;
-
-/* Return the result. */
-   return result;
-}
-
-static AstObject *Cast( AstObject *this_object, AstObject *obj, int *status ) {
-/*
-*  Name:
-*     Cast
-
-*  Purpose:
-*     Cast an Object into an instance of a sub-class.
-
-*  Type:
-*     Private function.
-
-*  Synopsis:
-*     #include "frameset.h"
-*     AstObject *Cast( AstObject *this, AstObject *obj, int *status )
-
-*  Class Membership:
-*     FrameSet member function (over-rides the protected astCast
-*     method inherited from the Frame class).
-
-*  Description:
-*     This function returns a deep copy of an ancestral component of the
-*     supplied object. The required class of the ancestral component is
-*     specified by another object. Specifically, if "this" and "new" are
-*     of the same class, a copy of "this" is returned. If "this" is an
-*     instance of a subclass of "obj", then a copy of the component
-*     of "this" that matches the class of "obj" is returned. Otherwise,
-*     a NULL pointer is returned without error.
-
-*  Parameters:
-*     this
-*        Pointer to the Object to be cast.
-*     obj
-*        Pointer to an Object that defines the class of the returned Object.
-*        The returned Object will be of the same class as "obj".
-
-*  Returned Value:
-*     A pointer to the new Object. NULL if "this" is not a sub-class of
-*     "obj", or if an error occurs.
-
-*  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; */
-   AstFrame *cfrm;
-   AstObject *new;
-   astDECLARE_GLOBALS
-   int generation_gap;
-
-/* Initialise */
-   new = NULL;
-
-/* Check inherited status */
-   if( !astOK ) return new;
-
-/* Get a pointer to the thread specific global data structure. */
-   astGET_GLOBALS(NULL);
-
-/* See how many steps up the class inheritance ladder it is from "obj"
-   to this class (FrameSet). A positive value is returned if FrameSet
-   is a sub-class of "obj". A negative value is returned if "obj" is
-   a sub-class of FrameSet. Zero is returned if "obj" is a FrameSet.
-   AST__COUSIN is returned if "obj" is not on the same line of descent
-   as FrameSet. */
-   generation_gap = astClassCompare( (AstObjectVtab *) &class_vtab,
-                                     astVTAB( obj ) );
-
-/* If "obj" is a FrameSet or a sub-class of FrameSet, we can cast by
-   truncating the vtab for "this" so that it matches the vtab of "obJ",
-   and then taking a deep copy of "this". */
-   if( generation_gap <= 0 && generation_gap != AST__COUSIN ) {
-      new = astCastCopy( this_object, obj );
-
-/* If "obj" is not a FrameSet or a sub-class of FrameSet (e.g. a Frame or
-   some sub-class of Frame), we attempt to cast the current Frame into
-   the class indicated by "obj". */
-   } else {
-      cfrm = astGetFrame( (AstFrameSet *) this_object, AST__CURRENT );
-      new = astCast( cfrm, obj );
-      cfrm = astAnnul( cfrm );
-   }
-
-/* Return the new pointer. */
-   return new;
-}
-
-static double Centre( AstFrame *this_frame, int axis, double value, double gap, int *status ) {
-/*
-*  Name:
-*     Centre
-
-*  Purpose:
-*     Find a "nice" central value for tabulating Frame axis values.
-
-*  Type:
-*     Private function.
-
-*  Synopsis:
-*     #include "frameset.h"
-*     double  Centre( AstFrame *this_frame, int axis, double value,
-*                     double gap, int *status )
-
-*  Class Membership:
-*     FrameSet member function (over-rides the protected astCentre method
-*     inherited from the Frame class).
-
-*  Description:
-*     This function returns an axis value which produces a nice formatted
-*     value suitable for a major tick mark on a plot axis, close to the
-*     supplied axis value.
-
-*  Parameters:
-*     this
-*        Pointer to the Frame.
-*     axis
-*        The number of the axis (zero-based) for which a central value
-*        is to be found.
-*     value
-*        An arbitrary axis value in the section that is being plotted.
-*     gap
-*        The gap size.
-
-*  Returned Value:
-*     The nice central axis value.
-
-*  Notes:
-*     - A value of zero is returned if the supplied gap size is zero.
-*     - A value of zero will be returned if this function is invoked
-*     with the global error status set, or if it should fail for any
-*     reason.
-*/
-
-/* Local Variables: */
-   AstFrame *fr;                 /* Pointer to current Frame */
-   AstFrameSet *this;            /* Pointer to the FrameSet structure */
-   double result;                /* Value to return */
-
-/* Check the global error status. */
-   if ( !astOK ) return 0.0;
-
-/* Obtain a pointer to the FrameSet structure. */
-   this = (AstFrameSet *) this_frame;
-
-/* Validate the axis index. */
-   (void) astValidateAxis( this, axis, 1, "astCentre" );
-
-/* Obtain a pointer to the FrameSet's current Frame and invoke this
-   Frame's astCentre method to obtain the required value. Annul the
-   Frame pointer afterwards. */
-   fr = astGetFrame( this, AST__CURRENT );
-   result = astCentre( fr, axis, value, gap );
-   fr = astAnnul( fr );
-
-/* If an error occurred, clear the result. */
-   if ( !astOK ) result = 0.0;
-
-/* Return the result. */
-   return result;
-}
-
-static void CheckPerm( AstFrame *this_frame, const int *perm, const char *method, int *status ) {
-/*
-*  Name:
-*     CheckPerm
-
-*  Purpose:
-*     Check that an array contains a valid permutation.
-
-*  Type:
-*     Private function.
-
-*  Synopsis:
-*     #include "frameset.h"
-*     void CheckPerm( AstFrame *this, const int *perm, const char *method, int *status )
-
-*  Class Membership:
-*     FrameSet member function (over-rides the protected astCheckPerm
-*     method inherited from the Frame class).
-
-*  Description:
-*     This function checks the validity of a permutation array that
-*     will be used to permute the order of a Frame's axes. If the
-*     permutation specified by the array is not valid, an error is
-*     reported and the global error status is set. Otherwise, the
-*     function returns without further action.
-
-*  Parameters:
-*     this
-*        Pointer to the Frame.
-*     perm
-*        Pointer to an array of integers with the same number of
-*        elements as there are axes in the Frame. For each axis, the
-*        corresponding integer gives the (zero based) axis index to be
-*        used to identify the information for that axis (using the
-*        un-permuted axis numbering). To be valid, the integers in
-*        this array should therefore all lie in the range zero to
-*        (naxes-1) inclusive, where "naxes" is the number of Frame
-*        axes, and each value should occur exactly once.
-*     method
-*        Pointer to a constant null-terminated character string
-*        containing the name of the method that invoked this function
-*        to validate a permutation array. This method name is used
-*        solely for constructing error messages.
-*     status
-*        Pointer to the inherited status variable.
-
-*  Notes:
-*     - Error messages issued by this function refer to the external
-*     (public) numbering system used for axes (which is one-based),
-*     whereas zero-based axis indices are used internally.
-*/
-
-/* Local Variables: */
-   AstFrame *fr;                 /* Pointer to current Frame */
-   AstFrameSet *this;            /* Pointer to the FrameSet structure */
-
-/* Check the global error status. */
-   if ( !astOK ) return;
-
-/* Obtain a pointer to the FrameSet structure. */
-   this = (AstFrameSet *) this_frame;
-
-/* Obtain a pointer to the FrameSet's current Frame and invoke this
-   Frame's astCheckPerm method. Annul the Frame pointer afterwards. */
-   fr = astGetFrame( this, AST__CURRENT );
-   astCheckPerm( fr, perm, method );
-   fr = astAnnul( fr );
-
-}
-
-static void Clear( AstObject *this_object, const char *attrib, int *status ) {
-/*
-*  Name:
-*     Clear
-
-*  Purpose:
-*     Clear attribute values for a FrameSet.
-
-*  Type:
-*     Private function.
-
-*  Synopsis:
-*     #include "frameset.h"
-*     void Clear( AstObject *this, const char *attrib, int *status )
-
-*  Class Membership:
-*     FrameSet member function (over-rides the public astClear method
-*     inherited from the Object class).
-
-*  Description:
-*     This function clears the values of a specified set of attributes
-*     for a FrameSet. Clearing an attribute cancels any value that has
-*     previously been explicitly set for it, so that the standard
-*     default attribute value will subsequently be used instead. This
-*     also causes the astTest function to return the value zero for
-*     the attribute, indicating that no value has been set.
-
-*  Parameters:
-*     this
-*        Pointer to the FrameSet.
-*     attrib
-*        Pointer to a null-terminated character string containing a
-*        comma-separated list of the names of the attributes to be
-*        cleared.
-*     status
-*        Pointer to the inherited status variable.
-
-*  Notes:
-*     - This function preserves the integrity of the FrameSet (if
-*     possible) by appropriately remapping its current Frame to take
-*     account of its changed attribute values.
-*/
-
-/* Local Variables: */
-   astDECLARE_GLOBALS            /* Declare the thread specific global data */
-   AstFrame *save_frame;         /* Saved pointer to integrity Frame */
-   AstFrameSet *this;            /* Pointer to FrameSet structure */
-   const char *save_method;      /* Saved pointer to method name */
-   int ok;                       /* Status OK? */
-   int save_lost;                /* Saved integrity modified flag */
-
-/* Check the global error status. */
-   if ( !astOK ) return;
-
-/* Get a pointer to the structure holding thread-specific global data. */
-   astGET_GLOBALS(this_object);
-
-/* Obtain a pointer to the FrameSet structure. */
-   this = (AstFrameSet *) this_object;
-
-/* To allow this function to be invoked recursively, we first save any
-   existing FrameSet integrity information in local variables. */
-   save_frame = integrity_frame;
-   save_lost= integrity_lost;
-   save_method = integrity_method;
-
-/* Set the name of the method being used (for use in error
-   messages). */
-   integrity_method = "astClear";
-
-/* Record the initial integrity state of the FrameSet. */
-   RecordIntegrity( this, status );
-
-/* Invoke the parent astClear method to clear the FrameSet's attribute
-   values and note if this succeeds. */
-   (*parent_clear)( this_object, attrib, status );
-   ok = astOK;
-
-/* Restore the FrameSet's integrity. */
-   RestoreIntegrity( this, status );
-
-/* If integrity could not be restored, then add contextual error
-   information. */
-   if ( !astOK && ok ) {
-      astError( astStatus, "Unable to accommodate clearing the \"%s\" "
-                           "attribute(s).", status, attrib );
-   }
-
-/* Restore any saved FrameSet integrity information. */
-   integrity_frame = save_frame;
-   integrity_lost = save_lost;
-   integrity_method = save_method;
-}
-
-static void ClearAttrib( AstObject *this_object, const char *attrib, int *status ) {
-/*
-*  Name:
-*     ClearAttrib
-
-*  Purpose:
-*     Clear an attribute value for a FrameSet.
-
-*  Type:
-*     Private function.
-
-*  Synopsis:
-*     #include "frameset.h"
-*     void ClearAttrib( AstObject *this, const char *attrib )
-
-*  Class Membership:
-*     FrameSet 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
-*     FrameSet, so that the default value will subsequently be used.
-
-*  Parameters:
-*     this
-*        Pointer to the FrameSet.
-*     attrib
-*        Pointer to a null terminated string specifying the attribute
-*        name.  This should be in lower case with no surrounding white
-*        space.
-*/
-
-/* Local Variables: */
-   astDECLARE_GLOBALS            /* Declare the thread specific global data */
-   AstFrame *fr;                 /* Pointer to current Frame */
-   AstFrameSet *this;            /* Pointer to the FrameSet structure */
-
-/* Check the global error status. */
-   if ( !astOK ) return;
-
-
-/* Get a pointer to the structure holding thread-specific global data. */
-   astGET_GLOBALS(this_object);
-/* Obtain a pointer to the FrameSet structure. */
-   this = (AstFrameSet *) this_object;
-
-/* Check the attribute name and clear the appropriate attribute. */
-
-/* We first handle attributes that apply to the FrameSet as a whole
-   (rather than to the current Frame). */
-
-/* Base. */
-/* ----- */
-   if ( !strcmp( attrib, "base" ) ) {
-      astClearBase( this );
-
-/* Current. */
-/* -------- */
-/* Since this determines the choice of current Frame, we must restore
-   the integrity state of the FrameSet before changing this attribute
-   and record the new integrity state afterwards. */
-   } else if ( !strcmp( attrib, "current" ) ) {
-      RestoreIntegrity( this, status );
-      astClearCurrent( this );
-      RecordIntegrity( this, status );
-
-/* ID. */
-/* --- */
-   } else if ( !strcmp( attrib, "id" ) ) {
-      astClearID( this );
-
-/* Ident. */
-/* ------ */
-   } else if ( !strcmp( attrib, "ident" ) ) {
-      astClearIdent( this );
-
-/* Invert. */
-/* ------- */
-/* Since this affects the choice of current Frame, we must restore the
-   integrity state of the FrameSet before changing this attribute and
-   record the new integrity state afterwards. */
-   } else if ( !strcmp( attrib, "invert" ) ) {
-      RestoreIntegrity( this, status );
-      astClearInvert( this );
-      RecordIntegrity( this, status );
-
-/* Report. */
-/* ------- */
-   } else if ( !strcmp( attrib, "report" ) ) {
-      astClearReport( this );
-
-/* Variant. */
-/* -------- */
-   } else if ( !strcmp( attrib, "variant" ) ) {
-      astClearVariant( 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 ( !strcmp( attrib, "allvariants" ) ||
-               !strcmp( attrib, "class" ) ||
-               !strcmp( attrib, "nframe" ) ||
-               !strcmp( attrib, "nin" ) ||
-               !strcmp( attrib, "nobject" ) ||
-               !strcmp( attrib, "nout" ) ||
-               !strcmp( attrib, "refcount" ) ||
-               !strcmp( attrib, "tranforward" ) ||
-               !strcmp( attrib, "traninverse" ) ) {
-      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);
-
-/* Pass unrecognised attributes on to the FrameSet's current Frame for
-   further interpretation. */
-   } else {
-
-/* Force a copy to be made of the current Frame, if needed, to make it
-   independent of other Frames within the FrameSet. */
-      (void) ForceCopy( this, AST__CURRENT, status );
-
-/* Obtain a pointer to the current Frame and invoke its astClearAttrib
-   method. Annul the Frame pointer afterwards. */
-      fr = astGetFrame( this, AST__CURRENT );
-      astClearAttrib( fr, attrib );
-      fr = astAnnul( fr );
-
-/* Note that the current Frame has been modified. */
-      integrity_lost = 1;
-   }
-}
-
-static void ClearBase( AstFrameSet *this, int *status ) {
-/*
-*+
-*  Name:
-*     astClearBase
-
-*  Purpose:
-*     Clear the value of the Base attribute of a FrameSet.
-
-*  Type:
-*     Protected virtual function.
-
-*  Synopsis:
-*     #include "frameset.h"
-*     void astClearBase( AstFrameSet *this )
-
-*  Class Membership:
-*     FrameSet method.
-
-*  Description:
-*     This function clears the value of the Base attribute of a
-*     FrameSet. This value is an index that identifies the base Frame
-*     for the FrameSet.
-
-*  Parameters:
-*     this
-*        Pointer to the FrameSet.
-*-
-*/
-
-/* Local Variables: */
-   int invert;                    /* FrameSet is inverted? */
-
-/* Check the global error status. */
-   if ( !astOK ) return;
-
-/* Determine if the FrameSet has been inverted. */
-   invert = astGetInvert( this );
-
-/* If it has not been inverted, clear the base Frame index, otherwise
-   clear the current Frame index instead. */
-   if ( astOK ) *( invert ? &this->current : &this->base ) = -INT_MAX;
-}
-
-static void ClearCurrent( AstFrameSet *this, int *status ) {
-/*
-*+
-*  Name:
-*     astClearCurrent
-
-*  Purpose:
-*     Clear the value of the Current attribute for a FrameSet.
-
-*  Type:
-*     Protected function.
-
-*  Synopsis:
-*     #include "frameset.h"
-*     int astClearCurrent( AstFrameSet *this )
-
-*  Class Membership:
-*     FrameSet method.
-
-*  Description:
-*     This function clears the value of the Current attribute for a
-*     FrameSet. This attribute is an index that identifies the current
-*     Frame for the FrameSet.
-
-*  Parameters:
-*     this
-*        Pointer to the FrameSet.
-*-
-*/
-
-/* Local Variables: */
-   int invert;                   /* FrameSet is inverted? */
-
-/* Check the global error status. */
-   if ( !astOK ) return;
-
-/* Determine if the FrameSet has been inverted. */
-   invert = astGetInvert( this );
-
-/* If it has not been inverted, clear the current frame index,
-   otherwise clear the base Frame index instead. */
-   if ( astOK ) *( invert ? &this->base : &this->current ) = -INT_MAX;
-}
-
-static void ClearVariant( AstFrameSet *this, int *status ) {
-/*
-*+
-*  Name:
-*     astClearVariant
-
-*  Purpose:
-*     Clear the value of the Variant attribute of a FrameSet.
-
-*  Type:
-*     Protected virtual function.
-
-*  Synopsis:
-*     #include "frameset.h"
-*     void astClearVariant( AstFrameSet *this )
-
-*  Class Membership:
-*     FrameSet method.
-
-*  Description:
-*     This function clears the value of the Variant attribute of a
-*     FrameSet.
-
-*  Parameters:
-*     this
-*        Pointer to the FrameSet.
-*-
-*/
-
-/* Local Variables: */
-   AstFrame *frm;
-   int icur;
-
-/* Check the global error status. */
-   if ( !astOK ) return;
-
-/* Get the one-based index of the Frame to use. */
-   icur = GetVarFrm( this, astGetCurrent( this ), status );
-
-/* Get a pointer to the current Frame in the FrameSet. */
-   frm = astGetFrame( this, icur );
-
-/* Replace any Variants FrameSet in the Frame with a NULL pointer. */
-   astSetFrameVariants( frm, NULL );
-
-/* Annul the current Frame pointer. */
-   frm = astAnnul( frm );
-
-}
-
-static AstMapping *CombineMaps( AstMapping *mapping1, int invert1,
-                                AstMapping *mapping2, int invert2,
-                                int series, int *status ) {
-/*
-*  Name:
-*     CombineMaps
-
-*  Purpose:
-*     Combine two Mappings with specified Invert flags into a CmpMap.
-
-*  Type:
-*     Private function.
-
-*  Synopsis:
-*     #include "frameset.h"
-*     AstMapping *CombineMaps( AstMapping *mapping1, int invert1,
-*                              AstMapping *mapping2, int invert2,
-*                              int series )
-
-*  Class Membership:
-*     FrameSet member function.
-
-*  Description:
-*     This function combines two Mappings into a CmpMap (compound
-*     Mapping) as if their Invert flags were set to specified values
-*     when the CmpMap is created. However, the individual Mappings are
-*     returned with their Invert flag values unchanged from their
-*     original state.
-
-*  Parameters:
-*     mapping1
-*        Pointer to the first Mapping.
-*     invert1
-*        The (boolean) Invert flag value required for the first Mapping.
-*     mapping2
-*        Pointer to the second Mapping.
-*     invert2
-*        The (boolean) Invert flag value required for the second Mapping.
-*     series
-*        Whether the Mappings are to be combined in series (as opposed to
-*        in parallel).
-
-*  Returned Value:
-*     A pointer to the resulting compound Mapping (a CmpMap).
-
-*  Notes:
-*     - This function is a wrap-up for the astCmpMap constructor and
-*     temporarily assigns the required Invert flag values while
-*     creating the required CmpMap. However, it also takes account of
-*     the possibility that the two Mapping pointers supplied may point
-*     at the same Mapping.
-*     - A null Object pointer (AST__NULL) will be returned if this
-*     function is invoked with the AST error status set, or if it
-*     should fail for any reason.
-*/
-
-/* Local Variables: */
-   AstMapping *map1;             /* First temporary Mapping pointer */
-   AstMapping *map2;             /* Second temporary Mapping pointer */
-   AstMapping *result;           /* Pointer to result Mapping */
-   int copy;                     /* Copy needed? */
-   int inv1;                     /* First original Invert flag value */
-   int inv2;                     /* Second original Invert flag value */
-   int set1;                     /* First Invert flag originally set? */
-   int set2;                     /* Second Invert flag originally set? */
-
-/* Initialise */
-   result = NULL;
-
-/* Check the global error status. */
-   if ( !astOK ) return result;
-
-/* Limit incoming values to 0 or 1. */
-   invert1 = ( invert1 != 0 );
-   invert2 = ( invert2 != 0 );
-
-/* Obtain the Invert flag values for each Mapping. */
-   inv1 = astGetInvert( mapping1 );
-   inv2 = astGetInvert( mapping2 );
-
-/* Also determine if these values are explicitly set. */
-   set1 = astTestInvert( mapping1 );
-   set2 = astTestInvert( mapping2 );
-
-/* If both Mappings are actually the same but we need different Invert
-   flag values to be set, then this can only be achieved by making a
-   copy. Note if this is necessary. */
-   copy = ( ( mapping1 == mapping2 ) && ( invert1 != invert2 ) );
-
-/* Clone the first Mapping pointer. Do likewise for the second but
-   make a copy instead if necessary. */
-   map1 = astClone( mapping1 );
-   map2 = copy ? astCopy( mapping2 ) : astClone( mapping2 );
-
-/* If the Invert value for the first Mapping needs changing, make the
-   change. */
-   if ( invert1 != inv1 ) {
-      if ( invert1 ) {
-         astSetInvert( map1, 1 );
-      } else {
-         astClearInvert( map1 );
-      }
-   }
-
-/* Similarly, change the Invert flag for the second Mapping if
-   necessary. */
-   if ( invert2 != inv2 ) {
-      if ( invert2 ) {
-         astSetInvert( map2, 1 );
-      } else {
-         astClearInvert( map2 );
-      }
-   }
-
-/* Combine the two Mappings into a CmpMap. */
-   result = (AstMapping *) astCmpMap( map1, map2, series, "", status );
-
-/* If the first Mapping's Invert value was changed, restore it to its
-   original state. */
-   if ( invert1 != inv1 ) {
-      if ( set1 ) {
-         astSetInvert( map1, inv1 );
-      } else {
-         astClearInvert( map1 );
-      }
-   }
-
-/* Similarly, restore the second Mapping's Invert value if
-   necessary. This step is not needed, however, if a copy was made. */
-   if ( ( invert2 != inv2 ) && !copy ) {
-      if ( set2 ) {
-         astSetInvert( map2, inv2 );
-      } else {
-         astClearInvert( map2 );
-      }
-   }
-
-/* Annul the temporary Mapping pointers. */
-   map1 = astAnnul( map1 );
-   map2 = astAnnul( map2 );
-
-/* If an error occurred, then annul the result pointer. */
-   if ( !astOK ) result = astAnnul( result );
-
-/* Return the result. */
-   return result;
-}
-
-static AstFrameSet *Convert( AstFrame *from, AstFrame *to,
-                             const char *domainlist, int *status ) {
-/*
-*  Name:
-*     Convert
-
-*  Purpose:
-*     Determine how to convert between two coordinate systems.
-
-*  Type:
-*     Private function.
-
-*  Synopsis:
-*     #include "frameset.h"
-*     AstFrameSet *Convert( AstFrame *from, AstFrame *to,
-*                           const char *domainlist, int *status )
-
-*  Class Membership:
-*     FrameSet member function (over-rides the public astConvert
-*     method inherited fromm the Frame class).
-
-*  Description:
-*     This function compares two FrameSets and determines whether it
-*     is possible to convert between the coordinate systems which
-*     their current Frames represent. If conversion is possible, it
-*     returns a FrameSet which describes the conversion and which may
-*     be used (as a Mapping) to transform coordinate values in either
-*     direction.
-*
-*     If conversion is possible, the Base attributes of both FrameSets
-*     will be modified on exit to identify the Frames which were used
-*     as the intermediate coordinate system.
-
-*  Parameters:
-*     from
-*        Pointer to a FrameSet whose current Frame represents the
-*        "source" coordinate system.  Note that the Base attribute of
-*        the FrameSet may be modified by this function.
-*     to
-*        Pointer to a FrameSet whose current Frame represents the
-*        "destination" coordinate system.  Note that the Base
-*        attribute of the FrameSet may be modified by this function.
-*     domainlist
-*        Pointer to a null-terminated character string containing a
-*        comma-separated list of Frame domains. This may be used to
-*        define a priority order for the different intermediate
-*        coordinate systems that might be used to perform the
-*        conversion.
-*
-*        The function will first try to obtain a conversion by making
-*        use only of intermediate Frames whose Domain attribute
-*        matches the first domain in this list. If this fails, the
-*        second domain in the list will be used, and so on, until
-*        conversion is achieved. A blank domain (e.g. two consecutive
-*        commas) indicates that all Frames should be considered,
-*        regardless of their Domain attributes. The list is
-*        case-insensitive and all white space is ignored.
-*     status
-*        Pointer to the inherited status variable.
-
-*  Returned Value:
-*        If the requested coordinate conversion is possible, the
-*        function returns a pointer to a FrameSet which describes the
-*        conversion. Otherwise, a null Object pointer (AST__NULL) is
-*        returned without error.
-*
-*        If a FrameSet is returned, it will contain two Frames. Frame
-*        number 1 (its base Frame) will describe the source coordinate
-*        system, corresponding to the "from" parameter. Frame number 2
-*        (its current Frame) will describe the destination coordinate
-*        system, corresponding to the "to" parameter. The Mapping
-*        which inter-relates these Frames will perform the required
-*        conversion between the two coordinate systems.
-
-*  Notes:
-*     - Either of the "from" and "to" pointers may identify a basic
-*     Frame instead of a FrameSet, in which case the function behaves
-*     as if it were a FrameSet containing only a single Frame.
-*     - 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 is simply a wrap-up for the ConvertX function
-*    which performs the required processing but swaps the order of the
-*    first two arguments. This is a trick to allow the astConvert
-*    method to be over-ridden by derived classes on the basis of the
-*    class of either of the first two arguments.
-*/
-
-/* Check the inherited status. */
-   if ( !astOK ) return NULL;
-
-/* Invoke the private "ConvertX" member function with the first two
-   arguments swapped. */
-   return ConvertX( to, from, domainlist, status );
-}
-
-static AstFrameSet *ConvertX( AstFrame *to, AstFrame *from,
-                              const char *domainlist, int *status ) {
-/*
-*  Name:
-*     ConvertX
-
-*  Purpose:
-*     Determine how to convert between two coordinate systems.
-
-*  Type:
-*     Private function.
-
-*  Synopsis:
-*     #include "frameset.h"
-*     AstFrameSet *ConvertX( AstFrame *to, AstFrame *from,
-*                            const char *domainlist )
-
-*  Class Membership:
-*     FrameSet member function (over-rides the protected "astConvertX"
-*     method inherited from the Frame class).
-
-*  Description:
-*     This function performs the processing for the public astConvert
-*     method (as inherited from the Frame class and over-ridden by the
-*     FrameSet class) and has exactly the same interface except that
-*     the order of the first two arguments is swapped. This is a trick
-*     to allow the astConvert method to be over-ridden by derived
-*     classes on the basis of the class of either of its first two
-*     arguments.
-*
-*     See the astConvert method for details of the interface.
-*/
-
-/* Local Variables: */
-   AstFrame *from_frame;         /* Pointer to "from" Frame */
-   AstFrame *to_frame;           /* Pointer to "to" Frame */
-   AstFrameSet *cvt;             /* Pointer to conversion FrameSet */
-   AstFrameSet *result;          /* Pointer to FrameSet to be returned */
-   AstMapping *from_map;         /* Pointer to "from" Mapping */
-   AstMapping *map;              /* Pointer to conversion Mapping */
-   AstMapping *result_map;       /* Pointer to result Mapping */
-   AstMapping *tmp;              /* Temporary Mapping pointer */
-   AstMapping *to_map;           /* Pointer to "to" Mapping */
-   char *domain;                 /* Pointer to individual domain string */
-   char *domain_end;             /* Pointer to final null of domain string */
-   char *domainlist_copy;        /* Pointer to copy of domains list */
-   int *from_order;              /* List of Frame indices in search order */
-   int *to_order;                /* List of Frame indices in search order */
-   int best_score;               /* Score from best match */
-   int from_base;                /* Index of "from" base Frame */
-   int from_current;             /* Index of "from" current Frame */
-   int from_index;               /* Index of "from" Frame */
-   int from_isframe;             /* "from" is a Frame (not a FrameSet)? */
-   int from_nframe;              /* Number of "from" Frames */
-   int from_number;              /* Loop counter for "from" Frames */
-   int iframe_from;              /* Index of best "from" Frame */
-   int iframe_to;                /* Index of best "to" Frame */
-   int match;                    /* Possible match found? */
-   int n;                        /* Count of Frames */
-   int perfect;                  /* Perfect match found? */
-   int score;                    /* Score from latest match */
-   int to_base;                  /* Index of "to" base Frame */
-   int to_current;               /* Index of "to" current Frame */
-   int to_index;                 /* Index of "to" Frame */
-   int to_isframe;               /* "to" is a Frame (not a FrameSet)? */
-   int to_nframe;                /* Number of "to" Frames */
-   int to_number;                /* Loop counter for "to" Frames */
-
-/* Initialise. */
-   result = NULL;
-
-/* Check the global error status. */
-   if ( !astOK ) return result;
-
-/* Initialise variables to avoid "used of uninitialised variable"
-   messages from dumb compilers. */
-   result_map = NULL;
-   iframe_from = 0;
-   iframe_to = 0;
-
-/* Determine the number of Frames in "from" and the indices of its
-   base and current Frames. Use values of 1 if "from" is a Frame and
-   not a FrameSet. */
-   from_isframe = !astIsAFrameSet( from );
-   from_nframe = from_isframe ? 1 : astGetNframe( from );
-   from_base = from_isframe ? 1 : astGetBase( from );
-   from_current = from_isframe ? 1 : astGetCurrent( from );
-
-/* Obtain similar values for "to". */
-   to_isframe = !astIsAFrameSet( to );
-   to_nframe = to_isframe ? 1 : astGetNframe( to );
-   to_base = to_isframe ? 1 : astGetBase( to );
-   to_current = to_isframe ? 1 : astGetCurrent( to );
-
-/* Allocate memory for arrays which will hold the indices of "from"
-   and "to" Frames. */
-   from_order = astMalloc( sizeof( int ) * (size_t) from_nframe );
-   to_order = astMalloc( sizeof( int ) * (size_t) to_nframe );
-
-/* Make a temporary copy of the domains list. */
-   domainlist_copy = astStore( NULL, domainlist,
-                               strlen( domainlist ) + (size_t) 1 );
-   if ( astOK ) {
-
-/* Fill the "from_order" array with the indices of all the Frames in
-   "from", in the order in which they will be used for searching. Use
-   the base Frame first. */
-      n = 0;
-      from_order[ n++ ] = from_base;
-
-/* Then add all the "from" Frames in the appropriate order, omitting
-   the base and current Frames. */
-      if ( !astGetInvert( from ) ) {
-         for ( from_index = 1; from_index <= from_nframe; from_index++ ) {
-            if ( ( from_index != from_base ) &&
-                 ( from_index != from_current ) ) {
-               from_order[ n++ ] = from_index;
-            }
-         }
-      } else {
-         for ( from_index = from_nframe; from_index >= 1; from_index-- ) {
-            if ( ( from_index != from_base ) &&
-                 ( from_index != from_current ) ) {
-               from_order[ n++ ] = from_index;
-            }
-         }
-      }
-
-/* Finish with the current Frame, if different from the base Frame. */
-      if ( from_current != from_base ) from_order[ n++ ] = from_current;
-
-/* Repeat this process for the "to" Frame. */
-      n = 0;
-      to_order[ n++ ] = to_base;
-      if ( !astGetInvert( to ) ) {
-         for ( to_index = 1; to_index <= to_nframe; to_index++ ) {
-            if ( ( to_index != to_base ) && ( to_index != to_current ) ) {
-               to_order[ n++ ] = to_index;
-            }
-         }
-      } else {
-         for ( to_index = to_nframe; to_index >= 1; to_index-- ) {
-            if ( ( to_index != to_base ) && ( to_index != to_current ) ) {
-               to_order[ n++ ] = to_index;
-            }
-         }
-      }
-      if ( to_current != to_base ) to_order[ n++ ] = to_current;
-
-/* Loop to inspect each comma-separated field in the domains list
-   until an error occurs, all the domains are used up, or a match is
-   found. */
-      domain = domainlist_copy;
-      match = 0;
-      while ( astOK && domain && !match ) {
-
-/* Change the comma at the end of each field to a null to terminate
-   the domain. */
-         if ( ( domain_end = strchr( domain, ',' ) ) ) *domain_end = '\0';
-
-/* For any given domain, we will ignore imperfect matches in favour of
-   better ones by assigning a score to each match. Initialise the best
-   score value for the current domain. */
-         best_score = -1;
-
-/* Loop through each Frame in "to". Quit looping early if an error
-   occurs or a perfect match is found. */
-         perfect = 0;
-         for ( to_number = 0;
-               astOK && !perfect && ( to_number < to_nframe );
-               to_number++ ) {
-
-/* Permute the "to" Frame number into a Frame index to implement the
-   required search order, and obtain a pointer to the required "to"
-   Frame. */
-            to_index = to_order[ to_number ];
-            to_frame = to_isframe ? astClone( to ) :
-                                    astGetFrame( to, to_index );
-
-/* Loop through each Frame in "from". Quit looping early if an error
-   occurs or a perfect match is found. */
-            for ( from_number = 0;
-                  astOK && !perfect && ( from_number < from_nframe );
-                  from_number++ ) {
-
-/* Permute the "from" Frame number into a Frame index to implement the
-   required search order, and obtain a pointer to the required "from"
-   Frame. */
-               from_index = from_order[ from_number ];
-               from_frame = from_isframe ? astClone( from ) :
-                                           astGetFrame( from, from_index );
-
-/* Attempt to obtain a FrameSet which describes the conversion between
-   the selected "from" and "to" Frames and test if successful. If so,
-   we have a potential route to construct the overall Mapping we
-   want. */
-               cvt = astConvert( from_frame, to_frame, domain );
-               if ( astOK && cvt ) {
-
-/* Extract the required Mapping from the returned FrameSet. */
-                  map = astGetMapping( cvt, AST__BASE, AST__CURRENT );
-
-/* If necessary, prefix the Mapping between the "from" current Frame
-   and the individual "from" Frame we have selected. */
-                  if ( from_index != from_current ) {
-                     from_map = astGetMapping( from, AST__CURRENT,
-                                               from_index );
-                     tmp = (AstMapping *) astCmpMap( from_map, map, 1, "", status );
-                     from_map = astAnnul( from_map );
-                     map = astAnnul( map );
-                     map = tmp;
-                  }
-
-/* Similarly, if necessary, append the Mapping between the selected
-   "to" Frame and the "to" current Frame. */
-                  if ( to_index != to_current ) {
-                     to_map = astGetMapping( to, to_index, AST__CURRENT );
-                     tmp = (AstMapping *) astCmpMap( map, to_map, 1, "", status );
-                     to_map = astAnnul( to_map );
-                     map = astAnnul( map );
-                     map = tmp;
-                  }
-
-/* Simplify the resulting overall Mapping (this is done here because
-   it may sometimes affect the attribute values used to assign a score
-   below). */
-                  tmp = astSimplify( map );
-                  map = astAnnul( map );
-                  map = tmp;
-
-/* Assign a score that favours Mappings with both transformations
-   available over those with only one, and Mappings with only a
-   forward transformation over those with only an inverse
-   transformation. */
-                  score = ( astGetTranForward( map ) ? 2 : 0 ) +
-                          ( astGetTranInverse( map ) ? 1 : 0 );
-
-/* If the new score is better than the previous one (or is the first
-   one), note that we have a possible match. */
-                  if ( astOK && ( score > best_score ) ) {
-                     match = 1;
-
-/* Update the best score and note if it indicates a perfect match (in
-   which case we can stop searching at this point). */
-                     best_score = score;
-                     perfect = ( best_score >= 3 );
-
-/* Annul any previous result Mapping pointer and replace it with this
-   better one. */
-                     if ( result_map ) result_map = astAnnul( result_map );
-                     result_map = astClone( map );
-
-/* Note which "from" and "to" Frames were used. */
-                     iframe_from = from_index;
-                     iframe_to = to_index;
-                  }
-
-/* Annul pointers to the intermediate Objects. */
-                  map = astAnnul( map );
-                  cvt = astAnnul( cvt );
-               }
-               from_frame = astAnnul( from_frame );
-            }
-            to_frame = astAnnul( to_frame );
-         }
-
-/* Go on to consider the next field in the domains list. */
-         domain = domain_end ? domain_end + 1 : NULL;
-      }
-   }
-
-/* Free the memory allocated for temporary arrays. */
-   domainlist_copy = astFree( domainlist_copy );
-   from_order = astFree( from_order );
-   to_order = astFree( to_order );
-
-/* If a result is being returned, then obtain a pointer to the current
-   "from" Frame and use it to start constructing the result
-   FrameSet. */
-   if ( result_map ) {
-      from_frame = from_isframe ? astClone( from ) :
-                                  astGetFrame( from, AST__CURRENT );
-      result = astFrameSet( from_frame, "", status );
-      from_frame = astAnnul( from_frame );
-
-/* Similarly. obtain a pointer to the current "to" frame and add it to
-   the result FrameSet (related to the base Frame by the result
-   Mapping). */
-      to_frame = to_isframe ? astClone( to ) :
-                              astGetFrame( to, AST__CURRENT );
-      astAddFrame( result, AST__BASE, result_map, to_frame );
-      to_frame = astAnnul( to_frame );
-
-/* Annul the result Mapping pointer. */
-      result_map = astAnnul( result_map );
-   }
-
-/* If successful, and a FrameSet is being returned, then set the base
-   Frames of "from" and "to" (if they are FrameSets) to indicate the
-   route used to generate the result Mapping. */
-   if ( astOK && result ) {
-      if ( !from_isframe ) astSetBase( from, iframe_from );
-      if ( !to_isframe ) astSetBase( to, iframe_to );
-   }
-
-/* If an error occurred, annul the returned FrameSet pointer. */
-   if ( !astOK && result ) result = astAnnul( result );
-
-/* Return the result. */
-   return result;
-}
-
-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 "frameset.h"
-*     double Distance( AstFrame *this,
-*                      const double point1[], const double point2[], int *status )
-
-*  Class Membership:
-*     FrameSet member function (over-rides the protected astDistance
-*     method inherited from the Frame class).
-
-*  Description:
-*     This function finds the distance between two points whose
-*     FrameSet coordinates are given. The distance calculated is that
-*     along the geodesic curve that joins the two points.
-
-*  Parameters:
-*     this
-*        Pointer to the FrameSet.
-*     point1
-*        An array of double, with one element for each FrameSet axis
-*        containing the coordinates of the first point.
-*     point2
-*        An array of double, with one element for each FrameSet axis
-*        containing the coordinates of the second point.
-*     status
-*        Pointer to the inherited status variable.
-
-*  Returned Value:
-*     The distance between the two points.
-
-*  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: */
-   AstFrame *fr;                 /* Pointer to current Frame */
-   AstFrameSet *this;            /* Pointer to the FrameSet structure */
-   double result;                /* Value to return */
-
-/* Check the global error status. */
-   if ( !astOK ) return AST__BAD;
-
-/* Obtain a pointer to the FrameSet structure. */
-   this = (AstFrameSet *) this_frame;
-
-/* Obtain a pointer to the FrameSet's current Frame and invoke this
-   Frame's astDistance method. Annul the Frame pointer afterwards. */
-   fr = astGetFrame( this, AST__CURRENT );
-   result = astDistance( fr, point1, point2 );
-   fr = astAnnul( fr );
-
-/* If an error occurred, clear the result. */
-   if ( !astOK ) result = AST__BAD;
-
-/* Return the result. */
-   return result;
-}
-
-static int Equal( AstObject *this_object, AstObject *that_object, int *status ) {
-/*
-*  Name:
-*     Equal
-
-*  Purpose:
-*     Test if two FrameSets are equivalent.
-
-*  Type:
-*     Private function.
-
-*  Synopsis:
-*     #include "frameset.h"
-*     int Equal( AstObject *this, AstObject *that, int *status )
-
-*  Class Membership:
-*     FrameSet member function (over-rides the astEqual protected
-*     method inherited from the Mapping class).
-
-*  Description:
-*     This function returns a boolean result (0 or 1) to indicate whether
-*     two FrameSets are equivalent.
-
-*  Parameters:
-*     this
-*        Pointer to the first FrameSet.
-*     that
-*        Pointer to the second FrameSet.
-*     status
-*        Pointer to the inherited status variable.
-
-*  Returned Value:
-*     One if the FrameSets are equivalent, zero otherwise.
-
-*  Notes:
-*     - The two FrameSets are considered equivalent if all the encapsulated
-*     Frames are equal and all the encapsulated Mappings are equal.
-*     - 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: */
-   AstFrameSet *that;            /* Pointer to the second FrameSet structure */
-   AstFrameSet *this;            /* Pointer to the first FrameSet structure */
-   int i;                        /* Loop index */
-   int result;                   /* Result value to return */
-
-/* Initialise. */
-   result = 0;
-
-/* Check the global error status. */
-   if ( !astOK ) return result;
-
-/* Checks that the second object is of the same class as the first . */
-   if( !strcmp( astGetClass( this_object ), astGetClass( that_object ) ) ){
-
-/* Obtain pointers to the two FrameSet structures. */
-      this = (AstFrameSet *) this_object;
-      that = (AstFrameSet *) that_object;
-
-/* Check the number of nodes and frames are equal. Also check the indices
-   of the base and current Frames are equal */
-      if( this->nframe == that->nframe &&
-          this->nnode == that->nnode &&
-          this->base == that->base &&
-          this->current == that->current ) {
-
-/* Check the Frames and nodes are equal. */
-          result = 1;
-          for ( i = 0; i < this->nframe; i++ ) {
-             if( !astEqual( this->frame[ i ], that->frame[ i ] ) ||
-                 this->node[ i ] != that->node[ i ] ){
-                result = 0;
-                break;
-             }
-          }
-
-/* Check the Mappings, links and invert flags are equal. */
-         if( result ) {
-            for ( i = 0; i < this->nnode - 1; i++ ) {
-               if( !astEqual( this->map[ i ], that->map[ i ] ) ||
-                   this->link[ i ] != that->link[ i ] ||
-                   this->invert[ i ] != that->invert[ i ] ) {
-                  result = 0;
-                  break;
-               }
-            }
-         }
-      }
-   }
-
-/* If an error occurred, clear the result value. */
-   if ( !astOK ) result = 0;
-
-/* Return the result, */
-   return result;
-}
-
-static int Fields( AstFrame *this_frame, int axis, const char *fmt,
-                   const char *str, int maxfld, char **fields,
-                   int *nc, double *val, int *status ) {
-/*
-*+
-*  Name:
-*     astFields
-
-*  Purpose:
-*     Identify numerical fields within a formatted FrameSet axis value.
-
-*  Type:
-*     Protected virtual function.
-
-*  Synopsis:
-*     #include "frameset.h"
-*     int astFields( AstFrame *this, int axis, const char *fmt,
-*                    const char *str, int maxfld, char **fields,
-*                    int *nc, double *val )
-
-*  Class Membership:
-*     FrameSet member function (over-rides the protected astFields
-*     method inherited from the Frame class).
-
-*  Description:
-*     This function identifies the numerical fields within a FrameSet axis
-*     value that has been formatted using astAxisFormat. It assumes that
-*     the value was formatted using the supplied format string. It also
-*     returns the equivalent floating point value.
-
-*  Parameters:
-*     this
-*        Pointer to the FrameSet.
-*     axis
-*        The number of the FrameSet axis for which the values have been
-*        formatted (axis numbering starts at zero for the first axis).
-*     fmt
-*        Pointer to a constant null-terminated string containing the
-*        format used when creating "str".
-*     str
-*        Pointer to a constant null-terminated string containing the
-*        formatted value.
-*     maxfld
-*        The maximum number of fields to identify within "str".
-*     fields
-*        A pointer to an array of at least "maxfld" character pointers.
-*        Each element is returned holding a pointer to the start of the
-*        corresponding field  in "str" (in the order in which they occur
-*        within "str"), or NULL if no corresponding field can be found.
-*     nc
-*        A pointer to an array of at least "maxfld" integers. Each
-*        element is returned holding the number of characters in the
-*        corresponding field, or zero if no corresponding field can be
-*        found.
-*     val
-*        Pointer to a location at which to store the value
-*        equivalent to the returned field values. If this is NULL,
-*        it is ignored.
-
-*  Returned Value:
-*     The number of fields succesfully identified and returned.
-
-*  Notes:
-*     - Leading and trailing spaces are ignored.
-*     - If the formatted value is not consistent with the supplied format
-*     string, then a value of zero will be returned, "fields" will be
-*     returned holding NULLs, "nc" will be returned holding zeros, and
-*     "val" is returned holding VAL__BAD.
-*     - Fields are counted from the start of the formatted string. If the
-*     string contains more than "maxfld" fields, then trailing fields are
-*     ignored.
-*     - If this function is invoked with the global error status set, or
-*     if it should fail for any reason, then a value of zero will be returned
-*     as the function value, and "fields", "nc" and "val"  will be returned
-*     holding their supplied values
-*-
-*/
-
-/* Local Variables: */
-   AstFrame *fr;                 /* Pointer to current Frame */
-   AstFrameSet *this;            /* Pointer to the FrameSet structure */
-   int result;                   /* Result field count to return */
-
-/* Check the global error status. */
-   if ( !astOK ) return 0;
-
-/* Obtain a pointer to the FrameSet structure. */
-   this = (AstFrameSet *) this_frame;
-
-/* Validate the axis index. */
-   (void) astValidateAxis( this, axis, 1, "astFields" );
-
-/* Obtain a pointer to the FrameSet's current Frame and invoke this
-   Frame's astFields method to perform the processing. Annul the Frame
-   pointer afterwards. */
-   fr = astGetFrame( this, AST__CURRENT );
-   result = astFields( fr, axis, fmt, str, maxfld, fields, nc, val );
-   fr = astAnnul( fr );
-
-/* If an error occurred, clear the result. */
-   if ( !astOK ) result = 0;
-
-/* Return the result. */
-   return result;
-}
-
-static AstFrameSet *FindFrame( AstFrame *target_frame, AstFrame *template,
-                               const char *domainlist, int *status ) {
-/*
-*  Name:
-*     FindFrame
-
-*  Purpose:
-*     Find a coordinate system with specified characteristics.
-
-*  Type:
-*     Private function.
-
-*  Synopsis:
-*     #include "frameset.h"
-*     AstFrameSet *FindFrame( AstFrame *target, AstFrame *template,
-*                             const char *domainlist, int *status )
-
-*  Class Membership:
-*     FrameSet member function (over-rides the astFindFrame method
-*     inherited from the Frame class).
-
-*  Description:
-*     This function uses a "template" Frame to search a FrameSet to
-*     identify a coordinate system which has a specified set of
-*     characteristics. If a suitable coordinate system can be found,
-*     the function returns a pointer to a FrameSet which describes the
-*     required coordinate system and how to convert coordinates to and
-*     from it.
-
-*  Parameters:
-*     target
-*        Pointer to the target FrameSet.  Note that if a suitable
-*        coordinate system is found, then the FrameSet's Current
-*        attribute will be modified to indicate which Frame was used
-*        to obtain attribute values which were not specified by the
-*        template.
-*     template
-*        Pointer to the template Frame, which should be an instance of
-*        the type of Frame you wish to find.
-*     domainlist
-*        Pointer to a null-terminated character string containing a
-*        comma-separated list of Frame domains. This may be used to
-*        establish a priority order for the different types of
-*        coordinate system that might be found.
-*
-*        The function will first try to find a suitable coordinate
-*        system whose Domain attribute equals the first domain in this
-*        list. If this fails, the second domain in the list will be
-*        used, and so on, until a result is obtained. A blank domain
-*        (e.g. two consecutive commas) indicates that any coordinate
-*        system is acceptable (subject to the template) regardless of
-*        its domain.
-*
-*        This list is case-insensitive and all white space is ignored.
-*        If you do not wish to restrict the domain in this way, you
-*        should supply an empty string.
-*     status
-*        Pointer to the inherited status variable.
-
-*  Returned Value:
-*     If the search is successful, the function returns a pointer to a
-*     FrameSet which contains the Frame found and a description of how
-*     to convert to (and from) the coordinate system it
-*     represents. Otherwise, a null Object pointer (AST__NULL) is
-*     returned without error.
-*
-*     If a FrameSet is returned, it will contain two Frames. Frame
-*     number 1 (its base Frame) represents the target coordinate
-*     system and will be the same as the (base Frame of the)
-*     target. Frame number 2 (its current Frame) will be a Frame
-*     representing the coordinate system which the function found. The
-*     Mapping which inter-relates these two Frames will describe how
-*     to convert between their respective coordinate systems.
-
-*  Notes:
-*     - A null Object pointer (AST__NULL) will be returned if this
-*     function is invoked with the AST error status set, or if it
-*     should fail for any reason.
-*/
-
-/* Local Variables: */
-   AstFrame *base_frame;         /* Pointer to target base Frame */
-   AstFrame *frame;              /* Pointer to result Frame */
-   AstFrame *selected_frame;     /* Pointer to selected target Frame */
-   AstFrameSet *found;           /* FrameSet pointer (result of search) */
-   AstFrameSet *result;          /* Pointer to result FrameSet */
-   AstFrameSet *target;          /* Pointer to target FrameSet structure */
-   AstMapping *map;              /* Pointer to result Mapping */
-   AstMapping *prefix;           /* Pointer to prefix Mapping */
-   AstMapping *tmp;              /* Temporary Mapping pointer */
-   char *domain;                 /* Pointer to individual domain field */
-   char *domain_end;             /* Pointer to null at end of domain */
-   char *domainlist_copy;        /* Pointer to copy of domains list */
-   int *target_order;            /* Array of indices defining search order */
-   int match;                    /* Match obtained? */
-   int n;                        /* Count of target_order elements */
-   int target_base;              /* Index of target base Frame */
-   int target_current;           /* Index of target current Frame */
-   int target_index;             /* Index of selected target Frame */
-   int target_nframe;            /* Number of Frames in target FrameSet */
-   int target_number;            /* Loop index for search */
-
-/* Initialise. */
-   result = NULL;
-
-/* Check the global error status. */
-   if ( !astOK ) return result;
-
-/* Initialise variables to avoid "used of uninitialised variable"
-   messages from dumb compilers. */
-   target_index = 0;
-
-/* Obtain a pointer to the target FrameSet structure. */
-   target = (AstFrameSet *) target_frame;
-
-/* Determine the number of Frames in the target FrameSet and the
-   indices of the current and base Frames. */
-   target_nframe = astGetNframe( target );
-   target_current = astGetCurrent( target );
-   target_base = astGetBase( target );
-
-/* Allocate an array to hold a list of all the target Frame indices. */
-   target_order = astMalloc( sizeof( int ) * (size_t) target_nframe );
-
-/* Make a temporary copy of the domains list. */
-   domainlist_copy = astStore( NULL, domainlist,
-                               strlen( domainlist ) + (size_t) 1 );
-   if ( astOK ) {
-
-/* Form a list of the indices of all the Frames in the target in the
-   order they will be searched for a match. Add the current Frame
-   index first. */
-      n = 0;
-      target_order[ n++ ] = target_current;
-
-/* Follow this by the base Frame index, if different. */
-      if ( target_base != target_current ) target_order[ n++ ] = target_base;
-
-/* Then add all the remaining target Frame indices. */
-      for ( target_index = 1; target_index <= target_nframe; target_index++ ) {
-         if ( ( target_index != target_current ) &&
-              ( target_index != target_base ) ) {
-            target_order[ n++ ] = target_index;
-         }
-      }
-
-/* Loop to inspect each comma-separated field in the domains list
-   until an error occurs, all the domains are used up, or a match is
-   found. */
-      domain = domainlist_copy;
-      match = 0;
-      while ( astOK && domain && !match ) {
-
-/* Change the comma at the end of each field to a null to terminate
-   the domain. */
-         if ( ( domain_end = strchr( domain, ',' ) ) ) *domain_end = '\0';
-
-/* Loop to try and match each target Frame in turn, in the order
-   identified above. Quit the loop early if an error occurs or a match
-   is found. */
-         for ( target_number = 0;
-               astOK && !match && ( target_number < target_nframe );
-               target_number++ ) {
-
-/* Permute the target Frame number into a Frame index to implement the
-   required search order. Then obtain a pointer to the selected target
-   Frame. */
-            target_index = target_order[ target_number ];
-            selected_frame = astGetFrame( target, target_index );
-
-/* Search the target Frame using the template supplied, together with
-   the current domain. */
-            found = astFindFrame( selected_frame, template, domain );
-
-/* Note if a match is found, and extract pointers to the conversion
-   Mapping and the result Frame from the FrameSet produced. */
-            if ( astOK && found ) {
-               match = 1;
-               map = astGetMapping( found, AST__BASE, AST__CURRENT );
-               frame = astGetFrame( found, AST__CURRENT );
-
-/* Obtain a pointer to the Mapping between the target base Frame and
-   the selected target Frame, and prefix this Mapping to the one
-   obtained above. */
-               prefix = astGetMapping( target, AST__BASE, target_index );
-               tmp = (AstMapping *) astCmpMap( prefix, map, 1, "", status );
-               prefix = astAnnul( prefix );
-               map = astAnnul( map );
-               map = tmp;
-
-/* Simplify the resulting Mapping. */
-               tmp = astSimplify( map );
-               map = astAnnul( map );
-               map = tmp;
-
-/* Obtain a pointer to the target base Frame, and use this to start
-   building the result FrameSet. */
-               base_frame = astGetFrame( target, AST__BASE );
-               result = astFrameSet( base_frame, "", status );
-               base_frame = astAnnul( base_frame );
-
-/* Add the result Frame, which is related to the base Frame by the
-   result Mapping. */
-               astAddFrame( result, AST__BASE, map, frame );
-
-/* Annul pointers to all intermediate Objects. */
-               map = astAnnul( map );
-               frame = astAnnul( frame );
-               found = astAnnul( found );
-            }
-            selected_frame = astAnnul( selected_frame );
-         }
-
-/* Go on to consider the next field in the domains list. */
-         domain = domain_end ? domain_end + 1 : NULL;
-      }
-   }
-
-/* Free the temporary arrays. */
-   target_order = astFree( target_order );
-   domainlist_copy = astFree( domainlist_copy );
-
-/* If a result is being returned, set the current Frame of the target
-   to indicate where the result Frame was found. */
-   if ( astOK && result ) astSetCurrent( target, target_index );
-
-/* If an error occurred, annul any result FrameSet pointer. */
-   if ( !astOK && result ) result = astAnnul( result );
-
-/* Return the result. */
-   return result;
-}
-
-static AstPointSet *FrameGrid( AstFrame *this_frame, 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 "frameset.h"
-*     AstPointSet *FrameGrid( AstFrame *this_frame, int size,
-*                             const double *lbnd, const double *ubnd,
-*                             int *status )
-
-*  Class Membership:
-*     FrameSet 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: */
-   AstFrame *fr;                 /* Pointer to current Frame */
-   AstFrameSet *this;            /* Pointer to the FrameSet structure */
-   AstPointSet *result;          /* Value to return */
-
-/* Check the global error status. */
-   if ( !astOK ) return NULL;
-
-/* Obtain a pointer to the FrameSet structure. */
-   this = (AstFrameSet *) this_frame;
-
-/* Obtain a pointer to the FrameSet's current Frame and invoke this
-   Frame's astFrameGrid method. Annul the Frame pointer afterwards. */
-   fr = astGetFrame( this, AST__CURRENT );
-   result = astFrameGrid( fr, size, lbnd, ubnd );
-   fr = astAnnul( fr );
-
-/* If an error occurred, clear the result. */
-   if ( !astOK ) result = astAnnul( result );
-
-/* Return the result. */
-   return result;
-}
-
-static int ForceCopy( AstFrameSet *this, int iframe, int *status ) {
-/*
-*  Name:
-*     ForceCopy
-
-*  Purpose:
-*     Force a copy to be made of a Frame, if necessary.
-
-*  Type:
-*     Private function.
-
-*  Synopsis:
-*     #include "frameset.h"
-*     int ForceCopy( AstFrameSet *this, int iframe, int *status )
-
-*  Class Membership:
-*     FrameSet member function.
-
-*  Description:
-*     This function examines a Frame within a FrameSet, identified by its
-*     Frame index. If the same Frame is found to be referenced a second time
-*     within the FrameSet, then the original reference is replaced with an
-*     independent copy of the Frame.
-*
-*     This process supports the preservation of FrameSet integrity in cases
-*     where the same Frame is referenced more than once. After using this
-*     function, the nominated Frame's attributes may be modified without
-*     danger of affecting other parts of the FrameSet.
-
-*  Parameters:
-*     this
-*        Pointer to the FrameSet.
-*     iframe
-*        The index of the Frame to be examined.
-*     status
-*        Pointer to the inherited status variable.
-
-*  Returned Value:
-*     One if a copy of the nominated Frame was made, otherwise zero.
-
-*  Notes:
-*     - Using this function a second time on the same Frame will have no
-*     effect, since the first usage will make the Frame independent of any
-*     other Frames within the FrameSet.
-*     - 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: */
-   astDECLARE_GLOBALS           /* Declare the thread specific global data */
-   AstFrame *frame;             /* Pointer to Frame */
-   AstFrame *tmp;               /* Temporary Frame pointer */
-   int ifr;                     /* Loop counter for Frames */
-   int result;                  /* Value to return */
-
-/* Initialise. */
-   result = 0;
-
-/* Check the global error status. */
-   if ( !astOK ) return result;
-
-/* Get a pointer to the structure holding thread-specific global data. */
-   astGET_GLOBALS(this);
-
-/* Validate and translate the Frame index supplied. */
-   iframe = astValidateFrameIndex( this, iframe, integrity_method );
-
-/* If OK, obtain the corresponding Frame pointer (don't clone it). */
-   if ( astOK ) {
-      frame = this->frame[ iframe - 1 ];
-
-/* Loop to inspect each Frame in the FrameSet. */
-      for ( ifr = 1; ifr <= this->nframe; ifr++ ) {
-
-/* If the same Frame is referenced anywhere else, then make a copy of it. */
-         if ( ( ifr != iframe ) && ( this->frame[ ifr - 1 ] == frame ) ) {
-            tmp = astCopy( frame );
-
-/* If successful, replace the original reference to the Frame with a pointer
-   to this copy and annul the original pointer. */
-            if ( astOK ) {
-               this->frame[ iframe - 1 ] = tmp;
-               frame = astAnnul( frame );
-
-/* Set the returned result. */
-               if ( astOK ) result = 1;
-            }
-
-/* Quit looping once a copy has been made. */
-            break;
-         }
-      }
-   }
-
-/* 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 FrameSet axis.
-
-*  Type:
-*     Private function.
-
-*  Synopsis:
-*     #include "frameset.h"
-*     const char *Format( AstFrame *this, int axis, double value, int *status )
-
-*  Class Membership:
-*     FrameSet 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
-*     FrameSet axis. The formatting applied is that specified by a
-*     previous invocation of the astSetFormat method. A suitable
-*     default format is applied if necessary.
-
-*  Parameters:
-*     this
-*        Pointer to the FrameSet.
-*     axis
-*        The number of the axis (zero-based) for which formatting is
-*        to be performed.
-*     value
-*        The coordinate value to be formatted.
-*     status
-*        Pointer to the inherited status variable.
-
-*  Returned Value:
-*     A pointer to a null-terminated string containing the formatted
-*     value.
-
-*  Notes:
-*     - The returned string pointer may point at memory allocated
-*     within the FrameSet object, or at static memory. The contents of
-*     the string may be over-written or the pointer may become invalid
-*     following a further invocation of the same function or deletion
-*     of the FrameSet. 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: */
-   AstFrame *fr;                 /* Pointer to current Frame */
-   AstFrameSet *this;            /* Pointer to the FrameSet structure */
-   const char *result;           /* Pointer value to return */
-
-/* Check the global error status. */
-   if ( !astOK ) return NULL;
-
-/* Obtain a pointer to the FrameSet structure. */
-   this = (AstFrameSet *) this_frame;
-
-/* Validate the axis index. */
-   (void) astValidateAxis( this, axis, 1, "astFormat" );
-
-/* Obtain a pointer to the FrameSet's current Frame and invoke the
-   astFormat method for this Frame. Annul the Frame pointer
-   afterwards. */
-   fr = astGetFrame( this, AST__CURRENT );
-   result = astFormat( fr, axis, value );
-   fr = astAnnul( fr );
-
-/* If an error occurred, clear the result value. */
-   if ( !astOK ) result = NULL;
-
-/* Return the result. */
-   return result;
-}
-
-static double Gap( AstFrame *this_frame, int axis, double gap, int *ntick, int *status ) {
-/*
-*  Name:
-*     Gap
-
-*  Purpose:
-*     Find a "nice" gap for tabulating FrameSet axis values.
-
-*  Type:
-*     Private function.
-
-*  Synopsis:
-*     #include "frameset.h"
-*     double Gap( AstFrame *this, int axis, double gap, int *ntick, int *status )
-
-*  Class Membership:
-*     FrameSet 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 FrameSet 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 FrameSet.
-*     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: */
-   AstFrame *fr;                 /* Pointer to current Frame */
-   AstFrameSet *this;            /* Pointer to the FrameSet structure */
-   double result;                /* Gap value to return */
-
-/* Check the global error status. */
-   if ( !astOK ) return 0.0;
-
-/* Obtain a pointer to the FrameSet structure. */
-   this = (AstFrameSet *) this_frame;
-
-/* Validate the axis index. */
-   (void) astValidateAxis( this, axis, 1, "astGap" );
-
-/* Obtain a pointer to the FrameSet's current Frame and invoke this
-   Frame's astGap method to obtain the required gap value. Annul the
-   Frame pointer afterwards. */
-   fr = astGetFrame( this, AST__CURRENT );
-   result = astGap( fr, axis, gap, ntick );
-   fr = astAnnul( fr );
-
-/* If an error occurred, clear the result. */
-   if ( !astOK ) result = 0.0;
-
-/* Return the result. */
-   return result;
-}
-
-static int GetNode( AstFrameSet *this, int inode, int *nnodes,
-                    int *iframe, AstMapping **map, int *parent,
-                    int *status ) {
-/*
-*+
-*  Name:
-*     astGetNode
-
-*  Purpose:
-*     Get information about a single node in a FrameSet tree.
-
-*  Type:
-*     Protected virtual function.
-
-*  Synopsis:
-*     #include "frameset.h"
-*     int astGetNode( AstFrameSet *this, int inode, int *nnodes,
-*                     int *iframe, AstMapping **map, int *parent )
-
-*  Class Membership:
-*     FrameSet method.
-
-*  Description:
-*     This function returns information about a specified node in a
-*     FrameSet. It is documented as protected, because it should not
-*     be used in general purpose software since it depends on the internal
-*     details of the FrameSet class.  However, it is in fact public so that
-*     it can be used in external software that needs to know about the
-*     internal structure of a FrameSet (for instance, a graphical FrameSet
-*     visualisation system).
-
-*  Parameters:
-*     this
-*        Pointer to the FrameSet.
-*     inode
-*        The zero-based index of the required node.
-*     nnodes
-*        Address of an int returned holding the number of nodes defined
-*        in the FrameSet.
-*     iframe
-*        Address of an int returned holding the one-based index of the
-*        Frame associated with the node. AST__NOFRAME is returned if the
-*        node has no Frame.
-*     map
-*        Address of a Mapping pointer returned holding a pointer to a
-*        deep copy of the Mapping, if any, from the parent node to the
-*        requested node. NULL is returned if the node has no parent.
-*     parent
-*        Address of an int returned holding the zero-based index of the
-*        node from which the requested node is derived. -1 is returned if
-*        the requested node has no parent (i.e. is the root of the tree).
-
-*  Returned Value:
-*     A non-zero value is returned if the "inode" value is within bounds.
-*     Otherwise, zero is returned.
-
-*-
-*/
-
-/* Local Variables: */
-   int jframe;
-   int result;
-
-/* Initialise returned values. */
-   *nnodes = 0;
-   *iframe = AST__NOFRAME;
-   *map = NULL;
-   *parent = -1;
-   result = 0;
-
-/* Check the global error status. */
-   if ( !astOK ) return result;
-
-/* Return the number of nodes. */
-   *nnodes = this->nnode;
-
-/* Check the index of the requested node. */
-   if( inode >= 0 && inode < this->nnode ) {
-
-/* Get the index of the Frame - if any - associated with the node. */
-      for( jframe = 0; jframe < this->nframe; jframe++ ) {
-         if( this->node[ jframe ] == inode ) {
-            *iframe = jframe + 1;
-            break;
-         }
-      }
-
-/* Get the Mapping - if any - associated with the node. The root node -
-   node zero - has no mapping or parent node. */
-      if( inode > 0 ) {
-         *map = astCopy( this->map[ inode - 1 ] );
-         if( astGetInvert( *map ) !=  this->invert[ inode - 1 ] ) {
-            astSetInvert( *map,  this->invert[ inode - 1 ] );
-         }
-
-/* The index of the parent node. */
-         *parent = this->link[ inode - 1 ];
-      }
-
-/* Indicate success. */
-      result = 1;
-   }
-
-   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 "frameset.h"
-*     int GetObjSize( AstObject *this, int *status )
-
-*  Class Membership:
-*     FrameSet member function (over-rides the astGetObjSize protected
-*     method inherited from the parent class).
-
-*  Description:
-*     This function returns the in-memory size of the supplied FrameSet,
-*     in bytes.
-
-*  Parameters:
-*     this
-*        Pointer to the FrameSet.
-*     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: */
-   AstFrameSet *this;         /* Pointer to FrameSet structure */
-   int result;                /* Result value to return */
-   int iframe;                /* Loop counter for Frames */
-   int inode;                 /* Loop counter for nodes */
-
-/* Initialise. */
-   result = 0;
-
-/* Check the global error status. */
-   if ( !astOK ) return result;
-
-/* Obtain a pointers to the FrameSet structure. */
-   this = (AstFrameSet *) 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 );
-
-   for ( iframe = 0; iframe < this->nframe; iframe++ ) {
-      result += astGetObjSize( this->frame[ iframe ] );
-   }
-
-   for ( inode = 0; inode < this->nnode - 1; inode++ ) {
-      result += astGetObjSize( this->map[ inode ] );
-   }
-
-   result += astTSizeOf( this->frame );
-   result += astTSizeOf( this->varfrm );
-   result += astTSizeOf( this->node );
-   result += astTSizeOf( this->map );
-   result += astTSizeOf( this->link );
-   result += astTSizeOf( this->invert );
-
-/* If an error occurred, clear the result value. */
-   if ( !astOK ) result = 0;
-
-/* Return the result, */
-   return result;
-}
-
-static const char *GetAttrib( AstObject *this_object, const char *attrib, int *status ) {
-/*
-*  Name:
-*     GetAttrib
-
-*  Purpose:
-*     Get the value of a specified attribute for a FrameSet.
-
-*  Type:
-*     Private function.
-
-*  Synopsis:
-*     #include "frameset.h"
-*     const char *GetAttrib( AstObject *this, const char *attrib, int *status )
-
-*  Class Membership:
-*     FrameSet 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 FrameSet, formatted as a character string.
-
-*  Parameters:
-*     this
-*        Pointer to the FrameSet.
-*     attrib
-*        Pointer to a null-terminated string containing the name of
-*        the attribute whose value is required. This name should be in
-*        lower case, with all white space removed.
-*     status
-*        Pointer to the inherited status variable.
-
-*  Returned Value:
-*     - Pointer to a null-terminated string containing the attribute
-*     value.
-
-*  Notes:
-*     - The returned string pointer may point at memory allocated
-*     within the FrameSet, 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 FrameSet. 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 */
-   AstFrame *fr;                 /* Pointer to current Frame */
-   AstFrameSet *this;            /* Pointer to the FrameSet structure */
-   const char *result;           /* Pointer value to return */
-   int base;                     /* Base attribute value */
-   int current;                  /* Current attribute value */
-   int invert;                   /* Invert attribute value */
-   int nframe;                   /* Nframe attribute value */
-   int nin;                      /* Nin attribute value */
-   int nobject;                  /* Nobject attribute value */
-   int nout;                     /* Nout attribute value */
-   int ref_count;                /* RefCount attribute value */
-   int report;                   /* Report attribute value */
-   int tranforward;              /* TranForward attribute value */
-   int traninverse;              /* TranInverse attribute value */
-
-/* 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 FrameSet structure. */
-   this = (AstFrameSet *) this_object;
-
-/* Compare "attrib" with each recognised attribute name in turn,
-   obtaining the value of the required attribute. If necessary, write
-   the value into "getattrib_buff" as a null-terminated string in an appropriate
-   format.  Set "result" to point at the result string. */
-
-/* We first handle attributes that apply to the FrameSet as a whole
-   (rather than to the current Frame). */
-
-/* AllVariants. */
-/* ------------ */
-   if ( !strcmp( attrib, "allvariants" ) ) {
-      result = astGetAllVariants( this );
-
-/* Base. */
-/* ----- */
-   } else if ( !strcmp( attrib, "base" ) ) {
-      base = astGetBase( this );
-      if ( astOK ) {
-         (void) sprintf( getattrib_buff, "%d", base );
-         result = getattrib_buff;
-      }
-
-/* Class. */
-/* ------ */
-   } else if ( !strcmp( attrib, "class" ) ) {
-      result = astGetClass( this );
-
-/* Current. */
-/* -------- */
-   } else if ( !strcmp( attrib, "current" ) ) {
-      current = astGetCurrent( this );
-      if ( astOK ) {
-         (void) sprintf( getattrib_buff, "%d", current );
-         result = getattrib_buff;
-      }
-
-/* ID. */
-/* --- */
-   } else if ( !strcmp( attrib, "id" ) ) {
-      result = astGetID( this );
-
-/* Ident. */
-/* ------ */
-   } else if ( !strcmp( attrib, "ident" ) ) {
-      result = astGetIdent( this );
-
-/* Invert. */
-/* ------- */
-   } else if ( !strcmp( attrib, "invert" ) ) {
-      invert = astGetInvert( this );
-      if ( astOK ) {
-         (void) sprintf( getattrib_buff, "%d", invert );
-         result = getattrib_buff;
-      }
-
-/* Nframe. */
-/* ------- */
-   } else if ( !strcmp( attrib, "nframe" ) ) {
-      nframe = astGetNframe( this );
-      if ( astOK ) {
-         (void) sprintf( getattrib_buff, "%d", nframe );
-         result = getattrib_buff;
-      }
-
-/* Nin. */
-/* ---- */
-   } else if ( !strcmp( attrib, "nin" ) ) {
-      nin = astGetNin( this );
-      if ( astOK ) {
-         (void) sprintf( getattrib_buff, "%d", nin );
-         result = getattrib_buff;
-      }
-
-/* Nobject. */
-/* -------- */
-   } else if ( !strcmp( attrib, "nobject" ) ) {
-      nobject = astGetNobject( this );
-      if ( astOK ) {
-         (void) sprintf( getattrib_buff, "%d", nobject );
-         result = getattrib_buff;
-      }
-
-/* Nout. */
-/* ----- */
-   } else if ( !strcmp( attrib, "nout" ) ) {
-      nout = astGetNout( this );
-      if ( astOK ) {
-         (void) sprintf( getattrib_buff, "%d", nout );
-         result = getattrib_buff;
-      }
-
-/* RefCount. */
-/* --------- */
-   } else if ( !strcmp( attrib, "refcount" ) ) {
-      ref_count = astGetRefCount( this );
-      if ( astOK ) {
-         (void) sprintf( getattrib_buff, "%d", ref_count );
-         result = getattrib_buff;
-      }
-
-/* Report. */
-/* ------- */
-   } else if ( !strcmp( attrib, "report" ) ) {
-      report = astGetReport( this );
-      if ( astOK ) {
-         (void) sprintf( getattrib_buff, "%d", report );
-         result = getattrib_buff;
-      }
-
-/* TranForward. */
-/* ------------ */
-   } else if ( !strcmp( attrib, "tranforward" ) ) {
-      tranforward = astGetTranForward( this );
-      if ( astOK ) {
-         (void) sprintf( getattrib_buff, "%d", tranforward );
-         result = getattrib_buff;
-      }
-
-/* TranInverse. */
-/* ------------ */
-   } else if ( !strcmp( attrib, "traninverse" ) ) {
-      traninverse = astGetTranInverse( this );
-      if ( astOK ) {
-         (void) sprintf( getattrib_buff, "%d", traninverse );
-         result = getattrib_buff;
-      }
-
-/* Variant. */
-/* -------- */
-   } else if ( !strcmp( attrib, "variant" ) ) {
-      result = astGetVariant( this );
-
-/* Pass unrecognised attributes on to the FrameSet's current Frame for
-   further interpretation. */
-   } else {
-
-/* Obtain a pointer to the current Frame and invoke its astGetAttrib
-   method. Annul the Frame pointer afterwards. */
-      fr = astGetFrame( this, AST__CURRENT );
-      result = astGetAttrib( fr, attrib );
-      fr = astAnnul( fr );
-   }
-
-/* If an error occurred, clear the result value. */
-   if ( !astOK ) result = NULL;
-
-/* Return the result. */
-   return result;
-}
-
-static AstAxis *GetAxis( AstFrame *this_frame, int axis, int *status ) {
-/*
-*  Name:
-*     GetAxis
-
-*  Purpose:
-*     Obtain a pointer to a specified Axis from a FrameSet.
-
-*  Type:
-*     Private function.
-
-*  Synopsis:
-*     #include "frameset.h"
-*     AstAxis *GetAxis( AstFrame *this, int axis, int *status )
-
-*  Class Membership:
-*     FrameSet member function (over-rides the astGetAxis method
-*     inherited from the Frame class).
-
-*  Description:
-*     This function returns a pointer to the Axis object associated
-*     with one of the axes of the current Frame of a FrameSet. This
-*     object describes the quantity which is represented along that
-*     axis.
-
-*  Parameters:
-*     this
-*        Pointer to the FrameSet.
-*     axis
-*        The number of the axis (zero-based) for which an Axis pointer
-*        is required.
-*     status
-*        Pointer to the inherited status variable.
-
-*  Returned Value:
-*     A pointer to the requested Axis object.
-
-*  Notes:
-*     - The reference count of the requested Axis object will be
-*     incremented by one to reflect the additional pointer returned by
-*     this function.
-*     - A NULL pointer will be returned if this function is invoked
-*     with the global error status set, or if it should fail for any
-*     reason.
-*/
-
-/* Local Variables: */
-   AstAxis *result;              /* Pointer to Axis */
-   AstFrame *fr;                 /* Pointer to current Frame */
-   AstFrameSet *this;            /* Pointer to the FrameSet structure */
-
-/* Check the global error status. */
-   if ( !astOK ) return NULL;
-
-/* Obtain a pointer to the FrameSet structure. */
-   this = (AstFrameSet *) this_frame;
-
-/* Validate the axis index. */
-   (void) astValidateAxis( this, axis, 1, "astGetAxis" );
-
-/* Obtain a pointer to the FrameSet's current Frame and invoke this
-   Frame's astGetAxis method to obtain the required Axis
-   pointer. Annul the Frame pointer afterwards. */
-   fr = astGetFrame( this, AST__CURRENT );
-   result = astGetAxis( fr, axis );
-   fr = astAnnul( fr );
-
-/* If an error occurred, annul the result. */
-   if ( !astOK ) result = astAnnul( result );
-
-/* Return the result. */
-   return result;
-}
-
-static int GetBase( AstFrameSet *this, int *status ) {
-/*
-*+
-*  Name:
-*     astGetBase
-
-*  Purpose:
-*     Obtain the value of the Base attribute for a FrameSet.
-
-*  Type:
-*     Protected virtual function.
-
-*  Synopsis:
-*     #include "frameset.h"
-*     int astGetBase( AstFrameSet *this )
-
-*  Class Membership:
-*     FrameSet method.
-
-*  Description:
-*     This function returns the value of the Base attribute for a
-*     FrameSet. This value is an index that identifies the base Frame
-*     in the FrameSet.
-
-*  Parameters:
-*     this
-*        Pointer to the FrameSet.
-
-*  Returned Value:
-*     The Base attribute value.
-
-*  Notes:
-*     - A value of zero will be returned if this function is invoked
-*     with the global status set, or if it should fail for any reason.
-*-
-*/
-
-/* Local Variables: */
-   int invert;                   /* FrameSet is inverted? */
-   int result;                   /* Value to return */
-
-/* Initialise */
-   result = 0;
-
-/* Check the global error status. */
-   if ( !astOK ) return result;
-
-/* Determine if the FrameSet has been inverted. */
-   invert = astGetInvert( this );
-
-/* If it has not been inverted, return the base Frame index, otherwise
-   return the index of the current Frame instead. Provide defaults if
-   necessary. */
-   if ( astOK ) {
-      if ( !invert ) {
-         result = ( this->base != -INT_MAX ) ? this->base : 1;
-      } else {
-         result = ( this->current != -INT_MAX ) ? this->current :
-                                                  astGetNframe( this );
-      }
-   }
-
-/* If an error occurred, clear the result. */
-   if ( !astOK ) result = 0;
-
-/* Return the result. */
-   return result;
-}
-
-static int GetCurrent( AstFrameSet *this, int *status ) {
-/*
-*+
-*  Name:
-*     astGetCurrent
-
-*  Purpose:
-*     Obtain the value of the Current attribute for a FrameSet.
-
-*  Type:
-*     Protected function.
-
-*  Synopsis:
-*     #include "frameset.h"
-*     int astGetCurrent( AstFrameSet *this )
-
-*  Class Membership:
-*     FrameSet method.
-
-*  Description:
-*     This function returns the value of the Current attribute for a
-*     FrameSet.  This attribute is an index that identifies the
-*     current Frame in a FrameSet.
-
-*  Parameters:
-*     this
-*        Pointer to the FrameSet.
-
-*  Returned Value:
-*     Value of the Current attribute.
-
-*  Notes:
-*     - A value of zero will be returned if this function is invoked
-*     with the global status set, or if it should fail for any reason.
-*-
-*/
-
-/* Local Variables: */
-   int invert;                   /* FrameSet is inverted? */
-   int result;                   /* Value to return */
-
-/* Initialise */
-   result = 0;
-
-/* Check the global error status. */
-   if ( !astOK ) return result;
-
-/* Determine if the FrameSet has been inverted. */
-   invert = astGetInvert( this );
-
-/* If it has not been inverted, return the current Frame index,
-   otherwise return the index of the base Frame instead. Provide
-   defaults if necessary. */
-   if ( astOK ) {
-      if ( !invert ) {
-         result = ( this->current != -INT_MAX ) ? this->current :
-                                                  astGetNframe( this );
-      } else {
-         result = ( this->base != -INT_MAX ) ? this->base : 1;
-      }
-   }
-
-/* If an error occurred, clear the result. */
-   if ( !astOK ) result = 0;
-
-/* Return the result. */
-   return result;
-}
-
-static AstFrame *GetFrame( AstFrameSet *this, int iframe, int *status ) {
-/*
-*++
-*  Name:
-c     astGetFrame
-f     AST_GETFRAME
-
-*  Purpose:
-*     Obtain a pointer to a specified Frame in a FrameSet.
-
-*  Type:
-*     Public virtual function.
-
-*  Synopsis:
-c     #include "frameset.h"
-c     AstFrame *astGetFrame( AstFrameSet *this, int iframe )
-f     RESULT = AST_GETFRAME( THIS, IFRAME, STATUS )
-
-*  Class Membership:
-*     FrameSet method.
-
-*  Description:
-*     This function returns a pointer to a specified Frame in a
-*     FrameSet.
-
-*  Parameters:
-c     this
-f     THIS = INTEGER (Given)
-*        Pointer to the FrameSet.
-c     iframe
-f     IFRAME = INTEGER (Given)
-*        The index of the required Frame within the FrameSet.  This
-*        value should lie in the range from 1 to the number of Frames
-*        in the FrameSet (as given by its Nframe attribute).
-f     STATUS = INTEGER (Given and Returned)
-f        The global status.
-
-*  Returned Value:
-c     astGetFrame()
-f     AST_GETFRAME = INTEGER
-*        A pointer to the requested Frame.
-
-*  Notes:
-*     - A value of AST__BASE or AST__CURRENT may be given for the
-c     "iframe" parameter to specify the base Frame or the current
-f     IFRAME argument to specify the base Frame or the current
-*     Frame respectively.
-*     - This function increments the RefCount attribute of the
-*     selected Frame by one.
-*     - 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: */
-   AstFrame *result;             /* Pointer value to return */
-
-/* Initialise. */
-   result = NULL;
-
-/* Check the global error status. */
-   if ( !astOK ) return result;
-
-/* Validate and translate the Frame index supplied. */
-   iframe = astValidateFrameIndex( this, iframe, "astGetFrame" );
-
-/* If OK, clone a pointer to the requested Frame. */
-   if ( astOK ) result = astClone( this->frame[ iframe - 1 ] );
-
-/* Return the result. */
-   return result;
-}
-
-static int GetIsLinear( AstMapping *this_mapping, int *status ){
-/*
-*  Name:
-*     GetIsLinear
-
-*  Purpose:
-*     Return the value of the IsLinear attribute for a FrameSet.
-
-*  Type:
-*     Private function.
-
-*  Synopsis:
-*     #include "mapping.h"
-*     void GetIsLinear( AstMapping *this, int *status )
-
-*  Class Membership:
-*     FrameSet member function (over-rides the protected astGetIsLinear
-*     method inherited from the Mapping class).
-
-*  Description:
-*     This function returns the value of the IsLinear attribute for a
-*     FrameSet, which is the IsLinear value of he base->current Mapping.
-
-*  Parameters:
-*     this
-*        Pointer to the Frame.
-*     status
-*        Pointer to the inherited status variable.
-*/
-/* Local Variables: */
-   AstMapping *map;
-   int result;
-
-/* Check global status */
-   if( !astOK ) return 0;
-
-/* Get the Mapping. */
-   map = astGetMapping( (AstFrameSet *) this_mapping, AST__BASE,
-                        AST__CURRENT );
-
-/* Get its IsLinear attribute value. */
-   result = astGetIsLinear( map );
-
-/* Free the Mapping. */
-   map = astAnnul( map );
-
-/* Return the result. */
-   return result;
-}
-
-static AstMapping *GetMapping( AstFrameSet *this, int iframe1, int iframe2, int *status ) {
-/*
-*++
-*  Name:
-c     astGetMapping
-f     AST_GETMAPPING
-
-*  Purpose:
-*     Obtain a Mapping that converts between two Frames in a FrameSet.
-
-*  Type:
-*     Public virtual function.
-
-*  Synopsis:
-c     #include "frameset.h"
-c     AstMapping *astGetMapping( AstFrameSet *this, int iframe1, int iframe2 )
-f     RESULT = AST_GETMAPPING( THIS, IFRAME1, IFRAME2, STATUS )
-
-*  Class Membership:
-*     FrameSet method.
-
-*  Description:
-*     This function returns a pointer to a Mapping that will convert
-*     coordinates between the coordinate systems represented by two
-*     Frames in a FrameSet.
-
-*  Parameters:
-c     this
-f     THIS = INTEGER (Given)
-*        Pointer to the FrameSet.
-c     iframe1
-f     IFRAME1 = INTEGER (Given)
-*        The index of the first Frame in the FrameSet. This Frame describes
-*        the coordinate system for the "input" end of the Mapping.
-c     iframe2
-f     IFRAME2 = INTEGER (Given)
-*        The index of the second Frame in the FrameSet. This Frame
-*        describes the coordinate system for the "output" end of the
-*        Mapping.
-f     STATUS = INTEGER (Given and Returned)
-f        The global status.
-
-*  Returned Value:
-c     astGetMapping()
-f     AST_GETMAPPING = INTEGER
-*        Pointer to a Mapping whose forward transformation converts
-*        coordinates from the first coordinate system to the second
-*        one, and whose inverse transformation converts coordinates in
-*        the opposite direction.
-
-*  Notes:
-*     - The returned Mapping will include the clipping effect of any
-*     Regions which occur on the path between the two supplied
-*     Frames (this includes the two supplied Frames themselves).
-c     - The values given for the "iframe1" and "iframe2" parameters
-f     - The values given for the IFRAME1 and IFRAME2 arguments
-*     should lie in the range from 1 to the number of Frames in the
-*     FrameSet (as given by its Nframe attribute). A value of
-*     AST__BASE or AST__CURRENT may also be given to identify the
-*     FrameSet's base Frame or current Frame respectively.  It is
-c     permissible for both these parameters to have the same value, in
-f     permissible for both these arguments to have the same value, in
-*     which case a unit Mapping (UnitMap) is returned.
-*     - It should always be possible to generate the Mapping
-*     requested, but this does necessarily guarantee that it will be
-*     able to perform the required coordinate conversion. If
-*     necessary, the TranForward and TranInverse attributes of the
-*     returned Mapping should be inspected to determine if the
-*     required transformation is available.
-*     - 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: */
-   AstFrame *fr;                 /* Temporary pointer to Frame */
-   AstFrame **frames;            /* Pointer to array of Frames */
-   AstMapping **path;            /* Pointer to array of conversion Mappings */
-   AstMapping *copy;             /* Pointer to copy of Mapping */
-   AstMapping *result;           /* Result pointer to be returned */
-   AstMapping *tmp;              /* Temporary pointer for joining Mappings */
-   int *forward;                 /* Pointer to array of Mapping directions */
-   int ipath;                    /* Loop counter for conversion path steps */
-   int iframe;                   /* Frame index */
-   int inode;                    /* Node index */
-   int npath;                    /* Number of steps in conversion path */
-
-/* Initialise. */
-   result = NULL;
-
-/* Check the global error status. */
-   if ( !astOK ) return result;
-
-/* Validate and translate the Frame indices supplied. */
-   iframe1 = astValidateFrameIndex( this, iframe1, "astGetMapping" );
-   iframe2 = astValidateFrameIndex( this, iframe2, "astGetMapping" );
-
-/* Allocate memory to hold an array of Mapping pointers and associated
-   direction flags - a maximum of one element for each Mapping and one
-   for each Frame in the FrameSet. */
-   path = astMalloc( sizeof( AstMapping * ) * (size_t) ( this->nnode - 1 +
-                                                         this->nframe ) );
-   forward = astMalloc( sizeof( int ) * (size_t) ( this->nnode - 1 +
-                                                   this->nframe ) );
-
-/* Allocate memory to hold a list of the Frame pointers (if any) associated
-   with each node. */
-   frames = astMalloc( sizeof( AstFrame * )  * (size_t) ( this->nnode ) );
-
-/* If OK, set up an array of Frame pointers indexed by node index. If a
-   node has no associated Frame store a NULL pointer. This is needed so
-   that we can find Frame pointers quickly within the Span function. Note,
-   we simply copy the pointers rather than cloning them, so they do not
-   need to be annulled when finished with. */
-   if ( astOK ) {
-      for( inode = 0; inode < this->nnode; inode++ ) frames[ inode ] = NULL;
-      for( iframe = 0; iframe < this->nframe; iframe++ ) {
-         frames[ this->node[ iframe ] ] = this->frame[ iframe ];
-      }
-
-/* Obtain the Mapping pointers and direction flags needed to convert
-   coordinates between the nodes associated with the two specified
-   Frames. */
-      npath = Span( this, frames, this->node[ iframe1 - 1 ],
-                    this->node[ iframe2 - 1 ], -1, path, forward, status ) - 1;
-
-/* If this failed, it indicates a corrupt FrameSet object, so report
-   an error. */
-      if ( npath < 0 ) {
-         astError( AST__FRSIN, "astGetMapping(%s): Invalid or corrupt "
-                   "%s - could not find conversion path between Frames "
-                   "%d and %d.", status, astGetClass( this ), astGetClass( this ),
-                   iframe1, iframe2 );
-
-/* If the conversion path is of zero length (i.e. the two Frames are
-   the same) then we will return a Mapping which is equivalent to the
-   Frame. Most classes of Frame are equivalent to a UnitMap. However,
-   we do not hard-wire this equivalence since some classes of Frame (e.g.
-   Regions, and CmpFrames containing Regions) do not correspond to a
-   UnitMap. Instead we use the astIsUnitFrame method on the Frame to determine
-   if the Frame is equivalent to a UnitMap. If so, create a suitable UnitMap.
-   If not, return the Frame itself (a form of Mapping). */
-      } else if ( npath == 0 ) {
-         fr = astGetFrame( this, iframe1 );
-         if( astIsUnitFrame( fr ) ){
-            result = (AstMapping *) astUnitMap( astGetNaxes( fr ), "", status );
-         } else {
-            result = (AstMapping *) astClone( fr );
-         }
-         fr = astAnnul( fr );
-
-/* If the conversion path involves at least one non-trivial Mapping,
-   make a copy of the first Mapping, inverting the copy if
-   necessary. */
-      } else {
-         result = astCopy( path[ 0 ] );
-         if ( !forward[ 0 ] ) astInvert( result );
-
-/* Now loop to concatenate any further Mappings. First make a copy of
-   each additional Mapping and invert the copy if necessary. */
-         for ( ipath = 1; ipath < npath; ipath++ ) {
-            copy = astCopy( path[ ipath ] );
-            if ( !forward[ ipath ] ) astInvert( copy );
-
-/* Concatenate the copy with the result so far, then annul the pointer
-   to the copy and save the pointer to the new result. */
-            tmp = (AstMapping *) astCmpMap( result, copy, 1, "", status );
-            result = astAnnul( result );
-            copy = astAnnul( copy );
-            result = tmp;
-         }
-      }
-   }
-
-/* Free the memory allocated for the conversion path information. */
-   path = astFree( path );
-   forward = astFree( forward );
-   frames = astFree( frames );
-
-/* If an error occurred, annul the returned Mapping. */
-   if ( !astOK ) result = astAnnul( result );
-
-/* Return the result. */
-   return result;
-}
-
-static int GetNaxes( AstFrame *this_frame, int *status ) {
-/*
-*  Name:
-*     GetNaxes
-
-*  Purpose:
-*     Determine how many axes a FrameSet has.
-
-*  Type:
-*     Private function.
-
-*  Synopsis:
-*     #include "frameset.h"
-*     int GetNaxes( AstFrame *this, int *status )
-
-*  Class Membership:
-*     FrameSet member function (over-rides the astGetNaxes method
-*     inherited from the Frame class).
-
-*  Description:
-*     This function returns the number of axes for a FrameSet. This is equal
-*     to the number of axes in its current Frame.
-
-*  Parameters:
-*     this
-*        Pointer to the FrameSet.
-*     status
-*        Pointer to the inherited status variable.
-
-*  Returned Value:
-*     The number of FrameSet axes (zero or more).
-
-*  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: */
-   AstFrame *fr;                 /* Pointer to current Frame */
-   AstFrameSet *this;            /* Pointer to the FrameSet structure */
-   int result;                   /* Result to be returned */
-
-/* Check the global error status. */
-   if ( !astOK ) return 0;
-
-/* Obtain a pointer to the FrameSet structure. */
-   this = (AstFrameSet *) this_frame;
-
-/* Obtain a pointer to the FrameSet's current Frame. */
-   fr = astGetFrame( this, AST__CURRENT );
-
-/* Obtain the number of axes in this Frame. */
-   result = astGetNaxes( fr );
-
-/* Annul the current Frame pointer. */
-   fr = astAnnul( fr );
-
-/* If an error occurred, clear the result value. */
-   if ( !astOK ) result = 0;
-
-/* Return the result. */
-   return result;
-}
-
-static int GetNframe( AstFrameSet *this, int *status ) {
-/*
-*+
-*  Name:
-*     astGetNframe
-
-*  Purpose:
-*     Determine the number of Frames in a FrameSet.
-
-*  Type:
-*     Protected virtual function.
-
-*  Synopsis:
-*     #include "frameset.h"
-*     int astGetNframe( AstFrameSet *this )
-
-*  Class Membership:
-*     FrameSet method.
-
-*  Description:
-*     This function returns the number of Frames in a FrameSet.
-
-*  Parameters:
-*     this
-*        Pointer to the FrameSet.
-
-*  Returned Value:
-*     The number of Frames in the FrameSet (always 1 or more).
-
-*  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.
-*-
-*/
-
-/* Check the global error status. */
-   if ( !astOK ) return 0;
-
-/* Return the Frame count. */
-   return this->nframe;
-}
-
-static int GetNin( AstMapping *this_mapping, int *status ) {
-/*
-*  Name:
-*     GetNin
-
-*  Purpose:
-*     Get the number of input coordinates for a FrameSet.
-
-*  Type:
-*     Private function.
-
-*  Synopsis:
-*     #include "frameset.h"
-*     int GetNin( AstMapping *this, int *status )
-
-*  Class Membership:
-*     FrameSet member function (over-rides the astGetNin method
-*     inherited from the Frame class).
-
-*  Description:
-*     This function returns the number of input coordinate values
-*     required per point by a FrameSet when used to transform a set of
-*     points (i.e. the number of dimensions of the space in which the
-*     input points reside).
-*
-*     The value returned is equal to the number of axes in the
-*     FrameSet's base Frame.
-
-*  Parameters:
-*     this
-*        Pointer to the FrameSet.
-*     status
-*        Pointer to the inherited status variable.
-
-*  Returned Value:
-*     Number of coordinate values required.
-
-*  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: */
-   AstFrame *fr;                 /* Pointer to base Frame */
-   AstFrameSet *this;            /* Pointer to the FrameSet structure */
-   int result;                   /* Result to be returned */
-
-/* Check the global error status. */
-   if ( !astOK ) return 0;
-
-/* Obtain a pointer to the FrameSet structure. */
-   this = (AstFrameSet *) this_mapping;
-
-/* Obtain a pointer to the FrameSet's base Frame. */
-   fr = astGetFrame( this, AST__BASE );
-
-/* Obtain the number of axes in this Frame. */
-   result = astGetNaxes( fr );
-
-/* Annul the base Frame pointer. */
-   fr = astAnnul( fr );
-
-/* If an error occurred, clear the result value. */
-   if ( !astOK ) result = 0;
-
-/* Return the result. */
-   return result;
-}
-
-static int GetNout( AstMapping *this_mapping, int *status ) {
-/*
-*  Name:
-*     GetNout
-
-*  Purpose:
-*     Get the number of output coordinates for a FrameSet.
-
-*  Type:
-*     Private function.
-
-*  Synopsis:
-*     #include "frameset.h"
-*     int GetNout( AstMapping *this, int *status )
-
-*  Class Membership:
-*     FrameSet member function (over-rides the astGetNout method
-*     inherited from the Frame class).
-
-*  Description:
-*     This function returns the number of output coordinate values
-*     generated per point by a FrameSet when used to transform a set
-*     of points (i.e. the number of dimensions of the space in which
-*     the output points reside).
-*
-*     The value returned is equal to the number of axes in the
-*     FrameSet's current Frame.
-
-*  Parameters:
-*     this
-*        Pointer to the FrameSet.
-*     status
-*        Pointer to the inherited status variable.
-
-*  Returned Value:
-*     Number of coordinate values generated.
-
-*  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.
-*/
-
-/* Check the global error status. */
-   if ( !astOK ) return 0;
-
-/* Return the number of axes in the FrameSet's current Frame. */
-   return GetNaxes( (AstFrame *) this_mapping, status );
-}
-
-static const int *GetPerm( AstFrame *this_frame, int *status ) {
-/*
-*  Name:
-*     GetPerm
-
-*  Purpose:
-*     Access the axis permutation array for the current Frame of a FrameSet.
-
-*  Type:
-*     Private function.
-
-*  Synopsis:
-*     #include "frameset.h"
-*     const int *GetPerm( AstFrame *this, int *status )
-
-*  Class Membership:
-*     FrameSet member function (over-rides the astGetPerm protected
-*     method inherited from the Frame class).
-
-*  Description:
-*     This function returns a pointer to the axis permutation array
-*     for the current Frame of a FrameSet. This array constitutes a
-*     lookup-table that converts between an axis number supplied
-*     externally and the corresponding index in the Frame's internal
-*     axis arrays.
-
-*  Parameters:
-*     this
-*        Pointer to the FrameSet.
-*     status
-*        Pointer to the inherited status variable.
-
-*  Returned Value:
-*     Pointer to the current Frame's axis permutation array (a
-*     constant array of int).  Each element of this contains the
-*     (zero-based) internal axis index to be used in place of the
-*     external index which is used to address the permutation
-*     array. If the current Frame has zero axes, this pointer will be
-*     NULL.
-
-*  Notes:
-*     - The pointer returned by this function gives direct access to
-*     data internal to the Frame object. It remains valid only so long
-*     as the Frame exists. The permutation array contents may be
-*     modified by other functions which operate on the Frame and this
-*     may render the returned pointer invalid.
-*     - 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: */
-   AstFrame *fr;                 /* Pointer to current Frame */
-   AstFrameSet *this;            /* Pointer to FrameSet structure */
-   const int *result;            /* Result pointer value */
-
-/* Check the global error status. */
-   if ( !astOK ) return NULL;
-
-/* Obtain a pointer to the FrameSet structure. */
-   this = (AstFrameSet *) this_frame;
-
-/* Obtain a pointer to the FrameSet's current Frame and then obtain a
-   pointer to its axis permutation array. Annul the Frame pointer
-   afterwards. */
-   fr = astGetFrame( this, AST__CURRENT );
-   result = astGetPerm( fr );
-   fr = astAnnul( fr );
-
-/* If an error occurred, clear the result value. */
-   if ( !astOK ) result = NULL;
-
-/* Return the result. */
-   return result;
-}
-
-static int GetTranForward( AstMapping *this_mapping, int *status ) {
-/*
-*  Name:
-*     GetTranForward
-
-*  Purpose:
-*     Determine if a FrameSet defines a forward coordinate transformation.
-
-*  Type:
-*     Private function.
-
-*  Synopsis:
-*     #include "frameset.h"
-*     int GetTranForward( AstMapping *this )
-
-*  Class Membership:
-*     Frameset member function (over-rides the astGetTranForward
-*     protected method inherited from the Frame class).
-
-*  Description:
-*     This function returns a value indicating whether a FrameSet is
-*     able to perform a coordinate transformation in the "forward"
-*     direction.
-
-*  Parameters:
-*     this
-*        Pointer to the FrameSet.
-
-*  Returned Value:
-*     Zero if the forward coordinate transformation is not defined, or
-*     1 if it is.
-
-*  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: */
-   AstFrameSet *this;            /* Pointer to the FrameSet structure */
-   AstMapping *map;              /* Pointer to base->current Mapping */
-   int result;                   /* Result to be returned */
-
-/* Check the global error status. */
-   if ( !astOK ) return 0;
-
-/* Obtain a pointer to the FrameSet structure. */
-   this = (AstFrameSet *) this_mapping;
-
-/* Obtain the Mapping between the base and current Frames in the
-   FrameSet (note this takes account of whether the FrameSet has been
-   inverted). */
-   map = astGetMapping( this, AST__BASE, AST__CURRENT );
-
-/* Determine whether the required transformation is defined. */
-   result = astGetTranForward( map );
-
-/* Annul the Mapping pointer. */
-   map = astAnnul( map );
-
-/* If an error occurred, clear the returned result. */
-   if ( !astOK ) result = 0;
-
-/* Return the result. */
-   return result;
-}
-
-static int GetTranInverse( AstMapping *this_mapping, int *status ) {
-/*
-*  Name:
-*     GetTranInverse
-
-*  Purpose:
-*     Determine if a FrameSet defines an inverse coordinate transformation.
-
-*  Type:
-*     Private function.
-
-*  Synopsis:
-*     #include "frameset.h"
-*     int GetTranInverse( AstMapping *this )
-
-*  Class Membership:
-*     Frameset member function (over-rides the astGetTranInverse
-*     protected method inherited from the Frame class).
-
-*  Description:
-*     This function returns a value indicating whether a FrameSet is
-*     able to perform a coordinate transformation in the "inverse"
-*     direction.
-
-*  Parameters:
-*     this
-*        Pointer to the FrameSet.
-
-*  Returned Value:
-*     Zero if the inverse coordinate transformation is not defined, or
-*     1 if it is.
-
-*  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: */
-   AstFrameSet *this;            /* Pointer to the FrameSet structure */
-   AstMapping *map;              /* Pointer to base->current Mapping */
-   int result;                   /* Result to be returned */
-
-/* Check the global error status. */
-   if ( !astOK ) return 0;
-
-/* Obtain a pointer to the FrameSet structure. */
-   this = (AstFrameSet *) this_mapping;
-
-/* Obtain the Mapping between the base and current Frames in the
-   FrameSet (note this takes account of whether the FrameSet has been
-   inverted). */
-   map = astGetMapping( this, AST__BASE, AST__CURRENT );
-
-/* Determine whether the required transformation is defined. */
-   result = astGetTranInverse( map );
-
-/* Annul the Mapping pointer. */
-   map = astAnnul( map );
-
-/* If an error occurred, clear the returned result. */
-   if ( !astOK ) result = 0;
-
-/* Return the result. */
-   return result;
-}
-
-static int GetUseDefs( AstObject *this_object, int *status ) {
-/*
-*  Name:
-*     GetUseDefs
-
-*  Purpose:
-*     Get the value of the UseDefs attribute for a FrameSet.
-
-*  Type:
-*     Private function.
-
-*  Synopsis:
-*     #include "frameset.h"
-*     int GetUseDefs( AstObject *this_object, int *status ) {
-
-*  Class Membership:
-*     FrameSet member function (over-rides the protected astGetUseDefs
-*     method inherited from the Frame class).
-
-*  Description:
-*     This function returns the value of the UseDefs attribute for a FrameSet,
-*     supplying a suitable default.
-
-*  Parameters:
-*     this
-*        Pointer to the FrameSet.
-*     status
-*        Pointer to the inherited status variable.
-
-*  Returned Value:
-*     - The USeDefs value.
-*/
-
-/* Local Variables: */
-   AstFrame *fr;                 /* Pointer to current Frame */
-   AstFrameSet *this;            /* Pointer to the FrameSet structure */
-   int result;                   /* Value to return */
-
-/* Initialise. */
-   result = 0;
-
-/* Check the global error status. */
-   if ( !astOK ) return result;
-
-/* Obtain a pointer to the FrameSet structure. */
-   this = (AstFrameSet *) this_object;
-
-/* If the UseDefs value for the FrameSet has been set explicitly, use the
-   Get method inherited from the parent Frame class to get its value> */
-   if( astTestUseDefs( this ) ) {
-      result = (*parent_getusedefs)( this_object, status );
-
-/* Otherwise, supply a default value equal to the UseDefs value of the
-   current Frame. */
-   } else {
-      fr = astGetFrame( this, AST__CURRENT );
-      result = astGetUseDefs( fr );
-      fr = astAnnul( fr );
-   }
-
-/* Return the result. */
-   return result;
-}
-
-static int GetVarFrm( AstFrameSet *this, int iframe, int *status ) {
-/*
-*  Name:
-*     GetVarFrm
-
-*  Purpose:
-*     Get the index of the variants Frame for a nominated Frame.
-
-*  Type:
-*     Private function.
-
-*  Synopsis:
-*     #include "frameset.h"
-*     int GetVarFrm( AstFrameSet *this, int iframe, int *status ) {
-
-*  Class Membership:
-*     Private function.
-
-*  Description:
-*     This function returns the index of the variants Frame associated
-*     with a nominated mirror Frame. See astMirrorVariants.
-
-*  Parameters:
-*     this
-*        Pointer to the FrameSet.
-*     iframe
-*        The one-based index of the nominated Frame that may potentially be
-*        a mirror for the variant Mappings in another Frame.
-*     status
-*        Pointer to the inherited status variable.
-
-*  Returned Value:
-*     The one-based Frame index of the Frame that defines the variant
-*     Mappings associated with Frame "iframe". This will be the same as
-*     "iframe" unless the nominated Frame is a mirror for another Frame.
-*/
-
-/* Local Variables: */
-   int result;                   /* Value to return */
-
-/* Initialise. */
-   result = AST__NOFRAME;
-
-/* Check the global error status. */
-   if ( !astOK ) return result;
-
-/* Initialise the returned value. */
-   result = iframe;
-
-/* If the nominated Frame is mirroring another Frame, return the index of
-   the mirrored Frame. Walk up the chain until we reach a Frame which is
-   not a mirror for another Frame. */
-   while( this->varfrm[ result - 1 ] > 0 ) {
-      if( this->varfrm[ result - 1 ] == result ) {
-         astError( AST__INTER, "GetVarFrm(FrameSet): FrameSet is corrupt "
-                   "(internal programming error).", status );
-         break;
-      } else {
-         result = this->varfrm[ result - 1 ];
-      }
-   }
-
-/* Return the result. */
-   return result;
-}
-
-static const char *GetVariant( AstFrameSet *this, int *status ) {
-/*
-*+
-*  Name:
-*     astGetVariant
-
-*  Purpose:
-*     Obtain the value of the Variant attribute for a FrameSet.
-
-*  Type:
-*     Protected virtual function.
-
-*  Synopsis:
-*     #include "frameset.h"
-*     const char *astGetVariant( AstFrameSet *this )
-
-*  Class Membership:
-*     FrameSet method.
-
-*  Description:
-*     This function returns the value of the Variant attribute for a
-*     FrameSet.
-
-*  Parameters:
-*     this
-*        Pointer to the FrameSet.
-
-*  Returned Value:
-*     The Variant attribute value.
-
-*  Notes:
-*     - A NULL value will be returned if this function is invoked
-*     with the global status set, or if it should fail for any reason.
-*-
-*/
-
-/* Local Variables: */
-   AstFrame *frm;
-   AstFrame *vfs;
-   const char *result;
-   int icur;
-   int iuse;
-
-/* Initialise */
-   result = NULL;
-
-/* Check the global error status. */
-   if ( !astOK ) return result;
-
-/* Get the one-based index of the current Frame. */
-   icur = astGetCurrent( this );
-
-/* The current Frame may mirror the variant Mappings in another Frame,
-   rather than defining any variant Mappings itself. Get the one-based
-   index of the Frame that defines the variant Mappings to use. */
-   iuse = GetVarFrm( this, icur, status );
-
-/* Get a pointer to the Variants FrameSet in the used Frame. */
-   frm = astGetFrame( this, iuse );
-   vfs = astGetFrameVariants( frm );
-
-/* If the current Frame has no Variants FrameSet, return the Domain name
-   of the current Frame. */
-   if( !vfs ) {
-      result = astGetDomain( this );
-
-/* Otherwise, return the Domain name of the current Frame in the Variants
-   FrameSet. Then annul the Variants FrameSet pointer. */
-   } else {
-      result = astGetDomain( vfs );
-      vfs = astAnnul( vfs );
-   }
-
-/* Annul the current Frame pointer. */
-   frm = astAnnul( frm );
-
-/* If an error occurred, clear the result. */
-   if ( !astOK ) result = NULL;
-
-/* Return the result. */
-   return result;
-}
-
-void astInitFrameSetVtab_(  AstFrameSetVtab *vtab, const char *name, int *status ) {
-/*
-*+
-*  Name:
-*     astInitFrameSetVtab
-
-*  Purpose:
-*     Initialise a virtual function table for a FrameSet.
-
-*  Type:
-*     Protected function.
-
-*  Synopsis:
-*     #include "frameset.h"
-*     void astInitFrameSetVtab( AstFrameSetVtab *vtab, const char *name )
-
-*  Class Membership:
-*     FrameSet vtab initialiser.
-
-*  Description:
-*     This function initialises the component of a virtual function
-*     table which is used by the FrameSet 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 */
-   AstMappingVtab *mapping;      /* Pointer to Mapping component of Vtab */
-   AstObjectVtab *object;        /* Pointer to Object component of Vtab */
-
-/* Check the local error status. */
-   if ( !astOK ) return;
-
-/* Get a pointer to the thread specific global data structure. */
-   astGET_GLOBALS(NULL);
-
-/* Initialize the component of the virtual function table used by the
-   parent class. */
-   astInitFrameVtab( (AstFrameVtab *) vtab, name );
-
-/* Store a unique "magic" value in the virtual function table. This
-   will be used (by astIsAFrameSet) 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->AddFrame = AddFrame;
-   vtab->AddVariant = AddVariant;
-   vtab->ClearBase = ClearBase;
-   vtab->ClearCurrent = ClearCurrent;
-   vtab->GetBase = GetBase;
-   vtab->GetCurrent = GetCurrent;
-   vtab->GetFrame = GetFrame;
-   vtab->GetMapping = GetMapping;
-   vtab->GetNframe = GetNframe;
-   vtab->GetNode = GetNode;
-   vtab->GetAllVariants = GetAllVariants;
-   vtab->MirrorVariants = MirrorVariants;
-   vtab->RemapFrame = RemapFrame;
-   vtab->RemoveFrame = RemoveFrame;
-   vtab->SetBase = SetBase;
-   vtab->SetCurrent = SetCurrent;
-   vtab->TestBase = TestBase;
-   vtab->TestCurrent = TestCurrent;
-   vtab->ValidateFrameIndex = ValidateFrameIndex;
-
-   vtab->ClearVariant = ClearVariant;
-   vtab->GetVariant = GetVariant;
-   vtab->SetVariant = SetVariant;
-   vtab->TestVariant = TestVariant;
-
-/* Save the inherited pointers to methods that will be extended, and
-   replace them with pointers to the new member functions. */
-   object = (AstObjectVtab *) vtab;
-
-   parent_clear = object->Clear;
-   parent_getobjsize = object->GetObjSize;
-   object->GetObjSize = GetObjSize;
-   object->Clear = Clear;
-
-   parent_vset = object->VSet;
-   object->VSet = VSet;
-
-   parent_getusedefs = object->GetUseDefs;
-   object->GetUseDefs = GetUseDefs;
-
-#if defined(THREAD_SAFE)
-   parent_managelock = object->ManageLock;
-   object->ManageLock = ManageLock;
-#endif
-
-/* Store replacement pointers for methods which will be over-ridden by
-   new member functions implemented here. */
-   mapping = (AstMappingVtab *) vtab;
-   frame = (AstFrameVtab *) vtab;
-
-   object->ClearAttrib = ClearAttrib;
-   object->GetAttrib = GetAttrib;
-   object->SetAttrib = SetAttrib;
-   object->TestAttrib = TestAttrib;
-
-   object->GetUseDefs = GetUseDefs;
-   object->Equal = Equal;
-   object->Cast = Cast;
-
-   mapping->GetIsLinear = GetIsLinear;
-   mapping->GetNin = GetNin;
-   mapping->GetNout = GetNout;
-   mapping->GetTranForward = GetTranForward;
-   mapping->GetTranInverse = GetTranInverse;
-   mapping->Rate = Rate;
-   mapping->ReportPoints = ReportPoints;
-   mapping->RemoveRegions = RemoveRegions;
-   mapping->Simplify = Simplify;
-   mapping->Transform = Transform;
-   mapping->MapSplit = MapSplit;
-
-   frame->Abbrev = Abbrev;
-   frame->Angle = Angle;
-   frame->AxAngle = AxAngle;
-   frame->AxDistance = AxDistance;
-   frame->AxNorm = AxNorm;
-   frame->AxOffset = AxOffset;
-   frame->CheckPerm = CheckPerm;
-   frame->ClearDigits = ClearDigits;
-   frame->ClearDirection = ClearDirection;
-   frame->ClearDomain = ClearDomain;
-   frame->ClearFormat = ClearFormat;
-   frame->ClearLabel = ClearLabel;
-   frame->ClearMatchEnd = ClearMatchEnd;
-   frame->ClearMaxAxes = ClearMaxAxes;
-   frame->ClearMinAxes = ClearMinAxes;
-   frame->ClearPermute = ClearPermute;
-   frame->ClearPreserveAxes = ClearPreserveAxes;
-   frame->ClearSymbol = ClearSymbol;
-   frame->ClearTitle = ClearTitle;
-   frame->ClearUnit = ClearUnit;
-   frame->Convert = Convert;
-   frame->ConvertX = ConvertX;
-   frame->Distance = Distance;
-   frame->Fields = Fields;
-   frame->FindFrame = FindFrame;
-   frame->Format = Format;
-   frame->FrameGrid = FrameGrid;
-   frame->Centre = Centre;
-   frame->Gap = Gap;
-   frame->GetAxis = GetAxis;
-   frame->GetDigits = GetDigits;
-   frame->GetDirection = GetDirection;
-   frame->GetDomain = GetDomain;
-   frame->GetFormat = GetFormat;
-   frame->GetLabel = GetLabel;
-   frame->GetMatchEnd = GetMatchEnd;
-   frame->GetMaxAxes = GetMaxAxes;
-   frame->GetMinAxes = GetMinAxes;
-   frame->GetNaxes = GetNaxes;
-   frame->GetPerm = GetPerm;
-   frame->GetPermute = GetPermute;
-   frame->GetPreserveAxes = GetPreserveAxes;
-   frame->GetSymbol = GetSymbol;
-   frame->GetTitle = GetTitle;
-   frame->GetUnit = GetUnit;
-   frame->Intersect = Intersect;
-   frame->IsUnitFrame = IsUnitFrame;
-   frame->LineContains = LineContains;
-   frame->LineCrossing = LineCrossing;
-   frame->LineDef = LineDef;
-   frame->LineOffset = LineOffset;
-   frame->Match = Match;
-   frame->MatchAxes = MatchAxes;
-   frame->MatchAxesX = MatchAxesX;
-   frame->Norm = Norm;
-   frame->NormBox = NormBox;
-   frame->Offset = Offset;
-   frame->Offset2 = Offset2;
-   frame->Overlay = Overlay;
-   frame->PermAxes = PermAxes;
-   frame->PickAxes = PickAxes;
-   frame->PrimaryFrame = PrimaryFrame;
-   frame->Resolve = Resolve;
-   frame->ResolvePoints = ResolvePoints;
-   frame->SetAxis = SetAxis;
-   frame->SetDigits = SetDigits;
-   frame->SetDirection = SetDirection;
-   frame->SetDomain = SetDomain;
-   frame->SetFormat = SetFormat;
-   frame->SetLabel = SetLabel;
-   frame->SetMatchEnd = SetMatchEnd;
-   frame->SetMaxAxes = SetMaxAxes;
-   frame->SetMinAxes = SetMinAxes;
-   frame->SetPermute = SetPermute;
-   frame->SetPreserveAxes = SetPreserveAxes;
-   frame->SetSymbol = SetSymbol;
-   frame->SetTitle = SetTitle;
-   frame->SetUnit = SetUnit;
-   frame->SubFrame = SubFrame;
-   frame->SystemCode = SystemCode;
-   frame->SystemString = SystemString;
-   frame->TestDigits = TestDigits;
-   frame->TestDirection = TestDirection;
-   frame->TestDomain = TestDomain;
-   frame->TestFormat = TestFormat;
-   frame->TestLabel = TestLabel;
-   frame->TestMatchEnd = TestMatchEnd;
-   frame->TestMaxAxes = TestMaxAxes;
-   frame->TestMinAxes = TestMinAxes;
-   frame->TestPermute = TestPermute;
-   frame->TestPreserveAxes = TestPreserveAxes;
-   frame->TestSymbol = TestSymbol;
-   frame->TestTitle = TestTitle;
-   frame->TestUnit = TestUnit;
-   frame->Unformat = Unformat;
-   frame->ValidateAxis = ValidateAxis;
-   frame->ValidateAxisSelection = ValidateAxisSelection;
-   frame->ValidateSystem = ValidateSystem;
-
-   frame->GetActiveUnit = GetActiveUnit;
-   frame->SetActiveUnit = SetActiveUnit;
-   frame->TestActiveUnit = TestActiveUnit;
-
-   frame->GetTop = GetTop;
-   frame->SetTop = SetTop;
-   frame->TestTop = TestTop;
-   frame->ClearTop = ClearTop;
-
-   frame->GetBottom = GetBottom;
-   frame->SetBottom = SetBottom;
-   frame->TestBottom = TestBottom;
-   frame->ClearBottom = ClearBottom;
-
-   frame->GetEpoch = GetEpoch;
-   frame->SetEpoch = SetEpoch;
-   frame->TestEpoch = TestEpoch;
-   frame->ClearEpoch = ClearEpoch;
-
-   frame->GetDtai = GetDtai;
-   frame->SetDtai = SetDtai;
-   frame->TestDtai = TestDtai;
-   frame->ClearDtai = ClearDtai;
-
-   frame->GetDut1 = GetDut1;
-   frame->SetDut1 = SetDut1;
-   frame->TestDut1 = TestDut1;
-   frame->ClearDut1 = ClearDut1;
-
-   frame->GetSystem = GetSystem;
-   frame->SetSystem = SetSystem;
-   frame->TestSystem = TestSystem;
-   frame->ClearSystem = ClearSystem;
-
-   frame->GetAlignSystem = GetAlignSystem;
-   frame->SetAlignSystem = SetAlignSystem;
-   frame->TestAlignSystem = TestAlignSystem;
-   frame->ClearAlignSystem = ClearAlignSystem;
-
-   frame->ClearObsLat = ClearObsLat;
-   frame->TestObsLat = TestObsLat;
-   frame->GetObsLat = GetObsLat;
-   frame->SetObsLat = SetObsLat;
-
-   frame->ClearObsAlt = ClearObsAlt;
-   frame->TestObsAlt = TestObsAlt;
-   frame->GetObsAlt = GetObsAlt;
-   frame->SetObsAlt = SetObsAlt;
-
-   frame->ClearObsLon = ClearObsLon;
-   frame->TestObsLon = TestObsLon;
-   frame->GetObsLon = GetObsLon;
-   frame->SetObsLon = SetObsLon;
-
-/* Declare the copy constructor, destructor and class dump
-   functions. */
-   astSetDelete( vtab, Delete );
-   astSetCopy( vtab, Copy );
-   astSetDump( vtab, Dump, "FrameSet",
-               "Set of inter-related coordinate systems" );
-
-/* 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 "frameset.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:
-*     FrameSet 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: */
-   AstFrame *fr;                 /* Pointer to current Frame */
-   AstFrameSet *this;            /* Pointer to the FrameSet structure */
-
-/* Check the global error status. */
-   if ( !astOK ) return;
-
-/* Obtain a pointer to the FrameSet structure. */
-   this = (AstFrameSet *) this_frame;
-
-/* Obtain a pointer to the FrameSet's current Frame and invoke the
-   astIntersect method for this Frame. Annul the Frame pointer
-   afterwards. */
-   fr = astGetFrame( this, AST__CURRENT );
-   astIntersect( fr, a1, a2, b1, b2, cross );
-   fr = astAnnul( fr );
-
-}
-
-static int IsUnitFrame( AstFrame *this_frame, int *status ){
-/*
-*  Name:
-*     IsUnitFrame
-
-*  Purpose:
-*     Is this Frame equivalent to a UnitMap?
-
-*  Type:
-*     Private function.
-
-*  Synopsis:
-*     #include "frameset.h"
-*     int IsUnitFrame( AstFrame *this, int *status )
-
-*  Class Membership:
-*     FrameSet member function (over-rides the protected astIsUnitFrame
-*     method inherited from the Frame class).
-
-*  Description:
-*     This function returns a flag indicating if the supplied Frame is
-*     equivalent to a UnitMap when treated as a Mapping (note, the Frame
-*     class inherits from Mapping and therefore every Frame is also a Mapping).
-
-*  Parameters:
-*     this
-*        Pointer to the Frame.
-*     status
-*        Pointer to the inherited status variable.
-
-*  Returned Value:
-*     A non-zero value is returned if the supplied Frame is equivalent to
-*     a UnitMap when treated as a Mapping.
-
-*-
-*/
-
-/* Local Variables: */
-   AstFrame *fr;                 /* Pointer to FrameSet's current Frame */
-   AstFrameSet *this;            /* Pointer to the FrameSet structure */
-   int result;                   /* Result to be returned */
-
-/* Initialise the returned value. */
-   result = 0;
-
-/* Check the global error status. */
-   if ( !astOK ) return result;
-
-/* Obtain a pointer to the FrameSet structure. */
-   this = (AstFrameSet *) this_frame;
-
-/* Obtain a pointer to the FrameSet's current Frame. */
-   fr = astGetFrame( this, AST__CURRENT );
-
-/* Invoke the astIsUnitFrame method for this Frame. */
-   result = astIsUnitFrame( fr );
-
-/* Annul the Frame pointer. */
-   fr = astAnnul( fr );
-
-/* If an error occurred, clean up by clearing the returned result. */
-   if ( !astOK ) result = 0;
-
-/* Return the result. */
-   return result;
-}
-
-static int LineContains( AstFrame *this_frame, AstLineDef *l, int def, double *point, int *status ) {
-/*
-*  Name:
-*     LineContains
-
-*  Purpose:
-*     Determine if a line contains a point.
-
-*  Type:
-*     Private function.
-
-*  Synopsis:
-*     #include "frameset.h"
-*     int LineContains( AstFrame *this, AstLineDef *l, int def, double *point, int *status )
-
-*  Class Membership:
-*     FrameSet 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.
-
-*  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: */
-   AstFrame *fr;                 /* Pointer to current Frame */
-   int result;                   /* Returned value */
-
-/* Initialise */
-   result =0;
-
-/* Obtain a pointer to the FrameSet's current Frame and then invoke the
-   method. Annul the Frame pointer afterwards. */
-   fr = astGetFrame( (AstFrameSet *) this_frame, AST__CURRENT );
-   result = astLineContains( fr, l, def, point );
-   fr = astAnnul( fr );
-
-/* Return the result. */
-   return result;
-}
-
-static int LineCrossing( AstFrame *this_frame, AstLineDef *l1, AstLineDef *l2,
-                         double **cross, int *status ) {
-/*
-*  Name:
-*     LineCrossing
-
-*  Purpose:
-*     Determine if two lines cross.
-
-*  Type:
-*     Private function.
-
-*  Synopsis:
-*     #include "frameset.h"
-*     int LineCrossing( AstFrame *this, AstLineDef *l1, AstLineDef *l2,
-*                       double **cross, int *status )
-
-*  Class Membership:
-*     FrameSet 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: */
-   AstFrame *fr;                 /* Pointer to current Frame */
-   int result;                   /* Returned value */
-
-/* Initialise */
-   result =0;
-
-/* Obtain a pointer to the FrameSet's current Frame and then invoke the
-   method. Annul the Frame pointer afterwards. */
-   fr = astGetFrame( (AstFrameSet *) this_frame, AST__CURRENT );
-   result = astLineCrossing( fr, l1, l2, cross );
-   fr = astAnnul( fr );
-
-/* Return the result. */
-   return result;
-}
-
-static AstLineDef *LineDef( AstFrame *this_frame, 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 "frameset.h"
-*     AstLineDef *LineDef( AstFrame *this, const double start[2],
-*                             const double end[2], int *status )
-
-*  Class Membership:
-*     FrameSet 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: */
-   AstFrame *fr;                 /* Pointer to current Frame */
-   AstLineDef *result;           /* Returned value */
-
-/* Initialise */
-   result = NULL;
-
-/* Obtain a pointer to the FrameSet's current Frame and then invoke the
-   method. Annul the Frame pointer afterwards. */
-   fr = astGetFrame( (AstFrameSet *) this_frame, AST__CURRENT );
-   result = astLineDef( fr, start, end );
-   fr = astAnnul( fr );
-
-/* Return the result. */
-   return result;
-}
-
-static void LineOffset( AstFrame *this_frame, 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 "frame.h"
-*     void LineOffset( AstFrame *this, AstLineDef *line, double par,
-*                      double prp, double point[2], int *status )
-
-*  Class Membership:
-*     FrameSet 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: */
-   AstFrame *fr;                 /* Pointer to current Frame */
-
-/* Obtain a pointer to the FrameSet's current Frame and then invoke the
-   method. Annul the Frame pointer afterwards. */
-   fr = astGetFrame( (AstFrameSet *) this_frame, AST__CURRENT );
-   astLineOffset( fr, line, par, prp, point );
-   fr = astAnnul( fr );
-}
-
-static const char *GetAllVariants( AstFrameSet *this, int *status ) {
-/*
-*  Name:
-*     GetAllVariants
-
-*  Purpose:
-*     Get a pointer to a list of the variant Mappings for the current Frame.
-
-*  Type:
-*     Private function.
-
-*  Synopsis:
-*     #include "frameset.h"
-*     const char *getAllVariants( AstFrameSet *this )
-
-*  Class Membership:
-*     FrameSet member function.
-
-*  Description:
-*     This function returns a space separated list of names for all the
-*     variant Mappings associated with the current Frame. See attribute
-*     "Variant". If the current Frame has no variant Mappings, the return
-*     value contains just the Domain name of the current Frame in the
-*     supplied FrameSet.
-
-*  Parameters:
-*     this
-*        Pointer to the Frame.
-
-*  Returned Value:
-*     A pointer to a null-terminated string containing the list.
-
-*  Notes:
-*     - The returned string pointer may point at memory allocated
-*     within the FrameSet, 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 Frame. 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
-   AstFrame *frm;
-   AstFrame *vfrm;
-   AstFrameSet *vfs;
-   const char *dom;
-   const char *result;
-   int ifrm;
-   int nc;
-   int icur;
-   int nfrm;
-
-/* Check the global error status. */
-   if ( !astOK ) return NULL;
-
-/* Get a pointer to the structure holding thread-specific global data. */
-   astGET_GLOBALS( this );
-
-/* Get the one-based index of the Frame that defines the available
-   variant Mappings. */
-   icur = GetVarFrm( this, astGetCurrent( this ), status );
-
-/* Get the variants FrameSet from the Frame selected above. */
-   frm = astGetFrame( this, icur );
-   vfs = astGetFrameVariants( frm );
-
-/* If the Frame does not have a variants FrameSet, just return the DOmain
-   name from the current Frame. */
-   if( !vfs ) {
-      result = astGetDomain( this );
-
-/* If a variants FrameSet was found, form a space sperated list of the
-   Domain names in the FrameSet, stored in the static "getallvariants_buff"
-   string. */
-   } else if( astOK ){
-      nc = 0;
-
-      nfrm = astGetNframe( vfs );
-      for( ifrm = 0; ifrm < nfrm; ifrm++ ) {
-         vfrm = astGetFrame( vfs, ifrm + 1 );
-         dom = astGetDomain( vfrm );
-         if( astOK ){
-            if( ( nc + strlen(dom) + 1 ) < GETALLVARIANTS_BUFF_LEN ) {
-               nc += sprintf( getallvariants_buff + nc, "%s ", dom  );
-            } else {
-               astError( AST__INTER, "astGetAllVariants(%s): Buffer "
-                         "overflow - too many variants.", status,
-                         astGetClass(this) );
-            }
-         }
-         vfrm = astAnnul( vfrm );
-      }
-
-/* Remove the final space. */
-      getallvariants_buff[ nc - 1 ] = 0;
-
-/* Return a pointer to the buffer. */
-      result = getallvariants_buff;
-
-/* Annul the pointer to the variants FrameSet. */
-      vfs = astAnnul( vfs );
-   }
-
-/* Free the pointer to the current Frame. */
-   frm = astAnnul( frm );
-
-/* If an error occurred, clear the result value. */
-   if ( !astOK ) result = NULL;
-
-/* Return the result. */
-   return result;
-}
-
-#if defined(THREAD_SAFE)
-static int ManageLock( AstObject *this_object, int mode, int extra,
-                       AstObject **fail, int *status ) {
-/*
-*  Name:
-*     ManageLock
-
-*  Purpose:
-*     Manage the thread lock on an Object.
-
-*  Type:
-*     Private function.
-
-*  Synopsis:
-*     #include "object.h"
-*     AstObject *ManageLock( AstObject *this, int mode, int extra,
-*                            AstObject **fail, int *status )
-
-*  Class Membership:
-*     FrameSet member function (over-rides the astManageLock protected
-*     method inherited from the parent class).
-
-*  Description:
-*     This function manages the thread lock on the supplied Object. The
-*     lock can be locked, unlocked or checked by this function as
-*     deteremined by parameter "mode". See astLock for details of the way
-*     these locks are used.
-
-*  Parameters:
-*     this
-*        Pointer to the Object.
-*     mode
-*        An integer flag indicating what the function should do:
-*
-*        AST__LOCK: Lock the Object for exclusive use by the calling
-*        thread. The "extra" value indicates what should be done if the
-*        Object is already locked (wait or report an error - see astLock).
-*
-*        AST__UNLOCK: Unlock the Object for use by other threads.
-*
-*        AST__CHECKLOCK: Check that the object is locked for use by the
-*        calling thread (report an error if not).
-*     extra
-*        Extra mode-specific information.
-*     fail
-*        If a non-zero function value is returned, a pointer to the
-*        Object that caused the failure is returned at "*fail". This may
-*        be "this" or it may be an Object contained within "this". Note,
-*        the Object's reference count is not incremented, and so the
-*        returned pointer should not be annulled. A NULL pointer is
-*        returned if this function returns a value of zero.
-*     status
-*        Pointer to the inherited status variable.
-
-*  Returned Value:
-*    A local status value:
-*        0 - Success
-*        1 - Could not lock or unlock the object because it was already
-*            locked by another thread.
-*        2 - Failed to lock a POSIX mutex
-*        3 - Failed to unlock a POSIX mutex
-*        4 - Bad "mode" value supplied.
-
-*  Notes:
-*     - This function attempts to execute even if an error has already
-*     occurred.
-*/
-
-/* Local Variables: */
-   AstFrameSet *this;    /* Pointer to FrameSet structure */
-   int i;                /* Loop count */
-   int result;           /* Returned status value */
-
-/* Initialise */
-   result = 0;
-
-/* Check the supplied pointer is not NULL. */
-   if( !this_object ) return result;
-
-/* Obtain a pointers to the FrameSet structure. */
-   this = (AstFrameSet *) this_object;
-
-/* Invoke the ManageLock method inherited from the parent class. */
-   if( !result ) result = (*parent_managelock)( this_object, mode, extra,
-                                                fail, status );
-
-/* Invoke the astManageLock method on any Objects contained within
-   the supplied Object. */
-   for( i = 0; i < this->nframe; i++ ) {
-      if( !result ) result = astManageLock( this->frame[ i ], mode,
-                                            extra, fail );
-   }
-
-   for ( i = 0; i < this->nnode - 1; i++ ) {
-      if( !result ) result = astManageLock( this->map[ i ], mode, extra,
-                                            fail );
-   }
-
-   return result;
-
-}
-#endif
-
-static int *MapSplit( AstMapping *this_map, int nin, const int *in, AstMapping **map, int *status ){
-/*
-*  Name:
-*     MapSplit
-
-*  Purpose:
-*     Create a Mapping representing a subset of the inputs of an existing
-*     FrameSet.
-
-*  Type:
-*     Private function.
-
-*  Synopsis:
-*     #include "frameset.h"
-*     int *MapSplit( AstMapping *this, int nin, const int *in, AstMapping **map, int *status )
-
-*  Class Membership:
-*     FrameSet method (over-rides the protected astMapSplit method
-*     inherited from the Mapping class).
-
-*  Description:
-*     This function creates a new Mapping by picking specified inputs from
-*     an existing FrameSet. This is only possible if the specified inputs
-*     correspond to some subset of the FrameSet outputs. That is, there
-*     must exist a subset of the FrameSet outputs for which each output
-*     depends only on the selected FrameSet inputs, and not on any of the
-*     inputs which have not been selected. If this condition is not met
-*     by the supplied FrameSet, then a NULL Mapping is returned.
-
-*  Parameters:
-*     this
-*        Pointer to the FrameSet to be split (the FrameSet is not actually
-*        modified by this function).
-*     nin
-*        The number of inputs to pick from "this".
-*     in
-*        Pointer to an array of indices (zero based) for the inputs which
-*        are to be picked. This array should have "nin" elements. If "Nin"
-*        is the number of inputs of the supplied FrameSet, then each element
-*        should have a value in the range zero to Nin-1.
-*     map
-*        Address of a location at which to return a pointer to the new
-*        Mapping. This Mapping will have "nin" inputs (the number of
-*        outputs may be different to "nin"). A NULL pointer will be
-*        returned if the supplied FrameSet has no subset of outputs which
-*        depend only on the selected inputs.
-*     status
-*        Pointer to the inherited status variable.
-
-*  Returned Value:
-*     A pointer to a dynamically allocated array of ints. The number of
-*     elements in this array will equal the number of outputs for the
-*     returned Mapping. Each element will hold the index of the
-*     corresponding output in the supplied FrameSet. The array should be
-*     freed using astFree when no longer needed. A NULL pointer will
-*     be returned if no output Mapping can be created.
-
-*  Notes:
-*     - If this function is invoked with the global error status set,
-*     or if it should fail for any reason, then NULL values will be
-*     returned as the function value and for the "map" pointer.
-*/
-
-/* Local Variables: */
-   AstMapping *bcmap;   /* Base->current Mapping */
-   int *result;         /* Returned pointer */
-
-/* Initialise */
-   result = NULL;
-   *map = NULL;
-
-/* Check the global error status. */
-   if ( !astOK ) return result;
-
-/* Get the Mapping from base to current Frame and try to split it. */
-   bcmap = astGetMapping( (AstFrameSet *) this_map, AST__BASE, AST__CURRENT );
-   result = astMapSplit( bcmap, nin, in, map );
-   bcmap = astAnnul( bcmap );
-
-/* Free returned resources if an error has occurred. */
-   if( !astOK ) {
-      result = astFree( result );
-      *map = astAnnul( *map );
-   }
-
-/* Return the list of output indices. */
-   return result;
-}
-
-static int Match( AstFrame *this_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 "frameset.h"
-*     int Match( AstFrame *template, AstFrame *target, int matchsub,
-*                int **template_axes, int **target_axes,
-*                AstMapping **map, AstFrame **result, int *status )
-
-*  Class Membership:
-*     FrameSet member function (over-rides the protected astMatch
-*     method inherited from the Frame class).
-
-*  Description:
-*     This function matches the current Frame of a "template" FrameSet
-*     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 current Frame of the target
-*     FrameSet. 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 FrameSet, whose current Frame
-*        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 (i.e. if the
-*        target is of a more specialised class than the template). In
-*        this latter case, the target is cast down to the class of the
-*        template. NOTE, this argument is handled by the global method
-*        wrapper function "astMatch_", rather than by the class-specific
-*        implementations of this method.
-*     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 axis in the
-*        template FrameSet's current Frame from which it is
-*        derived. If it is not derived from any template FrameSet
-*        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 Frame and the current
-*        Frame of the template FrameSet. 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.
-*/
-
-/* Local Variables: */
-   AstFrame *fr;                 /* Pointer to FrameSet's current Frame */
-   AstFrameSet *this;            /* Pointer to the FrameSet structure */
-   int match;                    /* Result to be returned */
-
-/* Initialise the returned values. */
-   *template_axes = NULL;
-   *target_axes = NULL;
-   *map = NULL;
-   *result = NULL;
-   match = 0;
-
-/* Check the global error status. */
-   if ( !astOK ) return match;
-
-/* Obtain a pointer to the FrameSet structure. */
-   this = (AstFrameSet *) this_frame;
-
-/* Obtain a pointer to the FrameSet's current Frame. */
-   fr = astGetFrame( this, AST__CURRENT );
-
-/* Invoke the astMatch method for this Frame. */
-   match =astMatch( fr, target, matchsub, template_axes, target_axes,
-                    map, result );
-
-/* Annul the Frame pointer. */
-   fr = astAnnul( fr );
-
-/* If an error occurred, clean up by freeing any allocated memory,
-   annulling returned objects and clearing the returned result. */
-   if ( !astOK ) {
-      *template_axes = astFree( *template_axes );
-      *target_axes = astFree( *target_axes );
-      *map = astAnnul( *map );
-      *result = astAnnul( *result );
-      match = 0;
-   }
-
-/* Return the result. */
-   return match;
-}
-
-static void MatchAxes( AstFrame *frm1_frame, AstFrame *frm2, int *axes,
-                       int *status ) {
-/*
-*  Name:
-*     MatchAxes
-
-*  Purpose:
-*     Find any corresponding axes in two Frames.
-
-*  Type:
-*     Private function.
-
-*  Synopsis:
-*     #include "frameset.h"
-*     void MatchAxes( AstFrame *frm1, AstFrame *frm2, int *axes )
-*                     int *status )
-
-*  Class Membership:
-*     FrameSet member function (over-rides the protected astMatchAxes
-*     method inherited from the Frame class).
-
-*  Description:
-*     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:
-*     frm1
-*        Pointer to the first Frame.
-*     frm2
-*        Pointer to the second Frame.
-*     axes
-*        Pointer to an
-*        integer array in which to return the indices of the axes (within
-*        the second Frame) that correspond to each axis within the first
-*        Frame. Axis indices start at 1. A value of zero will be stored
-*        in the returned array for each axis in the first Frame that has
-*        no corresponding axis in the second Frame.
-*
-*        The number of elements in this array must be greater than or
-*        equal to the number of axes in the first 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 *frm1;
-
-/* Check the global error status. */
-   if ( !astOK ) return;
-
-/* Get a pointer to the current Frame in the FrameSet. */
-   frm1 = astGetFrame( (AstFrameSet *) frm1_frame, AST__CURRENT );
-
-/* Invoke the astMatchAxesX on the second Frame. */
-   astMatchAxesX( frm2, frm1, axes );
-
-/* Free resources */
-   frm1 = astAnnul( frm1 );
-}
-
-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 "frameset.h"
-*     void MatchAxesX( AstFrame *frm2, AstFrame *frm1, int *axes )
-*                      int *status )
-
-*  Class Membership:
-*     FrameSet 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 *frm2;
-
-/* Check the global error status. */
-   if ( !astOK ) return;
-
-/* Get a pointer to the current Frame in the FrameSet. */
-   frm2 = astGetFrame( (AstFrameSet *) frm2_frame, AST__CURRENT );
-
-/* Invoke the astMatchAxesX on the current Frame. */
-   astMatchAxesX( frm2, frm1, axes );
-
-/* Free resources */
-   frm2 = astAnnul( frm2 );
-}
-
-static void MirrorVariants( AstFrameSet *this, int iframe, int *status ) {
-/*
-*++
-*  Name:
-c     astMirrorVariants
-f     AST_MIRRORVARIANTS
-
-*  Purpose:
-*     Make the current Frame mirror the variant Mappings in another Frame.
-
-*  Type:
-*     Public virtual function.
-
-*  Synopsis:
-c     #include "frameset.h"
-c     void astMirrorVariants( AstFrameSet *this, int iframe )
-f     CALL AST_MIRRORVARIANTS( THIS, IFRAME, STATUS )
-
-*  Class Membership:
-*     FrameSet method.
-
-*  Description:
-c     This function
-f     This routine
-*     indicates that all access to the Variant attribute of the current
-*     Frame should should be forwarded to some other nominated Frame in
-*     the FrameSet. For instance, if a value is set subsequently for the
-*     Variant attribute of the current Frame, the current Frame will be left
-*     unchanged and the setting is instead applied to the nominated Frame.
-*     Likewise, if the value of the Variant attribute is requested, the
-*     value returned is the value stored for the nominated Frame rather
-*     than the current Frame itself.
-*
-*     This provides a mechanism for propagating the effects of variant
-*     Mappings around a FrameSet. If a new Frame is added to a FrameSet
-*     by connecting it to an pre-existing Frame that has two or more variant
-*     Mappings, then it may be appropriate to set the new Frame so that it
-*     mirrors the variants Mappings of the pre-existing Frame. If this is
-*     done, then it will be possible to select a specific variant Mapping
-*     using either the pre-existing Frame or the new Frame.
-
-*  Parameters:
-c     this
-f     THIS = INTEGER (Given)
-*        Pointer to the FrameSet.
-c     iframe
-f     IFRAME = INTEGER (Given)
-*        The index of the Frame within the FrameSet which is to be
-*        mirrored by the current Frame. This value should lie in the range
-*        from 1 to the number of Frames in the FrameSet (as given by its
-*        Nframe attribute). If AST__NOFRAME is supplied (or the current
-*        Frame is specified), then any mirroring established by a previous
-*        call to this
-c        function
-f        routine
-*        is disabled.
-f     STATUS = INTEGER (Given and Returned)
-f        The global status.
-
-*  Notes:
-*     - Mirrors can be chained. That is, if Frame B is set to be a mirror
-*     of Frame A, and Frame C is set to be a mirror of Frame B, then
-*     Frame C will act as a mirror of Frame A.
-*     - Variant Mappings cannot be added to the current Frame if it is
-*     mirroring another Frame. So calls to the
-c     astAddVariant function
-f     AST_ADDVARIANT routine
-*     will cause an error to be reported if the current Frame is
-*     mirroring another Frame.
-*     - A value of AST__BASE may be given for the
-c     "iframe" parameter
-f     IFRAME argument
-*     to specify the base Frame.
-*     - Any variant Mappings explicitly added to the current Frame using
-c     astAddVariant
-f     AST_ADDVARIANT
-*     will be ignored if the current Frame is mirroring another Frame.
-
-*--
-*/
-
-/* Local Variables: */
-   int icur;
-
-/* Check the global error status. */
-   if ( !astOK ) return;
-
-/* Get the current Frame index. */
-   icur = astGetCurrent( this );
-
-/* If AST__NOFRAME, disable any mirroring. */
-   if( iframe == AST__NOFRAME ) {
-      this->varfrm[ icur - 1 ] = 0;
-
-/* Otherwise, validate and translate the Frame index supplied. */
-   } else {
-      iframe = astValidateFrameIndex( this, iframe, "astMirrorVariants" );
-
-/* If the current Frame has been specified, disable any mirroring. */
-      if( iframe == icur ) {
-         this->varfrm[ icur - 1 ] = 0;
-
-/* Otherwise, store the one-based variants frame index. */
-      } else {
-         this->varfrm[ icur - 1 ] = iframe;
-      }
-   }
-}
-
-static void Norm( AstFrame *this_frame, double value[], int *status ) {
-/*
-*  Name:
-*     Norm
-
-*  Purpose:
-*     Normalise a set of FrameSet coordinates.
-
-*  Type:
-*     Private function.
-
-*  Synopsis:
-*     #include "frameset.h"
-*     void Norm( AstAxis *this, double value[], int *status )
-
-*  Class Membership:
-*     FrameSet member function (over-rides the astNorm method
-*     inherited from the Frame class).
-
-*  Description:
-*     This function converts a set of coordinate values for the
-*     current Frame of a FrameSet, 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.
-*
-*     Typically, for Frames whose axes represent cyclic values (such
-*     as angles or positions on the sky), this function wraps an
-*     arbitrary set of coordinates, so that they lie within the first
-*     cycle (say zero to 2*pi or -pi/2 to +pi/2). For Frames with
-*     ordinary linear axes, without constraints, this function will
-*     typically return the original coordinate values unchanged.
-
-*  Parameters:
-*     this
-*        Pointer to the FrameSet.
-*     value
-*        An array of double, with one element for each FrameSet 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: */
-   AstFrame *fr;                 /* Pointer to the current Frame */
-   AstFrameSet *this;            /* Pointer to the FrameSet structure */
-
-/* Check the global error status. */
-   if ( !astOK ) return;
-
-/* Obtain a pointer to the FrameSet structure. */
-   this = (AstFrameSet *) this_frame;
-
-/* Obtain a pointer to the FrameSet's current Frame and invoke this
-   Frame's astNorm method to obtain the new values. Annul the Frame
-   pointer afterwards. */
-   fr = astGetFrame( this, AST__CURRENT );
-   astNorm( fr, value );
-   fr = astAnnul( fr );
-}
-
-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 "frameset.h"
-*     void astNormBox( AstFrame *this, double lbnd[], double ubnd[],
-*                      AstMapping *reg, int *status )
-
-*  Class Membership:
-*     FrameSet 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: */
-   AstFrame *fr;                 /* Pointer to the current Frame */
-   AstFrameSet *this;            /* Pointer to the FrameSet structure */
-
-/* Check the global error status. */
-   if ( !astOK ) return;
-
-/* Obtain a pointer to the FrameSet structure. */
-   this = (AstFrameSet *) this_frame;
-
-/* Obtain a pointer to the FrameSet's current Frame and invoke this
-   Frame's astNormBox method to obtain the new values. Annul the Frame
-   pointer afterwards. */
-   fr = astGetFrame( this, AST__CURRENT );
-   astNormBox( fr, lbnd, ubnd, reg );
-   fr = astAnnul( fr );
-}
-
-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:
-*     Public virtual function.
-
-*  Synopsis:
-*     #include "frameset.h"
-*     void Offset( AstFrame *this,
-*                  const double point1[], const double point2[],
-*                  double offset, double point3[], int *status )
-
-*  Class Membership:
-*     FrameSet member function (over-rides the protected astOffset
-*     method inherited from the Frame class).
-
-*  Description:
-*     This function finds the FrameSet coordinate values of a point
-*     which is offset a specified distance along the geodesic curve
-*     between two other points.
-
-*  Parameters:
-*     this
-*        Pointer to the FrameSet.
-*     point1
-*        An array of double, with one element for each FrameSet 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 FrameSet 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. 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 FrameSet 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: */
-   AstFrame *fr;                 /* Pointer to current Frame */
-   AstFrameSet *this;            /* Pointer to the FrameSet structure */
-
-/* Check the global error status. */
-   if ( !astOK ) return;
-
-/* Obtain a pointer to the FrameSet structure. */
-   this = (AstFrameSet *) this_frame;
-
-/* Obtain a pointer to the FrameSet's current Frame and invoke this
-   Frame's astOffset method. Annul the Frame pointer afterwards. */
-   fr = astGetFrame( this, AST__CURRENT );
-   astOffset( fr, point1, point2, offset, point3 );
-   fr = astAnnul( fr );
-}
-
-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 in a 2D Frame.
-
-*  Type:
-*     Private function.
-
-*  Synopsis:
-*     #include "frameset.h"
-*     double Offset2( AstFrame *this, const double point1[2], double angle,
-*                     double offset, double point2[2], int *status );
-
-*  Class Membership:
-*     FrameSet member function (over-rides the protected astOffset2
-*     method inherited from the Frame class).
-
-*  Description:
-*     This function finds the Frame coordinate values of a point which
-*     is offset a specified distance along the geodesic curve at a
-*     given angle from a specified starting point. It can only be
-*     used with 2-dimensional Frames.
-*
-*     For example, in a basic Frame, this offset will be along the
-*     straight line joining two points. For a more specialised Frame
-*     describing a sky coordinate system, however, it would be along
-*     the great circle passing through two sky positions.
-
-*  Parameters:
-*     this
-*        Pointer to the Frame.
-*     point1
-*        An array of double, with one element for each Frame axis
-*        (Naxes attribute). 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. If this is positive, it will be in the direction of the
-*        given angle. If it is negative, it will be in the opposite
-*        direction.
-*     point2
-*        An array of double, with one element for each Frame 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.
-*     - An error will be reported if the Frame is not 2-dimensional.
-*     - This function will return "bad" coordinate values (AST__BAD)
-*     if any of the input coordinates has this value.
-*/
-
-/* Local Variables: */
-   AstFrame *fr;                 /* Pointer to current Frame */
-   AstFrameSet *this;            /* Pointer to the FrameSet structure */
-   double result;                /* Value to return */
-
-/* Check the global error status. */
-   if ( !astOK ) return AST__BAD;
-
-/* Obtain a pointer to the FrameSet structure. */
-   this = (AstFrameSet *) this_frame;
-
-/* Obtain a pointer to the FrameSet's current Frame and invoke the
-   astOffset2 method for this Frame. Annul the Frame pointer afterwards. */
-   fr = astGetFrame( this, AST__CURRENT );
-   result = astOffset2( fr, point1, angle, offset, point2 );
-   fr = astAnnul( fr );
-
-/* If an error occurred, clear the result value. */
-   if ( !astOK ) result = AST__BAD;
-
-/* Return the result. */
-   return result;
-}
-
-static void Overlay( AstFrame *template_frame, const int *template_axes,
-                     AstFrame *result, int *status ) {
-/*
-*  Name:
-*     Overlay
-
-*  Purpose:
-*     Overlay the attributes of a template FrameSet on to another Frame.
-
-*  Type:
-*     Private function.
-
-*  Synopsis:
-*     #include "frameset.h"
-*     void Overlay( AstFrame *template, const int *template_axes,
-*                   AstFrame *result, int *status )
-
-*  Class Membership:
-*     FrameSet member function (over-rides the protected astOverlay
-*     method inherited from the Frame class).
-
-*  Description:
-*     This function overlays attributes from the current Frame of a
-*     FrameSet 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.
-
-*  Parameters:
-*     template
-*        Pointer to the template FrameSet, for whose current Frame
-*        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 axis in the current Frame of
-*        the template FrameSet to which it corresponds. This array is
-*        used to establish from which template Frame axis any
-*        axis-dependent attributes should be obtained.
-*
-*        If any axis in the result Frame is not associated with a
-*        template Frame 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.
-*/
-
-/* Local Variables: */
-   AstFrame *fr;                 /* Pointer to current Frame */
-   AstFrameSet *template;        /* Pointer to the FrameSet structure */
-
-/* Check the global error status. */
-   if ( !astOK ) return;
-
-/* Obtain a pointer to the FrameSet structure. */
-   template = (AstFrameSet *) template_frame;
-
-/* Obtain a pointer to the current Frame and invoke its astOverlay
-   method to overlay its attributes. Annul the Frame pointer
-   afterwards. */
-   fr = astGetFrame( template, AST__CURRENT );
-   astOverlay( fr, template_axes, result );
-   fr = astAnnul( fr );
-}
-
-static void PermAxes( AstFrame *this_frame, const int perm[], int *status ) {
-/*
-*  Name:
-*     PermAxes
-
-*  Purpose:
-*     Permute the order of a FrameSet's axes.
-
-*  Type:
-*     Private function.
-
-*  Synopsis:
-*     #include "frameset.h"
-*     void PermAxes( AstFrame *this, const int perm[], int *status )
-
-*  Class Membership:
-*     FrameSet member function (over-rides the astPermAxes method
-*     inherited from the Frame class).
-
-*  Description:
-*     This function permutes the order in which the axes in the
-*     current Frame of a FrameSet occur.
-
-*  Parameters:
-*     this
-*        Pointer to the FrameSet.
-*     perm
-*        An array of int (with one element for each axis of the
-*        FrameSet's current Frame) which lists the axes in their new
-*        order. Each element of this array should be a (zero-based)
-*        axis index identifying the axes according to their old
-*        (un-permuted) order.
-*     status
-*        Pointer to the inherited status variable.
-
-*  Notes:
-*     - Only genuine permutations of the axis order are permitted, so
-*     each axis must be referenced exactly once in the "perm" array.
-*     - If more than one axis permutation is applied to the same Frame
-*     in a FrameSet, the effects are cumulative.
-*/
-
-/* Local Variables: */
-   AstFrame *fr;                 /* Pointer to current Frame */
-   AstFrameSet *this;            /* Pointer to the FrameSet structure */
-   AstPermMap *map;              /* Pointer to axis permutation Mapping */
-   int *invperm;                 /* Pointer to inverse permutation array */
-   int axis;                     /* Loop counter for axes */
-   int naxes;                    /* Number of FrameSet axes */
-
-/* Check the global error status. */
-   if ( !astOK ) return;
-
-/* Obtain a pointer to the FrameSet structure. */
-   this = (AstFrameSet *) this_frame;
-
-/* Validate the permutation array, to check that it describes a
-   genuine permutation. */
-   astCheckPerm( this, perm, "astPermAxes" );
-
-/* Obtain a pointer to the FrameSet's current Frame and invoke this
-   Frame's astPermAxes method to permute its axes. Annul the Frame
-   pointer afterwards. */
-   fr = astGetFrame( this, AST__CURRENT );
-   astPermAxes( fr, perm );
-   fr = astAnnul( fr );
-
-/* Obtain the number of axes in the FrameSet's current Frame and allocate
-   memory to hold an inverse permutation array. */
-   naxes =  astGetNaxes( this );
-   invperm = astMalloc( sizeof( int ) * (size_t) naxes );
-
-/* Fill the inverse permutation array with values that will invert the
-   axis permutation supplied. */
-   if ( astOK ) {
-      for ( axis = 0; axis < naxes; axis++ ) invperm[ perm[ axis ] ] = axis;
-
-/* Create a PermMap that will permute coordinate values in the same way as
-   the current Frame's axes have been permuted. */
-      map = astPermMap( naxes, invperm, naxes, perm, NULL, "", status );
-
-/* Modify the Frame's relationship to the rest of the Frames in the
-   FrameSet so that the correct coordinate values remain associated
-   with the permuted axes. */
-      astRemapFrame( this, AST__CURRENT, map );
-
-/* Annul the PermMap and free the inverse permutation array. */
-      map = astAnnul( map );
-   }
-   invperm = astFree( invperm );
-}
-
-static AstFrame *PickAxes( AstFrame *this_frame, int naxes, const int axes[],
-                           AstMapping **map, int *status ) {
-/*
-*  Name:
-*     PickAxes
-
-*  Purpose:
-*     Create a new Frame by picking axes from a FrameSet.
-
-*  Type:
-*     Private function.
-
-*  Synopsis:
-*     #include "frameset.h"
-*     AstFrame *PickAxes( AstFrame *this, int naxes, const int axes[],
-*                         AstMapping **map, int *status )
-
-*  Class Membership:
-*     FrameSet member function (over-rides the astPickAxes protected
-*     method inherited from the Frame class).
-
-*  Description:
-*     This function creates a new Frame whose axes are copies of axes
-*     picked from the current Frame of an existing FrameSet. Other
-*     Frame attributes are also copied from this current Frame to the
-*     new Frame. Zero or more of the original axes may be picked in
-*     any order, but each can be used only once. Additional axes (with
-*     default characteristics) may be included in the new Frame if
-*     required.
-*
-*     Optionally, a Mapping that converts between the original Frame's
-*     axes and those of the new Frame may also be returned.
-
-*  Parameters:
-*     this
-*        Pointer to the FrameSet.
-*     naxes
-*        The number of axes required in the new Frame.
-*     axes
-*        Pointer to an array of int with naxes elements. This should
-*        contain (zero based) axis indices specifying the axes which
-*        are to be included in the new Frame, in the order
-*        required. Each axis index may occur only once.
-*
-*        If additional (default) axes are also to be included, the
-*        corresponding elements of this array should be set to -1.
-*     map
-*        Address of a location to receive a pointer to a new
-*        Mapping. This will be a PermMap (or a UnitMap as a special
-*        case) that describes the axis permutation that has taken
-*        place between the current Frame of the FrameSet and the new
-*        Frame.  The forward transformation will convert from the
-*        original FrameSet's axes to the new one's, and vice versa.
-*
-*        If this Mapping is not required, a NULL value may be supplied
-*        for this parameter.
-*     status
-*        Pointer to the inherited status variable.
-
-*  Returned Value:
-*     Pointer to the new Frame.
-
-*  Notes:
-*     - The class of object returned may differ from that of the
-*     original current Frame, depending on which axes are
-*     selected. For example, if a single axis is picked from a
-*     SkyFrame (which always has two axes), the resulting Frame cannot
-*     be a valid SkyFrame, so will revert to the parent class (Frame)
-*     instead.
-*     - The new Frame contains a deep copy of all the data selected
-*     from the original current Frame. Modifying the new Frame will
-*     therefore not affect the FrameSet or the Frames it contains.
-*     - 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: */
-   AstFrame *fr;                 /* Pointer to current Frame */
-   AstFrame *frame;              /* Pointer to Frame to be returned */
-   AstFrameSet *this;            /* Pointer to FrameSet structure */
-
-/* Initialise the returned pointers. */
-   if ( map ) *map = NULL;
-   frame = NULL;
-
-/* Check the global error status. */
-   if ( !astOK ) return frame;
-
-/* Obtain a pointer to the FrameSet structure. */
-   this = (AstFrameSet *) this_frame;
-
-/* Check that a valid set of axes is being selected . */
-   astValidateAxisSelection( this, naxes, axes, "astPickAxes" );
-
-/* Obtain a pointer to the FrameSet's current Frame and use its
-   astPickAxes method to obtain the required new Frame and
-   Mapping. Annul the current Frame pointer afterwards. */
-   fr = astGetFrame( this, AST__CURRENT );
-   frame = astPickAxes( fr, naxes, axes, map );
-   fr = astAnnul( fr );
-
-/* If an error occurred, annul the Mapping pointer (if requested) and
-   the new Frame pointer. */
-   if ( !astOK ) {
-      if ( map ) *map = astAnnul( *map );
-      frame = astAnnul( frame );
-   }
-
-/* Return the pointer to the new Frame. */
-   return frame;
-}
-
-static void PrimaryFrame( AstFrame *this_frame, int axis1,
-                          AstFrame **frame, int *axis2, int *status ) {
-/*
-*  Name:
-*     PrimaryFrame
-
-*  Purpose:
-*     Uniquely identify a primary Frame and one of its axes.
-
-*  Type:
-*     Private function.
-
-*  Synopsis:
-*     #include "frameset.h"
-*     void PrimaryFrame( AstFrame *this, int axis1, AstFrame **frame,
-*                        int *axis2, int *status )
-
-*  Class Membership:
-*     FrameSet member function (over-rides the protected
-*     astPrimaryFrame method inherited from the Frame class).
-
-*  Description:
-*     This function returns information about the underlying (primary)
-*     Frame corresponding to a specified axis of the current Frame of
-*     a FrameSet, when this current Frame may be a compound Frame
-*     composed of more than one simpler one.
-
-*  Parameters:
-*     this
-*        Pointer to the FrameSet.
-*     axis1
-*        An axis index (zero-based) identifying the axis of the
-*        FrameSet's current Frame for which information is required.
-*     frame
-*        Address of a location to receive a pointer to the underlying
-*        (primary) frame to which the requested axis belongs
-*        (i.e. this will not be a compound Frame).
-*     axis2
-*        Pointer to an int which is to receive the axis index within
-*        "frame" which identifies the axis being referred to, using
-*        the axis order that applied when the primary Frame was
-*        originally constructed (i.e. this function undoes all
-*        subsequent axis pemutations and the effects of combining
-*        Frames, in order to reveal the original underlying axis
-*        order).
-*     status
-*        Pointer to the inherited status variable.
-
-*  Notes:
-*     - This protected method is provided so that class
-*     implementations can distinguish the axes of Frames from one
-*     another (e.g. can distinguish a longitude axis as being
-*     different from a latitide axis) even after their order has been
-*     permuted and they have been combined with axes from other
-*     Frames.
-*     - The reference count of the primary Frame will be incremented
-*     by one to reflect the new pointer returned.
-*/
-
-/* Local Variables: */
-   AstFrame *fr;                 /* Pointer to current Frame */
-   AstFrameSet *this;            /* Pointer to the FrameSet structure */
-
-/* Initialise the returned values. */
-   *frame = NULL;
-   *axis2 = 0;
-
-/* Check the global error status. */
-   if ( !astOK ) return;
-
-/* Obtain a pointer to the FrameSet structure. */
-   this = (AstFrameSet *) this_frame;
-
-/* Validate the axis index supplied. */
-   (void) astValidateAxis( this, axis1, 1, "astPrimaryFrame" );
-
-/* Obtain a pointer to the FrameSet's current Frame and invoke its
-   astPrimaryFrame method. Annul the Frame pointer afterwards. */
-   fr = astGetFrame( this, AST__CURRENT );
-   astPrimaryFrame( fr, axis1, frame, axis2 );
-   fr = astAnnul( fr );
-
-/* If an error occurred, annul the returned object and clear the
-   returned axis value. */
-   if ( !astOK ) {
-      *frame = astAnnul( *frame );
-      *axis2 = 0;
-   }
-}
-
-static double Rate( AstMapping *this_mapping, double *at, int ax1, int ax2, int *status ){
-/*
-*  Name:
-*     Rate
-
-*  Purpose:
-*     Calculate the rate of change of a Mapping output.
-
-*  Type:
-*     Private function.
-
-*  Synopsis:
-*     #include "frameset.h"
-*     result = Rate( AstMapping *this, double *at, int ax1, int ax2, int *status )
-
-*  Class Membership:
-*     FrameSet member function (over-rides the astRate method
-*     inherited from the Frame class).
-
-*     This function evaluates the rate of change of a specified output of
-*     the supplied Mapping with respect to a specified input, at a
-*     specified input position.
-*
-*     The result is estimated by interpolating the function using a
-*     fourth order polynomial in the neighbourhood of the specified
-*     position. The size of the neighbourhood used is chosen to minimise
-*     the RMS residual per unit length between the interpolating
-*     polynomial and the supplied Mapping function.
-
-*  Parameters:
-*     this
-*        Pointer to the Mapping to be applied.
-*     at
-*        The address of an array holding the axis values at the position
-*        at which the rate of change is to be evaluated. The number of
-*        elements in this array should equal the number of inputs to the
-*        Mapping.
-*     ax1
-*        The index of the Mapping output for which the rate of change is to
-*        be found (output numbering starts at 0 for the first output).
-*     ax2
-*        The index of the Mapping input which is to be varied in order to
-*        find the rate of change (input numbering starts at 0 for the first
-*        input).
-*     status
-*        Pointer to the inherited status variable.
-
-*  Returned Value:
-*     astRate()
-*        The rate of change of Mapping output "ax1" with respect to input
-*        "ax2", evaluated at "at", or AST__BAD if the value cannot be
-*        calculated.
-
-*  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: */
-   AstFrameSet *this;            /* Pointer to the FrameSet structure */
-   AstMapping *map;              /* Pointer to the base->current Mapping */
-   double result;                /* Returned rate of change */
-
-/* Check the global error status. */
-   if ( !astOK ) return AST__BAD;
-
-/* Obtain a pointer to the FrameSet structure. */
-   this = (AstFrameSet *) this_mapping;
-
-/* Obtain the Mapping between the base and current Frames in the
-   FrameSet (note this takes account of whether the FrameSet has been
-   inverted). */
-   map = astGetMapping( this, AST__BASE, AST__CURRENT );
-
-/* Invoke the astRate method on the Mapping. */
-   result = astRate( map, at, ax1, ax2 );
-
-/* Annul the Mapping pointer. */
-   map = astAnnul( map );
-
-/* Return a pointer to the output PointSet. */
-   return result;
-}
-
-static void RecordIntegrity( AstFrameSet *this, int *status ) {
-/*
-*+
-*  Name:
-*     RecordIntegrity
-
-*  Purpose:
-*     Record the current integrity state of a FrameSet.
-
-*  Type:
-*     Private function.
-
-*  Synopsis:
-*     #include "frameset.h"
-*     void RecordIntegrity( AstFrameSet *this, int *status )
-
-*  Class Membership:
-*     FrameSet member function.
-
-*  Description:
-*     This function makes a record of the current integrity state of a
-*     FrameSet by taking a copy of its current Frame (it stores a
-*     pointer to this copy in a static variable). If the current Frame
-*     is subsequently modified, the RestoreIntegrity function can then
-*     attempt to restore the FrameSet's integrity to this recorded
-*     state by appropriately remapping its current Frame.
-
-*  Parameters:
-*     this
-*        Pointer to the FrameSet.
-*-
-*     status
-*        Pointer to the inherited status variable.
-*/
-
-/* Local Variables: */
-   astDECLARE_GLOBALS            /* Declare the thread specific global data */
-   AstFrame *current;            /* Pointer to current Frame */
-
-/* Get a pointer to the structure holding thread-specific global data. */
-   astGET_GLOBALS(this);
-
-/* Initialise the record of the FrameSet's integrity. */
-   integrity_frame = NULL;
-   integrity_lost = 0;
-
-/* Check the global error status. */
-   if ( !astOK ) return;
-
-/* Obtain a pointer to the FrameSet's current Frame. */
-   current = astGetFrame( this, AST__CURRENT );
-
-/* Make a copy of this Frame, storing its pointer. */
-   integrity_frame = astCopy( current );
-
-/* Annul the current Frame pointer. */
-   current = astAnnul( current );
-}
-
-static void RemapFrame( AstFrameSet *this, int iframe, AstMapping *map, int *status ) {
-/*
-*++
-*  Name:
-c     astRemapFrame
-f     AST_REMAPFRAME
-
-*  Purpose:
-*     Modify a Frame's relationship to other Frames in a FrameSet.
-
-*  Type:
-*     Public virtual function.
-
-*  Synopsis:
-c     #include "frameset.h"
-c     void astRemapFrame( AstFrameSet *this, int iframe, AstMapping *map )
-f     CALL AST_REMAPFRAME( THIS, IFRAME, MAP, STATUS )
-
-*  Class Membership:
-*     FrameSet method.
-
-*  Description:
-c     This function modifies the relationship (i.e. Mapping) between a
-f     This routine modifies the relationship (i.e. Mapping) between a
-*     specified Frame in a FrameSet and the other Frames in that
-*     FrameSet.
-*
-*     Typically, this might be required if the FrameSet has been used
-*     to calibrate (say) an image, and that image is re-binned. The
-*     Frame describing the image will then have undergone a coordinate
-*     transformation, and this should be communicated to the associated
-c     FrameSet using this function.
-f     FrameSet using this routine.
-
-*  Parameters:
-c     this
-f     THIS = INTEGER (Given)
-*        Pointer to the FrameSet.
-c     iframe
-f     IFRAME = INTEGER (Given)
-*        The index within the FrameSet of the Frame to be modified.
-*        This value should lie in the range from 1 to the number of
-*        Frames in the FrameSet (as given by its Nframe attribute).
-c     map
-f     MAP = INTEGER (Given)
-*        Pointer to a Mapping whose forward transformation converts
-*        coordinate values from the original coordinate system
-*        described by the Frame to the new one, and whose inverse
-*        transformation converts in the opposite direction.
-f     STATUS = INTEGER (Given and Returned)
-f        The global status.
-
-*  Notes:
-*     - A value of AST__BASE or AST__CURRENT may be given for the
-c     "iframe" parameter to specify the base Frame or the current
-f     IFRAME argument to specify the base Frame or the current
-*     Frame respectively.
-*     - The relationship between the selected Frame and any other
-c     Frame within the FrameSet will be modified by this function,
-f     Frame within the FrameSet will be modified by this routine,
-*     but the relationship between all other Frames in the FrameSet
-*     remains unchanged.
-*     - The number of input coordinate values accepted by the Mapping
-*     (its Nin attribute) and the number of output coordinate values
-*     generated (its Nout attribute) must be equal and must match the
-*     number of axes in the Frame being modified.
-*     - If a simple change of axis order is required, then the
-c     astPermAxes function may provide a more straightforward method
-f     AST_PERMAXES routine may provide a more straightforward method
-*     of making the required changes to the FrameSet.
-c     - This function cannot be used to change the number of Frame
-f     - This routine cannot be used to change the number of Frame
-*     axes. To achieve this, a new Frame must be added to the FrameSet
-c     (astAddFrame) and the original one removed if necessary
-c     (astRemoveFrame).
-f     (AST_ADDFRAME) and the original one removed if necessary
-f     (AST_REMOVEFRAME).
-*     - Any variant Mappings associated with the remapped Frame (except
-*     for the current variant) will be lost as a consequence of calling this
-*     method (see attribute "Variant").
-*--
-*/
-
-/* Local Variables: */
-   AstFrame *fr;                 /* Pointer to Frame */
-   int icur;                     /* Index of original current Frame */
-   int naxes;                    /* Number of Frame axes */
-   int nin;                      /* Number of Mapping input coordinates */
-   int nout;                     /* Number of Mapping output coordinates */
-   int varfrm;                   /* The index of the variants frame */
-
-/* Check the global error status. */
-   if ( !astOK ) return;
-
-/* Validate and translate the Frame index supplied. */
-   iframe = astValidateFrameIndex( this, iframe, "astRemapFrame" );
-
-/* Variant Mappings from a source node to a destination node are stored
-   within the Frame object associated with the destination node. But
-   remapping a Frame causes the Frame to be dissociated from its original
-   node, and associated with a new node, leaving the original node
-   without any Frame in which to store its variant mappings. So we are
-   forced to remove the variant Mappings if the Frame is remapped. We do
-   this by clearing the Variant attribute before the Frame is remapped.
-   This will leave the current variant as the sole Mapping between the
-   original source and destination nodes. However, if the Frame being
-   remapped is just a mirror for another Frame, then we do not need to
-   do this since the Frame being mirrored is not itself being remapped
-   and so can retain its variant mappings. So we temporarily prevent the
-   remapped Frame from acting as a mirror before we clear the Variant
-   attribute. */
-   icur = astGetCurrent( this );
-   astSetCurrent( this, iframe );
-
-   varfrm = this->varfrm[ iframe - 1 ];
-   this->varfrm[ iframe - 1 ] = 0;
-
-   astClearVariant( this );
-
-   this->varfrm[ iframe - 1 ] = varfrm;
-   astSetCurrent( this, icur );
-
-/* Obtain the number of input and output coordinates per point for the
-   Mapping supplied. */
-   nin = astGetNin( map );
-   nout = astGetNout( map );
-
-/* Obtain a pointer to the specified Frame and determine how many axes
-   it has. Annul the Frame pointer afterwards. */
-   fr = astGetFrame( this, iframe );
-   naxes = astGetNaxes( fr );
-   fr = astAnnul( fr );
-
-/* Check that the number of input coordinates matches the number of
-   Frame axes and report an error if necessary. */
-   if ( astOK ) {
-      if ( nin != naxes ) {
-         astError( AST__NCPIN, "astRemapFrame(%s): Bad number of %s input "
-                   "coordinate values (%d).", status, astGetClass( this ),
-                   astGetClass( map ), nin );
-         astError( AST__NCPIN, "The %s given should accept %d coordinate "
-                   "value%s for each input point.", status, astGetClass( map ), naxes,
-                   ( naxes == 1 ) ? "" : "s" );
-
-/* Similarly, check that the number of output coordinates matches the
-   number of Frame axes. */
-      } else if ( nout != naxes ) {
-         astError( AST__NCPIN, "astRemapFrame(%s): Bad number of %s output "
-                   "coordinate values (%d).", status, astGetClass( this ),
-                   astGetClass( map ), nout );
-         astError( AST__NCPIN, "The %s given should generate %d "
-                   "coordinate value%s for each output point.", status,
-                   astGetClass( map ), naxes, ( naxes == 1 ) ? "" : "s" );
-      }
-   }
-
-/* If there is more than one Frame present in the FrameSet, extend the
-   FrameSet arrays to hold a new node. */
-   if ( astOK && ( this->nframe > 1 ) ) {
-      this->map = astGrow( this->map, this->nnode, sizeof( AstMapping * ) );
-      this->link = astGrow( this->link, this->nnode, sizeof( int ) );
-      this->invert = astGrow( this->invert, this->nnode, sizeof( int ) );
-
-/* Clone and store a pointer to the Mapping. */
-      if ( astOK ) {
-         this->map[ this->nnode - 1 ] = astClone( map );
-
-/* Add a new "link" element showing that the new node is derived from
-   that of the old Frame and store the current value of the Invert
-   attribute for the Mapping. */
-         this->link[ this->nnode - 1 ] = this->node[ iframe - 1 ];
-         this->invert[ this->nnode - 1 ] = astGetInvert( map );
-
-/* Increment the node count and associate the modified Frame with the
-   new node. */
-         if ( astOK ) {
-            this->nnode++;
-            this->node[ iframe - 1 ] = this->nnode - 1;
-
-/* Tidy the resulting set of nodes, because the node originally
-   referenced by the Frame may no longer be needed. This also
-   simplifies any compound Mapping which may result if this node is
-   removed. */
-            TidyNodes( this, status );
-         }
-      }
-   }
-}
-
-static void RemoveFrame( AstFrameSet *this, int iframe, int *status ) {
-/*
-*++
-*  Name:
-c     astRemoveFrame
-f     AST_REMOVEFRAME
-
-*  Purpose:
-*     Remove a Frame from a FrameSet.
-
-*  Type:
-*     Public virtual function.
-
-*  Synopsis:
-c     #include "frameset.h"
-c     void astRemoveFrame( AstFrameSet *this, int iframe )
-f     CALL AST_REMOVEFRAME( THIS, IFRAME, STATUS )
-
-*  Class Membership:
-*     FrameSet method.
-
-*  Description:
-c     This function removes a Frame from a FrameSet. All other Frames
-f     This routine removes a Frame from a FrameSet. All other Frames
-*     in the FrameSet have their indices re-numbered from one (if
-*     necessary), but are otherwise unchanged.
-
-*  Parameters:
-c     this
-f     THIS = INTEGER (Given)
-*        Pointer to the FrameSet.
-c     iframe
-f     IFRAME = INTEGER (Given)
-*        The index within the FrameSet of the Frame to be removed.
-*        This value should lie in the range from 1 to the number of
-*        Frames in the FrameSet (as given by its Nframe attribute).
-f     STATUS = INTEGER (Given and Returned)
-f        The global status.
-
-*  Notes:
-*     - Removing a Frame from a FrameSet does not affect the
-*     relationship between other Frames in the FrameSet, even if they
-*     originally depended on the Frame being removed.
-*     - The number of Frames in a FrameSet cannot be reduced to zero.
-*     An error will result if an attempt is made to remove the only
-*     remaining Frame.
-*     - A value of AST__BASE or AST__CURRENT may be given for the
-c     "iframe" parameter to specify the base Frame or the current
-f     IFRAME argument to specify the base Frame or the current
-*     Frame respectively.
-*     - If a FrameSet's base or current Frame is removed, the Base or
-*     Current attribute (respectively) of the FrameSet will have its
-*     value cleared, so that another Frame will then assume its role
-*     by default.
-*     - If any other Frame is removed, the base and current Frames
-*     will remain the same. To ensure this, the Base and/or Current
-*     attributes of the FrameSet will be changed, if necessary, to
-*     reflect any change in the indices of these Frames.
-*--
-*/
-
-/* Local Variables: */
-   int ifr;                      /* Loop counter for Frames */
-   int ii;                       /* Base/current Frame index */
-
-/* Check the global error status. */
-   if ( !astOK ) return;
-
-/* Validate and translate the Frame index supplied. */
-   iframe = astValidateFrameIndex( this, iframe, "astRemoveFrame" );
-   if ( astOK ) {
-
-/* Reject any attempt to remove the final Frame from the FrameSet. */
-      if ( this->nframe == 1 ) {
-         astError( AST__REMIN, "astRemoveFrame(%s): Invalid attempt to "
-                   "remove the only Frame in a %s.", status, astGetClass( this ),
-                   astGetClass( this ) );
-
-/* If OK, annul the pointer to the selected Frame. */
-      } else {
-         this->frame[ iframe - 1 ] = astAnnul( this->frame[ iframe - 1 ] );
-
-/* Ensure that the variant Mappings in the Frame being removed are not
-   mirrored by any other Frames in the FrameSet. */
-         RemoveMirrors( this, iframe, status );
-
-/* Any Frames that are mirroring variants in Frames higher than the
-   removed Frame need to have their mirror frame indices decremented. */
-         for ( ifr = 1; ifr <= this->nframe; ifr++ ) {
-            if( this->varfrm[ ifr - 1 ] > iframe ) this->varfrm[ ifr - 1 ]--;
-         }
-
-/* Loop to move all subsequent Frame pointers down in the FrameSet's
-   "frame" array to close the resulting gap. Also move the associated
-   "node" and "varfrm" array contents in the same way. */
-         for ( ifr = iframe; ifr < this->nframe; ifr++ ) {
-            this->frame[ ifr - 1 ] = this->frame[ ifr ];
-            this->node[ ifr - 1 ] = this->node[ ifr ];
-            this->varfrm[ ifr - 1 ] = this->varfrm[ ifr ];
-         }
-         this->frame[ this->nframe - 1 ] = NULL;
-         this->node[ this->nframe - 1 ] = -1;
-         this->varfrm[ this->nframe - 1 ] = 0;
-
-/* Decrement the Frame count. */
-         this->nframe--;
-
-/* Tidy the nodes in the FrameSet. */
-         TidyNodes( this, status );
-
-/* If the Base attribute is set and the removed Frame was the base
-   Frame, then clear the attribute value so that a new base Frame will
-   be selected by default. */
-         if ( astTestBase( this ) ) {
-            ii = astGetBase( this );
-            if ( iframe == ii ) {
-               astClearBase( this );
-
-/* If the index of the removed Frame is smaller than the base Frame
-   index, then decrement the Base attribute so that the same base
-   Frame will be used in future. */
-            } else if ( iframe < ii ) {
-               astSetBase( this, ii - 1 );
-            }
-         }
-
-/* Repeat the above procedure for the current Frame. */
-         if ( astTestCurrent( this ) ) {
-            ii = astGetCurrent( this );
-            if ( iframe == ii ) {
-               astClearCurrent( this );
-            } else if ( iframe < ii ) {
-               astSetCurrent( this, ii - 1 );
-            }
-         }
-      }
-   }
-}
-
-static void RemoveMirrors( AstFrameSet *this, int iframe, int *status ) {
-/*
-*  Name:
-*     RemoveMirrors
-
-*  Purpose:
-*     Ensure no other Frames act as mirrors for a specified Frame.
-
-*  Type:
-*     Private function.
-
-*  Synopsis:
-*     #include "frameset.h"
-*     void RemoveMirrors( AstFrameSet *this, int iframe, int *status )
-
-*  Class Membership:
-*     Private function.
-
-*  Description:
-*     This function searchs the FrameSet for Frames that are currently
-*     acting as mirrors for the variant Mappings in the Frame with index
-*     "iframe", and disables mirroring in any found Frames. It should be
-*     used when "iframe" has its variant Mappings removed.
-
-*  Parameters:
-*     this
-*        Pointer to the FrameSet.
-*     iframe
-*        One-based index of a Frame that has had its variant Mappings
-*        removed.
-*     status
-*        Pointer to the inherited status variable.
-
-*/
-
-/* Local Variables: */
-   int *frmlist;
-   int ifr;
-   int nfrm;
-
-/* Check the global error status. */
-   if ( !astOK ) return;
-
-/* Iniitalise a list to hold the indices of the FRames that mirror
-   "iframe". */
-   nfrm = 0;
-   frmlist = NULL;
-
-/* Check each Frame in the FrameSet. */
-   for( ifr = 1; ifr <= this->nframe; ifr++ ) {
-
-/* Get the index of the Frame that defines the variant Mappings to use
-   with Frame "ifr". If this is "iframe", then add "ifr" to the list of
-   Frames that need to be "de-mirrored". We cannot "de-mirror" the Frame
-   immediately as doing so may break a chain of mirrors, resulting in the
-   Frames higher up the chain no longer being associated with "iframe". */
-      if( GetVarFrm( this, ifr, status ) == iframe ) {
-         frmlist = astGrow( frmlist, nfrm + 1, sizeof( *frmlist ) );
-         if( astOK ) frmlist[ nfrm++ ] = ifr;
-      }
-   }
-
-/* Loop round all the Frames found above that mirror "iframe". */
-   for( ifr = 0; ifr < nfrm; ifr++ ) {
-
-/* Indicate that the Frame no longer mirrors any other Frame. */
-      this->varfrm[ frmlist[ ifr ] - 1 ] = 0;
-   }
-
-/* Free the list. */
-   frmlist = astFree( frmlist );
-}
-
-static AstMapping *RemoveRegions( AstMapping *this_mapping, int *status ) {
-/*
-*  Name:
-*     RemoveRegions
-
-*  Purpose:
-*     Remove any Regions from a Mapping.
-
-*  Type:
-*     Private function.
-
-*  Synopsis:
-*     #include "frameset.h"
-*     AstMapping *RemoveRegions( AstMapping *this, int *status )
-
-*  Class Membership:
-*     FrameSet method (over-rides the astRemoveRegions method inherited
-*     from the Mapping class).
-
-*  Description:
-*     This function searches the supplied Mapping (which may be a
-*     compound Mapping such as a FrameSet) for any component Mappings
-*     that are instances of the AST Region class. It then creates a new
-*     Mapping from which all Regions have been removed. If a Region
-*     cannot simply be removed (for instance, if it is a component of a
-*     parallel FrameSet), then it is replaced with an equivalent UnitMap
-*     in the returned Mapping.
-*
-*     The implementation provided by the FrameSet class invokes the
-*     astRemoveRegions method on all the component Frames and Mappings,
-*     and joins the results together into a new FrameSet.
-
-*  Parameters:
-*     this
-*        Pointer to the original Region.
-*     status
-*        Pointer to the inherited status variable.
-
-*  Returned Value:
-*     A pointer to the modified mapping.
-
-*  Notes:
-*     - A NULL pointer value will be returned if this function is
-*     invoked with the AST error status set, or if it should fail for
-*     any reason.
-*/
-
-/* Local Variables: */
-   AstFrame **newfrms;           /* Array of new Frames */
-   AstFrameSet *new;             /* Pointer to new FrameSet */
-   AstFrameSet *this;            /* Pointer to FrameSet structure */
-   AstMapping **newmaps;         /* Array of new Mappings */
-   AstMapping *result;           /* Result pointer to return */
-   int changed;                  /* Has any mapping been changed? */
-   int i;                        /* Loop count */
-   int nax;                      /* Number of Frame axes */
-
-/* Initialise. */
-   result = NULL;
-
-/* Check the global error status. */
-   if ( !astOK ) return result;
-
-/* Get a pointer to the FrameSet. */
-   this = (AstFrameSet *) this_mapping;
-
-/* Allocate arrays to hold the modified Mapping and Frame pointers. */
-   newmaps = astMalloc( sizeof( AstMapping *)*( this->nnode - 1 ) );
-   newfrms = astMalloc( sizeof( AstFrame *)*( this->nframe ) );
-   if( astOK ) {
-
-/* Invoke the astRemoveRegions method on all the component Mappings. */
-      changed = 0;
-      for( i = 0; i < this->nnode - 1; i++ ) {
-         newmaps[ i ] = astRemoveRegions( this->map[ i ] );
-
-/* Note if any Mapping was changed. */
-         if( newmaps[ i ] != this->map[ i ] ) {
-            changed = 1;
-
-/* The implementation of the astRemoveRegions method provided by the
-   Region class returns a Frame rather than a UnitMap. But we need
-   Mappings here, not Frames. So if the new Mapping is a Frame, replace
-   it with an equivalent UnitMap. */
-            if( astIsAFrame( newmaps[ i ] ) ) {
-               nax = astGetNin( newmaps[ i ] );
-               (void) astAnnul( newmaps[ i ] );
-               newmaps[ i ] = (AstMapping *) astUnitMap( nax, " ", status );
-            }
-         }
-      }
-
-/* Invoke the astRemoveRegions method on all the component Frames. */
-      for( i = 0; i < this->nframe; i++ ) {
-         newfrms[ i ] = astRemoveRegions( this->frame[ i ] );
-
-/* Note if any Frame was changed. */
-         if( newfrms[ i ] != this->frame[ i ] ) changed = 1;
-      }
-
-/* If no component was modified, just return a clone of the supplied
-   pointer. */
-      if( ! changed ) {
-         result = astClone( this );
-
-/* Otherwise, we need to create a new FrameSet to return. We take a deep
-   copy of the supplied FrameSet and then modify the Mappings and Frames
-   so that we retain any extra information in the supplied FrameSet. */
-      } else {
-         new = astCopy( this );
-
-         for( i = 0; i < this->nnode - 1; i++ ) {
-            (void) astAnnul( new->map[ i ] );
-            new->map[ i ] = astClone( newmaps[ i ] );
-         }
-
-         for( i = 0; i < this->nframe; i++ ) {
-            (void) astAnnul( new->frame[ i ] );
-            new->frame[ i ] = astClone( newfrms[ i ] );
-         }
-
-         result = (AstMapping *) new;
-      }
-
-/* Free resources. */
-      for( i = 0; i < this->nnode - 1; i++ ) {
-         newmaps[ i ] = astAnnul( newmaps[ i ] );
-      }
-
-      for( i = 0; i < this->nframe; i++ ) {
-         newfrms[ i ] = astAnnul( newfrms[ i ] );
-      }
-
-   }
-
-   newfrms = astFree( newfrms );
-   newmaps = astFree( newmaps );
-
-/* Annul the returned Mapping if an error has occurred. */
-   if( !astOK ) result = astAnnul( result );
-
-/* Return the result. */
-   return result;
-}
-
-static void ReportPoints( AstMapping *this_mapping, int forward,
-                          AstPointSet *in_points, AstPointSet *out_points, int *status ) {
-/*
-*  Name:
-*     ReportPoints
-
-*  Purpose:
-*     Report the effect of transforming a set of points using a FrameSet.
-
-*  Type:
-*     Private function.
-
-*  Synopsis:
-*     #include "mapping.h"
-*     void ReportPoints( AstMapping *this, int forward,
-*                        AstPointSet *in_points, AstPointSet *out_points, int *status )
-
-*  Class Membership:
-*     FrameSet member function (over-rides the protected astReportPoints
-*     method inherited from the Frame class).
-
-*  Description:
-*     This function reports the coordinates of a set of points before
-*     and after being transformed by a FrameSet, by writing them to
-*     standard output.
-
-*  Parameters:
-*     this
-*        Pointer to the FrameSet.
-*     forward
-*        A non-zero value indicates that the FrameSet's forward
-*        coordinate transformation has been applied, while a zero
-*        value indicates the inverse transformation.
-*     in_points
-*        Pointer to a PointSet which is associated with the
-*        coordinates of a set of points before the FrameSet was
-*        applied.
-*     out_points
-*        Pointer to a PointSet which is associated with the
-*        coordinates of the same set of points after the FrameSet has
-*        been applied.
-*     status
-*        Pointer to the inherited status variable.
-*/
-
-/* Local Variables: */
-   AstFrame *base_frame;         /* Pointer to current Frame */
-   AstFrame *current_frame;      /* Pointer to base Frame */
-   AstFrameSet *this;            /* Pointer to the FrameSet structure */
-   double **ptr_in;              /* Pointer to array of input data pointers */
-   double **ptr_out;             /* Pointer to array of output data pointers */
-   int coord;                    /* Loop counter for coordinates */
-   int ncoord_in;                /* Number of input coordinates per point */
-   int ncoord_out;               /* Number of output coordinates per point */
-   int npoint;                   /* Number of points to report */
-   int npoint_in;                /* Number of input points */
-   int npoint_out;               /* Number of output points */
-   int point;                    /* Loop counter for points */
-
-/* Check the global error status. */
-   if ( !astOK ) return;
-
-/* Obtain a pointer to the FrameSet structure. */
-   this = (AstFrameSet *) this_mapping;
-
-/* Obtain the numbers of points and coordinates associated with each
-   PointSet. */
-   npoint_in = astGetNpoint( in_points );
-   npoint_out = astGetNpoint( out_points );
-   ncoord_in = astGetNcoord( in_points );
-   ncoord_out = astGetNcoord( out_points );
-
-/* Obtain the pointers that give access to the coordinate data
-   associated with each PointSet. */
-   ptr_in = astGetPoints( in_points );
-   ptr_out = astGetPoints( out_points );
-
-/* In the event that both PointSets don't contain equal numbers of
-   points (this shouldn't actually happen), simply use the minimum
-   number. */
-   npoint = ( npoint_in < npoint_out ) ? npoint_in : npoint_out;
-
-/* Obtain pointers to the FrameSet's base and current Frames. */
-   base_frame = astGetFrame( this, AST__BASE );
-   current_frame = astGetFrame( this, AST__CURRENT );
-
-/* Loop to report the effect of the transformation on each point in
-   turn. */
-   if ( astOK ) {
-      for ( point = 0; point < npoint; point++ ) {
-
-/* Report the input coordinates (in parentheses and separated by
-   commas). Format each value for display using the appropriate
-   Frame's astFormat method. */
-         printf( "(" );
-         for ( coord = 0; coord < ncoord_in; coord++ ) {
-            printf( "%s%s", coord ? ", " : "",
-                    astFormat( forward ? base_frame : current_frame,
-                               coord, ptr_in[ coord ][ point ] ) );
-         }
-
-/* Similarly report the output coordinates, this time formatting
-   values using the other Frame's astFormat method. */
-         printf( ") --> (" );
-         for ( coord = 0; coord < ncoord_out; coord++ ) {
-            printf( "%s%s", coord ? ", " : "",
-                    astFormat( forward ? current_frame : base_frame,
-                               coord, ptr_out[ coord ][ point ] ) );
-         }
-         printf( ")\n" );
-      }
-   }
-
-/* Annul the Frame pointers. */
-   base_frame = astAnnul( base_frame );
-   current_frame = astAnnul( current_frame );
-}
-
-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 "frameset.h"
-*     void Resolve( AstFrame *this, const double point1[],
-*                   const double point2[], const double point3[],
-*                   double point4[], double *d1, double *d2, int *status );
-
-*  Class Membership:
-*     FrameSet member function (over-rides the protected 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.
-
-*  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 value is always positive.
-*     status
-*        Pointer to the inherited status variable.
-
-*  Notes:
-*     - Each vector used in 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, or if the required
-*     output values are undefined.
-*/
-
-/* Local Variables: */
-   AstFrame *fr;                 /* Pointer to current Frame */
-   AstFrameSet *this;            /* Pointer to the FrameSet structure */
-
-/* Check the global error status. */
-   if ( !astOK ) return;
-
-/* Obtain a pointer to the FrameSet structure. */
-   this = (AstFrameSet *) this_frame;
-
-/* Obtain a pointer to the FrameSet's current Frame and invoke this
-   Frame's astResolve method. Annul the Frame pointer afterwards. */
-   fr = astGetFrame( this, AST__CURRENT );
-   astResolve( fr, point1, point2, point3, point4, d1, d2 );
-   fr = astAnnul( fr );
-
-}
-
-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 "frameset.h"
-*     AstPointSet *astResolvePoints( AstFrame *this, const double point1[],
-*                                    const double point2[], AstPointSet *in,
-*                                    AstPointSet *out )
-
-*  Class Membership:
-*     FrameSet 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 always be positive.
-
-*  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.
-*/
-
-/* Local Variables: */
-   AstPointSet *result;          /* Pointer to output PointSet */
-   AstFrameSet *this;            /* Pointer to FrameSet structure */
-   AstFrame *fr;                 /* Pointer to current Frame */
-
-/* Initialise. */
-   result = NULL;
-
-/* Check the global error status. */
-   if ( !astOK ) return result;
-
-/* Obtain a pointer to the FrameSet structure. */
-   this = (AstFrameSet *) this_frame;
-
-/* Obtain a pointer to the FrameSet's current Frame and invoke this
-   Frame's astResolvePoints method. Annul the Frame pointer afterwards. */
-   fr = astGetFrame( this, AST__CURRENT );
-   result = astResolvePoints( this, point1, point2, in, out );
-   fr = astAnnul( fr );
-
-/* Return a pointer to the output PointSet. */
-   return result;
-
-}
-
-static void RestoreIntegrity( AstFrameSet *this, int *status ) {
-/*
-*+
-*  Name:
-*     RestoreIntegrity
-
-*  Purpose:
-*     Restore a previous integrity state for a FrameSet.
-
-*  Type:
-*     Private function.
-
-*  Synopsis:
-*     #include "frameset.h"
-*     void RestoreIntegrity( AstFrameSet *this )
-
-*  Class Membership:
-*     FrameSet member function.
-
-*  Description:
-*     This function restores a FrameSet to a previous integrity state,
-*     as recorded (in static variables) by a previous invocation of
-*     the RecordIntegrity function. It does this by appropriately
-*     remapping the FrameSet's current Frame, if this appears
-*     necessary.
-
-*  Parameters:
-*     this
-*        Pointer to the FrameSet.
-
-*  Notes:
-*     - The previous record of the FrameSet's integrity state (as
-*     recorded by RecordIntegrity) is deleted by this function, even
-*     if it is invoked with the global error status set.
-*     - An error will result if the previous integrity state cannot be
-*     restored.
-*-
-*/
-
-/* Local Variables: */
-   astDECLARE_GLOBALS            /* Declare the thread specific global data */
-   AstFrame *current;            /* Pointer to current Frame */
-   AstFrameSet *cvt;             /* Pointer to conversion FrameSet */
-   AstMapping *map;              /* Pointer to conversion Mapping */
-   int flags;                    /* Flags associated with current frame */
-
-/* Get a pointer to the structure holding thread-specific global data. */
-   astGET_GLOBALS(this);
-
-/* Check that a previous record of the FrameSet's integrity state has
-   been made. Do not modify the FrameSet if it appears that the
-   previous integrity state has not been lost (i.e. that the current
-   Frame has not been modified), nor if there is only one Frame
-   present. Check the global error status. */
-   if ( integrity_frame && integrity_lost && ( astGetNframe( this ) > 1 ) &&
-        astOK ) {
-
-/* Obtain a pointer to the current Frame. */
-      current = astGetFrame( this, AST__CURRENT );
-
-/* Since we need to obtain a conversion between the recorded copy of
-   this Frame and the current one, we must match their Domain
-   attributes (otherwise conversion cannot be performed). Do this by
-   changing the recorded copy as necessary. */
-      if ( astTestDomain( current ) ) {
-         astSetDomain( integrity_frame, astGetDomain( current ) );
-      } else {
-         astClearDomain( integrity_frame );
-      }
-
-/* Temporarily set both Frames AST__INTFLAG flag to indicate that the
-   following call to astConvert is part of the process of restoring a
-   FrameSet's integrity. Some classes of Frame (e.g. DSBSpecFrames) may
-   choose to return a different Mapping in this case. */
-      astSetFrameFlags( integrity_frame, astGetFrameFlags( integrity_frame )
-                                         | AST__INTFLAG );
-      flags = astGetFrameFlags( current );
-      astSetFrameFlags( current, flags | AST__INTFLAG );
-
-/* Obtain the required conversion FrameSet, restore the original frame
-   flags and annul the current Frame pointer. */
-      cvt = astConvert( integrity_frame, current, "" );
-      astSetFrameFlags( current, flags );
-      current = astAnnul( current );
-
-/* If no conversion could be found, then the FrameSet's integrity
-   state cannot be restored, so report an error. */
-      if ( !cvt ) {
-         if( astOK ) {
-            astError( AST__ILOST, "%s(%s): Cannot maintain %s integrity.", status,
-                      integrity_method, astGetClass( this ),
-                      astGetClass( this ) );
-         }
-
-/* Otherwise, obtain a pointer to the conversion Mapping. */
-      } else {
-         map = astGetMapping( cvt, AST__BASE, AST__CURRENT );
-
-/* If the Mapping is not a UnitMap (i.e. a null Mapping), then use it
-   to remap the FrameSet's current Frame. */
-         if ( strcmp( astGetClass( map ), "UnitMap" ) ) {
-            astRemapFrame( this, AST__CURRENT, map );
-         }
-
-/* Annul the conversion Mapping and Frameset pointers. */
-         map = astAnnul( map );
-         cvt = astAnnul( cvt );
-      }
-   }
-
-/* Delete the recorded integrity information by annulling the original
-   copy of the current Frame (thus deleting it) and resetting the
-   associated modification flag. */
-   if ( integrity_frame ) integrity_frame = astAnnul( integrity_frame );
-   integrity_lost = 0;
-}
-
-static void SetAttrib( AstObject *this_object, const char *setting, int *status ) {
-/*
-*  Name:
-*     SetAttrib
-
-*  Purpose:
-*     Set an attribute value for a FrameSet.
-
-*  Type:
-*     Private function.
-
-*  Synopsis:
-*     #include "frameset.h"
-*     void SetAttrib( AstObject *this, const char *setting, int *status )
-
-*  Class Membership:
-*     FrameSet member function (extends the astSetAttrib method
-*     inherited from the Frame class).
-
-*  Description:
-*     This function assigns an attribute value for a FrameSet, 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 FrameSet.
-*     setting
-*        Pointer to a null terminated string specifying the new
-*        attribute value.
-*     status
-*        Pointer to the inherited status variable.
-
-*  Attributes:
-*     The set of attribute values is not fixed and is determined by
-*     the current Frame. In addition, the FrameSet class defines the
-*     following attributes:
-*
-*        Base (integer)
-*        Current (integer)
-
-*  Notes:
-*     - This protected method is intended to be invoked by the Object
-*     astSet method and makes additional attributes accessible to it.
-*     - All attribute settings passed to this function are simply
-*     passed on to the corresponding method for the FrameSet's current
-*     Frame.
-*/
-
-/* Local Variables: */
-   AstFrame *fr;                 /* Pointer to a Frame within the FrameSet */
-   AstFrameSet *this;            /* Pointer to the FrameSet structure */
-   astDECLARE_GLOBALS            /* Declare the thread specific global data */
-   const char *dom;              /* Pointer to Domain string */
-   int base;                     /* Base attribute value */
-   int base_off;                 /* Offset of Base value string */
-   int current;                  /* Current attribute value */
-   int current_off;              /* Offset of Current value string */
-   int id;                       /* Offset of ID string */
-   int invert;                   /* Invert attribute value */
-   int len;                      /* Length of setting string */
-   int nc;                       /* Number of characters read by astSscanf */
-   int nfrm;                     /* Number of Frames in FrameSet */
-   int report;                   /* Report attribute value */
-   int variant;                  /* Offset of Variant string */
-
-/* Check the global error status. */
-   if ( !astOK ) return;
-
-/* Get a pointer to the structure holding thread-specific global data. */
-   astGET_GLOBALS(this_object);
-
-/* Obtain a pointer to the FrameSet structure. */
-   this = (AstFrameSet *) 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. */
-
-/* We first handle attributes that apply to the FrameSet as a whole
-   (rather than to the current Frame). */
-
-/* Base. */
-/* ----- */
-/* Read as an integer. */
-   if ( nc = 0,
-        ( 1 == astSscanf( setting, "base= %d %n", &base, &nc ) )
-          && ( nc >= len ) ) {
-      astSetBase( this, base );
-
-/* Also allow a string. */
-   } else if ( nc = 0,
-               ( 0 == astSscanf( setting, "base= %n%*s %n", &base_off, &nc ) )
-                 && ( nc >= len ) ) {
-
-/* Check for "AST__CURRENT" or "Current". */
-      if ( astChrMatch( "AST__CURRENT", setting + base_off ) ||
-           astChrMatch( "Current", setting + base_off ) ) {
-         astSetBase( this, AST__CURRENT );
-
-/* Check for "AST__BASE" or "Base" (possible, although not very
-   useful). */
-      } else if ( astChrMatch( "AST__BASE", setting + base_off ) ||
-                  astChrMatch( "Base", setting + base_off ) ) {
-
-/* If the FrameSet contains a Frame with the given Domain name, make it
-   the base Frame. */
-      } else {
-         nfrm = astGetNframe( this );
-         for( base = 1; base <= nfrm; base++ ) {
-            fr = astGetFrame( this, base );
-            dom = astGetDomain( fr );
-            fr = astAnnul( fr );
-            if( astChrMatch( dom, setting + base_off ) ) break;
-         }
-
-         if( base <= nfrm ) {
-            astSetBase( this, base );
-
-/* Report an error if the value wasn't recognised. */
-         } else {
-            astError( AST__ATTIN, "astSetAttrib(%s): Invalid index value for "
-                      "Base Frame \"%s\".", status,
-                      astGetClass( this ),  setting + base_off );
-         }
-      }
-
-/* Current. */
-/* -------- */
-/* Since this determines the choice of current Frame, we must restore
-   the integrity state of the FrameSet before changing this attribute
-   and record the new integrity state afterwards. */
-
-/* Read as an integer. */
-   } else if ( nc = 0,
-               ( 1 == astSscanf( setting, "current= %d %n", &current, &nc ) )
-                 && ( nc >= len ) ) {
-      RestoreIntegrity( this, status );
-      astSetCurrent( this, current );
-      RecordIntegrity( this, status );
-
-/* Also allow a string. */
-   } else if ( nc = 0,
-               ( 0 == astSscanf( setting, "current= %n%*s %n",
-                              &current_off, &nc ) )
-                 && ( nc >= len ) ) {
-
-/* Check for "AST__BASE" or "Base". */
-      if ( astChrMatch( "AST__BASE", setting + current_off ) ||
-           astChrMatch( "Base", setting + current_off ) ) {
-         RestoreIntegrity( this, status );
-         astSetCurrent( this, AST__BASE );
-         RecordIntegrity( this, status );
-
-/* Check for "AST__CURRENT" or "Current" (possible, although not very
-   useful). */
-      } else if ( astChrMatch( "AST__CURRENT", setting + current_off ) ||
-                  astChrMatch( "Current", setting + current_off ) ) {
-
-/* If the FrameSet contains a Frame with the given Domain name, make it
-   the current Frame. */
-      } else {
-         nfrm = astGetNframe( this );
-         for( current = 1; current <= nfrm; current++ ) {
-            fr = astGetFrame( this, current );
-            dom = astGetDomain( fr );
-            fr = astAnnul( fr );
-            if( astChrMatch( dom, setting + current_off ) ) break;
-         }
-
-         if( current <= nfrm ) {
-            RestoreIntegrity( this, status );
-            astSetCurrent( this, current );
-            RecordIntegrity( this, status );
-
-/* Report an error if the value wasn't recognised. */
-         } else {
-            astError( AST__ATTIN, "astSetAttrib(%s): Invalid index value for "
-                      "Current Frame \"%s\".", status,
-                      astGetClass( this ),  setting + current_off );
-         }
-      }
-
-/* ID. */
-/* --- */
-   } else if ( nc = 0, ( 0 == astSscanf( setting, "id=%n%*[^\n]%n", &id, &nc ) )
-                       && ( nc >= len ) ) {
-      astSetID( this, setting + id );
-
-/* Ident. */
-/* ------ */
-   } else if ( nc = 0, ( 0 == astSscanf( setting, "ident=%n%*[^\n]%n", &id, &nc ) )
-                       && ( nc >= len ) ) {
-      astSetIdent( this, setting + id );
-
-/* Invert. */
-/* ------- */
-/* Since this affects the choice of current Frame, we must restore the
-   integrity state of the FrameSet before changing this attribute and
-   record the new integrity state afterwards. */
-   } else if ( nc = 0,
-        ( 1 == astSscanf( setting, "invert= %d %n", &invert, &nc ) )
-        && ( nc >= len ) ) {
-      RestoreIntegrity( this, status );
-      astSetInvert( this, invert );
-      RecordIntegrity( this, status );
-
-/* Report. */
-/* ------- */
-   } else if ( nc = 0,
-        ( 1 == astSscanf( setting, "report= %d %n", &report, &nc ) )
-        && ( nc >= len ) ) {
-      astSetReport( this, report );
-
-/* Variant. */
-/* -------- */
-   } else if ( nc = 0,
-               ( 0 == astSscanf( setting, "variant=%n%*[^\n]%n", &variant, &nc ) )
-               && ( nc >= len ) ) {
-      astSetVariant( this, setting + variant );
-
-/* 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 ( MATCH( "allvariants" ) ||
-               MATCH( "class" ) ||
-               MATCH( "nframe" ) ||
-               MATCH( "nin" ) ||
-               MATCH( "nobject" ) ||
-               MATCH( "nout" ) ||
-               MATCH( "refcount" ) ||
-               MATCH( "tranforward" ) ||
-               MATCH( "traninverse" ) ) {
-      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 unrecognised settings on to the FrameSet's current Frame for
-   further interpretation. */
-   } else {
-
-/* Force a copy to be made of the current Frame, if needed, to make it
-   independent of other Frames within the FrameSet. */
-      (void) ForceCopy( this, AST__CURRENT, status );
-
-/* Obtain a pointer to the current Frame and invoke its astSetAttrib
-   method. Annul the Frame pointer afterwards. */
-      fr = astGetFrame( this, AST__CURRENT );
-      astSetAttrib( fr, setting );
-      fr = astAnnul( fr );
-
-/* Note that the current Frame has been modified. */
-      integrity_lost = 1;
-   }
-
-/* Undefine macros local to this function. */
-#undef MATCH
-}
-
-static void SetAxis( AstFrame *this_frame, int axis, AstAxis *newaxis, int *status ) {
-/*
-*  Name:
-*     SetAxis
-
-*  Purpose:
-*     Set a new Axis for a FrameSet.
-
-*  Type:
-*     Private function.
-
-*  Synopsis:
-*     #include "frameset.h"
-*     void SetAxis( AstFrame *this, int axis, AstAxis *newaxis, int *status )
-
-*  Class Membership:
-*     FrameSet member function (over-rides the astSetAxis method
-*     inherited from the Frame class).
-
-*  Description:
-*     This function allows a new Axis object to be associated with one
-*     of the axes of the current Frame in a FrameSet, replacing the
-*     previous one. Each Axis object contains a description of the
-*     quantity represented along one of the Frame's axes, so this
-*     function allows this description to be exchanged for another
-*     one.
-
-*  Parameters:
-*     this
-*        Pointer to the FrameSet.
-*     axis
-*        The index (zero-based) of the axis whose associated Axis
-*        object is to be replaced.
-*     newaxis
-*        Pointer to the new Axis object.
-*     status
-*        Pointer to the inherited status variable.
-*/
-
-/* Local Variables: */
-   AstFrame *fr;                 /* Pointer to current Frame */
-   AstFrameSet *this;            /* Pointer to the FrameSet structure */
-
-/* Check the global error status. */
-   if ( !astOK ) return;
-
-/* Obtain a pointer to the FrameSet structure. */
-   this = (AstFrameSet *) this_frame;
-
-/* Validate the axis index supplied. */
-   (void) astValidateAxis( this, axis, 1, "astSetAxis" );
-
-/* Obtain a pointer to the FrameSet's current Frame and invoke this
-   Frame's astSetAxis method to assign the new Axis object. Annul the
-   Frame pointer afterwards. */
-   fr = astGetFrame( this, AST__CURRENT );
-   astSetAxis( fr, axis, newaxis );
-   fr = astAnnul( fr );
-}
-
-static void SetBase( AstFrameSet *this, int iframe, int *status ) {
-/*
-*+
-*  Name:
-*     astSetBase
-
-*  Purpose:
-*     Set a value for the Base attribute of a FrameSet.
-
-*  Type:
-*     Protected virtual function.
-
-*  Synopsis:
-*     #include "frameset.h"
-*     void astSetBase( AstFrameSet *this, int iframe )
-
-*  Class Membership:
-*     FrameSet method.
-
-*  Description:
-*     This function sets a value for the Base attribute of a FrameSet. This
-*     value is an index that identifies the base Frame for the FrameSet.
-
-*  Parameters:
-*     this
-*        Pointer to the FrameSet.
-*     iframe
-*        Value to be set for the Base attribute.
-
-*  Notes:
-*     - A value of AST__BASE or AST__CURRENT may be given for the
-*     "iframe" parameter to identify the base Frame or the current
-*     Frame respectively.
-*-
-*/
-
-/* Local Variables: */
-   int invert;                    /* FrameSet is inverted? */
-
-/* Check the global error status. */
-   if ( !astOK ) return;
-
-/* Validate and translate the Frame index supplied. */
-   iframe = astValidateFrameIndex( this, iframe, "astSetBase" );
-
-/* Determine if the FrameSet has been inverted. */
-   invert = astGetInvert( this );
-
-/* If it has not been inverted, set the base Frame index, otherwise
-   set the current Frame index instead. */
-   if ( astOK ) *( invert ? &this->current : &this->base ) = iframe;
-}
-
-static void SetCurrent( AstFrameSet *this, int iframe, int *status ) {
-/*
-*+
-*  Name:
-*     astSetCurrent
-
-*  Purpose:
-*     Set a value for the Current attribute of a FrameSet.
-
-*  Type:
-*     Protected function.
-
-*  Synopsis:
-*     #include "frameset.h"
-*     int astSetCurrent( AstFrameSet *this, int iframe )
-
-*  Class Membership:
-*     FrameSet method.
-
-*  Description:
-*     This function sets a value for the Current attribute of a
-*     FrameSet. This attribute is an index that identifies the current
-*     Frame for the FrameSet.
-
-*  Parameters:
-*     this
-*        Pointer to the FrameSet.
-*     iframe
-*        Value to be set for the Current attribute.
-
-*  Notes:
-*     - A value of AST__BASE or AST__CURRENT may be given for the
-*     "iframe" parameter to identify the base Frame or the current
-*     Frame respectively.
-*-
-*/
-
-/* Local Variables: */
-   int invert;                   /* FrameSet is inverted? */
-
-/* Check the global error status. */
-   if ( !astOK ) return;
-
-/* Validate and translate the Frame index supplied. */
-   iframe = astValidateFrameIndex( this, iframe, "astSetCurrent" );
-
-/* Determine if the FrameSet has been inverted. */
-   invert = astGetInvert( this );
-
-/* If it has not been inverted, set the current frame index, otherwise
-   set the base Frame index instead. */
-   if ( astOK ) *( invert ? &this->base : &this->current ) = iframe;
-}
-
-static void SetVariant( AstFrameSet *this, const char *variant, int *status ) {
-/*
-*+
-*  Name:
-*     astSetVariant
-
-*  Purpose:
-*     Set a value for the Variant attribute of a FrameSet.
-
-*  Type:
-*     Protected virtual function.
-
-*  Synopsis:
-*     #include "frameset.h"
-*     void astSetVariant( AstFrameSet *this,  const char *variant )
-
-*  Class Membership:
-*     FrameSet method.
-
-*  Description:
-*     This function sets a value for the Variant attribute of a FrameSet.
-
-*  Parameters:
-*     this
-*        Pointer to the FrameSet.
-*     variant
-*        Value to be set for the Variant attribute.
-
-*  Notes:
-*     - An error will be reported if the supplied variant name cannot be
-*     found in the Variants FrameSet associated with the current Frame.
-
-*-
-*/
-
-/* Local Variables: */
-   AstCmpMap *map6;
-   AstCmpMap *map5;
-   AstCmpMap *map4;
-   AstFrame *frm;
-   AstFrame *vfrm;
-   AstFrameSet *tfs;
-   AstFrameSet *vfs;
-   AstMapping *map0;
-   AstMapping *map2;
-   AstMapping *map3;
-   AstMapping *map1;
-   char *myvar;
-   const char *dom;
-   int icur;
-   int ifrm;
-   int inode;
-   int inv0;
-   int inv;
-   int nfrm;
-
-/* Check the global error status. */
-   if ( !astOK ) return;
-
-/* Get a copy of the supplied string and clean it. */
-   myvar = astStore( NULL, variant, strlen( variant ) + 1 );
-   astRemoveLeadingBlanks( myvar );
-   astChrCase( NULL, myvar, 1, 0 );
-   if( astOK ) {
-      myvar[ astChrLen( myvar ) ] = 0;
-
-/* Get the one-based index of the Frame that defines the available
-   variant Mappings. */
-      icur = GetVarFrm( this, astGetCurrent( this ), status );
-
-/* Get the variants FrameSet from the Frame selected above. */
-      frm = astGetFrame( this, icur );
-      vfs = astGetFrameVariants( frm );
-
-/* If there is no variants FrameSet in the Frame, the only allowed value
-   for "Variant" is the Domain name of the current Frame. */
-      if( ! vfs ) {
-         dom = astGetDomain( this );
-         if( astOK && strcmp( myvar, dom ) ) {
-            astError( AST__ATTIN, "astSetVariant(%s): Unknown Frame "
-                      "variant '%s' requested.", status, astGetClass( this ),
-                      myvar );
-         }
-
-/* If there is a variants FrameSet in the Frame... */
-      } else {
-
-/* Find the index of the Frame in the Variants FrameSet that has a Domain
-   equal to myvar. */
-         nfrm = astGetNframe( vfs );
-         for( ifrm = 0; ifrm < nfrm; ifrm++ ) {
-            vfrm = astGetFrame( vfs, ifrm + 1 );
-            dom = astGetDomain( vfrm );
-            vfrm = astAnnul( vfrm );
-            if( !astOK || !strcmp( myvar, dom ) ) break;
-         }
-
-/* Report an error if no such Frame found. */
-         if( ifrm == nfrm && astOK ) {
-            astError( AST__ATTIN, "astSetVariant(%s): Unknown Frame "
-                      "variant '%s' requested - available variants are "
-                      "'%s'.", status, astGetClass(this), myvar,
-                      astGetAllVariants(this) );
-
-/* Otherwise, get a Mapping from the current Frame in "this" to the
-   currently selected Variant Frame. We cannot assume that they are the
-   same as attributes of the current Frame (e.g. System) may have been
-   changed since the variant was added. If the required Frame is already
-   the current Frame, there is nothing more to do since the required
-   variant is already selected. */
-         } else if( ifrm + 1 != astGetCurrent( vfs ) ){
-            vfrm = astGetFrame( vfs, AST__CURRENT );
-            dom = astGetDomain( frm );
-            if( dom ) dom = astStore( NULL, dom, strlen( dom ) + 1 );
-            astSetDomain( frm, astGetDomain( vfrm ) );
-            tfs = astConvert( frm, vfrm, "" );
-            astSetDomain( frm, dom );
-            if( tfs ) {
-               map1 = astGetMapping( tfs, AST__BASE, AST__CURRENT );
-               tfs = astAnnul( tfs );
-               vfrm = astAnnul( vfrm );
-
-/* Get the Mapping from the original Variant Frame to the requested variant
-   Frame. */
-               map2 = astGetMapping( vfs, AST__CURRENT, ifrm + 1 );
-
-/* Get a Mapping from the new variant Frame to the current Frame in "this". */
-               vfrm = astGetFrame( vfs, ifrm + 1 );
-               astSetDomain( frm, astGetDomain( vfrm ) );
-               tfs = astConvert( vfrm, frm, "" );
-               astSetDomain( frm, dom );
-               if( tfs ) {
-                  map3 = astGetMapping( tfs, AST__BASE, AST__CURRENT );
-                  tfs = astAnnul( tfs );
-
-/* Concatentate the three Mappings, to get the Mapping from the old
-   variant Frame to the new variant Frame. */
-                  map4 = astCmpMap( map1, map2, 1, " ", status );
-                  map5 = astCmpMap( map4, map3, 1, " ", status );
-
-/* Now we modify the Mapping in the FrameSet. First get the index of the node
-   with which the Frame is associated. */
-                  inode = this->node[ icur - 1 ];
-
-/* Get the Mapping that generates the node values, and its Invert flag. */
-                  map0 = this->map[ inode - 1 ];
-                  inv0 = this->invert[ inode - 1 ];
-
-/* Temporarily reset the invert flag in the Mapping to account for any
-   changes made to the Mapping via other pointers. */
-                  inv = astGetInvert( map0 );
-                  astSetInvert( map0, inv0 );
-
-/* Concatentate with "map5" to get the Mapping form the the parent node
-   to the new variant of the current node. */
-                  map6 = astCmpMap( map0, map5, 1, " ", status );
-
-/* Simplify it and use it to replace the Mapping in the FrameSet structure. */
-                  this->map[ inode - 1 ] = astSimplify( map6 );
-                  this->invert[ inode - 1 ] = astGetInvert( this->map[ inode - 1 ] );
-
-/* Re-instate the original Invert flag and free the old Mapping pointer. */
-                  astSetInvert( map0, inv );
-                  map0 = astAnnul( map0 );
-
-/* Make the variant Frame the current Frame within the Variants FrameSet. */
-                  astSetCurrent( vfs, ifrm + 1 );
-
-/* Free resources. */
-                  map6 = astAnnul( map6 );
-                  map5 = astAnnul( map5 );
-                  map4 = astAnnul( map4 );
-                  map3 = astAnnul( map3 );
-
-/* Report an error if a Mapping cannot be found from the new variant Frame
-   to the current Frame in "this". */
-               } else if( astOK ) {
-                  astError( AST__INTER, "astSetVariant(%s): Cannot convert "
-                            "from a %s with Domain '%s' to a %s with Domain "
-                            "'%s' (internal programming error).", status,
-                            astGetClass( this ), astGetClass( vfrm ),
-                            astGetDomain( vfrm ), astGetClass( frm ),
-                            astGetDomain( frm ) );
-               }
-
-/* Free resources. */
-               map2 = astAnnul( map2 );
-               map1 = astAnnul( map1 );
-
-/* Report an error if a Mapping cannot be found from the current Frame in
-   "this" to the current Variant Frame. */
-            } else if( astOK ) {
-               astError( AST__INTER, "astSetVariant(%s): Cannot convert "
-                         "from a %s with Domain '%s' to a %s with Domain "
-                         "'%s' (internal programming error).", status,
-                         astGetClass( this ), astGetClass( frm ),
-                         astGetDomain( frm ), astGetClass( vfrm ),
-                         astGetDomain( vfrm ) );
-            }
-
-/* Free resources. */
-            vfrm = astAnnul( vfrm );
-            dom = astFree( (void *) dom );
-         }
-
-/* Annul the pointer to the Variants FrameSet. */
-         vfs = astAnnul( vfs );
-      }
-
-/* Annul the pointer to the current Frame in "this". */
-      frm = astAnnul( frm );
-   }
-
-/* Free the memory holding the cleaned variant name. */
-   myvar = astFree( myvar );
-}
-
-static AstMapping *Simplify( AstMapping *this_mapping, int *status ) {
-/*
-*  Name:
-*     Simplify
-
-*  Purpose:
-*     Simplify the Mappings in a FrameSet.
-
-*  Type:
-*     Private function.
-
-*  Synopsis:
-*     #include "frameset.h"
-*     AstMapping *Simplify( AstMapping *this, int *status )
-
-*  Class Membership:
-*     FrameSet method (over-rides the astSimplify method inherited
-*     from the Frame class).
-
-*  Description:
-*     This function simplifies the Mappings in a FrameSet to eliminate
-*     redundant computational steps, or to merge separate steps which
-*     can be performed more efficiently in a single operation.
-
-*  Parameters:
-*     this
-*        Pointer to the original FrameSet.
-*     status
-*        Pointer to the inherited status variable.
-
-*  Returned Value:
-*     A new pointer to the (possibly simplified) FrameSet. If
-*     simplification was not possible, this will be a cloned pointer
-*     to the original FrameSet.
-
-*  Notes:
-*     - A NULL pointer value will be returned if this function is
-*     invoked with the AST error status set, or if it should fail for
-*     any reason.
-*/
-
-/* Local Variables: */
-   AstFrameSet *new;             /* Pointer to new (simpler?) FrameSet */
-   AstFrameSet *this;            /* Pointer to original FrameSet structure */
-   AstMapping *map;              /* Pointer to Mapping */
-   AstMapping *result;           /* Result pointer to return */
-   AstMapping *tmp;              /* Temporary Mapping pointer */
-   int inode;                    /* Loop counter for FrameSet nodes */
-   int inv;                      /* Mapping Invert attribute value */
-   int invert;                   /* Invert flag value */
-   int set;                      /* Invert attribute set? */
-   int simpler;                  /* Simplification achieved? */
-
-/* Initialise. */
-   result = NULL;
-
-/* Check the global error status. */
-   if ( !astOK ) return result;
-
-/* Obtain a pointer to the FrameSet structure. */
-   this = (AstFrameSet *) this_mapping;
-
-/* Make a copy of the FrameSet, since we may alter it (this is a deep
-   copy, which is a minor limitation of the current implementation). */
-   new = astCopy( this );
-
-/* Loop to examine each of the Mappings between the Frames in the
-   copy. */
-   simpler = 0;
-   for ( inode = 1; astOK && ( inode < new->nnode ); inode++ ) {
-
-/* Obtain the Mapping pointer and associated invert flag. */
-      map = new->map[ inode - 1 ];
-      invert = new->invert[ inode - 1 ];
-
-/* Determine if the Mapping's Invert attribute is set, and obtain its
-   value. */
-      set = astTestInvert( map );
-      inv = astGetInvert( map );
-
-/* If necessary, set the required value for the Invert attribute. */
-      if ( inv != invert ) astSetInvert( map, invert );
-
-/* Simplify the Mapping. */
-      tmp = astSimplify( map );
-
-/* If necessary, restore the original state of the Mapping's Invert
-   attribute. */
-      if ( inv != invert ) {
-         if ( set ) {
-            astSetInvert( map, inv );
-         } else {
-            astClearInvert( map );
-         }
-      }
-
-/* Test if simplification was performed. */
-      if ( astOK ) {
-         if ( tmp != map ) {
-
-/* If so, annul the original Mapping pointer and substitute the new
-   one. Also set a new invert flag to accompany it. */
-            (void) astAnnul( new->map[ inode - 1 ] );
-            new->map[ inode - 1 ] = astClone( tmp );
-            new->invert[ inode - 1 ] = astGetInvert( tmp );
-
-/* Note if any Mapping within the FrameSet is simplified. */
-            simpler = 1;
-         }
-      }
-
-/* Annul the pointer to the simplified Mapping. */
-      tmp = astAnnul( tmp );
-   }
-
-/* If simplification was possible, clone a pointer to the new
-   FrameSet. Otherwise clone a pointer to the original one. */
-   if ( astOK ) result = astClone( simpler ? new : this );
-
-/* Annul the new FrameSet pointer. */
-   new = astAnnul( new );
-
-/* If an error occurred, annul the returned pointer. */
-   if ( !astOK ) result = astAnnul( result );
-
-/* Return the result. */
-   return result;
-}
-
-static int Span( AstFrameSet *this, AstFrame **frames, int inode1, int inode2,
-                 int avoid, AstMapping **map, int *forward, int *status ) {
-/*
-*  Name:
-*     Span
-
-*  Purpose:
-*     Find a path between two nodes in a FrameSet.
-
-*  Type:
-*     Private function.
-
-*  Synopsis:
-*     #include "frameset.h"
-*     int Span( AstFrameSet *this, AstFrame **frames, int inode1, int inode2,
-*               int avoid, AstMapping **map, int *forward, int *status )
-
-*  Class Membership:
-*     FrameSet member function.
-
-*  Description:
-*     This function searches a FrameSet to identify a path between two
-*     specified nodes. It returns an array of pointers to each Mapping
-*     in the path, along with direction information, so that an
-*     overall Mapping between the two nodes can be constructed.
-
-*  Parameters:
-*     this
-*        Pointer to the FrameSet.
-*     frames
-*        Pointer to an array of Frame pointers, indexed by node index.
-*        Nodes which have no associated Frame will have a NULL pointer
-*        stored in this array.
-*     inode1
-*        Zero based index of the starting node.
-*     inode2
-*        Zero based index of the ending node.
-*     avoid
-*        Zero based index which identifies a node which is to be
-*        avoided (i.e. the initial step in the path should not be via
-*        this node). This value is required because the function
-*        invokes itself recursively; it provides a mechanism to
-*        prevent searches proceeding back down paths that have already
-*        been searched. External callers should provide a value of -1,
-*        which indicates that all possible paths should initially be
-*        explored.
-*     map
-*        Pointer to the start of an array that will be filled with a
-*        series of pointers to Mappings which must be applied in turn
-*        in order to transform between the two Frames. External
-*        callers should ensure that this array contains at least as many
-*        elements as there are Mappings and Frames in the FrameSet (one less
-*        than the number of nodes plus the number of Frames).
-*
-*        Note that the pointers are simply copies of addresses from
-*        the FrameSet's "map" array. They are not cloned, so should
-*        not be annulled by the caller.
-*     forward
-*        Pointer to the start of an array of int that will be filled
-*        with boolean flags (0 or 1) to indicate whether the forward
-*        (as opposed to the inverse) transformation should be used for
-*        each Mapping returned in order to effect the transformation
-*        between the starting and ending nodes. This array should be the
-*        same size as the "map" array.
-*     status
-*        Pointer to the inherited status variable.
-
-*  Returned Value:
-*     The function returns one more than the number of Mappings
-*     required to perform the transformation, or zero if it was not
-*     possible to find a path between the two nodes.
-
-*  Notes:
-*     - If a node has an associated Frame, the Frame usually represents
-*     a UnitMap and so can be ignored. The exception is if the Frame is
-*     actually a Region (or a CmpFrame containing a Region), in which
-*     case it represents a Mapping which returns bad values if the
-*     input position is outside the Region. This form of Mapping should
-*     not be ignored, and so the returned list of Mappings includes the
-*     effect of any Frames along the path which are not equivalent to a
-*     UnitMap. This equivalence is determined by invoking the astSimplify
-*     method on the Frame.
-*     - 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.
-*     - On the assumption that the FrameSet has been consistently
-*     constructed, there should be exactly one path between any pair
-*     of its nodes.  It should not, therefore, ever fail to find a
-*     path except when invoked recursively to explore a subset of the
-*     FrameSet's nodes (this should not be visible to an external
-*     caller).  Failure to find a path does not in itself result in an
-*     error condition.
-*/
-
-/* Local Variables: */
-   AstFrame *frame;          /* Pointer to Frame associated with inode1 */
-   int fwd;                  /* Forward Mapping identified? */
-   int inode;                /* Loop counter for nodes */
-   int inv;                  /* Inverse Mapping identified? */
-   int invert;               /* Original Mapping Invert value */
-   int nextra;               /* No. of extra Mappings to add to path */
-   int result;               /* Count of mappings (to be returned) */
-
-/* Check the global error status. */
-   if ( !astOK ) return 0;
-
-/* See if the two nodes are the same. */
-   result = ( inode1 == inode2 );
-
-/* If so, we need to consider the Mapping represented by any Frame
-   associated with the node. Most classes of Frames are equivalent to a
-   UnitMap and so can be ignored. But some (e.g. the Region class)
-   are not equivalent to a UnitMap and so needs to be included in the
-   returned Mapping list. */
-   if( result ) {
-      result = 1;
-
-/* If inode1 is associated with a Frame, which is not equivalent to a
-   UnitMap, add the Frame as the first Mapping into the returned list. The
-   "forward" value is irrelevant since the forward and inverse transformations
-   of Frames are the same. */
-      frame = frames[ inode1 ];
-      if( frame ) {
-         if( !astIsUnitFrame( frame ) ) {
-            result++;
-            *map = (AstMapping *) frame;
-            *forward = 1;
-         }
-      }
-
-/* If the nodes are different, we now attempt to find the next step in
-   the path between them. Loop through all available nodes looking for
-   the next one to transform to (i.e. one that is directly related by
-   a Mapping to our starting node). */
-   } else {
-      for ( inode = 0; inode < this->nnode; inode++ ) {
-
-/* Do not consider node "avoid". This prevents us re-tracing our steps
-   backwards when this function is invoked recursively. */
-         if ( inode != avoid ) {
-
-/* Test if inode is derived from inode1 (if so, the Mapping associated
-   with inode will convert from inode1 to inode when applied in the
-   forward direction). */
-            fwd = ( inode > 0 ) && ( this->link[ inode - 1 ] == inode1 );
-
-/* Test if inode1 is derived from inode (if so, the Mapping associated
-   with inode1 will convert from inode1 to inode when applied in the
-   inverse direction). */
-            inv = ( inode1 > 0 ) && ( this->link[ inode1 - 1 ] == inode );
-
-/* If the nodes are directly related, we try to find a path from inode to
-   inode2 without going back through inode1. */
-            if ( fwd || inv ) {
-
-/* If node1 is associated with a Frame, we need to include the Frame
-   as a Mapping in the returned list unless the Frame is equivalent to a
-   UnitMap. Note the number of slots to be reserved for node1 when we call
-   Span recursively below. */
-               nextra = 1;
-               frame = frames[ inode1 ];
-               if( frame && !astIsUnitFrame( frame ) ) nextra = 2;
-
-/* Invoke this function recursively to try and find a path from inode
-   to inode2 without going back through inode1. If this is possible, a
-   non-zero result will be returned. Store the returned Mappings and
-   direction information in the arrays supplied, but leave extra space to
-   insert information about the Mapping between nodes inode1 and inode. */
-               result = Span( this, frames, inode, inode2, inode1,
-                              map + nextra, forward + nextra, status );
-
-/* If a path was found, increment the Mapping count to account for the
-   one that transforms between nodes inode1 and inode and insert
-   information for this Mapping into the output arrays. */
-               if ( result ) {
-                  result++;
-                  nextra--;
-                  map[ nextra ] = this->map[ ( fwd ? inode : inode1 ) - 1 ];
-                  forward[ nextra ] = fwd;
-
-/* Obtain the original value of the Invert attribute for the Mapping
-   between nodes inode1 and inode (recorded when the Mapping was first
-   added to the FrameSet). Test if this value has now changed. If so,
-   some external code has inverted the Mapping via another pointer, so
-   invert the returned direction information to compensate for
-   this. */
-                  invert = this->invert[ ( fwd ? inode : inode1 ) - 1 ];
-                  if ( invert != astGetInvert( map[ nextra ] ) ) {
-                     forward[ nextra ] = !forward[ nextra ];
-                  }
-
-/* If inode1 is associated with a non-unit Frame Mapping, add the Frame
-   Mapping in as the first Mapping in the returned list. The "forward" value
-   is irrelevant since the forward and inverse transformations of Frames
-   are the same. */
-                  if( nextra ) {
-                     result++;
-                     *map = (AstMapping *) frame;
-                     *forward = 1;
-                  }
-
-/* Quit searching once a path has been found. */
-                  break;
-	       }
-	    }
-         }
-      }
-   }
-
-/* Return the result, which is one more than the number of mappings
-   found (i.e. steps in the path), or zero if no path was found (this
-   should only occur when invoked recursively to explore an
-   unsuccessful sub-path). */
-   return result;
-}
-
-static int SubFrame( AstFrame *this_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 FrameSet and convert to the new coordinate system.
-
-*  Type:
-*     Private function.
-
-*  Synopsis:
-*     #include "frameset.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:
-*     FrameSet 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 the current Frame of a "target" FrameSet 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 current Frame of the target
-*     FrameSet and the result Frame. 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 FrameSet, from whose current Frame the
-*        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 FrameSet. This
-*        number may be greater than or less than the number of axes in
-*        the FrameSet's current 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 current Frame of the target FrameSet. 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 FrameSet, 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 current Frame of the target FrameSet
-*        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 current Frame of the target FrameSet 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.
-*/
-
-/* Local Variables: */
-   AstFrame *fr;                 /* Pointer to FrameSet's current Frame */
-   AstFrameSet *this;            /* Pointer to the FrameSet structure */
-   int match;                    /* Result to be returned */
-
-/* Initialise. */
-   *map = NULL;
-   *result = NULL;
-   match = 0;
-
-/* Check the global error status. */
-   if ( !astOK ) return match;
-
-/* Obtain a pointer to the FrameSet structure. */
-   this = (AstFrameSet *) this_frame;
-
-/* Obtain a pointer to the FrameSet's current Frame. */
-   fr = astGetFrame( this, AST__CURRENT );
-
-/* Invoke the astSubFrame method for this Frame. */
-   match = astSubFrame( fr, template, result_naxes, target_axes, template_axes,
-                        map, result );
-
-/* Annul the Frame pointer. */
-   fr = astAnnul( fr );
-
-/* If an error occurred, clean up by annulling any returned objects and clear
-   the returned result. */
-   if ( !astOK ) {
-      *map = astAnnul( *map );
-      *result = astAnnul( *result );
-      match = 0;
-   }
-
-/* Return the result. */
-   return match;
-}
-
-static AstSystemType SystemCode( AstFrame *this_frame, const char *system, int *status ) {
-/*
-*  Name:
-*     SystemCode
-
-*  Purpose:
-*     Convert a string into a coordinate system type code.
-
-*  Type:
-*     Private function.
-
-*  Synopsis:
-*     #include "frameset.h"
-*     AstSystemType SystemCode( AstFrame *this, const char *system, int *status )
-
-*  Class Membership:
-*     FrameSet member function (over-rides the protected astSystemCode
-*     method inherited from the Frame class).
-
-*  Description:
-*     This function converts a string used for the external description of
-*     a coordinate system into a Frame coordinate system type code (System
-*     attribute value). It is the inverse of the astSystemString function.
-
-*  Parameters:
-*     this
-*        Pointer to the Frame.
-*     system
-*        Pointer to a constant null-terminated string containing the
-*        external description of the 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 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 */
-   AstFrame *fr;              /* Pointer to FrameSet's current Frame */
-   AstFrameSet *this;         /* Pointer to the FrameSet structure */
-
-/* Initialise. */
-   result = AST__BADSYSTEM;
-
-/* Check the global error status. */
-   if ( !astOK ) return result;
-
-/* Obtain a pointer to the FrameSet structure. */
-   this = (AstFrameSet *) this_frame;
-
-/* Obtain a pointer to the FrameSet's current Frame and invoke the
-   astSystemCode method for this Frame. Annul the Frame pointer afterwards. */
-   fr = astGetFrame( this, AST__CURRENT );
-   result = astSystemCode( fr, system );
-   fr = astAnnul( fr );
-
-/* If an error occurred, clear the result value. */
-   if ( !astOK ) result = AST__BADSYSTEM;
-
-/* Return the result. */
-   return result;
-}
-
-static const char *SystemString( AstFrame *this_frame, AstSystemType system, int *status ) {
-/*
-*  Name:
-*     SystemString
-
-*  Purpose:
-*     Convert a coordinate system type code into a string.
-
-*  Type:
-*     Private function.
-
-*  Synopsis:
-*     #include "frameset.h"
-*     const char *SystemString( AstFrame *this, AstSystemType system, int *status )
-
-*  Class Membership:
-*     FrameSet member function (over-rides the protected astSystemString
-*     method inherited from the Frame class).
-
-*  Description:
-*     This function converts a Frame coordinate system type code
-*     (System attribute value) into a string suitable for use as an
-*     external representation of the coordinate system type.
-
-*  Parameters:
-*     this
-*        Pointer to 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 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: */
-   AstFrame *fr;                 /* Pointer to FrameSet's current Frame */
-   AstFrameSet *this;            /* Pointer to the FrameSet 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 FrameSet structure. */
-   this = (AstFrameSet *) this_frame;
-
-/* Obtain a pointer to the FrameSet's current Frame and invoke the
-   astSystemString method for this Frame. Annul the Frame pointer
-   afterwards. */
-   fr = astGetFrame( this, AST__CURRENT );
-   result = astSystemString( fr, system );
-   fr = astAnnul( fr );
-
-/* If an error occurred, clear the result value. */
-   if ( !astOK ) result = NULL;
-
-/* Return the result pointer. */
-   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 FrameSet.
-
-*  Type:
-*     Private function.
-
-*  Synopsis:
-*     #include "frameset.h"
-*     int TestAttrib( AstObject *this, const char *attrib, int *status )
-
-*  Class Membership:
-*     FrameSet 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 FrameSet's attributes.
-
-*  Parameters:
-*     this
-*        Pointer to the FrameSet.
-*     attrib
-*        Pointer to a null terminated string specifying the attribute
-*        name.  This should be in lower case with no surrounding white
-*        space.
-*     status
-*        Pointer to the inherited status variable.
-
-*  Returned Value:
-*     One if a value has been set, otherwise zero.
-
-*  Notes:
-*     - A value of zero will be returned if this function is invoked
-*     with the global status set, or if it should fail for any reason.
-*/
-
-/* Local Variables: */
-   AstFrame *fr;                 /* Pointer to current Frame */
-   AstFrameSet *this;            /* Pointer to the FrameSet structure */
-   int result;                   /* Result value to return */
-
-/* Initialise. */
-   result = 0;
-
-/* Check the global error status. */
-   if ( !astOK ) return result;
-
-/* Obtain a pointer to the FrameSet structure. */
-   this = (AstFrameSet *) this_object;
-
-/* Check the attribute name and test the appropriate attribute. */
-
-/* We first handle attributes that apply to the FrameSet as a whole
-   (rather than to the current Frame). */
-
-/* Base. */
-/* ----- */
-   if ( !strcmp( attrib, "base" ) ) {
-      result = astTestBase( this );
-
-/* Current. */
-/* -------- */
-   } else if ( !strcmp( attrib, "current" ) ) {
-      result = astTestCurrent( this );
-
-/* ID. */
-/* --- */
-   } else if ( !strcmp( attrib, "id" ) ) {
-      result = astTestID( this );
-
-/* Ident. */
-/* ------ */
-   } else if ( !strcmp( attrib, "ident" ) ) {
-      result = astTestIdent( this );
-
-/* Invert. */
-/* ------- */
-   } else if ( !strcmp( attrib, "invert" ) ) {
-      result = astTestInvert( this );
-
-/* Report. */
-/* ------- */
-   } else if ( !strcmp( attrib, "report" ) ) {
-      result = astTestReport( this );
-
-/* Variant. */
-/* -------- */
-   } else if ( !strcmp( attrib, "variant" ) ) {
-      result = astTestVariant( 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 ( !strcmp( attrib, "allvariants" ) ||
-               !strcmp( attrib, "class" ) ||
-               !strcmp( attrib, "nframe" ) ||
-               !strcmp( attrib, "nin" ) ||
-               !strcmp( attrib, "nobject" ) ||
-               !strcmp( attrib, "nout" ) ||
-               !strcmp( attrib, "refcount" ) ||
-               !strcmp( attrib, "tranforward" ) ||
-               !strcmp( attrib, "traninverse" ) ) {
-      result = 0;
-
-/* Pass unrecognised attributes on to the FrameSet's current Frame for
-   further interpretation. */
-   } else {
-
-/* Obtain a pointer to the current Frame and invoke its astTestAttrib
-   method. Annul the Frame pointer afterwards. */
-      fr = astGetFrame( this, AST__CURRENT );
-      result = astTestAttrib( fr, attrib );
-      fr = astAnnul( fr );
-   }
-
-/* If an error occurred, clear the result value. */
-   if ( !astOK ) result = 0;
-
-/* Return the result, */
-   return result;
-}
-
-static int TestBase( AstFrameSet *this, int *status ) {
-/*
-*+
-*  Name:
-*     astTestBase
-
-*  Purpose:
-*     Determine if a value has been set for the Base attribute of a FrameSet.
-
-*  Type:
-*     Protected virtual function.
-
-*  Synopsis:
-*     #include "frameset.h"
-*     int astTestBase( AstFrameSet *this )
-
-*  Class Membership:
-*     FrameSet method.
-
-*  Description:
-*     This function returns a boolean result to indicate if a value
-*     has been set for the Base attribute of a FrameSet. This
-*     attribute is an index that identifies the base Frame in the
-*     FrameSet.
-
-*  Parameters:
-*     this
-*        Pointer to the FrameSet.
-
-*  Returned Value:
-*     Zero or 1, depending on whether a value has been set.
-
-*  Notes:
-*     - A value of zero will be returned if this function is invoked
-*     with the global status set, or if it should fail for any reason.
-*-
-*/
-
-/* Local Variables: */
-   int invert;                   /* FrameSet is inverted? */
-   int result;                   /* Value to return */
-
-/* Initialise. */
-   result = 0;
-
-/* Check the global error status. */
-   if ( !astOK ) return result;
-
-/* Determine if the FrameSet has been inverted. */
-   invert = astGetInvert( this );
-
-/* If it has not been inverted, test the base Frame index, otherwise
-   test the index of the current Frame instead. */
-   if ( astOK ) {
-      if ( !invert ) {
-         result = ( this->base != -INT_MAX );
-      } else {
-         result = ( this->current != -INT_MAX );
-      }
-   }
-
-/* Return the result. */
-   return result;
-}
-
-static int TestCurrent( AstFrameSet *this, int *status ) {
-/*
-*+
-*  Name:
-*     astTestCurrent
-
-*  Purpose:
-*     Test if a value has been set for the Current attribute of a FrameSet.
-
-*  Type:
-*     Protected function.
-
-*  Synopsis:
-*     #include "frameset.h"
-*     int astTestCurrent( AstFrameSet *this )
-
-*  Class Membership:
-*     FrameSet method.
-
-*  Description:
-*     This function returns a boolean result to indicate whether a
-*     value has been set for the Current attribute of a FrameSet.
-*     This attribute is an index that identifies the current Frame in
-*     a FrameSet.
-
-*  Parameters:
-*     this
-*        Pointer to the FrameSet.
-
-*  Returned Value:
-*     Zero or 1, depending on whether a value has been set.
-
-*  Notes:
-*     - A value of zero will be returned if this function is invoked
-*     with the global status set, or if it should fail for any reason.
-*-
-*/
-
-/* Local Variables: */
-   int invert;                   /* FrameSet is inverted? */
-   int result;                   /* Value to return */
-
-/* Initialise. */
-   result = 0;
-
-/* Check the global error status. */
-   if ( !astOK ) return result;
-
-/* Determine if the FrameSet has been inverted. */
-   invert = astGetInvert( this );
-
-/* If it has not been inverted, test the current Frame index,
-   otherwise test the index of the base Frame instead. */
-   if ( astOK ) {
-      if ( !invert ) {
-         result = ( this->current != -INT_MAX );
-      } else {
-         result = ( this->base != -INT_MAX );
-      }
-   }
-
-/* Return the result. */
-   return result;
-}
-
-static int TestVariant( AstFrameSet *this, int *status ) {
-/*
-*+
-*  Name:
-*     astTestVariant
-
-*  Purpose:
-*     Determine if a value has been set for the Variant attribute of a FrameSet.
-
-*  Type:
-*     Protected virtual function.
-
-*  Synopsis:
-*     #include "frameset.h"
-*     int astTestVariant( AstFrameSet *this )
-
-*  Class Membership:
-*     FrameSet method.
-
-*  Description:
-*     This function returns a boolean result to indicate if a value
-*     has been set for the Variant attribute of a FrameSet.
-
-*  Parameters:
-*     this
-*        Pointer to the FrameSet.
-
-*  Returned Value:
-*     Zero or 1, depending on whether a value has been set.
-
-*  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: */
-   AstFrame *frm;
-   AstFrameSet *vfs;
-   int result;
-   int icur;
-
-/* Initialise. */
-   result = 0;
-
-/* Check the global error status. */
-   if ( !astOK ) return result;
-
-/* Get the one-based index of the Frame to use. */
-   icur = GetVarFrm( this, astGetCurrent( this ), status );
-
-/* Get a pointer to the Variants FrameSet in the current Frame. */
-   frm = astGetFrame( this, icur );
-   vfs = astGetFrameVariants( frm );
-
-/* If it is null, return zero, otherwise 1. */
-   result = vfs ? 1 : 0;
-
-/* Annul pointers. */
-   if( vfs ) vfs = astAnnul( vfs );
-   frm = astAnnul( frm );
-
-/* Return the result. */
-   return result;
-}
-
-static void TidyNodes( AstFrameSet *this, int *status ) {
-/*
-*  Name:
-*     TidyNodes
-
-*  Purpose:
-*     Tidy the nodes in a FrameSet.
-
-*  Type:
-*     Private function.
-
-*  Synopsis:
-*     #include "frameset.h"
-*     void TidyNodes( AstFrameSet *this, int *status )
-
-*  Class Membership:
-*     FrameSet member function.
-
-*  Description:
-*     This function tidies the nodes in a FrameSet, removing any that
-*     are unnecessary or represent dead-ends. It should be used after
-*     any changes have been made to a FrameSet that may have reduced
-*     the number of references to any of its nodes (either by Frames
-*     or by other nodes).
-
-*  Parameters:
-*     this
-*        Pointer to the FrameSet.
-*     status
-*        Pointer to the inherited status variable.
-*/
-
-/* Local Variables: */
-   AstMapping *newmap;           /* Pointer to simplified Mapping */
-   AstMapping *tmpmap;           /* Pointer to new compound Mapping */
-   int ifr;                      /* Loop counter for Frames */
-   int inode;                    /* Loop counter for nodes */
-   int last_link[ 2 ];           /* Last nodes to reference via "link" array */
-   int link_ref;                 /* Number of "link" array references */
-   int needed;                   /* Node still required? */
-   int next;                     /* Node which references the removed one */
-   int remove;                   /* Node to be removed */
-   int suspect;                  /* Loop counter for testing nodes */
-
-/* Check the global error status. */
-   if ( !astOK ) return;
-
-/* Loop to search for unnecessary nodes until no more are found. */
-   needed = 0;
-   while ( !needed ) {
-
-/* Inspect each node (including node zero, which does not actually
-   have a Mapping associated with it) to see how many times it is
-   referenced. */
-      for ( suspect = 0; suspect < this->nnode; suspect++ ) {
-         link_ref = 0;
-
-/* Test for at least one reference from within the "node" array which
-   associates Frames with particular nodes. */
-         for ( ifr = 1; ifr <= this->nframe; ifr++ ) {
-            if ( ( needed = ( this->node[ ifr - 1 ] == suspect ) ) ) break;
-         }
-
-/* If no references were found above, look for references in the
-   "link" array that inter-connects all the nodes. */
-         if ( !needed ) {
-            for ( inode = 1; inode < this->nnode; inode ++ ) {
-               if ( this->link[ inode - 1 ] == suspect ) {
-
-/* Node zero must be retained if it has more than two links
-   referencing it, while other nodes only require more than one. */
-                  if ( ( needed = ( link_ref >= ( suspect ? 1 : 2 ) ) ) ) break;
-
-/* Remember (up to) the first two nodes which reference the current one. */
-                  last_link[ link_ref++ ] = inode;
-               }
-            }
-         }
-
-/* If there were insufficient references to retain this node, we must
-   now decide why it should be removed. */
-         if ( !needed ) {
-
-/* If there is no Frame associated with a node and there are less than
-   two links to it (for node zero), or less then one link (for other
-   nodes), then the there is no route to anything else via this node.
-   It is a dead-end. */
-            if ( link_ref < ( suspect ? 1 : 2 ) ) {
-
-/* To tidy up, we remove the affected node or, for node zero, the
-   remaining one that references it. Annul the Mapping associated with
-   the node being removed. */
-               remove = suspect ? suspect : last_link[ 0 ];
-               this->map[ remove - 1 ] = astAnnul( this->map[ remove - 1 ] );
-
-/* If an unnecessary node is not a dead-end, then it is a redundant
-   node which simply joins two Mappings. */
-            } else {
-
-/* To tidy up, we remove the affected node or, for node zero, the
-   first one that references it. */
-               remove = suspect ? suspect : last_link[ 0 ];
-
-/* We then produce a compound Mapping which spans the gap by
-   concatenating the Mappings associated with the node being removed
-   and the remaining one which references it. For node zero, the first
-   of these Mappings must be inverted because there are no out-going
-   Mappings from node zero. */
-               next = suspect ? last_link[ 0 ] : last_link[ 1 ];
-               tmpmap = CombineMaps( this->map[ remove - 1 ],
-                                     this->invert[ remove - 1 ] != !suspect,
-                                     this->map[ next - 1 ],
-                                     this->invert[ next - 1 ], 1, status );
-
-/* Simplify this compound Mapping. */
-               newmap = astSimplify( tmpmap );
-               tmpmap = astAnnul( tmpmap );
-
-/* Annul the individual Mapping pointers. */
-               this->map[ remove - 1 ] = astAnnul( this->map[ remove - 1 ] );
-               this->map[ next - 1 ] = astAnnul( this->map[ next - 1 ] );
-
-/* Install the new compound Mapping and its Invert flag. */
-               this->map[ next - 1 ] = newmap;
-               this->invert[ next - 1 ] = astGetInvert( newmap );
-
-/* Transfer the "link" value from the removed node to the one which
-   takes its place. */
-               this->link[ next - 1 ] = this->link[ remove - 1 ];
-            }
-
-/* Loop to move all subsequent node data down in the "map", "invert"
-   and "link" arrays to close the gap where a node has been
-   removed. */
-            for ( inode = remove; inode < this->nnode - 1; inode ++ ) {
-               this->map [ inode - 1 ] = this->map[ inode ];
-               this->link [ inode - 1 ] = this->link[ inode ];
-               this->invert[ inode - 1 ] = this->invert[ inode ];
-            }
-            this->map[ this->nnode - 2 ] = NULL;
-            this->link[ this->nnode - 2 ] = -1;
-            this->invert[ this->nnode - 2 ] = -1;
-
-/* Decrement the node count. */
-            this->nnode--;
-
-/* Loop to adjust each entry in the "node" array for the change in
-   node numbering, re-directing references to the removed node towards
-   the new node zero. */
-            for ( ifr = 1; ifr <= this->nframe; ifr++ ) {
-               if ( this->node[ ifr - 1 ] > remove ) {
-                  this->node[ ifr - 1 ]--;
-               } else if ( this->node[ ifr - 1 ] == remove ) {
-                  this->node[ ifr - 1 ] = 0;
-               }
-            }
-
-/* Similarly adjust each entry in the "link" array. */
-            for ( inode = 1; inode < this->nnode; inode++ ) {
-               if ( this->link[ inode - 1 ] > remove ) {
-                  this->link[ inode - 1 ]--;
-               } else if ( this->link[ inode - 1 ] == remove ) {
-                  this->link[ inode - 1 ] = 0;
-               }
-            }
-
-/* Once a node has been removed, other nodes (perhaps already tested)
-   may no longer be needed, so quit the testing loop and start testing
-   again with node zero. The process terminates when no more
-   unnecessary nodes can be found. */
-            break;
-         }
-      }
-   }
-}
-
-static AstPointSet *Transform( AstMapping *this_mapping, AstPointSet *in,
-                               int forward, AstPointSet *out, int *status ) {
-/*
-*  Name:
-*     Transform
-
-*  Purpose:
-*     Transform a set of points.
-
-*  Type:
-*     Private function.
-
-*  Synopsis:
-*     #include "frameset.h"
-*     AstPointSet *Transform( AstMapping *this, AstPointSet *in,
-*                             int forward, AstPointSet *out, int *status )
-
-*  Class Membership:
-*     FrameSet member function (over-rides the astTransform method
-*     inherited from the Frame class).
-
-*  Description:
-*     This function takes a FrameSet and a set of points encapsulated
-*     in a PointSet, and applies either the forward or inverse
-*     coordinate transformation (if defined by the FrameSet) to the
-*     points. The forward transformation converts between the
-*     FrameSet's base Frame and its current Frame, while the inverse
-*     transformation converts in the opposite direction.
-
-*  Parameters:
-*     this
-*        Pointer to the FrameSet.
-*     in
-*        Pointer to the PointSet holding the input coordinate data.
-*     forward
-*        A non-zero value indicates that the forward coordinate transformation
-*        should be applied, while a zero value requests the inverse
-*        transformation.
-*     out
-*        Pointer to a PointSet which will hold the transformed (output)
-*        coordinate values. A NULL value may also be given, in which case a
-*        new PointSet will be created by this function.
-*     status
-*        Pointer to the inherited status variable.
-
-*  Returned Value:
-*     Pointer to the output (possibly new) PointSet.
-
-*  Notes:
-*     - An error will result if the FrameSet supplied does not define
-*     the requested coordinate transformation (either forward or
-*     inverse).
-*     - The number of coordinate values per point in the input
-*     PointSet must match the number of input coordinates for the
-*     FrameSet being applied (or number of output coordinates if the
-*     inverse transformation is requested).  This will be equal to the
-*     number of axes in the FrameSet's base Frame (or the current
-*     Frame for the inverse transformation).
-*     - If an output PointSet is supplied, it must have space for
-*     sufficient number of points and coordinate values per point to
-*     accommodate the result (e.g. the number of FrameSet output
-*     coordinates, or number of input coordinates if the inverse
-*     transformation is requested). Any excess space will be ignored.
-*     - 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: */
-   AstFrameSet *this;            /* Pointer to the FrameSet structure */
-   AstMapping *map;              /* Pointer to the base->current Mapping */
-   AstPointSet *result;          /* Pointer value to return */
-
-/* Check the global error status. */
-   if ( !astOK ) return NULL;
-
-/* Obtain a pointer to the FrameSet structure. */
-   this = (AstFrameSet *) this_mapping;
-
-/* Obtain the Mapping between the base and current Frames in the
-   FrameSet (note this takes account of whether the FrameSet has been
-   inverted). */
-   map = astGetMapping( this, AST__BASE, AST__CURRENT );
-
-/* Apply the Mapping to the input PointSet. */
-   result = astTransform( map, in, forward, out );
-
-/* Annul the Mapping pointer. */
-   map = astAnnul( map );
-
-/* If an error has occurred and a new PointSet may have been created, then
-   clean up by annulling it. In any case, ensure that a NULL result is
-   returned.*/
-   if ( !astOK ) {
-      if ( !out ) result = astAnnul( result );
-      result = NULL;
-   }
-
-/* Return a pointer to the output PointSet. */
-   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 FrameSet axis.
-
-*  Type:
-*     Private function.
-
-*  Synopsis:
-*     #include "frameset.h"
-*     int Unformat( AstFrame *this, int axis, const char *string,
-*                   double *value, int *status )
-
-*  Class Membership:
-*     FrameSet member function (over-rides the public astUnformat
-*     method inherited from the Frame class).
-
-*  Description:
-*     This function reads a formatted coordinate value for a FrameSet
-*     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 FrameSet.
-*     axis
-*        The number of the FrameSet axis for which the coordinate
-*        value is to be read (axis numbering starts at zero for the
-*        first axis).
-*     string
-*        Pointer to a constant null-terminated string containing the
-*        formatted coordinate value.
-*     value
-*        Pointer to a double in which the coordinate value read will be
-*        returned.
-*     status
-*        Pointer to the inherited status variable.
-
-*  Returned Value:
-*     The number of characters read from the string to obtain the
-*     coordinate value.
-
-*  Notes:
-*     - Any white space at the beginning of the string will be
-*     skipped, as also will any trailing white space following the
-*     coordinate value read. The function's return value will reflect
-*     this.
-*     - A function value of zero (and no coordinate value) will be
-*     returned, without error, if the string supplied does not contain
-*     a suitably formatted value.
-*     - The string "<bad>" is recognised as a special case and will
-*     generate the value AST__BAD, without error. The test for this
-*     string is case-insensitive and permits embedded white space.
-*     - A function result of zero will be returned and no coordinate
-*     value will be returned via the "value" pointer if this function
-*     is invoked with the global error status set, or if it should
-*     fail for any reason.
-*/
-
-/* Local Variables: */
-   AstFrame *fr;                 /* Pointer to current Frame */
-   AstFrameSet *this;            /* Pointer to the FrameSet structure */
-   double coord;                 /* Coordinate value read */
-   int nc;                       /* Number of characters read */
-
-/* Initialise. */
-   nc = 0;
-
-/* Check the global error status. */
-   if ( !astOK ) return nc;
-
-/* Obtain a pointer to the FrameSet structure. */
-   this = (AstFrameSet *) this_frame;
-
-/* Validate the axis index. */
-   (void) astValidateAxis( this, axis, 1, "astUnformat" );
-
-/* Obtain a pointer to the FrameSet's current Frame and invoke the
-   astUnformat method for this Frame. Annul the Frame pointer
-   afterwards. */
-   fr = astGetFrame( this, AST__CURRENT );
-   nc = astUnformat( fr, axis, string, &coord );
-   fr = astAnnul( fr );
-
-/* 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 ValidateAxis( AstFrame *this_frame, int axis, int fwd,
-                         const char *method, int *status ) {
-/*
-*  Name:
-*     ValidateAxis
-
-*  Purpose:
-*     Validate and permute a FrameSet's axis index.
-
-*  Type:
-*     Private function.
-
-*  Synopsis:
-*     #include "frameset.h"
-*     int ValidateAxis( AstFrame *this, int axis, int fwd, const char *method,
-*                       int *status )
-
-*  Class Membership:
-*     FrameSet member function (over-rides the protected
-*     astValidateAxis method inherited from the Frame class).
-
-*  Description:
-*     This function checks the validity of an index (zero-based) which
-*     is to be used to address one of the coordinate axes of the
-*     current Frame in a FrameSet. If the index is valid, it is
-*     permuted using the axis permutation array associated with the
-*     FrameSet's current Frame and the (zero-based) permuted axis
-*     index is returned.  This gives the index the axis had when the
-*     Frame was first created. If the axis index supplied is not
-*     valid, an error is reported and the global error status is set.
-
-*  Parameters:
-*     this
-*        Pointer to the FrameSet.
-*     axis
-*        The axis index (zero-based) to be checked. To be valid, it
-*        must lie between zero and (naxes-1) inclusive, where "naxes"
-*        is the number of coordinate axes associated with the
-*        FrameSet's current Frame.
-*     fwd
-*        If non-zero, the suppplied axis index is assumed to be an
-*        "external" axis index, and the corresponding "internal" axis index
-*        is returned as the function value. Otherwise, the suppplied axis
-*        index is assumed to be an "internal" axis index, and the
-*        corresponding "external" axis index is returned as the function
-*        value.
-*     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 permuted axis index - either "internal" or "external" as
-*     specified by "fwd".
-
-*  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: */
-   AstFrame *fr;                 /* Pointer to current Frame */
-   AstFrameSet *this;            /* Pointer to the FrameSet structure */
-   int naxes;                    /* Number of FrameSet axes */
-   int result;                   /* Permuted axis index */
-
-/* Initialise. */
-   result = 0;
-
-/* Check the global error status. */
-   if ( !astOK ) return result;
-
-/* Obtain a pointer to the FrameSet structure. */
-   this = (AstFrameSet *) this_frame;
-
-/* Determine the number of FrameSet axes. */
-   naxes = astGetNaxes( this );
-   if ( astOK ) {
-
-/* If the FrameSet has no axes, report an error (convert to 1-based
-   axis numbering for the benefit of the public interface). */
-      if ( naxes == 0 ) {
-         astError( AST__AXIIN, "%s(%s): Invalid attempt to use an axis index "
-                   "(%d) for a %s which has no axes.", status, method,
-                   astGetClass( this ), axis + 1, astGetClass( this ) );
-
-/* Otherwise, check the axis index for validity and report an error if
-   it is not valid (again, convert to 1-based axis numbering). */
-      } else if ( ( axis < 0 ) || ( axis >= naxes ) ) {
-         astError( AST__AXIIN, "%s(%s): Axis index (%d) invalid - it should "
-                   "be in the range 1 to %d.", status, method, astGetClass( this ),
-                   axis + 1, naxes );
-
-/* If the axis index was valid, obtain a pointer to the FrameSet's
-   current Frame and invoke this Frame's astValidateAxis method to
-   obtain the permuted axis index. Annul the Frame pointer
-   afterwards. */
-      } else {
-         fr = astGetFrame( this, AST__CURRENT );
-         result = astValidateAxis( fr, axis, fwd, "astValidateAxis" );
-         fr = astAnnul( fr );
-      }
-   }
-
-/* If an error occurred, clear the result value. */
-   if ( !astOK ) result = 0;
-
-/* Return the result. */
-   return result;
-}
-
-static void ValidateAxisSelection( AstFrame *this_frame, int naxes,
-                                   const int *axes, const char *method, int *status ) {
-/*
-*  Name:
-*     ValidateAxisSelection
-
-*  Purpose:
-*     Check that a set of axes selected from a Frame is valid.
-
-*  Type:
-*     Private function.
-
-*  Synopsis:
-*     #include "frameset.h"
-*     void ValidateAxisSelection( AstFrame *this, int naxes,
-*                                 const int *axes, const char *method, int *status )
-
-*  Class Membership:
-*     FrameSet member function (over-rides the protected astValidateAxisSelection
-*     method inherited from the Frame class).
-
-*  Description:
-*     This function checks the validity of an array of (zero-based)
-*     axis indices that specify a set of axes to be selected from a
-*     Frame. To be valid, no axis should be selected more than
-*     once. In assessing this, any axis indices that do not refer to
-*     valid Frame axes (e.g. are set to -1) are ignored.
-*
-*     If the axis selection is valid, this function returns without further
-*     action. Otherwise, an error is reported and the global error status is
-*     set.
-
-*  Parameters:
-*     this
-*        Pointer to the Frame.
-*     naxes
-*        The number of axes to be selected (may be zero).
-*     axes
-*        Pointer to an array of int with naxes elements that contains the
-*        (zero based) axis indices 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 selection. This method name is used
-*        solely for constructing error messages.
-*     status
-*        Pointer to the inherited status variable.
-*/
-
-/* Local Variables: */
-   AstFrame *fr;                 /* Pointer to current Frame */
-   AstFrameSet *this;            /* Pointer to the FrameSet structure */
-
-/* Check the global error status. */
-   if ( !astOK ) return;
-
-/* Obtain a pointer to the FrameSet structure. */
-   this = (AstFrameSet *) this_frame;
-
-/* Obtain a pointer to the FrameSet's current Frame and invoke this
-   Frame's astValidateAxisSelection method. Annul the Frame pointer
-   afterwards. */
-   fr = astGetFrame( this, AST__CURRENT );
-   astValidateAxisSelection( fr, naxes, axes, method );
-   fr = astAnnul( fr );
-
-}
-
-static int ValidateFrameIndex( AstFrameSet *this, int iframe,
-                               const char *method, int *status ) {
-/*
-*+
-*  Name:
-*     astValidateFrameIndex
-
-*  Purpose:
-*     Validate a FrameSet Frame index number.
-
-*  Type:
-*     Protected virtual function.
-
-*  Synopsis:
-*     #include "frameset.h"
-*     int astValidateFrameIndex( AstFrameSet *this, int iframe,
-*                                const char *method )
-
-*  Class Membership:
-*     FrameSet method.
-
-*  Description:
-*     This function checks a (one-based) FrameSet Frame index for
-*     validity. If it is not valid, an error is reported. Otherwise,
-*     the function returns the Frame index value, having translated
-*     the special values AST__CURRENT and AST__BASE into valid Frame
-*     indices if necessary.
-
-*  Parameters:
-*     this
-*        Pointer to the FrameSet.
-*     iframe
-*        The Frame index. To be valid this should lie in the range 1
-*        to the number of Frames in the FrameSet.  In addition, the
-*        values AST__CURRENT and AST__BASE may be given to indicate
-*        the "current" and "base" Frames. These values will be
-*        translated into the acceptable range.
-*     method
-*        Pointer to a constant null-terminated character string
-*        containing the name of the method that invoked this function
-*        to validate a Frame index. This method name is used solely
-*        for constructing error messages.
-
-*  Returned Value:
-*     The validated (one-based) Frame index.
-
-*  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
-*     (e.g. if the Frame index is invalid).
-*-
-*/
-
-/* Local Variables: */
-   int nframe;                   /* Number of Frames */
-   int result;                   /* Returned index value */
-
-/* Initialise. */
-   result = 0;
-
-/* Check the global error status. */
-   if ( !astOK ) return result;
-
-/* Check if the base or current Frame was specified and retrieve the
-   required Frame index from the FrameSet. */
-   if ( iframe == AST__BASE ) {
-      result = astGetBase( this );
-   } else if ( iframe == AST__CURRENT ) {
-      result = astGetCurrent( this );
-
-/* Otherwise, determine how many Frames there are in the FrameSet. */
-   } else {
-      nframe = astGetNframe( this );
-      if ( astOK ) {
-
-/* Check that the supplied index is within range and report an error
-   if it is not. */
-         if ( ( iframe < 1 ) || ( iframe > nframe ) ) {
-            astError( AST__FRMIN, "%s(%s): Invalid Frame index (%d) given.", status,
-                      method, astGetClass( this ), iframe );
-            astError( AST__FRMIN, "This value should be in the range 1 to "
-                      "%d (or AST__CURRENT or AST__BASE).", status, nframe );
-
-/* If OK, return the validated index value. */
-         } else {
-            result = iframe;
-         }
-      }
-   }
-
-/* Return the result. */
-   return result;
-}
-
-static int ValidateSystem( AstFrame *this_frame, AstSystemType system, const char *method, int *status ) {
-/*
-*  Name:
-*     ValidateSystem
-
-*  Purpose:
-*     Validate a value for a Frame's System attribute.
-
-*  Type:
-*     Private function.
-
-*  Synopsis:
-*     #include "frameset.h"
-*     int ValidateSystem( AstFrame *this, AstSystemType system,
-*                         const char *method, int *status )
-
-*  Class Membership:
-*     FrameSet member function (over-rides the protected 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 */
-   AstFrame *fr;              /* Pointer to FrameSet's current Frame */
-   AstFrameSet *this;         /* Pointer to the FrameSet structure */
-
-/* Initialise. */
-   result = AST__BADSYSTEM;
-
-/* Check the global error status. */
-   if ( !astOK ) return result;
-
-/* Obtain a pointer to the FrameSet structure. */
-   this = (AstFrameSet *) this_frame;
-
-/* Obtain a pointer to the FrameSet's current Frame and invoke the
-   astValidateSystem method for this Frame. Annul the Frame pointer
-   afterwards. */
-   fr = astGetFrame( this, AST__CURRENT );
-   result = astValidateSystem( this, system, method );
-   fr = astAnnul( fr );
-
-/* If an error occurred, clear the result value. */
-   if ( !astOK ) result = AST__BADSYSTEM;
-
-/* Return the result. */
-   return result;
-}
-
-static void VSet( AstObject *this_object, const char *settings,
-                  char **text, va_list args, int *status ) {
-/*
-*  Name:
-*     VSet
-
-*  Purpose:
-*     Set values for a FrameSet's attributes.
-
-*  Type:
-*     Private function.
-
-*  Synopsis:
-*     #include "frameset.h"
-*     void VSet( AstObject *this, const char *settings, char **text,
-*                va_list args, int *status )
-
-*  Class Membership:
-*     FrameSet member function (over-rides the protected astVSet
-*     method inherited from the Object class).
-
-*  Description:
-*     This function assigns a set of attribute values for a FrameSet,
-*     the attributes and their values being specified by means of a
-*     string containing a comma-separated list of the form:
-*
-*        "attribute1 = value1, attribute2 = value2, ... "
-*
-*     Here, "attribute" specifies an attribute name and the value to
-*     the right of each "=" sign should be a suitable textual
-*     representation of the value to be assigned to that
-*     attribute. This will be interpreted according to the attribute's
-*     data type.
-*
-*     The string supplied may also contain "printf"-style format
-*     specifiers identified by a "%" sign in the usual way. If
-*     present, these will be substituted by values supplied as
-*     optional arguments (as a va_list variable argument list), using
-*     the normal "printf" rules, before the string is used.
-
-*  Parameters:
-*     this
-*        Pointer to the FrameSet.
-*     settings
-*        Pointer to a null-terminated string containing a
-*        comma-separated list of attribute settings.
-*     text
-*        Pointer to a location at which to return a pointer to dynamic
-*        memory holding a copy of the expanded setting string. This memory
-*        should be freed using astFree when no longer needed. If a NULL
-*        pointer is supplied, no string is created.
-*     args
-*        The variable argument list which contains values to be
-*        substituted for any "printf"-style format specifiers that
-*        appear in the "settings" string.
-*     status
-*        Pointer to the inherited status variable.
-
-*  Notes:
-*     - This function preserves the integrity of the FrameSet (if
-*     possible) by appropriately remapping its current Frame to take
-*     account of its changed attribute values.
-*/
-
-/* Local Variables: */
-   astDECLARE_GLOBALS            /* Declare the thread specific global data */
-   AstFrame *save_frame;         /* Saved pointer to integrity Frame */
-   AstFrameSet *this;            /* Pointer to FrameSet structure */
-   char *fulltext;               /* Pointer to expanded text string */
-   const char *save_method;      /* Saved pointer to method name */
-   int len;                      /* Length of settings string */
-   int ok;                       /* Status OK? */
-   int save_lost;                /* Saved integrity modified flag */
-
-/* Initialise */
-   if( text ) *text = NULL;
-
-/* Check the global error status. */
-   if ( !astOK ) return;
-
-/* Get a pointer to the structure holding thread-specific global data. */
-   astGET_GLOBALS(this_object);
-
-/* Obtain the length of the "settings" string and test it is not
-   zero. If it is, there is nothing more to do. */
-   len = (int) strlen( settings );
-   if ( len != 0 ) {
-
-/* Obtain a pointer to the FrameSet structure. */
-      this = (AstFrameSet *) this_object;
-
-/* This function may be invoked recursively (because astConvert,
-   below, constructs a FrameSet and may require that its attributes be
-   set). To allow this, we first save any existing FrameSet integrity
-   information in local variables. */
-      save_frame = integrity_frame;
-      save_lost = integrity_lost;
-      save_method = integrity_method;
-
-/* Set the name of the method being used (for use in error
-   messages). */
-      integrity_method = "astSet";
-
-/* Record the initial integrity state of the FrameSet. */
-      RecordIntegrity( this, status );
-
-/* Invoke the parent astVSet method to set the FrameSet's attribute
-   values and note if this succeeds. */
-      (*parent_vset)( this_object, settings, &fulltext, args, status );
-      ok = astOK;
-
-/* Restore the FrameSet's integrity. */
-      RestoreIntegrity( this, status );
-
-/* If integrity could not be restored, then add contextual error
-   information. */
-      if ( !astOK && ok ) {
-
-/* Display the message. */
-         astError( astStatus, "Unable to accommodate the attribute setting "
-                               "\"%s\".", status, fulltext );
-      }
-
-/* Restore any saved FrameSet integrity information. */
-      integrity_frame = save_frame;
-      integrity_lost = save_lost;
-      integrity_method = save_method;
-
-/* If the full text of the setting string is not needed, free it.
-   Otherwise return it. */
-      if( text ) {
-         *text = fulltext;
-      } else {
-         fulltext = astFree( fulltext );
-      }
-   }
-}
-
-/* FrameSet Attributes. */
-/* -------------------- */
-/*
-*att++
-*  Name:
-*     AllVariants
-
-*  Purpose:
-*     A list of the variant Mappings associated with the current Frame.
-
-*  Type:
-*     Public attribute.
-
-*  Synopsis:
-*     String, read-only.
-
-*  Description:
-*     This attribute gives a space separated list of the names of all the
-*     variant Mappings associated with the current Frame (see attribute
-*     "Variant"). If the current Frame has no variant Mappings, then the
-*     list will hold a single entry equal to the Domain name of the
-*     current Frame.
-
-*  Applicability:
-*     FrameSet
-*        All FrameSets have this attribute.
-*att--
-*/
-
-/*
-*att++
-*  Name:
-*     Base
-
-*  Purpose:
-*     FrameSet base Frame index.
-
-*  Type:
-*     Public attribute.
-
-*  Synopsis:
-*     Integer.
-
-*  Description:
-*     This attribute gives the index of the Frame which is to be
-*     regarded as the "base" Frame within a FrameSet. The default is
-*     the first Frame added to the FrameSet when it is created (this
-*     Frame always has an index of 1).
-*
-*     When setting a new value for this attribute, a string may be
-*     supplied instead of an integer index. In this case a search
-*     is made within the FrameSet for a Frame that has its Domain
-*     attribute value equal to the supplied string (the comparison is
-*     case-insensitive). If found, the Frame is made the base Frame.
-*     Otherwise an error is reported.
-
-*  Applicability:
-*     FrameSet
-*        All FrameSets have this attribute.
-
-*  Notes:
-*     - Inverting a FrameSet (inverting the boolean sense of its
-c     Invert attribute, with the astInvert function for example) will
-f     Invert attribute, with the AST_INVERT routine for example) will
-*     interchange the values of its Base and Current attributes.
-*att--
-*/
-
-/*
-*att++
-*  Name:
-*     Current
-
-*  Purpose:
-*     FrameSet current Frame index.
-
-*  Type:
-*     Public attribute.
-
-*  Synopsis:
-*     Integer.
-
-*  Description:
-*     This attribute gives the index of the Frame which is to be
-*     regarded as the "current" Frame within a FrameSet. The default
-*     is the most recent Frame added to the FrameSet (this Frame
-*     always has an index equal to the FrameSet's Nframe attribute).
-*
-*     When setting a new value for this attribute, a string may be
-*     supplied instead of an integer index. In this case a search
-*     is made within the FrameSet for a Frame that has its Domain
-*     attribute value equal to the supplied string (the comparison is
-*     case-insensitive). If found, the Frame is made the current Frame.
-*     Otherwise an error is reported.
-
-*  Applicability:
-*     FrameSet
-*        All FrameSets have this attribute.
-
-*  Notes:
-*     - Inverting a FrameSet (inverting the boolean sense of its
-c     Invert attribute, with the astInvert function for example) will
-f     Invert attribute, with the AST_INVERT routine for example) will
-*     interchange the values of its Base and Current attributes.
-*att--
-*/
-
-/*
-*att++
-*  Name:
-*     Nframe
-
-*  Purpose:
-*     Number of Frames in a FrameSet.
-
-*  Type:
-*     Public attribute.
-
-*  Synopsis:
-*     Integer, read-only.
-
-*  Description:
-*     This attribute gives the number of Frames in a FrameSet. This
-*     value will change as Frames are added or removed, but will
-*     always be at least one.
-
-*  Applicability:
-*     FrameSet
-*        All FrameSets have this attribute.
-*att--
-*/
-
-/*
-*att++
-*  Name:
-*     Variant
-
-*  Purpose:
-*     Indicates which variant of the current Frame is to be used.
-
-*  Type:
-*     Public attribute.
-
-*  Synopsis:
-*     String.
-
-*  Description:
-*     This attribute can be used to change the Mapping that connects the
-*     current Frame to the other Frames in the FrameSet. By default, each
-*     Frame in a FrameSet is connected to the other Frames by a single
-*     Mapping that can only be changed by using the
-c     astRemapFrame
-f     AST_REMAPFRAME
-*     method. However, it is also possible to associate multiple Mappings
-*     with a Frame, each Mapping having an identifying name. If this is
-*     done, the "Variant" attribute can be set to indicate the name of
-*     the Mapping that is to be used with the current Frame.
-*
-*     A possible (if unlikely) use-case is to create a FrameSet that can
-*     be used to describe the WCS of an image formed by co-adding images
-*     of two different parts of the sky. In such an image, each pixel contains
-*     flux from two points on the sky.and so the WCS for the image should
-*     ideally contain one pixel Frame and two SkyFrames - one describing
-*     each of the two co-added images. There is nothing to prevent a
-*     FrameSet containing two explicit SkyFrames, but the problem then arises
-*     of how to distinguish between them. The two primary characteristics of
-*     a Frame that distinguishes it from other Frames are its class and its
-*     Domain attribute value. The class of a Frame cannot be changed, but we
-*     could in principle use two different Domain values to distinguish the
-*     two SkyFrames. However, in practice it is not uncommon for application
-*     software to assume that SkyFrames will have the default Domain value
-*     of "SKY". That is, instead of searching for Frames that have a class
-*     of "SkyFrame", such software searches for Frames that have a Domain
-*     of "SKY". To alleviate this problem, it is possible to add a single
-*     SkyFrame to the FrameSet, but specifying two alternate Mappings to
-*     use with the SkyFrame. Setting the "Variant" attribute to the name
-*     of one or the other of these alternate Mappings will cause the
-*     SkyFrame to be remapped within the FrameSet so that it uses the
-*     specified Mapping. The same facility can be used with any class of
-*     Frame, not just SkyFrames.
-*
-*     To use this facility, the Frame should first be added to the
-*     FrameSet in the usual manner using the
-c     astAddFrame method. By default, the Mapping supplied to astAddFrame
-f     AST_ADDFRAME method. By default, the Mapping supplied to AST_ADDVARIANT
-*     is assigned a name equal to the Domain name of the Frame. To assign a
-*     different name to it, the
-c     astAddVariant
-f     AST_ADDVARIANT
-*     method should then be called specifying the required name and a NULL
-*     Mapping. The
-c     astAddVariant
-f     AST_ADDVARIANT
-*     method should then be called repeatedly to add each required extra
-*     Mapping to the current Frame, supplying a unique name for each one.
-*
-*     Each Frame in a FrameSet can have its own set of variant Mappings.
-*     To control the Mappings in use with a specific Frame, you need first
-*     to make it the current Frame in the FrameSet.
-*
-*     The
-c     astMirrorVariants function
-f     AST_MIRRORVARIANTS routine
-*     allows the effects of variant Mappings associated with a nominated
-*     Frame to be propagated to other Frames in the FrameSet.
-*
-*     Once this has been done, setting a new value for the "Variant"
-*     attribute of a FrameSet will cause the current Frame in the
-*     FrameSet to be remapped to use the specified variant Mapping. An
-*     error will be reported if the current Frame has no variant Mapping
-*     with the supplied name.
-*
-*     Getting the value of the "Variant" attribute will return the name
-*     of the variant Mapping currently in use with the current Frame. If
-*     the Frame has no variant Mappings, the value will default to the
-*     Domain name of the current Frame.
-*
-*     Clearing the "Variant" attribute will have the effect of removing
-*     all variant Mappings (except for the currently selected Mapping) from
-*     the current Frame.
-*
-*     Testing the "Variant" attribute will return
-c     a non-zero value
-f     .TRUE.
-*     if the current Frame contains any variant Mappings, and
-c     zero
-f     .FALSE.
-*     otherwise.
-*
-*     A complete list of the names associated with all the available
-*     variant Mappings in the current Frame can be obtained from the
-*     AllVariants attribute.
-*
-*     If a Frame with variant Mappings is remapped using the
-c     astRemapFrame
-f     AST_REMAPFRAME
-*     method, the currently selected variant Mapping is used by
-c     astRemapFrame
-f     AST_REMAPFRAME
-*     and the other variant Mappings are removed from the Frame.
-
-*  Applicability:
-*     FrameSet
-*        All FrameSets have this attribute.
-*att--
-*/
-
-/* Access to attributes of the current Frame. */
-/* ------------------------------------------ */
-/* Use the macros defined at the start of this file to implement
-   private member functions that give access to the attributes of the
-   current Frame of a FrameSet and its axes. These functions over-ride
-   the attribute access methods inherited from the Frame class. */
-
-/* Clear, Get, Set and Test axis-independent Frame attributes. */
-MAKE_CLEAR(Digits)
-MAKE_CLEAR(Domain)
-MAKE_CLEAR(MatchEnd)
-MAKE_CLEAR(MaxAxes)
-MAKE_CLEAR(MinAxes)
-MAKE_CLEAR(Permute)
-MAKE_CLEAR(PreserveAxes)
-MAKE_CLEAR(Title)
-
-MAKE_GET(Digits,int)
-MAKE_GET(Domain,const char *)
-MAKE_GET(MatchEnd,int)
-MAKE_GET(MaxAxes,int)
-MAKE_GET(MinAxes,int)
-MAKE_GET(Permute,int)
-MAKE_GET(PreserveAxes,int)
-MAKE_GET(Title,const char *)
-MAKE_SET(Digits,int)
-MAKE_SET(Domain,const char *)
-MAKE_SET(MatchEnd,int)
-MAKE_SET(MaxAxes,int)
-MAKE_SET(MinAxes,int)
-MAKE_SET(Permute,int)
-MAKE_SET(PreserveAxes,int)
-MAKE_SET(Title,const char *)
-MAKE_TEST(Digits)
-MAKE_TEST(Domain)
-MAKE_TEST(MatchEnd)
-MAKE_TEST(MaxAxes)
-MAKE_TEST(MinAxes)
-MAKE_TEST(Permute)
-MAKE_TEST(PreserveAxes)
-MAKE_TEST(Title)
-
-MAKE_GET(ActiveUnit,int)
-MAKE_SET(ActiveUnit,int)
-MAKE_TEST(ActiveUnit)
-
-MAKE_GET(System,AstSystemType)
-MAKE_SET(System,AstSystemType)
-MAKE_TEST(System)
-MAKE_CLEAR(System)
-
-MAKE_GET(AlignSystem,AstSystemType)
-MAKE_SET(AlignSystem,AstSystemType)
-MAKE_TEST(AlignSystem)
-MAKE_CLEAR(AlignSystem)
-
-MAKE_GET(Epoch,double)
-MAKE_SET(Epoch,double)
-MAKE_TEST(Epoch)
-MAKE_CLEAR(Epoch)
-
-MAKE_GET(Dtai,double)
-MAKE_SET(Dtai,double)
-MAKE_TEST(Dtai)
-MAKE_CLEAR(Dtai)
-
-MAKE_GET(Dut1,double)
-MAKE_SET(Dut1,double)
-MAKE_TEST(Dut1)
-MAKE_CLEAR(Dut1)
-
-MAKE_GET(ObsLon,double)
-MAKE_SET(ObsLon,double)
-MAKE_TEST(ObsLon)
-MAKE_CLEAR(ObsLon)
-
-MAKE_GET(ObsLat,double)
-MAKE_SET(ObsLat,double)
-MAKE_TEST(ObsLat)
-MAKE_CLEAR(ObsLat)
-
-MAKE_GET(ObsAlt,double)
-MAKE_SET(ObsAlt,double)
-MAKE_TEST(ObsAlt)
-MAKE_CLEAR(ObsAlt)
-
-/* Clear, Get, Set and Test axis-dependent Frame attributes. */
-MAKE_CLEAR_AXIS(Direction)
-MAKE_CLEAR_AXIS(Format)
-MAKE_CLEAR_AXIS(Label)
-MAKE_CLEAR_AXIS(Symbol)
-MAKE_CLEAR_AXIS(Unit)
-MAKE_GET_AXIS(Direction,int)
-MAKE_GET_AXIS(Format,const char *)
-MAKE_GET_AXIS(Label,const char *)
-MAKE_GET_AXIS(Symbol,const char *)
-MAKE_GET_AXIS(Unit,const char *)
-MAKE_SET_AXIS(Direction,int)
-MAKE_SET_AXIS(Format,const char *)
-MAKE_SET_AXIS(Label,const char *)
-MAKE_SET_AXIS(Symbol,const char *)
-MAKE_SET_AXIS(Unit,const char *)
-MAKE_TEST_AXIS(Direction)
-MAKE_TEST_AXIS(Format)
-MAKE_TEST_AXIS(Label)
-MAKE_TEST_AXIS(Symbol)
-MAKE_TEST_AXIS(Unit)
-
-MAKE_GET_AXIS(Bottom,double)
-MAKE_SET_AXIS(Bottom,double)
-MAKE_TEST_AXIS(Bottom)
-MAKE_CLEAR_AXIS(Bottom)
-
-MAKE_GET_AXIS(Top,double)
-MAKE_SET_AXIS(Top,double)
-MAKE_TEST_AXIS(Top)
-MAKE_CLEAR_AXIS(Top)
-
-/* Copy constructor. */
-/* ----------------- */
-static void Copy( const AstObject *objin, AstObject *objout, int *status ) {
-/*
-*  Name:
-*     Copy
-
-*  Purpose:
-*     Copy constructor for FrameSet objects.
-
-*  Type:
-*     Private function.
-
-*  Synopsis:
-*     void Copy( const AstObject *objin, AstObject *objout, int *status )
-
-*  Description:
-*     This function implements the copy constructor for FrameSet 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: */
-   AstFrameSet *in;              /* Pointer to input FrameSet */
-   AstFrameSet *out;             /* Pointer to output FrameSet */
-   int iframe;                   /* Loop counter for Frames */
-   int inode;                    /* Loop counter for nodes */
-
-/* Check the global error status. */
-   if ( !astOK ) return;
-
-/* Obtain pointers to the input and output FrameSets. */
-   in = (AstFrameSet *) objin;
-   out = (AstFrameSet *) objout;
-
-/* For safety, first clear any references to the input memory from
-   the output FrameSet. */
-   out->frame = NULL;
-   out->varfrm = NULL;
-   out->node = NULL;
-   out->map = NULL;
-   out->link = NULL;
-   out->invert = NULL;
-
-/* Allocate memory in the output FrameSet to store the Frame and node
-   information and copy scalar information across. */
-   out->frame = astMalloc( sizeof( AstFrame * ) * (size_t) in->nframe );
-   out->varfrm = astStore( NULL, in->varfrm, sizeof( int ) *
-                                         (size_t) in->nframe );
-   out->node = astStore( NULL, in->node, sizeof( int ) *
-                                         (size_t) in->nframe );
-   out->map = astMalloc( sizeof( AstMapping * ) * (size_t) ( in->nnode - 1 ) );
-   out->link = astStore( NULL, in->link, sizeof( int ) *
-                                         (size_t) ( in->nnode - 1 ) );
-   out->invert = astStore( NULL, in->invert, sizeof( int ) *
-                                         (size_t) ( in->nnode - 1 ) );
-
-/* If OK, make copies of each input Frame and Mapping and store the
-   resulting pointers in the output FrameSet. */
-   if ( astOK ) {
-      for ( iframe = 0; iframe < in->nframe; iframe++ ) {
-         out->frame[ iframe ] = astCopy( in->frame[ iframe ] );
-      }
-      for ( inode = 0; inode < in->nnode - 1; inode++ ) {
-         out->map[ inode ] = astCopy( in->map[ inode ] );
-      }
-
-/* If an error occurred while copying any of these objects, clean up
-   by looping through the arrays of pointers again and annulling them
-   all. */
-      if ( !astOK ) {
-         for ( iframe = 0; iframe < in->nframe; iframe++ ) {
-            out->frame[ iframe ] = astAnnul( out->frame[ iframe ] );
-         }
-         for ( inode = 0; inode < in->nnode - 1; inode++ ) {
-            out->map[ inode ] = astAnnul( out->map[ inode ] );
-         }
-      }
-   }
-
-/* If an error occurred, clean up by freeing all memory allocated above. */
-   if ( !astOK ) {
-      out->frame = astFree( out->frame );
-      out->varfrm = astFree( out->varfrm );
-      out->node = astFree( out->node );
-      out->map = astFree( out->map );
-      out->link = astFree( out->link );
-      out->invert = astFree( out->invert );
-   }
-}
-
-/* Destructor. */
-/* ----------- */
-static void Delete( AstObject *obj, int *status ) {
-/*
-*  Name:
-*     Delete
-
-*  Purpose:
-*     Destructor for FrameSet objects.
-
-*  Type:
-*     Private function.
-
-*  Synopsis:
-*     void Delete( AstObject *obj, int *status )
-
-*  Description:
-*     This function implements the destructor for FrameSet 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: */
-   AstFrameSet *this;               /* Pointer to FrameSet */
-   int iframe;                      /* Loop counter for Frames */
-   int inode;                       /* Loop counter for nodes */
-
-/* Obtain a pointer to the FrameSet structure. */
-   this = (AstFrameSet *) obj;
-
-/* Annul all Frame pointers and clear the node numbers associated with
-   them. */
-   for ( iframe = 0; iframe < this->nframe; iframe++ ) {
-      this->frame[ iframe ] = astAnnul( this->frame[ iframe ] );
-      this->node[ iframe ] = 0;
-   }
-
-/* Annul all Mapping pointers and clear the links between pairs of
-   nodes and the associated Mapping Invert information. */
-   for ( inode = 0; inode < this->nnode - 1; inode++ ) {
-      this->map[ inode ] = astAnnul( this->map[ inode ] );
-      this->link[ inode ] = 0;
-      this->invert[ inode ] = 0;
-   }
-
-/* Free all allocated memory. */
-   this->frame = astFree( this->frame );
-   this->varfrm = astFree( this->varfrm );
-   this->node = astFree( this->node );
-   this->map = astFree( this->map );
-   this->link = astFree( this->link );
-   this->invert = astFree( this->invert );
-}
-
-/* Dump function. */
-/* -------------- */
-static void Dump( AstObject *this_object, AstChannel *channel, int *status ) {
-/*
-*  Name:
-*     Dump
-
-*  Purpose:
-*     Dump function for FrameSet 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 FrameSet class to an output Channel.
-
-*  Parameters:
-*     this
-*        Pointer to the FrameSet 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 Constants: */
-#define COMMENT_LEN 150          /* Maximum length of a comment string */
-#define KEY_LEN 50               /* Maximum length of a keyword */
-
-/* Local Variables: */
-   AstFrameSet *this;            /* Pointer to the FrameSet structure */
-   char comment[ COMMENT_LEN + 1 ]; /* Buffer for comment string */
-   char key[ KEY_LEN + 1 ];      /* Buffer for keyword string */
-   int ifr;                      /* Loop counter for Frames */
-   int inode;                    /* Loop counter for nodes */
-   int invert;                   /* Invert attribute value */
-   int ival;                     /* Integer value */
-   int set;                      /* Attribute value set? */
-
-/* Check the global error status. */
-   if ( !astOK ) return;
-
-/* Obtain a pointer to the FrameSet structure. */
-   this = (AstFrameSet *) this_object;
-
-/* Determine if the FrameSet is inverted. This is required so that the
-   effects of inversion can be un-done to obtain information about the
-   "true" Base and Current Frames. (The values written are "internal"
-   values that are not affected by the Invert setting.) */
-   invert = astGetInvert( this );
-
-/* Write out values representing the instance variables for the
-   FrameSet 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. */
-
-/* Nframe. */
-/* ------- */
-   set = ( this->nframe != 0 );
-   ival = set ? this->nframe : astGetNframe( this );
-   astWriteInt( channel, "Nframe", set, 1, ival,
-                "Number of Frames in FrameSet" );
-
-/* Base. */
-/* ----- */
-   set = ( this->base != -INT_MAX );
-   ival = set ? this->base : ( !invert ? astGetBase( this ) :
-                                         astGetCurrent( this ) );
-   astWriteInt( channel, "Base", set, 1, ival, "Index of base Frame" );
-
-/* Current. */
-/* -------- */
-   set = ( this->current != -INT_MAX );
-   ival = set ? this->current : ( !invert ? astGetCurrent( this ) :
-                                            astGetBase( this ) );
-   astWriteInt( channel, "Currnt", set, 1, ival, "Index of current Frame" );
-
-/* Number of nodes. */
-/* ---------------- */
-   ival = this->nnode;
-   set = ( ival != this->nframe );
-   astWriteInt( channel, "Nnode", set, 0, ival,
-                "Number of nodes in FrameSet" );
-
-/* Node index for each Frame. */
-/* -------------------------- */
-/* There is a node value for each Frame in the FrameSet. */
-   for ( ifr = 1; ifr <= this->nframe; ifr++ ) {
-
-/* Convert node numbering to start at 1 for the external
-   representation. Regard a node number as "set" if it differs from
-   the Frame number. */
-      ival = this->node[ ifr - 1 ] + 1;
-      set = ( ival != ifr );
-
-/* Create a suitable keyword and comment. */
-      (void) sprintf( key, "Nod%d", ifr );
-      (void) sprintf( comment,
-                      "Frame %d is associated with node %d", ifr, ival );
-
-/* Write out the value. */
-      astWriteInt( channel, key, set, 0, ival, comment );
-   }
-
-/* Index of variants Frame for each Frame. */
-/* --------------------------------------- */
-   for ( ifr = 1; ifr <= this->nframe; ifr++ ) {
-
-/* Retain the one-based Frame index values in varfrm. Regard a number as
-   "set" if it is greater than zero. */
-      ival = this->varfrm[ ifr - 1 ];
-      set = ( ival > 0 );
-
-/* Create a suitable keyword and comment. */
-      (void) sprintf( key, "VFr%d", ifr );
-      (void) sprintf( comment,
-                      "Frame %d inherits variants from Frame %d", ifr, ival );
-
-/* Write out the value. */
-      astWriteInt( channel, key, set, 0, ival, comment );
-   }
-
-/* Links between nodes. */
-/* -------------------- */
-/* Each node in the FrameSet (except the first) has a link to another
-   node from which it is derived. */
-   for ( inode = 1; inode < this->nnode; inode++ ) {
-
-/* Convert node numbering to start at 1 (as above). */
-      ival = this->link[ inode - 1 ] + 1;
-      (void) sprintf( key, "Lnk%d", inode + 1 );
-      (void) sprintf( comment,
-                      "Node %d is derived from node %d", inode + 1, ival );
-      astWriteInt( channel, key, 1, 0, ival, comment );
-
-/* Inversion flags. */
-/* ---------------- */
-/* Each node with a link has a value which the Invert attribute of the
-   associated Mapping should have when the transformation from the
-   parent node to the node in question is required. */
-      ival = this->invert[ inode - 1 ];
-
-/* Regard the value as set only if the Mapping's inverse
-   transformation is required. */
-      set = ( ival != 0 );
-      (void) sprintf( key, "Inv%d", inode + 1 );
-      astWriteInt( channel, key, set, 0, ival,
-                   ival ? "The inverse mapping is used" :
-                          "The forward mapping is used" );
-   }
-
-/* Frame objects. */
-/* -------------- */
-/* Output an Object description for each Frame in the FrameSet. */
-   for ( ifr = 1; ifr <= this->nframe; ifr++ ) {
-      (void) sprintf( key, "Frm%d", ifr );
-      (void) sprintf( comment, "Frame number %d", ifr );
-      astWriteObject( channel, key, 1, 1, this->frame[ ifr - 1 ],
-                      comment );
-   }
-
-/* Mapping objects. */
-/* ---------------- */
-/* Output an Object description for each Mapping in the FrameSet. */
-   for ( inode = 1; inode < this->nnode; inode++ ) {
-      (void) sprintf( key, "Map%d", inode + 1 );
-      (void) sprintf( comment, "Mapping between nodes %d and %d",
-                      this->link[ inode - 1 ] + 1, inode + 1 );
-      astWriteObject( channel, key, 1, 1, this->map[ inode - 1 ], comment );
-   }
-
-/* Undefine macros local to this function. */
-#undef COMMENT_LEN
-#undef KEY_LEN
-}
-
-/* Standard class functions. */
-/* ========================= */
-/* Implement the astIsAFrameSet and astCheckFrameSet functions using
-   the macros defined for this purpose in the "object.h" header
-   file. */
-astMAKE_ISA(FrameSet,Frame)
-astMAKE_CHECK(FrameSet)
-
-AstFrameSet *astFrameSet_( void *frame_void, const char *options, int *status, ...) {
-/*
-*+
-*  Name:
-*     astFrameSet
-
-*  Purpose:
-*     Create a FrameSet.
-
-*  Type:
-*     Protected function.
-
-*  Synopsis:
-*     #include "frameset.h"
-*     AstFrameSet *astFrameSet( AstFrame *frame, const char *options, int *status, ... )
-
-*  Class Membership:
-*     FrameSet constructor.
-
-*  Description:
-*     This function creates a new FrameSet and optionally initialises
-*     its attributes.
-
-*  Parameters:
-*     frame
-*        Pointer to the initial Frame. If this is not a FrameSet, the
-*        new FrameSet will be initialised to contain this Frame alone.
-*
-*        If it is a FrameSet, the new FrameSet will be initialised to
-*        contain the same Frames (and Mappings) and to have the same
-*        attribute values as the one supplied. This is similar to
-*        making a copy, except that the Frames (and Mappings)
-*        contained in the original FrameSet are not themselves copied,
-*        but are shared by both FrameSets.
-*     options
-*        Pointer to a null terminated string containing an optional
-*        comma-separated list of attribute assignments to be used for
-*        initialising the new FrameSet. 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 FrameSet.
-
-*  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 FrameSet constructor which
-*     is available via the protected interface to the FrameSet class.
-*     A public interface is provided by the astFrameSetId_ function.
-*     - Because this function has a variable argument list, it is
-*     invoked by a macro that evaluates to a function pointer (not a
-*     function invocation) and no checking or casting of arguments is
-*     performed before the function is invoked. Because of this, the
-*     "frame" parameter is of type (void *) and is converted and
-*     validated within the function itself.
-*/
-
-/* Local Variables: */
-   astDECLARE_GLOBALS            /* Pointer to thread-specific global data */
-   AstFrame *frame;              /* Pointer to Frame structure */
-   AstFrameSet *new;             /* Pointer to new FrameSet */
-   va_list args;                 /* Variable argument list */
-
-/* Initialise. */
-   new = NULL;
-
-/* Get a pointer to the thread specific global data structure. */
-   astGET_GLOBALS(NULL);
-
-/* Check the global status. */
-   if ( !astOK ) return new;
-
-/* Obtain and validate a pointer to the Frame structure provided. */
-   frame = astCheckFrame( frame_void );
-   if ( astOK ) {
-
-/* Initialise the FrameSet, allocating memory and initialising the
-   virtual function table as well if necessary. */
-      new = astInitFrameSet( NULL, sizeof( AstFrameSet ), !class_init,
-                             &class_vtab, "FrameSet", frame );
-
-/* 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
-   FrameSet'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 FrameSet. */
-   return new;
-}
-
-AstFrameSet *astInitFrameSet_( void *mem, size_t size, int init,
-                               AstFrameSetVtab *vtab, const char *name,
-                               AstFrame *frame, int *status ) {
-/*
-*+
-*  Name:
-*     astInitFrameSet
-
-*  Purpose:
-*     Initialise a FrameSet.
-
-*  Type:
-*     Protected function.
-
-*  Synopsis:
-*     #include "frameset.h"
-*     AstFrameSet *astInitFrameSet( void *mem, size_t size, int init,
-*                                   AstFrameSetVtab *vtab, const char *name,
-*                                   AstFrame *frame )
-
-*  Class Membership:
-*     FrameSet initialiser.
-
-*  Description:
-*     This function is provided for use by class implementations to
-*     initialise a new FrameSet object. It allocates memory (if
-*     necessary) to accommodate the FrameSet plus any additional data
-*     associated with the derived class.  It then initialises a
-*     FrameSet 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 FrameSet at the start of the memory passed
-*     via the "vtab" parameter.
-
-*  Parameters:
-*     mem
-*        A pointer to the memory in which the FrameSet is to be
-*        created. This must be of sufficient size to accommodate the
-*        FrameSet data (sizeof(FrameSet)) 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 FrameSet (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 FrameSet structure, so a valid value must be
-*        supplied even if not required for allocating memory.
-*     init
-*        A logical flag indicating if the FrameSet'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 FrameSet.
-*     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).
-*     frame
-*        Pointer to the initial Frame (or FrameSet).
-
-*  Returned Value:
-*     A pointer to the new FrameSet.
-
-*  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: */
-   AstFrameSet *new;                /* Pointer to new FrameSet */
-   AstFrameSet *old;                /* Pointer to original FrameSet */
-   int iframe;                      /* Loop counter for Frames */
-   int inode;                       /* Loop counter for nodes */
-
-/* Check the global status. */
-   if ( !astOK ) return NULL;
-
-/* If necessary, initialise the virtual function table. */
-   if ( init ) astInitFrameSetVtab( vtab, name );
-
-/* Initialise a Frame structure (the parent class) as the first
-   component within the FrameSet structure, allocating memory if
-   necessary. Give this Frame zero axes, as all axis information for
-   the FrameSet will be derived from the Frames it contains. */
-   new = (AstFrameSet *) astInitFrame( mem, size, 0,
-                                       (AstFrameVtab *) vtab, name, 0 );
-
-   if ( astOK ) {
-
-/* Initialise the FrameSet data. */
-/* ----------------------------- */
-
-/* Normal Frame supplied. */
-/* ---------------------- */
-/* Check that the Frame supplied is not a FrameSet (initialising using
-   a FrameSet is a special case which is handled below).  If not, we
-   initialise the new FrameSet to refer to a single Frame. */
-      if ( !astIsAFrameSet( frame ) && astOK ) {
-
-/* Allocate memory for the arrays of Frame information. */
-         new->frame = astMalloc( sizeof( AstFrame * ) );
-         new->node = astMalloc( sizeof( int ) );
-         new->varfrm = astMalloc( sizeof( int ) );
-
-/* The node arrays are not required until at least two Frames are
-   present. */
-         new->map = NULL;
-         new->link = NULL;
-         new->invert = NULL;
-
-/* If OK, initialise these arrays, thus adding the Frame to the
-   FrameSet. */
-         if ( astOK ) {
-            new->frame[ 0 ] = astClone( frame );
-            new->node[ 0 ] = 0;
-            new->varfrm[ 0 ] = 0;
-            new->nframe = 1;
-            new->nnode = 1;
-
-/* Initialise the FrameSet attributes to their undefined states. */
-            new->base = -INT_MAX;
-            new->current = -INT_MAX;
-         }
-
-/* FrameSet supplied. */
-/* ------------------ */
-/* If a FrameSet was supplied, we will initialise the new FrameSet to
-   refer to the same Frame and Mapping information (this is similar to
-   making a copy, except that we clone all the pointers, instead of
-   copying the Objects they refer to). */
-      } else if ( astOK ) {
-
-/* Obtain a pointer to the original FrameSet structure. */
-         old = (AstFrameSet *) frame;
-
-/* Allocate memory in the new FrameSet to store the Frame and node
-   information and copy any scalar information across. */
-         new->frame = astMalloc( sizeof( AstFrame * ) * (size_t) old->nframe );
-         new->node = astStore( NULL, old->node,
-                               sizeof( int ) * (size_t) old->nframe );
-         new->varfrm = astStore( NULL, old->varfrm,
-                               sizeof( int ) * (size_t) old->nframe );
-         new->map = astMalloc( sizeof( AstMapping * ) *
-                               (size_t) ( old->nnode - 1 ) );
-         new->link = astStore( NULL, old->link,
-                               sizeof( int ) * (size_t) ( old->nnode - 1 ) );
-         new->invert = astStore( NULL, old->invert,
-                                 sizeof( int ) * (size_t) ( old->nnode - 1 ) );
-
-/* If OK, clone the pointer to each Frame and Mapping referenced by
-   the original FrameSet and store the resulting pointers in the new
-   FrameSet. */
-         if ( astOK ) {
-            for ( iframe = 0; iframe < old->nframe; iframe++ ) {
-               new->frame[ iframe ] = astClone( old->frame[ iframe ] );
-            }
-            for ( inode = 0; inode < old->nnode - 1; inode++ ) {
-               new->map[ inode ] = astClone( old->map[ inode ] );
-            }
-
-/* If an error occurred while cloning any of these pointers, clean up
-   by looping through the arrays of cloned pointers again and
-   annulling them all. */
-            if ( !astOK ) {
-               for ( iframe = 0; iframe < old->nframe; iframe++ ) {
-                  new->frame[ iframe ] = astAnnul( new->frame[ iframe ] );
-               }
-               for ( inode = 0; inode < old->nnode - 1; inode++ ) {
-                  new->map[ inode ] = astAnnul( new->map[ inode ] );
-               }
-            }
-         }
-
-/* If an error occurred, clean up by freeing all memory allocated
-   above. */
-         if ( !astOK ) {
-            new->frame = astFree( new->frame );
-            new->node = astFree( new->node );
-            new->varfrm = astFree( new->varfrm );
-            new->map = astFree( new->map );
-            new->link = astFree( new->link );
-            new->invert = astFree( new->invert );
-         }
-
-/* Copy the Frame and node counts across. */
-         new->nframe = old->nframe;
-         new->nnode = old->nnode;
-
-/* Copy the other FrameSet attributes across. */
-         new->base = old->base;
-         new->current = old->current;
-
-/* Transfer any other inherited attribute values that relate to the
-   FrameSet itself (rather than the enclosed Frames). */
-        if ( astTestInvert( old ) ) astSetInvert( new, astGetInvert( old ) );
-      }
-
-/* 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;
-
-/* Undefine macros local to this function. */
-#undef TRANSFER
-}
-
-AstFrameSet *astLoadFrameSet_( void *mem, size_t size,
-                               AstFrameSetVtab *vtab, const char *name,
-                               AstChannel *channel, int *status ) {
-/*
-*+
-*  Name:
-*     astLoadFrameSet
-
-*  Purpose:
-*     Load a FrameSet.
-
-*  Type:
-*     Protected function.
-
-*  Synopsis:
-*     #include "frameset.h"
-*     AstFrameSet *astLoadFrameSet( void *mem, size_t size,
-*                                   AstFrameSetVtab *vtab, const char *name,
-*                                   AstChannel *channel )
-
-*  Class Membership:
-*     FrameSet loader.
-
-*  Description:
-*     This function is provided to load a new FrameSet 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
-*     FrameSet structure in this memory, using data read from the
-*     input Channel.
-
-*  Parameters:
-*     mem
-*        A pointer to the memory into which the FrameSet is to be
-*        loaded.  This must be of sufficient size to accommodate the
-*        FrameSet data (sizeof(FrameSet)) 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 FrameSet (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 FrameSet 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(AstFrameSet) is used instead.
-*     vtab
-*        Pointer to the start of the virtual function table to be
-*        associated with the new FrameSet. If this is NULL, a pointer
-*        to the (static) virtual function table for the FrameSet 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 "FrameSet" is used instead.
-
-*  Returned Value:
-*     A pointer to the new FrameSet.
-
-*  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 Constants: */
-   astDECLARE_GLOBALS            /* Pointer to thread-specific global data */
-#define KEY_LEN 50               /* Maximum length of a keyword */
-
-/* Local Variables: */
-   AstFrameSet *new;             /* Pointer to the new FrameSet */
-   char key[ KEY_LEN + 1 ];      /* Buffer for keyword string */
-   int ifr;                      /* Get a pointer to the thread specific global data structure. */
-
-/* Loop counter for Frames */
-   int inode;                    /* Loop counter for nodes */
-
-   astGET_GLOBALS(channel);
-
-/* Initialise. */
-   new = NULL;
-
-/* Check the global error status. */
-   if ( !astOK ) return new;
-
-/* If a NULL virtual function table has been supplied, then this is
-   the first loader to be invoked for this FrameSet. In this case the
-   FrameSet belongs to this class, so supply appropriate values to be
-   passed to the parent class loader (and its parent, etc.). */
-   if ( !vtab ) {
-      size = sizeof( AstFrameSet );
-      vtab = &class_vtab;
-      name = "FrameSet";
-
-/* If required, initialise the virtual function table for this class. */
-      if ( !class_init ) {
-         astInitFrameSetVtab( 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 FrameSet. */
-   new = astLoadFrame( mem, size, (AstFrameVtab *) vtab, name,
-                       channel );
-
-   if ( astOK ) {
-
-/* Read input data. */
-/* ================ */
-/* Request the input Channel to read all the input data appropriate to
-   this class into the internal "values list". */
-      astReadClassData( channel, "FrameSet" );
-
-/* 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. */
-
-/* Nframe. */
-/* ------- */
-      new->nframe = astReadInt( channel, "nframe", 1 );
-      if ( new->nframe < 0 ) new->nframe = 1;
-
-/* Number of nodes. */
-/* ---------------- */
-      new->nnode = astReadInt( channel, "nnode", new->nframe );
-      if ( new->nnode < 1 ) new->nnode = 1;
-
-/* Allocate memory to hold Frame and node information. */
-      new->frame = astMalloc( sizeof( AstFrame *) * (size_t) new->nframe );
-      new->node = astMalloc( sizeof( int ) * (size_t) new->nframe );
-      new->varfrm = astMalloc( sizeof( int ) * (size_t) new->nframe );
-      new->link = astMalloc( sizeof( int ) * (size_t) ( new->nnode - 1 ) );
-      new->invert = astMalloc( sizeof( int ) * (size_t) ( new->nnode - 1 ) );
-      new->map = astMalloc( sizeof( AstMapping * ) *
-                            (size_t) ( new->nnode - 1 ) );
-
-/* If an error occurs, ensure that all allocated memory is freed. */
-      if ( !astOK ) {
-         new->frame = astFree( new->frame );
-         new->node = astFree( new->node );
-         new->varfrm = astFree( new->varfrm );
-         new->link = astFree( new->link );
-         new->invert = astFree( new->invert );
-         new->map = astFree( new->map );
-
-/* Otherwise, initialise the arrays which will hold Object pointers. */
-      } else {
-         for ( ifr = 1; ifr <= new->nframe; ifr++ ) {
-            new->frame[ ifr - 1 ] = NULL;
-         }
-         for ( inode = 1; inode < new->nnode; inode++ ) {
-            new->map[ inode - 1 ] = NULL;
-         }
-
-/* Read Frame data... */
-         for ( ifr = 1; ifr <= new->nframe; ifr++ ) {
-
-/* Frame objects. */
-/* -------------- */
-/* Create the required keyword and then read the Frame. */
-            (void) sprintf( key, "frm%d", ifr );
-            new->frame[ ifr - 1 ] = astReadObject( channel, key, NULL );
-
-/* Node index for each Frame. */
-/* -------------------------- */
-            (void) sprintf( key, "nod%d", ifr );
-            new->node[ ifr - 1 ] = astReadInt( channel, key, ifr ) - 1;
-
-/* Index of variants Frame. */
-/* ------------------------ */
-            (void) sprintf( key, "vfr%d", ifr );
-            new->varfrm[ ifr - 1 ] = astReadInt( channel, key, 0 );
-         }
-
-/* Read node data... */
-         for ( inode = 1; inode < new->nnode; inode++ ) {
-
-/* Links between nodes. */
-/* -------------------- */
-            (void) sprintf( key, "lnk%d", inode + 1 );
-            new->link[ inode - 1 ] = astReadInt( channel, key, 0 ) - 1;
-
-/* Inversion flags. */
-/* ---------------- */
-            (void) sprintf( key, "inv%d", inode + 1 );
-            new->invert[ inode - 1 ] = astReadInt( channel, key, 0 );
-
-/* Mapping objects. */
-/* ---------------- */
-            (void) sprintf( key, "map%d", inode + 1 );
-            new->map[ inode - 1 ] = astReadObject( channel, key, NULL );
-         }
-
-/* Read remaining data... */
-
-/* Base. */
-/* ----- */
-         new->base = astReadInt( channel, "base", -INT_MAX );
-         if ( new->base < 1 ) new->base = -INT_MAX;
-
-/* Current. */
-/* -------- */
-         new->current = astReadInt( channel, "currnt", -INT_MAX );
-         if ( new->base < 1 ) new->base = -INT_MAX;
-      }
-
-/* If an error occurred, clean up by deleting the new FrameSet. */
-      if ( !astOK ) new = astDelete( new );
-   }
-
-/* Return the new FrameSet pointer. */
-   return new;
-
-/* Undefine macros local to this function. */
-#undef KEY_LEN
-}
-
-/* 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 astAddFrame_( AstFrameSet *this, int iframe, AstMapping *map,
-                   AstFrame *frame, int *status ) {
-   if ( !astOK ) return;
-   (**astMEMBER(this,FrameSet,AddFrame))( this, iframe, map, frame, status );
-}
-void astClearBase_( AstFrameSet *this, int *status ) {
-   if ( !astOK ) return;
-   (**astMEMBER(this,FrameSet,ClearBase))( this, status );
-}
-void astClearCurrent_( AstFrameSet *this, int *status ) {
-   if ( !astOK ) return;
-   (**astMEMBER(this,FrameSet,ClearCurrent))( this, status );
-}
-void astClearVariant_( AstFrameSet *this, int *status ) {
-   if ( !astOK ) return;
-   (**astMEMBER(this,FrameSet,ClearVariant))( this, status );
-}
-int astGetBase_( AstFrameSet *this, int *status ) {
-   if ( !astOK ) return 0;
-   return (**astMEMBER(this,FrameSet,GetBase))( this, status );
-}
-int astGetCurrent_( AstFrameSet *this, int *status ) {
-   if ( !astOK ) return 0;
-   return (**astMEMBER(this,FrameSet,GetCurrent))( this, status );
-}
-const char *astGetVariant_( AstFrameSet *this, int *status ) {
-   if ( !astOK ) return NULL;
-   return (**astMEMBER(this,FrameSet,GetVariant))( this, status );
-}
-AstFrame *astGetFrame_( AstFrameSet *this, int iframe, int *status ) {
-   if ( !astOK ) return NULL;
-   return (**astMEMBER(this,FrameSet,GetFrame))( this, iframe, status );
-}
-AstMapping *astGetMapping_( AstFrameSet *this, int iframe1, int iframe2, int *status ) {
-   if ( !astOK ) return NULL;
-   return (**astMEMBER(this,FrameSet,GetMapping))( this, iframe1, iframe2, status );
-}
-int astGetNframe_( AstFrameSet *this, int *status ) {
-   if ( !astOK ) return 0;
-   return (**astMEMBER(this,FrameSet,GetNframe))( this, status );
-}
-void astRemapFrame_( AstFrameSet *this, int iframe, AstMapping *map, int *status ) {
-   if ( !astOK ) return;
-   (**astMEMBER(this,FrameSet,RemapFrame))( this, iframe, map, status );
-}
-void astAddVariant_( AstFrameSet *this, AstMapping *map, const char *name, int *status ) {
-   if ( !astOK ) return;
-   (**astMEMBER(this,FrameSet,AddVariant))( this, map, name, status );
-}
-void astMirrorVariants_( AstFrameSet *this, int iframe, int *status ) {
-   if ( !astOK ) return;
-   (**astMEMBER(this,FrameSet,MirrorVariants))( this, iframe, status );
-}
-void astRemoveFrame_( AstFrameSet *this, int iframe, int *status ) {
-   if ( !astOK ) return;
-   (**astMEMBER(this,FrameSet,RemoveFrame))( this, iframe, status );
-}
-void astSetBase_( AstFrameSet *this, int ibase, int *status ) {
-   if ( !astOK ) return;
-   (**astMEMBER(this,FrameSet,SetBase))( this, ibase, status );
-}
-void astSetCurrent_( AstFrameSet *this, int icurrent, int *status ) {
-   if ( !astOK ) return;
-   (**astMEMBER(this,FrameSet,SetCurrent))( this, icurrent, status );
-}
-void astSetVariant_( AstFrameSet *this, const char *variant, int *status ) {
-   if ( !astOK ) return;
-   (**astMEMBER(this,FrameSet,SetVariant))( this, variant, status );
-}
-int astTestBase_( AstFrameSet *this, int *status ) {
-   if ( !astOK ) return 0;
-   return (**astMEMBER(this,FrameSet,TestBase))( this, status );
-}
-int astTestCurrent_( AstFrameSet *this, int *status ) {
-   if ( !astOK ) return 0;
-   return (**astMEMBER(this,FrameSet,TestCurrent))( this, status );
-}
-int astTestVariant_( AstFrameSet *this, int *status ) {
-   if ( !astOK ) return 0;
-   return (**astMEMBER(this,FrameSet,TestVariant))( this, status );
-}
-int astValidateFrameIndex_( AstFrameSet *this, int iframe,
-                            const char *method, int *status ) {
-   if ( !astOK ) return 0;
-   return (**astMEMBER(this,FrameSet,ValidateFrameIndex))( this, iframe,
-                                                           method, status );
-}
-const char *astGetAllVariants_( AstFrameSet *this, int *status ) {
-   if ( !astOK ) return NULL;
-   return (**astMEMBER(this,FrameSet,GetAllVariants))( this, status );
-}
-int astGetNode_( AstFrameSet *this, int inode, int *nnodes,
-                 int *iframe, AstMapping **map, int *parent,
-                 int *status ) {
-   if ( !astOK ) return 0;
-   return (**astMEMBER(this,FrameSet,GetNode))( this, inode, nnodes,
-                                                iframe, map, parent, 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. */
-AstFrameSet *astFrameSetId_( void *, const char *, ... );
-int astGetNodeId_( AstFrameSet *, int, int *, int *, AstMapping **, int *, int *);
-
-/* Special interface function implementations. */
-/* ------------------------------------------- */
-AstFrameSet *astFrameSetId_( void *frame_void, const char *options, ... ) {
-/*
-*++
-*  Name:
-c     astFrameSet
-f     AST_FRAMESET
-
-*  Purpose:
-*     Create a FrameSet.
-
-*  Type:
-*     Public function.
-
-*  Synopsis:
-c     #include "frameset.h"
-c     AstFrameSet *astFrameSet( AstFrame *frame, const char *options, ... )
-f     RESULT = AST_FRAMESET( FRAME, OPTIONS, STATUS )
-
-*  Class Membership:
-*     FrameSet constructor.
-
-*  Description:
-*     This function creates a new FrameSet and optionally initialises
-*     its attributes.
-*
-*     A FrameSet consists of a set of one or more Frames (which
-*     describe coordinate systems), connected together by Mappings
-*     (which describe how the coordinate systems are inter-related). A
-*     FrameSet makes it possible to obtain a Mapping between any pair
-*     of these Frames (i.e. to convert between any of the coordinate
-*     systems which it describes).  The individual Frames are
-*     identified within the FrameSet by an integer index, with Frames
-*     being numbered consecutively from one as they are added to the
-*     FrameSet.
-*
-*     Every FrameSet has a "base" Frame and a "current" Frame (which
-*     are allowed to be the same). Any of the Frames may be nominated
-*     to hold these positions, and the choice is determined by the
-*     values of the FrameSet's Base and Current attributes, which hold
-*     the indices of the relevant Frames.  By default, the first Frame
-*     added to a FrameSet is its base Frame, and the last one added is
-*     its current Frame.
-*
-*     The base Frame describes the "native" coordinate system of
-*     whatever the FrameSet is used to calibrate (e.g. the pixel
-*     coordinates of an image) and the current Frame describes the
-*     "apparent" coordinate system in which it should be viewed
-*     (e.g. displayed, etc.). Any further Frames represent a library
-*     of alternative coordinate systems, which may be selected by
-*     making them current.
-*
-*     When a FrameSet is used in a context that requires a Frame,
-*     (e.g. obtaining its Title value, or number of axes), the current
-*     Frame is used. A FrameSet may therefore be used in place of its
-*     current Frame in most situations.
-*
-*     When a FrameSet is used in a context that requires a Mapping,
-*     the Mapping used is the one between its base Frame and its
-*     current Frame. Thus, a FrameSet may be used to convert "native"
-*     coordinates into "apparent" ones, and vice versa. Like any
-c     Mapping, a FrameSet may also be inverted (see astInvert), which
-f     Mapping, a FrameSet may also be inverted (see AST_INVERT), which
-*     has the effect of interchanging its base and current Frames and
-*     hence of reversing the Mapping between them.
-*
-*     Regions may be added into a FrameSet (since a Region is a type of
-*     Frame), either explicitly or as components within CmpFrames. In this
-*     case the Mapping between a pair of Frames within a FrameSet will
-*     include the effects of the clipping produced by any Regions included
-*     in the path between the Frames.
-
-*  Parameters:
-c     frame
-f     FRAME = INTEGER (Given)
-*        Pointer to the first Frame to be inserted into the
-*        FrameSet. This initially becomes both the base and the
-*        current Frame. (Further Frames may be added using the
-c        astAddFrame function.)
-f        AST_ADDFRAME routine.)
-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 FrameSet. 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 FrameSet. 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     astFrameSet()
-f     AST_FRAMESET
-*        A pointer to the new FrameSet.
-
-*  Notes:
-c     - If a pointer to an existing FrameSet is given for the "frame"
-c     parameter, then the new FrameSet will (as a special case) be
-f     - If a pointer to an existing FrameSet is given for the FRAME
-f     argument, then the new FrameSet will (as a special case) be
-*     initialised to contain the same Frames and Mappings, and to have
-*     the same attribute values, as the one supplied. This process is
-c     similar to making a copy of a FrameSet (see astCopy), except
-f     similar to making a copy of a FrameSet (see AST_COPY), except
-*     that the Frames and Mappings contained in the original are not
-*     themselves copied, but are shared by both FrameSets.
-*     - 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 astFrameSet constructor function. It returns an ID value
-*     (instead of a true C pointer) to external users, and must be
-*     provided because astFrameSet_ has a variable argument list which
-*     cannot be encapsulated in a macro (where this conversion would
-*     otherwise occur).
-*     - Because no checking or casting of arguments is performed
-*     before the function is invoked, the "frame" parameter is of type
-*     (void *) and is converted from an ID value to a pointer and
-*     validated within the function itself.
-*     - The variable argument list also prevents this function from
-*     invoking astFrameSet_ directly, so it must be a
-*     re-implementation of it in all respects, except for the
-*     conversions between IDs and pointers on input/output of Objects.
-*/
-
-/* Local Variables: */
-   astDECLARE_GLOBALS            /* Pointer to thread-specific global data */
-   AstFrame *frame;              /* Pointer to Frame structure */
-   AstFrameSet *new;             /* Pointer to new FrameSet */
-   va_list args;                 /* Variable argument list */
-
-   int *status;
-
-/* Initialise. */
-   new = NULL;
-
-/* Get a pointer to the thread specific global data structure. */
-   astGET_GLOBALS(NULL);
-
-/* Pointer to inherited status value */
-
-/* Get a pointer to the inherited status value. */
-   status = astGetStatusPtr;
-
-/* Check the global status. */
-   if ( !astOK ) return new;
-
-/* Obtain the Frame pointer from the ID supplied and validate the
-   pointer to ensure it identifies a valid Frame. */
-   frame = astVerifyFrame( astMakePointer( frame_void ) );
-   if ( astOK ) {
-
-/* Initialise the FrameSet, allocating memory and initialising the
-   virtual function table as well if necessary. */
-      new = astInitFrameSet( NULL, sizeof( AstFrameSet ), !class_init,
-                             &class_vtab, "FrameSet", frame );
-
-/* 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
-   FrameSet'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 FrameSet. */
-   return astMakeId( new );
-}
-
-int astGetNodeId_( AstFrameSet *this, int inode, int *nnodes,
-                   int *iframe, AstMapping **map, int *parent,
-                   int *status ) {
-/*
-*+
-*  Name:
-*     astGetNode
-
-*  Purpose:
-*     Get information about a single node in a FrameSet tree.
-
-*  Type:
-*     Protected virtual function.
-
-*  Synopsis:
-*     #include "frameset.h"
-*     int astGetNode( AstFrameSet *this, int inode, int *nnodes,
-*                     int *iframe, AstMapping **map, int *parent )
-
-*  Class Membership:
-*     FrameSet method.
-
-*  Description:
-*     This function returns information about a specified node in a
-*     FrameSet. It is documented as protected, because it should not
-*     be used in general purpose software since it depends on the internal
-*     details of the FrameSet class.  However, it is in fact public so that
-*     it can be used in external software that needs to know about the
-*     internal structure of a FrameSet (for instance, a graphical FrameSet
-*     visualisation system).
-
-*  Parameters:
-*     this
-*        Pointer to the FrameSet.
-*     inode
-*        The zero-based index of the required node.
-*     nnodes
-*        Address of an int returned holding the number of nodes defined
-*        in the FrameSet.
-*     frame
-*        Address of a Frame pointer returned holding a pointer to a deep
-*        copy of the Frame, if any, associated with the node. NULL
-*        is returned if the node has no Frame.
-*     map
-*        Address of a Mapping pointer returned holding a pointer to a
-*        deep copy of the Mapping, if any, from the parent node to the
-*        requested node. NULL is returned if the node has no parent.
-*     parent
-*        Address of an int returned holding the zero-based index of the
-*        node from which the requested node is derived. -1 is returned if
-*        the requested node has no parent (i.e. is the root of the tree).
-
-*  Returned Value:
-*     A non-zero value is returned if the "inode" value is within bounds.
-*     Otherwise, zero is returned.
-
-*-
-*/
-
-/* Local Variables: */
-   int result;
-
-/* Initialise. */
-   result = 0;
-
-/* Check the global error status. */
-   if ( !astOK ) return result;
-
-/* Invoke the normal astGetNode_ function. */
-   result = astGetNode_( this, inode, nnodes, iframe, map, parent, status );
-
-/* Return an ID value for the Mapping. */
-   *map = astMakeId( *map );
-
-/* Return the result. */
-   return result;
-}
-
-