home *** CD-ROM | disk | FTP | other *** search
/ Source Code 1992 March / Source_Code_CD-ROM_Walnut_Creek_March_1992.iso / usenet / altsrcs / 3 / 3353 < prev    next >
Internet Message Format  |  1991-05-16  |  62KB
  1. From: brennan@ssc-vax.UUCP (Mike Brennan)
  2. Newsgroups: alt.sources
  3. Subject: mawk0.97.shar 5 of 6
  4. Message-ID: <3967@ssc-bee.ssc-vax.UUCP>
  5. Date: 11 May 91 14:57:57 GMT
  6.  
  7.  
  8. ------------------cut here----------------
  9.       case  SC_SPACE  :   goto reswitch ;
  10.  
  11.       case  SC_COMMENT :
  12.           eat_comment() ; goto reswitch ;
  13.  
  14.       case  SC_NL  : 
  15.           lineno++ ; eat_nl() ;
  16.           ct_ret(NL) ;
  17.  
  18.       case SC_ESCAPE :
  19.           while ( scan_code[ c = next() ] == SC_SPACE ) ;
  20.           if ( c == '\n')
  21.           { token_lineno = ++lineno ; goto reswitch ; }
  22.           if ( c == 0 )  ct_ret(EOF) ;
  23.           un_next() ;
  24.           yylval.ival = '\\' ;
  25.           ct_ret(UNEXPECTED) ;
  26.  
  27.  
  28.       case  SC_SEMI_COLON  : 
  29.           eat_nl() ;
  30.           ct_ret(SEMI_COLON) ;
  31.  
  32.       case  SC_LBRACE :  
  33.           eat_nl() ; brace_cnt++ ;
  34.           ct_ret(LBRACE) ;
  35.  
  36.       case  SC_PLUS  :
  37.           test2_ret('+', INC, '=', ADD_ASG, PLUS ) ;
  38.  
  39.       case  SC_MINUS :
  40.           test2_ret('-', DEC, '=', SUB_ASG, MINUS ) ;
  41.  
  42.       case  SC_COMMA :  eat_nl() ; ct_ret(COMMA) ;
  43.  
  44.       case  SC_MUL  :  test1_ret('=', MUL_ASG, MUL) ;
  45.       case  SC_DIV :   
  46.           { int *p = can_precede_re ;
  47.  
  48.             do
  49.                 if ( *p == current_token )
  50.                     ct_ret( collect_RE() ) ;
  51.             while ( *p++ != -1 ) ;
  52.  
  53.             test1_ret( '=', DIV_ASG , DIV ) ;
  54.           }
  55.  
  56.       case  SC_MOD  :  test1_ret('=', MOD_ASG, MOD) ;
  57.       case  SC_POW :   test1_ret('=' , POW_ASG, POW) ;
  58.       case  SC_LPAREN : 
  59.           paren_cnt++ ;
  60.           ct_ret(LPAREN) ;
  61.  
  62.       case  SC_RPAREN : 
  63.           if ( --paren_cnt < 0 )
  64.           { compile_error( "extra ')'" ) ;
  65.             paren_cnt = 0 ;
  66.             goto reswitch ; }
  67.  
  68.           ct_ret(RPAREN) ;
  69.  
  70.       case  SC_LBOX   : ct_ret(LBOX) ;
  71.       case  SC_RBOX   : ct_ret(RBOX) ;
  72.  
  73.       case  SC_MATCH  : ct_ret(MATCH) ;
  74.  
  75.       case  SC_EQUAL  :
  76.           test1_ret( '=', EQ, ASSIGN ) ;
  77.  
  78.       case  SC_NOT : /* !  */
  79.           test2_ret('=', NEQ, '~', NOT_MATCH, NOT ) ;
  80.  
  81.       case  SC_LT  :  /* '<' */
  82.           if ( getline_flag )
  83.           { getline_flag = 0 ; ct_ret(IO_IN) ; }
  84.           else
  85.           { ct_ret( ifnext('=', LTE , LT) ) ; }
  86.  
  87.       case  SC_GT  :  /* '>' */
  88.           if ( print_flag && paren_cnt == 0 )
  89.           { print_flag = 0 ;
  90.             /* there are 3 types of IO_OUT 
  91.                -- build the error string in temp_buff */
  92.             temp_buff.string_buff[0] = '>' ;
  93.             if ( next() == '>' ) 
  94.             { 
  95.               yylval.ival = F_APPEND ;
  96.               temp_buff.string_buff[1] = '>' ;
  97.               temp_buff.string_buff[2] =  0 ;
  98.             }
  99.             else
  100.             { un_next() ; 
  101.               yylval.ival = F_TRUNC ; 
  102.               temp_buff.string_buff[1] = 0 ;
  103.             }
  104.             return current_token = IO_OUT ;
  105.           }
  106.  
  107.           ct_ret( ifnext('=', GTE , GT) ) ;
  108.  
  109.       case  SC_OR :
  110.           if ( next() == '|' ) 
  111.           { eat_nl() ; ct_ret(brace_cnt?OR:P_OR) ; }
  112.           else 
  113.           { un_next() ; 
  114.  
  115.             if ( print_flag && paren_cnt == 0 )
  116.             { print_flag = 0 ; 
  117.               yylval.ival = PIPE_OUT;
  118.               temp_buff.string_buff[0] = '|' ;
  119.               temp_buff.string_buff[1] = 0 ;
  120.               ct_ret(IO_OUT) ;
  121.             }
  122.             else  ct_ret(PIPE) ;
  123.           }
  124.  
  125.       case  SC_AND :
  126.           if ( next() == '&' )  
  127.           { eat_nl() ; ct_ret(brace_cnt?AND:P_AND) ; }
  128.           else 
  129.           { un_next() ; yylval.ival = '&' ; ct_ret(UNEXPECTED) ; }
  130.  
  131.       case  SC_QMARK  :  ct_ret(QMARK) ;
  132.       case  SC_COLON  :  ct_ret(COLON) ;
  133.       case  SC_RBRACE :
  134.           if ( --brace_cnt < 0 )
  135.           { compile_error("extra '}'" ) ;
  136.             brace_cnt = 0 ; goto reswitch ; }
  137.  
  138.           if ( (c = current_token) == NL || c == SEMI_COLON 
  139.                || c == SC_FAKE_SEMI_COLON  || c == RBRACE  )
  140.           { eat_nl() ; ct_ret(RBRACE) ; }
  141.  
  142.           brace_cnt++ ; un_next() ;
  143.           current_token = SC_FAKE_SEMI_COLON ;
  144.           return  SEMI_COLON ;
  145.  
  146.       case  SC_DIGIT  :
  147.       case  SC_DOT    :
  148.           { double d ;
  149.             int flag ;
  150.  
  151.             if ( (d = collect_decimal(c, &flag)) == 0.0 )
  152.                 if ( flag )  ct_ret(flag) ;
  153.                 else  yylval.cp = &cell_zero ;
  154.             else if ( d == 1.0 ) yylval.cp = &cell_one ;
  155.             else 
  156.             { yylval.cp = new_CELL() ;
  157.               yylval.cp->type = C_DOUBLE ;
  158.               yylval.cp->dval = d ; 
  159.             }
  160.             ct_ret( CONSTANT ) ;
  161.           }
  162.  
  163.       case  SC_DOLLAR :  /* '$' */
  164.           { double d ;
  165.             int flag ;
  166.  
  167.             while ( scan_code[c = next()] == SC_SPACE )  ;
  168.             if ( scan_code[c] != SC_DIGIT &&
  169.                  scan_code[c] != SC_DOT )
  170.             { un_next() ; ct_ret(DOLLAR) ; }
  171.             /* compute field address at compile time */
  172.             if ( (d = collect_decimal(c, &flag)) == 0.0 )
  173.                 if ( flag )  ct_ret(flag) ; /* an error */
  174.                 else  yylval.cp = &field[0] ;
  175.             else
  176.             { int k = (int) d ;
  177.  
  178.               if ( k > MAX_FIELD )
  179.               { compile_error(
  180.                    "maximum field index(%d) exceeded" , k ) ;
  181.                 k = MAX_FIELD ;
  182.               }
  183.               else  yylval.cp = &field[k] ;
  184.             }
  185.  
  186.             ct_ret(FIELD) ;
  187.           }
  188.  
  189.       case  SC_DQUOTE :
  190.           return current_token = collect_string() ;
  191.  
  192.       case  SC_IDCHAR : /* collect an identifier */
  193.             { unsigned char *p =
  194.                     (unsigned char *)temp_buff.string_buff + 1 ;
  195.               SYMTAB *stp ;
  196.  
  197.               temp_buff.string_buff[0] = c ;
  198.  
  199.               while ( 
  200.                 (c = scan_code[ *p++ = next()]) == SC_IDCHAR ||
  201.                        c == SC_DIGIT )  ;
  202.               
  203.               un_next() ; * --p = 0 ;
  204.  
  205.               switch( (stp = find(temp_buff.string_buff))->type )
  206.               { case ST_NONE :  
  207.                   /* check for function call before defined */
  208.                       if ( next() == '(' )
  209.                       { stp->type = ST_FUNCT ;
  210.                         stp->stval.fbp = (FBLOCK *)
  211.                                 zmalloc(sizeof(FBLOCK)) ;
  212.                         stp->stval.fbp->name = stp->name ;
  213.                         stp->stval.fbp->code = (INST *) 0 ;
  214.                         yylval.fbp = stp->stval.fbp ;
  215.                         current_token = FUNCT_ID ;
  216.                       }
  217.                       else
  218.                       { yylval.stp = stp ;
  219.                         current_token = ID ;
  220.                       }
  221.                       un_next() ;
  222.                       break ;
  223.                         
  224.                 case ST_VAR :
  225.                 case  ST_ARRAY :
  226.                 case  ST_LOCAL_NONE :
  227.                 case  ST_LOCAL_VAR :
  228.                 case  ST_LOCAL_ARRAY :
  229.  
  230.                       yylval.stp = stp ;
  231.                       current_token = ID ;
  232.                       break ;
  233.  
  234.                 case ST_FUNCT :
  235.                       yylval.fbp = stp->stval.fbp ;
  236.                       current_token = FUNCT_ID ;
  237.                       break ;
  238.  
  239.                 case ST_KEYWORD :  
  240.                       current_token = stp->stval.kw ;
  241.                       break ;
  242.  
  243.                 case  ST_BUILTIN :
  244.                       yylval.bip = stp->stval.bip ;
  245.                       current_token = BUILTIN ;
  246.                       break ;
  247.  
  248.                 case  ST_FIELD  :
  249.                       yylval.cp = stp->stval.cp ;
  250.                       current_token = FIELD ;
  251.                       break ;
  252.  
  253.                 case  ST_LENGTH  :
  254.                     { CELL *bi_length() ;
  255.                       static BI_REC length_bi_rec =
  256.                       { "length", bi_length, 1, 1 } ;
  257.  
  258.                       while ( scan_code[ c = next() ] == SC_SPACE ) ;
  259.                       un_next() ;
  260.  
  261.                       if ( c == '(' )
  262.                       { yylval.bip = &length_bi_rec ;
  263.                         current_token = BUILTIN ;
  264.                       }
  265.                       else current_token = LENGTH ;
  266.                     }
  267.                     break ;
  268.  
  269.                 default : 
  270.                       bozo("find returned bad st type") ;
  271.               }
  272.               return  current_token  ;
  273.             }
  274.  
  275.  
  276.       case  SC_UNEXPECTED :
  277.             yylval.ival = c & 0xff ;
  278.             ct_ret(UNEXPECTED) ;
  279.     }
  280.     return  0 ; /* never get here make lint happy */
  281. }
  282.  
  283. /* collect a decimal constant in temp_buff.
  284.    Return the value and error conditions by reference */
  285.  
  286. static double collect_decimal(c, flag)
  287.   int c ; int *flag ;
  288. { register unsigned char *p = (unsigned char*) temp_buff.string_buff + 1;
  289.   unsigned char *endp ;
  290.   double d ;
  291.  
  292.   *flag = 0 ;
  293.   temp_buff.string_buff[0] = c ;
  294.  
  295.   if ( c == '.' )
  296.   { if ( scan_code[*p++ = next()] != SC_DIGIT )
  297.     { *flag = UNEXPECTED ; yylval.ival = '.' ;
  298.       return 0.0 ; }
  299.   }
  300.   else
  301.   {  while ( scan_code[*p++ = next()] == SC_DIGIT ) ;
  302.      if ( p[-1] != '.' )
  303.      { un_next() ; p-- ; }
  304.   }
  305.   /* get rest of digits after decimal point */
  306.   while ( scan_code[*p++ = next()] == SC_DIGIT )  ;
  307.  
  308.   /* check for exponent */
  309.   if ( p[-1] != 'e' && p[-1] != 'E' )
  310.   { un_next() ; * --p = 0 ; }
  311.   else  /* get the exponent */
  312.     if ( scan_code[*p = next()] != SC_DIGIT &&
  313.          *p != '-' && *p != '+' )
  314.     { *++p = 0 ; *flag = BAD_DECIMAL ;
  315.       return 0.0 ; }
  316.     else  /* get the rest of the exponent */
  317.     { p++ ;
  318.       while ( scan_code[*p++ = next()] == SC_DIGIT )  ;
  319.       un_next() ; * --p = 0 ;
  320.     }
  321.  
  322.   errno = 0 ; /* check for overflow/underflow */
  323.   d = strtod( temp_buff.string_buff, &endp ) ;
  324.   if ( errno )
  325.       compile_error( "%s : decimal %sflow" , temp_buff.string_buff,
  326.         d == 0.0 ? "under" : "over") ;
  327.   if ( endp != p )
  328.   { *flag = BAD_DECIMAL ; return 0.0 ; }
  329.   return d ;
  330. }
  331.  
  332. /*----------  process escape characters ---------------*/
  333.  
  334. static char hex_val['f' - 'A' + 1] = {
  335. 10,11,12,13,14,15, 0, 0,
  336.  0, 0, 0, 0, 0, 0, 0, 0,
  337.  0, 0, 0, 0, 0, 0, 0, 0,
  338.  0, 0, 0, 0, 0, 0, 0, 0,
  339. 10,11,12,13,14,15 } ;
  340.  
  341. #define isoctal(x)  ((x)>='0'&&(x)<='7')
  342.  
  343. #define  hex_value(x)   hex_val[(x)-'A']
  344.  
  345. #define ishex(x) (scan_code[x] == SC_DIGIT ||\
  346.                   'A' <= (x) && (x) <= 'f' && hex_value(x))
  347.  
  348. static int PROTO(octal, (char **)) ;
  349. static int PROTO(hex, (char **)) ;
  350.  
  351. /* process one , two or three octal digits
  352.    moving a pointer forward by reference */
  353. static int octal( start_p )
  354.   char **start_p ;
  355. { register char *p = *start_p ;
  356.   register unsigned x ;
  357.  
  358.   x = *p++ - '0' ;
  359.   if ( isoctal(*p) )
  360.   {
  361.     x = (x<<3) + *p++ - '0' ;
  362.     if ( isoctal(*p) )   x = (x<<3) + *p++ - '0' ;
  363.   }
  364.   *start_p = p ;
  365.   return  x & 0xff ;
  366. }
  367.  
  368. /* process one or two hex digits
  369.    moving a pointer forward by reference */
  370.  
  371. static int  hex( start_p )
  372.   unsigned char **start_p ;
  373. { register unsigned char *p = *start_p ;
  374.   register unsigned x ;
  375.   unsigned t ;
  376.  
  377.   if ( scan_code[*p] == SC_DIGIT )
  378.         x = *p++ - '0' ;
  379.   else  x = hex_value(*p++) ;
  380.  
  381.   if ( scan_code[*p] == SC_DIGIT )
  382.         x = (x<<4) + *p++ - '0' ;
  383.   else
  384.   if ( 'A' <= *p && *p <= 'f' && (t = hex_value(*p)) )
  385.   { x = (x<<4) + t ; p++ ; }
  386.  
  387.   *start_p = p ;
  388.   return x ;
  389. }
  390.  
  391. static char escape_test[] = 
  392.   "n\nt\tb\br\rf\fa\07v\013\\\\\"\"\'\'" ;
  393.  
  394. /* process the escape characters in a string, in place . */
  395.  
  396. static char *rm_escape(s)
  397.   char *s ;
  398. { register char *p, *q ;
  399.   char *t ;
  400.  
  401.   q = p = s ;
  402.  
  403.   while ( *p )
  404.       if ( *p == '\\' )
  405.       { 
  406.         if ( t = strchr(escape_test, * ++p) )
  407.         { 
  408.           p++ ; *q++ = t[1] ; 
  409.         }
  410.         else
  411.         if ( isoctal(*p) ) 
  412.         {
  413.           t = p ;  *q++ = octal(&t) ; p = t ;
  414.         }
  415.         else
  416.         if ( *p == 'x' && ishex(*(unsigned char*)(p+1)) )
  417.         {
  418.           t = p+1 ; *q++ = hex(&t) ; p = t ;
  419.         }
  420.         else  /* not an escape sequence */
  421.         { 
  422.           *q++ = '\\' ; *q++ = *p++ ;
  423.         }
  424.       }
  425.       else  *q++ = *p++ ;
  426.  
  427.   *q = 0 ;
  428.   return s ;
  429. }
  430.  
  431. static  int  collect_string()
  432. { register unsigned char *p = (unsigned char *)temp_buff.string_buff ;
  433.   int c ;
  434.   int e_flag = 0 ; /* on if have an escape char */
  435.  
  436.   while ( 1 )
  437.       switch( scan_code[ *p++ = next() ] )
  438.       { case  SC_DQUOTE : /* done */
  439.               * --p = 0 ;  goto out ;
  440.  
  441.         case  SC_NL :
  442.               p[-1] = 0 ;
  443.               /* fall thru */
  444.  
  445.         case  0 :   /* unterminated string */
  446.               compile_error(
  447.               "runaway string constant \"%.10s ..." ,
  448.               temp_buff.string_buff, token_lineno ) ;
  449.               mawk_exit(1) ;
  450.  
  451.         case SC_ESCAPE :
  452.               if ( (c = next()) == '\n' )
  453.               { p-- ; lineno++ ; }
  454.               else  
  455.                 if ( c == 0 )  un_next() ;   
  456.                 else 
  457.                 { *p++ = c ; e_flag = 1 ; }
  458.  
  459.               break ;
  460.  
  461.         default : break ;
  462.       }
  463.  
  464. out:
  465.     yylval.cp = new_CELL() ;
  466.     yylval.cp->type = C_STRING ;
  467.     yylval.cp->ptr = (PTR) new_STRING(
  468.          e_flag ? rm_escape( temp_buff.string_buff ) 
  469.                 : temp_buff.string_buff ) ;
  470.     return  CONSTANT ;
  471. }
  472.  
  473.  
  474. static  int  collect_RE()
  475. { register unsigned char *p = (unsigned char*) temp_buff.string_buff ;
  476.   int c ;
  477.   STRING *sval ;
  478.  
  479.   while ( 1 )
  480.       switch( scan_code[ *p++ = next() ] )
  481.       { case  SC_DIV : /* done */
  482.               * --p = 0 ;  goto out ;
  483.  
  484.         case  SC_NL :
  485.               p[-1] = 0 ;
  486.               /* fall thru */
  487.  
  488.         case  0 :   /* unterminated re */
  489.               compile_error(
  490.               "runaway regular expression /%.10s ..." ,
  491.               temp_buff.string_buff, token_lineno ) ;
  492.               mawk_exit(1) ;
  493.  
  494.         case SC_ESCAPE :
  495.               switch( c = next() )
  496.               { case '/' :  
  497.                       p[-1] = '/' ; break ;
  498.  
  499.                 case '\n' :
  500.                       p-- ;  break ;
  501.  
  502.                 case  0   :
  503.                       un_next() ;  break ;
  504.  
  505.                 default :
  506.                       *p++ = c ; break ;
  507.               }
  508.               break ;
  509.       }
  510.  
  511. out:
  512.   /* now we've got the RE, so compile it */
  513.   sval = new_STRING( temp_buff.string_buff ) ;
  514.   yylval.cp = new_CELL() ;
  515.   yylval.cp->type = C_RE ;
  516.   yylval.cp->ptr = re_compile(sval) ;
  517.   free_STRING(sval) ;
  518.   return RE ;
  519. }
  520.  
  521. @//E*O*F mawk0.97/scan.c//
  522. chmod u=rw,g=r,o=r mawk0.97/scan.c
  523.  
  524. echo x - mawk0.97/scan.h
  525. sed 's/^@//' > "mawk0.97/scan.h" <<'@//E*O*F mawk0.97/scan.h//'
  526.  
  527. /********************************************
  528. scan.h
  529. copyright 1991, Michael D. Brennan
  530.  
  531. This is a source file for mawk, an implementation of
  532. the Awk programming language as defined in
  533. Aho, Kernighan and Weinberger, The AWK Programming Language,
  534. Addison-Wesley, 1988.
  535.  
  536. See the accompaning file, LIMITATIONS, for restrictions
  537. regarding modification and redistribution of this
  538. program in source or binary form.
  539. ********************************************/
  540.  
  541.  
  542. /* $Log:    scan.h,v $
  543.  * Revision 2.2  91/04/09  12:39:31  brennan
  544.  * added static to funct decls to satisfy STARDENT compiler
  545.  * 
  546.  * Revision 2.1  91/04/08  08:23:54  brennan
  547.  * VERSION 0.97
  548.  * 
  549. */
  550.  
  551.  
  552. /* scan.h  */
  553.  
  554. #ifndef  SCAN_H_INCLUDED
  555. #define  SCAN_H_INCLUDED   1
  556.  
  557. #include <stdio.h>
  558.  
  559. #ifndef   MAKESCAN
  560. #include  "symtype.h"
  561. #include  "parse.h"
  562. #endif
  563.  
  564.  
  565. extern  char scan_code[256] ;
  566.  
  567. /*  the scan codes to compactify the main switch */
  568.  
  569. #define  SC_SPACE               1
  570. #define  SC_NL                  2
  571. #define  SC_SEMI_COLON          3
  572. #define  SC_FAKE_SEMI_COLON     4
  573. #define  SC_LBRACE              5
  574. #define  SC_RBRACE              6
  575. #define  SC_QMARK               7
  576. #define  SC_COLON               8
  577. #define  SC_OR                  9
  578. #define  SC_AND                10
  579. #define  SC_PLUS               11
  580. #define  SC_MINUS              12
  581. #define  SC_MUL                13
  582. #define  SC_DIV                14
  583. #define  SC_MOD                15
  584. #define  SC_POW                16
  585. #define  SC_LPAREN             17
  586. #define  SC_RPAREN             18
  587. #define  SC_LBOX               19
  588. #define  SC_RBOX               20
  589. #define  SC_IDCHAR             21
  590. #define  SC_DIGIT              22
  591. #define  SC_DQUOTE             23
  592. #define  SC_ESCAPE             24
  593. #define  SC_COMMENT            25
  594. #define  SC_EQUAL              26
  595. #define  SC_NOT                27
  596. #define  SC_LT                 28
  597. #define  SC_GT                 29
  598. #define  SC_COMMA              30
  599. #define  SC_DOT                31
  600. #define  SC_MATCH              32
  601. #define  SC_DOLLAR             33
  602. #define  SC_UNEXPECTED         34
  603.  
  604. #ifndef  MAKESCAN
  605.  
  606. /* global functions in scan.c */
  607.  
  608. void  PROTO(scan_init, (int, char *) ) ;
  609. void  PROTO(scan_cleanup, (void) ) ;
  610. void  PROTO(eat_nl, (void) ) ;
  611. int   PROTO(yylex, (void) ) ;
  612.  
  613.  
  614. extern  YYSTYPE  yylval ;
  615.  
  616. #define  ct_ret(x)  return current_token = (x)
  617.  
  618. #define  next() (*buffp ? *buffp++ : slow_next())
  619. #define  un_next()  buffp--
  620.  
  621. #define  ifnext(c,x,y) (next()==c?x:(un_next(),y))
  622.  
  623. #define  test1_ret(c,x,d)  if ( next() == (c) ) ct_ret(x) ;\
  624.                            else { un_next() ; ct_ret(d) ; }
  625.  
  626. #define  test2_ret(c1,x1,c2,x2,d)   switch( next() )\
  627.                                    { case c1: ct_ret(x1) ;\
  628.                                      case c2: ct_ret(x2) ;\
  629.                                      default: un_next() ;\
  630.                                               ct_ret(d) ; }
  631. #endif  /* ! MAKESCAN  */
  632. #endif
  633. @//E*O*F mawk0.97/scan.h//
  634. chmod u=rw,g=r,o=r mawk0.97/scan.h
  635.  
  636. echo x - mawk0.97/scancode.c
  637. sed 's/^@//' > "mawk0.97/scancode.c" <<'@//E*O*F mawk0.97/scancode.c//'
  638.  
  639.  
  640. /* scancode.c */
  641.  
  642.  
  643. char scan_code[256] = {
  644.  0,34,34,34,34,34,34,34,34, 1, 2, 1, 1, 1,34,34,
  645. 34,34,34,34,34,34,34,34,34,34,34,34,34,34,34,34,
  646.  1,27,23,25,33,15,10,34,17,18,13,11,30,12,31,14,
  647. 22,22,22,22,22,22,22,22,22,22, 8, 3,28,26,29, 7,
  648. 34,21,21,21,21,21,21,21,21,21,21,21,21,21,21,21,
  649. 21,21,21,21,21,21,21,21,21,21,21,19,24,20,16,21,
  650. 34,21,21,21,21,21,21,21,21,21,21,21,21,21,21,21,
  651. 21,21,21,21,21,21,21,21,21,21,21, 5, 9, 6,32,34,
  652. 34,34,34,34,34,34,34,34,34,34,34,34,34,34,34,34,
  653. 34,34,34,34,34,34,34,34,34,34,34,34,34,34,34,34,
  654. 34,34,34,34,34,34,34,34,34,34,34,34,34,34,34,34,
  655. 34,34,34,34,34,34,34,34,34,34,34,34,34,34,34,34,
  656. 34,34,34,34,34,34,34,34,34,34,34,34,34,34,34,34,
  657. 34,34,34,34,34,34,34,34,34,34,34,34,34,34,34,34,
  658. 34,34,34,34,34,34,34,34,34,34,34,34,34,34,34,34,
  659. 34,34,34,34,34,34,34,34,34,34,34,34,34,34,34,34
  660. } ;
  661. @//E*O*F mawk0.97/scancode.c//
  662. chmod u=rw,g=r,o=r mawk0.97/scancode.c
  663.  
  664. echo x - mawk0.97/sizes.h
  665. sed 's/^@//' > "mawk0.97/sizes.h" <<'@//E*O*F mawk0.97/sizes.h//'
  666.  
  667. /********************************************
  668. sizes.h
  669. copyright 1991, Michael D. Brennan
  670.  
  671. This is a source file for mawk, an implementation of
  672. the Awk programming language as defined in
  673. Aho, Kernighan and Weinberger, The AWK Programming Language,
  674. Addison-Wesley, 1988.
  675.  
  676. See the accompaning file, LIMITATIONS, for restrictions
  677. regarding modification and redistribution of this
  678. program in source or binary form.
  679. ********************************************/
  680.  
  681. /* $Log:    sizes.h,v $
  682.  * Revision 2.1  91/04/08  08:24:09  brennan
  683.  * VERSION 0.97
  684.  * 
  685. */
  686.  
  687. /*  sizes.h  */
  688.  
  689. #ifndef  SIZES_H
  690. #define  SIZES_H
  691.  
  692. #define  HASH_PRIME  53
  693. #define  A_HASH_PRIME 37
  694.  
  695.  
  696. #if      SMALL_EVAL_STACK
  697. /* allow some put not a lot of recursion */
  698. #define  EVAL_STACK_SIZE  64
  699. #else
  700. #define  EVAL_STACK_SIZE  256
  701. #endif
  702.  
  703. #define  MAX_COMPILE_ERRORS  5 /* quit if more than 4 errors */
  704.  
  705. #define  BUFFSZ    4096   /* input buffer size */
  706.  
  707. #define  MAX_LOOP_DEPTH   20
  708. /* should never be exceeded, doesn't matter if its too
  709.    big (unless gross) because resources sized by it are freed */
  710.  
  711. #define  MAX_FIELD   100  /* biggest field number */
  712. #define  SPRINTF_SZ   300  /* biggest sprintf string length */
  713.  
  714. /* the size of the temp buffer in front of main_buff */
  715. #define  PTR_SZ   sizeof(PTR)
  716. #define  TEMP_BUFF_SZ  (MAX_FIELD*PTR_SZ > SPRINTF_SZ ?\
  717.         MAX_FIELD*PTR_SZ : SPRINTF_SZ )
  718.  
  719. #define  PAGE_SZ    1024  /* max instructions for a block */
  720.  
  721. #endif   /* SIZES_H */
  722. @//E*O*F mawk0.97/sizes.h//
  723. chmod u=rw,g=r,o=r mawk0.97/sizes.h
  724.  
  725. echo x - mawk0.97/split.c
  726. sed 's/^@//' > "mawk0.97/split.c" <<'@//E*O*F mawk0.97/split.c//'
  727.  
  728. /********************************************
  729. split.c
  730. copyright 1991, Michael D. Brennan
  731.  
  732. This is a source file for mawk, an implementation of
  733. the Awk programming language as defined in
  734. Aho, Kernighan and Weinberger, The AWK Programming Language,
  735. Addison-Wesley, 1988.
  736.  
  737. See the accompaning file, LIMITATIONS, for restrictions
  738. regarding modification and redistribution of this
  739. program in source or binary form.
  740. ********************************************/
  741.  
  742. /* $Log:    split.c,v $
  743.  * Revision 2.1  91/04/08  08:24:11  brennan
  744.  * VERSION 0.97
  745.  * 
  746. */
  747.  
  748. /* split.c */
  749.  
  750. #include "mawk.h"
  751. #include "symtype.h"
  752. #include "bi_vars.h"
  753. #include "bi_funct.h"
  754. #include "memory.h"
  755. #include "scan.h"
  756. #include "regexp.h"
  757. #include "field.h"
  758. #include <string.h>
  759.  
  760.  
  761. /* split string s on SPACE without changing s.
  762.    load the pieces into STRINGS and ptrs into
  763.    temp_buff.ptr_buff[] 
  764.    return the number of pieces */
  765.  
  766. int space_split( s )  
  767.   register char *s ;
  768. { char *back = strchr(s,0) ;
  769.   int i = 0 ;
  770.   int len ;
  771.   char *q ;
  772.   STRING  *sval ;
  773.  
  774.   while ( 1 )
  775.   { while ( scan_code[*(unsigned char*)s] == SC_SPACE )  s++ ;
  776.     if ( *s == 0 )  break ;
  777.     /* mark the front with q */
  778.     q = s++ ;
  779.     *back = ' ' ; /* sentinal */
  780.     while ( scan_code[*(unsigned char*)s] != SC_SPACE )  s++ ;
  781.     *back = 0 ;
  782.     sval = (STRING *) (temp_buff.ptr_buff[i++] = 
  783.          (PTR) new_STRING((char *) 0, len = s - q )) ;
  784.     (void) memcpy(sval->str, q, len) ;
  785.   }
  786.   if ( i > MAX_FIELD ) 
  787.      rt_overflow("maximum number of fields", MAX_FIELD) ;
  788.   return i ;
  789. }
  790.  
  791.  
  792. char *re_pos_match(s, re, lenp)
  793.   register char *s ; 
  794.   PTR re ; unsigned *lenp ;
  795. {
  796.   while ( s = REmatch(s, re, lenp) )
  797.         if ( *lenp )   return s ;
  798.         else
  799.         if ( *s == 0 )  break ;
  800.         else s++ ;
  801.  
  802.   return (char *) 0 ;
  803. }
  804.  
  805. int re_split(s, re)
  806.   char *s ;
  807.   PTR  re ;
  808. { register char *t ;
  809.   int i = 0 ;
  810.   unsigned mlen, len ;
  811.   STRING *sval ;
  812.  
  813.   while ( t = re_pos_match(s, re, &mlen) )
  814.   { sval = (STRING*)(temp_buff.ptr_buff[i++] = (PTR)
  815.             new_STRING( (char *)0, len = t-s) ) ;
  816.     (void) memcpy(sval->str, s, len) ;
  817.     s = t + mlen ;
  818.   }
  819.   temp_buff.ptr_buff[i++] = (PTR) new_STRING(s) ;
  820.   if ( i > MAX_FIELD ) 
  821.      rt_overflow("maximum number of fields", MAX_FIELD) ;
  822.   return i ;
  823. }
  824.     
  825. /*  split(s, X, r)
  826.     split s into array X on r
  827.  
  828.     entry: sp[0] holds r
  829.            sp[-1] pts at X
  830.            sp[-2] holds s
  831. */
  832. CELL *bi_split(sp)
  833.   register CELL *sp ;
  834. { 
  835.   int cnt ;   /* the number of pieces */
  836.   double dcnt ; /* double version of cnt */
  837.   ARRAY A ;
  838.   CELL  *cp ;
  839.   char *ofmt ;
  840.  
  841.  
  842.   if ( sp->type < C_RE )  cast_for_split(sp) ;
  843.         /* can be C_RE, C_SPACE or C_SNULL */
  844.   sp -= 2 ;
  845.   if ( sp->type < C_STRING )  cast1_to_s(sp) ;
  846.  
  847.   if ( string(sp)->len == 0 ) /* nothing to split */
  848.   { free_STRING( string(sp) ) ;
  849.     sp->type = C_DOUBLE ; sp->dval = 0.0 ;
  850.     return sp ;
  851.   }
  852.  
  853.   switch ( (sp+2)->type )
  854.   {
  855.     case C_RE :
  856.         cnt = re_split(string(sp)->str, (sp+2)->ptr) ;
  857.         break ;
  858.  
  859.     case C_SPACE :
  860.         cnt = space_split(string(sp)->str) ;
  861.         break ;
  862.  
  863.     /* this case could be done by C_RE, but very slowly.
  864.        Since it is the common way to eliminate fields,
  865.        we'll treat the special case for speed */
  866.     case C_SNULL : /* split on empty string */
  867.         cnt = 1 ;
  868.         temp_buff.ptr_buff[0] = sp->ptr ;
  869.         string(sp)->ref_cnt++ ;
  870.         break ;
  871.  
  872.     default : bozo("bad splitting cell in bi_split") ;
  873.   }
  874.  
  875.   /* now load the array */
  876.  
  877.   free_STRING( string(sp) ) ;
  878.  
  879.   sp->type = C_DOUBLE ;
  880.   sp->dval = dcnt = (double) cnt ;
  881.  
  882.   ofmt = string(field + OFMT)->str ;
  883.   A = (ARRAY) (sp+1)->ptr  ;
  884.  
  885.   while ( cnt )
  886.   { char xbuff[256] ;
  887.     /* this big in case the user did something goofy with
  888.        OFMT  */
  889.   
  890.     (void) sprintf(xbuff, ofmt, dcnt ) ;
  891.     dcnt -= 1.0 ;
  892.     cp = array_find( A, xbuff, 1) ;
  893.     cell_destroy(cp) ;
  894.     cp->ptr = temp_buff.ptr_buff[--cnt] ;
  895.     cp->type = C_MBSTRN ;
  896.   }
  897.  
  898.   return sp ;
  899. }
  900.  
  901. @//E*O*F mawk0.97/split.c//
  902. chmod u=rw,g=r,o=r mawk0.97/split.c
  903.  
  904. echo x - mawk0.97/symtype.h
  905. sed 's/^@//' > "mawk0.97/symtype.h" <<'@//E*O*F mawk0.97/symtype.h//'
  906.  
  907. /********************************************
  908. symtype.h
  909. copyright 1991, Michael D. Brennan
  910.  
  911. This is a source file for mawk, an implementation of
  912. the Awk programming language as defined in
  913. Aho, Kernighan and Weinberger, The AWK Programming Language,
  914. Addison-Wesley, 1988.
  915.  
  916. See the accompaning file, LIMITATIONS, for restrictions
  917. regarding modification and redistribution of this
  918. program in source or binary form.
  919. ********************************************/
  920.  
  921. /*$Log:    symtype.h,v $
  922.  * Revision 2.1  91/04/08  08:24:14  brennan
  923.  * VERSION 0.97
  924.  * 
  925. */
  926.  
  927. /* types related to symbols are defined here */
  928.  
  929. #ifndef  SYMTYPE_H
  930. #define  SYMTYPE_H
  931.  
  932.  
  933. /* struct to hold info about builtins */
  934. typedef struct {
  935. char *name ;
  936. PF_CP  fp ;  /* ptr to function that does the builtin */
  937. unsigned char min_args, max_args ; 
  938. /* info for parser to check correct number of arguments */
  939. } BI_REC ;
  940.  
  941. /*---------------------------
  942.    structures and types for arrays
  943.  *--------------------------*/
  944.  
  945. /* array hash nodes */
  946.  
  947. typedef  struct anode {
  948. struct anode *link ;
  949. STRING *sval ;
  950. CELL   *cp ;
  951. }  ANODE, **ARRAY ;
  952.  
  953. /* note ARRAY is a ptr to a hash table */
  954.  
  955. CELL *PROTO(array_find, (ARRAY,void *, int) ) ;
  956. int PROTO(array_test, (ARRAY, STRING *) ) ;
  957. INST *PROTO(array_loop, (INST *, CELL *, CELL *) ) ;
  958. void PROTO(array_delete, (ARRAY, STRING *) ) ;
  959. CELL *PROTO(array_cat, (CELL *, int) ) ;
  960. void PROTO(array_free, (ARRAY) ) ;
  961.  
  962. #define new_ARRAY() (ARRAY)memset(zmalloc(A_HASH_PRIME *\
  963.                         sizeof(ANODE*)), 0, A_HASH_PRIME*sizeof(ANODE*))
  964.  
  965. extern  ARRAY  Argv ;
  966.  
  967. /* for parsing  (i,j) in A  */
  968. typedef  struct {
  969. INST *start ;
  970. int cnt ;
  971. } ARG2_REC ;
  972.  
  973. /*------------------------
  974.   user defined functions
  975.   ------------------------*/
  976.  
  977. typedef  struct fblock {
  978. char *name ;
  979. INST *code  ;
  980. unsigned short nargs ;
  981. char *typev ;  /* array of size nargs holding types */
  982. } FBLOCK ;   /* function block */
  983.  
  984. void  PROTO(add_to_fdump_list, (FBLOCK *) ) ;
  985. void  PROTO( fdump, (void) ) ;
  986.  
  987. /*-------------------------
  988.   elements of the symbol table
  989.   -----------------------*/
  990.  
  991. #define  ST_NONE 0
  992. #define  ST_VAR   1
  993. #define  ST_KEYWORD   2
  994. #define  ST_BUILTIN 3 /* a pointer to a builtin record */
  995. #define  ST_ARRAY   4 /* a void * ptr to a hash table */
  996. #define  ST_FIELD   5  /* a cell ptr to a field */
  997. #define  ST_FUNCT   6
  998. #define  ST_LENGTH  7  /* length is special */
  999. #define  ST_LOCAL_NONE  8
  1000. #define  ST_LOCAL_VAR   9
  1001. #define  ST_LOCAL_ARRAY 10
  1002.  
  1003. #define  is_local(stp)   ((stp)->type>=ST_LOCAL_NONE)
  1004.  
  1005. typedef  struct {
  1006. char *name ;
  1007. char type ;
  1008. unsigned char offset ;  /* offset in stack frame for local vars */
  1009. union {
  1010. CELL *cp ;
  1011. int  kw ;
  1012. PF_CP fp ;
  1013. BI_REC *bip ;
  1014. ARRAY  array ; 
  1015. FBLOCK  *fbp ;
  1016. } stval ;
  1017. }  SYMTAB ;
  1018.  
  1019.  
  1020. /*****************************
  1021.  structures for type checking function calls
  1022.  ******************************/
  1023.  
  1024. typedef  struct ca_rec {
  1025. struct ca_rec  *link ;
  1026. short type ;
  1027. short arg_num ;  /* position in callee's stack */
  1028. /*---------  this data only set if we'll  need to patch -------*/
  1029. /* happens if argument is an ID or type ST_NONE or ST_LOCAL_NONE */
  1030.  
  1031. int call_offset ;
  1032. /* where the type is stored */
  1033. SYMTAB  *sym_p ;  /* if type is ST_NONE  */
  1034. char *type_p ;  /* if type  is ST_LOCAL_NONE */
  1035. }  CA_REC  ; /* call argument record */
  1036.  
  1037. /* type field of CA_REC matches with ST_ types */
  1038. #define   CA_EXPR       ST_LOCAL_VAR
  1039. #define   CA_ARRAY      ST_LOCAL_ARRAY
  1040.  
  1041. typedef  struct fcall {
  1042. struct fcall *link ;
  1043. FBLOCK  *callee ;
  1044. short   call_scope ;
  1045. FBLOCK  *call ;  /* only used if call_scope == SCOPE_FUNCT  */
  1046. INST    *call_start ; /* computed later as code may be moved */
  1047. CA_REC  *arg_list ;
  1048. short   arg_cnt_checked ;
  1049. unsigned line_no ; /* for error messages */
  1050. } FCALL_REC ;
  1051.  
  1052. extern  FCALL_REC  *resolve_list ;
  1053.  
  1054. void PROTO(resolve_fcalls, (void) ) ;
  1055. void PROTO(check_fcall, (FBLOCK*,int,FBLOCK*,CA_REC*,unsigned) ) ;
  1056.  
  1057. /* hash.c */
  1058. unsigned  PROTO( hash, (char *) ) ;
  1059. SYMTAB *PROTO( insert, (char *) ) ;
  1060. SYMTAB *PROTO( find, (char *) ) ;
  1061. SYMTAB *PROTO( save_id, (char *) ) ;
  1062. void    PROTO( restore_ids, (void) ) ;
  1063.  
  1064. /* error.c */
  1065. void  PROTO(type_error, (SYMTAB *) ) ;
  1066.  
  1067. #endif  /* SYMTYPE_H */
  1068. @//E*O*F mawk0.97/symtype.h//
  1069. chmod u=rw,g=r,o=r mawk0.97/symtype.h
  1070.  
  1071. echo x - mawk0.97/types.h
  1072. sed 's/^@//' > "mawk0.97/types.h" <<'@//E*O*F mawk0.97/types.h//'
  1073.  
  1074. /********************************************
  1075. types.h
  1076. copyright 1991, Michael D. Brennan
  1077.  
  1078. This is a source file for mawk, an implementation of
  1079. the Awk programming language as defined in
  1080. Aho, Kernighan and Weinberger, The AWK Programming Language,
  1081. Addison-Wesley, 1988.
  1082.  
  1083. See the accompaning file, LIMITATIONS, for restrictions
  1084. regarding modification and redistribution of this
  1085. program in source or binary form.
  1086. ********************************************/
  1087.  
  1088.  
  1089. /* $Log:    types.h,v $
  1090.  * Revision 2.1  91/04/08  08:24:15  brennan
  1091.  * VERSION 0.97
  1092.  * 
  1093. */
  1094.  
  1095.  
  1096. /*  types.h  */
  1097.  
  1098. #ifndef  TYPES_H
  1099. #define  TYPES_H
  1100.  
  1101. #if     HAVE_VOID_PTR
  1102. typedef  void *PTR ;
  1103. #else
  1104. typedef  char *PTR ;
  1105. #endif
  1106.  
  1107. #include  "sizes.h"
  1108.  
  1109.  
  1110. /*  CELL  types  */
  1111.  
  1112. #define  C_NOINIT                0
  1113. #define  C_DOUBLE                1
  1114. #define  C_STRING                2
  1115. #define  C_STRNUM                3
  1116. #define  C_MBSTRN                4 
  1117.         /*could be STRNUM, has not been checked */
  1118. #define  C_RE                    5
  1119. #define  C_SPACE                 6
  1120.         /* split on space */
  1121. #define  C_SNULL                 7
  1122.         /* split on the empty string  */
  1123. #define  C_REPL                  8
  1124.         /* a replacement string   '\&' changed to &  */
  1125. #define  C_REPLV                 9
  1126.         /* a vector replacement -- broken on &  */
  1127. #define  NUM_CELL_TYPES         10
  1128.  
  1129. /* these defines are used to check types for two
  1130.    CELLs which are adjacent in memory */
  1131.  
  1132. #define  TWO_NOINITS  (2*(1<<C_NOINIT))
  1133. #define  TWO_DOUBLES  (2*(1<<C_DOUBLE))
  1134. #define  TWO_STRINGS  (2*(1<<C_STRING))
  1135. #define  TWO_STRNUMS  (2*(1<<C_STRNUM))
  1136. #define  TWO_MBSTRNS  (2*(1<<C_MBSTRN))
  1137. #define  NOINIT_AND_DOUBLE  ((1<<C_NOINIT)+(1<<C_DOUBLE))
  1138. #define  NOINIT_AND_STRING  ((1<<C_NOINIT)+(1<<C_STRING))
  1139. #define  NOINIT_AND_STRNUM  ((1<<C_NOINIT)+(1<<C_STRNUM))
  1140. #define  DOUBLE_AND_STRING  ((1<<C_DOUBLE)+(1<<C_STRING))
  1141. #define  DOUBLE_AND_STRNUM  ((1<<C_STRNUM)+(1<<C_DOUBLE))
  1142. #define  STRING_AND_STRNUM  ((1<<C_STRING)+(1<<C_STRNUM))
  1143. #define  NOINIT_AND_MBSTRN  ((1<<C_NOINIT)+(1<<C_MBSTRN))
  1144. #define  DOUBLE_AND_MBSTRN  ((1<<C_DOUBLE)+(1<<C_MBSTRN))
  1145. #define  STRING_AND_MBSTRN  ((1<<C_STRING)+(1<<C_MBSTRN))
  1146. #define  STRNUM_AND_MBSTRN  ((1<<C_STRNUM)+(1<<C_MBSTRN))
  1147.  
  1148. typedef  struct {
  1149. unsigned short ref_cnt ;
  1150. unsigned short len ;
  1151. char str[4] ;
  1152. } STRING ;
  1153.  
  1154.  
  1155. typedef  struct cell {
  1156. short type ;
  1157. short vcnt ; /* only used if type == C_REPLV   */
  1158. PTR   ptr ;
  1159. double  dval ;
  1160. }  CELL ;
  1161.  
  1162.  
  1163. /* all builtins are passed the evaluation stack pointer and
  1164.    return its new value, here is the type */
  1165.  
  1166. #ifdef __STDC__
  1167. typedef CELL *(*PF_CP)(CELL *) ;
  1168. #else
  1169. typedef CELL *(*PF_CP)() ;
  1170. #endif
  1171.  
  1172. /* an element of code (instruction) */
  1173. typedef  union {
  1174. int  op ;
  1175. PTR  ptr ;
  1176. }  INST ;
  1177.  
  1178. /* a scratch buffer type */
  1179. union tbuff {
  1180. PTR   ptr_buff[MAX_FIELD] ;
  1181. char   string_buff[TEMP_BUFF_SZ + BUFFSZ + 1] ;
  1182. } ;
  1183.  
  1184. #endif
  1185. @//E*O*F mawk0.97/types.h//
  1186. chmod u=rw,g=r,o=r mawk0.97/types.h
  1187.  
  1188. echo x - mawk0.97/zmalloc.c
  1189. sed 's/^@//' > "mawk0.97/zmalloc.c" <<'@//E*O*F mawk0.97/zmalloc.c//'
  1190.  
  1191. /********************************************
  1192. zmalloc.c
  1193. copyright 1991, Michael D. Brennan
  1194.  
  1195. This is a source file for mawk, an implementation of
  1196. the Awk programming language as defined in
  1197. Aho, Kernighan and Weinberger, The AWK Programming Language,
  1198. Addison-Wesley, 1988.
  1199.  
  1200. See the accompaning file, LIMITATIONS, for restrictions
  1201. regarding modification and redistribution of this
  1202. program in source or binary form.
  1203. ********************************************/
  1204.  
  1205. /*$Log:    zmalloc.c,v $
  1206.  * Revision 2.2  91/04/09  12:39:45  brennan
  1207.  * added static to funct decls to satisfy STARDENT compiler
  1208.  * 
  1209.  * Revision 2.1  91/04/08  08:24:17  brennan
  1210.  * VERSION 0.97
  1211.  * 
  1212. */
  1213.  
  1214. /*  zmalloc.c  */
  1215. #include  "mawk.h"
  1216. #include  "zmalloc.h"
  1217.  
  1218. void PROTO( mawk_exit, (int) ) ;
  1219.  
  1220. /*
  1221.   zmalloc() gets mem from malloc() in CHUNKS of 2048 bytes
  1222.   and cuts these blocks into smaller pieces that are multiples
  1223.   of eight bytes.  When a piece is returned via zfree(), it goes
  1224.   on a linked linear list indexed by its size.  The lists are
  1225.   an array, pool[].
  1226.  
  1227.   E.g., if you ask for 22 bytes with p = zmalloc(22), you actually get
  1228.   a piece of size 24.  When you free it with zfree(p,22) , it is added
  1229.   to the list at pool[2].
  1230. */
  1231.  
  1232. #define ZBLOCKSZ    8    
  1233. #define ZSHIFT      3
  1234. #define POOLSZ      16
  1235.  
  1236. #define  CHUNK          256    
  1237.         /* number of blocks to get from malloc */
  1238.  
  1239. static PTR  PROTO( emalloc, (unsigned) ) ;
  1240. void PROTO( errmsg, (int , char *, ...) ) ;
  1241.  
  1242. static PTR emalloc(size)
  1243.   unsigned size ;
  1244. { PTR p ;
  1245.  
  1246.   if( !(p = malloc(size)) )
  1247.   { errmsg(0, "out of memory") ; mawk_exit(1) ; }
  1248.   return p ;
  1249. }
  1250.  
  1251.  
  1252. typedef  union  zblock {
  1253. char dummy[ZBLOCKSZ] ;
  1254. union zblock *link ;
  1255. }  ZBLOCK  ;
  1256.  
  1257. /* ZBLOCKS of sizes 1, 2, ... 16
  1258.    which is bytes of sizes 8, 16, ... , 128
  1259.    are stored on the linked linear lists in
  1260.    pool[0], pool[1], ... , pool[15]
  1261. */
  1262.  
  1263. static  ZBLOCK  *pool[POOLSZ] ;
  1264.  
  1265. PTR   zmalloc( size )
  1266.   unsigned size ;
  1267. { register unsigned blocks ;
  1268.   register ZBLOCK *p ;
  1269.   static  unsigned amt_avail ;
  1270.   static  ZBLOCK  *avail ;
  1271.  
  1272.   if ( size > POOLSZ * ZBLOCKSZ )  return emalloc(size) ;
  1273.  
  1274.   blocks = (size >> ZSHIFT) + ((size & (ZBLOCKSZ-1)) != 0) ;
  1275.  
  1276.   if ( p = pool[blocks-1] )
  1277.   { pool[blocks-1] = p->link ; return (PTR) p ; }
  1278.  
  1279.   if ( blocks > amt_avail )
  1280.   { if ( amt_avail ) /* free avail */
  1281.     { avail->link = pool[--amt_avail] ; pool[amt_avail] = avail ; }
  1282.     if ( !(avail = (ZBLOCK *) malloc(CHUNK*ZBLOCKSZ)) )
  1283.     { /* if we get here, almost out of memory */
  1284.         amt_avail = 0 ;   return  emalloc(size) ; }
  1285.     amt_avail = CHUNK ;
  1286.   }
  1287.   
  1288.   /* get p from the avail pile */
  1289.   p = avail ; avail += blocks ; amt_avail -= blocks ; 
  1290.   return (PTR) p ;
  1291. }
  1292.  
  1293. void  zfree( p, size)
  1294.   register PTR p ;  unsigned size ;
  1295. { register int index ; ;
  1296.  
  1297.   if ( size > POOLSZ * ZBLOCKSZ )  free(p) ;
  1298.   else
  1299.   {
  1300.     index  = (size >> ZSHIFT) + ((size & (ZBLOCKSZ-1)) != 0) - 1;
  1301.     ((ZBLOCK *) p)->link = pool[index] ;
  1302.     pool[index] = (ZBLOCK *) p ;
  1303.   }
  1304. }
  1305.  
  1306. PTR  zrealloc( p, old_size, new_size )
  1307.   register PTR  p ;
  1308.   unsigned old_size, new_size ;
  1309. { register PTR q ;
  1310.  
  1311.   (void) memcpy(q = zmalloc(new_size), p, 
  1312.                 old_size < new_size ? old_size : new_size) ;
  1313.  
  1314.   zfree(p, old_size) ;
  1315.   return q ;
  1316. }
  1317.  
  1318.  
  1319. @//E*O*F mawk0.97/zmalloc.c//
  1320. chmod u=rw,g=r,o=r mawk0.97/zmalloc.c
  1321.  
  1322. echo x - mawk0.97/zmalloc.h
  1323. sed 's/^@//' > "mawk0.97/zmalloc.h" <<'@//E*O*F mawk0.97/zmalloc.h//'
  1324.  
  1325. /********************************************
  1326. zmalloc.h
  1327. copyright 1991, Michael D. Brennan
  1328.  
  1329. This is a source file for mawk, an implementation of
  1330. the Awk programming language as defined in
  1331. Aho, Kernighan and Weinberger, The AWK Programming Language,
  1332. Addison-Wesley, 1988.
  1333.  
  1334. See the accompaning file, LIMITATIONS, for restrictions
  1335. regarding modification and redistribution of this
  1336. program in source or binary form.
  1337. ********************************************/
  1338.  
  1339. /*$Log:    zmalloc.h,v $
  1340.  * Revision 2.1  91/04/08  08:24:19  brennan
  1341.  * VERSION 0.97
  1342.  * 
  1343. */
  1344.  
  1345. /* zmalloc.h */
  1346.  
  1347. #ifndef  ZMALLOC_H
  1348. #define  ZMALLOC_H
  1349.  
  1350. #ifdef   __STDC__
  1351. #include  <stdlib.h>
  1352. #include  <string.h>   /* memcpy() */
  1353.  
  1354. #else
  1355.  
  1356. PTR  memcpy(), malloc(), realloc() ;
  1357. void free() ;
  1358. #endif
  1359.  
  1360.  
  1361. PTR  PROTO( zmalloc, (unsigned) ) ;
  1362. void PROTO( zfree, (PTR, unsigned) ) ;
  1363. PTR  PROTO( zrealloc , (PTR,unsigned,unsigned) ) ;
  1364.  
  1365.  
  1366.  
  1367. #endif  /* ZMALLOC_H */
  1368. @//E*O*F mawk0.97/zmalloc.h//
  1369. chmod u=rw,g=r,o=r mawk0.97/zmalloc.h
  1370.  
  1371. echo mkdir - mawk0.97/rexp
  1372. mkdir mawk0.97/rexp
  1373. chmod u=rwx,g=rx,o=rx mawk0.97/rexp
  1374.  
  1375. echo x - mawk0.97/rexp/Makefile
  1376. sed 's/^@//' > "mawk0.97/rexp/Makefile" <<'@//E*O*F mawk0.97/rexp/Makefile//'
  1377.  
  1378. ####################################
  1379. # This is a makefile for mawk,
  1380. # an implementation of AWK (1988).
  1381. ####################################
  1382. #
  1383. #
  1384. # This builds a regular expression library
  1385. # Remove the -DMAWK and the library has general use.
  1386. # (Even if left in, the diff is very small)
  1387. #
  1388.  
  1389. CFLAGS = -O  -DMAWK
  1390.  
  1391. C=rexp.c rexp0.c rexp1.c rexp2.c rexp3.c rexpdb.c
  1392.  
  1393. regexp.a : $(C)
  1394.     rm -f *.o
  1395.     cc -c $(CFLAGS) $?
  1396.     ar r regexp.a *.o
  1397.     rm -f *.o
  1398.  
  1399.  
  1400.  
  1401.     
  1402.  
  1403. @//E*O*F mawk0.97/rexp/Makefile//
  1404. chmod u=rw,g=r,o=r mawk0.97/rexp/Makefile
  1405.  
  1406. echo x - mawk0.97/rexp/rexp.c
  1407. sed 's/^@//' > "mawk0.97/rexp/rexp.c" <<'@//E*O*F mawk0.97/rexp/rexp.c//'
  1408.  
  1409. /********************************************
  1410. rexp.c
  1411. copyright 1991, Michael D. Brennan
  1412.  
  1413. This is a source file for mawk an implementation of
  1414. the Awk programming language as defined in
  1415. Aho, Kernighan and Weinberger, The AWK Programming Language,
  1416. Addison-Wesley, 1988.
  1417.  
  1418. See the accompaning file, LIMITATIONS, for restrictions
  1419. regarding modification and redistribution of this
  1420. program in source or binary form.
  1421. ********************************************/
  1422.  
  1423. /*   rexp.c   */
  1424.  
  1425. /*  op precedence  parser for regular expressions  */
  1426.  
  1427. #include  "rexp.h"
  1428.  
  1429. /* static  prototypes */
  1430. void  PROTO( op_pop, (void) ) ;
  1431.  
  1432. /*  DATA   */
  1433. int   REerrno ;
  1434. char *REerrlist[] = { (char *) 0 ,
  1435. /* 1  */    "missing '('",
  1436. /* 2  */    "missing ')'",
  1437. /* 3  */    "bad class -- [], [^] or [" ,
  1438. /* 4  */    "missing operand" ,
  1439. /* 5  */    "resource exhaustion -- regular expression too large",
  1440. /* 6  */    "null regular expression" } ;
  1441.  
  1442. /* E5 is very unlikely to occur */
  1443.  
  1444. /* This table drives the operator precedence parser */
  1445. static  int  table[8][8]  =  {
  1446.  
  1447. /*        0   |   CAT   *   +   ?   (   )   */
  1448. /* 0 */   0,  L,  L,    L,  L,  L,  L,  E1,
  1449. /* | */   G,  G,  L,    L,  L,  L,  L,  G,
  1450. /* CAT*/  G,  G,  G,    L,  L,  L,  L,  G,
  1451. /* * */   G,  G,  G,    G,  G,  G, E7,  G,
  1452. /* + */   G,  G,  G,    G,  G,  G, E7,  G,
  1453. /* ? */   G,  G,  G,    G,  G,  G, E7,  G,
  1454. /* ( */   E2, L,  L,    L,  L,  L,  L,  EQ,
  1455. /* ) */   G , G,  G,    G,  G,  G,  E7,  G     }   ;
  1456.  
  1457.  
  1458. /*====================================
  1459.   THE  STACKS
  1460.  ==========================*/
  1461. typedef struct
  1462. { int  token ;
  1463.   int  prec ;   }  OP ;
  1464.  
  1465. #define  STACKSZ   96
  1466.  
  1467. /*---------------------------
  1468.   m_ptr -> top filled slot on the m_stack
  1469.   op_ptr -> top filled slot on op_stack, 
  1470.      initially this is only half filled with the token
  1471.      the precedence is added later
  1472.  *----------------------*/
  1473.  
  1474. static  OP  *op_stack, *op_limit, *op_ptr ;
  1475. static  MACHINE *m_stack, *m_limit, *m_ptr ;
  1476.  
  1477. /* inline for speed on the m_stack */
  1478. #define m_pop() (m_ptr<m_stack?RE_error_trap(-E4): *m_ptr--)
  1479. #define m_push(x)  if(++m_ptr==m_limit) RE_error_trap(-E5);*m_ptr=(x)
  1480.  
  1481. /*=======================*/
  1482.  
  1483. static jmp_buf  err_buf  ;  /*  used to trap on error */
  1484.  
  1485. MACHINE  RE_error_trap(x)  /* return is dummy to make macro OK */
  1486.   int x ;
  1487. {
  1488.   while ( m_ptr >= m_stack ) RE_free( m_ptr-- -> start ) ;
  1489.   RE_free(m_stack) ; RE_free(op_stack) ;
  1490.   REerrno = x ;
  1491.   longjmp(err_buf, 1 ) ;
  1492.   /* dummy return to make compiler happy */
  1493.   return *m_stack ;
  1494. }
  1495.  
  1496.  
  1497. VOID *REcompile(re)
  1498.   char *re ;
  1499. { MACHINE  m  ;
  1500.   register int  t ;
  1501.  
  1502.   RE_lex_init(re) ;
  1503.  
  1504.   if ( *re == 0 )
  1505.   { STATE *p = (STATE *) RE_malloc( sizeof(STATE) ) ;
  1506.     p->type = M_ACCEPT ;
  1507.     return  (VOID *) p ;
  1508.   }
  1509.  
  1510.   if ( setjmp(err_buf) )   return (VOID *) 0 ;
  1511.      /* global error trap */
  1512.  
  1513.   /* initialize the stacks  */
  1514.   m_stack =(MACHINE *) RE_malloc(STACKSZ*sizeof(MACHINE)) ;
  1515.   m_ptr = m_stack - 1 ;
  1516.   m_limit = m_stack + STACKSZ ;
  1517.   op_ptr = op_stack = (OP *) RE_malloc(STACKSZ*sizeof(OP)) ;
  1518.   op_ptr->token = 0 ;
  1519.   op_limit = op_stack + STACKSZ ;
  1520.  
  1521.  
  1522.   t = RE_lex(&m) ;
  1523.  
  1524.   while( 1 )
  1525.    { switch( t )
  1526.        { 
  1527.          case T_STR  :
  1528.          case T_ANY  :
  1529.          case T_U    :
  1530.          case T_START :
  1531.          case T_END :
  1532.          case T_CLASS :  m_push(m) ;  break ;
  1533.  
  1534.          case  0 :   /*  end of reg expr   */
  1535.            if ( op_ptr -> token == 0 )  /*  done   */
  1536.            { m = m_pop() ;
  1537.              if ( m_ptr < m_stack )  /* DONE !!! */
  1538.              { free(m_stack) ; free(op_stack) ;
  1539.                return  (VOID *) m.start ;
  1540.              }
  1541.                /*  machines still on the stack  */
  1542.              RE_panic("values still on machine stack") ;
  1543.              }
  1544.          /*  case 0  falls  thru to default
  1545.              which is operator case  */
  1546.  
  1547.          default:
  1548.  
  1549.            if ( (op_ptr -> prec = table[op_ptr -> token][t]) == G )
  1550.                { while ( op_ptr -> prec != L )  op_pop() ;
  1551.                  continue ; }
  1552.  
  1553.            if ( op_ptr -> prec < 0 )
  1554.               if ( op_ptr->prec == E7 ) 
  1555.                   RE_panic("parser returns E7") ;
  1556.               else  RE_error_trap(-op_ptr->prec) ;
  1557.  
  1558.            if ( ++op_ptr == op_stack + STACKSZ ) /* stack overflow */
  1559.                  RE_error_trap(-E5) ;
  1560.            op_ptr -> token = t ;
  1561.        }
  1562.     t = RE_lex(&m) ;
  1563.   }
  1564. }
  1565.  
  1566. static void  op_pop()
  1567. { register int  t  ;
  1568.   MACHINE m, n ;
  1569.  
  1570.   if ( (t = op_ptr-- -> token) >= T_LP ) return ;
  1571.         /* nothing to do with '(' or ')' */
  1572.   if ( t <= T_CAT )  /* binary operation */
  1573.         n = m_pop() ;
  1574.   m = m_pop() ;
  1575.  
  1576.   switch( t )
  1577.   {  case  T_CAT :  RE_cat(&m, &n) ;  break ;
  1578.      case  T_OR  :  RE_or( &m, &n) ;  break ;
  1579.      case T_STAR  :  RE_close( &m) ;  break ;
  1580.      case T_PLUS  :  RE_poscl( &m ) ; break ;
  1581.      case T_Q     :  RE_01( &m ) ;    break ;
  1582.      default       :
  1583.         RE_panic("strange token popped from op_stack") ;
  1584.   }
  1585.   m_push(m) ;
  1586. }
  1587.  
  1588. /* getting here means a logic flaw or unforeseen case */
  1589. void RE_panic( s )
  1590.   char *s ;
  1591. { fprintf( stderr, "REcompile() - panic:  %s\n", s) ;
  1592.   exit(100) ; }
  1593.  
  1594. @//E*O*F mawk0.97/rexp/rexp.c//
  1595. chmod u=rw,g=r,o=r mawk0.97/rexp/rexp.c
  1596.  
  1597. echo x - mawk0.97/rexp/rexp.h
  1598. sed 's/^@//' > "mawk0.97/rexp/rexp.h" <<'@//E*O*F mawk0.97/rexp/rexp.h//'
  1599.  
  1600. /********************************************
  1601. rexp.h
  1602. copyright 1991, Michael D. Brennan
  1603.  
  1604. This is a source file for mawk an implementation of
  1605. the Awk programming language as defined in
  1606. Aho, Kernighan and Weinberger, The AWK Programming Language,
  1607. Addison-Wesley, 1988.
  1608.  
  1609. See the accompaning file, LIMITATIONS, for restrictions
  1610. regarding modification and redistribution of this
  1611. program in source or binary form.
  1612. ********************************************/
  1613.  
  1614. /*  rexp.h    */
  1615.  
  1616. #ifndef  REXP_H
  1617. #define  REXP_H
  1618.  
  1619. #include  <string.h>
  1620. #include  <stdio.h>
  1621. #include  <setjmp.h>
  1622.  
  1623. #ifndef   PROTO
  1624. #ifdef    __STDC__
  1625. #define  PROTO(name, args)   name  args
  1626. #else
  1627. #define  PROTO(name, args)   name()
  1628. #endif
  1629. #endif   
  1630.  
  1631. #ifdef  __STDC__
  1632. #define  VOID   void
  1633. #include <stdlib.h>
  1634. #else
  1635. #define  VOID   char
  1636. char *malloc(), *realloc() ;
  1637. void free() ;
  1638. #endif
  1639.  
  1640. /* user can change this  */
  1641.  
  1642. #define  RE_malloc(x)    RE_xmalloc(x)
  1643. #define  RE_realloc(x,l)   RE_xrealloc(x,l)
  1644. #define  RE_free(x)      free(x)
  1645.  
  1646. VOID  *PROTO( RE_xmalloc, (unsigned) ) ;
  1647. VOID  *PROTO( RE_xrealloc, (void *,unsigned) ) ;
  1648.  
  1649.  
  1650. /*  finite machine  state types  */
  1651.  
  1652. #define  M_STR         0
  1653. #define  M_CLASS       1
  1654. #define  M_ANY         2
  1655. #define  M_START       3
  1656. #define  M_END         4
  1657. #define  M_U           5
  1658. #define  M_1J          6
  1659. #define  M_2JA         7
  1660. #define  M_2JB         8
  1661. #define  M_ACCEPT      9
  1662. #define  U_ON          10
  1663.  
  1664. #define  U_OFF     0
  1665. #define  END_OFF   0
  1666. #define  END_ON    (2*U_ON)
  1667.  
  1668.  
  1669. typedef  unsigned char BV[32] ;  /* bit vector */
  1670.  
  1671. typedef  struct
  1672. { char type ;
  1673.   unsigned char  len ;  /* used for M_STR  */
  1674.   union
  1675.    { 
  1676.      char *str  ;  /* string */
  1677.      BV   *bvp ;   /*  class  */
  1678.      int   jump ;
  1679.    }  data ;
  1680. }     STATE  ;
  1681.  
  1682. #define  STATESZ  (sizeof(STATE))
  1683.  
  1684. typedef  struct
  1685. { STATE  *start, *stop ; }   MACHINE ;
  1686.  
  1687.  
  1688. /*  tokens   */
  1689. #define  T_OR   1       /* | */
  1690. #define  T_CAT  2       
  1691. #define  T_STAR 3       /* * */
  1692. #define  T_PLUS 4       /* + */
  1693. #define  T_Q    5       /* ? */
  1694. #define  T_LP   6       /* ( */
  1695. #define  T_RP   7       /* ) */
  1696. #define  T_START 8      /* ^ */
  1697. #define  T_END  9       /* $ */
  1698. #define  T_ANY  10      /* . */
  1699. #define  T_CLASS 11     /* starts with [ */
  1700. #define  T_SLASH 12     /*  \  */
  1701. #define  T_CHAR  13     /* all the rest */
  1702. #define  T_STR   14
  1703. #define  T_U     15
  1704.  
  1705. /*  precedences and error codes  */
  1706. #define  L   0
  1707. #define  EQ  1
  1708. #define  G   2
  1709. #define  E1  (-1)
  1710. #define  E2  (-2)
  1711. #define  E3  (-3)
  1712. #define  E4  (-4)
  1713. #define  E5  (-5)
  1714. #define  E6  (-6)
  1715. #define  E7  (-7)
  1716.  
  1717. #define  MEMORY_FAILURE      5
  1718.  
  1719. /* struct for the run time stack */
  1720. typedef struct {
  1721. STATE *m ;   /*   save the machine ptr */
  1722. int    u ;   /*   save the u_flag */
  1723. char  *s ;   /*   save the active string ptr */
  1724. char  *ss ;  /*   save the match start -- only used by REmatch */
  1725. } RT_STATE ;   /* run time state */
  1726.  
  1727. /*  error  trap   */
  1728. extern int REerrno ;
  1729. MACHINE   PROTO(RE_error_trap, (int) ) ;
  1730.  
  1731.  
  1732. MACHINE   PROTO( RE_u, (void) ) ;
  1733. MACHINE   PROTO( RE_start, (void) ) ;
  1734. MACHINE   PROTO( RE_end, (void) ) ;
  1735. MACHINE   PROTO( RE_any, (void) ) ;
  1736. MACHINE   PROTO( RE_str, (char *, unsigned) ) ;
  1737. MACHINE   PROTO( RE_class, (BV *) ) ;
  1738. void      PROTO( RE_cat, (MACHINE *, MACHINE *) ) ;
  1739. void      PROTO( RE_or, (MACHINE *, MACHINE *) ) ;
  1740. void      PROTO( RE_close, (MACHINE *) ) ;
  1741. void      PROTO( RE_poscl, (MACHINE *) ) ;
  1742. void      PROTO( RE_01, (MACHINE *) ) ;
  1743. void      PROTO( RE_panic, (char *) ) ;
  1744. char     *PROTO( str_str, (char *, char *, unsigned) ) ;
  1745.  
  1746. void      PROTO( RE_lex_init , (char *) ) ;
  1747. int       PROTO( RE_lex , (MACHINE *) ) ;
  1748. void      PROTO( RE_run_stack_init, (void) ) ;
  1749. RT_STATE *PROTO( RE_new_run_stack, (void) ) ;
  1750.  
  1751. #endif   /* REXP_H  */
  1752. @//E*O*F mawk0.97/rexp/rexp.h//
  1753. chmod u=rw,g=r,o=r mawk0.97/rexp/rexp.h
  1754.  
  1755. echo x - mawk0.97/rexp/rexp0.c
  1756. sed 's/^@//' > "mawk0.97/rexp/rexp0.c" <<'@//E*O*F mawk0.97/rexp/rexp0.c//'
  1757.  
  1758. /********************************************
  1759. rexp0.c
  1760. copyright 1991, Michael D. Brennan
  1761.  
  1762. This is a source file for mawk an implementation of
  1763. the Awk programming language as defined in
  1764. Aho, Kernighan and Weinberger, The AWK Programming Language,
  1765. Addison-Wesley, 1988.
  1766.  
  1767. See the accompaning file, LIMITATIONS, for restrictions
  1768. regarding modification and redistribution of this
  1769. program in source or binary form.
  1770. ********************************************/
  1771.  
  1772. /*  rexp0.c   */
  1773.  
  1774. /*  lexical scanner  */
  1775.  
  1776. #include  "rexp.h"
  1777.  
  1778. /* static functions */
  1779. static int  PROTO( do_str, (int, char **, MACHINE *) ) ;
  1780. static int  PROTO( do_class, (char **, MACHINE *) ) ;
  1781. static int  PROTO( escape, (char **) ) ;
  1782. static BV   *PROTO( store_bvp, (BV *) ) ;
  1783. static int  PROTO( ctohex, (int) ) ;
  1784.  
  1785.  
  1786. #ifndef  EG  /* if EG make next array visible */
  1787. static
  1788. #endif
  1789. char  RE_char2token[ '|' + 1 ] = {
  1790. 0,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
  1791. 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,9,13,13,13,
  1792. 6,7,3,4,13,13,10,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
  1793. 13,13,5,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
  1794. 13,13,13,13,13,13,13,13,13,13,11,12,13,8,13,13,13,13,13,13,
  1795. 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,
  1796. 13,13,13,13,1} ;
  1797.  
  1798. #define  char2token(x) ( (unsigned char)(x) > '|' ? T_CHAR : RE_char2token[x] )
  1799.  
  1800. #define NOT_STARTED    (-1)
  1801.  
  1802. static  int  prev  ;
  1803. static  char   *lp  ;     /*  ptr to reg exp string  */
  1804. static  unsigned re_len ;
  1805.  
  1806.  
  1807. void  RE_lex_init( re )
  1808.   char *re ;
  1809. { 
  1810.   lp = re ;
  1811.   re_len = strlen(re) + 1  ;
  1812.   prev = NOT_STARTED ;
  1813.   RE_run_stack_init() ;
  1814. }
  1815.   
  1816.  
  1817. int   RE_lex( mp )
  1818.   MACHINE  *mp ;
  1819. { register int c ;
  1820.  
  1821.   switch( c = char2token(*lp) )
  1822.    {
  1823.      case T_OR :
  1824.      case T_PLUS :
  1825.      case T_STAR :
  1826.      case T_Q :
  1827.      case T_RP :
  1828.            lp++ ;  return  prev = c ;
  1829.      case T_SLASH :
  1830.            if ( lp[1] != 0 )  break ;
  1831.            /* else fall thru */
  1832.  
  1833.      case 0   :   return 0 ;
  1834.      
  1835.      case T_LP :
  1836.            switch( prev )
  1837.            { 
  1838.              case T_CHAR :
  1839.              case T_STR  :
  1840.              case T_ANY :
  1841.              case T_CLASS :
  1842.              case T_START :
  1843.              case T_RP :
  1844.              case T_PLUS :
  1845.              case T_STAR :
  1846.              case T_Q :
  1847.              case T_U :
  1848.                   return prev = T_CAT ;
  1849.              default  :
  1850.                   lp++ ;
  1851.                   return prev = T_LP ;
  1852.            }
  1853.    }
  1854.  
  1855.   /*  *lp  is  an operand, but implicit cat op is possible   */
  1856.   switch( prev )
  1857.    { case  NOT_STARTED :
  1858.      case  T_OR :
  1859.      case  T_LP :
  1860.      case T_CAT :
  1861.  
  1862.           switch( c )
  1863.            { case  T_ANY : 
  1864.              { static plus_is_star_flag = 0 ;
  1865.  
  1866.                   if ( * ++lp == '*' )
  1867.                   { lp++ ;  *mp = RE_u() ;
  1868.                     return  prev = T_U ; }
  1869.                   else
  1870.                   if ( *lp == '+' )
  1871.                       if ( plus_is_star_flag )
  1872.                       { lp++ ;  *mp = RE_u() ;
  1873.                         plus_is_star_flag = 0 ;
  1874.                         return prev = T_U ;
  1875.                       }
  1876.                       else
  1877.                       { plus_is_star_flag = 1 ;
  1878.                         lp-- ; *mp = RE_any() ;
  1879.                         return prev = T_ANY ;
  1880.                       }
  1881.                   else  
  1882.                   { *mp = RE_any() ;
  1883.                     prev = T_ANY ;
  1884.                   }
  1885.               }
  1886.               break ;
  1887.                     
  1888.              case  T_SLASH :
  1889.                   lp++ ; c = escape(&lp) ;
  1890.                   prev = do_str(c, &lp, mp) ;
  1891.                   break ;
  1892.  
  1893.              case  T_CHAR  :
  1894.                   c = *lp++ ;
  1895.                   prev = do_str(c, &lp, mp) ;
  1896.                   break ;
  1897.  
  1898.              case T_CLASS : prev = do_class(&lp, mp) ;
  1899.                             break ;
  1900.  
  1901.              case T_START : *mp = RE_start() ; lp++ ;
  1902.                             prev = T_START ;
  1903.                             break ;
  1904.  
  1905.              case T_END :  
  1906.                      lp++ ; *mp = RE_end() ;
  1907.                      return  prev = T_END ;
  1908.  
  1909.              default :
  1910.                      RE_panic("bad switch in RE_lex") ;
  1911.            }
  1912.            break ;
  1913.  
  1914.      default : /* don't advance the pointer, return T_CAT */
  1915.           return prev = T_CAT ;
  1916.     }
  1917.     /* check for end character */
  1918.     if ( *lp == '$' )
  1919.     { mp->start->type += END_ON ; lp++ ; }
  1920.     return prev ;
  1921. }
  1922.  
  1923. static  int  do_str( c, pp, mp)
  1924.   int c ; /* the first character */
  1925.   char **pp ;  /* where to put the re_char pointer on exit */
  1926.   MACHINE  *mp ;  /* where to put the string machine */
  1927. { register char *p , *s ;
  1928.   char *str ;
  1929.   unsigned len ;
  1930.  
  1931.  
  1932.   p = *pp ;
  1933.   s = str = RE_malloc( re_len ) ;
  1934.   *s++ = c ;  len = 1 ;
  1935.  
  1936.   while ( 1 )
  1937.   { char *save ;
  1938.   
  1939.     switch( char2token(*p) )
  1940.     {
  1941.       case  T_CHAR :  *s++ = *p++ ;
  1942.                       break ;
  1943.       case  T_SLASH :
  1944.                       save = ++p ;
  1945.                       *s++ = escape(&save) ;
  1946.                       p = save ;
  1947.                       break ;
  1948.  
  1949.       default  :  goto  out ;
  1950.     }
  1951.     len++ ;
  1952.   }
  1953. out:
  1954.   /* if len > 1 and we failed on a ? + or * , need to back up */
  1955.   if ( len > 1 && (*p == '*' || *p == '+' || *p == '?' ) )
  1956.   { len-- ; p-- ; s-- ; }
  1957.  
  1958.   *s = 0 ;
  1959.   *pp = p ;
  1960.   *mp = RE_str((char *) RE_realloc(str, len+1) , len) ;
  1961.   return  T_STR ;
  1962. }
  1963.  
  1964.  
  1965. /*--------------------------------------------
  1966.   BUILD A CHARACTER CLASS
  1967.  *---------------------------*/
  1968.  
  1969. #define  on( b, x)  ( (b)[(x)>>3] |= ( 1 << ((x)&7) ))
  1970.  
  1971. static  void  PROTO(block_on, (BV,int,int) ) ;
  1972.  
  1973. static  void  block_on( b, x, y)
  1974.   BV b ; int x, y ;  /* must call with x<=y */
  1975. { int lo = x >> 3 ;
  1976.   int hi = y >> 3 ;
  1977.   int  i, j, bit  ;
  1978.  
  1979.   if ( lo == hi )
  1980.     { j = x&7 ; bit =  1 << j ; i = (y&7) - j + 1 ;
  1981.       for ( ; i ; i-- , bit <<= 1 )  b[lo] |= bit ; }
  1982.   else
  1983.     { for ( i = lo + 1 ; i <= hi - 1 ; i++ )  b[i] = 0xff ;
  1984.       b[lo] |= ( 0xff << (x&7) ) ;
  1985.       b[hi] |= ~( 0xff << ((y&7)+1)) ;
  1986.     }
  1987. }
  1988.  
  1989. /* build a BV for a character class.
  1990.    *start points at the '['
  1991.    on exit:   *start points at the character after ']'
  1992.               mp points at a machine that recognizes the class
  1993. */
  1994.  
  1995. static int  do_class( start, mp)
  1996.   char **start ; MACHINE  *mp ;
  1997. { register char *p ;
  1998.   register BV   *bvp ;
  1999.   int  prev ;
  2000.   char *q , *t;
  2001.   int  cnt ;
  2002.   int comp_flag ;
  2003.  
  2004.   p = (*start) + 1 ;
  2005.   if ( *p == ']' || *p == '^' && *(p+1) == ']' )
  2006.          RE_error_trap(-E3) ;
  2007.   while ( 1 )  /* find the back of the class */
  2008.     { if ( ! (q = strchr(p,']')) )  /* no closing bracket */
  2009.          RE_error_trap(-E3) ;
  2010.       p = q-1 ;
  2011.       cnt = 0 ;
  2012.       while ( *p == '\\') { cnt++ ; p-- ; }
  2013.       if ( (cnt & 1) == 0 )  /* even number of \ */  break ;
  2014.       p = q+1 ;
  2015.     }
  2016.   /*  q  now  pts at the back of the class   */
  2017.   p = (*start) + 1 ;
  2018.   *start = q + 1 ;
  2019.  
  2020.   bvp = (BV *) RE_malloc( sizeof(BV) ) ;
  2021.   (void) memset( bvp, 0, sizeof(BV) ) ;
  2022.  
  2023.   comp_flag = *p == '^' ? p++ , 1 : 0 ;
  2024.   prev = -1 ;  /* indicates  -  cannot be part of a range  */
  2025.  
  2026.   while ( p < q )
  2027.   {
  2028.      switch( *p )
  2029.       { case '\\' :
  2030.           t = ++p ;
  2031.           prev = escape(&t) ;
  2032.           on(*bvp, prev) ;
  2033.           p = t ;
  2034.           continue ;
  2035.  
  2036.         case '-' :
  2037.           if ( prev == -1 || p+1 == q || prev > *(p+1) )
  2038.              { prev = '-' ; on(*bvp, '-') ; }
  2039.           else
  2040.              { p++ ;
  2041.                block_on(*bvp, prev, *p) ;
  2042.                prev = -1 ;
  2043.              }
  2044.           break ;
  2045.  
  2046.         default :
  2047.           prev = *p ;
  2048.           on(*bvp, *p) ;
  2049.           break ;
  2050.       }
  2051.       p++ ;
  2052.   }
  2053.  
  2054.   if ( comp_flag )
  2055.     for ( p = (char *) bvp ; p < (char *) bvp + sizeof(BV) ; p++)  *p = ~*p ;
  2056.  
  2057.   /* make sure zero is off */
  2058.   (*bvp)[0] &= 0xfe ;
  2059.  
  2060.   *mp = RE_class( store_bvp( bvp ) ) ;
  2061.   return  T_CLASS ;
  2062. }
  2063.  
  2064.  
  2065. /* storage for bit vectors so they can be reused ,
  2066.    stored in an unsorted linear array 
  2067.    the array grows as needed
  2068. */
  2069.  
  2070. #define         BV_GROWTH       6
  2071.  
  2072. static BV *store_bvp( bvp )
  2073.   BV *bvp ;
  2074. {
  2075.   static BV **bv_base, **bv_limit ;
  2076.   static BV **bv_next ; /* next empty slot in the array */
  2077.  
  2078.   register BV **p ;
  2079.   unsigned t ;
  2080.  
  2081.  
  2082.   if ( bv_next == bv_limit ) /* need to grow */
  2083.   {
  2084.     if ( ! bv_base )  /* first growth */
  2085.     {  t = 0 ; bv_base = (BV**)RE_malloc(BV_GROWTH*sizeof(BV*)) ; }
  2086.     else 
  2087.     { t = bv_next - bv_base ;
  2088.       bv_base = (BV**) RE_realloc(bv_base, (t+BV_GROWTH)*sizeof(BV*)) ;
  2089.     }
  2090.  
  2091.     bv_next = bv_base + t ;
  2092.     bv_limit = bv_next + BV_GROWTH ;
  2093.   }
  2094.  
  2095.   /* put bvp in bv_next as a sentinal */
  2096.   *bv_next = bvp ;
  2097.   p = bv_base ;
  2098.   while ( memcmp(*p, bvp, sizeof(BV)) )  p++ ;
  2099.  
  2100.   if ( p == bv_next )  /* it is new */
  2101.         bv_next++ ;
  2102.   else  /* we already have it */  RE_free(bvp) ;
  2103.  
  2104.   return *p ;
  2105. }
  2106.   
  2107.  
  2108. /* ----------   convert escape sequences  -------------*/
  2109.  
  2110. #define isoctal(x)  ((x)>='0'&&(x)<='7')
  2111.  
  2112. #define  NOT_HEX        16
  2113. static char hex_val['f' - 'A' + 1] = {
  2114. 10,11,12,13,14,15, 0, 0,
  2115.  0, 0, 0, 0, 0, 0, 0, 0,
  2116.  0, 0, 0, 0, 0, 0, 0, 0,
  2117.  0, 0, 0, 0, 0, 0, 0, 0,
  2118. 10,11,12,13,14,15 } ;
  2119.  
  2120. /* interpret 1 character as hex */
  2121. static int ctohex( c )
  2122.   register int c ;
  2123. { int t ;
  2124.  
  2125.   if ( c >= '0' && c <= '9' )  return c - '0' ;
  2126.  
  2127.   if ( c >= 'A' && c <= 'f' && ( t = hex_val[c-'A'] ))  return t ;
  2128.  
  2129.   return NOT_HEX ;
  2130. }
  2131.  
  2132. static char escape_test[] = "n\nt\tb\br\rf\fa\07v\013" ;
  2133.  
  2134. /*-----------------
  2135.   return the char 
  2136.   and move the pointer forward
  2137.   on entry *s -> at the character after the slash
  2138.  *-------------------*/
  2139.  
  2140. static int escape(start_p)
  2141.   char **start_p ;
  2142. { register char *p = *start_p ;
  2143.   register unsigned x ;
  2144.   unsigned xx ;
  2145.   char *t ;
  2146.  
  2147.   
  2148.   if ( t = strchr(escape_test, *p) )
  2149.   { *start_p = p + 1 ;
  2150.     return  t[1] ;
  2151.   }
  2152.  
  2153.   if ( isoctal(*p) )
  2154.   { x = *p++ - '0' ;
  2155.     if ( isoctal(*p) )
  2156.     { x = (x<<3) + *p++ - '0' ;
  2157.       if ( isoctal(*p) )
  2158.          x = (x<<3) + *p++ - '0' ;
  2159.     }
  2160.     *start_p = p ;
  2161.     return  x & 0xff ;
  2162.   }
  2163.  
  2164.   if ( *p == 0 )  return 0 ;
  2165.  
  2166.   if ( *p++ == 'x' ) /* might be a hex digit */
  2167.   {  if ( (x = ctohex(*p)) == NOT_HEX ) 
  2168.      { *start_p  = p ;  return 'x' ; }
  2169.  
  2170.      /* look for another hex digit */
  2171.      if ( (xx = ctohex(* ++p)) != NOT_HEX )
  2172.      { x = (x<<4) + xx ; p++ ; }
  2173.  
  2174.      *start_p = p ; return x ;
  2175.   }
  2176.   /* anything else \c -> c */
  2177.   *start_p = p ;
  2178.   return p[-1]  ;
  2179. }
  2180. @//E*O*F mawk0.97/rexp/rexp0.c//
  2181. chmod u=rw,g=r,o=r mawk0.97/rexp/rexp0.c
  2182.  
  2183. echo x - mawk0.97/rexp/rexp1.c
  2184. sed 's/^@//' > "mawk0.97/rexp/rexp1.c" <<'@//E*O*F mawk0.97/rexp/rexp1.c//'
  2185.  
  2186. /********************************************
  2187. rexp1.c
  2188. copyright 1991, Michael D. Brennan
  2189.  
  2190. This is a source file for mawk an implementation of
  2191. the Awk programming language as defined in
  2192. Aho, Kernighan and Weinberger, The AWK Programming Language,
  2193. Addison-Wesley, 1988.
  2194.  
  2195. See the accompaning file, LIMITATIONS, for restrictions
  2196. regarding modification and redistribution of this
  2197. program in source or binary form.
  2198. ********************************************/
  2199.  
  2200. /*  rexp1.c   */
  2201.  
  2202. /*  re machine  operations  */
  2203.  
  2204. #include  "rexp.h"
  2205.  
  2206. static MACHINE *PROTO( new_TWO , (int) ) ;
  2207.  
  2208.  
  2209. static  MACHINE  *new_TWO(type)
  2210.   int type ;
  2211. { 
  2212.   static  MACHINE  x ;
  2213.  
  2214.   x.start = (STATE *) RE_malloc(2*STATESZ) ;
  2215.   x.stop = x.start + 1 ;
  2216.   x.start->type = type ;
  2217.   x.stop->type = M_ACCEPT ;
  2218.   return &x ;
  2219. } ;
  2220.  
  2221.  
  2222. /*  build a machine that recognizes any  */
  2223. MACHINE  RE_any()
  2224. { return  * new_TWO(M_ANY) ; }
  2225.  
  2226. /*  build a machine that recognizes the start of string  */
  2227. MACHINE  RE_start()
  2228. { return  * new_TWO(M_START) ; }
  2229.  
  2230. MACHINE  RE_end()
  2231. { return  * new_TWO(M_END) ; }
  2232.  
  2233. /*  build a machine that recognizes a class  */
  2234. MACHINE  RE_class( bvp )
  2235.   BV *bvp  ;
  2236. { register MACHINE *p = new_TWO(M_CLASS) ;
  2237.  
  2238.   p->start->data.bvp = bvp ;
  2239.   return *p ;
  2240. }
  2241.  
  2242.  
  2243. MACHINE  RE_u()
  2244. { return  *new_TWO(M_U) ; }
  2245.  
  2246. MACHINE  RE_str( str, len)
  2247.   char *str ;
  2248.   unsigned len ;
  2249. { register MACHINE *p = new_TWO(M_STR) ;
  2250.  
  2251.   p->start->len = len ;
  2252.   p->start->data.str = str ;
  2253.   return *p ;
  2254. }
  2255.  
  2256. /*  replace m and n by a machine that recognizes  mn   */
  2257. void  RE_cat( mp, np)
  2258.   MACHINE  *mp, *np ;
  2259. { unsigned sz1, sz2, sz ;
  2260.  
  2261.   sz1 = mp->stop - mp->start  ;
  2262.   sz2 = np->stop - np->start + 1 ;
  2263.   sz  = sz1 + sz2 ;
  2264.  
  2265.   mp->start = (STATE *) RE_realloc( mp->start, sz * STATESZ ) ;
  2266.   mp->stop = mp->start + (sz - 1) ;
  2267.   (void)  memcpy( mp->start + sz1, np->start, sz2 * STATESZ ) ;
  2268.   RE_free( np->start ) ;
  2269. }
  2270.  
  2271.  /*  replace m by a machine that recognizes m|n  */
  2272.  
  2273. void  RE_or( mp, np)
  2274.   MACHINE  *mp, *np ;
  2275. { register STATE *p ;
  2276.   unsigned szm, szn ;
  2277.  
  2278.   szm = mp->stop - mp->start + 1 ;
  2279.   szn = np->stop - np->start + 1 ;
  2280.  
  2281.   p = (STATE *) RE_malloc( (szm+szn+1) * STATESZ ) ;
  2282.   (void) memcpy( p+1, mp->start, szm * STATESZ ) ;
  2283.   RE_free( mp->start) ;
  2284.   mp->start = p ;
  2285.   (mp->stop  = p + szm + szn) -> type = M_ACCEPT ;
  2286.   p->type = M_2JA ;
  2287.   p->data.jump = szm+1 ;
  2288.   (void) memcpy( p + szm + 1 , np->start, szn * STATESZ) ;
  2289.   RE_free( np->start ) ;
  2290.   (p += szm)->type = M_1J ;
  2291.   p->data.jump = szn ;
  2292. }
  2293.  
  2294. /*  UNARY  OPERATIONS     */
  2295.  
  2296. /*  replace m by m*   */
  2297.  
  2298. void  RE_close( mp )
  2299.   MACHINE  *mp ;
  2300. { register STATE *p ;
  2301.   unsigned sz ;
  2302.  
  2303.   sz = mp->stop - mp->start + 1 ;
  2304.   p = (STATE *) RE_malloc( (sz+2) * STATESZ ) ;
  2305.   (void) memcpy( p+1, mp->start, sz * STATESZ) ;
  2306.   RE_free( mp->start ) ;
  2307.   mp->start = p ;
  2308.   mp->stop  = p + (sz+1) ;
  2309.   p->type = M_2JA ;
  2310.   p->data.jump = sz + 1 ;
  2311.   (p += sz) -> type = M_2JB ;
  2312.   p->data.jump = -(sz-1) ;
  2313.   (p+1)->type = M_ACCEPT ;
  2314. }
  2315.  
  2316. /*  replace m  by  m+  (positive closure)   */
  2317.  
  2318. void  RE_poscl( mp )
  2319.   MACHINE  *mp ;
  2320. { register STATE *p ;
  2321.   unsigned  sz ;
  2322.  
  2323.   sz = mp->stop - mp->start + 1 ;
  2324.   mp->start = p = (STATE *) RE_realloc(mp->start ,  (sz+1) * STATESZ ) ;
  2325.   mp->stop  = p + sz ;
  2326.   p +=  --sz ;
  2327.   p->type = M_2JB ;
  2328.   p->data.jump = -sz ;
  2329.   (p+1)->type = M_ACCEPT ;
  2330. }
  2331.  
  2332. /* replace  m  by  m? (zero or one)  */
  2333.  
  2334. void  RE_01( mp )
  2335.   MACHINE  *mp ;
  2336. { unsigned  sz ;
  2337.   register  STATE *p ;
  2338.  
  2339.   sz = mp->stop - mp->start + 1 ;
  2340.   p = (STATE *) RE_malloc( (sz+1) * STATESZ ) ;
  2341.   (void) memcpy( p+1, mp->start, sz * STATESZ) ;
  2342.   RE_free( mp->start ) ;
  2343.   mp->start = p ;
  2344.   mp->stop = p + sz ;
  2345.   p->type = M_2JB ;
  2346.   p->data.jump = sz ;
  2347. }
  2348.  
  2349. /*===================================
  2350. MEMORY  ALLOCATION
  2351.  *==============================*/
  2352.  
  2353.  
  2354. VOID *RE_xmalloc( sz ) 
  2355.   unsigned sz ;
  2356. { register VOID *p ;
  2357.  
  2358.   if ( ! ( p = malloc(sz) ) )  RE_error_trap(MEMORY_FAILURE) ;
  2359.   return p ;
  2360. }
  2361.  
  2362. VOID *RE_xrealloc( p, sz)
  2363.   register VOID *p ; unsigned sz ;
  2364. { if ( ! ( p = realloc( p, sz) ) )  RE_error_trap(MEMORY_FAILURE) ;
  2365.   return p ;
  2366. }
  2367.  
  2368. @//E*O*F mawk0.97/rexp/rexp1.c//
  2369. chmod u=rw,g=r,o=r mawk0.97/rexp/rexp1.c
  2370.  
  2371. echo x - mawk0.97/rexp/rexp2.c
  2372. sed 's/^@//' > "mawk0.97/rexp/rexp2.c" <<'@//E*O*F mawk0.97/rexp/rexp2.c//'
  2373.  
  2374. /********************************************
  2375. rexp2.c
  2376. copyright 1991, Michael D. Brennan
  2377.  
  2378. This is a source file for mawk an implementation of
  2379. the Awk programming language as defined in
  2380. Aho, Kernighan and Weinberger, The AWK Programming Language,
  2381. Addison-Wesley, 1988.
  2382.  
  2383. See the accompaning file, LIMITATIONS, for restrictions
  2384. regarding modification and redistribution of this
  2385. program in source or binary form.
  2386. ********************************************/
  2387.  
  2388. /*  rexp2.c   */
  2389.  
  2390. /*  test a string against a machine   */
  2391.  
  2392. #include "rexp.h"
  2393. #include <string.h>
  2394.  
  2395. /* statics */
  2396. static RT_STATE *PROTO(slow_push,(RT_STATE *,STATE*,char*,int)); 
  2397.  
  2398. /*  check that a bit is on  */
  2399. #define  ison(b,x) ( (b)[(x)>>3] & ( 1 << ((x)&7)  ))
  2400.  
  2401.  
  2402. RT_STATE *RE_run_stack_base; 
  2403. RT_STATE *RE_run_stack_limit ;
  2404. /* for statistics and debug */
  2405. static RT_STATE *stack_max ; 
  2406.  
  2407. void RE_run_stack_init()
  2408. { if ( !RE_run_stack_base )
  2409.   {
  2410.     RE_run_stack_base = (RT_STATE *)
  2411.                  RE_malloc(sizeof(RT_STATE) * 16 ) ;
  2412.     RE_run_stack_limit = RE_run_stack_base + 16 ;
  2413.     stack_max = RE_run_stack_base-1 ;
  2414.   }
  2415. }
  2416.  
  2417. RT_STATE  *RE_new_run_stack()
  2418. { int oldsize = RE_run_stack_limit - RE_run_stack_base ;
  2419.  
  2420.   RE_run_stack_base = (RT_STATE *) RE_realloc( RE_run_stack_base ,
  2421.           (oldsize+8) * sizeof(RT_STATE) ) ;
  2422.   RE_run_stack_limit = RE_run_stack_base + oldsize + 8 ;
  2423.   return  stack_max = RE_run_stack_base + oldsize ;
  2424. }
  2425.  
  2426. static RT_STATE *slow_push(sp, m, s, u)
  2427.   RT_STATE *sp ;
  2428.   STATE *m ;
  2429.   char *s ;
  2430.   int   u ;
  2431. { 
  2432.   if ( sp > stack_max )
  2433.      if ( (stack_max = sp) == RE_run_stack_limit )
  2434.          sp = RE_new_run_stack() ;
  2435.  
  2436.   sp->m = m ; sp->s = s ; sp->u = u ;
  2437.   return sp ;
  2438. }
  2439.  
  2440. #ifdef   DEBUG
  2441. void  print_max_stack(f)
  2442.   FILE *f ;
  2443. { fprintf(f, "stack_max = %d\n", stack_max-RE_run_stack_base+1) ; }
  2444. #endif
  2445.  
  2446. #ifdef   DEBUG
  2447. #define  push(mx,sx,ux)   stackp = slow_push(++stackp, mx, sx, ux)
  2448. #else
  2449. #define  push(mx,sx,ux)   if (++stackp == RE_run_stack_limit)\
  2450.                                 stackp = slow_push(stackp,mx,sx,ux) ;\
  2451.