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

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