pike.git / src / docode.c

version» Context lines:

pike.git/src/docode.c:569:    free_string(n1);       switch(n?n->token:0)    {    case F_CONSTANT:    tmp1=store_constant(&n->u.sval,    !(n->tree_info & OPT_EXTERNAL_DEPEND),    n->name);    if(TYPEOF(n->u.sval) == T_FUNCTION &&    SUBTYPEOF(n->u.sval) == FUNCTION_BUILTIN) -  emit1(F_CALL_BUILTIN, DO_NOT_WARN((INT32)tmp1)); +  emit1(F_CALL_BUILTIN, (INT32)tmp1);    else -  emit1(F_APPLY, DO_NOT_WARN((INT32)tmp1)); +  emit1(F_APPLY, (INT32)tmp1);    break;       default:    my_yyerror("docode: Failed to make call to %s",func);    }    free_node(n);   }      static int do_encode_automap_arg_list(node *n,    int flags)
pike.git/src/docode.c:633:    node *n=find_module_identifier(n1,0);    free_string(n1);       switch(n?n->token:0)    {    case F_CONSTANT:    tmp1=store_constant(&n->u.sval,    (!(n->tree_info & OPT_EXTERNAL_DEPEND)) &&    (TYPEOF(n->u.sval) != T_TYPE),    n->name); -  emit1(F_CONSTANT, DO_NOT_WARN((INT32)tmp1)); +  emit1(F_CONSTANT, (INT32)tmp1);    break;       default:    my_yyerror("docode: Failed to make svalue for builtin %s",func);    }    free_node(n);   }      static void emit_range (node *n DO_IF_DEBUG (COMMA int num_args))   {
pike.git/src/docode.c:778: Inside #if defined(PIKE_DEBUG)
   if( !node_is_eq(*arg,lval) )    Pike_fatal("lval should be the same as arg1, or this will not work.\n");   #endif    do_docode(lval, DO_LVALUE);    emit0(F_MARK);    emit0(F_CONST0);    PUSH_CLEANUP_FRAME(do_pop_mark, 0);    while ((arg = my_get_arg(&args, ++no)) && *arg) {    do_docode(*arg, 0);    } -  emit1(F_LTOSVAL_CALL_BUILTIN_AND_ASSIGN, DO_NOT_WARN((INT32)tmp1)); +  emit1(F_LTOSVAL_CALL_BUILTIN_AND_ASSIGN, (INT32)tmp1);    POP_AND_DONT_CLEANUP;    return 1;   }      static int is_apply_constant_function_arg0( node *n, node *target )   {    if (/*n->token == F_APPLY &&*/    (CAR(n)->token == F_CONSTANT) &&    (TYPEOF(CAR(n)->u.sval) == T_FUNCTION) &&    (SUBTYPEOF(CAR(n)->u.sval) == FUNCTION_BUILTIN) &&
pike.git/src/docode.c:1192:       case '?':    {    INT32 *prev_switch_jumptable = current_switch.jumptable;    int adroppings , bdroppings;    current_switch.jumptable=0;       if(!CDDR(n))    {    tmp1=alloc_label(); -  do_jump_when_zero(CAR(n), DO_NOT_WARN((INT32)tmp1)); +  do_jump_when_zero(CAR(n), (INT32)tmp1);    DO_CODE_BLOCK(CADR(n)); -  low_insert_label( DO_NOT_WARN((INT32)tmp1)); +  low_insert_label( (INT32)tmp1 );    current_switch.jumptable = prev_switch_jumptable;    return 0;    }       if(!CADR(n))    {    tmp1=alloc_label(); -  do_jump_when_non_zero(CAR(n), DO_NOT_WARN((INT32)tmp1)); +  do_jump_when_non_zero(CAR(n), (INT32)tmp1);    DO_CODE_BLOCK(CDDR(n)); -  low_insert_label( DO_NOT_WARN((INT32)tmp1)); +  low_insert_label( (INT32)tmp1 );    current_switch.jumptable = prev_switch_jumptable;    return 0;    }       tmp1=alloc_label(); -  do_jump_when_zero(CAR(n), DO_NOT_WARN((INT32)tmp1)); +  do_jump_when_zero(CAR(n), (INT32)tmp1);       adroppings=do_docode(CADR(n), flags);    tmp3=emit1(F_POP_N_ELEMS,0);       /* Else */    tmp2=do_branch(-1); -  low_insert_label( DO_NOT_WARN((INT32)tmp1)); +  low_insert_label( (INT32)tmp1 );       bdroppings=do_docode(CDDR(n), flags);    if(adroppings < bdroppings)    {    do_pop(bdroppings - adroppings);    }       if(adroppings > bdroppings)    { -  update_arg(DO_NOT_WARN((INT32)tmp3), -  adroppings - bdroppings); +  update_arg((INT32)tmp3, adroppings - bdroppings);    adroppings=bdroppings;    }    -  low_insert_label( DO_NOT_WARN((INT32)tmp2)); +  low_insert_label( (INT32)tmp2 );       current_switch.jumptable = prev_switch_jumptable;    return adroppings;    }       case F_MULTI_ASSIGN:    if (flags & DO_POP) {    emit_multi_assign(CAR(n), CDR(n), 0);    return 0;    } else {    /* Fall back to the normal assign case. */    tmp1=do_docode(CDR(n),DO_LVALUE);   #ifdef PIKE_DEBUG    if(tmp1 & 1)    Pike_fatal("Very internal compiler error.\n");   #endif -  emit1(F_ARRAY_LVALUE, DO_NOT_WARN((INT32)(tmp1>>1))); +  emit1(F_ARRAY_LVALUE, (INT32)(tmp1>>1) );    emit0(F_MARK);    PUSH_CLEANUP_FRAME(do_pop_mark, 0);    do_docode(CAR(n), 0);    emit_apply_builtin("aggregate");    POP_AND_DONT_CLEANUP;    emit0(F_ASSIGN);    return 1;    }       case F_ASSIGN_SELF:
pike.git/src/docode.c:1471:    break;    }    return flags & DO_POP ? 0 : 1;    }       case F_LAND:    case F_LOR:    tmp1=alloc_label();    if(flags & DO_POP)    { -  do_cond_jump(CAR(n), DO_NOT_WARN((INT32)tmp1), n->token == F_LOR, DO_POP); +  do_cond_jump(CAR(n), (INT32)tmp1, n->token == F_LOR, DO_POP);    DO_CODE_BLOCK(CDR(n)); -  low_insert_label( DO_NOT_WARN((INT32)tmp1)); +  low_insert_label( (INT32)tmp1 );    return 0;    }else{ -  do_cond_jump(CAR(n), DO_NOT_WARN((INT32)tmp1), n->token == F_LOR, 0); +  do_cond_jump(CAR(n), (INT32)tmp1, n->token == F_LOR, 0);    code_expression(CDR(n), flags, n->token == F_LOR ? "||" : "&&"); -  low_insert_label( DO_NOT_WARN((INT32)tmp1)); +  low_insert_label( (INT32)tmp1 );    return 1;    }       case F_RANGE:    tmp1=do_docode(CAR(n),DO_NOT_COPY_TOPLEVEL);    {   #ifdef PIKE_DEBUG    int num_args =   #endif    do_docode (CDR (n), DO_NOT_COPY);    emit_range (n DO_IF_DEBUG (COMMA num_args)); -  return DO_NOT_WARN((INT32)tmp1); +  return (INT32)tmp1;    }       /* The special bound type nodes are simply ignored when the    * arglist to the range operator is coded. emit_range looks at    * them later on instead. */    case F_RANGE_FROM_BEG:    case F_RANGE_FROM_END:    return do_docode (CAR (n), flags);    case F_RANGE_OPEN:    return 0;
pike.git/src/docode.c:1645:    if(CDR(n))    {    do_jump_when_zero(CAR(n),current_label->break_label);    tmp2=ins_label(-1);    DO_CODE_BLOCK(CADR(n));    ins_label(current_label->continue_label);    DO_CODE_BLOCK(CDDR(n));    }else{    tmp2=ins_label(-1);    } -  do_jump_when_non_zero(CAR(n), DO_NOT_WARN((INT32)tmp2)); +  do_jump_when_non_zero(CAR(n), (INT32)tmp2);    ins_label(current_label->break_label);       current_switch.jumptable = prev_switch_jumptable;    POP_STATEMENT_LABEL;    BLOCK_END;    return 0;    }       case ' ':    ret = do_docode(CAR(n),0);
pike.git/src/docode.c:1699:    PUSH_CLEANUP_FRAME(do_pop, 5);       PUSH_STATEMENT_LABEL;    current_switch.jumptable=0;    current_label->break_label=alloc_label();    current_label->continue_label=alloc_label();       /* Doubt it's necessary to use a label separate from    * current_label->break_label, but I'm playing safe. /mast */    tmp3 = alloc_label(); -  do_jump(F_FOREACH_START, DO_NOT_WARN((INT32) tmp3)); +  do_jump(F_FOREACH_START, (INT32) tmp3);    tmp1=ins_label(-1);    DO_CODE_BLOCK(CDR(n));    ins_label(current_label->continue_label); -  do_jump(F_FOREACH_LOOP, DO_NOT_WARN((INT32)tmp1)); +  do_jump(F_FOREACH_LOOP, (INT32)tmp1);    ins_label(current_label->break_label); -  low_insert_label( DO_NOT_WARN((INT32)tmp3)); +  low_insert_label( (INT32)tmp3 );       current_switch.jumptable = prev_switch_jumptable;    POP_STATEMENT_LABEL;    POP_AND_DO_CLEANUP;    BLOCK_END;    return 0;    }          BLOCK_BEGIN;
pike.git/src/docode.c:1745:    goto foreach_arg_pushed;    }    do_docode (CAR(low), DO_NOT_COPY);    tmp1 = alloc_label();    emit0(F_DUP);    emit0(F_CONST0);    do_jump(F_BRANCH_WHEN_GE, tmp1);    /* The value is negative. replace it with zero. */    emit0(F_POP_VALUE);    emit0(F_CONST0); -  low_insert_label(DO_NOT_WARN((INT32)tmp1)); +  low_insert_label((INT32)tmp1);    goto foreach_arg_pushed;    }    }    do_docode(arr,DO_NOT_COPY);    emit0(F_CONST0);    current_stack_depth++;    foreach_arg_pushed:    PUSH_CLEANUP_FRAME(do_pop, 4);       PUSH_STATEMENT_LABEL;    current_switch.jumptable=0;    current_label->break_label=alloc_label();    current_label->continue_label=alloc_label();       tmp3=do_branch(-1);    tmp1=ins_label(-1);    DO_CODE_BLOCK(CDR(n));    ins_label(current_label->continue_label); -  low_insert_label( DO_NOT_WARN((INT32)tmp3)); -  do_jump(n->token, DO_NOT_WARN((INT32)tmp1)); +  low_insert_label( (INT32)tmp3 ); +  do_jump(n->token, (INT32)tmp1);    ins_label(current_label->break_label);       current_switch.jumptable = prev_switch_jumptable;    POP_STATEMENT_LABEL;    POP_AND_DO_CLEANUP;    BLOCK_END;    return 0;    }       case F_INC_NEQ_LOOP:
pike.git/src/docode.c:1795:       PUSH_STATEMENT_LABEL;    current_switch.jumptable=0;    current_label->break_label=alloc_label();    current_label->continue_label=alloc_label();    tmp3=do_branch(-1);    tmp1=ins_label(-1);       DO_CODE_BLOCK(CDR(n));    ins_label(current_label->continue_label); -  low_insert_label( DO_NOT_WARN((INT32)tmp3)); -  do_jump(n->token, DO_NOT_WARN((INT32)tmp1)); +  low_insert_label( (INT32)tmp3 ); +  do_jump(n->token, (INT32)tmp1);    ins_label(current_label->break_label);       current_switch.jumptable = prev_switch_jumptable;    POP_STATEMENT_LABEL;    POP_AND_DO_CLEANUP;    BLOCK_END;    return 0;    }       case F_LOOP:
pike.git/src/docode.c:1836:    BLOCK_BEGIN;    PUSH_STATEMENT_LABEL;       current_switch.jumptable=0;    current_label->break_label=alloc_label();    current_label->continue_label=alloc_label();       tmp2=ins_label(-1);    DO_CODE_BLOCK(CAR(n));    ins_label(current_label->continue_label); -  do_jump_when_non_zero(CDR(n), DO_NOT_WARN((INT32)tmp2)); +  do_jump_when_non_zero(CDR(n), (INT32)tmp2);    ins_label(current_label->break_label);       current_switch.jumptable = prev_switch_jumptable;    POP_STATEMENT_LABEL;    BLOCK_END;    return 0;    }       case F_POP_VALUE:    {
pike.git/src/docode.c:1865:    case T_VOID:    DO_CODE_BLOCK(CAR(n));    return 0;    case T_INT:    /* FIXME: Integer range? */    tmp1 = do_docode(CAR(n), 0);    if(!tmp1)    emit0(F_CONST0);    else {    if(tmp1>1) -  do_pop(DO_NOT_WARN((INT32)(tmp1-1))); +  do_pop((INT32)(tmp1-1));    emit0(F_CAST_TO_INT);    }    return 1;    case T_STRING:    /* FIXME: String width? */    tmp1 = do_docode(CAR(n), 0);    if(!tmp1)    emit0(F_CONST0);    else if(tmp1>1) -  do_pop(DO_NOT_WARN((INT32)(tmp1-1))); +  do_pop((INT32)(tmp1-1));    emit0(F_CAST_TO_STRING);    return 1;    default:    if (compile_type_to_runtime_type(n->type) == PIKE_T_MIXED) {    tmp1 = do_docode(CAR(n), 0);    if(!tmp1)    emit0(F_CONST0);    else if(tmp1>1) -  do_pop(DO_NOT_WARN((INT32)(tmp1-1))); +  do_pop((INT32)(tmp1-1));    return 1;    }    }    {    struct svalue sv;    SET_SVAL(sv, T_TYPE, 0, type, n->type);    tmp1 = store_constant(&sv, 0, n->name); -  emit1(F_CONSTANT, DO_NOT_WARN((INT32)tmp1)); +  emit1(F_CONSTANT, (INT32)tmp1);    }       tmp1=do_docode(CAR(n),0);    if(!tmp1) { emit0(F_CONST0); tmp1=1; } -  if(tmp1>1) do_pop(DO_NOT_WARN((INT32)(tmp1-1))); +  if(tmp1>1) do_pop((INT32)(tmp1-1));       emit0(F_CAST);    return 1;       case F_SOFT_CAST:    if (runtime_options & RUNTIME_CHECK_TYPES) {    {    struct svalue sv;    SET_SVAL(sv, T_TYPE, 0, type, n->type);    tmp1 = store_constant(&sv, 0, n->name); -  emit1(F_CONSTANT, DO_NOT_WARN((INT32)tmp1)); +  emit1(F_CONSTANT, (INT32)tmp1);    }    tmp1 = do_docode(CAR(n), 0);    if (!tmp1) { emit0(F_CONST0); tmp1 = 1; } -  if (tmp1 > 1) do_pop(DO_NOT_WARN((INT32)(tmp1 - 1))); +  if (tmp1 > 1) do_pop((INT32)(tmp1 - 1));    emit0(F_SOFT_CAST);    return 1;    }    tmp1 = do_docode(CAR(n), flags); -  if (tmp1 > 1) do_pop(DO_NOT_WARN((INT32)(tmp1 - 1))); +  if (tmp1 > 1) do_pop((INT32)(tmp1 - 1));    return !!tmp1;       case F_APPLY:    if(CAR(n)->token == F_CONSTANT)    {    int args = count_args(CDR(n));    if(TYPEOF(CAR(n)->u.sval) == T_FUNCTION)    {    if(SUBTYPEOF(CAR(n)->u.sval) == FUNCTION_BUILTIN) /* driver fun? */    {    if(!CAR(n)->u.sval.u.efun->docode ||    !CAR(n)->u.sval.u.efun->docode(n))    {    if(args==1)    {    do_docode(CDR(n),0);    tmp1=store_constant(& CAR(n)->u.sval,    !(CAR(n)->tree_info & OPT_EXTERNAL_DEPEND),    CAR(n)->name); -  emit1(F_CALL_BUILTIN1, DO_NOT_WARN((INT32)tmp1)); +  emit1(F_CALL_BUILTIN1, (INT32)tmp1);   #ifdef USE_APPLY_N    }else if(args>0){    do_docode(CDR(n),0);    tmp1=store_constant(& CAR(n)->u.sval,    !(CAR(n)->tree_info & OPT_EXTERNAL_DEPEND),    CAR(n)->name); -  emit2(F_CALL_BUILTIN_N, DO_NOT_WARN((INT32)tmp1), args); +  emit2(F_CALL_BUILTIN_N, (INT32)tmp1, args);   #endif    }else{    emit0(F_MARK);    PUSH_CLEANUP_FRAME(do_pop_mark, 0);    do_docode(CDR(n),0);    tmp1=store_constant(& CAR(n)->u.sval,    !(CAR(n)->tree_info & OPT_EXTERNAL_DEPEND),    CAR(n)->name); -  emit1(F_CALL_BUILTIN, DO_NOT_WARN((INT32)tmp1)); +  emit1(F_CALL_BUILTIN, (INT32)tmp1);    POP_AND_DONT_CLEANUP;    }    }    if(n->type == void_type_string)    return 0;    return 1;    }else{    if(CAR(n)->u.sval.u.object == Pike_compiler->fake_object)    return do_lfun_call(SUBTYPEOF(CAR(n)->u.sval), CDR(n));    }
pike.git/src/docode.c:1975: Inside #if defined(USE_APPLY_N)
  #ifdef USE_APPLY_N    if( args <= 1 )   #endif    {    emit0(F_MARK);    PUSH_CLEANUP_FRAME(do_pop_mark, 0);    do_docode(CDR(n),0);    tmp1=store_constant(& CAR(n)->u.sval,    !(CAR(n)->tree_info & OPT_EXTERNAL_DEPEND),    CAR(n)->name); -  emit1(F_APPLY, DO_NOT_WARN((INT32)tmp1)); +  emit1(F_APPLY, (INT32)tmp1);    POP_AND_DONT_CLEANUP;    }   #ifdef USE_APPLY_N    else    {    do_docode(CDR(n),0);    tmp1=store_constant(& CAR(n)->u.sval,    !(CAR(n)->tree_info & OPT_EXTERNAL_DEPEND),    CAR(n)->name); -  emit2(F_APPLY_N, DO_NOT_WARN((INT32)tmp1), args); +  emit2(F_APPLY_N, (INT32)tmp1, args);    }   #endif    return 1;    }    else if(CAR(n)->token == F_EXTERNAL &&    CAR(n)->u.integer.a == Pike_compiler->new_program->id &&    CAR(n)->u.integer.b != IDREF_MAGIC_THIS)    {    return do_lfun_call(CAR(n)->u.integer.b, CDR(n));    }
pike.git/src/docode.c:2037:    yyerror("No call_function efun.");    }else{    if(TYPEOF(foo->u.sval) == T_FUNCTION &&    SUBTYPEOF(foo->u.sval) == FUNCTION_BUILTIN &&    foo->u.sval.u.efun->function == f_call_function)    {    emit0(F_CALL_FUNCTION);    }else{    /* We might want to put "predef::"+foo->name here /Hubbe */    tmp1=store_constant(& foo->u.sval, 1, foo->name); -  emit1(F_APPLY, DO_NOT_WARN((INT32)tmp1)); +  emit1(F_APPLY, (INT32)tmp1);    }    }    free_node(foo);    POP_AND_DONT_CLEANUP;    return 1;    }       case F_ARG_LIST:    case F_COMMA_EXPR:    case ':':
pike.git/src/docode.c:2093:    /* Retrace */    /* Note: n->parent is always a visited CAR node on the    * way to the root.    */    n = n->parent;    } while (n);       /* Restore root->parent. */    root->parent = parent;    } -  return DO_NOT_WARN((INT32)tmp1); +  return (INT32)tmp1;          /* Switch:    * So far all switches are implemented with a binsearch lookup.    * It stores the case values in the programs area for constants.    * It also has a jump-table in the program itself, for every index in    * the array of cases, there is 2 indexes in the jumptable, and one extra.    * The first entry in the jumptable is used if you call switch with    * a value that is ranked lower than all the indexes in the array of    * cases. (Ranked by the binsearch that is) The second is used if it
pike.git/src/docode.c:2145:    current_switch.values_on_stack=0;    current_switch.index=2;    current_switch.less_label=-1;    current_switch.greater_label=-1;    current_switch.default_label=-1;    current_switch.jumptable=xalloc(sizeof(INT32)*(cases*2+2));    jumptable=xalloc(sizeof(INT32)*(cases*2+2));       for(e=1; e<cases*2+2; e++)    { -  jumptable[e] = DO_NOT_WARN((INT32)emit1(F_POINTER, 0)); +  jumptable[e] = (INT32)emit1(F_POINTER, 0);    current_switch.jumptable[e]=-1;    }    emit0(F_NOTREACHED);       DO_CODE_BLOCK(CDR(n));      #ifdef PIKE_DEBUG    if(Pike_sp-save_sp != cases)    Pike_fatal("Count cases is wrong!\n");   #endif
pike.git/src/docode.c:2208:    if(current_switch.default_label < 0)    current_switch.default_label = ins_label(-1);       for(e=1;e<cases*2+2;e++)    if(current_switch.jumptable[e]==-1)    current_switch.jumptable[e]=current_switch.default_label;       for(e=1; e<cases*2+2; e++)    update_arg(jumptable[e], current_switch.jumptable[e]);    -  update_arg(DO_NOT_WARN((INT32)tmp1), -  store_constant(Pike_sp-1,1,0)); +  update_arg((INT32)tmp1, store_constant(Pike_sp-1,1,0));       pop_stack();    free(jumptable);    free(current_switch.jumptable);       current_switch = prev_switch;       low_insert_label( current_label->break_label);       POP_STATEMENT_LABEL;
pike.git/src/docode.c:2451:    }    }       emit0(in_catch ? F_VOLATILE_RETURN : F_RETURN);    return 0;    }       case F_SSCANF:    tmp1=do_docode(CAR(n),DO_NOT_COPY);    tmp2=do_docode(CDR(n),DO_NOT_COPY | DO_LVALUE); -  emit1(F_SSCANF, DO_NOT_WARN((INT32)(tmp1+tmp2))); +  emit1(F_SSCANF, (INT32)(tmp1+tmp2));    return 1;       case F_CATCH: {    INT32 *prev_switch_jumptable = current_switch.jumptable;       tmp1=do_jump(F_CATCH,-1);    PUSH_CLEANUP_FRAME(do_escape_catch, 0);       /* Entry point called via catching_eval_instruction(). */    emit0(F_ENTRY);
pike.git/src/docode.c:2485:    current_stack_depth++;    /* Entry point called via catching_eval_instruction() after    * catching an error.    *    * NB: This is reached by subtracting ENTRY_PROLOGUE_SIZE    * from the label below.    * NB: The label must be after the entry, since it may expand to code    * that requires the entry code to have run.    */    emit0(F_ENTRY); -  ins_label(DO_NOT_WARN((INT32)tmp1)); +  ins_label((INT32)tmp1);       POP_AND_DONT_CLEANUP;    return 1;    }       case F_LVALUE_LIST:    ret = do_docode(CAR(n),DO_LVALUE);    return ret + do_docode(CDR(n),DO_LVALUE);       case F_ARRAY_LVALUE:    tmp1=do_docode(CAR(n),DO_LVALUE);   #ifdef PIKE_DEBUG    if(tmp1 & 1)    Pike_fatal("Very internal compiler error.\n");   #endif -  emit1(F_ARRAY_LVALUE, DO_NOT_WARN((INT32)(tmp1>>1))); +  emit1(F_ARRAY_LVALUE, (INT32)(tmp1>>1));    return 2;       case F_ARROW:    if(CDR(n)->token != F_CONSTANT || TYPEOF(CDR(n)->u.sval) != T_STRING)    Pike_fatal("Bugg in F_ARROW, index not string.\n");    if(flags & WANT_LVALUE)    {    /* FIXME!!!! ??? I wonder what needs fixing... /Hubbe */    tmp1=do_docode(CAR(n), 0);    emit1(F_ARROW_STRING, store_prog_string(CDR(n)->u.sval.u.string));
pike.git/src/docode.c:2527:    } else {    emit1(F_ARROW, store_prog_string(CDR(n)->u.sval.u.string));    }    if(!(flags & DO_NOT_COPY))    {    while(n && (n->token==F_INDEX || n->token==F_ARROW)) n=CAR(n);    if(n && n->token==F_CONSTANT && !(n->node_info & OPT_EXTERNAL_DEPEND))    emit0(F_COPY_VALUE);    }    } -  return DO_NOT_WARN((INT32)tmp1); +  return (INT32)tmp1;       case F_INDEX:    if(flags & WANT_LVALUE)    {    int mklval=CAR(n) && match_types(CAR(n)->type, string_type_string);    tmp1 = do_docode(CAR(n),    mklval ? DO_LVALUE_IF_POSSIBLE : 0);    if(tmp1==2)    {   #ifdef PIKE_DEBUG
pike.git/src/docode.c:2567:       emit0(F_INDEX);       if(!(flags & DO_NOT_COPY))    {    while(n && (n->token==F_INDEX || n->token==F_ARROW)) n=CAR(n);    if(n && (n->token==F_CONSTANT) && !(n->node_info & OPT_EXTERNAL_DEPEND))    emit0(F_COPY_VALUE);    }    } -  return DO_NOT_WARN((INT32)tmp1); +  return (INT32)tmp1;       case F_CONSTANT:    switch(TYPEOF(n->u.sval))    {    case T_INT:    if(!n->u.sval.u.integer && SUBTYPEOF(n->u.sval) == NUMBER_UNDEFINED)    {    emit0(F_UNDEFINED);    }else{   #if SIZEOF_INT_TYPE > 4
pike.git/src/docode.c:2597: Inside #if SIZEOF_INT_TYPE > 4
   else    emit1(F_NUMBER,i);   #else    emit1(F_NUMBER,n->u.sval.u.integer);   #endif    }    return 1;       case T_STRING:    tmp1=store_prog_string(n->u.sval.u.string); -  emit1(F_STRING, DO_NOT_WARN((INT32)tmp1)); +  emit1(F_STRING, (INT32)tmp1);    return 1;       case T_FUNCTION:    if(SUBTYPEOF(n->u.sval) != FUNCTION_BUILTIN)    {    if(n->u.sval.u.object == Pike_compiler->fake_object)    {    /* When does this occur? /mast */    emit1(F_GLOBAL, SUBTYPEOF(n->u.sval));    return 1;
pike.git/src/docode.c:2645:    /* FALL_THROUGH */    default:   #ifdef PIKE_DEBUG    if((TYPEOF(n->u.sval) == T_OBJECT) &&    (n->u.sval.u.object->next == n->u.sval.u.object))    Pike_fatal("Internal error: Pointer to parent cannot be a compile time constant!\n");   #endif    tmp1=store_constant(&(n->u.sval),    !(n->tree_info & OPT_EXTERNAL_DEPEND),    n->name); -  emit1(F_CONSTANT, DO_NOT_WARN((INT32)tmp1)); +  emit1(F_CONSTANT, (INT32)tmp1);    return 1;       case T_TYPE:    tmp1 = store_constant(&(n->u.sval), 0, n->name); -  emit1(F_CONSTANT, DO_NOT_WARN((INT32)tmp1)); +  emit1(F_CONSTANT, (INT32)tmp1);    return 1;       case T_ARRAY:    case T_MAPPING:    case T_MULTISET:    tmp1=store_constant(&(n->u.sval),    !(n->tree_info & OPT_EXTERNAL_DEPEND),    n->name); -  emit1(F_CONSTANT, DO_NOT_WARN((INT32)tmp1)); +  emit1(F_CONSTANT, (INT32)tmp1);       /* copy now or later ? */    if(!(flags & DO_NOT_COPY) && !(n->tree_info & OPT_EXTERNAL_DEPEND))    {    if(flags & DO_NOT_COPY_TOPLEVEL)    {    switch(TYPEOF(n->u.sval))    {    case T_ARRAY:    if(array_fix_type_field(n->u.sval.u.array) & BIT_COMPLEX)