The Ecere SDK - sdk/blob - compiler/bootstrap/ecp/bootstrap/ecp.c

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