/*

  PDS Table Verifier

  This routine reads the information in a PDS label describing one or more
  table-type objects and compares the given parameters to the actual data in
  the file. It checks for sufficent number of records, looks for common
  transposition errors in the label, compiles a list of attributes for each
  column and ten attempts to read all columns (apart from bit fields). If
  extrema are included in the label, the data values are checked to ensure
  they are within bounds.

  Table objects may be binary or ASCII; different INTERCHANGE_FORMATs may
  appear in the same label - although this is generally not a good idea.
  Multiple pointers with different file names are also allowed.

  08 Mar 2001, A.C.Raugh: Begin rewrite from 'btv' and 'atv'


  Format:   pdstv [-v] [-d <directory>] [-o <report>] [-f] [-b] <label>

   where:   -d <directory>   gives the directory to check for the data file
            -o <report>      directs the report to the named file
            -f               indicates blank fields should be flagged
            -b               signals batch mode processing
            -v               print version and exit

            If the label file is not found on first try, the data directory
            name is prepended to the input argument and another attempt is
            made to find the file.

  17 May 2001, acr: upgrade to handle YYYY-DDD dates.
  21 May 2001, acr: Upgrade to handle FORMAT strings with repetition factors,
                    and to check the repetition count against the ITEMS value.
  11 Jun 2001, acr: Corrected handling of BYTES and REPETITIONS in CONTAINERs:
                    BYTES * REPETITIONS = sizeof(CONTAINER); Added 
                    'checkfilename' routine to check syntax of file names in 
                    TABLE pointers.
  25 Jun 2001, acr: Relabel invalid numeric columns as type=SPARE; do not 
                    attempt to print out summary values for SPARE columns
  26 Jun 2001, acr: Fixed stupid problem of not setting ITEM_OFFSET for columns.

  03 Jan 2002, acr: Added batch mode capabilities; changed "flag blanks"
                    option to "-f" from "-b".

  26 Feb 2002, acr: Increased precision of max/min found in file

  07 Mar 2002, acr: Bug fixes: Added check for valid max/min before printing
                    summary - a null marker is printed if no valid values
                    were encountered; Removed a couple of checks specific
                    to RECORD_BYTES that duplicated checks on ROW_BYTES.
                    When ROW_BYTES<>RECORD_BYTES, ROW_BYTES should take
                    precedence - the conditions being flagged were not
                    truly errors.
  08 Mar 2002, acr: More bugs: the test for a table-type object was giving
                    false positives, so the macro has been replaced by a 
                    function; inappropriate checks against RECORD_BYTES
                    were replaced with checks agains parent object size;
                    cleaned up table attributes listing for containers.
  14 Mar 2002, acr: Added tolerance for checks against label max/min in 
                    binary files to avoid flagging caused by rounding and
                    conversion of the label values and the limits of 
                    precision on real number comparisons; added processing
                    time report and "-t" option to command line.
  08 Aug 2002, acr: Added global 'error_count' to send appropriate exit
                    status at completion.
  06 Jan 2003, acr: Adjusted 'breakline' routine and usage to preserve blank
                    space inside quotes for use in character constants; 
                    disabled the underscores-within-quotes check until PDS
                    DEs can figure out what they want to do about this.
  16 Jan 2003, acr: Upgrade to ignore blank padding in MISSING_CONSTANT
                    and INVALID_CONSTANT field comparisons.
  01 Feb 2003, acr: Added handling of NOT_APPLICABLE_-, UNKNOWN_-, and 
                    NULL_CONSTANT keywords; adjusted output summary format
  02 May 2003, acr: Fixed a couple of stupid bugs that caused the program to 
                    crash while skipping over non-table objects; and to 
                    explicitly remove blanks and double quotes from pointer
                    values.
  06 Dec 2006, acr: Modified TIME field checking to remove some annoying and
                    spurious error messages; added version info and "-v" 
                    option
  11 Dec 2006, acr: Modified to allow TIME field checking to accept field 
                    values truncated at reasonable points.
  21 Feb 2007, acr: Fixed dumb bug in TIME field checking.
  03 May 2007, acr: Increased maximum TIME field width (standards change)
  19 Feb 2008, acr: Fixed memory leak caused by undocumented attempt to 
                    fixed table offset interpretation problem.  Also fixed
                    the table offset interpretation problem (in subroutine
                    "breakline").
  19 Aug 2013, acr: Changed 'getline' to 'getlblline' to avoid conflicts
                    in new compiler.
*/

#define  VERSION_ID  "PDSTV Version 1.1.4 (19 Feb 2008)"

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <errno.h>
#include <values.h>
#include <time.h>

#include "pdstv.h"
#include "tvutil.h"
#include "bintv.h"
#include "tverr.h"


/*---------------------------------------------------------------------------
  Global Variables 
*/

FILE    *label, *data;              /* input files                      */
FILE    *report;                    /* output file                      */
char     barline[100],blanks[100];  /* report file dingbats             */
char     dblbar[100];
int      flag_blank_fields; 
int      batch_mode;
int      error_count;

table   *table_top;                 /* Table object list                */


/*---------------------------------------------------------------------------
  Functions
*/

int   setup                     /* Read arguments and open files             */
        (int argc, char *argv[], char *label_file, FILE **label, 
         FILE **report, char *directory, int *flag_blanks, 
         int *batch_mode, int *time_display);
void  parse_pointer             /* Parse the object pointer for file/offset  */
        (char *value, int record_bytes, char *path, table *tbl, int linecount);
void  parse_FORMAT              /* Parse FORMAT string for attributes        */
        (column *col, int linecount);
int   check_table               /* Check current table object definition     */
        (int *linecount, table *tab, int record_bytes, int fixed_length); 
int   get_column_attributes     /* Read COLUMN Parameters                    */
        (int column_number, column *col, int *linecount, int super_offset,
         int ASCII_flag, char *colnum_prefix);
int   check_column_attributes   /* Check column parameters for consistency   */
        (column *col, int object_offset, int parent_row_bytes,
         int table_row__bytes, int ASCII_flag, FILE *report, int row_flag,
         int linecount);
int   get_container_attributes  /* Read CONTAINER Parameters                 */
        (char *cntlabel, container *cnt,   int *linecount,   
         int row_bytes,  int record_bytes, int super_offset, 
         int ASCII,      char *colnum_prefix);
void  checkfilename(char *file, int linecount);
int   table_type(char *object_type);  /* Check for TABLE objects             */

/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/

main(argc,argv)
  int   argc;
  char *argv[];

