home *** CD-ROM | disk | FTP | other *** search
/ BURKS 2 / BURKS_AUG97.ISO / BURKS / SOFTWARE / SOURCES / MAWK11AS.ZIP / EXECUTE.C (.txt) < prev    next >
C/C++ Source or Header  |  1991-12-18  |  33KB  |  1,181 lines
  1.  
  2. /********************************************
  3. execute.c
  4. copyright 1991, Michael D. Brennan
  5.  
  6. This is a source file for mawk, an implementation of
  7. the AWK programming language.
  8.  
  9. Mawk is distributed without warranty under the terms of
  10. the GNU General Public License, version 2, 1991.
  11. ********************************************/
  12.  
  13. /* $Log:    execute.c,v $
  14.  * Revision 5.1  91/12/05  07:55:50  brennan
  15.  * 1.1 pre-release
  16.  * 
  17. */
  18.  
  19.  
  20. #include "mawk.h"
  21. #include "code.h"
  22. #include "memory.h"
  23. #include "symtype.h"
  24. #include "field.h"
  25. #include "bi_funct.h"
  26. #include "bi_vars.h"
  27. #include "regexp.h"
  28. #include "repl.h"
  29. #include "fin.h"
  30. #include <math.h>
  31.  
  32. /* static functions */
  33. static int PROTO( compare, (CELL *) ) ;
  34. static void PROTO( eval_overflow, (void) ) ;
  35.  
  36.  
  37. #if   NOINFO_SIGFPE
  38. static char dz_msg[] = "division by zero" ;
  39. #endif
  40.  
  41. #ifdef   DEBUG
  42. #define  inc_sp()   if( ++sp == eval_stack+EVAL_STACK_SIZE )\
  43.                          eval_overflow()
  44. #else
  45.  
  46. /* If things are working, the eval stack should not overflow */
  47.  
  48. #define inc_sp()    sp++
  49. #endif
  50.  
  51. #define  SAFETY    16
  52. #define  DANGER    (EVAL_STACK_SIZE-SAFETY)
  53.  
  54. /*  The stack machine that executes the code */
  55.  
  56. CELL  eval_stack[EVAL_STACK_SIZE] ;
  57. /* these can move for deep recursion */
  58. static CELL  *stack_base = eval_stack ;
  59. static CELL  *stack_danger = eval_stack + DANGER ;      
  60.  
  61. #ifdef  DEBUG
  62. static void eval_overflow()
  63. { overflow("eval stack" , EVAL_STACK_SIZE) ; mawk_exit(1) ; }
  64. #endif
  65.  
  66. static INST *restart_label ; /* control flow labels */
  67. INST *next_label ;
  68. static CELL tc ; /*useful temp */
  69.  
  70. void  execute(cdp, sp, fp)
  71.   register INST *cdp ;  /* code ptr, start execution here */
  72.   register CELL *sp ;   /* eval_stack pointer */
  73.   CELL *fp ;            /* frame ptr into eval_stack for
  74.                            user defined functions */
  75. { 
  76.   /* some useful temporaries */
  77.   CELL *cp ;
  78.   int t ;
  79.  
  80.   /* for moving the stack (deep recursion) */
  81.   CELL *old_stack_base ;
  82.   CELL *old_sp ;
  83.  
  84. #ifdef  DEBUG
  85.   CELL *entry_sp = sp ;
  86. #endif
  87.  
  88.  
  89.   if ( fp )  /* we are a function call, check for deep recursion */
  90.   {
  91.     if (sp > stack_danger)
  92.     { /* change stacks */
  93.       old_stack_base = stack_base ;
  94.       old_sp = sp ;
  95.       stack_base = (CELL *) zmalloc(sizeof(CELL)*EVAL_STACK_SIZE) ;
  96.       stack_danger = stack_base + DANGER ;
  97.       sp = stack_base ;
  98.       /* waste 1 slot for ANSI, actually LM_DOS breaks in
  99.          RET if we don't */
  100. #ifdef  DEBUG 
  101.       entry_sp = sp ;
  102. #endif
  103.     }
  104.     else old_stack_base = (CELL*) 0 ;
  105.   }
  106.  
  107.   while ( 1 )
  108.     switch( cdp++ -> op )
  109.     {   
  110.  
  111. /* HALT only used by the disassemble now ; this remains
  112.    so compilers don't offset the jump table */
  113.         case  _HALT :
  114.  
  115.         case  _STOP :  /* only for range patterns */
  116. #ifdef  DEBUG
  117.                 if ( sp != entry_sp+1 ) bozo("stop0") ;
  118. #endif
  119.                 return ;
  120.  
  121.         case  _PUSHC :  
  122.             inc_sp() ;
  123.             (void) cellcpy(sp, cdp++ -> ptr) ;
  124.             break ;
  125.  
  126.         case _PUSHD  :
  127.             inc_sp() ;
  128.             sp->type = C_DOUBLE ;
  129.             sp->dval = *(double*) cdp++->ptr ;
  130.             break ;
  131.  
  132.         case  _PUSHS :
  133.             inc_sp() ;
  134.             sp->type = C_STRING ;
  135.             sp->ptr = cdp++->ptr ;
  136.             string(sp)->ref_cnt++ ;
  137.             break ;
  138.  
  139.         case  F_PUSHA :
  140.             if ( (CELL*)cdp->ptr != field && nf < 0 ) split_field0() ;
  141.             /* fall thru */
  142.  
  143.         case  _PUSHA :
  144.         case  A_PUSHA :
  145.             inc_sp() ;
  146.             sp -> ptr = cdp++ -> ptr ;
  147.             break ;
  148.  
  149.         case _PUSHI :  /* put contents of next address on stack*/
  150.             inc_sp() ;
  151.             (void) cellcpy(sp, cdp++ -> ptr) ;
  152.             break ;
  153.             
  154.         case L_PUSHI :  
  155.             /* put the contents of a local var on stack,
  156.                cdp->op holds the offset from the frame pointer */
  157.             inc_sp() ;
  158.             (void) cellcpy(sp, fp + cdp++->op) ;
  159.             break ;
  160.  
  161.         case L_PUSHA : /* put a local address on eval stack */
  162.             inc_sp() ;
  163.             sp->ptr = (PTR)(fp + cdp++->op) ;
  164.             break ;
  165.  
  166.  
  167.         case F_PUSHI :
  168.  
  169.         /* push contents of $i 
  170.            cdp[0] holds & $i , cdp[1] holds i */
  171.  
  172.             inc_sp() ;
  173.             if ( nf < 0 )  split_field0() ;
  174.             cp = (CELL *) cdp->ptr ;
  175.             t =  (cdp+1)->op ;
  176.             cdp += 2 ;
  177.  
  178.             if ( t <= nf ) (void) cellcpy(sp, cp) ;
  179.             else  /* an unset field */
  180.             { sp->type = C_STRING ;
  181.               sp->ptr = (PTR) & null_str ;
  182.               null_str.ref_cnt++ ;
  183.             }
  184.             break ;
  185.  
  186.         case NF_PUSHI :
  187.  
  188.             inc_sp() ;
  189.             if ( nf < 0 ) split_field0() ;
  190.             (void) cellcpy(sp, NF) ;
  191.             break ;
  192.  
  193.         case  FE_PUSHA :
  194.             if ( sp->type != C_DOUBLE )  cast1_to_d(sp) ;
  195.             if ( (t = (int) sp->dval) < 0 )
  196.                 rt_error( "negative field index $%d", t) ;
  197.             if ( t && nf < 0 )  split_field0() ;
  198.             sp->ptr = (PTR) field_ptr(t) ;
  199.             break ;
  200.  
  201.         case  FE_PUSHI :
  202.             if ( sp->type != C_DOUBLE )  cast1_to_d(sp) ;
  203.  
  204.             if ( (t = (int) sp->dval) < 0 )
  205.                   rt_error( "negative field index $%d", t) ;
  206.  
  207.             if ( nf < 0)  split_field0() ;
  208.             if ( t <= nf ) (void) cellcpy(sp, field_ptr(t)) ;
  209.             else
  210.             { sp->type = C_STRING ;
  211.               sp->ptr = (PTR) & null_str ;
  212.               null_str.ref_cnt++ ;
  213.             }
  214.             break ; 
  215.  
  216.  
  217.         case  AE_PUSHA :
  218.         /* top of stack has an expr, cdp->ptr points at an
  219.            array, replace the expr with the cell address inside
  220.            the array */
  221.  
  222.             cp = array_find((ARRAY)cdp++->ptr, sp, CREATE) ;
  223.             cell_destroy(sp) ;
  224.             sp->ptr = (PTR) cp ;
  225.             break ;
  226.  
  227.         case  AE_PUSHI :
  228.         /* top of stack has an expr, cdp->ptr points at an
  229.            array, replace the expr with the contents of the
  230.            cell inside the array */
  231.  
  232.             cp = array_find((ARRAY) cdp++->ptr, sp, CREATE) ;
  233.             cell_destroy(sp) ;
  234.             (void) cellcpy(sp, cp) ;
  235.             break ;
  236.  
  237.         case  LAE_PUSHI :
  238.         /*  sp[0] is an expression
  239.             cdp->op is offset from frame pointer of a CELL which
  240.                has an ARRAY in the ptr field, replace expr
  241.             with  array[expr]
  242.         */
  243.             cp = array_find( (ARRAY)fp[cdp++->op].ptr, sp, CREATE) ;
  244.             cell_destroy(sp) ;
  245.             (void) cellcpy(sp, cp) ;
  246.             break ;
  247.             
  248.         case  LAE_PUSHA :
  249.         /*  sp[0] is an expression
  250.             cdp->op is offset from frame pointer of a CELL which
  251.                has an ARRAY in the ptr field, replace expr
  252.             with  & array[expr]
  253.         */
  254.             cp = array_find( (ARRAY)fp[cdp++->op].ptr, sp, CREATE) ;
  255.             cell_destroy(sp) ;
  256.             sp->ptr = (PTR) cp ;
  257.             break ;
  258.             
  259.         case  LA_PUSHA  :
  260.         /*  cdp->op is offset from frame pointer of a CELL which
  261.                has an ARRAY in the ptr field. Push this ARRAY
  262.                on the eval stack
  263.         */
  264.             inc_sp() ;
  265.             sp->ptr = fp[cdp++->op].ptr ;
  266.             break ;
  267.  
  268.         case  SET_ALOOP :
  269.             { ALOOP_STATE *ap = (ALOOP_STATE *)
  270.                             (cdp + cdp->op + 2)->ptr ;
  271.  
  272.               ap->var = (CELL *) sp[-1].ptr ;
  273.               ap->A = (ARRAY) sp->ptr ;
  274.               sp -= 2 ;
  275.  
  276.           ap->index = -1 ;
  277.               if ( inc_aloop_state(ap) )  cdp++ ;
  278.           else  cdp += cdp->op + 3 ;
  279.         }
  280.         break ;
  281.  
  282.         case  ALOOP :
  283.  
  284.         if ( inc_aloop_state( (ALOOP_STATE*) cdp[1].ptr ) )
  285.             cdp += cdp->op ;
  286.         else    cdp += 2 ;
  287.         break ;
  288.  
  289.         case  _POP : 
  290.             cell_destroy(sp) ;
  291.             sp-- ;
  292.             break ;
  293.  
  294.         case _DUP  :
  295.             (void) cellcpy(sp+1, sp) ;
  296.             sp++ ; break