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