/* label.c
********************************************************************************
* label.c  -- Routines for PDS label objects
*
* User routines:
*       Pro_OpenLabel()		creates a PDS label object.
*       Pro_LabelCount()	returns the number of tables/columns/items.
*       Pro_LabelName()		returns the name of a table/column.
*       Pro_LabelFind()		returns the index of a named table/column.
*	Pro_LabelSampling()	returns the sampling parameters of a column.
*       Pro_LabelInt()		returns the integer value of a label keyword.
*       Pro_LabelFloat()	returns the floating point value of a keyword.
*       Pro_LabelString()	returns the string value of a keyword.
*
* Programmer routines:
*	XPro_LabelInfo()	returns the key parameters of a column.
*
* Neil Heather & Mark Showalter, PDS Rings Node, March 1998.
*******************************************************************************/

#include 
#include 
#include 
#include "profile.h"
#include "fortran.h"

#include "oal.h"

/*************************
 * Data type definitions *
 *************************/

typedef struct ZPRO_COLUMN_STRUCT {
    ODLTREE	odltree;
    RL_CHAR	name[PRO_NAMELEN+1];
    RL_INT4     items;		/* Default: 1          */
    RL_FLT8     missing;	/* Default: -HUGE_VAL  */
    RL_FLT8     invalid;	/* Default: -HUGE_VAL  */
    RL_FLT8     offset;		/* Default: 0.0        */
    RL_FLT8     scale;		/* Default: 1.0        */
} ZPRO_COLUMN;

typedef struct ZPRO_TABLE_STRUCT {
    ODLTREE	odltree;
    RL_CHAR	name[PRO_NAMELEN+1];
    RL_CHAR	xname[PRO_NAMELEN+1];
    RL_INT4	nrows, ncolumns;
    RL_FLT8	x1, x2, dx;
    ZPRO_COLUMN	*columns;
} ZPRO_TABLE;

typedef struct ZPRO_LABEL_STRUCT {
    XPRO_CLASS	class;
    ODLTREE	odltree;  /* the root node of the label file */
    RL_CHAR	filename[PRO_FILELEN+1];
    RL_INT4	ntables;
    ZPRO_TABLE	*tables;
} ZPRO_LABEL;

/********************************
 * Internal function prototypes *
 ********************************/

static void          ZPro_FreeLabel  RL_PROTO((RL_VOID *pointer));
static void          ZPro_PrintLabel RL_PROTO((RL_VOID *pointer));
static ZPRO_LABEL   *ZPro_LabelPtr   RL_PROTO((PRO_OBJECT *object));
static ZPRO_TABLE   *ZPro_TablePtr   RL_PROTO((PRO_OBJECT *object,
                                               RL_INT4 ntable));
static ZPRO_COLUMN  *ZPro_ColumnPtr  RL_PROTO((PRO_OBJECT *object,
                                               RL_INT4 ntable,
                                               RL_INT4 ncolumn));

static RL_BOOL ZPro_GetParam  RL_PROTO((ODLTREE odltree, RL_CHAR *name,
                                        RL_CHAR **ptr));
static RL_BOOL ZPro_GetInt    RL_PROTO((ODLTREE odltree, RL_CHAR *name,
                                        RL_INT4 *value));
static RL_BOOL ZPro_GetFloat  RL_PROTO((ODLTREE odltree, RL_CHAR *name,
                                        RL_FLT8 *value));
static RL_BOOL ZPro_GetString RL_PROTO((ODLTREE odltree, RL_CHAR *name,
                                        RL_CHAR *value, RL_INT4 maxlen));
static void    ZPro_DefInt    RL_PROTO((ODLTREE odltree, RL_CHAR *name,
                                        RL_INT4 dfault, RL_INT4 *value));
static void    ZPro_DefFloat  RL_PROTO((ODLTREE odltree, RL_CHAR *name,
                                        RL_FLT8 dfault, RL_FLT8 *value));
static void    ZPro_DefFloat2 RL_PROTO((ODLTREE odltree, RL_CHAR *name1,
                                        RL_CHAR *name2,
                                        RL_FLT8 dfault, RL_FLT8 *value));
static void    ZPro_DefString RL_PROTO((ODLTREE odltree, RL_CHAR *name,
                                        RL_CHAR *dfault,
                                        RL_CHAR *value, RL_INT4 maxlen));
static void    ZPro_DefName   RL_PROTO((ODLTREE odltree, RL_CHAR *name,
                                        RL_CHAR *unit, RL_CHAR *dfault,
                                        RL_CHAR *value, RL_INT4 maxlen));

/********************
 * Static variables *
 ********************/

static XPRO_CLASS label_class = {XPRO_LABEL_CLASS, "PDS label", NULL};

#define TEMP_MAXLEN 255
static RL_CHAR    temp_name[TEMP_MAXLEN+1];

/*********************
 * Macro definitions *
 *********************/

#define SUPPRESS_MESSAGES 1

/*
********************************************************************************
* EXPORTED USER ROUTINES
********************************************************************************
*$ Component_name:
*	Pro_OpenLabel (label.c)
*$ Abstract:
*	This routine opens the specified PDS label file and creates a label
*	object.
*$ Keywords:
*	PROFILE
*	C, PUBLIC, SUBROUTINE
*$ Declarations:
*	PRO_OBJECT	*Pro_OpenLabel(labelfile)
*	RL_CHAR		*labelfile;
*$ Inputs:
*      *labelfile	name of PDS label file.
*$ Outputs:
*	none
*$ Returns:
*	pointer to a new label object.
*$ Detailed_description:
*	This routine opens the specified PDS label file and creates a label
*	object.  It parses the label to find the TABLE and SERIES objects.  Use
*	Pro_ColumnSeries() (see column.c) to create a series object from one of
*	the columns.
*$ External_references:
*	Profile toolkit, Object Access library.
*$ Side_effects:
*	Memory is allocated.  The label file is opened.
*$ Examples:
*	This snippet of code creates a label object for a PDS file called
*	"table.tab":
*
*	PRO_OBJECT	*label;
*
*	label = Pro_OpenLabel("table.tab");
*$ Error_handling:
*	Profile library error handling is in effect.
*
*	Conditions raised:
*	PRO_SETUP_FAILURE	if the label cannot be read or parsed or has no
*				TABLE or SERIES objects.
*$ Limitations:
*	none
*$ Author_and_institution:
*	Mark R. Showalter
*	NASA/Ames Research Center
*$ Version_and_date:
*	1.0: March 1998
*$ Change_history:
*	none
*******************************************************************************/

PRO_OBJECT	*Pro_OpenLabel(labelfile)
RL_CHAR		*labelfile;
{
ODLTREE		root_node, node;
PRO_OBJECT	*new;
ZPRO_LABEL	*label;
ZPRO_TABLE	*table;
ZPRO_COLUMN	*column;
RL_INT4         i, j, ntables, nseries;

    /****************************
     * Read and parse the label *
     ****************************/

    root_node = OaParseLabelFile(labelfile, NULL, ODL_EXPAND_STRUCTURE,
			(unsigned short) SUPPRESS_MESSAGES);
    if (root_node != NULL) root_node = OaConvertLabel(root_node);

    if (root_node == NULL || (oa_errno >= 500 && oa_errno < 900)) {
	(void) sprintf(xpro_message, "label parsing failure\n\
Unable to read/parse label in file \"%s\"\n\
OA Library error code %d",
	labelfile, oa_errno);
	RL_RaiseError("PRO_SETUP_FAILURE", xpro_message);

	if (root_node != NULL) OdlFreeTree(root_node);
	return NULL;
    }

    /**********************************
     * Count the SERIES & TABLE nodes *
     **********************************/

    for (i=1; ; i++) {
	node = OdlFindObjDesc(root_node, "*SERIES", NULL, NULL,
			(unsigned long) i, ODL_RECURSIVE_DOWN);
	if (node == NULL) break;
    }
    ntables = i - 1;

    for (i=1; ; i++) {
	node = OdlFindObjDesc(root_node, "*TABLE", NULL, NULL,
			(unsigned long) i, ODL_RECURSIVE_DOWN);
	if (node == NULL) break;
    }
    ntables += i - 1;

    if (ntables == 0) {
	(void) sprintf(xpro_message, "label setup failure\n\
No TABLE or SERIES objects found in label \"%s\"",
	labelfile);
	RL_RaiseError("PRO_SETUP_FAILURE", xpro_message);

	OdlFreeTree(root_node);
	return NULL;
    }

    /***************************************
     * Initialize the ZPRO_LABEL structure *
     ***************************************/

    label = (ZPRO_LABEL *) XRL_Malloc(sizeof(ZPRO_LABEL));
    if (label == NULL) return NULL;

    label->class = label_class;
    label->odltree = root_node;

    (void) strncpy(label->filename, labelfile, PRO_FILELEN);
    label->filename[PRO_FILELEN] = '\0';

    label->ntables = ntables;

    label->tables = (struct ZPRO_TABLE_STRUCT *)
	XRL_Malloc(ntables * sizeof(ZPRO_TABLE));
    if (label->tables == NULL) {
	ZPro_FreeLabel((RL_VOID *) label);
	return NULL;
    }

    /*****************************************
     * Fill in the SERIES and TABLE pointers *
     *****************************************/

    for (i=1; ; i++) {
	node = OdlFindObjDesc(root_node, "*SERIES", NULL, NULL,
			(unsigned long) i, ODL_RECURSIVE_DOWN);
	if (node == NULL) break;

	label->tables[i-1].odltree = node;
    }
    nseries = i - 1;

    for (i=1; ; i++) {
	node = OdlFindObjDesc(root_node, "*TABLE", NULL, NULL,
			(unsigned long) i, ODL_RECURSIVE_DOWN);
	if (node == NULL) break;

	label->tables[nseries + i-1].odltree = node;
    }

    /*****************************
     * Fill each table structure *
     *****************************/

    for (i=0; i < ntables; i++) {
	table = &(label->tables[i]);
	node = table->odltree;

	ZPro_DefString(node, "NAME", "", table->name, PRO_NAMELEN);

	ZPro_DefInt(node, "ROWS",    1, &(table->nrows));
	ZPro_DefInt(node, "COLUMNS", 1, &(table->ncolumns));

	ZPro_DefFloat2(node, "MINIMUM_SAMPLING_PARAMETER",
	                     "START_SAMPLING_PARAMETER",
	                     1., &(table->x1));
	ZPro_DefFloat2(node, "MAXIMUM_SAMPLING_PARAMETER",
	                     "STOP_SAMPLING_PARAMETER",
	                     (RL_FLT8) table->nrows, &(table->x2));
	ZPro_DefFloat(node,  "SAMPLING_PARAMETER_INTERVAL",
	                     1., &(table->dx));
	ZPro_DefName(node,   "SAMPLING_PARAMETER_NAME",
	                     "SAMPLING_PARAMETER_UNIT",
	                     "ROW_INDEX", table->xname, PRO_NAMELEN);

	/******************************
	 * Allocate column structures *
	 ******************************/

	table->columns = (struct ZPRO_COLUMN_STRUCT *)
	    XRL_Malloc(table->ncolumns * sizeof(ZPRO_COLUMN));
	if (table->columns == NULL) {
		ZPro_FreeLabel((RL_VOID *) label);
		return NULL;
	}

	/**********************************************
	 * For each table, fill each column structure *
	 **********************************************/

	for (j=1; j <= table->ncolumns; j++) {
	    node = OdlFindObjDesc(table->odltree, "*COLUMN", NULL, NULL,
			(unsigned long) j, ODL_RECURSIVE_DOWN);
                                         /* ODL_THIS_OBJECT doesn't work! */

	    if (node == NULL) {		/* This should never happen */
		label->tables[i].ncolumns = j-1;
		break;
	    }

	    column = &(table->columns[j-1]);
	    column->odltree = node;

	    (void) sprintf(xpro_message, "COLUMN_%d", j);
	    ZPro_DefName(node, "NAME", "UNIT", xpro_message,
			column->name, PRO_NAMELEN);

	    ZPro_DefInt(node, "ITEMS", 1, &(column->items));
	    ZPro_DefFloat2(node, "MISSING_CONSTANT", "MISSING", -HUGE_VAL,
			&(column->missing));
	    ZPro_DefFloat2(node, "INVALID_CONSTANT", "INVALID", -HUGE_VAL,
			&(column->invalid));
	    ZPro_DefFloat(node, "OFFSET", 0., &(column->offset));
	    ZPro_DefFloat(node, "SCALING_FACTOR", 1., &(column->scale));
	}
    }

    /*********************
     * Create new object *
     *********************/

    new = XPro_MakeObject(0., 0., ZPro_FreeLabel, ZPro_PrintLabel,
                          (RL_VOID *) label);

    return new;
}

