The Ecere SDK - sdk/blob - compiler/bootstrap/libec/bootstrap/pass16.c

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