path: root/vendor/voclient/libvotable/votParse_f77.c

/**
 *  VOTPARSE_F77.C -- Public interface for the libVOTable F77 wrapper
 *
 *  @file       votParse_f77.c
 *  @author     Mike Fitzpatrick and Eric Timmermann
 *  @date       8/03/09
 *
 *  @brief      Public interface for the libVOTable F77 wrapper
 */

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <expat.h>
#include <unistd.h>
#include <ctype.h>
#include <errno.h>

#include "votParseP.h"
#include "votParse.h"



/*  Fortran Interface Definitions.
 *
 *  Fortran compilers on various platforms may append one or more trailing
 *  underscores to symbol names, we'll use macros for the interface names
 *  and use defines to see what the symbol name is.
 */
#ifdef  _NO_US_			/*  MACHDEP	*/

#define VF_OPENVOTABLE   	vf_openvotable
#define VF_CLOSEVOTABLE   	vf_closevotable
#define VF_GETRESOURCE   	vf_getresource
#define VF_GETTABLE   		vf_gettable
#define VF_GETFIELD   		vf_getfield
#define VF_GETDATA   		vf_getdata
#define VF_GETTABLEDATA   	vf_gettabledata
#define VF_GETTR   		vf_gettr
#define VF_GETTD   		vf_gettd
#define VF_GETBINARY   		vf_getbinary
#define VF_GETBINARY2  		vf_getbinary2
#define VF_GETFITS   		vf_getfits
#define VF_GETGROUP   		vf_getgroup
#define VF_GETFIELDREF   	vf_getfieldref
#define VF_GETPARAMREF   	vf_getparamref
#define VF_GETDESCRIPTION   	vf_getdescription
#define VF_GETPARAM   		vf_getparam
#define VF_GETINFO   		vf_getinfo
#define VF_GETSTREAM   		vf_getstream
#define VF_GETVALUES   		vf_getvalues
#define VF_GETMIN   		vf_getmin
#define VF_GETMAX   		vf_getmax
#define VF_GETOPTION   		vf_getoption
#define VF_GETLINK   		vf_getlink
#define VF_GETCOOSYS   		vf_getcoosys
#define VF_GETDATATYPE   	vf_getdatatype
#define VF_GETDATATYPESTR       vf_getdatatypestr

#define VF_NEWRESOURCE   	vf_newresource
#define VF_NEWTABLE   		vf_newtable
#define VF_NEWFIELD   		vf_newfield
#define VF_NEWDATA   		vf_newdata
#define VF_NEWTABLEDATA   	vf_newtabledata
#define VF_NEWTR   		vf_newtr
#define VF_NEWTD   		vf_newtd
#define VF_NEWBINARY   		vf_newbinary
#define VF_NEWBINARY2  		vf_newbinary2
#define VF_NEWFITS   		vf_newfits
#define VF_NEWGROUP   		vf_newgroup
#define VF_NEWFIELDREF   	vf_newfieldref
#define VF_NEWPARAMREF   	vf_newparamref
#define VF_NEWDESCRIPTION   	vf_newdescription
#define VF_NEWPARAM   		vf_newparam
#define VF_NEWINFO   		vf_newinfo
#define VF_NEWSTREAM   		vf_newstream
#define VF_NEWVALUES   		vf_newvalues
#define VF_NEWMIN   		vf_newmin
#define VF_NEWMAX   		vf_newmax
#define VF_NEWOPTION   		vf_newoption
#define VF_NEWLINK   		vf_newlink
#define VF_NEWCOOSYS   		vf_newcoosys

#define VF_NEWNODE   		vf_newnode
#define VF_FREENODE   		vf_freenode
#define VF_ATTACHNODE   	vf_attachnode
#define VF_DELETENODE   	vf_deletenode
#define VF_COPYELEMENT   	vf_copyelement
#define VF_GETNCOLS   		vf_getncols
#define VF_GETNROWS   		vf_getnrows
#define VF_GETTABLECELL   	vf_gettablecell
#define VF_GETTABLEINT   	vf_gettableint
#define VF_GETTABLEREAL   	vf_gettablereal
#define VF_GETLENGTH   		vf_getlength
#define VF_GETNUMBEROF   	vf_getnumberof
#define VF_FINDBYATTR   	vf_findbyattr
#define VF_FINDINGROUP   	vf_findingroup
#define VF_NEXTINGROUP   	vf_nextingroup
#define VF_GETNEXT   		vf_getnext
#define VF_GETSIBLING		vf_getsibling
#define VF_GETCHILD   		vf_getchild
#define VF_GETPARENT   		vf_getparent
#define VF_CHILDOFTYPE   	vf_childoftype
#define VF_VALUEOF   		vf_valueof
#define VF_TYPEOF   		vf_typeof
#define VF_SETVALUE   		vf_setvalue
#define VF_GETVALUE   		vf_getvalue
#define VF_GETINTVALUE   	vf_getintvalue
#define VF_GETREALVALUE   	vf_getrealvalue
#define VF_SETATTR   		vf_setattr
#define VF_GETATTR   		vf_getattr
#define VF_WRITEXML		vf_writexml
#define VF_WRITEHTML            vf_writehtml
#define VF_WRITESHTML           vf_writeshtml
#define VF_WRITEASV             vf_writeasv
#define VF_WRITEBSV             vf_writebsv
#define VF_WRITECSV             vf_writecsv
#define VF_WRITETSV             vf_writetsv
#define VF_SETWARN		vf_setwarn

#else

#define VF_OPENVOTABLE   	vf_openvotable_
#define VF_CLOSEVOTABLE   	vf_closevotable_

#define VF_GETRESOURCE   	vf_getresource_
#define VF_GETTABLE   		vf_gettable_
#define VF_GETFIELD   		vf_getfield_
#define VF_GETDATA   		vf_getdata_
#define VF_GETTABLEDATA   	vf_gettabledata_
#define VF_GETTR   		vf_gettr_
#define VF_GETTD   		vf_gettd_
#define VF_GETBINARY   		vf_getbinary_
#define VF_GETBINARY2   	vf_getbinary2_
#define VF_GETFITS   		vf_getfits_
#define VF_GETGROUP   		vf_getgroup_
#define VF_GETFIELDREF   	vf_getfieldref_
#define VF_GETPARAMREF   	vf_getparamref_
#define VF_GETDESCRIPTION   	vf_getdescription_
#define VF_GETPARAM   		vf_getparam_
#define VF_GETINFO   		vf_getinfo_
#define VF_GETSTREAM   		vf_getstream_
#define VF_GETVALUES   		vf_getvalues_
#define VF_GETMIN   		vf_getmin_
#define VF_GETMAX   		vf_getmax_
#define VF_GETOPTION   		vf_getoption_
#define VF_GETLINK   		vf_getlink_
#define VF_GETCOOSYS   		vf_getcoosys_
#define VF_GETDATATYPE   	vf_getdatatype_
#define VF_GETDATATYPESTR       vf_getdatatypestr_

