The Ecere SDK - sdk/blob - compiler/bootstrap/ecp/bootstrap/ecp.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
  33 #if /*defined(_W64) || */(defined(__WORDSIZE) && __WORDSIZE == 8) || defined(__x86_64__)
  34 #define _64BIT 1
  35 #else
  36 #define _64BIT 0
  37 #endif
  38
  39 #define arch_PointerSize                  sizeof(void *)
  40 #define structSize_Instance               (_64BIT ? 24 : 12)
  41 #define structSize_Module                 (_64BIT ? 560 : 300)
  42 #define structSize_OldList                (_64BIT ? 32 : 20)
  43
  44 extern void *  __ecereNameSpace__ecere__com__eSystem_New(unsigned int size);
  45
  46 extern void *  __ecereNameSpace__ecere__com__eSystem_New0(unsigned int size);
  47
  48 extern void *  __ecereNameSpace__ecere__com__eSystem_Renew(void *  memory, unsigned int size);
  49
  50 extern void *  __ecereNameSpace__ecere__com__eSystem_Renew0(void *  memory, unsigned int size);
  51
  52 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass___ecereNameSpace__ecere__sys__BTNode;
  53
  54 struct __ecereNameSpace__ecere__sys__BTNode;
  55
  56 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass___ecereNameSpace__ecere__sys__BinaryTree;
  57
  58 struct __ecereNameSpace__ecere__sys__BinaryTree
  59 {
  60 struct __ecereNameSpace__ecere__sys__BTNode * root;
  61 int count;
  62 int (*  CompareKey)(struct __ecereNameSpace__ecere__sys__BinaryTree * tree, uintptr_t a, uintptr_t b);
  63 void (*  FreeKey)(void *  key);
  64 } __attribute__ ((gcc_struct));
  65
  66 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass___ecereNameSpace__ecere__sys__OldList;
  67
  68 struct __ecereNameSpace__ecere__sys__OldList
  69 {
  70 void *  first;
  71 void *  last;
  72 int count;
  73 unsigned int offset;
  74 unsigned int circ;
  75 } __attribute__ ((gcc_struct));
  76
  77 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass___ecereNameSpace__ecere__com__Method;
  78
  79 struct __ecereNameSpace__ecere__com__Method
  80 {
  81 char *  name;
  82 struct __ecereNameSpace__ecere__com__Method * parent;
  83 struct __ecereNameSpace__ecere__com__Method * left;
  84 struct __ecereNameSpace__ecere__com__Method * right;
  85 int depth;
  86 int (*  function)();
  87 int vid;
  88 int type;
  89 struct __ecereNameSpace__ecere__com__Class * _class;
  90 void *  symbol;
  91 char *  dataTypeString;
  92 struct Type * dataType;
  93 int memberAccess;
  94 } __attribute__ ((gcc_struct));
  95
  96 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass___ecereNameSpace__ecere__com__Property;
  97
  98 struct __ecereNameSpace__ecere__com__Property
  99 {
 100 struct __ecereNameSpace__ecere__com__Property * prev;
 101 struct __ecereNameSpace__ecere__com__Property * next;
 102 char *  name;
 103 unsigned int isProperty;
 104 int memberAccess;
 105 int id;
 106 struct __ecereNameSpace__ecere__com__Class * _class;
 107 char *  dataTypeString;
 108 struct __ecereNameSpace__ecere__com__Class * dataTypeClass;
 109 struct Type * dataType;
 110 void (*  Set)(void * , int);
 111 int (*  Get)(void * );
 112 unsigned int (*  IsSet)(void * );
 113 void *  data;
 114 void *  symbol;
 115 int vid;
 116 unsigned int conversion;
 117 unsigned int watcherOffset;
 118 char *  category;
 119 unsigned int compiled;
 120 unsigned int selfWatchable;
 121 unsigned int isWatchable;
 122 } __attribute__ ((gcc_struct));
 123
 124 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_CodePosition;
 125
 126 struct CodePosition
 127 {
 128 int line;
 129 int charPos;
 130 int pos;
 131 unsigned int included;
 132 } __attribute__ ((gcc_struct));
 133
 134 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_Location;
 135
 136 struct Location
 137 {
 138 struct CodePosition start;
 139 struct CodePosition end;
 140 } __attribute__ ((gcc_struct));
 141
 142 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_Attrib;
 143
 144 struct Attrib;
 145
 146 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_ExtDecl;
 147
 148 struct ExtDecl;
 149
 150 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_ClassDefinition;
 151
 152 struct ClassDefinition
 153 {
 154 struct ClassDefinition * prev;
 155 struct ClassDefinition * next;
 156 struct Location loc;
 157 struct Specifier * _class;
 158 struct __ecereNameSpace__ecere__sys__OldList *  baseSpecs;
 159 struct __ecereNameSpace__ecere__sys__OldList *  definitions;
 160 struct Symbol * symbol;
 161 struct Location blockStart;
 162 struct Location nameLoc;
 163 int endid;
 164 int declMode;
 165 unsigned int deleteWatchable;
 166 } __attribute__ ((gcc_struct));
 167
 168 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_Context;
 169
 170 struct Context
 171 {
 172 struct Context * parent;
 173 struct __ecereNameSpace__ecere__sys__BinaryTree types;
 174 struct __ecereNameSpace__ecere__sys__BinaryTree classes;
 175 struct __ecereNameSpace__ecere__sys__BinaryTree symbols;
 176 struct __ecereNameSpace__ecere__sys__BinaryTree structSymbols;
 177 int nextID;
 178 int simpleID;
 179 struct __ecereNameSpace__ecere__sys__BinaryTree templateTypes;
 180 struct ClassDefinition * classDef;
 181 unsigned int templateTypesOnly;
 182 unsigned int hasNameSpace;
 183 } __attribute__ ((gcc_struct));
 184
 185 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_Instantiation;
 186
 187 struct Instantiation
 188 {
 189 struct Instantiation * prev;
 190 struct Instantiation * next;
 191 struct Location loc;
 192 struct Specifier * _class;
 193 struct Expression * exp;
 194 struct __ecereNameSpace__ecere__sys__OldList *  members;
 195 struct Symbol * symbol;
 196 unsigned int fullSet;
 197 unsigned int isConstant;
 198 unsigned char *  data;
 199 struct Location nameLoc;
 200 struct Location insideLoc;
 201 unsigned int built;
 202 } __attribute__ ((gcc_struct));
 203
 204 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_Declaration;
 205
 206 struct Declaration
 207 {
 208 struct Declaration * prev;
 209 struct Declaration * next;
 210 struct Location loc;
 211 int type;
 212 union
 213 {
 214 struct
 215 {
 216 struct __ecereNameSpace__ecere__sys__OldList *  specifiers;
 217 struct __ecereNameSpace__ecere__sys__OldList *  declarators;
 218 } __attribute__ ((gcc_struct));
 219 struct Instantiation * inst;
 220 struct
 221 {
 222 struct Identifier * id;
 223 struct Expression * exp;
 224 } __attribute__ ((gcc_struct));
 225 } __attribute__ ((gcc_struct));
 226 struct Specifier * extStorage;
 227 struct Symbol * symbol;
 228 int declMode;
 229 } __attribute__ ((gcc_struct));
 230
 231 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_Statement;
 232
 233 struct Statement;
 234
 235 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_TypeName;
 236
 237 struct TypeName;
 238
 239 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_Initializer;
 240
 241 struct Initializer;
 242
 243 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass___ecereNameSpace__ecere__com__DataValue;
 244
 245 struct __ecereNameSpace__ecere__com__DataValue
 246 {
 247 union
 248 {
 249 char c;
 250 unsigned char uc;
 251 short s;
 252 unsigned short us;
 253 int i;
 254 unsigned int ui;
 255 void *  p;
 256 float f;
 257 double d;
 258 long long i64;
 259 uint64 ui64;
 260 } __attribute__ ((gcc_struct));
 261 } __attribute__ ((gcc_struct));
 262
 263 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_Expression;
 264
 265 struct Expression
 266 {
 267 struct Expression * prev;
 268 struct Expression * next;
 269 struct Location loc;
 270 int type;
 271 union
 272 {
 273 struct
 274 {
 275 char *  constant;
 276 struct Identifier * identifier;
 277 } __attribute__ ((gcc_struct));
 278 struct Statement * compound;
 279 struct Instantiation * instance;
 280 char *  string;
 281 struct __ecereNameSpace__ecere__sys__OldList *  list;
 282 struct
 283 {
 284 struct __ecereNameSpace__ecere__sys__OldList * specifiers;
 285 struct Declarator * decl;
 286 } __attribute__ ((gcc_struct)) _classExp;
 287 struct
 288 {
 289 struct Identifier * id;
 290 } __attribute__ ((gcc_struct)) classData;
 291 struct
 292 {
 293 struct Expression * exp;
 294 struct __ecereNameSpace__ecere__sys__OldList * arguments;
 295 struct Location argLoc;
 296 } __attribute__ ((gcc_struct)) call;
 297 struct
 298 {
 299 struct Expression * exp;
 300 struct __ecereNameSpace__ecere__sys__OldList * index;
 301 } __attribute__ ((gcc_struct)) index;
 302 struct
 303 {
 304 struct Expression * exp;
 305 struct Identifier * member;
 306 int memberType;
 307 unsigned int thisPtr;
 308 } __attribute__ ((gcc_struct)) member;
 309 struct
 310 {
 311 int op;
 312 struct Expression * exp1;
 313 struct Expression * exp2;
 314 } __attribute__ ((gcc_struct)) op;
 315 struct TypeName * typeName;
 316 struct Specifier * _class;
 317 struct
 318 {
 319 struct TypeName * typeName;
 320 struct Expression * exp;
 321 } __attribute__ ((gcc_struct)) cast;
 322 struct
 323 {
 324 struct Expression * cond;
 325 struct __ecereNameSpace__ecere__sys__OldList * exp;
 326 struct Expression * elseExp;
 327 } __attribute__ ((gcc_struct)) cond;
 328 struct
 329 {
 330 struct TypeName * typeName;
 331 struct Expression * size;
 332 } __attribute__ ((gcc_struct)) _new;
 333 struct
 334 {
 335 struct TypeName * typeName;
 336 struct Expression * size;
 337 struct Expression * exp;
 338 } __attribute__ ((gcc_struct)) _renew;
 339 struct
 340 {
 341 char * table;
 342 struct Identifier * id;
 343 } __attribute__ ((gcc_struct)) db;
 344 struct
 345 {
 346 struct Expression * ds;
 347 struct Expression * name;
 348 } __attribute__ ((gcc_struct)) dbopen;
 349 struct
 350 {
 351 struct TypeName * typeName;
 352 struct Initializer * initializer;
 353 } __attribute__ ((gcc_struct)) initializer;
 354 struct
 355 {
 356 struct Expression * exp;
 357 struct TypeName * typeName;
 358 } __attribute__ ((gcc_struct)) vaArg;
 359 } __attribute__ ((gcc_struct));
 360 unsigned int debugValue;
 361 struct __ecereNameSpace__ecere__com__DataValue val;
 362 uint64 address;
 363 unsigned int hasAddress;
 364 struct Type * expType;
 365 struct Type * destType;
 366 unsigned int usage;
 367 int tempCount;
 368 unsigned int byReference;
 369 unsigned int isConstant;
 370 unsigned int addedThis;
 371 unsigned int needCast;
 372 unsigned int thisPtr;
 373 } __attribute__ ((gcc_struct));
 374
 375 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_TemplateDatatype;
 376
 377 struct TemplateDatatype
 378 {
 379 struct __ecereNameSpace__ecere__sys__OldList *  specifiers;
 380 struct Declarator * decl;
 381 } __attribute__ ((gcc_struct));
 382
 383 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_TemplateArgument;
 384
 385 struct TemplateArgument
 386 {
 387 struct TemplateArgument * prev;
 388 struct TemplateArgument * next;
 389 struct Location loc;
 390 struct Identifier * name;
 391 int type;
 392 union
 393 {
 394 struct Expression * expression;
 395 struct Identifier * identifier;
 396 struct TemplateDatatype * templateDatatype;
 397 } __attribute__ ((gcc_struct));
 398 } __attribute__ ((gcc_struct));
 399
 400 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_TemplateParameter;
 401
 402 struct TemplateParameter
 403 {
 404 struct TemplateParameter * prev;
 405 struct TemplateParameter * next;
 406 struct Location loc;
 407 int type;
 408 struct Identifier * identifier;
 409 union
 410 {
 411 struct TemplateDatatype * dataType;
 412 int memberType;
 413 } __attribute__ ((gcc_struct));
 414 struct TemplateArgument * defaultArgument;
 415 char *  dataTypeString;
 416 struct Type * baseType;
 417 } __attribute__ ((gcc_struct));
 418
 419 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_Specifier;
 420
 421 struct Specifier
 422 {
 423 struct Specifier * prev;
 424 struct Specifier * next;
 425 struct Location loc;
 426 int type;
 427 union
 428 {
 429 int specifier;
 430 struct
 431 {
 432 struct ExtDecl * extDecl;
 433 char *  name;
 434 struct Symbol * symbol;
 435 struct __ecereNameSpace__ecere__sys__OldList *  templateArgs;
 436 } __attribute__ ((gcc_struct));
 437 struct
 438 {
 439 struct Identifier * id;
 440 struct __ecereNameSpace__ecere__sys__OldList *  list;
 441 struct __ecereNameSpace__ecere__sys__OldList *  baseSpecs;
 442 struct __ecereNameSpace__ecere__sys__OldList *  definitions;
 443 unsigned int addNameSpace;
 444 struct Context * ctx;
 445 struct ExtDecl * extDeclStruct;
 446 } __attribute__ ((gcc_struct));
 447 struct Expression * expression;
 448 struct Specifier * _class;
 449 struct TemplateParameter * templateParameter;
 450 } __attribute__ ((gcc_struct));
 451 } __attribute__ ((gcc_struct));
 452
 453 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_Identifier;
 454
 455 struct Identifier
 456 {
 457 struct Identifier * prev;
 458 struct Identifier * next;
 459 struct Location loc;
 460 struct Symbol * classSym;
 461 struct Specifier * _class;
 462 char *  string;
 463 struct Identifier * badID;
 464 } __attribute__ ((gcc_struct));
 465
 466 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_Declarator;
 467
 468 struct Declarator
 469 {
 470 struct Declarator * prev;
 471 struct Declarator * next;
 472 struct Location loc;
 473 int type;
 474 struct Symbol * symbol;
 475 struct Declarator * declarator;
 476 union
 477 {
 478 struct Identifier * identifier;
 479 struct
 480 {
 481 struct Expression * exp;
 482 struct Expression * posExp;
 483 struct Attrib * attrib;
 484 } __attribute__ ((gcc_struct)) structDecl;
 485 struct
 486 {
 487 struct Expression * exp;
 488 struct Specifier * enumClass;
 489 } __attribute__ ((gcc_struct)) array;
 490 struct
 491 {
 492 struct __ecereNameSpace__ecere__sys__OldList * parameters;
 493 } __attribute__ ((gcc_struct)) function;
 494 struct
 495 {
 496 struct __ecereNameSpace__ecere__com__Instance * pointer;
 497 } __attribute__ ((gcc_struct)) pointer;
 498 struct
 499 {
 500 struct ExtDecl * extended;
 501 } __attribute__ ((gcc_struct)) extended;
 502 } __attribute__ ((gcc_struct));
 503 } __attribute__ ((gcc_struct));
 504
 505 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_FunctionDefinition;
 506
 507 struct FunctionDefinition
 508 {
 509 struct FunctionDefinition * prev;
 510 struct FunctionDefinition * next;
 511 struct Location loc;
 512 struct __ecereNameSpace__ecere__sys__OldList *  specifiers;
 513 struct Declarator * declarator;
 514 struct __ecereNameSpace__ecere__sys__OldList *  declarations;
 515 struct Statement * body;
 516 struct __ecereNameSpace__ecere__com__Class * _class;
 517 struct __ecereNameSpace__ecere__sys__OldList attached;
 518 int declMode;
 519 struct Type * type;
 520 struct Symbol * propSet;
 521 int tempCount;
 522 unsigned int propertyNoThis;
 523 } __attribute__ ((gcc_struct));
 524
 525 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_DBTableDef;
 526
 527 struct DBTableDef;
 528
 529 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_External;
 530
 531 struct External
 532 {
 533 struct External * prev;
 534 struct External * next;
 535 struct Location loc;
 536 int type;
 537 struct Symbol * symbol;
 538 union
 539 {
 540 struct FunctionDefinition * function;
 541 struct ClassDefinition * _class;
 542 struct Declaration * declaration;
 543 char *  importString;
 544 struct Identifier * id;
 545 struct DBTableDef * table;
 546 } __attribute__ ((gcc_struct));
 547 int importType;
 548 } __attribute__ ((gcc_struct));
 549
 550 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_ModuleImport;
 551
 552 struct ModuleImport;
 553
 554 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_ClassImport;
 555
 556 struct ClassImport;
 557
 558 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_Symbol;
 559
 560 struct Symbol
 561 {
 562 char *  string;
 563 struct Symbol * parent;
 564 struct Symbol * left;
 565 struct Symbol * right;
 566 int depth;
 567 struct Type * type;
 568 union
 569 {
 570 struct __ecereNameSpace__ecere__com__Method * method;
 571 struct __ecereNameSpace__ecere__com__Property * _property;
 572 struct __ecereNameSpace__ecere__com__Class * registered;
 573 } __attribute__ ((gcc_struct));
 574 int id;
 575 int idCode;
 576 union
 577 {
 578 struct
 579 {
 580 struct External * pointerExternal;
 581 struct External * structExternal;
 582 } __attribute__ ((gcc_struct));
 583 struct
 584 {
 585 struct External * externalGet;
 586 struct External * externalSet;
 587 struct External * externalPtr;
 588 struct External * externalIsSet;
 589 } __attribute__ ((gcc_struct));
 590 struct
 591 {
 592 struct External * methodExternal;
 593 struct External * methodCodeExternal;
 594 } __attribute__ ((gcc_struct));
 595 } __attribute__ ((gcc_struct));
 596 unsigned int imported;
 597 unsigned int declaredStructSym;
 598 struct __ecereNameSpace__ecere__com__Class * _class;
 599 unsigned int declaredStruct;
 600 unsigned int needConstructor;
 601 unsigned int needDestructor;
 602 char *  constructorName;
 603 char *  structName;
 604 char *  className;
 605 char *  destructorName;
 606 struct ModuleImport * module;
 607 struct ClassImport * _import;
 608 struct Location nameLoc;
 609 unsigned int isParam;
 610 unsigned int isRemote;
 611 unsigned int isStruct;
 612 unsigned int fireWatchersDone;
 613 int declaring;
 614 unsigned int classData;
 615 unsigned int isStatic;
 616 char *  shortName;
 617 struct __ecereNameSpace__ecere__sys__OldList *  templateParams;
 618 struct __ecereNameSpace__ecere__sys__OldList templatedClasses;
 619 struct Context * ctx;
 620 int isIterator;
 621 struct Expression * propCategory;
 622 } __attribute__ ((gcc_struct));
 623
 624 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_Type;
 625
 626 struct Type
 627 {
 628 struct Type * prev;
 629 struct Type * next;
 630 int refCount;
 631 union
 632 {
 633 struct Symbol * _class;
 634 struct
 635 {
 636 struct __ecereNameSpace__ecere__sys__OldList members;
 637 char *  enumName;
 638 } __attribute__ ((gcc_struct));
 639 struct
 640 {
 641 struct Type * returnType;
 642 struct __ecereNameSpace__ecere__sys__OldList params;
 643 struct Symbol * thisClass;
 644 unsigned int staticMethod;
 645 struct TemplateParameter * thisClassTemplate;
 646 } __attribute__ ((gcc_struct));
 647 struct
 648 {
 649 struct __ecereNameSpace__ecere__com__Method * method;
 650 struct __ecereNameSpace__ecere__com__Class * methodClass;
 651 struct __ecereNameSpace__ecere__com__Class * usedClass;
 652 } __attribute__ ((gcc_struct));
 653 struct
 654 {
 655 struct Type * arrayType;
 656 int arraySize;
 657 struct Expression * arraySizeExp;
 658 unsigned int freeExp;
 659 struct Symbol * enumClass;
 660 } __attribute__ ((gcc_struct));
 661 struct Type * type;
 662 struct TemplateParameter * templateParameter;
 663 } __attribute__ ((gcc_struct));
 664 int kind;
 665 unsigned int size;
 666 char *  name;
 667 char *  typeName;
 668 int classObjectType;
 669 int alignment;
 670 unsigned int offset;
 671 int bitFieldCount;
 672 int count;
 673 unsigned int isSigned : 1;
 674 unsigned int constant : 1;
 675 unsigned int truth : 1;
 676 unsigned int byReference : 1;
 677 unsigned int extraParam : 1;
 678 unsigned int directClassAccess : 1;
 679 unsigned int computing : 1;
 680 unsigned int keepCast : 1;
 681 unsigned int passAsTemplate : 1;
 682 unsigned int dllExport : 1;
 683 unsigned int attrStdcall : 1;
 684 } __attribute__ ((gcc_struct));
 685
 686 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass___ecereNameSpace__ecere__com__Class;
 687
 688 struct __ecereNameSpace__ecere__com__Class
 689 {
 690 struct __ecereNameSpace__ecere__com__Class * prev;
 691 struct __ecereNameSpace__ecere__com__Class * next;
 692 char *  name;
 693 int offset;
 694 int structSize;
 695 int (* *  _vTbl)();
 696 int vTblSize;
 697 int (*  Constructor)(struct __ecereNameSpace__ecere__com__Instance *);
 698 void (*  Destructor)(struct __ecereNameSpace__ecere__com__Instance *);
 699 int offsetClass;
 700 int sizeClass;
 701 struct __ecereNameSpace__ecere__com__Class * base;
 702 struct __ecereNameSpace__ecere__sys__BinaryTree methods;
 703 struct __ecereNameSpace__ecere__sys__BinaryTree members;
 704 struct __ecereNameSpace__ecere__sys__BinaryTree prop;
 705 struct __ecereNameSpace__ecere__sys__OldList membersAndProperties;
 706 struct __ecereNameSpace__ecere__sys__BinaryTree classProperties;
 707 struct __ecereNameSpace__ecere__sys__OldList derivatives;
 708 int memberID;
 709 int startMemberID;
 710 int type;
 711 struct __ecereNameSpace__ecere__com__Instance * module;
 712 struct __ecereNameSpace__ecere__com__NameSpace *  nameSpace;
 713 char *  dataTypeString;
 714 struct Type * dataType;
 715 int typeSize;
 716 int defaultAlignment;
 717 void (*  Initialize)();
 718 int memberOffset;
 719 struct __ecereNameSpace__ecere__sys__OldList selfWatchers;
 720 char *  designerClass;
 721 unsigned int noExpansion;
 722 char *  defaultProperty;
 723 unsigned int comRedefinition;
 724 int count;
 725 unsigned int isRemote;
 726 unsigned int internalDecl;
 727 void *  data;
 728 unsigned int computeSize;
 729 int structAlignment;
 730 int destructionWatchOffset;
 731 unsigned int fixed;
 732 struct __ecereNameSpace__ecere__sys__OldList delayedCPValues;
 733 int inheritanceAccess;
 734 char *  fullName;
 735 void *  symbol;
 736 struct __ecereNameSpace__ecere__sys__OldList conversions;
 737 struct __ecereNameSpace__ecere__sys__OldList templateParams;
 738 struct __ecereNameSpace__ecere__com__ClassTemplateArgument *  templateArgs;
 739 struct __ecereNameSpace__ecere__com__Class * templateClass;
 740 struct __ecereNameSpace__ecere__sys__OldList templatized;
 741 int numParams;
 742 unsigned int isInstanceClass;
 743 } __attribute__ ((gcc_struct));
 744
 745 extern long long __ecereNameSpace__ecere__com__eClass_GetProperty(struct __ecereNameSpace__ecere__com__Class * _class, char *  name);
 746
 747 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass___ecereNameSpace__ecere__com__Instance;
 748
 749 struct __ecereNameSpace__ecere__com__Instance
 750 {
 751 int (* *  _vTbl)();
 752 struct __ecereNameSpace__ecere__com__Class * _class;
 753 int _refCount;
 754 } __attribute__ ((gcc_struct));
 755
 756 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass___ecereNameSpace__ecere__com__DataMember;
 757
 758 struct __ecereNameSpace__ecere__com__DataMember
 759 {
 760 struct __ecereNameSpace__ecere__com__DataMember * prev;
 761 struct __ecereNameSpace__ecere__com__DataMember * next;
 762 char *  name;
 763 unsigned int isProperty;
 764 int memberAccess;
 765 int id;
 766 struct __ecereNameSpace__ecere__com__Class * _class;
 767 char *  dataTypeString;
 768 struct __ecereNameSpace__ecere__com__Class * dataTypeClass;
 769 struct Type * dataType;
 770 int type;
 771 int offset;
 772 int memberID;
 773 struct __ecereNameSpace__ecere__sys__OldList members;
 774 struct __ecereNameSpace__ecere__sys__BinaryTree membersAlpha;
 775 int memberOffset;
 776 int structAlignment;
 777 } __attribute__ ((gcc_struct));
 778
 779 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass___ecereNameSpace__ecere__com__SerialBuffer;
 780
 781 struct __ecereNameSpace__ecere__com__SerialBuffer
 782 {
 783 unsigned char *  _buffer;
 784 unsigned int count;
 785 unsigned int _size;
 786 unsigned int pos;
 787 } __attribute__ ((gcc_struct));
 788
 789 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass___ecereNameSpace__ecere__com__ClassTemplateArgument;
 790
 791 struct __ecereNameSpace__ecere__com__ClassTemplateArgument
 792 {
 793 union
 794 {
 795 struct
 796 {
 797 char *  dataTypeString;
 798 struct __ecereNameSpace__ecere__com__Class * dataTypeClass;
 799 } __attribute__ ((gcc_struct));
 800 struct __ecereNameSpace__ecere__com__DataValue expression;
 801 struct
 802 {
 803 char *  memberString;
 804 union
 805 {
 806 struct __ecereNameSpace__ecere__com__DataMember * member;
 807 struct __ecereNameSpace__ecere__com__Property * prop;
 808 struct __ecereNameSpace__ecere__com__Method * method;
 809 } __attribute__ ((gcc_struct));
 810 } __attribute__ ((gcc_struct));
 811 } __attribute__ ((gcc_struct));
 812 } __attribute__ ((gcc_struct));
 813
 814 enum yytokentype
 815 {
 816 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
 817 };
 818
 819 typedef union YYSTYPE
 820 {
 821 int specifierType;
 822 int i;
 823 int declMode;
 824 struct Identifier * id;
 825 struct Expression * exp;
 826 struct Specifier * specifier;
 827 struct __ecereNameSpace__ecere__sys__OldList * list;
 828 struct Enumerator * enumerator;
 829 struct Declarator * declarator;
 830 struct __ecereNameSpace__ecere__com__Instance * pointer;
 831 struct Initializer * initializer;
 832 struct InitDeclarator * initDeclarator;
 833 struct TypeName * typeName;
 834 struct Declaration * declaration;
 835 struct Statement * stmt;
 836 struct FunctionDefinition * function;
 837 struct External * external;
 838 struct Context * context;
 839 struct __ecereNameSpace__ecere__com__Instance * asmField;
 840 struct Attrib * attrib;
 841 struct ExtDecl * extDecl;
 842 struct Attribute * attribute;
 843 struct Instantiation * instance;
 844 struct MembersInit * membersInit;
 845 struct MemberInit * memberInit;
 846 struct ClassFunction * classFunction;
 847 struct ClassDefinition * _class;
 848 struct ClassDef * classDef;
 849 struct PropertyDef * prop;
 850 char * string;
 851 struct Symbol * symbol;
 852 struct PropertyWatch * propertyWatch;
 853 struct TemplateParameter * templateParameter;
 854 struct TemplateArgument * templateArgument;
 855 struct TemplateDatatype * templateDatatype;
 856 struct __ecereNameSpace__ecere__com__Instance * dbtableEntry;
 857 struct __ecereNameSpace__ecere__com__Instance * dbindexItem;
 858 struct DBTableDef * dbtableDef;
 859 } __attribute__ ((gcc_struct)) YYSTYPE;
 860
 861 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_Enumerator;
 862
 863 struct Enumerator
 864 {
 865 struct Enumerator * prev;
 866 struct Enumerator * next;
 867 struct Location loc;
 868 struct Identifier * id;
 869 struct Expression * exp;
 870 } __attribute__ ((gcc_struct));
 871
 872 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_InitDeclarator;
 873
 874 struct InitDeclarator
 875 {
 876 struct InitDeclarator * prev;
 877 struct InitDeclarator * next;
 878 struct Location loc;
 879 struct Declarator * declarator;
 880 struct Initializer * initializer;
 881 } __attribute__ ((gcc_struct));
 882
 883 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_Attribute;
 884
 885 struct Attribute;
 886
 887 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_ClassFunction;
 888
 889 struct ClassFunction
 890 {
 891 struct ClassFunction * prev;
 892 struct ClassFunction * next;
 893 struct Location loc;
 894 struct __ecereNameSpace__ecere__sys__OldList *  specifiers;
 895 struct Declarator * declarator;
 896 struct __ecereNameSpace__ecere__sys__OldList *  declarations;
 897 struct Statement * body;
 898 struct __ecereNameSpace__ecere__com__Class * _class;
 899 struct __ecereNameSpace__ecere__sys__OldList attached;
 900 int declMode;
 901 struct Type * type;
 902 struct Symbol * propSet;
 903 unsigned int isVirtual;
 904 unsigned int isConstructor;
 905 unsigned int isDestructor;
 906 unsigned int dontMangle;
 907 int id;
 908 int idCode;
 909 } __attribute__ ((gcc_struct));
 910
 911 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_MembersInit;
 912
 913 struct MembersInit;
 914
 915 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_MemberInit;
 916
 917 struct MemberInit;
 918
 919 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_PropertyDef;
 920
 921 struct PropertyDef
 922 {
 923 struct PropertyDef * prev;
 924 struct PropertyDef * next;
 925 struct Location loc;
 926 struct __ecereNameSpace__ecere__sys__OldList *  specifiers;
 927 struct Declarator * declarator;
 928 struct Identifier * id;
 929 struct Statement * getStmt;
 930 struct Statement * setStmt;
 931 struct Statement * issetStmt;
 932 struct Symbol * symbol;
 933 unsigned int conversion;
 934 unsigned int isWatchable;
 935 struct Expression * category;
 936 } __attribute__ ((gcc_struct));
 937
 938 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_PropertyWatch;
 939
 940 struct PropertyWatch;
 941
 942 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_ClassDef;
 943
 944 struct ClassDef
 945 {
 946 struct ClassDef * prev;
 947 struct ClassDef * next;
 948 struct Location loc;
 949 int type;
 950 union
 951 {
 952 struct Declaration * decl;
 953 struct ClassFunction * function;
 954 struct __ecereNameSpace__ecere__sys__OldList *  defProperties;
 955 struct PropertyDef * propertyDef;
 956 struct PropertyWatch * propertyWatch;
 957 char *  designer;
 958 struct Identifier * defaultProperty;
 959 struct
 960 {
 961 struct Identifier * id;
 962 struct Initializer * initializer;
 963 } __attribute__ ((gcc_struct));
 964 } __attribute__ ((gcc_struct));
 965 int memberAccess;
 966 void *  object;
 967 } __attribute__ ((gcc_struct));
 968
 969 extern YYSTYPE yylval;
 970
 971 extern struct Location yylloc;
 972
 973 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_Definition;
 974
 975 struct Definition
 976 {
 977 struct Definition * prev;
 978 struct Definition * next;
 979 char *  name;
 980 int type;
 981 } __attribute__ ((gcc_struct));
 982
 983 struct ClassDefine
 984 {
 985 struct Definition * prev;
 986 struct Definition * next;
 987 char *  name;
 988 int type;
 989 char * base;
 990 struct __ecereNameSpace__ecere__sys__OldList propertiesAndMembers;
 991 struct __ecereNameSpace__ecere__sys__OldList classProperties;
 992 struct __ecereNameSpace__ecere__sys__OldList methods;
 993 unsigned int isRemote;
 994 unsigned int isWatchable;
 995 unsigned int fixed;
 996 unsigned int isStatic;
 997 unsigned int noExpansion;
 998 } __attribute__ ((gcc_struct));
 999