{ /* label values (correspond to keywords of same name): */

  int       record_bytes = 0;
  int       file_records = 0;
  char      record_type[30];
  int       fixed_length =-1;     /* 1 : RECORD_TYPE =  "FIXED LENGTH"
                                     0 : RECORD_TYPE <> "FIXED LENGTH"
                                    -1 : RECORD_TYPE not found 
                                  */
  char      tbl_offset_string[50];      /* Offset strings from pointers      */
  char      path[400];                  /* directory path from command line  */


  /* command line variables */

  char      label_file[200];                /* input label file name         */
  char      report_file[200];               /* report file name              */
  int       time_display;                   /* flag to print process time    */


  /* housekeeping */

  int       i,j,k;                          /* loop/subscript                */
  char      line[MAXRECORDLENGTH];          /* input line buffer             */
  char      lastline[MAXRECORDLENGTH];      /* extra line buffer             */
  int       linecount;                      /* input line number             */
  int       tablecount,table_number;        /* number of TABLE objects       */
  int       done;                           /* loop flag                     */
  char      keyword[80];                    /* label keyword string          */
  char      padval[80];                     /* label value string with blanks*/
  char     *value;                          /* value string without blanks   */
  int       length;                         /* string length                 */
  int       err;                            /* error number                  */
  char     *crem;                           /* conversion remainder pointer  */
  int       still_looking;                  /* logical_flags                 */
  char     *p;                              /* utility pointer               */
  table    *newtab, *tab, *nexttab;
  char      objlabel[80];
  double    total_clock;


  /*=========================================================================*/

  clock();    /* Start the clock */

  /*=========================================================================*/

  /* Initialize global printing dingbats: */

  memset((void *)blanks, ' ',100);
  memset((void *)barline,'-',100);
  memset((void *)dblbar, '=',100);

  /* Set total error count to zero: */

  error_count = 0;

  /* Read arguments, open files: */

  if (setup(argc,argv,label_file,&label,&report,path,
            &flag_blank_fields,&batch_mode,&time_display) == 0) 
    { if (batch_mode) fprintf (report,"OK\n");
      exit(error_count);
    }

  /* Write header to report file: */

  if (!batch_mode)
    { fprintf (report,"%28.28sPDS Table Verifier Report\n",blanks);
      fprintf (report,"%28.28s-------------------------\n",blanks);
      fprintf (report,"%s\n\n",VERSION_ID);
      fprintf (report,"   Label file: %s\n",label_file);

 
      /* Report file label error section banner: */

      fprintf (report,"%79.79s\n\n",dblbar);
      fprintf (report,"\nLABEL ERRORS:\n-------------\n\n");
    }

 /*--------------------------------------------------------------------*/

  /* Read file keywords (until first object definition), searching for and 
     saving keywords:
  */

  table_top   = NULL;
  tablecount  = 0;
  linecount   = 0;

  done = FALSE;
  while (!done)          /* repeat until the general stuff is done */
    { if (!getlblline(line,label,&linecount))
        { tverr(UNEXP_EOF,linecount,"label");
          if (batch_mode) fprintf (report,"OK\n");
          fclose(report);
          exit(11);
        }
      breakline(line,keyword,padval,linecount);
      value = trim_copyof(padval);
  
      /* Match keyword against list and save value: */

      if      (strcmp(keyword,"RECORD_BYTES") == 0)
        { record_bytes = atoi(value);
          if (record_bytes <= 0)
            { tverr(INV_RECORD_BYTES,linecount,value);
              record_bytes = 0;
            }
        }

      else if (strcmp(keyword,"FILE_RECORDS") == 0)
        { file_records = atoi(value);
          if (file_records <= 0)
            { tverr(INV_FILE_RECORDS,linecount,value);
              file_records = 0;
            }
        }

      else if (strcmp(keyword,"RECORD_TYPE") == 0)
        { strcpy(record_type,value);

          if (strcmp(record_type,"FIXED_LENGTH")==0      ||
              strcmp(record_type,"\"FIXED LENGTH\"")==0  ||
              strcmp(record_type,"\"FIXED_LENGTH\"")==0)
            { fixed_length = TRUE; }
          else if (strstr(record_type,"FIXED"))
            { fixed_length = TRUE;
              tverr(INV_RECORD_TYPE,linecount);
            }
          else
            { fixed_length = FALSE; }
        }          

      /* If we've got a pointer, we check to see if this is a table-type
         object. If so, we allocate a new TABLE structure for it, start
         filling it, and link it into the current list (top node is 'tab'):
      */

      else if (keyword[0] == '^')
        { if (table_type(keyword+1))  /* Skip past pointer character */
            { tablecount++;

              newtab = (table *)malloc(sizeof(table));
              newtab->label            = NULL;
              newtab->datafile         = NULL;
              newtab->name             = NULL;
              newtab->offset           = 0;
              newtab->offset_read[0]   = '\0';
              newtab->record_offset    = TRUE;
              newtab->ascii            = TRUE;
              newtab->checked          = FALSE;
              newtab->rows             = 0;
              newtab->row_bytes        = 0;
              newtab->row_prefix_bytes = 0;
              newtab->row_suffix_bytes = 0;
              newtab->fldlist          = NULL;
              newtab->next             = NULL;

              parse_pointer(value,record_bytes,path,newtab,linecount);
              if (newtab->datafile == NULL)
                { newtab->datafile = copy_of(label_file); }
              newtab->label = copy_of(keyword+1);

              /* Now link into the table list: */

              if (table_top == NULL)
                { table_top = newtab; }
              else
                { tab = table_top;
                  while (tab->next != NULL)
                    { tab = tab->next; }
                  tab->next = newtab;
                }
            }
        }


      else if (strcmp(keyword,"OBJECT") == 0)
        { done = TRUE; }

    }


  /*-----------------------------------------------------------------*/
  /* File-level validity checks: Make sure required file keywords are
     present, and that there is at least one table-type object pointer.
  */

  if (record_bytes == 0)
    { tverr(NO_RECORD_BYTES,linecount); }

  if (file_records == 0)
    { tverr(NO_FILE_RECORDS,linecount); }

  if (fixed_length <  0)
    { tverr(NO_RECORD_TYPE,linecount); }

  /* If there were no table-type objects, there's no point in carrying on: */

  if (tablecount < 1)
    { tverr(NO_TABLES,linecount);
      if (batch_mode) fprintf (report,"OK\n");
      fclose(report);
      exit(error_count);
    } 

  /* End of the general label section: */

  if (!batch_mode) fprintf (report,"\n%79.79s\n\n",dblbar);

  /*-------------------------------------------------------------------*/

  /* Now we finish reading through the label, checking table objects as
     we encounter them. We assume that pointers are listed in the same
     order as the label objects, unless that order is overridden by 
     explicitly named pointers (probably not a good idea, but what the
     heck):
  */

  table_number = 0;

  done = FALSE;

  while (done == FALSE) 
   { /* We know we're at an object line, so we check to see if it
         is a table object:
      */

      if (!table_type(value))   /* Skip non-tables */
        { done = skip_object(value,&linecount);
          if (!done) done = next_object(value,&linecount);
          continue;
        }

      /* We know we've got a table object, so match it to a pointer: */

      table_number++;
      tab = table_top;
      still_looking = TRUE;
      while (still_looking)
        { if (tab->checked == FALSE  &&  strcmp(tab->label,value) == 0)
            { still_looking = FALSE; }
          else
            { tab = tab->next;
              still_looking = (tab != NULL);
            }
        }

      /* If we failed to find one, signal an error and go on to the next
         object:
      */

      if (tab == NULL)
        { tverr(MISSING_POINTER,linecount,value);
          done = skip_object(value,&linecount);
          if (!done) { done = next_object(value,&linecount); }
          continue;  /* back to the top of the loop */
        }

      /* OK, we have found a table and we have its pointer, so we're ready
         to read it and check it:
      */

      tab->tblnum = table_number;
      done = check_table(&linecount,tab,record_bytes,fixed_length);

      /* 'checktable' should leave us at the end of the table object, so we
         find the beginning of the next object:
      */

      done = next_object(value,&linecount);

   } /* WHILE not done with objects */

  /* We'll check the end status ('done') here, to look for a common syntax 
     error which might not be signaled otherwise:
  */

  if (done == ENDOFOBJECT)
    { tverr(BAD_END_OBJECT,linecount); }



  fclose(label);

  /* Some code for debug displays. This should be disabled in the operational
     system:
  */

/*------------------------
  print_structure(table_top);
------------------------*/

/*-----------------------
  if (table_top == NULL)
    { printf ("No tables found (%d)\n",tablecount); }
  else
    { printf ("%d table(s) found:\n\n",tablecount); 
      tab = table_top;
      while (tab)
        { printf ("\n\n");
          printf ("   Label: %s\n",tab->label);
          printf ("Datafile: %s\n",tab->datafile);
          printf ("  Offset: %d   Record Offsets: %d\n",
                             tab->offset, tab->record_offset);
          tab = tab->next;
        }
    } 
------------------------*/


 /*--------------------------------------------------------------------*/
 /*--------------------------------------------------------------------*/


  /* Finish report: */

  if (!batch_mode)
    { fprintf (report,"%79.79s\n\n",dblbar);
      fprintf (report,"\nDone.");
      if (time_display)
        { total_clock = (double)(clock())/(double)(CLOCKS_PER_SEC);
          fprintf (report,"  Processing Time: %f seconds\n",total_clock);
        }
      else
        { fprintf (report,"\n"); }
    }
  else
    { fprintf (report,"OK\n"); }

  fclose(report);

  exit(error_count);

}

/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
/* SUBROUTINES                                                               */
/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/


int setup(int argc, char *argv[], char *label_file, FILE **label, 
          FILE **report, char *directory, int *flag_blanks, 
          int *batch_mode, int *time_display)

/* Routine to read the input arguments and open the files needed.  If a
   failure status is returned the main program should end.

   Parameters:

     int    argc;
     char  *argv[];
     char  *label_file;   label file name 
     FILE **label;        label file pointer  
     FILE **report;       report file pointer 
     char  *directory;    remote directory path name 
     int   *flag_blanks   TRUE for blank character field flagging
     int   *batch_mode    TRUE if running in batch mode
     int   *time_display  TRUE if processing time should be included in report

*/

{ int   i;
  int   len;
  char  filename[300];

  strcpy(directory,"./");
  *report       = stdout;
  *label        = NULL;
  *flag_blanks  = 0;
  *batch_mode   = 0;
  *time_display = 0;

  if (argc == 1)
    { tverr(USAGE,0); 
      exit(error_count);
    }

  i = 1;
  while (i < argc )
    { if (!strcmp(argv[i],"-v"))
        { printf("%s\n",VERSION_ID); 
          exit(0);
        }
      else if (!strcmp(argv[i],"-d"))
        { ++i;
          if (i >= argc)
            { tverr(USAGE,0);
              return 0;
            }
          strcpy(directory,argv[i]);
          len = strlen(directory);
          if (directory[len-1] != '/')
            { directory[len]   = '/';
              directory[len+1] = '\0';
            }
          ++i;
        }

      else if (!strcmp(argv[i],"-o") &&  !(*batch_mode))
        { ++i;
          if (i >= argc)
            { tverr(USAGE,0);
              return 0;
            }
          if ((*report=fopen(argv[i],"w")) == NULL)
            { tverr(OPEN_FAIL,0,argv[i],"writing", strerror(errno));
              return 0;
            }
          ++i;
        }

      else if (!strcmp(argv[i],"-f"))
        { *flag_blanks = 1;
          ++i;
        }

      else if (!strcmp(argv[i],"-b"))
        { *batch_mode = 1;
          if (*report != stdout)
            { fclose(*report); 
              *report = stdout;
            }
          ++i;
        }

      else if (!strcmp(argv[i],"-t"))
        { *time_display = 1;
          ++i;
        }

      else
        { strcpy(label_file,argv[i]);
          ++i;
        } 

    }      /* end while */

  /* Open the label file.  If it is not found in the default directory, the
     directory included in the '-d' option is prepended and a second attempt
     is made.
  */

  if ((*label=fopen(label_file,"r")) == NULL)
    { strcpy(filename,directory);
      strcat(filename,label_file);
      strcpy(label_file,filename);
      if ((*label=fopen(label_file,"r")) == NULL)
        { tverr(OPEN_FAIL,0,label_file,"reading",strerror(errno));
          return 0;
        }
    }

  return 1;
}

