home *** CD-ROM | disk | FTP | other *** search
/ BURKS 2 / BURKS_AUG97.ISO / BURKS / SOFTWARE / SOURCES / MAWK11AS.ZIP / SCAN.C (.txt) < prev    next >
C/C++ Source or Header  |  1991-12-18  |  22KB  |  833 lines
  1.  
  2. /********************************************
  3. scan.c
  4. copyright 1991, Michael D. Brennan
  5.  
  6. This is a source file for mawk, an implementation of
  7. the AWK programming language.
  8.  
  9. Mawk is distributed without warranty under the terms of
  10. the GNU General Public License, version 2, 1991.
  11. ********************************************/
  12.  
  13.  
  14. /* $Log:    scan.c,v $
  15.  * Revision 5.1  91/12/05  07:56:27  brennan
  16.  * 1.1 pre-release
  17.  * 
  18. */
  19.  
  20.  
  21. #include  "mawk.h"
  22. #include  "sizes.h"
  23. #include  "scan.h"
  24. #include  "memory.h"
  25. #include  "field.h"
  26. #include  "init.h"
  27. #include  "fin.h"
  28. #include  "repl.h"
  29. #include  "code.h"
  30.  
  31. #if HAVE_FCNTL_H
  32. #include  <fcntl.h>
  33. #endif
  34.  
  35. #include  "files.h"
  36.  
  37.  
  38. /* static functions */
  39. static void PROTO(scan_fillbuff, (void) ) ;
  40. static void PROTO(scan_open, (void) ) ;
  41. static int PROTO(slow_next, (void) ) ;
  42. static void PROTO(eat_comment, (void) ) ;
  43. static void PROTO(eat_semi_colon, (void) ) ;
  44. static double PROTO(collect_decimal, (int, int *) ) ;
  45. static int PROTO(collect_string, (void) ) ;
  46. static int  PROTO(collect_RE, (void) ) ;
  47.  
  48.  
  49. /*-----------------------------
  50.   program file management
  51.  *----------------------------*/
  52.  
  53. char *pfile_name ;
  54. STRING  *program_string ;
  55. PFILE *pfile_list ;
  56. static  unsigned char *buffer ;
  57. static  unsigned char *buffp ;  
  58.     /* unsigned so it works with 8 bit chars */
  59. static  int  program_fd   ; 
  60. static  int  eof_flag ;
  61.  
  62. void  scan_init(cmdline_program)
  63.   char * cmdline_program ;
  64. { 
  65.   if ( cmdline_program )
  66.   {
  67.     program_fd = -1 ; /* command line program */
  68.     program_string = new_STRING((char *)0, 
  69.                 strlen(cmdline_program) + 1 ) ;
  70.     (void) strcpy(program_string->str, cmdline_program) ;
  71.     /* simulate file termination */
  72.     program_string->str[program_string->len-1] = '\n' ;
  73.     buffp = (unsigned char *)  program_string->str ;
  74.     eof_flag = 1 ;
  75.   }
  76.   else /* program from file[s] */
  77.   {
  78.     scan_open() ;
  79.     buffp = buffer = (unsigned char *) zmalloc( BUFFSZ+1 ) ;
  80.     scan_fillbuff() ;
  81.   }
  82.  
  83.   eat_nl() ; /* scan to first token */
  84.   if ( next() == 0 ) { errmsg(0, "no program") ; mawk_exit(1) ; }
  85.   un_next() ;
  86.   
  87. }
  88.  
  89. static void  scan_open() /* open pfile_name */
  90. {
  91.   if ( pfile_name[0] == '-' && pfile_name[1] == 0 )
  92.         program_fd = 0 ;
  93.   else
  94.   if ( (program_fd = open(pfile_name, O_RDONLY, 0)) == -1 )
  95.   { errmsg( errno, "cannot open %s", pfile_name) ; mawk_exit(1) ; }
  96. }
  97.  
  98. void scan_cleanup()
  99. { 
  100.   if ( program_fd >= 0 ) zfree(buffer, BUFFSZ+1) ;
  101.   else  free_STRING(program_string) ;
  102.  
  103.   if ( program_fd > 0 )  (void) close(program_fd) ;
  104.  
  105.   /* redefine SPACE as [ \t\n] */
  106.  
  107.   scan_code['\n'] = posix_space_flag && rs_shadow.type != SEP_MLR
  108.             ? SC_UNEXPECTED : SC_SPACE ;
  109.   scan_code['\f'] = SC_UNEXPECTED ; /*value doesn't matter */
  110.   scan_code['\013'] = SC_UNEXPECTED ; /* \v not space */
  111.   scan_code['\r'] = SC_UNEXPECTED ;
  112. }
  113.  
  114. /*--------------------------------
  115.   global variables shared by yyparse() and yylex()
  116.   and used for error messages too
  117.  *-------------------------------*/
  118.  
  119. int  current_token = -1 ; 
  120. unsigned  token_lineno ;
  121. unsigned  compile_error_count ;
  122. int   NR_flag ; /* are we tracking NR */
  123. int   paren_cnt ;
  124. int   brace_cnt ;
  125. int   print_flag ;  /* changes meaning of '>' */
  126. int   getline_flag ; /* changes meaning of '<' */
  127.  
  128. extern  YYSTYPE  yylval ;
  129.  
  130. /*----------------------------------------
  131.  file reading functions
  132.  next() and un_next(c) are macros in scan.h
  133.  
  134.  *---------------------*/
  135.  
  136. static  unsigned lineno = 1 ;
  137.  
  138.  
  139. static  void scan_fillbuff()
  140. { unsigned r ;
  141.  
  142.   r = fillbuff(program_fd, (char *)buffer, BUFFSZ) ;
  143.   if ( r < BUFFSZ ) 
  144.   { eof_flag = 1 ;
  145.     /* check eof is terminated */
  146.     if ( r && buffer[r-1] != '\n' )
  147.     { buffer[r] = '\n' ; buffer[r+1] = 0 ; }
  148.   }
  149. }
  150.  
  151. /* read one character -- slowly */
  152. static int slow_next()
  153. { 
  154.    
  155.   while ( *buffp == 0 )
  156.   {
  157.     if ( !eof_flag ) 
  158.     { buffp = buffer ; scan_fillbuff() ; }
  159.     else
  160.     if ( pfile_list /* open another program file */ )
  161.     {
  162.       PFILE *q ;
  163.  
  164.       if ( program_fd > 0 ) (void) close(program_fd) ;
  165.       eof_flag = 0 ;
  166.       pfile_name = pfile_list->fname ;
  167.       q = pfile_list ;
  168.       pfile_list = pfile_list->link ;
  169.       ZFREE(q) ;
  170.       scan_open() ;
  171.       token_lineno = lineno = 1 ;
  172.     }
  173.     else  break /* real eof */ ;
  174.   }
  175.  
  176.   return *buffp++ ; /* note can un_next() , eof which is zero */
  177. }
  178.  
  179. static void eat_comment()
  180. { register int c ;
  181.  
  182.   while ( (c = next()) != '\n' && scan_code[c] ) ;
  183.   un_next() ;
  184. }
  185.  
  186. /* this is how we handle extra semi-colons that are
  187.    now allowed to separate pattern-action blocks
  188.  
  189.    A proof that they are useless clutter to the language:
  190.    we throw them away
  191. */
  192.  
  193. static  void  eat_semi_colon()
  194. /* eat one semi-colon on the current line */
  195. { register int c ;
  196.  
  197.   while ( scan_code[c = next()] == SC_SPACE )  ;
  198.   if ( c != ';' )  un_next() ;
  199. }
  200.  
  201. void eat_nl() /* eat all space including newlines */
  202. {
  203.   while ( 1 )
  204.     switch( scan_code[next()] )
  205.     { 
  206.       case SC_COMMENT : 
  207.          eat_comment() ;
  208.          break ;
  209.          
  210.       case  SC_NL  :   lineno++ ;
  211.       /* fall thru  */
  212.       case  SC_SPACE  :   break ;
  213.       default :  
  214.           un_next() ; return ;
  215.     }
  216. }
  217.  
  218. int yylex()
  219. { 
  220.   register int c ;
  221.  
  222.   token_lineno = lineno ;
  223.  
  224. reswitch:
  225.  
  226.     switch( scan_code[c = next()] )
  227.     {
  228.       case  0  :  
  229.           ct_ret(EOF) ;
  230.           
  231.       case  SC_SPACE  :   goto reswitch ;
  232.  
  233.       case  SC_COMMENT :
  234.           eat_comment() ; goto reswitch ;
  235.  
  236.       case  SC_NL  : 
  237.           lineno++ ; eat_nl() ;
  238.           ct_ret(NL) ;
  239.  
  240.       case SC_ESCAPE :
  241.           while ( scan_code[ c = next() ] == SC_SPACE ) ;
  242.           if ( c == '\n')
  243.           { token_lineno = ++lineno ; goto reswitch ; }
  244.           if ( c == 0 )  ct_ret(EOF) ;
  245.           un_next() ;
  246.           yylval.ival = '\\' ;
  247.           ct_ret(UNEXPECTED) ;
  248.  
  249.  
  250.       case  SC_SEMI_COLON  : 
  251.           eat_nl() ;
  252.           ct_ret(SEMI_COLON) ;
  253.  
  254.       case  SC_LBRACE :  
  255.           eat_nl() ; brace_cnt++ ;
  256.           ct_ret(LBRACE) ;
  257.  
  258.       case  SC_PLUS  :
  259.           switch( next() )
  260.           {
  261.             case '+' :  
  262.                 yylval.ival = '+' ;
  263.                 string_buff[0] = 
  264.                      string_buff[1] = '+' ;
  265.                 string_buff[2] = 0 ;
  266.                 ct_ret(INC_or_DEC) ;
  267.  
  268.             case  '=' :
  269.                 ct_ret(ADD_ASG) ;
  270.  
  271.             default :  un_next() ; ct_ret(PLUS) ;
  272.           }
  273.  
  274.       case  SC_MINUS :
  275.           switch( next() )
  276.           {
  277.             case '-' :  
  278.                 yylval.ival = '-' ;
  279.                 string_buff[0] = 
  280.                      string_buff[1] = '-' ;
  281.                 string_buff[2] = 0 ;
  282.                 ct_ret(INC_or_DEC) ;
  283.  
  284.             case  '=' :
  285.                 ct_ret(SUB_ASG) ;
  286.  
  287.             default :  un_next() ; ct_ret(MINUS) ;
  288.           }
  289.  
  290.       case  SC_COMMA :  eat_nl() ; ct_ret(COMMA) ;
  291.  
  292.       case  SC_MUL  :  test1_ret('=', MUL_ASG, MUL) ;
  293.       case  SC_DIV :   
  294.           { static int can_precede_div[] =
  295.         { DOUBLE, STRING_, RPAREN, ID, D_ID, RE, RBOX, FIELD,
  296.           GETLINE, INC_or_DEC, -1 } ;
  297.           
  298.           int *p = can_precede_div ;
  299.  
  300.             do
  301.                 if ( *p == current_token )
  302.         {
  303.           if ( *p != INC_or_DEC ) 
  304.             test1_ret('=', DIV_ASG, DIV) ;
  305.  
  306.           if ( next() == '=' )
  307.           { un_next() ; ct_ret( collect_RE() ) ;  }
  308.         }
  309.                  
  310.             while ( * ++p != -1 ) ;
  311.  
  312.             ct_ret( collect_RE() ) ;
  313.           }
  314.  
  315.       case  SC_MOD  :  test1_ret('=', MOD_ASG, MOD) ;
  316.       case  SC_POW :   test1_ret('=' , POW_ASG, POW) ;
  317.       case  SC_LPAREN : 
  318.           paren_cnt++ ;
  319.           ct_ret(LPAREN) ;
  320.  
  321.       case  SC_RPAREN : 
  322.           if ( --paren_cnt < 0 )
  323.           { compile_error( "extra ')'" ) ;
  324.             paren_cnt = 0 ;
  325.             goto reswitch ; }
  326.  
  327.           ct_ret(RPAREN) ;
  328.  
  329.       case  SC_LBOX   : ct_ret(LBOX) ;
  330.       case  SC_RBOX   : ct_ret(RBOX) ;
  331.  
  332.       case  SC_MATCH  : 
  333.       string_buff[0] = '~' ; string_buff[0] = 0 ;