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

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