/* printct.c Main and support routines for printing ltx2x ct file */

/* printct.c Main and support routines for printing ltx2x ct file */
/* Written by Peter Wilson (Catholic University and NIST) */
/* [email protected] */
/* Version 0.1, July 1996 */
/* 0.2, November 1996 */
/*---------------------------------------------------------------------*/

char FILE_VERSION[] = "Version 0.2";
char FILE_DATE[] = "November 1996";

/* VERSION HISTORY:
* Version 0.1 (July 1996): First release
* Version 0.2 (November 1996): Added SWITCH_TO_XXX and SWITCH_BACK
* Added CODE and friends
*
*/

/* Development of this software was funded by the United States Government,
* and is not subject to copyright.
*/

/* National Institute of Standards and Technology (NIST)
* Manufacturing Engineering Laboratory (MEL)
* Manufacturing Systems Integration Division (MSID)
* ********************************************************************
* D I S C L A I M E R
*
* There is no warranty for the PRINTCT software.
* If the PRINTCT software is modified by someone else and passed on,
* NIST wants the software's recipients to know that what they
* have is not what NIST distributed.
*
* Policies
*
* 1. Anyone may copy and distribute verbatim copies of the
* source code as received in any medium.
*
* 2. Anyone may modify your copy or copies of the PRINTCT source
* code or any portion of it, and copy and distribute such modifications
* provided that all modifications are clearly associated with the entity
* that performs the modifications.
*
* NO WARRANTY
* ===========
*
* NIST PROVIDES ABSOLUTELY NO WARRANTY. THE PRINTCT SOFTWARE
* IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER
* EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
* THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS
* WITH YOU. SHOULD ANY PORTION OF THE PRINTCT SOFTWARE PROVE DEFECTIVE,
* YOU ASSUME THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
*
* IN NO EVENT WILL NIST BE LIABLE FOR DAMAGES,
* INCLUDING ANY LOST PROFITS, LOST MONIES, OR OTHER SPECIAL,
* INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR
* INABILITY TO USE (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA
* BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY THIRD PARTIES OR A
* FAILURE OF THE PROGRAM TO OPERATE WITH PROGRAMS NOT DISTRIBUTED BY
* NIST) THE PROGRAMS, EVEN IF YOU HAVE BEEN ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGES, OR FOR ANY CLAIM BY ANY OTHER PARTY.
*/

#include <string.h>
#include "getopt.h"
#include <stdio.h>
#include <ctype.h>
#ifndef STRTYPES_H
#include "strtypes.h"
#endif
/* typedef char *STRING; A pointer-to-a-char */
/* typedef STRING *PTRADR; A pointer-to-a-pointer-to-a-char */
/* define SNUL '\0' end of a string */

# define MAX_ERRORS 10

FILE *filerr; /* Error file */
FILE *filtabin; /* Table input file */
FILE *filtabout; /* Table output file */

int TDEBUG = FALSE; /* for debugging command table */

/* length of a user buffer */
# define MAX_UBUFF_LEN 514

char errstr[MAX_UBUFF_LEN]; /* buffer for assembling error/warning text */

/* keywords */
enum key_word{AUDIBLE_ALERT_CHAR,
BACKSPACE_CHAR,
CA,
CARRIAGE_RETURN_CHAR,
CODE,
CODE_SETUP,
COMMENT,
CONTINUE,
END_CODE,
END_CTFILE,
END_ITEM,
END_ITEM_PARAM,
END_MODE,
END_OPT,
END_TAG,
END_TAG_1,
END_TAG_2,
END_TAG_3,
END_TAG_4,
END_TAG_5,
END_TAG_6,
END_TAG_7,
END_TAG_8,
END_TAG_9,
END_TYPE,
ESCAPE_CHAR,
FORMFEED_CHAR,
HEX_CHAR,
HORIZONTAL_TAB_CHAR,
INCLUDE,
IN_MODE,
NAMEK,
NEWLINE_CHAR,
OPT_PARAM,
PC_AT_END,
PC_AT_START,
PRINT_CONTROL,
PRINT_OPT,
PRINT_P1,
PRINT_P2,
PRINT_P3,
PRINT_P4,
PRINT_P5,
PRINT_P6,
PRINT_P7,
PRINT_P8,
PRINT_P9,
REQPARAMS,
RESET_BUFFER,
RESET_FILE,
RESET_MODE,
RESET_SYSBUF,
SECTIONING_LEVEL,
SET_MODE,
SOURCE,
SPECIAL_TOKEN,
START_ITEM,
START_ITEM_PARAM,
START_OPT,
START_TAG,
START_TAG_1,
START_TAG_2,
START_TAG_3,
START_TAG_4,
START_TAG_5,
START_TAG_6,
START_TAG_7,
START_TAG_8,
START_TAG_9,
STRINGG,
SWITCH_BACK,
SWITCH_TO_BUFFER,
SWITCH_TO_FILE,
SWITCH_TO_SYSBUF,
TYPE,
VERTICAL_TAB_CHAR,
MAX_KEYSTR};
int max_keystr = MAX_KEYSTR;
STRING key_array[MAX_KEYSTR];

