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