/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/

void parse_pointer(char *value, int record_bytes, char *path, table *tbl,
                   int linecount)


/* Routine to extract the various bits of information from the ^TABLE pointer
   value string.

   Parameters:
       value         Pointer string to be parse
       record_bytes  RECORD_BYTES value from top of label
       path          Data file directory passed in on the command line, if any
       tbl           Table structure to be filled
*/

{ int    record_offset;  /* 1 if offset is given as record count (no <BYTES>)*/
  long   i,j,k;          /* look/subscript/temporary storage */
  char  *rem, *p;        /* string pointers for conversions */
  char   bsfx[10];       /* Holds the offset type string (null or <BYTES>) */
  char   filename[200];  /* buffer for data file name and path */
  char   ptrfile[100];   /* buffer for checking filename syntax */
  char   buff[50];       /* 'value' editing buffer */

  /* The object pointer value has several possible formats:

        Attached labels:    ^TABLE = 25                      record offset
                            ^TABLE = 100 <BYTES>             byte offset

        Detached labesl:    ^TABLE = "FILE.EXT"              no offset
                            ^TABLE = ("FILE.EXT",25)         record offset
                            ^TABLE = ("FILE.EXT",100<BYTES>) byte offset

      On entering this routine, the value has any double quotes and spaces
      stripped away.  Also the "filename" string may contain a directory name,
      if one was entered on the command line.
  */
  
  /* Remove double quotes and spaces from the value: */
  
  j = 0;
  for (i=0; i<strlen(value); i++)
    { if (value[i] != '"'  &&  !isspace(value[i]))
        { buff[j] = value[i];
	  j++;
	}
    }
  buff[j] = '\0';
  strcpy(value,buff);

  /* Save a character version of the offset without parentheses: */

  if (value[0] == '(')
    { strcpy(tbl->offset_read,value+1); }
  else
    { strcpy(tbl->offset_read,value); }
  p = strchr(tbl->offset_read,')');
  if (p) p[0] = '\0';

  /* Check for the <BYTES> flag, remove it if found, and set record_offset: */

  if (p = strstr(value,"<BYTES>"))
    { tbl->record_offset = 0;
      p[0] = '\0';
      strcpy(bsfx," <BYTES>");
    }
  else
    { tbl->record_offset = 1;
      bsfx[0] = '\0';
    }

  /* Check the attached possibilities first by attempting to convert the
     value to an integer.  If this fails (if it leaves any sort of remainder),
     assume the value is for a detached label:
  */

  /*********************************************************************/
  /* NOTE: PDS offsets are 1-based, NOT 0-based, thus the subtraction. */
  /*********************************************************************/

  if (value[0] != '(')
    { i = strtol(value,&rem,10) -1 ;
      if (rem == NULL  ||  strcspn(rem," ") == 0)
        { 
          /* It converted without remainder (or the remainder was a blank
             string) and so must refer to an attached label.  Set the byte 
             offset to be returned (multiply by record_bytes if a record 
             offset was read) and set the data file name to be null to 
             indicate that the data are in the input label file, then return:
          */

          i = (tbl->record_offset)? i * record_bytes : i;
          tbl->offset = i;
          tbl->datafile = NULL;

          /* Save the string version for later display, if needed: */

          strcpy(tbl->offset_read,value);
          strcat(tbl->offset_read,bsfx);

          return;
        }
    }

  /* At this point we know the value indicates a detached data file. If there
     is no opening parenthesis, there is just a file name in the value.  This
     is appended to the input directory (if any) and returned:
  */

  if (value[0] != '(')
    { strcpy(filename,path);
      strcat(filename,value);
      tbl->datafile = (char *)malloc(strlen(filename)+1);
      strcpy(tbl->datafile,filename);
      tbl->offset = 0;
    }

  /* Otherwise we're left with a value that has an opening paren, a filename,
     a comma, and an offset value.  Separate out these parts and save them:
  */
  else
    { value++;                    /* skip over the opening parenthesis */
      rem = strchr(value,',');    /* find comma */
      p = rem + 1;                /* Offset begins after the comma */
      rem[0] = '\0';              /* end string after filename */

      /*********************************************************************/
      /* NOTE: PDS offsets are 1-based, NOT 0-based, thus the subtraction. */
      /*********************************************************************/

      strcpy(filename,path);
      strcat(filename,value);     /* save filename */
      tbl->datafile = (char *)malloc(strlen(filename)+1);
      strcpy(tbl->datafile,filename);

      i = atol(p) - 1;            /* closing paren is ignored */
      i = (tbl->record_offset)? i * record_bytes : i;
      tbl->offset = i;                /* save offset */
    }

  /* Finally, before we go, we make sure the filename syntax is valid: */

  checkfilename(value,linecount);

  /* Done done. */

  return;
}

/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/

void parse_FORMAT(column *col,int linecount)

  /* This routine parses the format string saved in the column definition
     and fills the related parameter fields. Note that the format may 
     contain a repetition count if the COLUMN has more than one item.
     Valid field formats are:

        iAw       i(Aw)
        iIw       i(Iw)
        iFw.d     i(Fw.d)
        iEw.d     i(Ew.d)

     where   i  =  item counts (ITEMS)
             w  =  field width
             d  =  precision (digits right of the decimal)

  */

{ char    buff[50];  /* Copy of format string */
  long    repcount;  /* repetition count: should be = items */
  char   *rem, *p;   /* conversion pointers */
  int     i,j,len;

  repcount = 0;

  /* We'll begin by making a copy of the format string and clipping trailing
     blanks:
  */

  strcpy(buff,col->format);
  len = strlen(buff);
  while (buff[len-1] == ' ') 
    { buff[len-1] = '\0'; 
      len--;
    }

  /* If this begins with a digit, we convert the numeric part and save it
     as the repetition count:
  */

  if (isdigit(buff[0]))
    { repcount = strtol(buff,&rem,10);
      if (repcount == 0)
        { tverr(INV_FORMAT,linecount,col->colnum,col->format); }
      else if (repcount != col->items)
        { tverr(BAD_REPCOUNT,linecount,col->colnum,col->format,col->items); }

      p = rem;
    }

  /* If not, we make sure no ITEMS were declared for the column: */

  else
    { if (col->items > 1)
        { tverr(NO_REPCOUNT,linecount,col->colnum,col->format); }
      p = buff; 
    }

  /* If the next character is a '(' the last character should be ')'. We
     remove these:
  */

  if (p[0] == '(')
    { p++;
      i = strlen(p);
      if (p[i-1] == ')')
        { p[i-1] = '\0'; }
      else
        { tverr(INV_FORMAT,linecount,col->colnum, col->format); }
     }

  /* The next character should be a type designator, either A, I, F or E.
     We check for it and branch depending on whether or not we expect a
     precision value:
  */

  if (p[0] == 'A'  ||  p[0] == 'I')
    { p++;

      /* Convert the integer width. There should be no remainder: */

      col->fwidth = (int) strtol(p,&rem,10);
      if (col->fwidth < 1  ||  strlen(rem) > 0)
        { tverr(INV_FORMAT,linecount,col->colnum, col->format); }
      col->fprecision = 0;
    }

  else if (p[0] == 'F'  ||  p[0] || 'E' )
    { p++;

      /* Convert the first integer as the width:   */

      col->fwidth = (int)strtol(p,&rem,10);
      if (col->fwidth < 1)
        { tverr(INV_FORMAT,linecount,col->colnum, col->format); }

      /* The remainder should begin with a decimal point, after which is
         the precision:
      */

      p = rem;
      if (p[0] != '.')
        { tverr(INV_FORMAT,linecount,col->colnum, col->format);
          col->fprecision = 0;
        }
      else
        { p++;
          col->fprecision = (int)strtol(p,&rem,10);

          /* Precision may be zero here, but there still should be no 
             remainder:
          */

          if (col->fprecision < 0  ||  strlen(rem) > 0)
            { tverr(INV_FORMAT,linecount,col->colnum, col->format); }
        }
    }

  else
    { tverr(INV_FORMAT,linecount,col->colnum, col->format); }

  /* And we're done: */

  return;
}

/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/

int check_table (int *linecount, table *tab,
                 int record_bytes, int fixed_length)


  /* This routine reads through the current table-type object definition,
     collects the various parameters and attributes, performs syntax checking 
     on the definition, and then attempts to use the column definitions to
     read the corresponding data from the indicated file ('datafile')
     starting at 'offset' bytes from the beginning of the file.

     Parameters:
        linecount       Pointer to current label location
        tab             Pointer to correspondong table structure
        record_bytes    RECORD_BYTES value from label
        fixed_length    TRUE if fixed-length records    
  */