#define VF_NEWRESOURCE   	vf_newresource_
#define VF_NEWTABLE   		vf_newtable_
#define VF_NEWFIELD   		vf_newfield_
#define VF_NEWDATA   		vf_newdata_
#define VF_NEWTABLEDATA   	vf_newtabledata_
#define VF_NEWTR   		vf_newtr_
#define VF_NEWTD   		vf_newtd_
#define VF_NEWBINARY   		vf_newbinary_
#define VF_NEWBINARY2  		vf_newbinary2_
#define VF_NEWFITS   		vf_newfits_
#define VF_NEWGROUP   		vf_newgroup_
#define VF_NEWFIELDREF   	vf_newfieldref_
#define VF_NEWPARAMREF   	vf_newparamref_
#define VF_NEWDESCRIPTION   	vf_newdescription_
#define VF_NEWPARAM   		vf_newparam_
#define VF_NEWINFO   		vf_newinfo_
#define VF_NEWSTREAM   		vf_newstream_
#define VF_NEWVALUES   		vf_newvalues_
#define VF_NEWMIN   		vf_newmin_
#define VF_NEWMAX   		vf_newmax_
#define VF_NEWOPTION   		vf_newoption_
#define VF_NEWLINK   		vf_newlink_
#define VF_NEWCOOSYS   		vf_newcoosys_

#define VF_NEWNODE   		vf_newnode_
#define VF_FREENODE   		vf_freenode_
#define VF_ATTACHNODE   	vf_attachnode_
#define VF_DELETENODE   	vf_deletenode_
#define VF_COPYELEMENT   	vf_copyelement_
#define VF_GETNCOLS   		vf_getncols_
#define VF_GETNROWS   		vf_getnrows_
#define VF_GETTABLECELL   	vf_gettablecell_
#define VF_GETTABLEINT   	vf_gettableint_
#define VF_GETTABLEREAL   	vf_gettablereal_
#define VF_GETLENGTH   		vf_getlength_
#define VF_GETNUMBEROF   	vf_getnumberof_
#define VF_FINDBYATTR   	vf_findbyattr_
#define VF_FINDINGROUP   	vf_findingroup_
#define VF_NEXTINGROUP   	vf_nextingroup_
#define VF_GETNEXT   		vf_getnext_
#define VF_GETSIBLING		vf_getsibling_
#define VF_GETCHILD   		vf_getchild_
#define VF_GETPARENT   		vf_getparent_
#define VF_CHILDOFTYPE   	vf_childoftype_
#define VF_VALUEOF   		vf_valueof_
#define VF_TYPEOF   		vf_typeof_
#define VF_SETVALUE   		vf_setvalue_
#define VF_GETVALUE   		vf_getvalue_
#define VF_GETINTVALUE   	vf_getintvalue_
#define VF_GETREALVALUE   	vf_getrealvalue_
#define VF_SETATTR   		vf_setattr_
#define VF_GETATTR   		vf_getattr_
#define VF_WRITEXML		vf_writexml_
#define VF_WRITEHTML            vf_writehtml_
#define VF_WRITESHTML           vf_writeshtml_
#define VF_WRITEASV             vf_writeasv_
#define VF_WRITEBSV             vf_writebsv_
#define VF_WRITECSV             vf_writecsv_
#define VF_WRITETSV             vf_writetsv_
#define VF_SETWARN		vf_setwarn_

#endif


/**
 *   Public function prototypes.
 */
handle_t  VF_OPENVOTABLE (char *arg, int alen);
void 	  VF_CLOSEVOTABLE (handle_t *vot);

handle_t  VF_GETRESOURCE (handle_t *handle);
handle_t  VF_GETTABLE (handle_t *handle);
handle_t  VF_GETFIELD (handle_t *handle);
handle_t  VF_GETDATA (handle_t *handle);
handle_t  VF_GETTABLEDATA (handle_t *handle);
handle_t  VF_GETTR (handle_t *handle);
handle_t  VF_GETTD (handle_t *handle);
handle_t  VF_GETBINARY (handle_t *handle);
handle_t  VF_GETBINARY2 (handle_t *handle);
handle_t  VF_GETFITS (handle_t *handle);
handle_t  VF_GETGROUP (handle_t *handle);
handle_t  VF_GETFIELDRef (handle_t *handle);
handle_t  VF_GETPARAMREF (handle_t *handle);
handle_t  VF_GETDESCRIPTION (handle_t *handle);
handle_t  VF_GETPARAM (handle_t *handle);
handle_t  VF_GETINFO (handle_t *handle);
handle_t  VF_GETSTREAM (handle_t *handle);
handle_t  VF_GETVALUES (handle_t *handle);
handle_t  VF_GETMIN (handle_t *handle);
handle_t  VF_GETMAX (handle_t *handle);
handle_t  VF_GETOPTION (handle_t *handle);
handle_t  VF_GETLINK (handle_t *handle);
handle_t  VF_GETCOOSYS (handle_t *handle);

