path: root/support/flatten/flatten.c

/* A lexical scanner generated by flex */

/* scanner skeleton version:
 * $Header: /usr/fsys/odin/a/vern/flex/RCS/flex.skel,v 2.16 90/08/03 14:09:36 vern Exp $
 */

#define FLEX_SCANNER

#include <stdio.h>


/* cfront 1.2 defines "c_plusplus" instead of "__cplusplus" */
#ifdef c_plusplus
#ifndef __cplusplus
#define __cplusplus
#endif
#endif


#ifdef __cplusplus

#include <stdlib.h>
#include <osfcn.h>

/* use prototypes in function declarations */
#define YY_USE_PROTOS

/* the "const" storage-class-modifier is valid */
#define YY_USE_CONST

#else	/* ! __cplusplus */

#ifdef __STDC__

#ifdef __GNUC__
#include <stddef.h>
void *malloc( size_t );
void free( void* );
#else
#include <stdlib.h>
#endif	/* __GNUC__ */

#define YY_USE_PROTOS
#define YY_USE_CONST

#endif	/* __STDC__ */
#endif	/* ! __cplusplus */


#ifdef __TURBOC__
#define YY_USE_CONST
#endif


#ifndef YY_USE_CONST
#define const
#endif


#ifdef YY_USE_PROTOS
#define YY_PROTO(proto) proto
#else
#define YY_PROTO(proto) ()
/* we can't get here if it's an ANSI C compiler, or a C++ compiler,
 * so it's got to be a K&R compiler, and therefore there's no standard
 * place from which to include these definitions
 */
char *malloc();
int free();
int read();
#endif


/* amount of stuff to slurp up with each read */
#ifndef YY_READ_BUF_SIZE
#define YY_READ_BUF_SIZE 8192
#endif

/* returned upon end-of-file */
#define YY_END_TOK 0

/* copy whatever the last rule matched to the standard output */

/* cast to (char *) is because for 8-bit chars, yytext is (unsigned char *) */
/* this used to be an fputs(), but since the string might contain NUL's,
 * we now use fwrite()
 */
#define ECHO (void) fwrite( (char *) yytext, yyleng, 1, yyout )

/* gets input and stuffs it into "buf".  number of characters read, or YY_NULL,
 * is returned in "result".
 */
#define YY_INPUT(buf,result,max_size) \
	if ( (result = read( fileno(yyin), (char *) buf, max_size )) < 0 ) \
	    YY_FATAL_ERROR( "read() in flex scanner failed" );
#define YY_NULL 0

/* no semi-colon after return; correct usage is to write "yyterminate();" -
 * we don't want an extra ';' after the "return" because that will cause
 * some compilers to complain about unreachable statements.
 */
#define yyterminate() return ( YY_NULL )

/* report a fatal error */

/* The funky do-while is used to turn this macro definition into
 * a single C statement (which needs a semi-colon terminator).
 * This avoids problems with code like:
 *
 * 	if ( something_happens )
 *		YY_FATAL_ERROR( "oops, the something happened" );
 *	else
 *		everything_okay();
 *
 * Prior to using the do-while the compiler would get upset at the
 * "else" because it interpreted the "if" statement as being all
 * done when it reached the ';' after the YY_FATAL_ERROR() call.
 */

#define YY_FATAL_ERROR(msg) \
	do \
		{ \
		(void) fputs( msg, stderr ); \
		(void) putc( '\n', stderr ); \
		exit( 1 ); \
		} \
	while ( 0 )

/* default yywrap function - always treat EOF as an EOF */
#define yywrap() 1

/* enter a start condition.  This macro really ought to take a parameter,
 * but we do it the disgusting crufty way forced on us by the ()-less
 * definition of BEGIN
 */
#define BEGIN yy_start = 1 + 2 *

/* action number for EOF rule of a given start state */
#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)

/* special action meaning "start processing a new file" */
#define YY_NEW_FILE \
	do \
		{ \
		yy_init_buffer( yy_current_buffer, yyin ); \
		yy_load_buffer_state(); \
		} \
	while ( 0 )

/* default declaration of generated scanner - a define so the user can
 * easily add parameters
 */
#define YY_DECL int yylex YY_PROTO(( void )) 

/* code executed at the end of each rule */
#define YY_BREAK break;

#define YY_END_OF_BUFFER_CHAR 0

#ifndef YY_BUF_SIZE
#define YY_BUF_SIZE (YY_READ_BUF_SIZE * 2) /* size of default input buffer */
#endif

typedef struct yy_buffer_state *YY_BUFFER_STATE;

#define YY_CHAR char
# line 1 "flatten.lx"
#define INITIAL 0
# line 2 "flatten.lx"
/* flatten.lx    (flex) lexer for concatenating "included" (La)TeX files
 *               Written by Peter Wilson (Catholic University and NIST)
 *               pwilson@cme.nist.gov
 */

char FILE_VERSION[] = "Version 1.1";
char FILE_DATE[] = "October 1995";

/* Version History:
 *         1.0 (December 1994): First release
 *         1.1 (October 1995): Added:
 *             -- directory searching
 *             -- use of \endinput to stop processing an included file
 */

/* 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 FLaTTeN software.
 * If the FLaTTeN 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 FLaTTeN 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 FLaTTeN 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 FLaTTeN 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 <stdio.h>
#include <string.h>
#include <ctype.h>
#include "getopt.h"
#include "srchenv.h"

typedef char *STRING;    /* a pointer-to-a-char */
typedef STRING *PTRADR;  /* A pointer-to-a-pointer-to-a-char */


#ifndef TRUE
# define TRUE 1
#endif
#ifndef FALSE
# define FALSE 0
#endif
# define MAX_DEPTH 100               /* max file nesting depth */
# define MAX_NAME 100                /* max length of a file name */
# define MY_EOS '\0'
# define MAX_ERRORS 10               /* max number of errors */

FILE *filerr;                        /* error file */
FILE *filout;                        /* output file */
FILE *filin;                         /* input root file */
int kind;                            /* kind of file inclusion */
int depth = 0;                       /* depth of file nesting */
FILE *file_stack[MAX_DEPTH];         /* stack of files */
char *name_stack[MAX_DEPTH];         /* stack of file names */
YY_BUFFER_STATE buffer_stack[MAX_DEPTH]; /* stack of input buffers */
char filnam[MAX_NAME];               /* name of a file */
char extnam[MAX_NAME];               /* name of file with extension */

extern FILE *yyin;
extern FILE *yyout;

int DEBUG;                           /* >=1 for debugging */
int num_errors = 0;                  /* number of errors */
int lineno = 1;                      /* input file line number */
# define MAX_LINE 2000               /* max length of an input line */
char linebuf[MAX_LINE];              /* buffer for input line */
int linlen = 0;                     /* current no of chars in linebuf */

char verb_char;                     /* delimeter for \verb command */

FILE *filtabin;                     /* command input file */
int num_commands = 0;               /* number of types of include commands */
# define MAX_TABLE_LINE 100         /* max number of chars in command table line */
# define MAX_COMMANDS 100           /* max number of inclusion commands */
STRING ctable[MAX_COMMANDS];        /* include command name table */

int lex_result;                     /* scratch integer for lexer */

                 /* Environment variable defined search path stuff */
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() */

