/* ekbseg.f -- translated by f2c (version 19980913). You must link the resulting object file with the libraries: -lf2c -lm (in that order) */ #include "f2c.h" /* Table of constant values */ static integer c__512 = 512; static integer c__32 = 32; static integer c__1 = 1; static integer c__100 = 100; /* $Procedure EKBSEG ( EK, start new segment ) */ /* Subroutine */ int ekbseg_(integer *handle, char *tabnam, integer *ncols, char *cnames, char *decls, integer *segno, ftnlen tabnam_len, ftnlen cnames_len, ftnlen decls_len) { /* Initialized data */ static logical first = TRUE_; /* System generated locals */ integer i__1, i__2; /* Builtin functions */ integer s_rnge(char *, integer, char *, integer); /* Local variables */ extern /* Subroutine */ int zzekpdec_(char *, integer *, ftnlen), zzekpgch_(integer *, char *, ftnlen); integer i__; extern integer zzekstyp_(integer *, integer *); integer idend; extern /* Subroutine */ int chkin_(char *, ftnlen), errch_(char *, char *, ftnlen, ftnlen); integer stype; extern logical failed_(void); extern /* Subroutine */ int chckid_(char *, integer *, char *, ftnlen, ftnlen); extern integer lastnb_(char *, ftnlen); extern logical return_(void); integer cdscrs[1100] /* was [11][100] */; static integer idspec[518]; integer nchars; extern /* Subroutine */ int chkout_(char *, ftnlen), ssizei_(integer *, integer *), lxdfid_(integer *), lxidnt_(integer *, char *, integer *, integer *, integer *, ftnlen), setmsg_(char *, ftnlen), sigerr_(char *, ftnlen), errint_(char *, integer *, ftnlen), zzekbs01_(integer *, char *, integer *, char *, integer *, integer *, ftnlen, ftnlen), zzekbs02_(integer *, char *, integer * , char *, integer *, integer *, ftnlen, ftnlen); /* $ Abstract */ /* Start a new segment in an E-kernel. */ /* $ Copyright */ /* Copyright (1995), California Institute of Technology. */ /* U.S. Government sponsorship acknowledged. */ /* $ Required_Reading */ /* EK */ /* $ Keywords */ /* EK */ /* $ Declarations */ /* Include Section: EK Boolean Enumerated Type */ /* ekbool.inc Version 1 21-DEC-1994 (NJB) */ /* Within the EK system, boolean values sometimes must be */ /* represented by integer or character codes. The codes and their */ /* meanings are listed below. */ /* Integer code indicating `true': */ /* Integer code indicating `false': */ /* Character code indicating `true': */ /* Character code indicating `false': */ /* End Include Section: EK Boolean Enumerated Type */ /* 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 */ /* Include Section: EK Column Name Size */ /* ekcnamsz.inc Version 1 17-JAN-1995 (NJB) */ /* Size of column name, in characters. */ /* End Include Section: EK Column Name Size */ /* Include Section: EK Data Page Parameters */ /* ekfilpar.inc Version 1 03-APR-1995 (NJB) */ /* These parameters apply to EK files using architecture 4. */ /* These files use a paged DAS file as their underlying file */ /* structure. */ /* In paged DAS EK files, data pages are structured: they contain */ /* metadata as well as data. The metadata is located in the last */ /* few addresses of each page, so as to interfere as little as */ /* possible with calculation of data addresses. */ /* Each data page belongs to exactly one segment. Some bookkeeping */ /* information, such as record pointers, is also stored in data */ /* pages. */ /* Each page contains a forward pointer that allows rapid lookup */ /* of data items that span multiple pages. Each page also keeps */ /* track of the current number of links from its parent segment */ /* to the page. Link counts enable pages to `know' when they */ /* are no longer in use by a segment; unused pages are deallocated */ /* and returned to the free list. */ /* The parameters in this include file depend on the parameters */ /* declared in the include file ekpage.inc. If those parameters */ /* change, this file must be updated. The specified parameter */ /* declarations we need from that file are: */ /* INTEGER PGSIZC */ /* PARAMETER ( PGSIZC = 1024 ) */ /* INTEGER PGSIZD */ /* PARAMETER ( PGSIZD = 128 ) */ /* INTEGER PGSIZI */ /* PARAMETER ( PGSIZI = 256 ) */ /* Character pages use an encoding mechanism to represent integer */ /* metadata. Each integer is encoded in five consecutive */ /* characters. */ /* Character data page parameters: */ /* Size of encoded integer: */ /* Usable page size: */ /* Location of character forward pointer: */ /* Location of character link count: */ /* Double precision data page parameters: */ /* Usable page size: */ /* Location of d.p. forward pointer: */ /* Location of d.p. link count: */ /* Integer data page parameters: */ /* Usable page size: */ /* Location of integer forward pointer: */ /* Location of integer link count: */ /* End Include Section: EK Data Page Parameters */ /* Include Section: EK File Metadata Parameters */ /* ekfilpar.inc Version 1 28-MAR-1995 (NJB) */ /* These parameters apply to EK files using architecture 4. */ /* These files use a paged DAS file as their underlying file */ /* structure. */ /* The metadata for an architecture 4 EK file is very simple: it */ /* consists of a single integer, which is a pointer to a tree */ /* that in turn points to the segments in the EK. However, in the */ /* interest of upward compatibility, one integer page is reserved */ /* for the file's metadata. */ /* Size of file parameter block: */ /* All offsets shown below are relative to the beginning of the */ /* first integer page in the EK. */ /* Index of the segment pointer tree---this location contains the */ /* root page number of the tree: */ /* End Include Section: EK File Metadata Parameters */ /* Include Section: EK General Limit Parameters */ /* ekglimit.inc Version 1 21-MAY-1995 (NJB) */ /* This file contains general limits for the EK system. */ /* MXCLSG is the maximum number of columns allowed in a segment. */ /* This limit applies to logical tables as well, since all segments */ /* in a logical table must have the same column definitions. */ /* End Include Section: EK General Limit Parameters */ /* Include Section: EK Das Paging Parameters */ /* ekpage.inc Version 4 25-AUG-1995 (NJB) */ /* The EK DAS paging system makes use of the integer portion */ /* of an EK file's DAS address space to store the few numbers */ /* required to describe the system's state. The allocation */ /* of DAS integer addresses is shown below. */ /* DAS integer array */ /* +--------------------------------------------+ */ /* | EK architecture code | Address = 1 */ /* +--------------------------------------------+ */ /* | Character page size (in DAS words) | */ /* +--------------------------------------------+ */ /* | Character page base address | */ /* +--------------------------------------------+ */ /* | Number of character pages in file | */ /* +--------------------------------------------+ */ /* | Number of character pages on free list | */ /* +--------------------------------------------+ */ /* | Character free list head pointer | Address = 6 */ /* +--------------------------------------------+ */ /* | | Addresses = */ /* | Metadata for d.p. pages | 7--11 */ /* | | */ /* +--------------------------------------------+ */ /* | | Addresses = */ /* | Metadata for integer pages | 12--16 */ /* | | */ /* +--------------------------------------------+ */ /* . */ /* . */ /* . */ /* +--------------------------------------------+ */ /* | | End Address = */ /* | Unused space | integer page */ /* | | end */ /* +--------------------------------------------+ */ /* | | Start Address = */ /* | First integer page | integer page */ /* | | base */ /* +--------------------------------------------+ */ /* . */ /* . */ /* . */ /* +--------------------------------------------+ */ /* | | */ /* | Last integer page | */ /* | | */ /* +--------------------------------------------+ */ /* The following parameters indicate positions of elements in the */ /* paging system metadata array: */ /* Number of metadata items per data type: */ /* Character metadata indices: */ /* Double precision metadata indices: */ /* Integer metadata indices: */ /* Size of metadata area: */ /* Page sizes, in units of DAS words of the appropriate type: */ /* Default page base addresses: */ /* End Include Section: EK Das Paging Parameters */ /* Include Section: EK Record Pointer Parameters */ /* ekrecptr.inc Version 2 18-JUL-1995 (NJB) */ /* This file declares parameters used in EK record pointers. */ /* Each segment references data in a given record via two levels */ /* of indirection: a record number points to a record pointer, */ /* which is a structured array of metadata and data pointers. */ /* Record pointers always occupy contiguous ranges of integer */ /* addresses. */ /* The parameter declarations in this file depend on the assumption */ /* that integer pages contain 256 DAS integer words and that the */ /* maximum number of columns in a segment is 100. Record pointers */ /* are stored in integer data pages, so they must fit within the */ /* usable data area afforded by these pages. The size of the usable */ /* data area is given by the parameter IPSIZE which is declared in */ /* ekdatpag.inc. The assumed value of IPSIZE is 254. */ /* The first element of each record pointer is a status indicator. */ /* The meanings of status indicators depend on whether the parent EK */ /* is shadowed or not. For shadowed EKs, allowed status values and */ /* their meanings are: */ /* OLD The record has not been modified since */ /* the EK containing the record was opened. */ /* UPDATE The record is an update of a previously existing */ /* record. The original record is now on the */ /* modified record list. */ /* NEW The record has been added since the EK containing the */ /* record was opened. The record is not an update */ /* of a previously existing record. */ /* DELOLD This status applies only to a backup record. */ /* DELOLD status indicates that the record corresponds */ /* to a deleted OLD record in the source segment. */ /* DELNEW This status applies only to a backup record. */ /* DELNEW status indicates that the record corresponds */ /* to a deleted NEW record in the source segment. */ /* DELUPD This status applies only to a backup record. */ /* DELUPD status indicates that the record corresponds */ /* to a deleted UPDATEd record in the source segment. */ /* In EKs that are not shadowed, all records have status OLD. */ /* The following parameters refer to indices within the record */ /* pointer structure: */ /* Index of status indicator: */ /* Each record pointer contains a pointer to its companion: for a */ /* record belonging to a shadowed EK, this is the backup counterpart, */ /* or if the parent EK is itself a backup EK, a pointer to the */ /* record's source record. The pointer is UNINIT (see below) if the */ /* record is unmodified. */ /* Record companion pointers contain record numbers, not record */ /* base addresses. */ /* Index of record's companion pointer: */ /* Each data item is referenced by an integer. The meaning of */ /* this integer depends on the representation of data in the */ /* column to which the data item belongs. Actual lookup of a */ /* data item must be done by subroutines appropriate to the class of */ /* the column to which the item belongs. Note that data items don't */ /* necessarily occupy contiguous ranges of DAS addresses. */ /* Base address of data pointers: */ /* Maximum record pointer size: */ /* Data pointers are given the value UNINIT to start with; this */ /* indicates that the data item is uninitialized. UNINIT is */ /* distinct from the value NULL. NOBACK indicates an uninitialized */ /* backup column entry. */ /* End Include Section: EK Record Pointer Parameters */ /* 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 */ /* Include Section: EK Table Name Size */ /* ektnamsz.inc Version 1 17-JAN-1995 (NJB) */ /* Size of table name, in characters. */ /* End Include Section: EK Table Name Size */ /* 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 */ /* $ Brief_I/O */ /* Variable I/O Description */ /* -------- --- -------------------------------------------------- */ /* HANDLE I File handle. */ /* TABNAM I Table name. */ /* NCOLS I Number of columns in the segment. */ /* CNAMES I Names of columns. */ /* DECLS I Declarations of columns. */ /* SEGNO O Segment number. */ /* $ Detailed_Input */ /* HANDLE the handle of an EK file that is open for writing. */ /* TABNAM is the name of the EK table to which the current */ /* segment belongs. All segments in the EK file */ /* designated by HANDLE must have identical column */ /* attributes. TABNAM must not exceed 32 characters */ /* in length. Case is not significant. Table names */ /* must start with a letter and contain only */ /* characters from the set {A-Z,a-z,0-9,$,_}. */ /* NCOLS is the number of columns in a new segment. */ /* CNAMES, */ /* DECLS are, respectively, and array of column names and */ /* their corresponding declarations: the Ith element */ /* of CNAMES and the Ith element of DECLS apply to */ /* the Ith column in the segment. */ /* Column names must not exceed CNAMSZ (32) characters */ /* in length. Case is not significant. Column names */ /* must start with a letter and contain only */ /* characters from the set {A-Z,a-z,0-9,$,_}. */ /* The declarations are strings that contain */ /* `keyword=value' assignments that define the */ /* attributes of the columns to which they apply. The */ /* column attributes that are defined by a column */ /* declaration are: */ /* DATATYPE */ /* SIZE */ /* */ /* */ /* The form of a declaration is */ /* 'DATATYPE = , */ /* SIZE = , */ /* INDEXED = , */ /* NULLS_OK = ' */ /* For example, an indexed, scalar, integer column */ /* that allows null values would have the declaration */ /* 'DATATYPE = INTEGER, */ /* SIZE = 1, */ /* INDEXED = TRUE, */ /* NULLS_OK = TRUE' */ /* Commas are required to separate the assignments */ /* within declarations; white space is optional; */ /* case is not significant. */ /* The order in which the attribute keywords are */ /* listed in declaration is not significant. */ /* Every column in a segment must be declared. */ /* Each column entry is effectively an array, each */ /* element of which has the declared data type. The */ /* SIZE keyword indicates how many elements are in */ /* each entry of the column in whose declaration the */ /* keyword appears. Note that only scalar-valued */ /* columns (those for which SIZE = 1) may be */ /* referenced in query constraints. A size */ /* assignment has the syntax */ /* SIZE = */ /* or */ /* SIZE = VARIABLE */ /* The size value defaults to 1 if omitted. */ /* The DATATYPE keyword defines the data type of */ /* column entries. The DATATYPE assignment syntax */ /* has any of the forms */ /* DATATYPE = CHARACTER*() */ /* DATATYPE = CHARACTER*(*) */ /* DATATYPE = DOUBLE PRECISION */ /* DATATYPE = INTEGER */ /* DATATYPE = TIME */ /* As the datatype declaration syntax suggests, */ /* character strings may have fixed or variable */ /* length. Variable-length strings are allowed only */ /* in columns of size 1. */ /* Optionally, scalar-valued columns may be indexed. */ /* To create an index for a column, use the assignment */ /* INDEXED = TRUE */ /* By default, columns are not indexed. */ /* Optionally, any column can allow null values. To */ /* indicate that a column may allow null values, use */ /* the assigment */ /* NULLS_OK = TRUE */ /* in the column declaration. By default, null */ /* values are not allowed in column entries. */ /* $ Detailed_Output */ /* SEGNO is the number of the segment created by this */ /* routine. Segment numbers are used as unique */ /* identifiers by other EK access routines. */ /* $ Parameters */ /* None. */ /* $ Exceptions */ /* 1) If HANDLE is invalid, the error will be diagnosed by routines */ /* called by this routine. */ /* 2) If TABNAM is more than TNAMSZ characters long, the error */ /* is diagnosed by routines called by this routine. */ /* 3) If TABNAM contains any nonprintable characters, the error */ /* is diagnosed by routines called by this routine. */ /* 4) If NCOLS is non-positive or greater than the maximum allowed */ /* number MXCLSG, the error SPICE(INVALIDCOUNT) is signalled. */ /* 5) If any column name exceeds CNAMSZ characters in length, the */ /* error is diagnosed by routines called by this routine. */ /* 6) If any column name contains non-printable characters, the */ /* error is diagnosed by routines called by this routine. */ /* 7) If a declaration cannot be understood by this routine, the */ /* error is diagnosed by routines called by this routine. */ /* 8) If an non-positive string length or element size is specified, */ /* the error is diagnosed by routines called by this routine. */ /* 9) If an I/O error occurs while reading or writing the indicated */ /* file, the error will be diagnosed by routines called by this */ /* routine. */ /* $ Files */ /* See the EK Required Reading for a discussion of the EK file */ /* format. */ /* $ Particulars */ /* This routine operates by side effects: it prepares an EK for */ /* the addition of a new segment. It is not necessary to take */ /* any special action to `complete' a segment; segments are readable */ /* after the completion of any record insertion, deletion, write, */ /* or update operation. */ /* $ Examples */ /* 1) Suppose we have an E-kernel named ORDER_DB.EK which contains */ /* records of orders for data products. The E-kernel has a */ /* table called DATAORDERS that consists of the set of columns */ /* listed below: */ /* DATAORDERS */ /* Column Name Data Type */ /* ----------- --------- */ /* ORDER_ID INTEGER */ /* CUSTOMER_ID INTEGER */ /* LAST_NAME CHARACTER*(*) */ /* FIRST_NAME CHARACTER*(*) */ /* ORDER_DATE TIME */ /* COST DOUBLE PRECISION */ /* The order database also has a table of items that have been */ /* ordered. The columns of this table are shown below: */ /* DATAITEMS */ /* Column Name Data Type */ /* ----------- --------- */ /* ITEM_ID INTEGER */ /* ORDER_ID INTEGER */ /* ITEM_NAME CHARACTER*(*) */ /* DESCRIPTION CHARACTER*(*) */ /* PRICE DOUBLE PRECISION */ /* We'll suppose that the file ORDER_DB.EK contains two segments, */ /* the first containing the DATAORDERS table and the second */ /* containing the DATAITEMS table. */ /* Below, we show how we'd open a new EK file and start the */ /* first of the segments described above. */ /* C */ /* C Open a new EK file. For simplicity, we will not */ /* C reserve any space for the comment area, so the */ /* C number of reserved comment characters is zero. */ /* C The variable IFNAME is the internal file name. */ /* C */ /* NRESVC = 0 */ /* IFNAME = 'Test EK/Created 20-SEP-1995' */ /* CALL EKOPN ( 'ORDER_DB.EK', IFNAME, NRESVC, HANDLE ) */ /* C */ /* C Set up the table and column names and declarations */ /* C for the DATAORDERS segment. We'll index all of */ /* C the columns. All columns are scalar, so we omit */ /* C the size declaration. Only the COST column may take */ /* C null values. */ /* C */ /* TABLE = 'DATAORDERS' */ /* NCOLS = 6 */ /* CNAMES(1) = 'ORDER_ID' */ /* CDECLS(1) = 'DATATYPE = INTEGER, INDEXED = TRUE' */ /* CNAMES(2) = 'CUSTOMER_ID' */ /* CDECLS(2) = 'DATATYPE = INTEGER, INDEXED = TRUE' */ /* CNAMES(3) = 'LAST_NAME' */ /* CDECLS(3) = 'DATATYPE = CHARACTER*(*),' // */ /* . 'INDEXED = TRUE' */ /* CNAMES(4) = 'FIRST_NAME' */ /* CDECLS(4) = 'DATATYPE = CHARACTER*(*),' // */ /* . 'INDEXED = TRUE' */ /* CNAMES(5) = 'ORDER_DATE' */ /* CDECLS(5) = 'DATATYPE = TIME, INDEXED = TRUE' */ /* CNAMES(6) = 'COST' */ /* CDECLS(6) = 'DATATYPE = DOUBLE PRECISION,' // */ /* . 'INDEXED = TRUE' // */ /* . 'NULLS_OK = TRUE' */ /* C */ /* C Start the segment. */ /* C */ /* CALL EKBSEG ( HANDLE, TABNAM, NCOLS, */ /* . CNAMES, CDECLS, SEGNO ) */ /* C */ /* C Add data to the segment. No special action */ /* C is required to finish the segment. */ /* C */ /* [Data is added via calls to EKAPPR and the */ /* EKACEC, EKACED, and EKACEI routines. See any */ /* of these routines for examples.] */ /* C */ /* C At this point, the second segment could be */ /* C created by an analogous process. In fact, the */ /* C second segment could be created at any time; it is */ /* C not necessary to populate the first segment with */ /* C data before starting the second segment. */ /* C */ /* C */ /* C The file must be closed by a call to EKCLS. */ /* C */ /* CALL EKCLS ( HANDLE ) */ /* $ Restrictions */ /* None. */ /* $ Literature_References */ /* None. */ /* $ Author_and_Institution */ /* N.J. Bachman (JPL) */ /* $ Version */ /* - SPICELIB Version 1.1.0, 07-JUL-1996 (NJB) */ /* Erroneous error message for invalid column names was fixed. */ /* Previous version line was changed from "Beta" to "SPICELIB." */ /* - SPICELIB Version 1.0.0, 06-NOV-1995 (NJB) */ /* -& */ /* $ Index_Entries */ /* start new E-kernel segment */ /* start new EK segment */ /* -& */ /* $ Revisions */ /* - SPICELIB Version 1.1.0, 07-JUL-1996 (NJB) */ /* Erroneous error message for invalid column names was fixed. */ /* Previous version line was changed from "Beta" to "SPICELIB." */ /* -& */ /* SPICELIB functions */ /* Non-SPICELIB functions */ /* Local parameters */ /* Local variables */ /* Saved variables */ /* Initial values */ /* Standard SPICE error handling. */ if (return_()) { return 0; } else { chkin_("EKBSEG", (ftnlen)6); } /* Before trying to actually write anything, do every error */ /* check we can. */ /* Is this file handle valid--is the file open for paged write */ /* access? Signal an error if not. */ zzekpgch_(handle, "WRITE", (ftnlen)5); if (failed_()) { chkout_("EKBSEG", (ftnlen)6); return 0; } /* Get the default identifier specification the first time through. */ if (first) { ssizei_(&c__512, idspec); lxdfid_(idspec); first = FALSE_; } /* The table name must not be too long, and all of its characters */ /* must be printable (it's ok for it to unprintable). */ chckid_("EK table name", &c__32, tabnam, (ftnlen)13, tabnam_len); if (failed_()) { chkout_("EKBSEG", (ftnlen)6); return 0; } /* Make sure the table name satisfies all of our restrictions on */ /* allowed characters. */ lxidnt_(idspec, tabnam, &c__1, &idend, &nchars, tabnam_len); if (nchars == 0 || nchars < lastnb_(tabnam, tabnam_len)) { setmsg_("Table name <#> violates syntax rules.", (ftnlen)37); errch_("#", tabnam, (ftnlen)1, tabnam_len); sigerr_("SPICE(INVALIDNAME)", (ftnlen)18); chkout_("EKBSEG", (ftnlen)6); return 0; } /* Check out NCOLS. */ if (*ncols < 1 || *ncols > 100) { setmsg_("Number of columns must be in range 1:#, was #.", (ftnlen)46); errint_("#", &c__100, (ftnlen)1); errint_("#", ncols, (ftnlen)1); sigerr_("SPICE(INVALIDCOUNT)", (ftnlen)19); chkout_("EKBSEG", (ftnlen)6); return 0; } /* Check the column names for length and printability. */ i__1 = *ncols; for (i__ = 1; i__ <= i__1; ++i__) { chckid_("EK column name", &c__32, cnames + (i__ - 1) * cnames_len, ( ftnlen)14, cnames_len); if (failed_()) { chkout_("EKBSEG", (ftnlen)6); return 0; } /* Make sure each column name satisfies all of our restrictions on */ /* allowed characters. */ lxidnt_(idspec, cnames + (i__ - 1) * cnames_len, &c__1, &idend, & nchars, cnames_len); if (nchars == 0 || nchars < lastnb_(cnames + (i__ - 1) * cnames_len, cnames_len)) { setmsg_("Column name <#> violates syntax rules.", (ftnlen)38); errch_("#", cnames + (i__ - 1) * cnames_len, (ftnlen)1, cnames_len); sigerr_("SPICE(INVALIDNAME)", (ftnlen)18); chkout_("EKBSEG", (ftnlen)6); return 0; } } /* Parse the column declarations before proceeding. */ i__1 = *ncols; for (i__ = 1; i__ <= i__1; ++i__) { /* Parse the declaration of the Ith column. The descriptor is */ /* returned with all elements other than pointers initialized. */ zzekpdec_(decls + (i__ - 1) * decls_len, &cdscrs[(i__2 = i__ * 11 - 11) < 1100 && 0 <= i__2 ? i__2 : s_rnge("cdscrs", i__2, "ekb" "seg_", (ftnlen)529)], decls_len); if (failed_()) { chkout_("EKBSEG", (ftnlen)6); return 0; } } /* Determine the segment type. */ stype = zzekstyp_(ncols, cdscrs); /* Create the segment metadata according to the segment's type. */ if (stype == 1) { zzekbs01_(handle, tabnam, ncols, cnames, cdscrs, segno, tabnam_len, cnames_len); } else if (stype == 2) { zzekbs02_(handle, tabnam, ncols, cnames, cdscrs, segno, tabnam_len, cnames_len); } else { setmsg_("Segment type # is not currently supported.", (ftnlen)42); errint_("#", &stype, (ftnlen)1); sigerr_("SPICE(BUG)", (ftnlen)10); chkout_("EKBSEG", (ftnlen)6); return 0; } chkout_("EKBSEG", (ftnlen)6); return 0; } /* ekbseg_ */