The Ecere SDK - sdk/blob - compiler/bootstrap/libec/bootstrap/pass2.c

   1 /* Code generated from eC source file: pass2.ec */
   2 #if defined(__GNUC__)
   3 typedef long long int64;
   4 typedef unsigned long long uint64;
   5 #ifndef _WIN32
   6 #define __declspec(x)
   7 #endif
   8 #elif defined(__TINYC__)
   9 #include <stdarg.h>
  10 #define __builtin_va_list va_list
  11 #define __builtin_va_start va_start
  12 #define __builtin_va_end va_end
  13 #ifdef _WIN32
  14 #define strcasecmp stricmp
  15 #define strncasecmp strnicmp
  16 #define __declspec(x) __attribute__((x))
  17 #else
  18 #define __declspec(x)
  19 #endif
  20 typedef long long int64;
  21 typedef unsigned long long uint64;
  22 #else
  23 typedef __int64 int64;
  24 typedef unsigned __int64 uint64;
  25 #endif
  26 #ifdef __BIG_ENDIAN__
  27 #define __ENDIAN_PAD(x) (8 - (x))
  28 #else
  29 #define __ENDIAN_PAD(x) 0
  30 #endif
  31 #include <stdint.h>
  32 #include <sys/types.h>
  33 extern void *  __ecereNameSpace__ecere__com__eSystem_New(unsigned int size);
  34
  35 extern void *  __ecereNameSpace__ecere__com__eSystem_New0(unsigned int size);
  36
  37 extern void *  __ecereNameSpace__ecere__com__eSystem_Renew(void *  memory, unsigned int size);
  38
  39 extern void *  __ecereNameSpace__ecere__com__eSystem_Renew0(void *  memory, unsigned int size);
  40
  41 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass___ecereNameSpace__ecere__sys__BTNode;
  42
  43 struct __ecereNameSpace__ecere__sys__BTNode;
  44
  45 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass___ecereNameSpace__ecere__sys__BinaryTree;
  46
  47 struct __ecereNameSpace__ecere__sys__BinaryTree
  48 {
  49 struct __ecereNameSpace__ecere__sys__BTNode * root;
  50 int count;
  51 int (*  CompareKey)(struct __ecereNameSpace__ecere__sys__BinaryTree * tree, uintptr_t a, uintptr_t b);
  52 void (*  FreeKey)(void *  key);
  53 } __attribute__ ((gcc_struct));
  54
  55 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass___ecereNameSpace__ecere__sys__OldList;
  56
  57 struct __ecereNameSpace__ecere__sys__OldList
  58 {
  59 void *  first;
  60 void *  last;
  61 int count;
  62 unsigned int offset;
  63 unsigned int circ;
  64 } __attribute__ ((gcc_struct));
  65
  66 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass___ecereNameSpace__ecere__com__Method;
  67
  68 struct __ecereNameSpace__ecere__com__Method
  69 {
  70 char *  name;
  71 struct __ecereNameSpace__ecere__com__Method * parent;
  72 struct __ecereNameSpace__ecere__com__Method * left;
  73 struct __ecereNameSpace__ecere__com__Method * right;
  74 int depth;
  75 int (*  function)();
  76 int vid;
  77 int type;
  78 struct __ecereNameSpace__ecere__com__Class * _class;
  79 void *  symbol;
  80 char *  dataTypeString;
  81 struct Type * dataType;
  82 int memberAccess;
  83 } __attribute__ ((gcc_struct));
  84
  85 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass___ecereNameSpace__ecere__com__Property;
  86
  87 struct __ecereNameSpace__ecere__com__Property
  88 {
  89 struct __ecereNameSpace__ecere__com__Property * prev;
  90 struct __ecereNameSpace__ecere__com__Property * next;
  91 char *  name;
  92 unsigned int isProperty;
  93 int memberAccess;
  94 int id;
  95 struct __ecereNameSpace__ecere__com__Class * _class;
  96 char *  dataTypeString;
  97 struct __ecereNameSpace__ecere__com__Class * dataTypeClass;
  98 struct Type * dataType;
  99 void (*  Set)(void * , int);
 100 int (*  Get)(void * );
 101 unsigned int (*  IsSet)(void * );
 102 void *  data;
 103 void *  symbol;
 104 int vid;
 105 unsigned int conversion;
 106 unsigned int watcherOffset;
 107 char *  category;
 108 unsigned int compiled;
 109 unsigned int selfWatchable;
 110 unsigned int isWatchable;
 111 } __attribute__ ((gcc_struct));
 112
 113 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_CodePosition;
 114
 115 struct CodePosition
 116 {
 117 int line;
 118 int charPos;
 119 int pos;
 120 int included;
 121 } __attribute__ ((gcc_struct));
 122
 123 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_Location;
 124
 125 struct Location
 126 {
 127 struct CodePosition start;
 128 struct CodePosition end;
 129 } __attribute__ ((gcc_struct));
 130
 131 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_Attrib;
 132
 133 struct Attrib;
 134
 135 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_ExtDecl;
 136
 137 struct ExtDecl;
 138
 139 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_ClassDefinition;
 140
 141 struct ClassDefinition
 142 {
 143 struct ClassDefinition * prev;
 144 struct ClassDefinition * next;
 145 struct Location loc;
 146 struct Specifier * _class;
 147 struct __ecereNameSpace__ecere__sys__OldList *  baseSpecs;
 148 struct __ecereNameSpace__ecere__sys__OldList *  definitions;
 149 struct Symbol * symbol;
 150 struct Location blockStart;
 151 struct Location nameLoc;
 152 int endid;
 153 int declMode;
 154 unsigned int deleteWatchable;
 155 } __attribute__ ((gcc_struct));
 156
 157 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_Context;
 158
 159 struct Context
 160 {
 161 struct Context * parent;
 162 struct __ecereNameSpace__ecere__sys__BinaryTree types;
 163 struct __ecereNameSpace__ecere__sys__BinaryTree classes;
 164 struct __ecereNameSpace__ecere__sys__BinaryTree symbols;
 165 struct __ecereNameSpace__ecere__sys__BinaryTree structSymbols;
 166 int nextID;
 167 int simpleID;
 168 struct __ecereNameSpace__ecere__sys__BinaryTree templateTypes;
 169 struct ClassDefinition * classDef;
 170 unsigned int templateTypesOnly;
 171 unsigned int hasNameSpace;
 172 } __attribute__ ((gcc_struct));
 173
 174 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_Instantiation;
 175
 176 struct Instantiation
 177 {
 178 struct Instantiation * prev;
 179 struct Instantiation * next;
 180 struct Location loc;
 181 struct Specifier * _class;
 182 struct Expression * exp;
 183 struct __ecereNameSpace__ecere__sys__OldList *  members;
 184 struct Symbol * symbol;
 185 unsigned int fullSet;
 186 unsigned int isConstant;
 187 unsigned char *  data;
 188 struct Location nameLoc;
 189 struct Location insideLoc;
 190 unsigned int built;
 191 } __attribute__ ((gcc_struct));
 192
 193 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_Declaration;
 194
 195 struct Declaration
 196 {
 197 struct Declaration * prev;
 198 struct Declaration * next;
 199 struct Location loc;
 200 int type;
 201 union
 202 {
 203 struct
 204 {
 205 struct __ecereNameSpace__ecere__sys__OldList *  specifiers;
 206 struct __ecereNameSpace__ecere__sys__OldList *  declarators;
 207 } __attribute__ ((gcc_struct));
 208 struct Instantiation * inst;
 209 struct
 210 {
 211 struct Identifier * id;
 212 struct Expression * exp;
 213 } __attribute__ ((gcc_struct));
 214 } __attribute__ ((gcc_struct));
 215 struct Specifier * extStorage;
 216 struct Symbol * symbol;
 217 int declMode;
 218 } __attribute__ ((gcc_struct));
 219
 220 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_Statement;
 221
 222 struct Statement
 223 {
 224 struct Statement * prev;
 225 struct Statement * next;
 226 struct Location loc;
 227 int type;
 228 union
 229 {
 230 struct __ecereNameSpace__ecere__sys__OldList *  expressions;
 231 struct
 232 {
 233 struct Identifier * id;
 234 struct Statement * stmt;
 235 } __attribute__ ((gcc_struct)) labeled;
 236 struct
 237 {
 238 struct Expression * exp;
 239 struct Statement * stmt;
 240 } __attribute__ ((gcc_struct)) caseStmt;
 241 struct
 242 {
 243 struct __ecereNameSpace__ecere__sys__OldList * declarations;
 244 struct __ecereNameSpace__ecere__sys__OldList * statements;
 245 struct Context * context;
 246 unsigned int isSwitch;
 247 } __attribute__ ((gcc_struct)) compound;
 248 struct
 249 {
 250 struct __ecereNameSpace__ecere__sys__OldList * exp;
 251 struct Statement * stmt;
 252 struct Statement * elseStmt;
 253 } __attribute__ ((gcc_struct)) ifStmt;
 254 struct
 255 {
 256 struct __ecereNameSpace__ecere__sys__OldList * exp;
 257 struct Statement * stmt;
 258 } __attribute__ ((gcc_struct)) switchStmt;
 259 struct
 260 {
 261 struct __ecereNameSpace__ecere__sys__OldList * exp;
 262 struct Statement * stmt;
 263 } __attribute__ ((gcc_struct)) whileStmt;
 264 struct
 265 {
 266 struct __ecereNameSpace__ecere__sys__OldList * exp;
 267 struct Statement * stmt;
 268 } __attribute__ ((gcc_struct)) doWhile;
 269 struct
 270 {
 271 struct Statement * init;
 272 struct Statement * check;
 273 struct __ecereNameSpace__ecere__sys__OldList * increment;
 274 struct Statement * stmt;
 275 } __attribute__ ((gcc_struct)) forStmt;
 276 struct
 277 {
 278 struct Identifier * id;
 279 } __attribute__ ((gcc_struct)) gotoStmt;
 280 struct
 281 {
 282 struct Specifier * spec;
 283 char * statements;
 284 struct __ecereNameSpace__ecere__sys__OldList * inputFields;
 285 struct __ecereNameSpace__ecere__sys__OldList * outputFields;
 286 struct __ecereNameSpace__ecere__sys__OldList * clobberedFields;
 287 } __attribute__ ((gcc_struct)) asmStmt;
 288 struct
 289 {
 290 struct Expression * watcher;
 291 struct Expression * object;
 292 struct __ecereNameSpace__ecere__sys__OldList * watches;
 293 } __attribute__ ((gcc_struct)) _watch;
 294 struct
 295 {
 296 struct Identifier * id;
 297 struct __ecereNameSpace__ecere__sys__OldList * exp;
 298 struct __ecereNameSpace__ecere__sys__OldList * filter;
 299 struct Statement * stmt;
 300 } __attribute__ ((gcc_struct)) forEachStmt;
 301 struct Declaration * decl;
 302 } __attribute__ ((gcc_struct));
 303 } __attribute__ ((gcc_struct));
 304
 305 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_TypeName;
 306
 307 struct TypeName
 308 {
 309 struct TypeName * prev;
 310 struct TypeName * next;
 311 struct Location loc;
 312 struct __ecereNameSpace__ecere__sys__OldList *  qualifiers;
 313 struct Declarator * declarator;
 314 int classObjectType;
 315 struct Expression * bitCount;
 316 } __attribute__ ((gcc_struct));
 317
 318 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_Initializer;
 319
 320 struct Initializer
 321 {
 322 struct Initializer * prev;
 323 struct Initializer * next;
 324 struct Location loc;
 325 int type;
 326 union
 327 {
 328 struct Expression * exp;
 329 struct __ecereNameSpace__ecere__sys__OldList *  list;
 330 } __attribute__ ((gcc_struct));
 331 unsigned int isConstant;
 332 } __attribute__ ((gcc_struct));
 333
 334 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass___ecereNameSpace__ecere__com__DataValue;
 335
 336 struct __ecereNameSpace__ecere__com__DataValue
 337 {
 338 union
 339 {
 340 char c;
 341 unsigned char uc;
 342 short s;
 343 unsigned short us;
 344 int i;
 345 unsigned int ui;
 346 void *  p;
 347 float f;
 348 double d;
 349 long long i64;
 350 uint64 ui64;
 351 } __attribute__ ((gcc_struct));
 352 } __attribute__ ((gcc_struct));
 353
 354 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_Expression;
 355
 356 struct Expression
 357 {
 358 struct Expression * prev;
 359 struct Expression * next;
 360 struct Location loc;
 361 int type;
 362 union
 363 {
 364 struct
 365 {
 366 char *  constant;
 367 struct Identifier * identifier;
 368 } __attribute__ ((gcc_struct));
 369 struct Statement * compound;
 370 struct Instantiation * instance;
 371 char *  string;
 372 struct __ecereNameSpace__ecere__sys__OldList *  list;
 373 struct
 374 {
 375 struct __ecereNameSpace__ecere__sys__OldList * specifiers;
 376 struct Declarator * decl;
 377 } __attribute__ ((gcc_struct)) _classExp;
 378 struct
 379 {
 380 struct Identifier * id;
 381 } __attribute__ ((gcc_struct)) classData;
 382 struct
 383 {
 384 struct Expression * exp;
 385 struct __ecereNameSpace__ecere__sys__OldList * arguments;
 386 struct Location argLoc;
 387 } __attribute__ ((gcc_struct)) call;
 388 struct
 389 {
 390 struct Expression * exp;
 391 struct __ecereNameSpace__ecere__sys__OldList * index;
 392 } __attribute__ ((gcc_struct)) index;
 393 struct
 394 {
 395 struct Expression * exp;
 396 struct Identifier * member;
 397 int memberType;
 398 unsigned int thisPtr;
 399 } __attribute__ ((gcc_struct)) member;
 400 struct
 401 {
 402 int op;
 403 struct Expression * exp1;
 404 struct Expression * exp2;
 405 } __attribute__ ((gcc_struct)) op;
 406 struct TypeName * typeName;
 407 struct Specifier * _class;
 408 struct
 409 {
 410 struct TypeName * typeName;
 411 struct Expression * exp;
 412 } __attribute__ ((gcc_struct)) cast;
 413 struct
 414 {
 415 struct Expression * cond;
 416 struct __ecereNameSpace__ecere__sys__OldList * exp;
 417 struct Expression * elseExp;
 418 } __attribute__ ((gcc_struct)) cond;
 419 struct
 420 {
 421 struct TypeName * typeName;
 422 struct Expression * size;
 423 } __attribute__ ((gcc_struct)) _new;
 424 struct
 425 {
 426 struct TypeName * typeName;
 427 struct Expression * size;
 428 struct Expression * exp;
 429 } __attribute__ ((gcc_struct)) _renew;
 430 struct
 431 {
 432 char * table;
 433 struct Identifier * id;
 434 } __attribute__ ((gcc_struct)) db;
 435 struct
 436 {
 437 struct Expression * ds;
 438 struct Expression * name;
 439 } __attribute__ ((gcc_struct)) dbopen;
 440 struct
 441 {
 442 struct TypeName * typeName;
 443 struct Initializer * initializer;
 444 } __attribute__ ((gcc_struct)) initializer;
 445 struct
 446 {
 447 struct Expression * exp;
 448 struct TypeName * typeName;
 449 } __attribute__ ((gcc_struct)) vaArg;
 450 } __attribute__ ((gcc_struct));
 451 unsigned int debugValue;
 452 struct __ecereNameSpace__ecere__com__DataValue val;
 453 uint64 address;
 454 unsigned int hasAddress;
 455 struct Type * expType;
 456 struct Type * destType;
 457 unsigned int usage;
 458 int tempCount;
 459 unsigned int byReference;
 460 unsigned int isConstant;
 461 unsigned int addedThis;
 462 unsigned int needCast;
 463 unsigned int thisPtr;
 464 } __attribute__ ((gcc_struct));
 465
 466 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_TemplateDatatype;
 467
 468 struct TemplateDatatype;
 469
 470 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_TemplateArgument;
 471
 472 struct TemplateArgument;
 473
 474 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_TemplateParameter;
 475
 476 struct TemplateParameter;
 477
 478 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_Specifier;
 479
 480 struct Specifier
 481 {
 482 struct Specifier * prev;
 483 struct Specifier * next;
 484 struct Location loc;
 485 int type;
 486 union
 487 {
 488 int specifier;
 489 struct
 490 {
 491 struct ExtDecl * extDecl;
 492 char *  name;
 493 struct Symbol * symbol;
 494 struct __ecereNameSpace__ecere__sys__OldList *  templateArgs;
 495 } __attribute__ ((gcc_struct));
 496 struct
 497 {
 498 struct Identifier * id;
 499 struct __ecereNameSpace__ecere__sys__OldList *  list;
 500 struct __ecereNameSpace__ecere__sys__OldList *  baseSpecs;
 501 struct __ecereNameSpace__ecere__sys__OldList *  definitions;
 502 unsigned int addNameSpace;
 503 struct Context * ctx;
 504 struct ExtDecl * extDeclStruct;
 505 } __attribute__ ((gcc_struct));
 506 struct Expression * expression;
 507 struct Specifier * _class;
 508 struct TemplateParameter * templateParameter;
 509 } __attribute__ ((gcc_struct));
 510 } __attribute__ ((gcc_struct));
 511
 512 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_Identifier;
 513
 514 struct Identifier
 515 {
 516 struct Identifier * prev;
 517 struct Identifier * next;
 518 struct Location loc;
 519 struct Symbol * classSym;
 520 struct Specifier * _class;
 521 char *  string;
 522 struct Identifier * badID;
 523 } __attribute__ ((gcc_struct));
 524
 525 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_Pointer;
 526
 527 struct Pointer;
 528
 529 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_Declarator;
 530
 531 struct Declarator
 532 {
 533 struct Declarator * prev;
 534 struct Declarator * next;
 535 struct Location loc;
 536 int type;
 537 struct Symbol * symbol;
 538 struct Declarator * declarator;
 539 union
 540 {
 541 struct Identifier * identifier;
 542 struct
 543 {
 544 struct Expression * exp;
 545 struct Expression * posExp;
 546 struct Attrib * attrib;
 547 } __attribute__ ((gcc_struct)) structDecl;
 548 struct
 549 {
 550 struct Expression * exp;
 551 struct Specifier * enumClass;
 552 } __attribute__ ((gcc_struct)) array;
 553 struct
 554 {
 555 struct __ecereNameSpace__ecere__sys__OldList * parameters;
 556 } __attribute__ ((gcc_struct)) function;
 557 struct
 558 {
 559 struct Pointer * pointer;
 560 } __attribute__ ((gcc_struct)) pointer;
 561 struct
 562 {
 563 struct ExtDecl * extended;
 564 } __attribute__ ((gcc_struct)) extended;
 565 } __attribute__ ((gcc_struct));
 566 } __attribute__ ((gcc_struct));
 567
 568 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_FunctionDefinition;
 569
 570 struct FunctionDefinition
 571 {
 572 struct FunctionDefinition * prev;
 573 struct FunctionDefinition * next;
 574 struct Location loc;
 575 struct __ecereNameSpace__ecere__sys__OldList *  specifiers;
 576 struct Declarator * declarator;
 577 struct __ecereNameSpace__ecere__sys__OldList *  declarations;
 578 struct Statement * body;
 579 struct __ecereNameSpace__ecere__com__Class * _class;
 580 struct __ecereNameSpace__ecere__sys__OldList attached;
 581 int declMode;
 582 struct Type * type;
 583 struct Symbol * propSet;
 584 int tempCount;
 585 unsigned int propertyNoThis;
 586 } __attribute__ ((gcc_struct));
 587
 588 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_DBTableDef;
 589
 590 struct DBTableDef;
 591
 592 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_External;
 593
 594 struct External
 595 {
 596 struct External * prev;
 597 struct External * next;
 598 struct Location loc;
 599 int type;
 600 struct Symbol * symbol;
 601 union
 602 {
 603 struct FunctionDefinition * function;
 604 struct ClassDefinition * _class;
 605 struct Declaration * declaration;
 606 char *  importString;
 607 struct Identifier * id;
 608 struct DBTableDef * table;
 609 } __attribute__ ((gcc_struct));
 610 int importType;
 611 } __attribute__ ((gcc_struct));
 612
 613 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_ModuleImport;
 614
 615 struct ModuleImport;
 616
 617 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_ClassImport;
 618
 619 struct ClassImport;
 620
 621 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_Symbol;
 622
 623 struct Symbol
 624 {
 625 char *  string;
 626 struct Symbol * parent;
 627 struct Symbol * left;
 628 struct Symbol * right;
 629 int depth;
 630 struct Type * type;
 631 union
 632 {
 633 struct __ecereNameSpace__ecere__com__Method * method;
 634 struct __ecereNameSpace__ecere__com__Property * _property;
 635 struct __ecereNameSpace__ecere__com__Class * registered;
 636 } __attribute__ ((gcc_struct));
 637 int id;
 638 int idCode;
 639 union
 640 {
 641 struct
 642 {
 643 struct External * pointerExternal;
 644 struct External * structExternal;
 645 } __attribute__ ((gcc_struct));
 646 struct
 647 {
 648 struct External * externalGet;
 649 struct External * externalSet;
 650 struct External * externalPtr;
 651 struct External * externalIsSet;
 652 } __attribute__ ((gcc_struct));
 653 struct
 654 {
 655 struct External * methodExternal;
 656 struct External * methodCodeExternal;
 657 } __attribute__ ((gcc_struct));
 658 } __attribute__ ((gcc_struct));
 659 unsigned int imported;
 660 unsigned int declaredStructSym;
 661 struct __ecereNameSpace__ecere__com__Class * _class;
 662 unsigned int declaredStruct;
 663 unsigned int needConstructor;
 664 unsigned int needDestructor;
 665 char *  constructorName;
 666 char *  structName;
 667 char *  className;
 668 char *  destructorName;
 669 struct ModuleImport * module;
 670 struct ClassImport * _import;
 671 struct Location nameLoc;
 672 unsigned int isParam;
 673 unsigned int isRemote;
 674 unsigned int isStruct;
 675 unsigned int fireWatchersDone;
 676 int declaring;
 677 unsigned int classData;
 678 unsigned int isStatic;
 679 char *  shortName;
 680 struct __ecereNameSpace__ecere__sys__OldList *  templateParams;
 681 struct __ecereNameSpace__ecere__sys__OldList templatedClasses;
 682 struct Context * ctx;
 683 int isIterator;
 684 struct Expression * propCategory;
 685 } __attribute__ ((gcc_struct));
 686
 687 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_Type;
 688
 689 struct Type
 690 {
 691 struct Type * prev;
 692 struct Type * next;
 693 int refCount;
 694 union
 695 {
 696 struct Symbol * _class;
 697 struct
 698 {
 699 struct __ecereNameSpace__ecere__sys__OldList members;
 700 char *  enumName;
 701 } __attribute__ ((gcc_struct));
 702 struct
 703 {
 704 struct Type * returnType;
 705 struct __ecereNameSpace__ecere__sys__OldList params;
 706 struct Symbol * thisClass;
 707 unsigned int staticMethod;
 708 struct TemplateParameter * thisClassTemplate;
 709 } __attribute__ ((gcc_struct));
 710 struct
 711 {
 712 struct __ecereNameSpace__ecere__com__Method * method;
 713 struct __ecereNameSpace__ecere__com__Class * methodClass;
 714 struct __ecereNameSpace__ecere__com__Class * usedClass;
 715 } __attribute__ ((gcc_struct));
 716 struct
 717 {
 718 struct Type * arrayType;
 719 int arraySize;
 720 struct Expression * arraySizeExp;
 721 unsigned int freeExp;
 722 struct Symbol * enumClass;
 723 } __attribute__ ((gcc_struct));
 724 struct Type * type;
 725 struct TemplateParameter * templateParameter;
 726 } __attribute__ ((gcc_struct));
 727 int kind;
 728 unsigned int size;
 729 char *  name;
 730 char *  typeName;
 731 int classObjectType;
 732 int alignment;
 733 unsigned int offset;
 734 int bitFieldCount;
 735 int count;
 736 unsigned int isSigned : 1;
 737 unsigned int constant : 1;
 738 unsigned int truth : 1;
 739 unsigned int byReference : 1;
 740 unsigned int extraParam : 1;
 741 unsigned int directClassAccess : 1;
 742 unsigned int computing : 1;
 743 unsigned int keepCast : 1;
 744 unsigned int passAsTemplate : 1;
 745 unsigned int dllExport : 1;
 746 unsigned int attrStdcall : 1;
 747 unsigned int declaredWithStruct : 1;
 748 } __attribute__ ((gcc_struct));
 749
 750 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass___ecereNameSpace__ecere__com__Class;
 751
 752 struct __ecereNameSpace__ecere__com__Class
 753 {
 754 struct __ecereNameSpace__ecere__com__Class * prev;
 755 struct __ecereNameSpace__ecere__com__Class * next;
 756 char *  name;
 757 int offset;
 758 int structSize;
 759 int (* *  _vTbl)();
 760 int vTblSize;
 761 int (*  Constructor)(struct __ecereNameSpace__ecere__com__Instance *);
 762 void (*  Destructor)(struct __ecereNameSpace__ecere__com__Instance *);
 763 int offsetClass;
 764 int sizeClass;
 765 struct __ecereNameSpace__ecere__com__Class * base;
 766 struct __ecereNameSpace__ecere__sys__BinaryTree methods;
 767 struct __ecereNameSpace__ecere__sys__BinaryTree members;
 768 struct __ecereNameSpace__ecere__sys__BinaryTree prop;
 769 struct __ecereNameSpace__ecere__sys__OldList membersAndProperties;
 770 struct __ecereNameSpace__ecere__sys__BinaryTree classProperties;
 771 struct __ecereNameSpace__ecere__sys__OldList derivatives;
 772 int memberID;
 773 int startMemberID;
 774 int type;
 775 struct __ecereNameSpace__ecere__com__Instance * module;
 776 struct __ecereNameSpace__ecere__com__NameSpace *  nameSpace;
 777 char *  dataTypeString;
 778 struct Type * dataType;
 779 int typeSize;
 780 int defaultAlignment;
 781 void (*  Initialize)();
 782 int memberOffset;
 783 struct __ecereNameSpace__ecere__sys__OldList selfWatchers;
 784 char *  designerClass;
 785 unsigned int noExpansion;
 786 char *  defaultProperty;
 787 unsigned int comRedefinition;
 788 int count;
 789 unsigned int isRemote;
 790 unsigned int internalDecl;
 791 void *  data;
 792 unsigned int computeSize;
 793 int structAlignment;
 794 int destructionWatchOffset;
 795 unsigned int fixed;
 796 struct __ecereNameSpace__ecere__sys__OldList delayedCPValues;
 797 int inheritanceAccess;
 798 char *  fullName;
 799 void *  symbol;
 800 struct __ecereNameSpace__ecere__sys__OldList conversions;
 801 struct __ecereNameSpace__ecere__sys__OldList templateParams;
 802 struct __ecereNameSpace__ecere__com__ClassTemplateArgument *  templateArgs;
 803 struct __ecereNameSpace__ecere__com__Class * templateClass;
 804 struct __ecereNameSpace__ecere__sys__OldList templatized;
 805 int numParams;
 806 unsigned int isInstanceClass;
 807 unsigned int byValueSystemClass;
 808 } __attribute__ ((gcc_struct));
 809
 810 extern long long __ecereNameSpace__ecere__com__eClass_GetProperty(struct __ecereNameSpace__ecere__com__Class * _class, char *  name);
 811
 812 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass___ecereNameSpace__ecere__com__Instance;
 813
 814 struct __ecereNameSpace__ecere__com__Instance
 815 {
 816 int (* *  _vTbl)();
 817 struct __ecereNameSpace__ecere__com__Class * _class;
 818 int _refCount;
 819 } __attribute__ ((gcc_struct));
 820
 821 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass___ecereNameSpace__ecere__com__DataMember;
 822
 823 struct __ecereNameSpace__ecere__com__DataMember
 824 {
 825 struct __ecereNameSpace__ecere__com__DataMember * prev;
 826 struct __ecereNameSpace__ecere__com__DataMember * next;
 827 char *  name;
 828 unsigned int isProperty;
 829 int memberAccess;
 830 int id;
 831 struct __ecereNameSpace__ecere__com__Class * _class;
 832 char *  dataTypeString;
 833 struct __ecereNameSpace__ecere__com__Class * dataTypeClass;
 834 struct Type * dataType;
 835 int type;
 836 int offset;
 837 int memberID;
 838 struct __ecereNameSpace__ecere__sys__OldList members;
 839 struct __ecereNameSpace__ecere__sys__BinaryTree membersAlpha;
 840 int memberOffset;
 841 int structAlignment;
 842 } __attribute__ ((gcc_struct));
 843
 844 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass___ecereNameSpace__ecere__com__SerialBuffer;
 845
 846 struct __ecereNameSpace__ecere__com__SerialBuffer
 847 {
 848 unsigned char *  _buffer;
 849 unsigned int count;
 850 unsigned int _size;
 851 unsigned int pos;
 852 } __attribute__ ((gcc_struct));
 853
 854 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass___ecereNameSpace__ecere__com__ClassTemplateArgument;
 855
 856 struct __ecereNameSpace__ecere__com__ClassTemplateArgument
 857 {
 858 union
 859 {
 860 struct
 861 {
 862 char *  dataTypeString;
 863 struct __ecereNameSpace__ecere__com__Class * dataTypeClass;
 864 } __attribute__ ((gcc_struct));
 865 struct __ecereNameSpace__ecere__com__DataValue expression;
 866 struct
 867 {
 868 char *  memberString;
 869 union
 870 {
 871 struct __ecereNameSpace__ecere__com__DataMember * member;
 872 struct __ecereNameSpace__ecere__com__Property * prop;
 873 struct __ecereNameSpace__ecere__com__Method * method;
 874 } __attribute__ ((gcc_struct));
 875 } __attribute__ ((gcc_struct));
 876 } __attribute__ ((gcc_struct));
 877 } __attribute__ ((gcc_struct));
 878
 879 enum yytokentype
 880 {
 881 IDENTIFIER = 258, CONSTANT = 259, STRING_LITERAL = 260, SIZEOF = 261, PTR_OP = 262, INC_OP = 263, DEC_OP = 264, LEFT_OP = 265, RIGHT_OP = 266, LE_OP = 267, GE_OP = 268, EQ_OP = 269, NE_OP = 270, AND_OP = 271, OR_OP = 272, MUL_ASSIGN = 273, DIV_ASSIGN = 274, MOD_ASSIGN = 275, ADD_ASSIGN = 276, SUB_ASSIGN = 277, LEFT_ASSIGN = 278, RIGHT_ASSIGN = 279, AND_ASSIGN = 280, XOR_ASSIGN = 281, OR_ASSIGN = 282, TYPE_NAME = 283, TYPEDEF = 284, EXTERN = 285, STATIC = 286, AUTO = 287, REGISTER = 288, CHAR = 289, SHORT = 290, INT = 291, UINT = 292, INT64 = 293, LONG = 294, SIGNED = 295, UNSIGNED = 296, FLOAT = 297, DOUBLE = 298, CONST = 299, VOLATILE = 300, VOID = 301, VALIST = 302, STRUCT = 303, UNION = 304, ENUM = 305, ELLIPSIS = 306, CASE = 307, DEFAULT = 308, IF = 309, SWITCH = 310, WHILE = 311, DO = 312, FOR = 313, GOTO = 314, CONTINUE = 315, BREAK = 316, RETURN = 317, IFX = 318, ELSE = 319, CLASS = 320, THISCLASS = 321, CLASS_NAME = 322, PROPERTY = 323, SETPROP = 324, GETPROP = 325, NEWOP = 326, RENEW = 327, DELETE = 328, EXT_DECL = 329, EXT_STORAGE = 330, IMPORT = 331, DEFINE = 332, VIRTUAL = 333, ATTRIB = 334, PUBLIC = 335, PRIVATE = 336, TYPED_OBJECT = 337, ANY_OBJECT = 338, _INCREF = 339, EXTENSION = 340, ASM = 341, TYPEOF = 342, WATCH = 343, STOPWATCHING = 344, FIREWATCHERS = 345, WATCHABLE = 346, CLASS_DESIGNER = 347, CLASS_NO_EXPANSION = 348, CLASS_FIXED = 349, ISPROPSET = 350, CLASS_DEFAULT_PROPERTY = 351, PROPERTY_CATEGORY = 352, CLASS_DATA = 353, CLASS_PROPERTY = 354, SUBCLASS = 355, NAMESPACE = 356, NEW0OP = 357, RENEW0 = 358, VAARG = 359, DBTABLE = 360, DBFIELD = 361, DBINDEX = 362, DATABASE_OPEN = 363, ALIGNOF = 364, ATTRIB_DEP = 365, __ATTRIB = 366
 882 };
 883
 884 typedef union YYSTYPE
 885 {
 886 int specifierType;
 887 int i;
 888 int declMode;
 889 struct Identifier * id;
 890 struct Expression * exp;
 891 struct Specifier * specifier;
 892 struct __ecereNameSpace__ecere__sys__OldList * list;
 893 struct Enumerator * enumerator;
 894 struct Declarator * declarator;
 895 struct Pointer * pointer;
 896 struct Initializer * initializer;
 897 struct InitDeclarator * initDeclarator;
 898 struct TypeName * typeName;
 899 struct Declaration * declaration;
 900 struct Statement * stmt;
 901 struct FunctionDefinition * function;
 902 struct External * external;
 903 struct Context * context;
 904 struct AsmField * asmField;
 905 struct Attrib * attrib;
 906 struct ExtDecl * extDecl;
 907 struct Attribute * attribute;
 908 struct Instantiation * instance;
 909 struct MembersInit * membersInit;
 910 struct MemberInit * memberInit;
 911 struct ClassFunction * classFunction;
 912 struct ClassDefinition * _class;
 913 struct ClassDef * classDef;
 914 struct PropertyDef * prop;
 915 char * string;
 916 struct Symbol * symbol;
 917 struct PropertyWatch * propertyWatch;
 918 struct TemplateParameter * templateParameter;
 919 struct TemplateArgument * templateArgument;
 920 struct TemplateDatatype * templateDatatype;
 921 struct DBTableEntry * dbtableEntry;
 922 struct DBIndexItem * dbindexItem;
 923 struct DBTableDef * dbtableDef;
 924 } __attribute__ ((gcc_struct)) YYSTYPE;
 925
 926 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_Enumerator;
 927
 928 struct Enumerator;
 929
 930 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_InitDeclarator;
 931
 932 struct InitDeclarator
 933 {
 934 struct InitDeclarator * prev;
 935 struct InitDeclarator * next;
 936 struct Location loc;
 937 struct Declarator * declarator;
 938 struct Initializer * initializer;
 939 } __attribute__ ((gcc_struct));
 940
 941 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_AsmField;
 942
 943 struct AsmField
 944 {
 945 struct AsmField * prev;
 946 struct AsmField * next;
 947 struct Location loc;
 948 char *  command;
 949 struct Expression * expression;
 950 } __attribute__ ((gcc_struct));
 951
 952 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_Attribute;
 953
 954 struct Attribute;
 955
 956 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_ClassFunction;
 957
 958 struct ClassFunction
 959 {
 960 struct ClassFunction * prev;
 961 struct ClassFunction * next;
 962 struct Location loc;
 963 struct __ecereNameSpace__ecere__sys__OldList *  specifiers;
 964 struct Declarator * declarator;
 965 struct __ecereNameSpace__ecere__sys__OldList *  declarations;
 966 struct Statement * body;
 967 struct __ecereNameSpace__ecere__com__Class * _class;
 968 struct __ecereNameSpace__ecere__sys__OldList attached;
 969 int declMode;
 970 struct Type * type;
 971 struct Symbol * propSet;
 972 unsigned int isVirtual;
 973 unsigned int isConstructor;
 974 unsigned int isDestructor;
 975 unsigned int dontMangle;
 976 int id;
 977 int idCode;
 978 } __attribute__ ((gcc_struct));
 979
 980 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_MembersInit;
 981
 982 struct MembersInit
 983 {
 984 struct MembersInit * prev;
 985 struct MembersInit * next;
 986 struct Location loc;
 987 int type;
 988 union
 989 {
 990 struct __ecereNameSpace__ecere__sys__OldList *  dataMembers;
 991 struct ClassFunction * function;
 992 } __attribute__ ((gcc_struct));
 993 } __attribute__ ((gcc_struct));
 994
 995 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_MemberInit;
 996
 997 struct MemberInit
 998 {
 999 struct MemberInit * prev;
1000 struct MemberInit * next;
1001 struct Location loc;
1002 struct Location realLoc;
1003 struct __ecereNameSpace__ecere__sys__OldList *  identifiers;
1004 struct Initializer * initializer;
1005 unsigned int used;
1006 unsigned int variable;
1007 unsigned int takeOutExp;
1008 } __attribute__ ((gcc_struct));
1009
1010 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_PropertyDef;
1011
1012 struct PropertyDef
1013 {
1014 struct PropertyDef * prev;
1015 struct PropertyDef * next;
1016 struct Location loc;
1017 struct __ecereNameSpace__ecere__sys__OldList *  specifiers;
1018 struct Declarator * declarator;
1019 struct Identifier * id;
1020 struct Statement * getStmt;
1021 struct Statement * setStmt;
1022 struct Statement * issetStmt;
1023 struct Symbol * symbol;
1024 unsigned int conversion;
1025 unsigned int isWatchable;
1026 struct Expression * category;
1027 } __attribute__ ((gcc_struct));
1028
1029 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_PropertyWatch;
1030
1031 struct PropertyWatch
1032 {
1033 struct PropertyWatch * prev;
1034 struct PropertyWatch * next;
1035 struct Location loc;
1036 struct Statement * compound;
1037 struct __ecereNameSpace__ecere__sys__OldList *  properties;
1038 unsigned int deleteWatch;
1039 } __attribute__ ((gcc_struct));
1040
1041 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_ClassDef;
1042
1043 struct ClassDef
1044 {
1045 struct ClassDef * prev;
1046 struct ClassDef * next;
1047 struct Location loc;
1048 int type;
1049 union
1050 {
1051 struct Declaration * decl;
1052 struct ClassFunction * function;
1053 struct __ecereNameSpace__ecere__sys__OldList *  defProperties;
1054 struct PropertyDef * propertyDef;
1055 struct PropertyWatch * propertyWatch;
1056 char *  designer;
1057 struct Identifier * defaultProperty;
1058 struct
1059 {
1060 struct Identifier * id;
1061 struct Initializer * initializer;
1062 } __attribute__ ((gcc_struct));
1063 } __attribute__ ((gcc_struct));
1064 int memberAccess;
1065 void *  object;
1066 } __attribute__ ((gcc_struct));
1067
1068 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_DBTableEntry;
1069
1070 struct DBTableEntry;
1071
1072 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_DBIndexItem;
1073
1074 struct DBIndexItem;
1075
1076 extern YYSTYPE yylval;
1077
1078 extern struct Location yylloc;
1079
1080 extern struct External * curExternal;
1081
1082 static struct Statement * curCompound;
1083
1084 extern struct Expression * CopyExpression(struct Expression * exp);
1085
1086 extern void FreeExpression(struct Expression * exp);
1087
1088 void __ecereMethod___ecereNameSpace__ecere__sys__OldList_Remove(struct __ecereNameSpace__ecere__sys__OldList * this, void *  item);
1089
1090 void __ecereMethod___ecereNameSpace__ecere__sys__OldList_Add(struct __ecereNameSpace__ecere__sys__OldList * this, void *  item);
1091
1092 static void _FixRefExp(struct Expression ** expPtr, struct Expression ** memberExpPtr)
1093 {
1094 struct Expression * memberExp = *memberExpPtr;
1095
1096 if(memberExp && memberExp->type == 8 && memberExp->member.exp && (memberExp->member.exp->type == 5 || memberExp->member.exp->type == 34))
1097 {
1098 struct Expression * bracketExp = memberExp->member.exp;
1099 struct Expression * idExp = (*bracketExp->list).last;
1100
1101 if(idExp && idExp->type == 0)
1102 {
1103 struct Expression * newExp = (((void *)0));
1104 struct Expression * exp = *expPtr;
1105
1106 *memberExpPtr = (((void *)0));
1107 newExp = CopyExpression(exp);
1108 *(struct Expression **)((unsigned char *)newExp + ((unsigned char *)memberExpPtr - (unsigned char *)exp)) = memberExp;
1109 memberExp->member.exp = idExp;
1110 exp->type = 5;
1111 exp->list = bracketExp->list;
1112 bracketExp->list = (((void *)0));
1113 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Remove((&*exp->list), idExp);
1114 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Add((&*exp->list), newExp);
1115 FreeExpression(bracketExp);
1116 *expPtr = exp;
1117 }
1118 }
1119 else if(*expPtr && (*expPtr)->type == 4 && (*expPtr)->op.op == '&' && !(*expPtr)->op.exp1 && memberExp && (memberExp->type == 5 || memberExp->type == 34) && memberExp->list && (*memberExp->list).count > 1)
1120 {
1121 struct Expression * newExp = (((void *)0));
1122 struct Expression * exp = *expPtr;
1123
1124 *memberExpPtr = (((void *)0));
1125 newExp = CopyExpression(exp);
1126 *(struct Expression **)((unsigned char *)newExp + ((unsigned char *)memberExpPtr - (unsigned char *)exp)) = (*memberExp->list).last;
1127 exp->type = 5;
1128 exp->list = memberExp->list;
1129 memberExp->list = (((void *)0));
1130 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Remove((&*exp->list), (*exp->list).last);
1131 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Add((&*exp->list), newExp);
1132 FreeExpression(memberExp);
1133 *expPtr = newExp;
1134 }
1135 }
1136
1137 static struct Expression * FixRefExp(struct Expression * exp)
1138 {
1139 if(exp->type == 4)
1140 {
1141 _FixRefExp(&exp, &exp->op.exp1);
1142 _FixRefExp(&exp, &exp->op.exp2);
1143 }
1144 else if(exp->type == 6)
1145 _FixRefExp(&exp, &exp->index.exp);
1146 else if(exp->type == 8)
1147 _FixRefExp(&exp, &exp->member.exp);
1148 return exp;
1149 }
1150
1151 extern int strcmp(const char * , const char * );
1152
1153 extern void *  __ecereNameSpace__ecere__com__eInstance_New(struct __ecereNameSpace__ecere__com__Class * _class);
1154
1155 static struct Expression * FixReference(struct Expression * e, unsigned int wantReference)
1156 {
1157 if(e->expType && e->type != 2)
1158 {
1159 struct Type * type = e->expType;
1160 unsigned int isPointer = 0x0;
1161
1162 if(type->kind == 8)
1163 {
1164 struct __ecereNameSpace__ecere__com__Class * _class = type->_class ? type->_class->registered : (((void *)0));
1165
1166 if(_class && ((_class->type == 1 && !type->declaredWithStruct) || _class->type == 5 || (_class->type == 1000 && _class->base && strcmp(_class->fullName, "uintptr") && strcmp(_class->fullName, "intptr") && strcmp(_class->fullName, "uintsize") && strcmp(_class->fullName, "intsize"))))
1167 {
1168 if(wantReference != (e->byReference || isPointer))
1169 {
1170 struct Expression * exp = e;
1171
1172 for(; ; )
1173 {
1174 if(exp->type == 5 || exp->type == 34)
1175 {
1176 if(exp->list)
1177 {
1178 exp->byReference = wantReference;
1179 exp = (*exp->list).last;
1180 }
1181 else
1182 break;
1183 }
1184 else if(exp->type == 11)
1185 {
1186 exp->byReference = wantReference;
1187 exp = exp->cast.exp;
1188 }
1189 else if(exp->type == 12)
1190 {
1191 if((*exp->cond.exp).last)
1192 FixReference((*exp->cond.exp).last, wantReference);
1193 FixReference(exp->cond.elseExp, wantReference);
1194 break;
1195 }
1196 else
1197 {
1198 if(wantReference != (exp->byReference || isPointer))
1199 {
1200 struct Expression * newExp = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass_Expression);
1201
1202 *newExp = *exp;
1203 if(exp->destType)
1204 exp->destType->refCount++;
1205 if(exp->expType)
1206 exp->expType->refCount++;
1207 exp->type = 4;
1208 exp->op.exp1 = (((void *)0));
1209 exp->op.exp2 = newExp;
1210 if(wantReference)
1211 exp->op.op = '&';
1212 else
1213 exp->op.op = '*';
1214 e->byReference = wantReference;
1215 exp->byReference = wantReference;
1216 }
1217 break;
1218 }
1219 }
1220 }
1221 }
1222 }
1223 }
1224 e = FixRefExp(e);
1225 return e;
1226 }
1227
1228 static unsigned int FixMember(struct Expression * exp)
1229 {
1230 unsigned int byReference = 0x0;
1231
1232 for(; exp; )
1233 {
1234 if(exp->type == 5 || exp->type == 34)
1235 {
1236 if((*exp->list).count > 1)
1237 byReference = 0x1;
1238 exp = (*exp->list).last;
1239 }
1240 else if(exp->type == 11)
1241 {
1242 exp = exp->cast.exp;
1243 }
1244 else
1245 {
1246 if(byReference)
1247 FixReference(exp, 0x1);
1248 else
1249 byReference = exp->byReference;
1250 break;
1251 }
1252 }
1253 return byReference;
1254 }
1255
1256 extern struct __ecereNameSpace__ecere__sys__OldList *  MkList(void);
1257
1258 extern char *  strcpy(char * , const char * );
1259
1260 extern void FullClassNameCat(char *  output, char *  className, unsigned int includeTemplateParams);
1261
1262 extern char *  strcat(char * , const char * );
1263
1264 extern void DeclareMethod(struct __ecereNameSpace__ecere__com__Method * method, char *  name);
1265
1266 extern struct Declarator * SpecDeclFromString(char *  string, struct __ecereNameSpace__ecere__sys__OldList *  specs, struct Declarator * baseDecl);
1267
1268 extern struct Declarator * MkDeclaratorBrackets(struct Declarator * declarator);
1269
1270 extern struct Declarator * MkDeclaratorPointer(struct Pointer * pointer, struct Declarator * declarator);
1271
1272 extern struct Pointer * MkPointer(struct __ecereNameSpace__ecere__sys__OldList * qualifiers, struct Pointer * pointer);
1273
1274 extern struct Declarator * GetFuncDecl(struct Declarator * decl);
1275
1276 extern struct TypeName * MkTypeName(struct __ecereNameSpace__ecere__sys__OldList * qualifiers, struct Declarator * declarator);
1277
1278 extern struct __ecereNameSpace__ecere__sys__OldList *  MkListOne(void *  item);
1279
1280 extern struct Specifier * MkSpecifierName(char *  name);
1281
1282 extern void MangleClassName(char *  className);
1283
1284 extern struct Symbol * FindClass(char *  name);
1285
1286 extern void DeclareClass(struct Symbol * classSym, char *  className);
1287
1288 extern struct Expression * MkExpCast(struct TypeName * typeName, struct Expression * expression);
1289
1290 extern struct Expression * MkExpIndex(struct Expression * expression, struct __ecereNameSpace__ecere__sys__OldList * index);
1291
1292 extern struct Expression * MkExpPointer(struct Expression * expression, struct Identifier * member);
1293
1294 extern struct Expression * MkExpIdentifier(struct Identifier * id);
1295
1296 extern struct Identifier * MkIdentifier(char *  string);
1297
1298 extern char *  __ecereNameSpace__ecere__sys__CopyString(char *  string);
1299
1300 extern void ListAdd(struct __ecereNameSpace__ecere__sys__OldList * list, void *  item);
1301
1302 extern struct Expression * MkExpOp(struct Expression * exp1, int op, struct Expression * exp2);
1303
1304 extern struct Expression * MkExpTypeSize(struct TypeName * typeName);
1305
1306 extern struct Expression * MkExpBrackets(struct __ecereNameSpace__ecere__sys__OldList * expressions);
1307
1308 extern struct Expression * QMkExpId(char *  id);
1309
1310 extern struct __ecereNameSpace__ecere__com__Property * __ecereNameSpace__ecere__com__eClass_FindProperty(struct __ecereNameSpace__ecere__com__Class * _class, char *  name, struct __ecereNameSpace__ecere__com__Instance * module);
1311
1312 extern struct __ecereNameSpace__ecere__com__Instance * privateModule;
1313
1314 extern void DeclareProperty(struct __ecereNameSpace__ecere__com__Property * prop, char *  setName, char *  getName);
1315
1316 extern int sprintf(char * , char * , ...);
1317
1318 extern struct Context * curContext;
1319
1320 extern struct Type * MkClassType(char *  name);
1321
1322 extern struct __ecereNameSpace__ecere__com__Class * containerClass;
1323
1324 extern unsigned int __ecereNameSpace__ecere__com__eClass_IsDerived(struct __ecereNameSpace__ecere__com__Class * _class, struct __ecereNameSpace__ecere__com__Class * from);
1325
1326 extern struct __ecereNameSpace__ecere__com__DataMember * __ecereNameSpace__ecere__com__eClass_FindDataMember(struct __ecereNameSpace__ecere__com__Class * _class, char *  name, struct __ecereNameSpace__ecere__com__Instance * module, struct __ecereNameSpace__ecere__com__DataMember **  subMemberStack, int *  subMemberStackPos);
1327
1328 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass___ecereNameSpace__ecere__com__BitMember;
1329
1330 struct __ecereNameSpace__ecere__com__BitMember
1331 {
1332 struct __ecereNameSpace__ecere__com__BitMember * prev;
1333 struct __ecereNameSpace__ecere__com__BitMember * next;
1334 char *  name;
1335 unsigned int isProperty;
1336 int memberAccess;
1337 int id;
1338 struct __ecereNameSpace__ecere__com__Class * _class;
1339 char *  dataTypeString;
1340 struct __ecereNameSpace__ecere__com__Class * dataTypeClass;
1341 struct Type * dataType;
1342 int type;
1343 int size;
1344 int pos;
1345 uint64 mask;
1346 } __attribute__ ((gcc_struct));
1347
1348 extern int __ecereNameSpace__ecere__com__GetRuntimePlatform(void);
1349
1350 extern struct Expression * MkExpConstant(char *  string);
1351
1352 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass___ecereNameSpace__ecere__com__ClassProperty;
1353
1354 struct __ecereNameSpace__ecere__com__ClassProperty
1355 {
1356 char *  name;
1357 struct __ecereNameSpace__ecere__com__ClassProperty * parent;
1358 struct __ecereNameSpace__ecere__com__ClassProperty * left;
1359 struct __ecereNameSpace__ecere__com__ClassProperty * right;
1360 int depth;
1361 void (*  Set)(struct __ecereNameSpace__ecere__com__Class *, long long);
1362 long long (*  Get)(struct __ecereNameSpace__ecere__com__Class *);
1363 char *  dataTypeString;
1364 struct Type * dataType;
1365 unsigned int constant;
1366 } __attribute__ ((gcc_struct));
1367
1368 extern struct __ecereNameSpace__ecere__com__ClassProperty * __ecereNameSpace__ecere__com__eClass_FindClassProperty(struct __ecereNameSpace__ecere__com__Class * _class, char *  name);
1369
1370 extern void FreeExpContents(struct Expression * exp);
1371
1372 extern struct Expression * MkExpString(char *  string);
1373
1374 extern char *  QMkString(char *  source);
1375
1376 extern struct Specifier * MkSpecifier(int specifier);
1377
1378 extern void FreeIdentifier(struct Identifier * id);
1379
1380 extern struct Context * PushContext(void);
1381
1382 extern struct Statement * MkCompoundStmt(struct __ecereNameSpace__ecere__sys__OldList * declarations, struct __ecereNameSpace__ecere__sys__OldList * statements);
1383
1384 extern struct Declaration * MkDeclaration(struct __ecereNameSpace__ecere__sys__OldList * specifiers, struct __ecereNameSpace__ecere__sys__OldList * initDeclarators);
1385
1386 extern struct InitDeclarator * MkInitDeclarator(struct Declarator * declarator, struct Initializer * initializer);
1387
1388 extern struct Declarator * MkDeclaratorIdentifier(struct Identifier * id);
1389
1390 extern struct Initializer * MkInitializerAssignment(struct Expression * exp);
1391
1392 extern struct Expression * QBrackets(struct Expression * exp);
1393
1394 extern struct Statement * MkExpressionStmt(struct __ecereNameSpace__ecere__sys__OldList * expressions);
1395
1396 extern struct Expression * MkExpCall(struct Expression * expression, struct __ecereNameSpace__ecere__sys__OldList * arguments);
1397
1398 extern void PopContext(struct Context * ctx);
1399
1400 extern void FreeType(struct Type * type);
1401
1402 extern void Compiler_Error(char *  format, ...);
1403
1404 extern char *  __ecereNameSpace__ecere__GetTranslatedString(struct __ecereNameSpace__ecere__com__Instance * module, char *  string, char *  stringAndContext);
1405
1406 extern struct __ecereNameSpace__ecere__com__Instance * __thisModule;
1407
1408 extern struct __ecereNameSpace__ecere__com__Method * __ecereNameSpace__ecere__com__eClass_FindMethod(struct __ecereNameSpace__ecere__com__Class * _class, char *  name, struct __ecereNameSpace__ecere__com__Instance * module);
1409
1410 extern void ProcessExpressionType(struct Expression * exp);
1411
1412 extern struct Expression * MkExpCondition(struct Expression * cond, struct __ecereNameSpace__ecere__sys__OldList * expressions, struct Expression * elseExp);
1413
1414 extern struct __ecereNameSpace__ecere__sys__OldList *  CopyList(struct __ecereNameSpace__ecere__sys__OldList *  source, void *  (*  CopyFunction)(void * ));
1415
1416 extern struct Expression * GetTemplateArgExp(struct TemplateParameter * param, struct __ecereNameSpace__ecere__com__Class * curClass, unsigned int pointer);
1417
1418 extern struct __ecereNameSpace__ecere__com__Class * thisClass;
1419
1420 extern struct Expression * MkExpMember(struct Expression * expression, struct Identifier * member);
1421
1422 extern struct __ecereNameSpace__ecere__com__Class * __ecereNameSpace__ecere__com__eSystem_FindClass(struct __ecereNameSpace__ecere__com__Instance * module, char *  name);
1423
1424 extern struct Context * globalContext;
1425
1426 extern void FreeSymbol(struct Symbol * symbol);
1427
1428 extern struct TypeName * QMkType(char *  spec, struct Declarator * decl);
1429
1430 extern struct Declarator * QMkPtrDecl(char *  id);
1431
1432 extern struct MemberInit * MkMemberInit(struct __ecereNameSpace__ecere__sys__OldList * ids, struct Initializer * initializer);
1433
1434 extern struct Declaration * MkDeclarationInst(struct Instantiation * inst);
1435
1436 extern struct Instantiation * MkInstantiationNamed(struct __ecereNameSpace__ecere__sys__OldList * specs, struct Expression * exp, struct __ecereNameSpace__ecere__sys__OldList * members);
1437
1438 extern struct MembersInit * MkMembersInitList(struct __ecereNameSpace__ecere__sys__OldList * dataMembers);
1439
1440 extern struct Expression * MkExpExtensionCompound(struct Statement * compound);
1441
1442 extern void ProcessExpressionInstPass(struct Expression * exp);
1443
1444 extern struct Context * SetupTemplatesContext(struct __ecereNameSpace__ecere__com__Class * _class);
1445
1446 extern void FinishTemplatesContext(struct Context * context);
1447
1448 extern struct Specifier * MkStructOrUnion(int type, struct Identifier * id, struct __ecereNameSpace__ecere__sys__OldList * definitions);
1449
1450 extern struct Type * ProcessTypeString(char *  string, unsigned int staticMethod);
1451
1452 extern void PrintTypeNoConst(struct Type * type, char *  string, unsigned int printName, unsigned int fullName);
1453
1454 extern int ComputeTypeSize(struct Type * type);
1455
1456 extern void FreeTypeName(struct TypeName * typeName);
1457
1458 extern struct Type * ProcessType(struct __ecereNameSpace__ecere__sys__OldList * specs, struct Declarator * decl);
1459
1460 extern unsigned int internalValueCounter;
1461
1462 extern int printf(char * , ...);
1463
1464 extern struct Type * ProcessTemplateParameterType(struct TemplateParameter * param);
1465
1466 extern void DeclareStruct(char *  name, unsigned int skipNoHead);
1467
1468 extern void FreeSpecifier(struct Specifier * spec);
1469
1470 static void ProcessStatement(struct Statement * stmt);
1471
1472 extern void FreeList(struct __ecereNameSpace__ecere__sys__OldList * list, void (*  FreeFunction)(void * ));
1473
1474 extern void FreeDeclarator(struct Declarator * decl);
1475
1476 extern char *  StringFromSpecDecl(struct __ecereNameSpace__ecere__sys__OldList * specs, struct Declarator * decl);
1477
1478 static void ProcessInitializer(struct Initializer * init);
1479
1480 unsigned int __ecereMethod___ecereNameSpace__ecere__sys__OldList_Insert(struct __ecereNameSpace__ecere__sys__OldList * this, void *  prevItem, void *  item);
1481
1482 unsigned int __ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_Add(struct __ecereNameSpace__ecere__sys__BinaryTree * this, struct __ecereNameSpace__ecere__sys__BTNode * node);
1483
1484 void __ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_Remove(struct __ecereNameSpace__ecere__sys__BinaryTree * this, struct __ecereNameSpace__ecere__sys__BTNode * node);
1485
1486 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_int;
1487
1488 static void ProcessExpression(struct Expression * exp)
1489 {
1490 struct Location oldyylloc = yylloc;
1491
1492 yylloc = exp->loc;
1493 switch(exp->type)
1494 {
1495 case 0:
1496 {
1497 if(exp->expType && exp->expType->kind == 16)
1498 {
1499 struct __ecereNameSpace__ecere__com__Class * _class = exp->expType->methodClass;
1500 struct __ecereNameSpace__ecere__com__Method * method = exp->expType->method;
1501
1502 if(method->type == 1)
1503 {
1504 char name[1024];
1505 struct TypeName * typeName;
1506 struct Declarator * decl;
1507 struct __ecereNameSpace__ecere__sys__OldList * specs = MkList();
1508
1509 strcpy(name, "__ecereVMethodID_");
1510 FullClassNameCat(name, method->_class->fullName, 0x0);
1511 strcat(name, "_");
1512 strcat(name, method->name);
1513 DeclareMethod(method, name);
1514 decl = SpecDeclFromString(method->dataTypeString, specs, MkDeclaratorBrackets(MkDeclaratorPointer(MkPointer((((void *)0)), (((void *)0))), (((void *)0)))));
1515 if(!method->dataType->staticMethod)
1516 {
1517 struct Declarator * funcDecl = GetFuncDecl(decl);
1518
1519 if(!funcDecl->function.parameters)
1520 funcDecl->function.parameters = MkList();
1521 {
1522 struct TypeName * firstParam = ((struct TypeName *)(*funcDecl->function.parameters).first);
1523 struct Specifier * firstSpec = firstParam ? (*firstParam->qualifiers).first : (((void *)0));
1524
1525 if(firstParam && firstSpec->type == 0 && firstSpec->specifier == VOID && !firstParam->declarator)
1526 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Remove((&*funcDecl->function.parameters), (*funcDecl->function.parameters).first);
1527 }
1528 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Insert((&*funcDecl->function.parameters), (((void *)0)), MkTypeName(MkListOne(MkSpecifierName(method->dataType->thisClass ? method->dataType->thisClass->string : method->_class->fullName)), (((void *)0))));
1529 }
1530 typeName = MkTypeName(specs, decl);
1531 if(_class)
1532 {
1533 char className[1024];
1534
1535 strcpy(className, "__ecereClass_");
1536 FullClassNameCat(className, _class->fullName, 0x1);
1537 MangleClassName(className);
1538 if(!_class->symbol)
1539 _class->symbol = FindClass(_class->fullName);
1540 DeclareClass(_class->symbol, className);
1541 exp->type = 5;
1542 exp->list = MkListOne(MkExpCast(typeName, MkExpIndex(MkExpPointer(MkExpIdentifier(MkIdentifier(className)), MkIdentifier("_vTbl")), MkListOne(MkExpIdentifier(MkIdentifier(name))))));
1543 }
1544 }
1545 else
1546 {
1547 char name[1024];
1548
1549 strcpy(name, "__ecereMethod_");
1550 FullClassNameCat(name, method->_class->fullName, 0x0);
1551 strcat(name, "_");
1552 strcat(name, method->name);
1553 (__ecereNameSpace__ecere__com__eSystem_Delete(exp->identifier->string), exp->identifier->string = 0);
1554 exp->identifier->_class = (((void *)0));
1555 exp->identifier->string = __ecereNameSpace__ecere__sys__CopyString(name);
1556 DeclareMethod(method, name);
1557 }
1558 }
1559 break;
1560 }
1561 case 2:
1562 break;
1563 case 3:
1564 break;
1565 case 13:
1566 case 28:
1567 case 14:
1568 case 29:
1569 {
1570 struct __ecereNameSpace__ecere__sys__OldList * args = MkList();
1571
1572 if(exp->type == 14 || exp->type == 29)
1573 ListAdd(args, exp->_renew.exp);
1574 ListAdd(args, MkExpOp(MkExpTypeSize(exp->_new.typeName), '*', MkExpBrackets(MkListOne(exp->_new.size))));
1575 switch(exp->type)
1576 {
1577 case 13:
1578 exp->call.exp = QMkExpId("ecere::com::eSystem_New");
1579 break;
1580 case 28:
1581 exp->call.exp = QMkExpId("ecere::com::eSystem_New0");
1582 break;
1583 case 14:
1584 exp->call.exp = QMkExpId("ecere::com::eSystem_Renew");
1585 break;
1586 case 29:
1587 exp->call.exp = QMkExpId("ecere::com::eSystem_Renew0");
1588 break;
1589 }
1590 exp->call.arguments = args;
1591 exp->type = 7;
1592 ProcessExpression(exp);
1593 break;
1594 }
1595 case 4:
1596 {
1597 struct Expression * exp1 = exp->op.exp1;
1598 struct Expression * exp2 = exp->op.exp2;
1599
1600 switch(exp->op.op)
1601 {
1602 case '=':
1603 if(exp->op.exp2)
1604 exp->op.exp2->usage = (exp->op.exp2->usage & ~0x1) | (((unsigned int)0x1) << 0);
1605 break;
1606 case MUL_ASSIGN:
1607 case DIV_ASSIGN:
1608 case MOD_ASSIGN:
1609 case ADD_ASSIGN:
1610 case SUB_ASSIGN:
1611 case LEFT_ASSIGN:
1612 case RIGHT_ASSIGN:
1613 case AND_ASSIGN:
1614 case XOR_ASSIGN:
1615 case OR_ASSIGN:
1616 exp->op.exp2->usage = (exp->op.exp2->usage & ~0x1) | (((unsigned int)0x1) << 0);
1617 break;
1618 case INC_OP:
1619 case DEC_OP:
1620 case '&':
1621 if(exp->op.exp1 && exp->op.exp2)
1622 {
1623 exp->op.exp1->usage = (exp->op.exp1->usage & ~0x1) | (((unsigned int)0x1) << 0);
1624 exp->op.exp2->usage = (exp->op.exp2->usage & ~0x1) | (((unsigned int)0x1) << 0);
1625 }
1626 else if(exp->op.exp2)
1627 {
1628 exp->op.exp2->usage = (exp->op.exp2->usage & ~0x40) | (((unsigned int)0x1) << 6);
1629 }
1630 break;
1631 case '*':
1632 case '+':
1633 case '-':
1634 if(exp->op.exp1)
1635 {
1636 exp->op.exp1->usage = (exp->op.exp1->usage & ~0x1) | (((unsigned int)0x1) << 0);
1637 }
1638 case '~':
1639 case '!':
1640 if(exp->op.exp2)
1641 exp->op.exp2->usage = (exp->op.exp2->usage & ~0x1) | (((unsigned int)0x1) << 0);
1642 break;
1643 case '/':
1644 case '%':
1645 case LEFT_OP:
1646 case RIGHT_OP:
1647 case '<':
1648 case '>':
1649 case LE_OP:
1650 case GE_OP:
1651 case EQ_OP:
1652 case NE_OP:
1653 case '|':
1654 case '^':
1655 case AND_OP:
1656 case OR_OP:
1657 if(exp->op.exp1)
1658 exp->op.exp1->usage = (exp->op.exp1->usage & ~0x1) | (((unsigned int)0x1) << 0);
1659 if(exp->op.exp2)
1660 exp->op.exp2->usage = (exp->op.exp2->usage & ~0x1) | (((unsigned int)0x1) << 0);
1661 break;
1662 }
1663 if(exp->op.op == '=' || exp->op.op == MUL_ASSIGN || exp->op.op == DIV_ASSIGN || exp->op.op == ADD_ASSIGN || exp->op.op == MOD_ASSIGN || exp->op.op == SUB_ASSIGN || exp->op.op == LEFT_ASSIGN || exp->op.op == RIGHT_ASSIGN || exp->op.op == AND_ASSIGN || exp->op.op == OR_ASSIGN || exp->op.op == XOR_ASSIGN || exp->op.op == INC_OP || exp->op.op == DEC_OP)
1664 {
1665 struct Expression * memberExp;
1666 struct Expression * parentExp = (((void *)0));
1667
1668 if(exp->op.exp1 && exp->op.exp1->type == 8)
1669 {
1670 struct Expression * testExp, * topExp = (((void *)0));
1671 struct Expression * lastExp = exp->op.exp1, * parentExp = (((void *)0));
1672 struct __ecereNameSpace__ecere__com__Property * lastProperty = (((void *)0));
1673 struct __ecereNameSpace__ecere__com__Class * propertyClass;
1674 char setName[1024], getName[1024];
1675
1676 testExp = exp->op.exp1->member.exp;
1677 while(0x1)
1678 {
1679 while(testExp)
1680 {
1681 if(testExp->type == 11)
1682 testExp = testExp->cast.exp;
1683 else if(testExp->type == 5 || testExp->type == 34)
1684 testExp = (*testExp->list).last;
1685 else if(testExp->type == 8)
1686 break;
1687 else
1688 testExp = (((void *)0));
1689 }
1690 if(!testExp)
1691 break;
1692 if(testExp->member.memberType == 1 || testExp->member.memberType == 4)
1693 {
1694 struct Type * type = testExp->member.exp->expType;
1695
1696 if(type)
1697 {
1698 if(type->kind == 8)
1699 {
1700 struct __ecereNameSpace__ecere__com__Class * _class = testExp->member.member->classSym ? testExp->member.member->classSym->registered : type->_class->registered;
1701 struct __ecereNameSpace__ecere__com__Class * convertTo = (((void *)0));
1702
1703 if(testExp->member.memberType == 4)
1704 {
1705 convertTo = _class;
1706 _class = FindClass(testExp->member.member->string)->registered;
1707 lastProperty = __ecereNameSpace__ecere__com__eClass_FindProperty(_class, convertTo->fullName, privateModule);
1708 }
1709 else
1710 {
1711 lastProperty = __ecereNameSpace__ecere__com__eClass_FindProperty(_class, testExp->member.member->string, privateModule);
1712 }
1713 if(lastProperty && lastProperty->Get && lastProperty->Set)
1714 {
1715 DeclareProperty(lastProperty, setName, getName);
1716 propertyClass = convertTo ? _class : ((((struct Symbol *)lastProperty->symbol)->type && ((struct Symbol *)lastProperty->symbol)->type->kind == 8) ? ((struct Symbol *)lastProperty->symbol)->type->_class->registered : ((struct Symbol *)lastProperty->symbol)->_class);
1717 if(propertyClass && propertyClass->type == 1)
1718 {
1719 topExp = testExp;
1720 parentExp = lastExp;
1721 }
1722 else if(propertyClass && propertyClass->type == 2)
1723 {
1724 topExp = testExp;
1725 parentExp = lastExp;
1726 }
1727 }
1728 }
1729 }
1730 }
1731 lastExp = testExp;
1732 testExp = testExp->member.exp;
1733 }
1734 if(topExp)
1735 {
1736 if(propertyClass->type == 1)
1737 {
1738 struct Expression * copy;
1739 struct Expression * value;
1740 char className[1024];
1741 struct Expression * tempExp;
1742
1743 sprintf(className, "__simpleStruct%d", curContext->simpleID);
1744 tempExp = QMkExpId(className);
1745 tempExp->expType = MkClassType(propertyClass->fullName);
1746 parentExp->member.exp = tempExp;
1747 value = MkExpBrackets(MkList());
1748 copy = CopyExpression(topExp);
1749 copy->usage = (copy->usage & ~0x1) | (((unsigned int)0x1) << 0);
1750 copy->usage = (copy->usage & ~0x20) | (((unsigned int)0x1) << 5);
1751 ListAdd(value->list, copy);
1752 ListAdd(value->list, MkExpOp(exp->op.exp1, exp->op.op, exp->op.exp2));
1753 ListAdd(value->list, CopyExpression(tempExp));
1754 value->expType = tempExp->expType;
1755 tempExp->expType->refCount++;
1756 exp->op.exp1 = topExp;
1757 exp->op.exp2 = value;
1758 exp->op.op = '=';
1759 exp1 = exp->op.exp1;
1760 exp2 = exp->op.exp2;
1761 }
1762 else if(propertyClass->type == 2)
1763 {
1764 struct Expression * copy;
1765 struct Expression * value;
1766 char className[1024];
1767 struct Expression * tempExp;
1768
1769 sprintf(className, "__simpleStruct%d", curContext->simpleID);
1770 tempExp = QMkExpId(className);
1771 tempExp->expType = MkClassType(propertyClass->fullName);
1772 parentExp->member.exp = tempExp;
1773 value = MkExpBrackets(MkList());
1774 copy = CopyExpression(topExp);
1775 copy->usage = (copy->usage & ~0x1) | (((unsigned int)0x1) << 0);
1776 copy->usage = (copy->usage & ~0x20) | (((unsigned int)0x1) << 5);
1777 ListAdd(value->list, copy);
1778 ListAdd(value->list, MkExpOp(exp->op.exp1, exp->op.op, exp->op.exp2));
1779 ListAdd(value->list, CopyExpression(tempExp));
1780 value->expType = tempExp->expType;
1781 value->expType->refCount++;
1782 exp->op.exp1 = topExp;
1783 exp->op.exp2 = value;
1784 exp->op.op = '=';
1785 exp1 = exp->op.exp1;
1786 exp2 = exp->op.exp2;
1787 }
1788 }
1789 }
1790 memberExp = exp->op.exp1;
1791 while(memberExp && ((memberExp->type == 5 && (*memberExp->list).count == 1) || memberExp->type == 34 || memberExp->type == 25))
1792 {
1793 parentExp = memberExp;
1794 if(memberExp->type == 25)
1795 memberExp = (*((struct Statement *)(*memberExp->compound->compound.statements).last)->expressions).last;
1796 else
1797 memberExp = (*memberExp->list).last;
1798 }
1799 if(memberExp && memberExp->type == 6 && memberExp->index.exp && memberExp->index.exp->expType && memberExp->index.exp->expType->kind == 8 && memberExp->index.exp->expType->_class && memberExp->index.exp->expType->_class->registered && memberExp->index.exp->expType->_class->registered != containerClass && __ecereNameSpace__ecere__com__eClass_IsDerived(memberExp->index.exp->expType->_class->registered, containerClass))
1800 {
1801 ProcessExpression(memberExp);
1802 while(memberExp && ((memberExp->type == 5 && (*memberExp->list).count == 1) || memberExp->type == 34 || memberExp->type == 25))
1803 {
1804 parentExp = memberExp;
1805 if(memberExp->type == 25)
1806 memberExp = (*((struct Statement *)(*memberExp->compound->compound.statements).last)->expressions).last;
1807 else
1808 memberExp = (*memberExp->list).last;
1809 }
1810 if(memberExp && memberExp->type == 25)
1811 {
1812 parentExp = memberExp;
1813 if(memberExp->type == 25)
1814 {
1815 struct Statement * stmt = memberExp->compound->compound.statements ? (*memberExp->compound->compound.statements).last : (((void *)0));
1816
1817 if(stmt && stmt->type != 3)
1818 stmt = (((void *)0));
1819 memberExp = (stmt && stmt->expressions) ? (*stmt->expressions).last : (((void *)0));
1820 if(memberExp)
1821 {
1822 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Remove((&*stmt->expressions), memberExp);
1823 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Add((&*stmt->expressions), MkExpOp(memberExp, exp->op.op, exp->op.exp2));
1824 exp->type = 5;
1825 exp->list = MkListOne(parentExp);
1826 ProcessExpression(exp);
1827 break;
1828 }
1829 }
1830 else
1831 memberExp = (*memberExp->list).last;
1832 }
1833 }
1834 if(memberExp && memberExp->type != 8)
1835 memberExp = (((void *)0));
1836 if(memberExp && memberExp->type == 8)
1837 {
1838 struct Type * type = memberExp->member.exp->expType;
1839
1840 if(type)
1841 {
1842 if(type->kind == 8 || type->kind == 19)
1843 {
1844 struct __ecereNameSpace__ecere__com__Class * _class = memberExp->member.member->classSym ? (memberExp->member.member->classSym ? memberExp->member.member->classSym->registered : (((void *)0))) : (type->_class ? type->_class->registered : (((void *)0)));
1845
1846 if(memberExp == exp1)
1847 exp1 = (((void *)0));
1848 else
1849 {
1850 if(parentExp->type == 25)
1851 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Remove((&*((struct Statement *)(*parentExp->compound->compound.statements).last)->expressions), memberExp);
1852 else
1853 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Remove((&*parentExp->list), memberExp);
1854 }
1855 if(_class && _class->type == 2 && memberExp->member.memberType == 3)
1856 {
1857 struct __ecereNameSpace__ecere__com__BitMember * bitMember = (struct __ecereNameSpace__ecere__com__BitMember *)__ecereNameSpace__ecere__com__eClass_FindDataMember(_class, memberExp->member.member->string, privateModule, (((void *)0)), (((void *)0)));
1858 char mask[32], shift[10];
1859 struct __ecereNameSpace__ecere__sys__OldList * specs = MkList();
1860 struct Declarator * decl = SpecDeclFromString(_class->dataTypeString, specs, (((void *)0)));
1861 struct TypeName * type = MkTypeName(specs, decl);
1862
1863 if(bitMember->mask > (0xffffffff))
1864 sprintf(mask, ((__ecereNameSpace__ecere__com__GetRuntimePlatform() == 1) ? "0x%I64XLL" : "0x%llXLL"), bitMember->mask);
1865 else
1866 sprintf(mask, ((__ecereNameSpace__ecere__com__GetRuntimePlatform() == 1) ? "0x%I64X" : "0x%llX"), bitMember->mask);
1867 sprintf(shift, "%d", bitMember->pos);
1868 exp->op.exp1 = memberExp->member.exp;
1869 if(exp->op.op == XOR_ASSIGN)
1870 {
1871 exp->op.exp2 = MkExpOp(MkExpBrackets(MkListOne(MkExpCast(type, exp->op.exp2))), LEFT_OP, MkExpConstant(shift));
1872 }
1873 else
1874 {
1875 exp->op.exp2 = MkExpOp(MkExpBrackets(MkListOne(MkExpOp(CopyExpression(memberExp->member.exp), '&', MkExpOp((((void *)0)), '~', MkExpConstant(mask))))), '|', MkExpBrackets(MkListOne(MkExpOp(MkExpBrackets(MkListOne(MkExpCast(type, exp->op.exp2))), LEFT_OP, MkExpConstant(shift)))));
1876 }
1877 memberExp->member.exp = (((void *)0));
1878 FreeExpression(memberExp);
1879 ProcessExpression(exp);
1880 return ;
1881 }
1882 else if(_class && _class->type == 3 && memberExp->member.memberType == 3)
1883 {
1884 }
1885 else if(memberExp->member.memberType != 3)
1886 {
1887 struct __ecereNameSpace__ecere__com__Property * prop;
1888 struct __ecereNameSpace__ecere__com__Class * convertTo = (((void *)0));
1889 struct __ecereNameSpace__ecere__com__ClassProperty * classProperty = (((void *)0));
1890
1891 if(memberExp->member.memberType == 4)
1892 {
1893 convertTo = _class;
1894 _class = FindClass(memberExp->member.member->string)->registered;
1895 prop = __ecereNameSpace__ecere__com__eClass_FindProperty(_class, convertTo->fullName, privateModule);
1896 }
1897 else
1898 prop = __ecereNameSpace__ecere__com__eClass_FindProperty(_class, memberExp->member.member->string, privateModule);
1899 if(memberExp->member.memberType == 5)
1900 classProperty = __ecereNameSpace__ecere__com__eClass_FindClassProperty(_class, memberExp->member.member->string);
1901 exp->tempCount = memberExp->member.exp->tempCount;
1902 if(classProperty)
1903 {
1904 if(classProperty->Set)
1905 {
1906 struct Identifier * id = memberExp->member.member;
1907 struct Expression * classExp = memberExp->member.exp;
1908 struct Expression * value = exp->op.exp2;
1909
1910 memberExp->member.exp = (((void *)0));
1911 memberExp->member.member = (((void *)0));
1912 exp->op.exp2 = (((void *)0));
1913 FreeExpContents(memberExp);
1914 exp->type = 7;
1915 exp->call.exp = MkExpIdentifier(MkIdentifier("ecere::com::eClass_SetProperty"));
1916 exp->call.arguments = MkList();
1917 ListAdd(exp->call.arguments, classExp);
1918 ListAdd(exp->call.arguments, MkExpString(QMkString(id->string)));
1919 ListAdd(exp->call.arguments, MkExpCast(MkTypeName(MkListOne(MkSpecifier(INT64)), (((void *)0))), value));
1920 FreeIdentifier(id);
1921 ProcessExpression(exp);
1922 return ;
1923 }
1924 }
1925 else if(prop)
1926 {
1927 if((!convertTo && prop->Set) || (convertTo && prop->Get))
1928 {
1929 struct Expression * value = exp->op.exp2;
1930 char setName[1024], getName[1024];
1931 char * setToUse = convertTo ? getName : setName;
1932 char * getToUse = convertTo ? setName : getName;
1933 unsigned int needAddress = 0x0;
1934 int operator = exp->op.op;
1935
1936 switch(operator)
1937 {
1938 case MUL_ASSIGN:
1939 operator = '*';
1940 break;
1941 case DIV_ASSIGN:
1942 operator = '/';
1943 break;
1944 case MOD_ASSIGN:
1945 operator = '%';
1946 break;
1947 case SUB_ASSIGN:
1948 operator = '-';
1949 break;
1950 case ADD_ASSIGN:
1951 operator = '+';
1952 break;
1953 case LEFT_ASSIGN:
1954 operator = LEFT_OP;
1955 break;
1956 case RIGHT_ASSIGN:
1957 operator = RIGHT_OP;
1958 break;
1959 case AND_ASSIGN:
1960 operator = '&';
1961 break;
1962 case OR_ASSIGN:
1963 operator = '|';
1964 break;
1965 case XOR_ASSIGN:
1966 operator = '^';
1967 break;
1968 }
1969 if(operator != '=')
1970 {
1971 if(operator == INC_OP)
1972 value = MkExpOp(CopyExpression(memberExp), '+', MkExpConstant("1"));
1973 else if(operator == DEC_OP)
1974 value = MkExpOp(CopyExpression(memberExp), '-', MkExpConstant("1"));
1975 else
1976 {
1977 value = MkExpOp(CopyExpression(memberExp), operator, value);
1978 exp2 = (((void *)0));
1979 }
1980 value->expType = memberExp->expType;
1981 memberExp->expType->refCount++;
1982 value->usage = (value->usage & ~0x4) | (((unsigned int)0x1) << 2);
1983 }
1984 else if(value)
1985 {
1986 exp2 = (((void *)0));
1987 }
1988 if(value)
1989 value->usage = (value->usage & ~0x4) | (((unsigned int)0x1) << 2);
1990 DeclareProperty(prop, setName, getName);
1991 if(memberExp->member.exp)
1992 ProcessExpression(memberExp->member.exp);
1993 if(((unsigned int)((exp->usage & 0x1) >> 0)) && ((!convertTo && prop->Get) || (convertTo && prop->Set)))
1994 {
1995 int __simpleStruct0, __simpleStruct1;
1996 struct __ecereNameSpace__ecere__sys__OldList * list = MkList();
1997 struct __ecereNameSpace__ecere__sys__OldList * args;
1998 char ecereTemp[100];
1999 struct Context * context = PushContext();
2000
2001 exp->tempCount++;
2002 curExternal->function->tempCount = (__simpleStruct0 = curExternal->function->tempCount, __simpleStruct1 = exp->tempCount, (__simpleStruct0 > __simpleStruct1) ? __simpleStruct0 : __simpleStruct1);
2003 sprintf(ecereTemp, "__ecTemp%d", exp->tempCount);
2004 curContext = context;
2005 exp->type = 25;
2006 exp->compound = MkCompoundStmt(MkListOne(MkDeclaration(MkListOne(MkSpecifier(VOID)), MkListOne(MkInitDeclarator(MkDeclaratorPointer(MkPointer((((void *)0)), (((void *)0))), MkDeclaratorIdentifier(MkIdentifier(ecereTemp))), MkInitializerAssignment(QBrackets(memberExp->member.exp)))))), list);
2007 args = MkList();
2008 if(convertTo)
2009 {
2010 ListAdd(args, value);
2011 ListAdd(args, QMkExpId(ecereTemp));
2012 ListAdd(list, MkExpressionStmt(MkListOne(MkExpCall(QMkExpId(getName), args))));
2013 }
2014 else
2015 {
2016 ListAdd(args, QMkExpId(ecereTemp));
2017 ListAdd(args, value);
2018 ListAdd(list, MkExpressionStmt(MkListOne(MkExpCall(QMkExpId(setName), args))));
2019 }
2020 args = MkList();
2021 if(convertTo)
2022 ListAdd(args, QMkExpId(ecereTemp));
2023 else
2024 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Insert((&*args), (((void *)0)), QMkExpId(ecereTemp));
2025 ListAdd(list, MkExpressionStmt(MkListOne(MkExpCall(QMkExpId(getToUse), args))));
2026 exp->compound->compound.context = context;
2027 PopContext(context);
2028 curContext = context->parent;
2029 }
2030 else
2031 {
2032 struct Expression * newExp = exp;
2033
2034 if(parentExp && parentExp->type == 25)
2035 {
2036 newExp = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass_Expression);
2037 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Add((&*((struct Statement *)(*parentExp->compound->compound.statements).last)->expressions), newExp);
2038 FreeType(exp->expType);
2039 FreeType(exp->destType);
2040 *exp = *parentExp;
2041 parentExp->type = 16;
2042 parentExp->expType = (((void *)0));
2043 parentExp->destType = (((void *)0));
2044 }
2045 newExp->type = 7;
2046 newExp->call.exp = QMkExpId(setToUse);
2047 newExp->call.arguments = MkList();
2048 if(convertTo)
2049 {
2050 ListAdd(newExp->call.arguments, value);
2051 ListAdd(newExp->call.arguments, FixReference(memberExp->member.exp, 0x1));
2052 }
2053 else
2054 {
2055 ListAdd(newExp->call.arguments, FixReference(memberExp->member.exp, 0x1));
2056 ListAdd(newExp->call.arguments, value);
2057 }
2058 needAddress = 0x1;
2059 }
2060 memberExp->member.exp = (((void *)0));
2061 if(value)
2062 {
2063 value->tempCount = exp->tempCount;
2064 ProcessExpression(value);
2065 if(needAddress)
2066 FixReference(value, 0x1);
2067 }
2068 FreeExpression(memberExp);
2069 }
2070 else
2071 {
2072 struct __ecereNameSpace__ecere__com__DataMember * member = __ecereNameSpace__ecere__com__eClass_FindDataMember(_class, memberExp->member.member->string, privateModule, (((void *)0)), (((void *)0)));
2073
2074 if(member)
2075 {
2076 memberExp->member.memberType = 3;
2077 }
2078 else
2079 Compiler_Error(__ecereNameSpace__ecere__GetTranslatedString(__thisModule, "no set defined for property %s of class %s\n", (((void *)0))), prop->name, prop->_class->fullName);
2080 }
2081 }
2082 else
2083 {
2084 struct __ecereNameSpace__ecere__com__Method * method = __ecereNameSpace__ecere__com__eClass_FindMethod(_class, memberExp->member.member->string, privateModule);
2085
2086 if(method && method->type == 1 && type->kind != 19)
2087 {
2088 struct Expression * value = exp->op.exp2;
2089
2090 value->tempCount = exp->tempCount;
2091 ProcessExpression(value);
2092 if(memberExp->member.exp)
2093 ProcessExpression(memberExp->member.exp);
2094 if(((unsigned int)((exp->usage & 0x1) >> 0)))
2095 {
2096 struct __ecereNameSpace__ecere__sys__OldList * list = MkList();
2097 struct __ecereNameSpace__ecere__sys__OldList * args;
2098
2099 args = MkList();
2100 ListAdd(args, memberExp->member.exp);
2101 {
2102 char * string = QMkString(memberExp->member.member->string);
2103
2104 ListAdd(args, MkExpString(string));
2105 (__ecereNameSpace__ecere__com__eSystem_Delete(string), string = 0);
2106 }
2107 ListAdd(args, value);
2108 ListAdd(list, MkExpCall(QMkExpId("ecere::com::eInstance_SetMethod"), args));
2109 ListAdd(list, CopyExpression(value));
2110 exp->type = 5;
2111 exp->list = list;
2112 }
2113 else
2114 {
2115 exp->type = 7;
2116 exp->call.exp = QMkExpId("ecere::com::eInstance_SetMethod");
2117 exp->call.arguments = MkList();
2118 ListAdd(exp->call.arguments, memberExp->member.exp);
2119 {
2120 char * string = QMkString(memberExp->member.member->string);
2121
2122 ListAdd(exp->call.arguments, MkExpString(string));
2123 (__ecereNameSpace__ecere__com__eSystem_Delete(string), string = 0);
2124 }
2125 ListAdd(exp->call.arguments, value);
2126 }
2127 memberExp->member.exp = (((void *)0));
2128 exp2 = (((void *)0));
2129 FreeExpression(memberExp);
2130 }
2131 }
2132 }
2133 else if(memberExp->member.memberType == 3)
2134 {
2135 if(FixMember(memberExp->member.exp))
2136 {
2137 ProcessExpression(memberExp);
2138 memberExp->type = 9;
2139 }
2140 }
2141 }
2142 }
2143 }
2144 }
2145 else if(exp->op.op == _INCREF)
2146 {
2147 struct Expression * object = exp->op.exp2;
2148
2149 exp->op.exp2 = (((void *)0));
2150 FreeExpContents(exp);
2151 exp->expType = (((void *)0));
2152 exp->destType = (((void *)0));
2153 exp->op.op = INC_OP;
2154 exp->op.exp1 = MkExpPointer(object, MkIdentifier("_refCount"));
2155 }
2156 else if(exp->op.op == DELETE)
2157 {
2158 struct Expression * object = exp->op.exp2;
2159 struct __ecereNameSpace__ecere__sys__OldList * args = MkList();
2160
2161 exp->type = 5;
2162 exp->list = MkList();
2163 object->usage = (object->usage & ~0x80) | (((unsigned int)0x1) << 7);
2164 ProcessExpression(object);
2165 ListAdd(args, object);
2166 if(exp->expType && exp->expType->kind == 8 && exp->expType->_class && exp->expType->_class->registered && exp->expType->_class->registered->type == 0 && strcmp(exp->expType->_class->registered->dataTypeString, "char *"))
2167 {
2168 struct Expression * decRefExp = MkExpCall(QMkExpId("ecere::com::eInstance_DecRef"), args);
2169
2170 ProcessExpressionType(decRefExp);
2171 ListAdd(exp->list, decRefExp);
2172 }
2173 else if(exp->expType && exp->expType->kind == 8 && exp->expType->_class && exp->expType->_class->registered && exp->expType->_class->registered->type == 5)
2174 {
2175 struct __ecereNameSpace__ecere__sys__OldList * list = MkList();
2176 struct __ecereNameSpace__ecere__com__Class * _class;
2177
2178 for(_class = exp->expType->_class->registered; _class && _class->type == 5; _class = _class->base)
2179 {
2180 char className[1024];
2181
2182 if(_class->templateClass)
2183 _class = _class->templateClass;
2184 strcpy(className, "__ecereClass_");
2185 FullClassNameCat(className, _class->fullName, 0x0);
2186 MangleClassName(className);
2187 if(!_class->symbol)
2188 _class->symbol = FindClass(_class->fullName);
2189 DeclareClass(_class->symbol, className);
2190 ListAdd(list, MkExpCondition(MkExpPointer(QMkExpId(className), MkIdentifier("Destructor")), MkListOne(MkExpCall(MkExpPointer(QMkExpId(className), MkIdentifier("Destructor")), CopyList(args, CopyExpression))), MkExpConstant("0")));
2191 }
2192 ListAdd(list, MkExpCall(QMkExpId("ecere::com::eSystem_Delete"), args));
2193 ListAdd(exp->list, MkExpBrackets(MkListOne(MkExpCondition(CopyExpression(object), MkListOne(MkExpBrackets(list)), MkExpConstant("0")))));
2194 }
2195 else if(exp->expType && exp->expType->kind == 20)
2196 {
2197 struct Expression * argExp = GetTemplateArgExp(exp->expType->templateParameter, thisClass, 0x0);
2198
2199 if(argExp)
2200 {
2201 struct Expression * classExp = MkExpMember(argExp, MkIdentifier("dataTypeClass"));
2202 struct TypeName * typeName;
2203 struct __ecereNameSpace__ecere__sys__OldList * qualifiers = MkList();
2204 struct Declarator * declarator = SpecDeclFromString("void (*)(void * _class, void * data)", qualifiers, (((void *)0)));
2205
2206 typeName = MkTypeName(qualifiers, declarator);
2207 ProcessExpressionType(classExp);
2208 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Insert((&*args), (((void *)0)), CopyExpression(classExp));
2209 DeclareMethod(__ecereNameSpace__ecere__com__eClass_FindMethod(__ecereNameSpace__ecere__com__eSystem_FindClass(privateModule, "class"), "OnFree", privateModule), "__ecereVMethodID_class_OnFree");
2210 ListAdd(exp->list, MkExpCall(MkExpBrackets(MkListOne(MkExpCast(typeName, MkExpIndex(MkExpPointer(classExp, MkIdentifier("_vTbl")), MkListOne(MkExpIdentifier(MkIdentifier("__ecereVMethodID_class_OnFree"))))))), args));
2211 }
2212 }
2213 else
2214 ListAdd(exp->list, MkExpCall(QMkExpId("ecere::com::eSystem_Delete"), args));
2215 ListAdd(exp->list, MkExpOp(CopyExpression(object), '=', MkExpConstant("0")));
2216 exp2 = (((void *)0));
2217 ProcessExpression(exp);
2218 }
2219 if(exp->type == 4)
2220 {
2221 if(exp->op.op == '=' && exp->op.exp1 && exp->op.exp1->expType && exp->op.exp1->expType->kind == 20 && (exp->op.exp1->type == 6 || (exp->op.exp1->type == 4 && exp->op.exp1->op.op == '*' && !exp->op.exp1->op.exp1)))
2222 {
2223 struct Expression * argExp = GetTemplateArgExp(exp->op.exp1->expType->templateParameter, thisClass, 0x0);
2224
2225 if(argExp)
2226 {
2227 struct Expression * classExp = MkExpMember(argExp, MkIdentifier("dataTypeClass"));
2228 struct __ecereNameSpace__ecere__sys__OldList * args = MkList();
2229 struct Expression * derefExp = exp->op.exp1;
2230 struct Expression * sizeExp = MkExpCondition(MkExpBrackets(MkListOne(MkExpOp(MkExpOp(MkExpMember(CopyExpression(classExp), MkIdentifier("type")), EQ_OP, MkExpIdentifier(MkIdentifier("normalClass"))), OR_OP, MkExpOp(MkExpMember(CopyExpression(classExp), MkIdentifier("type")), EQ_OP, MkExpIdentifier(MkIdentifier("noHeadClass")))))), MkListOne(MkExpTypeSize(MkTypeName(MkListOne(MkSpecifier(VOID)), MkDeclaratorPointer(MkPointer((((void *)0)), (((void *)0))), (((void *)0)))))), MkExpMember(CopyExpression(classExp), MkIdentifier("typeSize")));
2231
2232 if(exp->op.exp1->type == 6)
2233 {
2234 struct Expression * indexExp = derefExp->index.exp;
2235 struct __ecereNameSpace__ecere__sys__OldList * indexExpIndex = derefExp->index.index;
2236
2237 derefExp->index.index = (((void *)0));
2238 derefExp->index.exp = (((void *)0));
2239 FreeExpression(derefExp);
2240 derefExp = MkExpOp(MkExpCast(MkTypeName(MkListOne(MkSpecifier(CHAR)), MkDeclaratorPointer(MkPointer((((void *)0)), (((void *)0))), (((void *)0)))), indexExp), '+', MkExpBrackets(MkListOne(MkExpOp(MkExpBrackets(indexExpIndex), '*', MkExpBrackets(MkListOne(CopyExpression(sizeExp)))))));
2241 }
2242 else
2243 {
2244 struct Expression * indexExp = derefExp->op.exp2;
2245
2246 derefExp->op.exp2 = (((void *)0));
2247 FreeExpression(derefExp);
2248 derefExp = indexExp;
2249 }
2250 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Add((&*args), derefExp);
2251 ProcessExpressionType((*args).last);
2252 ProcessExpression((*args).last);
2253 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Add((&*args), MkExpCast(MkTypeName(MkListOne(MkSpecifier(CHAR)), MkDeclaratorPointer(MkPointer((((void *)0)), (((void *)0))), (((void *)0)))), MkExpCondition(MkExpBrackets(MkListOne(MkExpOp(MkExpMember(classExp, MkIdentifier("type")), EQ_OP, MkExpIdentifier(MkIdentifier("structClass"))))), MkListOne(exp->op.exp2), MkExpOp((((void *)0)), '&', CopyExpression(exp->op.exp2)))));
2254 thisClass = curExternal->function ? curExternal->function->_class : (((void *)0));
2255 {
2256 struct Symbol * thisSymbol = (thisSymbol = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass_Symbol), thisSymbol->string = __ecereNameSpace__ecere__sys__CopyString("this"), thisSymbol->type = MkClassType(thisClass->fullName), thisSymbol);
2257
2258 __ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_Add(&globalContext->symbols, (struct __ecereNameSpace__ecere__sys__BTNode *)thisSymbol);
2259 ProcessExpressionType((*args).last);
2260 ProcessExpression((*args).last);
2261 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Add((&*args), sizeExp);
2262 ProcessExpressionType((*args).last);
2263 ProcessExpression((*args).last);
2264 exp->list = MkListOne(MkExpCall(MkExpIdentifier(MkIdentifier("memcpy")), args));
2265 exp->type = 5;
2266 __ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_Remove(&globalContext->symbols, (struct __ecereNameSpace__ecere__sys__BTNode *)thisSymbol);
2267 FreeSymbol(thisSymbol);
2268 }
2269 thisClass = (((void *)0));
2270 return ;
2271 }
2272 }
2273 else if(exp->op.op == '*' && !exp->op.exp1 && exp->op.exp2 && exp->op.exp2->expType && exp->op.exp2->expType->kind == 13 && exp->op.exp2->expType->type && exp->op.exp2->expType->type->kind == 20)
2274 {
2275 struct Expression * argExp = GetTemplateArgExp(exp->op.exp2->expType->type->templateParameter, thisClass, 0x0);
2276
2277 if(argExp)
2278 {
2279 struct Expression * classExp = MkExpMember(argExp, MkIdentifier("dataTypeClass"));
2280 struct Expression * sizeExp = MkExpMember(CopyExpression(classExp), MkIdentifier("typeSize"));
2281
2282 exp->type = 5;
2283 exp->list = MkListOne(MkExpBrackets(MkListOne(MkExpCast(MkTypeName(MkListOne(MkSpecifierName("uint64")), (((void *)0))), MkExpBrackets(MkListOne(MkExpCondition(MkExpBrackets(MkListOne(MkExpOp(MkExpMember(CopyExpression(classExp), MkIdentifier("type")), EQ_OP, MkExpIdentifier(MkIdentifier("structClass"))))), MkListOne(MkExpBrackets(MkListOne(MkExpCast(MkTypeName(MkListOne(MkSpecifierName("uint64")), (((void *)0))), CopyExpression(exp->op.exp2))))), MkExpCondition(MkExpBrackets(MkListOne(MkExpOp(MkExpOp(MkExpMember(CopyExpression(classExp), MkIdentifier("type")), EQ_OP, MkExpIdentifier(MkIdentifier("normalClass"))), OR_OP, MkExpOp(MkExpMember(classExp, MkIdentifier("type")), EQ_OP, MkExpIdentifier(MkIdentifier("noHeadClass")))))), MkListOne(MkExpCast(MkTypeName(MkListOne(MkSpecifierName("uint64")), (((void *)0))), MkExpOp((((void *)0)), '*', MkExpBrackets(MkListOne(MkExpCast(MkTypeName(MkListOne(MkSpecifier(VOID)), MkDeclaratorPointer(MkPointer((((void *)0)), MkPointer((((void *)0)), (((void *)0)))), (((void *)0)))), CopyExpression(exp->op.exp2))))))), MkExpBrackets(MkListOne(MkExpCondition(MkExpBrackets(MkListOne(MkExpOp(CopyExpression(sizeExp), EQ_OP, MkExpConstant("1")))), MkListOne(MkExpOp((((void *)0)), '*', MkExpBrackets(MkListOne(MkExpCast(MkTypeName(MkListOne(MkSpecifierName("byte")), MkDeclaratorPointer(MkPointer((((void *)0)), (((void *)0))), (((void *)0)))), CopyExpression(exp->op.exp2)))))), MkExpBrackets(MkListOne(MkExpCondition(MkExpBrackets(MkListOne(MkExpOp(CopyExpression(sizeExp), EQ_OP, MkExpConstant("2")))), MkListOne(MkExpOp((((void *)0)), '*', MkExpBrackets(MkListOne(MkExpCast(MkTypeName(MkListOne(MkSpecifierName("uint16")), MkDeclaratorPointer(MkPointer((((void *)0)), (((void *)0))), (((void *)0)))), CopyExpression(exp->op.exp2)))))), MkExpBrackets(MkListOne(MkExpCondition(MkExpBrackets(MkListOne(MkExpOp(sizeExp, EQ_OP, MkExpConstant("4")))), MkListOne(MkExpOp((((void *)0)), '*', MkExpBrackets(MkListOne(MkExpCast(MkTypeName(MkListOne(MkSpecifierName("uint32")), MkDeclaratorPointer(MkPointer((((void *)0)), (((void *)0))), (((void *)0)))), CopyExpression(exp->op.exp2)))))), MkExpOp((((void *)0)), '*', MkExpBrackets(MkListOne(MkExpCast(MkTypeName(MkListOne(MkSpecifierName("uint64")), MkDeclaratorPointer(MkPointer((((void *)0)), (((void *)0))), (((void *)0)))), exp->op.exp2)))))))))))))))))))));
2284 thisClass = curExternal->function ? curExternal->function->_class : (((void *)0));
2285 {
2286 struct Symbol * thisSymbol = (thisSymbol = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass_Symbol), thisSymbol->string = __ecereNameSpace__ecere__sys__CopyString("this"), thisSymbol->type = MkClassType(thisClass->fullName), thisSymbol);
2287
2288 __ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_Add(&globalContext->symbols, (struct __ecereNameSpace__ecere__sys__BTNode *)thisSymbol);
2289 ProcessExpressionType((*exp->list).first);
2290 ProcessExpression((*exp->list).first);
2291 __ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_Remove(&globalContext->symbols, (struct __ecereNameSpace__ecere__sys__BTNode *)thisSymbol);
2292 FreeSymbol(thisSymbol);
2293 }
2294 thisClass = (((void *)0));
2295 return ;
2296 }
2297 }
2298 else
2299 {
2300 if(exp->op.exp1)
2301 {
2302 if(exp->op.exp2)
2303 exp->op.exp1->tempCount = exp->op.exp2->tempCount;
2304 ProcessExpression(exp->op.exp1);
2305 if(exp->op.op == '=' && exp->op.exp2 && (!exp->op.exp2->byReference || (exp->op.exp2->expType && exp->op.exp2->expType->kind == 8 && exp->op.exp2->expType->_class && exp->op.exp2->expType->_class->registered && exp->op.exp2->expType->_class->registered->type == 1)) && exp->op.exp2->expType && (exp->op.exp2->expType->kind != 13 && exp->op.exp2->expType->kind != 20))
2306 FixReference(exp->op.exp1, 0x0);
2307 }
2308 if(exp->op.exp2)
2309 {
2310 if(exp->op.exp1)
2311 exp->op.exp2->tempCount = exp->op.exp1->tempCount;
2312 ProcessExpression(exp->op.exp2);
2313 if(exp->op.exp1 || (exp->op.op != '*' && exp->op.op != '&'))
2314 {
2315 if((!exp->op.exp1 && (!exp->op.exp2 || !exp->op.exp2->expType || exp->op.exp2->expType->kind != 8 || !exp->op.exp2->expType->_class || !exp->op.exp2->expType->_class->registered || (exp->op.exp2->expType->_class->registered->type != 0 && exp->op.exp2->expType->_class->registered->type != 1 && exp->op.exp2->expType->_class->registered->type != 5))) || (exp->op.exp1 && exp->op.exp1->expType && exp->op.exp1->expType->kind != 13 && exp->op.exp1->expType->kind != 20))
2316 {
2317 FixReference(exp->op.exp2, exp->op.exp1 ? exp->op.exp1->byReference : 0x0);
2318 }
2319 }
2320 }
2321 }
2322 if(exp->op.op == '*' && !exp->op.exp1 && exp->op.exp2 && exp->op.exp2->type == 4 && exp->op.exp2->op.op == '&' && !exp->op.exp2->op.exp1)
2323 {
2324 struct Expression * next = exp->next, * prev = exp->prev;
2325 struct Expression * derefExp = exp->op.exp2;
2326 struct Expression * refExp = exp->op.exp2->op.exp2;
2327 struct Type * expType = exp->expType, * destType = exp->destType;
2328
2329 derefExp->op.exp2 = (((void *)0));
2330 FreeExpression(derefExp);
2331 FreeType(exp->expType);
2332 FreeType(exp->destType);
2333 *exp = *refExp;
2334 exp->prev = prev;
2335 exp->next = next;
2336 ((refExp ? (__ecereClass_Expression->Destructor ? __ecereClass_Expression->Destructor(refExp) : 0, __ecereNameSpace__ecere__com__eSystem_Delete(refExp)) : 0), refExp = 0);
2337 }
2338 if(exp->op.op == '&' && !exp->op.exp1 && exp->op.exp2 && exp->op.exp2->expType && exp->op.exp2->expType->kind == 20 && !exp->op.exp2->expType->passAsTemplate)
2339 {
2340 struct Expression * exp2 = exp->op.exp2;
2341 struct Expression * argExp = GetTemplateArgExp(exp2->expType->templateParameter, thisClass, 0x0);
2342
2343 if(argExp)
2344 {
2345 struct Expression * classExp = MkExpMember(argExp, MkIdentifier("dataTypeClass"));
2346 struct Expression * e;
2347
2348 exp->type = 5;
2349 exp->list = MkListOne(MkExpOp(MkExpCast(MkTypeName(MkListOne(MkSpecifier(CHAR)), MkDeclaratorPointer(MkPointer((((void *)0)), (((void *)0))), (((void *)0)))), MkExpOp((((void *)0)), '&', exp2)), '+', MkExpCall(MkExpIdentifier(MkIdentifier("__ENDIAN_PAD")), MkListOne((e = MkExpCondition(MkExpBrackets(MkListOne(MkExpOp(MkExpOp(MkExpOp(MkExpMember(CopyExpression(classExp), MkIdentifier("type")), EQ_OP, MkExpIdentifier(MkIdentifier("structClass"))), OR_OP, MkExpOp(MkExpMember(CopyExpression(classExp), MkIdentifier("type")), EQ_OP, MkExpIdentifier(MkIdentifier("normalClass")))), OR_OP, MkExpOp(MkExpMember(CopyExpression(classExp), MkIdentifier("type")), EQ_OP, MkExpIdentifier(MkIdentifier("noHeadClass")))))), MkListOne(MkExpTypeSize(MkTypeName(MkListOne(MkSpecifier(VOID)), MkDeclaratorPointer(MkPointer((((void *)0)), (((void *)0))), (((void *)0)))))), MkExpMember(classExp, MkIdentifier("typeSize"))))))));
2350 thisClass = curExternal->function ? curExternal->function->_class : (((void *)0));
2351 {
2352 ProcessExpressionType(e);
2353 ProcessExpression(e);
2354 }
2355 thisClass = (((void *)0));
2356 }
2357 }
2358 }
2359 else
2360 {
2361 if(exp1)
2362 FreeExpression(exp1);
2363 if(exp2)
2364 FreeExpression(exp2);
2365 }
2366 break;
2367 }
2368 case 5:
2369 case 34:
2370 {
2371 if(exp->list)
2372 {
2373 struct Expression * e;
2374
2375 for(e = (*exp->list).first; e; e = e->next)
2376 {
2377 if(!e->next)
2378 {
2379 e->usage |= (exp->usage & (((unsigned int)(0x1)) | (((unsigned int)(0x1)) << 2) | (((unsigned int)(0x1)) << 4)));
2380 }
2381 e->tempCount = exp->tempCount;
2382 ProcessExpression(e);
2383 if(!e->next)
2384 exp->byReference = e->byReference;
2385 exp->tempCount = e->tempCount;
2386 }
2387 }
2388 break;
2389 }
2390 case 6:
2391 {
2392 struct Expression * e;
2393 struct Expression * checkedExp = exp->index.exp;
2394 unsigned int isBuiltin = 0x0;
2395
2396 while(checkedExp->type == 25 || checkedExp->type == 5 || checkedExp->type == 11)
2397 {
2398 if(checkedExp->type == 25)
2399 {
2400 isBuiltin = 0x1;
2401 break;
2402 }
2403 else if(checkedExp->type == 5)
2404 checkedExp = checkedExp->list ? (*checkedExp->list).last : (((void *)0));
2405 else
2406 checkedExp = checkedExp->cast.exp;
2407 }
2408 exp->index.exp->tempCount = exp->tempCount;
2409 exp->index.exp->usage = (exp->index.exp->usage & ~0x1) | (((unsigned int)0x1) << 0);
2410 ProcessExpression(exp->index.exp);
2411 if(exp->index.exp->expType && exp->index.exp->expType->kind == 13 && exp->index.exp->expType->type && exp->index.exp->expType->type->kind == 20)
2412 {
2413 struct Expression * argExp = GetTemplateArgExp(exp->index.exp->expType->type->templateParameter, thisClass, 0x0);
2414
2415 if(argExp)
2416 {
2417 struct Expression * classExp = MkExpMember(argExp, MkIdentifier("dataTypeClass"));
2418 struct Expression * sizeExp = MkExpMember(CopyExpression(classExp), MkIdentifier("typeSize"));
2419
2420 exp->type = 5;
2421 exp->list = MkListOne(MkExpBrackets(MkListOne(MkExpCast(MkTypeName(MkListOne(MkSpecifierName("uint64")), (((void *)0))), MkExpBrackets(MkListOne(MkExpCondition(MkExpBrackets(MkListOne(MkExpOp(MkExpMember(CopyExpression(classExp), MkIdentifier("type")), EQ_OP, MkExpIdentifier(MkIdentifier("structClass"))))), MkListOne(MkExpCast(MkTypeName(MkListOne(MkSpecifierName("uint64")), (((void *)0))), MkExpBrackets(MkListOne(MkExpOp(MkExpBrackets(MkListOne(MkExpCast(MkTypeName(MkListOne(MkSpecifierName("byte")), MkDeclaratorPointer(MkPointer((((void *)0)), (((void *)0))), (((void *)0)))), CopyExpression(exp->index.exp)))), '+', MkExpOp(MkExpBrackets(CopyList(exp->index.index, CopyExpression)), '*', CopyExpression(sizeExp))))))), MkExpCondition(MkExpBrackets(MkListOne(MkExpOp(MkExpOp(MkExpMember(CopyExpression(classExp), MkIdentifier("type")), EQ_OP, MkExpIdentifier(MkIdentifier("normalClass"))), OR_OP, MkExpOp(MkExpMember(classExp, MkIdentifier("type")), EQ_OP, MkExpIdentifier(MkIdentifier("noHeadClass")))))), MkListOne(MkExpCast(MkTypeName(MkListOne(MkSpecifierName("uint64")), (((void *)0))), MkExpIndex(MkExpBrackets(MkListOne(MkExpCast(MkTypeName(MkListOne(MkSpecifier(VOID)), MkDeclaratorPointer(MkPointer((((void *)0)), MkPointer((((void *)0)), (((void *)0)))), (((void *)0)))), CopyExpression(exp->index.exp)))), CopyList(exp->index.index, CopyExpression)))), MkExpBrackets(MkListOne(MkExpCondition(MkExpBrackets(MkListOne(MkExpOp(CopyExpression(sizeExp), EQ_OP, MkExpConstant("1")))), MkListOne(MkExpIndex(MkExpBrackets(MkListOne(MkExpCast(MkTypeName(MkListOne(MkSpecifierName("byte")), MkDeclaratorPointer(MkPointer((((void *)0)), (((void *)0))), (((void *)0)))), CopyExpression(exp->index.exp)))), CopyList(exp->index.index, CopyExpression))), MkExpBrackets(MkListOne(MkExpCondition(MkExpBrackets(MkListOne(MkExpOp(CopyExpression(sizeExp), EQ_OP, MkExpConstant("2")))), MkListOne(MkExpIndex(MkExpBrackets(MkListOne(MkExpCast(MkTypeName(MkListOne(MkSpecifierName("uint16")), MkDeclaratorPointer(MkPointer((((void *)0)), (((void *)0))), (((void *)0)))), CopyExpression(exp->index.exp)))), CopyList(exp->index.index, CopyExpression))), MkExpBrackets(MkListOne(MkExpCondition(MkExpBrackets(MkListOne(MkExpOp(sizeExp, EQ_OP, MkExpConstant("4")))), MkListOne(MkExpIndex(MkExpBrackets(MkListOne(MkExpCast(MkTypeName(MkListOne(MkSpecifierName("uint32")), MkDeclaratorPointer(MkPointer((((void *)0)), (((void *)0))), (((void *)0)))), CopyExpression(exp->index.exp)))), CopyList(exp->index.index, CopyExpression))), MkExpIndex(MkExpBrackets(MkListOne(MkExpCast(MkTypeName(MkListOne(MkSpecifierName("uint64")), MkDeclaratorPointer(MkPointer((((void *)0)), (((void *)0))), (((void *)0)))), exp->index.exp))), exp->index.index))))))))))))))))));
2422 thisClass = curExternal->function ? curExternal->function->_class : (((void *)0));
2423 {
2424 struct Symbol * thisSymbol = (thisSymbol = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass_Symbol), thisSymbol->string = __ecereNameSpace__ecere__sys__CopyString("this"), thisSymbol->type = MkClassType(thisClass->fullName), thisSymbol);
2425
2426 __ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_Add(&globalContext->symbols, (struct __ecereNameSpace__ecere__sys__BTNode *)thisSymbol);
2427 ProcessExpressionType((*exp->list).first);
2428 ProcessExpression((*exp->list).first);
2429 __ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_Remove(&globalContext->symbols, (struct __ecereNameSpace__ecere__sys__BTNode *)thisSymbol);
2430 FreeSymbol(thisSymbol);
2431 }
2432 thisClass = (((void *)0));
2433 return ;
2434 }
2435 }
2436 for(e = (*exp->index.index).first; e; e = e->next)
2437 {
2438 if(!e->next)
2439 e->usage = (e->usage & ~0x1) | (((unsigned int)0x1) << 0);
2440 ProcessExpression(e);
2441 }
2442 exp->tempCount = exp->index.exp->tempCount;
2443 if(exp->index.exp->expType)
2444 {
2445 struct Type * source = exp->index.exp->expType;
2446
2447 if(source->kind == 8 && source->_class && source->_class->registered && source->_class->registered != containerClass && __ecereNameSpace__ecere__com__eClass_IsDerived(source->_class->registered, containerClass))
2448 {
2449 struct __ecereNameSpace__ecere__com__Class * _class = source->_class->registered;
2450 unsigned int isArray = 0x0;
2451 struct __ecereNameSpace__ecere__com__Class * arrayClass = __ecereNameSpace__ecere__com__eSystem_FindClass(privateModule, "Array");
2452
2453 if(source && __ecereNameSpace__ecere__com__eClass_IsDerived(source->_class->registered, arrayClass))
2454 isArray = 0x1;
2455 if(isArray && _class->templateArgs)
2456 {
2457 struct __ecereNameSpace__ecere__sys__OldList * specs = MkList();
2458 struct Declarator * decl = SpecDeclFromString(_class->templateArgs[2].dataTypeString, specs, (((void *)0)));
2459 struct TypeName * typeName = MkTypeName(specs, MkDeclaratorPointer(MkPointer((((void *)0)), (((void *)0))), decl));
2460
2461 exp->index.exp = MkExpBrackets(MkListOne(MkExpCast(typeName, MkExpMember(exp->index.exp, MkIdentifier("array")))));
2462 ProcessExpressionType(exp->index.exp);
2463 ProcessExpression(exp);
2464 }
2465 else if(isBuiltin && _class->templateArgs)
2466 {
2467 struct __ecereNameSpace__ecere__sys__OldList * specs = MkList();
2468 struct Declarator * decl = SpecDeclFromString(_class->templateArgs[2].dataTypeString, specs, (((void *)0)));
2469 struct TypeName * typeName = MkTypeName(specs, MkDeclaratorPointer(MkPointer((((void *)0)), (((void *)0))), decl));
2470
2471 exp->index.exp = MkExpBrackets(MkListOne(MkExpCast(typeName, MkExpPointer(MkExpCast(QMkType("BuiltInContainer", QMkPtrDecl((((void *)0)))), exp->index.exp), MkIdentifier("data")))));
2472 ProcessExpressionType(exp->index.exp);
2473 ProcessExpression(exp);
2474 }
2475 else if(_class->templateArgs)
2476 {
2477 char iteratorType[1024];
2478 struct __ecereNameSpace__ecere__sys__OldList * declarations = MkList();
2479 struct __ecereNameSpace__ecere__sys__OldList * statements = MkList();
2480 struct __ecereNameSpace__ecere__sys__OldList * args = MkList();
2481 struct __ecereNameSpace__ecere__sys__OldList * instMembers = MkList();
2482 struct Expression * expExt;
2483 struct Context * context = PushContext();
2484
2485 sprintf(iteratorType, "Iterator<%s, %s >", _class->templateArgs[2].dataTypeString, _class->templateArgs[1].dataTypeString);
2486 ListAdd(instMembers, MkMemberInit((((void *)0)), MkInitializerAssignment(exp->index.exp)));
2487 ListAdd(declarations, MkDeclarationInst(MkInstantiationNamed(MkListOne(MkSpecifierName(iteratorType)), MkExpIdentifier(MkIdentifier("__internalIterator")), MkListOne(MkMembersInitList(instMembers)))));
2488 ListAdd(args, MkExpBrackets(exp->index.index));
2489 ListAdd(args, ((unsigned int)((exp->usage & 0x2) >> 1)) ? MkExpIdentifier(MkIdentifier("true")) : MkExpIdentifier(MkIdentifier("false")));
2490 ListAdd(statements, MkExpressionStmt(MkListOne(MkExpCall(MkExpMember(MkExpIdentifier(MkIdentifier("__internalIterator")), MkIdentifier("Index")), args))));
2491 ListAdd(statements, MkExpressionStmt(MkListOne(MkExpMember(MkExpIdentifier(MkIdentifier("__internalIterator")), MkIdentifier("data")))));
2492 exp->type = 5;
2493 exp->list = MkListOne(expExt = (MkExpExtensionCompound(MkCompoundStmt(declarations, statements))));
2494 expExt->compound->compound.context = context;
2495 PopContext(context);
2496 expExt->usage = exp->usage;
2497 ProcessExpressionType((*exp->list).first);
2498 ProcessExpressionInstPass((*exp->list).first);
2499 ProcessExpression((*exp->list).first);
2500 }
2501 }
2502 }
2503 break;
2504 }
2505 case 7:
2506 {
2507 struct Expression * e;
2508 struct Expression * memberExp;
2509 unsigned int typedObject = 0x0;
2510 struct Type * ellipsisDestType = (((void *)0));
2511 unsigned int usedEllipsis = 0x0;
2512
2513 if(exp->call.arguments)
2514 {
2515 for(e = (*exp->call.arguments).first; e; e = e->next)
2516 {
2517 int __simpleStruct2, __simpleStruct3;
2518 int __simpleStruct0, __simpleStruct1;
2519
2520 e->usage = (e->usage & ~0x1) | (((unsigned int)0x1) << 0);
2521 e->usage = (e->usage & ~0x4) | (((unsigned int)0x1) << 2);
2522 e->tempCount = (__simpleStruct0 = e->tempCount, __simpleStruct1 = exp->tempCount, (__simpleStruct0 > __simpleStruct1) ? __simpleStruct0 : __simpleStruct1);
2523 ProcessExpression(e);
2524 exp->tempCount = (__simpleStruct2 = exp->tempCount, __simpleStruct3 = e->tempCount, (__simpleStruct2 > __simpleStruct3) ? __simpleStruct2 : __simpleStruct3);
2525 }
2526 }
2527 exp->call.exp->usage = (exp->call.exp->usage & ~0x1) | (((unsigned int)0x1) << 0);
2528 exp->call.exp->usage = (exp->call.exp->usage & ~0x8) | (((unsigned int)0x1) << 3);
2529 exp->call.exp->tempCount = exp->tempCount;
2530 ProcessExpression(exp->call.exp);
2531 memberExp = (exp->call.exp->type == 8) ? exp->call.exp : (((void *)0));
2532 if(exp->call.exp->expType && exp->call.exp->expType->kind == 16)
2533 {
2534 struct __ecereNameSpace__ecere__com__Class * _class = exp->call.exp->expType->methodClass;
2535 struct __ecereNameSpace__ecere__com__Class * argClass = exp->call.exp->expType->methodClass;
2536 struct __ecereNameSpace__ecere__com__Method * method = exp->call.exp->expType->method;
2537
2538 if(method->type == 1)
2539 {
2540 char name[1024];
2541 struct TypeName * typeName;
2542 struct Declarator * decl;
2543 struct Context * back;
2544 struct __ecereNameSpace__ecere__sys__OldList * specs = MkList();
2545
2546 strcpy(name, "__ecereVMethodID_");
2547 FullClassNameCat(name, method->_class->fullName, 0x0);
2548 strcat(name, "_");
2549 strcat(name, method->name);
2550 DeclareMethod(method, name);
2551 back = curContext;
2552 curContext = method->_class->symbol ? ((struct Symbol *)method->_class->symbol)->ctx : globalContext;
2553 {
2554 struct Context * context = SetupTemplatesContext(method->_class);
2555
2556 decl = SpecDeclFromString(method->dataTypeString, specs, MkDeclaratorBrackets(MkDeclaratorPointer(MkPointer((((void *)0)), (((void *)0))), (((void *)0)))));
2557 FinishTemplatesContext(context);
2558 }
2559 curContext = back;
2560 if(method->dataType && !method->dataType->staticMethod)
2561 {
2562 struct Declarator * funcDecl = GetFuncDecl(decl);
2563
2564 if(!funcDecl->function.parameters)
2565 funcDecl->function.parameters = MkList();
2566 {
2567 struct TypeName * firstParam = ((struct TypeName *)(*funcDecl->function.parameters).first);
2568 struct Specifier * firstSpec = firstParam ? (*firstParam->qualifiers).first : (((void *)0));
2569
2570 if(firstParam && firstSpec && firstSpec->type == 0 && firstSpec->specifier == VOID && !firstParam->declarator)
2571 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Remove((&*funcDecl->function.parameters), (*funcDecl->function.parameters).first);
2572 }
2573 if(method->dataType->thisClass && !strcmp(method->dataType->thisClass->string, "class"))
2574 {
2575 typedObject = 0x1;
2576 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Insert((&*funcDecl->function.parameters), (((void *)0)), MkTypeName(MkListOne(MkSpecifier(VOID)), MkDeclaratorPointer(MkPointer((((void *)0)), (((void *)0))), (((void *)0)))));
2577 if(!method->dataType->extraParam)
2578 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Insert((&*funcDecl->function.parameters), (((void *)0)), MkTypeName(MkListOne(MkStructOrUnion(3, MkIdentifier("__ecereNameSpace__ecere__com__Class"), (((void *)0)))), MkDeclaratorPointer(MkPointer((((void *)0)), (((void *)0))), (((void *)0)))));
2579 }
2580 else
2581 {
2582 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Insert((&*funcDecl->function.parameters), (((void *)0)), MkTypeName(MkListOne(MkSpecifierName(method->dataType->thisClass ? method->dataType->thisClass->string : method->_class->fullName)), (((void *)0))));
2583 }
2584 }
2585 typeName = MkTypeName(specs, decl);
2586 if(memberExp && memberExp->member.exp->expType)
2587 {
2588 struct Type * type = memberExp->member.exp->expType;
2589
2590 if(type->kind == 8 && type->_class && type->_class->registered)
2591 {
2592 struct __ecereNameSpace__ecere__com__Class * regClass = type->_class->registered;
2593 int classType = regClass->type;
2594
2595 if(classType != 0 || !strcmp(regClass->dataTypeString, "char *") || method->dataType->byReference)
2596 argClass = regClass;
2597 }
2598 else if(type->kind == 19)
2599 {
2600 argClass = FindClass("ecere::com::Class")->registered;
2601 }
2602 else if((type->kind == 12 || type->kind == 13) && type->type && type->type->kind == 1)
2603 {
2604 argClass = FindClass("char *")->registered;
2605 }
2606 else if(type->kind == 13)
2607 {
2608 argClass = __ecereNameSpace__ecere__com__eSystem_FindClass(privateModule, "uintptr");
2609 FreeType(memberExp->member.exp->expType);
2610 memberExp->member.exp->expType = ProcessTypeString("uintptr", 0x0);
2611 memberExp->member.exp->byReference = 0x1;
2612 }
2613 else
2614 {
2615 char string[1024] = "";
2616 struct Symbol * classSym;
2617
2618 PrintTypeNoConst(type, string, 0x0, 0x1);
2619 classSym = FindClass(string);
2620 if(classSym)
2621 argClass = classSym->registered;
2622 }
2623 }
2624 {
2625 struct Type * type = memberExp ? memberExp->member.exp->expType : (((void *)0));
2626 struct __ecereNameSpace__ecere__com__Class * regClass = (type && type->kind == 8 && type->_class) ? type->_class->registered : (((void *)0));
2627
2628 if(!exp->call.exp->expType->methodClass && (!memberExp || !_class) && type && type->classObjectType)
2629 {
2630 if(regClass && regClass->type == 0 && strcmp(regClass->dataTypeString, "char *"))
2631 {
2632 exp->call.exp = MkExpBrackets(MkListOne(MkExpCast(typeName, MkExpIndex(MkExpPointer(MkExpBrackets(MkListOne(CopyExpression(memberExp->member.exp))), MkIdentifier("_vTbl")), MkListOne(MkExpIdentifier(MkIdentifier(name)))))));
2633 }
2634 else
2635 {
2636 exp->call.exp = MkExpBrackets(MkListOne(MkExpCast(typeName, MkExpIndex(MkExpPointer(MkExpIdentifier(MkIdentifier("class")), MkIdentifier("_vTbl")), MkListOne(MkExpIdentifier(MkIdentifier(name)))))));
2637 }
2638 }
2639 else if(memberExp && !_class && exp->call.exp->expType->_class && (type->kind == 19 || (regClass && regClass->type == 0 && strcmp(regClass->dataTypeString, "char *"))))
2640 {
2641 exp->call.exp = MkExpBrackets(MkListOne(MkExpCast(typeName, MkExpIndex(MkExpPointer(CopyExpression(memberExp->member.exp), MkIdentifier("_vTbl")), MkListOne(MkExpIdentifier(MkIdentifier(name)))))));
2642 }
2643 else
2644 {
2645 char className[1024];
2646
2647 if(!_class && argClass && strcmp(argClass->fullName, "class"))
2648 _class = argClass;
2649 if(!_class)
2650 {
2651 _class = __ecereClass_int;
2652 }
2653 strcpy(className, "__ecereClass_");
2654 FullClassNameCat(className, _class->fullName, 0x1);
2655 MangleClassName(className);
2656 if(!_class->symbol)
2657 _class->symbol = FindClass(_class->fullName);
2658 DeclareClass(_class->symbol, className);
2659 exp->call.exp = MkExpBrackets(MkListOne(MkExpCast(typeName, MkExpIndex(MkExpPointer(MkExpIdentifier(MkIdentifier(className)), MkIdentifier("_vTbl")), MkListOne(MkExpIdentifier(MkIdentifier(name)))))));
2660 }
2661 }
2662 }
2663 else
2664 {
2665 char name[1024];
2666
2667 strcpy(name, "__ecereMethod_");
2668 FullClassNameCat(name, method->_class->fullName, 0x0);
2669 strcat(name, "_");
2670 strcat(name, method->name);
2671 exp->call.exp = MkExpIdentifier(MkIdentifier(name));
2672 DeclareMethod(method, name);
2673 if(memberExp && memberExp->expType && method->dataType)
2674 {
2675 exp->call.exp->expType = method->dataType;
2676 method->dataType->refCount++;
2677 }
2678 }
2679 if(memberExp && (!memberExp->member.exp || !memberExp->member.exp->expType || memberExp->member.exp->expType->kind != 19))
2680 {
2681 if(method->dataType && !method->dataType->staticMethod && !method->dataType->extraParam)
2682 {
2683 if(!exp->call.arguments)
2684 exp->call.arguments = MkList();
2685 if(typedObject && memberExp->member.exp && memberExp->member.exp->expType)
2686 {
2687 unsigned int changeReference = 0x0;
2688
2689 if(argClass && (argClass->type == 4 || argClass->type == 3 || argClass->type == 2 || argClass->type == 1000) && strcmp(argClass->fullName, "class") && strcmp(argClass->fullName, "uintptr") && strcmp(argClass->fullName, "intptr"))
2690 changeReference = 0x1;
2691 if(!memberExp->member.exp->expType->classObjectType && ((((memberExp->member.exp->expType->kind != 13 && (memberExp->member.exp->expType->kind != 8 || !memberExp->member.exp->expType->_class || !memberExp->member.exp->expType->_class->registered || memberExp->member.exp->expType->_class->registered->type == 1)))) || method->dataType->byReference))
2692 changeReference = 0x1;
2693 if(typedObject && memberExp->member.exp->expType->classObjectType && memberExp->member.exp->expType->byReference != method->dataType->byReference)
2694 changeReference = 0x1;
2695 if(changeReference)
2696 {
2697 if(memberExp->member.exp->type == 5 && memberExp->member.exp->list && (*memberExp->member.exp->list).count == 1 && ((struct Expression *)(*memberExp->member.exp->list).first)->type == 4 && ((struct Expression *)(*memberExp->member.exp->list).first)->op.op == '*' && !((struct Expression *)(*memberExp->member.exp->list).first)->op.exp1)
2698 {
2699 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Insert((&*exp->call.arguments), (((void *)0)), ((struct Expression *)(*memberExp->member.exp->list).first)->op.exp2);
2700 ((struct Expression *)(*memberExp->member.exp->list).first)->op.exp2 = (((void *)0));
2701 }
2702 else if(memberExp->member.exp->type == 4 && memberExp->member.exp->op.op == '*' && !memberExp->member.exp->op.exp1)
2703 {
2704 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Insert((&*exp->call.arguments), (((void *)0)), memberExp->member.exp->op.exp2);
2705 memberExp->member.exp->op.exp2 = (((void *)0));
2706 }
2707 else if(!memberExp->member.exp->byReference)
2708 {
2709 struct Expression * checkedExp = memberExp->member.exp;
2710 struct Expression * parentExp = (((void *)0));
2711 struct Expression * newExp;
2712
2713 while(((checkedExp->type == 5 || checkedExp->type == 34) && checkedExp->list) || checkedExp->type == 11)
2714 {
2715 parentExp = checkedExp;
2716 if(checkedExp->type == 5 || checkedExp->type == 34)
2717 checkedExp = (*checkedExp->list).last;
2718 else if(checkedExp->type == 11)
2719 checkedExp = checkedExp->cast.exp;
2720 }
2721 newExp = (typedObject && !memberExp->member.exp->expType->classObjectType) ? checkedExp : MkExpOp((((void *)0)), '&', checkedExp);
2722 if(parentExp && (parentExp->type == 5 || parentExp->type == 34))
2723 {
2724 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Remove((&*parentExp->list), checkedExp);
2725 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Add((&*parentExp->list), newExp);
2726 }
2727 else if(parentExp && parentExp->type == 11)
2728 {
2729 parentExp->cast.exp = newExp;
2730 parentExp->cast.typeName->declarator = MkDeclaratorPointer(MkPointer((((void *)0)), (((void *)0))), parentExp->cast.typeName->declarator);
2731 }
2732 if(typedObject && !memberExp->member.exp->expType->classObjectType)
2733 {
2734 struct Type * destType = (destType = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass_Type), destType->refCount = 1, destType->kind = 8, destType->classObjectType = 3, destType);
2735
2736 (parentExp ? parentExp : newExp)->expType = checkedExp->expType;
2737 (parentExp ? parentExp : newExp)->destType = destType;
2738 if(checkedExp->expType)
2739 checkedExp->expType->refCount++;
2740 }
2741 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Insert((&*exp->call.arguments), (((void *)0)), parentExp ? parentExp : newExp);
2742 }
2743 else
2744 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Insert((&*exp->call.arguments), (((void *)0)), memberExp->member.exp);
2745 }
2746 else
2747 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Insert((&*exp->call.arguments), (((void *)0)), memberExp->member.exp);
2748 if(memberExp->member.exp && memberExp->member.exp->expType && memberExp->member.exp->expType->classObjectType == 2)
2749 {
2750 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Insert((&*exp->call.arguments), (((void *)0)), MkExpIdentifier(MkIdentifier("class")));
2751 }
2752 else
2753 {
2754 if(memberExp && !argClass)
2755 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Insert((&*exp->call.arguments), (((void *)0)), MkExpPointer(CopyExpression(memberExp->member.exp), MkIdentifier("_class")));
2756 else
2757 {
2758 char className[1024];
2759
2760 strcpy(className, "__ecereClass_");
2761 FullClassNameCat(className, argClass->fullName, 0x1);
2762 MangleClassName(className);
2763 if(!argClass->symbol)
2764 argClass->symbol = FindClass(argClass->fullName);
2765 DeclareClass(argClass->symbol, className);
2766 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Insert((&*exp->call.arguments), (((void *)0)), MkExpIdentifier(MkIdentifier(className)));
2767 }
2768 }
2769 }
2770 else
2771 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Insert((&*exp->call.arguments), (((void *)0)), memberExp->member.exp);
2772 memberExp->member.exp = (((void *)0));
2773 }
2774 FreeExpression(memberExp);
2775 }
2776 }
2777 if(exp->call.arguments)
2778 {
2779 for(e = (*exp->call.arguments).first; e; e = e->next)
2780 {
2781 struct Type * destType = (e->destType && e->destType->kind == 14) ? ellipsisDestType : e->destType;
2782
2783 if(destType && (destType->classObjectType == 2 || destType->classObjectType == 3))
2784 {
2785 if(e->destType && e->destType->kind == 14)
2786 usedEllipsis = 0x1;
2787 ellipsisDestType = destType;
2788 if(e && e->expType)
2789 {
2790 struct Type * type = e->expType;
2791 struct __ecereNameSpace__ecere__com__Class * _class = (((void *)0));
2792
2793 if(type->kind == 8 && type->_class && type->_class->registered)
2794 {
2795 _class = type->_class->registered;
2796 }
2797 else if(type->kind == 19)
2798 {
2799 _class = FindClass("ecere::com::Class")->registered;
2800 }
2801 else if((type->kind == 12 || type->kind == 13) && type->type && type->type->kind == 1)
2802 {
2803 _class = FindClass("char *")->registered;
2804 }
2805 else if(type->kind == 13)
2806 {
2807 _class = __ecereNameSpace__ecere__com__eSystem_FindClass(privateModule, "uintptr");
2808 FreeType(e->expType);
2809 e->expType = ProcessTypeString("uintptr", 0x0);
2810 e->byReference = 0x1;
2811 }
2812 else
2813 {
2814 char string[1024] = "";
2815 struct Symbol * classSym;
2816
2817 PrintTypeNoConst(type, string, 0x0, 0x1);
2818 classSym = FindClass(string);
2819 if(classSym)
2820 _class = classSym->registered;
2821 }
2822 if((_class && (_class->type == 4 || _class->type == 3 || _class->type == 2 || _class->type == 1000) && strcmp(_class->fullName, "class") && strcmp(_class->fullName, "uintptr") && strcmp(_class->fullName, "intptr")) || (!e->expType->classObjectType && (((type->kind != 13 && type->kind != 22 && type->kind != 19 && type->kind != 12 && (type->kind != 8 || !type->_class || !type->_class->registered || type->_class->registered->type == 1))) || destType->byReference)))
2823 {
2824 {
2825 struct Expression * checkedExp;
2826 struct Expression * parentExp;
2827 struct Expression * newExp;
2828
2829 checkedExp = e;
2830 parentExp = exp;
2831 while(((checkedExp->type == 5 || checkedExp->type == 34 || checkedExp->type == 25) && checkedExp->list) || checkedExp->type == 11)
2832 {
2833 parentExp = checkedExp;
2834 if(checkedExp->type == 5 || checkedExp->type == 34 || checkedExp->type == 25)
2835 {
2836 if(checkedExp->type == 25)
2837 {
2838 checkedExp = (*((struct Statement *)(*checkedExp->compound->compound.statements).last)->expressions).last;
2839 }
2840 else
2841 checkedExp = (*checkedExp->list).last;
2842 }
2843 else if(checkedExp->type == 11)
2844 checkedExp = checkedExp->cast.exp;
2845 }
2846 if(checkedExp && checkedExp->type == 4 && checkedExp->op.op == '*' && !checkedExp->op.exp1)
2847 {
2848 newExp = checkedExp->op.exp2;
2849 checkedExp->op.exp2 = (((void *)0));
2850 FreeExpContents(checkedExp);
2851 if(e->expType && e->expType->passAsTemplate)
2852 {
2853 char size[100];
2854
2855 ComputeTypeSize(e->expType);
2856 sprintf(size, "%d", e->expType->size);
2857 newExp = MkExpBrackets(MkListOne(MkExpOp(MkExpCast(MkTypeName(MkListOne(MkSpecifier(CHAR)), MkDeclaratorPointer(MkPointer((((void *)0)), (((void *)0))), (((void *)0)))), newExp), '+', MkExpCall(MkExpIdentifier(MkIdentifier("__ENDIAN_PAD")), MkListOne(MkExpConstant(size))))));
2858 }
2859 if(parentExp->type == 7)
2860 {
2861 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Insert((&*exp->call.arguments), e->prev, newExp);
2862 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Remove((&*exp->call.arguments), e);
2863 e = newExp;
2864 }
2865 else if(parentExp->type == 5 || parentExp->type == 34)
2866 {
2867 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Remove((&*parentExp->list), checkedExp);
2868 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Add((&*parentExp->list), newExp);
2869 }
2870 else if(parentExp->type == 11)
2871 {
2872 if(parentExp->destType && parentExp->destType->kind == 14)
2873 {
2874 FreeTypeName(parentExp->cast.typeName);
2875 parentExp->cast.typeName = MkTypeName(MkListOne(MkSpecifier(VOID)), MkDeclaratorPointer(MkPointer((((void *)0)), (((void *)0))), (((void *)0))));
2876 }
2877 parentExp->cast.exp = newExp;
2878 }
2879 else if(parentExp->type == 25)
2880 {
2881 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Remove((&*((struct Statement *)(*parentExp->compound->compound.statements).last)->expressions), checkedExp);
2882 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Add((&*((struct Statement *)(*parentExp->compound->compound.statements).last)->expressions), newExp);
2883 }
2884 e->byReference = 0x1;
2885 FreeType(checkedExp->expType);
2886 FreeType(checkedExp->destType);
2887 ((checkedExp ? (__ecereClass_Expression->Destructor ? __ecereClass_Expression->Destructor(checkedExp) : 0, __ecereNameSpace__ecere__com__eSystem_Delete(checkedExp)) : 0), checkedExp = 0);
2888 }
2889 else if((!e->byReference && (!e->expType || !e->expType->classObjectType)) || (_class && _class->type == 5))
2890 {
2891 struct Expression * checkedExp;
2892 struct Expression * parentExp;
2893 struct Expression * newExp;
2894
2895 {
2896 unsigned int hasAddress = e->type == 0 || (e->type == 8 && e->member.memberType == 3) || (e->type == 9 && e->member.memberType == 3) || (e->type == 4 && !e->op.exp1 && e->op.op == '*') || e->type == 6;
2897
2898 if(_class && _class->type != 5 && _class->type != 0 && _class->type != 1 && !hasAddress)
2899 {
2900 struct Context * context = PushContext();
2901 struct Declarator * decl;
2902 struct __ecereNameSpace__ecere__sys__OldList * specs = MkList();
2903 char typeString[1024];
2904 struct Expression * newExp = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass_Expression);
2905
2906 typeString[0] = '\0';
2907 *newExp = *e;
2908 if(exp->destType)
2909 exp->destType->refCount++;
2910 newExp->prev = (((void *)0));
2911 newExp->next = (((void *)0));
2912 newExp->expType = (((void *)0));
2913 PrintTypeNoConst(e->expType, typeString, 0x0, 0x1);
2914 decl = SpecDeclFromString(typeString, specs, (((void *)0)));
2915 newExp->destType = ProcessType(specs, decl);
2916 curContext = context;
2917 e->type = 25;
2918 if(curCompound)
2919 {
2920 char name[100];
2921 struct __ecereNameSpace__ecere__sys__OldList * stmts = MkList();
2922
2923 sprintf(name, "__internalValue%03X", internalValueCounter++);
2924 if(!curCompound->compound.declarations)
2925 curCompound->compound.declarations = MkList();
2926 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Insert((&*curCompound->compound.declarations), (((void *)0)), MkDeclaration(specs, MkListOne(MkInitDeclarator(MkDeclaratorIdentifier(MkIdentifier(name)), (((void *)0))))));
2927 ListAdd(stmts, MkExpressionStmt(MkListOne(MkExpOp(MkExpIdentifier(MkIdentifier(name)), '=', newExp))));
2928 ListAdd(stmts, MkExpressionStmt(MkListOne(MkExpIdentifier(MkIdentifier(name)))));
2929 e->compound = MkCompoundStmt((((void *)0)), stmts);
2930 }
2931 else
2932 printf("libec: compiler error, curCompound is null in ApplyAnyObjectLogic\n");
2933 e->compound->compound.context = context;
2934 PopContext(context);
2935 curContext = context->parent;
2936 }
2937 }
2938 checkedExp = e;
2939 parentExp = exp;
2940 while(((checkedExp->type == 5 || checkedExp->type == 34 || checkedExp->type == 25) && checkedExp->list) || checkedExp->type == 11)
2941 {
2942 parentExp = checkedExp;
2943 if(checkedExp->type == 5 || checkedExp->type == 34 || checkedExp->type == 25)
2944 {
2945 if(checkedExp->type == 25)
2946 {
2947 checkedExp = (*((struct Statement *)(*checkedExp->compound->compound.statements).last)->expressions).last;
2948 }
2949 else
2950 checkedExp = (*checkedExp->list).last;
2951 }
2952 else if(checkedExp->type == 11)
2953 checkedExp = checkedExp->cast.exp;
2954 }
2955 newExp = MkExpOp((((void *)0)), '&', checkedExp);
2956 newExp->byReference = 0x1;
2957 if(parentExp->type == 7)
2958 {
2959 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Insert((&*exp->call.arguments), e->prev, newExp);
2960 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Remove((&*exp->call.arguments), e);
2961 e = newExp;
2962 }
2963 else if(parentExp->type == 5 || parentExp->type == 34)
2964 {
2965 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Remove((&*parentExp->list), checkedExp);
2966 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Add((&*parentExp->list), newExp);
2967 }
2968 else if(parentExp->type == 11)
2969 parentExp->cast.exp = newExp;
2970 else if(parentExp->type == 5 || parentExp->type == 25)
2971 {
2972 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Remove((&*((struct Statement *)(*parentExp->compound->compound.statements).last)->expressions), checkedExp);
2973 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Add((&*((struct Statement *)(*parentExp->compound->compound.statements).last)->expressions), newExp);
2974 }
2975 }
2976 }
2977 }
2978 if(destType->classObjectType == 2)
2979 {
2980 char className[1024];
2981
2982 if(!_class && type->kind == 13 && type->type && type->type->kind == 1)
2983 _class = __ecereNameSpace__ecere__com__eSystem_FindClass(privateModule, "String");
2984 if(!_class)
2985 _class = __ecereNameSpace__ecere__com__eSystem_FindClass(privateModule, "int");
2986 if(!strcmp(_class->name, "class"))
2987 {
2988 strcpy(className, "class");
2989 }
2990 else
2991 {
2992 strcpy(className, "__ecereClass_");
2993 FullClassNameCat(className, _class->fullName, 0x1);
2994 MangleClassName(className);
2995 if(!_class->symbol)
2996 _class->symbol = FindClass(_class->fullName);
2997 DeclareClass(_class->symbol, className);
2998 }
2999 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Insert((&*exp->call.arguments), e->prev, MkExpIdentifier(MkIdentifier(className)));
3000 }
3001 }
3002 }
3003 {
3004 FixReference(e, !destType || !destType->declaredWithStruct);
3005 }
3006 }
3007 if(ellipsisDestType)
3008 {
3009 if(usedEllipsis || (exp->call.exp->expType && exp->call.exp->expType->kind == 11 && exp->call.exp->expType->params.last && ((struct Type *)exp->call.exp->expType->params.last)->kind == 14))
3010 {
3011 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Insert((&*exp->call.arguments), (*exp->call.arguments).last, MkExpCast(MkTypeName(MkListOne(MkSpecifier(VOID)), MkDeclaratorPointer(MkPointer((((void *)0)), (((void *)0))), (((void *)0)))), MkExpConstant("0")));
3012 }
3013 }
3014 }
3015 break;
3016 }
3017 case 8:
3018 {
3019 unsigned int changeToPtr = 0x0;
3020 unsigned int noHead = 0x0;
3021 struct Type * type = exp->member.exp->expType;
3022 struct Specifier * memberClassSpecifier = exp->member.member ? exp->member.member->_class : (((void *)0));
3023
3024 if(exp->member.member)
3025 exp->member.member->_class = (((void *)0));
3026 if(type && type->kind == 20)
3027 {
3028 struct Type * baseType = ProcessTemplateParameterType(type->templateParameter);
3029
3030 if(baseType)
3031 type = baseType;
3032 }
3033 if(type && exp->member.member && !type->directClassAccess)
3034 {
3035 struct __ecereNameSpace__ecere__com__Class * _class = exp->member.member->classSym ? exp->member.member->classSym->registered : (((type->kind == 8 || type->kind == 19) && type->_class) ? type->_class->registered : (((void *)0)));
3036 struct __ecereNameSpace__ecere__com__Property * prop = (((void *)0));
3037 struct __ecereNameSpace__ecere__com__ClassProperty * classProperty = (((void *)0));
3038 struct __ecereNameSpace__ecere__com__Method * method = (((void *)0));
3039 struct __ecereNameSpace__ecere__com__Class * convertTo = (((void *)0));
3040 struct __ecereNameSpace__ecere__com__DataMember * member = (((void *)0));
3041 unsigned int thisPtr = exp->member.thisPtr;
3042
3043 if(type->kind == 19 && exp->member.exp->type == 26)
3044 _class = __ecereNameSpace__ecere__com__eSystem_FindClass(privateModule, "ecere::com::Class");
3045 if(!_class)
3046 {
3047 char string[2048] = "";
3048 struct Symbol * classSym;
3049
3050 PrintTypeNoConst(type, string, 0x0, 0x1);
3051 classSym = FindClass(string);
3052 _class = classSym ? classSym->registered : (((void *)0));
3053 }
3054 if(_class && exp->member.memberType == 3)
3055 {
3056 if(!thisPtr && !exp->member.member->classSym)
3057 member = __ecereNameSpace__ecere__com__eClass_FindDataMember(_class, exp->member.member->string, (((void *)0)), (((void *)0)), (((void *)0)));
3058 if(!member)
3059 member = __ecereNameSpace__ecere__com__eClass_FindDataMember(_class, exp->member.member->string, privateModule, (((void *)0)), (((void *)0)));
3060 }
3061 else if(_class && exp->member.memberType == 1)
3062 {
3063 if(!thisPtr && !exp->member.member->classSym)
3064 prop = __ecereNameSpace__ecere__com__eClass_FindProperty(_class, exp->member.member->string, (((void *)0)));
3065 if(!prop)
3066 prop = __ecereNameSpace__ecere__com__eClass_FindProperty(_class, exp->member.member->string, privateModule);
3067 if(prop && (((unsigned int)((exp->usage & 0x40) >> 6)) || (((unsigned int)((exp->usage & 0x1) >> 0)) && !prop->Get && !prop->conversion) || (((unsigned int)((exp->usage & 0x80) >> 7)) && !prop->Set && !prop->conversion)))
3068 {
3069 member = __ecereNameSpace__ecere__com__eClass_FindDataMember(_class, exp->member.member->string, privateModule, (((void *)0)), (((void *)0)));
3070 if(member)
3071 {
3072 exp->member.memberType = 3;
3073 prop = (((void *)0));
3074 }
3075 else
3076 {
3077 if(((unsigned int)((exp->usage & 0x40) >> 6)))
3078 Compiler_Error(__ecereNameSpace__ecere__GetTranslatedString(__thisModule, "cannot obtain address of property\n", (((void *)0))));
3079 else if(!prop->Get)
3080 Compiler_Error(__ecereNameSpace__ecere__GetTranslatedString(__thisModule, "no get defined for property %s of class %s\n", (((void *)0))), prop->name, prop->_class->fullName);
3081 else if(((unsigned int)((exp->usage & 0x80) >> 7)))
3082 Compiler_Error(__ecereNameSpace__ecere__GetTranslatedString(__thisModule, "no get defined for property %s of class %s\n", (((void *)0))), prop->name, prop->_class->fullName);
3083 }
3084 }
3085 }
3086 else if(_class && exp->member.memberType == 2)
3087 {
3088 if(!thisPtr)
3089 method = __ecereNameSpace__ecere__com__eClass_FindMethod(_class, exp->member.member->string, (((void *)0)));
3090 if(!method)
3091 method = __ecereNameSpace__ecere__com__eClass_FindMethod(_class, exp->member.member->string, privateModule);
3092 }
3093 else if(_class && exp->member.memberType == 4)
3094 {
3095 convertTo = _class;
3096 _class = FindClass(exp->member.member->string)->registered;
3097 prop = __ecereNameSpace__ecere__com__eClass_FindProperty(_class, convertTo->fullName, privateModule);
3098 }
3099 else if(_class && exp->member.memberType == 5)
3100 {
3101 classProperty = __ecereNameSpace__ecere__com__eClass_FindClassProperty(_class, exp->member.member->string);
3102 }
3103 if(prop)
3104 {
3105 if(((unsigned int)((exp->usage & 0x1) >> 0)))
3106 {
3107 if(prop->Get)
3108 {
3109 char getName[1024], setName[1024];
3110 struct Expression * ptr = exp->member.exp;
3111 struct __ecereNameSpace__ecere__com__Class * propertyClass;
3112 char * nameToUse = convertTo ? setName : getName;
3113
3114 FreeIdentifier(exp->member.member);
3115 exp->member.exp->usage = (exp->member.exp->usage & ~0x1) | (((unsigned int)0x1) << 0);
3116 ProcessExpression(exp->member.exp);
3117 DeclareProperty(prop, setName, getName);
3118 propertyClass = convertTo ? _class : ((((struct Symbol *)prop->symbol)->type && ((struct Symbol *)prop->symbol)->type->kind == 8) ? ((struct Symbol *)prop->symbol)->type->_class->registered : ((struct Symbol *)prop->symbol)->_class);
3119 if(propertyClass && propertyClass->type == 2)
3120 {
3121 struct __ecereNameSpace__ecere__sys__OldList * args = MkList();
3122
3123 if(((unsigned int)((exp->usage & 0x20) >> 5)))
3124 {
3125 char className[1024];
3126 struct Declaration * decl;
3127 struct Declarator * declarator;
3128 struct __ecereNameSpace__ecere__sys__OldList * specs = MkList(), * decls = MkList();
3129 struct Expression * tempExp;
3130
3131 sprintf(className, "__simpleStruct%d", curContext->simpleID++);
3132 declarator = SpecDeclFromString(propertyClass->dataTypeString, specs, MkDeclaratorIdentifier(MkIdentifier(className)));
3133 ListAdd(decls, MkInitDeclarator(declarator, (((void *)0))));
3134 decl = MkDeclaration(specs, decls);
3135 if(!curCompound->compound.declarations)
3136 curCompound->compound.declarations = MkList();
3137 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Insert((&*curCompound->compound.declarations), (((void *)0)), decl);
3138 tempExp = QMkExpId(className);
3139 tempExp->expType = MkClassType(propertyClass->fullName);
3140 exp->op.exp1 = tempExp;
3141 exp->op.exp2 = MkExpCall(QMkExpId(nameToUse), args);
3142 exp->op.op = '=';
3143 exp->type = 4;
3144 }
3145 else
3146 {
3147 exp->type = 7;
3148 exp->call.exp = QMkExpId(nameToUse);
3149 exp->call.arguments = args;
3150 }
3151 ListAdd(args, FixReference(ptr, 0x1));
3152 }
3153 else if(propertyClass && propertyClass->type == 3)
3154 {
3155 struct __ecereNameSpace__ecere__sys__OldList * args = MkList();
3156
3157 ListAdd(args, FixReference(ptr, 0x1));
3158 exp->type = 7;
3159 exp->call.exp = QMkExpId(nameToUse);
3160 exp->call.arguments = args;
3161 }
3162 else if(propertyClass && propertyClass->type == 1)
3163 {
3164 struct __ecereNameSpace__ecere__sys__OldList * args = MkList();
3165 char className[1024];
3166 struct Declaration * decl;
3167 struct __ecereNameSpace__ecere__sys__OldList * specs = MkList(), * decls = MkList();
3168 struct Expression * tempExp;
3169
3170 className[0] = (char)0;
3171 FullClassNameCat(className, propertyClass->fullName, 0x0);
3172 ListAdd(specs, MkStructOrUnion(3, MkIdentifier(className), (((void *)0))));
3173 sprintf(className, "__simpleStruct%d", curContext->simpleID++);
3174 ListAdd(decls, MkInitDeclarator(MkDeclaratorIdentifier(MkIdentifier(className)), (((void *)0))));
3175 decl = MkDeclaration(specs, decls);
3176 if(curCompound)
3177 {
3178 if(!curCompound->compound.declarations)
3179 curCompound->compound.declarations = MkList();
3180 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Insert((&*curCompound->compound.declarations), (((void *)0)), decl);
3181 }
3182 tempExp = QMkExpId(className);
3183 tempExp->expType = MkClassType(propertyClass->fullName);
3184 if(convertTo)
3185 {
3186 ListAdd(args, FixReference(CopyExpression(tempExp), 0x1));
3187 ListAdd(args, FixReference(ptr, 0x1));
3188 }
3189 else
3190 {
3191 ListAdd(args, FixReference(ptr, 0x1));
3192 ListAdd(args, FixReference(CopyExpression(tempExp), 0x1));
3193 }
3194 if(((unsigned int)((exp->usage & 0x20) >> 5)))
3195 {
3196 exp->type = 7;
3197 exp->call.exp = QMkExpId(nameToUse);
3198 exp->call.arguments = args;
3199 FreeExpression(tempExp);
3200 }
3201 else
3202 {
3203 exp->type = 5;
3204 exp->list = MkList();
3205 ListAdd(exp->list, MkExpCall(QMkExpId(nameToUse), args));
3206 if(((unsigned int)((exp->usage & 0x10) >> 4)))
3207 {
3208 ListAdd(exp->list, FixReference(tempExp, 0x1));
3209 exp->byReference = 0x1;
3210 }
3211 else
3212 ListAdd(exp->list, tempExp);
3213 }
3214 }
3215 else
3216 {
3217 exp->type = 7;
3218 exp->call.exp = QMkExpId(nameToUse);
3219 exp->call.arguments = MkList();
3220 ListAdd(exp->call.arguments, FixReference(ptr, 0x1));
3221 }
3222 }
3223 else if(prop->conversion)
3224 {
3225 void * prev = exp->prev, * next = exp->next;
3226
3227 *exp = *exp->member.exp;
3228 exp->prev = prev;
3229 exp->next = next;
3230 }
3231 }
3232 }
3233 else if(classProperty)
3234 {
3235 if(((unsigned int)((exp->usage & 0x1) >> 0)))
3236 {
3237 if(classProperty->Get)
3238 {
3239 struct Identifier * id = exp->member.member;
3240 struct Expression * classExp = exp->member.exp;
3241
3242 exp->type = 7;
3243 exp->call.exp = MkExpIdentifier(MkIdentifier("ecere::com::eClass_GetProperty"));
3244 exp->call.arguments = MkList();
3245 ListAdd(exp->call.arguments, classExp);
3246 ListAdd(exp->call.arguments, MkExpString(QMkString(id->string)));
3247 FreeIdentifier(id);
3248 ProcessExpression(exp);
3249 return ;
3250 }
3251 }
3252 }
3253 else if(method)
3254 {
3255 if((((unsigned int)((exp->usage & 0x1) >> 0)) || exp->member.exp->expType->kind == 19) && !((unsigned int)((exp->usage & 0x8) >> 3)))
3256 {
3257 char name[1024];
3258
3259 FreeIdentifier(exp->member.member);
3260 exp->member.exp->usage = (exp->member.exp->usage & ~0x1) | (((unsigned int)0x1) << 0);
3261 ProcessExpression(exp->member.exp);
3262 if(method->type == 1)
3263 {
3264 strcpy(name, "__ecereVMethodID_");
3265 FullClassNameCat(name, method->_class->fullName, 0x0);
3266 strcat(name, "_");
3267 strcat(name, method->name);
3268 exp->type = 6;
3269 if(memberClassSpecifier)
3270 {
3271 char className[1024];
3272
3273 strcpy(className, "__ecereClass_");
3274 FullClassNameCat(className, _class->fullName, 0x1);
3275 MangleClassName(className);
3276 if(!_class->symbol)
3277 _class->symbol = FindClass(_class->fullName);
3278 DeclareClass(_class->symbol, className);
3279 exp->index.exp = MkExpPointer(MkExpIdentifier(MkIdentifier(className)), MkIdentifier("_vTbl"));
3280 }
3281 else
3282 {
3283 if(exp->thisPtr && _class->type != 0)
3284 {
3285 FreeExpression(exp->member.exp);
3286 exp->index.exp = MkExpPointer(MkExpIdentifier(MkIdentifier("class")), MkIdentifier("_vTbl"));
3287 }
3288 else
3289 exp->index.exp = MkExpPointer(exp->member.exp, MkIdentifier("_vTbl"));
3290 }
3291 exp->index.index = MkListOne(QMkExpId(name));
3292 DeclareMethod(method, name);
3293 }
3294 else
3295 {
3296 FreeExpression(exp->member.exp);
3297 exp->type = 0;
3298 strcpy(name, "__ecereMethod_");
3299 FullClassNameCat(name, method->_class->fullName, 0x0);
3300 strcat(name, "_");
3301 strcat(name, method->name);
3302 exp->identifier = MkIdentifier(name);
3303 DeclareMethod(method, name);
3304 }
3305 }
3306 }
3307 else if(member)
3308 {
3309 if(((unsigned int)((exp->usage & 0x1) >> 0)))
3310 {
3311 exp->member.exp->usage = (exp->member.exp->usage & ~0x1) | (((unsigned int)0x1) << 0);
3312 }
3313 ProcessExpression(exp->member.exp);
3314 if(type->kind == 8)
3315 DeclareStruct(type->_class->registered->fullName, 0x0);
3316 if(_class->type == 5)
3317 {
3318 noHead = 0x1;
3319 }
3320 else if(_class->type == 1)
3321 {
3322 changeToPtr = 0x1;
3323 }
3324 else if(_class->type == 2)
3325 {
3326 struct __ecereNameSpace__ecere__sys__OldList * list = MkList();
3327 char mask[32], shift[10];
3328 struct __ecereNameSpace__ecere__sys__OldList * specs = MkList();
3329 struct __ecereNameSpace__ecere__com__BitMember * bitMember = (struct __ecereNameSpace__ecere__com__BitMember *)member;
3330 struct Declarator * decl = SpecDeclFromString(bitMember->dataTypeString, specs, (((void *)0)));
3331 struct TypeName * type = MkTypeName(specs, decl);
3332
3333 if(bitMember->mask > (0xffffffff))
3334 sprintf(mask, ((__ecereNameSpace__ecere__com__GetRuntimePlatform() == 1) ? "0x%I64XLL" : "0x%llXLL"), bitMember->mask);
3335 else
3336 sprintf(mask, ((__ecereNameSpace__ecere__com__GetRuntimePlatform() == 1) ? "0x%I64X" : "0x%llX"), bitMember->mask);
3337 sprintf(shift, "%d", bitMember->pos);
3338 FreeIdentifier(exp->member.member);
3339 ListAdd(list, MkExpCast(type, MkExpBrackets(MkListOne(MkExpOp(MkExpBrackets(MkListOne(MkExpOp(exp->member.exp, '&', MkExpConstant(mask)))), RIGHT_OP, MkExpConstant(shift))))));
3340 exp->type = 5;
3341 exp->list = list;
3342 }
3343 else if(_class->type == 3)
3344 {
3345 }
3346 else
3347 {
3348 if(thisPtr)
3349 {
3350 char pointerName[1024];
3351
3352 strcpy(pointerName, "__ecerePointer_");
3353 FullClassNameCat(pointerName, type->_class->registered->fullName, 0x0);
3354 FreeIdentifier(exp->member.exp->identifier);
3355 exp->member.exp->identifier = MkIdentifier(pointerName);
3356 }
3357 else
3358 {
3359 struct Expression * bytePtr, * e;
3360 struct Expression * classExp;
3361 struct Expression * checkedExp;
3362 char structName[1024];
3363 char className[1024];
3364
3365 strcpy(className, "__ecereClass_");
3366 FullClassNameCat(className, member->_class->fullName, 0x1);
3367 MangleClassName(className);
3368 if(!member->_class->symbol)
3369 member->_class->symbol = FindClass(member->_class->fullName);
3370 DeclareClass(member->_class->symbol, className);
3371 DeclareStruct(member->_class->fullName, 0x0);
3372 structName[0] = (char)0;
3373 FullClassNameCat(structName, member->_class->fullName, 0x0);
3374 checkedExp = exp->member.exp;
3375 while(((checkedExp->type == 5 || checkedExp->type == 34) && checkedExp->list && (*checkedExp->list).count == 1) || checkedExp->type == 11)
3376 {
3377 if(checkedExp->type == 5 || checkedExp->type == 34)
3378 checkedExp = (*checkedExp->list).last;
3379 else if(checkedExp->type == 11)
3380 checkedExp = checkedExp->cast.exp;
3381 }
3382 if(checkedExp->type != 0 && checkedExp->type != 2 && checkedExp->type != 8 && checkedExp->type != 9)
3383 {
3384 int __simpleStruct0, __simpleStruct1;
3385 char ecereTemp[100];
3386 struct Statement * compound;
3387 struct __ecereNameSpace__ecere__sys__OldList * list = MkList();
3388 struct Context * context = PushContext();
3389
3390 if(exp->member.exp->tempCount > exp->tempCount)
3391 exp->tempCount = exp->member.exp->tempCount;
3392 exp->tempCount++;
3393 curExternal->function->tempCount = (__simpleStruct0 = curExternal->function->tempCount, __simpleStruct1 = exp->tempCount, (__simpleStruct0 > __simpleStruct1) ? __simpleStruct0 : __simpleStruct1);
3394 sprintf(ecereTemp, "__ecTemp%d", exp->tempCount);
3395 curContext = context;
3396 compound = MkCompoundStmt(MkListOne(MkDeclaration(MkListOne(MkSpecifier(CHAR)), MkListOne(MkInitDeclarator(MkDeclaratorPointer(MkPointer((((void *)0)), (((void *)0))), MkDeclaratorIdentifier(MkIdentifier(ecereTemp))), MkInitializerAssignment(QBrackets(exp->member.exp)))))), (((void *)0)));
3397 if(member->_class->fixed)
3398 {
3399 if(member->_class->templateClass ? member->_class->templateClass->offset : member->_class->offset)
3400 {
3401 char string[256];
3402
3403 sprintf(string, "%d", member->_class->templateClass ? member->_class->templateClass->offset : member->_class->offset);
3404 e = QBrackets(MkExpOp(QMkExpId(ecereTemp), '+', MkExpConstant(string)));
3405 }
3406 else
3407 e = QMkExpId(ecereTemp);
3408 }
3409 else
3410 {
3411 e = QBrackets(MkExpOp(QMkExpId(ecereTemp), '+', MkExpPointer(QMkExpId(className), MkIdentifier("offset"))));
3412 }
3413 compound->compound.context = context;
3414 compound->compound.statements = MkListOne(MkExpressionStmt(MkListOne(QBrackets(MkExpCast(MkTypeName(MkListOne(MkStructOrUnion(3, MkIdentifier(structName), (((void *)0)))), MkDeclaratorPointer(MkPointer((((void *)0)), (((void *)0))), (((void *)0)))), e)))));
3415 exp->member.exp = MkExpExtensionCompound(compound);
3416 PopContext(context);
3417 curContext = context->parent;
3418 }
3419 else
3420 {
3421 bytePtr = MkExpCast(QMkType("char", QMkPtrDecl((((void *)0)))), exp->member.exp);
3422 if(member->_class->fixed)
3423 {
3424 if(member->_class->templateClass ? member->_class->templateClass->offset : member->_class->offset)
3425 {
3426 char string[256];
3427
3428 sprintf(string, "%d", member->_class->templateClass ? member->_class->templateClass->offset : member->_class->offset);
3429 e = QBrackets(QBrackets(MkExpOp(bytePtr, '+', MkExpConstant(string))));
3430 }
3431 else
3432 e = bytePtr;
3433 }
3434 else
3435 e = QBrackets(QBrackets(MkExpOp(bytePtr, '+', MkExpPointer(QMkExpId(className), MkIdentifier("offset")))));
3436 exp->member.exp = QBrackets(MkExpCast(MkTypeName(MkListOne(MkStructOrUnion(3, MkIdentifier(structName), (((void *)0)))), QMkPtrDecl((((void *)0)))), e));
3437 }
3438 }
3439 exp->type = 9;
3440 }
3441 }
3442 }
3443 FreeSpecifier(memberClassSpecifier);
3444 if(exp->type == 8 || exp->type == 9)
3445 {
3446 exp->member.exp->usage = (exp->member.exp->usage & ~0x1) | (((unsigned int)0x1) << 0);
3447 exp->member.exp->usage = (exp->member.exp->usage & ~0x10) | (((unsigned int)0x1) << 4);
3448 exp->member.exp->tempCount = exp->tempCount;
3449 ProcessExpression(exp->member.exp);
3450 exp->tempCount = exp->member.exp->tempCount;
3451 if((changeToPtr && exp->member.exp->byReference) || noHead)
3452 exp->type = 9;
3453 }
3454 break;
3455 }
3456 case 25:
3457 {
3458 struct Expression * e = (*((struct Statement *)(*exp->compound->compound.statements).last)->expressions).last;
3459
3460 if(e)
3461 e->usage |= exp->usage & (((unsigned int)(0x1)) | (((unsigned int)(0x1)) << 2) | (((unsigned int)(0x1)) << 4));
3462 ProcessStatement(exp->compound);
3463 break;
3464 }
3465 case 9:
3466 {
3467 exp->member.exp->usage = (exp->member.exp->usage & ~0x1) | (((unsigned int)0x1) << 0);
3468 ProcessExpression(exp->member.exp);
3469 break;
3470 }
3471 case 10:
3472 {
3473 struct Specifier * spec = exp->typeName->qualifiers ? (*exp->typeName->qualifiers).first : (((void *)0));
3474
3475 if(spec && spec->type == 8 && !exp->typeName->declarator)
3476 {
3477 struct Expression * argExp = GetTemplateArgExp(spec->templateParameter, thisClass, 0x0);
3478
3479 if(argExp)
3480 {
3481 struct Expression * classExp;
3482
3483 FreeTypeName(exp->typeName);
3484 classExp = MkExpMember(argExp, MkIdentifier("dataTypeClass"));
3485 exp->type = 5;
3486 exp->list = MkListOne(MkExpCondition(MkExpBrackets(MkListOne(MkExpOp(MkExpOp(MkExpMember(CopyExpression(classExp), MkIdentifier("type")), EQ_OP, MkExpIdentifier(MkIdentifier("normalClass"))), OR_OP, MkExpOp(MkExpMember(CopyExpression(classExp), MkIdentifier("type")), EQ_OP, MkExpIdentifier(MkIdentifier("noHeadClass")))))), MkListOne(MkExpTypeSize(MkTypeName(MkListOne(MkSpecifier(VOID)), MkDeclaratorPointer(MkPointer((((void *)0)), (((void *)0))), (((void *)0)))))), MkExpMember(classExp, MkIdentifier("typeSize"))));
3487 ProcessExpressionType(exp);
3488 ProcessExpression(exp);
3489 }
3490 }
3491 break;
3492 }
3493 case 11:
3494 {
3495 if(exp->cast.exp)
3496 {
3497 exp->cast.exp->usage |= exp->usage & (((unsigned int)(0x1)) | (((unsigned int)(0x1)) << 4));
3498 ProcessExpression(exp->cast.exp);
3499 if(exp->cast.exp->byReference)
3500 exp->byReference = exp->cast.exp->byReference;
3501 if(exp->expType && exp->expType->kind == 8 && exp->expType->_class && exp->expType->_class->registered && exp->expType->_class->registered->type == 1 && exp->cast.exp->expType && (exp->cast.exp->expType->kind == 13 || exp->cast.exp->expType->kind == 12 || (exp->cast.exp->expType->kind == 8 && exp->cast.exp->expType->_class && exp->cast.exp->expType->_class->registered && !strcmp(exp->cast.exp->expType->_class->registered->dataTypeString, "char *"))))
3502 exp->byReference = 0x1;
3503 }
3504 break;
3505 }
3506 case 12:
3507 {
3508 struct Expression * e;
3509
3510 if(((unsigned int)((exp->usage & 0x1) >> 0)))
3511 exp->cond.cond->usage = (exp->cond.cond->usage & ~0x1) | (((unsigned int)0x1) << 0);
3512 ProcessExpression(exp->cond.cond);
3513 for(e = (*exp->cond.exp).first; e; e = e->next)
3514 {
3515 if(!e->next && ((unsigned int)((exp->usage & 0x1) >> 0)))
3516 e->usage = (e->usage & ~0x1) | (((unsigned int)0x1) << 0);
3517 ProcessExpression(e);
3518 }
3519 if(((unsigned int)((exp->usage & 0x1) >> 0)))
3520 exp->cond.elseExp->usage = (exp->cond.elseExp->usage & ~0x1) | (((unsigned int)0x1) << 0);
3521 ProcessExpression(exp->cond.elseExp);
3522 break;
3523 }
3524 case 26:
3525 {
3526 if(exp->_classExp.specifiers && (*exp->_classExp.specifiers).first && ((struct Specifier *)(*exp->_classExp.specifiers).first)->type == 8)
3527 {
3528 struct Specifier * spec = (*exp->_classExp.specifiers).first;
3529 struct Expression * argExp = GetTemplateArgExp(spec->templateParameter, thisClass, 0x1);
3530
3531 if(argExp)
3532 {
3533 FreeList(exp->_classExp.specifiers, FreeSpecifier);
3534 if(exp->_classExp.decl)
3535 FreeDeclarator(exp->_classExp.decl);
3536 exp->type = 8;
3537 exp->member.exp = argExp;
3538 exp->member.member = MkIdentifier("dataTypeClass");
3539 ProcessExpressionType(argExp);
3540 ProcessExpression(exp);
3541 }
3542 }
3543 else
3544 {
3545 char className[1024];
3546 char * string = StringFromSpecDecl(exp->_classExp.specifiers, exp->_classExp.decl);
3547
3548 strcpy(className, "__ecereClass_");
3549 FullClassNameCat(className, string, 0x1);
3550 MangleClassName(className);
3551 DeclareClass(FindClass(string), className);
3552 (__ecereNameSpace__ecere__com__eSystem_Delete(string), string = 0);
3553 FreeList(exp->_classExp.specifiers, FreeSpecifier);
3554 if(exp->_classExp.decl)
3555 FreeDeclarator(exp->_classExp.decl);
3556 exp->type = 0;
3557 exp->identifier = MkIdentifier(className);
3558 }
3559 break;
3560 }
3561 case 36:
3562 {
3563 ProcessExpression(exp->vaArg.exp);
3564 break;
3565 }
3566 case 35:
3567 {
3568 ProcessInitializer(exp->initializer.initializer);
3569 break;
3570 }
3571 }
3572 FixRefExp(exp);
3573 yylloc = oldyylloc;
3574 }
3575
3576 static void ProcessInitializer(struct Initializer * init)
3577 {
3578 switch(init->type)
3579 {
3580 case 0:
3581 init->exp->usage = (init->exp->usage & ~0x1) | (((unsigned int)0x1) << 0);
3582 ProcessExpression(init->exp);
3583 if(init->exp->destType && init->exp->destType->kind == 8 && init->exp->destType->_class && init->exp->destType->_class->registered && init->exp->destType->_class->registered->type == 5)
3584 {
3585 FixReference(init->exp, 0x1);
3586 }
3587 else if(init->exp->destType && init->exp->destType->kind == 8)
3588 FixReference(init->exp, 0x0);
3589 break;
3590 case 1:
3591 {
3592 struct Initializer * i;
3593
3594 for(i = (*init->list).first; i; i = i->next)
3595 ProcessInitializer(i);
3596 break;
3597 }
3598 }
3599 }
3600
3601 static void ProcessDeclaration(struct Declaration * decl)
3602 {
3603 switch(decl->type)
3604 {
3605 case 1:
3606 {
3607 if(decl->declarators)
3608 {
3609 struct InitDeclarator * d;
3610
3611 for(d = (*decl->declarators).first; d; d = d->next)
3612 {
3613 if(d->initializer)
3614 ProcessInitializer(d->initializer);
3615 }
3616 }
3617 break;
3618 }
3619 }
3620 }
3621
3622 static void ProcessStatement(struct Statement * stmt)
3623 {
3624 switch(stmt->type)
3625 {
3626 case 0:
3627 ProcessStatement(stmt->labeled.stmt);
3628 break;
3629 case 1:
3630 if(stmt->caseStmt.exp)
3631 {
3632 stmt->caseStmt.exp->usage = (stmt->caseStmt.exp->usage & ~0x1) | (((unsigned int)0x1) << 0);
3633 ProcessExpression(stmt->caseStmt.exp);
3634 }
3635 if(stmt->caseStmt.stmt)
3636 ProcessStatement(stmt->caseStmt.stmt);
3637 break;
3638 case 2:
3639 {
3640 if(stmt->compound.context)
3641 {
3642 struct Declaration * decl;
3643 struct Statement * s;
3644 struct Statement * prevCompound = curCompound;
3645 struct Context * prevContext = curContext;
3646
3647 if(!stmt->compound.isSwitch)
3648 {
3649 curCompound = stmt;
3650 curContext = stmt->compound.context;
3651 }
3652 if(stmt->compound.declarations)
3653 {
3654 for(decl = (*stmt->compound.declarations).first; decl; decl = decl->next)
3655 ProcessDeclaration(decl);
3656 }
3657 if(stmt->compound.statements)
3658 {
3659 for(s = (*stmt->compound.statements).first; s; s = s->next)
3660 ProcessStatement(s);
3661 }
3662 curContext = prevContext;
3663 curCompound = prevCompound;
3664 }
3665 break;
3666 }
3667 case 3:
3668 {
3669 struct Expression * exp;
3670
3671 if(stmt->expressions)
3672 {
3673 for(exp = (*stmt->expressions).first; exp; exp = exp->next)
3674 {
3675 ProcessExpression(exp);
3676 }
3677 }
3678 break;
3679 }
3680 case 4:
3681 {
3682 if(stmt->ifStmt.exp)
3683 {
3684 struct Expression * exp;
3685
3686 ((struct Expression *)(*stmt->ifStmt.exp).last)->usage = (((struct Expression *)(*stmt->ifStmt.exp).last)->usage & ~0x1) | (((unsigned int)0x1) << 0);
3687 for(exp = (*stmt->ifStmt.exp).first; exp; exp = exp->next)
3688 {
3689 ProcessExpression(exp);
3690 }
3691 }
3692 if(stmt->ifStmt.stmt)
3693 ProcessStatement(stmt->ifStmt.stmt);
3694 if(stmt->ifStmt.elseStmt)
3695 ProcessStatement(stmt->ifStmt.elseStmt);
3696 break;
3697 }
3698 case 5:
3699 {
3700 struct Expression * exp;
3701
3702 ((struct Expression *)(*stmt->switchStmt.exp).last)->usage = (((struct Expression *)(*stmt->switchStmt.exp).last)->usage & ~0x1) | (((unsigned int)0x1) << 0);
3703 for(exp = (*stmt->switchStmt.exp).first; exp; exp = exp->next)
3704 {
3705 ProcessExpression(exp);
3706 }
3707 ProcessStatement(stmt->switchStmt.stmt);
3708 break;
3709 }
3710 case 6:
3711 {
3712 struct Expression * exp;
3713
3714 ((struct Expression *)(*stmt->whileStmt.exp).last)->usage = (((struct Expression *)(*stmt->whileStmt.exp).last)->usage & ~0x1) | (((unsigned int)0x1) << 0);
3715 for(exp = (*stmt->whileStmt.exp).first; exp; exp = exp->next)
3716 {
3717 ProcessExpression(exp);
3718 }
3719 ProcessStatement(stmt->whileStmt.stmt);
3720 break;
3721 }
3722 case 7:
3723 {
3724 struct Expression * exp;
3725
3726 if(stmt->doWhile.exp && (*stmt->doWhile.exp).last)
3727 {
3728 ((struct Expression *)(*stmt->doWhile.exp).last)->usage = (((struct Expression *)(*stmt->doWhile.exp).last)->usage & ~0x1) | (((unsigned int)0x1) << 0);
3729 for(exp = (*stmt->doWhile.exp).first; exp; exp = exp->next)
3730 {
3731 ProcessExpression(exp);
3732 }
3733 }
3734 if(stmt->doWhile.stmt)
3735 ProcessStatement(stmt->doWhile.stmt);
3736 break;
3737 }
3738 case 8:
3739 {
3740 struct Expression * exp;
3741
3742 if(stmt->forStmt.init)
3743 ProcessStatement(stmt->forStmt.init);
3744 if(stmt->forStmt.check)
3745 {
3746 if(stmt->forStmt.check->expressions)
3747 {
3748 ((struct Expression *)(*stmt->forStmt.check->expressions).last)->usage = (((struct Expression *)(*stmt->forStmt.check->expressions).last)->usage & ~0x1) | (((unsigned int)0x1) << 0);
3749 }
3750 ProcessStatement(stmt->forStmt.check);
3751 }
3752 if(stmt->forStmt.increment)
3753 {
3754 for(exp = (*stmt->forStmt.increment).first; exp; exp = exp->next)
3755 {
3756 ProcessExpression(exp);
3757 }
3758 }
3759 if(stmt->forStmt.stmt)
3760 ProcessStatement(stmt->forStmt.stmt);
3761 break;
3762 }
3763 case 9:
3764 break;
3765 case 10:
3766 break;
3767 case 11:
3768 break;
3769 case 12:
3770 {
3771 struct Expression * exp;
3772
3773 if(stmt->expressions)
3774 {
3775 ((struct Expression *)(*stmt->expressions).last)->usage = (((struct Expression *)(*stmt->expressions).last)->usage & ~0x1) | (((unsigned int)0x1) << 0);
3776 for(exp = (*stmt->expressions).first; exp; exp = exp->next)
3777 {
3778 ProcessExpression(exp);
3779 if(!exp->next && exp->destType && exp->destType->byReference)
3780 FixReference(exp, 0x1);
3781 }
3782 }
3783 break;
3784 }
3785 case 14:
3786 {
3787 ProcessDeclaration(stmt->decl);
3788 break;
3789 }
3790 case 13:
3791 {
3792 struct AsmField * field;
3793
3794 if(stmt->asmStmt.inputFields)
3795 {
3796 for(field = (*stmt->asmStmt.inputFields).first; field; field = field->next)
3797 if(field->expression)
3798 ProcessExpression(field->expression);
3799 }
3800 if(stmt->asmStmt.outputFields)
3801 {
3802 for(field = (*stmt->asmStmt.outputFields).first; field; field = field->next)
3803 if(field->expression)
3804 ProcessExpression(field->expression);
3805 }
3806 if(stmt->asmStmt.clobberedFields)
3807 {
3808 for(field = (*stmt->asmStmt.clobberedFields).first; field; field = field->next)
3809 if(field->expression)
3810 ProcessExpression(field->expression);
3811 }
3812 break;
3813 }
3814 }
3815 }
3816
3817 static void ProcessFunction(struct FunctionDefinition * function)
3818 {
3819 if(function->body)
3820 ProcessStatement(function->body);
3821 }
3822
3823 static void ProcessMemberInitData(struct MemberInit * member)
3824 {
3825 if(member->initializer)
3826 ProcessInitializer(member->initializer);
3827 }
3828
3829 static void ProcessInstantiation(struct Instantiation * inst)
3830 {
3831 if(inst->members)
3832 {
3833 struct MembersInit * members;
3834
3835 for(members = (*inst->members).first; members; members = members->next)
3836 {
3837 if(members->type == 0)
3838 {
3839 if(members->dataMembers)
3840 {
3841 struct MemberInit * member;
3842
3843 for(member = (*members->dataMembers).first; member; member = member->next)
3844 ProcessMemberInitData(member);
3845 }
3846 }
3847 else if(members->type == 1)
3848 {
3849 ProcessFunction((struct FunctionDefinition *)members->function);
3850 }
3851 }
3852 }
3853 }
3854
3855 extern struct __ecereNameSpace__ecere__sys__OldList *  ast;
3856
3857 void ProcessMemberAccess()
3858 {
3859 struct External * external;
3860
3861 for(external = (*ast).first; external; external = external->next)
3862 {
3863 curExternal = external;
3864 if(external->type == 1)
3865 {
3866 if(external->declaration)
3867 ProcessDeclaration(external->declaration);
3868 }
3869 }
3870 for(external = (*ast).first; external; external = external->next)
3871 {
3872 curExternal = external;
3873 if(external->type == 0)
3874 {
3875 ProcessFunction(external->function);
3876 }
3877 else if(external->type == 1)
3878 {
3879 if(external->declaration)
3880 ProcessDeclaration(external->declaration);
3881 }
3882 else if(external->type == 2)
3883 {
3884 struct ClassDefinition * _class = external->_class;
3885
3886 if(_class->definitions)
3887 {
3888 struct ClassDef * def;
3889 struct __ecereNameSpace__ecere__com__Class * regClass = _class->symbol->registered;
3890
3891 for(def = (*_class->definitions).first; def; def = def->next)
3892 {
3893 if(def->type == 0)
3894 {
3895 curExternal = def->function->declarator->symbol->pointerExternal;
3896 ProcessFunction((struct FunctionDefinition *)def->function);
3897 }
3898 else if(def->type == 2 && def->decl->type == 2)
3899 {
3900 ProcessInstantiation(def->decl->inst);
3901 }
3902 else if(def->type == 1 && def->defProperties)
3903 {
3904 struct MemberInit * defProperty;
3905 struct Symbol * thisSymbol = (thisSymbol = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass_Symbol), thisSymbol->string = __ecereNameSpace__ecere__sys__CopyString("this"), thisSymbol->type = MkClassType(regClass->fullName), thisSymbol);
3906
3907 __ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_Add(&globalContext->symbols, (struct __ecereNameSpace__ecere__sys__BTNode *)thisSymbol);
3908 for(defProperty = (*def->defProperties).first; defProperty; defProperty = defProperty->next)
3909 {
3910 ProcessMemberInitData(defProperty);
3911 }
3912 __ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_Remove(&globalContext->symbols, (struct __ecereNameSpace__ecere__sys__BTNode *)thisSymbol);
3913 FreeSymbol(thisSymbol);
3914 }
3915 else if(def->type == 3 && def->propertyDef)
3916 {
3917 struct PropertyDef * prop = def->propertyDef;
3918 struct Symbol * thisSymbol = (thisSymbol = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass_Symbol), thisSymbol->string = __ecereNameSpace__ecere__sys__CopyString("this"), thisSymbol->type = MkClassType(regClass->fullName), thisSymbol);
3919
3920 __ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_Add(&globalContext->symbols, (struct __ecereNameSpace__ecere__sys__BTNode *)thisSymbol);
3921 if(prop->setStmt)
3922 {
3923 curExternal = prop->symbol->externalSet;
3924 ProcessStatement(prop->setStmt);
3925 }
3926 if(prop->getStmt)
3927 {
3928 curExternal = prop->symbol->externalGet;
3929 ProcessStatement(prop->getStmt);
3930 }
3931 if(prop->issetStmt)
3932 {
3933 curExternal = prop->symbol->externalIsSet;
3934 ProcessStatement(prop->issetStmt);
3935 }
3936 __ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_Remove(&globalContext->symbols, (struct __ecereNameSpace__ecere__sys__BTNode *)thisSymbol);
3937 FreeSymbol(thisSymbol);
3938 }
3939 else if(def->type == 10 && def->propertyDef)
3940 {
3941 struct PropertyDef * prop = def->propertyDef;
3942
3943 if(prop->setStmt)
3944 {
3945 curExternal = prop->symbol->externalSet;
3946 ProcessStatement(prop->setStmt);
3947 }
3948 if(prop->getStmt)
3949 {
3950 curExternal = prop->symbol->externalGet;
3951 ProcessStatement(prop->getStmt);
3952 }
3953 }
3954 else if(def->type == 4 && def->propertyWatch)
3955 {
3956 struct PropertyWatch * propertyWatch = def->propertyWatch;
3957 struct Symbol * thisSymbol = (thisSymbol = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass_Symbol), thisSymbol->string = __ecereNameSpace__ecere__sys__CopyString("this"), thisSymbol->type = MkClassType(regClass->fullName), thisSymbol);
3958
3959 __ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_Add(&globalContext->symbols, (struct __ecereNameSpace__ecere__sys__BTNode *)thisSymbol);
3960 if(propertyWatch->compound)
3961 {
3962 struct Symbol * thisSymbol = (thisSymbol = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass_Symbol), thisSymbol->string = __ecereNameSpace__ecere__sys__CopyString("this"), thisSymbol->type = MkClassType(regClass->fullName), thisSymbol);
3963
3964 __ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_Add(&propertyWatch->compound->compound.context->symbols, (struct __ecereNameSpace__ecere__sys__BTNode *)thisSymbol);
3965 curExternal = (((void *)0));
3966 ProcessStatement(propertyWatch->compound);
3967 }
3968 __ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_Remove(&globalContext->symbols, (struct __ecereNameSpace__ecere__sys__BTNode *)thisSymbol);
3969 FreeSymbol(thisSymbol);
3970 }
3971 }
3972 }
3973 }
3974 }
3975 }
3976
3977 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass___ecereNameSpace__ecere__com__GlobalFunction;
3978
3979 struct __ecereNameSpace__ecere__com__GlobalFunction;
3980
3981 extern struct __ecereNameSpace__ecere__com__GlobalFunction * __ecereNameSpace__ecere__com__eSystem_RegisterFunction(char *  name, char *  type, void *  func, struct __ecereNameSpace__ecere__com__Instance * module, int declMode);
3982
3983 void __ecereRegisterModule_pass2(struct __ecereNameSpace__ecere__com__Instance * module)
3984 {
3985 struct __ecereNameSpace__ecere__com__Class * class;
3986
3987 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("ProcessMemberAccess", "void ProcessMemberAccess(void)", ProcessMemberAccess, module, 1);
3988 }
3989
3990 void __ecereUnregisterModule_pass2(struct __ecereNameSpace__ecere__com__Instance * module)
3991 {
3992
3993 }
3994