void packup();
char *strsave();
void yyerror();
void start_a_file();
void end_a_file();
void catl();
void warning();
void read_table();
int lookup();
void initialise_senv();

/* END OF C CODE TO BE COPIED TO OUTPUT */
/* TeX comments from % through eol and gobble following whitespace */
#define VERBATIM_STATE 1
#define VERB_STATE 2
#define IN_STATE 3
/* END OF DEFINITIONS SECTION */              
# line 164 "flatten.lx"

/* done after the current pattern has been matched and before the
 * corresponding action - sets up yytext
 */
#define YY_DO_BEFORE_ACTION \
	yytext = yy_bp; \
	yyleng = yy_cp - yy_bp; \
	yy_hold_char = *yy_cp; \
	*yy_cp = '\0'; \
	yy_c_buf_p = yy_cp;

#define EOB_ACT_CONTINUE_SCAN 0
#define EOB_ACT_END_OF_FILE 1
#define EOB_ACT_LAST_MATCH 2

/* return all but the first 'n' matched characters back to the input stream */
#define yyless(n) \
	do \
		{ \
		/* undo effects of setting up yytext */ \
		*yy_cp = yy_hold_char; \
		yy_c_buf_p = yy_cp = yy_bp + n; \
		YY_DO_BEFORE_ACTION; /* set up yytext again */ \
		} \
	while ( 0 )

#define unput(c) yyunput( c, yytext )


struct yy_buffer_state
    {
    FILE *yy_input_file;

    YY_CHAR *yy_ch_buf;		/* input buffer */
    YY_CHAR *yy_buf_pos;	/* current position in input buffer */

    /* size of input buffer in bytes, not including room for EOB characters*/
    int yy_buf_size;	

    /* number of characters read into yy_ch_buf, not including EOB characters */
    int yy_n_chars;

    int yy_eof_status;		/* whether we've seen an EOF on this buffer */
#define EOF_NOT_SEEN 0
    /* "pending" happens when the EOF has been seen but there's still
     * some text process
     */
#define EOF_PENDING 1
#define EOF_DONE 2
    };

static YY_BUFFER_STATE yy_current_buffer;

/* we provide macros for accessing buffer states in case in the
 * future we want to put the buffer states in a more general
 * "scanner state"
 */
#define YY_CURRENT_BUFFER yy_current_buffer


/* yy_hold_char holds the character lost when yytext is formed */
static YY_CHAR yy_hold_char;

static int yy_n_chars;		/* number of characters read into yy_ch_buf */



#ifndef YY_USER_ACTION
#define YY_USER_ACTION
#endif

#ifndef YY_USER_INIT
#define YY_USER_INIT
#endif

extern YY_CHAR *yytext;
extern int yyleng;
extern FILE *yyin, *yyout;

YY_CHAR *yytext;
int yyleng;

FILE *yyin = (FILE *) 0, *yyout = (FILE *) 0;

#define YY_END_OF_BUFFER 20
typedef int yy_state_type;
static const short int yy_accept[90] =
    {   0,
        0,    0,    0,    0,    0,    0,    0,    0,   20,   18,
       15,   18,   16,   18,    5,    3,    4,    9,    8,   13,
       13,   12,   14,    0,    1,   16,   11,   11,   11,   11,
        5,    0,   13,   13,   12,   14,   12,   14,    1,   11,
       11,   11,    0,   11,   11,   11,    0,   11,   11,   11,
        0,    0,   11,   11,    7,    7,    7,    0,    0,    0,
        0,   11,    0,    0,    0,   11,    0,    0,   10,    0,
        0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
        0,    6,    0,    6,    0,    0,    2,    2,    0
    } ;

static const YY_CHAR yy_ec[128] =
    {   0,
        1,    1,    1,    1,    1,    1,    1,    1,    2,    3,
        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
        1,    2,    1,    1,    1,    1,    4,    1,    1,    1,
        1,    5,    1,    1,    1,    1,    1,    1,    1,    1,
        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
        1,    1,    1,    1,    6,    6,    6,    6,    6,    6,
        6,    6,    6,    6,    6,    6,    6,    6,    6,    6,
        6,    6,    6,    6,    6,    6,    6,    6,    6,    6,
        1,    7,    1,    1,    1,    1,    8,    9,    6,   10,

       11,    6,   12,    6,   13,    6,    6,    6,   14,   15,
        6,   16,    6,   17,    6,   18,   19,   20,    6,    6,
        6,    6,   21,    1,   22,    1,    1
    } ;

static const YY_CHAR yy_meta[23] =
    {   0,
        1,    1,    2,    1,    1,    3,    4,    3,    3,    3,
        3,    3,    3,    3,    3,    3,    3,    3,    3,    3,
        5,    5
    } ;

static const short int yy_base[101] =
    {   0,
        0,   22,    3,    5,  159,  158,    9,   11,  160,  163,
      163,  156,    0,    8,    0,  163,  147,  163,  163,    0,
       13,  155,  154,  152,  152,    0,    0,  142,  137,  140,
        0,  135,    0,   16,  147,  146,  145,  144,  143,  132,
      133,  125,  131,  127,  126,  129,   18,  122,  121,   44,
       34,   38,   39,  119,  163,    0,    0,   48,  123,   40,
       50,  114,  115,   51,  120,  112,  120,  108,    0,  112,
      104,   93,   74,   68,   62,   64,   64,   52,   61,   45,
       54,   71,   57,   70,   61,   62,   67,   14,  163,   84,
       89,   94,   99,  104,   11,    6,  109,  114,  118,  123

    } ;

static const short int yy_def[101] =
    {   0,
       90,   90,   91,   91,   92,   92,   93,   93,   89,   89,
       89,   94,   95,   96,   97,   89,   89,   89,   89,   98,
       98,   89,   89,   94,   89,   95,   96,   96,   96,   96,
       97,   89,   98,   98,   89,   89,   89,   89,   89,   96,
       96,   96,   89,   96,   96,   96,   89,   96,   96,   99,
       89,   89,   96,   96,   89,  100,   96,   89,   89,   89,
       89,   96,   89,   89,   89,   96,   89,   89,   96,   89,
       89,   89,   89,   89,   89,   89,   89,   89,   89,   89,
       89,   89,   89,   89,   89,   89,   89,   89,    0,   89,
       89,   89,   89,   89,   89,   89,   89,   89,   89,   89

    } ;

static const short int yy_nxt[186] =
    {   0,
       10,   10,   11,   12,   10,   16,   14,   16,   27,   17,
       21,   17,   21,   26,   34,   88,   28,   34,   29,   51,
       10,   10,   10,   10,   11,   12,   10,   30,   14,   22,
       23,   22,   23,   35,   36,   51,   35,   36,   52,   58,
       60,   60,   10,   10,   55,   55,   80,   55,   56,   58,
       55,   64,   64,   80,   52,   80,   81,   59,   85,   61,
       61,   86,   85,   85,   55,   55,   82,   59,   88,   65,
       65,   84,   84,   82,   83,   82,   79,   78,   87,   77,
       76,   75,   87,   87,   13,   13,   13,   13,   13,   15,
       15,   15,   15,   15,   18,   18,   18,   18,   18,   20,

       20,   20,   20,   20,   24,   24,   24,   24,   24,   31,
       74,   31,   73,   31,   33,   33,   33,   33,   57,   72,
       57,   57,   57,   55,   71,   55,   55,   55,   70,   69,
       68,   67,   66,   63,   62,   54,   53,   50,   49,   48,
       47,   46,   45,   44,   39,   38,   37,   38,   37,   43,
       42,   41,   40,   39,   25,   38,   37,   32,   25,   89,
       19,   19,    9,   89,   89,   89,   89,   89,   89,   89,
       89,   89,   89,   89,   89,   89,   89,   89,   89,   89,
       89,   89,   89,   89,   89
    } ;

