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

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