home *** CD-ROM | disk | FTP | other *** search
/ Night Owl 25 / nopv25.iso / 040A / INTERCAL.ZIP / src / lexer.c < prev    next >
Encoding:
C/C++ Source or Header  |  1996-09-03  |  54.2 KB  |  2,124 lines
  1. /* A lexical scanner generated by flex */
  2.  
  3. /* Scanner skeleton version:
  4.  * $Header: /home/daffy/u0/vern/flex/RCS/flex.skl,v 2.85 95/04/24 10:48:47 vern Exp $
  5.  */
  6.  
  7. #define FLEX_SCANNER
  8. #define YY_FLEX_MAJOR_VERSION 2
  9. #define YY_FLEX_MINOR_VERSION 5
  10.  
  11. #include <stdio.h>
  12.  
  13.  
  14. /* cfront 1.2 defines "c_plusplus" instead of "__cplusplus" */
  15. #ifdef c_plusplus
  16. #ifndef __cplusplus
  17. #define __cplusplus
  18. #endif
  19. #endif
  20.  
  21.  
  22. #ifdef __cplusplus
  23.  
  24. #include <stdlib.h>
  25. #include <unistd.h>
  26.  
  27. /* Use prototypes in function declarations. */
  28. #define YY_USE_PROTOS
  29.  
  30. /* The "const" storage-class-modifier is valid. */
  31. #define YY_USE_CONST
  32.  
  33. #else    /* ! __cplusplus */
  34.  
  35. #if __STDC__
  36.  
  37. #define YY_USE_PROTOS
  38. #define YY_USE_CONST
  39.  
  40. #endif    /* __STDC__ */
  41. #endif    /* ! __cplusplus */
  42.  
  43. #ifdef __TURBOC__
  44.  #pragma warn -rch
  45.  #pragma warn -use
  46. #include <io.h>
  47. #include <stdlib.h>
  48. #define YY_USE_CONST
  49. #define YY_USE_PROTOS
  50. #endif
  51.  
  52. #ifdef YY_USE_CONST
  53. #define yyconst const
  54. #else
  55. #define yyconst
  56. #endif
  57.  
  58.  
  59. #ifdef YY_USE_PROTOS
  60. #define YY_PROTO(proto) proto
  61. #else
  62. #define YY_PROTO(proto) ()
  63. #endif
  64.  
  65. /* Returned upon end-of-file. */
  66. #define YY_NULL 0
  67.  
  68. /* Promotes a possibly negative, possibly signed char to an unsigned
  69.  * integer for use as an array index.  If the signed char is negative,
  70.  * we want to instead treat it as an 8-bit unsigned char, hence the
  71.  * double cast.
  72.  */
  73. #define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c)
  74.  
  75. /* Enter a start condition.  This macro really ought to take a parameter,
  76.  * but we do it the disgusting crufty way forced on us by the ()-less
  77.  * definition of BEGIN.
  78.  */
  79. #define BEGIN yy_start = 1 + 2 *
  80.  
  81. /* Translate the current start state into a value that can be later handed
  82.  * to BEGIN to return to the state.  The YYSTATE alias is for lex
  83.  * compatibility.
  84.  */
  85. #define YY_START ((yy_start - 1) / 2)
  86. #define YYSTATE YY_START
  87.  
  88. /* Action number for EOF rule of a given start state. */
  89. #define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
  90.  
  91. /* Special action meaning "start processing a new file". */
  92. #define YY_NEW_FILE yyrestart( yyin )
  93.  
  94. #define YY_END_OF_BUFFER_CHAR 0
  95.  
  96. /* Size of default input buffer. */
  97. #define YY_BUF_SIZE 16384
  98.  
  99. typedef struct yy_buffer_state *YY_BUFFER_STATE;
  100.  
  101. extern int yyleng;
  102. extern FILE *yyin, *yyout;
  103.  
  104. #define EOB_ACT_CONTINUE_SCAN 0
  105. #define EOB_ACT_END_OF_FILE 1
  106. #define EOB_ACT_LAST_MATCH 2
  107.  
  108. /* The funky do-while in the following #define is used to turn the definition
  109.  * int a single C statement (which needs a semi-colon terminator).  This
  110.  * avoids problems with code like:
  111.  *
  112.  *     if ( condition_holds )
  113.  *        yyless( 5 );
  114.  *    else
  115.  *        do_something_else();
  116.  *
  117.  * Prior to using the do-while the compiler would get upset at the
  118.  * "else" because it interpreted the "if" statement as being all
  119.  * done when it reached the ';' after the yyless() call.
  120.  */
  121.  
  122. /* Return all but the first 'n' matched characters back to the input stream. */
  123.  
  124. #define yyless(n) \
  125.     do \
  126.         { \
  127.         /* Undo effects of setting up yytext. */ \
  128.         *yy_cp = yy_hold_char; \
  129.         yy_c_buf_p = yy_cp = yy_bp + n - YY_MORE_ADJ; \
  130.         YY_DO_BEFORE_ACTION; /* set up yytext again */ \
  131.         } \
  132.     while ( 0 )
  133.  
  134. #define unput(c) yyunput( c, yytext_ptr )
  135.  
  136. /* The following is because we cannot portably get our hands on size_t
  137.  * (without autoconf's help, which isn't available because we want
  138.  * flex-generated scanners to compile on their own).
  139.  */
  140. typedef unsigned int yy_size_t;
  141.  
  142.  
  143. struct yy_buffer_state
  144.     {
  145.     FILE *yy_input_file;
  146.  
  147.     char *yy_ch_buf;        /* input buffer */
  148.     char *yy_buf_pos;        /* current position in input buffer */
  149.  
  150.     /* Size of input buffer in bytes, not including room for EOB
  151.      * characters.
  152.      */
  153.     yy_size_t yy_buf_size;
  154.  
  155.     /* Number of characters read into yy_ch_buf, not including EOB
  156.      * characters.
  157.      */
  158.     int yy_n_chars;
  159.  
  160.     /* Whether we "own" the buffer - i.e., we know we created it,
  161.      * and can realloc() it to grow it, and should free() it to
  162.      * delete it.
  163.      */
  164.     int yy_is_our_buffer;
  165.  
  166.     /* Whether this is an "interactive" input source; if so, and
  167.      * if we're using stdio for input, then we want to use getc()
  168.      * instead of fread(), to make sure we stop fetching input after
  169.      * each newline.
  170.      */
  171.     int yy_is_interactive;
  172.  
  173.     /* Whether we're considered to be at the beginning of a line.
  174.      * If so, '^' rules will be active on the next match, otherwise
  175.      * not.
  176.      */
  177.     int yy_at_bol;
  178.  
  179.     /* Whether to try to fill the input buffer when we reach the
  180.      * end of it.
  181.      */
  182.     int yy_fill_buffer;
  183.  
  184.     int yy_buffer_status;
  185. #define YY_BUFFER_NEW 0
  186. #define YY_BUFFER_NORMAL 1
  187.     /* When an EOF's been seen but there's still some text to process
  188.      * then we mark the buffer as YY_EOF_PENDING, to indicate that we
  189.      * shouldn't try reading from the input source any more.  We might
  190.      * still have a bunch of tokens to match, though, because of
  191.      * possible backing-up.
  192.      *
  193.      * When we actually see the EOF, we change the status to "new"
  194.      * (via yyrestart()), so that the user can continue scanning by
  195.      * just pointing yyin at a new input file.
  196.      */
  197. #define YY_BUFFER_EOF_PENDING 2
  198.     };
  199.  
  200. static YY_BUFFER_STATE yy_current_buffer = 0;
  201.  
  202. /* We provide macros for accessing buffer states in case in the
  203.  * future we want to put the buffer states in a more general
  204.  * "scanner state".
  205.  */
  206. #define YY_CURRENT_BUFFER yy_current_buffer
  207.  
  208.  
  209. /* yy_hold_char holds the character lost when yytext is formed. */
  210. static char yy_hold_char;
  211.  
  212. static int yy_n_chars;        /* number of characters read into yy_ch_buf */
  213.  
  214.  
  215. int yyleng;
  216.  
  217. /* Points to current character in buffer. */
  218. static char *yy_c_buf_p = (char *) 0;
  219. static int yy_init = 1;        /* whether we need to initialize */
  220. static int yy_start = 0;    /* start state number */
  221.  
  222. /* Flag which is used to allow yywrap()'s to do buffer switches
  223.  * instead of setting up a fresh yyin.  A bit of a hack ...
  224.  */
  225. static int yy_did_buffer_switch_on_eof;
  226.  
  227. void yyrestart YY_PROTO(( FILE *input_file ));
  228.  
  229. void yy_switch_to_buffer YY_PROTO(( YY_BUFFER_STATE new_buffer ));
  230. void yy_load_buffer_state YY_PROTO(( void ));
  231. YY_BUFFER_STATE yy_create_buffer YY_PROTO(( FILE *file, int size ));
  232. void yy_delete_buffer YY_PROTO(( YY_BUFFER_STATE b ));
  233. void yy_init_buffer YY_PROTO(( YY_BUFFER_STATE b, FILE *file ));
  234. void yy_flush_buffer YY_PROTO(( YY_BUFFER_STATE b ));
  235. #define YY_FLUSH_BUFFER yy_flush_buffer( yy_current_buffer )
  236.  
  237. YY_BUFFER_STATE yy_scan_buffer YY_PROTO(( char *base, yy_size_t size ));
  238. YY_BUFFER_STATE yy_scan_string YY_PROTO(( yyconst char *str ));
  239. YY_BUFFER_STATE yy_scan_bytes YY_PROTO(( yyconst char *bytes, int len ));
  240.  
  241. static void *yy_flex_alloc YY_PROTO(( yy_size_t ));
  242. static void *yy_flex_realloc YY_PROTO(( void *, yy_size_t ));
  243. static void yy_flex_free YY_PROTO(( void * ));
  244.  
  245. #define yy_new_buffer yy_create_buffer
  246.  
  247. #define yy_set_interactive(is_interactive) \
  248.     { \
  249.     if ( ! yy_current_buffer ) \
  250.         yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); \
  251.     yy_current_buffer->yy_is_interactive = is_interactive; \
  252.     }
  253.  
  254. #define yy_set_bol(at_bol) \
  255.     { \
  256.     if ( ! yy_current_buffer ) \
  257.         yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); \
  258.     yy_current_buffer->yy_at_bol = at_bol; \
  259.     }
  260.  
  261. #define YY_AT_BOL() (yy_current_buffer->yy_at_bol)
  262.  
  263. typedef unsigned char YY_CHAR;
  264. FILE *yyin = (FILE *) 0, *yyout = (FILE *) 0;
  265. typedef int yy_state_type;
  266. extern char *yytext;
  267. #define yytext_ptr yytext
  268.  
  269. static yy_state_type yy_get_previous_state YY_PROTO(( void ));
  270. static yy_state_type yy_try_NUL_trans YY_PROTO(( yy_state_type current_state ));
  271. static int yy_get_next_buffer YY_PROTO(( void ));
  272. static void yy_fatal_error YY_PROTO(( yyconst char msg[] ));
  273.  
  274. /* Done after the current pattern has been matched and before the
  275.  * corresponding action - sets up yytext.
  276.  */
  277. #define YY_DO_BEFORE_ACTION \
  278.     yytext_ptr = yy_bp; \
  279.     yyleng = (int) (yy_cp - yy_bp); \
  280.     yy_hold_char = *yy_cp; \
  281.     *yy_cp = '\0'; \
  282.     yy_c_buf_p = yy_cp;
  283.  
  284. #define YY_NUM_RULES 58
  285. #define YY_END_OF_BUFFER 59
  286. static yyconst short int yy_accept[216] =
  287.     {   0,
  288.        56,   56,   59,   57,   56,   56,   17,    6,    7,   57,
  289.         9,   16,   57,   55,    4,    2,    1,    1,    3,    5,
  290.        57,   12,   14,   57,   57,   57,   57,   57,   57,   57,
  291.        57,   57,   57,   57,   10,   57,   13,    8,   56,    0,
  292.        25,    0,    0,    1,    1,   15,   28,    0,   27,    0,
  293.         0,   19,    0,    0,    0,    0,    0,    0,    0,    0,
  294.         0,    0,    0,    0,   25,    0,   18,    0,    0,    0,
  295.         0,    0,    0,    0,    0,   24,    0,   23,    0,    0,
  296.         0,    0,    0,    0,    0,   26,    0,    0,    0,    0,
  297.         0,    0,    0,    0,    0,    0,   30,    0,    0,    0,
  298.  
  299.         0,    0,    0,    0,   11,    0,    0,    0,    0,    0,
  300.         0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
  301.         0,    0,    0,    0,    0,   36,    0,    0,    0,    0,
  302.         0,    0,    0,   32,   54,   40,    0,    0,   20,    0,
  303.         0,    0,    0,   34,    0,    0,    0,    0,    0,    0,
  304.         0,    0,    0,    0,    0,    0,    0,    0,   31,    0,
  305.         0,    0,   48,    0,    0,    0,    0,    0,   50,    0,
  306.         0,    0,    0,    0,   52,    0,   21,    0,   41,   22,
  307.         0,    0,    0,   42,   35,   38,    0,   37,    0,    0,
  308.         0,    0,    0,    0,    0,    0,   46,    0,    0,    0,
  309.  
  310.        51,    0,   45,    0,   53,   33,   49,    0,    0,   39,
  311.        44,   29,   47,   43,    0
  312.     } ;
  313.  
  314. static yyconst int yy_ec[256] =
  315.     {   0,
  316.         1,    1,    1,    1,    1,    1,    1,    1,    2,    3,
  317.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  318.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  319.         1,    2,    1,    4,    5,    6,    7,    8,    9,   10,
  320.        11,    1,   12,   13,   14,   15,    1,   16,   16,   17,
  321.        17,   17,   17,   16,   16,   16,   16,   18,   19,   20,
  322.         1,    1,   21,   22,   23,   24,   25,   26,   27,   28,
  323.        29,   30,   31,    1,    1,   32,   33,   34,   35,   36,
  324.         1,   37,   38,   39,   40,   41,   42,   43,   44,    1,
  325.         1,    1,    1,   45,    1,    1,    1,    1,    1,    1,
  326.  
  327.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  328.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  329.         1,    1,    1,    1,    1,   46,    1,    1,    1,    1,
  330.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  331.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  332.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  333.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  334.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  335.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  336.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  337.  
  338.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  339.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  340.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  341.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  342.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  343.         1,    1,    1,    1,    1
  344.     } ;
  345.  
  346. static yyconst int yy_meta[47] =
  347.     {   0,
  348.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  349.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  350.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  351.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  352.         1,    1,    1,    1,    1,    1
  353.     } ;
  354.  
  355. static yyconst short int yy_base[216] =
  356.     {   0,
  357.         0,    0,  310,  311,   45,   47,  311,  311,  311,   49,
  358.       311,  311,   51,  311,  311,  311,   53,   55,  311,  311,
  359.       295,  311,  311,  284,  263,   38,  271,  270,  273,  274,
  360.        51,  270,  274,   23,  255,  262,  311,  311,   72,   77,
  361.        79,   81,   88,   85,  104,  311,  311,  260,  311,  265,
  362.       263,  106,  258,  253,  259,  253,  248,  251,  262,   80,
  363.       265,  263,  256,  254,  112,  114,  311,  245,  258,   58,
  364.       120,  250,  252,  253,  244,  311,  239,  311,  254,  250,
  365.       241,  247,  233,  235,  233,  311,  256,  230,  245,  227,
  366.       130,  232,  238,  237,  132,  226,  231,  223,  134,  222,
  367.  
  368.       226,  225,  226,  226,  311,  112,  224,  222,  138,  216,
  369.       223,  228,  211,  142,  213,  119,  214,  220,  145,  212,
  370.       205,  205,  219,  122,  215,  210,  152,  206,  205,  215,
  371.       202,  149,  198,  196,  311,  311,  200,  204,  158,  203,
  372.       191,  206,  201,  311,  193,  185,  191,  160,  190,  194,
  373.       165,  183,  187,  171,  182,  191,  186,  187,  311,  168,
  374.       180,  173,  311,  175,  176,  182,  154,  181,  311,  176,
  375.       184,  172,  172,  174,  311,  169,  311,  166,  311,  311,
  376.       186,  158,  170,  164,  311,  311,  158,  311,  200,  156,
  377.       129,  130,  123,  105,   98,   85,  311,   78,   76,   71,
  378.  
  379.       311,   59,  311,   47,  311,  311,  311,   35,   30,  311,
  380.       311,  311,  311,  311,  311
  381.     } ;
  382.  
  383. static yyconst short int yy_def[216] =
  384.     {   0,
  385.       215,    1,  215,  215,  215,  215,  215,  215,  215,  215,
  386.       215,  215,  215,  215,  215,  215,  215,  215,  215,  215,
  387.       215,  215,  215,  215,  215,  215,  215,  215,  215,  215,
  388.       215,  215,  215,  215,  215,  215,  215,  215,  215,  215,
  389.       215,  215,  215,  215,  215,  215,  215,  215,  215,  215,
  390.       215,  215,  215,  215,  215,  215,  215,  215,  215,  215,
  391.       215,  215,  215,  215,  215,  215,  215,  215,  215,  215,
  392.       215,  215,  215,  215,  215,  215,  215,  215,  215,  215,
  393.       215,  215,  215,  215,  215,  215,  215,  215,  215,  215,
  394.       215,  215,  215,  215,  215,  215,  215,  215,  215,  215,
  395.  
  396.       215,  215,  215,  215,  215,  215,  215,  215,  215,  215,
  397.       215,  215,  215,  215,  215,  215,  215,  215,  215,  215,
  398.       215,  215,  215,  215,  215,  215,  215,  215,  215,  215,
  399.       215,  215,  215,  215,  215,  215,  215,  215,  215,  215,
  400.       215,  215,  215,  215,  215,  215,  215,  215,  215,  215,
  401.       215,  215,  215,  215,  215,  215,  215,  215,  215,  215,
  402.       215,  215,  215,  215,  215,  215,  215,  215,  215,  215,
  403.       215,  215,  215,  215,  215,  215,  215,  215,  215,  215,
  404.       215,  215,  215,  215,  215,  215,  215,  215,  215,  215,
  405.       215,  215,  215,  215,  215,  215,  215,  215,  215,  215,
  406.  
  407.       215,  215,  215,  215,  215,  215,  215,  215,  215,  215,
  408.       215,  215,  215,  215,    0
  409.     } ;
  410.  
  411. static yyconst short int yy_nxt[358] =
  412.     {   0,
  413.         4,    5,    6,    7,    8,    9,   10,   11,   12,   13,
  414.         4,   14,   15,    4,   16,   17,   18,   19,   20,   21,
  415.        22,   23,   24,   25,   26,   27,    4,   28,   29,    4,
  416.        30,    4,    4,   31,    4,   32,   33,   34,    4,    4,
  417.        35,   36,    4,    4,   37,   38,   39,   39,   39,   39,
  418.        40,   40,   42,   42,   44,   44,   45,   45,  214,   56,
  419.        50,   61,   62,  213,   41,   41,   43,   43,   44,   44,
  420.        44,   44,   51,   39,   39,  212,   46,   57,   40,   40,
  421.        65,   65,   42,   42,   91,   58,   44,   44,   92,   66,
  422.        66,  211,   41,   41,   65,   65,   43,   43,   67,  210,
  423.  
  424.        44,   44,   80,   66,   66,   45,   45,   71,   71,  209,
  425.        81,  208,   82,   65,   65,   66,   66,   83,   84,   44,
  426.        44,   71,   71,  207,   67,   46,  206,   65,   65,   66,
  427.        66,  109,  109,  114,  114,  119,  119,  205,  127,  109,
  428.       109,   72,  128,  114,  114,  136,  119,  119,  144,  137,
  429.       154,  154,  145,  148,  148,   72,  204,  110,  203,  160,
  430.       160,  148,  148,  202,  120,  110,  171,  171,  121,  160,
  431.       160,  115,  154,  154,  181,  181,  155,  189,  189,  121,
  432.       186,  115,  149,  161,  187,  171,  171,  181,  181,  201,
  433.       149,  200,  172,  161,  199,  173,  197,  196,  155,  195,
  434.  
  435.       198,  189,  189,  194,  193,  192,  190,  182,  191,  188,
  436.       185,  172,  184,  183,  180,  179,  178,  177,  176,  175,
  437.       182,  174,  170,  169,  168,  167,  166,  165,  164,  163,
  438.       190,  162,  159,  158,  157,  156,  153,  152,  151,  150,
  439.       147,  146,  143,  142,  141,  140,  139,  138,  135,  134,
  440.       133,  132,  131,  130,  129,  126,  125,  124,  123,  122,
  441.       118,  117,  116,  113,  112,  111,  108,  107,  106,  105,
  442.       104,  103,  102,  101,  100,   99,   98,   97,   96,   95,
  443.        94,   93,   90,   89,   88,   87,   86,   85,   79,   78,
  444.        77,   76,   75,   74,   73,   70,   69,   68,   64,   63,
  445.  
  446.        60,   59,   55,   54,   53,   52,   49,   48,   47,  215,
  447.         3,  215,  215,  215,  215,  215,  215,  215,  215,  215,
  448.       215,  215,  215,  215,  215,  215,  215,  215,  215,  215,
  449.       215,  215,  215,  215,  215,  215,  215,  215,  215,  215,
  450.       215,  215,  215,  215,  215,  215,  215,  215,  215,  215,
  451.       215,  215,  215,  215,  215,  215,  215
  452.     } ;
  453.  
  454. static yyconst short int yy_chk[358] =
  455.     {   0,
  456.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  457.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  458.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  459.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  460.         1,    1,    1,    1,    1,    1,    5,    5,    6,    6,
  461.        10,   10,   13,   13,   17,   17,   18,   18,  209,   31,
  462.        26,   34,   34,  208,   10,   10,   13,   13,   17,   17,
  463.        18,   18,   26,   39,   39,  204,   18,   31,   40,   40,
  464.        41,   41,   42,   42,   70,   31,   44,   44,   70,   43,
  465.        43,  202,   40,   40,   41,   41,   42,   42,   43,  200,
  466.  
  467.        44,   44,   60,   43,   43,   45,   45,   52,   52,  199,
  468.        60,  198,   60,   65,   65,   66,   66,   60,   60,   45,
  469.        45,   71,   71,  196,   66,   45,  195,   65,   65,   66,
  470.        66,   91,   91,   95,   95,   99,   99,  194,  106,  109,
  471.       109,   52,  106,  114,  114,  116,  119,  119,  124,  116,
  472.       132,  132,  124,  127,  127,   71,  193,   91,  192,  139,
  473.       139,  148,  148,  191,   99,  109,  151,  151,   99,  160,
  474.       160,   95,  154,  154,  162,  162,  132,  170,  170,  119,
  475.       167,  114,  127,  139,  167,  171,  171,  181,  181,  190,
  476.       148,  187,  151,  160,  184,  151,  183,  182,  154,  178,
  477.  
  478.       183,  189,  189,  176,  174,  173,  170,  162,  172,  168,
  479.       166,  171,  165,  164,  161,  158,  157,  156,  155,  153,
  480.       181,  152,  150,  149,  147,  146,  145,  143,  142,  141,
  481.       189,  140,  138,  137,  134,  133,  131,  130,  129,  128,
  482.       126,  125,  123,  122,  121,  120,  118,  117,  115,  113,
  483.       112,  111,  110,  108,  107,  104,  103,  102,  101,  100,
  484.        98,   97,   96,   94,   93,   92,   90,   89,   88,   87,
  485.        85,   84,   83,   82,   81,   80,   79,   77,   75,   74,
  486.        73,   72,   69,   68,   64,   63,   62,   61,   59,   58,
  487.        57,   56,   55,   54,   53,   51,   50,   48,   36,   35,
  488.  
  489.        33,   32,   30,   29,   28,   27,   25,   24,   21,    3,
  490.       215,  215,  215,  215,  215,  215,  215,  215,  215,  215,
  491.       215,  215,  215,  215,  215,  215,  215,  215,  215,  215,
  492.       215,  215,  215,  215,  215,  215,  215,  215,  215,  215,
  493.       215,  215,  215,  215,  215,  215,  215,  215,  215,  215,
  494.       215,  215,  215,  215,  215,  215,  215
  495.     } ;
  496.  
  497. static yy_state_type yy_last_accepting_state;
  498. static char *yy_last_accepting_cpos;
  499.  
  500. /* The intent behind this definition is that it'll catch
  501.  * any uses of REJECT which flex missed.
  502.  */
  503. #define REJECT reject_used_but_not_detected
  504. #define yymore() yymore_used_but_not_detected
  505. #define YY_MORE_ADJ 0
  506. char *yytext;
  507. #line 1 "lexer.l"
  508. #define INITIAL 0
  509. #line 2 "lexer.l"
  510. /*
  511.  * NAME
  512.  *   lexer.l -- source for the C-INTERCAL lexical analyzer.
  513.  *
  514. LICENSE TERMS
  515.     Copyright (C) 1996 Eric S. Raymond 
  516.  
  517.     This program is free software; you can redistribute it and/or modify
  518.     it under the terms of the GNU General Public License as published by
  519.     the Free Software Foundation; either version 2 of the License, or
  520.     (at your option) any later version.
  521.  
  522.     This program is distributed in the hope that it will be useful,
  523.     but WITHOUT ANY WARRANTY; without even the implied warranty of
  524.     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  525.     GNU General Public License for more details.
  526.  
  527.     You should have received a copy of the GNU General Public License
  528.     along with this program; if not, write to the Free Software
  529.     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  530. */
  531. #include <stdio.h>
  532. #include <stdlib.h>
  533. #include <ctype.h>
  534. #include <string.h>
  535. #include <memory.h>
  536. #include "ick.h"
  537. #include "y.tab.h"
  538. #include "lose.h"
  539.  
  540. #define YY_NO_UNPUT
  541.  
  542. #ifndef yywrap
  543. static int yywrap(void)
  544. {
  545.     return 1;
  546. }
  547. #endif /* yywrap */
  548.  
  549. #ifdef YYLINENO_BY_HAND
  550. int     yylineno = 1;
  551. #endif /* YYLINENO_BY_HAND */
  552.  
  553. #ifdef MAIN
  554. YYSTYPE    yylval;
  555. #endif /* MAIN */
  556.  
  557. char *textlines[MAXLINES];
  558. int politesse = 0;
  559. int stbeginline = 0;
  560.  
  561. #ifdef FLEX_SCANNER
  562. static char linebuf[YY_BUF_SIZE];
  563. #else /* FLEX_SCANNER */
  564. static char linebuf[YYLMAX];
  565. #endif /* FLEX_SCANNER */
  566.  
  567. static char *lineptr = linebuf;
  568.  
  569. bool re_send_token = FALSE;
  570.  
  571. int lexer(void);
  572. static int myatoi(char *text);
  573.  
  574. #define SETLINENO                    \
  575.     {if (stbeginline == 0)    stbeginline = yylineno;    \
  576.      else if (stbeginline < 0)    stbeginline = 0;}
  577.  
  578. /*
  579.  * The spectacular ugliness of INTERCAL syntax requires that the lexical
  580.  * analyzer have two levels. One, embedded in the getc() function, handles
  581.  * logical-line continuation and the ! abbrev, and stashes each logical
  582.  * line away in a buffer accessible to the code generator (this is necessary
  583.  * for the * construct to be interpreted correctly). The upper level is
  584.  * generated by lex(1) and does normal tokenizing.
  585.  */
  586.  
  587. #undef getc(s)
  588. int getc(FILE *fp)
  589. {
  590.     extern FILE* yyin;
  591.  
  592.     static bool bangflag = FALSE;
  593.     static bool backflag = FALSE;
  594.  
  595.     if (bangflag)
  596.     {
  597.     bangflag = FALSE;
  598.     /*    *lineptr++ = '!'; */
  599.     return('.');
  600.     }
  601.     else if (backflag)    /* converting ctrl-H (backspace) to two chars "^H" */
  602.     {
  603.     backflag = FALSE;
  604.     /*    *lineptr++ = '\010'; */
  605.     return('H');
  606.     }
  607.     else
  608.     {
  609.     int c = fgetc(fp);
  610.  
  611.     if (feof(yyin))
  612.     {
  613.         *lineptr = '\0';
  614.         return(EOF);
  615.     }
  616. #ifdef BACKSLASH_CONTINUATION
  617.     else if (c == '\\')
  618.     {
  619.         do {
  620.         c = fgetc(fp);
  621. #ifdef    YYLINENO_BY_HAND
  622.         if( c == '\n' ) yylineno++;
  623. #endif    /* YYLINENO_BY_HAND */
  624.         } while
  625.         (c != '\\' && isspace(c));
  626.     }
  627. #endif    /* BACKSLASH_CONTINUATION */
  628.     if (c == '!')
  629.     {
  630.         *lineptr++ = '!';
  631.         bangflag = TRUE;
  632.         return(c = '\'');
  633.     }
  634.     else if (c == '\010')    /* convert ctrl-H (backspace) to
  635.                    two chars "^" and "H" so lex can take it */
  636.     {
  637.         *lineptr++ = '\010';
  638.         backflag = TRUE;
  639.         return(c = '^');
  640.     }
  641.     else if (c == '\n')
  642.     {
  643.         *lineptr = '\0';
  644.         lineptr = linebuf;
  645.         textlines[yylineno] = strcpy((char *)malloc(1+strlen(linebuf)),linebuf);
  646. #ifdef YYLINENO_BY_HAND
  647.         yylineno++;
  648. #endif /* YYLINENO_BY_HAND */
  649.         return('\n');
  650.     }
  651.     else
  652.     {
  653. #ifdef ACCEPT_LOWERCASE
  654.         if (islower(c))
  655.         c = toupper(c);
  656. #endif /* ACCEPT_LOWERCASE */
  657.         return(*lineptr++ = c);
  658.     }
  659.     }
  660. }
  661.  
  662. /* replace YY_INPUT so that it uses our getc function. */
  663. #undef YY_INPUT
  664. #define YY_INPUT(buf,result,max_size) \
  665.     { \
  666.       int c = getc(yyin); \
  667.       if (c == EOF) { \
  668.         if (ferror(yyin)) \
  669.           YY_FATAL_ERROR("input in flex scanner failed"); \
  670.         result = YY_NULL; \
  671.       } else { \
  672.         buf[0] = c; \
  673.         result = 1; \
  674.       } \
  675.     }
  676.  
  677. #line 678 "lexyy.c"
  678.  
  679. /* Macros after this point can all be overridden by user definitions in
  680.  * section 1.
  681.  */
  682.  
  683. #ifndef YY_SKIP_YYWRAP
  684. #ifdef __cplusplus
  685. extern "C" int yywrap YY_PROTO(( void ));
  686. #else
  687. extern int yywrap YY_PROTO(( void ));
  688. #endif
  689. #endif
  690.  
  691. #ifndef YY_NO_UNPUT
  692. static void yyunput YY_PROTO(( int c, char *buf_ptr ));
  693. #endif
  694.  
  695. #ifndef yytext_ptr
  696. static void yy_flex_strncpy YY_PROTO(( char *, yyconst char *, int ));
  697. #endif
  698.  
  699. #ifndef YY_NO_INPUT
  700. #ifdef __cplusplus
  701. static int yyinput YY_PROTO(( void ));
  702. #else
  703. static int input YY_PROTO(( void ));
  704. #endif
  705. #endif
  706.  
  707. #if YY_STACK_USED
  708. static int yy_start_stack_ptr = 0;
  709. static int yy_start_stack_depth = 0;
  710. static int *yy_start_stack = 0;
  711. #ifndef YY_NO_PUSH_STATE
  712. static void yy_push_state YY_PROTO(( int new_state ));
  713. #endif
  714. #ifndef YY_NO_POP_STATE
  715. static void yy_pop_state YY_PROTO(( void ));
  716. #endif
  717. #ifndef YY_NO_TOP_STATE
  718. static int yy_top_state YY_PROTO(( void ));
  719. #endif
  720.  
  721. #else
  722. #define YY_NO_PUSH_STATE 1
  723. #define YY_NO_POP_STATE 1
  724. #define YY_NO_TOP_STATE 1
  725. #endif
  726.  
  727. #ifdef YY_MALLOC_DECL
  728. YY_MALLOC_DECL
  729. #else
  730. #if __STDC__
  731. #ifndef __cplusplus
  732. #include <stdlib.h>
  733. #endif
  734. #else
  735. /* Just try to get by without declaring the routines.  This will fail
  736.  * miserably on non-ANSI systems for which sizeof(size_t) != sizeof(int)
  737.  * or sizeof(void*) != sizeof(int).
  738.  */
  739. #endif
  740. #endif
  741.  
  742. /* Amount of stuff to slurp up with each read. */
  743. #ifndef YY_READ_BUF_SIZE
  744. #define YY_READ_BUF_SIZE 8192
  745. #endif
  746.  
  747. /* Copy whatever the last rule matched to the standard output. */
  748.  
  749. #ifndef ECHO
  750. /* This used to be an fputs(), but since the string might contain NUL's,
  751.  * we now use fwrite().
  752.  */
  753. #define ECHO (void) fwrite( yytext, yyleng, 1, yyout )
  754. #endif
  755.  
  756. /* Gets input and stuffs it into "buf".  number of characters read, or YY_NULL,
  757.  * is returned in "result".
  758.  */
  759. #ifndef YY_INPUT
  760. #define YY_INPUT(buf,result,max_size) \
  761.     if ( yy_current_buffer->yy_is_interactive ) \
  762.         { \
  763.         int c = '*', n; \
  764.         for ( n = 0; n < max_size && \
  765.                  (c = getc( yyin )) != EOF && c != '\n'; ++n ) \
  766.             buf[n] = (char) c; \
  767.         if ( c == '\n' ) \
  768.             buf[n++] = (char) c; \
  769.         if ( c == EOF && ferror( yyin ) ) \
  770.             YY_FATAL_ERROR( "input in flex scanner failed" ); \
  771.         result = n; \
  772.         } \
  773.     else if ( ((result = fread( buf, 1, max_size, yyin )) == 0) \
  774.           && ferror( yyin ) ) \
  775.         YY_FATAL_ERROR( "input in flex scanner failed" );
  776. #endif
  777.  
  778. /* No semi-colon after return; correct usage is to write "yyterminate();" -
  779.  * we don't want an extra ';' after the "return" because that will cause
  780.  * some compilers to complain about unreachable statements.
  781.  */
  782. #ifndef yyterminate
  783. #define yyterminate() return YY_NULL
  784. #endif
  785.  
  786. /* Number of entries by which start-condition stack grows. */
  787. #ifndef YY_START_STACK_INCR
  788. #define YY_START_STACK_INCR 25
  789. #endif
  790.  
  791. /* Report a fatal error. */
  792. #ifndef YY_FATAL_ERROR
  793. #define YY_FATAL_ERROR(msg) yy_fatal_error( msg )
  794. #endif
  795.  
  796. /* Default declaration of generated scanner - a define so the user can
  797.  * easily add parameters.
  798.  */
  799. #ifndef YY_DECL
  800. #define YY_DECL int yylex YY_PROTO(( void ))
  801. #endif
  802.  
  803. /* Code executed at the beginning of each rule, after yytext and yyleng
  804.  * have been set up.
  805.  */
  806. #ifndef YY_USER_ACTION
  807. #define YY_USER_ACTION
  808. #endif
  809.  
  810. /* Code executed at the end of each rule. */
  811. #ifndef YY_BREAK
  812. #define YY_BREAK break;
  813. #endif
  814.  
  815. #define YY_RULE_SETUP \
  816.     YY_USER_ACTION
  817.  
  818. YY_DECL
  819.     {
  820.     register yy_state_type yy_current_state;
  821.     register char *yy_cp, *yy_bp;
  822.     register int yy_act;
  823.  
  824. #line 174 "lexer.l"
  825.  
  826.  
  827. #line 828 "lexyy.c"
  828.  
  829.     if ( yy_init )
  830.         {
  831.         yy_init = 0;
  832.  
  833. #ifdef YY_USER_INIT
  834.         YY_USER_INIT;
  835. #endif
  836.  
  837.         if ( ! yy_start )
  838.             yy_start = 1;    /* first start state */
  839.  
  840.         if ( ! yyin )
  841.             yyin = stdin;
  842.  
  843.         if ( ! yyout )
  844.             yyout = stdout;
  845.  
  846.         if ( ! yy_current_buffer )
  847.             yy_current_buffer =
  848.                 yy_create_buffer( yyin, YY_BUF_SIZE );
  849.  
  850.         yy_load_buffer_state();
  851.         }
  852.  
  853.     while ( 1 )        /* loops until end-of-file is reached */
  854.         {
  855.         yy_cp = yy_c_buf_p;
  856.  
  857.         /* Support of yytext. */
  858.         *yy_cp = yy_hold_char;
  859.  
  860.         /* yy_bp points to the position in yy_ch_buf of the start of
  861.          * the current run.
  862.          */
  863.         yy_bp = yy_cp;
  864.  
  865.         yy_current_state = yy_start;
  866. yy_match:
  867.         do
  868.             {
  869.             register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)];
  870.             if ( yy_accept[yy_current_state] )
  871.                 {
  872.                 yy_last_accepting_state = yy_current_state;
  873.                 yy_last_accepting_cpos = yy_cp;
  874.                 }
  875.             while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
  876.                 {
  877.                 yy_current_state = (int) yy_def[yy_current_state];
  878.                 if ( yy_current_state >= 216 )
  879.                     yy_c = yy_meta[(unsigned int) yy_c];
  880.                 }
  881.             yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
  882.             ++yy_cp;
  883.             }
  884.         while ( yy_base[yy_current_state] != 311 );
  885.  
  886. yy_find_action:
  887.         yy_act = yy_accept[yy_current_state];
  888.         if ( yy_act == 0 )
  889.             { /* have to back up */
  890.             yy_cp = yy_last_accepting_cpos;
  891.             yy_current_state = yy_last_accepting_state;
  892.             yy_act = yy_accept[yy_current_state];
  893.             }
  894.  
  895.         YY_DO_BEFORE_ACTION;
  896.  
  897.  
  898. do_action:    /* This label is used only to access EOF actions. */
  899.  
  900.  
  901.         switch ( yy_act )
  902.     { /* beginning of action switch */
  903.             case 0: /* must back up */
  904.             /* undo the effects of YY_DO_BEFORE_ACTION */
  905.             *yy_cp = yy_hold_char;
  906.             yy_cp = yy_last_accepting_cpos;
  907.             yy_current_state = yy_last_accepting_state;
  908.             goto yy_find_action;
  909.  
  910. case 1:
  911. YY_RULE_SETUP
  912. #line 176 "lexer.l"
  913. {yylval.numval = myatoi(yytext); return(NUMBER);}
  914.     YY_BREAK
  915. case 2:
  916. YY_RULE_SETUP
  917. #line 177 "lexer.l"
  918. {return(ONESPOT);}
  919.     YY_BREAK
  920. case 3:
  921. YY_RULE_SETUP
  922. #line 178 "lexer.l"
  923. {return(TWOSPOT);}
  924.     YY_BREAK
  925. case 4:
  926. YY_RULE_SETUP
  927. #line 179 "lexer.l"
  928. {return(TAIL);}
  929.     YY_BREAK
  930. case 5:
  931. YY_RULE_SETUP
  932. #line 180 "lexer.l"
  933. {return(HYBRID);}
  934.     YY_BREAK
  935. case 6:
  936. YY_RULE_SETUP
  937. #line 181 "lexer.l"
  938. {return(MESH);}
  939.     YY_BREAK
  940. case 7:
  941. YY_RULE_SETUP
  942. #line 183 "lexer.l"
  943. {return(MINGLE);}
  944.     YY_BREAK
  945. case 8:
  946. YY_RULE_SETUP
  947. #line 184 "lexer.l"
  948. {return(SELECT);}
  949.     YY_BREAK
  950. case 9:
  951. YY_RULE_SETUP
  952. #line 186 "lexer.l"
  953. {yylval.numval = AND; return(UNARY);}
  954.     YY_BREAK
  955. case 10:
  956. YY_RULE_SETUP
  957. #line 187 "lexer.l"
  958. {yylval.numval = OR; return(UNARY);}
  959.     YY_BREAK
  960. case 11:
  961. #line 189 "lexer.l"
  962. case 12:
  963. YY_RULE_SETUP
  964. #line 189 "lexer.l"
  965. {yylval.numval = XOR; return(UNARY);}
  966.     YY_BREAK
  967. case 13:
  968. YY_RULE_SETUP
  969. #line 190 "lexer.l"
  970. {yylval.numval = FIN; return(UNARY);}
  971.     YY_BREAK
  972. case 14:
  973. YY_RULE_SETUP
  974. #line 191 "lexer.l"
  975. {yylval.numval = WHIRL; return(UNARY);}
  976.     YY_BREAK
  977. case 15:
  978. YY_RULE_SETUP
  979. #line 192 "lexer.l"
  980. {yylval.numval = WHIRL + myatoi(yytext) - 1; return(UNARY);}
  981.     YY_BREAK
  982. case 16:
  983. YY_RULE_SETUP
  984. #line 194 "lexer.l"
  985. {return(SPARK);}
  986.     YY_BREAK
  987. case 17:
  988. YY_RULE_SETUP
  989. #line 195 "lexer.l"
  990. {return(EARS);}
  991.     YY_BREAK
  992. case 18:
  993. YY_RULE_SETUP
  994. #line 197 "lexer.l"
  995. {SETLINENO; yylval.numval = myatoi(yytext); return(LABEL);}
  996.     YY_BREAK
  997. case 19:
  998. YY_RULE_SETUP
  999. #line 199 "lexer.l"
  1000. {SETLINENO; return(DO);}
  1001.     YY_BREAK
  1002. case 20:
  1003. YY_RULE_SETUP
  1004. #line 200 "lexer.l"
  1005. {SETLINENO; politesse++; return(DO);}
  1006.     YY_BREAK
  1007. case 21:
  1008. YY_RULE_SETUP
  1009. #line 201 "lexer.l"
  1010. {SETLINENO; politesse++; return(DO);}
  1011.     YY_BREAK
  1012. case 22:
  1013. YY_RULE_SETUP
  1014. #line 202 "lexer.l"
  1015. {SETLINENO; politesse++; return(DO);}
  1016.     YY_BREAK
  1017. case 23:
  1018. YY_RULE_SETUP
  1019. #line 203 "lexer.l"
  1020. {return(NOT);}
  1021.     YY_BREAK
  1022. case 24:
  1023. YY_RULE_SETUP
  1024. #line 204 "lexer.l"
  1025. {return(NOT);}
  1026.     YY_BREAK
  1027. case 25:
  1028. YY_RULE_SETUP
  1029. #line 206 "lexer.l"
  1030. {yylval.numval = myatoi(yytext);
  1031.                  if (yylval.numval && yylval.numval < 100)
  1032.            return(OHOHSEVEN);
  1033.          else
  1034.            lose(E017, yylineno, (char *)NULL);}
  1035.     YY_BREAK
  1036. case 26:
  1037. YY_RULE_SETUP
  1038. #line 211 "lexer.l"
  1039. {return(SUB);}
  1040.     YY_BREAK
  1041. case 27:
  1042. YY_RULE_SETUP
  1043. #line 212 "lexer.l"
  1044. {return(BY);}
  1045.     YY_BREAK
  1046. case 28:
  1047. YY_RULE_SETUP
  1048. #line 214 "lexer.l"
  1049. {return(GETS);}
  1050.     YY_BREAK
  1051. case 29:
  1052. YY_RULE_SETUP
  1053. #line 215 "lexer.l"
  1054. {yylval.numval = GETS; return(GERUND);}
  1055.     YY_BREAK
  1056. case 30:
  1057. YY_RULE_SETUP
  1058. #line 217 "lexer.l"
  1059. {stbeginline = 0; return(NEXT);}
  1060.     YY_BREAK
  1061. case 31:
  1062. YY_RULE_SETUP
  1063. #line 218 "lexer.l"
  1064. {yylval.numval = NEXT; return(GERUND);}
  1065.     YY_BREAK
  1066. case 32:
  1067. YY_RULE_SETUP
  1068. #line 219 "lexer.l"
  1069. {return(FORGET);}
  1070.     YY_BREAK
  1071. case 33:
  1072. YY_RULE_SETUP
  1073. #line 220 "lexer.l"
  1074. {yylval.numval = FORGET; return(GERUND);}
  1075.     YY_BREAK
  1076. case 34:
  1077. YY_RULE_SETUP
  1078. #line 221 "lexer.l"
  1079. {return(RESUME);}
  1080.     YY_BREAK
  1081. case 35:
  1082. YY_RULE_SETUP
  1083. #line 222 "lexer.l"
  1084. {yylval.numval = RESUME; return(GERUND);}
  1085.     YY_BREAK
  1086. case 36:
  1087. YY_RULE_SETUP
  1088. #line 223 "lexer.l"
  1089. {return(STASH);}
  1090.     YY_BREAK
  1091. case 37:
  1092. YY_RULE_SETUP
  1093. #line 224 "lexer.l"
  1094. {yylval.numval = STASH; return(GERUND);}
  1095.     YY_BREAK
  1096. case 38:
  1097. YY_RULE_SETUP
  1098. #line 225 "lexer.l"
  1099. {return(RETRIEVE);}
  1100.     YY_BREAK
  1101. case 39:
  1102. YY_RULE_SETUP
  1103. #line 226 "lexer.l"
  1104. {yylval.numval = RETRIEVE; return(GERUND);}
  1105.     YY_BREAK
  1106. case 40:
  1107. YY_RULE_SETUP
  1108. #line 227 "lexer.l"
  1109. {return(IGNORE);}
  1110.     YY_BREAK
  1111. case 41:
  1112. YY_RULE_SETUP
  1113. #line 228 "lexer.l"
  1114. {yylval.numval = IGNORE; return(GERUND);}
  1115.     YY_BREAK
  1116. case 42:
  1117. YY_RULE_SETUP
  1118. #line 229 "lexer.l"
  1119. {return(REMEMBER);}
  1120.     YY_BREAK
  1121. case 43:
  1122. YY_RULE_SETUP
  1123. #line 230 "lexer.l"
  1124. {yylval.numval = REMEMBER; return(GERUND);}
  1125.     YY_BREAK
  1126. case 44:
  1127. YY_RULE_SETUP
  1128. #line 231 "lexer.l"
  1129. {return(ABSTAIN);}
  1130.     YY_BREAK
  1131. case 45:
  1132. YY_RULE_SETUP
  1133. #line 232 "lexer.l"
  1134. {yylval.numval = ABSTAIN; return(GERUND);}
  1135.     YY_BREAK
  1136. case 46:
  1137. YY_RULE_SETUP
  1138. #line 233 "lexer.l"
  1139. {return(REINSTATE);}
  1140.     YY_BREAK
  1141. case 47:
  1142. YY_RULE_SETUP
  1143. #line 234 "lexer.l"
  1144. {yylval.numval = REINSTATE; return(GERUND);}
  1145.     YY_BREAK
  1146. case 48:
  1147. YY_RULE_SETUP
  1148. #line 235 "lexer.l"
  1149. {return(READ_OUT);}
  1150.     YY_BREAK
  1151. case 49:
  1152. YY_RULE_SETUP
  1153. #line 236 "lexer.l"
  1154. {yylval.numval = READ_OUT; return(GERUND);}
  1155.     YY_BREAK
  1156. case 50:
  1157. YY_RULE_SETUP
  1158. #line 237 "lexer.l"
  1159. {return(WRITE_IN);}
  1160.     YY_BREAK
  1161. case 51:
  1162. YY_RULE_SETUP
  1163. #line 238 "lexer.l"
  1164. {yylval.numval = WRITE_IN; return(GERUND);}
  1165.     YY_BREAK
  1166. case 52:
  1167. YY_RULE_SETUP
  1168. #line 239 "lexer.l"
  1169. {stbeginline = -stbeginline; return(COME_FROM);}
  1170.     YY_BREAK
  1171. case 53:
  1172. YY_RULE_SETUP
  1173. #line 240 "lexer.l"
  1174. {yylval.numval = COME_FROM; return(GERUND);}
  1175.     YY_BREAK
  1176. case 54:
  1177. YY_RULE_SETUP
  1178. #line 241 "lexer.l"
  1179. {return(GIVE_UP);}
  1180.     YY_BREAK
  1181. case 55:
  1182. YY_RULE_SETUP
  1183. #line 243 "lexer.l"
  1184. {return(INTERSECTION);}
  1185.     YY_BREAK
  1186. case 56:
  1187. YY_RULE_SETUP
  1188. #line 245 "lexer.l"
  1189. ;
  1190.     YY_BREAK
  1191. case 57:
  1192. YY_RULE_SETUP
  1193. #line 246 "lexer.l"
  1194. {yylval.numval = yytext[0]; return(BADCHAR);}
  1195.     YY_BREAK
  1196. case 58:
  1197. YY_RULE_SETUP
  1198. #line 249 "lexer.l"
  1199. ECHO;
  1200.     YY_BREAK
  1201. #line 1202 "lexyy.c"
  1202. case YY_STATE_EOF(INITIAL):
  1203.     yyterminate();
  1204.  
  1205.     case YY_END_OF_BUFFER:
  1206.         {
  1207.         /* Amount of text matched not including the EOB char. */
  1208.         int yy_amount_of_matched_text = (int) (yy_cp - yytext_ptr) - 1;
  1209.  
  1210.         /* Undo the effects of YY_DO_BEFORE_ACTION. */
  1211.         *yy_cp = yy_hold_char;
  1212.  
  1213.         if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_NEW )
  1214.             {
  1215.             /* We're scanning a new file or input source.  It's
  1216.              * possible that this happened because the user
  1217.              * just pointed yyin at a new source and called
  1218.              * yylex().  If so, then we have to assure
  1219.              * consistency between yy_current_buffer and our
  1220.              * globals.  Here is the right place to do so, because
  1221.              * this is the first action (other than possibly a
  1222.              * back-up) that will match for the new input source.
  1223.              */
  1224.             yy_n_chars = yy_current_buffer->yy_n_chars;
  1225.             yy_current_buffer->yy_input_file = yyin;
  1226.             yy_current_buffer->yy_buffer_status = YY_BUFFER_NORMAL;
  1227.             }
  1228.  
  1229.         /* Note that here we test for yy_c_buf_p "<=" to the position
  1230.          * of the first EOB in the buffer, since yy_c_buf_p will
  1231.          * already have been incremented past the NUL character
  1232.          * (since all states make transitions on EOB to the
  1233.          * end-of-buffer state).  Contrast this with the test
  1234.          * in input().
  1235.          */
  1236.         if ( yy_c_buf_p <= &yy_current_buffer->yy_ch_buf[yy_n_chars] )
  1237.             { /* This was really a NUL. */
  1238.             yy_state_type yy_next_state;
  1239.  
  1240.             yy_c_buf_p = yytext_ptr + yy_amount_of_matched_text;
  1241.  
  1242.             yy_current_state = yy_get_previous_state();
  1243.  
  1244.             /* Okay, we're now positioned to make the NUL
  1245.              * transition.  We couldn't have
  1246.              * yy_get_previous_state() go ahead and do it
  1247.              * for us because it doesn't know how to deal
  1248.              * with the possibility of jamming (and we don't
  1249.              * want to build jamming into it because then it
  1250.              * will run more slowly).
  1251.              */
  1252.  
  1253.             yy_next_state = yy_try_NUL_trans( yy_current_state );
  1254.  
  1255.             yy_bp = yytext_ptr + YY_MORE_ADJ;
  1256.  
  1257.             if ( yy_next_state )
  1258.                 {
  1259.                 /* Consume the NUL. */
  1260.                 yy_cp = ++yy_c_buf_p;
  1261.                 yy_current_state = yy_next_state;
  1262.                 goto yy_match;
  1263.                 }
  1264.  
  1265.             else
  1266.                 {
  1267.                 yy_cp = yy_c_buf_p;
  1268.                 goto yy_find_action;
  1269.                 }
  1270.             }
  1271.  
  1272.         else switch ( yy_get_next_buffer() )
  1273.             {
  1274.             case EOB_ACT_END_OF_FILE:
  1275.                 {
  1276.                 yy_did_buffer_switch_on_eof = 0;
  1277.  
  1278.                 if ( yywrap() )
  1279.                     {
  1280.                     /* Note: because we've taken care in
  1281.                      * yy_get_next_buffer() to have set up
  1282.                      * yytext, we can now set up
  1283.                      * yy_c_buf_p so that if some total
  1284.                      * hoser (like flex itself) wants to
  1285.                      * call the scanner after we return the
  1286.                      * YY_NULL, it'll still work - another
  1287.                      * YY_NULL will get returned.
  1288.                      */
  1289.                     yy_c_buf_p = yytext_ptr + YY_MORE_ADJ;
  1290.  
  1291.                     yy_act = YY_STATE_EOF(YY_START);
  1292.                     goto do_action;
  1293.                     }
  1294.  
  1295.                 else
  1296.                     {
  1297.                     if ( ! yy_did_buffer_switch_on_eof )
  1298.                         YY_NEW_FILE;
  1299.                     }
  1300.                 break;
  1301.                 }
  1302.  
  1303.             case EOB_ACT_CONTINUE_SCAN:
  1304.                 yy_c_buf_p =
  1305.                     yytext_ptr + yy_amount_of_matched_text;
  1306.  
  1307.                 yy_current_state = yy_get_previous_state();
  1308.  
  1309.                 yy_cp = yy_c_buf_p;
  1310.                 yy_bp = yytext_ptr + YY_MORE_ADJ;
  1311.                 goto yy_match;
  1312.  
  1313.             case EOB_ACT_LAST_MATCH:
  1314.                 yy_c_buf_p =
  1315.                 &yy_current_buffer->yy_ch_buf[yy_n_chars];
  1316.  
  1317.                 yy_current_state = yy_get_previous_state();
  1318.  
  1319.                 yy_cp = yy_c_buf_p;
  1320.                 yy_bp = yytext_ptr + YY_MORE_ADJ;
  1321.                 goto yy_find_action;
  1322.             }
  1323.         break;
  1324.         }
  1325.  
  1326.     default:
  1327.         YY_FATAL_ERROR(
  1328.             "fatal flex scanner internal error--no action found" );
  1329.     } /* end of action switch */
  1330.         } /* end of scanning one token */
  1331.     } /* end of yylex */
  1332.  
  1333.  
  1334. /* yy_get_next_buffer - try to read in a new buffer
  1335.  *
  1336.  * Returns a code representing an action:
  1337.  *    EOB_ACT_LAST_MATCH -
  1338.  *    EOB_ACT_CONTINUE_SCAN - continue scanning from current position
  1339.  *    EOB_ACT_END_OF_FILE - end of file
  1340.  */
  1341.  
  1342. static int yy_get_next_buffer()
  1343.     {
  1344.     register char *dest = yy_current_buffer->yy_ch_buf;
  1345.     register char *source = yytext_ptr;
  1346.     register int number_to_move, i;
  1347.     int ret_val;
  1348.  
  1349.     if ( yy_c_buf_p > &yy_current_buffer->yy_ch_buf[yy_n_chars + 1] )
  1350.         YY_FATAL_ERROR(
  1351.         "fatal flex scanner internal error--end of buffer missed" );
  1352.  
  1353.     if ( yy_current_buffer->yy_fill_buffer == 0 )
  1354.         { /* Don't try to fill the buffer, so this is an EOF. */
  1355.         if ( yy_c_buf_p - yytext_ptr - YY_MORE_ADJ == 1 )
  1356.             {
  1357.             /* We matched a singled characater, the EOB, so
  1358.              * treat this as a final EOF.
  1359.              */
  1360.             return EOB_ACT_END_OF_FILE;
  1361.             }
  1362.  
  1363.         else
  1364.             {
  1365.             /* We matched some text prior to the EOB, first
  1366.              * process it.
  1367.              */
  1368.             return EOB_ACT_LAST_MATCH;
  1369.             }
  1370.         }
  1371.  
  1372.     /* Try to read more data. */
  1373.  
  1374.     /* First move last chars to start of buffer. */
  1375.     number_to_move = (int) (yy_c_buf_p - yytext_ptr) - 1;
  1376.  
  1377.     for ( i = 0; i < number_to_move; ++i )
  1378.         *(dest++) = *(source++);
  1379.  
  1380.     if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_EOF_PENDING )
  1381.         /* don't do the read, it's not guaranteed to return an EOF,
  1382.          * just force an EOF
  1383.          */
  1384.         yy_n_chars = 0;
  1385.  
  1386.     else
  1387.         {
  1388.         int num_to_read =
  1389.             yy_current_buffer->yy_buf_size - number_to_move - 1;
  1390.  
  1391.         while ( num_to_read <= 0 )
  1392.             { /* Not enough room in the buffer - grow it. */
  1393. #ifdef YY_USES_REJECT
  1394.             YY_FATAL_ERROR(
  1395. "input buffer overflow, can't enlarge buffer because scanner uses REJECT" );
  1396. #else
  1397.  
  1398.             /* just a shorter name for the current buffer */
  1399.             YY_BUFFER_STATE b = yy_current_buffer;
  1400.  
  1401.             int yy_c_buf_p_offset =
  1402.                 (int) (yy_c_buf_p - b->yy_ch_buf);
  1403.  
  1404.             if ( b->yy_is_our_buffer )
  1405.                 {
  1406.                 int new_size = b->yy_buf_size * 2;
  1407.  
  1408.                 if ( new_size <= 0 )
  1409.                     b->yy_buf_size += b->yy_buf_size / 8;
  1410.                 else
  1411.                     b->yy_buf_size *= 2;
  1412.  
  1413.                 b->yy_ch_buf = (char *)
  1414.                     /* Include room in for 2 EOB chars. */
  1415.                     yy_flex_realloc( (void *) b->yy_ch_buf,
  1416.                              b->yy_buf_size + 2 );
  1417.                 }
  1418.             else
  1419.                 /* Can't grow it, we don't own it. */
  1420.                 b->yy_ch_buf = 0;
  1421.  
  1422.             if ( ! b->yy_ch_buf )
  1423.                 YY_FATAL_ERROR(
  1424.                 "fatal error - scanner input buffer overflow" );
  1425.  
  1426.             yy_c_buf_p = &b->yy_ch_buf[yy_c_buf_p_offset];
  1427.  
  1428.             num_to_read = yy_current_buffer->yy_buf_size -
  1429.                         number_to_move - 1;
  1430. #endif
  1431.             }
  1432.  
  1433.         if ( num_to_read > YY_READ_BUF_SIZE )
  1434.             num_to_read = YY_READ_BUF_SIZE;
  1435.  
  1436.         /* Read in more data. */
  1437.         YY_INPUT( (&yy_current_buffer->yy_ch_buf[number_to_move]),
  1438.             yy_n_chars, num_to_read );
  1439.         }
  1440.  
  1441.     if ( yy_n_chars == 0 )
  1442.         {
  1443.         if ( number_to_move == YY_MORE_ADJ )
  1444.             {
  1445.             ret_val = EOB_ACT_END_OF_FILE;
  1446.             yyrestart( yyin );
  1447.             }
  1448.  
  1449.         else
  1450.             {
  1451.             ret_val = EOB_ACT_LAST_MATCH;
  1452.             yy_current_buffer->yy_buffer_status =
  1453.                 YY_BUFFER_EOF_PENDING;
  1454.             }
  1455.         }
  1456.  
  1457.     else
  1458.         ret_val = EOB_ACT_CONTINUE_SCAN;
  1459.  
  1460.     yy_n_chars += number_to_move;
  1461.     yy_current_buffer->yy_ch_buf[yy_n_chars] = YY_END_OF_BUFFER_CHAR;
  1462.     yy_current_buffer->yy_ch_buf[yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR;
  1463.  
  1464.     yytext_ptr = &yy_current_buffer->yy_ch_buf[0];
  1465.  
  1466.     return ret_val;
  1467.     }
  1468.  
  1469.  
  1470. /* yy_get_previous_state - get the state just before the EOB char was reached */
  1471.  
  1472. static yy_state_type yy_get_previous_state()
  1473.     {
  1474.     register yy_state_type yy_current_state;
  1475.     register char *yy_cp;
  1476.  
  1477.     yy_current_state = yy_start;
  1478.  
  1479.     for ( yy_cp = yytext_ptr + YY_MORE_ADJ; yy_cp < yy_c_buf_p; ++yy_cp )
  1480.         {
  1481.         register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
  1482.         if ( yy_accept[yy_current_state] )
  1483.             {
  1484.             yy_last_accepting_state = yy_current_state;
  1485.             yy_last_accepting_cpos = yy_cp;
  1486.             }
  1487.         while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
  1488.             {
  1489.             yy_current_state = (int) yy_def[yy_current_state];
  1490.             if ( yy_current_state >= 216 )
  1491.                 yy_c = yy_meta[(unsigned int) yy_c];
  1492.             }
  1493.         yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
  1494.         }
  1495.  
  1496.     return yy_current_state;
  1497.     }
  1498.  
  1499.  
  1500. /* yy_try_NUL_trans - try to make a transition on the NUL character
  1501.  *
  1502.  * synopsis
  1503.  *    next_state = yy_try_NUL_trans( current_state );
  1504.  */
  1505.  
  1506. #ifdef YY_USE_PROTOS
  1507. static yy_state_type yy_try_NUL_trans( yy_state_type yy_current_state )
  1508. #else
  1509. static yy_state_type yy_try_NUL_trans( yy_current_state )
  1510. yy_state_type yy_current_state;
  1511. #endif
  1512.     {
  1513.     register int yy_is_jam;
  1514.     register char *yy_cp = yy_c_buf_p;
  1515.  
  1516.     register YY_CHAR yy_c = 1;
  1517.     if ( yy_accept[yy_current_state] )
  1518.         {
  1519.         yy_last_accepting_state = yy_current_state;
  1520.         yy_last_accepting_cpos = yy_cp;
  1521.         }
  1522.     while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
  1523.         {
  1524.         yy_current_state = (int) yy_def[yy_current_state];
  1525.         if ( yy_current_state >= 216 )
  1526.             yy_c = yy_meta[(unsigned int) yy_c];
  1527.         }
  1528.     yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
  1529.     yy_is_jam = (yy_current_state == 215);
  1530.  
  1531.     return yy_is_jam ? 0 : yy_current_state;
  1532.     }
  1533.  
  1534.  
  1535. #ifndef YY_NO_UNPUT
  1536. #ifdef YY_USE_PROTOS
  1537. static void yyunput( int c, register char *yy_bp )
  1538. #else
  1539. static void yyunput( c, yy_bp )
  1540. int c;
  1541. register char *yy_bp;
  1542. #endif
  1543.     {
  1544.     register char *yy_cp = yy_c_buf_p;
  1545.  
  1546.     /* undo effects of setting up yytext */
  1547.     *yy_cp = yy_hold_char;
  1548.  
  1549.     if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )
  1550.         { /* need to shift things up to make room */
  1551.         /* +2 for EOB chars. */
  1552.         register int number_to_move = yy_n_chars + 2;
  1553.         register char *dest = &yy_current_buffer->yy_ch_buf[
  1554.                     yy_current_buffer->yy_buf_size + 2];
  1555.         register char *source =
  1556.                 &yy_current_buffer->yy_ch_buf[number_to_move];
  1557.  
  1558.         while ( source > yy_current_buffer->yy_ch_buf )
  1559.             *--dest = *--source;
  1560.  
  1561.         yy_cp += (int) (dest - source);
  1562.         yy_bp += (int) (dest - source);
  1563.         yy_n_chars = yy_current_buffer->yy_buf_size;
  1564.  
  1565.         if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )
  1566.             YY_FATAL_ERROR( "flex scanner push-back overflow" );
  1567.         }
  1568.  
  1569.     *--yy_cp = (char) c;
  1570.  
  1571.  
  1572.     yytext_ptr = yy_bp;
  1573.     yy_hold_char = *yy_cp;
  1574.     yy_c_buf_p = yy_cp;
  1575.     }
  1576. #endif    /* ifndef YY_NO_UNPUT */
  1577.  
  1578.  
  1579. #ifdef __cplusplus
  1580. static int yyinput()
  1581. #else
  1582. static int input()
  1583. #endif
  1584.     {
  1585.     int c;
  1586.  
  1587.     *yy_c_buf_p = yy_hold_char;
  1588.  
  1589.     if ( *yy_c_buf_p == YY_END_OF_BUFFER_CHAR )
  1590.         {
  1591.         /* yy_c_buf_p now points to the character we want to return.
  1592.          * If this occurs *before* the EOB characters, then it's a
  1593.          * valid NUL; if not, then we've hit the end of the buffer.
  1594.          */
  1595.         if ( yy_c_buf_p < &yy_current_buffer->yy_ch_buf[yy_n_chars] )
  1596.             /* This was really a NUL. */
  1597.             *yy_c_buf_p = '\0';
  1598.  
  1599.         else
  1600.             { /* need more input */
  1601.             yytext_ptr = yy_c_buf_p;
  1602.             ++yy_c_buf_p;
  1603.  
  1604.             switch ( yy_get_next_buffer() )
  1605.                 {
  1606.                 case EOB_ACT_END_OF_FILE:
  1607.                     {
  1608.                     if ( yywrap() )
  1609.                         {
  1610.                         yy_c_buf_p =
  1611.                         yytext_ptr + YY_MORE_ADJ;
  1612.                         return EOF;
  1613.                         }
  1614.  
  1615.                     if ( ! yy_did_buffer_switch_on_eof )
  1616.                         YY_NEW_FILE;
  1617. #ifdef __cplusplus
  1618.                     return yyinput();
  1619. #else
  1620.                     return input();
  1621. #endif
  1622.                     }
  1623.  
  1624.                 case EOB_ACT_CONTINUE_SCAN:
  1625.                     yy_c_buf_p = yytext_ptr + YY_MORE_ADJ;
  1626.                     break;
  1627.  
  1628.                 case EOB_ACT_LAST_MATCH:
  1629. #ifdef __cplusplus
  1630.                     YY_FATAL_ERROR(
  1631.                     "unexpected last match in yyinput()" );
  1632. #else
  1633.                     YY_FATAL_ERROR(
  1634.                     "unexpected last match in input()" );
  1635. #endif
  1636.                 }
  1637.             }
  1638.         }
  1639.  
  1640.     c = *(unsigned char *) yy_c_buf_p;    /* cast for 8-bit char's */
  1641.     *yy_c_buf_p = '\0';    /* preserve yytext */
  1642.     yy_hold_char = *++yy_c_buf_p;
  1643.  
  1644.  
  1645.     return c;
  1646.     }
  1647.  
  1648.  
  1649. #ifdef YY_USE_PROTOS
  1650. void yyrestart( FILE *input_file )
  1651. #else
  1652. void yyrestart( input_file )
  1653. FILE *input_file;
  1654. #endif
  1655.     {
  1656.     if ( ! yy_current_buffer )
  1657.         yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE );
  1658.  
  1659.     yy_init_buffer( yy_current_buffer, input_file );
  1660.     yy_load_buffer_state();
  1661.     }
  1662.  
  1663.  
  1664. #ifdef YY_USE_PROTOS
  1665. void yy_switch_to_buffer( YY_BUFFER_STATE new_buffer )
  1666. #else
  1667. void yy_switch_to_buffer( new_buffer )
  1668. YY_BUFFER_STATE new_buffer;
  1669. #endif
  1670.     {
  1671.     if ( yy_current_buffer == new_buffer )
  1672.         return;
  1673.  
  1674.     if ( yy_current_buffer )
  1675.         {
  1676.         /* Flush out information for old buffer. */
  1677.         *yy_c_buf_p = yy_hold_char;
  1678.         yy_current_buffer->yy_buf_pos = yy_c_buf_p;
  1679.         yy_current_buffer->yy_n_chars = yy_n_chars;
  1680.         }
  1681.  
  1682.     yy_current_buffer = new_buffer;
  1683.     yy_load_buffer_state();
  1684.  
  1685.     /* We don't actually know whether we did this switch during
  1686.      * EOF (yywrap()) processing, but the only time this flag
  1687.      * is looked at is after yywrap() is called, so it's safe
  1688.      * to go ahead and always set it.
  1689.      */
  1690.     yy_did_buffer_switch_on_eof = 1;
  1691.     }
  1692.  
  1693.  
  1694. #ifdef YY_USE_PROTOS
  1695. void yy_load_buffer_state( void )
  1696. #else
  1697. void yy_load_buffer_state()
  1698. #endif
  1699.     {
  1700.     yy_n_chars = yy_current_buffer->yy_n_chars;
  1701.     yytext_ptr = yy_c_buf_p = yy_current_buffer->yy_buf_pos;
  1702.     yyin = yy_current_buffer->yy_input_file;
  1703.     yy_hold_char = *yy_c_buf_p;
  1704.     }
  1705.  
  1706.  
  1707. #ifdef YY_USE_PROTOS
  1708. YY_BUFFER_STATE yy_create_buffer( FILE *file, int size )
  1709. #else
  1710. YY_BUFFER_STATE yy_create_buffer( file, size )
  1711. FILE *file;
  1712. int size;
  1713. #endif
  1714.     {
  1715.     YY_BUFFER_STATE b;
  1716.  
  1717.     b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) );
  1718.     if ( ! b )
  1719.         YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
  1720.  
  1721.     b->yy_buf_size = size;
  1722.  
  1723.     /* yy_ch_buf has to be 2 characters longer than the size given because
  1724.      * we need to put in 2 end-of-buffer characters.
  1725.      */
  1726.     b->yy_ch_buf = (char *) yy_flex_alloc( b->yy_buf_size + 2 );
  1727.     if ( ! b->yy_ch_buf )
  1728.         YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
  1729.  
  1730.     b->yy_is_our_buffer = 1;
  1731.  
  1732.     yy_init_buffer( b, file );
  1733.  
  1734.     return b;
  1735.     }
  1736.  
  1737.  
  1738. #ifdef YY_USE_PROTOS
  1739. void yy_delete_buffer( YY_BUFFER_STATE b )
  1740. #else
  1741. void yy_delete_buffer( b )
  1742. YY_BUFFER_STATE b;
  1743. #endif
  1744.     {
  1745.     if ( ! b )
  1746.         return;
  1747.  
  1748.     if ( b == yy_current_buffer )
  1749.         yy_current_buffer = (YY_BUFFER_STATE) 0;
  1750.  
  1751.     if ( b->yy_is_our_buffer )
  1752.         yy_flex_free( (void *) b->yy_ch_buf );
  1753.  
  1754.     yy_flex_free( (void *) b );
  1755.     }
  1756.  
  1757.  
  1758. #ifndef YY_ALWAYS_INTERACTIVE
  1759. #ifndef YY_NEVER_INTERACTIVE
  1760. extern int isatty YY_PROTO(( int ));
  1761. #endif
  1762. #endif
  1763.  
  1764. #ifdef YY_USE_PROTOS
  1765. void yy_init_buffer( YY_BUFFER_STATE b, FILE *file )
  1766. #else
  1767. void yy_init_buffer( b, file )
  1768. YY_BUFFER_STATE b;
  1769. FILE *file;
  1770. #endif
  1771.  
  1772.  
  1773.     {
  1774.     yy_flush_buffer( b );
  1775.  
  1776.     b->yy_input_file = file;
  1777.     b->yy_fill_buffer = 1;
  1778.  
  1779. #if YY_ALWAYS_INTERACTIVE
  1780.     b->yy_is_interactive = 1;
  1781. #else
  1782. #if YY_NEVER_INTERACTIVE
  1783.     b->yy_is_interactive = 0;
  1784. #else
  1785.     b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0;
  1786. #endif
  1787. #endif
  1788.     }
  1789.  
  1790.  
  1791. #ifdef YY_USE_PROTOS
  1792. void yy_flush_buffer( YY_BUFFER_STATE b )
  1793. #else
  1794. void yy_flush_buffer( b )
  1795. YY_BUFFER_STATE b;
  1796. #endif
  1797.  
  1798.     {
  1799.     b->yy_n_chars = 0;
  1800.  
  1801.     /* We always need two end-of-buffer characters.  The first causes
  1802.      * a transition to the end-of-buffer state.  The second causes
  1803.      * a jam in that state.
  1804.      */
  1805.     b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
  1806.     b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
  1807.  
  1808.     b->yy_buf_pos = &b->yy_ch_buf[0];
  1809.  
  1810.     b->yy_at_bol = 1;
  1811.     b->yy_buffer_status = YY_BUFFER_NEW;
  1812.  
  1813.     if ( b == yy_current_buffer )
  1814.         yy_load_buffer_state();
  1815.     }
  1816.  
  1817.  
  1818. #ifndef YY_NO_SCAN_BUFFER
  1819. #ifdef YY_USE_PROTOS
  1820. YY_BUFFER_STATE yy_scan_buffer( char *base, yy_size_t size )
  1821. #else
  1822. YY_BUFFER_STATE yy_scan_buffer( base, size )
  1823. char *base;
  1824. yy_size_t size;
  1825. #endif
  1826.     {
  1827.     YY_BUFFER_STATE b;
  1828.  
  1829.     if ( size < 2 ||
  1830.          base[size-2] != YY_END_OF_BUFFER_CHAR ||
  1831.          base[size-1] != YY_END_OF_BUFFER_CHAR )
  1832.         /* They forgot to leave room for the EOB's. */
  1833.         return 0;
  1834.  
  1835.     b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) );
  1836.     if ( ! b )
  1837.         YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" );
  1838.  
  1839.     b->yy_buf_size = size - 2;    /* "- 2" to take care of EOB's */
  1840.     b->yy_buf_pos = b->yy_ch_buf = base;
  1841.     b->yy_is_our_buffer = 0;
  1842.     b->yy_input_file = 0;
  1843.     b->yy_n_chars = b->yy_buf_size;
  1844.     b->yy_is_interactive = 0;
  1845.     b->yy_at_bol = 1;
  1846.     b->yy_fill_buffer = 0;
  1847.     b->yy_buffer_status = YY_BUFFER_NEW;
  1848.  
  1849.     yy_switch_to_buffer( b );
  1850.  
  1851.     return b;
  1852.     }
  1853. #endif
  1854.  
  1855.  
  1856. #ifndef YY_NO_SCAN_STRING
  1857. #ifdef YY_USE_PROTOS
  1858. YY_BUFFER_STATE yy_scan_string( yyconst char *str )
  1859. #else
  1860. YY_BUFFER_STATE yy_scan_string( str )
  1861. yyconst char *str;
  1862. #endif
  1863.     {
  1864.     int len;
  1865.     for ( len = 0; str[len]; ++len )
  1866.         ;
  1867.  
  1868.     return yy_scan_bytes( str, len );
  1869.     }
  1870. #endif
  1871.  
  1872.  
  1873. #ifndef YY_NO_SCAN_BYTES
  1874. #ifdef YY_USE_PROTOS
  1875. YY_BUFFER_STATE yy_scan_bytes( yyconst char *bytes, int len )
  1876. #else
  1877. YY_BUFFER_STATE yy_scan_bytes( bytes, len )
  1878. yyconst char *bytes;
  1879. int len;
  1880. #endif
  1881.     {
  1882.     YY_BUFFER_STATE b;
  1883.     char *buf;
  1884.     yy_size_t n;
  1885.     int i;
  1886.  
  1887.     /* Get memory for full buffer, including space for trailing EOB's. */
  1888.     n = len + 2;
  1889.     buf = (char *) yy_flex_alloc( n );
  1890.     if ( ! buf )
  1891.         YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" );
  1892.  
  1893.     for ( i = 0; i < len; ++i )
  1894.         buf[i] = bytes[i];
  1895.  
  1896.     buf[len] = buf[len+1] = YY_END_OF_BUFFER_CHAR;
  1897.  
  1898.     b = yy_scan_buffer( buf, n );
  1899.     if ( ! b )
  1900.         YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" );
  1901.  
  1902.     /* It's okay to grow etc. this buffer, and we should throw it
  1903.      * away when we're done.
  1904.      */
  1905.     b->yy_is_our_buffer = 1;
  1906.  
  1907.     return b;
  1908.     }
  1909. #endif
  1910.  
  1911.  
  1912. #ifndef YY_NO_PUSH_STATE
  1913. #ifdef YY_USE_PROTOS
  1914. static void yy_push_state( int new_state )
  1915. #else
  1916. static void yy_push_state( new_state )
  1917. int new_state;
  1918. #endif
  1919.     {
  1920.     if ( yy_start_stack_ptr >= yy_start_stack_depth )
  1921.         {
  1922.         yy_size_t new_size;
  1923.  
  1924.         yy_start_stack_depth += YY_START_STACK_INCR;
  1925.         new_size = yy_start_stack_depth * sizeof( int );
  1926.  
  1927.         if ( ! yy_start_stack )
  1928.             yy_start_stack = (int *) yy_flex_alloc( new_size );
  1929.  
  1930.         else
  1931.             yy_start_stack = (int *) yy_flex_realloc(
  1932.                     (void *) yy_start_stack, new_size );
  1933.  
  1934.         if ( ! yy_start_stack )
  1935.             YY_FATAL_ERROR(
  1936.             "out of memory expanding start-condition stack" );
  1937.         }
  1938.  
  1939.     yy_start_stack[yy_start_stack_ptr++] = YY_START;
  1940.  
  1941.     BEGIN(new_state);
  1942.     }
  1943. #endif
  1944.  
  1945.  
  1946. #ifndef YY_NO_POP_STATE
  1947. static void yy_pop_state()
  1948.     {
  1949.     if ( --yy_start_stack_ptr < 0 )
  1950.         YY_FATAL_ERROR( "start-condition stack underflow" );
  1951.  
  1952.     BEGIN(yy_start_stack[yy_start_stack_ptr]);
  1953.     }
  1954. #endif
  1955.  
  1956.  
  1957. #ifndef YY_NO_TOP_STATE
  1958. static int yy_top_state()
  1959.     {
  1960.     return yy_start_stack[yy_start_stack_ptr - 1];
  1961.     }
  1962. #endif
  1963.  
  1964. #ifndef YY_EXIT_FAILURE
  1965. #define YY_EXIT_FAILURE 2
  1966. #endif
  1967.  
  1968. #ifdef YY_USE_PROTOS
  1969. static void yy_fatal_error( yyconst char msg[] )
  1970. #else
  1971. static void yy_fatal_error( msg )
  1972. char msg[];
  1973. #endif
  1974.     {
  1975.     (void) fprintf( stderr, "%s\n", msg );
  1976.     exit( YY_EXIT_FAILURE );
  1977.     }
  1978.  
  1979.  
  1980.  
  1981. /* Redefine yyless() so it works in section 3 code. */
  1982.  
  1983. #undef yyless
  1984. #define yyless(n) \
  1985.     do \
  1986.         { \
  1987.         /* Undo effects of setting up yytext. */ \
  1988.         yytext[yyleng] = yy_hold_char; \
  1989.         yy_c_buf_p = yytext + n - YY_MORE_ADJ; \
  1990.         yy_hold_char = *yy_c_buf_p; \
  1991.         *yy_c_buf_p = '\0'; \
  1992.         yyleng = n; \
  1993.         } \
  1994.     while ( 0 )
  1995.  
  1996.  
  1997. /* Internal utility routines. */
  1998.  
  1999. #ifndef yytext_ptr
  2000. #ifdef YY_USE_PROTOS
  2001. static void yy_flex_strncpy( char *s1, yyconst char *s2, int n )
  2002. #else
  2003. static void yy_flex_strncpy( s1, s2, n )
  2004. char *s1;
  2005. yyconst char *s2;
  2006. int n;
  2007. #endif
  2008.     {
  2009.     register int i;
  2010.     for ( i = 0; i < n; ++i )
  2011.         s1[i] = s2[i];
  2012.     }
  2013. #endif
  2014.  
  2015.  
  2016. #ifdef YY_USE_PROTOS
  2017. static void *yy_flex_alloc( yy_size_t size )
  2018. #else
  2019. static void *yy_flex_alloc( size )
  2020. yy_size_t size;
  2021. #endif
  2022.     {
  2023.     return (void *) malloc( size );
  2024.     }
  2025.  
  2026. #ifdef YY_USE_PROTOS
  2027. static void *yy_flex_realloc( void *ptr, yy_size_t size )
  2028. #else
  2029. static void *yy_flex_realloc( ptr, size )
  2030. void *ptr;
  2031. yy_size_t size;
  2032. #endif
  2033.     {
  2034.     /* The cast to (char *) in the following accommodates both
  2035.      * implementations that use char* generic pointers, and those
  2036.      * that use void* generic pointers.  It works with the latter
  2037.      * because both ANSI C and C++ allow castless assignment from
  2038.      * any pointer type to void*, and deal with argument conversions
  2039.      * as though doing an assignment.
  2040.      */
  2041.     return (void *) realloc( (char *) ptr, size );
  2042.     }
  2043.  
  2044. #ifdef YY_USE_PROTOS
  2045. static void yy_flex_free( void *ptr )
  2046. #else
  2047. static void yy_flex_free( ptr )
  2048. void *ptr;
  2049. #endif
  2050.     {
  2051.     free( ptr );
  2052.     }
  2053.  
  2054. #if YY_MAIN
  2055. int main()
  2056.     {
  2057.     yylex();
  2058.     return 0;
  2059.     }
  2060. #endif
  2061. #line 249 "lexer.l"
  2062.  
  2063.  
  2064. int lexer(void)
  2065. {
  2066.     static int tok = BADCHAR;
  2067.  
  2068.     if (re_send_token)
  2069.     re_send_token = FALSE;
  2070.     else 
  2071.     {
  2072.     tok = yylex();
  2073. #ifdef YYDEBUG
  2074.     if (yydebug)
  2075.         (void) fprintf(stdout, "yylex: returning token %d\n", tok); 
  2076. #endif /* YYDEBUG */
  2077.     }
  2078.  
  2079. #ifdef YYDEBUG
  2080.     if (yydebug)
  2081.     (void) fprintf(stdout, "lexer: returning token %d\n", tok); 
  2082. #endif /* YYDEBUG */
  2083.     return(tok);
  2084. }
  2085.  
  2086. static int myatoi(char *text)
  2087. {
  2088. #define MAXTEXT 100
  2089.     static char buf[MAXTEXT];
  2090.     register int i;
  2091.  
  2092.     for(buf[i = 0] = '\0';*text && i < MAXTEXT;text++) {
  2093.     if(isdigit(*text)) {
  2094.         buf[i++] = *text;
  2095.     }
  2096.     }
  2097.     buf[i] = '\0';
  2098.     return atoi(buf);
  2099. }
  2100.  
  2101. void yyerror(char *errtype)
  2102. {
  2103. #ifdef MAIN
  2104.     (void) printf("lextest: lexer error: %s.\n", errtype);
  2105. #else /* MAIN */
  2106.     /* lose(E017, yylineno, (char *)NULL); */
  2107.     (void) errtype;
  2108. #endif /* MAIN */
  2109. }
  2110.  
  2111. #ifdef MAIN
  2112. int main(void)
  2113. {
  2114.     int    t;
  2115.  
  2116.     while ((t = yylex()) > 0)
  2117.     {
  2118.         (void) printf("%03d %09d\n", t, yylval.numval);
  2119.         yylval.numval = 0;
  2120.     }
  2121.     return 0;
  2122. }
  2123. #endif /* MAIN */
  2124.