handle_t  VF_NEWRESOURCE (handle_t *parent_h);
handle_t  VF_NEWTABLE (handle_t *parent_h);
handle_t  VF_NEWFIELD (handle_t *parent_h);
handle_t  VF_NEWDATA (handle_t *parent_h);
handle_t  VF_NEWTABLEDATA (handle_t *parent_h);
handle_t  VF_NEWTR (handle_t *parent_h);
handle_t  VF_NEWTD (handle_t *parent_h);
handle_t  VF_NEWBINARY (handle_t *parent_h);
handle_t  VF_NEWBINARY2 (handle_t *parent_h);
handle_t  VF_NEWFITS (handle_t *parent_h);
handle_t  VF_NEWGROUP (handle_t *parent_h);
handle_t  VF_NEWFIELDRef (handle_t *parent_h);
handle_t  VF_NEWPARAMREF (handle_t *parent_h);
handle_t  VF_NEWDESCRIPTION (handle_t *parent_h);
handle_t  VF_NEWPARAM (handle_t *parent_h);
handle_t  VF_NEWINFO (handle_t *parent_h);
handle_t  VF_NEWSTREAM (handle_t *parent_h);
handle_t  VF_NEWVALUES (handle_t *parent_h);
handle_t  VF_NEWMIN (handle_t *parent_h);
handle_t  VF_NEWMAX (handle_t *parent_h);
handle_t  VF_NEWOPTION (handle_t *parent_h);
handle_t  VF_NEWLINK (handle_t *parent_h);
handle_t  VF_NEWCOOSYS (handle_t *parent_h);

int 	  VF_GETDATAType (handle_t *data);
void 	  VF_GETDATATYPESTR (handle_t *data, char *type, int *len, int tlen);

handle_t  VF_NEWNODE (handle_t *parent, int *type);
void 	  VF_ATTACHNODE (handle_t *parent, handle_t *new);
void 	  VF_FREENODE (handle_t *elem);
void 	  VF_DELETENODE (handle_t *elem);
handle_t  VF_COPYELEMENT (handle_t *src, handle_t *parent);
;
int 	  VF_GETNCOLS (handle_t *tdata);
int 	  VF_GETNROWS (handle_t *tdata);
void 	  VF_GETTABLECELL (handle_t *tdata, int *row, int *col, char *value, 
		int *maxch);
int 	  VF_GETTABLEINT (handle_t *tdata, int *row, int *col);
float 	  VF_GETTABLEREAL (handle_t *tdata, int *row, int *col);
int 	  VF_GETLENGTH (handle_t *elem);
int 	  VF_GETNUMBEROF (handle_t *elem, int *type);
handle_t  VF_FINDBYATTR (handle_t *parent, char *name, char *value, int nlen, 
		int vlen);
handle_t  VF_FINDINGROUP (handle_t *group, int *type);
handle_t  VF_NEXTINGROUP (void);
handle_t  VF_GETNEXT (handle_t *elem);
handle_t  VF_GETSIBLING (handle_t *elem);
handle_t  VF_GETCHILD (handle_t *elem);
handle_t  VF_GETPARENT (handle_t *elem);
handle_t  VF_CHILDOFTYPE (handle_t *elem, int *type);
int 	  VF_VALUEOF (handle_t *elem);
int 	  VF_TYPEOF (handle_t *elem);
;
int 	  VF_SETVALUE (handle_t *elem, char *value, int vlen);
void 	  VF_GETVALUE (handle_t *elem, char *value, int *maxch, int vlen);
int 	  VF_GETINTVALUE (handle_t *elem);
float 	  VF_GETREALVALUE (handle_t *elem);
void 	  VF_GETATTR (handle_t *elem, char *name, char *val, int *len, 
		int nlen, int vlen);
int 	  VF_SETATTR (handle_t *elem, char *attr, char *value, int alen, 
		int vlen);
void 	  VF_WRITEXML (handle_t *elem, char *fname, int flen);
void 	  VF_WRITEHTML (handle_t *elem, char *ifname, char *ofname, 
		int iflen, int oflen);
void 	  VF_WRITESHTML (handle_t *elem, char *ifname, char *ofname, 
		int iflen, int oflen);
void 	  VF_WRITEASV (handle_t *elem, char *fname, int flen);
void 	  VF_WRITEBSV (handle_t *elem, char *fname, int flen);
void 	  VF_WRITECSV (handle_t *elem, char *fname, int flen);
void 	  VF_WRITETSV (handle_t *elem, char *fname, int flen);
void 	  VF_SETWARN (int *value);



/** 
 *  Local interface declarations.
 */
static char *sstrip (char *instr, int len);
static void  spad (char *outstr, int len);

static handle_t	handle     = 0;			/* global value		*/
static handle_t *s_group   = (handle_t *) NULL;



/*****************************************************************************
 *
 ****************************************************************************/


/** VF_OPENVOTABLE
 *
 *  @brief		This will create a tree holding the VOTable build from
 *  			an XML file parser or just a blank VOTable.
 *  @param[in] *arg 	the source of the table.
 *  @return	 	The root node of the VOTable.
 */
handle_t
VF_OPENVOTABLE (char *arg, int alen)
{
    char *_arg = sstrip (arg, alen);

    handle = vot_openVOTABLE (_arg);

    if (_arg) free ((char *) _arg);

    return (handle);
}


/** VF_CLOSEVOTABLE
 *
 *  @brief		Destroys the node and all of it's children.
 *  @param[in] vot 	A handle to the Element that you want deleted.
 *  @warning 		Destroys the node and all of it's children.
 */
void
VF_CLOSEVOTABLE (handle_t *vot)
{
    vot_closeVOTABLE (*vot);
}




/*****************************************************************************
 *  Routines to get nodes of a VOTable as a handle.
 ****************************************************************************/

/** VF_GETRESOURCE
 *
 *  @brief		Gets the node of a specified type.
 *  @param[in] handle 	A handle to the Element will you wish to search from.
 *  @return 		A handle to the found node. Zero otherwise.
 */
handle_t
VF_GETRESOURCE (handle_t *handle)
{
    return ( vot_getRESOURCE (*handle) );
}


/** VF_GETTABLE
 *
 *  @brief		Gets the node of a specified type.
 *  @param[in] handle 	A handle to the Element will you wish to search from.
 *  @return 		A handle to the found node. Zero otherwise.
 */
handle_t
VF_GETTABLE (handle_t *handle)
{
    return ( vot_getTABLE (*handle) );
}


/** VF_GETFIELD
 *
 *  @brief		Gets the node of a specified type.
 *  @param[in] handle 	A handle to the Element will you wish to search from.
 *  @return 		A handle to the found node. Zero otherwise.
 */
handle_t
VF_GETFIELD (handle_t *handle)
{
    return ( vot_getFIELD (*handle) );
}


/** VF_GETDATA
 *
 *  @brief		Gets the node of a specified type.
 *  @param[in] handle 	A handle to the Element will you wish to search from.
 *  @return 		A handle to the found node. Zero otherwise.
 */
