Main Page | Class List | Directories | File List | Class Members | File Members
src

interpret_functions_fixed.h File Reference

#include "global.h"

Go to the source code of this file.

Defines

#define DO_IF_BIGNUM(CODE)
#define DO_IF_ELSE_COMPUTED_GOTO(A, B)   (B)
#define OPCODE0_ALIAS(A, B, C, D)   OPCODE0(A,B,C,{D();})
#define OPCODE1_ALIAS(A, B, C, D)   OPCODE1(A,B,C,{D();})
#define OPCODE2_ALIAS(A, B, C, D)   OPCODE2(A,B,C,{D();})
#define INTER_ESCAPE_CATCH   return -2
#define INTER_RETURN   return -1
#define DO_BRANCH   DOJUMP
#define DONT_BRANCH   SKIPJUMP
#define LOCAL_VAR(X)   X
#define GET_JUMP()   (/*write_to_stderr("GET_JUMP\n", 9),*/ LOW_GET_JUMP())
#define SKIPJUMP()   (/*write_to_stderr("SKIPJUMP\n", 9),*/ LOW_SKIPJUMP())
#define DOJUMP()
#define DO_JUMP_TO(NEWPC)
#define DO_DUMB_RETURN
#define DO_RETURN   DO_DUMB_RETURN
#define JUMP_SET_TO_PC_AT_NEXT(PC)   ((PC) = PROG_COUNTER)
#define DO_JUMP_TO_NEXT   JUMP_DONE
#define DO_INDEX
#define CJUMP(X, DESC, Y)
#define AUTO_BIGNUM_LOOP_TEST(X, Y)   0
#define LOOP(ID, DESC, INC, OP2, OP4)
#define COMPARISON(ID, DESC, EXPR)
#define MKAPPLY(OP, OPCODE, NAME, TYPE,ARG2, ARG3)
#define MKAPPLY2(OP, OPCODE, NAME, TYPE,ARG2, ARG3)
#define DO_CALL_BUILTIN(ARGS)   (*(Pike_fp->context.prog->constants[arg1].sval.u.efun->function))(ARGS)
#define ENTRY_PROLOGUE_SIZE   0
#define DO_RECUR(XFLAGS)

