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

   1 /* Code generated from eC source file: loadSymbols.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
  43 struct __ecereNameSpace__ecere__com__Instance;
  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 const char *  name;
 106 unsigned int isProperty;
 107 int memberAccess;
 108 int id;
 109 struct __ecereNameSpace__ecere__com__Class * _class;
 110 const 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 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_Context;
 158
 159 struct Context;
 160
 161 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_Instantiation;
 162
 163 struct Instantiation;
 164
 165 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_Declaration;
 166
 167 struct Declaration;
 168
 169 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_Statement;
 170
 171 struct Statement;
 172
 173 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_TypeName;
 174
 175 struct TypeName;
 176
 177 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_Initializer;
 178
 179 struct Initializer;
 180
 181 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass___ecereNameSpace__ecere__com__DataValue;
 182
 183 struct __ecereNameSpace__ecere__com__DataValue
 184 {
 185 union
 186 {
 187 char c;
 188 unsigned char uc;
 189 short s;
 190 unsigned short us;
 191 int i;
 192 unsigned int ui;
 193 void *  p;
 194 float f;
 195 double d;
 196 long long i64;
 197 uint64 ui64;
 198 } __attribute__ ((gcc_struct)) __anon1;
 199 } __attribute__ ((gcc_struct));
 200
 201 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_Expression;
 202
 203 struct Expression
 204 {
 205 struct Expression * prev;
 206 struct Expression * next;
 207 struct Location loc;
 208 int type;
 209 union
 210 {
 211 struct
 212 {
 213 char *  constant;
 214 struct Identifier * identifier;
 215 } __attribute__ ((gcc_struct)) __anon1;
 216 struct Statement * compound;
 217 struct Instantiation * instance;
 218 struct
 219 {
 220 char *  string;
 221 unsigned int intlString;
 222 } __attribute__ ((gcc_struct)) __anon2;
 223 struct __ecereNameSpace__ecere__sys__OldList *  list;
 224 struct
 225 {
 226 struct __ecereNameSpace__ecere__sys__OldList * specifiers;
 227 struct Declarator * decl;
 228 } __attribute__ ((gcc_struct)) _classExp;
 229 struct
 230 {
 231 struct Identifier * id;
 232 } __attribute__ ((gcc_struct)) classData;
 233 struct
 234 {
 235 struct Expression * exp;
 236 struct __ecereNameSpace__ecere__sys__OldList * arguments;
 237 struct Location argLoc;
 238 } __attribute__ ((gcc_struct)) call;
 239 struct
 240 {
 241 struct Expression * exp;
 242 struct __ecereNameSpace__ecere__sys__OldList * index;
 243 } __attribute__ ((gcc_struct)) index;
 244 struct
 245 {
 246 struct Expression * exp;
 247 struct Identifier * member;
 248 int memberType;
 249 unsigned int thisPtr;
 250 } __attribute__ ((gcc_struct)) member;
 251 struct
 252 {
 253 int op;
 254 struct Expression * exp1;
 255 struct Expression * exp2;
 256 } __attribute__ ((gcc_struct)) op;
 257 struct TypeName * typeName;
 258 struct Specifier * _class;
 259 struct
 260 {
 261 struct TypeName * typeName;
 262 struct Expression * exp;
 263 } __attribute__ ((gcc_struct)) cast;
 264 struct
 265 {
 266 struct Expression * cond;
 267 struct __ecereNameSpace__ecere__sys__OldList * exp;
 268 struct Expression * elseExp;
 269 } __attribute__ ((gcc_struct)) cond;
 270 struct
 271 {
 272 struct TypeName * typeName;
 273 struct Expression * size;
 274 } __attribute__ ((gcc_struct)) _new;
 275 struct
 276 {
 277 struct TypeName * typeName;
 278 struct Expression * size;
 279 struct Expression * exp;
 280 } __attribute__ ((gcc_struct)) _renew;
 281 struct
 282 {
 283 char * table;
 284 struct Identifier * id;
 285 } __attribute__ ((gcc_struct)) db;
 286 struct
 287 {
 288 struct Expression * ds;
 289 struct Expression * name;
 290 } __attribute__ ((gcc_struct)) dbopen;
 291 struct
 292 {
 293 struct TypeName * typeName;
 294 struct Initializer * initializer;
 295 } __attribute__ ((gcc_struct)) initializer;
 296 struct
 297 {
 298 struct Expression * exp;
 299 struct TypeName * typeName;
 300 } __attribute__ ((gcc_struct)) vaArg;
 301 } __attribute__ ((gcc_struct)) __anon1;
 302 unsigned int debugValue;
 303 struct __ecereNameSpace__ecere__com__DataValue val;
 304 uint64 address;
 305 unsigned int hasAddress;
 306 struct Type * expType;
 307 struct Type * destType;
 308 unsigned int usage;
 309 int tempCount;
 310 unsigned int byReference;
 311 unsigned int isConstant;
 312 unsigned int addedThis;
 313 unsigned int needCast;
 314 unsigned int thisPtr;
 315 unsigned int opDestType;
 316 unsigned int needTemplateCast;
 317 } __attribute__ ((gcc_struct));
 318
 319 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_TemplateDatatype;
 320
 321 struct TemplateDatatype;
 322
 323 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_TemplateArgument;
 324
 325 struct TemplateArgument;
 326
 327 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_TemplateParameter;
 328
 329 struct TemplateParameter;
 330
 331 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_Specifier;
 332
 333 struct Specifier;
 334
 335 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_Identifier;
 336
 337 struct Identifier;
 338
 339 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_Pointer;
 340
 341 struct Pointer;
 342
 343 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_Declarator;
 344
 345 struct Declarator;
 346
 347 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_FunctionDefinition;
 348
 349 struct FunctionDefinition;
 350
 351 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_DBTableDef;
 352
 353 struct DBTableDef;
 354
 355 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_External;
 356
 357 struct External;
 358
 359 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_ModuleImport;
 360
 361 struct ModuleImport;
 362
 363 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_ClassImport;
 364
 365 struct ClassImport;
 366
 367 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_Symbol;
 368
 369 struct Symbol
 370 {
 371 char *  string;
 372 struct Symbol * parent;
 373 struct Symbol * left;
 374 struct Symbol * right;
 375 int depth;
 376 struct Type * type;
 377 union
 378 {
 379 struct __ecereNameSpace__ecere__com__Method * method;
 380 struct __ecereNameSpace__ecere__com__Property * _property;
 381 struct __ecereNameSpace__ecere__com__Class * registered;
 382 } __attribute__ ((gcc_struct)) __anon1;
 383 int id;
 384 int idCode;
 385 union
 386 {
 387 struct
 388 {
 389 struct External * pointerExternal;
 390 struct External * structExternal;
 391 } __attribute__ ((gcc_struct)) __anon1;
 392 struct
 393 {
 394 struct External * externalGet;
 395 struct External * externalSet;
 396 struct External * externalPtr;
 397 struct External * externalIsSet;
 398 } __attribute__ ((gcc_struct)) __anon2;
 399 struct
 400 {
 401 struct External * methodExternal;
 402 struct External * methodCodeExternal;
 403 } __attribute__ ((gcc_struct)) __anon3;
 404 } __attribute__ ((gcc_struct)) __anon2;
 405 unsigned int imported;
 406 unsigned int declaredStructSym;
 407 struct __ecereNameSpace__ecere__com__Class * _class;
 408 unsigned int declaredStruct;
 409 unsigned int needConstructor;
 410 unsigned int needDestructor;
 411 char *  constructorName;
 412 char *  structName;
 413 char *  className;
 414 char *  destructorName;
 415 struct ModuleImport * module;
 416 struct ClassImport * _import;
 417 struct Location nameLoc;
 418 unsigned int isParam;
 419 unsigned int isRemote;
 420 unsigned int isStruct;
 421 unsigned int fireWatchersDone;
 422 int declaring;
 423 unsigned int classData;
 424 unsigned int isStatic;
 425 char *  shortName;
 426 struct __ecereNameSpace__ecere__sys__OldList *  templateParams;
 427 struct __ecereNameSpace__ecere__sys__OldList templatedClasses;
 428 struct Context * ctx;
 429 int isIterator;
 430 struct Expression * propCategory;
 431 } __attribute__ ((gcc_struct));
 432
 433 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_Type;
 434
 435 struct Type;
 436
 437 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass___ecereNameSpace__ecere__com__Class;
 438
 439 struct __ecereNameSpace__ecere__com__Class
 440 {
 441 struct __ecereNameSpace__ecere__com__Class * prev;
 442 struct __ecereNameSpace__ecere__com__Class * next;
 443 const char *  name;
 444 int offset;
 445 int structSize;
 446 int (* *  _vTbl)();
 447 int vTblSize;
 448 int (*  Constructor)(struct __ecereNameSpace__ecere__com__Instance *);
 449 void (*  Destructor)(struct __ecereNameSpace__ecere__com__Instance *);
 450 int offsetClass;
 451 int sizeClass;
 452 struct __ecereNameSpace__ecere__com__Class * base;
 453 struct __ecereNameSpace__ecere__sys__BinaryTree methods;
 454 struct __ecereNameSpace__ecere__sys__BinaryTree members;
 455 struct __ecereNameSpace__ecere__sys__BinaryTree prop;
 456 struct __ecereNameSpace__ecere__sys__OldList membersAndProperties;
 457 struct __ecereNameSpace__ecere__sys__BinaryTree classProperties;
 458 struct __ecereNameSpace__ecere__sys__OldList derivatives;
 459 int memberID;
 460 int startMemberID;
 461 int type;
 462 struct __ecereNameSpace__ecere__com__Instance * module;
 463 struct __ecereNameSpace__ecere__com__NameSpace *  nameSpace;
 464 const char *  dataTypeString;
 465 struct Type * dataType;
 466 int typeSize;
 467 int defaultAlignment;
 468 void (*  Initialize)();
 469 int memberOffset;
 470 struct __ecereNameSpace__ecere__sys__OldList selfWatchers;
 471 const char *  designerClass;
 472 unsigned int noExpansion;
 473 const char *  defaultProperty;
 474 unsigned int comRedefinition;
 475 int count;
 476 int isRemote;
 477 unsigned int internalDecl;
 478 void *  data;
 479 unsigned int computeSize;
 480 int structAlignment;
 481 int destructionWatchOffset;
 482 unsigned int fixed;
 483 struct __ecereNameSpace__ecere__sys__OldList delayedCPValues;
 484 int inheritanceAccess;
 485 const char *  fullName;
 486 void *  symbol;
 487 struct __ecereNameSpace__ecere__sys__OldList conversions;
 488 struct __ecereNameSpace__ecere__sys__OldList templateParams;
 489 struct __ecereNameSpace__ecere__com__ClassTemplateArgument *  templateArgs;
 490 struct __ecereNameSpace__ecere__com__Class * templateClass;
 491 struct __ecereNameSpace__ecere__sys__OldList templatized;
 492 int numParams;
 493 unsigned int isInstanceClass;
 494 unsigned int byValueSystemClass;
 495 } __attribute__ ((gcc_struct));
 496
 497 extern long long __ecereNameSpace__ecere__com__eClass_GetProperty(struct __ecereNameSpace__ecere__com__Class * _class, const char *  name);
 498
 499 extern void __ecereNameSpace__ecere__com__eClass_SetProperty(struct __ecereNameSpace__ecere__com__Class * _class, const char *  name, long long value);
 500
 501 extern void __ecereNameSpace__ecere__com__eInstance_FireSelfWatchers(struct __ecereNameSpace__ecere__com__Instance * instance, struct __ecereNameSpace__ecere__com__Property * _property);
 502
 503 extern void __ecereNameSpace__ecere__com__eInstance_SetMethod(struct __ecereNameSpace__ecere__com__Instance * instance, const char *  name, void *  function);
 504
 505 extern void __ecereNameSpace__ecere__com__eInstance_IncRef(struct __ecereNameSpace__ecere__com__Instance * instance);
 506
 507 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);
 508
 509 extern void __ecereNameSpace__ecere__com__eInstance_Watch(void *  instance, struct __ecereNameSpace__ecere__com__Property * _property, void *  object, void (*  callback)(void * , void * ));
 510
 511 extern void __ecereNameSpace__ecere__com__eInstance_FireWatchers(struct __ecereNameSpace__ecere__com__Instance * instance, struct __ecereNameSpace__ecere__com__Property * _property);
 512
 513 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass___ecereNameSpace__ecere__com__Instance;
 514
 515 struct __ecereNameSpace__ecere__com__Instance
 516 {
 517 int (* *  _vTbl)();
 518 struct __ecereNameSpace__ecere__com__Class * _class;
 519 int _refCount;
 520 } __attribute__ ((gcc_struct));
 521
 522 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass___ecereNameSpace__ecere__com__DataMember;
 523
 524 struct __ecereNameSpace__ecere__com__DataMember
 525 {
 526 struct __ecereNameSpace__ecere__com__DataMember * prev;
 527 struct __ecereNameSpace__ecere__com__DataMember * next;
 528 const char *  name;
 529 unsigned int isProperty;
 530 int memberAccess;
 531 int id;
 532 struct __ecereNameSpace__ecere__com__Class * _class;
 533 const char *  dataTypeString;
 534 struct __ecereNameSpace__ecere__com__Class * dataTypeClass;
 535 struct Type * dataType;
 536 int type;
 537 int offset;
 538 int memberID;
 539 struct __ecereNameSpace__ecere__sys__OldList members;
 540 struct __ecereNameSpace__ecere__sys__BinaryTree membersAlpha;
 541 int memberOffset;
 542 int structAlignment;
 543 } __attribute__ ((gcc_struct));
 544
 545 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass___ecereNameSpace__ecere__com__SerialBuffer;
 546
 547 struct __ecereNameSpace__ecere__com__SerialBuffer
 548 {
 549 unsigned char *  _buffer;
 550 unsigned int count;
 551 unsigned int _size;
 552 unsigned int pos;
 553 } __attribute__ ((gcc_struct));
 554
 555 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass___ecereNameSpace__ecere__com__ClassTemplateArgument;
 556
 557 struct __ecereNameSpace__ecere__com__ClassTemplateArgument
 558 {
 559 union
 560 {
 561 struct
 562 {
 563 const char *  dataTypeString;
 564 struct __ecereNameSpace__ecere__com__Class * dataTypeClass;
 565 } __attribute__ ((gcc_struct)) __anon1;
 566 struct __ecereNameSpace__ecere__com__DataValue expression;
 567 struct
 568 {
 569 const char *  memberString;
 570 union
 571 {
 572 struct __ecereNameSpace__ecere__com__DataMember * member;
 573 struct __ecereNameSpace__ecere__com__Property * prop;
 574 struct __ecereNameSpace__ecere__com__Method * method;
 575 } __attribute__ ((gcc_struct)) __anon1;
 576 } __attribute__ ((gcc_struct)) __anon2;
 577 } __attribute__ ((gcc_struct)) __anon1;
 578 } __attribute__ ((gcc_struct));
 579
 580 extern int yychar;
 581
 582 struct __ecereNameSpace__ecere__com__NameSpace * globalData;
 583
 584 void SetGlobalData(struct __ecereNameSpace__ecere__com__NameSpace * nameSpace)
 585 {
 586 globalData = nameSpace;
 587 }
 588
 589 struct __ecereNameSpace__ecere__sys__OldList dataRedefinitions;
 590
 591 extern char sourceFileStack[30][797];
 592
 593 extern int include_stack_ptr;
 594
 595 static int numIncludes;
 596
 597 static char ** includes;
 598
 599 unsigned int inIDE = 0;
 600
 601 void SetInIDE(unsigned int b)
 602 {
 603 inIDE = b;
 604 }
 605
 606 struct __ecereNameSpace__ecere__com__Instance * sourceDirs;
 607
 608 void SetSourceDirs(struct __ecereNameSpace__ecere__com__Instance * list)
 609 {
 610 sourceDirs = list;
 611 }
 612
 613 struct __ecereNameSpace__ecere__sys__OldList * includeDirs, * sysIncludeDirs;
 614
 615 void SetIncludeDirs(struct __ecereNameSpace__ecere__sys__OldList * list)
 616 {
 617 includeDirs = list;
 618 }
 619
 620 void SetSysIncludeDirs(struct __ecereNameSpace__ecere__sys__OldList * list)
 621 {
 622 sysIncludeDirs = list;
 623 }
 624
 625 unsigned int ecereImported;
 626
 627 void SetEcereImported(unsigned int b)
 628 {
 629 ecereImported = b;
 630 }
 631
 632 unsigned int GetEcereImported()
 633 {
 634 return ecereImported;
 635 }
 636
 637 unsigned int inPreCompiler = 0;
 638
 639 void SetInPreCompiler(unsigned int b)
 640 {
 641 inPreCompiler = b;
 642 }
 643
 644 unsigned int inSymbolGen = 0;
 645
 646 void SetInSymbolGen(unsigned int b)
 647 {
 648 inSymbolGen = b;
 649 }
 650
 651 struct __ecereNameSpace__ecere__sys__OldList * precompDefines;
 652
 653 void SetPrecompDefines(struct __ecereNameSpace__ecere__sys__OldList * list)
 654 {
 655 precompDefines = list;
 656 }
 657
 658 unsigned int DummyMethod()
 659 {
 660 return 1;
 661 }
 662
 663 extern char *  __ecereNameSpace__ecere__sys__TrimLSpaces(const char *  string, char *  output);
 664
 665 extern int strcmp(const char * , const char * );
 666
 667 extern int strtol(const char * , char * * , int base);
 668
 669 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);
 670
 671 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass___ecereNameSpace__ecere__com__BitMember;
 672
 673 struct __ecereNameSpace__ecere__com__BitMember
 674 {
 675 struct __ecereNameSpace__ecere__com__BitMember * prev;
 676 struct __ecereNameSpace__ecere__com__BitMember * next;
 677 const char *  name;
 678 unsigned int isProperty;
 679 int memberAccess;
 680 int id;
 681 struct __ecereNameSpace__ecere__com__Class * _class;
 682 const char *  dataTypeString;
 683 struct __ecereNameSpace__ecere__com__Class * dataTypeClass;
 684 struct Type * dataType;
 685 int type;
 686 int size;
 687 int pos;
 688 uint64 mask;
 689 } __attribute__ ((gcc_struct));
 690
 691 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);
 692
 693 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);
 694
 695 extern struct __ecereNameSpace__ecere__com__DataMember * __ecereNameSpace__ecere__com__eMember_New(int type, int declMode);
 696
 697 extern unsigned int __ecereNameSpace__ecere__com__eMember_AddMember(struct __ecereNameSpace__ecere__com__DataMember * addTo, struct __ecereNameSpace__ecere__com__DataMember * dataMember);
 698
 699 extern unsigned int __ecereNameSpace__ecere__com__eClass_AddMember(struct __ecereNameSpace__ecere__com__Class * _class, struct __ecereNameSpace__ecere__com__DataMember * dataMember);
 700
 701 extern char *  strcpy(char * , const char * );
 702
 703 unsigned int __ecereMethod___ecereNameSpace__ecere__sys__File_GetLine(struct __ecereNameSpace__ecere__com__Instance * this, char *  s, int max);
 704
 705 static void ReadDataMembers(struct __ecereNameSpace__ecere__com__Class * regClass, struct __ecereNameSpace__ecere__com__DataMember * member, struct __ecereNameSpace__ecere__com__Instance * f)
 706 {
 707 char line[1024];
 708 char name[1024];
 709 int size = 0, bitPos = -1;
 710 int memberAccess = 1;
 711
 712 for(; ; )
 713 {
 714 if(!__ecereMethod___ecereNameSpace__ecere__sys__File_GetLine(f, line, sizeof (line)))
 715 break;
 716 __ecereNameSpace__ecere__sys__TrimLSpaces(line, line);
 717 if(!strcmp(line, "."))
 718 break;
 719 if(line[0] == '[')
 720 {
 721 if(!strcmp(line, "[Size]"))
 722 {
 723 __ecereMethod___ecereNameSpace__ecere__sys__File_GetLine(f, line, sizeof (line));
 724 __ecereNameSpace__ecere__sys__TrimLSpaces(line, line);
 725 size = strtol(line, (((void *)0)), 0);
 726 }
 727 else if(!strcmp(line, "[Pos]"))
 728 {
 729 __ecereMethod___ecereNameSpace__ecere__sys__File_GetLine(f, line, sizeof (line));
 730 __ecereNameSpace__ecere__sys__TrimLSpaces(line, line);
 731 bitPos = strtol(line, (((void *)0)), 0);
 732 }
 733 else if(!strcmp(line, "[Public]"))
 734 memberAccess = 1;
 735 else if(!strcmp(line, "[Private]"))
 736 memberAccess = 2;
 737 else if(!strcmp(line, "[Type]"))
 738 {
 739 __ecereMethod___ecereNameSpace__ecere__sys__File_GetLine(f, line, sizeof (line));
 740 __ecereNameSpace__ecere__sys__TrimLSpaces(line, line);
 741 if(member)
 742 {
 743 if(!__ecereNameSpace__ecere__com__eMember_AddDataMember(member, name, line[0] ? line : 0, 0, 0, memberAccess))
 744 ;
 745 }
 746 else if(regClass && regClass->type == 2)
 747 {
 748 struct __ecereNameSpace__ecere__com__BitMember * member = __ecereNameSpace__ecere__com__eClass_AddBitMember(regClass, name, line[0] ? line : 0, 0, 0, memberAccess);
 749
 750 member->size = size;
 751 member->pos = bitPos;
 752 }
 753 else if(regClass)
 754 {
 755 if(!__ecereNameSpace__ecere__com__eClass_AddDataMember(regClass, name, line[0] ? line : 0, 0, 0, memberAccess))
 756 ;
 757 }
 758 }
 759 else if(!strcmp(line, "[Struct]") || !strcmp(line, "[Union]"))
 760 {
 761 struct __ecereNameSpace__ecere__com__DataMember * dataMember = (regClass || member) ? __ecereNameSpace__ecere__com__eMember_New((!strcmp(line, "[Union]")) ? 1 : 2, memberAccess) : (((void *)0));
 762
 763 ReadDataMembers((((void *)0)), dataMember, f);
 764 if(member)
 765 {
 766 if(!__ecereNameSpace__ecere__com__eMember_AddMember(member, dataMember))
 767 ;
 768 }
 769 else if(regClass)
 770 {
 771 if(!__ecereNameSpace__ecere__com__eClass_AddMember(regClass, dataMember))
 772 ;
 773 }
 774 }
 775 }
 776 else
 777 {
 778 size = 0;
 779 bitPos = -1;
 780 strcpy(name, line);
 781 memberAccess = 1;
 782 }
 783 }
 784 }
 785
 786 extern struct __ecereNameSpace__ecere__com__Instance * __ecereNameSpace__ecere__sys__FileOpenBuffered(const char *  fileName, int mode);
 787
 788 extern char *  __ecereNameSpace__ecere__sys__GetLastDirectory(const char *  string, char *  output);
 789
 790 extern int strcasecmp(const char * , const char * );
 791
 792 extern struct Symbol * DeclClass(int symbolID, const char *  name);
 793
 794 extern struct __ecereNameSpace__ecere__com__Class * __ecereNameSpace__ecere__com__eSystem_FindClass(struct __ecereNameSpace__ecere__com__Instance * module, const char *  name);
 795
 796 extern struct __ecereNameSpace__ecere__com__Instance * privateModule;
 797
 798 extern struct Symbol * FindClass(const char *  name);
 799
 800 extern const char *  sourceFile;
 801
 802 extern char *  strstr(const char * , const char * );
 803
 804 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);
 805
 806 extern char *  strcat(char * , const char * );
 807
 808 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass___ecereNameSpace__ecere__sys__OldLink;
 809
 810 struct __ecereNameSpace__ecere__sys__OldLink
 811 {
 812 struct __ecereNameSpace__ecere__sys__OldLink * prev;
 813 struct __ecereNameSpace__ecere__sys__OldLink * next;
 814 void *  data;
 815 } __attribute__ ((gcc_struct));
 816
 817 extern void __ecereNameSpace__ecere__com__eClass_DestructionWatchable(struct __ecereNameSpace__ecere__com__Class * _class);
 818
 819 extern struct ModuleImport * FindModule(struct __ecereNameSpace__ecere__com__Instance * moduleToFind);
 820
 821 extern struct ModuleImport * mainModule;
 822
 823 extern char *  strchr(const char * , int);
 824
 825 extern void *  memcpy(void * , const void * , size_t size);
 826
 827 extern char *  __ecereNameSpace__ecere__sys__TrimRSpaces(const char *  string, char *  output);
 828
 829 extern void __ecereNameSpace__ecere__com__eEnum_AddFixedValue(struct __ecereNameSpace__ecere__com__Class * _class, const char *  string, long long value);
 830
 831 extern long long strtoll(const char *  nptr, char * *  endptr, int base);
 832
 833 extern long long __ecereNameSpace__ecere__com__eEnum_AddValue(struct __ecereNameSpace__ecere__com__Class * _class, const char *  string);
 834
 835 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);
 836
 837 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);
 838
 839 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);
 840
 841 extern void __ecereNameSpace__ecere__com__eProperty_Watchable(struct __ecereNameSpace__ecere__com__Property * _property);
 842
 843 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass___ecereNameSpace__ecere__com__ClassProperty;
 844
 845 struct __ecereNameSpace__ecere__com__ClassProperty;
 846
 847 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);
 848
 849 extern char *  __ecereNameSpace__ecere__sys__CopyString(const char *  string);
 850
 851 extern struct __ecereNameSpace__ecere__com__Instance * pushLexer(void);
 852
 853 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_OpTable;
 854
 855 struct OpTable
 856 {
 857 unsigned int (*  Add)(struct Expression *, struct Operand *, struct Operand *);
 858 unsigned int (*  Sub)(struct Expression *, struct Operand *, struct Operand *);
 859 unsigned int (*  Mul)(struct Expression *, struct Operand *, struct Operand *);
 860 unsigned int (*  Div)(struct Expression *, struct Operand *, struct Operand *);
 861 unsigned int (*  Mod)(struct Expression *, struct Operand *, struct Operand *);
 862 unsigned int (*  Neg)(struct Expression *, struct Operand *);
 863 unsigned int (*  Inc)(struct Expression *, struct Operand *);
 864 unsigned int (*  Dec)(struct Expression *, struct Operand *);
 865 unsigned int (*  Asign)(struct Expression *, struct Operand *, struct Operand *);
 866 unsigned int (*  AddAsign)(struct Expression *, struct Operand *, struct Operand *);
 867 unsigned int (*  SubAsign)(struct Expression *, struct Operand *, struct Operand *);
 868 unsigned int (*  MulAsign)(struct Expression *, struct Operand *, struct Operand *);
 869 unsigned int (*  DivAsign)(struct Expression *, struct Operand *, struct Operand *);
 870 unsigned int (*  ModAsign)(struct Expression *, struct Operand *, struct Operand *);
 871 unsigned int (*  BitAnd)(struct Expression *, struct Operand *, struct Operand *);
 872 unsigned int (*  BitOr)(struct Expression *, struct Operand *, struct Operand *);
 873 unsigned int (*  BitXor)(struct Expression *, struct Operand *, struct Operand *);
 874 unsigned int (*  LShift)(struct Expression *, struct Operand *, struct Operand *);
 875 unsigned int (*  RShift)(struct Expression *, struct Operand *, struct Operand *);
 876 unsigned int (*  BitNot)(struct Expression *, struct Operand *);
 877 unsigned int (*  AndAsign)(struct Expression *, struct Operand *, struct Operand *);
 878 unsigned int (*  OrAsign)(struct Expression *, struct Operand *, struct Operand *);
 879 unsigned int (*  XorAsign)(struct Expression *, struct Operand *, struct Operand *);
 880 unsigned int (*  LShiftAsign)(struct Expression *, struct Operand *, struct Operand *);
 881 unsigned int (*  RShiftAsign)(struct Expression *, struct Operand *, struct Operand *);
 882 unsigned int (*  Not)(struct Expression *, struct Operand *);
 883 unsigned int (*  Equ)(struct Expression *, struct Operand *, struct Operand *);
 884 unsigned int (*  Nqu)(struct Expression *, struct Operand *, struct Operand *);
 885 unsigned int (*  And)(struct Expression *, struct Operand *, struct Operand *);
 886 unsigned int (*  Or)(struct Expression *, struct Operand *, struct Operand *);
 887 unsigned int (*  Grt)(struct Expression *, struct Operand *, struct Operand *);
 888 unsigned int (*  Sma)(struct Expression *, struct Operand *, struct Operand *);
 889 unsigned int (*  GrtEqu)(struct Expression *, struct Operand *, struct Operand *);
 890 unsigned int (*  SmaEqu)(struct Expression *, struct Operand *, struct Operand *);
 891 unsigned int (*  Cond)(struct Expression *, struct Operand *, struct Operand *, struct Operand *);
 892 } __attribute__ ((gcc_struct));
 893
 894 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_Operand;
 895
 896 struct Operand
 897 {
 898 int kind;
 899 struct Type * type;
 900 unsigned int ptrSize;
 901 union
 902 {
 903 char c;
 904 unsigned char uc;
 905 short s;
 906 unsigned short us;
 907 int i;
 908 unsigned int ui;
 909 float f;
 910 double d;
 911 long long i64;
 912 uint64 ui64;
 913 } __attribute__ ((gcc_struct)) __anon1;
 914 struct OpTable ops;
 915 } __attribute__ ((gcc_struct));
 916
 917 extern unsigned int skipErrors;
 918
 919 extern struct Expression * ParseExpressionString(char *  expression);
 920
 921 extern struct Type * ProcessTypeString(const char *  string, unsigned int staticMethod);
 922
 923 extern void ProcessExpressionType(struct Expression * exp);
 924
 925 extern void ComputeExpression(struct Expression * exp);
 926
 927 extern struct Operand GetOperand(struct Expression * exp);
 928
 929 extern void FreeExpression(struct Expression * exp);
 930
 931 extern void popLexer(struct __ecereNameSpace__ecere__com__Instance * backup);
 932
 933 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass___ecereNameSpace__ecere__com__ClassTemplateParameter;
 934
 935 struct __ecereNameSpace__ecere__com__ClassTemplateParameter;
 936
 937 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);
 938
 939 extern void __ecereNameSpace__ecere__com__eClass_DoneAddingTemplateParameters(struct __ecereNameSpace__ecere__com__Class * base);
 940
 941 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass___ecereNameSpace__ecere__com__DefinedExpression;
 942
 943 struct __ecereNameSpace__ecere__com__DefinedExpression;
 944
 945 extern struct __ecereNameSpace__ecere__com__DefinedExpression * __ecereNameSpace__ecere__com__eSystem_RegisterDefine(const char *  name, const char *  value, struct __ecereNameSpace__ecere__com__Instance * module, int declMode);
 946
 947 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass___ecereNameSpace__ecere__com__GlobalFunction;
 948
 949 struct __ecereNameSpace__ecere__com__GlobalFunction;
 950
 951 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);
 952
 953 extern char *  strncpy(char * , const char * , size_t n);
 954
 955 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass___ecereNameSpace__ecere__com__NameSpace;
 956
 957 struct __ecereNameSpace__ecere__com__NameSpace
 958 {
 959 const char *  name;
 960 struct __ecereNameSpace__ecere__com__NameSpace *  btParent;
 961 struct __ecereNameSpace__ecere__com__NameSpace *  left;
 962 struct __ecereNameSpace__ecere__com__NameSpace *  right;
 963 int depth;
 964 struct __ecereNameSpace__ecere__com__NameSpace *  parent;
 965 struct __ecereNameSpace__ecere__sys__BinaryTree nameSpaces;
 966 struct __ecereNameSpace__ecere__sys__BinaryTree classes;
 967 struct __ecereNameSpace__ecere__sys__BinaryTree defines;
 968 struct __ecereNameSpace__ecere__sys__BinaryTree functions;
 969 } __attribute__ ((gcc_struct));
 970
 971 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_GlobalData;
 972
 973 struct GlobalData
 974 {
 975 uintptr_t key;
 976 struct __ecereNameSpace__ecere__sys__BTNode * parent;
 977 struct __ecereNameSpace__ecere__sys__BTNode * left;
 978 struct __ecereNameSpace__ecere__sys__BTNode * right;
 979 int depth;
 980 struct __ecereNameSpace__ecere__com__Instance * module;
 981 char *  dataTypeString;
 982 struct Type * dataType;
 983 void *  symbol;
 984 char *  fullName;
 985 } __attribute__ ((gcc_struct));
 986
 987 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_DataRedefinition;
 988
 989 struct DataRedefinition
 990 {
 991 struct DataRedefinition * prev;
 992 struct DataRedefinition * next;
 993 char name[1024];
 994 char type1[1024];
 995 char type2[1024];
 996 } __attribute__ ((gcc_struct));
 997
 998 void ImportModule(const char *  name, int importType, int importAccess, unsigned int loadDllOnly);
 999
1000 extern char *  __ecereNameSpace__ecere__sys__GetSystemPathBuffer(char *  d, const char *  p);
1001
1002 extern void Compiler_Error(const char *  format, ...);
1003
1004 extern const char *  __ecereNameSpace__ecere__GetTranslatedString(const char * name, const char *  string, const char *  stringAndContext);
1005
1006 extern void *  __ecereNameSpace__ecere__com__eInstance_New(struct __ecereNameSpace__ecere__com__Class * _class);
1007
1008 int __ecereVMethodID___ecereNameSpace__ecere__sys__File_Eof;
1009
1010 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass___ecereNameSpace__ecere__sys__File;
1011
1012 struct __ecereNameSpace__ecere__sys__BTNode * __ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_FindString(struct __ecereNameSpace__ecere__sys__BinaryTree * this, const char *  key);
1013
1014 int __ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_CompareString(struct __ecereNameSpace__ecere__sys__BinaryTree * this, const char *  a, const char *  b);
1015
1016 unsigned int __ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_Add(struct __ecereNameSpace__ecere__sys__BinaryTree * this, struct __ecereNameSpace__ecere__sys__BTNode * node);
1017
1018 void __ecereMethod___ecereNameSpace__ecere__sys__OldList_Add(struct __ecereNameSpace__ecere__sys__OldList * this, void *  item);
1019
1020 extern void __ecereNameSpace__ecere__com__eInstance_DecRef(struct __ecereNameSpace__ecere__com__Instance * instance);
1021
1022 unsigned int LoadSymbols(const char * fileName, int importType, unsigned int loadDllOnly)
1023 {
1024 struct __ecereNameSpace__ecere__com__Instance * f = __ecereNameSpace__ecere__sys__FileOpenBuffered(fileName, 1);
1025 unsigned int globalInstance = 0;
1026
1027 if(f)
1028 {
1029 unsigned int ecereCOMModule = 0;
1030 char moduleName[797];
1031
1032 __ecereNameSpace__ecere__sys__GetLastDirectory(fileName, moduleName);
1033 if(!((strcasecmp)(moduleName, "instance.sym") && (strcasecmp)(moduleName, "BinaryTree.sym") && (strcasecmp)(moduleName, "dataTypes.sym") && (strcasecmp)(moduleName, "OldList.sym") && (strcasecmp)(moduleName, "String.sym") && (strcasecmp)(moduleName, "BTNode.sym") && (strcasecmp)(moduleName, "Array.sym") && (strcasecmp)(moduleName, "AVLTree.sym") && (strcasecmp)(moduleName, "BuiltInContainer.sym") && (strcasecmp)(moduleName, "Container.sym") && (strcasecmp)(moduleName, "CustomAVLTree.sym") && (strcasecmp)(moduleName, "LinkList.sym") && (strcasecmp)(moduleName, "List.sym") && (strcasecmp)(moduleName, "Map.sym") && (strcasecmp)(moduleName, "Mutex.sym")))
1034 ecereCOMModule = 1;
1035 for(; ; )
1036 {
1037 char line[1024];
1038
1039 if(!__ecereMethod___ecereNameSpace__ecere__sys__File_GetLine(f, line, sizeof (line)))
1040 break;
1041 __ecereNameSpace__ecere__sys__TrimLSpaces(line, line);
1042 if(line[0] == '[')
1043 {
1044 if(!strcmp(line, "[Global Instance]"))
1045 globalInstance = 1;
1046 else if(!strcmp(line, "[Defined Classes]"))
1047 {
1048 struct __ecereNameSpace__ecere__com__Class * regClass = (((void *)0));
1049 char name[1024];
1050 unsigned int isRemote = 0;
1051 unsigned int isStatic = 0;
1052 unsigned int isWatchable = 0;
1053 int classType = 0;
1054 unsigned int fixed = 0;
1055 unsigned int noExpansion = 0;
1056 int inheritanceAccess = 1;
1057
1058 for(; ; )
1059 {
1060 if(!__ecereMethod___ecereNameSpace__ecere__sys__File_GetLine(f, line, sizeof (line)))
1061 break;
1062 __ecereNameSpace__ecere__sys__TrimLSpaces(line, line);
1063 if(!strcmp(line, "."))
1064 break;
1065 if(line[0] == '[')
1066 {
1067 if(!strcmp(line, "[Remote]"))
1068 isRemote = 1;
1069 else if(!strcmp(line, "[Static]"))
1070 isStatic = 1;
1071 else if(!strcmp(line, "[Fixed]"))
1072 fixed = 1;
1073 else if(!strcmp(line, "[No Expansion]"))
1074 noExpansion = 1;
1075 else if(!strcmp(line, "[Watchable]"))
1076 isWatchable = 1;
1077 else if(!strcmp(line, "[Enum]"))
1078 classType = 4;
1079 else if(!strcmp(line, "[Bit]"))
1080 classType = 2;
1081 else if(!strcmp(line, "[Struct]"))
1082 classType = 1;
1083 else if(!strcmp(line, "[Unit]"))
1084 classType = 3;
1085 else if(!strcmp(line, "[NoHead]"))
1086 classType = 5;
1087 else if(!strcmp(line, "[Base]") || !strcmp(line, "[Private Base]"))
1088 {
1089 if(!strcmp(line, "[Private Base]"))
1090 inheritanceAccess = 2;
1091 __ecereMethod___ecereNameSpace__ecere__sys__File_GetLine(f, line, sizeof (line));
1092 __ecereNameSpace__ecere__sys__TrimLSpaces(line, line);
1093 if(importType == 3)
1094 DeclClass(0, name);
1095 if(isStatic || loadDllOnly || importType == 3 || importType == 4)
1096 regClass = (((void *)0));
1097 else if(regClass = __ecereNameSpace__ecere__com__eSystem_FindClass(privateModule, name), !regClass || regClass->internalDecl || regClass->isRemote)
1098 {
1099 struct Symbol * existingClass = FindClass(name);
1100 const char * baseName = (classType == 0 && importType == 2 && isRemote) ? "DCOMClientObject" : (!strcmp(line, "[None]") ? (((void *)0)) : line);
1101
1102 if(!isRemote || (importType != 2) || (!sourceFile || !strstr(sourceFile, ".main.ec")))
1103 {
1104 if(!regClass || regClass->internalDecl)
1105 regClass = __ecereNameSpace__ecere__com__eSystem_RegisterClass(classType, name, isRemote ? (((void *)0)) : baseName, 0, 0, (((void *)0)), (((void *)0)), privateModule, ecereCOMModule ? 4 : 1, inheritanceAccess);
1106 if(regClass && isRemote)
1107 regClass->isRemote = (importType == 2) ? 1 : 2;
1108 if(isRemote)
1109 {
1110 if(importType == 2)
1111 {
1112 char className[1024] = "DCOMClient_";
1113
1114 strcat(className, name);
1115 if(!existingClass)
1116 existingClass = DeclClass(0, name);
1117 regClass = __ecereNameSpace__ecere__com__eSystem_RegisterClass(classType, className, baseName, 0, 0, (((void *)0)), (((void *)0)), privateModule, ecereCOMModule ? 4 : 1, inheritanceAccess);
1118 }
1119 if(regClass)
1120 regClass->isRemote = (importType == 2) ? 1 : 3;
1121 }
1122 if(existingClass)
1123 {
1124 struct __ecereNameSpace__ecere__sys__OldLink * link;
1125
1126 for(link = existingClass->templatedClasses.first; link; link = link->next)
1127 {
1128 struct Symbol * symbol = link->data;
1129
1130 symbol->__anon1.registered = __ecereNameSpace__ecere__com__eSystem_FindClass(privateModule, symbol->string);
1131 }
1132 }
1133 if(fixed)
1134 regClass->fixed = 1;
1135 if(noExpansion)
1136 regClass->noExpansion = 1;
1137 if(isWatchable)
1138 {
1139 __ecereNameSpace__ecere__com__eClass_DestructionWatchable(regClass);
1140 regClass->structSize = regClass->offset;
1141 }
1142 if(regClass && existingClass)
1143 {
1144 existingClass->__anon1.registered = regClass;
1145 regClass->symbol = existingClass;
1146 existingClass->id = (((int)0x7fffffff));
1147 existingClass->idCode = (((int)0x7fffffff));
1148 existingClass->imported = 1;
1149 if(regClass->module)
1150 existingClass->module = FindModule(regClass->module);
1151 else
1152 existingClass->module = mainModule;
1153 }
1154 }
1155 else
1156 regClass = (((void *)0));
1157 }
1158 else
1159 regClass = (((void *)0));
1160 isRemote = 0;
1161 isWatchable = 0;
1162 fixed = 0;
1163 isStatic = 0;
1164 }
1165 else if(!strcmp(line, "[Enum Values]"))
1166 {
1167 for(; ; )
1168 {
1169 char * equal;
1170
1171 if(!__ecereMethod___ecereNameSpace__ecere__sys__File_GetLine(f, line, sizeof (line)))
1172 break;
1173 __ecereNameSpace__ecere__sys__TrimLSpaces(line, line);
1174 if(!strcmp(line, "."))
1175 break;
1176 if(regClass)
1177 {
1178 equal = strchr(line, '=');
1179 if(equal)
1180 {
1181 char name[1024];
1182
1183 memcpy(name, line, (int)(equal - line));
1184 name[equal - line] = '\0';
1185 __ecereNameSpace__ecere__sys__TrimLSpaces(name, name);
1186 __ecereNameSpace__ecere__sys__TrimRSpaces(name, name);
1187 __ecereNameSpace__ecere__com__eEnum_AddFixedValue(regClass, name, strtoll(equal + 1, (((void *)0)), 0));
1188 }
1189 else
1190 {
1191 __ecereNameSpace__ecere__com__eEnum_AddValue(regClass, line);
1192 }
1193 }
1194 }
1195 }
1196 else if(!strcmp(line, "[Defined Methods]"))
1197 {
1198 char name[1024];
1199 unsigned int isVirtual = 0;
1200 int memberAccess = 1;
1201
1202 for(; ; )
1203 {
1204 if(!__ecereMethod___ecereNameSpace__ecere__sys__File_GetLine(f, line, sizeof (line)))
1205 break;
1206 __ecereNameSpace__ecere__sys__TrimLSpaces(line, line);
1207 if(!strcmp(line, "."))
1208 break;
1209 if(line[0] == '[')
1210 {
1211 if(!strcmp(line, "[Type]"))
1212 {
1213 __ecereMethod___ecereNameSpace__ecere__sys__File_GetLine(f, line, sizeof (line));
1214 if(regClass)
1215 {
1216 __ecereNameSpace__ecere__sys__TrimLSpaces(line, line);
1217 if(isVirtual)
1218 __ecereNameSpace__ecere__com__eClass_AddVirtualMethod(regClass, name, line[0] ? line : 0, DummyMethod, memberAccess);
1219 else
1220 __ecereNameSpace__ecere__com__eClass_AddMethod(regClass, name, line[0] ? line : 0, DummyMethod, memberAccess);
1221 }
1222 }
1223 else if(!strcmp(line, "[Virtual]"))
1224 isVirtual = 1;
1225 else if(!strcmp(line, "[Public]"))
1226 memberAccess = 1;
1227 else if(!strcmp(line, "[Private]"))
1228 memberAccess = 2;
1229 }
1230 else
1231 {
1232 strcpy(name, line);
1233 isVirtual = 0;
1234 memberAccess = 1;
1235 }
1236 }
1237 }
1238 else if(!strcmp(line, "[Defined Properties]"))
1239 {
1240 char name[1024];
1241 unsigned int setStmt = 0, getStmt = 0, isVirtual = 0, conversion = 0;
1242 unsigned int isWatchable = 0;
1243 int memberAccess = 1;
1244
1245 for(; ; )
1246 {
1247 if(!__ecereMethod___ecereNameSpace__ecere__sys__File_GetLine(f, line, sizeof (line)))
1248 break;
1249 __ecereNameSpace__ecere__sys__TrimLSpaces(line, line);
1250 if(!strcmp(line, "."))
1251 break;
1252 if(line[0] == '[')
1253 {
1254 if(!strcmp(line, "[Type]"))
1255 {
1256 __ecereMethod___ecereNameSpace__ecere__sys__File_GetLine(f, line, sizeof (line));
1257 __ecereNameSpace__ecere__sys__TrimLSpaces(line, line);
1258 if(regClass)
1259 {
1260 struct __ecereNameSpace__ecere__com__Property * prop = __ecereNameSpace__ecere__com__eClass_AddProperty(regClass, conversion ? (((void *)0)) : name, line[0] ? line : 0, (void *)(uintptr_t)setStmt, (void *)(uintptr_t)getStmt, memberAccess);
1261
1262 if(prop)
1263 {
1264 prop->compiled = 0;
1265 if(isWatchable)
1266 {
1267 __ecereNameSpace__ecere__com__eProperty_Watchable(prop);
1268 regClass->structSize = regClass->offset;
1269 }
1270 }
1271 }
1272 }
1273 else if(!strcmp(line, "[Set]"))
1274 setStmt = 1;
1275 else if(!strcmp(line, "[Get]"))
1276 getStmt = 1;
1277 else if(!strcmp(line, "[Watchable]"))
1278 isWatchable = 1;
1279 else if(!strcmp(line, "[Public]"))
1280 memberAccess = 1;
1281 else if(!strcmp(line, "[Private]"))
1282 memberAccess = 2;
1283 else if(!strcmp(line, "[Conversion]"))
1284 {
1285 conversion = 1;
1286 setStmt = getStmt = isVirtual = isWatchable = 0;
1287 }
1288 }
1289 else
1290 {
1291 strcpy(name, line);
1292 setStmt = getStmt = isVirtual = conversion = isWatchable = 0;
1293 memberAccess = 1;
1294 }
1295 }
1296 }
1297 else if(!strcmp(line, "[Defined Class Properties]"))
1298 {
1299 char name[1024];
1300 unsigned int setStmt = 0, getStmt = 0;
1301
1302 for(; ; )
1303 {
1304 if(!__ecereMethod___ecereNameSpace__ecere__sys__File_GetLine(f, line, sizeof (line)))
1305 break;
1306 __ecereNameSpace__ecere__sys__TrimLSpaces(line, line);
1307 if(!strcmp(line, "."))
1308 break;
1309 if(line[0] == '[')
1310 {
1311 if(!strcmp(line, "[Type]"))
1312 {
1313 __ecereMethod___ecereNameSpace__ecere__sys__File_GetLine(f, line, sizeof (line));
1314 __ecereNameSpace__ecere__sys__TrimLSpaces(line, line);
1315 if(regClass)
1316 {
1317 __ecereNameSpace__ecere__com__eClass_AddClassProperty(regClass, name, line, (void *)(uintptr_t)setStmt, (void *)(uintptr_t)getStmt);
1318 }
1319 }
1320 else if(!strcmp(line, "[Set]"))
1321 setStmt = 1;
1322 else if(!strcmp(line, "[Get]"))
1323 getStmt = 1;
1324 }
1325 else
1326 {
1327 strcpy(name, line);
1328 setStmt = getStmt = 0;
1329 }
1330 }
1331 }
1332 else if(!strcmp(line, "[Defined Data Members]"))
1333 {
1334 ReadDataMembers(regClass, (((void *)0)), f);
1335 }
1336 else if(!strcmp(line, "[Template Parameters]"))
1337 {
1338 while(!((unsigned int (*)(struct __ecereNameSpace__ecere__com__Instance *))__extension__ ({
1339 struct __ecereNameSpace__ecere__com__Instance * __internal_ClassInst = f;
1340
1341 __internal_ClassInst ? __internal_ClassInst->_vTbl : __ecereClass___ecereNameSpace__ecere__sys__File->_vTbl;
1342 })[__ecereVMethodID___ecereNameSpace__ecere__sys__File_Eof])(f))
1343 {
1344 char name[1024];
1345 int type = 0;
1346 struct __ecereNameSpace__ecere__com__ClassTemplateArgument defaultArg =
1347 {
1348
1349 .__anon1 = {
1350
1351 .__anon1 = {
1352 .dataTypeString = 0
1353 }
1354 }
1355 };
1356 void * info = (((void *)0));
1357
1358 __ecereMethod___ecereNameSpace__ecere__sys__File_GetLine(f, line, sizeof (line));
1359 __ecereNameSpace__ecere__sys__TrimLSpaces(line, line);
1360 if(line[0] == '.')
1361 break;
1362 strcpy(name, line);
1363 __ecereMethod___ecereNameSpace__ecere__sys__File_GetLine(f, line, sizeof (line));
1364 __ecereNameSpace__ecere__sys__TrimLSpaces(line, line);
1365 if(!strcmp(line, "[Expression]"))
1366 type = 2;
1367 else if(!strcmp(line, "[Identifier]"))
1368 type = 1;
1369 switch(type)
1370 {
1371 case 0:
1372 __ecereMethod___ecereNameSpace__ecere__sys__File_GetLine(f, line, sizeof (line));
1373 __ecereNameSpace__ecere__sys__TrimLSpaces(line, line);
1374 if(regClass && strcmp(line, "[None]"))
1375 {
1376 info = __ecereNameSpace__ecere__sys__CopyString(line);
1377 }
1378 __ecereMethod___ecereNameSpace__ecere__sys__File_GetLine(f, line, sizeof (line));
1379 __ecereNameSpace__ecere__sys__TrimLSpaces(line, line);
1380 if(regClass && strcmp(line, "[None]"))
1381 {
1382 defaultArg.__anon1.__anon1.dataTypeString = __ecereNameSpace__ecere__sys__CopyString(line);
1383 }
1384 break;
1385 case 2:
1386 __ecereMethod___ecereNameSpace__ecere__sys__File_GetLine(f, line, sizeof (line));
1387 __ecereNameSpace__ecere__sys__TrimLSpaces(line, line);
1388 if(regClass && strcmp(line, "[None]"))
1389 {
1390 info = __ecereNameSpace__ecere__sys__CopyString(line);
1391 }
1392 __ecereMethod___ecereNameSpace__ecere__sys__File_GetLine(f, line, sizeof (line));
1393 __ecereNameSpace__ecere__sys__TrimLSpaces(line, line);
1394 if(regClass && strcmp(line, "[None]"))
1395 {
1396 struct __ecereNameSpace__ecere__com__Instance * backup = pushLexer();
1397 struct Operand op;
1398 struct Expression * exp;
1399
1400 skipErrors = 1;
1401 exp = ParseExpressionString(line);
1402 if(exp)
1403 {
1404 if(info)
1405 exp->destType = ProcessTypeString(info, 0);
1406 ProcessExpressionType(exp);
1407 ComputeExpression(exp);
1408 op = GetOperand(exp);
1409 defaultArg.__anon1.expression.__anon1.ui64 = op.__anon1.ui64;
1410 FreeExpression(exp);
1411 }
1412 skipErrors = 0;
1413 popLexer(backup);
1414 }
1415 break;
1416 case 1:
1417 __ecereMethod___ecereNameSpace__ecere__sys__File_GetLine(f, line, sizeof (line));
1418 __ecereNameSpace__ecere__sys__TrimLSpaces(line, line);
1419 if(!strcmp(line, "[Data member]"))
1420 info = (void *)0;
1421 else if(!strcmp(line, "[Method]"))
1422 info = (void *)1;
1423 else if(!strcmp(line, "[Property]"))
1424 info = (void *)2;
1425 __ecereMethod___ecereNameSpace__ecere__sys__File_GetLine(f, line, sizeof (line));
1426 __ecereNameSpace__ecere__sys__TrimLSpaces(line, line);
1427 if(regClass && strcmp(line, "[None]"))
1428 {
1429 defaultArg.__anon1.__anon2.memberString = __ecereNameSpace__ecere__sys__CopyString(line);
1430 }
1431 break;
1432 }
1433 if(regClass)
1434 __ecereNameSpace__ecere__com__eClass_AddTemplateParameter(regClass, name, type, info, &defaultArg);
1435 if(type == 0 || type == 2)
1436 (__ecereNameSpace__ecere__com__eSystem_Delete(info), info = 0);
1437 if(type == 0 || type == 1)
1438 (__ecereNameSpace__ecere__com__eSystem_Delete((void *)defaultArg.__anon1.__anon1.dataTypeString), defaultArg.__anon1.__anon1.dataTypeString = 0);
1439 }
1440 if(regClass)
1441 __ecereNameSpace__ecere__com__eClass_DoneAddingTemplateParameters(regClass);
1442 }
1443 }
1444 else
1445 {
1446 inheritanceAccess = 1;
1447 classType = 0;
1448 isRemote = 0;
1449 strcpy(name, line);
1450 regClass = (((void *)0));
1451 }
1452 }
1453 }
1454 else if(!strcmp(line, "[Defined Expressions]"))
1455 {
1456 char name[1024];
1457
1458 for(; ; )
1459 {
1460 if(!__ecereMethod___ecereNameSpace__ecere__sys__File_GetLine(f, line, sizeof (line)))
1461 break;
1462 __ecereNameSpace__ecere__sys__TrimLSpaces(line, line);
1463 if(!strcmp(line, "."))
1464 break;
1465 if(!strcmp(line, "[Value]"))
1466 {
1467 __ecereMethod___ecereNameSpace__ecere__sys__File_GetLine(f, line, sizeof (line));
1468 __ecereNameSpace__ecere__sys__TrimLSpaces(line, line);
1469 if(!loadDllOnly && importType != 3 && importType != 4)
1470 __ecereNameSpace__ecere__com__eSystem_RegisterDefine(name, line, privateModule, ecereCOMModule ? 4 : 1);
1471 }
1472 else if(line[0] != '[')
1473 {
1474 strcpy(name, line);
1475 }
1476 }
1477 }
1478 else if(!strcmp(line, "[Defined Functions]"))
1479 {
1480 char name[1024];
1481
1482 for(; ; )
1483 {
1484 if(!__ecereMethod___ecereNameSpace__ecere__sys__File_GetLine(f, line, sizeof (line)))
1485 break;
1486 __ecereNameSpace__ecere__sys__TrimLSpaces(line, line);
1487 if(!strcmp(line, "."))
1488 break;
1489 if(!strcmp(line, "[Type]"))
1490 {
1491 __ecereMethod___ecereNameSpace__ecere__sys__File_GetLine(f, line, sizeof (line));
1492 __ecereNameSpace__ecere__sys__TrimLSpaces(line, line);
1493 if(!loadDllOnly && importType != 3 && importType != 4)
1494 __ecereNameSpace__ecere__com__eSystem_RegisterFunction(name, line, (((void *)0)), privateModule, ecereCOMModule ? 4 : 1);
1495 }
1496 else if(line[0] != '[')
1497 {
1498 strcpy(name, line);
1499 }
1500 }
1501 }
1502 else if(!strcmp(line, "[Defined Data]"))
1503 {
1504 char name[1024];
1505
1506 for(; ; )
1507 {
1508 if(!__ecereMethod___ecereNameSpace__ecere__sys__File_GetLine(f, line, sizeof (line)))
1509 break;
1510 __ecereNameSpace__ecere__sys__TrimLSpaces(line, line);
1511 if(!strcmp(line, "."))
1512 break;
1513 if(!strcmp(line, "[Type]"))
1514 {
1515 __ecereMethod___ecereNameSpace__ecere__sys__File_GetLine(f, line, sizeof (line));
1516 __ecereNameSpace__ecere__sys__TrimLSpaces(line, line);
1517 if(!loadDllOnly && importType != 3 && importType != 4)
1518 {
1519 int start = 0, c;
1520 struct __ecereNameSpace__ecere__com__NameSpace * nameSpace = globalData;
1521 struct GlobalData * data;
1522
1523 for(c = 0; name[c]; c++)
1524 {
1525 if(name[c] == '.' || (name[c] == ':' && name[c + 1] == ':'))
1526 {
1527 struct __ecereNameSpace__ecere__com__NameSpace * newSpace;
1528 char * spaceName = __ecereNameSpace__ecere__com__eSystem_New(sizeof(char) * (c - start + 1));
1529
1530 strncpy(spaceName, name + start, c - start);
1531 spaceName[c - start] = '\0';
1532 newSpace = (struct __ecereNameSpace__ecere__com__NameSpace *)__ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_FindString(&(*nameSpace).nameSpaces, spaceName);
1533 if(!newSpace)
1534 {
1535 newSpace = __ecereNameSpace__ecere__com__eSystem_New0(sizeof(struct __ecereNameSpace__ecere__com__NameSpace) * (1));
1536 (*newSpace).classes.CompareKey = (void *)__ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_CompareString;
1537 (*newSpace).defines.CompareKey = (void *)__ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_CompareString;
1538 (*newSpace).functions.CompareKey = (void *)__ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_CompareString;
1539 (*newSpace).nameSpaces.CompareKey = (void *)__ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_CompareString;
1540 (*newSpace).name = spaceName;
1541 (*newSpace).parent = nameSpace;
1542 __ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_Add(&(*nameSpace).nameSpaces, (struct __ecereNameSpace__ecere__sys__BTNode *)newSpace);
1543 }
1544 else
1545 (__ecereNameSpace__ecere__com__eSystem_Delete(spaceName), spaceName = 0);
1546 nameSpace = newSpace;
1547 if(name[c] == ':')
1548 c++;
1549 start = c + 1;
1550 }
1551 }
1552 if(c - start)
1553 {
1554 data = (struct GlobalData *)__ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_FindString(&(*nameSpace).functions, name + start);
1555 if(!data)
1556 {
1557 data = __extension__ ({
1558 struct GlobalData * __ecereInstance1 = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass_GlobalData);
1559
1560 __ecereInstance1->fullName = __ecereNameSpace__ecere__sys__CopyString(name), __ecereInstance1->dataTypeString = __ecereNameSpace__ecere__sys__CopyString(line), __ecereInstance1->module = privateModule, __ecereInstance1;
1561 });
1562 data->key = (uintptr_t)(data->fullName + start);
1563 __ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_Add(&(*nameSpace).functions, (struct __ecereNameSpace__ecere__sys__BTNode *)data);
1564 }
1565 else if(strcmp(data->dataTypeString, line))
1566 {
1567 struct DataRedefinition * redefinition = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass_DataRedefinition);
1568
1569 strcpy(redefinition->name, name);
1570 strcpy(redefinition->type1, data->dataTypeString);
1571 strcpy(redefinition->type2, line);
1572 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Add(&dataRedefinitions, redefinition);
1573 }
1574 }
1575 }
1576 }
1577 else if(line[0] != '[')
1578 {
1579 strcpy(name, line);
1580 }
1581 }
1582 }
1583 else if(!strcmp(line, "[Imported Modules]"))
1584 {
1585 int moduleImportType = 0;
1586 int importAccess = 1;
1587
1588 for(; ; )
1589 {
1590 if(!__ecereMethod___ecereNameSpace__ecere__sys__File_GetLine(f, line, sizeof (line)))
1591 break;
1592 __ecereNameSpace__ecere__sys__TrimLSpaces(line, line);
1593 if(!strcmp(line, "."))
1594 break;
1595 if(!strcmp(line, "[Static]"))
1596 moduleImportType = 1;
1597 else if(!strcmp(line, "[Remote]"))
1598 moduleImportType = 2;
1599 else if(!strcmp(line, "[Private]"))
1600 importAccess = 2;
1601 else if(line[0] != '[')
1602 {
1603 if(importType != 3 && importType != 4)
1604 ImportModule(line, moduleImportType, importAccess, loadDllOnly);
1605 else
1606 ImportModule(line, 4, importAccess, loadDllOnly);
1607 if(!strcmp(line, "ecere"))
1608 ecereImported = 1;
1609 moduleImportType = 0;
1610 importAccess = 1;
1611 }
1612 }
1613 }
1614 }
1615 }
1616 (__ecereNameSpace__ecere__com__eInstance_DecRef(f), f = 0);
1617 }
1618 else if(importType != 4)
1619 {
1620 char sysFileName[797];
1621
1622 __ecereNameSpace__ecere__sys__GetSystemPathBuffer(sysFileName, fileName);
1623 Compiler_Error(__ecereNameSpace__ecere__GetTranslatedString("ec", "Couldn't open %s\n", (((void *)0))), sysFileName);
1624 }
1625 return globalInstance;
1626 }
1627
1628 struct __ecereNameSpace__ecere__com__Instance * loadedModules;
1629
1630 extern unsigned int __ecereNameSpace__ecere__sys__StripExtension(char *  string);
1631
1632 extern struct __ecereNameSpace__ecere__sys__OldList *  defines;
1633
1634 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_ImportedModule;
1635
1636 struct ImportedModule
1637 {
1638 struct ImportedModule * prev;
1639 struct ImportedModule * next;
1640 char *  name;
1641 int type;
1642 int importType;
1643 unsigned int globalInstance;
1644 unsigned int dllOnly;
1645 int importAccess;
1646 } __attribute__ ((gcc_struct));
1647
1648 extern size_t strlen(const char * );
1649
1650 extern char *  __ecereNameSpace__ecere__sys__GetExtension(const char *  string, char *  output);
1651
1652 extern char *  symbolsDir;
1653
1654 extern char *  __ecereNameSpace__ecere__sys__PathCat(char *  string, const char *  addedPath);
1655
1656 extern char *  __ecereNameSpace__ecere__sys__ChangeExtension(const char *  string, const char *  ext, char *  output);
1657
1658 extern unsigned int __ecereNameSpace__ecere__sys__FileExists(const char *  fileName);
1659
1660 extern unsigned int inCompiler;
1661
1662 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass___ecereNameSpace__ecere__com__IteratorPointer;
1663
1664 struct __ecereNameSpace__ecere__com__IteratorPointer;
1665
1666 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass___ecereNameSpace__ecere__com__MapIterator;
1667
1668 struct __ecereNameSpace__ecere__com__MapIterator
1669 {
1670 struct __ecereNameSpace__ecere__com__Instance * container;
1671 struct __ecereNameSpace__ecere__com__IteratorPointer * pointer;
1672 } __attribute__ ((gcc_struct));
1673
1674 extern struct __ecereNameSpace__ecere__com__Instance * __ecereNameSpace__ecere__com__eModule_LoadStrict(struct __ecereNameSpace__ecere__com__Instance * fromModule, const char *  name, int importAccess);
1675
1676 extern struct __ecereNameSpace__ecere__com__Instance * __thisModule;
1677
1678 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass___ecereNameSpace__ecere__com__Module;
1679
1680 struct __ecereNameSpace__ecere__com__Module
1681 {
1682 struct __ecereNameSpace__ecere__com__Instance * application;
1683 struct __ecereNameSpace__ecere__sys__OldList classes;
1684 struct __ecereNameSpace__ecere__sys__OldList defines;
1685 struct __ecereNameSpace__ecere__sys__OldList functions;
1686 struct __ecereNameSpace__ecere__sys__OldList modules;
1687 struct __ecereNameSpace__ecere__com__Instance * prev;
1688 struct __ecereNameSpace__ecere__com__Instance * next;
1689 const char *  name;
1690 void *  library;
1691 void *  Unload;
1692 int importType;
1693 int origImportType;
1694 struct __ecereNameSpace__ecere__com__NameSpace privateNameSpace;
1695 struct __ecereNameSpace__ecere__com__NameSpace publicNameSpace;
1696 } __attribute__ ((gcc_struct));
1697
1698 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass___ecereNameSpace__ecere__com__Iterator;
1699
1700 struct __ecereNameSpace__ecere__com__Iterator
1701 {
1702 struct __ecereNameSpace__ecere__com__Instance * container;
1703 struct __ecereNameSpace__ecere__com__IteratorPointer * pointer;
1704 } __attribute__ ((gcc_struct));
1705
1706 extern int sprintf(char * , const char * , ...);
1707
1708 extern int __ecereNameSpace__ecere__com__GetRuntimePlatform(void);
1709
1710 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass___ecereNameSpace__ecere__com__List_TPL_ecere__com__Module_;
1711
1712 unsigned int __ecereMethod___ecereNameSpace__ecere__sys__OldList_AddName(struct __ecereNameSpace__ecere__sys__OldList * this, void *  item);
1713
1714 struct __ecereNameSpace__ecere__com__Instance * __ecereProp___ecereNameSpace__ecere__com__MapIterator_Get_map(struct __ecereNameSpace__ecere__com__MapIterator * this);
1715
1716 void __ecereProp___ecereNameSpace__ecere__com__MapIterator_Set_map(struct __ecereNameSpace__ecere__com__MapIterator * this, struct __ecereNameSpace__ecere__com__Instance * value);
1717
1718 extern struct __ecereNameSpace__ecere__com__Property ** __ecereProp___ecereNameSpace__ecere__com__MapIterator_map;
1719
1720 unsigned int __ecereMethod___ecereNameSpace__ecere__com__Iterator_Index(struct __ecereNameSpace__ecere__com__Iterator * this, const uint64 index, unsigned int create);
1721
1722 int __ecereVMethodID___ecereNameSpace__ecere__com__Container_Add;
1723
1724 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass___ecereNameSpace__ecere__com__List;
1725
1726 uint64 __ecereProp___ecereNameSpace__ecere__com__Iterator_Get_data(struct __ecereNameSpace__ecere__com__Iterator * this);
1727
1728 void __ecereProp___ecereNameSpace__ecere__com__Iterator_Set_data(struct __ecereNameSpace__ecere__com__Iterator * this, uint64 value);
1729
1730 extern struct __ecereNameSpace__ecere__com__Property ** __ecereProp___ecereNameSpace__ecere__com__Iterator_data;
1731
1732 unsigned int __ecereMethod___ecereNameSpace__ecere__com__Iterator_Next();
1733
1734 void ImportModule(const char * name, int importType, int importAccess, unsigned int loadDllOnly)
1735 {
1736 struct ImportedModule * module = (((void *)0));
1737 char moduleName[797];
1738
1739 strncpy(moduleName, name, (797) - 1);
1740 moduleName[(797) - 1] = (char)0;
1741 __ecereNameSpace__ecere__sys__StripExtension(moduleName);
1742 for(module = (*defines).first; module; module = module->next)
1743 {
1744 if(module->type == 0 && !(strcasecmp)(module->name, moduleName))
1745 break;
1746 }
1747 if((!module || (module->dllOnly && !loadDllOnly)) && strlen(name) < (274))
1748 {
1749 char ext[17];
1750 struct __ecereNameSpace__ecere__com__Instance * loadedModule = (((void *)0));
1751 char symFile[797];
1752
1753 symFile[0] = '\0';
1754 __ecereNameSpace__ecere__sys__GetExtension(name, ext);
1755 strcpy(symFile, symbolsDir ? symbolsDir : "");
1756 __ecereNameSpace__ecere__sys__PathCat(symFile, name);
1757 __ecereNameSpace__ecere__sys__ChangeExtension(symFile, "sym", symFile);
1758 if(!strcmp(ext, "dll") || !strcmp(ext, "so") || !strcmp(ext, "dylib") || !ext[0])
1759 {
1760 if(importType != 4)
1761 {
1762 if(!module)
1763 {
1764 if(precompDefines)
1765 {
1766 module = __extension__ ({
1767 struct ImportedModule * __ecereInstance1 = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass_ImportedModule);
1768
1769 __ecereInstance1->name = __ecereNameSpace__ecere__sys__CopyString(moduleName), __ecereInstance1->type = 0, __ecereInstance1->importType = importType, __ecereInstance1->importAccess = importAccess, __ecereInstance1;
1770 });
1771 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Add((&*precompDefines), module);
1772 }
1773 module = __extension__ ({
1774 struct ImportedModule * __ecereInstance1 = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass_ImportedModule);
1775
1776 __ecereInstance1->name = __ecereNameSpace__ecere__sys__CopyString(moduleName), __ecereInstance1->type = 0, __ecereInstance1->importType = importType, __ecereInstance1->importAccess = importAccess, __ecereInstance1;
1777 });
1778 __ecereMethod___ecereNameSpace__ecere__sys__OldList_AddName((&*defines), module);
1779 }
1780 module->dllOnly = loadDllOnly;
1781 if(ext[0] || !__ecereNameSpace__ecere__sys__FileExists(symFile))
1782 {
1783 unsigned int skipLoad = 0;
1784 struct __ecereNameSpace__ecere__com__Instance * list = (((void *)0));
1785
1786 if(!inCompiler && !inPreCompiler && !inSymbolGen)
1787 {
1788 struct __ecereNameSpace__ecere__com__MapIterator it = (it.container = (void *)0, it.pointer = (void *)0, __ecereProp___ecereNameSpace__ecere__com__MapIterator_Set_map(&it, loadedModules), it);
1789
1790 if(!__ecereMethod___ecereNameSpace__ecere__com__Iterator_Index((void *)&it, (uint64)(name), 0))
1791 {
1792 struct __ecereNameSpace__ecere__com__Instance * firstModule = __ecereNameSpace__ecere__com__eModule_LoadStrict(((struct __ecereNameSpace__ecere__com__Module *)(((char *)__thisModule + structSize_Instance)))->application, name, importAccess);
1793
1794 if(firstModule)
1795 {
1796 list = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass___ecereNameSpace__ecere__com__List_TPL_ecere__com__Module_);
1797 ((struct __ecereNameSpace__ecere__com__IteratorPointer * (*)(struct __ecereNameSpace__ecere__com__Instance *, uint64 value))__extension__ ({
1798 struct __ecereNameSpace__ecere__com__Instance * __internal_ClassInst = list;
1799
1800 __internal_ClassInst ? __internal_ClassInst->_vTbl : __ecereClass___ecereNameSpace__ecere__com__List->_vTbl;
1801 })[__ecereVMethodID___ecereNameSpace__ecere__com__Container_Add])(list, (uint64)(firstModule));
1802 __extension__ ({
1803 struct __ecereNameSpace__ecere__com__Iterator __internalIterator =
1804 {
1805 loadedModules, 0
1806 };
1807
1808 __ecereMethod___ecereNameSpace__ecere__com__Iterator_Index(&__internalIterator, ((uint64)(name)), 1);
1809 __ecereProp___ecereNameSpace__ecere__com__Iterator_Set_data(&__internalIterator, ((uint64)(list)));
1810 });
1811 }
1812 else
1813 skipLoad = 1;
1814 }
1815 else
1816 list = ((struct __ecereNameSpace__ecere__com__Instance *)__ecereProp___ecereNameSpace__ecere__com__Iterator_Get_data((void *)&it));
1817 }
1818 if(!skipLoad)
1819 {
1820 loadedModule = __ecereNameSpace__ecere__com__eModule_LoadStrict(privateModule, name, importAccess);
1821 if(loadedModule)
1822 {
1823 ((struct __ecereNameSpace__ecere__com__Module *)(((char *)loadedModule + structSize_Instance)))->importType = importType;
1824 module->dllOnly = 0x0;
1825 if(list)
1826 ((struct __ecereNameSpace__ecere__com__IteratorPointer * (*)(struct __ecereNameSpace__ecere__com__Instance *, uint64 value))__extension__ ({
1827 struct __ecereNameSpace__ecere__com__Instance * __internal_ClassInst = list;
1828
1829 __internal_ClassInst ? __internal_ClassInst->_vTbl : __ecereClass___ecereNameSpace__ecere__com__List->_vTbl;
1830 })[__ecereVMethodID___ecereNameSpace__ecere__com__Container_Add])(list, (uint64)(loadedModule));
1831 }
1832 }
1833 }
1834 }
1835 }
1836 if(!loadedModule && (!strcmp(ext, "ec") || !strcmp(ext, "sym") || !ext[0]))
1837 {
1838 {
1839 if(!module)
1840 {
1841 if(precompDefines)
1842 {
1843 module = __extension__ ({
1844 struct ImportedModule * __ecereInstance1 = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass_ImportedModule);
1845
1846 __ecereInstance1->name = __ecereNameSpace__ecere__sys__CopyString(moduleName), __ecereInstance1->type = 0, __ecereInstance1->importType = importType, __ecereInstance1->importAccess = importAccess, __ecereInstance1;
1847 });
1848 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Add((&*precompDefines), module);
1849 }
1850 module = __extension__ ({
1851 struct ImportedModule * __ecereInstance1 = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass_ImportedModule);
1852
1853 __ecereInstance1->name = __ecereNameSpace__ecere__sys__CopyString(moduleName), __ecereInstance1->type = 0, __ecereInstance1->importType = importType, __ecereInstance1->importAccess = importAccess, __ecereInstance1;
1854 });
1855 __ecereMethod___ecereNameSpace__ecere__sys__OldList_AddName((&*defines), module);
1856 }
1857 module->dllOnly = loadDllOnly;
1858 if(inPreCompiler)
1859 return ;
1860 if(inIDE && !__ecereNameSpace__ecere__sys__FileExists(symFile) && sourceDirs)
1861 {
1862 {
1863 struct __ecereNameSpace__ecere__com__Iterator dir =
1864 {
1865 (sourceDirs), 0
1866 };
1867
1868 while(__ecereMethod___ecereNameSpace__ecere__com__Iterator_Next(&dir))
1869 {
1870 char configDir[274];
1871
1872 strcpy(symFile, ((char * )(__ecereProp___ecereNameSpace__ecere__com__Iterator_Get_data(&dir))));
1873 __ecereNameSpace__ecere__sys__PathCat(symFile, "obj");
1874 sprintf(configDir, "debug.%s", (__ecereNameSpace__ecere__com__GetRuntimePlatform() == 1) ? "win32" : "linux");
1875 __ecereNameSpace__ecere__sys__PathCat(symFile, configDir);
1876 __ecereNameSpace__ecere__sys__PathCat(symFile, name);
1877 __ecereNameSpace__ecere__sys__ChangeExtension(symFile, "sym", symFile);
1878 if(__ecereNameSpace__ecere__sys__FileExists(symFile))
1879 break;
1880 }
1881 }
1882 }
1883 if(!__ecereNameSpace__ecere__sys__FileExists(symFile))
1884 {
1885 char fileName[274];
1886
1887 __ecereNameSpace__ecere__sys__GetLastDirectory(symFile, fileName);
1888 strcpy(symFile, symbolsDir ? symbolsDir : "");
1889 __ecereNameSpace__ecere__sys__PathCat(symFile, fileName);
1890 }
1891 module->globalInstance = LoadSymbols(symFile, importType, loadDllOnly);
1892 }
1893 }
1894 }
1895 }
1896
1897 int FindIncludeFileID(char * includeFile)
1898 {
1899 int c;
1900
1901 for(c = 0; c < numIncludes; c++)
1902 if(!((__ecereNameSpace__ecere__com__GetRuntimePlatform() == 1) ? (strcasecmp) : strcmp)(includes[c], includeFile))
1903 return c + 1;
1904 return 0;
1905 }
1906
1907 int GetIncludeFileID(char * includeFile)
1908 {
1909 int found = FindIncludeFileID(includeFile);
1910
1911 if(found)
1912 return found;
1913 includes = __ecereNameSpace__ecere__com__eSystem_Renew(includes, sizeof(char *) * (numIncludes + 1));
1914 includes[numIncludes++] = __ecereNameSpace__ecere__sys__CopyString(includeFile);
1915 return numIncludes;
1916 }
1917
1918 char * GetIncludeFileFromID(int id)
1919 {
1920 return includes[id - 1];
1921 }
1922
1923 extern char *  __ecereNameSpace__ecere__sys__StripLastDirectory(const char *  string, char *  output);
1924
1925 extern struct __ecereNameSpace__ecere__com__Instance * __ecereNameSpace__ecere__sys__FileOpen(const char *  fileName, int mode);
1926
1927 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass___ecereNameSpace__ecere__sys__NamedItem;
1928
1929 struct __ecereNameSpace__ecere__sys__NamedItem
1930 {
1931 struct __ecereNameSpace__ecere__sys__NamedItem * prev;
1932 struct __ecereNameSpace__ecere__sys__NamedItem * next;
1933 char *  name;
1934 } __attribute__ ((gcc_struct));
1935
1936 struct __ecereNameSpace__ecere__com__Instance * OpenIncludeFile(char * includeFile)
1937 {
1938 struct __ecereNameSpace__ecere__com__Instance * file;
1939 char location[274];
1940
1941 __ecereNameSpace__ecere__sys__StripLastDirectory(sourceFileStack[(include_stack_ptr >= 0) ? include_stack_ptr : 0], location);
1942 __ecereNameSpace__ecere__sys__PathCat(location, includeFile);
1943 file = __ecereNameSpace__ecere__sys__FileOpen(location, 1);
1944 if(file)
1945 {
1946 strcpy(sourceFileStack[include_stack_ptr + 1], location);
1947 }
1948 else if(inIDE)
1949 {
1950 struct __ecereNameSpace__ecere__sys__NamedItem * includeDir;
1951
1952 if(includeDirs)
1953 {
1954 for(includeDir = (*includeDirs).first; includeDir; includeDir = includeDir->next)
1955 {
1956 strcpy(location, includeDir->name);
1957 __ecereNameSpace__ecere__sys__PathCat(location, includeFile);
1958 file = __ecereNameSpace__ecere__sys__FileOpen(location, 1);
1959 if(file)
1960 break;
1961 }
1962 }
1963 if(!file && sysIncludeDirs)
1964 {
1965 for(includeDir = (*sysIncludeDirs).first; includeDir; includeDir = includeDir->next)
1966 {
1967 strcpy(location, includeDir->name);
1968 __ecereNameSpace__ecere__sys__PathCat(location, includeFile);
1969 file = __ecereNameSpace__ecere__sys__FileOpen(location, 1);
1970 if(file)
1971 break;
1972 }
1973 }
1974 }
1975 return file;
1976 }
1977
1978 void FreeIncludeFiles()
1979 {
1980 int c;
1981
1982 for(c = 0; c < numIncludes; c++)
1983 (__ecereNameSpace__ecere__com__eSystem_Delete(includes[c]), includes[c] = 0);
1984 (__ecereNameSpace__ecere__com__eSystem_Delete(includes), includes = 0);
1985 numIncludes = 0;
1986 }
1987
1988 extern void FreeSymbol(struct Symbol * symbol);
1989
1990 extern void FreeType(struct Type * type);
1991
1992 void __ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_Remove(struct __ecereNameSpace__ecere__sys__BinaryTree * this, struct __ecereNameSpace__ecere__sys__BTNode * node);
1993
1994 void FreeGlobalData(struct __ecereNameSpace__ecere__com__NameSpace * globalDataList)
1995 {
1996 struct __ecereNameSpace__ecere__com__NameSpace * ns;
1997 struct GlobalData * data;
1998
1999 for(; (ns = (struct __ecereNameSpace__ecere__com__NameSpace *)globalDataList->nameSpaces.root); )
2000 {
2001 FreeGlobalData(ns);
2002 __ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_Remove(&globalDataList->nameSpaces, (struct __ecereNameSpace__ecere__sys__BTNode *)ns);
2003 (__ecereNameSpace__ecere__com__eSystem_Delete((void *)(*ns).name), (*ns).name = 0);
2004 (__ecereNameSpace__ecere__com__eSystem_Delete(ns), ns = 0);
2005 }
2006 for(; (data = (struct GlobalData *)globalDataList->functions.root); )
2007 {
2008 __ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_Remove(&globalDataList->functions, (void *)data);
2009 if(data->symbol)
2010 FreeSymbol(data->symbol);
2011 FreeType(data->dataType);
2012 (__ecereNameSpace__ecere__com__eSystem_Delete(data->fullName), data->fullName = 0);
2013 (__ecereNameSpace__ecere__com__eSystem_Delete(data->dataTypeString), data->dataTypeString = 0);
2014 ((data ? (__ecereClass_GlobalData->Destructor ? __ecereClass_GlobalData->Destructor((void *)data) : 0, __ecereClass___ecereNameSpace__ecere__sys__BTNode->Destructor ? __ecereClass___ecereNameSpace__ecere__sys__BTNode->Destructor((void *)data) : 0, __ecereNameSpace__ecere__com__eSystem_Delete(data)) : 0), data = 0);
2015 }
2016 }
2017
2018 extern void PrintType(struct Type * type, char *  string, unsigned int printName, unsigned int fullName);
2019
2020 extern void Compiler_Warning(const char *  format, ...);
2021
2022 void __ecereMethod___ecereNameSpace__ecere__sys__OldList_Free(struct __ecereNameSpace__ecere__sys__OldList * this, void (*  freeFn)(void * ));
2023
2024 void CheckDataRedefinitions()
2025 {
2026 struct DataRedefinition * redefinition;
2027
2028 for(redefinition = dataRedefinitions.first; redefinition; redefinition = redefinition->next)
2029 {
2030 struct Type * type1 = ProcessTypeString(redefinition->type1, 0);
2031 struct Type * type2 = ProcessTypeString(redefinition->type2, 0);
2032 char type1String[1024] = "";
2033 char type2String[1024] = "";
2034
2035 PrintType(type1, type1String, 0, 1);
2036 PrintType(type2, type2String, 0, 1);
2037 if(strcmp(type1String, type2String))
2038 Compiler_Warning(__ecereNameSpace__ecere__GetTranslatedString("ec", "Redefinition of %s (defining as %s, already defined as %s)\n", (((void *)0))), redefinition->name, type1String, type2String);
2039 FreeType(type1);
2040 FreeType(type2);
2041 }
2042 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Free(&dataRedefinitions, (((void *)0)));
2043 }
2044
2045 void __ecereRegisterModule_loadSymbols(struct __ecereNameSpace__ecere__com__Instance * module)
2046 {
2047 struct __ecereNameSpace__ecere__com__Class __attribute__((unused)) * class;
2048
2049 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("SetGlobalData", "void SetGlobalData(ecere::com::NameSpace * nameSpace)", SetGlobalData, module, 1);
2050 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("SetInIDE", "void SetInIDE(bool b)", SetInIDE, module, 1);
2051 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("SetSourceDirs", "void SetSourceDirs(ecere::com::List<String> list)", SetSourceDirs, module, 1);
2052 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("SetIncludeDirs", "void SetIncludeDirs(ecere::sys::OldList * list)", SetIncludeDirs, module, 1);
2053 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("SetSysIncludeDirs", "void SetSysIncludeDirs(ecere::sys::OldList * list)", SetSysIncludeDirs, module, 1);
2054 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("SetEcereImported", "void SetEcereImported(bool b)", SetEcereImported, module, 1);
2055 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("GetEcereImported", "bool GetEcereImported(void)", GetEcereImported, module, 1);
2056 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("SetInPreCompiler", "void SetInPreCompiler(bool b)", SetInPreCompiler, module, 1);
2057 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("SetInSymbolGen", "void SetInSymbolGen(bool b)", SetInSymbolGen, module, 1);
2058 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("SetPrecompDefines", "void SetPrecompDefines(ecere::sys::OldList * list)", SetPrecompDefines, module, 1);
2059 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("DummyMethod", "bool DummyMethod(void)", DummyMethod, module, 1);
2060 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("LoadSymbols", "bool LoadSymbols(const char * fileName, ecere::com::ImportType importType, bool loadDllOnly)", LoadSymbols, module, 1);
2061 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("ImportModule", "void ImportModule(const char * name, ecere::com::ImportType importType, ecere::com::AccessMode importAccess, bool loadDllOnly)", ImportModule, module, 1);
2062 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("FindIncludeFileID", "int FindIncludeFileID(char * includeFile)", FindIncludeFileID, module, 2);
2063 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("GetIncludeFileID", "int GetIncludeFileID(char * includeFile)", GetIncludeFileID, module, 2);
2064 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("GetIncludeFileFromID", "char * GetIncludeFileFromID(int id)", GetIncludeFileFromID, module, 2);
2065 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("OpenIncludeFile", "ecere::sys::File OpenIncludeFile(char * includeFile)", OpenIncludeFile, module, 2);
2066 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("FreeIncludeFiles", "void FreeIncludeFiles(void)", FreeIncludeFiles, module, 1);
2067 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("FreeGlobalData", "void FreeGlobalData(ecere::com::NameSpace globalDataList)", FreeGlobalData, module, 1);
2068 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("CheckDataRedefinitions", "void CheckDataRedefinitions(void)", CheckDataRedefinitions, module, 1);
2069 }
2070
2071 void __ecereUnregisterModule_loadSymbols(struct __ecereNameSpace__ecere__com__Instance * module)
2072 {
2073
2074 }
2075
2076 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass___ecereNameSpace__ecere__com__Map_TPL_String__ecere__com__List_TPL_ecere__com__Module___;
2077
2078 void __ecereCreateModuleInstances_loadSymbols()
2079 {
2080 loadedModules = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass___ecereNameSpace__ecere__com__Map_TPL_String__ecere__com__List_TPL_ecere__com__Module___);
2081 __ecereNameSpace__ecere__com__eInstance_IncRef(loadedModules);
2082 }
2083
2084 void __ecereDestroyModuleInstances_loadSymbols()
2085 {
2086 (__ecereNameSpace__ecere__com__eInstance_DecRef(loadedModules), loadedModules = 0);
2087 }
2088