void strtouc(); /* convert string to upper case */
int lookup_string(); /* finds posn. of string in an ordered array of strings */
void init_print_control();
void init_keys();
int key_to_int();
STRING key_to_string();

enum cont_enum {CONT_UNKNOWN_ENUM,
CONT_TAG};

#define MAX_TABLE_LINE 1000
char table_line[MAX_TABLE_LINE];
#define MAX_TABLE_ENTRIES 1000
int num_table_errors = 0;

STRING unk = "ERROR";

enum print_control{BUFFER,
DEFAULT_PRINT,
FFILE,
FIRST_STRING,
MODE,
NO_OP,
NO_PRINT,
PRINT_UNDERFLOW,
RESET,
SOURCE_STRING,
SYSBUF,
TO_BUFFER,
TO_FILE,
TO_SYSBUF,
UNKNOWN_PRINT,
MAX_PCSTR};
int max_pcstr = MAX_PCSTR;
STRING pc_array[MAX_PCSTR];

void delete_to_chars();
void table_error();
void tdebug_tline();
void tdebug_str_str_int();
void tdebug_str_int();
void tdebug_str();
void process_table();
void process_pc();
int ct_lineno = 0; /* table line number */

/* Environment variable defined search path stuff */
void initialise_senv();
char path_name[257]; /* name of a path */
char sys_envname[20]; /* name of environment variable */
char path_sep[10]; /* path name seperators */
char dir_cat; /* directory catenation char */
int senv_debug; /* =1 for debug searchenv() */

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

/* MAIN the main program ----------------------------------------- */
main(argc, argv)
int argc;
char **argv;
{
int optchar;
FILE *file;
char tabnam[100];

/* print banner */
fprintf(stdout, "\n printct: An ltx2x command table printer\n");
fprintf(stdout, "\n (%s, %s)\n", FILE_VERSION, FILE_DATE);

/* open error log file */
file = fopen("printct.err", "w");
if (!file) {
fprintf(stderr, "Fatal Error: Could not open file printct.err\n");
exit(1);
}
filerr = file;
fprintf(stdout, "Error file is printct.err\n");
fprintf(filerr, "Error file for program printct (%s, %s)\n", FILE_VERSION, FILE_DATE);
fprintf(filerr, "Author: Peter Wilson (Catholic University and NIST)\n");
fprintf(filerr, "Email any comments or suggestions to [email protected]\n\n");
/* open Table output file */
file = fopen("printct.lis", "w");
if (!file) {
fprintf(stderr, "Fatal Error: Could not open file printct.lis\n");
exit(1);
}
filtabout = file;
fprintf(stdout, "Table output file is printct.lis\n");
fprintf(filerr, "Table output file is printct.lis\n");

/* set up for Table input file */
strcpy(tabnam, "ltx2x.ct");
initialise_senv(); /* initialise directory searching */

/* get command line optional parameters */
opterr = 1; /* getopt prints errors if opterr is 1 */
while (EOF != (optchar =
getopt(argc,argv,"tf:P:D:"))) {
/* Uwe Sassenberg [email protected] found
* that he had to add this next line of code to stop an infinite
* loop of this while (It did not seem to recognise EOF !!)
* If it compiles but just sits there chewing CPU cycles, try
* uncommenting the next line of code
*/
/* if (optchar == 255) break; */
switch(optchar) {
case '?': /* command line error */
fprintf(stderr, "\nUsage: [-t] [-f tablename] [-P chars] [-D char]\n");
fprintf(filerr, "\nUsage: [-t] [-f tablename] [-P chars] [-D char]\n");
break;
case 't': /* switch on command table & SEARCHENV debugging */
TDEBUG = TRUE;
senv_debug = 1;
fprintf(stdout, "Command table debugging set ON\n");
fprintf(filerr, "Command table debugging set ON\n");
break;
case 'f': /* special Table input file */
strcpy(tabnam, optarg);
break;
case 'P': /* pathname seperators */
strcpy(path_sep, optarg);
strcat(path_sep, " ");
fprintf(stdout, "Pathname seperators set to (%s)\n", path_sep);
fprintf(filerr, "Pathname seperators set to (%s)\n", path_sep);
break;
case 'D': /* directory catenation char */
dir_cat = optarg[0];
fprintf(stdout, "Directory catenation character set to %c\n", dir_cat);
fprintf(filerr, "Directory catenation character set to %c\n", dir_cat);
break;
} /* end of switch */
} /* end of optional parameter processing */

/* open Table file */
if (!searchenv(tabnam, sys_envname, path_name, path_sep, dir_cat, senv_debug)) {
fprintf(stderr, "Fatal Error: Could not find file %s\n", tabnam);
exit(1);
}
file = fopen(path_name, "r");
if (!file) {
fprintf(stderr, "Fatal Error: Could not open file %s\n", path_name);
exit(1);
}
filtabin = file;
fprintf(stdout, "Table input file is %s\n", path_name);
fprintf(filerr, "Table input file is %s\n", path_name);

/* No other parameters */

/* do some initialisations */
init_keys(); /* 6/96 initialise command keywords */
init_print_control(); /* initialise pc keywords */

process_table(filtabin, filtabout);
fclose(filtabin);
fclose(filtabout);
exit(0);

} /* end MAIN */
/*------------------------------------------------------------------------*/