/*
********************************************************************************
*$ Component_name:
*	Pro_LabelCount (label.c)
*$ Abstract:
*	This routine returns the number of tables in a PDS label object, the
*	number of columns in a table, or the number of items in a column.
*$ Keywords:
*	PROFILE, SERIES, LABEL
*	C, PUBLIC, SUBROUTINE
*$ Declarations:
*	RL_INT4		Pro_LabelCount(object, ntable, ncolumn)
*	PRO_OBJECT	*object;
*	RL_INT4		ntable, ncolumn;
*$ Inputs:
*	object		pointer to the PDS label object.
*	ntable		index of the selected table (0 or 1...n).
*	ncolumn		index of the selected column (0 or 1...n).
*$ Outputs:
*	none
*$ Returns:
*	If ntable is zero, this is the number of tables in the label;
*	If ncolumn is zero, this is the number of columns in the selected table;
*	Otherwise, this is the number of items in the selected column.
*$ Detailed_description:
*	This routine returns the number of tables in a PDS label object, the
*	number of columns in a table, or the number of items in a column.
*
*	The quantity returned depends on the which input parameters are set to
*	zero.  If ntable is zero, the total number of PDS TABLE and SERIES
*	objects is returned.  Otherwise, ntable is the index (starting with 1)
*	of the selected table.  If ncolumn is zero, the number of PDS COLUMN
*	objects in the selected table is returned.  Otherwise, ncolumn is the
*	index (starting with 1) of the selected column and the number of ITEMs
*	in the column is returned.
*$ External_references:
*	Profile toolkit
*$ Side_effects:
*	none
*$ Examples:
*	Suppose the PDS label associated with an object looks like this:
*
*	^TIME_SERIES	= "FOOBAR.TAB"
*	^DATA_TABLE	= "FOOBAR.DAT"
*	^IMAGE		= "FOOBAR.IMG"
*	OBJECT		= TIME_SERIES
*	  ... (3 columns defined, each with 1 item)
*	END_OBJECT	= TIME_SERIES
*	OBJECT		= DATA_TABLE
*	  ... (1 column defined, with 600 items)
*	END_OBJECT	= DATA_TABLE
*	OBJECT		= IMAGE
*	  ...
*	END_OBJECT	= IMAGE
*	END
*
*	Then Pro_LabelCount(label, 0, 0) returns 2 (number of tables or series);
*	     Pro_LabelCount(label, 1, 0) returns 3 (columns in TIME_SERIES);
*	     Pro_LabelCount(label, 1, 1) returns 1 (items in column);
*	     Pro_LabelCount(label, 2, 1) returns 600 (items in column);
*$ Error_handling:
*	Profile library error handling is in effect.
*
*	Conditions raised:
*	PRO_CLASS_ERROR		if object is NULL or is not a PDS label.
*	PRO_DOMAIN_ERROR	if the table or column index is out of range.
*$ Limitations:
*	none
*$ Author_and_institution:
*	Mark R. Showalter
*	NASA/Ames Research Center
*$ Version_and_date:
*	1.0: March 1998
*$ Change_history:
*	none
*******************************************************************************/

RL_INT4		Pro_LabelCount(object, ntable, ncolumn)
PRO_OBJECT	*object;
RL_INT4		ntable, ncolumn;
{
ZPRO_LABEL	*label;
ZPRO_TABLE	*table;
ZPRO_COLUMN	*column;

    /**********************
     * Return table count *
     **********************/

    if (ntable == 0) {
	label = ZPro_LabelPtr(object);
	if (label == NULL) return 0;

	return label->ntables;
    }

    /*********************************
     * Otherwise return column count *
     *********************************/

    if (ncolumn == 0) {
	table = ZPro_TablePtr(object, ntable);
	if (table == NULL) return 0;

	return table->ncolumns;
    }

    /*******************************
     * Otherwise return item count *
     *******************************/

    column = ZPro_ColumnPtr(object, ntable, ncolumn);
    if (column == NULL) return 0;

    return column->items;
}

/*
********************************************************************************
*$ Component_name:
*	Pro_LabelName (label.c)
*$ Abstract:
*	This routine returns the name of the specified table or column.
*$ Keywords:
*	PROFILE, SERIES, LABEL
*	C, PUBLIC, SUBROUTINE
*$ Declarations:
*	RL_CHAR		*Pro_LabelName(object, ntable, ncolumn)
*	PRO_OBJECT	*object;
*	RL_INT4		ntable, ncolumn;
*$ Inputs:
*	object		pointer to the PDS label object.
*	ntable          index of selected table (1...n).
*	ncolumn		index of the selected column (0 or 1...n).
*$ Outputs:
*	none
*$ Returns:
*	a pointer to a (read-only) string containing the desired name.
*	If ncolumn is zero, this is the name of the selected table; otherwise,
*	this is the name of the selected column.
*$ Detailed_description:
*	This routine returns the name of the specified table or column.
*
*	The quantity returned depends on the which input parameters are set to
*	zero.  If ncolumn is zero, the name of the PDS TABLE or SERIES object is
*	returned; otherwise, ncolumn is the index (starting with 1) of the
*	selected column and the routine returns the column's name.
*
*	COLUMN names are defined by the PDS label's NAME field, followed by a
*	space and (if present) the PDS label's UNIT field in parentheses.
*$ External_references:
*	Profile toolkit
*$ Side_effects:
*	none
*$ Examples:
*	Suppose the PDS label associated with an object looks like this:
*
*	^SERIES				= "PS1G02.TAB"
*	OBJECT				= SERIES
*	  NAME				= OCCULTATION_GEOMETRY
*	  SAMPLING_PARAMETER_NAME       = RECORD_INDEX
*	  SAMPLING_PARAMETER_UNIT       = 'N/A'
*	  START_SAMPLING_PARAMETER      = -16.
*	  STOP_SAMPLING_PARAMETER       = 1296.
*	  SAMPLING_PARAMETER_INTERVAL	= 1.0
*	  OBJECT			= COLUMN
*	    NAME			= RECORD_INDEX
*	    UNIT			= 'N/A'
*	  END_OBJECT			= COLUMN
*	  OBJECT			= COLUMN
*	    NAME			= INTERCEPT_RADIUS
*	    UNIT			= "km"
*	  END_OBJECT			= COLUMN
*	END_OBJECT			= SERIES
*	END
*
*	Then Pro_LabelName(label, 1, 0) returns "OCCULTATION_GEOMETRY";
*	     Pro_LabelName(label, 1, 1) returns "RECORD_INDEX";
*	     Pro_LabelName(label, 1, 2) returns "INTERCEPT_RADIUS (km)"
*$ Error_handling:
*	Profile library error handling is in effect.
*
*	Conditions raised:
*	PRO_CLASS_ERROR		if object is NULL or is not a PDS label.
*	PRO_DOMAIN_ERROR	if the table or column index is out of range.
*$ Limitations:
*	none
*$ Author_and_institution:
*	Mark R. Showalter
*	NASA/Ames Research Center
*$ Version_and_date:
*	1.0: March 1998
*$ Change_history:
*	none
*******************************************************************************/

RL_CHAR		*Pro_LabelName(object, ntable, ncolumn)
PRO_OBJECT	*object;
RL_INT4		ntable, ncolumn;
{
ZPRO_TABLE	*table;
ZPRO_COLUMN	*column;

    /*********************
     * Return table name *
     *********************/

    if (ncolumn == 0) {
	table = ZPro_TablePtr(object, ntable);
	if (table == NULL) return NULL;

	return table->name;
    }

    /********************************
     * Otherwise return column name *
     ********************************/

    column = ZPro_ColumnPtr(object, ntable, ncolumn);
    if (column == NULL) return NULL;

    return column->name;
}

/*
********************************************************************************
*$ Component_name:
*	Pro_LabelXName (label.c)
*$ Abstract:
*	This routine returns the name of a table's X-coordinate.
*$ Keywords:
*	PROFILE, SERIES, LABEL
*	C, PUBLIC, SUBROUTINE
*$ Declarations:
*	RL_CHAR		*Pro_LabelXName(object, ntable)
*	PRO_OBJECT	*object;
*	RL_INT4		ntable;
*$ Inputs:
*	object		pointer to the PDS label object.
*	ntable          index of selected table (1...n).
*$ Outputs:
*	none
*$ Returns:
*	a pointer to a (read-only) string containing the desired name, or NULL
*	on a non-fatal error.
*$ Detailed_description:
*	This routine returns the name of a table's X-coordinate.  Names are
*	defined by the PDS label's SAMPLING_PARAMETER_NAME field, followed by a
*	space and (if present) the PDS label's SAMPLING_PARAMETER_UNIT field in
*	parentheses.
*$ External_references:
*	Profile toolkit
*$ Side_effects:
*	none
*$ Examples:
*	Suppose the PDS label associated with an object looks like this:
*
*	^SERIES				= "PS1G02.TAB"
*	OBJECT				= SERIES
*	  NAME				= OCCULTATION_GEOMETRY
*	  SAMPLING_PARAMETER_NAME       = RECORD_INDEX
*	  SAMPLING_PARAMETER_UNIT       = 'N/A'
*	  START_SAMPLING_PARAMETER      = -16.
*	  STOP_SAMPLING_PARAMETER       = 1296.
*	  SAMPLING_PARAMETER_INTERVAL	= 1.0
*	  OBJECT			= COLUMN
*	    NAME			= RECORD_INDEX
*	    UNIT			= 'N/A'
*	  END_OBJECT			= COLUMN
*	  OBJECT			= COLUMN
*	    NAME			= INTERCEPT_RADIUS
*	    UNIT			= "km"
*	  END_OBJECT			= COLUMN
*	END_OBJECT			= SERIES
*	END
*
*	Then Pro_LabelXName(label, 1) returns "RECORD_INDEX"
*$ Error_handling:
*	Profile library error handling is in effect.
*
*	Conditions raised:
*	PRO_CLASS_ERROR		if object is NULL or is not a PDS label.
*	PRO_DOMAIN_ERROR	if the table index is out of range.
*$ Limitations:
*	none
*$ Author_and_institution:
*	Mark R. Showalter
*	NASA/Ames Research Center
*$ Version_and_date:
*	1.0: March 1998
*$ Change_history:
*	none
*******************************************************************************/

RL_CHAR		*Pro_LabelXName(object, ntable)
PRO_OBJECT	*object;
RL_INT4		ntable;
{
ZPRO_TABLE	*table;
ZPRO_COLUMN	*column;

    table = ZPro_TablePtr(object, ntable);
    if (table == NULL) return NULL;

    return table->xname;
}

/*
********************************************************************************
*$ Component_name:
*	Pro_LabelFind (label.c)
*$ Abstract:
*	This routine returns the index of the named table or column.
*$ Keywords:
*	PROFILE, SERIES, LABEL
*	C, PUBLIC, SUBROUTINE
*$ Declarations:
*	RL_INT4		Pro_LabelFind(object, ntable, name)
*	PRO_OBJECT	*object;
*	RL_INT4		ntable;
*	RL_CHAR		*name;
*$ Inputs:
*	object		pointer to the PDS label object.
*	ntable          index of selected table (1...n).
*	name		name of the table or column to find.  For columns, this
*			string can optionally exclude units inside parentheses.
*$ Outputs:
*	none
*$ Returns:
*	index (1...n) of the selected table or column; 0 if not found.
*	If ntable is zero, this is the index of the table with the given name;
*	otherwise, this is the index of the column with the given name.
*$ Detailed_description:
*	This routine returns the index of the named table or column.
*
*	The quantity returned depends on the which input parameters are set to
*	zero.  If ntable is zero, the index (starting with 1) of the table with
*	the given name is returned.  Otherwise, ntable is the index of the
*	selected table and the number returned is the index of the column with
*	the given name.  For columns, if the name string does not contain units
*	(inside parentheses), then any units in the column name are ignored.
*$ External_references:
*	Profile toolkit
*$ Side_effects:
*	none
*$ Examples:
*	Suppose the PDS label associated with an object looks like this:
*
*	^SERIES				= "PS1G02.TAB"
*	OBJECT				= SERIES
*	  NAME				= OCCULTATION_GEOMETRY
*	  SAMPLING_PARAMETER_NAME       = RECORD_INDEX
*	  SAMPLING_PARAMETER_UNIT       = 'N/A'
*	  START_SAMPLING_PARAMETER      = -16.
*	  STOP_SAMPLING_PARAMETER       = 1296.
*	  SAMPLING_PARAMETER_INTERVAL	= 1.0
*	  OBJECT			= COLUMN
*	    NAME			= RECORD_INDEX
*	    UNIT			= 'N/A'
*	  END_OBJECT			= COLUMN
*	  OBJECT			= COLUMN
*	    NAME			= INTERCEPT_RADIUS
*	    UNIT			= "km"
*	  END_OBJECT			= COLUMN
*	END_OBJECT			= SERIES
*	END
*
*	Then Pro_LabelFind(label, 0, "OCCULTATION_GEOMETRY")  returns 1;
*	     Pro_LabelFind(label, 1, "RECORD_INDEX")          returns 1;
*	     Pro_LabelFind(label, 1, "INTERCEPT_RADIUS (km)") returns 2;
*	     Pro_LabelFind(label, 1, "INTERCEPT_RADIUS")      returns 2;
*$ Error_handling:
*	Profile library error handling is in effect.
*
*	Conditions raised:
*	PRO_CLASS_ERROR		if object is NULL or is not a PDS label.
*	PRO_DOMAIN_ERROR	if the table index is out of range.
*	PRO_NOT_FOUND		if no table or column of the given name exists.
*$ Limitations:
*	none
*$ Author_and_institution:
*	Mark R. Showalter
*	NASA/Ames Research Center
*$ Version_and_date:
*	1.0: March 1998
*$ Change_history:
*	none
*******************************************************************************/