handle_t
VF_GETDATA (handle_t *handle)
{
    return ( vot_getDATA (*handle) );
}


/** VF_GETTABLEDATA
 *
 *  @brief		Gets the node of a specified type.
 *  @param[in] handle 	A handle to the Element will you wish to search from.
 *  @return 		A handle to the found node. Zero otherwise.
 */
handle_t
VF_GETTABLEDATA (handle_t *handle)
{
    return ( vot_getTABLEDATA (*handle) );
}


/** VF_GETTR
 *
 *  @brief		Gets the node of a specified type.
 *  @param[in] handle 	A handle to the Element will you wish to search from.
 *  @return 		A handle to the found node. Zero otherwise.
 */
handle_t
VF_GETTR (handle_t *handle)
{
    return ( vot_getTR (*handle) );
}


/** VF_GETTD
 * 
 *  @brief		Gets the node of a specified type.
 *  @param[in] handle 	A handle to the Element will you wish to search from.
 *  @return 		A handle to the found node. Zero otherwise.
 */
handle_t
VF_GETTD (handle_t *handle)
{
    return ( vot_getTD (*handle) );
}


/** VF_GETBINARY
 * 
 *  @brief		Gets the node of a specified type.
 *  @param[in] handle 	A handle to the Element will you wish to search from.
 *  @return 		A handle to the found node. Zero otherwise.
 */
handle_t
VF_GETBINARY (handle_t *handle)
{
    return ( vot_getBINARY (*handle) );
}


/** VF_GETBINARY2
 * 
 *  @brief		Gets the node of a specified type.
 *  @param[in] handle 	A handle to the Element will you wish to search from.
 *  @return 		A handle to the found node. Zero otherwise.
 */
handle_t
VF_GETBINARY2 (handle_t *handle)
{
    return ( vot_getBINARY2 (*handle) );
}


/** VF_GETFITS
 *
 *  @brief		Gets the node of a specified type.
 *  @param[in] handle 	A handle to the Element will you wish to search from.
 *  @return 		A handle to the found node. Zero otherwise.
 */
handle_t
VF_GETFITS (handle_t *handle)
{
    return ( vot_getFITS (*handle) );
}


/** VF_GETGROUP
 *
 *  @brief		Gets the node of a specified type.
 *  @param[in] handle 	A handle to the Element will you wish to search from.
 *  @return 		A handle to the found node. Zero otherwise.
 */
handle_t
VF_GETGROUP (handle_t *handle)
{
    return ( vot_getGROUP (*handle) );
}


/** VF_GETFIELDRef
 *
 *  @brief		Gets the node of a specified type.
 *  @param[in] handle 	A handle to the Element will you wish to search from.
 *  @return 		A handle to the found node. Zero otherwise.
 */
handle_t
VF_GETFIELDRef (handle_t *handle)
{
    return ( vot_getFIELDRef (*handle) );
}


/** VF_GETPARAMREF
 *
 *  @brief		Gets the node of a specified type.
 *  @param[in] handle 	A handle to the Element will you wish to search from.
 *  @return 		A handle to the found node. Zero otherwise.
 */
handle_t
VF_GETPARAMREF (handle_t *handle)
{
    return ( vot_getPARAMRef (*handle) );
}


/** VF_GETDESCRIPTION
 *
 *  @brief		Gets the node of a specified type.
 *  @param[in] handle 	A handle to the Element will you wish to search from.
 *  @return 		A handle to the found node. Zero otherwise.
 */
handle_t
VF_GETDESCRIPTION (handle_t *handle)
{
    return ( vot_getDESCRIPTION (*handle) );
}


/** VF_GETPARAM
 *
 *  @brief		Gets the node of a specified type.
 *  @param[in] handle 	A handle to the Element will you wish to search from.
 *  @return 		A handle to the found node. Zero otherwise.
 */
handle_t
VF_GETPARAM (handle_t *handle)
{
    return ( vot_getPARAM (*handle) );
}


/** VF_GETINFO
 *
 *  @brief		Gets the node of a specified type.
 *  @param[in] handle 	A handle to the Element will you wish to search from.
 *  @return 		A handle to the found node. Zero otherwise.
 */
handle_t
VF_GETINFO (handle_t *handle)
{
    return ( vot_getINFO (*handle) );
}


/** VF_GETSTREAM
 *
 *  @brief		Gets the node of a specified type.
 *  @param[in] handle 	A handle to the Element will you wish to search from.
 *  @return 		A handle to the found node. Zero otherwise.
 */
handle_t
VF_GETSTREAM (handle_t *handle)
{
    return ( vot_getSTREAM (*handle) );
}


/** VF_GETVALUES
 *
 *  @brief		Gets the node of a specified type.
 *  @param[in] handle 	A handle to the Element will you wish to search from.
 *  @return 		A handle to the found node. Zero otherwise.
 */
handle_t
VF_GETVALUES (handle_t *handle)
{
    return ( vot_getVALUES (*handle) );
}


/** VF_GETMIN
 *
 *  @brief		Gets the node of a specified type.
 *  @param[in] handle 	A handle to the Element will you wish to search from.
 *  @return 		A handle to the found node. Zero otherwise.
 */
handle_t
VF_GETMIN (handle_t *handle)
{
    return ( vot_getMIN (*handle) );
}


/** VF_GETMAX
 *
 *  @brief		Gets the node of a specified type.
 *  @param[in] handle 	A handle to the Element will you wish to search from.
 *  @return 		A handle to the found node. Zero otherwise.
 */
handle_t
VF_GETMAX (handle_t *handle)
{
    return ( vot_getMAX (*handle) );
}


/** VF_GETOPTION
 *
 *  @brief		Gets the node of a specified type.
 *  @param[in] handle 	A handle to the Element will you wish to search from.
 *  @return 		A handle to the found node. Zero otherwise.
 */
handle_t
VF_GETOPTION (handle_t *handle)
{
    return ( vot_getOPTION (*handle) );
}


/** VF_GETLINK
 * 
 *  @brief		Gets the node of a specified type.
 *  @param[in] handle 	A handle to the Element will you wish to search from.
 *  @return 		A handle to the found node. Zero otherwise.
 */
handle_t
VF_GETLINK (handle_t *handle)
{
    return ( vot_getLINK (*handle) );
}


