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

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