RL_INT4		Pro_LabelFind(object, ntable, name)
PRO_OBJECT	*object;
RL_INT4		ntable;
RL_CHAR		*name;
{
RL_INT4		ntables, ncolumns, lname, i;
RL_BOOL		hasunits;
RL_CHAR		*comp;
ZPRO_LABEL	*label;

    /**********************************
     * Search for matching table name *
     **********************************/

    if (ntable == 0) {
	ntables = Pro_LabelCount(object, 0, 0);
	for (i=1; i<=ntables; i++) {
	    if (strcmp(name, Pro_LabelName(object,i,0)) == 0) return i;
	}

	/* If no match is found, report error */
	label = ZPro_LabelPtr(object);
	(void) sprintf(xpro_message, "named table not found\n\
label contains no table named \"%s\"\n\
label file = \"%s\"",
				name, label->filename);

	RL_RaiseError("PRO_NOT_FOUND", xpro_message);
	return 0;
    }

    /*********************************************
     * Otherwise search for matching column name *
     *********************************************/

    /* Check for units in match string */
    hasunits = (strchr(name, '(') != NULL);
    lname = strlen(name);

    /* Search for matching table name */
    ncolumns = Pro_LabelCount(object, ntable, 0);
    for (i=1; i<=ncolumns; i++) {
	comp = Pro_LabelName(object,ntable,i);

	/* If match string has units, check for exact match */
	if (hasunits) {
	    if (strcmp(name, comp) == 0) return i;
	}

	/* Otherwise, match up to end, paren, or blank+paren */
	else {
	    if (strncmp(name, comp, lname) == 0) {
		if (comp[lname] == '\0' || comp[lname]   == '(') return i;
		if (comp[lname] == ' '  && comp[lname+1] == '(') return i;
	    }
	}
    }

    /* If no match is found, report error */
    label = ZPro_LabelPtr(object);
    (void) sprintf(xpro_message, "named column not found\n\
table #%d contains no column named \"%s\"\n\
label file = \"%s\"",
				ntable, name, label->filename);

    RL_RaiseError("PRO_NOT_FOUND", xpro_message);
    return 0;
}

/*
********************************************************************************
*$ Component_name:
*	Pro_LabelSampling (label.c)
*$ Abstract:
*	This routine returns the sampling parameters used by a specified table
*	or column.
*$ Keywords:
*	PROFILE, SERIES, LABEL
*	C, PUBLIC, SUBROUTINE
*$ Declarations:
*	RL_INT4		Pro_LabelSampling(object, ntable, ncolumn, nitem,
*					x1, x2, dx)
*	PRO_OBJECT	*object;
*	RL_INT4		ntable, ncolumn, nitem;
*	RL_FLT8		*x1, *x2, *dx;
*$ Inputs:
*	object		pointer to the PDS label object.
*	ntable          index of selected table (1...n).
*	ncolumn		index of the selected column (1...n) or 0 for row
*			sampling.
*	nitem		index of selected item, or 0 for all.
*$ Outputs:
*	*x1		first sampling parameter; not returned if x1==NULL.
*	*x2		last sampling parameter;  not returned if x2==NULL.
*	*dx		interval between samples; not returned if dx==NULL.
*$ Returns:
*	the number of samples in selected column/item pair; 0 on error.
*$ Detailed_description:
*	This routine returns the sampling parameters used by a specified table
*	or column.
*
*	If nitem is nonzero, then it is assumed that the only a single item per
*	row is to be used; in this case the sampling parameters for the column
*	match those for the row.  However, if nitem is zero in a column that
*	contains multiple items, then the items are treated as subsamples, so
*	the sample interval is correspondingly reduced.
*
*	Note that the row sampling parameters are returned if ncolumn is zero.
*$ External_references:
*	Profile toolkit
*$ Side_effects:
*	none
*$ Examples:
*	Suppose the PDS label associated with an object looks like this:
*
*	^SERIES				= "PS1G02.TAB"
*	OBJECT				= SERIES
*	  SAMPLING_PARAMETER_NAME       = RECORD_INDEX
*	  SAMPLING_PARAMETER_UNIT       = 'N/A'
*	  START_SAMPLING_PARAMETER      = -16.
*	  STOP_SAMPLING_PARAMETER       = 1296.
*	  SAMPLING_PARAMETER_INTERVAL	= 1.0
*	  OBJECT			= COLUMN
*	    ITEMS			= 1
*	  END_OBJECT			= COLUMN
*	  OBJECT			= COLUMN
*	    ITEMS			= 100
*	  END_OBJECT			= COLUMN
*	END_OBJECT			= SERIES
*	END
*
*	Then Pro_LabelSampling(label, 1, 1, 1, &x1, &x2, &dx)
*			sets x1=-16., x2=1296., dx=1., returns 1313;
*	     Pro_LabelSampling(label, 1, 1, 0, &x1, &x2, &dx)
*			sets x1=-16., x2=1296., dx=1., returns 1313;
*	     Pro_LabelSampling(label, 1, 2, 1, &x1, &x2, &dx)
*			sets x1=-16., x2=1296., dx=1., returns 1313;
*	     Pro_LabelSampling(label, 1, 2, 0, &x1, &x2, &dx)
*			sets x1=-16., x2=1296.99, dx=0.01, returns 131300
*$ Error_handling:
*	Profile library error handling is in effect.
*
*	Conditions raised:
*	PRO_CLASS_ERROR		if object is NULL or is not a PDS label.
*	PRO_DOMAIN_ERROR	if table, column or item index is out of range.
*$ Limitations:
*	none
*$ Author_and_institution:
*	Mark R. Showalter
*	NASA/Ames Research Center
*$ Version_and_date:
*	1.0: March 1998
*$ Change_history:
*	none
*******************************************************************************/

RL_INT4		Pro_LabelSampling(object, ntable, ncolumn, nitem, x1, x2, dx)
PRO_OBJECT	*object;
RL_INT4		ntable, ncolumn, nitem;
RL_FLT8		*x1, *x2, *dx;
{
ZPRO_TABLE	*table;
ZPRO_COLUMN	*column;
RL_FLT8		scaled_dx;
RL_INT4		nrows;

    /**************
     * Find table *
     **************/

    table = ZPro_TablePtr(object, ntable);
    if (table == NULL) return 0;

    scaled_dx = table->dx;
    nrows = table->nrows;

    /*********************************************
     * Find column and optional expansion factor *
     *********************************************/

    if (ncolumn != 0) {
	column = ZPro_ColumnPtr(object, ntable, ncolumn);
	if (column == NULL) return 0;

	if (nitem < 0 || nitem > column->items)
	    XPro_IDomainError("item index", object, 1, column->items, nitem);

	if (nitem == 0) {
	    scaled_dx /= column->items;
	    nrows *= column->items;
	}
    }

    /*****************
     * Return values *
     *****************/

    if (x1 != NULL) *x1 = table->x1;
    if (x2 != NULL) *x2 = table->x2 + (table->dx - scaled_dx);
    if (dx != NULL) *dx = scaled_dx;

    return nrows;
}

/*
********************************************************************************
*$ Component_name:
*	Pro_LabelInt (label.c)
*$ Abstract:
*	This routine returns the integer value of a specified keyword in a PDS
*	label.
*$ Keywords:
*	PROFILE, SERIES, LABEL
*	C, PUBLIC, SUBROUTINE
*$ Declarations:
*	RL_INT4		Pro_LabelInt(object, ntable, ncolumn, keyword, dfault,
*					raise_error)
*	PRO_OBJECT	*object;
*	RL_INT4		ntable, ncolumn, dfault;
*	RL_CHAR		*keyword;
*	RL_BOOL		raise_error;
*$ Inputs:
*	object		pointer to the PDS label object.
*	ntable		table index, or 0 to search among top keywords only.
*	ncolumn		column index, or 0 to search among table keywords only.
*	keyword		keyword name.
*	dfault		default value to return on error.
*	raise_error	TRUE to raise PRO_EVALUATION_FAILURE on error;
*			FALSE otherwise.
*$ Outputs:
*	none
*$ Returns:
*	integer value of the keyword; default value on non-fatal error.
*$ Detailed_description:
*	This routine returns the integer value of a specified keyword in a PDS
*	label.
*
*	What section of the label is searched depends on the values of the
*	ntable and ncolumn parameters.  If ntable is zero, then only the
*	keywords at the top of the PDS label (above any PDS OBJECTs) are
*	searched.  If ntable is nonzero but ncolumn is zero, then the keywords
*	inside the TABLE/SERIES object but above the COLUMN objects are
*	searched, followed by the keywords at the top of the label.  If both
*	ntable and nseries are nonzero, then the keywords in the selected
*	COLUMN object are searched, followed by the keywords in the selected
*	TABLE/SERIES object, followed by the keywords at the top of the label.
*
*	If the keyword is not found in the PDS label, or is found but is not a
*	valid integer, the default value is returned.  In this case, error code
*	PRO_EVALUATION_FAILURE if the raise_error parameter is TRUE; otherwise
*	no error condition is raised.
*$ External_references:
*	Profile toolkit, Object Access library.
*$ Side_effects:
*	none
*$ Examples:
*	Suppose the PDS label associated with an object looks like this:
*
*	FOO		= 1313
*	ABC		= "DEF"
*	OBJECT		= SERIES
*	  FOO		= 1000
*	  BAR		= 999
*	  OBJECT	= COLUMN
*	    FOO		= 3
*	  END_OBJECT	= COLUMN
*	END_OBJECT	= SERIES
*	END
*
*	Then Pro_LabelInt(label, 1, 1, "FOO", -99, TRUE) returns 3;
*	     Pro_LabelInt(label, 1, 0, "FOO", -99, TRUE) returns 1000;
*	     Pro_LabelInt(label, 0, 0, "FOO", -99, TRUE) returns 1313;
*	     Pro_LabelInt(label, 1, 1, "BAR", -99, TRUE) returns 999;
*	     Pro_LabelInt(label, 1, 0, "BAR", -99, TRUE) returns 999;
*	     Pro_LabelInt(label, 0, 0, "BAR", -99, TRUE) raises
*			PRO_EVALUATION_FAILURE and returns -99;
*	     Pro_LabelInt(label, 0, 0, "BAR", -99, FALSE) returns -99;
*	     Pro_LabelInt(label, 0, 0, "ABC", -99, TRUE) raises
*			PRO_EVALUATION_FAILURE and returns -99;
*	     Pro_LabelInt(label, 0, 0, "ABC", -99, FALSE) returns -99;
*$ Error_handling:
*	Profile library error handling is in effect.
*
*	Conditions raised:
*	PRO_CLASS_ERROR		if object is NULL or is not a PDS label.
*	PRO_DOMAIN_ERROR	if the table/column index is out of range.
*	PRO_EVALUATION_FAILURE	raised optionally, if the named keyword is not
*				found or is not a valid integer.
*$ Limitations:
*	none
*$ Author_and_institution:
*	Mark R. Showalter
*	NASA/Ames Research Center
*$ Version_and_date:
*	1.0: March 1998
*$ Change_history:
*	none
*******************************************************************************/

RL_INT4		Pro_LabelInt(object, ntable, ncolumn, keyword, dfault,
				raise_error)
PRO_OBJECT	*object;
RL_INT4		ntable, ncolumn, dfault;
RL_CHAR		*keyword;
RL_BOOL		raise_error;
{
ZPRO_COLUMN	*column;
ZPRO_TABLE	*table;
ZPRO_LABEL	*label;
RL_BOOL         status;
RL_INT4		value;

    if (ntable > 0) {

    /* Search column object if necessary */
	if (ncolumn > 0) {
	    column = ZPro_ColumnPtr(object, ntable, ncolumn);
	    if (column == NULL) return dfault;

	    status = ZPro_GetInt(column->odltree, keyword, &value);
	    if (status) return value;
	}

    /* Search table object if necessary */
	table = ZPro_TablePtr(object, ntable);
	if (table == NULL) return dfault;

        status = ZPro_GetInt(table->odltree, keyword, &value);
        if (status) return value;
    }

    /* Search root object if necessary */
    label = ZPro_LabelPtr(object);
    if (label == NULL) return dfault;

    status = ZPro_GetInt(label->odltree, keyword, &value);
    if (status) return value;

    /* Raise error if necessary */
    if (raise_error) {
	(void) sprintf(xpro_message, "\
keyword not found or not a valid integer\n\
label file = \"%s\"\n\
table = %d; column = %d; keyword = \"%s\"",
		label->filename, ntable, ncolumn, keyword);

	RL_RaiseError("PRO_EVALUATION_FAILURE", xpro_message);
    }

    return dfault;
}

