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