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 struct Expression * prev = exp->prev, * next = exp->next;
2295
2296 FreeType(newCall->destType);
2297 FreeType(newCall->expType);
2298 newCall->destType = exp->destType;
2299 newCall->expType = exp->expType;
2300 *exp = *newCall;
2301 exp->prev = prev;
2302 exp->next = next;
2303 ((newCall ? (__ecereClass_Expression->Destructor ? __ecereClass_Expression->Destructor((void *)newCall) : 0, __ecereNameSpace__ecere__com__eSystem_Delete(newCall)) : 0), newCall = 0);
2304 }
2305 }
2306 }
2307 if(exp->type != 1)
2308 FreeInstance(inst);
2309 }
2310 else
2311 ProcessInstantiation(inst);
2312 break;
2313 }
2314 case 2:
2315 break;
2316 case 3:
2317 break;
2318 case 13:
2319 case 26:
2320 ProcessExpression(exp->__anon1._new.size);
2321 break;
2322 case 14:
2323 case 27:
2324 ProcessExpression(exp->__anon1._renew.size);
2325 ProcessExpression(exp->__anon1._renew.exp);
2326 break;
2327 case 4:
2328 {
2329 switch(exp->__anon1.op.op)
2330 {
2331 case '=':
2332 if(exp->__anon1.op.exp2)
2333 exp->__anon1.op.exp2->usage = (exp->__anon1.op.exp2->usage & ~0x1) | (((unsigned int)(0x1)) << 0);
2334 if(exp->__anon1.op.exp1)
2335 exp->__anon1.op.exp1->usage = (exp->__anon1.op.exp1->usage & ~0x2) | (((unsigned int)(0x1)) << 1);
2336 break;
2337 case MUL_ASSIGN:
2338 case DIV_ASSIGN:
2339 case MOD_ASSIGN:
2340 case ADD_ASSIGN:
2341 case SUB_ASSIGN:
2342 case LEFT_ASSIGN:
2343 case RIGHT_ASSIGN:
2344 case AND_ASSIGN:
2345 case XOR_ASSIGN:
2346 case OR_ASSIGN:
2347 if(exp->__anon1.op.exp2)
2348 exp->__anon1.op.exp2->usage = (exp->__anon1.op.exp2->usage & ~0x1) | (((unsigned int)(0x1)) << 0);
2349 if(exp->__anon1.op.exp1)
2350 exp->__anon1.op.exp1->usage = (exp->__anon1.op.exp1->usage & ~0x2) | (((unsigned int)(0x1)) << 1);
2351 break;
2352 case INC_OP:
2353 case DEC_OP:
2354 if(exp->__anon1.op.exp1)
2355 exp->__anon1.op.exp1->usage = (exp->__anon1.op.exp1->usage & ~0x2) | (((unsigned int)(0x1)) << 1);
2356 case '&':
2357 if(exp->__anon1.op.exp1 && exp->__anon1.op.exp2)
2358 {
2359 exp->__anon1.op.exp1->usage = (exp->__anon1.op.exp1->usage & ~0x1) | (((unsigned int)(0x1)) << 0);
2360 exp->__anon1.op.exp2->usage = (exp->__anon1.op.exp2->usage & ~0x1) | (((unsigned int)(0x1)) << 0);
2361 }
2362 break;
2363 case '*':
2364 case '+':
2365 case '-':
2366 if(exp->__anon1.op.exp1)
2367 {
2368 exp->__anon1.op.exp1->usage = (exp->__anon1.op.exp1->usage & ~0x1) | (((unsigned int)(0x1)) << 0);
2369 }
2370 case '~':
2371 case '!':
2372 if(exp->__anon1.op.exp2)
2373 exp->__anon1.op.exp2->usage = (exp->__anon1.op.exp2->usage & ~0x1) | (((unsigned int)(0x1)) << 0);
2374 break;
2375 case '/':
2376 case '%':
2377 case LEFT_OP:
2378 case RIGHT_OP:
2379 case '<':
2380 case '>':
2381 case LE_OP:
2382 case GE_OP:
2383 case EQ_OP:
2384 case NE_OP:
2385 case '|':
2386 case '^':
2387 case AND_OP:
2388 case OR_OP:
2389 if(exp->__anon1.op.exp1)
2390 exp->__anon1.op.exp1->usage = (exp->__anon1.op.exp1->usage & ~0x1) | (((unsigned int)(0x1)) << 0);
2391 if(exp->__anon1.op.exp2)
2392 exp->__anon1.op.exp2->usage = (exp->__anon1.op.exp2->usage & ~0x1) | (((unsigned int)(0x1)) << 0);
2393 break;
2394 }
2395 if(exp->__anon1.op.exp1)
2396 {
2397 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)))
2398 {
2399 struct Type * type = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass_Type);
2400
2401 CopyTypeInto(type, exp->__anon1.op.exp1->destType);
2402 type->passAsTemplate = 0x0;
2403 FreeType(exp->__anon1.op.exp1->destType);
2404 exp->__anon1.op.exp1->destType = type;
2405 }
2406 ProcessExpression(exp->__anon1.op.exp1);
2407 }
2408 if(exp->__anon1.op.exp2)
2409 {
2410 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)))
2411 {
2412 struct Type * type = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass_Type);
2413
2414 CopyTypeInto(type, exp->__anon1.op.exp2->destType);
2415 type->passAsTemplate = 0x0;
2416 FreeType(exp->__anon1.op.exp2->destType);
2417 exp->__anon1.op.exp2->destType = type;
2418 }
2419 if(exp->__anon1.op.exp1)
2420 exp->__anon1.op.exp2->tempCount = exp->__anon1.op.exp1->tempCount;
2421 ProcessExpression(exp->__anon1.op.exp2);
2422 }
2423 break;
2424 }
2425 case 32:
2426 case 5:
2427 {
2428 struct Expression * e;
2429
2430 for(e = (*exp->__anon1.list).first; e; e = e->next)
2431 {
2432 int __simpleStruct2, __simpleStruct3;
2433 int __simpleStruct0, __simpleStruct1;
2434
2435 e->tempCount = (__simpleStruct0 = e->tempCount, __simpleStruct1 = exp->tempCount, (__simpleStruct0 > __simpleStruct1) ? __simpleStruct0 : __simpleStruct1);
2436 if(!e->next)
2437 {
2438 e->usage |= (exp->usage & ((((unsigned int)(0x1)) | (((unsigned int)(0x1)) << 2))));
2439 }
2440 ProcessExpression(e);
2441 exp->tempCount = (__simpleStruct2 = exp->tempCount, __simpleStruct3 = e->tempCount, (__simpleStruct2 > __simpleStruct3) ? __simpleStruct2 : __simpleStruct3);
2442 }
2443 break;
2444 }
2445 case 6:
2446 {
2447 struct Expression * e;
2448
2449 exp->__anon1.index.exp->usage = (exp->__anon1.index.exp->usage & ~0x1) | (((unsigned int)(0x1)) << 0);
2450 ProcessExpression(exp->__anon1.index.exp);
2451 for(e = (*exp->__anon1.index.index).first; e; e = e->next)
2452 {
2453 if(!e->next)
2454 e->usage = (e->usage & ~0x1) | (((unsigned int)(0x1)) << 0);
2455 ProcessExpression(e);
2456 }
2457 exp->tempCount = exp->__anon1.index.exp->tempCount;
2458 break;
2459 }
2460 case 7:
2461 {
2462 struct Expression * e;
2463
2464 ProcessExpression(exp->__anon1.call.exp);
2465 if(exp->__anon1.call.arguments)
2466 {
2467 for(e = (*exp->__anon1.call.arguments).first; e; e = e->next)
2468 {
2469 e->usage = (e->usage & ~0x1) | (((unsigned int)(0x1)) << 0);
2470 e->usage = (e->usage & ~0x4) | (((unsigned int)(0x1)) << 2);
2471 ProcessExpression(e);
2472 }
2473 }
2474 break;
2475 }
2476 case 8:
2477 {
2478 exp->__anon1.member.exp->usage = (exp->__anon1.member.exp->usage & ~0x1) | (((unsigned int)(0x1)) << 0);
2479 ProcessExpression(exp->__anon1.member.exp);
2480 if(!exp->__anon1.member.memberType)
2481 {
2482 struct Type * type = exp->__anon1.member.exp->expType;
2483
2484 if((type && type->kind == 8 && exp->__anon1.member.member))
2485 {
2486 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)));
2487 struct __ecereNameSpace__ecere__com__Property * prop = (((void *)0));
2488 struct __ecereNameSpace__ecere__com__Method * method = (((void *)0));
2489 struct __ecereNameSpace__ecere__com__DataMember * member = (((void *)0));
2490 struct __ecereNameSpace__ecere__com__Property * revConvert = (((void *)0));
2491
2492 if(exp->__anon1.member.thisPtr)
2493 {
2494 member = __ecereNameSpace__ecere__com__eClass_FindDataMember(_class, exp->__anon1.member.member->string, privateModule, (((void *)0)), (((void *)0)));
2495 if(!member)
2496 prop = __ecereNameSpace__ecere__com__eClass_FindProperty(_class, exp->__anon1.member.member->string, privateModule);
2497 }
2498 else
2499 {
2500 prop = __ecereNameSpace__ecere__com__eClass_FindProperty(_class, exp->__anon1.member.member->string, (((void *)0)));
2501 if(!prop)
2502 member = __ecereNameSpace__ecere__com__eClass_FindDataMember(_class, exp->__anon1.member.member->string, (((void *)0)), (((void *)0)), (((void *)0)));
2503 if(!prop && !member)
2504 {
2505 method = __ecereNameSpace__ecere__com__eClass_FindMethod(_class, exp->__anon1.member.member->string, (((void *)0)));
2506 if(!method)
2507 {
2508 prop = __ecereNameSpace__ecere__com__eClass_FindProperty(_class, exp->__anon1.member.member->string, privateModule);
2509 if(!prop)
2510 member = __ecereNameSpace__ecere__com__eClass_FindDataMember(_class, exp->__anon1.member.member->string, privateModule, (((void *)0)), (((void *)0)));
2511 }
2512 }
2513 }
2514 if(!prop && !member && !method)
2515 method = __ecereNameSpace__ecere__com__eClass_FindMethod(_class, exp->__anon1.member.member->string, privateModule);
2516 if(!prop && !member && !method)
2517 {
2518 struct Symbol * classSym = FindClass(exp->__anon1.member.member->string);
2519
2520 if(classSym)
2521 {
2522 struct __ecereNameSpace__ecere__com__Class * convertClass = classSym->__anon1.registered;
2523
2524 if(convertClass)
2525 revConvert = __ecereNameSpace__ecere__com__eClass_FindProperty(convertClass, _class->fullName, privateModule);
2526 }
2527 }
2528 if(prop)
2529 {
2530 exp->__anon1.member.memberType = 1;
2531 if(!prop->dataType)
2532 prop->dataType = ProcessTypeString(prop->dataTypeString, 0x0);
2533 FreeType(exp->expType);
2534 exp->expType = prop->dataType;
2535 if(prop->dataType)
2536 prop->dataType->refCount++;
2537 }
2538 else if(method)
2539 {
2540 exp->__anon1.member.memberType = 2;
2541 if(!method->dataType)
2542 ProcessMethodType(method);
2543 FreeType(exp->expType);
2544 exp->expType = method->dataType;
2545 if(method->dataType)
2546 method->dataType->refCount++;
2547 }
2548 else if(member)
2549 {
2550 exp->__anon1.member.memberType = 3;
2551 DeclareStruct(_class->fullName, 0x0);
2552 if(!member->dataType)
2553 member->dataType = ProcessTypeString(member->dataTypeString, 0x0);
2554 FreeType(exp->expType);
2555 exp->expType = member->dataType;
2556 if(member->dataType)
2557 member->dataType->refCount++;
2558 }
2559 else if(revConvert)
2560 {
2561 exp->__anon1.member.memberType = 4;
2562 FreeType(exp->expType);
2563 exp->expType = MkClassType(revConvert->_class->fullName);
2564 }
2565 }
2566 }
2567 break;
2568 }
2569 case 10:
2570 break;
2571 case 11:
2572 {
2573 exp->__anon1.cast.exp->usage |= exp->usage;
2574 ProcessExpression(exp->__anon1.cast.exp);
2575 break;
2576 }
2577 case 12:
2578 {
2579 struct Expression * e;
2580
2581 if(((unsigned int)((exp->usage & 0x1) >> 0)))
2582 exp->__anon1.cond.cond->usage = (exp->__anon1.cond.cond->usage & ~0x1) | (((unsigned int)(0x1)) << 0);
2583 ProcessExpression(exp->__anon1.cond.cond);
2584 for(e = (*exp->__anon1.cond.exp).first; e; e = e->next)
2585 {
2586 if(!e->next && ((unsigned int)((exp->usage & 0x1) >> 0)))
2587 e->usage = (e->usage & ~0x1) | (((unsigned int)(0x1)) << 0);
2588 ProcessExpression(e);
2589 }
2590 if(exp->__anon1.cond.elseExp)
2591 {
2592 if(((unsigned int)((exp->usage & 0x1) >> 0)))
2593 exp->__anon1.cond.elseExp->usage = (exp->__anon1.cond.elseExp->usage & ~0x1) | (((unsigned int)(0x1)) << 0);
2594 ProcessExpression(exp->__anon1.cond.elseExp);
2595 }
2596 break;
2597 }
2598 case 23:
2599 {
2600 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)
2601 {
2602 ((struct Expression *)(*((struct Statement *)(*exp->__anon1.compound->__anon1.compound.statements).last)->__anon1.expressions).last)->usage = exp->usage;
2603 }
2604 ProcessStatement(exp->__anon1.compound);
2605 break;
2606 }
2607 case 34:
2608 {
2609 ProcessExpression(exp->__anon1.vaArg.exp);
2610 break;
2611 }
2612 case 33:
2613 {
2614 ProcessInitializer(exp->__anon1.initializer.initializer);
2615 break;
2616 }
2617 }
2618 CheckTemplateTypes(exp);
2619 }
2620
2621 static void ProcessInitializer(struct Initializer * init)
2622 {
2623 switch(init->type)
2624 {
2625 case 0:
2626 init->__anon1.exp->usage = (init->__anon1.exp->usage & ~0x1) | (((unsigned int)(0x1)) << 0);
2627 ProcessExpression(init->__anon1.exp);
2628 break;
2629 case 1:
2630 {
2631 struct Initializer * i;
2632
2633 for(i = (*init->__anon1.list).first; i; i = i->next)
2634 ProcessInitializer(i);
2635 break;
2636 }
2637 }
2638 }
2639
2640 static void ProcessSpecifier(struct Specifier * spec)
2641 {
2642 switch(spec->type)
2643 {
2644 case 0:
2645 break;
2646 case 1:
2647 {
2648 break;
2649 }
2650 case 2:
2651 {
2652 struct Enumerator * e;
2653
2654 if(spec->__anon1.__anon2.list)
2655 {
2656 for(e = (*spec->__anon1.__anon2.list).first; e; e = e->next)
2657 {
2658 if(e->exp)
2659 ProcessExpression(e->exp);
2660 }
2661 }
2662 break;
2663 }
2664 case 3:
2665 case 4:
2666 {
2667 if(spec->__anon1.__anon2.definitions)
2668 {
2669 struct ClassDef * def;
2670
2671 for(def = (*spec->__anon1.__anon2.definitions).first; def; def = def->next)
2672 {
2673 if(def->type == 2 && def->__anon1.decl && def->__anon1.decl->type == 0)
2674 ProcessDeclaration(def->__anon1.decl);
2675 }
2676 }
2677 break;
2678 }
2679 }
2680 }
2681
2682 extern void FreeList(struct __ecereNameSpace__ecere__sys__OldList * list, void (*  FreeFunction)(void * ));
2683
2684 extern struct Specifier * _MkSpecifierName(const char *  name, struct Symbol * symbol, struct __ecereNameSpace__ecere__sys__OldList * templateArgs);
2685
2686 extern struct Identifier * CopyIdentifier(struct Identifier * id);
2687
2688 extern struct MemberInit * MkMemberInit(struct __ecereNameSpace__ecere__sys__OldList * ids, struct Initializer * initializer);
2689
2690 extern int strcmp(const char * , const char * );
2691
2692 extern struct Expression * MkExpInstance(struct Instantiation * inst);
2693
2694 extern struct MembersInit * MkMembersInitList(struct __ecereNameSpace__ecere__sys__OldList * dataMembers);
2695
2696 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)
2697 {
2698 struct Symbol * classSym = inst->_class->__anon1.__anon1.symbol;
2699 struct __ecereNameSpace__ecere__com__DataMember * dataMember = (((void *)0));
2700 unsigned int someMemberSet = 0x0;
2701 int anonID = 1;
2702
2703 for(dataMember = parentMember->members.first; dataMember; dataMember = dataMember->next)
2704 {
2705 struct MembersInit * members;
2706 struct MemberInit * member = (((void *)0));
2707
2708 if(!dataMember->name && (dataMember->type == 1 || dataMember->type == 2))
2709 {
2710 struct __ecereNameSpace__ecere__sys__OldList * subList = MkList();
2711
2712 if(!ProcessBracketInst_DataMember(dataMember, inst, subList ? subList : list, dataMember->name ? dataMember : namedParentMember, someMemberSet || parentMemberSet || dataMember->prev))
2713 {
2714 if(subList)
2715 FreeList(subList, FreeInitializer);
2716 return 0x0;
2717 }
2718 if(subList && (*subList).count)
2719 {
2720 struct Initializer * init = MkInitializerList(subList);
2721 char id[100];
2722
2723 sprintf(id, "__anon%d", anonID);
2724 init->id = MkIdentifier(id);
2725 ListAdd(list, init);
2726 someMemberSet = 0x1;
2727 }
2728 else
2729 {
2730 if(list->count)
2731 someMemberSet = 0x1;
2732 (__ecereNameSpace__ecere__com__eSystem_Delete(subList), subList = 0);
2733 }
2734 anonID++;
2735 }
2736 else
2737 {
2738 struct __ecereNameSpace__ecere__com__Class * curClass = (((void *)0));
2739 struct __ecereNameSpace__ecere__com__DataMember * curMember = (((void *)0));
2740 struct __ecereNameSpace__ecere__com__DataMember * subMemberStack[256];
2741 int subMemberStackPos = 0;
2742 unsigned int found = 0x0;
2743
2744 if(inst->members && (*inst->members).first)
2745 {
2746 for(members = (*inst->members).first; members; members = members->next)
2747 {
2748 if(members->type == 0)
2749 {
2750 for(member = (*members->__anon1.dataMembers).first; member; member = member->next)
2751 {
2752 if(member->identifiers)
2753 {
2754 struct Identifier * firstID = (*member->identifiers).first;
2755 struct __ecereNameSpace__ecere__com__DataMember * _subMemberStack[256];
2756 int _subMemberStackPos = 0;
2757 struct __ecereNameSpace__ecere__com__DataMember * thisMember;
2758
2759 thisMember = firstID ? (struct __ecereNameSpace__ecere__com__DataMember *)__ecereNameSpace__ecere__com__eClass_FindProperty(classSym->__anon1.registered, firstID->string, privateModule) : (((void *)0));
2760 if(!thisMember && firstID)
2761 thisMember = __ecereNameSpace__ecere__com__eClass_FindDataMember(classSym->__anon1.registered, firstID->string, privateModule, _subMemberStack, &_subMemberStackPos);
2762 if(thisMember && thisMember->memberAccess == 1)
2763 {
2764 curMember = thisMember;
2765 curClass = curMember->_class;
2766 memcpy(subMemberStack, _subMemberStack, sizeof(struct __ecereNameSpace__ecere__com__DataMember *) * _subMemberStackPos);
2767 subMemberStackPos = _subMemberStackPos;
2768 }
2769 if(dataMember == thisMember)
2770 {
2771 if((*member->identifiers).count > 1 && member->initializer && member->initializer->type == 0)
2772 {
2773 struct __ecereNameSpace__ecere__sys__OldList * partList = MkList();
2774 struct Symbol * symbol;
2775 struct Specifier * spec;
2776 struct MembersInit * nextMembers;
2777 struct MemberInit * next = member->next;
2778
2779 if(!dataMember->dataType)
2780 dataMember->dataType = ProcessTypeString(dataMember->dataTypeString, 0x0);
2781 symbol = (dataMember->dataType && dataMember->dataType->kind == 8) ? dataMember->dataType->__anon1._class : (((void *)0));
2782 spec = _MkSpecifierName(dataMember->dataTypeString, symbol, (((void *)0)));
2783 {
2784 struct __ecereNameSpace__ecere__sys__OldList * identifiers = MkList();
2785 struct Identifier * id;
2786
2787 for(id = ((struct Identifier *)(*member->identifiers).first)->next; id; id = id->next)
2788 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Add((&*identifiers), CopyIdentifier(id));
2789 ListAdd(partList, MkMemberInit(identifiers, MkInitializerAssignment(member->initializer->__anon1.exp)));
2790 }
2791 for(nextMembers = members; nextMembers; nextMembers = nextMembers->next)
2792 {
2793 if(!nextMembers->__anon1.dataMembers)
2794 continue;
2795 if(members != nextMembers)
2796 next = (*nextMembers->__anon1.dataMembers).first;
2797 if(nextMembers->type == 0)
2798 {
2799 struct MemberInit * nextMember;
2800
2801 for(nextMember = next; nextMember; nextMember = next, next = nextMember ? nextMember->next : (((void *)0)))
2802 {
2803 struct Identifier * nextID = (*nextMember->identifiers).first;
2804
2805 if(nextMember->identifiers && (*nextMember->identifiers).count > 1 && !strcmp(firstID->string, nextID->string))
2806 {
2807 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Remove((&*nextMembers->__anon1.dataMembers), nextMember);
2808 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Remove((&*nextMember->identifiers), nextID);
2809 ListAdd(partList, nextMember);
2810 }
2811 }
2812 }
2813 }
2814 member->initializer->__anon1.exp = MkExpInstance(MkInstantiation(spec, (((void *)0)), MkListOne(MkMembersInitList(partList))));
2815 }
2816 found = 0x1;
2817 break;
2818 }
2819 }
2820 else
2821 {
2822 __ecereNameSpace__ecere__com__eClass_FindNextMember(classSym->__anon1.registered, &curClass, &curMember, subMemberStack, &subMemberStackPos);
2823 if(curMember == dataMember)
2824 {
2825 found = 0x1;
2826 break;
2827 }
2828 }
2829 }
2830 }
2831 if(found)
2832 break;
2833 }
2834 }
2835 if(member && member->initializer && member->initializer->type == 0)
2836 {
2837 struct Initializer * init = (init = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass_Initializer), init->loc = yylloc, init);
2838
2839 if(namedParentMember->type == 1 && dataMember->name)
2840 init->id = MkIdentifier(dataMember->name);
2841 if(member->initializer->__anon1.exp->type == 1 && member->initializer->__anon1.exp->expType && member->initializer->__anon1.exp->expType->__anon1._class->__anon1.registered->type == 1)
2842 {
2843 struct __ecereNameSpace__ecere__sys__OldList * subList = MkList();
2844
2845 ProcessBracketInst(member->initializer->__anon1.exp->__anon1.instance, subList);
2846 FreeExpression(member->initializer->__anon1.exp);
2847 if((*subList).count)
2848 {
2849 init->type = 1;
2850 init->__anon1.list = subList;
2851 }
2852 else
2853 {
2854 FreeInitializer(init);
2855 init = (((void *)0));
2856 }
2857 }
2858 else
2859 {
2860 member->initializer->__anon1.exp->usage = (member->initializer->__anon1.exp->usage & ~0x1) | (((unsigned int)(0x1)) << 0);
2861 ProcessExpression(member->initializer->__anon1.exp);
2862 init->type = 0;
2863 init->__anon1.exp = member->initializer->__anon1.exp;
2864 }
2865 if(init)
2866 ListAdd(list, init);
2867 member->initializer->__anon1.exp = (((void *)0));
2868 FreeInitializer(member->initializer);
2869 member->initializer = (((void *)0));
2870 someMemberSet = 0x1;
2871 }
2872 else if(member && member->initializer && member->initializer->type == 1)
2873 {
2874 if(namedParentMember->type == 1 && dataMember->name)
2875 member->initializer->id = MkIdentifier(dataMember->name);
2876 ListAdd(list, member->initializer);
2877 member->initializer = (((void *)0));
2878 someMemberSet = 0x1;
2879 }
2880 else if(dataMember && dataMember->dataTypeString && parentMember->type != 1 && namedParentMember->type != 1)
2881 {
2882 struct Symbol * classSym;
2883 struct Initializer * init = (init = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass_Initializer), init->loc = yylloc, init);
2884
2885 if(namedParentMember->type == 1 && dataMember->name)
2886 init->id = MkIdentifier(dataMember->name);
2887 if(!dataMember->dataType)
2888 dataMember->dataType = ProcessTypeString(dataMember->dataTypeString, 0x0);
2889 classSym = (dataMember->dataType && dataMember->dataType->kind == 8) ? dataMember->dataType->__anon1._class : (((void *)0));
2890 if(classSym && classSym->__anon1.registered && classSym->__anon1.registered->type == 1)
2891 {
2892 struct __ecereNameSpace__ecere__sys__OldList * subList = MkList();
2893 struct Specifier * spec = _MkSpecifierName(dataMember->dataTypeString, classSym, (((void *)0)));
2894 struct Instantiation * inst = MkInstantiation(spec, (((void *)0)), (((void *)0)));
2895
2896 ProcessBracketInst(inst, subList);
2897 FreeInstance(inst);
2898 if((*subList).count)
2899 {
2900 init->type = 1;
2901 init->__anon1.list = subList;
2902 }
2903 else
2904 {
2905 FreeInitializer(init);
2906 init = (((void *)0));
2907 }
2908 }
2909 else
2910 {
2911 init->type = 0;
2912 init->__anon1.exp = MkExpConstant("0");
2913 }
2914 someMemberSet = 0x1;
2915 if(init)
2916 ListAdd(list, init);
2917 }
2918 }
2919 }
2920 if(!someMemberSet && !parentMemberSet)
2921 {
2922 struct Symbol * classSym;
2923 struct Initializer * init = (init = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass_Initializer), init->loc = yylloc, init);
2924
2925 dataMember = parentMember->members.first;
2926 if(namedParentMember->type == 1 && dataMember->name)
2927 init->id = MkIdentifier(dataMember->name);
2928 if(!dataMember->dataType && dataMember->dataTypeString)
2929 dataMember->dataType = ProcessTypeString(dataMember->dataTypeString, 0x0);
2930 classSym = (dataMember->dataType && dataMember->dataType->kind == 8) ? dataMember->dataType->__anon1._class : (((void *)0));
2931 if(classSym && classSym->__anon1.registered && classSym->__anon1.registered->type == 1)
2932 {
2933 struct __ecereNameSpace__ecere__sys__OldList * subList = MkList();
2934 struct Specifier * spec = _MkSpecifierName(dataMember->dataTypeString, classSym, (((void *)0)));
2935 struct Instantiation * inst = MkInstantiation(spec, (((void *)0)), (((void *)0)));
2936
2937 ProcessBracketInst(inst, subList);
2938 FreeInstance(inst);
2939 init->type = 1;
2940 init->__anon1.list = subList;
2941 }
2942 else
2943 {
2944 init->type = 0;
2945 init->__anon1.exp = MkExpConstant("0");
2946 }
2947 ListAdd(list, init);
2948 }
2949 return 0x1;
2950 }
2951
2952 extern void Compiler_Error(const char *  format, ...);
2953
2954 extern const char *  __ecereNameSpace__ecere__GetTranslatedString(const char * name, const char *  string, const char *  stringAndContext);
2955
2956 static unsigned int ProcessBracketInst(struct Instantiation * inst, struct __ecereNameSpace__ecere__sys__OldList * list)
2957 {
2958 static int recursionCount = 0;
2959 struct Symbol * classSym = inst->_class->__anon1.__anon1.symbol;
2960 struct __ecereNameSpace__ecere__com__Class * _class = (((void *)0));
2961 int anonID = 1;
2962
2963 if(recursionCount > 500)
2964 return 0x0;
2965 recursionCount++;
2966 while(_class != classSym->__anon1.registered)
2967 {
2968 struct __ecereNameSpace__ecere__com__DataMember * dataMember;
2969 struct __ecereNameSpace__ecere__com__Class * lastClass = _class;
2970
2971 for(_class = classSym->__anon1.registered; _class->base != lastClass && _class->base->type != 1000; _class = _class->base)
2972 ;
2973 for(dataMember = _class->membersAndProperties.first; dataMember; dataMember = dataMember->next)
2974 {
2975 if(!dataMember->isProperty && !dataMember->name && (dataMember->type == 1 || dataMember->type == 2))
2976 {
2977 struct __ecereNameSpace__ecere__sys__OldList * subList = MkList();
2978
2979 if(!ProcessBracketInst_DataMember(dataMember, inst, subList ? subList : list, dataMember, 0x0))
2980 {
2981 if(subList)
2982 FreeList(subList, FreeInitializer);
2983 recursionCount--;
2984 return 0x0;
2985 }
2986 if(dataMember->type == 2 || (subList && (*subList).count))
2987 {
2988 struct Initializer * init = MkInitializerList(subList);
2989 char id[100];
2990
2991 sprintf(id, "__anon%d", anonID);
2992 init->id = MkIdentifier(id);
2993 ListAdd(list, init);
2994 }
2995 else
2996 (__ecereNameSpace__ecere__com__eSystem_Delete(subList), subList = 0);
2997 anonID++;
2998 }
2999 else
3000 {
3001 struct MembersInit * members;
3002 struct MemberInit * member = (((void *)0));
3003 unsigned int found = 0x0;
3004
3005 if(inst->members && (*inst->members).first)
3006 {
3007 struct __ecereNameSpace__ecere__com__DataMember * curMember = (((void *)0));
3008 struct __ecereNameSpace__ecere__com__Class * curClass = (((void *)0));
3009 struct __ecereNameSpace__ecere__com__DataMember * subMemberStack[256];
3010 int subMemberStackPos = 0;
3011
3012 for(members = (*inst->members).first; members; members = members->next)
3013 {
3014 if(members->type == 0)
3015 {
3016 for(member = (*members->__anon1.dataMembers).first; member; member = member->next)
3017 {
3018 struct Identifier * firstID = member->identifiers ? (*member->identifiers).first : (((void *)0));
3019
3020 if(firstID)
3021 {
3022 struct __ecereNameSpace__ecere__com__DataMember * _subMemberStack[256];
3023 int _subMemberStackPos = 0;
3024 struct __ecereNameSpace__ecere__com__DataMember * thisMember = (struct __ecereNameSpace__ecere__com__DataMember *)__ecereNameSpace__ecere__com__eClass_FindProperty(classSym->__anon1.registered, firstID->string, privateModule);
3025
3026 if(!thisMember)
3027 thisMember = __ecereNameSpace__ecere__com__eClass_FindDataMember(classSym->__anon1.registered, firstID->string, privateModule, _subMemberStack, &_subMemberStackPos);
3028 if(thisMember)
3029 {
3030 curMember = thisMember;
3031 curClass = curMember->_class;
3032 memcpy(subMemberStack, _subMemberStack, sizeof(struct __ecereNameSpace__ecere__com__DataMember *) * _subMemberStackPos);
3033 subMemberStackPos = _subMemberStackPos;
3034 }
3035 if(curMember == dataMember)
3036 {
3037 if(dataMember->isProperty)
3038 {
3039 if(!((struct __ecereNameSpace__ecere__com__Property *)dataMember)->Set)
3040 {
3041 Compiler_Error(__ecereNameSpace__ecere__GetTranslatedString("ec", "No set defined for property %s\n", (((void *)0))), dataMember->name);
3042 continue;
3043 }
3044 recursionCount--;
3045 return 0x0;
3046 }
3047 if((*member->identifiers).count > 1 && member->initializer && member->initializer->type == 0)
3048 {
3049 struct __ecereNameSpace__ecere__sys__OldList * partList = MkList();
3050 struct Specifier * spec;
3051 struct MembersInit * nextMembers;
3052 struct MemberInit * next = member->next;
3053 struct Symbol * symbol;
3054
3055 if(!dataMember->dataType)
3056 dataMember->dataType = ProcessTypeString(dataMember->dataTypeString, 0x0);
3057 symbol = (dataMember->dataType && dataMember->dataType->kind == 8) ? dataMember->dataType->__anon1._class : (((void *)0));
3058 spec = _MkSpecifierName(dataMember->dataTypeString, symbol, (((void *)0)));
3059 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Remove((&*member->identifiers), firstID);
3060 ListAdd(partList, MkMemberInit(member->identifiers, MkInitializerAssignment(member->initializer->__anon1.exp)));
3061 for(nextMembers = members; nextMembers; nextMembers = nextMembers->next)
3062 {
3063 if(!nextMembers->__anon1.dataMembers)
3064 continue;
3065 if(members != nextMembers)
3066 next = (*nextMembers->__anon1.dataMembers).first;
3067 if(nextMembers->type == 0)
3068 {
3069 struct MemberInit * nextMember;
3070
3071 for(nextMember = next; nextMember; nextMember = next, next = nextMember ? nextMember->next : (((void *)0)))
3072 {
3073 struct Identifier * nextID = (*nextMember->identifiers).first;
3074
3075 if(nextMember->identifiers && (*nextMember->identifiers).count > 1 && !strcmp(firstID->string, nextID->string))
3076 {
3077 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Remove((&*nextMembers->__anon1.dataMembers), nextMember);
3078 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Remove((&*nextMember->identifiers), nextID);
3079 ListAdd(partList, nextMember);
3080 }
3081 }
3082 }
3083 }
3084 member->initializer->__anon1.exp = MkExpInstance(MkInstantiation(spec, (((void *)0)), MkListOne(MkMembersInitList(partList))));
3085 member->identifiers = (((void *)0));
3086 }
3087 found = 0x1;
3088 break;
3089 }
3090 }
3091 else
3092 {
3093 __ecereNameSpace__ecere__com__eClass_FindNextMember(classSym->__anon1.registered, &curClass, &curMember, subMemberStack, &subMemberStackPos);
3094 if(curMember == dataMember)
3095 {
3096 if(dataMember->isProperty)
3097 {
3098 if(!((struct __ecereNameSpace__ecere__com__Property *)dataMember)->Set)
3099 {
3100 Compiler_Error(__ecereNameSpace__ecere__GetTranslatedString("ec", "No set defined for property %s\n", (((void *)0))), dataMember->name);
3101 continue;
3102 }
3103 recursionCount--;
3104 return 0x0;
3105 }
3106 found = 0x1;
3107 break;
3108 }
3109 }
3110 }
3111 }
3112 if(found)
3113 break;
3114 }
3115 }
3116 if(dataMember->isProperty)
3117 continue;
3118 if(member && member->initializer && member->initializer->type == 0)
3119 {
3120 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)
3121 {
3122 struct __ecereNameSpace__ecere__sys__OldList * subList = MkList();
3123
3124 ProcessBracketInst(member->initializer->__anon1.exp->__anon1.instance, subList);
3125 FreeExpression(member->initializer->__anon1.exp);
3126 member->initializer->__anon1.exp = (((void *)0));
3127 ListAdd(list, MkInitializerList(subList));
3128 }
3129 else
3130 {
3131 member->initializer->__anon1.exp->usage = (member->initializer->__anon1.exp->usage & ~0x1) | (((unsigned int)(0x1)) << 0);
3132 ProcessExpression(member->initializer->__anon1.exp);
3133 ListAdd(list, MkInitializerAssignment(CopyExpression(member->initializer->__anon1.exp)));
3134 }
3135 member->takeOutExp = 0x1;
3136 }
3137 else if(member && member->initializer && member->initializer->type == 1)
3138 {
3139 ListAdd(list, member->initializer);
3140 member->initializer = (((void *)0));
3141 }
3142 else if(dataMember && dataMember->dataTypeString)
3143 {
3144 struct Symbol * classSym;
3145
3146 if(!dataMember->dataType)
3147 dataMember->dataType = ProcessTypeString(dataMember->dataTypeString, 0x0);
3148 classSym = (dataMember->dataType && dataMember->dataType->kind == 8) ? dataMember->dataType->__anon1._class : (((void *)0));
3149 if(classSym && classSym->__anon1.registered && classSym->__anon1.registered->type == 1)
3150 {
3151 struct __ecereNameSpace__ecere__sys__OldList * subList = MkList();
3152 struct Specifier * spec = _MkSpecifierName(dataMember->dataTypeString, classSym, (((void *)0)));
3153 struct Instantiation * inst = MkInstantiation(spec, (((void *)0)), (((void *)0)));
3154
3155 ProcessBracketInst(inst, subList);
3156 FreeInstance(inst);
3157 ListAdd(list, MkInitializerList(subList));
3158 }
3159 else if(dataMember->dataType->kind == 12)
3160 ListAdd(list, MkInitializerList(MkListOne(MkInitializerAssignment(MkExpConstant("0")))));
3161 else
3162 ListAdd(list, MkInitializerAssignment(MkExpConstant("0")));
3163 }
3164 }
3165 }
3166 }
3167 if(inst->members && (*inst->members).first)
3168 {
3169 struct MembersInit * members;
3170 struct MemberInit * member = (((void *)0));
3171
3172 for(members = (*inst->members).first; members; members = members->next)
3173 {
3174 if(members->type == 0)
3175 {
3176 for(member = (*members->__anon1.dataMembers).first; member; member = member->next)
3177 {
3178 if(member->takeOutExp)
3179 {
3180 FreeInitializer(member->initializer);
3181 member->initializer = (((void *)0));
3182 }
3183 }
3184 }
3185 }
3186 }
3187 recursionCount--;
3188 return 0x1;
3189 }
3190
3191 static void ProcessDeclaration(struct Declaration * decl)
3192 {
3193 yylloc = decl->loc;
3194 switch(decl->type)
3195 {
3196 case 1:
3197 {
3198 if(!curDecl)
3199 {
3200 curDecl = decl;
3201 declTempCount = 0;
3202 }
3203 if(decl->__anon1.__anon1.specifiers)
3204 {
3205 struct Specifier * s;
3206
3207 for(s = (*decl->__anon1.__anon1.specifiers).first; s; s = s->next)
3208 {
3209 ProcessSpecifier(s);
3210 }
3211 }
3212 if(decl->__anon1.__anon1.declarators)
3213 {
3214 struct InitDeclarator * d;
3215
3216 for(d = (*decl->__anon1.__anon1.declarators).first; d; d = d->next)
3217 {
3218 if(d->initializer)
3219 ProcessInitializer(d->initializer);
3220 }
3221 }
3222 if(curDecl == decl)
3223 {
3224 curDecl = (((void *)0));
3225 declTempCount = 0;
3226 }
3227 break;
3228 }
3229 case 2:
3230 {
3231 struct Instantiation * inst = decl->__anon1.inst;
3232
3233 if(inCompiler)
3234 {
3235 struct Symbol * classSym = inst->_class->__anon1.__anon1.symbol;
3236
3237 if(!curCompound)
3238 {
3239 struct Statement * stmt;
3240
3241 if(!inst->isConstant || (classSym && classSym->__anon1.registered && (classSym->__anon1.registered->type == 0 || classSym->__anon1.registered->type == 5)))
3242 {
3243 decl->type = 1;
3244 decl->__anon1.__anon1.specifiers = MkListOne(MkSpecifierName(inst->_class->__anon1.__anon1.name));
3245 if(decl->declMode == 3)
3246 {
3247 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Insert((&*decl->__anon1.__anon1.specifiers), (((void *)0)), MkSpecifier(STATIC));
3248 }
3249 decl->__anon1.__anon1.declarators = MkListOne(MkInitDeclarator(MkDeclaratorIdentifier(MkIdentifier(inst->exp->__anon1.__anon1.identifier->string)), (((void *)0))));
3250 ProcessDeclaration(decl);
3251 CreateInstancesBody();
3252 {
3253 struct Expression * exp = MkExpInstance(inst);
3254
3255 stmt = MkExpressionStmt(MkListOne(exp));
3256 ListAdd(createInstancesBody->__anon1.compound.statements, stmt);
3257 ProcessExpressionType(exp);
3258 }
3259 if(classSym && classSym->__anon1.registered && (classSym->__anon1.registered->type == 0))
3260 {
3261 ListAdd(createInstancesBody->__anon1.compound.statements, MkExpressionStmt(MkListOne(MkExpCall(MkExpIdentifier(MkIdentifier("ecere::com::eInstance_IncRef")), MkListOne(CopyExpression(inst->exp))))));
3262 {
3263 struct Expression * exp = MkExpOp((((void *)0)), DELETE, CopyExpression(inst->exp));
3264
3265 ListAdd(destroyInstancesBody->__anon1.compound.statements, MkExpressionStmt(MkListOne(exp)));
3266 ProcessExpressionType(exp);
3267 }
3268 }
3269 else if(classSym && classSym->__anon1.registered && (classSym->__anon1.registered->type == 5))
3270 {
3271 struct Expression * exp = MkExpOp((((void *)0)), DELETE, CopyExpression(inst->exp));
3272
3273 ListAdd(destroyInstancesBody->__anon1.compound.statements, MkExpressionStmt(MkListOne(exp)));
3274 ProcessExpressionType(exp);
3275 }
3276 break;
3277 }
3278 else
3279 {
3280 CreateInstancesBody();
3281 }
3282 }
3283 {
3284 char className[1024];
3285
3286 className[0] = (char)0;
3287 decl->type = 1;
3288 decl->__anon1.__anon1.specifiers = MkList();
3289 decl->__anon1.__anon1.declarators = MkList();
3290 if(classSym && classSym->__anon1.registered && classSym->__anon1.registered->type == 2)
3291 {
3292 struct __ecereNameSpace__ecere__sys__OldList list =
3293 {
3294 0
3295 };
3296
3297 ProcessInstMembers(inst, inst->exp, &list, 0x0);
3298 ProcessExpression(inst->exp);
3299 ListAdd(decl->__anon1.__anon1.specifiers, MkSpecifierName(inst->_class->__anon1.__anon1.name));
3300 ListAdd(decl->__anon1.__anon1.declarators, MkInitDeclarator(MkDeclaratorIdentifier(inst->exp->__anon1.__anon1.identifier), MkInitializerAssignment(list.first)));
3301 inst->exp->__anon1.__anon1.identifier = (((void *)0));
3302 }
3303 else if(classSym && classSym->__anon1.registered && classSym->__anon1.registered->type == 3)
3304 {
3305 struct __ecereNameSpace__ecere__sys__OldList list =
3306 {
3307 0
3308 };
3309
3310 ProcessInstMembers(inst, inst->exp, &list, 0x0);
3311 ProcessExpression(inst->exp);
3312 ListAdd(decl->__anon1.__anon1.specifiers, MkSpecifierName(inst->_class->__anon1.__anon1.name));
3313 ListAdd(decl->__anon1.__anon1.declarators, MkInitDeclarator(MkDeclaratorIdentifier(inst->exp->__anon1.__anon1.identifier), MkInitializerAssignment(list.first)));
3314 inst->exp->__anon1.__anon1.identifier = (((void *)0));
3315 }
3316 else if(classSym && classSym->__anon1.registered && classSym->__anon1.registered->type == 1)
3317 {
3318 struct Expression * exp;
3319
3320 DeclareStruct(inst->_class->__anon1.__anon1.name, 0x0);
3321 ProcessExpression(inst->exp);
3322 {
3323 if(inst->fullSet)
3324 {
3325 ListAdd(decl->__anon1.__anon1.specifiers, MkSpecifierName(inst->_class->__anon1.__anon1.name));
3326 ListAdd(decl->__anon1.__anon1.declarators, MkInitDeclarator(MkDeclaratorIdentifier(inst->exp->__anon1.__anon1.identifier), (((void *)0))));
3327 inst->exp->__anon1.__anon1.identifier = (((void *)0));
3328 }
3329 else
3330 {
3331 struct __ecereNameSpace__ecere__sys__OldList * list = MkList();
3332
3333 if(ProcessBracketInst(inst, list))
3334 {
3335 ListAdd(decl->__anon1.__anon1.specifiers, MkSpecifierName(inst->_class->__anon1.__anon1.name));
3336 ListAdd(decl->__anon1.__anon1.declarators, MkInitDeclarator(MkDeclaratorIdentifier(inst->exp->__anon1.__anon1.identifier), MkInitializerList(list)));
3337 inst->exp->__anon1.__anon1.identifier = (((void *)0));
3338 }
3339 else
3340 {
3341 FreeList(list, FreeInitializer);
3342 exp = MkExpBrackets(MkList());
3343 ProcessInstMembers(inst, inst->exp, exp->__anon1.list, 0x1);
3344 ListAdd(exp->__anon1.list, CopyExpression(inst->exp));
3345 ListAdd(decl->__anon1.__anon1.specifiers, MkSpecifierName(inst->_class->__anon1.__anon1.name));
3346 ListAdd(decl->__anon1.__anon1.declarators, MkInitDeclarator(MkDeclaratorIdentifier(inst->exp->__anon1.__anon1.identifier), MkInitializerAssignment(exp)));
3347 inst->exp->__anon1.__anon1.identifier = (((void *)0));
3348 }
3349 }
3350 }
3351 }
3352 else
3353 {
3354 struct Expression * newCall;
3355
3356 strcpy(className, "__ecereClass_");
3357 if(classSym && classSym->__anon1.registered && classSym->__anon1.registered->type == 5 && classSym->__anon1.registered->templateClass)
3358 {
3359 classSym = FindClass(classSym->__anon1.registered->templateClass->fullName);
3360 FullClassNameCat(className, classSym->string, 0x1);
3361 }
3362 else
3363 FullClassNameCat(className, inst->_class->__anon1.__anon1.name, 0x1);
3364 MangleClassName(className);
3365 if(classSym)
3366 DeclareClass(classSym, className);
3367 if(classSym && classSym->__anon1.registered && classSym->__anon1.registered->type == 5 && (classSym->__anon1.registered->templateClass ? classSym->__anon1.registered->templateClass->fixed : classSym->__anon1.registered->fixed))
3368 {
3369 char size[256];
3370
3371 sprintf(size, "%d", classSym->__anon1.registered->templateClass ? classSym->__anon1.registered->templateClass->structSize : classSym->__anon1.registered->structSize);
3372 newCall = MkExpCall(QMkExpId("ecere::com::eSystem_New0"), MkListOne(MkExpConstant(size)));
3373 }
3374 else
3375 {
3376 newCall = MkExpCall(QMkExpId("ecere::com::eInstance_New"), MkListOne(QMkExpId(className)));
3377 ProcessExpressionType(newCall);
3378 newCall->byReference = 0x1;
3379 }
3380 if(inst->exp)
3381 {
3382 struct Expression * exp, * newExp;
3383 struct Identifier * id = CopyIdentifier(inst->exp->__anon1.__anon1.identifier);
3384
3385 if(inst->members && (*inst->members).first)
3386 {
3387 newExp = MkExpOp(CopyExpression(inst->exp), '=', newCall);
3388 exp = MkExpBrackets(MkList());
3389 ListAdd(exp->__anon1.list, newExp);
3390 ProcessInstMembers(inst, inst->exp, exp->__anon1.list, 0x0);
3391 ListAdd(exp->__anon1.list, inst->exp);
3392 ProcessExpression(inst->exp);
3393 inst->exp = (((void *)0));
3394 }
3395 else
3396 exp = newCall;
3397 ListAdd(decl->__anon1.__anon1.specifiers, MkSpecifierName(inst->_class->__anon1.__anon1.name));
3398 ListAdd(decl->__anon1.__anon1.declarators, MkInitDeclarator(MkDeclaratorIdentifier(id), MkInitializerAssignment(exp)));
3399 }
3400 else
3401 FreeExpression(newCall);
3402 }
3403 }
3404 FreeInstance(inst);
3405 }
3406 else
3407 ProcessInstantiation(inst);
3408 break;
3409 }
3410 case 0:
3411 {
3412 if(decl->__anon1.__anon1.specifiers)
3413 {
3414 struct Specifier * spec;
3415
3416 for(spec = (*decl->__anon1.__anon1.specifiers).first; spec; spec = spec->next)
3417 ProcessSpecifier(spec);
3418 }
3419 break;
3420 }
3421 }
3422 }
3423
3424 static void ProcessStatement(struct Statement * stmt)
3425 {
3426 yylloc = stmt->loc;
3427 switch(stmt->type)
3428 {
3429 case 0:
3430 if(stmt->__anon1.labeled.stmt)
3431 ProcessStatement(stmt->__anon1.labeled.stmt);
3432 break;
3433 case 1:
3434 if(stmt->__anon1.caseStmt.exp)
3435 ProcessExpression(stmt->__anon1.caseStmt.exp);
3436 if(stmt->__anon1.caseStmt.stmt)
3437 ProcessStatement(stmt->__anon1.caseStmt.stmt);
3438 break;
3439 case 2:
3440 {
3441 if(stmt->__anon1.compound.context)
3442 {
3443 struct Declaration * decl;
3444 struct Statement * s;
3445 struct Statement * prevCompound = curCompound;
3446 struct Context * prevContext = curContext;
3447
3448 if(!stmt->__anon1.compound.isSwitch)
3449 {
3450 curCompound = stmt;
3451 curContext = stmt->__anon1.compound.context;
3452 }
3453 if(stmt->__anon1.compound.declarations)
3454 {
3455 for(decl = (*stmt->__anon1.compound.declarations).first; decl; decl = decl->next)
3456 ProcessDeclaration(decl);
3457 }
3458 if(stmt->__anon1.compound.statements)
3459 {
3460 for(s = (*stmt->__anon1.compound.statements).first; s; s = s->next)
3461 {
3462 ProcessStatement(s);
3463 }
3464 }
3465 curCompound = prevCompound;
3466 curContext = prevContext;
3467 }
3468 break;
3469 }
3470 case 3:
3471 {
3472 struct Expression * exp;
3473
3474 if(stmt->__anon1.expressions)
3475 {
3476 for(exp = (*stmt->__anon1.expressions).first; exp; exp = exp->next)
3477 {
3478 ProcessExpression(exp);
3479 }
3480 }
3481 break;
3482 }
3483 case 4:
3484 {
3485 struct Expression * exp;
3486
3487 ((struct Expression *)(*stmt->__anon1.ifStmt.exp).last)->usage = (((struct Expression *)(*stmt->__anon1.ifStmt.exp).last)->usage & ~0x1) | (((unsigned int)(0x1)) << 0);
3488 for(exp = (*stmt->__anon1.ifStmt.exp).first; exp; exp = exp->next)
3489 {
3490 ProcessExpression(exp);
3491 }
3492 if(stmt->__anon1.ifStmt.stmt)
3493 ProcessStatement(stmt->__anon1.ifStmt.stmt);
3494 if(stmt->__anon1.ifStmt.elseStmt)
3495 ProcessStatement(stmt->__anon1.ifStmt.elseStmt);
3496 break;
3497 }
3498 case 5:
3499 {
3500 struct Expression * exp;
3501
3502 ((struct Expression *)(*stmt->__anon1.switchStmt.exp).last)->usage = (((struct Expression *)(*stmt->__anon1.switchStmt.exp).last)->usage & ~0x1) | (((unsigned int)(0x1)) << 0);
3503 for(exp = (*stmt->__anon1.switchStmt.exp).first; exp; exp = exp->next)
3504 ProcessExpression(exp);
3505 ProcessStatement(stmt->__anon1.switchStmt.stmt);
3506 break;
3507 }
3508 case 6:
3509 {
3510 if(stmt->__anon1.whileStmt.exp)
3511 {
3512 struct Expression * exp;
3513
3514 ((struct Expression *)(*stmt->__anon1.whileStmt.exp).last)->usage = (((struct Expression *)(*stmt->__anon1.whileStmt.exp).last)->usage & ~0x1) | (((unsigned int)(0x1)) << 0);
3515 for(exp = (*stmt->__anon1.whileStmt.exp).first; exp; exp = exp->next)
3516 {
3517 ProcessExpression(exp);
3518 }
3519 }
3520 if(stmt->__anon1.whileStmt.stmt)
3521 ProcessStatement(stmt->__anon1.whileStmt.stmt);
3522 break;
3523 }
3524 case 7:
3525 {
3526 if(stmt->__anon1.doWhile.exp)
3527 {
3528 struct Expression * exp;
3529
3530 ((struct Expression *)(*stmt->__anon1.doWhile.exp).last)->usage = (((struct Expression *)(*stmt->__anon1.doWhile.exp).last)->usage & ~0x1) | (((unsigned int)(0x1)) << 0);
3531 for(exp = (*stmt->__anon1.doWhile.exp).first; exp; exp = exp->next)
3532 {
3533 ProcessExpression(exp);
3534 }
3535 }
3536 if(stmt->__anon1.doWhile.stmt)
3537 ProcessStatement(stmt->__anon1.doWhile.stmt);
3538 break;
3539 }
3540 case 8:
3541 {
3542 struct Expression * exp;
3543
3544 if(stmt->__anon1.forStmt.init)
3545 ProcessStatement(stmt->__anon1.forStmt.init);
3546 if(stmt->__anon1.forStmt.check && stmt->__anon1.forStmt.check->__anon1.expressions)
3547 {
3548 ((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);
3549 }
3550 if(stmt->__anon1.forStmt.check)
3551 ProcessStatement(stmt->__anon1.forStmt.check);
3552 if(stmt->__anon1.forStmt.increment)
3553 {
3554 for(exp = (*stmt->__anon1.forStmt.increment).first; exp; exp = exp->next)
3555 ProcessExpression(exp);
3556 }
3557 if(stmt->__anon1.forStmt.stmt)
3558 ProcessStatement(stmt->__anon1.forStmt.stmt);
3559 break;
3560 }
3561 case 9:
3562 break;
3563 case 10:
3564 break;
3565 case 11:
3566 break;
3567 case 12:
3568 {
3569 struct Expression * exp;
3570
3571 if(stmt->__anon1.expressions && (*stmt->__anon1.expressions).last)
3572 {
3573 ((struct Expression *)(*stmt->__anon1.expressions).last)->usage = (((struct Expression *)(*stmt->__anon1.expressions).last)->usage & ~0x1) | (((unsigned int)(0x1)) << 0);
3574 for(exp = (*stmt->__anon1.expressions).first; exp; exp = exp->next)
3575 {
3576 ProcessExpression(exp);
3577 }
3578 }
3579 break;
3580 }
3581 case 14:
3582 {
3583 ProcessDeclaration(stmt->__anon1.decl);
3584 break;
3585 }
3586 case 13:
3587 {
3588 struct AsmField * field;
3589
3590 if(stmt->__anon1.asmStmt.inputFields)
3591 {
3592 for(field = (*stmt->__anon1.asmStmt.inputFields).first; field; field = field->next)
3593 if(field->expression)
3594 ProcessExpression(field->expression);
3595 }
3596 if(stmt->__anon1.asmStmt.outputFields)
3597 {
3598 for(field = (*stmt->__anon1.asmStmt.outputFields).first; field; field = field->next)
3599 if(field->expression)
3600 ProcessExpression(field->expression);
3601 }
3602 if(stmt->__anon1.asmStmt.clobberedFields)
3603 {
3604 for(field = (*stmt->__anon1.asmStmt.clobberedFields).first; field; field = field->next)
3605 if(field->expression)
3606 ProcessExpression(field->expression);
3607 }
3608 break;
3609 }
3610 }
3611 }
3612
3613 static void ProcessFunction(struct FunctionDefinition * function)
3614 {
3615 if(function->body)
3616 {
3617 yylloc = function->loc;
3618 ProcessStatement(function->body);
3619 }
3620 }
3621
3622 extern struct Type * MkClassTypeSymbol(struct Symbol * symbol);
3623
3624 extern void FreeSymbol(struct Symbol * symbol);
3625
3626 unsigned int __ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_Add(struct __ecereNameSpace__ecere__sys__BinaryTree * this, struct __ecereNameSpace__ecere__sys__BTNode * node);
3627
3628 void __ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_Remove(struct __ecereNameSpace__ecere__sys__BinaryTree * this, struct __ecereNameSpace__ecere__sys__BTNode * node);
3629
3630 void ProcessInstantiations()
3631 {
3632 struct External * external;
3633
3634 for(external = (*ast).first; external; external = external->next)
3635 {
3636 curExternal = external;
3637 if(external->type == 1)
3638 {
3639 if(external->__anon1.declaration)
3640 ProcessDeclaration(external->__anon1.declaration);
3641 }
3642 else if(external->type == 0)
3643 {
3644 ProcessFunction(external->__anon1.function);
3645 }
3646 else if(external->type == 2)
3647 {
3648 struct ClassDefinition * _class = external->__anon1._class;
3649
3650 if(_class->definitions)
3651 {
3652 struct ClassDef * def;
3653
3654 for(def = (*_class->definitions).first; def; def = def->next)
3655 {
3656 if(def->type == 0)
3657 {
3658 curExternal = def->__anon1.function->declarator ? def->__anon1.function->declarator->symbol->__anon2.__anon1.pointerExternal : external;
3659 ProcessFunction((struct FunctionDefinition *)def->__anon1.function);
3660 }
3661 else if(def->type == 2 && def->__anon1.decl->type == 2)
3662 {
3663 ProcessInstantiation(def->__anon1.decl->__anon1.inst);
3664 }
3665 else if(def->type == 1 && def->__anon1.defProperties)
3666 {
3667 struct MemberInit * defProperty;
3668 struct Symbol * thisSymbol = (thisSymbol = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass_Symbol), thisSymbol->string = __ecereNameSpace__ecere__sys__CopyString("this"), thisSymbol->type = MkClassTypeSymbol(_class->symbol), thisSymbol);
3669
3670 __ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_Add(&globalContext->symbols, (struct __ecereNameSpace__ecere__sys__BTNode *)thisSymbol);
3671 for(defProperty = (*def->__anon1.defProperties).first; defProperty; defProperty = defProperty->next)
3672 {
3673 ProcessMemberInitData(defProperty);
3674 }
3675 __ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_Remove(&globalContext->symbols, (struct __ecereNameSpace__ecere__sys__BTNode *)thisSymbol);
3676 FreeSymbol(thisSymbol);
3677 }
3678 else if(def->type == 3 && def->__anon1.propertyDef)
3679 {
3680 struct PropertyDef * prop = def->__anon1.propertyDef;
3681 struct Symbol * thisSymbol = (thisSymbol = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass_Symbol), thisSymbol->string = __ecereNameSpace__ecere__sys__CopyString("this"), thisSymbol->type = MkClassTypeSymbol(_class->symbol), thisSymbol);
3682
3683 __ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_Add(&globalContext->symbols, (struct __ecereNameSpace__ecere__sys__BTNode *)thisSymbol);
3684 if(prop->setStmt)
3685 {
3686 curExternal = prop->symbol ? prop->symbol->__anon2.__anon2.externalSet : (((void *)0));
3687 ProcessStatement(prop->setStmt);
3688 }
3689 if(prop->getStmt)
3690 {
3691 curExternal = prop->symbol ? prop->symbol->__anon2.__anon2.externalGet : (((void *)0));
3692 ProcessStatement(prop->getStmt);
3693 }
3694 if(prop->issetStmt)
3695 {
3696 curExternal = prop->symbol ? prop->symbol->__anon2.__anon2.externalIsSet : (((void *)0));
3697 ProcessStatement(prop->issetStmt);
3698 }
3699 __ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_Remove(&globalContext->symbols, (struct __ecereNameSpace__ecere__sys__BTNode *)thisSymbol);
3700 FreeSymbol(thisSymbol);
3701 }
3702 else if(def->type == 4 && def->__anon1.propertyWatch)
3703 {
3704 struct PropertyWatch * propertyWatch = def->__anon1.propertyWatch;
3705 struct Symbol * thisSymbol = (thisSymbol = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass_Symbol), thisSymbol->string = __ecereNameSpace__ecere__sys__CopyString("this"), thisSymbol->type = MkClassTypeSymbol(_class->symbol), thisSymbol);
3706
3707 __ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_Add(&globalContext->symbols, (struct __ecereNameSpace__ecere__sys__BTNode *)thisSymbol);
3708 if(propertyWatch->compound)
3709 {
3710 __ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_Add(&propertyWatch->compound->__anon1.compound.context->symbols, (struct __ecereNameSpace__ecere__sys__BTNode *)thisSymbol);
3711 curExternal = (((void *)0));
3712 ProcessStatement(propertyWatch->compound);
3713 }
3714 __ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_Remove(&globalContext->symbols, (struct __ecereNameSpace__ecere__sys__BTNode *)thisSymbol);
3715 FreeSymbol(thisSymbol);
3716 }
3717 }
3718 }
3719 }
3720 }
3721 }
3722
3723 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass___ecereNameSpace__ecere__com__GlobalFunction;
3724
3725 struct __ecereNameSpace__ecere__com__GlobalFunction;
3726
3727 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);
3728
3729 void __ecereRegisterModule_pass16(struct __ecereNameSpace__ecere__com__Instance * module)
3730 {
3731 struct __ecereNameSpace__ecere__com__Class * class;
3732
3733 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("DeclareClass", "void DeclareClass(Symbol classSym, const char * className)", DeclareClass, module, 1);
3734 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("ProcessExpressionInstPass", "void ProcessExpressionInstPass(Expression exp)", ProcessExpressionInstPass, module, 2);
3735 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("ProcessInstantiations", "void ProcessInstantiations(void)", ProcessInstantiations, module, 1);
3736 }
3737
3738 void __ecereUnregisterModule_pass16(struct __ecereNameSpace__ecere__com__Instance * module)
3739 {
3740
3741 }
3742