home *** CD-ROM | disk | FTP | other *** search
/ Crawly Crypt Collection 2 / crawlyvol2.bin / program / c / yaccsrc2 / ysetup.c < prev    next >
Encoding:
C/C++ Source or Header  |  1991-05-19  |  16.3 KB  |  555 lines
  1.  
  2. # include "y2.h"     
  3. # include <stdlib.h> 
  4. # include <string.h> 
  5. # if __MSDOS__
  6. # include <dos.h>    
  7. # else 
  8. # include <ext.h>    
  9. # endif 
  10.  
  11. void               usage  ( void );
  12. void               yyparse( void );
  13.  
  14. extern int         adb,
  15.                    nxdb;
  16. /*
  17.  * YSETUP.C  -- Modified for use with DECUS LEX
  18.  *              Variable "yylval" resides in yylex(), not in yypars();
  19.  *              Therefore, is defined "extern" here.
  20.  *
  21.  *              Also, the command line processing for the Decus version
  22.  *              has been changed.  A new switch has been added to allow
  23.  *              specification of the "table" file name(s), and unused
  24.  *              switch processing removed.
  25.  *
  26.  *                               NOTE
  27.  *              This probably won't run on UNIX any more.
  28.  *
  29.  * Bob Denny 27-Aug-81
  30.  * Bob Denny 22-Mar-82 (01) Added header line, changes for 'new' DECUS library
  31.  * Bob Denny 12-Apr-83 (02) Make filename[] size per #define'd FNAMESIZE so
  32.  *                          VAX filenames won't blow out.  Conditionalize
  33.  *                          time handling for banner.  Make filespec buffer
  34.  *                          static for safety, since global "infile" is
  35.  *                          pointed to it.
  36.  * Scott Guthery 15-May-83  (03) Fixed up option flag handling for RT-11
  37.  *                               23-Dec-83  Adapted for IBM PC/XT & DeSmet C compiler
  38.  * Michiel van Loon
  39.  *               20-Nov-89  Adapted for ATARI-ST
  40.  */
  41.  
  42. static char        filename[ FNAMESIZE ];
  43. static struct date day;
  44. static struct time hour;
  45.  
  46. int                i,
  47.                    j,
  48.                    lev,
  49.                    t,
  50.                    ty;
  51. int                c;
  52. int                tempty;
  53. int              * p;
  54. int                defsw,
  55.                    infsw;
  56. char               actname[ 8 ];
  57. char             * cp;
  58.  
  59. void setup( argc, argv )
  60. int    argc;
  61. char * argv[ ];
  62. {
  63.   char finsave[ FNAMESIZE ];
  64.  
  65.   defsw   = infsw = 0;
  66.   foutput = NULL;
  67.   fdefine = NULL;
  68.   i       = 1;                                /*(03)*/
  69.   while ( argc > 1 && argv[ i ][ 0 ] == '-' ) /*(03)*/
  70.     {
  71.       while ( *++( argv[ i ] ) )
  72.         {
  73.           switch ( *argv[ i ] )
  74.             {
  75.                 # ifdef debug
  76.               case 'a' :
  77.               case 'A' :
  78.                 adb  = 3;
  79.                 continue ;
  80.               case 'n' :
  81.               case 'N' :
  82.                 nxdb = 1;
  83.                 continue ;
  84.                 # endif 
  85.               case 'i' :
  86.               case 'I' :
  87.                 infsw++;
  88.                 continue ;
  89.               case 'h' :
  90.               case 'H' :
  91.                 defsw++;
  92.                 continue ;
  93.               default :
  94.                 fprintf( stderr, "Illegal option: %c\n", *argv[ i ] );
  95.                 usage( );
  96.             }
  97.         }
  98.       i++; /*(03)*/
  99.       argc--;
  100.     }
  101.  
  102.   if ( argc < 2 )
  103.     usage( ); /* Catch no filename given */
  104.  
  105.     /*
  106.      * Now open the input file with a default extension of ".Y",
  107.      * then replace the period in argv[1] with a null, so argv[1]
  108.      * can be used to form the table, defs and info filenames.
  109.      */
  110.  
  111.   cp      = argv[ i ];
  112.   while ( *cp++ != '.' && *cp != '\0' )
  113.     ; /* Scan past '.' or to null */
  114.   if ( *cp == '\0' )
  115.     {
  116.       sprintf( filename, "%s.Y", argv[ i ] );
  117.     }
  118.   else
  119.     {
  120.       strcpy( filename, argv[ i ] );
  121.       *( argv[ i ] - 1 ) = '\0'; /* Null the period */
  122.     }
  123.  
  124.   strcpy( finsave, filename );
  125.   if ( ( finput = fopen( filename, "r" ) ) == NULL )
  126.     error( "cannot open input file \"%s\"", filename );
  127.  
  128.     /*
  129.      * Now open the .H and .I files if requested.
  130.      */
  131.  
  132.   if ( defsw )
  133.     {
  134.       sprintf( filename, "%s.H", argv[ i ] );
  135.       fdefine = fopen( filename, "w" );
  136.       if ( fdefine == NULL )
  137.         error( "cannot open defs file\"%s\"", filename );
  138.     }
  139.  
  140.   if ( infsw )
  141.     {
  142.       sprintf( filename, "%s.I", argv[ i ] );
  143.       if ( ( foutput = fopen( filename, "w" ) ) == NULL )
  144.         error( "cannot open info file\"%s\"", filename );
  145.     }
  146.     /*
  147.      * Now the "table" output C file.
  148.      */
  149.   sprintf( filename, "%s.C", argv[ i ] );
  150.   if ( ( ftable = fopen( filename, "w" ) ) == NULL )
  151.     error( "cannot open table file\"%s\"", filename );
  152.     /*
  153.      * Finally, the temp files.
  154.      */
  155.   if ( ( ftemp = fopen( TEMPNAME, "w" ) ) == NULL )
  156.     error( "cannot open temp file" );
  157.   if ( ( faction = fopen( ACTNAME, "w" ) ) == NULL )
  158.     error( "cannot open action file" );
  159.     /*
  160.      * Now put the full filename of the input file into
  161.      * the "filename" buffer for cpyact(), and point the
  162.      * global cell "infile" at it.
  163.      */
  164.   strcpy( filename, finsave );
  165.   infile  = filename;
  166.   /*
  167.    * Put out a header line at the beginning of the 'table' file.
  168.    */
  169.   fprintf( ftable,
  170.            "/*\n * Created by CSD YACC (MS-DOS/ATARI-ST) from \"%s\"\n",
  171.            infile );
  172.   getdate( &day );
  173.   gettime( &hour );
  174.   fprintf( ftable,
  175.            " * Date %02d/%02d/%02d  Time %02d:%02d:%02d\n",
  176.            day.da_day,
  177.            day.da_mon,
  178.            day.da_year,
  179.            hour.ti_hour,
  180.            hour.ti_min,
  181.            hour.ti_sec );
  182.   fprintf( ftable, "*/\n" );
  183.   /*
  184.    * Complete  initialization.
  185.    */
  186.   cnamp   = cnames;
  187.   defin( 0, "$end" );
  188.   extval  = 0400;
  189.   defin( 0, "error" );
  190.   defin( 1, "$accept" );
  191.   mem     = mem0;
  192.   lev     = 0;
  193.   ty      = 0;
  194.   i       = 0;
  195.  
  196.   yyparse( );
  197. }
  198.  
  199. static void yyparse( )
  200. {
  201.   /* sorry -- no yacc parser here.....
  202.                we must bootstrap somehow... */
  203.  
  204.   for ( t = gettok( ); t != MARK && t != ENDFILE; )
  205.     {
  206.       switch ( t )
  207.         {
  208.  
  209.           case ';' :
  210.             t     = gettok( );
  211.             break ;
  212.  
  213.           case START :
  214.             if ( ( t = gettok( ) ) != IDENTIFIER )
  215.               {
  216.                 error( "bad %%start construction" );
  217.               }
  218.             start = chfind( 1, tokname );
  219.             t     = gettok( );
  220.             continue ;
  221.  
  222.           case TYPEDEF :
  223.             if ( ( t = gettok( ) ) != TYPENAME )
  224.               error( "bad syntax in %%type" );
  225.             ty    = numbval;
  226.             for ( ; ; )
  227.               {
  228.                 t = gettok( );
  229.                 switch ( t )
  230.                   {
  231.  
  232.                     case IDENTIFIER :
  233.                       if ( ( t = chfind( 1, tokname ) ) < NTBASE )
  234.                         {
  235.                           j = TYPE( toklev[ t ] );
  236.                           if ( j != 0 && j != ty )
  237.                             {
  238.                               error( "type redeclaration of token %s",
  239.                                      tokset[ t ].name );
  240.                             }
  241.                           else
  242.                             SETTYPE( toklev[ t ], ty );
  243.                         }
  244.                       else
  245.                         {
  246.                           j = nontrst[ t - NTBASE ].tvalue;
  247.                           if ( j != 0 && j != ty )
  248.                             {
  249.                               error( "type redeclaration of nonterminal %s",
  250.                                      nontrst[ t - NTBASE ].name );
  251.                             }
  252.                           else
  253.                             nontrst[ t - NTBASE ].tvalue = ty;
  254.                         }
  255.                     case ',' :
  256.                       continue ;
  257.  
  258.                     case ';' :
  259.                       t = gettok( );
  260.                       break ;
  261.                     default :
  262.                       break ;
  263.                   }
  264.                 break ;
  265.               }
  266.             continue ;
  267.  
  268.           case UNION :
  269.             /* copy the union declaration to the output */
  270.             cpyunion( );
  271.             t     = gettok( );
  272.             continue ;
  273.  
  274.           case LEFT :
  275.           case BINARY :
  276.           case RIGHT :
  277.             ++i;
  278.           case TERM :
  279.             lev   = t - TERM; /* nonzero means new prec. and assoc. */
  280.             ty    = 0;
  281.  
  282.             /* get identifiers so defined */
  283.  
  284.             t     = gettok( );
  285.             if ( t == TYPENAME )
  286.               {
  287.                 /* there is a type defined */
  288.                 ty = numbval;
  289.                 t  = gettok( );
  290.               }
  291.             for ( ; ; )
  292.               {
  293.                 switch ( t )
  294.                   {
  295.  
  296.                     case ',' :
  297.                       t = gettok( );
  298.                       continue ;
  299.  
  300.                     case ';' :
  301.                       break ;
  302.  
  303.                     case IDENTIFIER :
  304.                       j = chfind( 0, tokname );
  305.                       if ( lev )
  306.                         {
  307.                           if ( ASSOC( toklev[ j ] ) )
  308.                             error( "redeclaration of precedence of%s",
  309.                                    tokname );
  310.                           SETASC( toklev[ j ], lev );
  311.                           SETPLEV( toklev[ j ], i );
  312.                         }
  313.                       if ( ty )
  314.                         {
  315.                           if ( TYPE( toklev[ j ] ) )
  316.                             error( "redeclaration of type of %s",
  317.                                    tokname );
  318.                           SETTYPE( toklev[ j ], ty );
  319.                         }
  320.                       if ( ( t = gettok( ) ) == NUMBER )
  321.                         {
  322.                           tokset[ j ].value = numbval;
  323.                           if ( j < ndefout && j > 2 )
  324.                             {
  325.                               error( "please define type number of %s earlier",
  326.                                      tokset[ j ].name );
  327.                             }
  328.                           t = gettok( );
  329.                         }
  330.                       continue ;
  331.  
  332.                   }
  333.  
  334.                 break ;
  335.               }
  336.  
  337.             continue ;
  338.  
  339.           case LCURLY :
  340.             defout( );
  341.             cpycode( );
  342.             t     = gettok( );
  343.             continue ;
  344.  
  345.           default :
  346.             printf( "Unrecognized character: %o\n", t );
  347.             error( "syntax error" );
  348.  
  349.         }
  350.  
  351.     }
  352.  
  353.   if ( t == ENDFILE )
  354.     {
  355.       error( "unexpected EOF before %%" );
  356.     }
  357.     /* t is MARK */
  358.  
  359.   defout( );
  360.  
  361.   fprintf( ftable, "#define yyclearin yychar = -1\n" );
  362.   fprintf( ftable, "#define yyerrok yyerrflag = 0\n" );
  363.   /*
  364.      fprintf( ftable,"extern int yychar;\nextern short yyerrflag;\n" );
  365.   */
  366.   fprintf( ftable,
  367.            "#ifndef YYMAXDEPTH\n#define YYMAXDEPTH 150\n#endif\n" );
  368.   if ( !ntypes )
  369.     fprintf( ftable, "#ifndef YYSTYPE\n#define YYSTYPE int\n#endif\n" );
  370.     # ifdef unix
  371.   fprintf( ftable, "YYSTYPE yylval, yyval;\n" );
  372.   # else 
  373.   fprintf( ftable, "extern YYSTYPE yylval;  /*CSD & DECUS LEX */\n" );
  374.   fprintf( ftable, "YYSTYPE yyval;          /*CSD & DECUS LEX */\n" );
  375.   # endif 
  376.   prdptr[ 0 ] = mem;
  377.   /* added production */
  378.   *mem++      = NTBASE;
  379.   *mem++      = start;                        /* if start is 0, we will overwrite with the lhs of the firstrule */
  380.   *mem++      = 1;
  381.   *mem++      = 0;
  382.   prdptr[ 1 ] = mem;
  383.   while ( ( t = gettok( ) ) == LCURLY )
  384.     cpycode( );
  385.   if ( t != C_IDENTIFIER )
  386.     error( "bad syntax on first rule" );
  387.   if ( !start )
  388.     prdptr[ 0 ][ 1 ] = chfind( 1, tokname );
  389.  
  390.     /* read rules */
  391.  
  392.   while ( t != MARK && t != ENDFILE )
  393.     {
  394.  
  395.       /* process a rule */
  396.  
  397.       if ( t == '|' )
  398.         {
  399.           *mem++ = *prdptr[ nprod - 1 ];
  400.         }
  401.       else
  402.         if ( t == C_IDENTIFIER )
  403.           {
  404.             *mem = chfind( 1, tokname );
  405.             # ifdef debug
  406.             fprintf( ftable,
  407.                      "setup_lhs nprod = %d ID = %s, id = %d toklev = %d\n",
  408.                      nprod,
  409.                      tokname,
  410.                      *mem,
  411.                      toklev[ *mem ] );
  412.             # endif 
  413.             if ( *mem < NTBASE )
  414.               error( "token illegal on LHS of grammar rule" );
  415.             ++mem;
  416.           }
  417.         else
  418.           error( "illegal rule: missing semicolon or | ?" );
  419.  
  420.       /* read rule body */
  421.       t      = gettok( );
  422.       more_rule : while ( t == IDENTIFIER )
  423.         {
  424.           *mem = chfind( 1, tokname );
  425.           # ifdef debug
  426.           fprintf( ftable,
  427.                    "setup nprod = %d ID = %s id = %d toklev = %d\n",
  428.                    nprod,
  429.                    tokname,
  430.                    *mem,
  431.                    toklev[ *mem ] );
  432.           # endif 
  433.           if ( *mem < NTBASE )
  434.             levprd[ nprod ] = toklev[ *mem ];
  435.           ++mem;
  436.           t    = gettok( );
  437.         }
  438.       if ( t == PREC )
  439.         {
  440.           if ( gettok( ) != IDENTIFIER )
  441.             error( "illegal %%prec syntax" );
  442.           j = chfind( 2, tokname );
  443.           if ( j >= NTBASE )
  444.             error( "nonterminal %s illegal after %%prec",
  445.                    nontrst[ j - NTBASE ].name );
  446.           levprd[ nprod ] = toklev[ j ];
  447.           t = gettok( );
  448.         }
  449.       if ( t == '=' )
  450.         {
  451.           levprd[ nprod ] |= ACTFLAG;
  452.           fprintf( faction, "\ncase %d:", nprod );
  453.           cpyact( mem - prdptr[ nprod ] - 1 );
  454.           fprintf( faction, " break;" );
  455.           if ( ( t = gettok( ) ) == IDENTIFIER )
  456.             {
  457.               /* action within rule... */
  458.               sprintf( actname, "$$%d", nprod );
  459.               j      = chfind( 1, actname ); /* make it a nonterminal */
  460.               /* the current rule will become rule number nprod+1 */
  461.               /* move the contents down, and make room for the null */
  462.               for ( p = mem; p >= prdptr[ nprod ]; --p )
  463.                 p[ 2 ] = *p;
  464.               mem    += 2;
  465.               /* enter null production for action */
  466.               p      = prdptr[ nprod ];
  467.               *p++   = j;
  468.               *p++   = -nprod;
  469.  
  470.               /* update the production information */
  471.               levprd[ nprod + 1 ] = levprd[ nprod ] & ~ACTFLAG;
  472.               levprd[ nprod ]     = ACTFLAG;
  473.  
  474.               if ( ++nprod >= NPROD )
  475.                 error( "more than %d rules", NPROD );
  476.               prdptr[ nprod ]     = p;
  477.  
  478.               /* make the action appear in the original rule */
  479.               *mem++ = j;
  480.  
  481.               /* get some more of the rule */
  482.  
  483.               goto more_rule;
  484.             }
  485.  
  486.         }
  487.  
  488.       while ( t == ';' )
  489.         t = gettok( );
  490.  
  491.       *mem++ = -nprod;
  492.  
  493.       /* check that default action is reasonable */
  494.  
  495.       if ( ntypes &&
  496.            !( levprd[ nprod ] & ACTFLAG ) &&
  497.            nontrst[ *prdptr[ nprod ] - NTBASE ].tvalue )
  498.         {
  499.           /* no explicit action, LHS has value */
  500.           /*01*/
  501.           tempty = prdptr[ nprod ][ 1 ];
  502.           if ( tempty < 0 )
  503.             error( "must return a value, since LHS has a type" );
  504.           else
  505.             if ( tempty >= NTBASE )
  506.               tempty = nontrst[ tempty - NTBASE ].tvalue;
  507.             else
  508.               tempty = TYPE( toklev[ tempty ] );
  509.           if ( tempty != nontrst[ *prdptr[ nprod ] - NTBASE ].tvalue )
  510.             {
  511.               error( "default action causes potential type clash" );
  512.             }
  513.         }
  514.       if ( ++nprod >= NPROD )
  515.         error( "more than %d rules", NPROD );
  516.       prdptr[ nprod ] = mem;
  517.       levprd[ nprod ] = 0;
  518.     }
  519.   /* end of all rules */
  520.   fprintf( faction, "/* End of actions */" ); /* Properly terminate the last line */
  521.   finact( );
  522.   if ( t == MARK )
  523.     {
  524.       fprintf( ftable, "\n#line %d\n", lineno );
  525.       while ( ( c = unix_getc( finput ) ) != EOF )
  526.         putc( c, ftable );
  527.     }
  528.   fclose( finput );
  529.   # ifdef debug
  530.   for ( p = mem0; p != mem; p++ )
  531.     fprintf( ftable, "mem = %ld val = %d\n", p - mem0, *p );
  532.   for ( i = 0; i != nprod; i++ )
  533.     fprintf( ftable,
  534.              "prod = %d prdptr = %ld levprd = 0x%X\n",
  535.              i,
  536.              prdptr[ i ] - mem0,
  537.              levprd[ i ] );
  538.   # endif 
  539. }
  540.  
  541. static void usage( )
  542.  
  543.  
  544. {
  545.   fprintf( stderr, "CSD YACC (MS-DOS/ATARI-ST):\n" );
  546.   fprintf( stderr, "   yacc -hi infile\n\n" );
  547.   fprintf( stderr, "Switches:\n" );
  548.   fprintf( stderr, "   -h   Create definitions header file\n" );
  549.   fprintf( stderr, "   -i   Create parser description file\n\n" );
  550.   fprintf( stderr, "Default input file extension is \".Y\"\n" );
  551.   fprintf( stderr, "Defs file same name, \".H\" extension.\n" );
  552.   fprintf( stderr, "Info file same name, \".I\" extension.\n" );
  553.   exit( EX_ERR );
  554. }
  555.