home *** CD-ROM | disk | FTP | other *** search
/ GEMini Atari / GEMini_Atari_CD-ROM_Walnut_Creek_December_1993.iso / zip / gnu / flexs237.lzh / FLEXS237 / MAIN.C < prev    next >
C/C++ Source or Header  |  1993-07-29  |  20KB  |  773 lines

  1. /* flex - tool to generate fast lexical analyzers */
  2.  
  3. /*-
  4.  * Copyright (c) 1990 The Regents of the University of California.
  5.  * All rights reserved.
  6.  *
  7.  * This code is derived from software contributed to Berkeley by
  8.  * Vern Paxson.
  9.  * 
  10.  * The United States Government has rights in this work pursuant
  11.  * to contract no. DE-AC03-76SF00098 between the United States
  12.  * Department of Energy and the University of California.
  13.  *
  14.  * Redistribution and use in source and binary forms are permitted provided
  15.  * that: (1) source distributions retain this entire copyright notice and
  16.  * comment, and (2) distributions including binaries display the following
  17.  * acknowledgement:  ``This product includes software developed by the
  18.  * University of California, Berkeley and its contributors'' in the
  19.  * documentation or other materials provided with the distribution and in
  20.  * all advertising materials mentioning features or use of this software.
  21.  * Neither the name of the University nor the names of its contributors may
  22.  * be used to endorse or promote products derived from this software without
  23.  * specific prior written permission.
  24.  * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR IMPLIED
  25.  * WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF
  26.  * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
  27.  */
  28.  
  29. #ifndef lint
  30. char copyright[] =
  31. "@(#) Copyright (c) 1990 The Regents of the University of California.\n\
  32.  All rights reserved.\n";
  33. #endif /* not lint */
  34.  
  35. #ifndef lint
  36. static char rcsid[] =
  37.     "@(#) $Header: /usr/fsys/odin/a/vern/flex/RCS/main.c,v 2.9 90/06/27 23:48:24 vern Exp $ (LBL)";
  38. #endif
  39.  
  40.  
  41. #include "flexdef.h"
  42.  
  43. static char flex_version[] = "2.3";
  44.  
  45.  
  46. /* declare functions that have forward references */
  47.  
  48. void flexinit PROTO((int, char**));
  49. void readin PROTO(());
  50. void set_up_initial_allocations PROTO(());
  51.  
  52.  
  53. /* these globals are all defined and commented in flexdef.h */
  54. int printstats, syntaxerror, eofseen, ddebug, trace, spprdflt;
  55. int interactive, caseins, useecs, fulltbl, usemecs;
  56. int fullspd, gen_line_dirs, performance_report, backtrack_report, csize;
  57. int yymore_used, reject, real_reject, continued_action;
  58. int yymore_really_used, reject_really_used;
  59. int datapos, dataline, linenum;
  60. FILE *skelfile = NULL;
  61. char *infilename = NULL;
  62. int onestate[ONE_STACK_SIZE], onesym[ONE_STACK_SIZE];
  63. int onenext[ONE_STACK_SIZE], onedef[ONE_STACK_SIZE], onesp;
  64. int current_mns, num_rules, current_max_rules, lastnfa;
  65. int *firstst, *lastst, *finalst, *transchar, *trans1, *trans2;
  66. int *accptnum, *assoc_rule, *state_type, *rule_type, *rule_linenum;
  67. int current_state_type;
  68. int variable_trailing_context_rules;
  69. int numtemps, numprots, protprev[MSP], protnext[MSP], prottbl[MSP];
  70. int protcomst[MSP], firstprot, lastprot, protsave[PROT_SAVE_SIZE];
  71. int numecs, nextecm[CSIZE + 1], ecgroup[CSIZE + 1], nummecs, tecfwd[CSIZE + 1];
  72. int tecbck[CSIZE + 1];
  73. int *xlation = (int *) 0;
  74. int num_xlations;
  75. int lastsc, current_max_scs, *scset, *scbol, *scxclu, *sceof, *actvsc;
  76. char **scname;
  77. int current_max_dfa_size, current_max_xpairs;
  78. int current_max_template_xpairs, current_max_dfas;
  79. int lastdfa, *nxt, *chk, *tnxt;
  80. int *base, *def, *nultrans, NUL_ec, tblend, firstfree, **dss, *dfasiz;
  81. union dfaacc_union *dfaacc;
  82. int *accsiz, *dhash, numas;
  83. int numsnpairs, jambase, jamstate;
  84. int lastccl, current_maxccls, *cclmap, *ccllen, *cclng, cclreuse;
  85. int current_max_ccl_tbl_size;
  86. Char *ccltbl;
  87. char *starttime, *endtime, nmstr[MAXLINE];
  88. int sectnum, nummt, hshcol, dfaeql, numeps, eps2, num_reallocs;
  89. int tmpuses, totnst, peakpairs, numuniq, numdup, hshsave;
  90. int num_backtracking, bol_needed;
  91. FILE *temp_action_file;
  92. FILE *backtrack_file;
  93. int end_of_buffer_state;
  94. char *action_file_name = NULL;
  95. char **input_files;
  96. int num_input_files;
  97. char *program_name;
  98.  
  99. #ifndef SHORT_FILE_NAMES
  100. static char *outfile = "lex.yy.c";
  101. #else
  102. static char *outfile = "lexyy.c";
  103. #endif
  104. static int outfile_created = 0;
  105. static int use_stdout;
  106. static char *skelname = NULL;
  107. #ifdef atarist
  108. long _stksize = -1L;    /* need lots of stk+heap */
  109. #endif
  110.  
  111. int main( argc, argv )
  112. int argc;
  113. char **argv;
  114.  
  115.     {
  116.     flexinit( argc, argv );
  117.  
  118.     readin();
  119.  
  120.     if ( syntaxerror )
  121.     flexend( 1 );
  122.  
  123.     if ( yymore_really_used == REALLY_USED )
  124.     yymore_used = true;
  125.     else if ( yymore_really_used == REALLY_NOT_USED )
  126.     yymore_used = false;
  127.  
  128.     if ( reject_really_used == REALLY_USED )
  129.     reject = true;
  130.     else if ( reject_really_used == REALLY_NOT_USED )
  131.     reject = false;
  132.  
  133.     if ( performance_report )
  134.     {
  135.     if ( interactive )
  136.         fprintf( stderr,
  137.              "-I (interactive) entails a minor performance penalty\n" );
  138.  
  139.     if ( yymore_used )
  140.         fprintf( stderr, "yymore() entails a minor performance penalty\n" );
  141.  
  142.     if ( reject )
  143.         fprintf( stderr, "REJECT entails a large performance penalty\n" );
  144.  
  145.     if ( variable_trailing_context_rules )
  146.         fprintf( stderr,
  147. "Variable trailing context rules entail a large performance penalty\n" );
  148.     }
  149.  
  150.     if ( reject )
  151.     real_reject = true;
  152.  
  153.     if ( variable_trailing_context_rules )
  154.     reject = true;
  155.  
  156.     if ( (fulltbl || fullspd) && reject )
  157.     {
  158.     if ( real_reject )
  159.         flexerror( "REJECT cannot be used with -f or -F" );
  160.     else
  161.         flexerror(
  162.     "variable trailing context rules cannot be used with -f or -F" );
  163.     }
  164.  
  165.     ntod();
  166.  
  167.     /* generate the C state transition tables from the DFA */
  168.     make_tables();
  169.  
  170.     /* note, flexend does not return.  It exits with its argument as status. */
  171.  
  172.     flexend( 0 );
  173.  
  174.     /*NOTREACHED*/
  175.     }
  176.  
  177.  
  178. /* flexend - terminate flex
  179.  *
  180.  * synopsis
  181.  *    int status;
  182.  *    flexend( status );
  183.  *
  184.  *    status is exit status.
  185.  *
  186.  * note
  187.  *    This routine does not return.
  188.  */
  189.  
  190. void flexend( status )
  191. int status;
  192.  
  193.     {
  194.     int tblsiz;
  195.     char *flex_gettime();
  196.  
  197.     if ( skelfile != NULL )
  198.     {
  199.     if ( ferror( skelfile ) )
  200.         flexfatal( "error occurred when writing skeleton file" );
  201.  
  202.     else if ( fclose( skelfile ) )
  203.         flexfatal( "error occurred when closing skeleton file" );
  204.     }
  205.  
  206.     if ( temp_action_file )
  207.     {
  208.     if ( ferror( temp_action_file ) )
  209.         flexfatal( "error occurred when writing temporary action file" );
  210.  
  211.     else if ( fclose( temp_action_file ) )
  212.         flexfatal( "error occurred when closing temporary action file" );
  213.  
  214.     else if ( unlink( action_file_name ) )
  215.         flexfatal( "error occurred when deleting temporary action file" );
  216.     }
  217.  
  218.     if ( status != 0 && outfile_created )
  219.     {
  220.     if ( ferror( stdout ) )
  221.         flexfatal( "error occurred when writing output file" );
  222.  
  223.     else if ( fclose( stdout ) )
  224.         flexfatal( "error occurred when closing output file" );
  225.  
  226.     else if ( unlink( outfile ) )
  227.         flexfatal( "error occurred when deleting output file" );
  228.     }
  229.  
  230.     if ( backtrack_report && backtrack_file )
  231.     {
  232.     if ( num_backtracking == 0 )
  233.         fprintf( backtrack_file, "No backtracking.\n" );
  234.     else if ( fullspd || fulltbl )
  235.         fprintf( backtrack_file,
  236.              "%d backtracking (non-accepting) states.\n",
  237.              num_backtracking );
  238.     else
  239.         fprintf( backtrack_file, "Compressed tables always backtrack.\n" );
  240.  
  241.     if ( ferror( backtrack_file ) )
  242.         flexfatal( "error occurred when writing backtracking file" );
  243.  
  244.     else if ( fclose( backtrack_file ) )
  245.         flexfatal( "error occurred when closing backtracking file" );
  246.     }
  247.  
  248.     if ( printstats )
  249.     {
  250.     endtime = flex_gettime();
  251.  
  252.     fprintf( stderr, "%s version %s usage statistics:\n", program_name,
  253.          flex_version );
  254.     fprintf( stderr, "  started at %s, finished at %s\n",
  255.          starttime, endtime );
  256.  
  257.     fprintf( stderr, "  scanner options: -" );
  258.  
  259.     if ( backtrack_report )
  260.         putc( 'b', stderr );
  261.     if ( ddebug )
  262.         putc( 'd', stderr );
  263.     if ( interactive )
  264.         putc( 'I', stderr );
  265.     if ( caseins )
  266.         putc( 'i', stderr );
  267.     if ( ! gen_line_dirs )
  268.         putc( 'L', stderr );
  269.     if ( performance_report )
  270.         putc( 'p', stderr );
  271.     if ( spprdflt )
  272.         putc( 's', stderr );
  273.     if ( use_stdout )
  274.         putc( 't', stderr );
  275.     if ( trace )
  276.         putc( 'T', stderr );
  277.     if ( printstats )
  278.         putc( 'v', stderr );    /* always true! */
  279.     if ( csize == 256 )
  280.         putc( '8', stderr );
  281.  
  282.     fprintf( stderr, " -C" );
  283.  
  284.     if ( fulltbl )
  285.         putc( 'f', stderr );
  286.     if ( fullspd )
  287.         putc( 'F', stderr );
  288.     if ( useecs )
  289.         putc( 'e', stderr );
  290.     if ( usemecs )
  291.         putc( 'm', stderr );
  292.  
  293.     if ( strcmp( skelname, DEFAULT_SKELETON_FILE ) )
  294.         fprintf( stderr, " -S%s", skelname );
  295.  
  296.     putc( '\n', stderr );
  297.  
  298.     fprintf( stderr, "  %d/%d NFA states\n", lastnfa, current_mns );
  299.     fprintf( stderr, "  %d/%d DFA states (%d words)\n", lastdfa,
  300.          current_max_dfas, totnst );
  301.     fprintf( stderr,
  302.          "  %d rules\n", num_rules - 1 /* - 1 for def. rule */ );
  303.  
  304.     if ( num_backtracking == 0 )
  305.         fprintf( stderr, "  No backtracking\n" );
  306.     else if ( fullspd || fulltbl )
  307.         fprintf( stderr, "  %d backtracking (non-accepting) states\n",
  308.              num_backtracking );
  309.     else
  310.         fprintf( stderr, "  compressed tables always backtrack\n" );
  311.  
  312.     if ( bol_needed )
  313.         fprintf( stderr, "  Beginning-of-line patterns used\n" );
  314.  
  315.     fprintf( stderr, "  %d/%d start conditions\n", lastsc,
  316.          current_max_scs );
  317.     fprintf( stderr, "  %d epsilon states, %d double epsilon states\n",
  318.          numeps, eps2 );
  319.  
  320.     if ( lastccl == 0 )
  321.         fprintf( stderr, "  no character classes\n" );
  322.     else
  323.         fprintf( stderr,
  324.     "  %d/%d character classes needed %d/%d words of storage, %d reused\n",
  325.              lastccl, current_maxccls,
  326.              cclmap[lastccl] + ccllen[lastccl],
  327.              current_max_ccl_tbl_size, cclreuse );
  328.  
  329.     fprintf( stderr, "  %d state/nextstate pairs created\n", numsnpairs );
  330.     fprintf( stderr, "  %d/%d unique/duplicate transitions\n",
  331.          numuniq, numdup );
  332.  
  333.     if ( fulltbl )
  334.         {
  335.         tblsiz = lastdfa * numecs;
  336.         fprintf( stderr, "  %d table entries\n", tblsiz );
  337.         }
  338.  
  339.     else
  340.         {
  341.         tblsiz = 2 * (lastdfa + numtemps) + 2 * tblend;
  342.  
  343.         fprintf( stderr, "  %d/%d base-def entries created\n",
  344.              lastdfa + numtemps, current_max_dfas );
  345.         fprintf( stderr, "  %d/%d (peak %d) nxt-chk entries created\n",
  346.              tblend, current_max_xpairs, peakpairs );
  347.         fprintf( stderr,
  348.              "  %d/%d (peak %d) template nxt-chk entries created\n",
  349.              numtemps * nummecs, current_max_template_xpairs,
  350.              numtemps * numecs );
  351.         fprintf( stderr, "  %d empty table entries\n", nummt );
  352.         fprintf( stderr, "  %d protos created\n", numprots );
  353.         fprintf( stderr, "  %d templates created, %d uses\n",
  354.              numtemps, tmpuses );
  355.         }
  356.  
  357.     if ( useecs )
  358.         {
  359.         tblsiz = tblsiz + csize;
  360.         fprintf( stderr, "  %d/%d equivalence classes created\n",
  361.              numecs, csize );
  362.         }
  363.  
  364.     if ( usemecs )
  365.         {
  366.         tblsiz = tblsiz + numecs;
  367.         fprintf( stderr, "  %d/%d meta-equivalence classes created\n",
  368.              nummecs, csize );
  369.         }
  370.  
  371.     fprintf( stderr, "  %d (%d saved) hash collisions, %d DFAs equal\n",
  372.          hshcol, hshsave, dfaeql );
  373.     fprintf( stderr, "  %d sets of reallocations needed\n", num_reallocs );
  374.     fprintf( stderr, "  %d total table entries needed\n", tblsiz );
  375.     }
  376.  
  377. #ifndef VMS
  378.     exit( status );
  379. #else
  380.     exit( status + 1 );
  381. #endif
  382.     }
  383.  
  384.  
  385. /* flexinit - initialize flex
  386.  *
  387.  * synopsis
  388.  *    int argc;
  389.  *    char **argv;
  390.  *    flexinit( argc, argv );
  391.  */
  392.  
  393. void flexinit( argc, argv )
  394. int argc;
  395. char **argv;
  396.  
  397.     {
  398.     int i, sawcmpflag;
  399.     char *arg, *flex_gettime(), *mktemp();
  400.  
  401.     printstats = syntaxerror = trace = spprdflt = interactive = caseins = false;
  402.     backtrack_report = performance_report = ddebug = fulltbl = fullspd = false;
  403.     yymore_used = continued_action = reject = false;
  404.     yymore_really_used = reject_really_used = false;
  405.     gen_line_dirs = usemecs = useecs = true;
  406.  
  407.     sawcmpflag = false;
  408.     use_stdout = false;
  409.  
  410.     csize = DEFAULT_CSIZE;
  411.  
  412.     program_name = argv[0];
  413.  
  414.     /* read flags */
  415.     for ( --argc, ++argv; argc ; --argc, ++argv )
  416.     {
  417.     if ( argv[0][0] != '-' || argv[0][1] == '\0' )
  418.         break;
  419.  
  420.     arg = argv[0];
  421.  
  422.     for ( i = 1; arg[i] != '\0'; ++i )
  423.         switch ( arg[i] )
  424.         {
  425.         case 'b':
  426.             backtrack_report = true;
  427.             break;
  428.  
  429.         case 'c':
  430.             fprintf( stderr,
  431.     "%s: Assuming use of deprecated -c flag is really intended to be -C\n",
  432.                  program_name );
  433.  
  434.             /* fall through */
  435.  
  436.         case 'C':
  437.             if ( i != 1 )
  438.             flexerror( "-C flag must be given separately" );
  439.  
  440.             if ( ! sawcmpflag )
  441.             {
  442.             useecs = false;
  443.             usemecs = false;
  444.             fulltbl = false;
  445.             sawcmpflag = true;
  446.             }
  447.  
  448.             for ( ++i; arg[i] != '\0'; ++i )
  449.             switch ( arg[i] )
  450.                 {
  451.                 case 'e':
  452.                 useecs = true;
  453.                 break;
  454.  
  455.                 case 'F':
  456.                 fullspd = true;
  457.                 break;
  458.  
  459.                 case 'f':
  460.                 fulltbl = true;
  461.                 break;
  462.  
  463.                 case 'm':
  464.                 usemecs = true;
  465.                 break;
  466.  
  467.                 default:
  468.                 lerrif( "unknown -C option '%c'",
  469.                     (int) arg[i] );
  470.                 break;
  471.                 }
  472.  
  473.             goto get_next_arg;
  474.  
  475.         case 'd':
  476.             ddebug = true;
  477.             break;
  478.  
  479.         case 'f':
  480.             useecs = usemecs = false;
  481.             fulltbl = true;
  482.             break;
  483.  
  484.         case 'F':
  485.             useecs = usemecs = false;
  486.             fullspd = true;
  487.             break;
  488.  
  489.         case 'I':
  490.             interactive = true;
  491.             break;
  492.  
  493.         case 'i':
  494.             caseins = true;
  495.             break;
  496.  
  497.         case 'L':
  498.             gen_line_dirs = false;
  499.             break;
  500.  
  501.         case 'n':
  502.             /* stupid do-nothing deprecated option */
  503.             break;
  504.  
  505.         case 'p':
  506.             performance_report = true;
  507.             break;
  508.  
  509.         case 'S':
  510.             if ( i != 1 )
  511.             flexerror( "-S flag must be given separately" );
  512.  
  513.             skelname = arg + i + 1;
  514.             goto get_next_arg;
  515.  
  516.         case 's':
  517.             spprdflt = true;
  518.             break;
  519.  
  520.         case 't':
  521.             use_stdout = true;
  522.             break;
  523.  
  524.         case 'T':
  525.             trace = true;
  526.             break;
  527.  
  528.         case 'v':
  529.             printstats = true;
  530.             break;
  531.  
  532.         case '8':
  533.             csize = CSIZE;
  534.             break;
  535.  
  536.         default:
  537.             lerrif( "unknown flag '%c'", (int) arg[i] );
  538.             break;
  539.         }
  540.  
  541. get_next_arg: /* used by -C and -S flags in lieu of a "continue 2" control */
  542.     ;
  543.     }
  544.  
  545.     if ( (fulltbl || fullspd) && usemecs )
  546.     flexerror( "full table and -Cm don't make sense together" );
  547.  
  548.     if ( (fulltbl || fullspd) && interactive )
  549.     flexerror( "full table and -I are (currently) incompatible" );
  550.  
  551.     if ( fulltbl && fullspd )
  552.     flexerror( "full table and -F are mutually exclusive" );
  553.  
  554.     if ( ! skelname )
  555.     {
  556.     static char skeleton_name_storage[400];
  557.  
  558.     skelname = skeleton_name_storage;
  559.     (void) strcpy( skelname, DEFAULT_SKELETON_FILE );
  560.     }
  561.  
  562.     if ( ! use_stdout )
  563.     {
  564.     FILE *prev_stdout = freopen( outfile, "w", stdout );
  565.  
  566.     if ( prev_stdout == NULL )
  567.         lerrsf( "could not create %s", outfile );
  568.  
  569.     outfile_created = 1;
  570.     }
  571.  
  572.     num_input_files = argc;
  573.     input_files = argv;
  574.     set_input_file( num_input_files > 0 ? input_files[0] : NULL );
  575.  
  576.     if ( backtrack_report )
  577.     {
  578. #ifndef SHORT_FILE_NAMES
  579.     backtrack_file = fopen( "lex.backtrack", "w" );
  580. #else
  581.     backtrack_file = fopen( "lex.bck", "w" );
  582. #endif
  583.  
  584.     if ( backtrack_file == NULL )
  585.         flexerror( "could not create lex.backtrack" );
  586.     }
  587.  
  588.     else
  589.     backtrack_file = NULL;
  590.  
  591.  
  592.     lastccl = 0;
  593.     lastsc = 0;
  594.  
  595.     /* initialize the statistics */
  596.     starttime = flex_gettime();
  597.  
  598.     if ( (skelfile = fopen( skelname, "r" )) == NULL )
  599.     lerrsf( "can't open skeleton file %s", skelname );
  600.  
  601. #ifdef SYS_V
  602.     action_file_name = tmpnam( NULL );
  603. #endif
  604. #ifdef atarist
  605.     action_file_name = tmpnam( NULL );
  606. #endif
  607.  
  608.     if ( action_file_name == NULL )
  609.     {
  610.     static char temp_action_file_name[32];
  611.  
  612. #ifndef SHORT_FILE_NAMES
  613.     (void) strcpy( temp_action_file_name, "/tmp/flexXXXXXX" );
  614. #else
  615.     (void) strcpy( temp_action_file_name, "flexXXXXXX.tmp" );
  616. #endif
  617.     (void) mktemp( temp_action_file_name );
  618.  
  619.     action_file_name = temp_action_file_name;
  620.     }
  621.  
  622.     if ( (temp_action_file = fopen( action_file_name, "w" )) == NULL )
  623.     lerrsf( "can't open temporary action file %s", action_file_name );
  624.  
  625.     lastdfa = lastnfa = num_rules = numas = numsnpairs = tmpuses = 0;
  626.     numecs = numeps = eps2 = num_reallocs = hshcol = dfaeql = totnst = 0;
  627.     numuniq = numdup = hshsave = eofseen = datapos = dataline = 0;
  628.     num_backtracking = onesp = numprots = 0;
  629.     variable_trailing_context_rules = bol_needed = false;
  630.  
  631.     linenum = sectnum = 1;
  632.     firstprot = NIL;
  633.  
  634.     /* used in mkprot() so that the first proto goes in slot 1
  635.      * of the proto queue
  636.      */
  637.     lastprot = 1;
  638.  
  639.     if ( useecs )
  640.     { /* set up doubly-linked equivalence classes */
  641.     /* We loop all the way up to csize, since ecgroup[csize] is the
  642.      * position used for NUL characters
  643.      */
  644.     ecgroup[1] = NIL;
  645.  
  646.     for ( i = 2; i <= csize; ++i )
  647.         {
  648.         ecgroup[i] = i - 1;
  649.         nextecm[i - 1] = i;
  650.         }
  651.  
  652.     nextecm[csize] = NIL;
  653.     }
  654.  
  655.     else
  656.     { /* put everything in its own equivalence class */
  657.     for ( i = 1; i <= csize; ++i )
  658.         {
  659.         ecgroup[i] = i;
  660.         nextecm[i] = BAD_SUBSCRIPT;    /* to catch errors */
  661.         }
  662.     }
  663.  
  664.     set_up_initial_allocations();
  665.     }
  666.  
  667.  
  668. /* readin - read in the rules section of the input file(s)
  669.  *
  670.  * synopsis
  671.  *    readin();
  672.  */
  673.  
  674. void readin()
  675.  
  676.     {
  677.     skelout();
  678.  
  679.     if ( ddebug )
  680.     puts( "#define FLEX_DEBUG" );
  681.  
  682.     if ( csize == 256 )
  683.     puts( "#define YY_CHAR unsigned char" );
  684.     else
  685.     puts( "#define YY_CHAR char" );
  686.  
  687.     line_directive_out( stdout );
  688.  
  689.     if ( yyparse() )
  690.     {
  691.     pinpoint_message( "fatal parse error" );
  692.     flexend( 1 );
  693.     }
  694.  
  695.     if ( xlation )
  696.     {
  697.     numecs = ecs_from_xlation( ecgroup );
  698.     useecs = true;
  699.     }
  700.  
  701.     else if ( useecs )
  702.     numecs = cre8ecs( nextecm, ecgroup, csize );
  703.  
  704.     else
  705.     numecs = csize;
  706.  
  707.     /* now map the equivalence class for NUL to its expected place */
  708.     ecgroup[0] = ecgroup[csize];
  709.     NUL_ec = abs( ecgroup[0] );
  710.  
  711.     if ( useecs )
  712.     ccl2ecl();
  713.     }
  714.  
  715.  
  716.  
  717. /* set_up_initial_allocations - allocate memory for internal tables */
  718.  
  719. void set_up_initial_allocations()
  720.  
  721.     {
  722.     current_mns = INITIAL_MNS;
  723.     firstst = allocate_integer_array( current_mns );
  724.     lastst = allocate_integer_array( current_mns );
  725.     finalst = allocate_integer_array( current_mns );
  726.     transchar = allocate_integer_array( current_mns );
  727.     trans1 = allocate_integer_array( current_mns );
  728.     trans2 = allocate_integer_array( current_mns );
  729.     accptnum = allocate_integer_array( current_mns );
  730.     assoc_rule = allocate_integer_array( current_mns );
  731.     state_type = allocate_integer_array( current_mns );
  732.  
  733.     current_max_rules = INITIAL_MAX_RULES;
  734.     rule_type = allocate_integer_array( current_max_rules );
  735.     rule_linenum = allocate_integer_array( current_max_rules );
  736.  
  737.     current_max_scs = INITIAL_MAX_SCS;
  738.     scset = allocate_integer_array( current_max_scs );
  739.     scbol = allocate_integer_array( current_max_scs );
  740.     scxclu = allocate_integer_array( current_max_scs );
  741.     sceof = allocate_integer_array( current_max_scs );
  742.     scname = allocate_char_ptr_array( current_max_scs );
  743.     actvsc = allocate_integer_array( current_max_scs );
  744.  
  745.     current_maxccls = INITIAL_MAX_CCLS;
  746.     cclmap = allocate_integer_array( current_maxccls );
  747.     ccllen = allocate_integer_array( current_maxccls );
  748.     cclng = allocate_integer_array( current_maxccls );
  749.  
  750.     current_max_ccl_tbl_size = INITIAL_MAX_CCL_TBL_SIZE;
  751.     ccltbl = allocate_character_array( current_max_ccl_tbl_size );
  752.  
  753.     current_max_dfa_size = INITIAL_MAX_DFA_SIZE;
  754.  
  755.     current_max_xpairs = INITIAL_MAX_XPAIRS;
  756.     nxt = allocate_integer_array( current_max_xpairs );
  757.     chk = allocate_integer_array( current_max_xpairs );
  758.  
  759.     current_max_template_xpairs = INITIAL_MAX_TEMPLATE_XPAIRS;
  760.     tnxt = allocate_integer_array( current_max_template_xpairs );
  761.  
  762.     current_max_dfas = INITIAL_MAX_DFAS;
  763.     base = allocate_integer_array( current_max_dfas );
  764.     def = allocate_integer_array( current_max_dfas );
  765.     dfasiz = allocate_integer_array( current_max_dfas );
  766.     accsiz = allocate_integer_array( current_max_dfas );
  767.     dhash = allocate_integer_array( current_max_dfas );
  768.     dss = allocate_int_ptr_array( current_max_dfas );
  769.     dfaacc = allocate_dfaacc_union( current_max_dfas );
  770.  
  771.     nultrans = (int *) 0;
  772.     }
  773.