/** VF_GETCOOSYS
 * 
 *  @brief		Gets the node of a specified type.
 *  @param[in] handle 	A handle to the Element will you wish to search from.
 *  @return 		A handle to the found node. Zero otherwise.
 */
handle_t
VF_GETCOOSYS (handle_t *handle)
{
    return ( vot_getCOOSYS (*handle) );
}



/*************************************************************************/

/** VF_GETDATAType
 * 
 *  @brief	Returns the type of the DATA element.
 *  @param[in] data 	A handle to a DATA element
 *  @return	The type as an int.
 */
int
VF_GETDATAType (handle_t *data)
{
    return ( vot_getDATAType (*data) );
}


/** VF_GETDATATypeString
 * 
 *  @brief	Returns the type of the DATA element.
 *  @param[in] data 	A handle to a DATA element
 *  @return	The type as an string.
 */
void
VF_GETDATATYPESTR (handle_t *data, char *type, int *len, int tlen)
{
    char *_val = vot_getDATATypeString (*data);

    memset (type, 0, *len);
    spad ( strncpy (type, _val, *len), *len );
}




/*****************************************************************************
 *  Routines to create new nodes of a VOTable.
 ****************************************************************************/

/** VF_NEWRESOURCE
 *
 *  @brief		   Create the node of a specified type.
 *  @param[in] parent_h    A handle to the parent node. from.
 *  @return 		   A handle to the new node. Zero otherwise.
 */
handle_t
VF_NEWRESOURCE (handle_t *parent_h)
{
    return ( vot_newRESOURCE (*parent_h) );
}


/** VF_NEWTABLE
 *
 *  @brief		   Create the node of a specified type.
 *  @param[in] parent_h    A handle to the parent node. from.
 *  @return 		   A handle to the new node. Zero otherwise.
 */
handle_t
VF_NEWTABLE (handle_t *parent_h)
{
    return ( vot_newTABLE (*parent_h) );
}


/** VF_NEWFIELD
 *
 *  @brief		   Create the node of a specified type.
 *  @param[in] parent_h    A handle to the parent node. from.
 *  @return 		   A handle to the new node. Zero otherwise.
 */
handle_t
VF_NEWFIELD (handle_t *parent_h)
{
    return ( vot_newFIELD (*parent_h) );
}


/** VF_NEWDATA
 *
 *  @brief		   Create the node of a specified type.
 *  @param[in] parent_h    A handle to the parent node. from.
 *  @return 		   A handle to the new node. Zero otherwise.
 */
handle_t
VF_NEWDATA (handle_t *parent_h)
{
    return ( vot_newDATA (*parent_h) );
}


/** VF_NEWTABLEDATA
 *
 *  @brief		   Create the node of a specified type.
 *  @param[in] parent_h    A handle to the parent node. from.
 *  @return 		   A handle to the new node. Zero otherwise.
 */
handle_t
VF_NEWTABLEDATA (handle_t *parent_h)
{
    return ( vot_newTABLEDATA (*parent_h) );
}


/** VF_NEWTR
 *
 *  @brief		   Create the node of a specified type.
 *  @param[in] parent_h    A handle to the parent node. from.
 *  @return 		   A handle to the new node. Zero otherwise.
 */
handle_t
VF_NEWTR (handle_t *parent_h)
{
    return ( vot_newTR (*parent_h) );
}


/** VF_NEWTD
 * 
 *  @brief		   Create the node of a specified type.
 *  @param[in] parent_h    A handle to the parent node. from.
 *  @return 		   A handle to the new node. Zero otherwise.
 */
handle_t
VF_NEWTD (handle_t *parent_h)
{
    return ( vot_newTD (*parent_h) );
}


/** VF_NEWBINARY
 * 
 *  @brief		   Create the node of a specified type.
 *  @param[in] parent_h    A handle to the parent node. from.
 *  @return 		   A handle to the new node. Zero otherwise.
 */
handle_t
VF_NEWBINARY (handle_t *parent_h)
{
    return ( vot_newBINARY (*parent_h) );
}


/** VF_NEWBINARY2
 * 
 *  @brief		   Create the node of a specified type.
 *  @param[in] parent_h    A handle to the parent node. from.
 *  @return 		   A handle to the new node. Zero otherwise.
 */
handle_t
VF_NEWBINARY2 (handle_t *parent_h)
{
    return ( vot_newBINARY2 (*parent_h) );
}


/** VF_NEWFITS
 *
 *  @brief		   Create the node of a specified type.
 *  @param[in] parent_h    A handle to the parent node. from.
 *  @return 		   A handle to the new node. Zero otherwise.
 */
handle_t
VF_NEWFITS (handle_t *parent_h)
{
    return ( vot_newFITS (*parent_h) );
}


/** VF_NEWGROUP
 *
 *  @brief		   Create the node of a specified type.
 *  @param[in] parent_h    A handle to the parent node. from.
 *  @return 		   A handle to the new node. Zero otherwise.
 */
handle_t
VF_NEWGROUP (handle_t *parent_h)
{
    return ( vot_newGROUP (*parent_h) );
}


/** VF_NEWFIELDRef
 *
 *  @brief		   Create the node of a specified type.
 *  @param[in] parent_h    A handle to the parent node. from.
 *  @return 		   A handle to the new node. Zero otherwise.
 */
handle_t
VF_NEWFIELDRef (handle_t *parent_h)
{
    return ( vot_newFIELDRef (*parent_h) );
}


/** VF_NEWPARAMREF
 *
 *  @brief		   Create the node of a specified type.
 *  @param[in] parent_h    A handle to the parent node. from.
 *  @return 		   A handle to the new node. Zero otherwise.
 */
handle_t
VF_NEWPARAMREF (handle_t *parent_h)
{
    return ( vot_newPARAMRef (*parent_h) );
}


/** VF_NEWDESCRIPTION
 *
 *  @brief		   Create the node of a specified type.
 *  @param[in] parent_h    A handle to the parent node. from.
 *  @return 		   A handle to the new node. Zero otherwise.
 */
handle_t
VF_NEWDESCRIPTION (handle_t *parent_h)
{
    return ( vot_newDESCRIPTION (*parent_h) );
}


