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

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