1000 static struct __ecereNameSpace__ecere__com__Class * __ecereClass_ClassDefine;
1001
1002 struct Define
1003 {
1004 struct Definition * prev;
1005 struct Definition * next;
1006 char *  name;
1007 int type;
1008 struct Expression * exp;
1009 } __attribute__ ((gcc_struct));
1010
1011 static struct __ecereNameSpace__ecere__com__Class * __ecereClass_Define;
1012
1013 struct FunctionDefine
1014 {
1015 struct Definition * prev;
1016 struct Definition * next;
1017 char *  name;
1018 int type;
1019 char * dataType;
1020 } __attribute__ ((gcc_struct));
1021
1022 static struct __ecereNameSpace__ecere__com__Class * __ecereClass_FunctionDefine;
1023
1024 struct DataDefine
1025 {
1026 struct Definition * prev;
1027 struct Definition * next;
1028 char *  name;
1029 int type;
1030 char * dataType;
1031 } __attribute__ ((gcc_struct));
1032
1033 static struct __ecereNameSpace__ecere__com__Class * __ecereClass_DataDefine;
1034
1035 struct MethodDefine
1036 {
1037 struct MethodDefine * prev, * next;
1038 char * name;
1039 int memberAccess;
1040 char * type;
1041 unsigned int isVirtual;
1042 } __attribute__ ((gcc_struct));
1043
1044 static struct __ecereNameSpace__ecere__com__Class * __ecereClass_MethodDefine;
1045
1046 struct PropertyDefine
1047 {
1048 struct PropertyDefine * prev, * next;
1049 char * name;
1050 int isProperty;
1051 char * type;
1052 unsigned int isWatchable;
1053 int memberAccess;
1054 unsigned int isVirtual;
1055 unsigned int hasSet, hasGet;
1056 } __attribute__ ((gcc_struct));
1057
1058 static struct __ecereNameSpace__ecere__com__Class * __ecereClass_PropertyDefine;
1059
1060 struct DataMemberDefine
1061 {
1062 struct DataMemberDefine * prev, * next;
1063 char * name;
1064 int isProperty;
1065 char * type;
1066 struct __ecereNameSpace__ecere__sys__OldList dataMembers;
1067 struct __ecereNameSpace__ecere__sys__OldList classProperties;
1068 int memberAccess;
1069 int memberType;
1070 int size, bitPos;
1071 } __attribute__ ((gcc_struct));
1072
1073 static struct __ecereNameSpace__ecere__com__Class * __ecereClass_DataMemberDefine;
1074
1075 void FreeMethodDefine(struct MethodDefine * method)
1076 {
1077 (__ecereNameSpace__ecere__com__eSystem_Delete(method->name), method->name = 0);
1078 (__ecereNameSpace__ecere__com__eSystem_Delete(method->type), method->type = 0);
1079 }
1080
1081 void FreeDataMemberDefine(struct DataMemberDefine * dataMember)
1082 {
1083 (__ecereNameSpace__ecere__com__eSystem_Delete(dataMember->name), dataMember->name = 0);
1084 (__ecereNameSpace__ecere__com__eSystem_Delete(dataMember->type), dataMember->type = 0);
1085 }
1086
1087 void FreeDataDefine(struct DataDefine * data)
1088 {
1089 (__ecereNameSpace__ecere__com__eSystem_Delete(data->name), data->name = 0);
1090 (__ecereNameSpace__ecere__com__eSystem_Delete(data->type), data->type = 0);
1091 }
1092
1093 void __ecereMethod___ecereNameSpace__ecere__sys__OldList_Free(struct __ecereNameSpace__ecere__sys__OldList * this, void (*  freeFn)(void * ));
1094
1095 void FreeDefinition(struct Definition * definition)
1096 {
1097 (__ecereNameSpace__ecere__com__eSystem_Delete(definition->name), definition->name = 0);
1098 switch(definition->type)
1099 {
1100 case 1:
1101 {
1102 struct ClassDefine * classDefine = (struct ClassDefine *)definition;
1103
1104 (__ecereNameSpace__ecere__com__eSystem_Delete(classDefine->base), classDefine->base = 0);
1105 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Free(&classDefine->methods, FreeMethodDefine);
1106 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Free(&classDefine->propertiesAndMembers, FreeDataMemberDefine);
1107 break;
1108 }
1109 case 3:
1110 (__ecereNameSpace__ecere__com__eSystem_Delete(((struct FunctionDefine *)definition)->dataType), ((struct FunctionDefine *)definition)->dataType = 0);
1111 break;
1112 case 4:
1113 (__ecereNameSpace__ecere__com__eSystem_Delete(((struct DataDefine *)definition)->dataType), ((struct DataDefine *)definition)->dataType = 0);
1114 break;
1115 case 2:
1116 break;
1117 }
1118 }
1119
1120 static unsigned int globalInstance = 0x0;
1121
1122 static struct Context * globalContext;
1123
1124 static struct __ecereNameSpace__ecere__sys__OldList defines, imports, precompDefines;
1125
1126 static struct __ecereNameSpace__ecere__com__Instance * privateModule;
1127
1128 struct __ecereNameSpace__ecere__sys__OldList _excludedSymbols =
1129 {
1130 0, 0, 0, (unsigned int)&((struct Symbol *)(void * )0)->left, 0
1131 };
1132
1133 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass___ecereNameSpace__ecere__com__NameSpace;
1134
1135 struct __ecereNameSpace__ecere__com__NameSpace
1136 {
1137 char *  name;
1138 struct __ecereNameSpace__ecere__com__NameSpace *  btParent;
1139 struct __ecereNameSpace__ecere__com__NameSpace *  left;
1140 struct __ecereNameSpace__ecere__com__NameSpace *  right;
1141 int depth;
1142 struct __ecereNameSpace__ecere__com__NameSpace *  parent;
1143 struct __ecereNameSpace__ecere__sys__BinaryTree nameSpaces;
1144 struct __ecereNameSpace__ecere__sys__BinaryTree classes;
1145 struct __ecereNameSpace__ecere__sys__BinaryTree defines;
1146 struct __ecereNameSpace__ecere__sys__BinaryTree functions;
1147 } __attribute__ ((gcc_struct));
1148
1149 static struct __ecereNameSpace__ecere__com__NameSpace globalData;
1150
1151 extern struct Identifier * GetDeclId(struct Declarator * decl);
1152
1153 extern char *  __ecereNameSpace__ecere__sys__CopyString(char *  string);
1154
1155 extern void ProcessExpressionType(struct Expression * exp);
1156
1157 extern void ComputeExpression(struct Expression * exp);
1158
1159 extern int strtol(char * , char * * , int base);
1160
1161 extern void FreeExpression(struct Expression * exp);
1162
1163 extern struct Type * ProcessType(struct __ecereNameSpace__ecere__sys__OldList * specs, struct Declarator * decl);
1164
1165 extern void PrintType(struct Type * type, char *  string, unsigned int printName, unsigned int fullName);
1166
1167 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass___ecereNameSpace__ecere__com__BitMember;
1168
1169 struct __ecereNameSpace__ecere__com__BitMember
1170 {
1171 struct __ecereNameSpace__ecere__com__BitMember * prev;
1172 struct __ecereNameSpace__ecere__com__BitMember * next;
1173 char *  name;
1174 unsigned int isProperty;
1175 int memberAccess;
1176 int id;
1177 struct __ecereNameSpace__ecere__com__Class * _class;
1178 char *  dataTypeString;
1179 struct __ecereNameSpace__ecere__com__Class * dataTypeClass;
1180 struct Type * dataType;
1181 int type;
1182 int size;
1183 int pos;
1184 uint64 mask;
1185 } __attribute__ ((gcc_struct));
1186
1187 extern struct __ecereNameSpace__ecere__com__BitMember * __ecereNameSpace__ecere__com__eClass_AddBitMember(struct __ecereNameSpace__ecere__com__Class * _class, char *  name, char *  type, int bitSize, int bitPos, int declMode);
1188
1189 extern struct __ecereNameSpace__ecere__com__DataMember * __ecereNameSpace__ecere__com__eMember_AddDataMember(struct __ecereNameSpace__ecere__com__DataMember * member, char *  name, char *  type, unsigned int size, unsigned int alignment, int declMode);
1190
1191 extern struct __ecereNameSpace__ecere__com__DataMember * __ecereNameSpace__ecere__com__eClass_AddDataMember(struct __ecereNameSpace__ecere__com__Class * _class, char *  name, char *  type, unsigned int size, unsigned int alignment, int declMode);
1192
1193 extern struct __ecereNameSpace__ecere__com__DataMember * __ecereNameSpace__ecere__com__eMember_New(int type, int declMode);
1194
1195 extern unsigned int __ecereNameSpace__ecere__com__eMember_AddMember(struct __ecereNameSpace__ecere__com__DataMember * addTo, struct __ecereNameSpace__ecere__com__DataMember * dataMember);
1196
1197 extern unsigned int __ecereNameSpace__ecere__com__eClass_AddMember(struct __ecereNameSpace__ecere__com__Class * _class, struct __ecereNameSpace__ecere__com__DataMember * dataMember);
1198
1199 extern struct __ecereNameSpace__ecere__sys__OldList *  MkListOne(void *  item);
1200
1201 extern struct Declarator * MkDeclaratorIdentifier(struct Identifier * id);
1202
1203 extern char *  StringFromSpecDecl(struct __ecereNameSpace__ecere__sys__OldList * specs, struct Declarator * decl);
1204
1205 extern struct __ecereNameSpace__ecere__com__Property * __ecereNameSpace__ecere__com__eClass_AddProperty(struct __ecereNameSpace__ecere__com__Class * _class, char *  name, char *  dataType, void *  setStmt, void *  getStmt, int declMode);
1206
1207 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass___ecereNameSpace__ecere__com__ClassProperty;
1208
1209 struct __ecereNameSpace__ecere__com__ClassProperty
1210 {
1211 char *  name;
1212 struct __ecereNameSpace__ecere__com__ClassProperty * parent;
1213 struct __ecereNameSpace__ecere__com__ClassProperty * left;
1214 struct __ecereNameSpace__ecere__com__ClassProperty * right;
1215 int depth;
1216 void (*  Set)(struct __ecereNameSpace__ecere__com__Class *, long long);
1217 long long (*  Get)(struct __ecereNameSpace__ecere__com__Class *);
1218 char *  dataTypeString;
1219 struct Type * dataType;
1220 unsigned int constant;
1221 } __attribute__ ((gcc_struct));
1222
1223 extern struct __ecereNameSpace__ecere__com__ClassProperty * __ecereNameSpace__ecere__com__eClass_AddClassProperty(struct __ecereNameSpace__ecere__com__Class * _class, char *  name, char *  dataType, void *  setStmt, void *  getStmt);
1224
1225 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);
1226
1227 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);
1228
1229 extern void *  __ecereNameSpace__ecere__com__eInstance_New(struct __ecereNameSpace__ecere__com__Class * _class);
1230
1231 void __ecereMethod___ecereNameSpace__ecere__sys__OldList_Add(struct __ecereNameSpace__ecere__sys__OldList * this, void *  item);
1232
1233 static void AddDefinitions(struct ClassDefine * classDefine, struct DataMemberDefine * parentMemberDefine, struct __ecereNameSpace__ecere__com__Class * regClass, struct __ecereNameSpace__ecere__com__DataMember * member, struct __ecereNameSpace__ecere__sys__OldList * definitions)
1234 {
1235 if(definitions != (((void *)0)))
1236 {
1237 struct ClassDef * def;
1238
1239 for(def = definitions->first; def; def = def->next)
1240 {
1241 if(def->type == 2)
1242 {
1243 struct Declaration * decl = def->decl;
1244 struct __ecereNameSpace__ecere__com__DataMember * dataMember;
1245 struct Type * dataType;
1246 struct DataMemberDefine * dataMemberDefine;
1247
1248 if(decl->type == 0)
1249 {
1250 struct Declarator * d;
1251
1252 if(decl->declarators)
1253 {
1254 for(d = (*decl->declarators).first; d; d = d->next)
1255 {
1256 {
1257 struct Identifier * declId = GetDeclId(d);
1258
1259 dataMemberDefine = __extension__ ({
1260 struct DataMemberDefine * __ecereInstance1 = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass_DataMemberDefine);
1261
1262 __ecereInstance1->isProperty = 3, __ecereInstance1->memberType = 0, __ecereInstance1->name = __ecereNameSpace__ecere__sys__CopyString(declId->string), __ecereInstance1;
1263 });
1264 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Add(&parentMemberDefine->dataMembers, dataMemberDefine);
1265 if(regClass && regClass->type == 2)
1266 {
1267 struct Expression * sizeExp = d->structDecl.exp, * posExp = d->structDecl.posExp;
1268 int bitSize = 0, bitPos = -1;
1269 char dataTypeString[1024];
1270
1271 dataTypeString[0] = '\0';
1272 if(sizeExp)
1273 {
1274 ProcessExpressionType(sizeExp);
1275 ComputeExpression(sizeExp);
1276 if(sizeExp->isConstant)
1277 bitSize = strtol(sizeExp->constant, (((void *)0)), 0);
1278 FreeExpression(sizeExp);
1279 }
1280 if(posExp)
1281 {
1282 ProcessExpressionType(posExp);
1283 ComputeExpression(posExp);
1284 if(posExp->isConstant)
1285 bitPos = strtol(posExp->constant, (((void *)0)), 0);
1286 FreeExpression(posExp);
1287 }
1288 d->structDecl.exp = (((void *)0));
1289 d->structDecl.posExp = (((void *)0));
1290 dataType = ProcessType(decl->specifiers, d);
1291 PrintType(dataType, dataTypeString, 0x0, 0x1);
1292 {
1293 struct __ecereNameSpace__ecere__com__BitMember * member = __ecereNameSpace__ecere__com__eClass_AddBitMember(regClass, declId->string, dataTypeString, 0, 0, def->memberAccess);
1294
1295 member->size = bitSize;
1296 member->pos = bitPos;
1297 dataMember = (struct __ecereNameSpace__ecere__com__DataMember *)member;
1298 }
1299 if(dataMember)
1300 dataMember->dataType = dataType;
1301 dataMemberDefine->size = bitSize;
1302 dataMemberDefine->bitPos = bitPos;
1303 dataMemberDefine->type = __ecereNameSpace__ecere__sys__CopyString(dataTypeString);
1304 }
1305 else
1306 {
1307 {
1308 char typeString[1024];
1309
1310 typeString[0] = '\0';
1311 dataType = ProcessType(decl->specifiers, d);
1312 PrintType(dataType, typeString, 0x0, 0x1);
1313 if(member)
1314 dataMember = __ecereNameSpace__ecere__com__eMember_AddDataMember(member, declId->string, typeString, 0, 0, def->memberAccess);
1315 else
1316 dataMember = __ecereNameSpace__ecere__com__eClass_AddDataMember(regClass, declId->string, typeString, 0, 0, def->memberAccess);
1317 if(dataMember)
1318 dataMember->dataType = dataType;
1319 dataMemberDefine->type = __ecereNameSpace__ecere__sys__CopyString(typeString);
1320 }
1321 }
1322 dataMemberDefine->memberAccess = def->memberAccess;
1323 }
1324 }
1325 }
1326 else if(decl->specifiers)
1327 {
1328 struct Specifier * spec;
1329
1330 for(spec = (*decl->specifiers).first; spec; spec = spec->next)
1331 {
1332 if(spec->type == 3 || spec->type == 4)
1333 {
1334 if(spec->definitions && !spec->id)
1335 {
1336 struct __ecereNameSpace__ecere__com__DataMember * dataMember = __ecereNameSpace__ecere__com__eMember_New((spec->type == 4) ? 1 : 2, def->memberAccess);
1337
1338 dataMemberDefine = __extension__ ({
1339 struct DataMemberDefine * __ecereInstance1 = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass_DataMemberDefine);
1340
1341 __ecereInstance1->isProperty = 3, __ecereInstance1->memberType = (spec->type == 4) ? 1 : 2, __ecereInstance1;
1342 });
1343 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Add(&parentMemberDefine->dataMembers, dataMemberDefine);
1344 AddDefinitions((((void *)0)), dataMemberDefine, (((void *)0)), dataMember, spec->definitions);
1345 if(member)
1346 __ecereNameSpace__ecere__com__eMember_AddMember(member, dataMember);
1347 else
1348 __ecereNameSpace__ecere__com__eClass_AddMember(regClass, dataMember);
1349 }
1350 else if(spec->definitions && spec->id && (*spec->definitions).count)
1351 {
1352 {
1353 struct Identifier * id = spec->id;
1354 char typeString[1024];
1355
1356 typeString[0] = '\0';
1357 spec->id = (((void *)0));
1358 decl->declarators = MkListOne(MkDeclaratorIdentifier(id));
1359 dataType = ProcessType(decl->specifiers, (((void *)0)));
1360 PrintType(dataType, typeString, 0x0, 0x1);
1361 if(member)
1362 dataMember = __ecereNameSpace__ecere__com__eMember_AddDataMember(member, id->string, typeString, 0, 0, def->memberAccess);
1363 else
1364 dataMember = __ecereNameSpace__ecere__com__eClass_AddDataMember(regClass, id->string, typeString, 0, 0, def->memberAccess);
1365 if(dataMember)
1366 dataMember->dataType = dataType;
1367 }
1368 }
1369 }
1370 }
1371 }
1372 }
1373 else if(decl->type == 2)
1374 {
1375 struct Instantiation * inst = decl->inst;
1376 struct Expression * exp = inst->exp;
1377
1378 if(exp)
1379 {
1380 {
1381 char * string = exp->identifier->string;
1382
1383 {
1384 struct Type * dataType = (dataType = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass_Type), dataType->kind = 8, dataType->_class = inst->_class->symbol, dataType->refCount = 1, dataType);
1385
1386 if(member)
1387 dataMember = __ecereNameSpace__ecere__com__eMember_AddDataMember(member, string, inst->_class->name, 0, 0, def->memberAccess);
1388 else
1389 dataMember = __ecereNameSpace__ecere__com__eClass_AddDataMember(regClass, string, inst->_class->name, 0, 0, def->memberAccess);
1390 if(dataMember)
1391 dataMember->dataType = dataType;
1392 }
1393 dataMemberDefine = __extension__ ({
1394 struct DataMemberDefine * __ecereInstance1 = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass_DataMemberDefine);
1395
1396 __ecereInstance1->isProperty = 3, __ecereInstance1->memberType = 0, __ecereInstance1->name = __ecereNameSpace__ecere__sys__CopyString(string), __ecereInstance1->type = __ecereNameSpace__ecere__sys__CopyString(inst->_class->name), __ecereInstance1;
1397 });
1398 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Add(&parentMemberDefine->dataMembers, dataMemberDefine);
1399 }
1400 }
1401 }
1402 }
1403 else if(def->type == 3 && def->propertyDef)
1404 {
1405 struct PropertyDef * propertyDef = def->propertyDef;
1406
1407 {
1408 struct __ecereNameSpace__ecere__com__Property * prop;
1409 struct PropertyDefine * propDefine;
1410
1411 {
1412 char * dataTypeString = StringFromSpecDecl(propertyDef->specifiers, propertyDef->declarator);
1413
1414 prop = __ecereNameSpace__ecere__com__eClass_AddProperty(regClass, propertyDef->conversion ? (((void *)0)) : propertyDef->id->string, dataTypeString, propertyDef->setStmt, propertyDef->getStmt, def->memberAccess);
1415 if(prop)
1416 {
1417 prop->IsSet = (void *)propertyDef->issetStmt;
1418 prop->compiled = 0x0;
1419 }
1420 (__ecereNameSpace__ecere__com__eSystem_Delete(dataTypeString), dataTypeString = 0);
1421 }
1422 if(prop)
1423 {
1424 prop->symbol = __extension__ ({
1425 struct Symbol * __ecereInstance1 = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass_Symbol);
1426
1427 __ecereInstance1->string = __ecereNameSpace__ecere__sys__CopyString(propertyDef->symbol->string), __ecereInstance1->id = propertyDef->symbol->id, __ecereInstance1->type = propertyDef->symbol->type, __ecereInstance1;
1428 });
1429 if(propertyDef->symbol->type)
1430 propertyDef->symbol->type->refCount++;
1431 propDefine = __extension__ ({
1432 struct PropertyDefine * __ecereInstance1 = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass_PropertyDefine);
1433
1434 __ecereInstance1->isProperty = 1, __ecereInstance1->name = prop->conversion ? (((void *)0)) : __ecereNameSpace__ecere__sys__CopyString(prop->name), __ecereInstance1->type = __ecereNameSpace__ecere__sys__CopyString(prop->dataTypeString), __ecereInstance1->isVirtual = 0x0, __ecereInstance1->memberAccess = def->memberAccess, __ecereInstance1->hasSet = propertyDef->setStmt ? 0x1 : 0x0, __ecereInstance1->hasGet = propertyDef->getStmt ? 0x1 : 0x0, __ecereInstance1->isWatchable = propertyDef->isWatchable, __ecereInstance1;
1435 });
1436 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Add(&classDefine->propertiesAndMembers, propDefine);
1437 }
1438 }
1439 }
1440 else if(def->type == 10 && def->propertyDef)
1441 {
1442 struct PropertyDef * propertyDef = def->propertyDef;
1443
1444 {
1445 struct __ecereNameSpace__ecere__com__ClassProperty * prop;
1446 struct PropertyDefine * propDefine;
1447
1448 {
1449 char * dataTypeString = StringFromSpecDecl(propertyDef->specifiers, propertyDef->declarator);
1450
1451 prop = __ecereNameSpace__ecere__com__eClass_AddClassProperty(regClass, propertyDef->id->string, dataTypeString, propertyDef->setStmt, propertyDef->getStmt);
1452 (__ecereNameSpace__ecere__com__eSystem_Delete(dataTypeString), dataTypeString = 0);
1453 }
1454 if(prop)
1455 {
1456 propDefine = __extension__ ({
1457 struct PropertyDefine * __ecereInstance1 = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass_PropertyDefine);
1458
1459 __ecereInstance1->name = __ecereNameSpace__ecere__sys__CopyString(prop->name), __ecereInstance1->type = __ecereNameSpace__ecere__sys__CopyString(prop->dataTypeString), __ecereInstance1->hasSet = propertyDef->setStmt ? 0x1 : 0x0, __ecereInstance1->hasGet = propertyDef->getStmt ? 0x1 : 0x0, __ecereInstance1;
1460 });
1461 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Add(&classDefine->classProperties, propDefine);
1462 }
1463 }
1464 }
1465 else if(def->type == 7)
1466 {
1467 classDefine->fixed = 0x1;
1468 }
1469 else if(def->type == 6)
1470 {
1471 classDefine->noExpansion = 0x1;
1472 }
1473 else if(def->type == 13)
1474 {
1475 struct __ecereNameSpace__ecere__com__DataMember * member;
1476 struct __ecereNameSpace__ecere__com__Property * prop;
1477 struct __ecereNameSpace__ecere__com__Method * method;
1478
1479 if((prop = __ecereNameSpace__ecere__com__eClass_FindProperty(regClass, def->id->string, privateModule)))
1480 {
1481 struct PropertyDefine * propDefine;
1482
1483 prop = __ecereNameSpace__ecere__com__eClass_AddProperty(regClass, def->id->string, (((void *)0)), (((void *)0)), (((void *)0)), def->memberAccess);
1484 if(prop)
1485 {
1486 propDefine = __extension__ ({
1487 struct PropertyDefine * __ecereInstance1 = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass_PropertyDefine);
1488
1489 __ecereInstance1->isProperty = 1, __ecereInstance1->name = __ecereNameSpace__ecere__sys__CopyString(prop->name), __ecereInstance1->memberAccess = def->memberAccess, __ecereInstance1;
1490 });
1491 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Add(&classDefine->propertiesAndMembers, propDefine);
1492 }
1493 }
1494 else if((member = __ecereNameSpace__ecere__com__eClass_FindDataMember(regClass, def->id->string, privateModule, (((void *)0)), (((void *)0)))))
1495 {
1496 struct DataMemberDefine * dataMemberDefine;
1497
1498 member = __ecereNameSpace__ecere__com__eClass_AddDataMember(regClass, def->id->string, (((void *)0)), 0, 0, def->memberAccess);
1499 dataMemberDefine = __extension__ ({
1500 struct DataMemberDefine * __ecereInstance1 = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass_DataMemberDefine);
1501
1502 __ecereInstance1->isProperty = 3, __ecereInstance1->memberType = 0, __ecereInstance1->name = __ecereNameSpace__ecere__sys__CopyString(def->id->string), __ecereInstance1->memberAccess = def->memberAccess, __ecereInstance1;
1503 });
1504 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Add(&parentMemberDefine->dataMembers, dataMemberDefine);
1505 }
1506 }
1507 }
1508 }
1509 }
1510
1511 extern void FreeType(struct Type * type);
1512
1513 extern struct __ecereNameSpace__ecere__com__Class * __ecereNameSpace__ecere__com__eSystem_RegisterClass(int type, char *  name, char *  baseName, int size, int sizeClass, unsigned int (*  Constructor)(void * ), void (*  Destructor)(void * ), struct __ecereNameSpace__ecere__com__Instance * module, int declMode, int inheritanceAccess);
1514
1515 extern struct __ecereNameSpace__ecere__com__Method * __ecereNameSpace__ecere__com__eClass_AddVirtualMethod(struct __ecereNameSpace__ecere__com__Class * _class, char *  name, char *  type, void *  function, int declMode);
1516
1517 extern struct __ecereNameSpace__ecere__com__Method * __ecereNameSpace__ecere__com__eClass_AddMethod(struct __ecereNameSpace__ecere__com__Class * _class, char *  name, char *  type, void *  function, int declMode);
1518
1519 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);
1520
1521 extern char *  strcpy(char * , const char * );
1522
1523 extern char *  strcat(char * , const char * );
1524
1525 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_OpTable;
1526
1527 struct OpTable
1528 {
1529 unsigned int (*  Add)(struct Expression *, struct Operand *, struct Operand *);
1530 unsigned int (*  Sub)(struct Expression *, struct Operand *, struct Operand *);
1531 unsigned int (*  Mul)(struct Expression *, struct Operand *, struct Operand *);
1532 unsigned int (*  Div)(struct Expression *, struct Operand *, struct Operand *);
1533 unsigned int (*  Mod)(struct Expression *, struct Operand *, struct Operand *);
1534 unsigned int (*  Neg)(struct Expression *, struct Operand *);
1535 unsigned int (*  Inc)(struct Expression *, struct Operand *);
1536 unsigned int (*  Dec)(struct Expression *, struct Operand *);
1537 unsigned int (*  Asign)(struct Expression *, struct Operand *, struct Operand *);
1538 unsigned int (*  AddAsign)(struct Expression *, struct Operand *, struct Operand *);
1539 unsigned int (*  SubAsign)(struct Expression *, struct Operand *, struct Operand *);
1540 unsigned int (*  MulAsign)(struct Expression *, struct Operand *, struct Operand *);
1541 unsigned int (*  DivAsign)(struct Expression *, struct Operand *, struct Operand *);
1542 unsigned int (*  ModAsign)(struct Expression *, struct Operand *, struct Operand *);
1543 unsigned int (*  BitAnd)(struct Expression *, struct Operand *, struct Operand *);
1544 unsigned int (*  BitOr)(struct Expression *, struct Operand *, struct Operand *);
1545 unsigned int (*  BitXor)(struct Expression *, struct Operand *, struct Operand *);
1546 unsigned int (*  LShift)(struct Expression *, struct Operand *, struct Operand *);
1547 unsigned int (*  RShift)(struct Expression *, struct Operand *, struct Operand *);
1548 unsigned int (*  BitNot)(struct Expression *, struct Operand *);
1549 unsigned int (*  AndAsign)(struct Expression *, struct Operand *, struct Operand *);
1550 unsigned int (*  OrAsign)(struct Expression *, struct Operand *, struct Operand *);
1551 unsigned int (*  XorAsign)(struct Expression *, struct Operand *, struct Operand *);
1552 unsigned int (*  LShiftAsign)(struct Expression *, struct Operand *, struct Operand *);
1553 unsigned int (*  RShiftAsign)(struct Expression *, struct Operand *, struct Operand *);
1554 unsigned int (*  Not)(struct Expression *, struct Operand *);
1555 unsigned int (*  Equ)(struct Expression *, struct Operand *, struct Operand *);
1556 unsigned int (*  Nqu)(struct Expression *, struct Operand *, struct Operand *);
1557 unsigned int (*  And)(struct Expression *, struct Operand *, struct Operand *);
1558 unsigned int (*  Or)(struct Expression *, struct Operand *, struct Operand *);
1559 unsigned int (*  Grt)(struct Expression *, struct Operand *, struct Operand *);
1560 unsigned int (*  Sma)(struct Expression *, struct Operand *, struct Operand *);
1561 unsigned int (*  GrtEqu)(struct Expression *, struct Operand *, struct Operand *);
1562 unsigned int (*  SmaEqu)(struct Expression *, struct Operand *, struct Operand *);
1563 unsigned int (*  Cond)(struct Expression *, struct Operand *, struct Operand *, struct Operand *);
1564 } __attribute__ ((gcc_struct));
1565
1566 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_Operand;
1567
1568 struct Operand
1569 {
1570 int kind;
1571 struct Type * type;
1572 unsigned int ptrSize;
1573 union
1574 {
1575 char c;
1576 unsigned char uc;
1577 short s;
1578 unsigned short us;
1579 int i;
1580 unsigned int ui;
1581 float f;
1582 double d;
1583 long long i64;
1584 uint64 ui64;
1585 } __attribute__ ((gcc_struct));
1586 struct OpTable ops;
1587 } __attribute__ ((gcc_struct));
1588
1589 extern struct Operand GetOperand(struct Expression * exp);
1590
1591 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass___ecereNameSpace__ecere__com__ClassTemplateParameter;
1592
1593 struct __ecereNameSpace__ecere__com__ClassTemplateParameter
1594 {
1595 struct __ecereNameSpace__ecere__com__ClassTemplateParameter * prev;
1596 struct __ecereNameSpace__ecere__com__ClassTemplateParameter * next;
1597 char *  name;
1598 int type;
1599 union
1600 {
1601 char *  dataTypeString;
1602 int memberType;
1603 } __attribute__ ((gcc_struct));
1604 struct __ecereNameSpace__ecere__com__ClassTemplateArgument defaultArg;
1605 void *  param;
1606 } __attribute__ ((gcc_struct));
1607
1608 extern struct __ecereNameSpace__ecere__com__ClassTemplateParameter * __ecereNameSpace__ecere__com__eClass_AddTemplateParameter(struct __ecereNameSpace__ecere__com__Class * _class, char *  name, int type, void *  info, struct __ecereNameSpace__ecere__com__ClassTemplateArgument * defaultArg);
1609
1610 static void ProcessClass(int classType, struct __ecereNameSpace__ecere__sys__OldList * definitions, struct Symbol * symbol, struct __ecereNameSpace__ecere__sys__OldList * baseSpecs, struct __ecereNameSpace__ecere__sys__OldList * enumValues, unsigned int isWatchable, int declMode)
1611 {
1612 struct __ecereNameSpace__ecere__com__Class * regClass;
1613 struct ClassDef * def;
1614 struct ClassDefine * classDefine;
1615 char baseName[1024];
1616 unsigned int unitType = 0x0;
1617 unsigned int wouldBeEnum = 0x0;
1618 int inheritanceAccess = 1;
1619
1620 baseName[0] = '\0';
1621 if(baseSpecs != (((void *)0)))
1622 {
1623 struct Type * baseType = ProcessType(baseSpecs, (((void *)0)));
1624
1625 PrintType(baseType, baseName, 0x0, 0x1);
1626 if(baseType->kind == 8)
1627 {
1628 if(baseType->_class->registered && classType == 0)
1629 {
1630 if(baseType->_class->registered->type == 3)
1631 classType = 3;
1632 else if(baseType->_class->registered->type == 2)
1633 classType = 2;
1634 else if(baseType->_class->registered->type == 5)
1635 classType = 5;
1636 else if(baseType->_class->registered->type == 4)
1637 {
1638 wouldBeEnum = 0x1;
1639 }
1640 }
1641 }
1642 else if(baseType->kind == 9 || baseType->kind == 10)
1643 {
1644 classType = 5;
1645 baseName[0] = '\0';
1646 }
1647 else
1648 unitType = 0x1;
1649 FreeType(baseType);
1650 if(((struct Specifier *)baseSpecs->first)->type == 0 && ((struct Specifier *)baseSpecs->first)->specifier == PRIVATE)
1651 inheritanceAccess = 2;
1652 }
1653 if(classType == 0)
1654 {
1655 if(unitType)
1656 classType = 3;
1657 if(definitions != (((void *)0)))
1658 {
1659 for(def = definitions->first; def; def = def->next)
1660 {
1661 if(def->type == 2)
1662 {
1663 struct Declaration * decl = def->decl;
1664
1665 if(decl->type == 0)
1666 {
1667 if(unitType)
1668 {
1669 classType = 2;
1670 break;
1671 }
1672 if(decl->declarators)
1673 {
1674 struct Declarator * d;
1675
1676 for(d = (*decl->declarators).first; d; d = d->next)
1677 {
1678 if(d->structDecl.exp)
1679 {
1680 classType = 2;
1681 break;
1682 }
1683 }
1684 if(d)
1685 break;
1686 }
1687 }
1688 }
1689 }
1690 }
1691 }
1692 if(classType == 0 && wouldBeEnum)
1693 classType = 4;
1694 regClass = symbol->registered = __ecereNameSpace__ecere__com__eSystem_RegisterClass((classType == 6) ? 1 : classType, symbol->string, baseName[0] ? baseName : (((void *)0)), 0, 0, (((void *)0)), (((void *)0)), privateModule, 1, inheritanceAccess);
1695 if(regClass)
1696 regClass->symbol = symbol;
1697 classDefine = __extension__ ({
1698 struct ClassDefine * __ecereInstance1 = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass_ClassDefine);
1699
1700 __ecereInstance1->type = 1, __ecereInstance1->name = __ecereNameSpace__ecere__sys__CopyString(symbol->string), __ecereInstance1->base = baseName[0] ? __ecereNameSpace__ecere__sys__CopyString(baseName) : (((void *)0)), __ecereInstance1->isStatic = declMode == 3, __ecereInstance1->isRemote = symbol->isRemote, __ecereInstance1->isWatchable = isWatchable, __ecereInstance1;
1701 });
1702 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Add(&precompDefines, classDefine);
1703 if(classType == 6)
1704 {
1705 struct __ecereNameSpace__ecere__com__DataMember * unionMember = __ecereNameSpace__ecere__com__eMember_New(1, 1);
1706 struct DataMemberDefine * unionDefine;
1707
1708 unionDefine = __extension__ ({
1709 struct DataMemberDefine * __ecereInstance1 = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass_DataMemberDefine);
1710
1711 __ecereInstance1->isProperty = 3, __ecereInstance1->memberType = 1, __ecereInstance1;
1712 });
1713 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Add(&classDefine->propertiesAndMembers, unionDefine);
1714 AddDefinitions(classDefine, unionDefine, regClass, unionMember, definitions);
1715 __ecereNameSpace__ecere__com__eClass_AddMember(regClass, unionMember);
1716 }
1717 else if(regClass)
1718 AddDefinitions(classDefine, (struct DataMemberDefine *)classDefine, regClass, (((void *)0)), definitions);
1719 if(definitions != (((void *)0)))
1720 {
1721 for(def = definitions->first; def; def = def->next)
1722 {
1723 if(def->type == 0)
1724 {
1725 struct ClassFunction * func = def->function;
1726
1727 if(!func->dontMangle && func->declarator)
1728 {
1729 struct Identifier * id = GetDeclId(func->declarator);
1730 struct __ecereNameSpace__ecere__com__Method * method;
1731 struct MethodDefine * methodDefine;
1732
1733 {
1734 char * dataTypeString = StringFromSpecDecl(func->specifiers, func->declarator);
1735
1736 if(func->isVirtual)
1737 method = __ecereNameSpace__ecere__com__eClass_AddVirtualMethod(regClass, id->string, dataTypeString, func->declarator->symbol, def->memberAccess);
1738 else
1739 method = __ecereNameSpace__ecere__com__eClass_AddMethod(regClass, id->string, dataTypeString, func->declarator->symbol, def->memberAccess);
1740 (__ecereNameSpace__ecere__com__eSystem_Delete(dataTypeString), dataTypeString = 0);
1741 }
1742 if(method)
1743 {
1744 method->symbol = __extension__ ({
1745 struct Symbol * __ecereInstance1 = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass_Symbol);
1746
1747 __ecereInstance1->string = __ecereNameSpace__ecere__sys__CopyString(func->declarator->symbol->string), __ecereInstance1->id = func->declarator->symbol->id, __ecereInstance1->type = func->declarator->symbol->type, __ecereInstance1;
1748 });
1749 if(func->declarator->symbol->type)
1750 func->declarator->symbol->type->refCount++;
1751 ((struct Symbol *)method->symbol)->method = method;
1752 func->declarator->symbol = (((void *)0));
1753 if(method->type != 1 || method->_class == regClass)
1754 {
1755 methodDefine = __extension__ ({
1756 struct MethodDefine * __ecereInstance1 = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass_MethodDefine);
1757
1758 __ecereInstance1->name = __ecereNameSpace__ecere__sys__CopyString(method->name), __ecereInstance1->type = __ecereNameSpace__ecere__sys__CopyString(method->dataTypeString), __ecereInstance1->memberAccess = def->memberAccess, __ecereInstance1->isVirtual = method->type == 1, __ecereInstance1;
1759 });
1760 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Add(&classDefine->methods, methodDefine);
1761 }
1762 }
1763 }
1764 }
1765 else if(def->type == 13)
1766 {
1767 struct __ecereNameSpace__ecere__com__Method * method;
1768
1769 if((method = __ecereNameSpace__ecere__com__eClass_FindMethod(regClass, def->id->string, privateModule)))
1770 {
1771 struct MethodDefine * methodDefine;
1772
1773 method = __ecereNameSpace__ecere__com__eClass_AddMethod(regClass, def->id->string, (((void *)0)), (((void *)0)), def->memberAccess);
1774 methodDefine = __extension__ ({
1775 struct MethodDefine * __ecereInstance1 = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass_MethodDefine);
1776
1777 __ecereInstance1->name = __ecereNameSpace__ecere__sys__CopyString(method->name), __ecereInstance1->memberAccess = def->memberAccess, __ecereInstance1;
1778 });
1779 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Add(&classDefine->methods, methodDefine);
1780 }
1781 }
1782 }
1783 }
1784 if(regClass && symbol->templateParams)
1785 {
1786 struct TemplateParameter * param;
1787
1788 for(param = (*symbol->templateParams).first; param; param = param->next)
1789 {
1790 struct __ecereNameSpace__ecere__com__ClassTemplateArgument defaultArg =
1791 {
1792 0, 0, 0, 0, 0
1793 };
1794
1795 if(param->defaultArgument)
1796 {
1797 switch(param->type)
1798 {
1799 case 0:
1800 defaultArg.dataTypeString = StringFromSpecDecl(param->defaultArgument->templateDatatype->specifiers, param->defaultArgument->templateDatatype->decl);
1801 break;
1802 case 1:
1803 {
1804 char memberString[1024];
1805
1806 memberString[0] = '\0';
1807 if(param->defaultArgument->identifier->_class && param->defaultArgument->identifier->_class->name)
1808 {
1809 if(param->defaultArgument->identifier->_class->type == 8)
1810 strcpy(memberString, param->defaultArgument->identifier->_class->templateParameter->identifier->string);
1811 else
1812 strcpy(memberString, param->defaultArgument->identifier->_class->name);
1813 }
1814 if(memberString[0])
1815 {
1816 strcat(memberString, "::");
1817 }
1818 strcat(memberString, param->defaultArgument->identifier->string);
1819 defaultArg.memberString = __ecereNameSpace__ecere__sys__CopyString(memberString);
1820 break;
1821 }
1822 case 2:
1823 {
1824 struct Operand op;
1825
1826 ProcessExpressionType(param->defaultArgument->expression);
1827 ComputeExpression(param->defaultArgument->expression);
1828 op = GetOperand(param->defaultArgument->expression);
1829 defaultArg.expression.ui64 = op.ui64;
1830 break;
1831 }
1832 }
1833 }
1834 if(param->type == 1)
1835 {
1836 __ecereNameSpace__ecere__com__eClass_AddTemplateParameter(regClass, param->identifier->string, param->type, (void *)param->memberType, &defaultArg);
1837 }
1838 else
1839 {
1840 char * typeString = param->dataType ? StringFromSpecDecl(param->dataType->specifiers, param->dataType->decl) : (((void *)0));
1841
1842 __ecereNameSpace__ecere__com__eClass_AddTemplateParameter(regClass, param->identifier->string, param->type, typeString, &defaultArg);
1843 }
1844 }
1845 }
1846 }
1847
1848 extern void SetParsingType(unsigned int b);
1849
1850 extern void __ecereNameSpace__ecere__com__eEnum_AddFixedValue(struct __ecereNameSpace__ecere__com__Class * _class, char *  string, int value);
1851
1852 extern int __ecereNameSpace__ecere__com__eEnum_AddValue(struct __ecereNameSpace__ecere__com__Class * _class, char *  string);
1853
1854 static void ProcessClassEnumValues(int classType, struct __ecereNameSpace__ecere__sys__OldList * definitions, struct Symbol * symbol, struct __ecereNameSpace__ecere__sys__OldList * baseSpecs, struct __ecereNameSpace__ecere__sys__OldList * enumValues)
1855 {
1856 struct __ecereNameSpace__ecere__com__Class * regClass = symbol->registered;
1857
1858 if(regClass && enumValues)
1859 {
1860 struct Enumerator * e;
1861
1862 for(e = enumValues->first; e; e = e->next)
1863 {
1864 if(e->exp)
1865 {
1866 struct Type * destType = (destType = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass_Type), destType->kind = 3, destType->refCount = 1, destType);
1867
1868 e->exp->destType = destType;
1869 SetParsingType(0x1);
1870 ProcessExpressionType(e->exp);
1871 SetParsingType(0x0);
1872 if(!e->exp->expType)
1873 {
1874 destType->kind = 8;
1875 destType->_class = symbol;
1876 ProcessExpressionType(e->exp);
1877 }
1878 ComputeExpression(e->exp);
1879 if(e->exp->isConstant && e->exp->type == 2)
1880 {
1881 struct Operand op = GetOperand(e->exp);
1882 int value;
1883
1884 switch(op.kind)
1885 {
1886 case 1:
1887 value = op.type->isSigned ? (int)op.c : (int)op.uc;
1888 break;
1889 case 2:
1890 value = op.type->isSigned ? (int)op.s : (int)op.us;
1891 break;
1892 default:
1893 value = op.i;
1894 }
1895 __ecereNameSpace__ecere__com__eEnum_AddFixedValue(regClass, e->id->string, value);
1896 }
1897 else
1898 __ecereNameSpace__ecere__com__eEnum_AddValue(regClass, e->id->string);
1899 }
1900 else
1901 __ecereNameSpace__ecere__com__eEnum_AddValue(regClass, e->id->string);
1902 }
1903 }
1904 }
1905
1906 extern struct __ecereNameSpace__ecere__sys__OldList *  GetAST(void);
1907
1908 extern struct Symbol * FindClass(char *  name);
1909
1910 extern void SetCurrentNameSpace(char *  s);
1911
1912 extern void ComputeModuleClasses(struct __ecereNameSpace__ecere__com__Instance * module);
1913
1914 void PreCompPreProcessClassDefinitions()
1915 {
1916 struct __ecereNameSpace__ecere__sys__OldList * ast = GetAST();
1917 struct External * external, * next;
1918
1919 for(external = (*ast).first; external; external = next)
1920 {
1921 next = external->next;
1922 if(external->type == 2)
1923 {
1924 struct ClassDefinition * _class = external->_class;
1925
1926 if(_class->declMode == 1 || _class->declMode == 2 || _class->declMode == 3)
1927 {
1928 if(_class->definitions)
1929 {
1930 ProcessClass(0, _class->definitions, _class->symbol, _class->baseSpecs, (((void *)0)), _class->deleteWatchable, _class->declMode);
1931 }
1932 }
1933 }
1934 else if(external->type == 1)
1935 {
1936 struct Declaration * declaration = external->declaration;
1937
1938 if(declaration->type == 1)
1939 {
1940 if(external->declaration->declMode == 1 || external->declaration->declMode == 2 || external->declaration->declMode == 3)
1941 {
1942 if(declaration->specifiers)
1943 {
1944 struct Specifier * specifier;
1945
1946 for(specifier = (*declaration->specifiers).first; specifier; specifier = specifier->next)
1947 {
1948 if((specifier->type == 2 || specifier->type == 3 || specifier->type == 4) && specifier->id && specifier->id->string && (declaration->declMode || specifier->baseSpecs || (specifier->type == 2 && specifier->definitions)))
1949 {
1950 struct Symbol * symbol = FindClass(specifier->id->string);
1951
1952 if(symbol)
1953 {
1954 int classType;
1955
1956 if(specifier->type == 2)
1957 classType = 4;
1958 else if(specifier->type == 4)
1959 classType = 6;
1960 else
1961 classType = 1;
1962 ProcessClass(classType, specifier->definitions, symbol, specifier->baseSpecs, specifier->list, 0x0, external->declaration->declMode);
1963 }
1964 }
1965 }
1966 }
1967 if(external->declaration->declMode == 1 || external->declaration->declMode == 2)
1968 {
1969 if(declaration->declarators)
1970 {
1971 struct InitDeclarator * d;
1972
1973 for(d = (*declaration->declarators).first; d; d = d->next)
1974 {
1975 if(d->declarator)
1976 {
1977 struct Symbol * symbol = d->declarator->symbol;
1978
1979 if(symbol)
1980 {
1981 struct DataDefine * dataDefine;
1982 char typeString[1024];
1983
1984 typeString[0] = '\0';
1985 PrintType(symbol->type, typeString, 0x0, 0x1);
1986 dataDefine = __extension__ ({
1987 struct DataDefine * __ecereInstance1 = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass_DataDefine);
1988
1989 __ecereInstance1->type = 4, __ecereInstance1->name = __ecereNameSpace__ecere__sys__CopyString(symbol->string), __ecereInstance1->dataType = __ecereNameSpace__ecere__sys__CopyString(typeString), __ecereInstance1;
1990 });
1991 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Add(&precompDefines, dataDefine);
1992 }
1993 }
1994 }
1995 }
1996 }
1997 }
1998 }
1999 else if(declaration->type == 2)
2000 {
2001 if(external->declaration->declMode == 1 || external->declaration->declMode == 2)
2002 {
2003 struct Symbol * symbol = declaration->inst->symbol;
2004
2005 if(symbol)
2006 {
2007 struct DataDefine * dataDefine;
2008 char typeString[1024];
2009
2010 typeString[0] = '\0';
2011 PrintType(symbol->type, typeString, 0x0, 0x1);
2012 dataDefine = __extension__ ({
2013 struct DataDefine * __ecereInstance1 = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass_DataDefine);
2014
2015 __ecereInstance1->type = 4, __ecereInstance1->name = __ecereNameSpace__ecere__sys__CopyString(symbol->string), __ecereInstance1->dataType = __ecereNameSpace__ecere__sys__CopyString(typeString), __ecereInstance1;
2016 });
2017 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Add(&precompDefines, dataDefine);
2018 }
2019 }
2020 globalInstance = 0x1;
2021 }
2022 else if(declaration->type == 3)
2023 {
2024 if(external->declaration->declMode == 1 || external->declaration->declMode == 2)
2025 {
2026 struct Define * definition = (definition = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass_Define), definition->type = 2, definition->name = __ecereNameSpace__ecere__sys__CopyString(declaration->id->string), definition->exp = declaration->exp, definition);
2027
2028 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Add(&precompDefines, definition);
2029 }
2030 }
2031 }
2032 else if(external->type == 0 && (external->function->declMode == 1 || external->function->declMode == 2))
2033 {
2034 struct FunctionDefinition * function = external->function;
2035 struct FunctionDefine * functionDefine;
2036 char typeString[1024];
2037
2038 typeString[0] = '\0';
2039 PrintType(function->declarator->symbol->type, typeString, 0x1, 0x1);
2040 functionDefine = __extension__ ({
2041 struct FunctionDefine * __ecereInstance1 = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass_FunctionDefine);
2042
2043 __ecereInstance1->type = 3, __ecereInstance1->name = __ecereNameSpace__ecere__sys__CopyString(function->declarator->symbol->string), __ecereInstance1->dataType = __ecereNameSpace__ecere__sys__CopyString(typeString), __ecereInstance1;
2044 });
2045 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Add(&precompDefines, functionDefine);
2046 }
2047 else if(external->type == 4)
2048 {
2049 SetCurrentNameSpace(external->id->string);
2050 }
2051 }
2052 ComputeModuleClasses(privateModule);
2053 for(external = (*ast).first; external; external = next)
2054 {
2055 next = external->next;
2056 if(external->type == 1 && (external->declaration->declMode == 1 || external->declaration->declMode == 2))
2057 {
2058 struct Declaration * declaration = external->declaration;
2059
2060 if(declaration->type == 1)
2061 {
2062 if(declaration->specifiers)
2063 {
2064 struct Specifier * specifier;
2065
2066 for(specifier = (*declaration->specifiers).first; specifier; specifier = specifier->next)
2067 {
2068 if((specifier->type == 2) && specifier->id && specifier->id->string && (declaration->declMode || specifier->baseSpecs || (specifier->type == 2 && specifier->definitions)))
2069 {
2070 struct Symbol * symbol = FindClass(specifier->id->string);
2071
2072 if(symbol)
2073 {
2074 ProcessClassEnumValues(4, specifier->definitions, symbol, specifier->baseSpecs, specifier->list);
2075 }
2076 }
2077 }
2078 }
2079 }
2080 }
2081 }
2082 }
2083
2084 int __ecereMethod___ecereNameSpace__ecere__sys__File_Printf(struct __ecereNameSpace__ecere__com__Instance * this, char *  format, ...);
2085
2086 static void OutputDataMembers(struct ClassDefine * classDefine, struct __ecereNameSpace__ecere__com__Class * _class, struct __ecereNameSpace__ecere__com__Instance * f)
2087 {
2088 if(classDefine->propertiesAndMembers.first)
2089 {
2090 struct DataMemberDefine * member = classDefine->propertiesAndMembers.first;
2091 int last = 0;
2092
2093 for(member = classDefine->propertiesAndMembers.first; member; member = member->next)
2094 {
2095 if(member->isProperty == 1)
2096 {
2097 struct PropertyDefine * prop = (struct PropertyDefine *)member;
2098
2099 if(last != 1)
2100 {
2101 if(last)
2102 __ecereMethod___ecereNameSpace__ecere__sys__File_Printf(f, "         .\n");
2103 __ecereMethod___ecereNameSpace__ecere__sys__File_Printf(f, "      [Defined Properties]\n");
2104 }
2105 if(prop->name)
2106 __ecereMethod___ecereNameSpace__ecere__sys__File_Printf(f, "         %s\n", prop->name);
2107 else
2108 __ecereMethod___ecereNameSpace__ecere__sys__File_Printf(f, "         [Conversion]\n");
2109 if(prop->memberAccess == 1)
2110 __ecereMethod___ecereNameSpace__ecere__sys__File_Printf(f, "            [Public]\n");
2111 else
2112 __ecereMethod___ecereNameSpace__ecere__sys__File_Printf(f, "            [Private]\n");
2113 if(prop->isVirtual)
2114 __ecereMethod___ecereNameSpace__ecere__sys__File_Printf(f, "            [Virtual]\n");
2115 if(prop->hasSet)
2116 __ecereMethod___ecereNameSpace__ecere__sys__File_Printf(f, "            [Set]\n");
2117 if(prop->hasGet)
2118 __ecereMethod___ecereNameSpace__ecere__sys__File_Printf(f, "            [Get]\n");
2119 if(prop->isWatchable)
2120 __ecereMethod___ecereNameSpace__ecere__sys__File_Printf(f, "            [Watchable]\n");
2121 __ecereMethod___ecereNameSpace__ecere__sys__File_Printf(f, "            [Type]\n");
2122 __ecereMethod___ecereNameSpace__ecere__sys__File_Printf(f, "               %s\n", prop->type ? prop->type : "");
2123 }
2124 else
2125 {
2126 if(last != 3)
2127 {
2128 if(last)
2129 __ecereMethod___ecereNameSpace__ecere__sys__File_Printf(f, "         .\n");
2130 __ecereMethod___ecereNameSpace__ecere__sys__File_Printf(f, "      [Defined Data Members]\n");
2131 }
2132 if(member->memberType == 0)
2133 {
2134 __ecereMethod___ecereNameSpace__ecere__sys__File_Printf(f, "         %s\n", member->name);
2135 if(member->memberAccess == 1)
2136 __ecereMethod___ecereNameSpace__ecere__sys__File_Printf(f, "            [Public]\n");
2137 else
2138 __ecereMethod___ecereNameSpace__ecere__sys__File_Printf(f, "            [Private]\n");
2139 if(_class && _class->type == 2)
2140 {
2141 if(member->size)
2142 {
2143 __ecereMethod___ecereNameSpace__ecere__sys__File_Printf(f, "            [Size]\n");
2144 __ecereMethod___ecereNameSpace__ecere__sys__File_Printf(f, "               %d\n", member->size);
2145 }
2146 if(member->bitPos != -1)
2147 {
2148 __ecereMethod___ecereNameSpace__ecere__sys__File_Printf(f, "            [Pos]\n");
2149 __ecereMethod___ecereNameSpace__ecere__sys__File_Printf(f, "               %d\n", member->bitPos);
2150 }
2151 }
2152 __ecereMethod___ecereNameSpace__ecere__sys__File_Printf(f, "            [Type]\n");
2153 __ecereMethod___ecereNameSpace__ecere__sys__File_Printf(f, "               %s\n", member->type ? member->type : "");
2154 }
2155 else
2156 {
2157 if(member->memberAccess == 1)
2158 __ecereMethod___ecereNameSpace__ecere__sys__File_Printf(f, "            [Public]\n");
2159 else
2160 __ecereMethod___ecereNameSpace__ecere__sys__File_Printf(f, "            [Private]\n");
2161 __ecereMethod___ecereNameSpace__ecere__sys__File_Printf(f, (member->memberType == 1) ? "      [Union]\n" : "      [Struct]\n");
2162 OutputDataMembers((struct ClassDefine *)member, (((void *)0)), f);
2163 }
2164 }
2165 last = member->isProperty;
2166 }
2167 __ecereMethod___ecereNameSpace__ecere__sys__File_Printf(f, "         .\n");
2168 }
2169 if(classDefine->classProperties.first)
2170 {
2171 struct PropertyDefine * prop = classDefine->propertiesAndMembers.first;
2172
2173 __ecereMethod___ecereNameSpace__ecere__sys__File_Printf(f, "      [Defined Class Properties]\n");
2174 for(prop = classDefine->classProperties.first; prop; prop = prop->next)
2175 {
2176 if(prop->name)
2177 __ecereMethod___ecereNameSpace__ecere__sys__File_Printf(f, "         %s\n", prop->name);
2178 if(prop->hasSet)
2179 __ecereMethod___ecereNameSpace__ecere__sys__File_Printf(f, "            [Set]\n");
2180 if(prop->hasGet)
2181 __ecereMethod___ecereNameSpace__ecere__sys__File_Printf(f, "            [Get]\n");
2182 __ecereMethod___ecereNameSpace__ecere__sys__File_Printf(f, "            [Type]\n");
2183 __ecereMethod___ecereNameSpace__ecere__sys__File_Printf(f, "               %s\n", prop->type ? prop->type : "");
2184 }
2185 __ecereMethod___ecereNameSpace__ecere__sys__File_Printf(f, "         .\n");
2186 }
2187 }
2188
2189 extern struct __ecereNameSpace__ecere__com__Instance * __ecereNameSpace__ecere__sys__FileOpen(char *  fileName, int mode);
2190
2191 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_ImportedModule;
2192
2193 struct ImportedModule
2194 {
2195 struct ImportedModule * prev;
2196 struct ImportedModule * next;
2197 char *  name;
2198 int type;
2199 int importType;
2200 unsigned int globalInstance;
2201 unsigned int dllOnly;
2202 int importAccess;
2203 } __attribute__ ((gcc_struct));
2204
2205 extern struct __ecereNameSpace__ecere__com__Class * __ecereNameSpace__ecere__com__eSystem_FindClass(struct __ecereNameSpace__ecere__com__Instance * module, char *  name);
2206
2207 extern void PrintExpression(struct Expression * exp, char *  string);
2208
2209 extern void __ecereNameSpace__ecere__sys__ChangeCh(char *  string, char ch1, char ch2);
2210
2211 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass___ecereNameSpace__ecere__com__EnumClassData;
2212
2213 struct __ecereNameSpace__ecere__com__EnumClassData
2214 {
2215 struct __ecereNameSpace__ecere__sys__OldList values;
2216 int largest;
2217 } __attribute__ ((gcc_struct));
2218
2219 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass___ecereNameSpace__ecere__sys__NamedLink;
2220
2221 struct __ecereNameSpace__ecere__sys__NamedLink
2222 {
2223 struct __ecereNameSpace__ecere__sys__NamedLink * prev;
2224 struct __ecereNameSpace__ecere__sys__NamedLink * next;
2225 char *  name;
2226 void *  data;
2227 } __attribute__ ((gcc_struct));
2228
2229 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass___ecereNameSpace__ecere__com__DefinedExpression;
2230
2231 struct __ecereNameSpace__ecere__com__DefinedExpression;
2232
2233 extern struct __ecereNameSpace__ecere__com__DefinedExpression * __ecereNameSpace__ecere__com__eSystem_FindDefine(struct __ecereNameSpace__ecere__com__Instance * module, char *  name);
2234
2235 extern void OutputExpression(struct Expression * exp, struct __ecereNameSpace__ecere__com__Instance * f);
2236
2237 int __ecereVMethodID___ecereNameSpace__ecere__sys__File_Puts;
2238
2239 extern void __ecereNameSpace__ecere__com__eInstance_DecRef(struct __ecereNameSpace__ecere__com__Instance * instance);
2240
2241 static void OutputSymbols(char * fileName)
2242 {
2243 struct __ecereNameSpace__ecere__com__Instance * f = __ecereNameSpace__ecere__sys__FileOpen(fileName, 2);
2244
2245 if(f)
2246 {
2247 int lastType = (int)-1;
2248 struct Definition * definition;
2249
2250 if(globalInstance)
2251 __ecereMethod___ecereNameSpace__ecere__sys__File_Printf(f, "[Global Instance]\n");
2252 for(definition = precompDefines.first; definition; definition = definition->next)
2253 {
2254 if(definition->type != lastType)
2255 {
2256 if(lastType != (int)-1)
2257 __ecereMethod___ecereNameSpace__ecere__sys__File_Printf(f, "   .\n");
2258 if(definition->type == 0)
2259 __ecereMethod___ecereNameSpace__ecere__sys__File_Printf(f, "[Imported Modules]\n");
2260 else if(definition->type == 1)
2261 __ecereMethod___ecereNameSpace__ecere__sys__File_Printf(f, "[Defined Classes]\n");
2262 else if(definition->type == 2)
2263 __ecereMethod___ecereNameSpace__ecere__sys__File_Printf(f, "[Defined Expressions]\n");
2264 else if(definition->type == 3)
2265 __ecereMethod___ecereNameSpace__ecere__sys__File_Printf(f, "[Defined Functions]\n");
2266 else if(definition->type == 4)
2267 __ecereMethod___ecereNameSpace__ecere__sys__File_Printf(f, "[Defined Data]\n");
2268 lastType = definition->type;
2269 }
2270 if(definition->type == 0)
2271 {
2272 struct ImportedModule * module = (struct ImportedModule *)definition;
2273
2274 if(module->importType == 1)
2275 __ecereMethod___ecereNameSpace__ecere__sys__File_Printf(f, "   [Static]\n");
2276 else if(module->importType == 2)
2277 __ecereMethod___ecereNameSpace__ecere__sys__File_Printf(f, "   [Remote]\n");
2278 if(module->importAccess == 2)
2279 __ecereMethod___ecereNameSpace__ecere__sys__File_Printf(f, "   [Private]\n");
2280 __ecereMethod___ecereNameSpace__ecere__sys__File_Printf(f, "   %s\n", module->name);
2281 }
2282 else if(definition->type == 1)
2283 {
2284 struct __ecereNameSpace__ecere__com__Class * _class = __ecereNameSpace__ecere__com__eSystem_FindClass(privateModule, definition->name);
2285 struct ClassDefine * classDefine = (struct ClassDefine *)definition;
2286
2287 __ecereMethod___ecereNameSpace__ecere__sys__File_Printf(f, "   %s\n", definition->name);
2288 if(classDefine->isStatic)
2289 __ecereMethod___ecereNameSpace__ecere__sys__File_Printf(f, "      [Static]\n");
2290 if(classDefine->fixed)
2291 __ecereMethod___ecereNameSpace__ecere__sys__File_Printf(f, "      [Fixed]\n");
2292 if(classDefine->noExpansion)
2293 __ecereMethod___ecereNameSpace__ecere__sys__File_Printf(f, "      [No Expansion]\n");
2294 if(classDefine->isRemote)
2295 __ecereMethod___ecereNameSpace__ecere__sys__File_Printf(f, "      [Remote]\n");
2296 if(classDefine->isWatchable)
2297 __ecereMethod___ecereNameSpace__ecere__sys__File_Printf(f, "      [Watchable]\n");
2298 if(_class->type == 4)
2299 __ecereMethod___ecereNameSpace__ecere__sys__File_Printf(f, "      [Enum]\n");
2300 else if(_class->type == 2)
2301 __ecereMethod___ecereNameSpace__ecere__sys__File_Printf(f, "      [Bit]\n");
2302 else if(_class->type == 1)
2303 __ecereMethod___ecereNameSpace__ecere__sys__File_Printf(f, "      [Struct]\n");
2304 else if(_class->type == 3)
2305 __ecereMethod___ecereNameSpace__ecere__sys__File_Printf(f, "      [Unit]\n");
2306 else if(_class->type == 5)
2307 __ecereMethod___ecereNameSpace__ecere__sys__File_Printf(f, "      [NoHead]\n");
2308 if(_class->inheritanceAccess == 2)
2309 __ecereMethod___ecereNameSpace__ecere__sys__File_Printf(f, "      [Private Base]\n");
2310 else
2311 __ecereMethod___ecereNameSpace__ecere__sys__File_Printf(f, "      [Base]\n");
2312 if(classDefine->base)
2313 __ecereMethod___ecereNameSpace__ecere__sys__File_Printf(f, "         %s\n", classDefine->base);
2314 else
2315 __ecereMethod___ecereNameSpace__ecere__sys__File_Printf(f, "         [None]\n");
2316 if(_class->templateParams.count)
2317 {
2318 struct __ecereNameSpace__ecere__com__ClassTemplateParameter * param;
2319 struct TemplateParameter * tp;
2320
2321 __ecereMethod___ecereNameSpace__ecere__sys__File_Printf(f, "         [Template Parameters]\n");
2322 for(tp = (*((struct Symbol *)_class->symbol)->templateParams).first, param = _class->templateParams.first; param && tp; param = param->next, tp = tp->next)
2323 {
2324 __ecereMethod___ecereNameSpace__ecere__sys__File_Printf(f, "               %s\n", param->name);
2325 switch(param->type)
2326 {
2327 case 0:
2328 __ecereMethod___ecereNameSpace__ecere__sys__File_Printf(f, "               [Type]\n");
2329 __ecereMethod___ecereNameSpace__ecere__sys__File_Printf(f, "               %s\n", param->dataTypeString ? param->dataTypeString : "[None]");
2330 __ecereMethod___ecereNameSpace__ecere__sys__File_Printf(f, "               %s\n", param->defaultArg.dataTypeString ? param->defaultArg.dataTypeString : "[None]");
2331 break;
2332 case 2:
2333 __ecereMethod___ecereNameSpace__ecere__sys__File_Printf(f, "               [Expression]\n");
2334 __ecereMethod___ecereNameSpace__ecere__sys__File_Printf(f, "               %s\n", param->dataTypeString ? param->dataTypeString : "[None]");
2335 if(tp->defaultArgument && tp->defaultArgument->expression)
2336 {
2337 char temp[8192];
2338
2339 temp[0] = (char)0;
2340 PrintExpression(tp->defaultArgument->expression, temp);
2341 __ecereNameSpace__ecere__sys__ChangeCh(temp, '\n', ' ');
2342 __ecereMethod___ecereNameSpace__ecere__sys__File_Printf(f, "               ");
2343 ((unsigned int (*)(struct __ecereNameSpace__ecere__com__Instance *, const char *  string))f->_vTbl[__ecereVMethodID___ecereNameSpace__ecere__sys__File_Puts])(f, temp);
2344 ((unsigned int (*)(struct __ecereNameSpace__ecere__com__Instance *, const char *  string))f->_vTbl[__ecereVMethodID___ecereNameSpace__ecere__sys__File_Puts])(f, "\n");
2345 }
2346 else
2347 __ecereMethod___ecereNameSpace__ecere__sys__File_Printf(f, "               [None]\n");
2348 break;
2349 case 1:
2350 __ecereMethod___ecereNameSpace__ecere__sys__File_Printf(f, "               [Identifier]\n");
2351 __ecereMethod___ecereNameSpace__ecere__sys__File_Printf(f, "               %s\n", (param->memberType == 0) ? "[Data member]" : ((param->memberType == 1) ? "[Method]" : "[Property]"));
2352 if(tp->defaultArgument && tp->defaultArgument->identifier)
2353 {
2354 __ecereMethod___ecereNameSpace__ecere__sys__File_Printf(f, "               ");
2355 if(tp->defaultArgument->identifier->_class && tp->defaultArgument->identifier->_class->type == 1 && tp->defaultArgument->identifier->_class->name)
2356 {
2357 __ecereMethod___ecereNameSpace__ecere__sys__File_Printf(f, "%s::", tp->defaultArgument->identifier->_class->name);
2358 }
2359 else if(tp->defaultArgument->identifier->_class && tp->defaultArgument->identifier->_class->type == 8 && tp->defaultArgument->identifier->_class->templateParameter->identifier)
2360 {
2361 __ecereMethod___ecereNameSpace__ecere__sys__File_Printf(f, "%s::", tp->defaultArgument->identifier->_class->templateParameter->identifier->string);
2362 }
2363 __ecereMethod___ecereNameSpace__ecere__sys__File_Printf(f, "%s\n", tp->defaultArgument->identifier->string);
2364 }
2365 else
2366 {
2367 __ecereMethod___ecereNameSpace__ecere__sys__File_Printf(f, "               [None]\n");
2368 }
2369 break;
2370 }
2371 }
2372 __ecereMethod___ecereNameSpace__ecere__sys__File_Printf(f, "         .\n");
2373 }
2374 if(!classDefine->isStatic)
2375 {
2376 if(classDefine->methods.first)
2377 {
2378 struct MethodDefine * method;
2379
2380 __ecereMethod___ecereNameSpace__ecere__sys__File_Printf(f, "      [Defined Methods]\n");
2381 for(method = classDefine->methods.first; method; method = method->next)
2382 {
2383 __ecereMethod___ecereNameSpace__ecere__sys__File_Printf(f, "         %s\n", method->name);
2384 if(method->memberAccess == 1)
2385 __ecereMethod___ecereNameSpace__ecere__sys__File_Printf(f, "            [Public]\n");
2386 else
2387 __ecereMethod___ecereNameSpace__ecere__sys__File_Printf(f, "            [Private]\n");
2388 if(method->isVirtual)
2389 __ecereMethod___ecereNameSpace__ecere__sys__File_Printf(f, "            [Virtual]\n");
2390 __ecereMethod___ecereNameSpace__ecere__sys__File_Printf(f, "            [Type]\n");
2391 __ecereMethod___ecereNameSpace__ecere__sys__File_Printf(f, "               %s\n", method->type ? method->type : "");
2392 }
2393 __ecereMethod___ecereNameSpace__ecere__sys__File_Printf(f, "         .\n");
2394 }
2395 OutputDataMembers(classDefine, _class, f);
2396 if(_class->type == 4)
2397 {
2398 struct __ecereNameSpace__ecere__sys__NamedLink * value;
2399 struct __ecereNameSpace__ecere__com__Class * enumClass = __ecereNameSpace__ecere__com__eSystem_FindClass(privateModule, "enum");
2400 struct __ecereNameSpace__ecere__com__EnumClassData * e = (_class ? ((void *)(((char *)_class->data) + enumClass->offsetClass)) : (((void *)0)));
2401
2402 __ecereMethod___ecereNameSpace__ecere__sys__File_Printf(f, "      [Enum Values]\n");
2403 for(value = e->values.first; value; value = value->next)
2404 {
2405 __ecereMethod___ecereNameSpace__ecere__sys__File_Printf(f, "         %s = %d\n", value->name, value->data);
2406 }
2407 __ecereMethod___ecereNameSpace__ecere__sys__File_Printf(f, "         .\n");
2408 }
2409 }
2410 }
2411 else if(definition->type == 2)
2412 {
2413 struct __ecereNameSpace__ecere__com__DefinedExpression * defExp = __ecereNameSpace__ecere__com__eSystem_FindDefine(privateModule, definition->name);
2414 struct Define * defineDefine = (struct Define *)definition;
2415
2416 __ecereMethod___ecereNameSpace__ecere__sys__File_Printf(f, "   %s\n", definition->name);
2417 __ecereMethod___ecereNameSpace__ecere__sys__File_Printf(f, "      [Value]\n");
2418 __ecereMethod___ecereNameSpace__ecere__sys__File_Printf(f, "         ");
2419 OutputExpression(defineDefine->exp, f);
2420 __ecereMethod___ecereNameSpace__ecere__sys__File_Printf(f, "\n");
2421 }
2422 else if(definition->type == 3)
2423 {
2424 struct FunctionDefine * functionDefine = (struct FunctionDefine *)definition;
2425
2426 __ecereMethod___ecereNameSpace__ecere__sys__File_Printf(f, "   %s\n", functionDefine->name);
2427 __ecereMethod___ecereNameSpace__ecere__sys__File_Printf(f, "      [Type]\n");
2428 __ecereMethod___ecereNameSpace__ecere__sys__File_Printf(f, "         %s\n", functionDefine->dataType);
2429 }
2430 else if(definition->type == 4)
2431 {
2432 struct DataDefine * dataDefine = (struct DataDefine *)definition;
2433
2434 __ecereMethod___ecereNameSpace__ecere__sys__File_Printf(f, "   %s\n", dataDefine->name);
2435 __ecereMethod___ecereNameSpace__ecere__sys__File_Printf(f, "      [Type]\n");
2436 __ecereMethod___ecereNameSpace__ecere__sys__File_Printf(f, "         %s\n", dataDefine->dataType);
2437 }
2438 }
2439 __ecereMethod___ecereNameSpace__ecere__sys__File_Printf(f, "   .\n");
2440 (__ecereNameSpace__ecere__com__eInstance_DecRef(f), f = 0);
2441 }
2442 }
2443
2444 static struct __ecereNameSpace__ecere__com__Class * __ecereClass_PrecompApp;
2445
2446 extern int __ecereNameSpace__ecere__com__GetRuntimePlatform(void);
2447
2448 extern int GetHostBits(void);
2449
2450 extern int strcmp(const char * , const char * );
2451
2452 extern size_t strlen(const char * );
2453
2454 extern char *  GetOutputFile(void);
2455
2456 extern void SetOutputFile(char *  s);
2457
2458 extern char *  GetSourceFile(void);
2459
2460 extern void SetSourceFile(char *  s);
2461
2462 extern void SetSymbolsDir(char *  s);
2463
2464 extern void SetDefaultNameSpace(char *  s);
2465
2466 extern void SetStrictNameSpaces(unsigned int b);
2467
2468 extern char *  GetSymbolsDir(void);
2469
2470 extern char *  __ecereNameSpace__ecere__sys__PathCat(char *  string, char *  addedPath);
2471
2472 extern char *  __ecereNameSpace__ecere__sys__ChangeExtension(char *  string, char *  ext, char *  output);
2473
2474 extern int printf(char * , ...);
2475
2476 extern char *  __ecereNameSpace__ecere__GetTranslatedString(struct __ecereNameSpace__ecere__com__Instance * module, char *  string, char *  stringAndContext);
2477
2478 extern struct __ecereNameSpace__ecere__com__Instance * __thisModule;
2479
2480 extern void SetGlobalContext(struct Context * context);
2481
2482 extern void SetTopContext(struct Context * context);
2483
2484 extern void SetCurrentContext(struct Context * context);
2485
2486 extern void SetExcludedSymbols(struct __ecereNameSpace__ecere__sys__OldList *  list);
2487
2488 extern void SetGlobalData(struct __ecereNameSpace__ecere__com__NameSpace *  nameSpace);
2489
2490 extern void SetDefines(struct __ecereNameSpace__ecere__sys__OldList *  list);
2491
2492 extern void SetImports(struct __ecereNameSpace__ecere__sys__OldList *  list);
2493
2494 extern void SetPrecompDefines(struct __ecereNameSpace__ecere__sys__OldList *  list);
2495
2496 extern void SetInPreCompiler(unsigned int b);
2497
2498 extern void SetTargetPlatform(int platform);
2499
2500 extern void SetTargetBits(int bits);
2501
2502 extern void SetEchoOn(unsigned int b);
2503
2504 extern struct __ecereNameSpace__ecere__com__Instance * __ecereNameSpace__ecere__com____ecere_COM_Initialize(unsigned int guiApp, int argc, char *  argv[]);
2505
2506 extern void SetPrivateModule(struct __ecereNameSpace__ecere__com__Instance * module);
2507
2508 extern struct Type * ProcessTypeString(char *  string, unsigned int staticMethod);
2509
2510 extern unsigned int __ecereNameSpace__ecere__sys__FileExists(char *  fileName);
2511
2512 extern unsigned int __ecereNameSpace__ecere__sys__DeleteFile(char *  fileName);
2513
2514 extern int snprintf(char * , size_t, char * , ...);
2515
2516 extern struct __ecereNameSpace__ecere__com__Instance * __ecereNameSpace__ecere__sys__DualPipeOpen(unsigned int mode, char *  commandLine);
2517
2518 extern void SetFileInput(struct __ecereNameSpace__ecere__com__Instance * file);
2519
2520 extern void SetMainModule(struct ModuleImport * moduleImport);
2521
2522 extern void resetScanner(void);
2523
2524 extern void ParseEc(void);
2525
2526 extern void SetYydebug(unsigned int b);
2527
2528 extern void ProcessDBTableDefinitions(void);
2529
2530 extern void FreeASTTree(struct __ecereNameSpace__ecere__sys__OldList * ast);
2531
2532 extern void FreeContext(struct Context * context);
2533
2534 extern void FreeExcludedSymbols(struct __ecereNameSpace__ecere__sys__OldList * excludedSymbols);
2535
2536 extern void FreeModuleDefine(struct Definition * def);
2537
2538 extern void FreeModuleImport(struct ModuleImport * imp);
2539
2540 extern void FreeTypeData(struct __ecereNameSpace__ecere__com__Instance * privateModule);
2541
2542 extern void FreeIncludeFiles(void);
2543
2544 extern void FreeGlobalData(struct __ecereNameSpace__ecere__com__NameSpace * globalDataList);
2545
2546 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass___ecereNameSpace__ecere__sys__TempFile;
2547
2548 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass___ecereNameSpace__ecere__com__Application;
2549
2550 struct __ecereNameSpace__ecere__com__Application
2551 {
2552 int argc;
2553 char * *  argv;
2554 int exitCode;
2555 unsigned int isGUIApp;
2556 struct __ecereNameSpace__ecere__sys__OldList allModules;
2557 char *  parsedCommand;
2558 struct __ecereNameSpace__ecere__com__NameSpace systemNameSpace;
2559 } __attribute__ ((gcc_struct));
2560
2561 char *  __ecereProp___ecereNameSpace__ecere__com__Platform_Get_char__PTR_(int this);
2562
2563 int __ecereProp___ecereNameSpace__ecere__com__Platform_Set_char__PTR_(char *  value);
2564
2565 extern struct __ecereNameSpace__ecere__com__Property ** __ecereProp___ecereNameSpace__ecere__com__Platform_char__PTR_;
2566
2567 unsigned int __ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_Add(struct __ecereNameSpace__ecere__sys__BinaryTree * this, struct __ecereNameSpace__ecere__sys__BTNode * node);
2568
2569 int __ecereVMethodID___ecereNameSpace__ecere__sys__File_Eof;
2570
2571 int __ecereVMethodID___ecereNameSpace__ecere__sys__File_Read;
2572
2573 int __ecereVMethodID___ecereNameSpace__ecere__sys__File_Write;
2574
2575 int __ecereMethod___ecereNameSpace__ecere__sys__DualPipe_GetExitCode();
2576
2577 int __ecereVMethodID___ecereNameSpace__ecere__sys__File_Seek;
2578
2579 void __ecereMethod_PrecompApp_Main(struct __ecereNameSpace__ecere__com__Instance * this)
2580 {
2581 int c;
2582 unsigned int valid = 0x1;
2583 char defaultSymFile[797];
2584 char * cppCommand = (((void *)0));
2585 char * cppOptions = (((void *)0));
2586 int cppOptionsLen = 0;
2587 int targetPlatform = __ecereNameSpace__ecere__com__GetRuntimePlatform();
2588 int targetBits = GetHostBits();
2589
2590 for(c = 1; c < ((struct __ecereNameSpace__ecere__com__Application *)(((char *)this + structSize_Module)))->argc; c++)
2591 {
2592 char * arg = ((struct __ecereNameSpace__ecere__com__Application *)(((char *)this + structSize_Module)))->argv[c];
2593
2594 if(arg[0] == '-')
2595 {
2596 if(!strcmp(arg + 1, "m32") || !strcmp(arg + 1, "m64"))
2597 {
2598 int argLen = strlen(arg);
2599 int newLen = cppOptionsLen + 1 + argLen;
2600
2601 cppOptions = __ecereNameSpace__ecere__com__eSystem_Renew(cppOptions, sizeof(char) * (newLen + 1));
2602 cppOptions[cppOptionsLen] = ' ';
2603 strcpy(cppOptions + cppOptionsLen + 1, arg);
2604 cppOptionsLen = newLen;
2605 targetBits = !strcmp(arg + 1, "m32") ? 32 : 64;
2606 }
2607 else if(arg[1] == 'D')
2608 {
2609 int argLen = strlen(arg);
2610 int newLen = cppOptionsLen + 1 + argLen;
2611
2612 cppOptions = __ecereNameSpace__ecere__com__eSystem_Renew(cppOptions, sizeof(char) * (newLen + 1));
2613 cppOptions[cppOptionsLen] = ' ';
2614 strcpy(cppOptions + cppOptionsLen + 1, arg);
2615 cppOptionsLen = newLen;
2616 }
2617 else if(arg[1] == 'I')
2618 {
2619 int argLen = strlen(arg);
2620 int newLen = cppOptionsLen + argLen + 3;
2621
2622 cppOptions = __ecereNameSpace__ecere__com__eSystem_Renew(cppOptions, sizeof(char) * (newLen + 1));
2623 cppOptions[cppOptionsLen] = ' ';
2624 cppOptions[cppOptionsLen + 1] = '-';
2625 cppOptions[cppOptionsLen + 2] = 'I';
2626 cppOptions[cppOptionsLen + 3] = '"';
2627 strcpy(cppOptions + cppOptionsLen + 4, arg + 2);
2628 cppOptions[newLen - 1] = '\"';
2629 cppOptions[newLen] = '\0';
2630 cppOptionsLen = newLen;
2631 }
2632 else if(!strcmp(arg + 1, "t"))
2633 {
2634 if(++c < ((struct __ecereNameSpace__ecere__com__Application *)(((char *)this + structSize_Module)))->argc)
2635 targetPlatform = __ecereProp___ecereNameSpace__ecere__com__Platform_Set_char__PTR_(((struct __ecereNameSpace__ecere__com__Application *)(((char *)this + structSize_Module)))->argv[c]);
2636 else
2637 valid = 0x0;
2638 }
2639 else if(!strcmp(arg + 1, "cpp"))
2640 {
2641 if(++c < ((struct __ecereNameSpace__ecere__com__Application *)(((char *)this + structSize_Module)))->argc)
2642 cppCommand = __ecereNameSpace__ecere__sys__CopyString(((struct __ecereNameSpace__ecere__com__Application *)(((char *)this + structSize_Module)))->argv[c]);
2643 else
2644 valid = 0x0;
2645 }
2646 else if(!strcmp(arg + 1, "o"))
2647 {
2648 if(!GetOutputFile() && c + 1 < ((struct __ecereNameSpace__ecere__com__Application *)(((char *)this + structSize_Module)))->argc)
2649 {
2650 SetOutputFile(((struct __ecereNameSpace__ecere__com__Application *)(((char *)this + structSize_Module)))->argv[c + 1]);
2651 c++;
2652 }
2653 else
2654 valid = 0x0;
2655 }
2656 else if(!strcmp(arg + 1, "c"))
2657 {
2658 if(!GetSourceFile() && c + 1 < ((struct __ecereNameSpace__ecere__com__Application *)(((char *)this + structSize_Module)))->argc)
2659 {
2660 SetSourceFile(((struct __ecereNameSpace__ecere__com__Application *)(((char *)this + structSize_Module)))->argv[c + 1]);
2661 c++;
2662 }
2663 else
2664 valid = 0x0;
2665 }
2666 else if(!strcmp(arg + 1, "isystem") || !strcmp(arg + 1, "isysroot"))
2667 {
2668 if(c + 1 < ((struct __ecereNameSpace__ecere__com__Application *)(((char *)this + structSize_Module)))->argc)
2669 {
2670 int argLen = strlen(arg);
2671 int arg1Len = strlen(((struct __ecereNameSpace__ecere__com__Application *)(((char *)this + structSize_Module)))->argv[c + 1]);
2672 int newLen = cppOptionsLen + argLen + arg1Len + 4;
2673
2674 cppOptions = __ecereNameSpace__ecere__com__eSystem_Renew(cppOptions, sizeof(char) * (newLen + 1));
2675 cppOptions[cppOptionsLen] = ' ';
2676 strcpy(cppOptions + cppOptionsLen + 1, arg);
2677 cppOptions[cppOptionsLen + argLen + 1] = ' ';
2678 cppOptions[cppOptionsLen + argLen + 2] = '"';
2679 arg = ((struct __ecereNameSpace__ecere__com__Application *)(((char *)this + structSize_Module)))->argv[++c];
2680 strcpy(cppOptions + cppOptionsLen + argLen + 3, arg);
2681 cppOptions[newLen - 1] = '\"';
2682 cppOptions[newLen] = '\0';
2683 cppOptionsLen = newLen;
2684 }
2685 else
2686 valid = 0x0;
2687 }
2688 else if(!strcmp(arg + 1, "symbols"))
2689 {
2690 if(c + 1 < ((struct __ecereNameSpace__ecere__com__Application *)(((char *)this + structSize_Module)))->argc)
2691 {
2692 SetSymbolsDir(((struct __ecereNameSpace__ecere__com__Application *)(((char *)this + structSize_Module)))->argv[c + 1]);
2693 c++;
2694 }
2695 else
2696 valid = 0x0;
2697 }
2698 else if(!strcmp(arg + 1, "defaultns"))
2699 {
2700 if(c + 1 < ((struct __ecereNameSpace__ecere__com__Application *)(((char *)this + structSize_Module)))->argc)
2701 {
2702 SetDefaultNameSpace(((struct __ecereNameSpace__ecere__com__Application *)(((char *)this + structSize_Module)))->argv[c + 1]);
2703 c++;
2704 }
2705 else
2706 valid = 0x0;
2707 }
2708 else if(!strcmp(arg + 1, "strictns"))
2709 {
2710 SetStrictNameSpaces(0x1);
2711 }
2712 }
2713 else
2714 valid = 0x0;
2715 }
2716 if(valid)
2717 {
2718 if(!cppCommand)
2719 cppCommand = __ecereNameSpace__ecere__sys__CopyString("gcc");
2720 if(!GetSourceFile())
2721 valid = 0x0;
2722 else if(!GetOutputFile())
2723 {
2724 strcpy(defaultSymFile, GetSymbolsDir());
2725 __ecereNameSpace__ecere__sys__PathCat(defaultSymFile, GetSourceFile());
2726 __ecereNameSpace__ecere__sys__ChangeExtension(defaultSymFile, "sym", defaultSymFile);
2727 SetOutputFile(defaultSymFile);
2728 }
2729 }
2730 if(!valid)
2731 {
2732 printf(__ecereNameSpace__ecere__GetTranslatedString(__thisModule, "Syntax:\n   ecp [-t <target platform>] [-cpp <c preprocessor>] [-o <output>] [-symbols <outputdir>] [-I<includedir>]* [-isystem <sysincludedir>]* [-D<definition>]* -c <input>\n", (((void *)0))));
2733 }
2734 else
2735 {
2736 char command[3075LL];
2737 struct __ecereNameSpace__ecere__com__Instance * cppOutput;
2738
2739 SetGlobalContext(globalContext);
2740 SetTopContext(globalContext);
2741 SetCurrentContext(globalContext);
2742 SetExcludedSymbols(&_excludedSymbols);
2743 SetGlobalData(&globalData);
2744 SetDefines(&defines);
2745 SetImports(&imports);
2746 SetPrecompDefines(&precompDefines);
2747 SetInPreCompiler(0x1);
2748 SetTargetPlatform(targetPlatform);
2749 SetTargetBits(targetBits);
2750 SetEchoOn(0x0);
2751 privateModule = (struct __ecereNameSpace__ecere__com__Instance *)__ecereNameSpace__ecere__com____ecere_COM_Initialize(0x1 | (targetBits == sizeof(uintptr_t) * 8 ? (unsigned int)0 : targetBits == 64 ? (unsigned int)2 : targetBits == 32 ? (unsigned int)4 : (unsigned int)0) | (unsigned int)8, 1, (((void *)0)));
2752 SetPrivateModule(privateModule);
2753 __ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_Add(&globalContext->types, (struct __ecereNameSpace__ecere__sys__BTNode *)__extension__ ({
2754 struct Symbol * __ecereInstance1 = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass_Symbol);
2755
2756 __ecereInstance1->string = __ecereNameSpace__ecere__sys__CopyString("uint"), __ecereInstance1->type = ProcessTypeString("unsigned int", 0x0), __ecereInstance1;
2757 }));
2758 __ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_Add(&globalContext->types, (struct __ecereNameSpace__ecere__sys__BTNode *)__extension__ ({
2759 struct Symbol * __ecereInstance1 = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass_Symbol);
2760
2761 __ecereInstance1->string = __ecereNameSpace__ecere__sys__CopyString("uint64"), __ecereInstance1->type = ProcessTypeString("unsigned int64", 0x0), __ecereInstance1;
2762 }));
2763 __ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_Add(&globalContext->types, (struct __ecereNameSpace__ecere__sys__BTNode *)__extension__ ({
2764 struct Symbol * __ecereInstance1 = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass_Symbol);
2765
2766 __ecereInstance1->string = __ecereNameSpace__ecere__sys__CopyString("uint32"), __ecereInstance1->type = ProcessTypeString("unsigned int", 0x0), __ecereInstance1;
2767 }));
2768 __ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_Add(&globalContext->types, (struct __ecereNameSpace__ecere__sys__BTNode *)__extension__ ({
2769 struct Symbol * __ecereInstance1 = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass_Symbol);
2770
2771 __ecereInstance1->string = __ecereNameSpace__ecere__sys__CopyString("uint16"), __ecereInstance1->type = ProcessTypeString("unsigned short", 0x0), __ecereInstance1;
2772 }));
2773 __ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_Add(&globalContext->types, (struct __ecereNameSpace__ecere__sys__BTNode *)__extension__ ({
2774 struct Symbol * __ecereInstance1 = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass_Symbol);
2775
2776 __ecereInstance1->string = __ecereNameSpace__ecere__sys__CopyString("byte"), __ecereInstance1->type = ProcessTypeString("unsigned char", 0x0), __ecereInstance1;
2777 }));
2778 __ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_Add(&globalContext->types, (struct __ecereNameSpace__ecere__sys__BTNode *)__extension__ ({
2779 struct Symbol * __ecereInstance1 = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass_Symbol);
2780
2781 __ecereInstance1->string = __ecereNameSpace__ecere__sys__CopyString("intptr_t"), __ecereInstance1->type = ProcessTypeString("intptr", 0x0), __ecereInstance1;
2782 }));
2783 __ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_Add(&globalContext->types, (struct __ecereNameSpace__ecere__sys__BTNode *)__extension__ ({
2784 struct Symbol * __ecereInstance1 = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass_Symbol);
2785
2786 __ecereInstance1->string = __ecereNameSpace__ecere__sys__CopyString("uintptr_t"), __ecereInstance1->type = ProcessTypeString("uintptr", 0x0), __ecereInstance1;
2787 }));
2788 __ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_Add(&globalContext->types, (struct __ecereNameSpace__ecere__sys__BTNode *)__extension__ ({
2789 struct Symbol * __ecereInstance1 = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass_Symbol);
2790
2791 __ecereInstance1->string = __ecereNameSpace__ecere__sys__CopyString("ssize_t"), __ecereInstance1->type = ProcessTypeString("intsize", 0x0), __ecereInstance1;
2792 }));
2793 __ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_Add(&globalContext->types, (struct __ecereNameSpace__ecere__sys__BTNode *)__extension__ ({
2794 struct Symbol * __ecereInstance1 = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass_Symbol);
2795
2796 __ecereInstance1->string = __ecereNameSpace__ecere__sys__CopyString("size_t"), __ecereInstance1->type = ProcessTypeString("uintsize", 0x0), __ecereInstance1;
2797 }));
2798 {
2799 char * outputFilePath = GetOutputFile();
2800
2801 if(__ecereNameSpace__ecere__sys__FileExists(outputFilePath))
2802 __ecereNameSpace__ecere__sys__DeleteFile(outputFilePath);
2803 }
2804 snprintf(command, sizeof command, "%s%s -x c -E \"%s\"", cppCommand, cppOptions ? cppOptions : "", GetSourceFile());
2805 command[sizeof command - 1] = (char)0;
2806 if((cppOutput = __ecereNameSpace__ecere__sys__DualPipeOpen((((unsigned int)(0x1))), command)))
2807 {
2808 int exitCode;
2809 struct __ecereNameSpace__ecere__sys__OldList * ast;
2810 struct __ecereNameSpace__ecere__com__Instance * fileInput = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass___ecereNameSpace__ecere__sys__TempFile);
2811 struct ModuleImport * mainModule = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass_ModuleImport);
2812
2813 SetFileInput(fileInput);
2814 SetMainModule(mainModule);
2815 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Add(&imports, mainModule);
2816 resetScanner();
2817 for(; !((unsigned int (*)(struct __ecereNameSpace__ecere__com__Instance *))cppOutput->_vTbl[__ecereVMethodID___ecereNameSpace__ecere__sys__File_Eof])(cppOutput); )
2818 {
2819 char junk[4096];
2820 int count = ((int (*)(struct __ecereNameSpace__ecere__com__Instance *, void *  buffer, unsigned int size, unsigned int count))cppOutput->_vTbl[__ecereVMethodID___ecereNameSpace__ecere__sys__File_Read])(cppOutput, junk, 1, 4096);
2821
2822 ((int (*)(struct __ecereNameSpace__ecere__com__Instance *, void *  buffer, unsigned int size, unsigned int count))fileInput->_vTbl[__ecereVMethodID___ecereNameSpace__ecere__sys__File_Write])(fileInput, junk, 1, count);
2823 }
2824 exitCode = __ecereMethod___ecereNameSpace__ecere__sys__DualPipe_GetExitCode(cppOutput);
2825 (__ecereNameSpace__ecere__com__eInstance_DecRef(cppOutput), cppOutput = 0);
2826 ((unsigned int (*)(struct __ecereNameSpace__ecere__com__Instance *, int pos, int mode))fileInput->_vTbl[__ecereVMethodID___ecereNameSpace__ecere__sys__File_Seek])(fileInput, 0, 0);
2827 ParseEc();
2828 SetCurrentNameSpace((((void *)0)));
2829 SetYydebug(0x0);
2830 (__ecereNameSpace__ecere__com__eInstance_DecRef(fileInput), fileInput = 0);
2831 SetFileInput((((void *)0)));
2832 ast = GetAST();
2833 if(!exitCode)
2834 {
2835 if(ast)
2836 {
2837 ProcessDBTableDefinitions();
2838 PreCompPreProcessClassDefinitions();
2839 }
2840 if(!((struct __ecereNameSpace__ecere__com__Application *)(((char *)this + structSize_Module)))->exitCode)
2841 OutputSymbols(GetOutputFile());
2842 }
2843 else
2844 ((struct __ecereNameSpace__ecere__com__Application *)(((char *)this + structSize_Module)))->exitCode = exitCode;
2845 if(ast)
2846 {
2847 FreeASTTree(ast);
2848 }
2849 }
2850 FreeContext(globalContext);
2851 FreeExcludedSymbols(&_excludedSymbols);
2852 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Free(&defines, FreeModuleDefine);
2853 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Free(&imports, FreeModuleImport);
2854 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Free(&precompDefines, FreeDefinition);
2855 FreeTypeData(privateModule);
2856 FreeIncludeFiles();
2857 FreeGlobalData(&globalData);
2858 (__ecereNameSpace__ecere__com__eInstance_DecRef(privateModule), privateModule = 0);
2859 }
2860 (__ecereNameSpace__ecere__com__eSystem_Delete(cppCommand), cppCommand = 0);
2861 (__ecereNameSpace__ecere__com__eSystem_Delete(cppOptions), cppOptions = 0);
2862 SetSymbolsDir((((void *)0)));
2863 }
2864
2865 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass___ecereNameSpace__ecere__com__Module;
2866
2867 struct __ecereNameSpace__ecere__com__Module
2868 {
2869 struct __ecereNameSpace__ecere__com__Instance * application;
2870 struct __ecereNameSpace__ecere__sys__OldList classes;
2871 struct __ecereNameSpace__ecere__sys__OldList defines;
2872 struct __ecereNameSpace__ecere__sys__OldList functions;
2873 struct __ecereNameSpace__ecere__sys__OldList modules;
2874 struct __ecereNameSpace__ecere__com__Instance * prev;
2875 struct __ecereNameSpace__ecere__com__Instance * next;
2876 char *  name;
2877 void *  library;
2878 void *  Unload;
2879 int importType;
2880 int origImportType;
2881 struct __ecereNameSpace__ecere__com__NameSpace privateNameSpace;
2882 struct __ecereNameSpace__ecere__com__NameSpace publicNameSpace;
2883 } __attribute__ ((gcc_struct));
2884
2885 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass___ecereNameSpace__ecere__com__GlobalFunction;
2886
2887 struct __ecereNameSpace__ecere__com__GlobalFunction;
2888
2889 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);
2890
2891 void __ecereRegisterModule_ecp(struct __ecereNameSpace__ecere__com__Instance * module)
2892 {
2893 struct __ecereNameSpace__ecere__com__Class * class;
2894
2895 class = __ecereNameSpace__ecere__com__eSystem_RegisterClass(5, "ClassDefine", "Definition", sizeof(struct ClassDefine), 0, 0, 0, module, 2, 1);
2896 if(((struct __ecereNameSpace__ecere__com__Module *)(((char *)module + structSize_Instance)))->application == ((struct __ecereNameSpace__ecere__com__Module *)(((char *)__thisModule + structSize_Instance)))->application && class)
2897 __ecereClass_ClassDefine = class;
2898 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "base", "char *", arch_PointerSize, arch_PointerSize, 1);
2899 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "propertiesAndMembers", "ecere::sys::OldList", structSize_OldList, arch_PointerSize, 1);
2900 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "classProperties", "ecere::sys::OldList", structSize_OldList, arch_PointerSize, 1);
2901 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "methods", "ecere::sys::OldList", structSize_OldList, arch_PointerSize, 1);
2902 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "isRemote", "bool", 4, 4, 1);
2903 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "isWatchable", "bool", 4, 4, 1);
2904 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "fixed", "bool", 4, 4, 1);
2905 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "isStatic", "bool", 4, 4, 1);
2906 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "noExpansion", "bool", 4, 4, 1);
2907 class = __ecereNameSpace__ecere__com__eSystem_RegisterClass(5, "Define", "Definition", sizeof(struct Define), 0, 0, 0, module, 2, 1);
2908 if(((struct __ecereNameSpace__ecere__com__Module *)(((char *)module + structSize_Instance)))->application == ((struct __ecereNameSpace__ecere__com__Module *)(((char *)__thisModule + structSize_Instance)))->application && class)
2909 __ecereClass_Define = class;
2910 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "exp", "Expression", arch_PointerSize, arch_PointerSize, 1);
2911 class = __ecereNameSpace__ecere__com__eSystem_RegisterClass(5, "FunctionDefine", "Definition", sizeof(struct FunctionDefine), 0, 0, 0, module, 2, 1);
2912 if(((struct __ecereNameSpace__ecere__com__Module *)(((char *)module + structSize_Instance)))->application == ((struct __ecereNameSpace__ecere__com__Module *)(((char *)__thisModule + structSize_Instance)))->application && class)
2913 __ecereClass_FunctionDefine = class;
2914 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "dataType", "char *", arch_PointerSize, arch_PointerSize, 1);
2915 class = __ecereNameSpace__ecere__com__eSystem_RegisterClass(5, "DataDefine", "Definition", sizeof(struct DataDefine), 0, 0, 0, module, 2, 1);
2916 if(((struct __ecereNameSpace__ecere__com__Module *)(((char *)module + structSize_Instance)))->application == ((struct __ecereNameSpace__ecere__com__Module *)(((char *)__thisModule + structSize_Instance)))->application && class)
2917 __ecereClass_DataDefine = class;
2918 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "dataType", "char *", arch_PointerSize, arch_PointerSize, 1);
2919 class = __ecereNameSpace__ecere__com__eSystem_RegisterClass(5, "MethodDefine", 0, sizeof(struct MethodDefine), 0, 0, 0, module, 2, 1);
2920 if(((struct __ecereNameSpace__ecere__com__Module *)(((char *)module + structSize_Instance)))->application == ((struct __ecereNameSpace__ecere__com__Module *)(((char *)__thisModule + structSize_Instance)))->application && class)
2921 __ecereClass_MethodDefine = class;
2922 class = __ecereNameSpace__ecere__com__eSystem_RegisterClass(5, "PropertyDefine", 0, sizeof(struct PropertyDefine), 0, 0, 0, module, 2, 1);
2923 if(((struct __ecereNameSpace__ecere__com__Module *)(((char *)module + structSize_Instance)))->application == ((struct __ecereNameSpace__ecere__com__Module *)(((char *)__thisModule + structSize_Instance)))->application && class)
2924 __ecereClass_PropertyDefine = class;
2925 class = __ecereNameSpace__ecere__com__eSystem_RegisterClass(5, "DataMemberDefine", 0, sizeof(struct DataMemberDefine), 0, 0, 0, module, 2, 1);
2926 if(((struct __ecereNameSpace__ecere__com__Module *)(((char *)module + structSize_Instance)))->application == ((struct __ecereNameSpace__ecere__com__Module *)(((char *)__thisModule + structSize_Instance)))->application && class)
2927 __ecereClass_DataMemberDefine = class;
2928 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("FreeMethodDefine", "void FreeMethodDefine(MethodDefine method)", FreeMethodDefine, module, 2);
2929 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("FreeDataMemberDefine", "void FreeDataMemberDefine(DataMemberDefine dataMember)", FreeDataMemberDefine, module, 2);
2930 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("FreeDataDefine", "void FreeDataDefine(DataDefine data)", FreeDataDefine, module, 2);
2931 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("FreeDefinition", "void FreeDefinition(Definition definition)", FreeDefinition, module, 2);
2932 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("PreCompPreProcessClassDefinitions", "void PreCompPreProcessClassDefinitions(void)", PreCompPreProcessClassDefinitions, module, 2);
2933 class = __ecereNameSpace__ecere__com__eSystem_RegisterClass(0, "PrecompApp", "ecere::com::Application", 0, 0, 0, 0, module, 2, 1);
2934 if(((struct __ecereNameSpace__ecere__com__Module *)(((char *)module + structSize_Instance)))->application == ((struct __ecereNameSpace__ecere__com__Module *)(((char *)__thisModule + structSize_Instance)))->application && class)
2935 __ecereClass_PrecompApp = class;
2936 __ecereNameSpace__ecere__com__eClass_AddMethod(class, "Main", 0, __ecereMethod_PrecompApp_Main, 1);
2937 }
2938
2939 void __ecereUnregisterModule_ecp(struct __ecereNameSpace__ecere__com__Instance * module)
2940 {
2941
2942 }
2943
2944 int __ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_CompareString(struct __ecereNameSpace__ecere__sys__BinaryTree * this, char *  a, char *  b);
2945
2946 void __ecereCreateModuleInstances_ecp()
2947 {
2948 globalContext = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass_Context);
2949 (globalData.classes.CompareKey = (void *)__ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_CompareString, globalData.defines.CompareKey = (void *)__ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_CompareString, globalData.functions.CompareKey = (void *)__ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_CompareString, globalData.nameSpaces.CompareKey = (void *)__ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_CompareString);
2950 }
2951
2952 void __ecereDestroyModuleInstances_ecp()
2953 {
2954 ((globalContext ? (__ecereClass_Context->Destructor ? __ecereClass_Context->Destructor(globalContext) : 0, __ecereNameSpace__ecere__com__eSystem_Delete(globalContext)) : 0), globalContext = 0);
2955 }
2956