SpiceInt lstltc_c ( ConstSpiceChar * string,
SpiceInt n,
SpiceInt lenvals,
const void * array )
/*
-Brief_I/O
VARIABLE I/O DESCRIPTION
-------- --- --------------------------------------------------
string I Upper bound value to search against.
n I Number elements in array.
lenvals I String length.
array I Array of possible lower bounds.
The function returns the index of the last element of array that
is lexically less than string.
-Detailed_Input
string is a string acting as an upper bound: the array element
that is lexically the greatest element less than string
is to be found. Trailing blanks in this bound value are
not significant.
n is the dimension of the array.
lenvals is the declared length of the strings in the input
string array, including null terminators. The input
array should be declared with dimension
[n][lenvals]
array is the array of character strings to be searched.
Trailing blanks in the strings in this array are not
significant. The strings must be sorted in
non-decreasing order. The elements of array need not be
distinct.
-Detailed_Output
The function returns the index of the highest-indexed element in the
input array that is lexically less than string. The routine assumes
the array elements are sorted in non-decreasing order.
If all elements of the input array are greater than or equal to the
specified upper bound string, the function returns -1.
-Parameters
None.
-Exceptions
1) If ndim < 1 the function value is -1. This is not considered
an error.
2) If input key value pointer is null, the error SPICE(NULLPOINTER) will
be signaled. The function returns -1.
3) The input key value may have length zero. This case is not
considered an error.
4) If the input array pointer is null, the error SPICE(NULLPOINTER) will
be signaled. The function returns -1.
5) If the input array string's length is less than 2, the error
SPICE(STRINGTOOSHORT) will be signaled. The function returns -1.
-Files
None.
-Particulars
Note: If you need to find the first element of the array that
is greater than or equal to string, simply add 1 to the
result returned by this function and check to see if the
result is within the array bounds given by n.
-Examples
Let array be a character array of dimension
[5][lenvals]
which contains the following elements:
"BOHR"
"EINSTEIN"
"FEYNMAN"
"GALILEO"
"NEWTON"
Then
lstltc_c ( "NEWTON", 5, lenvals, array ) == 3
lstltc_c ( "EINSTEIN", 5, lenvals, array ) == 0
lstltc_c ( "GALILEO", 5, lenvals, array ) == 2
lstltc_c ( "Galileo", 5, lenvals, array ) == 3
lstltc_c ( "BETHE", 5, lenvals, array ) == -1
-Restrictions
1) The input array is assumed to be sorted in increasing order. If
this condition is not met, the results of bsrchc_c are unpredictable.
2) String comparisons performed by this routine are Fortran-style:
trailing blanks in the input array or key value are ignored.
This gives consistent behavior with CSPICE code generated by
the f2c translator, as well as with the Fortran SPICE Toolkit.
Note that this behavior is not identical to that of the ANSI
C library functions strcmp and strncmp.
-Literature_References
None.
-Author_and_Institution
N.J. Bachman (JPL)
H.A. Neilan (JPL)
W.L. Taber (JPL)
-Version
-CSPICE Version 1.1.0, 07-MAR-2009 (NJB)
This file now includes the header file f2cMang.h.
This header supports name mangling of f2c library
functions.
-CSPICE Version 1.0.0, 22-JUL-2002 (NJB) (HAN) (WLT)
-Index_Entries
last character element less_than
-&
*/
{ /* Begin lstltc_c */
/*
f2c library utility prototypes
*/
logical l_gt (char *a, char *b, ftnlen la, ftnlen lb );
logical l_le (char *a, char *b, ftnlen la, ftnlen lb );
logical l_lt (char *a, char *b, ftnlen la, ftnlen lb );
/*
Local macros
*/
#define ARRAY( i ) ( ( (SpiceChar *)array ) + (i)*lenvals )
/*
Local variables
*/
SpiceInt begin;
SpiceInt end;
SpiceInt items;
SpiceInt j;
SpiceInt keylen;
SpiceInt middle;
/*
Use discovery check-in.
Return immediately if the array dimension is non-positive.
*/
if ( n < 1 )
{
return ( -1 );
}
/*
Make sure the pointer for the key value is non-null
and that the length is adequate.
*/
CHKPTR_VAL ( CHK_DISCOVER, "lstltc_c", string, -1 );
/*
Make sure the pointer for the string array is non-null
and that the length lenvals is sufficient.
*/
CHKOSTR_VAL ( CHK_DISCOVER, "lstltc_c", array, lenvals, -1 );
/*
Return if none of the array's elements are less than the key value.
*/
keylen = strlen(string);
begin = 0;
end = n - 1;
if ( l_le( ( char * )string,
( char * )ARRAY(begin),
( ftnlen )keylen,
( ftnlen )strlen(ARRAY(begin)) ) )
{
return ( -1 );
}
/*
Return if the key string is greater than all of the array's elements.
*/
if ( l_gt( ( char * )string,
( char * )ARRAY(end),
( ftnlen )keylen,
( ftnlen )strlen(ARRAY(end)) ) )
{
return ( end );
}
/*
Do a binary search for the specified key value.
At this point, string is greater than the first element of array and
less than or equal to the last element of array.
*/
items = n;
while ( items > 2 )
{
/*
Check the middle element.
*/
j = items / 2;
middle = begin + j;
/*
Narrow the search area.
*/
if ( l_lt ( (char * ) ARRAY(middle),
(char * ) string,
(ftnlen ) strlen( ARRAY(middle) ),
(ftnlen ) keylen ) )
{
/*
The middle element is less than string.
*/
begin = middle;
}
else
{
end = middle;
}
items = end - begin + 1;
/*
At this point, string is greater than the array element at index
begin and is less than or equal to the element at index end.
*/
}
/*
The element at index begin is the winner.
*/
return ( begin );
} /* End lstltc_c */
/* $Procedure UNIONC ( Union two character sets ) */
/* Subroutine */ int unionc_(char *a, char *b, char *c__, ftnlen a_len,
ftnlen b_len, ftnlen c_len)
{
/* System generated locals */
integer i__1, i__2, i__3;
/* Builtin functions */
integer i_len(char *, ftnlen);
/* Subroutine */ int s_copy(char *, char *, ftnlen, ftnlen);
integer s_cmp(char *, char *, ftnlen, ftnlen);
logical l_lt(char *, char *, ftnlen, ftnlen), l_gt(char *, char *, ftnlen,
ftnlen);
/* Local variables */
integer over, acard, bcard;
extern integer cardc_(char *, ftnlen);
integer ccard;
extern /* Subroutine */ int chkin_(char *, ftnlen);
extern integer sizec_(char *, ftnlen);
integer csize;
extern /* Subroutine */ int scardc_(integer *, char *, ftnlen);
integer apoint, bpoint;
extern /* Subroutine */ int sigerr_(char *, ftnlen), chkout_(char *,
ftnlen), excess_(integer *, char *, ftnlen), setmsg_(char *,
ftnlen), errint_(char *, integer *, ftnlen);
extern logical return_(void);
/* $ Abstract */
/* Union two character sets to form a third set. */
/* $ Disclaimer */
/* THIS SOFTWARE AND ANY RELATED MATERIALS WERE CREATED BY THE */
/* CALIFORNIA INSTITUTE OF TECHNOLOGY (CALTECH) UNDER A U.S. */
/* GOVERNMENT CONTRACT WITH THE NATIONAL AERONAUTICS AND SPACE */
/* ADMINISTRATION (NASA). THE SOFTWARE IS TECHNOLOGY AND SOFTWARE */
/* PUBLICLY AVAILABLE UNDER U.S. EXPORT LAWS AND IS PROVIDED "AS-IS" */
/* TO THE RECIPIENT WITHOUT WARRANTY OF ANY KIND, INCLUDING ANY */
/* WARRANTIES OF PERFORMANCE OR MERCHANTABILITY OR FITNESS FOR A */
/* PARTICULAR USE OR PURPOSE (AS SET FORTH IN UNITED STATES UCC */
/* SECTIONS 2312-2313) OR FOR ANY PURPOSE WHATSOEVER, FOR THE */
/* SOFTWARE AND RELATED MATERIALS, HOWEVER USED. */
/* IN NO EVENT SHALL CALTECH, ITS JET PROPULSION LABORATORY, OR NASA */
/* BE LIABLE FOR ANY DAMAGES AND/OR COSTS, INCLUDING, BUT NOT */
/* LIMITED TO, INCIDENTAL OR CONSEQUENTIAL DAMAGES OF ANY KIND, */
/* INCLUDING ECONOMIC DAMAGE OR INJURY TO PROPERTY AND LOST PROFITS, */
/* REGARDLESS OF WHETHER CALTECH, JPL, OR NASA BE ADVISED, HAVE */
/* REASON TO KNOW, OR, IN FACT, SHALL KNOW OF THE POSSIBILITY. */
/* RECIPIENT BEARS ALL RISK RELATING TO QUALITY AND PERFORMANCE OF */
/* THE SOFTWARE AND ANY RELATED MATERIALS, AND AGREES TO INDEMNIFY */
/* CALTECH AND NASA FOR ALL THIRD-PARTY CLAIMS RESULTING FROM THE */
/* ACTIONS OF RECIPIENT IN THE USE OF THE SOFTWARE. */
/* $ Required_Reading */
/* SETS */
/* $ Keywords */
/* CELLS, SETS */
/* $ Declarations */
/* $ Brief_I/O */
/* VARIABLE I/O DESCRIPTION */
/* -------- --- -------------------------------------------------- */
/* A I First input set. */
/* B I Second input set. */
/* C O Union of A and B. */
/* $ Detailed_Input */
/* A is a set. */
/* B is a set, distinct from A. */
/* $ Detailed_Output */
/* C is a set, distinct from sets A and B, which */
/* contains the union of A and B (that is, all of */
/* the elements which are in A or B or both). */
/* If the size (maximum cardinality) of C is smaller */
/* than the cardinality of the union of A and B, */
/* then only as many items as will fit in C are */
/* included, and an error is signalled. */
/* $ Parameters */
/* None. */
/* $ Particulars */
/* None. */
/* $ Examples */
/* The UNION of two sets contains every element which is */
/* in the first set, or in the second set, or in both sets. */
/* {a,b} union {c,d} = {a,b,c,d} */
/* {a,b,c} {b,c,d} {a,b,c,d} */
/* {a,b,c,d} {} {a,b,c,d} */
/* {} {a,b,c,d} {a,b,c,d} */
/* {} {} {} */
/* The following call */
/* CALL UNIONC ( PLANETS, ASTEROIDS, RESULT ) */
/* places the union of the character sets PLANETS and */
/* ASTEROIDS into the character set RESULT. */
/* The output set must be distinct from both of the input sets. */
/* For example, the following calls are invalid. */
/* CALL UNIONI ( CURRENT, NEW, CURRENT ) */
/* CALL UNIONI ( NEW, CURRENT, CURRENT ) */
/* In each of the examples above, whether or not the subroutine */
/* signals an error, the results will almost certainly be wrong. */
/* Nearly the same effect can be achieved, however, by placing the */
/* result into a temporary set, which is immediately copied back */
/* into one of the input sets, as shown below. */
/* CALL UNIONI ( CURRENT, NEW, TEMP ) */
/* CALL COPYI ( TEMP, NEW ) */
/* $ Restrictions */
/* None. */
/* $ Exceptions */
/* 1) If the union of the two sets causes an excess of elements, the */
/* error SPICE(SETEXCESS) is signalled. */
/* 2) If length of the elements of the output set is < the */
/* maximum of the lengths of the elements of the input */
/* sets, the error SPICE(ELEMENTSTOOSHORT) is signalled. */
/* $ Files */
/* None. */
/* $ Literature_References */
/* None. */
/* $ Author_and_Institution */
/* N.J. Bachman (JPL) */
/* C.A. Curzon (JPL) */
/* W.L. Taber (JPL) */
/* I.M. Underwood (JPL) */
/* $ Version */
/* - SPICELIB Version 1.1.0, 18-JUN-1999 (WLT) */
/* Made CHKOUT calls consistent with CHKIN. */
/* - SPICELIB Version 1.0.1, 10-MAR-1992 (WLT) */
/* Comment section for permuted index source lines was added */
/* following the header. */
/* - SPICELIB Version 1.0.0, 31-JAN-1990 (CAC) (WLT) (IMU) */
/* -& */
/* $ Index_Entries */
/* union two character sets */
/* -& */
/* $ Revisions */
/* - Beta Version 2.0.0, 05-JAN-1989 (NJB) */
/* Error signalled if output set elements are not long enough. */
/* Length must be at least max of lengths of input elements. */
/* Also, calling protocol for EXCESS has been changed. */
/* -& */
/* SPICELIB functions */
/* Local variables */
/* Set up the error processing. */
if (return_()) {
return 0;
}
chkin_("UNIONC", (ftnlen)6);
/* Make sure output set elements are long enough. */
/* Computing MAX */
i__1 = i_len(a, a_len), i__2 = i_len(b, b_len);
if (i_len(c__, c_len) < max(i__1,i__2)) {
setmsg_("Length of output cell is #. Length required to contain res"
"ult is #.", (ftnlen)68);
i__1 = i_len(c__, c_len);
errint_("#", &i__1, (ftnlen)1);
/* Computing MAX */
i__2 = i_len(a, a_len), i__3 = i_len(b, b_len);
i__1 = max(i__2,i__3);
errint_("#", &i__1, (ftnlen)1);
sigerr_("SPICE(ELEMENTSTOOSHORT)", (ftnlen)23);
chkout_("UNIONC", (ftnlen)6);
return 0;
}
/* Find the cardinality of the input sets, and the allowed size */
/* of the output set. */
acard = cardc_(a, a_len);
bcard = cardc_(b, b_len);
csize = sizec_(c__, c_len);
/* Begin with the input pointers at the first elements of the */
/* input sets. The cardinality of the output set is zero. */
/* And there is no overflow so far. */
apoint = 1;
bpoint = 1;
ccard = 0;
over = 0;
/* When the ends of both input sets are reached, we're done. */
while(apoint <= acard || bpoint <= bcard) {
/* If there is still space in the output set, fill it */
/* as necessary. */
if (ccard < csize) {
if (apoint > acard) {
++ccard;
s_copy(c__ + (ccard + 5) * c_len, b + (bpoint + 5) * b_len,
c_len, b_len);
++bpoint;
} else if (bpoint > bcard) {
++ccard;
s_copy(c__ + (ccard + 5) * c_len, a + (apoint + 5) * a_len,
c_len, a_len);
++apoint;
} else if (s_cmp(a + (apoint + 5) * a_len, b + (bpoint + 5) *
b_len, a_len, b_len) == 0) {
++ccard;
s_copy(c__ + (ccard + 5) * c_len, a + (apoint + 5) * a_len,
c_len, a_len);
++apoint;
++bpoint;
} else if (l_lt(a + (apoint + 5) * a_len, b + (bpoint + 5) *
b_len, a_len, b_len)) {
++ccard;
s_copy(c__ + (ccard + 5) * c_len, a + (apoint + 5) * a_len,
c_len, a_len);
++apoint;
} else if (l_gt(a + (apoint + 5) * a_len, b + (bpoint + 5) *
b_len, a_len, b_len)) {
++ccard;
s_copy(c__ + (ccard + 5) * c_len, b + (bpoint + 5) * b_len,
c_len, b_len);
++bpoint;
}
/* Otherwise, stop filling the array, but continue to count the */
/* number of elements in excess of the size of the output set. */
} else {
if (apoint > acard) {
++over;
++bpoint;
} else if (bpoint > bcard) {
++over;
++apoint;
} else if (s_cmp(a + (apoint + 5) * a_len, b + (bpoint + 5) *
b_len, a_len, b_len) == 0) {
++over;
++apoint;
++bpoint;
} else if (l_lt(a + (apoint + 5) * a_len, b + (bpoint + 5) *
b_len, a_len, b_len)) {
++over;
++apoint;
} else if (l_gt(a + (apoint + 5) * a_len, b + (bpoint + 5) *
b_len, a_len, b_len)) {
++over;
++bpoint;
}
}
}
/* Set the cardinality of the output set. */
scardc_(&ccard, c__, c_len);
/* Report any excess. */
if (over > 0) {
excess_(&over, "set", (ftnlen)3);
sigerr_("SPICE(SETEXCESS)", (ftnlen)16);
}
chkout_("UNIONC", (ftnlen)6);
return 0;
} /* unionc_ */
/* $Procedure MAXAC ( Maximum element of array, character ) */
/* Subroutine */ int maxac_(char *array, integer *ndim, char *maxval, integer
*loc, ftnlen array_len, ftnlen maxval_len)
{
/* System generated locals */
integer i__1;
/* Builtin functions */
/* Subroutine */ int s_copy(char *, char *, ftnlen, ftnlen);
logical l_gt(char *, char *, ftnlen, ftnlen);
/* Local variables */
integer i__;
/* $ Abstract */
/* Locate the maximum element of a character array. */
/* $ Disclaimer */
/* THIS SOFTWARE AND ANY RELATED MATERIALS WERE CREATED BY THE */
/* CALIFORNIA INSTITUTE OF TECHNOLOGY (CALTECH) UNDER A U.S. */
/* GOVERNMENT CONTRACT WITH THE NATIONAL AERONAUTICS AND SPACE */
/* ADMINISTRATION (NASA). THE SOFTWARE IS TECHNOLOGY AND SOFTWARE */
/* PUBLICLY AVAILABLE UNDER U.S. EXPORT LAWS AND IS PROVIDED "AS-IS" */
/* TO THE RECIPIENT WITHOUT WARRANTY OF ANY KIND, INCLUDING ANY */
/* WARRANTIES OF PERFORMANCE OR MERCHANTABILITY OR FITNESS FOR A */
/* PARTICULAR USE OR PURPOSE (AS SET FORTH IN UNITED STATES UCC */
/* SECTIONS 2312-2313) OR FOR ANY PURPOSE WHATSOEVER, FOR THE */
/* SOFTWARE AND RELATED MATERIALS, HOWEVER USED. */
/* IN NO EVENT SHALL CALTECH, ITS JET PROPULSION LABORATORY, OR NASA */
/* BE LIABLE FOR ANY DAMAGES AND/OR COSTS, INCLUDING, BUT NOT */
/* LIMITED TO, INCIDENTAL OR CONSEQUENTIAL DAMAGES OF ANY KIND, */
/* INCLUDING ECONOMIC DAMAGE OR INJURY TO PROPERTY AND LOST PROFITS, */
/* REGARDLESS OF WHETHER CALTECH, JPL, OR NASA BE ADVISED, HAVE */
/* REASON TO KNOW, OR, IN FACT, SHALL KNOW OF THE POSSIBILITY. */
/* RECIPIENT BEARS ALL RISK RELATING TO QUALITY AND PERFORMANCE OF */
/* THE SOFTWARE AND ANY RELATED MATERIALS, AND AGREES TO INDEMNIFY */
/* CALTECH AND NASA FOR ALL THIRD-PARTY CLAIMS RESULTING FROM THE */
/* ACTIONS OF RECIPIENT IN THE USE OF THE SOFTWARE. */
/* $ Required_Reading */
/* None. */
/* $ Keywords */
/* ARRAY, SEARCH */
/* $ Declarations */
/* $ Brief_I/O */
/* VARIABLE I/O DESCRIPTION */
/* -------- --- ------------------------------------------------- */
/* ARRAY I Array. */
/* NDIM I Number of elements in ARRAY. */
/* MAXVAL O Maximum value in ARRAY. */
/* LOC O Location of MAXVAL in ARRAY. */
/* $ Detailed_Input */
/* ARRAY is an arbitrary array. */
/* NDIM is the number of elements in ARRAY. */
/* $ Detailed_Output */
/* MAXVAL is the value in array that is greater than or equal */
/* to all other values in the array. If the array */
/* contains more than one element with this value, */
/* the first one is returned. */
/* Elements in character arrays are compared according */
/* to the ASCII collating sequence. */
/* LOC is the location of the maximum element. That is, */
/* MAXVAL contains element ARRAY(LOC). */
/* $ Parameters */
/* None. */
/* $ Exceptions */
/* Error free. */
/* 1) If the array is empty (NDIM is less than one), LOC is zero, and */
/* MAXVAL is not changed. */
/* 2) If the declared length of MAXVAL is too short to contain the */
/* entire element, the element is truncated. (The original value */
/* can be accessed via LOC.) */
/* $ Files */
/* None. */
/* $ Particulars */
/* None. */
/* $ Examples */
/* Let array A contain the following elements. */
/* A(1) = 'Einstein' */
/* A(2) = 'Bohr' */
/* A(3) = 'Feynman' */
/* A(4) = 'Pauli' */
/* A(5) = 'Bardeen' */
/* A(6) = 'Dirac' */
/* Then following the call */
/* CALL MAXAC ( A, 6, MAXVAL, LOC ) */
/* the values of MAXVAL and LOC are 'Pauli' and 4 respectively. */
/* $ Restrictions */
/* None */
/* $ Author_and_Institution */
/* I.M. Underwood (JPL) */
/* $ Literature_References */
/* None */
/* $ Version */
/* - SPICELIB Version 1.0.1, 10-MAR-1992 (WLT) */
/* Comment section for permuted index source lines was added */
/* following the header. */
/* - SPICELIB Version 1.0.0, 31-JAN-1990 (IMU) */
/* -& */
/* $ Index_Entries */
/* maximum element of character array */
/* -& */
/* $ Revisions */
/* - Beta Version 1.0.1, 2-FEB-1989 (IMU) */
/* Missing header sections completed. */
/* -& */
/* Local variables */
if (*ndim <= 0) {
*loc = 0;
return 0;
}
s_copy(maxval, array, maxval_len, array_len);
*loc = 1;
i__1 = *ndim;
for (i__ = 2; i__ <= i__1; ++i__) {
if (l_gt(array + (i__ - 1) * array_len, maxval, array_len, maxval_len)
) {
s_copy(maxval, array + (i__ - 1) * array_len, maxval_len,
array_len);
*loc = i__;
}
}
return 0;
} /* maxac_ */
/* $Procedure ZZEKSCMP ( EK, scalar value comparison ) */
logical zzekscmp_(integer *op, integer *handle, integer *segdsc, integer *
coldsc, integer *row, integer *eltidx, integer *dtype, char *cval,
doublereal *dval, integer *ival, logical *null, ftnlen cval_len)
{
/* System generated locals */
integer i__1;
logical ret_val;
/* Builtin functions */
integer i_len(char *, ftnlen);
logical l_lt(char *, char *, ftnlen, ftnlen), l_gt(char *, char *, ftnlen,
ftnlen);
/* Local variables */
char eltc[1024];
doublereal eltd;
integer elti, unit;
extern /* Subroutine */ int chkin_(char *, ftnlen);
integer cvlen;
logical found, enull;
extern logical failed_(void), matchi_(char *, char *, char *, char *,
ftnlen, ftnlen, ftnlen, ftnlen);
integer cmplen;
doublereal numval;
integer coltyp, strlen;
extern /* Subroutine */ int setmsg_(char *, ftnlen), errint_(char *,
integer *, ftnlen), sigerr_(char *, ftnlen), chkout_(char *,
ftnlen), dashlu_(integer *, integer *), errfnm_(char *, integer *,
ftnlen);
integer rel;
extern /* Subroutine */ int zzekrsc_(integer *, integer *, integer *,
integer *, integer *, integer *, char *, logical *, logical *,
ftnlen), zzekrsd_(integer *, integer *, integer *, integer *,
integer *, doublereal *, logical *, logical *), zzekrsi_(integer *
, integer *, integer *, integer *, integer *, integer *, logical *
, logical *);
/* $ Abstract */
/* Compare a specified scalar EK column entry with a scalar value. */
/* $ Disclaimer */
/* THIS SOFTWARE AND ANY RELATED MATERIALS WERE CREATED BY THE */
/* CALIFORNIA INSTITUTE OF TECHNOLOGY (CALTECH) UNDER A U.S. */
/* GOVERNMENT CONTRACT WITH THE NATIONAL AERONAUTICS AND SPACE */
/* ADMINISTRATION (NASA). THE SOFTWARE IS TECHNOLOGY AND SOFTWARE */
/* PUBLICLY AVAILABLE UNDER U.S. EXPORT LAWS AND IS PROVIDED "AS-IS" */
/* TO THE RECIPIENT WITHOUT WARRANTY OF ANY KIND, INCLUDING ANY */
/* WARRANTIES OF PERFORMANCE OR MERCHANTABILITY OR FITNESS FOR A */
/* PARTICULAR USE OR PURPOSE (AS SET FORTH IN UNITED STATES UCC */
/* SECTIONS 2312-2313) OR FOR ANY PURPOSE WHATSOEVER, FOR THE */
/* SOFTWARE AND RELATED MATERIALS, HOWEVER USED. */
/* IN NO EVENT SHALL CALTECH, ITS JET PROPULSION LABORATORY, OR NASA */
/* BE LIABLE FOR ANY DAMAGES AND/OR COSTS, INCLUDING, BUT NOT */
/* LIMITED TO, INCIDENTAL OR CONSEQUENTIAL DAMAGES OF ANY KIND, */
/* INCLUDING ECONOMIC DAMAGE OR INJURY TO PROPERTY AND LOST PROFITS, */
/* REGARDLESS OF WHETHER CALTECH, JPL, OR NASA BE ADVISED, HAVE */
/* REASON TO KNOW, OR, IN FACT, SHALL KNOW OF THE POSSIBILITY. */
/* RECIPIENT BEARS ALL RISK RELATING TO QUALITY AND PERFORMANCE OF */
/* THE SOFTWARE AND ANY RELATED MATERIALS, AND AGREES TO INDEMNIFY */
/* CALTECH AND NASA FOR ALL THIRD-PARTY CLAIMS RESULTING FROM THE */
/* ACTIONS OF RECIPIENT IN THE USE OF THE SOFTWARE. */
/* $ Required_Reading */
/* EK */
/* $ Keywords */
/* PRIVATE */
/* EK */
/* $ Declarations */
/* $ Disclaimer */
/* THIS SOFTWARE AND ANY RELATED MATERIALS WERE CREATED BY THE */
/* CALIFORNIA INSTITUTE OF TECHNOLOGY (CALTECH) UNDER A U.S. */
/* GOVERNMENT CONTRACT WITH THE NATIONAL AERONAUTICS AND SPACE */
/* ADMINISTRATION (NASA). THE SOFTWARE IS TECHNOLOGY AND SOFTWARE */
/* PUBLICLY AVAILABLE UNDER U.S. EXPORT LAWS AND IS PROVIDED "AS-IS" */
/* TO THE RECIPIENT WITHOUT WARRANTY OF ANY KIND, INCLUDING ANY */
/* WARRANTIES OF PERFORMANCE OR MERCHANTABILITY OR FITNESS FOR A */
/* PARTICULAR USE OR PURPOSE (AS SET FORTH IN UNITED STATES UCC */
/* SECTIONS 2312-2313) OR FOR ANY PURPOSE WHATSOEVER, FOR THE */
/* SOFTWARE AND RELATED MATERIALS, HOWEVER USED. */
/* IN NO EVENT SHALL CALTECH, ITS JET PROPULSION LABORATORY, OR NASA */
/* BE LIABLE FOR ANY DAMAGES AND/OR COSTS, INCLUDING, BUT NOT */
/* LIMITED TO, INCIDENTAL OR CONSEQUENTIAL DAMAGES OF ANY KIND, */
/* INCLUDING ECONOMIC DAMAGE OR INJURY TO PROPERTY AND LOST PROFITS, */
/* REGARDLESS OF WHETHER CALTECH, JPL, OR NASA BE ADVISED, HAVE */
/* REASON TO KNOW, OR, IN FACT, SHALL KNOW OF THE POSSIBILITY. */
/* RECIPIENT BEARS ALL RISK RELATING TO QUALITY AND PERFORMANCE OF */
/* THE SOFTWARE AND ANY RELATED MATERIALS, AND AGREES TO INDEMNIFY */
/* CALTECH AND NASA FOR ALL THIRD-PARTY CLAIMS RESULTING FROM THE */
/* ACTIONS OF RECIPIENT IN THE USE OF THE SOFTWARE. */
/* Include Section: EK Column Descriptor Parameters */
/* ekcoldsc.inc Version 6 23-AUG-1995 (NJB) */
/* Note: The column descriptor size parameter CDSCSZ is */
/* declared separately in the include section CDSIZE$INC.FOR. */
/* Offset of column descriptors, relative to start of segment */
/* integer address range. This number, when added to the last */
/* integer address preceding the segment, yields the DAS integer */
/* base address of the first column descriptor. Currently, this */
/* offset is exactly the size of a segment descriptor. The */
/* parameter SDSCSZ, which defines the size of a segment descriptor, */
/* is declared in the include file eksegdsc.inc. */
/* Size of column descriptor */
/* Indices of various pieces of column descriptors: */
/* CLSIDX is the index of the column's class code. (We use the */
/* word `class' to distinguish this item from the column's data */
/* type.) */
/* TYPIDX is the index of the column's data type code (CHR, INT, DP, */
/* or TIME). The type is actually implied by the class, but it */
/* will frequently be convenient to look up the type directly. */
/* LENIDX is the index of the column's string length value, if the */
/* column has character type. A value of IFALSE in this element of */
/* the descriptor indicates that the strings have variable length. */
/* SIZIDX is the index of the column's element size value. This */
/* descriptor element is meaningful for columns with fixed-size */
/* entries. For variable-sized columns, this value is IFALSE. */
/* NAMIDX is the index of the base address of the column's name. */
/* IXTIDX is the data type of the column's index. IXTIDX */
/* contains a type value only if the column is indexed. For columns */
/* that are not indexed, the location IXTIDX contains the boolean */
/* value IFALSE. */
/* IXPIDX is a pointer to the column's index. IXTPDX contains a */
/* meaningful value only if the column is indexed. The */
/* interpretation of the pointer depends on the data type of the */
/* index. */
/* NFLIDX is the index of a flag indicating whether nulls are */
/* permitted in the column. The value at location NFLIDX is */
/* ITRUE if nulls are permitted and IFALSE otherwise. */
/* ORDIDX is the index of the column's ordinal position in the */
/* list of columns belonging to the column's parent segment. */
/* METIDX is the index of the column's integer metadata pointer. */
/* This pointer is a DAS integer address. */
/* The last position in the column descriptor is reserved. No */
/* parameter is defined to point to this location. */
/* End Include Section: EK Column Descriptor Parameters */
/* $ Disclaimer */
/* THIS SOFTWARE AND ANY RELATED MATERIALS WERE CREATED BY THE */
/* CALIFORNIA INSTITUTE OF TECHNOLOGY (CALTECH) UNDER A U.S. */
/* GOVERNMENT CONTRACT WITH THE NATIONAL AERONAUTICS AND SPACE */
/* ADMINISTRATION (NASA). THE SOFTWARE IS TECHNOLOGY AND SOFTWARE */
/* PUBLICLY AVAILABLE UNDER U.S. EXPORT LAWS AND IS PROVIDED "AS-IS" */
/* TO THE RECIPIENT WITHOUT WARRANTY OF ANY KIND, INCLUDING ANY */
/* WARRANTIES OF PERFORMANCE OR MERCHANTABILITY OR FITNESS FOR A */
/* PARTICULAR USE OR PURPOSE (AS SET FORTH IN UNITED STATES UCC */
/* SECTIONS 2312-2313) OR FOR ANY PURPOSE WHATSOEVER, FOR THE */
/* SOFTWARE AND RELATED MATERIALS, HOWEVER USED. */
/* IN NO EVENT SHALL CALTECH, ITS JET PROPULSION LABORATORY, OR NASA */
/* BE LIABLE FOR ANY DAMAGES AND/OR COSTS, INCLUDING, BUT NOT */
/* LIMITED TO, INCIDENTAL OR CONSEQUENTIAL DAMAGES OF ANY KIND, */
/* INCLUDING ECONOMIC DAMAGE OR INJURY TO PROPERTY AND LOST PROFITS, */
/* REGARDLESS OF WHETHER CALTECH, JPL, OR NASA BE ADVISED, HAVE */
/* REASON TO KNOW, OR, IN FACT, SHALL KNOW OF THE POSSIBILITY. */
/* RECIPIENT BEARS ALL RISK RELATING TO QUALITY AND PERFORMANCE OF */
/* THE SOFTWARE AND ANY RELATED MATERIALS, AND AGREES TO INDEMNIFY */
/* CALTECH AND NASA FOR ALL THIRD-PARTY CLAIMS RESULTING FROM THE */
/* ACTIONS OF RECIPIENT IN THE USE OF THE SOFTWARE. */
/* Include Section: EK Operator Codes */
/* ekopcd.inc Version 1 30-DEC-1994 (NJB) */
/* Within the EK system, operators used in EK queries are */
/* represented by integer codes. The codes and their meanings are */
/* listed below. */
/* Relational expressions in EK queries have the form */
/* <column name> <operator> <value> */
/* For columns containing numeric values, the operators */
/* EQ, GE, GT, LE, LT, NE */
/* may be used; these operators have the same meanings as their */
/* Fortran counterparts. For columns containing character values, */
/* the list of allowed operators includes those in the above list, */
/* and in addition includes the operators */
/* LIKE, UNLIKE */
/* which are used to compare strings to a template. In the character */
/* case, the meanings of the parameters */
/* GE, GT, LE, LT */
/* match those of the Fortran lexical functions */
/* LGE, LGT, LLE, LLT */
/* The additional unary operators */
/* ISNULL, NOTNUL */
/* are used to test whether a value of any type is null. */
/* End Include Section: EK Operator Codes */
/* $ Disclaimer */
/* THIS SOFTWARE AND ANY RELATED MATERIALS WERE CREATED BY THE */
/* CALIFORNIA INSTITUTE OF TECHNOLOGY (CALTECH) UNDER A U.S. */
/* GOVERNMENT CONTRACT WITH THE NATIONAL AERONAUTICS AND SPACE */
/* ADMINISTRATION (NASA). THE SOFTWARE IS TECHNOLOGY AND SOFTWARE */
/* PUBLICLY AVAILABLE UNDER U.S. EXPORT LAWS AND IS PROVIDED "AS-IS" */
/* TO THE RECIPIENT WITHOUT WARRANTY OF ANY KIND, INCLUDING ANY */
/* WARRANTIES OF PERFORMANCE OR MERCHANTABILITY OR FITNESS FOR A */
/* PARTICULAR USE OR PURPOSE (AS SET FORTH IN UNITED STATES UCC */
/* SECTIONS 2312-2313) OR FOR ANY PURPOSE WHATSOEVER, FOR THE */
/* SOFTWARE AND RELATED MATERIALS, HOWEVER USED. */
/* IN NO EVENT SHALL CALTECH, ITS JET PROPULSION LABORATORY, OR NASA */
/* BE LIABLE FOR ANY DAMAGES AND/OR COSTS, INCLUDING, BUT NOT */
/* LIMITED TO, INCIDENTAL OR CONSEQUENTIAL DAMAGES OF ANY KIND, */
/* INCLUDING ECONOMIC DAMAGE OR INJURY TO PROPERTY AND LOST PROFITS, */
/* REGARDLESS OF WHETHER CALTECH, JPL, OR NASA BE ADVISED, HAVE */
/* REASON TO KNOW, OR, IN FACT, SHALL KNOW OF THE POSSIBILITY. */
/* RECIPIENT BEARS ALL RISK RELATING TO QUALITY AND PERFORMANCE OF */
/* THE SOFTWARE AND ANY RELATED MATERIALS, AND AGREES TO INDEMNIFY */
/* CALTECH AND NASA FOR ALL THIRD-PARTY CLAIMS RESULTING FROM THE */
/* ACTIONS OF RECIPIENT IN THE USE OF THE SOFTWARE. */
/* Include Section: EK Query Limit Parameters */
/* ekqlimit.inc Version 3 16-NOV-1995 (NJB) */
/* Parameter MAXCON increased to 1000. */
/* ekqlimit.inc Version 2 01-AUG-1995 (NJB) */
/* Updated to support SELECT clause. */
/* ekqlimit.inc Version 1 07-FEB-1995 (NJB) */
/* These limits apply to character string queries input to the */
/* EK scanner. This limits are part of the EK system's user */
/* interface: the values should be advertised in the EK required */
/* reading document. */
/* Maximum length of an input query: MAXQRY. This value is */
/* currently set to twenty-five 80-character lines. */
/* Maximum number of columns that may be listed in the */
/* `order-by clause' of a query: MAXSEL. MAXSEL = 50. */
/* Maximum number of tables that may be listed in the `FROM */
/* clause' of a query: MAXTAB. */
/* Maximum number of relational expressions that may be listed */
/* in the `constraint clause' of a query: MAXCON. */
/* This limit applies to a query when it is represented in */
/* `normalized form': that is, the constraints have been */
/* expressed as a disjunction of conjunctions of relational */
/* expressions. The number of relational expressions in a query */
/* that has been expanded in this fashion may be greater than */
/* the number of relations in the query as orginally written. */
/* For example, the expression */
/* ( ( A LT 1 ) OR ( B GT 2 ) ) */
/* AND */
/* ( ( C NE 3 ) OR ( D EQ 4 ) ) */
/* which contains 4 relational expressions, expands to the */
/* equivalent normalized constraint */
/* ( ( A LT 1 ) AND ( C NE 3 ) ) */
/* OR */
/* ( ( A LT 1 ) AND ( D EQ 4 ) ) */
/* OR */
/* ( ( B GT 2 ) AND ( C NE 3 ) ) */
/* OR */
/* ( ( B GT 2 ) AND ( D EQ 4 ) ) */
/* which contains eight relational expressions. */
/* MXJOIN is the maximum number of tables that can be joined. */
/* MXJCON is the maximum number of join constraints allowed. */
/* Maximum number of order-by columns that may be used in the */
/* `order-by clause' of a query: MAXORD. MAXORD = 10. */
/* Maximum number of tokens in a query: 500. Tokens are reserved */
/* words, column names, parentheses, and values. Literal strings */
/* and time values count as single tokens. */
/* Maximum number of numeric tokens in a query: */
/* Maximum total length of character tokens in a query: */
/* Maximum length of literal string values allowed in queries: */
/* MAXSTR. */
/* End Include Section: EK Query Limit Parameters */
/* $ Disclaimer */
/* THIS SOFTWARE AND ANY RELATED MATERIALS WERE CREATED BY THE */
/* CALIFORNIA INSTITUTE OF TECHNOLOGY (CALTECH) UNDER A U.S. */
/* GOVERNMENT CONTRACT WITH THE NATIONAL AERONAUTICS AND SPACE */
/* ADMINISTRATION (NASA). THE SOFTWARE IS TECHNOLOGY AND SOFTWARE */
/* PUBLICLY AVAILABLE UNDER U.S. EXPORT LAWS AND IS PROVIDED "AS-IS" */
/* TO THE RECIPIENT WITHOUT WARRANTY OF ANY KIND, INCLUDING ANY */
/* WARRANTIES OF PERFORMANCE OR MERCHANTABILITY OR FITNESS FOR A */
/* PARTICULAR USE OR PURPOSE (AS SET FORTH IN UNITED STATES UCC */
/* SECTIONS 2312-2313) OR FOR ANY PURPOSE WHATSOEVER, FOR THE */
/* SOFTWARE AND RELATED MATERIALS, HOWEVER USED. */
/* IN NO EVENT SHALL CALTECH, ITS JET PROPULSION LABORATORY, OR NASA */
/* BE LIABLE FOR ANY DAMAGES AND/OR COSTS, INCLUDING, BUT NOT */
/* LIMITED TO, INCIDENTAL OR CONSEQUENTIAL DAMAGES OF ANY KIND, */
/* INCLUDING ECONOMIC DAMAGE OR INJURY TO PROPERTY AND LOST PROFITS, */
/* REGARDLESS OF WHETHER CALTECH, JPL, OR NASA BE ADVISED, HAVE */
/* REASON TO KNOW, OR, IN FACT, SHALL KNOW OF THE POSSIBILITY. */
/* RECIPIENT BEARS ALL RISK RELATING TO QUALITY AND PERFORMANCE OF */
/* THE SOFTWARE AND ANY RELATED MATERIALS, AND AGREES TO INDEMNIFY */
/* CALTECH AND NASA FOR ALL THIRD-PARTY CLAIMS RESULTING FROM THE */
/* ACTIONS OF RECIPIENT IN THE USE OF THE SOFTWARE. */
/* Include Section: EK Segment Descriptor Parameters */
/* eksegdsc.inc Version 8 06-NOV-1995 (NJB) */
/* All `base addresses' referred to below are the addresses */
/* *preceding* the item the base applies to. This convention */
/* enables simplied address calculations in many cases. */
/* Size of segment descriptor. Note: the include file ekcoldsc.inc */
/* must be updated if this parameter is changed. The parameter */
/* CDOFF in that file should be kept equal to SDSCSZ. */
/* Index of the segment type code: */
/* Index of the segment's number. This number is the segment's */
/* index in the list of segments contained in the EK to which */
/* the segment belongs. */
/* Index of the DAS integer base address of the segment's integer */
/* meta-data: */
/* Index of the DAS character base address of the table name: */
/* Index of the segment's column count: */
/* Index of the segment's record count: */
/* Index of the root page number of the record tree: */
/* Index of the root page number of the character data page tree: */
/* Index of the root page number of the double precision data page */
/* tree: */
/* Index of the root page number of the integer data page tree: */
/* Index of the `modified' flag: */
/* Index of the `initialized' flag: */
/* Index of the shadowing flag: */
/* Index of the companion file handle: */
/* Index of the companion segment number: */
/* The next three items are, respectively, the page numbers of the */
/* last character, d.p., and integer data pages allocated by the */
/* segment: */
/* The next three items are, respectively, the page-relative */
/* indices of the last DAS word in use in the segment's */
/* last character, d.p., and integer data pages: */
/* Index of the DAS character base address of the column name list: */
/* The last descriptor element is reserved for future use. No */
/* parameter is defined to point to this location. */
/* End Include Section: EK Segment Descriptor Parameters */
/* $ Disclaimer */
/* THIS SOFTWARE AND ANY RELATED MATERIALS WERE CREATED BY THE */
/* CALIFORNIA INSTITUTE OF TECHNOLOGY (CALTECH) UNDER A U.S. */
/* GOVERNMENT CONTRACT WITH THE NATIONAL AERONAUTICS AND SPACE */
/* ADMINISTRATION (NASA). THE SOFTWARE IS TECHNOLOGY AND SOFTWARE */
/* PUBLICLY AVAILABLE UNDER U.S. EXPORT LAWS AND IS PROVIDED "AS-IS" */
/* TO THE RECIPIENT WITHOUT WARRANTY OF ANY KIND, INCLUDING ANY */
/* WARRANTIES OF PERFORMANCE OR MERCHANTABILITY OR FITNESS FOR A */
/* PARTICULAR USE OR PURPOSE (AS SET FORTH IN UNITED STATES UCC */
/* SECTIONS 2312-2313) OR FOR ANY PURPOSE WHATSOEVER, FOR THE */
/* SOFTWARE AND RELATED MATERIALS, HOWEVER USED. */
/* IN NO EVENT SHALL CALTECH, ITS JET PROPULSION LABORATORY, OR NASA */
/* BE LIABLE FOR ANY DAMAGES AND/OR COSTS, INCLUDING, BUT NOT */
/* LIMITED TO, INCIDENTAL OR CONSEQUENTIAL DAMAGES OF ANY KIND, */
/* INCLUDING ECONOMIC DAMAGE OR INJURY TO PROPERTY AND LOST PROFITS, */
/* REGARDLESS OF WHETHER CALTECH, JPL, OR NASA BE ADVISED, HAVE */
/* REASON TO KNOW, OR, IN FACT, SHALL KNOW OF THE POSSIBILITY. */
/* RECIPIENT BEARS ALL RISK RELATING TO QUALITY AND PERFORMANCE OF */
/* THE SOFTWARE AND ANY RELATED MATERIALS, AND AGREES TO INDEMNIFY */
/* CALTECH AND NASA FOR ALL THIRD-PARTY CLAIMS RESULTING FROM THE */
/* ACTIONS OF RECIPIENT IN THE USE OF THE SOFTWARE. */
/* Include Section: EK Data Types */
/* ektype.inc Version 1 27-DEC-1994 (NJB) */
/* Within the EK system, data types of EK column contents are */
/* represented by integer codes. The codes and their meanings */
/* are listed below. */
/* Integer codes are also used within the DAS system to indicate */
/* data types; the EK system makes no assumptions about compatibility */
/* between the codes used here and those used in the DAS system. */
/* Character type: */
/* Double precision type: */
/* Integer type: */
/* `Time' type: */
/* Within the EK system, time values are represented as ephemeris */
/* seconds past J2000 (TDB), and double precision numbers are used */
/* to store these values. However, since time values require special */
/* treatment both on input and output, and since the `TIME' column */
/* has a special role in the EK specification and code, time values */
/* are identified as a type distinct from double precision numbers. */
/* End Include Section: EK Data Types */
/* $ Disclaimer */
/* THIS SOFTWARE AND ANY RELATED MATERIALS WERE CREATED BY THE */
/* CALIFORNIA INSTITUTE OF TECHNOLOGY (CALTECH) UNDER A U.S. */
/* GOVERNMENT CONTRACT WITH THE NATIONAL AERONAUTICS AND SPACE */
/* ADMINISTRATION (NASA). THE SOFTWARE IS TECHNOLOGY AND SOFTWARE */
/* PUBLICLY AVAILABLE UNDER U.S. EXPORT LAWS AND IS PROVIDED "AS-IS" */
/* TO THE RECIPIENT WITHOUT WARRANTY OF ANY KIND, INCLUDING ANY */
/* WARRANTIES OF PERFORMANCE OR MERCHANTABILITY OR FITNESS FOR A */
/* PARTICULAR USE OR PURPOSE (AS SET FORTH IN UNITED STATES UCC */
/* SECTIONS 2312-2313) OR FOR ANY PURPOSE WHATSOEVER, FOR THE */
/* SOFTWARE AND RELATED MATERIALS, HOWEVER USED. */
/* IN NO EVENT SHALL CALTECH, ITS JET PROPULSION LABORATORY, OR NASA */
/* BE LIABLE FOR ANY DAMAGES AND/OR COSTS, INCLUDING, BUT NOT */
/* LIMITED TO, INCIDENTAL OR CONSEQUENTIAL DAMAGES OF ANY KIND, */
/* INCLUDING ECONOMIC DAMAGE OR INJURY TO PROPERTY AND LOST PROFITS, */
/* REGARDLESS OF WHETHER CALTECH, JPL, OR NASA BE ADVISED, HAVE */
/* REASON TO KNOW, OR, IN FACT, SHALL KNOW OF THE POSSIBILITY. */
/* RECIPIENT BEARS ALL RISK RELATING TO QUALITY AND PERFORMANCE OF */
/* THE SOFTWARE AND ANY RELATED MATERIALS, AND AGREES TO INDEMNIFY */
/* CALTECH AND NASA FOR ALL THIRD-PARTY CLAIMS RESULTING FROM THE */
/* ACTIONS OF RECIPIENT IN THE USE OF THE SOFTWARE. */
/* Include Section: EK Template Matching Wild Characters */
/* ekwild.inc Version 1 16-JAN-1995 (NJB) */
/* Within the EK system, templates used for pattern matching */
/* are those accepted by the SPICELIB routine MATCHW. MATCHW */
/* accepts two special characters: one representing wild */
/* strings and one representing wild characters. This include */
/* file defines those special characters for use within the EK */
/* system. */
/* Wild string symbol: this character matches any string. */
/* Wild character symbol: this character matches any character. */
/* End Include Section: EK Template Matching Wild Characters */
/* $ Brief_I/O */
/* Variable I/O Description */
/* -------- --- -------------------------------------------------- */
/* OP I Relational operator code. */
/* HANDLE I EK file handle. */
/* SEGDSC I Segment descriptor. */
/* COLDSC I Column descriptor. */
/* ROW I ID of row containing column entry to compare. */
/* ELTIDX I Index of element in array-valued column entry. */
/* DTYPE I Data type of input value. */
/* CVAL I Character string to compare with column entry. */
/* DVAL I D.p. value to compare with column entry. */
/* IVAL I Integer value to compare with column entry. */
/* NULL I Flag indicating whether scalar is null. */
/* The function returns .TRUE. if and only if the specified column */
/* entry and input value of the corresponding data type satisfy the */
/* relation specified by the input argument OP. */
/* $ Detailed_Input */
/* OP is an integer code representing a binary relational */
/* operator. The possible values of OP are the */
/* parameters */
/* EQ */
/* GE */
/* GT */
/* LE */
/* LIKE */
/* LT */
/* NE */
/* ISNULL */
/* NOTNUL */
/* HANDLE is an EK file handle. The file may be open for */
/* reading or writing. */
/* SEGDSC is the EK segment descriptor of the column entry */
/* to be compared. */
/* COLDSC is an EK column descriptor for the column */
/* containing the entry to be compared. */
/* ROW is the identifier of the row containing the column */
/* entry to be compared. Note that these identifiers */
/* are polymorphic: their meaning is a function of */
/* the class of column that contains the entry of */
/* interest. */
/* ELTIDX is the index of the column entry element to be */
/* compared, if the column is array-valued. ELTIDX */
/* is ignored for scalar columns. */
/* DTYPE is the data type of the input scalar value. */
/* CVAL, */
/* DVAL, */
/* IVAL are, respectively, character, double precision, */
/* and integer scalar variables. The column entry */
/* is compared against whichever of these has the */
/* same data type as the entry; the other two */
/* variables are ignored. If the data type of the */
/* column entry is TIME, the entry is compared with */
/* the variable DVAL. */
/* NULL */
/* $ Detailed_Output */
/* The function returns .TRUE. if and only if the specified column */
/* entry and input value of the corresponding data type satisfy the */
/* relation specified by the input argument OP. */
/* If the specified column entry is null, it is considered to */
/* precede all non-null values, and the logical value of the */
/* expression */
/* <column element> OP <value> */
/* is determined accordingly. Null character values do not satisfy */
/* the relation */
/* <null column element> LIKE <character value> */
/* for any character value. */
/* $ Parameters */
/* Within the EK system, relational operators used in EK queries are */
/* represented by integer codes. The codes and their meanings are */
/* listed below. */
/* Relational expressions in EK queries have the form */
/* <column name> <operator> <value> */
/* For columns containing numeric values, the operators */
/* EQ, GE, GT, LE, LT, NE */
/* may be used; these operators have the same meanings as their */
/* Fortran counterparts. For columns containing character values, */
/* the list of allowed operators includes those in the above list, */
/* and in addition includes the operator */
/* LIKE */
/* which is used to compare strings to a template. In the character */
/* case, the meanings of the parameters */
/* GE, GT, LE, LT */
/* match those of the Fortran lexical functions */
/* LGE, LGT, LLE, LLT */
/* Null values are considered to precede all non-null values. */
/* $ Exceptions */
/* 1) If the input file handle is invalid, the error will be */
/* diagnosed by routines called by this routine. */
/* The function value is .FALSE. in this case. */
/* 2) If an I/O error occurs while attempting to find the address */
/* range of the specified column entry element, the error will */
/* be diagnosed by routines called by this routine. The */
/* function value is .FALSE. in this case. */
/* 3) If any of SEGDSC, COLDSC, or ROW are invalid, this routine */
/* may fail in unpredictable, but possibly spectacular, ways. */
/* Except as described in this header section, no attempt is */
/* made to handle these errors. */
/* 4) If the data type code in the input column descriptor is not */
/* recognized, the error SPICE(INVALIDDATATYPE) is signalled. */
/* The function value is .FALSE. in this case. */
/* 5) If the specified column entry cannot be found, the error */
/* SPICE(INVALIDINDEX) is signalled. The function value is */
/* .FALSE. in this case. */
/* 6) If the relational operator code OP is not recognized, the */
/* error SPICE(UNNATURALRELATION) is signalled. The function */
/* value is .FALSE. in this case. */
/* $ Files */
/* See the description of the argument HANDLE in $Detailed_Input. */
/* $ Particulars */
/* This routine is an EK utility intended to centralize a frequently */
/* performed comparison operation. */
/* $ Examples */
/* See ZZEKRMCH. */
/* $ Restrictions */
/* 1) This routine must execute quickly. Therefore, it checks in */
/* only if it detects an error. If an error is signalled by a */
/* routine called by this routine, this routine will not appear */
/* in the SPICELIB traceback display. Also, in the interest */
/* of speed, this routine does not test the value of the SPICELIB */
/* function RETURN upon entry. */
/* $ Literature_References */
/* None. */
/* $ Author_and_Institution */
/* N.J. Bachman (JPL) */
/* $ Version */
/* - SPICELIB Version 1.2.0, 31-MAY-2009 (NJB) */
/* Bug fix: routine failed to account for the possibility */
/* that scalar string column entries can have unlimited */
/* length. Now at most the first MAXSTR characters of such */
/* an entry are used in comparisons. */
/* - SPICELIB Version 1.1.0, 21-DEC-2001 (NJB) */
/* Bug fix: routine now indicates "no match" when operator */
/* is LIKE or UNLIKE and column entry is null. */
/* - SPICELIB Version 1.0.0, 17-OCT-1995 (NJB) */
/* -& */
/* SPICELIB functions */
/* Local variables */
/* Use discovery check-in for speed. */
/* The function value defaults to .FALSE. */
ret_val = FALSE_;
/* Look up the specified column element. */
coltyp = coldsc[1];
if (coltyp == 1) {
/* We'll use at most the first MAXSTR characters of the input */
/* string. */
/* Computing MIN */
i__1 = i_len(cval, cval_len);
cvlen = min(i__1,1024);
/* Fetch the column entry to be compared. Note that ROW */
/* is a polymorphic identifier. See ZZEKRSC for details */
/* on how ROW is used. */
zzekrsc_(handle, segdsc, coldsc, row, eltidx, &strlen, eltc, &enull, &
found, (ftnlen)1024);
if (failed_()) {
/* Don't check out here because we haven't checked in. */
return ret_val;
}
/* Let CMPLEN be the string length to use in comparisons. */
if (found && ! enull) {
cmplen = min(strlen,1024);
} else {
cmplen = 0;
}
} else if (coltyp == 2 || coltyp == 4) {
zzekrsd_(handle, segdsc, coldsc, row, eltidx, &eltd, &enull, &found);
} else if (coltyp == 3) {
zzekrsi_(handle, segdsc, coldsc, row, eltidx, &elti, &enull, &found);
} else {
chkin_("ZZEKSCMP", (ftnlen)8);
setmsg_("Data type code # not recognized.", (ftnlen)32);
errint_("#", &coltyp, (ftnlen)1);
sigerr_("SPICE(INVALIDDATATYPE)", (ftnlen)22);
chkout_("ZZEKSCMP", (ftnlen)8);
return ret_val;
}
if (! found) {
dashlu_(handle, &unit);
chkin_("ZZEKSCMP", (ftnlen)8);
setmsg_("EK = #; COLIDX = #; ROW = #; ELTIDX = #. Column entry eleme"
"nt was not found.", (ftnlen)76);
errfnm_("#", &unit, (ftnlen)1);
errint_("#", &coldsc[8], (ftnlen)1);
errint_("#", row, (ftnlen)1);
errint_("#", eltidx, (ftnlen)1);
sigerr_("SPICE(INVALIDINDEX)", (ftnlen)19);
chkout_("ZZEKSCMP", (ftnlen)8);
return ret_val;
}
/* Handle the ISNULL and NOTNUL operators, if perchance we see them. */
if (*op == 9) {
ret_val = enull;
return ret_val;
} else if (*op == 10) {
ret_val = ! enull;
return ret_val;
}
/* Find the order relation that applies to the input values. */
/* Null values precede all others. */
if (enull) {
if (*null) {
rel = 1;
} else {
rel = 5;
}
} else if (*null) {
if (enull) {
rel = 1;
} else {
rel = 3;
}
} else {
/* Compare the value we looked up with the input scalar value. */
if (coltyp == 1) {
if (*dtype != 1) {
chkin_("ZZEKSCMP", (ftnlen)8);
setmsg_("Column type is #; value type is #.", (ftnlen)34);
errint_("#", &coltyp, (ftnlen)1);
errint_("#", dtype, (ftnlen)1);
sigerr_("SPICE(BUG)", (ftnlen)10);
chkout_("ZZEKSCMP", (ftnlen)8);
return ret_val;
}
if (l_lt(eltc, cval, cmplen, cvlen)) {
rel = 5;
} else if (l_gt(eltc, cval, cmplen, cvlen)) {
rel = 3;
} else {
rel = 1;
}
} else if (coltyp == 4) {
if (*dtype != 4 && *dtype != 2) {
chkin_("ZZEKSCMP", (ftnlen)8);
setmsg_("Column type is #; value type is #.", (ftnlen)34);
errint_("#", &coltyp, (ftnlen)1);
errint_("#", dtype, (ftnlen)1);
sigerr_("SPICE(BUG)", (ftnlen)10);
chkout_("ZZEKSCMP", (ftnlen)8);
return ret_val;
}
if (eltd < *dval) {
rel = 5;
} else if (eltd > *dval) {
rel = 3;
} else {
rel = 1;
}
} else if (coltyp == 2) {
if (*dtype == 3) {
numval = (doublereal) (*ival);
} else if (*dtype == 2 || *dtype == 4) {
numval = *dval;
} else {
chkin_("ZZEKSCMP", (ftnlen)8);
setmsg_("Column type is #; value type is #.", (ftnlen)34);
errint_("#", &coltyp, (ftnlen)1);
errint_("#", dtype, (ftnlen)1);
sigerr_("SPICE(BUG)", (ftnlen)10);
chkout_("ZZEKSCMP", (ftnlen)8);
return ret_val;
}
if (eltd < numval) {
rel = 5;
} else if (eltd > numval) {
rel = 3;
} else {
rel = 1;
}
} else if (coltyp == 3) {
if (*dtype == 3) {
numval = (doublereal) (*ival);
} else if (*dtype == 2) {
numval = *dval;
} else {
chkin_("ZZEKSCMP", (ftnlen)8);
setmsg_("Column type is #; value type is #.", (ftnlen)34);
errint_("#", &coltyp, (ftnlen)1);
errint_("#", dtype, (ftnlen)1);
sigerr_("SPICE(BUG)", (ftnlen)10);
chkout_("ZZEKSCMP", (ftnlen)8);
return ret_val;
}
if ((doublereal) elti < numval) {
rel = 5;
} else if ((doublereal) elti > numval) {
rel = 3;
} else {
rel = 1;
}
} else {
/* Something untoward has happened in our column descriptor */
/* argument. */
chkin_("ZZEKSCMP", (ftnlen)8);
setmsg_("The data type code # was not recognized.", (ftnlen)40);
errint_("#", &coltyp, (ftnlen)1);
sigerr_("SPICE(INVALIDDATATYPE)", (ftnlen)22);
chkout_("ZZEKSCMP", (ftnlen)8);
return ret_val;
}
}
/* Determine the truth of the input relational expression. */
if (*op == 1) {
ret_val = rel == 1;
} else if (*op == 5) {
ret_val = rel == 5;
} else if (*op == 4) {
ret_val = rel != 3;
} else if (*op == 3) {
ret_val = rel == 3;
} else if (*op == 2) {
ret_val = rel != 5;
} else if (*op == 6) {
ret_val = rel != 1;
} else if (*op == 7 && *dtype == 1) {
if (*null || enull) {
ret_val = FALSE_;
} else {
ret_val = matchi_(eltc, cval, "*", "%", cmplen, cvlen, (ftnlen)1,
(ftnlen)1);
}
} else if (*op == 8 && *dtype == 1) {
if (*null || enull) {
ret_val = FALSE_;
} else {
ret_val = ! matchi_(eltc, cval, "*", "%", cmplen, cvlen, (ftnlen)
1, (ftnlen)1);
}
} else {
/* Sorry, we couldn't resist. */
chkin_("ZZEKSCMP", (ftnlen)8);
setmsg_("The relational operator # was not recognized or was not app"
"licable for data type #.", (ftnlen)83);
errint_("#", op, (ftnlen)1);
errint_("#", dtype, (ftnlen)1);
sigerr_("SPICE(UNNATURALRELATION)", (ftnlen)24);
chkout_("ZZEKSCMP", (ftnlen)8);
return ret_val;
}
return ret_val;
} /* zzekscmp_ */