static const short int yy_chk[186] =
    {   0,
        1,    1,    1,    1,    1,    3,    1,    4,   96,    3,
        7,    4,    8,   95,   21,   88,   14,   34,   14,   47,
        1,    1,    2,    2,    2,    2,    2,   14,    2,    7,
        7,    8,    8,   21,   21,   51,   34,   34,   47,   52,
       53,   60,    2,    2,   50,   50,   80,   50,   50,   58,
       50,   61,   64,   78,   51,   81,   78,   52,   83,   53,
       60,   83,   85,   86,   50,   50,   80,   58,   87,   61,
       64,   84,   82,   78,   79,   81,   77,   76,   83,   75,
       74,   73,   85,   86,   90,   90,   90,   90,   90,   91,
       91,   91,   91,   91,   92,   92,   92,   92,   92,   93,

       93,   93,   93,   93,   94,   94,   94,   94,   94,   97,
       72,   97,   71,   97,   98,   98,   98,   98,   99,   70,
       99,   99,   99,  100,   68,  100,  100,  100,   67,   66,
       65,   63,   62,   59,   54,   49,   48,   46,   45,   44,
       43,   42,   41,   40,   39,   38,   37,   36,   35,   32,
       30,   29,   28,   25,   24,   23,   22,   17,   12,    9,
        6,    5,   89,   89,   89,   89,   89,   89,   89,   89,
       89,   89,   89,   89,   89,   89,   89,   89,   89,   89,
       89,   89,   89,   89,   89
    } ;

static yy_state_type yy_last_accepting_state;
static YY_CHAR *yy_last_accepting_cpos;

/* the intent behind this definition is that it'll catch
 * any uses of REJECT which flex missed
 */
#define REJECT reject_used_but_not_detected
#define yymore() yymore_used_but_not_detected
#define YY_MORE_ADJ 0

/* these variables are all declared out here so that section 3 code can
 * manipulate them
 */
/* points to current character in buffer */
static YY_CHAR *yy_c_buf_p = (YY_CHAR *) 0;
static int yy_init = 1;		/* whether we need to initialize */
static int yy_start = 0;	/* start state number */

/* flag which is used to allow yywrap()'s to do buffer switches
 * instead of setting up a fresh yyin.  A bit of a hack ...
 */
static int yy_did_buffer_switch_on_eof;

static yy_state_type yy_get_previous_state YY_PROTO(( void ));
static yy_state_type yy_try_NUL_trans YY_PROTO(( yy_state_type current_state ));
static int yy_get_next_buffer YY_PROTO(( void ));
static void yyunput YY_PROTO(( YY_CHAR c, YY_CHAR *buf_ptr ));
void yyrestart YY_PROTO(( FILE *input_file ));
void yy_switch_to_buffer YY_PROTO(( YY_BUFFER_STATE new_buffer ));
void yy_load_buffer_state YY_PROTO(( void ));
YY_BUFFER_STATE yy_create_buffer YY_PROTO(( FILE *file, int size ));
void yy_delete_buffer YY_PROTO(( YY_BUFFER_STATE b ));
void yy_init_buffer YY_PROTO(( YY_BUFFER_STATE b, FILE *file ));

#define yy_new_buffer yy_create_buffer

#ifdef __cplusplus
static int yyinput YY_PROTO(( void ));
#else
static int input YY_PROTO(( void ));
#endif