/** VF_NEWPARAM
 *
 *  @brief		   Create the node of a specified type.
 *  @param[in] parent_h    A handle to the parent node. from.
 *  @return 		   A handle to the new node. Zero otherwise.
 */
handle_t
VF_NEWPARAM (handle_t *parent_h)
{
    return ( vot_newPARAM (*parent_h) );
}


/** VF_NEWINFO
 *
 *  @brief		   Create the node of a specified type.
 *  @param[in] parent_h    A handle to the parent node. from.
 *  @return 		   A handle to the new node. Zero otherwise.
 */
handle_t
VF_NEWINFO (handle_t *parent_h)
{
    return ( vot_newINFO (*parent_h) );
}


/** VF_NEWSTREAM
 *
 *  @brief		   Create the node of a specified type.
 *  @param[in] parent_h    A handle to the parent node. from.
 *  @return 		   A handle to the new node. Zero otherwise.
 */
handle_t
VF_NEWSTREAM (handle_t *parent_h)
{
    return ( vot_newSTREAM (*parent_h) );
}


/** VF_NEWVALUES
 *
 *  @brief		   Create the node of a specified type.
 *  @param[in] parent_h    A handle to the parent node. from.
 *  @return 		   A handle to the new node. Zero otherwise.
 */
handle_t
VF_NEWVALUES (handle_t *parent_h)
{
    return ( vot_newVALUES (*parent_h) );
}


/** VF_NEWMIN
 *
 *  @brief		   Create the node of a specified type.
 *  @param[in] parent_h    A handle to the parent node. from.
 *  @return 		   A handle to the new node. Zero otherwise.
 */
handle_t
VF_NEWMIN (handle_t *parent_h)
{
    return ( vot_newMIN (*parent_h) );
}


/** VF_NEWMAX
 *
 *  @brief		   Create the node of a specified type.
 *  @param[in] parent_h    A handle to the parent node. from.
 *  @return 		   A handle to the new node. Zero otherwise.
 */
handle_t
VF_NEWMAX (handle_t *parent_h)
{
    return ( vot_newMAX (*parent_h) );
}


/** VF_NEWOPTION
 *
 *  @brief		   Create the node of a specified type.
 *  @param[in] parent_h    A handle to the parent node. from.
 *  @return 		   A handle to the new node. Zero otherwise.
 */
handle_t
VF_NEWOPTION (handle_t *parent_h)
{
    return ( vot_newOPTION (*parent_h) );
}


/** VF_NEWLINK
 * 
 *  @brief		   Create the node of a specified type.
 *  @param[in] parent_h    A handle to the parent node. from.
 *  @return 		   A handle to the new node. Zero otherwise.
 */
handle_t
VF_NEWLINK (handle_t *parent_h)
{
    return ( vot_newLINK (*parent_h) );
}


/** VF_NEWCOOSYS
 * 
 *  @brief		   Create the node of a specified type.
 *  @param[in] parent_h    A handle to the parent node. from.
 *  @return 		   A handle to the new node. Zero otherwise.
 */
handle_t
VF_NEWCOOSYS (handle_t *parent_h)
{
    return ( vot_newCOOSYS (*parent_h) );
}



/*****************************************************************************
 ****************************************************************************/


/** VF_NEWNODE
 * 
 *  @brief		Creates a new blank unlinked node.
 *  @param[in] parent 	A handle to the Element that you want to add a node to.
 *  @param[in] type 	The type of node you wish to create.
 *  @return 		A handle to the created node.
 */
handle_t
VF_NEWNODE (handle_t *parent, int *type)
{
    return ( vot_newNode (*parent, *type) );
}


/** VF_ATTACHNODE
 *
 *  @brief		Adds a node as a child of parent.
 *  @param[in] parent 	A handle to the Element that you want to add a node to.
 *  @param[in] new 	A handle to the Element that you want to add.
 */
void
VF_ATTACHNODE (handle_t *parent, handle_t *new)
{
    vot_attachNode (*parent, *new);
}


/** VF_FREENODE
 *
 *  @brief		Destroys the node and all of it's children.
 *  @param[in] elem 	A handle to the Element that you want deleted.
 *  @warning 		Destroys the node and all of it's children.
 */
void
VF_FREENODE (handle_t *elem)
{
    vot_freeNode (*elem);
}


/** VF_DELETENODE
 *
 *  @brief		Destroys the node and all of it's children.
 *  @param[in] elem 	A handle to the Element that you want deleted.
 *  @warning 		Destroys the node and all of it's children.
 */
void
VF_DELETENODE (handle_t *elem)
{
    vot_deleteNode (*elem);
}


/** VF_COPYELEMENT
 *
 *  @brief		Adds a node as a child of parent.
 *  @param[in] src 	A handle to the Element to copy.
 *  @param[in] parent 	A handle to the Elements parent.
 *  @return 		A handle of the copy of the structure.
 */
handle_t
VF_COPYELEMENT (handle_t *src, handle_t *parent)
{
    return ( vot_copyElement (*src, *parent) );
}


/*****************************************************************************
 *  Utility methods
 ****************************************************************************/


/** VF_GETNCOLS
 * 
 *  @brief		Return the nuber of columns in the structure.
 *  @param[in]  tdata 	A handle to a TABLEDATA
 *  @return		The number of cols.
 */
int
VF_GETNCOLS (handle_t *tdata)
{
    return ( vot_getNCols (*tdata) );
}


/** VF_GETNROWS
 * 
 *  @brief		Return the nuber of columns in the structure.
 *  @param[in]  tdata 	A handle to a TABLEDATA
 *  @return		The number of cols.
 */
int
VF_GETNROWS (handle_t *tdata)
{
    return ( vot_getNRows (*tdata) );
}


/** VF_GETTABLECELL
 * 
 *  @brief		Return the nuber of contents of a table cell 
 *  @param[in]  tdata 	A handle to a TABLEDATA.
 *  @param[in]  row 	An int for a row.
 *  @param[in]  col 	An int for a col.
 *  @return		The content of the cell.
 */
void
VF_GETTABLECELL (handle_t *tdata, int *row, int *col, char *value, int *maxch)
{
    char *_val = vot_getTableCell (*tdata, (*row - 1), (*col - 1));

    memset (value, 0, *maxch);
    spad ( strncpy (value, _val, *maxch), *maxch);
}


