lib/as3/expr.c

   1 /* expr.c
   2
   3    Extension module for the rfxswf library.
   4    Part of the swftools package.
   5
   6    Copyright (c) 2009 Matthias Kramm <kramm@quiss.org>
   7
   8    This program is free software; you can redistribute it and/or modify
   9    it under the terms of the GNU General Public License as published by
  10    the Free Software Foundation; either version 2 of the License, or
  11    (at your option) any later version.
  12
  13    This program is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with this program; if not, write to the Free Software
  20    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
  21
  22 #include "expr.h"
  23 #include "common.h"
  24 #include "tokenizer.h"
  25
  26 #define IS_INT(a) (TYPE_IS_INT((a)) || TYPE_IS_UINT((a)))
  27 #define BOTH_INT(a,b) (IS_INT(a) && IS_INT(b))
  28
  29 #define READ_HEADER_LEFTRIGHT \
  30     typedcode_t left = n->child[0]->type->read(n->child[0]);\
  31     typedcode_t right = n->child[1]->type->read(n->child[1]);\
  32     code_t*c=0;\
  33     classinfo_t*t=0;
  34
  35 #define READ_HEADER_ONE \
  36     typedcode_t x = n->child[0]->type->read(n->child[0]);\
  37     code_t*c=0;\
  38     classinfo_t*t=0;
  39
  40 #define EXEC_HEADER_ONE \
  41     code_t* x = n->child[0]->type->exec(n->child[0]);\
  42     code_t*c=0;\
  43     classinfo_t*t=0;
  44
  45 #define EXEC_HEADER_LEFTRIGHT \
  46     code_t* left = n->child[0]->type->exec(n->child[0]);\
  47     code_t* right = n->child[1]->type->exec(n->child[1]);\
  48     code_t*c=0;\
  49     classinfo_t*t=0;
  50
  51 #define EVAL_HEADER_LEFTRIGHT \
  52     constant_t left = n->child[0]->type->eval(n->child[0]);\
  53     constant_t right = n->child[1]->type->eval(n->child[1]);\
  54     constant_t r; \
  55     if(left.type==CONSTANT_UNKNOWN || right.type==CONSTANT_UNKNOWN) {\
  56         r.type = CONSTANT_UNKNOWN;return r; \
  57     }
  58
  59
  60 #define RET \
  61     typedcode_t r; \
  62     r.c = c; \
  63     r.t = t; \
  64     return r;
  65
  66 static classinfo_t*join_types(classinfo_t*type1, classinfo_t*type2, nodetype_t*t)
  67 {
  68     if(t == &node_plus) {
  69         if((TYPE_IS_XMLLIST(type1) || TYPE_IS_XML(type1)) &&
  70            (TYPE_IS_XMLLIST(type2) || TYPE_IS_XML(type2)))
  71             return TYPE_OBJECT;
  72         if(BOTH_INT(type1, type2))
  73             return TYPE_INT;
  74         if(IS_NUMBER_OR_INT(type1) && IS_NUMBER_OR_INT(type2))
  75             return TYPE_NUMBER;
  76         if(TYPE_IS_DATE(type1) || TYPE_IS_DATE(type2))
  77             return TYPE_OBJECT;
  78         if(TYPE_IS_STRING(type1) || TYPE_IS_STRING(type2)) {
  79             /* depending on where the strings come from, the result type
  80                of an "add" might be an object or a string, depending on the
  81                verifier's mood. So basically we just don't know the type. */
  82             return TYPE_VOID;
  83         }
  84         if(TYPE_IS_ANY(type1) || TYPE_IS_ANY(type2))
  85             return TYPE_ANY;
  86         return TYPE_OBJECT; // e.g. array+array = object
  87     }
  88
  89     if(type1 == type2)
  90         return type1;
  91     return TYPE_ANY;
  92 }
  93 static int getlocalnr(code_t*c)
  94 {
  95     if(c->opcode == OPCODE_GETLOCAL) {return (ptroff_t)c->data[0];}
  96     else if(c->opcode == OPCODE_GETLOCAL_0) {return 0;}
  97     else if(c->opcode == OPCODE_GETLOCAL_1) {return 1;}
  98     else if(c->opcode == OPCODE_GETLOCAL_2) {return 2;}
  99     else if(c->opcode == OPCODE_GETLOCAL_3) {return 3;}
 100     else syntaxerror("Internal error: opcode %02x is not a getlocal call", c->opcode);
 101     return 0;
 102 }
 103
 104
 105 int gettempvar(); /* FIXME: we should use a function pointer here */
 106
 107
 108 static code_t* toreadwrite(code_t*in, code_t*middlepart, char justassign, char readbefore, char pushvalue)
 109 {
 110     /* converts this:
 111
 112        [prefix code] [read instruction]
 113
 114        to this:
 115
 116        [prefix code] ([dup]) [read instruction] [middlepart] [setvar] [write instruction] [getvar]
 117     */
 118     if(in && in->opcode == OPCODE_COERCE_A) {
 119         in = code_cutlast(in);
 120     }
 121     if(in->next)
 122         syntaxerror("internal error");
 123
 124     /* chop off read instruction */
 125     code_t*prefix = in;
 126     code_t*r = in;
 127     if(r->prev) {
 128         prefix = r->prev;r->prev = 0;
 129         prefix->next=0;
 130     } else {
 131         prefix = 0;
 132     }
 133
 134     char use_temp_var = readbefore;
 135
 136     /* generate the write instruction, and maybe append a dup to the prefix code */
 137     code_t* write = abc_nop(0);
 138     if(r->opcode == OPCODE_GETPROPERTY) {
 139         write->opcode = OPCODE_SETPROPERTY;
 140         multiname_t*m = (multiname_t*)r->data[0];
 141         write->data[0] = multiname_clone(m);
 142         if(m->type == QNAME || m->type == MULTINAME ||
 143            m->type == QNAMEA || m->type == MULTINAMEA) {
 144             if(!justassign) {
 145                 prefix = abc_dup(prefix); // we need the object, too
 146             }
 147             use_temp_var = 1;
 148         } else if(m->type == MULTINAMEL || m->type == MULTINAMELA ||
 149                   m->type == RTQNAME || m->type == RTQNAMEA) {
 150             if(!justassign) {
 151                 /* dupping two values on the stack requires 5 operations and one register-
 152                    couldn't adobe just have given us a dup2? */
 153                 int temp = gettempvar();
 154                 prefix = abc_setlocal(prefix, temp);
 155                 prefix = abc_dup(prefix);
 156                 prefix = abc_getlocal(prefix, temp);
 157                 prefix = abc_swap(prefix);
 158                 prefix = abc_getlocal(prefix, temp);
 159                 if(!use_temp_var);
 160                     prefix = abc_kill(prefix, temp);
 161             }
 162             use_temp_var = 1;
 163         } else {
 164             syntaxerror("illegal lvalue: can't assign a value to this expression (not a qname/multiname)");
 165         }
 166     } else if(r->opcode == OPCODE_GETSLOT) {
 167         write->opcode = OPCODE_SETSLOT;
 168         write->data[0] = r->data[0];
 169         if(!justassign) {
 170             prefix = abc_dup(prefix); // we need the object, too
 171         }
 172         use_temp_var = 1;
 173     } else if(r->opcode == OPCODE_GETLOCAL) {
 174         write->opcode = OPCODE_SETLOCAL;
 175         write->data[0] = r->data[0];
 176     } else if(r->opcode == OPCODE_GETLOCAL_0) {
 177         write->opcode = OPCODE_SETLOCAL_0;
 178     } else if(r->opcode == OPCODE_GETLOCAL_1) {
 179         write->opcode = OPCODE_SETLOCAL_1;
 180     } else if(r->opcode == OPCODE_GETLOCAL_2) {
 181         write->opcode = OPCODE_SETLOCAL_2;
 182     } else if(r->opcode == OPCODE_GETLOCAL_3) {
 183         write->opcode = OPCODE_SETLOCAL_3;
 184     } else if(r->opcode == OPCODE_GETSUPER) {
 185         write->opcode = OPCODE_SETSUPER;
 186         multiname_t*m = (multiname_t*)r->data[0];
 187         write->data[0] = multiname_clone(m);
 188     } else {
 189         code_dump(r);
 190         syntaxerror("illegal lvalue: can't assign a value to this expression");
 191     }
 192     code_t* c = 0;
 193
 194     int temp = -1;
 195     if(!justassign) {
 196         if(use_temp_var) {
 197             /* with getproperty/getslot, we have to be extra careful not
 198                to execute the read code twice, as it might have side-effects
 199                (e.g. if the property is in fact a setter/getter combination)
 200
 201                So read the value, modify it, and write it again,
 202                using prefix only once and making sure (by using a temporary
 203                register) that the return value is what we just wrote */
 204             temp = gettempvar();
 205             c = code_append(c, prefix);
 206             c = code_append(c, r);
 207             if(pushvalue && readbefore) {
 208                 c = abc_dup(c);
 209                 c = abc_setlocal(c, temp);
 210             }
 211             c = code_append(c, middlepart);
 212             if(pushvalue && !readbefore) {
 213                 c = abc_dup(c);
 214                 c = abc_setlocal(c, temp);
 215             }
 216             c = code_append(c, write);
 217             if(pushvalue) {
 218                 c = abc_getlocal(c, temp);
 219                 c = abc_kill(c, temp);
 220             }
 221         } else {
 222             /* if we're allowed to execute the read code twice *and*
 223                the middlepart doesn't modify the code, things are easier.
 224             */
 225             //c = code_append(c, prefix);
 226             if(prefix) syntaxerror("internal error (prefix)");
 227             code_t* r2 = 0;
 228             if(pushvalue) {
 229                 r2 = code_dup(r);
 230             }
 231             c = code_append(c, r);
 232             c = code_append(c, middlepart);
 233             c = code_append(c, write);
 234             if(pushvalue) {
 235                 c = code_append(c, r2);
 236             }
 237         }
 238     } else {
 239         /* even smaller version: overwrite the value without reading
 240            it out first */
 241         if(!use_temp_var) {
 242             if(prefix) {
 243                 c = code_append(c, prefix);
 244                 c = abc_dup(c);
 245             }
 246             c = code_append(c, middlepart);
 247             c = code_append(c, write);
 248             if(pushvalue) {
 249                 c = code_append(c, r);
 250             }
 251         } else {
 252             code_free(r);r=0;
 253             temp = gettempvar();
 254             if(prefix) {
 255                 c = code_append(c, prefix);
 256             }
 257             c = code_append(c, middlepart);
 258             if(pushvalue) {
 259                 c = abc_dup(c);
 260                 c = abc_setlocal(c, temp);
 261             }
 262             c = code_append(c, write);
 263             if(pushvalue) {
 264                 c = abc_getlocal(c, temp);
 265                 c = abc_kill(c, temp);
 266             }
 267         }
 268     }
 269     return c;
 270 }
 271
 272 typedcode_t push_constant(constant_t*v)
 273 {
 274     typedcode_t t;
 275     switch(v->type) {
 276         case CONSTANT_INT: t.c = abc_pushint(0, v->i);t.t = TYPE_INT;break;
 277         case CONSTANT_UINT: t.c = abc_pushuint(0, v->u);t.t = TYPE_UINT;break;
 278         case CONSTANT_FLOAT: t.c = abc_pushdouble(0, v->f);t.t = TYPE_FLOAT;break;
 279         case CONSTANT_TRUE: t.c = abc_pushtrue(0);t.t = TYPE_BOOLEAN;break;
 280         case CONSTANT_FALSE: t.c = abc_pushfalse(0);t.t = TYPE_BOOLEAN;break;
 281         case CONSTANT_STRING: t.c = abc_pushstring2(0, v->s);t.t = TYPE_STRING;break;
 282         case CONSTANT_NULL: t.c = abc_pushnull(0);t.t = TYPE_NULL;break;
 283         case CONSTANT_UNDEFINED: t.c = abc_pushundefined(0);t.t = TYPE_ANY;break;
 284         case CONSTANT_NAMESPACE:
 285         case CONSTANT_NAMESPACE_PACKAGE:
 286         case CONSTANT_NAMESPACE_PACKAGEINTERNAL:
 287         case CONSTANT_NAMESPACE_PROTECTED:
 288         case CONSTANT_NAMESPACE_EXPLICIT:
 289         case CONSTANT_NAMESPACE_STATICPROTECTED:
 290         case CONSTANT_NAMESPACE_PRIVATE:
 291             t.c = abc_pushnamespace(0, v->ns);t.t = TYPE_NAMESPACE;break;
 292         default:
 293             syntaxerror("internal error: bad constant");
 294     }
 295     return t;
 296 }
 297
 298 code_t*converttype(code_t*c, classinfo_t*from, classinfo_t*to);
 299
 300 int constant_to_int(constant_t*c)
 301 {
 302     switch(c->type) {
 303         case CONSTANT_INT:    return c->i;
 304         case CONSTANT_UINT:   return (int)c->u;
 305         case CONSTANT_FLOAT:  return c->f;
 306         case CONSTANT_TRUE:   return 1;
 307         case CONSTANT_FALSE:  return 0;
 308         case CONSTANT_STRING: return atoi(c->s->str);
 309         default: syntaxerror("can't convert this constant to an integer");
 310     }
 311 }
 312
 313 double constant_to_float(constant_t*c)
 314 {
 315     switch(c->type) {
 316         case CONSTANT_INT:    return (double)c->i;
 317         case CONSTANT_UINT:   return (double)c->u;
 318         case CONSTANT_FLOAT:  return c->f;
 319         case CONSTANT_TRUE:   return (double)1;
 320         case CONSTANT_FALSE:  return (double)0;
 321         case CONSTANT_STRING: return atof(c->s->str);
 322         default: syntaxerror("can't convert this constant to a float");
 323     }
 324 }
 325
 326 // -------------------------- x + y -----------------------------------
 327
 328 typedcode_t node_plus_write(node_t*n)
 329 {
 330     syntaxerror("can't assign to this expression");
 331 }
 332 typedcode_t node_plus_read(node_t*n)
 333 {
 334     READ_HEADER_LEFTRIGHT;
 335     c = code_append(left.c, right.c);
 336     if(BOTH_INT(left.t, right.t)) {
 337        c = abc_add_i(c);
 338        t = TYPE_INT;
 339     } else {
 340        c = abc_add(c);
 341        t = join_types(left.t,right.t,n->type);
 342     }
 343     RET;
 344 }
 345 code_t* node_plus_exec(node_t*n)
 346 {
 347     EXEC_HEADER_LEFTRIGHT;
 348     return code_append(left, right);
 349 }
 350 constant_t node_plus_eval(node_t*n)
 351 {
 352     EVAL_HEADER_LEFTRIGHT;
 353     char left_int = left.type == CONSTANT_INT || left.type == CONSTANT_UINT;
 354     if(left_int && (right.type == CONSTANT_INT || right.type == CONSTANT_UINT)) {
 355         int i = constant_to_int(&left) + constant_to_int(&right);
 356         r.type = CONSTANT_INT;
 357         r.i = i;
 358     } else if(left_int && right.type == CONSTANT_FLOAT) {
 359         double f = constant_to_int(&left) + constant_to_float(&right);
 360         r.type = CONSTANT_FLOAT;
 361         r.f = f;
 362     } else if(left.type == CONSTANT_STRING) {
 363         char*add = constant_tostring(&right);
 364         int l1 = left.s->len;
 365         int l2 = strlen(add);
 366         char*s = malloc(l1+l2+1);
 367         memcpy(s, left.s->str, l1);
 368         memcpy(s+l1, add, l2);
 369         s[l1+l2]=0;
 370         r.type = CONSTANT_STRING;
 371         r.s = malloc(sizeof(string_t));
 372         r.s->str = s;
 373         r.s->len = l1+l2;
 374         free(add);
 375     } else {
 376         r.type = CONSTANT_UNKNOWN;
 377     }
 378     return r;
 379 }
 380 nodetype_t node_plus =
 381 {
 382 name:"plus",
 383 flags:NODE_HAS_CHILDREN,
 384 eval:node_plus_eval,
 385 write:node_plus_write,
 386 read:node_plus_read,
 387 exec:node_plus_exec,
 388 };
 389
 390 // -------------------------- x - y -----------------------------------
 391
 392 typedcode_t node_minus_write(node_t*n)
 393 {
 394     syntaxerror("can't assign to this expression");
 395 }
 396 typedcode_t node_minus_read(node_t*n)
 397 {
 398     READ_HEADER_LEFTRIGHT;
 399     c = code_append(left.c, right.c);
 400     if(BOTH_INT(left.t,right.t)) {
 401        c = abc_subtract_i(c);
 402        t = TYPE_INT;
 403     } else {
 404        c = abc_subtract(c);
 405        t = TYPE_NUMBER;
 406     }
 407     RET;
 408 }
 409 code_t* node_minus_exec(node_t*n)
 410 {
 411     EXEC_HEADER_LEFTRIGHT;
 412     return code_append(left, right);
 413 }
 414 constant_t node_minus_eval(node_t*n)
 415 {
 416     constant_t r;r.type=CONSTANT_UNKNOWN;return r;
 417 }
 418 nodetype_t node_minus =
 419 {
 420 name:"minus",
 421 flags:NODE_HAS_CHILDREN,
 422 eval: node_minus_eval,
 423 write: node_minus_write,
 424 read: node_minus_read,
 425 exec: node_minus_exec
 426 };
 427
 428 // ---------------------------- ++x -----------------------------------
 429
 430 typedcode_t node_lplusplus_write(node_t*n)
 431 {
 432     syntaxerror("can't assign to this expression");
 433 }
 434 typedcode_t node_lplusplus_read(node_t*n)
 435 {
 436     READ_HEADER_ONE;
 437     t = x.t;
 438     if(is_getlocal(x.c) && (TYPE_IS_INT(x.t) || TYPE_IS_NUMBER(x.t))) {
 439         int nr = getlocalnr(x.c);
 440         code_free(x.c);x.c=0;
 441         if(TYPE_IS_INT(x.t)) {
 442            c = abc_inclocal_i(c, nr);
 443            c = abc_getlocal(c, nr);
 444         } else if(TYPE_IS_NUMBER(x.t)) {
 445            c = abc_inclocal(c, nr);
 446            c = abc_getlocal(c, nr);
 447         } else syntaxerror("internal error");
 448     } else {
 449         if(TYPE_IS_INT(x.t) || TYPE_IS_UINT(x.t)) {
 450             c = abc_increment_i(c);
 451             t = TYPE_INT;
 452         } else {
 453             c = abc_increment(c);
 454             t = TYPE_NUMBER;
 455         }
 456         c = converttype(c, t, x.t);
 457         c = toreadwrite(x.c, c, 0, 0, 1);
 458         t = x.t;
 459     }
 460     RET
 461 }
 462 code_t* node_lplusplus_exec(node_t*n)
 463 {
 464     typedcode_t x = n->child[0]->type->read(n->child[0]);
 465     code_t*c=0;
 466     if(is_getlocal(x.c) && (TYPE_IS_INT(x.t) || TYPE_IS_NUMBER(x.t))) {
 467         int nr = getlocalnr(x.c);
 468         code_free(x.c);x.c=0;
 469         if(TYPE_IS_INT(x.t)) {
 470            c = abc_inclocal_i(c, nr);
 471         } else if(TYPE_IS_NUMBER(x.t)) {
 472            c = abc_inclocal(c, nr);
 473         } else syntaxerror("internal error");
 474     } else {
 475         classinfo_t*t;
 476         if(TYPE_IS_INT(x.t) || TYPE_IS_UINT(x.t)) {
 477             c = abc_increment_i(c);
 478             t = TYPE_INT;
 479         } else {
 480             c = abc_increment(c);
 481             t = TYPE_NUMBER;
 482         }
 483         c = converttype(c, t, x.t); //convert back to original type
 484         c = toreadwrite(x.c, c, 0, 0, 0);
 485         t = x.t;
 486     }
 487     return c;
 488 }
 489 constant_t node_lplusplus_eval(node_t*n)
 490 {
 491     constant_t r;r.type=CONSTANT_UNKNOWN;return r;
 492 }
 493 nodetype_t node_lplusplus =
 494 {
 495 name: "lplusplus",
 496 flags:NODE_HAS_CHILDREN,
 497 eval: node_lplusplus_eval,
 498 write: node_lplusplus_write,
 499 read: node_lplusplus_read,
 500 exec: node_lplusplus_exec
 501 };
 502
 503
 504 // ---------------------------- --x -----------------------------------
 505
 506 typedcode_t node_lminusminus_write(node_t*n)
 507 {
 508     syntaxerror("can't assign to this expression");
 509 }
 510 typedcode_t node_lminusminus_read(node_t*n)
 511 {
 512     READ_HEADER_ONE;
 513     t = x.t;
 514     if(is_getlocal(x.c) && (TYPE_IS_INT(x.t) || TYPE_IS_NUMBER(x.t))) {
 515         int nr = getlocalnr(x.c);
 516         code_free(x.c);x.c=0;
 517         if(TYPE_IS_INT(x.t)) {
 518            c = abc_declocal_i(c, nr);
 519            c = abc_getlocal(c, nr);
 520         } else if(TYPE_IS_NUMBER(x.t)) {
 521            c = abc_declocal(c, nr);
 522            c = abc_getlocal(c, nr);
 523         } else syntaxerror("internal error");
 524     } else {
 525         if(TYPE_IS_INT(x.t) || TYPE_IS_UINT(x.t)) {
 526             c = abc_decrement_i(c);
 527             t = TYPE_INT;
 528         } else {
 529             c = abc_decrement(c);
 530             t = TYPE_NUMBER;
 531         }
 532         c = converttype(c, t, x.t);
 533         c = toreadwrite(x.c, c, 0, 0, 1);
 534         t = x.t;
 535     }
 536     RET
 537 }
 538 code_t* node_lminusminus_exec(node_t*n)
 539 {
 540     typedcode_t x = n->child[0]->type->read(n->child[0]);
 541     code_t*c=0;
 542     if(is_getlocal(x.c) && (TYPE_IS_INT(x.t) || TYPE_IS_NUMBER(x.t))) {
 543         int nr = getlocalnr(x.c);
 544         code_free(x.c);x.c=0;
 545         if(TYPE_IS_INT(x.t)) {
 546            c = abc_declocal_i(c, nr);
 547         } else if(TYPE_IS_NUMBER(x.t)) {
 548            c = abc_declocal(c, nr);
 549         } else syntaxerror("internal error");
 550     } else {
 551         classinfo_t*t;
 552         if(TYPE_IS_INT(x.t) || TYPE_IS_UINT(x.t)) {
 553             c = abc_decrement_i(c);
 554             t = TYPE_INT;
 555         } else {
 556             c = abc_decrement(c);
 557             t = TYPE_NUMBER;
 558         }
 559         c = converttype(c, t, x.t); //convert back to original type
 560         c = toreadwrite(x.c, c, 0, 0, 0);
 561         t = x.t;
 562     }
 563     return c;
 564 }
 565 constant_t node_lminusminus_eval(node_t*n)
 566 {
 567     constant_t r;r.type=CONSTANT_UNKNOWN;return r;
 568 }
 569 nodetype_t node_lminusminus =
 570 {
 571 name: "lminusminus",
 572 flags:NODE_HAS_CHILDREN,
 573 eval: node_lminusminus_eval,
 574 write: node_lminusminus_write,
 575 read: node_lminusminus_read,
 576 exec: node_lminusminus_exec
 577 };
 578
 579
 580
 581 // ---------------------------- x++ -----------------------------------
 582
 583 typedcode_t node_rplusplus_write(node_t*n)
 584 {
 585     syntaxerror("can't assign to this expression");
 586 }
 587 typedcode_t node_rplusplus_read(node_t*n)
 588 {
 589     READ_HEADER_ONE;
 590     t = x.t;
 591     if(is_getlocal(x.c) && (TYPE_IS_INT(x.t) || TYPE_IS_NUMBER(x.t))) {
 592         int nr = getlocalnr(x.c);
 593         code_free(x.c);x.c=0;
 594         if(TYPE_IS_INT(x.t)) {
 595            c = abc_getlocal(0, nr);
 596            c = abc_inclocal_i(c, nr);
 597         } else if(TYPE_IS_NUMBER(x.t)) {
 598            c = abc_getlocal(0, nr);
 599            c = abc_inclocal(c, nr);
 600         } else syntaxerror("internal error");
 601     } else {
 602         if(TYPE_IS_INT(x.t) || TYPE_IS_UINT(x.t)) {
 603             c = abc_increment_i(c);
 604             t = TYPE_INT;
 605         } else {
 606             c = abc_increment(c);
 607             t = TYPE_NUMBER;
 608         }
 609         c = converttype(c, t, x.t);
 610         c = toreadwrite(x.c, c, 0, 1, 1);
 611         t = x.t;
 612     }
 613     RET
 614 }
 615 code_t* node_rplusplus_exec(node_t*n)
 616 {
 617     typedcode_t x = n->child[0]->type->read(n->child[0]);
 618     code_t*c=0;
 619     if(is_getlocal(x.c) && (TYPE_IS_INT(x.t) || TYPE_IS_NUMBER(x.t))) {
 620         int nr = getlocalnr(x.c);
 621         code_free(x.c);x.c=0;
 622         if(TYPE_IS_INT(x.t)) {
 623            c = abc_inclocal_i(c, nr);
 624         } else if(TYPE_IS_NUMBER(x.t)) {
 625            c = abc_inclocal(c, nr);
 626         } else syntaxerror("internal error");
 627     } else {
 628         classinfo_t*t;
 629         if(TYPE_IS_INT(x.t) || TYPE_IS_UINT(x.t)) {
 630             c = abc_increment_i(c);
 631             t = TYPE_INT;
 632         } else {
 633             c = abc_increment(c);
 634             t = TYPE_NUMBER;
 635         }
 636         c = converttype(c, t, x.t); //convert back to original type
 637         c = toreadwrite(x.c, c, 0, 1, 0);
 638         t = x.t;
 639     }
 640     return c;
 641 }
 642 constant_t node_rplusplus_eval(node_t*n)
 643 {
 644     constant_t r;r.type=CONSTANT_UNKNOWN;return r;
 645 }
 646 nodetype_t node_rplusplus =
 647 {
 648 name: "rplusplus",
 649 flags:NODE_HAS_CHILDREN,
 650 eval: node_rplusplus_eval,
 651 write: node_rplusplus_write,
 652 read: node_rplusplus_read,
 653 exec: node_rplusplus_exec
 654 };
 655
 656 // ---------------------------- x-- -----------------------------------
 657
 658 typedcode_t node_rminusminus_write(node_t*n)
 659 {
 660     syntaxerror("can't assign to this expression");
 661 }
 662 typedcode_t node_rminusminus_read(node_t*n)
 663 {
 664     READ_HEADER_ONE;
 665     t = x.t;
 666     if(is_getlocal(x.c) && (TYPE_IS_INT(x.t) || TYPE_IS_NUMBER(x.t))) {
 667         int nr = getlocalnr(x.c);
 668         code_free(x.c);x.c=0;
 669         if(TYPE_IS_INT(x.t)) {
 670            c = abc_getlocal(0, nr);
 671            c = abc_declocal_i(c, nr);
 672         } else if(TYPE_IS_NUMBER(x.t)) {
 673            c = abc_getlocal(0, nr);
 674            c = abc_declocal(c, nr);
 675         } else syntaxerror("internal error");
 676     } else {
 677         if(TYPE_IS_INT(x.t) || TYPE_IS_UINT(x.t)) {
 678             c = abc_decrement_i(c);
 679             t = TYPE_INT;
 680         } else {
 681             c = abc_decrement(c);
 682             t = TYPE_NUMBER;
 683         }
 684         c = converttype(c, t, x.t);
 685         c = toreadwrite(x.c, c, 0, 1, 1);
 686         t = x.t;
 687     }
 688     RET
 689 }
 690 code_t* node_rminusminus_exec(node_t*n)
 691 {
 692     typedcode_t x = n->child[0]->type->read(n->child[0]);
 693     code_t*c=0;
 694     if(is_getlocal(x.c) && (TYPE_IS_INT(x.t) || TYPE_IS_NUMBER(x.t))) {
 695         int nr = getlocalnr(x.c);
 696         code_free(x.c);x.c=0;
 697         if(TYPE_IS_INT(x.t)) {
 698            c = abc_declocal_i(c, nr);
 699         } else if(TYPE_IS_NUMBER(x.t)) {
 700            c = abc_declocal(c, nr);
 701         } else syntaxerror("internal error");
 702     } else {
 703         classinfo_t*t;
 704         if(TYPE_IS_INT(x.t) || TYPE_IS_UINT(x.t)) {
 705             c = abc_decrement_i(c);
 706             t = TYPE_INT;
 707         } else {
 708             c = abc_decrement(c);
 709             t = TYPE_NUMBER;
 710         }
 711         c = converttype(c, t, x.t); //convert back to original type
 712         c = toreadwrite(x.c, c, 0, 1, 0);
 713         t = x.t;
 714     }
 715     return c;
 716 }
 717 constant_t node_rminusminus_eval(node_t*n)
 718 {
 719     constant_t r;r.type=CONSTANT_UNKNOWN;return r;
 720 }
 721 nodetype_t node_rminusminus =
 722 {
 723 name: "rminusminus",
 724 flags:NODE_HAS_CHILDREN,
 725 eval: node_rminusminus_eval,
 726 write: node_rminusminus_write,
 727 read: node_rminusminus_read,
 728 exec: node_rminusminus_exec
 729 };
 730
 731 // ---------------------------- x*y -----------------------------------
 732
 733 typedcode_t node_multiply_write(node_t*n)
 734 {
 735     syntaxerror("can't assign to this expression");
 736 }
 737 typedcode_t node_multiply_read(node_t*n)
 738 {
 739     READ_HEADER_LEFTRIGHT;
 740     c = code_append(left.c,right.c);
 741     if(BOTH_INT(left.t,right.t)) {
 742        c = abc_multiply_i(c);
 743        t = TYPE_INT;
 744     } else {
 745        c = abc_multiply(c);
 746        t = TYPE_NUMBER;
 747     }
 748     RET
 749 }
 750 code_t* node_multiply_exec(node_t*n)
 751 {
 752     EXEC_HEADER_LEFTRIGHT;
 753     return code_append(left, right);
 754 }
 755 constant_t node_multiply_eval(node_t*n)
 756 {
 757     constant_t r;r.type=CONSTANT_UNKNOWN;return r;
 758 }
 759 nodetype_t node_multiply =
 760 {
 761 name: "multiply",
 762 flags:NODE_HAS_CHILDREN,
 763 eval: node_multiply_eval,
 764 write: node_multiply_write,
 765 read: node_multiply_read,
 766 exec: node_multiply_exec
 767 };
 768
 769 // ---------------------------- x/y -----------------------------------
 770
 771 typedcode_t node_div_write(node_t*n)
 772 {
 773     syntaxerror("can't assign to this expression");
 774 }
 775 typedcode_t node_div_read(node_t*n)
 776 {
 777     READ_HEADER_LEFTRIGHT;
 778     c = code_append(left.c, right.c);
 779     c = abc_divide(c);
 780     t = TYPE_NUMBER;
 781     RET
 782 }
 783 code_t* node_div_exec(node_t*n)
 784 {
 785     EXEC_HEADER_LEFTRIGHT;
 786     return code_append(left, right);
 787 }
 788 constant_t node_div_eval(node_t*n)
 789 {
 790     constant_t r;r.type=CONSTANT_UNKNOWN;return r;
 791 }
 792 nodetype_t node_div =
 793 {
 794 name: "div",
 795 flags:NODE_HAS_CHILDREN,
 796 eval: node_div_eval,
 797 write: node_div_write,
 798 read: node_div_read,
 799 exec: node_div_exec
 800 };
 801
 802 // ---------------------------- x%y -----------------------------------
 803
 804 typedcode_t node_mod_write(node_t*n)
 805 {
 806     syntaxerror("can't assign to this expression");
 807 }
 808 typedcode_t node_mod_read(node_t*n)
 809 {
 810     READ_HEADER_LEFTRIGHT;
 811     c = code_append(left.c, right.c);
 812     c = abc_modulo(c);
 813     t = TYPE_NUMBER;
 814     RET
 815 }
 816 code_t* node_mod_exec(node_t*n)
 817 {
 818     EXEC_HEADER_LEFTRIGHT;
 819     return code_append(left, right);
 820 }
 821 constant_t node_mod_eval(node_t*n)
 822 {
 823     constant_t r;r.type=CONSTANT_UNKNOWN;return r;
 824 }
 825 nodetype_t node_mod =
 826 {
 827 name: "mod",
 828 flags:NODE_HAS_CHILDREN,
 829 eval: node_mod_eval,
 830 write: node_mod_write,
 831 read: node_mod_read,
 832 exec: node_mod_exec
 833 };
 834
 835 // ---------------------------- x<y -----------------------------------
 836
 837 typedcode_t node_lt_write(node_t*n)
 838 {
 839     syntaxerror("can't assign to this expression");
 840 }
 841 typedcode_t node_lt_read(node_t*n)
 842 {
 843     READ_HEADER_LEFTRIGHT;
 844     c = code_append(left.c,right.c);
 845     c = abc_lessthan(c);
 846     t = TYPE_BOOLEAN;
 847     RET;
 848 }
 849 code_t* node_lt_exec(node_t*n)
 850 {
 851     EXEC_HEADER_LEFTRIGHT;
 852     return code_append(left, right);
 853 }
 854 constant_t node_lt_eval(node_t*n)
 855 {
 856     constant_t r;r.type=CONSTANT_UNKNOWN;return r;
 857 }
 858 nodetype_t node_lt =
 859 {
 860 name: "lt",
 861 flags:NODE_HAS_CHILDREN,
 862 eval: node_lt_eval,
 863 write: node_lt_write,
 864 read: node_lt_read,
 865 exec: node_lt_exec
 866 };
 867
 868 // ---------------------------- x>y -----------------------------------
 869
 870 typedcode_t node_gt_write(node_t*n)
 871 {
 872     syntaxerror("can't assign to this expression");
 873 }
 874 typedcode_t node_gt_read(node_t*n)
 875 {
 876     READ_HEADER_LEFTRIGHT;
 877     c = code_append(left.c,right.c);
 878     c = abc_greaterthan(c);
 879     t = TYPE_BOOLEAN;
 880     RET;
 881 }
 882 code_t* node_gt_exec(node_t*n)
 883 {
 884     EXEC_HEADER_LEFTRIGHT;
 885     return code_append(left, right);
 886 }
 887 constant_t node_gt_eval(node_t*n)
 888 {
 889     constant_t r;r.type=CONSTANT_UNKNOWN;return r;
 890 }
 891 nodetype_t node_gt =
 892 {
 893 name: "gt",
 894 flags:NODE_HAS_CHILDREN,
 895 eval: node_gt_eval,
 896 write: node_gt_write,
 897 read: node_gt_read,
 898 exec: node_gt_exec
 899 };
 900
 901 // ---------------------------- x<=y ----------------------------------
 902
 903 typedcode_t node_le_write(node_t*n)
 904 {
 905     syntaxerror("can't assign to this expression");
 906 }
 907 typedcode_t node_le_read(node_t*n)
 908 {
 909     READ_HEADER_LEFTRIGHT;
 910     c = code_append(left.c,right.c);
 911     c = abc_lessequals(c);
 912     t = TYPE_BOOLEAN;
 913     RET;
 914 }
 915 code_t* node_le_exec(node_t*n)
 916 {
 917     EXEC_HEADER_LEFTRIGHT;
 918     return code_append(left, right);
 919 }
 920 constant_t node_le_eval(node_t*n)
 921 {
 922     constant_t r;r.type=CONSTANT_UNKNOWN;return r;
 923 }
 924 nodetype_t node_le = //<=
 925 {
 926 name: "le",
 927 flags:NODE_HAS_CHILDREN,
 928 eval: node_le_eval,
 929 write: node_le_write,
 930 read: node_le_read,
 931 exec: node_le_exec
 932 };
 933
 934 // ---------------------------- x>=y ----------------------------------
 935
 936 typedcode_t node_ge_write(node_t*n)
 937 {
 938     syntaxerror("can't assign to this expression");
 939 }
 940 typedcode_t node_ge_read(node_t*n)
 941 {
 942     READ_HEADER_LEFTRIGHT;
 943     c = code_append(left.c,right.c);
 944     c = abc_greaterequals(c);
 945     t = TYPE_BOOLEAN;
 946     RET;
 947 }
 948 code_t* node_ge_exec(node_t*n)
 949 {
 950     EXEC_HEADER_LEFTRIGHT;
 951     return code_append(left, right);
 952 }
 953 constant_t node_ge_eval(node_t*n)
 954 {
 955     constant_t r;r.type=CONSTANT_UNKNOWN;return r;
 956 }
 957 nodetype_t node_ge = //>=
 958 {
 959 name: "ge",
 960 flags:NODE_HAS_CHILDREN,
 961 eval: node_ge_eval,
 962 write: node_ge_write,
 963 read: node_ge_read,
 964 exec: node_ge_exec
 965 };
 966
 967 // ---------------------------- x==y ----------------------------------
 968
 969 typedcode_t node_eqeq_write(node_t*n)
 970 {
 971     syntaxerror("can't assign to this expression");
 972 }
 973 typedcode_t node_eqeq_read(node_t*n)
 974 {
 975     READ_HEADER_LEFTRIGHT;
 976     c = code_append(left.c,right.c);
 977     c = abc_equals(c);
 978     t = TYPE_BOOLEAN;
 979     RET;
 980 }
 981 code_t* node_eqeq_exec(node_t*n)
 982 {
 983     EXEC_HEADER_LEFTRIGHT;
 984     return code_append(left, right);
 985 }
 986 constant_t node_eqeq_eval(node_t*n)
 987 {
 988     constant_t r;r.type=CONSTANT_UNKNOWN;return r;
 989 }
 990 nodetype_t node_eqeq = //==
 991 {
 992 name: "eqeq",
 993 flags:NODE_HAS_CHILDREN,
 994 eval: node_eqeq_eval,
 995 write: node_eqeq_write,
 996 read: node_eqeq_read,
 997 exec: node_eqeq_exec
 998 };
 999
