home *** CD-ROM | disk | FTP | other *** search
/ rtsi.com / 2014.01.www.rtsi.com.tar / www.rtsi.com / OS9 / OSK / GRAPHICS / rayshade.lzh / input_lex.c < prev    next >
Text File  |  1990-09-29  |  42KB  |  1,465 lines
  1. /* A lexical scanner generated by flex */
  2.  
  3. /* scanner skeleton version:
  4.  * $Header: /usr/fsys/odin/a/vern/flex/RCS/flex.skel,v 2.16 90/08/03 14:09:36 vern Exp $
  5.  */
  6.  
  7. #define FLEX_SCANNER
  8.  
  9. #include <stdio.h>
  10.  
  11.  
  12. /* cfront 1.2 defines "c_plusplus" instead of "__cplusplus" */
  13. #ifdef c_plusplus
  14. #ifndef __cplusplus
  15. #define __cplusplus
  16. #endif
  17. #endif
  18.  
  19.  
  20. #ifdef __cplusplus
  21.  
  22. #include <stdlib.h>
  23. #include <osfcn.h>
  24.  
  25. /* use prototypes in function declarations */
  26. #define YY_USE_PROTOS
  27.  
  28. /* the "const" storage-class-modifier is valid */
  29. #define YY_USE_CONST
  30.  
  31. #else    /* ! __cplusplus */
  32.  
  33. #ifdef __STDC__
  34.  
  35. #ifdef __GNUC__
  36. #include <stddef.h>
  37. void *malloc( size_t );
  38. void free( void* );
  39. #else
  40. #include <stdlib.h>
  41. #endif    /* __GNUC__ */
  42.  
  43. #define YY_USE_PROTOS
  44. #define YY_USE_CONST
  45.  
  46. #endif    /* __STDC__ */
  47. #endif    /* ! __cplusplus */
  48.  
  49.  
  50. #ifdef __TURBOC__
  51. #define YY_USE_CONST
  52. #endif
  53.  
  54.  
  55. #ifndef YY_USE_CONST
  56. #define const
  57. #endif
  58.  
  59.  
  60. #ifdef YY_USE_PROTOS
  61. #define YY_PROTO(proto) proto
  62. #else
  63. #define YY_PROTO(proto) ()
  64. /* we can't get here if it's an ANSI C compiler, or a C++ compiler,
  65.  * so it's got to be a K&R compiler, and therefore there's no standard
  66.  * place from which to include these definitions
  67.  */
  68. char *malloc();
  69. int free();
  70. int read();
  71. #endif
  72.  
  73.  
  74. /* amount of stuff to slurp up with each read */
  75. #ifndef YY_READ_BUF_SIZE
  76. #define YY_READ_BUF_SIZE 8192
  77. #endif
  78.  
  79. /* returned upon end-of-file */
  80. #define YY_END_TOK 0
  81.  
  82. /* copy whatever the last rule matched to the standard output */
  83.  
  84. /* cast to (char *) is because for 8-bit chars, yytext is (unsigned char *) */
  85. /* this used to be an fputs(), but since the string might contain NUL's,
  86.  * we now use fwrite()
  87.  */
  88. #define ECHO (void) fwrite( (char *) yytext, yyleng, 1, yyout )
  89.  
  90. /* gets input and stuffs it into "buf".  number of characters read, or YY_NULL,
  91.  * is returned in "result".
  92.  */
  93. #define YY_INPUT(buf,result,max_size) \
  94.     if ( (result = read( fileno(yyin), (char *) buf, max_size )) < 0 ) \
  95.         YY_FATAL_ERROR( "read() in flex scanner failed" );
  96. #define YY_NULL 0
  97.  
  98. /* no semi-colon after return; correct usage is to write "yyterminate();" -
  99.  * we don't want an extra ';' after the "return" because that will cause
  100.  * some compilers to complain about unreachable statements.
  101.  */
  102. #define yyterminate() return ( YY_NULL )
  103.  
  104. /* report a fatal error */
  105.  
  106. /* The funky do-while is used to turn this macro definition into
  107.  * a single C statement (which needs a semi-colon terminator).
  108.  * This avoids problems with code like:
  109.  *
  110.  *     if ( something_happens )
  111.  *        YY_FATAL_ERROR( "oops, the something happened" );
  112.  *    else
  113.  *        everything_okay();
  114.  *
  115.  * Prior to using the do-while the compiler would get upset at the
  116.  * "else" because it interpreted the "if" statement as being all
  117.  * done when it reached the ';' after the YY_FATAL_ERROR() call.
  118.  */
  119.  
  120. #define YY_FATAL_ERROR(msg) \
  121.     do \
  122.         { \
  123.         (void) fputs( msg, stderr ); \
  124.         (void) putc( '\n', stderr ); \
  125.         exit( 1 ); \
  126.         } \
  127.     while ( 0 )
  128.  
  129. /* default yywrap function - always treat EOF as an EOF */
  130. #ifndef OSK
  131. #define yywrap() 1
  132. #endif
  133.  
  134. /* enter a start condition.  This macro really ought to take a parameter,
  135.  * but we do it the disgusting crufty way forced on us by the ()-less
  136.  * definition of BEGIN
  137.  */
  138. #define BEGIN yy_start = 1 + 2 *
  139.  
  140. /* action number for EOF rule of a given start state */
  141. #define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
  142.  
  143. /* special action meaning "start processing a new file" */
  144. #define YY_NEW_FILE \
  145.     do \
  146.         { \
  147.         yy_init_buffer( yy_current_buffer, yyin ); \
  148.         yy_load_buffer_state(); \
  149.         } \
  150.     while ( 0 )
  151.  
  152. /* default declaration of generated scanner - a define so the user can
  153.  * easily add parameters
  154.  */
  155. #define YY_DECL int yylex YY_PROTO(( void )) 
  156.  
  157. /* code executed at the end of each rule */
  158. #define YY_BREAK break;
  159.  
  160. #define YY_END_OF_BUFFER_CHAR 0
  161.  
  162. #ifndef YY_BUF_SIZE
  163. #define YY_BUF_SIZE (YY_READ_BUF_SIZE * 2) /* size of default input buffer */
  164. #endif
  165.  
  166. typedef struct yy_buffer_state *YY_BUFFER_STATE;
  167.  
  168. #define YY_CHAR char
  169. #define INITIAL 0
  170. /* input_lex.l                                    */
  171. /*                                        */
  172. /* Copyright (C) 1989, Craig E. Kolb                        */
  173. /*                                        */
  174. /* This software may be freely copied, modified, and redistributed,        */
  175. /* provided that this copyright notice is preserved on all copies.        */
  176. /*                                         */
  177. /* There is no warranty or other guarantee of fitness for this software,    */
  178. /* it is provided solely "as is".  Bug reports or fixes may be sent        */
  179. /* to the author, who may or may not act on them as he desires.            */
  180. /*                                        */
  181. /* You may not include this software in a program or other software product */
  182. /* without supplying the source, or without informing the end-user that the */
  183. /* source is available for no extra charge.                    */
  184. /*                                        */
  185. /* $Id: input_lex.l,v 3.0.1.4 90/03/07 21:26:29 craig Exp $ */
  186. #ifdef SYSV
  187. #include <string.h>
  188. #else
  189. #include <strings.h>
  190. #endif
  191. #include "typedefs.h"
  192. #include "y.tab.h"
  193. double atof();
  194. char *strsave();
  195.  
  196. /* done after the current pattern has been matched and before the
  197.  * corresponding action - sets up yytext
  198.  */
  199. #define YY_DO_BEFORE_ACTION \
  200.     yytext = yy_bp; \
  201.     yyleng = yy_cp - yy_bp; \
  202.     yy_hold_char = *yy_cp; \
  203.     *yy_cp = '\0'; \
  204.     yy_c_buf_p = yy_cp;
  205.  
  206. #define EOB_ACT_CONTINUE_SCAN 0
  207. #define EOB_ACT_END_OF_FILE 1
  208. #define EOB_ACT_LAST_MATCH 2
  209.  
  210. /* return all but the first 'n' matched characters back to the input stream */
  211. #define yyless(n) \
  212.     do \
  213.         { \
  214.         /* undo effects of setting up yytext */ \
  215.         *yy_cp = yy_hold_char; \
  216.         yy_c_buf_p = yy_cp = yy_bp + n; \
  217.         YY_DO_BEFORE_ACTION; /* set up yytext again */ \
  218.         } \
  219.     while ( 0 )
  220.  
  221. #define unput(c) yyunput( c, yytext )
  222.  
  223.  
  224. struct yy_buffer_state
  225.     {
  226.     FILE *yy_input_file;
  227.  
  228.     YY_CHAR *yy_ch_buf;        /* input buffer */
  229.     YY_CHAR *yy_buf_pos;    /* current position in input buffer */
  230.  
  231.     /* size of input buffer in bytes, not including room for EOB characters*/
  232.     int yy_buf_size;    
  233.  
  234.     /* number of characters read into yy_ch_buf, not including EOB characters */
  235.     int yy_n_chars;
  236.  
  237.     int yy_eof_status;        /* whether we've seen an EOF on this buffer */
  238. #define EOF_NOT_SEEN 0
  239.     /* "pending" happens when the EOF has been seen but there's still
  240.      * some text process
  241.      */
  242. #define EOF_PENDING 1
  243. #define EOF_DONE 2
  244.     };
  245.  
  246. static YY_BUFFER_STATE yy_current_buffer;
  247.  
  248. /* we provide macros for accessing buffer states in case in the
  249.  * future we want to put the buffer states in a more general
  250.  * "scanner state"
  251.  */
  252. #define YY_CURRENT_BUFFER yy_current_buffer
  253.  
  254.  
  255. /* yy_hold_char holds the character lost when yytext is formed */
  256. static YY_CHAR yy_hold_char;
  257.  
  258. static int yy_n_chars;        /* number of characters read into yy_ch_buf */
  259.  
  260.  
  261.  
  262. #ifndef YY_USER_ACTION
  263. #define YY_USER_ACTION
  264. #endif
  265.  
  266. #ifndef YY_USER_INIT
  267. #define YY_USER_INIT
  268. #endif
  269.  
  270. extern YY_CHAR *yytext;
  271. extern int yyleng;
  272. extern FILE *yyin, *yyout;
  273.  
  274. YY_CHAR *yytext;
  275. int yyleng;
  276. int yylineno = 1;
  277.  
  278. FILE *yyin = (FILE *) 0, *yyout = (FILE *) 0;
  279.  
  280. #define YY_END_OF_BUFFER 62
  281. typedef int yy_state_type;
  282. static const short int yy_accept[300] =
  283.     {   0,
  284.         0,    0,   62,   60,    1,    1,   60,   60,   55,   56,
  285.        55,   55,   55,   55,   55,   55,   55,   55,   55,   55,
  286.        55,   55,   55,   55,   55,   55,   55,   55,   55,    2,
  287.         0,   56,   58,    3,   55,   57,    0,   55,   55,   55,
  288.        55,   55,   55,   55,   55,   55,   55,   55,   55,   55,
  289.        55,   55,   55,   55,   55,   55,   55,   55,   55,   55,
  290.        55,   55,   55,   55,   55,   55,   55,   55,   55,   55,
  291.        55,   55,   55,   55,   53,   55,    0,   57,    0,    0,
  292.        59,   55,   55,   55,   55,    8,   55,   55,   55,   55,
  293.        55,   55,   55,   55,   55,   55,   21,   55,   24,   25,
  294.  
  295.        55,   55,   55,   55,   55,   55,   55,   55,   55,   55,
  296.        55,   55,   55,   55,   55,   55,   55,   55,   55,   55,
  297.        55,   55,   55,   55,   55,   55,   55,    0,   58,    0,
  298.         0,   57,   55,   55,   55,   55,    9,   55,   11,   55,
  299.        55,   55,   55,   55,   55,   55,   55,   20,   55,   55,
  300.        55,   27,   55,   55,   55,   31,   55,   55,   55,   35,
  301.        55,   55,   55,   55,   40,   55,   55,   55,   55,   55,
  302.        55,   55,   55,   55,   55,   55,   54,    0,   57,   55,
  303.        55,   55,   55,   55,   55,   55,   55,   55,   55,   55,
  304.        55,   55,   55,   55,   26,   55,   55,   30,   32,   55,
  305.  
  306.        55,   55,   55,   38,   39,   55,   55,   55,   44,   55,
  307.        55,   55,   55,   55,   55,   55,   55,   55,   55,    7,
  308.        55,   55,   13,   55,   15,   16,   55,   55,   55,   55,
  309.        55,   55,   55,   33,   55,   36,   55,   55,   42,   55,
  310.        45,   46,   47,   55,   55,   55,   55,   55,   55,   55,
  311.        55,   10,   55,   55,   55,   18,   55,   22,   55,   55,
  312.        55,   55,   37,   55,   43,   48,   49,   55,   55,   55,
  313.         4,    5,   55,   12,   14,   55,   19,   55,   55,   29,
  314.        34,   55,   55,   55,   52,   55,   55,   23,   55,   55,
  315.        50,   51,    6,   55,   55,   41,   17,   28,    0
  316.  
  317.     } ;
  318.  
  319. static const YY_CHAR yy_ec[128] =
  320.     {   0,
  321.         1,    1,    1,    1,    1,    1,    1,    1,    2,    1,
  322.         1,    1,    3,    1,    1,    1,    1,    1,    1,    1,
  323.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  324.         1,    2,    1,    1,    4,    1,    1,    1,    1,    1,
  325.         1,    5,    6,    1,    7,    8,    9,   10,   10,   10,
  326.        10,   10,   10,   10,   10,   10,   10,    1,    1,    1,
  327.         1,    1,    1,    1,   11,   11,   11,   11,   12,   11,
  328.        11,   11,   11,   11,   11,   11,   11,   11,   11,   11,
  329.        11,   11,   11,   11,   11,   11,   11,   11,   11,   11,
  330.         1,    1,    1,    1,   13,    1,   14,   15,   16,   17,
  331.  
  332.        18,   19,   20,   21,   22,   23,   24,   25,   26,   27,
  333.        28,   29,   30,   31,   32,   33,   34,   35,   36,   37,
  334.        38,   11,    1,    1,    1,    1,    1
  335.     } ;
  336.  
  337. static const YY_CHAR yy_meta[39] =
  338.     {   0,
  339.         1,    1,    1,    1,    2,    1,    2,    2,    2,    2,
  340.         2,    2,    2,    2,    2,    2,    2,    2,    2,    2,
  341.         2,    2,    2,    2,    2,    2,    2,    2,    2,    2,
  342.         2,    2,    2,    2,    2,    2,    2,    2
  343.     } ;
  344.  
  345. static const short int yy_base[301] =
  346.     {   0,
  347.         0,  597,  600,  602,  602,  602,   31,  589,  593,   32,
  348.       592,   38,   40,   41,   42,   43,   44,   46,   48,   51,
  349.        56,   71,   77,   58,   82,   83,   84,   85,   90,  602,
  350.       586,   86,   91,  602,  590,   95,  113,  111,  103,  117,
  351.       101,  119,  121,  122,  123,  125,  126,  127,  129,  131,
  352.       130,  134,  133,  137,  136,  132,  139,  138,  150,  140,
  353.       144,  157,  160,  161,  162,  168,  164,  169,  172,  173,
  354.       174,  179,  175,  183,  589,  181,  193,  201,  208,  583,
  355.       582,  187,  186,  196,  201,  586,  202,  216,  217,  218,
  356.       219,  220,  221,  224,  222,  223,  232,  231,  585,  584,
  357.  
  358.       225,  239,  228,  244,  246,  248,  249,  250,  253,  254,
  359.       256,  257,  255,  258,   53,  261,  264,  259,  266,  274,
  360.       275,  278,  267,  270,  263,  290,  289,  578,  577,  291,
  361.       576,  575,  279,  294,  295,  297,  579,  300,  578,  302,
  362.       303,  304,  305,  309,  312,  313,  311,  577,  306,  314,
  363.       315,  576,  316,  324,  318,  575,  320,  321,  325,  574,
  364.       329,  336,  339,  343,  573,  345,  347,  348,  349,  350,
  365.       351,  354,  355,  356,  357,  359,  572,  566,  565,  361,
  366.       358,  360,  366,  370,  367,  374,  379,  389,  390,  369,
  367.       372,  393,  373,  395,  569,  396,  399,  568,  567,  398,
  368.  
  369.       402,  400,  409,  566,  565,  404,  406,  408,  564,  410,
  370.       414,  412,  420,  413,  416,  423,  415,  417,  418,  563,
  371.       422,  434,  562,  440,  561,  560,  435,  442,  444,  446,
  372.       447,  449,  454,  559,  450,  558,  456,  451,  557,  458,
  373.       556,  555,  554,  459,  460,  465,  462,  466,  468,  474,
  374.       475,  553,  477,  476,  480,  552,  482,  551,  483,  484,
  375.       495,  490,  550,  491,  549,  548,  546,  489,  492,  496,
  376.       545,  543,  497,  542,  541,  499,  540,  498,  500,  539,
  377.       537,  493,  511,  512,  535,  517,  514,  534,  518,  522,
  378.       533,  531,  530,  527,  524,  528,  180,   52,  602,   50
  379.  
  380.     } ;
  381.  
  382. static const short int yy_def[301] =
  383.     {   0,
  384.       299,    1,  299,  299,  299,  299,  299,  299,  300,  299,
  385.       300,  300,  300,  300,  300,  300,  300,  300,  300,  300,
  386.       300,  300,  300,  300,  300,  300,  300,  300,  300,  299,
  387.       299,  299,  299,  299,  300,  299,  299,  300,  300,  300,
  388.       300,  300,  300,  300,  300,  300,  300,  300,  300,  300,
  389.       300,  300,  300,  300,  300,  300,  300,  300,  300,  300,
  390.       300,  300,  300,  300,  300,  300,  300,  300,  300,  300,
  391.       300,  300,  300,  300,  300,  300,  299,  299,  299,  299,
  392.       299,  300,  300,  300,  300,  300,  300,  300,  300,  300,
  393.       300,  300,  300,  300,  300,  300,  300,  300,  300,  300,
  394.  
  395.       300,  300,  300,  300,  300,  300,  300,  300,  300,  300,
  396.       300,  300,  300,  300,  300,  300,  300,  300,  300,  300,
  397.       300,  300,  300,  300,  300,  300,  300,  299,  299,  299,
  398.       299,  299,  300,  300,  300,  300,  300,  300,  300,  300,
  399.       300,  300,  300,  300,  300,  300,  300,  300,  300,  300,
  400.       300,  300,  300,  300,  300,  300,  300,  300,  300,  300,
  401.       300,  300,  300,  300,  300,  300,  300,  300,  300,  300,
  402.       300,  300,  300,  300,  300,  300,  300,  299,  299,  300,
  403.       300,  300,  300,  300,  300,  300,  300,  300,  300,  300,
  404.       300,  300,  300,  300,  300,  300,  300,  300,  300,  300,
  405.  
  406.       300,  300,  300,  300,  300,  300,  300,  300,  300,  300,
  407.       300,  300,  300,  300,  300,  300,  300,  300,  300,  300,
  408.       300,  300,  300,  300,  300,  300,  300,  300,  300,  300,
  409.       300,  300,  300,  300,  300,  300,  300,  300,  300,  300,
  410.       300,  300,  300,  300,  300,  300,  300,  300,  300,  300,
  411.       300,  300,  300,  300,  300,  300,  300,  300,  300,  300,
  412.       300,  300,  300,  300,  300,  300,  300,  300,  300,  300,
  413.       300,  300,  300,  300,  300,  300,  300,  300,  300,  300,
  414.       300,  300,  300,  300,  300,  300,  300,  300,  300,  300,
  415.       300,  300,  300,  300,  300,  300,  300,  300,    0,  299
  416.  
  417.     } ;
  418.  
  419. static const short int yy_nxt[641] =
  420.     {   0,
  421.         4,    5,    6,    4,    4,    7,    7,    8,    9,   10,
  422.        11,   11,    4,   12,   13,   14,   15,   16,   17,   18,
  423.        19,   11,   20,   11,   21,   22,   11,   23,   24,   11,
  424.        25,   26,   27,   28,   11,   29,   11,   11,   31,   36,
  425.        32,   32,  299,   37,  299,  299,  299,  299,  299,   37,
  426.       299,   35,  299,   40,   38,  299,  299,  299,   53,   48,
  427.       299,   44,  299,   49,   41,   57,   39,   42,   45,   50,
  428.        55,   54,   58,   43,   46,  299,   56,   59,   47,   51,
  429.        52,  299,   65,   60,   61,   66,  299,  299,  299,  299,
  430.       165,   63,   62,   36,  299,   32,   69,   37,   70,   67,
  431.  
  432.        33,   73,   77,   37,   78,  299,   79,  299,   77,   68,
  433.        64,   71,   79,   75,   74,  299,   72,   76,   80,   80,
  434.        83,  299,   81,  299,   82,  299,  299,  299,   85,  299,
  435.       299,  299,   84,  299,  299,  299,  299,  299,  299,   88,
  436.       299,  299,  299,  299,  299,   92,   87,   94,  299,   89,
  437.        91,   96,   98,  102,  299,   86,   99,   90,   97,   93,
  438.       103,  299,   95,  101,  299,  299,  299,  107,  299,  105,
  439.       104,  100,  299,  299,  108,  113,  299,  299,  299,  299,
  440.       109,  106,  111,  299,  299,  299,  119,  299,  110,  114,
  441.       299,  299,  115,  112,  121,  116,  125,  118,  128,  128,
  442.  
  443.       299,  117,  129,  120,  126,  299,  299,  122,  127,  123,
  444.        78,  124,  130,  131,  131,  133,  134,  132,  130,  135,
  445.       299,  299,  299,  299,  299,  299,  299,  299,  299,  299,
  446.       137,  138,  299,  136,  139,  299,  299,  143,  145,  147,
  447.       142,  144,  146,  299,  150,  141,  149,  153,  299,  140,
  448.       299,  148,  299,  299,  299,  152,  151,  299,  299,  299,
  449.       299,  299,  299,  299,  158,  299,  155,  299,  299,  159,
  450.       299,  299,  157,  161,  299,  162,  154,  167,  299,  299,
  451.       156,  163,  299,  299,  164,  173,  160,  168,  166,  175,
  452.       169,  170,  171,  299,  299,  172,  178,  178,  299,  299,
  453.  
  454.       179,  299,  174,  176,  299,  177,  299,  299,  299,  299,
  455.       299,  180,  183,  299,  182,  299,  299,  299,  299,  299,
  456.       299,  186,  299,  184,  299,  299,  181,  190,  299,  299,
  457.       187,  188,  185,  299,  191,  189,  196,  192,  194,  193,
  458.       299,  197,  201,  299,  202,  200,  195,  299,  199,  299,
  459.       198,  299,  299,  299,  299,  299,  204,  203,  299,  299,
  460.       299,  299,  299,  299,  299,  299,  209,  210,  213,  206,
  461.       299,  299,  208,  299,  299,  205,  299,  299,  299,  207,
  462.       222,  211,  217,  299,  212,  216,  220,  221,  215,  214,
  463.       219,  218,  223,  299,  299,  224,  228,  299,  230,  299,
  464.  
  465.       299,  227,  299,  299,  299,  225,  299,  226,  299,  229,
  466.       299,  231,  299,  299,  299,  234,  299,  299,  299,  299,
  467.       299,  299,  299,  239,  299,  240,  299,  299,  232,  233,
  468.       235,  242,  236,  237,  246,  244,  241,  238,  299,  299,
  469.       247,  243,  248,  245,  299,  251,  299,  250,  299,  249,
  470.       299,  299,  252,  299,  299,  299,  255,  254,  299,  256,
  471.       299,  257,  299,  299,  299,  253,  299,  260,  259,  299,
  472.       299,  261,  299,  263,  258,  269,  266,  267,  299,  299,
  473.       299,  299,  262,  264,  299,  271,  299,  299,  299,  265,
  474.       270,  272,  268,  299,  299,  299,  299,  299,  277,  299,
  475.  
  476.       299,  299,  299,  299,  299,  279,  275,  276,  273,  274,
  477.       281,  280,  282,  285,  278,  299,  299,  289,  299,  283,
  478.       290,  299,  299,  286,  284,  287,  299,  294,  299,  292,
  479.       288,  299,  299,  293,  299,  299,  291,  299,  299,  299,
  480.       298,  299,  295,  299,  299,  299,  299,  299,  296,  299,
  481.       299,  297,  299,  299,  299,  299,  299,  299,  299,  299,
  482.       299,  299,  299,  299,  299,  299,  299,  299,  299,  299,
  483.       299,  299,  299,  299,  179,  179,  299,  299,  299,  299,
  484.       299,  299,  299,  299,  132,  132,  129,  129,  299,  299,
  485.       299,   81,   81,  299,  299,   33,  299,   34,   33,  299,
  486.  
  487.        30,    3,  299,  299,  299,  299,  299,  299,  299,  299,
  488.       299,  299,  299,  299,  299,  299,  299,  299,  299,  299,
  489.       299,  299,  299,  299,  299,  299,  299,  299,  299,  299,
  490.       299,  299,  299,  299,  299,  299,  299,  299,  299,  299
  491.     } ;
  492.  
  493. static const short int yy_chk[641] =
  494.     {   0,
  495.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  496.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  497.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  498.         1,    1,    1,    1,    1,    1,    1,    1,    7,   10,
  499.         7,   10,   12,   10,   13,   14,   15,   16,   17,   10,
  500.        18,  300,   19,   13,   12,   20,  298,  115,   17,   15,
  501.        21,   14,   24,   15,   13,   19,   12,   13,   14,   16,
  502.        18,   17,   20,   13,   14,   22,   18,   21,   14,   16,
  503.        16,   23,   24,   21,   22,   24,   25,   26,   27,   28,
  504.       115,   23,   22,   32,   29,   32,   26,   32,   26,   25,
  505.  
  506.        33,   27,   33,   32,   36,   41,   36,   39,   33,   25,
  507.        23,   26,   36,   28,   27,   38,   26,   29,   37,   37,
  508.        39,   40,   37,   42,   38,   43,   44,   45,   41,   46,
  509.        47,   48,   40,   49,   51,   50,   56,   53,   52,   44,
  510.        55,   54,   58,   57,   60,   48,   43,   50,   61,   45,
  511.        47,   52,   54,   56,   59,   42,   54,   46,   53,   49,
  512.        57,   62,   51,   55,   63,   64,   65,   60,   67,   59,
  513.        58,   54,   66,   68,   61,   65,   69,   70,   71,   73,
  514.        61,   59,   63,   72,  297,   76,   70,   74,   62,   66,
  515.        83,   82,   66,   64,   71,   67,   74,   69,   77,   77,
  516.  
  517.        84,   68,   77,   70,   74,   85,   87,   72,   76,   72,
  518.        78,   73,   78,   79,   79,   82,   83,   79,   78,   84,
  519.        88,   89,   90,   91,   92,   93,   95,   96,   94,  101,
  520.        87,   88,  103,   85,   89,   98,   97,   92,   93,   95,
  521.        91,   92,   94,  102,   98,   90,   97,  103,  104,   89,
  522.       105,   96,  106,  107,  108,  102,  101,  109,  110,  113,
  523.       111,  112,  114,  118,  108,  116,  105,  125,  117,  109,
  524.       119,  123,  107,  111,  124,  112,  104,  117,  120,  121,
  525.       106,  113,  122,  133,  114,  123,  110,  118,  116,  125,
  526.       119,  120,  121,  127,  126,  122,  130,  130,  134,  135,
  527.  
  528.       130,  136,  124,  126,  138,  127,  140,  141,  142,  143,
  529.       149,  133,  136,  144,  135,  147,  145,  146,  150,  151,
  530.       153,  141,  155,  138,  157,  158,  134,  145,  154,  159,
  531.       142,  143,  140,  161,  146,  144,  153,  147,  150,  149,
  532.       162,  154,  159,  163,  161,  158,  151,  164,  157,  166,
  533.       155,  167,  168,  169,  170,  171,  163,  162,  172,  173,
  534.       174,  175,  181,  176,  182,  180,  169,  170,  173,  166,
  535.       183,  185,  168,  190,  184,  164,  191,  193,  186,  167,
  536.       185,  171,  180,  187,  172,  176,  183,  184,  175,  174,
  537.       182,  181,  186,  188,  189,  187,  191,  192,  193,  194,
  538.  
  539.       196,  190,  200,  197,  202,  188,  201,  189,  206,  192,
  540.       207,  194,  208,  203,  210,  200,  212,  214,  211,  217,
  541.       215,  218,  219,  207,  213,  208,  221,  216,  196,  197,
  542.       201,  211,  202,  203,  215,  213,  210,  206,  222,  227,
  543.       215,  212,  216,  214,  224,  219,  228,  218,  229,  217,
  544.       230,  231,  221,  232,  235,  238,  227,  224,  233,  228,
  545.       237,  229,  240,  244,  245,  222,  247,  232,  231,  246,
  546.       248,  233,  249,  237,  230,  247,  244,  245,  250,  251,
  547.       254,  253,  235,  238,  255,  249,  257,  259,  260,  240,
  548.       248,  250,  246,  268,  262,  264,  269,  282,  257,  261,
  549.  
  550.       270,  273,  278,  276,  279,  260,  254,  255,  251,  253,
  551.       262,  261,  264,  270,  259,  283,  284,  279,  287,  268,
  552.       282,  286,  289,  273,  269,  276,  290,  287,  295,  284,
  553.       278,  294,  296,  286,  293,  292,  283,  291,  288,  285,
  554.       295,  281,  289,  280,  277,  275,  274,  272,  290,  271,
  555.       267,  294,  266,  265,  263,  258,  256,  252,  243,  242,
  556.       241,  239,  236,  234,  226,  225,  223,  220,  209,  205,
  557.       204,  199,  198,  195,  179,  178,  177,  165,  160,  156,
  558.       152,  148,  139,  137,  132,  131,  129,  128,  100,   99,
  559.        86,   81,   80,   75,   35,   31,   11,    9,    8,    3,
  560.  
  561.         2,  299,  299,  299,  299,  299,  299,  299,  299,  299,
  562.       299,  299,  299,  299,  299,  299,  299,  299,  299,  299,
  563.       299,  299,  299,  299,  299,  299,  299,  299,  299,  299,
  564.       299,  299,  299,  299,  299,  299,  299,  299,  299,  299
  565.     } ;
  566.  
  567. static yy_state_type yy_last_accepting_state;
  568. static YY_CHAR *yy_last_accepting_cpos;
  569.  
  570. /* the intent behind this definition is that it'll catch
  571.  * any uses of REJECT which flex missed
  572.  */
  573. #define REJECT reject_used_but_not_detected
  574. #define yymore() yymore_used_but_not_detected
  575. #define YY_MORE_ADJ 0
  576.  
  577. /* these variables are all declared out here so that section 3 code can
  578.  * manipulate them
  579.  */
  580. /* points to current character in buffer */
  581. static YY_CHAR *yy_c_buf_p = (YY_CHAR *) 0;
  582. static int yy_init = 1;        /* whether we need to initialize */
  583. static int yy_start = 0;    /* start state number */
  584.  
  585. /* flag which is used to allow yywrap()'s to do buffer switches
  586.  * instead of setting up a fresh yyin.  A bit of a hack ...
  587.  */
  588. static int yy_did_buffer_switch_on_eof;
  589.  
  590. static yy_state_type yy_get_previous_state YY_PROTO(( void ));
  591. static yy_state_type yy_try_NUL_trans YY_PROTO(( yy_state_type current_state ));
  592. static int yy_get_next_buffer YY_PROTO(( void ));
  593. static void yyunput YY_PROTO(( YY_CHAR c, YY_CHAR *buf_ptr ));
  594. void yyrestart YY_PROTO(( FILE *input_file ));
  595. void yy_switch_to_buffer YY_PROTO(( YY_BUFFER_STATE new_buffer ));
  596. void yy_load_buffer_state YY_PROTO(( void ));
  597. YY_BUFFER_STATE yy_create_buffer YY_PROTO(( FILE *file, int size ));
  598. void yy_delete_buffer YY_PROTO(( YY_BUFFER_STATE b ));
  599. void yy_init_buffer YY_PROTO(( YY_BUFFER_STATE b, FILE *file ));
  600.  
  601. #define yy_new_buffer yy_create_buffer
  602.  
  603. #ifdef __cplusplus
  604. static int yyinput YY_PROTO(( void ));
  605. #else
  606. static int input YY_PROTO(( void ));
  607. #endif
  608.  
  609. YY_DECL
  610.     {
  611.     register yy_state_type yy_current_state;
  612.     register YY_CHAR *yy_cp, *yy_bp;
  613.     register int yy_act;
  614.  
  615.  
  616.  
  617.     if ( yy_init )
  618.     {
  619.     YY_USER_INIT;
  620.  
  621.     if ( ! yy_start )
  622.         yy_start = 1;    /* first start state */
  623.  
  624.     if ( ! yyin )
  625.         yyin = stdin;
  626.  
  627.     if ( ! yyout )
  628.         yyout = stdout;
  629.  
  630.     if ( yy_current_buffer )
  631.         yy_init_buffer( yy_current_buffer, yyin );
  632.     else
  633.         yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE );
  634.  
  635.     yy_load_buffer_state();
  636.  
  637.     yy_init = 0;
  638.     }
  639.  
  640.     while ( 1 )        /* loops until end-of-file is reached */
  641.     {
  642.     yy_cp = yy_c_buf_p;
  643.  
  644.     /* support of yytext */
  645.     *yy_cp = yy_hold_char;
  646.  
  647.     /* yy_bp points to the position in yy_ch_buf of the start of the
  648.      * current run.
  649.      */
  650.     yy_bp = yy_cp;
  651.  
  652.     yy_current_state = yy_start;
  653.     if ( yy_bp[-1] == '\n' )
  654.         ++yy_current_state;
  655. yy_match:
  656.     do
  657.         {
  658.         register YY_CHAR yy_c = yy_ec[*yy_cp];
  659.         if ( yy_accept[yy_current_state] )
  660.         {
  661.         yy_last_accepting_state = yy_current_state;
  662.         yy_last_accepting_cpos = yy_cp;
  663.         }
  664.         while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
  665.         {
  666.         yy_current_state = yy_def[yy_current_state];
  667.         if ( yy_current_state >= 300 )
  668.             yy_c = yy_meta[yy_c];
  669.         }
  670.         yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
  671.         ++yy_cp;
  672.         }
  673.     while ( yy_current_state != 299 );
  674.     yy_cp = yy_last_accepting_cpos;
  675.     yy_current_state = yy_last_accepting_state;
  676.  
  677. yy_find_action:
  678.     yy_act = yy_accept[yy_current_state];
  679.  
  680.     YY_DO_BEFORE_ACTION;
  681.     YY_USER_ACTION;
  682.  
  683. do_action:    /* this label is used only to access EOF actions */
  684.  
  685.  
  686.     switch ( yy_act )
  687.         {
  688.         case 0: /* must backtrack */
  689.         /* undo the effects of YY_DO_BEFORE_ACTION */
  690.         *yy_cp = yy_hold_char;
  691.         yy_cp = yy_last_accepting_cpos;
  692.         yy_current_state = yy_last_accepting_state;
  693.         goto yy_find_action;
  694.  
  695. case 1:
  696. ;
  697.     YY_BREAK
  698. case 2:
  699. {handlehash();}
  700.     YY_BREAK
  701. case 3:
  702. {skipcomments();}
  703.     YY_BREAK
  704. case 4:
  705. {return(tADAPTIVE);}
  706.     YY_BREAK
  707. case 5:
  708. {return(tAPERTURE);}
  709.     YY_BREAK
  710. case 6:
  711. {return(tBACKGROUND);}
  712.     YY_BREAK
  713. case 7:
  714. {return(tBLOTCH);}
  715.     YY_BREAK
  716. case 8:
  717. {return(tBOX);}
  718.     YY_BREAK
  719. case 9:
  720. {return(tBUMP);}
  721.     YY_BREAK
  722. case 10:
  723. {return(tCHECKER);}
  724.     YY_BREAK
  725. case 11:
  726. {return(tCONE);}
  727.     YY_BREAK
  728. case 12:
  729. {return(tCONTRAST);}
  730.     YY_BREAK
  731. case 13:
  732. {return(tCUTOFF);}
  733.     YY_BREAK
  734. case 14:
  735. {return(tCYL);}
  736.     YY_BREAK
  737. case 15:
  738. {return(tENDDEF);}
  739.     YY_BREAK
  740. case 16:
  741. {return(tSTARTDEF);}
  742.     YY_BREAK
  743. case 17:
  744. {return(tDIRECTIONAL);}
  745.     YY_BREAK
  746. case 18:
  747. {return(tENDFILE);}
  748.     YY_BREAK
  749. case 19:
  750. {return(tEXTENDED);}
  751.     YY_BREAK
  752. case 20:
  753. {return(tEYEP);}
  754.     YY_BREAK
  755. case 21:
  756. {return(tFBM);}
  757.     YY_BREAK
  758. case 22:
  759. {return(tFBMBUMP);}
  760.     YY_BREAK
  761. case 23:
  762. {return(tFOCALDIST);}
  763.     YY_BREAK
  764. case 24:
  765. {return(tFOG);}
  766.     YY_BREAK
  767. case 25:
  768. {return(tFOV);}
  769.     YY_BREAK
  770. case 26:
  771. {return(tGLOSS);}
  772.     YY_BREAK
  773. case 27:
  774. {return(tGRID);}
  775.     YY_BREAK
  776. case 28:
  777. {return(tHEIGHTFIELD);}
  778.     YY_BREAK
  779. case 29:
  780. {return(tJITTERED);}
  781.     YY_BREAK
  782. case 30:
  783. {return(tLIGHT);}
  784.     YY_BREAK
  785. case 31:
  786. {return(tLIST);}
  787.     YY_BREAK
  788. case 32:
  789. {return(tLOOKP);}
  790.     YY_BREAK
  791. case 33:
  792. {return(tMARBLE);}
  793.     YY_BREAK
  794. case 34:
  795. {return(tMAXDEPTH);}
  796.     YY_BREAK
  797. case 35:
  798. {return(tMIST);}
  799.     YY_BREAK
  800. case 36:
  801. {return(tOBJECT);}
  802.     YY_BREAK
  803. case 37:
  804. {return(tOUTFILE);}
  805.     YY_BREAK
  806. case 38:
  807. {return(tPLANE);}
  808.     YY_BREAK
  809. case 39:
  810. {return(tPOINT);}
  811.     YY_BREAK
  812. case 40:
  813. {return(tPOLY);}
  814.     YY_BREAK
  815. case 41:
  816. {return(tRESOLUTION);}
  817.     YY_BREAK
  818. case 42:
  819. {return(tROTATE);}
  820.     YY_BREAK
  821. case 43:
  822. {return(tSAMPLES);}
  823.     YY_BREAK
  824. case 44:
  825. {return(tSCALE);}
  826.     YY_BREAK
  827. case 45:
  828. {return(tSCREEN);}
  829.     YY_BREAK
  830. case 46:
  831. {return(tSPHERE);}
  832.     YY_BREAK
  833. case 47:
  834. {return(tSUPERQ);}
  835.     YY_BREAK
  836. case 48:
  837. {return(tSURFACE);}
  838.     YY_BREAK
  839. case 49:
  840. {return(tTEXTURE);}
  841.     YY_BREAK
  842. case 50:
  843. {return(tTRANSFORM);}
  844.     YY_BREAK
  845. case 51:
  846. {return(tTRANSLATE);}
  847.     YY_BREAK
  848. case 52:
  849. {return(tTRIANGLE);}
  850.     YY_BREAK
  851. case 53:
  852. {return(tUP);}
  853.     YY_BREAK
  854. case 54:
  855. {return(tWOOD);}
  856.     YY_BREAK
  857. case 55:
  858. {yylval.c = strsave(yytext);
  859.                 return(tSTRING);}
  860.     YY_BREAK
  861. case 56:
  862. {yylval.i = atoi(yytext);
  863.                 return(tINT);}
  864.     YY_BREAK
  865. case 57:
  866. case 58:
  867. case 59:
  868. {yylval.d = atof(yytext); return(tFLOAT);}
  869.     YY_BREAK
  870. case 60:
  871. {return yytext[0];}
  872.     YY_BREAK
  873. case 61:
  874. ECHO;
  875.     YY_BREAK
  876. case YY_STATE_EOF(INITIAL):
  877.     yyterminate();
  878.  
  879.         case YY_END_OF_BUFFER:
  880.         {
  881.         /* amount of text matched not including the EOB char */
  882.         int yy_amount_of_matched_text = yy_cp - yytext - 1;
  883.  
  884.         /* undo the effects of YY_DO_BEFORE_ACTION */
  885.         *yy_cp = yy_hold_char;
  886.  
  887.         /* note that here we test for yy_c_buf_p "<=" to the position
  888.          * of the first EOB in the buffer, since yy_c_buf_p will
  889.          * already have been incremented past the NUL character
  890.          * (since all states make transitions on EOB to the end-
  891.          * of-buffer state).  Contrast this with the test in yyinput().
  892.          */
  893.         if ( yy_c_buf_p <= &yy_current_buffer->yy_ch_buf[yy_n_chars] )
  894.             /* this was really a NUL */
  895.             {
  896.             yy_state_type yy_next_state;
  897.  
  898.             yy_c_buf_p = yytext + yy_amount_of_matched_text;
  899.  
  900.             yy_current_state = yy_get_previous_state();
  901.  
  902.             /* okay, we're now positioned to make the
  903.              * NUL transition.  We couldn't have
  904.              * yy_get_previous_state() go ahead and do it
  905.              * for us because it doesn't know how to deal
  906.              * with the possibility of jamming (and we
  907.              * don't want to build jamming into it because
  908.              * then it will run more slowly)
  909.              */
  910.  
  911.             yy_next_state = yy_try_NUL_trans( yy_current_state );
  912.  
  913.             yy_bp = yytext + YY_MORE_ADJ;
  914.  
  915.             if ( yy_next_state )
  916.             {
  917.             /* consume the NUL */
  918.             yy_cp = ++yy_c_buf_p;
  919.             yy_current_state = yy_next_state;
  920.             goto yy_match;
  921.             }
  922.  
  923.             else
  924.             {
  925.                 yy_cp = yy_last_accepting_cpos;
  926.                 yy_current_state = yy_last_accepting_state;
  927.             goto yy_find_action;
  928.             }
  929.             }
  930.  
  931.         else switch ( yy_get_next_buffer() )
  932.             {
  933.             case EOB_ACT_END_OF_FILE:
  934.             {
  935.             yy_did_buffer_switch_on_eof = 0;
  936.  
  937.             if ( yywrap() )
  938.                 {
  939.                 /* note: because we've taken care in
  940.                  * yy_get_next_buffer() to have set up yytext,
  941.                  * we can now set up yy_c_buf_p so that if some
  942.                  * total hoser (like flex itself) wants
  943.                  * to call the scanner after we return the
  944.                  * YY_NULL, it'll still work - another YY_NULL
  945.                  * will get returned.
  946.                  */
  947.                 yy_c_buf_p = yytext + YY_MORE_ADJ;
  948.  
  949.                 yy_act = YY_STATE_EOF((yy_start - 1) / 2);
  950.                 goto do_action;
  951.                 }
  952.  
  953.             else
  954.                 {
  955.                 if ( ! yy_did_buffer_switch_on_eof )
  956.                 YY_NEW_FILE;
  957.                 }
  958.             }
  959.             break;
  960.  
  961.             case EOB_ACT_CONTINUE_SCAN:
  962.             yy_c_buf_p = yytext + yy_amount_of_matched_text;
  963.  
  964.             yy_current_state = yy_get_previous_state();
  965.  
  966.             yy_cp = yy_c_buf_p;
  967.             yy_bp = yytext + YY_MORE_ADJ;
  968.             goto yy_match;
  969.  
  970.             case EOB_ACT_LAST_MATCH:
  971.             yy_c_buf_p =
  972.                 &yy_current_buffer->yy_ch_buf[yy_n_chars];
  973.  
  974.             yy_current_state = yy_get_previous_state();
  975.  
  976.             yy_cp = yy_c_buf_p;
  977.             yy_bp = yytext + YY_MORE_ADJ;
  978.             goto yy_find_action;
  979.             }
  980.         break;
  981.         }
  982.  
  983.         default:
  984. #ifdef FLEX_DEBUG
  985.         printf( "action # %d\n", yy_act );
  986. #endif
  987.         YY_FATAL_ERROR(
  988.             "fatal flex scanner internal error--no action found" );
  989.         }
  990.     }
  991.     }
  992.  
  993.  
  994. /* yy_get_next_buffer - try to read in a new buffer
  995.  *
  996.  * synopsis
  997.  *     int yy_get_next_buffer();
  998.  *     
  999.  * returns a code representing an action
  1000.  *     EOB_ACT_LAST_MATCH - 
  1001.  *     EOB_ACT_CONTINUE_SCAN - continue scanning from current position
  1002.  *     EOB_ACT_END_OF_FILE - end of file
  1003.  */
  1004.  
  1005. static int yy_get_next_buffer()
  1006.  
  1007.     {
  1008.     register YY_CHAR *dest = yy_current_buffer->yy_ch_buf;
  1009.     register YY_CHAR *source = yytext - 1; /* copy prev. char, too */
  1010.     register int number_to_move, i;
  1011.     int ret_val;
  1012.  
  1013.     if ( yy_c_buf_p > &yy_current_buffer->yy_ch_buf[yy_n_chars + 1] )
  1014.     YY_FATAL_ERROR(
  1015.         "fatal flex scanner internal error--end of buffer missed" );
  1016.  
  1017.     /* try to read more data */
  1018.  
  1019.     /* first move last chars to start of buffer */
  1020.     number_to_move = yy_c_buf_p - yytext;
  1021.  
  1022.     for ( i = 0; i < number_to_move; ++i )
  1023.     *(dest++) = *(source++);
  1024.  
  1025.     if ( yy_current_buffer->yy_eof_status != EOF_NOT_SEEN )
  1026.     /* don't do the read, it's not guaranteed to return an EOF,
  1027.      * just force an EOF
  1028.      */
  1029.     yy_n_chars = 0;
  1030.  
  1031.     else
  1032.     {
  1033.     int num_to_read = yy_current_buffer->yy_buf_size - number_to_move - 1;
  1034.  
  1035.     if ( num_to_read > YY_READ_BUF_SIZE )
  1036.         num_to_read = YY_READ_BUF_SIZE;
  1037.  
  1038.     else if ( num_to_read <= 0 )
  1039.         YY_FATAL_ERROR( "fatal error - scanner input buffer overflow" );
  1040.  
  1041.     /* read in more data */
  1042.     YY_INPUT( (&yy_current_buffer->yy_ch_buf[number_to_move]),
  1043.           yy_n_chars, num_to_read );
  1044.     }
  1045.  
  1046.     if ( yy_n_chars == 0 )
  1047.     {
  1048.     if ( number_to_move == 1 )
  1049.         {
  1050.         ret_val = EOB_ACT_END_OF_FILE;
  1051.         yy_current_buffer->yy_eof_status = EOF_DONE;
  1052.         }
  1053.  
  1054.     else
  1055.         {
  1056.         ret_val = EOB_ACT_LAST_MATCH;
  1057.         yy_current_buffer->yy_eof_status = EOF_PENDING;
  1058.         }
  1059.     }
  1060.  
  1061.     else
  1062.     ret_val = EOB_ACT_CONTINUE_SCAN;
  1063.  
  1064.     yy_n_chars += number_to_move;
  1065.     yy_current_buffer->yy_ch_buf[yy_n_chars] = YY_END_OF_BUFFER_CHAR;
  1066.     yy_current_buffer->yy_ch_buf[yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR;
  1067.  
  1068.     /* yytext begins at the second character in yy_ch_buf; the first
  1069.      * character is the one which preceded it before reading in the latest
  1070.      * buffer; it needs to be kept around in case it's a newline, so
  1071.      * yy_get_previous_state() will have with '^' rules active
  1072.      */
  1073.  
  1074.     yytext = &yy_current_buffer->yy_ch_buf[1];
  1075.  
  1076.     return ( ret_val );
  1077.     }
  1078.  
  1079.  
  1080. /* yy_get_previous_state - get the state just before the EOB char was reached
  1081.  *
  1082.  * synopsis
  1083.  *     yy_state_type yy_get_previous_state();
  1084.  */
  1085.  
  1086. static yy_state_type yy_get_previous_state()
  1087.  
  1088.     {
  1089.     register yy_state_type yy_current_state;
  1090.     register YY_CHAR *yy_cp;
  1091.  
  1092.     register YY_CHAR *yy_bp = yytext;
  1093.  
  1094.     yy_current_state = yy_start;
  1095.     if ( yy_bp[-1] == '\n' )
  1096.     ++yy_current_state;
  1097.  
  1098.     for ( yy_cp = yytext + YY_MORE_ADJ; yy_cp < yy_c_buf_p; ++yy_cp )
  1099.     {
  1100.     register YY_CHAR yy_c = (*yy_cp ? yy_ec[*yy_cp] : 1);
  1101.     if ( yy_accept[yy_current_state] )
  1102.         {
  1103.         yy_last_accepting_state = yy_current_state;
  1104.         yy_last_accepting_cpos = yy_cp;
  1105.         }
  1106.     while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
  1107.         {
  1108.         yy_current_state = yy_def[yy_current_state];
  1109.         if ( yy_current_state >= 300 )
  1110.         yy_c = yy_meta[yy_c];
  1111.         }
  1112.     yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
  1113.     }
  1114.  
  1115.     return ( yy_current_state );
  1116.     }
  1117.  
  1118.  
  1119. /* yy_try_NUL_trans - try to make a transition on the NUL character
  1120.  *
  1121.  * synopsis
  1122.  *     next_state = yy_try_NUL_trans( current_state );
  1123.  */
  1124.  
  1125. #ifdef YY_USE_PROTOS
  1126. static yy_state_type yy_try_NUL_trans( register yy_state_type yy_current_state )
  1127. #else
  1128. static yy_state_type yy_try_NUL_trans( yy_current_state )
  1129. register yy_state_type yy_current_state;
  1130. #endif
  1131.  
  1132.     {
  1133.     register int yy_is_jam;
  1134.     register YY_CHAR *yy_cp = yy_c_buf_p;
  1135.  
  1136.     register YY_CHAR yy_c = 1;
  1137.     if ( yy_accept[yy_current_state] )
  1138.     {
  1139.     yy_last_accepting_state = yy_current_state;
  1140.     yy_last_accepting_cpos = yy_cp;
  1141.     }
  1142.     while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
  1143.     {
  1144.     yy_current_state = yy_def[yy_current_state];
  1145.     if ( yy_current_state >= 300 )
  1146.         yy_c = yy_meta[yy_c];
  1147.     }
  1148.     yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
  1149.     yy_is_jam = (yy_current_state == 299);
  1150.  
  1151.     return ( yy_is_jam ? 0 : yy_current_state );
  1152.     }
  1153.  
  1154.  
  1155. #ifdef YY_USE_PROTOS
  1156. static void yyunput( YY_CHAR c, register YY_CHAR *yy_bp )
  1157. #else
  1158. static void yyunput( c, yy_bp )
  1159. YY_CHAR c;
  1160. register YY_CHAR *yy_bp;
  1161. #endif
  1162.  
  1163.     {
  1164.     register YY_CHAR *yy_cp = yy_c_buf_p;
  1165.  
  1166.     /* undo effects of setting up yytext */
  1167.     *yy_cp = yy_hold_char;
  1168.  
  1169.     if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )
  1170.     { /* need to shift things up to make room */
  1171.     register int number_to_move = yy_n_chars + 2; /* +2 for EOB chars */
  1172.     register YY_CHAR *dest =
  1173.         &yy_current_buffer->yy_ch_buf[yy_current_buffer->yy_buf_size + 2];
  1174.     register YY_CHAR *source =
  1175.         &yy_current_buffer->yy_ch_buf[number_to_move];
  1176.  
  1177.     while ( source > yy_current_buffer->yy_ch_buf )
  1178.         *--dest = *--source;
  1179.  
  1180.     yy_cp += dest - source;
  1181.     yy_bp += dest - source;
  1182.     yy_n_chars = yy_current_buffer->yy_buf_size;
  1183.  
  1184.     if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )
  1185.         YY_FATAL_ERROR( "flex scanner push-back overflow" );
  1186.     }
  1187.  
  1188.     if ( yy_cp > yy_bp && yy_cp[-1] == '\n' )
  1189.     yy_cp[-2] = '\n';
  1190.  
  1191.     if ((*--yy_cp = c) == '\n')
  1192.         yylineno--;
  1193.  
  1194.     /* note: the formal parameter *must* be called "yy_bp" for this
  1195.      *       macro to now work correctly
  1196.      */
  1197.     YY_DO_BEFORE_ACTION; /* set up yytext again */
  1198.     }
  1199.  
  1200.  
  1201. #ifdef __cplusplus
  1202. static int yyinput()
  1203. #else
  1204. static int input()
  1205. #endif
  1206.  
  1207.     {
  1208.     int c;
  1209.     YY_CHAR *yy_cp = yy_c_buf_p;
  1210.  
  1211.     *yy_cp = yy_hold_char;
  1212.  
  1213.     if ( *yy_c_buf_p == YY_END_OF_BUFFER_CHAR )
  1214.     {
  1215.     /* yy_c_buf_p now points to the character we want to return.
  1216.      * If this occurs *before* the EOB characters, then it's a
  1217.      * valid NUL; if not, then we've hit the end of the buffer.
  1218.      */
  1219.     if ( yy_c_buf_p < &yy_current_buffer->yy_ch_buf[yy_n_chars] )
  1220.         /* this was really a NUL */
  1221.         *yy_c_buf_p = '\0';
  1222.  
  1223.     else
  1224.         { /* need more input */
  1225.         yytext = yy_c_buf_p;
  1226.         ++yy_c_buf_p;
  1227.  
  1228.         switch ( yy_get_next_buffer() )
  1229.         {
  1230.         case EOB_ACT_END_OF_FILE:
  1231.             {
  1232.             if ( yywrap() )
  1233.             {
  1234.             yy_c_buf_p = yytext + YY_MORE_ADJ;
  1235.             return ( EOF );
  1236.             }
  1237.  
  1238.             YY_NEW_FILE;
  1239.  
  1240. #ifdef __cplusplus
  1241.             return ( yyinput() );
  1242. #else
  1243.             return ( input() );
  1244. #endif
  1245.             }
  1246.             break;
  1247.  
  1248.         case EOB_ACT_CONTINUE_SCAN:
  1249.             yy_c_buf_p = yytext + YY_MORE_ADJ;
  1250.             break;
  1251.  
  1252.         case EOB_ACT_LAST_MATCH:
  1253. #ifdef __cplusplus
  1254.             YY_FATAL_ERROR( "unexpected last match in yyinput()" );
  1255. #else
  1256.             YY_FATAL_ERROR( "unexpected last match in input()" );
  1257. #endif
  1258.         }
  1259.         }
  1260.     }
  1261.  
  1262.     if ((c = *yy_c_buf_p) == '\n')
  1263.         yylineno++;
  1264.     yy_hold_char = *++yy_c_buf_p;
  1265.  
  1266.     return ( c );
  1267.     }
  1268.  
  1269.  
  1270. #ifdef YY_USE_PROTOS
  1271. void yyrestart( FILE *input_file )
  1272. #else
  1273. void yyrestart( input_file )
  1274. FILE *input_file;
  1275. #endif
  1276.  
  1277.     {
  1278.     yy_init_buffer( yy_current_buffer, input_file );
  1279.     yy_load_buffer_state();
  1280.     }
  1281.  
  1282.  
  1283. #ifdef YY_USE_PROTOS
  1284. void yy_switch_to_buffer( YY_BUFFER_STATE new_buffer )
  1285. #else
  1286. void yy_switch_to_buffer( new_buffer )
  1287. YY_BUFFER_STATE new_buffer;
  1288. #endif
  1289.  
  1290.     {
  1291.     if ( yy_current_buffer == new_buffer )
  1292.     return;
  1293.  
  1294.     if ( yy_current_buffer )
  1295.     {
  1296.     /* flush out information for old buffer */
  1297.     *yy_c_buf_p = yy_hold_char;
  1298.     yy_current_buffer->yy_buf_pos = yy_c_buf_p;
  1299.     yy_current_buffer->yy_n_chars = yy_n_chars;
  1300.     }
  1301.  
  1302.     yy_current_buffer = new_buffer;
  1303.     yy_load_buffer_state();
  1304.  
  1305.     /* we don't actually know whether we did this switch during
  1306.      * EOF (yywrap()) processing, but the only time this flag
  1307.      * is looked at is after yywrap() is called, so it's safe
  1308.      * to go ahead and always set it.
  1309.      */
  1310.     yy_did_buffer_switch_on_eof = 1;
  1311.     }
  1312.  
  1313.  
  1314. #ifdef YY_USE_PROTOS
  1315. void yy_load_buffer_state( void )
  1316. #else
  1317. void yy_load_buffer_state()
  1318. #endif
  1319.  
  1320.     {
  1321.     yy_n_chars = yy_current_buffer->yy_n_chars;
  1322.     yytext = yy_c_buf_p = yy_current_buffer->yy_buf_pos;
  1323.     yyin = yy_current_buffer->yy_input_file;
  1324.     yy_hold_char = *yy_c_buf_p;
  1325.     }
  1326.  
  1327.  
  1328. #ifdef YY_USE_PROTOS
  1329. YY_BUFFER_STATE yy_create_buffer( FILE *file, int size )
  1330. #else
  1331. YY_BUFFER_STATE yy_create_buffer( file, size )
  1332. FILE *file;
  1333. int size;
  1334. #endif
  1335.  
  1336.     {
  1337.     YY_BUFFER_STATE b;
  1338.  
  1339.     b = (YY_BUFFER_STATE) malloc( sizeof( struct yy_buffer_state ) );
  1340.  
  1341.     if ( ! b )
  1342.     YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
  1343.  
  1344.     b->yy_buf_size = size;
  1345.  
  1346.     /* yy_ch_buf has to be 2 characters longer than the size given because
  1347.      * we need to put in 2 end-of-buffer characters.
  1348.      */
  1349.     b->yy_ch_buf = (YY_CHAR *) malloc( (unsigned) (b->yy_buf_size + 2) );
  1350.  
  1351.     if ( ! b->yy_ch_buf )
  1352.     YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
  1353.  
  1354.     yy_init_buffer( b, file );
  1355.  
  1356.     return ( b );
  1357.     }
  1358.  
  1359.  
  1360. #ifdef YY_USE_PROTOS
  1361. void yy_delete_buffer( YY_BUFFER_STATE b )
  1362. #else
  1363. void yy_delete_buffer( b )
  1364. YY_BUFFER_STATE b;
  1365. #endif
  1366.  
  1367.     {
  1368.     if ( b == yy_current_buffer )
  1369.     yy_current_buffer = (YY_BUFFER_STATE) 0;
  1370.  
  1371.     free( (char *) b->yy_ch_buf );
  1372.     free( (char *) b );
  1373.     }
  1374.  
  1375.  
  1376. #ifdef YY_USE_PROTOS
  1377. void yy_init_buffer( YY_BUFFER_STATE b, FILE *file )
  1378. #else
  1379. void yy_init_buffer( b, file )
  1380. YY_BUFFER_STATE b;
  1381. FILE *file;
  1382. #endif
  1383.  
  1384.     {
  1385.     b->yy_input_file = file;
  1386.  
  1387.     /* we put in the '\n' and start reading from [1] so that an
  1388.      * initial match-at-newline will be true.
  1389.      */
  1390.  
  1391.     b->yy_ch_buf[0] = '\n';
  1392.     b->yy_n_chars = 1;
  1393.  
  1394.     /* we always need two end-of-buffer characters.  The first causes
  1395.      * a transition to the end-of-buffer state.  The second causes
  1396.      * a jam in that state.
  1397.      */
  1398.     b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
  1399.     b->yy_ch_buf[2] = YY_END_OF_BUFFER_CHAR;
  1400.  
  1401.     b->yy_buf_pos = &b->yy_ch_buf[1];
  1402.  
  1403.     b->yy_eof_status = EOF_NOT_SEEN;
  1404.     }
  1405.  
  1406. yywrap() {return(1);}
  1407. /*
  1408.  * Skip over comments.
  1409.  */
  1410. skipcomments()
  1411. {
  1412.     char c;
  1413.  
  1414.     while (1) {
  1415.         while (input() != '*')
  1416.             ;
  1417.         if ((c = input()) == '/')
  1418.             return;
  1419.         unput(c);
  1420.     }
  1421. }
  1422. /*
  1423.  * Deal with ccp-produced lines of the form:
  1424.  * # n "filename"
  1425.  * and
  1426.  * # n
  1427.  * Where filename is the name of the file being processed, and n is
  1428.  * the current line number in that file.
  1429.  */
  1430. handlehash()
  1431. {
  1432.     char buf[BUFSIZ];
  1433.     int i;
  1434.     extern int yylineno;
  1435.     extern char yyfilename[];
  1436.  
  1437.     /*
  1438.      * Read the entire line into buf.
  1439.      */
  1440.     for (i = 0; (buf[i] = input()) != '\n'; i++)
  1441.             ;
  1442.     unput(buf[i]);        /* To make sure consecutive # lines work. */
  1443.     buf[i] = (char)NULL;    /* Replace newline with NULL. */
  1444.  
  1445.     /*
  1446.      * Complain if the line was not of the form #n "filename"
  1447.      */
  1448.     if ((i = sscanf(buf, "%d \"%[^\"]s\"", &yylineno, yyfilename)) == 0) {
  1449.         yyerror("Unknown '#' control.");
  1450.         exit(1);
  1451.     }
  1452.     if (i == 1) {
  1453. #ifdef SYSV
  1454.         if (strchr(buf, '"') != (char *)0) {
  1455. #else
  1456.         if (index(buf, '"') != (char *)0) {
  1457. #endif
  1458.             /*
  1459.              * Filename was "", which means stdin.
  1460.              */
  1461.             strcpy(yyfilename, "stdin");
  1462.         }
  1463.     }
  1464. }
  1465.