Functions

 OPCODE0 (F_UNDEFINED,"push UNDEFINED", I_UPDATE_SP,{push_int(0);Pike_sp[-1].subtype=NUMBER_UNDEFINED;}) OPCODE0(F_CONST0
 CJUMP (F_BRANCH_WHEN_NE,"branch if !=",!is_eq)
 CJUMP (F_BRANCH_WHEN_LT,"branch if <", is_lt)
 CJUMP (F_BRANCH_WHEN_LE,"branch if <=", is_le)
 CJUMP (F_BRANCH_WHEN_GT,"branch if >", is_gt)
 CJUMP (F_BRANCH_WHEN_GE,"branch if >=", is_ge)
 OPCODE0_BRANCH (F_BRANCH_AND_POP_WHEN_ZERO,"branch & pop if zero", 0,{if(!UNSAFE_IS_ZERO(Pike_sp-1)){DONT_BRANCH();}else{DO_BRANCH();pop_stack();}}) OPCODE0_BRANCH(F_BRANCH_AND_POP_WHEN_NON_ZERO
 LOOP (F_DEC_LOOP,"--Loop",-1, >, is_gt)
 LOOP (F_INC_NEQ_LOOP,"++Loop!=", 1,!=,!is_eq)
 LOOP (F_DEC_NEQ_LOOP,"--Loop!=",-1,!=,!is_eq)
 OPCODE0_BRANCH (F_LOOP,"loop", I_UPDATE_SP,{push_int(1);if(!is_lt(Pike_sp-2, Pike_sp-1)){o_subtract();DO_BRANCH();}else{DONT_BRANCH();pop_2_elems();}}) OPCODE0_BRANCH(F_FOREACH
 OPCODE0 (F_NOT,"!", 0,{switch(Pike_sp[-1].type){case PIKE_T_INT:Pike_sp[-1].u.integer=!Pike_sp[-1].u.integer;Pike_sp[-1].subtype=NUMBER_NUMBER;break;case PIKE_T_FUNCTION:case PIKE_T_OBJECT:if(UNSAFE_IS_ZERO(Pike_sp-1)){pop_stack();push_int(1);}else{pop_stack();push_int(0);}break;default:free_svalue(Pike_sp-1);Pike_sp[-1].type=PIKE_T_INT;Pike_sp[-1].subtype=NUMBER_NUMBER;Pike_sp[-1].u.integer=0;}}) OPCODE0_ALIAS(F_LSH
 COMPARISON (F_EQ,"==", is_eq(Pike_sp-2, Pike_sp-1))
 COMPARISON (F_NE,"!=",!is_eq(Pike_sp-2, Pike_sp-1))
 COMPARISON (F_GT,">", is_gt(Pike_sp-2, Pike_sp-1))
 COMPARISON (F_GE,">=", is_ge(Pike_sp-2, Pike_sp-1))
 COMPARISON (F_LT,"<", is_lt(Pike_sp-2, Pike_sp-1))
 COMPARISON (F_LE,"<=", is_le(Pike_sp-2, Pike_sp-1))
 OPCODE0 (F_ADD,"+", I_UPDATE_SP,{f_add(2);}) OPCODE0(F_ADD_INTS
 OPCODE0_ALIAS (F_AND,"&", I_UPDATE_SP, o_and)
 OPCODE0_ALIAS (F_OR,"|", I_UPDATE_SP, o_or)
 OPCODE0_ALIAS (F_XOR,"^", I_UPDATE_SP, o_xor)
 OPCODE0_ALIAS (F_MULTIPLY,"*", I_UPDATE_SP, o_multiply)
 OPCODE0_ALIAS (F_DIVIDE,"/", I_UPDATE_SP, o_divide)
 OPCODE0_ALIAS (F_MOD,"%", I_UPDATE_SP, o_mod)
 OPCODE1 (F_ADD_INT,"add integer", 0,{if(Pike_sp[-1].type==T_INTDO_IF_BIGNUM(&&(!INT_TYPE_ADD_OVERFLOW(Pike_sp[-1].u.integer, arg1)))){Pike_sp[-1].u.integer+=arg1;Pike_sp[-1].subtype=NUMBER_NUMBER;}else{push_int(arg1);f_add(2);}}) OPCODE1(F_ADD_NEG_INT
 OPCODE0_ALIAS (F_CAST_TO_INT,"cast_to_int", 0, o_cast_to_int)
 OPCODE0_ALIAS (F_CAST_TO_STRING,"cast_to_string", 0, o_cast_to_string)
 OPCODE0 (F_SOFT_CAST,"soft cast", I_UPDATE_SP,{DO_IF_DEBUG({if(Pike_sp[-2].type!=T_TYPE){Pike_fatal("Argument 1 to soft_cast isn't a type!\n");}});if(runtime_options &RUNTIME_CHECK_TYPES){struct pike_type *sval_type=get_type_of_svalue(Pike_sp-1);if(!pike_types_le(sval_type, Pike_sp[-2].u.type)){if(!pike_types_le(sval_type, weak_type_string)||!match_types(sval_type, Pike_sp[-2].u.type)){struct pike_string *t1;struct pike_string *t2;char *fname="__soft-cast";ONERROR tmp1;ONERROR tmp2;if(Pike_fp->current_object &&Pike_fp->context.prog &&Pike_fp->current_object->prog){struct pike_string *name=ID_FROM_INT(Pike_fp->current_object->prog, Pike_fp->fun)->name;if((!name->size_shift)&&(name->len< 100)) fname=name->str;}t1=describe_type(Pike_sp[-2].u.type);SET_ONERROR(tmp1, do_free_string, t1);t2=describe_type(sval_type);SET_ONERROR(tmp2, do_free_string, t2);free_type(sval_type);bad_arg_error(NULL, Pike_sp-1, 1, 1, t1->str, Pike_sp-1,"%s(): Soft cast failed. Expected %s, got %s\n", fname, t1->str, t2->str);UNSET_ONERROR(tmp2);UNSET_ONERROR(tmp1);free_string(t2);free_string(t1);}}free_type(sval_type);DO_IF_DEBUG({if(d_flag > 2){struct pike_string *t=describe_type(Pike_sp[-2].u.type);fprintf(stderr,"Soft cast to %s\n", t->str);free_string(t);}});}stack_swap();pop_stack();}) OPCODE1_ALIAS(F_RANGE
 OPCODE0 (F_COPY_VALUE,"copy_value", 0,{LOCAL_VAR(struct svalue tmp);copy_svalues_recursively_no_free(&tmp, Pike_sp-1, 1, 0);free_svalue(Pike_sp-1);move_svalue(Pike_sp-1,&tmp);print_return_value();}) OPCODE0(F_INDIRECT
 MKAPPLY2 (OPCODE1, CALL_LFUN,"call lfun", APPLY_LOW, Pike_fp->current_object,(void *)(ptrdiff_t)(arg1+Pike_fp->context.identifier_level))
 MKAPPLY2 (OPCODE1, APPLY,"apply", APPLY_SVALUE_STRICT,&((Pike_fp->context.prog->constants+arg1)->sval), 0)
 MKAPPLY (OPCODE0, CALL_FUNCTION,"call function", APPLY_STACK, 0, 0)
 OPCODE1_JUMP (F_CALL_OTHER,"call other", I_UPDATE_ALL,{INT32 args=DO_NOT_WARN((INT32)(Pike_sp-*--Pike_mark_sp));LOCAL_VAR(struct svalue *s);s=Pike_sp-args;JUMP_SET_TO_PC_AT_NEXT(Pike_fp->return_addr);if(s->type==T_OBJECT){LOCAL_VAR(struct object *o);LOCAL_VAR(struct program *p);o=s->u.object;if((p=o->prog)){p=p->inherits[s->subtype].prog;if(FIND_LFUN(p, LFUN_ARROW)==-1){int fun;fun=find_shared_string_identifier(Pike_fp->context.prog->strings[arg1], p);if(fun >=0){fun+=o->prog->inherits[s->subtype].identifier_level;if(low_mega_apply(APPLY_LOW, args-1, o,(void *)(ptrdiff_t) fun)){Pike_fp->save_sp--;Pike_fp->flags|=PIKE_FRAME_RETURN_INTERNAL;DO_JUMP_TO(Pike_fp->pc);}stack_pop_keep_top();DO_JUMP_TO_NEXT;}}}}{LOCAL_VAR(struct svalue tmp);LOCAL_VAR(struct svalue tmp2);tmp.type=PIKE_T_STRING;tmp.u.string=Pike_fp->context.prog->strings[arg1];tmp.subtype=1;index_no_free(&tmp2, s,&tmp);free_svalue(s);move_svalue(s,&tmp2);print_return_value();if(low_mega_apply(APPLY_STACK, args, 0, 0)){Pike_fp->flags|=PIKE_FRAME_RETURN_INTERNAL;DO_JUMP_TO(Pike_fp->pc);}else{DO_JUMP_TO_NEXT;}}}) OPCODE1_JUMP(F_CALL_OTHER_AND_POP

Variables

 push
 I_UPDATE_SP
branch &pop if zero
 foreach
<<",I_UPDATE_SP,o_lsh);OPCODE0_ALIAS(F_RSH,"> o_rsh
int int
add integer
 range
 o_range2
 indirect
call other & pop
call other I_UPDATE_ALL

Define Documentation

#define AUTO_BIGNUM_LOOP_TEST (  X,
Y   )     0
 

#define CJUMP (  X,
DESC,
Y   ) 
 

Value:

OPCODE0_BRANCH(X, DESC, I_UPDATE_SP, { \
    if(Y(Pike_sp-2,Pike_sp-1)) { \
      DO_BRANCH(); \
    }else{ \
      /* write_to_stderr("foreach\n", 8); */    \
      DONT_BRANCH(); \
    } \
    pop_2_elems(); \
  })

#define COMPARISON (  ID,
DESC,
EXPR   ) 
 

Value:

OPCODE0(ID, DESC, I_UPDATE_SP, {        \
    INT32 val = EXPR;                   \
    pop_2_elems();                      \
    push_int(val);                      \
  })

#define DO_BRANCH   DOJUMP
 

#define DO_CALL_BUILTIN (  ARGS   )     (*(Pike_fp->context.prog->constants[arg1].sval.u.efun->function))(ARGS)
 

#define DO_DUMB_RETURN
 

Value:

{                               \
  if(Pike_fp -> flags & PIKE_FRAME_RETURN_INTERNAL)     \
  {                                                     \
    int f=Pike_fp->flags;                               \
    if(f & PIKE_FRAME_RETURN_POP)                       \
       low_return_pop();                                \
     else                                               \
       low_return();                                    \
                                                        \
    DO_IF_DEBUG(if (Pike_interpreter.trace_level > 5)   \
      fprintf(stderr, "Returning to 0x%p\n",            \
              Pike_fp->return_addr));                   \
    DO_JUMP_TO(Pike_fp->return_addr);                   \
  }                                                     \
  DO_IF_DEBUG(if (Pike_interpreter.trace_level > 5)     \
    fprintf(stderr, "Inter return\n"));                 \
  INTER_RETURN;                                         \
}

#define DO_IF_BIGNUM (  CODE   ) 
 

#define DO_IF_ELSE_COMPUTED_GOTO (  A,
B   )     (B)
 

#define DO_INDEX
 

Value:

do {                            \
    LOCAL_VAR(struct svalue tmp);               \
    index_no_free(&tmp,Pike_sp-2,Pike_sp-1);    \
    pop_2_elems();                              \
    move_svalue (Pike_sp, &tmp);                \
    Pike_sp++;                                  \
    print_return_value();                       \
  }while(0)

#define DO_JUMP_TO (  NEWPC   ) 
 

Value:

{       \
  SET_PROG_COUNTER(NEWPC);              \
  FETCH;                                \
  JUMP_DONE;                            \
}

#define DO_JUMP_TO_NEXT   JUMP_DONE
 

#define DO_RECUR (  XFLAGS   ) 
 

#define DO_RETURN   DO_DUMB_RETURN
 

 
#define DOJUMP (   ) 
 

Value:

do { \
    PIKE_OPCODE_T *addr;                                                \
    INT32 tmp; \
    JUMP_SET_TO_PC_AT_NEXT (addr);                                      \
    tmp = GET_JUMP(); \
    SET_PROG_COUNTER(addr + tmp); \
    FETCH; \
    if(tmp < 0) \
      fast_check_threads_etc(6); \
  } while(0)

#define DONT_BRANCH   SKIPJUMP
 

#define ENTRY_PROLOGUE_SIZE   0
 

 
#define GET_JUMP (   )     (/*write_to_stderr("GET_JUMP\n", 9),*/ LOW_GET_JUMP())
 

#define INTER_ESCAPE_CATCH   return -2
 

#define INTER_RETURN   return -1
 

#define JUMP_SET_TO_PC_AT_NEXT (  PC   )     ((PC) = PROG_COUNTER)
 

#define LOCAL_VAR (  X   )     X
 

#define LOOP (  ID,
DESC,
INC,
OP2,
OP4   ) 
 

Value:

OPCODE0_BRANCH(ID, DESC, 0, {                                           \
    union anything *i=get_pointer_if_this_type(Pike_sp-2, T_INT);       \
    if(i && !AUTO_BIGNUM_LOOP_TEST(i->integer,INC) &&                   \
       Pike_sp[-3].type == T_INT)                                       \
    {                                                                   \
      i->integer += INC;                                                \
      if(i->integer OP2 Pike_sp[-3].u.integer)                          \
      {                                                                 \
        DO_BRANCH();                                                    \
      }else{                                                            \
        /* write_to_stderr("loop\n", 8); */                             \
        DONT_BRANCH();                                                  \
      }                                                                 \
    }else{                                                              \
      lvalue_to_svalue_no_free(Pike_sp,Pike_sp-2); Pike_sp++;           \
      push_int(INC);                                                    \
      f_add(2);                                                         \
      assign_lvalue(Pike_sp-3,Pike_sp-1);                               \
      if(OP4 ( Pike_sp-1, Pike_sp-4 ))                                  \
      {                                                                 \
        DO_BRANCH();                                                    \
      }else{                                                            \
        /* write_to_stderr("loop\n", 8); */                             \
        DONT_BRANCH();                                                  \
      }                                                                 \
      pop_stack();                                                      \
    }                                                                   \
  })

#define MKAPPLY (  OP,
OPCODE,
NAME,
TYPE,
ARG2,
ARG3   ) 
 

#define MKAPPLY2 (  OP,
OPCODE,
NAME,
TYPE,
ARG2,
ARG3   ) 
 

#define OPCODE0_ALIAS (  A,
B,
C,
D   )     OPCODE0(A,B,C,{D();})
 

#define OPCODE1_ALIAS (  A,
B,
C,
D   )     OPCODE1(A,B,C,{D();})
 