/*
********************************************************************************
*$ Component_name:
*	Pro_LabelFloat (label.c)
*$ Abstract:
*	This routine returns the floating-point value of a specified keyword in
*	a PDS label.
*$ Keywords:
*	PROFILE, SERIES, LABEL
*	C, PUBLIC, SUBROUTINE
*$ Declarations:
*	RL_FLT8		Pro_LabelFloat(object, ntable, ncolumn, keyword, dfault,
*					raise_error)
*	PRO_OBJECT	*object;
*	RL_INT4		ntable, ncolumn;
*	RL_CHAR		*keyword;
*	RL_FLT8		dfault;
*	RL_BOOL		raise_error;
*$ Inputs:
*	object		pointer to the PDS label object.
*	ntable		table index, or 0 to search among top keywords only.
*	ncolumn		column index, or 0 to search among table keywords only.
*	keyword		keyword name.
*	dfault		default value to return on error.
*	raise_error	TRUE to raise PRO_EVALUATION_FAILURE on error;
*			FALSE otherwise.
*$ Outputs:
*	none
*$ Returns:
*	floating-point value of the keyword; default value on non-fatal error.
*$ Detailed_description:
*	This routine returns the floating-point value of a specified keyword in
*	a PDS label.
*
*	What section of the label is searched depends on the values of the
*	ntable and ncolumn parameters.  If ntable is zero, then only the
*	keywords at the top of the PDS label (above any PDS OBJECTs) are
*	searched.  If ntable is nonzero but ncolumn is zero, then the keywords
*	inside the TABLE/SERIES object but above the COLUMN objects are
*	searched, followed by the keywords at the top of the label.  If both
*	ntable and nseries are nonzero, then the keywords in the selected
*	COLUMN object are searched, followed by the keywords in the selected
*	TABLE/SERIES object, followed by the keywords at the top of the label.
*
*	If the keyword is not found in the PDS label, or is found but is not a
*	valid floating-point number, the default value is returned.  In this
*	case, error code PRO_EVALUATION_FAILURE if the raise_error parameter is
*	TRUE; otherwise no error condition is raised.
*$ External_references:
*	Profile toolkit, Object Access library.
*$ Side_effects:
*	none
*$ Examples:
*	Suppose the PDS label associated with an object looks like this:
*
*	FOO		= 313.
*	ABC		= "DEF"
*	OBJECT		= SERIES
*	  FOO		= 100
*	  BAR		= 999
*	  OBJECT	= COLUMN
*	    FOO		= 3.
*	  END_OBJECT	= COLUMN
*	END_OBJECT	= SERIES
*	END
*
*	Then Pro_LabelFloat(label, 1, 1, "FOO", -99., TRUE) returns 3.;
*	     Pro_LabelFloat(label, 1, 0, "FOO", -99., TRUE) returns 100.;
*	     Pro_LabelFloat(label, 0, 0, "FOO", -99., TRUE) returns 313.;
*	     Pro_LabelFloat(label, 1, 1, "BAR", -99., TRUE) returns 999.;
*	     Pro_LabelFloat(label, 1, 0, "BAR", -99., TRUE) returns 999.;
*	     Pro_LabelFloat(label, 0, 0, "BAR", -99., TRUE) raises
*			PRO_EVALUATION_FAILURE and returns -99.;
*	     Pro_LabelFloat(label, 0, 0, "BAR", -99., FALSE) returns -99.;
*	     Pro_LabelFloat(label, 0, 0, "ABC", -99., TRUE) raises
*			PRO_EVALUATION_FAILURE and returns -99.;
*	     Pro_LabelFloat(label, 0, 0, "ABC", -99., FALSE) returns -99.;
*$ Error_handling:
*	Profile library error handling is in effect.
*
*	Conditions raised:
*	PRO_CLASS_ERROR		if object is NULL or is not a PDS label.
*	PRO_DOMAIN_ERROR	if the table/column index is out of range.
*	PRO_EVALUATION_FAILURE	raised optionally, if the named keyword is not
*				found or is not a valid floating-point number.
*$ Limitations:
*	none
*$ Author_and_institution:
*	Mark R. Showalter
*	NASA/Ames Research Center
*$ Version_and_date:
*	1.0: March 1998
*$ Change_history:
*	none
*******************************************************************************/

RL_FLT8		Pro_LabelFloat(object, ntable, ncolumn, keyword, dfault,
		raise_error)
PRO_OBJECT	*object;
RL_INT4		ntable, ncolumn;
RL_CHAR		*keyword;
RL_FLT8		dfault;
RL_BOOL		raise_error;
{
ZPRO_COLUMN	*column;
ZPRO_TABLE	*table;
ZPRO_LABEL	*label;
RL_BOOL         status;
RL_FLT8		value;

    if (ntable > 0) {

    /* Search column object if necessary */
	if (ncolumn > 0) {
	    column = ZPro_ColumnPtr(object, ntable, ncolumn);
	    if (column == NULL) return dfault;

	    status = ZPro_GetFloat(column->odltree, keyword, &value);
	    if (status) return value;
	}

    /* Search table object if necessary */
	table = ZPro_TablePtr(object, ntable);
	if (table == NULL) return dfault;

        status = ZPro_GetFloat(table->odltree, keyword, &value);
        if (status) return value;
    }

    /* Search root object if necessary */
    label = ZPro_LabelPtr(object);
    if (label == NULL) return dfault;

    status = ZPro_GetFloat(label->odltree, keyword, &value);
    if (status) return value;

    /* Raise error if necessary */
    if (raise_error) {
	(void) sprintf(xpro_message, "\
keyword not found or not a valid floating-point value\n\
label file = \"%s\"\n\
table = %d; column = %d; keyword = \"%s\"",
		label->filename, ntable, ncolumn, keyword);

	RL_RaiseError("PRO_EVALUATION_FAILURE", xpro_message);
    }

    return dfault;
}

/*
********************************************************************************
*$ Component_name:
*	Pro_LabelString (label.c)
*$ Abstract:
*	This routine returns a pointer to the character string value of the
*	specified keyword in a PDS label.
*$ Keywords:
*	PROFILE, SERIES, LABEL
*	C, PUBLIC, SUBROUTINE
*$ Declarations:
*	RL_CHAR		*Pro_LabelString(object, ntable, ncolumn, keyword,
*					dfault, raise_error)
*	PRO_OBJECT	*object;
*	RL_INT4		ntable, ncolumn;
*	RL_CHAR		*keyword, *dfault;
*	RL_BOOL		raise_error;
*$ Inputs:
*	object		pointer to the PDS label object.
*	ntable		table index, or 0 to search among top keywords only.
*	ncolumn		column index, or 0 to search among table keywords only.
*	keyword		keyword name.
*	dfault		default string to return on error.
*	raise_error	TRUE to raise PRO_EVALUATION_FAILURE on error;
*			FALSE otherwise.
*$ Outputs:
*	none
*$ Returns:
*	pointer to a (read-only) string containing the value of keyword; a
*	pointer to the default string on error.  The string is truncated if
*	necessary after 255 characters (plus the final '\0').
*$ Detailed_description:
*	This routine returns a pointer to the character string value of the
*	specified keyword in a PDS label.  Quotes (single or double) are
*	stripped away if present.
*
*	What section of the label is searched depends on the values of the
*	ntable and ncolumn parameters.  If ntable is zero, then only the
*	keywords at the top of the PDS label (above any PDS OBJECTs) are
*	searched.  If ntable is nonzero but ncolumn is zero, then the keywords
*	inside the TABLE/SERIES object but above the COLUMN objects are
*	searched, followed by the keywords at the top of the label.  If both
*	ntable and nseries are nonzero, then the keywords in the selected
*	COLUMN object are searched, followed by the keywords in the selected
*	TABLE/SERIES object, followed by the keywords at the top of the label.
*
*	If the keyword is not found in the PDS label, or is found but is not a
*	valid string, the default value is returned.  In this case, error code
*	PRO_EVALUATION_FAILURE if the raise_error parameter is TRUE; otherwise
*	no error condition is raised.
*$ External_references:
*	Profile toolkit, Object Access library.
*$ Side_effects:
*	none
*$ Examples:
*	Suppose the PDS label associated with an object looks like this:
*
*	FOO		= 313
*	OBJECT		= SERIES
*	  FOO		= ABC
*	  BAR		= 999
*	  OBJECT	= COLUMN
*	    FOO		= "Bar"
*	  END_OBJECT	= COLUMN
*	END_OBJECT	= SERIES
*	END
*
*	Then Pro_LabelString(label, 1, 1, "FOO", "xx", TRUE) returns "Bar";
*	     Pro_LabelString(label, 1, 0, "FOO", "xx", TRUE) returns "ABC";
*	     Pro_LabelString(label, 0, 0, "FOO", "xx", TRUE) returns "313";
*	     Pro_LabelString(label, 1, 1, "BAR", "xx", TRUE) returns "999";
*	     Pro_LabelString(label, 1, 0, "BAR", "xx", TRUE) returns "999";
*	     Pro_LabelString(label, 0, 0, "BAR", "xx", TRUE) raises
*			PRO_EVALUATION_FAILURE and returns "xx";
*	     Pro_LabelString(label, 0, 0, "BAR", "xx", FALSE) returns "xx";
*$ Error_handling:
*	Profile library error handling is in effect.
*
*	Conditions raised:
*	PRO_CLASS_ERROR		if object is NULL or is not a PDS label.
*	PRO_DOMAIN_ERROR	if the table/column index is out of range.
*	PRO_EVALUATION_FAILURE	raised optionally, if the named keyword is not
*				found or is not a valid string.
*$ Limitations:
*	Returned strings are limited to 255 characters, plus final null
*	character.
*$ Author_and_institution:
*	Mark R. Showalter
*	NASA/Ames Research Center
*$ Version_and_date:
*	1.0: March 1998
*$ Change_history:
*	none
*******************************************************************************/

RL_CHAR		*Pro_LabelString(object, ntable, ncolumn, keyword, dfault,
		raise_error)
PRO_OBJECT	*object;
RL_INT4		ntable, ncolumn;
RL_CHAR		*keyword, *dfault;
RL_BOOL		raise_error;
{
ZPRO_COLUMN	*column;
ZPRO_TABLE	*table;
ZPRO_LABEL	*label;
RL_BOOL         status;

    /* Anticipate failure */
    strncpy(temp_name, dfault, TEMP_MAXLEN);
    temp_name[TEMP_MAXLEN] = '\0';

    if (ntable > 0) {

    /* Search column object if necessary */
	if (ncolumn > 0) {
	    column = ZPro_ColumnPtr(object, ntable, ncolumn);
	    if (column == NULL) return temp_name;

	    status = ZPro_GetString(column->odltree, keyword,
	                            temp_name, TEMP_MAXLEN);
	    if (status) return temp_name;
	}

    /* Search table object if necessary */
	table = ZPro_TablePtr(object, ntable);
	if (table == NULL) return temp_name;

        status = ZPro_GetString(table->odltree, keyword,
	                        temp_name, TEMP_MAXLEN);
        if (status) return temp_name;
    }

    /* Search root object if necessary */
    label = ZPro_LabelPtr(object);
    if (label == NULL) return temp_name;

    status = ZPro_GetString(label->odltree, keyword, temp_name, TEMP_MAXLEN);
    if (status) return temp_name;

    /* Raise error if necessary */
    if (raise_error) {
	(void) sprintf(xpro_message, "\
keyword not found or not a valid string\n\
label file = \"%s\"\n\
table = %d; column = %d; keyword = \"%s\"",
		label->filename, ntable, ncolumn, keyword);

	RL_RaiseError("PRO_EVALUATION_FAILURE", xpro_message);
    }

    return temp_name;
}

/*
********************************************************************************
* PROGRAMMER ROUTINES
********************************************************************************
* XPro_LabelInfo(object, ntable, ncolumn, tabletree, columntree,
*		rows, items, x1, x2, dx, xname, yname,
*		missing, invalid, offset, scale)
*
* This routine fetches information on a given table and column.
*
* Input:
*	object		PDS label object.
*	ntable		table index [1...n].
*	column		column index [1...n].
*
* Output:
*	*tabletree	pointer to the ODLTREE of the table.
*	*columntree	pointer to the ODLTREE of the column.
*	*rows		number of rows.
*	*items		number of items.
*	*x1, *x2, *dx	column sampling.
*	xname		name of the x-coordinate.
*	yname		name of the y-coordinate.
*	*missing	missing flag value.
*	*invalid	invalid flag value.
*	*offset		offset to apply to tabulated values.
*	*scale		scale factor to apply to tabulated values.
*
* Return:		TRUE if all is well; FALSE if an error occurred.
*
* Errors:
*	PRO_CLASS_ERROR		if object is NULL or not a PDS label object.
*	PRO_DOMAIN_ERROR	if the table/column index is out of range.
*******************************************************************************/

RL_BOOL XPro_LabelInfo(object, ntable, ncolumn, tabletree, columntree,
		rows, items, x1, x2, dx, xname, yname,
		missing, invalid, offset, scale)
PRO_OBJECT	*object;
RL_INT4		ntable, ncolumn, *rows, *items;
RL_FLT8		*x1, *x2, *dx, *missing, *invalid, *offset, *scale;
RL_VOID		**tabletree, **columntree;
RL_CHAR		**xname, **yname;
{
ZPRO_COLUMN	*column;
ZPRO_TABLE	*table;

    column = (ZPRO_COLUMN *) ZPro_ColumnPtr(object, ntable, ncolumn);
    if (column == NULL) return FALSE;

    *items	= column->items;
    *missing	= column->missing;
    *invalid	= column->invalid;
    *offset	= column->offset;
    *scale	= column->scale;
    *yname	= column->name;
    *columntree = (RL_VOID *) column->odltree;

    table = ZPro_TablePtr(object, ntable);
    *rows	= table->nrows;
    *x1		= table->x1;
    *x2		= table->x2;
    *dx		= table->dx;
    *xname	= table->xname;
    *tabletree	= (RL_VOID *) table->odltree;

    return TRUE;
}

