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

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