home *** CD-ROM | disk | FTP | other *** search
/ Garbo / Garbo.cdr / pc / source / mawk.lzh / mawk.3 < prev    next >
Encoding:
Text File  |  1991-05-19  |  60.5 KB  |  2,597 lines
  1.   register FCALL_REC *q = &dummy ; /* trails p */
  2.  
  3.   q->link = p ;
  4.   while ( p )
  5.   {
  6.     if ( ! p->callee->code )
  7.     { /* callee never defined */
  8.       errmsg(0, "line %u: function %s never defined" ,
  9.           p->line_no, p->callee->name) ;
  10.       if ( ++compile_error_count == MAX_COMPILE_ERRORS ) 
  11.               mawk_exit(1) ;
  12.       /* delete p from list */
  13.       q->link = p->link ;
  14.       /* don't worry about freeing memory, we'll exit soon */
  15.     }
  16.     else  /* note p->arg_list starts with last argument */
  17.     if ( ! p->arg_list  /* nothing to do */  ||
  18.          ! p->arg_cnt_checked && 
  19.          ! arg_cnt_ok(p->callee, p->arg_list, p->line_no) )
  20.     {  q->link = p->link ; /* delete p */ 
  21.        /* the ! arg_list case is not an error so free memory */
  22.        zfree(p, sizeof(FCALL_REC)) ;
  23.     }
  24.     else
  25.     { /* keep p and set call_start */
  26.       q = p ;
  27.       switch ( p->call_scope )
  28.       {
  29.         case SCOPE_MAIN  :
  30.                 p->call_start = main_start ;
  31.                 break ;
  32.  
  33.         case SCOPE_BEGIN :
  34.                 p->call_start = begin_start ;
  35.                 break ;
  36.  
  37.         case SCOPE_END :
  38.                 p->call_start = end_start ;
  39.                 break ;
  40.  
  41.         case SCOPE_FUNCT :
  42.                 p->call_start = p->call->code ;
  43.                 break ;
  44.       }
  45.     }
  46.     p = q->link ;
  47.   }
  48.   return  dummy.link ;
  49. }
  50.  
  51. /* continuously walk the resolve_list making type deductions
  52.    until this list goes empty or no more progress can be made
  53.    (An example where no more progress can be made is at end of file
  54. */
  55.  
  56. void  resolve_fcalls()
  57. { register FCALL_REC *p, *old_list , *new_list ;
  58.   int progress ; /* a flag */
  59.  
  60.   old_list = first_pass(resolve_list) ;
  61.   new_list = (FCALL_REC *) 0 ;
  62.   progress = 0 ;
  63.  
  64.   while ( 1 )
  65.   {
  66.     if ( !(p = old_list) )
  67.     { /* flop the lists */
  68.       if ( !(p = old_list = new_list)  /* nothing left */
  69.           || ! progress    /* can't do any more */ )  return ;
  70.  
  71.       /* reset after flop */
  72.       new_list = (FCALL_REC *) 0 ;  progress = 0 ;
  73.     }
  74.  
  75.     old_list = p->link ;
  76.  
  77.     if ( p->arg_list = call_arg_check(p->callee, p->arg_list ,
  78.               p->call_start, p->line_no)  )
  79.     {
  80.        /* still have work to do , put on new_list   */
  81.        progress  |= check_progress ;
  82.        p->link = new_list ;  new_list = p ;
  83.     }
  84.     else  /* done with p */
  85.     {  progress = 1 ;  zfree(p, sizeof(FCALL_REC)) ; }
  86.   }
  87. }
  88.  
  89. /* the parser has just reduced a function call ;
  90.    the info needed to type check is passed in.  If type checking
  91.    can not be done yet (most common reason -- function referenced
  92.    but not defined), a node is added to the resolve list.
  93. */
  94. void check_fcall( callee, call_scope, call, arg_list, line_no )
  95.   FBLOCK *callee ;
  96.   int call_scope ;
  97.   FBLOCK  *call ;
  98.   CA_REC  *arg_list ;
  99.   unsigned line_no ;
  100. {
  101.   FCALL_REC *p ;
  102.   INST *call_start ;
  103.  
  104.   if ( ! callee->code ) 
  105.   { /* forward reference to a function to be defined later */
  106.     p = (FCALL_REC *) zmalloc(sizeof(FCALL_REC)) ;
  107.     p->callee = callee ;
  108.     p->call_scope = call_scope ;
  109.     p->call = call ;
  110.     p->arg_list = arg_list ;
  111.     p->arg_cnt_checked = 0 ;
  112.     p->line_no = line_no ;
  113.     /* add to resolve list */
  114.     p->link = resolve_list ; resolve_list = p ;
  115.   }
  116.   else
  117.   if ( arg_list && arg_cnt_ok( callee, arg_list, line_no ) )
  118.   {
  119.       switch ( call_scope )
  120.       {
  121.         case SCOPE_MAIN  :
  122.                 call_start = main_start ;
  123.                 break ;
  124.  
  125.         case SCOPE_BEGIN :
  126.                 call_start = begin_start ;
  127.                 break ;
  128.  
  129.         case SCOPE_END :
  130.                 call_start = end_start ;
  131.                 break ;
  132.  
  133.         case SCOPE_FUNCT :
  134.                 call_start = call->code ;
  135.                 break ;
  136.       }
  137.  
  138.       /* usually arg_list disappears here and all is well
  139.          otherwise add to resolve list */
  140.  
  141.       if ( arg_list = call_arg_check(callee, arg_list,
  142.                 call_start, line_no) )
  143.       {
  144.             p = (FCALL_REC *) zmalloc(sizeof(FCALL_REC)) ;
  145.             p->callee = callee ;
  146.             p->call_scope = call_scope ;
  147.             p->call = call ;
  148.             p->arg_list = arg_list ;
  149.             p->arg_cnt_checked = 1 ;
  150.             p->line_no = line_no ;
  151.             /* add to resolve list */
  152.             p->link = resolve_list ; resolve_list = p ;
  153.       }
  154.   }
  155. }
  156.  
  157.  
  158.  
  159. /*  example where typing cannot progress
  160.  
  161. { f(z) }
  162.  
  163. function f(x) { print NR }
  164.  
  165. # this is legal, does something useful, but absurdly written
  166. # We have to design so this works
  167. */
  168.  
  169. @//E*O*F mawk0.97/fcall.c//
  170. chmod u=rw,g=r,o=r mawk0.97/fcall.c
  171.  
  172. echo x - mawk0.97/field.c
  173. sed 's/^@//' > "mawk0.97/field.c" <<'@//E*O*F mawk0.97/field.c//'
  174.  
  175. /********************************************
  176. field.c
  177. copyright 1991, Michael D. Brennan
  178.  
  179. This is a source file for mawk, an implementation of
  180. the Awk programming language as defined in
  181. Aho, Kernighan and Weinberger, The AWK Programming Language,
  182. Addison-Wesley, 1988.
  183.  
  184. See the accompaning file, LIMITATIONS, for restrictions
  185. regarding modification and redistribution of this
  186. program in source or binary form.
  187. ********************************************/
  188.  
  189. /* $Log:    field.c,v $
  190.  * Revision 2.2  91/04/09  12:39:00  brennan
  191.  * added static to funct decls to satisfy STARDENT compiler
  192.  * 
  193.  * Revision 2.1  91/04/08  08:23:01  brennan
  194.  * VERSION 0.97
  195.  * 
  196. */
  197.  
  198.  
  199. /* field.c */
  200.  
  201. #include "mawk.h"
  202. #include "field.h"
  203. #include "init.h"
  204. #include "memory.h"
  205. #include "scan.h"
  206. #include "bi_vars.h"
  207. #include "repl.h"
  208. #include "regexp.h"
  209.  
  210. CELL  field[NUM_FIELDS] ;
  211.  
  212. /* statics */
  213. static void PROTO( build_field0, (void) ) ;
  214. static void PROTO( xcast, (CELL *) ) ;
  215. static void PROTO( set_rs_shadow, (void) ) ;
  216.  
  217. /* the order is important here, must be the same as
  218.    postion after field[MAX_FIELD] */
  219.  
  220. static char *biv_field_names[] = {
  221. "NF" , "RS" , "FS", "OFMT" } ;
  222.  
  223. /* a description of how to split based on RS.
  224.    If RS is changed, so is rs_shadow */
  225. SEPARATOR rs_shadow = {SEP_CHAR, '\n'} ;
  226. /* a splitting CELL version of FS */
  227. CELL fs_shadow = {C_SPACE} ;
  228. int   nf ;  
  229.   /* nf holds the true value of NF.  If nf < 0 , then
  230.      NF has not been computed, i.e., $0 has not been split
  231.   */
  232.  
  233. static void set_rs_shadow()
  234. { CELL c ;
  235.   STRING  *sval ;
  236.   char *s ;
  237.   unsigned len ;
  238.  
  239.   if ( rs_shadow.type == SEP_STR )  free_STRING((STRING*) rs_shadow.ptr) ;
  240.  
  241.   cast_for_split( cellcpy(&c, field+RS) ) ;
  242.   switch( c.type )
  243.   {
  244.     case C_RE :
  245.         if ( s = is_string_split(c.ptr, &len) )
  246.             if ( len == 1 )
  247.             { rs_shadow.type = SEP_CHAR ;
  248.               rs_shadow.c = s[0] ;
  249.             }
  250.             else
  251.             { rs_shadow.type = SEP_STR ;
  252.               rs_shadow.ptr = (PTR) new_STRING(s) ;
  253.             }
  254.         else
  255.         { rs_shadow.type = SEP_RE ;
  256.           rs_shadow.ptr = c.ptr ;
  257.         }
  258.         break ;
  259.  
  260.     case C_SPACE :
  261.         rs_shadow.type = SEP_CHAR ;
  262.         rs_shadow.c = ' ' ;
  263.         break ;
  264.  
  265.     case C_SNULL : /* RS becomes one or more blank lines */
  266.         rs_shadow.type = SEP_RE ;
  267.         sval = new_STRING( "\n([ \t]*\n)+" ) ;
  268.         rs_shadow.ptr = re_compile(sval) ;
  269.         free_STRING(sval) ;
  270.         break ;
  271.  
  272.     default : bozo("bad cell in set_rs_shadow") ;
  273.   }
  274. }
  275.  
  276. void  field_init()
  277. { char **p = biv_field_names ;
  278.   SYMTAB *st_p ;
  279.   int i ;
  280.  
  281.   for(i = NF  ; i < NUM_FIELDS ; p++ , i++ )
  282.   {
  283.     st_p = insert( *p ) ;
  284.     st_p->type = ST_FIELD ;
  285.     st_p->stval.cp = &field[i] ;
  286.   }
  287.  
  288.   field[NF].type = C_DOUBLE ;
  289.   field[NF].dval = 0.0 ;
  290.   field[0].type = C_STRING ;
  291.   field[0].ptr = (PTR) & null_str ;
  292.   null_str.ref_cnt++ ;
  293.  
  294.   field[RS].type = C_STRING ;
  295.   field[RS].ptr =  (PTR) new_STRING( "\n" ) ;
  296.   /* rs_shadow already set */
  297.  
  298.   field[FS].type = C_STRING ;
  299.   field[FS].ptr = (PTR) new_STRING( " " ) ;
  300.   /* fs_shadow is already set */
  301.  
  302.   field[OFMT].type = C_STRING ;
  303.   field[OFMT].ptr = (PTR) new_STRING( "%.6g" ) ;
  304. }
  305.  
  306.  
  307.  
  308. void  set_field0( s, len)
  309.   char *s ;
  310.   unsigned len ;
  311. { 
  312.   cell_destroy( & field[0] ) ;
  313.   nf = -1 ;
  314.  
  315.   if ( len )
  316.   {
  317.     field[0].type = C_MBSTRN ;
  318.     field[0].ptr = (PTR) new_STRING( (char *) 0, len) ;
  319.     (void) memcpy( string(&field[0])->str, s, len ) ;
  320.   }
  321.   else
  322.   {
  323.     field[0].type = C_STRING ;
  324.     field[0].ptr = (PTR) &null_str ;
  325.     null_str.ref_cnt++ ;
  326.   }
  327. }
  328.  
  329.  
  330.  
  331. /* split field[0] into $1, $2 ... and set NF  */
  332.  
  333. void  split_field0()
  334. { register int i ;
  335.   CELL  c ;
  336.   int  cast_flag ; /* we had to cast field[0] */
  337.   char *s ;
  338.   unsigned len ;
  339.  
  340.   if ( fs_shadow.type == C_SNULL ) /* FS == "" */
  341.   { cell_destroy(field+1) ;
  342.     (void) cellcpy(field+1, field+0) ;
  343.     cell_destroy(field+NF) ;
  344.     field[NF].type = C_DOUBLE ; field[NF].dval = 1.0 ;
  345.     return ;
  346.   }
  347.  
  348.   if ( field[0].type < C_STRING )
  349.   { cast1_to_s(cellcpy(&c, field+0)) ;
  350.     s = string(&c)->str ;
  351.     len = string(&c)->len ;
  352.     cast_flag = 1 ;
  353.   }
  354.   else  
  355.   { s = string(field)->str ; 
  356.     len = string(field)->len ;
  357.     cast_flag = 0 ; 
  358.   }
  359.  
  360.   nf = len == 0 ? 0 :
  361.        fs_shadow.type == C_SPACE
  362.        ? space_split(s) : re_split(s, fs_shadow.ptr) ;
  363.  
  364.   cell_destroy(field+NF) ;
  365.   field[NF].type = C_DOUBLE ;
  366.   field[NF].dval = (double) nf ;
  367.  
  368.   for( i = 1 ; i <= nf ; i++ )
  369.   {
  370.     cell_destroy(field+i) ;
  371.     field[i].ptr = temp_buff.ptr_buff[i-1] ;
  372.     field[i].type = C_MBSTRN ;
  373.   }
  374.  
  375.   if ( cast_flag )  free_STRING( string(&c) ) ;
  376. }
  377.  
  378. /*
  379.   assign CELL *cp to field[i]
  380.   and take care of all side effects
  381. */
  382.  
  383. void  field_assign( i, cp)
  384.   register int i ;
  385.   CELL *cp ;
  386. { register int j ;
  387.   CELL c ;
  388.  
  389.   /* update fields not up to date */
  390.   if ( nf < 0 )  split_field0() ;
  391.  
  392.   switch( i )
  393.   {
  394.     case 0 :
  395.         cell_destroy(field) ;
  396.         nf = -1 ;
  397.         (void) cellcpy(field, cp) ;
  398.         break ; ;
  399.  
  400.     case  NF :
  401.         cell_destroy(field+NF) ;
  402.         (void) cellcpy(field+NF, cellcpy(&c,cp) ) ;
  403.         if ( c.type != C_DOUBLE )  cast1_to_d(&c) ;
  404.  
  405.         if ( (j = (int) c.dval) < 0 )
  406.             rt_error("negative value assigned to NF") ;
  407.         if ( j > MAX_FIELD )
  408.             rt_overflow("MAX_FIELD", MAX_FIELD) ;
  409.  
  410.         if ( j > nf )
  411.             for ( i = nf+1 ; i <= j ; i++ )
  412.             { cell_destroy(field+i) ;
  413.               field[i].type = C_STRING ;
  414.               field[i].ptr = (PTR) &null_str ;
  415.               null_str.ref_cnt++ ;
  416.             }
  417.  
  418.         nf = j ;
  419.         build_field0() ;
  420.         break ;
  421.  
  422.     case  RS :
  423.         cell_destroy(field+RS) ;
  424.         (void) cellcpy(field+RS, cp) ;
  425.         set_rs_shadow() ;
  426.         break ;
  427.  
  428.     case  FS :
  429.         cell_destroy(field+FS) ;
  430.         cast_for_split( cellcpy(&fs_shadow, cellcpy(field+FS, cp)) ) ;
  431.         break ;
  432.  
  433.     case OFMT : 
  434.         /* If the user does something stupid with OFMT, we could crash.
  435.            We'll make an attempt to protect ourselves here.  This is
  436.            why OFMT is made a field.
  437.  
  438.            The ptr of OFMT always has a valid STRING, even if assigned
  439.            a DOUBLE or NOINIT
  440.         */
  441.  
  442.         free_STRING( string(field+OFMT) ) ;
  443.         (void) cellcpy(field+OFMT, cp) ;
  444.         if ( field[OFMT].type < C_STRING ) /* !! */
  445.              field[OFMT].ptr = (PTR) new_STRING( "%.6g" ) ;
  446.         else
  447.         {
  448.           /* It's a string, but if it's really goofy it could still
  449.              damage us. Test it . */
  450.           temp_buff.string_buff[256] = 0 ;
  451.           (void) sprintf(temp_buff.string_buff, 
  452.              string(field+OFMT)->str, 3.1459) ;
  453.           if ( temp_buff.string_buff[256] )
  454.                 rt_error("OFMT assigned unusable value") ;
  455.         }
  456.         break ;
  457.            
  458.  
  459.     default:
  460.  
  461. #ifdef DEBUG 
  462.         if ( i < 0 )
  463.             bozo("negative field index in field_assign") ;
  464.         if ( i > MAX_FIELD )
  465.             bozo("large field index in field_assign") ;
  466. #endif
  467.  
  468.         cell_destroy(field+i) ;
  469.         (void) cellcpy(field+i, cp) ;
  470.         if ( i > nf )
  471.         { for ( j = nf+1 ; j < i ; j++ )
  472.           { cell_destroy(field+j) ;
  473.             field[j].type = C_STRING ;
  474.             field[j].ptr = (PTR) &null_str ;
  475.             null_str.ref_cnt++ ;
  476.           }
  477.           nf = i ;
  478.           cell_destroy(field+NF) ;
  479.           field[NF].type = C_DOUBLE ;
  480.           field[NF].dval = (double) i ;
  481.         }
  482.  
  483.         build_field0() ;
  484.  
  485.   }
  486. }
  487.  
  488.  
  489. /* get the string rep of a double without changing its
  490.    type */
  491.  
  492. static void  xcast( cp )
  493.   register CELL *cp ;
  494. {
  495.   switch ( cp->type )
  496.   {
  497.     case C_NOINIT :
  498.         cp->ptr = (PTR) &null_str ;
  499.         null_str.ref_cnt++ ;
  500.         break ;
  501.  
  502.     case C_DOUBLE :
  503.         (void) sprintf(temp_buff.string_buff, 
  504.           string(field+OFMT)->str, cp->dval) ;
  505.         cp->ptr = (PTR) new_STRING(temp_buff.string_buff) ;
  506.         break ;
  507.   }
  508. }
  509.  
  510.  
  511. /* construct field[0] from the other fields */
  512.  
  513. static void  build_field0()
  514. { 
  515.  
  516.  
  517. #ifdef DEBUG
  518.   if ( nf < 0 )  
  519.       bozo("nf <0 in build_field0") ;
  520. #endif
  521.  
  522.   cell_destroy( field+0 ) ;
  523.  
  524.   if ( nf == 0 )
  525.   { field[0].type = C_STRING ;
  526.     field[0].ptr = (PTR) &null_str ;
  527.     null_str.ref_cnt++ ;
  528.   }
  529.   else
  530.   if ( nf == 1 )  (void) cellcpy(field, field+1) ;
  531.  
  532.   else
  533.   { CELL  ofs ;
  534.     char *ofs_str ;
  535.     unsigned ofs_len , len0 = 0 ;
  536.     register int i ;
  537.     register char *p, *q ;
  538.  
  539.  
  540.     (void) cellcpy(& ofs , bi_vars + OFS) ;
  541.     if ( ofs.type < C_STRING )  cast1_to_s(&ofs) ;
  542.     ofs_str = string(&ofs)->str ;
  543.     ofs_len = string(&ofs)->len ;
  544.  
  545.  
  546.     for( i = 1 ; i <= nf ; i++ )
  547.     {
  548.       if ( field[i].type < C_STRING )  xcast(field+i) ;
  549.       len0 += string(field+i)->len + ofs_len ;
  550.     }
  551.     len0 -= ofs_len ;
  552.  
  553.     field[0].type = C_STRING ;
  554.     field[0].ptr = (PTR) new_STRING((char *) 0, len0) ;
  555.  
  556.     p = string(field)->str ;
  557.     for( i = 1 ; i < nf ; i++ )
  558.     {
  559.       (void) memcpy(p, string(field+i)->str, string(field+i)->len) ;
  560.       p += string(field+i)->len ;
  561.  
  562.       /* add the separator */
  563.       q = ofs_str ;
  564.       while ( *p++ = *q++ ) ;  p-- ;
  565.  
  566.       /* if not really string undo the xcast */
  567.       if ( field[i].type < C_STRING )
  568.               free_STRING( string(field+i) ) ;
  569.     }
  570.     /* do the last piece */
  571.     (void) memcpy(p, string(field+i)->str, string(field+i)->len) ;
  572.     if ( field[i].type < C_STRING )
  573.               free_STRING( string(field+i) ) ;
  574.     
  575.     free_STRING( string(&ofs) ) ;
  576.   } 
  577. }
  578. @//E*O*F mawk0.97/field.c//
  579. chmod u=rw,g=r,o=r mawk0.97/field.c
  580.  
  581. echo x - mawk0.97/field.h
  582. sed 's/^@//' > "mawk0.97/field.h" <<'@//E*O*F mawk0.97/field.h//'
  583.  
  584. /********************************************
  585. field.h
  586. copyright 1991, Michael D. Brennan
  587.  
  588. This is a source file for mawk, an implementation of
  589. the Awk programming language as defined in
  590. Aho, Kernighan and Weinberger, The AWK Programming Language,
  591. Addison-Wesley, 1988.
  592.  
  593. See the accompaning file, LIMITATIONS, for restrictions
  594. regarding modification and redistribution of this
  595. program in source or binary form.
  596. ********************************************/
  597.  
  598. /* $Log:    field.h,v $
  599.  * Revision 2.1  91/04/08  08:23:03  brennan
  600.  * VERSION 0.97
  601.  * 
  602. */
  603.  
  604. /* field.h */
  605.  
  606.  
  607. #ifndef  FIELD_H
  608. #define  FIELD_H   1
  609.  
  610. void  PROTO( set_field0, (char *, unsigned) ) ;
  611. void  PROTO( split_field0, (void) ) ;
  612. int   PROTO( is_strnum, (char *, unsigned, double *) ) ;
  613. void  PROTO( field_assign, (int, CELL *) ) ;
  614. char *PROTO( is_string_split, (PTR , unsigned *) ) ;
  615.  
  616. #define   NF            (MAX_FIELD+1)
  617. #define   RS            (MAX_FIELD+2)
  618. #define   FS            (MAX_FIELD+3)
  619. #define   OFMT          (MAX_FIELD+4)
  620. #define   NUM_FIELDS    (MAX_FIELD+5)
  621.  
  622.  
  623. extern  CELL  field[NUM_FIELDS] ;
  624.  
  625. extern  int  nf ; /* shadows NF */
  626.  
  627. /* a shadow type for RS and FS */
  628. #define  SEP_SPACE      0
  629. #define  SEP_CHAR       1
  630. #define  SEP_STR        2
  631. #define  SEP_RE         3
  632.  
  633. typedef  struct {
  634. char  type ;
  635. char  c ;
  636. PTR ptr ; /* STRING* or RE machine* */
  637. } SEPARATOR ;
  638.  
  639. extern   SEPARATOR  rs_shadow  ;
  640. extern   CELL  fs_shadow ;
  641.  
  642.  
  643.  
  644.  
  645.  
  646.  
  647. #endif   /* FIELD_H  */
  648. @//E*O*F mawk0.97/field.h//
  649. chmod u=rw,g=r,o=r mawk0.97/field.h
  650.  
  651. echo x - mawk0.97/files.c
  652. sed 's/^@//' > "mawk0.97/files.c" <<'@//E*O*F mawk0.97/files.c//'
  653.  
  654. /********************************************
  655. files.c
  656. copyright 1991, Michael D. Brennan
  657.  
  658. This is a source file for mawk, an implementation of
  659. the Awk programming language as defined in
  660. Aho, Kernighan and Weinberger, The AWK Programming Language,
  661. Addison-Wesley, 1988.
  662.  
  663. See the accompaning file, LIMITATIONS, for restrictions
  664. regarding modification and redistribution of this
  665. program in source or binary form.
  666. ********************************************/
  667.  
  668. /*$Log:    files.c,v $
  669.  * Revision 2.1  91/04/08  08:23:05  brennan
  670.  * VERSION 0.97
  671.  * 
  672. */
  673.  
  674. /* files.c */
  675.  
  676. #include "mawk.h"
  677. #include "files.h"
  678. #include "memory.h"
  679. #include <stdio.h>
  680. #include "fin.h"
  681.  
  682. #if  ! DOS
  683. #include <fcntl.h>
  684. #endif
  685.  
  686. /* We store dynamically created files on a linked linear
  687.    list with move to the front (big surprise)  */
  688.  
  689. typedef struct file {
  690. struct file *link ;
  691. STRING  *name ;
  692. short type ;
  693. #if   ! DOS
  694. int pid ;  /* we need to wait() when we close an out pipe */
  695. #endif
  696. PTR   ptr ;  /* FIN*   or  FILE*   */
  697. }  FILE_NODE ;
  698.  
  699. static FILE_NODE *file_list ;
  700.  
  701. PTR  file_find( sval, type )
  702.   STRING *sval ;
  703.   int type ;
  704. { register FILE_NODE *p = file_list ;
  705.   FILE_NODE *q = (FILE_NODE *) 0 ;
  706.   char *name = sval->str ;
  707.  
  708.   while (1)
  709.   {
  710.     if ( !p )   /* open a new one */
  711.     {
  712.       p = (FILE_NODE*) zmalloc(sizeof(FILE_NODE)) ;
  713.       switch( p->type = type )
  714.       {
  715.         case  F_TRUNC :
  716.             if ( !(p->ptr = (PTR) fopen(name, "w")) )
  717.                 goto out_failure ;
  718.             break ;
  719.  
  720.         case  F_APPEND :
  721.             if ( !(p->ptr = (PTR) fopen(name, "a")) )
  722.                 goto out_failure ;
  723.             break ;
  724.  
  725.         case  F_IN  :
  726.             if ( !(p->ptr = (PTR) FINopen(name, 0)) )
  727.             { zfree(p, sizeof(FILE_NODE)) ; return (PTR) 0 ; }
  728.             break ;
  729.  
  730.         case  PIPE_OUT :
  731.         case  PIPE_IN :
  732. #if   DOS
  733.             rt_error("pipes not supported under MsDOS") ;
  734. #else
  735.             if ( !(p->ptr = get_pipe(name, type, &p->pid)) )
  736.                 if ( type == PIPE_OUT ) goto out_failure ;
  737.                 else
  738.                 { zfree(p, sizeof(FILE_NODE) ) ;
  739.                   return (PTR) 0 ;
  740.                 }
  741. #endif
  742.             break ;
  743.  
  744. #ifdef  DEBUG
  745.         default :
  746.             bozo("bad file type") ;
  747. #endif
  748.       }
  749.       /* successful open */
  750.       p->name = sval ;
  751.       sval->ref_cnt++ ;
  752.       break ;
  753.     }
  754.  
  755.     if ( strcmp(name, p->name->str) == 0 )
  756.     { 
  757.       if ( p->type != type )  goto type_failure ;
  758.       if ( !q )  /*at front of list */
  759.           return  p->ptr ;
  760.       /* delete from list for move to front */
  761.       q->link = p->link ;
  762.       break ;
  763.     }
  764.     q = p ; p = p->link ;
  765.   }
  766.  
  767.   /* put p at the front of the list */
  768.   p->link = file_list ;
  769.   return  (PTR) (file_list = p)->ptr ;
  770.  
  771. out_failure:
  772.   errmsg(errno, "cannot open \"%s\" for output", name) ;
  773.   mawk_exit(1) ;
  774.  
  775. type_failure :
  776.   rt_error("use of file \"%s\"\n\tis inconsistent with previous use",
  777.            name) ;
  778. }
  779.  
  780.  
  781. /* close a file and delete it's node from the file_list */
  782.  
  783. int  file_close( sval )
  784.   STRING *sval ;
  785. { register FILE_NODE *p = file_list ;
  786.   FILE_NODE *q = (FILE_NODE *) 0 ; /* trails p */
  787.   char *name = sval->str ;
  788.  
  789.   while ( p )
  790.         if ( strcmp(name,p->name->str) == 0 ) /* found */
  791.         { 
  792.           switch( p->type )
  793.           {
  794.             case  F_TRUNC :
  795.             case  F_APPEND :    
  796.                 (void) fclose((FILE *) p->ptr) ;
  797.                 break ;
  798.  
  799.             case  PIPE_OUT :
  800.                 (void) fclose((FILE *) p->ptr) ;
  801. #if  ! DOS
  802.                 (void) wait_for(p->pid) ;
  803. #endif
  804.                 break ;
  805.  
  806.             case F_IN  :
  807.             case PIPE_IN :
  808.                 FINclose((FIN *) p->ptr) ;
  809.                 break ;
  810.           }
  811.  
  812.           free_STRING(p->name) ;
  813.           if ( q )  q->link = p->link ;
  814.           else  file_list = p->link ;
  815.  
  816.           zfree(p, sizeof(FILE_NODE)) ;
  817.           return 0 ;
  818.         }
  819.         else { q = p ; p = p->link ; }
  820.  
  821.   /* its not on the list */
  822.   return -1 ;
  823. }
  824.  
  825. /* When we exit, we need to close and wait for all output pipes */
  826.  
  827. #if   !DOS
  828. void close_out_pipes()
  829. { register FILE_NODE *p = file_list ;
  830.  
  831.   while ( p )
  832.   { if ( p->type == PIPE_OUT )
  833.     { (void) fclose((FILE *) p->ptr) ;  (void) wait_for(p->pid) ; }
  834.     p = p->link ;
  835.   }
  836. }
  837. #endif
  838.  
  839.  
  840. char *shell ;
  841.  
  842. #if  !  DOS
  843. PTR get_pipe( name, type, pid_ptr)
  844.   char *name ;
  845.   int type ;
  846.   int *pid_ptr ;
  847. { int the_pipe[2], local_fd, remote_fd ;
  848.  
  849.   if ( ! shell ) shell = (shell = getenv("SHELL")) ? shell :"/bin/sh" ;
  850.   
  851.   if ( pipe(the_pipe) == -1 )  return (PTR) 0 ;
  852.   local_fd = the_pipe[type == PIPE_OUT] ;
  853.   remote_fd = the_pipe[type == PIPE_IN ] ;
  854.  
  855.   switch( *pid_ptr = fork() )
  856.   { case -1 :  
  857.       (void) close(local_fd) ;
  858.       (void) close(remote_fd) ;
  859.       return (PTR) 0 ;
  860.  
  861.     case  0 :
  862.         (void) close(local_fd) ;
  863.         (void) close(type == PIPE_IN) ;
  864.         (void) dup( remote_fd ) ;
  865.         (void) close( remote_fd ) ;
  866.         (void) execl(shell, shell, "-c", name, (char *) 0 ) ;
  867.         errmsg(errno, "failed to exec %s -c %s" , shell, name) ;
  868.     fflush(stderr) ;
  869.         _exit(128) ;
  870.  
  871.     default :
  872.         (void) close(remote_fd) ;
  873.         /* we could deadlock if future child inherit the local fd ,
  874.            set close on exec flag */
  875.         (void) fcntl(local_fd, F_SETFD, 1) ;
  876.         break ;
  877.   }
  878.  
  879.   return  type == PIPE_IN ? (PTR) FINdopen(local_fd, 0) : 
  880.                             (PTR)  fdopen(local_fd, "w")  ;
  881. }
  882.   
  883.  
  884.  
  885. /*------------ children ------------------*/
  886.  
  887. /* we need to wait for children at the end of output pipes to
  888.    complete so we know any files they have created are complete */
  889.  
  890. /* dead children are kept on this list */
  891.  
  892. static struct child {
  893. int pid ;
  894. int exit_status ;
  895. struct child *link ;
  896. }  *child_list ;
  897.  
  898. static  void  add_to_child_list(pid, exit_status)
  899.   int pid, exit_status ;
  900. { register struct child *p = 
  901.           (struct child *) zmalloc(sizeof(struct child)) ;
  902.  
  903.   p->pid = pid ; p->exit_status = exit_status ;
  904.   p->link = child_list ; child_list = p ;
  905. }
  906.  
  907. static struct child *remove_from_child_list(pid)
  908.   int pid ;
  909. { register struct child *p = child_list ;
  910.   struct child *q = (struct child *) 0 ;
  911.  
  912.   while ( p )
  913.     if ( p->pid == pid )
  914.     {
  915.         if ( q ) q->link = p->link ;
  916.         else child_list = p->link ;
  917.         break ;
  918.     }
  919.     else { q = p ; p = p->link ; }
  920.  
  921.   return p ;  /* null return if not in the list */
  922. }
  923.     
  924.  
  925. /* wait for a specific child to complete and return its 
  926.    exit status */
  927.  
  928. int wait_for(pid)
  929.   int pid ;
  930. { int exit_status ;
  931.   struct child *p ;
  932.   int id ;
  933.  
  934.   /* see if an earlier wait() caught our child */
  935.   if ( p = remove_from_child_list(pid) ) 
  936.   { exit_status = p->exit_status ;
  937.     zfree(p, sizeof(struct child)) ;
  938.   }
  939.   else /* need to really wait */
  940.     while ( (id = wait(&exit_status)) != pid )
  941.         if ( id == -1 ) /* can't happen */  bozo("wait_for") ;
  942.         else
  943.         { /* we got the exit status of another child
  944.              put it on the child list and try again */
  945.           add_to_child_list(id, exit_status ) ;
  946.         }
  947.  
  948.   return exit_status ;
  949. }
  950.         
  951. #endif
  952. @//E*O*F mawk0.97/files.c//
  953. chmod u=rw,g=r,o=r mawk0.97/files.c
  954.  
  955. echo x - mawk0.97/files.h
  956. sed 's/^@//' > "mawk0.97/files.h" <<'@//E*O*F mawk0.97/files.h//'
  957.  
  958. /********************************************
  959. files.h
  960. copyright 1991, Michael D. Brennan
  961.  
  962. This is a source file for mawk, an implementation of
  963. the Awk programming language as defined in
  964. Aho, Kernighan and Weinberger, The AWK Programming Language,
  965. Addison-Wesley, 1988.
  966.  
  967. See the accompaning file, LIMITATIONS, for restrictions
  968. regarding modification and redistribution of this
  969. program in source or binary form.
  970. ********************************************/
  971.  
  972. /*$Log:    files.h,v $
  973.  * Revision 2.1  91/04/08  08:23:07  brennan
  974.  * VERSION 0.97
  975.  * 
  976. */
  977.  
  978. #ifndef   FILES_H
  979. #define   FILES_H
  980.  
  981. /* IO redirection types */
  982. #define  F_IN           (-5)
  983. #define  PIPE_IN        (-4)
  984. #define  PIPE_OUT       (-3)
  985. #define  F_APPEND       (-2)
  986. #define  F_TRUNC        (-1)
  987.  
  988. extern char *shell ; /* for pipes and system() */
  989.  
  990. PTR  PROTO(file_find, (STRING *, int)) ;
  991. int  PROTO(file_close, (STRING *)) ;
  992. PTR  PROTO(get_pipe, (char *, int) ) ;
  993. int  PROTO(wait_for, (int) ) ;
  994. void  PROTO( close_out_pipes, (void) ) ;
  995.  
  996.  
  997. #endif
  998. @//E*O*F mawk0.97/files.h//
  999. chmod u=rw,g=r,o=r mawk0.97/files.h
  1000.  
  1001. echo x - mawk0.97/fin.c
  1002. sed 's/^@//' > "mawk0.97/fin.c" <<'@//E*O*F mawk0.97/fin.c//'
  1003.  
  1004. /********************************************
  1005. fin.c
  1006. copyright 1991, Michael D. Brennan
  1007.  
  1008. This is a source file for mawk, an implementation of
  1009. the Awk programming language as defined in
  1010. Aho, Kernighan and Weinberger, The AWK Programming Language,
  1011. Addison-Wesley, 1988.
  1012.  
  1013. See the accompaning file, LIMITATIONS, for restrictions
  1014. regarding modification and redistribution of this
  1015. program in source or binary form.
  1016. ********************************************/
  1017.  
  1018. /*$Log:    fin.c,v $
  1019.  * Revision 2.1  91/04/08  08:23:09  brennan
  1020.  * VERSION 0.97
  1021.  * 
  1022. */
  1023.  
  1024. /* fin.c */
  1025.  
  1026. #include "mawk.h"
  1027. #include "fin.h"
  1028. #include "memory.h"
  1029. #include "bi_vars.h"
  1030. #include "field.h"
  1031. #include "symtype.h"
  1032. #include "scan.h"
  1033. #include <fcntl.h>
  1034.  
  1035. extern int errno ;
  1036. int PROTO(isatty, (int) ) ;
  1037. FILE *PROTO(fdopen, (int, char*) ) ;
  1038.  
  1039. /* statics */
  1040. int  PROTO( next_main, (void) ) ;
  1041. int  PROTO( is_cmdline_assign, (char *) ) ;
  1042.  
  1043. FIN  *FINdopen( fd, main_flag )
  1044.   int fd , main_flag ;
  1045. { register FIN *fin = (FIN *) zmalloc( sizeof(FIN) ) ;
  1046.  
  1047.   fin->fd = fd ;
  1048.  
  1049.   if ( main_flag )
  1050.   { fin->flags = MAIN_FLAG ;
  1051.     fin->buffp = fin->buff = main_buff ;
  1052.   }
  1053.   else
  1054.   { 
  1055.     fin->flags = 0 ;
  1056.     fin->buffp = fin->buff = (char *) zmalloc(BUFFSZ+1) ;
  1057.   }
  1058.   *fin->buffp = 0 ;
  1059.  
  1060.   if ( isatty(fd) && rs_shadow.type == SEP_CHAR 
  1061.        && rs_shadow.c == '\n' )
  1062.   {
  1063.     /* interactive, i.e., line buffer this file */
  1064.     if ( fd == 0 ) fin->fp = stdin ;
  1065.     else
  1066.     if ( !(fin->fp = fdopen(fd, "r")) )
  1067.     { errmsg(errno, "fdopen failed") ; exit(1) ; }
  1068.   }
  1069.   else  fin->fp = (FILE *) 0 ;
  1070.  
  1071.   return fin ;
  1072. }
  1073.  
  1074. FIN  *FINopen( filename, main_flag )
  1075.   char *filename ;
  1076.   int main_flag ;
  1077. { int fd ;
  1078.  
  1079.   if ( (fd = open( filename , O_RDONLY, 0 )) == -1 )
  1080.   { errmsg( errno, "cannot open %s" , filename ) ;
  1081.     return (FIN *) 0 ; }
  1082.  
  1083.   else  return  FINdopen( fd, main_flag ) ;
  1084. }
  1085.  
  1086. void  FINclose( fin )
  1087.   register FIN *fin ;
  1088. {
  1089.   if ( ! (fin->flags & MAIN_FLAG) )  
  1090.         zfree(fin->buff, BUFFSZ+1) ;
  1091.  
  1092.   if ( fin->fd )  
  1093.         if ( fin->fp )  (void) fclose(fin->fp) ;
  1094.         else  (void) close(fin->fd) ;
  1095.  
  1096.   zfree( fin , sizeof(FIN) ) ;
  1097. }
  1098.  
  1099. /* return one input record as determined by RS,
  1100.    from input file (FIN)  fin
  1101. */
  1102.  
  1103. char *FINgets( fin, len_p )
  1104.   FIN *fin ;
  1105.   unsigned *len_p ;
  1106. { register char *p, *q ;
  1107.   unsigned match_len ;
  1108.   unsigned r ;
  1109.  
  1110. restart :
  1111.  
  1112.   if ( ! (p = fin->buffp)[0] )  /* need a refill */
  1113.   { 
  1114.     if ( fin->flags & EOF_FLAG )
  1115.         if ( (fin->flags & MAIN_FLAG) && next_main() )  goto restart ;
  1116.         else
  1117.         { *len_p = 0 ; return (char *) 0 ; }
  1118.         
  1119.     if ( fin->fp ) /* line buffering */
  1120.       if ( ! fgets(fin->buff, BUFFSZ+1, fin->fp) )
  1121.       {
  1122.         fin->flags |= EOF_FLAG ;
  1123.         fin->buff[0] = 0 ;
  1124.         fin->buffp = fin->buff ;
  1125.         goto restart ;  /* might be main_fin */
  1126.       }
  1127.       else  /* return this line */
  1128.       {
  1129.         if ( !(p = strchr(fin->buff, '\n')) )
  1130.              p = fin->buff + BUFFSZ + 1 ; /* unlikely to occur */
  1131.  
  1132.         *p = 0 ; *len_p = p - fin->buff ;
  1133.         fin->buffp = p ;
  1134.         return  fin->buff ;
  1135.       }
  1136.     else  /* block buffering */
  1137.     {
  1138.       if ( (r = fillbuff(fin->fd, fin->buff, BUFFSZ)) == 0 )
  1139.       {
  1140.         fin->flags |= EOF_FLAG ;
  1141.         fin->buffp = fin->buff ;
  1142.         goto restart ; /* might be main */
  1143.       }
  1144.       else
  1145.       if ( r < BUFFSZ )  fin->flags |= EOF_FLAG ;
  1146.  
  1147.       p = fin->buffp = fin->buff ;
  1148.     }
  1149.   }
  1150.  
  1151. retry: 
  1152.  
  1153.   switch( rs_shadow.type )
  1154.   {
  1155.     case SEP_CHAR :
  1156.             q = strchr(p, rs_shadow.c) ;
  1157.             match_len = 1 ;
  1158.             break ;
  1159.  
  1160.     case SEP_STR  :
  1161.             q = str_str(p, ((STRING *) rs_shadow.ptr)->str,
  1162.                 match_len = ((STRING *) rs_shadow.ptr)->len ) ;
  1163.             break ;
  1164.  
  1165.     case SEP_RE :
  1166.             q = re_pos_match(p, rs_shadow.ptr, &match_len) ;
  1167.             /* if the match is at the end, there might be more
  1168.                still to be read */
  1169.             if ( q && q[match_len] == 0 &&
  1170.                  p != fin->buff )  q = (char *) 0 ;
  1171.             break ;
  1172.             
  1173.     default :
  1174.             bozo("type of rs_shadow") ;
  1175.   }
  1176.   if ( q )
  1177.   {  /* the easy and normal case */
  1178.      *q = 0 ;  *len_p = q - p ;
  1179.      fin->buffp = q + match_len  ;
  1180.      return p ;
  1181.   }
  1182.  
  1183.   if ( p == fin->buff )  /* last line or one huge (truncated) line */
  1184.   { *len_p = r = strlen(p) ;  fin->buffp = p + r ;
  1185.     /* treat truncated case as overflow */
  1186.     if ( r == BUFFSZ ) 
  1187.     { /* overflow, update NR and FNR */
  1188.       cast2_to_d(bi_vars+NR) ;
  1189.       bi_vars[NR].dval += 1.0 ;
  1190.       bi_vars[FNR].dval += 1.0 ;
  1191.       rt_overflow("maximum record length" , BUFFSZ) ;
  1192.     }
  1193.      return p ;
  1194.   }
  1195.  
  1196.   /* move a partial line to front of buffer and try again */
  1197.   p = (char *) memcpy( fin->buff, p, r = strlen(p) ) ;
  1198.   q = p+r ; 
  1199.   if ( fin->flags & EOF_FLAG ) *q = 0 ;
  1200.   else 
  1201.   { unsigned rr = BUFFSZ - r ;
  1202.  
  1203.     if ( (r = fillbuff(fin->fd, q, rr)) < rr ) fin->flags |= EOF_FLAG ;
  1204.   }
  1205.   goto retry ;
  1206. }
  1207.  
  1208. /*--------
  1209.   target is big enough to hold size + 1 chars 
  1210.   on exit the back of the target is zero terminated
  1211.  *--------------*/
  1212. unsigned  fillbuff(fd, target, size)
  1213.   int fd ;
  1214.   register char *target ;
  1215.   unsigned size ;
  1216. { register int r ;
  1217.   unsigned entry_size = size ;
  1218.  
  1219.   while ( size )
  1220.     switch( r = read(fd, target, size) )
  1221.     { case -1 :
  1222.         errmsg(errno, "read error on file") ;
  1223.         exit(1) ;
  1224.  
  1225.       case 0 :
  1226.         goto out ;
  1227.  
  1228.       default :
  1229.         target += r ; size -= r ;
  1230.         break ;
  1231.     }
  1232.  
  1233. out :
  1234.   *target = 0 ;
  1235.   return  entry_size - size ;
  1236. }
  1237.  
  1238. /* main_fin is a handle to the main input stream
  1239.    == -1 if never tried to open 
  1240.    == 0  if end of stream
  1241.       otherwise active    */
  1242. FIN *main_fin = (FIN *) -1 ;
  1243. ARRAY   Argv ;   /* to the user this is ARGV  */
  1244. static int argi = 1 ;  /* index of next ARGV[argi] to try to open */
  1245.  
  1246. int  open_main()  /* boolean return, true if main is open */
  1247. { 
  1248.   if ( bi_vars[ARGC].type == C_DOUBLE && bi_vars[ARGC].dval == 1.0 )
  1249.   { cell_destroy( bi_vars + FILENAME ) ;
  1250.     bi_vars[FILENAME].type = C_STRING ;
  1251.     bi_vars[FILENAME].ptr = (PTR) new_STRING( "-") ;
  1252.     main_fin = FINdopen(0, 1) ;
  1253.     return  1 ;
  1254.   }
  1255.   else    return next_main() ;
  1256. }
  1257.  
  1258. static  int  next_main()
  1259. { char xbuff[16] ;
  1260.   register CELL *cp ;
  1261.   STRING *sval ;
  1262.   CELL   argc ;  /* temp copy of ARGC */
  1263.   CELL   tc ;    /* copy of ARGV[argi] */
  1264.   double d_argi ;
  1265.  
  1266. #ifdef  DEBUG
  1267.   if ( ! main_fin ) bozo("call to next_main with dead main") ;
  1268. #endif
  1269.  
  1270.   tc.type = C_NOINIT ;
  1271.  
  1272.   if ( main_fin != (FIN *)-1 )  FINclose(main_fin) ;
  1273.   cell_destroy( bi_vars + FILENAME ) ;
  1274.   cell_destroy( bi_vars + FNR ) ;
  1275.   bi_vars[FNR].type = C_DOUBLE ;
  1276.   bi_vars[FNR].dval = 0.0 ;
  1277.  
  1278.   if ( cellcpy(&argc, &bi_vars[ARGC])->type != C_DOUBLE )
  1279.           cast1_to_d(&argc) ;
  1280.   xbuff[1] = 0 ;
  1281.   d_argi = (double) argi ;
  1282.  
  1283.   while ( d_argi < argc.dval )
  1284.   {
  1285.     if ( argi < 10 )  xbuff[0] = argi + '0' ;
  1286.     else  (void) sprintf(xbuff, "%u", argi) ;
  1287.  
  1288.     argi++ ; d_argi += 1.0 ;
  1289.     sval = new_STRING(xbuff) ;
  1290.  
  1291.     /* the user might have changed ARGC or deleted 
  1292.        ARGV[argi] -- test for existence without side effects */
  1293.     
  1294.     if ( ! array_test(Argv, sval) )
  1295.     { free_STRING(sval) ; continue ; }
  1296.  
  1297.     cp = array_find( Argv, sval, 0) ;
  1298.     free_STRING(sval) ;
  1299.  
  1300.     /* make a copy so we can cast w/o side effect */
  1301.     cell_destroy(&tc) ;
  1302.     cp = cellcpy(&tc, cp) ;
  1303.     if ( cp->type < C_STRING )  cast1_to_s(cp) ;
  1304.     if ( string(cp)->len == 0 )  continue ;
  1305.  
  1306.     if ( string(cp)->len == 1 && string(cp)->str[0] == '-' )
  1307.     { /* input from stdin */
  1308.       main_fin = FINdopen(0,1) ;
  1309.     }
  1310.     else  /* it might be a command line assignment */
  1311.     if ( is_cmdline_assign(string(cp)->str) )  continue ;
  1312.  
  1313.     else /* try to open it */
  1314.     if ( ! (main_fin = FINopen( string(cp)->str, 1 )) ) continue ;
  1315.  
  1316.     /* success */
  1317.     (void) cellcpy( &bi_vars[FILENAME] , cp ) ;
  1318.     free_STRING( string(cp) ) ;
  1319.     return 1 ;
  1320.   }
  1321.   /* failure */
  1322.   bi_vars[FILENAME].type = C_STRING ;
  1323.   bi_vars[FILENAME].ptr = (PTR) new_STRING( "" ) ;
  1324.   main_fin = (FIN *) 0 ;
  1325.   cell_destroy(&tc) ;
  1326.   return 0 ;
  1327. }
  1328.     
  1329.  
  1330. static int is_cmdline_assign(s)
  1331.   char *s ;
  1332. { char *q;
  1333.   unsigned char *p ;
  1334.   int c ;
  1335.   SYMTAB *stp ;
  1336.   CELL *cp ;
  1337.  
  1338.   if ( scan_code[*(unsigned char *)s] != SC_IDCHAR 
  1339.        || !(q = strchr(s,'=')) ) return 0 ;
  1340.  
  1341.   p = (unsigned char *)s+1 ;
  1342.   while ( (c = scan_code[*p]) == SC_IDCHAR || c == SC_DIGIT ) p++ ;
  1343.  
  1344.   if ( (char *)p < q )  return 0 ;
  1345.  
  1346.   *q = 0 ;
  1347.   stp = find(s) ;
  1348.  
  1349.   switch( stp->type )
  1350.   {
  1351.     case  ST_NONE :
  1352.         stp->type = ST_VAR ;
  1353.         stp->stval.cp = cp = new_CELL() ;
  1354.         break ;
  1355.  
  1356.     case  ST_VAR :
  1357.         cp = stp->stval.cp ;
  1358.         break ;
  1359.  
  1360.     default :
  1361.         rt_error(
  1362.           "cannot command line assign to %s\n\t- type clash or keyword" 
  1363.           , s ) ;
  1364.   }
  1365.   
  1366.   *q++ = '=' ;
  1367.   cp->ptr = (PTR) new_STRING(q) ;
  1368.   check_strnum(cp) ;
  1369.   return 1 ;
  1370. }
  1371. @//E*O*F mawk0.97/fin.c//
  1372. chmod u=rw,g=r,o=r mawk0.97/fin.c
  1373.  
  1374. echo x - mawk0.97/fin.h
  1375. sed 's/^@//' > "mawk0.97/fin.h" <<'@//E*O*F mawk0.97/fin.h//'
  1376.  
  1377. /********************************************
  1378. fin.h
  1379. copyright 1991, Michael D. Brennan
  1380.  
  1381. This is a source file for mawk, an implementation of
  1382. the Awk programming language as defined in
  1383. Aho, Kernighan and Weinberger, The AWK Programming Language,
  1384. Addison-Wesley, 1988.
  1385.  
  1386. See the accompaning file, LIMITATIONS, for restrictions
  1387. regarding modification and redistribution of this
  1388. program in source or binary form.
  1389. ********************************************/
  1390.  
  1391. /*$Log:    fin.h,v $
  1392.  * Revision 2.1  91/04/08  08:23:11  brennan
  1393.  * VERSION 0.97
  1394.  * 
  1395. */
  1396.  
  1397. /* fin.h */
  1398.  
  1399. #ifndef  FIN_H
  1400. #define  FIN_H
  1401. /* structure to control input files */
  1402.  
  1403. typedef struct {
  1404. int  fd ;
  1405. FILE *fp ;   /* NULL unless interactive */
  1406. char *buff ;
  1407. char *buffp ;
  1408. short flags ;
  1409. }  FIN ;
  1410.  
  1411. #define  MAIN_FLAG    1   /* part of main input stream if on */
  1412. #define  EOF_FLAG     2
  1413.  
  1414. FIN *  PROTO (FINdopen, (int, int) );
  1415. FIN *  PROTO (FINopen, (char *, int) );
  1416. void   PROTO (FINclose, (FIN *) ) ;
  1417. char*  PROTO (FINgets, (FIN *, unsigned *) ) ;
  1418. unsigned PROTO ( fillbuff, (int, char *, unsigned) ) ;
  1419.  
  1420.  
  1421. extern  FIN  *main_fin ;  /* for the main input stream */
  1422. int   PROTO( open_main, (void) ) ;
  1423. #endif  /* FIN_H */
  1424. @//E*O*F mawk0.97/fin.h//
  1425. chmod u=rw,g=r,o=r mawk0.97/fin.h
  1426.  
  1427. echo x - mawk0.97/hash.c
  1428. sed 's/^@//' > "mawk0.97/hash.c" <<'@//E*O*F mawk0.97/hash.c//'
  1429.  
  1430. /********************************************
  1431. hash.c
  1432. copyright 1991, Michael D. Brennan
  1433.  
  1434. This is a source file for mawk, an implementation of
  1435. the Awk programming language as defined in
  1436. Aho, Kernighan and Weinberger, The AWK Programming Language,
  1437. Addison-Wesley, 1988.
  1438.  
  1439. See the accompaning file, LIMITATIONS, for restrictions
  1440. regarding modification and redistribution of this
  1441. program in source or binary form.
  1442. ********************************************/
  1443.  
  1444.  
  1445. /* $Log:    hash.c,v $
  1446.  * Revision 2.1  91/04/08  08:23:13  brennan
  1447.  * VERSION 0.97
  1448.  * 
  1449. */
  1450.  
  1451.  
  1452. /* hash.c */
  1453.  
  1454. #include "mawk.h"
  1455. #include "memory.h"
  1456. #include "symtype.h"
  1457. #include <string.h>
  1458.  
  1459.  
  1460. unsigned hash(s)
  1461.   register char *s ;
  1462. { register unsigned h = 0 ;
  1463.  
  1464.   while ( *s )  h += h + *s++ ;
  1465.   return  h  ;
  1466. }
  1467.  
  1468. typedef struct hash {
  1469. struct hash *link ;
  1470. SYMTAB  symtab ;
  1471. }  HASHNODE ;
  1472.  
  1473. static  HASHNODE *PROTO( delete, (char *) ) ;
  1474.  
  1475. #define  new_HASHNODE() (HASHNODE *) zmalloc(sizeof(HASHNODE))
  1476.  
  1477. static HASHNODE *hash_table[HASH_PRIME] ;
  1478.  
  1479. /*
  1480.  *   insert -- s is not there and need not be duplicated
  1481.  *   -- used during initialization
  1482.  */
  1483.  
  1484. SYMTAB *insert(s) 
  1485.   char *s ;
  1486. { register HASHNODE *p = new_HASHNODE();
  1487.   register unsigned h ;
  1488.   
  1489.   p->link = hash_table[h = hash(s) % HASH_PRIME ] ;
  1490.   p->symtab.name = s ;
  1491.   hash_table[h] = p ;
  1492.   return &p->symtab ;
  1493. }
  1494.  
  1495. /*
  1496.  *  find --  s might be there, find it else insert and dup
  1497.  *  s 
  1498.  */
  1499.  
  1500. SYMTAB *find(s)
  1501.   char *s ;
  1502. { register HASHNODE *p ;
  1503.   HASHNODE *q ;
  1504.   unsigned h ;
  1505.  
  1506.   p = hash_table[h = hash(s) % HASH_PRIME ] ;
  1507.   q = (HASHNODE *) 0 ;
  1508.   while ( 1 )
  1509.   { if ( !p )
  1510.     { p = new_HASHNODE() ;
  1511.       p->symtab.type = ST_NONE ;
  1512.       p->symtab.name = strcpy(zmalloc( strlen(s)+1 ), s) ;
  1513.       break ;
  1514.     }
  1515.  
  1516.     if ( strcmp(p->symtab.name, s) == 0 ) /* found */
  1517.       if ( !q )  /* already at the front */
  1518.         return  &p->symtab ;
  1519.       else /* delete from the list */
  1520.       { q->link = p->link ;  break ; }
  1521.  
  1522.     q = p ; p = p->link ;
  1523.   }
  1524.   /* put p on front of the list */
  1525.   p->link = hash_table[h] ;
  1526.   hash_table[h] = p ;
  1527.   return & p->symtab ;
  1528. }
  1529.  
  1530.  
  1531. /* remove a node from the hash table
  1532.    return a ptr to the node */
  1533.  
  1534. static unsigned last_hash ;
  1535.  
  1536. static  HASHNODE  *delete( s )
  1537.   char *s ;
  1538. { register HASHNODE *p ;
  1539.   HASHNODE *q = (HASHNODE *) 0 ;
  1540.   unsigned h ;
  1541.  
  1542.   p = hash_table[ last_hash = h = hash(s) % HASH_PRIME ] ;
  1543.   while ( p )
  1544.       if ( strcmp(p->symtab.name, s) == 0 )  /* found */
  1545.       {
  1546.         if ( q )  q->link = p->link ;
  1547.         else  hash_table[h] = p->link ;
  1548.         return p ;
  1549.       }
  1550.       else { q = p ; p = p->link ; }
  1551.  
  1552. #ifdef  DEBUG   /* we should not ever get here */
  1553.   bozo("delete") ;
  1554. #endif
  1555.   return (HASHNODE *) 0 ;
  1556. }
  1557.  
  1558. /* when processing user functions,  global ids which are
  1559.    replaced by local ids are saved on this list */
  1560.  
  1561. static HASHNODE  *save_list ;
  1562.  
  1563. /* store a global id on the save list,
  1564.    return a ptr to the local symtab  */
  1565. SYMTAB *save_id( s )
  1566.   char *s ;
  1567. { HASHNODE *p, *q ;
  1568.   unsigned h ;
  1569.  
  1570.   p = delete(s) ;
  1571.   q = new_HASHNODE() ;
  1572.   q->symtab.type = ST_LOCAL_NONE ;
  1573.   q->symtab.name = p->symtab.name ;
  1574.   /* put q in the hash table */
  1575.   q->link = hash_table[ h = last_hash ] ;
  1576.   hash_table[h] = q ;
  1577.  
  1578.   /* save p */
  1579.   p->link = save_list ; save_list = p ;
  1580.  
  1581.   return & q->symtab ;
  1582. }
  1583.  
  1584. /* restore all global indentifiers */
  1585. void  restore_ids()
  1586. { register HASHNODE *p, *q ;
  1587.   register unsigned h ;
  1588.  
  1589.   q = save_list ; save_list = (HASHNODE *) 0 ;
  1590.   while ( q )
  1591.   {
  1592.     p = q ; q = q->link ;
  1593.     zfree( delete(p->symtab.name) , sizeof(HASHNODE) ) ;
  1594.     p->link = hash_table[h = last_hash ] ; 
  1595.     hash_table[h] = p ;
  1596.   }
  1597. }
  1598. @//E*O*F mawk0.97/hash.c//
  1599. chmod u=rw,g=r,o=r mawk0.97/hash.c
  1600.  
  1601. echo x - mawk0.97/init.c
  1602. sed 's/^@//' > "mawk0.97/init.c" <<'@//E*O*F mawk0.97/init.c//'
  1603.  
  1604. /********************************************
  1605. init.c
  1606. copyright 1991, Michael D. Brennan
  1607.  
  1608. This is a source file for mawk, an implementation of
  1609. the Awk programming language as defined in
  1610. Aho, Kernighan and Weinberger, The AWK Programming Language,
  1611. Addison-Wesley, 1988.
  1612.  
  1613. See the accompaning file, LIMITATIONS, for restrictions
  1614. regarding modification and redistribution of this
  1615. program in source or binary form.
  1616. ********************************************/
  1617.  
  1618.  
  1619. /* $Log:    init.c,v $
  1620.  * Revision 2.2  91/04/09  12:39:08  brennan
  1621.  * added static to funct decls to satisfy STARDENT compiler
  1622.  * 
  1623.  * Revision 2.1  91/04/08  08:23:15  brennan
  1624.  * VERSION 0.97
  1625.  * 
  1626. */
  1627.  
  1628.  
  1629. /* init.c */
  1630. #include "mawk.h"
  1631. #include "code.h"
  1632. #include "init.h"
  1633. #include "memory.h"
  1634. #include "symtype.h"
  1635. #include "bi_vars.h"
  1636. #include "field.h"
  1637.  
  1638. #define PROGRAM_FROM_CMDLINE   1
  1639.  
  1640. /* static protos */
  1641. static void PROTO( no_program, (void) ) ;
  1642. static void PROTO( process_cmdline , (int, char **) ) ;
  1643. static void PROTO( set_FS, (char *) ) ;
  1644. static void PROTO( set_dump, (char *) ) ;
  1645.  
  1646. #if  DOS  &&  ! HAVE_REARGV
  1647. #include <fcntl.h>
  1648. static  void  PROTO(emit_prompt, (void) ) ;
  1649. #endif
  1650.  
  1651. union tbuff  temp_buff ;
  1652. char *main_buff = temp_buff.string_buff + TEMP_BUFF_SZ ;
  1653.  
  1654. void initialize(argc, argv)
  1655.   int argc ; char **argv ;
  1656. {
  1657.   bi_vars_init() ; /* load the builtin variables */
  1658.   bi_funct_init() ; /* load the builtin functions */
  1659.   kw_init() ; /* load the keywords */
  1660.   field_init() ; 
  1661.   process_cmdline(argc, argv)  ;   
  1662.  
  1663.   jmp_stacks_init() ;
  1664.   code_init() ;
  1665.   fpe_init() ;
  1666.  
  1667. #if  NO_STRTOD
  1668.   strtod_init() ;
  1669. #endif
  1670.  
  1671. }
  1672.  
  1673. void  compile_cleanup()
  1674. /* program has parsed OK, free some memory
  1675.    we don't need anymore */
  1676. {
  1677.    scan_cleanup() ;
  1678.    jmp_stacks_cleanup() ;
  1679.    code_cleanup() ;
  1680. }
  1681.  
  1682.  
  1683. static void no_program()
  1684. { errmsg( 0, "no program") ; mawk_exit(1) ; }
  1685.  
  1686. int  dump_code ;  /* if on dump internal code */
  1687. #ifdef   DEBUG
  1688. int  dump_RE   ;  /* if on dump compiled REs  */
  1689. #endif
  1690.  
  1691. static void set_FS(s)
  1692.   char *s ;
  1693. {
  1694.   cell_destroy(field+FS) ;
  1695.   field[FS].type = C_STRING ;
  1696.   field[FS].ptr = (PTR) new_STRING(s) ;
  1697.   cast_for_split( cellcpy(&fs_shadow, field+FS) ) ;
  1698. }
  1699.  
  1700.  
  1701. #ifdef  DEBUG
  1702. static void set_dump(s)
  1703.   char *s ;
  1704. {
  1705.   while ( 1 )
  1706.   { switch ( *s )
  1707.     { case 'p' :
  1708.       case 'P' :  yydebug = 1 ; break ;
  1709.  
  1710.       case  'c' :
  1711.       case  'C' :  dump_code = 1 ; break ;
  1712.  
  1713.       case  'r' :
  1714.       case  'R' :  dump_RE = 1 ; break ;
  1715.  
  1716.       case   0  :  
  1717.              if ( s[-1] == 'D' ) dump_code = 1 ;
  1718.              return ;
  1719.  
  1720.       default :  break ;
  1721.     }
  1722.     s++ ;
  1723.   }
  1724. }
  1725. #else
  1726. static void  set_dump(s)
  1727.   char *s ;
  1728. { dump_code = 1 ; }
  1729. #endif
  1730.  
  1731. static void process_cmdline(argc, argv)
  1732.   int argc ; char **argv ;
  1733. { extern int program_fd ; 
  1734.   int i ;  /* index to walk command line */
  1735.   char *p ;
  1736.   CELL *cp ;
  1737.   SYMTAB *st_p ;
  1738.   char xbuff[20] ;
  1739.  
  1740.  
  1741.   for( i = 1 ; i < argc && argv[i][0] == '-' ; i++ )
  1742.   { p = & argv[i][1] ;
  1743.     if ( *p == 'F' )  set_FS(p+1) ;
  1744.  
  1745.     else if ( *p == 'D' )  set_dump(p+1) ;
  1746.     else if ( *p == 'f' )
  1747.     { if ( i == argc - 1 )  no_program() ;
  1748.       scan_init(! PROGRAM_FROM_CMDLINE, argv[i+1] ) ;
  1749.       i += 2 ;
  1750.       goto  set_ARGV ;
  1751.     }
  1752.   }
  1753.  
  1754. #if  DOS   &&  ! HAVE_REARGV
  1755. /* allows short programs to be typed in without mucking stdin */
  1756.   emit_prompt() ;
  1757.   scan_init(! PROGRAM_FROM_CMDLINE, "CON") ;
  1758. #else   /* the real world */
  1759.  
  1760.   if ( i == argc )  no_program() ;
  1761.   scan_init(PROGRAM_FROM_CMDLINE, argv[i]) ;
  1762.   i++ ;
  1763. #endif
  1764.  
  1765. set_ARGV:
  1766.  
  1767.   /* now set up ARGC and ARGV  */
  1768.   st_p = insert( "ARGV" ) ;
  1769.   st_p->type = ST_ARRAY ;
  1770.   Argv = st_p->stval.array = new_ARRAY() ;
  1771.   xbuff[0] = '0' ; xbuff[1] = 0 ;
  1772.   cp = array_find( st_p->stval.array, xbuff, 1) ;
  1773.   cp->type = C_STRING ;
  1774.   cp->ptr = (PTR) new_STRING( progname ) ;
  1775.  
  1776.   /* ARGV[0] is set, do the rest 
  1777.      The type of ARGV[1] ... should be C_MBSTRN
  1778.      because the user might enter numbers from the command line */
  1779.   { int arg_count = 1 ;
  1780.  
  1781.     for( ; i < argc ; i++, arg_count++ )
  1782.     { 
  1783.       if ( arg_count < 10 )  xbuff[0] = arg_count + '0' ;
  1784.       else (void) sprintf(xbuff, "%u" , arg_count ) ;
  1785.       cp = array_find( st_p->stval.array, xbuff, 1) ;
  1786.       cp->type = C_MBSTRN ;
  1787.       cp->ptr = (PTR) new_STRING( argv[i] ) ;
  1788.     }
  1789.     bi_vars[ARGC].type = C_DOUBLE ;
  1790.     bi_vars[ARGC].dval = (double) arg_count ;
  1791.   }
  1792. }
  1793.  
  1794. #if  DOS  &&  ! HAVE_REARGV
  1795.  
  1796. static void  emit_prompt()
  1797. {  static char prompt[] = DOS_PROMPT ;
  1798.    int fd = open("CON", O_WRONLY, 0) ;
  1799.  
  1800.    (void) write(fd, prompt, strlen(prompt)) ;
  1801.    (void) close(fd) ;
  1802. }
  1803. #endif
  1804.  
  1805. @//E*O*F mawk0.97/init.c//
  1806. chmod u=rw,g=r,o=r mawk0.97/init.c
  1807.  
  1808. echo x - mawk0.97/init.h
  1809. sed 's/^@//' > "mawk0.97/init.h" <<'@//E*O*F mawk0.97/init.h//'
  1810.  
  1811. /********************************************
  1812. init.h
  1813. copyright 1991, Michael D. Brennan
  1814.  
  1815. This is a source file for mawk, an implementation of
  1816. the Awk programming language as defined in
  1817. Aho, Kernighan and Weinberger, The AWK Programming Language,
  1818. Addison-Wesley, 1988.
  1819.  
  1820. See the accompaning file, LIMITATIONS, for restrictions
  1821. regarding modification and redistribution of this
  1822. program in source or binary form.
  1823. ********************************************/
  1824.  
  1825. /* $Log:    init.h,v $
  1826.  * Revision 2.1  91/04/08  08:23:17  brennan
  1827.  * VERSION 0.97
  1828.  * 
  1829. */
  1830.  
  1831. /* init.h  */
  1832.  
  1833.  
  1834. #ifndef  INIT_H
  1835. #define  INIT_H
  1836.  
  1837.  
  1838. void  PROTO( initialize, (int, char **) ) ;
  1839. void  PROTO( code_init, (void) ) ;
  1840. void  PROTO( code_cleanup, (void) ) ;
  1841. void  PROTO( compile_cleanup, (void) ) ;
  1842. void PROTO(scan_init, (int, char *) ) ;
  1843. void PROTO(scan_cleanup, (void) ) ;
  1844. void PROTO(bi_vars_init, (void) ) ;
  1845. void PROTO(bi_funct_init, (void) ) ;
  1846. void PROTO(print_init, (void) ) ;
  1847. void PROTO(kw_init, (void) ) ;
  1848. void PROTO(jmp_stacks_init, (void) ) ;
  1849. void PROTO(jmp_stacks_cleanup, (void) ) ;
  1850. void  PROTO( field_init, (void) ) ;
  1851. void  PROTO( fpe_init, (void) ) ;
  1852.  
  1853. #endif   /* INIT_H  */
  1854. @//E*O*F mawk0.97/init.h//
  1855. chmod u=rw,g=r,o=r mawk0.97/init.h
  1856.  
  1857. echo x - mawk0.97/jmp.c
  1858. sed 's/^@//' > "mawk0.97/jmp.c" <<'@//E*O*F mawk0.97/jmp.c//'
  1859.  
  1860. /********************************************
  1861. jmp.c
  1862. copyright 1991, Michael D. Brennan
  1863.  
  1864. This is a source file for mawk, an implementation of
  1865. the Awk programming language as defined in
  1866. Aho, Kernighan and Weinberger, The AWK Programming Language,
  1867. Addison-Wesley, 1988.
  1868.  
  1869. See the accompaning file, LIMITATIONS, for restrictions
  1870. regarding modification and redistribution of this
  1871. program in source or binary form.
  1872. ********************************************/
  1873.  
  1874. /* $Log:    jmp.c,v $
  1875.  * Revision 2.1  91/04/08  08:23:19  brennan
  1876.  * VERSION 0.97
  1877.  * 
  1878. */
  1879.  
  1880. /* this module deals with back patching jumps, breaks and continues,
  1881.    and with save and restoring code when we move code.
  1882.    There are three stacks.  If we encounter a compile error, the
  1883.    stacks are frozen, i.e., we do not attempt error recovery
  1884.    on the stacks
  1885. */
  1886.  
  1887.  
  1888. #include "mawk.h"
  1889. #include "jmp.h"
  1890. #include "code.h"
  1891. #include "sizes.h"
  1892. #include "init.h"
  1893. #include "memory.h"
  1894.  
  1895. extern unsigned compile_error_count ;
  1896. #define error_state  (compile_error_count>0)
  1897.  
  1898.  
  1899. /* a stack to hold jumps that need to be patched */
  1900.  
  1901. #define JMP_STK_SZ  (2*MAX_LOOP_DEPTH)
  1902.  
  1903. static INST **jmp_stack ; 
  1904. static INST **jmp_sp  ;
  1905.  
  1906. /*-------------------------------------*/
  1907. /* a stack to hold break or continue that need to be
  1908.    patched (which is all of them) */
  1909.  
  1910. #define  BC_SZ    MAX_LOOP_DEPTH
  1911.  
  1912. /* the stack holds a linked list of these */
  1913.  
  1914. struct BC_node { /* struct for the break/continue list */
  1915. char type ;   /*  'B' or 'C' */
  1916. INST *jmp ;   /*  the jump to patch */
  1917. struct BC_node *link ;
  1918. } ;
  1919.  
  1920. static   struct BC_node  **BC_stack ;
  1921. static   struct BC_node  **BC_sp ;
  1922.  
  1923. /*---------------------------------------*/
  1924. /* a stack to hold some pieces of code while 
  1925.    reorganizing loops */
  1926.  
  1927. #define  LOOP_CODE_SZ    (2*MAX_LOOP_DEPTH)
  1928.  
  1929. static struct loop_code {
  1930. INST *code ;
  1931. unsigned short len ;
  1932. }  *loop_code_stack , *lc_sp ;
  1933.  
  1934. /*--------------------------------------*/
  1935. void jmp_stacks_init()
  1936. { jmp_stack = (INST **)  zmalloc(JMP_STK_SZ*sizeof(INST*)) ;
  1937.   jmp_sp = jmp_stack-1 ;
  1938.  
  1939.   BC_stack = (struct BC_node **) 
  1940.               zmalloc(BC_SZ*sizeof(struct BC_node*)) ;
  1941.   BC_sp =  BC_stack-1 ;
  1942.  
  1943.   loop_code_stack = (struct loop_code *)
  1944.                     zmalloc(LOOP_CODE_SZ*sizeof(struct loop_code)) ;
  1945.   lc_sp = loop_code_stack - 1 ;
  1946. }
  1947.  
  1948. void jmp_stacks_cleanup()
  1949. { zfree(jmp_stack, JMP_STK_SZ*sizeof(INST*)) ;
  1950.   zfree(BC_stack, BC_SZ*sizeof(struct BC_node*)) ;
  1951.   zfree(loop_code_stack, LOOP_CODE_SZ*sizeof(struct loop_code)) ;
  1952. }
  1953. /*--------------------------------------*/
  1954. /* operations on the jmp_stack */
  1955.  
  1956. void code_jmp( jtype, target)
  1957.   int jtype ; INST *target ;
  1958. { 
  1959.   if (error_state)  return ;
  1960.  
  1961.   /* check if a constant expression will be at top of stack,
  1962.      if so replace conditional jump with jump */
  1963.  
  1964.   if ( code_ptr[-2].op == _PUSHC && jtype != _JMP )
  1965.   { int t = test( (CELL *) code_ptr[-1].ptr ) ;
  1966.     if ( jtype == _JZ && ! t ||
  1967.          jtype == _JNZ && t )
  1968.     { code_ptr -= 2 ; jtype = _JMP ; }
  1969.   }
  1970.    
  1971.   if ( ! target ) /* jump will have to be patched later ,
  1972.                      put it on the jmp_stack */
  1973.   { if ( ++jmp_sp == jmp_stack + JMP_STK_SZ )
  1974.           overflow("jmp stack" , JMP_STK_SZ ) ; 
  1975.     *jmp_sp = code_ptr ;
  1976.     code2(jtype, 0) ;
  1977.   }
  1978.   else
  1979.   { INST *source = code_ptr ;
  1980.   
  1981.     code_ptr++->op = jtype ;
  1982.     code_ptr++->op = target - source ; 
  1983.   }
  1984. }
  1985.  
  1986. void patch_jmp(target)  /* patch a jump on the jmp_stack */
  1987.   INST *target ;
  1988. { register INST *source ;
  1989.  
  1990.   if ( ! error_state )
  1991.   {
  1992.     if ( jmp_sp <= jmp_stack-1 ) bozo("jmp stack underflow") ;
  1993.     source = *jmp_sp-- ;
  1994.     source[1].op = target - source ;
  1995.   }
  1996. }
  1997.  
  1998.  
  1999. /*---------------------------*/
  2000.  
  2001. /* a stack of linked lists of BC_nodes for patching 
  2002.    break and continue statements.  */
  2003.  
  2004.  
  2005. void BC_new()  /* push an empty list on the stack */
  2006. { 
  2007.   if ( ! error_state )
  2008.   { if ( ++BC_sp == BC_stack + BC_SZ ) overflow("BC stack", BC_SZ) ;
  2009.     * BC_sp = (struct BC_node *) 0 ;
  2010.   }
  2011. }
  2012.  
  2013. void BC_insert(type, address)
  2014.   int type ; INST *address ;
  2015. { register struct BC_node *p ; 
  2016.  
  2017.   if ( error_state )  return ;
  2018.   if ( BC_sp <= BC_stack - 1 )
  2019.   {  compile_error(  type == 'B' ?
  2020.         "break statement outside of loop" :
  2021.         "continue statement outside of loop" ) ; 
  2022.      return ;
  2023.   }
  2024.   
  2025.   p = (struct BC_node *) zmalloc( sizeof(struct BC_node) ) ;
  2026.   p->type = type ; p->jmp = address ;
  2027.   p->link = *BC_sp ; *BC_sp = p ;
  2028. }
  2029.  
  2030. void BC_clear(B_address, C_address)  
  2031. /* patch all break and continues on list */
  2032. INST *B_address, *C_address ;
  2033. { register struct BC_node *p , *q ;
  2034.  
  2035.   if (error_state) return ;
  2036.   if ( BC_sp <= BC_stack-1) bozo("underflow on BC stack") ;
  2037.   p = *BC_sp-- ;
  2038.   while ( p )
  2039.   { p->jmp[1].op = (p->type=='B' ? B_address : C_address) - p->jmp ;
  2040.     q = p ; p = p->link ; zfree(q, sizeof(struct BC_node)) ;
  2041.   }
  2042. }
  2043.  
  2044. /*---------------------------------------------*/
  2045. /*  save and restore some code for reorganizing
  2046.     loops on a stack */
  2047.  
  2048.  
  2049. void code_push( p, len)
  2050.   INST *p ; unsigned len ;
  2051. { 
  2052.   if (error_state) return ;
  2053.   if ( ++lc_sp == loop_code_stack + LOOP_CODE_SZ )
  2054.         overflow("loop_code_stack" , LOOP_CODE_SZ) ;
  2055.  
  2056.   if ( len )
  2057.   { lc_sp->code = (INST *) zmalloc(sizeof(INST) * len) ;
  2058.     (void) memcpy(lc_sp->code, p, sizeof(INST) * len) ; }
  2059.   else  lc_sp->code = (INST *) 0 ;
  2060.   lc_sp->len = (unsigned short) len ;
  2061. }
  2062.  
  2063. /* copy the code at the top of the loop code stack to target.
  2064.    return the number of bytes moved */
  2065.  
  2066. unsigned code_pop(target) 
  2067.   INST *target ;
  2068. { 
  2069.   if (error_state)  return 0 ;
  2070.   if ( lc_sp <= loop_code_stack-1 )  bozo("loop code stack underflow") ;
  2071.   if ( lc_sp->len )
  2072.   { (void) memcpy(target, lc_sp->code, lc_sp->len * sizeof(INST)) ;
  2073.     zfree(lc_sp->code, sizeof(INST)*lc_sp->len) ; }
  2074.   return lc_sp-- -> len ;
  2075. }
  2076. @//E*O*F mawk0.97/jmp.c//
  2077. chmod u=rw,g=r,o=r mawk0.97/jmp.c
  2078.  
  2079. echo x - mawk0.97/jmp.h
  2080. sed 's/^@//' > "mawk0.97/jmp.h" <<'@//E*O*F mawk0.97/jmp.h//'
  2081.  
  2082. /********************************************
  2083. jmp.h
  2084. copyright 1991, Michael D. Brennan
  2085.  
  2086. This is a source file for mawk, an implementation of
  2087. the Awk programming language as defined in
  2088. Aho, Kernighan and Weinberger, The AWK Programming Language,
  2089. Addison-Wesley, 1988.
  2090.  
  2091. See the accompaning file, LIMITATIONS, for restrictions
  2092. regarding modification and redistribution of this
  2093. program in source or binary form.
  2094. ********************************************/
  2095.  
  2096. /* $Log:    jmp.h,v $
  2097.  * Revision 2.1  91/04/08  08:23:21  brennan
  2098.  * VERSION 0.97
  2099.  * 
  2100. */
  2101.  
  2102. #ifndef   JMP_H
  2103. #define   JMP_H
  2104.  
  2105. void  PROTO(BC_new, (void) ) ;
  2106. void  PROTO(BC_insert, (int, INST*) ) ;
  2107. void  PROTO(BC_clear, (INST *, INST *) ) ;
  2108. void  PROTO(code_push, (INST *, unsigned) ) ;
  2109. unsigned  PROTO(code_pop, (INST *) ) ;
  2110. void  PROTO(code_jmp, (int, INST *) ) ;
  2111. void  PROTO(patch_jmp, (INST *) ) ;
  2112.  
  2113.  
  2114. #endif  /* JMP_H  */
  2115.  
  2116. @//E*O*F mawk0.97/jmp.h//
  2117. chmod u=rw,g=r,o=r mawk0.97/jmp.h
  2118.  
  2119. echo x - mawk0.97/kw.c
  2120. sed 's/^@//' > "mawk0.97/kw.c" <<'@//E*O*F mawk0.97/kw.c//'
  2121.  
  2122. /********************************************
  2123. kw.c
  2124. copyright 1991, Michael D. Brennan
  2125.  
  2126. This is a source file for mawk, an implementation of
  2127. the Awk programming language as defined in
  2128. Aho, Kernighan and Weinberger, The AWK Programming Language,
  2129. Addison-Wesley, 1988.
  2130.  
  2131. See the accompaning file, LIMITATIONS, for restrictions
  2132. regarding modification and redistribution of this
  2133. program in source or binary form.
  2134. ********************************************/
  2135.  
  2136.  
  2137. /* $Log:    kw.c,v $
  2138.  * Revision 2.1  91/04/08  08:23:23  brennan
  2139.  * VERSION 0.97
  2140.  * 
  2141. */
  2142.  
  2143.  
  2144. /* kw.c */
  2145.  
  2146.  
  2147. #include "mawk.h"
  2148. #include "symtype.h"
  2149. #include "parse.h"
  2150. #include "init.h"
  2151.  
  2152.  
  2153. static struct kw {
  2154. char *text ;
  2155. short kw ;
  2156. }  keywords[] = {
  2157.  
  2158. "print", PRINT,
  2159. "printf", PRINTF,
  2160. "do" , DO ,
  2161. "while" , WHILE ,
  2162. "for" , FOR ,
  2163. "break" , BREAK ,
  2164. "continue" , CONTINUE ,
  2165. "if" , IF ,
  2166. "else", ELSE ,
  2167. "in" , IN ,
  2168. "delete", DELETE ,
  2169. "split" , SPLIT ,
  2170. "match" , MATCH_FUNC ,
  2171. "BEGIN" , BEGIN,
  2172. "END" ,   END ,
  2173. "exit" , EXIT ,
  2174. "next" , NEXT ,
  2175. "return", RETURN,
  2176. "getline", GETLINE,
  2177. "sub" , SUB,
  2178. "gsub", GSUB,
  2179. "function", FUNCTION,
  2180. (char *) 0 , 0 } ;
  2181.  
  2182. /* put keywords in the symbol table */
  2183. void kw_init()
  2184. { register struct kw *p = keywords ;
  2185.   register SYMTAB *q ;
  2186.  
  2187.   while ( p->text )
  2188.   { q = insert( p->text ) ;
  2189.     q->type = ST_KEYWORD ;
  2190.     q->stval.kw = p++ -> kw ;
  2191.   }
  2192. }
  2193.  
  2194. /* find a keyword to emit an error message */
  2195. char *find_kw_str( kw_token )
  2196.   int kw_token ;
  2197. { struct kw *p = keywords ;
  2198.  
  2199.   for( p = keywords ; p->text ; p++ )
  2200.         if ( p->kw == kw_token )  return p->text ;
  2201.   /* search failed */
  2202.   return (char *) 0 ;
  2203. }
  2204. @//E*O*F mawk0.97/kw.c//
  2205. chmod u=rw,g=r,o=r mawk0.97/kw.c
  2206.  
  2207. echo x - mawk0.97/machine.h
  2208. sed 's/^@//' > "mawk0.97/machine.h" <<'@//E*O*F mawk0.97/machine.h//'
  2209.  
  2210. /********************************************
  2211. machine.h
  2212. copyright 1991, Michael D. Brennan
  2213.  
  2214. This is a source file for mawk, an implementation of
  2215. the Awk programming language as defined in
  2216. Aho, Kernighan and Weinberger, The AWK Programming Language,
  2217. Addison-Wesley, 1988.
  2218.  
  2219. See the accompaning file, LIMITATIONS, for restrictions
  2220. regarding modification and redistribution of this
  2221. program in source or binary form.
  2222. ********************************************/
  2223.  
  2224. /*$Log:    machine.h,v $
  2225.  * Revision 2.2  91/04/09  12:39:14  brennan
  2226.  * added static to funct decls to satisfy STARDENT compiler
  2227.  * 
  2228.  * Revision 2.1  91/04/08  08:23:25  brennan
  2229.  * VERSION 0.97
  2230.  * 
  2231. */
  2232.  
  2233.  
  2234. /* I've attempted to isolate machine/system dependencies here.
  2235.  
  2236.    Floating point exceptions are the biggest hassle.
  2237.    If you have IEEE754 floating point, turn off floating point
  2238.    traps and let the INFs and NANs go berserk.  This should be
  2239.    the default (see page 14 of IEEE754), but ANSI C seems to imply
  2240.    they should be on (i.e., one standards committee does not talk to
  2241.    the other).  Anyway, define a macro TURNOFF_FPE_TRAPS() which will
  2242.    probably be a 1 liner.
  2243.  
  2244.    If you cannot turn off floating exceptions, check out
  2245.    fpe_catch() in matherr.c and modify as needed for your machine.
  2246.    Also you may need to define FPE_ZERODIVIDE and FPE_OVERFLOW.
  2247.  
  2248.    If you have SysV like matherr(), use it.
  2249.    If you have SysV compatible math lib , use it.
  2250.    You might need to supply a macro to replace drand48(), otherwise.
  2251.    (See BSD43 for no IEEE754, no matherr(), no fmod(),
  2252.     no strtod(), no drand48())
  2253.  
  2254.    If you have to be conservative with memory (e.g., small model
  2255.    MsDos), a small evaluation stack (16-32) is plenty.
  2256.    Recursive functions calls are the only reason you need a big
  2257.    stack.  The default for MsDos uses 64 which allows some
  2258.    recursion without killing too many memory CELLs.
  2259. */
  2260.  
  2261. /*  MsDOS --
  2262.     If you use command.com as the shell, entering programs on the
  2263.     command line is hopeless.  Command.com will always glom onto
  2264.     | or < or > as redirection.
  2265.  
  2266.     If you use a Unix style shell under DOS, then you need to
  2267.     write 
  2268.  
  2269.         void  reargv(int *argc, char ***argv)
  2270.  
  2271.     which gets the arguments from your shell, and then
  2272.  
  2273.     #define   HAVE_REARGV    1
  2274.  
  2275.     See README in dos directory
  2276.     and MsDos section of manual.
  2277. */
  2278.  
  2279. #ifndef    MACHINE_H
  2280. #define    MACHINE_H
  2281.  
  2282.  
  2283. #ifdef  sun   /* sun3 or sun4 with SUNOS 4.0.3 */
  2284. #define  FPE_TRAPS              0
  2285. #define  TURNOFF_FPE_TRAPS()    /* empty, default is off */      
  2286. #define  HAVE_MATHERR           1
  2287. #endif
  2288.  
  2289. #ifdef    __TURBOC__
  2290. #define   DOS            1
  2291. #define   SMALL_EVAL_STACK      1
  2292. #define  FPE_TRAPS              0
  2293. #define  TURNOFF_FPE_TRAPS()    _control87(0x3f,0x3f)
  2294. #define  HAVE_MATHERR           1
  2295. #endif
  2296.  
  2297. #ifdef   ULTRIX  /* V4.1 on a vax 3600 */
  2298. #define  HAVE_VOID_PTR          1
  2299. #define  HAVE_MATHERR           1
  2300. #define   FPE_ZERODIVIDE   FPE_FLTDIV_FAULT
  2301. #define   FPE_OVERFLOW     FPE_FLTOVF_FAULT
  2302. #endif
  2303.  
  2304. #ifdef    BSD43   /* on a vax */
  2305. #define   NO_STRTOD             1
  2306. #define   NO_FMOD               1
  2307. #define   srand48(x)    srandom(x)
  2308. #define   drand48() (((double)random())/((double)(unsigned)0x80000000))
  2309. #define   vfprintf(s,f,a)  _doprnt(f,a,s)
  2310. #define   FPE_ZERODIVIDE   FPE_FLTDIV_FAULT
  2311. #define   FPE_OVERFLOW     FPE_FLTOVF_FAULT
  2312. #endif
  2313.  
  2314. #ifdef   STARDENT  /* Stardent 3000, SysV R3.0 */
  2315. #define  HAVE_MATHERR    1
  2316. #define  FPE_TRAPS    0
  2317. #define  TURNOFF_FPE_TRAPS()    /* nothing */
  2318. #define  HAVE_VOID_PTR    1
  2319. #endif
  2320.  
  2321. /*  the defaults    */
  2322. #ifndef   HAVE_VOID_PTR
  2323. #define   HAVE_VOID_PTR         0  /* no void * */
  2324. #endif
  2325.  
  2326. #ifndef   FPE_TRAPS
  2327. #define   FPE_TRAPS             1  
  2328.     /* floating point errors generate exceptions  */
  2329. #endif
  2330.  
  2331. #ifndef   HAVE_MATHERR
  2332. #define   HAVE_MATHERR          0
  2333.     /*  SysV style matherr() is not available */
  2334. #endif
  2335.  
  2336. #ifndef  NO_STRTOD
  2337. #define  NO_STRTOD              0 /* default is have */
  2338. #endif
  2339.  
  2340. #ifndef  SMALL_EVAL_STACK
  2341. #define  SMALL_EVAL_STACK       0
  2342. #endif
  2343.  
  2344. #ifndef  NO_FMOD
  2345. #define  NO_FMOD                0 /* default is to have fmod() */
  2346. #endif
  2347.  
  2348. #define   STDC_MATHERR          (FPE_TRAPS && ! HAVE_MATHERR)
  2349.  
  2350. #ifndef   DOS
  2351. #define   DOS    0
  2352. #endif
  2353.  
  2354. #if   DOS 
  2355.  
  2356. #ifndef  HAVE_REARGV
  2357. #define  HAVE_REARGV    0
  2358. #endif
  2359.  
  2360. #define  DOS_PROMPT     "mawk> "
  2361.     /* change to "mawk \01 "  on a good day */
  2362. #endif
  2363.  
  2364.  
  2365.  
  2366.  
  2367.  
  2368. #endif   /* MACHINE_H  */
  2369. @//E*O*F mawk0.97/machine.h//
  2370. chmod u=rw,g=r,o=r mawk0.97/machine.h
  2371.  
  2372. echo x - mawk0.97/main.c
  2373. sed 's/^@//' > "mawk0.97/main.c" <<'@//E*O*F mawk0.97/main.c//'
  2374.  
  2375. /********************************************
  2376. main.c
  2377. copyright 1991, Michael D. Brennan
  2378.  
  2379. This is a source file for mawk, an implementation of
  2380. the Awk programming language as defined in
  2381. Aho, Kernighan and Weinberger, The AWK Programming Language,
  2382. Addison-Wesley, 1988.
  2383.  
  2384. See the accompaning file, LIMITATIONS, for restrictions
  2385. regarding modification and redistribution of this
  2386. program in source or binary form.
  2387. ********************************************/
  2388.  
  2389.  
  2390. /* $Log:    main.c,v $
  2391.  * Revision 2.2  91/04/22  08:08:58  brennan
  2392.  * cannot close(3) or close(4) because of bug in TurboC++ 1.0
  2393.  * 
  2394.  * Revision 2.1  91/04/08  08:23:27  brennan
  2395.  * VERSION 0.97
  2396.  * 
  2397. */
  2398.  
  2399.  
  2400.  
  2401. /*  main.c  */
  2402.  
  2403. #include "mawk.h"
  2404. #include "code.h"
  2405. #include "init.h"
  2406. #include "fin.h"
  2407. #include "bi_vars.h"
  2408. #include "field.h"
  2409. #include "files.h"
  2410. #include <stdio.h>
  2411.  
  2412. #if  DOS 
  2413. void  reargv(int *, char ***) ;
  2414. #endif
  2415.  
  2416.  
  2417. void  PROTO( process, (void) ) ;
  2418. void  PROTO( main_loop, (void) ) ;
  2419.  
  2420. extern int program_fd ;
  2421. char *progname ;
  2422.  
  2423. jmp_buf   exit_jump, next_jump ;
  2424. int  exit_code ;
  2425.  
  2426.  
  2427. main(argc , argv )
  2428.   int argc ; char **argv ;
  2429. { 
  2430.  
  2431. #if   DOS
  2432.   progname = "mawk" ;
  2433. #if      HAVE_REARGV
  2434.   reargv(&argc, &argv) ;
  2435. #endif
  2436. #else
  2437.   { char *strrchr() ;
  2438.     char *p = strrchr(argv[0], '/') ;
  2439.     progname = p ? p+1 : argv[0] ; }
  2440. #endif
  2441.  
  2442.   initialize(argc, argv) ;
  2443.  
  2444.   if ( parse() || compile_error_count )  exit(1) ;
  2445.  
  2446.   compile_cleanup() ;
  2447.   process() ;
  2448.  
  2449.   mawk_exit( exit_code ) ;
  2450.   return 0 ;
  2451. }
  2452.  
  2453.  
  2454. static  void  process()
  2455. {
  2456.  
  2457.   if ( setjmp(exit_jump) )
  2458.   { if ( begin_start ) zfree(begin_start, begin_size) ;
  2459.     goto the_exit ;
  2460.   }
  2461.  
  2462.   if ( begin_start )
  2463.   { (void) execute(begin_start, eval_stack-1, 0) ;
  2464.     zfree( begin_start , begin_size ) ;
  2465.     begin_start = (INST *) 0 ;
  2466.   }
  2467.  
  2468.   if ( main_start || end_start )  main_loop() ;
  2469.  
  2470. the_exit:
  2471.  
  2472.   if ( setjmp(exit_jump) )  mawk_exit(exit_code) ;
  2473.  
  2474.   if ( main_start )  zfree(main_start, main_size) ;
  2475.   if ( end_start ) (void) execute(end_start, eval_stack-1, 0) ;
  2476. }
  2477.  
  2478.  
  2479. static void  main_loop()
  2480. { register char *p ;
  2481.   unsigned len ;
  2482.  
  2483.   /* the main file stream might already be open by a call of
  2484.      getline in the BEGIN block */
  2485.  
  2486.   if ( main_fin == (FIN *) -1 && ! open_main()
  2487.        || ! main_fin )  return ;
  2488.  
  2489.   if ( main_start )
  2490.   {
  2491.      (void)  setjmp(next_jump) ;
  2492.  
  2493.      while ( p = FINgets( main_fin, &len ) )
  2494.      { 
  2495.        if ( TEST2(bi_vars + NR) != TWO_DOUBLES )
  2496.                     cast2_to_d(bi_vars + NR) ;
  2497.  
  2498.        bi_vars[NR].dval += 1.0 ;
  2499.        bi_vars[FNR].dval += 1.0 ;
  2500.  
  2501.        set_field0(p, len) ;
  2502.        (void) execute( main_start, eval_stack-1, 0) ;
  2503.      }
  2504.   }
  2505.   else  /* eat main to set NR and FNR before executing END */
  2506.   { long nr ;
  2507.  
  2508.     if ( TEST2(bi_vars+NR) != TWO_DOUBLES ) cast2_to_d(bi_vars+NR) ;
  2509.     nr = (long) bi_vars[NR].dval ;
  2510.     while ( FINgets( main_fin, &len ) )
  2511.     { nr++ ; bi_vars[FNR].dval += 1.0 ; }
  2512.     bi_vars[NR].dval = (double) nr ;
  2513.   }
  2514. }
  2515.  
  2516.  
  2517. void  mawk_exit(x)
  2518.   int x ;
  2519. {
  2520. #if  !  DOS
  2521.   close_out_pipes() ;  /* no effect, if no out pipes */
  2522. #endif
  2523.   exit(x) ;
  2524. }
  2525. @//E*O*F mawk0.97/main.c//
  2526. chmod u=rw,g=r,o=r mawk0.97/main.c
  2527.  
  2528. echo x - mawk0.97/makescan.c
  2529. sed 's/^@//' > "mawk0.97/makescan.c" <<'@//E*O*F mawk0.97/makescan.c//'
  2530.  
  2531. /********************************************
  2532. makescan.c
  2533. copyright 1991, Michael D. Brennan
  2534.  
  2535. This is a source file for mawk, an implementation of
  2536. the Awk programming language as defined in
  2537. Aho, Kernighan and Weinberger, The AWK Programming Language,
  2538. Addison-Wesley, 1988.
  2539.  
  2540. See the accompaning file, LIMITATIONS, for restrictions
  2541. regarding modification and redistribution of this
  2542. program in source or binary form.
  2543. ********************************************/
  2544.  
  2545.  
  2546.  
  2547. /*$Log:    makescan.c,v $
  2548.  * Revision 2.1  91/04/08  08:23:29  brennan
  2549.  * VERSION 0.97
  2550.  * 
  2551. */
  2552.  
  2553. /* source for makescan.exe which builds the scancode[]
  2554.    via:   makescan.exe > scancode.c
  2555. */
  2556.  
  2557. #define  MAKESCAN
  2558.  
  2559. #include  "scan.h"
  2560.  
  2561. char   scan_code[256] ;
  2562.  
  2563. void  scan_init()
  2564. { 
  2565.   register char *p ;
  2566.  
  2567.   (void) memset(scan_code, SC_UNEXPECTED, sizeof(scan_code)) ;
  2568.   for( p = scan_code + '0' ; p <= scan_code + '9' ; p++ )
  2569.        *p = SC_DIGIT ;
  2570.   scan_code[0] = 0 ;
  2571.   scan_code[ ' ' ] = scan_code['\t'] = scan_code['\f'] = SC_SPACE ;
  2572.   scan_code[ '\r'] = scan_code['\013'] = SC_SPACE ;
  2573.  
  2574.   scan_code[';'] = SC_SEMI_COLON ;
  2575.   scan_code['\n'] = SC_NL ;
  2576.   scan_code['{'] = SC_LBRACE ;
  2577.   scan_code[ '}'] = SC_RBRACE ;
  2578.   scan_code['+'] = SC_PLUS ;
  2579.   scan_code['-'] = SC_MINUS ;
  2580.   scan_code['*'] = SC_MUL ;
  2581.   scan_code['/'] = SC_DIV ;
  2582.   scan_code['%'] = SC_MOD ;
  2583.   scan_code['^'] = SC_POW ;
  2584.   scan_code['('] = SC_LPAREN ;
  2585.   scan_code[')'] = SC_RPAREN ;
  2586.   scan_code['_'] = SC_IDCHAR ;
  2587.   scan_code['='] = SC_EQUAL ;
  2588.   scan_code['#'] = SC_COMMENT ;
  2589.   scan_code['\"'] = SC_DQUOTE ;
  2590.   scan_code[','] = SC_COMMA ;
  2591.   scan_code['!'] = SC_NOT ;
  2592.   scan_code['<'] = SC_LT ;
  2593.   scan_code['>'] = SC_GT ;
  2594.   scan_code['|'] = SC_OR ;
  2595.  
  2596.  
  2597.