/*
********************************************************************************
* INTERNAL ROUTINES
********************************************************************************
* ZPro_FreeLabel(pointer)
*
* This routine closes the PDS label and frees the data structures in memory
* associated with it.
*
* Input:
*	label		pointer to the PDS label object.
*
* Side Effects:		memory is freed.
*******************************************************************************/

static void	ZPro_FreeLabel(pointer)
RL_VOID		*pointer;
{
ZPRO_LABEL	*label;
RL_INT4		i, j;

    label = (ZPRO_LABEL *) pointer;
    if (label == NULL) return;

    if (label->tables != NULL) {
	for (i=0; intables; i++) XRL_Free(label->tables[i].columns);
	XRL_Free(label->tables);
    }

    OdlFreeTree(label->odltree);
    XRL_Free(label);
}

/*
********************************************************************************
* ZPro_PrintLabel(pointer)
*
* This routine prints out information about a PDS label object.
*
* Input:
*	pointer		pointer to the PDS label object.
*******************************************************************************/

static void	ZPro_PrintLabel(pointer)
RL_VOID		*pointer;
{
ZPRO_LABEL	*label;
ZPRO_TABLE	*table;
ZPRO_COLUMN	*column;
RL_INT4		i, j;

    label = (ZPRO_LABEL *) pointer;

    /* Make sure object is not NULL */
    if (label == NULL) {
        printf("PRINT ERROR: PDS label pointer is NULL\n");
        return;
    }

    /* Make sure object is a PDS label */
    if (label->class.id != XPRO_LABEL_CLASS) {
        printf("PRINT ERROR: Object is not a PDS label\n");
        return;
    }

    /* Print object info... */
    for (i=1; i <= label->ntables; i++) {
	table = &(label->tables[i-1]);

	printf("\nTable #%d: %s\n", i, table->name);
	printf("  rows  = %d (%g to %g by %g)\n",
			table->nrows, table->x1, table->x2, table->dx);
	printf("  xname = %s\n", table->xname);

	for (j=1; j <= table->ncolumns; j++) {
	    column = &(table->columns[j-1]);

	    printf("  Column #%d: %s\n", j, column->name);
	    if (column->items != 1)
		printf("    items   = %d\n", column->items);
	    if (column->missing != -HUGE_VAL)
		printf("    missing = %g\n", column->missing);
	    if (column->invalid != -HUGE_VAL)
		printf("    invalid = %g\n", column->invalid);
	    if (column->offset != 0. || column->scale != 1.)
		printf("    scaling = %g * x + %g\n",
			column->scale, column->offset);
	}
    }
}

/*
********************************************************************************
* ZPro_LabelPtr(object)
*
* This internal routine returns a pointer to the object's ZPRO_LABEL data
* structure.
*
* Input:
*	object		pointer to a PDS label object.
*
* Return:		pointer to ZPRO_LABEL structure, or NULL on error.
*
* Errors:
*	PRO_CLASS_ERROR		if object is NULL or not a PDS label.
*******************************************************************************/

static ZPRO_LABEL	*ZPro_LabelPtr(object)
PRO_OBJECT		*object;
{
ZPRO_LABEL		*label;

    /* Find PDS label object pointer */
    label = (ZPRO_LABEL *) XPro_ObjectPtr(object);

    /* Make sure object is not NULL */
    if (label == NULL) {
	XPro_NullError("PDS label", object);
	return NULL;
    }

    /* Make sure object is a PDS label */
    if (label->class.id != XPRO_LABEL_CLASS) {
	XPro_ClassError("PDS label", object);
	return NULL;
    }

    return (ZPRO_LABEL *) object->class.pointer;
}

/*
********************************************************************************
* ZPro_TablePtr(object, ntable)
*
* This internal routine returns a pointer to the a selected ZPRO_TABLE data
* structure.
*
* Input:
*	object		pointer to a PDS label object.
*	ntable		table index [1...n].
*
* Return:		pointer to ZPRO_TABLE structure, or NULL on error.
*
* Errors:
*	PRO_CLASS_ERROR		if object is NULL or not a PDS label.
*	PRO_DOMAIN_ERROR	if the table index is out of range.
*******************************************************************************/

static ZPRO_TABLE	*ZPro_TablePtr(object, ntable)
PRO_OBJECT		*object;
RL_INT4			ntable;
{
ZPRO_LABEL		*label;

    /* Find PDS label object pointer */
    label = ZPro_LabelPtr(object);
    if (label == NULL) return NULL;

    /* Check the table index */
    if (ntable < 1 || ntable > label->ntables) {
	XPro_IDomainError("table index", object, 1, label->ntables, ntable);
	return NULL;
    }

    return &(label->tables[ntable-1]);
}

/*
********************************************************************************
* ZPro_ColumnPtr(object, ntable, ncolumn)
*
* This internal routine returns a pointer to a selected ZPRO_COLUMN data
* structure.
*
* Input:
*	object		pointer to a PDS label object.
*	ntable		table index [1...n].
*	ncolumn		column index [1...n].
*
* Return:		pointer to ZPRO_LABEL structure, or NULL on error.
*
* Errors:
*	PRO_CLASS_ERROR		if object is NULL or not a PDS label.
*	PRO_DOMAIN_ERROR	if the table/column index is out of range.
*******************************************************************************/

static ZPRO_COLUMN	*ZPro_ColumnPtr(object, ntable, ncolumn)
PRO_OBJECT		*object;
RL_INT4			ntable, ncolumn;
{
ZPRO_TABLE		*table;

    table = ZPro_TablePtr(object, ntable);
    if (table == NULL) return NULL;

    /* Check the column index */
    if (ncolumn < 1 || ncolumn > table->ncolumns) {
	XPro_IDomainError("column index", object, 1, table->ncolumns, ncolumn);
	return NULL;
    }

    return &(table->columns[ncolumn-1]);
}

/*
********************************************************************************
* ZPro_GetParam(odltree, name, ptr)
*
* This internal routine finds a specified keyword in a PDS object.
*
* Input:
*	odltree		pointer to the ODL tree.
*	name		name of keyword for which to search.
*	ptr		pointer where the resultant string is stored.
*
* Return:		TRUE if keyword is found; FALSE otherwise.
*******************************************************************************/

static RL_BOOL	ZPro_GetParam(odltree, name, ptr)
ODLTREE		odltree;
RL_CHAR		*name;
RL_CHAR		**ptr;
{
KEYWORD		*kwdptr;
RL_CHAR 	*string;

    kwdptr = OdlFindKwd(odltree, name, NULL, (unsigned long) 0,
		ODL_THIS_OBJECT);

    string = OdlGetKwdName(kwdptr);
    if (string == NULL) {
	*ptr = NULL;
	return FALSE;
    }

    *ptr = OdlGetKwdValue(kwdptr);
    return (*ptr != NULL);
}

/*
********************************************************************************
* ZPro_GetInt(odltree, name, value)
*
* This internal routine finds the integer value of a specified keyword in a PDS
* label.
*
* Input:
*	odltree		pointer to the object.
*	name		name of keyword for which to search.
*
* Output{
*	*value		value of integer, unchanged on error.
*
* Return:		TRUE if value is found and is a valid integer;
*			FALSE otherwise.
*******************************************************************************/

static RL_BOOL	ZPro_GetInt(odltree, name, value)
ODLTREE		odltree;
RL_CHAR		*name;
RL_INT4		*value;
{
RL_BOOL		status;
RL_CHAR		*string;
char		*ptr;
RL_INT4		rval;

    status = ZPro_GetParam(odltree, name, &string);
    if (!status) return FALSE;

    rval = strtol(string, &ptr, 10);

    if ((rval == 0) && (string == ptr)) {
	return FALSE;
    } else {
	*value = rval;
	return TRUE;
    }
}

/*
********************************************************************************
* ZPro_GetFloat(odltree, name, value)
*
* This internal routine finds the floating point value of a specified keyword in
* a PDS label.
*
* Input:
*	odltree		pointer to the object.
*	name		name of keyword for which to search.
*
* Output:
*	*value		floating-point value; unchanged on error.
*
* Return:		TRUE if value is found and is a valid float;
*			FALSE otherwise.
*******************************************************************************/

static RL_BOOL	ZPro_GetFloat(odltree, name, value)
ODLTREE		odltree;
RL_CHAR		*name;
RL_FLT8		*value;
{
RL_BOOL		status;
RL_CHAR		*string;
char		*ptr;
RL_FLT8		rval;

    status = ZPro_GetParam(odltree, name, &string);
    if (!status) {
	return FALSE;
    }

    rval = strtod(string, &ptr);

    if ((rval == 0.) && (string == ptr)) {
	return FALSE;
    } else {
	*value = rval;
	return TRUE;
    }
}

/*
********************************************************************************
* ZPro_GetString(odltree, name, value, maxlen)
*
* This internal routine finds the string value of a specified keyword in a PDS
* object.  It strips away surrounding quotes if necessary.
*
* Input:
*	odltree		pointer to the ODL tree.
*	name		name of keyword for which to search.
*	maxlen		maximum string length returned, excluding final '\0'.
*
* Output:
*	*value		string found, truncated if necessary; unchanged on
*			error.
*
* Return:		TRUE if value is found; FALSE otherwise.
*******************************************************************************/

static RL_BOOL	ZPro_GetString(odltree, name, value, maxlen)
ODLTREE		odltree;
RL_CHAR		*name, *value;
RL_INT4		maxlen;
{
RL_BOOL		status;
RL_CHAR		*string;
RL_INT4		len;

    status = ZPro_GetParam(odltree, name, &string);
    if ((!status) || (string == NULL)) {
	return FALSE;
    }

    if ((string[0] == '\"') || (string[0] == '\'')) {
	len = strlen(string) - 2;
	if (len	> maxlen) len = maxlen;
	strncpy(value, &string[1], len);
	value[len] = '\0';
    } else {
	strncpy(value, &string[0], maxlen);
	value[maxlen] = '\0';
    }

    return TRUE;
}

/*
********************************************************************************
* ZPro_DefInt(odltree, name, dfault, value)
*
* This internal routine finds the integer value of a specified keyword in a PDS
* label.  If the value is not found, it returns a default value.
*
* Input:
*	odltree		pointer to the object.
*	name		name of keyword for which to search.
*	dfault		default integer value.
*	*value		value of integer.
*******************************************************************************/

static void ZPro_DefInt(odltree, name, dfault, value)
ODLTREE	odltree;
RL_CHAR	*name;
RL_INT4	dfault, *value;
{
RL_BOOL	status;

    status = ZPro_GetInt(odltree, name, value);
    if (!status) *value = dfault;
}

/*
********************************************************************************
* ZPro_DefFloat(odltree, name, dfault, value)
*
* This internal routine finds the floating-point value of a specified keyword in
* a PDS label.  If the value is not found, it returns a default value.
*
* Input:
*	odltree		pointer to the object.
*	name		name of keyword for which to search.
*	dfault		default floating-point value.
*	*value		floating-point value found.
*******************************************************************************/

static void ZPro_DefFloat(odltree, name, dfault, value)
ODLTREE	odltree;
RL_CHAR	*name;
RL_FLT8	dfault, *value;
{
RL_BOOL	status;

    status = ZPro_GetFloat(odltree, name, value);
    if (!status) *value = dfault;
}

/*
********************************************************************************
* ZPro_DefFloat2(odltree, name1, name2, dfault, value)
*
* This internal routine finds the floating-point value of either of a specified
* pair of possible keywords in a PDS label.  If neither value is found, it
* returns a default value.
*
* Input:
*	odltree		pointer to the object.
*	name1, name2	names of keywords for which to search.
*	dfault		default floating-point value.
*	*value		floating-point value found.
*******************************************************************************/

static void ZPro_DefFloat2(odltree, name1, name2, dfault, value)
ODLTREE	odltree;
RL_CHAR	*name1, *name2;
RL_FLT8	dfault, *value;
{
RL_BOOL	status;

    status = ZPro_GetFloat(odltree, name1, value);
    if (status) return;

    ZPro_DefFloat(odltree, name2, dfault, value);
}

/*
********************************************************************************
* ZPro_DefString(odltree, name, dfault, value, maxlen)
*
* This internal routine finds the string value of a specified keyword in a PDS
* object.  It strips away surrounding quotes if necessary.  If the value is not
* found, a default string is returned.
*
* Input:
*	odltree		pointer to the ODL tree.
*	name		name of keyword for which to search.
*	*dfault		default string.
*	*value		string found, truncated if necessary.
*	maxlen		maximum string length returned, excluding final '\0'.
*******************************************************************************/

static void ZPro_DefString(odltree, name, dfault, value, maxlen)
ODLTREE	odltree;
RL_CHAR	*name, *dfault, *value;
RL_INT4	maxlen;
{
RL_BOOL	status;

    status = ZPro_GetString(odltree, name, value, maxlen);
    if (!status) {
	strncpy(value, dfault, maxlen);
	value[maxlen] = '\0';
    }
}

