pike.git/ src/ operators.c

1996-06-21

1996-06-21 19:53:25 by Fredrik Hübinette (Hubbe) <hubbe@hubbe.net>

• 07c0737aa1ce07da6be82c9e41f6e1de728cf67a (202 lines) (+163/-39) ^{[ Show | Annotate ]}
  Branch: branches/E-12

operator overloading added

Rev: src/opcodes.c:1.5
Rev: src/operators.c:1.9
Rev: src/svalue.c:1.12
Rev: src/svalue.h:1.9

20:   #include "add_efun.h"   #include "peep.h"   #include "lex.h" + #include "program.h" + #include "object.h"      #define COMPARISON(ID,NAME,EXPR) \   void ID(INT32 args) \
31:    error("Too few arguments to %s\n",NAME); \    i=EXPR; \    pop_n_elems(2); \ -  sp->type=T_INT; \ -  sp->u.integer=i; \ -  sp++; \ +  push_int(i); \   }      COMPARISON(f_eq,"`==", is_eq(sp-2,sp-1))
44:   COMPARISON(f_ge,"`>=",!is_lt(sp-2,sp-1))       + #define CALL_OPERATOR(OP, args) \ +  if(!sp[-args].u.object->prog) \ +  error("Operator %s called in destructed object.\n",lfun_names[OP]); \ +  if(sp[-args].u.object->prog->lfuns[OP] == -1) \ +  error("No operator %s in object.\n",lfun_names[OP]); \ +  apply_lfun(sp[-args].u.object, OP, args-1); \ +  free_svalue(sp-2); \ +  sp[-2]=sp[-1]; \ +  sp--; +  +    void f_add(INT32 args)   {    INT32 e,size;
60:    switch(sp[-args].type)    {    case T_OBJECT: +  CALL_OPERATOR(LFUN_ADD,args); +  return; +     case T_PROGRAM:    case T_FUNCTION:    error("Bad argument 1 to summation\n");
338:      void o_subtract()   { -  if (sp[-2].type != sp[-1].type && !float_promote()) +  if (sp[-2].type != sp[-1].type && +  !float_promote() && +  sp[-2].type != T_OBJECT)    error("Subtract on different types.\n");    -  switch(sp[-1].type) +  switch(sp[-2].type)    { -  +  case T_OBJECT: +  CALL_OPERATOR(LFUN_SUBTRACT,2); +  break; +     case T_ARRAY:    {    struct array *a;
431:      void o_and()   { -  if(sp[-1].type != sp[-2].type) +  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; +     case T_INT:    sp--;    sp[-1].u.integer &= sp[0].u.integer;
479:    case 0: error("Too few arguments to `&\n");    case 1: return;    case 2: o_and(); return; -  default: while(--args > 0) o_and(); +  default: +  if(sp[-args].type == T_OBJECT) +  { +  CALL_OPERATOR(LFUN_AND, args); +  }else{ +  while(--args > 0) o_and();    }    } -  + }      static int generate_and(node *n)   {
503:      void o_or()   { -  if(sp[-1].type != sp[-2].type) +  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; +     case T_INT:    sp--;    sp[-1].u.integer |= sp[0].u.integer;
552:    case 0: error("Too few arguments to `|\n");    case 1: return;    case 2: o_or(); return; -  default: while(--args > 0) o_or(); +  default: +  if(sp[-args].type==T_OBJECT) +  { +  CALL_OPERATOR(LFUN_OR, args); +  } else { +  while(--args > 0) o_or();    }    } -  + }      static int generate_or(node *n)   {
577:      void o_xor()   { -  if(sp[-1].type != sp[-2].type) +  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; +     case T_INT:    sp--;    sp[-1].u.integer ^= sp[0].u.integer;
625:    case 0: error("Too few arguments to `^\n");    case 1: return;    case 2: o_xor(); return; -  default: while(--args > 0) o_xor(); +  default: +  if(sp[-args].type==T_OBJECT) +  { +  CALL_OPERATOR(LFUN_XOR, args); +  } else { +  while(--args > 0) o_xor();    }    } -  + }      static int generate_xor(node *n)   {
649:      void o_lsh()   { -  if(sp[-2].type != T_INT) error("Bad argument 1 to <<\n"); +  if(sp[-2].type != T_INT) +  { +  if(sp[-2].type == T_OBJECT) +  { +  CALL_OPERATOR(LFUN_LSH,2); +  return; +  } +  +  error("Bad argument 1 to <<\n"); +  }    if(sp[-1].type != T_INT) error("Bad argument 2 to <<\n");    sp--;    sp[-1].u.integer = sp[-1].u.integer << sp->u.integer;
675:      void o_rsh()   { -  if(sp[-2].type != T_INT) error("Bad argument 1 to >>\n"); +  if(sp[-2].type != T_INT) +  { +  if(sp[-2].type == T_OBJECT) +  { +  CALL_OPERATOR(LFUN_RSH,2); +  return; +  } +  error("Bad argument 1 to >>\n"); +  }    if(sp[-1].type != T_INT) error("Bad argument 2 to >>\n");    sp--;    sp[-1].u.integer = sp[-1].u.integer >> sp->u.integer;
740:    return;       default: +  if(sp[-2].type == T_OBJECT) +  { +  CALL_OPERATOR(LFUN_MULTIPLY,2); +  return; +  } +     error("Bad arguments to multiply.\n");    }   }
751:    case 0: error("Too few arguments to `*\n");    case 1: return;    case 2: o_multiply(); return; -  default: while(--args > 0) o_multiply(); +  default: +  if(sp[-args].type==T_OBJECT) +  { +  CALL_OPERATOR(LFUN_MULTIPLY, args); +  } else { +  while(--args > 0) o_multiply();    }    } -  + }      static int generate_multiply(node *n)   {
775:      void o_divide()   { -  if(sp[-2].type!=sp[-1].type && !float_promote()) +  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); +  break; +     case T_STRING:    {    struct array *ret;
831:      void o_mod()   { -  if(sp[-2].type != sp[-1].type && !float_promote()) +  if(sp[-2].type != sp[-1].type && +  !float_promote() && +  sp[-2].type != T_OBJECT)    error("Modulo on different types.\n");    -  switch(sp[-1].type) +  switch(sp[-2].type)    { -  +  case T_OBJECT: +  CALL_OPERATOR(LFUN_MOD,2); +  break; +     case T_FLOAT:    {    FLOAT_TYPE foo;
878:      void o_not()   { -  if(sp[-1].type==T_INT) +  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)) +  { +  pop_stack(); +  push_int(1);    }else{    pop_stack(); -  sp->type=T_INT; -  sp->u.integer=0; -  sp++; +  push_int(0);    } -  +  break; +  +  default: +  free_svalue(sp-1); +  sp[-1].type=T_INT; +  sp[-1].u.integer=0;    } -  + }      void f_not(INT32 args)   {
910:   {    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;
944:   {    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;
1016:   {    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_lt,"function(int|float,int|float:int)|function(string,string:int)",OPT_TRY_OPTIMIZE,0,generate_comparison); -  add_efun2("`<=",f_le,"function(int|float,int|float:int)|function(string,string:int)",OPT_TRY_OPTIMIZE,0,generate_comparison); -  add_efun2("`>", f_gt,"function(int|float,int|float:int)|function(string,string:int)",OPT_TRY_OPTIMIZE,0,generate_comparison); -  add_efun2("`>=",f_ge,"function(int|float,int|float:int)|function(string,string:int)",OPT_TRY_OPTIMIZE,0,generate_comparison); +  add_efun2("`!",f_not,"function(mixed:int)",OPT_TRY_OPTIMIZE,0,generate_not);    -  add_efun2("`+",f_add,"function(int...:int)|!function(int...:mixed)&function(int|float...:float)|!function(int|float...:mixed)&function(string|int|float...:string)|function(array...:array)|function(mapping...:mapping)|function(list...:list)",OPT_TRY_OPTIMIZE,optimize_binary,generate_sum); + #define CMP_TYPE "function(object,mixed:int)|function(mixed,object:int)|function(int|float,int|float:int)|function(string,string:int)" +  add_efun2("`<", f_lt,CMP_TYPE,OPT_TRY_OPTIMIZE,0,generate_comparison); +  add_efun2("`<=",f_le,CMP_TYPE,OPT_TRY_OPTIMIZE,0,generate_comparison); +  add_efun2("`>", f_gt,CMP_TYPE,OPT_TRY_OPTIMIZE,0,generate_comparison); +  add_efun2("`>=",f_ge,CMP_TYPE,OPT_TRY_OPTIMIZE,0,generate_comparison);    -  add_efun2("`-",f_minus,"function(int:int)|function(float:float)|function(array,array:array)|function(mapping,mapping:mapping)|function(list,list:list)|function(float|int,float:float)|function(float,int:float)|function(int,int:int)|function(string,string:string)",OPT_TRY_OPTIMIZE,0,generate_minus); +  add_efun2("`+",f_add,"function(object,mixed...:mixed)|function(int...:int)|!function(int...:mixed)&function(int|float...:float)|!function(int|float...:mixed)&function(string|int|float...:string)|function(array...:array)|function(mapping...:mapping)|function(list...:list)",OPT_TRY_OPTIMIZE,optimize_binary,generate_sum);    -  add_efun2("`&",f_and,"function(int...:int)|function(mapping...:mapping)|function(list...:list)|function(array...:array)",OPT_TRY_OPTIMIZE,optimize_binary,generate_and); +  add_efun2("`-",f_minus,"function(object,mixed...:mixed)|function(int:int)|function(float:float)|function(array,array:array)|function(mapping,mapping:mapping)|function(list,list:list)|function(float|int,float:float)|function(float,int:float)|function(int,int:int)|function(string,string:string)",OPT_TRY_OPTIMIZE,0,generate_minus);    -  add_efun2("`|",f_or,"function(int...:int)|function(mapping...:mapping)|function(list...:list)|function(array...:array)",OPT_TRY_OPTIMIZE,optimize_binary,generate_or); + #define LOG_TYPE "function(object,mixed...:mixed)|function(int...:int)|function(mapping...:mapping)|function(list...:list)|function(array...:array)"    -  add_efun2("`^",f_xor,"function(int...:int)|function(mapping...:mapping)|function(list...:list)|function(array...:array)",OPT_TRY_OPTIMIZE,optimize_binary,generate_xor); +  add_efun2("`&",f_and,LOG_TYPE,OPT_TRY_OPTIMIZE,optimize_binary,generate_and);    -  add_efun2("`<<",f_lsh,"function(int,int:int)",OPT_TRY_OPTIMIZE,0,generate_lsh); -  add_efun2("`>>",f_rsh,"function(int,int:int)",OPT_TRY_OPTIMIZE,0,generate_rsh); +  add_efun2("`|",f_or,LOG_TYPE,OPT_TRY_OPTIMIZE,optimize_binary,generate_or);    -  add_efun2("`*",f_multiply,"function(int...:int)|!function(int...:mixed)&function(float|int...:float)|function(string*,string:string)",OPT_TRY_OPTIMIZE,optimize_binary,generate_multiply); +  add_efun2("`^",f_xor,LOG_TYPE,OPT_TRY_OPTIMIZE,optimize_binary,generate_xor);    -  add_efun2("`/",f_divide,"function(int,int:int)|function(float|int,float:float)|function(float,int:float)|function(string,string:string*)",OPT_TRY_OPTIMIZE,0,generate_divide); +     -  add_efun2("`%",f_mod,"function(int,int:int)|!function(int,int:mixed)&function(int|float,int|float:float)",OPT_TRY_OPTIMIZE,0,generate_mod); + #define SHIFT_TYPE "function(object,mixed:mixed)|function(int,int:int)"    -  add_efun2("`!",f_not,"function(mixed:int)",OPT_TRY_OPTIMIZE,0,generate_not); -  add_efun2("`~",f_compl,"function(int:int)|function(float:float)",OPT_TRY_OPTIMIZE,0,generate_compl); +  add_efun2("`<<",f_lsh,SHIFT_TYPE,OPT_TRY_OPTIMIZE,0,generate_lsh); +  add_efun2("`>>",f_rsh,SHIFT_TYPE,OPT_TRY_OPTIMIZE,0,generate_rsh); +  +  add_efun2("`*",f_multiply,"function(object,mixed...:mixed)|function(int...:int)|!function(int...:mixed)&function(float|int...:float)|function(string*,string:string)",OPT_TRY_OPTIMIZE,optimize_binary,generate_multiply); +  +  add_efun2("`/",f_divide,"function(object,mixed:mixed)|function(int,int:int)|function(float|int,float:float)|function(float,int:float)|function(string,string:string*)",OPT_TRY_OPTIMIZE,0,generate_divide); +  +  add_efun2("`%",f_mod,"function(object,mixed:mixed)|function(int,int:int)|!function(int,int:mixed)&function(int|float,int|float:float)",OPT_TRY_OPTIMIZE,0,generate_mod); +  +  add_efun2("`~",f_compl,"function(object:mixed)|function(int:int)|function(float:float)",OPT_TRY_OPTIMIZE,0,generate_compl);   }