{ /* Table parameters: */

  long int   rows;
  int        row_bytes;
  int        columns;

  /* Data checking parameters: */

  long int   rows_read;
  int        max_length   = 0;              /* maximum record length         */
  int        min_length   = MAXINT;         /* minimum record length         */
  int        record_count = 0;              /* number of records in file     */
  int        column_count = 0;
  int        object_offset = 0;             /* No offset for main table      */
  char       colnum_prefix[5];              /* Null prefix for main table    */

  /* housekeeping */

  int        i,j,k;                         /* loop/subscript                */
  char       line[MAXRECORDLENGTH];         /* input line buffer             */
  int        not_done;                      /* loop flag                     */
  char       keyword[80];                   /* label keyword string          */
  char       padval[80];                    /* label value string with blanks*/
  char      *value;                         /* label value without blanks    */
  int        length;                        /* string length                 */
  int        err;                           /* error number                  */
  char      *p;                             /* utility pointer               */
  int        endoftable;
  int        still_looking;                 /* loop flag                     */
  int        row_flag = TRUE;               /* parameter flag                */
  field     *newfld, *currentfld, *fld;
  column    *col;
  container *cnt;

  /* We know when this routine is called that the current input line is the
     "OBJECT = " line. First order of business is to read through the object
     definition collecting attributes and column definitions until we reach
     the END_OBJECT line for the table.
  */

  rows      = 0;
  row_bytes = 0;
  columns   = 0;
  colnum_prefix[0] = '\0';

  endoftable = FALSE;
  
  /* Print the banner for the output report: */

  if (!batch_mode)
    { fprintf (report,"\n%79.79s\n\n",dblbar);
      sprintf (line, "%s (Table #%d):",tab->label,tab->tblnum);
      length = strlen(line);
      fprintf (report,"\n%s\n%*.*s\n\n",line,length,length,barline);
    }

  /* We begin by reading keywords from the present location until we encounter
     the first COLUMN  or CONTAINER definition.
  */

  not_done = 1;
  while (not_done)
    { if (!getlblline(line,label,linecount))
        { tverr(UNEXP_EOF,*linecount,"label");
          return 1;
        }
      breakline(line,keyword,padval,*linecount);
      value = trim_copyof(padval);

      /* Checking for required keywords: */

      if (strcmp(keyword,"ROWS")==0)
        { rows = atol(value); 
          tab->rows = rows;
        }

      else if (strcmp(keyword,"ROW_BYTES")==0)
        { tab->row_bytes = atoi(value); }

      else if (strcmp(keyword,"ROW_PREFIX_BYTES")==0)
        { tab->row_prefix_bytes = atoi(value); }

      else if (strcmp(keyword,"ROW_SUFFIX_BYTES")==0)
        { tab->row_suffix_bytes = atoi(value); }

      else if (strcmp(keyword,"INTERCHANGE_FORMAT")==0)
        { if (strcmp(value,"ASCII") == 0)
            { tab->ascii = TRUE; }
          else
            { tab->ascii = FALSE; }
        }

      else if (strcmp(keyword,"COLUMNS")==0)
        { columns = atoi(value); }

      else if (strcmp(keyword,"OBJECT")==0)
        { not_done = FALSE; }
    }

  /* We do some error-checking on the top-level table values before going
     on:
  */

  row_bytes = tab->row_prefix_bytes + tab->row_bytes + tab->row_suffix_bytes;
  if ((row_bytes != record_bytes)  &&  fixed_length)
    { tverr(ROWB_NE_RECB,*linecount,row_bytes,record_bytes); }

  /* OK, now we're ready to start collecting the column definitions. Columns
     may be either scalar COLUMN objects or (possibly) repeating CONTAINER
     objects. We check for the object type and call the appropriate 
     subroutine to gather the relevant parameters:
  */

  not_done     = TRUE;
  column_count = 0;
  while (not_done)
    { /* Check for valid column types and deal: */

      /* OBJECT = COLUMN */

      if (strcmp(value,"COLUMN") == 0)
        { column_count++;

          /* Allocate new field and column objects: */

          newfld = (field *)malloc(sizeof(field));
          newfld->type = COLUMN;
          newfld->next = NULL;
          col = (column *)malloc(sizeof(column));
          newfld->ptr.col = col;
          
          endoftable = get_column_attributes(column_count,col,linecount,
                                             tab->row_prefix_bytes,
                                             tab->ascii,colnum_prefix);
          check_column_attributes(col,tab->row_prefix_bytes,tab->row_bytes,
                                  tab->row_bytes,tab->ascii,report,row_flag,
                                  *linecount);


          /* Link the field into the table: */

          if (tab->fldlist == NULL)
            { tab->fldlist = newfld; 
              currentfld   = newfld;
            }
          else
            { currentfld->next = newfld;
              currentfld       = newfld;
            }
        }

      /* OBJECT = CONTAINER, each CONTAINER = 1 column */


      else if (strstr(value,"CONTAINER") != NULL)
        { column_count++;

          newfld = (field *)malloc(sizeof(field));
          newfld->type = CONTAINER;
          newfld->next = NULL;
          cnt = (container *)malloc(sizeof(container));
          newfld->ptr.cnt = cnt;

          endoftable = get_container_attributes(value, cnt, linecount,
                          tab->row_bytes, record_bytes, tab->row_prefix_bytes, 
                          tab->ascii,colnum_prefix);

          if (tab->fldlist == NULL)
            { tab->fldlist = newfld; 
              currentfld   = newfld;
            }
          else
            { currentfld->next = newfld;
              currentfld       = newfld;
            }
        }

      /* Invalid sub-object - ignore it: */

      else
        { tverr(INV_SUBOBJECT,*linecount,value,"table");
          endoftable = skip_object(value,linecount);
        }

      /* If we havne't already encountered a premature end of table, check
         to see if we're at the end of the table by reading the next line
         and checking for "END_OBJECT = TABLE":
      */

      if (!endoftable)
        { if (!getlblline(line,label,linecount))
            { tverr(UNEXP_EOF,*linecount,"label");
              return ENDOFFILE;
            }
          breakline(line,keyword,padval,*linecount);
          value = trim_copyof(padval);

          if (strcmp(keyword,"END_OBJECT") == 0)
            { endoftable = TRUE;

              /* Check for label match: */

              if (value  &&  strcmp(value,tab->label) != 0)
                { tverr(OBJLBL_MISMATCH,*linecount,value,tab->label); }
            }

          else if (strcmp(keyword,"END") == 0)
            { tverr(UNEXP_END,*linecount);
              return ENDOFLABEL;
            }
        }

      not_done = !endoftable;

      /* Next column. */
    }


  /* Make sure we saw the right number of COLUMNs: */

  if (columns != column_count)
    { tverr(COLUMN_MISCOUNT,*linecount,columns,column_count); }
  tab->columns = columns;

  /* And call the routine to read the data and check it against the column
     specifications:
  */

  if (tab->ascii)
    { read_ascii_table_data(tab, column_count, record_bytes); }
  else
    { read_binary_table_data(tab, column_count, record_bytes); }


  /* Return the end-of-table status and we're done here: */

  return endoftable;
}


/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/

int get_column_attributes(int column_count, column *col,int *linecount,
                          int super_offset, int ASCII, char *colnum_prefix)

  /* Routine to read the OBJECT definition for the current COLUMN object.
     When this routine is called, the current line contains the "OBJECT =
     COLUMN" declaration.

     Parameters:
       column_count    Number of the current column
       col             Column attributes structure
       linecount       Label line pointer
       super_offset    Offset to beginning of object containing this column
       ASCII           TRUE for ASCII tables
       colnum_prefix   Prefix for the column index string

     Normal return value is 0. Anything else indicates a problem.
  */