#define OPCODE2_ALIAS (  A,
B,
C,
D   )     OPCODE2(A,B,C,{D();})
 

 
#define SKIPJUMP (   )     (/*write_to_stderr("SKIPJUMP\n", 9),*/ LOW_SKIPJUMP())
 

Function Documentation

CJUMP (  F_BRANCH_WHEN_GE  ,
"branch if >="  ,
is_ge 
) 
 

CJUMP (  F_BRANCH_WHEN_GT  ,
"branch   if,
"  ,
is_gt 
) 
 

CJUMP (  F_BRANCH_WHEN_LE  ,
"branch if <="  ,
is_le 
) 
 

CJUMP (  F_BRANCH_WHEN_LT   ) 
 

CJUMP (  F_BRANCH_WHEN_NE   ) 
 

COMPARISON (  F_LE  ,
"<="  ,
is_le(Pike_sp-2, Pike_sp-1) 
) 
 

COMPARISON (  F_LT   ) 
 

COMPARISON (  F_GE  ,
">="  ,
is_ge(Pike_sp-2, Pike_sp-1) 
) 
 

COMPARISON (  F_GT  ,
"  ,
"  ,
is_gt(Pike_sp-2, Pike_sp-1) 
) 
 

COMPARISON (  F_NE   ) 
 

