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