/*-----------STRING FUNCTIONS-------------------------*/

/* DELETE_TO_CHARS deletes all chars through first occurrence of "c" */
void delete_to_chars(c,s)
char c[];
char s[];
{
int len;
int pos;
int i, n;

len = strlen(s);
pos = strcspn(s, c);
if (pos > 0 && pos < len) { /* = found */
n = 0;
for (i = (pos+1); i <= len; i++ ) {
s[n] = s[i];
n++;
}
}
} /* end DELETE_TO_CHARS */

/* STRTOUC converts a string in place to upper case */
void strtouc(str)
char str[];
{
int i;
for (i = 0; str[i] != SNUL; i++) {
str[i] = toupper(str[i]);
}
return;
} /* end STRTOUC */

/*---------------ERROR AND DEBUG PRINTING-------------*/

/* TABLE_ERROR prints Command table error message */
void table_error(s)
char *s;
{
fprintf(stderr, "\nCommand table: %s line\n%d: %s\n",
s, ct_lineno, table_line);
fprintf(filerr, "\nCommand table: %s line\n%d: %s\n",
s, ct_lineno, table_line);
fflush(stderr);
fflush(filerr);
num_table_errors++;
if (num_table_errors >= MAX_ERRORS) {
fprintf(stderr, "\n** Table processing ended with at least %d errors **\n",
num_table_errors);
fprintf(filerr, "\n** Table processing ended with at least %d errors **\n",
num_table_errors);
exit(1);
}
} /* end TABLE_ERROR */

/* TDEBUG_TLINE prints table line */
void tdebug_tline(str)
char str[];
{
fprintf(stderr, "\nline %d: %s", ct_lineno, str);
fprintf(filerr, "\nline %d: %s", ct_lineno, str);
fflush(stderr);
fflush(filerr);
} /* end TDEBUG_TLINE */

/* TDEBUG_STR prints diagnostics */
void tdebug_str(str)
char str[];
{
fprintf(stderr, "LD: (Read_table) %s", str);
fprintf(filerr, "LD: (Read_table) %s", str);
fflush(stderr);
fflush(filerr);
} /* end TDEBUG_STR */

/* PROCESS_TABLE reads and writes a command table */
/* Just checks keyword at start of line then prints the line out */
/* Keywords are specified in key_word enumeration */
/*-----------------------------------------------------------------------*/