{ char   line[MAXRECORDLENGTH];     /* input line buffer */
  char   keyword[80],padval[80];
  char  *value;
  int    not_done;                  /* loop flag */
  int    err;                       /* Function return status */
  int    i,j,k;                     /* loop/subscript */
  char  *crem;                      /* conversion pointer */
  int    msb;                       /* True if MSB field */
  int    OK = 0;                    /* Normal return status */
  int    column_number;             /* Explicit COLUMN_NUMBER value */


  /* Initialize column attributes: */

  col->start_byte         = super_offset;
  col->items              = 1;
  col->item_bytes         = 0;
  col->item_offset        = 0;
  col->msbflag            = -1;
  col->max.str            = NULL;
  col->min.str            = NULL;
  col->mmflag             = 0;
  col->vmax.str           = NULL;
  col->vmin.str           = NULL;
  col->vmflag             = 0;
  col->dmax               = 0;
  col->dmin               = 0;
  col->dmflag             = 0;
  col->invalid.str        = NULL;
  col->invflag            = 0;
  col->missing.str        = NULL;
  col->missflag           = 0;
  col->not_applicable.str = NULL;
  col->naflag             = 0;
  col->unknown.str        = NULL;
  col->unkflag            = 0;
  col->null.str           = NULL;
  col->nullflag           = 0;
  col->offset             = 0;
  col->scaling_factor     = 1;
  col->format[0]          = '\0';
  col->name[0]            = '\0';
  col->maxstr             = NULL;
  col->minstr             = NULL;
  col->invalidcount       = 0;
  col->missingcount       = 0;
  col->nacount            = 0;
  col->unknowncount       = 0;
  col->nullcount          = 0;
  col->badcount           = 0;
 
  strcpy(col->colnum,colnum_prefix);

  /* We will loop until we unexpectedly run out of label, or we 
     encounter the next END_OBJECT line (since columns may not 
     have sub-objects):
  */

  not_done = 1;
  while (not_done)
    { if (!getlblline(line,label,linecount))
        { tverr(UNEXP_EOF,*linecount,"label");
          return ENDOFFILE;
        }
      breakline(line,keyword,padval,*linecount);
      value = trim_copyof(padval);

      if (strcmp(keyword,"END")==0)
        { tverr(UNEXP_END,*linecount);
          return ENDOFLABEL;
        }
      else if (strcmp(keyword,"END_OBJECT")  == 0)
          not_done = FALSE;

      else if (strcmp(keyword,"BYTES")      == 0)
        { col->bytes = atoi(value);
          col->item_bytes = col->bytes;
        }

      else if (strcmp(keyword,"NAME")       == 0)
          strcpy(col->name,value);

      else if (strcmp(keyword,"COLUMN_NUMBER") == 0)
        { strcat(col->colnum,value);
          column_number = atoi(value);
        }

      else if (strcmp(keyword,"START_BYTE") == 0)
          col->start_byte = atoi(value);

      else if (strcmp(keyword,"ITEMS")      == 0)
          col->items = atoi(value);

      else if (strcmp(keyword,"ITEM_BYTES") == 0)
          col->item_bytes = atoi(value);

      else if (strcmp(keyword,"ITEM_OFFSET") == 0)
          col->item_offset = atoi(value);

      else if (strcmp(keyword,"VALID_MAXIMUM")    == 0)
        { col->vmax.str = copy_of(value);
          col->vmflag += 1;
        }
      else if (strcmp(keyword,"VALID_MINIMUM")    == 0)
        { col->vmin.str = copy_of(value);
          col->vmflag += 2;
        }
      else if (strcmp(keyword,"MAXIMUM")    == 0)
        { col->max.str = copy_of(value);
          col->mmflag += 1;
        }
      else if (strcmp(keyword,"MINIMUM")    == 0)
        { col->min.str = copy_of(value);
          col->mmflag += 2;
        }
      else if (strcmp(keyword,"DERIVED_MAXIMUM") == 0)
        { col->dmax = strtod(value,(char **)NULL);
          col->dmflag += 1;
        }
      else if (strcmp(keyword,"DERIVED_MINIMUM") == 0)
        { col->dmin = strtod(value,(char **)NULL);
          col->dmflag += 2;
        }
      else if (strcmp(keyword,"INVALID_CONSTANT")== 0)
        { col->invalid.str = copy_of(value);
          col->invflag = 1;
        }
      else if (strcmp(keyword,"INVALID")         == 0)
        { col->invalid.str = copy_of(value);
          col->invflag = 1;
          tverr(OBSOLETE_KEYWORD,*linecount,column_count+1,
                                "INVALID","INVALID_CONSTANT");
        }
      else if (strcmp(keyword,"MISSING_CONSTANT")== 0)
        { col->missing.str = copy_of(value);
          col->missflag = 1;
        }
      else if (strcmp(keyword,"MISSING")         == 0)
        { col->missing.str = copy_of(value);
          col->missflag = 1;
          tverr(OBSOLETE_KEYWORD,*linecount,column_count+1,
                                "MISSING","MISSING_CONSTANT");
        }
      else if (strcmp(keyword,"NOT_APPLICABLE_CONSTANT")== 0)
        { col->not_applicable.str = copy_of(value);
          col->naflag = 1;
        }
      else if (strcmp(keyword,"UNKNOWN_CONSTANT") == 0)
        { col->unknown.str = copy_of(value);
          col->unkflag = 1;
          tverr(BAD_CONSTANT,*linecount,column_count+1,
                             "UNKNOWN_CONSTANT","MISSING_CONSTANT");
        }
      else if (strcmp(keyword,"NULL_CONSTANT") == 0)
        { col->null.str = copy_of(value);
          col->nullflag = 1;
          tverr(BAD_CONSTANT,*linecount,column_count+1,
                             "NULL_CONSTANT","MISSING_CONSTANT");
        }
      else if (strcmp(keyword,"OFFSET")          == 0)
          col->offset = strtod(value,(char **)NULL);

      else if (strcmp(keyword,"SCALING_FACTOR")  == 0)
          col->scaling_factor = strtod(value,(char **)NULL);

      /* Because of the different data types involved in ASCII and binary
         tables, we split here to handle the processing for each type in 
         a separate block (for readbility):
      */

      else if (strcmp(keyword,"DATA_TYPE")       == 0  &&  ASCII)
        { if (strstr(value,"INTEGER") != NULL)
            { col->type = SIGNED_INTEGER;
              if (strstr(value,"ASCII_INTEGER") == NULL  &&
                  strstr(value,"ASCII INTEGER") == NULL)
                { tverr(OBSOLETE_TYPE,*linecount,column_count+1,value,
                        "ASCII_INTEGER");
                }
            }
          else if (strstr(value,"FLOAT") != NULL  ||
                   strstr(value,"REAL")  != NULL)
            { col->type = REAL;
              if (strstr(value,"ASCII_REAL") == NULL  &&
                  strstr(value,"ASCII REAL") == NULL)
                { tverr(OBSOLETE_TYPE,*linecount,column_count+1,value,
                        "ASCII_REAL");
                }
            }
          else if (strstr(value,"CHARACTER") != NULL)
              col->type = CHARACTER;
          else if (strstr(value,"DATE") != NULL)
              col->type = DATE;
          else if (strstr(value,"TIME") != NULL)
              col->type = TIME;
          else
              col->type = UNRECOGNIZED;
        }

      else if (strcmp(keyword,"DATA_TYPE") == 0  &&  !ASCII)
        { if (strstr(value,"UNSIGNED_INTEGER") != NULL)
            { col->type = UNSIGNED_INTEGER;
              if (strstr(value,"MSB_UNSIGNED_INTEGER") == NULL  &&
                  strstr(value,"MSB UNSIGNED INTEGER") == NULL  &&
                  strstr(value,"LSB_UNSIGNED_INTEGER") == NULL  &&
                  strstr(value,"LSB UNSIGNED INTEGER") == NULL)
                { tverr(OBSOLETE_TYPE,*linecount,column_count+1,value,
                        "MSB_UNSIGNED_INTEGER");
                }

              msb = (strstr(value,"LSB")==NULL)? 1 : 0;
              if (col->msbflag < 0)
                { col->msbflag = msb; }
              else if (col->msbflag != msb)
                { tverr(INT_TYPE_CONFLICT,*linecount,column_count+1); }

            }
          else if (strstr(value,"INTEGER") != NULL)
            { col->type = SIGNED_INTEGER;
              if (strstr(value,"MSB_INTEGER") == NULL  &&
                  strstr(value,"MSB INTEGER") == NULL  &&
                  strstr(value,"LSB_INTEGER") == NULL  &&
                  strstr(value,"LSB INTEGER") == NULL)
                { tverr(OBSOLETE_TYPE,*linecount,column_count+1,value,
                        "MSB_INTEGER");
                }

              msb = (strstr(value,"LSB")==NULL)? 1 : 0;
              if (col->msbflag < 0)
                { col->msbflag = msb; }
              else if (col->msbflag != msb)
                { tverr(INT_TYPE_CONFLICT,*linecount,column_count+1); }
            }
          else if (strstr(value,"FLOAT") != NULL  ||
                   strstr(value,"REAL")  != NULL)
            { col->type = REAL;
              if (strstr(value,"IEEE_REAL") == NULL  &&
                  strstr(value,"IEEE REAL") == NULL)
                { tverr(OBSOLETE_TYPE,*linecount,column_count+1,value,
                        "IEEE_REAL");
                }
            }
          else if (strstr(value,"CHARACTER") != NULL)
              col->type = CHARACTER;
          else if (strstr(value,"DATE") != NULL)
              col->type = DATE;
          else if (strstr(value,"TIME") != NULL)
              col->type = TIME;
          else
              col->type = UNRECOGNIZED;
        }

      else if (strcmp(keyword,"FORMAT")          == 0)
        { i=j=0;
          while (value[i] == ' ') ++i;
          if (value[i] == '"') ++i;
          while (value[i]!=' '  &&  value[i]!='"'  &&  
                 i<(int)strlen(value)  &&  i<50)
              col->format[j++] = value[i++];
          col->format[j] = '\0';
          if (i==50)
            { tverr(FORMAT_TOO_BIG,*linecount,column_count+1); }
        }
    }

  /* Now that we know the column's attributes, we can initialize the 
     statistics variables in the structure:
  */

  if (NUMERIC_FIELD(col->type))
    { col->maxfound.dbl = -MAXDOUBLE;
      col->minfound.dbl =  MAXDOUBLE;
    }
  else
    { col->maxfound.bytes = -MAXINT;
      col->minfound.bytes =  MAXINT;
    }
  col->maxstr = NULL;
  col->minstr = NULL;
  col->invalidcount = 0;
  col->missingcount = 0;
  col->nacount      = 0;
  col->nullcount    = 0;
  col->unknowncount = 0;
  col->badcount     = 0;

  /* Parse out the field width and precision values from the format string,
     if any:
  */

  if (strlen(col->format) > 0)
    { parse_FORMAT(col,*linecount); }

  /* If we didn't find a COLUMN_NUMBER, write one: */

  if (strcmp(col->colnum,colnum_prefix) == 0)
    { sprintf(col->colnum,"%s%d",colnum_prefix,column_count); }

  /* If we did find a COLUMN_NUMBER, make sure it's the right one: */

  else if (column_number != column_count)
    { tverr(BAD_COLNUM,*linecount,column_count,column_number); }

  /* If there was no specific ITEM_OFFSET encountered, we'll use ITEM_BYTES. 
     We set this even if there are no ITEMS, since the variables have been
     initialized and it's faster to assign than check:
  */

  col->item_offset = (col->item_offset == 0)? 
                     col->item_bytes : col->item_offset;

  /* All done: */

  return OK;
}

