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)