int in_code; /* global flag TRUE while processing CODE */
void process_table(fin, fout)
FILE *fin; /* input file */
FILE *fout; /* output file */
{

char line[MAX_TABLE_LINE];
char code_name[MAX_TABLE_LINE];
int num_names;
int num;
char str[MAX_TABLE_LINE];
int last_string = CONT_UNKNOWN_ENUM;
char *cin;
int key; /* command keyword */

STRING tab0 = "";
STRING tab1 = " ";
STRING tab2 = " ";
STRING tab3 = " ";
char code_tab[20];

in_code = FALSE; /* flag for CODE processing */

for (;;) { /* loop over all files */
line[0] = SNUL;
cin = fgets(line, MAX_TABLE_LINE, fin); /* read a line */
ct_lineno++;
if (TDEBUG) {
tdebug_tline(line);
}
if (feof(fin) != 0) { /* end of this file */
return;
}
strcpy(table_line, line);
/* get first name on line */
num_names = sscanf(line, "%s", code_name);
if (num_names <= 0) { /* blank line */
fprintf(fout, "\n");
continue; /* ignore */
}
strtouc(code_name); /* convert to upper case for comparisons */
key = key_to_int(code_name);
switch (key) {
case END_CTFILE : { /* end of file */
if (TDEBUG) {
tdebug_str("END_CTFILE=\n");
}
delete_to_chars("=:", line);
fprintf(fout, "%s%s%s", tab0, key_to_string(key), line);
break;
}

case CA :
case COMMENT : { /* comment line */
if (TDEBUG) {
tdebug_str("C=\n");
}
delete_to_chars("=:", line);
fprintf(fout, "%sc=%s", tab3, line); /* print lower case c= */
break;
}

case INCLUDE : { /* file inclusion */
if (TDEBUG) {
tdebug_str(code_name);
}
last_string = CONT_UNKNOWN_ENUM;
delete_to_chars("=:", line);
fprintf(fout, "%s%s%s", tab0, key_to_string(key), line);
break;
}

case TYPE : { /* start of a record */
last_string = CONT_UNKNOWN_ENUM;
delete_to_chars("=:", line);
fprintf(fout, "%s%s%s", tab0, key_to_string(key), line);
break;
}

case END_TYPE : { /* end of a record */
last_string = CONT_UNKNOWN_ENUM;
/* delete_to_chars("=:", line); */
fprintf(fout, "%s%s", tab0, line);
break;
}

case NAMEK : { /* process NAME= */
last_string = CONT_UNKNOWN_ENUM;
delete_to_chars("=:", line);
fprintf(fout, "%s%s%s", tab0, key_to_string(key), line);
break;
}

case PRINT_CONTROL : { /* process PRINT_CONTROL= */
last_string = CONT_UNKNOWN_ENUM;
delete_to_chars("=:", line);
if (TDEBUG) {
sprintf(errstr, "%s %s\n", code_name, line);
tdebug_str(errstr);
}
fprintf(fout, "%s%s", tab1, key_to_string(key));
process_pc(fout, line);
break;
}

case START_TAG :
case END_TAG : { /* process START/END__TAG= */
last_string = CONT_TAG;
delete_to_chars("=:", line);
fprintf(fout, "%s%s%s", tab1, key_to_string(key), line);
break;
}

case OPT_PARAM : { /* process OPT_PARAM= */
last_string = CONT_UNKNOWN_ENUM;
delete_to_chars("=:", line);
fprintf(fout, "%s%s%s", tab1, key_to_string(key), line);
break;
}

case PRINT_OPT : { /* process PRINT_OPT= */
last_string = CONT_UNKNOWN_ENUM;
delete_to_chars("=:", line);
fprintf(fout, "%s%s%s", tab1, key_to_string(key), line);
break;
}

case START_OPT :
case END_OPT : { /* process START/END_OPT= */
last_string = CONT_TAG;
delete_to_chars("=:", line);
fprintf(fout, "%s%s%s", tab1, key_to_string(key), line);
break;
}

case REQPARAMS : { /* process REQPARAMS= */
last_string = CONT_UNKNOWN_ENUM;
delete_to_chars("=:", line);
sscanf(line, "%d", &num);
if (TDEBUG) {
sprintf(errstr, "%s %d\n", code_name, num);
tdebug_str(errstr);
}
if (num >= 0 && num <= 9 ) {
;
}
else {
table_error("REQPARAMS out of range (0-9)");
}
fprintf(fout, "%s%s%s", tab1, key_to_string(key), line);
break;
}

case START_TAG_1 :
case END_TAG_1 :
case START_TAG_2 :
case END_TAG_2 :
case START_TAG_3 :
case END_TAG_3 :
case START_TAG_4 :
case END_TAG_4 :
case START_TAG_5 :
case END_TAG_5 :
case START_TAG_6 :
case END_TAG_6 :
case START_TAG_7 :
case END_TAG_7 :
case START_TAG_8 :
case END_TAG_8 :
case START_TAG_9 :
case END_TAG_9 : { /* process START/END_TAG_N= */
last_string = CONT_TAG;
delete_to_chars("=:", line);
fprintf(fout, "%s%s%s", tab1, key_to_string(key), line);
break;
}

case PRINT_P1 :
case PRINT_P2 :
case PRINT_P3 :
case PRINT_P4 :
case PRINT_P5 :
case PRINT_P6 :
case PRINT_P7 :
case PRINT_P8 :
case PRINT_P9 : { /* process PRINT_PN= */
last_string = CONT_UNKNOWN_ENUM;
delete_to_chars("=:", line);
fprintf(fout, "%s%s", tab1, key_to_string(key));
process_pc(fout, line);
break;
}

case START_ITEM :
case END_ITEM : { /* process START/END_ITEM= */
last_string = CONT_TAG;
delete_to_chars("=:", line);
fprintf(fout, "%s%s%s", tab1, key_to_string(key), line);
break;
}

case START_ITEM_PARAM :
case END_ITEM_PARAM : { /* process START/END_ITEM_PARAM= */
last_string = CONT_TAG;
delete_to_chars("=:", line);
fprintf(fout, "%s%s%s", tab1, key_to_string(key), line);
break;
}

case CONTINUE : /* process CONTINUE= */
case STRINGG : { /* process STRING= */
delete_to_chars("=:", line);
fprintf(fout, "%s%s%s", tab2, key_to_string(STRINGG), line);
break;
}

case SOURCE : { /* 6/96 process SOURCE= */
if (last_string == CONT_UNKNOWN_ENUM) {
sprintf(errstr, "Can not use %s at this point", code_name);
table_error(errstr);
}
delete_to_chars("=:", line);
fprintf(fout, "%s%s%s", tab2, key_to_string(key), line);
break;
}

case PC_AT_START :
case PC_AT_END : { /* 6/96 process PC_AT_START/END= */
last_string = CONT_UNKNOWN_ENUM;
delete_to_chars("=:", line);
fprintf(fout, "%s%s", tab1, key_to_string(key));
process_pc(fout, line);
if (TDEBUG) {
sprintf(errstr, "%s %s\n", code_name, line);
tdebug_str(errstr);
}
break;
}

case SECTIONING_LEVEL : { /* process SECTIONING_LEVEL= */
last_string = CONT_UNKNOWN_ENUM;
delete_to_chars("=:", line);
fprintf(fout, "%s%s%s", tab1, key_to_string(key), line);
if (TDEBUG) {
sprintf(errstr, "%s %s\n", code_name, str);
tdebug_str(errstr);
}
break;
}

case RESET_SYSBUF :
case RESET_BUFFER :
case RESET_FILE :
case RESET_MODE :
case SET_MODE : { /* process (RE)SET_X= */
if (TDEBUG) {
sprintf(errstr, "%s\n", code_name);
tdebug_str(errstr);
}
if (last_string == CONT_UNKNOWN_ENUM) {
sprintf(errstr, "Can not use %s at this point", code_name);
table_error(errstr);
}
delete_to_chars("=:", line);
fprintf(fout, "%s%s%s", tab2, key_to_string(key), line);
break;
}

case SWITCH_BACK :
case SWITCH_TO_BUFFER :
case SWITCH_TO_FILE :
case SWITCH_TO_SYSBUF : { /* 11/96 process SWITCH-XXX */
if (TDEBUG) {
sprintf(errstr, "%s\n", code_name);
tdebug_str(errstr);
}
if (last_string == CONT_UNKNOWN_ENUM) {
sprintf(errstr, "Can not use %s at this point", code_name);
table_error(errstr);
}
delete_to_chars("=:", line);
fprintf(fout, "%s%s%s", tab2, key_to_string(key), line);
break;
}

case IN_MODE : { /* 6/96 process IN_MODE */
last_string = CONT_UNKNOWN_ENUM;
delete_to_chars("=:", line);
fprintf(fout, "%s%s%s", tab0, key_to_string(key), line);
break;
}

case END_MODE : { /* 6/96 process END_MODE */
last_string = CONT_UNKNOWN_ENUM;
/* delete_to_chars("=:", line); */
fprintf(fout, "%s%s", tab0, line);
break;
}

case SPECIAL_TOKEN : { /* process SPECIAL_TOKEN= */
last_string = CONT_UNKNOWN_ENUM;
delete_to_chars("=:", line);
fprintf(fout, "%s%s%s", tab0, key_to_string(key), line);
break;
}

case ESCAPE_CHAR :
case NEWLINE_CHAR :
case HORIZONTAL_TAB_CHAR :
case VERTICAL_TAB_CHAR :
case BACKSPACE_CHAR :
case CARRIAGE_RETURN_CHAR :
case FORMFEED_CHAR :
case AUDIBLE_ALERT_CHAR :
case HEX_CHAR : { /* process characters */
if (TDEBUG) {
tdebug_str(code_name);
}
last_string = CONT_UNKNOWN_ENUM;
delete_to_chars("=:", line);
fprintf(fout, "%s%s%s", tab0, key_to_string(key), line);
break;
}

case CODE_SETUP : { /* CODE_SETUP added for code interp */
if (TDEBUG) {
sprintf(errstr, "%s\n", code_name);
tdebug_str(errstr);
}
last_string = CONT_UNKNOWN_ENUM;
fprintf(fout, "%s%s\n", tab0, key_to_string(key));
strcpy(code_tab, tab0);
in_code = TRUE;
break;
}

case CODE : { /* CODE added for code interp */
if (TDEBUG) {
sprintf(errstr, "%s\n", code_name);
tdebug_str(errstr);
}
if (last_string == CONT_UNKNOWN_ENUM) {
sprintf(errstr, "Can not use %s at this point", code_name);
table_error(errstr);
}
fprintf(fout, "%s%s\n", tab2, key_to_string(key));
strcpy(code_tab, tab2);
in_code = TRUE;
break;
}

default : { /* possibly unrecognised */
if (!in_code) { /* unrecognised! */
if (TDEBUG) {
tdebug_str("UNRECOGNISED CODE NAME\n");
}
last_string = CONT_UNKNOWN_ENUM;
table_error("Unrecognised code");
break;
}
/* are in CODE processing */
if (key == END_CODE) { /* end of CODE */
if (TDEBUG) {
sprintf(errstr, "%s\n", code_name);
tdebug_str(errstr);
}
fprintf(fout, "%s%s\n", code_tab, key_to_string(key));
in_code = FALSE;
break;
}
else { /* still in CODE, just print */
fprintf(fout, "%s%s", code_tab, table_line);
break;
}
break;
} /* end of default case */
} /* end of switch */
fflush(fout);

} /* end of loop over all files */
} /* end PROCESS_TABLE */