/** VF_GETTABLEINT
 * 
 *  @brief		Return the nuber of contents of a table cell as an int
 *  @param[in]  tdata 	A handle to a TABLEDATA.
 *  @param[in]  row 	An int for a row.
 *  @param[in]  col 	An int for a col.
 *  @return		The content of the cell as an int.
 */
int
VF_GETTABLEINT (handle_t *tdata, int *row, int *col)
{
    return ( atoi (vot_getTableCell (*tdata, (*row - 1), (*col - 1))) );
}


/** VF_GETTABLEREAL
 * 
 *  @brief		Return the nuber of contents of a table cell as an real
 *  @param[in]  tdata 	A handle to a TABLEDATA.
 *  @param[in]  row 	An int for a row.
 *  @param[in]  col 	An int for a col.
 *  @return		The content of the cell as a real.
 */
float
VF_GETTABLEREAL (handle_t *tdata, int *row, int *col)
{
    return ( atof (vot_getTableCell (*tdata, (*row - 1), (*col - 1))) );
}


/** VF_GETLENGTH
 * 
 *  @brief		Return the number of sibling Elements of the same type.
 *  @param[in]  elem 	A handle the Element.
 *  @return		The status of the set.
 */
int
VF_GETLENGTH (handle_t *elem)
{
    return ( vot_getLength (*elem) );
}


/** VF_GETNUMBEROF
 *
 *  @brief		Return the number of sibling Elements of the type.
 *  @param[in]  elem 	A handle the Element.
 *  @param[in]  type 	An int of the type of element you wish to count.
 *  @return		The status of the set.
 */
int
VF_GETNUMBEROF (handle_t *elem, int *type)
{
    return ( vot_getNumberOf (*elem, *type) );
}


/** VF_FINDBYATTR.
 * 
 *  @brief		Return a handle to an Element with the requested attr.
 *  @param[in]  parent 	A handle the parent Element.
 *  @param[in]  name 	A string holding the Value type.
 *  @param[in]  value 	A string holding the Value value.
 *  @return		The handle to the element.
 */
handle_t
VF_FINDBYATTR (handle_t *parent, char *name, char *value, int nlen, int vlen)
{

    return ( vot_findByAttr (*parent, name, value) );
}


/** VF_FINDINGROUP.
 * 
 *  @brief		Return an array of handle_ts of the requested type.
 *  @param[in]  group 	A handle the parent Element.
 *  @param[in]  type 	Value of the type.
 *  @return		An array of handles.
 */
handle_t
VF_FINDINGROUP (handle_t *group, int *type)
{
    s_group = vot_findInGroup (*group, *type);
    return ( (handle_t) *s_group );
}


/** VF_NEXTINGROUP.
 * 
 *  @brief		Return an array of handle_ts of the requested type.
 *  @param[in]  group 	A handle the parent Element.
 *  @param[in]  type 	Value of the type.
 *  @return		An array of handles.
 */
handle_t
VF_NEXTINGROUP (void)
{
    s_group++;
    return ( (handle_t) *s_group );
}


/** VF_GETNEXT
 *  
 *  @brief		Return a handle of the next Element of the same type.
 *  @param[in]  elem 	A handle the Element.
 *  @return		A handle of the next Element of the same type.
 */
handle_t
VF_GETNEXT (handle_t *elem)
{
    return ( vot_getNext (*elem) );
}


/** VF_GETSIBLING.
 * 
 *  @brief		Return a handle of the next Element.
 *  @param[in]  elem 	A handle the Element.
 *  @return		A handle of the next Element.
 */
handle_t
VF_GETSIBLING (handle_t *elem)
{
    return ( vot_getSibling (*elem) );
}


/** VF_GETCHILD
 *
 *  @brief		Return a handle of the child Element.
 *  @param[in]  elem 	A handle the Element.
 *  @return		A handle of the child Element.
 */
handle_t
VF_GETCHILD (handle_t *elem)
{
    return ( vot_getChild (*elem) );
}


/** VF_GETPARENT
 *
 *  @brief		Return a handle of the parent Element.
 *  @param[in]  elem 	A handle the Element.
 *  @return		A handle of the paretn Element.
 */
handle_t
VF_GETPARENT (handle_t *elem)
{
    return ( vot_getParent (*elem) );
}


/** VF_GETCHILDOfTYPE
 *  @brief		Return a handle of the next Element of the same type.
 *  @param[in]  elem 	A handle the Element.
 *  @param[in]  type 	An integer of the Element type for find.
 *  @return		A handle of the Element.
 */
handle_t
VF_CHILDOFTYPE (handle_t *elem, int *type)
{
    return ( vot_getChildOfType (*elem, *type) );
}


/** VF_VALUEOF
 *
 *  @brief 		Return type of the Element.
 *  @param[in]  elem 	A handle the Element.
 *  @return		An integer of the type.
 */
int
VF_VALUEOF (handle_t *elem)
{
    return ( vot_valueOf (*elem) );
}


/** VF_TYPEOF
 *
 *  @brief 		Return type of the Element.
 *  @param[in]  elem 	A handle the Element.
 *  @return		An integer of the type.
 */
int
VF_TYPEOF (handle_t *elem)
{
    return ( vot_typeOf (*elem) );
}


/** VF_SETWARN
 * 
 *  @brief		Set the warning level
 *  @param[in]  value 	Warning level
 *  @return		Nothing
 */
void
VF_SETWARN (int *value)
{
    vot_setWarnings (*value);
}



/****************************************************************************
 *
 ***************************************************************************/

/** VF_SETVALUE
 *
 *  @brief		Return the Value for the ELEMENT.
 *  @param[in]  elem 	A handle the ELEMENT.
 *  @param[in]  value 	A string holding the Value value.
 *  @return 		The status of the set.
 */
int
VF_SETVALUE (handle_t *elem, char *value, int vlen)
{
    int  retval = -1;

    char *_value = sstrip (value, vlen);

    retval = vot_setValue (*elem, _value);

    if (_value) free ((char *) _value);

    return (retval);
}


/** VF_GETVALUE
 *
 *  @brief		Return the Value for the ELEMENT.
 *  @param[in]  elem 	A handle the ELEMENT.
 *  @return 		A string of the value or the Value.
 */