/*
********************************************************************************
* ZPro_DefName(odltree, name, unit, dfault, value, maxlen)
*
* This internal routine finds the string value of a specified keyword and
* merges it with an optional set of units in a PDS object.  It strips away any
* surrounding quotes if necessary.  If the value is not found, a default string
* is returned.
*
* Input:
*	odltree		pointer to the ODL tree.
*	name		name keyword for which to search.
*	name		unit keyword for which to search.
*	*dfault		default string.
*	*value		string found, truncated if necessary.
*	maxlen		maximum string length returned, excluding final '\0'.
*******************************************************************************/

static void ZPro_DefName(odltree, name, unit, dfault, value, maxlen)
ODLTREE		odltree;
RL_CHAR		*name, *unit, *dfault, *value;
RL_INT4		maxlen;
{
RL_CHAR		temp1[PRO_NAMELEN+1], temp2[PRO_NAMELEN+1];

    ZPro_DefString(odltree, name, dfault, temp1, PRO_NAMELEN);
    ZPro_DefString(odltree, unit, "N/A",  temp2, PRO_NAMELEN);

    if (strcmp(temp2, "N/A") == 0) {
	strncpy(value, temp1, maxlen);
    } else {
	(void) sprintf(xpro_message, "%s (%s)", temp1, temp2);
	strncpy(value, xpro_message, maxlen);
    }

    value[maxlen] = '\0';
}

/*
********************************************************************************
* FORTRAN INTERFACE ROUTINES
********************************************************************************
*$ Component_name:
*	FPro_OpenLabel (label.c, fprofile.for)
*$ Abstract:
*	This routine opens the specified PDS label file and creates a label
*	object.
*$ Keywords:
*	PROFILE, LABEL
*	FORTRAN, PUBLIC, SUBROUTINE
*$ Declarations:
*	integer*4 function FPro_OpenLabel(labelfile)
*	character*(*)	labelfile
*$ Inputs:
*	labelfile	name of PDS label file.
*$ Outputs:
*	none
*$ Returns:
*	a FORTRAN pointer to the new label object.
*$ Detailed_description:
*	This routine opens the specified PDS label file and creates a label
*	object.  It parses the label to find the TABLE and SERIES objects.  Use
*	Pro_ColumnSeries() (see column.c) to create a series object from one of
*	the columns.
*$ External_references:
*	Profile toolkit, Object Access library.
*$ Side_effects:
*	Memory is allocated.  The label file is opened.
*$ Examples:
*	This snippet of code creates a label object for a PDS file called
*	"table.tab":
*
*	integer*4	label
*
*	label = FPro_OpenLabel('table.tab')
*$ Error_handling:
*	Profile library error handling is in effect.
*
*	Conditions raised:
*	PRO_SETUP_FAILURE	if the label cannot be read or parsed or has no
*				TABLE or SERIES objects.
*$ Limitations:
*	file names are limited to 255 characters.
*$ Author_and_institution:
*	Mark R. Showalter
*	NASA/Ames Research Center
*$ Version_and_date:
*	1.0: March 1998
*$ Change_history:
*	none
********************************************************************************
* Note: GPro_OpenLabel() defined here is the intermediary routine between
* FPro_OpenLabel() and Pro_OpenLabel(), allowing for the fact that strings
* cannot be passed directly between FORTRAN and C.  See fprofile.for for the
* rest of the code.
*
* integer*4 function GPro_OpenLabel(labelfile)
* byte		labelfile(*)
*******************************************************************************/

RL_INT4 FORTRAN_NAME(gpro_openlabel) (labelfile)
RL_CHAR *labelfile;
{
RL_VOID *ptr;
RL_INT4 index;

    /* Call function */
    ptr = (RL_VOID *) Pro_OpenLabel(labelfile);
    if (ptr == NULL) return 0;

    /* Save new pointer */
    index = FORT_AddPointer(ptr);
    if (index == 0) Pro_FreeObject((PRO_OBJECT *) ptr);

    return index;
}

/*
********************************************************************************
*$ Component_name:
*	FPro_LabelCount (label.c)
*$ Abstract:
*	This routine returns the number of tables in a PDS label object, the
*	number of columns in a table, or the number of items in a column.
*$ Keywords:
*	PROFILE, SERIES, LABEL
*	FORTRAN, PUBLIC, SUBROUTINE
*$ Declarations:
*	integer*4 function FPro_LabelCount(object, ntable, ncolumn)
*	integer*4 	object, ntable, ncolumn
*$ Inputs:
*	object		FORTRAN pointer to the PDS label object.
*	ntable		index of the selected table (0 or 1...n).
*	ncolumn		index of the selected column (0 or 1...n).
*$ Outputs:
*	none
*$ Returns:
*	If ntable is zero, this is the number of tables in the label;
*	If ncolumn is zero, this is the number of columns in the selected table;
*	Otherwise, this is the number of items in the selected column.
*$ Detailed_description:
*	This routine returns the number of tables in a PDS label object, the
*	number of columns in a table, or the number of items in a column.
*
*	The quantity returned depends on the which input parameters are set to
*	zero.  If ntable is zero, the total number of PDS TABLE and SERIES
*	objects is returned.  Otherwise, ntable is the index (starting with 1)
*	of the selected table.  If ncolumn is zero, the number of PDS COLUMN
*	objects in the selected table is returned.  Otherwise, ncolumn is the
*	index (starting with 1) of the selected column and the number of ITEMs
*	in the column is returned.
*$ External_references:
*	Profile toolkit
*$ Side_effects:
*	none
*$ Examples:
*	Suppose the PDS label associated with an object looks like this:
*
*	^TIME_SERIES	= "FOOBAR.TAB"
*	^DATA_TABLE	= "FOOBAR.DAT"
*	^IMAGE		= "FOOBAR.IMG"
*	OBJECT		= TIME_SERIES
*	  ... (3 columns defined, each with 1 item)
*	END_OBJECT	= TIME_SERIES
*	OBJECT		= DATA_TABLE
*	  ... (1 column defined, with 600 items)
*	END_OBJECT	= DATA_TABLE
*	OBJECT		= IMAGE
*	  ...
*	END_OBJECT	= IMAGE
*	END
*
*	Then FPro_LabelCount(label, 0, 0) returns 2 (number of tables/series);
*	     FPro_LabelCount(label, 1, 0) returns 3 (columns in TIME_SERIES);
*	     FPro_LabelCount(label, 1, 1) returns 1 (items in column);
*	     FPro_LabelCount(label, 2, 1) returns 600 (items in column);
*$ Error_handling:
*	Profile library error handling is in effect.
*
*	Conditions raised:
*	PRO_CLASS_ERROR		if object is NULL or is not a PDS label.
*	PRO_DOMAIN_ERROR	if the table or column index is out of range.
*	FORTRAN_POINTER_ERROR	if object is not a valid FORTRAN object pointer.
*$ Limitations:
*	none
*$ Author_and_institution:
*	Mark R. Showalter
*	NASA/Ames Research Center
*$ Version_and_date:
*	1.0: March 1998
*$ Change_history:
*	none
*******************************************************************************/

RL_INT4 FORTRAN_NAME(fpro_labelcount) (object, ntable, ncolumn)
RL_INT4 *object;
RL_INT4 *ntable, *ncolumn;
{
RL_VOID *ptr;

    /* Look up label pointer */
    ptr = FORT_GetPointer(*object);
    if (ptr == NULL) return 0;

    /* Call function */
    return Pro_LabelCount((PRO_OBJECT *) ptr, *ntable, *ncolumn);
}

/*
********************************************************************************
*$ Component_name:
*	FPro_LabelName (label.c, fprofile.for)
*$ Abstract:
*	This routine returns the name of the specified table or column.
*$ Keywords:
*	PROFILE, SERIES, LABEL
*	FORTRAN, PUBLIC, SUBROUTINE
*$ Declarations:
*	subroutine FPro_LabelName(object, ntable, ncolumn, name)
*	integer*4	object, ntable, ncolumn
*	character*(*)	name
*$ Inputs:
*	object		FORTRAN pointer to the PDS label object.
*	ntable          index of selected table (1...n).
*	ncolumn		index of the selected column (0 or 1...n).
*$ Outputs:
*	name		desired name.  If ncolumn==0, this is the name of the
*			selected table; otherwise, this is the name of the
*			selected column.
*$ Returns:
*	none
*$ Detailed_description:
*	This routine returns the name of the specified table or column.
*
*	The quantity returned depends on the which input parameters are set to
*	zero.  If ncolumn is zero, the name of the PDS TABLE or SERIES object is
*	returned; otherwise, ncolumn is the index (starting with 1) of the
*	selected column and the routine returns the column's name.
*
*	COLUMN names are defined by the PDS label's NAME field, followed by a
*	space and (if present) the PDS label's UNIT field in parentheses.
*$ External_references:
*	Profile toolkit
*$ Side_effects:
*	none
*$ Examples:
*	Suppose the PDS label associated with an object looks like this:
*
*	^SERIES				= "PS1G02.TAB"
*	OBJECT				= SERIES
*	  NAME				= OCCULTATION_GEOMETRY
*	  SAMPLING_PARAMETER_NAME       = RECORD_INDEX
*	  SAMPLING_PARAMETER_UNIT       = 'N/A'
*	  START_SAMPLING_PARAMETER      = -16.
*	  STOP_SAMPLING_PARAMETER       = 1296.
*	  SAMPLING_PARAMETER_INTERVAL	= 1.0
*	  OBJECT			= COLUMN
*	    NAME			= RECORD_INDEX
*	    UNIT			= 'N/A'
*	  END_OBJECT			= COLUMN
*	  OBJECT			= COLUMN
*	    NAME			= INTERCEPT_RADIUS
*	    UNIT			= "km"
*	  END_OBJECT			= COLUMN
*	END_OBJECT			= SERIES
*	END
*
*	Then FPro_LabelName(label, 1, 0, name) sets name='OCCULTATION_GEOMETRY';
*	     FPro_LabelName(label, 1, 1, name) sets name='RECORD_INDEX';
*	     FPro_LabelName(label, 1, 2, name) sets name='INTERCEPT_RADIUS (km)'
*$ Error_handling:
*	Profile library error handling is in effect.
*
*	Conditions raised:
*	PRO_CLASS_ERROR		if object is NULL or is not a PDS label.
*	PRO_DOMAIN_ERROR	if the table or column index is out of range.
*	FORTRAN_POINTER_ERROR	if object is not a valid FORTRAN pointer.
*$ Limitations:
*	none
*$ Author_and_institution:
*	Mark R. Showalter
*	NASA/Ames Research Center
*$ Version_and_date:
*	1.0: March 1998
*$ Change_history:
*	none
********************************************************************************
* Note: GPro_LabelName() defined here is the intermediary routine between
* FPro_LabelName() and Pro_LabelName(), allowing for the fact that strings
* cannot be passed directly between FORTRAN and C.  See fprofile.for for the
* rest of the code.
*
* subroutine GPro_LabelName(object, ntable, ncolumn, buffer, lbuffer)
* integer*4	object, ntable, ncolumn, lbuffer
* byte		buffer(*)
*******************************************************************************/

void    FORTRAN_NAME(gpro_labelname) (object, ntable, ncolumn, buffer, lbuffer)
RL_INT4 *object, *ntable, *ncolumn, *lbuffer;
RL_CHAR *buffer;
{
RL_VOID *ptr;

    /* Look up label pointer */
    ptr = FORT_GetPointer(*object);
    if (ptr == NULL) {
        buffer[0] = '\0';
        return;
    }

    /* Call function */
    strncpy(buffer, Pro_LabelName((PRO_OBJECT *) ptr, *ntable, *ncolumn),
            *lbuffer-1);
    buffer[*lbuffer-1] = '\0';
}

/*
********************************************************************************
*$ Component_name:
*	FPro_LabelXName (label.c, fprofile.for)
*$ Abstract:
*	This routine returns the name of a table's X-coordinate.
*$ Keywords:
*	PROFILE, SERIES, LABEL
*	FORTRAN, PUBLIC, SUBROUTINE
*$ Declarations:
*	subroutine FPro_LabelXName(object, ntable, name)
*	integer*4	object, ntable
*	character*(*)	name
*$ Inputs:
*	object		FORTRAN pointer to the PDS label object.
*	ntable          index of selected table (1...n).
*$ Outputs:
*	name		desired name, or blank on non-fatal error.
*$ Returns:
*	none
*$ Detailed_description:
*	This routine returns the name of a table's X-coordinate.  Names are
*	defined by the PDS label's SAMPLING_PARAMETER_NAME field, followed by a
*	space and (if present) the PDS label's SAMPLING_PARAMETER_UNIT field in
*	parentheses.
*$ External_references:
*	Profile toolkit
*$ Side_effects:
*	none
*$ Examples:
*	Suppose the PDS label associated with an object looks like this:
*
*	^SERIES				= "PS1G02.TAB"
*	OBJECT				= SERIES
*	  NAME				= OCCULTATION_GEOMETRY
*	  SAMPLING_PARAMETER_NAME       = RECORD_INDEX
*	  SAMPLING_PARAMETER_UNIT       = 'N/A'
*	  START_SAMPLING_PARAMETER      = -16.
*	  STOP_SAMPLING_PARAMETER       = 1296.
*	  SAMPLING_PARAMETER_INTERVAL	= 1.0
*	  OBJECT			= COLUMN
*	    NAME			= RECORD_INDEX
*	    UNIT			= 'N/A'
*	  END_OBJECT			= COLUMN
*	  OBJECT			= COLUMN
*	    NAME			= INTERCEPT_RADIUS
*	    UNIT			= "km"
*	  END_OBJECT			= COLUMN
*	END_OBJECT			= SERIES
*	END
*
*	Then FPro_LabelXName(label, 1, name) sets name='RECORD_INDEX'.
*$ Error_handling:
*	Profile library error handling is in effect.
*
*	Conditions raised:
*	PRO_CLASS_ERROR		if object is NULL or is not a PDS label.
*	PRO_DOMAIN_ERROR	if the table index is out of range.
*	FORTRAN_POINTER_ERROR	if object is not a valid FORTRAN pointer.
*$ Limitations:
*	none
*$ Author_and_institution:
*	Mark R. Showalter
*	NASA/Ames Research Center
*$ Version_and_date:
*	1.0: March 1998
*$ Change_history:
*	none
********************************************************************************
* Note: GPro_LabelXName() defined here is the intermediary routine between
* FPro_LabelXName() and Pro_LabelXName(), allowing for the fact that strings
* cannot be passed directly between FORTRAN and C.  See fprofile.for for the
* rest of the code.
*
* subroutine GPro_LabelXName(object, ntable, buffer, lbuffer)
* integer*4	object, ntable, lbuffer
* byte		buffer(*)
*******************************************************************************/

