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 const 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 const 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 const 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 const 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 unsigned int casted : 1;
 695 } __attribute__ ((gcc_struct));
 696
 697 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass___ecereNameSpace__ecere__com__Class;
 698
 699 struct __ecereNameSpace__ecere__com__Class
 700 {
 701 struct __ecereNameSpace__ecere__com__Class * prev;
 702 struct __ecereNameSpace__ecere__com__Class * next;
 703 const char *  name;
 704 int offset;
 705 int structSize;
 706 int (* *  _vTbl)();
 707 int vTblSize;
 708 int (*  Constructor)(struct __ecereNameSpace__ecere__com__Instance *);
 709 void (*  Destructor)(struct __ecereNameSpace__ecere__com__Instance *);
 710 int offsetClass;
 711 int sizeClass;
 712 struct __ecereNameSpace__ecere__com__Class * base;
 713 struct __ecereNameSpace__ecere__sys__BinaryTree methods;
 714 struct __ecereNameSpace__ecere__sys__BinaryTree members;
 715 struct __ecereNameSpace__ecere__sys__BinaryTree prop;
 716 struct __ecereNameSpace__ecere__sys__OldList membersAndProperties;
 717 struct __ecereNameSpace__ecere__sys__BinaryTree classProperties;
 718 struct __ecereNameSpace__ecere__sys__OldList derivatives;
 719 int memberID;
 720 int startMemberID;
 721 int type;
 722 struct __ecereNameSpace__ecere__com__Instance * module;
 723 struct __ecereNameSpace__ecere__com__NameSpace *  nameSpace;
 724 const char *  dataTypeString;
 725 struct Type * dataType;
 726 int typeSize;
 727 int defaultAlignment;
 728 void (*  Initialize)();
 729 int memberOffset;
 730 struct __ecereNameSpace__ecere__sys__OldList selfWatchers;
 731 const char *  designerClass;
 732 unsigned int noExpansion;
 733 const char *  defaultProperty;
 734 unsigned int comRedefinition;
 735 int count;
 736 int isRemote;
 737 unsigned int internalDecl;
 738 void *  data;
 739 unsigned int computeSize;
 740 int structAlignment;
 741 int destructionWatchOffset;
 742 unsigned int fixed;
 743 struct __ecereNameSpace__ecere__sys__OldList delayedCPValues;
 744 int inheritanceAccess;
 745 const char *  fullName;
 746 void *  symbol;
 747 struct __ecereNameSpace__ecere__sys__OldList conversions;
 748 struct __ecereNameSpace__ecere__sys__OldList templateParams;
 749 struct __ecereNameSpace__ecere__com__ClassTemplateArgument *  templateArgs;
 750 struct __ecereNameSpace__ecere__com__Class * templateClass;
 751 struct __ecereNameSpace__ecere__sys__OldList templatized;
 752 int numParams;
 753 unsigned int isInstanceClass;
 754 unsigned int byValueSystemClass;
 755 } __attribute__ ((gcc_struct));
 756
 757 extern long long __ecereNameSpace__ecere__com__eClass_GetProperty(struct __ecereNameSpace__ecere__com__Class * _class, const char *  name);
 758
 759 extern void __ecereNameSpace__ecere__com__eClass_SetProperty(struct __ecereNameSpace__ecere__com__Class * _class, const char *  name, long long value);
 760
 761 extern void __ecereNameSpace__ecere__com__eInstance_FireSelfWatchers(struct __ecereNameSpace__ecere__com__Instance * instance, struct __ecereNameSpace__ecere__com__Property * _property);
 762
 763 extern void __ecereNameSpace__ecere__com__eInstance_SetMethod(struct __ecereNameSpace__ecere__com__Instance * instance, const char *  name, void *  function);
 764
 765 extern void __ecereNameSpace__ecere__com__eInstance_IncRef(struct __ecereNameSpace__ecere__com__Instance * instance);
 766
 767 extern void __ecereNameSpace__ecere__com__eInstance_StopWatching(struct __ecereNameSpace__ecere__com__Instance * instance, struct __ecereNameSpace__ecere__com__Property * _property, struct __ecereNameSpace__ecere__com__Instance * object);
 768
 769 extern void __ecereNameSpace__ecere__com__eInstance_Watch(void *  instance, struct __ecereNameSpace__ecere__com__Property * _property, void *  object, void (*  callback)(void * , void * ));
 770
 771 extern void __ecereNameSpace__ecere__com__eInstance_FireWatchers(struct __ecereNameSpace__ecere__com__Instance * instance, struct __ecereNameSpace__ecere__com__Property * _property);
 772
 773 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass___ecereNameSpace__ecere__com__Instance;
 774
 775 struct __ecereNameSpace__ecere__com__Instance
 776 {
 777 int (* *  _vTbl)();
 778 struct __ecereNameSpace__ecere__com__Class * _class;
 779 int _refCount;
 780 } __attribute__ ((gcc_struct));
 781
 782 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass___ecereNameSpace__ecere__com__DataMember;
 783
 784 struct __ecereNameSpace__ecere__com__DataMember
 785 {
 786 struct __ecereNameSpace__ecere__com__DataMember * prev;
 787 struct __ecereNameSpace__ecere__com__DataMember * next;
 788 const char *  name;
 789 unsigned int isProperty;
 790 int memberAccess;
 791 int id;
 792 struct __ecereNameSpace__ecere__com__Class * _class;
 793 const char *  dataTypeString;
 794 struct __ecereNameSpace__ecere__com__Class * dataTypeClass;
 795 struct Type * dataType;
 796 int type;
 797 int offset;
 798 int memberID;
 799 struct __ecereNameSpace__ecere__sys__OldList members;
 800 struct __ecereNameSpace__ecere__sys__BinaryTree membersAlpha;
 801 int memberOffset;
 802 int structAlignment;
 803 } __attribute__ ((gcc_struct));
 804
 805 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass___ecereNameSpace__ecere__com__SerialBuffer;
 806
 807 struct __ecereNameSpace__ecere__com__SerialBuffer
 808 {
 809 unsigned char *  _buffer;
 810 unsigned int count;
 811 unsigned int _size;
 812 unsigned int pos;
 813 } __attribute__ ((gcc_struct));
 814
 815 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass___ecereNameSpace__ecere__com__ClassTemplateArgument;
 816
 817 struct __ecereNameSpace__ecere__com__ClassTemplateArgument
 818 {
 819 union
 820 {
 821 struct
 822 {
 823 const char *  dataTypeString;
 824 struct __ecereNameSpace__ecere__com__Class * dataTypeClass;
 825 } __attribute__ ((gcc_struct));
 826 struct __ecereNameSpace__ecere__com__DataValue expression;
 827 struct
 828 {
 829 const char *  memberString;
 830 union
 831 {
 832 struct __ecereNameSpace__ecere__com__DataMember * member;
 833 struct __ecereNameSpace__ecere__com__Property * prop;
 834 struct __ecereNameSpace__ecere__com__Method * method;
 835 } __attribute__ ((gcc_struct));
 836 } __attribute__ ((gcc_struct));
 837 } __attribute__ ((gcc_struct));
 838 } __attribute__ ((gcc_struct));
 839
 840 enum yytokentype
 841 {
 842 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
 843 };
 844
 845 typedef union YYSTYPE
 846 {
 847 int specifierType;
 848 int i;
 849 int declMode;
 850 struct Identifier * id;
 851 struct Expression * exp;
 852 struct Specifier * specifier;
 853 struct __ecereNameSpace__ecere__sys__OldList * list;
 854 struct Enumerator * enumerator;
 855 struct Declarator * declarator;
 856 struct __ecereNameSpace__ecere__com__Instance * pointer;
 857 struct Initializer * initializer;
 858 struct InitDeclarator * initDeclarator;
 859 struct TypeName * typeName;
 860 struct Declaration * declaration;
 861 struct Statement * stmt;
 862 struct FunctionDefinition * function;
 863 struct External * external;
 864 struct Context * context;
 865 struct __ecereNameSpace__ecere__com__Instance * asmField;
 866 struct Attrib * attrib;
 867 struct ExtDecl * extDecl;
 868 struct Attribute * attribute;
 869 struct Instantiation * instance;
 870 struct MembersInit * membersInit;
 871 struct MemberInit * memberInit;
 872 struct ClassFunction * classFunction;
 873 struct ClassDefinition * _class;
 874 struct ClassDef * classDef;
 875 struct PropertyDef * prop;
 876 char * string;
 877 struct Symbol * symbol;
 878 struct PropertyWatch * propertyWatch;
 879 struct TemplateParameter * templateParameter;
 880 struct TemplateArgument * templateArgument;
 881 struct TemplateDatatype * templateDatatype;
 882 struct __ecereNameSpace__ecere__com__Instance * dbtableEntry;
 883 struct __ecereNameSpace__ecere__com__Instance * dbindexItem;
 884 struct DBTableDef * dbtableDef;
 885 } __attribute__ ((gcc_struct)) YYSTYPE;
 886
 887 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_Enumerator;
 888
 889 struct Enumerator
 890 {
 891 struct Enumerator * prev;
 892 struct Enumerator * next;
 893 struct Location loc;
 894 struct Identifier * id;
 895 struct Expression * exp;
 896 } __attribute__ ((gcc_struct));
 897
 898 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_InitDeclarator;
 899
 900 struct InitDeclarator
 901 {
 902 struct InitDeclarator * prev;
 903 struct InitDeclarator * next;
 904 struct Location loc;
 905 struct Declarator * declarator;
 906 struct Initializer * initializer;
 907 } __attribute__ ((gcc_struct));
 908
 909 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_Attribute;
 910
 911 struct Attribute;
 912
 913 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_ClassFunction;
 914
 915 struct ClassFunction
 916 {
 917 struct ClassFunction * prev;
 918 struct ClassFunction * next;
 919 struct Location loc;
 920 struct __ecereNameSpace__ecere__sys__OldList *  specifiers;
 921 struct Declarator * declarator;
 922 struct __ecereNameSpace__ecere__sys__OldList *  declarations;
 923 struct Statement * body;
 924 struct __ecereNameSpace__ecere__com__Class * _class;
 925 struct __ecereNameSpace__ecere__sys__OldList attached;
 926 int declMode;
 927 struct Type * type;
 928 struct Symbol * propSet;
 929 unsigned int isVirtual;
 930 unsigned int isConstructor;
 931 unsigned int isDestructor;
 932 unsigned int dontMangle;
 933 int id;
 934 int idCode;
 935 } __attribute__ ((gcc_struct));
 936
 937 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_MembersInit;
 938
 939 struct MembersInit;
 940
 941 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_MemberInit;
 942
 943 struct MemberInit;
 944
 945 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_PropertyDef;
 946
 947 struct PropertyDef
 948 {
 949 struct PropertyDef * prev;
 950 struct PropertyDef * next;
 951 struct Location loc;
 952 struct __ecereNameSpace__ecere__sys__OldList *  specifiers;
 953 struct Declarator * declarator;
 954 struct Identifier * id;
 955 struct Statement * getStmt;
 956 struct Statement * setStmt;
 957 struct Statement * issetStmt;
 958 struct Symbol * symbol;
 959 struct Expression * category;
 960 struct
 961 {
 962 unsigned int conversion : 1;
 963 unsigned int isWatchable : 1;
 964 unsigned int isDBProp : 1;
 965 } __attribute__ ((gcc_struct));
 966 } __attribute__ ((gcc_struct));
 967
 968 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_PropertyWatch;
 969
 970 struct PropertyWatch;
 971
 972 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_ClassDef;
 973
 974 struct ClassDef
 975 {
 976 struct ClassDef * prev;
 977 struct ClassDef * next;
 978 struct Location loc;
 979 int type;
 980 union
 981 {
 982 struct Declaration * decl;
 983 struct ClassFunction * function;
 984 struct __ecereNameSpace__ecere__sys__OldList *  defProperties;
 985 struct PropertyDef * propertyDef;
 986 struct PropertyWatch * propertyWatch;
 987 char *  designer;
 988 struct Identifier * defaultProperty;
 989 struct
 990 {
 991 struct Identifier * id;
 992 struct Initializer * initializer;
 993 } __attribute__ ((gcc_struct));
 994 } __attribute__ ((gcc_struct));
 995 int memberAccess;
 996 void *  object;
 997 } __attribute__ ((gcc_struct));
 998
 999 extern YYSTYPE yylval;