void
VF_GETVALUE (handle_t *elem, char *value, int *maxch, int vlen)
{
    char *_val = vot_getValue (*elem);

    memset (value, 0, *maxch);
    spad ( strncpy (value, _val, *maxch), *maxch);
}


/** VF_GETINTVALUE
 *
 *  @brief		Return the Value for the ELEMENT as an int.
 *  @param[in]  elem 	A handle the ELEMENT.
 *  @return 		An int value
 */
int
VF_GETINTVALUE (handle_t *elem)
{
    return ( atoi (vot_getValue (*elem)) );
}


/** VF_GETREALVALUE
 *
 *  @brief		Return the Value for the ELEMENT.
 *  @param[in]  elem 	A handle the ELEMENT.
 *  @return 		A real value
 */
float
VF_GETREALVALUE (handle_t *elem)
{
    return ( atof (vot_getValue (*elem)) );
}


/** VF_GETATTR
 * 
 *  @brief		Return the attribute for the Element.
 *  @param[in]  elem 	A handle the Element.
 *  @param[in]  attr 	A string holding the attribute name.
 *  @return		A string of the value or the attr.
 */
void
VF_GETATTR (handle_t *elem, char *name, char *val, int *len, int nlen, int vlen)
{
    char *_name  = sstrip (name, nlen);
    char *res  = vot_getAttr (*elem, _name);

    memset (val, 0, *len);

    if (res) {
        int rlen = strlen (res); 		/*  found a value */
        strncpy (val, res, rlen);
        spad (val, vlen);
    }

    free ((char *) _name);
}


/** VF_SETATTR
 * 
 *  @brief		Return the attribute for the Element.
 *  @param[in]  elem 	A handle the Element.
 *  @param[in]  attr 	A string holding the attribute name.
 *  @param[in]  value 	A string holding the attribute value.
 *  @return		The status of the set.
 */
int
VF_SETATTR (handle_t *elem, char *attr, char *value, int alen, int vlen)
{
    int  retval = -1;

    char *_attr  = sstrip (attr, alen);
    char *_value = sstrip (value, vlen);

    retval = vot_setAttr (*elem, _attr, _value);

    if (_attr)  free ((char *) _attr);
    if (_value) free ((char *) _value);

    return (retval);
}


/** VF_WRITEXML
 * 
 *  @brief		Dump the XML to the named file (or stdout).
 *  @param[in]  elem 	A handle the root node
 *  @param[in]  fname 	Output file name
 *  @param[in]  flen 	Length of utput file name
 *  @return		Nothing
 */
void
VF_WRITEXML (handle_t *elem, char *fname, int flen)
{
    char *_fname  = sstrip (fname, flen);

    vot_writeVOTable (*elem, _fname, 0);

    free ((char *) _fname);
}



/** VF_WRITEHTML
 * 
 *  @brief              Print the XML to the named file (or stdout)
 *  @param[in]  elem    A handle the root Element.
 *  @param[in]  fname   Output file name
 */
void
VF_WRITEHTML (handle_t *elem, char *ifname, char *ofname, int iflen, int oflen)
{
    char *_ifname = sstrip (ifname, iflen);
    char *_ofname = sstrip (ofname, oflen);

    vot_writeHTML (*elem, _ifname, _ofname);

    free ((char *) _ifname);
    free ((char *) _ofname);
}



/** VF_WRITESHTML
 * 
 *  @brief              Print the XML to the named file (or stdout)
 *  @param[in]  elem    A handle the root Element.
 *  @param[in]  fname   Output file name
 */
void
VF_WRITESHTML (handle_t *elem, char *ifname, char *ofname, int iflen, int oflen)
{
    char *_ifname = sstrip (ifname, iflen);
    char *_ofname = sstrip (ofname, oflen);

    vot_writeSHTML (*elem, _ifname, _ofname);

    free ((char *) _ifname);
    free ((char *) _ofname);
}




/** VF_WRITEASV
 * 
 *  @brief              Print the XML as Ascii-Separated Values
 *  @param[in]  elem    A handle the root Element.
 *  @param[in]  fname   Output file name
 */
void
VF_WRITEASV (handle_t *elem, char *fname, int flen)
{
    char *_fname = sstrip (fname, flen);

    vot_writeASV (*elem, _fname, 1);

    free ((char *) _fname);
}


/** VF_WRITEBSV
 * 
 *  @brief              Print the XML as Ascii-Separated Values
 *  @param[in]  elem    A handle the root Element.
 *  @param[in]  fname   Output file name
 */
void
VF_WRITEBSV (handle_t *elem, char *fname, int flen)
{
    char *_fname = sstrip (fname, flen);

    vot_writeBSV (*elem, _fname, 1);

    free ((char *) _fname);
}


/** VF_WRITECSV
 * 
 *  @brief              Print the XML as Ascii-Separated Values
 *  @param[in]  elem    A handle the root Element.
 *  @param[in]  fname   Output file name
 */
void
VF_WRITECSV (handle_t *elem, char *fname, int flen)
{
    char *_fname = sstrip (fname, flen);

    vot_writeCSV (*elem, _fname, 1);

    free ((char *) _fname);
}


/** VF_WRITEASV
 * 
 *  @brief              Print the XML as Ascii-Separated Values
 *  @param[in]  elem    A handle the root Element.
 *  @param[in]  fname   Output file name
 */
void
VF_WRITETSV (handle_t *elem, char *fname, int flen)
{
    char *_fname = sstrip (fname, flen);

    vot_writeTSV (*elem, _fname, 1);

    free ((char *) _fname);
}






/****************************************************************************
 *  Private utility procedures
 ****************************************************************************/

/**
 *  sstrip
 *
 *  Utility to trim trailing blanks from string and add a null terminator.
 */
static char *
sstrip (char *instr, int len)
{
    if (len > 0 && instr) {
        char *newstr = calloc (1, len+1);
	int i = len;

        strncpy (newstr, instr, len);

	/* trim trailing blanks */
	for (i=len; newstr[i] == ' ' || newstr[i] == '\0'; i--)	
	    newstr[i] = '\0';
	    
        return (newstr);
    }

    return ((char *) NULL);
}


/**
 *  spad 
 *
 *  Pad a string to length 'len' with blanks, as Fortran requires.
 */
void
spad (char *outstr, int len)
{
    int i=0;
        
    for (i = strlen(outstr); i < len; i++)
        outstr[i] = ' ';
}