home *** CD-ROM | disk | FTP | other *** search
/ Crawly Crypt Collection 2 / crawlyvol2.bin / program / c / yaccsrc2 / ygttok.c < prev    next >
Encoding:
C/C++ Source or Header  |  1991-05-19  |  5.3 KB  |  209 lines
  1.  
  2. # include "y2.h"     
  3. # include <string.h> 
  4. # include <ctype.h>  
  5.  
  6. extern int peekline; /* number of '\n' seen in lookahead */
  7.  
  8. int gettok( )
  9. {
  10.   register i,
  11.            base;
  12.   register c,
  13.            match,
  14.            reserve;
  15.  
  16.   begin : reserve = 0;
  17.   lineno          += peekline;
  18.   peekline        = 0;
  19.   c               = unix_getc( finput );
  20.   while ( c == ' ' || c == '\n' || c == '\t' || c == '\f' || c == '\r' )
  21.     {
  22.       if ( c == '\n' )
  23.         ++lineno;
  24.       c = unix_getc( finput );
  25.     }
  26.   if ( c == '/' )
  27.     {
  28.       /* skip comment */
  29.       lineno += skipcom( );
  30.       goto begin;
  31.     }
  32.  
  33.   switch ( c )
  34.     {
  35.  
  36.       case -1 :         /* EOF */
  37.         return ( ENDFILE );
  38.       case '{' :
  39.         yacc_ungetc( c );
  40.         return ( '=' ); /* action ... */
  41.       case '<' :        /* get, and look up, a type name (union member name) */
  42.         i     = 0;
  43.         while ( ( c = unix_getc( finput ) ) != '>' &&
  44.                 c >= 0 &&
  45.                 c != '\n' )
  46.           {
  47.             tokname[ i ] = c;
  48.             if ( ++i >= NAMESIZE )
  49.               --i;
  50.           }
  51.         if ( c != '>' )
  52.           error( "unterminated < ... > clause" );
  53.         tokname[ i ] = '\0';
  54.         for ( i = 1; i <= ntypes; ++i )
  55.           {
  56.             if ( !strcmp( typeset[ i ], tokname ) )
  57.               {
  58.                 numbval = i;
  59.                 return ( TYPENAME );
  60.               }
  61.           }
  62.         typeset[ numbval = ++ntypes ] = cstash( tokname );
  63.         return ( TYPENAME );
  64.  
  65.       case '"' :
  66.       case '\'' :
  67.         match = c;
  68.         tokname[ 0 ] = ' ';
  69.         i     = 1;
  70.         for ( ; ; )
  71.           {
  72.             c = unix_getc( finput );
  73.             if ( c == '\n' || c == EOF )
  74.               error( "illegal or missing ' or \"" );
  75.             if ( c == '\\' )
  76.               {
  77.                 c = unix_getc( finput );
  78.                 tokname[ i ] = '\\';
  79.                 if ( ++i >= NAMESIZE )
  80.                   --i;
  81.               }
  82.             else
  83.               if ( c == match )
  84.                 break ;
  85.             tokname[ i ] = c;
  86.             if ( ++i >= NAMESIZE )
  87.               --i;
  88.           }
  89.         break ;
  90.  
  91.       case '%' :
  92.       case '\\' :
  93.  
  94.         switch ( c = unix_getc( finput ) )
  95.           {
  96.  
  97.             case '0' :
  98.               return ( TERM );
  99.             case '<' :
  100.               return ( LEFT );
  101.             case '2' :
  102.               return ( BINARY );
  103.             case '>' :
  104.               return ( RIGHT );
  105.             case '%' :
  106.             case '\\' :
  107.               return ( MARK );
  108.             case '=' :
  109.               return ( PREC );
  110.             case '{' :
  111.               return ( LCURLY );
  112.             default :
  113.               reserve = 1;
  114.           }
  115.  
  116.       default :
  117.  
  118.         if ( isdigit( c ) )
  119.           {
  120.             /* number */
  121.             numbval = c - '0';
  122.             base    = ( c == '0' ) ? 8 : 10;
  123.             for ( c = unix_getc( finput );
  124.                   isdigit( c );\
  125.                   c = getc( finput ) )
  126.               {
  127.                 numbval = numbval * base + c - '0';
  128.               }
  129.             yacc_ungetc( c );
  130.             return ( NUMBER );
  131.           }
  132.         else
  133.           if ( islower( c ) ||\
  134.                isupper( c ) ||\
  135.                c == '_' ||\
  136.                c == '.' ||\
  137.                c == '$' )
  138.             {
  139.               i = 0;
  140.               while ( islower( c ) ||\
  141.                       isupper( c ) ||\
  142.                       isdigit( c ) ||\
  143.                       c == '_' ||\
  144.                       c == '.' ||\
  145.                       c == '$' )
  146.                 {
  147.                   tokname[ i ] = c;
  148.                   if ( reserve && isupper( c ) )
  149.                     tokname[ i ] += 'a' - 'A';
  150.                   if ( ++i >= NAMESIZE )
  151.                     --i;
  152.                   c = unix_getc( finput );
  153.                 }
  154.             }
  155.           else
  156.             return ( c );
  157.  
  158.         yacc_ungetc( c );
  159.     }
  160.  
  161.   tokname[ i ]    = '\0';
  162.  
  163.   if ( reserve )
  164.     {
  165.       /* find a reserved word */
  166.       if ( !strcmp( tokname, "term" ) )
  167.         return ( TERM );
  168.       if ( !strcmp( tokname, "token" ) )
  169.         return ( TERM );
  170.       if ( !strcmp( tokname, "left" ) )
  171.         return ( LEFT );
  172.       if ( !strcmp( tokname, "nonassoc" ) )
  173.         return ( BINARY );
  174.       if ( !strcmp( tokname, "binary" ) )
  175.         return ( BINARY );
  176.       if ( !strcmp( tokname, "right" ) )
  177.         return ( RIGHT );
  178.       if ( !strcmp( tokname, "prec" ) )
  179.         return ( PREC );
  180.       if ( !strcmp( tokname, "start" ) )
  181.         return ( START );
  182.       if ( !strcmp( tokname, "type" ) )
  183.         return ( TYPEDEF );
  184.       if ( !strcmp( tokname, "union" ) )
  185.         return ( UNION );
  186.       error( "invalid escape, or illegal reserved word: %s", tokname );
  187.     }
  188.  
  189.     /* look ahead to distinguish IDENTIFIER from C_IDENTIFIER */
  190.  
  191.   c               = unix_getc( finput );
  192.   while ( c == ' ' || c == '\t' || c == '\n' || c == '\f' || c == '/' )
  193.     {
  194.       if ( c == '\n' )
  195.         ++peekline;
  196.       else
  197.         if ( c == '/' )
  198.           {
  199.             /* look for comments */
  200.             peekline += skipcom( );
  201.           }
  202.       c = unix_getc( finput );
  203.     }
  204.   if ( c == ':' )
  205.     return ( C_IDENTIFIER );
  206.   yacc_ungetc( c );
  207.   return ( IDENTIFIER );
  208. }
  209.