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