COMPARISON (  F_EQ   ) 
 

LOOP (  F_DEC_NEQ_LOOP   ) 
 

LOOP (  F_INC_NEQ_LOOP   ) 
 

LOOP (  F_DEC_LOOP  ,
"--Loop"  ,
-  1,
is_gt 
) 
 

MKAPPLY (  OPCODE0  ,
CALL_FUNCTION  ,
"call function"  ,
APPLY_STACK  ,
0  ,
0 
) 
 

MKAPPLY2 (  OPCODE1  ,
APPLY  ,
"apply"  ,
APPLY_SVALUE_STRICT  ,
&  ((Pike_fp->context.prog->constants+arg1)->sval),
0 
) 
 

MKAPPLY2 (  OPCODE1  ,
CALL_LFUN  ,
"call lfun"  ,
APPLY_LOW  ,
Pike_fp->  current_object,
(void *)(ptrdiff_t)(arg1+Pike_fp->context.identifier_level) 
) 
 

OPCODE0 (  F_COPY_VALUE  ,
"copy_value"  ,
0 
) 
 

OPCODE0 (  F_SOFT_CAST  ,
"soft cast"  ,
I_UPDATE_SP 
) 
 

OPCODE0 (  F_ADD  ,
"+"  ,
I_UPDATE_SP 
) 
 

