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