/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/

int check_column_attributes(column *col, int object_offset, int parent_bytes,
                            int row_bytes, int ASCII, FILE *report,
                            int row_flag,int linecount)

  /* This routine checks the attributes for a single column to make sure they
     are logically sound.

     Parameters:
       col             Column attributes structure
       object_offset   Offset in record to start of parent object
       parent_bytes    ROW_BYTES (or the equivalent) of the parent object
       row_bytes       ROW_BYTES from the label
       ASCII           TRUE if this is an ASCII table
       report          Output report file
       row_flag        TRUE if we're checking a column in a row, FALSE if
                         we're in a CONTAINER

  */

{ int   status;      /* Return status. 1 is added for each error found */
  int   bytes;       /* holding place */
  char *buff;        /* Conversion buffer */
  char  colnum[50];  /* Convenience string */
  char  env[20];     /* Set to reflect row_flag */
  int   maxlen,minlen,vmaxlen,vminlen;
  int   invlen,misslen,nalen,nulllen,unklen,fieldlen;

  status = 0;
  strcpy(colnum,col->colnum);

  if (row_flag)
    { strcpy(env,"row"); }
  else
    { strcpy(env,"container"); }

  /* If this is a SPARE column, make sure it has a data type of CHARACTER,
     or signal an error.  We use a special type to indicate spare columns,
     to make them easier to identify later:
  */

  if (spare_column(col))
    { if (col->type != CHARACTER)
        { tverr(BAD_SPARE_TYPE,linecount,colnum); }
      col->type = SPARE;
    }

  /* Collect the various string lengths for checking for field overflow: */

  if (col->mmflag%2) maxlen  = strlen(col->max.str);
  if (col->mmflag>1) minlen  = strlen(col->min.str);
  if (col->vmflag%2) vmaxlen = strlen(col->vmax.str);
  if (col->vmflag>1) vminlen = strlen(col->vmin.str);
  if (col->invflag)  invlen  = strlen(col->invalid.str);
  if (col->missflag) misslen = strlen(col->missing.str);
  if (col->naflag)   nalen   = strlen(col->not_applicable.str);
  if (col->nullflag) nulllen = strlen(col->null.str);
  if (col->unkflag)  unklen  = strlen(col->unknown.str);
  fieldlen = (col->items>1) ? col->item_bytes : col->bytes;

  /* First, if this is a numeric field, convert the various value strings to
     their floating-point equivalents as needed:
  */

  if (NUMERIC_FIELD(col->type))

    { /* ...MAXIMUM... */

      if (col->mmflag%2)
        { buff = copy_of(col->max.str);
          col->max.dbl = strtod(buff,(char **)NULL);
          free(buff);
          if (maxlen > fieldlen)
            { tverr(VALUE_TOO_LONG,linecount,colnum,
                                  "MAXIMUM",col->max.str,fieldlen);
            }
        }
 
      /* ...MINIMUM... */

      if (col->mmflag > 1)
        { buff = copy_of(col->min.str);
          col->min.dbl = strtod(buff,(char **)NULL);
          free(buff);
          if (minlen > fieldlen)
            { tverr(VALUE_TOO_LONG,linecount,colnum,
                                  "MINIMUM",col->min.str,fieldlen);
            }
        }

      /* ...VALID_MAXIMUM... */

      if (col->vmflag%2)
        { buff = copy_of(col->vmax.str);
          col->vmax.dbl = strtod(buff,(char **)NULL);
          free(buff);
          if (vmaxlen > fieldlen)
            { tverr(VALUE_TOO_LONG,linecount,colnum,
                                  "VALID_MAXIMUM",col->vmax.str,fieldlen);
            }
        }

      /* ...VALID_MINIMUM... */

      if (col->vmflag > 1)
        { buff = copy_of(col->vmin.str);
          col->vmin.dbl = strtod(buff,(char **)NULL);
          free(buff);
          if (vminlen > fieldlen)
            { tverr(VALUE_TOO_LONG,linecount,colnum,
                                  "VALID_MINIMUM",col->vmin.str,fieldlen);
            }
        }

      /* ...INVALID_CONSTANT... */

      if (col->invflag  &&  !ASCII)
        { buff = copy_of(col->invalid.str);
          col->invalid.dbl = strtod(buff,(char **)NULL);
          free(buff);
          if (invlen > fieldlen)
            { tverr(VALUE_TOO_LONG,linecount,colnum,"INVALID_CONSTANT",
                                  col->invalid.str,fieldlen);
            }
        }

      /* ...MISSING_CONSTANT... */

      if (col->missflag  &&  !ASCII)
        { buff = copy_of(col->missing.str);
          col->missing.dbl = strtod(buff,(char **)NULL);
          free(buff);
          if (misslen > fieldlen)
            { tverr(VALUE_TOO_LONG,linecount,colnum,"MISSING_CONSTANT",
                                  col->missing.str,fieldlen);
            }
        }

      /* ...NOT_APPLICABLE_CONSTANT... */

      if (col->naflag  &&  !ASCII)
        { buff = copy_of(col->not_applicable.str);
          col->not_applicable.dbl = strtod(buff,(char **)NULL);
          free(buff);
          if (nalen > fieldlen)
            { tverr(VALUE_TOO_LONG,linecount,colnum,"NOT_APPLICABLE_CONSTANT",
                                  col->not_applicable.str,fieldlen);
            }
        }

      /* ...UNKNOWN_CONSTANT... */

      if (col->unkflag  &&  !ASCII)
        { buff = copy_of(col->unknown.str);
          col->unknown.dbl = strtod(buff,(char **)NULL);
          free(buff);
          if (unklen > fieldlen)
            { tverr(VALUE_TOO_LONG,linecount,colnum,"UNKNOWN_CONSTANT",
                                  col->unknown.str,fieldlen);
            }
        }

      /* ...NULL_CONSTANT... */

      if (col->nullflag  &&  !ASCII)
        { buff = copy_of(col->null.str);
          col->null.dbl = strtod(buff,(char **)NULL);
          free(buff);
          if (nulllen > fieldlen)
            { tverr(VALUE_TOO_LONG,linecount,colnum,"NULL_CONSTANT",
                                  col->null.str,fieldlen);
            }
        }

    }

  /* But if it's a character string, make sure null max/min pointers are
     null pointers (and not zero-values); and that any values which are 
     given don't overflow the field:
  */

  else
    { /* ...MAXIMUM... */

      if (col->mmflag % 2)   
        { if (maxlen > fieldlen)
            { tverr(VALUE_TOO_LONG,linecount,colnum,
                                  "MAXIMUM",col->max.str,fieldlen);
            }
        }
      else
        { col->max.str = NULL; }

      /* ...MINIMUM... */

      if (col->mmflag > 1)
        { if (minlen > fieldlen)
            { tverr(VALUE_TOO_LONG,linecount,colnum,
                                  "MINIMUM",col->min.str,fieldlen);
            }
        }
      else
        { col->min.str = NULL; }

      /* Check for overflow in the constants, if any: */

     if (col->missflag  &&  misslen > fieldlen)
        { tverr(VALUE_TOO_LONG,linecount,colnum,
                              "MISSING_CONSTANT",col->missing.str,fieldlen);
        }

     if (col->invflag   &&  invlen > fieldlen)
        { tverr(VALUE_TOO_LONG,linecount,colnum,
                              "INVALID_CONSTANT",col->invalid.str,fieldlen);
        }

     if (col->naflag    &&  nalen > fieldlen)
        { tverr(VALUE_TOO_LONG,linecount,colnum,"NOT_APPLICABLE_CONSTANT",
                              col->not_applicable.str,fieldlen);
        }

     if (col->unkflag   &&  unklen > fieldlen)
        { tverr(VALUE_TOO_LONG,linecount,colnum,
                              "UNKNOWN_CONSTANT",col->unknown.str,fieldlen);
        }

     if (col->nullflag  &&  nulllen > fieldlen)
        { tverr(VALUE_TOO_LONG,linecount,colnum,
                              "NULL_CONSTANT",col->null.str,fieldlen);
        }



    }


  /* Field checks: */

  /*** MAXIMUM > MINIMUM */

  if ( col->mmflag == 3)
    { if (NUMERIC_FIELD(col->type))
        { if ( col->max.dbl <  col->min.dbl)
            { tverr(DBLMAX_LT_MIN,linecount,
                    colnum, col->max.dbl,  col->min.dbl);
              ++status;
            }
        }
      else 
        { if (strcmp(col->max.str,col->min.str) < 0)
            { tverr(STRMAX_LT_MIN,linecount,
                    colnum, col->max.str,  col->min.str);
              ++status;
            }
        }
     }


  /*** VALID_MAXIMUM > VALID_MINIMUM */

  if ( col->vmflag == 3)
    { if (NUMERIC_FIELD(col->type))
        { if ( col->vmax.dbl <  col->vmin.dbl)
            { tverr(DBLVALMAX_LT_VALMIN,linecount,
                     colnum, col->vmax.dbl,col->vmin.dbl);
              ++status;
            }
        }
      else 
        { if (strcmp(col->vmax.str,col->vmin.str) < 0)
            { tverr(STRVALMAX_LT_VALMIN,linecount,
                     colnum, col->vmax.str,col->vmin.str);
              ++status;
            }
        }
     }



  /*** DERIVED_MAXMIMUM or DERIVED_MINIMUM only in numeric fields ***/

  if (col->dmflag > 0)
    { if (!NUMERIC_FIELD(col->type))
        { tverr(BAD_DER_MAXMIN,linecount,colnum); }
    }

  /*** DERIVED_MAXIMUM > DERIVED_MINIMUM */

  if (( col->dmflag == 3) && ( col->dmax <  col->dmin))
    { tverr(DERMAX_LT_DERMIN,linecount,colnum, col->dmax,col->dmax);
      ++status;
    }

  /*** DERIVED_MAXIMUM/MINIMUM must have OFFSET and SCALING factor as well */

  if ( ( col->dmflag != 0)            &&  
       ( col->offset == 0.0)          &&
       ( col->scaling_factor == 1.0))    
    { tverr(MISSING_SCALE,linecount,colnum);
      ++status;
    }


  /*** 1 <= START_BYTE <= parent object BYTES and ROW_BYTES */

  if ( col->start_byte < 1)
    { tverr(STARTBYTE_LT_1,linecount,colnum, col->start_byte);
      ++status;
    }
  if ( col->start_byte > parent_bytes)
    { tverr(STARTBYTE_GT_PAR_BYTES,linecount,
                colnum, col->start_byte, parent_bytes);
      ++status;
    }

  if ( col->start_byte > row_bytes)
    { tverr(STARTBYTE_GT_ROW_BYTES,linecount,
                colnum, col->start_byte, row_bytes);
      ++status;
    }
   

  /*** START_BYTE + BYTES + object_offset <= parent size and ROW_BYTES  */

  if ( col->start_byte-1 + col->bytes > parent_bytes)
    { tverr(FIELD_TOO_LONG,linecount,colnum,env);
      ++status;
    }
  if ( col->start_byte-1 + col->bytes + object_offset > row_bytes)
    { tverr(FIELD_TOO_LONG,linecount,colnum,"table row");
      ++status;
    }

  /*** SCALING_FACTOR <> 0 */

  if ( col->scaling_factor == 0.0)
    { tverr(SCALE_EQ_0,linecount,colnum);
      ++status;
    }

  /*** NAME required */

  if (strcmp( col->name,"") == 0)
    { tverr(UNNAMED_COLUMN,linecount,colnum);
      ++status;
    }

  /*** Total ITEMS x ITEM_BYTES must be <= BYTES in field */

  bytes = col->items * col->item_bytes;
  if (col->items > 1  &&  bytes > col->bytes)
    { tverr(ITEM_BYTES_MISMATCH,linecount,colnum,bytes,col->bytes);
      col->type = 0;
      ++status;
    }

  /******
    Now we've reached things that are dependent on whether or not the table
    is ASCII or binary:
   ******/

  if (ASCII)
    {  /*** FORMAT specifier must be appropriate to data type. */

      if (
        ((col->type==UNSIGNED_INTEGER) && (strchr(col->format,'I')==NULL))  ||
        ((col->type==SIGNED_INTEGER)   && (strchr(col->format,'I')==NULL))  ||
        ((col->type==REAL)             && (strpbrk(col->format,"EF")==NULL))||
        ((col->type==CHARACTER)        && (strchr(col->format,'A')==NULL))  ||
        ((col->type==DATE)             && (strchr(col->format,'A')==NULL))  ||
        ((col->type==TIME)             && (strchr(col->format,'A')==NULL))    )

        { tverr(FORMAT_TYPE_MISMATCH,linecount,colnum,col->format,
                            field_type[col->type]);
          ++status;
        }

      /*** Width of FORMAT specifier must be = BYTES */

      bytes = (col->items == 1) ? col->bytes : col->item_bytes;
      if (col->fwidth >  bytes)
        { tverr(WIDTH_GT_BYTES,linecount,colnum,col->fwidth,bytes);
          ++status;
        }
      if ( col->fwidth < bytes)
        { tverr(WIDTH_LT_BYTES,linecount,colnum,col->fwidth,col->bytes);
          ++status;
        }

      /*** Width of FORMAT specifier must be >= precision */

      if ( col->fwidth <  col->fprecision)
        { tverr(PREC_GT_WIDTH,linecount,colnum,col->fprecision,col->fwidth);
          ++status;
        }

      /*** Width of FORMAT specifier for DATE and TIME fields must be 
           >= minimum: */

      if (col->type == DATE  &&  col->fwidth < MINDATEWIDTH)
        { tverr(WIDTH_LT_MIN_DATE,linecount,colnum,col->fwidth); }

      else if (col->type == DATE  &&  col->fwidth > MAXDATEWIDTH)
        { tverr(WIDTH_GT_MAX_DATE,linecount,colnum,col->fwidth); }

      else if (col->type == TIME  &&  col->fwidth < MINTIMEWIDTH)
        { tverr(WIDTH_LT_MIN_TIME,linecount,colnum,col->fwidth,MINTIMEWIDTH);
          ++status;
        }

      else if (col->type == TIME  &&  col->fwidth > MAXTIMEWIDTH)
        { tverr(WIDTH_GT_MAX_TIME,linecount,colnum,col->fwidth,MAXTIMEWIDTH);
          ++status;
        }

    }  /* ASCII-specific checks */

  else /* Binary-specific checks */
    {  /*** FORMAT specifier, if any, must be appropriate to data type. */

      if (strlen(col->format) > 0)
        { if (
          ((col->type==UNSIGNED_INTEGER) && (strchr(col->format,'I')==NULL))  ||
          ((col->type==SIGNED_INTEGER)   && (strchr(col->format,'I')==NULL))  ||
          ((col->type==REAL)             && (strpbrk(col->format,"EF")==NULL))||
          ((col->type==CHARACTER)        && (strchr(col->format,'A')==NULL))  ||
          ((col->type==DATE)             && (strchr(col->format,'A')==NULL))  ||
          ((col->type==TIME)             && (strchr(col->format,'A')==NULL))   )

            { tverr(FORMAT_TYPE_MISMATCH,linecount,colnum,col->format,
                                field_type[col->type]);
              ++status;
            }


          /*** Width of FORMAT specifier must be >= precision */

          if ( col->fwidth <  col->fprecision)
            { tverr(PREC_GT_WIDTH,linecount,colnum,col->fprecision,col->fwidth);
              ++status;
            }

          /*** Width of FORMAT specifier for DATE and TIME fields
               must be >= minimum: 
          */


          if (col->type == DATE  &&  col->fwidth < MINDATEWIDTH)
            { tverr(WIDTH_LT_MIN_DATE,linecount,colnum,col->fwidth);
              ++status;
            }

          else if (col->type == DATE  &&  col->fwidth > MAXDATEWIDTH)
            { tverr(WIDTH_GT_MAX_DATE,linecount,colnum,col->fwidth);
              ++status;
            }

          else if (col->type == TIME  &&  col->fwidth < MINTIMEWIDTH)
            { tverr(WIDTH_LT_MIN_TIME,linecount,colnum,col->fwidth,
                                 MINTIMEWIDTH);
              ++status;
            }

          else if (col->type == TIME  &&  col->fwidth > MAXTIMEWIDTH)
            { tverr(WIDTH_GT_MAX_TIME,linecount,colnum,col->fwidth,
                                 MAXTIMEWIDTH);
              ++status;
            }
        } /* FORMAT check */


      /*** Numeric fields must have a reasonable number of bytes */

      bytes = (col->items == 1) ? col->bytes : col->item_bytes;

      if (col->type == SIGNED_INTEGER  ||  col->type == UNSIGNED_INTEGER)
        { if (bytes != 1  &&  bytes != 2  &&  bytes != 4)
            { tverr(INV_INT_SIZE,linecount,colnum,bytes);
              col->type = SPARE;
              ++status;
            }
        }

      if (col->type == REAL  &&  (bytes !=4  &&  bytes != 8))
        { tverr(INV_REAL_SIZE,linecount,colnum,bytes);
          col->type = SPARE;
          ++status;
        }

    } /* Binary-specific checks */

  /* Now we return the cumulative error count as the status: */

  return status;

}