OPCODE0 (  F_NOT  ,
"!"  ,
0 
) 
 

OPCODE0 (  F_UNDEFINED  ,
"push UNDEFINED"  ,
I_UPDATE_SP 
) 
 

OPCODE0_ALIAS (  F_CAST_TO_STRING  ,
"cast_to_string"  ,
0  ,
o_cast_to_string 
) 
 

OPCODE0_ALIAS (  F_CAST_TO_INT  ,
"cast_to_int"  ,
0  ,
o_cast_to_int 
) 
 

OPCODE0_ALIAS (  F_MOD  ,
"%"  ,
I_UPDATE_SP  ,
o_mod 
) 
 

OPCODE0_ALIAS (  F_DIVIDE  ,
"/"  ,
I_UPDATE_SP  ,
o_divide 
) 
 

OPCODE0_ALIAS (  F_MULTIPLY  ,
"*"  ,
I_UPDATE_SP  ,
o_multiply 
) 
 

OPCODE0_ALIAS (  F_XOR  ,
"^"  ,
I_UPDATE_SP  ,
o_xor 
) 
 

OPCODE0_ALIAS (  F_OR  ,
"|"  ,
I_UPDATE_SP  ,
o_or 
) 
 

OPCODE0_ALIAS (  F_AND  ,
"&"  ,
I_UPDATE_SP  ,
o_and 
) 
 

OPCODE0_BRANCH (  F_LOOP  ,
"loop"  ,
I_UPDATE_SP 
) 
 

OPCODE0_BRANCH (  F_BRANCH_AND_POP_WHEN_ZERO  ,
"branch & pop if zero"  ,
0 
) 
 

OPCODE1 (  F_ADD_INT  ,
"add integer"  ,
0 
) 
 

OPCODE1_JUMP (  F_CALL_OTHER  ,
"call other"  ,
I_UPDATE_ALL 
) 
 

Variable Documentation

foreach
 

call other I_UPDATE_ALL
 

I_UPDATE_SP
 

indirect
 

int int
 

add integer
 

o_range2
 

<<",I_UPDATE_SP,o_lsh);OPCODE0_ALIAS(F_RSH,"> o_rsh
 

pop
 

push
 

range
 

branch& pop if zero
 

Generated on Fri Jul 22 23:44:29 2005 for Pike by  doxygen 1.3.9.1