YY_DECL
    {
    register yy_state_type yy_current_state;
    register YY_CHAR *yy_cp, *yy_bp;
    register int yy_act;


                /* START OF RULES SECTION */

               /*--------------- expressions and actions -------------------*/

                /* TeX comment */

    if ( yy_init )
	{
	YY_USER_INIT;

	if ( ! yy_start )
	    yy_start = 1;	/* first start state */

	if ( ! yyin )
	    yyin = stdin;

	if ( ! yyout )
	    yyout = stdout;

	if ( yy_current_buffer )
	    yy_init_buffer( yy_current_buffer, yyin );
	else
	    yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE );

	yy_load_buffer_state();

	yy_init = 0;
	}

    while ( 1 )		/* loops until end-of-file is reached */
	{
	yy_cp = yy_c_buf_p;

	/* support of yytext */
	*yy_cp = yy_hold_char;

	/* yy_bp points to the position in yy_ch_buf of the start of the
	 * current run.
	 */
	yy_bp = yy_cp;

	yy_current_state = yy_start;
yy_match:
	do
	    {
	    register YY_CHAR yy_c = yy_ec[*yy_cp];
	    if ( yy_accept[yy_current_state] )
		{
		yy_last_accepting_state = yy_current_state;
		yy_last_accepting_cpos = yy_cp;
		}
	    while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
		{
		yy_current_state = yy_def[yy_current_state];
		if ( yy_current_state >= 90 )
		    yy_c = yy_meta[yy_c];
		}
	    yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
	    ++yy_cp;
	    }
	while ( yy_current_state != 89 );
	yy_cp = yy_last_accepting_cpos;
	yy_current_state = yy_last_accepting_state;

yy_find_action:
	yy_act = yy_accept[yy_current_state];

	YY_DO_BEFORE_ACTION;
	YY_USER_ACTION;

do_action:	/* this label is used only to access EOF actions */


	switch ( yy_act )
	    {
	    case 0: /* must backtrack */
	    /* undo the effects of YY_DO_BEFORE_ACTION */
	    *yy_cp = yy_hold_char;
	    yy_cp = yy_last_accepting_cpos;
	    yy_current_state = yy_last_accepting_state;
	    goto yy_find_action;

case 1:
# line 170 "flatten.lx"
{ catl(yyleng, yytext);
                 if (DEBUG) {
                   fprintf(filerr, "%s", yytext);
                   fflush(filerr);
                 }
                 lineno++;
                 linebuf[0] = MY_EOS;
                 linlen = 0;
                 fprintf(filout, "%s", yytext);
               }
	YY_BREAK
              /* verbatims */
              /* \begin{verbatim} */
case 2:
# line 183 "flatten.lx"
{ catl(yyleng, yytext);
                 if (DEBUG) {
                   fprintf(filerr, "%s", yytext);
                   fflush(filerr);
                 }
                 BEGIN VERBATIM_STATE;
                 fprintf(filout, "%s", yytext);
               }
	YY_BREAK
                      /* newline in verbatim */
case 3:
# line 192 "flatten.lx"
{ catl(yyleng, yytext);
                 if (DEBUG) {
                   fprintf(filerr, "%s", yytext);
                   fflush(filerr);
                 }
                 lineno++;
                 linebuf[0] = MY_EOS;
                 linlen = 0;
                 fprintf(filout, "%s", yytext); 
               }
	YY_BREAK
                      /* backslash in verbatim */
case 4:
# line 203 "flatten.lx"
{ catl(yyleng, yytext);
                 if (DEBUG) {
                   fprintf(filerr, "%s", yytext);
                   fflush(filerr);
                 }
                 fprintf(filout, "%s", yytext); 
               }
	YY_BREAK
                   /* all except backslash and newline */
case 5:
# line 211 "flatten.lx"
{ catl(yyleng, yytext);
                 if (DEBUG) {
                   fprintf(filerr, "%s", yytext);
                   fflush(filerr);
                 }
                 fprintf(filout, "%s", yytext); 
               }
	YY_BREAK
                      /* \end{verbatim} */
case 6:
# line 219 "flatten.lx"
{ catl(yyleng, yytext);
                 if (DEBUG) {
                   fprintf(filerr, "%s", yytext);
                   fflush(filerr);
                 }
                 BEGIN 0;
                 fprintf(filout, "%s", yytext); 
               }
	YY_BREAK
                     /* \verb (and its trailing char) */
case 7:
# line 229 "flatten.lx"
{ catl(yyleng, yytext);
                 if (DEBUG) {
                   fprintf(filerr, "%s", yytext);
                   fflush(filerr);
                 }
                 BEGIN VERB_STATE;
                 fprintf(filout, "%s", yytext); 
                 verb_char = yytext[yyleng - 1];
               }
	YY_BREAK
                    /* newline inside \verb */
case 8:
# line 239 "flatten.lx"
{ catl(yyleng, yytext);
                 if (DEBUG) {
                   fprintf(filerr, "%s", yytext);
                   fflush(filerr);
                 }
                 lineno++;
                 linebuf[0] = MY_EOS;
                 linlen = 0;
                 fprintf(filout, "%s", yytext); 
               }
	YY_BREAK
                    /* chars inside \verb */
case 9:
# line 250 "flatten.lx"
{ catl(yyleng, yytext);
                 if (DEBUG) {
                   fprintf(filerr, "%s", yytext);
                   fflush(filerr);
                 }
                 if (verb_char == yytext[0]) {
                   BEGIN 0;
                 }
                 fprintf(filout, "%s", yytext); 
               }
	YY_BREAK
                /*-------- endinput command ------*/
case 10:
# line 263 "flatten.lx"
{ catl(yyleng, yytext);
                 if (DEBUG) {
                   fprintf(filerr, "\nlex DEBUG: End of input %s\n", name_stack[depth]);
                   fflush(filerr);
                 }
                 if (depth > 0) {
                   end_a_file();
                   yy_switch_to_buffer(buffer_stack[depth]);
                 }
                 else {
                   return(EOF);
                 }
	}
	YY_BREAK
               /*--------- includes? -------------*/
case 11:
# line 279 "flatten.lx"
{ catl(yyleng, yytext);
                 if (DEBUG) {
                   fprintf(filerr, "%s", yytext);
                   fflush(filerr);
                 }
                 lex_result = lookup(yytext);
                 if (DEBUG) {
                   fprintf(filerr, " (lookup=%d) ", lex_result);
                   fflush(filerr);
                 }
                 if (lex_result >= 0) {           /* found an include */
                   fprintf(filout, "%%%s", yytext);
                   BEGIN IN_STATE;
                 }
                 else {
                   fprintf(filout, "%s", yytext);
                 }
               }
	YY_BREAK
                     /* left brace */
case 12:
# line 299 "flatten.lx"
{ catl(yyleng, yytext);
                 if (DEBUG) {
                   fprintf(filerr, "%s", yytext);
                   fflush(filerr);
                 }
                 fprintf(filout, "%s", yytext);
	}
	YY_BREAK
                     /* file name */
case 13:
# line 309 "flatten.lx"
{ catl(yyleng, yytext);
                 if (DEBUG) {
                   fprintf(filerr, "%s", yytext);
                   fflush(filerr);
                 }
                 strcpy(filnam, yytext);
                 fprintf(filout, "%s", yytext);
	}
	YY_BREAK
                     /* close brace */
case 14:
# line 319 "flatten.lx"
{ catl(yyleng, yytext);
                 if (DEBUG) {
                   fprintf(filerr, "%s", yytext);
                   fflush(filerr);
                 }
                 fprintf(filout, "%s\n", yytext);
                 start_a_file(filnam);
                 yy_switch_to_buffer(buffer_stack[depth]);
                 if (DEBUG) {
                   fprintf(filerr, "\nlex DEBUG: Start of file: %s\n", name_stack[depth]);
                   fflush(filerr);
                 }
                 BEGIN 0;
	}
	YY_BREAK
               /*------------- uninteresting stuff -----------------*/
                     /* newline */
case 15:
# line 337 "flatten.lx"
{ catl(yyleng, yytext);
                 if (DEBUG) {
                   fprintf(filerr, "%s", yytext);
                   fflush(filerr);
                 }
                 lineno++;
                 linebuf[0] = MY_EOS;
                 linlen = 0;
                 fprintf(filout, "%s", yytext); 
	}
	YY_BREAK
                    /* alphabetic string */
case 16:
# line 349 "flatten.lx"
{ catl(yyleng, yytext);
                 if (DEBUG) {
                   fprintf(filerr, "%s", yytext);
                   fflush(filerr);
                 }
                 fprintf(filout, "%s", yytext); 
	}
	YY_BREAK
                   /* End Of File */
case YY_STATE_EOF(INITIAL):
case YY_STATE_EOF(VERBATIM_STATE):
case YY_STATE_EOF(VERB_STATE):
case YY_STATE_EOF(IN_STATE):
# line 358 "flatten.lx"
{ catl(yyleng, yytext);
                 if (DEBUG) {
                   fprintf(filerr, "\nlex DEBUG: End of file %s\n", name_stack[depth]);
                   fflush(filerr);
                 }
                 if (depth > 0) {
                   end_a_file();
                   yy_switch_to_buffer(buffer_stack[depth]);
                 }
                 else {
                   return(EOF);
                 }
	}
	YY_BREAK
                   /* anything else */
case 18:
# line 373 "flatten.lx"
{ catl(yyleng, yytext);
                 if (DEBUG) {
                   fprintf(filerr, "%s", yytext);
                   fflush(filerr);
                 }
                 fprintf(filout, "%s", yytext); 
	}
	YY_BREAK
               /* END OF RULES SECTION */
case 19:
# line 382 "flatten.lx"
ECHO;
	YY_BREAK

	    case YY_END_OF_BUFFER:
		{
		/* amount of text matched not including the EOB char */
		int yy_amount_of_matched_text = yy_cp - yytext - 1;

		/* undo the effects of YY_DO_BEFORE_ACTION */
		*yy_cp = yy_hold_char;

		/* note that here we test for yy_c_buf_p "<=" to the position
		 * of the first EOB in the buffer, since yy_c_buf_p will
		 * already have been incremented past the NUL character
		 * (since all states make transitions on EOB to the end-
		 * of-buffer state).  Contrast this with the test in yyinput().
		 */
		if ( yy_c_buf_p <= &yy_current_buffer->yy_ch_buf[yy_n_chars] )
		    /* this was really a NUL */
		    {
		    yy_state_type yy_next_state;

		    yy_c_buf_p = yytext + yy_amount_of_matched_text;

		    yy_current_state = yy_get_previous_state();

		    /* okay, we're now positioned to make the
		     * NUL transition.  We couldn't have
		     * yy_get_previous_state() go ahead and do it
		     * for us because it doesn't know how to deal
		     * with the possibility of jamming (and we
		     * don't want to build jamming into it because
		     * then it will run more slowly)
		     */

		    yy_next_state = yy_try_NUL_trans( yy_current_state );

		    yy_bp = yytext + YY_MORE_ADJ;

		    if ( yy_next_state )
			{
			/* consume the NUL */
			yy_cp = ++yy_c_buf_p;
			yy_current_state = yy_next_state;
			goto yy_match;
			}

		    else
			{
			    yy_cp = yy_last_accepting_cpos;
			    yy_current_state = yy_last_accepting_state;
			goto yy_find_action;
			}
		    }

		else switch ( yy_get_next_buffer() )
		    {
		    case EOB_ACT_END_OF_FILE:
			{
			yy_did_buffer_switch_on_eof = 0;

			if ( yywrap() )
			    {
			    /* note: because we've taken care in
			     * yy_get_next_buffer() to have set up yytext,
			     * we can now set up yy_c_buf_p so that if some
			     * total hoser (like flex itself) wants
			     * to call the scanner after we return the
			     * YY_NULL, it'll still work - another YY_NULL
			     * will get returned.
			     */
			    yy_c_buf_p = yytext + YY_MORE_ADJ;

			    yy_act = YY_STATE_EOF((yy_start - 1) / 2);
			    goto do_action;
			    }

			else
			    {
			    if ( ! yy_did_buffer_switch_on_eof )
				YY_NEW_FILE;
			    }
			}
			break;

		    case EOB_ACT_CONTINUE_SCAN:
			yy_c_buf_p = yytext + yy_amount_of_matched_text;

			yy_current_state = yy_get_previous_state();

			yy_cp = yy_c_buf_p;
			yy_bp = yytext + YY_MORE_ADJ;
			goto yy_match;

		    case EOB_ACT_LAST_MATCH:
			yy_c_buf_p =
			    &yy_current_buffer->yy_ch_buf[yy_n_chars];

			yy_current_state = yy_get_previous_state();

			yy_cp = yy_c_buf_p;
			yy_bp = yytext + YY_MORE_ADJ;
			goto yy_find_action;
		    }
		break;
		}

	    default:
#ifdef FLEX_DEBUG
		printf( "action # %d\n", yy_act );
#endif
		YY_FATAL_ERROR(
			"fatal flex scanner internal error--no action found" );
	    }
	}
    }