/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/

int get_container_attributes(char *cntlabel, container *cnt,   int *linecount,
                             int row_bytes,  int record_bytes, int super_offset,
                             int ASCII,      char *colnum_prefix)

  /* Routine to read the OBJECT definition for the current COLUMN object.
     When this routine is called, the current line contains the "OBJECT =
     COLUMN" declaration.

     Parameters:
       cntlabel        Value of "CONTAINER =" statement
       cnt             Container attributes structure
       linecount       Label line pointer
       row_bytes       ROW_BYTES of the current table
       record_bytes    RECORD_BYTES of the file
       super_offset    Offset to beginning of object containing this container
       ASCII           TRUE for ASCII tables
       colnum_prefix   Prefix for column index string

     Normal return value is 0. Anything else indicates a problem.
  */

{ char   line[MAXRECORDLENGTH];     /* input line buffer */
  char   keyword[80],padval[80];
  char  *value;
  int    not_done;                  /* loop flag */
  int    err;                       /* Function return status */
  int    i,j,k;                     /* loop/subscript */
  char  *crem;                      /* conversion pointer */
  int    msb;                       /* True if MSB field */
  int    OK = 0;                    /* Normal return status */
  int    start_line;                /* First line of CONTAINER definition */
  int    object_offset;             /* Cumulative offset to CONTAINER */
  int    row_flag = FALSE;          /* Indicates we're in a CONTAINER */

  /* Subobject variables: */

  int         local_column_count;
  char        local_colnum_prefix[50];
  int         endofcnt;
  field      *newfld, *currentfld;
  column     *newcol, *currentcol;
  container  *newcnt, *currentcnt;

  start_line = *linecount;

  /* Initialize container attributes: */

  cnt->start_byte  = 0;
  cnt->name        = NULL;
  cnt->bytes       = 0;     /* BYTES * REPETITIONS = total size of CONTAINER */
  cnt->repetitions = 1;
  cnt->fldlist     = NULL;
  strcpy(cnt->colnum,colnum_prefix);

  /* First we loop through the container attributes section, saving 
     keyword values of interest:
  */

  not_done = TRUE;
  while (not_done)
    { if (!getlblline(line,label,linecount))
        { tverr(UNEXP_EOF,*linecount,"label");
          return ENDOFFILE;
        }
      breakline(line,keyword,padval,*linecount);
      value = trim_copyof(padval);

      if (strcmp(keyword,"END")==0)
        { tverr(UNEXP_END,*linecount);
          return ENDOFLABEL;
        }

      else if (strcmp(keyword,"END_OBJECT")  == 0)
        { not_done = FALSE;
          if (strlen(value)>0  &&  strcmp(value,cntlabel) != 0)
            { tverr(OBJLBL_MISMATCH,*linecount,value,cntlabel); }
        }

      else if (strcmp(keyword,"NAME")          == 0)
          cnt->name = copy_of(value);

      else if (strcmp(keyword,"COLUMN_NUMBER") == 0)
          strcat(cnt->colnum,value); 

      else if (strcmp(keyword,"BYTES")         == 0)
          cnt->bytes = atoi(value);

      else if (strcmp(keyword,"REPETITIONS")   == 0)
          cnt->repetitions = atoi(value);

      else if (strcmp(keyword,"START_BYTE")    == 0)
          cnt->start_byte  = atoi(value);

      else if (strcmp(keyword,"OBJECT")        == 0)
        { not_done = FALSE; }
    } 

  /* Now we'll do some error_checking on the top-level keywords we've got
     so far:
  */

  if (cnt->name == NULL)
    { tverr(UNNAMED_CONTAINER,*linecount,start_line);
      cnt->name = copy_of("UNNAMED");
    }

  if (cnt->repetitions < 1)
    { tverr(INV_REP,*linecount,cnt->repetitions,start_line);
      cnt->repetitions = 1;
    }

  if ((cnt->start_byte-1 + (cnt->bytes * cnt->repetitions) + super_offset) 
        > row_bytes)
    { tverr(CONTAINER_TOO_LONG,*linecount,cnt->name,start_line); }

  /* Set the column number if we didn't read one: */

  if (strcmp(cnt->colnum,colnum_prefix) == 0)
    { sprintf(cnt->colnum,"%s%d",colnum_prefix,local_column_count); }

  /* Check for the odd case of an empty CONTAINER: */

  if (strcmp(keyword,"END_OBJECT") == 0)
    { tverr(EMPTY_CONTAINER,*linecount,cnt->name,start_line);
      return ENDOFOBJECT;
    }

  /* Now we're ready to read the subobjects. We call this routine again
     recursively if we encounter another container:
  */

  not_done = TRUE;
  local_column_count = 0;
  sprintf(local_colnum_prefix,"%s.",cnt->colnum);
  object_offset = super_offset + cnt->start_byte - 1;

  while (not_done)
    { if (strcmp(value,"COLUMN") == 0)
        { local_column_count++;

          newfld = (field *)malloc(sizeof(field));
          newfld->type = COLUMN;
          newfld->next = NULL;
          newcol = (column *)malloc(sizeof(column));
          newfld->ptr.col = newcol;

          endofcnt = get_column_attributes(local_column_count,newcol,linecount,
                                           super_offset, ASCII,
                                           local_colnum_prefix);
          check_column_attributes(newcol,object_offset,cnt->bytes,
                                  record_bytes,ASCII,report,row_flag,
                                  *linecount);

          if (cnt->fldlist == NULL)
            { cnt->fldlist = newfld; }
          else
            { currentfld->next = newfld; }
          currentfld   = newfld;
        }

      else if (strstr(value,"CONTAINER") != NULL)
        { local_column_count++;

          newfld = (field *)malloc(sizeof(field));
          newfld->type = CONTAINER;
          newfld->next = NULL;
          newcnt = (container *)malloc(sizeof(container));
          newfld->ptr.cnt = newcnt;

          endofcnt = get_container_attributes(value, newcnt,
                          linecount, cnt->bytes, record_bytes,
                          object_offset, ASCII, local_colnum_prefix);

          /* I can't think of any other attributes to check which aren't
             already caught by the above checks, so there will be no
             'check_container_attributes' routine until I do. Note that
             the 'check_column_attributes' will flag columns that overflow 
             the allowed number of bytes per repetition.
          */

          if (cnt->fldlist == NULL)
            { cnt->fldlist = newfld; }
          else
            { currentfld->next = newfld; }
          currentfld   = newfld;
        }

      else
        { tverr(INV_SUBOBJECT,*linecount,value,"CONTAINER");
          endofcnt = skip_object(value,linecount);
        }

      /* If we haven't already encountered a premature end condition, 
         look for the next object:
      */

      if (!endofcnt)
        { endofcnt = next_object(value,linecount); 

          /* If we get an end condition, make sure it's a valid one: */

          if (endofcnt == ENDOFLABEL)
            { tverr(UNEXP_END,*linecount);
              return ENDOFLABEL;
            }

          else if (endofcnt == ENDOFOBJECT)
            { if (strlen(value) > 0  &&  strcmp(value,cntlabel) != 0)
                { tverr(OBJLBL_MISMATCH,*linecount,value,cntlabel); }
            }
        }

      /* Ready for the next subobject: */

      not_done = !endofcnt;

    }

  /* Here would be a good place to do some additional validity checking,
     once I think of some:
  */

  return OK;
}       