1000 // --------------------------- x===y ----------------------------------
1001
1002 typedcode_t node_eqeqeq_write(node_t*n)
1003 {
1004     syntaxerror("can't assign to this expression");
1005 }
1006 typedcode_t node_eqeqeq_read(node_t*n)
1007 {
1008     READ_HEADER_LEFTRIGHT;
1009     c = code_append(left.c,right.c);
1010     c = abc_strictequals(c);
1011     t = TYPE_BOOLEAN;
1012     RET;
1013 }
1014 code_t* node_eqeqeq_exec(node_t*n)
1015 {
1016     EXEC_HEADER_LEFTRIGHT;
1017     return code_append(left, right);
1018 }
1019 constant_t node_eqeqeq_eval(node_t*n)
1020 {
1021     constant_t r;r.type=CONSTANT_UNKNOWN;return r;
1022 }
1023 nodetype_t node_eqeqeq = //===
1024 {
1025 name: "eqeqeq",
1026 flags:NODE_HAS_CHILDREN,
1027 eval: node_eqeqeq_eval,
1028 write: node_eqeqeq_write,
1029 read: node_eqeqeq_read,
1030 exec: node_eqeqeq_exec
1031 };
1032
1033 // --------------------------- x!==y ----------------------------------
1034
1035 typedcode_t node_noteqeq_write(node_t*n)
1036 {
1037     syntaxerror("can't assign to this expression");
1038 }
1039 typedcode_t node_noteqeq_read(node_t*n)
1040 {
1041     READ_HEADER_LEFTRIGHT;
1042     c = code_append(left.c,right.c);
1043     c = abc_strictequals(c);
1044     c = abc_not(c);
1045     t = TYPE_BOOLEAN;
1046     RET;
1047 }
1048 code_t* node_noteqeq_exec(node_t*n)
1049 {
1050     EXEC_HEADER_LEFTRIGHT;
1051     return code_append(left, right);
1052 }
1053 constant_t node_noteqeq_eval(node_t*n)
1054 {
1055     constant_t r;r.type=CONSTANT_UNKNOWN;return r;
1056 }
1057 nodetype_t node_noteqeq = //!==
1058 {
1059 name: "noteqeq",
1060 flags:NODE_HAS_CHILDREN,
1061 eval: node_noteqeq_eval,
1062 write: node_noteqeq_write,
1063 read: node_noteqeq_read,
1064 exec: node_noteqeq_exec
1065 };
1066
1067 // --------------------------- x!=y ----------------------------------
1068
1069 typedcode_t node_noteq_write(node_t*n)
1070 {
1071     syntaxerror("can't assign to this expression");
1072 }
1073 typedcode_t node_noteq_read(node_t*n)
1074 {
1075     READ_HEADER_LEFTRIGHT;
1076     c = code_append(left.c,right.c);
1077     c = abc_equals(c);
1078     c = abc_not(c);
1079     t = TYPE_BOOLEAN;
1080     RET;
1081 }
1082 code_t* node_noteq_exec(node_t*n)
1083 {
1084     EXEC_HEADER_LEFTRIGHT;
1085     return code_append(left, right);
1086 }
1087 constant_t node_noteq_eval(node_t*n)
1088 {
1089     constant_t r;r.type=CONSTANT_UNKNOWN;return r;
1090 }
1091 nodetype_t node_noteq = //!=
1092 {
1093 name: "noteq",
1094 flags:NODE_HAS_CHILDREN,
1095 eval: node_noteq_eval,
1096 write: node_noteq_write,
1097 read: node_noteq_read,
1098 exec: node_noteq_exec
1099 };
1100
1101 // --------------------------- x||y ----------------------------------
1102
1103 typedcode_t node_oror_write(node_t*n)
1104 {
1105     syntaxerror("can't assign to this expression");
1106 }
1107 typedcode_t node_oror_read(node_t*n)
1108 {
1109     READ_HEADER_LEFTRIGHT;
1110     t = join_types(left.t, right.t, n->type);
1111     c = left.c;
1112     c = converttype(c, left.t, t);
1113     c = abc_dup(c);
1114     code_t*jmp = c = abc_iftrue(c, 0);
1115     c = cut_last_push(c);
1116     c = code_append(c, right.c);
1117     c = converttype(c, right.t, t);
1118     code_t*label = c = abc_label(c);
1119     jmp->branch = label;
1120     RET;
1121 }
1122 code_t* node_oror_exec(node_t*n)
1123 {
1124     typedcode_t left = n->child[0]->type->read(n->child[0]);
1125     code_t* right = n->child[1]->type->exec(n->child[1]);
1126     code_t*c = left.c;
1127     code_t*jmp = c = abc_iftrue(c, 0);
1128     c = code_append(c, right);
1129     code_t*label = c = abc_label(c);
1130     jmp->branch = label;
1131     return c;
1132 }
1133 constant_t node_oror_eval(node_t*n)
1134 {
1135     constant_t r;r.type=CONSTANT_UNKNOWN;return r;
1136 }
1137 nodetype_t node_oror = //||
1138 {
1139 name: "oror",
1140 flags:NODE_HAS_CHILDREN,
1141 eval: node_oror_eval,
1142 write: node_oror_write,
1143 read: node_oror_read,
1144 exec: node_oror_exec
1145 };
1146
1147 // --------------------------- x&&y ----------------------------------
1148
1149 typedcode_t node_andand_write(node_t*n)
1150 {
1151     syntaxerror("can't assign to this expression");
1152 }
1153 typedcode_t node_andand_read(node_t*n)
1154 {
1155     READ_HEADER_LEFTRIGHT;
1156     t = join_types(left.t, right.t, &node_andand);
1157     c = left.c;
1158     c = converttype(c, left.t, t);
1159     c = abc_dup(c);
1160     code_t*jmp = c = abc_iffalse(c, 0);
1161     c = cut_last_push(c);
1162     c = code_append(c,right.c);
1163     c = converttype(c, right.t, t);
1164     code_t*label = c = abc_label(c);
1165     jmp->branch = label;
1166     RET;
1167 }
1168 code_t* node_andand_exec(node_t*n)
1169 {
1170     typedcode_t left = n->child[0]->type->read(n->child[0]);\
1171     code_t* right = n->child[1]->type->exec(n->child[1]);\
1172     code_t*c = left.c;
1173     code_t*jmp = c = abc_iffalse(c, 0);
1174     c = code_append(c, right);
1175     code_t*label = c = abc_label(c);
1176     jmp->branch = label;
1177     return c;
1178 }
1179 constant_t node_andand_eval(node_t*n)
1180 {
1181     constant_t r;r.type=CONSTANT_UNKNOWN;return r;
1182 }
1183 nodetype_t node_andand = //&&
1184 {
1185 name: "andand",
1186 flags:NODE_HAS_CHILDREN,
1187 eval: node_andand_eval,
1188 write: node_andand_write,
1189 read: node_andand_read,
1190 exec: node_andand_exec
1191 };
1192
1193 // ----------------------------- !x -----------------------------------
1194
1195 typedcode_t node_not_write(node_t*n)
1196 {
1197     syntaxerror("can't assign to this expression");
1198 }
1199 typedcode_t node_not_read(node_t*n)
1200 {
1201     READ_HEADER_ONE;
1202     c = x.c;
1203     c = abc_not(c);
1204     t = TYPE_BOOLEAN;
1205     RET;
1206 }
1207 code_t* node_not_exec(node_t*n)
1208 {
1209     EXEC_HEADER_ONE;
1210     return x;
1211 }
1212 constant_t node_not_eval(node_t*n)
1213 {
1214     constant_t r;r.type=CONSTANT_UNKNOWN;return r;
1215 }
1216 nodetype_t node_not =
1217 {
1218 name: "not",
1219 flags:NODE_HAS_CHILDREN,
1220 eval: node_not_eval,
1221 write: node_not_write,
1222 read: node_not_read,
1223 exec: node_not_exec
1224 };
1225
1226 // ----------------------------- ~x -----------------------------------
1227
1228 typedcode_t node_bitnot_write(node_t*n)
1229 {
1230     syntaxerror("can't assign to this expression");
1231 }
1232 typedcode_t node_bitnot_read(node_t*n)
1233 {
1234     READ_HEADER_ONE;
1235     c = x.c;
1236     c = abc_bitnot(c);
1237     t = TYPE_INT;
1238     RET;
1239 }
1240 code_t* node_bitnot_exec(node_t*n)
1241 {
1242     EXEC_HEADER_ONE;
1243     return x;
1244 }
1245 constant_t node_bitnot_eval(node_t*n)
1246 {
1247     constant_t r;r.type=CONSTANT_UNKNOWN;return r;
1248 }
1249 nodetype_t node_bitnot =
1250 {
1251 name: "bitnot",
1252 flags:NODE_HAS_CHILDREN,
1253 eval: node_bitnot_eval,
1254 write: node_bitnot_write,
1255 read: node_bitnot_read,
1256 exec: node_bitnot_exec
1257 };
1258
1259 // ----------------------------- x&y -----------------------------------
1260
1261 typedcode_t node_bitand_write(node_t*n)
1262 {
1263     syntaxerror("can't assign to this expression");
1264 }
1265 typedcode_t node_bitand_read(node_t*n)
1266 {
1267     READ_HEADER_LEFTRIGHT;
1268     c = code_append(left.c,right.c);
1269     c = abc_bitand(c);
1270     t = TYPE_INT;
1271     RET;
1272 }
1273 code_t* node_bitand_exec(node_t*n)
1274 {
1275     EXEC_HEADER_LEFTRIGHT;
1276     return code_append(left, right);
1277 }
1278 constant_t node_bitand_eval(node_t*n)
1279 {
1280     constant_t r;r.type=CONSTANT_UNKNOWN;return r;
1281 }
1282 nodetype_t node_bitand =
1283 {
1284 name: "bitand",
1285 flags:NODE_HAS_CHILDREN,
1286 eval: node_bitand_eval,
1287 write: node_bitand_write,
1288 read: node_bitand_read,
1289 exec: node_bitand_exec
1290 };
1291
1292 // ----------------------------- x^y -----------------------------------
1293
1294 typedcode_t node_bitxor_write(node_t*n)
1295 {
1296     syntaxerror("can't assign to this expression");
1297 }
1298 typedcode_t node_bitxor_read(node_t*n)
1299 {
1300     READ_HEADER_LEFTRIGHT;
1301     c = code_append(left.c,right.c);
1302     c = abc_bitxor(c);
1303     t = TYPE_INT;
1304     RET;
1305 }
1306 code_t* node_bitxor_exec(node_t*n)
1307 {
1308     EXEC_HEADER_LEFTRIGHT;
1309     return code_append(left, right);
1310 }
1311 constant_t node_bitxor_eval(node_t*n)
1312 {
1313     constant_t r;r.type=CONSTANT_UNKNOWN;return r;
1314 }
1315 nodetype_t node_bitxor =
1316 {
1317 name: "bitxor",
1318 flags:NODE_HAS_CHILDREN,
1319 eval: node_bitxor_eval,
1320 write: node_bitxor_write,
1321 read: node_bitxor_read,
1322 exec: node_bitxor_exec
1323 };
1324
1325 // ----------------------------- x|y -----------------------------------
1326
1327 typedcode_t node_bitor_write(node_t*n)
1328 {
1329     syntaxerror("can't assign to this expression");
1330 }
1331 typedcode_t node_bitor_read(node_t*n)
1332 {
1333     READ_HEADER_LEFTRIGHT;
1334     c = code_append(left.c,right.c);
1335     c = abc_bitor(c);
1336     t = TYPE_INT;
1337     RET;
1338 }
1339 code_t* node_bitor_exec(node_t*n)
1340 {
1341     EXEC_HEADER_LEFTRIGHT;
1342     return code_append(left, right);
1343 }
1344 constant_t node_bitor_eval(node_t*n)
1345 {
1346     constant_t r;r.type=CONSTANT_UNKNOWN;return r;
1347 }
1348 nodetype_t node_bitor =
1349 {
1350 name: "bitor",
1351 flags:NODE_HAS_CHILDREN,
1352 eval: node_bitor_eval,
1353 write: node_bitor_write,
1354 read: node_bitor_read,
1355 exec: node_bitor_exec
1356 };
1357
1358 // ---------------------------- x>>y -----------------------------------
1359
1360 typedcode_t node_shr_write(node_t*n)
1361 {
1362     syntaxerror("can't assign to this expression");
1363 }
1364 typedcode_t node_shr_read(node_t*n)
1365 {
1366     READ_HEADER_LEFTRIGHT;
1367     c = code_append(left.c,right.c);
1368     c = abc_rshift(c);
1369     t = TYPE_INT;
1370     RET;
1371 }
1372 code_t* node_shr_exec(node_t*n)
1373 {
1374     EXEC_HEADER_LEFTRIGHT;
1375     return code_append(left, right);
1376 }
1377 constant_t node_shr_eval(node_t*n)
1378 {
1379     constant_t r;r.type=CONSTANT_UNKNOWN;return r;
1380 }
1381 nodetype_t node_shr = //>>
1382 {
1383 name: "shr",
1384 flags:NODE_HAS_CHILDREN,
1385 eval: node_shr_eval,
1386 write: node_shr_write,
1387 read: node_shr_read,
1388 exec: node_shr_exec
1389 };
1390
1391 // ---------------------------- x<<y -----------------------------------
1392
1393 typedcode_t node_shl_write(node_t*n)
1394 {
1395     syntaxerror("can't assign to this expression");
1396 }
1397 typedcode_t node_shl_read(node_t*n)
1398 {
1399     READ_HEADER_LEFTRIGHT;
1400     c = code_append(left.c,right.c);
1401     c = abc_lshift(c);
1402     t = TYPE_INT;
1403     RET;
1404 }
1405 code_t* node_shl_exec(node_t*n)
1406 {
1407     EXEC_HEADER_LEFTRIGHT;
1408     return code_append(left, right);
1409 }
1410 constant_t node_shl_eval(node_t*n)
1411 {
1412     constant_t r;r.type=CONSTANT_UNKNOWN;return r;
1413 }
1414 nodetype_t node_shl = //<<
1415 {
1416 name: "shl",
1417 flags:NODE_HAS_CHILDREN,
1418 eval: node_shl_eval,
1419 write: node_shl_write,
1420 read: node_shl_read,
1421 exec: node_shl_exec
1422 };
1423
1424 // ---------------------------- x>>>y -----------------------------------
1425
1426 typedcode_t node_ushr_write(node_t*n)
1427 {
1428     syntaxerror("can't assign to this expression");
1429 }
1430 typedcode_t node_ushr_read(node_t*n)
1431 {
1432     READ_HEADER_LEFTRIGHT;
1433     c = code_append(left.c,right.c);
1434     c = abc_urshift(c);
1435     t = TYPE_INT;
1436     RET;
1437 }
1438 code_t* node_ushr_exec(node_t*n)
1439 {
1440     EXEC_HEADER_LEFTRIGHT;
1441     return code_append(left, right);
1442 }
1443 constant_t node_ushr_eval(node_t*n)
1444 {
1445     constant_t r;r.type=CONSTANT_UNKNOWN;return r;
1446 }
1447 nodetype_t node_ushr = //>>>
1448 {
1449 name: "ushr",
1450 flags:NODE_HAS_CHILDREN,
1451 eval: node_ushr_eval,
1452 write: node_ushr_write,
1453 read: node_ushr_read,
1454 exec: node_ushr_exec
1455 };
1456
1457 // ---------------------------- x in y ----------------------------------
1458
1459 typedcode_t node_in_write(node_t*n)
1460 {
1461     syntaxerror("can't assign to this expression");
1462 }
1463 typedcode_t node_in_read(node_t*n)
1464 {
1465     READ_HEADER_LEFTRIGHT;
1466     c = code_append(left.c,right.c);
1467     c = abc_in(c);
1468     t = TYPE_BOOLEAN;
1469     RET;
1470 }
1471 code_t* node_in_exec(node_t*n)
1472 {
1473     EXEC_HEADER_LEFTRIGHT;
1474     return code_append(left, right);
1475 }
1476 constant_t node_in_eval(node_t*n)
1477 {
1478     constant_t r;r.type=CONSTANT_UNKNOWN;return r;
1479 }
1480 nodetype_t node_in = //in
1481 {
1482 name: "in",
1483 flags:NODE_HAS_CHILDREN,
1484 eval: node_in_eval,
1485 write: node_in_write,
1486 read: node_in_read,
1487 exec: node_in_exec
1488 };
1489
1490 // ---------------------------- x as y ----------------------------------
1491
1492 typedcode_t node_as_write(node_t*n)
1493 {
1494     /* ? */
1495     syntaxerror("can't assign to this expression");
1496 }
1497 typedcode_t node_as_read(node_t*n)
1498 {
1499     READ_HEADER_LEFTRIGHT;
1500     c = code_append(left.c, right.c);
1501     c = abc_astypelate(c);
1502     if(TYPE_IS_CLASS(right.t) && right.t->data) {
1503         t = (classinfo_t*)right.t->data;
1504     } else {
1505         t = TYPE_ANY;
1506     }
1507     RET;
1508 }
1509 code_t* node_as_exec(node_t*n)
1510 {
1511     /* we assume here that "as" doesn't have side-effects (like
1512        early run time type checking) */
1513     EXEC_HEADER_LEFTRIGHT;
1514     return code_append(left, right);
1515 }
1516 constant_t node_as_eval(node_t*n)
1517 {
1518     constant_t r;r.type=CONSTANT_UNKNOWN;return r;
1519 }
1520 nodetype_t node_as = //as
1521 {
1522 name: "as",
1523 flags:NODE_HAS_CHILDREN,
1524 eval: node_as_eval,
1525 write: node_as_write,
1526 read: node_as_read,
1527 exec: node_as_exec
1528 };
1529
1530 // ------------------------- x instanceof y -----------------------------
1531
1532 typedcode_t node_instanceof_write(node_t*n)
1533 {
1534     syntaxerror("can't assign to this expression");
1535 }
1536 typedcode_t node_instanceof_read(node_t*n)
1537 {
1538     READ_HEADER_LEFTRIGHT;
1539     c = code_append(left.c, right.c);
1540     c = abc_instanceof(c);
1541     t = TYPE_BOOLEAN;
1542     RET;
1543 }
1544 code_t* node_instanceof_exec(node_t*n)
1545 {
1546     EXEC_HEADER_LEFTRIGHT;
1547     return code_append(left, right);
1548 }
1549 constant_t node_instanceof_eval(node_t*n)
1550 {
1551     constant_t r;r.type=CONSTANT_UNKNOWN;return r;
1552 }
1553 nodetype_t node_instanceof = //instanceof
1554 {
1555 name: "instanceof",
1556 flags:NODE_HAS_CHILDREN,
1557 eval: node_instanceof_eval,
1558 write: node_instanceof_write,
1559 read: node_instanceof_read,
1560 exec: node_instanceof_exec
1561 };
1562
1563 // ------------------------- x is y --------------------------------------
1564
1565 typedcode_t node_is_write(node_t*n)
1566 {
1567     syntaxerror("can't assign to this expression");
1568 }
1569 typedcode_t node_is_read(node_t*n)
1570 {
1571     READ_HEADER_LEFTRIGHT;
1572     c = code_append(left.c, right.c);
1573     c = abc_istypelate(c);
1574     t = TYPE_BOOLEAN;
1575     RET;
1576 }
1577 code_t* node_is_exec(node_t*n)
1578 {
1579     EXEC_HEADER_LEFTRIGHT;
1580     return code_append(left, right);
1581 }
1582 constant_t node_is_eval(node_t*n)
1583 {
1584     constant_t r;r.type=CONSTANT_UNKNOWN;return r;
1585 }
1586 nodetype_t node_is = //is
1587 {
1588 name: "is",
1589 flags:NODE_HAS_CHILDREN,
1590 eval: node_is_eval,
1591 write: node_is_write,
1592 read: node_is_read,
1593 exec: node_is_exec
1594 };
1595
1596 // ------------------------- x[y] --------------------------------------
1597
1598 typedcode_t node_arraylookup_write(node_t*n)
1599 {
1600     syntaxerror("not implemented yet");
1601 }
1602 typedcode_t node_arraylookup_read(node_t*n)
1603 {
1604     READ_HEADER_LEFTRIGHT;
1605     c = code_append(left.c, right.c);
1606
1607     /* XXX not sure whether this access logic is correct */
1608     namespace_t ns = {left.t?left.t->access:ACCESS_PACKAGE, ""};
1609     namespace_set_t nsset;
1610     namespace_list_t l;l.next = 0;
1611     nsset.namespaces = &l;
1612     l.namespace = &ns;
1613     multiname_t m = {MULTINAMEL, 0, &nsset, 0};
1614
1615     c = abc_getproperty2(c, &m);
1616     t = 0; // array elements have unknown type
1617     RET;
1618 }
1619 code_t* node_arraylookup_exec(node_t*n)
1620 {
1621     EXEC_HEADER_LEFTRIGHT;
1622     return code_append(left, right);
1623 }
1624 constant_t node_arraylookup_eval(node_t*n)
1625 {
1626     constant_t r;r.type=CONSTANT_UNKNOWN;return r;
1627 }
1628 nodetype_t node_arraylookup =
1629 {
1630 name: "arraylookup",
1631 flags:NODE_HAS_CHILDREN,
1632 eval: node_arraylookup_eval,
1633 write: node_arraylookup_write,
1634 read: node_arraylookup_read,
1635 exec: node_arraylookup_exec
1636 };
1637
1638 // ------------------------- typeof(x) ------------------------------------
1639
1640 typedcode_t node_typeof_write(node_t*n)
1641 {
1642     syntaxerror("can't assign to this expression");
1643 }
1644 typedcode_t node_typeof_read(node_t*n)
1645 {
1646     READ_HEADER_ONE;
1647     c = x.c;
1648     c = abc_typeof(c);
1649     t = TYPE_BOOLEAN;
1650     RET;
1651 }
1652 code_t* node_typeof_exec(node_t*n)
1653 {
1654     EXEC_HEADER_ONE;
1655     return x;
1656 }
1657 constant_t node_typeof_eval(node_t*n)
1658 {
1659     constant_t r;r.type=CONSTANT_UNKNOWN;return r;
1660 }
1661 nodetype_t node_typeof = //typeof
1662 {
1663 name: "typeof",
1664 flags:NODE_HAS_CHILDREN,
1665 eval: node_typeof_eval,
1666 write: node_typeof_write,
1667 read: node_typeof_read,
1668 exec: node_typeof_exec
1669 };
1670
1671 // ------------------------- (void)(x) ------------------------------------
1672
1673 typedcode_t node_void_write(node_t*n)
1674 {
1675     syntaxerror("can't assign to this expression");
1676 }
1677 typedcode_t node_void_read(node_t*n)
1678 {
1679     code_t*c = n->type->exec(n);
1680     c = abc_pushundefined(c);
1681     classinfo_t*t = TYPE_ANY;
1682     RET;
1683 }
1684 code_t* node_void_exec(node_t*n)
1685 {
1686     EXEC_HEADER_ONE;
1687     return x;
1688 }
1689 constant_t node_void_eval(node_t*n)
1690 {
1691     constant_t r;r.type=CONSTANT_UNKNOWN;return r;
1692 }
1693 nodetype_t node_void = //void
1694 {
1695 name: "void",
1696 flags:NODE_HAS_CHILDREN,
1697 eval: node_void_eval,
1698 write: node_void_write,
1699 read: node_void_read,
1700 exec: node_void_exec
1701 };
1702
1703 // ---------------------------- -x ----------------------------------------
1704
1705 typedcode_t node_neg_write(node_t*n)
1706 {
1707     syntaxerror("can't assign to this expression");
1708 }
1709 typedcode_t node_neg_read(node_t*n)
1710 {
1711     READ_HEADER_ONE;
1712     c = x.c;
1713     if(IS_INT(x.t)) {
1714        c = abc_negate_i(c);
1715        t = TYPE_INT;
1716     } else {
1717        c = abc_negate(c);
1718        t = TYPE_NUMBER;
1719     }
1720     RET;
1721 }
1722 code_t* node_neg_exec(node_t*n)
1723 {
1724     EXEC_HEADER_ONE;
1725     return x;
1726 }
1727 constant_t node_neg_eval(node_t*n)
1728 {
1729     constant_t r;r.type=CONSTANT_UNKNOWN;return r;
1730 }
1731 nodetype_t node_neg = //-
1732 {
1733 name: "neg",
1734 flags:NODE_HAS_CHILDREN,
1735 eval: node_neg_eval,
1736 write: node_neg_write,
1737 read: node_neg_read,
1738 exec: node_neg_exec
1739 };
1740
1741 // ---------------------------- x*=y ----------------------------------------
1742
1743 typedcode_t node_muleq_write(node_t*n)
1744 {
1745     syntaxerror("can't assign to this expression");
1746 }
1747 typedcode_t node_muleq_read(node_t*n)
1748 {
1749     READ_HEADER_LEFTRIGHT;
1750     c = right.c;
1751     classinfo_t*f = 0;
1752     if(BOTH_INT(left.t,right.t)) {
1753        c=abc_multiply_i(c);
1754        f = TYPE_INT;
1755     } else {
1756        c=abc_multiply(c);
1757        f = TYPE_NUMBER;
1758     }
1759     c=converttype(c, f, left.t);
1760     c = toreadwrite(left.c, c, 0, 0, 1);
1761     t = left.t;
1762     RET;
1763 }
1764 code_t* node_muleq_exec(node_t*n)
1765 {
1766     READ_HEADER_LEFTRIGHT;
1767     c = right.c;
1768     classinfo_t*f = 0;
1769     if(BOTH_INT(left.t,right.t)) {
1770         c=abc_multiply_i(c);
1771         f = TYPE_INT;
1772     } else {
1773         c=abc_multiply(c);
1774         f = TYPE_NUMBER;
1775     }
1776     c = converttype(c, f, left.t);
1777     return toreadwrite(left.c, c, 0, 0, 0);
1778 }
1779 constant_t node_muleq_eval(node_t*n)
1780 {
1781     constant_t r;r.type=CONSTANT_UNKNOWN;return r;
1782 }
1783 nodetype_t node_muleq =
1784 {
1785 name: "muleq",
1786 flags:NODE_HAS_CHILDREN,
1787 eval: node_muleq_eval,
1788 write: node_muleq_write,
1789 read: node_muleq_read,
1790 exec: node_muleq_exec
1791 };
1792
1793 // ---------------------------- x%=y ----------------------------------------
1794
1795 typedcode_t node_modeq_write(node_t*n)
1796 {
1797     syntaxerror("can't assign to this expression");
1798 }
1799 typedcode_t node_modeq_read(node_t*n)
1800 {
1801     READ_HEADER_LEFTRIGHT;
1802     c = abc_modulo(right.c);
1803     c = converttype(c, TYPE_NUMBER, left.t);
1804     c = toreadwrite(left.c, c, 0, 0, 1);
1805     t = left.t;
1806     RET;
1807 }
1808 code_t* node_modeq_exec(node_t*n)
1809 {
1810     READ_HEADER_LEFTRIGHT;
1811     c = abc_modulo(right.c);
1812     c = converttype(c, TYPE_NUMBER, left.t);
1813     return toreadwrite(left.c, c, 0, 0, 0);
1814 }
1815 constant_t node_modeq_eval(node_t*n)
1816 {
1817     constant_t r;r.type=CONSTANT_UNKNOWN;return r;
1818 }
1819 nodetype_t node_modeq = //%=
1820 {
1821 name: "modeq",
1822 flags:NODE_HAS_CHILDREN,
1823 eval: node_modeq_eval,
1824 write: node_modeq_write,
1825 read: node_modeq_read,
1826 exec: node_modeq_exec
1827 };
1828
1829 // ---------------------------- x<<=y ----------------------------------------
1830
1831 typedcode_t node_shleq_write(node_t*n)
1832 {
1833     syntaxerror("can't assign to this expression");
1834 }
1835 typedcode_t node_shleq_read(node_t*n)
1836 {
1837     READ_HEADER_LEFTRIGHT;
1838     c = abc_lshift(right.c);
1839     c = converttype(c, TYPE_INT, left.t);
1840     c = toreadwrite(left.c, c, 0, 0, 1);
1841     t = left.t;
1842     RET;
1843 }
1844 code_t* node_shleq_exec(node_t*n)
1845 {
1846     READ_HEADER_LEFTRIGHT;
1847     c = abc_lshift(right.c);
1848     c = converttype(c, TYPE_INT, left.t);
1849     return toreadwrite(left.c, c, 0, 0, 0);
1850 }
1851 constant_t node_shleq_eval(node_t*n)
1852 {
1853     constant_t r;r.type=CONSTANT_UNKNOWN;return r;
1854 }
1855 nodetype_t node_shleq = //<<=
1856 {
1857 name: "shleq",
1858 flags:NODE_HAS_CHILDREN,
1859 eval: node_shleq_eval,
1860 write: node_shleq_write,
1861 read: node_shleq_read,
1862 exec: node_shleq_exec
1863 };
1864
1865 // ---------------------------- x>>=y ----------------------------------------
1866
1867 typedcode_t node_shreq_write(node_t*n)
1868 {
1869     syntaxerror("can't assign to this expression");
1870 }
1871 typedcode_t node_shreq_read(node_t*n)
1872 {
1873     READ_HEADER_LEFTRIGHT;
1874     c = abc_rshift(right.c);
1875     c = converttype(c, TYPE_INT, left.t);
1876     c = toreadwrite(left.c, c, 0, 0, 1);
1877     t = left.t;
1878     RET;
1879 }
1880 code_t* node_shreq_exec(node_t*n)
1881 {
1882     READ_HEADER_LEFTRIGHT;
1883     c = abc_rshift(right.c);
1884     c = converttype(c, TYPE_INT, left.t);
1885     return toreadwrite(left.c, c, 0, 0, 0);
1886 }
1887 constant_t node_shreq_eval(node_t*n)
1888 {
1889     constant_t r;r.type=CONSTANT_UNKNOWN;return r;
1890 }
1891 nodetype_t node_shreq = //>>=
1892 {
1893 name: "shreq",
1894 flags:NODE_HAS_CHILDREN,
1895 eval: node_shreq_eval,
1896 write: node_shreq_write,
1897 read: node_shreq_read,
1898 exec: node_shreq_exec
1899 };
1900
1901 // --------------------------- x>>>=y ----------------------------------------
1902
1903 typedcode_t node_ushreq_write(node_t*n)
1904 {
1905     syntaxerror("can't assign to this expression");
1906 }
1907 typedcode_t node_ushreq_read(node_t*n)
1908 {
1909     READ_HEADER_LEFTRIGHT;
1910     c = abc_urshift(right.c);
1911     c = converttype(c, TYPE_UINT, left.t);
1912     c = toreadwrite(left.c, c, 0, 0, 1);
1913     t = left.t;
1914     RET;
1915 }
1916 code_t* node_ushreq_exec(node_t*n)
1917 {
1918     READ_HEADER_LEFTRIGHT;
1919     c = abc_urshift(right.c);
1920     c = converttype(c, TYPE_UINT, left.t);
1921     return toreadwrite(left.c, c, 0, 0, 0);
1922 }
1923 constant_t node_ushreq_eval(node_t*n)
1924 {
1925     constant_t r;r.type=CONSTANT_UNKNOWN;return r;
1926 }
1927 nodetype_t node_ushreq = //>>>=
1928 {
1929 name: "ushreq",
1930 flags:NODE_HAS_CHILDREN,
1931 eval: node_ushreq_eval,
1932 write: node_ushreq_write,
1933 read: node_ushreq_read,
1934 exec: node_ushreq_exec
1935 };
1936
1937 // --------------------------- x/=y ----------------------------------------
1938
1939 typedcode_t node_diveq_write(node_t*n)
1940 {
1941     syntaxerror("can't assign to this expression");
1942 }
1943 typedcode_t node_diveq_read(node_t*n)
1944 {
1945     READ_HEADER_LEFTRIGHT;
1946     c = abc_divide(right.c);
1947     c = converttype(c, TYPE_NUMBER, left.t);
1948     c = toreadwrite(left.c, c, 0, 0, 1);
1949     t = left.t;
1950     RET;
1951 }
1952 code_t* node_diveq_exec(node_t*n)
1953 {
1954     READ_HEADER_LEFTRIGHT;
1955     c = abc_divide(right.c);
1956     c = converttype(c, TYPE_NUMBER, left.t);
1957     return toreadwrite(left.c, c, 0, 0, 0);
1958 }
1959 constant_t node_diveq_eval(node_t*n)
1960 {
1961     constant_t r;r.type=CONSTANT_UNKNOWN;return r;
1962 }
1963 nodetype_t node_diveq =
1964 {
1965 name: "diveq",
1966 flags:NODE_HAS_CHILDREN,
1967 eval: node_diveq_eval,
1968 write: node_diveq_write,
1969 read: node_diveq_read,
1970 exec: node_diveq_exec
1971 };
1972
1973 // --------------------------- x|=y ----------------------------------------
1974
1975 typedcode_t node_bitoreq_write(node_t*n)
1976 {
1977     syntaxerror("can't assign to this expression");
1978 }
1979 typedcode_t node_bitoreq_read(node_t*n)
1980 {
1981     READ_HEADER_LEFTRIGHT;
1982     c = abc_bitor(right.c);
1983     c = converttype(c, TYPE_INT, left.t);
1984     c = toreadwrite(left.c, c, 0, 0, 1);
1985     t = left.t;
1986     RET;
1987 }
1988 code_t* node_bitoreq_exec(node_t*n)
1989 {
1990     READ_HEADER_LEFTRIGHT;
1991     c = abc_bitor(right.c);
1992     c = converttype(c, TYPE_INT, left.t);
1993     return toreadwrite(left.c, c, 0, 0, 0);
1994 }
1995 constant_t node_bitoreq_eval(node_t*n)
1996 {
1997     constant_t r;r.type=CONSTANT_UNKNOWN;return r;
1998 }
1999 nodetype_t node_bitoreq = //|=
2000 {
2001 name: "bitoreq",
2002 flags:NODE_HAS_CHILDREN,
2003 eval: node_bitoreq_eval,
2004 write: node_bitoreq_write,
2005 read: node_bitoreq_read,
2006 exec: node_bitoreq_exec
2007 };
2008
2009 // --------------------------- x^=y ----------------------------------------
2010
2011 typedcode_t node_bitxoreq_write(node_t*n)
2012 {
2013     syntaxerror("can't assign to this expression");
2014 }
2015 typedcode_t node_bitxoreq_read(node_t*n)
2016 {
2017     READ_HEADER_LEFTRIGHT;
2018     c = abc_bitxor(right.c);
2019     c = converttype(c, TYPE_INT, left.t);
2020     c = toreadwrite(left.c, c, 0, 0, 1);
2021     t = left.t;
2022     RET;
2023 }
2024 code_t* node_bitxoreq_exec(node_t*n)
2025 {
2026     READ_HEADER_LEFTRIGHT;
2027     c = abc_bitxor(right.c);
2028     c = converttype(c, TYPE_INT, left.t);
2029     return toreadwrite(left.c, c, 0, 0, 0);
2030 }
2031 constant_t node_bitxoreq_eval(node_t*n)
2032 {
2033     constant_t r;r.type=CONSTANT_UNKNOWN;return r;
2034 }
2035 nodetype_t node_bitxoreq = //^=
2036 {
2037 name: "bitxoreq",
2038 flags:NODE_HAS_CHILDREN,
2039 eval: node_bitxoreq_eval,
2040 write: node_bitxoreq_write,
2041 read: node_bitxoreq_read,
2042 exec: node_bitxoreq_exec
2043 };
2044
2045 // --------------------------- x&=y ----------------------------------------
2046
2047 typedcode_t node_bitandeq_write(node_t*n)
2048 {
2049     syntaxerror("can't assign to this expression");
2050 }
2051 typedcode_t node_bitandeq_read(node_t*n)
2052 {
2053     READ_HEADER_LEFTRIGHT;
2054     c = abc_bitand(right.c);
2055     c = converttype(c, TYPE_INT, left.t);
2056     c = toreadwrite(left.c, c, 0, 0, 1);
2057     t = left.t;
2058     RET;
2059 }
2060 code_t* node_bitandeq_exec(node_t*n)
2061 {
2062     READ_HEADER_LEFTRIGHT;
2063     c = abc_bitand(right.c);
2064     c = converttype(c, TYPE_INT, left.t);
2065     return toreadwrite(left.c, c, 0, 0, 0);
2066 }
2067 constant_t node_bitandeq_eval(node_t*n)
2068 {
2069     constant_t r;r.type=CONSTANT_UNKNOWN;return r;
2070 }
2071 nodetype_t node_bitandeq = //^=
2072 {
2073 name: "bitandeq",
2074 flags:NODE_HAS_CHILDREN,
2075 eval: node_bitandeq_eval,
2076 write: node_bitandeq_write,
2077 read: node_bitandeq_read,
2078 exec: node_bitandeq_exec
2079 };
2080
2081 // --------------------------- x+=y ----------------------------------------
2082
2083 typedcode_t node_pluseq_write(node_t*n)
2084 {
2085     syntaxerror("can't assign to this expression");
2086 }
2087 typedcode_t node_pluseq_read(node_t*n)
2088 {
2089     READ_HEADER_LEFTRIGHT;
2090     c = right.c;
2091     if(TYPE_IS_INT(left.t)) {
2092        c = abc_add_i(c);
2093     } else {
2094        c = abc_add(c);
2095        c = converttype(c, join_types(left.t,right.t,&node_plus), left.t);
2096     }
2097     c = toreadwrite(left.c, c, 0, 0, 1);
2098     t = left.t;
2099     RET;
2100 }
2101 code_t* node_pluseq_exec(node_t*n)
2102 {
2103     READ_HEADER_LEFTRIGHT;
2104     c = right.c;
2105     if(TYPE_IS_INT(left.t)) {
2106        c = abc_add_i(c);
2107     } else {
2108        c = abc_add(c);
2109        c = converttype(c, join_types(left.t,right.t,&node_plus), left.t);
2110     }
2111     return toreadwrite(left.c, c, 0, 0, 0);
2112 }
2113 constant_t node_pluseq_eval(node_t*n)
2114 {
2115     constant_t r;r.type=CONSTANT_UNKNOWN;return r;
2116 }
2117 nodetype_t node_pluseq = //+=
2118 {
2119 name: "pluseq",
2120 flags:NODE_HAS_CHILDREN,
2121 eval: node_pluseq_eval,
2122 write: node_pluseq_write,
2123 read: node_pluseq_read,
2124 exec: node_pluseq_exec
2125 };
2126
2127 // --------------------------- x-=y ----------------------------------------
2128
2129 typedcode_t node_minuseq_write(node_t*n)
2130 {
2131     syntaxerror("can't assign to this expression");
2132 }
2133 typedcode_t node_minuseq_read(node_t*n)
2134 {
2135     READ_HEADER_LEFTRIGHT;
2136     c = right.c;
2137     if(TYPE_IS_INT(left.t)) {
2138        c = abc_subtract_i(c);
2139     } else {
2140        c = abc_subtract(c);
2141        c = converttype(c, TYPE_NUMBER, left.t);
2142     }
2143     c = toreadwrite(left.c, c, 0, 0, 1);
2144     t = left.t;
2145     RET;
2146 }
2147 code_t* node_minuseq_exec(node_t*n)
2148 {
2149     READ_HEADER_LEFTRIGHT;
2150     c = right.c;
2151     if(TYPE_IS_INT(left.t)) {
2152        c = abc_subtract_i(c);
2153     } else {
2154        c = abc_subtract(c);
2155        c = converttype(c, TYPE_NUMBER, left.t);
2156     }
2157     return toreadwrite(left.c, c, 0, 0, 0);
2158 }
2159 constant_t node_minuseq_eval(node_t*n)
2160 {
2161     constant_t r;r.type=CONSTANT_UNKNOWN;return r;
2162 }
2163 nodetype_t node_minuseq = //-=
2164 {
2165 name: "minuseq",
2166 flags:NODE_HAS_CHILDREN,
2167 eval: node_minuseq_eval,
2168 write: node_minuseq_write,
2169 read: node_minuseq_read,
2170 exec: node_minuseq_exec
2171 };
2172
2173 // --------------------------- x=y -----------------------------------------
2174
2175 typedcode_t node_assign_write(node_t*n)
2176 {
2177     syntaxerror("can't assign to this expression");
2178 }
2179 typedcode_t node_assign_read(node_t*n)
2180 {
2181     READ_HEADER_LEFTRIGHT;
2182     c = right.c;
2183     c = converttype(c, right.t, left.t);
2184     c = toreadwrite(left.c, c, 1, 0, 1);
2185     t = left.t;
2186     RET;
2187 }
2188 code_t* node_assign_exec(node_t*n)
2189 {
2190     READ_HEADER_LEFTRIGHT;
2191     c = right.c;
2192     c = converttype(c, right.t, left.t);
2193     return toreadwrite(left.c, c, 1, 0, 0);
2194 }
2195 constant_t node_assign_eval(node_t*n)
2196 {
2197     constant_t r;r.type=CONSTANT_UNKNOWN;return r;
2198 }
2199 nodetype_t node_assign =
2200 {
2201 name: "assign",
2202 flags:NODE_HAS_CHILDREN,
2203 eval: node_assign_eval,
2204 write: node_assign_write,
2205 read: node_assign_read,
2206 exec: node_assign_exec
2207 };
2208
2209 // --------------------------- x?y1:y2 --------------------------------------
2210
2211 typedcode_t node_tenary_write(node_t*n)
2212 {
2213     /* TODO: this might actually be kinda useful.
2214        (global?global.x:this.x) = 3;
2215     */
2216     syntaxerror("can't assign to this expression");
2217 }
2218 typedcode_t node_tenary_read(node_t*n)
2219 {
2220     typedcode_t cond = n->child[0]->type->read(n->child[0]);
2221     typedcode_t left = n->child[1]->type->read(n->child[1]);
2222     typedcode_t right = n->child[2]->type->read(n->child[2]);
2223     classinfo_t*t = join_types(left.t,right.t,&node_tenary);
2224     code_t* c = cond.c;
2225     code_t*j1 = c = abc_iffalse(c, 0);
2226     c = code_append(c, left.c);
2227     c = converttype(c, left.t, t);
2228     code_t*j2 = c = abc_jump(c, 0);
2229     c = j1->branch = abc_label(c);
2230     c = code_append(c, right.c);
2231     c = converttype(c, right.t, t);
2232     c = j2->branch = abc_label(c);
2233     RET;
2234 }
2235 code_t* node_tenary_exec(node_t*n)
2236 {
2237     typedcode_t cond = n->child[0]->type->read(n->child[0]);
2238     code_t* left = n->child[1]->type->exec(n->child[1]);
2239     code_t* right = n->child[2]->type->exec(n->child[2]);
2240     code_t* c = cond.c;
2241     code_t*j1 = c = abc_iffalse(c, 0);
2242     c = code_append(c, left);
2243     code_t*j2 = c = abc_jump(c, 0);
2244     c = j1->branch = abc_label(c);
2245     c = code_append(c, right);
2246     c = j2->branch = abc_label(c);
2247     return c;
2248 }
2249 constant_t node_tenary_eval(node_t*n)
2250 {
2251     constant_t r;r.type=CONSTANT_UNKNOWN;return r;
2252 }
2253 nodetype_t node_tenary =
2254 {
2255 name: "tenary",
2256 flags:NODE_HAS_CHILDREN,
2257 eval: node_tenary_eval,
2258 write: node_tenary_write,
2259 read: node_tenary_read,
2260 exec: node_tenary_exec
2261 };
2262
2263 // ---------------------------- comma ----------------------------------------
2264
2265 typedcode_t node_comma_write(node_t*n)
2266 {
2267     syntaxerror("can't assign to this expression");
2268 }
2269 typedcode_t node_comma_read(node_t*n)
2270 {
2271     code_t*c = 0;
2272     classinfo_t*t = 0;
2273     int i;
2274     for(i=0;i<n->num_children-1;i++) {
2275         c = code_append(c, n->child[i]->type->exec(n->child[i]));
2276     }
2277     typedcode_t o = n->child[i]->type->read(n->child[i]);
2278     c = code_append(c, o.c);
2279     t = o.t;
2280     RET;
2281 }
2282 code_t* node_comma_exec(node_t*n)
2283 {
2284     int t;
2285     code_t*c = 0;
2286     for(t=0;t<n->num_children;t++) {
2287         c = code_append(c, n->child[t]->type->exec(n->child[t]));
2288     }
2289     return c;
2290 }
2291 constant_t node_comma_eval(node_t*n)
2292 {
2293     constant_t r;r.type=CONSTANT_UNKNOWN;return r;
2294 }
2295 nodetype_t node_comma =
2296 {
2297 name: "expr",
2298 flags: NODE_HAS_CHILDREN,
2299 eval: node_comma_eval,
2300 write: node_comma_write,
2301 read: node_comma_read,
2302 exec: node_comma_exec
2303 };
2304
2305
2306 #if 0
2307 // -------------------------- new x -----------------------------------
2308
2309 typedcode_t node_new_write(node_t*n)
2310 {
2311 }
2312 typedcode_t node_new_read(node_t*n)
2313 {
2314 }
2315 code_t* node_new_exec(node_t*n)
2316 {
2317 }
2318 constant_t node_new_eval(node_t*n)
2319 {
2320     constant_t r;r.type=CONSTANT_UNKNOWN;return r;
2321 }
2322 nodetype_t node_new = //new
2323 {
2324 write: node_new_write,
2325 read: node_new_read,
2326 eval: node_new_eval,
2327 exec: node_new_exec
2328 };
2329
2330 // ------------------------ delete x ----------------------------------
2331
2332 typedcode_t node_delete_write(node_t*n)
2333 {
2334 }
2335 typedcode_t node_delete_read(node_t*n)
2336 {
2337 }
2338 code_t* node_delete_exec(node_t*n)
2339 {
2340 }
2341 constant_t node_delete_eval(node_t*n)
2342 {
2343     constant_t r;r.type=CONSTANT_UNKNOWN;return r;
2344 }
2345 nodetype_t node_delete = //delete
2346 {
2347 write: node_delete_write,
2348 read: node_delete_read,
2349 eval: node_delete_eval,
2350 exec: node_delete_exec
2351 };
2352
2353 // ---------------------------- x.y -----------------------------------
2354
2355 typedcode_t node_dot_write(node_t*n)
2356 {
2357 }
2358 typedcode_t node_dot_read(node_t*n)
2359 {
2360 }
2361 code_t* node_dot_exec(node_t*n)
2362 {
2363 }
2364 constant_t node_dot_eval(node_t*n)
2365 {
2366     constant_t r;r.type=CONSTANT_UNKNOWN;return r;
2367 }
2368 nodetype_t node_dot =
2369 {
2370 write: node_dot_write,
2371 read: node_dot_read,
2372 eval: node_dot_eval,
2373 exec: node_dot_exec
2374 };
2375
2376 // --------------------------- x..y -----------------------------------
2377
2378 typedcode_t node_dotdot_write(node_t*n)
2379 {
2380 }
2381 typedcode_t node_dotdot_read(node_t*n)
2382 {
2383 }
2384 code_t* node_dotdot_exec(node_t*n)
2385 {
2386
2387 }
2388 constant_t node_dotdot_eval(node_t*n)
2389 {
2390     constant_t r;r.type=CONSTANT_UNKNOWN;return r;
2391 }
2392 nodetype_t node_dotdot = //..
2393 {
2394 write: node_dotdot_write,
2395 read: node_dotdot_read,
2396 eval: node_dotdot_eval,
2397 exec: node_dotdot_exec
2398 };
2399
2400 // --------------------------- x.@y -----------------------------------
2401
2402 typedcode_t node_dotat_write(node_t*n)
2403 {
2404 }
2405 typedcode_t node_dotat_read(node_t*n)
2406 {
2407 }
2408 code_t* node_dotat_exec(node_t*n)
2409 {
2410 }
2411 constant_t node_dotat_eval(node_t*n)
2412 {
2413     constant_t r;r.type=CONSTANT_UNKNOWN;return r;
2414 }
2415 nodetype_t node_dotat = //.@
2416 {
2417 write: node_dotat_write,
2418 read: node_dotat_read,
2419 eval: node_dotat_eval,
2420 exec: node_dotat_exec
2421 };
2422
2423 // --------------------------- x.*y -----------------------------------
2424
2425 typedcode_t node_dotstar_write(node_t*n)
2426 {
2427 }
2428 typedcode_t node_dotstar_read(node_t*n)
2429 {
2430 }
2431 code_t* node_dotstar_exec(node_t*n)
2432 {
2433 }
2434 constant_t node_dotstar_eval(node_t*n)
2435 {
2436     constant_t r;r.type=CONSTANT_UNKNOWN;return r;
2437 }
2438 nodetype_t node_dotstar = //.*
2439 {
2440 write: node_dotstar_write,
2441 read: node_dotstar_read,
2442 eval: node_dotstar_eval,
2443 exec: node_dotstar_exec
2444 };
2445
2446 // -------------------------- x.(y) -----------------------------------
2447
2448 typedcode_t node_filter_write(node_t*n)
2449 {
2450 }
2451 typedcode_t node_filter_read(node_t*n)
2452 {
2453 }
2454 code_t* node_filter_exec(node_t*n)
2455 {
2456 }
2457 constant_t node_filter_eval(node_t*n)
2458 {
2459     constant_t r;r.type=CONSTANT_UNKNOWN;return r;
2460 }
2461 nodetype_t node_filter = //.(
2462 {
2463 write: node_filter_write,
2464 read: node_filter_read,
2465 eval: node_filter_eval,
2466 exec: node_filter_exec
2467 };
2468
2469 // ------------------------ x(y1,...,yn) ------------------------------
2470
2471 typedcode_t node_call_write(node_t*n)
2472 {
2473 }
2474 typedcode_t node_call_read(node_t*n)
2475 {
2476 }
2477 code_t* node_call_exec(node_t*n)
2478 {
2479 }
2480 constant_t node_call_eval(node_t*n)
2481 {
2482     constant_t r;r.type=CONSTANT_UNKNOWN;return r;
2483 }
2484 nodetype_t node_call = //functioncall
2485 {
2486 write: node_call_write,
2487 read: node_call_read,
2488 eval: node_call_eval,
2489 exec: node_call_exec
2490 };
2491
2492 // ------------------------------ @x ----------------------------------------
2493
2494 typedcode_t node_at_write(node_t*n)
2495 {
2496 }
2497 typedcode_t node_at_read(node_t*n)
2498 {
2499 }
2500 code_t* node_at_exec(node_t*n)
2501 {
2502 }
2503 constant_t node_at_eval(node_t*n)
2504 {
2505     constant_t r;r.type=CONSTANT_UNKNOWN;return r;
2506 }
2507 nodetype_t node_at = //@
2508 {
2509 write: node_at_write,
2510 read: node_at_read,
2511 eval: node_at_eval,
2512 exec: node_at_exec
2513 };
2514
2515 // ---------------------------- x.ns::y ----------------------------------------
2516
2517 typedcode_t node_dotns_write(node_t*n)
2518 {
2519 }
2520 typedcode_t node_dotns_read(node_t*n)
2521 {
2522 }
2523 code_t* node_dotns_exec(node_t*n)
2524 {
2525 }
2526 constant_t node_dotns_eval(node_t*n)
2527 {
2528     constant_t r;r.type=CONSTANT_UNKNOWN;return r;
2529 }
2530 nodetype_t node_dotns = //.::
2531 {
2532 write: node_dotns_write,
2533 read: node_dotns_read,
2534 eval: node_dotns_eval,
2535 exec: node_dotns_exec
2536 };
2537 #endif
2538
2539 // ------------------------ constant ------------------------------
2540
2541 typedcode_t node_const_write(node_t*n)
2542 {
2543     syntaxerror("can't assign a value to a constant");
2544 }
2545 typedcode_t node_const_read(node_t*n)
2546 {
2547     constant_t*v = n->value;
2548     code_t*c=0;
2549     classinfo_t*t=0;
2550     switch(v->type) {
2551         case CONSTANT_INT:
2552             if(v->i>-128 && v->i<128) {
2553                 c = abc_pushbyte(0,v->i);
2554             } else if(v->i>=-32768 && v->i<32768) {
2555                 c = abc_pushshort(0,v->i);
2556             } else {
2557                 c = abc_pushint(0,v->i);
2558             }
2559             t = TYPE_INT;
2560         break;
2561         case CONSTANT_UINT:
2562             c = abc_pushuint(0,v->u);
2563             if(v->u<128) {
2564                 c = abc_pushbyte(0,v->u);
2565             } else if(v->u<32768) {
2566                 c = abc_pushshort(0,v->u);
2567             } else {
2568                 c = abc_pushint(0,v->u);
2569             }
2570             t = TYPE_UINT;
2571         break;
2572         case CONSTANT_FLOAT:
2573             c = abc_pushdouble(0,v->f);
2574             t = TYPE_FLOAT;
2575         break;
2576         case CONSTANT_TRUE:
2577             c = abc_pushtrue(0);
2578             t = TYPE_BOOLEAN;
2579         break;
2580         case CONSTANT_FALSE:
2581             c = abc_pushfalse(0);
2582             t = TYPE_BOOLEAN;
2583         break;
2584         case CONSTANT_NULL:
2585             c = abc_pushnull(0);
2586             t = TYPE_NULL;
2587         break;
2588         case CONSTANT_STRING:
2589             c = abc_pushstring2(0,v->s);
2590             t = TYPE_STRING;
2591         break;
2592         case CONSTANT_UNDEFINED:
2593             c = abc_pushundefined(0);
2594             t = 0;
2595         break;
2596         case CONSTANT_NAMESPACE:
2597         case CONSTANT_NAMESPACE_PACKAGE:
2598         case CONSTANT_NAMESPACE_PACKAGEINTERNAL:
2599         case CONSTANT_NAMESPACE_PROTECTED:
2600         case CONSTANT_NAMESPACE_EXPLICIT:
2601         case CONSTANT_NAMESPACE_STATICPROTECTED:
2602         case CONSTANT_NAMESPACE_PRIVATE:
2603             c = abc_pushnamespace(0, v->ns);
2604         break;
2605         case CONSTANT_UNKNOWN:
2606             syntaxerror("internal error: invalid constant");
2607         default:
2608             *(int*)0=0;
2609             syntaxerror("invalid constant (%d)", v->type);
2610
2611     }
2612     RET;
2613 }
2614
2615 code_t* node_const_exec(node_t*n)
2616 {
2617     return 0;
2618 }
2619 constant_t node_const_eval(node_t*n)
2620 {
2621     constant_t*c = constant_clone(n->value);
2622     constant_t r = *c;
2623     free(c); //shallow free
2624     return r;
2625 }
2626 nodetype_t node_const =
2627 {
2628 name: "const",
2629 flags:0,
2630 eval: node_const_eval,
2631 write: node_const_write,
2632 read: node_const_read,
2633 exec: node_const_exec
2634 };
2635
2636 // ------------------------ code node ------------------------------
2637
2638 typedcode_t node_code_write(node_t*n)
2639 {
2640     typedcode_t t;
2641     t.c = 0;
2642     int tmp = gettempvar();
2643     t.c = abc_setlocal(t.c, tmp);
2644     code_t*w = toreadwrite(n->code.c, abc_getlocal(0,tmp), 1, 0, 0);
2645     t.c = code_append(t.c, w);
2646     t.c = abc_kill(t.c, tmp);
2647     n->code.c=0;
2648     t.t = n->code.t;
2649     return t;
2650 }
2651 typedcode_t node_code_read(node_t*n)
2652 {
2653     typedcode_t t;
2654     t.c = n->code.c;
2655     n->code.c=0;
2656     t.t = n->code.t;
2657     return t;
2658 }
2659 code_t* node_code_exec(node_t*n)
2660 {
2661     code_t*c = code_dup(n->code.c);
2662     c = cut_last_push(c);
2663     return c;
2664 }
2665 constant_t node_code_eval(node_t*n)
2666 {
2667     constant_t r;r.type=CONSTANT_UNKNOWN;return r;
2668 }
2669 nodetype_t node_code =
2670 {
2671 name: "code",
2672 flags:0,
2673 eval: node_code_eval,
2674 write: node_code_write,
2675 read: node_code_read,
2676 exec: node_code_exec
2677 };
2678
2679 // ------------------------ dummy node ------------------------------
2680
2681 typedcode_t node_dummy_write(node_t*n)
2682 {
2683     syntaxerror("not implemented yet");
2684 }
2685 typedcode_t node_dummy_read(node_t*n)
2686 {
2687     typedcode_t t;
2688     t.c = abc_pushundefined(0);
2689     t.t = TYPE_ANY;
2690     return t;
2691 }
2692 code_t* node_dummy_exec(node_t*n)
2693 {
2694     return 0;
2695 }
2696 constant_t node_dummy_eval(node_t*n)
2697 {
2698     constant_t r;r.type=CONSTANT_UNKNOWN;return r;
2699 }
2700 nodetype_t node_dummy =
2701 {
2702 name: "dummy",
2703 flags:0,
2704 eval: node_dummy_eval,
2705 write: node_dummy_write,
2706 read: node_dummy_read,
2707 exec: node_dummy_exec
2708 };
2709
2710 // ======================== node handling ==============================
2711
2712 node_t* mkdummynode()
2713 {
2714     node_t*n = (node_t*)rfx_calloc(sizeof(node_t));
2715     n->type = &node_dummy;
2716     return n;
2717 }
2718
2719 node_t* mkconstnode(constant_t*c)
2720 {
2721     node_t*n = (node_t*)malloc(sizeof(node_t));
2722     n->type = &node_const;
2723     n->parent = 0;
2724     n->value = c;
2725     return n;
2726 }
2727
2728 node_t* mkcodenode(typedcode_t c)
2729 {
2730     node_t*n = (node_t*)malloc(sizeof(node_t));
2731     n->type = &node_code;
2732     n->parent = 0;
2733     n->code = c;
2734     return n;
2735 }
2736
2737 node_t* mkmultinode(nodetype_t*t, node_t*one)
2738 {
2739     node_t*n = (node_t*)malloc(sizeof(node_t));
2740     n->type = t;
2741     n->parent = 0;
2742     n->child = (node_t**)malloc(sizeof(node_t*)*1);
2743     n->child[0] = one;
2744     n->num_children = 1;
2745     return n;
2746 }
2747
2748 node_t* mkstringnode(const char*s)
2749 {
2750     return mkconstnode(constant_new_string(s));
2751 }
2752
2753 node_t* mkaddnode(node_t*n1, node_t*n2)
2754 {
2755     return mknode2(&node_plus, n1, n2);
2756 }
2757
2758 node_t* multinode_extend(node_t*n, node_t*add)
2759 {
2760     n->child = realloc(n->child, (n->num_children+1)*sizeof(node_t*));
2761     n->child[n->num_children] = add;
2762     n->num_children++;
2763     return n;
2764 }
2765
2766 node_t* mknode1(nodetype_t*t, node_t*node)
2767 {
2768     node_t*n = (node_t*)malloc(sizeof(node_t)+sizeof(node_t*)*2);
2769     node_t**x = (node_t**)&n[1];
2770     n->type = t;
2771     n->parent = 0;
2772     n->child = x;
2773     n->num_children = 1;
2774     x[0] = node;
2775     x[1] = 0;
2776     return n;
2777 };
2778
2779 node_t* mknode2(nodetype_t*t, node_t*left, node_t*right)
2780 {
2781     node_t*n = (node_t*)malloc(sizeof(node_t)+sizeof(node_t*)*3);
2782     node_t**x = (node_t**)&n[1];
2783     n->type = t;
2784     n->parent = 0;
2785     n->child = x;
2786     n->num_children = 2;
2787     x[0] = left;
2788     x[1] = right;
2789     x[2] = 0;
2790     return n;
2791 }
2792 node_t* mknode3(nodetype_t*t, node_t*one, node_t*two, node_t*three)
2793 {
2794     node_t*n = (node_t*)malloc(sizeof(node_t)+sizeof(node_t*)*4);
2795     node_t**x = (node_t**)&n[1];
2796     n->type = t;
2797     n->parent = 0;
2798     n->child = x;
2799     n->num_children = 3;
2800     x[0] = one;
2801     x[1] = two;
2802     x[2] = three;
2803     x[3] = 0;
2804     return n;
2805 }
2806
2807 void node_free(node_t*n)
2808 {
2809     int t;
2810     if(n->type == &node_code) {
2811         if(n->code.c) {
2812             code_free(n->code.c);n->code.c = 0;
2813         }
2814     } else if(n->type == &node_const) {
2815         /* keep, this is not our reference */
2816     } else for(t=0;t<n->num_children;t++) {
2817         node_free(n->child[t]);n->child[t] = 0;
2818     }
2819     free(n);
2820 }
2821
2822 typedcode_t node_read(node_t*n)
2823 {
2824     constant_t c = n->type->eval(n);
2825     if(c.type == CONSTANT_UNKNOWN) {
2826         typedcode_t t = n->type->read(n);
2827         node_free(n);
2828         return t;
2829     } else {
2830         typedcode_t t = push_constant(&c);
2831         node_free(n);
2832         return t;
2833     }
2834 }
2835 typedcode_t node_write(node_t*n)
2836 {
2837     typedcode_t t = n->type->write(n);
2838     node_free(n);
2839     return t;
2840 }
2841 code_t* node_exec(node_t*n)
2842 {
2843     code_t*c = n->type->exec(n);
2844     node_free(n);
2845     return c;
2846 }
2847 constant_t node_eval(node_t*n)
2848 {
2849     constant_t c = n->type->eval(n);
2850     node_free(n);
2851     return c;
2852 }
2853
2854 /*
2855  |
2856  +-add
2857  | |
2858  | +-code
2859  | |
2860  | +-code
2861  |   |
2862  |   +
2863  |
2864  +-div
2865
2866 */
2867 void node_dump2(node_t*n, const char*p1, const char*p2, FILE*fi)
2868 {
2869     if(n->type->flags&NODE_HAS_CHILDREN) {
2870         fprintf(fi, "%s%s\n", p1, n->type->name);
2871         int t;
2872         char*o2 = malloc(strlen(p2)+3);
2873         strcpy(o2, p2);strcat(o2, "| ");
2874         char*o3 = malloc(strlen(p2)+3);
2875         strcpy(o3, p2);strcat(o3, "+-");
2876         char*o4 = malloc(strlen(p2)+3);
2877         strcpy(o4, p2);strcat(o4, "  ");
2878
2879         for(t=0;t<n->num_children;t++) {
2880             fprintf(fi, "%s\n", o2);
2881             node_dump2(n->child[t], o3, t<n->num_children-1?o2:o4, fi);
2882         }
2883         free(o2);
2884         free(o3);
2885         free(o4);
2886     } else if(n->type == &node_const) {
2887         char*s = constant_tostring(n->value);
2888         fprintf(fi, "%s%s (%s)\n", p1, n->type->name, s);
2889         free(s);
2890     } else if(n->type == &node_code) {
2891         fprintf(fi, "%s%s (%s)\n", p1, n->type->name, n->code.t?n->code.t->name:"*");
2892         code_dump2(n->code.c, 0, 0, (char*)p2, fi);
2893     } else {
2894         fprintf(fi, "%s%s\n", p1, n->type->name);
2895     }
2896 }
2897
2898 void node_dump(node_t*n)
2899 {
2900     printf("------------VVVV---------------\n");
2901     node_dump2(n,"","",stdout);
2902     printf("-------------------------------\n");
2903 }
2904