/* yy_get_next_buffer - try to read in a new buffer
 *
 * synopsis
 *     int yy_get_next_buffer();
 *     
 * returns a code representing an action
 *     EOB_ACT_LAST_MATCH - 
 *     EOB_ACT_CONTINUE_SCAN - continue scanning from current position
 *     EOB_ACT_END_OF_FILE - end of file
 */

static int yy_get_next_buffer()

    {
    register YY_CHAR *dest = yy_current_buffer->yy_ch_buf;
    register YY_CHAR *source = yytext - 1; /* copy prev. char, too */
    register int number_to_move, i;
    int ret_val;

    if ( yy_c_buf_p > &yy_current_buffer->yy_ch_buf[yy_n_chars + 1] )
	YY_FATAL_ERROR(
		"fatal flex scanner internal error--end of buffer missed" );

    /* try to read more data */

    /* first move last chars to start of buffer */
    number_to_move = yy_c_buf_p - yytext;

    for ( i = 0; i < number_to_move; ++i )
	*(dest++) = *(source++);

    if ( yy_current_buffer->yy_eof_status != EOF_NOT_SEEN )
	/* don't do the read, it's not guaranteed to return an EOF,
	 * just force an EOF
	 */
	yy_n_chars = 0;

    else
	{
	int num_to_read = yy_current_buffer->yy_buf_size - number_to_move - 1;

	if ( num_to_read > YY_READ_BUF_SIZE )
	    num_to_read = YY_READ_BUF_SIZE;

	else if ( num_to_read <= 0 )
	    YY_FATAL_ERROR( "fatal error - scanner input buffer overflow" );

	/* read in more data */
	YY_INPUT( (&yy_current_buffer->yy_ch_buf[number_to_move]),
		  yy_n_chars, num_to_read );
	}

    if ( yy_n_chars == 0 )
	{
	if ( number_to_move == 1 )
	    {
	    ret_val = EOB_ACT_END_OF_FILE;
	    yy_current_buffer->yy_eof_status = EOF_DONE;
	    }

	else
	    {
	    ret_val = EOB_ACT_LAST_MATCH;
	    yy_current_buffer->yy_eof_status = EOF_PENDING;
	    }
	}

    else
	ret_val = EOB_ACT_CONTINUE_SCAN;

    yy_n_chars += number_to_move;
    yy_current_buffer->yy_ch_buf[yy_n_chars] = YY_END_OF_BUFFER_CHAR;
    yy_current_buffer->yy_ch_buf[yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR;

    /* yytext begins at the second character in yy_ch_buf; the first
     * character is the one which preceded it before reading in the latest
     * buffer; it needs to be kept around in case it's a newline, so
     * yy_get_previous_state() will have with '^' rules active
     */

    yytext = &yy_current_buffer->yy_ch_buf[1];

    return ( ret_val );
    }


/* yy_get_previous_state - get the state just before the EOB char was reached
 *
 * synopsis
 *     yy_state_type yy_get_previous_state();
 */

static yy_state_type yy_get_previous_state()

    {
    register yy_state_type yy_current_state;
    register YY_CHAR *yy_cp;

    yy_current_state = yy_start;

    for ( yy_cp = yytext + YY_MORE_ADJ; yy_cp < yy_c_buf_p; ++yy_cp )
	{
	register YY_CHAR yy_c = (*yy_cp ? yy_ec[*yy_cp] : 1);
	if ( yy_accept[yy_current_state] )
	    {
	    yy_last_accepting_state = yy_current_state;
	    yy_last_accepting_cpos = yy_cp;
	    }
	while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
	    {
	    yy_current_state = yy_def[yy_current_state];
	    if ( yy_current_state >= 90 )
		yy_c = yy_meta[yy_c];
	    }
	yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
	}

    return ( yy_current_state );
    }


/* yy_try_NUL_trans - try to make a transition on the NUL character
 *
 * synopsis
 *     next_state = yy_try_NUL_trans( current_state );
 */

#ifdef YY_USE_PROTOS
static yy_state_type yy_try_NUL_trans( register yy_state_type yy_current_state )
#else
static yy_state_type yy_try_NUL_trans( yy_current_state )
register yy_state_type yy_current_state;
#endif

    {
    register int yy_is_jam;
    register YY_CHAR *yy_cp = yy_c_buf_p;

    register YY_CHAR yy_c = 1;
    if ( yy_accept[yy_current_state] )
	{
	yy_last_accepting_state = yy_current_state;
	yy_last_accepting_cpos = yy_cp;
	}
    while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
	{
	yy_current_state = yy_def[yy_current_state];
	if ( yy_current_state >= 90 )
	    yy_c = yy_meta[yy_c];
	}
    yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
    yy_is_jam = (yy_current_state == 89);

    return ( yy_is_jam ? 0 : yy_current_state );
    }


#ifdef YY_USE_PROTOS
static void yyunput( YY_CHAR c, register YY_CHAR *yy_bp )
#else
static void yyunput( c, yy_bp )
YY_CHAR c;
register YY_CHAR *yy_bp;
#endif

    {
    register YY_CHAR *yy_cp = yy_c_buf_p;

    /* undo effects of setting up yytext */
    *yy_cp = yy_hold_char;

    if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )
	{ /* need to shift things up to make room */
	register int number_to_move = yy_n_chars + 2; /* +2 for EOB chars */
	register YY_CHAR *dest =
	    &yy_current_buffer->yy_ch_buf[yy_current_buffer->yy_buf_size + 2];
	register YY_CHAR *source =
	    &yy_current_buffer->yy_ch_buf[number_to_move];

	while ( source > yy_current_buffer->yy_ch_buf )
	    *--dest = *--source;

	yy_cp += dest - source;
	yy_bp += dest - source;
	yy_n_chars = yy_current_buffer->yy_buf_size;

	if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )
	    YY_FATAL_ERROR( "flex scanner push-back overflow" );
	}

    if ( yy_cp > yy_bp && yy_cp[-1] == '\n' )
	yy_cp[-2] = '\n';

    *--yy_cp = c;

    /* note: the formal parameter *must* be called "yy_bp" for this
     *       macro to now work correctly
     */
    YY_DO_BEFORE_ACTION; /* set up yytext again */
    }


