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

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