/*---------------FILE INCLUSION-------------------*/

/* INITIALISE_SENV initialises path searching */
void initialise_senv()
{
strcpy(sys_envname,"LTX2XTABLES"); /* environment variable name */
strcpy(path_sep," :;"); /* path seperators */
dir_cat = '/'; /* dir catenation char */
senv_debug = 0; /* debugging off */
} /* end INITIALISE_SENV */

/*---------------------------------------------------------------*/
/* 6/96 extras */

/* PARSE_PC parses print control and returns new structure */
void process_pc(fout, a_line)
FILE *fout;
char a_line[];
{
char key_name[MAX_TABLE_LINE];
int key_enum;

/* get first keyword on line */
sscanf(a_line, "%s", key_name);
strtouc(key_name);
/* convert to enumeration type */
key_enum = printc_to_int(key_name);
/* switch to get all the data */
switch (key_enum) {
case DEFAULT_PRINT: { /* got it all */
fprintf(fout, "%s", a_line);
return;
}
case NO_PRINT: { /* got it all */
fprintf(fout, "%s", a_line);
return;
}
case TO_SYSBUF: { /* got it all */
fprintf(fout, "%s", a_line);
return;
}
case PRINT_UNDERFLOW: { /* got it all */
fprintf(fout, "%s", a_line);
return;
}
case UNKNOWN_PRINT: { /* got it all */
fprintf(fout, "%s", a_line);
return;
}

case TO_BUFFER: { /* get buffer number */
fprintf(fout, "%s", a_line);
return;
}

case TO_FILE: { /* get file */
fprintf(fout, "%s", a_line);
return;
}

case SYSBUF: { /* got it all */
fprintf(fout, "%s", a_line);
return;
}

case BUFFER: { /* get buffer number */
fprintf(fout, "%s", a_line);
return;
}

case FFILE: { /* get file */
fprintf(fout, "%s", a_line);
return;
}

case FIRST_STRING: { /* get string */
fprintf(fout, "%s", a_line);
return;
}

case RESET: { /* got it all */
fprintf(fout, "%s", a_line);
return;
}

case NO_OP: { /* got it all */
fprintf(fout, "%s", a_line);
return;
}

default: {
fprintf(fout, "**** %s", a_line);
return;
}
}
} /* end PROCESS_PC */

