7d7d7e1999-01-31Fredrik Hübinette (Hubbe) #undef GET_ARG #undef GET_ARG2 #ifdef PIKE_DEBUG #define GET_ARG() (backlog[backlogp].arg=(\ instr=prefix,\ prefix=0,\ instr+=EXTRACT_UCHAR(pc++),\ (t_flag>3 ? sprintf(trace_buffer,"- Arg = %ld\n",(long)instr),write_to_stderr(trace_buffer,strlen(trace_buffer)) : 0),\ instr)) #define GET_ARG2() (\ instr=EXTRACT_UCHAR(pc++),\ (t_flag>3 ? sprintf(trace_buffer,"- Arg2= %ld\n",(long)instr),write_to_stderr(trace_buffer,strlen(trace_buffer)) : 0),\ instr) #else #define GET_ARG() (instr=prefix,prefix=0,instr+EXTRACT_UCHAR(pc++)) #define GET_ARG2() EXTRACT_UCHAR(pc++) #endif static int eval_instruction(unsigned char *pc) { unsigned INT32 accumulator=0,instr, prefix=0;
a2ad152000-02-16Fredrik Hübinette (Hubbe)  debug_malloc_touch(Pike_fp);
7d7d7e1999-01-31Fredrik Hübinette (Hubbe)  while(1) {
a2ad152000-02-16Fredrik Hübinette (Hubbe)  Pike_fp->pc = pc;
7d7d7e1999-01-31Fredrik Hübinette (Hubbe)  instr=EXTRACT_UCHAR(pc++); #ifdef PIKE_DEBUG if(d_flag) {
dcbfa71999-05-07Fredrik Hübinette (Hubbe) #ifdef _REENTRANT #ifndef __NT__
7d7d7e1999-01-31Fredrik Hübinette (Hubbe)  if(!mt_trylock(& interpreter_lock)) fatal("Interpreter running unlocked!\n"); #endif
dcbfa71999-05-07Fredrik Hübinette (Hubbe)  if(d_flag>1 && thread_for_id(th_self()) != thread_id) fatal("thread_for_id() (or thread_id) failed in interpreter.h! %p != %p\n",thread_for_id(th_self()),thread_id); #endif
a2ad152000-02-16Fredrik Hübinette (Hubbe)  Pike_sp[0].type=99; /* an invalid type */ Pike_sp[1].type=99; Pike_sp[2].type=99; Pike_sp[3].type=99;
7d7d7e1999-01-31Fredrik Hübinette (Hubbe) 
a2ad152000-02-16Fredrik Hübinette (Hubbe)  if(Pike_sp<Pike_evaluator_stack || Pike_mark_sp < Pike_mark_stack || Pike_fp->locals>Pike_sp)
7d7d7e1999-01-31Fredrik Hübinette (Hubbe)  fatal("Stack error (generic).\n");
a2ad152000-02-16Fredrik Hübinette (Hubbe)  if(Pike_sp > Pike_evaluator_stack+Pike_stack_size)
7d7d7e1999-01-31Fredrik Hübinette (Hubbe)  fatal("Stack error (overflow).\n");
a2ad152000-02-16Fredrik Hübinette (Hubbe)  if(Pike_fp->fun>=0 && Pike_fp->current_object->prog && Pike_fp->locals+Pike_fp->num_locals > Pike_sp)
7d7d7e1999-01-31Fredrik Hübinette (Hubbe)  fatal("Stack error (stupid!).\n");
a2ad152000-02-16Fredrik Hübinette (Hubbe)  if(recoveries && Pike_sp-Pike_evaluator_stack < recoveries->Pike_sp)
7d7d7e1999-01-31Fredrik Hübinette (Hubbe)  fatal("Stack error (underflow).\n");
a2ad152000-02-16Fredrik Hübinette (Hubbe)  if(Pike_mark_sp > Pike_mark_stack && Pike_mark_sp[-1] > Pike_sp)
7d7d7e1999-01-31Fredrik Hübinette (Hubbe)  fatal("Stack error (underflow?)\n"); if(d_flag > 9) do_debug(); backlogp++; if(backlogp >= BACKLOG) backlogp=0; if(backlog[backlogp].program) free_program(backlog[backlogp].program);
a2ad152000-02-16Fredrik Hübinette (Hubbe)  backlog[backlogp].program=Pike_fp->context.prog; add_ref(Pike_fp->context.prog);
7d7d7e1999-01-31Fredrik Hübinette (Hubbe)  backlog[backlogp].instruction=instr; backlog[backlogp].arg=0; backlog[backlogp].pc=pc;
e1fed61999-09-09Fredrik Hübinette (Hubbe) 
a2ad152000-02-16Fredrik Hübinette (Hubbe)  debug_malloc_touch(Pike_fp->current_object);
b040a21999-09-14Fredrik Hübinette (Hubbe)  switch(d_flag) { default: case 3:
a2ad152000-02-16Fredrik Hübinette (Hubbe)  check_object(Pike_fp->current_object);
8f29a31999-09-15Fredrik Hübinette (Hubbe) /* break; */
b040a21999-09-14Fredrik Hübinette (Hubbe)  case 2:
a2ad152000-02-16Fredrik Hübinette (Hubbe)  check_object_context(Pike_fp->current_object, Pike_fp->context.prog, Pike_fp->current_storage);
b040a21999-09-14Fredrik Hübinette (Hubbe)  case 1: case 0: break; }
7d7d7e1999-01-31Fredrik Hübinette (Hubbe)  } if(t_flag > 2) { char *file, *f; INT32 linep;
a2ad152000-02-16Fredrik Hübinette (Hubbe)  file=get_line(pc-1,Pike_fp->context.prog,&linep);
7d7d7e1999-01-31Fredrik Hübinette (Hubbe)  while((f=STRCHR(file,'/'))) file=f+1; fprintf(stderr,"- %s:%4ld:(%lx): %-25s %4ld %4ld\n", file,(long)linep,
a2ad152000-02-16Fredrik Hübinette (Hubbe)  (long)(pc-Pike_fp->context.prog->program-1),
7d7d7e1999-01-31Fredrik Hübinette (Hubbe)  get_f_name(instr + F_OFFSET),
a2ad152000-02-16Fredrik Hübinette (Hubbe)  (long)(Pike_sp-Pike_evaluator_stack), (long)(Pike_mark_sp-Pike_mark_stack));
7d7d7e1999-01-31Fredrik Hübinette (Hubbe)  } if(instr + F_OFFSET < F_MAX_OPCODE) ADD_RUNNED(instr + F_OFFSET); #endif 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; CASE(F_LDA); accumulator=GET_ARG(); break; /* Push number */
a2ad152000-02-16Fredrik Hübinette (Hubbe)  CASE(F_UNDEFINED); push_int(0); Pike_sp[-1].subtype=NUMBER_UNDEFINED; break;
7d7d7e1999-01-31Fredrik 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; /* The rest of the basic 'push value' instructions */
a2ad152000-02-16Fredrik Hübinette (Hubbe)  CASE(F_MARK_AND_STRING); *(Pike_mark_sp++)=Pike_sp;
7d7d7e1999-01-31Fredrik Hübinette (Hubbe)  CASE(F_STRING);
a2ad152000-02-16Fredrik Hübinette (Hubbe)  copy_shared_string(Pike_sp->u.string,Pike_fp->context.prog->strings[GET_ARG()]); Pike_sp->type=PIKE_T_STRING; Pike_sp->subtype=0; Pike_sp++;
7d7d7e1999-01-31Fredrik Hübinette (Hubbe)  print_return_value(); break; CASE(F_ARROW_STRING);
a2ad152000-02-16Fredrik Hübinette (Hubbe)  copy_shared_string(Pike_sp->u.string,Pike_fp->context.prog->strings[GET_ARG()]); Pike_sp->type=PIKE_T_STRING; Pike_sp->subtype=1; /* Magic */ Pike_sp++;
7d7d7e1999-01-31Fredrik Hübinette (Hubbe)  print_return_value(); break; CASE(F_CONSTANT);
a2ad152000-02-16Fredrik Hübinette (Hubbe)  assign_svalue_no_free(Pike_sp++,& Pike_fp->context.prog->constants[GET_ARG()].sval);
7d7d7e1999-01-31Fredrik Hübinette (Hubbe)  print_return_value(); break; CASE(F_FLOAT);
a2ad152000-02-16Fredrik Hübinette (Hubbe)  Pike_sp->type=PIKE_T_FLOAT; MEMCPY((void *)&Pike_sp->u.float_number, pc, sizeof(FLOAT_TYPE));
7d7d7e1999-01-31Fredrik Hübinette (Hubbe)  pc+=sizeof(FLOAT_TYPE);
a2ad152000-02-16Fredrik Hübinette (Hubbe)  Pike_sp++;
7d7d7e1999-01-31Fredrik Hübinette (Hubbe)  break; CASE(F_LFUN);
a2ad152000-02-16Fredrik Hübinette (Hubbe)  Pike_sp->u.object=Pike_fp->current_object; add_ref(Pike_fp->current_object); Pike_sp->subtype=GET_ARG()+Pike_fp->context.identifier_level; Pike_sp->type=PIKE_T_FUNCTION; Pike_sp++;
7d7d7e1999-01-31Fredrik Hübinette (Hubbe)  print_return_value(); break; CASE(F_TRAMPOLINE); { struct object *o=low_clone(pike_trampoline_program);
a2ad152000-02-16Fredrik Hübinette (Hubbe)  add_ref( ((struct pike_trampoline *)(o->storage))->frame=Pike_fp ); ((struct pike_trampoline *)(o->storage))->func=GET_ARG()+Pike_fp->context.identifier_level;
7d7d7e1999-01-31Fredrik Hübinette (Hubbe)  push_object(o);
f14a742000-01-22Henrik Grubbström (Grubba)  /* Make it look like a function. */
a2ad152000-02-16Fredrik Hübinette (Hubbe)  Pike_sp[-1].subtype = pike_trampoline_program->lfuns[LFUN_CALL]; Pike_sp[-1].type = T_FUNCTION;
7d7d7e1999-01-31Fredrik Hübinette (Hubbe)  print_return_value(); break; } /* The not so basic 'push value' instructions */ CASE(F_GLOBAL);
0ad1d32000-02-15Henrik Grubbström (Grubba)  {
a2ad152000-02-16Fredrik Hübinette (Hubbe)  low_object_index_no_free(Pike_sp, Pike_fp->current_object, GET_ARG() + Pike_fp->context.identifier_level); Pike_sp++;
0ad1d32000-02-15Henrik Grubbström (Grubba)  print_return_value(); }
7d7d7e1999-01-31Fredrik Hübinette (Hubbe)  break; CASE(F_EXTERNAL); { struct inherit *inherit; struct program *p; struct object *o; INT32 i,id=GET_ARG();
a2ad152000-02-16Fredrik Hübinette (Hubbe)  inherit=&Pike_fp->context;
7d7d7e1999-01-31Fredrik Hübinette (Hubbe) 
a2ad152000-02-16Fredrik Hübinette (Hubbe)  o=Pike_fp->current_object;
7d7d7e1999-01-31Fredrik Hübinette (Hubbe)  if(!o) error("Current object is destructed\n"); while(1) { if(inherit->parent_offset) { #ifdef PIKE_DEBUG if(t_flag>4) { sprintf(trace_buffer,"- Following o->parent (accumulator+=%d)\n",inherit->parent_offset-1); write_to_stderr(trace_buffer,strlen(trace_buffer)); } #endif i=o->parent_identifier; o=o->parent; accumulator+=inherit->parent_offset-1; }else{ #ifdef PIKE_DEBUG if(t_flag>4) { sprintf(trace_buffer,"- Following inherit->parent (accumulator+=%d)\n",inherit->parent_offset-1); write_to_stderr(trace_buffer,strlen(trace_buffer)); } #endif i=inherit->parent_identifier; o=inherit->parent; } if(!o) error("Parent was lost during cloning.\n"); if(!(p=o->prog)) error("Attempting to access variable in destructed object\n");
0ad1d32000-02-15Henrik Grubbström (Grubba)  #ifdef DEBUG_MALLOC
e1b5e32000-02-15Fredrik Hübinette (Hubbe)  if (o->refs == 0x55555555) { fprintf(stderr, "The object %p has been zapped!\n", o); describe(p); fatal("Object zapping detected.\n"); }
0ad1d32000-02-15Henrik Grubbström (Grubba)  if (p->refs == 0x55555555) { fprintf(stderr, "The program %p has been zapped!\n", p);
e1b5e32000-02-15Fredrik Hübinette (Hubbe)  describe(p);
0ad1d32000-02-15Henrik Grubbström (Grubba)  fprintf(stderr, "Which taken from the object %p\n", o);
e1b5e32000-02-15Fredrik Hübinette (Hubbe)  describe(o);
0ad1d32000-02-15Henrik Grubbström (Grubba)  fatal("Looks like the program %p has been zapped!\n", p); } #endif /* DEBUG_MALLOC */
e1b5e32000-02-15Fredrik Hübinette (Hubbe)  #ifdef PIKE_DEBUG if(i < 0 || i > p->num_identifiers) fatal("Identifier out of range!\n"); #endif
7d7d7e1999-01-31Fredrik Hübinette (Hubbe)  inherit=INHERIT_FROM_INT(p, i);
0ad1d32000-02-15Henrik Grubbström (Grubba) #ifdef DEBUG_MALLOC if (inherit->storage_offset == 0x55555555) { fprintf(stderr, "The inherit %p has been zapped!\n", inherit); debug_malloc_dump_references(inherit); fprintf(stderr, "It was extracted from the program %p %d\n", p, i);
e1b5e32000-02-15Fredrik Hübinette (Hubbe)  describe(p);
0ad1d32000-02-15Henrik Grubbström (Grubba)  fprintf(stderr, "Which was in turn taken from the object %p\n", o);
e1b5e32000-02-15Fredrik Hübinette (Hubbe)  describe(o);
0ad1d32000-02-15Henrik Grubbström (Grubba)  fatal("Looks like the program %p has been zapped!\n", p); } #endif /* DEBUG_MALLOC */
7d7d7e1999-01-31Fredrik Hübinette (Hubbe)  if(!accumulator) break; --accumulator; }
a2ad152000-02-16Fredrik Hübinette (Hubbe)  low_object_index_no_free(Pike_sp,
7d7d7e1999-01-31Fredrik Hübinette (Hubbe)  o, id + inherit->identifier_level);
a2ad152000-02-16Fredrik Hübinette (Hubbe)  Pike_sp++;
7d7d7e1999-01-31Fredrik Hübinette (Hubbe)  print_return_value(); break; } CASE(F_EXTERNAL_LVALUE); { struct inherit *inherit; struct program *p; struct object *o; INT32 i,id=GET_ARG();
a2ad152000-02-16Fredrik Hübinette (Hubbe)  inherit=&Pike_fp->context; o=Pike_fp->current_object;
7d7d7e1999-01-31Fredrik Hübinette (Hubbe)  if(!o) error("Current object is destructed\n"); while(1) { if(inherit->parent_offset) { i=o->parent_identifier; o=o->parent; accumulator+=inherit->parent_offset-1; }else{ i=inherit->parent_identifier; o=inherit->parent; } 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);
a2ad152000-02-16Fredrik Hübinette (Hubbe)  Pike_sp->type=T_LVALUE; Pike_sp->u.integer=id + inherit->identifier_level; Pike_sp++;
7d7d7e1999-01-31Fredrik Hübinette (Hubbe)  break; }
a2ad152000-02-16Fredrik Hübinette (Hubbe)  CASE(F_MARK_AND_LOCAL); *(Pike_mark_sp++)=Pike_sp;
7d7d7e1999-01-31Fredrik Hübinette (Hubbe)  CASE(F_LOCAL);
a2ad152000-02-16Fredrik Hübinette (Hubbe)  assign_svalue_no_free(Pike_sp++,Pike_fp->locals+GET_ARG());
7d7d7e1999-01-31Fredrik Hübinette (Hubbe)  print_return_value(); break; CASE(F_2_LOCALS);
a2ad152000-02-16Fredrik Hübinette (Hubbe)  assign_svalue_no_free(Pike_sp++,Pike_fp->locals+GET_ARG());
7d7d7e1999-01-31Fredrik Hübinette (Hubbe)  print_return_value();
a2ad152000-02-16Fredrik Hübinette (Hubbe)  assign_svalue_no_free(Pike_sp++,Pike_fp->locals+GET_ARG2());
7d7d7e1999-01-31Fredrik Hübinette (Hubbe)  print_return_value(); break; CASE(F_LOCAL_2_LOCAL); { int tmp=GET_ARG();
a2ad152000-02-16Fredrik Hübinette (Hubbe)  assign_svalue(Pike_fp->locals+tmp, Pike_fp->locals+GET_ARG2());
7d7d7e1999-01-31Fredrik Hübinette (Hubbe)  break; } CASE(F_LOCAL_2_GLOBAL); {
a2ad152000-02-16Fredrik Hübinette (Hubbe)  INT32 tmp=GET_ARG() + Pike_fp->context.identifier_level;
7d7d7e1999-01-31Fredrik Hübinette (Hubbe)  struct identifier *i;
a2ad152000-02-16Fredrik Hübinette (Hubbe)  if(!Pike_fp->current_object->prog)
7d7d7e1999-01-31Fredrik Hübinette (Hubbe)  error("Cannot access global variables in destructed object.\n");
a2ad152000-02-16Fredrik Hübinette (Hubbe)  i=ID_FROM_INT(Pike_fp->current_object->prog, tmp);
7d7d7e1999-01-31Fredrik Hübinette (Hubbe)  if(!IDENTIFIER_IS_VARIABLE(i->identifier_flags)) error("Cannot assign functions or constants.\n"); if(i->run_time_type == T_MIXED) {
a2ad152000-02-16Fredrik Hübinette (Hubbe)  assign_svalue((struct svalue *)GLOBAL_FROM_INT(tmp), Pike_fp->locals + GET_ARG2());
7d7d7e1999-01-31Fredrik Hübinette (Hubbe)  }else{ assign_to_short_svalue((union anything *)GLOBAL_FROM_INT(tmp), i->run_time_type,
a2ad152000-02-16Fredrik Hübinette (Hubbe)  Pike_fp->locals + GET_ARG2());
7d7d7e1999-01-31Fredrik Hübinette (Hubbe)  } break; } CASE(F_GLOBAL_2_LOCAL); {
a2ad152000-02-16Fredrik Hübinette (Hubbe)  INT32 tmp=GET_ARG() + Pike_fp->context.identifier_level;
7d7d7e1999-01-31Fredrik Hübinette (Hubbe)  INT32 tmp2=GET_ARG2();
a2ad152000-02-16Fredrik Hübinette (Hubbe)  free_svalue(Pike_fp->locals + tmp2); low_object_index_no_free(Pike_fp->locals + tmp2, Pike_fp->current_object,
7d7d7e1999-01-31Fredrik Hübinette (Hubbe)  tmp); break; } CASE(F_LOCAL_LVALUE);
a2ad152000-02-16Fredrik Hübinette (Hubbe)  Pike_sp[0].type=T_LVALUE; Pike_sp[0].u.lval=Pike_fp->locals+GET_ARG(); Pike_sp[1].type=T_VOID; Pike_sp+=2;
7d7d7e1999-01-31Fredrik Hübinette (Hubbe)  break; CASE(F_LEXICAL_LOCAL); {
a2ad152000-02-16Fredrik Hübinette (Hubbe)  struct pike_frame *f=Pike_fp;
7d7d7e1999-01-31Fredrik Hübinette (Hubbe)  while(accumulator--) { f=f->scope; if(!f) error("Lexical scope error.\n"); } push_svalue(f->locals + GET_ARG()); print_return_value(); break; } CASE(F_LEXICAL_LOCAL_LVALUE); {
a2ad152000-02-16Fredrik Hübinette (Hubbe)  struct pike_frame *f=Pike_fp;
7d7d7e1999-01-31Fredrik Hübinette (Hubbe)  while(accumulator--) { f=f->scope; if(!f) error("Lexical scope error.\n"); }
a2ad152000-02-16Fredrik Hübinette (Hubbe)  Pike_sp[0].type=T_LVALUE; Pike_sp[0].u.lval=f->locals+GET_ARG(); Pike_sp[1].type=T_VOID; Pike_sp+=2;
7d7d7e1999-01-31Fredrik Hübinette (Hubbe)  break; } CASE(F_ARRAY_LVALUE); f_aggregate(GET_ARG()*2);
a2ad152000-02-16Fredrik Hübinette (Hubbe)  Pike_sp[-1].u.array->flags |= ARRAY_LVALUE; Pike_sp[-1].u.array->type_field |= BIT_UNFINISHED | BIT_MIXED; Pike_sp[0]=Pike_sp[-1]; Pike_sp[-1].type=T_ARRAY_LVALUE; Pike_sp++;
7d7d7e1999-01-31Fredrik Hübinette (Hubbe)  break; CASE(F_CLEAR_2_LOCAL); instr=GET_ARG();
a2ad152000-02-16Fredrik Hübinette (Hubbe)  free_svalues(Pike_fp->locals + instr, 2, -1); Pike_fp->locals[instr].type=PIKE_T_INT; Pike_fp->locals[instr].subtype=0; Pike_fp->locals[instr].u.integer=0; Pike_fp->locals[instr+1].type=PIKE_T_INT; Pike_fp->locals[instr+1].subtype=0; Pike_fp->locals[instr+1].u.integer=0;
7d7d7e1999-01-31Fredrik Hübinette (Hubbe)  break; CASE(F_CLEAR_4_LOCAL); { int e; instr=GET_ARG();
a2ad152000-02-16Fredrik Hübinette (Hubbe)  free_svalues(Pike_fp->locals + instr, 4, -1);
7d7d7e1999-01-31Fredrik Hübinette (Hubbe)  for(e=0;e<4;e++) {
a2ad152000-02-16Fredrik Hübinette (Hubbe)  Pike_fp->locals[instr+e].type=PIKE_T_INT; Pike_fp->locals[instr+e].subtype=0; Pike_fp->locals[instr+e].u.integer=0;
7d7d7e1999-01-31Fredrik Hübinette (Hubbe)  } break; } CASE(F_CLEAR_LOCAL); instr=GET_ARG();
a2ad152000-02-16Fredrik Hübinette (Hubbe)  free_svalue(Pike_fp->locals + instr); Pike_fp->locals[instr].type=PIKE_T_INT; Pike_fp->locals[instr].subtype=0; Pike_fp->locals[instr].u.integer=0;
7d7d7e1999-01-31Fredrik Hübinette (Hubbe)  break; CASE(F_INC_LOCAL); instr=GET_ARG();
43899f1999-10-23Fredrik Noring #ifdef AUTO_BIGNUM
a2ad152000-02-16Fredrik Hübinette (Hubbe)  if(Pike_fp->locals[instr].type == PIKE_T_INT && !INT_TYPE_ADD_OVERFLOW(Pike_fp->locals[instr].u.integer, 1))
43899f1999-10-23Fredrik Noring #else
a2ad152000-02-16Fredrik Hübinette (Hubbe)  if(Pike_fp->locals[instr].type == PIKE_T_INT)
43899f1999-10-23Fredrik Noring #endif /* AUTO_BIGNUM */ {
a2ad152000-02-16Fredrik Hübinette (Hubbe)  Pike_fp->locals[instr].u.integer++; assign_svalue_no_free(Pike_sp++,Pike_fp->locals+instr);
43899f1999-10-23Fredrik Noring  } else
7d7d7e1999-01-31Fredrik Hübinette (Hubbe)  {
a2ad152000-02-16Fredrik Hübinette (Hubbe)  assign_svalue_no_free(Pike_sp++,Pike_fp->locals+instr);
7d7d7e1999-01-31Fredrik Hübinette (Hubbe)  push_int(1); f_add(2);
a2ad152000-02-16Fredrik Hübinette (Hubbe)  assign_svalue(Pike_fp->locals+instr,Pike_sp-1);
7d7d7e1999-01-31Fredrik Hübinette (Hubbe)  } break; CASE(F_POST_INC_LOCAL); instr=GET_ARG();
a2ad152000-02-16Fredrik Hübinette (Hubbe)  assign_svalue_no_free(Pike_sp++,Pike_fp->locals+instr);
7d7d7e1999-01-31Fredrik Hübinette (Hubbe)  goto inc_local_and_pop; CASE(F_INC_LOCAL_AND_POP); instr=GET_ARG(); inc_local_and_pop:
43899f1999-10-23Fredrik Noring #ifdef AUTO_BIGNUM
a2ad152000-02-16Fredrik Hübinette (Hubbe)  if(Pike_fp->locals[instr].type == PIKE_T_INT && !INT_TYPE_ADD_OVERFLOW(Pike_fp->locals[instr].u.integer, 1))
43899f1999-10-23Fredrik Noring #else
a2ad152000-02-16Fredrik Hübinette (Hubbe)  if(Pike_fp->locals[instr].type == PIKE_T_INT)
43899f1999-10-23Fredrik Noring #endif /* AUTO_BIGNUM */
7d7d7e1999-01-31Fredrik Hübinette (Hubbe)  {
a2ad152000-02-16Fredrik Hübinette (Hubbe)  Pike_fp->locals[instr].u.integer++;
7d7d7e1999-01-31Fredrik Hübinette (Hubbe)  }else{
a2ad152000-02-16Fredrik Hübinette (Hubbe)  assign_svalue_no_free(Pike_sp++,Pike_fp->locals+instr);
7d7d7e1999-01-31Fredrik Hübinette (Hubbe)  push_int(1); f_add(2);
a2ad152000-02-16Fredrik Hübinette (Hubbe)  assign_svalue(Pike_fp->locals+instr,Pike_sp-1);
7d7d7e1999-01-31Fredrik Hübinette (Hubbe)  pop_stack(); } break; CASE(F_DEC_LOCAL); instr=GET_ARG();
43899f1999-10-23Fredrik Noring #ifdef AUTO_BIGNUM
a2ad152000-02-16Fredrik Hübinette (Hubbe)  if(Pike_fp->locals[instr].type == PIKE_T_INT && !INT_TYPE_SUB_OVERFLOW(Pike_fp->locals[instr].u.integer, 1))
43899f1999-10-23Fredrik Noring #else
a2ad152000-02-16Fredrik Hübinette (Hubbe)  if(Pike_fp->locals[instr].type == PIKE_T_INT)
43899f1999-10-23Fredrik Noring #endif /* AUTO_BIGNUM */
7d7d7e1999-01-31Fredrik Hübinette (Hubbe)  {
a2ad152000-02-16Fredrik Hübinette (Hubbe)  Pike_fp->locals[instr].u.integer--; assign_svalue_no_free(Pike_sp++,Pike_fp->locals+instr);
7d7d7e1999-01-31Fredrik Hübinette (Hubbe)  }else{
a2ad152000-02-16Fredrik Hübinette (Hubbe)  assign_svalue_no_free(Pike_sp++,Pike_fp->locals+instr);
7d7d7e1999-01-31Fredrik Hübinette (Hubbe)  push_int(1); o_subtract();
a2ad152000-02-16Fredrik Hübinette (Hubbe)  assign_svalue(Pike_fp->locals+instr,Pike_sp-1);
7d7d7e1999-01-31Fredrik Hübinette (Hubbe)  } break; CASE(F_POST_DEC_LOCAL); instr=GET_ARG();
a2ad152000-02-16Fredrik Hübinette (Hubbe)  assign_svalue_no_free(Pike_sp++,Pike_fp->locals+instr);
7d7d7e1999-01-31Fredrik Hübinette (Hubbe)  goto dec_local_and_pop;
a2ad152000-02-16Fredrik Hübinette (Hubbe)  /* Pike_fp->locals[instr].u.integer--; */
7d7d7e1999-01-31Fredrik Hübinette (Hubbe)  break; CASE(F_DEC_LOCAL_AND_POP); instr=GET_ARG(); dec_local_and_pop:
43899f1999-10-23Fredrik Noring #ifdef AUTO_BIGNUM
a2ad152000-02-16Fredrik Hübinette (Hubbe)  if(Pike_fp->locals[instr].type == PIKE_T_INT && !INT_TYPE_SUB_OVERFLOW(Pike_fp->locals[instr].u.integer, 1))
43899f1999-10-23Fredrik Noring #else
a2ad152000-02-16Fredrik Hübinette (Hubbe)  if(Pike_fp->locals[instr].type == PIKE_T_INT)
43899f1999-10-23Fredrik Noring #endif /* AUTO_BIGNUM */
7d7d7e1999-01-31Fredrik Hübinette (Hubbe)  {
a2ad152000-02-16Fredrik Hübinette (Hubbe)  Pike_fp->locals[instr].u.integer--;
7d7d7e1999-01-31Fredrik Hübinette (Hubbe)  }else{
a2ad152000-02-16Fredrik Hübinette (Hubbe)  assign_svalue_no_free(Pike_sp++,Pike_fp->locals+instr);
7d7d7e1999-01-31Fredrik Hübinette (Hubbe)  push_int(1); o_subtract();
a2ad152000-02-16Fredrik Hübinette (Hubbe)  assign_svalue(Pike_fp->locals+instr,Pike_sp-1);
7d7d7e1999-01-31Fredrik Hübinette (Hubbe)  pop_stack(); } break; CASE(F_LTOSVAL);
a2ad152000-02-16Fredrik Hübinette (Hubbe)  lvalue_to_svalue_no_free(Pike_sp,Pike_sp-2); Pike_sp++;
7d7d7e1999-01-31Fredrik Hübinette (Hubbe)  break; CASE(F_LTOSVAL2);
a2ad152000-02-16Fredrik Hübinette (Hubbe)  Pike_sp[0]=Pike_sp[-1]; Pike_sp[-1].type=PIKE_T_INT; Pike_sp++; lvalue_to_svalue_no_free(Pike_sp-2,Pike_sp-4);
7d7d7e1999-01-31Fredrik Hübinette (Hubbe)  /* 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 */
a2ad152000-02-16Fredrik Hübinette (Hubbe)  if( (1 << Pike_sp[-2].type) & ( BIT_ARRAY | BIT_MULTISET | BIT_MAPPING | BIT_STRING ))
7d7d7e1999-01-31Fredrik Hübinette (Hubbe)  { struct svalue s;
0542ef1999-11-17Fredrik Hübinette (Hubbe)  s.type=PIKE_T_INT;
7d7d7e1999-01-31Fredrik Hübinette (Hubbe)  s.subtype=0; s.u.integer=0;
a2ad152000-02-16Fredrik Hübinette (Hubbe)  assign_lvalue(Pike_sp-4,&s);
7d7d7e1999-01-31Fredrik Hübinette (Hubbe)  } break; CASE(F_ADD_TO_AND_POP);
a2ad152000-02-16Fredrik Hübinette (Hubbe)  Pike_sp[0]=Pike_sp[-1]; Pike_sp[-1].type=PIKE_T_INT; Pike_sp++; lvalue_to_svalue_no_free(Pike_sp-2,Pike_sp-4);
7d7d7e1999-01-31Fredrik Hübinette (Hubbe)  /* 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 */
a2ad152000-02-16Fredrik Hübinette (Hubbe)  if( (1 << Pike_sp[-2].type) & ( BIT_ARRAY | BIT_MULTISET | BIT_MAPPING | BIT_STRING ))
7d7d7e1999-01-31Fredrik Hübinette (Hubbe)  { struct svalue s;
0542ef1999-11-17Fredrik Hübinette (Hubbe)  s.type=PIKE_T_INT;
7d7d7e1999-01-31Fredrik Hübinette (Hubbe)  s.subtype=0; s.u.integer=0;
a2ad152000-02-16Fredrik Hübinette (Hubbe)  assign_lvalue(Pike_sp-4,&s);
7d7d7e1999-01-31Fredrik Hübinette (Hubbe)  } f_add(2);
a2ad152000-02-16Fredrik Hübinette (Hubbe)  assign_lvalue(Pike_sp-3,Pike_sp-1);
7d7d7e1999-01-31Fredrik Hübinette (Hubbe)  pop_n_elems(3); break; CASE(F_GLOBAL_LVALUE); { struct identifier *i;
a2ad152000-02-16Fredrik Hübinette (Hubbe)  INT32 tmp=GET_ARG() + Pike_fp->context.identifier_level;
7d7d7e1999-01-31Fredrik Hübinette (Hubbe) 
a2ad152000-02-16Fredrik Hübinette (Hubbe)  if(!Pike_fp->current_object->prog)
7d7d7e1999-01-31Fredrik Hübinette (Hubbe)  error("Cannot access global variables in destructed object.\n");
a2ad152000-02-16Fredrik Hübinette (Hubbe)  i=ID_FROM_INT(Pike_fp->current_object->prog, tmp);
7d7d7e1999-01-31Fredrik Hübinette (Hubbe)  if(!IDENTIFIER_IS_VARIABLE(i->identifier_flags)) error("Cannot re-assign functions or constants.\n"); if(i->run_time_type == T_MIXED) {
a2ad152000-02-16Fredrik Hübinette (Hubbe)  Pike_sp[0].type=T_LVALUE; Pike_sp[0].u.lval=(struct svalue *)GLOBAL_FROM_INT(tmp);
7d7d7e1999-01-31Fredrik Hübinette (Hubbe)  }else{
a2ad152000-02-16Fredrik Hübinette (Hubbe)  Pike_sp[0].type=T_SHORT_LVALUE; Pike_sp[0].u.short_lval= (union anything *)GLOBAL_FROM_INT(tmp); Pike_sp[0].subtype=i->run_time_type;
7d7d7e1999-01-31Fredrik Hübinette (Hubbe)  }
a2ad152000-02-16Fredrik Hübinette (Hubbe)  Pike_sp[1].type=T_VOID; Pike_sp+=2;
7d7d7e1999-01-31Fredrik Hübinette (Hubbe)  break; } CASE(F_INC); {
a2ad152000-02-16Fredrik Hübinette (Hubbe)  union anything *u=get_pointer_if_this_type(Pike_sp-2, PIKE_T_INT);
2ba9191999-10-23Fredrik Hübinette (Hubbe)  if(u #ifdef AUTO_BIGNUM && !INT_TYPE_ADD_OVERFLOW(u->integer, 1) #endif )
7d7d7e1999-01-31Fredrik Hübinette (Hubbe)  { instr=++ u->integer; pop_n_elems(2); push_int(u->integer);
2ba9191999-10-23Fredrik Hübinette (Hubbe)  break;
7d7d7e1999-01-31Fredrik Hübinette (Hubbe)  }
a2ad152000-02-16Fredrik Hübinette (Hubbe)  lvalue_to_svalue_no_free(Pike_sp, Pike_sp-2); Pike_sp++;
2ba9191999-10-23Fredrik Hübinette (Hubbe)  push_int(1); f_add(2);
a2ad152000-02-16Fredrik Hübinette (Hubbe)  assign_lvalue(Pike_sp-3, Pike_sp-1); assign_svalue(Pike_sp-3, Pike_sp-1);
2ba9191999-10-23Fredrik Hübinette (Hubbe)  pop_n_elems(2);
7d7d7e1999-01-31Fredrik Hübinette (Hubbe)  break; } CASE(F_DEC); {
a2ad152000-02-16Fredrik Hübinette (Hubbe)  union anything *u=get_pointer_if_this_type(Pike_sp-2, PIKE_T_INT);
2ba9191999-10-23Fredrik Hübinette (Hubbe)  if(u #ifdef AUTO_BIGNUM && !INT_TYPE_SUB_OVERFLOW(u->integer, 1) #endif )
7d7d7e1999-01-31Fredrik Hübinette (Hubbe)  { instr=-- u->integer; pop_n_elems(2); push_int(u->integer);
2ba9191999-10-23Fredrik Hübinette (Hubbe)  break;
7d7d7e1999-01-31Fredrik Hübinette (Hubbe)  }
a2ad152000-02-16Fredrik Hübinette (Hubbe)  lvalue_to_svalue_no_free(Pike_sp, Pike_sp-2); Pike_sp++;
2ba9191999-10-23Fredrik Hübinette (Hubbe)  push_int(1); o_subtract();
a2ad152000-02-16Fredrik Hübinette (Hubbe)  assign_lvalue(Pike_sp-3, Pike_sp-1); assign_svalue(Pike_sp-3, Pike_sp-1);
2ba9191999-10-23Fredrik Hübinette (Hubbe)  pop_n_elems(2);
7d7d7e1999-01-31Fredrik Hübinette (Hubbe)  break; } CASE(F_DEC_AND_POP); {
a2ad152000-02-16Fredrik Hübinette (Hubbe)  union anything *u=get_pointer_if_this_type(Pike_sp-2, PIKE_T_INT);
f075fd1999-11-08Fredrik Hübinette (Hubbe)  if(u #ifdef AUTO_BIGNUM && !INT_TYPE_SUB_OVERFLOW(u->integer, 1) #endif )
7d7d7e1999-01-31Fredrik Hübinette (Hubbe)  { instr=-- u->integer; pop_n_elems(2); }else{
a2ad152000-02-16Fredrik Hübinette (Hubbe)  lvalue_to_svalue_no_free(Pike_sp, Pike_sp-2); Pike_sp++;
7d7d7e1999-01-31Fredrik Hübinette (Hubbe)  push_int(1); o_subtract();
a2ad152000-02-16Fredrik Hübinette (Hubbe)  assign_lvalue(Pike_sp-3, Pike_sp-1);
7d7d7e1999-01-31Fredrik Hübinette (Hubbe)  pop_n_elems(3); } break; } CASE(F_INC_AND_POP); {
a2ad152000-02-16Fredrik Hübinette (Hubbe)  union anything *u=get_pointer_if_this_type(Pike_sp-2, PIKE_T_INT);
2ba9191999-10-23Fredrik Hübinette (Hubbe)  if(u #ifdef AUTO_BIGNUM && !INT_TYPE_ADD_OVERFLOW(u->integer, 1) #endif )
7d7d7e1999-01-31Fredrik Hübinette (Hubbe)  { instr=++ u->integer; pop_n_elems(2);
2ba9191999-10-23Fredrik Hübinette (Hubbe)  break;
7d7d7e1999-01-31Fredrik Hübinette (Hubbe)  }
a2ad152000-02-16Fredrik Hübinette (Hubbe)  lvalue_to_svalue_no_free(Pike_sp, Pike_sp-2); Pike_sp++;
2ba9191999-10-23Fredrik Hübinette (Hubbe)  push_int(1); f_add(2);
a2ad152000-02-16Fredrik Hübinette (Hubbe)  assign_lvalue(Pike_sp-3, Pike_sp-1);
2ba9191999-10-23Fredrik Hübinette (Hubbe)  pop_n_elems(3);
7d7d7e1999-01-31Fredrik Hübinette (Hubbe)  break; } CASE(F_POST_INC); {
a2ad152000-02-16Fredrik Hübinette (Hubbe)  union anything *u=get_pointer_if_this_type(Pike_sp-2, PIKE_T_INT);
2ba9191999-10-23Fredrik Hübinette (Hubbe)  if(u #ifdef AUTO_BIGNUM && !INT_TYPE_ADD_OVERFLOW(u->integer, 1) #endif )
7d7d7e1999-01-31Fredrik Hübinette (Hubbe)  { instr=u->integer ++; pop_n_elems(2); push_int(instr);
2ba9191999-10-23Fredrik Hübinette (Hubbe)  break;
7d7d7e1999-01-31Fredrik Hübinette (Hubbe)  }
a2ad152000-02-16Fredrik Hübinette (Hubbe)  lvalue_to_svalue_no_free(Pike_sp, Pike_sp-2); Pike_sp++; assign_svalue_no_free(Pike_sp,Pike_sp-1); Pike_sp++;
2ba9191999-10-23Fredrik Hübinette (Hubbe)  push_int(1); f_add(2);
a2ad152000-02-16Fredrik Hübinette (Hubbe)  assign_lvalue(Pike_sp-4, Pike_sp-1); assign_svalue(Pike_sp-4, Pike_sp-2);
2ba9191999-10-23Fredrik Hübinette (Hubbe)  pop_n_elems(3);
7d7d7e1999-01-31Fredrik Hübinette (Hubbe)  break; } CASE(F_POST_DEC); {
a2ad152000-02-16Fredrik Hübinette (Hubbe)  union anything *u=get_pointer_if_this_type(Pike_sp-2, PIKE_T_INT);
2ba9191999-10-23Fredrik Hübinette (Hubbe)  if(u #ifdef AUTO_BIGNUM && !INT_TYPE_SUB_OVERFLOW(u->integer, 1) #endif )
7d7d7e1999-01-31Fredrik Hübinette (Hubbe)  { instr=u->integer --; pop_n_elems(2); push_int(instr);
2ba9191999-10-23Fredrik Hübinette (Hubbe)  break;
7d7d7e1999-01-31Fredrik Hübinette (Hubbe)  }
a2ad152000-02-16Fredrik Hübinette (Hubbe)  lvalue_to_svalue_no_free(Pike_sp, Pike_sp-2); Pike_sp++; assign_svalue_no_free(Pike_sp,Pike_sp-1); Pike_sp++;
2ba9191999-10-23Fredrik Hübinette (Hubbe)  push_int(1); o_subtract();
a2ad152000-02-16Fredrik Hübinette (Hubbe)  assign_lvalue(Pike_sp-4, Pike_sp-1); assign_svalue(Pike_sp-4, Pike_sp-2);
2ba9191999-10-23Fredrik Hübinette (Hubbe)  pop_n_elems(3);
7d7d7e1999-01-31Fredrik Hübinette (Hubbe)  break; } CASE(F_ASSIGN);
a2ad152000-02-16Fredrik Hübinette (Hubbe)  assign_lvalue(Pike_sp-3,Pike_sp-1); free_svalue(Pike_sp-3); free_svalue(Pike_sp-2); Pike_sp[-3]=Pike_sp[-1]; Pike_sp-=2;
7d7d7e1999-01-31Fredrik Hübinette (Hubbe)  break; CASE(F_ASSIGN_AND_POP);
a2ad152000-02-16Fredrik Hübinette (Hubbe)  assign_lvalue(Pike_sp-3,Pike_sp-1);
7d7d7e1999-01-31Fredrik Hübinette (Hubbe)  pop_n_elems(3); break; CASE(F_APPLY_ASSIGN_LOCAL);
a2ad152000-02-16Fredrik Hübinette (Hubbe)  strict_apply_svalue(Pike_fp->context.prog->constants + GET_ARG(), Pike_sp - *--Pike_mark_sp );
7d7d7e1999-01-31Fredrik Hübinette (Hubbe)  /* Fall through */ CASE(F_ASSIGN_LOCAL);
a2ad152000-02-16Fredrik Hübinette (Hubbe)  assign_svalue(Pike_fp->locals+GET_ARG(),Pike_sp-1);
7d7d7e1999-01-31Fredrik Hübinette (Hubbe)  break; CASE(F_APPLY_ASSIGN_LOCAL_AND_POP);
a2ad152000-02-16Fredrik Hübinette (Hubbe)  strict_apply_svalue(Pike_fp->context.prog->constants + GET_ARG(), Pike_sp - *--Pike_mark_sp );
7d7d7e1999-01-31Fredrik Hübinette (Hubbe)  /* Fall through */ CASE(F_ASSIGN_LOCAL_AND_POP); instr=GET_ARG();
a2ad152000-02-16Fredrik Hübinette (Hubbe)  free_svalue(Pike_fp->locals+instr); Pike_fp->locals[instr]=Pike_sp[-1]; Pike_sp--;
7d7d7e1999-01-31Fredrik Hübinette (Hubbe)  break; CASE(F_ASSIGN_GLOBAL) { struct identifier *i;
a2ad152000-02-16Fredrik Hübinette (Hubbe)  INT32 tmp=GET_ARG() + Pike_fp->context.identifier_level; if(!Pike_fp->current_object->prog)
7d7d7e1999-01-31Fredrik Hübinette (Hubbe)  error("Cannot access global variables in destructed object.\n");
a2ad152000-02-16Fredrik Hübinette (Hubbe)  i=ID_FROM_INT(Pike_fp->current_object->prog, tmp);
7d7d7e1999-01-31Fredrik Hübinette (Hubbe)  if(!IDENTIFIER_IS_VARIABLE(i->identifier_flags)) error("Cannot assign functions or constants.\n"); if(i->run_time_type == T_MIXED) {
a2ad152000-02-16Fredrik Hübinette (Hubbe)  assign_svalue((struct svalue *)GLOBAL_FROM_INT(tmp), Pike_sp-1);
7d7d7e1999-01-31Fredrik Hübinette (Hubbe)  }else{ assign_to_short_svalue((union anything *)GLOBAL_FROM_INT(tmp), i->run_time_type,
a2ad152000-02-16Fredrik Hübinette (Hubbe)  Pike_sp-1);
7d7d7e1999-01-31Fredrik Hübinette (Hubbe)  } } break; CASE(F_ASSIGN_GLOBAL_AND_POP) { struct identifier *i;
a2ad152000-02-16Fredrik Hübinette (Hubbe)  INT32 tmp=GET_ARG() + Pike_fp->context.identifier_level; if(!Pike_fp->current_object->prog)
7d7d7e1999-01-31Fredrik Hübinette (Hubbe)  error("Cannot access global variables in destructed object.\n");
a2ad152000-02-16Fredrik Hübinette (Hubbe)  i=ID_FROM_INT(Pike_fp->current_object->prog, tmp);
7d7d7e1999-01-31Fredrik Hübinette (Hubbe)  if(!IDENTIFIER_IS_VARIABLE(i->identifier_flags)) error("Cannot assign functions or constants.\n"); if(i->run_time_type == T_MIXED) { struct svalue *s=(struct svalue *)GLOBAL_FROM_INT(tmp); free_svalue(s);
a2ad152000-02-16Fredrik Hübinette (Hubbe)  Pike_sp--; *s=*Pike_sp;
7d7d7e1999-01-31Fredrik Hübinette (Hubbe)  }else{ assign_to_short_svalue((union anything *)GLOBAL_FROM_INT(tmp), i->run_time_type,
a2ad152000-02-16Fredrik Hübinette (Hubbe)  Pike_sp-1);
7d7d7e1999-01-31Fredrik Hübinette (Hubbe)  pop_stack(); } } break; /* Stack machine stuff */ CASE(F_POP_VALUE); pop_stack(); break; CASE(F_POP_N_ELEMS); pop_n_elems(GET_ARG()); break;
a2ad152000-02-16Fredrik Hübinette (Hubbe)  CASE(F_MARK2); *(Pike_mark_sp++)=Pike_sp; CASE(F_MARK); *(Pike_mark_sp++)=Pike_sp; break; CASE(F_MARK_X); *(Pike_mark_sp++)=Pike_sp-GET_ARG(); break; CASE(F_POP_MARK); --Pike_mark_sp; break;
7d7d7e1999-01-31Fredrik Hübinette (Hubbe)  CASE(F_CLEAR_STRING_SUBTYPE);
a2ad152000-02-16Fredrik Hübinette (Hubbe)  if(Pike_sp[-1].type==PIKE_T_STRING) Pike_sp[-1].subtype=0;
7d7d7e1999-01-31Fredrik Hübinette (Hubbe)  break; /* Jumps */ CASE(F_BRANCH); DOJUMP(); break; CASE(F_BRANCH_IF_NOT_LOCAL_ARROW); { struct svalue tmp;
0542ef1999-11-17Fredrik Hübinette (Hubbe)  tmp.type=PIKE_T_STRING;
a2ad152000-02-16Fredrik Hübinette (Hubbe)  tmp.u.string=Pike_fp->context.prog->strings[GET_ARG()];
7d7d7e1999-01-31Fredrik Hübinette (Hubbe)  tmp.subtype=1;
a2ad152000-02-16Fredrik Hübinette (Hubbe)  Pike_sp->type=PIKE_T_INT; Pike_sp++; index_no_free(Pike_sp-1,Pike_fp->locals+GET_ARG2() , &tmp);
7d7d7e1999-01-31Fredrik Hübinette (Hubbe)  print_return_value(); } /* Fall through */ CASE(F_BRANCH_WHEN_ZERO);
a2ad152000-02-16Fredrik Hübinette (Hubbe)  if(!IS_ZERO(Pike_sp-1))
7d7d7e1999-01-31Fredrik Hübinette (Hubbe)  { pc+=sizeof(INT32); }else{ DOJUMP(); } pop_stack(); break;
0f19431999-11-29Fredrik Hübinette (Hubbe) 
7d7d7e1999-01-31Fredrik Hübinette (Hubbe)  CASE(F_BRANCH_WHEN_NON_ZERO);
a2ad152000-02-16Fredrik Hübinette (Hubbe)  if(IS_ZERO(Pike_sp-1))
7d7d7e1999-01-31Fredrik Hübinette (Hubbe)  { pc+=sizeof(INT32); }else{ DOJUMP(); } pop_stack(); break; CASE(F_BRANCH_IF_LOCAL); instr=GET_ARG();
a2ad152000-02-16Fredrik Hübinette (Hubbe)  if(IS_ZERO(Pike_fp->locals + instr))
7d7d7e1999-01-31Fredrik Hübinette (Hubbe)  { pc+=sizeof(INT32); }else{ DOJUMP(); } break; CASE(F_BRANCH_IF_NOT_LOCAL); instr=GET_ARG();
a2ad152000-02-16Fredrik Hübinette (Hubbe)  if(!IS_ZERO(Pike_fp->locals + instr))
7d7d7e1999-01-31Fredrik Hübinette (Hubbe)  { pc+=sizeof(INT32); }else{ DOJUMP(); } break; 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); CASE(F_BRANCH_AND_POP_WHEN_ZERO);
a2ad152000-02-16Fredrik Hübinette (Hubbe)  if(!IS_ZERO(Pike_sp-1))
7d7d7e1999-01-31Fredrik Hübinette (Hubbe)  { pc+=sizeof(INT32); }else{ DOJUMP(); pop_stack(); } break; CASE(F_BRANCH_AND_POP_WHEN_NON_ZERO);
a2ad152000-02-16Fredrik Hübinette (Hubbe)  if(IS_ZERO(Pike_sp-1))
7d7d7e1999-01-31Fredrik Hübinette (Hubbe)  { pc+=sizeof(INT32); }else{ DOJUMP(); pop_stack(); } break; CASE(F_LAND);
a2ad152000-02-16Fredrik Hübinette (Hubbe)  if(!IS_ZERO(Pike_sp-1))
7d7d7e1999-01-31Fredrik Hübinette (Hubbe)  { pc+=sizeof(INT32); pop_stack(); }else{ DOJUMP(); } break; CASE(F_LOR);
a2ad152000-02-16Fredrik Hübinette (Hubbe)  if(IS_ZERO(Pike_sp-1))
7d7d7e1999-01-31Fredrik Hübinette (Hubbe)  { pc+=sizeof(INT32); pop_stack(); }else{ DOJUMP(); } break; CASE(F_EQ_OR);
a2ad152000-02-16Fredrik Hübinette (Hubbe)  if(!is_eq(Pike_sp-2,Pike_sp-1))
7d7d7e1999-01-31Fredrik Hübinette (Hubbe)  { pop_n_elems(2); pc+=sizeof(INT32); }else{ pop_n_elems(2); push_int(1); DOJUMP(); } break; CASE(F_EQ_AND);
a2ad152000-02-16Fredrik Hübinette (Hubbe)  if(is_eq(Pike_sp-2,Pike_sp-1))
7d7d7e1999-01-31Fredrik Hübinette (Hubbe)  { pop_n_elems(2); pc+=sizeof(INT32); }else{ pop_n_elems(2); push_int(0); DOJUMP(); } break; CASE(F_CATCH); if(o_catch(pc+sizeof(INT32))) return -1; /* There was a return inside the evaluated code */ else pc+=EXTRACT_INT(pc); break; CASE(F_THROW_ZERO); push_int(0); f_throw(1); break; CASE(F_SWITCH) { INT32 tmp;
a2ad152000-02-16Fredrik Hübinette (Hubbe)  tmp=switch_lookup(Pike_fp->context.prog-> constants[GET_ARG()].sval.u.array,Pike_sp-1);
7d7d7e1999-01-31Fredrik Hübinette (Hubbe)  pc=(unsigned char *)DO_ALIGN(pc,sizeof(INT32)); pc+=(tmp>=0 ? 1+tmp*2 : 2*~tmp) * sizeof(INT32); if(*(INT32*)pc < 0) fast_check_threads_etc(7); pc+=*(INT32*)pc; pop_stack(); break; }
775f3d1999-10-23Fredrik Noring 
f075fd1999-11-08Fredrik Hübinette (Hubbe)  /* FIXME: Does this need bignum tests? /Fixed - Hubbe */
2ba9191999-10-23Fredrik Hübinette (Hubbe)  LOOP(F_INC_LOOP, 1, <, is_lt); LOOP(F_DEC_LOOP, -1, >, is_gt); LOOP(F_INC_NEQ_LOOP, 1, !=, !is_eq); LOOP(F_DEC_NEQ_LOOP, -1, !=, !is_eq);
7d7d7e1999-01-31Fredrik Hübinette (Hubbe)  CASE(F_FOREACH) /* array, lvalue, X, i */ {
a2ad152000-02-16Fredrik Hübinette (Hubbe)  if(Pike_sp[-4].type != PIKE_T_ARRAY) PIKE_ERROR("foreach", "Bad argument 1.\n", Pike_sp-3, 1); if(Pike_sp[-1].u.integer < Pike_sp[-4].u.array->size)
7d7d7e1999-01-31Fredrik Hübinette (Hubbe)  { fast_check_threads_etc(10);
a2ad152000-02-16Fredrik Hübinette (Hubbe)  index_no_free(Pike_sp,Pike_sp-4,Pike_sp-1); Pike_sp++; assign_lvalue(Pike_sp-4, Pike_sp-1); free_svalue(Pike_sp-1); Pike_sp--;
7d7d7e1999-01-31Fredrik Hübinette (Hubbe)  pc+=EXTRACT_INT(pc);
a2ad152000-02-16Fredrik Hübinette (Hubbe)  Pike_sp[-1].u.integer++;
7d7d7e1999-01-31Fredrik Hübinette (Hubbe)  }else{ pc+=sizeof(INT32); } break; } CASE(F_APPLY_AND_RETURN); {
a2ad152000-02-16Fredrik Hübinette (Hubbe)  INT32 args=Pike_sp - *--Pike_mark_sp; /* fprintf(stderr,"%p >= %p\n",Pike_fp->expendible,Pike_sp-args); */ if(Pike_fp->expendible >= Pike_sp-args)
7d7d7e1999-01-31Fredrik Hübinette (Hubbe)  { /* fprintf(stderr,"NOT EXPENDIBLE!\n"); */
a2ad152000-02-16Fredrik Hübinette (Hubbe)  MEMMOVE(Pike_sp-args+1,Pike_sp-args,args*sizeof(struct svalue)); Pike_sp++; Pike_sp[-args-1].type=PIKE_T_INT;
7d7d7e1999-01-31Fredrik Hübinette (Hubbe)  } /* We sabotage the stack here */
a2ad152000-02-16Fredrik Hübinette (Hubbe)  assign_svalue(Pike_sp-args-1,&Pike_fp->context.prog->constants[GET_ARG()].sval);
7d7d7e1999-01-31Fredrik Hübinette (Hubbe)  return args+1; } CASE(F_CALL_LFUN_AND_RETURN); {
a2ad152000-02-16Fredrik Hübinette (Hubbe)  INT32 args=Pike_sp - *--Pike_mark_sp; if(Pike_fp->expendible >= Pike_sp-args)
7d7d7e1999-01-31Fredrik Hübinette (Hubbe)  {
a2ad152000-02-16Fredrik Hübinette (Hubbe)  MEMMOVE(Pike_sp-args+1,Pike_sp-args,args*sizeof(struct svalue)); Pike_sp++; Pike_sp[-args-1].type=PIKE_T_INT;
7d7d7e1999-01-31Fredrik Hübinette (Hubbe)  }else{
a2ad152000-02-16Fredrik Hübinette (Hubbe)  free_svalue(Pike_sp-args-1);
7d7d7e1999-01-31Fredrik Hübinette (Hubbe)  } /* More stack sabotage */
a2ad152000-02-16Fredrik Hübinette (Hubbe)  Pike_sp[-args-1].u.object=Pike_fp->current_object; Pike_sp[-args-1].subtype=GET_ARG()+Pike_fp->context.identifier_level;
f41da61999-03-17Fredrik Hübinette (Hubbe) #ifdef PIKE_DEBUG if(t_flag > 9)
a2ad152000-02-16Fredrik Hübinette (Hubbe)  fprintf(stderr,"- IDENTIFIER_LEVEL: %d\n",Pike_fp->context.identifier_level);
f41da61999-03-17Fredrik Hübinette (Hubbe) #endif
a2ad152000-02-16Fredrik Hübinette (Hubbe)  Pike_sp[-args-1].type=PIKE_T_FUNCTION; add_ref(Pike_fp->current_object);
7d7d7e1999-01-31Fredrik Hübinette (Hubbe)  return args+1; } CASE(F_RETURN_LOCAL); instr=GET_ARG();
a2ad152000-02-16Fredrik Hübinette (Hubbe)  if(Pike_fp->expendible <= Pike_fp->locals+instr)
2a45e61999-04-07Fredrik Hübinette (Hubbe)  {
a2ad152000-02-16Fredrik Hübinette (Hubbe)  pop_n_elems(Pike_sp-1 - (Pike_fp->locals+instr));
2a45e61999-04-07Fredrik Hübinette (Hubbe)  }else{
a2ad152000-02-16Fredrik Hübinette (Hubbe)  push_svalue(Pike_fp->locals+instr);
2a45e61999-04-07Fredrik Hübinette (Hubbe)  }
7d7d7e1999-01-31Fredrik Hübinette (Hubbe)  print_return_value(); goto do_return;
0f19431999-11-29Fredrik Hübinette (Hubbe)  CASE(F_RETURN_IF_TRUE);
a2ad152000-02-16Fredrik Hübinette (Hubbe)  if(!IS_ZERO(Pike_sp-1))
0f19431999-11-29Fredrik Hübinette (Hubbe)  goto do_return;
cb0bf11999-12-02Martin Stjernholm  pop_stack();
0f19431999-11-29Fredrik Hübinette (Hubbe)  break;
7d7d7e1999-01-31Fredrik Hübinette (Hubbe)  CASE(F_RETURN_1); push_int(1); goto do_return; CASE(F_RETURN_0); push_int(0); goto do_return; CASE(F_RETURN); do_return: #if defined(PIKE_DEBUG) && defined(GC2)
4647061999-09-14Fredrik Hübinette (Hubbe)  if(d_flag>3) do_gc(); if(d_flag>4) do_debug();
7d7d7e1999-01-31Fredrik Hübinette (Hubbe)  check_threads_etc(); #endif /* fall through */ CASE(F_DUMB_RETURN); return -1; CASE(F_NEGATE);
a2ad152000-02-16Fredrik Hübinette (Hubbe)  if(Pike_sp[-1].type == PIKE_T_INT)
7d7d7e1999-01-31Fredrik Hübinette (Hubbe)  {
43899f1999-10-23Fredrik Noring #ifdef AUTO_BIGNUM
a2ad152000-02-16Fredrik Hübinette (Hubbe)  if(INT_TYPE_NEG_OVERFLOW(Pike_sp[-1].u.integer))
43899f1999-10-23Fredrik Noring  { convert_stack_top_to_bignum(); o_negate(); } else #endif /* AUTO_BIGNUM */
a2ad152000-02-16Fredrik Hübinette (Hubbe)  Pike_sp[-1].u.integer =- Pike_sp[-1].u.integer;
43899f1999-10-23Fredrik Noring  }
a2ad152000-02-16Fredrik Hübinette (Hubbe)  else if(Pike_sp[-1].type == PIKE_T_FLOAT)
7d7d7e1999-01-31Fredrik Hübinette (Hubbe)  {
a2ad152000-02-16Fredrik Hübinette (Hubbe)  Pike_sp[-1].u.float_number =- Pike_sp[-1].u.float_number;
7d7d7e1999-01-31Fredrik Hübinette (Hubbe)  }else{ o_negate(); } break; CASE(F_COMPL); o_compl(); break; CASE(F_NOT);
a2ad152000-02-16Fredrik Hübinette (Hubbe)  switch(Pike_sp[-1].type)
7d7d7e1999-01-31Fredrik Hübinette (Hubbe)  {
0542ef1999-11-17Fredrik Hübinette (Hubbe)  case PIKE_T_INT:
a2ad152000-02-16Fredrik Hübinette (Hubbe)  Pike_sp[-1].u.integer =! Pike_sp[-1].u.integer;
7d7d7e1999-01-31Fredrik Hübinette (Hubbe)  break;
0542ef1999-11-17Fredrik Hübinette (Hubbe)  case PIKE_T_FUNCTION: case PIKE_T_OBJECT:
a2ad152000-02-16Fredrik Hübinette (Hubbe)  if(IS_ZERO(Pike_sp-1))
7d7d7e1999-01-31Fredrik Hübinette (Hubbe)  { pop_stack(); push_int(1); }else{ pop_stack(); push_int(0); } break; default:
a2ad152000-02-16Fredrik Hübinette (Hubbe)  free_svalue(Pike_sp-1); Pike_sp[-1].type=PIKE_T_INT; Pike_sp[-1].u.integer=0;
7d7d7e1999-01-31Fredrik Hübinette (Hubbe)  } break; CASE(F_LSH); o_lsh(); break; CASE(F_RSH); o_rsh(); break;
a2ad152000-02-16Fredrik Hübinette (Hubbe)  COMPARISMENT(F_EQ, is_eq(Pike_sp-2,Pike_sp-1)); COMPARISMENT(F_NE,!is_eq(Pike_sp-2,Pike_sp-1)); COMPARISMENT(F_GT, is_gt(Pike_sp-2,Pike_sp-1)); COMPARISMENT(F_GE,!is_lt(Pike_sp-2,Pike_sp-1)); COMPARISMENT(F_LT, is_lt(Pike_sp-2,Pike_sp-1)); COMPARISMENT(F_LE,!is_gt(Pike_sp-2,Pike_sp-1));
7d7d7e1999-01-31Fredrik 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; 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; CASE(F_PUSH_ARRAY);
a2ad152000-02-16Fredrik Hübinette (Hubbe)  switch(Pike_sp[-1].type)
7d7d7e1999-01-31Fredrik Hübinette (Hubbe)  { default:
a2ad152000-02-16Fredrik Hübinette (Hubbe)  PIKE_ERROR("@", "Bad argument.\n", Pike_sp, 1);
7d7d7e1999-01-31Fredrik Hübinette (Hubbe) 
0542ef1999-11-17Fredrik Hübinette (Hubbe)  case PIKE_T_OBJECT:
a2ad152000-02-16Fredrik Hübinette (Hubbe)  if(!Pike_sp[-1].u.object->prog || FIND_LFUN(Pike_sp[-1].u.object->prog,LFUN__VALUES) == -1) PIKE_ERROR("@", "Bad argument.\n", Pike_sp, 1);
7d7d7e1999-01-31Fredrik Hübinette (Hubbe) 
a2ad152000-02-16Fredrik Hübinette (Hubbe)  apply_lfun(Pike_sp[-1].u.object, LFUN__VALUES, 0); if(Pike_sp[-1].type != PIKE_T_ARRAY)
7d7d7e1999-01-31Fredrik Hübinette (Hubbe)  error("Bad return type from o->_values() in @\n");
a2ad152000-02-16Fredrik Hübinette (Hubbe)  free_svalue(Pike_sp-2); Pike_sp[-2]=Pike_sp[-1]; Pike_sp--;
7d7d7e1999-01-31Fredrik Hübinette (Hubbe)  break;
0542ef1999-11-17Fredrik Hübinette (Hubbe)  case PIKE_T_ARRAY: break;
7d7d7e1999-01-31Fredrik Hübinette (Hubbe)  }
a2ad152000-02-16Fredrik Hübinette (Hubbe)  Pike_sp--; push_array_items(Pike_sp->u.array);
7d7d7e1999-01-31Fredrik Hübinette (Hubbe)  break; CASE(F_LOCAL_LOCAL_INDEX); {
a2ad152000-02-16Fredrik Hübinette (Hubbe)  struct svalue *s=Pike_fp->locals+GET_ARG();
0542ef1999-11-17Fredrik Hübinette (Hubbe)  if(s->type == PIKE_T_STRING) s->subtype=0;
a2ad152000-02-16Fredrik Hübinette (Hubbe)  Pike_sp++->type=PIKE_T_INT; index_no_free(Pike_sp-1,Pike_fp->locals+GET_ARG2(),s);
7d7d7e1999-01-31Fredrik Hübinette (Hubbe)  break; } CASE(F_LOCAL_INDEX); {
a2ad152000-02-16Fredrik Hübinette (Hubbe)  struct svalue tmp,*s=Pike_fp->locals+GET_ARG();
0542ef1999-11-17Fredrik Hübinette (Hubbe)  if(s->type == PIKE_T_STRING) s->subtype=0;
a2ad152000-02-16Fredrik Hübinette (Hubbe)  index_no_free(&tmp,Pike_sp-1,s); free_svalue(Pike_sp-1); Pike_sp[-1]=tmp;
7d7d7e1999-01-31Fredrik Hübinette (Hubbe)  break; } CASE(F_GLOBAL_LOCAL_INDEX); { struct svalue tmp,*s;
a2ad152000-02-16Fredrik Hübinette (Hubbe)  low_object_index_no_free(Pike_sp, Pike_fp->current_object, GET_ARG() + Pike_fp->context.identifier_level); Pike_sp++; s=Pike_fp->locals+GET_ARG2();
0542ef1999-11-17Fredrik Hübinette (Hubbe)  if(s->type == PIKE_T_STRING) s->subtype=0;
a2ad152000-02-16Fredrik Hübinette (Hubbe)  index_no_free(&tmp,Pike_sp-1,s); free_svalue(Pike_sp-1); Pike_sp[-1]=tmp;
7d7d7e1999-01-31Fredrik Hübinette (Hubbe)  break; } CASE(F_LOCAL_ARROW); { struct svalue tmp;
0542ef1999-11-17Fredrik Hübinette (Hubbe)  tmp.type=PIKE_T_STRING;
a2ad152000-02-16Fredrik Hübinette (Hubbe)  tmp.u.string=Pike_fp->context.prog->strings[GET_ARG()];
7d7d7e1999-01-31Fredrik Hübinette (Hubbe)  tmp.subtype=1;
a2ad152000-02-16Fredrik Hübinette (Hubbe)  Pike_sp->type=PIKE_T_INT; Pike_sp++; index_no_free(Pike_sp-1,Pike_fp->locals+GET_ARG2() , &tmp);
7d7d7e1999-01-31Fredrik Hübinette (Hubbe)  print_return_value(); break; } CASE(F_ARROW); { struct svalue tmp,tmp2;
0542ef1999-11-17Fredrik Hübinette (Hubbe)  tmp.type=PIKE_T_STRING;
a2ad152000-02-16Fredrik Hübinette (Hubbe)  tmp.u.string=Pike_fp->context.prog->strings[GET_ARG()];
7d7d7e1999-01-31Fredrik Hübinette (Hubbe)  tmp.subtype=1;
a2ad152000-02-16Fredrik Hübinette (Hubbe)  index_no_free(&tmp2, Pike_sp-1, &tmp); free_svalue(Pike_sp-1); Pike_sp[-1]=tmp2;
7d7d7e1999-01-31Fredrik Hübinette (Hubbe)  print_return_value(); break; } CASE(F_STRING_INDEX); { struct svalue tmp,tmp2;
0542ef1999-11-17Fredrik Hübinette (Hubbe)  tmp.type=PIKE_T_STRING;
a2ad152000-02-16Fredrik Hübinette (Hubbe)  tmp.u.string=Pike_fp->context.prog->strings[GET_ARG()];
7d7d7e1999-01-31Fredrik Hübinette (Hubbe)  tmp.subtype=0;
a2ad152000-02-16Fredrik Hübinette (Hubbe)  index_no_free(&tmp2, Pike_sp-1, &tmp); free_svalue(Pike_sp-1); Pike_sp[-1]=tmp2;
7d7d7e1999-01-31Fredrik Hübinette (Hubbe)  print_return_value(); break; } 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(); CASE(F_INDEX); do_index: { struct svalue s;
a2ad152000-02-16Fredrik Hübinette (Hubbe)  index_no_free(&s,Pike_sp-2,Pike_sp-1);
7d7d7e1999-01-31Fredrik Hübinette (Hubbe)  pop_n_elems(2);
a2ad152000-02-16Fredrik Hübinette (Hubbe)  *Pike_sp=s; Pike_sp++;
7d7d7e1999-01-31Fredrik Hübinette (Hubbe)  } print_return_value(); break;
624f571999-03-11Fredrik Hübinette (Hubbe)  CASE(F_MAGIC_INDEX); push_magic_index(magic_index_program, accumulator, GET_ARG()); break; CASE(F_MAGIC_SET_INDEX); push_magic_index(magic_set_index_program, accumulator, GET_ARG()); break;
7d7d7e1999-01-31Fredrik Hübinette (Hubbe)  CASE(F_CAST); f_cast(); break;
02a23c1999-11-25Henrik Grubbström (Grubba)  CASE(F_SOFT_CAST);
1adc6c1999-12-12Henrik Grubbström (Grubba)  /* Stack: type_string, value */
02a23c1999-11-25Henrik Grubbström (Grubba) #ifdef PIKE_DEBUG
a2ad152000-02-16Fredrik Hübinette (Hubbe)  if (Pike_sp[-2].type != T_STRING) {
1afcea1999-12-13Henrik Grubbström (Grubba)  /* FIXME: The type should really be T_TYPE... */
1adc6c1999-12-12Henrik Grubbström (Grubba)  fatal("Argument 1 to soft_cast isn't a string!\n"); } #endif /* PIKE_DEBUG */
7d955e1999-12-13Henrik Grubbström (Grubba)  if (runtime_options & RUNTIME_CHECK_TYPES) {
a2ad152000-02-16Fredrik Hübinette (Hubbe)  struct pike_string *sval_type = get_type_of_svalue(Pike_sp-1); if (!pike_types_le(sval_type, Pike_sp[-2].u.string)) {
1afcea1999-12-13Henrik Grubbström (Grubba)  /* get_type_from_svalue() doesn't return a fully specified type * for array, mapping and multiset, so we perform a more lenient * check for them. */
96bd671999-12-13Henrik Grubbström (Grubba)  if (!pike_types_le(sval_type, weak_type_string) ||
a2ad152000-02-16Fredrik Hübinette (Hubbe)  !match_types(sval_type, Pike_sp[-2].u.string)) {
1afcea1999-12-13Henrik Grubbström (Grubba)  struct pike_string *t1; struct pike_string *t2;
2cb90b1999-12-27Henrik Grubbström (Grubba)  char *fname = "__soft-cast";
1afcea1999-12-13Henrik Grubbström (Grubba)  ONERROR tmp1; ONERROR tmp2;
a2ad152000-02-16Fredrik Hübinette (Hubbe)  if (Pike_fp->current_object && Pike_fp->context.prog && Pike_fp->current_object->prog) {
26356d1999-12-19Henrik Grubbström (Grubba)  /* Look up the function-name */ struct pike_string *name =
a2ad152000-02-16Fredrik Hübinette (Hubbe)  ID_FROM_INT(Pike_fp->current_object->prog, Pike_fp->fun)->name;
2cb90b1999-12-27Henrik Grubbström (Grubba)  if ((!name->size_shift) && (name->len < 100))
26356d1999-12-19Henrik Grubbström (Grubba)  fname = name->str; }
a2ad152000-02-16Fredrik Hübinette (Hubbe)  t1 = describe_type(Pike_sp[-2].u.string);
1afcea1999-12-13Henrik Grubbström (Grubba)  SET_ONERROR(tmp1, do_free_string, t1); t2 = describe_type(sval_type); SET_ONERROR(tmp2, do_free_string, t2); free_string(sval_type);
a2ad152000-02-16Fredrik Hübinette (Hubbe)  bad_arg_error(NULL, Pike_sp-1, 1, 1, t1->str, Pike_sp-1,
26356d1999-12-19Henrik Grubbström (Grubba)  "%s(): Soft cast failed. Expected %s, got %s\n", fname, t1->str, t2->str);
1afcea1999-12-13Henrik Grubbström (Grubba)  /* NOT_REACHED */ UNSET_ONERROR(tmp2); UNSET_ONERROR(tmp1); free_string(t2); free_string(t1); }
1adc6c1999-12-12Henrik Grubbström (Grubba)  } free_string(sval_type); #ifdef PIKE_DEBUG if (d_flag > 2) {
a2ad152000-02-16Fredrik Hübinette (Hubbe)  struct pike_string *t = describe_type(Pike_sp[-2].u.string);
02a23c1999-11-25Henrik Grubbström (Grubba)  fprintf(stderr, "Soft cast to %s\n", t->str); free_string(t); } #endif /* PIKE_DEBUG */
1adc6c1999-12-12Henrik Grubbström (Grubba)  }
02a23c1999-11-25Henrik Grubbström (Grubba)  stack_swap(); pop_stack(); break;
7d7d7e1999-01-31Fredrik Hübinette (Hubbe)  CASE(F_RANGE); o_range(); break; CASE(F_COPY_VALUE); { struct svalue tmp;
a2ad152000-02-16Fredrik Hübinette (Hubbe)  copy_svalues_recursively_no_free(&tmp,Pike_sp-1,1,0); free_svalue(Pike_sp-1); Pike_sp[-1]=tmp;
7d7d7e1999-01-31Fredrik Hübinette (Hubbe)  } break; CASE(F_INDIRECT); { struct svalue s;
a2ad152000-02-16Fredrik Hübinette (Hubbe)  lvalue_to_svalue_no_free(&s,Pike_sp-2);
0542ef1999-11-17Fredrik Hübinette (Hubbe)  if(s.type != PIKE_T_STRING)
7d7d7e1999-01-31Fredrik Hübinette (Hubbe)  { pop_n_elems(2);
a2ad152000-02-16Fredrik Hübinette (Hubbe)  *Pike_sp=s; Pike_sp++;
7d7d7e1999-01-31Fredrik Hübinette (Hubbe)  }else{ struct object *o; o=low_clone(string_assignment_program);
a2ad152000-02-16Fredrik Hübinette (Hubbe)  ((struct string_assignment_storage *)o->storage)->lval[0]=Pike_sp[-2]; ((struct string_assignment_storage *)o->storage)->lval[1]=Pike_sp[-1];
7d7d7e1999-01-31Fredrik Hübinette (Hubbe)  ((struct string_assignment_storage *)o->storage)->s=s.u.string;
a2ad152000-02-16Fredrik Hübinette (Hubbe)  Pike_sp-=2;
7d7d7e1999-01-31Fredrik Hübinette (Hubbe)  push_object(o); } } print_return_value(); break; CASE(F_SIZEOF);
a2ad152000-02-16Fredrik Hübinette (Hubbe)  instr=pike_sizeof(Pike_sp-1);
7d7d7e1999-01-31Fredrik Hübinette (Hubbe)  pop_stack(); push_int(instr); break; CASE(F_SIZEOF_LOCAL);
a2ad152000-02-16Fredrik Hübinette (Hubbe)  push_int(pike_sizeof(Pike_fp->locals+GET_ARG()));
7d7d7e1999-01-31Fredrik Hübinette (Hubbe)  break; CASE(F_SSCANF); o_sscanf(GET_ARG()); break; CASE(F_CALL_LFUN);
a2ad152000-02-16Fredrik Hübinette (Hubbe)  apply_low(Pike_fp->current_object, GET_ARG()+Pike_fp->context.identifier_level, Pike_sp - *--Pike_mark_sp);
7d7d7e1999-01-31Fredrik Hübinette (Hubbe)  break; CASE(F_CALL_LFUN_AND_POP);
a2ad152000-02-16Fredrik Hübinette (Hubbe)  apply_low(Pike_fp->current_object, GET_ARG()+Pike_fp->context.identifier_level, Pike_sp - *--Pike_mark_sp);
7d7d7e1999-01-31Fredrik Hübinette (Hubbe)  pop_stack(); break; CASE(F_MARK_APPLY);
a2ad152000-02-16Fredrik Hübinette (Hubbe)  strict_apply_svalue(Pike_fp->context.prog->constants + GET_ARG(), 0);
7d7d7e1999-01-31Fredrik Hübinette (Hubbe)  break; CASE(F_MARK_APPLY_POP);
a2ad152000-02-16Fredrik Hübinette (Hubbe)  strict_apply_svalue(Pike_fp->context.prog->constants + GET_ARG(), 0);
7d7d7e1999-01-31Fredrik Hübinette (Hubbe)  pop_stack(); break; CASE(F_APPLY);
a2ad152000-02-16Fredrik Hübinette (Hubbe)  strict_apply_svalue(Pike_fp->context.prog->constants + GET_ARG(), Pike_sp - *--Pike_mark_sp );
7d7d7e1999-01-31Fredrik Hübinette (Hubbe)  break; CASE(F_APPLY_AND_POP);
a2ad152000-02-16Fredrik Hübinette (Hubbe)  strict_apply_svalue(Pike_fp->context.prog->constants + GET_ARG(), Pike_sp - *--Pike_mark_sp );
7d7d7e1999-01-31Fredrik Hübinette (Hubbe)  pop_stack(); break; CASE(F_CALL_FUNCTION);
a2ad152000-02-16Fredrik Hübinette (Hubbe)  mega_apply(APPLY_STACK,Pike_sp - *--Pike_mark_sp,0,0);
7d7d7e1999-01-31Fredrik Hübinette (Hubbe)  break; CASE(F_CALL_FUNCTION_AND_RETURN); {
a2ad152000-02-16Fredrik Hübinette (Hubbe)  INT32 args=Pike_sp - *--Pike_mark_sp;
7d7d7e1999-01-31Fredrik Hübinette (Hubbe)  if(!args)
a2ad152000-02-16Fredrik Hübinette (Hubbe)  PIKE_ERROR("`()", "Too few arguments.\n", Pike_sp, 0); switch(Pike_sp[-args].type)
7d7d7e1999-01-31Fredrik Hübinette (Hubbe)  {
0542ef1999-11-17Fredrik Hübinette (Hubbe)  case PIKE_T_INT:
a2ad152000-02-16Fredrik Hübinette (Hubbe)  if (!Pike_sp[-args].u.integer) { PIKE_ERROR("`()", "Attempt to call the NULL-value\n", Pike_sp, args);
7d7d7e1999-01-31Fredrik Hübinette (Hubbe)  }
0542ef1999-11-17Fredrik Hübinette (Hubbe)  case PIKE_T_STRING: case PIKE_T_FLOAT: case PIKE_T_MAPPING: case PIKE_T_MULTISET:
a2ad152000-02-16Fredrik Hübinette (Hubbe)  PIKE_ERROR("`()", "Attempt to call a non-function value.\n", Pike_sp, args);
7d7d7e1999-01-31Fredrik Hübinette (Hubbe)  } return args; } default: fatal("Strange instruction %ld\n",(long)instr); } } }