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