/* LOOKUP_STRING returns position of string in an array of strings */
int lookup_string(str, array, numstr)
STRING str; /* string to search for */
STRING array[]; /* array of strings */
int numstr; /* number of strings in array */
{
int low, mid, high, result;

low = 0;
high = numstr - 1;
while (low <= high) {
mid = (low + high)/2;
result = strcmp(str, array[mid]);
if (result < 0) { /* not in top half */
high = mid - 1;
}
else if (result > 0) { /* not in bottom half */
low = mid + 1;
}
else { /* found it */
return(mid);
}
}
return(-1); /* str not in array */
} /* end LOOKUP_STRING */

/* INIT_PRINT_CONTROL initialises print control stuff */
void init_print_control()
{

/* set up enum/str array */
pc_array[BUFFER] = "BUFFER";
pc_array[DEFAULT_PRINT] = "DEFAULT_PRINT";
pc_array[FFILE] = "FILE";
pc_array[FIRST_STRING] = "FIRST_STRING";
pc_array[MODE] = "MODE";
pc_array[NO_OP] = "NO_OP";
pc_array[NO_PRINT] = "NO_PRINT";
pc_array[PRINT_UNDERFLOW] = "PRINT_UNDERFLOW";
pc_array[RESET] = "RESET";
pc_array[SOURCE_STRING] = "SOURCE_STRING";
pc_array[SYSBUF] = "SYSBUF";
pc_array[TO_BUFFER] = "TO_BUFFER";
pc_array[TO_FILE] = "TO_FILE";
pc_array[TO_SYSBUF] = "TO_SYSBUF";
pc_array[UNKNOWN_PRINT] = "UNKNOWN_PRINT";

} /* end INIT_PRINT_CONTROL */

