pike.git / src / interpreter.h

version» Context lines:

pike.git/src/interpreter.h:136:    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 */       CASE(F_MARK_AND_STRING); *(mark_sp++)=sp;    CASE(F_STRING);    copy_shared_string(sp->u.string,fp->context.prog->strings[GET_ARG()]); -  sp->type=T_STRING; +  sp->type=PIKE_T_STRING;    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->type=PIKE_T_STRING;    sp->subtype=1; /* Magic */    sp++;    print_return_value();    break;       CASE(F_CONSTANT);    assign_svalue_no_free(sp++,& fp->context.prog->constants[GET_ARG()].sval);    print_return_value();    break;       CASE(F_FLOAT); -  sp->type=T_FLOAT; +  sp->type=PIKE_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;    add_ref(fp->current_object);    sp->subtype=GET_ARG()+fp->context.identifier_level; -  sp->type=T_FUNCTION; +  sp->type=PIKE_T_FUNCTION;    sp++;    print_return_value();    break;       CASE(F_TRAMPOLINE);    {    struct object *o=low_clone(pike_trampoline_program);    add_ref( ((struct pike_trampoline *)(o->storage))->frame=fp );    ((struct pike_trampoline *)(o->storage))->func=GET_ARG()+fp->context.identifier_level;    push_object(o);
pike.git/src/interpreter.h:397:    sp[-1].u.array->flags |= ARRAY_LVALUE;    sp[-1].u.array->type_field |= BIT_UNFINISHED | BIT_MIXED;    sp[0]=sp[-1];    sp[-1].type=T_ARRAY_LVALUE;    sp++;    break;       CASE(F_CLEAR_2_LOCAL);    instr=GET_ARG();    free_svalues(fp->locals + instr, 2, -1); -  fp->locals[instr].type=T_INT; +  fp->locals[instr].type=PIKE_T_INT;    fp->locals[instr].subtype=0;    fp->locals[instr].u.integer=0; -  fp->locals[instr+1].type=T_INT; +  fp->locals[instr+1].type=PIKE_T_INT;    fp->locals[instr+1].subtype=0;    fp->locals[instr+1].u.integer=0;    break;       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].type=PIKE_T_INT;    fp->locals[instr+e].subtype=0;    fp->locals[instr+e].u.integer=0;    }    break;    }       CASE(F_CLEAR_LOCAL);    instr=GET_ARG();    free_svalue(fp->locals + instr); -  fp->locals[instr].type=T_INT; +  fp->locals[instr].type=PIKE_T_INT;    fp->locals[instr].subtype=0;    fp->locals[instr].u.integer=0;    break;       CASE(F_INC_LOCAL);    instr=GET_ARG();   #ifdef AUTO_BIGNUM -  if(fp->locals[instr].type == T_INT && +  if(fp->locals[instr].type == PIKE_T_INT &&    !INT_TYPE_ADD_OVERFLOW(fp->locals[instr].u.integer, 1))   #else -  if(fp->locals[instr].type == T_INT) +  if(fp->locals[instr].type == PIKE_T_INT)   #endif /* AUTO_BIGNUM */    {    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);
pike.git/src/interpreter.h:457:       CASE(F_POST_INC_LOCAL);    instr=GET_ARG();    assign_svalue_no_free(sp++,fp->locals+instr);    goto inc_local_and_pop;       CASE(F_INC_LOCAL_AND_POP);    instr=GET_ARG();    inc_local_and_pop:   #ifdef AUTO_BIGNUM -  if(fp->locals[instr].type == T_INT && +  if(fp->locals[instr].type == PIKE_T_INT &&    !INT_TYPE_ADD_OVERFLOW(fp->locals[instr].u.integer, 1))   #else -  if(fp->locals[instr].type == T_INT) +  if(fp->locals[instr].type == PIKE_T_INT)   #endif /* AUTO_BIGNUM */    {    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();    }    break;       CASE(F_DEC_LOCAL);    instr=GET_ARG();   #ifdef AUTO_BIGNUM -  if(fp->locals[instr].type == T_INT && +  if(fp->locals[instr].type == PIKE_T_INT &&    !INT_TYPE_SUB_OVERFLOW(fp->locals[instr].u.integer, 1))   #else -  if(fp->locals[instr].type == T_INT) +  if(fp->locals[instr].type == PIKE_T_INT)   #endif /* AUTO_BIGNUM */    {    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);    }
pike.git/src/interpreter.h:503:    instr=GET_ARG();    assign_svalue_no_free(sp++,fp->locals+instr);    goto dec_local_and_pop;    /* fp->locals[instr].u.integer--; */    break;       CASE(F_DEC_LOCAL_AND_POP);    instr=GET_ARG();    dec_local_and_pop:   #ifdef AUTO_BIGNUM -  if(fp->locals[instr].type == T_INT && +  if(fp->locals[instr].type == PIKE_T_INT &&    !INT_TYPE_SUB_OVERFLOW(fp->locals[instr].u.integer, 1))   #else -  if(fp->locals[instr].type == T_INT) +  if(fp->locals[instr].type == PIKE_T_INT)   #endif /* AUTO_BIGNUM */    {    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();    }    break;       CASE(F_LTOSVAL);    lvalue_to_svalue_no_free(sp,sp-2);    sp++;    break;       CASE(F_LTOSVAL2);    sp[0]=sp[-1]; -  sp[-1].type=T_INT; +  sp[-1].type=PIKE_T_INT;    sp++;    lvalue_to_svalue_no_free(sp-2,sp-4);       /* 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[-2].type) & ( BIT_ARRAY | BIT_MULTISET | BIT_MAPPING | BIT_STRING ))    {    struct svalue s; -  s.type=T_INT; +  s.type=PIKE_T_INT;    s.subtype=0;    s.u.integer=0;    assign_lvalue(sp-4,&s);    }    break;          CASE(F_ADD_TO_AND_POP);    sp[0]=sp[-1]; -  sp[-1].type=T_INT; +  sp[-1].type=PIKE_T_INT;    sp++;    lvalue_to_svalue_no_free(sp-2,sp-4);       /* 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[-2].type) & ( BIT_ARRAY | BIT_MULTISET | BIT_MAPPING | BIT_STRING ))    {    struct svalue s; -  s.type=T_INT; +  s.type=PIKE_T_INT;    s.subtype=0;    s.u.integer=0;    assign_lvalue(sp-4,&s);    }    f_add(2);    assign_lvalue(sp-3,sp-1);    pop_n_elems(3);    break;       CASE(F_GLOBAL_LVALUE);
pike.git/src/interpreter.h:601:    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;    }       CASE(F_INC);    { -  union anything *u=get_pointer_if_this_type(sp-2, T_INT); +  union anything *u=get_pointer_if_this_type(sp-2, PIKE_T_INT);    if(u   #ifdef AUTO_BIGNUM    && !INT_TYPE_ADD_OVERFLOW(u->integer, 1)   #endif    )    {    instr=++ u->integer;    pop_n_elems(2);    push_int(u->integer);    break;
pike.git/src/interpreter.h:624:    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); +  union anything *u=get_pointer_if_this_type(sp-2, PIKE_T_INT);    if(u   #ifdef AUTO_BIGNUM    && !INT_TYPE_SUB_OVERFLOW(u->integer, 1)   #endif    )    {    instr=-- u->integer;    pop_n_elems(2);    push_int(u->integer);    break;
pike.git/src/interpreter.h:647:    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); +  union anything *u=get_pointer_if_this_type(sp-2, PIKE_T_INT);    if(u   #ifdef AUTO_BIGNUM    && !INT_TYPE_SUB_OVERFLOW(u->integer, 1)   #endif   )    {    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); +  union anything *u=get_pointer_if_this_type(sp-2, PIKE_T_INT);    if(u   #ifdef AUTO_BIGNUM    && !INT_TYPE_ADD_OVERFLOW(u->integer, 1)   #endif    )    {    instr=++ u->integer;    pop_n_elems(2);    break;    }    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); +  union anything *u=get_pointer_if_this_type(sp-2, PIKE_T_INT);    if(u   #ifdef AUTO_BIGNUM    && !INT_TYPE_ADD_OVERFLOW(u->integer, 1)   #endif    )    {    instr=u->integer ++;    pop_n_elems(2);    push_int(instr);    break;
pike.git/src/interpreter.h:713:    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); +  union anything *u=get_pointer_if_this_type(sp-2, PIKE_T_INT);    if(u   #ifdef AUTO_BIGNUM    && !INT_TYPE_SUB_OVERFLOW(u->integer, 1)   #endif    )    {    instr=u->integer --;    pop_n_elems(2);    push_int(instr);    break;
pike.git/src/interpreter.h:823:       /* Stack machine stuff */    CASE(F_POP_VALUE); pop_stack(); break;    CASE(F_POP_N_ELEMS); pop_n_elems(GET_ARG()); break;    CASE(F_MARK2); *(mark_sp++)=sp;    CASE(F_MARK); *(mark_sp++)=sp; break;    CASE(F_MARK_X); *(mark_sp++)=sp-GET_ARG(); break;    CASE(F_POP_MARK); --mark_sp; break;       CASE(F_CLEAR_STRING_SUBTYPE); -  if(sp[-1].type==T_STRING) sp[-1].subtype=0; +  if(sp[-1].type==PIKE_T_STRING) sp[-1].subtype=0;    break;       /* Jumps */    CASE(F_BRANCH);    DOJUMP();    break;       CASE(F_BRANCH_IF_NOT_LOCAL_ARROW);    {    struct svalue tmp; -  tmp.type=T_STRING; +  tmp.type=PIKE_T_STRING;    tmp.u.string=fp->context.prog->strings[GET_ARG()];    tmp.subtype=1; -  sp->type=T_INT; +  sp->type=PIKE_T_INT;    sp++;    index_no_free(sp-1,fp->locals+GET_ARG2() , &tmp);    print_return_value();    }       /* Fall through */       CASE(F_BRANCH_WHEN_ZERO);    if(!IS_ZERO(sp-1))    {
pike.git/src/interpreter.h:989:    }       /* FIXME: Does this need bignum tests? /Fixed - 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);       CASE(F_FOREACH) /* array, lvalue, X, i */    { -  if(sp[-4].type != T_ARRAY) +  if(sp[-4].type != PIKE_T_ARRAY)    PIKE_ERROR("foreach", "Bad argument 1.\n", sp-3, 1);    if(sp[-1].u.integer < sp[-4].u.array->size)    {    fast_check_threads_etc(10);    index_no_free(sp,sp-4,sp-1);    sp++;    assign_lvalue(sp-4, sp-1);    free_svalue(sp-1);    sp--;    pc+=EXTRACT_INT(pc);
pike.git/src/interpreter.h:1016:       CASE(F_APPLY_AND_RETURN);    {    INT32 args=sp - *--mark_sp;   /* fprintf(stderr,"%p >= %p\n",fp->expendible,sp-args); */    if(fp->expendible >= sp-args)    {   /* fprintf(stderr,"NOT EXPENDIBLE!\n"); */    MEMMOVE(sp-args+1,sp-args,args*sizeof(struct svalue));    sp++; -  sp[-args-1].type=T_INT; +  sp[-args-1].type=PIKE_T_INT;    }    /* We sabotage the stack here */    assign_svalue(sp-args-1,&fp->context.prog->constants[GET_ARG()].sval);    return args+1;    }       CASE(F_CALL_LFUN_AND_RETURN);    {    INT32 args=sp - *--mark_sp;    if(fp->expendible >= sp-args)    {    MEMMOVE(sp-args+1,sp-args,args*sizeof(struct svalue));    sp++; -  sp[-args-1].type=T_INT; +  sp[-args-1].type=PIKE_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;   #ifdef PIKE_DEBUG    if(t_flag > 9)    fprintf(stderr,"- IDENTIFIER_LEVEL: %d\n",fp->context.identifier_level);   #endif -  sp[-args-1].type=T_FUNCTION; +  sp[-args-1].type=PIKE_T_FUNCTION;    add_ref(fp->current_object);       return args+1;    }       CASE(F_RETURN_LOCAL);    instr=GET_ARG();    if(fp->expendible <= fp->locals+instr)    {    pop_n_elems(sp-1 - (fp->locals+instr));
pike.git/src/interpreter.h:1080: Inside #if defined(PIKE_DEBUG) && defined(GC2)
   if(d_flag>4) do_debug();    check_threads_etc();   #endif       /* fall through */       CASE(F_DUMB_RETURN);    return -1;       CASE(F_NEGATE); -  if(sp[-1].type == T_INT) +  if(sp[-1].type == PIKE_T_INT)    {   #ifdef AUTO_BIGNUM    if(INT_TYPE_NEG_OVERFLOW(sp[-1].u.integer))    {    convert_stack_top_to_bignum();    o_negate();    }    else   #endif /* AUTO_BIGNUM */    sp[-1].u.integer =- sp[-1].u.integer;    } -  else if(sp[-1].type == T_FLOAT) +  else if(sp[-1].type == PIKE_T_FLOAT)    {    sp[-1].u.float_number =- sp[-1].u.float_number;    }else{    o_negate();    }    break;       CASE(F_COMPL); o_compl(); break;       CASE(F_NOT);    switch(sp[-1].type)    { -  case T_INT: +  case PIKE_T_INT:    sp[-1].u.integer =! sp[-1].u.integer;    break;    -  case T_FUNCTION: -  case T_OBJECT: +  case PIKE_T_FUNCTION: +  case PIKE_T_OBJECT:    if(IS_ZERO(sp-1))    {    pop_stack();    push_int(1);    }else{    pop_stack();    push_int(0);    }    break;       default:    free_svalue(sp-1); -  sp[-1].type=T_INT; +  sp[-1].type=PIKE_T_INT;    sp[-1].u.integer=0;    }    break;       CASE(F_LSH); o_lsh(); break;    CASE(F_RSH); o_rsh(); break;       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));
pike.git/src/interpreter.h:1156:       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);    switch(sp[-1].type)    {    default:    PIKE_ERROR("@", "Bad argument.\n", sp, 1);    -  case T_OBJECT: +  case PIKE_T_OBJECT:    if(!sp[-1].u.object->prog || FIND_LFUN(sp[-1].u.object->prog,LFUN__VALUES) == -1)    PIKE_ERROR("@", "Bad argument.\n", sp, 1);       apply_lfun(sp[-1].u.object, LFUN__VALUES, 0); -  if(sp[-1].type != T_ARRAY) +  if(sp[-1].type != PIKE_T_ARRAY)    error("Bad return type from o->_values() in @\n");    free_svalue(sp-2);    sp[-2]=sp[-1];    sp--;    break;    -  case T_ARRAY: break; +  case PIKE_T_ARRAY: break;    }    sp--;    push_array_items(sp->u.array);    break;       CASE(F_LOCAL_LOCAL_INDEX);    {    struct svalue *s=fp->locals+GET_ARG(); -  if(s->type == T_STRING) s->subtype=0; -  sp++->type=T_INT; +  if(s->type == PIKE_T_STRING) s->subtype=0; +  sp++->type=PIKE_T_INT;    index_no_free(sp-1,fp->locals+GET_ARG2(),s);    break;    }       CASE(F_LOCAL_INDEX);    {    struct svalue tmp,*s=fp->locals+GET_ARG(); -  if(s->type == T_STRING) s->subtype=0; +  if(s->type == PIKE_T_STRING) s->subtype=0;    index_no_free(&tmp,sp-1,s);    free_svalue(sp-1);    sp[-1]=tmp;    break;    }       CASE(F_GLOBAL_LOCAL_INDEX);    {    struct svalue tmp,*s;    low_object_index_no_free(sp,    fp->current_object,    GET_ARG() + fp->context.identifier_level);    sp++;    s=fp->locals+GET_ARG2(); -  if(s->type == T_STRING) s->subtype=0; +  if(s->type == PIKE_T_STRING) s->subtype=0;    index_no_free(&tmp,sp-1,s);    free_svalue(sp-1);    sp[-1]=tmp;    break;    }       CASE(F_LOCAL_ARROW);    {    struct svalue tmp; -  tmp.type=T_STRING; +  tmp.type=PIKE_T_STRING;    tmp.u.string=fp->context.prog->strings[GET_ARG()];    tmp.subtype=1; -  sp->type=T_INT; +  sp->type=PIKE_T_INT;    sp++;    index_no_free(sp-1,fp->locals+GET_ARG2() , &tmp);    print_return_value();    break;    }       CASE(F_ARROW);    {    struct svalue tmp,tmp2; -  tmp.type=T_STRING; +  tmp.type=PIKE_T_STRING;    tmp.u.string=fp->context.prog->strings[GET_ARG()];    tmp.subtype=1;    index_no_free(&tmp2, sp-1, &tmp);    free_svalue(sp-1);    sp[-1]=tmp2;    print_return_value();    break;    }       CASE(F_STRING_INDEX);    {    struct svalue tmp,tmp2; -  tmp.type=T_STRING; +  tmp.type=PIKE_T_STRING;    tmp.u.string=fp->context.prog->strings[GET_ARG()];    tmp.subtype=0;    index_no_free(&tmp2, sp-1, &tmp);    free_svalue(sp-1);    sp[-1]=tmp2;    print_return_value();    break;    }       CASE(F_POS_INT_INDEX);
pike.git/src/interpreter.h:1292:    copy_svalues_recursively_no_free(&tmp,sp-1,1,0);    free_svalue(sp-1);    sp[-1]=tmp;    }    break;       CASE(F_INDIRECT);    {    struct svalue s;    lvalue_to_svalue_no_free(&s,sp-2); -  if(s.type != T_STRING) +  if(s.type != PIKE_T_STRING)    {    pop_n_elems(2);    *sp=s;    sp++;    }else{    struct object *o;    o=low_clone(string_assignment_program);    ((struct string_assignment_storage *)o->storage)->lval[0]=sp[-2];    ((struct string_assignment_storage *)o->storage)->lval[1]=sp[-1];    ((struct string_assignment_storage *)o->storage)->s=s.u.string;
pike.git/src/interpreter.h:1365:    mega_apply(APPLY_STACK,sp - *--mark_sp,0,0);    break;       CASE(F_CALL_FUNCTION_AND_RETURN);    {    INT32 args=sp - *--mark_sp;    if(!args)    PIKE_ERROR("`()", "Too few arguments.\n", sp, 0);    switch(sp[-args].type)    { -  case T_INT: +  case PIKE_T_INT:    if (!sp[-args].u.integer) {    PIKE_ERROR("`()", "Attempt to call the NULL-value\n", sp, args);    } -  case T_STRING: -  case T_FLOAT: -  case T_MAPPING: -  case T_MULTISET: +  case PIKE_T_STRING: +  case PIKE_T_FLOAT: +  case PIKE_T_MAPPING: +  case PIKE_T_MULTISET:    PIKE_ERROR("`()", "Attempt to call a non-function value.\n", sp, args);    }    return args;    }       default:    fatal("Strange instruction %ld\n",(long)instr);    }       }   }