#ifdef __cplusplus
static int yyinput()
#else
static int input()
#endif

    {
    int c;
    YY_CHAR *yy_cp = yy_c_buf_p;

    *yy_cp = yy_hold_char;

    if ( *yy_c_buf_p == YY_END_OF_BUFFER_CHAR )
	{
	/* yy_c_buf_p now points to the character we want to return.
	 * If this occurs *before* the EOB characters, then it's a
	 * valid NUL; if not, then we've hit the end of the buffer.
	 */
	if ( yy_c_buf_p < &yy_current_buffer->yy_ch_buf[yy_n_chars] )
	    /* this was really a NUL */
	    *yy_c_buf_p = '\0';

	else
	    { /* need more input */
	    yytext = yy_c_buf_p;
	    ++yy_c_buf_p;

	    switch ( yy_get_next_buffer() )
		{
		case EOB_ACT_END_OF_FILE:
		    {
		    if ( yywrap() )
			{
			yy_c_buf_p = yytext + YY_MORE_ADJ;
			return ( EOF );
			}

		    YY_NEW_FILE;

#ifdef __cplusplus
		    return ( yyinput() );
#else
		    return ( input() );
#endif
		    }
		    break;

		case EOB_ACT_CONTINUE_SCAN:
		    yy_c_buf_p = yytext + YY_MORE_ADJ;
		    break;

		case EOB_ACT_LAST_MATCH:
#ifdef __cplusplus
		    YY_FATAL_ERROR( "unexpected last match in yyinput()" );
#else
		    YY_FATAL_ERROR( "unexpected last match in input()" );
#endif
		}
	    }
	}

    c = *yy_c_buf_p;
    yy_hold_char = *++yy_c_buf_p;

    return ( c );
    }


#ifdef YY_USE_PROTOS
void yyrestart( FILE *input_file )
#else
void yyrestart( input_file )
FILE *input_file;
#endif

    {
    yy_init_buffer( yy_current_buffer, input_file );
    yy_load_buffer_state();
    }


#ifdef YY_USE_PROTOS
void yy_switch_to_buffer( YY_BUFFER_STATE new_buffer )
#else
void yy_switch_to_buffer( new_buffer )
YY_BUFFER_STATE new_buffer;
#endif

    {
    if ( yy_current_buffer == new_buffer )
	return;

    if ( yy_current_buffer )
	{
	/* flush out information for old buffer */
	*yy_c_buf_p = yy_hold_char;
	yy_current_buffer->yy_buf_pos = yy_c_buf_p;
	yy_current_buffer->yy_n_chars = yy_n_chars;
	}

    yy_current_buffer = new_buffer;
    yy_load_buffer_state();

    /* we don't actually know whether we did this switch during
     * EOF (yywrap()) processing, but the only time this flag
     * is looked at is after yywrap() is called, so it's safe
     * to go ahead and always set it.
     */
    yy_did_buffer_switch_on_eof = 1;
    }


#ifdef YY_USE_PROTOS
void yy_load_buffer_state( void )
#else
void yy_load_buffer_state()
#endif

    {
    yy_n_chars = yy_current_buffer->yy_n_chars;
    yytext = yy_c_buf_p = yy_current_buffer->yy_buf_pos;
    yyin = yy_current_buffer->yy_input_file;
    yy_hold_char = *yy_c_buf_p;
    }


#ifdef YY_USE_PROTOS
YY_BUFFER_STATE yy_create_buffer( FILE *file, int size )
#else
YY_BUFFER_STATE yy_create_buffer( file, size )
FILE *file;
int size;
#endif

    {
    YY_BUFFER_STATE b;

    b = (YY_BUFFER_STATE) malloc( sizeof( struct yy_buffer_state ) );

    if ( ! b )
	YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );

    b->yy_buf_size = size;

    /* yy_ch_buf has to be 2 characters longer than the size given because
     * we need to put in 2 end-of-buffer characters.
     */
    b->yy_ch_buf = (YY_CHAR *) malloc( (unsigned) (b->yy_buf_size + 2) );

    if ( ! b->yy_ch_buf )
	YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );

    yy_init_buffer( b, file );

    return ( b );
    }


#ifdef YY_USE_PROTOS
void yy_delete_buffer( YY_BUFFER_STATE b )
#else
void yy_delete_buffer( b )
YY_BUFFER_STATE b;
#endif

    {
    if ( b == yy_current_buffer )
	yy_current_buffer = (YY_BUFFER_STATE) 0;

    free( (char *) b->yy_ch_buf );
    free( (char *) b );
    }


#ifdef YY_USE_PROTOS
void yy_init_buffer( YY_BUFFER_STATE b, FILE *file )
#else
void yy_init_buffer( b, file )
YY_BUFFER_STATE b;
FILE *file;
#endif

    {
    b->yy_input_file = file;

    /* we put in the '\n' and start reading from [1] so that an
     * initial match-at-newline will be true.
     */

    b->yy_ch_buf[0] = '\n';
    b->yy_n_chars = 1;

    /* we always need two end-of-buffer characters.  The first causes
     * a transition to the end-of-buffer state.  The second causes
     * a jam in that state.
     */
    b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
    b->yy_ch_buf[2] = YY_END_OF_BUFFER_CHAR;

    b->yy_buf_pos = &b->yy_ch_buf[1];

    b->yy_eof_status = EOF_NOT_SEEN;
    }
# line 382 "flatten.lx"

               /* START OF USER SUBROUTINE SECTION */


