home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / forut062.zip / ForUtil-0.62 / commons / scan_commons.c < prev    next >
C/C++ Source or Header  |  1996-08-28  |  65KB  |  2,479 lines
  1. /* A lexical scanner generated by flex */
  2.  
  3. /* Scanner skeleton version:
  4.  * $Header: /home/daffy/u0/vern/flex/RCS/flex.skl,v 2.85 95/04/24 10:48:47 vern Exp $
  5.  */
  6.  
  7. #define FLEX_SCANNER
  8. #define YY_FLEX_MAJOR_VERSION 2
  9. #define YY_FLEX_MINOR_VERSION 5
  10.  
  11. #include <stdio.h>
  12.  
  13.  
  14. /* cfront 1.2 defines "c_plusplus" instead of "__cplusplus" */
  15. #ifdef c_plusplus
  16. #ifndef __cplusplus
  17. #define __cplusplus
  18. #endif
  19. #endif
  20.  
  21.  
  22. #ifdef __cplusplus
  23.  
  24. #include <stdlib.h>
  25. #include <unistd.h>
  26.  
  27. /* Use prototypes in function declarations. */
  28. #define YY_USE_PROTOS
  29.  
  30. /* The "const" storage-class-modifier is valid. */
  31. #define YY_USE_CONST
  32.  
  33. #else    /* ! __cplusplus */
  34.  
  35. #if __STDC__
  36.  
  37. #define YY_USE_PROTOS
  38. #define YY_USE_CONST
  39.  
  40. #endif    /* __STDC__ */
  41. #endif    /* ! __cplusplus */
  42.  
  43. #ifdef __TURBOC__
  44.  #pragma warn -rch
  45.  #pragma warn -use
  46. #include <io.h>
  47. #include <stdlib.h>
  48. #define YY_USE_CONST
  49. #define YY_USE_PROTOS
  50. #endif
  51.  
  52. #ifdef YY_USE_CONST
  53. #define yyconst const
  54. #else
  55. #define yyconst
  56. #endif
  57.  
  58.  
  59. #ifdef YY_USE_PROTOS
  60. #define YY_PROTO(proto) proto
  61. #else
  62. #define YY_PROTO(proto) ()
  63. #endif
  64.  
  65. /* Returned upon end-of-file. */
  66. #define YY_NULL 0
  67.  
  68. /* Promotes a possibly negative, possibly signed char to an unsigned
  69.  * integer for use as an array index.  If the signed char is negative,
  70.  * we want to instead treat it as an 8-bit unsigned char, hence the
  71.  * double cast.
  72.  */
  73. #define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c)
  74.  
  75. /* Enter a start condition.  This macro really ought to take a parameter,
  76.  * but we do it the disgusting crufty way forced on us by the ()-less
  77.  * definition of BEGIN.
  78.  */
  79. #define BEGIN yy_start = 1 + 2 *
  80.  
  81. /* Translate the current start state into a value that can be later handed
  82.  * to BEGIN to return to the state.  The YYSTATE alias is for lex
  83.  * compatibility.
  84.  */
  85. #define YY_START ((yy_start - 1) / 2)
  86. #define YYSTATE YY_START
  87.  
  88. /* Action number for EOF rule of a given start state. */
  89. #define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
  90.  
  91. /* Special action meaning "start processing a new file". */
  92. #define YY_NEW_FILE yyrestart( yyin )
  93.  
  94. #define YY_END_OF_BUFFER_CHAR 0
  95.  
  96. /* Size of default input buffer. */
  97. #define YY_BUF_SIZE 16384
  98.  
  99. typedef struct yy_buffer_state *YY_BUFFER_STATE;
  100.  
  101. extern int yyleng;
  102. extern FILE *yyin, *yyout;
  103.  
  104. #define EOB_ACT_CONTINUE_SCAN 0
  105. #define EOB_ACT_END_OF_FILE 1
  106. #define EOB_ACT_LAST_MATCH 2
  107.  
  108. /* The funky do-while in the following #define is used to turn the definition
  109.  * int a single C statement (which needs a semi-colon terminator).  This
  110.  * avoids problems with code like:
  111.  *
  112.  *     if ( condition_holds )
  113.  *        yyless( 5 );
  114.  *    else
  115.  *        do_something_else();
  116.  *
  117.  * Prior to using the do-while the compiler would get upset at the
  118.  * "else" because it interpreted the "if" statement as being all
  119.  * done when it reached the ';' after the yyless() call.
  120.  */
  121.  
  122. /* Return all but the first 'n' matched characters back to the input stream. */
  123.  
  124. #define yyless(n) \
  125.     do \
  126.         { \
  127.         /* Undo effects of setting up yytext. */ \
  128.         *yy_cp = yy_hold_char; \
  129.         yy_c_buf_p = yy_cp = yy_bp + n - YY_MORE_ADJ; \
  130.         YY_DO_BEFORE_ACTION; /* set up yytext again */ \
  131.         } \
  132.     while ( 0 )
  133.  
  134. #define unput(c) yyunput( c, yytext_ptr )
  135.  
  136. /* The following is because we cannot portably get our hands on size_t
  137.  * (without autoconf's help, which isn't available because we want
  138.  * flex-generated scanners to compile on their own).
  139.  */
  140. typedef unsigned int yy_size_t;
  141.  
  142.  
  143. struct yy_buffer_state
  144.     {
  145.     FILE *yy_input_file;
  146.  
  147.     char *yy_ch_buf;        /* input buffer */
  148.     char *yy_buf_pos;        /* current position in input buffer */
  149.  
  150.     /* Size of input buffer in bytes, not including room for EOB
  151.      * characters.
  152.      */
  153.     yy_size_t yy_buf_size;
  154.  
  155.     /* Number of characters read into yy_ch_buf, not including EOB
  156.      * characters.
  157.      */
  158.     int yy_n_chars;
  159.  
  160.     /* Whether we "own" the buffer - i.e., we know we created it,
  161.      * and can realloc() it to grow it, and should free() it to
  162.      * delete it.
  163.      */
  164.     int yy_is_our_buffer;
  165.  
  166.     /* Whether this is an "interactive" input source; if so, and
  167.      * if we're using stdio for input, then we want to use getc()
  168.      * instead of fread(), to make sure we stop fetching input after
  169.      * each newline.
  170.      */
  171.     int yy_is_interactive;
  172.  
  173.     /* Whether we're considered to be at the beginning of a line.
  174.      * If so, '^' rules will be active on the next match, otherwise
  175.      * not.
  176.      */
  177.     int yy_at_bol;
  178.  
  179.     /* Whether to try to fill the input buffer when we reach the
  180.      * end of it.
  181.      */
  182.     int yy_fill_buffer;
  183.  
  184.     int yy_buffer_status;
  185. #define YY_BUFFER_NEW 0
  186. #define YY_BUFFER_NORMAL 1
  187.     /* When an EOF's been seen but there's still some text to process
  188.      * then we mark the buffer as YY_EOF_PENDING, to indicate that we
  189.      * shouldn't try reading from the input source any more.  We might
  190.      * still have a bunch of tokens to match, though, because of
  191.      * possible backing-up.
  192.      *
  193.      * When we actually see the EOF, we change the status to "new"
  194.      * (via yyrestart()), so that the user can continue scanning by
  195.      * just pointing yyin at a new input file.
  196.      */
  197. #define YY_BUFFER_EOF_PENDING 2
  198.     };
  199.  
  200. static YY_BUFFER_STATE yy_current_buffer = 0;
  201.  
  202. /* We provide macros for accessing buffer states in case in the
  203.  * future we want to put the buffer states in a more general
  204.  * "scanner state".
  205.  */
  206. #define YY_CURRENT_BUFFER yy_current_buffer
  207.  
  208.  
  209. /* yy_hold_char holds the character lost when yytext is formed. */
  210. static char yy_hold_char;
  211.  
  212. static int yy_n_chars;        /* number of characters read into yy_ch_buf */
  213.  
  214.  
  215. int yyleng;
  216.  
  217. /* Points to current character in buffer. */
  218. static char *yy_c_buf_p = (char *) 0;
  219. static int yy_init = 1;        /* whether we need to initialize */
  220. static int yy_start = 0;    /* start state number */
  221.  
  222. /* Flag which is used to allow yywrap()'s to do buffer switches
  223.  * instead of setting up a fresh yyin.  A bit of a hack ...
  224.  */
  225. static int yy_did_buffer_switch_on_eof;
  226.  
  227. void yyrestart YY_PROTO(( FILE *input_file ));
  228.  
  229. void yy_switch_to_buffer YY_PROTO(( YY_BUFFER_STATE new_buffer ));
  230. void yy_load_buffer_state YY_PROTO(( void ));
  231. YY_BUFFER_STATE yy_create_buffer YY_PROTO(( FILE *file, int size ));
  232. void yy_delete_buffer YY_PROTO(( YY_BUFFER_STATE b ));
  233. void yy_init_buffer YY_PROTO(( YY_BUFFER_STATE b, FILE *file ));
  234. void yy_flush_buffer YY_PROTO(( YY_BUFFER_STATE b ));
  235. #define YY_FLUSH_BUFFER yy_flush_buffer( yy_current_buffer )
  236.  
  237. YY_BUFFER_STATE yy_scan_buffer YY_PROTO(( char *base, yy_size_t size ));
  238. YY_BUFFER_STATE yy_scan_string YY_PROTO(( yyconst char *str ));
  239. YY_BUFFER_STATE yy_scan_bytes YY_PROTO(( yyconst char *bytes, int len ));
  240.  
  241. static void *yy_flex_alloc YY_PROTO(( yy_size_t ));
  242. static void *yy_flex_realloc YY_PROTO(( void *, yy_size_t ));
  243. static void yy_flex_free YY_PROTO(( void * ));
  244.  
  245. #define yy_new_buffer yy_create_buffer
  246.  
  247. #define yy_set_interactive(is_interactive) \
  248.     { \
  249.     if ( ! yy_current_buffer ) \
  250.         yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); \
  251.     yy_current_buffer->yy_is_interactive = is_interactive; \
  252.     }
  253.  
  254. #define yy_set_bol(at_bol) \
  255.     { \
  256.     if ( ! yy_current_buffer ) \
  257.         yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); \
  258.     yy_current_buffer->yy_at_bol = at_bol; \
  259.     }
  260.  
  261. #define YY_AT_BOL() (yy_current_buffer->yy_at_bol)
  262.  
  263.  
  264. #define YY_USES_REJECT
  265. typedef unsigned char YY_CHAR;
  266. FILE *yyin = (FILE *) 0, *yyout = (FILE *) 0;
  267. typedef int yy_state_type;
  268. extern int yylineno;
  269. int yylineno = 1;
  270. extern char *yytext;
  271. #define yytext_ptr yytext
  272.  
  273. static yy_state_type yy_get_previous_state YY_PROTO(( void ));
  274. static yy_state_type yy_try_NUL_trans YY_PROTO(( yy_state_type current_state ));
  275. static int yy_get_next_buffer YY_PROTO(( void ));
  276. static void yy_fatal_error YY_PROTO(( yyconst char msg[] ));
  277.  
  278. /* Done after the current pattern has been matched and before the
  279.  * corresponding action - sets up yytext.
  280.  */
  281. #define YY_DO_BEFORE_ACTION \
  282.     yytext_ptr = yy_bp; \
  283.     yyleng = (int) (yy_cp - yy_bp); \
  284.     yy_hold_char = *yy_cp; \
  285.     *yy_cp = '\0'; \
  286.     yy_c_buf_p = yy_cp;
  287.  
  288. #define YY_NUM_RULES 19
  289. #define YY_END_OF_BUFFER 20
  290. static yyconst short int yy_acclist[26] =
  291.     {   0,
  292.        20,   18,   19,   19,   18,   19,   18,   19,    1,   12,
  293.         4,   16,   10,    8,    6,    2,   13,    5,   14,   17,
  294.        11,    9,    7,    3,   15
  295.     } ;
  296.  
  297. static yyconst short int yy_accept[177] =
  298.     {   0,
  299.         1,    1,    1,    1,    1,    2,    4,    5,    7,    9,
  300.         9,    9,    9,   10,   10,   10,   10,   10,   10,   10,
  301.        10,   10,   10,   10,   10,   10,   10,   10,   10,   10,
  302.        10,   10,   10,   10,   10,   10,   10,   10,   10,   10,
  303.        10,   10,   10,   10,   10,   10,   10,   10,   10,   10,
  304.        10,   10,   10,   11,   11,   11,   11,   11,   11,   11,
  305.        11,   11,   11,   12,   12,   12,   12,   12,   12,   12,
  306.        12,   12,   13,   13,   14,   15,   15,   15,   15,   15,
  307.        15,   15,   15,   15,   15,   15,   16,   16,   16,   16,
  308.        16,   16,   17,   17,   17,   17,   17,   17,   17,   17,
  309.  
  310.        17,   17,   17,   17,   17,   17,   17,   17,   17,   17,
  311.        17,   17,   17,   17,   17,   17,   17,   17,   17,   17,
  312.        17,   17,   17,   17,   17,   17,   17,   17,   17,   17,
  313.        17,   17,   17,   17,   18,   18,   18,   18,   18,   18,
  314.        18,   18,   18,   18,   19,   19,   19,   20,   20,   20,
  315.        20,   20,   20,   20,   21,   21,   22,   23,   23,   23,
  316.        23,   23,   23,   23,   24,   24,   25,   25,   25,   25,
  317.        25,   25,   25,   25,   26,   26
  318.     } ;
  319.  
  320. static yyconst int yy_ec[256] =
  321.     {   0,
  322.         1,    1,    1,    1,    1,    1,    1,    1,    2,    3,
  323.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  324.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  325.         1,    4,    5,    5,    5,    5,    5,    5,    5,    5,
  326.         5,    6,    5,    5,    5,    5,    5,    5,    5,    5,
  327.         5,    5,    5,    5,    5,    5,    5,    5,    5,    5,
  328.         5,    5,    5,    5,    7,    8,    9,   10,   11,    5,
  329.        12,   13,   14,    5,    5,   15,   16,   17,   18,   19,
  330.         5,   20,   21,   22,   23,    5,    5,   24,    5,    5,
  331.         5,    5,    5,    5,    5,    5,    7,    8,    9,   10,
  332.  
  333.        11,    5,   12,   13,   14,    5,    5,   15,   16,   17,
  334.        18,   19,    5,   20,   21,   22,   23,    5,    5,   24,
  335.         5,    5,    5,    5,    5,    5,    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,    1,    1,    1,    1,    1,
  340.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  341.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  342.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  343.  
  344.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  345.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  346.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  347.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  348.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  349.         1,    1,    1,    1,    1
  350.     } ;
  351.  
  352. static yyconst int yy_meta[25] =
  353.     {   0,
  354.         1,    2,    3,    4,    5,    5,    5,    5,    5,    5,
  355.         5,    5,    5,    5,    5,    5,    5,    5,    5,    5,
  356.         5,    5,    5,    5
  357.     } ;
  358.  
  359. static yyconst short int yy_base[203] =
  360.     {   0,
  361.       287,    0,    0,    0,  289,  291,  291,  284,    0,  283,
  362.       283,  281,  291,  280,  279,    6,    0,    0,  264,  264,
  363.       262,  272,  267,  270,  260,  252,  252,  261,  252,  264,
  364.       250,    3,  261,  257,  253,  259,  250,  257,  245,  247,
  365.       246,  248,  250,  242,    0,  248,  239,  244,  243,  242,
  366.       245,  240,  247,  227,    0,  224,  243,  226,  230,  222,
  367.       239,  231,  238,    0,  221,    0,    0,  228,  234,  217,
  368.       232,  232,  214,  230,  229,  211,  226,    0,  225,  224,
  369.       216,  222,  221,    0,  220,  220,  218,  217,  211,  215,
  370.       214,  214,  212,  211,  210,  209,  198,  207,  206,  205,
  371.  
  372.         0,  204,  203,  202,  184,  200,  199,  198,    3,  197,
  373.         0,  196,  185,  194,  191,  188,   10,  182,   25,    0,
  374.       164,    0,    0,  175,   28,   21,  169,   31,   32,  152,
  375.        35,   36,  159,  156,    0,   39,   42,   44,    0,   45,
  376.        48,    0,   49,  150,   52,   55,  148,   57,   60,   62,
  377.        65,   67,   68,  142,  137,  131,  128,   71,   74,   77,
  378.       123,   79,   82,  103,   70,   24,   13,    7,    0,   84,
  379.        85,   88,   91,    4,  291,   94,   99,  104,  106,  108,
  380.       110,  112,  114,  116,  118,  123,  128,  132,  137,  142,
  381.       147,  151,  156,  160,  162,  166,  170,  175,  179,  183,
  382.  
  383.       188,  192
  384.     } ;
  385.  
  386. static yyconst short int yy_def[203] =
  387.     {   0,
  388.       176,  176,  177,  177,  175,  175,  175,  175,  178,  175,
  389.       178,  175,  175,  175,  175,  175,   16,  175,  175,  175,
  390.       175,  175,  175,  175,  175,  175,  175,  175,  175,  175,
  391.       175,  175,  175,  175,  175,  175,  175,  175,  175,  175,
  392.       175,  175,  175,  175,  179,  175,  175,  175,  175,  175,
  393.       175,  175,  179,  175,  180,  175,  175,  175,  175,  175,
  394.       175,  175,  180,  181,  175,  182,  183,  175,  175,  175,
  395.       175,  181,  175,  182,  183,  175,  175,  184,  175,  175,
  396.       175,  175,  175,  185,  175,  184,  175,  175,  175,  175,
  397.       175,  185,  175,  175,  175,  175,  175,  175,  175,  175,
  398.  
  399.       186,  175,  175,  175,  175,  175,  175,  175,  175,  175,
  400.       187,  175,  175,  175,  175,  175,  188,  175,  175,  189,
  401.       175,  190,  191,  175,  188,  188,  175,  192,  175,  175,
  402.       175,  175,  175,  175,  193,  192,  192,  194,  195,  196,
  403.       197,  198,  175,  175,  194,  194,  195,  196,  196,  197,
  404.       197,  175,  199,  175,  175,  175,  175,  200,  199,  199,
  405.       175,  200,  200,  175,  175,  175,  175,  175,  201,  175,
  406.       202,  202,  202,  175,    0,  175,  175,  175,  175,  175,
  407.       175,  175,  175,  175,  175,  175,  175,  175,  175,  175,
  408.       175,  175,  175,  175,  175,  175,  175,  175,  175,  175,
  409.  
  410.       175,  175
  411.     } ;
  412.  
  413. static yyconst short int yy_nxt[316] =
  414.     {   0,
  415.       175,  175,    7,    8,  117,    9,  117,  161,    9,   17,
  416.       169,  117,   24,  125,   18,   19,  168,   25,   39,   20,
  417.        21,   40,  175,  134,   22,   23,  128,  108,  128,  117,
  418.       134,  125,  128,  138,  136,  138,  140,  141,  140,  141,
  419.       128,  144,  136,  175,  144,  138,  140,  145,  148,  141,
  420.       153,  150,  153,  138,  154,  145,  175,  154,  140,  156,
  421.       148,  175,  156,  141,  157,  150,  175,  157,  158,  153,
  422.       158,  159,  158,  167,  162,  153,  164,  159,  175,  164,
  423.       158,  166,  162,  175,  166,  171,  171,  171,  172,  171,
  424.       174,  172,  175,  174,    6,    6,    6,    6,    6,    7,
  425.  
  426.         7,    7,    7,    7,   11,   11,  102,   11,   11,   53,
  427.        53,   63,   63,   72,   72,   74,   74,   75,   75,   86,
  428.        86,   92,   92,  109,  109,  109,  165,  109,  119,  119,
  429.       119,   91,  119,  126,   90,  126,  126,  129,  129,  129,
  430.       161,  129,  131,  131,  131,   88,  131,  132,  132,  132,
  431.       155,  132,  137,   79,  137,  137,  143,  143,  143,   69,
  432.       143,  146,  142,  146,  146,  147,  147,  149,  139,  149,
  433.       149,  151,  135,  151,  151,  152,  152,  152,  133,  152,
  434.       160,  130,  160,  160,  163,  127,  163,  163,  170,  170,
  435.       170,  124,  170,  173,  123,  173,  173,  122,  121,  120,
  436.  
  437.       118,  116,  115,  114,  113,  112,  111,  110,  108,  107,
  438.       106,  105,  104,  103,  102,  101,  100,   99,   98,   97,
  439.        96,   95,   94,   93,   91,   90,   89,   88,   87,   85,
  440.        84,   83,   82,   81,   80,   79,   78,   77,   76,   73,
  441.        71,   70,   69,   68,   67,   66,   65,   64,   62,   61,
  442.        60,   59,   58,   57,   56,   55,   54,   52,   51,   50,
  443.        49,   48,   47,   46,   45,   44,   43,   42,   41,   38,
  444.        37,   36,   35,   34,   33,   32,   31,   30,   29,   28,
  445.        27,   26,   16,   15,   14,   13,   12,   10,  175,    7,
  446.         5,  175,  175,  175,  175,  175,  175,  175,  175,  175,
  447.  
  448.       175,  175,  175,  175,  175,  175,  175,  175,  175,  175,
  449.       175,  175,  175,  175,  175
  450.     } ;
  451.  
  452. static yyconst short int yy_chk[316] =
  453.     {   0,
  454.         0,    0,    2,    2,  109,    2,  109,  174,    2,   16,
  455.       168,  117,   18,  117,   16,   16,  167,   18,   32,   16,
  456.        16,   32,  126,  126,   16,   16,  119,  166,  119,  125,
  457.       125,  125,  128,  129,  128,  129,  131,  132,  131,  132,
  458.       136,  136,  136,  137,  137,  138,  140,  138,  140,  141,
  459.       143,  141,  143,  145,  145,  145,  146,  146,  148,  148,
  460.       148,  149,  149,  150,  150,  150,  151,  151,  152,  153,
  461.       152,  153,  158,  165,  158,  159,  159,  159,  160,  160,
  462.       162,  162,  162,  163,  163,  170,  171,  170,  171,  172,
  463.       172,  172,  173,  173,  176,  176,  176,  176,  176,  177,
  464.  
  465.       177,  177,  177,  177,  178,  178,  164,  178,  178,  179,
  466.       179,  180,  180,  181,  181,  182,  182,  183,  183,  184,
  467.       184,  185,  185,  186,  186,  186,  161,  186,  187,  187,
  468.       187,  157,  187,  188,  156,  188,  188,  189,  189,  189,
  469.       155,  189,  190,  190,  190,  154,  190,  191,  191,  191,
  470.       147,  191,  192,  144,  192,  192,  193,  193,  193,  134,
  471.       193,  194,  133,  194,  194,  195,  195,  196,  130,  196,
  472.       196,  197,  127,  197,  197,  198,  198,  198,  124,  198,
  473.       199,  121,  199,  199,  200,  118,  200,  200,  201,  201,
  474.       201,  116,  201,  202,  115,  202,  202,  114,  113,  112,
  475.  
  476.       110,  108,  107,  106,  105,  104,  103,  102,  100,   99,
  477.        98,   97,   96,   95,   94,   93,   92,   91,   90,   89,
  478.        88,   87,   86,   85,   83,   82,   81,   80,   79,   77,
  479.        76,   75,   74,   73,   72,   71,   70,   69,   68,   65,
  480.        63,   62,   61,   60,   59,   58,   57,   56,   54,   53,
  481.        52,   51,   50,   49,   48,   47,   46,   44,   43,   42,
  482.        41,   40,   39,   38,   37,   36,   35,   34,   33,   31,
  483.        30,   29,   28,   27,   26,   25,   24,   23,   22,   21,
  484.        20,   19,   15,   14,   12,   11,   10,    8,    5,    1,
  485.       175,  175,  175,  175,  175,  175,  175,  175,  175,  175,
  486.  
  487.       175,  175,  175,  175,  175,  175,  175,  175,  175,  175,
  488.       175,  175,  175,  175,  175
  489.     } ;
  490.  
  491. static yy_state_type yy_state_buf[YY_BUF_SIZE + 2], *yy_state_ptr;
  492. static char *yy_full_match;
  493. static int yy_lp;
  494. #define REJECT \
  495. { \
  496. *yy_cp = yy_hold_char; /* undo effects of setting up yytext */ \
  497. yy_cp = yy_full_match; /* restore poss. backed-over text */ \
  498. ++yy_lp; \
  499. goto find_rule; \
  500. }
  501. #define yymore() yymore_used_but_not_detected
  502. #define YY_MORE_ADJ 0
  503. char *yytext;
  504. #line 1 "scan_commons.l"
  505. #define INITIAL 0
  506. #line 2 "scan_commons.l"
  507. #ifndef lint
  508. static char rcsId[]="$Header: /usr/local/rcs/ForUtil/Commons/RCS/scan_commons.l,v 1.9 1996/08/28 17:44:20 koen Exp koen $";
  509. #endif
  510. /*****
  511. * scan_commons.l : database builder for stuff defined in common blocks
  512. *
  513. * This file Version    $Revision: 1.9 $
  514. *
  515. * Creation date:    Fri Mar 15 18:02:11 GMT+0100 1996
  516. * Last modification:     $Date: 1996/08/28 17:44:20 $
  517. * By:            $Author: koen $
  518. * Current State:    $State: Exp $
  519. *
  520. * Author:        koen
  521. * (C)Copyright 1995-1996 Ripley Software Development
  522. * All Rights Reserved
  523. *
  524. * This program has three undocumented switches for debugging purposes:
  525. * -c: dump core on errors
  526. * -t: do not install signal traps, needed for debugging
  527. * -m for memory information under msdos
  528. *****/
  529. /*****
  530. * ChangeLog 
  531. * $Log: scan_commons.l,v $
  532. * Revision 1.9  1996/08/28 17:44:20  koen
  533. * Added print_version_id
  534. *
  535. * Revision 1.8  1996/08/27 19:13:29  koen
  536. * Changed scanner routines to support scanning of source files.
  537. *
  538. * Revision 1.7  1996/08/07 21:11:04  koen
  539. * Updated the rules and added a rule for PARAMETER
  540. *
  541. * Revision 1.6  1996/08/02 14:49:29  koen
  542. * moved all system dependencies to lib/sysdeps.h
  543. *
  544. * Revision 1.5  1996/07/30 01:58:16  koen
  545. * Changed rule for common blocks to use every possible char as a 
  546. * continuation character. 
  547. * Implemented the ignore_this_file routine. 
  548. * Reorganized output stuff and command line handling. 
  549. * Added version information.
  550. *
  551. * Revision 1.4  1996/07/16 00:38:14  koen
  552. * minor (cosmetic) changes.
  553. *
  554. * Revision 1.3  1996/05/06 00:33:02  koen
  555. * Adapted for MSDOS. Added some showing of files to scan when -v is used.
  556. *
  557. * Revision 1.2  1996/04/25 02:27:04  koen
  558. * Cleanup and comments added.
  559. *
  560. * Revision 1.1  1996/03/15 04:16:42  koen
  561. * Initial Revision
  562. *
  563. *****/ 
  564. #ifdef HAVE_CONFIG_H
  565. #include "autoconf.h"
  566. #endif
  567.  
  568. #include <signal.h>
  569.  
  570. #include "lib_commons.h"
  571. #include "forutil.h"
  572. #include "memmacros.h"
  573. #include "version.h"
  574.  
  575. #define MAXDIRS        64
  576. #define MAXIGNORE    64
  577. #define MAXEXTS        8
  578.  
  579. #define YY_EXIT_FAILURE    13
  580.  
  581. /****
  582. * Local variables
  583. ****/
  584. datum content;
  585. int verbose;
  586. static char progname[32];
  587. static int quiet, full_names, replace, dump_core, no_signal;
  588. static int num_total, num_total_accepted, num_total_rejected;
  589. static int num_total_replaced, num_total_stored;
  590. static int num_common_total, num_common_rejected, num_common_accepted;
  591. static int num_common_replaced, num_common_stored, fast;
  592. static int reorganize, curr_file_num, ign_file_num;
  593. static char *outfile;
  594. static char curr_path[512], curr_file[128];
  595. static int num_dirs_to_visit, num_extensions, num_ignore;
  596. static char *dirs_to_visit[MAXDIRS];
  597. static char *ext_table[MAXEXTS];
  598. static char *ignore_list[MAXIGNORE];
  599.  
  600. int num_files;
  601. static int num_warnings, num_errors;
  602. char **file_list;
  603.  
  604. #ifdef __MSDOS__
  605. unsigned long dir_mem, ext_mem, file_mem, ign_mem;
  606. static int need_mem_info_for_msdos;
  607. #endif
  608.  
  609. /* the database file */
  610. static GDBM_FILE db_file;
  611.  
  612. /****
  613. * Local function prototypes
  614. ****/
  615. static void get_common_contents(char *text);
  616.  
  617. static void (*gdbm_proto_func)();    /* generic gdbm insertion proto */
  618. static void replace_item(datum key);    /* replace & update an item */
  619. static void insert_item(datum key);    /* insert an item */
  620.  
  621. static char *usage = {"Usage: %s [-afhqrsv] [-Eext] [-Idir] [-ddatabase] [-xname] [files]\n\n"
  622. " Scan f77 include files for commons and stores them for use with get_common\n"
  623. "\n Options:\n"
  624. "\t-a: add instead of rejecting duplicate commons in different files\n"
  625. "\t-f: Store filenames only. Default is full filenames.\n"
  626. "\t-h, --help: print this help\n"
  627. "\t-q: be really quiet (usefull if called from a script)\n"
  628. "\t-r: re-organize after updating. This may take a _long_ time.\n"
  629. "\t-s: safe operation, resync database after each update (safe but slower)\n"
  630. "\t-v: verbose\n"
  631. "\t--version: display version number\n"
  632. "\t-E[ext] : extensions to use when searching files. Multiple -E allowed\n"
  633. "\t          Use -E- to specify no extension.\n"
  634. "\t-I[dir] : get files from directory dir. Multiple -I allowed\n"
  635. "\t-d[database]: name of database to create/update\n"
  636. "\t-x[name]: name of file to ignore when scanning directories\n"
  637. " Using -f can help reduce the size of the created database.\n"
  638. " To automate updates, scan_commons looks at the value of the environment\n"
  639. " variable COMMON_DATABASE if no database is given.\n\n"
  640. "(C)Copyright 1995-1996 by Ripley Software Development\n"};
  641.  
  642. /****
  643. * A Note on the regular expressions used.
  644. *
  645. * We scan for a number of defined types in common include files.
  646. * (common, character, real and logical)
  647. * The scanning sequence is as follows:
  648. * 1. A scan is made for lines containing the COMMON, LOGICAL, REAL,
  649. *    DOUBLE, COMPLEX and CHARACTER keywords. These lines must begin with
  650. *    at least 6 spaces and must be followed by characters defining that param.
  651. *    The contents of the text found are scanned for ``real'' definitions by 
  652. *    get_common_contents
  653. * 
  654. * 2. When step 1 is complete, a further scan is done to see if the
  655. *    common block found has continuation lines, identified by the 
  656. *    BEGIN GETBLOCK statement. 
  657. *    All lines following any of the keywords mentioned above that begin
  658. *    with five spaces and a continuation character contain additional
  659. *    contents of that parameter block and are picked up by the scanner.
  660. *
  661. * The ``+'' after both regexp tells lex it must match one or more of these
  662. * regular expressions. 
  663. *****/
  664. #define GETBLOCK 1
  665.  
  666. #line 667 "lex.yy.c"
  667.  
  668. /* Macros after this point can all be overridden by user definitions in
  669.  * section 1.
  670.  */
  671.  
  672. #ifndef YY_SKIP_YYWRAP
  673. #ifdef __cplusplus
  674. extern "C" int yywrap YY_PROTO(( void ));
  675. #else
  676. extern int yywrap YY_PROTO(( void ));
  677. #endif
  678. #endif
  679.  
  680. #ifndef YY_NO_UNPUT
  681. static void yyunput YY_PROTO(( int c, char *buf_ptr ));
  682. #endif
  683.  
  684. #ifndef yytext_ptr
  685. static void yy_flex_strncpy YY_PROTO(( char *, yyconst char *, int ));
  686. #endif
  687.  
  688. #ifndef YY_NO_INPUT
  689. #ifdef __cplusplus
  690. static int yyinput YY_PROTO(( void ));
  691. #else
  692. static int input YY_PROTO(( void ));
  693. #endif
  694. #endif
  695.  
  696. #if YY_STACK_USED
  697. static int yy_start_stack_ptr = 0;
  698. static int yy_start_stack_depth = 0;
  699. static int *yy_start_stack = 0;
  700. #ifndef YY_NO_PUSH_STATE
  701. static void yy_push_state YY_PROTO(( int new_state ));
  702. #endif
  703. #ifndef YY_NO_POP_STATE
  704. static void yy_pop_state YY_PROTO(( void ));
  705. #endif
  706. #ifndef YY_NO_TOP_STATE
  707. static int yy_top_state YY_PROTO(( void ));
  708. #endif
  709.  
  710. #else
  711. #define YY_NO_PUSH_STATE 1
  712. #define YY_NO_POP_STATE 1
  713. #define YY_NO_TOP_STATE 1
  714. #endif
  715.  
  716. #ifdef YY_MALLOC_DECL
  717. YY_MALLOC_DECL
  718. #else
  719. #if __STDC__
  720. #ifndef __cplusplus
  721. #include <stdlib.h>
  722. #endif
  723. #else
  724. /* Just try to get by without declaring the routines.  This will fail
  725.  * miserably on non-ANSI systems for which sizeof(size_t) != sizeof(int)
  726.  * or sizeof(void*) != sizeof(int).
  727.  */
  728. #endif
  729. #endif
  730.  
  731. /* Amount of stuff to slurp up with each read. */
  732. #ifndef YY_READ_BUF_SIZE
  733. #define YY_READ_BUF_SIZE 8192
  734. #endif
  735.  
  736. /* Copy whatever the last rule matched to the standard output. */
  737.  
  738. #ifndef ECHO
  739. /* This used to be an fputs(), but since the string might contain NUL's,
  740.  * we now use fwrite().
  741.  */
  742. #define ECHO (void) fwrite( yytext, yyleng, 1, yyout )
  743. #endif
  744.  
  745. /* Gets input and stuffs it into "buf".  number of characters read, or YY_NULL,
  746.  * is returned in "result".
  747.  */
  748. #ifndef YY_INPUT
  749. #define YY_INPUT(buf,result,max_size) \
  750.     if ( yy_current_buffer->yy_is_interactive ) \
  751.         { \
  752.         int c = '*', n; \
  753.         for ( n = 0; n < max_size && \
  754.                  (c = getc( yyin )) != EOF && c != '\n'; ++n ) \
  755.             buf[n] = (char) c; \
  756.         if ( c == '\n' ) \
  757.             buf[n++] = (char) c; \
  758.         if ( c == EOF && ferror( yyin ) ) \
  759.             YY_FATAL_ERROR( "input in flex scanner failed" ); \
  760.         result = n; \
  761.         } \
  762.     else if ( ((result = fread( buf, 1, max_size, yyin )) == 0) \
  763.           && ferror( yyin ) ) \
  764.         YY_FATAL_ERROR( "input in flex scanner failed" );
  765. #endif
  766.  
  767. /* No semi-colon after return; correct usage is to write "yyterminate();" -
  768.  * we don't want an extra ';' after the "return" because that will cause
  769.  * some compilers to complain about unreachable statements.
  770.  */
  771. #ifndef yyterminate
  772. #define yyterminate() return YY_NULL
  773. #endif
  774.  
  775. /* Number of entries by which start-condition stack grows. */
  776. #ifndef YY_START_STACK_INCR
  777. #define YY_START_STACK_INCR 25
  778. #endif
  779.  
  780. /* Report a fatal error. */
  781. #ifndef YY_FATAL_ERROR
  782. #define YY_FATAL_ERROR(msg) yy_fatal_error( msg )
  783. #endif
  784.  
  785. /* Default declaration of generated scanner - a define so the user can
  786.  * easily add parameters.
  787.  */
  788. #ifndef YY_DECL
  789. #define YY_DECL int yylex YY_PROTO(( void ))
  790. #endif
  791.  
  792. /* Code executed at the beginning of each rule, after yytext and yyleng
  793.  * have been set up.
  794.  */
  795. #ifndef YY_USER_ACTION
  796. #define YY_USER_ACTION
  797. #endif
  798.  
  799. /* Code executed at the end of each rule. */
  800. #ifndef YY_BREAK
  801. #define YY_BREAK break;
  802. #endif
  803.  
  804. #define YY_RULE_SETUP \
  805.     if ( yyleng > 0 ) \
  806.         yy_current_buffer->yy_at_bol = \
  807.                 (yytext[yyleng - 1] == '\n'); \
  808.     YY_USER_ACTION
  809.  
  810. YY_DECL
  811.     {
  812.     register yy_state_type yy_current_state;
  813.     register char *yy_cp, *yy_bp;
  814.     register int yy_act;
  815.  
  816. #line 177 "scan_commons.l"
  817.  
  818. #line 819 "lex.yy.c"
  819.  
  820.     if ( yy_init )
  821.         {
  822.         yy_init = 0;
  823.  
  824. #ifdef YY_USER_INIT
  825.         YY_USER_INIT;
  826. #endif
  827.  
  828.         if ( ! yy_start )
  829.             yy_start = 1;    /* first start state */
  830.  
  831.         if ( ! yyin )
  832.             yyin = stdin;
  833.  
  834.         if ( ! yyout )
  835.             yyout = stdout;
  836.  
  837.         if ( ! yy_current_buffer )
  838.             yy_current_buffer =
  839.                 yy_create_buffer( yyin, YY_BUF_SIZE );
  840.  
  841.         yy_load_buffer_state();
  842.         }
  843.  
  844.     while ( 1 )        /* loops until end-of-file is reached */
  845.         {
  846.         yy_cp = yy_c_buf_p;
  847.  
  848.         /* Support of yytext. */
  849.         *yy_cp = yy_hold_char;
  850.  
  851.         /* yy_bp points to the position in yy_ch_buf of the start of
  852.          * the current run.
  853.          */
  854.         yy_bp = yy_cp;
  855.  
  856.         yy_current_state = yy_start;
  857.         yy_current_state += YY_AT_BOL();
  858.         yy_state_ptr = yy_state_buf;
  859.         *yy_state_ptr++ = yy_current_state;
  860. yy_match:
  861.         do
  862.             {
  863.             register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)];
  864.             while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
  865.                 {
  866.                 yy_current_state = (int) yy_def[yy_current_state];
  867.                 if ( yy_current_state >= 176 )
  868.                     yy_c = yy_meta[(unsigned int) yy_c];
  869.                 }
  870.             yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
  871.             *yy_state_ptr++ = yy_current_state;
  872.             ++yy_cp;
  873.             }
  874.         while ( yy_base[yy_current_state] != 291 );
  875.  
  876. yy_find_action:
  877.         yy_current_state = *--yy_state_ptr;
  878.         yy_lp = yy_accept[yy_current_state];
  879. find_rule: /* we branch to this label when backing up */
  880.         for ( ; ; ) /* until we find what rule we matched */
  881.             {
  882.             if ( yy_lp && yy_lp < yy_accept[yy_current_state + 1] )
  883.                 {
  884.                 yy_act = yy_acclist[yy_lp];
  885.                     {
  886.                     yy_full_match = yy_cp;
  887.                     break;
  888.                     }
  889.                 }
  890.             --yy_cp;
  891.             yy_current_state = *--yy_state_ptr;
  892.             yy_lp = yy_accept[yy_current_state];
  893.             }
  894.  
  895.         YY_DO_BEFORE_ACTION;
  896.  
  897.         if ( yy_act != YY_END_OF_BUFFER )
  898.             {
  899.             int yyl;
  900.             for ( yyl = 0; yyl < yyleng; ++yyl )
  901.                 if ( yytext[yyl] == '\n' )
  902.                     ++yylineno;
  903.             }
  904.  
  905. do_action:    /* This label is used only to access EOF actions. */
  906.  
  907.  
  908.         switch ( yy_act )
  909.     { /* beginning of action switch */
  910. case 1:
  911. YY_RULE_SETUP
  912. #line 178 "scan_commons.l"
  913. BEGIN(INITIAL);
  914.     YY_BREAK
  915. case 2:
  916. #line 181 "scan_commons.l"
  917. case 3:
  918. YY_RULE_SETUP
  919. #line 181 "scan_commons.l"
  920. {
  921.             get_common_contents(yytext);
  922.             BEGIN 0;
  923.         }
  924.     YY_BREAK
  925. case 4:
  926. #line 186 "scan_commons.l"
  927. case 5:
  928. YY_RULE_SETUP
  929. #line 186 "scan_commons.l"
  930. {
  931.             get_common_contents(yytext);
  932.             BEGIN 0;
  933.         }
  934.     YY_BREAK
  935. case 6:
  936. #line 191 "scan_commons.l"
  937. case 7:
  938. YY_RULE_SETUP
  939. #line 191 "scan_commons.l"
  940. {
  941.             get_common_contents(yytext);
  942.             BEGIN 0;
  943.         }
  944.     YY_BREAK
  945. case 8:
  946. #line 196 "scan_commons.l"
  947. case 9:
  948. YY_RULE_SETUP
  949. #line 196 "scan_commons.l"
  950. {
  951.             get_common_contents(yytext);
  952.             BEGIN 0;
  953.         }
  954.     YY_BREAK
  955. case 10:
  956. #line 201 "scan_commons.l"
  957. case 11:
  958. YY_RULE_SETUP
  959. #line 201 "scan_commons.l"
  960. {
  961.             get_common_contents(yytext);
  962.             BEGIN 0;
  963.         }
  964.     YY_BREAK
  965. case 12:
  966. #line 206 "scan_commons.l"
  967. case 13:
  968. YY_RULE_SETUP
  969. #line 206 "scan_commons.l"
  970. {
  971.             get_common_contents(yytext);
  972.             BEGIN 0;
  973.         }
  974.     YY_BREAK
  975. case 14:
  976. #line 211 "scan_commons.l"
  977. case 15:
  978. YY_RULE_SETUP
  979. #line 211 "scan_commons.l"
  980. {
  981.             get_common_contents(yytext);
  982.             BEGIN 0;
  983.         }
  984.     YY_BREAK
  985. case 16:
  986. #line 216 "scan_commons.l"
  987. case 17:
  988. YY_RULE_SETUP
  989. #line 216 "scan_commons.l"
  990. {
  991.             get_common_contents(yytext);
  992.             BEGIN 0;
  993.         }
  994.     YY_BREAK
  995. case 18:
  996. YY_RULE_SETUP
  997. #line 220 "scan_commons.l"
  998. BEGIN(INITIAL);
  999.     YY_BREAK
  1000. case YY_STATE_EOF(INITIAL):
  1001. case YY_STATE_EOF(GETBLOCK):
  1002. #line 221 "scan_commons.l"
  1003. {
  1004.         yyterminate();
  1005.         }
  1006.     YY_BREAK
  1007. case 19:
  1008. YY_RULE_SETUP
  1009. #line 224 "scan_commons.l"
  1010. ECHO;
  1011.     YY_BREAK
  1012. #line 1013 "lex.yy.c"
  1013.  
  1014.     case YY_END_OF_BUFFER:
  1015.         {
  1016.         /* Amount of text matched not including the EOB char. */
  1017.         int yy_amount_of_matched_text = (int) (yy_cp - yytext_ptr) - 1;
  1018.  
  1019.         /* Undo the effects of YY_DO_BEFORE_ACTION. */
  1020.         *yy_cp = yy_hold_char;
  1021.  
  1022.         if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_NEW )
  1023.             {
  1024.             /* We're scanning a new file or input source.  It's
  1025.              * possible that this happened because the user
  1026.              * just pointed yyin at a new source and called
  1027.              * yylex().  If so, then we have to assure
  1028.              * consistency between yy_current_buffer and our
  1029.              * globals.  Here is the right place to do so, because
  1030.              * this is the first action (other than possibly a
  1031.              * back-up) that will match for the new input source.
  1032.              */
  1033.             yy_n_chars = yy_current_buffer->yy_n_chars;
  1034.             yy_current_buffer->yy_input_file = yyin;
  1035.             yy_current_buffer->yy_buffer_status = YY_BUFFER_NORMAL;
  1036.             }
  1037.  
  1038.         /* Note that here we test for yy_c_buf_p "<=" to the position
  1039.          * of the first EOB in the buffer, since yy_c_buf_p will
  1040.          * already have been incremented past the NUL character
  1041.          * (since all states make transitions on EOB to the
  1042.          * end-of-buffer state).  Contrast this with the test
  1043.          * in input().
  1044.          */
  1045.         if ( yy_c_buf_p <= &yy_current_buffer->yy_ch_buf[yy_n_chars] )
  1046.             { /* This was really a NUL. */
  1047.             yy_state_type yy_next_state;
  1048.  
  1049.             yy_c_buf_p = yytext_ptr + yy_amount_of_matched_text;
  1050.  
  1051.             yy_current_state = yy_get_previous_state();
  1052.  
  1053.             /* Okay, we're now positioned to make the NUL
  1054.              * transition.  We couldn't have
  1055.              * yy_get_previous_state() go ahead and do it
  1056.              * for us because it doesn't know how to deal
  1057.              * with the possibility of jamming (and we don't
  1058.              * want to build jamming into it because then it
  1059.              * will run more slowly).
  1060.              */
  1061.  
  1062.             yy_next_state = yy_try_NUL_trans( yy_current_state );
  1063.  
  1064.             yy_bp = yytext_ptr + YY_MORE_ADJ;
  1065.  
  1066.             if ( yy_next_state )
  1067.                 {
  1068.                 /* Consume the NUL. */
  1069.                 yy_cp = ++yy_c_buf_p;
  1070.                 yy_current_state = yy_next_state;
  1071.                 goto yy_match;
  1072.                 }
  1073.  
  1074.             else
  1075.                 {
  1076.                 yy_cp = yy_c_buf_p;
  1077.                 goto yy_find_action;
  1078.                 }
  1079.             }
  1080.  
  1081.         else switch ( yy_get_next_buffer() )
  1082.             {
  1083.             case EOB_ACT_END_OF_FILE:
  1084.                 {
  1085.                 yy_did_buffer_switch_on_eof = 0;
  1086.  
  1087.                 if ( yywrap() )
  1088.                     {
  1089.                     /* Note: because we've taken care in
  1090.                      * yy_get_next_buffer() to have set up
  1091.                      * yytext, we can now set up
  1092.                      * yy_c_buf_p so that if some total
  1093.                      * hoser (like flex itself) wants to
  1094.                      * call the scanner after we return the
  1095.                      * YY_NULL, it'll still work - another
  1096.                      * YY_NULL will get returned.
  1097.                      */
  1098.                     yy_c_buf_p = yytext_ptr + YY_MORE_ADJ;
  1099.  
  1100.                     yy_act = YY_STATE_EOF(YY_START);
  1101.                     goto do_action;
  1102.                     }
  1103.  
  1104.                 else
  1105.                     {
  1106.                     if ( ! yy_did_buffer_switch_on_eof )
  1107.                         YY_NEW_FILE;
  1108.                     }
  1109.                 break;
  1110.                 }
  1111.  
  1112.             case EOB_ACT_CONTINUE_SCAN:
  1113.                 yy_c_buf_p =
  1114.                     yytext_ptr + yy_amount_of_matched_text;
  1115.  
  1116.                 yy_current_state = yy_get_previous_state();
  1117.  
  1118.                 yy_cp = yy_c_buf_p;
  1119.                 yy_bp = yytext_ptr + YY_MORE_ADJ;
  1120.                 goto yy_match;
  1121.  
  1122.             case EOB_ACT_LAST_MATCH:
  1123.                 yy_c_buf_p =
  1124.                 &yy_current_buffer->yy_ch_buf[yy_n_chars];
  1125.  
  1126.                 yy_current_state = yy_get_previous_state();
  1127.  
  1128.                 yy_cp = yy_c_buf_p;
  1129.                 yy_bp = yytext_ptr + YY_MORE_ADJ;
  1130.                 goto yy_find_action;
  1131.             }
  1132.         break;
  1133.         }
  1134.  
  1135.     default:
  1136.         YY_FATAL_ERROR(
  1137.             "fatal flex scanner internal error--no action found" );
  1138.     } /* end of action switch */
  1139.         } /* end of scanning one token */
  1140.     } /* end of yylex */
  1141.  
  1142.  
  1143. /* yy_get_next_buffer - try to read in a new buffer
  1144.  *
  1145.  * Returns a code representing an action:
  1146.  *    EOB_ACT_LAST_MATCH -
  1147.  *    EOB_ACT_CONTINUE_SCAN - continue scanning from current position
  1148.  *    EOB_ACT_END_OF_FILE - end of file
  1149.  */
  1150.  
  1151. static int yy_get_next_buffer()
  1152.     {
  1153.     register char *dest = yy_current_buffer->yy_ch_buf;
  1154.     register char *source = yytext_ptr;
  1155.     register int number_to_move, i;
  1156.     int ret_val;
  1157.  
  1158.     if ( yy_c_buf_p > &yy_current_buffer->yy_ch_buf[yy_n_chars + 1] )
  1159.         YY_FATAL_ERROR(
  1160.         "fatal flex scanner internal error--end of buffer missed" );
  1161.  
  1162.     if ( yy_current_buffer->yy_fill_buffer == 0 )
  1163.         { /* Don't try to fill the buffer, so this is an EOF. */
  1164.         if ( yy_c_buf_p - yytext_ptr - YY_MORE_ADJ == 1 )
  1165.             {
  1166.             /* We matched a singled characater, the EOB, so
  1167.              * treat this as a final EOF.
  1168.              */
  1169.             return EOB_ACT_END_OF_FILE;
  1170.             }
  1171.  
  1172.         else
  1173.             {
  1174.             /* We matched some text prior to the EOB, first
  1175.              * process it.
  1176.              */
  1177.             return EOB_ACT_LAST_MATCH;
  1178.             }
  1179.         }
  1180.  
  1181.     /* Try to read more data. */
  1182.  
  1183.     /* First move last chars to start of buffer. */
  1184.     number_to_move = (int) (yy_c_buf_p - yytext_ptr) - 1;
  1185.  
  1186.     for ( i = 0; i < number_to_move; ++i )
  1187.         *(dest++) = *(source++);
  1188.  
  1189.     if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_EOF_PENDING )
  1190.         /* don't do the read, it's not guaranteed to return an EOF,
  1191.          * just force an EOF
  1192.          */
  1193.         yy_n_chars = 0;
  1194.  
  1195.     else
  1196.         {
  1197.         int num_to_read =
  1198.             yy_current_buffer->yy_buf_size - number_to_move - 1;
  1199.  
  1200.         while ( num_to_read <= 0 )
  1201.             { /* Not enough room in the buffer - grow it. */
  1202. #ifdef YY_USES_REJECT
  1203.             YY_FATAL_ERROR(
  1204. "input buffer overflow, can't enlarge buffer because scanner uses REJECT" );
  1205. #else
  1206.  
  1207.             /* just a shorter name for the current buffer */
  1208.             YY_BUFFER_STATE b = yy_current_buffer;
  1209.  
  1210.             int yy_c_buf_p_offset =
  1211.                 (int) (yy_c_buf_p - b->yy_ch_buf);
  1212.  
  1213.             if ( b->yy_is_our_buffer )
  1214.                 {
  1215.                 int new_size = b->yy_buf_size * 2;
  1216.  
  1217.                 if ( new_size <= 0 )
  1218.                     b->yy_buf_size += b->yy_buf_size / 8;
  1219.                 else
  1220.                     b->yy_buf_size *= 2;
  1221.  
  1222.                 b->yy_ch_buf = (char *)
  1223.                     /* Include room in for 2 EOB chars. */
  1224.                     yy_flex_realloc( (void *) b->yy_ch_buf,
  1225.                              b->yy_buf_size + 2 );
  1226.                 }
  1227.             else
  1228.                 /* Can't grow it, we don't own it. */
  1229.                 b->yy_ch_buf = 0;
  1230.  
  1231.             if ( ! b->yy_ch_buf )
  1232.                 YY_FATAL_ERROR(
  1233.                 "fatal error - scanner input buffer overflow" );
  1234.  
  1235.             yy_c_buf_p = &b->yy_ch_buf[yy_c_buf_p_offset];
  1236.  
  1237.             num_to_read = yy_current_buffer->yy_buf_size -
  1238.                         number_to_move - 1;
  1239. #endif
  1240.             }
  1241.  
  1242.         if ( num_to_read > YY_READ_BUF_SIZE )
  1243.             num_to_read = YY_READ_BUF_SIZE;
  1244.  
  1245.         /* Read in more data. */
  1246.         YY_INPUT( (&yy_current_buffer->yy_ch_buf[number_to_move]),
  1247.             yy_n_chars, num_to_read );
  1248.         }
  1249.  
  1250.     if ( yy_n_chars == 0 )
  1251.         {
  1252.         if ( number_to_move == YY_MORE_ADJ )
  1253.             {
  1254.             ret_val = EOB_ACT_END_OF_FILE;
  1255.             yyrestart( yyin );
  1256.             }
  1257.  
  1258.         else
  1259.             {
  1260.             ret_val = EOB_ACT_LAST_MATCH;
  1261.             yy_current_buffer->yy_buffer_status =
  1262.                 YY_BUFFER_EOF_PENDING;
  1263.             }
  1264.         }
  1265.  
  1266.     else
  1267.         ret_val = EOB_ACT_CONTINUE_SCAN;
  1268.  
  1269.     yy_n_chars += number_to_move;
  1270.     yy_current_buffer->yy_ch_buf[yy_n_chars] = YY_END_OF_BUFFER_CHAR;
  1271.     yy_current_buffer->yy_ch_buf[yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR;
  1272.  
  1273.     yytext_ptr = &yy_current_buffer->yy_ch_buf[0];
  1274.  
  1275.     return ret_val;
  1276.     }
  1277.  
  1278.  
  1279. /* yy_get_previous_state - get the state just before the EOB char was reached */
  1280.  
  1281. static yy_state_type yy_get_previous_state()
  1282.     {
  1283.     register yy_state_type yy_current_state;
  1284.     register char *yy_cp;
  1285.  
  1286.     yy_current_state = yy_start;
  1287.     yy_current_state += YY_AT_BOL();
  1288.     yy_state_ptr = yy_state_buf;
  1289.     *yy_state_ptr++ = yy_current_state;
  1290.  
  1291.     for ( yy_cp = yytext_ptr + YY_MORE_ADJ; yy_cp < yy_c_buf_p; ++yy_cp )
  1292.         {
  1293.         register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
  1294.         while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
  1295.             {
  1296.             yy_current_state = (int) yy_def[yy_current_state];
  1297.             if ( yy_current_state >= 176 )
  1298.                 yy_c = yy_meta[(unsigned int) yy_c];
  1299.             }
  1300.         yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
  1301.         *yy_state_ptr++ = yy_current_state;
  1302.         }
  1303.  
  1304.     return yy_current_state;
  1305.     }
  1306.  
  1307.  
  1308. /* yy_try_NUL_trans - try to make a transition on the NUL character
  1309.  *
  1310.  * synopsis
  1311.  *    next_state = yy_try_NUL_trans( current_state );
  1312.  */
  1313.  
  1314. #ifdef YY_USE_PROTOS
  1315. static yy_state_type yy_try_NUL_trans( yy_state_type yy_current_state )
  1316. #else
  1317. static yy_state_type yy_try_NUL_trans( yy_current_state )
  1318. yy_state_type yy_current_state;
  1319. #endif
  1320.     {
  1321.     register int yy_is_jam;
  1322.  
  1323.     register YY_CHAR yy_c = 1;
  1324.     while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
  1325.         {
  1326.         yy_current_state = (int) yy_def[yy_current_state];
  1327.         if ( yy_current_state >= 176 )
  1328.             yy_c = yy_meta[(unsigned int) yy_c];
  1329.         }
  1330.     yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
  1331.     *yy_state_ptr++ = yy_current_state;
  1332.     yy_is_jam = (yy_current_state == 175);
  1333.  
  1334.     return yy_is_jam ? 0 : yy_current_state;
  1335.     }
  1336.  
  1337.  
  1338. #ifndef YY_NO_UNPUT
  1339. #ifdef YY_USE_PROTOS
  1340. static void yyunput( int c, register char *yy_bp )
  1341. #else
  1342. static void yyunput( c, yy_bp )
  1343. int c;
  1344. register char *yy_bp;
  1345. #endif
  1346.     {
  1347.     register char *yy_cp = yy_c_buf_p;
  1348.  
  1349.     /* undo effects of setting up yytext */
  1350.     *yy_cp = yy_hold_char;
  1351.  
  1352.     if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )
  1353.         { /* need to shift things up to make room */
  1354.         /* +2 for EOB chars. */
  1355.         register int number_to_move = yy_n_chars + 2;
  1356.         register char *dest = &yy_current_buffer->yy_ch_buf[
  1357.                     yy_current_buffer->yy_buf_size + 2];
  1358.         register char *source =
  1359.                 &yy_current_buffer->yy_ch_buf[number_to_move];
  1360.  
  1361.         while ( source > yy_current_buffer->yy_ch_buf )
  1362.             *--dest = *--source;
  1363.  
  1364.         yy_cp += (int) (dest - source);
  1365.         yy_bp += (int) (dest - source);
  1366.         yy_n_chars = yy_current_buffer->yy_buf_size;
  1367.  
  1368.         if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )
  1369.             YY_FATAL_ERROR( "flex scanner push-back overflow" );
  1370.         }
  1371.  
  1372.     *--yy_cp = (char) c;
  1373.  
  1374.     if ( c == '\n' )
  1375.         --yylineno;
  1376.  
  1377.     yytext_ptr = yy_bp;
  1378.     yy_hold_char = *yy_cp;
  1379.     yy_c_buf_p = yy_cp;
  1380.     }
  1381. #endif    /* ifndef YY_NO_UNPUT */
  1382.  
  1383.  
  1384. #ifdef __cplusplus
  1385. static int yyinput()
  1386. #else
  1387. static int input()
  1388. #endif
  1389.     {
  1390.     int c;
  1391.  
  1392.     *yy_c_buf_p = yy_hold_char;
  1393.  
  1394.     if ( *yy_c_buf_p == YY_END_OF_BUFFER_CHAR )
  1395.         {
  1396.         /* yy_c_buf_p now points to the character we want to return.
  1397.          * If this occurs *before* the EOB characters, then it's a
  1398.          * valid NUL; if not, then we've hit the end of the buffer.
  1399.          */
  1400.         if ( yy_c_buf_p < &yy_current_buffer->yy_ch_buf[yy_n_chars] )
  1401.             /* This was really a NUL. */
  1402.             *yy_c_buf_p = '\0';
  1403.  
  1404.         else
  1405.             { /* need more input */
  1406.             yytext_ptr = yy_c_buf_p;
  1407.             ++yy_c_buf_p;
  1408.  
  1409.             switch ( yy_get_next_buffer() )
  1410.                 {
  1411.                 case EOB_ACT_END_OF_FILE:
  1412.                     {
  1413.                     if ( yywrap() )
  1414.                         {
  1415.                         yy_c_buf_p =
  1416.                         yytext_ptr + YY_MORE_ADJ;
  1417.                         return EOF;
  1418.                         }
  1419.  
  1420.                     if ( ! yy_did_buffer_switch_on_eof )
  1421.                         YY_NEW_FILE;
  1422. #ifdef __cplusplus
  1423.                     return yyinput();
  1424. #else
  1425.                     return input();
  1426. #endif
  1427.                     }
  1428.  
  1429.                 case EOB_ACT_CONTINUE_SCAN:
  1430.                     yy_c_buf_p = yytext_ptr + YY_MORE_ADJ;
  1431.                     break;
  1432.  
  1433.                 case EOB_ACT_LAST_MATCH:
  1434. #ifdef __cplusplus
  1435.                     YY_FATAL_ERROR(
  1436.                     "unexpected last match in yyinput()" );
  1437. #else
  1438.                     YY_FATAL_ERROR(
  1439.                     "unexpected last match in input()" );
  1440. #endif
  1441.                 }
  1442.             }
  1443.         }
  1444.  
  1445.     c = *(unsigned char *) yy_c_buf_p;    /* cast for 8-bit char's */
  1446.     *yy_c_buf_p = '\0';    /* preserve yytext */
  1447.     yy_hold_char = *++yy_c_buf_p;
  1448.  
  1449.     yy_current_buffer->yy_at_bol = (c == '\n');
  1450.     if ( yy_current_buffer->yy_at_bol )
  1451.         ++yylineno;
  1452.  
  1453.     return c;
  1454.     }
  1455.  
  1456.  
  1457. #ifdef YY_USE_PROTOS
  1458. void yyrestart( FILE *input_file )
  1459. #else
  1460. void yyrestart( input_file )
  1461. FILE *input_file;
  1462. #endif
  1463.     {
  1464.     if ( ! yy_current_buffer )
  1465.         yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE );
  1466.  
  1467.     yy_init_buffer( yy_current_buffer, input_file );
  1468.     yy_load_buffer_state();
  1469.     }
  1470.  
  1471.  
  1472. #ifdef YY_USE_PROTOS
  1473. void yy_switch_to_buffer( YY_BUFFER_STATE new_buffer )
  1474. #else
  1475. void yy_switch_to_buffer( new_buffer )
  1476. YY_BUFFER_STATE new_buffer;
  1477. #endif
  1478.     {
  1479.     if ( yy_current_buffer == new_buffer )
  1480.         return;
  1481.  
  1482.     if ( yy_current_buffer )
  1483.         {
  1484.         /* Flush out information for old buffer. */
  1485.         *yy_c_buf_p = yy_hold_char;
  1486.         yy_current_buffer->yy_buf_pos = yy_c_buf_p;
  1487.         yy_current_buffer->yy_n_chars = yy_n_chars;
  1488.         }
  1489.  
  1490.     yy_current_buffer = new_buffer;
  1491.     yy_load_buffer_state();
  1492.  
  1493.     /* We don't actually know whether we did this switch during
  1494.      * EOF (yywrap()) processing, but the only time this flag
  1495.      * is looked at is after yywrap() is called, so it's safe
  1496.      * to go ahead and always set it.
  1497.      */
  1498.     yy_did_buffer_switch_on_eof = 1;
  1499.     }
  1500.  
  1501.  
  1502. #ifdef YY_USE_PROTOS
  1503. void yy_load_buffer_state( void )
  1504. #else
  1505. void yy_load_buffer_state()
  1506. #endif
  1507.     {
  1508.     yy_n_chars = yy_current_buffer->yy_n_chars;
  1509.     yytext_ptr = yy_c_buf_p = yy_current_buffer->yy_buf_pos;
  1510.     yyin = yy_current_buffer->yy_input_file;
  1511.     yy_hold_char = *yy_c_buf_p;
  1512.     }
  1513.  
  1514.  
  1515. #ifdef YY_USE_PROTOS
  1516. YY_BUFFER_STATE yy_create_buffer( FILE *file, int size )
  1517. #else
  1518. YY_BUFFER_STATE yy_create_buffer( file, size )
  1519. FILE *file;
  1520. int size;
  1521. #endif
  1522.     {
  1523.     YY_BUFFER_STATE b;
  1524.  
  1525.     b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) );
  1526.     if ( ! b )
  1527.         YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
  1528.  
  1529.     b->yy_buf_size = size;
  1530.  
  1531.     /* yy_ch_buf has to be 2 characters longer than the size given because
  1532.      * we need to put in 2 end-of-buffer characters.
  1533.      */
  1534.     b->yy_ch_buf = (char *) yy_flex_alloc( b->yy_buf_size + 2 );
  1535.     if ( ! b->yy_ch_buf )
  1536.         YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
  1537.  
  1538.     b->yy_is_our_buffer = 1;
  1539.  
  1540.     yy_init_buffer( b, file );
  1541.  
  1542.     return b;
  1543.     }
  1544.  
  1545.  
  1546. #ifdef YY_USE_PROTOS
  1547. void yy_delete_buffer( YY_BUFFER_STATE b )
  1548. #else
  1549. void yy_delete_buffer( b )
  1550. YY_BUFFER_STATE b;
  1551. #endif
  1552.     {
  1553.     if ( ! b )
  1554.         return;
  1555.  
  1556.     if ( b == yy_current_buffer )
  1557.         yy_current_buffer = (YY_BUFFER_STATE) 0;
  1558.  
  1559.     if ( b->yy_is_our_buffer )
  1560.         yy_flex_free( (void *) b->yy_ch_buf );
  1561.  
  1562.     yy_flex_free( (void *) b );
  1563.     }
  1564.  
  1565.  
  1566. #ifndef YY_ALWAYS_INTERACTIVE
  1567. #ifndef YY_NEVER_INTERACTIVE
  1568. extern int isatty YY_PROTO(( int ));
  1569. #endif
  1570. #endif
  1571.  
  1572. #ifdef YY_USE_PROTOS
  1573. void yy_init_buffer( YY_BUFFER_STATE b, FILE *file )
  1574. #else
  1575. void yy_init_buffer( b, file )
  1576. YY_BUFFER_STATE b;
  1577. FILE *file;
  1578. #endif
  1579.  
  1580.  
  1581.     {
  1582.     yy_flush_buffer( b );
  1583.  
  1584.     b->yy_input_file = file;
  1585.     b->yy_fill_buffer = 1;
  1586.  
  1587. #if YY_ALWAYS_INTERACTIVE
  1588.     b->yy_is_interactive = 1;
  1589. #else
  1590. #if YY_NEVER_INTERACTIVE
  1591.     b->yy_is_interactive = 0;
  1592. #else
  1593.     b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0;
  1594. #endif
  1595. #endif
  1596.     }
  1597.  
  1598.  
  1599. #ifdef YY_USE_PROTOS
  1600. void yy_flush_buffer( YY_BUFFER_STATE b )
  1601. #else
  1602. void yy_flush_buffer( b )
  1603. YY_BUFFER_STATE b;
  1604. #endif
  1605.  
  1606.     {
  1607.     b->yy_n_chars = 0;
  1608.  
  1609.     /* We always need two end-of-buffer characters.  The first causes
  1610.      * a transition to the end-of-buffer state.  The second causes
  1611.      * a jam in that state.
  1612.      */
  1613.     b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
  1614.     b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
  1615.  
  1616.     b->yy_buf_pos = &b->yy_ch_buf[0];
  1617.  
  1618.     b->yy_at_bol = 1;
  1619.     b->yy_buffer_status = YY_BUFFER_NEW;
  1620.  
  1621.     if ( b == yy_current_buffer )
  1622.         yy_load_buffer_state();
  1623.     }
  1624.  
  1625.  
  1626. #ifndef YY_NO_SCAN_BUFFER
  1627. #ifdef YY_USE_PROTOS
  1628. YY_BUFFER_STATE yy_scan_buffer( char *base, yy_size_t size )
  1629. #else
  1630. YY_BUFFER_STATE yy_scan_buffer( base, size )
  1631. char *base;
  1632. yy_size_t size;
  1633. #endif
  1634.     {
  1635.     YY_BUFFER_STATE b;
  1636.  
  1637.     if ( size < 2 ||
  1638.          base[size-2] != YY_END_OF_BUFFER_CHAR ||
  1639.          base[size-1] != YY_END_OF_BUFFER_CHAR )
  1640.         /* They forgot to leave room for the EOB's. */
  1641.         return 0;
  1642.  
  1643.     b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) );
  1644.     if ( ! b )
  1645.         YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" );
  1646.  
  1647.     b->yy_buf_size = size - 2;    /* "- 2" to take care of EOB's */
  1648.     b->yy_buf_pos = b->yy_ch_buf = base;
  1649.     b->yy_is_our_buffer = 0;
  1650.     b->yy_input_file = 0;
  1651.     b->yy_n_chars = b->yy_buf_size;
  1652.     b->yy_is_interactive = 0;
  1653.     b->yy_at_bol = 1;
  1654.     b->yy_fill_buffer = 0;
  1655.     b->yy_buffer_status = YY_BUFFER_NEW;
  1656.  
  1657.     yy_switch_to_buffer( b );
  1658.  
  1659.     return b;
  1660.     }
  1661. #endif
  1662.  
  1663.  
  1664. #ifndef YY_NO_SCAN_STRING
  1665. #ifdef YY_USE_PROTOS
  1666. YY_BUFFER_STATE yy_scan_string( yyconst char *str )
  1667. #else
  1668. YY_BUFFER_STATE yy_scan_string( str )
  1669. yyconst char *str;
  1670. #endif
  1671.     {
  1672.     int len;
  1673.     for ( len = 0; str[len]; ++len )
  1674.         ;
  1675.  
  1676.     return yy_scan_bytes( str, len );
  1677.     }
  1678. #endif
  1679.  
  1680.  
  1681. #ifndef YY_NO_SCAN_BYTES
  1682. #ifdef YY_USE_PROTOS
  1683. YY_BUFFER_STATE yy_scan_bytes( yyconst char *bytes, int len )
  1684. #else
  1685. YY_BUFFER_STATE yy_scan_bytes( bytes, len )
  1686. yyconst char *bytes;
  1687. int len;
  1688. #endif
  1689.     {
  1690.     YY_BUFFER_STATE b;
  1691.     char *buf;
  1692.     yy_size_t n;
  1693.     int i;
  1694.  
  1695.     /* Get memory for full buffer, including space for trailing EOB's. */
  1696.     n = len + 2;
  1697.     buf = (char *) yy_flex_alloc( n );
  1698.     if ( ! buf )
  1699.         YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" );
  1700.  
  1701.     for ( i = 0; i < len; ++i )
  1702.         buf[i] = bytes[i];
  1703.  
  1704.     buf[len] = buf[len+1] = YY_END_OF_BUFFER_CHAR;
  1705.  
  1706.     b = yy_scan_buffer( buf, n );
  1707.     if ( ! b )
  1708.         YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" );
  1709.  
  1710.     /* It's okay to grow etc. this buffer, and we should throw it
  1711.      * away when we're done.
  1712.      */
  1713.     b->yy_is_our_buffer = 1;
  1714.  
  1715.     return b;
  1716.     }
  1717. #endif
  1718.  
  1719.  
  1720. #ifndef YY_NO_PUSH_STATE
  1721. #ifdef YY_USE_PROTOS
  1722. static void yy_push_state( int new_state )
  1723. #else
  1724. static void yy_push_state( new_state )
  1725. int new_state;
  1726. #endif
  1727.     {
  1728.     if ( yy_start_stack_ptr >= yy_start_stack_depth )
  1729.         {
  1730.         yy_size_t new_size;
  1731.  
  1732.         yy_start_stack_depth += YY_START_STACK_INCR;
  1733.         new_size = yy_start_stack_depth * sizeof( int );
  1734.  
  1735.         if ( ! yy_start_stack )
  1736.             yy_start_stack = (int *) yy_flex_alloc( new_size );
  1737.  
  1738.         else
  1739.             yy_start_stack = (int *) yy_flex_realloc(
  1740.                     (void *) yy_start_stack, new_size );
  1741.  
  1742.         if ( ! yy_start_stack )
  1743.             YY_FATAL_ERROR(
  1744.             "out of memory expanding start-condition stack" );
  1745.         }
  1746.  
  1747.     yy_start_stack[yy_start_stack_ptr++] = YY_START;
  1748.  
  1749.     BEGIN(new_state);
  1750.     }
  1751. #endif
  1752.  
  1753.  
  1754. #ifndef YY_NO_POP_STATE
  1755. static void yy_pop_state()
  1756.     {
  1757.     if ( --yy_start_stack_ptr < 0 )
  1758.         YY_FATAL_ERROR( "start-condition stack underflow" );
  1759.  
  1760.     BEGIN(yy_start_stack[yy_start_stack_ptr]);
  1761.     }
  1762. #endif
  1763.  
  1764.  
  1765. #ifndef YY_NO_TOP_STATE
  1766. static int yy_top_state()
  1767.     {
  1768.     return yy_start_stack[yy_start_stack_ptr - 1];
  1769.     }
  1770. #endif
  1771.  
  1772. #ifndef YY_EXIT_FAILURE
  1773. #define YY_EXIT_FAILURE 2
  1774. #endif
  1775.  
  1776. #ifdef YY_USE_PROTOS
  1777. static void yy_fatal_error( yyconst char msg[] )
  1778. #else
  1779. static void yy_fatal_error( msg )
  1780. char msg[];
  1781. #endif
  1782.     {
  1783.     (void) fprintf( stderr, "%s\n", msg );
  1784.     exit( YY_EXIT_FAILURE );
  1785.     }
  1786.  
  1787.  
  1788.  
  1789. /* Redefine yyless() so it works in section 3 code. */
  1790.  
  1791. #undef yyless
  1792. #define yyless(n) \
  1793.     do \
  1794.         { \
  1795.         /* Undo effects of setting up yytext. */ \
  1796.         yytext[yyleng] = yy_hold_char; \
  1797.         yy_c_buf_p = yytext + n - YY_MORE_ADJ; \
  1798.         yy_hold_char = *yy_c_buf_p; \
  1799.         *yy_c_buf_p = '\0'; \
  1800.         yyleng = n; \
  1801.         } \
  1802.     while ( 0 )
  1803.  
  1804.  
  1805. /* Internal utility routines. */
  1806.  
  1807. #ifndef yytext_ptr
  1808. #ifdef YY_USE_PROTOS
  1809. static void yy_flex_strncpy( char *s1, yyconst char *s2, int n )
  1810. #else
  1811. static void yy_flex_strncpy( s1, s2, n )
  1812. char *s1;
  1813. yyconst char *s2;
  1814. int n;
  1815. #endif
  1816.     {
  1817.     register int i;
  1818.     for ( i = 0; i < n; ++i )
  1819.         s1[i] = s2[i];
  1820.     }
  1821. #endif
  1822.  
  1823.  
  1824. #ifdef YY_USE_PROTOS
  1825. static void *yy_flex_alloc( yy_size_t size )
  1826. #else
  1827. static void *yy_flex_alloc( size )
  1828. yy_size_t size;
  1829. #endif
  1830.     {
  1831.     return (void *) malloc( size );
  1832.     }
  1833.  
  1834. #ifdef YY_USE_PROTOS
  1835. static void *yy_flex_realloc( void *ptr, yy_size_t size )
  1836. #else
  1837. static void *yy_flex_realloc( ptr, size )
  1838. void *ptr;
  1839. yy_size_t size;
  1840. #endif
  1841.     {
  1842.     /* The cast to (char *) in the following accommodates both
  1843.      * implementations that use char* generic pointers, and those
  1844.      * that use void* generic pointers.  It works with the latter
  1845.      * because both ANSI C and C++ allow castless assignment from
  1846.      * any pointer type to void*, and deal with argument conversions
  1847.      * as though doing an assignment.
  1848.      */
  1849.     return (void *) realloc( (char *) ptr, size );
  1850.     }
  1851.  
  1852. #ifdef YY_USE_PROTOS
  1853. static void yy_flex_free( void *ptr )
  1854. #else
  1855. static void yy_flex_free( ptr )
  1856. void *ptr;
  1857. #endif
  1858.     {
  1859.     free( ptr );
  1860.     }
  1861.  
  1862. #if YY_MAIN
  1863. int main()
  1864.     {
  1865.     yylex();
  1866.     return 0;
  1867.     }
  1868. #endif
  1869. #line 224 "scan_commons.l"
  1870.  
  1871.  
  1872. /****
  1873. * macro used in the signal catcher routine below.
  1874. * aborts the scanner if yyin is still open and, if needed,
  1875. * closes the current database file.
  1876. ****/
  1877. #define SHUTUP(text,exitnum)    { \
  1878.     fprintf(stderr, "\n%s: %s\n", progname, text); \
  1879.     if(yyin) \
  1880.     { \
  1881.         fprintf(stderr, "Stopping scanner\n"); \
  1882.         YY_FLUSH_BUFFER; \
  1883.         fclose(yyin); fclose(yyout); \
  1884.     } \
  1885.     if(db_file) \
  1886.     { \
  1887.         fprintf(stderr, "Syncing and closing database\n");\
  1888.         gdbm_close(db_file); db_file = NULL; \
  1889.     } \
  1890.     fprintf(stderr, "Terminated with signal %s\n", #exitnum); \
  1891.     fprintf(stderr, "Total files scanned: %i\n", curr_file_num); \
  1892.     if(dump_core) abort(); \
  1893.     exit(exitnum+20); \
  1894.     }
  1895.  
  1896. /****
  1897. * Exit function for internal flex errors. This function will
  1898. * close the database file (if left open)
  1899. ****/
  1900. void
  1901. scanner_fail(void)
  1902. {
  1903. #if 0
  1904.     if(db_file)
  1905.     {
  1906.         gdbm_close(db_file);
  1907.         db_file = NULL;
  1908.     }
  1909.     fclose(yyin);
  1910.     fclose(yyout);
  1911. #endif
  1912. }
  1913. /****
  1914. * Signal handler for a nice and clean exit 
  1915. ****/
  1916. static RETSIGTYPE
  1917. sig_handler(int signum)
  1918. {
  1919.     switch(signum)
  1920.     {
  1921. #ifdef SIGBUS    /* SIGBUS is not defined on all systems */
  1922.         case SIGBUS:
  1923.             SHUTUP("Aaaiieee, a bus error!", SIGBUS);
  1924. #endif /* SIGBUS */
  1925.         case SIGSEGV:
  1926.             SHUTUP("Ooops, a segmentation violation.", SIGSEGV);
  1927. #ifdef SIGALRM    /* same for SIGALRM */
  1928.         case SIGALRM:
  1929.             SHUTUP("Aborted.", SIGALRM);
  1930. #endif
  1931.         case SIGUSR1:
  1932.             SHUTUP("Memory allocation error.", SIGUSR1);
  1933. #ifdef SIGQUIT    /* same for SIGQUIT */
  1934.         case SIGQUIT:
  1935.             SHUTUP("Interrupted.", SIGQUIT);
  1936. #endif
  1937.         case SIGINT:
  1938.             SHUTUP("Interrupted.", SIGINT);
  1939.         default:
  1940.             SHUTUP("What did _you_ do?  Stopping.", signum);
  1941.     }
  1942. }
  1943.  
  1944. /*****
  1945. * replace an existing entry in the current database with the data contained
  1946. * in key. Otherwise create a new entry in the database.
  1947. *****/
  1948. static void replace_item(datum key)
  1949. {
  1950.     if(gdbm_exists(db_file, key))
  1951.     {
  1952.         datum prev;
  1953.  
  1954.         prev = gdbm_fetch(db_file, key);
  1955.         /*
  1956.         * If the stringcompare matches the current file, it's already 
  1957.         * here so we don't want to update it again. 
  1958.         */
  1959.         if(strstr(prev.dptr, content.dptr))
  1960.         {
  1961.             num_common_rejected++;
  1962.             return;
  1963.         }
  1964.         /*
  1965.         * Resize the returned item so it will contain the next also 
  1966.         * but separated by a comma 
  1967.         */
  1968.         prev.dsize += content.dsize + 2;
  1969.         checked_realloc(prev.dptr, prev.dsize, char);
  1970.  
  1971.         /* update data */
  1972.         strcat(prev.dptr, ",");
  1973.         strcat(prev.dptr, content.dptr);
  1974.  
  1975.         /* store the new data */
  1976.         gdbm_store(db_file, key, prev, GDBM_REPLACE);
  1977.  
  1978.         free(prev.dptr);
  1979.         num_common_accepted++;
  1980.         num_common_stored++;
  1981.         num_common_replaced++;
  1982.         return;
  1983.     }    /* fall through */
  1984.     insert_item(key);
  1985. }
  1986.  
  1987. /*****
  1988. * Add a new entry to the current database
  1989. *****/
  1990. static void insert_item(datum key)
  1991. {
  1992.     if(gdbm_store(db_file, key, content, GDBM_INSERT))
  1993.     {
  1994.         if(!verbose)
  1995.             printf("already have %s, rejected.\n", key.dptr);
  1996.         num_common_rejected++;
  1997.         return;
  1998.     }    /* fall through */
  1999.     num_common_accepted++;
  2000.     num_common_stored++;
  2001. }
  2002.  
  2003. /*****
  2004. * retrieve all commons found in text
  2005. *****/
  2006. static void
  2007. get_common_contents(char *text)
  2008. {
  2009.     char *chPtr, *block;
  2010.     int i;
  2011.     datum key;
  2012.  
  2013.     /* allocate scratch memory */
  2014.     checked_malloc(block, strlen(text)+1, char);
  2015.     /* 
  2016.     * must copy, text is a ptr into a buffer of the scanner. 
  2017.     * Modifying this block will cause unpredictable results 
  2018.     */
  2019.     strcpy(block, text);
  2020.     /* make all text upcase */
  2021.     upcase(block);
  2022.  
  2023.     /* 
  2024.     * forget blocks with FUNCTION in them, scanner picked up the
  2025.     * wrong line.
  2026.     */
  2027.     if(strstr(block, "FUNCTION"))
  2028.         return;
  2029.  
  2030.     /* scan the block for commons. scan_block returns 0 on error. */
  2031.     if((num_warnings = scan_block(block, yylineno)) != -1)
  2032.     {
  2033.         /* store the commons returned */
  2034.         for(i=0, chPtr = strtok(block, ","); chPtr != NULL; 
  2035.             chPtr = strtok(NULL, ","), i++)
  2036.         {
  2037.             key.dptr = chPtr;
  2038.             key.dsize = strlen(chPtr)+1;
  2039.             /*
  2040.             * gdbm_proto_func is a ptr to the actual function used. 
  2041.             * It's real value depends on the -a command line option 
  2042.             */
  2043.             gdbm_proto_func(key); 
  2044.             num_common_total++; 
  2045.         }
  2046.     }
  2047.     else
  2048.         num_errors++;
  2049.     /* if we got warnings, display in what file they are found */
  2050.     if(num_warnings)
  2051.         fprintf(stderr, "File: %s%s\n", curr_path, curr_file);
  2052.     free(block);
  2053. }
  2054.  
  2055. /*****
  2056. * Command line handling
  2057. *****/
  2058. int set_global_option(char *arg)
  2059. { 
  2060.     switch(arg[0])
  2061.     {
  2062.         case 'a' :    /* add instead of reject commons */
  2063.             printf("adding instead of rejecting duplicate "
  2064.                 "commons\n");
  2065.             replace = GDBM_REPLACE;
  2066.             gdbm_proto_func = replace_item;
  2067.             break;
  2068.         case 'c' :    /* dump core on errors */
  2069.             dump_core = 1;
  2070.             break;
  2071.         case 'f' :    /* use filenames instead of full paths */
  2072.             full_names = 0 ;
  2073.             break;
  2074.         case 'h' :    /* help requested */
  2075.             printf(usage, progname); 
  2076.             exit(2); 
  2077. #ifdef __MSDOS__
  2078.         case 'm' :    /* show memory usage under msdos */
  2079.             need_mem_info_for_msdos = 1;
  2080.             break;
  2081. #endif
  2082.         case 'q' :     /* be really quiet */
  2083.             quiet = 1; 
  2084.             verbose = 0; 
  2085.             break; 
  2086.         case 'r' :    /* re-organize database */
  2087.             reorganize = 1;
  2088.             break;
  2089.         case 's' :    /* fast store. No update after each add */
  2090.             fast = 0;
  2091.             break;
  2092.         case 't' :    /* don't install signal handlers */
  2093.             no_signal = 1;
  2094.             break;
  2095.         case 'v' :     /* be verbose */
  2096.             verbose = 1; 
  2097.             break; 
  2098.         case 'E' :    /* an extension specification */
  2099.             SCAN_ARG("-E");
  2100.             if(num_extensions == MAXEXTS)
  2101.             {
  2102.                 fprintf(stderr, "Capacity exceeded, more than "
  2103.                     "%i extensions given on command "
  2104.                     "line.\n", MAXEXTS);
  2105.                 fprintf(stderr, "Ignoring extension %s\n", 
  2106.                     arg+1);
  2107.             }
  2108.             else
  2109.             {
  2110.                 checked_malloc(ext_table[num_extensions], 
  2111.                     strlen(arg+1)+1,char);
  2112.                 strcpy(ext_table[num_extensions++], arg+1); 
  2113. #ifdef __MSDOS__     /* dos returns uppercase when building a filelist */
  2114.                 upcase(ext_table[num_extensions-1]);
  2115. #endif
  2116.             }
  2117.             return(1); 
  2118.         case 'I' :    /* a directory specification */
  2119.             SCAN_ARG("-I");
  2120.             if(num_dirs_to_visit == MAXDIRS)
  2121.             {
  2122.                 fprintf(stderr, "Capacity exceeded, more than "
  2123.                     "%i directories given on command "
  2124.                     "line.\n", MAXDIRS);
  2125.                 fprintf(stderr, "Ignoring directory %s\n", 
  2126.                     arg+1);
  2127.             }
  2128.             else
  2129.             {
  2130.                 checked_malloc(dirs_to_visit[num_dirs_to_visit],
  2131.                     strlen(arg+1)+1, char);
  2132.                 strcpy(dirs_to_visit[num_dirs_to_visit++], 
  2133.                     arg+1); 
  2134.             }
  2135.             return(1); 
  2136.         case 'd' :    /* name of database to create/update */
  2137.             SCAN_ARG("-d");
  2138.             outfile = arg + 1;
  2139.             return(1); 
  2140.         case 'x' :    /* ignore file specification */
  2141.             SCAN_ARG("-x");
  2142.             if(num_ignore == MAXIGNORE)
  2143.             {
  2144.                 fprintf(stderr, "Capacity exceeded, more than "
  2145.                     "%i ignores given on command line.\n", 
  2146.                     MAXIGNORE);
  2147.                 fprintf(stderr, "Ignoring option -x%s\n", 
  2148.                     arg+1);
  2149.             }
  2150.             else
  2151.             {
  2152.                 checked_malloc(ignore_list[num_ignore], 
  2153.                     strlen(arg+1)+1, char);
  2154.                 strcpy(ignore_list[num_ignore++], arg+1);
  2155. #ifdef __MSDOS__ /* dos returns uppercase when building a filelist */
  2156.                 upcase(ignore_list[num_ignore-1]);
  2157. #endif
  2158.             }
  2159.             return(1);
  2160.         case '-' :    /* secondary options */
  2161.             if(!strcmp("help", arg+1))    /* help wanted */
  2162.             {
  2163.                 printf(usage, progname); 
  2164.                 exit(2); 
  2165.             }
  2166.             if(!strcmp("version", arg+1))    /* version number */
  2167.             {
  2168.                 print_version_id(progname, VERSION, "$Revision: 1.9 $");
  2169.                 exit(2);
  2170.             }    /* fall through */
  2171.         default:
  2172.             fprintf(stderr,"unknown option -%s\n", arg);
  2173.             exit(3);
  2174.     }
  2175.     return(0); 
  2176. }
  2177.  
  2178. /*****
  2179. * Return 0 if the file given is to be ignored, something else otherwise
  2180. *****/
  2181. static inline int 
  2182. ignore_this_file(char *file)
  2183. {
  2184.     register int i;
  2185.     char *ret_val = NULL;
  2186.     for(i = 0 ; i < num_ignore &&
  2187.         (ret_val = strstr(file, ignore_list[i])) == NULL; i++)
  2188.             /* do nothing */ ;
  2189.     if(ret_val != NULL)
  2190.     {
  2191.         if(!quiet)
  2192.             printf("Ignoring file %s\n", file);
  2193.         ign_file_num++;
  2194.         return(0);
  2195.     }
  2196.     return(1);
  2197. }
  2198.  
  2199. /*****
  2200. * main for scan_commons
  2201. *****/
  2202. int main (int argc, char **argv)
  2203. { 
  2204.     FILE *file;
  2205.     int i, narg;
  2206.     char *arg;
  2207.     char fullname[MAXPATHLEN];
  2208.  
  2209.     get_filename_part(argv[0], progname);
  2210.  
  2211.     if(argc == 1)
  2212.     {
  2213.         printf(usage, progname);
  2214.         exit(2);
  2215.     }
  2216.  
  2217.     /*
  2218.     * Command line handling. Set default switches.
  2219.     */
  2220.     full_names = 1;
  2221.     replace = GDBM_INSERT;
  2222.     fast = GDBM_FAST;
  2223.     /* default action is to insert a common if it does not yet exist */
  2224.     gdbm_proto_func = insert_item;
  2225.  
  2226.     /* scan the entire command line for any options */
  2227.     arg = argv[narg = 1];
  2228.     while ( narg < argc && arg[0] == '-' )
  2229.     {
  2230.         if (arg[0] == '-')
  2231.         {
  2232.             int num_opts = strlen(arg) ;
  2233.             for(i = 1 ; i < num_opts ; i++ )
  2234.             if(set_global_option(++arg))
  2235.                 break;
  2236.         }
  2237.         arg = argv[++narg];
  2238.     }
  2239.     /*
  2240.     * Try to get a database name from the environment specification if no
  2241.     * database is given on the command line
  2242.     */
  2243.     if(outfile == NULL)
  2244.         outfile = get_database_location(COMMON_LOCATION);
  2245.     if(outfile == NULL)
  2246.     {
  2247.         fprintf(stderr, "%s: no database found/specified\n", progname);
  2248.         exit(5);
  2249.     }
  2250.  
  2251.     /* attach signal handlers if not in debug mode. */
  2252.     if(!no_signal)
  2253.         ATTACH_SIGNALS;
  2254.  
  2255.     /* see if we have a dir spec or files on the command line */
  2256.     if(num_dirs_to_visit == 0 && narg == argc && reorganize == 0 )
  2257.     {
  2258.         fprintf(stderr,"%s: no files given.\n", progname);
  2259.         exit(4);
  2260.     }
  2261.  
  2262.     /* report initial settings if we have to be verbose */
  2263.     if(verbose)
  2264.     {
  2265.         if(num_dirs_to_visit != 0)
  2266.         {
  2267.             printf("List of directories to visit:\n");
  2268.             for(i = 0 ; i < num_dirs_to_visit; i++)
  2269.                 printf("%s\n", dirs_to_visit[i]);
  2270.         }
  2271.         if(num_extensions != 0)
  2272.         {
  2273.             printf("List of extensions to use:\n");
  2274.             for(i = 0 ; i < num_extensions; i++)
  2275.                 printf("%s ", ext_table[i]);
  2276.             printf("\n");
  2277.         }
  2278.         if(num_ignore != 0)
  2279.         {
  2280.             printf("List of files to ignore:\n");
  2281.             for(i = 0 ; i < num_ignore; i++)
  2282.                 printf("%s\n", ignore_list[i]);
  2283.         }
  2284.         if(num_dirs_to_visit != 0)
  2285.             printf("Scanning directories\n");
  2286.         fflush(stdout);
  2287.     }
  2288.  
  2289.     /* go create a list of all files in the directories given (if any) */
  2290.     for(i = 0 ; i < num_dirs_to_visit; i++)
  2291.     {
  2292.         if(verbose)
  2293.             printf("%s\n", dirs_to_visit[i]); 
  2294.         build_file_list(&file_list, &num_files, dirs_to_visit[i],
  2295.             ext_table, num_extensions); 
  2296.     }
  2297.  
  2298.     /* add files given on the command line to the list of files to visit */
  2299.     if(narg != argc)
  2300.     {
  2301.         for(i = narg ; i < argc ; i++)
  2302.         {
  2303.             checked_realloc(file_list, num_files+1, char*);
  2304.             checked_malloc(file_list[num_files], strlen(argv[i])+1,
  2305.                 char);
  2306.             sprintf(file_list[num_files++], "%s", argv[i]); 
  2307.         }
  2308.         if(verbose && argc-narg !=0)
  2309.             printf("%i files given on command line.", argc - narg); 
  2310.     }
  2311.  
  2312.     /* give the list of files to scan when we are being verbose */
  2313.     if(verbose)
  2314.     {
  2315.         printf("List of files to scan:\n");
  2316.         for(i = 0 ; i < num_files; i++)
  2317.             printf("%s\n", file_list[i]);
  2318.     }
  2319.  
  2320.     /* show number of files to scan */
  2321.     if(!quiet)
  2322.     {
  2323.         printf("Total Files to scan: %i\n", num_files); 
  2324.         printf("Database to create/update: %s\n", outfile);
  2325.     }
  2326.     fflush(stdout);
  2327.  
  2328.     /* open the database file for storage. Set to fast mode if requested */
  2329.     db_file = gdbm_open(outfile, 256, GDBM_WRCREAT | fast, DBM_PERM, NULL);
  2330.     if(db_file == NULL)
  2331.     {
  2332.         fprintf(stderr, "gdbm error: %s\n", gdbm_strerror(gdbm_errno));
  2333.         perror(outfile);
  2334.         exit(6);
  2335.     }
  2336.  
  2337.     /* write some administrative data to the database */
  2338.     write_commondb_header(db_file, outfile);
  2339.     for(i = 0 ; i < num_dirs_to_visit; i++)
  2340.         write_commondb_dirinfo(db_file, dirs_to_visit[i]);
  2341.  
  2342.     /* purge non-matching chars to /dev/null */
  2343.     yyout = fopen(YYOUT_DEVICE, "w+");
  2344.  
  2345.     num_files--;
  2346.  
  2347.     /* register exit function if the scanner fails */
  2348.     atexit(scanner_fail);
  2349.  
  2350.     /* loop through all files in the filelist */
  2351.     for(i = 0; i <= num_files; i++)
  2352.     {
  2353.         /* Check to see if we are to ignore this file */
  2354.         if((num_ignore == 0 ? 1 : ignore_this_file(file_list[i])))
  2355.         {
  2356.             file = fopen(file_list[i], "r");
  2357.             if(!file)
  2358.             {
  2359.                 perror(file_list[i]); 
  2360.                 continue;
  2361.             }
  2362.             num_common_total = num_common_rejected = 0;
  2363.             num_common_accepted = 0;
  2364.             num_common_replaced = num_common_stored = 0;
  2365.             num_errors = num_warnings = 0;
  2366.  
  2367.             /* get the complete path to this file and store it */
  2368.             ParseFilename(file_list[i], curr_file, curr_path);
  2369.             if(full_names)
  2370.                 sprintf(fullname, "%s%s", curr_path, curr_file);
  2371.             else
  2372.                 sprintf(fullname, "%s", curr_file);
  2373.  
  2374.             /* data belonging to each common found in this file */
  2375.             content.dptr = fullname;
  2376.             content.dsize = strlen(fullname)+1;
  2377.             yyin = file;  
  2378.             if(!quiet) 
  2379.                 printf("\nScanning %s\n", file_list[i]);
  2380.             rewind(yyin);
  2381.             /* go scan the file */
  2382.             yylex();
  2383.             YY_FLUSH_BUFFER;    /* clear scanner buffer */ 
  2384.             fclose(yyin);        /* close the input file */
  2385.             if(verbose)         /* report if wanted */
  2386.             { 
  2387.                 printf("\n---- Stats for file %s (%i/%i)\n", 
  2388.                     file_list[i], i+1, num_files+1);
  2389.                 printf("commons found      : %i\n", 
  2390.                     num_common_total);
  2391.                 printf("duplicate commons  : %i\n", 
  2392.                     num_common_replaced);
  2393.                 printf("commons rejected   : %i\n", 
  2394.                     num_common_rejected);
  2395.                 printf("commons accepted   : %i\n", 
  2396.                     num_common_accepted);
  2397.                 printf("commons stored     : %i\n", 
  2398.                     num_common_stored);
  2399.                 printf("Scan warnings      : %i\n", 
  2400.                     num_warnings);
  2401.                 printf("Scan errors        : %i\n", 
  2402.                     num_errors);
  2403.             }
  2404.             /* flush messages to stdout */
  2405.             fflush(stdout);
  2406.             num_total += num_common_total;
  2407.             num_total_replaced += num_common_replaced;
  2408.             num_total_rejected += num_common_rejected;
  2409.             num_total_accepted += num_common_accepted;
  2410.             num_total_stored   += num_common_stored;
  2411.             curr_file_num++;
  2412.         }
  2413.     }
  2414.     /* close /dev/null */
  2415.     fclose(yyout);
  2416.  
  2417.     /* report some statistics */
  2418.     if(!quiet)
  2419.     {
  2420.         printf("\n--- Total Statistics ---\n");
  2421.         printf("Directories visited: %i\n", num_dirs_to_visit);
  2422.         printf("Files searched     : %i\n", num_files+1);
  2423.         printf("Files ignored      : %i\n\n", ign_file_num);
  2424.         printf("commons found      : %i\n", num_total);
  2425.         printf("duplicate commons  : %i\n", num_total_replaced);
  2426.         printf("commons rejected   : %i\n", num_total_rejected);
  2427.         printf("commons accepted   : %i\n", num_total_accepted);
  2428.         printf("commons stored     : %i\n", num_total_stored);
  2429.         printf("\n------------------------\n");
  2430.     }
  2431.  
  2432.     /* write some more administrative data */
  2433.     write_commondb_update_info(db_file, num_total - num_total_rejected );
  2434.  
  2435.     if(reorganize)
  2436.     {
  2437.         if(!quiet)
  2438.             printf("Re-organizing database\n");
  2439.         if(gdbm_reorganize(db_file))
  2440.         {
  2441.             fprintf(stderr, "gdbm error: %s\n",
  2442.                 gdbm_strerror(gdbm_errno));
  2443.             perror(outfile);
  2444.         }
  2445.     }
  2446.     gdbm_close(db_file);    /* close the database */
  2447.     db_file = NULL;
  2448.  
  2449. #ifdef __MSDOS__
  2450.     if(need_mem_info_for_msdos)
  2451.     {
  2452.         printf("\n------------------\n");
  2453.         printf("MSDOS Memory Usage\n\n");
  2454.         printf("Heap size is %u bytes\n", _heaplen);
  2455.         printf("Stack size is %u\ bytesn", _stklen);
  2456.         dir_mem = sizeof(dirs_to_visit);
  2457.         for(i = 0 ; i < num_dirs_to_visit; i++)
  2458.             dir_mem += strlen(dirs_to_visit[i]);
  2459.         printf("Memory used by dir list: %lu bytes\n", dir_mem);
  2460.         ext_mem = sizeof(ext_table);
  2461.         for(i = 0 ; i < num_extensions; i++)
  2462.             ext_mem += strlen(ext_table[i]);
  2463.         printf("Memory used by ext list: %lu bytes\n", ext_mem);
  2464.         ign_mem = sizeof(ignore_list);
  2465.         for(i = 0 ; i < num_ignore; i++)
  2466.             ign_mem += strlen(ignore_list[i]);
  2467.         printf("Memory used by ignore list: %lu bytes\n", ign_mem);
  2468.         file_mem = sizeof(file_list);
  2469.         for(i = 0 ; i < num_files; i++)
  2470.             file_mem += strlen(file_list[i]);
  2471.          printf("Memory used by file list: %lu bytes\n", file_mem);
  2472.  
  2473.         printf("Total memory used: %lu bytes\n",
  2474.             dir_mem + ext_mem + ign_mem + file_mem);
  2475.     }
  2476. #endif
  2477.     return(0);
  2478. }
  2479.