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