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