home *** CD-ROM | disk | FTP | other *** search
/ The World of Computer Software / World_Of_Computer_Software-02-387-Vol-3of3.iso / m / mawk11as.zip / SCAN.C < 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 ;
  334.       yylval.ival = 1 ;
  335.       ct_ret(MATCH) ;
  336.  
  337.       case  SC_EQUAL  :
  338.           test1_ret( '=', EQ, ASSIGN ) ;
  339.  
  340.       case  SC_NOT : /* !  */
  341.       if ( (c = next()) == '~' )
  342.       {
  343.         string_buff[0] = '!' ;
  344.         string_buff[1] = '~' ;
  345.         string_buff[2] = 0 ;
  346.         yylval.ival = 0 ;
  347.         ct_ret(MATCH) ;
  348.       }
  349.       else
  350.       if ( c == '=' )  ct_ret(NEQ) ;
  351.  
  352.       un_next() ;
  353.       ct_ret(NOT) ;
  354.  
  355.  
  356.       case  SC_LT  :  /* '<' */
  357.           if ( getline_flag )
  358.           { getline_flag = 0 ; ct_ret(IO_IN) ; }
  359.           else
  360.             test1_ret('=', LTE, LT) ;
  361.  
  362.       case  SC_GT  :  /* '>' */
  363.           if ( print_flag && paren_cnt == 0 )
  364.           { print_flag = 0 ;
  365.             /* there are 3 types of IO_OUT 
  366.                -- build the error string in string_buff */
  367.             string_buff[0] = '>' ;
  368.             if ( next() == '>' ) 
  369.             { 
  370.               yylval.ival = F_APPEND ;
  371.               string_buff[1] = '>' ;
  372.               string_buff[2] =  0 ;
  373.             }
  374.             else
  375.             { un_next() ; 
  376.               yylval.ival = F_TRUNC ; 
  377.               string_buff[1] = 0 ;
  378.             }
  379.             return current_token = IO_OUT ;
  380.           }
  381.  
  382.           test1_ret('=', GTE, GT) ;
  383.  
  384.       case  SC_OR :
  385.           if ( next() == '|' ) 
  386.           { eat_nl() ; ct_ret(OR) ; }
  387.           else 
  388.           { un_next() ; 
  389.  
  390.             if ( print_flag && paren_cnt == 0 )
  391.             { print_flag = 0 ; 
  392.               yylval.ival = PIPE_OUT;
  393.               string_buff[0] = '|' ;
  394.               string_buff[1] = 0 ;
  395.               ct_ret(IO_OUT) ;
  396.             }
  397.             else  ct_ret(PIPE) ;
  398.           }
  399.  
  400.       case  SC_AND :
  401.           if ( next() == '&' )  
  402.           { eat_nl() ; ct_ret(AND) ; }
  403.           else 
  404.           { un_next() ; yylval.ival = '&' ; ct_ret(UNEXPECTED) ; }
  405.  
  406.       case  SC_QMARK  :  ct_ret(QMARK) ;
  407.       case  SC_COLON  :  ct_ret(COLON) ;
  408.       case  SC_RBRACE :
  409.           if ( --brace_cnt < 0 )
  410.           { compile_error("extra '}'" ) ;
  411.             eat_semi_colon() ;
  412.             brace_cnt = 0 ; goto reswitch ; }
  413.  
  414.           if ( (c = current_token) == NL || c == SEMI_COLON 
  415.                || c == SC_FAKE_SEMI_COLON  || c == RBRACE  )
  416.           { 
  417.             /* if the brace_cnt is zero , we've completed
  418.                a pattern action block. If the user insists
  419.                on adding a semi-colon on the same line
  420.                we will eat it.  Note what we do below:
  421.                physical law -- conservation of semi-colons */
  422.  
  423.             if ( brace_cnt == 0 )  eat_semi_colon() ;
  424.             eat_nl() ;
  425.             ct_ret(RBRACE) ;
  426.           }
  427.  
  428.           /* supply missing semi-colon to statement that
  429.              precedes a '}' */
  430.           brace_cnt++ ; un_next() ;
  431.           current_token = SC_FAKE_SEMI_COLON ;
  432.           return  SEMI_COLON ;
  433.  
  434.       case  SC_DIGIT  :
  435.       case  SC_DOT    :
  436.           { double d ;
  437.             int flag ;
  438.         static double double_zero = 0.0 ;
  439.         static double double_one = 1.0 ;
  440.  
  441.             if ( (d = collect_decimal(c, &flag)) == 0.0 )
  442.                 if ( flag )  ct_ret(flag) ;
  443.                 else  yylval.ptr = (PTR) &double_zero ;
  444.             else if ( d == 1.0 ) yylval.ptr = (PTR) &double_one ;
  445.             else 
  446.             { yylval.ptr = (PTR) ZMALLOC(double) ;
  447.           *(double*)yylval.ptr = d ;
  448.             }
  449.             ct_ret( DOUBLE ) ;
  450.           }
  451.  
  452.       case  SC_DOLLAR :  /* '$' */
  453.           { double d ;
  454.             int flag ;
  455.  
  456.             while ( scan_code[c = next()] == SC_SPACE )  ;
  457.             if ( scan_code[c] != SC_DIGIT &&
  458.                  scan_code[c] != SC_DOT )
  459.             { un_next() ; ct_ret(DOLLAR) ; }
  460.             /* compute field address at compile time */
  461.             if ( (d = collect_decimal(c, &flag)) == 0.0 )
  462.                 if ( flag )  ct_ret(flag) ; /* an error */
  463.                 else  yylval.cp = &field[0] ;
  464.             else
  465.             { int k = (int) d ;
  466.  
  467.               if ( k > MAX_FIELD )
  468.               { compile_error(
  469.                    "$%g exceeds maximum field(%d)" , d, MAX_FIELD) ;
  470.                 k = MAX_FIELD ;
  471.               }
  472.               yylval.cp = field_ptr(k) ;
  473.             }
  474.  
  475.             ct_ret(FIELD) ;
  476.           }
  477.  
  478.       case  SC_DQUOTE :
  479.           return current_token = collect_string() ;
  480.  
  481.       case  SC_IDCHAR : /* collect an identifier */
  482.             { unsigned char *p =
  483.                     (unsigned char *)string_buff + 1 ;
  484.               SYMTAB *stp ;
  485.  
  486.               string_buff[0] = c ;
  487.  
  488.               while ( 
  489.                 (c = scan_code[ *p++ = next()]) == SC_IDCHAR ||
  490.                        c == SC_DIGIT )  ;
  491.               
  492.               un_next() ; * --p = 0 ;
  493.  
  494.               switch( (stp = find(string_buff))->type )
  495.               { case ST_NONE :  
  496.                   /* check for function call before defined */
  497.                       if ( next() == '(' )
  498.                       { stp->type = ST_FUNCT ;
  499.                         stp->stval.fbp = (FBLOCK *)
  500.                                 zmalloc(sizeof(FBLOCK)) ;
  501.                         stp->stval.fbp->name = stp->name ;
  502.                         stp->stval.fbp->code = (INST *) 0 ;
  503.                         yylval.fbp = stp->stval.fbp ;
  504.                         current_token = FUNCT_ID ;
  505.                       }
  506.                       else
  507.                       { yylval.stp = stp ;
  508.                         current_token = 
  509.                             current_token == DOLLAR ? D_ID : ID ;
  510.                       }
  511.                       un_next() ;
  512.                       break ;
  513.  
  514.                 case  ST_NR  :
  515.               NR_flag = 1 ;
  516.                       stp->type = ST_VAR ;
  517.                       /* fall thru */
  518.                         
  519.                 case ST_VAR :
  520.                 case  ST_ARRAY :
  521.                 case  ST_LOCAL_NONE :
  522.                 case  ST_LOCAL_VAR :
  523.                 case  ST_LOCAL_ARRAY :
  524.  
  525.                       yylval.stp = stp ;
  526.                       current_token =
  527.                             current_token == DOLLAR ? D_ID : ID ;
  528.                       break ;
  529.  
  530.         case ST_ENV :
  531.               stp->type = ST_ARRAY ;
  532.               stp->stval.array = new_ARRAY() ;
  533.               load_environ(stp->stval.array) ;
  534.               yylval.stp = stp ;
  535.               current_token =
  536.               current_token == DOLLAR ? D_ID : ID ;
  537.               break ;
  538.  
  539.                 case ST_FUNCT :
  540.                       yylval.fbp = stp->stval.fbp ;
  541.                       current_token = FUNCT_ID ;
  542.                       break ;
  543.  
  544.                 case ST_KEYWORD :  
  545.                       current_token = stp->stval.kw ;
  546.                       break ;
  547.  
  548.                 case  ST_BUILTIN :
  549.                       yylval.bip = stp->stval.bip ;
  550.                       current_token = BUILTIN ;
  551.                       break ;
  552.  
  553.                 case  ST_FIELD  :
  554.                       yylval.cp = stp->stval.cp ;
  555.                       current_token = FIELD ;
  556.                       break ;
  557.  
  558.                 default : 
  559.                       bozo("find returned bad st type") ;
  560.               }
  561.               return  current_token  ;
  562.             }
  563.  
  564.  
  565.       case  SC_UNEXPECTED :
  566.             yylval.ival = c & 0xff ;
  567.             ct_ret(UNEXPECTED) ;
  568.     }
  569.     return  0 ; /* never get here make lint happy */
  570. }
  571.  
  572. /* collect a decimal constant in temp_buff.
  573.    Return the value and error conditions by reference */
  574.  
  575. static double collect_decimal(c, flag)
  576.   int c ; int *flag ;
  577. { register unsigned char *p = (unsigned char*) string_buff + 1;
  578.   unsigned char *endp ;
  579.   double d ;
  580.  
  581.   *flag = 0 ;
  582.   string_buff[0] = c ;
  583.  
  584.   if ( c == '.' )
  585.   { if ( scan_code[*p++ = next()] != SC_DIGIT )
  586.     { *flag = UNEXPECTED ; yylval.ival = '.' ;
  587.       return 0.0 ; }
  588.   }
  589.   else
  590.   {  while ( scan_code[*p++ = next()] == SC_DIGIT ) ;
  591.      if ( p[-1] != '.' )
  592.      { un_next() ; p-- ; }
  593.   }
  594.   /* get rest of digits after decimal point */
  595.   while ( scan_code[*p++ = next()] == SC_DIGIT )  ;
  596.  
  597.   /* check for exponent */
  598.   if ( p[-1] != 'e' && p[-1] != 'E' )
  599.   { un_next() ; * --p = 0 ; }
  600.   else  /* get the exponent */
  601.     if ( scan_code[*p = next()] != SC_DIGIT &&
  602.          *p != '-' && *p != '+' )
  603.     { *++p = 0 ; *flag = BAD_DECIMAL ;
  604.       return 0.0 ; }
  605.     else  /* get the rest of the exponent */
  606.     { p++ ;
  607.       while ( scan_code[*p++ = next()] == SC_DIGIT )  ;
  608.       un_next() ; * --p = 0 ;
  609.     }
  610.  
  611.   errno = 0 ; /* check for overflow/underflow */
  612.   d = strtod( string_buff, (char **)&endp ) ;
  613.  
  614. #ifndef  STRTOD_UNDERFLOW_ON_ZERO_BUG
  615.   if ( errno )
  616.       compile_error( "%s : decimal %sflow" , string_buff,
  617.         d == 0.0 ? "under" : "over") ;
  618. #else /* sun4 bug */
  619.   if ( errno && d != 0.0 )
  620.       compile_error( "%s : decimal overflow", string_buff) ;
  621. #endif
  622.  
  623.   if ( endp < p )
  624.   { *flag = BAD_DECIMAL ; return 0.0 ; }
  625.   return d ;
  626. }
  627.  
  628. /*----------  process escape characters ---------------*/
  629.  
  630. static char hex_val['f' - 'A' + 1] = {
  631. 10,11,12,13,14,15, 0, 0,
  632.  0, 0, 0, 0, 0, 0, 0, 0,
  633.  0, 0, 0, 0, 0, 0, 0, 0,
  634.  0, 0, 0, 0, 0, 0, 0, 0,
  635. 10,11,12,13,14,15 } ;
  636.  
  637. #define isoctal(x)  ((x)>='0'&&(x)<='7')
  638.  
  639. #define  hex_value(x)   hex_val[(x)-'A']
  640.  
  641. #define ishex(x) (scan_code[x] == SC_DIGIT ||\
  642.                   'A' <= (x) && (x) <= 'f' && hex_value(x))
  643.  
  644. static int PROTO(octal, (char **)) ;
  645. static int PROTO(hex, (char **)) ;
  646.  
  647. /* process one , two or three octal digits
  648.    moving a pointer forward by reference */
  649. static int octal( start_p )
  650.   char **start_p ;
  651. { register char *p = *start_p ;
  652.   register unsigned x ;
  653.  
  654.   x = *p++ - '0' ;
  655.   if ( isoctal(*p) )
  656.   {
  657.     x = (x<<3) + *p++ - '0' ;
  658.     if ( isoctal(*p) )   x = (x<<3) + *p++ - '0' ;
  659.   }
  660.   *start_p = p ;
  661.   return  x & 0xff ;
  662. }
  663.  
  664. /* process one or two hex digits
  665.    moving a pointer forward by reference */
  666.  
  667. static int  hex( start_p )
  668.   char **start_p ;
  669. { register unsigned char *p = (unsigned char*) *start_p ;
  670.   register unsigned x ;
  671.   unsigned t ;
  672.  
  673.   if ( scan_code[*p] == SC_DIGIT )
  674.         x = *p++ - '0' ;
  675.   else  x = hex_value(*p++) ;
  676.  
  677.   if ( scan_code[*p] == SC_DIGIT )
  678.         x = (x<<4) + *p++ - '0' ;
  679.   else
  680.   if ( 'A' <= *p && *p <= 'f' && (t = hex_value(*p)) )
  681.   { x = (x<<4) + t ; p++ ; }
  682.  
  683.   *start_p = (char *) p ;
  684.   return x ;
  685. }
  686.  
  687. #define  ET_END     9
  688.  
  689. static struct { char in , out ; } escape_test[ET_END+1] = {
  690. 'n' , '\n',
  691. 't' , '\t',
  692. 'f' , '\f',
  693. 'b' , '\b',
  694. 'r' , '\r',
  695. 'a' , '\07',
  696. 'v' , '\013',
  697. '\\', '\\',
  698. '\"', '\"',
  699. 0 , 0 } ;
  700.  
  701.  
  702. /* process the escape characters in a string, in place . */
  703.  
  704. char *rm_escape(s)
  705.   char *s ;
  706. { register char *p, *q ;
  707.   char *t ;
  708.   int i ;
  709.  
  710.   q = p = s ;
  711.  
  712.   while ( *p )
  713.       if ( *p == '\\' )
  714.       { 
  715.         escape_test[ET_END].in = * ++p ; /* sentinal */
  716.         i = 0 ;
  717.         while ( escape_test[i].in != *p )  i++ ;
  718.  
  719.         if ( i != ET_END )  /* in table */
  720.         { 
  721.           p++ ; *q++ = escape_test[i].out ;
  722.         }
  723.         else
  724.         if ( isoctal(*p) ) 
  725.         {
  726.           t = p ;  *q++ = octal(&t) ; p = t ;
  727.         }
  728.         else
  729.         if ( *p == 'x' && ishex(*(unsigned char*)(p+1)) )
  730.         {
  731.           t = p+1 ; *q++ = hex(&t) ; p = t ;
  732.         }
  733.         else
  734.         if ( *p == 0 ) /* can only happen with command line assign */
  735.             *q++ = '\\' ;
  736.         else  /* not an escape sequence */
  737.         { 
  738.           *q++ = '\\' ; *q++ = *p++ ;
  739.         }
  740.       }
  741.       else  *q++ = *p++ ;
  742.  
  743.   *q = 0 ;
  744.   return s ;
  745. }
  746.  
  747. static  int  collect_string()
  748. { register unsigned char *p = (unsigned char *)string_buff ;
  749.   int c ;
  750.   int e_flag = 0 ; /* on if have an escape char */
  751.  
  752.   while ( 1 )
  753.       switch( scan_code[ *p++ = next() ] )
  754.       { case  SC_DQUOTE : /* done */
  755.               * --p = 0 ;  goto out ;
  756.  
  757.         case  SC_NL :
  758.               p[-1] = 0 ;
  759.               /* fall thru */
  760.  
  761.         case  0 :   /* unterminated string */
  762.               compile_error(
  763.               "runaway string constant \"%.10s ..." ,
  764.               string_buff, token_lineno ) ;
  765.               mawk_exit(1) ;
  766.  
  767.         case SC_ESCAPE :
  768.               if ( (c = next()) == '\n' )
  769.               { p-- ; lineno++ ; }
  770.               else  
  771.                 if ( c == 0 )  un_next() ;   
  772.                 else 
  773.                 { *p++ = c ; e_flag = 1 ; }
  774.  
  775.               break ;
  776.  
  777.         default : break ;
  778.       }
  779.  
  780. out:
  781.     yylval.ptr = (PTR) new_STRING(
  782.          e_flag ? rm_escape( string_buff ) 
  783.                 : string_buff ) ;
  784.     return  STRING_ ;
  785. }
  786.  
  787.  
  788. static  int  collect_RE()
  789. { register unsigned char *p = (unsigned char*) string_buff ;
  790.   int c ;
  791.   STRING *sval ;
  792.  
  793.   while ( 1 )
  794.       switch( scan_code[ *p++ = next() ] )
  795.       { case  SC_DIV : /* done */
  796.               * --p = 0 ;  goto out ;
  797.  
  798.         case  SC_NL :
  799.               p[-1] = 0 ;
  800.               /* fall thru */
  801.  
  802.         case  0 :   /* unterminated re */
  803.               compile_error(
  804.               "runaway regular expression /%.10s ..." ,
  805.               string_buff, token_lineno ) ;
  806.               mawk_exit(1) ;
  807.  
  808.         case SC_ESCAPE :
  809.               switch( c = next() )
  810.               { case '/' :  
  811.                       p[-1] = '/' ; break ;
  812.  
  813.                 case '\n' :
  814.                       p-- ;  break ;
  815.  
  816.                 case  0   :
  817.                       un_next() ;  break ;
  818.  
  819.                 default :
  820.                       *p++ = c ; break ;
  821.               }
  822.               break ;
  823.       }
  824.  
  825. out:
  826.   /* now we've got the RE, so compile it */
  827.   sval = new_STRING( string_buff ) ;
  828.   yylval.ptr = re_compile(sval) ;
  829.   free_STRING(sval) ;
  830.   return RE ;
  831. }
  832.  
  833.