void    FORTRAN_NAME(gpro_labelxname) (object, ntable, buffer, lbuffer)
RL_INT4 *object, *ntable, *lbuffer;
RL_CHAR *buffer;
{
RL_VOID *ptr;

    /* Look up label pointer */
    ptr = FORT_GetPointer(*object);
    if (ptr == NULL) {
        buffer[0] = '\0';
        return;
    }

    /* Call function */
    strncpy(buffer, Pro_LabelXName((PRO_OBJECT *) ptr, *ntable), *lbuffer-1);
    buffer[*lbuffer-1] = '\0';
}

/*
********************************************************************************
*$ Component_name:
*	FPro_LabelFind (label.c, fprofile.for)
*$ Abstract:
*	This routine returns the index of the named table or column.
*$ Keywords:
*	PROFILE, SERIES, LABEL
*	FORTRAN, PUBLIC, SUBROUTINE
*$ Declarations:
*	integer*4 function FPro_LabelFind(object, ntable, name)
*	integer*4	object, ntable
*	character*(*)	name
*$ Inputs:
*	object		FORTRAN pointer to the PDS label object.
*	ntable          index of selected table (1...n).
*	name		name of the table or column to find.  For columns, this
*			string can optionally exclude units inside parentheses.
*$ Outputs:
*	none
*$ Returns:
*	index (1...n) of the selected table or column; 0 if not found.
*	If ntable is zero, this is the index of the table with the given name;
*	otherwise, this is the index of the column with the given name.
*$ Detailed_description:
*	This routine returns the index of the named table or column.
*
*	The quantity returned depends on the which input parameters are set to
*	zero.  If ntable is zero, the index (starting with 1) of the table with
*	the given name is returned.  Otherwise, ntable is the index of the
*	selected table and the number returned is the index of the column with
*	the given name.  For columns, if the name string does not contain units
*	(inside parentheses), then any units in the column name are ignored.
*$ External_references:
*	Profile toolkit
*$ Side_effects:
*	none
*$ Examples:
*	Suppose the PDS label associated with an object looks like this:
*
*	^SERIES				= "PS1G02.TAB"
*	OBJECT				= SERIES
*	  NAME				= OCCULTATION_GEOMETRY
*	  SAMPLING_PARAMETER_NAME       = RECORD_INDEX
*	  SAMPLING_PARAMETER_UNIT       = 'N/A'
*	  START_SAMPLING_PARAMETER      = -16.
*	  STOP_SAMPLING_PARAMETER       = 1296.
*	  SAMPLING_PARAMETER_INTERVAL	= 1.0
*	  OBJECT			= COLUMN
*	    NAME			= RECORD_INDEX
*	    UNIT			= 'N/A'
*	  END_OBJECT			= COLUMN
*	  OBJECT			= COLUMN
*	    NAME			= INTERCEPT_RADIUS
*	    UNIT			= "km"
*	  END_OBJECT			= COLUMN
*	END_OBJECT			= SERIES
*	END
*
*	Then FPro_LabelFind(label, 0, 'OCCULTATION_GEOMETRY')  returns 1;
*	     FPro_LabelFind(label, 1, 'RECORD_INDEX')          returns 1;
*	     FPro_LabelFind(label, 1, 'INTERCEPT_RADIUS (km)') returns 2;
*	     FPro_LabelFind(label, 1, 'INTERCEPT_RADIUS')      returns 2;
*$ Error_handling:
*	Profile library error handling is in effect.
*
*	Conditions raised:
*	PRO_CLASS_ERROR		if object is NULL or is not a PDS label.
*	PRO_DOMAIN_ERROR	if the table index is out of range.
*	PRO_NOT_FOUND		if no table or column of the given name exists.
*	FORTRAN_POINTER_ERROR	if object is not a valid FORTRAN pointer.
*$ Limitations:
*	none
*$ Author_and_institution:
*	Mark R. Showalter
*	NASA/Ames Research Center
*$ Version_and_date:
*	1.0: March 1998
*$ Change_history:
*	none
********************************************************************************
* Note: GPro_LabelFind() defined here is the intermediary routine between
* FPro_LabelFind() and Pro_LabelFind(), allowing for the fact that strings
* cannot be passed directly between FORTRAN and C.  See fprofile.for for the
* rest of the code.
*
* integer*4 function GPro_LabelFind(object, ntable, buffer)
* integer*4	object
* byte		buffer(*)
*******************************************************************************/

RL_INT4	FORTRAN_NAME(gpro_labelfind) (object, ntable, buffer)
RL_INT4 *object, *ntable;
RL_CHAR *buffer;
{
RL_VOID *ptr;

    /* Look up label pointer */
    ptr = FORT_GetPointer(*object);
    if (ptr == NULL) return 0;

    /* Call function */
    return Pro_LabelFind((PRO_OBJECT *) ptr, *ntable, buffer);
}

/*
********************************************************************************
*$ Component_name:
*	FPro_LabelSampling (label.c)
*$ Abstract:
*	This routine returns the sampling parameters used by a specified table
*	or column.
*$ Keywords:
*	PROFILE, SERIES, LABEL
*	FORTRAN, PUBLIC, SUBROUTINE
*$ Declarations:
*	integer*4 function FPro_LabelSampling(object, ntable, ncolumn, nitem,
*					x1, x2, dx)
*	integer*4	object, ntable, ncolumn, nitem
*	real*8		x1, x2, dx
*$ Inputs:
*	object		FORTRAN pointer to the PDS label object.
*	ntable          index of selected table (1...n).
*	ncolumn		index of the selected column (1...n) or 0 for row
*			sampling.
*	nitem		index of selected item, or 0 for all.
*$ Outputs:
*	x1		first sampling parameter.
*	x2		last sampling parameter.
*	dx		interval between samples.
*$ Returns:
*	the number of samples in selected column/item pair; 0 on error.
*$ Detailed_description:
*	This routine returns the sampling parameters used by a specified table
*	or column.
*
*	If nitem is nonzero, then it is assumed that the only a single item per
*	row is to be used; in this case the sampling parameters for the column
*	match those for the row.  However, if nitem is zero in a column that
*	contains multiple items, then the items are treated as subsamples, so
*	the sample interval is correspondingly reduced.
*
*	Note that the row sampling parameters are returned if ncolumn is zero.
*$ External_references:
*	Profile toolkit
*$ Side_effects:
*	none
*$ Examples:
*	Suppose the PDS label associated with an object looks like this:
*
*	^SERIES				= "PS1G02.TAB"
*	OBJECT				= SERIES
*	  SAMPLING_PARAMETER_NAME       = RECORD_INDEX
*	  SAMPLING_PARAMETER_UNIT       = 'N/A'
*	  START_SAMPLING_PARAMETER      = -16.
*	  STOP_SAMPLING_PARAMETER       = 1296.
*	  SAMPLING_PARAMETER_INTERVAL	= 1.0
*	  OBJECT			= COLUMN
*	    ITEMS			= 1
*	  END_OBJECT			= COLUMN
*	  OBJECT			= COLUMN
*	    ITEMS			= 100
*	  END_OBJECT			= COLUMN
*	END_OBJECT			= SERIES
*	END
*
*	Then FPro_LabelSampling(label, 1, 1, 1, x1, x2, dx)
*			sets x1=-16.d0, x2=1296.d0, dx=1.d0, returns 1313;
*	     FPro_LabelSampling(label, 1, 1, 0, x1, x2, dx)
*			sets x1=-16.d0, x2=1296.d0, dx=1.d0, returns 1313;
*	     FPro_LabelSampling(label, 1, 2, 1, x1, x2, dx)
*			sets x1=-16.d0, x2=1296.d0, dx=1.d0, returns 1313;
*	     FPro_LabelSampling(label, 1, 2, 0, x1, x2, dx)
*			sets x1=-16.d0, x2=1296.99d0, dx=0.01d0, returns 131300
*$ Error_handling:
*	Profile library error handling is in effect.
*
*	Conditions raised:
*	PRO_CLASS_ERROR		if object is NULL or is not a PDS label.
*	PRO_DOMAIN_ERROR	if table, column or item index is out of range.
*	FORTRAN_POINTER_ERROR	if object is not a valid FORTRAN object pointer.
*$ Limitations:
*	none
*$ Author_and_institution:
*	Mark R. Showalter
*	NASA/Ames Research Center
*$ Version_and_date:
*	1.0: March 1998
*$ Change_history:
*	none
*******************************************************************************/

RL_INT4	FORTRAN_NAME(fpro_labelsampling) (object, ntable, ncolumn, nitem,
	                                  x1, x2, dx)
RL_INT4 *object, *ntable, *ncolumn, *nitem;
RL_FLT8	*x1, *x2, *dx;
{
RL_VOID *ptr;

    /* Look up label pointer */
    ptr = FORT_GetPointer(*object);
    if (ptr == NULL) return 0;

    /* Call function */
    return Pro_LabelSampling((PRO_OBJECT *) ptr, *ntable, *ncolumn, *nitem,
                             x1, x2, dx);
}

/*
********************************************************************************
*$ Component_name:
*	FPro_LabelInt (label.c, fprofile.for)
*$ Abstract:
*	This routine returns the integer value of a specified keyword in a PDS
*	label.
*$ Keywords:
*	PROFILE, SERIES, LABEL
*	FORTRAN, PUBLIC, SUBROUTINE
*$ Declarations:
*	integer*4 function FPro_LabelInt(object, table, column,
*					keyword, default, raise_error)
*	integer*4	object, table, column, default
*	character*(*)	keyword
*	logical*4	raise_error
*$ Inputs:
*	object		FORTRAN pointer to the PDS label object.
*	ntable		table index, or 0 to search among top keywords only.
*	ncolumn		column index, or 0 to search among table keywords only.
*	keyword		keyword name.
*	dfault		default value to return on error.
*	raise_error	.TRUE. to raise PRO_EVALUATION_FAILURE on error;
*			.FALSE. otherwise.
*$ Outputs:
*	none
*$ Returns:
*	integer value of the keyword; default value on non-fatal error.
*$ Detailed_description:
*	This routine returns the integer value of a specified keyword in a PDS
*	label.
*
*	What section of the label is searched depends on the values of the
*	ntable and ncolumn parameters.  If ntable is zero, then only the
*	keywords at the top of the PDS label (above any PDS OBJECTs) are
*	searched.  If ntable is nonzero but ncolumn is zero, then the keywords
*	inside the TABLE/SERIES object but above the COLUMN objects are
*	searched, followed by the keywords at the top of the label.  If both
*	ntable and nseries are nonzero, then the keywords in the selected
*	COLUMN object are searched, followed by the keywords in the selected
*	TABLE/SERIES object, followed by the keywords at the top of the label.
*
*	If the keyword is not found in the PDS label, or is found but is not a
*	valid integer, the default value is returned.  In this case, error code
*	PRO_EVALUATION_FAILURE if the raise_error parameter is TRUE; otherwise
*	no error condition is raised.
*$ External_references:
*	Profile toolkit, Object Access library.
*$ Side_effects:
*	none
*$ Examples:
*	Suppose the PDS label associated with an object looks like this:
*
*	FOO		= 1313
*	ABC		= "DEF"
*	OBJECT		= SERIES
*	  FOO		= 1000
*	  BAR		= 999
*	  OBJECT	= COLUMN
*	    FOO		= 3
*	  END_OBJECT	= COLUMN
*	END_OBJECT	= SERIES
*	END
*
*	Then FPro_LabelInt(label, 1, 1, 'FOO', -99, .TRUE.) returns 3;
*	     FPro_LabelInt(label, 1, 0, 'FOO', -99, .TRUE.) returns 1000;
*	     FPro_LabelInt(label, 0, 0, 'FOO', -99, .TRUE.) returns 1313;
*	     FPro_LabelInt(label, 1, 1, 'BAR', -99, .TRUE.) returns 999;
*	     FPro_LabelInt(label, 1, 0, 'BAR', -99, .TRUE.) returns 999;
*	     FPro_LabelInt(label, 0, 0, 'BAR', -99, .TRUE.) raises
*			PRO_EVALUATION_FAILURE and returns -99;
*	     FPro_LabelInt(label, 0, 0, 'BAR', -99, .FALSE.) returns -99;
*	     FPro_LabelInt(label, 0, 0, 'ABC', -99, .TRUE.) raises
*			PRO_EVALUATION_FAILURE and returns -99;
*	     FPro_LabelInt(label, 0, 0, 'ABC', -99, .FALSE.) returns -99;
*$ Error_handling:
*	Profile library error handling is in effect.
*
*	Conditions raised:
*	PRO_CLASS_ERROR		if object is NULL or is not a PDS label.
*	PRO_DOMAIN_ERROR	if the table/column index is out of range.
*	PRO_EVALUATION_FAILURE	raised optionally, if the named keyword is not
*				found or is not a valid integer.
*	FORTRAN_POINTER_ERROR	if object is not a valid FORTRAN pointer.
*$ Limitations:
*	none
*$ Author_and_institution:
*	Mark R. Showalter
*	NASA/Ames Research Center
*$ Version_and_date:
*	1.0: March 1998
*$ Change_history:
*	none
********************************************************************************
* Note: GPro_LabelInt() defined here is the intermediary routine between
* FPro_LabelInt() and Pro_LabelInt(), allowing for the fact that strings cannot
* be passed directly between FORTRAN and C.  See fprofile.for for the rest of
* the code.
*
* integer*4 function GPro_LabelInt(object, ntable, ncolumn, keyword,
*					default, raise_error)
* integer*4	object, ntable, ncolumn, default
* byte		keyword(*)
* logical*4	raise_error
*******************************************************************************/