/* PRINTC_TO_INT converts print control string to enum */
int printc_to_int(s)
STRING s;
{
int pos;

pos = lookup_string(s, pc_array, max_pcstr);
if (pos == -1) { /* unknown string */
table_error("PRINT_CONTROL unrecognised");
return(UNKNOWN_PRINT);
}
return(pos);
} /* end PRINTC_TO_INT */

/* INIT_KEYS initialises keyword stuff */
void init_keys()
{

/* set up enum/string array */
key_array[AUDIBLE_ALERT_CHAR] = "AUDIBLE_ALERT_CHAR=";
key_array[BACKSPACE_CHAR] = "BACKSPACE_CHAR=";
key_array[CA] = "C=";
key_array[CARRIAGE_RETURN_CHAR] = "CARRIAGE_RETURN_CHAR=";
key_array[CODE] = "CODE:";
key_array[CODE_SETUP] = "CODE_SETUP=";
key_array[COMMENT] = "COMMENT=";
key_array[CONTINUE] = "CONTINUE=";
key_array[END_CODE] = "END_CODE";
key_array[END_CTFILE] = "END_CTFILE=";
key_array[END_ITEM] = "END_ITEM=";
key_array[END_ITEM_PARAM] = "END_ITEM_PARAM=";
key_array[END_MODE] = "END_MODE";
key_array[END_OPT] = "END_OPT=";
key_array[END_TAG] = "END_TAG=";
key_array[END_TAG_1] = "END_TAG_1=";
key_array[END_TAG_2] = "END_TAG_2=";
key_array[END_TAG_3] = "END_TAG_3=";
key_array[END_TAG_4] = "END_TAG_4=";
key_array[END_TAG_5] = "END_TAG_5=";
key_array[END_TAG_6] = "END_TAG_6=";
key_array[END_TAG_7] = "END_TAG_7=";
key_array[END_TAG_8] = "END_TAG_8=";
key_array[END_TAG_9] = "END_TAG_9=";
key_array[END_TYPE] = "END_TYPE";
key_array[ESCAPE_CHAR] = "ESCAPE_CHAR=";
key_array[FORMFEED_CHAR] = "FORMFEED_CHAR=";
key_array[HEX_CHAR] = "HEX_CHAR=";
key_array[HORIZONTAL_TAB_CHAR] = "HORIZONTAL_TAB_CHAR=";
key_array[INCLUDE] = "INCLUDE=";
key_array[IN_MODE] = "IN_MODE=";
key_array[NAMEK] = "NAME=";
key_array[NEWLINE_CHAR] = "NEWLINE_CHAR=";
key_array[OPT_PARAM] = "OPT_PARAM=";
key_array[PC_AT_END] = "PC_AT_END=";
key_array[PC_AT_START] = "PC_AT_START=";
key_array[PRINT_CONTROL] = "PRINT_CONTROL=";
key_array[PRINT_OPT] = "PRINT_OPT=";
key_array[PRINT_P1] = "PRINT_P1=";
key_array[PRINT_P2] = "PRINT_P2=";
key_array[PRINT_P3] = "PRINT_P3=";
key_array[PRINT_P4] = "PRINT_P4=";
key_array[PRINT_P5] = "PRINT_P5=";
key_array[PRINT_P6] = "PRINT_P6=";
key_array[PRINT_P7] = "PRINT_P7=";
key_array[PRINT_P8] = "PRINT_P8=";
key_array[PRINT_P9] = "PRINT_P9=";
key_array[REQPARAMS] = "REQPARAMS=";
key_array[RESET_BUFFER] = "RESET_BUFFER:";
key_array[RESET_FILE] = "RESET_FILE:";
key_array[RESET_MODE] = "RESET_MODE:";
key_array[RESET_SYSBUF] = "RESET_SYSBUF:";
key_array[SECTIONING_LEVEL] = "SECTIONING_LEVEL=";
key_array[SET_MODE] = "SET_MODE:";
key_array[SOURCE] = "SOURCE:";
key_array[SPECIAL_TOKEN] = "SPECIAL_TOKEN=";
key_array[START_ITEM] = "START_ITEM=";
key_array[START_ITEM_PARAM] = "START_ITEM_PARAM=";
key_array[START_OPT] = "START_OPT=";
key_array[START_TAG] = "START_TAG=";
key_array[START_TAG_1] = "START_TAG_1=";
key_array[START_TAG_2] = "START_TAG_2=";
key_array[START_TAG_3] = "START_TAG_3=";
key_array[START_TAG_4] = "START_TAG_4=";
key_array[START_TAG_5] = "START_TAG_5=";
key_array[START_TAG_6] = "START_TAG_6=";
key_array[START_TAG_7] = "START_TAG_7=";
key_array[START_TAG_8] = "START_TAG_8=";
key_array[START_TAG_9] = "START_TAG_9=";
key_array[STRINGG] = "STRING:";
key_array[SWITCH_BACK] = "SWITCH_BACK:";
key_array[SWITCH_TO_BUFFER] = "SWITCH_TO_BUFFER:";
key_array[SWITCH_TO_FILE] = "SWITCH_TO_FILE:";
key_array[SWITCH_TO_SYSBUF] = "SWITCH_TO_SYSBUF:";
key_array[TYPE] = "TYPE=";
key_array[VERTICAL_TAB_CHAR] = "VERTICAL_TAB_CHAR=";

} /* end INIT_KEYS */

/* KEY_TO_INT converts a keyword string to an integer */
int key_to_int(s, no_error)
STRING s;
{
int pos;

pos = lookup_string(s, key_array, max_keystr);
if (pos == -1) { /* unknown string */
if (!in_code) {
table_error("KEYWORD unrecognised");
}
}
return(pos);
} /* end KEY_TO_INT */

/* KEY_TO_STRING converts a keyword integer to a string */
STRING key_to_string(pos)
int pos;
{
if (pos >= 0 && pos < max_keystr) {
return(key_array[pos]);
}
table_error("KEYWORD out of range");
return(unk);
} /* end KEY_TO_STRING */