summaryrefslogtreecommitdiff
path: root/support/flatten/flatten.c
diff options
context:
space:
mode:
authorNorbert Preining <norbert@preining.info>2019-09-02 13:46:59 +0900
committerNorbert Preining <norbert@preining.info>2019-09-02 13:46:59 +0900
commite0c6872cf40896c7be36b11dcc744620f10adf1d (patch)
tree60335e10d2f4354b0674ec22d7b53f0f8abee672 /support/flatten/flatten.c
Initial commit
Diffstat (limited to 'support/flatten/flatten.c')
-rw-r--r--support/flatten/flatten.c1877
1 files changed, 1877 insertions, 0 deletions
diff --git a/support/flatten/flatten.c b/support/flatten/flatten.c
new file mode 100644
index 0000000000..ed435dc790
--- /dev/null
+++ b/support/flatten/flatten.c
@@ -0,0 +1,1877 @@
+/* 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 */ \ No newline at end of file