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