The Ecere SDK - sdk/blob - compiler/bootstrap/ecere/bootstrap/instance.c

   1 #if defined(__GNUC__)
   2 typedef long long int64;
   3 typedef unsigned long long uint64;
   4 #ifdef _WIN32
   5 #define stdcall __attribute__((__stdcall__))
   6 #else
   7 #define stdcall
   8 #define __declspec(x)
   9 #endif
  10 #elif defined(__TINYC__)
  11 #include <stdarg.h>
  12 #define __builtin_va_list va_list
  13 #define __builtin_va_start va_start
  14 #define __builtin_va_end va_end
  15 #ifdef _WIN32
  16 #define strcasecmp stricmp
  17 #define strncasecmp strnicmp
  18 #define __declspec(x) __attribute__((x))
  19 #define stdcall __attribute__((__stdcall__))
  20 #else
  21 #define __declspec(x)
  22 #define stdcall
  23 #endif
  24 typedef long long int64;
  25 typedef unsigned long long uint64;
  26 #else
  27 typedef __int64 int64;
  28 typedef unsigned __int64 uint64;
  29 #endif
  30 #ifdef __BIG_ENDIAN__
  31 #define __ENDIAN_PAD(x) (8 - (x))
  32 #else
  33 #define __ENDIAN_PAD(x) 0
  34 #endif
  35 #include <stdint.h>
  36 #include <sys/types.h>
  37
  38 #if /*defined(_W64) || */(defined(__WORDSIZE) && __WORDSIZE == 8) || defined(__x86_64__)
  39 #define _64BIT 1
  40 #else
  41 #define _64BIT 0
  42 #endif
  43
  44 #define arch_PointerSize                  sizeof(void *)
  45 #define structSize_Instance               (_64BIT ? 24 : 12)
  46 #define structSize_Module                 (_64BIT ? 560 : 300)
  47 #define structSize_BinaryTree             (_64BIT ? 32 : 16)
  48 #define structSize_OldList                (_64BIT ? 32 : 20)
  49 #define structSize_NamedLink64            (_64BIT ? 32 : 24)
  50 #define structSize_ClassTemplateArgument  (_64BIT ? 16 : 8)
  51 #define structSize_ClassTemplateParameter (_64BIT ? 64 : 40)
  52 #define structSize_OldLink                (_64BIT ? 24 : 12)
  53 #define structSize_BTNamedLink            (_64BIT ? 48 : 24)
  54 #define structSize_Application            (_64BIT ? 800 : 428)
  55 #define structSize_Watcher                (_64BIT ? 32 : 16)
  56 #define structSize_SelfWatcher            (_64BIT ? 32 : 16)
  57 #define structSize_GlobalFunction         (_64BIT ? 72 : 36)
  58 #define structSize_DefinedExpression      (_64BIT ? 40 : 20)
  59 #define structSize_BitMember              (_64BIT ? 96 : 64)
  60 #define structSize_NamedLink              (_64BIT ? 32 : 16)
  61 #define structSize_DataMember             (_64BIT ? 160 : 96)
  62 #define structSize_ClassProperty          (_64BIT ? 80 : 40)
  63 #define structSize_Method                 (_64BIT ? 96 : 52)
  64 #define structSize_Property               (_64BIT ? 152 : 88)
  65 #define structSize_Class                  (_64BIT ? 616 : 358)
  66
  67 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass___ecereNameSpace__ecere__sys__BTNode;
  68
  69 struct __ecereNameSpace__ecere__sys__BTNode;
  70
  71 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass___ecereNameSpace__ecere__sys__BinaryTree;
  72
  73 struct __ecereNameSpace__ecere__sys__BinaryTree
  74 {
  75 struct __ecereNameSpace__ecere__sys__BTNode * root;
  76 int count;
  77 int (*  CompareKey)(struct __ecereNameSpace__ecere__sys__BinaryTree * tree, uintptr_t a, uintptr_t b);
  78 void (*  FreeKey)(void *  key);
  79 } __attribute__ ((gcc_struct));
  80
  81 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass___ecereNameSpace__ecere__sys__OldList;
  82
  83 struct __ecereNameSpace__ecere__sys__OldList
  84 {
  85 void *  first;
  86 void *  last;
  87 int count;
  88 unsigned int offset;
  89 unsigned int circ;
  90 } __attribute__ ((gcc_struct));
  91
  92 struct __ecereNameSpace__ecere__com__Class
  93 {
  94 struct __ecereNameSpace__ecere__com__Class * prev, * next;
  95 char * name;
  96 int offset, structSize;
  97 int (** _vTbl)();
  98 int vTblSize;
  99 int (* Constructor)(struct __ecereNameSpace__ecere__com__Instance *);
 100 void (* Destructor)(struct __ecereNameSpace__ecere__com__Instance *);
 101 int offsetClass, sizeClass;
 102 struct __ecereNameSpace__ecere__com__Class * base;
 103 struct __ecereNameSpace__ecere__sys__BinaryTree methods;
 104 struct __ecereNameSpace__ecere__sys__BinaryTree members;
 105 struct __ecereNameSpace__ecere__sys__BinaryTree prop;
 106 struct __ecereNameSpace__ecere__sys__OldList membersAndProperties;
 107 struct __ecereNameSpace__ecere__sys__BinaryTree classProperties;
 108 struct __ecereNameSpace__ecere__sys__OldList derivatives;
 109 int memberID, startMemberID;
 110 int type;
 111 struct __ecereNameSpace__ecere__com__Instance * module;
 112 struct __ecereNameSpace__ecere__com__NameSpace * nameSpace;
 113 char * dataTypeString;
 114 struct __ecereNameSpace__ecere__com__Instance * dataType;
 115 int typeSize;
 116 int defaultAlignment;
 117 void (* Initialize)();
 118 int memberOffset;
 119 struct __ecereNameSpace__ecere__sys__OldList selfWatchers;
 120 char * designerClass;
 121 unsigned int noExpansion;
 122 char * defaultProperty;
 123 unsigned int comRedefinition;
 124 int count;
 125 unsigned int isRemote;
 126 unsigned int internalDecl;
 127 void * data;
 128 unsigned int computeSize;
 129 int structAlignment;
 130 int destructionWatchOffset;
 131 unsigned int fixed;
 132 struct __ecereNameSpace__ecere__sys__OldList delayedCPValues;
 133 int inheritanceAccess;
 134 char * fullName;
 135 void * symbol;
 136 struct __ecereNameSpace__ecere__sys__OldList conversions;
 137 struct __ecereNameSpace__ecere__sys__OldList templateParams;
 138 struct __ecereNameSpace__ecere__com__ClassTemplateArgument * templateArgs;
 139 struct __ecereNameSpace__ecere__com__Class * templateClass;
 140 struct __ecereNameSpace__ecere__sys__OldList templatized;
 141 int numParams;
 142 } __attribute__ ((gcc_struct));
 143
 144 static struct __ecereNameSpace__ecere__com__Class * __ecereClass___ecereNameSpace__ecere__com__Class;
 145
 146 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass___ecereNameSpace__ecere__com__Instance;
 147
 148 struct __ecereNameSpace__ecere__com__Instance
 149 {
 150 int (* *  _vTbl)();
 151 struct __ecereNameSpace__ecere__com__Class * _class;
 152 int _refCount;
 153 } __attribute__ ((gcc_struct));
 154
 155 struct __ecereNameSpace__ecere__com__Property
 156 {
 157 struct __ecereNameSpace__ecere__com__Property * prev, * next;
 158 char * name;
 159 unsigned int isProperty;
 160 int memberAccess;
 161 int id;
 162 struct __ecereNameSpace__ecere__com__Class * _class;
 163 char * dataTypeString;
 164 struct __ecereNameSpace__ecere__com__Class * dataTypeClass;
 165 struct __ecereNameSpace__ecere__com__Instance * dataType;
 166 void (* Set)(void *, int);
 167 int (* Get)(void *);
 168 unsigned int (* IsSet)(void *);
 169 void * data;
 170 void * symbol;
 171 int vid;
 172 unsigned int conversion;
 173 unsigned int watcherOffset;
 174 char * category;
 175 unsigned int compiled;
 176 unsigned int selfWatchable, isWatchable;
 177 } __attribute__ ((gcc_struct));
 178
 179 static struct __ecereNameSpace__ecere__com__Class * __ecereClass___ecereNameSpace__ecere__com__Property;
 180
 181 struct __ecereNameSpace__ecere__com__DataMember
 182 {
 183 struct __ecereNameSpace__ecere__com__DataMember * prev, * next;
 184 char * name;
 185 unsigned int isProperty;
 186 int memberAccess;
 187 int id;
 188 struct __ecereNameSpace__ecere__com__Class * _class;
 189 char * dataTypeString;
 190 struct __ecereNameSpace__ecere__com__Class * dataTypeClass;
 191 struct __ecereNameSpace__ecere__com__Instance * dataType;
 192 int type;
 193 int offset;
 194 int memberID;
 195 struct __ecereNameSpace__ecere__sys__OldList members;
 196 struct __ecereNameSpace__ecere__sys__BinaryTree membersAlpha;
 197 int memberOffset;
 198 int structAlignment;
 199 } __attribute__ ((gcc_struct));
 200
 201 static struct __ecereNameSpace__ecere__com__Class * __ecereClass___ecereNameSpace__ecere__com__DataMember;
 202
 203 struct __ecereNameSpace__ecere__com__Method
 204 {
 205 char * name;
 206 struct __ecereNameSpace__ecere__com__Method * parent, * left, * right;
 207 int depth;
 208 int (* function)();
 209 int vid;
 210 int type;
 211 struct __ecereNameSpace__ecere__com__Class * _class;
 212 void * symbol;
 213 char * dataTypeString;
 214 struct __ecereNameSpace__ecere__com__Instance * dataType;
 215 int memberAccess;
 216 } __attribute__ ((gcc_struct));
 217
 218 static struct __ecereNameSpace__ecere__com__Class * __ecereClass___ecereNameSpace__ecere__com__Method;
 219
 220 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass___ecereNameSpace__ecere__com__SerialBuffer;
 221
 222 struct __ecereNameSpace__ecere__com__SerialBuffer
 223 {
 224 unsigned char *  _buffer;
 225 unsigned int count;
 226 unsigned int _size;
 227 unsigned int pos;
 228 } __attribute__ ((gcc_struct));
 229
 230 struct __ecereNameSpace__ecere__com__DataValue
 231 {
 232 union
 233 {
 234 char c;
 235 unsigned char uc;
 236 short s;
 237 unsigned short us;
 238 int i;
 239 unsigned int ui;
 240 void * p;
 241 float f;
 242 double d;
 243 long long i64;
 244 uint64 ui64;
 245 } __attribute__ ((gcc_struct));
 246 } __attribute__ ((gcc_struct));
 247
 248 static struct __ecereNameSpace__ecere__com__Class * __ecereClass___ecereNameSpace__ecere__com__DataValue;
 249
 250 struct __ecereNameSpace__ecere__com__ClassTemplateArgument
 251 {
 252 union
 253 {
 254 struct
 255 {
 256 char * dataTypeString;
 257 struct __ecereNameSpace__ecere__com__Class * dataTypeClass;
 258 } __attribute__ ((gcc_struct));
 259 struct __ecereNameSpace__ecere__com__DataValue expression;
 260 struct
 261 {
 262 char * memberString;
 263 union
 264 {
 265 struct __ecereNameSpace__ecere__com__DataMember * member;
 266 struct __ecereNameSpace__ecere__com__Property * prop;
 267 struct __ecereNameSpace__ecere__com__Method * method;
 268 } __attribute__ ((gcc_struct));
 269 } __attribute__ ((gcc_struct));
 270 } __attribute__ ((gcc_struct));
 271 } __attribute__ ((gcc_struct));
 272
 273 static struct __ecereNameSpace__ecere__com__Class * __ecereClass___ecereNameSpace__ecere__com__ClassTemplateArgument;
 274
 275 void exit(int status);
 276
 277 void * calloc(size_t nmemb, size_t size);
 278
 279 void free(void * ptr);
 280
 281 void * malloc(size_t size);
 282
 283 void * realloc(void * ptr, size_t size);
 284
 285 long int strtol(const char * nptr, char ** endptr, int base);
 286
 287 long long int strtoll(const char * nptr, char ** endptr, int base);
 288
 289 unsigned long long int strtoull(const char * nptr, char ** endptr, int base);
 290
 291 typedef __builtin_va_list va_list;
 292
 293 typedef void FILE;
 294
 295 FILE * bsl_stdin(void);
 296
 297 FILE * bsl_stdout(void);
 298
 299 FILE * bsl_stderr(void);
 300
 301 char * fgets(char * s, int size, FILE * stream);
 302
 303 FILE * fopen(const char * path, const char * mode);
 304
 305 int fclose(FILE * fp);
 306
 307 int fflush(FILE * stream);
 308
 309 int fgetc(FILE * stream);
 310
 311 int fprintf(FILE * stream, const char * format, ...);
 312
 313 int fputc(int c, FILE * stream);
 314
 315 size_t fread(void * ptr, size_t size, size_t nmemb, FILE * stream);
 316
 317 size_t fwrite(const void * ptr, size_t size, size_t nmemb, FILE * stream);
 318
 319 int vsnprintf(char *, size_t, const char *, ...);
 320
 321 int snprintf(char * str, size_t, const char * format, ...);
 322
 323 int fseek(FILE * stream, long offset, int whence);
 324
 325 long ftell(FILE * stream);
 326
 327 int feof(FILE * stream);
 328
 329 int ferror(FILE * stream);
 330
 331 int fileno(FILE * stream);
 332
 333
 334 struct __ecereNameSpace__ecere__com__Class * __ecereNameSpace__ecere__com__eSystem_FindClass(struct __ecereNameSpace__ecere__com__Instance * module, char * name);
 335
 336 void * __ecereNameSpace__ecere__com__eSystem_Renew(void * memory, unsigned int size);
 337
 338 void * __ecereNameSpace__ecere__com__eSystem_Renew0(void * memory, unsigned int size);
 339
 340 void * __ecereNameSpace__ecere__com__eSystem_New(unsigned int size);
 341
 342 void * __ecereNameSpace__ecere__com__eSystem_New0(unsigned int size);
 343
 344 void __ecereNameSpace__ecere__com__eSystem_Delete(void * memory);
 345
 346 void * __ecereNameSpace__ecere__com__eInstance_New(struct __ecereNameSpace__ecere__com__Class * _class);
 347
 348 extern int __ecereVMethodID_class_OnGetDataFromString;
 349
 350 unsigned int Instance_LocateModule(char * name, char * fileName);
 351
 352 void Instance_COM_Initialize(int argc, char ** argv, char ** parsedCommand, int * argcPtr, char *** argvPtr);
 353
 354 void * Instance_Module_Load(const char * libLocation, const char * name, void ** Load, void ** Unload);
 355
 356 void Instance_Module_Free(void * library);
 357
 358 static struct __ecereNameSpace__ecere__com__Class * __ecereClass___ecereNameSpace__ecere__com__unichar;
 359
 360 int __ecereNameSpace__ecere__sys__UTF32toUTF8Len(unsigned int *  source, int count, unsigned char *  dest, int max);
 361
 362 char * __ecereMethod___ecereNameSpace__ecere__com__unichar_OnGetString(struct __ecereNameSpace__ecere__com__Class * class, unsigned int * this, char * tempString, void * fieldData, unsigned int * needClass)
 363 {
 364 __ecereNameSpace__ecere__sys__UTF32toUTF8Len(&(*this), 1, tempString, 5);
 365 return tempString;
 366 }
 367
 368 unsigned int __ecereNameSpace__ecere__sys__UTF8GetChar(char *  string, int *  numBytes);
 369
 370 unsigned int __ecereMethod___ecereNameSpace__ecere__com__unichar_OnGetDataFromString(struct __ecereNameSpace__ecere__com__Class * class, unsigned int * this, char * string)
 371 {
 372 int nb;
 373
 374 (*this) = __ecereNameSpace__ecere__sys__UTF8GetChar(string, &nb);
 375 return 0x1;
 376 }
 377
 378 void __ecereNameSpace__ecere__com__eInstance_FireWatchers(struct __ecereNameSpace__ecere__com__Instance * instance, struct __ecereNameSpace__ecere__com__Property * _property);
 379
 380 void __ecereNameSpace__ecere__com__MemoryGuard_PushLoc(char * loc)
 381 {
 382 }
 383
 384 void __ecereNameSpace__ecere__com__MemoryGuard_PopLoc()
 385 {
 386 }
 387
 388 extern unsigned int __ecereDll_Load_ecere(struct __ecereNameSpace__ecere__com__Instance * module);
 389
 390 extern unsigned int __ecereDll_Unload_ecere(struct __ecereNameSpace__ecere__com__Instance * module);
 391
 392 struct __ecereNameSpace__ecere__com__BTNamedLink
 393 {
 394 char * name;
 395 struct __ecereNameSpace__ecere__com__BTNamedLink * parent, * left, * right;
 396 int depth;
 397 void * data;
 398 } __attribute__ ((gcc_struct));
 399
 400 static struct __ecereNameSpace__ecere__com__Class * __ecereClass___ecereNameSpace__ecere__com__BTNamedLink;
 401
 402 struct __ecereNameSpace__ecere__com__SelfWatcher
 403 {
 404 struct __ecereNameSpace__ecere__com__SelfWatcher * prev, * next;
 405 void (* callback)(struct __ecereNameSpace__ecere__com__Instance *);
 406 struct __ecereNameSpace__ecere__com__Property * _property;
 407 } __attribute__ ((gcc_struct));
 408
 409 static struct __ecereNameSpace__ecere__com__Class * __ecereClass___ecereNameSpace__ecere__com__SelfWatcher;
 410
 411 static struct __ecereNameSpace__ecere__com__Class * __ecereClass___ecereNameSpace__ecere__com__AccessMode;
 412
 413 struct __ecereNameSpace__ecere__com__SubModule
 414 {
 415 struct __ecereNameSpace__ecere__com__SubModule * prev, * next;
 416 struct __ecereNameSpace__ecere__com__Instance * module;
 417 int importMode;
 418 } __attribute__ ((gcc_struct));
 419
 420 static struct __ecereNameSpace__ecere__com__Class * __ecereClass___ecereNameSpace__ecere__com__SubModule;
 421
 422 static struct __ecereNameSpace__ecere__com__Class * __ecereClass___ecereNameSpace__ecere__com__DataMemberType;
 423
 424 static struct __ecereNameSpace__ecere__com__Class * __ecereClass___ecereNameSpace__ecere__com__ClassType;
 425
 426 static struct __ecereNameSpace__ecere__com__Property * __ecereProp___ecereNameSpace__ecere__com__Class_char__PTR_, * __ecerePropM___ecereNameSpace__ecere__com__Class_char__PTR_;
 427
 428 char *  __ecereProp___ecereNameSpace__ecere__com__Class_Get_char__PTR_(struct __ecereNameSpace__ecere__com__Class * this)
 429 {
 430 return this->name;
 431 }
 432
 433 extern struct __ecereNameSpace__ecere__com__Instance * __thisModule;
 434
 435 struct __ecereNameSpace__ecere__com__Class * __ecereProp___ecereNameSpace__ecere__com__Class_Set_char__PTR_(char *  value)
 436 {
 437 struct __ecereNameSpace__ecere__com__Class * theClass = __ecereNameSpace__ecere__com__eSystem_FindClass(__thisModule, value);
 438
 439 return theClass;
 440 }
 441
 442 char * __ecereMethod___ecereNameSpace__ecere__com__Class_OnGetString(struct __ecereNameSpace__ecere__com__Class * class, struct __ecereNameSpace__ecere__com__Class * this, char * tempString, void * fieldData, unsigned int * needClass)
 443 {
 444 return this->name;
 445 }
 446
 447 struct __ecereNameSpace__ecere__com__NameSpace
 448 {
 449 char * name;
 450 struct __ecereNameSpace__ecere__com__NameSpace * btParent, * left, * right;
 451 int depth;
 452 struct __ecereNameSpace__ecere__com__NameSpace * parent;
 453 struct __ecereNameSpace__ecere__sys__BinaryTree nameSpaces;
 454 struct __ecereNameSpace__ecere__sys__BinaryTree classes;
 455 struct __ecereNameSpace__ecere__sys__BinaryTree defines;
 456 struct __ecereNameSpace__ecere__sys__BinaryTree functions;
 457 } __attribute__ ((gcc_struct));
 458
 459 static struct __ecereNameSpace__ecere__com__Class * __ecereClass___ecereNameSpace__ecere__com__NameSpace;
 460
 461 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass___ecereNameSpace__ecere__com__Module;
 462
 463 struct __ecereNameSpace__ecere__com__Module
 464 {
 465 struct __ecereNameSpace__ecere__com__Instance * application;
 466 struct __ecereNameSpace__ecere__sys__OldList classes;
 467 struct __ecereNameSpace__ecere__sys__OldList defines;
 468 struct __ecereNameSpace__ecere__sys__OldList functions;
 469 struct __ecereNameSpace__ecere__sys__OldList modules;
 470 struct __ecereNameSpace__ecere__com__Instance * prev;
 471 struct __ecereNameSpace__ecere__com__Instance * next;
 472 char *  name;
 473 void *  library;
 474 void *  Unload;
 475 int importType;
 476 int origImportType;
 477 struct __ecereNameSpace__ecere__com__NameSpace privateNameSpace;
 478 struct __ecereNameSpace__ecere__com__NameSpace publicNameSpace;
 479 } __attribute__ ((gcc_struct));
 480
 481 unsigned int __ecereMethod___ecereNameSpace__ecere__com__Class_OnGetDataFromString(struct __ecereNameSpace__ecere__com__Class * class, struct __ecereNameSpace__ecere__com__Class ** this, char * string)
 482 {
 483 struct __ecereNameSpace__ecere__com__Class * theClass;
 484
 485 theClass = __ecereNameSpace__ecere__com__eSystem_FindClass(__thisModule, string);
 486 if(!theClass)
 487 theClass = __ecereNameSpace__ecere__com__eSystem_FindClass(((struct __ecereNameSpace__ecere__com__Module *)(((char *)__thisModule + structSize_Instance)))->application, string);
 488 (*this) = (void *)theClass;
 489 return theClass != (((void *)0));
 490 }
 491
 492 void __ecereMethod___ecereNameSpace__ecere__com__IOChannel_Serialize(struct __ecereNameSpace__ecere__com__Instance * this, struct __ecereNameSpace__ecere__com__Class * class, void * data);
 493
 494 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_char__PTR_;
 495
 496 void __ecereMethod___ecereNameSpace__ecere__com__Class_OnSerialize(struct __ecereNameSpace__ecere__com__Class * class, struct __ecereNameSpace__ecere__com__Class * this, struct __ecereNameSpace__ecere__com__Instance * channel)
 497 {
 498 __ecereMethod___ecereNameSpace__ecere__com__IOChannel_Serialize(channel, __ecereClass_char__PTR_, this->fullName);
 499 }
 500
 501 void __ecereMethod___ecereNameSpace__ecere__com__Class_OnFree(struct __ecereNameSpace__ecere__com__Class * class, struct __ecereNameSpace__ecere__com__Class * this)
 502 {
 503 }
 504
 505 void __ecereMethod___ecereNameSpace__ecere__com__IOChannel_Unserialize(struct __ecereNameSpace__ecere__com__Instance * this, struct __ecereNameSpace__ecere__com__Class * class, void * *  data);
 506
 507 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_String;
 508
 509 void __ecereMethod___ecereNameSpace__ecere__com__Class_OnUnserialize(struct __ecereNameSpace__ecere__com__Class * class, struct __ecereNameSpace__ecere__com__Class ** this, struct __ecereNameSpace__ecere__com__Instance * channel)
 510 {
 511 struct __ecereNameSpace__ecere__com__Class * theClass;
 512 char * string;
 513
 514 __ecereMethod___ecereNameSpace__ecere__com__IOChannel_Unserialize(channel, __ecereClass_String, &string);
 515 theClass = __ecereNameSpace__ecere__com__eSystem_FindClass(__thisModule, string);
 516 if(!theClass)
 517 theClass = __ecereNameSpace__ecere__com__eSystem_FindClass(((struct __ecereNameSpace__ecere__com__Module *)(((char *)__thisModule + structSize_Instance)))->application, string);
 518 (__ecereNameSpace__ecere__com__eSystem_Delete(string), string = 0);
 519 (*this) = (void *)theClass;
 520 }
 521
 522 static struct __ecereNameSpace__ecere__com__Class * __ecereClass___ecereNameSpace__ecere__com__TemplateParameterType;
 523
 524 static struct __ecereNameSpace__ecere__com__Class * __ecereClass___ecereNameSpace__ecere__com__TemplateMemberType;
 525
 526 struct __ecereNameSpace__ecere__com__ClassTemplateParameter
 527 {
 528 struct __ecereNameSpace__ecere__com__ClassTemplateParameter * prev, * next;
 529 char * name;
 530 int type;
 531 union
 532 {
 533 char * dataTypeString;
 534 int memberType;
 535 } __attribute__ ((gcc_struct));
 536 struct __ecereNameSpace__ecere__com__ClassTemplateArgument defaultArg;
 537 void * param;
 538 } __attribute__ ((gcc_struct));
 539
 540 static struct __ecereNameSpace__ecere__com__Class * __ecereClass___ecereNameSpace__ecere__com__ClassTemplateParameter;
 541
 542 static struct __ecereNameSpace__ecere__com__Class * __ecereClass___ecereNameSpace__ecere__com__MethodType;
 543
 544 static struct __ecereNameSpace__ecere__com__Class * __ecereClass___ecereNameSpace__ecere__com__ImportType;
 545
 546 struct __ecereNameSpace__ecere__com__BitMember
 547 {
 548 struct __ecereNameSpace__ecere__com__BitMember * prev, * next;
 549 char * name;
 550 unsigned int isProperty;
 551 int memberAccess;
 552 int id;
 553 struct __ecereNameSpace__ecere__com__Class * _class;
 554 char * dataTypeString;
 555 struct __ecereNameSpace__ecere__com__Class * dataTypeClass;
 556 struct __ecereNameSpace__ecere__com__Instance * dataType;
 557 int type;
 558 int size;
 559 int pos;
 560 uint64 mask;
 561 } __attribute__ ((gcc_struct));
 562
 563 static struct __ecereNameSpace__ecere__com__Class * __ecereClass___ecereNameSpace__ecere__com__BitMember;
 564
 565 struct __ecereNameSpace__ecere__com__ClassProperty
 566 {
 567 char * name;
 568 struct __ecereNameSpace__ecere__com__ClassProperty * parent, * left, * right;
 569 int depth;
 570 void (* Set)(struct __ecereNameSpace__ecere__com__Class *, long long);
 571 long long (* Get)(struct __ecereNameSpace__ecere__com__Class *);
 572 char * dataTypeString;
 573 struct __ecereNameSpace__ecere__com__Instance * dataType;
 574 unsigned int constant;
 575 } __attribute__ ((gcc_struct));
 576
 577 static struct __ecereNameSpace__ecere__com__Class * __ecereClass___ecereNameSpace__ecere__com__ClassProperty;
 578
 579 struct __ecereNameSpace__ecere__com__DefinedExpression
 580 {
 581 struct __ecereNameSpace__ecere__com__DefinedExpression * prev, * next;
 582 char * name;
 583 char * value;
 584 struct __ecereNameSpace__ecere__com__NameSpace * nameSpace;
 585 } __attribute__ ((gcc_struct));
 586
 587 static struct __ecereNameSpace__ecere__com__Class * __ecereClass___ecereNameSpace__ecere__com__DefinedExpression;
 588
 589 struct __ecereNameSpace__ecere__com__GlobalFunction
 590 {
 591 struct __ecereNameSpace__ecere__com__GlobalFunction * prev, * next;
 592 char * name;
 593 int (* function)();
 594 struct __ecereNameSpace__ecere__com__Instance * module;
 595 struct __ecereNameSpace__ecere__com__NameSpace * nameSpace;
 596 char * dataTypeString;
 597 struct __ecereNameSpace__ecere__com__Instance * dataType;
 598 void * symbol;
 599 } __attribute__ ((gcc_struct));
 600
 601 static struct __ecereNameSpace__ecere__com__Class * __ecereClass___ecereNameSpace__ecere__com__GlobalFunction;
 602
 603 struct __ecereNameSpace__ecere__com__EnumClassData
 604 {
 605 struct __ecereNameSpace__ecere__sys__OldList values;
 606 int largest;
 607 } __attribute__ ((gcc_struct));
 608
 609 static struct __ecereNameSpace__ecere__com__Class * __ecereClass___ecereNameSpace__ecere__com__EnumClassData;
 610
 611 struct __ecereNameSpace__ecere__com__Watcher
 612 {
 613 struct __ecereNameSpace__ecere__com__Watcher * prev, * next;
 614 void (* callback)(struct __ecereNameSpace__ecere__com__Instance *, struct __ecereNameSpace__ecere__com__Instance *);
 615 struct __ecereNameSpace__ecere__com__Instance * object;
 616 } __attribute__ ((gcc_struct));
 617
 618 static struct __ecereNameSpace__ecere__com__Class * __ecereClass___ecereNameSpace__ecere__com__Watcher;
 619
 620 static unsigned int __ecereNameSpace__ecere__com__TOTAL_MEM = 0;
 621
 622 static unsigned int __ecereNameSpace__ecere__com__OUTSIDE_MEM = 0;
 623
 624 struct __ecereNameSpace__ecere__com__MemBlock
 625 {
 626 struct __ecereNameSpace__ecere__com__MemBlock * prev, * next;
 627 struct __ecereNameSpace__ecere__com__MemPart * part;
 628 unsigned int size;
 629 } __attribute__ ((gcc_struct));
 630
 631 static struct __ecereNameSpace__ecere__com__Class * __ecereClass___ecereNameSpace__ecere__com__MemBlock;
 632
 633 struct __ecereNameSpace__ecere__com__MemPart
 634 {
 635 void * memory;
 636 int blocksUsed;
 637 int size;
 638 struct __ecereNameSpace__ecere__com__BlockPool * pool;
 639 } __attribute__ ((gcc_struct));
 640
 641 static struct __ecereNameSpace__ecere__com__Class * __ecereClass___ecereNameSpace__ecere__com__MemPart;
 642
 643 static int __ecereNameSpace__ecere__com__power15[] =
 644 {
 645 4, 8, 12, 16, 24, 32, 48, 64, 96, 144, 224, 320, 480, 720, 1072, 1600, 2400, 6900, 5408, 8096, 12144, 18208, 27312, 40976, 61456, 92176, 138256, 207392, 311088, 466624, 699920
 646 };
 647
 648 struct __ecereNameSpace__ecere__com__BlockPool
 649 {
 650 struct __ecereNameSpace__ecere__com__MemBlock * first, * last;
 651 struct __ecereNameSpace__ecere__com__MemBlock * free;
 652 unsigned int blockSize;
 653 unsigned int blockSpace;
 654 int numParts;
 655 int numBlocks;
 656 unsigned int totalSize;
 657 unsigned int usedSpace;
 658 } __attribute__ ((gcc_struct));
 659
 660 static struct __ecereNameSpace__ecere__com__Class * __ecereClass___ecereNameSpace__ecere__com__BlockPool;
 661
 662 unsigned int __ecereMethod___ecereNameSpace__ecere__com__BlockPool_Expand(struct __ecereNameSpace__ecere__com__BlockPool * this, unsigned int numBlocks)
 663 {
 664 unsigned char * memory = malloc(numBlocks * this->blockSpace);
 665
 666 __ecereNameSpace__ecere__com__TOTAL_MEM += numBlocks * this->blockSpace;
 667 if(memory)
 668 {
 669 int c;
 670 struct __ecereNameSpace__ecere__com__MemBlock * block = (struct __ecereNameSpace__ecere__com__MemBlock *)memory;
 671 struct __ecereNameSpace__ecere__com__MemPart * part = calloc(1, sizeof(struct __ecereNameSpace__ecere__com__MemPart));
 672
 673 __ecereNameSpace__ecere__com__TOTAL_MEM += sizeof(struct __ecereNameSpace__ecere__com__MemPart);
 674 this->free = block;
 675 for(c = 0; c < numBlocks - 1; c++)
 676 {
 677 block->part = part;
 678 block->prev = (((void *)0));
 679 block->next = (struct __ecereNameSpace__ecere__com__MemBlock *)((unsigned char *)block + this->blockSpace);
 680 block = block->next;
 681 }
 682 part->blocksUsed = 0;
 683 part->pool = this;
 684 part->memory = memory;
 685 part->size = numBlocks;
 686 block->part = part;
 687 block->prev = (((void *)0));
 688 block->next = (((void *)0));
 689 this->totalSize += numBlocks;
 690 this->numParts++;
 691 return 0x1;
 692 }
 693 return 0x0;
 694 }
 695
 696 struct __ecereNameSpace__ecere__com__MemBlock * __ecereMethod___ecereNameSpace__ecere__com__BlockPool_Add(struct __ecereNameSpace__ecere__com__BlockPool * this)
 697 {
 698 int __simpleStruct0;
 699 struct __ecereNameSpace__ecere__com__MemBlock * block = (((void *)0));
 700
 701 if(!this->free)
 702 __ecereMethod___ecereNameSpace__ecere__com__BlockPool_Expand(this, (__simpleStruct0 = this->numBlocks / 2, (1 > __simpleStruct0) ? 1 : __simpleStruct0));
 703 if(this->free)
 704 {
 705 block = this->free;
 706 block->prev = this->last;
 707 if(block->prev)
 708 block->prev->next = block;
 709 if(!this->first)
 710 this->first = block;
 711 this->last = block;
 712 this->free = block->next;
 713 block->next = (((void *)0));
 714 block->part->blocksUsed++;
 715 this->numBlocks++;
 716 }
 717 return block;
 718 }
 719
 720 void __ecereMethod___ecereNameSpace__ecere__com__BlockPool_Remove(struct __ecereNameSpace__ecere__com__BlockPool * this, struct __ecereNameSpace__ecere__com__MemBlock * block)
 721 {
 722 if(block->prev)
 723 block->prev->next = block->next;
 724 if(block->next)
 725 block->next->prev = block->prev;
 726 if(this->first == block)
 727 this->first = block->next;
 728 if(this->last == block)
 729 this->last = block->prev;
 730 block->next = this->free;
 731 this->free = block;
 732 block->part->blocksUsed--;
 733 this->numBlocks--;
 734 (*block->part->pool).usedSpace -= block->size;
 735 if(!block->part->blocksUsed && this->numBlocks && this->totalSize > this->numBlocks + this->numBlocks / 2)
 736 {
 737 struct __ecereNameSpace__ecere__com__MemBlock * next = this->free, * prev = (((void *)0));
 738 struct __ecereNameSpace__ecere__com__MemPart * part = block->part;
 739
 740 this->free = (((void *)0));
 741 this->totalSize -= part->size;
 742 while(next)
 743 {
 744 if(next->part != part)
 745 {
 746 if(prev)
 747 prev->next = next;
 748 else
 749 this->free = next;
 750 prev = next;
 751 }
 752 next = next->next;
 753 }
 754 ;
 755 if(prev)
 756 prev->next = (((void *)0));
 757 __ecereNameSpace__ecere__com__TOTAL_MEM -= part->size * this->blockSpace;
 758 __ecereNameSpace__ecere__com__TOTAL_MEM -= sizeof(struct __ecereNameSpace__ecere__com__MemPart);
 759 this->numParts--;
 760 free(part->memory);
 761 free(part);
 762 }
 763 }
 764
 765 static struct __ecereNameSpace__ecere__com__BlockPool * __ecereNameSpace__ecere__com__pools;
 766
 767 static unsigned int __ecereNameSpace__ecere__com__PosFibonacci(unsigned int number)
 768 {
 769 unsigned int pos;
 770 unsigned int last = 1, prev = 0;
 771 unsigned int current = 1;
 772
 773 for(pos = 0; ; pos++)
 774 {
 775 current += prev;
 776 prev = last;
 777 last = current;
 778 if(current >= number)
 779 break;
 780 }
 781 return pos;
 782 }
 783
 784 static unsigned int __ecereNameSpace__ecere__com__NthFibonacci(unsigned int number)
 785 {
 786 unsigned int pos;
 787 unsigned int last = 1, prev = 0;
 788 unsigned int current = 1;
 789
 790 for(pos = 0; pos <= number; pos++)
 791 {
 792 current += prev;
 793 prev = last;
 794 last = current;
 795 }
 796 return current;
 797 }
 798
 799 static unsigned int __ecereNameSpace__ecere__com__NextFibonacci(unsigned int number)
 800 {
 801 unsigned int pos;
 802 unsigned int last = 1, prev = 0;
 803 unsigned int current = 1;
 804
 805 for(pos = 0; ; pos++)
 806 {
 807 current += prev;
 808 prev = last;
 809 last = current;
 810 if(current >= number)
 811 return current;
 812 }
 813 }
 814
 815 static unsigned int __ecereNameSpace__ecere__com__log1_5i(unsigned int number)
 816 {
 817 unsigned int pos;
 818 uint64 current = sizeof(void *);
 819
 820 for(pos = 0; pos < 31; pos++)
 821 {
 822 if(current >= number)
 823 break;
 824 current = current * 3 / 2;
 825 if(current == 1)
 826 current = 2;
 827 }
 828 return pos;
 829 }
 830
 831 static unsigned int __ecereNameSpace__ecere__com__pow1_5(unsigned int number)
 832 {
 833 unsigned int pos;
 834 uint64 current = sizeof(void *);
 835
 836 for(pos = 0; pos < number; pos++)
 837 {
 838 current = current * 3 / 2;
 839 if(current == 1)
 840 current = 2;
 841 }
 842 return (unsigned int)current;
 843 }
 844
 845 static unsigned int __ecereNameSpace__ecere__com__pow1_5i(unsigned int number)
 846 {
 847 unsigned int pos;
 848 uint64 current = sizeof(void *);
 849
 850 for(pos = 0; pos < 31; pos++)
 851 {
 852 if(current >= number)
 853 return (unsigned int)current;
 854 current = current * 3 / 2;
 855 if(current == 1)
 856 current = 2;
 857 }
 858 return (unsigned int)current;
 859 }
 860
 861 unsigned int __ecereNameSpace__ecere__com__log2i(unsigned int number)
 862 {
 863 unsigned int power;
 864
 865 for(power = 0; power < 32; power++)
 866 if((1L << power) >= number)
 867 break;
 868 return power;
 869 }
 870
 871 unsigned int __ecereNameSpace__ecere__com__pow2i(unsigned int number)
 872 {
 873 return 1 << __ecereNameSpace__ecere__com__log2i(number);
 874 }
 875
 876 static unsigned int __ecereNameSpace__ecere__com__memoryInitialized = 0x0;
 877
 878 static void __ecereNameSpace__ecere__com__InitMemory()
 879 {
 880 int c;
 881
 882 __ecereNameSpace__ecere__com__memoryInitialized = 0x1;
 883 __ecereNameSpace__ecere__com__pools = calloc(1, sizeof(struct __ecereNameSpace__ecere__com__BlockPool) * 31);
 884 for(c = 0; c < 31; c++)
 885 {
 886 int expansion;
 887
 888 __ecereNameSpace__ecere__com__pools[c].blockSize = __ecereNameSpace__ecere__com__pow1_5(c);
 889 if(__ecereNameSpace__ecere__com__pools[c].blockSize % sizeof(void *))
 890 __ecereNameSpace__ecere__com__pools[c].blockSize += sizeof(void *) - (__ecereNameSpace__ecere__com__pools[c].blockSize % sizeof(void *));
 891 __ecereNameSpace__ecere__com__pools[c].blockSpace = __ecereNameSpace__ecere__com__pools[c].blockSize;
 892 __ecereNameSpace__ecere__com__pools[c].blockSpace += sizeof(struct __ecereNameSpace__ecere__com__MemBlock);
 893 expansion = (__ecereNameSpace__ecere__com__pools[c].blockSize < 128) ? 1024 : (131072 / __ecereNameSpace__ecere__com__pools[c].blockSize);
 894 if(c < 12)
 895 __ecereMethod___ecereNameSpace__ecere__com__BlockPool_Expand(&__ecereNameSpace__ecere__com__pools[c], ((1 > expansion) ? 1 : expansion));
 896 }
 897 }
 898
 899 static void * __ecereNameSpace__ecere__com___mymalloc(unsigned int size)
 900 {
 901 struct __ecereNameSpace__ecere__com__MemBlock * block = (((void *)0));
 902
 903 if(size)
 904 {
 905 unsigned int p = __ecereNameSpace__ecere__com__log1_5i(size);
 906
 907 if(!__ecereNameSpace__ecere__com__memoryInitialized)
 908 __ecereNameSpace__ecere__com__InitMemory();
 909 if(p < 31)
 910 {
 911 block = __ecereMethod___ecereNameSpace__ecere__com__BlockPool_Add(&__ecereNameSpace__ecere__com__pools[p]);
 912 if(block)
 913 {
 914 block->size = size;
 915 __ecereNameSpace__ecere__com__pools[p].usedSpace += size;
 916 }
 917 }
 918 else
 919 {
 920 block = malloc(sizeof(struct __ecereNameSpace__ecere__com__MemBlock) + size);
 921 if(block)
 922 {
 923 __ecereNameSpace__ecere__com__TOTAL_MEM += sizeof(struct __ecereNameSpace__ecere__com__MemBlock) + size;
 924 __ecereNameSpace__ecere__com__OUTSIDE_MEM += sizeof(struct __ecereNameSpace__ecere__com__MemBlock) + size;
 925 block->part = (((void *)0));
 926 block->size = size;
 927 }
 928 }
 929 }
 930 return block ? ((struct __ecereNameSpace__ecere__com__MemBlock *)block + 1) : (((void *)0));
 931 }
 932
 933 extern void *  memset(void *  area, int value, size_t count);
 934
 935 static void * __ecereNameSpace__ecere__com___mycalloc(int n, unsigned int size)
 936 {
 937 void * pointer = __ecereNameSpace__ecere__com___mymalloc(n * size);
 938
 939 if(pointer)
 940 memset(pointer, 0, n * size);
 941 return pointer;
 942 }
 943
 944 static void __ecereNameSpace__ecere__com___myfree(void * pointer)
 945 {
 946 if(pointer)
 947 {
 948 struct __ecereNameSpace__ecere__com__MemBlock * block = (struct __ecereNameSpace__ecere__com__MemBlock *)((unsigned char *)pointer - sizeof(struct __ecereNameSpace__ecere__com__MemBlock));
 949 struct __ecereNameSpace__ecere__com__MemPart * part = block->part;
 950 struct __ecereNameSpace__ecere__com__BlockPool * pool = part ? part->pool : (((void *)0));
 951
 952 if(pool)
 953 __ecereMethod___ecereNameSpace__ecere__com__BlockPool_Remove((&*pool), block);
 954 else
 955 {
 956 __ecereNameSpace__ecere__com__TOTAL_MEM -= sizeof(struct __ecereNameSpace__ecere__com__MemBlock) + block->size;
 957 __ecereNameSpace__ecere__com__OUTSIDE_MEM -= sizeof(struct __ecereNameSpace__ecere__com__MemBlock) + block->size;
 958 free(block);
 959 }
 960 }
 961 }
 962
 963 extern void *  memcpy(void * , const void * , size_t size);
 964
 965 static void * __ecereNameSpace__ecere__com___myrealloc(void * pointer, unsigned int size)
 966 {
 967 struct __ecereNameSpace__ecere__com__MemBlock * block = pointer ? ((struct __ecereNameSpace__ecere__com__MemBlock *)((unsigned char *)pointer - sizeof(struct __ecereNameSpace__ecere__com__MemBlock))) : (((void *)0));
 968 void * newPointer = (((void *)0));
 969 struct __ecereNameSpace__ecere__com__MemPart * part = block ? block->part : (((void *)0));
 970 struct __ecereNameSpace__ecere__com__BlockPool * pool = part ? part->pool : (((void *)0));
 971
 972 if(block)
 973 {
 974 if(pool)
 975 {
 976 unsigned int ns = __ecereNameSpace__ecere__com__pow1_5i(size);
 977 unsigned int mod = ns % sizeof(void *);
 978
 979 if(mod)
 980 ns += sizeof(void *) - mod;
 981 if(ns == (*pool).blockSize)
 982 {
 983 newPointer = pointer;
 984 (*pool).usedSpace += size - block->size;
 985 block->size = size;
 986 }
 987 }
 988 else if(size)
 989 {
 990 struct __ecereNameSpace__ecere__com__MemBlock * newBlock = realloc(block, sizeof(struct __ecereNameSpace__ecere__com__MemBlock) + size);
 991
 992 if(newBlock)
 993 {
 994 __ecereNameSpace__ecere__com__TOTAL_MEM += size - newBlock->size;
 995 __ecereNameSpace__ecere__com__OUTSIDE_MEM += size - newBlock->size;
 996 newPointer = ((struct __ecereNameSpace__ecere__com__MemBlock *)newBlock + 1);
 997 }
 998 }
 999 }
1000 if(!newPointer)
1001 {
1002 newPointer = __ecereNameSpace__ecere__com___mymalloc(size);
1003 if(pointer && newPointer)
1004 {
1005 unsigned int __simpleStruct0;
1006
1007 memcpy(newPointer, pointer, (__simpleStruct0 = block->size, (size < __simpleStruct0) ? size : __simpleStruct0));
1008 __ecereNameSpace__ecere__com___myfree(pointer);
1009 }
1010 }
1011 return newPointer;
1012 }
1013
1014 static void * __ecereNameSpace__ecere__com___mycrealloc(void * pointer, unsigned int size)
1015 {
1016 struct __ecereNameSpace__ecere__com__MemBlock * block = pointer ? ((struct __ecereNameSpace__ecere__com__MemBlock *)((unsigned char *)pointer - sizeof(struct __ecereNameSpace__ecere__com__MemBlock))) : (((void *)0));
1017 void * newPointer = (((void *)0));
1018 struct __ecereNameSpace__ecere__com__MemPart * part = block ? block->part : (((void *)0));
1019 struct __ecereNameSpace__ecere__com__BlockPool * pool = part ? part->pool : (((void *)0));
1020
1021 if(block)
1022 {
1023 if(pool)
1024 {
1025 unsigned int ns = __ecereNameSpace__ecere__com__pow1_5i(size);
1026 unsigned int mod = ns % sizeof(void *);
1027
1028 if(mod)
1029 ns += sizeof(void *) - mod;
1030 if(ns == (*pool).blockSize)
1031 {
1032 int extra = size - block->size;
1033
1034 newPointer = pointer;
1035 (*pool).usedSpace += extra;
1036 if(extra > 0)
1037 memset((unsigned char *)pointer + block->size, 0, extra);
1038 block->size = size;
1039 }
1040 }
1041 else if(size)
1042 {
1043 struct __ecereNameSpace__ecere__com__MemBlock * newBlock = realloc(block, sizeof(struct __ecereNameSpace__ecere__com__MemBlock) + size);
1044
1045 if(newBlock)
1046 {
1047 int extra = size - newBlock->size;
1048
1049 __ecereNameSpace__ecere__com__TOTAL_MEM += extra;
1050 __ecereNameSpace__ecere__com__OUTSIDE_MEM += extra;
1051 newPointer = ((struct __ecereNameSpace__ecere__com__MemBlock *)newBlock + 1);
1052 if(extra > 0)
1053 memset((unsigned char *)newPointer + newBlock->size, 0, extra);
1054 newBlock->size = size;
1055 }
1056 }
1057 }
1058 if(!newPointer)
1059 {
1060 newPointer = __ecereNameSpace__ecere__com___mymalloc(size);
1061 if(newPointer)
1062 {
1063 if(pointer)
1064 {
1065 unsigned int __simpleStruct0;
1066
1067 memcpy(newPointer, pointer, (__simpleStruct0 = block->size, (size < __simpleStruct0) ? size : __simpleStruct0));
1068 if(size > block->size)
1069 memset((unsigned char *)newPointer + block->size, 0, size - block->size);
1070 __ecereNameSpace__ecere__com___myfree(pointer);
1071 }
1072 else
1073 memset((unsigned char *)newPointer, 0, size);
1074 }
1075 }
1076 return newPointer;
1077 }
1078
1079 static void * __ecereNameSpace__ecere__com___malloc(unsigned int size)
1080 {
1081 void * pointer;
1082
1083 pointer = size ? __ecereNameSpace__ecere__com___mymalloc(size + 2 * 0) : (((void *)0));
1084 return pointer ? ((unsigned char *)pointer + 0) : (((void *)0));
1085 }
1086
1087 static void * __ecereNameSpace__ecere__com___calloc(int n, unsigned int size)
1088 {
1089 void * pointer;
1090
1091 pointer = (n * size) ? __ecereNameSpace__ecere__com___mycalloc(1, n * size + 2 * 0) : (((void *)0));
1092 return pointer ? ((unsigned char *)pointer + 0) : (((void *)0));
1093 }
1094
1095 static void __ecereNameSpace__ecere__com___free(void *  pointer);
1096
1097 static void * __ecereNameSpace__ecere__com___realloc(void * pointer, unsigned int size)
1098 {
1099 if(!size)
1100 {
1101 __ecereNameSpace__ecere__com___free(pointer);
1102 return (((void *)0));
1103 }
1104 pointer = __ecereNameSpace__ecere__com___myrealloc(pointer, size);
1105 return pointer ? ((unsigned char *)pointer + 0) : (((void *)0));
1106 }
1107
1108 static void * __ecereNameSpace__ecere__com___crealloc(void * pointer, unsigned int size)
1109 {
1110 if(!size)
1111 return (((void *)0));
1112 pointer = __ecereNameSpace__ecere__com___mycrealloc(pointer, size);
1113 return pointer ? ((unsigned char *)pointer + 0) : (((void *)0));
1114 }
1115
1116 static void __ecereNameSpace__ecere__com___free(void * pointer)
1117 {
1118 if(pointer)
1119 {
1120 __ecereNameSpace__ecere__com___myfree(pointer);
1121 }
1122 }
1123
1124 void __ecereNameSpace__ecere__com__memswap(unsigned char * a, unsigned char * b, unsigned int size)
1125 {
1126 unsigned int c;
1127 unsigned char buffer[1024];
1128
1129 for(c = 0; c < size; )
1130 {
1131 int s = sizeof buffer;
1132
1133 if(c + s > size)
1134 s = size - c;
1135 memcpy(buffer, a + c, s);
1136 memcpy(a + c, b + c, s);
1137 memcpy(b + c, buffer, s);
1138 c += s;
1139 }
1140 }
1141
1142 void __ecereNameSpace__ecere__com__CheckMemory()
1143 {
1144 }
1145
1146 static void __ecereNameSpace__ecere__com__ComputeClassParameters(struct __ecereNameSpace__ecere__com__Class * templatedClass, char *  templateParams, struct __ecereNameSpace__ecere__com__Instance * findModule);
1147
1148 extern char *  strchr(const char * , int);
1149
1150 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass___ecereNameSpace__ecere__sys__OldLink;
1151
1152 struct __ecereNameSpace__ecere__sys__OldLink
1153 {
1154 struct __ecereNameSpace__ecere__sys__OldLink * prev;
1155 struct __ecereNameSpace__ecere__sys__OldLink * next;
1156 void *  data;
1157 } __attribute__ ((gcc_struct));
1158
1159 extern char *  __ecereNameSpace__ecere__sys__CopyString(char *  string);
1160
1161 extern void *  memmove(void * , const void * , size_t size);
1162
1163 static void __ecereNameSpace__ecere__com__SetDelayedCPValues(struct __ecereNameSpace__ecere__com__Class * _class, struct __ecereNameSpace__ecere__com__ClassProperty * _property);
1164
1165 struct __ecereNameSpace__ecere__sys__BTNode * __ecereProp___ecereNameSpace__ecere__sys__BinaryTree_Get_first(struct __ecereNameSpace__ecere__sys__BinaryTree * this);
1166
1167 extern struct __ecereNameSpace__ecere__com__Property ** __ecereProp___ecereNameSpace__ecere__sys__BinaryTree_first;
1168
1169 struct __ecereNameSpace__ecere__sys__BTNode * __ecereProp___ecereNameSpace__ecere__sys__BTNode_Get_next(struct __ecereNameSpace__ecere__sys__BTNode * this);
1170
1171 extern struct __ecereNameSpace__ecere__com__Property ** __ecereProp___ecereNameSpace__ecere__sys__BTNode_next;
1172
1173 struct __ecereNameSpace__ecere__sys__BTNode * __ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_FindString(struct __ecereNameSpace__ecere__sys__BinaryTree * this, char *  key);
1174
1175 void __ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_Delete(struct __ecereNameSpace__ecere__sys__BinaryTree * this, struct __ecereNameSpace__ecere__sys__BTNode * node);
1176
1177 void __ecereMethod___ecereNameSpace__ecere__sys__OldList_Delete(struct __ecereNameSpace__ecere__sys__OldList * this, void *  item);
1178
1179 static void __ecereNameSpace__ecere__com__FixDerivativesBase(struct __ecereNameSpace__ecere__com__Class * base, struct __ecereNameSpace__ecere__com__Class * mod)
1180 {
1181 struct __ecereNameSpace__ecere__sys__OldLink * derivative;
1182 struct __ecereNameSpace__ecere__sys__OldLink * templateLink;
1183
1184 __ecereNameSpace__ecere__com__ComputeClassParameters(base, strchr(base->name, '<'), (((void *)0)));
1185 for(derivative = base->derivatives.first; derivative; derivative = derivative->next)
1186 {
1187 struct __ecereNameSpace__ecere__com__Class * _class = derivative->data;
1188 int type = _class->type;
1189 int size = _class->structSize - _class->offset;
1190 int oldSizeClass = _class->sizeClass;
1191 int sizeClass = _class->sizeClass - _class->offsetClass;
1192 struct __ecereNameSpace__ecere__com__Class * enumBase = (((void *)0));
1193 char * dataTypeString = (((void *)0));
1194 struct __ecereNameSpace__ecere__com__Class * baseClass;
1195 unsigned int offsetBefore = _class->offset;
1196 int offsetClass, totalSizeClass;
1197
1198 for(baseClass = base; baseClass->base; baseClass = baseClass->base)
1199 ;
1200 if(base && !base->internalDecl && (base->type == 5 || base->type == 1 || base->type == 0))
1201 {
1202 if(base->type == 1 && type == 0)
1203 type = 5;
1204 else
1205 type = base->type;
1206 }
1207 if(base && (_class->type == 0 || _class->type == 5 || _class->type == 1) && (base->type == 3 || base->type == 2 || base->type == 4))
1208 {
1209 type = base->type;
1210 }
1211 if(type == 4)
1212 {
1213 if(base->type != 4)
1214 {
1215 enumBase = base;
1216 base = __ecereNameSpace__ecere__com__eSystem_FindClass(_class->module, "enum");
1217 }
1218 }
1219 dataTypeString = enumBase ? enumBase->dataTypeString : base->dataTypeString;
1220 offsetClass = base ? (base->templateClass ? base->templateClass->sizeClass : base->sizeClass) : (type == 5 ? 0 : 0);
1221 totalSizeClass = offsetClass + sizeClass;
1222 if(type == 0 || type == 5)
1223 _class->offset = (base && (base->templateClass ? base->templateClass->structSize : base->structSize) && base->type != 1000) ? (base->templateClass ? base->templateClass->structSize : base->structSize) : ((type == 5) ? 0 : structSize_Instance);
1224 if(type == 1)
1225 {
1226 _class->memberOffset = (base && (base->templateClass ? base->templateClass->structSize : base->structSize) && base->type != 1000) ? (base->templateClass ? base->templateClass->structSize : base->structSize) : 0;
1227 _class->typeSize = _class->structSize = _class->memberOffset + size;
1228 }
1229 else if(type == 2 || type == 4 || type == 3)
1230 {
1231 struct __ecereNameSpace__ecere__com__Class * dataTypeClass = __ecereNameSpace__ecere__com__eSystem_FindClass(_class->module, dataTypeString);
1232
1233 if(dataTypeClass)
1234 _class->typeSize = dataTypeClass->typeSize;
1235 _class->structSize = 0;
1236 }
1237 else if(type == 0 || type == 5)
1238 {
1239 _class->structSize = _class->offset + size;
1240 _class->typeSize = sizeof(void *);
1241 }
1242 if(_class->type != 1000)
1243 _class->type = type;
1244 (__ecereNameSpace__ecere__com__eSystem_Delete(_class->dataTypeString), _class->dataTypeString = 0);
1245 _class->dataTypeString = __ecereNameSpace__ecere__sys__CopyString(dataTypeString);
1246 if(totalSizeClass != oldSizeClass)
1247 {
1248 _class->data = __ecereNameSpace__ecere__com__eSystem_Renew(_class->data, sizeof(unsigned char) * (totalSizeClass));
1249 memmove((unsigned char *)_class->data + mod->offsetClass, (unsigned char *)_class->data, totalSizeClass - mod->sizeClass);
1250 if(base->type != 1000 && base->type != 4)
1251 memcpy((unsigned char *)_class->data, (unsigned char *)base->data, totalSizeClass - _class->sizeClass);
1252 else
1253 memset((unsigned char *)_class->data, 0, totalSizeClass - _class->sizeClass);
1254 }
1255 _class->offsetClass = offsetClass;
1256 _class->sizeClass = totalSizeClass;
1257 {
1258 struct __ecereNameSpace__ecere__com__Method * method, * next;
1259 struct __ecereNameSpace__ecere__com__Class * b;
1260 unsigned int needUpdate = (mod != (base->templateClass ? base->templateClass : base) || _class->vTblSize != mod->vTblSize);
1261 int updateStart = -1, updateEnd = -1;
1262
1263 if(mod->base && mod->base->base && mod->base->vTblSize > baseClass->vTblSize && needUpdate)
1264 {
1265 _class->vTblSize += mod->base->vTblSize - baseClass->vTblSize;
1266 _class->_vTbl = __ecereNameSpace__ecere__com__eSystem_Renew(_class->_vTbl, sizeof(void *) * (_class->vTblSize));
1267 memmove(_class->_vTbl + mod->base->vTblSize, _class->_vTbl + baseClass->vTblSize, (_class->vTblSize - mod->vTblSize) * sizeof(void *));
1268 updateStart = baseClass->vTblSize;
1269 updateEnd = updateStart + mod->base->vTblSize - baseClass->vTblSize;
1270 for(method = (struct __ecereNameSpace__ecere__com__Method *)__ecereProp___ecereNameSpace__ecere__sys__BinaryTree_Get_first(&_class->methods); method; method = next)
1271 {
1272 next = (struct __ecereNameSpace__ecere__com__Method *)__ecereProp___ecereNameSpace__ecere__sys__BTNode_Get_next(((struct __ecereNameSpace__ecere__sys__BTNode *)method));
1273 if(method->type == 1)
1274 method->vid += mod->base->vTblSize - baseClass->vTblSize;
1275 }
1276 }
1277 for(b = mod->base; b && b != (((void *)0)); b = b->base)
1278 {
1279 struct __ecereNameSpace__ecere__com__Method * vMethod;
1280
1281 for(vMethod = (struct __ecereNameSpace__ecere__com__Method *)__ecereProp___ecereNameSpace__ecere__sys__BinaryTree_Get_first(&b->methods); vMethod; vMethod = (struct __ecereNameSpace__ecere__com__Method *)__ecereProp___ecereNameSpace__ecere__sys__BTNode_Get_next(((struct __ecereNameSpace__ecere__sys__BTNode *)vMethod)))
1282 {
1283 if(vMethod->type == 1)
1284 {
1285 method = (struct __ecereNameSpace__ecere__com__Method *)__ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_FindString(&_class->methods, vMethod->name);
1286 if(method)
1287 {
1288 if(method->function)
1289 _class->_vTbl[vMethod->vid] = method->function;
1290 if(!method->symbol)
1291 {
1292 (__ecereNameSpace__ecere__com__eSystem_Delete(method->name), method->name = 0);
1293 (__ecereNameSpace__ecere__com__eSystem_Delete(method->dataTypeString), method->dataTypeString = 0);
1294 __ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_Delete(&_class->methods, (struct __ecereNameSpace__ecere__sys__BTNode *)method);
1295 }
1296 else
1297 {
1298 (__ecereNameSpace__ecere__com__eSystem_Delete(method->dataTypeString), method->dataTypeString = 0);
1299 method->type = vMethod->type;
1300 method->dataTypeString = __ecereNameSpace__ecere__sys__CopyString(vMethod->dataTypeString);
1301 method->_class = vMethod->_class;
1302 }
1303 }
1304 else if((vMethod->vid >= updateStart && vMethod->vid < updateEnd) || _class->_vTbl[vMethod->vid] == b->_vTbl[vMethod->vid])
1305 _class->_vTbl[vMethod->vid] = _class->base->_vTbl[vMethod->vid];
1306 }
1307 }
1308 }
1309 }
1310 if(type == 0 || type == 5 || type == 1)
1311 {
1312 struct __ecereNameSpace__ecere__com__Property * prop;
1313 struct __ecereNameSpace__ecere__com__DataMember * member;
1314 struct __ecereNameSpace__ecere__com__Class * c;
1315
1316 for(c = mod->base; c; c = c->base)
1317 {
1318 struct __ecereNameSpace__ecere__com__Property * _property;
1319
1320 for(_property = c->membersAndProperties.first; _property; _property = _property->next)
1321 {
1322 if(_property->isProperty)
1323 {
1324 struct __ecereNameSpace__ecere__com__BTNamedLink * link = (struct __ecereNameSpace__ecere__com__BTNamedLink *)__ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_FindString(&_class->prop, _property->name);
1325
1326 if(link)
1327 {
1328 prop = link->data;
1329 if(!prop->Set && !prop->Get && prop->memberAccess == 4)
1330 {
1331 struct __ecereNameSpace__ecere__com__SelfWatcher * watcher;
1332
1333 for(watcher = _class->selfWatchers.first; watcher; watcher = watcher->next)
1334 {
1335 if(watcher->_property == prop)
1336 watcher->_property = _property;
1337 }
1338 _property->selfWatchable = 0x1;
1339 __ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_Delete(&_class->prop, (struct __ecereNameSpace__ecere__sys__BTNode *)link);
1340 (__ecereNameSpace__ecere__com__eSystem_Delete(prop->name), prop->name = 0);
1341 (__ecereNameSpace__ecere__com__eSystem_Delete(prop->dataTypeString), prop->dataTypeString = 0);
1342 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Delete(&_class->membersAndProperties, prop);
1343 }
1344 }
1345 }
1346 }
1347 }
1348 {
1349 for(member = _class->membersAndProperties.first; member; member = member->next)
1350 {
1351 int offsetDiff = _class->offset - offsetBefore;
1352
1353 if(!member->isProperty && offsetDiff > 0)
1354 {
1355 member->offset += offsetDiff;
1356 member->memberOffset += offsetDiff;
1357 }
1358 member->id += mod->base->memberID;
1359 }
1360 _class->memberID += mod->base->memberID;
1361 _class->startMemberID += mod->base->memberID;
1362 }
1363 }
1364 __ecereNameSpace__ecere__com__FixDerivativesBase(_class, mod);
1365 {
1366 struct __ecereNameSpace__ecere__com__Class * c;
1367
1368 for(c = mod->base; c; c = c->base)
1369 {
1370 struct __ecereNameSpace__ecere__com__ClassProperty * _property;
1371
1372 for(_property = (struct __ecereNameSpace__ecere__com__ClassProperty *)__ecereProp___ecereNameSpace__ecere__sys__BinaryTree_Get_first(&c->classProperties); _property; _property = (struct __ecereNameSpace__ecere__com__ClassProperty *)__ecereProp___ecereNameSpace__ecere__sys__BTNode_Get_next(((struct __ecereNameSpace__ecere__sys__BTNode *)_property)))
1373 {
1374 __ecereNameSpace__ecere__com__SetDelayedCPValues(_class, _property);
1375 }
1376 }
1377 }
1378 }
1379 {
1380 struct __ecereNameSpace__ecere__sys__OldLink * templateLink;
1381
1382 for(templateLink = base->templatized.first; templateLink; templateLink = templateLink->next)
1383 {
1384 struct __ecereNameSpace__ecere__com__Class * template = templateLink->data;
1385 char * templateParams = strchr(template->name, '<');
1386
1387 template->base = base->base;
1388 template->_vTbl = base->_vTbl;
1389 template->data = base->data;
1390 template->offset = base->offset;
1391 template->offsetClass = base->offsetClass;
1392 template->sizeClass = base->sizeClass;
1393 template->structSize = base->structSize;
1394 template->vTblSize = base->vTblSize;
1395 __ecereNameSpace__ecere__com__FixDerivativesBase(template, mod);
1396 }
1397 }
1398 }
1399
1400 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass___ecereNameSpace__ecere__com__Application;
1401
1402 struct __ecereNameSpace__ecere__com__Application
1403 {
1404 int argc;
1405 char * *  argv;
1406 int exitCode;
1407 unsigned int isGUIApp;
1408 struct __ecereNameSpace__ecere__sys__OldList allModules;
1409 char *  parsedCommand;
1410 struct __ecereNameSpace__ecere__com__NameSpace systemNameSpace;
1411 } __attribute__ ((gcc_struct));
1412
1413 extern int strcmp(const char * , const char * );
1414
1415 extern char *  strncpy(char * , const char * , size_t n);
1416
1417 static void __ecereNameSpace__ecere__com__FreeTemplatesDerivatives(struct __ecereNameSpace__ecere__com__Class * base);
1418
1419 extern int printf(char * , ...);
1420
1421 static void __ecereNameSpace__ecere__com__NameSpace_Free(struct __ecereNameSpace__ecere__com__NameSpace * parentNameSpace);
1422
1423 static struct __ecereNameSpace__ecere__com__BTNamedLink * __ecereNameSpace__ecere__com__SearchNameSpace(struct __ecereNameSpace__ecere__com__NameSpace * nameSpace, char *  name, void *  listOffset);
1424
1425 extern char *  strcpy(char * , const char * );
1426
1427 static void __ecereNameSpace__ecere__com__FreeTemplateArgs(struct __ecereNameSpace__ecere__com__Class * template);
1428
1429 static void __ecereNameSpace__ecere__com__CopyTemplateArg(struct __ecereNameSpace__ecere__com__ClassTemplateParameter * param, struct __ecereNameSpace__ecere__com__ClassTemplateArgument * arg);
1430
1431 extern char *  strstr(const char * , const char * );
1432
1433 int __ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_CompareString(struct __ecereNameSpace__ecere__sys__BinaryTree * this, char *  a, char *  b);
1434
1435 unsigned int __ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_Add(struct __ecereNameSpace__ecere__sys__BinaryTree * this, struct __ecereNameSpace__ecere__sys__BTNode * node);
1436
1437 void __ecereMethod___ecereNameSpace__ecere__sys__OldList_Remove(struct __ecereNameSpace__ecere__sys__OldList * this, void *  item);
1438
1439 struct __ecereNameSpace__ecere__sys__OldLink * __ecereMethod___ecereNameSpace__ecere__sys__OldList_FindLink(struct __ecereNameSpace__ecere__sys__OldList * this, void *  data);
1440
1441 void __ecereMethod___ecereNameSpace__ecere__sys__OldList_Add(struct __ecereNameSpace__ecere__sys__OldList * this, void *  item);
1442
1443 struct __ecereNameSpace__ecere__com__Class * __ecereNameSpace__ecere__com__eSystem_RegisterClass(int type, char * name, char * baseName, int size, int sizeClass, unsigned int (* Constructor)(void *), void (* Destructor)(void *), struct __ecereNameSpace__ecere__com__Instance * module, int declMode, int inheritanceAccess)
1444 {
1445 int start = 0, c;
1446 struct __ecereNameSpace__ecere__com__NameSpace * nameSpace = (((void *)0));
1447 unsigned int force64Bits = ((unsigned int)((struct __ecereNameSpace__ecere__com__Application *)(((char *)((struct __ecereNameSpace__ecere__com__Module *)(((char *)module + structSize_Instance)))->application + structSize_Module)))->isGUIApp & 2) ? 0x1 : 0x0;
1448 unsigned int force32Bits = ((unsigned int)((struct __ecereNameSpace__ecere__com__Application *)(((char *)((struct __ecereNameSpace__ecere__com__Module *)(((char *)module + structSize_Instance)))->application + structSize_Module)))->isGUIApp & 4) ? 0x1 : 0x0;
1449 unsigned int inCompiler = ((unsigned int)((struct __ecereNameSpace__ecere__com__Application *)(((char *)((struct __ecereNameSpace__ecere__com__Module *)(((char *)module + structSize_Instance)))->application + structSize_Module)))->isGUIApp & 8) ? 0x1 : 0x0;
1450 unsigned int crossBits = force32Bits || force64Bits;
1451 unsigned int fixed = 0x0;
1452
1453 if(inCompiler && crossBits)
1454 {
1455 struct __ecereNameSpace__ecere__com__Class * c = __ecereNameSpace__ecere__com__eSystem_FindClass(((struct __ecereNameSpace__ecere__com__Module *)(((char *)__thisModule + structSize_Instance)))->application, name);
1456
1457 if(c && c->fixed)
1458 fixed = 0x1;
1459 else if(((struct __ecereNameSpace__ecere__com__Module *)(((char *)__thisModule + structSize_Instance)))->name && !strcmp(((struct __ecereNameSpace__ecere__com__Module *)(((char *)__thisModule + structSize_Instance)))->name, "ecereCOM"))
1460 fixed = 0x1;
1461 }
1462 {
1463 nameSpace = (declMode == 1) ? &((struct __ecereNameSpace__ecere__com__Module *)(((char *)module + structSize_Instance)))->publicNameSpace : &((struct __ecereNameSpace__ecere__com__Module *)(((char *)module + structSize_Instance)))->privateNameSpace;
1464 if(declMode == 4)
1465 nameSpace = &((struct __ecereNameSpace__ecere__com__Application *)(((char *)((struct __ecereNameSpace__ecere__com__Module *)(((char *)module + structSize_Instance)))->application + structSize_Module)))->systemNameSpace;
1466 {
1467 for(c = 0; name[c]; c++)
1468 {
1469 if(name[c] == '.' || (name[c] == ':' && name[c + 1] == ':'))
1470 {
1471 struct __ecereNameSpace__ecere__com__NameSpace * newSpace;
1472 char * spaceName = __ecereNameSpace__ecere__com___malloc(c - start + 1);
1473
1474 strncpy(spaceName, name + start, c - start);
1475 spaceName[c - start] = '\0';
1476 newSpace = (struct __ecereNameSpace__ecere__com__NameSpace *)__ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_FindString(&(*nameSpace).nameSpaces, spaceName);
1477 if(!newSpace)
1478 {
1479 newSpace = __ecereNameSpace__ecere__com__eSystem_New0(sizeof(struct __ecereNameSpace__ecere__com__NameSpace) * (1));
1480 (*newSpace).classes.CompareKey = (void *)__ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_CompareString;
1481 (*newSpace).defines.CompareKey = (void *)__ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_CompareString;
1482 (*newSpace).functions.CompareKey = (void *)__ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_CompareString;
1483 (*newSpace).nameSpaces.CompareKey = (void *)__ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_CompareString;
1484 (*newSpace).name = spaceName;
1485 (*newSpace).parent = nameSpace;
1486 __ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_Add(&(*nameSpace).nameSpaces, (struct __ecereNameSpace__ecere__sys__BTNode *)newSpace);
1487 }
1488 else
1489 (__ecereNameSpace__ecere__com__eSystem_Delete(spaceName), spaceName = 0);
1490 nameSpace = newSpace;
1491 if(name[c] == ':')
1492 c++;
1493 start = c + 1;
1494 }
1495 }
1496 }
1497 }
1498 if(c - start)
1499 {
1500 int offsetClass;
1501 int totalSizeClass;
1502 struct __ecereNameSpace__ecere__com__BTNamedLink * classLink = (((void *)0));
1503 struct __ecereNameSpace__ecere__com__Class * _class = (((void *)0));
1504 char * dataTypeString = (((void *)0));
1505 struct __ecereNameSpace__ecere__com__Class * enumBase = (((void *)0));
1506 struct __ecereNameSpace__ecere__com__Class * base = (baseName && baseName[0]) ? __ecereNameSpace__ecere__com__eSystem_FindClass(module, baseName) : (((void *)0));
1507 unsigned int refine = 0x0;
1508
1509 if(base && !base->internalDecl && (base->type == 5 || base->type == 1 || base->type == 0))
1510 {
1511 if(base->type == 1 && type == 0)
1512 type = 5;
1513 else
1514 type = base->type;
1515 }
1516 if(base && (type == 0 || type == 5 || type == 1) && (base->type == 3 || base->type == 2 || base->type == 4))
1517 {
1518 type = base->type;
1519 }
1520 if(!base || base->type == 1000)
1521 {
1522 if(type == 4)
1523 {
1524 if(base || !baseName || !baseName[0] || !strcmp(baseName, "unsigned int") || !strcmp(baseName, "uint") || !strcmp(baseName, "unsigned int64") || !strcmp(baseName, "uint64") || !strcmp(baseName, "int64") || !strcmp(baseName, "unsigned short") || !strcmp(baseName, "short") || !strcmp(baseName, "unsigned char") || !strcmp(baseName, "byte") || !strcmp(baseName, "char") || !strcmp(baseName, "uint32") || !strcmp(baseName, "uint16"))
1525 {
1526 base = __ecereNameSpace__ecere__com__eSystem_FindClass(module, "enum");
1527 dataTypeString = (baseName && baseName[0]) ? baseName : "int";
1528 }
1529 else
1530 {
1531 base = __ecereNameSpace__ecere__com__eSystem_RegisterClass((int)0, baseName, (((void *)0)), 0, 0, (((void *)0)), (((void *)0)), module, declMode, 1);
1532 base->internalDecl = 0x1;
1533 enumBase = base;
1534 base = __ecereNameSpace__ecere__com__eSystem_FindClass(module, "enum");
1535 }
1536 }
1537 else if(type == 1 && (!baseName || !baseName[0]))
1538 {
1539 base = __ecereNameSpace__ecere__com__eSystem_FindClass(module, "struct");
1540 dataTypeString = name + start;
1541 }
1542 else
1543 {
1544 if(type == 0)
1545 dataTypeString = "struct __ecereNameSpace__ecere__com__Instance";
1546 else if(type == 5)
1547 dataTypeString = "void *";
1548 else if(type == 2)
1549 dataTypeString = (baseName && baseName[0]) ? baseName : "unsigned int";
1550 else if(type == 3)
1551 dataTypeString = (baseName && baseName[0]) ? baseName : "int";
1552 else if(type == 1)
1553 dataTypeString = name + start;
1554 if(base || (!baseName || !baseName[0]) || type == 2 || type == 3)
1555 {
1556 if(base || !baseName || !baseName[0] || !strcmp(baseName, "unsigned int") || !strcmp(baseName, "uint") || !strcmp(baseName, "unsigned int64") || !strcmp(baseName, "uint64") || !strcmp(baseName, "int64") || !strcmp(baseName, "unsigned short") || !strcmp(baseName, "short") || !strcmp(baseName, "unsigned char") || !strcmp(baseName, "byte") || !strcmp(baseName, "char") || !strcmp(baseName, "uint32") || !strcmp(baseName, "uint16"))
1557 {
1558 if(type == 0 && strcmp(name, "ecere::com::Instance") && strcmp(name, "enum") && strcmp(name, "struct"))
1559 base = __ecereNameSpace__ecere__com__eSystem_FindClass(module, "ecere::com::Instance");
1560 else
1561 base = __ecereNameSpace__ecere__com__eSystem_FindClass(module, "class");
1562 }
1563 }
1564 else
1565 {
1566 }
1567 }
1568 }
1569 else
1570 {
1571 if(type == 4)
1572 {
1573 if(base->type != 4)
1574 {
1575 enumBase = base;
1576 base = __ecereNameSpace__ecere__com__eSystem_FindClass(module, "enum");
1577 }
1578 }
1579 dataTypeString = enumBase ? enumBase->dataTypeString : base->dataTypeString;
1580 }
1581 offsetClass = base ? base->sizeClass : (type == 5 ? 0 : 0);
1582 totalSizeClass = offsetClass + sizeClass;
1583 if((_class = __ecereNameSpace__ecere__com__eSystem_FindClass(module, name)))
1584 {
1585 __ecereNameSpace__ecere__com__FreeTemplatesDerivatives(_class);
1586 if(!_class->internalDecl)
1587 {
1588 if(declMode != 4)
1589 printf("error: Redefinition of class %s\n", name);
1590 else
1591 {
1592 _class->comRedefinition = 0x1;
1593 return _class;
1594 }
1595 return (((void *)0));
1596 }
1597 classLink = (struct __ecereNameSpace__ecere__com__BTNamedLink *)__ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_FindString(&(*_class->nameSpace).classes, name + start);
1598 __ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_Delete(&(*_class->nameSpace).classes, (struct __ecereNameSpace__ecere__sys__BTNode *)classLink);
1599 {
1600 struct __ecereNameSpace__ecere__sys__OldLink * t;
1601
1602 for(t = _class->templatized.first; t; t = t->next)
1603 {
1604 struct __ecereNameSpace__ecere__com__Class * template = t->data;
1605
1606 classLink = (struct __ecereNameSpace__ecere__com__BTNamedLink *)__ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_FindString(&(*_class->nameSpace).classes, template->name);
1607 __ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_Delete(&(*_class->nameSpace).classes, (struct __ecereNameSpace__ecere__sys__BTNode *)classLink);
1608 }
1609 }
1610 {
1611 struct __ecereNameSpace__ecere__com__NameSpace * ns = _class->nameSpace;
1612
1613 while((*ns).parent && !__ecereProp___ecereNameSpace__ecere__sys__BinaryTree_Get_first(&(*ns).classes) && !__ecereProp___ecereNameSpace__ecere__sys__BinaryTree_Get_first(&(*ns).functions) && !__ecereProp___ecereNameSpace__ecere__sys__BinaryTree_Get_first(&(*ns).defines) && !__ecereProp___ecereNameSpace__ecere__sys__BinaryTree_Get_first(&(*ns).nameSpaces))
1614 {
1615 struct __ecereNameSpace__ecere__com__NameSpace * parent = (*ns).parent;
1616
1617 __ecereNameSpace__ecere__com__NameSpace_Free(ns);
1618 __ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_Delete(&(*parent).nameSpaces, (struct __ecereNameSpace__ecere__sys__BTNode *)ns);
1619 ns = parent;
1620 }
1621 }
1622 refine = 0x1;
1623 }
1624 else
1625 {
1626 classLink = __ecereNameSpace__ecere__com__SearchNameSpace(&((struct __ecereNameSpace__ecere__com__Module *)(((char *)((struct __ecereNameSpace__ecere__com__Module *)(((char *)module + structSize_Instance)))->application + structSize_Instance)))->privateNameSpace, name, &(*((struct __ecereNameSpace__ecere__com__NameSpace *)0)).classes);
1627 if(!classLink)
1628 classLink = __ecereNameSpace__ecere__com__SearchNameSpace(&((struct __ecereNameSpace__ecere__com__Module *)(((char *)((struct __ecereNameSpace__ecere__com__Module *)(((char *)module + structSize_Instance)))->application + structSize_Instance)))->publicNameSpace, name, &(*((struct __ecereNameSpace__ecere__com__NameSpace *)0)).classes);
1629 if(!classLink)
1630 classLink = __ecereNameSpace__ecere__com__SearchNameSpace(&((struct __ecereNameSpace__ecere__com__Module *)(((char *)((struct __ecereNameSpace__ecere__com__Module *)(((char *)module + structSize_Instance)))->application + structSize_Instance)))->privateNameSpace, name + start, &(*((struct __ecereNameSpace__ecere__com__NameSpace *)0)).classes);
1631 if(!classLink)
1632 classLink = __ecereNameSpace__ecere__com__SearchNameSpace(&((struct __ecereNameSpace__ecere__com__Module *)(((char *)((struct __ecereNameSpace__ecere__com__Module *)(((char *)module + structSize_Instance)))->application + structSize_Instance)))->publicNameSpace, name + start, &(*((struct __ecereNameSpace__ecere__com__NameSpace *)0)).classes);
1633 if(classLink)
1634 _class = classLink->data;
1635 if(_class && _class->internalDecl)
1636 {
1637 __ecereNameSpace__ecere__com__FreeTemplatesDerivatives(_class);
1638 __ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_Delete(&(*_class->nameSpace).classes, (struct __ecereNameSpace__ecere__sys__BTNode *)classLink);
1639 {
1640 struct __ecereNameSpace__ecere__sys__OldLink * t;
1641
1642 for(t = _class->templatized.first; t; t = t->next)
1643 {
1644 struct __ecereNameSpace__ecere__com__Class * template = t->data;
1645
1646 classLink = (struct __ecereNameSpace__ecere__com__BTNamedLink *)__ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_FindString(&(*_class->nameSpace).classes, template->name);
1647 __ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_Delete(&(*_class->nameSpace).classes, (struct __ecereNameSpace__ecere__sys__BTNode *)classLink);
1648 }
1649 }
1650 refine = 0x1;
1651 (__ecereNameSpace__ecere__com__eSystem_Delete(_class->fullName), _class->fullName = 0);
1652 _class->fullName = __ecereNameSpace__ecere__sys__CopyString(name);
1653 }
1654 else
1655 {
1656 _class = __ecereNameSpace__ecere__com___calloc(1, sizeof(struct __ecereNameSpace__ecere__com__Class));
1657 _class->methods.CompareKey = (void *)__ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_CompareString;
1658 _class->members.CompareKey = (void *)__ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_CompareString;
1659 _class->prop.CompareKey = (void *)__ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_CompareString;
1660 _class->classProperties.CompareKey = (void *)__ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_CompareString;
1661 _class->name = __ecereNameSpace__ecere__sys__CopyString(name + start);
1662 _class->fullName = __ecereNameSpace__ecere__sys__CopyString(name);
1663 }
1664 }
1665 if(nameSpace)
1666 {
1667 __ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_Add(&(*nameSpace).classes, (struct __ecereNameSpace__ecere__sys__BTNode *)__extension__ ({
1668 struct __ecereNameSpace__ecere__com__BTNamedLink * __ecereInstance1 = __ecereNameSpace__ecere__com__eSystem_New0(structSize_BTNamedLink);
1669
1670 __ecereInstance1->name = _class->name, __ecereInstance1->data = _class, __ecereInstance1;
1671 }));
1672 {
1673 struct __ecereNameSpace__ecere__sys__OldLink * t;
1674
1675 for(t = _class->templatized.first; t; t = t->next)
1676 {
1677 struct __ecereNameSpace__ecere__com__Class * template = t->data;
1678
1679 __ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_Add(&(*nameSpace).classes, (struct __ecereNameSpace__ecere__sys__BTNode *)__extension__ ({
1680 struct __ecereNameSpace__ecere__com__BTNamedLink * __ecereInstance1 = __ecereNameSpace__ecere__com__eSystem_New0(structSize_BTNamedLink);
1681
1682 __ecereInstance1->name = template->name, __ecereInstance1->data = template, __ecereInstance1;
1683 }));
1684 }
1685 }
1686 }
1687 if(_class)
1688 {
1689 if(!base && baseName && strcmp(baseName, name))
1690 {
1691 if(strchr(baseName, '<'))
1692 {
1693 char templateClassName[1024];
1694 struct __ecereNameSpace__ecere__com__Class * templateBase;
1695
1696 strcpy(templateClassName, baseName);
1697 *strchr(templateClassName, '<') = '\0';
1698 templateBase = __ecereNameSpace__ecere__com__eSystem_FindClass(module, templateClassName);
1699 if(!templateBase)
1700 {
1701 templateBase = __ecereNameSpace__ecere__com__eSystem_RegisterClass((int)0, templateClassName, (((void *)0)), 0, 0, (((void *)0)), (((void *)0)), module, declMode, 1);
1702 templateBase->internalDecl = 0x1;
1703 }
1704 base = __ecereNameSpace__ecere__com__eSystem_FindClass(module, baseName);
1705 }
1706 else
1707 {
1708 base = __ecereNameSpace__ecere__com__eSystem_RegisterClass((int)0, baseName, (((void *)0)), 0, 0, (((void *)0)), (((void *)0)), module, declMode, 1);
1709 base->internalDecl = 0x1;
1710 }
1711 }
1712 else
1713 _class->internalDecl = 0x0;
1714 if(totalSizeClass)
1715 {
1716 _class->data = __ecereNameSpace__ecere__com__eSystem_Renew(_class->data, sizeof(unsigned char) * (totalSizeClass));
1717 if(base && base->type != 1000 && base->type != 4)
1718 memcpy(_class->data, base->data, offsetClass);
1719 else
1720 memset(_class->data, 0, offsetClass);
1721 memset((unsigned char *)_class->data + offsetClass, 0, sizeClass);
1722 }
1723 (__ecereNameSpace__ecere__com__eSystem_Delete(_class->dataTypeString), _class->dataTypeString = 0);
1724 _class->dataTypeString = __ecereNameSpace__ecere__sys__CopyString(dataTypeString);
1725 _class->defaultAlignment = base ? base->defaultAlignment : 0;
1726 if(_class->module)
1727 {
1728 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Remove(&((struct __ecereNameSpace__ecere__com__Module *)(((char *)_class->module + structSize_Instance)))->classes, _class);
1729 }
1730 if(_class->base)
1731 {
1732 struct __ecereNameSpace__ecere__com__Class * base = _class->base;
1733 struct __ecereNameSpace__ecere__sys__OldLink * deriv = __ecereMethod___ecereNameSpace__ecere__sys__OldList_FindLink(&base->derivatives, _class);
1734
1735 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Delete(&base->derivatives, deriv);
1736 }
1737 if(module)
1738 {
1739 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Add(&((struct __ecereNameSpace__ecere__com__Module *)(((char *)module + structSize_Instance)))->classes, _class);
1740 }
1741 _class->nameSpace = nameSpace;
1742 {
1743 struct __ecereNameSpace__ecere__sys__OldLink * t;
1744
1745 for(t = _class->templatized.first; t; t = t->next)
1746 {
1747 struct __ecereNameSpace__ecere__com__Class * template = t->data;
1748
1749 template->nameSpace = nameSpace;
1750 }
1751 }
1752 _class->module = module;
1753 _class->base = base;
1754 if(base)
1755 {
1756 int numParams = 0;
1757 struct __ecereNameSpace__ecere__com__Class * sClass;
1758
1759 for(sClass = base; sClass; sClass = sClass->base)
1760 {
1761 if(sClass->templateClass)
1762 sClass = sClass->templateClass;
1763 numParams += sClass->templateParams.count;
1764 }
1765 if(numParams)
1766 {
1767 if(_class->templateArgs)
1768 {
1769 __ecereNameSpace__ecere__com__FreeTemplateArgs(_class);
1770 }
1771 (__ecereNameSpace__ecere__com__eSystem_Delete(_class->templateArgs), _class->templateArgs = 0);
1772 _class->templateArgs = __ecereNameSpace__ecere__com__eSystem_New0(sizeof(struct __ecereNameSpace__ecere__com__ClassTemplateArgument) * (numParams));
1773 _class->numParams = numParams;
1774 for(sClass = _class; sClass; sClass = sClass->base)
1775 {
1776 struct __ecereNameSpace__ecere__com__Class * prevClass;
1777 struct __ecereNameSpace__ecere__com__ClassTemplateParameter * param;
1778 int id = 0;
1779
1780 if(sClass->templateClass)
1781 sClass = sClass->templateClass;
1782 for(prevClass = sClass->base; prevClass; prevClass = prevClass->base)
1783 {
1784 if(prevClass->templateClass)
1785 prevClass = prevClass->templateClass;
1786 id += prevClass->templateParams.count;
1787 }
1788 if(base->templateArgs)
1789 {
1790 for(param = sClass->templateParams.first; param; param = param->next)
1791 {
1792 _class->templateArgs[id] = base->templateArgs[id];
1793 __ecereNameSpace__ecere__com__CopyTemplateArg(param, &_class->templateArgs[id]);
1794 id++;
1795 }
1796 }
1797 }
1798 }
1799 }
1800 _class->memberID = _class->startMemberID = (base && (type == 0 || type == 5 || type == 1)) ? base->memberID : 0;
1801 if(type == 0 || type == 5)
1802 _class->offset = (base && base->structSize && base->type != 1000) ? base->structSize : ((type == 5) ? 0 : ((force64Bits && inCompiler && fixed) ? 24 : (force32Bits && inCompiler && fixed) ? 12 : structSize_Instance));
1803 if(crossBits)
1804 {
1805 if(strstr(name, "ecere::sys::EARHeader") || strstr(name, "AnchorValue") || !strcmp(name, "ecere::com::CustomAVLTree") || !strcmp(name, "ecere::com::Array") || !strcmp(name, "ecere::gui::Window") || !strcmp(name, "ecere::sys::Mutex"))
1806 ;
1807 else
1808 {
1809 if(!strcmp(name, "ecere::sys::FileListing"))
1810 {
1811 size = 3 * (force32Bits ? 4 : 8);
1812 _class->structAlignment = force32Bits ? 4 : 8;
1813 }
1814 else if(!strcmp(name, "ecere::com::Class"))
1815 size = 0;
1816 else if(!strcmp(name, "ecere::com::ClassProperty"))
1817 size = 0;
1818 else if(!strcmp(name, "ecere::com::NameSpace"))
1819 size = 0;
1820 else if(!strcmp(name, "ecere::sys::BufferedFile"))
1821 size = 0;
1822 else if(!strcmp(name, "ecere::sys::BTNode"))
1823 size = 0;
1824 else if(!strcmp(name, "ecere::sys::StringBTNode"))
1825 size = 0;
1826 else if(!strcmp(name, "ecere::sys::OldList"))
1827 size = 0;
1828 else if(!strcmp(name, "ecere::sys::Item"))
1829 size = 0;
1830 else if(!strcmp(name, "ecere::sys::NamedLink"))
1831 size = 0;
1832 else if(!strcmp(name, "ecere::sys::OldLink"))
1833 size = 0;
1834 else if(!strcmp(name, "ecere::sys::NamedItem"))
1835 size = 0;
1836 else if(!strcmp(name, "ecere::sys::NamedItem64"))
1837 size = 0;
1838 else if(!strcmp(name, "ecere::sys::BinaryTree"))
1839 size = 0;
1840 else if(module != ((struct __ecereNameSpace__ecere__com__Module *)(((char *)module + structSize_Instance)))->application && inCompiler)
1841 {
1842 if(fixed || type == 1)
1843 size = 0;
1844 }
1845 }
1846 }
1847 if(type == 1)
1848 {
1849 _class->memberOffset = (base && base->structSize && base->type != 1000) ? base->structSize : 0;
1850 _class->typeSize = _class->structSize = _class->memberOffset + size;
1851 }
1852 else if(type == 2 || type == 4 || type == 3)
1853 {
1854 struct __ecereNameSpace__ecere__com__Class * dataTypeClass = __ecereNameSpace__ecere__com__eSystem_FindClass(_class->module, dataTypeString);
1855
1856 if(dataTypeClass)
1857 _class->typeSize = dataTypeClass->typeSize;
1858 _class->structSize = 0;
1859 }
1860 else if(type == 0 || type == 5)
1861 {
1862 _class->structSize = _class->offset + size;
1863 _class->typeSize = sizeof(void *);
1864 }
1865 _class->offsetClass = offsetClass;
1866 _class->sizeClass = totalSizeClass;
1867 _class->Constructor = (void *)Constructor;
1868 _class->Destructor = Destructor;
1869 if(_class->type != 1000)
1870 _class->type = type;
1871 if(!size)
1872 _class->computeSize = 0x1;
1873 else
1874 _class->computeSize = 0x0;
1875 _class->inheritanceAccess = inheritanceAccess;
1876 if(type == 4)
1877 {
1878 if(enumBase)
1879 _class->base = base = enumBase;
1880 {
1881 struct __ecereNameSpace__ecere__com__EnumClassData * data = (struct __ecereNameSpace__ecere__com__EnumClassData *)_class->data;
1882
1883 if(base && base->type != 4)
1884 data->largest = -1;
1885 else
1886 data->largest = ((struct __ecereNameSpace__ecere__com__EnumClassData *)base->data)->largest;
1887 }
1888 }
1889 if(base && base->vTblSize)
1890 {
1891 _class->vTblSize = base->vTblSize;
1892 (__ecereNameSpace__ecere__com__eSystem_Delete(_class->_vTbl), _class->_vTbl = 0);
1893 _class->_vTbl = __ecereNameSpace__ecere__com___malloc(sizeof(int (*)()) * _class->vTblSize);
1894 memcpy(_class->_vTbl, base->_vTbl, sizeof(int (*)()) * _class->vTblSize);
1895 }
1896 if(_class->base)
1897 {
1898 struct __ecereNameSpace__ecere__sys__OldLink * link = (link = __ecereNameSpace__ecere__com__eSystem_New0(structSize_OldLink), link->data = _class, link);
1899
1900 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Add(&_class->base->derivatives, link);
1901 }
1902 __ecereNameSpace__ecere__com__FixDerivativesBase(_class, _class);
1903 return _class;
1904 }
1905 }
1906 return (((void *)0));
1907 }
1908
1909 static void __ecereNameSpace__ecere__com__DataMember_Free(struct __ecereNameSpace__ecere__com__DataMember * parentMember)
1910 {
1911 struct __ecereNameSpace__ecere__com__DataMember * member;
1912 struct __ecereNameSpace__ecere__com__BTNamedLink * namedLink;
1913
1914 (__ecereNameSpace__ecere__com__eSystem_Delete(parentMember->name), parentMember->name = 0);
1915 (__ecereNameSpace__ecere__com__eSystem_Delete(parentMember->dataTypeString), parentMember->dataTypeString = 0);
1916 while((member = parentMember->members.first))
1917 {
1918 __ecereNameSpace__ecere__com__DataMember_Free(member);
1919 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Delete(&parentMember->members, member);
1920 }
1921 while((namedLink = (struct __ecereNameSpace__ecere__com__BTNamedLink *)__ecereProp___ecereNameSpace__ecere__sys__BinaryTree_Get_first(&parentMember->membersAlpha)))
1922 {
1923 __ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_Delete(&parentMember->membersAlpha, (struct __ecereNameSpace__ecere__sys__BTNode *)namedLink);
1924 }
1925 }
1926
1927 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass___ecereNameSpace__ecere__sys__NamedLink;
1928
1929 struct __ecereNameSpace__ecere__sys__NamedLink
1930 {
1931 struct __ecereNameSpace__ecere__sys__NamedLink * prev;
1932 struct __ecereNameSpace__ecere__sys__NamedLink * next;
1933 char *  name;
1934 void *  data;
1935 } __attribute__ ((gcc_struct));
1936
1937 static void __ecereNameSpace__ecere__com__FreeEnumValue(struct __ecereNameSpace__ecere__sys__NamedLink * value)
1938 {
1939 (__ecereNameSpace__ecere__com__eSystem_Delete(value->name), value->name = 0);
1940 }
1941
1942 static void __ecereNameSpace__ecere__com__FreeTemplateArg(struct __ecereNameSpace__ecere__com__Class * template, struct __ecereNameSpace__ecere__com__ClassTemplateParameter * param, int id)
1943 {
1944 switch(param->type)
1945 {
1946 case 0:
1947 (__ecereNameSpace__ecere__com__eSystem_Delete(template->templateArgs[id].dataTypeString), template->templateArgs[id].dataTypeString = 0);
1948 break;
1949 case 1:
1950 (__ecereNameSpace__ecere__com__eSystem_Delete(template->templateArgs[id].memberString), template->templateArgs[id].memberString = 0);
1951 break;
1952 case 2:
1953 break;
1954 }
1955 }
1956
1957 static void __ecereNameSpace__ecere__com__FreeTemplateArgs(struct __ecereNameSpace__ecere__com__Class * template)
1958 {
1959 if(template->templateArgs)
1960 {
1961 struct __ecereNameSpace__ecere__com__Class * _class;
1962
1963 for(_class = template; _class; _class = _class->base)
1964 {
1965 struct __ecereNameSpace__ecere__com__Class * prevClass;
1966 struct __ecereNameSpace__ecere__com__ClassTemplateParameter * param;
1967 int id = 0;
1968
1969 if(_class->templateClass)
1970 _class = _class->templateClass;
1971 for(prevClass = _class->base; prevClass; prevClass = prevClass->base)
1972 {
1973 if(prevClass->templateClass)
1974 prevClass = prevClass->templateClass;
1975 id += prevClass->templateParams.count;
1976 }
1977 if(id < template->numParams)
1978 {
1979 for(param = _class->templateParams.first; param; param = param->next)
1980 {
1981 switch(param->type)
1982 {
1983 case 0:
1984 (__ecereNameSpace__ecere__com__eSystem_Delete(template->templateArgs[id].dataTypeString), template->templateArgs[id].dataTypeString = 0);
1985 break;
1986 case 1:
1987 (__ecereNameSpace__ecere__com__eSystem_Delete(template->templateArgs[id].memberString), template->templateArgs[id].memberString = 0);
1988 break;
1989 case 2:
1990 break;
1991 }
1992 id++;
1993 }
1994 }
1995 }
1996 }
1997 }
1998
1999 static void __ecereNameSpace__ecere__com__FreeTemplate(struct __ecereNameSpace__ecere__com__Class * template)
2000 {
2001 struct __ecereNameSpace__ecere__sys__OldLink * deriv;
2002
2003 if(template->nameSpace)
2004 {
2005 struct __ecereNameSpace__ecere__com__BTNamedLink * link = (struct __ecereNameSpace__ecere__com__BTNamedLink *)__ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_FindString(&(*template->nameSpace).classes, template->name);
2006
2007 __ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_Delete(&(*template->nameSpace).classes, (struct __ecereNameSpace__ecere__sys__BTNode *)link);
2008 }
2009 __ecereNameSpace__ecere__com__FreeTemplateArgs(template);
2010 (__ecereNameSpace__ecere__com__eSystem_Delete(template->fullName), template->fullName = 0);
2011 (__ecereNameSpace__ecere__com__eSystem_Delete(template->name), template->name = 0);
2012 (__ecereNameSpace__ecere__com__eSystem_Delete(template->templateArgs), template->templateArgs = 0);
2013 (__ecereNameSpace__ecere__com__eSystem_Delete(template->dataTypeString), template->dataTypeString = 0);
2014 while((deriv = template->derivatives.first))
2015 {
2016 ((struct __ecereNameSpace__ecere__com__Class *)deriv->data)->base = (((void *)0));
2017 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Delete(&template->derivatives, deriv);
2018 }
2019 __ecereNameSpace__ecere__com___free(template);
2020 }
2021
2022 static void __ecereNameSpace__ecere__com__FreeTemplates(struct __ecereNameSpace__ecere__com__Class * _class)
2023 {
2024 struct __ecereNameSpace__ecere__sys__OldLink * deriv, * template;
2025
2026 for(deriv = _class->derivatives.first; deriv; deriv = deriv->next)
2027 {
2028 __ecereNameSpace__ecere__com__FreeTemplates(deriv->data);
2029 }
2030 __ecereNameSpace__ecere__com__FreeTemplateArgs(_class);
2031 (__ecereNameSpace__ecere__com__eSystem_Delete(_class->templateArgs), _class->templateArgs = 0);
2032 (__ecereNameSpace__ecere__com__eSystem_Delete(_class->dataTypeString), _class->dataTypeString = 0);
2033 while((template = _class->templatized.first))
2034 {
2035 __ecereNameSpace__ecere__com__FreeTemplates(template->data);
2036 __ecereNameSpace__ecere__com__FreeTemplate(template->data);
2037 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Delete(&_class->templatized, template);
2038 }
2039 }
2040
2041 void __ecereMethod___ecereNameSpace__ecere__sys__OldList_Free(struct __ecereNameSpace__ecere__sys__OldList * this, void (*  freeFn)(void * ));
2042
2043 void __ecereNameSpace__ecere__com__eClass_Unregister(struct __ecereNameSpace__ecere__com__Class * _class)
2044 {
2045 struct __ecereNameSpace__ecere__com__BTNamedLink * namedLink;
2046 struct __ecereNameSpace__ecere__com__DataMember * member;
2047 struct __ecereNameSpace__ecere__com__Method * method;
2048 struct __ecereNameSpace__ecere__sys__OldLink * deriv, * template;
2049 struct __ecereNameSpace__ecere__com__ClassProperty * classProp;
2050 struct __ecereNameSpace__ecere__com__ClassTemplateParameter * param;
2051
2052 (__ecereNameSpace__ecere__com__eSystem_Delete(_class->_vTbl), _class->_vTbl = 0);
2053 __ecereNameSpace__ecere__com__FreeTemplates(_class);
2054 __ecereNameSpace__ecere__com__FreeTemplateArgs(_class);
2055 (__ecereNameSpace__ecere__com__eSystem_Delete(_class->templateArgs), _class->templateArgs = 0);
2056 while((template = _class->templatized.first))
2057 {
2058 __ecereNameSpace__ecere__com__FreeTemplate(template->data);
2059 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Delete(&_class->templatized, template);
2060 }
2061 while((member = _class->membersAndProperties.first))
2062 {
2063 if(!member->isProperty && (member->type == 1 || member->type == 2))
2064 __ecereNameSpace__ecere__com__DataMember_Free(member);
2065 (__ecereNameSpace__ecere__com__eSystem_Delete(member->name), member->name = 0);
2066 (__ecereNameSpace__ecere__com__eSystem_Delete(member->dataTypeString), member->dataTypeString = 0);
2067 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Delete(&_class->membersAndProperties, member);
2068 }
2069 while((member = _class->conversions.first))
2070 {
2071 (__ecereNameSpace__ecere__com__eSystem_Delete(member->name), member->name = 0);
2072 (__ecereNameSpace__ecere__com__eSystem_Delete(member->dataTypeString), member->dataTypeString = 0);
2073 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Delete(&_class->conversions, member);
2074 }
2075 while((namedLink = (struct __ecereNameSpace__ecere__com__BTNamedLink *)__ecereProp___ecereNameSpace__ecere__sys__BinaryTree_Get_first(&_class->prop)))
2076 {
2077 __ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_Delete(&_class->prop, (struct __ecereNameSpace__ecere__sys__BTNode *)namedLink);
2078 }
2079 while((namedLink = (struct __ecereNameSpace__ecere__com__BTNamedLink *)__ecereProp___ecereNameSpace__ecere__sys__BinaryTree_Get_first(&_class->members)))
2080 {
2081 __ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_Delete(&_class->members, (struct __ecereNameSpace__ecere__sys__BTNode *)namedLink);
2082 }
2083 while((classProp = (struct __ecereNameSpace__ecere__com__ClassProperty *)__ecereProp___ecereNameSpace__ecere__sys__BinaryTree_Get_first(&_class->classProperties)))
2084 {
2085 (__ecereNameSpace__ecere__com__eSystem_Delete(classProp->name), classProp->name = 0);
2086 (__ecereNameSpace__ecere__com__eSystem_Delete(classProp->dataTypeString), classProp->dataTypeString = 0);
2087 __ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_Delete(&_class->classProperties, (struct __ecereNameSpace__ecere__sys__BTNode *)classProp);
2088 }
2089 while((method = (struct __ecereNameSpace__ecere__com__Method *)__ecereProp___ecereNameSpace__ecere__sys__BinaryTree_Get_first(&_class->methods)))
2090 {
2091 (__ecereNameSpace__ecere__com__eSystem_Delete(method->name), method->name = 0);
2092 (__ecereNameSpace__ecere__com__eSystem_Delete(method->dataTypeString), method->dataTypeString = 0);
2093 __ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_Delete(&_class->methods, (struct __ecereNameSpace__ecere__sys__BTNode *)method);
2094 }
2095 if(_class->type == 4)
2096 {
2097 struct __ecereNameSpace__ecere__com__EnumClassData * data = (struct __ecereNameSpace__ecere__com__EnumClassData *)_class->data;
2098
2099 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Free(&data->values, (void *)__ecereNameSpace__ecere__com__FreeEnumValue);
2100 }
2101 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Free(&_class->delayedCPValues, (((void *)0)));
2102 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Free(&_class->selfWatchers, (((void *)0)));
2103 if(_class->base)
2104 {
2105 struct __ecereNameSpace__ecere__com__Class * base = _class->base;
2106
2107 for(deriv = base->derivatives.first; deriv; deriv = deriv->next)
2108 {
2109 if(deriv->data == _class)
2110 break;
2111 }
2112 if(deriv)
2113 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Delete(&base->derivatives, deriv);
2114 }
2115 while((deriv = _class->derivatives.first))
2116 {
2117 ((struct __ecereNameSpace__ecere__com__Class *)deriv->data)->base = (((void *)0));
2118 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Delete(&_class->derivatives, deriv);
2119 }
2120 if(_class->nameSpace)
2121 {
2122 struct __ecereNameSpace__ecere__com__BTNamedLink * link = (struct __ecereNameSpace__ecere__com__BTNamedLink *)__ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_FindString(&(*_class->nameSpace).classes, _class->name);
2123
2124 __ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_Delete(&(*_class->nameSpace).classes, (struct __ecereNameSpace__ecere__sys__BTNode *)link);
2125 }
2126 (__ecereNameSpace__ecere__com__eSystem_Delete(_class->name), _class->name = 0);
2127 (__ecereNameSpace__ecere__com__eSystem_Delete(_class->fullName), _class->fullName = 0);
2128 (__ecereNameSpace__ecere__com__eSystem_Delete(_class->dataTypeString), _class->dataTypeString = 0);
2129 (__ecereNameSpace__ecere__com__eSystem_Delete(_class->data), _class->data = 0);
2130 while((param = _class->templateParams.first))
2131 {
2132 switch(param->type)
2133 {
2134 case 0:
2135 (__ecereNameSpace__ecere__com__eSystem_Delete(param->defaultArg.dataTypeString), param->defaultArg.dataTypeString = 0);
2136 break;
2137 case 1:
2138 (__ecereNameSpace__ecere__com__eSystem_Delete(param->defaultArg.memberString), param->defaultArg.memberString = 0);
2139 break;
2140 case 2:
2141 break;
2142 }
2143 if(param->type != 1)
2144 (__ecereNameSpace__ecere__com__eSystem_Delete(param->dataTypeString), param->dataTypeString = 0);
2145 (__ecereNameSpace__ecere__com__eSystem_Delete(param->name), param->name = 0);
2146 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Delete(&_class->templateParams, param);
2147 }
2148 __ecereNameSpace__ecere__com___free(_class);
2149 }
2150
2151 struct __ecereNameSpace__ecere__sys__BTNode * __ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_Find(struct __ecereNameSpace__ecere__sys__BinaryTree * this, uintptr_t key);
2152
2153 static struct __ecereNameSpace__ecere__com__BTNamedLink * __ecereNameSpace__ecere__com__ScanNameSpace(struct __ecereNameSpace__ecere__com__NameSpace * nameSpace, char * name, void * listOffset)
2154 {
2155 struct __ecereNameSpace__ecere__sys__BinaryTree * tree = (struct __ecereNameSpace__ecere__sys__BinaryTree *)((unsigned char *)nameSpace + (unsigned int)listOffset);
2156 struct __ecereNameSpace__ecere__com__BTNamedLink * link = (struct __ecereNameSpace__ecere__com__BTNamedLink *)__ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_Find((&*tree), (uintptr_t)name);
2157 struct __ecereNameSpace__ecere__com__NameSpace * child;
2158
2159 if(!link)
2160 {
2161 for(child = (struct __ecereNameSpace__ecere__com__NameSpace *)__ecereProp___ecereNameSpace__ecere__sys__BinaryTree_Get_first(&nameSpace->nameSpaces); child; child = (struct __ecereNameSpace__ecere__com__NameSpace *)__ecereProp___ecereNameSpace__ecere__sys__BTNode_Get_next(((struct __ecereNameSpace__ecere__sys__BTNode *)child)))
2162 {
2163 link = __ecereNameSpace__ecere__com__ScanNameSpace(child, name, listOffset);
2164 if(link)
2165 break;
2166 }
2167 }
2168 return link;
2169 }
2170
2171 static struct __ecereNameSpace__ecere__com__BTNamedLink * __ecereNameSpace__ecere__com__SearchNameSpace(struct __ecereNameSpace__ecere__com__NameSpace * nameSpace, char * name, void * listOffset)
2172 {
2173 int start = 0, c;
2174 char ch;
2175 int level = 0;
2176
2177 for(c = 0; (ch = name[c]); c++)
2178 {
2179 if(ch == '<')
2180 level++;
2181 if(ch == '>')
2182 level--;
2183 if(level == 0 && (ch == '.' || (ch == ':' && name[c + 1] == ':')))
2184 {
2185 struct __ecereNameSpace__ecere__com__NameSpace * newSpace;
2186 char * spaceName = __ecereNameSpace__ecere__com___malloc(c - start + 1);
2187
2188 memcpy(spaceName, name + start, c - start);
2189 spaceName[c - start] = '\0';
2190 newSpace = (struct __ecereNameSpace__ecere__com__NameSpace *)__ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_FindString(&nameSpace->nameSpaces, spaceName);
2191 __ecereNameSpace__ecere__com___free(spaceName);
2192 if(!newSpace)
2193 return (((void *)0));
2194 nameSpace = newSpace;
2195 if(level == 0 && ch == ':')
2196 c++;
2197 start = c + 1;
2198 }
2199 }
2200 if(c - start)
2201 {
2202 return __ecereNameSpace__ecere__com__ScanNameSpace(nameSpace, name + start, listOffset);
2203 }
2204 return (((void *)0));
2205 }
2206
2207 static struct __ecereNameSpace__ecere__com__BTNamedLink * __ecereNameSpace__ecere__com__SearchModule(struct __ecereNameSpace__ecere__com__Instance * module, char * name, void * listOffset, unsigned int searchPrivate)
2208 {
2209 struct __ecereNameSpace__ecere__com__SubModule * subModule;
2210 struct __ecereNameSpace__ecere__com__BTNamedLink * link;
2211
2212 if(searchPrivate)
2213 {
2214 link = __ecereNameSpace__ecere__com__SearchNameSpace(&((struct __ecereNameSpace__ecere__com__Module *)(((char *)module + structSize_Instance)))->privateNameSpace, name, listOffset);
2215 if(link)
2216 return link;
2217 }
2218 link = __ecereNameSpace__ecere__com__SearchNameSpace(&((struct __ecereNameSpace__ecere__com__Module *)(((char *)module + structSize_Instance)))->publicNameSpace, name, listOffset);
2219 if(link)
2220 return link;
2221 for(subModule = ((struct __ecereNameSpace__ecere__com__Module *)(((char *)module + structSize_Instance)))->modules.first; subModule; subModule = subModule->next)
2222 {
2223 if(searchPrivate || subModule->importMode == 1)
2224 {
2225 link = __ecereNameSpace__ecere__com__SearchModule(subModule->module, name, listOffset, 0x0);
2226 if(link)
2227 return link;
2228 }
2229 }
2230 return (((void *)0));
2231 }
2232
2233 extern int isspace(int c);
2234
2235 long long __ecereNameSpace__ecere__com___strtoi64(char * string, char ** endString, int base)
2236 {
2237 long long value = 0;
2238 int sign = 1;
2239 int c;
2240 char ch;
2241
2242 for(c = 0; (ch = string[c]) && isspace(ch); c++)
2243 ;
2244 if(ch == '+')
2245 c++;
2246 else if(ch == '-')
2247 {
2248 sign = -1;
2249 c++;
2250 }
2251 ;
2252 if(!base)
2253 {
2254 if(ch == '0' && string[c + 1] == 'x')
2255 {
2256 base = 16;
2257 c += 2;
2258 }
2259 else if(ch == '0')
2260 {
2261 base = 8;
2262 c++;
2263 }
2264 else
2265 base = 10;
2266 }
2267 for(; (ch = string[c]); c++)
2268 {
2269 if(ch >= '0' && ch <= '9')
2270 ch -= '0';
2271 else if(ch >= 'a' && ch <= 'z')
2272 ch -= ('a' - 10);
2273 else if(ch >= 'A' && ch <= 'Z')
2274 ch -= ('A' - 10);
2275 else
2276 {
2277 if(endString)
2278 *endString = string + c;
2279 break;
2280 }
2281 if(ch < base)
2282 {
2283 value *= base;
2284 value += ch;
2285 }
2286 else
2287 {
2288 if(endString)
2289 *endString = string + c;
2290 break;
2291 }
2292 }
2293 return sign * value;
2294 }
2295
2296 uint64 __ecereNameSpace__ecere__com___strtoui64(char * string, char ** endString, int base)
2297 {
2298 uint64 value = 0;
2299 int sign = 1;
2300 int c;
2301 char ch;
2302
2303 for(c = 0; (ch = string[c]) && isspace(ch); c++)
2304 ;
2305 if(ch == '+')
2306 c++;
2307 else if(ch == '-')
2308 {
2309 sign = -1;
2310 c++;
2311 }
2312 ;
2313 if(!base)
2314 {
2315 if(ch == '0' && string[c + 1] == 'x')
2316 {
2317 base = 16;
2318 c += 2;
2319 }
2320 else if(ch == '0')
2321 {
2322 base = 8;
2323 c++;
2324 }
2325 else
2326 base = 10;
2327 }
2328 for(; (ch = string[c]); c++)
2329 {
2330 if(ch >= '0' && ch <= '9')
2331 ch -= '0';
2332 else if(ch >= 'a' && ch <= 'z')
2333 ch -= ('a' - 10);
2334 else if(ch >= 'A' && ch <= 'Z')
2335 ch -= ('A' - 10);
2336 else
2337 {
2338 if(endString)
2339 *endString = string + c;
2340 break;
2341 }
2342 if(ch < base)
2343 {
2344 value *= base;
2345 value += ch;
2346 }
2347 else
2348 {
2349 if(endString)
2350 *endString = string + c;
2351 break;
2352 }
2353 }
2354 return sign * value;
2355 }
2356
2357 extern char *  strcat(char * , const char * );
2358
2359 extern size_t strlen(const char * );
2360
2361 struct __ecereNameSpace__ecere__com__Class * __ecereNameSpace__ecere__com__eSystem_FindClass(struct __ecereNameSpace__ecere__com__Instance * module, char * name)
2362 {
2363 if(name && module)
2364 {
2365 struct __ecereNameSpace__ecere__com__BTNamedLink * link;
2366
2367 link = __ecereNameSpace__ecere__com__SearchNameSpace(&((struct __ecereNameSpace__ecere__com__Application *)(((char *)((struct __ecereNameSpace__ecere__com__Module *)(((char *)module + structSize_Instance)))->application + structSize_Module)))->systemNameSpace, name, &(*((struct __ecereNameSpace__ecere__com__NameSpace *)0)).classes);
2368 if(link)
2369 return link->data;
2370 link = __ecereNameSpace__ecere__com__SearchModule(module, name, &(*((struct __ecereNameSpace__ecere__com__NameSpace *)0)).classes, 0x1);
2371 if(link)
2372 return link->data;
2373 {
2374 char noTemplateName[1024];
2375 char * templateParams = strchr(name, '<');
2376
2377 if(templateParams)
2378 {
2379 strncpy(noTemplateName, name, templateParams - name);
2380 noTemplateName[templateParams - name] = '\0';
2381 }
2382 else
2383 strcpy(noTemplateName, name);
2384 link = __ecereNameSpace__ecere__com__SearchNameSpace(&((struct __ecereNameSpace__ecere__com__Application *)(((char *)((struct __ecereNameSpace__ecere__com__Module *)(((char *)module + structSize_Instance)))->application + structSize_Module)))->systemNameSpace, noTemplateName, &(*((struct __ecereNameSpace__ecere__com__NameSpace *)0)).classes);
2385 if(!link)
2386 link = __ecereNameSpace__ecere__com__SearchModule(module, noTemplateName, &(*((struct __ecereNameSpace__ecere__com__NameSpace *)0)).classes, 0x1);
2387 if(link)
2388 {
2389 struct __ecereNameSpace__ecere__com__Class * _class = link->data;
2390 struct __ecereNameSpace__ecere__com__Class * templatedClass = (((void *)0));
2391 char className[1024];
2392
2393 strcpy(className, _class->fullName);
2394 strcat(className, templateParams);
2395 link = __ecereNameSpace__ecere__com__SearchNameSpace(&((struct __ecereNameSpace__ecere__com__Application *)(((char *)((struct __ecereNameSpace__ecere__com__Module *)(((char *)module + structSize_Instance)))->application + structSize_Module)))->systemNameSpace, className, &(*((struct __ecereNameSpace__ecere__com__NameSpace *)0)).classes);
2396 if(link)
2397 return link->data;
2398 link = __ecereNameSpace__ecere__com__SearchModule(module, className, &(*((struct __ecereNameSpace__ecere__com__NameSpace *)0)).classes, 0x1);
2399 if(link)
2400 return link->data;
2401 if(_class && templateParams)
2402 {
2403 struct __ecereNameSpace__ecere__sys__OldList __simpleStruct1 =
2404 {
2405 0, 0, 0, 0, 0
2406 };
2407 struct __ecereNameSpace__ecere__sys__OldList __simpleStruct0 =
2408 {
2409 0, 0, 0, 0, 0
2410 };
2411
2412 templatedClass = __ecereNameSpace__ecere__com__eSystem_New0(structSize_Class);
2413 *templatedClass = *_class;
2414 templatedClass->templateClass = _class;
2415 templatedClass->fullName = __ecereNameSpace__ecere__sys__CopyString(className);
2416 templatedClass->dataTypeString = __ecereNameSpace__ecere__sys__CopyString(_class->dataTypeString);
2417 templatedClass->name = __ecereNameSpace__ecere__sys__CopyString(templatedClass->fullName + strlen(_class->fullName) - strlen(_class->name));
2418 __ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_Add(&(*templatedClass->nameSpace).classes, (struct __ecereNameSpace__ecere__sys__BTNode *)__extension__ ({
2419 struct __ecereNameSpace__ecere__com__BTNamedLink * __ecereInstance1 = __ecereNameSpace__ecere__com__eSystem_New0(structSize_BTNamedLink);
2420
2421 __ecereInstance1->name = templatedClass->name, __ecereInstance1->data = templatedClass, __ecereInstance1;
2422 }));
2423 templatedClass->templateArgs = (((void *)0));
2424 templatedClass->numParams = 0;
2425 templatedClass->derivatives = __simpleStruct0;
2426 templatedClass->templatized = __simpleStruct1;
2427 __ecereNameSpace__ecere__com__ComputeClassParameters(templatedClass, templateParams, module);
2428 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Add(&_class->templatized, __extension__ ({
2429 struct __ecereNameSpace__ecere__sys__OldLink * __ecereInstance1 = __ecereNameSpace__ecere__com__eSystem_New0(structSize_OldLink);
2430
2431 __ecereInstance1->data = templatedClass, __ecereInstance1;
2432 }));
2433 }
2434 return templatedClass;
2435 }
2436 }
2437 }
2438 return (((void *)0));
2439 }
2440
2441 static void __ecereNameSpace__ecere__com__CopyTemplateArg(struct __ecereNameSpace__ecere__com__ClassTemplateParameter * param, struct __ecereNameSpace__ecere__com__ClassTemplateArgument * arg)
2442 {
2443 switch(param->type)
2444 {
2445 case 0:
2446 arg->dataTypeString = __ecereNameSpace__ecere__sys__CopyString(arg->dataTypeString);
2447 break;
2448 case 2:
2449 break;
2450 case 1:
2451 arg->memberString = __ecereNameSpace__ecere__sys__CopyString(arg->memberString);
2452 break;
2453 }
2454 }
2455
2456 extern char *  __ecereNameSpace__ecere__sys__TrimRSpaces(char *  string, char *  output);
2457
2458 extern unsigned long strtoul(const char *  nptr, char * *  endptr, int base);
2459
2460 extern double strtod(char * , char * * );
2461
2462 extern int sprintf(char * , char * , ...);
2463
2464 struct __ecereNameSpace__ecere__com__DataMember * __ecereNameSpace__ecere__com__eClass_FindDataMember(struct __ecereNameSpace__ecere__com__Class * _class, char *  name, struct __ecereNameSpace__ecere__com__Instance * module, struct __ecereNameSpace__ecere__com__DataMember **  subMemberStack, int *  subMemberStackPos);
2465
2466 struct __ecereNameSpace__ecere__com__Method * __ecereNameSpace__ecere__com__eClass_FindMethod(struct __ecereNameSpace__ecere__com__Class * _class, char *  name, struct __ecereNameSpace__ecere__com__Instance * module);
2467
2468 struct __ecereNameSpace__ecere__com__Property * __ecereNameSpace__ecere__com__eClass_FindProperty(struct __ecereNameSpace__ecere__com__Class * _class, char *  name, struct __ecereNameSpace__ecere__com__Instance * module);
2469
2470 static void __ecereNameSpace__ecere__com__ComputeClassParameters(struct __ecereNameSpace__ecere__com__Class * templatedClass, char * templateParams, struct __ecereNameSpace__ecere__com__Instance * findModule)
2471 {
2472 char ch;
2473 char * nextParamStart = templateParams ? (templateParams + 1) : (((void *)0));
2474 struct __ecereNameSpace__ecere__com__ClassTemplateParameter * curParam = (((void *)0));
2475 struct __ecereNameSpace__ecere__com__Class * lastClass = (((void *)0)), * sClass;
2476 int curParamID = 0;
2477 int numParams = 0;
2478 struct __ecereNameSpace__ecere__com__Class * _class = templatedClass->templateClass ? templatedClass->templateClass : templatedClass;
2479
2480 for(sClass = _class; sClass; sClass = sClass->base)
2481 {
2482 if(sClass->templateClass)
2483 sClass = sClass->templateClass;
2484 numParams += sClass->templateParams.count;
2485 }
2486 if(templatedClass->templateArgs)
2487 __ecereNameSpace__ecere__com__FreeTemplateArgs(templatedClass);
2488 (__ecereNameSpace__ecere__com__eSystem_Delete(templatedClass->templateArgs), templatedClass->templateArgs = 0);
2489 templatedClass->templateArgs = __ecereNameSpace__ecere__com__eSystem_New0(sizeof(struct __ecereNameSpace__ecere__com__ClassTemplateArgument) * (numParams));
2490 templatedClass->numParams = numParams;
2491 if(_class != templatedClass)
2492 {
2493 }
2494 if(templatedClass->base && templatedClass->base->templateArgs && _class == templatedClass)
2495 {
2496 struct __ecereNameSpace__ecere__com__Class * sClass;
2497
2498 memcpy(templatedClass->templateArgs, templatedClass->base->templateArgs, sizeof(struct __ecereNameSpace__ecere__com__ClassTemplateArgument) * (numParams - templatedClass->templateParams.count));
2499 for(sClass = templatedClass->base; sClass; sClass = sClass->base)
2500 {
2501 struct __ecereNameSpace__ecere__com__ClassTemplateParameter * param;
2502 struct __ecereNameSpace__ecere__com__Class * prevClass;
2503 int id = 0;
2504
2505 for(prevClass = sClass->base; prevClass; prevClass = prevClass->base)
2506 {
2507 if(prevClass->templateClass)
2508 prevClass = prevClass->templateClass;
2509 id += prevClass->templateParams.count;
2510 }
2511 if(sClass->templateClass)
2512 sClass = sClass->templateClass;
2513 for(param = sClass->templateParams.first; param; param = param->next)
2514 __ecereNameSpace__ecere__com__CopyTemplateArg(param, &templatedClass->templateArgs[id++]);
2515 }
2516 }
2517 while(nextParamStart)
2518 {
2519 char * paramStart = nextParamStart;
2520 char * paramEnd;
2521 int level = 0;
2522
2523 while(*paramStart == ' ')
2524 paramStart++;
2525 paramEnd = paramStart;
2526 while((ch = *paramEnd, ch && (level > 0 || (ch != '>' && ch != ','))))
2527 {
2528 if(ch == '<')
2529 level++;
2530 if(ch == '>')
2531 level--;
2532 paramEnd++;
2533 }
2534 nextParamStart = (ch == ',') ? (paramEnd + 1) : (((void *)0));
2535 while(*paramEnd == ' ')
2536 paramEnd--;
2537 if(paramEnd > paramStart)
2538 {
2539 char * ptr, * equal = (((void *)0));
2540
2541 for(ptr = paramStart; ptr <= paramEnd; ptr++)
2542 {
2543 if(*ptr == '=')
2544 {
2545 equal = ptr;
2546 break;
2547 }
2548 }
2549 if(equal)
2550 {
2551 char * end = equal - 1;
2552 char ident[1024];
2553
2554 while(*end == ' ')
2555 end--;
2556 strncpy(ident, paramStart, end + 1 - paramStart);
2557 ident[end + 1 - paramStart] = (char)0;
2558 for(sClass = _class; sClass; sClass = sClass->base)
2559 {
2560 if(sClass->templateClass)
2561 sClass = sClass->templateClass;
2562 for(curParam = sClass->templateParams.first; curParam; curParam = curParam->next)
2563 {
2564 if(!strcmp(curParam->name, ident))
2565 break;
2566 }
2567 if(curParam)
2568 {
2569 struct __ecereNameSpace__ecere__com__Class * nextClass;
2570 struct __ecereNameSpace__ecere__com__ClassTemplateParameter * prevParam;
2571
2572 curParamID = 0;
2573 for(prevParam = curParam->prev; prevParam; prevParam = prevParam->prev)
2574 curParamID++;
2575 for(nextClass = sClass->base; nextClass; nextClass = nextClass->base)
2576 {
2577 if(nextClass->templateClass)
2578 nextClass = nextClass->templateClass;
2579 curParamID += nextClass->templateParams.count;
2580 }
2581 break;
2582 }
2583 }
2584 lastClass = sClass;
2585 }
2586 else
2587 {
2588 if(curParam)
2589 {
2590 curParam = curParam->next;
2591 curParamID++;
2592 }
2593 if(!curParam)
2594 {
2595 for(sClass = lastClass ? lastClass->base : _class; sClass; sClass = sClass->base)
2596 {
2597 struct __ecereNameSpace__ecere__com__ClassTemplateParameter * param;
2598
2599 curParamID = 0;
2600 if(sClass->templateClass)
2601 sClass = sClass->templateClass;
2602 for(param = sClass->templateParams.first; param; param = param->next, curParamID++)
2603 {
2604 curParam = param;
2605 break;
2606 }
2607 if(curParam)
2608 {
2609 struct __ecereNameSpace__ecere__com__Class * nextClass;
2610
2611 for(nextClass = sClass->base; nextClass; nextClass = nextClass->base)
2612 {
2613 if(nextClass->templateClass)
2614 nextClass = nextClass->templateClass;
2615 curParamID += nextClass->templateParams.count;
2616 }
2617 lastClass = sClass;
2618 break;
2619 }
2620 }
2621 }
2622 }
2623 if(curParam)
2624 {
2625 struct __ecereNameSpace__ecere__com__ClassTemplateArgument argument =
2626 {
2627 0, 0, 0, 0, 0
2628 };
2629 char value[1024];
2630
2631 if(equal)
2632 {
2633 equal++;
2634 while(*equal == ' ')
2635 equal++;
2636 memcpy(value, equal, paramEnd - equal);
2637 value[paramEnd - equal] = (char)0;
2638 }
2639 else
2640 {
2641 memcpy(value, paramStart, paramEnd - paramStart);
2642 value[paramEnd - paramStart] = (char)0;
2643 }
2644 __ecereNameSpace__ecere__sys__TrimRSpaces(value, value);
2645 switch(curParam->type)
2646 {
2647 case 0:
2648 argument.dataTypeString = __ecereNameSpace__ecere__sys__CopyString(value);
2649 argument.dataTypeClass = __ecereNameSpace__ecere__com__eSystem_FindClass(_class->module, value);
2650 if(!argument.dataTypeClass)
2651 argument.dataTypeClass = __ecereNameSpace__ecere__com__eSystem_FindClass(((struct __ecereNameSpace__ecere__com__Module *)(((char *)_class->module + structSize_Instance)))->application, value);
2652 if(!argument.dataTypeClass)
2653 argument.dataTypeClass = __ecereNameSpace__ecere__com__eSystem_FindClass(findModule, value);
2654 break;
2655 case 2:
2656 {
2657 struct __ecereNameSpace__ecere__com__Class * expClass = __ecereNameSpace__ecere__com__eSystem_FindClass(_class->module, curParam->dataTypeString);
2658
2659 if(!expClass)
2660 expClass = __ecereNameSpace__ecere__com__eSystem_FindClass(((struct __ecereNameSpace__ecere__com__Module *)(((char *)_class->module + structSize_Instance)))->application, curParam->dataTypeString);
2661 if(expClass)
2662 {
2663 ((unsigned int (*)(void *, void *, const char *))(void *)expClass->_vTbl[__ecereVMethodID_class_OnGetDataFromString])(expClass, &argument.expression, value);
2664 }
2665 else if(value[0] == '\"')
2666 {
2667 char * endQuote = value + strlen(value) - 1;
2668
2669 if(*endQuote != '\"')
2670 endQuote++;
2671 *endQuote = '\0';
2672 argument.expression.p = __ecereNameSpace__ecere__sys__CopyString(value + 1);
2673 }
2674 else if(value[0] == '\'')
2675 {
2676 int nb;
2677 unsigned int ch = __ecereNameSpace__ecere__sys__UTF8GetChar(value + 1, &nb);
2678
2679 argument.expression.ui = ch;
2680 }
2681 else if(!strcmp(curParam->dataTypeString, "uint"))
2682 {
2683 argument.expression.ui = strtoul(value, (((void *)0)), 0);
2684 }
2685 else if(!strcmp(curParam->dataTypeString, "char"))
2686 {
2687 argument.expression.c = (char)strtol(value, (((void *)0)), 0);
2688 }
2689 else if(!strcmp(curParam->dataTypeString, "byte"))
2690 {
2691 argument.expression.uc = (unsigned char)strtoul(value, (((void *)0)), 0);
2692 }
2693 else if(!strcmp(curParam->dataTypeString, "short"))
2694 {
2695 argument.expression.s = (short)strtol(value, (((void *)0)), 0);
2696 }
2697 else if(!strcmp(curParam->dataTypeString, "uint16"))
2698 {
2699 argument.expression.us = (unsigned short)strtoul(value, (((void *)0)), 0);
2700 }
2701 else if(!strcmp(curParam->dataTypeString, "int64"))
2702 {
2703 argument.expression.i64 = __ecereNameSpace__ecere__com___strtoi64(value, (((void *)0)), 0);
2704 }
2705 else if(!strcmp(curParam->dataTypeString, "uint64"))
2706 {
2707 argument.expression.ui64 = __ecereNameSpace__ecere__com___strtoui64(value, (((void *)0)), 0);
2708 }
2709 else if(!strcmp(curParam->dataTypeString, "float"))
2710 {
2711 argument.expression.f = (float)strtod(value, (((void *)0)));
2712 }
2713 else if(!strcmp(curParam->dataTypeString, "double"))
2714 {
2715 argument.expression.d = strtod(value, (((void *)0)));
2716 }
2717 else
2718 {
2719 argument.expression.i = strtol(value, (((void *)0)), 0);
2720 }
2721 break;
2722 }
2723 case 1:
2724 argument.memberString = __ecereNameSpace__ecere__sys__CopyString(value);
2725 break;
2726 }
2727 __ecereNameSpace__ecere__com__FreeTemplateArg(templatedClass, curParam, curParamID);
2728 templatedClass->templateArgs[curParamID] = argument;
2729 }
2730 }
2731 }
2732 if(templatedClass == _class)
2733 {
2734 struct __ecereNameSpace__ecere__com__Class * sClass = _class;
2735 int curParamID = 0;
2736 struct __ecereNameSpace__ecere__com__Class * nextClass;
2737 struct __ecereNameSpace__ecere__com__ClassTemplateParameter * param;
2738
2739 for(nextClass = sClass->base; nextClass; nextClass = nextClass->base)
2740 {
2741 if(nextClass->templateClass)
2742 nextClass = nextClass->templateClass;
2743 curParamID += nextClass->templateParams.count;
2744 }
2745 for(param = sClass->templateParams.first; param; param = param->next)
2746 {
2747 if(!templatedClass->templateArgs[curParamID].dataTypeString)
2748 {
2749 templatedClass->templateArgs[curParamID] = param->defaultArg;
2750 __ecereNameSpace__ecere__com__CopyTemplateArg(param, &templatedClass->templateArgs[curParamID]);
2751 if(param->type == 0 && param->defaultArg.dataTypeString)
2752 {
2753 templatedClass->templateArgs[curParamID].dataTypeClass = __ecereNameSpace__ecere__com__eSystem_FindClass(templatedClass->module, param->defaultArg.dataTypeString);
2754 if(!templatedClass->templateArgs[curParamID].dataTypeClass)
2755 templatedClass->templateArgs[curParamID].dataTypeClass = __ecereNameSpace__ecere__com__eSystem_FindClass(((struct __ecereNameSpace__ecere__com__Module *)(((char *)templatedClass->module + structSize_Instance)))->application, param->defaultArg.dataTypeString);
2756 if(!templatedClass->templateArgs[curParamID].dataTypeClass)
2757 templatedClass->templateArgs[curParamID].dataTypeClass = __ecereNameSpace__ecere__com__eSystem_FindClass(findModule, param->defaultArg.dataTypeString);
2758 }
2759 }
2760 curParamID++;
2761 }
2762 }
2763 if(templatedClass->base && templatedClass->base->templateArgs && numParams - _class->templateParams.count)
2764 {
2765 int c = numParams - _class->templateParams.count - 1;
2766
2767 for(sClass = _class->base; sClass; sClass = sClass->base)
2768 {
2769 struct __ecereNameSpace__ecere__com__ClassTemplateParameter * param;
2770
2771 if(sClass->templateClass)
2772 sClass = sClass->templateClass;
2773 for(param = sClass->templateParams.last; param; param = param->prev)
2774 {
2775 struct __ecereNameSpace__ecere__com__ClassTemplateArgument * arg = &templatedClass->templateArgs[c];
2776 struct __ecereNameSpace__ecere__com__ClassTemplateArgument * baseArg = &templatedClass->base->templateArgs[c];
2777
2778 if(!(*arg).dataTypeString)
2779 {
2780 *arg = templatedClass->base->templateArgs[c];
2781 __ecereNameSpace__ecere__com__CopyTemplateArg(param, arg);
2782 if(param->type == 0)
2783 {
2784 if((*arg).dataTypeClass && strchr((*arg).dataTypeString, '<') && (*arg).dataTypeClass->templateArgs)
2785 {
2786 struct __ecereNameSpace__ecere__com__Class * expClass = (*arg).dataTypeClass;
2787 struct __ecereNameSpace__ecere__com__Class * cClass = (((void *)0));
2788 int paramCount = 0;
2789 int lastParam = -1;
2790 char templateString[1024];
2791
2792 sprintf(templateString, "%s<", expClass->templateClass->fullName);
2793 for(cClass = expClass; cClass; cClass = cClass->base)
2794 {
2795 int p = 0;
2796 struct __ecereNameSpace__ecere__com__ClassTemplateParameter * param;
2797
2798 for(param = cClass->templateParams.first; param; param = param->next)
2799 {
2800 int id = p;
2801 struct __ecereNameSpace__ecere__com__Class * sClass;
2802 struct __ecereNameSpace__ecere__com__ClassTemplateArgument arg;
2803
2804 for(sClass = expClass->base; sClass; sClass = sClass->base)
2805 id += sClass->templateParams.count;
2806 arg = expClass->templateArgs[id];
2807 {
2808 struct __ecereNameSpace__ecere__com__ClassTemplateParameter * cParam;
2809 int p = numParams - _class->templateParams.count;
2810
2811 for(cParam = _class->templateParams.first; cParam; cParam = cParam->next, p++)
2812 {
2813 if(cParam->type == 0 && arg.dataTypeString && !strcmp(cParam->name, arg.dataTypeString))
2814 {
2815 arg.dataTypeString = templatedClass->templateArgs[p].dataTypeString;
2816 arg.dataTypeClass = templatedClass->templateArgs[p].dataTypeClass;
2817 break;
2818 }
2819 }
2820 }
2821 {
2822 char argument[256];
2823
2824 argument[0] = '\0';
2825 switch(param->type)
2826 {
2827 case 2:
2828 {
2829 break;
2830 }
2831 case 1:
2832 {
2833 strcat(argument, arg.member->name);
2834 break;
2835 }
2836 case 0:
2837 {
2838 if(arg.dataTypeString)
2839 strcat(argument, arg.dataTypeString);
2840 break;
2841 }
2842 }
2843 if(argument[0])
2844 {
2845 if(paramCount)
2846 strcat(templateString, ", ");
2847 if(lastParam != p - 1)
2848 {
2849 strcat(templateString, param->name);
2850 strcat(templateString, " = ");
2851 }
2852 strcat(templateString, argument);
2853 paramCount++;
2854 lastParam = p;
2855 }
2856 }
2857 p++;
2858 }
2859 }
2860 {
2861 int len = strlen(templateString);
2862
2863 if(templateString[len - 1] == '>')
2864 templateString[len++] = ' ';
2865 templateString[len++] = '>';
2866 templateString[len++] = '\0';
2867 }
2868 __ecereNameSpace__ecere__com__FreeTemplateArg(templatedClass, param, c);
2869 (*arg).dataTypeString = __ecereNameSpace__ecere__sys__CopyString(templateString);
2870 (*arg).dataTypeClass = __ecereNameSpace__ecere__com__eSystem_FindClass(templatedClass->module, templateString);
2871 if(!(*arg).dataTypeClass)
2872 (*arg).dataTypeClass = __ecereNameSpace__ecere__com__eSystem_FindClass(((struct __ecereNameSpace__ecere__com__Module *)(((char *)templatedClass->module + structSize_Instance)))->application, templateString);
2873 }
2874 else
2875 {
2876 struct __ecereNameSpace__ecere__com__ClassTemplateParameter * cParam;
2877 int p = numParams - _class->templateParams.count;
2878
2879 for(cParam = _class->templateParams.first; cParam; cParam = cParam->next, p++)
2880 {
2881 if(cParam->type == 0 && (*baseArg).dataTypeString && !strcmp(cParam->name, (*baseArg).dataTypeString))
2882 {
2883 __ecereNameSpace__ecere__com__FreeTemplateArg(templatedClass, param, c);
2884 (*arg).dataTypeString = templatedClass->templateArgs[p].dataTypeString;
2885 (*arg).dataTypeClass = templatedClass->templateArgs[p].dataTypeClass;
2886 __ecereNameSpace__ecere__com__CopyTemplateArg(cParam, arg);
2887 break;
2888 }
2889 }
2890 }
2891 }
2892 }
2893 c--;
2894 }
2895 }
2896 }
2897 {
2898 struct __ecereNameSpace__ecere__com__Class * sClass;
2899
2900 for(sClass = _class; sClass; sClass = sClass->base)
2901 {
2902 int curParamID = 0;
2903 struct __ecereNameSpace__ecere__com__Class * nextClass;
2904 struct __ecereNameSpace__ecere__com__ClassTemplateParameter * param;
2905
2906 if(sClass->templateClass)
2907 sClass = sClass->templateClass;
2908 for(nextClass = sClass->base; nextClass; nextClass = nextClass->base)
2909 {
2910 if(nextClass->templateClass)
2911 nextClass = nextClass->templateClass;
2912 curParamID += nextClass->templateParams.count;
2913 }
2914 for(param = sClass->templateParams.first; param; param = param->next)
2915 {
2916 if(!templatedClass->templateArgs[curParamID].dataTypeString)
2917 {
2918 templatedClass->templateArgs[curParamID] = param->defaultArg;
2919 __ecereNameSpace__ecere__com__CopyTemplateArg(param, &templatedClass->templateArgs[curParamID]);
2920 if(param->type == 0 && param->defaultArg.dataTypeString)
2921 {
2922 templatedClass->templateArgs[curParamID].dataTypeClass = __ecereNameSpace__ecere__com__eSystem_FindClass(templatedClass->module, param->defaultArg.dataTypeString);
2923 if(!templatedClass->templateArgs[curParamID].dataTypeClass)
2924 templatedClass->templateArgs[curParamID].dataTypeClass = __ecereNameSpace__ecere__com__eSystem_FindClass(((struct __ecereNameSpace__ecere__com__Module *)(((char *)templatedClass->module + structSize_Instance)))->application, param->defaultArg.dataTypeString);
2925 if(!templatedClass->templateArgs[curParamID].dataTypeClass)
2926 templatedClass->templateArgs[curParamID].dataTypeClass = __ecereNameSpace__ecere__com__eSystem_FindClass(findModule, param->defaultArg.dataTypeString);
2927 }
2928 }
2929 curParamID++;
2930 }
2931 }
2932 }
2933 {
2934 int c = numParams - 1;
2935
2936 for(sClass = _class; sClass; sClass = sClass->base)
2937 {
2938 struct __ecereNameSpace__ecere__com__ClassTemplateParameter * param;
2939
2940 if(sClass->templateClass)
2941 sClass = sClass->templateClass;
2942 for(param = sClass->templateParams.last; param; param = param->prev)
2943 {
2944 if(param->type == 0)
2945 {
2946 struct __ecereNameSpace__ecere__com__ClassTemplateArgument * arg = &templatedClass->templateArgs[c];
2947 struct __ecereNameSpace__ecere__com__ClassTemplateParameter * cParam;
2948 struct __ecereNameSpace__ecere__com__Class * dClass;
2949 int p = numParams - 1;
2950
2951 for(dClass = _class; dClass; dClass = dClass->base)
2952 {
2953 if(dClass->templateClass)
2954 dClass = dClass->templateClass;
2955 for(cParam = dClass->templateParams.last; cParam; cParam = cParam->prev, p--)
2956 {
2957 if(cParam->type == 0 && (*arg).dataTypeString && !strcmp(cParam->name, (*arg).dataTypeString))
2958 {
2959 if(templatedClass->templateArgs[p].dataTypeString && c != p)
2960 {
2961 __ecereNameSpace__ecere__com__FreeTemplateArg(templatedClass, param, c);
2962 (*arg).dataTypeString = templatedClass->templateArgs[p].dataTypeString;
2963 (*arg).dataTypeClass = templatedClass->templateArgs[p].dataTypeClass;
2964 __ecereNameSpace__ecere__com__CopyTemplateArg(cParam, arg);
2965 }
2966 }
2967 }
2968 }
2969 }
2970 c--;
2971 }
2972 }
2973 }
2974 {
2975 struct __ecereNameSpace__ecere__com__Class * tClass;
2976 int c = numParams - 1;
2977
2978 for(tClass = _class; tClass; tClass = tClass->base)
2979 {
2980 struct __ecereNameSpace__ecere__com__ClassTemplateParameter * param;
2981
2982 if(tClass->templateClass)
2983 tClass = tClass->templateClass;
2984 for(param = tClass->templateParams.last; param; param = param->prev)
2985 {
2986 struct __ecereNameSpace__ecere__com__ClassTemplateArgument * arg = &templatedClass->templateArgs[c];
2987
2988 if(param->type == 1 && (*arg).memberString)
2989 {
2990 struct __ecereNameSpace__ecere__com__Class * memberClass = templatedClass;
2991 char * memberString = (*arg).memberString;
2992 char * colon = strstr(memberString, "::");
2993 char * memberName = memberString;
2994
2995 if(colon)
2996 memberName = colon + 2;
2997 if(!colon)
2998 {
2999 memberString = param->defaultArg.memberString;
3000 colon = memberString ? strstr(memberString, "::") : (((void *)0));
3001 }
3002 if(colon)
3003 {
3004 char className[1024];
3005 struct __ecereNameSpace__ecere__com__Class * sClass;
3006
3007 memcpy(className, memberString, colon - memberString);
3008 className[colon - memberString] = '\0';
3009 for(sClass = _class; sClass; sClass = sClass->base)
3010 {
3011 struct __ecereNameSpace__ecere__com__ClassTemplateParameter * cParam;
3012 struct __ecereNameSpace__ecere__com__Class * nextClass;
3013 int id = 0;
3014
3015 if(sClass->templateClass)
3016 sClass = sClass->templateClass;
3017 for(nextClass = sClass->base; nextClass; nextClass = nextClass->base)
3018 {
3019 if(nextClass->templateClass)
3020 nextClass = nextClass->templateClass;
3021 id += nextClass->templateParams.count;
3022 }
3023 for(cParam = sClass->templateParams.first; cParam; cParam = cParam->next)
3024 {
3025 if(cParam->type == 0 && !strcmp(cParam->name, className) && templatedClass->templateArgs[id].dataTypeString)
3026 {
3027 strcpy(className, templatedClass->templateArgs[id].dataTypeString);
3028 }
3029 id++;
3030 }
3031 }
3032 memberClass = __ecereNameSpace__ecere__com__eSystem_FindClass(templatedClass->module, className);
3033 if(!memberClass)
3034 memberClass = __ecereNameSpace__ecere__com__eSystem_FindClass(findModule, className);
3035 if(!memberClass)
3036 memberClass = __ecereNameSpace__ecere__com__eSystem_FindClass(((struct __ecereNameSpace__ecere__com__Module *)(((char *)templatedClass->module + structSize_Instance)))->application, className);
3037 }
3038 if(memberClass)
3039 {
3040 switch(param->memberType)
3041 {
3042 case 0:
3043 (*arg).member = __ecereNameSpace__ecere__com__eClass_FindDataMember(memberClass, memberName, memberClass->module, (((void *)0)), (((void *)0)));
3044 break;
3045 case 1:
3046 (*arg).method = __ecereNameSpace__ecere__com__eClass_FindMethod(memberClass, memberName, memberClass->module);
3047 break;
3048 case 2:
3049 (*arg).prop = __ecereNameSpace__ecere__com__eClass_FindProperty(memberClass, memberName, memberClass->module);
3050 break;
3051 }
3052 }
3053 }
3054 c--;
3055 }
3056 }
3057 }
3058 }
3059
3060 unsigned int __ecereNameSpace__ecere__com__DefaultFunction()
3061 {
3062 return 0x1;
3063 }
3064
3065 unsigned int __ecereNameSpace__ecere__com__eClass_IsDerived(struct __ecereNameSpace__ecere__com__Class * _class, struct __ecereNameSpace__ecere__com__Class * from)
3066 {
3067 if(!_class && !from)
3068 return 0x1;
3069 if(_class && from && (_class->templateClass || from->templateClass))
3070 {
3071 if(__ecereNameSpace__ecere__com__eClass_IsDerived(_class->templateClass ? _class->templateClass : _class, from->templateClass ? from->templateClass : from))
3072 {
3073 if(!from->templateClass)
3074 return 0x1;
3075 else if(!_class->templateClass && _class == from->templateClass)
3076 return 0x0;
3077 else
3078 {
3079 struct __ecereNameSpace__ecere__com__Class * sClass;
3080
3081 for(sClass = from; sClass; sClass = sClass->base)
3082 {
3083 if(sClass->templateParams.first)
3084 {
3085 struct __ecereNameSpace__ecere__com__ClassTemplateParameter * param;
3086 struct __ecereNameSpace__ecere__com__Class * nextClass;
3087 int p = 0;
3088
3089 for(nextClass = sClass->base; nextClass; nextClass = nextClass->base)
3090 p += nextClass->templateParams.count;
3091 for(param = sClass->templateParams.first; param; param = param->next, p++)
3092 {
3093 struct __ecereNameSpace__ecere__com__ClassTemplateArgument * arg = &_class->templateArgs[p];
3094 struct __ecereNameSpace__ecere__com__ClassTemplateArgument * fArg = &from->templateArgs[p];
3095
3096 if(param->type == 0)
3097 {
3098 if((*arg).dataTypeString != (*fArg).dataTypeString && (*arg).dataTypeString && (*fArg).dataTypeString && strcmp((*arg).dataTypeString, (*fArg).dataTypeString))
3099 break;
3100 }
3101 else if(param->type == 1)
3102 {
3103 if((*arg).member != (*fArg).member)
3104 break;
3105 }
3106 else if(param->type == 2)
3107 {
3108 if((*arg).expression.ui64 != (*fArg).expression.ui64)
3109 break;
3110 }
3111 }
3112 if(param)
3113 return 0x0;
3114 }
3115 }
3116 return 0x1;
3117 }
3118 }
3119 }
3120 else
3121 {
3122 for(; _class && from; _class = _class->base)
3123 {
3124 if(_class == from || _class->templateClass == from || (_class->type == 1000 && from->name && !strcmp(_class->name, from->name)))
3125 return 0x1;
3126 }
3127 }
3128 return 0x0;
3129 }
3130
3131 static void __ecereNameSpace__ecere__com__FixDerivativeVirtualMethod(struct __ecereNameSpace__ecere__com__Class * base, char * name, int vid, void * origFunction, char * type)
3132 {
3133 struct __ecereNameSpace__ecere__sys__OldLink * derivative;
3134
3135 for(derivative = base->derivatives.first; derivative; derivative = derivative->next)
3136 {
3137 struct __ecereNameSpace__ecere__com__Class * _class = derivative->data;
3138 struct __ecereNameSpace__ecere__com__Method * method, * next;
3139 void * function = origFunction;
3140
3141 _class->vTblSize++;
3142 _class->_vTbl = __ecereNameSpace__ecere__com__eSystem_Renew(_class->_vTbl, sizeof(void *) * (_class->vTblSize));
3143 memmove(_class->_vTbl + vid + 1, _class->_vTbl + vid, (_class->vTblSize - vid - 1) * sizeof(void *));
3144 method = (struct __ecereNameSpace__ecere__com__Method *)__ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_FindString(&_class->methods, name);
3145 if(method)
3146 {
3147 if(method->function)
3148 function = method->function;
3149 if(!method->symbol)
3150 {
3151 (__ecereNameSpace__ecere__com__eSystem_Delete(method->name), method->name = 0);
3152 (__ecereNameSpace__ecere__com__eSystem_Delete(method->dataTypeString), method->dataTypeString = 0);
3153 __ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_Delete(&_class->methods, (struct __ecereNameSpace__ecere__sys__BTNode *)method);
3154 }
3155 else
3156 {
3157 (__ecereNameSpace__ecere__com__eSystem_Delete(method->dataTypeString), method->dataTypeString = 0);
3158 method->type = 1;
3159 method->dataTypeString = __ecereNameSpace__ecere__sys__CopyString(type);
3160 method->_class = base;
3161 }
3162 }
3163 for(method = (struct __ecereNameSpace__ecere__com__Method *)__ecereProp___ecereNameSpace__ecere__sys__BinaryTree_Get_first(&_class->methods); method; method = next)
3164 {
3165 next = (struct __ecereNameSpace__ecere__com__Method *)__ecereProp___ecereNameSpace__ecere__sys__BTNode_Get_next(((struct __ecereNameSpace__ecere__sys__BTNode *)method));
3166 if(method->type == 1)
3167 method->vid++;
3168 }
3169 _class->_vTbl[vid] = function;
3170 {
3171 struct __ecereNameSpace__ecere__sys__OldLink * templateLink;
3172
3173 for(templateLink = _class->templatized.first; templateLink; templateLink = templateLink->next)
3174 {
3175 struct __ecereNameSpace__ecere__com__Class * template = templateLink->data;
3176
3177 template->_vTbl = _class->_vTbl;
3178 }
3179 }
3180 if(_class->derivatives.first || _class->templatized.first)
3181 __ecereNameSpace__ecere__com__FixDerivativeVirtualMethod(_class, name, vid, function, type);
3182 }
3183 {
3184 struct __ecereNameSpace__ecere__sys__OldLink * templateLink;
3185
3186 for(templateLink = base->templatized.first; templateLink; templateLink = templateLink->next)
3187 {
3188 struct __ecereNameSpace__ecere__com__Class * template = templateLink->data;
3189
3190 template->_vTbl = base->_vTbl;
3191 __ecereNameSpace__ecere__com__FixDerivativeVirtualMethod(template, name, vid, origFunction, type);
3192 }
3193 }
3194 }
3195
3196 struct __ecereNameSpace__ecere__com__Method * __ecereNameSpace__ecere__com__eClass_AddMethod(struct __ecereNameSpace__ecere__com__Class * _class, char * name, char * type, void * function, int declMode)
3197 {
3198 if(_class && name)
3199 {
3200 struct __ecereNameSpace__ecere__com__Class * base;
3201
3202 for(base = _class; base; base = base->base)
3203 {
3204 struct __ecereNameSpace__ecere__com__Method * method = (struct __ecereNameSpace__ecere__com__Method *)__ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_FindString(&base->methods, name);
3205
3206 if(method)
3207 {
3208 if(method->type == 1)
3209 {
3210 struct __ecereNameSpace__ecere__sys__OldLink * deriv;
3211 void * oldFunction = _class->_vTbl[method->vid];
3212
3213 if(method->vid >= _class->vTblSize)
3214 printf("error: virtual methods overriding failure\n");
3215 else
3216 _class->_vTbl[method->vid] = function ? function : __ecereNameSpace__ecere__com__DefaultFunction;
3217 for(deriv = _class->derivatives.first; deriv; deriv = deriv->next)
3218 {
3219 struct __ecereNameSpace__ecere__com__Class * derivClass = deriv->data;
3220
3221 if(derivClass->_vTbl[method->vid] == oldFunction)
3222 __ecereNameSpace__ecere__com__eClass_AddMethod(derivClass, name, type, function, declMode);
3223 }
3224 {
3225 struct __ecereNameSpace__ecere__sys__OldLink * templateLink;
3226
3227 for(templateLink = _class->templatized.first; templateLink; templateLink = templateLink->next)
3228 {
3229 struct __ecereNameSpace__ecere__com__Class * template = templateLink->data;
3230
3231 for(deriv = template->derivatives.first; deriv; deriv = deriv->next)
3232 {
3233 struct __ecereNameSpace__ecere__com__Class * derivClass = deriv->data;
3234
3235 if(derivClass->_vTbl[method->vid] == oldFunction)
3236 __ecereNameSpace__ecere__com__eClass_AddMethod(derivClass, name, type, function, declMode);
3237 }
3238 }
3239 }
3240 }
3241 else
3242 {
3243 if(base == _class)
3244 {
3245 break;
3246 }
3247 base = (((void *)0));
3248 break;
3249 }
3250 return method;
3251 }
3252 }
3253 if(!base)
3254 {
3255 struct __ecereNameSpace__ecere__com__Method * method = (method = __ecereNameSpace__ecere__com__eSystem_New0(structSize_Method), method->name = __ecereNameSpace__ecere__sys__CopyString(name), method->function = function ? function : __ecereNameSpace__ecere__com__DefaultFunction, method->_class = _class, method->dataTypeString = __ecereNameSpace__ecere__sys__CopyString(type), method->memberAccess = declMode, method);
3256
3257 __ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_Add(&_class->methods, (struct __ecereNameSpace__ecere__sys__BTNode *)method);
3258 return method;
3259 }
3260 }
3261 return (((void *)0));
3262 }
3263
3264 struct __ecereNameSpace__ecere__com__Method * __ecereNameSpace__ecere__com__eClass_AddVirtualMethod(struct __ecereNameSpace__ecere__com__Class * _class, char * name, char * type, void * function, int declMode)
3265 {
3266 if(_class && name)
3267 {
3268 struct __ecereNameSpace__ecere__com__Class * base;
3269
3270 for(base = _class; base; base = base->base)
3271 {
3272 struct __ecereNameSpace__ecere__com__Method * method = (struct __ecereNameSpace__ecere__com__Method *)__ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_FindString(&base->methods, name);
3273
3274 if(method)
3275 {
3276 if(method->type == 1)
3277 {
3278 if(method->vid >= _class->vTblSize)
3279 printf("error: virtual methods overriding failure\n");
3280 else
3281 _class->_vTbl[method->vid] = function ? function : __ecereNameSpace__ecere__com__DefaultFunction;
3282 }
3283 else
3284 base = (((void *)0));
3285 return method;
3286 }
3287 }
3288 if(!base)
3289 {
3290 struct __ecereNameSpace__ecere__com__Method * method = (method = __ecereNameSpace__ecere__com__eSystem_New0(structSize_Method), method->name = __ecereNameSpace__ecere__sys__CopyString(name), method->function = function ? function : __ecereNameSpace__ecere__com__DefaultFunction, method->type = 1, method->_class = _class, method->vid = _class->vTblSize++, method->dataTypeString = __ecereNameSpace__ecere__sys__CopyString(type), method->memberAccess = declMode, method);
3291
3292 __ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_Add(&_class->methods, (struct __ecereNameSpace__ecere__sys__BTNode *)method);
3293 _class->_vTbl = __ecereNameSpace__ecere__com__eSystem_Renew(_class->_vTbl, sizeof(void *) * (_class->vTblSize));
3294 _class->_vTbl[method->vid] = function ? function : __ecereNameSpace__ecere__com__DefaultFunction;
3295 if(_class->derivatives.first || _class->templatized.first)
3296 __ecereNameSpace__ecere__com__FixDerivativeVirtualMethod(_class, name, method->vid, function ? function : (void *)__ecereNameSpace__ecere__com__DefaultFunction, type);
3297 return method;
3298 }
3299 }
3300 return (((void *)0));
3301 }
3302
3303 static void __ecereNameSpace__ecere__com__FixDerivativeProperty(struct __ecereNameSpace__ecere__com__Class * base, struct __ecereNameSpace__ecere__com__Property * _property)
3304 {
3305 struct __ecereNameSpace__ecere__sys__OldLink * derivative;
3306
3307 for(derivative = base->derivatives.first; derivative; derivative = derivative->next)
3308 {
3309 struct __ecereNameSpace__ecere__com__Class * _class = derivative->data;
3310 struct __ecereNameSpace__ecere__com__Property * prop;
3311 struct __ecereNameSpace__ecere__com__BTNamedLink * link;
3312
3313 link = (struct __ecereNameSpace__ecere__com__BTNamedLink *)__ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_FindString(&_class->prop, _property->name);
3314 if(link)
3315 {
3316 prop = link->data;
3317 if(!prop->Set && !prop->Get && prop->memberAccess == 4)
3318 {
3319 struct __ecereNameSpace__ecere__com__SelfWatcher * watcher;
3320
3321 for(watcher = _class->selfWatchers.first; watcher; watcher = watcher->next)
3322 {
3323 if(watcher->_property == prop)
3324 watcher->_property = _property;
3325 }
3326 _property->selfWatchable = 0x1;
3327 (__ecereNameSpace__ecere__com__eSystem_Delete(prop->name), prop->name = 0);
3328 (__ecereNameSpace__ecere__com__eSystem_Delete(prop->dataTypeString), prop->dataTypeString = 0);
3329 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Delete(&_class->membersAndProperties, prop);
3330 __ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_Delete(&_class->prop, (struct __ecereNameSpace__ecere__sys__BTNode *)link);
3331 }
3332 }
3333 for(prop = _class->membersAndProperties.first; prop; prop = prop->next)
3334 prop->id++;
3335 _class->memberID++;
3336 _class->startMemberID++;
3337 __ecereNameSpace__ecere__com__FixDerivativeProperty(_class, _property);
3338 }
3339 }
3340
3341 struct __ecereNameSpace__ecere__com__Property * __ecereNameSpace__ecere__com__eClass_AddProperty(struct __ecereNameSpace__ecere__com__Class * _class, char * name, char * dataType, void * setStmt, void * getStmt, int declMode)
3342 {
3343 struct __ecereNameSpace__ecere__com__Property * _property = (((void *)0));
3344
3345 if(_class)
3346 {
3347 if(!__ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_FindString(&_class->prop, (name ? name : dataType)))
3348 {
3349 _property = __extension__ ({
3350 struct __ecereNameSpace__ecere__com__Property * __ecereInstance1 = __ecereNameSpace__ecere__com__eSystem_New0(structSize_Property);
3351
3352 __ecereInstance1->isProperty = 0x1, __ecereInstance1->name = __ecereNameSpace__ecere__sys__CopyString(name ? name : dataType), __ecereInstance1->id = (name && (setStmt || getStmt || dataType)) ? _class->memberID++ : 0, __ecereInstance1->Set = setStmt, __ecereInstance1->Get = getStmt, __ecereInstance1->dataTypeString = __ecereNameSpace__ecere__sys__CopyString(dataType), __ecereInstance1->_class = _class, __ecereInstance1->compiled = 0x1, __ecereInstance1->conversion = name ? 0x0 : 0x1, __ecereInstance1->memberAccess = declMode, __ecereInstance1;
3353 });
3354 if(name)
3355 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Add(&_class->membersAndProperties, _property);
3356 else
3357 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Add(&_class->conversions, _property);
3358 __ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_Add(&_class->prop, (struct __ecereNameSpace__ecere__sys__BTNode *)__extension__ ({
3359 struct __ecereNameSpace__ecere__com__BTNamedLink * __ecereInstance1 = __ecereNameSpace__ecere__com__eSystem_New0(structSize_BTNamedLink);
3360
3361 __ecereInstance1->name = _property->name, __ecereInstance1->data = _property, __ecereInstance1;
3362 }));
3363 if(!_property->conversion)
3364 {
3365 __ecereNameSpace__ecere__com__FixDerivativeProperty(_class, _property);
3366 }
3367 }
3368 }
3369 return _property;
3370 }
3371
3372 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass___ecereNameSpace__ecere__sys__NamedLink64;
3373
3374 struct __ecereNameSpace__ecere__sys__NamedLink64
3375 {
3376 struct __ecereNameSpace__ecere__sys__NamedLink64 * prev;
3377 struct __ecereNameSpace__ecere__sys__NamedLink64 * next;
3378 char *  name;
3379 long long data;
3380 } __attribute__ ((gcc_struct));
3381
3382 static void __ecereNameSpace__ecere__com__SetDelayedCPValues(struct __ecereNameSpace__ecere__com__Class * _class, struct __ecereNameSpace__ecere__com__ClassProperty * _property)
3383 {
3384 struct __ecereNameSpace__ecere__sys__OldLink * deriv;
3385 struct __ecereNameSpace__ecere__sys__NamedLink64 * value, * next;
3386
3387 for(value = _class->delayedCPValues.first; value; value = next)
3388 {
3389 next = value->next;
3390 if(!strcmp(value->name, _property->name))
3391 {
3392 _property->Set(_class, value->data);
3393 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Delete(&_class->delayedCPValues, value);
3394 }
3395 }
3396 for(deriv = _class->derivatives.first; deriv; deriv = deriv->next)
3397 {
3398 __ecereNameSpace__ecere__com__SetDelayedCPValues(deriv->data, _property);
3399 }
3400 }
3401
3402 struct __ecereNameSpace__ecere__com__ClassProperty * __ecereNameSpace__ecere__com__eClass_AddClassProperty(struct __ecereNameSpace__ecere__com__Class * _class, char * name, char * dataType, void * setStmt, void * getStmt)
3403 {
3404 if(name && !__ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_FindString(&_class->classProperties, name))
3405 {
3406 struct __ecereNameSpace__ecere__com__ClassProperty * _property = (_property = __ecereNameSpace__ecere__com__eSystem_New0(structSize_ClassProperty), _property->name = __ecereNameSpace__ecere__sys__CopyString(name), _property->Set = setStmt, _property->Get = getStmt, _property->dataTypeString = __ecereNameSpace__ecere__sys__CopyString(dataType), _property);
3407
3408 __ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_Add(&_class->classProperties, (struct __ecereNameSpace__ecere__sys__BTNode *)_property);
3409 __ecereNameSpace__ecere__com__SetDelayedCPValues(_class, _property);
3410 return _property;
3411 }
3412 return (((void *)0));
3413 }
3414
3415 struct __ecereNameSpace__ecere__com__ClassProperty * __ecereNameSpace__ecere__com__eClass_FindClassProperty(struct __ecereNameSpace__ecere__com__Class * _class, char * name)
3416 {
3417 struct __ecereNameSpace__ecere__com__ClassProperty * _property = (((void *)0));
3418
3419 if(name && _class)
3420 {
3421 struct __ecereNameSpace__ecere__com__Class * origClass = _class;
3422
3423 for(; _class; _class = _class->base)
3424 {
3425 _property = (struct __ecereNameSpace__ecere__com__ClassProperty *)__ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_FindString(&_class->classProperties, name);
3426 if(_property)
3427 break;
3428 }
3429 if(!_property && origClass->type == 4)
3430 {
3431 struct __ecereNameSpace__ecere__com__Class * enumClass = __ecereNameSpace__ecere__com__eSystem_FindClass(origClass->module, "enum");
3432
3433 _property = __ecereNameSpace__ecere__com__eClass_FindClassProperty(enumClass, name);
3434 }
3435 }
3436 return _property;
3437 }
3438
3439 long long __ecereNameSpace__ecere__com__eClass_GetProperty(struct __ecereNameSpace__ecere__com__Class * _class, char * name)
3440 {
3441 struct __ecereNameSpace__ecere__com__ClassProperty * _property = __ecereNameSpace__ecere__com__eClass_FindClassProperty(_class, name);
3442
3443 if(_property && _property->Get && _property->Get != (void *)1)
3444 {
3445 long long result = _property->Get(_class);
3446
3447 return result;
3448 }
3449 return 0;
3450 }
3451
3452 void __ecereNameSpace__ecere__com__eClass_SetProperty(struct __ecereNameSpace__ecere__com__Class * _class, char * name, long long value)
3453 {
3454 struct __ecereNameSpace__ecere__com__ClassProperty * _property = __ecereNameSpace__ecere__com__eClass_FindClassProperty(_class, name);
3455
3456 if(_property)
3457 {
3458 if(_property->Set)
3459 ((void (*)(void *, long long))_property->Set)(_class, value);
3460 }
3461 else
3462 {
3463 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Add(&_class->delayedCPValues, __extension__ ({
3464 struct __ecereNameSpace__ecere__sys__NamedLink64 * __ecereInstance1 = __ecereNameSpace__ecere__com__eSystem_New0(structSize_NamedLink64);
3465
3466 __ecereInstance1->name = name, __ecereInstance1->data = value, __ecereInstance1;
3467 }));
3468 }
3469 }
3470
3471 struct __ecereNameSpace__ecere__com__Method * __ecereNameSpace__ecere__com__eClass_FindMethod(struct __ecereNameSpace__ecere__com__Class * _class, char * name, struct __ecereNameSpace__ecere__com__Instance * module)
3472 {
3473 if(_class && name)
3474 {
3475 for(; _class; _class = _class->base)
3476 {
3477 struct __ecereNameSpace__ecere__com__Method * method;
3478
3479 if(_class->templateClass)
3480 _class = _class->templateClass;
3481 method = (struct __ecereNameSpace__ecere__com__Method *)__ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_FindString(&_class->methods, name);
3482 if(method && (method->memberAccess == 1 || _class->module == module || !method->dataTypeString))
3483 {
3484 if(!method->dataTypeString)
3485 {
3486 if(_class->module != module)
3487 {
3488 if(method->memberAccess == 1)
3489 module = _class->module;
3490 else
3491 {
3492 return (((void *)0));
3493 }
3494 }
3495 }
3496 else
3497 {
3498 return method;
3499 }
3500 }
3501 if(_class->inheritanceAccess == 2 && _class->module != module)
3502 break;
3503 }
3504 }
3505 return (((void *)0));
3506 }
3507
3508 static unsigned int __ecereNameSpace__ecere__com__ConstructInstance(void * instance, struct __ecereNameSpace__ecere__com__Class * _class, struct __ecereNameSpace__ecere__com__Class * from)
3509 {
3510 if(_class->templateClass)
3511 _class = _class->templateClass;
3512 if(_class->base && from != _class->base)
3513 {
3514 if(!__ecereNameSpace__ecere__com__ConstructInstance(instance, _class->base, from))
3515 return 0x0;
3516 }
3517 if(_class->Initialize)
3518 {
3519 void (* Initialize)(struct __ecereNameSpace__ecere__com__Instance * module) = (void *)_class->Initialize;
3520
3521 _class->Initialize = (((void *)0));
3522 Initialize(_class->module);
3523 }
3524 if(_class->Constructor)
3525 {
3526 if(!_class->Constructor(instance))
3527 {
3528 for(; _class; _class = _class->base)
3529 {
3530 if(_class->templateClass)
3531 _class = _class->templateClass;
3532 if(_class->Destructor)
3533 _class->Destructor(instance);
3534 }
3535 return 0x0;
3536 }
3537 }
3538 (_class->templateClass ? _class->templateClass : _class)->count++;
3539 return 0x1;
3540 }
3541
3542 void * __ecereNameSpace__ecere__com__eInstance_New(struct __ecereNameSpace__ecere__com__Class * _class)
3543 {
3544 struct __ecereNameSpace__ecere__com__Instance * instance = (((void *)0));
3545
3546 if(_class)
3547 {
3548 {
3549 int size = _class->structSize;
3550 int flags = (unsigned int)((struct __ecereNameSpace__ecere__com__Application *)(((char *)((struct __ecereNameSpace__ecere__com__Module *)(((char *)_class->module + structSize_Instance)))->application + structSize_Module)))->isGUIApp;
3551 unsigned int inCompiler = (flags & 8) ? 0x1 : 0x0;
3552 unsigned int force32Bits = (flags & 4) ? 0x1 : 0x0;
3553
3554 if(force32Bits && inCompiler)
3555 {
3556 if(!strcmp(_class->name, "Module"))
3557 size = 560;
3558 else if(_class->templateClass && !strcmp(_class->templateClass->name, "Map"))
3559 size = 40;
3560 else
3561 size *= 3;
3562 }
3563 instance = __ecereNameSpace__ecere__com___calloc(1, size);
3564 }
3565 if(_class->type == 0)
3566 {
3567 ((struct __ecereNameSpace__ecere__com__Instance *)(char *)instance)->_class = _class;
3568 ((struct __ecereNameSpace__ecere__com__Instance *)(char *)instance)->_vTbl = _class->_vTbl;
3569 }
3570 if(!__ecereNameSpace__ecere__com__ConstructInstance(instance, _class, (((void *)0))))
3571 {
3572 __ecereNameSpace__ecere__com___free(instance);
3573 instance = (((void *)0));
3574 }
3575 }
3576 return instance;
3577 }
3578
3579 void __ecereNameSpace__ecere__com__eInstance_Evolve(struct __ecereNameSpace__ecere__com__Instance ** instancePtr, struct __ecereNameSpace__ecere__com__Class * _class)
3580 {
3581 if(_class && instancePtr && *instancePtr)
3582 {
3583 unsigned int wasApp = 0x0, wasGuiApp = 0x0;
3584 struct __ecereNameSpace__ecere__com__Instance * instance = (struct __ecereNameSpace__ecere__com__Instance *)__ecereNameSpace__ecere__com__eSystem_Renew(*instancePtr, sizeof(unsigned char) * (_class->structSize));
3585 struct __ecereNameSpace__ecere__com__Class * fromClass = ((struct __ecereNameSpace__ecere__com__Instance *)(char *)instance)->_class;
3586
3587 *instancePtr = instance;
3588 memset(((unsigned char *)instance) + ((struct __ecereNameSpace__ecere__com__Instance *)(char *)instance)->_class->structSize, 0, _class->structSize - ((struct __ecereNameSpace__ecere__com__Instance *)(char *)instance)->_class->structSize);
3589 if((wasApp = !strcmp(((struct __ecereNameSpace__ecere__com__Instance *)(char *)instance)->_class->name, "Application")) || (wasGuiApp = !strcmp(((struct __ecereNameSpace__ecere__com__Instance *)(char *)instance)->_class->name, "GuiApplication")))
3590 {
3591 struct __ecereNameSpace__ecere__com__Instance * module;
3592 struct __ecereNameSpace__ecere__com__Instance * app = (struct __ecereNameSpace__ecere__com__Instance *)instance;
3593 struct __ecereNameSpace__ecere__com__BTNamedLink * link;
3594 struct __ecereNameSpace__ecere__com__Class * _class;
3595 struct __ecereNameSpace__ecere__com__NameSpace * nameSpace;
3596
3597 for(module = ((struct __ecereNameSpace__ecere__com__Application *)(((char *)app + structSize_Module)))->allModules.first; module; module = ((struct __ecereNameSpace__ecere__com__Module *)(((char *)module + structSize_Instance)))->next)
3598 ((struct __ecereNameSpace__ecere__com__Module *)(((char *)module + structSize_Instance)))->application = app;
3599 for(link = (struct __ecereNameSpace__ecere__com__BTNamedLink *)__ecereProp___ecereNameSpace__ecere__sys__BinaryTree_Get_first(&((struct __ecereNameSpace__ecere__com__Module *)(((char *)app + structSize_Instance)))->privateNameSpace.classes); link; link = (struct __ecereNameSpace__ecere__com__BTNamedLink *)__ecereProp___ecereNameSpace__ecere__sys__BTNode_Get_next(((struct __ecereNameSpace__ecere__sys__BTNode *)link)))
3600 {
3601 struct __ecereNameSpace__ecere__sys__OldLink * t;
3602
3603 ((struct __ecereNameSpace__ecere__com__Class *)link->data)->nameSpace = &((struct __ecereNameSpace__ecere__com__Module *)(((char *)app + structSize_Instance)))->privateNameSpace;
3604 for(t = ((struct __ecereNameSpace__ecere__com__Class *)link->data)->templatized.first; t; t = t->next)
3605 {
3606 struct __ecereNameSpace__ecere__com__Class * template = t->data;
3607
3608 template->nameSpace = ((struct __ecereNameSpace__ecere__com__Class *)link->data)->nameSpace;
3609 }
3610 }
3611 for(link = (struct __ecereNameSpace__ecere__com__BTNamedLink *)__ecereProp___ecereNameSpace__ecere__sys__BinaryTree_Get_first(&((struct __ecereNameSpace__ecere__com__Module *)(((char *)app + structSize_Instance)))->publicNameSpace.classes); link; link = (struct __ecereNameSpace__ecere__com__BTNamedLink *)__ecereProp___ecereNameSpace__ecere__sys__BTNode_Get_next(((struct __ecereNameSpace__ecere__sys__BTNode *)link)))
3612 {
3613 struct __ecereNameSpace__ecere__sys__OldLink * t;
3614
3615 ((struct __ecereNameSpace__ecere__com__Class *)link->data)->nameSpace = &((struct __ecereNameSpace__ecere__com__Module *)(((char *)app + structSize_Instance)))->publicNameSpace;
3616 for(t = ((struct __ecereNameSpace__ecere__com__Class *)link->data)->templatized.first; t; t = t->next)
3617 {
3618 struct __ecereNameSpace__ecere__com__Class * template = t->data;
3619
3620 template->nameSpace = ((struct __ecereNameSpace__ecere__com__Class *)link->data)->nameSpace;
3621 }
3622 }
3623 for(link = (struct __ecereNameSpace__ecere__com__BTNamedLink *)__ecereProp___ecereNameSpace__ecere__sys__BinaryTree_Get_first(&((struct __ecereNameSpace__ecere__com__Module *)(((char *)app + structSize_Instance)))->privateNameSpace.defines); link; link = (struct __ecereNameSpace__ecere__com__BTNamedLink *)__ecereProp___ecereNameSpace__ecere__sys__BTNode_Get_next(((struct __ecereNameSpace__ecere__sys__BTNode *)link)))
3624 ((struct __ecereNameSpace__ecere__com__DefinedExpression *)link->data)->nameSpace = &((struct __ecereNameSpace__ecere__com__Module *)(((char *)app + structSize_Instance)))->privateNameSpace;
3625 for(link = (struct __ecereNameSpace__ecere__com__BTNamedLink *)__ecereProp___ecereNameSpace__ecere__sys__BinaryTree_Get_first(&((struct __ecereNameSpace__ecere__com__Module *)(((char *)app + structSize_Instance)))->publicNameSpace.defines); link; link = (struct __ecereNameSpace__ecere__com__BTNamedLink *)__ecereProp___ecereNameSpace__ecere__sys__BTNode_Get_next(((struct __ecereNameSpace__ecere__sys__BTNode *)link)))
3626 ((struct __ecereNameSpace__ecere__com__DefinedExpression *)link->data)->nameSpace = &((struct __ecereNameSpace__ecere__com__Module *)(((char *)app + structSize_Instance)))->publicNameSpace;
3627 for(link = (struct __ecereNameSpace__ecere__com__BTNamedLink *)__ecereProp___ecereNameSpace__ecere__sys__BinaryTree_Get_first(&((struct __ecereNameSpace__ecere__com__Module *)(((char *)app + structSize_Instance)))->privateNameSpace.functions); link; link = (struct __ecereNameSpace__ecere__com__BTNamedLink *)__ecereProp___ecereNameSpace__ecere__sys__BTNode_Get_next(((struct __ecereNameSpace__ecere__sys__BTNode *)link)))
3628 ((struct __ecereNameSpace__ecere__com__GlobalFunction *)link->data)->nameSpace = &((struct __ecereNameSpace__ecere__com__Module *)(((char *)app + structSize_Instance)))->privateNameSpace;
3629 for(link = (struct __ecereNameSpace__ecere__com__BTNamedLink *)__ecereProp___ecereNameSpace__ecere__sys__BinaryTree_Get_first(&((struct __ecereNameSpace__ecere__com__Module *)(((char *)app + structSize_Instance)))->publicNameSpace.functions); link; link = (struct __ecereNameSpace__ecere__com__BTNamedLink *)__ecereProp___ecereNameSpace__ecere__sys__BTNode_Get_next(((struct __ecereNameSpace__ecere__sys__BTNode *)link)))
3630 ((struct __ecereNameSpace__ecere__com__GlobalFunction *)link->data)->nameSpace = &((struct __ecereNameSpace__ecere__com__Module *)(((char *)app + structSize_Instance)))->publicNameSpace;
3631 for(nameSpace = (struct __ecereNameSpace__ecere__com__NameSpace *)__ecereProp___ecereNameSpace__ecere__sys__BinaryTree_Get_first(&((struct __ecereNameSpace__ecere__com__Module *)(((char *)app + structSize_Instance)))->privateNameSpace.nameSpaces); nameSpace; nameSpace = (struct __ecereNameSpace__ecere__com__NameSpace *)__ecereProp___ecereNameSpace__ecere__sys__BTNode_Get_next(((struct __ecereNameSpace__ecere__sys__BTNode *)nameSpace)))
3632 (*nameSpace).parent = &((struct __ecereNameSpace__ecere__com__Module *)(((char *)app + structSize_Instance)))->privateNameSpace;
3633 for(nameSpace = (struct __ecereNameSpace__ecere__com__NameSpace *)__ecereProp___ecereNameSpace__ecere__sys__BinaryTree_Get_first(&((struct __ecereNameSpace__ecere__com__Module *)(((char *)app + structSize_Instance)))->publicNameSpace.nameSpaces); nameSpace; nameSpace = (struct __ecereNameSpace__ecere__com__NameSpace *)__ecereProp___ecereNameSpace__ecere__sys__BTNode_Get_next(((struct __ecereNameSpace__ecere__sys__BTNode *)nameSpace)))
3634 (*nameSpace).parent = &((struct __ecereNameSpace__ecere__com__Module *)(((char *)app + structSize_Instance)))->publicNameSpace;
3635 for(link = (struct __ecereNameSpace__ecere__com__BTNamedLink *)__ecereProp___ecereNameSpace__ecere__sys__BinaryTree_Get_first(&((struct __ecereNameSpace__ecere__com__Application *)(((char *)app + structSize_Module)))->systemNameSpace.classes); link; link = (struct __ecereNameSpace__ecere__com__BTNamedLink *)__ecereProp___ecereNameSpace__ecere__sys__BTNode_Get_next(((struct __ecereNameSpace__ecere__sys__BTNode *)link)))
3636 {
3637 struct __ecereNameSpace__ecere__sys__OldLink * t;
3638
3639 ((struct __ecereNameSpace__ecere__com__Class *)link->data)->nameSpace = &((struct __ecereNameSpace__ecere__com__Application *)(((char *)app + structSize_Module)))->systemNameSpace;
3640 for(t = ((struct __ecereNameSpace__ecere__com__Class *)link->data)->templatized.first; t; t = t->next)
3641 {
3642 struct __ecereNameSpace__ecere__com__Class * template = t->data;
3643
3644 template->nameSpace = ((struct __ecereNameSpace__ecere__com__Class *)link->data)->nameSpace;
3645 }
3646 }
3647 for(link = (struct __ecereNameSpace__ecere__com__BTNamedLink *)__ecereProp___ecereNameSpace__ecere__sys__BinaryTree_Get_first(&((struct __ecereNameSpace__ecere__com__Application *)(((char *)app + structSize_Module)))->systemNameSpace.defines); link; link = (struct __ecereNameSpace__ecere__com__BTNamedLink *)__ecereProp___ecereNameSpace__ecere__sys__BTNode_Get_next(((struct __ecereNameSpace__ecere__sys__BTNode *)link)))
3648 ((struct __ecereNameSpace__ecere__com__DefinedExpression *)link->data)->nameSpace = &((struct __ecereNameSpace__ecere__com__Application *)(((char *)app + structSize_Module)))->systemNameSpace;
3649 for(link = (struct __ecereNameSpace__ecere__com__BTNamedLink *)__ecereProp___ecereNameSpace__ecere__sys__BinaryTree_Get_first(&((struct __ecereNameSpace__ecere__com__Application *)(((char *)app + structSize_Module)))->systemNameSpace.functions); link; link = (struct __ecereNameSpace__ecere__com__BTNamedLink *)__ecereProp___ecereNameSpace__ecere__sys__BTNode_Get_next(((struct __ecereNameSpace__ecere__sys__BTNode *)link)))
3650 ((struct __ecereNameSpace__ecere__com__GlobalFunction *)link->data)->nameSpace = &((struct __ecereNameSpace__ecere__com__Application *)(((char *)app + structSize_Module)))->systemNameSpace;
3651 for(link = (struct __ecereNameSpace__ecere__com__BTNamedLink *)__ecereProp___ecereNameSpace__ecere__sys__BinaryTree_Get_first(&((struct __ecereNameSpace__ecere__com__Application *)(((char *)app + structSize_Module)))->systemNameSpace.functions); link; link = (struct __ecereNameSpace__ecere__com__BTNamedLink *)__ecereProp___ecereNameSpace__ecere__sys__BTNode_Get_next(((struct __ecereNameSpace__ecere__sys__BTNode *)link)))
3652 ((struct __ecereNameSpace__ecere__com__GlobalFunction *)link->data)->nameSpace = &((struct __ecereNameSpace__ecere__com__Application *)(((char *)app + structSize_Module)))->systemNameSpace;
3653 for(nameSpace = (struct __ecereNameSpace__ecere__com__NameSpace *)__ecereProp___ecereNameSpace__ecere__sys__BinaryTree_Get_first(&((struct __ecereNameSpace__ecere__com__Application *)(((char *)app + structSize_Module)))->systemNameSpace.nameSpaces); nameSpace; nameSpace = (struct __ecereNameSpace__ecere__com__NameSpace *)__ecereProp___ecereNameSpace__ecere__sys__BTNode_Get_next(((struct __ecereNameSpace__ecere__sys__BTNode *)nameSpace)))
3654 (*nameSpace).parent = &((struct __ecereNameSpace__ecere__com__Application *)(((char *)app + structSize_Module)))->systemNameSpace;
3655 for(_class = ((struct __ecereNameSpace__ecere__com__Module *)(((char *)app + structSize_Instance)))->classes.first; _class; _class = _class->next)
3656 {
3657 struct __ecereNameSpace__ecere__sys__OldLink * templateLink;
3658
3659 _class->module = (struct __ecereNameSpace__ecere__com__Instance *)app;
3660 for(templateLink = _class->templatized.first; templateLink; templateLink = templateLink->next)
3661 {
3662 struct __ecereNameSpace__ecere__com__Class * template = templateLink->data;
3663
3664 template->module = _class->module;
3665 }
3666 }
3667 for(module = ((struct __ecereNameSpace__ecere__com__Application *)(((char *)app + structSize_Module)))->allModules.first; module; module = ((struct __ecereNameSpace__ecere__com__Module *)(((char *)module + structSize_Instance)))->next)
3668 {
3669 for(_class = ((struct __ecereNameSpace__ecere__com__Module *)(((char *)module + structSize_Instance)))->classes.first; _class; _class = _class->next)
3670 {
3671 struct __ecereNameSpace__ecere__sys__OldLink * templateLink;
3672
3673 _class->module = module;
3674 for(templateLink = _class->templatized.first; templateLink; templateLink = templateLink->next)
3675 {
3676 struct __ecereNameSpace__ecere__com__Class * template = templateLink->data;
3677
3678 template->module = _class->module;
3679 }
3680 }
3681 }
3682 ((struct __ecereNameSpace__ecere__com__Module *)(((char *)app + structSize_Instance)))->application = app;
3683 }
3684 {
3685 struct __ecereNameSpace__ecere__com__Class * base;
3686
3687 for(base = ((struct __ecereNameSpace__ecere__com__Instance *)(char *)instance)->_class; base && base->type == 0 && base->count; base = base->base)
3688 (base->templateClass ? base->templateClass : base)->count--;
3689 }
3690 ((struct __ecereNameSpace__ecere__com__Instance *)(char *)instance)->_class = _class;
3691 ((struct __ecereNameSpace__ecere__com__Instance *)(char *)instance)->_vTbl = _class->_vTbl;
3692 if(!__ecereNameSpace__ecere__com__ConstructInstance(instance, _class, fromClass))
3693 {
3694 __ecereNameSpace__ecere__com___free(instance);
3695 *instancePtr = (((void *)0));
3696 }
3697 }
3698 }
3699
3700 void __ecereNameSpace__ecere__com__eInstance_Delete(struct __ecereNameSpace__ecere__com__Instance * instance)
3701 {
3702 if(instance)
3703 {
3704 struct __ecereNameSpace__ecere__com__Class * _class, * base;
3705 unsigned int ownVtbl;
3706
3707 ownVtbl = ((struct __ecereNameSpace__ecere__com__Instance *)(char *)instance)->_vTbl != ((struct __ecereNameSpace__ecere__com__Instance *)(char *)instance)->_class->_vTbl;
3708 for(_class = ((struct __ecereNameSpace__ecere__com__Instance *)(char *)instance)->_class; _class; _class = base)
3709 {
3710 if(_class->templateClass)
3711 _class = _class->templateClass;
3712 if(_class->destructionWatchOffset)
3713 {
3714 struct __ecereNameSpace__ecere__sys__OldList * watchers = (struct __ecereNameSpace__ecere__sys__OldList *)((unsigned char *)instance + _class->destructionWatchOffset);
3715 struct __ecereNameSpace__ecere__com__Watcher * watcher, * next;
3716
3717 for(watcher = (*watchers).first; watcher; watcher = next)
3718 {
3719 next = watcher->next;
3720 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Remove((&*watchers), watcher);
3721 watcher->callback(watcher->object, instance);
3722 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Delete((&*watchers), watcher);
3723 }
3724 }
3725 base = _class->base;
3726 if(base && base->type == 1000)
3727 base = (((void *)0));
3728 if(_class->Destructor)
3729 _class->Destructor(instance);
3730 }
3731 for(_class = ((struct __ecereNameSpace__ecere__com__Instance *)(char *)instance)->_class; _class; _class = base)
3732 {
3733 if(_class->templateClass)
3734 _class = _class->templateClass;
3735 base = _class->base;
3736 (_class->templateClass ? _class->templateClass : _class)->count--;
3737 if(_class->type == 0 && !_class->count && !_class->module)
3738 {
3739 __ecereNameSpace__ecere__com__eClass_Unregister(_class);
3740 }
3741 }
3742 if(ownVtbl)
3743 {
3744 (__ecereNameSpace__ecere__com__eSystem_Delete(((struct __ecereNameSpace__ecere__com__Instance *)(char *)instance)->_vTbl), ((struct __ecereNameSpace__ecere__com__Instance * )(char * )instance)->_vTbl = 0);
3745 }
3746 __ecereNameSpace__ecere__com___free(instance);
3747 }
3748 }
3749
3750 struct __ecereNameSpace__ecere__com__Property * __ecereNameSpace__ecere__com__eClass_FindProperty(struct __ecereNameSpace__ecere__com__Class * _class, char * name, struct __ecereNameSpace__ecere__com__Instance * module)
3751 {
3752 if(_class && name)
3753 {
3754 for(; _class; _class = _class->base)
3755 {
3756 struct __ecereNameSpace__ecere__com__BTNamedLink * link;
3757
3758 if(_class->templateClass)
3759 _class = _class->templateClass;
3760 link = (struct __ecereNameSpace__ecere__com__BTNamedLink *)__ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_FindString(&_class->prop, name);
3761 if(link)
3762 {
3763 struct __ecereNameSpace__ecere__com__Property * _property = (struct __ecereNameSpace__ecere__com__Property *)link->data;
3764
3765 if(_property->memberAccess == 1 || _class->module == module || !_property->dataTypeString)
3766 {
3767 if(!_property->dataTypeString)
3768 {
3769 if(_class->module != module)
3770 {
3771 if(_property->memberAccess == 1)
3772 module = _class->module;
3773 else
3774 {
3775 return (((void *)0));
3776 }
3777 }
3778 }
3779 else
3780 {
3781 return _property;
3782 }
3783 }
3784 }
3785 if(_class->inheritanceAccess == 2 && _class->module != module)
3786 break;
3787 }
3788 }
3789 return (((void *)0));
3790 }
3791
3792 static struct __ecereNameSpace__ecere__com__DataMember * __ecereNameSpace__ecere__com__FindDataMember(struct __ecereNameSpace__ecere__sys__OldList * list, struct __ecereNameSpace__ecere__sys__BinaryTree * alist, char * name, unsigned int * offset, int * id, unsigned int searchPrivate, struct __ecereNameSpace__ecere__com__DataMember ** subMemberStack, int * subMemberStackPos)
3793 {
3794 struct __ecereNameSpace__ecere__com__BTNamedLink * link;
3795 struct __ecereNameSpace__ecere__com__DataMember * dataMember;
3796
3797 link = (struct __ecereNameSpace__ecere__com__BTNamedLink *)__ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_FindString(alist, name);
3798 if(link)
3799 {
3800 dataMember = link->data;
3801 if(dataMember->type == 0 && (dataMember->memberAccess == 1 || searchPrivate || !dataMember->dataTypeString))
3802 {
3803 if(offset)
3804 *offset += dataMember->offset;
3805 if(id)
3806 *id = dataMember->id;
3807 return dataMember;
3808 }
3809 return (((void *)0));
3810 }
3811 for(dataMember = list->first; dataMember; dataMember = dataMember->next)
3812 {
3813 if(!dataMember->isProperty && (dataMember->memberAccess == 1 || searchPrivate) && !dataMember->name && (dataMember->type == 1 || dataMember->type == 2))
3814 {
3815 struct __ecereNameSpace__ecere__com__DataMember * childMember;
3816
3817 if(subMemberStackPos)
3818 subMemberStack[(*subMemberStackPos)++] = dataMember;
3819 childMember = __ecereNameSpace__ecere__com__FindDataMember(&dataMember->members, &dataMember->membersAlpha, name, offset, id, searchPrivate, subMemberStack, subMemberStackPos);
3820 if(childMember)
3821 {
3822 if(offset)
3823 *offset += dataMember->offset;
3824 if(id)
3825 *id += dataMember->id;
3826 return childMember;
3827 }
3828 if(subMemberStackPos)
3829 (*subMemberStackPos)--;
3830 }
3831 }
3832 return (((void *)0));
3833 }
3834
3835 struct __ecereNameSpace__ecere__com__DataMember * __ecereNameSpace__ecere__com__eClass_FindDataMember(struct __ecereNameSpace__ecere__com__Class * _class, char * name, struct __ecereNameSpace__ecere__com__Instance * module, struct __ecereNameSpace__ecere__com__DataMember ** subMemberStack, int * subMemberStackPos)
3836 {
3837 struct __ecereNameSpace__ecere__com__DataMember * dataMember = (((void *)0));
3838
3839 if(subMemberStackPos)
3840 *subMemberStackPos = 0;
3841 if(_class && name)
3842 {
3843 for(; _class; _class = _class->base)
3844 {
3845 if(_class->templateClass)
3846 _class = _class->templateClass;
3847 dataMember = __ecereNameSpace__ecere__com__FindDataMember(&_class->membersAndProperties, &_class->members, name, (((void *)0)), (((void *)0)), _class->module == module, subMemberStack, subMemberStackPos);
3848 if(dataMember)
3849 {
3850 if(!dataMember->dataTypeString)
3851 {
3852 if(_class->module != module)
3853 {
3854 if(dataMember->memberAccess == 1)
3855 module = _class->module;
3856 else
3857 {
3858 return (((void *)0));
3859 }
3860 }
3861 dataMember = (((void *)0));
3862 }
3863 else
3864 {
3865 dataMember->_class = _class->templateClass ? _class->templateClass : _class;
3866 return dataMember;
3867 }
3868 }
3869 if(_class->inheritanceAccess == 2 && _class->module != module)
3870 break;
3871 }
3872 }
3873 return dataMember;
3874 }
3875
3876 struct __ecereNameSpace__ecere__com__DataMember * __ecereNameSpace__ecere__com__eClass_FindDataMemberAndOffset(struct __ecereNameSpace__ecere__com__Class * _class, char * name, unsigned int * offset, struct __ecereNameSpace__ecere__com__Instance * module, struct __ecereNameSpace__ecere__com__DataMember ** subMemberStack, int * subMemberStackPos)
3877 {
3878 struct __ecereNameSpace__ecere__com__DataMember * dataMember = (((void *)0));
3879
3880 if(subMemberStackPos)
3881 *subMemberStackPos = 0;
3882 if(offset)
3883 *offset = 0;
3884 if(_class)
3885 {
3886 for(; _class; _class = _class->base)
3887 {
3888 if(_class->templateClass)
3889 _class = _class->templateClass;
3890 dataMember = __ecereNameSpace__ecere__com__FindDataMember(&_class->membersAndProperties, &_class->members, name, offset, (((void *)0)), _class->module == module, subMemberStack, subMemberStackPos);
3891 if(dataMember)
3892 {
3893 if(!dataMember->dataTypeString)
3894 {
3895 if(_class->module != module)
3896 {
3897 if(dataMember->memberAccess == 1)
3898 module = _class->module;
3899 else
3900 {
3901 return (((void *)0));
3902 }
3903 }
3904 dataMember = (((void *)0));
3905 }
3906 else
3907 {
3908 dataMember->_class = _class;
3909 return dataMember;
3910 }
3911 }
3912 if(_class->inheritanceAccess == 2 && _class->module != module)
3913 break;
3914 }
3915 }
3916 return dataMember;
3917 }
3918
3919 struct __ecereNameSpace__ecere__com__DataMember * __ecereNameSpace__ecere__com__eClass_FindDataMemberAndId(struct __ecereNameSpace__ecere__com__Class * _class, char * name, int * id, struct __ecereNameSpace__ecere__com__Instance * module, struct __ecereNameSpace__ecere__com__DataMember ** subMemberStack, int * subMemberStackPos)
3920 {
3921 struct __ecereNameSpace__ecere__com__DataMember * dataMember = (((void *)0));
3922
3923 if(subMemberStackPos)
3924 *subMemberStackPos = 0;
3925 if(_class)
3926 {
3927 for(; _class; _class = _class->base)
3928 {
3929 if(_class->templateClass)
3930 _class = _class->templateClass;
3931 dataMember = __ecereNameSpace__ecere__com__FindDataMember(&_class->membersAndProperties, &_class->members, name, (((void *)0)), id, _class->module == module, subMemberStack, subMemberStackPos);
3932 if(dataMember)
3933 {
3934 if(!dataMember->dataTypeString)
3935 {
3936 if(_class->module != module)
3937 {
3938 if(dataMember->memberAccess == 1)
3939 module = _class->module;
3940 else
3941 {
3942 return (((void *)0));
3943 }
3944 }
3945 dataMember = (((void *)0));
3946 }
3947 else
3948 {
3949 dataMember->_class = _class;
3950 return dataMember;
3951 }
3952 }
3953 if(_class->inheritanceAccess == 2 && _class->module != module)
3954 break;
3955 }
3956 }
3957 return dataMember;
3958 }
3959
3960 void __ecereNameSpace__ecere__com__eClass_FindNextMember(struct __ecereNameSpace__ecere__com__Class * _class, struct __ecereNameSpace__ecere__com__Class ** curClass, struct __ecereNameSpace__ecere__com__DataMember ** curMember, struct __ecereNameSpace__ecere__com__DataMember ** subMemberStack, int * subMemberStackPos)
3961 {
3962 if(*curMember)
3963 {
3964 *curMember = (*curMember)->next;
3965 if(subMemberStackPos && *subMemberStackPos > 0 && subMemberStack[*subMemberStackPos - 1]->type == 1)
3966 {
3967 *curMember = subMemberStack[--(*subMemberStackPos)];
3968 *curMember = (*curMember)->next;
3969 }
3970 if(subMemberStackPos && *subMemberStackPos > 0)
3971 {
3972 while(*curMember && ((*curMember)->memberAccess == 2))
3973 *curMember = (*curMember)->next;
3974 }
3975 else
3976 while(*curMember && (*curMember)->name)
3977 {
3978 struct __ecereNameSpace__ecere__com__DataMember * dataMember = __ecereNameSpace__ecere__com__eClass_FindDataMember(_class, (*curMember)->name, (((void *)0)), (((void *)0)), (((void *)0)));
3979
3980 if(!dataMember)
3981 dataMember = (struct __ecereNameSpace__ecere__com__DataMember *)__ecereNameSpace__ecere__com__eClass_FindProperty(_class, (*curMember)->name, (((void *)0)));
3982 if(dataMember && dataMember->memberAccess != 2)
3983 {
3984 *curMember = dataMember;
3985 break;
3986 }
3987 else
3988 *curMember = (*curMember)->next;
3989 }
3990 if(subMemberStackPos)
3991 {
3992 while((*curMember) && !(*curMember)->isProperty && !(*curMember)->name && ((*curMember)->type == 2 || (*curMember)->type == 1))
3993 {
3994 subMemberStack[(*subMemberStackPos)++] = *curMember;
3995 *curMember = (*curMember)->members.first;
3996 while(*curMember && ((*curMember)->memberAccess == 2))
3997 *curMember = (*curMember)->next;
3998 }
3999 }
4000 }
4001 while(!*curMember)
4002 {
4003 if(!*curMember)
4004 {
4005 if(subMemberStackPos && *subMemberStackPos)
4006 {
4007 *curMember = subMemberStack[--(*subMemberStackPos)];
4008 *curMember = (*curMember)->next;
4009 }
4010 else
4011 {
4012 struct __ecereNameSpace__ecere__com__Class * lastCurClass = *curClass;
4013
4014 if(*curClass == _class)
4015 break;
4016 for(*curClass = _class; (*curClass)->base != lastCurClass && (*curClass)->base->type != 1000 && (*curClass)->inheritanceAccess != 2; *curClass = (*curClass)->base)
4017 ;
4018 *curMember = (*curClass)->membersAndProperties.first;
4019 }
4020 if(subMemberStackPos && *subMemberStackPos > 0)
4021 {
4022 while(*curMember && ((*curMember)->memberAccess == 2))
4023 *curMember = (*curMember)->next;
4024 }
4025 else
4026 while(*curMember && (*curMember)->name)
4027 {
4028 struct __ecereNameSpace__ecere__com__DataMember * dataMember = __ecereNameSpace__ecere__com__eClass_FindDataMember(_class, (*curMember)->name, (((void *)0)), (((void *)0)), (((void *)0)));
4029
4030 if(!dataMember)
4031 dataMember = (struct __ecereNameSpace__ecere__com__DataMember *)__ecereNameSpace__ecere__com__eClass_FindProperty(_class, (*curMember)->name, (((void *)0)));
4032 if(dataMember && dataMember->memberAccess != 2)
4033 {
4034 *curMember = dataMember;
4035 break;
4036 }
4037 else
4038 *curMember = (*curMember)->next;
4039 }
4040 if(subMemberStackPos)
4041 {
4042 while((*curMember) && !(*curMember)->isProperty && !(*curMember)->name && ((*curMember)->type == 2 || (*curMember)->type == 1))
4043 {
4044 subMemberStack[(*subMemberStackPos)++] = *curMember;
4045 *curMember = (*curMember)->members.first;
4046 while(*curMember && (*curMember)->memberAccess == 2)
4047 *curMember = (*curMember)->next;
4048 }
4049 }
4050 }
4051 }
4052 }
4053
4054 void __ecereNameSpace__ecere__com__eInstance_SetMethod(struct __ecereNameSpace__ecere__com__Instance * instance, char * name, void * function)
4055 {
4056 if(instance && name)
4057 {
4058 struct __ecereNameSpace__ecere__com__Class * _class;
4059
4060 for(_class = ((struct __ecereNameSpace__ecere__com__Instance *)(char *)instance)->_class; _class; _class = _class->base)
4061 {
4062 struct __ecereNameSpace__ecere__com__Method * method = (struct __ecereNameSpace__ecere__com__Method *)__ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_FindString(&_class->methods, name);
4063
4064 if(method && method->type == 1)
4065 {
4066 if(((struct __ecereNameSpace__ecere__com__Instance *)(char *)instance)->_vTbl == ((struct __ecereNameSpace__ecere__com__Instance *)(char *)instance)->_class->_vTbl)
4067 {
4068 ((struct __ecereNameSpace__ecere__com__Instance *)(char *)instance)->_vTbl = __ecereNameSpace__ecere__com___malloc(sizeof(void *) * ((struct __ecereNameSpace__ecere__com__Instance *)(char *)instance)->_class->vTblSize);
4069 memcpy(((struct __ecereNameSpace__ecere__com__Instance *)(char *)instance)->_vTbl, ((struct __ecereNameSpace__ecere__com__Instance *)(char *)instance)->_class->_vTbl, sizeof(int (*)()) * ((struct __ecereNameSpace__ecere__com__Instance *)(char *)instance)->_class->vTblSize);
4070 }
4071 ((struct __ecereNameSpace__ecere__com__Instance *)(char *)instance)->_vTbl[method->vid] = function ? function : __ecereNameSpace__ecere__com__DefaultFunction;
4072 }
4073 }
4074 }
4075 }
4076
4077 unsigned int __ecereNameSpace__ecere__com__eInstance_IsDerived(struct __ecereNameSpace__ecere__com__Instance * instance, struct __ecereNameSpace__ecere__com__Class * from)
4078 {
4079 if(instance)
4080 {
4081 struct __ecereNameSpace__ecere__com__Class * _class = ((struct __ecereNameSpace__ecere__com__Instance *)(char *)instance)->_class;
4082
4083 for(; _class; _class = _class->base)
4084 {
4085 if(_class == from)
4086 return 0x1;
4087 }
4088 }
4089 return 0x0;
4090 }
4091
4092 void __ecereNameSpace__ecere__com__eInstance_IncRef(struct __ecereNameSpace__ecere__com__Instance * instance)
4093 {
4094 if(instance)
4095 ((struct __ecereNameSpace__ecere__com__Instance *)(char *)instance)->_refCount++;
4096 }
4097
4098 void __ecereNameSpace__ecere__com__eInstance_DecRef(struct __ecereNameSpace__ecere__com__Instance * instance)
4099 {
4100 if(instance)
4101 {
4102 ((struct __ecereNameSpace__ecere__com__Instance *)(char *)instance)->_refCount--;
4103 if(((struct __ecereNameSpace__ecere__com__Instance *)(char *)instance)->_refCount <= 0)
4104 {
4105 __ecereNameSpace__ecere__com__eInstance_Delete(instance);
4106 }
4107 }
4108 }
4109
4110 static void __ecereNameSpace__ecere__com__FixOffsets(struct __ecereNameSpace__ecere__com__Class * _class)
4111 {
4112 struct __ecereNameSpace__ecere__sys__OldLink * deriv;
4113
4114 _class->structSize += _class->base->structSize - _class->offset;
4115 _class->offset = _class->base->structSize;
4116 for(deriv = _class->derivatives.first; deriv; deriv = deriv->next)
4117 __ecereNameSpace__ecere__com__FixOffsets(deriv->data);
4118 }
4119
4120 void __ecereNameSpace__ecere__com__eClass_Resize(struct __ecereNameSpace__ecere__com__Class * _class, int newSize)
4121 {
4122 struct __ecereNameSpace__ecere__sys__OldLink * deriv;
4123
4124 _class->structSize = newSize;
4125 for(deriv = _class->derivatives.first; deriv; deriv = deriv->next)
4126 __ecereNameSpace__ecere__com__FixOffsets(deriv->data);
4127 }
4128
4129 struct __ecereNameSpace__ecere__com__DataMember * __ecereNameSpace__ecere__com__eClass_AddDataMember(struct __ecereNameSpace__ecere__com__Class * _class, char * name, char * type, unsigned int size, unsigned int alignment, int declMode)
4130 {
4131 if(_class && name)
4132 {
4133 if(!__ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_FindString(&_class->members, name))
4134 {
4135 struct __ecereNameSpace__ecere__com__DataMember * dataMember;
4136
4137 if(alignment)
4138 {
4139 int __simpleStruct0;
4140
4141 _class->structAlignment = (__simpleStruct0 = _class->structAlignment, (__simpleStruct0 > alignment) ? __simpleStruct0 : alignment);
4142 if(_class->memberOffset % alignment)
4143 _class->memberOffset += alignment - (_class->memberOffset % alignment);
4144 }
4145 dataMember = __extension__ ({
4146 struct __ecereNameSpace__ecere__com__DataMember * __ecereInstance1 = __ecereNameSpace__ecere__com__eSystem_New0(structSize_DataMember);
4147
4148 __ecereInstance1->name = __ecereNameSpace__ecere__sys__CopyString(name), __ecereInstance1->dataTypeString = __ecereNameSpace__ecere__sys__CopyString(type), __ecereInstance1->id = _class->memberID++, __ecereInstance1->_class = _class, __ecereInstance1->offset = _class->memberOffset, __ecereInstance1->memberOffset = size, __ecereInstance1->memberAccess = declMode, __ecereInstance1->membersAlpha.CompareKey = (void *)__ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_CompareString, __ecereInstance1;
4149 });
4150 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Add(&_class->membersAndProperties, dataMember);
4151 _class->memberOffset += size;
4152 __ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_Add(&_class->members, (struct __ecereNameSpace__ecere__sys__BTNode *)__extension__ ({
4153 struct __ecereNameSpace__ecere__com__BTNamedLink * __ecereInstance1 = __ecereNameSpace__ecere__com__eSystem_New0(structSize_BTNamedLink);
4154
4155 __ecereInstance1->name = dataMember->name, __ecereInstance1->data = dataMember, __ecereInstance1;
4156 }));
4157 return dataMember;
4158 }
4159 }
4160 return (((void *)0));
4161 }
4162
4163 struct __ecereNameSpace__ecere__com__DataMember * __ecereNameSpace__ecere__com__eMember_AddDataMember(struct __ecereNameSpace__ecere__com__DataMember * member, char * name, char * type, unsigned int size, unsigned int alignment, int declMode)
4164 {
4165 if(name && !__ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_FindString(&member->membersAlpha, name))
4166 {
4167 struct __ecereNameSpace__ecere__com__DataMember * dataMember;
4168
4169 if(alignment)
4170 {
4171 int __simpleStruct0;
4172
4173 member->structAlignment = (__simpleStruct0 = member->structAlignment, (__simpleStruct0 > alignment) ? __simpleStruct0 : alignment);
4174 if(member->memberOffset % alignment)
4175 member->memberOffset += alignment - (member->memberOffset % alignment);
4176 }
4177 dataMember = __extension__ ({
4178 struct __ecereNameSpace__ecere__com__DataMember * __ecereInstance1 = __ecereNameSpace__ecere__com__eSystem_New0(structSize_DataMember);
4179
4180 __ecereInstance1->name = __ecereNameSpace__ecere__sys__CopyString(name), __ecereInstance1->_class = member->_class, __ecereInstance1->dataTypeString = __ecereNameSpace__ecere__sys__CopyString(type), __ecereInstance1->id = member->memberID++, __ecereInstance1->offset = (member->type == 1) ? 0 : member->memberOffset, __ecereInstance1->memberAccess = declMode, __ecereInstance1->membersAlpha.CompareKey = (void *)__ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_CompareString, __ecereInstance1;
4181 });
4182 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Add(&member->members, dataMember);
4183 if(member->type == 1)
4184 {
4185 if(size > member->memberOffset)
4186 member->memberOffset = size;
4187 }
4188 else
4189 member->memberOffset += size;
4190 __ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_Add(&member->membersAlpha, (struct __ecereNameSpace__ecere__sys__BTNode *)__extension__ ({
4191 struct __ecereNameSpace__ecere__com__BTNamedLink * __ecereInstance1 = __ecereNameSpace__ecere__com__eSystem_New0(structSize_BTNamedLink);
4192
4193 __ecereInstance1->name = dataMember->name, __ecereInstance1->data = dataMember, __ecereInstance1;
4194 }));
4195 return dataMember;
4196 }
4197 return (((void *)0));
4198 }
4199
4200 struct __ecereNameSpace__ecere__com__DataMember * __ecereNameSpace__ecere__com__eMember_New(int type, int declMode)
4201 {
4202 return __extension__ ({
4203 struct __ecereNameSpace__ecere__com__DataMember * __ecereInstance1 = __ecereNameSpace__ecere__com__eSystem_New0(structSize_DataMember);
4204
4205 __ecereInstance1->type = type, __ecereInstance1->memberAccess = declMode, __ecereInstance1->membersAlpha.CompareKey = (void *)__ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_CompareString, __ecereInstance1;
4206 });
4207 }
4208
4209 static void __ecereNameSpace__ecere__com__SetMemberClass(struct __ecereNameSpace__ecere__com__DataMember * member, struct __ecereNameSpace__ecere__com__Class * _class)
4210 {
4211 struct __ecereNameSpace__ecere__com__DataMember * dataMember;
4212
4213 member->_class = _class;
4214 for(dataMember = member->members.first; dataMember; dataMember = dataMember->next)
4215 __ecereNameSpace__ecere__com__SetMemberClass(dataMember, _class);
4216 }
4217
4218 unsigned int __ecereNameSpace__ecere__com__eMember_AddMember(struct __ecereNameSpace__ecere__com__DataMember * addTo, struct __ecereNameSpace__ecere__com__DataMember * dataMember)
4219 {
4220 int __simpleStruct0, __simpleStruct1;
4221
4222 if(dataMember->name && __ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_FindString(&addTo->membersAlpha, dataMember->name))
4223 return 0x0;
4224 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Add(&addTo->members, dataMember);
4225 if(dataMember->name)
4226 __ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_Add(&addTo->membersAlpha, (struct __ecereNameSpace__ecere__sys__BTNode *)__extension__ ({
4227 struct __ecereNameSpace__ecere__com__BTNamedLink * __ecereInstance1 = __ecereNameSpace__ecere__com__eSystem_New0(structSize_BTNamedLink);
4228
4229 __ecereInstance1->name = dataMember->name, __ecereInstance1->data = dataMember, __ecereInstance1;
4230 }));
4231 dataMember->_class = addTo->_class;
4232 dataMember->id = addTo->memberID;
4233 if(dataMember->type == 1)
4234 addTo->memberID += 1;
4235 else
4236 addTo->memberID += dataMember->memberID;
4237 addTo->structAlignment = (__simpleStruct0 = addTo->structAlignment, __simpleStruct1 = dataMember->structAlignment, (__simpleStruct0 > __simpleStruct1) ? __simpleStruct0 : __simpleStruct1);
4238 dataMember->offset = (addTo->type == 1) ? 0 : addTo->memberOffset;
4239 if(addTo->type == 1)
4240 {
4241 if(dataMember->memberOffset > addTo->memberOffset)
4242 addTo->memberOffset = dataMember->memberOffset;
4243 }
4244 else
4245 addTo->memberOffset += dataMember->memberOffset;
4246 return 0x1;
4247 }
4248
4249 unsigned int __ecereNameSpace__ecere__com__eClass_AddMember(struct __ecereNameSpace__ecere__com__Class * _class, struct __ecereNameSpace__ecere__com__DataMember * dataMember)
4250 {
4251 int __simpleStruct0, __simpleStruct1;
4252
4253 if(!_class || _class->comRedefinition || (dataMember->name && __ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_FindString(&_class->members, dataMember->name)))
4254 return 0x0;
4255 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Add(&_class->membersAndProperties, dataMember);
4256 if(dataMember->name)
4257 __ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_Add(&_class->members, (struct __ecereNameSpace__ecere__sys__BTNode *)__extension__ ({
4258 struct __ecereNameSpace__ecere__com__BTNamedLink * __ecereInstance1 = __ecereNameSpace__ecere__com__eSystem_New0(structSize_BTNamedLink);
4259
4260 __ecereInstance1->name = dataMember->name, __ecereInstance1->data = dataMember, __ecereInstance1;
4261 }));
4262 __ecereNameSpace__ecere__com__SetMemberClass(dataMember, _class);
4263 dataMember->id = _class->memberID;
4264 _class->structAlignment = (__simpleStruct0 = _class->structAlignment, __simpleStruct1 = dataMember->structAlignment, (__simpleStruct0 > __simpleStruct1) ? __simpleStruct0 : __simpleStruct1);
4265 if(dataMember->type == 1)
4266 _class->memberID += 1;
4267 else
4268 _class->memberID += dataMember->memberID;
4269 dataMember->offset = _class->memberOffset;
4270 _class->memberOffset += dataMember->memberOffset;
4271 return 0x1;
4272 }
4273
4274 struct __ecereNameSpace__ecere__com__BitMember * __ecereNameSpace__ecere__com__eClass_AddBitMember(struct __ecereNameSpace__ecere__com__Class * _class, char * name, char * type, int bitSize, int bitPos, int declMode)
4275 {
4276 if(_class && name && !__ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_FindString(&_class->members, name))
4277 {
4278 uint64 mask = 0;
4279 int c;
4280 struct __ecereNameSpace__ecere__com__BitMember * bitMember = (bitMember = __ecereNameSpace__ecere__com__eSystem_New0(structSize_BitMember), bitMember->name = __ecereNameSpace__ecere__sys__CopyString(name), bitMember->_class = _class, bitMember->dataTypeString = __ecereNameSpace__ecere__sys__CopyString(type), bitMember->id = _class->memberID++, bitMember->memberAccess = declMode, bitMember);
4281
4282 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Add(&_class->membersAndProperties, bitMember);
4283 if(bitSize)
4284 {
4285 bitMember->pos = (bitPos == -1) ? _class->memberOffset : bitPos;
4286 bitMember->size = bitSize;
4287 _class->memberOffset = bitMember->pos + bitMember->size;
4288 for(c = 0; c < bitSize; c++)
4289 {
4290 if(c)
4291 mask <<= 1;
4292 mask |= 1;
4293 }
4294 bitMember->mask = mask << bitMember->pos;
4295 }
4296 __ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_Add(&_class->members, (struct __ecereNameSpace__ecere__sys__BTNode *)__extension__ ({
4297 struct __ecereNameSpace__ecere__com__BTNamedLink * __ecereInstance1 = __ecereNameSpace__ecere__com__eSystem_New0(structSize_BTNamedLink);
4298
4299 __ecereInstance1->name = bitMember->name, __ecereInstance1->data = bitMember, __ecereInstance1;
4300 }));
4301 return bitMember;
4302 }
4303 return (((void *)0));
4304 }
4305
4306 static struct __ecereNameSpace__ecere__com__Instance * __ecereNameSpace__ecere__com__Module_Load(struct __ecereNameSpace__ecere__com__Instance * fromModule, char * name, int importAccess, unsigned int ensureCOM)
4307 {
4308 unsigned int (stdcall * Load)(struct __ecereNameSpace__ecere__com__Instance * module) = (((void *)0));
4309 unsigned int (stdcall * Unload)(struct __ecereNameSpace__ecere__com__Instance * module) = (((void *)0));
4310 struct __ecereNameSpace__ecere__com__Instance * module;
4311
4312 for(module = ((struct __ecereNameSpace__ecere__com__Application *)(((char *)((struct __ecereNameSpace__ecere__com__Module *)(((char *)fromModule + structSize_Instance)))->application + structSize_Module)))->allModules.first; module; module = ((struct __ecereNameSpace__ecere__com__Module *)(((char *)module + structSize_Instance)))->next)
4313 {
4314 if(!strcmp(((struct __ecereNameSpace__ecere__com__Module *)(((char *)module + structSize_Instance)))->name, name))
4315 break;
4316 }
4317 if(ensureCOM && (!strcmp(name, "ecereCOM") || !strcmp(name, "ecere")))
4318 {
4319 for(module = ((struct __ecereNameSpace__ecere__com__Application *)(((char *)((struct __ecereNameSpace__ecere__com__Module *)(((char *)fromModule + structSize_Instance)))->application + structSize_Module)))->allModules.first; module; module = ((struct __ecereNameSpace__ecere__com__Module *)(((char *)module + structSize_Instance)))->next)
4320 {
4321 if(!strcmp(((struct __ecereNameSpace__ecere__com__Module *)(((char *)module + structSize_Instance)))->name, "ecere") || !strcmp(((struct __ecereNameSpace__ecere__com__Module *)(((char *)module + structSize_Instance)))->name, "ecereCOM"))
4322 break;
4323 }
4324 }
4325 if(!module)
4326 {
4327 void * library = (((void *)0));
4328
4329 if(ensureCOM && !strcmp(name, "ecereCOM"))
4330 {
4331 Load = __ecereDll_Load_ecere;
4332 Unload = __ecereDll_Unload_ecere;
4333 }
4334 else
4335 {
4336 char * libLocation = (((void *)0));
4337
4338 library = Instance_Module_Load(libLocation, name, &Load, &Unload);
4339 }
4340 if(Load)
4341 {
4342 module = (struct __ecereNameSpace__ecere__com__Instance *)__ecereNameSpace__ecere__com__eInstance_New(__ecereNameSpace__ecere__com__eSystem_FindClass(fromModule, "Module"));
4343 ((struct __ecereNameSpace__ecere__com__Module *)(((char *)module + structSize_Instance)))->application = ((struct __ecereNameSpace__ecere__com__Module *)(((char *)fromModule + structSize_Instance)))->application;
4344 ((struct __ecereNameSpace__ecere__com__Module *)(((char *)module + structSize_Instance)))->library = library;
4345 ((struct __ecereNameSpace__ecere__com__Module *)(((char *)module + structSize_Instance)))->name = __ecereNameSpace__ecere__sys__CopyString(name);
4346 ((struct __ecereNameSpace__ecere__com__Module *)(((char *)module + structSize_Instance)))->Unload = Unload;
4347 ((struct __ecereNameSpace__ecere__com__Module *)(((char *)module + structSize_Instance)))->origImportType = 0;
4348 if(!Load(module))
4349 {
4350 __ecereNameSpace__ecere__com__eInstance_Delete((struct __ecereNameSpace__ecere__com__Instance *)module);
4351 module = (((void *)0));
4352 }
4353 }
4354 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Add(&((struct __ecereNameSpace__ecere__com__Application *)(((char *)((struct __ecereNameSpace__ecere__com__Module *)(((char *)fromModule + structSize_Instance)))->application + structSize_Module)))->allModules, module);
4355 }
4356 if(ensureCOM && !strcmp(name, "ecere") && module)
4357 {
4358 name = !strcmp(((struct __ecereNameSpace__ecere__com__Module *)(((char *)module + structSize_Instance)))->name, "ecereCOM") ? "ecere" : "ecereCOM";
4359 if((!Load && !strcmp(((struct __ecereNameSpace__ecere__com__Module *)(((char *)module + structSize_Instance)))->name, "ecereCOM")) || (Load && (!__thisModule || !((struct __ecereNameSpace__ecere__com__Module *)(((char *)__thisModule + structSize_Instance)))->name || !strcmp(((struct __ecereNameSpace__ecere__com__Module *)(((char *)__thisModule + structSize_Instance)))->name, "ecereCOM")) && Load != __ecereDll_Load_ecere))
4360 {
4361 struct __ecereNameSpace__ecere__com__Instance * module;
4362
4363 for(module = ((struct __ecereNameSpace__ecere__com__Application *)(((char *)((struct __ecereNameSpace__ecere__com__Module *)(((char *)fromModule + structSize_Instance)))->application + structSize_Module)))->allModules.first; module; module = ((struct __ecereNameSpace__ecere__com__Module *)(((char *)module + structSize_Instance)))->next)
4364 {
4365 if(!strcmp(((struct __ecereNameSpace__ecere__com__Module *)(((char *)module + structSize_Instance)))->name, name))
4366 break;
4367 }
4368 if(!module)
4369 {
4370 Load = __ecereDll_Load_ecere;
4371 Unload = __ecereDll_Unload_ecere;
4372 module = (struct __ecereNameSpace__ecere__com__Instance *)__ecereNameSpace__ecere__com__eInstance_New(__ecereNameSpace__ecere__com__eSystem_FindClass(fromModule, "Module"));
4373 ((struct __ecereNameSpace__ecere__com__Module *)(((char *)module + structSize_Instance)))->application = ((struct __ecereNameSpace__ecere__com__Module *)(((char *)fromModule + structSize_Instance)))->application;
4374 ((struct __ecereNameSpace__ecere__com__Module *)(((char *)module + structSize_Instance)))->library = (((void *)0));
4375 ((struct __ecereNameSpace__ecere__com__Module *)(((char *)module + structSize_Instance)))->name = __ecereNameSpace__ecere__sys__CopyString(name);
4376 ((struct __ecereNameSpace__ecere__com__Module *)(((char *)module + structSize_Instance)))->Unload = Unload;
4377 if(!Load(module))
4378 {
4379 __ecereNameSpace__ecere__com__eInstance_Delete((struct __ecereNameSpace__ecere__com__Instance *)module);
4380 module = (((void *)0));
4381 }
4382 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Add(&((struct __ecereNameSpace__ecere__com__Application *)(((char *)((struct __ecereNameSpace__ecere__com__Module *)(((char *)fromModule + structSize_Instance)))->application + structSize_Module)))->allModules, module);
4383 }
4384 if(module)
4385 {
4386 if(fromModule)
4387 {
4388 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Add(&((struct __ecereNameSpace__ecere__com__Module *)(((char *)fromModule + structSize_Instance)))->modules, __extension__ ({
4389 struct __ecereNameSpace__ecere__com__SubModule * __ecereInstance1 = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass___ecereNameSpace__ecere__com__SubModule);
4390
4391 __ecereInstance1->module = module, __ecereInstance1->importMode = importAccess, __ecereInstance1;
4392 }));
4393 }
4394 module->_refCount++;
4395 }
4396 }
4397 }
4398 if(module)
4399 {
4400 if(fromModule)
4401 {
4402 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Add(&((struct __ecereNameSpace__ecere__com__Module *)(((char *)fromModule + structSize_Instance)))->modules, __extension__ ({
4403 struct __ecereNameSpace__ecere__com__SubModule * __ecereInstance1 = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass___ecereNameSpace__ecere__com__SubModule);
4404
4405 __ecereInstance1->module = module, __ecereInstance1->importMode = importAccess, __ecereInstance1;
4406 }));
4407 }
4408 module->_refCount++;
4409 }
4410 return module;
4411 }
4412
4413 struct __ecereNameSpace__ecere__com__Instance * __ecereNameSpace__ecere__com__eModule_Load(struct __ecereNameSpace__ecere__com__Instance * fromModule, char * name, int importAccess)
4414 {
4415 return __ecereNameSpace__ecere__com__Module_Load(fromModule, name, importAccess, 0x1);
4416 }
4417
4418 struct __ecereNameSpace__ecere__com__Instance * __ecereNameSpace__ecere__com__eModule_LoadStrict(struct __ecereNameSpace__ecere__com__Instance * fromModule, char * name, int importAccess)
4419 {
4420 return __ecereNameSpace__ecere__com__Module_Load(fromModule, name, importAccess, 0x0);
4421 }
4422
4423 struct __ecereNameSpace__ecere__com__Instance * __ecereNameSpace__ecere__com__eModule_LoadStatic(struct __ecereNameSpace__ecere__com__Instance * fromModule, char * name, int importAccess, unsigned int (* Load)(struct __ecereNameSpace__ecere__com__Instance * module), unsigned int (* Unload)(struct __ecereNameSpace__ecere__com__Instance * module))
4424 {
4425 struct __ecereNameSpace__ecere__com__Instance * module;
4426
4427 for(module = ((struct __ecereNameSpace__ecere__com__Application *)(((char *)((struct __ecereNameSpace__ecere__com__Module *)(((char *)fromModule + structSize_Instance)))->application + structSize_Module)))->allModules.first; module; module = ((struct __ecereNameSpace__ecere__com__Module *)(((char *)module + structSize_Instance)))->next)
4428 {
4429 if(!strcmp(((struct __ecereNameSpace__ecere__com__Module *)(((char *)module + structSize_Instance)))->name, name))
4430 break;
4431 }
4432 if(!module)
4433 {
4434 if(Load)
4435 {
4436 module = (struct __ecereNameSpace__ecere__com__Instance *)__ecereNameSpace__ecere__com__eInstance_New(__ecereNameSpace__ecere__com__eSystem_FindClass(fromModule, "Module"));
4437 ((struct __ecereNameSpace__ecere__com__Module *)(((char *)module + structSize_Instance)))->application = ((struct __ecereNameSpace__ecere__com__Module *)(((char *)fromModule + structSize_Instance)))->application;
4438 ((struct __ecereNameSpace__ecere__com__Module *)(((char *)module + structSize_Instance)))->name = __ecereNameSpace__ecere__sys__CopyString(name);
4439 ((struct __ecereNameSpace__ecere__com__Module *)(((char *)module + structSize_Instance)))->origImportType = 1;
4440 ((struct __ecereNameSpace__ecere__com__Module *)(((char *)module + structSize_Instance)))->Unload = (void *)Unload;
4441 if(!Load(module))
4442 {
4443 __ecereNameSpace__ecere__com__eInstance_Delete((struct __ecereNameSpace__ecere__com__Instance *)module);
4444 module = (((void *)0));
4445 }
4446 }
4447 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Add(&((struct __ecereNameSpace__ecere__com__Application *)(((char *)((struct __ecereNameSpace__ecere__com__Module *)(((char *)fromModule + structSize_Instance)))->application + structSize_Module)))->allModules, module);
4448 }
4449 if(module)
4450 {
4451 if(fromModule)
4452 {
4453 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Add(&((struct __ecereNameSpace__ecere__com__Module *)(((char *)fromModule + structSize_Instance)))->modules, __extension__ ({
4454 struct __ecereNameSpace__ecere__com__SubModule * __ecereInstance1 = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass___ecereNameSpace__ecere__com__SubModule);
4455
4456 __ecereInstance1->module = module, __ecereInstance1->importMode = importAccess, __ecereInstance1;
4457 }));
4458 }
4459 module->_refCount++;
4460 }
4461 return module;
4462 }
4463
4464 void __ecereNameSpace__ecere__com__eModule_Unload(struct __ecereNameSpace__ecere__com__Instance * fromModule, struct __ecereNameSpace__ecere__com__Instance * module)
4465 {
4466 struct __ecereNameSpace__ecere__sys__OldLink * m;
4467
4468 for(m = ((struct __ecereNameSpace__ecere__com__Module *)(((char *)fromModule + structSize_Instance)))->modules.first; m; m = m->next)
4469 {
4470 if(m->data == module)
4471 break;
4472 }
4473 if(m)
4474 {
4475 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Delete(&((struct __ecereNameSpace__ecere__com__Module *)(((char *)fromModule + structSize_Instance)))->modules, m);
4476 (__ecereNameSpace__ecere__com__eInstance_DecRef(module), module = 0);
4477 }
4478 }
4479
4480 void __ecereNameSpace__ecere__com__eEnum_AddFixedValue(struct __ecereNameSpace__ecere__com__Class * _class, char * string, int value)
4481 {
4482 if(_class && _class->type == 4)
4483 {
4484 struct __ecereNameSpace__ecere__com__EnumClassData * data = (struct __ecereNameSpace__ecere__com__EnumClassData *)_class->data;
4485 struct __ecereNameSpace__ecere__sys__NamedLink * item;
4486
4487 for(item = data->values.first; item; item = item->next)
4488 if(!strcmp(item->name, string))
4489 break;
4490 if(!item)
4491 {
4492 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Add(&data->values, __extension__ ({
4493 struct __ecereNameSpace__ecere__sys__NamedLink * __ecereInstance1 = __ecereNameSpace__ecere__com__eSystem_New0(structSize_NamedLink);
4494
4495 __ecereInstance1->data = (void *)value, __ecereInstance1->name = __ecereNameSpace__ecere__sys__CopyString(string), __ecereInstance1;
4496 }));
4497 if(value > data->largest)
4498 data->largest = value;
4499 }
4500 }
4501 }
4502
4503 int __ecereNameSpace__ecere__com__eEnum_AddValue(struct __ecereNameSpace__ecere__com__Class * _class, char * string)
4504 {
4505 if(_class && _class->type == 4)
4506 {
4507 struct __ecereNameSpace__ecere__com__EnumClassData * data = (struct __ecereNameSpace__ecere__com__EnumClassData *)_class->data;
4508 int value = data->largest + 1;
4509 struct __ecereNameSpace__ecere__sys__NamedLink * item;
4510
4511 for(item = data->values.first; item; item = item->next)
4512 if(!strcmp(item->name, string))
4513 break;
4514 if(!item)
4515 {
4516 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Add(&data->values, __extension__ ({
4517 struct __ecereNameSpace__ecere__sys__NamedLink * __ecereInstance1 = __ecereNameSpace__ecere__com__eSystem_New0(structSize_NamedLink);
4518
4519 __ecereInstance1->data = (void *)value, __ecereInstance1->name = __ecereNameSpace__ecere__sys__CopyString(string), __ecereInstance1;
4520 }));
4521 if(value > data->largest)
4522 data->largest = value;
4523 return value;
4524 }
4525 }
4526 return -1;
4527 }
4528
4529 static void __ecereNameSpace__ecere__com__NameSpace_Free(struct __ecereNameSpace__ecere__com__NameSpace * parentNameSpace)
4530 {
4531 struct __ecereNameSpace__ecere__com__NameSpace * nameSpace;
4532
4533 (__ecereNameSpace__ecere__com__eSystem_Delete(parentNameSpace->name), parentNameSpace->name = 0);
4534 while((nameSpace = (struct __ecereNameSpace__ecere__com__NameSpace *)__ecereProp___ecereNameSpace__ecere__sys__BinaryTree_Get_first(&parentNameSpace->nameSpaces)))
4535 {
4536 __ecereNameSpace__ecere__com__NameSpace_Free(nameSpace);
4537 __ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_Delete(&parentNameSpace->nameSpaces, (struct __ecereNameSpace__ecere__sys__BTNode *)nameSpace);
4538 }
4539 }
4540
4541 static void __ecereNameSpace__ecere__com__Application_Destructor(struct __ecereNameSpace__ecere__com__Instance * app)
4542 {
4543 if(((struct __ecereNameSpace__ecere__com__Application *)(((char *)app + structSize_Module)))->parsedCommand)
4544 {
4545 (__ecereNameSpace__ecere__com__eSystem_Delete(((struct __ecereNameSpace__ecere__com__Application *)(((char *)app + structSize_Module)))->argv), ((struct __ecereNameSpace__ecere__com__Application * )(((char * )app + structSize_Module)))->argv = 0);
4546 (__ecereNameSpace__ecere__com__eSystem_Delete(((struct __ecereNameSpace__ecere__com__Application *)(((char *)app + structSize_Module)))->parsedCommand), ((struct __ecereNameSpace__ecere__com__Application * )(((char * )app + structSize_Module)))->parsedCommand = 0);
4547 }
4548 }
4549
4550 static unsigned int __ecereNameSpace__ecere__com__Module_Constructor(struct __ecereNameSpace__ecere__com__Instance * module)
4551 {
4552 ((struct __ecereNameSpace__ecere__com__Module *)(((char *)module + structSize_Instance)))->privateNameSpace.classes.CompareKey = (void *)__ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_CompareString;
4553 ((struct __ecereNameSpace__ecere__com__Module *)(((char *)module + structSize_Instance)))->privateNameSpace.defines.CompareKey = (void *)__ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_CompareString;
4554 ((struct __ecereNameSpace__ecere__com__Module *)(((char *)module + structSize_Instance)))->privateNameSpace.functions.CompareKey = (void *)__ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_CompareString;
4555 ((struct __ecereNameSpace__ecere__com__Module *)(((char *)module + structSize_Instance)))->privateNameSpace.nameSpaces.CompareKey = (void *)__ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_CompareString;
4556 ((struct __ecereNameSpace__ecere__com__Module *)(((char *)module + structSize_Instance)))->publicNameSpace.classes.CompareKey = (void *)__ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_CompareString;
4557 ((struct __ecereNameSpace__ecere__com__Module *)(((char *)module + structSize_Instance)))->publicNameSpace.defines.CompareKey = (void *)__ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_CompareString;
4558 ((struct __ecereNameSpace__ecere__com__Module *)(((char *)module + structSize_Instance)))->publicNameSpace.functions.CompareKey = (void *)__ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_CompareString;
4559 ((struct __ecereNameSpace__ecere__com__Module *)(((char *)module + structSize_Instance)))->publicNameSpace.nameSpaces.CompareKey = (void *)__ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_CompareString;
4560 return 0x1;
4561 }
4562
4563 static void __ecereNameSpace__ecere__com__Module_Destructor(struct __ecereNameSpace__ecere__com__Instance * module)
4564 {
4565 struct __ecereNameSpace__ecere__com__Class * _class;
4566 struct __ecereNameSpace__ecere__com__DefinedExpression * def;
4567 struct __ecereNameSpace__ecere__com__GlobalFunction * function;
4568 struct __ecereNameSpace__ecere__com__Instance * m;
4569 struct __ecereNameSpace__ecere__com__SubModule * handle;
4570
4571 for(m = ((struct __ecereNameSpace__ecere__com__Application *)(((char *)((struct __ecereNameSpace__ecere__com__Module *)(((char *)module + structSize_Instance)))->application + structSize_Module)))->allModules.first; m; m = ((struct __ecereNameSpace__ecere__com__Module *)(((char *)m + structSize_Instance)))->next)
4572 {
4573 struct __ecereNameSpace__ecere__com__SubModule * next;
4574
4575 for(handle = ((struct __ecereNameSpace__ecere__com__Module *)(((char *)m + structSize_Instance)))->modules.first; handle; handle = next)
4576 {
4577 next = handle->next;
4578 if(handle->module == module)
4579 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Delete(&((struct __ecereNameSpace__ecere__com__Module *)(((char *)m + structSize_Instance)))->modules, handle);
4580 }
4581 }
4582 if(((struct __ecereNameSpace__ecere__com__Module *)(((char *)module + structSize_Instance)))->Unload)
4583 {
4584 if(((struct __ecereNameSpace__ecere__com__Module *)(((char *)module + structSize_Instance)))->origImportType == 1)
4585 {
4586 unsigned int (* Unload)(struct __ecereNameSpace__ecere__com__Instance * module) = (void *)((struct __ecereNameSpace__ecere__com__Module *)(((char *)module + structSize_Instance)))->Unload;
4587
4588 Unload(module);
4589 }
4590 else
4591 {
4592 unsigned int (stdcall * Unload)(struct __ecereNameSpace__ecere__com__Instance * module) = (void *)((struct __ecereNameSpace__ecere__com__Module *)(((char *)module + structSize_Instance)))->Unload;
4593
4594 Unload(module);
4595 }
4596 }
4597 {
4598 struct __ecereNameSpace__ecere__com__Instance * ourWorld = __ecereClass___ecereNameSpace__ecere__com__Class->module;
4599 void * ourHandle = (((void *)0));
4600
4601 while((handle = ((struct __ecereNameSpace__ecere__com__Module *)(((char *)module + structSize_Instance)))->modules.last))
4602 {
4603 struct __ecereNameSpace__ecere__com__Instance * depModule = handle->module;
4604
4605 if(depModule == ourWorld)
4606 {
4607 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Remove(&((struct __ecereNameSpace__ecere__com__Module *)(((char *)module + structSize_Instance)))->modules, handle);
4608 ourHandle = handle;
4609 }
4610 else
4611 {
4612 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Delete(&((struct __ecereNameSpace__ecere__com__Module *)(((char *)module + structSize_Instance)))->modules, handle);
4613 (__ecereNameSpace__ecere__com__eInstance_DecRef(depModule), depModule = 0);
4614 }
4615 }
4616 if(ourHandle)
4617 {
4618 (__ecereNameSpace__ecere__com__eSystem_Delete(ourHandle), ourHandle = 0);
4619 (__ecereNameSpace__ecere__com__eInstance_DecRef(ourWorld), ourWorld = 0);
4620 }
4621 }
4622 for(; (_class = ((struct __ecereNameSpace__ecere__com__Module *)(((char *)module + structSize_Instance)))->classes.first); )
4623 {
4624 if(_class->nameSpace)
4625 {
4626 struct __ecereNameSpace__ecere__com__BTNamedLink * classLink = (struct __ecereNameSpace__ecere__com__BTNamedLink *)__ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_FindString(&(*_class->nameSpace).classes, _class->name);
4627 struct __ecereNameSpace__ecere__sys__OldLink * t;
4628
4629 for(t = _class->templatized.first; t; t = t->next)
4630 {
4631 struct __ecereNameSpace__ecere__com__Class * template = t->data;
4632 struct __ecereNameSpace__ecere__com__BTNamedLink * link;
4633
4634 link = (struct __ecereNameSpace__ecere__com__BTNamedLink *)__ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_FindString(&(*template->nameSpace).classes, template->name);
4635 __ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_Delete(&(*template->nameSpace).classes, (struct __ecereNameSpace__ecere__sys__BTNode *)link);
4636 template->nameSpace = (((void *)0));
4637 }
4638 __ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_Delete(&(*_class->nameSpace).classes, (struct __ecereNameSpace__ecere__sys__BTNode *)classLink);
4639 _class->nameSpace = (((void *)0));
4640 }
4641 _class->module = (((void *)0));
4642 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Remove(&((struct __ecereNameSpace__ecere__com__Module *)(((char *)module + structSize_Instance)))->classes, _class);
4643 if(!_class->count || _class->type != 0)
4644 __ecereNameSpace__ecere__com__eClass_Unregister(_class);
4645 else
4646 {
4647 }
4648 }
4649 for(; (def = ((struct __ecereNameSpace__ecere__com__Module *)(((char *)module + structSize_Instance)))->defines.first); )
4650 {
4651 if(def->nameSpace)
4652 {
4653 struct __ecereNameSpace__ecere__com__BTNamedLink * defLink;
4654
4655 for(defLink = (struct __ecereNameSpace__ecere__com__BTNamedLink *)__ecereProp___ecereNameSpace__ecere__sys__BinaryTree_Get_first(&(*def->nameSpace).defines); defLink; defLink = (struct __ecereNameSpace__ecere__com__BTNamedLink *)__ecereProp___ecereNameSpace__ecere__sys__BTNode_Get_next(((struct __ecereNameSpace__ecere__sys__BTNode *)defLink)))
4656 if(defLink->data == def)
4657 {
4658 __ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_Delete(&(*def->nameSpace).defines, (struct __ecereNameSpace__ecere__sys__BTNode *)defLink);
4659 break;
4660 }
4661 }
4662 (__ecereNameSpace__ecere__com__eSystem_Delete(def->name), def->name = 0);
4663 (__ecereNameSpace__ecere__com__eSystem_Delete(def->value), def->value = 0);
4664 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Delete(&((struct __ecereNameSpace__ecere__com__Module *)(((char *)module + structSize_Instance)))->defines, def);
4665 }
4666 for(; (function = ((struct __ecereNameSpace__ecere__com__Module *)(((char *)module + structSize_Instance)))->functions.first); )
4667 {
4668 if(function->nameSpace)
4669 {
4670 struct __ecereNameSpace__ecere__com__BTNamedLink * functionLink;
4671
4672 for(functionLink = (struct __ecereNameSpace__ecere__com__BTNamedLink *)__ecereProp___ecereNameSpace__ecere__sys__BinaryTree_Get_first(&(*function->nameSpace).functions); functionLink; functionLink = (struct __ecereNameSpace__ecere__com__BTNamedLink *)__ecereProp___ecereNameSpace__ecere__sys__BTNode_Get_next(((struct __ecereNameSpace__ecere__sys__BTNode *)functionLink)))
4673 if(functionLink->data == function)
4674 {
4675 __ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_Delete(&(*function->nameSpace).functions, (struct __ecereNameSpace__ecere__sys__BTNode *)functionLink);
4676 break;
4677 }
4678 }
4679 (__ecereNameSpace__ecere__com__eSystem_Delete(function->name), function->name = 0);
4680 (__ecereNameSpace__ecere__com__eSystem_Delete(function->dataTypeString), function->dataTypeString = 0);
4681 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Delete(&((struct __ecereNameSpace__ecere__com__Module *)(((char *)module + structSize_Instance)))->functions, function);
4682 }
4683 (__ecereNameSpace__ecere__com__eSystem_Delete(((struct __ecereNameSpace__ecere__com__Module *)(((char *)module + structSize_Instance)))->name), ((struct __ecereNameSpace__ecere__com__Module * )(((char * )module + structSize_Instance)))->name = 0);
4684 __ecereNameSpace__ecere__com__NameSpace_Free(&((struct __ecereNameSpace__ecere__com__Module *)(((char *)module + structSize_Instance)))->privateNameSpace);
4685 __ecereNameSpace__ecere__com__NameSpace_Free(&((struct __ecereNameSpace__ecere__com__Module *)(((char *)module + structSize_Instance)))->publicNameSpace);
4686 if(module != ((struct __ecereNameSpace__ecere__com__Module *)(((char *)module + structSize_Instance)))->application)
4687 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Remove(&((struct __ecereNameSpace__ecere__com__Application *)(((char *)((struct __ecereNameSpace__ecere__com__Module *)(((char *)module + structSize_Instance)))->application + structSize_Module)))->allModules, module);
4688 else
4689 __ecereNameSpace__ecere__com__NameSpace_Free(&((struct __ecereNameSpace__ecere__com__Application *)(((char *)((struct __ecereNameSpace__ecere__com__Module *)(((char *)module + structSize_Instance)))->application + structSize_Module)))->systemNameSpace);
4690 Instance_Module_Free(((struct __ecereNameSpace__ecere__com__Module *)(((char *)module + structSize_Instance)))->library);
4691 }
4692
4693 static long long __ecereNameSpace__ecere__com__GetEnumSize(struct __ecereNameSpace__ecere__com__Class * _class)
4694 {
4695 struct __ecereNameSpace__ecere__com__EnumClassData * data = (struct __ecereNameSpace__ecere__com__EnumClassData *)_class->data;
4696
4697 return data->largest + 1;
4698 }
4699
4700 char * strlwr(char * string)
4701 {
4702 int c;
4703
4704 for(c = 0; string[c]; c++)
4705 if(string[c] >= 'A' && string[c] <= 'Z')
4706 string[c] += 'a' - 'A';
4707 return string;
4708 }
4709
4710 char * strupr(char * string)
4711 {
4712 int c;
4713
4714 for(c = 0; string[c]; c++)
4715 if(string[c] >= 'a' && string[c] <= 'z')
4716 string[c] -= 'a' - 'A';
4717 return string;
4718 }
4719
4720 struct __ecereNameSpace__ecere__com__DefinedExpression * __ecereNameSpace__ecere__com__eSystem_RegisterDefine(char * name, char * value, struct __ecereNameSpace__ecere__com__Instance * module, int declMode)
4721 {
4722 struct __ecereNameSpace__ecere__com__NameSpace * nameSpace = (((void *)0));
4723 int start = 0, c;
4724
4725 nameSpace = (declMode == 1) ? &((struct __ecereNameSpace__ecere__com__Module *)(((char *)module + structSize_Instance)))->publicNameSpace : &((struct __ecereNameSpace__ecere__com__Module *)(((char *)module + structSize_Instance)))->privateNameSpace;
4726 if(declMode == 4)
4727 nameSpace = &((struct __ecereNameSpace__ecere__com__Application *)(((char *)((struct __ecereNameSpace__ecere__com__Module *)(((char *)module + structSize_Instance)))->application + structSize_Module)))->systemNameSpace;
4728 if(declMode != 3)
4729 {
4730 for(c = 0; name[c]; c++)
4731 {
4732 if(name[c] == '.' || (name[c] == ':' && name[c + 1] == ':'))
4733 {
4734 struct __ecereNameSpace__ecere__com__NameSpace * newSpace;
4735 char * spaceName = __ecereNameSpace__ecere__com___malloc(c - start + 1);
4736
4737 strncpy(spaceName, name + start, c - start);
4738 spaceName[c - start] = '\0';
4739 newSpace = (struct __ecereNameSpace__ecere__com__NameSpace *)__ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_FindString(&(*nameSpace).nameSpaces, spaceName);
4740 if(!newSpace)
4741 {
4742 newSpace = __ecereNameSpace__ecere__com__eSystem_New0(sizeof(struct __ecereNameSpace__ecere__com__NameSpace) * (1));
4743 (*newSpace).classes.CompareKey = (void *)__ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_CompareString;
4744 (*newSpace).defines.CompareKey = (void *)__ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_CompareString;
4745 (*newSpace).functions.CompareKey = (void *)__ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_CompareString;
4746 (*newSpace).nameSpaces.CompareKey = (void *)__ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_CompareString;
4747 (*newSpace).name = spaceName;
4748 (*newSpace).parent = nameSpace;
4749 __ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_Add(&(*nameSpace).nameSpaces, (struct __ecereNameSpace__ecere__sys__BTNode *)newSpace);
4750 }
4751 else
4752 (__ecereNameSpace__ecere__com__eSystem_Delete(spaceName), spaceName = 0);
4753 nameSpace = newSpace;
4754 if(name[c] == ':')
4755 c++;
4756 start = c + 1;
4757 }
4758 }
4759 }
4760 else
4761 c = strlen(name);
4762 if(c - start && !__ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_FindString(&(*nameSpace).defines, name + start))
4763 {
4764 struct __ecereNameSpace__ecere__com__DefinedExpression * def = (def = __ecereNameSpace__ecere__com__eSystem_New0(structSize_DefinedExpression), def->name = __ecereNameSpace__ecere__sys__CopyString(name), def->nameSpace = nameSpace, def->value = __ecereNameSpace__ecere__sys__CopyString(value), def);
4765
4766 __ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_Add(&(*nameSpace).defines, (struct __ecereNameSpace__ecere__sys__BTNode *)__extension__ ({
4767 struct __ecereNameSpace__ecere__com__BTNamedLink * __ecereInstance1 = __ecereNameSpace__ecere__com__eSystem_New0(structSize_BTNamedLink);
4768
4769 __ecereInstance1->name = def->name + start, __ecereInstance1->data = def, __ecereInstance1;
4770 }));
4771 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Add(&((struct __ecereNameSpace__ecere__com__Module *)(((char *)module + structSize_Instance)))->defines, def);
4772 return def;
4773 }
4774 return (((void *)0));
4775 }
4776
4777 struct __ecereNameSpace__ecere__com__GlobalFunction * __ecereNameSpace__ecere__com__eSystem_RegisterFunction(char * name, char * type, void * func, struct __ecereNameSpace__ecere__com__Instance * module, int declMode)
4778 {
4779 struct __ecereNameSpace__ecere__com__NameSpace * nameSpace = (((void *)0));
4780 int start = 0, c;
4781
4782 nameSpace = (declMode == 1) ? &((struct __ecereNameSpace__ecere__com__Module *)(((char *)module + structSize_Instance)))->publicNameSpace : &((struct __ecereNameSpace__ecere__com__Module *)(((char *)module + structSize_Instance)))->privateNameSpace;
4783 if(declMode == 4)
4784 nameSpace = &((struct __ecereNameSpace__ecere__com__Application *)(((char *)((struct __ecereNameSpace__ecere__com__Module *)(((char *)module + structSize_Instance)))->application + structSize_Module)))->systemNameSpace;
4785 if(declMode != 3)
4786 {
4787 for(c = 0; name[c]; c++)
4788 {
4789 if(name[c] == '.' || (name[c] == ':' && name[c + 1] == ':'))
4790 {
4791 struct __ecereNameSpace__ecere__com__NameSpace * newSpace;
4792 char * spaceName = __ecereNameSpace__ecere__com___malloc(c - start + 1);
4793
4794 strncpy(spaceName, name + start, c - start);
4795 spaceName[c - start] = '\0';
4796 newSpace = (struct __ecereNameSpace__ecere__com__NameSpace *)__ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_FindString(&(*nameSpace).nameSpaces, spaceName);
4797 if(!newSpace)
4798 {
4799 newSpace = __ecereNameSpace__ecere__com__eSystem_New0(sizeof(struct __ecereNameSpace__ecere__com__NameSpace) * (1));
4800 (*newSpace).classes.CompareKey = (void *)__ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_CompareString;
4801 (*newSpace).defines.CompareKey = (void *)__ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_CompareString;
4802 (*newSpace).functions.CompareKey = (void *)__ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_CompareString;
4803 (*newSpace).nameSpaces.CompareKey = (void *)__ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_CompareString;
4804 (*newSpace).name = spaceName;
4805 (*newSpace).parent = nameSpace;
4806 __ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_Add(&(*nameSpace).nameSpaces, (struct __ecereNameSpace__ecere__sys__BTNode *)newSpace);
4807 }
4808 else
4809 (__ecereNameSpace__ecere__com__eSystem_Delete(spaceName), spaceName = 0);
4810 nameSpace = newSpace;
4811 if(name[c] == ':')
4812 c++;
4813 start = c + 1;
4814 }
4815 }
4816 }
4817 else
4818 c = strlen(name);
4819 if(c - start && !__ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_FindString(&(*nameSpace).functions, name + start))
4820 {
4821 struct __ecereNameSpace__ecere__com__GlobalFunction * function = (function = __ecereNameSpace__ecere__com__eSystem_New0(structSize_GlobalFunction), function->name = __ecereNameSpace__ecere__sys__CopyString(name), function->nameSpace = nameSpace, function->dataTypeString = __ecereNameSpace__ecere__sys__CopyString(type), function->function = func, function->module = module, function);
4822
4823 __ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_Add(&(*nameSpace).functions, (struct __ecereNameSpace__ecere__sys__BTNode *)__extension__ ({
4824 struct __ecereNameSpace__ecere__com__BTNamedLink * __ecereInstance1 = __ecereNameSpace__ecere__com__eSystem_New0(structSize_BTNamedLink);
4825
4826 __ecereInstance1->name = function->name + start, __ecereInstance1->data = function, __ecereInstance1;
4827 }));
4828 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Add(&((struct __ecereNameSpace__ecere__com__Module *)(((char *)module + structSize_Instance)))->functions, function);
4829 return function;
4830 }
4831 return (((void *)0));
4832 }
4833
4834 struct __ecereNameSpace__ecere__com__DefinedExpression * __ecereNameSpace__ecere__com__eSystem_FindDefine(struct __ecereNameSpace__ecere__com__Instance * module, char * name)
4835 {
4836 if(name && module)
4837 {
4838 struct __ecereNameSpace__ecere__com__BTNamedLink * link;
4839
4840 link = __ecereNameSpace__ecere__com__SearchNameSpace(&((struct __ecereNameSpace__ecere__com__Application *)(((char *)((struct __ecereNameSpace__ecere__com__Module *)(((char *)module + structSize_Instance)))->application + structSize_Module)))->systemNameSpace, name, &(*((struct __ecereNameSpace__ecere__com__NameSpace *)0)).defines);
4841 if(link)
4842 return link->data;
4843 link = __ecereNameSpace__ecere__com__SearchModule(module, name, &(*((struct __ecereNameSpace__ecere__com__NameSpace *)0)).defines, 0x1);
4844 if(link)
4845 return link->data;
4846 }
4847 return (((void *)0));
4848 }
4849
4850 struct __ecereNameSpace__ecere__com__GlobalFunction * __ecereNameSpace__ecere__com__eSystem_FindFunction(struct __ecereNameSpace__ecere__com__Instance * module, char * name)
4851 {
4852 if(name && module)
4853 {
4854 struct __ecereNameSpace__ecere__com__BTNamedLink * link;
4855
4856 link = __ecereNameSpace__ecere__com__SearchNameSpace(&((struct __ecereNameSpace__ecere__com__Application *)(((char *)((struct __ecereNameSpace__ecere__com__Module *)(((char *)module + structSize_Instance)))->application + structSize_Module)))->systemNameSpace, name, &(*((struct __ecereNameSpace__ecere__com__NameSpace *)0)).functions);
4857 if(link)
4858 return link->data;
4859 link = __ecereNameSpace__ecere__com__SearchModule(module, name, &(*((struct __ecereNameSpace__ecere__com__NameSpace *)0)).functions, 0x1);
4860 if(link)
4861 return link->data;
4862 }
4863 return (((void *)0));
4864 }
4865
4866 void * __ecereNameSpace__ecere__com__eSystem_Renew(void * memory, unsigned int size)
4867 {
4868 return __ecereNameSpace__ecere__com___realloc(memory, size);
4869 }
4870
4871 void * __ecereNameSpace__ecere__com__eSystem_Renew0(void * memory, unsigned int size)
4872 {
4873 return __ecereNameSpace__ecere__com___crealloc(memory, size);
4874 }
4875
4876 void * __ecereNameSpace__ecere__com__eSystem_New(unsigned int size)
4877 {
4878 return __ecereNameSpace__ecere__com___malloc(size);
4879 }
4880
4881 void * __ecereNameSpace__ecere__com__eSystem_New0(unsigned int size)
4882 {
4883 return __ecereNameSpace__ecere__com___calloc(1, size);
4884 }
4885
4886 void __ecereNameSpace__ecere__com__eSystem_Delete(void * memory)
4887 {
4888 if(memory)
4889 __ecereNameSpace__ecere__com___free(memory);
4890 }
4891
4892 void __ecereNameSpace__ecere__com__eInstance_FireSelfWatchers(struct __ecereNameSpace__ecere__com__Instance * instance, struct __ecereNameSpace__ecere__com__Property * _property)
4893 {
4894 if(instance && _property && _property->selfWatchable)
4895 {
4896 struct __ecereNameSpace__ecere__com__Class * _class;
4897
4898 for(_class = ((struct __ecereNameSpace__ecere__com__Instance *)(char *)instance)->_class; _class; _class = _class->base)
4899 {
4900 struct __ecereNameSpace__ecere__com__SelfWatcher * selfWatcher, * next;
4901
4902 for(selfWatcher = _class->selfWatchers.first; selfWatcher; selfWatcher = next)
4903 {
4904 next = selfWatcher->next;
4905 if(selfWatcher->_property == _property)
4906 selfWatcher->callback(instance);
4907 }
4908 }
4909 }
4910 }
4911
4912 void __ecereNameSpace__ecere__com__eInstance_FireWatchers(struct __ecereNameSpace__ecere__com__Instance * instance, struct __ecereNameSpace__ecere__com__Property * _property)
4913 {
4914 if(instance && _property && _property->isWatchable)
4915 {
4916 struct __ecereNameSpace__ecere__com__Instance * module = ((struct __ecereNameSpace__ecere__com__Instance *)(char *)instance)->_class ? ((struct __ecereNameSpace__ecere__com__Instance *)(char *)instance)->_class->module : (((void *)0));
4917 struct __ecereNameSpace__ecere__com__Instance * application = module ? ((struct __ecereNameSpace__ecere__com__Module *)(((char *)module + structSize_Instance)))->application : (((void *)0));
4918 int flags = application ? (unsigned int)((struct __ecereNameSpace__ecere__com__Application *)(((char *)application + structSize_Module)))->isGUIApp : 0;
4919 unsigned int inCompiler = (flags & 8) ? 0x1 : 0x0;
4920 unsigned int force32Bits = (flags & 4) ? 0x1 : 0x0;
4921
4922 if(!force32Bits || !inCompiler)
4923 {
4924 struct __ecereNameSpace__ecere__sys__OldList * watchers = (struct __ecereNameSpace__ecere__sys__OldList *)((unsigned char *)instance + _property->watcherOffset);
4925 struct __ecereNameSpace__ecere__com__Watcher * watcher, * next;
4926
4927 for(watcher = (*watchers).first; watcher; watcher = next)
4928 {
4929 next = watcher->next;
4930 watcher->callback(watcher->object, instance);
4931 }
4932 }
4933 }
4934 }
4935
4936 void __ecereNameSpace__ecere__com__eProperty_Watchable(struct __ecereNameSpace__ecere__com__Property * _property)
4937 {
4938 if(!_property->isWatchable)
4939 {
4940 struct __ecereNameSpace__ecere__com__Class * _class = _property->_class;
4941
4942 if(!_class->computeSize)
4943 {
4944 _property->watcherOffset = _class->structSize;
4945 _class->structSize += sizeof(struct __ecereNameSpace__ecere__sys__OldList);
4946 __ecereNameSpace__ecere__com__FixDerivativesBase(_class, _class);
4947 }
4948 _property->isWatchable = 0x1;
4949 }
4950 }
4951
4952 void __ecereNameSpace__ecere__com__eClass_DestructionWatchable(struct __ecereNameSpace__ecere__com__Class * _class)
4953 {
4954 if(!_class->destructionWatchOffset)
4955 {
4956 _class->destructionWatchOffset = _class->structSize;
4957 _class->structSize += sizeof(struct __ecereNameSpace__ecere__sys__OldList);
4958 __ecereNameSpace__ecere__com__FixDerivativesBase(_class, _class);
4959 }
4960 }
4961
4962 void __ecereNameSpace__ecere__com__eProperty_SelfWatch(struct __ecereNameSpace__ecere__com__Class * _class, char * name, void (* callback)(void *))
4963 {
4964 if(_class)
4965 {
4966 struct __ecereNameSpace__ecere__com__Property * _property = __ecereNameSpace__ecere__com__eClass_FindProperty(_class, name, _class->module);
4967
4968 if(!_property)
4969 _property = __ecereNameSpace__ecere__com__eClass_AddProperty(_class, name, (((void *)0)), (((void *)0)), (((void *)0)), 4);
4970 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Add(&_class->selfWatchers, __extension__ ({
4971 struct __ecereNameSpace__ecere__com__SelfWatcher * __ecereInstance1 = __ecereNameSpace__ecere__com__eSystem_New0(structSize_SelfWatcher);
4972
4973 __ecereInstance1->_property = _property, __ecereInstance1->callback = callback, __ecereInstance1;
4974 }));
4975 _property->selfWatchable = 0x1;
4976 }
4977 }
4978
4979 void __ecereNameSpace__ecere__com__eInstance_Watch(void * instance, struct __ecereNameSpace__ecere__com__Property * _property, void * object, void (* callback)(void *, void *))
4980 {
4981 if(_property->isWatchable)
4982 {
4983 struct __ecereNameSpace__ecere__sys__OldList * watchers = (struct __ecereNameSpace__ecere__sys__OldList *)((unsigned char *)instance + _property->watcherOffset);
4984
4985 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Add((&*watchers), __extension__ ({
4986 struct __ecereNameSpace__ecere__com__Watcher * __ecereInstance1 = __ecereNameSpace__ecere__com__eSystem_New0(structSize_Watcher);
4987
4988 __ecereInstance1->callback = callback, __ecereInstance1->object = object, __ecereInstance1;
4989 }));
4990 }
4991 }
4992
4993 void __ecereNameSpace__ecere__com__eInstance_WatchDestruction(struct __ecereNameSpace__ecere__com__Instance * instance, struct __ecereNameSpace__ecere__com__Instance * object, void (* callback)(struct __ecereNameSpace__ecere__com__Instance *, struct __ecereNameSpace__ecere__com__Instance *))
4994 {
4995 struct __ecereNameSpace__ecere__sys__OldList * watchers = (struct __ecereNameSpace__ecere__sys__OldList *)((unsigned char *)instance + ((struct __ecereNameSpace__ecere__com__Instance *)(char *)instance)->_class->destructionWatchOffset);
4996
4997 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Add((&*watchers), __extension__ ({
4998 struct __ecereNameSpace__ecere__com__Watcher * __ecereInstance1 = __ecereNameSpace__ecere__com__eSystem_New0(structSize_Watcher);
4999
5000 __ecereInstance1->callback = callback, __ecereInstance1->object = object, __ecereInstance1;
5001 }));
5002 }
5003
5004 void __ecereNameSpace__ecere__com__eInstance_StopWatching(struct __ecereNameSpace__ecere__com__Instance * instance, struct __ecereNameSpace__ecere__com__Property * _property, struct __ecereNameSpace__ecere__com__Instance * object)
5005 {
5006 if(instance && (!_property || _property->isWatchable))
5007 {
5008 if(_property)
5009 {
5010 struct __ecereNameSpace__ecere__sys__OldList * watchers = (struct __ecereNameSpace__ecere__sys__OldList *)((unsigned char *)instance + _property->watcherOffset);
5011 struct __ecereNameSpace__ecere__com__Watcher * watcher;
5012
5013 for(watcher = (*watchers).first; watcher; watcher = watcher->next)
5014 if(watcher->object == object)
5015 {
5016 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Delete((&*watchers), watcher);
5017 break;
5018 }
5019 }
5020 else
5021 {
5022 struct __ecereNameSpace__ecere__com__Class * _class, * base;
5023
5024 for(_class = ((struct __ecereNameSpace__ecere__com__Instance *)(char *)instance)->_class; _class; _class = base)
5025 {
5026 if(_class->destructionWatchOffset)
5027 {
5028 struct __ecereNameSpace__ecere__sys__OldList * watchers = (struct __ecereNameSpace__ecere__sys__OldList *)((unsigned char *)instance + _class->destructionWatchOffset);
5029 struct __ecereNameSpace__ecere__com__Watcher * watcher;
5030
5031 for(watcher = (*watchers).first; watcher; watcher = watcher->next)
5032 {
5033 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Delete((&*watchers), watcher);
5034 break;
5035 }
5036 }
5037 for(_property = (struct __ecereNameSpace__ecere__com__Property *)_class->membersAndProperties.first; _property; _property = _property->next)
5038 {
5039 if(_property->isProperty && _property->isWatchable)
5040 {
5041 struct __ecereNameSpace__ecere__sys__OldList * watchers = (struct __ecereNameSpace__ecere__sys__OldList *)((unsigned char *)instance + _property->watcherOffset);
5042 struct __ecereNameSpace__ecere__com__Watcher * watcher;
5043
5044 for(watcher = (*watchers).first; watcher; watcher = watcher->next)
5045 if(watcher->object == object)
5046 {
5047 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Delete((&*watchers), watcher);
5048 break;
5049 }
5050 }
5051 }
5052 base = _class->base;
5053 if(base && base->type == 1000)
5054 base = (((void *)0));
5055 }
5056 }
5057 }
5058 }
5059
5060 struct __ecereNameSpace__ecere__com__Class * __ecereNameSpace__ecere__com__eClass_GetDesigner(struct __ecereNameSpace__ecere__com__Class * _class)
5061 {
5062 for(; _class; _class = _class->base)
5063 {
5064 if(_class->designerClass)
5065 return (struct __ecereNameSpace__ecere__com__Class *)__ecereNameSpace__ecere__com__eSystem_FindClass(_class->module, _class->designerClass);
5066 }
5067 return (((void *)0));
5068 }
5069
5070 struct __ecereNameSpace__ecere__com__Class * __ecereNameSpace__ecere__com__eInstance_GetDesigner(struct __ecereNameSpace__ecere__com__Instance * instance)
5071 {
5072 if(instance)
5073 return __ecereNameSpace__ecere__com__eClass_GetDesigner(((struct __ecereNameSpace__ecere__com__Instance *)(char *)instance)->_class);
5074 return (((void *)0));
5075 }
5076
5077 unsigned int __ecereNameSpace__ecere__com__LocateModule(char * name, char * fileName)
5078 {
5079 return Instance_LocateModule(name, fileName);
5080 }
5081
5082 extern void __ecereNameSpace__ecere__com__InitializeDataTypes1(struct __ecereNameSpace__ecere__com__Instance * module);
5083
5084 extern void __ecereNameSpace__ecere__com__InitializeDataTypes(struct __ecereNameSpace__ecere__com__Instance * module);
5085
5086 extern double sin(struct __ecereNameSpace__ecere__com__Instance * number);
5087
5088 extern double sinh(struct __ecereNameSpace__ecere__com__Instance * number);
5089
5090 extern double cosh(struct __ecereNameSpace__ecere__com__Instance * number);
5091
5092 extern double tanh(struct __ecereNameSpace__ecere__com__Instance * number);
5093
5094 extern double sqrt(double number);
5095
5096 extern double cos(struct __ecereNameSpace__ecere__com__Instance * number);
5097
5098 extern double tan(struct __ecereNameSpace__ecere__com__Instance * number);
5099
5100 extern struct __ecereNameSpace__ecere__com__Instance * atan2(double y, double x);
5101
5102 extern struct __ecereNameSpace__ecere__com__Instance * asin(double number);
5103
5104 extern struct __ecereNameSpace__ecere__com__Instance * acos(double number);
5105
5106 extern struct __ecereNameSpace__ecere__com__Instance * atan(double number);
5107
5108 extern double pow(double number, double number2);
5109
5110 extern double fmod(double x, double y);
5111
5112 extern double fabs(double number);
5113
5114 extern double log(double number);
5115
5116 extern double log10(double number);
5117
5118 extern double ceil(double number);
5119
5120 extern double floor(double number);
5121
5122 extern double exp(double number);
5123
5124 extern void qsort(void * , size_t, size_t, int (* )(void * , void * ));
5125
5126 extern int system(const char * );
5127
5128 extern int atoi(const char * );
5129
5130 extern double atof(const char * );
5131
5132 extern int tolower(int);
5133
5134 extern int toupper(int);
5135
5136 extern unsigned int isdigit(int);
5137
5138 extern char *  getenv(const char *  name);
5139
5140 extern int rename(const char *  oldpath, const char *  newpath);
5141
5142 extern char *  strncat(char * , const char * , size_t n);
5143
5144 extern int strcasecmp(const char * , const char * );
5145
5146 extern int strncasecmp(const char * , const char * , size_t n);
5147
5148 extern int strncmp(const char * , const char * , size_t n);
5149
5150 extern int vsprintf(char * , const char * , __builtin_va_list);
5151
5152 extern int puts(char * );
5153
5154 extern int fputs(char * , void *  stream);
5155
5156 extern int isalnum(int c);
5157
5158 extern int isalpha(int c);
5159
5160 extern int islower(int c);
5161
5162 extern int isupper(int c);
5163
5164 extern int isprint(int c);
5165
5166 static void __ecereNameSpace__ecere__com__LoadCOM(struct __ecereNameSpace__ecere__com__Instance * module)
5167 {
5168 unsigned int force64Bits = ((unsigned int)((struct __ecereNameSpace__ecere__com__Application *)(((char *)((struct __ecereNameSpace__ecere__com__Module *)(((char *)module + structSize_Instance)))->application + structSize_Module)))->isGUIApp & 2) ? 0x1 : 0x0;
5169 unsigned int force32Bits = ((unsigned int)((struct __ecereNameSpace__ecere__com__Application *)(((char *)((struct __ecereNameSpace__ecere__com__Module *)(((char *)module + structSize_Instance)))->application + structSize_Module)))->isGUIApp & 4) ? 0x1 : 0x0;
5170 unsigned int inCompiler = ((unsigned int)((struct __ecereNameSpace__ecere__com__Application *)(((char *)((struct __ecereNameSpace__ecere__com__Module *)(((char *)module + structSize_Instance)))->application + structSize_Module)))->isGUIApp & 8) ? 0x1 : 0x0;
5171 int pointerSize = force64Bits ? 8 : force32Bits ? 4 : sizeof(void *);
5172 struct __ecereNameSpace__ecere__com__Class * applicationClass;
5173 struct __ecereNameSpace__ecere__com__Class * enumClass, * structClass, * boolClass;
5174 struct __ecereNameSpace__ecere__com__Class * moduleClass;
5175 struct __ecereNameSpace__ecere__com__Class * baseClass = __ecereNameSpace__ecere__com__eSystem_RegisterClass(0, "class", (((void *)0)), 0, 0, (((void *)0)), (((void *)0)), module, 4, 1);
5176
5177 baseClass->type = 1000;
5178 baseClass->memberOffset = 0;
5179 baseClass->offset = 0;
5180 baseClass->structSize = 0;
5181 baseClass->typeSize = 0;
5182 {
5183 struct __ecereNameSpace__ecere__com__Class * instanceClass = __ecereNameSpace__ecere__com__eSystem_RegisterClass(0, "ecere::com::Instance", (((void *)0)), 0, 0, (((void *)0)), (((void *)0)), module, 4, 1);
5184
5185 instanceClass->type = 1000;
5186 instanceClass->fixed = 0x1;
5187 instanceClass->memberOffset = 0;
5188 instanceClass->offset = 0;
5189 instanceClass->memberID = -3;
5190 instanceClass->startMemberID = -3;
5191 __ecereNameSpace__ecere__com__eClass_AddDataMember(instanceClass, "_vTbl", "int (**)()", pointerSize, pointerSize, 1);
5192 __ecereNameSpace__ecere__com__eClass_AddDataMember(instanceClass, "_class", "ecere::com::Class", pointerSize, pointerSize, 1);
5193 __ecereNameSpace__ecere__com__eClass_AddDataMember(instanceClass, "_refCount", "int", sizeof(int), sizeof(int), 1);
5194 }
5195 __ecereNameSpace__ecere__com__InitializeDataTypes1(module);
5196 enumClass = __ecereNameSpace__ecere__com__eSystem_RegisterClass(0, "enum", (((void *)0)), 0, force64Bits ? 40 : sizeof(struct __ecereNameSpace__ecere__com__EnumClassData), (((void *)0)), (((void *)0)), module, 4, 1);
5197 __ecereNameSpace__ecere__com__eClass_AddClassProperty(enumClass, "enumSize", "int", (((void *)0)), __ecereNameSpace__ecere__com__GetEnumSize)->constant = 0x1;
5198 enumClass->type = 1000;
5199 (__ecereNameSpace__ecere__com__eSystem_Delete(enumClass->dataTypeString), enumClass->dataTypeString = 0);
5200 enumClass->dataTypeString = __ecereNameSpace__ecere__sys__CopyString("int");
5201 structClass = __ecereNameSpace__ecere__com__eSystem_RegisterClass(0, "struct", (((void *)0)), 0, 0, (((void *)0)), (((void *)0)), module, 4, 1);
5202 structClass->type = 1000;
5203 structClass->memberOffset = 0;
5204 structClass->offset = 0;
5205 structClass->structSize = 0;
5206 structClass->typeSize = 0;
5207 __ecereNameSpace__ecere__com__InitializeDataTypes(module);
5208 boolClass = __ecereNameSpace__ecere__com__eSystem_RegisterClass(4, "bool", "uint", 0, 0, (((void *)0)), (((void *)0)), module, 4, 1);
5209 __ecereNameSpace__ecere__com__eEnum_AddFixedValue(boolClass, "true", (unsigned int)0x1);
5210 __ecereNameSpace__ecere__com__eEnum_AddFixedValue(boolClass, "false", (unsigned int)0x0);
5211 moduleClass = __ecereNameSpace__ecere__com__eSystem_RegisterClass(0, "ecere::com::Module", (((void *)0)), force64Bits ? 8 + 32 + 32 + 32 + 32 + 8 + 8 + 8 + 8 + 8 + 4 + 4 + (32 + 8 + 8 + 4 * 32) + (32 + 8 + 8 + 4 * 32) : sizeof(struct __ecereNameSpace__ecere__com__Module), 0, (void *)__ecereNameSpace__ecere__com__Module_Constructor, (void *)__ecereNameSpace__ecere__com__Module_Destructor, module, 4, 1);
5212 __ecereNameSpace__ecere__com__eClass_AddVirtualMethod(moduleClass, "OnLoad", "bool()", (((void *)0)), 1);
5213 __ecereNameSpace__ecere__com__eClass_AddVirtualMethod(moduleClass, "OnUnload", "void()", (((void *)0)), 1);
5214 __ecereNameSpace__ecere__com__eClass_AddMethod(moduleClass, "Load", "Module(char * name, AccessMode importAccess)", __ecereNameSpace__ecere__com__eModule_Load, 1);
5215 __ecereNameSpace__ecere__com__eClass_AddMethod(moduleClass, "Unload", "void(Module module)", __ecereNameSpace__ecere__com__eModule_Unload, 1);
5216 __ecereNameSpace__ecere__com__eClass_AddDataMember(moduleClass, "application", "Application", pointerSize, pointerSize, 1);
5217 __ecereNameSpace__ecere__com__eClass_AddDataMember(moduleClass, "classes", "OldList", force64Bits ? 32 : force32Bits ? 20 : sizeof(struct __ecereNameSpace__ecere__sys__OldList), pointerSize, 1);
5218 __ecereNameSpace__ecere__com__eClass_AddDataMember(moduleClass, "defines", "OldList", force64Bits ? 32 : force32Bits ? 20 : sizeof(struct __ecereNameSpace__ecere__sys__OldList), pointerSize, 1);
5219 __ecereNameSpace__ecere__com__eClass_AddDataMember(moduleClass, "functions", "OldList", force64Bits ? 32 : force32Bits ? 20 : sizeof(struct __ecereNameSpace__ecere__sys__OldList), pointerSize, 1);
5220 __ecereNameSpace__ecere__com__eClass_AddDataMember(moduleClass, "modules", "OldList", force64Bits ? 32 : force32Bits ? 20 : sizeof(struct __ecereNameSpace__ecere__sys__OldList), pointerSize, 1);
5221 __ecereNameSpace__ecere__com__eClass_AddDataMember(moduleClass, "prev", "Module", pointerSize, pointerSize, 1);
5222 __ecereNameSpace__ecere__com__eClass_AddDataMember(moduleClass, "next", "Module", pointerSize, pointerSize, 1);
5223 __ecereNameSpace__ecere__com__eClass_AddDataMember(moduleClass, "name", "char *", pointerSize, pointerSize, 1);
5224 __ecereNameSpace__ecere__com__eClass_AddDataMember(moduleClass, "library", "void *", pointerSize, pointerSize, 1);
5225 __ecereNameSpace__ecere__com__eClass_AddDataMember(moduleClass, "Unload", "void *", pointerSize, pointerSize, 1);
5226 __ecereNameSpace__ecere__com__eClass_AddDataMember(moduleClass, "importType", "ImportType", sizeof(int), 4, 1);
5227 __ecereNameSpace__ecere__com__eClass_AddDataMember(moduleClass, "origImportType", "ImportType", sizeof(int), 4, 1);
5228 __ecereNameSpace__ecere__com__eClass_AddDataMember(moduleClass, "privateNameSpace", "NameSpace", force64Bits ? (32 + 8 + 8 + 4 * 32) : force32Bits ? (16 + 4 + 4 + 4 * 16) : sizeof(struct __ecereNameSpace__ecere__com__NameSpace), pointerSize, 1);
5229 __ecereNameSpace__ecere__com__eClass_AddDataMember(moduleClass, "publicNameSpace", "NameSpace", force64Bits ? (32 + 8 + 8 + 4 * 32) : force32Bits ? (16 + 4 + 4 + 4 * 16) : sizeof(struct __ecereNameSpace__ecere__com__NameSpace), pointerSize, 1);
5230 moduleClass->fixed = 0x1;
5231 moduleClass->count++;
5232 if(inCompiler && force32Bits)
5233 moduleClass->structSize = 12 + 4 + 20 + 20 + 20 + 20 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + (16 + 4 + 4 + 4 * 16) + (16 + 4 + 4 + 4 * 16);
5234 applicationClass = __ecereNameSpace__ecere__com__eSystem_RegisterClass(0, "ecere::com::Application", "Module", force64Bits ? (8 + 8 + 4 + 4 + 32 + 8 + 176) : sizeof(struct __ecereNameSpace__ecere__com__Application), 0, (((void *)0)), (void *)__ecereNameSpace__ecere__com__Application_Destructor, module, 4, 1);
5235 if(inCompiler && force32Bits)
5236 {
5237 applicationClass->offset = 12 + 4 + 20 + 20 + 20 + 20 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + (16 + 4 + 4 + 4 * 16) + (16 + 4 + 4 + 4 * 16);
5238 applicationClass->structSize = applicationClass->offset + (4 + 4 + 4 + 4 + 20 + 4 + 88);
5239 }
5240 __ecereNameSpace__ecere__com__eClass_AddVirtualMethod(applicationClass, "Main", "void()", (((void *)0)), 1);
5241 __ecereNameSpace__ecere__com__eClass_AddDataMember(applicationClass, "argc", "int", sizeof(int), 4, 1);
5242 __ecereNameSpace__ecere__com__eClass_AddDataMember(applicationClass, "argv", "char **", pointerSize, pointerSize, 1);
5243 __ecereNameSpace__ecere__com__eClass_AddDataMember(applicationClass, "exitCode", "int", sizeof(int), 4, 1);
5244 __ecereNameSpace__ecere__com__eClass_AddDataMember(applicationClass, "isGUIApp", "bool", sizeof(unsigned int), 4, 1);
5245 __ecereNameSpace__ecere__com__eClass_AddDataMember(applicationClass, "allModules", "OldList", force64Bits ? 32 : force32Bits ? 20 : sizeof(struct __ecereNameSpace__ecere__sys__OldList), pointerSize, 1);
5246 __ecereNameSpace__ecere__com__eClass_AddDataMember(applicationClass, "parsedCommand", "char *", pointerSize, pointerSize, 1);
5247 __ecereNameSpace__ecere__com__eClass_AddDataMember(applicationClass, "systemNameSpace", "NameSpace", force64Bits ? (32 + 8 + 8 + 4 * 32) : force32Bits ? (16 + 4 + 4 + 4 * 16) : sizeof(struct __ecereNameSpace__ecere__com__NameSpace), pointerSize, 1);
5248 applicationClass->fixed = 0x1;
5249 applicationClass->count++;
5250 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("sin", "double sin(Angle number)", sin, module, 4);
5251 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("sinh", "double sinh(Angle number)", sinh, module, 4);
5252 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("cosh", "double cosh(Angle number)", cosh, module, 4);
5253 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("tanh", "double tanh(Angle number)", tanh, module, 4);
5254 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("sqrt", "double sqrt(double number)", sqrt, module, 4);
5255 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("cos", "double cos(Angle number)", cos, module, 4);
5256 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("tan", "double tan(Angle number)", tan, module, 4);
5257 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("atan2", "Angle atan2(double y, double x)", atan2, module, 4);
5258 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("asin", "Angle asin(double number)", asin, module, 4);
5259 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("acos", "Angle acos(double number)", acos, module, 4);
5260 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("atan", "Angle atan(double number)", atan, module, 4);
5261 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("pow", "double pow(double number, double number2)", pow, module, 4);
5262 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("fmod", "double fmod(double x, double y)", fmod, module, 4);
5263 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("fabs", "double fabs(double number)", fabs, module, 4);
5264 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("log", "double log(double number)", log, module, 4);
5265 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("log10", "double log10(double number)", log10, module, 4);
5266 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("ceil", "double ceil(double number)", ceil, module, 4);
5267 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("floor", "double floor(double number)", floor, module, 4);
5268 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("exp", "double exp(double number)", exp, module, 4);
5269 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("qsort", "void qsort(void *, uintsize, uintsize, int (*)(void *, void *))", qsort, module, 4);
5270 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("strtod", "double strtod(char*, char**)", strtod, module, 4);
5271 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("strtol", "int strtol(char*, char**, int base)", strtol, module, 4);
5272 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("system", "int system(const char*)", system, module, 4);
5273 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("atoi", "int atoi(const char*)", atoi, module, 4);
5274 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("atof", "double atof(const char*)", atof, module, 4);
5275 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("tolower", "int tolower(int)", tolower, module, 4);
5276 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("toupper", "int toupper(int)", toupper, module, 4);
5277 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("isdigit", "bool isdigit(int)", isdigit, module, 4);
5278 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("memset", "void * memset(void * area, int value, uintsize count)", memset, module, 4);
5279 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("getenv", "char * getenv(const char * name)", getenv, module, 4);
5280 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("rename", "int rename(const char *oldpath, const char *newpath)", rename, module, 4);
5281 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("strlen", "uintsize strlen(const char *)", strlen, module, 4);
5282 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("strcat", "char * strcat(char *, const char *)", strcat, module, 4);
5283 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("strncat", "char * strncat(char *, const char *, uintsize n)", strncat, module, 4);
5284 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("strchr", "char * strchr(const char *, int)", strchr, module, 4);
5285 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("strstr", "char * strstr(const char *, const char *)", strstr, module, 4);
5286 __ecereNameSpace__ecere__com__eSystem_RegisterDefine("fstrcmp", "(GetRuntimePlatform() == win32) ? strcmpi : strcmp", module, 4);
5287 __ecereNameSpace__ecere__com__eSystem_RegisterDefine("strcmpi", "strcasecmp", module, 4);
5288 __ecereNameSpace__ecere__com__eSystem_RegisterDefine("strnicmp", "strncasecmp", module, 4);
5289 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("strcasecmp", "int strcasecmp(const char *, const char *)", strcasecmp, module, 4);
5290 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("strncasecmp", "int strncasecmp(const char *, const char *, uintsize n)", strncasecmp, module, 4);
5291 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("strcmp", "int strcmp(const char *, const char *)", strcmp, module, 4);
5292 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("strncmp", "int strncmp(const char *, const char *, uintsize n)", strncmp, module, 4);
5293 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("strlwr", "char * strlwr(char *)", strlwr, module, 4);
5294 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("strupr", "char * strupr(char *)", strupr, module, 4);
5295 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("strcpy", "char * strcpy(char *, const char *)", strcpy, module, 4);
5296 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("strncpy", "char * strncpy(char *, const char *, uintsize n)", strncpy, module, 4);
5297 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("memcpy", "void * memcpy(void *, const void *, uintsize size)", memcpy, module, 4);
5298 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("memmove", "void * memmove(void *, const void *, uintsize size)", memmove, module, 4);
5299 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("sprintf", "int sprintf(char *, char *, ...)", sprintf, module, 4);
5300 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("snprintf", "int sprintf(char *, uintsize, char *, ...)", snprintf, module, 4);
5301 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("printf", "int printf(char *, ...)", printf, module, 4);
5302 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("vsprintf", "int vsprintf(char*, const char*, __builtin_va_list)", vsprintf, module, 4);
5303 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("vsnprintf", "int vsnprintf(char*, uintsize, const char*, __builtin_va_list)", vsnprintf, module, 4);
5304 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("puts", "int puts(char *)", puts, module, 4);
5305 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("fputs", "int fputs(char *, void * stream)", fputs, module, 4);
5306 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("isalnum", "int isalnum(int c)", isalnum, module, 4);
5307 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("isspace", "int isspace(int c)", isspace, module, 4);
5308 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("isalpha", "int isalpha(int c)", isalpha, module, 4);
5309 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("islower", "int islower(int c)", islower, module, 4);
5310 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("isupper", "int isupper(int c)", isupper, module, 4);
5311 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("isprint", "int isprint(int c)", isprint, module, 4);
5312 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("strtoul", "unsigned long strtoul(const char * nptr, char ** endptr, int base)", strtoul, module, 4);
5313 }
5314
5315 struct __ecereNameSpace__ecere__com__Instance * __ecereNameSpace__ecere__com____ecere_COM_Initialize(unsigned int guiApp, int argc, char * argv[])
5316 {
5317 struct __ecereNameSpace__ecere__com__Instance * app;
5318
5319 app = __ecereNameSpace__ecere__com___calloc(1, structSize_Application);
5320 __ecereNameSpace__ecere__com__Module_Constructor(app);
5321 ((struct __ecereNameSpace__ecere__com__Application *)(((char *)app + structSize_Module)))->systemNameSpace.classes.CompareKey = (void *)__ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_CompareString;
5322 ((struct __ecereNameSpace__ecere__com__Application *)(((char *)app + structSize_Module)))->systemNameSpace.defines.CompareKey = (void *)__ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_CompareString;
5323 ((struct __ecereNameSpace__ecere__com__Application *)(((char *)app + structSize_Module)))->systemNameSpace.functions.CompareKey = (void *)__ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_CompareString;
5324 ((struct __ecereNameSpace__ecere__com__Application *)(((char *)app + structSize_Module)))->systemNameSpace.nameSpaces.CompareKey = (void *)__ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_CompareString;
5325 Instance_COM_Initialize(argc, argv, &((struct __ecereNameSpace__ecere__com__Application *)(((char *)app + structSize_Module)))->parsedCommand, &((struct __ecereNameSpace__ecere__com__Application *)(((char *)app + structSize_Module)))->argc, &((struct __ecereNameSpace__ecere__com__Application *)(((char *)app + structSize_Module)))->argv);
5326 ((struct __ecereNameSpace__ecere__com__Module *)(((char *)app + structSize_Instance)))->application = app;
5327 ((struct __ecereNameSpace__ecere__com__Application *)(((char *)app + structSize_Module)))->allModules.offset = structSize_Instance + (unsigned int)&(*((struct __ecereNameSpace__ecere__com__Module *)0)).prev;
5328 ((struct __ecereNameSpace__ecere__com__Application *)(((char *)app + structSize_Module)))->isGUIApp = guiApp;
5329 __ecereNameSpace__ecere__com__LoadCOM(app);
5330 ((struct __ecereNameSpace__ecere__com__Instance *)(char *)app)->_class = __ecereNameSpace__ecere__com__eSystem_FindClass(app, "Application");
5331 return app;
5332 }
5333
5334 struct __ecereNameSpace__ecere__com__ClassTemplateParameter * __ecereNameSpace__ecere__com__eClass_AddTemplateParameter(struct __ecereNameSpace__ecere__com__Class * _class, char * name, int type, void * info, struct __ecereNameSpace__ecere__com__ClassTemplateArgument * defaultArg)
5335 {
5336 if(_class && name)
5337 {
5338 struct __ecereNameSpace__ecere__com__ClassTemplateParameter * param;
5339
5340 for(param = _class->templateParams.first; param; param = param->next)
5341 {
5342 if(!strcmp(param->name, name))
5343 return param;
5344 }
5345 param = __extension__ ({
5346 struct __ecereNameSpace__ecere__com__ClassTemplateParameter * __ecereInstance1 = __ecereNameSpace__ecere__com__eSystem_New0(structSize_ClassTemplateParameter);
5347
5348 __ecereInstance1->name = __ecereNameSpace__ecere__sys__CopyString(name), __ecereInstance1->type = type, __ecereInstance1->dataTypeString = (type == 1) ? info : __ecereNameSpace__ecere__sys__CopyString(info), __ecereInstance1;
5349 });
5350 if(defaultArg != (((void *)0)))
5351 {
5352 param->defaultArg = *defaultArg;
5353 __ecereNameSpace__ecere__com__CopyTemplateArg(param, &param->defaultArg);
5354 }
5355 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Add(&_class->templateParams, param);
5356 return param;
5357 }
5358 return (((void *)0));
5359 }
5360
5361 void __ecereNameSpace__ecere__com__eClass_DoneAddingTemplateParameters(struct __ecereNameSpace__ecere__com__Class * base)
5362 {
5363 if(base)
5364 {
5365 struct __ecereNameSpace__ecere__sys__OldLink * derivative;
5366 struct __ecereNameSpace__ecere__com__ClassTemplateParameter * param;
5367
5368 {
5369 void * first = base->templateParams.first;
5370 int count = base->templateParams.count;
5371
5372 base->templateParams.first = (((void *)0));
5373 base->templateParams.count = 0;
5374 __ecereNameSpace__ecere__com__FreeTemplateArgs(base);
5375 (__ecereNameSpace__ecere__com__eSystem_Delete(base->templateArgs), base->templateArgs = 0);
5376 __ecereNameSpace__ecere__com__FreeTemplatesDerivatives(base);
5377 base->templateParams.first = first;
5378 base->templateParams.count = count;
5379 }
5380 for(param = base->templateParams.first; param; param = param->next)
5381 {
5382 if(param->type == 1 && param->defaultArg.memberString)
5383 {
5384 struct __ecereNameSpace__ecere__com__Class * memberClass = base;
5385 char * colon = strstr(param->defaultArg.memberString, "::");
5386 char * memberName;
5387
5388 if(colon)
5389 {
5390 char className[1024];
5391 struct __ecereNameSpace__ecere__com__Class * sClass;
5392
5393 memcpy(className, param->defaultArg.memberString, colon - param->defaultArg.memberString);
5394 className[colon - param->defaultArg.memberString] = '\0';
5395 memberName = colon + 2;
5396 for(sClass = base; sClass; sClass = sClass->base)
5397 {
5398 struct __ecereNameSpace__ecere__com__ClassTemplateParameter * cParam;
5399 struct __ecereNameSpace__ecere__com__Class * nextClass;
5400 int id = 0;
5401
5402 for(nextClass = sClass->base; nextClass; nextClass = nextClass->base)
5403 id += nextClass->templateParams.count;
5404 if(sClass == base || base->templateArgs)
5405 {
5406 for(cParam = sClass->templateParams.first; cParam; cParam = cParam->next)
5407 {
5408 if(cParam->type == 0 && !strcmp(cParam->name, className))
5409 strcpy(className, (sClass == base) ? cParam->defaultArg.dataTypeString : base->templateArgs[id].dataTypeString);
5410 id++;
5411 }
5412 }
5413 }
5414 memberClass = __ecereNameSpace__ecere__com__eSystem_FindClass(base->module, className);
5415 if(!memberClass)
5416 memberClass = __ecereNameSpace__ecere__com__eSystem_FindClass(((struct __ecereNameSpace__ecere__com__Module *)(((char *)base->module + structSize_Instance)))->application, className);
5417 }
5418 else
5419 memberName = param->defaultArg.memberString;
5420 if(memberClass)
5421 {
5422 switch(param->memberType)
5423 {
5424 case 0:
5425 param->defaultArg.member = __ecereNameSpace__ecere__com__eClass_FindDataMember(memberClass, memberName, memberClass->module, (((void *)0)), (((void *)0)));
5426 break;
5427 case 1:
5428 param->defaultArg.method = __ecereNameSpace__ecere__com__eClass_FindMethod(memberClass, memberName, memberClass->module);
5429 break;
5430 case 2:
5431 param->defaultArg.prop = __ecereNameSpace__ecere__com__eClass_FindProperty(memberClass, memberName, memberClass->module);
5432 break;
5433 }
5434 }
5435 }
5436 }
5437 __ecereNameSpace__ecere__com__FixDerivativesBase(base, base);
5438 }
5439 }
5440
5441 static void __ecereNameSpace__ecere__com__FreeTemplatesDerivatives(struct __ecereNameSpace__ecere__com__Class * base)
5442 {
5443 struct __ecereNameSpace__ecere__sys__OldLink * derivative, * templateLink;
5444
5445 for(derivative = base->derivatives.first; derivative; derivative = derivative->next)
5446 {
5447 struct __ecereNameSpace__ecere__com__Class * _class = derivative->data;
5448
5449 if(_class->templateArgs)
5450 {
5451 __ecereNameSpace__ecere__com__FreeTemplateArgs(_class);
5452 (__ecereNameSpace__ecere__com__eSystem_Delete(_class->templateArgs), _class->templateArgs = 0);
5453 }
5454 __ecereNameSpace__ecere__com__FreeTemplatesDerivatives(_class);
5455 }
5456 for(templateLink = base->templatized.first; templateLink; templateLink = templateLink->next)
5457 {
5458 struct __ecereNameSpace__ecere__com__Class * _class = templateLink->data;
5459
5460 if(_class->templateArgs)
5461 {
5462 __ecereNameSpace__ecere__com__FreeTemplateArgs(_class);
5463 (__ecereNameSpace__ecere__com__eSystem_Delete(_class->templateArgs), _class->templateArgs = 0);
5464 }
5465 __ecereNameSpace__ecere__com__FreeTemplatesDerivatives(_class);
5466 }
5467 }
5468
5469 static const char * __ecereNameSpace__ecere__com__platformNames[4] =
5470 {
5471 "", "win32", "linux", "apple"
5472 };
5473
5474 static const int __ecereNameSpace__ecere__com__firstPlatform = 1;
5475
5476 static struct __ecereNameSpace__ecere__com__Property * __ecereProp___ecereNameSpace__ecere__com__Platform_char__PTR_, * __ecerePropM___ecereNameSpace__ecere__com__Platform_char__PTR_;
5477
5478 static const int __ecereNameSpace__ecere__com__lastPlatform = 3;
5479
5480 static struct __ecereNameSpace__ecere__com__Class * __ecereClass___ecereNameSpace__ecere__com__Platform;
5481
5482 int __ecereVMethodID_class_OnGetString;
5483
5484 char *  __ecereProp___ecereNameSpace__ecere__com__Platform_Get_char__PTR_(int this)
5485 {
5486 return ((char *  (*)(struct __ecereNameSpace__ecere__com__Class *, void *, char *  tempString, void *  fieldData, unsigned int *  needClass))__ecereClass___ecereNameSpace__ecere__com__Platform->_vTbl[__ecereVMethodID_class_OnGetString])(__ecereClass___ecereNameSpace__ecere__com__Platform, &this, (((void *)0)), (((void *)0)), (((void *)0)));
5487 }
5488
5489 int __ecereProp___ecereNameSpace__ecere__com__Platform_Set_char__PTR_(char *  value)
5490 {
5491 if(value)
5492 {
5493 int c;
5494
5495 for(c = __ecereNameSpace__ecere__com__firstPlatform; c <= __ecereNameSpace__ecere__com__lastPlatform; c++)
5496 if(!strcasecmp(value, __ecereNameSpace__ecere__com__platformNames[c]))
5497 return c;
5498 }
5499 return 0;
5500 }
5501
5502 char * __ecereMethod___ecereNameSpace__ecere__com__Platform_OnGetString(struct __ecereNameSpace__ecere__com__Class * class, int * this, char * tempString, void * fieldData, unsigned int * needClass)
5503 {
5504 if((*this) >= __ecereNameSpace__ecere__com__firstPlatform && (*this) <= __ecereNameSpace__ecere__com__lastPlatform)
5505 {
5506 if(tempString)
5507 strcpy(tempString, __ecereNameSpace__ecere__com__platformNames[*(int *)this]);
5508 return __ecereNameSpace__ecere__com__platformNames[*(int *)this];
5509 }
5510 if(tempString && tempString[0])
5511 tempString[0] = '\0';
5512 return (((void *)0));
5513 }
5514
5515 unsigned int __ecereMethod___ecereNameSpace__ecere__com__Platform_OnGetDataFromString(struct __ecereNameSpace__ecere__com__Class * class, int * this, char * string)
5516 {
5517 (*this) = __ecereProp___ecereNameSpace__ecere__com__Platform_Set_char__PTR_(string);
5518 return (unsigned int)*(int *)this;
5519 }
5520
5521 extern int runtimePlatform;
5522
5523 int __ecereNameSpace__ecere__com__GetRuntimePlatform()
5524 {
5525 return runtimePlatform;
5526 }
5527
5528 struct __ecereNameSpace__ecere__com__ObjectInfo
5529 {
5530 struct __ecereNameSpace__ecere__com__ObjectInfo * prev, * next;
5531 struct __ecereNameSpace__ecere__com__Instance * instance;
5532 char * name;
5533 struct __ecereNameSpace__ecere__com__Instance * instCode;
5534 unsigned int deleted;
5535 struct __ecereNameSpace__ecere__com__ObjectInfo * oClass;
5536 struct __ecereNameSpace__ecere__sys__OldList instances;
5537 struct __ecereNameSpace__ecere__com__Instance * classDefinition;
5538 unsigned int modified;
5539 } __attribute__ ((gcc_struct));
5540
5541 static struct __ecereNameSpace__ecere__com__Class * __ecereClass___ecereNameSpace__ecere__com__ObjectInfo;
5542
5543 static struct __ecereNameSpace__ecere__com__Property * __ecereProp___ecereNameSpace__ecere__com__DesignerBase_classDesigner, * __ecerePropM___ecereNameSpace__ecere__com__DesignerBase_classDesigner;
5544
5545 static struct __ecereNameSpace__ecere__com__Property * __ecereProp___ecereNameSpace__ecere__com__DesignerBase_objectClass, * __ecerePropM___ecereNameSpace__ecere__com__DesignerBase_objectClass;
5546
5547 static struct __ecereNameSpace__ecere__com__Property * __ecereProp___ecereNameSpace__ecere__com__DesignerBase_isDragging, * __ecerePropM___ecereNameSpace__ecere__com__DesignerBase_isDragging;
5548
5549 struct __ecereNameSpace__ecere__com__DesignerBase
5550 {
5551 struct __ecereNameSpace__ecere__com__Instance * classDesigner;
5552 char * objectClass;
5553 unsigned int isDragging;
5554 } __attribute__ ((gcc_struct));
5555
5556 static struct __ecereNameSpace__ecere__com__Class * __ecereClass___ecereNameSpace__ecere__com__DesignerBase;
5557
5558 struct __ecereNameSpace__ecere__com__Instance * __ecereProp___ecereNameSpace__ecere__com__DesignerBase_Get_classDesigner(struct __ecereNameSpace__ecere__com__Instance * this)
5559 {
5560 struct __ecereNameSpace__ecere__com__DesignerBase * __ecerePointer___ecereNameSpace__ecere__com__DesignerBase = (struct __ecereNameSpace__ecere__com__DesignerBase *)(this ? (((char *)this) + __ecereClass___ecereNameSpace__ecere__com__DesignerBase->offset) : 0);
5561
5562 return __ecerePointer___ecereNameSpace__ecere__com__DesignerBase->classDesigner;
5563 }
5564
5565 void __ecereProp___ecereNameSpace__ecere__com__DesignerBase_Set_classDesigner(struct __ecereNameSpace__ecere__com__Instance * this, struct __ecereNameSpace__ecere__com__Instance * value)
5566 {
5567 struct __ecereNameSpace__ecere__com__DesignerBase * __ecerePointer___ecereNameSpace__ecere__com__DesignerBase = (struct __ecereNameSpace__ecere__com__DesignerBase *)(this ? (((char *)this) + __ecereClass___ecereNameSpace__ecere__com__DesignerBase->offset) : 0);
5568
5569 __ecerePointer___ecereNameSpace__ecere__com__DesignerBase->classDesigner = value;
5570 __ecereNameSpace__ecere__com__eInstance_FireSelfWatchers(this, __ecereProp___ecereNameSpace__ecere__com__DesignerBase_classDesigner), __ecereNameSpace__ecere__com__eInstance_FireSelfWatchers(this, __ecerePropM___ecereNameSpace__ecere__com__DesignerBase_classDesigner);
5571 }
5572
5573 char *  __ecereProp___ecereNameSpace__ecere__com__DesignerBase_Get_objectClass(struct __ecereNameSpace__ecere__com__Instance * this)
5574 {
5575 struct __ecereNameSpace__ecere__com__DesignerBase * __ecerePointer___ecereNameSpace__ecere__com__DesignerBase = (struct __ecereNameSpace__ecere__com__DesignerBase *)(this ? (((char *)this) + __ecereClass___ecereNameSpace__ecere__com__DesignerBase->offset) : 0);
5576
5577 return __ecerePointer___ecereNameSpace__ecere__com__DesignerBase->objectClass;
5578 }
5579
5580 void __ecereProp___ecereNameSpace__ecere__com__DesignerBase_Set_objectClass(struct __ecereNameSpace__ecere__com__Instance * this, char *  value)
5581 {
5582 struct __ecereNameSpace__ecere__com__DesignerBase * __ecerePointer___ecereNameSpace__ecere__com__DesignerBase = (struct __ecereNameSpace__ecere__com__DesignerBase *)(this ? (((char *)this) + __ecereClass___ecereNameSpace__ecere__com__DesignerBase->offset) : 0);
5583
5584 __ecerePointer___ecereNameSpace__ecere__com__DesignerBase->objectClass = value;
5585 __ecereNameSpace__ecere__com__eInstance_FireSelfWatchers(this, __ecereProp___ecereNameSpace__ecere__com__DesignerBase_objectClass), __ecereNameSpace__ecere__com__eInstance_FireSelfWatchers(this, __ecerePropM___ecereNameSpace__ecere__com__DesignerBase_objectClass);
5586 }
5587
5588 unsigned int __ecereProp___ecereNameSpace__ecere__com__DesignerBase_Get_isDragging(struct __ecereNameSpace__ecere__com__Instance * this)
5589 {
5590 struct __ecereNameSpace__ecere__com__DesignerBase * __ecerePointer___ecereNameSpace__ecere__com__DesignerBase = (struct __ecereNameSpace__ecere__com__DesignerBase *)(this ? (((char *)this) + __ecereClass___ecereNameSpace__ecere__com__DesignerBase->offset) : 0);
5591
5592 return __ecerePointer___ecereNameSpace__ecere__com__DesignerBase->isDragging;
5593 }
5594
5595 void __ecereProp___ecereNameSpace__ecere__com__DesignerBase_Set_isDragging(struct __ecereNameSpace__ecere__com__Instance * this, unsigned int value)
5596 {
5597 struct __ecereNameSpace__ecere__com__DesignerBase * __ecerePointer___ecereNameSpace__ecere__com__DesignerBase = (struct __ecereNameSpace__ecere__com__DesignerBase *)(this ? (((char *)this) + __ecereClass___ecereNameSpace__ecere__com__DesignerBase->offset) : 0);
5598
5599 __ecerePointer___ecereNameSpace__ecere__com__DesignerBase->isDragging = value;
5600 __ecereNameSpace__ecere__com__eInstance_FireSelfWatchers(this, __ecereProp___ecereNameSpace__ecere__com__DesignerBase_isDragging), __ecereNameSpace__ecere__com__eInstance_FireSelfWatchers(this, __ecerePropM___ecereNameSpace__ecere__com__DesignerBase_isDragging);
5601 }
5602
5603 static struct __ecereNameSpace__ecere__com__Class * __ecereClass___ecereNameSpace__ecere__com__ClassDesignerBase;
5604
5605 struct __ecereNameSpace__ecere__com__Instance * __ecereNameSpace__ecere__com__activeDesigner;
5606
5607 void __ecereNameSpace__ecere__com__SetActiveDesigner(struct __ecereNameSpace__ecere__com__Instance * designer)
5608 {
5609 __ecereNameSpace__ecere__com__activeDesigner = designer;
5610 }
5611
5612 struct __ecereNameSpace__ecere__com__Instance * __ecereNameSpace__ecere__com__GetActiveDesigner()
5613 {
5614 return __ecereNameSpace__ecere__com__activeDesigner;
5615 }
5616
5617
5618
5619 unsigned int __ecereNameSpace__ecere__sys__UTF8Validate(char * source)
5620 {
5621 if(source)
5622 {
5623 int c;
5624
5625 for(c = 0; source[c]; )
5626 {
5627 unsigned char ch = source[c];
5628 unsigned int codePoint = 0;
5629 int numBytes = 1;
5630 int i;
5631 unsigned char mask = (unsigned char)0x7F;
5632
5633 if(ch & (unsigned char)0x80)
5634 {
5635 if(ch & (unsigned char)0x40)
5636 {
5637 mask >>= 2;
5638 numBytes++;
5639 if(ch & (unsigned char)0x20)
5640 {
5641 numBytes++;
5642 mask >>= 1;
5643 if(ch & (unsigned char)0x10)
5644 {
5645 if(ch & (unsigned char)0x08)
5646 return 0x0;
5647 numBytes++;
5648 mask >>= 1;
5649 }
5650 }
5651 }
5652 else
5653 return 0x0;
5654 }
5655 for(i = 0; i < numBytes && (ch = source[c]); i++, c++)
5656 {
5657 codePoint <<= 6;
5658 codePoint |= ch & mask;
5659 mask = (unsigned char)0x3F;
5660 if(i > 1)
5661 {
5662 if(!(ch & (unsigned char)0x80) || (ch & (unsigned char)0x40))
5663 return 0x0;
5664 }
5665 }
5666 if(i < numBytes)
5667 return 0x0;
5668 if(codePoint > 0x10FFFF || (codePoint >= 0xD800 && codePoint <= 0xDFFF) || (codePoint < 0x80 && numBytes > 1) || (codePoint < 0x800 && numBytes > 2) || (codePoint < 0x10000 && numBytes > 3))
5669 return 0x0;
5670 }
5671 }
5672 return 0x1;
5673 }
5674
5675 int __ecereNameSpace__ecere__sys__ISO8859_1toUTF8(char * source, char * dest, int max)
5676 {
5677 int c;
5678 int d = 0;
5679
5680 for(c = 0; source[c]; c++)
5681 {
5682 unsigned int ch = ((unsigned char *)source)[c];
5683
5684 if(ch < 0x80)
5685 {
5686 if(d + 1 >= max)
5687 break;
5688 dest[d++] = (char)ch;
5689 }
5690 else if(ch < 0x800)
5691 {
5692 if(d + 2 >= max)
5693 break;
5694 dest[d++] = (unsigned char)0xC0 | (unsigned char)((ch & 0x7C0) >> 6);
5695 dest[d++] = (unsigned char)0x80 | (unsigned char)(ch & 0x03F);
5696 }
5697 else if(ch < 0x10000)
5698 {
5699 if(d + 3 >= max)
5700 break;
5701 dest[d++] = (unsigned char)0xE0 | (unsigned char)((ch & 0xF000) >> 12);
5702 dest[d++] = (unsigned char)0x80 | (unsigned char)((ch & 0xFC0) >> 6);
5703 dest[d++] = (unsigned char)0x80 | (unsigned char)(ch & 0x03F);
5704 }
5705 else
5706 {
5707 if(d + 4 >= max)
5708 break;
5709 dest[d++] = (unsigned char)0xF0 | (unsigned char)((ch & 0x1C0000) >> 18);
5710 dest[d++] = (unsigned char)0x80 | (unsigned char)((ch & 0x3F000) >> 12);
5711 dest[d++] = (unsigned char)0x80 | (unsigned char)((ch & 0xFC0) >> 6);
5712 dest[d++] = (unsigned char)0x80 | (unsigned char)(ch & 0x03F);
5713 }
5714 }
5715 dest[d] = (char)0;
5716 return d;
5717 }
5718
5719 char * __ecereNameSpace__ecere__sys__UTF16toUTF8(unsigned short * source)
5720 {
5721 int c;
5722 int d = 0;
5723 int len;
5724 char * dest;
5725 unsigned short u16;
5726 unsigned int invert = 0x0;
5727
5728 for(len = 0; source[len]; len++)
5729 ;
5730 dest = __ecereNameSpace__ecere__com__eSystem_New(sizeof(char) * (len * 3 + 1));
5731 for(c = 0; (u16 = source[c]); c++)
5732 {
5733 unsigned int ch;
5734
5735 if(!c && (u16 == (unsigned short)0xFFFE || u16 == (unsigned short)0xFEFF))
5736 {
5737 if(u16 == (unsigned short)0xFFFE)
5738 invert = 0x1;
5739 continue;
5740 }
5741 if(invert)
5742 {
5743 u16 = ((u16 & (unsigned short)0xFF00) >> (unsigned short)8) | ((u16 & (unsigned short)0x00FF) << (unsigned short)8);
5744 }
5745 if(u16 < (unsigned short)0xD800 || u16 > (unsigned short)0xDBFF)
5746 ch = u16;
5747 else
5748 ch = (u16 << 10) + source[c++] + (0x10000 - (0xD800 << 10) - 0xDC00);
5749 if(ch < 0x80)
5750 {
5751 dest[d++] = (char)ch;
5752 }
5753 else if(ch < 0x800)
5754 {
5755 dest[d++] = (unsigned char)0xC0 | (unsigned char)((ch & 0x7C0) >> 6);
5756 dest[d++] = (unsigned char)0x80 | (unsigned char)(ch & 0x03F);
5757 }
5758 else if(ch < 0x10000)
5759 {
5760 dest[d++] = (unsigned char)0xE0 | (unsigned char)((ch & 0xF000) >> 12);
5761 dest[d++] = (unsigned char)0x80 | (unsigned char)((ch & 0xFC0) >> 6);
5762 dest[d++] = (unsigned char)0x80 | (unsigned char)(ch & 0x03F);
5763 }
5764 else
5765 {
5766 dest[d++] = (unsigned char)0xF0 | (unsigned char)((ch & 0x1C0000) >> 18);
5767 dest[d++] = (unsigned char)0x80 | (unsigned char)((ch & 0x3F000) >> 12);
5768 dest[d++] = (unsigned char)0x80 | (unsigned char)((ch & 0xFC0) >> 6);
5769 dest[d++] = (unsigned char)0x80 | (unsigned char)(ch & 0x03F);
5770 }
5771 }
5772 dest[d] = (char)0;
5773 dest = __ecereNameSpace__ecere__com__eSystem_Renew(dest, sizeof(char) * (d + 1));
5774 return dest;
5775 }
5776
5777 int __ecereNameSpace__ecere__sys__UTF16toUTF8Buffer(unsigned short * source, unsigned char * dest, int max)
5778 {
5779 int c;
5780 int d = 0;
5781 unsigned short u16;
5782
5783 for(c = 0; (u16 = source[c]); c++)
5784 {
5785 unsigned int ch;
5786
5787 if(u16 < (unsigned short)0xD800 || u16 > (unsigned short)0xDBFF)
5788 ch = u16;
5789 else
5790 ch = (u16 << 10) + source[c++] + (0x10000 - (0xD800 << 10) - 0xDC00);
5791 if(ch < 0x80)
5792 {
5793 if(d + 1 >= max)
5794 break;
5795 dest[d++] = (char)ch;
5796 }
5797 else if(ch < 0x800)
5798 {
5799 if(d + 2 >= max)
5800 break;
5801 dest[d++] = (unsigned char)0xC0 | (unsigned char)((ch & 0x7C0) >> 6);
5802 dest[d++] = (unsigned char)0x80 | (unsigned char)(ch & 0x03F);
5803 }
5804 else if(ch < 0x10000)
5805 {
5806 if(d + 3 >= max)
5807 break;
5808 dest[d++] = (unsigned char)0xE0 | (unsigned char)((ch & 0xF000) >> 12);
5809 dest[d++] = (unsigned char)0x80 | (unsigned char)((ch & 0xFC0) >> 6);
5810 dest[d++] = (unsigned char)0x80 | (unsigned char)(ch & 0x03F);
5811 }
5812 else
5813 {
5814 if(d + 4 >= max)
5815 break;
5816 dest[d++] = (unsigned char)0xF0 | (unsigned char)((ch & 0x1C0000) >> 18);
5817 dest[d++] = (unsigned char)0x80 | (unsigned char)((ch & 0x3F000) >> 12);
5818 dest[d++] = (unsigned char)0x80 | (unsigned char)((ch & 0xFC0) >> 6);
5819 dest[d++] = (unsigned char)0x80 | (unsigned char)(ch & 0x03F);
5820 }
5821 }
5822 dest[d] = (unsigned char)0;
5823 return d;
5824 }
5825
5826 unsigned int __ecereNameSpace__ecere__sys__UTF8GetChar(char * string, int * numBytes)
5827 {
5828 unsigned int ch;
5829 unsigned char b = ((unsigned char *)string)[0];
5830 int i;
5831 unsigned char mask = (unsigned char)0x7F;
5832 int nb = b ? 1 : 0;
5833
5834 ch = 0;
5835 if(b & (unsigned char)0x80)
5836 {
5837 if(b & (unsigned char)0x40)
5838 {
5839 mask >>= 2;
5840 nb++;
5841 if(b & (unsigned char)0x20)
5842 {
5843 nb++;
5844 mask >>= 1;
5845 if(b & (unsigned char)0x10)
5846 {
5847 if(b & (unsigned char)0x08)
5848 {
5849 nb = 0;
5850 }
5851 nb++;
5852 mask >>= 1;
5853 }
5854 }
5855 }
5856 else
5857 nb = 0;
5858 }
5859 for(i = 0; i < nb; i++)
5860 {
5861 ch <<= 6;
5862 ch |= (b = ((unsigned char *)string)[i]) & mask;
5863 mask = (unsigned char)0x3F;
5864 if(i > 1 && (!(b & (unsigned char)0x80) || (b & (unsigned char)0x40)))
5865 {
5866 nb = 0;
5867 ch = 0;
5868 }
5869 }
5870 if(i < nb || ch > 0x10FFFF || (ch >= 0xD800 && ch <= 0xDFFF) || (ch < 0x80 && nb > 1) || (ch < 0x800 && nb > 2) || (ch < 0x10000 && nb > 3))
5871 {
5872 ch = 0;
5873 nb = 0;
5874 }
5875 if(numBytes)
5876 *numBytes = nb;
5877 return ch;
5878 }
5879
5880 int __ecereNameSpace__ecere__sys__UTF8toUTF16Buffer(char * source, unsigned short * dest, int max)
5881 {
5882 if(source)
5883 {
5884 int c;
5885 int d = 0;
5886
5887 for(c = 0; source[c]; )
5888 {
5889 unsigned char ch = source[c];
5890 unsigned int codePoint = 0;
5891 int numBytes = 1;
5892 int i;
5893 unsigned char mask = (unsigned char)0x7F;
5894
5895 if(ch & (unsigned char)0x80 && ch & (unsigned char)0x40)
5896 {
5897 mask >>= 2;
5898 numBytes++;
5899 if(ch & (unsigned char)0x20)
5900 {
5901 numBytes++;
5902 mask >>= 1;
5903 if(ch & (unsigned char)0x10)
5904 {
5905 numBytes++;
5906 mask >>= 1;
5907 }
5908 }
5909 }
5910 for(i = 0; i < numBytes; i++)
5911 {
5912 codePoint <<= 6;
5913 codePoint |= source[c++] & mask;
5914 mask = (unsigned char)0x3F;
5915 }
5916 if(codePoint > 0xFFFF)
5917 {
5918 unsigned short lead = (unsigned short)((0xD800 - (0x10000 >> 10)) + (codePoint >> 10));
5919 unsigned short trail = (unsigned short)0xDC00 + (unsigned short)(codePoint & 0x3FF);
5920
5921 if(d >= max - 1)
5922 break;
5923 dest[d++] = lead;
5924 dest[d++] = trail;
5925 }
5926 else
5927 {
5928 if(d >= max)
5929 break;
5930 dest[d++] = (unsigned short)codePoint;
5931 }
5932 }
5933 dest[d] = (unsigned short)0;
5934 return d;
5935 }
5936 return 0;
5937 }
5938
5939 int __ecereNameSpace__ecere__sys__UTF32toUTF8Len(unsigned int * source, int count, unsigned char * dest, int max)
5940 {
5941 int c;
5942 int d = 0;
5943 unsigned int ch;
5944
5945 for(c = 0; c < count && (ch = source[c]); c++)
5946 {
5947 if(ch < 0x80)
5948 {
5949 if(d + 1 >= max)
5950 break;
5951 dest[d++] = (char)ch;
5952 }
5953 else if(ch < 0x800)
5954 {
5955 if(d + 2 >= max)
5956 break;
5957 dest[d++] = (unsigned char)0xC0 | (unsigned char)((ch & 0x7C0) >> 6);
5958 dest[d++] = (unsigned char)0x80 | (unsigned char)(ch & 0x03F);
5959 }
5960 else if(ch < 0x10000)
5961 {
5962 if(d + 3 >= max)
5963 break;
5964 dest[d++] = (unsigned char)0xE0 | (unsigned char)((ch & 0xF000) >> 12);
5965 dest[d++] = (unsigned char)0x80 | (unsigned char)((ch & 0xFC0) >> 6);
5966 dest[d++] = (unsigned char)0x80 | (unsigned char)(ch & 0x03F);
5967 }
5968 else
5969 {
5970 if(d + 4 >= max)
5971 break;
5972 dest[d++] = (unsigned char)0xF0 | (unsigned char)((ch & 0x1C0000) >> 18);
5973 dest[d++] = (unsigned char)0x80 | (unsigned char)((ch & 0x3F000) >> 12);
5974 dest[d++] = (unsigned char)0x80 | (unsigned char)((ch & 0xFC0) >> 6);
5975 dest[d++] = (unsigned char)0x80 | (unsigned char)(ch & 0x03F);
5976 }
5977 }
5978 dest[d] = (unsigned char)0;
5979 return d;
5980 }
5981
5982 unsigned short * __ecereNameSpace__ecere__sys__UTF8toUTF16(char * source, int * wordCount)
5983 {
5984 if(source)
5985 {
5986 int len = strlen(source);
5987 unsigned short * dest = __ecereNameSpace__ecere__com__eSystem_New(sizeof(unsigned short) * (len + 1));
5988 int c;
5989 int d = 0;
5990
5991 for(c = 0; source[c]; )
5992 {
5993 unsigned char ch = source[c];
5994 unsigned int codePoint = 0;
5995 int numBytes = 1;
5996 int i;
5997 unsigned char mask = (unsigned char)0x7F;
5998
5999 if(ch & (unsigned char)0x80 && ch & (unsigned char)0x40)
6000 {
6001 mask >>= 2;
6002 numBytes++;
6003 if(ch & (unsigned char)0x20)
6004 {
6005 numBytes++;
6006 mask >>= 1;
6007 if(ch & (unsigned char)0x10)
6008 {
6009 numBytes++;
6010 mask >>= 1;
6011 }
6012 }
6013 }
6014 for(i = 0; i < numBytes; i++)
6015 {
6016 codePoint <<= 6;
6017 codePoint |= source[c++] & mask;
6018 mask = (unsigned char)0x3F;
6019 }
6020 if(codePoint > 0xFFFF)
6021 {
6022 unsigned short lead = (unsigned short)((0xD800 - (0x10000 >> 10)) + (codePoint >> 10));
6023 unsigned short trail = (unsigned short)0xDC00 + (unsigned short)(codePoint & 0x3FF);
6024
6025 dest[d++] = lead;
6026 dest[d++] = trail;
6027 }
6028 else
6029 {
6030 dest[d++] = (unsigned short)codePoint;
6031 }
6032 }
6033 dest[d] = (unsigned short)0;
6034 if(wordCount)
6035 *wordCount = d;
6036 return dest;
6037 }
6038 return (((void *)0));
6039 }
6040
6041 int __ecereVMethodID___ecereNameSpace__ecere__com__DesignerBase_FindObject;
6042
6043 int __ecereVMethodID___ecereNameSpace__ecere__com__DesignerBase_RenameObject;
6044
6045 int __ecereVMethodID___ecereNameSpace__ecere__com__DesignerBase_SelectObjectFromDesigner;
6046
6047 int __ecereVMethodID___ecereNameSpace__ecere__com__DesignerBase_CodeAddObject;
6048
6049 int __ecereVMethodID___ecereNameSpace__ecere__com__DesignerBase_SheetAddObject;
6050
6051 int __ecereVMethodID___ecereNameSpace__ecere__com__DesignerBase_AddToolBoxClass;
6052
6053 int __ecereVMethodID___ecereNameSpace__ecere__com__DesignerBase_AddDefaultMethod;
6054
6055 int __ecereVMethodID___ecereNameSpace__ecere__com__DesignerBase_DeleteObject;
6056
6057 int __ecereVMethodID___ecereNameSpace__ecere__com__DesignerBase_ObjectContainsCode;
6058
6059 int __ecereVMethodID___ecereNameSpace__ecere__com__DesignerBase_ModifyCode;
6060
6061 int __ecereVMethodID___ecereNameSpace__ecere__com__DesignerBase_UpdateProperties;
6062
6063 int __ecereVMethodID___ecereNameSpace__ecere__com__ClassDesignerBase_Reset;
6064
6065 int __ecereVMethodID___ecereNameSpace__ecere__com__ClassDesignerBase_AddObject;
6066
6067 int __ecereVMethodID___ecereNameSpace__ecere__com__ClassDesignerBase_SelectObject;
6068
6069 int __ecereVMethodID___ecereNameSpace__ecere__com__ClassDesignerBase_ListToolBoxClasses;
6070
6071 int __ecereVMethodID___ecereNameSpace__ecere__com__ClassDesignerBase_PrepareTestObject;
6072
6073 int __ecereVMethodID___ecereNameSpace__ecere__com__ClassDesignerBase_CreateObject;
6074
6075 int __ecereVMethodID___ecereNameSpace__ecere__com__ClassDesignerBase_PostCreateObject;
6076
6077 int __ecereVMethodID___ecereNameSpace__ecere__com__ClassDesignerBase_DroppedObject;
6078
6079 int __ecereVMethodID___ecereNameSpace__ecere__com__ClassDesignerBase_DestroyObject;
6080
6081 int __ecereVMethodID___ecereNameSpace__ecere__com__ClassDesignerBase_FixProperty;
6082
6083 int __ecereVMethodID___ecereNameSpace__ecere__com__ClassDesignerBase_CreateNew;
6084
6085 void __ecereRegisterModule_instance(struct __ecereNameSpace__ecere__com__Instance * module)
6086 {
6087 struct __ecereNameSpace__ecere__com__Class * class;
6088
6089 __ecereNameSpace__ecere__com__eSystem_RegisterDefine("ecere::com::null", "((void *)0)", module, 4);
6090 class = __ecereNameSpace__ecere__com__eSystem_RegisterClass(3, "ecere::com::unichar", "uint", 0, 0, 0, 0, module, 4, 1);
6091 if(((struct __ecereNameSpace__ecere__com__Module *)(((char *)module + structSize_Instance)))->application == ((struct __ecereNameSpace__ecere__com__Module *)(((char *)__thisModule + structSize_Instance)))->application && class)
6092 __ecereClass___ecereNameSpace__ecere__com__unichar = class;
6093 __ecereNameSpace__ecere__com__eClass_AddMethod(class, "OnGetString", 0, __ecereMethod___ecereNameSpace__ecere__com__unichar_OnGetString, 1);
6094 __ecereNameSpace__ecere__com__eClass_AddMethod(class, "OnGetDataFromString", 0, __ecereMethod___ecereNameSpace__ecere__com__unichar_OnGetDataFromString, 1);
6095 class = __ecereNameSpace__ecere__com__eSystem_RegisterClass(5, "ecere::com::Property", 0, sizeof(struct __ecereNameSpace__ecere__com__Property), 0, 0, 0, module, 4, 1);
6096 if(((struct __ecereNameSpace__ecere__com__Module *)(((char *)module + structSize_Instance)))->application == ((struct __ecereNameSpace__ecere__com__Module *)(((char *)__thisModule + structSize_Instance)))->application && class)
6097 __ecereClass___ecereNameSpace__ecere__com__Property = class;
6098 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "prev", "ecere::com::Property", arch_PointerSize, arch_PointerSize, 1);
6099 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "next", "ecere::com::Property", arch_PointerSize, arch_PointerSize, 1);
6100 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "name", "char *", arch_PointerSize, arch_PointerSize, 1);
6101 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "isProperty", "bool", 4, 4, 1);
6102 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "memberAccess", "ecere::com::AccessMode", 4, 4, 1);
6103 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "id", "int", 4, 4, 1);
6104 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "_class", "ecere::com::Class", arch_PointerSize, arch_PointerSize, 1);
6105 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "dataTypeString", "char *", arch_PointerSize, arch_PointerSize, 1);
6106 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "dataTypeClass", "ecere::com::Class", arch_PointerSize, arch_PointerSize, 1);
6107 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "dataType", "Type", arch_PointerSize, arch_PointerSize, 1);
6108 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "Set", "void (*)(void *, int)", arch_PointerSize, arch_PointerSize, 1);
6109 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "Get", "int (*)(void *)", arch_PointerSize, arch_PointerSize, 1);
6110 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "IsSet", "bool (*)(void *)", arch_PointerSize, arch_PointerSize, 1);
6111 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "data", "void *", arch_PointerSize, arch_PointerSize, 1);
6112 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "symbol", "void *", arch_PointerSize, arch_PointerSize, 1);
6113 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "vid", "int", 4, 4, 1);
6114 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "conversion", "bool", 4, 4, 1);
6115 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "watcherOffset", "uint", 4, 4, 1);
6116 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "category", "char *", arch_PointerSize, arch_PointerSize, 1);
6117 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "compiled", "bool", 4, 4, 1);
6118 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "selfWatchable", "bool", 4, 4, 1);
6119 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "isWatchable", "bool", 4, 4, 1);
6120 if(class)
6121 class->fixed = (unsigned int)1;
6122 if(class)
6123 class->noExpansion = (unsigned int)1;
6124 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("ecere::com::MemoryGuard_PushLoc", "void ecere::com::MemoryGuard_PushLoc(char * loc)", __ecereNameSpace__ecere__com__MemoryGuard_PushLoc, module, 4);
6125 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("ecere::com::MemoryGuard_PopLoc", "void ecere::com::MemoryGuard_PopLoc(void)", __ecereNameSpace__ecere__com__MemoryGuard_PopLoc, module, 4);
6126 class = __ecereNameSpace__ecere__com__eSystem_RegisterClass(5, "ecere::com::BTNamedLink", 0, sizeof(struct __ecereNameSpace__ecere__com__BTNamedLink), 0, 0, 0, module, 4, 1);
6127 if(((struct __ecereNameSpace__ecere__com__Module *)(((char *)module + structSize_Instance)))->application == ((struct __ecereNameSpace__ecere__com__Module *)(((char *)__thisModule + structSize_Instance)))->application && class)
6128 __ecereClass___ecereNameSpace__ecere__com__BTNamedLink = class;
6129 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "name", "char *", arch_PointerSize, arch_PointerSize, 1);
6130 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "parent", "ecere::com::BTNamedLink", arch_PointerSize, arch_PointerSize, 1);
6131 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "left", "ecere::com::BTNamedLink", arch_PointerSize, arch_PointerSize, 1);
6132 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "right", "ecere::com::BTNamedLink", arch_PointerSize, arch_PointerSize, 1);
6133 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "depth", "int", 4, 4, 1);
6134 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "data", "void *", arch_PointerSize, arch_PointerSize, 1);
6135 if(class)
6136 class->fixed = (unsigned int)1;
6137 class = __ecereNameSpace__ecere__com__eSystem_RegisterClass(5, "ecere::com::SelfWatcher", 0, sizeof(struct __ecereNameSpace__ecere__com__SelfWatcher), 0, 0, 0, module, 2, 1);
6138 if(((struct __ecereNameSpace__ecere__com__Module *)(((char *)module + structSize_Instance)))->application == ((struct __ecereNameSpace__ecere__com__Module *)(((char *)__thisModule + structSize_Instance)))->application && class)
6139 __ecereClass___ecereNameSpace__ecere__com__SelfWatcher = class;
6140 if(class)
6141 class->fixed = (unsigned int)1;
6142 class = __ecereNameSpace__ecere__com__eSystem_RegisterClass(4, "ecere::com::AccessMode", 0, 0, 0, 0, 0, module, 4, 1);
6143 if(((struct __ecereNameSpace__ecere__com__Module *)(((char *)module + structSize_Instance)))->application == ((struct __ecereNameSpace__ecere__com__Module *)(((char *)__thisModule + structSize_Instance)))->application && class)
6144 __ecereClass___ecereNameSpace__ecere__com__AccessMode = class;
6145 __ecereNameSpace__ecere__com__eEnum_AddFixedValue(class, "defaultAccess", 0);
6146 __ecereNameSpace__ecere__com__eEnum_AddFixedValue(class, "publicAccess", 1);
6147 __ecereNameSpace__ecere__com__eEnum_AddFixedValue(class, "privateAccess", 2);
6148 __ecereNameSpace__ecere__com__eEnum_AddFixedValue(class, "staticAccess", 3);
6149 __ecereNameSpace__ecere__com__eEnum_AddFixedValue(class, "baseSystemAccess", 4);
6150 class = __ecereNameSpace__ecere__com__eSystem_RegisterClass(5, "ecere::com::SubModule", 0, sizeof(struct __ecereNameSpace__ecere__com__SubModule), 0, 0, 0, module, 4, 1);
6151 if(((struct __ecereNameSpace__ecere__com__Module *)(((char *)module + structSize_Instance)))->application == ((struct __ecereNameSpace__ecere__com__Module *)(((char *)__thisModule + structSize_Instance)))->application && class)
6152 __ecereClass___ecereNameSpace__ecere__com__SubModule = class;
6153 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "prev", "ecere::com::SubModule", arch_PointerSize, arch_PointerSize, 1);
6154 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "next", "ecere::com::SubModule", arch_PointerSize, arch_PointerSize, 1);
6155 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "module", "ecere::com::Module", arch_PointerSize, arch_PointerSize, 1);
6156 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "importMode", "ecere::com::AccessMode", 4, 4, 1);
6157 class = __ecereNameSpace__ecere__com__eSystem_RegisterClass(4, "ecere::com::DataMemberType", 0, 0, 0, 0, 0, module, 4, 1);
6158 if(((struct __ecereNameSpace__ecere__com__Module *)(((char *)module + structSize_Instance)))->application == ((struct __ecereNameSpace__ecere__com__Module *)(((char *)__thisModule + structSize_Instance)))->application && class)
6159 __ecereClass___ecereNameSpace__ecere__com__DataMemberType = class;
6160 __ecereNameSpace__ecere__com__eEnum_AddFixedValue(class, "normalMember", 0);
6161 __ecereNameSpace__ecere__com__eEnum_AddFixedValue(class, "unionMember", 1);
6162 __ecereNameSpace__ecere__com__eEnum_AddFixedValue(class, "structMember", 2);
6163 class = __ecereNameSpace__ecere__com__eSystem_RegisterClass(4, "ecere::com::ClassType", 0, 0, 0, 0, 0, module, 4, 1);
6164 if(((struct __ecereNameSpace__ecere__com__Module *)(((char *)module + structSize_Instance)))->application == ((struct __ecereNameSpace__ecere__com__Module *)(((char *)__thisModule + structSize_Instance)))->application && class)
6165 __ecereClass___ecereNameSpace__ecere__com__ClassType = class;
6166 __ecereNameSpace__ecere__com__eEnum_AddFixedValue(class, "normalClass", 0);
6167 __ecereNameSpace__ecere__com__eEnum_AddFixedValue(class, "structClass", 1);
6168 __ecereNameSpace__ecere__com__eEnum_AddFixedValue(class, "bitClass", 2);
6169 __ecereNameSpace__ecere__com__eEnum_AddFixedValue(class, "unitClass", 3);
6170 __ecereNameSpace__ecere__com__eEnum_AddFixedValue(class, "enumClass", 4);
6171 __ecereNameSpace__ecere__com__eEnum_AddFixedValue(class, "noHeadClass", 5);
6172 __ecereNameSpace__ecere__com__eEnum_AddFixedValue(class, "unionClass", 6);
6173 __ecereNameSpace__ecere__com__eEnum_AddFixedValue(class, "systemClass", 1000);
6174 class = __ecereNameSpace__ecere__com__eSystem_RegisterClass(5, "ecere::com::Class", 0, sizeof(struct __ecereNameSpace__ecere__com__Class), 0, 0, 0, module, 4, 1);
6175 if(((struct __ecereNameSpace__ecere__com__Module *)(((char *)module + structSize_Instance)))->application == ((struct __ecereNameSpace__ecere__com__Module *)(((char *)__thisModule + structSize_Instance)))->application && class)
6176 __ecereClass___ecereNameSpace__ecere__com__Class = class;
6177 __ecereNameSpace__ecere__com__eClass_AddMethod(class, "OnFree", 0, __ecereMethod___ecereNameSpace__ecere__com__Class_OnFree, 1);
6178 __ecereNameSpace__ecere__com__eClass_AddMethod(class, "OnGetString", 0, __ecereMethod___ecereNameSpace__ecere__com__Class_OnGetString, 1);
6179 __ecereNameSpace__ecere__com__eClass_AddMethod(class, "OnGetDataFromString", 0, __ecereMethod___ecereNameSpace__ecere__com__Class_OnGetDataFromString, 1);
6180 __ecereNameSpace__ecere__com__eClass_AddMethod(class, "OnSerialize", 0, __ecereMethod___ecereNameSpace__ecere__com__Class_OnSerialize, 1);
6181 __ecereNameSpace__ecere__com__eClass_AddMethod(class, "OnUnserialize", 0, __ecereMethod___ecereNameSpace__ecere__com__Class_OnUnserialize, 1);
6182 __ecereProp___ecereNameSpace__ecere__com__Class_char__PTR_ = __ecereNameSpace__ecere__com__eClass_AddProperty(class, 0, "char *", __ecereProp___ecereNameSpace__ecere__com__Class_Set_char__PTR_, __ecereProp___ecereNameSpace__ecere__com__Class_Get_char__PTR_, 1);
6183 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "prev", "ecere::com::Class", arch_PointerSize, arch_PointerSize, 1);
6184 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "next", "ecere::com::Class", arch_PointerSize, arch_PointerSize, 1);
6185 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "name", "char *", arch_PointerSize, arch_PointerSize, 1);
6186 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "offset", "int", 4, 4, 1);
6187 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "structSize", "int", 4, 4, 1);
6188 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "_vTbl", "int (* *)()", arch_PointerSize, arch_PointerSize, 1);
6189 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "vTblSize", "int", 4, 4, 1);
6190 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "Constructor", "int (*)(ecere::com::Instance)", arch_PointerSize, arch_PointerSize, 1);
6191 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "Destructor", "void (*)(ecere::com::Instance)", arch_PointerSize, arch_PointerSize, 1);
6192 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "offsetClass", "int", 4, 4, 1);
6193 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "sizeClass", "int", 4, 4, 1);
6194 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "base", "ecere::com::Class", arch_PointerSize, arch_PointerSize, 1);
6195 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "methods", "ecere::sys::BinaryTree", structSize_BinaryTree, arch_PointerSize, 1);
6196 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "members", "ecere::sys::BinaryTree", structSize_BinaryTree, arch_PointerSize, 1);
6197 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "prop", "ecere::sys::BinaryTree", structSize_BinaryTree, arch_PointerSize, 1);
6198 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "membersAndProperties", "ecere::sys::OldList", structSize_OldList, arch_PointerSize, 1);
6199 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "classProperties", "ecere::sys::BinaryTree", structSize_BinaryTree, arch_PointerSize, 1);
6200 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "derivatives", "ecere::sys::OldList", structSize_OldList, arch_PointerSize, 1);
6201 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "memberID", "int", 4, 4, 1);
6202 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "startMemberID", "int", 4, 4, 1);
6203 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "type", "ecere::com::ClassType", 4, 4, 1);
6204 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "module", "ecere::com::Module", arch_PointerSize, arch_PointerSize, 1);
6205 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "nameSpace", "ecere::com::NameSpace *", arch_PointerSize, arch_PointerSize, 1);
6206 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "dataTypeString", "char *", arch_PointerSize, arch_PointerSize, 1);
6207 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "dataType", "Type", arch_PointerSize, arch_PointerSize, 1);
6208 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "typeSize", "int", 4, 4, 1);
6209 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "defaultAlignment", "int", 4, 4, 1);
6210 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "Initialize", "void (*)()", arch_PointerSize, arch_PointerSize, 1);
6211 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "memberOffset", "int", 4, 4, 1);
6212 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "selfWatchers", "ecere::sys::OldList", structSize_OldList, arch_PointerSize, 1);
6213 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "designerClass", "char *", arch_PointerSize, arch_PointerSize, 1);
6214 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "noExpansion", "bool", 4, 4, 1);
6215 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "defaultProperty", "char *", arch_PointerSize, arch_PointerSize, 1);
6216 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "comRedefinition", "bool", 4, 4, 1);
6217 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "count", "int", 4, 4, 1);
6218 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "isRemote", "bool", 4, 4, 1);
6219 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "internalDecl", "bool", 4, 4, 1);
6220 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "data", "void *", arch_PointerSize, arch_PointerSize, 1);
6221 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "computeSize", "bool", 4, 4, 1);
6222 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "structAlignment", "int", 4, 4, 1);
6223 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "destructionWatchOffset", "int", 4, 4, 1);
6224 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "fixed", "bool", 4, 4, 1);
6225 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "delayedCPValues", "ecere::sys::OldList", structSize_OldList, arch_PointerSize, 1);
6226 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "inheritanceAccess", "ecere::com::AccessMode", 4, 4, 1);
6227 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "fullName", "char *", arch_PointerSize, arch_PointerSize, 1);
6228 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "symbol", "void *", arch_PointerSize, arch_PointerSize, 1);
6229 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "conversions", "ecere::sys::OldList", structSize_OldList, arch_PointerSize, 1);
6230 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "templateParams", "ecere::sys::OldList", structSize_OldList, arch_PointerSize, 1);
6231 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "templateArgs", "ecere::com::ClassTemplateArgument *", arch_PointerSize, arch_PointerSize, 1);
6232 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "templateClass", "ecere::com::Class", arch_PointerSize, arch_PointerSize, 1);
6233 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "templatized", "ecere::sys::OldList", structSize_OldList, arch_PointerSize, 1);
6234 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "numParams", "int", 4, 4, 1);
6235 if(class)
6236 class->fixed = (unsigned int)1;
6237 if(class)
6238 class->noExpansion = (unsigned int)1;
6239 class = __ecereNameSpace__ecere__com__eSystem_RegisterClass(4, "ecere::com::TemplateParameterType", 0, 0, 0, 0, 0, module, 4, 1);
6240 if(((struct __ecereNameSpace__ecere__com__Module *)(((char *)module + structSize_Instance)))->application == ((struct __ecereNameSpace__ecere__com__Module *)(((char *)__thisModule + structSize_Instance)))->application && class)
6241 __ecereClass___ecereNameSpace__ecere__com__TemplateParameterType = class;
6242 __ecereNameSpace__ecere__com__eEnum_AddFixedValue(class, "type", 0);
6243 __ecereNameSpace__ecere__com__eEnum_AddFixedValue(class, "identifier", 1);
6244 __ecereNameSpace__ecere__com__eEnum_AddFixedValue(class, "expression", 2);
6245 class = __ecereNameSpace__ecere__com__eSystem_RegisterClass(4, "ecere::com::TemplateMemberType", 0, 0, 0, 0, 0, module, 4, 1);
6246 if(((struct __ecereNameSpace__ecere__com__Module *)(((char *)module + structSize_Instance)))->application == ((struct __ecereNameSpace__ecere__com__Module *)(((char *)__thisModule + structSize_Instance)))->application && class)
6247 __ecereClass___ecereNameSpace__ecere__com__TemplateMemberType = class;
6248 __ecereNameSpace__ecere__com__eEnum_AddFixedValue(class, "dataMember", 0);
6249 __ecereNameSpace__ecere__com__eEnum_AddFixedValue(class, "method", 1);
6250 __ecereNameSpace__ecere__com__eEnum_AddFixedValue(class, "prop", 2);
6251 class = __ecereNameSpace__ecere__com__eSystem_RegisterClass(1, "ecere::com::ClassTemplateArgument", 0, sizeof(struct __ecereNameSpace__ecere__com__ClassTemplateArgument), 0, 0, 0, module, 4, 1);
6252 if(((struct __ecereNameSpace__ecere__com__Module *)(((char *)module + structSize_Instance)))->application == ((struct __ecereNameSpace__ecere__com__Module *)(((char *)__thisModule + structSize_Instance)))->application && class)
6253 __ecereClass___ecereNameSpace__ecere__com__ClassTemplateArgument = class;
6254 {
6255 struct __ecereNameSpace__ecere__com__DataMember * dataMember0 = __ecereNameSpace__ecere__com__eMember_New(1, 1);
6256
6257 {
6258 struct __ecereNameSpace__ecere__com__DataMember * dataMember1 = __ecereNameSpace__ecere__com__eMember_New(2, 1);
6259
6260 __ecereNameSpace__ecere__com__eMember_AddDataMember(dataMember1, "dataTypeString", "char *", arch_PointerSize, arch_PointerSize, 1);
6261 __ecereNameSpace__ecere__com__eMember_AddDataMember(dataMember1, "dataTypeClass", "ecere::com::Class", arch_PointerSize, arch_PointerSize, 1);
6262 __ecereNameSpace__ecere__com__eMember_AddMember(dataMember0, dataMember1);
6263 }
6264 __ecereNameSpace__ecere__com__eMember_AddDataMember(dataMember0, "expression", "ecere::com::DataValue", 8, 8, 1);
6265 {
6266 struct __ecereNameSpace__ecere__com__DataMember * dataMember1 = __ecereNameSpace__ecere__com__eMember_New(2, 1);
6267
6268 __ecereNameSpace__ecere__com__eMember_AddDataMember(dataMember1, "memberString", "char *", arch_PointerSize, arch_PointerSize, 1);
6269 {
6270 struct __ecereNameSpace__ecere__com__DataMember * dataMember2 = __ecereNameSpace__ecere__com__eMember_New(1, 1);
6271
6272 __ecereNameSpace__ecere__com__eMember_AddDataMember(dataMember2, "member", "ecere::com::DataMember", arch_PointerSize, arch_PointerSize, 1);
6273 __ecereNameSpace__ecere__com__eMember_AddDataMember(dataMember2, "prop", "ecere::com::Property", arch_PointerSize, arch_PointerSize, 1);
6274 __ecereNameSpace__ecere__com__eMember_AddDataMember(dataMember2, "method", "ecere::com::Method", arch_PointerSize, arch_PointerSize, 1);
6275 __ecereNameSpace__ecere__com__eMember_AddMember(dataMember1, dataMember2);
6276 }
6277 __ecereNameSpace__ecere__com__eMember_AddMember(dataMember0, dataMember1);
6278 }
6279 __ecereNameSpace__ecere__com__eClass_AddMember(class, dataMember0);
6280 }
6281 class = __ecereNameSpace__ecere__com__eSystem_RegisterClass(5, "ecere::com::ClassTemplateParameter", 0, sizeof(struct __ecereNameSpace__ecere__com__ClassTemplateParameter), 0, 0, 0, module, 4, 1);
6282 if(((struct __ecereNameSpace__ecere__com__Module *)(((char *)module + structSize_Instance)))->application == ((struct __ecereNameSpace__ecere__com__Module *)(((char *)__thisModule + structSize_Instance)))->application && class)
6283 __ecereClass___ecereNameSpace__ecere__com__ClassTemplateParameter = class;
6284 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "prev", "ecere::com::ClassTemplateParameter", arch_PointerSize, arch_PointerSize, 1);
6285 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "next", "ecere::com::ClassTemplateParameter", arch_PointerSize, arch_PointerSize, 1);
6286 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "name", "char *", arch_PointerSize, arch_PointerSize, 1);
6287 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "type", "ecere::com::TemplateParameterType", 4, 4, 1);
6288 {
6289 struct __ecereNameSpace__ecere__com__DataMember * dataMember0 = __ecereNameSpace__ecere__com__eMember_New(1, 1);
6290
6291 __ecereNameSpace__ecere__com__eMember_AddDataMember(dataMember0, "dataTypeString", "char *", arch_PointerSize, arch_PointerSize, 1);
6292 __ecereNameSpace__ecere__com__eMember_AddDataMember(dataMember0, "memberType", "ecere::com::TemplateMemberType", 4, 4, 1);
6293 __ecereNameSpace__ecere__com__eClass_AddMember(class, dataMember0);
6294 }
6295 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "defaultArg", "ecere::com::ClassTemplateArgument", structSize_ClassTemplateArgument, 8, 1);
6296 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "param", "void *", arch_PointerSize, arch_PointerSize, 1);
6297 if(class)
6298 class->fixed = (unsigned int)1;
6299 class = __ecereNameSpace__ecere__com__eSystem_RegisterClass(4, "ecere::com::MethodType", 0, 0, 0, 0, 0, module, 4, 1);
6300 if(((struct __ecereNameSpace__ecere__com__Module *)(((char *)module + structSize_Instance)))->application == ((struct __ecereNameSpace__ecere__com__Module *)(((char *)__thisModule + structSize_Instance)))->application && class)
6301 __ecereClass___ecereNameSpace__ecere__com__MethodType = class;
6302 __ecereNameSpace__ecere__com__eEnum_AddFixedValue(class, "normalMethod", 0);
6303 __ecereNameSpace__ecere__com__eEnum_AddFixedValue(class, "virtualMethod", 1);
6304 class = __ecereNameSpace__ecere__com__eSystem_RegisterClass(5, "ecere::com::Method", 0, sizeof(struct __ecereNameSpace__ecere__com__Method), 0, 0, 0, module, 4, 1);
6305 if(((struct __ecereNameSpace__ecere__com__Module *)(((char *)module + structSize_Instance)))->application == ((struct __ecereNameSpace__ecere__com__Module *)(((char *)__thisModule + structSize_Instance)))->application && class)
6306 __ecereClass___ecereNameSpace__ecere__com__Method = class;
6307 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "name", "char *", arch_PointerSize, arch_PointerSize, 1);
6308 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "parent", "ecere::com::Method", arch_PointerSize, arch_PointerSize, 1);
6309 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "left", "ecere::com::Method", arch_PointerSize, arch_PointerSize, 1);
6310 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "right", "ecere::com::Method", arch_PointerSize, arch_PointerSize, 1);
6311 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "depth", "int", 4, 4, 1);
6312 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "function", "int (*)()", arch_PointerSize, arch_PointerSize, 1);
6313 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "vid", "int", 4, 4, 1);
6314 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "type", "ecere::com::MethodType", 4, 4, 1);
6315 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "_class", "ecere::com::Class", arch_PointerSize, arch_PointerSize, 1);
6316 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "symbol", "void *", arch_PointerSize, arch_PointerSize, 1);
6317 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "dataTypeString", "char *", arch_PointerSize, arch_PointerSize, 1);
6318 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "dataType", "Type", arch_PointerSize, arch_PointerSize, 1);
6319 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "memberAccess", "ecere::com::AccessMode", 4, 4, 1);
6320 if(class)
6321 class->fixed = (unsigned int)1;
6322 class = __ecereNameSpace__ecere__com__eSystem_RegisterClass(4, "ecere::com::ImportType", 0, 0, 0, 0, 0, module, 4, 1);
6323 if(((struct __ecereNameSpace__ecere__com__Module *)(((char *)module + structSize_Instance)))->application == ((struct __ecereNameSpace__ecere__com__Module *)(((char *)__thisModule + structSize_Instance)))->application && class)
6324 __ecereClass___ecereNameSpace__ecere__com__ImportType = class;
6325 __ecereNameSpace__ecere__com__eEnum_AddFixedValue(class, "normalImport", 0);
6326 __ecereNameSpace__ecere__com__eEnum_AddFixedValue(class, "staticImport", 1);
6327 __ecereNameSpace__ecere__com__eEnum_AddFixedValue(class, "remoteImport", 2);
6328 __ecereNameSpace__ecere__com__eEnum_AddFixedValue(class, "preDeclImport", 3);
6329 __ecereNameSpace__ecere__com__eEnum_AddFixedValue(class, "comCheckImport", 4);
6330 class = __ecereNameSpace__ecere__com__eSystem_RegisterClass(1, "ecere::com::NameSpace", 0, sizeof(struct __ecereNameSpace__ecere__com__NameSpace), 0, 0, 0, module, 4, 1);
6331 if(((struct __ecereNameSpace__ecere__com__Module *)(((char *)module + structSize_Instance)))->application == ((struct __ecereNameSpace__ecere__com__Module *)(((char *)__thisModule + structSize_Instance)))->application && class)
6332 __ecereClass___ecereNameSpace__ecere__com__NameSpace = class;
6333 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "name", "char *", arch_PointerSize, arch_PointerSize, 1);
6334 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "btParent", "ecere::com::NameSpace *", arch_PointerSize, arch_PointerSize, 1);
6335 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "left", "ecere::com::NameSpace *", arch_PointerSize, arch_PointerSize, 1);
6336 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "right", "ecere::com::NameSpace *", arch_PointerSize, arch_PointerSize, 1);
6337 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "depth", "int", 4, 4, 1);
6338 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "parent", "ecere::com::NameSpace *", arch_PointerSize, arch_PointerSize, 1);
6339 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "nameSpaces", "ecere::sys::BinaryTree", structSize_BinaryTree, arch_PointerSize, 1);
6340 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "classes", "ecere::sys::BinaryTree", structSize_BinaryTree, arch_PointerSize, 1);
6341 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "defines", "ecere::sys::BinaryTree", structSize_BinaryTree, arch_PointerSize, 1);
6342 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "functions", "ecere::sys::BinaryTree", structSize_BinaryTree, arch_PointerSize, 1);
6343 class = __ecereNameSpace__ecere__com__eSystem_RegisterClass(1, "ecere::com::DataValue", 0, sizeof(struct __ecereNameSpace__ecere__com__DataValue), 0, 0, 0, module, 4, 1);
6344 if(((struct __ecereNameSpace__ecere__com__Module *)(((char *)module + structSize_Instance)))->application == ((struct __ecereNameSpace__ecere__com__Module *)(((char *)__thisModule + structSize_Instance)))->application && class)
6345 __ecereClass___ecereNameSpace__ecere__com__DataValue = class;
6346 {
6347 struct __ecereNameSpace__ecere__com__DataMember * dataMember0 = __ecereNameSpace__ecere__com__eMember_New(1, 1);
6348
6349 __ecereNameSpace__ecere__com__eMember_AddDataMember(dataMember0, "c", "char", 1, 1, 1);
6350 __ecereNameSpace__ecere__com__eMember_AddDataMember(dataMember0, "uc", "byte", 1, 1, 1);
6351 __ecereNameSpace__ecere__com__eMember_AddDataMember(dataMember0, "s", "short", 2, 2, 1);
6352 __ecereNameSpace__ecere__com__eMember_AddDataMember(dataMember0, "us", "uint16", 2, 2, 1);
6353 __ecereNameSpace__ecere__com__eMember_AddDataMember(dataMember0, "i", "int", 4, 4, 1);
6354 __ecereNameSpace__ecere__com__eMember_AddDataMember(dataMember0, "ui", "uint", 4, 4, 1);
6355 __ecereNameSpace__ecere__com__eMember_AddDataMember(dataMember0, "p", "void *", arch_PointerSize, arch_PointerSize, 1);
6356 __ecereNameSpace__ecere__com__eMember_AddDataMember(dataMember0, "f", "float", 4, 4, 1);
6357 __ecereNameSpace__ecere__com__eMember_AddDataMember(dataMember0, "d", "double", 8, 8, 1);
6358 __ecereNameSpace__ecere__com__eMember_AddDataMember(dataMember0, "i64", "int64", 8, 8, 1);
6359 __ecereNameSpace__ecere__com__eMember_AddDataMember(dataMember0, "ui64", "uint64", 8, 8, 1);
6360 __ecereNameSpace__ecere__com__eClass_AddMember(class, dataMember0);
6361 }
6362 class = __ecereNameSpace__ecere__com__eSystem_RegisterClass(5, "ecere::com::DataMember", 0, sizeof(struct __ecereNameSpace__ecere__com__DataMember), 0, 0, 0, module, 4, 1);
6363 if(((struct __ecereNameSpace__ecere__com__Module *)(((char *)module + structSize_Instance)))->application == ((struct __ecereNameSpace__ecere__com__Module *)(((char *)__thisModule + structSize_Instance)))->application && class)
6364 __ecereClass___ecereNameSpace__ecere__com__DataMember = class;
6365 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "prev", "ecere::com::DataMember", arch_PointerSize, arch_PointerSize, 1);
6366 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "next", "ecere::com::DataMember", arch_PointerSize, arch_PointerSize, 1);
6367 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "name", "char *", arch_PointerSize, arch_PointerSize, 1);
6368 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "isProperty", "bool", 4, 4, 1);
6369 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "memberAccess", "ecere::com::AccessMode", 4, 4, 1);
6370 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "id", "int", 4, 4, 1);
6371 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "_class", "ecere::com::Class", arch_PointerSize, arch_PointerSize, 1);
6372 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "dataTypeString", "char *", arch_PointerSize, arch_PointerSize, 1);
6373 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "dataTypeClass", "ecere::com::Class", arch_PointerSize, arch_PointerSize, 1);
6374 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "dataType", "Type", arch_PointerSize, arch_PointerSize, 1);
6375 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "type", "ecere::com::DataMemberType", 4, 4, 1);
6376 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "offset", "int", 4, 4, 1);
6377 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "memberID", "int", 4, 4, 1);
6378 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "members", "ecere::sys::OldList", structSize_OldList, arch_PointerSize, 1);
6379 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "membersAlpha", "ecere::sys::BinaryTree", structSize_BinaryTree, arch_PointerSize, 1);
6380 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "memberOffset", "int", 4, 4, 1);
6381 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "structAlignment", "int", 4, 4, 1);
6382 if(class)
6383 class->fixed = (unsigned int)1;
6384 class = __ecereNameSpace__ecere__com__eSystem_RegisterClass(5, "ecere::com::BitMember", 0, sizeof(struct __ecereNameSpace__ecere__com__BitMember), 0, 0, 0, module, 4, 1);
6385 if(((struct __ecereNameSpace__ecere__com__Module *)(((char *)module + structSize_Instance)))->application == ((struct __ecereNameSpace__ecere__com__Module *)(((char *)__thisModule + structSize_Instance)))->application && class)
6386 __ecereClass___ecereNameSpace__ecere__com__BitMember = class;
6387 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "prev", "ecere::com::BitMember", arch_PointerSize, arch_PointerSize, 1);
6388 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "next", "ecere::com::BitMember", arch_PointerSize, arch_PointerSize, 1);
6389 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "name", "char *", arch_PointerSize, arch_PointerSize, 1);
6390 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "isProperty", "bool", 4, 4, 1);
6391 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "memberAccess", "ecere::com::AccessMode", 4, 4, 1);
6392 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "id", "int", 4, 4, 1);
6393 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "_class", "ecere::com::Class", arch_PointerSize, arch_PointerSize, 1);
6394 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "dataTypeString", "char *", arch_PointerSize, arch_PointerSize, 1);
6395 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "dataTypeClass", "ecere::com::Class", arch_PointerSize, arch_PointerSize, 1);
6396 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "dataType", "Type", arch_PointerSize, arch_PointerSize, 1);
6397 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "type", "ecere::com::DataMemberType", 4, 4, 1);
6398 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "size", "int", 4, 4, 1);
6399 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "pos", "int", 4, 4, 1);
6400 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "mask", "uint64", 8, 8, 1);
6401 if(class)
6402 class->fixed = (unsigned int)1;
6403 class = __ecereNameSpace__ecere__com__eSystem_RegisterClass(5, "ecere::com::ClassProperty", 0, sizeof(struct __ecereNameSpace__ecere__com__ClassProperty), 0, 0, 0, module, 4, 1);
6404 if(((struct __ecereNameSpace__ecere__com__Module *)(((char *)module + structSize_Instance)))->application == ((struct __ecereNameSpace__ecere__com__Module *)(((char *)__thisModule + structSize_Instance)))->application && class)
6405 __ecereClass___ecereNameSpace__ecere__com__ClassProperty = class;
6406 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "name", "char *", arch_PointerSize, arch_PointerSize, 1);
6407 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "parent", "ecere::com::ClassProperty", arch_PointerSize, arch_PointerSize, 1);
6408 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "left", "ecere::com::ClassProperty", arch_PointerSize, arch_PointerSize, 1);
6409 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "right", "ecere::com::ClassProperty", arch_PointerSize, arch_PointerSize, 1);
6410 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "depth", "int", 4, 4, 1);
6411 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "Set", "void (*)(ecere::com::Class, int64)", arch_PointerSize, arch_PointerSize, 1);
6412 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "Get", "int64 (*)(ecere::com::Class)", arch_PointerSize, arch_PointerSize, 1);
6413 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "dataTypeString", "char *", arch_PointerSize, arch_PointerSize, 1);
6414 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "dataType", "Type", arch_PointerSize, arch_PointerSize, 1);
6415 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "constant", "bool", 4, 4, 1);
6416 if(class)
6417 class->fixed = (unsigned int)1;
6418 class = __ecereNameSpace__ecere__com__eSystem_RegisterClass(5, "ecere::com::DefinedExpression", 0, sizeof(struct __ecereNameSpace__ecere__com__DefinedExpression), 0, 0, 0, module, 4, 1);
6419 if(((struct __ecereNameSpace__ecere__com__Module *)(((char *)module + structSize_Instance)))->application == ((struct __ecereNameSpace__ecere__com__Module *)(((char *)__thisModule + structSize_Instance)))->application && class)
6420 __ecereClass___ecereNameSpace__ecere__com__DefinedExpression = class;
6421 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "prev", "ecere::com::DefinedExpression", arch_PointerSize, arch_PointerSize, 1);
6422 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "next", "ecere::com::DefinedExpression", arch_PointerSize, arch_PointerSize, 1);
6423 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "name", "char *", arch_PointerSize, arch_PointerSize, 1);
6424 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "value", "char *", arch_PointerSize, arch_PointerSize, 1);
6425 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "nameSpace", "ecere::com::NameSpace *", arch_PointerSize, arch_PointerSize, 1);
6426 if(class)
6427 class->fixed = (unsigned int)1;
6428 class = __ecereNameSpace__ecere__com__eSystem_RegisterClass(5, "ecere::com::GlobalFunction", 0, sizeof(struct __ecereNameSpace__ecere__com__GlobalFunction), 0, 0, 0, module, 4, 1);
6429 if(((struct __ecereNameSpace__ecere__com__Module *)(((char *)module + structSize_Instance)))->application == ((struct __ecereNameSpace__ecere__com__Module *)(((char *)__thisModule + structSize_Instance)))->application && class)
6430 __ecereClass___ecereNameSpace__ecere__com__GlobalFunction = class;
6431 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "prev", "ecere::com::GlobalFunction", arch_PointerSize, arch_PointerSize, 1);
6432 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "next", "ecere::com::GlobalFunction", arch_PointerSize, arch_PointerSize, 1);
6433 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "name", "char *", arch_PointerSize, arch_PointerSize, 1);
6434 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "function", "int (*)()", arch_PointerSize, arch_PointerSize, 1);
6435 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "module", "ecere::com::Module", arch_PointerSize, arch_PointerSize, 1);
6436 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "nameSpace", "ecere::com::NameSpace *", arch_PointerSize, arch_PointerSize, 1);
6437 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "dataTypeString", "char *", arch_PointerSize, arch_PointerSize, 1);
6438 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "dataType", "Type", arch_PointerSize, arch_PointerSize, 1);
6439 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "symbol", "void *", arch_PointerSize, arch_PointerSize, 1);
6440 if(class)
6441 class->fixed = (unsigned int)1;
6442 class = __ecereNameSpace__ecere__com__eSystem_RegisterClass(5, "ecere::com::EnumClassData", 0, sizeof(struct __ecereNameSpace__ecere__com__EnumClassData), 0, 0, 0, module, 4, 1);
6443 if(((struct __ecereNameSpace__ecere__com__Module *)(((char *)module + structSize_Instance)))->application == ((struct __ecereNameSpace__ecere__com__Module *)(((char *)__thisModule + structSize_Instance)))->application && class)
6444 __ecereClass___ecereNameSpace__ecere__com__EnumClassData = class;
6445 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "values", "ecere::sys::OldList", structSize_OldList, arch_PointerSize, 1);
6446 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "largest", "int", 4, 4, 1);
6447 if(class)
6448 class->fixed = (unsigned int)1;
6449 class = __ecereNameSpace__ecere__com__eSystem_RegisterClass(5, "ecere::com::Watcher", 0, sizeof(struct __ecereNameSpace__ecere__com__Watcher), 0, 0, 0, module, 2, 1);
6450 if(((struct __ecereNameSpace__ecere__com__Module *)(((char *)module + structSize_Instance)))->application == ((struct __ecereNameSpace__ecere__com__Module *)(((char *)__thisModule + structSize_Instance)))->application && class)
6451 __ecereClass___ecereNameSpace__ecere__com__Watcher = class;
6452 if(class)
6453 class->fixed = (unsigned int)1;
6454 class = __ecereNameSpace__ecere__com__eSystem_RegisterClass(5, "ecere::com::MemBlock", 0, sizeof(struct __ecereNameSpace__ecere__com__MemBlock), 0, 0, 0, module, 2, 1);
6455 if(((struct __ecereNameSpace__ecere__com__Module *)(((char *)module + structSize_Instance)))->application == ((struct __ecereNameSpace__ecere__com__Module *)(((char *)__thisModule + structSize_Instance)))->application && class)
6456 __ecereClass___ecereNameSpace__ecere__com__MemBlock = class;
6457 class = __ecereNameSpace__ecere__com__eSystem_RegisterClass(5, "ecere::com::MemPart", 0, sizeof(struct __ecereNameSpace__ecere__com__MemPart), 0, 0, 0, module, 2, 1);
6458 if(((struct __ecereNameSpace__ecere__com__Module *)(((char *)module + structSize_Instance)))->application == ((struct __ecereNameSpace__ecere__com__Module *)(((char *)__thisModule + structSize_Instance)))->application && class)
6459 __ecereClass___ecereNameSpace__ecere__com__MemPart = class;
6460 class = __ecereNameSpace__ecere__com__eSystem_RegisterClass(1, "ecere::com::BlockPool", 0, sizeof(struct __ecereNameSpace__ecere__com__BlockPool), 0, 0, 0, module, 2, 1);
6461 if(((struct __ecereNameSpace__ecere__com__Module *)(((char *)module + structSize_Instance)))->application == ((struct __ecereNameSpace__ecere__com__Module *)(((char *)__thisModule + structSize_Instance)))->application && class)
6462 __ecereClass___ecereNameSpace__ecere__com__BlockPool = class;
6463 __ecereNameSpace__ecere__com__eClass_AddMethod(class, "Add", "ecere::com::MemBlock Add()", __ecereMethod___ecereNameSpace__ecere__com__BlockPool_Add, 1);
6464 __ecereNameSpace__ecere__com__eClass_AddMethod(class, "Expand", "bool Expand(unsigned int numBlocks)", __ecereMethod___ecereNameSpace__ecere__com__BlockPool_Expand, 1);
6465 __ecereNameSpace__ecere__com__eClass_AddMethod(class, "Remove", "void Remove(ecere::com::MemBlock block)", __ecereMethod___ecereNameSpace__ecere__com__BlockPool_Remove, 1);
6466 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "first", "ecere::com::MemBlock", arch_PointerSize, arch_PointerSize, 1);
6467 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "last", "ecere::com::MemBlock", arch_PointerSize, arch_PointerSize, 1);
6468 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "free", "ecere::com::MemBlock", arch_PointerSize, arch_PointerSize, 1);
6469 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "blockSize", "uint", 4, 4, 1);
6470 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "blockSpace", "uint", 4, 4, 1);
6471 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "numParts", "int", 4, 4, 1);
6472 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "numBlocks", "int", 4, 4, 1);
6473 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "totalSize", "uint", 4, 4, 1);
6474 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "usedSpace", "uint", 4, 4, 1);
6475 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("ecere::com::log2i", "uint ecere::com::log2i(uint number)", __ecereNameSpace__ecere__com__log2i, module, 4);
6476 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("ecere::com::pow2i", "uint ecere::com::pow2i(uint number)", __ecereNameSpace__ecere__com__pow2i, module, 4);
6477 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("ecere::com::memswap", "void ecere::com::memswap(byte * a, byte * b, uint size)", __ecereNameSpace__ecere__com__memswap, module, 4);
6478 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("ecere::com::CheckMemory", "void ecere::com::CheckMemory(void)", __ecereNameSpace__ecere__com__CheckMemory, module, 4);
6479 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("ecere::com::eSystem_RegisterClass", "ecere::com::Class ecere::com::eSystem_RegisterClass(ecere::com::ClassType type, char * name, char * baseName, int size, int sizeClass, bool (* Constructor)(void *), void (* Destructor)(void *), ecere::com::Module module, ecere::com::AccessMode declMode, ecere::com::AccessMode inheritanceAccess)", __ecereNameSpace__ecere__com__eSystem_RegisterClass, module, 4);
6480 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("ecere::com::eClass_Unregister", "void ecere::com::eClass_Unregister(ecere::com::Class _class)", __ecereNameSpace__ecere__com__eClass_Unregister, module, 4);
6481 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("ecere::com::_strtoi64", "int64 ecere::com::_strtoi64(char * string, char * * endString, int base)", __ecereNameSpace__ecere__com___strtoi64, module, 4);
6482 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("ecere::com::_strtoui64", "uint64 ecere::com::_strtoui64(char * string, char * * endString, int base)", __ecereNameSpace__ecere__com___strtoui64, module, 4);
6483 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("ecere::com::eSystem_FindClass", "ecere::com::Class ecere::com::eSystem_FindClass(ecere::com::Module module, char * name)", __ecereNameSpace__ecere__com__eSystem_FindClass, module, 4);
6484 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("ecere::com::DefaultFunction", "bool ecere::com::DefaultFunction(void)", __ecereNameSpace__ecere__com__DefaultFunction, module, 2);
6485 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("ecere::com::eClass_IsDerived", "bool ecere::com::eClass_IsDerived(ecere::com::Class _class, ecere::com::Class from)", __ecereNameSpace__ecere__com__eClass_IsDerived, module, 4);
6486 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("ecere::com::eClass_AddMethod", "ecere::com::Method ecere::com::eClass_AddMethod(ecere::com::Class _class, char * name, char * type, void * function, ecere::com::AccessMode declMode)", __ecereNameSpace__ecere__com__eClass_AddMethod, module, 4);
6487 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("ecere::com::eClass_AddVirtualMethod", "ecere::com::Method ecere::com::eClass_AddVirtualMethod(ecere::com::Class _class, char * name, char * type, void * function, ecere::com::AccessMode declMode)", __ecereNameSpace__ecere__com__eClass_AddVirtualMethod, module, 4);
6488 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("ecere::com::eClass_AddProperty", "ecere::com::Property ecere::com::eClass_AddProperty(ecere::com::Class _class, char * name, char * dataType, void * setStmt, void * getStmt, ecere::com::AccessMode declMode)", __ecereNameSpace__ecere__com__eClass_AddProperty, module, 4);
6489 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("ecere::com::eClass_AddClassProperty", "ecere::com::ClassProperty ecere::com::eClass_AddClassProperty(ecere::com::Class _class, char * name, char * dataType, void * setStmt, void * getStmt)", __ecereNameSpace__ecere__com__eClass_AddClassProperty, module, 4);
6490 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("ecere::com::eClass_FindClassProperty", "ecere::com::ClassProperty ecere::com::eClass_FindClassProperty(ecere::com::Class _class, char * name)", __ecereNameSpace__ecere__com__eClass_FindClassProperty, module, 4);
6491 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("ecere::com::eClass_GetProperty", "int64 ecere::com::eClass_GetProperty(ecere::com::Class _class, char * name)", __ecereNameSpace__ecere__com__eClass_GetProperty, module, 4);
6492 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("ecere::com::eClass_SetProperty", "void ecere::com::eClass_SetProperty(ecere::com::Class _class, char * name, int64 value)", __ecereNameSpace__ecere__com__eClass_SetProperty, module, 4);
6493 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("ecere::com::eClass_FindMethod", "ecere::com::Method ecere::com::eClass_FindMethod(ecere::com::Class _class, char * name, ecere::com::Module module)", __ecereNameSpace__ecere__com__eClass_FindMethod, module, 4);
6494 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("ecere::com::eInstance_New", "void * ecere::com::eInstance_New(ecere::com::Class _class)", __ecereNameSpace__ecere__com__eInstance_New, module, 4);
6495 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("ecere::com::eInstance_Evolve", "void ecere::com::eInstance_Evolve(ecere::com::Instance * instancePtr, ecere::com::Class _class)", __ecereNameSpace__ecere__com__eInstance_Evolve, module, 4);
6496 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("ecere::com::eInstance_Delete", "void ecere::com::eInstance_Delete(ecere::com::Instance instance)", __ecereNameSpace__ecere__com__eInstance_Delete, module, 4);
6497 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("ecere::com::eClass_FindProperty", "ecere::com::Property ecere::com::eClass_FindProperty(ecere::com::Class _class, char * name, ecere::com::Module module)", __ecereNameSpace__ecere__com__eClass_FindProperty, module, 4);
6498 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("ecere::com::eClass_FindDataMember", "ecere::com::DataMember ecere::com::eClass_FindDataMember(ecere::com::Class _class, char * name, ecere::com::Module module, ecere::com::DataMember * subMemberStack, int * subMemberStackPos)", __ecereNameSpace__ecere__com__eClass_FindDataMember, module, 4);
6499 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("ecere::com::eClass_FindDataMemberAndOffset", "ecere::com::DataMember ecere::com::eClass_FindDataMemberAndOffset(ecere::com::Class _class, char * name, uint * offset, ecere::com::Module module, ecere::com::DataMember * subMemberStack, int * subMemberStackPos)", __ecereNameSpace__ecere__com__eClass_FindDataMemberAndOffset, module, 4);
6500 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("ecere::com::eClass_FindDataMemberAndId", "ecere::com::DataMember ecere::com::eClass_FindDataMemberAndId(ecere::com::Class _class, char * name, int * id, ecere::com::Module module, ecere::com::DataMember * subMemberStack, int * subMemberStackPos)", __ecereNameSpace__ecere__com__eClass_FindDataMemberAndId, module, 4);
6501 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("ecere::com::eClass_FindNextMember", "void ecere::com::eClass_FindNextMember(ecere::com::Class _class, ecere::com::Class * curClass, ecere::com::DataMember * curMember, ecere::com::DataMember * subMemberStack, int * subMemberStackPos)", __ecereNameSpace__ecere__com__eClass_FindNextMember, module, 4);
6502 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("ecere::com::eInstance_SetMethod", "void ecere::com::eInstance_SetMethod(ecere::com::Instance instance, char * name, void * function)", __ecereNameSpace__ecere__com__eInstance_SetMethod, module, 4);
6503 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("ecere::com::eInstance_IsDerived", "bool ecere::com::eInstance_IsDerived(ecere::com::Instance instance, ecere::com::Class from)", __ecereNameSpace__ecere__com__eInstance_IsDerived, module, 4);
6504 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("ecere::com::eInstance_IncRef", "void ecere::com::eInstance_IncRef(ecere::com::Instance instance)", __ecereNameSpace__ecere__com__eInstance_IncRef, module, 4);
6505 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("ecere::com::eInstance_DecRef", "void ecere::com::eInstance_DecRef(ecere::com::Instance instance)", __ecereNameSpace__ecere__com__eInstance_DecRef, module, 4);
6506 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("ecere::com::eClass_Resize", "void ecere::com::eClass_Resize(ecere::com::Class _class, int newSize)", __ecereNameSpace__ecere__com__eClass_Resize, module, 4);
6507 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("ecere::com::eClass_AddDataMember", "ecere::com::DataMember ecere::com::eClass_AddDataMember(ecere::com::Class _class, char * name, char * type, uint size, uint alignment, ecere::com::AccessMode declMode)", __ecereNameSpace__ecere__com__eClass_AddDataMember, module, 4);
6508 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("ecere::com::eMember_AddDataMember", "ecere::com::DataMember ecere::com::eMember_AddDataMember(ecere::com::DataMember member, char * name, char * type, uint size, uint alignment, ecere::com::AccessMode declMode)", __ecereNameSpace__ecere__com__eMember_AddDataMember, module, 4);
6509 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("ecere::com::eMember_New", "ecere::com::DataMember ecere::com::eMember_New(ecere::com::DataMemberType type, ecere::com::AccessMode declMode)", __ecereNameSpace__ecere__com__eMember_New, module, 4);
6510 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("ecere::com::eMember_AddMember", "bool ecere::com::eMember_AddMember(ecere::com::DataMember addTo, ecere::com::DataMember dataMember)", __ecereNameSpace__ecere__com__eMember_AddMember, module, 4);
6511 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("ecere::com::eClass_AddMember", "bool ecere::com::eClass_AddMember(ecere::com::Class _class, ecere::com::DataMember dataMember)", __ecereNameSpace__ecere__com__eClass_AddMember, module, 4);
6512 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("ecere::com::eClass_AddBitMember", "ecere::com::BitMember ecere::com::eClass_AddBitMember(ecere::com::Class _class, char * name, char * type, int bitSize, int bitPos, ecere::com::AccessMode declMode)", __ecereNameSpace__ecere__com__eClass_AddBitMember, module, 4);
6513 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("ecere::com::eModule_Load", "ecere::com::Module ecere::com::eModule_Load(ecere::com::Module fromModule, char * name, ecere::com::AccessMode importAccess)", __ecereNameSpace__ecere__com__eModule_Load, module, 4);
6514 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("ecere::com::eModule_LoadStrict", "ecere::com::Module ecere::com::eModule_LoadStrict(ecere::com::Module fromModule, char * name, ecere::com::AccessMode importAccess)", __ecereNameSpace__ecere__com__eModule_LoadStrict, module, 4);
6515 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("ecere::com::eModule_LoadStatic", "ecere::com::Module ecere::com::eModule_LoadStatic(ecere::com::Module fromModule, char * name, ecere::com::AccessMode importAccess, bool (* Load)(ecere::com::Module module), bool (* Unload)(ecere::com::Module module))", __ecereNameSpace__ecere__com__eModule_LoadStatic, module, 4);
6516 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("ecere::com::eModule_Unload", "void ecere::com::eModule_Unload(ecere::com::Module fromModule, ecere::com::Module module)", __ecereNameSpace__ecere__com__eModule_Unload, module, 4);
6517 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("ecere::com::eEnum_AddFixedValue", "void ecere::com::eEnum_AddFixedValue(ecere::com::Class _class, char * string, int value)", __ecereNameSpace__ecere__com__eEnum_AddFixedValue, module, 4);
6518 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("ecere::com::eEnum_AddValue", "int ecere::com::eEnum_AddValue(ecere::com::Class _class, char * string)", __ecereNameSpace__ecere__com__eEnum_AddValue, module, 4);
6519 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("ecere::com::eSystem_RegisterDefine", "ecere::com::DefinedExpression ecere::com::eSystem_RegisterDefine(char * name, char * value, ecere::com::Module module, ecere::com::AccessMode declMode)", __ecereNameSpace__ecere__com__eSystem_RegisterDefine, module, 4);
6520 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("ecere::com::eSystem_RegisterFunction", "ecere::com::GlobalFunction ecere::com::eSystem_RegisterFunction(char * name, char * type, void * func, ecere::com::Module module, ecere::com::AccessMode declMode)", __ecereNameSpace__ecere__com__eSystem_RegisterFunction, module, 4);
6521 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("ecere::com::eSystem_FindDefine", "ecere::com::DefinedExpression ecere::com::eSystem_FindDefine(ecere::com::Module module, char * name)", __ecereNameSpace__ecere__com__eSystem_FindDefine, module, 4);
6522 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("ecere::com::eSystem_FindFunction", "ecere::com::GlobalFunction ecere::com::eSystem_FindFunction(ecere::com::Module module, char * name)", __ecereNameSpace__ecere__com__eSystem_FindFunction, module, 4);
6523 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("ecere::com::eSystem_Renew", "void * ecere::com::eSystem_Renew(void * memory, uint size)", __ecereNameSpace__ecere__com__eSystem_Renew, module, 4);
6524 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("ecere::com::eSystem_Renew0", "void * ecere::com::eSystem_Renew0(void * memory, uint size)", __ecereNameSpace__ecere__com__eSystem_Renew0, module, 4);
6525 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("ecere::com::eSystem_New", "void * ecere::com::eSystem_New(uint size)", __ecereNameSpace__ecere__com__eSystem_New, module, 4);
6526 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("ecere::com::eSystem_New0", "void * ecere::com::eSystem_New0(uint size)", __ecereNameSpace__ecere__com__eSystem_New0, module, 4);
6527 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("ecere::com::eSystem_Delete", "void ecere::com::eSystem_Delete(void * memory)", __ecereNameSpace__ecere__com__eSystem_Delete, module, 4);
6528 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("ecere::com::eInstance_FireSelfWatchers", "void ecere::com::eInstance_FireSelfWatchers(ecere::com::Instance instance, ecere::com::Property _property)", __ecereNameSpace__ecere__com__eInstance_FireSelfWatchers, module, 4);
6529 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("ecere::com::eInstance_FireWatchers", "void ecere::com::eInstance_FireWatchers(ecere::com::Instance instance, ecere::com::Property _property)", __ecereNameSpace__ecere__com__eInstance_FireWatchers, module, 4);
6530 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("ecere::com::eProperty_Watchable", "void ecere::com::eProperty_Watchable(ecere::com::Property _property)", __ecereNameSpace__ecere__com__eProperty_Watchable, module, 4);
6531 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("ecere::com::eClass_DestructionWatchable", "void ecere::com::eClass_DestructionWatchable(ecere::com::Class _class)", __ecereNameSpace__ecere__com__eClass_DestructionWatchable, module, 4);
6532 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("ecere::com::eProperty_SelfWatch", "void ecere::com::eProperty_SelfWatch(ecere::com::Class _class, char * name, void (* callback)(void *))", __ecereNameSpace__ecere__com__eProperty_SelfWatch, module, 4);
6533 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("ecere::com::eInstance_Watch", "void ecere::com::eInstance_Watch(void * instance, ecere::com::Property _property, void * object, void (* callback)(void *, void *))", __ecereNameSpace__ecere__com__eInstance_Watch, module, 4);
6534 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("ecere::com::eInstance_WatchDestruction", "void ecere::com::eInstance_WatchDestruction(ecere::com::Instance instance, ecere::com::Instance object, void (* callback)(ecere::com::Instance, ecere::com::Instance))", __ecereNameSpace__ecere__com__eInstance_WatchDestruction, module, 4);
6535 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("ecere::com::eInstance_StopWatching", "void ecere::com::eInstance_StopWatching(ecere::com::Instance instance, ecere::com::Property _property, ecere::com::Instance object)", __ecereNameSpace__ecere__com__eInstance_StopWatching, module, 4);
6536 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("ecere::com::eClass_GetDesigner", "subclass(ecere::com::ClassDesignerBase) ecere::com::eClass_GetDesigner(ecere::com::Class _class)", __ecereNameSpace__ecere__com__eClass_GetDesigner, module, 4);
6537 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("ecere::com::eInstance_GetDesigner", "subclass(ecere::com::ClassDesignerBase) ecere::com::eInstance_GetDesigner(ecere::com::Instance instance)", __ecereNameSpace__ecere__com__eInstance_GetDesigner, module, 4);
6538 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("ecere::com::LocateModule", "bool ecere::com::LocateModule(char * name, char * fileName)", __ecereNameSpace__ecere__com__LocateModule, module, 4);
6539 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("ecere::com::__ecere_COM_Initialize", "ecere::com::Application ecere::com::__ecere_COM_Initialize(bool guiApp, int argc, char * argv[])", __ecereNameSpace__ecere__com____ecere_COM_Initialize, module, 4);
6540 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("ecere::com::eClass_AddTemplateParameter", "ecere::com::ClassTemplateParameter ecere::com::eClass_AddTemplateParameter(ecere::com::Class _class, char * name, ecere::com::TemplateParameterType type, void * info, ecere::com::ClassTemplateArgument defaultArg)", __ecereNameSpace__ecere__com__eClass_AddTemplateParameter, module, 4);
6541 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("ecere::com::eClass_DoneAddingTemplateParameters", "void ecere::com::eClass_DoneAddingTemplateParameters(ecere::com::Class base)", __ecereNameSpace__ecere__com__eClass_DoneAddingTemplateParameters, module, 4);
6542 class = __ecereNameSpace__ecere__com__eSystem_RegisterClass(4, "ecere::com::Platform", 0, 0, 0, 0, 0, module, 4, 1);
6543 if(((struct __ecereNameSpace__ecere__com__Module *)(((char *)module + structSize_Instance)))->application == ((struct __ecereNameSpace__ecere__com__Module *)(((char *)__thisModule + structSize_Instance)))->application && class)
6544 __ecereClass___ecereNameSpace__ecere__com__Platform = class;
6545 __ecereNameSpace__ecere__com__eClass_AddMethod(class, "OnGetString", 0, __ecereMethod___ecereNameSpace__ecere__com__Platform_OnGetString, 1);
6546 __ecereNameSpace__ecere__com__eClass_AddMethod(class, "OnGetDataFromString", 0, __ecereMethod___ecereNameSpace__ecere__com__Platform_OnGetDataFromString, 1);
6547 __ecereProp___ecereNameSpace__ecere__com__Platform_char__PTR_ = __ecereNameSpace__ecere__com__eClass_AddProperty(class, 0, "char *", __ecereProp___ecereNameSpace__ecere__com__Platform_Set_char__PTR_, __ecereProp___ecereNameSpace__ecere__com__Platform_Get_char__PTR_, 1);
6548 __ecereNameSpace__ecere__com__eEnum_AddFixedValue(class, "unknown", 0);
6549 __ecereNameSpace__ecere__com__eEnum_AddFixedValue(class, "win32", 1);
6550 __ecereNameSpace__ecere__com__eEnum_AddFixedValue(class, "tux", 2);
6551 __ecereNameSpace__ecere__com__eEnum_AddFixedValue(class, "apple", 3);
6552 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("ecere::com::GetRuntimePlatform", "ecere::com::Platform ecere::com::GetRuntimePlatform(void)", __ecereNameSpace__ecere__com__GetRuntimePlatform, module, 4);
6553 class = __ecereNameSpace__ecere__com__eSystem_RegisterClass(5, "ecere::com::ObjectInfo", 0, sizeof(struct __ecereNameSpace__ecere__com__ObjectInfo), 0, 0, 0, module, 4, 1);
6554 if(((struct __ecereNameSpace__ecere__com__Module *)(((char *)module + structSize_Instance)))->application == ((struct __ecereNameSpace__ecere__com__Module *)(((char *)__thisModule + structSize_Instance)))->application && class)
6555 __ecereClass___ecereNameSpace__ecere__com__ObjectInfo = class;
6556 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "prev", "ecere::com::ObjectInfo", arch_PointerSize, arch_PointerSize, 1);
6557 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "next", "ecere::com::ObjectInfo", arch_PointerSize, arch_PointerSize, 1);
6558 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "instance", "ecere::com::Instance", arch_PointerSize, arch_PointerSize, 1);
6559 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "name", "char *", arch_PointerSize, arch_PointerSize, 1);
6560 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "instCode", "Instantiation", arch_PointerSize, arch_PointerSize, 1);
6561 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "deleted", "bool", 4, 4, 1);
6562 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "oClass", "ecere::com::ObjectInfo", arch_PointerSize, arch_PointerSize, 1);
6563 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "instances", "ecere::sys::OldList", structSize_OldList, arch_PointerSize, 1);
6564 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "classDefinition", "ClassDefinition", arch_PointerSize, arch_PointerSize, 1);
6565 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "modified", "bool", 4, 4, 1);
6566 class = __ecereNameSpace__ecere__com__eSystem_RegisterClass(0, "ecere::com::DesignerBase", "ecere::gui::Window", sizeof(struct __ecereNameSpace__ecere__com__DesignerBase), 0, 0, 0, module, 4, 1);
6567 if(((struct __ecereNameSpace__ecere__com__Module *)(((char *)module + structSize_Instance)))->application == ((struct __ecereNameSpace__ecere__com__Module *)(((char *)__thisModule + structSize_Instance)))->application && class)
6568 __ecereClass___ecereNameSpace__ecere__com__DesignerBase = class;
6569 __ecereNameSpace__ecere__com__eClass_AddVirtualMethod(class, "FindObject", "bool FindObject(ecere::com::Instance * instance, char * string)", 0, 1);
6570 __ecereNameSpace__ecere__com__eClass_AddVirtualMethod(class, "RenameObject", "void RenameObject(ecere::com::ObjectInfo object, char * name)", 0, 1);
6571 __ecereNameSpace__ecere__com__eClass_AddVirtualMethod(class, "SelectObjectFromDesigner", "void SelectObjectFromDesigner(ecere::com::ObjectInfo object)", 0, 1);
6572 __ecereNameSpace__ecere__com__eClass_AddVirtualMethod(class, "CodeAddObject", "void CodeAddObject(ecere::com::Instance instance, ecere::com::ObjectInfo * object)", 0, 1);
6573 __ecereNameSpace__ecere__com__eClass_AddVirtualMethod(class, "SheetAddObject", "void SheetAddObject(ecere::com::ObjectInfo object)", 0, 1);
6574 __ecereNameSpace__ecere__com__eClass_AddVirtualMethod(class, "AddToolBoxClass", "void AddToolBoxClass(ecere::com::Class _class)", 0, 1);
6575 __ecereNameSpace__ecere__com__eClass_AddVirtualMethod(class, "AddDefaultMethod", "void AddDefaultMethod(ecere::com::Instance instance, ecere::com::Instance classInstance)", 0, 1);
6576 __ecereNameSpace__ecere__com__eClass_AddVirtualMethod(class, "DeleteObject", "void DeleteObject(ecere::com::ObjectInfo object)", 0, 1);
6577 __ecereNameSpace__ecere__com__eClass_AddVirtualMethod(class, "ObjectContainsCode", "bool ObjectContainsCode(ecere::com::ObjectInfo object)", 0, 1);
6578 __ecereNameSpace__ecere__com__eClass_AddVirtualMethod(class, "ModifyCode", "void ModifyCode(void)", 0, 1);
6579 __ecereNameSpace__ecere__com__eClass_AddVirtualMethod(class, "UpdateProperties", "void UpdateProperties(void)", 0, 1);
6580 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "classDesigner", "ecere::com::ClassDesignerBase", arch_PointerSize, arch_PointerSize, 1);
6581 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "objectClass", "char *", arch_PointerSize, arch_PointerSize, 1);
6582 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "isDragging", "bool", 4, 4, 1);
6583 __ecerePropM___ecereNameSpace__ecere__com__DesignerBase_classDesigner = __ecereNameSpace__ecere__com__eClass_AddProperty(class, "classDesigner", "ecere::com::ClassDesignerBase", __ecereProp___ecereNameSpace__ecere__com__DesignerBase_Set_classDesigner, __ecereProp___ecereNameSpace__ecere__com__DesignerBase_Get_classDesigner, 1);
6584 if(((struct __ecereNameSpace__ecere__com__Module *)(((char *)module + structSize_Instance)))->application == ((struct __ecereNameSpace__ecere__com__Module *)(((char *)__thisModule + structSize_Instance)))->application)
6585 __ecereProp___ecereNameSpace__ecere__com__DesignerBase_classDesigner = __ecerePropM___ecereNameSpace__ecere__com__DesignerBase_classDesigner, __ecerePropM___ecereNameSpace__ecere__com__DesignerBase_classDesigner = (void *)0;
6586 __ecerePropM___ecereNameSpace__ecere__com__DesignerBase_objectClass = __ecereNameSpace__ecere__com__eClass_AddProperty(class, "objectClass", "char *", __ecereProp___ecereNameSpace__ecere__com__DesignerBase_Set_objectClass, __ecereProp___ecereNameSpace__ecere__com__DesignerBase_Get_objectClass, 1);
6587 if(((struct __ecereNameSpace__ecere__com__Module *)(((char *)module + structSize_Instance)))->application == ((struct __ecereNameSpace__ecere__com__Module *)(((char *)__thisModule + structSize_Instance)))->application)
6588 __ecereProp___ecereNameSpace__ecere__com__DesignerBase_objectClass = __ecerePropM___ecereNameSpace__ecere__com__DesignerBase_objectClass, __ecerePropM___ecereNameSpace__ecere__com__DesignerBase_objectClass = (void *)0;
6589 __ecerePropM___ecereNameSpace__ecere__com__DesignerBase_isDragging = __ecereNameSpace__ecere__com__eClass_AddProperty(class, "isDragging", "bool", __ecereProp___ecereNameSpace__ecere__com__DesignerBase_Set_isDragging, __ecereProp___ecereNameSpace__ecere__com__DesignerBase_Get_isDragging, 1);
6590 if(((struct __ecereNameSpace__ecere__com__Module *)(((char *)module + structSize_Instance)))->application == ((struct __ecereNameSpace__ecere__com__Module *)(((char *)__thisModule + structSize_Instance)))->application)
6591 __ecereProp___ecereNameSpace__ecere__com__DesignerBase_isDragging = __ecerePropM___ecereNameSpace__ecere__com__DesignerBase_isDragging, __ecerePropM___ecereNameSpace__ecere__com__DesignerBase_isDragging = (void *)0;
6592 class = __ecereNameSpace__ecere__com__eSystem_RegisterClass(0, "ecere::com::ClassDesignerBase", "ecere::gui::Window", 0, 0, 0, 0, module, 4, 1);
6593 if(((struct __ecereNameSpace__ecere__com__Module *)(((char *)module + structSize_Instance)))->application == ((struct __ecereNameSpace__ecere__com__Module *)(((char *)__thisModule + structSize_Instance)))->application && class)
6594 __ecereClass___ecereNameSpace__ecere__com__ClassDesignerBase = class;
6595 __ecereNameSpace__ecere__com__eClass_AddVirtualMethod(class, "Reset", "void Reset(void)", 0, 1);
6596 __ecereNameSpace__ecere__com__eClass_AddVirtualMethod(class, "AddObject", "void AddObject(void)", 0, 1);
6597 __ecereNameSpace__ecere__com__eClass_AddVirtualMethod(class, "SelectObject", "void SelectObject(ecere::com::ObjectInfo object, ecere::com::Instance control)", 0, 1);
6598 __ecereNameSpace__ecere__com__eClass_AddVirtualMethod(class, "ListToolBoxClasses", "void ListToolBoxClasses(ecere::com::DesignerBase designer)", 0, 1);
6599 __ecereNameSpace__ecere__com__eClass_AddVirtualMethod(class, "PrepareTestObject", "void ::PrepareTestObject(ecere::com::DesignerBase designer, ecere::com::Instance test)", 0, 1);
6600 __ecereNameSpace__ecere__com__eClass_AddVirtualMethod(class, "CreateObject", "void ::CreateObject(ecere::com::DesignerBase designer, ecere::com::Instance instance, ecere::com::ObjectInfo object, bool isClass, ecere::com::Instance _class)", 0, 1);
6601 __ecereNameSpace__ecere__com__eClass_AddVirtualMethod(class, "PostCreateObject", "void ::PostCreateObject(ecere::com::Instance instance, ecere::com::ObjectInfo object, bool isClass, ecere::com::Instance _class)", 0, 1);
6602 __ecereNameSpace__ecere__com__eClass_AddVirtualMethod(class, "DroppedObject", "void ::DroppedObject(ecere::com::Instance instance, ecere::com::ObjectInfo object, bool isClass, ecere::com::Instance _class)", 0, 1);
6603 __ecereNameSpace__ecere__com__eClass_AddVirtualMethod(class, "DestroyObject", "void ::DestroyObject(ecere::com::Instance object)", 0, 1);
6604 __ecereNameSpace__ecere__com__eClass_AddVirtualMethod(class, "FixProperty", "void ::FixProperty(ecere::com::Property prop, ecere::com::Instance object)", 0, 1);
6605 __ecereNameSpace__ecere__com__eClass_AddVirtualMethod(class, "CreateNew", "void ::CreateNew(EditBox editBox, Size clientSize, char * name, char * inherit)", 0, 1);
6606 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("ecere::com::SetActiveDesigner", "void ecere::com::SetActiveDesigner(ecere::com::DesignerBase designer)", __ecereNameSpace__ecere__com__SetActiveDesigner, module, 4);
6607 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("ecere::com::GetActiveDesigner", "ecere::com::DesignerBase ecere::com::GetActiveDesigner(void)", __ecereNameSpace__ecere__com__GetActiveDesigner, module, 4);
6608 __ecereNameSpace__ecere__com__eSystem_RegisterDefine("ecere::sys::LEAD_OFFSET", "0xD800 - (0x10000 >> 10)", module, 2);
6609 __ecereNameSpace__ecere__com__eSystem_RegisterDefine("ecere::sys::SURROGATE_OFFSET", "0x10000 - (0xD800 << 10) - 0xDC00", module, 2);
6610 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("ecere::sys::UTF8Validate", "bool ecere::sys::UTF8Validate(char * source)", __ecereNameSpace__ecere__sys__UTF8Validate, module, 4);
6611 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("ecere::sys::ISO8859_1toUTF8", "int ecere::sys::ISO8859_1toUTF8(char * source, char * dest, int max)", __ecereNameSpace__ecere__sys__ISO8859_1toUTF8, module, 4);
6612 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("ecere::sys::UTF16toUTF8", "char * ecere::sys::UTF16toUTF8(uint16 * source)", __ecereNameSpace__ecere__sys__UTF16toUTF8, module, 4);
6613 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("ecere::sys::UTF16toUTF8Buffer", "int ecere::sys::UTF16toUTF8Buffer(uint16 * source, byte * dest, int max)", __ecereNameSpace__ecere__sys__UTF16toUTF8Buffer, module, 4);
6614 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("ecere::sys::UTF8GetChar", "ecere::com::unichar ecere::sys::UTF8GetChar(char * string, int * numBytes)", __ecereNameSpace__ecere__sys__UTF8GetChar, module, 4);
6615 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("ecere::sys::UTF8toUTF16Buffer", "int ecere::sys::UTF8toUTF16Buffer(char * source, uint16 * dest, int max)", __ecereNameSpace__ecere__sys__UTF8toUTF16Buffer, module, 4);
6616 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("ecere::sys::UTF32toUTF8Len", "int ecere::sys::UTF32toUTF8Len(ecere::com::unichar * source, int count, byte * dest, int max)", __ecereNameSpace__ecere__sys__UTF32toUTF8Len, module, 4);
6617 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("ecere::sys::UTF8toUTF16", "uint16 * ecere::sys::UTF8toUTF16(char * source, int * wordCount)", __ecereNameSpace__ecere__sys__UTF8toUTF16, module, 4);
6618 }
6619
6620 void __ecereUnregisterModule_instance(struct __ecereNameSpace__ecere__com__Instance * module)
6621 {
6622
6623 __ecerePropM___ecereNameSpace__ecere__com__DesignerBase_classDesigner = (void *)0;
6624 __ecerePropM___ecereNameSpace__ecere__com__DesignerBase_objectClass = (void *)0;
6625 __ecerePropM___ecereNameSpace__ecere__com__DesignerBase_isDragging = (void *)0;
6626 }
6627