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