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__eInstance_FireSelfWatchers(struct __ecereNameSpace__ecere__com__Instance * instance, struct __ecereNameSpace__ecere__com__Property * _property);
 831
 832 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass___ecereNameSpace__ecere__com__Instance;
 833
 834 struct __ecereNameSpace__ecere__com__Instance
 835 {
 836 int (* *  _vTbl)();
 837 struct __ecereNameSpace__ecere__com__Class * _class;
 838 int _refCount;
 839 } __attribute__ ((gcc_struct));
 840
 841 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass___ecereNameSpace__ecere__com__DataMember;
 842
 843 struct __ecereNameSpace__ecere__com__DataMember
 844 {
 845 struct __ecereNameSpace__ecere__com__DataMember * prev;
 846 struct __ecereNameSpace__ecere__com__DataMember * next;
 847 char *  name;
 848 unsigned int isProperty;
 849 int memberAccess;
 850 int id;
 851 struct __ecereNameSpace__ecere__com__Class * _class;
 852 char *  dataTypeString;
 853 struct __ecereNameSpace__ecere__com__Class * dataTypeClass;
 854 struct Type * dataType;
 855 int type;
 856 int offset;
 857 int memberID;
 858 struct __ecereNameSpace__ecere__sys__OldList members;
 859 struct __ecereNameSpace__ecere__sys__BinaryTree membersAlpha;
 860 int memberOffset;
 861 int structAlignment;
 862 } __attribute__ ((gcc_struct));
 863
 864 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass___ecereNameSpace__ecere__com__SerialBuffer;
 865
 866 struct __ecereNameSpace__ecere__com__SerialBuffer
 867 {
 868 unsigned char *  _buffer;
 869 unsigned int count;
 870 unsigned int _size;
 871 unsigned int pos;
 872 } __attribute__ ((gcc_struct));
 873
 874 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass___ecereNameSpace__ecere__com__ClassTemplateArgument;
 875
 876 struct __ecereNameSpace__ecere__com__ClassTemplateArgument
 877 {
 878 union
 879 {
 880 struct
 881 {
 882 char *  dataTypeString;
 883 struct __ecereNameSpace__ecere__com__Class * dataTypeClass;
 884 } __attribute__ ((gcc_struct));
 885 struct __ecereNameSpace__ecere__com__DataValue expression;
 886 struct
 887 {
 888 char *  memberString;
 889 union
 890 {
 891 struct __ecereNameSpace__ecere__com__DataMember * member;
 892 struct __ecereNameSpace__ecere__com__Property * prop;
 893 struct __ecereNameSpace__ecere__com__Method * method;
 894 } __attribute__ ((gcc_struct));
 895 } __attribute__ ((gcc_struct));
 896 } __attribute__ ((gcc_struct));
 897 } __attribute__ ((gcc_struct));
 898
 899 enum yytokentype
 900 {
 901 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
 902 };
 903
 904 typedef union YYSTYPE
 905 {
 906 int specifierType;
 907 int i;
 908 int declMode;
 909 struct Identifier * id;
 910 struct Expression * exp;
 911 struct Specifier * specifier;
 912 struct __ecereNameSpace__ecere__sys__OldList * list;
 913 struct Enumerator * enumerator;
 914 struct Declarator * declarator;
 915 struct Pointer * pointer;
 916 struct Initializer * initializer;
 917 struct InitDeclarator * initDeclarator;
 918 struct TypeName * typeName;
 919 struct Declaration * declaration;
 920 struct Statement * stmt;
 921 struct FunctionDefinition * function;
 922 struct External * external;
 923 struct Context * context;
 924 struct AsmField * asmField;
 925 struct Attrib * attrib;
 926 struct ExtDecl * extDecl;
 927 struct Attribute * attribute;
 928 struct Instantiation * instance;
 929 struct MembersInit * membersInit;
 930 struct MemberInit * memberInit;
 931 struct ClassFunction * classFunction;
 932 struct ClassDefinition * _class;
 933 struct ClassDef * classDef;
 934 struct PropertyDef * prop;
 935 char * string;
 936 struct Symbol * symbol;
 937 struct PropertyWatch * propertyWatch;
 938 struct TemplateParameter * templateParameter;
 939 struct TemplateArgument * templateArgument;
 940 struct TemplateDatatype * templateDatatype;
 941 struct DBTableEntry * dbtableEntry;
 942 struct DBIndexItem * dbindexItem;
 943 struct DBTableDef * dbtableDef;
 944 } __attribute__ ((gcc_struct)) YYSTYPE;
 945
 946 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_Enumerator;
 947
 948 struct Enumerator
 949 {
 950 struct Enumerator * prev;
 951 struct Enumerator * next;
 952 struct Location loc;
 953 struct Identifier * id;
 954 struct Expression * exp;
 955 } __attribute__ ((gcc_struct));
 956
 957 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_InitDeclarator;
 958
 959 struct InitDeclarator
 960 {
 961 struct InitDeclarator * prev;
 962 struct InitDeclarator * next;
 963 struct Location loc;
 964 struct Declarator * declarator;
 965 struct Initializer * initializer;
 966 } __attribute__ ((gcc_struct));
 967
 968 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_AsmField;
 969
 970 struct AsmField
 971 {
 972 struct AsmField * prev;
 973 struct AsmField * next;
 974 struct Location loc;
 975 char *  command;
 976 struct Expression * expression;
 977 struct Identifier * symbolic;
 978 } __attribute__ ((gcc_struct));
 979
 980 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_Attribute;
 981
 982 struct Attribute;
 983
 984 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_ClassFunction;
 985
 986 struct ClassFunction
 987 {
 988 struct ClassFunction * prev;
 989 struct ClassFunction * next;
 990 struct Location loc;
 991 struct __ecereNameSpace__ecere__sys__OldList *  specifiers;
 992 struct Declarator * declarator;
 993 struct __ecereNameSpace__ecere__sys__OldList *  declarations;
 994 struct Statement * body;
 995 struct __ecereNameSpace__ecere__com__Class * _class;
 996 struct __ecereNameSpace__ecere__sys__OldList attached;
 997 int declMode;
 998 struct Type * type;
 999 struct Symbol * propSet;
1000 unsigned int isVirtual;
1001 unsigned int isConstructor;
1002 unsigned int isDestructor;
1003 unsigned int dontMangle;
1004 int id;
1005 int idCode;
1006 } __attribute__ ((gcc_struct));
1007
1008 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_MembersInit;
1009
1010 struct MembersInit
1011 {
1012 struct MembersInit * prev;
1013 struct MembersInit * next;
1014 struct Location loc;
1015 int type;
1016 union
1017 {
1018 struct __ecereNameSpace__ecere__sys__OldList *  dataMembers;
1019 struct ClassFunction * function;
1020 } __attribute__ ((gcc_struct));
1021 } __attribute__ ((gcc_struct));
1022
1023 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_MemberInit;
1024
1025 struct MemberInit
1026 {
1027 struct MemberInit * prev;
1028 struct MemberInit * next;
1029 struct Location loc;
1030 struct Location realLoc;
1031 struct __ecereNameSpace__ecere__sys__OldList *  identifiers;
1032 struct Initializer * initializer;
1033 unsigned int used;
1034 unsigned int variable;
1035 unsigned int takeOutExp;
1036 } __attribute__ ((gcc_struct));
1037
1038 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_PropertyDef;
1039
1040 struct PropertyDef
1041 {
1042 struct PropertyDef * prev;
1043 struct PropertyDef * next;
1044 struct Location loc;
1045 struct __ecereNameSpace__ecere__sys__OldList *  specifiers;
1046 struct Declarator * declarator;
1047 struct Identifier * id;
1048 struct Statement * getStmt;
1049 struct Statement * setStmt;
1050 struct Statement * issetStmt;
1051 struct Symbol * symbol;
1052 struct Expression * category;
1053 struct
1054 {
1055 unsigned int conversion : 1;
1056 unsigned int isWatchable : 1;
1057 unsigned int isDBProp : 1;
1058 } __attribute__ ((gcc_struct));
1059 } __attribute__ ((gcc_struct));
1060
1061 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_PropertyWatch;
1062
1063 struct PropertyWatch
1064 {
1065 struct PropertyWatch * prev;
1066 struct PropertyWatch * next;
1067 struct Location loc;
1068 struct Statement * compound;
1069 struct __ecereNameSpace__ecere__sys__OldList *  properties;
1070 unsigned int deleteWatch;
1071 } __attribute__ ((gcc_struct));
1072
1073 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_ClassDef;
1074
1075 struct ClassDef
1076 {
1077 struct ClassDef * prev;
1078 struct ClassDef * next;
1079 struct Location loc;
1080 int type;
1081 union
1082 {
1083 struct Declaration * decl;
1084 struct ClassFunction * function;
1085 struct __ecereNameSpace__ecere__sys__OldList *  defProperties;
1086 struct PropertyDef * propertyDef;
1087 struct PropertyWatch * propertyWatch;
1088 char *  designer;
1089 struct Identifier * defaultProperty;
1090 struct
1091 {
1092 struct Identifier * id;
1093 struct Initializer * initializer;
1094 } __attribute__ ((gcc_struct));
1095 } __attribute__ ((gcc_struct));
1096 int memberAccess;
1097 void *  object;
1098 } __attribute__ ((gcc_struct));
1099
1100 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_DBTableEntry;
1101
1102 struct DBTableEntry;
1103
1104 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_DBIndexItem;
1105
1106 struct DBIndexItem;
1107
1108 extern YYSTYPE yylval;
1109
1110 extern struct Location yylloc;
1111
1112 extern struct External * curExternal;
1113
1114 static struct Statement * curCompound;
1115
1116 static struct Statement * createInstancesBody;
1117
1118 static struct Statement * destroyInstancesBody;
1119
1120 extern unsigned int inCompiler;
1121
1122 extern struct Statement * MkCompoundStmt(struct __ecereNameSpace__ecere__sys__OldList * declarations, struct __ecereNameSpace__ecere__sys__OldList * statements);
1123
1124 extern struct __ecereNameSpace__ecere__sys__OldList *  MkList(void);
1125
1126 extern struct Context * globalContext;
1127
1128 extern void ListAdd(struct __ecereNameSpace__ecere__sys__OldList * list, void *  item);
1129
1130 extern struct Specifier * MkSpecifier(int specifier);
1131
1132 extern char *  __ecereNameSpace__ecere__sys__GetLastDirectory(char *  string, char *  output);
1133
1134 extern char *  outputFile;
1135
1136 extern unsigned int __ecereNameSpace__ecere__sys__StripExtension(char *  string);
1137
1138 extern void FixModuleName(char *  moduleName);
1139
1140 extern int sprintf(char * , char * , ...);
1141
1142 extern struct Declarator * MkDeclaratorFunction(struct Declarator * declarator, struct __ecereNameSpace__ecere__sys__OldList * parameters);
1143
1144 extern struct Declarator * MkDeclaratorIdentifier(struct Identifier * id);
1145
1146 extern struct Identifier * MkIdentifier(char *  string);
1147
1148 extern struct FunctionDefinition * _MkFunction(struct __ecereNameSpace__ecere__sys__OldList * specifiers, struct Declarator * declarator, struct __ecereNameSpace__ecere__sys__OldList * declarationList, unsigned int errorOnOmit);
1149
1150 extern void ProcessFunctionBody(struct FunctionDefinition * func, struct Statement * body);
1151
1152 extern struct __ecereNameSpace__ecere__sys__OldList *  ast;
1153
1154 extern struct External * MkExternalFunction(struct FunctionDefinition * function);
1155
1156 extern void *  __ecereNameSpace__ecere__com__eInstance_New(struct __ecereNameSpace__ecere__com__Class * _class);
1157
1158 static void CreateInstancesBody()
1159 {
1160 if(inCompiler && !createInstancesBody)
1161 {
1162 char registerName[1024], moduleName[274];
1163 struct __ecereNameSpace__ecere__sys__OldList * specifiers;
1164 struct Declarator * declarator;
1165
1166 createInstancesBody = MkCompoundStmt((((void *)0)), MkList());
1167 createInstancesBody->compound.context = __extension__ ({
1168 struct Context * __ecereInstance1 = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass_Context);
1169
1170 __ecereInstance1->parent = globalContext, __ecereInstance1;
1171 });
1172 specifiers = MkList();
1173 ListAdd(specifiers, MkSpecifier(VOID));
1174 __ecereNameSpace__ecere__sys__GetLastDirectory(outputFile, moduleName);
1175 __ecereNameSpace__ecere__sys__StripExtension(moduleName);
1176 FixModuleName(moduleName);
1177 sprintf(registerName, "__ecereCreateModuleInstances_%s", moduleName);
1178 declarator = MkDeclaratorFunction(MkDeclaratorIdentifier(MkIdentifier(registerName)), (((void *)0)));
1179 {
1180 struct FunctionDefinition * function = _MkFunction(specifiers, declarator, (((void *)0)), 0x0);
1181
1182 ProcessFunctionBody(function, createInstancesBody);
1183 ListAdd(ast, MkExternalFunction(function));
1184 }
1185 destroyInstancesBody = MkCompoundStmt((((void *)0)), MkList());
1186 destroyInstancesBody->compound.context = __extension__ ({
1187 struct Context * __ecereInstance1 = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass_Context);
1188
1189 __ecereInstance1->parent = globalContext, __ecereInstance1;
1190 });
1191 specifiers = MkList();
1192 ListAdd(specifiers, MkSpecifier(VOID));
1193 sprintf(registerName, "__ecereDestroyModuleInstances_%s", moduleName);
1194 declarator = MkDeclaratorFunction(MkDeclaratorIdentifier(MkIdentifier(registerName)), (((void *)0)));
1195 {
1196 struct FunctionDefinition * function = _MkFunction(specifiers, declarator, (((void *)0)), 0x0);
1197
1198 ProcessFunctionBody(function, destroyInstancesBody);
1199 ListAdd(ast, MkExternalFunction(function));
1200 }
1201 }
1202 }
1203
1204 static void ProcessInitializer(struct Initializer * init);
1205
1206 static void ProcessMemberInitData(struct MemberInit * member)
1207 {
1208 if(member->initializer)
1209 ProcessInitializer(member->initializer);
1210 }
1211
1212 static void ProcessFunction(struct FunctionDefinition * function);
1213
1214 static void ProcessInstantiation(struct Instantiation * inst)
1215 {
1216 if(inst->members && (*inst->members).first)
1217 {
1218 struct MembersInit * members;
1219
1220 for(members = (*inst->members).first; members; members = members->next)
1221 {
1222 if(members->type == 0)
1223 {
1224 if(members->dataMembers)
1225 {
1226 struct MemberInit * member;
1227
1228 for(member = (*members->dataMembers).first; member; member = member->next)
1229 ProcessMemberInitData(member);
1230 }
1231 }
1232 else if(members->type == 1)
1233 {
1234 ProcessFunction((struct FunctionDefinition *)members->function);
1235 }
1236 }
1237 }
1238 }
1239
1240 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);
1241
1242 extern struct __ecereNameSpace__ecere__com__Instance * privateModule;
1243
1244 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);
1245
1246 extern void *  memcpy(void * , const void * , size_t size);
1247
1248 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);
1249
1250 extern struct Expression * CopyExpression(struct Expression * exp);
1251
1252 extern struct Expression * MkExpConstant(char *  string);
1253
1254 extern struct Expression * MkExpMember(struct Expression * expression, struct Identifier * member);
1255
1256 extern struct Expression * MkExpOp(struct Expression * exp1, int op, struct Expression * exp2);
1257
1258 extern void FreeType(struct Type * type);
1259
1260 extern void ProcessExpressionType(struct Expression * exp);
1261
1262 static void ProcessExpression(struct Expression * exp);
1263
1264 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)
1265 {
1266 struct Symbol * classSym = inst->_class->symbol;
1267 unsigned int fullSet = 0x1;
1268 struct __ecereNameSpace__ecere__com__DataMember * dataMember;
1269
1270 for(dataMember = parentMember->members.first; dataMember; dataMember = dataMember->next)
1271 {
1272 if(!dataMember->isProperty)
1273 {
1274 if(!dataMember->name && (dataMember->type == 1 || dataMember->type == 2))
1275 {
1276 if(!ProcessInstMembers_SimpleMemberEnsure(dataMember, inst, instExp, list, zeroOut))
1277 fullSet = 0x0;
1278 }
1279 else
1280 {
1281 unsigned int memberFilled = 0x0;
1282
1283 if(inst->members && (*inst->members).first)
1284 {
1285 struct __ecereNameSpace__ecere__com__Class * curClass = (((void *)0));
1286 struct __ecereNameSpace__ecere__com__DataMember * curMember = (((void *)0));
1287 struct __ecereNameSpace__ecere__com__DataMember * subMemberStack[256];
1288 int subMemberStackPos = 0;
1289 struct MembersInit * members;
1290
1291 for(members = (*inst->members).first; members; members = members->next)
1292 {
1293 if(members->type == 0)
1294 {
1295 struct MemberInit * member = (((void *)0));
1296
1297 for(member = (*members->dataMembers).first; member; member = member->next)
1298 {
1299 if(member->identifiers)
1300 {
1301 struct Identifier * firstID = (*member->identifiers).first;
1302 struct __ecereNameSpace__ecere__com__DataMember * _subMemberStack[256];
1303 int _subMemberStackPos = 0;
1304 struct __ecereNameSpace__ecere__com__DataMember * thisMember = (struct __ecereNameSpace__ecere__com__DataMember *)__ecereNameSpace__ecere__com__eClass_FindProperty(classSym->registered, firstID->string, privateModule);
1305
1306 if(!thisMember)
1307 thisMember = __ecereNameSpace__ecere__com__eClass_FindDataMember(classSym->registered, firstID->string, privateModule, _subMemberStack, &_subMemberStackPos);
1308 if(thisMember)
1309 {
1310 if(thisMember && thisMember->memberAccess == 1)
1311 {
1312 curMember = thisMember;
1313 curClass = curMember->_class;
1314 memcpy(subMemberStack, _subMemberStack, sizeof(struct __ecereNameSpace__ecere__com__DataMember *) * _subMemberStackPos);
1315 subMemberStackPos = _subMemberStackPos;
1316 }
1317 if(!firstID->next && thisMember == dataMember)
1318 {
1319 memberFilled = 0x1;
1320 break;
1321 }
1322 }
1323 }
1324 else
1325 {
1326 __ecereNameSpace__ecere__com__eClass_FindNextMember(classSym->registered, &curClass, &curMember, subMemberStack, &subMemberStackPos);
1327 if(curMember == dataMember)
1328 {
1329 memberFilled = 0x1;
1330 break;
1331 }
1332 }
1333 }
1334 if(memberFilled)
1335 break;
1336 }
1337 if(memberFilled)
1338 break;
1339 }
1340 }
1341 if(!memberFilled)
1342 {
1343 if(zeroOut)
1344 {
1345 struct Expression * instExpCopy = CopyExpression(instExp);
1346 struct Expression * memberExp;
1347 struct Expression * setExp;
1348 struct Expression * value = MkExpConstant("0");
1349
1350 memberExp = MkExpMember(instExpCopy, MkIdentifier(dataMember->name));
1351 memberExp->member.memberType = 3;
1352 value->usage = (value->usage & ~0x1) | (((unsigned int)0x1) << 0);
1353 setExp = MkExpOp(memberExp, '=', value);
1354 value->loc = inst->loc;
1355 setExp->loc = inst->loc;
1356 FreeType(instExpCopy->expType);
1357 instExpCopy->expType = instExp->expType;
1358 if(instExp->expType)
1359 instExp->expType->refCount++;
1360 ProcessExpressionType(setExp);
1361 ProcessExpression(setExp);
1362 ListAdd(list, setExp);
1363 }
1364 fullSet = 0x0;
1365 }
1366 }
1367 }
1368 }
1369 return fullSet;
1370 }
1371
1372 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass___ecereNameSpace__ecere__com__BitMember;
1373
1374 struct __ecereNameSpace__ecere__com__BitMember
1375 {
1376 struct __ecereNameSpace__ecere__com__BitMember * prev;
1377 struct __ecereNameSpace__ecere__com__BitMember * next;
1378 char *  name;
1379 unsigned int isProperty;
1380 int memberAccess;
1381 int id;
1382 struct __ecereNameSpace__ecere__com__Class * _class;
1383 char *  dataTypeString;
1384 struct __ecereNameSpace__ecere__com__Class * dataTypeClass;
1385 struct Type * dataType;
1386 int type;
1387 int size;
1388 int pos;
1389 uint64 mask;
1390 } __attribute__ ((gcc_struct));
1391
1392 extern struct Declarator * SpecDeclFromString(char *  string, struct __ecereNameSpace__ecere__sys__OldList *  specs, struct Declarator * baseDecl);
1393
1394 extern struct Expression * MkExpBrackets(struct __ecereNameSpace__ecere__sys__OldList * expressions);
1395
1396 extern struct __ecereNameSpace__ecere__sys__OldList *  MkListOne(void *  item);
1397
1398 extern struct Expression * MkExpCast(struct TypeName * typeName, struct Expression * expression);
1399
1400 extern struct TypeName * MkTypeName(struct __ecereNameSpace__ecere__sys__OldList * qualifiers, struct Declarator * declarator);
1401
1402 extern void FreeInitializer(struct Initializer * initializer);
1403
1404 extern void DeclareProperty(struct __ecereNameSpace__ecere__com__Property * prop, char *  setName, char *  getName);
1405
1406 extern struct Expression * MkExpCall(struct Expression * expression, struct __ecereNameSpace__ecere__sys__OldList * arguments);
1407
1408 extern struct Expression * MkExpIdentifier(struct Identifier * id);
1409
1410 extern struct Type * MkClassType(char *  name);
1411
1412 extern struct TypeName * QMkClass(char *  spec, struct Declarator * decl);
1413
1414 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);
1415
1416 extern void FreeExpression(struct Expression * exp);
1417
1418 void __ecereMethod___ecereNameSpace__ecere__sys__OldList_Clear(struct __ecereNameSpace__ecere__sys__OldList * this);
1419
1420 static unsigned int ProcessInstMembers(struct Instantiation * inst, struct Expression * instExp, struct __ecereNameSpace__ecere__sys__OldList * list, unsigned int zeroOut)
1421 {
1422 struct MembersInit * members;
1423 struct Symbol * classSym = inst->_class->symbol;
1424 unsigned int fullSet = 0x1, convert = 0x0;
1425
1426 if(classSym && classSym->registered && classSym->registered->type == 2)
1427 {
1428 struct Expression * exp = (((void *)0));
1429
1430 if(inst->members && (*inst->members).first)
1431 {
1432 struct __ecereNameSpace__ecere__com__Class * _class = (((void *)0));
1433
1434 while(_class != classSym->registered)
1435 {
1436 struct __ecereNameSpace__ecere__com__BitMember * bitMember = (((void *)0));
1437 struct __ecereNameSpace__ecere__com__Class * lastClass = _class;
1438
1439 for(_class = classSym->registered; _class->base != lastClass && _class->base->type != 1000; _class = _class->base)
1440 ;
1441 for(bitMember = _class->membersAndProperties.first; bitMember; bitMember = bitMember->next)
1442 {
1443 struct __ecereNameSpace__ecere__com__BitMember * curMember = (((void *)0));
1444 struct __ecereNameSpace__ecere__com__Class * curClass = (((void *)0));
1445 struct __ecereNameSpace__ecere__com__DataMember * subMemberStack[256];
1446 int subMemberStackPos = 0;
1447 struct MemberInit * member = (((void *)0));
1448 unsigned int found = 0x0;
1449
1450 for(members = (*inst->members).first; members; members = members->next)
1451 {
1452 if(members->type == 0)
1453 {
1454 for(member = (*members->dataMembers).first; member; member = member->next)
1455 {
1456 if(member->identifiers)
1457 {
1458 struct Identifier * firstID = (*member->identifiers).first;
1459 struct __ecereNameSpace__ecere__com__DataMember * _subMemberStack[256];
1460 int _subMemberStackPos = 0;
1461 struct __ecereNameSpace__ecere__com__BitMember * thisMember = (struct __ecereNameSpace__ecere__com__BitMember *)__ecereNameSpace__ecere__com__eClass_FindDataMember(_class, firstID->string, privateModule, _subMemberStack, &_subMemberStackPos);
1462
1463 if(!thisMember)
1464 {
1465 thisMember = (struct __ecereNameSpace__ecere__com__BitMember *)__ecereNameSpace__ecere__com__eClass_FindProperty(_class, firstID->string, privateModule);
1466 }
1467 if(thisMember && thisMember->memberAccess == 1)
1468 {
1469 curMember = thisMember;
1470 curClass = curMember->_class;
1471 memcpy(subMemberStack, _subMemberStack, sizeof(struct __ecereNameSpace__ecere__com__DataMember *) * _subMemberStackPos);
1472 subMemberStackPos = _subMemberStackPos;
1473 }
1474 if(thisMember == bitMember)
1475 {
1476 found = 0x1;
1477 break;
1478 }
1479 }
1480 else
1481 {
1482 __ecereNameSpace__ecere__com__eClass_FindNextMember(classSym->registered, &curClass, (struct __ecereNameSpace__ecere__com__DataMember **)&curMember, subMemberStack, &subMemberStackPos);
1483 if(curMember == bitMember)
1484 {
1485 found = 0x1;
1486 break;
1487 }
1488 }
1489 }
1490 }
1491 if(found)
1492 break;
1493 }
1494 if(member)
1495 {
1496 if(!bitMember->isProperty)
1497 {
1498 struct Expression * part = (((void *)0));
1499 struct __ecereNameSpace__ecere__sys__OldList * specs = MkList();
1500 struct Declarator * decl;
1501
1502 decl = SpecDeclFromString(_class->dataTypeString, specs, (((void *)0)));
1503 ProcessInitializer(member->initializer);
1504 if(member->initializer && member->initializer->type == 0)
1505 {
1506 if(bitMember->pos)
1507 {
1508 char pos[10];
1509
1510 sprintf(pos, "%d", bitMember->pos);
1511 part = MkExpBrackets(MkListOne(MkExpOp(MkExpBrackets(MkListOne(MkExpCast(MkTypeName(specs, decl), MkExpBrackets(MkListOne(member->initializer->exp))))), LEFT_OP, MkExpConstant(pos))));
1512 }
1513 else
1514 part = MkExpBrackets(MkListOne(MkExpCast(MkTypeName(specs, decl), MkExpBrackets(MkListOne(member->initializer->exp)))));
1515 member->initializer->exp = (((void *)0));
1516 FreeInitializer(member->initializer);
1517 member->initializer = (((void *)0));
1518 }
1519 if(exp)
1520 exp = MkExpOp(exp, '|', part);
1521 else
1522 exp = part;
1523 }
1524 else
1525 {
1526 char setName[1024], getName[1024];
1527
1528 DeclareProperty((struct __ecereNameSpace__ecere__com__Property *)bitMember, setName, getName);
1529 if(member->initializer && member->initializer->type == 0)
1530 {
1531 exp = MkExpCall(MkExpIdentifier(MkIdentifier(setName)), MkListOne(member->initializer->exp));
1532 member->initializer->exp = (((void *)0));
1533 FreeInitializer(member->initializer);
1534 member->initializer = (((void *)0));
1535 }
1536 }
1537 }
1538 }
1539 }
1540 }
1541 if(exp)
1542 exp = MkExpBrackets(MkListOne(exp));
1543 else
1544 exp = MkExpConstant("0");
1545 exp->expType = MkClassType(classSym->string);
1546 ProcessExpression(exp);
1547 ListAdd(list, exp);
1548 }
1549 else if(classSym && classSym->registered && classSym->registered->type == 3)
1550 {
1551 struct __ecereNameSpace__ecere__com__Class * _class = classSym->registered;
1552 struct Expression * exp = (((void *)0));
1553
1554 if(inst->members && (*inst->members).first)
1555 {
1556 struct MemberInit * member = (((void *)0));
1557 struct __ecereNameSpace__ecere__com__Property * prop = (((void *)0));
1558 unsigned int found = 0x0;
1559
1560 for(members = (*inst->members).first; members; members = members->next)
1561 {
1562 if(members->type == 0)
1563 {
1564 for(member = (*members->dataMembers).first; member; member = member->next)
1565 {
1566 if(member->identifiers)
1567 {
1568 struct Identifier * firstID = (*member->identifiers).first;
1569
1570 prop = __ecereNameSpace__ecere__com__eClass_FindProperty(_class, firstID->string, privateModule);
1571 if(prop)
1572 {
1573 found = 0x1;
1574 break;
1575 }
1576 prop = (((void *)0));
1577 }
1578 else
1579 {
1580 found = 0x1;
1581 break;
1582 }
1583 }
1584 }
1585 if(found)
1586 break;
1587 }
1588 if(member)
1589 {
1590 if(prop)
1591 {
1592 char setName[1024], getName[1024];
1593
1594 DeclareProperty(prop, setName, getName);
1595 if(member->initializer && member->initializer->type == 0)
1596 {
1597 exp = MkExpCall(MkExpIdentifier(MkIdentifier(setName)), MkListOne(member->initializer->exp));
1598 member->initializer->exp = (((void *)0));
1599 FreeInitializer(member->initializer);
1600 member->initializer = (((void *)0));
1601 }
1602 }
1603 else
1604 {
1605 ProcessInitializer(member->initializer);
1606 if(member->initializer && member->initializer->type == 0)
1607 {
1608 exp = MkExpCast(QMkClass(_class->fullName, (((void *)0))), MkExpBrackets(MkListOne(member->initializer->exp)));
1609 member->initializer->exp = (((void *)0));
1610 FreeInitializer(member->initializer);
1611 member->initializer = (((void *)0));
1612 }
1613 }
1614 }
1615 }
1616 if(exp)
1617 exp = MkExpBrackets(MkListOne(exp));
1618 else
1619 exp = MkExpConstant("0");
1620 ProcessExpression(exp);
1621 ListAdd(list, exp);
1622 }
1623 else if(classSym && classSym->registered)
1624 {
1625 if(classSym->registered->type == 1)
1626 {
1627 struct __ecereNameSpace__ecere__com__Class * _class = (((void *)0));
1628
1629 while(_class != classSym->registered)
1630 {
1631 struct __ecereNameSpace__ecere__com__DataMember * dataMember;
1632 struct __ecereNameSpace__ecere__com__Class * lastClass = _class;
1633
1634 for(_class = classSym->registered; _class->base != lastClass && _class->base->type != 1000; _class = _class->base)
1635 ;
1636 if(_class->structSize != _class->memberOffset)
1637 fullSet = 0x0;
1638 for(dataMember = _class->membersAndProperties.first; dataMember; dataMember = dataMember->next)
1639 {
1640 if(!dataMember->isProperty)
1641 {
1642 if(!dataMember->name && (dataMember->type == 1 || dataMember->type == 2))
1643 {
1644 if(!ProcessInstMembers_SimpleMemberEnsure(dataMember, inst, instExp, list, zeroOut))
1645 fullSet = 0x0;
1646 }
1647 else
1648 {
1649 unsigned int memberFilled = 0x0;
1650
1651 if(inst->members && (*inst->members).first)
1652 {
1653 struct __ecereNameSpace__ecere__com__Class * curClass = (((void *)0));
1654 struct __ecereNameSpace__ecere__com__DataMember * curMember = (((void *)0));
1655 struct __ecereNameSpace__ecere__com__DataMember * subMemberStack[256];
1656 int subMemberStackPos = 0;
1657
1658 for(members = (*inst->members).first; members; members = members->next)
1659 {
1660 if(members->type == 0 && members->dataMembers)
1661 {
1662 struct MemberInit * member = (((void *)0));
1663
1664 for(member = (*members->dataMembers).first; member; member = member->next)
1665 {
1666 if(member->identifiers)
1667 {
1668 struct __ecereNameSpace__ecere__com__DataMember * _subMemberStack[256];
1669 int _subMemberStackPos = 0;
1670 struct Identifier * firstID = (*member->identifiers).first;
1671 struct __ecereNameSpace__ecere__com__DataMember * thisMember = (struct __ecereNameSpace__ecere__com__DataMember *)__ecereNameSpace__ecere__com__eClass_FindProperty(classSym->registered, firstID->string, privateModule);
1672
1673 if(!thisMember)
1674 thisMember = __ecereNameSpace__ecere__com__eClass_FindDataMember(classSym->registered, firstID->string, privateModule, _subMemberStack, &_subMemberStackPos);
1675 if(thisMember)
1676 {
1677 if(thisMember->memberAccess == 1)
1678 {
1679 curMember = thisMember;
1680 curClass = curMember->_class;
1681 memcpy(subMemberStack, _subMemberStack, sizeof(struct __ecereNameSpace__ecere__com__DataMember *) * _subMemberStackPos);
1682 subMemberStackPos = _subMemberStackPos;
1683 }
1684 if(!firstID->next && curMember == dataMember)
1685 {
1686 memberFilled = 0x1;
1687 break;
1688 }
1689 }
1690 }
1691 else
1692 {
1693 __ecereNameSpace__ecere__com__eClass_FindNextMember(classSym->registered, &curClass, &curMember, subMemberStack, &subMemberStackPos);
1694 if(curMember == dataMember)
1695 {
1696 memberFilled = 0x1;
1697 break;
1698 }
1699 }
1700 }
1701 if(memberFilled)
1702 break;
1703 }
1704 if(memberFilled)
1705 break;
1706 }
1707 }
1708 if(!memberFilled)
1709 {
1710 if(zeroOut)
1711 {
1712 struct Expression * instExpCopy = CopyExpression(instExp);
1713 struct Expression * memberExp;
1714 struct Expression * setExp;
1715 struct Expression * value = MkExpConstant("0");
1716
1717 memberExp = MkExpMember(instExpCopy, MkIdentifier(dataMember->name));
1718 memberExp->member.memberType = 3;
1719 value->usage = (value->usage & ~0x1) | (((unsigned int)0x1) << 0);
1720 setExp = MkExpOp(memberExp, '=', value);
1721 value->loc = inst->loc;
1722 setExp->loc = inst->loc;
1723 FreeType(instExpCopy->expType);
1724 instExpCopy->expType = instExp->expType;
1725 if(instExp->expType)
1726 instExp->expType->refCount++;
1727 ProcessExpressionType(setExp);
1728 ProcessExpression(setExp);
1729 ListAdd(list, setExp);
1730 }
1731 fullSet = 0x0;
1732 }
1733 }
1734 }
1735 }
1736 }
1737 }
1738 if(inst->members && (*inst->members).first)
1739 {
1740 struct __ecereNameSpace__ecere__com__Class * curClass = (((void *)0));
1741 struct __ecereNameSpace__ecere__com__DataMember * curMember = (((void *)0));
1742 struct __ecereNameSpace__ecere__com__DataMember * subMemberStack[256];
1743 int subMemberStackPos = 0;
1744
1745 for(members = (*inst->members).first; members; members = members->next)
1746 {
1747 if(members->type == 0 && members->dataMembers)
1748 {
1749 struct MemberInit * member = (((void *)0));
1750 struct __ecereNameSpace__ecere__com__Method * method = (((void *)0));
1751
1752 for(member = (*members->dataMembers).first; member; member = member->next)
1753 {
1754 struct Identifier * ident = (((void *)0));
1755 struct __ecereNameSpace__ecere__com__DataMember * thisMember = (((void *)0));
1756
1757 if(member->identifiers)
1758 {
1759 struct __ecereNameSpace__ecere__com__DataMember * _subMemberStack[256];
1760 int _subMemberStackPos = 0;
1761 struct Identifier * firstID = (*member->identifiers).first;
1762
1763 thisMember = (struct __ecereNameSpace__ecere__com__DataMember *)__ecereNameSpace__ecere__com__eClass_FindProperty(classSym->registered, firstID->string, privateModule);
1764 if(!thisMember)
1765 thisMember = __ecereNameSpace__ecere__com__eClass_FindDataMember(classSym->registered, firstID->string, privateModule, _subMemberStack, &_subMemberStackPos);
1766 ident = firstID;
1767 if(thisMember)
1768 {
1769 if(thisMember->memberAccess == 1)
1770 {
1771 curMember = thisMember;
1772 curClass = curMember->_class;
1773 memcpy(subMemberStack, _subMemberStack, sizeof(struct __ecereNameSpace__ecere__com__DataMember *) * _subMemberStackPos);
1774 subMemberStackPos = _subMemberStackPos;
1775 }
1776 }
1777 else if(classSym->registered->type != 1)
1778 {
1779 method = __ecereNameSpace__ecere__com__eClass_FindMethod(classSym->registered, ident->string, privateModule);
1780 if(!method || method->type != 1)
1781 method = (((void *)0));
1782 }
1783 }
1784 else
1785 {
1786 __ecereNameSpace__ecere__com__eClass_FindNextMember(classSym->registered, &curClass, &curMember, subMemberStack, &subMemberStackPos);
1787 thisMember = curMember;
1788 }
1789 if(instExp && (thisMember || method))
1790 {
1791 struct Expression * instExpCopy = CopyExpression(instExp);
1792 struct Expression * setExp = (((void *)0));
1793
1794 instExpCopy->tempCount = instExp->tempCount;
1795 if(!ident)
1796 ident = MkIdentifier(thisMember->name);
1797 if(ident)
1798 {
1799 struct Expression * memberExp;
1800 unsigned int freeMemberExp = 0x0;
1801
1802 if(thisMember && thisMember->isProperty && ((struct __ecereNameSpace__ecere__com__Property *)thisMember)->conversion)
1803 convert = 0x1;
1804 if(member->identifiers && (*member->identifiers).count > 1)
1805 {
1806 struct Identifier * id = (*member->identifiers).first;
1807
1808 memberExp = MkExpMember(instExpCopy, id);
1809 for(id = id->next; id; id = id->next)
1810 memberExp = MkExpMember(memberExp, id);
1811 }
1812 else
1813 memberExp = MkExpMember(instExpCopy, ident);
1814 if(member->initializer && member->initializer->type == 0 && member->initializer->exp)
1815 {
1816 member->initializer->exp->usage = (member->initializer->exp->usage & ~0x1) | (((unsigned int)0x1) << 0);
1817 setExp = MkExpOp(memberExp, '=', member->initializer->exp);
1818 member->initializer->exp = (((void *)0));
1819 FreeInitializer(member->initializer);
1820 member->initializer = (((void *)0));
1821 }
1822 else
1823 {
1824 freeMemberExp = 0x1;
1825 }
1826 memberExp->loc = inst->loc;
1827 if(member->identifiers)
1828 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Clear((&*member->identifiers));
1829 if(setExp)
1830 setExp->loc = inst->loc;
1831 FreeType(instExpCopy->expType);
1832 instExpCopy->expType = instExp->expType;
1833 if(instExp->expType)
1834 instExp->expType->refCount++;
1835 if(setExp)
1836 {
1837 ProcessExpressionType(setExp);
1838 ProcessExpression(setExp);
1839 ListAdd(list, setExp);
1840 }
1841 if(freeMemberExp)
1842 FreeExpression(memberExp);
1843 }
1844 }
1845 }
1846 }
1847 }
1848 }
1849 }
1850 return fullSet || convert;
1851 }
1852
1853 extern struct ModuleImport * mainModule;
1854
1855 extern char *  __ecereNameSpace__ecere__sys__CopyString(char *  string);
1856
1857 extern struct Specifier * MkStructOrUnion(int type, struct Identifier * id, struct __ecereNameSpace__ecere__sys__OldList * definitions);
1858
1859 extern struct Declarator * MkDeclaratorPointer(struct Pointer * pointer, struct Declarator * declarator);
1860
1861 extern struct Pointer * MkPointer(struct __ecereNameSpace__ecere__sys__OldList * qualifiers, struct Pointer * pointer);
1862
1863 extern struct InitDeclarator * MkInitDeclarator(struct Declarator * declarator, struct Initializer * initializer);
1864
1865 extern struct Declaration * MkDeclaration(struct __ecereNameSpace__ecere__sys__OldList * specifiers, struct __ecereNameSpace__ecere__sys__OldList * initDeclarators);
1866
1867 extern struct External * MkExternalDeclaration(struct Declaration * declaration);
1868
1869 extern void DeclareStruct(char *  name, unsigned int skipNoHead);
1870
1871 void __ecereMethod___ecereNameSpace__ecere__sys__OldList_Add(struct __ecereNameSpace__ecere__sys__OldList * this, void *  item);
1872
1873 unsigned int __ecereMethod___ecereNameSpace__ecere__sys__OldList_Insert(struct __ecereNameSpace__ecere__sys__OldList * this, void *  prevItem, void *  item);
1874
1875 void __ecereMethod___ecereNameSpace__ecere__sys__OldList_Move(struct __ecereNameSpace__ecere__sys__OldList * this, void *  item, void *  prevItem);
1876
1877 void DeclareClass(struct Symbol * classSym, char * className)
1878 {
1879 if(classSym && classSym->id == (((int)0x7fffffff)))
1880 {
1881 struct Declaration * decl;
1882 struct __ecereNameSpace__ecere__sys__OldList * specifiers, * declarators;
1883 struct Declarator * d;
1884
1885 if(!classSym->_import)
1886 {
1887 if(!classSym->module)
1888 classSym->module = mainModule;
1889 if(!classSym->module)
1890 return ;
1891 classSym->_import = __extension__ ({
1892 struct ClassImport * __ecereInstance1 = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass_ClassImport);
1893
1894 __ecereInstance1->isRemote = classSym->registered ? classSym->registered->isRemote : 0, __ecereInstance1->name = __ecereNameSpace__ecere__sys__CopyString(classSym->string), __ecereInstance1;
1895 });
1896 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Add(&classSym->module->classes, classSym->_import);
1897 }
1898 classSym->_import->itself = 0x1;
1899 specifiers = MkList();
1900 declarators = MkList();
1901 ListAdd(specifiers, MkSpecifier(EXTERN));
1902 ListAdd(specifiers, MkStructOrUnion(3, MkIdentifier("__ecereNameSpace__ecere__com__Class"), (((void *)0))));
1903 d = MkDeclaratorPointer(MkPointer((((void *)0)), (((void *)0))), MkDeclaratorIdentifier(MkIdentifier(className)));
1904 ListAdd(declarators, MkInitDeclarator(d, (((void *)0))));
1905 decl = MkDeclaration(specifiers, declarators);
1906 if(curExternal)
1907 {
1908 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Insert((&*ast), curExternal->prev, (classSym->pointerExternal = MkExternalDeclaration(decl)));
1909 classSym->id = curExternal->symbol ? curExternal->symbol->idCode : 0;
1910 classSym->idCode = classSym->id;
1911 }
1912 }
1913 else if(classSym && curExternal && curExternal->symbol->idCode < classSym->id)
1914 {
1915 if(classSym->structExternal)
1916 DeclareStruct(classSym->string, classSym->registered && classSym->registered->type == 5);
1917 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Move((&*ast), classSym->pointerExternal, curExternal->prev);
1918 if(classSym->structExternal)
1919 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Move((&*ast), classSym->structExternal, classSym->pointerExternal);
1920 classSym->id = curExternal->symbol->idCode;
1921 classSym->idCode = classSym->id;
1922 }
1923 }
1924
1925 void ProcessExpressionInstPass(struct Expression * exp)
1926 {
1927 ProcessExpression(exp);
1928 }
1929
1930 extern struct Context * curContext;
1931
1932 static unsigned int ProcessBracketInst(struct Instantiation * inst, struct __ecereNameSpace__ecere__sys__OldList * list);
1933
1934 extern struct Specifier * MkSpecifierName(char *  name);
1935
1936 extern struct Initializer * MkInitializerList(struct __ecereNameSpace__ecere__sys__OldList * list);
1937
1938 extern struct Declaration * MkDeclarationInst(struct Instantiation * inst);
1939
1940 extern struct Instantiation * MkInstantiation(struct Specifier * _class, struct Expression * exp, struct __ecereNameSpace__ecere__sys__OldList * members);
1941
1942 extern struct Specifier * CopySpecifier(struct Specifier * spec);
1943
1944 extern struct Expression * QMkExpId(char *  id);
1945
1946 static void ProcessDeclaration(struct Declaration * decl);
1947
1948 extern char *  strcpy(char * , const char * );
1949
1950 extern struct Symbol * FindClass(char *  name);
1951
1952 extern void FullClassNameCat(char *  output, char *  className, unsigned int includeTemplateParams);
1953
1954 extern void MangleClassName(char *  className);
1955
1956 static struct Declaration * curDecl;
1957
1958 static int declTempCount;
1959
1960 extern struct Context * PushContext(void);
1961
1962 extern struct Declaration * QMkDeclaration(char *  name, struct InitDeclarator * initDecl);
1963
1964 extern struct Initializer * MkInitializerAssignment(struct Expression * exp);
1965
1966 extern struct Statement * MkExpressionStmt(struct __ecereNameSpace__ecere__sys__OldList * expressions);
1967
1968 extern void PopContext(struct Context * ctx);
1969
1970 extern void FreeInstance(struct Instantiation * inst);
1971
1972 extern struct Type * ProcessTypeString(char *  string, unsigned int staticMethod);
1973
1974 extern void ProcessMethodType(struct __ecereNameSpace__ecere__com__Method * method);
1975
1976 static void ProcessStatement(struct Statement * stmt);
1977
1978 extern void CheckTemplateTypes(struct Expression * exp);
1979
1980 void __ecereMethod___ecereNameSpace__ecere__sys__OldList_Remove(struct __ecereNameSpace__ecere__sys__OldList * this, void *  item);
1981
1982 void __ecereMethod___ecereNameSpace__ecere__sys__OldList_Free(struct __ecereNameSpace__ecere__sys__OldList * this, void (*  freeFn)(void * ));
1983
1984 static void ProcessExpression(struct Expression * exp)
1985 {
1986 switch(exp->type)
1987 {
1988 case 0:
1989 break;
1990 case 1:
1991 {
1992 struct Instantiation * inst = exp->instance;
1993
1994 if(inCompiler && inst->_class)
1995 {
1996 char className[1024];
1997 struct Symbol * classSym = inst->_class->symbol;
1998 struct Expression * instExp;
1999
2000 if(classSym && classSym->registered && classSym->registered->type == 2)
2001 {
2002 if(inst->exp)
2003 {
2004 struct __ecereNameSpace__ecere__sys__OldList list =
2005 {
2006 0
2007 };
2008
2009 ProcessInstMembers(inst, (((void *)0)), &list, 0x0);
2010 ProcessExpression(inst->exp);
2011 exp->type = 4;
2012 exp->op.op = '=';
2013 exp->op.exp1 = inst->exp;
2014 exp->op.exp2 = list.first;
2015 inst->exp = (((void *)0));
2016 }
2017 else
2018 {
2019 struct Type * expType = exp->expType;
2020 struct Expression * prev = exp->prev, * next = exp->next;
2021 struct __ecereNameSpace__ecere__sys__OldList list =
2022 {
2023 0, 0, 0, 0, 0
2024 };
2025
2026 ProcessInstMembers(inst, (((void *)0)), &list, 0x0);
2027 FreeType(exp->destType);
2028 *exp = *(struct Expression *)list.first;
2029 {
2030 struct Expression * firstExp = list.first;
2031
2032 ((firstExp ? (__ecereClass_Expression->Destructor ? __ecereClass_Expression->Destructor(firstExp) : 0, __ecereNameSpace__ecere__com__eSystem_Delete(firstExp)) : 0), firstExp = 0);
2033 }
2034 FreeType(exp->destType);
2035 exp->destType = expType;
2036 exp->prev = prev;
2037 exp->next = next;
2038 }
2039 }
2040 else if(classSym && classSym->registered && (classSym->registered->type == 3 || classSym->registered->type == 4))
2041 {
2042 if(inst->exp)
2043 {
2044 struct __ecereNameSpace__ecere__sys__OldList list =
2045 {
2046 0
2047 };
2048 struct Expression * e;
2049
2050 ProcessInstMembers(inst, (((void *)0)), &list, 0x0);
2051 ProcessExpression(inst->exp);
2052 exp->type = 4;
2053 exp->op.op = '=';
2054 exp->op.exp1 = inst->exp;
2055 exp->op.exp2 = list.first;
2056 inst->exp = (((void *)0));
2057 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Remove(&list, list.first);
2058 while(e = list.first)
2059 {
2060 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Remove(&list, e);
2061 FreeExpression(e);
2062 }
2063 }
2064 else
2065 {
2066 struct Expression * prev = exp->prev, * next = exp->next;
2067 struct Type * expType = exp->expType;
2068 struct __ecereNameSpace__ecere__sys__OldList list =
2069 {
2070 0
2071 };
2072
2073 ProcessInstMembers(inst, (((void *)0)), &list, 0x0);
2074 if(list.first)
2075 {
2076 struct Expression * e = list.first;
2077
2078 FreeType(exp->destType);
2079 *exp = *e;
2080 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Remove(&list, e);
2081 ((e ? (__ecereClass_Expression->Destructor ? __ecereClass_Expression->Destructor(e) : 0, __ecereNameSpace__ecere__com__eSystem_Delete(e)) : 0), e = 0);
2082 exp->expType = expType;
2083 exp->prev = prev;
2084 exp->next = next;
2085 while(e = list.first)
2086 {
2087 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Remove(&list, e);
2088 FreeExpression(e);
2089 }
2090 }
2091 else
2092 {
2093 exp->type = 2;
2094 exp->constant = __ecereNameSpace__ecere__sys__CopyString("0");
2095 }
2096 }
2097 }
2098 else if(classSym && classSym->registered && classSym->registered->type == 1)
2099 {
2100 if(inst->exp)
2101 {
2102 exp->type = 5;
2103 exp->list = MkList();
2104 ProcessInstMembers(inst, inst->exp, exp->list, 0x0);
2105 ProcessExpression(inst->exp);
2106 if(!(*exp->list).count)
2107 {
2108 exp->type = 16;
2109 (__ecereNameSpace__ecere__com__eSystem_Delete(exp->list), exp->list = 0);
2110 }
2111 }
2112 else
2113 {
2114 struct Declaration * decl;
2115 struct Declaration * dummyDecl;
2116
2117 {
2118 dummyDecl = MkDeclaration((((void *)0)), (((void *)0)));
2119 if(!curCompound->compound.declarations)
2120 curCompound->compound.declarations = MkList();
2121 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Insert((&*curCompound->compound.declarations), (((void *)0)), dummyDecl);
2122 sprintf(className, "__simpleStruct%d", curContext->simpleID++);
2123 {
2124 struct __ecereNameSpace__ecere__sys__OldList * list = MkList();
2125
2126 if(inst->isConstant && ProcessBracketInst(inst, list))
2127 {
2128 decl = MkDeclaration(MkList(), MkList());
2129 ListAdd(decl->specifiers, MkSpecifierName(inst->_class->name));
2130 ListAdd(decl->declarators, MkInitDeclarator(MkDeclaratorIdentifier(MkIdentifier(className)), MkInitializerList(list)));
2131 exp->type = 0;
2132 exp->identifier = MkIdentifier(className);
2133 }
2134 else
2135 {
2136 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Free((&*list), (((void *)0)));
2137 (__ecereNameSpace__ecere__com__eSystem_Delete(list), list = 0);
2138 decl = MkDeclarationInst(MkInstantiation(CopySpecifier(inst->_class), MkExpIdentifier(MkIdentifier(className)), (((void *)0))));
2139 exp->type = 5;
2140 exp->list = MkList();
2141 instExp = QMkExpId(className);
2142 instExp->loc = exp->loc;
2143 instExp->expType = MkClassType(inst->_class->name);
2144 decl->inst->fullSet = ProcessInstMembers(inst, instExp, exp->list, 0x0);
2145 ListAdd(exp->list, instExp);
2146 }
2147 }
2148 FreeType(exp->expType);
2149 exp->expType = MkClassType(inst->_class->name);
2150 {
2151 void * prev = dummyDecl->prev, * next = dummyDecl->next;
2152
2153 *dummyDecl = *decl;
2154 dummyDecl->prev = prev;
2155 dummyDecl->next = next;
2156 ((decl ? (__ecereClass_Declaration->Destructor ? __ecereClass_Declaration->Destructor(decl) : 0, __ecereNameSpace__ecere__com__eSystem_Delete(decl)) : 0), decl = 0);
2157 decl = dummyDecl;
2158 }
2159 ProcessDeclaration(decl);
2160 }
2161 }
2162 }
2163 else
2164 {
2165 struct Expression * newCall;
2166
2167 if(classSym && classSym->registered && classSym->registered->type == 5 && (classSym->registered->templateClass ? classSym->registered->templateClass->fixed : classSym->registered->fixed))
2168 {
2169 char size[256];
2170
2171 sprintf(size, "%d", classSym->registered->templateClass ? classSym->registered->templateClass->structSize : classSym->registered->structSize);
2172 newCall = MkExpCall(QMkExpId("ecere::com::eSystem_New0"), MkListOne(MkExpConstant(size)));
2173 newCall->byReference = 0x1;
2174 }
2175 else
2176 {
2177 strcpy(className, "__ecereClass_");
2178 if(classSym && classSym->registered && classSym->registered->type == 5 && classSym->registered->templateClass)
2179 {
2180 classSym = FindClass(classSym->registered->templateClass->fullName);
2181 FullClassNameCat(className, classSym->string, 0x1);
2182 }
2183 else
2184 FullClassNameCat(className, inst->_class->name, 0x1);
2185 MangleClassName(className);
2186 DeclareClass(classSym, className);
2187 newCall = MkExpCall(QMkExpId("ecere::com::eInstance_New"), MkListOne(QMkExpId(className)));
2188 ProcessExpressionType(newCall);
2189 newCall->byReference = 0x1;
2190 }
2191 if(inst->exp)
2192 {
2193 if(inst->members && (*inst->members).first)
2194 {
2195 exp->type = 5;
2196 exp->list = MkList();
2197 if(!inst->built)
2198 {
2199 ListAdd(exp->list, MkExpOp(inst->exp, '=', newCall));
2200 }
2201 else
2202 FreeExpression(newCall);
2203 ProcessInstMembers(inst, inst->exp, exp->list, 0x0);
2204 if(inst->built)
2205 FreeExpression(inst->exp);
2206 }
2207 else
2208 {
2209 exp->type = 4;
2210 exp->op.op = '=';
2211 exp->op.exp1 = inst->exp;
2212 exp->op.exp2 = newCall;
2213 ProcessExpression(inst->exp);
2214 }
2215 inst->exp = (((void *)0));
2216 }
2217 else
2218 {
2219 if(inst->members && (*inst->members).first)
2220 {
2221 int __simpleStruct0;
2222 char ecereTemp[100];
2223 struct MembersInit * members;
2224 int tempCount = exp->tempCount;
2225 struct __ecereNameSpace__ecere__sys__OldList * expList;
2226
2227 for(members = (*inst->members).first; members; members = members->next)
2228 {
2229 if(members->type == 0 && members->dataMembers)
2230 {
2231 struct MemberInit * member;
2232
2233 for(member = (*members->dataMembers).first; member; member = member->next)
2234 {
2235 if(member->initializer && member->initializer->type == 0)
2236 {
2237 int __simpleStruct0;
2238
2239 ProcessMemberInitData(member);
2240 tempCount = (__simpleStruct0 = member->initializer->exp->tempCount, (tempCount > __simpleStruct0) ? tempCount : __simpleStruct0);
2241 }
2242 }
2243 }
2244 }
2245 if(curDecl)
2246 tempCount = ((tempCount > declTempCount) ? tempCount : declTempCount);
2247 tempCount++;
2248 curExternal->function->tempCount = (__simpleStruct0 = curExternal->function->tempCount, (__simpleStruct0 > tempCount) ? __simpleStruct0 : tempCount);
2249 sprintf(ecereTemp, "__ecereInstance%d", tempCount);
2250 exp->type = 23;
2251 exp->compound = MkCompoundStmt((((void *)0)), (((void *)0)));
2252 exp->compound->compound.context = PushContext();
2253 exp->compound->compound.context->simpleID = exp->compound->compound.context->parent->simpleID;
2254 exp->compound->compound.declarations = MkListOne(QMkDeclaration(inst->_class->name, MkInitDeclarator(MkDeclaratorIdentifier(MkIdentifier(ecereTemp)), MkInitializerAssignment(newCall))));
2255 exp->compound->compound.statements = MkListOne(MkExpressionStmt((expList = MkList())));
2256 instExp = QMkExpId(ecereTemp);
2257 instExp->tempCount = tempCount;
2258 instExp->expType = MkClassType(inst->_class->name);
2259 instExp->byReference = 0x1;
2260 ProcessInstMembers(inst, instExp, expList, 0x0);
2261 FreeExpression(instExp);
2262 if(exp->usage)
2263 {
2264 struct Expression * tmpExp = QMkExpId(ecereTemp);
2265
2266 tmpExp->byReference = 0x1;
2267 ListAdd(expList, tmpExp);
2268 }
2269 exp->tempCount = tempCount;
2270 if(curDecl)
2271 declTempCount = ((declTempCount > tempCount) ? declTempCount : tempCount);
2272 PopContext(exp->compound->compound.context);
2273 }
2274 else
2275 {
2276 FreeType(newCall->destType);
2277 FreeType(newCall->expType);
2278 newCall->destType = exp->destType;
2279 newCall->expType = exp->expType;
2280 *exp = *newCall;
2281 ((newCall ? (__ecereClass_Expression->Destructor ? __ecereClass_Expression->Destructor(newCall) : 0, __ecereNameSpace__ecere__com__eSystem_Delete(newCall)) : 0), newCall = 0);
2282 }
2283 }
2284 }
2285 if(exp->type != 1)
2286 FreeInstance(inst);
2287 }
2288 else
2289 ProcessInstantiation(inst);
2290 break;
2291 }
2292 case 2:
2293 break;
2294 case 3:
2295 break;
2296 case 13:
2297 case 26:
2298 ProcessExpression(exp->_new.size);
2299 break;
2300 case 14:
2301 case 27:
2302 ProcessExpression(exp->_renew.size);
2303 ProcessExpression(exp->_renew.exp);
2304 break;
2305 case 4:
2306 {
2307 unsigned int assign = 0x0;
2308
2309 switch(exp->op.op)
2310 {
2311 case '=':
2312 if(exp->op.exp2)
2313 exp->op.exp2->usage = (exp->op.exp2->usage & ~0x1) | (((unsigned int)0x1) << 0);
2314 if(exp->op.exp1)
2315 exp->op.exp1->usage = (exp->op.exp1->usage & ~0x2) | (((unsigned int)0x1) << 1);
2316 assign = 0x1;
2317 break;
2318 case MUL_ASSIGN:
2319 case DIV_ASSIGN:
2320 case MOD_ASSIGN:
2321 case ADD_ASSIGN:
2322 case SUB_ASSIGN:
2323 case LEFT_ASSIGN:
2324 case RIGHT_ASSIGN:
2325 case AND_ASSIGN:
2326 case XOR_ASSIGN:
2327 case OR_ASSIGN:
2328 if(exp->op.exp2)
2329 exp->op.exp2->usage = (exp->op.exp2->usage & ~0x1) | (((unsigned int)0x1) << 0);
2330 assign = 0x1;
2331 if(exp->op.exp1)
2332 exp->op.exp1->usage = (exp->op.exp1->usage & ~0x2) | (((unsigned int)0x1) << 1);
2333 break;
2334 case INC_OP:
2335 case DEC_OP:
2336 if(exp->op.exp1)
2337 exp->op.exp1->usage = (exp->op.exp1->usage & ~0x2) | (((unsigned int)0x1) << 1);
2338 case '&':
2339 if(exp->op.exp1 && exp->op.exp2)
2340 {
2341 exp->op.exp1->usage = (exp->op.exp1->usage & ~0x1) | (((unsigned int)0x1) << 0);
2342 exp->op.exp2->usage = (exp->op.exp2->usage & ~0x1) | (((unsigned int)0x1) << 0);
2343 }
2344 break;
2345 case '*':
2346 case '+':
2347 case '-':
2348 if(exp->op.exp1)
2349 {
2350 exp->op.exp1->usage = (exp->op.exp1->usage & ~0x1) | (((unsigned int)0x1) << 0);
2351 }
2352 case '~':
2353 case '!':
2354 if(exp->op.exp2)
2355 exp->op.exp2->usage = (exp->op.exp2->usage & ~0x1) | (((unsigned int)0x1) << 0);
2356 break;
2357 case '/':
2358 case '%':
2359 case LEFT_OP:
2360 case RIGHT_OP:
2361 case '<':
2362 case '>':
2363 case LE_OP:
2364 case GE_OP:
2365 case EQ_OP:
2366 case NE_OP:
2367 case '|':
2368 case '^':
2369 case AND_OP:
2370 case OR_OP:
2371 if(exp->op.exp1)
2372 exp->op.exp1->usage = (exp->op.exp1->usage & ~0x1) | (((unsigned int)0x1) << 0);
2373 if(exp->op.exp2)
2374 exp->op.exp2->usage = (exp->op.exp2->usage & ~0x1) | (((unsigned int)0x1) << 0);
2375 break;
2376 }
2377 if(exp->op.exp1)
2378 {
2379 ProcessExpression(exp->op.exp1);
2380 }
2381 if(exp->op.exp2)
2382 {
2383 if(exp->op.exp1)
2384 exp->op.exp2->tempCount = exp->op.exp1->tempCount;
2385 ProcessExpression(exp->op.exp2);
2386 }
2387 break;
2388 }
2389 case 32:
2390 case 5:
2391 {
2392 struct Expression * e;
2393
2394 for(e = (*exp->list).first; e; e = e->next)
2395 {
2396 int __simpleStruct2, __simpleStruct3;
2397 int __simpleStruct0, __simpleStruct1;
2398
2399 e->tempCount = (__simpleStruct0 = e->tempCount, __simpleStruct1 = exp->tempCount, (__simpleStruct0 > __simpleStruct1) ? __simpleStruct0 : __simpleStruct1);
2400 if(!e->next)
2401 {
2402 e->usage |= (exp->usage & ((((unsigned int)(0x1)) | (((unsigned int)(0x1)) << 2))));
2403 }
2404 ProcessExpression(e);
2405 exp->tempCount = (__simpleStruct2 = exp->tempCount, __simpleStruct3 = e->tempCount, (__simpleStruct2 > __simpleStruct3) ? __simpleStruct2 : __simpleStruct3);
2406 }
2407 break;
2408 }
2409 case 6:
2410 {
2411 struct Expression * e;
2412
2413 exp->index.exp->usage = (exp->index.exp->usage & ~0x1) | (((unsigned int)0x1) << 0);
2414 ProcessExpression(exp->index.exp);
2415 for(e = (*exp->index.index).first; e; e = e->next)
2416 {
2417 if(!e->next)
2418 e->usage = (e->usage & ~0x1) | (((unsigned int)0x1) << 0);
2419 ProcessExpression(e);
2420 }
2421 exp->tempCount = exp->index.exp->tempCount;
2422 break;
2423 }
2424 case 7:
2425 {
2426 struct Expression * e;
2427 struct __ecereNameSpace__ecere__com__Method * method = (((void *)0));
2428
2429 ProcessExpression(exp->call.exp);
2430 if(exp->call.arguments)
2431 {
2432 for(e = (*exp->call.arguments).first; e; e = e->next)
2433 {
2434 e->usage = (e->usage & ~0x1) | (((unsigned int)0x1) << 0);
2435 e->usage = (e->usage & ~0x4) | (((unsigned int)0x1) << 2);
2436 ProcessExpression(e);
2437 }
2438 }
2439 break;
2440 }
2441 case 8:
2442 {
2443 exp->member.exp->usage = (exp->member.exp->usage & ~0x1) | (((unsigned int)0x1) << 0);
2444 ProcessExpression(exp->member.exp);
2445 if(!exp->member.memberType)
2446 {
2447 struct Type * type = exp->member.exp->expType;
2448
2449 if((type && type->kind == 8 && exp->member.member))
2450 {
2451 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)));
2452 struct __ecereNameSpace__ecere__com__Property * prop = (((void *)0));
2453 struct __ecereNameSpace__ecere__com__Method * method = (((void *)0));
2454 struct __ecereNameSpace__ecere__com__DataMember * member = (((void *)0));
2455 struct __ecereNameSpace__ecere__com__Property * revConvert = (((void *)0));
2456
2457 if(exp->member.thisPtr)
2458 {
2459 member = __ecereNameSpace__ecere__com__eClass_FindDataMember(_class, exp->member.member->string, privateModule, (((void *)0)), (((void *)0)));
2460 if(!member)
2461 prop = __ecereNameSpace__ecere__com__eClass_FindProperty(_class, exp->member.member->string, privateModule);
2462 }
2463 else
2464 {
2465 prop = __ecereNameSpace__ecere__com__eClass_FindProperty(_class, exp->member.member->string, (((void *)0)));
2466 if(!prop)
2467 member = __ecereNameSpace__ecere__com__eClass_FindDataMember(_class, exp->member.member->string, (((void *)0)), (((void *)0)), (((void *)0)));
2468 if(!prop && !member)
2469 {
2470 method = __ecereNameSpace__ecere__com__eClass_FindMethod(_class, exp->member.member->string, (((void *)0)));
2471 if(!method)
2472 {
2473 prop = __ecereNameSpace__ecere__com__eClass_FindProperty(_class, exp->member.member->string, privateModule);
2474 if(!prop)
2475 member = __ecereNameSpace__ecere__com__eClass_FindDataMember(_class, exp->member.member->string, privateModule, (((void *)0)), (((void *)0)));
2476 }
2477 }
2478 }
2479 if(!prop && !member && !method)
2480 method = __ecereNameSpace__ecere__com__eClass_FindMethod(_class, exp->member.member->string, privateModule);
2481 if(!prop && !member && !method)
2482 {
2483 struct Symbol * classSym = FindClass(exp->member.member->string);
2484
2485 if(classSym)
2486 {
2487 struct __ecereNameSpace__ecere__com__Class * convertClass = classSym->registered;
2488
2489 if(convertClass)
2490 revConvert = __ecereNameSpace__ecere__com__eClass_FindProperty(convertClass, _class->fullName, privateModule);
2491 }
2492 }
2493 if(prop)
2494 {
2495 exp->member.memberType = 1;
2496 if(!prop->dataType)
2497 prop->dataType = ProcessTypeString(prop->dataTypeString, 0x0);
2498 FreeType(exp->expType);
2499 exp->expType = prop->dataType;
2500 if(prop->dataType)
2501 prop->dataType->refCount++;
2502 }
2503 else if(method)
2504 {
2505 exp->member.memberType = 2;
2506 if(!method->dataType)
2507 ProcessMethodType(method);
2508 FreeType(exp->expType);
2509 exp->expType = method->dataType;
2510 if(method->dataType)
2511 method->dataType->refCount++;
2512 }
2513 else if(member)
2514 {
2515 exp->member.memberType = 3;
2516 DeclareStruct(_class->fullName, 0x0);
2517 if(!member->dataType)
2518 member->dataType = ProcessTypeString(member->dataTypeString, 0x0);
2519 FreeType(exp->expType);
2520 exp->expType = member->dataType;
2521 if(member->dataType)
2522 member->dataType->refCount++;
2523 }
2524 else if(revConvert)
2525 {
2526 exp->member.memberType = 4;
2527 FreeType(exp->expType);
2528 exp->expType = MkClassType(revConvert->_class->fullName);
2529 }
2530 }
2531 }
2532 break;
2533 }
2534 case 10:
2535 break;
2536 case 11:
2537 {
2538 exp->cast.exp->usage = (exp->cast.exp->usage & ~0x1) | (((unsigned int)0x1) << 0);
2539 ProcessExpression(exp->cast.exp);
2540 break;
2541 }
2542 case 12:
2543 {
2544 struct Expression * e;
2545
2546 if(((unsigned int)((exp->usage & 0x1) >> 0)))
2547 exp->cond.cond->usage = (exp->cond.cond->usage & ~0x1) | (((unsigned int)0x1) << 0);
2548 ProcessExpression(exp->cond.cond);
2549 for(e = (*exp->cond.exp).first; e; e = e->next)
2550 {
2551 if(!e->next && ((unsigned int)((exp->usage & 0x1) >> 0)))
2552 e->usage = (e->usage & ~0x1) | (((unsigned int)0x1) << 0);
2553 ProcessExpression(e);
2554 }
2555 if(exp->cond.elseExp)
2556 {
2557 if(((unsigned int)((exp->usage & 0x1) >> 0)))
2558 exp->cond.elseExp->usage = (exp->cond.elseExp->usage & ~0x1) | (((unsigned int)0x1) << 0);
2559 ProcessExpression(exp->cond.elseExp);
2560 }
2561 break;
2562 }
2563 case 23:
2564 {
2565 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)
2566 {
2567 ((struct Expression *)(*((struct Statement *)(*exp->compound->compound.statements).last)->expressions).last)->usage = exp->usage;
2568 }
2569 ProcessStatement(exp->compound);
2570 break;
2571 }
2572 case 34:
2573 {
2574 ProcessExpression(exp->vaArg.exp);
2575 break;
2576 }
2577 case 33:
2578 {
2579 ProcessInitializer(exp->initializer.initializer);
2580 break;
2581 }
2582 }
2583 CheckTemplateTypes(exp);
2584 }
2585
2586 static void ProcessInitializer(struct Initializer * init)
2587 {
2588 switch(init->type)
2589 {
2590 case 0:
2591 init->exp->usage = (init->exp->usage & ~0x1) | (((unsigned int)0x1) << 0);
2592 ProcessExpression(init->exp);
2593 break;
2594 case 1:
2595 {
2596 struct Initializer * i;
2597
2598 for(i = (*init->list).first; i; i = i->next)
2599 ProcessInitializer(i);
2600 break;
2601 }
2602 }
2603 }
2604
2605 static void ProcessSpecifier(struct Specifier * spec)
2606 {
2607 switch(spec->type)
2608 {
2609 case 0:
2610 break;
2611 case 1:
2612 {
2613 break;
2614 }
2615 case 2:
2616 {
2617 struct Enumerator * e;
2618
2619 if(spec->list)
2620 {
2621 for(e = (*spec->list).first; e; e = e->next)
2622 {
2623 if(e->exp)
2624 ProcessExpression(e->exp);
2625 }
2626 }
2627 break;
2628 }
2629 case 3:
2630 case 4:
2631 {
2632 if(spec->definitions)
2633 {
2634 struct ClassDef * def;
2635
2636 for(def = (*spec->definitions).first; def; def = def->next)
2637 {
2638 if(def->type == 2 && def->decl && def->decl->type == 0)
2639 ProcessDeclaration(def->decl);
2640 }
2641 }
2642 break;
2643 }
2644 }
2645 }
2646
2647 extern void FreeList(struct __ecereNameSpace__ecere__sys__OldList * list, void (*  FreeFunction)(void * ));
2648
2649 extern struct Specifier * _MkSpecifierName(char *  name, struct Symbol * symbol, struct __ecereNameSpace__ecere__sys__OldList * templateArgs);
2650
2651 extern struct Identifier * CopyIdentifier(struct Identifier * id);
2652
2653 extern struct MemberInit * MkMemberInit(struct __ecereNameSpace__ecere__sys__OldList * ids, struct Initializer * initializer);
2654
2655 extern int strcmp(const char * , const char * );
2656
2657 extern struct Expression * MkExpInstance(struct Instantiation * inst);
2658
2659 extern struct MembersInit * MkMembersInitList(struct __ecereNameSpace__ecere__sys__OldList * dataMembers);
2660
2661 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)
2662 {
2663 struct Symbol * classSym = inst->_class->symbol;
2664 struct __ecereNameSpace__ecere__com__DataMember * dataMember = (((void *)0));
2665 unsigned int someMemberSet = 0x0;
2666
2667 for(dataMember = parentMember->members.first; dataMember; dataMember = dataMember->next)
2668 {
2669 struct MembersInit * members;
2670 struct MemberInit * member = (((void *)0));
2671
2672 if(!dataMember->name && (dataMember->type == 1 || dataMember->type == 2))
2673 {
2674 struct __ecereNameSpace__ecere__sys__OldList * subList = 0;
2675
2676 if(!ProcessBracketInst_DataMember(dataMember, inst, subList ? subList : list, dataMember->name ? dataMember : namedParentMember, someMemberSet || parentMemberSet))
2677 {
2678 if(subList)
2679 FreeList(subList, FreeInitializer);
2680 return 0x0;
2681 }
2682 if(subList && (*subList).count)
2683 {
2684 ListAdd(list, MkInitializerList(subList));
2685 someMemberSet = 0x1;
2686 }
2687 else
2688 {
2689 if(list->count)
2690 someMemberSet = 0x1;
2691 (__ecereNameSpace__ecere__com__eSystem_Delete(subList), subList = 0);
2692 }
2693 }
2694 else
2695 {
2696 struct __ecereNameSpace__ecere__com__Class * curClass = (((void *)0));
2697 struct __ecereNameSpace__ecere__com__DataMember * curMember = (((void *)0));
2698 struct __ecereNameSpace__ecere__com__DataMember * subMemberStack[256];
2699 int subMemberStackPos = 0;
2700 unsigned int found = 0x0;
2701
2702 if(inst->members && (*inst->members).first)
2703 {
2704 for(members = (*inst->members).first; members; members = members->next)
2705 {
2706 if(members->type == 0)
2707 {
2708 for(member = (*members->dataMembers).first; member; member = member->next)
2709 {
2710 if(member->identifiers)
2711 {
2712 struct Identifier * firstID = (*member->identifiers).first;
2713 struct __ecereNameSpace__ecere__com__DataMember * _subMemberStack[256];
2714 int _subMemberStackPos = 0;
2715 struct __ecereNameSpace__ecere__com__DataMember * thisMember;
2716
2717 thisMember = firstID ? (struct __ecereNameSpace__ecere__com__DataMember *)__ecereNameSpace__ecere__com__eClass_FindProperty(classSym->registered, firstID->string, privateModule) : (((void *)0));
2718 if(!thisMember && firstID)
2719 thisMember = __ecereNameSpace__ecere__com__eClass_FindDataMember(classSym->registered, firstID->string, privateModule, _subMemberStack, &_subMemberStackPos);
2720 if(thisMember && thisMember->memberAccess == 1)
2721 {
2722 curMember = thisMember;
2723 curClass = curMember->_class;
2724 memcpy(subMemberStack, _subMemberStack, sizeof(struct __ecereNameSpace__ecere__com__DataMember *) * _subMemberStackPos);
2725 subMemberStackPos = _subMemberStackPos;
2726 }
2727 if(dataMember == thisMember)
2728 {
2729 if((*member->identifiers).count > 1 && member->initializer && member->initializer->type == 0)
2730 {
2731 struct __ecereNameSpace__ecere__sys__OldList * partList = MkList();
2732 struct Symbol * symbol;
2733 struct Specifier * spec;
2734 struct MembersInit * nextMembers;
2735 struct MemberInit * next = member->next;
2736
2737 if(!dataMember->dataType)
2738 dataMember->dataType = ProcessTypeString(dataMember->dataTypeString, 0x0);
2739 symbol = (dataMember->dataType && dataMember->dataType->kind == 8) ? dataMember->dataType->_class : (((void *)0));
2740 spec = _MkSpecifierName(dataMember->dataTypeString, symbol, (((void *)0)));
2741 {
2742 struct __ecereNameSpace__ecere__sys__OldList * identifiers = MkList();
2743 struct Identifier * id;
2744
2745 for(id = ((struct Identifier *)(*member->identifiers).first)->next; id; id = id->next)
2746 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Add((&*identifiers), CopyIdentifier(id));
2747 ListAdd(partList, MkMemberInit(identifiers, MkInitializerAssignment(member->initializer->exp)));
2748 }
2749 for(nextMembers = members; nextMembers; nextMembers = nextMembers->next)
2750 {
2751 if(!nextMembers->dataMembers)
2752 continue;
2753 if(members != nextMembers)
2754 next = (*nextMembers->dataMembers).first;
2755 if(nextMembers->type == 0)
2756 {
2757 struct MemberInit * nextMember;
2758
2759 for(nextMember = next; nextMember; nextMember = next, next = nextMember ? nextMember->next : (((void *)0)))
2760 {
2761 struct Identifier * nextID = (*nextMember->identifiers).first;
2762
2763 if(nextMember->identifiers && (*nextMember->identifiers).count > 1 && !strcmp(firstID->string, nextID->string))
2764 {
2765 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Remove((&*nextMembers->dataMembers), nextMember);
2766 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Remove((&*nextMember->identifiers), nextID);
2767 ListAdd(partList, nextMember);
2768 }
2769 }
2770 }
2771 }
2772 member->initializer->exp = MkExpInstance(MkInstantiation(spec, (((void *)0)), MkListOne(MkMembersInitList(partList))));
2773 }
2774 found = 0x1;
2775 break;
2776 }
2777 }
2778 else
2779 {
2780 __ecereNameSpace__ecere__com__eClass_FindNextMember(classSym->registered, &curClass, &curMember, subMemberStack, &subMemberStackPos);
2781 if(curMember == dataMember)
2782 {
2783 found = 0x1;
2784 break;
2785 }
2786 }
2787 }
2788 }
2789 if(found)
2790 break;
2791 }
2792 }
2793 if(member && member->initializer && member->initializer->type == 0)
2794 {
2795 struct Initializer * init = (init = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass_Initializer), init->loc = yylloc, init);
2796
2797 if(namedParentMember->type == 1 && dataMember->name)
2798 init->id = MkIdentifier(dataMember->name);
2799 if(member->initializer->exp->type == 1 && member->initializer->exp->expType && member->initializer->exp->expType->_class->registered->type == 1)
2800 {
2801 struct __ecereNameSpace__ecere__sys__OldList * subList = MkList();
2802
2803 ProcessBracketInst(member->initializer->exp->instance, subList);
2804 FreeExpression(member->initializer->exp);
2805 if((*subList).count)
2806 {
2807 init->type = 1;
2808 init->list = subList;
2809 }
2810 else
2811 {
2812 FreeInitializer(init);
2813 init = (((void *)0));
2814 }
2815 }
2816 else
2817 {
2818 member->initializer->exp->usage = (member->initializer->exp->usage & ~0x1) | (((unsigned int)0x1) << 0);
2819 ProcessExpression(member->initializer->exp);
2820 init->type = 0;
2821 init->exp = member->initializer->exp;
2822 }
2823 if(init)
2824 ListAdd(list, init);
2825 member->initializer->exp = (((void *)0));
2826 FreeInitializer(member->initializer);
2827 member->initializer = (((void *)0));
2828 someMemberSet = 0x1;
2829 }
2830 else if(member && member->initializer && member->initializer->type == 1)
2831 {
2832 if(namedParentMember->type == 1 && dataMember->name)
2833 member->initializer->id = MkIdentifier(dataMember->name);
2834 ListAdd(list, member->initializer);
2835 member->initializer = (((void *)0));
2836 someMemberSet = 0x1;
2837 }
2838 else if(dataMember && dataMember->dataTypeString && parentMember->type != 1 && namedParentMember->type != 1)
2839 {
2840 struct Symbol * classSym;
2841 struct Initializer * init = (init = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass_Initializer), init->loc = yylloc, init);
2842
2843 if(namedParentMember->type == 1 && dataMember->name)
2844 init->id = MkIdentifier(dataMember->name);
2845 if(!dataMember->dataType)
2846 dataMember->dataType = ProcessTypeString(dataMember->dataTypeString, 0x0);
2847 classSym = (dataMember->dataType && dataMember->dataType->kind == 8) ? dataMember->dataType->_class : (((void *)0));
2848 if(classSym && classSym->registered && classSym->registered->type == 1)
2849 {
2850 struct __ecereNameSpace__ecere__sys__OldList * subList = MkList();
2851 struct Specifier * spec = _MkSpecifierName(dataMember->dataTypeString, classSym, (((void *)0)));
2852 struct Instantiation * inst = MkInstantiation(spec, (((void *)0)), (((void *)0)));
2853
2854 ProcessBracketInst(inst, subList);
2855 FreeInstance(inst);
2856 if((*subList).count)
2857 {
2858 init->type = 1;
2859 init->list = subList;
2860 }
2861 else
2862 {
2863 FreeInitializer(init);
2864 init = (((void *)0));
2865 }
2866 }
2867 else
2868 {
2869 init->type = 0;
2870 init->exp = MkExpConstant("0");
2871 }
2872 someMemberSet = 0x1;
2873 if(init)
2874 ListAdd(list, init);
2875 }
2876 }
2877 }
2878 if(parentMember->type == 1 && !someMemberSet && !parentMemberSet)
2879 {
2880 struct Symbol * classSym;
2881 struct Initializer * init = (init = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass_Initializer), init->loc = yylloc, init);
2882
2883 dataMember = parentMember->members.first;
2884 if(namedParentMember->type == 1 && dataMember->name)
2885 init->id = MkIdentifier(dataMember->name);
2886 if(!dataMember->dataType && dataMember->dataTypeString)
2887 dataMember->dataType = ProcessTypeString(dataMember->dataTypeString, 0x0);
2888 classSym = (dataMember->dataType && dataMember->dataType->kind == 8) ? dataMember->dataType->_class : (((void *)0));
2889 if(classSym && classSym->registered && classSym->registered->type == 1)
2890 {
2891 struct __ecereNameSpace__ecere__sys__OldList * subList = MkList();
2892 struct Specifier * spec = _MkSpecifierName(dataMember->dataTypeString, classSym, (((void *)0)));
2893 struct Instantiation * inst = MkInstantiation(spec, (((void *)0)), (((void *)0)));
2894
2895 ProcessBracketInst(inst, subList);
2896 FreeInstance(inst);
2897 init->type = 1;
2898 init->list = subList;
2899 }
2900 else
2901 {
2902 init->type = 0;
2903 init->exp = MkExpConstant("0");
2904 }
2905 ListAdd(list, init);
2906 }
2907 return 0x1;
2908 }
2909
2910 extern void Compiler_Error(char *  format, ...);
2911
2912 extern char *  __ecereNameSpace__ecere__GetTranslatedString(char * name, char *  string, char *  stringAndContext);
2913
2914 static unsigned int ProcessBracketInst(struct Instantiation * inst, struct __ecereNameSpace__ecere__sys__OldList * list)
2915 {
2916 static int recursionCount = 0;
2917 struct Symbol * classSym = inst->_class->symbol;
2918 struct __ecereNameSpace__ecere__com__Class * _class = (((void *)0));
2919
2920 if(recursionCount > 500)
2921 return 0x0;
2922 recursionCount++;
2923 while(_class != classSym->registered)
2924 {
2925 struct __ecereNameSpace__ecere__com__DataMember * dataMember;
2926 struct __ecereNameSpace__ecere__com__Class * lastClass = _class;
2927
2928 for(_class = classSym->registered; _class->base != lastClass && _class->base->type != 1000; _class = _class->base)
2929 ;
2930 for(dataMember = _class->membersAndProperties.first; dataMember; dataMember = dataMember->next)
2931 {
2932 if(!dataMember->isProperty && !dataMember->name && (dataMember->type == 1 || dataMember->type == 2))
2933 {
2934 struct __ecereNameSpace__ecere__sys__OldList * subList = 0;
2935
2936 if(!ProcessBracketInst_DataMember(dataMember, inst, subList ? subList : list, dataMember, 0x0))
2937 {
2938 if(subList)
2939 FreeList(subList, FreeInitializer);
2940 recursionCount--;
2941 return 0x0;
2942 }
2943 if(dataMember->type == 2 || (subList && (*subList).count))
2944 ListAdd(list, MkInitializerList(subList));
2945 else
2946 (__ecereNameSpace__ecere__com__eSystem_Delete(subList), subList = 0);
2947 }
2948 else
2949 {
2950 struct MembersInit * members;
2951 struct MemberInit * member = (((void *)0));
2952 unsigned int found = 0x0;
2953
2954 if(inst->members && (*inst->members).first)
2955 {
2956 struct __ecereNameSpace__ecere__com__DataMember * curMember = (((void *)0));
2957 struct __ecereNameSpace__ecere__com__Class * curClass = (((void *)0));
2958 struct __ecereNameSpace__ecere__com__DataMember * subMemberStack[256];
2959 int subMemberStackPos = 0;
2960
2961 for(members = (*inst->members).first; members; members = members->next)
2962 {
2963 if(members->type == 0)
2964 {
2965 for(member = (*members->dataMembers).first; member; member = member->next)
2966 {
2967 struct Identifier * firstID = member->identifiers ? (*member->identifiers).first : (((void *)0));
2968
2969 if(firstID)
2970 {
2971 struct __ecereNameSpace__ecere__com__DataMember * _subMemberStack[256];
2972 int _subMemberStackPos = 0;
2973 struct __ecereNameSpace__ecere__com__DataMember * thisMember = (struct __ecereNameSpace__ecere__com__DataMember *)__ecereNameSpace__ecere__com__eClass_FindProperty(classSym->registered, firstID->string, privateModule);
2974
2975 if(!thisMember)
2976 thisMember = __ecereNameSpace__ecere__com__eClass_FindDataMember(classSym->registered, firstID->string, privateModule, _subMemberStack, &_subMemberStackPos);
2977 if(thisMember)
2978 {
2979 curMember = thisMember;
2980 curClass = curMember->_class;
2981 memcpy(subMemberStack, _subMemberStack, sizeof(struct __ecereNameSpace__ecere__com__DataMember *) * _subMemberStackPos);
2982 subMemberStackPos = _subMemberStackPos;
2983 }
2984 if(curMember == dataMember)
2985 {
2986 if(dataMember->isProperty)
2987 {
2988 if(!((struct __ecereNameSpace__ecere__com__Property *)dataMember)->Set)
2989 {
2990 Compiler_Error(__ecereNameSpace__ecere__GetTranslatedString("ec", "No set defined for property %s\n", (((void *)0))), dataMember->name);
2991 continue;
2992 }
2993 recursionCount--;
2994 return 0x0;
2995 }
2996 if((*member->identifiers).count > 1 && member->initializer && member->initializer->type == 0)
2997 {
2998 struct __ecereNameSpace__ecere__sys__OldList * partList = MkList();
2999 struct Specifier * spec;
3000 struct MembersInit * nextMembers;
3001 struct MemberInit * next = member->next;
3002 struct Symbol * symbol;
3003
3004 if(!dataMember->dataType)
3005 dataMember->dataType = ProcessTypeString(dataMember->dataTypeString, 0x0);
3006 symbol = (dataMember->dataType && dataMember->dataType->kind == 8) ? dataMember->dataType->_class : (((void *)0));
3007 spec = _MkSpecifierName(dataMember->dataTypeString, symbol, (((void *)0)));
3008 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Remove((&*member->identifiers), firstID);
3009 ListAdd(partList, MkMemberInit(member->identifiers, MkInitializerAssignment(member->initializer->exp)));
3010 for(nextMembers = members; nextMembers; nextMembers = nextMembers->next)
3011 {
3012 if(!nextMembers->dataMembers)
3013 continue;
3014 if(members != nextMembers)
3015 next = (*nextMembers->dataMembers).first;
3016 if(nextMembers->type == 0)
3017 {
3018 struct MemberInit * nextMember;
3019
3020 for(nextMember = next; nextMember; nextMember = next, next = nextMember ? nextMember->next : (((void *)0)))
3021 {
3022 struct Identifier * nextID = (*nextMember->identifiers).first;
3023
3024 if(nextMember->identifiers && (*nextMember->identifiers).count > 1 && !strcmp(firstID->string, nextID->string))
3025 {
3026 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Remove((&*nextMembers->dataMembers), nextMember);
3027 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Remove((&*nextMember->identifiers), nextID);
3028 ListAdd(partList, nextMember);
3029 }
3030 }
3031 }
3032 }
3033 member->initializer->exp = MkExpInstance(MkInstantiation(spec, (((void *)0)), MkListOne(MkMembersInitList(partList))));
3034 member->identifiers = (((void *)0));
3035 }
3036 found = 0x1;
3037 break;
3038 }
3039 }
3040 else
3041 {
3042 __ecereNameSpace__ecere__com__eClass_FindNextMember(classSym->registered, &curClass, &curMember, subMemberStack, &subMemberStackPos);
3043 if(curMember == dataMember)
3044 {
3045 if(dataMember->isProperty)
3046 {
3047 if(!((struct __ecereNameSpace__ecere__com__Property *)dataMember)->Set)
3048 {
3049 Compiler_Error(__ecereNameSpace__ecere__GetTranslatedString("ec", "No set defined for property %s\n", (((void *)0))), dataMember->name);
3050 continue;
3051 }
3052 recursionCount--;
3053 return 0x0;
3054 }
3055 found = 0x1;
3056 break;
3057 }
3058 }
3059 }
3060 }
3061 if(found)
3062 break;
3063 }
3064 }
3065 if(dataMember->isProperty)
3066 continue;
3067 if(member && member->initializer && member->initializer->type == 0)
3068 {
3069 struct Expression * memberExp = (((void *)0));
3070
3071 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)
3072 {
3073 struct __ecereNameSpace__ecere__sys__OldList * subList = MkList();
3074
3075 ProcessBracketInst(member->initializer->exp->instance, subList);
3076 FreeExpression(member->initializer->exp);
3077 member->initializer->exp = (((void *)0));
3078 ListAdd(list, MkInitializerList(subList));
3079 }
3080 else
3081 {
3082 member->initializer->exp->usage = (member->initializer->exp->usage & ~0x1) | (((unsigned int)0x1) << 0);
3083 ProcessExpression(member->initializer->exp);
3084 ListAdd(list, MkInitializerAssignment(CopyExpression(member->initializer->exp)));
3085 }
3086 member->takeOutExp = 0x1;
3087 }
3088 else if(member && member->initializer && member->initializer->type == 1)
3089 {
3090 ListAdd(list, member->initializer);
3091 member->initializer = (((void *)0));
3092 }
3093 else if(dataMember && dataMember->dataTypeString)
3094 {
3095 struct Symbol * classSym;
3096
3097 if(!dataMember->dataType)
3098 dataMember->dataType = ProcessTypeString(dataMember->dataTypeString, 0x0);
3099 classSym = (dataMember->dataType && dataMember->dataType->kind == 8) ? dataMember->dataType->_class : (((void *)0));
3100 if(classSym && classSym->registered && classSym->registered->type == 1)
3101 {
3102 struct __ecereNameSpace__ecere__sys__OldList * subList = MkList();
3103 struct Specifier * spec = _MkSpecifierName(dataMember->dataTypeString, classSym, (((void *)0)));
3104 struct Instantiation * inst = MkInstantiation(spec, (((void *)0)), (((void *)0)));
3105
3106 ProcessBracketInst(inst, subList);
3107 FreeInstance(inst);
3108 ListAdd(list, MkInitializerList(subList));
3109 }
3110 else if(dataMember->dataType->kind == 12)
3111 ListAdd(list, MkInitializerList(MkListOne(MkInitializerAssignment(MkExpConstant("0")))));
3112 else
3113 ListAdd(list, MkInitializerAssignment(MkExpConstant("0")));
3114 }
3115 }
3116 }
3117 }
3118 if(inst->members && (*inst->members).first)
3119 {
3120 struct MembersInit * members;
3121 struct MemberInit * member = (((void *)0));
3122
3123 for(members = (*inst->members).first; members; members = members->next)
3124 {
3125 if(members->type == 0)
3126 {
3127 for(member = (*members->dataMembers).first; member; member = member->next)
3128 {
3129 if(member->takeOutExp)
3130 {
3131 FreeInitializer(member->initializer);
3132 member->initializer = (((void *)0));
3133 }
3134 }
3135 }
3136 }
3137 }
3138 recursionCount--;
3139 return 0x1;
3140 }
3141
3142 static void ProcessDeclaration(struct Declaration * decl)
3143 {
3144 yylloc = decl->loc;
3145 switch(decl->type)
3146 {
3147 case 1:
3148 {
3149 if(!curDecl)
3150 {
3151 curDecl = decl;
3152 declTempCount = 0;
3153 }
3154 if(decl->specifiers)
3155 {
3156 struct Specifier * s;
3157
3158 for(s = (*decl->specifiers).first; s; s = s->next)
3159 {
3160 ProcessSpecifier(s);
3161 }
3162 }
3163 if(decl->declarators)
3164 {
3165 struct InitDeclarator * d;
3166
3167 for(d = (*decl->declarators).first; d; d = d->next)
3168 {
3169 if(d->initializer)
3170 ProcessInitializer(d->initializer);
3171 }
3172 }
3173 if(curDecl == decl)
3174 {
3175 curDecl = (((void *)0));
3176 declTempCount = 0;
3177 }
3178 break;
3179 }
3180 case 2:
3181 {
3182 struct Instantiation * inst = decl->inst;
3183
3184 if(inCompiler)
3185 {
3186 struct Symbol * classSym = inst->_class->symbol;
3187
3188 if(!curCompound)
3189 {
3190 struct Statement * stmt;
3191
3192 if(!inst->isConstant || (classSym && classSym->registered && (classSym->registered->type == 0 || classSym->registered->type == 5)))
3193 {
3194 decl->type = 1;
3195 decl->specifiers = MkListOne(MkSpecifierName(inst->_class->name));
3196 if(decl->declMode == 3)
3197 {
3198 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Insert((&*decl->specifiers), (((void *)0)), MkSpecifier(STATIC));
3199 }
3200 decl->declarators = MkListOne(MkInitDeclarator(MkDeclaratorIdentifier(MkIdentifier(inst->exp->identifier->string)), (((void *)0))));
3201 ProcessDeclaration(decl);
3202 CreateInstancesBody();
3203 {
3204 struct Expression * exp = MkExpInstance(inst);
3205
3206 stmt = MkExpressionStmt(MkListOne(exp));
3207 ListAdd(createInstancesBody->compound.statements, stmt);
3208 ProcessExpressionType(exp);
3209 }
3210 if(classSym && classSym->registered && (classSym->registered->type == 0))
3211 {
3212 ListAdd(createInstancesBody->compound.statements, MkExpressionStmt(MkListOne(MkExpCall(MkExpIdentifier(MkIdentifier("ecere::com::eInstance_IncRef")), MkListOne(CopyExpression(inst->exp))))));
3213 {
3214 struct Expression * exp = MkExpOp((((void *)0)), DELETE, CopyExpression(inst->exp));
3215
3216 ListAdd(destroyInstancesBody->compound.statements, MkExpressionStmt(MkListOne(exp)));
3217 ProcessExpressionType(exp);
3218 }
3219 }
3220 else if(classSym && classSym->registered && (classSym->registered->type == 5))
3221 {
3222 struct Expression * exp = MkExpOp((((void *)0)), DELETE, CopyExpression(inst->exp));
3223
3224 ListAdd(destroyInstancesBody->compound.statements, MkExpressionStmt(MkListOne(exp)));
3225 ProcessExpressionType(exp);
3226 }
3227 break;
3228 }
3229 else
3230 {
3231 CreateInstancesBody();
3232 }
3233 }
3234 {
3235 char className[1024];
3236
3237 className[0] = (char)0;
3238 decl->type = 1;
3239 decl->specifiers = MkList();
3240 decl->declarators = MkList();
3241 if(classSym && classSym->registered && classSym->registered->type == 2)
3242 {
3243 struct __ecereNameSpace__ecere__sys__OldList list =
3244 {
3245 0
3246 };
3247
3248 ProcessInstMembers(inst, inst->exp, &list, 0x0);
3249 ProcessExpression(inst->exp);
3250 ListAdd(decl->specifiers, MkSpecifierName(inst->_class->name));
3251 ListAdd(decl->declarators, MkInitDeclarator(MkDeclaratorIdentifier(inst->exp->identifier), MkInitializerAssignment(list.first)));
3252 inst->exp->identifier = (((void *)0));
3253 }
3254 else if(classSym && classSym->registered && classSym->registered->type == 3)
3255 {
3256 struct __ecereNameSpace__ecere__sys__OldList list =
3257 {
3258 0
3259 };
3260
3261 ProcessInstMembers(inst, inst->exp, &list, 0x0);
3262 ProcessExpression(inst->exp);
3263 ListAdd(decl->specifiers, MkSpecifierName(inst->_class->name));
3264 ListAdd(decl->declarators, MkInitDeclarator(MkDeclaratorIdentifier(inst->exp->identifier), MkInitializerAssignment(list.first)));
3265 inst->exp->identifier = (((void *)0));
3266 }
3267 else if(classSym && classSym->registered && classSym->registered->type == 1)
3268 {
3269 struct Expression * exp;
3270
3271 DeclareStruct(inst->_class->name, 0x0);
3272 ProcessExpression(inst->exp);
3273 {
3274 if(inst->fullSet)
3275 {
3276 ListAdd(decl->specifiers, MkSpecifierName(inst->_class->name));
3277 ListAdd(decl->declarators, MkInitDeclarator(MkDeclaratorIdentifier(inst->exp->identifier), (((void *)0))));
3278 inst->exp->identifier = (((void *)0));
3279 }
3280 else
3281 {
3282 struct __ecereNameSpace__ecere__sys__OldList * list = MkList();
3283
3284 if(ProcessBracketInst(inst, list))
3285 {
3286 ListAdd(decl->specifiers, MkSpecifierName(inst->_class->name));
3287 ListAdd(decl->declarators, MkInitDeclarator(MkDeclaratorIdentifier(inst->exp->identifier), MkInitializerList(list)));
3288 inst->exp->identifier = (((void *)0));
3289 }
3290 else
3291 {
3292 FreeList(list, FreeInitializer);
3293 exp = MkExpBrackets(MkList());
3294 ProcessInstMembers(inst, inst->exp, exp->list, 0x1);
3295 ListAdd(exp->list, CopyExpression(inst->exp));
3296 ListAdd(decl->specifiers, MkSpecifierName(inst->_class->name));
3297 ListAdd(decl->declarators, MkInitDeclarator(MkDeclaratorIdentifier(inst->exp->identifier), MkInitializerAssignment(exp)));
3298 inst->exp->identifier = (((void *)0));
3299 }
3300 }
3301 }
3302 }
3303 else
3304 {
3305 struct Expression * newCall;
3306
3307 strcpy(className, "__ecereClass_");
3308 if(classSym && classSym->registered && classSym->registered->type == 5 && classSym->registered->templateClass)
3309 {
3310 classSym = FindClass(classSym->registered->templateClass->fullName);
3311 FullClassNameCat(className, classSym->string, 0x1);
3312 }
3313 else
3314 FullClassNameCat(className, inst->_class->name, 0x1);
3315 MangleClassName(className);
3316 if(classSym)
3317 DeclareClass(classSym, className);
3318 if(classSym && classSym->registered && classSym->registered->type == 5 && (classSym->registered->templateClass ? classSym->registered->templateClass->fixed : classSym->registered->fixed))
3319 {
3320 char size[256];
3321
3322 sprintf(size, "%d", classSym->registered->templateClass ? classSym->registered->templateClass->structSize : classSym->registered->structSize);
3323 newCall = MkExpCall(QMkExpId("ecere::com::eSystem_New0"), MkListOne(MkExpConstant(size)));
3324 }
3325 else
3326 {
3327 newCall = MkExpCall(QMkExpId("ecere::com::eInstance_New"), MkListOne(QMkExpId(className)));
3328 ProcessExpressionType(newCall);
3329 newCall->byReference = 0x1;
3330 }
3331 if(inst->exp)
3332 {
3333 struct Expression * exp, * newExp;
3334 struct Identifier * id = CopyIdentifier(inst->exp->identifier);
3335
3336 if(inst->members && (*inst->members).first)
3337 {
3338 newExp = MkExpOp(CopyExpression(inst->exp), '=', newCall);
3339 exp = MkExpBrackets(MkList());
3340 ListAdd(exp->list, newExp);
3341 ProcessInstMembers(inst, inst->exp, exp->list, 0x0);
3342 ListAdd(exp->list, inst->exp);
3343 ProcessExpression(inst->exp);
3344 inst->exp = (((void *)0));
3345 }
3346 else
3347 exp = newCall;
3348 ListAdd(decl->specifiers, MkSpecifierName(inst->_class->name));
3349 ListAdd(decl->declarators, MkInitDeclarator(MkDeclaratorIdentifier(id), MkInitializerAssignment(exp)));
3350 }
3351 else
3352 FreeExpression(newCall);
3353 }
3354 }
3355 FreeInstance(inst);
3356 }
3357 else
3358 ProcessInstantiation(inst);
3359 break;
3360 }
3361 case 0:
3362 {
3363 if(decl->specifiers)
3364 {
3365 struct Specifier * spec;
3366
3367 for(spec = (*decl->specifiers).first; spec; spec = spec->next)
3368 ProcessSpecifier(spec);
3369 }
3370 break;
3371 }
3372 }
3373 }
3374
3375 static void ProcessStatement(struct Statement * stmt)
3376 {
3377 yylloc = stmt->loc;
3378 switch(stmt->type)
3379 {
3380 case 0:
3381 if(stmt->labeled.stmt)
3382 ProcessStatement(stmt->labeled.stmt);
3383 break;
3384 case 1:
3385 if(stmt->caseStmt.exp)
3386 ProcessExpression(stmt->caseStmt.exp);
3387 if(stmt->caseStmt.stmt)
3388 ProcessStatement(stmt->caseStmt.stmt);
3389 break;
3390 case 2:
3391 {
3392 if(stmt->compound.context)
3393 {
3394 struct Declaration * decl;
3395 struct Statement * s;
3396 struct Statement * prevCompound = curCompound;
3397 struct Context * prevContext = curContext;
3398
3399 if(!stmt->compound.isSwitch)
3400 {
3401 curCompound = stmt;
3402 curContext = stmt->compound.context;
3403 }
3404 if(stmt->compound.declarations)
3405 {
3406 for(decl = (*stmt->compound.declarations).first; decl; decl = decl->next)
3407 ProcessDeclaration(decl);
3408 }
3409 if(stmt->compound.statements)
3410 {
3411 for(s = (*stmt->compound.statements).first; s; s = s->next)
3412 {
3413 ProcessStatement(s);
3414 }
3415 }
3416 curCompound = prevCompound;
3417 curContext = prevContext;
3418 }
3419 break;
3420 }
3421 case 3:
3422 {
3423 struct Expression * exp;
3424
3425 if(stmt->expressions)
3426 {
3427 for(exp = (*stmt->expressions).first; exp; exp = exp->next)
3428 {
3429 ProcessExpression(exp);
3430 }
3431 }
3432 break;
3433 }
3434 case 4:
3435 {
3436 struct Expression * exp;
3437
3438 ((struct Expression *)(*stmt->ifStmt.exp).last)->usage = (((struct Expression *)(*stmt->ifStmt.exp).last)->usage & ~0x1) | (((unsigned int)0x1) << 0);
3439 for(exp = (*stmt->ifStmt.exp).first; exp; exp = exp->next)
3440 {
3441 ProcessExpression(exp);
3442 }
3443 if(stmt->ifStmt.stmt)
3444 ProcessStatement(stmt->ifStmt.stmt);
3445 if(stmt->ifStmt.elseStmt)
3446 ProcessStatement(stmt->ifStmt.elseStmt);
3447 break;
3448 }
3449 case 5:
3450 {
3451 struct Expression * exp;
3452
3453 ((struct Expression *)(*stmt->switchStmt.exp).last)->usage = (((struct Expression *)(*stmt->switchStmt.exp).last)->usage & ~0x1) | (((unsigned int)0x1) << 0);
3454 for(exp = (*stmt->switchStmt.exp).first; exp; exp = exp->next)
3455 ProcessExpression(exp);
3456 ProcessStatement(stmt->switchStmt.stmt);
3457 break;
3458 }
3459 case 6:
3460 {
3461 if(stmt->whileStmt.exp)
3462 {
3463 struct Expression * exp;
3464
3465 ((struct Expression *)(*stmt->whileStmt.exp).last)->usage = (((struct Expression *)(*stmt->whileStmt.exp).last)->usage & ~0x1) | (((unsigned int)0x1) << 0);
3466 for(exp = (*stmt->whileStmt.exp).first; exp; exp = exp->next)
3467 {
3468 ProcessExpression(exp);
3469 }
3470 }
3471 if(stmt->whileStmt.stmt)
3472 ProcessStatement(stmt->whileStmt.stmt);
3473 break;
3474 }
3475 case 7:
3476 {
3477 if(stmt->doWhile.exp)
3478 {
3479 struct Expression * exp;
3480
3481 ((struct Expression *)(*stmt->doWhile.exp).last)->usage = (((struct Expression *)(*stmt->doWhile.exp).last)->usage & ~0x1) | (((unsigned int)0x1) << 0);
3482 for(exp = (*stmt->doWhile.exp).first; exp; exp = exp->next)
3483 {
3484 ProcessExpression(exp);
3485 }
3486 }
3487 if(stmt->doWhile.stmt)
3488 ProcessStatement(stmt->doWhile.stmt);
3489 break;
3490 }
3491 case 8:
3492 {
3493 struct Expression * exp;
3494
3495 if(stmt->forStmt.init)
3496 ProcessStatement(stmt->forStmt.init);
3497 if(stmt->forStmt.check && stmt->forStmt.check->expressions)
3498 {
3499 ((struct Expression *)(*stmt->forStmt.check->expressions).last)->usage = (((struct Expression *)(*stmt->forStmt.check->expressions).last)->usage & ~0x1) | (((unsigned int)0x1) << 0);
3500 }
3501 if(stmt->forStmt.check)
3502 ProcessStatement(stmt->forStmt.check);
3503 if(stmt->forStmt.increment)
3504 {
3505 for(exp = (*stmt->forStmt.increment).first; exp; exp = exp->next)
3506 ProcessExpression(exp);
3507 }
3508 if(stmt->forStmt.stmt)
3509 ProcessStatement(stmt->forStmt.stmt);
3510 break;
3511 }
3512 case 9:
3513 break;
3514 case 10:
3515 break;
3516 case 11:
3517 break;
3518 case 12:
3519 {
3520 struct Expression * exp;
3521
3522 if(stmt->expressions && (*stmt->expressions).last)
3523 {
3524 ((struct Expression *)(*stmt->expressions).last)->usage = (((struct Expression *)(*stmt->expressions).last)->usage & ~0x1) | (((unsigned int)0x1) << 0);
3525 for(exp = (*stmt->expressions).first; exp; exp = exp->next)
3526 {
3527 ProcessExpression(exp);
3528 }
3529 }
3530 break;
3531 }
3532 case 14:
3533 {
3534 ProcessDeclaration(stmt->decl);
3535 break;
3536 }
3537 case 13:
3538 {
3539 struct AsmField * field;
3540
3541 if(stmt->asmStmt.inputFields)
3542 {
3543 for(field = (*stmt->asmStmt.inputFields).first; field; field = field->next)
3544 if(field->expression)
3545 ProcessExpression(field->expression);
3546 }
3547 if(stmt->asmStmt.outputFields)
3548 {
3549 for(field = (*stmt->asmStmt.outputFields).first; field; field = field->next)
3550 if(field->expression)
3551 ProcessExpression(field->expression);
3552 }
3553 if(stmt->asmStmt.clobberedFields)
3554 {
3555 for(field = (*stmt->asmStmt.clobberedFields).first; field; field = field->next)
3556 if(field->expression)
3557 ProcessExpression(field->expression);
3558 }
3559 break;
3560 }
3561 }
3562 }
3563
3564 static void ProcessFunction(struct FunctionDefinition * function)
3565 {
3566 if(function->body)
3567 {
3568 yylloc = function->loc;
3569 ProcessStatement(function->body);
3570 }
3571 }
3572
3573 extern struct Type * MkClassTypeSymbol(struct Symbol * symbol);
3574
3575 extern void FreeSymbol(struct Symbol * symbol);
3576
3577 unsigned int __ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_Add(struct __ecereNameSpace__ecere__sys__BinaryTree * this, struct __ecereNameSpace__ecere__sys__BTNode * node);
3578
3579 void __ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_Remove(struct __ecereNameSpace__ecere__sys__BinaryTree * this, struct __ecereNameSpace__ecere__sys__BTNode * node);
3580
3581 void ProcessInstantiations()
3582 {
3583 struct External * external;
3584
3585 for(external = (*ast).first; external; external = external->next)
3586 {
3587 curExternal = external;
3588 if(external->type == 1)
3589 {
3590 if(external->declaration)
3591 ProcessDeclaration(external->declaration);
3592 }
3593 else if(external->type == 0)
3594 {
3595 ProcessFunction(external->function);
3596 }
3597 else if(external->type == 2)
3598 {
3599 struct ClassDefinition * _class = external->_class;
3600
3601 if(_class->definitions)
3602 {
3603 struct ClassDef * def;
3604
3605 for(def = (*_class->definitions).first; def; def = def->next)
3606 {
3607 if(def->type == 0)
3608 {
3609 curExternal = def->function->declarator ? def->function->declarator->symbol->pointerExternal : external;
3610 ProcessFunction((struct FunctionDefinition *)def->function);
3611 }
3612 else if(def->type == 2 && def->decl->type == 2)
3613 {
3614 ProcessInstantiation(def->decl->inst);
3615 }
3616 else if(def->type == 1 && def->defProperties)
3617 {
3618 struct MemberInit * defProperty;
3619 struct Symbol * thisSymbol = (thisSymbol = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass_Symbol), thisSymbol->string = __ecereNameSpace__ecere__sys__CopyString("this"), thisSymbol->type = MkClassTypeSymbol(_class->symbol), thisSymbol);
3620
3621 __ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_Add(&globalContext->symbols, (struct __ecereNameSpace__ecere__sys__BTNode *)thisSymbol);
3622 for(defProperty = (*def->defProperties).first; defProperty; defProperty = defProperty->next)
3623 {
3624 ProcessMemberInitData(defProperty);
3625 }
3626 __ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_Remove(&globalContext->symbols, (struct __ecereNameSpace__ecere__sys__BTNode *)thisSymbol);
3627 FreeSymbol(thisSymbol);
3628 }
3629 else if(def->type == 3 && def->propertyDef)
3630 {
3631 struct PropertyDef * prop = def->propertyDef;
3632 struct Symbol * thisSymbol = (thisSymbol = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass_Symbol), thisSymbol->string = __ecereNameSpace__ecere__sys__CopyString("this"), thisSymbol->type = MkClassTypeSymbol(_class->symbol), thisSymbol);
3633
3634 __ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_Add(&globalContext->symbols, (struct __ecereNameSpace__ecere__sys__BTNode *)thisSymbol);
3635 if(prop->setStmt)
3636 {
3637 curExternal = prop->symbol ? prop->symbol->externalSet : (((void *)0));
3638 ProcessStatement(prop->setStmt);
3639 }
3640 if(prop->getStmt)
3641 {
3642 curExternal = prop->symbol ? prop->symbol->externalGet : (((void *)0));
3643 ProcessStatement(prop->getStmt);
3644 }
3645 if(prop->issetStmt)
3646 {
3647 curExternal = prop->symbol ? prop->symbol->externalIsSet : (((void *)0));
3648 ProcessStatement(prop->issetStmt);
3649 }
3650 __ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_Remove(&globalContext->symbols, (struct __ecereNameSpace__ecere__sys__BTNode *)thisSymbol);
3651 FreeSymbol(thisSymbol);
3652 }
3653 else if(def->type == 4 && def->propertyWatch)
3654 {
3655 struct PropertyWatch * propertyWatch = def->propertyWatch;
3656 struct Symbol * thisSymbol = (thisSymbol = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass_Symbol), thisSymbol->string = __ecereNameSpace__ecere__sys__CopyString("this"), thisSymbol->type = MkClassTypeSymbol(_class->symbol), thisSymbol);
3657
3658 __ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_Add(&globalContext->symbols, (struct __ecereNameSpace__ecere__sys__BTNode *)thisSymbol);
3659 if(propertyWatch->compound)
3660 {
3661 __ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_Add(&propertyWatch->compound->compound.context->symbols, (struct __ecereNameSpace__ecere__sys__BTNode *)thisSymbol);
3662 curExternal = (((void *)0));
3663 ProcessStatement(propertyWatch->compound);
3664 }
3665 __ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_Remove(&globalContext->symbols, (struct __ecereNameSpace__ecere__sys__BTNode *)thisSymbol);
3666 FreeSymbol(thisSymbol);
3667 }
3668 }
3669 }
3670 }
3671 }
3672 }
3673
3674 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass___ecereNameSpace__ecere__com__GlobalFunction;
3675
3676 struct __ecereNameSpace__ecere__com__GlobalFunction;
3677
3678 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);
3679
3680 void __ecereRegisterModule_pass16(struct __ecereNameSpace__ecere__com__Instance * module)
3681 {
3682 struct __ecereNameSpace__ecere__com__Class * class;
3683
3684 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("DeclareClass", "void DeclareClass(Symbol classSym, char * className)", DeclareClass, module, 1);
3685 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("ProcessExpressionInstPass", "void ProcessExpressionInstPass(Expression exp)", ProcessExpressionInstPass, module, 2);
3686 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("ProcessInstantiations", "void ProcessInstantiations(void)", ProcessInstantiations, module, 1);
3687 }
3688
3689 void __ecereUnregisterModule_pass16(struct __ecereNameSpace__ecere__com__Instance * module)
3690 {
3691
3692 }
3693