RL_INT4 FORTRAN_NAME(gpro_labelint) (object, ntable, ncolumn, keyword, dfault,
                                     raise_error)
RL_INT4 *object, *ntable, *ncolumn, *dfault, *raise_error;
RL_CHAR *keyword;
{
RL_VOID *ptr;

    /* Look up label pointer */
    ptr = FORT_GetPointer(*object);
    if (ptr == NULL) return 0;

    /* Call function */
    return Pro_LabelInt((PRO_OBJECT *) ptr, *ntable, *ncolumn, keyword,
                        *dfault, (RL_BOOL) *raise_error);
}

/*
********************************************************************************
*$ Component_name:
*	FPro_LabelFloat (label.c, fprofile.for)
*$ Abstract:
*	This routine returns the floating-point value of a specified keyword in
*	a PDS label.
*$ Keywords:
*	PROFILE, SERIES, LABEL
*	FORTRAN, PUBLIC, SUBROUTINE
*$ Declarations:
*	real*8 function FPro_LabelFloat(object, table, column,
*					keyword, default, raise_error)
*	integer*4 	object, table, column
*	character*(*)	keyword
*	real*8		default
*	logical*4	raise_error
*$ Inputs:
*	object		FORTRAN pointer to the PDS label object.
*	ntable		table index, or 0 to search among top keywords only.
*	ncolumn		column index, or 0 to search among table keywords only.
*	keyword		keyword name.
*	dfault		default value to return on error.
*	raise_error	.TRUE. to raise PRO_EVALUATION_FAILURE on error;
*			.FALSE. otherwise.
*$ Outputs:
*	none
*$ Returns:
*	floating-point value of the keyword; default value on non-fatal error.
*$ Detailed_description:
*	This routine returns the floating-point value of a specified keyword in
*	a PDS label.
*
*	What section of the label is searched depends on the values of the
*	ntable and ncolumn parameters.  If ntable is zero, then only the
*	keywords at the top of the PDS label (above any PDS OBJECTs) are
*	searched.  If ntable is nonzero but ncolumn is zero, then the keywords
*	inside the TABLE/SERIES object but above the COLUMN objects are
*	searched, followed by the keywords at the top of the label.  If both
*	ntable and nseries are nonzero, then the keywords in the selected
*	COLUMN object are searched, followed by the keywords in the selected
*	TABLE/SERIES object, followed by the keywords at the top of the label.
*
*	If the keyword is not found in the PDS label, or is found but is not a
*	valid floating-point number, the default value is returned.  In this
*	case, error code PRO_EVALUATION_FAILURE if the raise_error parameter is
*	TRUE; otherwise no error condition is raised.
*$ External_references:
*	Profile toolkit, Object Access library.
*$ Side_effects:
*	none
*$ Examples:
*	Suppose the PDS label associated with an object looks like this:
*
*	FOO		= 313.
*	ABC		= "DEF"
*	OBJECT		= SERIES
*	  FOO		= 100
*	  BAR		= 999
*	  OBJECT	= COLUMN
*	    FOO		= 3.
*	  END_OBJECT	= COLUMN
*	END_OBJECT	= SERIES
*	END
*
*	Then FPro_LabelFloat(label, 1, 1, 'FOO', -99.d0, .TRUE.) returns 3.d0;
*	     FPro_LabelFloat(label, 1, 0, 'FOO', -99.d0, .TRUE.) returns 100.d0;
*	     FPro_LabelFloat(label, 0, 0, 'FOO', -99.d0, .TRUE.) returns 313.d0;
*	     FPro_LabelFloat(label, 1, 1, 'BAR', -99.d0, .TRUE.) returns 999.d0;
*	     FPro_LabelFloat(label, 1, 0, 'BAR', -99.d0, .TRUE.) returns 999.d0;
*	     FPro_LabelFloat(label, 0, 0, 'BAR', -99.d0, .TRUE.) raises
*			PRO_EVALUATION_FAILURE and returns -99.d0;
*	     FPro_LabelFloat(label, 0, 0, 'BAR', -99.d0, .FALSE.) returns -99.d0;
*	     FPro_LabelFloat(label, 0, 0, 'ABC', -99.d0, .TRUE.) raises
*			PRO_EVALUATION_FAILURE and returns -99.d0;
*	     FPro_LabelFloat(label, 0, 0, 'ABC', -99.d0, .FALSE.) returns -99.d0;
*$ Error_handling:
*	Profile library error handling is in effect.
*
*	Conditions raised:
*	PRO_CLASS_ERROR		if object is NULL or is not a PDS label.
*	PRO_DOMAIN_ERROR	if the table/column index is out of range.
*	PRO_EVALUATION_FAILURE	raised optionally, if the named keyword is not
*				found or is not a valid floating-point number.
*	FORTRAN_POINTER_ERROR	if object is not a valid FORTRAN pointer.
*$ Limitations:
*	none
*$ Author_and_institution:
*	Mark R. Showalter
*	NASA/Ames Research Center
*$ Version_and_date:
*	1.0: March 1998
*$ Change_history:
*	none
********************************************************************************
* Note: GPro_LabelFloat() defined here is the intermediary routine between
* FPro_LabelFloat() and Pro_LabelFloat(), allowing for the fact that strings
* cannot be passed directly between FORTRAN and C.  See fprofile.for for the
* rest of the code.
*
* real*8 function GPro_LabelFloat(object, ntable, ncolumn, keyword,
*					default, raise_error)
* integer*4	object, ntable, ncolumn, raise_error
* byte		keyword(*)
* real*8	default
*******************************************************************************/

RL_FLT8 FORTRAN_NAME(gpro_labelfloat) (object, ntable, ncolumn, keyword,
                                       dfault, raise_error)
RL_INT4 *object, *ntable, *ncolumn, *raise_error;
RL_CHAR *keyword;
RL_FLT8	*dfault;
{
RL_VOID *ptr;

    /* Look up label pointer */
    ptr = FORT_GetPointer(*object);
    if (ptr == NULL) return 0.;

    /* Call function */
    return Pro_LabelFloat((PRO_OBJECT *) ptr, *ntable, *ncolumn, keyword,
                          *dfault, (RL_BOOL) *raise_error);
}

/*
********************************************************************************
*$ Component_name:
*	FPro_LabelString (label.c, fprofile.for)
*$ Abstract:
*	This routine returns a pointer to the character string value of the
*	specified keyword in a PDS label.
*$ Keywords:
*	PROFILE, SERIES, LABEL
*	FORTRAN, PUBLIC, SUBROUTINE
*$ Declarations:
*	subroutine FPro_LabelString(object, table, column,
*					keyword, default, raise_error, value)
*	integer*4	object, table, column
*	character*(*)	keyword, default, value
*	logical*4	raise_error
*$ Inputs:
*	object		FORTRAN pointer to the PDS label object.
*	ntable		table index, or 0 to search among top keywords only.
*	ncolumn		column index, or 0 to search among table keywords only.
*	keyword		keyword name.
*	dfault		default string to return on error.
*	raise_error	.TRUE. to raise PRO_EVALUATION_FAILURE on error;
*			.FALSE. otherwise.
*$ Outputs:
*	value		string containing the value of keyword; default string
*			on error.  The string is truncated if necessary after
*			255 characters.
*$ Returns:
*	none
*$ Detailed_description:
*	This routine returns a pointer to the character string value of the
*	specified keyword in a PDS label.  Quotes (single or double) are
*	stripped away if present.
*
*	What section of the label is searched depends on the values of the
*	ntable and ncolumn parameters.  If ntable is zero, then only the
*	keywords at the top of the PDS label (above any PDS OBJECTs) are
*	searched.  If ntable is nonzero but ncolumn is zero, then the keywords
*	inside the TABLE/SERIES object but above the COLUMN objects are
*	searched, followed by the keywords at the top of the label.  If both
*	ntable and nseries are nonzero, then the keywords in the selected
*	COLUMN object are searched, followed by the keywords in the selected
*	TABLE/SERIES object, followed by the keywords at the top of the label.
*
*	If the keyword is not found in the PDS label, or is found but is not a
*	valid string, the default value is returned.  In this case, error code
*	PRO_EVALUATION_FAILURE if the raise_error parameter is TRUE; otherwise
*	no error condition is raised.
*$ External_references:
*	Profile toolkit, Object Access library.
*$ Side_effects:
*	none
*$ Examples:
*	Suppose the PDS label associated with an object looks like this:
*
*	FOO		= 313
*	OBJECT		= SERIES
*	  FOO		= ABC
*	  BAR		= 999
*	  OBJECT	= COLUMN
*	    FOO		= "Bar"
*	  END_OBJECT	= COLUMN
*	END_OBJECT	= SERIES
*	END
*
*	Then FPro_LabelString(label, 1, 1, 'FOO', 'xx', .TRUE., value)
*			sets value = 'Bar';
*	     FPro_LabelString(label, 1, 0, 'FOO', 'xx', .TRUE., value)
*			sets value = 'ABC';
*	     FPro_LabelString(label, 0, 0, 'FOO', 'xx', .TRUE., value)
*			sets value = '313';
*	     FPro_LabelString(label, 1, 1, 'BAR', 'xx', .TRUE., value)
*			sets value = '999';
*	     FPro_LabelString(label, 1, 0, 'BAR', 'xx', .TRUE., value)
*			sets value = '999';
*	     FPro_LabelString(label, 0, 0, 'BAR', 'xx', .TRUE., value)
*			raises PRO_EVALUATION_FAILURE and sets value = 'xx';
*	     FPro_LabelString(label, 0, 0, 'BAR', 'xx', .FALSE., value)
*			sets value = 'xx'.
*$ Error_handling:
*	Profile library error handling is in effect.
*
*	Conditions raised:
*	PRO_CLASS_ERROR		if object is NULL or is not a PDS label.
*	PRO_DOMAIN_ERROR	if the table/column index is out of range.
*	PRO_EVALUATION_FAILURE	raised optionally, if the named keyword is not
*				found or is not a valid string.
*	FORTRAN_POINTER_ERROR	if object is not a valid FORTRAN pointer.
*$ Limitations:
*	Returned strings are limited to 255 characters.
*$ Author_and_institution:
*	Mark R. Showalter
*	NASA/Ames Research Center
*$ Version_and_date:
*	1.0: March 1998
*$ Change_history:
*	none
********************************************************************************
* Note: GPro_LabelString() defined here is the intermediary routine between
* FPro_LabelString() and Pro_LabelString(), allowing for the fact that strings
* cannot be passed directly between FORTRAN and C.  See fprofile.for for the
* rest of the code.
*
* subroutine GPro_LabelString(object, ntable, ncolumn, keyword, default,
*					raise_error, buffer, lbuffer)
* integer*4	object, ntable, ncolumn, lbuffer, raise_error
* byte		keyword(*), buffer(*), default(*)
*******************************************************************************/

void FORTRAN_NAME(gpro_labelstring) (object, ntable, ncolumn, keyword, dfault,
                                     raise_error, buffer, lbuffer)
RL_INT4 *object, *ntable, *ncolumn, *raise_error, *lbuffer;
RL_CHAR *keyword, *dfault, *buffer;
{
RL_VOID *ptr;
RL_CHAR	*string;

    /* Look up label pointer */
    ptr = FORT_GetPointer(*object);
    if (ptr == NULL) {
	buffer[0] = '\0';
	return;
    }

    /* Call function */
    string = Pro_LabelString((PRO_OBJECT *) ptr, *ntable, *ncolumn, keyword,
                             dfault, (RL_BOOL) *raise_error);

    strncpy(buffer, string, *lbuffer-1);
    buffer[*lbuffer] = '\0';
}

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