/* MAIN program */
main(argc, argv)
int argc;
char **argv;
{
    char optchar;
    int n;
    FILE *file;
    int result;
    int i, j;
    char tabnam[100];             /* command table input file */
    int TABLE = FALSE;

                 /* print banner */
  fprintf(stdout, "\n        flatten: Source file inclusion for LaTeX files");
  fprintf(stdout, "\n        (%s, %s)\n", FILE_VERSION, FILE_DATE);


                 /* open error log file */
   file = fopen("flatten.err", "w");
   if (!file) {
     fprintf(stderr, "\n Could not open file flatten.err\n");
     exit(1);
   }
   filerr = file;
   fprintf(stdout, "\nError file is flatten.err\n");
   fprintf(filerr, "Error file for program flatten (%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 pwilson@cme.nist.gov\n\n");
    
               /* set up for directory searching */
   initialise_senv();

    /* get command line optional parameters */
    opterr = 1;                   /* getopt will print errors with opterr = 1 */
    while (EOF != (optchar =
          getopt(argc,argv,"d:f:P:D:"))) { 
          switch(optchar) {
            case '?': {              /* command line error */
 fprintf(stdout,"\nUsage [-d number] [-f tablename] [-P chars] [-D char] infile outfile\n");
 fprintf(filerr,"\nUsage [-d number] [-f tablename] [-P chars] [-D char] infile outfile\n");
              break;
            }
            case 'd': {              /* switch on debugging */
              senv_debug = atoi(optarg);
              if (senv_debug > 1) {     /* debug everything */
                DEBUG = 1;
                senv_debug = 1;
                fprintf(stdout, "All debugging set ON\n");
                fprintf(filerr, "All debugging set ON\n");
              }
              else if (senv_debug = 1) {  /* debug directory search only */
                fprintf(stdout, "Directory search debugging set ON\n");
                fprintf(filerr, "Directory search debugging set ON\n");
              }
              else {              /* an error */
                senv_debug = 0;
                fprintf(stdout, "Debug option error. Requires number greater than zero\n");
                fprintf(filerr, "Debug option error. Requires number greater than zero\n");
              }
              break;
            }
            case 'f': {               /* commands in a file */
              TABLE = TRUE;
              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 optional parameter processing */

    if (TABLE) {                  /* 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, "Command input file is %s\n", path_name);
      fprintf(filerr, "Command input file is %s\n", path_name);
    }
    else {
      fprintf(stdout, "Using default inclusion commands\n");
      fprintf(filerr, "Using default inclusion commands\n");
    }

    /* rest of parameters are file names (input and output) */
    n = 0;
    for (;optind < argc; optind++) {
        n++;
        if (n == 1) {
           strcpy(filnam, argv[optind]);      /* take copy of input file name */
           file = fopen(argv[optind], "r");
           if (!file) {
              fprintf(stderr,"\nCould not open input file %s\n",argv[optind]);
              fprintf(filerr,"\nCould not open input file %s\n",argv[optind]);
              exit(1);
           }
           fprintf(stdout,"\nReading file %s", argv[optind]);
           fprintf(filerr,"\nReading file %s", argv[optind]);
           filin = file;
        }
        else { 
          if (n == 2) {
            file = fopen(argv[optind], "w");
            if (!file) {
              fprintf(stderr,"\nCould not open output file %s\n",argv[optind]);
              fprintf(filerr,"\nCould not open output file %s\n",argv[optind]);
                     exit(1);
            }
            fprintf(stdout," and writing to file %s\n",argv[optind]);
            fprintf(filerr," and writing to file %s\n",argv[optind]);
            filout = file;
          }
          else {
  fprintf(stderr,"\nOnly two files permitted. File %s ignored\n",argv[optind]);
  fprintf(filerr,"\nOnly two files permitted. File %s ignored\n",argv[optind]);
          }
        }
    }
    if (n == 0) { 
       fprintf(stderr,"\nAn input and an output file are required.\n");
       fprintf(filerr,"\nAn input and an output file are required.\n");
       exit(1);
    }
                 /* initialize file stacks */
    file_stack[0] = filin;
    if (DEBUG) {
      fprintf(stderr, "\n DEBUG: Source filnam = %s", filnam);
      fprintf(filerr, "\n DEBUG: Source filnam = %s", filnam);
                   fflush(filerr);
    }
    name_stack[0] = strsave(filnam);
    buffer_stack[0] = yy_create_buffer(filin, YY_BUF_SIZE);
/*    strcpy(name_stack[0], filnam); */
    if (DEBUG) {
      fprintf(stderr, "\n DEBUG: filnam = %s", filnam);
      fprintf(stderr, "\n        name_stack[0] = %s", name_stack[0]);
      fprintf(filerr, "\n DEBUG: filnam = %s", filnam);
      fprintf(filerr, "\n        name_stack[0] = %s", name_stack[0]);
                   fflush(filerr);
    }
    for (i = 1; i < MAX_DEPTH; i++) {
        file_stack[i] = NULL;
        name_stack[i] = NULL;
    }

                       /* set up command table */
    if (TABLE) {                                 /* read commands */
      read_table();
    }
    else {                                       /* use default commands */
      ctable[0] = "\\input";
      ctable[1] = "\\include";
      num_commands = 2;
    }
    if (DEBUG) {                     /* print table */
      fprintf(filerr, "\n COMMAND TABLE (%d commands)\n", num_commands);
      for (j = 0; j < num_commands; j++) {
        fprintf(filerr, "(%d) %s\n", j, ctable[j]);
      }
      fflush(filerr);
    }

                 /* process input */
      /* fprintf(filout, "File %s incorporates the following files:\n", name_stack[0]); */
      fprintf(filerr, "\nProcessing root source file %s", name_stack[depth]);
      fprintf(stdout, "\nProcessing root source file %s", name_stack[depth]);
                   fflush(filerr);

    for (;;) {
    /*      yyin = file_stack[depth]; */
      if (file_stack[depth] == NULL) {
        yyerror("FATAL ERROR: Null file name");
        exit(1);
      }
      yy_switch_to_buffer(buffer_stack[depth]);
      result = yylex();
      if (DEBUG) {
        fprintf(stderr, "\n DEBUG: Parse returned with result = %d",result);
        fprintf(filerr, "\n DEBUG: Parse returned with result = %d",result);
                   fflush(filerr);
      }
      if (result == EOF) {               /* end of current file */
        if (depth <= 0) {                /* end of all files */
          fprintf(stdout, "\nEnd of root input file %s\n", name_stack[0]);
          fprintf(filerr, "\nEnd of root input file %s\n", name_stack[0]);
          fprintf(stdout, "\nCompleted file processing\n");
          fprintf(filerr, "\nCompleted file processing\n");
          packup(filin, filout, filerr);
          return(0);
        }
        else {                          /* pop stacks */
          end_a_file();
        }
      }
      else {                       /* new file inclusion */
        start_a_file(filnam);
      }
    } /* end for loop */
}                                             /* end MAIN */


/* ADDEXT adds a .tex extension to a file name */
int addext(in, out)
char in[];                   /* name as input */
char out[];                  /* name with .tex extension */
{
  int i, n;
  int period;

  period = FALSE;
  for (i = 0; in[i] != MY_EOS; i++) {
    out[i] = in[i];
    if (in[i] == '.') {
      period = TRUE;
    }
  }
  out[i] = MY_EOS;
  if (period == FALSE) {
    strcat(out, ".tex");
  }
  return(period);
}                                                          /* end ADDEXT */

/* PACKUP closes 3 files */
void packup(f1, f2, f3)
FILE *f1;
FILE *f2;
FILE *f3;
{
    fclose(f1);
    fclose(f2);
    fclose(f3);
}                                                          /* end PACKUP */


/* STRSAVE saves a string somewhere */
char *strsave(s)
char *s;                           /* string to be saved */
{
  char *p, *malloc();

  if ((p = malloc(strlen(s)+1)) != NULL) {
     strcpy(p, s);
     return(p);
   }
  else {
    fprintf(stderr, "\nFATAL ERROR: Out of memory in STRSAVE\n");
    fprintf(filerr, "\nFATAL ERROR: Out of memory in STRSAVE\n");
    exit(1);
  }
}                                                         /* end STRSAVE */


/* YYERROR prints parse error message */
void yyerror(s)
char *s;                          /* string to be printed */
{
  fprintf(stderr, "\n%s in line\n%d: %s\n", s, lineno, linebuf);
  fprintf(filerr, "\n%s in line\n%d: %s\n", s, lineno, linebuf);
  num_errors++;
  if (num_errors >= MAX_ERRORS) {
    fprintf(stderr, "\n** Program ended with at least %d errors **\n", num_errors);
    fprintf(filerr, "\n** Program ended with at least %d errors **\n", num_errors);
    fprintf(yyout, "\n** Program ended with at least %d errors **\n", num_errors);
    exit(1);
  }
}                                         /* end YYERROR */


/* START_A_FILE starts a new input file */
void start_a_file(filnam)          
char filnam[];                     /* name of file */
{
  char extnam[MAX_NAME];
  FILE *file;
  int i;

  addext(filnam, extnam);           /* add extension to file name */
  if (depth >= MAX_DEPTH - 1) {
    fprintf(stderr, "\n File nesting too deep (over %d)\n", MAX_DEPTH);
    fprintf(filerr, "\n File nesting too deep (over %d)\n", MAX_DEPTH);
                   fflush(filerr);
    packup(filin, filout, filerr);
    exit(0);
  }
  if (!searchenv(extnam, sys_envname, path_name, path_sep, dir_cat, senv_debug)) {
    fprintf(stderr,"\nCould not find file %s\n", extnam);
    fprintf(filerr,"\nCould not find file %s\n", extnam);
                   fflush(filerr);
    fprintf(filout, "\n%%FLATTEN WARNING: Could not find file %s\n", extnam);
    fprintf(filout, "%%                  Skipping it\n");
    return;
  }
  file = fopen(path_name, "r");
  if (!file) {
    fprintf(stderr, "\n Could not open file %s\n", path_name);
    fprintf(filerr, "\n Could not open file %s\n", path_name);
                   fflush(filerr);
    fprintf(filout, "\n%%FLATTEN WARNING: Could not open file %s\n", path_name);
    fprintf(filout, "%%                  Skipping it\n");
    return;
  }
  depth++;
  name_stack[depth] = strsave(path_name);
  file_stack[depth] = file;
  buffer_stack[depth] = yy_create_buffer(file, YY_BUF_SIZE);
  if (DEBUG) {
    fprintf(filerr, "\n DEBUG (start_a_file): depth = %d", depth);
                   fflush(filerr);
    for (i = 0; i <= depth; i++) {
      fprintf(filerr, "\n        depth = %d, name_stack = %s", i, name_stack[i]);
    }
    fprintf(filerr, "\n DEBUG (start_a_file): New file is %s", name_stack[depth]);
    fprintf(stdout, "\n DEBUG (start_a_file): New file is %s", name_stack[depth]);
                   fflush(filerr);
  }

  fprintf(stdout, "\nProcessing file %s as %s", filnam, name_stack[depth]);
  fprintf(filerr, "\nProcessing file %s as %s", filnam, name_stack[depth]);
                   fflush(filerr);

}                                  /* end START_A_FILE */


/* END_A_FILE closes down a file */
void end_a_file()                             
{
  int i;

  fprintf(filout, "%%   END OF FILE %s\n", name_stack[depth]);
  fprintf(stdout, "\n   End of file %s", name_stack[depth]);
  fprintf(filerr, "\n   End of file %s", name_stack[depth]);
                   fflush(filerr);
  if (DEBUG) {
    fprintf(filerr, "\n DEBUG (end_a_file): depth = %d", depth);
    for (i = 0; i <= depth; i++) {
      fprintf(filerr, "\n        depth = %d, name_stack = %s", i, name_stack[i]);
                   fflush(filerr);
    }
    fprintf(filerr, "\n DEBUG (end_a_file): Old file was %s", name_stack[depth]);
    fprintf(stdout, "\n DEBUG (end_a_file): Old file was %s", name_stack[depth]);
                   fflush(filerr);
  }

                 /* pop stack */
  fclose(file_stack[depth]);
  file_stack[depth] = NULL;
  free(name_stack[depth]);
  name_stack[depth] = NULL;
  yy_delete_buffer(buffer_stack[depth]);
  depth--;
  if (depth < 0) {
    yyerror("Nesting depth gone negative");
    depth = 0;
  }
}                                  /* end END_A_FILE */


/* WARNING prints a warning */
void warning(s)                             
char *s;
{
  fprintf(stderr, "\nWARNING: %s in line\n%d: %s\n", s, lineno, linebuf);
  fprintf(filerr, "\nWARNING: %s in line\n%d: %s\n", s, lineno, linebuf);
                   fflush(filerr);
}                                   /* end WARNING */


/* CATL concatenates S to line buffer */
void catl(n,s)                
int n;               /* no of chars in s */
char *s;
{
  linlen = linlen + n;           /* current no. of chars to be in linebuf */
  if (linlen >= MAX_LINE) {      /* linebuf will overflow */
    warning("A very long line. Internal buffer size exceeded");
    linebuf[0] = '\0';
    linlen = n;
  }
  strcat(linebuf, s);
}                                         /* end CATL */


/* READ_TABLE sets up commands from filtabin */
void read_table()             
{
  char line[MAX_TABLE_LINE];
  char code_name[MAX_TABLE_LINE];
  int num_names;

  while ( fgets(line, MAX_TABLE_LINE, filtabin) != NULL) {  /* read a line */
                   /* get first name on line */
    num_names = sscanf(line, "%s", code_name);
    if (num_names == 0) {               /* ignore blank line */
      ;
    }
    else {                              /* add to table */
      if (num_commands >= MAX_COMMANDS) {  /* overflow */
        fprintf(stderr, "\nWARNING Too many commands, limited to %d\n", MAX_COMMANDS);
        fprintf(filerr, "\nWARNING Too many commands, limited to %d\n", MAX_COMMANDS);
                   fflush(filerr);
        return;
      }
      ctable[num_commands] = strsave(code_name);
      num_commands++;
    }
  }
}                                       /* end READ_TABLE */


/* LOOKUP searches for str in ctable */
int lookup(str)                         
char str[];
{
  int i;
 
  for (i = 0; i < num_commands; i++) {
    if (strcmp(ctable[i], str) == 0) {           /* found it */
      return(i);
    }
  }
  return(-1);
}                                       /* end LOOKUP */


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