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