1000
1001 extern struct Location yylloc;
1002
1003 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_Definition;
1004
1005 struct Definition
1006 {
1007 struct Definition * prev;
1008 struct Definition * next;
1009 char *  name;
1010 int type;
1011 } __attribute__ ((gcc_struct));
1012
1013 struct ClassDefine
1014 {
1015 struct Definition * prev;
1016 struct Definition * next;
1017 char *  name;
1018 int type;
1019 char * base;
1020 struct __ecereNameSpace__ecere__sys__OldList propertiesAndMembers;
1021 struct __ecereNameSpace__ecere__sys__OldList classProperties;
1022 struct __ecereNameSpace__ecere__sys__OldList methods;
1023 unsigned int isRemote;
1024 unsigned int isWatchable;
1025 unsigned int fixed;
1026 unsigned int isStatic;
1027 unsigned int noExpansion;
1028 } __attribute__ ((gcc_struct));
1029
1030 static struct __ecereNameSpace__ecere__com__Class * __ecereClass_ClassDefine;
1031
1032 struct Define
1033 {
1034 struct Definition * prev;
1035 struct Definition * next;
1036 char *  name;
1037 int type;
1038 struct Expression * exp;
1039 } __attribute__ ((gcc_struct));
1040
1041 static struct __ecereNameSpace__ecere__com__Class * __ecereClass_Define;
1042
1043 struct FunctionDefine
1044 {
1045 struct Definition * prev;
1046 struct Definition * next;
1047 char *  name;
1048 int type;
1049 char * dataType;
1050 } __attribute__ ((gcc_struct));
1051
1052 static struct __ecereNameSpace__ecere__com__Class * __ecereClass_FunctionDefine;
1053
1054 struct DataDefine
1055 {
1056 struct Definition * prev;
1057 struct Definition * next;
1058 char *  name;
1059 int type;
1060 char * dataType;
1061 } __attribute__ ((gcc_struct));
1062
1063 static struct __ecereNameSpace__ecere__com__Class * __ecereClass_DataDefine;
1064
1065 struct MethodDefine
1066 {
1067 struct MethodDefine * prev, * next;
1068 char * name;
1069 int memberAccess;
1070 char * type;
1071 unsigned int isVirtual;
1072 } __attribute__ ((gcc_struct));
1073
1074 static struct __ecereNameSpace__ecere__com__Class * __ecereClass_MethodDefine;
1075
1076 struct PropertyDefine
1077 {
1078 struct PropertyDefine * prev, * next;
1079 char * name;
1080 int isProperty;
1081 char * type;
1082 unsigned int isWatchable;
1083 int memberAccess;
1084 unsigned int isVirtual;
1085 unsigned int hasSet, hasGet;
1086 } __attribute__ ((gcc_struct));
1087
1088 static struct __ecereNameSpace__ecere__com__Class * __ecereClass_PropertyDefine;
1089
1090 struct DataMemberDefine
1091 {
1092 struct DataMemberDefine * prev, * next;
1093 char * name;
1094 int isProperty;
1095 char * type;
1096 struct __ecereNameSpace__ecere__sys__OldList dataMembers;
1097 struct __ecereNameSpace__ecere__sys__OldList classProperties;
1098 int memberAccess;
1099 int memberType;
1100 int size, bitPos;
1101 } __attribute__ ((gcc_struct));
1102
1103 static struct __ecereNameSpace__ecere__com__Class * __ecereClass_DataMemberDefine;
1104
1105 void FreeMethodDefine(struct MethodDefine * method)
1106 {
1107 (__ecereNameSpace__ecere__com__eSystem_Delete(method->name), method->name = 0);
1108 (__ecereNameSpace__ecere__com__eSystem_Delete(method->type), method->type = 0);
1109 }
1110
1111 void FreeDataMemberDefine(struct DataMemberDefine * dataMember)
1112 {
1113 (__ecereNameSpace__ecere__com__eSystem_Delete(dataMember->name), dataMember->name = 0);
1114 (__ecereNameSpace__ecere__com__eSystem_Delete(dataMember->type), dataMember->type = 0);
1115 }
1116
1117 void FreeDataDefine(struct DataDefine * data)
1118 {
1119 (__ecereNameSpace__ecere__com__eSystem_Delete(data->name), data->name = 0);
1120 (__ecereNameSpace__ecere__com__eSystem_Delete(data->type), data->type = 0);
1121 }
1122
1123 void __ecereMethod___ecereNameSpace__ecere__sys__OldList_Free(struct __ecereNameSpace__ecere__sys__OldList * this, void (*  freeFn)(void * ));
1124
1125 void FreeDefinition(struct Definition * definition)
1126 {
1127 (__ecereNameSpace__ecere__com__eSystem_Delete(definition->name), definition->name = 0);
1128 switch(definition->type)
1129 {
1130 case 1:
1131 {
1132 struct ClassDefine * classDefine = (struct ClassDefine *)definition;
1133
1134 (__ecereNameSpace__ecere__com__eSystem_Delete(classDefine->base), classDefine->base = 0);
1135 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Free(&classDefine->methods, FreeMethodDefine);
1136 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Free(&classDefine->propertiesAndMembers, FreeDataMemberDefine);
1137 break;
1138 }
1139 case 3:
1140 (__ecereNameSpace__ecere__com__eSystem_Delete(((struct FunctionDefine *)definition)->dataType), ((struct FunctionDefine *)definition)->dataType = 0);
1141 break;
1142 case 4:
1143 (__ecereNameSpace__ecere__com__eSystem_Delete(((struct DataDefine *)definition)->dataType), ((struct DataDefine *)definition)->dataType = 0);
1144 break;
1145 case 2:
1146 break;
1147 }
1148 }
1149
1150 static unsigned int globalInstance = 0x0;
1151
1152 static struct Context * globalContext;
1153
1154 static struct __ecereNameSpace__ecere__sys__OldList defines, imports, precompDefines;
1155
1156 static struct __ecereNameSpace__ecere__com__Instance * privateModule;
1157
1158 struct __ecereNameSpace__ecere__sys__OldList _excludedSymbols =
1159 {
1160 0, 0, 0, (unsigned int)&((struct Symbol *)(void * )0)->left, 0
1161 };
1162
1163 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass___ecereNameSpace__ecere__com__NameSpace;
1164
1165 struct __ecereNameSpace__ecere__com__NameSpace
1166 {
1167 const char *  name;
1168 struct __ecereNameSpace__ecere__com__NameSpace *  btParent;
1169 struct __ecereNameSpace__ecere__com__NameSpace *  left;
1170 struct __ecereNameSpace__ecere__com__NameSpace *  right;
1171 int depth;
1172 struct __ecereNameSpace__ecere__com__NameSpace *  parent;
1173 struct __ecereNameSpace__ecere__sys__BinaryTree nameSpaces;
1174 struct __ecereNameSpace__ecere__sys__BinaryTree classes;
1175 struct __ecereNameSpace__ecere__sys__BinaryTree defines;
1176 struct __ecereNameSpace__ecere__sys__BinaryTree functions;
1177 } __attribute__ ((gcc_struct));
1178
1179 static struct __ecereNameSpace__ecere__com__NameSpace globalData;
1180
1181 extern struct Identifier * GetDeclId(struct Declarator * decl);
1182
1183 extern char *  __ecereNameSpace__ecere__sys__CopyString(const char *  string);
1184
1185 extern void ProcessExpressionType(struct Expression * exp);
1186
1187 extern void ComputeExpression(struct Expression * exp);
1188
1189 extern int strtol(const char * , char * * , int base);
1190
1191 extern void FreeExpression(struct Expression * exp);
1192
1193 extern struct Type * ProcessType(struct __ecereNameSpace__ecere__sys__OldList * specs, struct Declarator * decl);
1194
1195 extern void PrintType(struct Type * type, char *  string, unsigned int printName, unsigned int fullName);
1196
1197 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass___ecereNameSpace__ecere__com__BitMember;
1198
1199 struct __ecereNameSpace__ecere__com__BitMember
1200 {
1201 struct __ecereNameSpace__ecere__com__BitMember * prev;
1202 struct __ecereNameSpace__ecere__com__BitMember * next;
1203 const char *  name;
1204 unsigned int isProperty;
1205 int memberAccess;
1206 int id;
1207 struct __ecereNameSpace__ecere__com__Class * _class;
1208 const char *  dataTypeString;
1209 struct __ecereNameSpace__ecere__com__Class * dataTypeClass;
1210 struct Type * dataType;
1211 int type;
1212 int size;
1213 int pos;
1214 uint64 mask;
1215 } __attribute__ ((gcc_struct));
1216
1217 extern struct __ecereNameSpace__ecere__com__BitMember * __ecereNameSpace__ecere__com__eClass_AddBitMember(struct __ecereNameSpace__ecere__com__Class * _class, const char *  name, const char *  type, int bitSize, int bitPos, int declMode);
1218
1219 extern struct __ecereNameSpace__ecere__com__DataMember * __ecereNameSpace__ecere__com__eMember_AddDataMember(struct __ecereNameSpace__ecere__com__DataMember * member, const char *  name, const char *  type, unsigned int size, unsigned int alignment, int declMode);
1220
1221 extern struct __ecereNameSpace__ecere__com__DataMember * __ecereNameSpace__ecere__com__eClass_AddDataMember(struct __ecereNameSpace__ecere__com__Class * _class, const char *  name, const char *  type, unsigned int size, unsigned int alignment, int declMode);
1222
1223 extern struct __ecereNameSpace__ecere__com__DataMember * __ecereNameSpace__ecere__com__eMember_New(int type, int declMode);
1224
1225 extern unsigned int __ecereNameSpace__ecere__com__eMember_AddMember(struct __ecereNameSpace__ecere__com__DataMember * addTo, struct __ecereNameSpace__ecere__com__DataMember * dataMember);
1226
1227 extern unsigned int __ecereNameSpace__ecere__com__eClass_AddMember(struct __ecereNameSpace__ecere__com__Class * _class, struct __ecereNameSpace__ecere__com__DataMember * dataMember);
1228
1229 extern struct __ecereNameSpace__ecere__sys__OldList *  MkListOne(void *  item);
1230
1231 extern struct Declarator * MkDeclaratorIdentifier(struct Identifier * id);
1232
1233 extern char *  StringFromSpecDecl(struct __ecereNameSpace__ecere__sys__OldList * specs, struct Declarator * decl);
1234
1235 extern struct __ecereNameSpace__ecere__com__Property * __ecereNameSpace__ecere__com__eClass_AddProperty(struct __ecereNameSpace__ecere__com__Class * _class, const char *  name, const char *  dataType, void *  setStmt, void *  getStmt, int declMode);
1236
1237 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass___ecereNameSpace__ecere__com__ClassProperty;
1238
1239 struct __ecereNameSpace__ecere__com__ClassProperty
1240 {
1241 const char *  name;
1242 struct __ecereNameSpace__ecere__com__ClassProperty * parent;
1243 struct __ecereNameSpace__ecere__com__ClassProperty * left;
1244 struct __ecereNameSpace__ecere__com__ClassProperty * right;
1245 int depth;
1246 void (*  Set)(struct __ecereNameSpace__ecere__com__Class *, long long);
1247 long long (*  Get)(struct __ecereNameSpace__ecere__com__Class *);
1248 const char *  dataTypeString;
1249 struct Type * dataType;
1250 unsigned int constant;
1251 } __attribute__ ((gcc_struct));
1252
1253 extern struct __ecereNameSpace__ecere__com__ClassProperty * __ecereNameSpace__ecere__com__eClass_AddClassProperty(struct __ecereNameSpace__ecere__com__Class * _class, const char *  name, const char *  dataType, void *  setStmt, void *  getStmt);
1254
1255 extern struct __ecereNameSpace__ecere__com__Property * __ecereNameSpace__ecere__com__eClass_FindProperty(struct __ecereNameSpace__ecere__com__Class * _class, const char *  name, struct __ecereNameSpace__ecere__com__Instance * module);
1256
1257 extern struct __ecereNameSpace__ecere__com__DataMember * __ecereNameSpace__ecere__com__eClass_FindDataMember(struct __ecereNameSpace__ecere__com__Class * _class, const char *  name, struct __ecereNameSpace__ecere__com__Instance * module, struct __ecereNameSpace__ecere__com__DataMember **  subMemberStack, int *  subMemberStackPos);
1258
1259 extern void *  __ecereNameSpace__ecere__com__eInstance_New(struct __ecereNameSpace__ecere__com__Class * _class);
1260
1261 void __ecereMethod___ecereNameSpace__ecere__sys__OldList_Add(struct __ecereNameSpace__ecere__sys__OldList * this, void *  item);
1262
1263 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)
1264 {
1265 if(definitions != (((void *)0)))
1266 {
1267 struct ClassDef * def;
1268
1269 for(def = definitions->first; def; def = def->next)
1270 {
1271 if(def->type == 2)
1272 {
1273 struct Declaration * decl = def->decl;
1274 struct __ecereNameSpace__ecere__com__DataMember * dataMember;
1275 struct Type * dataType;
1276 struct DataMemberDefine * dataMemberDefine;
1277
1278 if(decl->type == 0)
1279 {
1280 struct Declarator * d;
1281
1282 if(decl->declarators)
1283 {
1284 for(d = (*decl->declarators).first; d; d = d->next)
1285 {
1286 struct Identifier * declId = GetDeclId(d);
1287
1288 if(declId)
1289 {
1290 dataMemberDefine = __extension__ ({
1291 struct DataMemberDefine * __ecereInstance1 = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass_DataMemberDefine);
1292
1293 __ecereInstance1->isProperty = 3, __ecereInstance1->memberType = 0, __ecereInstance1->name = __ecereNameSpace__ecere__sys__CopyString(declId->string), __ecereInstance1;
1294 });
1295 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Add(&parentMemberDefine->dataMembers, dataMemberDefine);
1296 if(regClass && regClass->type == 2)
1297 {
1298 struct Expression * sizeExp = d->structDecl.exp, * posExp = d->structDecl.posExp;
1299 int bitSize = 0, bitPos = -1;
1300 char dataTypeString[1024];
1301
1302 dataTypeString[0] = '\0';
1303 if(sizeExp)
1304 {
1305 ProcessExpressionType(sizeExp);
1306 ComputeExpression(sizeExp);
1307 if(sizeExp->isConstant)
1308 bitSize = strtol(sizeExp->constant, (((void *)0)), 0);
1309 FreeExpression(sizeExp);
1310 }
1311 if(posExp)
1312 {
1313 ProcessExpressionType(posExp);
1314 ComputeExpression(posExp);
1315 if(posExp->isConstant)
1316 bitPos = strtol(posExp->constant, (((void *)0)), 0);
1317 FreeExpression(posExp);
1318 }
1319 d->structDecl.exp = (((void *)0));
1320 d->structDecl.posExp = (((void *)0));
1321 dataType = ProcessType(decl->specifiers, d);
1322 PrintType(dataType, dataTypeString, 0x0, 0x1);
1323 {
1324 struct __ecereNameSpace__ecere__com__BitMember * member = __ecereNameSpace__ecere__com__eClass_AddBitMember(regClass, declId->string, dataTypeString, 0, 0, def->memberAccess);
1325
1326 member->size = bitSize;
1327 member->pos = bitPos;
1328 dataMember = (struct __ecereNameSpace__ecere__com__DataMember *)member;
1329 }
1330 if(dataMember)
1331 dataMember->dataType = dataType;
1332 dataMemberDefine->size = bitSize;
1333 dataMemberDefine->bitPos = bitPos;
1334 dataMemberDefine->type = __ecereNameSpace__ecere__sys__CopyString(dataTypeString);
1335 }
1336 else
1337 {
1338 {
1339 char typeString[1024];
1340
1341 typeString[0] = '\0';
1342 dataType = ProcessType(decl->specifiers, d);
1343 PrintType(dataType, typeString, 0x0, 0x1);
1344 if(member)
1345 dataMember = __ecereNameSpace__ecere__com__eMember_AddDataMember(member, declId->string, typeString, 0, 0, def->memberAccess);
1346 else
1347 dataMember = __ecereNameSpace__ecere__com__eClass_AddDataMember(regClass, declId->string, typeString, 0, 0, def->memberAccess);
1348 if(dataMember)
1349 dataMember->dataType = dataType;
1350 dataMemberDefine->type = __ecereNameSpace__ecere__sys__CopyString(typeString);
1351 }
1352 }
1353 dataMemberDefine->memberAccess = def->memberAccess;
1354 }
1355 }
1356 }
1357 else if(decl->specifiers)
1358 {
1359 struct Specifier * spec;
1360
1361 for(spec = (*decl->specifiers).first; spec; spec = spec->next)
1362 {
1363 if(spec->type == 3 || spec->type == 4)
1364 {
1365 if(spec->definitions && !spec->id)
1366 {
1367 struct __ecereNameSpace__ecere__com__DataMember * dataMember = __ecereNameSpace__ecere__com__eMember_New((spec->type == 4) ? 1 : 2, def->memberAccess);
1368
1369 dataMemberDefine = __extension__ ({
1370 struct DataMemberDefine * __ecereInstance1 = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass_DataMemberDefine);
1371
1372 __ecereInstance1->isProperty = 3, __ecereInstance1->memberType = (spec->type == 4) ? 1 : 2, __ecereInstance1;
1373 });
1374 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Add(&parentMemberDefine->dataMembers, dataMemberDefine);
1375 AddDefinitions((((void *)0)), dataMemberDefine, (((void *)0)), dataMember, spec->definitions);
1376 if(member)
1377 __ecereNameSpace__ecere__com__eMember_AddMember(member, dataMember);
1378 else
1379 __ecereNameSpace__ecere__com__eClass_AddMember(regClass, dataMember);
1380 }
1381 else if(spec->definitions && spec->id && (*spec->definitions).count)
1382 {
1383 {
1384 struct Identifier * id = spec->id;
1385 char typeString[1024];
1386
1387 typeString[0] = '\0';
1388 spec->id = (((void *)0));
1389 decl->declarators = MkListOne(MkDeclaratorIdentifier(id));
1390 dataType = ProcessType(decl->specifiers, (((void *)0)));
1391 PrintType(dataType, typeString, 0x0, 0x1);
1392 if(member)
1393 dataMember = __ecereNameSpace__ecere__com__eMember_AddDataMember(member, id->string, typeString, 0, 0, def->memberAccess);
1394 else
1395 dataMember = __ecereNameSpace__ecere__com__eClass_AddDataMember(regClass, id->string, typeString, 0, 0, def->memberAccess);
1396 if(dataMember)
1397 dataMember->dataType = dataType;
1398 }
1399 }
1400 }
1401 }
1402 }
1403 }
1404 else if(decl->type == 2)
1405 {
1406 struct Instantiation * inst = decl->inst;
1407 struct Expression * exp = inst->exp;
1408
1409 if(exp)
1410 {
1411 {
1412 char * string = exp->identifier->string;
1413
1414 {
1415 struct Type * dataType = (dataType = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass_Type), dataType->kind = 8, dataType->_class = inst->_class->symbol, dataType->refCount = 1, dataType);
1416
1417 if(member)
1418 dataMember = __ecereNameSpace__ecere__com__eMember_AddDataMember(member, string, inst->_class->name, 0, 0, def->memberAccess);
1419 else
1420 dataMember = __ecereNameSpace__ecere__com__eClass_AddDataMember(regClass, string, inst->_class->name, 0, 0, def->memberAccess);
1421 if(dataMember)
1422 dataMember->dataType = dataType;
1423 }
1424 dataMemberDefine = __extension__ ({
1425 struct DataMemberDefine * __ecereInstance1 = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass_DataMemberDefine);
1426
1427 __ecereInstance1->isProperty = 3, __ecereInstance1->memberType = 0, __ecereInstance1->name = __ecereNameSpace__ecere__sys__CopyString(string), __ecereInstance1->type = __ecereNameSpace__ecere__sys__CopyString(inst->_class->name), __ecereInstance1;
1428 });
1429 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Add(&parentMemberDefine->dataMembers, dataMemberDefine);
1430 }
1431 }
1432 }
1433 }
1434 else if(def->type == 3 && def->propertyDef)
1435 {
1436 struct PropertyDef * propertyDef = def->propertyDef;
1437
1438 {
1439 struct __ecereNameSpace__ecere__com__Property * prop;
1440 struct PropertyDefine * propDefine;
1441
1442 {
1443 char * dataTypeString = StringFromSpecDecl(propertyDef->specifiers, propertyDef->declarator);
1444
1445 prop = __ecereNameSpace__ecere__com__eClass_AddProperty(regClass, propertyDef->conversion ? (((void *)0)) : propertyDef->id->string, dataTypeString, propertyDef->setStmt, propertyDef->getStmt, def->memberAccess);
1446 if(prop)
1447 {
1448 prop->IsSet = (void *)propertyDef->issetStmt;
1449 prop->compiled = 0x0;
1450 }
1451 (__ecereNameSpace__ecere__com__eSystem_Delete(dataTypeString), dataTypeString = 0);
1452 }
1453 if(prop)
1454 {
1455 prop->symbol = __extension__ ({
1456 struct Symbol * __ecereInstance1 = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass_Symbol);
1457
1458 __ecereInstance1->string = __ecereNameSpace__ecere__sys__CopyString(propertyDef->symbol->string), __ecereInstance1->id = propertyDef->symbol->id, __ecereInstance1->type = propertyDef->symbol->type, __ecereInstance1;
1459 });
1460 if(propertyDef->symbol->type)
1461 propertyDef->symbol->type->refCount++;
1462 propDefine = __extension__ ({
1463 struct PropertyDefine * __ecereInstance1 = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass_PropertyDefine);
1464
1465 __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;
1466 });
1467 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Add(&classDefine->propertiesAndMembers, propDefine);
1468 }
1469 }
1470 }
1471 else if(def->type == 10 && def->propertyDef)
1472 {
1473 struct PropertyDef * propertyDef = def->propertyDef;
1474
1475 {
1476 struct __ecereNameSpace__ecere__com__ClassProperty * prop;
1477 struct PropertyDefine * propDefine;
1478
1479 {
1480 char * dataTypeString = StringFromSpecDecl(propertyDef->specifiers, propertyDef->declarator);
1481
1482 prop = __ecereNameSpace__ecere__com__eClass_AddClassProperty(regClass, propertyDef->id->string, dataTypeString, propertyDef->setStmt, propertyDef->getStmt);
1483 (__ecereNameSpace__ecere__com__eSystem_Delete(dataTypeString), dataTypeString = 0);
1484 }
1485 if(prop)
1486 {
1487 propDefine = __extension__ ({
1488 struct PropertyDefine * __ecereInstance1 = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass_PropertyDefine);
1489
1490 __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;
1491 });
1492 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Add(&classDefine->classProperties, propDefine);
1493 }
1494 }
1495 }
1496 else if(def->type == 7)
1497 {
1498 if(classDefine)
1499 classDefine->fixed = 0x1;
1500 }
1501 else if(def->type == 6)
1502 {
1503 if(classDefine)
1504 classDefine->noExpansion = 0x1;
1505 }
1506 else if(def->type == 13)
1507 {
1508 struct __ecereNameSpace__ecere__com__DataMember * member;
1509 struct __ecereNameSpace__ecere__com__Property * prop;
1510 struct __ecereNameSpace__ecere__com__Method * method;
1511
1512 if((prop = __ecereNameSpace__ecere__com__eClass_FindProperty(regClass, def->id->string, privateModule)))
1513 {
1514 struct PropertyDefine * propDefine;
1515
1516 prop = __ecereNameSpace__ecere__com__eClass_AddProperty(regClass, def->id->string, (((void *)0)), (((void *)0)), (((void *)0)), def->memberAccess);
1517 if(prop)
1518 {
1519 propDefine = __extension__ ({
1520 struct PropertyDefine * __ecereInstance1 = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass_PropertyDefine);
1521
1522 __ecereInstance1->isProperty = 1, __ecereInstance1->name = __ecereNameSpace__ecere__sys__CopyString(prop->name), __ecereInstance1->memberAccess = def->memberAccess, __ecereInstance1;
1523 });
1524 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Add(&classDefine->propertiesAndMembers, propDefine);
1525 }
1526 }
1527 else if((member = __ecereNameSpace__ecere__com__eClass_FindDataMember(regClass, def->id->string, privateModule, (((void *)0)), (((void *)0)))))
1528 {
1529 struct DataMemberDefine * dataMemberDefine;
1530
1531 member = __ecereNameSpace__ecere__com__eClass_AddDataMember(regClass, def->id->string, (((void *)0)), 0, 0, def->memberAccess);
1532 dataMemberDefine = __extension__ ({
1533 struct DataMemberDefine * __ecereInstance1 = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass_DataMemberDefine);
1534
1535 __ecereInstance1->isProperty = 3, __ecereInstance1->memberType = 0, __ecereInstance1->name = __ecereNameSpace__ecere__sys__CopyString(def->id->string), __ecereInstance1->memberAccess = def->memberAccess, __ecereInstance1;
1536 });
1537 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Add(&parentMemberDefine->dataMembers, dataMemberDefine);
1538 }
1539 }
1540 }
1541 }
1542 }
1543
1544 extern void FreeType(struct Type * type);
1545
1546 extern struct __ecereNameSpace__ecere__com__Class * __ecereNameSpace__ecere__com__eSystem_RegisterClass(int type, const char *  name, const char *  baseName, int size, int sizeClass, unsigned int (*  Constructor)(void * ), void (*  Destructor)(void * ), struct __ecereNameSpace__ecere__com__Instance * module, int declMode, int inheritanceAccess);
1547
1548 extern struct __ecereNameSpace__ecere__com__Method * __ecereNameSpace__ecere__com__eClass_AddVirtualMethod(struct __ecereNameSpace__ecere__com__Class * _class, const char *  name, const char *  type, void *  function, int declMode);
1549
1550 extern struct __ecereNameSpace__ecere__com__Method * __ecereNameSpace__ecere__com__eClass_AddMethod(struct __ecereNameSpace__ecere__com__Class * _class, const char *  name, const char *  type, void *  function, int declMode);
1551
1552 extern struct __ecereNameSpace__ecere__com__Method * __ecereNameSpace__ecere__com__eClass_FindMethod(struct __ecereNameSpace__ecere__com__Class * _class, const char *  name, struct __ecereNameSpace__ecere__com__Instance * module);
1553
1554 extern char *  strcpy(char * , const char * );
1555
1556 extern char *  strcat(char * , const char * );
1557
1558 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_OpTable;
1559
1560 struct OpTable
1561 {
1562 unsigned int (*  Add)(struct Expression *, struct Operand *, struct Operand *);
1563 unsigned int (*  Sub)(struct Expression *, struct Operand *, struct Operand *);
1564 unsigned int (*  Mul)(struct Expression *, struct Operand *, struct Operand *);
1565 unsigned int (*  Div)(struct Expression *, struct Operand *, struct Operand *);
1566 unsigned int (*  Mod)(struct Expression *, struct Operand *, struct Operand *);
1567 unsigned int (*  Neg)(struct Expression *, struct Operand *);
1568 unsigned int (*  Inc)(struct Expression *, struct Operand *);
1569 unsigned int (*  Dec)(struct Expression *, struct Operand *);
1570 unsigned int (*  Asign)(struct Expression *, struct Operand *, struct Operand *);
1571 unsigned int (*  AddAsign)(struct Expression *, struct Operand *, struct Operand *);
1572 unsigned int (*  SubAsign)(struct Expression *, struct Operand *, struct Operand *);
1573 unsigned int (*  MulAsign)(struct Expression *, struct Operand *, struct Operand *);
1574 unsigned int (*  DivAsign)(struct Expression *, struct Operand *, struct Operand *);
1575 unsigned int (*  ModAsign)(struct Expression *, struct Operand *, struct Operand *);
1576 unsigned int (*  BitAnd)(struct Expression *, struct Operand *, struct Operand *);
1577 unsigned int (*  BitOr)(struct Expression *, struct Operand *, struct Operand *);
1578 unsigned int (*  BitXor)(struct Expression *, struct Operand *, struct Operand *);
1579 unsigned int (*  LShift)(struct Expression *, struct Operand *, struct Operand *);
1580 unsigned int (*  RShift)(struct Expression *, struct Operand *, struct Operand *);
1581 unsigned int (*  BitNot)(struct Expression *, struct Operand *);
1582 unsigned int (*  AndAsign)(struct Expression *, struct Operand *, struct Operand *);
1583 unsigned int (*  OrAsign)(struct Expression *, struct Operand *, struct Operand *);
1584 unsigned int (*  XorAsign)(struct Expression *, struct Operand *, struct Operand *);
1585 unsigned int (*  LShiftAsign)(struct Expression *, struct Operand *, struct Operand *);
1586 unsigned int (*  RShiftAsign)(struct Expression *, struct Operand *, struct Operand *);
1587 unsigned int (*  Not)(struct Expression *, struct Operand *);
1588 unsigned int (*  Equ)(struct Expression *, struct Operand *, struct Operand *);
1589 unsigned int (*  Nqu)(struct Expression *, struct Operand *, struct Operand *);
1590 unsigned int (*  And)(struct Expression *, struct Operand *, struct Operand *);
1591 unsigned int (*  Or)(struct Expression *, struct Operand *, struct Operand *);
1592 unsigned int (*  Grt)(struct Expression *, struct Operand *, struct Operand *);
1593 unsigned int (*  Sma)(struct Expression *, struct Operand *, struct Operand *);
1594 unsigned int (*  GrtEqu)(struct Expression *, struct Operand *, struct Operand *);
1595 unsigned int (*  SmaEqu)(struct Expression *, struct Operand *, struct Operand *);
1596 unsigned int (*  Cond)(struct Expression *, struct Operand *, struct Operand *, struct Operand *);
1597 } __attribute__ ((gcc_struct));
1598
1599 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_Operand;
1600
1601 struct Operand
1602 {
1603 int kind;
1604 struct Type * type;
1605 unsigned int ptrSize;
1606 union
1607 {
1608 char c;
1609 unsigned char uc;
1610 short s;
1611 unsigned short us;
1612 int i;
1613 unsigned int ui;
1614 float f;
1615 double d;
1616 long long i64;
1617 uint64 ui64;
1618 } __attribute__ ((gcc_struct));
1619 struct OpTable ops;
1620 } __attribute__ ((gcc_struct));
1621
1622 extern struct Operand GetOperand(struct Expression * exp);
1623
1624 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass___ecereNameSpace__ecere__com__ClassTemplateParameter;
1625
1626 struct __ecereNameSpace__ecere__com__ClassTemplateParameter
1627 {
1628 struct __ecereNameSpace__ecere__com__ClassTemplateParameter * prev;
1629 struct __ecereNameSpace__ecere__com__ClassTemplateParameter * next;
1630 const char *  name;
1631 int type;
1632 union
1633 {
1634 const char *  dataTypeString;
1635 int memberType;
1636 } __attribute__ ((gcc_struct));
1637 struct __ecereNameSpace__ecere__com__ClassTemplateArgument defaultArg;
1638 void *  param;
1639 } __attribute__ ((gcc_struct));
1640
1641 extern struct __ecereNameSpace__ecere__com__ClassTemplateParameter * __ecereNameSpace__ecere__com__eClass_AddTemplateParameter(struct __ecereNameSpace__ecere__com__Class * _class, const char *  name, int type, const void *  info, struct __ecereNameSpace__ecere__com__ClassTemplateArgument * defaultArg);
1642
1643 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)
1644 {
1645 struct __ecereNameSpace__ecere__com__Class * regClass;
1646 struct ClassDef * def;
1647 struct ClassDefine * classDefine;
1648 char baseName[1024];
1649 unsigned int unitType = 0x0;
1650 unsigned int wouldBeEnum = 0x0;
1651 int inheritanceAccess = 1;
1652
1653 baseName[0] = '\0';
1654 if(baseSpecs != (((void *)0)))
1655 {
1656 struct Type * baseType = ProcessType(baseSpecs, (((void *)0)));
1657
1658 PrintType(baseType, baseName, 0x0, 0x1);
1659 if(baseType->kind == 8)
1660 {
1661 if(baseType->_class->registered && classType == 0)
1662 {
1663 if(baseType->_class->registered->type == 3)
1664 classType = 3;
1665 else if(baseType->_class->registered->type == 2)
1666 classType = 2;
1667 else if(baseType->_class->registered->type == 5)
1668 classType = 5;
1669 else if(baseType->_class->registered->type == 4)
1670 {
1671 wouldBeEnum = 0x1;
1672 }
1673 }
1674 }
1675 else if(baseType->kind == 9 || baseType->kind == 10)
1676 {
1677 classType = 5;
1678 baseName[0] = '\0';
1679 }
1680 else
1681 unitType = 0x1;
1682 FreeType(baseType);
1683 if(((struct Specifier *)baseSpecs->first)->type == 0 && ((struct Specifier *)baseSpecs->first)->specifier == PRIVATE)
1684 inheritanceAccess = 2;
1685 }
1686 if(classType == 0)
1687 {
1688 if(unitType)
1689 classType = 3;
1690 if(definitions != (((void *)0)))
1691 {
1692 for(def = definitions->first; def; def = def->next)
1693 {
1694 if(def->type == 2)
1695 {
1696 struct Declaration * decl = def->decl;
1697
1698 if(decl->type == 0)
1699 {
1700 if(unitType)
1701 {
1702 classType = 2;
1703 break;
1704 }
1705 if(decl->declarators)
1706 {
1707 struct Declarator * d;
1708
1709 for(d = (*decl->declarators).first; d; d = d->next)
1710 {
1711 if(d->structDecl.exp)
1712 {
1713 classType = 2;
1714 break;
1715 }
1716 }
1717 if(d)
1718 break;
1719 }
1720 }
1721 }
1722 }
1723 }
1724 }
1725 if(classType == 0 && wouldBeEnum)
1726 classType = 4;
1727 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);
1728 if(regClass)
1729 regClass->symbol = symbol;
1730 classDefine = __extension__ ({
1731 struct ClassDefine * __ecereInstance1 = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass_ClassDefine);
1732
1733 __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;
1734 });
1735 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Add(&precompDefines, classDefine);
1736 if(classType == 6)
1737 {
1738 struct __ecereNameSpace__ecere__com__DataMember * unionMember = __ecereNameSpace__ecere__com__eMember_New(1, 1);
1739 struct DataMemberDefine * unionDefine;
1740
1741 unionDefine = __extension__ ({
1742 struct DataMemberDefine * __ecereInstance1 = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass_DataMemberDefine);
1743
1744 __ecereInstance1->isProperty = 3, __ecereInstance1->memberType = 1, __ecereInstance1;
1745 });
1746 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Add(&classDefine->propertiesAndMembers, unionDefine);
1747 AddDefinitions(classDefine, unionDefine, regClass, unionMember, definitions);
1748 __ecereNameSpace__ecere__com__eClass_AddMember(regClass, unionMember);
1749 }
1750 else if(regClass)
1751 AddDefinitions(classDefine, (struct DataMemberDefine *)classDefine, regClass, (((void *)0)), definitions);
1752 if(definitions != (((void *)0)))
1753 {
1754 for(def = definitions->first; def; def = def->next)
1755 {
1756 if(def->type == 0)
1757 {
1758 struct ClassFunction * func = def->function;
1759
1760 if(!func->dontMangle && func->declarator)
1761 {
1762 struct Identifier * id = GetDeclId(func->declarator);
1763 struct __ecereNameSpace__ecere__com__Method * method;
1764 struct MethodDefine * methodDefine;
1765
1766 {
1767 char * dataTypeString = StringFromSpecDecl(func->specifiers, func->declarator);
1768
1769 if(func->isVirtual)
1770 method = __ecereNameSpace__ecere__com__eClass_AddVirtualMethod(regClass, id->string, dataTypeString, func->declarator->symbol, def->memberAccess);
1771 else
1772 method = __ecereNameSpace__ecere__com__eClass_AddMethod(regClass, id->string, dataTypeString, func->declarator->symbol, def->memberAccess);
1773 (__ecereNameSpace__ecere__com__eSystem_Delete(dataTypeString), dataTypeString = 0);
1774 }
1775 if(method)
1776 {
1777 method->symbol = __extension__ ({
1778 struct Symbol * __ecereInstance1 = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass_Symbol);
1779
1780 __ecereInstance1->string = __ecereNameSpace__ecere__sys__CopyString(func->declarator->symbol->string), __ecereInstance1->id = func->declarator->symbol->id, __ecereInstance1->type = func->declarator->symbol->type, __ecereInstance1;
1781 });
1782 if(func->declarator->symbol->type)
1783 func->declarator->symbol->type->refCount++;
1784 ((struct Symbol *)method->symbol)->method = method;
1785 func->declarator->symbol = (((void *)0));
1786 if(method->type != 1 || method->_class == regClass)
1787 {
1788 methodDefine = __extension__ ({
1789 struct MethodDefine * __ecereInstance1 = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass_MethodDefine);
1790
1791 __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;
1792 });
1793 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Add(&classDefine->methods, methodDefine);
1794 }
1795 }
1796 }
1797 }
1798 else if(def->type == 13)
1799 {
1800 struct __ecereNameSpace__ecere__com__Method * method;
1801
1802 if((method = __ecereNameSpace__ecere__com__eClass_FindMethod(regClass, def->id->string, privateModule)))
1803 {
1804 struct MethodDefine * methodDefine;
1805
1806 method = __ecereNameSpace__ecere__com__eClass_AddMethod(regClass, def->id->string, (((void *)0)), (((void *)0)), def->memberAccess);
1807 methodDefine = __extension__ ({
1808 struct MethodDefine * __ecereInstance1 = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass_MethodDefine);
1809
1810 __ecereInstance1->name = __ecereNameSpace__ecere__sys__CopyString(method->name), __ecereInstance1->memberAccess = def->memberAccess, __ecereInstance1;
1811 });
1812 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Add(&classDefine->methods, methodDefine);
1813 }
1814 }
1815 }
1816 }
1817 if(regClass && symbol->templateParams)
1818 {
1819 struct TemplateParameter * param;
1820
1821 for(param = (*symbol->templateParams).first; param; param = param->next)
1822 {
1823 struct __ecereNameSpace__ecere__com__ClassTemplateArgument defaultArg =
1824 {
1825 .member = 0
1826 };
1827
1828 if(param->defaultArgument)
1829 {
1830 switch(param->type)
1831 {
1832 case 0:
1833 defaultArg.dataTypeString = StringFromSpecDecl(param->defaultArgument->templateDatatype->specifiers, param->defaultArgument->templateDatatype->decl);
1834 break;
1835 case 1:
1836 {
1837 char memberString[1024];
1838
1839 memberString[0] = '\0';
1840 if(param->defaultArgument->identifier->_class && param->defaultArgument->identifier->_class->name)
1841 {
1842 if(param->defaultArgument->identifier->_class->type == 8)
1843 strcpy(memberString, param->defaultArgument->identifier->_class->templateParameter->identifier->string);
1844 else
1845 strcpy(memberString, param->defaultArgument->identifier->_class->name);
1846 }
1847 if(memberString[0])
1848 {
1849 strcat(memberString, "::");
1850 }
1851 strcat(memberString, param->defaultArgument->identifier->string);
1852 defaultArg.memberString = __ecereNameSpace__ecere__sys__CopyString(memberString);
1853 break;
1854 }
1855 case 2:
1856 {
1857 struct Operand op;
1858
1859 ProcessExpressionType(param->defaultArgument->expression);
1860 ComputeExpression(param->defaultArgument->expression);
1861 op = GetOperand(param->defaultArgument->expression);
1862 defaultArg.expression.ui64 = op.ui64;
1863 break;
1864 }
1865 }
1866 }
1867 if(param->type == 1)
1868 {
1869 __ecereNameSpace__ecere__com__eClass_AddTemplateParameter(regClass, param->identifier->string, param->type, (void *)param->memberType, &defaultArg);
1870 }
1871 else
1872 {
1873 char * typeString = param->dataType ? StringFromSpecDecl(param->dataType->specifiers, param->dataType->decl) : (((void *)0));
1874
1875 __ecereNameSpace__ecere__com__eClass_AddTemplateParameter(regClass, param->identifier->string, param->type, typeString, &defaultArg);
1876 }
1877 }
1878 }
1879 }
1880
1881 extern void SetParsingType(unsigned int b);
1882
1883 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass___ecereNameSpace__ecere__sys__NamedLink;
1884
1885 struct __ecereNameSpace__ecere__sys__NamedLink
1886 {
1887 struct __ecereNameSpace__ecere__sys__NamedLink * prev;
1888 struct __ecereNameSpace__ecere__sys__NamedLink * next;
1889 char *  name;
1890 void *  data;
1891 } __attribute__ ((gcc_struct));
1892
1893 extern int strcmp(const char * , const char * );
1894
1895 extern void FreeExpContents(struct Expression * exp);
1896
1897 extern char *  PrintUInt(uint64 result);
1898
1899 extern struct Type * ProcessTypeString(const char *  string, unsigned int staticMethod);
1900
1901 extern void __ecereNameSpace__ecere__com__eEnum_AddFixedValue(struct __ecereNameSpace__ecere__com__Class * _class, const char *  string, int value);
1902
1903 extern void PrintExpression(struct Expression * exp, char *  string);
1904
1905 extern int printf(const char * , ...);
1906
1907 extern const char *  __ecereNameSpace__ecere__GetTranslatedString(const char * name, const char *  string, const char *  stringAndContext);
1908
1909 extern struct __ecereNameSpace__ecere__com__Instance * __thisModule;
1910
1911 extern int __ecereNameSpace__ecere__com__eEnum_AddValue(struct __ecereNameSpace__ecere__com__Class * _class, const char *  string);
1912
1913 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass___ecereNameSpace__ecere__com__Application;
1914
1915 struct __ecereNameSpace__ecere__com__Application
1916 {
1917 int argc;
1918 const char * *  argv;
1919 int exitCode;
1920 unsigned int isGUIApp;
1921 struct __ecereNameSpace__ecere__sys__OldList allModules;
1922 char *  parsedCommand;
1923 struct __ecereNameSpace__ecere__com__NameSpace systemNameSpace;
1924 } __attribute__ ((gcc_struct));
1925
1926 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)
1927 {
1928 struct __ecereNameSpace__ecere__com__Class * regClass = symbol->registered;
1929
1930 if(regClass && enumValues)
1931 {
1932 struct Enumerator * e;
1933
1934 for(e = enumValues->first; e; e = e->next)
1935 {
1936 if(e->exp)
1937 {
1938 struct Type * destType = (destType = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass_Type), destType->kind = 3, destType->refCount = 1, destType);
1939
1940 e->exp->destType = destType;
1941 SetParsingType(0x1);
1942 ProcessExpressionType(e->exp);
1943 SetParsingType(0x0);
1944 if(!e->exp->expType)
1945 {
1946 destType->kind = 8;
1947 destType->_class = symbol;
1948 ProcessExpressionType(e->exp);
1949 }
1950 if(e->exp->isConstant)
1951 {
1952 if(e->exp->type == 0 && e->exp->expType && e->exp->identifier && e->exp->identifier->string && e->exp->expType->kind == 15)
1953 {
1954 struct __ecereNameSpace__ecere__sys__NamedLink * l;
1955 char * string = e->exp->identifier->string;
1956
1957 for(l = e->exp->expType->members.first; l; l = l->next)
1958 {
1959 if(!strcmp(l->name, string))
1960 {
1961 if(l->data)
1962 {
1963 FreeExpContents(e->exp);
1964 e->exp->type = 2;
1965 e->exp->constant = PrintUInt((unsigned int)l->data);
1966 FreeType(e->exp->expType);
1967 e->exp->expType = ProcessTypeString("uint", 0x0);
1968 }
1969 break;
1970 }
1971 }
1972 }
1973 else
1974 ComputeExpression(e->exp);
1975 }
1976 if(e->exp->isConstant && e->exp->type == 2)
1977 {
1978 struct Operand op = GetOperand(e->exp);
1979 int value;
1980
1981 switch(op.kind)
1982 {
1983 case 1:
1984 value = op.type->isSigned ? (int)op.c : (int)op.uc;
1985 break;
1986 case 2:
1987 value = op.type->isSigned ? (int)op.s : (int)op.us;
1988 break;
1989 default:
1990 value = op.i;
1991 }
1992 __ecereNameSpace__ecere__com__eEnum_AddFixedValue(regClass, e->id->string, value);
1993 }
1994 else
1995 {
1996 char expString[8192];
1997
1998 expString[0] = (char)0;
1999 PrintExpression(e->exp, expString);
2000 printf(__ecereNameSpace__ecere__GetTranslatedString("ecp", "error: could not resolve value %s for enum %s in precompiler\n", (((void *)0))), expString, regClass->name);
2001 ((struct __ecereNameSpace__ecere__com__Application *)(((char *)((struct __ecereNameSpace__ecere__com__Instance *)__thisModule) + structSize_Module)))->exitCode = 1;
2002 __ecereNameSpace__ecere__com__eEnum_AddValue(regClass, e->id->string);
2003 }
2004 }
2005 else
2006 __ecereNameSpace__ecere__com__eEnum_AddValue(regClass, e->id->string);
2007 }
2008 }
2009 }
2010
2011 extern struct __ecereNameSpace__ecere__sys__OldList *  GetAST(void);
2012
2013 extern struct Symbol * FindClass(const char *  name);
2014
2015 extern void SetCurrentNameSpace(const char *  s);
2016
2017 extern void ComputeModuleClasses(struct __ecereNameSpace__ecere__com__Instance * module);
2018
2019 void PreCompPreProcessClassDefinitions()
2020 {
2021 struct __ecereNameSpace__ecere__sys__OldList * ast = GetAST();
2022 struct External * external, * next;
2023
2024 for(external = (*ast).first; external; external = next)
2025 {
2026 next = external->next;
2027 if(external->type == 2)
2028 {
2029 struct ClassDefinition * _class = external->_class;
2030
2031 if(_class->declMode == 1 || _class->declMode == 2 || _class->declMode == 3)
2032 {
2033 if(_class->definitions)
2034 {
2035 ProcessClass(0, _class->definitions, _class->symbol, _class->baseSpecs, (((void *)0)), _class->deleteWatchable, _class->declMode);
2036 }
2037 }
2038 }
2039 else if(external->type == 1)
2040 {
2041 struct Declaration * declaration = external->declaration;
2042
2043 if(declaration->type == 1)
2044 {
2045 if(external->declaration->declMode == 1 || external->declaration->declMode == 2 || external->declaration->declMode == 3)
2046 {
2047 if(declaration->specifiers)
2048 {
2049 struct Specifier * specifier;
2050
2051 for(specifier = (*declaration->specifiers).first; specifier; specifier = specifier->next)
2052 {
2053 if((specifier->type == 2 || specifier->type == 3 || specifier->type == 4) && specifier->id && specifier->id->string && (declaration->declMode || specifier->baseSpecs || (specifier->type == 2 && specifier->definitions)))
2054 {
2055 struct Symbol * symbol = FindClass(specifier->id->string);
2056
2057 if(symbol)
2058 {
2059 int classType;
2060
2061 if(specifier->type == 2)
2062 classType = 4;
2063 else if(specifier->type == 4)
2064 classType = 6;
2065 else
2066 classType = 1;
2067 ProcessClass(classType, specifier->definitions, symbol, specifier->baseSpecs, specifier->list, 0x0, external->declaration->declMode);
2068 }
2069 }
2070 }
2071 }
2072 if(external->declaration->declMode == 1 || external->declaration->declMode == 2)
2073 {
2074 if(declaration->declarators)
2075 {
2076 struct InitDeclarator * d;
2077
2078 for(d = (*declaration->declarators).first; d; d = d->next)
2079 {
2080 if(d->declarator)
2081 {
2082 struct Symbol * symbol = d->declarator->symbol;
2083
2084 if(symbol)
2085 {
2086 struct DataDefine * dataDefine;
2087 char typeString[1024];
2088
2089 typeString[0] = '\0';
2090 PrintType(symbol->type, typeString, 0x0, 0x1);
2091 dataDefine = __extension__ ({
2092 struct DataDefine * __ecereInstance1 = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass_DataDefine);
2093
2094 __ecereInstance1->type = 4, __ecereInstance1->name = __ecereNameSpace__ecere__sys__CopyString(symbol->string), __ecereInstance1->dataType = __ecereNameSpace__ecere__sys__CopyString(typeString), __ecereInstance1;
2095 });
2096 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Add(&precompDefines, dataDefine);
2097 }
2098 }
2099 }
2100 }
2101 }
2102 }
2103 }
2104 else if(declaration->type == 2)
2105 {
2106 if(external->declaration->declMode == 1 || external->declaration->declMode == 2)
2107 {
2108 struct Symbol * symbol = declaration->inst->symbol;
2109
2110 if(symbol)
2111 {
2112 struct DataDefine * dataDefine;
2113 char typeString[1024];
2114
2115 typeString[0] = '\0';
2116 PrintType(symbol->type, typeString, 0x0, 0x1);
2117 dataDefine = __extension__ ({
2118 struct DataDefine * __ecereInstance1 = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass_DataDefine);
2119
2120 __ecereInstance1->type = 4, __ecereInstance1->name = __ecereNameSpace__ecere__sys__CopyString(symbol->string), __ecereInstance1->dataType = __ecereNameSpace__ecere__sys__CopyString(typeString), __ecereInstance1;
2121 });
2122 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Add(&precompDefines, dataDefine);
2123 }
2124 }
2125 globalInstance = 0x1;
2126 }
2127 else if(declaration->type == 3)
2128 {
2129 if(external->declaration->declMode == 1 || external->declaration->declMode == 2)
2130 {
2131 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);
2132
2133 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Add(&precompDefines, definition);
2134 }
2135 }
2136 }
2137 else if(external->type == 0 && (external->function->declMode == 1 || external->function->declMode == 2))
2138 {
2139 struct FunctionDefinition * function = external->function;
2140 struct FunctionDefine * functionDefine;
2141 char typeString[1024];
2142
2143 typeString[0] = '\0';
2144 PrintType(function->declarator->symbol->type, typeString, 0x1, 0x1);
2145 functionDefine = __extension__ ({
2146 struct FunctionDefine * __ecereInstance1 = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass_FunctionDefine);
2147
2148 __ecereInstance1->type = 3, __ecereInstance1->name = __ecereNameSpace__ecere__sys__CopyString(function->declarator->symbol->string), __ecereInstance1->dataType = __ecereNameSpace__ecere__sys__CopyString(typeString), __ecereInstance1;
2149 });
2150 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Add(&precompDefines, functionDefine);
2151 }
2152 else if(external->type == 4)
2153 {
2154 SetCurrentNameSpace(external->id->string);
2155 }
2156 }
2157 ComputeModuleClasses(privateModule);
2158 for(external = (*ast).first; external; external = next)
2159 {
2160 next = external->next;
2161 if(external->type == 1 && (external->declaration->declMode == 1 || external->declaration->declMode == 2))
2162 {
2163 struct Declaration * declaration = external->declaration;
2164
2165 if(declaration->type == 1)
2166 {
2167 if(declaration->specifiers)
2168 {
2169 struct Specifier * specifier;
2170
2171 for(specifier = (*declaration->specifiers).first; specifier; specifier = specifier->next)
2172 {
2173 if((specifier->type == 2) && specifier->id && specifier->id->string && (declaration->declMode || specifier->baseSpecs || (specifier->type == 2 && specifier->definitions)))
2174 {
2175 struct Symbol * symbol = FindClass(specifier->id->string);
2176
2177 if(symbol)
2178 {
2179 ProcessClassEnumValues(4, specifier->definitions, symbol, specifier->baseSpecs, specifier->list);
2180 }
2181 }
2182 }
2183 }
2184 }
2185 }
2186 }
2187 }
2188
2189 int __ecereMethod___ecereNameSpace__ecere__sys__File_Printf(struct __ecereNameSpace__ecere__com__Instance * this, const char *  format, ...);
2190
2191 static void OutputDataMembers(struct ClassDefine * classDefine, struct __ecereNameSpace__ecere__com__Class * _class, struct __ecereNameSpace__ecere__com__Instance * f)
2192 {
2193 if(classDefine->propertiesAndMembers.first)
2194 {
2195 struct DataMemberDefine * member = classDefine->propertiesAndMembers.first;
2196 int last = 0;
2197
2198 for(member = classDefine->propertiesAndMembers.first; member; member = member->next)
2199 {
2200 if(member->isProperty == 1)
2201 {
2202 struct PropertyDefine * prop = (struct PropertyDefine *)member;
2203
2204 if(last != 1)
2205 {
2206 if(last)
2207 __ecereMethod___ecereNameSpace__ecere__sys__File_Printf(f, "         .\n");
2208 __ecereMethod___ecereNameSpace__ecere__sys__File_Printf(f, "      [Defined Properties]\n");
2209 }
2210 if(prop->name)
2211 __ecereMethod___ecereNameSpace__ecere__sys__File_Printf(f, "         %s\n", prop->name);
2212 else
2213 __ecereMethod___ecereNameSpace__ecere__sys__File_Printf(f, "         [Conversion]\n");
2214 if(prop->memberAccess == 1)
2215 __ecereMethod___ecereNameSpace__ecere__sys__File_Printf(f, "            [Public]\n");
2216 else
2217 __ecereMethod___ecereNameSpace__ecere__sys__File_Printf(f, "            [Private]\n");
2218 if(prop->isVirtual)
2219 __ecereMethod___ecereNameSpace__ecere__sys__File_Printf(f, "            [Virtual]\n");
2220 if(prop->hasSet)
2221 __ecereMethod___ecereNameSpace__ecere__sys__File_Printf(f, "            [Set]\n");
2222 if(prop->hasGet)
2223 __ecereMethod___ecereNameSpace__ecere__sys__File_Printf(f, "            [Get]\n");
2224 if(prop->isWatchable)
2225 __ecereMethod___ecereNameSpace__ecere__sys__File_Printf(f, "            [Watchable]\n");
2226 __ecereMethod___ecereNameSpace__ecere__sys__File_Printf(f, "            [Type]\n");
2227 __ecereMethod___ecereNameSpace__ecere__sys__File_Printf(f, "               %s\n", prop->type ? prop->type : "");
2228 }
2229 else
2230 {
2231 if(last != 3)
2232 {
2233 if(last)
2234 __ecereMethod___ecereNameSpace__ecere__sys__File_Printf(f, "         .\n");
2235 __ecereMethod___ecereNameSpace__ecere__sys__File_Printf(f, "      [Defined Data Members]\n");
2236 }
2237 if(member->memberType == 0)
2238 {
2239 __ecereMethod___ecereNameSpace__ecere__sys__File_Printf(f, "         %s\n", member->name);
2240 if(member->memberAccess == 1)
2241 __ecereMethod___ecereNameSpace__ecere__sys__File_Printf(f, "            [Public]\n");
2242 else
2243 __ecereMethod___ecereNameSpace__ecere__sys__File_Printf(f, "            [Private]\n");
2244 if(_class && _class->type == 2)
2245 {
2246 if(member->size)
2247 {
2248 __ecereMethod___ecereNameSpace__ecere__sys__File_Printf(f, "            [Size]\n");
2249 __ecereMethod___ecereNameSpace__ecere__sys__File_Printf(f, "               %d\n", member->size);
2250 }
2251 if(member->bitPos != -1)
2252 {
2253 __ecereMethod___ecereNameSpace__ecere__sys__File_Printf(f, "            [Pos]\n");
2254 __ecereMethod___ecereNameSpace__ecere__sys__File_Printf(f, "               %d\n", member->bitPos);
2255 }
2256 }
2257 __ecereMethod___ecereNameSpace__ecere__sys__File_Printf(f, "            [Type]\n");
2258 __ecereMethod___ecereNameSpace__ecere__sys__File_Printf(f, "               %s\n", member->type ? member->type : "");
2259 }
2260 else
2261 {
2262 if(member->memberAccess == 1)
2263 __ecereMethod___ecereNameSpace__ecere__sys__File_Printf(f, "            [Public]\n");
2264 else
2265 __ecereMethod___ecereNameSpace__ecere__sys__File_Printf(f, "            [Private]\n");
2266 __ecereMethod___ecereNameSpace__ecere__sys__File_Printf(f, (member->memberType == 1) ? "      [Union]\n" : "      [Struct]\n");
2267 OutputDataMembers((struct ClassDefine *)member, (((void *)0)), f);
2268 }
2269 }
2270 last = member->isProperty;
2271 }
2272 __ecereMethod___ecereNameSpace__ecere__sys__File_Printf(f, "         .\n");
2273 }
2274 if(classDefine->classProperties.first)
2275 {
2276 struct PropertyDefine * prop = classDefine->propertiesAndMembers.first;
2277
2278 __ecereMethod___ecereNameSpace__ecere__sys__File_Printf(f, "      [Defined Class Properties]\n");
2279 for(prop = classDefine->classProperties.first; prop; prop = prop->next)
2280 {
2281 if(prop->name)
2282 __ecereMethod___ecereNameSpace__ecere__sys__File_Printf(f, "         %s\n", prop->name);
2283 if(prop->hasSet)
2284 __ecereMethod___ecereNameSpace__ecere__sys__File_Printf(f, "            [Set]\n");
2285 if(prop->hasGet)
2286 __ecereMethod___ecereNameSpace__ecere__sys__File_Printf(f, "            [Get]\n");
2287 __ecereMethod___ecereNameSpace__ecere__sys__File_Printf(f, "            [Type]\n");
2288 __ecereMethod___ecereNameSpace__ecere__sys__File_Printf(f, "               %s\n", prop->type ? prop->type : "");
2289 }
2290 __ecereMethod___ecereNameSpace__ecere__sys__File_Printf(f, "         .\n");
2291 }
2292 }
2293
2294 extern struct __ecereNameSpace__ecere__com__Instance * __ecereNameSpace__ecere__sys__FileOpen(const char *  fileName, int mode);
2295
2296 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_ImportedModule;
2297
2298 struct ImportedModule
2299 {
2300 struct ImportedModule * prev;
2301 struct ImportedModule * next;
2302 char *  name;
2303 int type;
2304 int importType;
2305 unsigned int globalInstance;
2306 unsigned int dllOnly;
2307 int importAccess;
2308 } __attribute__ ((gcc_struct));
2309
2310 extern struct __ecereNameSpace__ecere__com__Class * __ecereNameSpace__ecere__com__eSystem_FindClass(struct __ecereNameSpace__ecere__com__Instance * module, const char *  name);
2311
2312 extern void __ecereNameSpace__ecere__sys__ChangeCh(char *  string, char ch1, char ch2);
2313
2314 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass___ecereNameSpace__ecere__com__EnumClassData;
2315
2316 struct __ecereNameSpace__ecere__com__EnumClassData
2317 {
2318 struct __ecereNameSpace__ecere__sys__OldList values;
2319 int largest;
2320 } __attribute__ ((gcc_struct));
2321
2322 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass___ecereNameSpace__ecere__com__DefinedExpression;
2323
2324 struct __ecereNameSpace__ecere__com__DefinedExpression;
2325
2326 extern struct __ecereNameSpace__ecere__com__DefinedExpression * __ecereNameSpace__ecere__com__eSystem_FindDefine(struct __ecereNameSpace__ecere__com__Instance * module, const char *  name);
2327
2328 extern void OutputExpression(struct Expression * exp, struct __ecereNameSpace__ecere__com__Instance * f);
2329
2330 int __ecereVMethodID___ecereNameSpace__ecere__sys__File_Puts;
2331
2332 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass___ecereNameSpace__ecere__sys__File;
2333
2334 extern void __ecereNameSpace__ecere__com__eInstance_DecRef(struct __ecereNameSpace__ecere__com__Instance * instance);
2335
2336 static void OutputSymbols(const char * fileName)
2337 {
2338 struct __ecereNameSpace__ecere__com__Instance * f = __ecereNameSpace__ecere__sys__FileOpen(fileName, 2);
2339
2340 if(f)
2341 {
2342 int lastType = (int)-1;
2343 struct Definition * definition;
2344
2345 if(globalInstance)
2346 __ecereMethod___ecereNameSpace__ecere__sys__File_Printf(f, "[Global Instance]\n");
2347 for(definition = precompDefines.first; definition; definition = definition->next)
2348 {
2349 if(definition->type != lastType)
2350 {
2351 if(lastType != (int)-1)
2352 __ecereMethod___ecereNameSpace__ecere__sys__File_Printf(f, "   .\n");
2353 if(definition->type == 0)
2354 __ecereMethod___ecereNameSpace__ecere__sys__File_Printf(f, "[Imported Modules]\n");
2355 else if(definition->type == 1)
2356 __ecereMethod___ecereNameSpace__ecere__sys__File_Printf(f, "[Defined Classes]\n");
2357 else if(definition->type == 2)
2358 __ecereMethod___ecereNameSpace__ecere__sys__File_Printf(f, "[Defined Expressions]\n");
2359 else if(definition->type == 3)
2360 __ecereMethod___ecereNameSpace__ecere__sys__File_Printf(f, "[Defined Functions]\n");
2361 else if(definition->type == 4)
2362 __ecereMethod___ecereNameSpace__ecere__sys__File_Printf(f, "[Defined Data]\n");
2363 lastType = definition->type;
2364 }
2365 if(definition->type == 0)
2366 {
2367 struct ImportedModule * module = (struct ImportedModule *)definition;
2368
2369 if(module->importType == 1)
2370 __ecereMethod___ecereNameSpace__ecere__sys__File_Printf(f, "   [Static]\n");
2371 else if(module->importType == 2)
2372 __ecereMethod___ecereNameSpace__ecere__sys__File_Printf(f, "   [Remote]\n");
2373 if(module->importAccess == 2)
2374 __ecereMethod___ecereNameSpace__ecere__sys__File_Printf(f, "   [Private]\n");
2375 __ecereMethod___ecereNameSpace__ecere__sys__File_Printf(f, "   %s\n", module->name);
2376 }
2377 else if(definition->type == 1)
2378 {
2379 struct __ecereNameSpace__ecere__com__Class * _class = __ecereNameSpace__ecere__com__eSystem_FindClass(privateModule, definition->name);
2380 struct ClassDefine * classDefine = (struct ClassDefine *)definition;
2381
2382 __ecereMethod___ecereNameSpace__ecere__sys__File_Printf(f, "   %s\n", definition->name);
2383 if(classDefine->isStatic)
2384 __ecereMethod___ecereNameSpace__ecere__sys__File_Printf(f, "      [Static]\n");
2385 if(classDefine->fixed)
2386 __ecereMethod___ecereNameSpace__ecere__sys__File_Printf(f, "      [Fixed]\n");
2387 if(classDefine->noExpansion)
2388 __ecereMethod___ecereNameSpace__ecere__sys__File_Printf(f, "      [No Expansion]\n");
2389 if(classDefine->isRemote)
2390 __ecereMethod___ecereNameSpace__ecere__sys__File_Printf(f, "      [Remote]\n");
2391 if(classDefine->isWatchable)
2392 __ecereMethod___ecereNameSpace__ecere__sys__File_Printf(f, "      [Watchable]\n");
2393 if(_class->type == 4)
2394 __ecereMethod___ecereNameSpace__ecere__sys__File_Printf(f, "      [Enum]\n");
2395 else if(_class->type == 2)
2396 __ecereMethod___ecereNameSpace__ecere__sys__File_Printf(f, "      [Bit]\n");
2397 else if(_class->type == 1)
2398 __ecereMethod___ecereNameSpace__ecere__sys__File_Printf(f, "      [Struct]\n");
2399 else if(_class->type == 3)
2400 __ecereMethod___ecereNameSpace__ecere__sys__File_Printf(f, "      [Unit]\n");
2401 else if(_class->type == 5)
2402 __ecereMethod___ecereNameSpace__ecere__sys__File_Printf(f, "      [NoHead]\n");
2403 if(_class->inheritanceAccess == 2)
2404 __ecereMethod___ecereNameSpace__ecere__sys__File_Printf(f, "      [Private Base]\n");
2405 else
2406 __ecereMethod___ecereNameSpace__ecere__sys__File_Printf(f, "      [Base]\n");
2407 if(classDefine->base)
2408 __ecereMethod___ecereNameSpace__ecere__sys__File_Printf(f, "         %s\n", classDefine->base);
2409 else
2410 __ecereMethod___ecereNameSpace__ecere__sys__File_Printf(f, "         [None]\n");
2411 if(_class->templateParams.count)
2412 {
2413 struct __ecereNameSpace__ecere__com__ClassTemplateParameter * param;
2414 struct TemplateParameter * tp;
2415
2416 __ecereMethod___ecereNameSpace__ecere__sys__File_Printf(f, "         [Template Parameters]\n");
2417 for(tp = (*((struct Symbol *)_class->symbol)->templateParams).first, param = _class->templateParams.first; param && tp; param = param->next, tp = tp->next)
2418 {
2419 __ecereMethod___ecereNameSpace__ecere__sys__File_Printf(f, "               %s\n", param->name);
2420 switch(param->type)
2421 {
2422 case 0:
2423 __ecereMethod___ecereNameSpace__ecere__sys__File_Printf(f, "               [Type]\n");
2424 __ecereMethod___ecereNameSpace__ecere__sys__File_Printf(f, "               %s\n", param->dataTypeString ? param->dataTypeString : "[None]");
2425 __ecereMethod___ecereNameSpace__ecere__sys__File_Printf(f, "               %s\n", param->defaultArg.dataTypeString ? param->defaultArg.dataTypeString : "[None]");
2426 break;
2427 case 2:
2428 __ecereMethod___ecereNameSpace__ecere__sys__File_Printf(f, "               [Expression]\n");
2429 __ecereMethod___ecereNameSpace__ecere__sys__File_Printf(f, "               %s\n", param->dataTypeString ? param->dataTypeString : "[None]");
2430 if(tp->defaultArgument && tp->defaultArgument->expression)
2431 {
2432 char temp[8192];
2433
2434 temp[0] = (char)0;
2435 PrintExpression(tp->defaultArgument->expression, temp);
2436 __ecereNameSpace__ecere__sys__ChangeCh(temp, '\n', ' ');
2437 __ecereMethod___ecereNameSpace__ecere__sys__File_Printf(f, "               ");
2438 ((unsigned int (*)(struct __ecereNameSpace__ecere__com__Instance *, const char *  string))__extension__ ({
2439 struct __ecereNameSpace__ecere__com__Instance * __internal_ClassInst = f;
2440
2441 __internal_ClassInst ? __internal_ClassInst->_vTbl : __ecereClass___ecereNameSpace__ecere__sys__File->_vTbl;
2442 })[__ecereVMethodID___ecereNameSpace__ecere__sys__File_Puts])(f, temp);
2443 ((unsigned int (*)(struct __ecereNameSpace__ecere__com__Instance *, const char *  string))__extension__ ({
2444 struct __ecereNameSpace__ecere__com__Instance * __internal_ClassInst = f;
2445
2446 __internal_ClassInst ? __internal_ClassInst->_vTbl : __ecereClass___ecereNameSpace__ecere__sys__File->_vTbl;
2447 })[__ecereVMethodID___ecereNameSpace__ecere__sys__File_Puts])(f, "\n");
2448 }
2449 else
2450 __ecereMethod___ecereNameSpace__ecere__sys__File_Printf(f, "               [None]\n");
2451 break;
2452 case 1:
2453 __ecereMethod___ecereNameSpace__ecere__sys__File_Printf(f, "               [Identifier]\n");
2454 __ecereMethod___ecereNameSpace__ecere__sys__File_Printf(f, "               %s\n", (param->memberType == 0) ? "[Data member]" : ((param->memberType == 1) ? "[Method]" : "[Property]"));
2455 if(tp->defaultArgument && tp->defaultArgument->identifier)
2456 {
2457 __ecereMethod___ecereNameSpace__ecere__sys__File_Printf(f, "               ");
2458 if(tp->defaultArgument->identifier->_class && tp->defaultArgument->identifier->_class->type == 1 && tp->defaultArgument->identifier->_class->name)
2459 {
2460 __ecereMethod___ecereNameSpace__ecere__sys__File_Printf(f, "%s::", tp->defaultArgument->identifier->_class->name);
2461 }
2462 else if(tp->defaultArgument->identifier->_class && tp->defaultArgument->identifier->_class->type == 8 && tp->defaultArgument->identifier->_class->templateParameter->identifier)
2463 {
2464 __ecereMethod___ecereNameSpace__ecere__sys__File_Printf(f, "%s::", tp->defaultArgument->identifier->_class->templateParameter->identifier->string);
2465 }
2466 __ecereMethod___ecereNameSpace__ecere__sys__File_Printf(f, "%s\n", tp->defaultArgument->identifier->string);
2467 }
2468 else
2469 {
2470 __ecereMethod___ecereNameSpace__ecere__sys__File_Printf(f, "               [None]\n");
2471 }
2472 break;
2473 }
2474 }
2475 __ecereMethod___ecereNameSpace__ecere__sys__File_Printf(f, "         .\n");
2476 }
2477 if(!classDefine->isStatic)
2478 {
2479 if(classDefine->methods.first)
2480 {
2481 struct MethodDefine * method;
2482
2483 __ecereMethod___ecereNameSpace__ecere__sys__File_Printf(f, "      [Defined Methods]\n");
2484 for(method = classDefine->methods.first; method; method = method->next)
2485 {
2486 __ecereMethod___ecereNameSpace__ecere__sys__File_Printf(f, "         %s\n", method->name);
2487 if(method->memberAccess == 1)
2488 __ecereMethod___ecereNameSpace__ecere__sys__File_Printf(f, "            [Public]\n");
2489 else
2490 __ecereMethod___ecereNameSpace__ecere__sys__File_Printf(f, "            [Private]\n");
2491 if(method->isVirtual)
2492 __ecereMethod___ecereNameSpace__ecere__sys__File_Printf(f, "            [Virtual]\n");
2493 __ecereMethod___ecereNameSpace__ecere__sys__File_Printf(f, "            [Type]\n");
2494 __ecereMethod___ecereNameSpace__ecere__sys__File_Printf(f, "               %s\n", method->type ? method->type : "");
2495 }
2496 __ecereMethod___ecereNameSpace__ecere__sys__File_Printf(f, "         .\n");
2497 }
2498 OutputDataMembers(classDefine, _class, f);
2499 if(_class->type == 4)
2500 {
2501 struct __ecereNameSpace__ecere__sys__NamedLink * value;
2502 struct __ecereNameSpace__ecere__com__Class * enumClass = __ecereNameSpace__ecere__com__eSystem_FindClass(privateModule, "enum");
2503 struct __ecereNameSpace__ecere__com__EnumClassData * e = (_class ? ((void *)(((char *)_class->data) + enumClass->offsetClass)) : (((void *)0)));
2504
2505 __ecereMethod___ecereNameSpace__ecere__sys__File_Printf(f, "      [Enum Values]\n");
2506 for(value = e->values.first; value; value = value->next)
2507 {
2508 __ecereMethod___ecereNameSpace__ecere__sys__File_Printf(f, "         %s = %d\n", value->name, value->data);
2509 }
2510 __ecereMethod___ecereNameSpace__ecere__sys__File_Printf(f, "         .\n");
2511 }
2512 }
2513 }
2514 else if(definition->type == 2)
2515 {
2516 struct __ecereNameSpace__ecere__com__DefinedExpression * defExp = __ecereNameSpace__ecere__com__eSystem_FindDefine(privateModule, definition->name);
2517 struct Define * defineDefine = (struct Define *)definition;
2518
2519 __ecereMethod___ecereNameSpace__ecere__sys__File_Printf(f, "   %s\n", definition->name);
2520 __ecereMethod___ecereNameSpace__ecere__sys__File_Printf(f, "      [Value]\n");
2521 __ecereMethod___ecereNameSpace__ecere__sys__File_Printf(f, "         ");
2522 OutputExpression(defineDefine->exp, f);
2523 __ecereMethod___ecereNameSpace__ecere__sys__File_Printf(f, "\n");
2524 }
2525 else if(definition->type == 3)
2526 {
2527 struct FunctionDefine * functionDefine = (struct FunctionDefine *)definition;
2528
2529 __ecereMethod___ecereNameSpace__ecere__sys__File_Printf(f, "   %s\n", functionDefine->name);
2530 __ecereMethod___ecereNameSpace__ecere__sys__File_Printf(f, "      [Type]\n");
2531 __ecereMethod___ecereNameSpace__ecere__sys__File_Printf(f, "         %s\n", functionDefine->dataType);
2532 }
2533 else if(definition->type == 4)
2534 {
2535 struct DataDefine * dataDefine = (struct DataDefine *)definition;
2536
2537 __ecereMethod___ecereNameSpace__ecere__sys__File_Printf(f, "   %s\n", dataDefine->name);
2538 __ecereMethod___ecereNameSpace__ecere__sys__File_Printf(f, "      [Type]\n");
2539 __ecereMethod___ecereNameSpace__ecere__sys__File_Printf(f, "         %s\n", dataDefine->dataType);
2540 }
2541 }
2542 __ecereMethod___ecereNameSpace__ecere__sys__File_Printf(f, "   .\n");
2543 (__ecereNameSpace__ecere__com__eInstance_DecRef(f), f = 0);
2544 }
2545 }
2546
2547 static struct __ecereNameSpace__ecere__com__Class * __ecereClass_PrecompApp;
2548
2549 extern int __ecereNameSpace__ecere__com__GetRuntimePlatform(void);
2550
2551 extern int GetHostBits(void);
2552
2553 extern size_t strlen(const char * );
2554
2555 extern char *  PassArg(char *  output, const char *  input);
2556
2557 extern const char *  GetOutputFile(void);
2558
2559 extern void SetOutputFile(const char *  s);
2560
2561 extern const char *  GetSourceFile(void);
2562
2563 extern void SetSourceFile(const char *  s);
2564
2565 extern void SetSymbolsDir(const char *  s);
2566
2567 extern void SetDefaultNameSpace(const char *  s);
2568
2569 extern void SetStrictNameSpaces(unsigned int b);
2570
2571 extern void SetI18nModuleName(const char *  s);
2572
2573 extern const char *  GetSymbolsDir(void);
2574
2575 extern char *  __ecereNameSpace__ecere__sys__PathCat(char *  string, const char *  addedPath);
2576
2577 extern char *  __ecereNameSpace__ecere__sys__ChangeExtension(const char *  string, const char *  ext, char *  output);
2578
2579 extern void SetGlobalData(struct __ecereNameSpace__ecere__com__NameSpace *  nameSpace);
2580
2581 extern void SetExcludedSymbols(struct __ecereNameSpace__ecere__sys__OldList *  list);
2582
2583 extern void SetGlobalContext(struct Context * context);
2584
2585 extern void SetCurrentContext(struct Context * context);
2586
2587 extern void SetTopContext(struct Context * context);
2588
2589 extern void SetDefines(struct __ecereNameSpace__ecere__sys__OldList *  list);
2590
2591 extern void SetImports(struct __ecereNameSpace__ecere__sys__OldList *  list);
2592
2593 extern void SetInPreCompiler(unsigned int b);
2594
2595 extern void SetPrecompDefines(struct __ecereNameSpace__ecere__sys__OldList *  list);
2596
2597 extern void SetTargetPlatform(int platform);
2598
2599 extern void SetTargetBits(int bits);
2600
2601 extern void SetEchoOn(unsigned int b);
2602
2603 extern struct __ecereNameSpace__ecere__com__Instance * __ecereNameSpace__ecere__com____ecere_COM_Initialize(unsigned int guiApp, int argc, char *  argv[]);
2604
2605 extern void SetPrivateModule(struct __ecereNameSpace__ecere__com__Instance * module);
2606
2607 extern unsigned int __ecereNameSpace__ecere__sys__FileExists(const char *  fileName);
2608
2609 extern unsigned int __ecereNameSpace__ecere__sys__DeleteFile(const char *  fileName);
2610
2611 extern int snprintf(char * , size_t, const char * , ...);
2612
2613 extern struct __ecereNameSpace__ecere__com__Instance * __ecereNameSpace__ecere__sys__DualPipeOpen(unsigned int mode, const char *  commandLine);
2614
2615 extern void SetFileInput(struct __ecereNameSpace__ecere__com__Instance * file);
2616
2617 extern void SetMainModule(struct ModuleImport * moduleImport);
2618
2619 extern void resetScanner(void);
2620
2621 extern void ParseEc(void);
2622
2623 extern void SetYydebug(unsigned int b);
2624
2625 extern void ProcessDBTableDefinitions(void);
2626
2627 extern void FreeASTTree(struct __ecereNameSpace__ecere__sys__OldList * ast);
2628
2629 extern void FreeContext(struct Context * context);
2630
2631 extern void FreeExcludedSymbols(struct __ecereNameSpace__ecere__sys__OldList * excludedSymbols);
2632
2633 extern void FreeModuleDefine(struct Definition * def);
2634
2635 extern void FreeModuleImport(struct ModuleImport * imp);
2636
2637 extern void FreeTypeData(struct __ecereNameSpace__ecere__com__Instance * privateModule);
2638
2639 extern void FreeIncludeFiles(void);
2640
2641 extern void FreeGlobalData(struct __ecereNameSpace__ecere__com__NameSpace * globalDataList);
2642
2643 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass___ecereNameSpace__ecere__sys__TempFile;
2644
2645 const char *  __ecereProp___ecereNameSpace__ecere__com__Platform_Get_char__PTR_(int this);
2646
2647 int __ecereProp___ecereNameSpace__ecere__com__Platform_Set_char__PTR_(const char *  value);
2648
2649 extern struct __ecereNameSpace__ecere__com__Property ** __ecereProp___ecereNameSpace__ecere__com__Platform_char__PTR_;
2650
2651 unsigned int __ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_Add(struct __ecereNameSpace__ecere__sys__BinaryTree * this, struct __ecereNameSpace__ecere__sys__BTNode * node);
2652
2653 int __ecereVMethodID___ecereNameSpace__ecere__sys__File_Eof;
2654
2655 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass___ecereNameSpace__ecere__sys__DualPipe;
2656
2657 int __ecereVMethodID___ecereNameSpace__ecere__sys__File_Read;
2658
2659 int __ecereVMethodID___ecereNameSpace__ecere__sys__File_Write;
2660
2661 int __ecereMethod___ecereNameSpace__ecere__sys__DualPipe_GetExitCode();
2662
2663 int __ecereVMethodID___ecereNameSpace__ecere__sys__File_Seek;
2664
2665 void __ecereMethod_PrecompApp_Main(struct __ecereNameSpace__ecere__com__Instance * this)
2666 {
2667 int c;
2668 unsigned int valid = 0x1;
2669 char defaultSymFile[797];
2670 char * cppCommand = (((void *)0));
2671 char * cppOptions = (((void *)0));
2672 int cppOptionsLen = 0;
2673 int targetPlatform = __ecereNameSpace__ecere__com__GetRuntimePlatform();
2674 int targetBits = GetHostBits();
2675
2676 for(c = 1; c < ((struct __ecereNameSpace__ecere__com__Application *)(((char *)this + structSize_Module)))->argc; c++)
2677 {
2678 const char * arg = ((struct __ecereNameSpace__ecere__com__Application *)(((char *)this + structSize_Module)))->argv[c];
2679
2680 if(arg[0] == '-')
2681 {
2682 if(!strcmp(arg + 1, "m32") || !strcmp(arg + 1, "m64"))
2683 {
2684 int newLen = cppOptionsLen + 1 + strlen(arg);
2685
2686 cppOptions = __ecereNameSpace__ecere__com__eSystem_Renew(cppOptions, sizeof(char) * (newLen + 1));
2687 cppOptions[cppOptionsLen] = ' ';
2688 strcpy(cppOptions + cppOptionsLen + 1, arg);
2689 cppOptionsLen = newLen;
2690 targetBits = !strcmp(arg + 1, "m32") ? 32 : 64;
2691 }
2692 else if(!strcmp(arg + 1, "t32") || !strcmp(arg + 1, "t64"))
2693 {
2694 targetBits = !strcmp(arg + 1, "t32") ? 32 : 64;
2695 }
2696 else if(arg[1] == 'D' || arg[1] == 'I')
2697 {
2698 char * buf;
2699 int size = cppOptionsLen + 1 + strlen(arg) * 2 + 1;
2700
2701 cppOptions = __ecereNameSpace__ecere__com__eSystem_Renew(cppOptions, sizeof(char) * (size));
2702 buf = cppOptions + cppOptionsLen;
2703 *buf++ = ' ';
2704 PassArg(buf, arg);
2705 cppOptionsLen = cppOptionsLen + 1 + strlen(buf);
2706 }
2707 else if(!strcmp(arg + 1, "t"))
2708 {
2709 if(++c < ((struct __ecereNameSpace__ecere__com__Application *)(((char *)this + structSize_Module)))->argc)
2710 targetPlatform = __ecereProp___ecereNameSpace__ecere__com__Platform_Set_char__PTR_(((struct __ecereNameSpace__ecere__com__Application *)(((char *)this + structSize_Module)))->argv[c]);
2711 else
2712 valid = 0x0;
2713 }
2714 else if(!strcmp(arg + 1, "cpp"))
2715 {
2716 if(++c < ((struct __ecereNameSpace__ecere__com__Application *)(((char *)this + structSize_Module)))->argc)
2717 cppCommand = __ecereNameSpace__ecere__sys__CopyString(((struct __ecereNameSpace__ecere__com__Application *)(((char *)this + structSize_Module)))->argv[c]);
2718 else
2719 valid = 0x0;
2720 }
2721 else if(!strcmp(arg + 1, "o"))
2722 {
2723 if(!GetOutputFile() && c + 1 < ((struct __ecereNameSpace__ecere__com__Application *)(((char *)this + structSize_Module)))->argc)
2724 {
2725 SetOutputFile(((struct __ecereNameSpace__ecere__com__Application *)(((char *)this + structSize_Module)))->argv[c + 1]);
2726 c++;
2727 }
2728 else
2729 valid = 0x0;
2730 }
2731 else if(!strcmp(arg + 1, "c"))
2732 {
2733 if(!GetSourceFile() && c + 1 < ((struct __ecereNameSpace__ecere__com__Application *)(((char *)this + structSize_Module)))->argc)
2734 {
2735 SetSourceFile(((struct __ecereNameSpace__ecere__com__Application *)(((char *)this + structSize_Module)))->argv[c + 1]);
2736 c++;
2737 }
2738 else
2739 valid = 0x0;
2740 }
2741 else if(!strcmp(arg + 1, "isystem") || !strcmp(arg + 1, "isysroot"))
2742 {
2743 if(c + 1 < ((struct __ecereNameSpace__ecere__com__Application *)(((char *)this + structSize_Module)))->argc)
2744 {
2745 char * buf;
2746 const char * arg1 = ((struct __ecereNameSpace__ecere__com__Application *)(((char *)this + structSize_Module)))->argv[++c];
2747 int size = cppOptionsLen + 1 + strlen(arg) * 2 + strlen(arg1) * 2 + 1;
2748
2749 cppOptions = __ecereNameSpace__ecere__com__eSystem_Renew(cppOptions, sizeof(char) * (size));
2750 buf = cppOptions + cppOptionsLen;
2751 *buf++ = ' ';
2752 buf = PassArg(buf, arg);
2753 *buf++ = ' ';
2754 buf = PassArg(buf, arg1);
2755 cppOptionsLen = buf - cppOptions;
2756 }
2757 else
2758 valid = 0x0;
2759 }
2760 else if(!strcmp(arg + 1, "fno-diagnostics-show-caret"))
2761 {
2762 char * buf;
2763 int size = cppOptionsLen + 1 + strlen(arg) * 2 + 1;
2764
2765 cppOptions = __ecereNameSpace__ecere__com__eSystem_Renew(cppOptions, sizeof(char) * (size));
2766 buf = cppOptions + cppOptionsLen;
2767 *buf++ = ' ';
2768 PassArg(buf, arg);
2769 cppOptionsLen = cppOptionsLen + 1 + strlen(buf);
2770 }
2771 else if(!strcmp(arg + 1, "symbols"))
2772 {
2773 if(c + 1 < ((struct __ecereNameSpace__ecere__com__Application *)(((char *)this + structSize_Module)))->argc)
2774 {
2775 SetSymbolsDir(((struct __ecereNameSpace__ecere__com__Application *)(((char *)this + structSize_Module)))->argv[c + 1]);
2776 c++;
2777 }
2778 else
2779 valid = 0x0;
2780 }
2781 else if(!strcmp(arg + 1, "defaultns"))
2782 {
2783 if(c + 1 < ((struct __ecereNameSpace__ecere__com__Application *)(((char *)this + structSize_Module)))->argc)
2784 {
2785 SetDefaultNameSpace(((struct __ecereNameSpace__ecere__com__Application *)(((char *)this + structSize_Module)))->argv[c + 1]);
2786 c++;
2787 }
2788 else
2789 valid = 0x0;
2790 }
2791 else if(!strcmp(arg + 1, "strictns"))
2792 {
2793 SetStrictNameSpaces(0x1);
2794 }
2795 else if(!strcmp(arg + 1, "module"))
2796 {
2797 if(c + 1 < ((struct __ecereNameSpace__ecere__com__Application *)(((char *)this + structSize_Module)))->argc)
2798 {
2799 SetI18nModuleName(((struct __ecereNameSpace__ecere__com__Application *)(((char *)this + structSize_Module)))->argv[c + 1]);
2800 c++;
2801 }
2802 else
2803 valid = 0x0;
2804 }
2805 }
2806 else
2807 valid = 0x0;
2808 }
2809 if(valid)
2810 {
2811 if(!cppCommand)
2812 cppCommand = __ecereNameSpace__ecere__sys__CopyString("gcc");
2813 if(!GetSourceFile())
2814 valid = 0x0;
2815 else if(!GetOutputFile())
2816 {
2817 strcpy(defaultSymFile, GetSymbolsDir());
2818 __ecereNameSpace__ecere__sys__PathCat(defaultSymFile, GetSourceFile());
2819 __ecereNameSpace__ecere__sys__ChangeExtension(defaultSymFile, "sym", defaultSymFile);
2820 SetOutputFile(defaultSymFile);
2821 }
2822 }
2823 if(!valid)
2824 {
2825 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))));
2826 }
2827 else
2828 {
2829 struct __ecereNameSpace__ecere__com__Instance * cppOutput;
2830 char command[3075];
2831
2832 SetGlobalData(&globalData);
2833 SetExcludedSymbols(&_excludedSymbols);
2834 SetGlobalContext(globalContext);
2835 SetCurrentContext(globalContext);
2836 SetTopContext(globalContext);
2837 SetDefines(&defines);
2838 SetImports(&imports);
2839 SetInPreCompiler(0x1);
2840 SetPrecompDefines(&precompDefines);
2841 SetTargetPlatform(targetPlatform);
2842 SetTargetBits(targetBits);
2843 SetEchoOn(0x0);
2844 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)));
2845 SetPrivateModule(privateModule);
2846 __ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_Add(&globalContext->types, (struct __ecereNameSpace__ecere__sys__BTNode *)__extension__ ({
2847 struct Symbol * __ecereInstance1 = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass_Symbol);
2848
2849 __ecereInstance1->string = __ecereNameSpace__ecere__sys__CopyString("uint"), __ecereInstance1->type = ProcessTypeString("unsigned int", 0x0), __ecereInstance1;
2850 }));
2851 __ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_Add(&globalContext->types, (struct __ecereNameSpace__ecere__sys__BTNode *)__extension__ ({
2852 struct Symbol * __ecereInstance1 = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass_Symbol);
2853
2854 __ecereInstance1->string = __ecereNameSpace__ecere__sys__CopyString("uint64"), __ecereInstance1->type = ProcessTypeString("unsigned int64", 0x0), __ecereInstance1;
2855 }));
2856 __ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_Add(&globalContext->types, (struct __ecereNameSpace__ecere__sys__BTNode *)__extension__ ({
2857 struct Symbol * __ecereInstance1 = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass_Symbol);
2858
2859 __ecereInstance1->string = __ecereNameSpace__ecere__sys__CopyString("uint32"), __ecereInstance1->type = ProcessTypeString("unsigned int", 0x0), __ecereInstance1;
2860 }));
2861 __ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_Add(&globalContext->types, (struct __ecereNameSpace__ecere__sys__BTNode *)__extension__ ({
2862 struct Symbol * __ecereInstance1 = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass_Symbol);
2863
2864 __ecereInstance1->string = __ecereNameSpace__ecere__sys__CopyString("uint16"), __ecereInstance1->type = ProcessTypeString("unsigned short", 0x0), __ecereInstance1;
2865 }));
2866 __ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_Add(&globalContext->types, (struct __ecereNameSpace__ecere__sys__BTNode *)__extension__ ({
2867 struct Symbol * __ecereInstance1 = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass_Symbol);
2868
2869 __ecereInstance1->string = __ecereNameSpace__ecere__sys__CopyString("byte"), __ecereInstance1->type = ProcessTypeString("unsigned char", 0x0), __ecereInstance1;
2870 }));
2871 __ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_Add(&globalContext->types, (struct __ecereNameSpace__ecere__sys__BTNode *)__extension__ ({
2872 struct Symbol * __ecereInstance1 = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass_Symbol);
2873
2874 __ecereInstance1->string = __ecereNameSpace__ecere__sys__CopyString("intptr_t"), __ecereInstance1->type = ProcessTypeString("intptr", 0x0), __ecereInstance1;
2875 }));
2876 __ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_Add(&globalContext->types, (struct __ecereNameSpace__ecere__sys__BTNode *)__extension__ ({
2877 struct Symbol * __ecereInstance1 = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass_Symbol);
2878
2879 __ecereInstance1->string = __ecereNameSpace__ecere__sys__CopyString("uintptr_t"), __ecereInstance1->type = ProcessTypeString("uintptr", 0x0), __ecereInstance1;
2880 }));
2881 __ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_Add(&globalContext->types, (struct __ecereNameSpace__ecere__sys__BTNode *)__extension__ ({
2882 struct Symbol * __ecereInstance1 = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass_Symbol);
2883
2884 __ecereInstance1->string = __ecereNameSpace__ecere__sys__CopyString("ssize_t"), __ecereInstance1->type = ProcessTypeString("intsize", 0x0), __ecereInstance1;
2885 }));
2886 __ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_Add(&globalContext->types, (struct __ecereNameSpace__ecere__sys__BTNode *)__extension__ ({
2887 struct Symbol * __ecereInstance1 = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass_Symbol);
2888
2889 __ecereInstance1->string = __ecereNameSpace__ecere__sys__CopyString("size_t"), __ecereInstance1->type = ProcessTypeString("uintsize", 0x0), __ecereInstance1;
2890 }));
2891 {
2892 const char * outputFilePath = GetOutputFile();
2893
2894 if(__ecereNameSpace__ecere__sys__FileExists(outputFilePath))
2895 __ecereNameSpace__ecere__sys__DeleteFile(outputFilePath);
2896 }
2897 snprintf(command, sizeof (command), "%s%s -x c -E \"%s\"", cppCommand, cppOptions ? cppOptions : "", GetSourceFile());
2898 command[sizeof (command) - 1] = (char)0;
2899 if((cppOutput = __ecereNameSpace__ecere__sys__DualPipeOpen((((unsigned int)(0x1))), command)))
2900 {
2901 int exitCode;
2902 struct __ecereNameSpace__ecere__sys__OldList * ast;
2903 struct __ecereNameSpace__ecere__com__Instance * fileInput = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass___ecereNameSpace__ecere__sys__TempFile);
2904 struct ModuleImport * mainModule = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass_ModuleImport);
2905
2906 SetFileInput(fileInput);
2907 SetMainModule(mainModule);
2908 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Add(&imports, mainModule);
2909 resetScanner();
2910 for(; !((unsigned int (*)(struct __ecereNameSpace__ecere__com__Instance *))__extension__ ({
2911 struct __ecereNameSpace__ecere__com__Instance * __internal_ClassInst = cppOutput;
2912
2913 __internal_ClassInst ? __internal_ClassInst->_vTbl : __ecereClass___ecereNameSpace__ecere__sys__DualPipe->_vTbl;
2914 })[__ecereVMethodID___ecereNameSpace__ecere__sys__File_Eof])(cppOutput); )
2915 {
2916 char junk[4096];
2917 int count = ((int (*)(struct __ecereNameSpace__ecere__com__Instance *, void *  buffer, unsigned int size, unsigned int count))__extension__ ({
2918 struct __ecereNameSpace__ecere__com__Instance * __internal_ClassInst = cppOutput;
2919
2920 __internal_ClassInst ? __internal_ClassInst->_vTbl : __ecereClass___ecereNameSpace__ecere__sys__DualPipe->_vTbl;
2921 })[__ecereVMethodID___ecereNameSpace__ecere__sys__File_Read])(cppOutput, junk, 1, 4096);
2922
2923 ((int (*)(struct __ecereNameSpace__ecere__com__Instance *, const void *  buffer, unsigned int size, unsigned int count))__extension__ ({
2924 struct __ecereNameSpace__ecere__com__Instance * __internal_ClassInst = fileInput;
2925
2926 __internal_ClassInst ? __internal_ClassInst->_vTbl : __ecereClass___ecereNameSpace__ecere__sys__TempFile->_vTbl;
2927 })[__ecereVMethodID___ecereNameSpace__ecere__sys__File_Write])(fileInput, junk, 1, count);
2928 }
2929 exitCode = __ecereMethod___ecereNameSpace__ecere__sys__DualPipe_GetExitCode(cppOutput);
2930 (__ecereNameSpace__ecere__com__eInstance_DecRef(cppOutput), cppOutput = 0);
2931 ((unsigned int (*)(struct __ecereNameSpace__ecere__com__Instance *, int pos, int mode))__extension__ ({
2932 struct __ecereNameSpace__ecere__com__Instance * __internal_ClassInst = fileInput;
2933
2934 __internal_ClassInst ? __internal_ClassInst->_vTbl : __ecereClass___ecereNameSpace__ecere__sys__TempFile->_vTbl;
2935 })[__ecereVMethodID___ecereNameSpace__ecere__sys__File_Seek])(fileInput, 0, 0);
2936 ParseEc();
2937 SetCurrentNameSpace((((void *)0)));
2938 SetYydebug(0x0);
2939 (__ecereNameSpace__ecere__com__eInstance_DecRef(fileInput), fileInput = 0);
2940 SetFileInput((((void *)0)));
2941 ast = GetAST();
2942 if(!exitCode)
2943 {
2944 if(ast)
2945 {
2946 ProcessDBTableDefinitions();
2947 PreCompPreProcessClassDefinitions();
2948 }
2949 if(!((struct __ecereNameSpace__ecere__com__Application *)(((char *)this + structSize_Module)))->exitCode)
2950 OutputSymbols(GetOutputFile());
2951 }
2952 else
2953 ((struct __ecereNameSpace__ecere__com__Application *)(((char *)this + structSize_Module)))->exitCode = exitCode;
2954 if(ast)
2955 {
2956 FreeASTTree(ast);
2957 }
2958 }
2959 FreeContext(globalContext);
2960 FreeExcludedSymbols(&_excludedSymbols);
2961 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Free(&defines, FreeModuleDefine);
2962 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Free(&imports, FreeModuleImport);
2963 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Free(&precompDefines, FreeDefinition);
2964 FreeTypeData(privateModule);
2965 FreeIncludeFiles();
2966 FreeGlobalData(&globalData);
2967 (__ecereNameSpace__ecere__com__eInstance_DecRef(privateModule), privateModule = 0);
2968 }
2969 (__ecereNameSpace__ecere__com__eSystem_Delete(cppCommand), cppCommand = 0);
2970 (__ecereNameSpace__ecere__com__eSystem_Delete(cppOptions), cppOptions = 0);
2971 SetSymbolsDir((((void *)0)));
2972 }
2973
2974 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass___ecereNameSpace__ecere__com__Module;
2975
2976 struct __ecereNameSpace__ecere__com__Module
2977 {
2978 struct __ecereNameSpace__ecere__com__Instance * application;
2979 struct __ecereNameSpace__ecere__sys__OldList classes;
2980 struct __ecereNameSpace__ecere__sys__OldList defines;
2981 struct __ecereNameSpace__ecere__sys__OldList functions;
2982 struct __ecereNameSpace__ecere__sys__OldList modules;
2983 struct __ecereNameSpace__ecere__com__Instance * prev;
2984 struct __ecereNameSpace__ecere__com__Instance * next;
2985 const char *  name;
2986 void *  library;
2987 void *  Unload;
2988 int importType;
2989 int origImportType;
2990 struct __ecereNameSpace__ecere__com__NameSpace privateNameSpace;
2991 struct __ecereNameSpace__ecere__com__NameSpace publicNameSpace;
2992 } __attribute__ ((gcc_struct));
2993
2994 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass___ecereNameSpace__ecere__com__GlobalFunction;
2995
2996 struct __ecereNameSpace__ecere__com__GlobalFunction;
2997
2998 extern struct __ecereNameSpace__ecere__com__GlobalFunction * __ecereNameSpace__ecere__com__eSystem_RegisterFunction(const char *  name, const char *  type, void *  func, struct __ecereNameSpace__ecere__com__Instance * module, int declMode);
2999
3000 void __ecereRegisterModule_ecp(struct __ecereNameSpace__ecere__com__Instance * module)
3001 {
3002 struct __ecereNameSpace__ecere__com__Class * class;
3003
3004 class = __ecereNameSpace__ecere__com__eSystem_RegisterClass(5, "ClassDefine", "Definition", sizeof(struct ClassDefine), 0, 0, 0, module, 2, 1);
3005 if(((struct __ecereNameSpace__ecere__com__Module *)(((char *)module + structSize_Instance)))->application == ((struct __ecereNameSpace__ecere__com__Module *)(((char *)__thisModule + structSize_Instance)))->application && class)
3006 __ecereClass_ClassDefine = class;
3007 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "base", "char *", arch_PointerSize, arch_PointerSize, 1);
3008 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "propertiesAndMembers", "ecere::sys::OldList", structSize_OldList, arch_PointerSize, 1);
3009 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "classProperties", "ecere::sys::OldList", structSize_OldList, arch_PointerSize, 1);
3010 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "methods", "ecere::sys::OldList", structSize_OldList, arch_PointerSize, 1);
3011 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "isRemote", "bool", 4, 4, 1);
3012 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "isWatchable", "bool", 4, 4, 1);
3013 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "fixed", "bool", 4, 4, 1);
3014 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "isStatic", "bool", 4, 4, 1);
3015 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "noExpansion", "bool", 4, 4, 1);
3016 class = __ecereNameSpace__ecere__com__eSystem_RegisterClass(5, "Define", "Definition", sizeof(struct Define), 0, 0, 0, module, 2, 1);
3017 if(((struct __ecereNameSpace__ecere__com__Module *)(((char *)module + structSize_Instance)))->application == ((struct __ecereNameSpace__ecere__com__Module *)(((char *)__thisModule + structSize_Instance)))->application && class)
3018 __ecereClass_Define = class;
3019 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "exp", "Expression", arch_PointerSize, arch_PointerSize, 1);
3020 class = __ecereNameSpace__ecere__com__eSystem_RegisterClass(5, "FunctionDefine", "Definition", sizeof(struct FunctionDefine), 0, 0, 0, module, 2, 1);
3021 if(((struct __ecereNameSpace__ecere__com__Module *)(((char *)module + structSize_Instance)))->application == ((struct __ecereNameSpace__ecere__com__Module *)(((char *)__thisModule + structSize_Instance)))->application && class)
3022 __ecereClass_FunctionDefine = class;
3023 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "dataType", "char *", arch_PointerSize, arch_PointerSize, 1);
3024 class = __ecereNameSpace__ecere__com__eSystem_RegisterClass(5, "DataDefine", "Definition", sizeof(struct DataDefine), 0, 0, 0, module, 2, 1);
3025 if(((struct __ecereNameSpace__ecere__com__Module *)(((char *)module + structSize_Instance)))->application == ((struct __ecereNameSpace__ecere__com__Module *)(((char *)__thisModule + structSize_Instance)))->application && class)
3026 __ecereClass_DataDefine = class;
3027 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "dataType", "char *", arch_PointerSize, arch_PointerSize, 1);
3028 class = __ecereNameSpace__ecere__com__eSystem_RegisterClass(5, "MethodDefine", 0, sizeof(struct MethodDefine), 0, 0, 0, module, 2, 1);
3029 if(((struct __ecereNameSpace__ecere__com__Module *)(((char *)module + structSize_Instance)))->application == ((struct __ecereNameSpace__ecere__com__Module *)(((char *)__thisModule + structSize_Instance)))->application && class)
3030 __ecereClass_MethodDefine = class;
3031 class = __ecereNameSpace__ecere__com__eSystem_RegisterClass(5, "PropertyDefine", 0, sizeof(struct PropertyDefine), 0, 0, 0, module, 2, 1);
3032 if(((struct __ecereNameSpace__ecere__com__Module *)(((char *)module + structSize_Instance)))->application == ((struct __ecereNameSpace__ecere__com__Module *)(((char *)__thisModule + structSize_Instance)))->application && class)
3033 __ecereClass_PropertyDefine = class;
3034 class = __ecereNameSpace__ecere__com__eSystem_RegisterClass(5, "DataMemberDefine", 0, sizeof(struct DataMemberDefine), 0, 0, 0, module, 2, 1);
3035 if(((struct __ecereNameSpace__ecere__com__Module *)(((char *)module + structSize_Instance)))->application == ((struct __ecereNameSpace__ecere__com__Module *)(((char *)__thisModule + structSize_Instance)))->application && class)
3036 __ecereClass_DataMemberDefine = class;
3037 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("FreeMethodDefine", "void FreeMethodDefine(MethodDefine method)", FreeMethodDefine, module, 2);
3038 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("FreeDataMemberDefine", "void FreeDataMemberDefine(DataMemberDefine dataMember)", FreeDataMemberDefine, module, 2);
3039 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("FreeDataDefine", "void FreeDataDefine(DataDefine data)", FreeDataDefine, module, 2);
3040 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("FreeDefinition", "void FreeDefinition(Definition definition)", FreeDefinition, module, 2);
3041 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("PreCompPreProcessClassDefinitions", "void PreCompPreProcessClassDefinitions(void)", PreCompPreProcessClassDefinitions, module, 2);
3042 class = __ecereNameSpace__ecere__com__eSystem_RegisterClass(0, "PrecompApp", "ecere::com::Application", 0, 0, 0, 0, module, 2, 1);
3043 if(((struct __ecereNameSpace__ecere__com__Module *)(((char *)module + structSize_Instance)))->application == ((struct __ecereNameSpace__ecere__com__Module *)(((char *)__thisModule + structSize_Instance)))->application && class)
3044 __ecereClass_PrecompApp = class;
3045 __ecereNameSpace__ecere__com__eClass_AddMethod(class, "Main", 0, __ecereMethod_PrecompApp_Main, 1);
3046 }
3047
3048 void __ecereUnregisterModule_ecp(struct __ecereNameSpace__ecere__com__Instance * module)
3049 {
3050
3051 }
3052
3053 int __ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_CompareString(struct __ecereNameSpace__ecere__sys__BinaryTree * this, const char *  a, const char *  b);
3054
3055 void __ecereCreateModuleInstances_ecp()
3056 {
3057 globalContext = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass_Context);
3058 (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);
3059 }
3060
3061 void __ecereDestroyModuleInstances_ecp()
3062 {
3063 ((globalContext ? (__ecereClass_Context->Destructor ? __ecereClass_Context->Destructor((void *)globalContext) : 0, __ecereNameSpace__ecere__com__eSystem_Delete(globalContext)) : 0), globalContext = 0);
3064 }
3065