pike.git
/
src
/
operators.c
version
»
Context lines:
10
20
40
80
file
none
3
pike.git/src/operators.c:1:
/*\ ||| This file a part of Pike, and is copyright by Fredrik Hubinette ||| Pike is distributed as GPL (General Public License) ||| See the files COPYING and DISCLAIMER for more information. \*/ #include <math.h> #include "global.h"
-
RCSID("$Id: operators.c,v 1.
15
1997/
05
/
19
23
:
31
:
04
hubbe
Exp $");
+
RCSID("$Id: operators.c,v 1.
16
1997/
08
/
30
18
:
35
:
48
grubba
Exp $");
#include "interpret.h" #include "svalue.h" #include "multiset.h" #include "mapping.h" #include "array.h" #include "stralloc.h" #include "opcodes.h" #include "operators.h" #include "language.h" #include "pike_memory.h"
pike.git/src/operators.c:326:
emit2(F_GT); else if(CAR(n)->u.sval.u.efun->function == f_ge) emit2(F_GE); else fatal("Couldn't generate comparison!\n"); return 1; } return 0; }
-
static int float_promote()
+
static int float_promote(
void
)
{ if(sp[-2].type==T_INT) { sp[-2].u.float_number=(FLOAT_TYPE)sp[-2].u.integer; sp[-2].type=T_FLOAT; } if(sp[-1].type==T_INT) { sp[-1].u.float_number=(FLOAT_TYPE)sp[-1].u.integer; sp[-1].type=T_FLOAT; } return sp[-2].type == sp[-1].type; }
-
void o_subtract()
+
void o_subtract(
void
)
{ if (sp[-2].type != sp[-1].type && !float_promote() && sp[-2].type != T_OBJECT) error("Subtract on different types.\n"); switch(sp[-2].type) { case T_OBJECT: CALL_OPERATOR(LFUN_SUBTRACT,2);
pike.git/src/operators.c:442:
return 1; case 2: do_docode(CDR(n),DO_NOT_COPY); emit2(F_SUBTRACT); return 1; } return 0; }
-
void o_and()
+
void o_and(
void
)
{ if(sp[-1].type != sp[-2].type && sp[-2].type != T_OBJECT) error("Bitwise and on different types.\n"); switch(sp[-2].type) { case T_OBJECT: CALL_OPERATOR(LFUN_AND,2); break;
pike.git/src/operators.c:578:
case 2: do_docode(CDR(n),0); emit2(F_AND); return 1; default: return 0; } }
-
void o_or()
+
void o_or(
void
)
{ if(sp[-1].type != sp[-2].type && sp[-2].type != T_OBJECT) error("Bitwise or on different types.\n"); switch(sp[-2].type) { case T_OBJECT: CALL_OPERATOR(LFUN_OR,2); break;
pike.git/src/operators.c:679:
do_docode(CDR(n),0); emit2(F_OR); return 1; default: return 0; } }
-
void o_xor()
+
void o_xor(
void
)
{ if(sp[-1].type != sp[-2].type && sp[-2].type != T_OBJECT) error("Bitwise xor on different types.\n"); switch(sp[-2].type) { case T_OBJECT: CALL_OPERATOR(LFUN_XOR,2); break;
pike.git/src/operators.c:779:
case 2: do_docode(CDR(n),0); emit2(F_XOR); return 1; default: return 0; } }
-
void o_lsh()
+
void o_lsh(
void
)
{ if(sp[-2].type != T_INT) { if(sp[-2].type == T_OBJECT) { CALL_OPERATOR(LFUN_LSH,2); return; } error("Bad argument 1 to <<\n");
pike.git/src/operators.c:814:
{ if(count_args(CDR(n))==2) { do_docode(CDR(n),DO_NOT_COPY); emit2(F_LSH); return 1; } return 0; }
-
void o_rsh()
+
void o_rsh(
void
)
{ if(sp[-2].type != T_INT) { if(sp[-2].type == T_OBJECT) { CALL_OPERATOR(LFUN_RSH,2); return; } error("Bad argument 1 to >>\n"); }
pike.git/src/operators.c:850:
{ do_docode(CDR(n),DO_NOT_COPY); emit2(F_RSH); return 1; } return 0; } #define TWO_TYPES(X,Y) (((X)<<8)|(Y))
-
void o_multiply()
+
void o_multiply(
void
)
{ switch(TWO_TYPES(sp[-2].type,sp[-1].type)) { case TWO_TYPES(T_ARRAY,T_STRING): { struct pike_string *ret; ret=implode(sp[-2].u.array,sp[-1].u.string); free_string(sp[-1].u.string); free_array(sp[-2].u.array); sp[-2].type=T_STRING;
pike.git/src/operators.c:943:
case 2: do_docode(CDR(n),0); emit2(F_MULTIPLY); return 1; default: return 0; } }
-
void o_divide()
+
void o_divide(
void
)
{ if(sp[-2].type!=sp[-1].type && !float_promote() && sp[-2].type != T_OBJECT) error("Division on different types.\n"); switch(sp[-2].type) { case T_OBJECT: CALL_OPERATOR(LFUN_DIVIDE,2);
pike.git/src/operators.c:1021:
{ if(count_args(CDR(n))==2) { do_docode(CDR(n),DO_NOT_COPY); emit2(F_DIVIDE); return 1; } return 0; }
-
void o_mod()
+
void o_mod(
void
)
{ if(sp[-2].type != sp[-1].type && !float_promote() && sp[-2].type != T_OBJECT) error("Modulo on different types.\n"); switch(sp[-2].type) { case T_OBJECT: CALL_OPERATOR(LFUN_MOD,2);
pike.git/src/operators.c:1089:
{ if(count_args(CDR(n))==2) { do_docode(CDR(n),DO_NOT_COPY); emit2(F_MOD); return 1; } return 0; }
-
void o_not()
+
void o_not(
void
)
{ switch(sp[-1].type) { case T_INT: sp[-1].u.integer = !sp[-1].u.integer; break; case T_FUNCTION: case T_OBJECT: if(IS_ZERO(sp-1))
pike.git/src/operators.c:1133:
{ if(count_args(CDR(n))==1) { do_docode(CDR(n),DO_NOT_COPY); emit2(F_NOT); return 1; } return 0; }
-
void o_compl()
+
void o_compl(
void
)
{ switch(sp[-1].type) { case T_OBJECT: CALL_OPERATOR(LFUN_COMPL,1); break; case T_INT: sp[-1].u.integer = ~ sp[-1].u.integer; break;
pike.git/src/operators.c:1185:
{ if(count_args(CDR(n))==1) { do_docode(CDR(n),DO_NOT_COPY); emit2(F_COMPL); return 1; } return 0; }
-
void o_negate()
+
void o_negate(
void
)
{ switch(sp[-1].type) { case T_OBJECT: CALL_OPERATOR(LFUN_SUBTRACT,1); break; case T_FLOAT: sp[-1].u.float_number=-sp[-1].u.float_number; return; case T_INT: sp[-1].u.integer = - sp[-1].u.integer; return; default: error("Bad argument to unary minus\n"); } }
-
void o_range()
+
void o_range(
void
)
{ INT32 from,to; if(sp[-3].type==T_OBJECT) { CALL_OPERATOR(LFUN_INDEX, 2); return; } if(sp[-2].type != T_INT)
pike.git/src/operators.c:1332:
static int generate_sizeof(node *n) { node **arg; if(count_args(CDR(n)) != 1) return 0; if(do_docode(CDR(n),DO_NOT_COPY) != 1) fatal("Count args was wrong in sizeof().\n"); emit2(F_SIZEOF); return 1; }
-
void init_operators()
+
void init_operators(
void
)
{ add_efun2("`[]",f_index, "function(string,int:int)|function(object,string:mixed)|function(array,int:mixed)|function(mapping,mixed:mixed)|function(multiset,mixed:int)|function(string,int,int:string)|function(array,int,int:array)",OPT_TRY_OPTIMIZE,0,0); add_efun2("`->",f_arrow, "function(object|mapping|multiset,string:mixed)",OPT_TRY_OPTIMIZE,0,0); add_efun2("`==",f_eq,"function(mixed,mixed:int)",OPT_TRY_OPTIMIZE,0,generate_comparison); add_efun2("`!=",f_ne,"function(mixed,mixed:int)",OPT_TRY_OPTIMIZE,0,generate_comparison); add_efun2("`!",f_not,"function(mixed:int)",OPT_TRY_OPTIMIZE,0,generate_not);