/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/

void checkfilename(char *file, int linecount)

  /* This routine checks the file name syntax to make sure it meets PDS
     constraints.
  */

{ int   i,j,k;           /* Loop/index  */
  int   lc,uc;           /* Case flags  */
  int   pd, bad;
  char *p,c;

  /* This is a quick & dirty check. It won't catch subtle stuff, but it 
     does check for the easy mistakes:
  */

  lc = uc = pd = bad = 0;

  /* Loop through the letters, checking for mixed case and disallowed
     characters:
  */

  for (i=0; i<strlen(file); i++)
    { c = file[i];

      if (!isalnum(c) && c != '_'  &&  c != '.')
        { bad++; }

      if (islower(c)) lc++;
      if (isupper(c)) uc++;
      if (c == '.')   pd++;
    }

  /* All right, now we check for errors: */

  if (bad > 0)
    { tverr(INV_CHAR_IN_FN,linecount,file); }

  if (lc > 0  &&  uc > 0)
    { tverr(MIXED_CASE_IN_FN,linecount,file); }

  if (pd < 1)
    { tverr(NO_EXT_IN_FN,linecount,file); }

  if (pd > 1)
    { tverr(MULT_EXT_IN_FN,linecount,file); }

  /* Done. */

  return;
}

/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/

int table_type(char *typestring)

  /* This routine determines whether the type string passed in corresponds
     to a table-type object (i.e., a TABLE, SPECTRUM or SERIES).
  */

{ char *p;

  /* The type identifier must either be the whole string, or the last part
     of the string with a leading '_' character. We'll check for the 
     easy cases first:
  */

  if (strcmp(typestring,"TABLE") == 0)
    { return TRUE; }
  if (strcmp(typestring,"SPECTRUM") == 0)
    { return TRUE; }
  if (strcmp(typestring,"SERIES") == 0)
    { return TRUE; }

  /* Failing that, we check for the type in the last part of the string: */

  p = strrchr(typestring,'_');

  /* If there is no underscore, we're done. Otherwise, we check again for 
     a match:
  */

  if (p == NULL)
    { return FALSE; }

  if (strcmp(p,"_TABLE") == 0)
    { return TRUE; }
  if (strcmp(p,"_SPECTRUM") == 0)
    { return TRUE; }
  if (strcmp(p,"_SERIES") == 0)
    { return TRUE; }

  /* No match - no table: */

  return FALSE;
}

/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/