home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 11 Util / 11-Util.zip / MAWK113.ZIP / mawk113 / scan.c < prev    next >
C/C++ Source or Header  |  1993-01-14  |  22KB  |  859 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.4.1.1  1993/01/15  03:33:50  mike
  16.  * patch3: safer double to int conversion
  17.  *
  18.  * Revision 5.4  1992/11/29  18:57:50  mike
  19.  * field expressions convert to long so 16 bit and 32 bit
  20.  * systems behave the same
  21.  *
  22.  * Revision 5.3  1992/07/08  15:43:41  brennan
  23.  * patch2: length returns.  I am a wimp
  24.  *
  25.  * Revision 5.2  1992/02/21  14:16:53  brennan
  26.  * fix:  getline <=
  27.  *
  28.  * Revision 5.1  91/12/05  07:56:27  brennan
  29.  * 1.1 pre-release
  30.  * 
  31. */
  32.  
  33.  
  34. #include  "mawk.h"
  35. #include  "sizes.h"
  36. #include  "scan.h"
  37. #include  "memory.h"
  38. #include  "field.h"
  39. #include  "init.h"
  40. #include  "fin.h"
  41. #include  "repl.h"
  42. #include  "code.h"
  43.  
  44. #if HAVE_FCNTL_H
  45. #include  <fcntl.h>
  46. #endif
  47.  
  48. #include  "files.h"
  49.  
  50.  
  51. /* static functions */
  52. static void PROTO(scan_fillbuff, (void) ) ;
  53. static void PROTO(scan_open, (void) ) ;
  54. static int PROTO(slow_next, (void) ) ;
  55. static void PROTO(eat_comment, (void) ) ;
  56. static void PROTO(eat_semi_colon, (void) ) ;
  57. static double PROTO(collect_decimal, (int, int *) ) ;
  58. static int PROTO(collect_string, (void) ) ;
  59. static int  PROTO(collect_RE, (void) ) ;
  60.  
  61.  
  62. /*-----------------------------
  63.   program file management
  64.  *----------------------------*/
  65.  
  66. char *pfile_name ;
  67. STRING  *program_string ;
  68. PFILE *pfile_list ;
  69. static  unsigned char *buffer ;
  70. static  unsigned char *buffp ;  
  71.     /* unsigned so it works with 8 bit chars */
  72. static  int  program_fd   ; 
  73. static  int  eof_flag ;
  74.  
  75. void  scan_init(cmdline_program)
  76.   char * cmdline_program ;
  77. { 
  78.   if ( cmdline_program )
  79.   {
  80.     program_fd = -1 ; /* command line program */
  81.     program_string = new_STRING((char *)0, 
  82.                 strlen(cmdline_program) + 1 ) ;
  83.     (void) strcpy(program_string->str, cmdline_program) ;
  84.     /* simulate file termination */
  85.     program_string->str[program_string->len-1] = '\n' ;
  86.     buffp = (unsigned char *)  program_string->str ;
  87.     eof_flag = 1 ;
  88.   }
  89.   else /* program from file[s] */
  90.   {
  91.     scan_open() ;
  92.     buffp = buffer = (unsigned char *) zmalloc( BUFFSZ+1 ) ;
  93.     scan_fillbuff() ;
  94.   }
  95.  
  96.   eat_nl() ; /* scan to first token */
  97.   if ( next() == 0 ) { errmsg(0, "no program") ; mawk_exit(1) ; }
  98.   un_next() ;
  99.   
  100. }
  101.  
  102. static void  scan_open() /* open pfile_name */
  103. {
  104.   if ( pfile_name[0] == '-' && pfile_name[1] == 0 )
  105.         program_fd = 0 ;
  106.   else
  107.   if ( (program_fd = open(pfile_name, O_RDONLY, 0)) == -1 )
  108.   { errmsg( errno, "cannot open %s", pfile_name) ; mawk_exit(1) ; }
  109. }
  110.  
  111. void scan_cleanup()
  112. { 
  113.   if ( program_fd >= 0 ) zfree(buffer, BUFFSZ+1) ;
  114.   else  free_STRING(program_string) ;
  115.  
  116.   if ( program_fd > 0 )  (void) close(program_fd) ;
  117.  
  118.   /* redefine SPACE as [ \t\n] */
  119.  
  120.   scan_code['\n'] = posix_space_flag && rs_shadow.type != SEP_MLR
  121.             ? SC_UNEXPECTED : SC_SPACE ;
  122.   scan_code['\f'] = SC_UNEXPECTED ; /*value doesn't matter */
  123.   scan_code['\013'] = SC_UNEXPECTED ; /* \v not space */
  124.   scan_code['\r'] = SC_UNEXPECTED ;
  125. }
  126.  
  127. /*--------------------------------
  128.   global variables shared by yyparse() and yylex()
  129.   and used for error messages too
  130.  *-------------------------------*/
  131.  
  132. int  current_token = -1 ; 
  133. unsigned  token_lineno ;
  134. unsigned  compile_error_count ;
  135. int   NR_flag ; /* are we tracking NR */
  136. int   paren_cnt ;
  137. int   brace_cnt ;
  138. int   print_flag ;  /* changes meaning of '>' */
  139. int   getline_flag ; /* changes meaning of '<' */
  140.  
  141. extern  YYSTYPE  yylval ;
  142.  
  143. /*----------------------------------------
  144.  file reading functions
  145.  next() and un_next(c) are macros in scan.h
  146.  
  147.  *---------------------*/
  148.  
  149. static  unsigned lineno = 1 ;
  150.  
  151.  
  152. static  void scan_fillbuff()
  153. { unsigned r ;
  154.  
  155.   r = fillbuff(program_fd, (char *)buffer, BUFFSZ) ;
  156.   if ( r < BUFFSZ ) 
  157.   { eof_flag = 1 ;
  158.     /* check eof is terminated */
  159.     if ( r && buffer[r-1] != '\n' )
  160.     { buffer[r] = '\n' ; buffer[r+1] = 0 ; }
  161.   }
  162. }
  163.  
  164. /* read one character -- slowly */
  165. static int slow_next()
  166. { 
  167.    
  168.   while ( *buffp == 0 )
  169.   {
  170.     if ( !eof_flag ) 
  171.     { buffp = buffer ; scan_fillbuff() ; }
  172.     else
  173.     if ( pfile_list /* open another program file */ )
  174.     {
  175.       PFILE *q ;
  176.  
  177.       if ( program_fd > 0 ) (void) close(program_fd) ;
  178.       eof_flag = 0 ;
  179.       pfile_name = pfile_list->fname ;
  180.       q = pfile_list ;
  181.       pfile_list = pfile_list->link ;
  182.       ZFREE(q) ;
  183.       scan_open() ;
  184.       token_lineno = lineno = 1 ;
  185.     }
  186.     else  break /* real eof */ ;
  187.   }
  188.  
  189.   return *buffp++ ; /* note can un_next() , eof which is zero */
  190. }
  191.  
  192. static void eat_comment()
  193. { register int c ;
  194.  
  195.   while ( (c = next()) != '\n' && scan_code[c] ) ;
  196.   un_next() ;
  197. }
  198.  
  199. /* this is how we handle extra semi-colons that are
  200.    now allowed to separate pattern-action blocks
  201.  
  202.    A proof that they are useless clutter to the language:
  203.    we throw them away
  204. */
  205.  
  206. static  void  eat_semi_colon()
  207. /* eat one semi-colon on the current line */
  208. { register int c ;
  209.  
  210.   while ( scan_code[c = next()] == SC_SPACE )  ;
  211.   if ( c != ';' )  un_next() ;
  212. }
  213.  
  214. void eat_nl() /* eat all space including newlines */
  215. {
  216.   while ( 1 )
  217.     switch( scan_code[next()] )
  218.     { 
  219.       case SC_COMMENT : 
  220.          eat_comment() ;
  221.          break ;
  222.          
  223.       case  SC_NL  :   lineno++ ;
  224.       /* fall thru  */
  225.       case  SC_SPACE  :   break ;
  226.       default :  
  227.           un_next() ; return ;
  228.     }
  229. }
  230.  
  231. int yylex()
  232. { 
  233.   register int c ;
  234.  
  235.   token_lineno = lineno ;
  236.  
  237. reswitch:
  238.  
  239.     switch( scan_code[c = next()] )
  240.     {
  241.       case  0  :  
  242.           ct_ret(EOF) ;
  243.           
  244.       case  SC_SPACE  :   goto reswitch ;
  245.  
  246.       case  SC_COMMENT :
  247.           eat_comment() ; goto reswitch ;
  248.  
  249.       case  SC_NL  : 
  250.           lineno++ ; eat_nl() ;
  251.           ct_ret(NL) ;
  252.  
  253.       case SC_ESCAPE :
  254.           while ( scan_code[ c = next() ] == SC_SPACE ) ;
  255.           if ( c == '\n')
  256.           { token_lineno = ++lineno ; goto reswitch ; }
  257.           if ( c == 0 )  ct_ret(EOF) ;
  258.           un_next() ;
  259.           yylval.ival = '\\' ;
  260.           ct_ret(UNEXPECTED) ;
  261.  
  262.  
  263.       case  SC_SEMI_COLON  : 
  264.           eat_nl() ;
  265.           ct_ret(SEMI_COLON) ;
  266.  
  267.       case  SC_LBRACE :  
  268.           eat_nl() ; brace_cnt++ ;
  269.           ct_ret(LBRACE) ;
  270.  
  271.       case  SC_PLUS  :
  272.           switch( next() )
  273.           {
  274.             case '+' :  
  275.                 yylval.ival = '+' ;
  276.                 string_buff[0] = 
  277.                      string_buff[1] = '+' ;
  278.                 string_buff[2] = 0 ;
  279.                 ct_ret(INC_or_DEC) ;
  280.  
  281.             case  '=' :
  282.                 ct_ret(ADD_ASG) ;
  283.  
  284.             default :  un_next() ; ct_ret(PLUS) ;
  285.           }
  286.  
  287.       case  SC_MINUS :
  288.           switch( next() )
  289.           {
  290.             case '-' :  
  291.                 yylval.ival = '-' ;
  292.                 string_buff[0] = 
  293.                      string_buff[1] = '-' ;
  294.                 string_buff[2] = 0 ;
  295.                 ct_ret(INC_or_DEC) ;
  296.  
  297.             case  '=' :
  298.                 ct_ret(SUB_ASG) ;
  299.  
  300.             default :  un_next() ; ct_ret(MINUS) ;
  301.           }
  302.  
  303.       case  SC_COMMA :  eat_nl() ; ct_ret(COMMA) ;
  304.  
  305.       case  SC_MUL  :  test1_ret('=', MUL_ASG, MUL) ;
  306.       case  SC_DIV :   
  307.           { static int can_precede_div[] =
  308.         { DOUBLE, STRING_, RPAREN, ID, D_ID, RE, RBOX, FIELD,
  309.           GETLINE, INC_or_DEC, -1 } ;
  310.           
  311.           int *p = can_precede_div ;
  312.  
  313.             do
  314.                 if ( *p == current_token )
  315.         {
  316.           if ( *p != INC_or_DEC ) 
  317.             test1_ret('=', DIV_ASG, DIV) ;
  318.  
  319.           if ( next() == '=' )
  320.           { un_next() ; ct_ret( collect_RE() ) ;  }
  321.         }
  322.                  
  323.             while ( * ++p != -1 ) ;
  324.  
  325.             ct_ret( collect_RE() ) ;
  326.           }
  327.  
  328.       case  SC_MOD  :  test1_ret('=', MOD_ASG, MOD) ;
  329.       case  SC_POW :   test1_ret('=' , POW_ASG, POW) ;
  330.       case  SC_LPAREN : 
  331.           paren_cnt++ ;
  332.           ct_ret(LPAREN) ;
  333.  
  334.       case  SC_RPAREN : 
  335.           if ( --paren_cnt < 0 )
  336.           { compile_error( "extra ')'" ) ;
  337.             paren_cnt = 0 ;
  338.             goto reswitch ; }
  339.  
  340.           ct_ret(RPAREN) ;
  341.  
  342.       case  SC_LBOX   : ct_ret(LBOX) ;
  343.       case  SC_RBOX   : ct_ret(RBOX) ;
  344.  
  345.       case  SC_MATCH  : 
  346.       string_buff[0] = '~' ; string_buff[0] = 0 ;
  347.       yylval.ival = 1 ;
  348.       ct_ret(MATCH) ;
  349.  
  350.       case  SC_EQUAL  :
  351.           test1_ret( '=', EQ, ASSIGN ) ;
  352.  
  353.       case  SC_NOT : /* !  */
  354.       if ( (c = next()) == '~' )
  355.       {
  356.         string_buff[0] = '!' ;
  357.         string_buff[1] = '~' ;
  358.         string_buff[2] = 0 ;
  359.         yylval.ival = 0 ;
  360.         ct_ret(MATCH) ;
  361.       }
  362.       else
  363.       if ( c == '=' )  ct_ret(NEQ) ;
  364.  
  365.       un_next() ;
  366.       ct_ret(NOT) ;
  367.  
  368.  
  369.       case  SC_LT  :  /* '<' */
  370.       if ( next() == '=' ) ct_ret(LTE) ;
  371.       else  un_next() ;
  372.  
  373.           if ( getline_flag )
  374.           { getline_flag = 0 ; ct_ret(IO_IN) ; }
  375.           else  ct_ret(LT) ;
  376.  
  377.       case  SC_GT  :  /* '>' */
  378.           if ( print_flag && paren_cnt == 0 )
  379.           { print_flag = 0 ;
  380.             /* there are 3 types of IO_OUT 
  381.                -- build the error string in string_buff */
  382.             string_buff[0] = '>' ;
  383.             if ( next() == '>' ) 
  384.             { 
  385.               yylval.ival = F_APPEND ;
  386.               string_buff[1] = '>' ;
  387.               string_buff[2] =  0 ;
  388.             }
  389.             else
  390.             { un_next() ; 
  391.               yylval.ival = F_TRUNC ; 
  392.               string_buff[1] = 0 ;
  393.             }
  394.             return current_token = IO_OUT ;
  395.           }
  396.  
  397.           test1_ret('=', GTE, GT) ;
  398.  
  399.       case  SC_OR :
  400.           if ( next() == '|' ) 
  401.           { eat_nl() ; ct_ret(OR) ; }
  402.           else 
  403.           { un_next() ; 
  404.  
  405.             if ( print_flag && paren_cnt == 0 )
  406.             { print_flag = 0 ; 
  407.               yylval.ival = PIPE_OUT;
  408.               string_buff[0] = '|' ;
  409.               string_buff[1] = 0 ;
  410.               ct_ret(IO_OUT) ;
  411.             }
  412.             else  ct_ret(PIPE) ;
  413.           }
  414.  
  415.       case  SC_AND :
  416.           if ( next() == '&' )  
  417.           { eat_nl() ; ct_ret(AND) ; }
  418.           else 
  419.           { un_next() ; yylval.ival = '&' ; ct_ret(UNEXPECTED) ; }
  420.  
  421.       case  SC_QMARK  :  ct_ret(QMARK) ;
  422.       case  SC_COLON  :  ct_ret(COLON) ;
  423.       case  SC_RBRACE :
  424.           if ( --brace_cnt < 0 )
  425.           { compile_error("extra '}'" ) ;
  426.             eat_semi_colon() ;
  427.             brace_cnt = 0 ; goto reswitch ; }
  428.  
  429.           if ( (c = current_token) == NL || c == SEMI_COLON 
  430.                || c == SC_FAKE_SEMI_COLON  || c == RBRACE  )
  431.           { 
  432.             /* if the brace_cnt is zero , we've completed
  433.                a pattern action block. If the user insists
  434.                on adding a semi-colon on the same line
  435.                we will eat it.  Note what we do below:
  436.                physical law -- conservation of semi-colons */
  437.  
  438.             if ( brace_cnt == 0 )  eat_semi_colon() ;
  439.             eat_nl() ;
  440.             ct_ret(RBRACE) ;
  441.           }
  442.  
  443.           /* supply missing semi-colon to statement that
  444.              precedes a '}' */
  445.           brace_cnt++ ; un_next() ;
  446.           current_token = SC_FAKE_SEMI_COLON ;
  447.           return  SEMI_COLON ;
  448.  
  449.       case  SC_DIGIT  :
  450.       case  SC_DOT    :
  451.           { double d ;
  452.             int flag ;
  453.         static double double_zero = 0.0 ;
  454.         static double double_one = 1.0 ;
  455.  
  456.             if ( (d = collect_decimal(c, &flag)) == 0.0 )
  457.                 if ( flag )  ct_ret(flag) ;
  458.                 else  yylval.ptr = (PTR) &double_zero ;
  459.             else if ( d == 1.0 ) yylval.ptr = (PTR) &double_one ;
  460.             else 
  461.             { yylval.ptr = (PTR) ZMALLOC(double) ;
  462.           *(double*)yylval.ptr = d ;
  463.             }
  464.             ct_ret( DOUBLE ) ;
  465.           }
  466.  
  467.       case  SC_DOLLAR :  /* '$' */
  468.           { double d ;
  469.             int flag ;
  470.  
  471.             while ( scan_code[c = next()] == SC_SPACE )  ;
  472.             if ( scan_code[c] != SC_DIGIT &&
  473.                  scan_code[c] != SC_DOT )
  474.             { un_next() ; ct_ret(DOLLAR) ; }
  475.             /* compute field address at compile time */
  476.             if ( (d = collect_decimal(c, &flag)) == 0.0 )
  477.                 if ( flag )  ct_ret(flag) ; /* an error */
  478.                 else  yylval.cp = &field[0] ;
  479.             else
  480.             { 
  481.               if ( d > MAX_FIELD )
  482.               { compile_error(
  483.                    "$%g exceeds maximum field(%d)" , d, MAX_FIELD) ;
  484.                 d = MAX_FIELD ;
  485.               }
  486.               yylval.cp = field_ptr((int)d) ;
  487.             }
  488.  
  489.             ct_ret(FIELD) ;
  490.           }
  491.  
  492.       case  SC_DQUOTE :
  493.           return current_token = collect_string() ;
  494.  
  495.       case  SC_IDCHAR : /* collect an identifier */
  496.             { unsigned char *p =
  497.                     (unsigned char *)string_buff + 1 ;
  498.               SYMTAB *stp ;
  499.  
  500.               string_buff[0] = c ;
  501.  
  502.               while ( 
  503.                 (c = scan_code[ *p++ = next()]) == SC_IDCHAR ||
  504.                        c == SC_DIGIT )  ;
  505.               
  506.               un_next() ; * --p = 0 ;
  507.  
  508.               switch( (stp = find(string_buff))->type )
  509.               { case ST_NONE :  
  510.                   /* check for function call before defined */
  511.                       if ( next() == '(' )
  512.                       { stp->type = ST_FUNCT ;
  513.                         stp->stval.fbp = (FBLOCK *)
  514.                                 zmalloc(sizeof(FBLOCK)) ;
  515.                         stp->stval.fbp->name = stp->name ;
  516.                         stp->stval.fbp->code = (INST *) 0 ;
  517.                         yylval.fbp = stp->stval.fbp ;
  518.                         current_token = FUNCT_ID ;
  519.                       }
  520.                       else
  521.                       { yylval.stp = stp ;
  522.                         current_token = 
  523.                             current_token == DOLLAR ? D_ID : ID ;
  524.                       }
  525.                       un_next() ;
  526.                       break ;
  527.  
  528.                 case  ST_NR  :
  529.               NR_flag = 1 ;
  530.                       stp->type = ST_VAR ;
  531.                       /* fall thru */
  532.                         
  533.                 case ST_VAR :
  534.                 case  ST_ARRAY :
  535.                 case  ST_LOCAL_NONE :
  536.                 case  ST_LOCAL_VAR :
  537.                 case  ST_LOCAL_ARRAY :
  538.  
  539.                       yylval.stp = stp ;
  540.                       current_token =
  541.                             current_token == DOLLAR ? D_ID : ID ;
  542.                       break ;
  543.  
  544.         case ST_ENV :
  545.               stp->type = ST_ARRAY ;
  546.               stp->stval.array = new_ARRAY() ;
  547.               load_environ(stp->stval.array) ;
  548.               yylval.stp = stp ;
  549.               current_token =
  550.               current_token == DOLLAR ? D_ID : ID ;
  551.               break ;
  552.  
  553.                 case ST_FUNCT :
  554.                       yylval.fbp = stp->stval.fbp ;
  555.                       current_token = FUNCT_ID ;
  556.                       break ;
  557.  
  558.                 case ST_KEYWORD :  
  559.                       current_token = stp->stval.kw ;
  560.                       break ;
  561.  
  562.                 case  ST_BUILTIN :
  563.                       yylval.bip = stp->stval.bip ;
  564.                       current_token = BUILTIN ;
  565.                       break ;
  566.  
  567.                 case  ST_LENGTH  :
  568.  
  569.               yylval.bip = stp->stval.bip ;
  570.  
  571.               /* check for length alone, this is an ugly
  572.              hack */
  573.                       while ( scan_code[ c = next() ] == SC_SPACE ) ;
  574.                       un_next() ;
  575.  
  576.               current_token = c == '(' ? BUILTIN : LENGTH ;
  577.               break ;
  578.  
  579.                 case  ST_FIELD  :
  580.                       yylval.cp = stp->stval.cp ;
  581.                       current_token = FIELD ;
  582.                       break ;
  583.  
  584.                 default : 
  585.                       bozo("find returned bad st type") ;
  586.               }
  587.               return  current_token  ;
  588.             }
  589.  
  590.  
  591.       case  SC_UNEXPECTED :
  592.             yylval.ival = c & 0xff ;
  593.             ct_ret(UNEXPECTED) ;
  594.     }
  595.     return  0 ; /* never get here make lint happy */
  596. }
  597.  
  598. /* collect a decimal constant in temp_buff.
  599.    Return the value and error conditions by reference */
  600.  
  601. static double collect_decimal(c, flag)
  602.   int c ; int *flag ;
  603. { register unsigned char *p = (unsigned char*) string_buff + 1;
  604.   unsigned char *endp ;
  605.   double d ;
  606.  
  607.   *flag = 0 ;
  608.   string_buff[0] = c ;
  609.  
  610.   if ( c == '.' )
  611.   { if ( scan_code[*p++ = next()] != SC_DIGIT )
  612.     { *flag = UNEXPECTED ; yylval.ival = '.' ;
  613.       return 0.0 ; }
  614.   }
  615.   else
  616.   {  while ( scan_code[*p++ = next()] == SC_DIGIT ) ;
  617.      if ( p[-1] != '.' )
  618.      { un_next() ; p-- ; }
  619.   }
  620.   /* get rest of digits after decimal point */
  621.   while ( scan_code[*p++ = next()] == SC_DIGIT )  ;
  622.  
  623.   /* check for exponent */
  624.   if ( p[-1] != 'e' && p[-1] != 'E' )
  625.   { un_next() ; * --p = 0 ; }
  626.   else  /* get the exponent */
  627.     if ( scan_code[*p = next()] != SC_DIGIT &&
  628.          *p != '-' && *p != '+' )
  629.     { *++p = 0 ; *flag = BAD_DECIMAL ;
  630.       return 0.0 ; }
  631.     else  /* get the rest of the exponent */
  632.     { p++ ;
  633.       while ( scan_code[*p++ = next()] == SC_DIGIT )  ;
  634.       un_next() ; * --p = 0 ;
  635.     }
  636.  
  637.   errno = 0 ; /* check for overflow/underflow */
  638.   d = strtod( string_buff, (char **)&endp ) ;
  639.  
  640. #ifndef  STRTOD_UNDERFLOW_ON_ZERO_BUG
  641.   if ( errno )
  642.       compile_error( "%s : decimal %sflow" , string_buff,
  643.         d == 0.0 ? "under" : "over") ;
  644. #else /* sun4 bug */
  645.   if ( errno && d != 0.0 )
  646.       compile_error( "%s : decimal overflow", string_buff) ;
  647. #endif
  648.  
  649.   if ( endp < p )
  650.   { *flag = BAD_DECIMAL ; return 0.0 ; }
  651.   return d ;
  652. }
  653.  
  654. /*----------  process escape characters ---------------*/
  655.  
  656. static char hex_val['f' - 'A' + 1] = {
  657. 10,11,12,13,14,15, 0, 0,
  658.  0, 0, 0, 0, 0, 0, 0, 0,
  659.  0, 0, 0, 0, 0, 0, 0, 0,
  660.  0, 0, 0, 0, 0, 0, 0, 0,
  661. 10,11,12,13,14,15 } ;
  662.  
  663. #define isoctal(x)  ((x)>='0'&&(x)<='7')
  664.  
  665. #define  hex_value(x)   hex_val[(x)-'A']
  666.  
  667. #define ishex(x) (scan_code[x] == SC_DIGIT ||\
  668.                   'A' <= (x) && (x) <= 'f' && hex_value(x))
  669.  
  670. static int PROTO(octal, (char **)) ;
  671. static int PROTO(hex, (char **)) ;
  672.  
  673. /* process one , two or three octal digits
  674.    moving a pointer forward by reference */
  675. static int octal( start_p )
  676.   char **start_p ;
  677. { register char *p = *start_p ;
  678.   register unsigned x ;
  679.  
  680.   x = *p++ - '0' ;
  681.   if ( isoctal(*p) )
  682.   {
  683.     x = (x<<3) + *p++ - '0' ;
  684.     if ( isoctal(*p) )   x = (x<<3) + *p++ - '0' ;
  685.   }
  686.   *start_p = p ;
  687.   return  x & 0xff ;
  688. }
  689.  
  690. /* process one or two hex digits
  691.    moving a pointer forward by reference */
  692.  
  693. static int  hex( start_p )
  694.   char **start_p ;
  695. { register unsigned char *p = (unsigned char*) *start_p ;
  696.   register unsigned x ;
  697.   unsigned t ;
  698.  
  699.   if ( scan_code[*p] == SC_DIGIT )
  700.         x = *p++ - '0' ;
  701.   else  x = hex_value(*p++) ;
  702.  
  703.   if ( scan_code[*p] == SC_DIGIT )
  704.         x = (x<<4) + *p++ - '0' ;
  705.   else
  706.   if ( 'A' <= *p && *p <= 'f' && (t = hex_value(*p)) )
  707.   { x = (x<<4) + t ; p++ ; }
  708.  
  709.   *start_p = (char *) p ;
  710.   return x ;
  711. }
  712.  
  713. #define  ET_END     9
  714.  
  715. static struct { char in , out ; } escape_test[ET_END+1] = {
  716. 'n' , '\n',
  717. 't' , '\t',
  718. 'f' , '\f',
  719. 'b' , '\b',
  720. 'r' , '\r',
  721. 'a' , '\07',
  722. 'v' , '\013',
  723. '\\', '\\',
  724. '\"', '\"',
  725. 0 , 0 } ;
  726.  
  727.  
  728. /* process the escape characters in a string, in place . */
  729.  
  730. char *rm_escape(s)
  731.   char *s ;
  732. { register char *p, *q ;
  733.   char *t ;
  734.   int i ;
  735.  
  736.   q = p = s ;
  737.  
  738.   while ( *p )
  739.       if ( *p == '\\' )
  740.       { 
  741.         escape_test[ET_END].in = * ++p ; /* sentinal */
  742.         i = 0 ;
  743.         while ( escape_test[i].in != *p )  i++ ;
  744.  
  745.         if ( i != ET_END )  /* in table */
  746.         { 
  747.           p++ ; *q++ = escape_test[i].out ;
  748.         }
  749.         else
  750.         if ( isoctal(*p) ) 
  751.         {
  752.           t = p ;  *q++ = octal(&t) ; p = t ;
  753.         }
  754.         else
  755.         if ( *p == 'x' && ishex(*(unsigned char*)(p+1)) )
  756.         {
  757.           t = p+1 ; *q++ = hex(&t) ; p = t ;
  758.         }
  759.         else
  760.         if ( *p == 0 ) /* can only happen with command line assign */
  761.             *q++ = '\\' ;
  762.         else  /* not an escape sequence */
  763.         { 
  764.           *q++ = '\\' ; *q++ = *p++ ;
  765.         }
  766.       }
  767.       else  *q++ = *p++ ;
  768.  
  769.   *q = 0 ;
  770.   return s ;
  771. }
  772.  
  773. static  int  collect_string()
  774. { register unsigned char *p = (unsigned char *)string_buff ;
  775.   int c ;
  776.   int e_flag = 0 ; /* on if have an escape char */
  777.  
  778.   while ( 1 )
  779.       switch( scan_code[ *p++ = next() ] )
  780.       { case  SC_DQUOTE : /* done */
  781.               * --p = 0 ;  goto out ;
  782.  
  783.         case  SC_NL :
  784.               p[-1] = 0 ;
  785.               /* fall thru */
  786.  
  787.         case  0 :   /* unterminated string */
  788.               compile_error(
  789.               "runaway string constant \"%.10s ..." ,
  790.               string_buff, token_lineno ) ;
  791.               mawk_exit(1) ;
  792.  
  793.         case SC_ESCAPE :
  794.               if ( (c = next()) == '\n' )
  795.               { p-- ; lineno++ ; }
  796.               else  
  797.                 if ( c == 0 )  un_next() ;   
  798.                 else 
  799.                 { *p++ = c ; e_flag = 1 ; }
  800.  
  801.               break ;
  802.  
  803.         default : break ;
  804.       }
  805.  
  806. out:
  807.     yylval.ptr = (PTR) new_STRING(
  808.          e_flag ? rm_escape( string_buff ) 
  809.                 : string_buff ) ;
  810.     return  STRING_ ;
  811. }
  812.  
  813.  
  814. static  int  collect_RE()
  815. { register unsigned char *p = (unsigned char*) string_buff ;
  816.   int c ;
  817.   STRING *sval ;
  818.  
  819.   while ( 1 )
  820.       switch( scan_code[ *p++ = next() ] )
  821.       { case  SC_DIV : /* done */
  822.               * --p = 0 ;  goto out ;
  823.  
  824.         case  SC_NL :
  825.               p[-1] = 0 ;
  826.               /* fall thru */
  827.  
  828.         case  0 :   /* unterminated re */
  829.               compile_error(
  830.               "runaway regular expression /%.10s ..." ,
  831.               string_buff, token_lineno ) ;
  832.               mawk_exit(1) ;
  833.  
  834.         case SC_ESCAPE :
  835.               switch( c = next() )
  836.               { case '/' :  
  837.                       p[-1] = '/' ; break ;
  838.  
  839.                 case '\n' :
  840.                       p-- ;  break ;
  841.  
  842.                 case  0   :
  843.                       un_next() ;  break ;
  844.  
  845.                 default :
  846.                       *p++ = c ; break ;
  847.               }
  848.               break ;
  849.       }
  850.  
  851. out:
  852.   /* now we've got the RE, so compile it */
  853.   sval = new_STRING( string_buff ) ;
  854.   yylval.ptr = re_compile(sval) ;
  855.   free_STRING(sval) ;
  856.   return RE ;
  857. }
  858.  
  859.