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