cb22561995-10-11Fredrik Hübinette (Hubbe) /*\
06983f1996-09-22Fredrik Hübinette (Hubbe) ||| This file a part of Pike, and is copyright by Fredrik Hubinette ||| Pike is distributed as GPL (General Public License)
cb22561995-10-11Fredrik Hübinette (Hubbe) ||| See the files COPYING and DISCLAIMER for more information. \*/
5267b71995-08-09Fredrik Hübinette (Hubbe) #include "global.h"
8c83371998-04-16Fredrik Hübinette (Hubbe) RCSID("$Id: interpret.c,v 1.78 1998/04/16 21:32:01 hubbe Exp $");
5267b71995-08-09Fredrik Hübinette (Hubbe) #include "interpret.h" #include "object.h" #include "program.h" #include "svalue.h" #include "array.h" #include "mapping.h" #include "error.h" #include "language.h" #include "stralloc.h"
06983f1996-09-22Fredrik Hübinette (Hubbe) #include "constants.h"
bb55f81997-03-16Fredrik Hübinette (Hubbe) #include "pike_macros.h"
06983f1996-09-22Fredrik Hübinette (Hubbe) #include "multiset.h"
5267b71995-08-09Fredrik Hübinette (Hubbe) #include "backend.h" #include "operators.h" #include "opcodes.h" #include "main.h" #include "lex.h"
06983f1996-09-22Fredrik Hübinette (Hubbe) #include "builtin_functions.h" #include "signal_handler.h" #include "gc.h"
07513e1996-10-04Fredrik Hübinette (Hubbe) #include "threads.h"
a29e021996-10-15Fredrik Hübinette (Hubbe) #include "callback.h"
9c6f7d1997-04-15Fredrik Hübinette (Hubbe) #include "fd_control.h"
5267b71995-08-09Fredrik Hübinette (Hubbe) 
349fcb1996-10-09Fredrik Hübinette (Hubbe) #include <fcntl.h>
8aeeb21996-11-19Fredrik Hübinette (Hubbe) #include <errno.h>
349fcb1996-10-09Fredrik Hübinette (Hubbe) 
b208c11996-08-03Fredrik Hübinette (Hubbe) #ifdef HAVE_MMAP #ifdef HAVE_SYS_TYPES_H #include <sys/types.h> #endif #ifdef HAVE_SYS_MMAN_H #include <sys/mman.h> #endif
06983f1996-09-22Fredrik Hübinette (Hubbe) #ifdef MAP_NORESERVE
b208c11996-08-03Fredrik Hübinette (Hubbe) #define USE_MMAP_FOR_STACK #endif #endif
189fd01997-01-28Fredrik Hübinette (Hubbe) /* * Define the default evaluator stack size, used for just about everything. */ #define EVALUATOR_STACK_SIZE 100000
c5016f1996-04-13Fredrik Hübinette (Hubbe) #define TRACE_LEN (100 + t_flag * 10)
5267b71995-08-09Fredrik Hübinette (Hubbe)  /* sp points to first unused value on stack * (much simpler than letting it point at the last used value.) */
b208c11996-08-03Fredrik Hübinette (Hubbe) struct svalue *sp; /* Current position */ struct svalue *evaluator_stack; /* Start of stack */
0f887e1996-08-12Fredrik Hübinette (Hubbe) int stack_size = EVALUATOR_STACK_SIZE;
3c9f631996-09-23Fredrik Hübinette (Hubbe) int evaluator_stack_malloced = 0;
5267b71995-08-09Fredrik Hübinette (Hubbe)  /* mark stack, used to store markers into the normal stack */
b208c11996-08-03Fredrik Hübinette (Hubbe) struct svalue **mark_sp; /* Current position */ struct svalue **mark_stack; /* Start of stack */
3c9f631996-09-23Fredrik Hübinette (Hubbe) int mark_stack_malloced = 0;
fa382f1996-06-21Fredrik Hübinette (Hubbe) 
be478c1997-08-30Henrik Grubbström (Grubba) void push_sp_mark(void)
36feac1997-03-06Fredrik Hübinette (Hubbe) { if(mark_sp == mark_stack + stack_size) error("No more mark stack!\n"); *mark_sp++=sp; }
be478c1997-08-30Henrik Grubbström (Grubba) int pop_sp_mark(void)
36feac1997-03-06Fredrik Hübinette (Hubbe) { #ifdef DEBUG if(mark_sp < mark_stack) fatal("Mark stack underflow!\n"); #endif return sp - *--mark_sp; }
fa382f1996-06-21Fredrik Hübinette (Hubbe) struct frame *fp; /* frame pointer */
05c7cd1997-07-19Fredrik Hübinette (Hubbe) #ifdef DEBUG static void gc_check_stack_callback(struct callback *foo, void *bar, void *gazonk) {
62d3e41998-04-05Fredrik Hübinette (Hubbe)  struct frame *f;
4694111997-11-07Fredrik Hübinette (Hubbe)  debug_gc_xmark_svalues(evaluator_stack,sp-evaluator_stack-1,"interpreter stack");
62d3e41998-04-05Fredrik Hübinette (Hubbe)  for(f=fp;f;f=f->parent_frame) { if(f->context.parent) gc_external_mark(f->context.parent); gc_external_mark(f->current_object); gc_external_mark(f->context.prog); }
05c7cd1997-07-19Fredrik Hübinette (Hubbe) } #endif
be478c1997-08-30Henrik Grubbström (Grubba) void init_interpreter(void)
fa382f1996-06-21Fredrik Hübinette (Hubbe) {
b208c11996-08-03Fredrik Hübinette (Hubbe) #ifdef USE_MMAP_FOR_STACK
349fcb1996-10-09Fredrik Hübinette (Hubbe)  static int fd = -1;
b208c11996-08-03Fredrik Hübinette (Hubbe) 
05c7cd1997-07-19Fredrik Hübinette (Hubbe) 
b208c11996-08-03Fredrik Hübinette (Hubbe) #ifndef MAP_VARIABLE #define MAP_VARIABLE 0 #endif #ifndef MAP_PRIVATE #define MAP_PRIVATE 0 #endif
3c9f631996-09-23Fredrik Hübinette (Hubbe) #ifndef MAP_FAILED #define MAP_FAILED -1 #endif
349fcb1996-10-09Fredrik Hübinette (Hubbe) #ifndef MAP_ANONYMOUS
b208c11996-08-03Fredrik Hübinette (Hubbe) #define MAP_ANONYMOUS 0
349fcb1996-10-09Fredrik Hübinette (Hubbe)  if(fd == -1) {
cf39c21996-11-18Fredrik Hübinette (Hubbe)  while(1) { fd=open("/dev/zero",O_RDONLY); if(fd >= 0) break; if(errno != EINTR)
d77dfb1996-11-21Fredrik Hübinette (Hubbe)  { evaluator_stack=0; mark_stack=0; goto use_malloc; }
cf39c21996-11-18Fredrik Hübinette (Hubbe)  }
c36b851997-11-01Henrik Grubbström (Grubba)  /* Don't keep this fd on exec() */ set_close_on_exec(fd, 1);
349fcb1996-10-09Fredrik Hübinette (Hubbe)  }
b208c11996-08-03Fredrik Hübinette (Hubbe) #endif
06983f1996-09-22Fredrik Hübinette (Hubbe) #define MMALLOC(X,Y) (Y *)mmap(0,X*sizeof(Y),PROT_READ|PROT_WRITE, MAP_NORESERVE | MAP_PRIVATE | MAP_ANONYMOUS, fd, 0)
b208c11996-08-03Fredrik Hübinette (Hubbe) 
07513e1996-10-04Fredrik Hübinette (Hubbe)  evaluator_stack_malloced=0; mark_stack_malloced=0;
0f887e1996-08-12Fredrik Hübinette (Hubbe)  evaluator_stack=MMALLOC(stack_size,struct svalue); mark_stack=MMALLOC(stack_size, struct svalue *);
349fcb1996-10-09Fredrik Hübinette (Hubbe)  if((char *)MAP_FAILED == (char *)evaluator_stack) evaluator_stack=0;
3c9f631996-09-23Fredrik Hübinette (Hubbe)  if((char *)MAP_FAILED == (char *)mark_stack) mark_stack=0;
07513e1996-10-04Fredrik Hübinette (Hubbe) #else evaluator_stack=0; mark_stack=0;
b208c11996-08-03Fredrik Hübinette (Hubbe) #endif
07513e1996-10-04Fredrik Hübinette (Hubbe) 
d77dfb1996-11-21Fredrik Hübinette (Hubbe) use_malloc:
3c9f631996-09-23Fredrik Hübinette (Hubbe)  if(!evaluator_stack) {
07513e1996-10-04Fredrik Hübinette (Hubbe)  evaluator_stack=(struct svalue *)xalloc(stack_size*sizeof(struct svalue));
3c9f631996-09-23Fredrik Hübinette (Hubbe)  evaluator_stack_malloced=1; } if(!mark_stack) {
07513e1996-10-04Fredrik Hübinette (Hubbe)  mark_stack=(struct svalue **)xalloc(stack_size*sizeof(struct svalue *));
3c9f631996-09-23Fredrik Hübinette (Hubbe)  mark_stack_malloced=1; }
fa382f1996-06-21Fredrik Hübinette (Hubbe)  sp=evaluator_stack; mark_sp=mark_stack;
07513e1996-10-04Fredrik Hübinette (Hubbe)  fp=0;
62d3e41998-04-05Fredrik Hübinette (Hubbe)  #ifdef DEBUG { static struct callback *spcb; if(!spcb) { spcb=add_gc_callback(gc_check_stack_callback,0,0); } } #endif
fa382f1996-06-21Fredrik Hübinette (Hubbe) } void check_stack(INT32 size) {
0f887e1996-08-12Fredrik Hübinette (Hubbe)  if(sp - evaluator_stack + size >= stack_size)
fa382f1996-06-21Fredrik Hübinette (Hubbe)  error("Stack overflow.\n"); } void check_mark_stack(INT32 size) {
0f887e1996-08-12Fredrik Hübinette (Hubbe)  if(mark_sp - mark_stack + size >= stack_size)
fa382f1996-06-21Fredrik Hübinette (Hubbe)  error("Stack overflow.\n"); }
5267b71995-08-09Fredrik Hübinette (Hubbe) 
b1f4eb1998-01-13Fredrik Hübinette (Hubbe) static int eval_instruction(unsigned char *pc);
5267b71995-08-09Fredrik Hübinette (Hubbe)  /* * lvalues are stored in two svalues in one of these formats: * array[index] : { array, index } * mapping[index] : { mapping, index }
06983f1996-09-22Fredrik Hübinette (Hubbe)  * multiset[index] : { multiset, index }
b208c11996-08-03Fredrik Hübinette (Hubbe)  * object[index] : { object, index }
5267b71995-08-09Fredrik Hübinette (Hubbe)  * local variable : { svalue_pointer, nothing } * global variable : { svalue_pointer/short_svalue_pointer, nothing } */ void lvalue_to_svalue_no_free(struct svalue *to,struct svalue *lval) { switch(lval->type) {
2a32691998-01-31Fredrik Hübinette (Hubbe)  case T_ARRAY_LVALUE:
5267b71995-08-09Fredrik Hübinette (Hubbe)  {
2a32691998-01-31Fredrik Hübinette (Hubbe)  INT32 e; struct array *a; ONERROR err; a=allocate_array(lval[1].u.array->size>>1); SET_ONERROR(err, do_free_array, a); for(e=0;e<a->size;e++) lvalue_to_svalue_no_free(a->item+e, lval[1].u.array->item+(e<<1)); to->type = T_ARRAY; to->u.array=a; UNSET_ONERROR(err); break;
5267b71995-08-09Fredrik Hübinette (Hubbe)  }
2a32691998-01-31Fredrik Hübinette (Hubbe)  case T_LVALUE: assign_svalue_no_free(to, lval->u.lval); break; case T_SHORT_LVALUE: assign_from_short_svalue_no_free(to, lval->u.short_lval, lval->subtype); break; case T_OBJECT: object_index_no_free(to, lval->u.object, lval+1); break; case T_ARRAY: simple_array_index_no_free(to, lval->u.array, lval+1); break; case T_MAPPING: mapping_index_no_free(to, lval->u.mapping, lval+1); break; case T_MULTISET: to->type=T_INT; if(multiset_member(lval->u.multiset,lval+1)) { to->u.integer=0; to->subtype=NUMBER_UNDEFINED; }else{ to->u.integer=0; to->subtype=NUMBER_NUMBER; } break; default: if(IS_ZERO(lval)) error("Indexing the NULL value.\n"); /* Per */ else error("Indexing a basic type.\n");
5267b71995-08-09Fredrik Hübinette (Hubbe)  } } void assign_lvalue(struct svalue *lval,struct svalue *from) { switch(lval->type) {
2a32691998-01-31Fredrik Hübinette (Hubbe)  case T_ARRAY_LVALUE: { INT32 e; if(from->type != T_ARRAY) error("Trying to assign combined lvalue from non-array.\n"); if(from->u.array->size < (lval[1].u.array->size>>1)) error("Not enough values for multiple assign.\n"); for(e=0;e<from->u.array->size;e++) assign_lvalue(lval[1].u.array->item+(e<<1),from->u.array->item+e); } break;
5267b71995-08-09Fredrik Hübinette (Hubbe)  case T_LVALUE: assign_svalue(lval->u.lval,from); break; case T_SHORT_LVALUE: assign_to_short_svalue(lval->u.short_lval, lval->subtype, from); break; case T_OBJECT: object_set_index(lval->u.object, lval+1, from); break; case T_ARRAY: simple_set_index(lval->u.array, lval+1, from); break; case T_MAPPING: mapping_insert(lval->u.mapping, lval+1, from); break;
06983f1996-09-22Fredrik Hübinette (Hubbe)  case T_MULTISET:
5267b71995-08-09Fredrik Hübinette (Hubbe)  if(IS_ZERO(from))
06983f1996-09-22Fredrik Hübinette (Hubbe)  multiset_delete(lval->u.multiset, lval+1);
5267b71995-08-09Fredrik Hübinette (Hubbe)  else
06983f1996-09-22Fredrik Hübinette (Hubbe)  multiset_insert(lval->u.multiset, lval+1);
5267b71995-08-09Fredrik Hübinette (Hubbe)  break; default:
6ec27f1996-12-05Per Hedbor  if(IS_ZERO(lval)) error("Indexing the NULL value.\n"); /* Per */ else error("Indexing a basic type.\n");
5267b71995-08-09Fredrik Hübinette (Hubbe)  } } union anything *get_pointer_if_this_type(struct svalue *lval, TYPE_T t) { switch(lval->type) {
2a32691998-01-31Fredrik Hübinette (Hubbe)  case T_ARRAY_LVALUE: return 0; case T_LVALUE: if(lval->u.lval->type == t) return & ( lval->u.lval->u ); return 0; case T_SHORT_LVALUE: if(lval->subtype == t) return lval->u.short_lval; return 0; case T_OBJECT: return object_get_item_ptr(lval->u.object,lval+1,t); case T_ARRAY: return array_get_item_ptr(lval->u.array,lval+1,t); case T_MAPPING: return mapping_get_item_ptr(lval->u.mapping,lval+1,t);
5267b71995-08-09Fredrik Hübinette (Hubbe) 
2a32691998-01-31Fredrik Hübinette (Hubbe)  case T_MULTISET: return 0; default: if(IS_ZERO(lval)) error("Indexing the NULL value.\n"); /* Per */
6ec27f1996-12-05Per Hedbor  else error("Indexing a basic type.\n");
2a32691998-01-31Fredrik Hübinette (Hubbe)  return 0;
5267b71995-08-09Fredrik Hübinette (Hubbe)  } }
5683de1995-11-06Fredrik Hübinette (Hubbe) #ifdef DEBUG
be478c1997-08-30Henrik Grubbström (Grubba) void print_return_value(void)
5683de1995-11-06Fredrik Hübinette (Hubbe) { if(t_flag>3) { char *s; init_buf(); describe_svalue(sp-1,0,0); s=simple_free_buf(); if((long)strlen(s) > (long)TRACE_LEN) { s[TRACE_LEN]=0; s[TRACE_LEN-1]='.'; s[TRACE_LEN-2]='.'; s[TRACE_LEN-2]='.'; } fprintf(stderr,"- value: %s\n",s); free(s); } } #else
acc38d1995-11-20Fredrik Hübinette (Hubbe) #define print_return_value()
5683de1995-11-06Fredrik Hübinette (Hubbe) #endif
81b84e1996-12-03Fredrik Hübinette (Hubbe) struct callback_list evaluator_callbacks;
a29e021996-10-15Fredrik Hübinette (Hubbe) 
5267b71995-08-09Fredrik Hübinette (Hubbe) #ifdef DEBUG static char trace_buffer[100]; #define GET_ARG() (backlog[backlogp].arg=(\ instr=prefix,\ prefix=0,\ instr+=EXTRACT_UCHAR(pc++),\
2a50961995-08-23Fredrik Hübinette (Hubbe)  (t_flag>3 ? sprintf(trace_buffer,"- Arg = %ld\n",(long)instr),write_to_stderr(trace_buffer,strlen(trace_buffer)) : 0),\
5267b71995-08-09Fredrik Hübinette (Hubbe)  instr)) #else #define GET_ARG() (instr=prefix,prefix=0,instr+EXTRACT_UCHAR(pc++)) #endif #define CASE(X) case (X)-F_OFFSET:
06983f1996-09-22Fredrik Hübinette (Hubbe) #define DOJUMP() \
0a861b1997-09-17Fredrik Hübinette (Hubbe)  do { int tmp; tmp=EXTRACT_INT(pc); pc+=tmp; if(tmp < 0) fast_check_threads_etc(6); }while(0)
06983f1996-09-22Fredrik Hübinette (Hubbe) 
5267b71995-08-09Fredrik Hübinette (Hubbe) #define COMPARISMENT(ID,EXPR) \ CASE(ID); \ instr=EXPR; \ pop_n_elems(2); \
7961fb1997-10-10Fredrik Hübinette (Hubbe) push_int(instr); \ break
5267b71995-08-09Fredrik Hübinette (Hubbe) 
7961fb1997-10-10Fredrik Hübinette (Hubbe) #define LOOP(ID, OP1, OP2, OP3, OP4) \ CASE(ID) \ { \ union anything *i=get_pointer_if_this_type(sp-2, T_INT); \ if(i) \ { \ OP1 ( i->integer ); \ if(i->integer OP2 sp[-3].u.integer) \ { \ pc+=EXTRACT_INT(pc); \ fast_check_threads_etc(8); \ }else{ \ pc+=sizeof(INT32); \ } \ }else{ \ lvalue_to_svalue_no_free(sp-2,sp); sp++; \ push_int(1); \ OP3; \ assign_lvalue(sp-3,sp-1); \ if(OP4 ( sp-1, sp-4 )) \ { \ pc+=EXTRACT_INT(pc); \ fast_check_threads_etc(8); \ }else{ \ pc+=sizeof(INT32); \ } \ pop_stack(); \ } \ break; \
5267b71995-08-09Fredrik Hübinette (Hubbe) }
c5016f1996-04-13Fredrik Hübinette (Hubbe) #define CJUMP(X,Y) \ CASE(X); \ if(Y(sp-2,sp-1)) { \
06983f1996-09-22Fredrik Hübinette (Hubbe)  DOJUMP(); \
c5016f1996-04-13Fredrik Hübinette (Hubbe) }else{ \ pc+=sizeof(INT32); \ } \ pop_n_elems(2); \ break
5267b71995-08-09Fredrik Hübinette (Hubbe) /* * reset the stack machine. */
be478c1997-08-30Henrik Grubbström (Grubba) void reset_evaluator(void)
5267b71995-08-09Fredrik Hübinette (Hubbe) { fp=0; pop_n_elems(sp - evaluator_stack); } #ifdef DEBUG #define BACKLOG 512 struct backlog { INT32 instruction; INT32 arg; struct program *program; unsigned char *pc; }; struct backlog backlog[BACKLOG]; int backlogp=BACKLOG-1;
5c8e891995-10-29Fredrik Hübinette (Hubbe) void dump_backlog(void)
5267b71995-08-09Fredrik Hübinette (Hubbe) { int e; if(!d_flag || backlogp<0 || backlogp>=BACKLOG) return; e=backlogp; do { e++; if(e>=BACKLOG) e=0; if(backlog[e].program) { char *file; INT32 line; file=get_line(backlog[e].pc-1,backlog[e].program, &line); fprintf(stderr,"%s:%ld: %s(%ld)\n", file,
f90e541995-08-17Fredrik Hübinette (Hubbe)  (long)line,
5267b71995-08-09Fredrik Hübinette (Hubbe)  low_get_f_name(backlog[e].instruction + F_OFFSET, backlog[e].program),
f90e541995-08-17Fredrik Hübinette (Hubbe)  (long)backlog[e].arg);
5267b71995-08-09Fredrik Hübinette (Hubbe)  } }while(e!=backlogp);
cb22561995-10-11Fredrik Hübinette (Hubbe) }
5267b71995-08-09Fredrik Hübinette (Hubbe)  #endif
b208c11996-08-03Fredrik Hübinette (Hubbe) static int o_catch(unsigned char *pc);
b1f4eb1998-01-13Fredrik Hübinette (Hubbe) static int eval_instruction(unsigned char *pc)
5267b71995-08-09Fredrik Hübinette (Hubbe) {
b1f4eb1998-01-13Fredrik Hübinette (Hubbe)  unsigned INT32 accumulator=0,instr, prefix=0;
5267b71995-08-09Fredrik Hübinette (Hubbe)  while(1) { fp->pc = pc; instr=EXTRACT_UCHAR(pc++); #ifdef DEBUG if(d_flag) {
9649491998-02-27Fredrik Hübinette (Hubbe) #if defined(_REENTRANT) && !defined(__NT__)
e82b301997-01-29Fredrik Hübinette (Hubbe)  if(!mt_trylock(& interpreter_lock)) fatal("Interpreter running unlocked!\n"); #endif sp[0].type=99; /* an invalid type */ sp[1].type=99; sp[2].type=99; sp[3].type=99; if(sp<evaluator_stack || mark_sp < mark_stack || fp->locals>sp) fatal("Stack error (generic).\n"); if(sp > evaluator_stack+stack_size) fatal("Stack error (overflow).\n"); if(fp->fun>=0 && fp->current_object->prog && fp->locals+fp->num_locals > sp) fatal("Stack error (stupid!).\n");
294dc51997-08-03Fredrik Hübinette (Hubbe)  if(recoveries && sp-evaluator_stack < recoveries->sp) fatal("Stack error (underflow)\n");
e82b301997-01-29Fredrik Hübinette (Hubbe) 
21d2f71997-04-10Fredrik Hübinette (Hubbe)  if(d_flag > 9) do_debug();
5267b71995-08-09Fredrik Hübinette (Hubbe)  backlogp++; if(backlogp >= BACKLOG) backlogp=0; if(backlog[backlogp].program) free_program(backlog[backlogp].program); backlog[backlogp].program=fp->context.prog;
8c83371998-04-16Fredrik Hübinette (Hubbe)  add_ref(fp->context.prog);
5267b71995-08-09Fredrik Hübinette (Hubbe)  backlog[backlogp].instruction=instr; backlog[backlogp].arg=0; backlog[backlogp].pc=pc; } if(t_flag > 2) { char *file, *f;
cd83521998-02-02Fredrik Hübinette (Hubbe)  INT32 linep;
5267b71995-08-09Fredrik Hübinette (Hubbe)  file=get_line(pc-1,fp->context.prog,&linep);
0f887e1996-08-12Fredrik Hübinette (Hubbe)  while((f=STRCHR(file,'/'))) file=f+1;
f90e541995-08-17Fredrik Hübinette (Hubbe)  fprintf(stderr,"- %s:%4ld:(%lx): %-25s %4ld %4ld\n", file,(long)linep, (long)(pc-fp->context.prog->program-1),
5267b71995-08-09Fredrik Hübinette (Hubbe)  get_f_name(instr + F_OFFSET),
f90e541995-08-17Fredrik Hübinette (Hubbe)  (long)(sp-evaluator_stack), (long)(mark_sp-mark_stack));
5267b71995-08-09Fredrik Hübinette (Hubbe)  }
06983f1996-09-22Fredrik Hübinette (Hubbe)  if(instr + F_OFFSET < F_MAX_OPCODE) ADD_RUNNED(instr + F_OFFSET);
5267b71995-08-09Fredrik Hübinette (Hubbe) #endif
06983f1996-09-22Fredrik Hübinette (Hubbe) 
5267b71995-08-09Fredrik Hübinette (Hubbe)  switch(instr) { /* Support to allow large arguments */ CASE(F_PREFIX_256); prefix+=256; break; CASE(F_PREFIX_512); prefix+=512; break; CASE(F_PREFIX_768); prefix+=768; break; CASE(F_PREFIX_1024); prefix+=1024; break; CASE(F_PREFIX_24BITX256); prefix+=EXTRACT_UCHAR(pc++)<<24; CASE(F_PREFIX_WORDX256); prefix+=EXTRACT_UCHAR(pc++)<<16; CASE(F_PREFIX_CHARX256); prefix+=EXTRACT_UCHAR(pc++)<<8; break;
b1f4eb1998-01-13Fredrik Hübinette (Hubbe)  CASE(F_LDA); accumulator=GET_ARG(); break;
5267b71995-08-09Fredrik Hübinette (Hubbe)  /* Push number */
d3bef31996-11-27Fredrik Hübinette (Hubbe)  CASE(F_CONST0); push_int(0); break; CASE(F_CONST1); push_int(1); break; CASE(F_CONST_1); push_int(-1); break; CASE(F_BIGNUM); push_int(0x7fffffff); break; CASE(F_NUMBER); push_int(GET_ARG()); break; CASE(F_NEG_NUMBER); push_int(-GET_ARG()); break;
5267b71995-08-09Fredrik Hübinette (Hubbe)  /* The rest of the basic 'push value' instructions */
9b08a21998-03-31Fredrik Hübinette (Hubbe)  CASE(F_MARK_AND_STRING); *(mark_sp++)=sp;
5267b71995-08-09Fredrik Hübinette (Hubbe)  CASE(F_STRING); copy_shared_string(sp->u.string,fp->context.prog->strings[GET_ARG()]); sp->type=T_STRING;
dffa011997-01-15Fredrik Hübinette (Hubbe)  sp->subtype=0; sp++; print_return_value(); break; CASE(F_ARROW_STRING); copy_shared_string(sp->u.string,fp->context.prog->strings[GET_ARG()]); sp->type=T_STRING; sp->subtype=1; /* Magic */
5267b71995-08-09Fredrik Hübinette (Hubbe)  sp++;
5683de1995-11-06Fredrik Hübinette (Hubbe)  print_return_value();
5267b71995-08-09Fredrik Hübinette (Hubbe)  break; CASE(F_CONSTANT); assign_svalue_no_free(sp++,fp->context.prog->constants+GET_ARG());
5683de1995-11-06Fredrik Hübinette (Hubbe)  print_return_value();
5267b71995-08-09Fredrik Hübinette (Hubbe)  break; CASE(F_FLOAT); sp->type=T_FLOAT; MEMCPY((void *)&sp->u.float_number, pc, sizeof(FLOAT_TYPE)); pc+=sizeof(FLOAT_TYPE); sp++; break; CASE(F_LFUN); sp->u.object=fp->current_object;
8c83371998-04-16Fredrik Hübinette (Hubbe)  add_ref(fp->current_object);
5267b71995-08-09Fredrik Hübinette (Hubbe)  sp->subtype=GET_ARG()+fp->context.identifier_level; sp->type=T_FUNCTION; sp++;
8267f41998-01-28Fredrik Hübinette (Hubbe)  print_return_value();
5267b71995-08-09Fredrik Hübinette (Hubbe)  break; /* The not so basic 'push value' instructions */
d2c6081996-11-07Fredrik Hübinette (Hubbe)  CASE(F_GLOBAL); low_object_index_no_free(sp, fp->current_object, GET_ARG() + fp->context.identifier_level); sp++; print_return_value(); break;
5267b71995-08-09Fredrik Hübinette (Hubbe) 
b1f4eb1998-01-13Fredrik Hübinette (Hubbe)  CASE(F_EXTERNAL); { struct inherit *inherit; struct program *p;
61e9a01998-01-25Fredrik Hübinette (Hubbe)  struct object *o; INT32 i,id=GET_ARG(); inherit=&fp->context; o=fp->current_object; if(!o) error("Current object is destructed\n");
b1f4eb1998-01-13Fredrik Hübinette (Hubbe)  while(1) {
61e9a01998-01-25Fredrik Hübinette (Hubbe)  if(inherit->parent_offset)
b1f4eb1998-01-13Fredrik Hübinette (Hubbe)  { i=o->parent_identifier; o=o->parent;
61e9a01998-01-25Fredrik Hübinette (Hubbe)  accumulator+=inherit->parent_offset-1;
b1f4eb1998-01-13Fredrik Hübinette (Hubbe)  }else{ i=inherit->parent_identifier; o=inherit->parent; }
61e9a01998-01-25Fredrik Hübinette (Hubbe)  if(!o) error("Parent was lost during cloning.\n"); if(!(p=o->prog)) error("Attempting to access variable in destructed object\n"); inherit=INHERIT_FROM_INT(p, i); if(!accumulator) break; --accumulator;
b1f4eb1998-01-13Fredrik Hübinette (Hubbe)  } low_object_index_no_free(sp, o, id + inherit->identifier_level); sp++; print_return_value(); break; } CASE(F_EXTERNAL_LVALUE); { struct inherit *inherit; struct program *p;
61e9a01998-01-25Fredrik Hübinette (Hubbe)  struct object *o; INT32 i,id=GET_ARG(); inherit=&fp->context; o=fp->current_object;
b1f4eb1998-01-13Fredrik Hübinette (Hubbe) 
61e9a01998-01-25Fredrik Hübinette (Hubbe)  if(!o) error("Current object is destructed\n");
b1f4eb1998-01-13Fredrik Hübinette (Hubbe)  while(1) {
61e9a01998-01-25Fredrik Hübinette (Hubbe)  if(inherit->parent_offset) { i=o->parent_identifier; o=o->parent; accumulator+=inherit->parent_offset-1; }else{ i=inherit->parent_identifier; o=inherit->parent; }
b1f4eb1998-01-13Fredrik Hübinette (Hubbe)  if(!o) error("Parent no longer exists\n"); if(!(p=o->prog)) error("Attempting to access variable in destructed object\n"); inherit=INHERIT_FROM_INT(p, i); if(!accumulator) break; accumulator--; } ref_push_object(o); sp->type=T_LVALUE; sp->u.integer=id + inherit->identifier_level; sp++; break; }
e82b301997-01-29Fredrik Hübinette (Hubbe)  CASE(F_MARK_AND_LOCAL); *(mark_sp++)=sp;
5267b71995-08-09Fredrik Hübinette (Hubbe)  CASE(F_LOCAL); assign_svalue_no_free(sp++,fp->locals+GET_ARG());
5683de1995-11-06Fredrik Hübinette (Hubbe)  print_return_value();
5267b71995-08-09Fredrik Hübinette (Hubbe)  break;
e82b301997-01-29Fredrik Hübinette (Hubbe)  CASE(F_2_LOCALS); assign_svalue_no_free(sp++,fp->locals+GET_ARG()); print_return_value(); assign_svalue_no_free(sp++,fp->locals+GET_ARG()); print_return_value(); break;
5267b71995-08-09Fredrik Hübinette (Hubbe)  CASE(F_LOCAL_LVALUE); sp[0].type=T_LVALUE; sp[0].u.lval=fp->locals+GET_ARG(); sp[1].type=T_VOID; sp+=2; break;
2a32691998-01-31Fredrik Hübinette (Hubbe)  CASE(F_ARRAY_LVALUE); f_aggregate(GET_ARG()*2); sp[-1].u.array->flags |= ARRAY_LVALUE; sp[0]=sp[-1]; sp[-1].type=T_ARRAY_LVALUE; sp++; break;
e82b301997-01-29Fredrik Hübinette (Hubbe)  CASE(F_CLEAR_2_LOCAL); instr=GET_ARG(); free_svalues(fp->locals + instr, 2, -1); fp->locals[instr].type=T_INT; fp->locals[instr].subtype=0; fp->locals[instr].u.integer=0; fp->locals[instr+1].type=T_INT; fp->locals[instr+1].subtype=0; fp->locals[instr+1].u.integer=0; break;
9b08a21998-03-31Fredrik Hübinette (Hubbe)  CASE(F_CLEAR_4_LOCAL); { int e; instr=GET_ARG(); free_svalues(fp->locals + instr, 4, -1); for(e=0;e<4;e++) { fp->locals[instr+e].type=T_INT; fp->locals[instr+e].subtype=0; fp->locals[instr+e].u.integer=0; } break; }
c5016f1996-04-13Fredrik Hübinette (Hubbe)  CASE(F_CLEAR_LOCAL); instr=GET_ARG(); free_svalue(fp->locals + instr); fp->locals[instr].type=T_INT; fp->locals[instr].subtype=0; fp->locals[instr].u.integer=0; break; CASE(F_INC_LOCAL); instr=GET_ARG();
7961fb1997-10-10Fredrik Hübinette (Hubbe)  if(fp->locals[instr].type == T_INT) { fp->locals[instr].u.integer++; assign_svalue_no_free(sp++,fp->locals+instr); }else{ assign_svalue_no_free(sp++,fp->locals+instr); push_int(1); f_add(2); assign_svalue(fp->locals+instr,sp-1); }
c5016f1996-04-13Fredrik Hübinette (Hubbe)  break; CASE(F_POST_INC_LOCAL); instr=GET_ARG(); assign_svalue_no_free(sp++,fp->locals+instr);
7961fb1997-10-10Fredrik Hübinette (Hubbe)  goto inc_local_and_pop;
c5016f1996-04-13Fredrik Hübinette (Hubbe)  CASE(F_INC_LOCAL_AND_POP); instr=GET_ARG();
7961fb1997-10-10Fredrik Hübinette (Hubbe)  inc_local_and_pop: if(fp->locals[instr].type == T_INT) { fp->locals[instr].u.integer++; }else{ assign_svalue_no_free(sp++,fp->locals+instr); push_int(1); f_add(2); assign_svalue(fp->locals+instr,sp-1); pop_stack(); }
c5016f1996-04-13Fredrik Hübinette (Hubbe)  break; CASE(F_DEC_LOCAL); instr=GET_ARG();
7961fb1997-10-10Fredrik Hübinette (Hubbe)  if(fp->locals[instr].type == T_INT) { fp->locals[instr].u.integer--; assign_svalue_no_free(sp++,fp->locals+instr); }else{ assign_svalue_no_free(sp++,fp->locals+instr); push_int(1); o_subtract(); assign_svalue(fp->locals+instr,sp-1); }
c5016f1996-04-13Fredrik Hübinette (Hubbe)  break; CASE(F_POST_DEC_LOCAL); instr=GET_ARG();
b208c11996-08-03Fredrik Hübinette (Hubbe)  assign_svalue_no_free(sp++,fp->locals+instr);
7961fb1997-10-10Fredrik Hübinette (Hubbe)  goto dec_local_and_pop;
7cf59d1997-10-25Henrik Grubbström (Grubba)  /* fp->locals[instr].u.integer--; */
c5016f1996-04-13Fredrik Hübinette (Hubbe)  break; CASE(F_DEC_LOCAL_AND_POP); instr=GET_ARG();
7961fb1997-10-10Fredrik Hübinette (Hubbe)  dec_local_and_pop: if(fp->locals[instr].type == T_INT) { fp->locals[instr].u.integer--; }else{ assign_svalue_no_free(sp++,fp->locals+instr); push_int(1); o_subtract(); assign_svalue(fp->locals+instr,sp-1); pop_stack(); }
c5016f1996-04-13Fredrik Hübinette (Hubbe)  break;
5267b71995-08-09Fredrik Hübinette (Hubbe)  CASE(F_LTOSVAL); lvalue_to_svalue_no_free(sp,sp-2); sp++; break; CASE(F_LTOSVAL2); sp[0]=sp[-1]; lvalue_to_svalue_no_free(sp-1,sp-3); /* this is so that foo+=bar (and similar things) will be faster, this * is done by freeing the old reference to foo after it has been pushed * on the stack. That way foo can have only 1 reference if we are lucky,
06983f1996-09-22Fredrik Hübinette (Hubbe)  * and then the low array/multiset/mapping manipulation routines can be
5267b71995-08-09Fredrik Hübinette (Hubbe)  * destructive if they like */
74b6991997-01-26Fredrik Hübinette (Hubbe)  if( (1 << sp[-1].type) & ( BIT_ARRAY | BIT_MULTISET | BIT_MAPPING | BIT_STRING ))
5267b71995-08-09Fredrik Hübinette (Hubbe)  { struct svalue s; s.type=T_INT;
0d3e6f1995-11-15Fredrik Hübinette (Hubbe)  s.subtype=0;
5267b71995-08-09Fredrik Hübinette (Hubbe)  s.u.integer=0; assign_lvalue(sp-3,&s); } sp++; break;
156fd51997-10-27Fredrik Hübinette (Hubbe)  CASE(F_ADD_TO_AND_POP); sp[0]=sp[-1]; lvalue_to_svalue_no_free(sp-1,sp-3); /* this is so that foo+=bar (and similar things) will be faster, this * is done by freeing the old reference to foo after it has been pushed * on the stack. That way foo can have only 1 reference if we are lucky, * and then the low array/multiset/mapping manipulation routines can be * destructive if they like */ if( (1 << sp[-1].type) & ( BIT_ARRAY | BIT_MULTISET | BIT_MAPPING | BIT_STRING )) { struct svalue s; s.type=T_INT; s.subtype=0; s.u.integer=0; assign_lvalue(sp-3,&s); } sp++; f_add(2); assign_lvalue(sp-3,sp-1); pop_n_elems(3); break;
6bc9281998-04-10Fredrik Hübinette (Hubbe)  CASE(F_GLOBAL_LVALUE);
5267b71995-08-09Fredrik Hübinette (Hubbe)  { struct identifier *i; INT32 tmp=GET_ARG() + fp->context.identifier_level; if(!fp->current_object->prog) error("Cannot access global variables in destructed object.\n"); i=ID_FROM_INT(fp->current_object->prog, tmp);
d2c6081996-11-07Fredrik Hübinette (Hubbe) 
7fda7a1997-09-08Fredrik Hübinette (Hubbe)  if(!IDENTIFIER_IS_VARIABLE(i->identifier_flags))
d2c6081996-11-07Fredrik Hübinette (Hubbe)  error("Cannot re-assign functions or constants.\n");
5267b71995-08-09Fredrik Hübinette (Hubbe)  if(i->run_time_type == T_MIXED) { sp[0].type=T_LVALUE; sp[0].u.lval=(struct svalue *)GLOBAL_FROM_INT(tmp); }else{ sp[0].type=T_SHORT_LVALUE; sp[0].u.short_lval= (union anything *)GLOBAL_FROM_INT(tmp); sp[0].subtype=i->run_time_type; } sp[1].type=T_VOID; sp+=2; break; }
7961fb1997-10-10Fredrik Hübinette (Hubbe)  CASE(F_INC); { union anything *u=get_pointer_if_this_type(sp-2, T_INT); if(u) { instr=++ u->integer; pop_n_elems(2); push_int(u->integer); }else{ lvalue_to_svalue_no_free(sp, sp-2); sp++; push_int(1); f_add(2); assign_lvalue(sp-3, sp-1); assign_svalue(sp-3, sp-1); pop_n_elems(2); } break; } CASE(F_DEC); { union anything *u=get_pointer_if_this_type(sp-2, T_INT); if(u) { instr=-- u->integer; pop_n_elems(2); push_int(u->integer); }else{ lvalue_to_svalue_no_free(sp, sp-2); sp++; push_int(1); o_subtract(); assign_lvalue(sp-3, sp-1); assign_svalue(sp-3, sp-1); pop_n_elems(2); } break; } CASE(F_DEC_AND_POP); { union anything *u=get_pointer_if_this_type(sp-2, T_INT); if(u) { instr=-- u->integer; pop_n_elems(2); }else{ lvalue_to_svalue_no_free(sp, sp-2); sp++; push_int(1); o_subtract(); assign_lvalue(sp-3, sp-1); pop_n_elems(3); } break; } CASE(F_INC_AND_POP); { union anything *u=get_pointer_if_this_type(sp-2, T_INT); if(u) { instr=++ u->integer; pop_n_elems(2); }else{ lvalue_to_svalue_no_free(sp, sp-2); sp++; push_int(1); f_add(2); assign_lvalue(sp-3, sp-1); pop_n_elems(3); } break; } CASE(F_POST_INC); { union anything *u=get_pointer_if_this_type(sp-2, T_INT); if(u) { instr=u->integer ++; pop_n_elems(2); push_int(instr); }else{ lvalue_to_svalue_no_free(sp, sp-2); sp++;
3fadf81997-10-13Fredrik Hübinette (Hubbe)  assign_svalue_no_free(sp,sp-1); sp++;
7961fb1997-10-10Fredrik Hübinette (Hubbe)  push_int(1); f_add(2); assign_lvalue(sp-4, sp-1); assign_svalue(sp-4, sp-2); pop_n_elems(3); } break; } CASE(F_POST_DEC); { union anything *u=get_pointer_if_this_type(sp-2, T_INT); if(u) { instr=u->integer --; pop_n_elems(2); push_int(instr); }else{ lvalue_to_svalue_no_free(sp, sp-2); sp++;
3fadf81997-10-13Fredrik Hübinette (Hubbe)  assign_svalue_no_free(sp,sp-1); sp++;
7961fb1997-10-10Fredrik Hübinette (Hubbe)  push_int(1); o_subtract(); assign_lvalue(sp-4, sp-1); assign_svalue(sp-4, sp-2); pop_n_elems(3); } break; }
5267b71995-08-09Fredrik Hübinette (Hubbe)  CASE(F_ASSIGN); assign_lvalue(sp-3,sp-1); free_svalue(sp-3); free_svalue(sp-2); sp[-3]=sp[-1]; sp-=2; break; CASE(F_ASSIGN_AND_POP); assign_lvalue(sp-3,sp-1); pop_n_elems(3); break;
9b08a21998-03-31Fredrik Hübinette (Hubbe)  CASE(F_APPLY_ASSIGN_LOCAL); strict_apply_svalue(fp->context.prog->constants + GET_ARG(), sp - *--mark_sp ); /* Fall through */
5267b71995-08-09Fredrik Hübinette (Hubbe)  CASE(F_ASSIGN_LOCAL); assign_svalue(fp->locals+GET_ARG(),sp-1); break;
9b08a21998-03-31Fredrik Hübinette (Hubbe)  CASE(F_APPLY_ASSIGN_LOCAL_AND_POP); strict_apply_svalue(fp->context.prog->constants + GET_ARG(), sp - *--mark_sp ); /* Fall through */
5267b71995-08-09Fredrik Hübinette (Hubbe)  CASE(F_ASSIGN_LOCAL_AND_POP); instr=GET_ARG(); free_svalue(fp->locals+instr);
5683de1995-11-06Fredrik Hübinette (Hubbe)  fp->locals[instr]=sp[-1]; sp--;
5267b71995-08-09Fredrik Hübinette (Hubbe)  break; CASE(F_ASSIGN_GLOBAL) { struct identifier *i; INT32 tmp=GET_ARG() + fp->context.identifier_level; if(!fp->current_object->prog) error("Cannot access global variables in destructed object.\n"); i=ID_FROM_INT(fp->current_object->prog, tmp);
7fda7a1997-09-08Fredrik Hübinette (Hubbe)  if(!IDENTIFIER_IS_VARIABLE(i->identifier_flags))
f68aec1997-03-23Fredrik Hübinette (Hubbe)  error("Cannot assign functions or constants.\n");
5267b71995-08-09Fredrik Hübinette (Hubbe)  if(i->run_time_type == T_MIXED) { assign_svalue((struct svalue *)GLOBAL_FROM_INT(tmp), sp-1); }else{ assign_to_short_svalue((union anything *)GLOBAL_FROM_INT(tmp), i->run_time_type, sp-1); } } break; CASE(F_ASSIGN_GLOBAL_AND_POP) { struct identifier *i; INT32 tmp=GET_ARG() + fp->context.identifier_level; if(!fp->current_object->prog) error("Cannot access global variables in destructed object.\n"); i=ID_FROM_INT(fp->current_object->prog, tmp);
7fda7a1997-09-08Fredrik Hübinette (Hubbe)  if(!IDENTIFIER_IS_VARIABLE(i->identifier_flags))
f68aec1997-03-23Fredrik Hübinette (Hubbe)  error("Cannot assign functions or constants.\n");
5267b71995-08-09Fredrik Hübinette (Hubbe)  if(i->run_time_type == T_MIXED) { struct svalue *s=(struct svalue *)GLOBAL_FROM_INT(tmp); free_svalue(s); sp--; *s=*sp; }else{ assign_to_short_svalue((union anything *)GLOBAL_FROM_INT(tmp), i->run_time_type, sp-1); pop_stack(); } } break; /* Stack machine stuff */ CASE(F_POP_VALUE); pop_stack(); break; CASE(F_POP_N_ELEMS); pop_n_elems(GET_ARG()); break;
b208c11996-08-03Fredrik Hübinette (Hubbe)  CASE(F_MARK2); *(mark_sp++)=sp;
5267b71995-08-09Fredrik Hübinette (Hubbe)  CASE(F_MARK); *(mark_sp++)=sp; break;
9b08a21998-03-31Fredrik Hübinette (Hubbe)  CASE(F_MARK_X); *(mark_sp++)=sp-GET_ARG(); break;
5267b71995-08-09Fredrik Hübinette (Hubbe) 
dffa011997-01-15Fredrik Hübinette (Hubbe)  CASE(F_CLEAR_STRING_SUBTYPE); if(sp[-1].type==T_STRING) sp[-1].subtype=0; break;
5267b71995-08-09Fredrik Hübinette (Hubbe)  /* Jumps */ CASE(F_BRANCH);
06983f1996-09-22Fredrik Hübinette (Hubbe)  DOJUMP();
5267b71995-08-09Fredrik Hübinette (Hubbe)  break; CASE(F_BRANCH_WHEN_ZERO); if(!IS_ZERO(sp-1)) {
f90e541995-08-17Fredrik Hübinette (Hubbe)  pc+=sizeof(INT32);
5267b71995-08-09Fredrik Hübinette (Hubbe)  }else{
06983f1996-09-22Fredrik Hübinette (Hubbe)  DOJUMP();
5267b71995-08-09Fredrik Hübinette (Hubbe)  } pop_stack(); break; CASE(F_BRANCH_WHEN_NON_ZERO); if(IS_ZERO(sp-1))
2a50961995-08-23Fredrik Hübinette (Hubbe)  {
f90e541995-08-17Fredrik Hübinette (Hubbe)  pc+=sizeof(INT32);
5267b71995-08-09Fredrik Hübinette (Hubbe)  }else{
06983f1996-09-22Fredrik Hübinette (Hubbe)  DOJUMP();
5267b71995-08-09Fredrik Hübinette (Hubbe)  } pop_stack(); break;
9b08a21998-03-31Fredrik Hübinette (Hubbe)  CASE(F_BRANCH_IF_LOCAL); instr=GET_ARG(); if(IS_ZERO(fp->locals + instr)) { pc+=sizeof(INT32); }else{ DOJUMP(); } break;
c5016f1996-04-13Fredrik Hübinette (Hubbe)  CJUMP(F_BRANCH_WHEN_EQ, is_eq); CJUMP(F_BRANCH_WHEN_NE,!is_eq); CJUMP(F_BRANCH_WHEN_LT, is_lt); CJUMP(F_BRANCH_WHEN_LE,!is_gt); CJUMP(F_BRANCH_WHEN_GT, is_gt); CJUMP(F_BRANCH_WHEN_GE,!is_lt);
596e361998-03-31Fredrik Hübinette (Hubbe)  CASE(F_BRANCH_AND_POP_WHEN_ZERO); if(!IS_ZERO(sp-1)) { pc+=sizeof(INT32); }else{ DOJUMP(); pop_stack(); } break; CASE(F_BRANCH_AND_POP_WHEN_NON_ZERO); if(!IS_ZERO(sp-1)) { pc+=sizeof(INT32); }else{ DOJUMP(); pop_stack(); } break;
5267b71995-08-09Fredrik Hübinette (Hubbe)  CASE(F_LAND); if(!IS_ZERO(sp-1)) {
f90e541995-08-17Fredrik Hübinette (Hubbe)  pc+=sizeof(INT32);
5267b71995-08-09Fredrik Hübinette (Hubbe)  pop_stack(); }else{
06983f1996-09-22Fredrik Hübinette (Hubbe)  DOJUMP();
5267b71995-08-09Fredrik Hübinette (Hubbe)  } break; CASE(F_LOR); if(IS_ZERO(sp-1)) {
f90e541995-08-17Fredrik Hübinette (Hubbe)  pc+=sizeof(INT32);
5267b71995-08-09Fredrik Hübinette (Hubbe)  pop_stack(); }else{
06983f1996-09-22Fredrik Hübinette (Hubbe)  DOJUMP();
5267b71995-08-09Fredrik Hübinette (Hubbe)  } break;
419fab1997-03-09Fredrik Hübinette (Hubbe)  CASE(F_EQ_OR);
2d12341997-03-10Fredrik Hübinette (Hubbe)  if(!is_eq(sp-2,sp-1))
419fab1997-03-09Fredrik Hübinette (Hubbe)  { pop_n_elems(2); pc+=sizeof(INT32); }else{ pop_n_elems(2); push_int(1); DOJUMP(); } break;
2d12341997-03-10Fredrik Hübinette (Hubbe)  CASE(F_EQ_AND); if(is_eq(sp-2,sp-1)) { pop_n_elems(2); pc+=sizeof(INT32); }else{ pop_n_elems(2); push_int(0); DOJUMP(); } break;
5267b71995-08-09Fredrik Hübinette (Hubbe)  CASE(F_CATCH);
b208c11996-08-03Fredrik Hübinette (Hubbe)  if(o_catch(pc+sizeof(INT32)))
b1f4eb1998-01-13Fredrik Hübinette (Hubbe)  return -1; /* There was a return inside the evaluated code */
b208c11996-08-03Fredrik Hübinette (Hubbe)  else pc+=EXTRACT_INT(pc); break; CASE(F_THROW_ZERO); push_int(0); f_throw(1);
5267b71995-08-09Fredrik Hübinette (Hubbe)  break; CASE(F_SWITCH) { INT32 tmp; tmp=switch_lookup(fp->context.prog->
c5016f1996-04-13Fredrik Hübinette (Hubbe)  constants[GET_ARG()].u.array,sp-1);
06983f1996-09-22Fredrik Hübinette (Hubbe)  pc=(unsigned char *)DO_ALIGN(pc,sizeof(INT32));
c5016f1996-04-13Fredrik Hübinette (Hubbe)  pc+=(tmp>=0 ? 1+tmp*2 : 2*~tmp) * sizeof(INT32);
0a861b1997-09-17Fredrik Hübinette (Hubbe)  if(*(INT32*)pc < 0) fast_check_threads_etc(7);
c5016f1996-04-13Fredrik Hübinette (Hubbe)  pc+=*(INT32*)pc;
5267b71995-08-09Fredrik Hübinette (Hubbe)  pop_stack(); break; }
7961fb1997-10-10Fredrik Hübinette (Hubbe)  LOOP(F_INC_LOOP, ++, <, f_add(2), is_lt); LOOP(F_DEC_LOOP, --, >, o_subtract(), is_gt); LOOP(F_INC_NEQ_LOOP, ++, !=, f_add(2), !is_eq); LOOP(F_DEC_NEQ_LOOP, --, !=, o_subtract(), !is_eq);
5267b71995-08-09Fredrik Hübinette (Hubbe) 
5683de1995-11-06Fredrik Hübinette (Hubbe)  CASE(F_FOREACH) /* array, lvalue , i */
5267b71995-08-09Fredrik Hübinette (Hubbe)  {
bb21091998-04-10Henrik Grubbström (Grubba)  if(sp[-4].type != T_ARRAY) ERROR("foreach", "Bad argument 1.\n", sp-3, 1);
5267b71995-08-09Fredrik Hübinette (Hubbe)  if(sp[-1].u.integer < sp[-4].u.array->size) {
0a861b1997-09-17Fredrik Hübinette (Hubbe)  fast_check_threads_etc(10);
5267b71995-08-09Fredrik Hübinette (Hubbe)  index_no_free(sp,sp-4,sp-1);
5683de1995-11-06Fredrik Hübinette (Hubbe)  sp++; assign_lvalue(sp-4, sp-1); free_svalue(sp-1); sp--;
5267b71995-08-09Fredrik Hübinette (Hubbe)  pc+=EXTRACT_INT(pc); sp[-1].u.integer++; }else{
f90e541995-08-17Fredrik Hübinette (Hubbe)  pc+=sizeof(INT32);
5267b71995-08-09Fredrik Hübinette (Hubbe)  } break; }
b1f4eb1998-01-13Fredrik Hübinette (Hubbe)  CASE(F_APPLY_AND_RETURN); { INT32 args=sp - *--mark_sp; if(fp->locals >= sp-args) { MEMMOVE(sp-args+1,sp-args,args*sizeof(struct svalue)); sp++; sp[-args-1].type=T_INT; } /* We sabotage the stack here */ assign_svalue(sp-args-1,fp->context.prog->constants+GET_ARG()); return args+1; } CASE(F_CALL_LFUN_AND_RETURN); { INT32 args=sp - *--mark_sp; if(fp->locals >= sp-args) { MEMMOVE(sp-args+1,sp-args,args*sizeof(struct svalue)); sp++; sp[-args-1].type=T_INT; }else{ free_svalue(sp-args-1); } /* More stack sabotage */ sp[-args-1].u.object=fp->current_object; sp[-args-1].subtype=GET_ARG()+fp->context.identifier_level; sp[-args-1].type=T_FUNCTION;
8c83371998-04-16Fredrik Hübinette (Hubbe)  add_ref(fp->current_object);
b1f4eb1998-01-13Fredrik Hübinette (Hubbe)  return args+1; }
9b08a21998-03-31Fredrik Hübinette (Hubbe)  CASE(F_RETURN_LOCAL); instr=GET_ARG(); pop_n_elems(sp-1 - (fp->locals+instr)); print_return_value(); goto do_return;
3c04e81997-03-13Fredrik Hübinette (Hubbe)  CASE(F_RETURN_1); push_int(1); goto do_return;
5267b71995-08-09Fredrik Hübinette (Hubbe)  CASE(F_RETURN_0);
a599231996-09-25Fredrik Hübinette (Hubbe)  push_int(0); goto do_return;
5267b71995-08-09Fredrik Hübinette (Hubbe)  CASE(F_RETURN);
a599231996-09-25Fredrik Hübinette (Hubbe)  do_return:
b1f4eb1998-01-13Fredrik Hübinette (Hubbe) #if defined(DEBUG) && defined(GC2) if(d_flag > 2) do_gc();
0a861b1997-09-17Fredrik Hübinette (Hubbe)  check_threads_etc();
b1f4eb1998-01-13Fredrik Hübinette (Hubbe) #endif
a599231996-09-25Fredrik Hübinette (Hubbe) 
5267b71995-08-09Fredrik Hübinette (Hubbe)  /* fall through */ CASE(F_DUMB_RETURN);
b1f4eb1998-01-13Fredrik Hübinette (Hubbe)  return -1;
5267b71995-08-09Fredrik Hübinette (Hubbe)  CASE(F_NEGATE); if(sp[-1].type == T_INT) { sp[-1].u.integer =- sp[-1].u.integer; }else if(sp[-1].type == T_FLOAT) { sp[-1].u.float_number =- sp[-1].u.float_number; }else{
fa382f1996-06-21Fredrik Hübinette (Hubbe)  o_negate();
5267b71995-08-09Fredrik Hübinette (Hubbe)  } break;
fa382f1996-06-21Fredrik Hübinette (Hubbe)  CASE(F_COMPL); o_compl(); break;
5267b71995-08-09Fredrik Hübinette (Hubbe)  CASE(F_NOT); switch(sp[-1].type) { case T_INT: sp[-1].u.integer =! sp[-1].u.integer; break; case T_FUNCTION: case T_OBJECT:
fa382f1996-06-21Fredrik Hübinette (Hubbe)  if(IS_ZERO(sp-1))
5267b71995-08-09Fredrik Hübinette (Hubbe)  {
fa382f1996-06-21Fredrik Hübinette (Hubbe)  pop_stack(); push_int(1); }else{ pop_stack(); push_int(0);
5267b71995-08-09Fredrik Hübinette (Hubbe)  }
fa382f1996-06-21Fredrik Hübinette (Hubbe)  break;
5267b71995-08-09Fredrik Hübinette (Hubbe)  default: free_svalue(sp-1); sp[-1].type=T_INT; sp[-1].u.integer=0; } break;
1b89ad1997-10-10Fredrik Hübinette (Hubbe)  CASE(F_LSH); o_lsh(); break; CASE(F_RSH); o_rsh(); break;
5267b71995-08-09Fredrik Hübinette (Hubbe)  COMPARISMENT(F_EQ, is_eq(sp-2,sp-1)); COMPARISMENT(F_NE,!is_eq(sp-2,sp-1)); COMPARISMENT(F_GT, is_gt(sp-2,sp-1)); COMPARISMENT(F_GE,!is_lt(sp-2,sp-1)); COMPARISMENT(F_LT, is_lt(sp-2,sp-1)); COMPARISMENT(F_LE,!is_gt(sp-2,sp-1));
7bd0ea1996-02-19Fredrik Hübinette (Hubbe)  CASE(F_ADD); f_add(2); break; CASE(F_SUBTRACT); o_subtract(); break; CASE(F_AND); o_and(); break; CASE(F_OR); o_or(); break; CASE(F_XOR); o_xor(); break; CASE(F_MULTIPLY); o_multiply(); break; CASE(F_DIVIDE); o_divide(); break; CASE(F_MOD); o_mod(); break;
5267b71995-08-09Fredrik Hübinette (Hubbe) 
3c04e81997-03-13Fredrik Hübinette (Hubbe)  CASE(F_ADD_INT); push_int(GET_ARG()); f_add(2); break; CASE(F_ADD_NEG_INT); push_int(-GET_ARG()); f_add(2); break;
5267b71995-08-09Fredrik Hübinette (Hubbe)  CASE(F_PUSH_ARRAY);
bb21091998-04-10Henrik Grubbström (Grubba)  if(sp[-1].type!=T_ARRAY) ERROR("@", "Bad argument.\n", sp, 1);
5267b71995-08-09Fredrik Hübinette (Hubbe)  sp--; push_array_items(sp->u.array); break;
9b08a21998-03-31Fredrik Hübinette (Hubbe)  CASE(F_LOCAL_LOCAL_INDEX); { struct svalue *s=fp->locals+GET_ARG(); if(s->type == T_STRING) s->subtype=0; sp++->type=T_INT; index_no_free(sp-1,fp->locals+GET_ARG(),s); break; }
06983f1996-09-22Fredrik Hübinette (Hubbe)  CASE(F_LOCAL_INDEX);
9b08a21998-03-31Fredrik Hübinette (Hubbe)  { struct svalue tmp,*s=fp->locals+GET_ARG(); if(s->type == T_STRING) s->subtype=0; index_no_free(&tmp,sp-1,s); free_svalue(sp-1); sp[-1]=tmp; break; }
06983f1996-09-22Fredrik Hübinette (Hubbe)  CASE(F_POS_INT_INDEX); push_int(GET_ARG()); print_return_value(); goto do_index; CASE(F_NEG_INT_INDEX); push_int(-GET_ARG()); print_return_value(); goto do_index;
dffa011997-01-15Fredrik Hübinette (Hubbe)  CASE(F_ARROW);
7be1c71997-01-17Fredrik Hübinette (Hubbe)  copy_shared_string(sp->u.string,fp->context.prog->strings[GET_ARG()]); sp->type=T_STRING; sp->subtype=1; sp++; print_return_value(); goto do_index;
06983f1996-09-22Fredrik Hübinette (Hubbe)  CASE(F_STRING_INDEX); copy_shared_string(sp->u.string,fp->context.prog->strings[GET_ARG()]); sp->type=T_STRING;
7be1c71997-01-17Fredrik Hübinette (Hubbe)  sp->subtype=0;
06983f1996-09-22Fredrik Hübinette (Hubbe)  sp++; print_return_value(); /* Fall through */
5683de1995-11-06Fredrik Hübinette (Hubbe)  CASE(F_INDEX);
06983f1996-09-22Fredrik Hübinette (Hubbe)  do_index:
9f68471997-03-08Fredrik Hübinette (Hubbe)  o_index();
5683de1995-11-06Fredrik Hübinette (Hubbe)  print_return_value(); break;
5267b71995-08-09Fredrik Hübinette (Hubbe)  CASE(F_CAST); f_cast(); break;
7bd0ea1996-02-19Fredrik Hübinette (Hubbe)  CASE(F_RANGE); o_range(); break;
5267b71995-08-09Fredrik Hübinette (Hubbe)  CASE(F_COPY_VALUE);
fa382f1996-06-21Fredrik Hübinette (Hubbe)  { struct svalue tmp; copy_svalues_recursively_no_free(&tmp,sp-1,1,0); free_svalue(sp-1); sp[-1]=tmp; }
5267b71995-08-09Fredrik Hübinette (Hubbe)  break;
b208c11996-08-03Fredrik Hübinette (Hubbe)  CASE(F_SIZEOF);
06983f1996-09-22Fredrik Hübinette (Hubbe)  instr=pike_sizeof(sp-1);
b208c11996-08-03Fredrik Hübinette (Hubbe)  pop_stack(); push_int(instr); break; CASE(F_SIZEOF_LOCAL);
06983f1996-09-22Fredrik Hübinette (Hubbe)  push_int(pike_sizeof(fp->locals+GET_ARG()));
5267b71995-08-09Fredrik Hübinette (Hubbe)  break;
ed98911998-04-15Fredrik Hübinette (Hubbe)  CASE(F_SSCANF); o_sscanf(GET_ARG()); break;
5267b71995-08-09Fredrik Hübinette (Hubbe)  CASE(F_CALL_LFUN); apply_low(fp->current_object, GET_ARG()+fp->context.identifier_level, sp - *--mark_sp); break;
b208c11996-08-03Fredrik Hübinette (Hubbe)  CASE(F_CALL_LFUN_AND_POP); apply_low(fp->current_object, GET_ARG()+fp->context.identifier_level, sp - *--mark_sp); pop_stack(); break;
3c04e81997-03-13Fredrik Hübinette (Hubbe)  CASE(F_MARK_APPLY); strict_apply_svalue(fp->context.prog->constants + GET_ARG(), 0); break; CASE(F_MARK_APPLY_POP); strict_apply_svalue(fp->context.prog->constants + GET_ARG(), 0); pop_stack(); break;
e82b301997-01-29Fredrik Hübinette (Hubbe)  CASE(F_APPLY); strict_apply_svalue(fp->context.prog->constants + GET_ARG(), sp - *--mark_sp ); break; CASE(F_APPLY_AND_POP); strict_apply_svalue(fp->context.prog->constants + GET_ARG(), sp - *--mark_sp ); pop_stack(); break;
b1f4eb1998-01-13Fredrik Hübinette (Hubbe)  CASE(F_CALL_FUNCTION); mega_apply(APPLY_STACK,sp - *--mark_sp,0,0); break; CASE(F_CALL_FUNCTION_AND_RETURN);
d103cb1998-01-30Fredrik Hübinette (Hubbe)  { INT32 args=sp - *--mark_sp; if(!args)
bb21091998-04-10Henrik Grubbström (Grubba)  ERROR("`()", "Too few arguments.\n", sp, 0);
d103cb1998-01-30Fredrik Hübinette (Hubbe)  switch(sp[-args].type) { case T_INT: case T_STRING: case T_FLOAT: case T_MAPPING: case T_MULTISET:
bb21091998-04-10Henrik Grubbström (Grubba)  ERROR("`()", "Attempt to call a non-function value.\n", sp, args);
d103cb1998-01-30Fredrik Hübinette (Hubbe)  } return args; }
b1f4eb1998-01-13Fredrik Hübinette (Hubbe) 
5267b71995-08-09Fredrik Hübinette (Hubbe)  default:
e82b301997-01-29Fredrik Hübinette (Hubbe)  fatal("Strange instruction %ld\n",(long)instr);
5267b71995-08-09Fredrik Hübinette (Hubbe)  }
fedf131998-03-25Fredrik Hübinette (Hubbe) 
5267b71995-08-09Fredrik Hübinette (Hubbe)  } }
cd83521998-02-02Fredrik Hübinette (Hubbe) static void trace_return_value(void) { char *s; init_buf(); my_strcat("Return: "); describe_svalue(sp-1,0,0); s=simple_free_buf(); if((long)strlen(s) > (long)TRACE_LEN) { s[TRACE_LEN]=0; s[TRACE_LEN-1]='.'; s[TRACE_LEN-2]='.'; s[TRACE_LEN-2]='.'; } fprintf(stderr,"%-*s%s\n",4,"-",s); free(s); } static void do_trace_call(INT32 args) { char *file,*s; INT32 linep,e; my_strcat("("); for(e=0;e<args;e++) { if(e) my_strcat(","); describe_svalue(sp-args+e,0,0); } my_strcat(")"); s=simple_free_buf(); if((long)strlen(s) > (long)TRACE_LEN) { s[TRACE_LEN]=0; s[TRACE_LEN-1]='.'; s[TRACE_LEN-2]='.'; s[TRACE_LEN-2]='.'; } if(fp && fp->pc) { char *f; file=get_line(fp->pc,fp->context.prog,&linep); while((f=STRCHR(file,'/'))) file=f+1; }else{ linep=0; file="-"; } fprintf(stderr,"- %s:%4ld: %s\n",file,(long)linep,s); free(s); }
b1f4eb1998-01-13Fredrik Hübinette (Hubbe) void mega_apply(enum apply_type type, INT32 args, void *arg1, void *arg2) { struct object *o; int fun, tailrecurse=-1; struct svalue *save_sp=sp-args;
a2a8801998-03-18Per Hedbor #ifdef PROFILING #ifdef HAVE_GETHRTIME long long start_time = gethrtime(); #endif #endif
b1f4eb1998-01-13Fredrik Hübinette (Hubbe)  switch(type) { case APPLY_STACK: apply_stack:
bb21091998-04-10Henrik Grubbström (Grubba)  if(!args) ERROR("`()", "Too few arguments.\n", sp, 0);
b1f4eb1998-01-13Fredrik Hübinette (Hubbe)  args--; if(sp-save_sp-args > (args<<2) + 32) { /* The test above assures these two areas * are not overlapping */ assign_svalues(save_sp, sp-args-1, args+1, BIT_MIXED); pop_n_elems(sp-save_sp-args-1); } arg1=(void *)(sp-args-1); case APPLY_SVALUE: apply_svalue: { struct svalue *s=(struct svalue *)arg1; switch(s->type) { case T_INT: if (!s->u.integer) {
bb21091998-04-10Henrik Grubbström (Grubba)  ERROR("0", "Attempt to call the NULL-value\n", sp, args);
b1f4eb1998-01-13Fredrik Hübinette (Hubbe)  } else { error("Attempt to call the value %d\n", s->u.integer); } case T_STRING: if (s->u.string->len > 20) { error("Attempt to call the string \"%20s\"...\n", s->u.string->str); } else { error("Attempt to call the string \"%s\"\n", s->u.string->str); } case T_MAPPING: error("Attempt to call a mapping\n"); default:
bb21091998-04-10Henrik Grubbström (Grubba)  error("Call to non-function value type:%s.\n", get_name_of_type(s->type));
b1f4eb1998-01-13Fredrik Hübinette (Hubbe)  case T_FUNCTION: if(s->subtype == FUNCTION_BUILTIN) {
cd83521998-02-02Fredrik Hübinette (Hubbe) #ifdef DEBUG if(t_flag>1) { init_buf(); describe_svalue(s,0,0); do_trace_call(args); } #endif
b1f4eb1998-01-13Fredrik Hübinette (Hubbe)  (*(s->u.efun->function))(args); break; }else{ o=s->u.object; fun=s->subtype; goto apply_low; } break; case T_ARRAY:
cd83521998-02-02Fredrik Hübinette (Hubbe) #ifdef DEBUG if(t_flag>1) { init_buf(); describe_svalue(s,0,0); do_trace_call(args); } #endif
b1f4eb1998-01-13Fredrik Hübinette (Hubbe)  apply_array(s->u.array,args); break; case T_PROGRAM:
cd83521998-02-02Fredrik Hübinette (Hubbe) #ifdef DEBUG if(t_flag>1) { init_buf(); describe_svalue(s,0,0); do_trace_call(args); } #endif
b1f4eb1998-01-13Fredrik Hübinette (Hubbe)  push_object(clone_object(s->u.program,args)); break; case T_OBJECT: o=s->u.object; fun=LFUN_CALL; goto call_lfun; } break; } call_lfun: #ifdef DEBUG if(fun < 0 || fun >= NUM_LFUNS) fatal("Apply lfun on illegal value!\n"); #endif if(!o->prog)
bb21091998-04-10Henrik Grubbström (Grubba)  ERROR("destructed object", "Apply on destructed object.\n", sp, args);
b1f4eb1998-01-13Fredrik Hübinette (Hubbe)  fun=FIND_LFUN(o->prog,fun); goto apply_low; case APPLY_LOW: o=(struct object *)arg1; fun=(long)arg2; apply_low: { struct program *p; struct reference *ref; struct frame new_frame; struct identifier *function; if(fun<0) {
0ffa001998-01-13Fredrik Hübinette (Hubbe)  pop_n_elems(sp-save_sp);
b1f4eb1998-01-13Fredrik Hübinette (Hubbe)  push_int(0); return; } check_threads_etc(); check_stack(256); check_mark_stack(256); #ifdef DEBUG if(d_flag>2) do_debug(); #endif p=o->prog; if(!p)
bb21091998-04-10Henrik Grubbström (Grubba)  ERROR("destructed object->function", "Cannot call functions in destructed objects.\n", sp, args);
b1f4eb1998-01-13Fredrik Hübinette (Hubbe) #ifdef DEBUG if(fun>=(int)p->num_identifier_references) fatal("Function index out of range.\n"); #endif ref = p->identifier_references + fun; #ifdef DEBUG if(ref->inherit_offset>=p->num_inherits) fatal("Inherit offset out of range in program.\n"); #endif /* init a new evaluation frame */ new_frame.parent_frame = fp; new_frame.current_object = o; new_frame.context = p->inherits[ ref->inherit_offset ]; function = new_frame.context.prog->identifiers + ref->identifier_offset;
a2a8801998-03-18Per Hedbor  #ifdef PROFILING function->num_calls++; #endif
b1f4eb1998-01-13Fredrik Hübinette (Hubbe)  new_frame.locals = sp - args; new_frame.args = args; new_frame.fun = fun; new_frame.current_storage = o->storage+new_frame.context.storage_offset; new_frame.pc = 0;
8c83371998-04-16Fredrik Hübinette (Hubbe)  add_ref(new_frame.current_object); add_ref(new_frame.context.prog); if(new_frame.context.parent) add_ref(new_frame.context.parent);
b1f4eb1998-01-13Fredrik Hübinette (Hubbe)  if(t_flag) {
cd83521998-02-02Fredrik Hübinette (Hubbe)  char buf[50];
b1f4eb1998-01-13Fredrik Hübinette (Hubbe)  init_buf(); sprintf(buf,"%lx->",(long)o); my_strcat(buf); my_strcat(function->name->str);
cd83521998-02-02Fredrik Hübinette (Hubbe)  do_trace_call(args);
b1f4eb1998-01-13Fredrik Hübinette (Hubbe)  } fp = &new_frame; if(function->func.offset == -1)
bb21091998-04-10Henrik Grubbström (Grubba)  ERROR(function->name->str, "Calling undefined function.\n", sp, args);
b1f4eb1998-01-13Fredrik Hübinette (Hubbe) 
662e451998-01-22Fredrik Hübinette (Hubbe)  tailrecurse=-1;
b1f4eb1998-01-13Fredrik Hübinette (Hubbe)  switch(function->identifier_flags & (IDENTIFIER_FUNCTION | IDENTIFIER_CONSTANT)) { case IDENTIFIER_C_FUNCTION: fp->num_args=args; new_frame.num_locals=args; (*function->func.c_fun)(args); break; case IDENTIFIER_CONSTANT: { struct svalue *s=fp->context.prog->constants+function->func.offset; if(s->type == T_PROGRAM) { struct object *tmp=parent_clone_object(s->u.program, o, fun, args); push_object(tmp); break; } /* Fall through */ } case 0: { if(sp-save_sp-args<=0) { /* Create an extra svalue for tail recursion style call */ sp++; MEMMOVE(sp-args,sp-args-1,sizeof(struct svalue)*args); sp[-args-1].type=T_INT; } low_object_index_no_free(sp-args-1,o,fun); tailrecurse=args+1; break; } case IDENTIFIER_PIKE_FUNCTION: { int num_args; int num_locals; unsigned char *pc; pc=new_frame.context.prog->program + function->func.offset; num_locals=EXTRACT_UCHAR(pc++); num_args=EXTRACT_UCHAR(pc++); /* adjust arguments on stack */ if(args < num_args) /* push zeros */ { clear_svalues(sp, num_args-args); sp += num_args-args; args += num_args-args; } if(function->identifier_flags & IDENTIFIER_VARARGS) { f_aggregate(args - num_args); /* make array */ args = num_args+1; }else{ if(args > num_args) { /* pop excessive */ pop_n_elems(args - num_args); args=num_args; } } clear_svalues(sp, num_locals - args); sp += num_locals - args; #ifdef DEBUG if(num_locals < num_args) fatal("Wrong number of arguments or locals in function def.\n"); #endif new_frame.num_locals=num_locals; new_frame.num_args=num_args; tailrecurse=eval_instruction(pc); #ifdef DEBUG if(sp<evaluator_stack) fatal("Stack error (also simple).\n"); #endif break; } }
a2a8801998-03-18Per Hedbor #ifdef PROFILING #ifdef HAVE_GETHRTIME function->total_time+=(INT32)((gethrtime()-start_time)/1000); #endif #endif
b1f4eb1998-01-13Fredrik Hübinette (Hubbe)  #if 0 if(sp - new_frame.locals > 1) { pop_n_elems(sp - new_frame.locals -1); }else if(sp - new_frame.locals < 1){ #ifdef DEBUG if(sp - new_frame.locals<0) fatal("Frame underflow.\n"); #endif sp->u.integer = 0; sp->subtype=NUMBER_NUMBER; sp->type = T_INT; sp++; } #endif if(new_frame.context.parent) free_object(new_frame.context.parent); free_object(new_frame.current_object); free_program(new_frame.context.prog); fp = new_frame.parent_frame; if(tailrecurse>=0) { args=tailrecurse; goto apply_stack; } } } if(save_sp+1 < sp) { assign_svalue(save_sp,sp-1); pop_n_elems(sp-save_sp-1); }
9106ac1998-02-03Fredrik Hübinette (Hubbe)  if(save_sp+1 > sp)
cd83521998-02-02Fredrik Hübinette (Hubbe)  {
9106ac1998-02-03Fredrik Hübinette (Hubbe)  if(type != APPLY_SVALUE) push_int(0);
cd83521998-02-02Fredrik Hübinette (Hubbe)  }else{
9106ac1998-02-03Fredrik Hübinette (Hubbe)  if(t_flag>1) trace_return_value();
cd83521998-02-02Fredrik Hübinette (Hubbe)  }
b1f4eb1998-01-13Fredrik Hübinette (Hubbe) }
b208c11996-08-03Fredrik Hübinette (Hubbe) /* Put catch outside of eval_instruction, so * the setjmp won't affect the optimization of * eval_instruction */ static int o_catch(unsigned char *pc) { JMP_BUF tmp; if(SETJMP(tmp)) { *sp=throw_value; throw_value.type=T_INT; sp++; UNSETJMP(tmp); return 0; }else{
b1f4eb1998-01-13Fredrik Hübinette (Hubbe)  int x=eval_instruction(pc); if(x!=-1) mega_apply(APPLY_STACK, x, 0,0);
b208c11996-08-03Fredrik Hübinette (Hubbe)  UNSETJMP(tmp); return 1; } }
3c0c281998-01-26Fredrik Hübinette (Hubbe) void f_call_function(INT32 args) { mega_apply(APPLY_STACK,args,0,0); }
5267b71995-08-09Fredrik Hübinette (Hubbe) int apply_low_safe_and_stupid(struct object *o, INT32 offset) { JMP_BUF tmp; struct frame new_frame; int ret; new_frame.parent_frame = fp; new_frame.current_object = o; new_frame.context=o->prog->inherits[0]; new_frame.locals = evaluator_stack; new_frame.args = 0;
48e2f41997-02-27Fredrik Hübinette (Hubbe)  new_frame.num_args=0; new_frame.num_locals=0;
5267b71995-08-09Fredrik Hübinette (Hubbe)  new_frame.fun = -1; new_frame.pc = 0; new_frame.current_storage=o->storage;
b1f4eb1998-01-13Fredrik Hübinette (Hubbe)  new_frame.context.parent=0;
5267b71995-08-09Fredrik Hübinette (Hubbe)  fp = & new_frame;
8c83371998-04-16Fredrik Hübinette (Hubbe)  add_ref(new_frame.current_object); add_ref(new_frame.context.prog);
5267b71995-08-09Fredrik Hübinette (Hubbe)  if(SETJMP(tmp)) { ret=1; }else{
b1f4eb1998-01-13Fredrik Hübinette (Hubbe)  int tmp=eval_instruction(o->prog->program + offset); if(tmp!=-1) mega_apply(APPLY_STACK, tmp, 0,0);
5267b71995-08-09Fredrik Hübinette (Hubbe) #ifdef DEBUG if(sp<evaluator_stack)
b208c11996-08-03Fredrik Hübinette (Hubbe)  fatal("Stack error (simple).\n");
5267b71995-08-09Fredrik Hübinette (Hubbe) #endif ret=0; } UNSETJMP(tmp); free_object(new_frame.current_object); free_program(new_frame.context.prog); fp = new_frame.parent_frame; return ret; } void safe_apply_low(struct object *o,int fun,int args) { JMP_BUF recovery; sp-=args;
dffa011997-01-15Fredrik Hübinette (Hubbe)  free_svalue(& throw_value); throw_value.type=T_INT;
5267b71995-08-09Fredrik Hübinette (Hubbe)  if(SETJMP(recovery)) {
dffa011997-01-15Fredrik Hübinette (Hubbe)  if(throw_value.type == T_ARRAY) { ONERROR tmp; SET_ONERROR(tmp,exit_on_error,"Error in handle_error in master object!"); assign_svalue_no_free(sp++, & throw_value); APPLY_MASTER("handle_error", 1); pop_stack(); UNSET_ONERROR(tmp); }
5267b71995-08-09Fredrik Hübinette (Hubbe)  sp->u.integer = 0; sp->subtype=NUMBER_NUMBER; sp->type = T_INT; sp++; }else{
fa382f1996-06-21Fredrik Hübinette (Hubbe)  INT32 expected_stack = sp - evaluator_stack + 1;
5267b71995-08-09Fredrik Hübinette (Hubbe)  sp+=args; apply_low(o,fun,args);
fa382f1996-06-21Fredrik Hübinette (Hubbe)  if(sp - evaluator_stack > expected_stack) pop_n_elems(sp - evaluator_stack - expected_stack); if(sp - evaluator_stack < expected_stack)
5267b71995-08-09Fredrik Hübinette (Hubbe)  { sp->u.integer = 0; sp->subtype=NUMBER_NUMBER; sp->type = T_INT; sp++; } } UNSETJMP(recovery); }
b1f4eb1998-01-13Fredrik Hübinette (Hubbe) 
5683de1995-11-06Fredrik Hübinette (Hubbe) void safe_apply(struct object *o, char *fun ,INT32 args) { #ifdef DEBUG if(!o->prog) fatal("Apply safe on destructed object.\n"); #endif safe_apply_low(o, find_identifier(fun, o->prog), args); }
fa382f1996-06-21Fredrik Hübinette (Hubbe) void apply_lfun(struct object *o, int fun, int args) { #ifdef DEBUG if(fun < 0 || fun >= NUM_LFUNS) fatal("Apply lfun on illegal value!\n"); #endif if(!o->prog)
bb21091998-04-10Henrik Grubbström (Grubba)  ERROR("destructed object", "Apply on destructed object.\n", sp, args);
fa382f1996-06-21Fredrik Hübinette (Hubbe) 
b1f4eb1998-01-13Fredrik Hübinette (Hubbe)  apply_low(o, (int)FIND_LFUN(o->prog,fun), args);
fa382f1996-06-21Fredrik Hübinette (Hubbe) }
5267b71995-08-09Fredrik Hübinette (Hubbe) void apply_shared(struct object *o,
06983f1996-09-22Fredrik Hübinette (Hubbe)  struct pike_string *fun,
5267b71995-08-09Fredrik Hübinette (Hubbe)  int args) {
fa382f1996-06-21Fredrik Hübinette (Hubbe)  apply_low(o, find_shared_string_identifier(fun, o->prog), args);
5267b71995-08-09Fredrik Hübinette (Hubbe) } void apply(struct object *o, char *fun, int args) {
fa382f1996-06-21Fredrik Hübinette (Hubbe)  apply_low(o, find_identifier(fun, o->prog), args);
5267b71995-08-09Fredrik Hübinette (Hubbe) } void apply_svalue(struct svalue *s, INT32 args) { if(s->type==T_INT) { pop_n_elems(args); push_int(0); }else{
fa382f1996-06-21Fredrik Hübinette (Hubbe)  INT32 expected_stack=sp-args+1 - evaluator_stack;
5267b71995-08-09Fredrik Hübinette (Hubbe)  strict_apply_svalue(s,args);
fa382f1996-06-21Fredrik Hübinette (Hubbe)  if(sp > (expected_stack + evaluator_stack))
f6f02d1995-10-16Fredrik Hübinette (Hubbe)  {
fa382f1996-06-21Fredrik Hübinette (Hubbe)  pop_n_elems(sp-(expected_stack + evaluator_stack));
f6f02d1995-10-16Fredrik Hübinette (Hubbe)  }
fa382f1996-06-21Fredrik Hübinette (Hubbe)  else if(sp < (expected_stack + evaluator_stack))
f6f02d1995-10-16Fredrik Hübinette (Hubbe)  { push_int(0); } #ifdef DEBUG
fa382f1996-06-21Fredrik Hübinette (Hubbe)  if(sp < (expected_stack + evaluator_stack)) fatal("Stack underflow!\n");
f6f02d1995-10-16Fredrik Hübinette (Hubbe) #endif
5267b71995-08-09Fredrik Hübinette (Hubbe)  } } #ifdef DEBUG
be478c1997-08-30Henrik Grubbström (Grubba) void slow_check_stack(void)
5267b71995-08-09Fredrik Hübinette (Hubbe) { struct svalue *s,**m; struct frame *f;
fa382f1996-06-21Fredrik Hübinette (Hubbe)  debug_check_stack();
5267b71995-08-09Fredrik Hübinette (Hubbe) 
0f887e1996-08-12Fredrik Hübinette (Hubbe)  if(sp > &(evaluator_stack[stack_size]))
5267b71995-08-09Fredrik Hübinette (Hubbe)  fatal("Stack overflow\n");
0f887e1996-08-12Fredrik Hübinette (Hubbe)  if(mark_sp > &(mark_stack[stack_size]))
fa382f1996-06-21Fredrik Hübinette (Hubbe)  fatal("Mark stack overflow.\n");
5267b71995-08-09Fredrik Hübinette (Hubbe) 
fa382f1996-06-21Fredrik Hübinette (Hubbe)  if(mark_sp < mark_stack)
5267b71995-08-09Fredrik Hübinette (Hubbe)  fatal("Mark stack underflow.\n"); for(s=evaluator_stack;s<sp;s++) check_svalue(s); s=evaluator_stack; for(m=mark_stack;m<mark_sp;m++) { if(*m < s) fatal("Mark stack failiure.\n"); s=*m; }
0f887e1996-08-12Fredrik Hübinette (Hubbe)  if(s > &(evaluator_stack[stack_size]))
5267b71995-08-09Fredrik Hübinette (Hubbe)  fatal("Mark stack exceeds svalue stack\n"); for(f=fp;f;f=f->parent_frame) {
0f887e1996-08-12Fredrik Hübinette (Hubbe)  if(f->locals) { if(f->locals < evaluator_stack || f->locals > &(evaluator_stack[stack_size]))
5267b71995-08-09Fredrik Hübinette (Hubbe)  fatal("Local variable pointer points to Finspång.\n");
0f887e1996-08-12Fredrik Hübinette (Hubbe)  if(f->args < 0 || f->args > stack_size) fatal("FEL FEL FEL! HELP!! (corrupted frame)\n"); }
5267b71995-08-09Fredrik Hübinette (Hubbe)  } } #endif
be478c1997-08-30Henrik Grubbström (Grubba) void cleanup_interpret(void)
5267b71995-08-09Fredrik Hübinette (Hubbe) { #ifdef DEBUG int e; #endif while(fp) { free_object(fp->current_object); free_program(fp->context.prog); fp = fp->parent_frame; } #ifdef DEBUG for(e=0;e<BACKLOG;e++) { if(backlog[e].program) { free_program(backlog[e].program); backlog[e].program=0; } } #endif reset_evaluator();
b208c11996-08-03Fredrik Hübinette (Hubbe)  #ifdef USE_MMAP_FOR_STACK
3c9f631996-09-23Fredrik Hübinette (Hubbe)  if(!evaluator_stack_malloced) { munmap((char *)evaluator_stack, stack_size*sizeof(struct svalue)); evaluator_stack=0; } if(!mark_stack_malloced) { munmap((char *)mark_stack, stack_size*sizeof(struct svalue *)); mark_stack=0; }
b208c11996-08-03Fredrik Hübinette (Hubbe) #endif
3c9f631996-09-23Fredrik Hübinette (Hubbe)  if(evaluator_stack) free((char *)evaluator_stack); if(mark_stack) free((char *)mark_stack); mark_stack=0; evaluator_stack=0; mark_stack_malloced=0; evaluator_stack_malloced=0;
5267b71995-08-09Fredrik Hübinette (Hubbe) }