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