Diff for /gforth/engine/engine.c between versions 1.37 and 1.56

version 1.37, 2002/01/04 20:31:54 version 1.56, 2003/01/19 23:35:33
Line 1 Line 1
 /* Gforth virtual machine (aka inner interpreter)  /* Gforth virtual machine (aka inner interpreter)
   
   Copyright (C) 1995,1996,1997,1998,2000 Free Software Foundation, Inc.    Copyright (C) 1995-2003 Free Software Foundation, Inc.
   
   This file is part of Gforth.    This file is part of Gforth.
   
Line 19 Line 19
   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111, USA.    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111, USA.
 */  */
   
 undefine(`symbols')  
   
 #include "config.h"  #include "config.h"
 #include "forth.h"  #include "forth.h"
 #include <ctype.h>  #include <ctype.h>
Line 66  undefine(`symbols') Line 64  undefine(`symbols')
 #define SEEK_SET 0  #define SEEK_SET 0
 #endif  #endif
   
   #ifndef HAVE_FSEEKO
   #define fseeko fseek
   #endif
   
   #ifndef HAVE_FTELLO
   #define ftello ftell
   #endif
   
 #define IOR(flag)       ((flag)? -512-errno : 0)  #define IOR(flag)       ((flag)? -512-errno : 0)
   
 struct F83Name {  struct F83Name {
Line 84  struct Longname { Line 90  struct Longname {
   
 #define LONGNAME_COUNT(np)      ((np)->countetc & (((~((UCell)0))<<3)>>3))  #define LONGNAME_COUNT(np)      ((np)->countetc & (((~((UCell)0))<<3)>>3))
   
 Cell *SP;  
 Float *FP;  
 Address UP=NULL;  
   
 #if 0  
 /* not used currently */  
 int emitcounter;  
 #endif  
 #define NULLC '\0'  #define NULLC '\0'
   
 #ifdef MEMCMP_AS_SUBROUTINE  #ifdef MEMCMP_AS_SUBROUTINE
Line 99  extern int gforth_memcmp(const char * s1 Line 97  extern int gforth_memcmp(const char * s1
 #define memcmp(s1,s2,n) gforth_memcmp(s1,s2,n)  #define memcmp(s1,s2,n) gforth_memcmp(s1,s2,n)
 #endif  #endif
   
 #ifdef HAS_FILE  
 char *cstr(Char *from, UCell size, int clear)  
 /* return a C-string corresponding to the Forth string ( FROM SIZE ).  
    the C-string lives until the next call of cstr with CLEAR being true */  
 {  
   static struct cstr_buffer {  
     char *buffer;  
     size_t size;  
   } *buffers=NULL;  
   static int nbuffers=0;  
   static int used=0;  
   struct cstr_buffer *b;  
   
   if (buffers==NULL)  
     buffers=malloc(0);  
   if (clear)  
     used=0;  
   if (used>=nbuffers) {  
     buffers=realloc(buffers,sizeof(struct cstr_buffer)*(used+1));  
     buffers[used]=(struct cstr_buffer){malloc(0),0};  
     nbuffers=used+1;  
   }  
   b=&buffers[used];  
   if (size+1 > b->size) {  
     b->buffer = realloc(b->buffer,size+1);  
     b->size = size+1;  
   }  
   memcpy(b->buffer,from,size);  
   b->buffer[size]='\0';  
   used++;  
   return b->buffer;  
 }  
   
 char *tilde_cstr(Char *from, UCell size, int clear)  
 /* like cstr(), but perform tilde expansion on the string */  
 {  
   char *s1,*s2;  
   int s1_len, s2_len;  
   struct passwd *getpwnam (), *user_entry;  
   
   if (size<1 || from[0]!='~')  
     return cstr(from, size, clear);  
   if (size<2 || from[1]=='/') {  
     s1 = (char *)getenv ("HOME");  
     if(s1 == NULL)  
       s1 = "";  
     s2 = from+1;  
     s2_len = size-1;  
   } else {  
     UCell i;  
     for (i=1; i<size && from[i]!='/'; i++)  
       ;  
     if (i==2 && from[1]=='+') /* deal with "~+", i.e., the wd */  
       return cstr(from+3, size<3?0:size-3,clear);  
     {  
       char user[i];  
       memcpy(user,from+1,i-1);  
       user[i-1]='\0';  
       user_entry=getpwnam(user);  
     }  
     if (user_entry==NULL)  
       return cstr(from, size, clear);  
     s1 = user_entry->pw_dir;  
     s2 = from+i;  
     s2_len = size-i;  
   }  
   s1_len = strlen(s1);  
   if (s1_len>1 && s1[s1_len-1]=='/')  
     s1_len--;  
   {  
     char path[s1_len+s2_len];  
     memcpy(path,s1,s1_len);  
     memcpy(path+s1_len,s2,s2_len);  
     return cstr(path,s1_len+s2_len,clear);  
   }  
 }  
 #endif  
   
 DCell timeval2us(struct timeval *tvp)  
 {  
 #ifndef BUGGY_LONG_LONG  
   return (tvp->tv_sec*(DCell)1000000)+tvp->tv_usec;  
 #else  
   DCell d2;  
   DCell d1=mmul(tvp->tv_sec,1000000);  
   d2.lo = d1.lo+tvp->tv_usec;  
   d2.hi = d1.hi + (d2.lo<d1.lo);  
   return d2;  
 #endif  
 }  
   
 #define NEWLINE '\n'  #define NEWLINE '\n'
   
 #ifndef HAVE_RINT  
 #define rint(x) floor((x)+0.5)  
 #endif  
   
 #ifdef HAS_FILE  
 static char* fileattr[6]={"rb","rb","r+b","r+b","wb","wb"};  
 static char* pfileattr[6]={"r","r","r+","r+","w","w"};  
   
 #ifndef O_BINARY  
 #define O_BINARY 0  
 #endif  
 #ifndef O_TEXT  
 #define O_TEXT 0  
 #endif  
   
 static int ufileattr[6]= {  
   O_RDONLY|O_BINARY, O_RDONLY|O_BINARY,  
   O_RDWR  |O_BINARY, O_RDWR  |O_BINARY,  
   O_WRONLY|O_BINARY, O_WRONLY|O_BINARY };  
 #endif  
   
 /* conversion on fetch */  /* conversion on fetch */
   
 #define vm_Cell2f(x)            ((Bool)(x))  #define vm_Cell2f(_cell,_x)             ((_x)=(Bool)(_cell))
 #define vm_Cell2c(x)            ((Char)(x))  #define vm_Cell2c(_cell,_x)             ((_x)=(Char)(_cell))
 #define vm_Cell2n(x)            ((Cell)x)  #define vm_Cell2n(_cell,_x)             ((_x)=(Cell)(_cell))
 #define vm_Cell2w(x)            ((Cell)x)  #define vm_Cell2w(_cell,_x)             ((_x)=(Cell)(_cell))
 #define vm_Cell2u(x)            ((UCell)(x))  #define vm_Cell2u(_cell,_x)             ((_x)=(UCell)(_cell))
 #define vm_Cell2a_(x)           ((Cell *)(x))  #define vm_Cell2a_(_cell,_x)            ((_x)=(Cell *)(_cell))
 #define vm_Cell2c_(x)           ((Char *)(x))  #define vm_Cell2c_(_cell,_x)            ((_x)=(Char *)(_cell))
 #define vm_Cell2f_(x)           ((Float *)(x))  #define vm_Cell2f_(_cell,_x)            ((_x)=(Float *)(_cell))
 #define vm_Cell2df_(x)          ((DFloat *)(x))  #define vm_Cell2df_(_cell,_x)           ((_x)=(DFloat *)(_cell))
 #define vm_Cell2sf_(x)          ((SFloat *)(x))  #define vm_Cell2sf_(_cell,_x)           ((_x)=(SFloat *)(_cell))
 #define vm_Cell2xt(x)           ((Xt)(x))  #define vm_Cell2xt(_cell,_x)            ((_x)=(Xt)(_cell))
 #define vm_Cell2f83name(x)      ((struct F83Name *)(x))  #define vm_Cell2f83name(_cell,_x)       ((_x)=(struct F83Name *)(_cell))
 #define vm_Cell2longname(x)     ((struct Longname *)(x))  #define vm_Cell2longname(_cell,_x)      ((_x)=(struct Longname *)(_cell))
 #define vm_Float2r(x)   (x)  #define vm_Float2r(_float,_x)           (_x=_float)
   
 /* conversion on store */  /* conversion on store */
   
 #define vm_f2Cell(x)            ((Cell)(x))  #define vm_f2Cell(_x,_cell)             ((_cell)=(Cell)(_x))
 #define vm_c2Cell(x)            ((Cell)(x))  #define vm_c2Cell(_x,_cell)             ((_cell)=(Cell)(_x))
 #define vm_n2Cell(x)            ((Cell)(x))  #define vm_n2Cell(_x,_cell)             ((_cell)=(Cell)(_x))
 #define vm_w2Cell(x)            ((Cell)(x))  #define vm_w2Cell(_x,_cell)             ((_cell)=(Cell)(_x))
 #define vm_u2Cell(x)            ((Cell)(x))  #define vm_u2Cell(_x,_cell)             ((_cell)=(Cell)(_x))
 #define vm_a_2Cell(x)           ((Cell)(x))  #define vm_a_2Cell(_x,_cell)            ((_cell)=(Cell)(_x))
 #define vm_c_2Cell(x)           ((Cell)(x))  #define vm_c_2Cell(_x,_cell)            ((_cell)=(Cell)(_x))
 #define vm_f_2Cell(x)           ((Cell)(x))  #define vm_f_2Cell(_x,_cell)            ((_cell)=(Cell)(_x))
 #define vm_df_2Cell(x)          ((Cell)(x))  #define vm_df_2Cell(_x,_cell)           ((_cell)=(Cell)(_x))
 #define vm_sf_2Cell(x)          ((Cell)(x))  #define vm_sf_2Cell(_x,_cell)           ((_cell)=(Cell)(_x))
 #define vm_xt2Cell(x)           ((Cell)(x))  #define vm_xt2Cell(_x,_cell)            ((_cell)=(Cell)(_x))
 #define vm_f83name2Cell(x)      ((Cell)(x))  #define vm_f83name2Cell(_x,_cell)       ((_cell)=(Cell)(_x))
 #define vm_longname2Cell(x)     ((Cell)(x))  #define vm_longname2Cell(_x,_cell)      ((_cell)=(Cell)(_x))
 #define vm_r2Float(x)   (x)  #define vm_r2Float(_x,_float)           (_float=_x)
   
 #define vm_Cell2Cell(x)         (x)  #define vm_Cell2Cell(_x,_y)             (_y=_x)
   
   #ifdef NO_IP
   #define IMM_ARG(access,value)           (VARIANT(value))
   #else
   #define IMM_ARG(access,value)           (access)
   #endif
   
 /* if machine.h has not defined explicit registers, define them as implicit */  /* if machine.h has not defined explicit registers, define them as implicit */
 #ifndef IPREG  #ifndef IPREG
Line 282  static int ufileattr[6]= { Line 174  static int ufileattr[6]= {
 # define CPU_DEP1 0  # define CPU_DEP1 0
 #endif  #endif
   
 /* declare and compute cfa for certain threading variants */  
 /* warning: this is nonsyntactical; it will not work in place of a statement */  
 #ifndef GETCFA  
 #define DOCFA  
 #else  
 #define DOCFA   Xt cfa; GETCFA(cfa)  
 #endif  
   
 /* instructions containing these must be the last instruction of a  /* instructions containing these must be the last instruction of a
    super-instruction (e.g., branches, EXECUTE, and other instructions     super-instruction (e.g., branches, EXECUTE, and other instructions
    ending the basic block). Instructions containing SET_IP get this     ending the basic block). Instructions containing SET_IP get this
Line 304  static int ufileattr[6]= { Line 188  static int ufileattr[6]= {
 #endif  #endif
 #define SUPER_CONTINUE  #define SUPER_CONTINUE
   
 #ifdef GFORTH_DEBUGGING  
 /* define some VM registers as global variables, so they survive exceptions;  
    global register variables are not up to the task (according to the   
    GNU C manual) */  
 Xt *ip;  
 Cell *rp;  
 #endif  
   
 #ifdef DEBUG  #ifdef DEBUG
 #define CFA_TO_NAME(__cfa) \  #define CFA_TO_NAME(__cfa) \
       Cell len, i; \        Cell len, i; \
Line 326  Cell *rp; Line 202  Cell *rp;
       }        }
 #endif  #endif
   
 Xt *primtable(Label symbols[], Cell size)  #if !defined(ENGINE)
 {  /* normal engine */
 #ifdef DIRECT_THREADED  #define VARIANT(v)      (v)
   return symbols;  #define JUMP(target)    goto I_noop
 #else /* !defined(DIRECT_THREADED) */  #define LABEL(name) J_##name: asm(""); I_##name:
   Xt *xts = (Xt *)malloc(size*sizeof(Xt));  
   Cell i;  #elif ENGINE==2
   /* variant with padding between VM instructions for finding out
   for (i=0; i<size; i++)     cross-inst jumps (for dynamic code) */
     xts[i] = &symbols[i];  #define engine engine2
   return xts;  #define VARIANT(v)      (v)
 #endif /* !defined(DIRECT_THREADED) */  #define JUMP(target)    goto I_noop
 }  #define LABEL(name) J_##name: SKIP16; I_##name:
   #define IN_ENGINE2
   
   #elif ENGINE==3
   /* variant with different immediate arguments for finding out
      immediate arguments (for native code) */
   #define engine engine3
   #define VARIANT(v)      ((v)^0xffffffff)
   #define JUMP(target)    goto K_lit
   #define LABEL(name) J_##name: asm(""); I_##name:
   #else
   #error illegal ENGINE value
   #endif /* ENGINE */
   
   #define LABEL2(name) K_##name:
   
 define(enginerest,  
 `(Xt *ip0, Cell *sp0, Cell *rp0, Float *fp0, Address lp0)  Label *engine(Xt *ip0, Cell *sp0, Cell *rp0, Float *fp0, Address lp0)
 /* executes code at ip, if ip!=NULL  /* executes code at ip, if ip!=NULL
    returns array of machine code labels (for use in a loader), if ip==NULL     returns array of machine code labels (for use in a loader), if ip==NULL
 */  */
 {  {
 #ifndef GFORTH_DEBUGGING  #ifndef GFORTH_DEBUGGING
   register Xt *ip IPREG;  
   register Cell *rp RPREG;    register Cell *rp RPREG;
 #endif  #endif
   #ifndef NO_IP
     register Xt *ip IPREG = ip0;
   #endif
   register Cell *sp SPREG = sp0;    register Cell *sp SPREG = sp0;
   register Float *fp FPREG = fp0;    register Float *fp FPREG = fp0;
   register Address lp LPREG = lp0;    register Address lp LPREG = lp0;
 #ifdef CFA_NEXT  
   register Xt cfa CFAREG;    register Xt cfa CFAREG;
 #endif  
 #ifdef MORE_VARS  #ifdef MORE_VARS
   MORE_VARS    MORE_VARS
 #endif  #endif
Line 381  define(enginerest, Line 270  define(enginerest,
     /* the following entry is normally unused;      /* the following entry is normally unused;
        it is there because its index indicates a does-handler */         it is there because its index indicates a does-handler */
     CPU_DEP1,      CPU_DEP1,
 #define INST_ADDR(name) (Label)&&I_##name  #define INST_ADDR(name) ((Label)&&I_##name)
 #include "prim_lab.i"  #include "prim_lab.i"
 #undef INST_ADDR  #undef INST_ADDR
     (Label)&&after_last,      (Label)&&after_last,
     (Label)0,      (Label)0,
 #ifdef IN_ENGINE2  #define INST_ADDR(name) ((Label)&&K_##name)
 #define INST_ADDR(name) (Label)&&J_##name  #include "prim_lab.i"
   #undef INST_ADDR
   #define INST_ADDR(name) ((Label)&&J_##name)
 #include "prim_lab.i"  #include "prim_lab.i"
 #undef INST_ADDR  #undef INST_ADDR
 #endif  
   };    };
 #ifdef CPU_DEP2  #ifdef CPU_DEP2
   CPU_DEP2    CPU_DEP2
 #endif  #endif
   
   ip = ip0;  
   rp = rp0;    rp = rp0;
 #ifdef DEBUG  #ifdef DEBUG
   fprintf(stderr,"ip=%x, sp=%x, rp=%x, fp=%x, lp=%x, up=%x\n",    fprintf(stderr,"ip=%x, sp=%x, rp=%x, fp=%x, lp=%x, up=%x\n",
           (unsigned)ip,(unsigned)sp,(unsigned)rp,            (unsigned)ip0,(unsigned)sp,(unsigned)rp,
           (unsigned)fp,(unsigned)lp,(unsigned)up);            (unsigned)fp,(unsigned)lp,(unsigned)up);
 #endif  #endif
   
   if (ip == NULL) {    if (ip0 == NULL) {
 #if defined(DOUBLY_INDIRECT)  #if defined(DOUBLY_INDIRECT)
 #define CODE_OFFSET (22*sizeof(Cell))  #define CODE_OFFSET (26*sizeof(Cell))
   #define XT_OFFSET (22*sizeof(Cell))
     int i;      int i;
     Cell code_offset = offset_image? CODE_OFFSET : 0;      Cell code_offset = offset_image? CODE_OFFSET : 0;
       Cell xt_offset = offset_image? XT_OFFSET : 0;
   
     symbols = (Label *)(malloc(MAX_SYMBOLS*sizeof(Cell)+CODE_OFFSET)+code_offset);      symbols = (Label *)(malloc(MAX_SYMBOLS*sizeof(Cell)+CODE_OFFSET)+code_offset);
       xts = (Label *)(malloc(MAX_SYMBOLS*sizeof(Cell)+XT_OFFSET)+xt_offset);
     for (i=0; i<DOESJUMP+1; i++)      for (i=0; i<DOESJUMP+1; i++)
       symbols[i] = (Label)routines[i];        xts[i] = symbols[i] = (Label)routines[i];
     for (; routines[i]!=0; i++) {      for (; routines[i]!=0; i++) {
       if (i>=MAX_SYMBOLS) {        if (i>=MAX_SYMBOLS) {
         fprintf(stderr,"gforth-ditc: more than %d primitives\n",MAX_SYMBOLS);          fprintf(stderr,"gforth-ditc: more than %d primitives\n",MAX_SYMBOLS);
         exit(1);          exit(1);
       }        }
       symbols[i] = &routines[i];        xts[i] = symbols[i] = &routines[i];
     }      }
 #endif /* defined(DOUBLY_INDIRECT) */  #endif /* defined(DOUBLY_INDIRECT) */
     return symbols;      return symbols;
Line 427  define(enginerest, Line 319  define(enginerest,
   IF_spTOS(spTOS = sp[0]);    IF_spTOS(spTOS = sp[0]);
   IF_fpTOS(fpTOS = fp[0]);    IF_fpTOS(fpTOS = fp[0]);
 /*  prep_terminal(); */  /*  prep_terminal(); */
   #ifdef NO_IP
     goto *(*(Label *)ip0);
   #else
   SET_IP(ip);    SET_IP(ip);
   SUPER_END; /* count the first block, too */    SUPER_END; /* count the first block, too */
   NEXT;    NEXT;
   #endif
   
 #ifdef CPU_DEP3  #ifdef CPU_DEP3
   CPU_DEP3    CPU_DEP3
Line 438  define(enginerest, Line 333  define(enginerest,
       
  docol:   docol:
   {    {
     DOCFA;  #ifdef NO_IP
       *--rp = next_code;
       goto **(Label *)PFA1(cfa);
   #else
 #ifdef DEBUG  #ifdef DEBUG
     {      {
       CFA_TO_NAME(cfa);        CFA_TO_NAME(cfa);
Line 464  define(enginerest, Line 362  define(enginerest,
       NEXT_P2;        NEXT_P2;
     }      }
 #endif  #endif
   #endif
   }    }
   
  docon:   docon:
   {    {
     DOCFA;  
 #ifdef DEBUG  #ifdef DEBUG
     fprintf(stderr,"%08lx: con: %08lx\n",(Cell)ip,*(Cell*)PFA1(cfa));      fprintf(stderr,"%08lx: con: %08lx\n",(Cell)ip,*(Cell*)PFA1(cfa));
 #endif  #endif
Line 479  define(enginerest, Line 377  define(enginerest,
     *--sp = *(Cell *)PFA1(cfa);      *--sp = *(Cell *)PFA1(cfa);
 #endif  #endif
   }    }
   #ifdef NO_IP
     goto *next_code;
   #else
   NEXT_P0;    NEXT_P0;
   NEXT;    NEXT;
   #endif
       
  dovar:   dovar:
   {    {
     DOCFA;  
 #ifdef DEBUG  #ifdef DEBUG
     fprintf(stderr,"%08lx: var: %08lx\n",(Cell)ip,(Cell)PFA1(cfa));      fprintf(stderr,"%08lx: var: %08lx\n",(Cell)ip,(Cell)PFA1(cfa));
 #endif  #endif
Line 495  define(enginerest, Line 396  define(enginerest,
     *--sp = (Cell)PFA1(cfa);      *--sp = (Cell)PFA1(cfa);
 #endif  #endif
   }    }
   #ifdef NO_IP
     goto *next_code;
   #else
   NEXT_P0;    NEXT_P0;
   NEXT;    NEXT;
   #endif
       
  douser:   douser:
   {    {
     DOCFA;  
 #ifdef DEBUG  #ifdef DEBUG
     fprintf(stderr,"%08lx: user: %08lx\n",(Cell)ip,(Cell)PFA1(cfa));      fprintf(stderr,"%08lx: user: %08lx\n",(Cell)ip,(Cell)PFA1(cfa));
 #endif  #endif
Line 511  define(enginerest, Line 415  define(enginerest,
     *--sp = (Cell)(up+*(Cell*)PFA1(cfa));      *--sp = (Cell)(up+*(Cell*)PFA1(cfa));
 #endif  #endif
   }    }
   #ifdef NO_IP
     goto *next_code;
   #else
   NEXT_P0;    NEXT_P0;
   NEXT;    NEXT;
   #endif
       
  dodefer:   dodefer:
   {    {
     DOCFA;  
 #ifdef DEBUG  #ifdef DEBUG
     fprintf(stderr,"%08lx: defer: %08lx\n",(Cell)ip,*(Cell*)PFA1(cfa));      fprintf(stderr,"%08lx: defer: %08lx\n",(Cell)ip,*(Cell*)PFA1(cfa));
 #endif  #endif
Line 526  define(enginerest, Line 433  define(enginerest,
   
  dofield:   dofield:
   {    {
     DOCFA;  
 #ifdef DEBUG  #ifdef DEBUG
     fprintf(stderr,"%08lx: field: %08lx\n",(Cell)ip,(Cell)PFA1(cfa));      fprintf(stderr,"%08lx: field: %08lx\n",(Cell)ip,(Cell)PFA1(cfa));
 #endif  #endif
     spTOS += *(Cell*)PFA1(cfa);      spTOS += *(Cell*)PFA1(cfa);
   }    }
   #ifdef NO_IP
     goto *next_code;
   #else
   NEXT_P0;    NEXT_P0;
   NEXT;    NEXT;
   #endif
   
  dodoes:   dodoes:
   /* this assumes the following structure:    /* this assumes the following structure:
Line 553  define(enginerest, Line 463  define(enginerest,
      pfa:       pfa:
             
      */       */
   #ifdef NO_IP
     *--rp = next_code;
     IF_spTOS(spTOS = sp[0]);
     sp--;
     spTOS = (Cell)PFA(cfa);
     goto **(Label *)DOES_CODE1(cfa);
   #else
   {    {
     DOCFA;  
   
     /*    fprintf(stderr, "Got CFA %08lx at doescode %08lx/%08lx: does: %08lx\n",cfa,(Cell)ip,(Cell)PFA(cfa),(Cell)DOES_CODE1(cfa));*/      /*    fprintf(stderr, "Got CFA %08lx at doescode %08lx/%08lx: does: %08lx\n",cfa,(Cell)ip,(Cell)PFA(cfa),(Cell)DOES_CODE1(cfa));*/
 #ifdef DEBUG  #ifdef DEBUG
     fprintf(stderr,"%08lx/%08lx: does: %08lx\n",(Cell)ip,(Cell)PFA(cfa),(Cell)DOES_CODE1(cfa));      fprintf(stderr,"%08lx/%08lx: does: %08lx\n",(Cell)ip,(Cell)PFA(cfa),(Cell)DOES_CODE1(cfa));
Line 574  define(enginerest, Line 489  define(enginerest,
     /*    fprintf(stderr,"TOS = %08lx, IP=%08lx\n", spTOS, IP);*/      /*    fprintf(stderr,"TOS = %08lx, IP=%08lx\n", spTOS, IP);*/
   }    }
   NEXT;    NEXT;
   
 #ifndef IN_ENGINE2  
 #define LABEL(name) I_##name  
 #else  
 #define LABEL(name) J_##name: asm(".skip 16"); I_##name  
 #endif  #endif
   
 #include "prim.i"  #include "prim.i"
 #undef LABEL  
   after_last: return (Label *)0;    after_last: return (Label *)0;
   /*needed only to get the length of the last primitive */    /*needed only to get the length of the last primitive */
 }'  }
 )  
   
 Label *engine enginerest  
   
 #define IN_ENGINE2  
 Label *engine2 enginerest  
   

Removed from v.1.37  
changed lines
  Added in v.1.56


FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>