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");
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 _class->_vTbl[method->vid] = function ? function : __ecereNameSpace__ecere__com__DefaultFunction;
3278 else
3279 base = (((void *)0));
3280 return method;
3281 }
3282 }
3283 if(!base)
3284 {
3285 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);
3286
3287 __ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_Add(&_class->methods, (struct __ecereNameSpace__ecere__sys__BTNode *)method);
3288 _class->_vTbl = __ecereNameSpace__ecere__com__eSystem_Renew(_class->_vTbl, sizeof(void *) * (_class->vTblSize));
3289 _class->_vTbl[method->vid] = function ? function : __ecereNameSpace__ecere__com__DefaultFunction;
3290 if(_class->derivatives.first || _class->templatized.first)
3291 __ecereNameSpace__ecere__com__FixDerivativeVirtualMethod(_class, name, method->vid, function ? function : (void *)__ecereNameSpace__ecere__com__DefaultFunction, type);
3292 return method;
3293 }
3294 }
3295 return (((void *)0));
3296 }
3297
3298 static void __ecereNameSpace__ecere__com__FixDerivativeProperty(struct __ecereNameSpace__ecere__com__Class * base, struct __ecereNameSpace__ecere__com__Property * _property)
3299 {
3300 struct __ecereNameSpace__ecere__sys__OldLink * derivative;
3301
3302 for(derivative = base->derivatives.first; derivative; derivative = derivative->next)
3303 {
3304 struct __ecereNameSpace__ecere__com__Class * _class = derivative->data;
3305 struct __ecereNameSpace__ecere__com__Property * prop;
3306 struct __ecereNameSpace__ecere__com__BTNamedLink * link;
3307
3308 link = (struct __ecereNameSpace__ecere__com__BTNamedLink *)__ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_FindString(&_class->prop, _property->name);
3309 if(link)
3310 {
3311 prop = link->data;
3312 if(!prop->Set && !prop->Get && prop->memberAccess == 4)
3313 {
3314 struct __ecereNameSpace__ecere__com__SelfWatcher * watcher;
3315
3316 for(watcher = _class->selfWatchers.first; watcher; watcher = watcher->next)
3317 {
3318 if(watcher->_property == prop)
3319 watcher->_property = _property;
3320 }
3321 _property->selfWatchable = 0x1;
3322 (__ecereNameSpace__ecere__com__eSystem_Delete(prop->name), prop->name = 0);
3323 (__ecereNameSpace__ecere__com__eSystem_Delete(prop->dataTypeString), prop->dataTypeString = 0);
3324 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Delete(&_class->membersAndProperties, prop);
3325 __ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_Delete(&_class->prop, (struct __ecereNameSpace__ecere__sys__BTNode *)link);
3326 }
3327 }
3328 for(prop = _class->membersAndProperties.first; prop; prop = prop->next)
3329 prop->id++;
3330 _class->memberID++;
3331 _class->startMemberID++;
3332 __ecereNameSpace__ecere__com__FixDerivativeProperty(_class, _property);
3333 }
3334 }
3335
3336 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)
3337 {
3338 struct __ecereNameSpace__ecere__com__Property * _property = (((void *)0));
3339
3340 if(_class)
3341 {
3342 if(!__ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_FindString(&_class->prop, (name ? name : dataType)))
3343 {
3344 _property = __extension__ ({
3345 struct __ecereNameSpace__ecere__com__Property * __ecereInstance1 = __ecereNameSpace__ecere__com__eSystem_New0(structSize_Property);
3346
3347 __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;
3348 });
3349 if(name)
3350 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Add(&_class->membersAndProperties, _property);
3351 else
3352 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Add(&_class->conversions, _property);
3353 __ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_Add(&_class->prop, (struct __ecereNameSpace__ecere__sys__BTNode *)__extension__ ({
3354 struct __ecereNameSpace__ecere__com__BTNamedLink * __ecereInstance1 = __ecereNameSpace__ecere__com__eSystem_New0(structSize_BTNamedLink);
3355
3356 __ecereInstance1->name = _property->name, __ecereInstance1->data = _property, __ecereInstance1;
3357 }));
3358 if(!_property->conversion)
3359 {
3360 __ecereNameSpace__ecere__com__FixDerivativeProperty(_class, _property);
3361 }
3362 }
3363 }
3364 return _property;
3365 }
3366
3367 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass___ecereNameSpace__ecere__sys__NamedLink64;
3368
3369 struct __ecereNameSpace__ecere__sys__NamedLink64
3370 {
3371 struct __ecereNameSpace__ecere__sys__NamedLink64 * prev;
3372 struct __ecereNameSpace__ecere__sys__NamedLink64 * next;
3373 char *  name;
3374 long long data;
3375 } __attribute__ ((gcc_struct));
3376
3377 static void __ecereNameSpace__ecere__com__SetDelayedCPValues(struct __ecereNameSpace__ecere__com__Class * _class, struct __ecereNameSpace__ecere__com__ClassProperty * _property)
3378 {
3379 struct __ecereNameSpace__ecere__sys__OldLink * deriv;
3380 struct __ecereNameSpace__ecere__sys__NamedLink64 * value, * next;
3381
3382 for(value = _class->delayedCPValues.first; value; value = next)
3383 {
3384 next = value->next;
3385 if(!strcmp(value->name, _property->name))
3386 {
3387 _property->Set(_class, value->data);
3388 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Delete(&_class->delayedCPValues, value);
3389 }
3390 }
3391 for(deriv = _class->derivatives.first; deriv; deriv = deriv->next)
3392 {
3393 __ecereNameSpace__ecere__com__SetDelayedCPValues(deriv->data, _property);
3394 }
3395 }
3396
3397 struct __ecereNameSpace__ecere__com__ClassProperty * __ecereNameSpace__ecere__com__eClass_AddClassProperty(struct __ecereNameSpace__ecere__com__Class * _class, char * name, char * dataType, void * setStmt, void * getStmt)
3398 {
3399 if(name && !__ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_FindString(&_class->classProperties, name))
3400 {
3401 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);
3402
3403 __ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_Add(&_class->classProperties, (struct __ecereNameSpace__ecere__sys__BTNode *)_property);
3404 __ecereNameSpace__ecere__com__SetDelayedCPValues(_class, _property);
3405 return _property;
3406 }
3407 return (((void *)0));
3408 }
3409
3410 struct __ecereNameSpace__ecere__com__ClassProperty * __ecereNameSpace__ecere__com__eClass_FindClassProperty(struct __ecereNameSpace__ecere__com__Class * _class, char * name)
3411 {
3412 struct __ecereNameSpace__ecere__com__ClassProperty * _property = (((void *)0));
3413
3414 if(name && _class)
3415 {
3416 struct __ecereNameSpace__ecere__com__Class * origClass = _class;
3417
3418 for(; _class; _class = _class->base)
3419 {
3420 _property = (struct __ecereNameSpace__ecere__com__ClassProperty *)__ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_FindString(&_class->classProperties, name);
3421 if(_property)
3422 break;
3423 }
3424 if(!_property && origClass->type == 4)
3425 {
3426 struct __ecereNameSpace__ecere__com__Class * enumClass = __ecereNameSpace__ecere__com__eSystem_FindClass(origClass->module, "enum");
3427
3428 _property = __ecereNameSpace__ecere__com__eClass_FindClassProperty(enumClass, name);
3429 }
3430 }
3431 return _property;
3432 }
3433
3434 long long __ecereNameSpace__ecere__com__eClass_GetProperty(struct __ecereNameSpace__ecere__com__Class * _class, char * name)
3435 {
3436 struct __ecereNameSpace__ecere__com__ClassProperty * _property = __ecereNameSpace__ecere__com__eClass_FindClassProperty(_class, name);
3437
3438 if(_property && _property->Get && _property->Get != (void *)1)
3439 {
3440 long long result = _property->Get(_class);
3441
3442 return result;
3443 }
3444 return 0;
3445 }
3446
3447 void __ecereNameSpace__ecere__com__eClass_SetProperty(struct __ecereNameSpace__ecere__com__Class * _class, char * name, long long value)
3448 {
3449 struct __ecereNameSpace__ecere__com__ClassProperty * _property = __ecereNameSpace__ecere__com__eClass_FindClassProperty(_class, name);
3450
3451 if(_property)
3452 {
3453 if(_property->Set)
3454 ((void (*)(void *, long long))_property->Set)(_class, value);
3455 }
3456 else
3457 {
3458 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Add(&_class->delayedCPValues, __extension__ ({
3459 struct __ecereNameSpace__ecere__sys__NamedLink64 * __ecereInstance1 = __ecereNameSpace__ecere__com__eSystem_New0(structSize_NamedLink64);
3460
3461 __ecereInstance1->name = name, __ecereInstance1->data = value, __ecereInstance1;
3462 }));
3463 }
3464 }
3465
3466 struct __ecereNameSpace__ecere__com__Method * __ecereNameSpace__ecere__com__eClass_FindMethod(struct __ecereNameSpace__ecere__com__Class * _class, char * name, struct __ecereNameSpace__ecere__com__Instance * module)
3467 {
3468 if(_class && name)
3469 {
3470 for(; _class; _class = _class->base)
3471 {
3472 struct __ecereNameSpace__ecere__com__Method * method;
3473
3474 if(_class->templateClass)
3475 _class = _class->templateClass;
3476 method = (struct __ecereNameSpace__ecere__com__Method *)__ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_FindString(&_class->methods, name);
3477 if(method && (method->memberAccess == 1 || _class->module == module || !method->dataTypeString))
3478 {
3479 if(!method->dataTypeString)
3480 {
3481 if(_class->module != module)
3482 {
3483 if(method->memberAccess == 1)
3484 module = _class->module;
3485 else
3486 {
3487 return (((void *)0));
3488 }
3489 }
3490 }
3491 else
3492 {
3493 return method;
3494 }
3495 }
3496 if(_class->inheritanceAccess == 2 && _class->module != module)
3497 break;
3498 }
3499 }
3500 return (((void *)0));
3501 }
3502
3503 static unsigned int __ecereNameSpace__ecere__com__ConstructInstance(void * instance, struct __ecereNameSpace__ecere__com__Class * _class, struct __ecereNameSpace__ecere__com__Class * from)
3504 {
3505 if(_class->templateClass)
3506 _class = _class->templateClass;
3507 if(_class->base && from != _class->base)
3508 {
3509 if(!__ecereNameSpace__ecere__com__ConstructInstance(instance, _class->base, from))
3510 return 0x0;
3511 }
3512 if(_class->Initialize)
3513 {
3514 void (* Initialize)(struct __ecereNameSpace__ecere__com__Instance * module) = (void *)_class->Initialize;
3515
3516 _class->Initialize = (((void *)0));
3517 Initialize(_class->module);
3518 }
3519 if(_class->Constructor)
3520 {
3521 if(!_class->Constructor(instance))
3522 {
3523 for(; _class; _class = _class->base)
3524 {
3525 if(_class->templateClass)
3526 _class = _class->templateClass;
3527 if(_class->Destructor)
3528 _class->Destructor(instance);
3529 }
3530 return 0x0;
3531 }
3532 }
3533 (_class->templateClass ? _class->templateClass : _class)->count++;
3534 return 0x1;
3535 }
3536
3537 void * __ecereNameSpace__ecere__com__eInstance_New(struct __ecereNameSpace__ecere__com__Class * _class)
3538 {
3539 struct __ecereNameSpace__ecere__com__Instance * instance = (((void *)0));
3540
3541 if(_class)
3542 {
3543 {
3544 int size = _class->structSize;
3545 int flags = (unsigned int)((struct __ecereNameSpace__ecere__com__Application *)(((char *)((struct __ecereNameSpace__ecere__com__Module *)(((char *)_class->module + structSize_Instance)))->application + structSize_Module)))->isGUIApp;
3546 unsigned int inCompiler = (flags & 8) ? 0x1 : 0x0;
3547 unsigned int force32Bits = (flags & 4) ? 0x1 : 0x0;
3548
3549 if(force32Bits && inCompiler)
3550 {
3551 if(!strcmp(_class->name, "Module"))
3552 size = 560;
3553 else if(_class->templateClass && !strcmp(_class->templateClass->name, "Map"))
3554 size = 40;
3555 else
3556 size *= 3;
3557 }
3558 instance = __ecereNameSpace__ecere__com___calloc(1, size);
3559 }
3560 if(_class->type == 0)
3561 {
3562 ((struct __ecereNameSpace__ecere__com__Instance *)(char *)instance)->_class = _class;
3563 ((struct __ecereNameSpace__ecere__com__Instance *)(char *)instance)->_vTbl = _class->_vTbl;
3564 }
3565 if(!__ecereNameSpace__ecere__com__ConstructInstance(instance, _class, (((void *)0))))
3566 {
3567 __ecereNameSpace__ecere__com___free(instance);
3568 instance = (((void *)0));
3569 }
3570 }
3571 return instance;
3572 }
3573
3574 void __ecereNameSpace__ecere__com__eInstance_Evolve(struct __ecereNameSpace__ecere__com__Instance ** instancePtr, struct __ecereNameSpace__ecere__com__Class * _class)
3575 {
3576 if(_class && instancePtr && *instancePtr)
3577 {
3578 unsigned int wasApp = 0x0, wasGuiApp = 0x0;
3579 struct __ecereNameSpace__ecere__com__Instance * instance = (struct __ecereNameSpace__ecere__com__Instance *)__ecereNameSpace__ecere__com__eSystem_Renew(*instancePtr, sizeof(unsigned char) * (_class->structSize));
3580 struct __ecereNameSpace__ecere__com__Class * fromClass = ((struct __ecereNameSpace__ecere__com__Instance *)(char *)instance)->_class;
3581
3582 *instancePtr = instance;
3583 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);
3584 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")))
3585 {
3586 struct __ecereNameSpace__ecere__com__Instance * module;
3587 struct __ecereNameSpace__ecere__com__Instance * app = (struct __ecereNameSpace__ecere__com__Instance *)instance;
3588 struct __ecereNameSpace__ecere__com__BTNamedLink * link;
3589 struct __ecereNameSpace__ecere__com__Class * _class;
3590 struct __ecereNameSpace__ecere__com__NameSpace * nameSpace;
3591
3592 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)
3593 ((struct __ecereNameSpace__ecere__com__Module *)(((char *)module + structSize_Instance)))->application = app;
3594 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)))
3595 {
3596 struct __ecereNameSpace__ecere__sys__OldLink * t;
3597
3598 ((struct __ecereNameSpace__ecere__com__Class *)link->data)->nameSpace = &((struct __ecereNameSpace__ecere__com__Module *)(((char *)app + structSize_Instance)))->privateNameSpace;
3599 for(t = ((struct __ecereNameSpace__ecere__com__Class *)link->data)->templatized.first; t; t = t->next)
3600 {
3601 struct __ecereNameSpace__ecere__com__Class * template = t->data;
3602
3603 template->nameSpace = ((struct __ecereNameSpace__ecere__com__Class *)link->data)->nameSpace;
3604 }
3605 }
3606 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)))
3607 {
3608 struct __ecereNameSpace__ecere__sys__OldLink * t;
3609
3610 ((struct __ecereNameSpace__ecere__com__Class *)link->data)->nameSpace = &((struct __ecereNameSpace__ecere__com__Module *)(((char *)app + structSize_Instance)))->publicNameSpace;
3611 for(t = ((struct __ecereNameSpace__ecere__com__Class *)link->data)->templatized.first; t; t = t->next)
3612 {
3613 struct __ecereNameSpace__ecere__com__Class * template = t->data;
3614
3615 template->nameSpace = ((struct __ecereNameSpace__ecere__com__Class *)link->data)->nameSpace;
3616 }
3617 }
3618 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)))
3619 ((struct __ecereNameSpace__ecere__com__DefinedExpression *)link->data)->nameSpace = &((struct __ecereNameSpace__ecere__com__Module *)(((char *)app + structSize_Instance)))->privateNameSpace;
3620 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)))
3621 ((struct __ecereNameSpace__ecere__com__DefinedExpression *)link->data)->nameSpace = &((struct __ecereNameSpace__ecere__com__Module *)(((char *)app + structSize_Instance)))->publicNameSpace;
3622 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)))
3623 ((struct __ecereNameSpace__ecere__com__GlobalFunction *)link->data)->nameSpace = &((struct __ecereNameSpace__ecere__com__Module *)(((char *)app + structSize_Instance)))->privateNameSpace;
3624 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)))
3625 ((struct __ecereNameSpace__ecere__com__GlobalFunction *)link->data)->nameSpace = &((struct __ecereNameSpace__ecere__com__Module *)(((char *)app + structSize_Instance)))->publicNameSpace;
3626 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)))
3627 (*nameSpace).parent = &((struct __ecereNameSpace__ecere__com__Module *)(((char *)app + structSize_Instance)))->privateNameSpace;
3628 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)))
3629 (*nameSpace).parent = &((struct __ecereNameSpace__ecere__com__Module *)(((char *)app + structSize_Instance)))->publicNameSpace;
3630 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)))
3631 {
3632 struct __ecereNameSpace__ecere__sys__OldLink * t;
3633
3634 ((struct __ecereNameSpace__ecere__com__Class *)link->data)->nameSpace = &((struct __ecereNameSpace__ecere__com__Application *)(((char *)app + structSize_Module)))->systemNameSpace;
3635 for(t = ((struct __ecereNameSpace__ecere__com__Class *)link->data)->templatized.first; t; t = t->next)
3636 {
3637 struct __ecereNameSpace__ecere__com__Class * template = t->data;
3638
3639 template->nameSpace = ((struct __ecereNameSpace__ecere__com__Class *)link->data)->nameSpace;
3640 }
3641 }
3642 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)))
3643 ((struct __ecereNameSpace__ecere__com__DefinedExpression *)link->data)->nameSpace = &((struct __ecereNameSpace__ecere__com__Application *)(((char *)app + structSize_Module)))->systemNameSpace;
3644 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)))
3645 ((struct __ecereNameSpace__ecere__com__GlobalFunction *)link->data)->nameSpace = &((struct __ecereNameSpace__ecere__com__Application *)(((char *)app + structSize_Module)))->systemNameSpace;
3646 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)))
3647 ((struct __ecereNameSpace__ecere__com__GlobalFunction *)link->data)->nameSpace = &((struct __ecereNameSpace__ecere__com__Application *)(((char *)app + structSize_Module)))->systemNameSpace;
3648 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)))
3649 (*nameSpace).parent = &((struct __ecereNameSpace__ecere__com__Application *)(((char *)app + structSize_Module)))->systemNameSpace;
3650 for(_class = ((struct __ecereNameSpace__ecere__com__Module *)(((char *)app + structSize_Instance)))->classes.first; _class; _class = _class->next)
3651 {
3652 struct __ecereNameSpace__ecere__sys__OldLink * templateLink;
3653
3654 _class->module = (struct __ecereNameSpace__ecere__com__Instance *)app;
3655 for(templateLink = _class->templatized.first; templateLink; templateLink = templateLink->next)
3656 {
3657 struct __ecereNameSpace__ecere__com__Class * template = templateLink->data;
3658
3659 template->module = _class->module;
3660 }
3661 }
3662 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)
3663 {
3664 for(_class = ((struct __ecereNameSpace__ecere__com__Module *)(((char *)module + structSize_Instance)))->classes.first; _class; _class = _class->next)
3665 {
3666 struct __ecereNameSpace__ecere__sys__OldLink * templateLink;
3667
3668 _class->module = module;
3669 for(templateLink = _class->templatized.first; templateLink; templateLink = templateLink->next)
3670 {
3671 struct __ecereNameSpace__ecere__com__Class * template = templateLink->data;
3672
3673 template->module = _class->module;
3674 }
3675 }
3676 }
3677 ((struct __ecereNameSpace__ecere__com__Module *)(((char *)app + structSize_Instance)))->application = app;
3678 }
3679 {
3680 struct __ecereNameSpace__ecere__com__Class * base;
3681
3682 for(base = ((struct __ecereNameSpace__ecere__com__Instance *)(char *)instance)->_class; base && base->type == 0 && base->count; base = base->base)
3683 (base->templateClass ? base->templateClass : base)->count--;
3684 }
3685 ((struct __ecereNameSpace__ecere__com__Instance *)(char *)instance)->_class = _class;
3686 ((struct __ecereNameSpace__ecere__com__Instance *)(char *)instance)->_vTbl = _class->_vTbl;
3687 if(!__ecereNameSpace__ecere__com__ConstructInstance(instance, _class, fromClass))
3688 {
3689 __ecereNameSpace__ecere__com___free(instance);
3690 *instancePtr = (((void *)0));
3691 }
3692 }
3693 }
3694
3695 void __ecereNameSpace__ecere__com__eInstance_Delete(struct __ecereNameSpace__ecere__com__Instance * instance)
3696 {
3697 if(instance)
3698 {
3699 struct __ecereNameSpace__ecere__com__Class * _class, * base;
3700 unsigned int ownVtbl;
3701
3702 ownVtbl = ((struct __ecereNameSpace__ecere__com__Instance *)(char *)instance)->_vTbl != ((struct __ecereNameSpace__ecere__com__Instance *)(char *)instance)->_class->_vTbl;
3703 for(_class = ((struct __ecereNameSpace__ecere__com__Instance *)(char *)instance)->_class; _class; _class = base)
3704 {
3705 if(_class->templateClass)
3706 _class = _class->templateClass;
3707 if(_class->destructionWatchOffset)
3708 {
3709 struct __ecereNameSpace__ecere__sys__OldList * watchers = (struct __ecereNameSpace__ecere__sys__OldList *)((unsigned char *)instance + _class->destructionWatchOffset);
3710 struct __ecereNameSpace__ecere__com__Watcher * watcher, * next;
3711
3712 for(watcher = (*watchers).first; watcher; watcher = next)
3713 {
3714 next = watcher->next;
3715 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Remove((&*watchers), watcher);
3716 watcher->callback(watcher->object, instance);
3717 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Delete((&*watchers), watcher);
3718 }
3719 }
3720 base = _class->base;
3721 if(base && base->type == 1000)
3722 base = (((void *)0));
3723 if(_class->Destructor)
3724 _class->Destructor(instance);
3725 }
3726 for(_class = ((struct __ecereNameSpace__ecere__com__Instance *)(char *)instance)->_class; _class; _class = base)
3727 {
3728 if(_class->templateClass)
3729 _class = _class->templateClass;
3730 base = _class->base;
3731 (_class->templateClass ? _class->templateClass : _class)->count--;
3732 if(_class->type == 0 && !_class->count && !_class->module)
3733 {
3734 __ecereNameSpace__ecere__com__eClass_Unregister(_class);
3735 }
3736 }
3737 if(ownVtbl)
3738 {
3739 (__ecereNameSpace__ecere__com__eSystem_Delete(((struct __ecereNameSpace__ecere__com__Instance *)(char *)instance)->_vTbl), ((struct __ecereNameSpace__ecere__com__Instance * )(char * )instance)->_vTbl = 0);
3740 }
3741 __ecereNameSpace__ecere__com___free(instance);
3742 }
3743 }
3744
3745 struct __ecereNameSpace__ecere__com__Property * __ecereNameSpace__ecere__com__eClass_FindProperty(struct __ecereNameSpace__ecere__com__Class * _class, char * name, struct __ecereNameSpace__ecere__com__Instance * module)
3746 {
3747 if(_class && name)
3748 {
3749 for(; _class; _class = _class->base)
3750 {
3751 struct __ecereNameSpace__ecere__com__BTNamedLink * link;
3752
3753 if(_class->templateClass)
3754 _class = _class->templateClass;
3755 link = (struct __ecereNameSpace__ecere__com__BTNamedLink *)__ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_FindString(&_class->prop, name);
3756 if(link)
3757 {
3758 struct __ecereNameSpace__ecere__com__Property * _property = (struct __ecereNameSpace__ecere__com__Property *)link->data;
3759
3760 if(_property->memberAccess == 1 || _class->module == module || !_property->dataTypeString)
3761 {
3762 if(!_property->dataTypeString)
3763 {
3764 if(_class->module != module)
3765 {
3766 if(_property->memberAccess == 1)
3767 module = _class->module;
3768 else
3769 {
3770 return (((void *)0));
3771 }
3772 }
3773 }
3774 else
3775 {
3776 return _property;
3777 }
3778 }
3779 }
3780 if(_class->inheritanceAccess == 2 && _class->module != module)
3781 break;
3782 }
3783 }
3784 return (((void *)0));
3785 }
3786
3787 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)
3788 {
3789 struct __ecereNameSpace__ecere__com__BTNamedLink * link;
3790 struct __ecereNameSpace__ecere__com__DataMember * dataMember;
3791
3792 link = (struct __ecereNameSpace__ecere__com__BTNamedLink *)__ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_FindString(alist, name);
3793 if(link)
3794 {
3795 dataMember = link->data;
3796 if(dataMember->type == 0 && (dataMember->memberAccess == 1 || searchPrivate || !dataMember->dataTypeString))
3797 {
3798 if(offset)
3799 *offset += dataMember->offset;
3800 if(id)
3801 *id = dataMember->id;
3802 return dataMember;
3803 }
3804 return (((void *)0));
3805 }
3806 for(dataMember = list->first; dataMember; dataMember = dataMember->next)
3807 {
3808 if(!dataMember->isProperty && (dataMember->memberAccess == 1 || searchPrivate) && !dataMember->name && (dataMember->type == 1 || dataMember->type == 2))
3809 {
3810 struct __ecereNameSpace__ecere__com__DataMember * childMember;
3811
3812 if(subMemberStackPos)
3813 subMemberStack[(*subMemberStackPos)++] = dataMember;
3814 childMember = __ecereNameSpace__ecere__com__FindDataMember(&dataMember->members, &dataMember->membersAlpha, name, offset, id, searchPrivate, subMemberStack, subMemberStackPos);
3815 if(childMember)
3816 {
3817 if(offset)
3818 *offset += dataMember->offset;
3819 if(id)
3820 *id += dataMember->id;
3821 return childMember;
3822 }
3823 if(subMemberStackPos)
3824 (*subMemberStackPos)--;
3825 }
3826 }
3827 return (((void *)0));
3828 }
3829
3830 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)
3831 {
3832 struct __ecereNameSpace__ecere__com__DataMember * dataMember = (((void *)0));
3833
3834 if(subMemberStackPos)
3835 *subMemberStackPos = 0;
3836 if(_class && name)
3837 {
3838 for(; _class; _class = _class->base)
3839 {
3840 if(_class->templateClass)
3841 _class = _class->templateClass;
3842 dataMember = __ecereNameSpace__ecere__com__FindDataMember(&_class->membersAndProperties, &_class->members, name, (((void *)0)), (((void *)0)), _class->module == module, subMemberStack, subMemberStackPos);
3843 if(dataMember)
3844 {
3845 if(!dataMember->dataTypeString)
3846 {
3847 if(_class->module != module)
3848 {
3849 if(dataMember->memberAccess == 1)
3850 module = _class->module;
3851 else
3852 {
3853 return (((void *)0));
3854 }
3855 }
3856 dataMember = (((void *)0));
3857 }
3858 else
3859 {
3860 dataMember->_class = _class->templateClass ? _class->templateClass : _class;
3861 return dataMember;
3862 }
3863 }
3864 if(_class->inheritanceAccess == 2 && _class->module != module)
3865 break;
3866 }
3867 }
3868 return dataMember;
3869 }
3870
3871 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)
3872 {
3873 struct __ecereNameSpace__ecere__com__DataMember * dataMember = (((void *)0));
3874
3875 if(subMemberStackPos)
3876 *subMemberStackPos = 0;
3877 if(offset)
3878 *offset = 0;
3879 if(_class)
3880 {
3881 for(; _class; _class = _class->base)
3882 {
3883 if(_class->templateClass)
3884 _class = _class->templateClass;
3885 dataMember = __ecereNameSpace__ecere__com__FindDataMember(&_class->membersAndProperties, &_class->members, name, offset, (((void *)0)), _class->module == module, subMemberStack, subMemberStackPos);
3886 if(dataMember)
3887 {
3888 if(!dataMember->dataTypeString)
3889 {
3890 if(_class->module != module)
3891 {
3892 if(dataMember->memberAccess == 1)
3893 module = _class->module;
3894 else
3895 {
3896 return (((void *)0));
3897 }
3898 }
3899 dataMember = (((void *)0));
3900 }
3901 else
3902 {
3903 dataMember->_class = _class;
3904 return dataMember;
3905 }
3906 }
3907 if(_class->inheritanceAccess == 2 && _class->module != module)
3908 break;
3909 }
3910 }
3911 return dataMember;
3912 }
3913
3914 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)
3915 {
3916 struct __ecereNameSpace__ecere__com__DataMember * dataMember = (((void *)0));
3917
3918 if(subMemberStackPos)
3919 *subMemberStackPos = 0;
3920 if(_class)
3921 {
3922 for(; _class; _class = _class->base)
3923 {
3924 if(_class->templateClass)
3925 _class = _class->templateClass;
3926 dataMember = __ecereNameSpace__ecere__com__FindDataMember(&_class->membersAndProperties, &_class->members, name, (((void *)0)), id, _class->module == module, subMemberStack, subMemberStackPos);
3927 if(dataMember)
3928 {
3929 if(!dataMember->dataTypeString)
3930 {
3931 if(_class->module != module)
3932 {
3933 if(dataMember->memberAccess == 1)
3934 module = _class->module;
3935 else
3936 {
3937 return (((void *)0));
3938 }
3939 }
3940 dataMember = (((void *)0));
3941 }
3942 else
3943 {
3944 dataMember->_class = _class;
3945 return dataMember;
3946 }
3947 }
3948 if(_class->inheritanceAccess == 2 && _class->module != module)
3949 break;
3950 }
3951 }
3952 return dataMember;
3953 }
3954
3955 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)
3956 {
3957 if(*curMember)
3958 {
3959 *curMember = (*curMember)->next;
3960 if(subMemberStackPos && *subMemberStackPos > 0 && subMemberStack[*subMemberStackPos - 1]->type == 1)
3961 {
3962 *curMember = subMemberStack[--(*subMemberStackPos)];
3963 *curMember = (*curMember)->next;
3964 }
3965 if(subMemberStackPos && *subMemberStackPos > 0)
3966 {
3967 while(*curMember && ((*curMember)->memberAccess == 2))
3968 *curMember = (*curMember)->next;
3969 }
3970 else
3971 while(*curMember && (*curMember)->name)
3972 {
3973 struct __ecereNameSpace__ecere__com__DataMember * dataMember = __ecereNameSpace__ecere__com__eClass_FindDataMember(_class, (*curMember)->name, (((void *)0)), (((void *)0)), (((void *)0)));
3974
3975 if(!dataMember)
3976 dataMember = (struct __ecereNameSpace__ecere__com__DataMember *)__ecereNameSpace__ecere__com__eClass_FindProperty(_class, (*curMember)->name, (((void *)0)));
3977 if(dataMember && dataMember->memberAccess != 2)
3978 {
3979 *curMember = dataMember;
3980 break;
3981 }
3982 else
3983 *curMember = (*curMember)->next;
3984 }
3985 if(subMemberStackPos)
3986 {
3987 while((*curMember) && !(*curMember)->isProperty && !(*curMember)->name && ((*curMember)->type == 2 || (*curMember)->type == 1))
3988 {
3989 subMemberStack[(*subMemberStackPos)++] = *curMember;
3990 *curMember = (*curMember)->members.first;
3991 while(*curMember && ((*curMember)->memberAccess == 2))
3992 *curMember = (*curMember)->next;
3993 }
3994 }
3995 }
3996 while(!*curMember)
3997 {
3998 if(!*curMember)
3999 {
4000 if(subMemberStackPos && *subMemberStackPos)
4001 {
4002 *curMember = subMemberStack[--(*subMemberStackPos)];
4003 *curMember = (*curMember)->next;
4004 }
4005 else
4006 {
4007 struct __ecereNameSpace__ecere__com__Class * lastCurClass = *curClass;
4008
4009 if(*curClass == _class)
4010 break;
4011 for(*curClass = _class; (*curClass)->base != lastCurClass && (*curClass)->base->type != 1000 && (*curClass)->inheritanceAccess != 2; *curClass = (*curClass)->base)
4012 ;
4013 *curMember = (*curClass)->membersAndProperties.first;
4014 }
4015 if(subMemberStackPos && *subMemberStackPos > 0)
4016 {
4017 while(*curMember && ((*curMember)->memberAccess == 2))
4018 *curMember = (*curMember)->next;
4019 }
4020 else
4021 while(*curMember && (*curMember)->name)
4022 {
4023 struct __ecereNameSpace__ecere__com__DataMember * dataMember = __ecereNameSpace__ecere__com__eClass_FindDataMember(_class, (*curMember)->name, (((void *)0)), (((void *)0)), (((void *)0)));
4024
4025 if(!dataMember)
4026 dataMember = (struct __ecereNameSpace__ecere__com__DataMember *)__ecereNameSpace__ecere__com__eClass_FindProperty(_class, (*curMember)->name, (((void *)0)));
4027 if(dataMember && dataMember->memberAccess != 2)
4028 {
4029 *curMember = dataMember;
4030 break;
4031 }
4032 else
4033 *curMember = (*curMember)->next;
4034 }
4035 if(subMemberStackPos)
4036 {
4037 while((*curMember) && !(*curMember)->isProperty && !(*curMember)->name && ((*curMember)->type == 2 || (*curMember)->type == 1))
4038 {
4039 subMemberStack[(*subMemberStackPos)++] = *curMember;
4040 *curMember = (*curMember)->members.first;
4041 while(*curMember && (*curMember)->memberAccess == 2)
4042 *curMember = (*curMember)->next;
4043 }
4044 }
4045 }
4046 }
4047 }
4048
4049 void __ecereNameSpace__ecere__com__eInstance_SetMethod(struct __ecereNameSpace__ecere__com__Instance * instance, char * name, void * function)
4050 {
4051 if(instance && name)
4052 {
4053 struct __ecereNameSpace__ecere__com__Class * _class;
4054
4055 for(_class = ((struct __ecereNameSpace__ecere__com__Instance *)(char *)instance)->_class; _class; _class = _class->base)
4056 {
4057 struct __ecereNameSpace__ecere__com__Method * method = (struct __ecereNameSpace__ecere__com__Method *)__ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_FindString(&_class->methods, name);
4058
4059 if(method && method->type == 1)
4060 {
4061 if(((struct __ecereNameSpace__ecere__com__Instance *)(char *)instance)->_vTbl == ((struct __ecereNameSpace__ecere__com__Instance *)(char *)instance)->_class->_vTbl)
4062 {
4063 ((struct __ecereNameSpace__ecere__com__Instance *)(char *)instance)->_vTbl = __ecereNameSpace__ecere__com___malloc(sizeof(void *) * ((struct __ecereNameSpace__ecere__com__Instance *)(char *)instance)->_class->vTblSize);
4064 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);
4065 }
4066 ((struct __ecereNameSpace__ecere__com__Instance *)(char *)instance)->_vTbl[method->vid] = function ? function : __ecereNameSpace__ecere__com__DefaultFunction;
4067 }
4068 }
4069 }
4070 }
4071
4072 unsigned int __ecereNameSpace__ecere__com__eInstance_IsDerived(struct __ecereNameSpace__ecere__com__Instance * instance, struct __ecereNameSpace__ecere__com__Class * from)
4073 {
4074 if(instance)
4075 {
4076 struct __ecereNameSpace__ecere__com__Class * _class = ((struct __ecereNameSpace__ecere__com__Instance *)(char *)instance)->_class;
4077
4078 for(; _class; _class = _class->base)
4079 {
4080 if(_class == from)
4081 return 0x1;
4082 }
4083 }
4084 return 0x0;
4085 }
4086
4087 void __ecereNameSpace__ecere__com__eInstance_IncRef(struct __ecereNameSpace__ecere__com__Instance * instance)
4088 {
4089 if(instance)
4090 ((struct __ecereNameSpace__ecere__com__Instance *)(char *)instance)->_refCount++;
4091 }
4092
4093 void __ecereNameSpace__ecere__com__eInstance_DecRef(struct __ecereNameSpace__ecere__com__Instance * instance)
4094 {
4095 if(instance)
4096 {
4097 ((struct __ecereNameSpace__ecere__com__Instance *)(char *)instance)->_refCount--;
4098 if(((struct __ecereNameSpace__ecere__com__Instance *)(char *)instance)->_refCount <= 0)
4099 {
4100 __ecereNameSpace__ecere__com__eInstance_Delete(instance);
4101 }
4102 }
4103 }
4104
4105 static void __ecereNameSpace__ecere__com__FixOffsets(struct __ecereNameSpace__ecere__com__Class * _class)
4106 {
4107 struct __ecereNameSpace__ecere__sys__OldLink * deriv;
4108
4109 _class->structSize += _class->base->structSize - _class->offset;
4110 _class->offset = _class->base->structSize;
4111 for(deriv = _class->derivatives.first; deriv; deriv = deriv->next)
4112 __ecereNameSpace__ecere__com__FixOffsets(deriv->data);
4113 }
4114
4115 void __ecereNameSpace__ecere__com__eClass_Resize(struct __ecereNameSpace__ecere__com__Class * _class, int newSize)
4116 {
4117 struct __ecereNameSpace__ecere__sys__OldLink * deriv;
4118
4119 _class->structSize = newSize;
4120 for(deriv = _class->derivatives.first; deriv; deriv = deriv->next)
4121 __ecereNameSpace__ecere__com__FixOffsets(deriv->data);
4122 }
4123
4124 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)
4125 {
4126 if(_class && name)
4127 {
4128 if(!__ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_FindString(&_class->members, name))
4129 {
4130 struct __ecereNameSpace__ecere__com__DataMember * dataMember;
4131
4132 if(alignment)
4133 {
4134 int __simpleStruct0;
4135
4136 _class->structAlignment = (__simpleStruct0 = _class->structAlignment, (__simpleStruct0 > alignment) ? __simpleStruct0 : alignment);
4137 if(_class->memberOffset % alignment)
4138 _class->memberOffset += alignment - (_class->memberOffset % alignment);
4139 }
4140 dataMember = __extension__ ({
4141 struct __ecereNameSpace__ecere__com__DataMember * __ecereInstance1 = __ecereNameSpace__ecere__com__eSystem_New0(structSize_DataMember);
4142
4143 __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;
4144 });
4145 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Add(&_class->membersAndProperties, dataMember);
4146 _class->memberOffset += size;
4147 __ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_Add(&_class->members, (struct __ecereNameSpace__ecere__sys__BTNode *)__extension__ ({
4148 struct __ecereNameSpace__ecere__com__BTNamedLink * __ecereInstance1 = __ecereNameSpace__ecere__com__eSystem_New0(structSize_BTNamedLink);
4149
4150 __ecereInstance1->name = dataMember->name, __ecereInstance1->data = dataMember, __ecereInstance1;
4151 }));
4152 return dataMember;
4153 }
4154 }
4155 return (((void *)0));
4156 }
4157
4158 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)
4159 {
4160 if(name && !__ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_FindString(&member->membersAlpha, name))
4161 {
4162 struct __ecereNameSpace__ecere__com__DataMember * dataMember;
4163
4164 if(alignment)
4165 {
4166 int __simpleStruct0;
4167
4168 member->structAlignment = (__simpleStruct0 = member->structAlignment, (__simpleStruct0 > alignment) ? __simpleStruct0 : alignment);
4169 if(member->memberOffset % alignment)
4170 member->memberOffset += alignment - (member->memberOffset % alignment);
4171 }
4172 dataMember = __extension__ ({
4173 struct __ecereNameSpace__ecere__com__DataMember * __ecereInstance1 = __ecereNameSpace__ecere__com__eSystem_New0(structSize_DataMember);
4174
4175 __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;
4176 });
4177 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Add(&member->members, dataMember);
4178 if(member->type == 1)
4179 {
4180 if(size > member->memberOffset)
4181 member->memberOffset = size;
4182 }
4183 else
4184 member->memberOffset += size;
4185 __ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_Add(&member->membersAlpha, (struct __ecereNameSpace__ecere__sys__BTNode *)__extension__ ({
4186 struct __ecereNameSpace__ecere__com__BTNamedLink * __ecereInstance1 = __ecereNameSpace__ecere__com__eSystem_New0(structSize_BTNamedLink);
4187
4188 __ecereInstance1->name = dataMember->name, __ecereInstance1->data = dataMember, __ecereInstance1;
4189 }));
4190 return dataMember;
4191 }
4192 return (((void *)0));
4193 }
4194
4195 struct __ecereNameSpace__ecere__com__DataMember * __ecereNameSpace__ecere__com__eMember_New(int type, int declMode)
4196 {
4197 return __extension__ ({
4198 struct __ecereNameSpace__ecere__com__DataMember * __ecereInstance1 = __ecereNameSpace__ecere__com__eSystem_New0(structSize_DataMember);
4199
4200 __ecereInstance1->type = type, __ecereInstance1->memberAccess = declMode, __ecereInstance1->membersAlpha.CompareKey = (void *)__ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_CompareString, __ecereInstance1;
4201 });
4202 }
4203
4204 static void __ecereNameSpace__ecere__com__SetMemberClass(struct __ecereNameSpace__ecere__com__DataMember * member, struct __ecereNameSpace__ecere__com__Class * _class)
4205 {
4206 struct __ecereNameSpace__ecere__com__DataMember * dataMember;
4207
4208 member->_class = _class;
4209 for(dataMember = member->members.first; dataMember; dataMember = dataMember->next)
4210 __ecereNameSpace__ecere__com__SetMemberClass(dataMember, _class);
4211 }
4212
4213 unsigned int __ecereNameSpace__ecere__com__eMember_AddMember(struct __ecereNameSpace__ecere__com__DataMember * addTo, struct __ecereNameSpace__ecere__com__DataMember * dataMember)
4214 {
4215 int __simpleStruct0, __simpleStruct1;
4216
4217 if(dataMember->name && __ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_FindString(&addTo->membersAlpha, dataMember->name))
4218 return 0x0;
4219 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Add(&addTo->members, dataMember);
4220 if(dataMember->name)
4221 __ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_Add(&addTo->membersAlpha, (struct __ecereNameSpace__ecere__sys__BTNode *)__extension__ ({
4222 struct __ecereNameSpace__ecere__com__BTNamedLink * __ecereInstance1 = __ecereNameSpace__ecere__com__eSystem_New0(structSize_BTNamedLink);
4223
4224 __ecereInstance1->name = dataMember->name, __ecereInstance1->data = dataMember, __ecereInstance1;
4225 }));
4226 dataMember->_class = addTo->_class;
4227 dataMember->id = addTo->memberID;
4228 if(dataMember->type == 1)
4229 addTo->memberID += 1;
4230 else
4231 addTo->memberID += dataMember->memberID;
4232 addTo->structAlignment = (__simpleStruct0 = addTo->structAlignment, __simpleStruct1 = dataMember->structAlignment, (__simpleStruct0 > __simpleStruct1) ? __simpleStruct0 : __simpleStruct1);
4233 dataMember->offset = (addTo->type == 1) ? 0 : addTo->memberOffset;
4234 if(addTo->type == 1)
4235 {
4236 if(dataMember->memberOffset > addTo->memberOffset)
4237 addTo->memberOffset = dataMember->memberOffset;
4238 }
4239 else
4240 addTo->memberOffset += dataMember->memberOffset;
4241 return 0x1;
4242 }
4243
4244 unsigned int __ecereNameSpace__ecere__com__eClass_AddMember(struct __ecereNameSpace__ecere__com__Class * _class, struct __ecereNameSpace__ecere__com__DataMember * dataMember)
4245 {
4246 int __simpleStruct0, __simpleStruct1;
4247
4248 if(!_class || _class->comRedefinition || (dataMember->name && __ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_FindString(&_class->members, dataMember->name)))
4249 return 0x0;
4250 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Add(&_class->membersAndProperties, dataMember);
4251 if(dataMember->name)
4252 __ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_Add(&_class->members, (struct __ecereNameSpace__ecere__sys__BTNode *)__extension__ ({
4253 struct __ecereNameSpace__ecere__com__BTNamedLink * __ecereInstance1 = __ecereNameSpace__ecere__com__eSystem_New0(structSize_BTNamedLink);
4254
4255 __ecereInstance1->name = dataMember->name, __ecereInstance1->data = dataMember, __ecereInstance1;
4256 }));
4257 __ecereNameSpace__ecere__com__SetMemberClass(dataMember, _class);
4258 dataMember->id = _class->memberID;
4259 _class->structAlignment = (__simpleStruct0 = _class->structAlignment, __simpleStruct1 = dataMember->structAlignment, (__simpleStruct0 > __simpleStruct1) ? __simpleStruct0 : __simpleStruct1);
4260 if(dataMember->type == 1)
4261 _class->memberID += 1;
4262 else
4263 _class->memberID += dataMember->memberID;
4264 dataMember->offset = _class->memberOffset;
4265 _class->memberOffset += dataMember->memberOffset;
4266 return 0x1;
4267 }
4268
4269 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)
4270 {
4271 if(_class && name && !__ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_FindString(&_class->members, name))
4272 {
4273 uint64 mask = 0;
4274 int c;
4275 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);
4276
4277 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Add(&_class->membersAndProperties, bitMember);
4278 if(bitSize)
4279 {
4280 bitMember->pos = (bitPos == -1) ? _class->memberOffset : bitPos;
4281 bitMember->size = bitSize;
4282 _class->memberOffset = bitMember->pos + bitMember->size;
4283 for(c = 0; c < bitSize; c++)
4284 {
4285 if(c)
4286 mask <<= 1;
4287 mask |= 1;
4288 }
4289 bitMember->mask = mask << bitMember->pos;
4290 }
4291 __ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_Add(&_class->members, (struct __ecereNameSpace__ecere__sys__BTNode *)__extension__ ({
4292 struct __ecereNameSpace__ecere__com__BTNamedLink * __ecereInstance1 = __ecereNameSpace__ecere__com__eSystem_New0(structSize_BTNamedLink);
4293
4294 __ecereInstance1->name = bitMember->name, __ecereInstance1->data = bitMember, __ecereInstance1;
4295 }));
4296 return bitMember;
4297 }
4298 return (((void *)0));
4299 }
4300
4301 static struct __ecereNameSpace__ecere__com__Instance * __ecereNameSpace__ecere__com__Module_Load(struct __ecereNameSpace__ecere__com__Instance * fromModule, char * name, int importAccess, unsigned int ensureCOM)
4302 {
4303 unsigned int (stdcall * Load)(struct __ecereNameSpace__ecere__com__Instance * module) = (((void *)0));
4304 unsigned int (stdcall * Unload)(struct __ecereNameSpace__ecere__com__Instance * module) = (((void *)0));
4305 struct __ecereNameSpace__ecere__com__Instance * module;
4306
4307 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)
4308 {
4309 if(!strcmp(((struct __ecereNameSpace__ecere__com__Module *)(((char *)module + structSize_Instance)))->name, name))
4310 break;
4311 }
4312 if(ensureCOM && (!strcmp(name, "ecereCOM") || !strcmp(name, "ecere")))
4313 {
4314 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)
4315 {
4316 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"))
4317 break;
4318 }
4319 }
4320 if(!module)
4321 {
4322 void * library = (((void *)0));
4323
4324 if(ensureCOM && !strcmp(name, "ecereCOM"))
4325 {
4326 Load = __ecereDll_Load_ecere;
4327 Unload = __ecereDll_Unload_ecere;
4328 }
4329 else
4330 {
4331 char * libLocation = (((void *)0));
4332
4333 library = Instance_Module_Load(libLocation, name, &Load, &Unload);
4334 }
4335 if(Load)
4336 {
4337 module = (struct __ecereNameSpace__ecere__com__Instance *)__ecereNameSpace__ecere__com__eInstance_New(__ecereNameSpace__ecere__com__eSystem_FindClass(fromModule, "Module"));
4338 ((struct __ecereNameSpace__ecere__com__Module *)(((char *)module + structSize_Instance)))->application = ((struct __ecereNameSpace__ecere__com__Module *)(((char *)fromModule + structSize_Instance)))->application;
4339 ((struct __ecereNameSpace__ecere__com__Module *)(((char *)module + structSize_Instance)))->library = library;
4340 ((struct __ecereNameSpace__ecere__com__Module *)(((char *)module + structSize_Instance)))->name = __ecereNameSpace__ecere__sys__CopyString(name);
4341 ((struct __ecereNameSpace__ecere__com__Module *)(((char *)module + structSize_Instance)))->Unload = Unload;
4342 ((struct __ecereNameSpace__ecere__com__Module *)(((char *)module + structSize_Instance)))->origImportType = 0;
4343 if(!Load(module))
4344 {
4345 __ecereNameSpace__ecere__com__eInstance_Delete((struct __ecereNameSpace__ecere__com__Instance *)module);
4346 module = (((void *)0));
4347 }
4348 }
4349 __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);
4350 }
4351 if(ensureCOM && !strcmp(name, "ecere") && module)
4352 {
4353 name = !strcmp(((struct __ecereNameSpace__ecere__com__Module *)(((char *)module + structSize_Instance)))->name, "ecereCOM") ? "ecere" : "ecereCOM";
4354 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))
4355 {
4356 struct __ecereNameSpace__ecere__com__Instance * module;
4357
4358 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)
4359 {
4360 if(!strcmp(((struct __ecereNameSpace__ecere__com__Module *)(((char *)module + structSize_Instance)))->name, name))
4361 break;
4362 }
4363 if(!module)
4364 {
4365 Load = __ecereDll_Load_ecere;
4366 Unload = __ecereDll_Unload_ecere;
4367 module = (struct __ecereNameSpace__ecere__com__Instance *)__ecereNameSpace__ecere__com__eInstance_New(__ecereNameSpace__ecere__com__eSystem_FindClass(fromModule, "Module"));
4368 ((struct __ecereNameSpace__ecere__com__Module *)(((char *)module + structSize_Instance)))->application = ((struct __ecereNameSpace__ecere__com__Module *)(((char *)fromModule + structSize_Instance)))->application;
4369 ((struct __ecereNameSpace__ecere__com__Module *)(((char *)module + structSize_Instance)))->library = (((void *)0));
4370 ((struct __ecereNameSpace__ecere__com__Module *)(((char *)module + structSize_Instance)))->name = __ecereNameSpace__ecere__sys__CopyString(name);
4371 ((struct __ecereNameSpace__ecere__com__Module *)(((char *)module + structSize_Instance)))->Unload = Unload;
4372 if(!Load(module))
4373 {
4374 __ecereNameSpace__ecere__com__eInstance_Delete((struct __ecereNameSpace__ecere__com__Instance *)module);
4375 module = (((void *)0));
4376 }
4377 __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);
4378 }
4379 if(module)
4380 {
4381 if(fromModule)
4382 {
4383 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Add(&((struct __ecereNameSpace__ecere__com__Module *)(((char *)fromModule + structSize_Instance)))->modules, __extension__ ({
4384 struct __ecereNameSpace__ecere__com__SubModule * __ecereInstance1 = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass___ecereNameSpace__ecere__com__SubModule);
4385
4386 __ecereInstance1->module = module, __ecereInstance1->importMode = importAccess, __ecereInstance1;
4387 }));
4388 }
4389 module->_refCount++;
4390 }
4391 }
4392 }
4393 if(module)
4394 {
4395 if(fromModule)
4396 {
4397 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Add(&((struct __ecereNameSpace__ecere__com__Module *)(((char *)fromModule + structSize_Instance)))->modules, __extension__ ({
4398 struct __ecereNameSpace__ecere__com__SubModule * __ecereInstance1 = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass___ecereNameSpace__ecere__com__SubModule);
4399
4400 __ecereInstance1->module = module, __ecereInstance1->importMode = importAccess, __ecereInstance1;
4401 }));
4402 }
4403 module->_refCount++;
4404 }
4405 return module;
4406 }
4407
4408 struct __ecereNameSpace__ecere__com__Instance * __ecereNameSpace__ecere__com__eModule_Load(struct __ecereNameSpace__ecere__com__Instance * fromModule, char * name, int importAccess)
4409 {
4410 return __ecereNameSpace__ecere__com__Module_Load(fromModule, name, importAccess, 0x1);
4411 }
4412
4413 struct __ecereNameSpace__ecere__com__Instance * __ecereNameSpace__ecere__com__eModule_LoadStrict(struct __ecereNameSpace__ecere__com__Instance * fromModule, char * name, int importAccess)
4414 {
4415 return __ecereNameSpace__ecere__com__Module_Load(fromModule, name, importAccess, 0x0);
4416 }
4417
4418 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))
4419 {
4420 struct __ecereNameSpace__ecere__com__Instance * module;
4421
4422 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)
4423 {
4424 if(!strcmp(((struct __ecereNameSpace__ecere__com__Module *)(((char *)module + structSize_Instance)))->name, name))
4425 break;
4426 }
4427 if(!module)
4428 {
4429 if(Load)
4430 {
4431 module = (struct __ecereNameSpace__ecere__com__Instance *)__ecereNameSpace__ecere__com__eInstance_New(__ecereNameSpace__ecere__com__eSystem_FindClass(fromModule, "Module"));
4432 ((struct __ecereNameSpace__ecere__com__Module *)(((char *)module + structSize_Instance)))->application = ((struct __ecereNameSpace__ecere__com__Module *)(((char *)fromModule + structSize_Instance)))->application;
4433 ((struct __ecereNameSpace__ecere__com__Module *)(((char *)module + structSize_Instance)))->name = __ecereNameSpace__ecere__sys__CopyString(name);
4434 ((struct __ecereNameSpace__ecere__com__Module *)(((char *)module + structSize_Instance)))->origImportType = 1;
4435 ((struct __ecereNameSpace__ecere__com__Module *)(((char *)module + structSize_Instance)))->Unload = (void *)Unload;
4436 if(!Load(module))
4437 {
4438 __ecereNameSpace__ecere__com__eInstance_Delete((struct __ecereNameSpace__ecere__com__Instance *)module);
4439 module = (((void *)0));
4440 }
4441 }
4442 __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);
4443 }
4444 if(module)
4445 {
4446 if(fromModule)
4447 {
4448 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Add(&((struct __ecereNameSpace__ecere__com__Module *)(((char *)fromModule + structSize_Instance)))->modules, __extension__ ({
4449 struct __ecereNameSpace__ecere__com__SubModule * __ecereInstance1 = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass___ecereNameSpace__ecere__com__SubModule);
4450
4451 __ecereInstance1->module = module, __ecereInstance1->importMode = importAccess, __ecereInstance1;
4452 }));
4453 }
4454 module->_refCount++;
4455 }
4456 return module;
4457 }
4458
4459 void __ecereNameSpace__ecere__com__eModule_Unload(struct __ecereNameSpace__ecere__com__Instance * fromModule, struct __ecereNameSpace__ecere__com__Instance * module)
4460 {
4461 struct __ecereNameSpace__ecere__sys__OldLink * m;
4462
4463 for(m = ((struct __ecereNameSpace__ecere__com__Module *)(((char *)fromModule + structSize_Instance)))->modules.first; m; m = m->next)
4464 {
4465 if(m->data == module)
4466 break;
4467 }
4468 if(m)
4469 {
4470 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Delete(&((struct __ecereNameSpace__ecere__com__Module *)(((char *)fromModule + structSize_Instance)))->modules, m);
4471 (__ecereNameSpace__ecere__com__eInstance_DecRef(module), module = 0);
4472 }
4473 }
4474
4475 void __ecereNameSpace__ecere__com__eEnum_AddFixedValue(struct __ecereNameSpace__ecere__com__Class * _class, char * string, int value)
4476 {
4477 if(_class && _class->type == 4)
4478 {
4479 struct __ecereNameSpace__ecere__com__EnumClassData * data = (struct __ecereNameSpace__ecere__com__EnumClassData *)_class->data;
4480 struct __ecereNameSpace__ecere__sys__NamedLink * item;
4481
4482 for(item = data->values.first; item; item = item->next)
4483 if(!strcmp(item->name, string))
4484 break;
4485 if(!item)
4486 {
4487 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Add(&data->values, __extension__ ({
4488 struct __ecereNameSpace__ecere__sys__NamedLink * __ecereInstance1 = __ecereNameSpace__ecere__com__eSystem_New0(structSize_NamedLink);
4489
4490 __ecereInstance1->data = (void *)value, __ecereInstance1->name = __ecereNameSpace__ecere__sys__CopyString(string), __ecereInstance1;
4491 }));
4492 if(value > data->largest)
4493 data->largest = value;
4494 }
4495 }
4496 }
4497
4498 int __ecereNameSpace__ecere__com__eEnum_AddValue(struct __ecereNameSpace__ecere__com__Class * _class, char * string)
4499 {
4500 if(_class && _class->type == 4)
4501 {
4502 struct __ecereNameSpace__ecere__com__EnumClassData * data = (struct __ecereNameSpace__ecere__com__EnumClassData *)_class->data;
4503 int value = data->largest + 1;
4504 struct __ecereNameSpace__ecere__sys__NamedLink * item;
4505
4506 for(item = data->values.first; item; item = item->next)
4507 if(!strcmp(item->name, string))
4508 break;
4509 if(!item)
4510 {
4511 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Add(&data->values, __extension__ ({
4512 struct __ecereNameSpace__ecere__sys__NamedLink * __ecereInstance1 = __ecereNameSpace__ecere__com__eSystem_New0(structSize_NamedLink);
4513
4514 __ecereInstance1->data = (void *)value, __ecereInstance1->name = __ecereNameSpace__ecere__sys__CopyString(string), __ecereInstance1;
4515 }));
4516 if(value > data->largest)
4517 data->largest = value;
4518 return value;
4519 }
4520 }
4521 return -1;
4522 }
4523
4524 static void __ecereNameSpace__ecere__com__NameSpace_Free(struct __ecereNameSpace__ecere__com__NameSpace * parentNameSpace)
4525 {
4526 struct __ecereNameSpace__ecere__com__NameSpace * nameSpace;
4527
4528 (__ecereNameSpace__ecere__com__eSystem_Delete(parentNameSpace->name), parentNameSpace->name = 0);
4529 while((nameSpace = (struct __ecereNameSpace__ecere__com__NameSpace *)__ecereProp___ecereNameSpace__ecere__sys__BinaryTree_Get_first(&parentNameSpace->nameSpaces)))
4530 {
4531 __ecereNameSpace__ecere__com__NameSpace_Free(nameSpace);
4532 __ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_Delete(&parentNameSpace->nameSpaces, (struct __ecereNameSpace__ecere__sys__BTNode *)nameSpace);
4533 }
4534 }
4535
4536 static void __ecereNameSpace__ecere__com__Application_Destructor(struct __ecereNameSpace__ecere__com__Instance * app)
4537 {
4538 if(((struct __ecereNameSpace__ecere__com__Application *)(((char *)app + structSize_Module)))->parsedCommand)
4539 {
4540 (__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);
4541 (__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);
4542 }
4543 }
4544
4545 static unsigned int __ecereNameSpace__ecere__com__Module_Constructor(struct __ecereNameSpace__ecere__com__Instance * module)
4546 {
4547 ((struct __ecereNameSpace__ecere__com__Module *)(((char *)module + structSize_Instance)))->privateNameSpace.classes.CompareKey = (void *)__ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_CompareString;
4548 ((struct __ecereNameSpace__ecere__com__Module *)(((char *)module + structSize_Instance)))->privateNameSpace.defines.CompareKey = (void *)__ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_CompareString;
4549 ((struct __ecereNameSpace__ecere__com__Module *)(((char *)module + structSize_Instance)))->privateNameSpace.functions.CompareKey = (void *)__ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_CompareString;
4550 ((struct __ecereNameSpace__ecere__com__Module *)(((char *)module + structSize_Instance)))->privateNameSpace.nameSpaces.CompareKey = (void *)__ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_CompareString;
4551 ((struct __ecereNameSpace__ecere__com__Module *)(((char *)module + structSize_Instance)))->publicNameSpace.classes.CompareKey = (void *)__ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_CompareString;
4552 ((struct __ecereNameSpace__ecere__com__Module *)(((char *)module + structSize_Instance)))->publicNameSpace.defines.CompareKey = (void *)__ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_CompareString;
4553 ((struct __ecereNameSpace__ecere__com__Module *)(((char *)module + structSize_Instance)))->publicNameSpace.functions.CompareKey = (void *)__ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_CompareString;
4554 ((struct __ecereNameSpace__ecere__com__Module *)(((char *)module + structSize_Instance)))->publicNameSpace.nameSpaces.CompareKey = (void *)__ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_CompareString;
4555 return 0x1;
4556 }
4557
4558 static void __ecereNameSpace__ecere__com__Module_Destructor(struct __ecereNameSpace__ecere__com__Instance * module)
4559 {
4560 struct __ecereNameSpace__ecere__com__Class * _class;
4561 struct __ecereNameSpace__ecere__com__DefinedExpression * def;
4562 struct __ecereNameSpace__ecere__com__GlobalFunction * function;
4563 struct __ecereNameSpace__ecere__com__Instance * m;
4564 struct __ecereNameSpace__ecere__com__SubModule * handle;
4565
4566 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)
4567 {
4568 struct __ecereNameSpace__ecere__com__SubModule * next;
4569
4570 for(handle = ((struct __ecereNameSpace__ecere__com__Module *)(((char *)m + structSize_Instance)))->modules.first; handle; handle = next)
4571 {
4572 next = handle->next;
4573 if(handle->module == module)
4574 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Delete(&((struct __ecereNameSpace__ecere__com__Module *)(((char *)m + structSize_Instance)))->modules, handle);
4575 }
4576 }
4577 if(((struct __ecereNameSpace__ecere__com__Module *)(((char *)module + structSize_Instance)))->Unload)
4578 {
4579 if(((struct __ecereNameSpace__ecere__com__Module *)(((char *)module + structSize_Instance)))->origImportType == 1)
4580 {
4581 unsigned int (* Unload)(struct __ecereNameSpace__ecere__com__Instance * module) = (void *)((struct __ecereNameSpace__ecere__com__Module *)(((char *)module + structSize_Instance)))->Unload;
4582
4583 Unload(module);
4584 }
4585 else
4586 {
4587 unsigned int (stdcall * Unload)(struct __ecereNameSpace__ecere__com__Instance * module) = (void *)((struct __ecereNameSpace__ecere__com__Module *)(((char *)module + structSize_Instance)))->Unload;
4588
4589 Unload(module);
4590 }
4591 }
4592 {
4593 struct __ecereNameSpace__ecere__com__Instance * ourWorld = __ecereClass___ecereNameSpace__ecere__com__Class->module;
4594 void * ourHandle = (((void *)0));
4595
4596 while((handle = ((struct __ecereNameSpace__ecere__com__Module *)(((char *)module + structSize_Instance)))->modules.last))
4597 {
4598 struct __ecereNameSpace__ecere__com__Instance * depModule = handle->module;
4599
4600 if(depModule == ourWorld)
4601 {
4602 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Remove(&((struct __ecereNameSpace__ecere__com__Module *)(((char *)module + structSize_Instance)))->modules, handle);
4603 ourHandle = handle;
4604 }
4605 else
4606 {
4607 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Delete(&((struct __ecereNameSpace__ecere__com__Module *)(((char *)module + structSize_Instance)))->modules, handle);
4608 (__ecereNameSpace__ecere__com__eInstance_DecRef(depModule), depModule = 0);
4609 }
4610 }
4611 if(ourHandle)
4612 {
4613 (__ecereNameSpace__ecere__com__eSystem_Delete(ourHandle), ourHandle = 0);
4614 (__ecereNameSpace__ecere__com__eInstance_DecRef(ourWorld), ourWorld = 0);
4615 }
4616 }
4617 for(; (_class = ((struct __ecereNameSpace__ecere__com__Module *)(((char *)module + structSize_Instance)))->classes.first); )
4618 {
4619 if(_class->nameSpace)
4620 {
4621 struct __ecereNameSpace__ecere__com__BTNamedLink * classLink = (struct __ecereNameSpace__ecere__com__BTNamedLink *)__ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_FindString(&(*_class->nameSpace).classes, _class->name);
4622 struct __ecereNameSpace__ecere__sys__OldLink * t;
4623
4624 for(t = _class->templatized.first; t; t = t->next)
4625 {
4626 struct __ecereNameSpace__ecere__com__Class * template = t->data;
4627 struct __ecereNameSpace__ecere__com__BTNamedLink * link;
4628
4629 link = (struct __ecereNameSpace__ecere__com__BTNamedLink *)__ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_FindString(&(*template->nameSpace).classes, template->name);
4630 __ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_Delete(&(*template->nameSpace).classes, (struct __ecereNameSpace__ecere__sys__BTNode *)link);
4631 template->nameSpace = (((void *)0));
4632 }
4633 __ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_Delete(&(*_class->nameSpace).classes, (struct __ecereNameSpace__ecere__sys__BTNode *)classLink);
4634 _class->nameSpace = (((void *)0));
4635 }
4636 _class->module = (((void *)0));
4637 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Remove(&((struct __ecereNameSpace__ecere__com__Module *)(((char *)module + structSize_Instance)))->classes, _class);
4638 if(!_class->count || _class->type != 0)
4639 __ecereNameSpace__ecere__com__eClass_Unregister(_class);
4640 else
4641 {
4642 }
4643 }
4644 for(; (def = ((struct __ecereNameSpace__ecere__com__Module *)(((char *)module + structSize_Instance)))->defines.first); )
4645 {
4646 if(def->nameSpace)
4647 {
4648 struct __ecereNameSpace__ecere__com__BTNamedLink * defLink;
4649
4650 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)))
4651 if(defLink->data == def)
4652 {
4653 __ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_Delete(&(*def->nameSpace).defines, (struct __ecereNameSpace__ecere__sys__BTNode *)defLink);
4654 break;
4655 }
4656 }
4657 (__ecereNameSpace__ecere__com__eSystem_Delete(def->name), def->name = 0);
4658 (__ecereNameSpace__ecere__com__eSystem_Delete(def->value), def->value = 0);
4659 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Delete(&((struct __ecereNameSpace__ecere__com__Module *)(((char *)module + structSize_Instance)))->defines, def);
4660 }
4661 for(; (function = ((struct __ecereNameSpace__ecere__com__Module *)(((char *)module + structSize_Instance)))->functions.first); )
4662 {
4663 if(function->nameSpace)
4664 {
4665 struct __ecereNameSpace__ecere__com__BTNamedLink * functionLink;
4666
4667 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)))
4668 if(functionLink->data == function)
4669 {
4670 __ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_Delete(&(*function->nameSpace).functions, (struct __ecereNameSpace__ecere__sys__BTNode *)functionLink);
4671 break;
4672 }
4673 }
4674 (__ecereNameSpace__ecere__com__eSystem_Delete(function->name), function->name = 0);
4675 (__ecereNameSpace__ecere__com__eSystem_Delete(function->dataTypeString), function->dataTypeString = 0);
4676 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Delete(&((struct __ecereNameSpace__ecere__com__Module *)(((char *)module + structSize_Instance)))->functions, function);
4677 }
4678 (__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);
4679 __ecereNameSpace__ecere__com__NameSpace_Free(&((struct __ecereNameSpace__ecere__com__Module *)(((char *)module + structSize_Instance)))->privateNameSpace);
4680 __ecereNameSpace__ecere__com__NameSpace_Free(&((struct __ecereNameSpace__ecere__com__Module *)(((char *)module + structSize_Instance)))->publicNameSpace);
4681 if(module != ((struct __ecereNameSpace__ecere__com__Module *)(((char *)module + structSize_Instance)))->application)
4682 __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);
4683 else
4684 __ecereNameSpace__ecere__com__NameSpace_Free(&((struct __ecereNameSpace__ecere__com__Application *)(((char *)((struct __ecereNameSpace__ecere__com__Module *)(((char *)module + structSize_Instance)))->application + structSize_Module)))->systemNameSpace);
4685 Instance_Module_Free(((struct __ecereNameSpace__ecere__com__Module *)(((char *)module + structSize_Instance)))->library);
4686 }
4687
4688 static long long __ecereNameSpace__ecere__com__GetEnumSize(struct __ecereNameSpace__ecere__com__Class * _class)
4689 {
4690 struct __ecereNameSpace__ecere__com__EnumClassData * data = (struct __ecereNameSpace__ecere__com__EnumClassData *)_class->data;
4691
4692 return data->largest + 1;
4693 }
4694
4695 char * strlwr(char * string)
4696 {
4697 int c;
4698
4699 for(c = 0; string[c]; c++)
4700 if(string[c] >= 'A' && string[c] <= 'Z')
4701 string[c] += 'a' - 'A';
4702 return string;
4703 }
4704
4705 char * strupr(char * string)
4706 {
4707 int c;
4708
4709 for(c = 0; string[c]; c++)
4710 if(string[c] >= 'a' && string[c] <= 'z')
4711 string[c] -= 'a' - 'A';
4712 return string;
4713 }
4714
4715 struct __ecereNameSpace__ecere__com__DefinedExpression * __ecereNameSpace__ecere__com__eSystem_RegisterDefine(char * name, char * value, struct __ecereNameSpace__ecere__com__Instance * module, int declMode)
4716 {
4717 struct __ecereNameSpace__ecere__com__NameSpace * nameSpace = (((void *)0));
4718 int start = 0, c;
4719
4720 nameSpace = (declMode == 1) ? &((struct __ecereNameSpace__ecere__com__Module *)(((char *)module + structSize_Instance)))->publicNameSpace : &((struct __ecereNameSpace__ecere__com__Module *)(((char *)module + structSize_Instance)))->privateNameSpace;
4721 if(declMode == 4)
4722 nameSpace = &((struct __ecereNameSpace__ecere__com__Application *)(((char *)((struct __ecereNameSpace__ecere__com__Module *)(((char *)module + structSize_Instance)))->application + structSize_Module)))->systemNameSpace;
4723 if(declMode != 3)
4724 {
4725 for(c = 0; name[c]; c++)
4726 {
4727 if(name[c] == '.' || (name[c] == ':' && name[c + 1] == ':'))
4728 {
4729 struct __ecereNameSpace__ecere__com__NameSpace * newSpace;
4730 char * spaceName = __ecereNameSpace__ecere__com___malloc(c - start + 1);
4731
4732 strncpy(spaceName, name + start, c - start);
4733 spaceName[c - start] = '\0';
4734 newSpace = (struct __ecereNameSpace__ecere__com__NameSpace *)__ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_FindString(&(*nameSpace).nameSpaces, spaceName);
4735 if(!newSpace)
4736 {
4737 newSpace = __ecereNameSpace__ecere__com__eSystem_New0(sizeof(struct __ecereNameSpace__ecere__com__NameSpace) * (1));
4738 (*newSpace).classes.CompareKey = (void *)__ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_CompareString;
4739 (*newSpace).defines.CompareKey = (void *)__ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_CompareString;
4740 (*newSpace).functions.CompareKey = (void *)__ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_CompareString;
4741 (*newSpace).nameSpaces.CompareKey = (void *)__ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_CompareString;
4742 (*newSpace).name = spaceName;
4743 (*newSpace).parent = nameSpace;
4744 __ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_Add(&(*nameSpace).nameSpaces, (struct __ecereNameSpace__ecere__sys__BTNode *)newSpace);
4745 }
4746 else
4747 (__ecereNameSpace__ecere__com__eSystem_Delete(spaceName), spaceName = 0);
4748 nameSpace = newSpace;
4749 if(name[c] == ':')
4750 c++;
4751 start = c + 1;
4752 }
4753 }
4754 }
4755 else
4756 c = strlen(name);
4757 if(c - start && !__ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_FindString(&(*nameSpace).defines, name + start))
4758 {
4759 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);
4760
4761 __ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_Add(&(*nameSpace).defines, (struct __ecereNameSpace__ecere__sys__BTNode *)__extension__ ({
4762 struct __ecereNameSpace__ecere__com__BTNamedLink * __ecereInstance1 = __ecereNameSpace__ecere__com__eSystem_New0(structSize_BTNamedLink);
4763
4764 __ecereInstance1->name = def->name + start, __ecereInstance1->data = def, __ecereInstance1;
4765 }));
4766 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Add(&((struct __ecereNameSpace__ecere__com__Module *)(((char *)module + structSize_Instance)))->defines, def);
4767 return def;
4768 }
4769 return (((void *)0));
4770 }
4771
4772 struct __ecereNameSpace__ecere__com__GlobalFunction * __ecereNameSpace__ecere__com__eSystem_RegisterFunction(char * name, char * type, void * func, struct __ecereNameSpace__ecere__com__Instance * module, int declMode)
4773 {
4774 struct __ecereNameSpace__ecere__com__NameSpace * nameSpace = (((void *)0));
4775 int start = 0, c;
4776
4777 nameSpace = (declMode == 1) ? &((struct __ecereNameSpace__ecere__com__Module *)(((char *)module + structSize_Instance)))->publicNameSpace : &((struct __ecereNameSpace__ecere__com__Module *)(((char *)module + structSize_Instance)))->privateNameSpace;
4778 if(declMode == 4)
4779 nameSpace = &((struct __ecereNameSpace__ecere__com__Application *)(((char *)((struct __ecereNameSpace__ecere__com__Module *)(((char *)module + structSize_Instance)))->application + structSize_Module)))->systemNameSpace;
4780 if(declMode != 3)
4781 {
4782 for(c = 0; name[c]; c++)
4783 {
4784 if(name[c] == '.' || (name[c] == ':' && name[c + 1] == ':'))
4785 {
4786 struct __ecereNameSpace__ecere__com__NameSpace * newSpace;
4787 char * spaceName = __ecereNameSpace__ecere__com___malloc(c - start + 1);
4788
4789 strncpy(spaceName, name + start, c - start);
4790 spaceName[c - start] = '\0';
4791 newSpace = (struct __ecereNameSpace__ecere__com__NameSpace *)__ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_FindString(&(*nameSpace).nameSpaces, spaceName);
4792 if(!newSpace)
4793 {
4794 newSpace = __ecereNameSpace__ecere__com__eSystem_New0(sizeof(struct __ecereNameSpace__ecere__com__NameSpace) * (1));
4795 (*newSpace).classes.CompareKey = (void *)__ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_CompareString;
4796 (*newSpace).defines.CompareKey = (void *)__ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_CompareString;
4797 (*newSpace).functions.CompareKey = (void *)__ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_CompareString;
4798 (*newSpace).nameSpaces.CompareKey = (void *)__ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_CompareString;
4799 (*newSpace).name = spaceName;
4800 (*newSpace).parent = nameSpace;
4801 __ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_Add(&(*nameSpace).nameSpaces, (struct __ecereNameSpace__ecere__sys__BTNode *)newSpace);
4802 }
4803 else
4804 (__ecereNameSpace__ecere__com__eSystem_Delete(spaceName), spaceName = 0);
4805 nameSpace = newSpace;
4806 if(name[c] == ':')
4807 c++;
4808 start = c + 1;
4809 }
4810 }
4811 }
4812 else
4813 c = strlen(name);
4814 if(c - start && !__ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_FindString(&(*nameSpace).functions, name + start))
4815 {
4816 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);
4817
4818 __ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_Add(&(*nameSpace).functions, (struct __ecereNameSpace__ecere__sys__BTNode *)__extension__ ({
4819 struct __ecereNameSpace__ecere__com__BTNamedLink * __ecereInstance1 = __ecereNameSpace__ecere__com__eSystem_New0(structSize_BTNamedLink);
4820
4821 __ecereInstance1->name = function->name + start, __ecereInstance1->data = function, __ecereInstance1;
4822 }));
4823 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Add(&((struct __ecereNameSpace__ecere__com__Module *)(((char *)module + structSize_Instance)))->functions, function);
4824 return function;
4825 }
4826 return (((void *)0));
4827 }
4828
4829 struct __ecereNameSpace__ecere__com__DefinedExpression * __ecereNameSpace__ecere__com__eSystem_FindDefine(struct __ecereNameSpace__ecere__com__Instance * module, char * name)
4830 {
4831 if(name && module)
4832 {
4833 struct __ecereNameSpace__ecere__com__BTNamedLink * link;
4834
4835 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);
4836 if(link)
4837 return link->data;
4838 link = __ecereNameSpace__ecere__com__SearchModule(module, name, &(*((struct __ecereNameSpace__ecere__com__NameSpace *)0)).defines, 0x1);
4839 if(link)
4840 return link->data;
4841 }
4842 return (((void *)0));
4843 }
4844
4845 struct __ecereNameSpace__ecere__com__GlobalFunction * __ecereNameSpace__ecere__com__eSystem_FindFunction(struct __ecereNameSpace__ecere__com__Instance * module, char * name)
4846 {
4847 if(name && module)
4848 {
4849 struct __ecereNameSpace__ecere__com__BTNamedLink * link;
4850
4851 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);
4852 if(link)
4853 return link->data;
4854 link = __ecereNameSpace__ecere__com__SearchModule(module, name, &(*((struct __ecereNameSpace__ecere__com__NameSpace *)0)).functions, 0x1);
4855 if(link)
4856 return link->data;
4857 }
4858 return (((void *)0));
4859 }
4860
4861 void * __ecereNameSpace__ecere__com__eSystem_Renew(void * memory, unsigned int size)
4862 {
4863 return __ecereNameSpace__ecere__com___realloc(memory, size);
4864 }
4865
4866 void * __ecereNameSpace__ecere__com__eSystem_Renew0(void * memory, unsigned int size)
4867 {
4868 return __ecereNameSpace__ecere__com___crealloc(memory, size);
4869 }
4870
4871 void * __ecereNameSpace__ecere__com__eSystem_New(unsigned int size)
4872 {
4873 return __ecereNameSpace__ecere__com___malloc(size);
4874 }
4875
4876 void * __ecereNameSpace__ecere__com__eSystem_New0(unsigned int size)
4877 {
4878 return __ecereNameSpace__ecere__com___calloc(1, size);
4879 }
4880
4881 void __ecereNameSpace__ecere__com__eSystem_Delete(void * memory)
4882 {
4883 if(memory)
4884 __ecereNameSpace__ecere__com___free(memory);
4885 }
4886
4887 void __ecereNameSpace__ecere__com__eInstance_FireSelfWatchers(struct __ecereNameSpace__ecere__com__Instance * instance, struct __ecereNameSpace__ecere__com__Property * _property)
4888 {
4889 if(instance && _property && _property->selfWatchable)
4890 {
4891 struct __ecereNameSpace__ecere__com__Class * _class;
4892
4893 for(_class = ((struct __ecereNameSpace__ecere__com__Instance *)(char *)instance)->_class; _class; _class = _class->base)
4894 {
4895 struct __ecereNameSpace__ecere__com__SelfWatcher * selfWatcher, * next;
4896
4897 for(selfWatcher = _class->selfWatchers.first; selfWatcher; selfWatcher = next)
4898 {
4899 next = selfWatcher->next;
4900 if(selfWatcher->_property == _property)
4901 selfWatcher->callback(instance);
4902 }
4903 }
4904 }
4905 }
4906
4907 void __ecereNameSpace__ecere__com__eInstance_FireWatchers(struct __ecereNameSpace__ecere__com__Instance * instance, struct __ecereNameSpace__ecere__com__Property * _property)
4908 {
4909 if(instance && _property && _property->isWatchable)
4910 {
4911 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));
4912 struct __ecereNameSpace__ecere__com__Instance * application = module ? ((struct __ecereNameSpace__ecere__com__Module *)(((char *)module + structSize_Instance)))->application : (((void *)0));
4913 int flags = application ? (unsigned int)((struct __ecereNameSpace__ecere__com__Application *)(((char *)application + structSize_Module)))->isGUIApp : 0;
4914 unsigned int inCompiler = (flags & 8) ? 0x1 : 0x0;
4915 unsigned int force32Bits = (flags & 4) ? 0x1 : 0x0;
4916
4917 if(!force32Bits || !inCompiler)
4918 {
4919 struct __ecereNameSpace__ecere__sys__OldList * watchers = (struct __ecereNameSpace__ecere__sys__OldList *)((unsigned char *)instance + _property->watcherOffset);
4920 struct __ecereNameSpace__ecere__com__Watcher * watcher, * next;
4921
4922 for(watcher = (*watchers).first; watcher; watcher = next)
4923 {
4924 next = watcher->next;
4925 watcher->callback(watcher->object, instance);
4926 }
4927 }
4928 }
4929 }
4930
4931 void __ecereNameSpace__ecere__com__eProperty_Watchable(struct __ecereNameSpace__ecere__com__Property * _property)
4932 {
4933 if(!_property->isWatchable)
4934 {
4935 struct __ecereNameSpace__ecere__com__Class * _class = _property->_class;
4936
4937 if(!_class->computeSize)
4938 {
4939 _property->watcherOffset = _class->structSize;
4940 _class->structSize += sizeof(struct __ecereNameSpace__ecere__sys__OldList);
4941 __ecereNameSpace__ecere__com__FixDerivativesBase(_class, _class);
4942 }
4943 _property->isWatchable = 0x1;
4944 }
4945 }
4946
4947 void __ecereNameSpace__ecere__com__eClass_DestructionWatchable(struct __ecereNameSpace__ecere__com__Class * _class)
4948 {
4949 if(!_class->destructionWatchOffset)
4950 {
4951 _class->destructionWatchOffset = _class->structSize;
4952 _class->structSize += sizeof(struct __ecereNameSpace__ecere__sys__OldList);
4953 __ecereNameSpace__ecere__com__FixDerivativesBase(_class, _class);
4954 }
4955 }
4956
4957 void __ecereNameSpace__ecere__com__eProperty_SelfWatch(struct __ecereNameSpace__ecere__com__Class * _class, char * name, void (* callback)(void *))
4958 {
4959 if(_class)
4960 {
4961 struct __ecereNameSpace__ecere__com__Property * _property = __ecereNameSpace__ecere__com__eClass_FindProperty(_class, name, _class->module);
4962
4963 if(!_property)
4964 _property = __ecereNameSpace__ecere__com__eClass_AddProperty(_class, name, (((void *)0)), (((void *)0)), (((void *)0)), 4);
4965 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Add(&_class->selfWatchers, __extension__ ({
4966 struct __ecereNameSpace__ecere__com__SelfWatcher * __ecereInstance1 = __ecereNameSpace__ecere__com__eSystem_New0(structSize_SelfWatcher);
4967
4968 __ecereInstance1->_property = _property, __ecereInstance1->callback = callback, __ecereInstance1;
4969 }));
4970 _property->selfWatchable = 0x1;
4971 }
4972 }
4973
4974 void __ecereNameSpace__ecere__com__eInstance_Watch(void * instance, struct __ecereNameSpace__ecere__com__Property * _property, void * object, void (* callback)(void *, void *))
4975 {
4976 if(_property->isWatchable)
4977 {
4978 struct __ecereNameSpace__ecere__sys__OldList * watchers = (struct __ecereNameSpace__ecere__sys__OldList *)((unsigned char *)instance + _property->watcherOffset);
4979
4980 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Add((&*watchers), __extension__ ({
4981 struct __ecereNameSpace__ecere__com__Watcher * __ecereInstance1 = __ecereNameSpace__ecere__com__eSystem_New0(structSize_Watcher);
4982
4983 __ecereInstance1->callback = callback, __ecereInstance1->object = object, __ecereInstance1;
4984 }));
4985 }
4986 }
4987
4988 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 *))
4989 {
4990 struct __ecereNameSpace__ecere__sys__OldList * watchers = (struct __ecereNameSpace__ecere__sys__OldList *)((unsigned char *)instance + ((struct __ecereNameSpace__ecere__com__Instance *)(char *)instance)->_class->destructionWatchOffset);
4991
4992 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Add((&*watchers), __extension__ ({
4993 struct __ecereNameSpace__ecere__com__Watcher * __ecereInstance1 = __ecereNameSpace__ecere__com__eSystem_New0(structSize_Watcher);
4994
4995 __ecereInstance1->callback = callback, __ecereInstance1->object = object, __ecereInstance1;
4996 }));
4997 }
4998
4999 void __ecereNameSpace__ecere__com__eInstance_StopWatching(struct __ecereNameSpace__ecere__com__Instance * instance, struct __ecereNameSpace__ecere__com__Property * _property, struct __ecereNameSpace__ecere__com__Instance * object)
5000 {
5001 if(instance && (!_property || _property->isWatchable))
5002 {
5003 if(_property)
5004 {
5005 struct __ecereNameSpace__ecere__sys__OldList * watchers = (struct __ecereNameSpace__ecere__sys__OldList *)((unsigned char *)instance + _property->watcherOffset);
5006 struct __ecereNameSpace__ecere__com__Watcher * watcher;
5007
5008 for(watcher = (*watchers).first; watcher; watcher = watcher->next)
5009 if(watcher->object == object)
5010 {
5011 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Delete((&*watchers), watcher);
5012 break;
5013 }
5014 }
5015 else
5016 {
5017 struct __ecereNameSpace__ecere__com__Class * _class, * base;
5018
5019 for(_class = ((struct __ecereNameSpace__ecere__com__Instance *)(char *)instance)->_class; _class; _class = base)
5020 {
5021 if(_class->destructionWatchOffset)
5022 {
5023 struct __ecereNameSpace__ecere__sys__OldList * watchers = (struct __ecereNameSpace__ecere__sys__OldList *)((unsigned char *)instance + _class->destructionWatchOffset);
5024 struct __ecereNameSpace__ecere__com__Watcher * watcher;
5025
5026 for(watcher = (*watchers).first; watcher; watcher = watcher->next)
5027 {
5028 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Delete((&*watchers), watcher);
5029 break;
5030 }
5031 }
5032 for(_property = (struct __ecereNameSpace__ecere__com__Property *)_class->membersAndProperties.first; _property; _property = _property->next)
5033 {
5034 if(_property->isProperty && _property->isWatchable)
5035 {
5036 struct __ecereNameSpace__ecere__sys__OldList * watchers = (struct __ecereNameSpace__ecere__sys__OldList *)((unsigned char *)instance + _property->watcherOffset);
5037 struct __ecereNameSpace__ecere__com__Watcher * watcher;
5038
5039 for(watcher = (*watchers).first; watcher; watcher = watcher->next)
5040 if(watcher->object == object)
5041 {
5042 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Delete((&*watchers), watcher);
5043 break;
5044 }
5045 }
5046 }
5047 base = _class->base;
5048 if(base && base->type == 1000)
5049 base = (((void *)0));
5050 }
5051 }
5052 }
5053 }
5054
5055 struct __ecereNameSpace__ecere__com__Class * __ecereNameSpace__ecere__com__eClass_GetDesigner(struct __ecereNameSpace__ecere__com__Class * _class)
5056 {
5057 for(; _class; _class = _class->base)
5058 {
5059 if(_class->designerClass)
5060 return (struct __ecereNameSpace__ecere__com__Class *)__ecereNameSpace__ecere__com__eSystem_FindClass(_class->module, _class->designerClass);
5061 }
5062 return (((void *)0));
5063 }
5064
5065 struct __ecereNameSpace__ecere__com__Class * __ecereNameSpace__ecere__com__eInstance_GetDesigner(struct __ecereNameSpace__ecere__com__Instance * instance)
5066 {
5067 if(instance)
5068 return __ecereNameSpace__ecere__com__eClass_GetDesigner(((struct __ecereNameSpace__ecere__com__Instance *)(char *)instance)->_class);
5069 return (((void *)0));
5070 }
5071
5072 unsigned int __ecereNameSpace__ecere__com__LocateModule(char * name, char * fileName)
5073 {
5074 return Instance_LocateModule(name, fileName);
5075 }
5076
5077 extern void __ecereNameSpace__ecere__com__InitializeDataTypes1(struct __ecereNameSpace__ecere__com__Instance * module);
5078
5079 extern void __ecereNameSpace__ecere__com__InitializeDataTypes(struct __ecereNameSpace__ecere__com__Instance * module);
5080
5081 extern double sin(struct __ecereNameSpace__ecere__com__Instance * number);
5082
5083 extern double sinh(struct __ecereNameSpace__ecere__com__Instance * number);
5084
5085 extern double cosh(struct __ecereNameSpace__ecere__com__Instance * number);
5086
5087 extern double tanh(struct __ecereNameSpace__ecere__com__Instance * number);
5088
5089 extern double sqrt(double number);
5090
5091 extern double cos(struct __ecereNameSpace__ecere__com__Instance * number);
5092
5093 extern double tan(struct __ecereNameSpace__ecere__com__Instance * number);
5094
5095 extern struct __ecereNameSpace__ecere__com__Instance * atan2(double y, double x);
5096
5097 extern struct __ecereNameSpace__ecere__com__Instance * asin(double number);
5098
5099 extern struct __ecereNameSpace__ecere__com__Instance * acos(double number);
5100
5101 extern struct __ecereNameSpace__ecere__com__Instance * atan(double number);
5102
5103 extern double pow(double number, double number2);
5104
5105 extern double fmod(double x, double y);
5106
5107 extern double fabs(double number);
5108
5109 extern double log(double number);
5110
5111 extern double log10(double number);
5112
5113 extern double ceil(double number);
5114
5115 extern double floor(double number);
5116
5117 extern double exp(double number);
5118
5119 extern void qsort(void * , size_t, size_t, int (* )(void * , void * ));
5120
5121 extern int system(const char * );
5122
5123 extern int atoi(const char * );
5124
5125 extern float atof(const char * );
5126
5127 extern int tolower(int);
5128
5129 extern int toupper(int);
5130
5131 extern unsigned int isdigit(int);
5132
5133 extern char *  getenv(const char *  name);
5134
5135 extern int rename(const char *  oldpath, const char *  newpath);
5136
5137 extern char *  strncat(char * , const char * , size_t n);
5138
5139 extern int strcasecmp(const char * , const char * );
5140
5141 extern int strncasecmp(const char * , const char * , size_t n);
5142
5143 extern int strncmp(const char * , const char * , size_t n);
5144
5145 extern int vsprintf(char * , const char * , __builtin_va_list);
5146
5147 extern int puts(char * );
5148
5149 extern int fputs(char * , void *  stream);
5150
5151 extern int isalnum(int c);
5152
5153 extern int isalpha(int c);
5154
5155 extern int islower(int c);
5156
5157 extern int isupper(int c);
5158
5159 extern int isprint(int c);
5160
5161 static void __ecereNameSpace__ecere__com__LoadCOM(struct __ecereNameSpace__ecere__com__Instance * module)
5162 {
5163 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;
5164 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;
5165 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;
5166 int pointerSize = force64Bits ? 8 : force32Bits ? 4 : sizeof(void *);
5167 struct __ecereNameSpace__ecere__com__Class * applicationClass;
5168 struct __ecereNameSpace__ecere__com__Class * enumClass, * structClass, * boolClass;
5169 struct __ecereNameSpace__ecere__com__Class * moduleClass;
5170 struct __ecereNameSpace__ecere__com__Class * baseClass = __ecereNameSpace__ecere__com__eSystem_RegisterClass(0, "class", (((void *)0)), 0, 0, (((void *)0)), (((void *)0)), module, 4, 1);
5171
5172 baseClass->type = 1000;
5173 baseClass->memberOffset = 0;
5174 baseClass->offset = 0;
5175 baseClass->structSize = 0;
5176 baseClass->typeSize = 0;
5177 {
5178 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);
5179
5180 instanceClass->type = 1000;
5181 instanceClass->fixed = 0x1;
5182 instanceClass->memberOffset = 0;
5183 instanceClass->offset = 0;
5184 instanceClass->memberID = -3;
5185 instanceClass->startMemberID = -3;
5186 __ecereNameSpace__ecere__com__eClass_AddDataMember(instanceClass, "_vTbl", "int (**)()", pointerSize, pointerSize, 1);
5187 __ecereNameSpace__ecere__com__eClass_AddDataMember(instanceClass, "_class", "ecere::com::Class", pointerSize, pointerSize, 1);
5188 __ecereNameSpace__ecere__com__eClass_AddDataMember(instanceClass, "_refCount", "int", sizeof(int), sizeof(int), 1);
5189 }
5190 __ecereNameSpace__ecere__com__InitializeDataTypes1(module);
5191 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);
5192 __ecereNameSpace__ecere__com__eClass_AddClassProperty(enumClass, "enumSize", "int", (((void *)0)), __ecereNameSpace__ecere__com__GetEnumSize)->constant = 0x1;
5193 enumClass->type = 1000;
5194 (__ecereNameSpace__ecere__com__eSystem_Delete(enumClass->dataTypeString), enumClass->dataTypeString = 0);
5195 enumClass->dataTypeString = __ecereNameSpace__ecere__sys__CopyString("int");
5196 structClass = __ecereNameSpace__ecere__com__eSystem_RegisterClass(0, "struct", (((void *)0)), 0, 0, (((void *)0)), (((void *)0)), module, 4, 1);
5197 structClass->type = 1000;
5198 structClass->memberOffset = 0;
5199 structClass->offset = 0;
5200 structClass->structSize = 0;
5201 structClass->typeSize = 0;
5202 __ecereNameSpace__ecere__com__InitializeDataTypes(module);
5203 boolClass = __ecereNameSpace__ecere__com__eSystem_RegisterClass(4, "bool", "uint", 0, 0, (((void *)0)), (((void *)0)), module, 4, 1);
5204 __ecereNameSpace__ecere__com__eEnum_AddFixedValue(boolClass, "true", (unsigned int)0x1);
5205 __ecereNameSpace__ecere__com__eEnum_AddFixedValue(boolClass, "false", (unsigned int)0x0);
5206 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);
5207 __ecereNameSpace__ecere__com__eClass_AddVirtualMethod(moduleClass, "OnLoad", "bool()", (((void *)0)), 1);
5208 __ecereNameSpace__ecere__com__eClass_AddVirtualMethod(moduleClass, "OnUnload", "void()", (((void *)0)), 1);
5209 __ecereNameSpace__ecere__com__eClass_AddMethod(moduleClass, "Load", "Module(char * name, AccessMode importAccess)", __ecereNameSpace__ecere__com__eModule_Load, 1);
5210 __ecereNameSpace__ecere__com__eClass_AddMethod(moduleClass, "Unload", "void(Module module)", __ecereNameSpace__ecere__com__eModule_Unload, 1);
5211 __ecereNameSpace__ecere__com__eClass_AddDataMember(moduleClass, "application", "Application", pointerSize, pointerSize, 1);
5212 __ecereNameSpace__ecere__com__eClass_AddDataMember(moduleClass, "classes", "OldList", force64Bits ? 32 : force32Bits ? 20 : sizeof(struct __ecereNameSpace__ecere__sys__OldList), pointerSize, 1);
5213 __ecereNameSpace__ecere__com__eClass_AddDataMember(moduleClass, "defines", "OldList", force64Bits ? 32 : force32Bits ? 20 : sizeof(struct __ecereNameSpace__ecere__sys__OldList), pointerSize, 1);
5214 __ecereNameSpace__ecere__com__eClass_AddDataMember(moduleClass, "functions", "OldList", force64Bits ? 32 : force32Bits ? 20 : sizeof(struct __ecereNameSpace__ecere__sys__OldList), pointerSize, 1);
5215 __ecereNameSpace__ecere__com__eClass_AddDataMember(moduleClass, "modules", "OldList", force64Bits ? 32 : force32Bits ? 20 : sizeof(struct __ecereNameSpace__ecere__sys__OldList), pointerSize, 1);
5216 __ecereNameSpace__ecere__com__eClass_AddDataMember(moduleClass, "prev", "Module", pointerSize, pointerSize, 1);
5217 __ecereNameSpace__ecere__com__eClass_AddDataMember(moduleClass, "next", "Module", pointerSize, pointerSize, 1);
5218 __ecereNameSpace__ecere__com__eClass_AddDataMember(moduleClass, "name", "char *", pointerSize, pointerSize, 1);
5219 __ecereNameSpace__ecere__com__eClass_AddDataMember(moduleClass, "library", "void *", pointerSize, pointerSize, 1);
5220 __ecereNameSpace__ecere__com__eClass_AddDataMember(moduleClass, "Unload", "void *", pointerSize, pointerSize, 1);
5221 __ecereNameSpace__ecere__com__eClass_AddDataMember(moduleClass, "importType", "ImportType", sizeof(int), 4, 1);
5222 __ecereNameSpace__ecere__com__eClass_AddDataMember(moduleClass, "origImportType", "ImportType", sizeof(int), 4, 1);
5223 __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);
5224 __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);
5225 moduleClass->fixed = 0x1;
5226 moduleClass->count++;
5227 if(inCompiler && force32Bits)
5228 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);
5229 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);
5230 if(inCompiler && force32Bits)
5231 {
5232 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);
5233 applicationClass->structSize = applicationClass->offset + (4 + 4 + 4 + 4 + 20 + 4 + 88);
5234 }
5235 __ecereNameSpace__ecere__com__eClass_AddVirtualMethod(applicationClass, "Main", "void()", (((void *)0)), 1);
5236 __ecereNameSpace__ecere__com__eClass_AddDataMember(applicationClass, "argc", "int", sizeof(int), 4, 1);
5237 __ecereNameSpace__ecere__com__eClass_AddDataMember(applicationClass, "argv", "char **", pointerSize, pointerSize, 1);
5238 __ecereNameSpace__ecere__com__eClass_AddDataMember(applicationClass, "exitCode", "int", sizeof(int), 4, 1);
5239 __ecereNameSpace__ecere__com__eClass_AddDataMember(applicationClass, "isGUIApp", "bool", sizeof(unsigned int), 4, 1);
5240 __ecereNameSpace__ecere__com__eClass_AddDataMember(applicationClass, "allModules", "OldList", force64Bits ? 32 : force32Bits ? 20 : sizeof(struct __ecereNameSpace__ecere__sys__OldList), pointerSize, 1);
5241 __ecereNameSpace__ecere__com__eClass_AddDataMember(applicationClass, "parsedCommand", "char *", pointerSize, pointerSize, 1);
5242 __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);
5243 applicationClass->fixed = 0x1;
5244 applicationClass->count++;
5245 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("sin", "double sin(Angle number)", sin, module, 4);
5246 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("sinh", "double sinh(Angle number)", sinh, module, 4);
5247 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("cosh", "double cosh(Angle number)", cosh, module, 4);
5248 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("tanh", "double tanh(Angle number)", tanh, module, 4);
5249 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("sqrt", "double sqrt(double number)", sqrt, module, 4);
5250 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("cos", "double cos(Angle number)", cos, module, 4);
5251 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("tan", "double tan(Angle number)", tan, module, 4);
5252 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("atan2", "Angle atan2(double y, double x)", atan2, module, 4);
5253 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("asin", "Angle asin(double number)", asin, module, 4);
5254 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("acos", "Angle acos(double number)", acos, module, 4);
5255 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("atan", "Angle atan(double number)", atan, module, 4);
5256 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("pow", "double pow(double number, double number2)", pow, module, 4);
5257 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("fmod", "double fmod(double x, double y)", fmod, module, 4);
5258 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("fabs", "double fabs(double number)", fabs, module, 4);
5259 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("log", "double log(double number)", log, module, 4);
5260 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("log10", "double log10(double number)", log10, module, 4);
5261 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("ceil", "double ceil(double number)", ceil, module, 4);
5262 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("floor", "double floor(double number)", floor, module, 4);
5263 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("exp", "double exp(double number)", exp, module, 4);
5264 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("qsort", "void qsort(void *, uintsize, uintsize, int (*)(void *, void *))", qsort, module, 4);
5265 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("strtod", "double strtod(char*, char**)", strtod, module, 4);
5266 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("strtol", "int strtol(char*, char**, int base)", strtol, module, 4);
5267 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("system", "int system(const char*)", system, module, 4);
5268 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("atoi", "int atoi(const char*)", atoi, module, 4);
5269 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("atof", "float atof(const char*)", atof, module, 4);
5270 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("tolower", "int tolower(int)", tolower, module, 4);
5271 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("toupper", "int toupper(int)", toupper, module, 4);
5272 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("isdigit", "bool isdigit(int)", isdigit, module, 4);
5273 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("memset", "void * memset(void * area, int value, uintsize count)", memset, module, 4);
5274 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("getenv", "char * getenv(const char * name)", getenv, module, 4);
5275 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("rename", "int rename(const char *oldpath, const char *newpath)", rename, module, 4);
5276 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("strlen", "uintsize strlen(const char *)", strlen, module, 4);
5277 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("strcat", "char * strcat(char *, const char *)", strcat, module, 4);
5278 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("strncat", "char * strncat(char *, const char *, uintsize n)", strncat, module, 4);
5279 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("strchr", "char * strchr(const char *, int)", strchr, module, 4);
5280 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("strstr", "char * strstr(const char *, const char *)", strstr, module, 4);
5281 __ecereNameSpace__ecere__com__eSystem_RegisterDefine("fstrcmp", "(GetRuntimePlatform() == win32) ? strcmpi : strcmp", module, 4);
5282 __ecereNameSpace__ecere__com__eSystem_RegisterDefine("strcmpi", "strcasecmp", module, 4);
5283 __ecereNameSpace__ecere__com__eSystem_RegisterDefine("strnicmp", "strncasecmp", module, 4);
5284 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("strcasecmp", "int strcasecmp(const char *, const char *)", strcasecmp, module, 4);
5285 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("strncasecmp", "int strncasecmp(const char *, const char *, uintsize n)", strncasecmp, module, 4);
5286 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("strcmp", "int strcmp(const char *, const char *)", strcmp, module, 4);
5287 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("strncmp", "int strncmp(const char *, const char *, uintsize n)", strncmp, module, 4);
5288 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("strlwr", "char * strlwr(char *)", strlwr, module, 4);
5289 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("strupr", "char * strupr(char *)", strupr, module, 4);
5290 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("strcpy", "char * strcpy(char *, const char *)", strcpy, module, 4);
5291 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("strncpy", "char * strncpy(char *, const char *, uintsize n)", strncpy, module, 4);
5292 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("memcpy", "void * memcpy(void *, const void *, uintsize size)", memcpy, module, 4);
5293 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("memmove", "void * memmove(void *, const void *, uintsize size)", memmove, module, 4);
5294 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("sprintf", "int sprintf(char *, char *, ...)", sprintf, module, 4);
5295 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("snprintf", "int sprintf(char *, uintsize, char *, ...)", snprintf, module, 4);
5296 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("printf", "int printf(char *, ...)", printf, module, 4);
5297 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("vsprintf", "int vsprintf(char*, const char*, __builtin_va_list)", vsprintf, module, 4);
5298 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("vsnprintf", "int vsnprintf(char*, uintsize, const char*, __builtin_va_list)", vsnprintf, module, 4);
5299 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("puts", "int puts(char *)", puts, module, 4);
5300 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("fputs", "int fputs(char *, void * stream)", fputs, module, 4);
5301 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("isalnum", "int isalnum(int c)", isalnum, module, 4);
5302 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("isspace", "int isspace(int c)", isspace, module, 4);
5303 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("isalpha", "int isalpha(int c)", isalpha, module, 4);
5304 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("islower", "int islower(int c)", islower, module, 4);
5305 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("isupper", "int isupper(int c)", isupper, module, 4);
5306 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("isprint", "int isprint(int c)", isprint, module, 4);
5307 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("strtoul", "unsigned long strtoul(const char * nptr, char ** endptr, int base)", strtoul, module, 4);
5308 }
5309
5310 struct __ecereNameSpace__ecere__com__Instance * __ecereNameSpace__ecere__com____ecere_COM_Initialize(unsigned int guiApp, int argc, char * argv[])
5311 {
5312 struct __ecereNameSpace__ecere__com__Instance * app;
5313
5314 app = __ecereNameSpace__ecere__com___calloc(1, structSize_Application);
5315 __ecereNameSpace__ecere__com__Module_Constructor(app);
5316 ((struct __ecereNameSpace__ecere__com__Application *)(((char *)app + structSize_Module)))->systemNameSpace.classes.CompareKey = (void *)__ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_CompareString;
5317 ((struct __ecereNameSpace__ecere__com__Application *)(((char *)app + structSize_Module)))->systemNameSpace.defines.CompareKey = (void *)__ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_CompareString;
5318 ((struct __ecereNameSpace__ecere__com__Application *)(((char *)app + structSize_Module)))->systemNameSpace.functions.CompareKey = (void *)__ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_CompareString;
5319 ((struct __ecereNameSpace__ecere__com__Application *)(((char *)app + structSize_Module)))->systemNameSpace.nameSpaces.CompareKey = (void *)__ecereMethod___ecereNameSpace__ecere__sys__BinaryTree_CompareString;
5320 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);
5321 ((struct __ecereNameSpace__ecere__com__Module *)(((char *)app + structSize_Instance)))->application = app;
5322 ((struct __ecereNameSpace__ecere__com__Application *)(((char *)app + structSize_Module)))->allModules.offset = structSize_Instance + (unsigned int)&(*((struct __ecereNameSpace__ecere__com__Module *)0)).prev;
5323 ((struct __ecereNameSpace__ecere__com__Application *)(((char *)app + structSize_Module)))->isGUIApp = guiApp;
5324 __ecereNameSpace__ecere__com__LoadCOM(app);
5325 ((struct __ecereNameSpace__ecere__com__Instance *)(char *)app)->_class = __ecereNameSpace__ecere__com__eSystem_FindClass(app, "Application");
5326 return app;
5327 }
5328
5329 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)
5330 {
5331 if(_class && name)
5332 {
5333 struct __ecereNameSpace__ecere__com__ClassTemplateParameter * param;
5334
5335 for(param = _class->templateParams.first; param; param = param->next)
5336 {
5337 if(!strcmp(param->name, name))
5338 return param;
5339 }
5340 param = __extension__ ({
5341 struct __ecereNameSpace__ecere__com__ClassTemplateParameter * __ecereInstance1 = __ecereNameSpace__ecere__com__eSystem_New0(structSize_ClassTemplateParameter);
5342
5343 __ecereInstance1->name = __ecereNameSpace__ecere__sys__CopyString(name), __ecereInstance1->type = type, __ecereInstance1->dataTypeString = (type == 1) ? info : __ecereNameSpace__ecere__sys__CopyString(info), __ecereInstance1;
5344 });
5345 if(defaultArg != (((void *)0)))
5346 {
5347 param->defaultArg = *defaultArg;
5348 __ecereNameSpace__ecere__com__CopyTemplateArg(param, &param->defaultArg);
5349 }
5350 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Add(&_class->templateParams, param);
5351 return param;
5352 }
5353 return (((void *)0));
5354 }
5355
5356 void __ecereNameSpace__ecere__com__eClass_DoneAddingTemplateParameters(struct __ecereNameSpace__ecere__com__Class * base)
5357 {
5358 if(base)
5359 {
5360 struct __ecereNameSpace__ecere__sys__OldLink * derivative;
5361 struct __ecereNameSpace__ecere__com__ClassTemplateParameter * param;
5362
5363 {
5364 void * first = base->templateParams.first;
5365 int count = base->templateParams.count;
5366
5367 base->templateParams.first = (((void *)0));
5368 base->templateParams.count = 0;
5369 __ecereNameSpace__ecere__com__FreeTemplateArgs(base);
5370 (__ecereNameSpace__ecere__com__eSystem_Delete(base->templateArgs), base->templateArgs = 0);
5371 __ecereNameSpace__ecere__com__FreeTemplatesDerivatives(base);
5372 base->templateParams.first = first;
5373 base->templateParams.count = count;
5374 }
5375 for(param = base->templateParams.first; param; param = param->next)
5376 {
5377 if(param->type == 1 && param->defaultArg.memberString)
5378 {
5379 struct __ecereNameSpace__ecere__com__Class * memberClass = base;
5380 char * colon = strstr(param->defaultArg.memberString, "::");
5381 char * memberName;
5382
5383 if(colon)
5384 {
5385 char className[1024];
5386 struct __ecereNameSpace__ecere__com__Class * sClass;
5387
5388 memcpy(className, param->defaultArg.memberString, colon - param->defaultArg.memberString);
5389 className[colon - param->defaultArg.memberString] = '\0';
5390 memberName = colon + 2;
5391 for(sClass = base; sClass; sClass = sClass->base)
5392 {
5393 struct __ecereNameSpace__ecere__com__ClassTemplateParameter * cParam;
5394 struct __ecereNameSpace__ecere__com__Class * nextClass;
5395 int id = 0;
5396
5397 for(nextClass = sClass->base; nextClass; nextClass = nextClass->base)
5398 id += nextClass->templateParams.count;
5399 if(sClass == base || base->templateArgs)
5400 {
5401 for(cParam = sClass->templateParams.first; cParam; cParam = cParam->next)
5402 {
5403 if(cParam->type == 0 && !strcmp(cParam->name, className))
5404 strcpy(className, (sClass == base) ? cParam->defaultArg.dataTypeString : base->templateArgs[id].dataTypeString);
5405 id++;
5406 }
5407 }
5408 }
5409 memberClass = __ecereNameSpace__ecere__com__eSystem_FindClass(base->module, className);
5410 if(!memberClass)
5411 memberClass = __ecereNameSpace__ecere__com__eSystem_FindClass(((struct __ecereNameSpace__ecere__com__Module *)(((char *)base->module + structSize_Instance)))->application, className);
5412 }
5413 else
5414 memberName = param->defaultArg.memberString;
5415 if(memberClass)
5416 {
5417 switch(param->memberType)
5418 {
5419 case 0:
5420 param->defaultArg.member = __ecereNameSpace__ecere__com__eClass_FindDataMember(memberClass, memberName, memberClass->module, (((void *)0)), (((void *)0)));
5421 break;
5422 case 1:
5423 param->defaultArg.method = __ecereNameSpace__ecere__com__eClass_FindMethod(memberClass, memberName, memberClass->module);
5424 break;
5425 case 2:
5426 param->defaultArg.prop = __ecereNameSpace__ecere__com__eClass_FindProperty(memberClass, memberName, memberClass->module);
5427 break;
5428 }
5429 }
5430 }
5431 }
5432 __ecereNameSpace__ecere__com__FixDerivativesBase(base, base);
5433 }
5434 }
5435
5436 static void __ecereNameSpace__ecere__com__FreeTemplatesDerivatives(struct __ecereNameSpace__ecere__com__Class * base)
5437 {
5438 struct __ecereNameSpace__ecere__sys__OldLink * derivative, * templateLink;
5439
5440 for(derivative = base->derivatives.first; derivative; derivative = derivative->next)
5441 {
5442 struct __ecereNameSpace__ecere__com__Class * _class = derivative->data;
5443
5444 if(_class->templateArgs)
5445 {
5446 __ecereNameSpace__ecere__com__FreeTemplateArgs(_class);
5447 (__ecereNameSpace__ecere__com__eSystem_Delete(_class->templateArgs), _class->templateArgs = 0);
5448 }
5449 __ecereNameSpace__ecere__com__FreeTemplatesDerivatives(_class);
5450 }
5451 for(templateLink = base->templatized.first; templateLink; templateLink = templateLink->next)
5452 {
5453 struct __ecereNameSpace__ecere__com__Class * _class = templateLink->data;
5454
5455 if(_class->templateArgs)
5456 {
5457 __ecereNameSpace__ecere__com__FreeTemplateArgs(_class);
5458 (__ecereNameSpace__ecere__com__eSystem_Delete(_class->templateArgs), _class->templateArgs = 0);
5459 }
5460 __ecereNameSpace__ecere__com__FreeTemplatesDerivatives(_class);
5461 }
5462 }
5463
5464 static const char * __ecereNameSpace__ecere__com__platformNames[4] =
5465 {
5466 "", "win32", "linux", "apple"
5467 };
5468
5469 static const int __ecereNameSpace__ecere__com__firstPlatform = 1;
5470
5471 static struct __ecereNameSpace__ecere__com__Property * __ecereProp___ecereNameSpace__ecere__com__Platform_char__PTR_, * __ecerePropM___ecereNameSpace__ecere__com__Platform_char__PTR_;
5472
5473 static const int __ecereNameSpace__ecere__com__lastPlatform = 3;
5474
5475 static struct __ecereNameSpace__ecere__com__Class * __ecereClass___ecereNameSpace__ecere__com__Platform;
5476
5477 int __ecereVMethodID_class_OnGetString;
5478
5479 char *  __ecereProp___ecereNameSpace__ecere__com__Platform_Get_char__PTR_(int this)
5480 {
5481 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)));
5482 }
5483
5484 int __ecereProp___ecereNameSpace__ecere__com__Platform_Set_char__PTR_(char *  value)
5485 {
5486 if(value)
5487 {
5488 int c;
5489
5490 for(c = __ecereNameSpace__ecere__com__firstPlatform; c <= __ecereNameSpace__ecere__com__lastPlatform; c++)
5491 if(!strcasecmp(value, __ecereNameSpace__ecere__com__platformNames[c]))
5492 return c;
5493 }
5494 return 0;
5495 }
5496
5497 char * __ecereMethod___ecereNameSpace__ecere__com__Platform_OnGetString(struct __ecereNameSpace__ecere__com__Class * class, int * this, char * tempString, void * fieldData, unsigned int * needClass)
5498 {
5499 if((*(this)) >= __ecereNameSpace__ecere__com__firstPlatform && (*(this)) <= __ecereNameSpace__ecere__com__lastPlatform)
5500 {
5501 if(tempString)
5502 strcpy(tempString, __ecereNameSpace__ecere__com__platformNames[*(int *)this]);
5503 return __ecereNameSpace__ecere__com__platformNames[*(int *)this];
5504 }
5505 if(tempString && tempString[0])
5506 tempString[0] = '\0';
5507 return (((void *)0));
5508 }
5509
5510 unsigned int __ecereMethod___ecereNameSpace__ecere__com__Platform_OnGetDataFromString(struct __ecereNameSpace__ecere__com__Class * class, int * this, char * string)
5511 {
5512 (*(this)) = __ecereProp___ecereNameSpace__ecere__com__Platform_Set_char__PTR_(string);
5513 return (unsigned int)*(int *)this;
5514 }
5515
5516 extern int runtimePlatform;
5517
5518 int __ecereNameSpace__ecere__com__GetRuntimePlatform()
5519 {
5520 return runtimePlatform;
5521 }
5522
5523 struct __ecereNameSpace__ecere__com__ObjectInfo
5524 {
5525 struct __ecereNameSpace__ecere__com__ObjectInfo * prev, * next;
5526 struct __ecereNameSpace__ecere__com__Instance * instance;
5527 char * name;
5528 struct __ecereNameSpace__ecere__com__Instance * instCode;
5529 unsigned int deleted;
5530 struct __ecereNameSpace__ecere__com__ObjectInfo * oClass;
5531 struct __ecereNameSpace__ecere__sys__OldList instances;
5532 struct __ecereNameSpace__ecere__com__Instance * classDefinition;
5533 unsigned int modified;
5534 } __attribute__ ((gcc_struct));
5535
5536 static struct __ecereNameSpace__ecere__com__Class * __ecereClass___ecereNameSpace__ecere__com__ObjectInfo;
5537
5538 static struct __ecereNameSpace__ecere__com__Property * __ecereProp___ecereNameSpace__ecere__com__DesignerBase_classDesigner, * __ecerePropM___ecereNameSpace__ecere__com__DesignerBase_classDesigner;
5539
5540 static struct __ecereNameSpace__ecere__com__Property * __ecereProp___ecereNameSpace__ecere__com__DesignerBase_objectClass, * __ecerePropM___ecereNameSpace__ecere__com__DesignerBase_objectClass;
5541
5542 static struct __ecereNameSpace__ecere__com__Property * __ecereProp___ecereNameSpace__ecere__com__DesignerBase_isDragging, * __ecerePropM___ecereNameSpace__ecere__com__DesignerBase_isDragging;
5543
5544 struct __ecereNameSpace__ecere__com__DesignerBase
5545 {
5546 struct __ecereNameSpace__ecere__com__Instance * classDesigner;
5547 char * objectClass;
5548 unsigned int isDragging;
5549 } __attribute__ ((gcc_struct));
5550
5551 static struct __ecereNameSpace__ecere__com__Class * __ecereClass___ecereNameSpace__ecere__com__DesignerBase;
5552
5553 struct __ecereNameSpace__ecere__com__Instance * __ecereProp___ecereNameSpace__ecere__com__DesignerBase_Get_classDesigner(struct __ecereNameSpace__ecere__com__Instance * this)
5554 {
5555 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);
5556
5557 return __ecerePointer___ecereNameSpace__ecere__com__DesignerBase->classDesigner;
5558 }
5559
5560 void __ecereProp___ecereNameSpace__ecere__com__DesignerBase_Set_classDesigner(struct __ecereNameSpace__ecere__com__Instance * this, struct __ecereNameSpace__ecere__com__Instance * value)
5561 {
5562 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);
5563
5564 __ecerePointer___ecereNameSpace__ecere__com__DesignerBase->classDesigner = value;
5565 __ecereNameSpace__ecere__com__eInstance_FireSelfWatchers(this, __ecereProp___ecereNameSpace__ecere__com__DesignerBase_classDesigner), __ecereNameSpace__ecere__com__eInstance_FireSelfWatchers(this, __ecerePropM___ecereNameSpace__ecere__com__DesignerBase_classDesigner);
5566 }
5567
5568 char *  __ecereProp___ecereNameSpace__ecere__com__DesignerBase_Get_objectClass(struct __ecereNameSpace__ecere__com__Instance * this)
5569 {
5570 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);
5571
5572 return __ecerePointer___ecereNameSpace__ecere__com__DesignerBase->objectClass;
5573 }
5574
5575 void __ecereProp___ecereNameSpace__ecere__com__DesignerBase_Set_objectClass(struct __ecereNameSpace__ecere__com__Instance * this, char *  value)
5576 {
5577 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);
5578
5579 __ecerePointer___ecereNameSpace__ecere__com__DesignerBase->objectClass = value;
5580 __ecereNameSpace__ecere__com__eInstance_FireSelfWatchers(this, __ecereProp___ecereNameSpace__ecere__com__DesignerBase_objectClass), __ecereNameSpace__ecere__com__eInstance_FireSelfWatchers(this, __ecerePropM___ecereNameSpace__ecere__com__DesignerBase_objectClass);
5581 }
5582
5583 unsigned int __ecereProp___ecereNameSpace__ecere__com__DesignerBase_Get_isDragging(struct __ecereNameSpace__ecere__com__Instance * this)
5584 {
5585 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);
5586
5587 return __ecerePointer___ecereNameSpace__ecere__com__DesignerBase->isDragging;
5588 }
5589
5590 void __ecereProp___ecereNameSpace__ecere__com__DesignerBase_Set_isDragging(struct __ecereNameSpace__ecere__com__Instance * this, unsigned int value)
5591 {
5592 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);
5593
5594 __ecerePointer___ecereNameSpace__ecere__com__DesignerBase->isDragging = value;
5595 __ecereNameSpace__ecere__com__eInstance_FireSelfWatchers(this, __ecereProp___ecereNameSpace__ecere__com__DesignerBase_isDragging), __ecereNameSpace__ecere__com__eInstance_FireSelfWatchers(this, __ecerePropM___ecereNameSpace__ecere__com__DesignerBase_isDragging);
5596 }
5597
5598 static struct __ecereNameSpace__ecere__com__Class * __ecereClass___ecereNameSpace__ecere__com__ClassDesignerBase;
5599
5600 struct __ecereNameSpace__ecere__com__Instance * __ecereNameSpace__ecere__com__activeDesigner;
5601
5602 void __ecereNameSpace__ecere__com__SetActiveDesigner(struct __ecereNameSpace__ecere__com__Instance * designer)
5603 {
5604 __ecereNameSpace__ecere__com__activeDesigner = designer;
5605 }
5606
5607 struct __ecereNameSpace__ecere__com__Instance * __ecereNameSpace__ecere__com__GetActiveDesigner()
5608 {
5609 return __ecereNameSpace__ecere__com__activeDesigner;
5610 }
5611
5612
5613
5614 unsigned int __ecereNameSpace__ecere__sys__UTF8Validate(char * source)
5615 {
5616 if(source)
5617 {
5618 int c;
5619
5620 for(c = 0; source[c]; )
5621 {
5622 unsigned char ch = source[c];
5623 unsigned int codePoint = 0;
5624 int numBytes = 1;
5625 int i;
5626 unsigned char mask = (unsigned char)0x7F;
5627
5628 if(ch & (unsigned char)0x80)
5629 {
5630 if(ch & (unsigned char)0x40)
5631 {
5632 mask >>= 2;
5633 numBytes++;
5634 if(ch & (unsigned char)0x20)
5635 {
5636 numBytes++;
5637 mask >>= 1;
5638 if(ch & (unsigned char)0x10)
5639 {
5640 if(ch & (unsigned char)0x08)
5641 return 0x0;
5642 numBytes++;
5643 mask >>= 1;
5644 }
5645 }
5646 }
5647 else
5648 return 0x0;
5649 }
5650 for(i = 0; i < numBytes && (ch = source[c]); i++, c++)
5651 {
5652 codePoint <<= 6;
5653 codePoint |= ch & mask;
5654 mask = (unsigned char)0x3F;
5655 if(i > 1)
5656 {
5657 if(!(ch & (unsigned char)0x80) || (ch & (unsigned char)0x40))
5658 return 0x0;
5659 }
5660 }
5661 if(i < numBytes)
5662 return 0x0;
5663 if(codePoint > 0x10FFFF || (codePoint >= 0xD800 && codePoint <= 0xDFFF) || (codePoint < 0x80 && numBytes > 1) || (codePoint < 0x800 && numBytes > 2) || (codePoint < 0x10000 && numBytes > 3))
5664 return 0x0;
5665 }
5666 }
5667 return 0x1;
5668 }
5669
5670 int __ecereNameSpace__ecere__sys__ISO8859_1toUTF8(char * source, char * dest, int max)
5671 {
5672 int c;
5673 int d = 0;
5674
5675 for(c = 0; source[c]; c++)
5676 {
5677 unsigned int ch = ((unsigned char *)source)[c];
5678
5679 if(ch < 0x80)
5680 {
5681 if(d + 1 >= max)
5682 break;
5683 dest[d++] = (char)ch;
5684 }
5685 else if(ch < 0x800)
5686 {
5687 if(d + 2 >= max)
5688 break;
5689 dest[d++] = (unsigned char)0xC0 | (unsigned char)((ch & 0x7C0) >> 6);
5690 dest[d++] = (unsigned char)0x80 | (unsigned char)(ch & 0x03F);
5691 }
5692 else if(ch < 0x10000)
5693 {
5694 if(d + 3 >= max)
5695 break;
5696 dest[d++] = (unsigned char)0xE0 | (unsigned char)((ch & 0xF000) >> 12);
5697 dest[d++] = (unsigned char)0x80 | (unsigned char)((ch & 0xFC0) >> 6);
5698 dest[d++] = (unsigned char)0x80 | (unsigned char)(ch & 0x03F);
5699 }
5700 else
5701 {
5702 if(d + 4 >= max)
5703 break;
5704 dest[d++] = (unsigned char)0xF0 | (unsigned char)((ch & 0x1C0000) >> 18);
5705 dest[d++] = (unsigned char)0x80 | (unsigned char)((ch & 0x3F000) >> 12);
5706 dest[d++] = (unsigned char)0x80 | (unsigned char)((ch & 0xFC0) >> 6);
5707 dest[d++] = (unsigned char)0x80 | (unsigned char)(ch & 0x03F);
5708 }
5709 }
5710 dest[d] = (char)0;
5711 return d;
5712 }
5713
5714 char * __ecereNameSpace__ecere__sys__UTF16toUTF8(unsigned short * source)
5715 {
5716 int c;
5717 int d = 0;
5718 int len;
5719 char * dest;
5720 unsigned short u16;
5721 unsigned int invert = 0x0;
5722
5723 for(len = 0; source[len]; len++)
5724 ;
5725 dest = __ecereNameSpace__ecere__com__eSystem_New(sizeof(char) * (len * 3 + 1));
5726 for(c = 0; (u16 = source[c]); c++)
5727 {
5728 unsigned int ch;
5729
5730 if(!c && (u16 == (unsigned short)0xFFFE || u16 == (unsigned short)0xFEFF))
5731 {
5732 if(u16 == (unsigned short)0xFFFE)
5733 invert = 0x1;
5734 continue;
5735 }
5736 if(invert)
5737 {
5738 u16 = ((u16 & (unsigned short)0xFF00) >> (unsigned short)8) | ((u16 & (unsigned short)0x00FF) << (unsigned short)8);
5739 }
5740 if(u16 < (unsigned short)0xD800 || u16 > (unsigned short)0xDBFF)
5741 ch = u16;
5742 else
5743 ch = (u16 << 10) + source[c++] + (0x10000 - (0xD800 << 10) - 0xDC00);
5744 if(ch < 0x80)
5745 {
5746 dest[d++] = (char)ch;
5747 }
5748 else if(ch < 0x800)
5749 {
5750 dest[d++] = (unsigned char)0xC0 | (unsigned char)((ch & 0x7C0) >> 6);
5751 dest[d++] = (unsigned char)0x80 | (unsigned char)(ch & 0x03F);
5752 }
5753 else if(ch < 0x10000)
5754 {
5755 dest[d++] = (unsigned char)0xE0 | (unsigned char)((ch & 0xF000) >> 12);
5756 dest[d++] = (unsigned char)0x80 | (unsigned char)((ch & 0xFC0) >> 6);
5757 dest[d++] = (unsigned char)0x80 | (unsigned char)(ch & 0x03F);
5758 }
5759 else
5760 {
5761 dest[d++] = (unsigned char)0xF0 | (unsigned char)((ch & 0x1C0000) >> 18);
5762 dest[d++] = (unsigned char)0x80 | (unsigned char)((ch & 0x3F000) >> 12);
5763 dest[d++] = (unsigned char)0x80 | (unsigned char)((ch & 0xFC0) >> 6);
5764 dest[d++] = (unsigned char)0x80 | (unsigned char)(ch & 0x03F);
5765 }
5766 }
5767 dest[d] = (char)0;
5768 dest = __ecereNameSpace__ecere__com__eSystem_Renew(dest, sizeof(char) * (d + 1));
5769 return dest;
5770 }
5771
5772 int __ecereNameSpace__ecere__sys__UTF16toUTF8Buffer(unsigned short * source, unsigned char * dest, int max)
5773 {
5774 int c;
5775 int d = 0;
5776 unsigned short u16;
5777
5778 for(c = 0; (u16 = source[c]); c++)
5779 {
5780 unsigned int ch;
5781
5782 if(u16 < (unsigned short)0xD800 || u16 > (unsigned short)0xDBFF)
5783 ch = u16;
5784 else
5785 ch = (u16 << 10) + source[c++] + (0x10000 - (0xD800 << 10) - 0xDC00);
5786 if(ch < 0x80)
5787 {
5788 if(d + 1 >= max)
5789 break;
5790 dest[d++] = (char)ch;
5791 }
5792 else if(ch < 0x800)
5793 {
5794 if(d + 2 >= max)
5795 break;
5796 dest[d++] = (unsigned char)0xC0 | (unsigned char)((ch & 0x7C0) >> 6);
5797 dest[d++] = (unsigned char)0x80 | (unsigned char)(ch & 0x03F);
5798 }
5799 else if(ch < 0x10000)
5800 {
5801 if(d + 3 >= max)
5802 break;
5803 dest[d++] = (unsigned char)0xE0 | (unsigned char)((ch & 0xF000) >> 12);
5804 dest[d++] = (unsigned char)0x80 | (unsigned char)((ch & 0xFC0) >> 6);
5805 dest[d++] = (unsigned char)0x80 | (unsigned char)(ch & 0x03F);
5806 }
5807 else
5808 {
5809 if(d + 4 >= max)
5810 break;
5811 dest[d++] = (unsigned char)0xF0 | (unsigned char)((ch & 0x1C0000) >> 18);
5812 dest[d++] = (unsigned char)0x80 | (unsigned char)((ch & 0x3F000) >> 12);
5813 dest[d++] = (unsigned char)0x80 | (unsigned char)((ch & 0xFC0) >> 6);
5814 dest[d++] = (unsigned char)0x80 | (unsigned char)(ch & 0x03F);
5815 }
5816 }
5817 dest[d] = (unsigned char)0;
5818 return d;
5819 }
5820
5821 unsigned int __ecereNameSpace__ecere__sys__UTF8GetChar(char * string, int * numBytes)
5822 {
5823 unsigned int ch;
5824 unsigned char b = ((unsigned char *)string)[0];
5825 int i;
5826 unsigned char mask = (unsigned char)0x7F;
5827 int nb = b ? 1 : 0;
5828
5829 ch = 0;
5830 if(b & (unsigned char)0x80)
5831 {
5832 if(b & (unsigned char)0x40)
5833 {
5834 mask >>= 2;
5835 nb++;
5836 if(b & (unsigned char)0x20)
5837 {
5838 nb++;
5839 mask >>= 1;
5840 if(b & (unsigned char)0x10)
5841 {
5842 if(b & (unsigned char)0x08)
5843 {
5844 nb = 0;
5845 }
5846 nb++;
5847 mask >>= 1;
5848 }
5849 }
5850 }
5851 else
5852 nb = 0;
5853 }
5854 for(i = 0; i < nb; i++)
5855 {
5856 ch <<= 6;
5857 ch |= (b = ((unsigned char *)string)[i]) & mask;
5858 mask = (unsigned char)0x3F;
5859 if(i > 1 && (!(b & (unsigned char)0x80) || (b & (unsigned char)0x40)))
5860 {
5861 nb = 0;
5862 ch = 0;
5863 }
5864 }
5865 if(i < nb || ch > 0x10FFFF || (ch >= 0xD800 && ch <= 0xDFFF) || (ch < 0x80 && nb > 1) || (ch < 0x800 && nb > 2) || (ch < 0x10000 && nb > 3))
5866 {
5867 ch = 0;
5868 nb = 0;
5869 }
5870 if(numBytes)
5871 *numBytes = nb;
5872 return ch;
5873 }
5874
5875 int __ecereNameSpace__ecere__sys__UTF8toUTF16Buffer(char * source, unsigned short * dest, int max)
5876 {
5877 if(source)
5878 {
5879 int c;
5880 int d = 0;
5881
5882 for(c = 0; source[c]; )
5883 {
5884 unsigned char ch = source[c];
5885 unsigned int codePoint = 0;
5886 int numBytes = 1;
5887 int i;
5888 unsigned char mask = (unsigned char)0x7F;
5889
5890 if(ch & (unsigned char)0x80 && ch & (unsigned char)0x40)
5891 {
5892 mask >>= 2;
5893 numBytes++;
5894 if(ch & (unsigned char)0x20)
5895 {
5896 numBytes++;
5897 mask >>= 1;
5898 if(ch & (unsigned char)0x10)
5899 {
5900 numBytes++;
5901 mask >>= 1;
5902 }
5903 }
5904 }
5905 for(i = 0; i < numBytes; i++)
5906 {
5907 codePoint <<= 6;
5908 codePoint |= source[c++] & mask;
5909 mask = (unsigned char)0x3F;
5910 }
5911 if(codePoint > 0xFFFF)
5912 {
5913 unsigned short lead = (unsigned short)((0xD800 - (0x10000 >> 10)) + (codePoint >> 10));
5914 unsigned short trail = (unsigned short)0xDC00 + (unsigned short)(codePoint & 0x3FF);
5915
5916 if(d >= max - 1)
5917 break;
5918 dest[d++] = lead;
5919 dest[d++] = trail;
5920 }
5921 else
5922 {
5923 if(d >= max)
5924 break;
5925 dest[d++] = (unsigned short)codePoint;
5926 }
5927 }
5928 dest[d] = (unsigned short)0;
5929 return d;
5930 }
5931 return 0;
5932 }
5933
5934 int __ecereNameSpace__ecere__sys__UTF32toUTF8Len(unsigned int * source, int count, unsigned char * dest, int max)
5935 {
5936 int c;
5937 int d = 0;
5938 unsigned int ch;
5939
5940 for(c = 0; c < count && (ch = source[c]); c++)
5941 {
5942 if(ch < 0x80)
5943 {
5944 if(d + 1 >= max)
5945 break;
5946 dest[d++] = (char)ch;
5947 }
5948 else if(ch < 0x800)
5949 {
5950 if(d + 2 >= max)
5951 break;
5952 dest[d++] = (unsigned char)0xC0 | (unsigned char)((ch & 0x7C0) >> 6);
5953 dest[d++] = (unsigned char)0x80 | (unsigned char)(ch & 0x03F);
5954 }
5955 else if(ch < 0x10000)
5956 {
5957 if(d + 3 >= max)
5958 break;
5959 dest[d++] = (unsigned char)0xE0 | (unsigned char)((ch & 0xF000) >> 12);
5960 dest[d++] = (unsigned char)0x80 | (unsigned char)((ch & 0xFC0) >> 6);
5961 dest[d++] = (unsigned char)0x80 | (unsigned char)(ch & 0x03F);
5962 }
5963 else
5964 {
5965 if(d + 4 >= max)
5966 break;
5967 dest[d++] = (unsigned char)0xF0 | (unsigned char)((ch & 0x1C0000) >> 18);
5968 dest[d++] = (unsigned char)0x80 | (unsigned char)((ch & 0x3F000) >> 12);
5969 dest[d++] = (unsigned char)0x80 | (unsigned char)((ch & 0xFC0) >> 6);
5970 dest[d++] = (unsigned char)0x80 | (unsigned char)(ch & 0x03F);
5971 }
5972 }
5973 dest[d] = (unsigned char)0;
5974 return d;
5975 }
5976
5977 unsigned short * __ecereNameSpace__ecere__sys__UTF8toUTF16(char * source, int * wordCount)
5978 {
5979 if(source)
5980 {
5981 int len = strlen(source);
5982 unsigned short * dest = __ecereNameSpace__ecere__com__eSystem_New(sizeof(unsigned short) * (len + 1));
5983 int c;
5984 int d = 0;
5985
5986 for(c = 0; source[c]; )
5987 {
5988 unsigned char ch = source[c];
5989 unsigned int codePoint = 0;
5990 int numBytes = 1;
5991 int i;
5992 unsigned char mask = (unsigned char)0x7F;
5993
5994 if(ch & (unsigned char)0x80 && ch & (unsigned char)0x40)
5995 {
5996 mask >>= 2;
5997 numBytes++;
5998 if(ch & (unsigned char)0x20)
5999 {
6000 numBytes++;
6001 mask >>= 1;
6002 if(ch & (unsigned char)0x10)
6003 {
6004 numBytes++;
6005 mask >>= 1;
6006 }
6007 }
6008 }
6009 for(i = 0; i < numBytes; i++)
6010 {
6011 codePoint <<= 6;
6012 codePoint |= source[c++] & mask;
6013 mask = (unsigned char)0x3F;
6014 }
6015 if(codePoint > 0xFFFF)
6016 {
6017 unsigned short lead = (unsigned short)((0xD800 - (0x10000 >> 10)) + (codePoint >> 10));
6018 unsigned short trail = (unsigned short)0xDC00 + (unsigned short)(codePoint & 0x3FF);
6019
6020 dest[d++] = lead;
6021 dest[d++] = trail;
6022 }
6023 else
6024 {
6025 dest[d++] = (unsigned short)codePoint;
6026 }
6027 }
6028 dest[d] = (unsigned short)0;
6029 if(wordCount)
6030 *wordCount = d;
6031 return dest;
6032 }
6033 return (((void *)0));
6034 }
6035
6036 int __ecereVMethodID___ecereNameSpace__ecere__com__DesignerBase_FindObject;
6037
6038 int __ecereVMethodID___ecereNameSpace__ecere__com__DesignerBase_RenameObject;
6039
6040 int __ecereVMethodID___ecereNameSpace__ecere__com__DesignerBase_SelectObjectFromDesigner;
6041
6042 int __ecereVMethodID___ecereNameSpace__ecere__com__DesignerBase_CodeAddObject;
6043
6044 int __ecereVMethodID___ecereNameSpace__ecere__com__DesignerBase_SheetAddObject;
6045
6046 int __ecereVMethodID___ecereNameSpace__ecere__com__DesignerBase_AddToolBoxClass;
6047
6048 int __ecereVMethodID___ecereNameSpace__ecere__com__DesignerBase_AddDefaultMethod;
6049
6050 int __ecereVMethodID___ecereNameSpace__ecere__com__DesignerBase_DeleteObject;
6051
6052 int __ecereVMethodID___ecereNameSpace__ecere__com__DesignerBase_ObjectContainsCode;
6053
6054 int __ecereVMethodID___ecereNameSpace__ecere__com__DesignerBase_ModifyCode;
6055
6056 int __ecereVMethodID___ecereNameSpace__ecere__com__DesignerBase_UpdateProperties;
6057
6058 int __ecereVMethodID___ecereNameSpace__ecere__com__ClassDesignerBase_Reset;
6059
6060 int __ecereVMethodID___ecereNameSpace__ecere__com__ClassDesignerBase_AddObject;
6061
6062 int __ecereVMethodID___ecereNameSpace__ecere__com__ClassDesignerBase_SelectObject;
6063
6064 int __ecereVMethodID___ecereNameSpace__ecere__com__ClassDesignerBase_ListToolBoxClasses;
6065
6066 int __ecereVMethodID___ecereNameSpace__ecere__com__ClassDesignerBase_PrepareTestObject;
6067
6068 int __ecereVMethodID___ecereNameSpace__ecere__com__ClassDesignerBase_CreateObject;
6069
6070 int __ecereVMethodID___ecereNameSpace__ecere__com__ClassDesignerBase_PostCreateObject;
6071
6072 int __ecereVMethodID___ecereNameSpace__ecere__com__ClassDesignerBase_DroppedObject;
6073
6074 int __ecereVMethodID___ecereNameSpace__ecere__com__ClassDesignerBase_DestroyObject;
6075
6076 int __ecereVMethodID___ecereNameSpace__ecere__com__ClassDesignerBase_FixProperty;
6077
6078 int __ecereVMethodID___ecereNameSpace__ecere__com__ClassDesignerBase_CreateNew;
6079
6080 void __ecereRegisterModule_instance(struct __ecereNameSpace__ecere__com__Instance * module)
6081 {
6082 struct __ecereNameSpace__ecere__com__Class * class;
6083
6084 __ecereNameSpace__ecere__com__eSystem_RegisterDefine("ecere::com::null", "((void *)0)", module, 4);
6085 class = __ecereNameSpace__ecere__com__eSystem_RegisterClass(3, "ecere::com::unichar", "uint", 0, 0, 0, 0, module, 4, 1);
6086 if(((struct __ecereNameSpace__ecere__com__Module *)(((char *)module + structSize_Instance)))->application == ((struct __ecereNameSpace__ecere__com__Module *)(((char *)__thisModule + structSize_Instance)))->application && class)
6087 __ecereClass___ecereNameSpace__ecere__com__unichar = class;
6088 __ecereNameSpace__ecere__com__eClass_AddMethod(class, "OnGetString", 0, __ecereMethod___ecereNameSpace__ecere__com__unichar_OnGetString, 1);
6089 __ecereNameSpace__ecere__com__eClass_AddMethod(class, "OnGetDataFromString", 0, __ecereMethod___ecereNameSpace__ecere__com__unichar_OnGetDataFromString, 1);
6090 class = __ecereNameSpace__ecere__com__eSystem_RegisterClass(5, "ecere::com::Property", 0, sizeof(struct __ecereNameSpace__ecere__com__Property), 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__Property = class;
6093 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "prev", "ecere::com::Property", arch_PointerSize, arch_PointerSize, 1);
6094 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "next", "ecere::com::Property", arch_PointerSize, arch_PointerSize, 1);
6095 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "name", "char *", arch_PointerSize, arch_PointerSize, 1);
6096 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "isProperty", "bool", 4, 4, 1);
6097 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "memberAccess", "ecere::com::AccessMode", 4, 4, 1);
6098 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "id", "int", 4, 4, 1);
6099 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "_class", "ecere::com::Class", arch_PointerSize, arch_PointerSize, 1);
6100 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "dataTypeString", "char *", arch_PointerSize, arch_PointerSize, 1);
6101 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "dataTypeClass", "ecere::com::Class", arch_PointerSize, arch_PointerSize, 1);
6102 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "dataType", "Type", arch_PointerSize, arch_PointerSize, 1);
6103 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "Set", "void( *)(void *, int)", arch_PointerSize, arch_PointerSize, 1);
6104 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "Get", "int( *)(void *)", arch_PointerSize, arch_PointerSize, 1);
6105 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "IsSet", "bool( *)(void *)", arch_PointerSize, arch_PointerSize, 1);
6106 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "data", "void *", arch_PointerSize, arch_PointerSize, 1);
6107 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "symbol", "void *", arch_PointerSize, arch_PointerSize, 1);
6108 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "vid", "int", 4, 4, 1);
6109 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "conversion", "bool", 4, 4, 1);
6110 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "watcherOffset", "uint", 4, 4, 1);
6111 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "category", "char *", arch_PointerSize, arch_PointerSize, 1);
6112 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "compiled", "bool", 4, 4, 1);
6113 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "selfWatchable", "bool", 4, 4, 1);
6114 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "isWatchable", "bool", 4, 4, 1);
6115 if(class)
6116 class->fixed = (unsigned int)1;
6117 if(class)
6118 class->noExpansion = (unsigned int)1;
6119 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("ecere::com::MemoryGuard_PushLoc", "void ecere::com::MemoryGuard_PushLoc(char * loc)", __ecereNameSpace__ecere__com__MemoryGuard_PushLoc, module, 4);
6120 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("ecere::com::MemoryGuard_PopLoc", "void ecere::com::MemoryGuard_PopLoc(void)", __ecereNameSpace__ecere__com__MemoryGuard_PopLoc, module, 4);
6121 class = __ecereNameSpace__ecere__com__eSystem_RegisterClass(5, "ecere::com::BTNamedLink", 0, sizeof(struct __ecereNameSpace__ecere__com__BTNamedLink), 0, 0, 0, module, 4, 1);
6122 if(((struct __ecereNameSpace__ecere__com__Module *)(((char *)module + structSize_Instance)))->application == ((struct __ecereNameSpace__ecere__com__Module *)(((char *)__thisModule + structSize_Instance)))->application && class)
6123 __ecereClass___ecereNameSpace__ecere__com__BTNamedLink = class;
6124 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "name", "char *", arch_PointerSize, arch_PointerSize, 1);
6125 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "parent", "ecere::com::BTNamedLink", arch_PointerSize, arch_PointerSize, 1);
6126 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "left", "ecere::com::BTNamedLink", arch_PointerSize, arch_PointerSize, 1);
6127 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "right", "ecere::com::BTNamedLink", arch_PointerSize, arch_PointerSize, 1);
6128 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "depth", "int", 4, 4, 1);
6129 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "data", "void *", arch_PointerSize, arch_PointerSize, 1);
6130 if(class)
6131 class->fixed = (unsigned int)1;
6132 class = __ecereNameSpace__ecere__com__eSystem_RegisterClass(5, "ecere::com::SelfWatcher", 0, sizeof(struct __ecereNameSpace__ecere__com__SelfWatcher), 0, 0, 0, module, 2, 1);
6133 if(((struct __ecereNameSpace__ecere__com__Module *)(((char *)module + structSize_Instance)))->application == ((struct __ecereNameSpace__ecere__com__Module *)(((char *)__thisModule + structSize_Instance)))->application && class)
6134 __ecereClass___ecereNameSpace__ecere__com__SelfWatcher = class;
6135 if(class)
6136 class->fixed = (unsigned int)1;
6137 class = __ecereNameSpace__ecere__com__eSystem_RegisterClass(4, "ecere::com::AccessMode", 0, 0, 0, 0, 0, module, 4, 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__AccessMode = class;
6140 __ecereNameSpace__ecere__com__eEnum_AddFixedValue(class, "defaultAccess", 0);
6141 __ecereNameSpace__ecere__com__eEnum_AddFixedValue(class, "publicAccess", 1);
6142 __ecereNameSpace__ecere__com__eEnum_AddFixedValue(class, "privateAccess", 2);
6143 __ecereNameSpace__ecere__com__eEnum_AddFixedValue(class, "staticAccess", 3);
6144 __ecereNameSpace__ecere__com__eEnum_AddFixedValue(class, "baseSystemAccess", 4);
6145 class = __ecereNameSpace__ecere__com__eSystem_RegisterClass(5, "ecere::com::SubModule", 0, sizeof(struct __ecereNameSpace__ecere__com__SubModule), 0, 0, 0, module, 4, 1);
6146 if(((struct __ecereNameSpace__ecere__com__Module *)(((char *)module + structSize_Instance)))->application == ((struct __ecereNameSpace__ecere__com__Module *)(((char *)__thisModule + structSize_Instance)))->application && class)
6147 __ecereClass___ecereNameSpace__ecere__com__SubModule = class;
6148 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "prev", "ecere::com::SubModule", arch_PointerSize, arch_PointerSize, 1);
6149 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "next", "ecere::com::SubModule", arch_PointerSize, arch_PointerSize, 1);
6150 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "module", "ecere::com::Module", arch_PointerSize, arch_PointerSize, 1);
6151 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "importMode", "ecere::com::AccessMode", 4, 4, 1);
6152 class = __ecereNameSpace__ecere__com__eSystem_RegisterClass(4, "ecere::com::DataMemberType", 0, 0, 0, 0, 0, module, 4, 1);
6153 if(((struct __ecereNameSpace__ecere__com__Module *)(((char *)module + structSize_Instance)))->application == ((struct __ecereNameSpace__ecere__com__Module *)(((char *)__thisModule + structSize_Instance)))->application && class)
6154 __ecereClass___ecereNameSpace__ecere__com__DataMemberType = class;
6155 __ecereNameSpace__ecere__com__eEnum_AddFixedValue(class, "normalMember", 0);
6156 __ecereNameSpace__ecere__com__eEnum_AddFixedValue(class, "unionMember", 1);
6157 __ecereNameSpace__ecere__com__eEnum_AddFixedValue(class, "structMember", 2);
6158 class = __ecereNameSpace__ecere__com__eSystem_RegisterClass(4, "ecere::com::ClassType", 0, 0, 0, 0, 0, module, 4, 1);
6159 if(((struct __ecereNameSpace__ecere__com__Module *)(((char *)module + structSize_Instance)))->application == ((struct __ecereNameSpace__ecere__com__Module *)(((char *)__thisModule + structSize_Instance)))->application && class)
6160 __ecereClass___ecereNameSpace__ecere__com__ClassType = class;
6161 __ecereNameSpace__ecere__com__eEnum_AddFixedValue(class, "normalClass", 0);
6162 __ecereNameSpace__ecere__com__eEnum_AddFixedValue(class, "structClass", 1);
6163 __ecereNameSpace__ecere__com__eEnum_AddFixedValue(class, "bitClass", 2);
6164 __ecereNameSpace__ecere__com__eEnum_AddFixedValue(class, "unitClass", 3);
6165 __ecereNameSpace__ecere__com__eEnum_AddFixedValue(class, "enumClass", 4);
6166 __ecereNameSpace__ecere__com__eEnum_AddFixedValue(class, "noHeadClass", 5);
6167 __ecereNameSpace__ecere__com__eEnum_AddFixedValue(class, "unionClass", 6);
6168 __ecereNameSpace__ecere__com__eEnum_AddFixedValue(class, "systemClass", 1000);
6169 class = __ecereNameSpace__ecere__com__eSystem_RegisterClass(5, "ecere::com::Class", 0, sizeof(struct __ecereNameSpace__ecere__com__Class), 0, 0, 0, module, 4, 1);
6170 if(((struct __ecereNameSpace__ecere__com__Module *)(((char *)module + structSize_Instance)))->application == ((struct __ecereNameSpace__ecere__com__Module *)(((char *)__thisModule + structSize_Instance)))->application && class)
6171 __ecereClass___ecereNameSpace__ecere__com__Class = class;
6172 __ecereNameSpace__ecere__com__eClass_AddMethod(class, "OnFree", 0, __ecereMethod___ecereNameSpace__ecere__com__Class_OnFree, 1);
6173 __ecereNameSpace__ecere__com__eClass_AddMethod(class, "OnGetString", 0, __ecereMethod___ecereNameSpace__ecere__com__Class_OnGetString, 1);
6174 __ecereNameSpace__ecere__com__eClass_AddMethod(class, "OnGetDataFromString", 0, __ecereMethod___ecereNameSpace__ecere__com__Class_OnGetDataFromString, 1);
6175 __ecereNameSpace__ecere__com__eClass_AddMethod(class, "OnSerialize", 0, __ecereMethod___ecereNameSpace__ecere__com__Class_OnSerialize, 1);
6176 __ecereNameSpace__ecere__com__eClass_AddMethod(class, "OnUnserialize", 0, __ecereMethod___ecereNameSpace__ecere__com__Class_OnUnserialize, 1);
6177 __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);
6178 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "prev", "ecere::com::Class", arch_PointerSize, arch_PointerSize, 1);
6179 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "next", "ecere::com::Class", arch_PointerSize, arch_PointerSize, 1);
6180 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "name", "char *", arch_PointerSize, arch_PointerSize, 1);
6181 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "offset", "int", 4, 4, 1);
6182 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "structSize", "int", 4, 4, 1);
6183 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "_vTbl", "int( * *)()", arch_PointerSize, arch_PointerSize, 1);
6184 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "vTblSize", "int", 4, 4, 1);
6185 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "Constructor", "int( *)(ecere::com::Instance)", arch_PointerSize, arch_PointerSize, 1);
6186 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "Destructor", "void( *)(ecere::com::Instance)", arch_PointerSize, arch_PointerSize, 1);
6187 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "offsetClass", "int", 4, 4, 1);
6188 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "sizeClass", "int", 4, 4, 1);
6189 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "base", "ecere::com::Class", arch_PointerSize, arch_PointerSize, 1);
6190 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "methods", "ecere::sys::BinaryTree", structSize_BinaryTree, arch_PointerSize, 1);
6191 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "members", "ecere::sys::BinaryTree", structSize_BinaryTree, arch_PointerSize, 1);
6192 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "prop", "ecere::sys::BinaryTree", structSize_BinaryTree, arch_PointerSize, 1);
6193 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "membersAndProperties", "ecere::sys::OldList", structSize_OldList, arch_PointerSize, 1);
6194 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "classProperties", "ecere::sys::BinaryTree", structSize_BinaryTree, arch_PointerSize, 1);
6195 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "derivatives", "ecere::sys::OldList", structSize_OldList, arch_PointerSize, 1);
6196 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "memberID", "int", 4, 4, 1);
6197 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "startMemberID", "int", 4, 4, 1);
6198 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "type", "ecere::com::ClassType", 4, 4, 1);
6199 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "module", "ecere::com::Module", arch_PointerSize, arch_PointerSize, 1);
6200 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "nameSpace", "ecere::com::NameSpace *", arch_PointerSize, arch_PointerSize, 1);
6201 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "dataTypeString", "char *", arch_PointerSize, arch_PointerSize, 1);
6202 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "dataType", "Type", arch_PointerSize, arch_PointerSize, 1);
6203 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "typeSize", "int", 4, 4, 1);
6204 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "defaultAlignment", "int", 4, 4, 1);
6205 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "Initialize", "void( *)()", arch_PointerSize, arch_PointerSize, 1);
6206 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "memberOffset", "int", 4, 4, 1);
6207 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "selfWatchers", "ecere::sys::OldList", structSize_OldList, arch_PointerSize, 1);
6208 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "designerClass", "char *", arch_PointerSize, arch_PointerSize, 1);
6209 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "noExpansion", "bool", 4, 4, 1);
6210 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "defaultProperty", "char *", arch_PointerSize, arch_PointerSize, 1);
6211 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "comRedefinition", "bool", 4, 4, 1);
6212 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "count", "int", 4, 4, 1);
6213 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "isRemote", "bool", 4, 4, 1);
6214 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "internalDecl", "bool", 4, 4, 1);
6215 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "data", "void *", arch_PointerSize, arch_PointerSize, 1);
6216 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "computeSize", "bool", 4, 4, 1);
6217 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "structAlignment", "int", 4, 4, 1);
6218 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "destructionWatchOffset", "int", 4, 4, 1);
6219 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "fixed", "bool", 4, 4, 1);
6220 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "delayedCPValues", "ecere::sys::OldList", structSize_OldList, arch_PointerSize, 1);
6221 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "inheritanceAccess", "ecere::com::AccessMode", 4, 4, 1);
6222 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "fullName", "char *", arch_PointerSize, arch_PointerSize, 1);
6223 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "symbol", "void *", arch_PointerSize, arch_PointerSize, 1);
6224 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "conversions", "ecere::sys::OldList", structSize_OldList, arch_PointerSize, 1);
6225 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "templateParams", "ecere::sys::OldList", structSize_OldList, arch_PointerSize, 1);
6226 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "templateArgs", "ecere::com::ClassTemplateArgument *", arch_PointerSize, arch_PointerSize, 1);
6227 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "templateClass", "ecere::com::Class", arch_PointerSize, arch_PointerSize, 1);
6228 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "templatized", "ecere::sys::OldList", structSize_OldList, arch_PointerSize, 1);
6229 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "numParams", "int", 4, 4, 1);
6230 if(class)
6231 class->fixed = (unsigned int)1;
6232 if(class)
6233 class->noExpansion = (unsigned int)1;
6234 class = __ecereNameSpace__ecere__com__eSystem_RegisterClass(4, "ecere::com::TemplateParameterType", 0, 0, 0, 0, 0, module, 4, 1);
6235 if(((struct __ecereNameSpace__ecere__com__Module *)(((char *)module + structSize_Instance)))->application == ((struct __ecereNameSpace__ecere__com__Module *)(((char *)__thisModule + structSize_Instance)))->application && class)
6236 __ecereClass___ecereNameSpace__ecere__com__TemplateParameterType = class;
6237 __ecereNameSpace__ecere__com__eEnum_AddFixedValue(class, "type", 0);
6238 __ecereNameSpace__ecere__com__eEnum_AddFixedValue(class, "identifier", 1);
6239 __ecereNameSpace__ecere__com__eEnum_AddFixedValue(class, "expression", 2);
6240 class = __ecereNameSpace__ecere__com__eSystem_RegisterClass(4, "ecere::com::TemplateMemberType", 0, 0, 0, 0, 0, module, 4, 1);
6241 if(((struct __ecereNameSpace__ecere__com__Module *)(((char *)module + structSize_Instance)))->application == ((struct __ecereNameSpace__ecere__com__Module *)(((char *)__thisModule + structSize_Instance)))->application && class)
6242 __ecereClass___ecereNameSpace__ecere__com__TemplateMemberType = class;
6243 __ecereNameSpace__ecere__com__eEnum_AddFixedValue(class, "dataMember", 0);
6244 __ecereNameSpace__ecere__com__eEnum_AddFixedValue(class, "method", 1);
6245 __ecereNameSpace__ecere__com__eEnum_AddFixedValue(class, "prop", 2);
6246 class = __ecereNameSpace__ecere__com__eSystem_RegisterClass(1, "ecere::com::ClassTemplateArgument", 0, sizeof(struct __ecereNameSpace__ecere__com__ClassTemplateArgument), 0, 0, 0, module, 4, 1);
6247 if(((struct __ecereNameSpace__ecere__com__Module *)(((char *)module + structSize_Instance)))->application == ((struct __ecereNameSpace__ecere__com__Module *)(((char *)__thisModule + structSize_Instance)))->application && class)
6248 __ecereClass___ecereNameSpace__ecere__com__ClassTemplateArgument = class;
6249 {
6250 struct __ecereNameSpace__ecere__com__DataMember * dataMember0 = __ecereNameSpace__ecere__com__eMember_New(1, 1);
6251
6252 {
6253 struct __ecereNameSpace__ecere__com__DataMember * dataMember1 = __ecereNameSpace__ecere__com__eMember_New(2, 1);
6254
6255 __ecereNameSpace__ecere__com__eMember_AddDataMember(dataMember1, "dataTypeString", "char *", arch_PointerSize, arch_PointerSize, 1);
6256 __ecereNameSpace__ecere__com__eMember_AddDataMember(dataMember1, "dataTypeClass", "ecere::com::Class", arch_PointerSize, arch_PointerSize, 1);
6257 __ecereNameSpace__ecere__com__eMember_AddMember(dataMember0, dataMember1);
6258 }
6259 __ecereNameSpace__ecere__com__eMember_AddDataMember(dataMember0, "expression", "ecere::com::DataValue", 8, 8, 1);
6260 {
6261 struct __ecereNameSpace__ecere__com__DataMember * dataMember1 = __ecereNameSpace__ecere__com__eMember_New(2, 1);
6262
6263 __ecereNameSpace__ecere__com__eMember_AddDataMember(dataMember1, "memberString", "char *", arch_PointerSize, arch_PointerSize, 1);
6264 {
6265 struct __ecereNameSpace__ecere__com__DataMember * dataMember2 = __ecereNameSpace__ecere__com__eMember_New(1, 1);
6266
6267 __ecereNameSpace__ecere__com__eMember_AddDataMember(dataMember2, "member", "ecere::com::DataMember", arch_PointerSize, arch_PointerSize, 1);
6268 __ecereNameSpace__ecere__com__eMember_AddDataMember(dataMember2, "prop", "ecere::com::Property", arch_PointerSize, arch_PointerSize, 1);
6269 __ecereNameSpace__ecere__com__eMember_AddDataMember(dataMember2, "method", "ecere::com::Method", arch_PointerSize, arch_PointerSize, 1);
6270 __ecereNameSpace__ecere__com__eMember_AddMember(dataMember1, dataMember2);
6271 }
6272 __ecereNameSpace__ecere__com__eMember_AddMember(dataMember0, dataMember1);
6273 }
6274 __ecereNameSpace__ecere__com__eClass_AddMember(class, dataMember0);
6275 }
6276 class = __ecereNameSpace__ecere__com__eSystem_RegisterClass(5, "ecere::com::ClassTemplateParameter", 0, sizeof(struct __ecereNameSpace__ecere__com__ClassTemplateParameter), 0, 0, 0, module, 4, 1);
6277 if(((struct __ecereNameSpace__ecere__com__Module *)(((char *)module + structSize_Instance)))->application == ((struct __ecereNameSpace__ecere__com__Module *)(((char *)__thisModule + structSize_Instance)))->application && class)
6278 __ecereClass___ecereNameSpace__ecere__com__ClassTemplateParameter = class;
6279 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "prev", "ecere::com::ClassTemplateParameter", arch_PointerSize, arch_PointerSize, 1);
6280 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "next", "ecere::com::ClassTemplateParameter", arch_PointerSize, arch_PointerSize, 1);
6281 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "name", "char *", arch_PointerSize, arch_PointerSize, 1);
6282 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "type", "ecere::com::TemplateParameterType", 4, 4, 1);
6283 {
6284 struct __ecereNameSpace__ecere__com__DataMember * dataMember0 = __ecereNameSpace__ecere__com__eMember_New(1, 1);
6285
6286 __ecereNameSpace__ecere__com__eMember_AddDataMember(dataMember0, "dataTypeString", "char *", arch_PointerSize, arch_PointerSize, 1);
6287 __ecereNameSpace__ecere__com__eMember_AddDataMember(dataMember0, "memberType", "ecere::com::TemplateMemberType", 4, 4, 1);
6288 __ecereNameSpace__ecere__com__eClass_AddMember(class, dataMember0);
6289 }
6290 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "defaultArg", "ecere::com::ClassTemplateArgument", structSize_ClassTemplateArgument, 8, 1);
6291 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "param", "void *", arch_PointerSize, arch_PointerSize, 1);
6292 if(class)
6293 class->fixed = (unsigned int)1;
6294 class = __ecereNameSpace__ecere__com__eSystem_RegisterClass(4, "ecere::com::MethodType", 0, 0, 0, 0, 0, module, 4, 1);
6295 if(((struct __ecereNameSpace__ecere__com__Module *)(((char *)module + structSize_Instance)))->application == ((struct __ecereNameSpace__ecere__com__Module *)(((char *)__thisModule + structSize_Instance)))->application && class)
6296 __ecereClass___ecereNameSpace__ecere__com__MethodType = class;
6297 __ecereNameSpace__ecere__com__eEnum_AddFixedValue(class, "normalMethod", 0);
6298 __ecereNameSpace__ecere__com__eEnum_AddFixedValue(class, "virtualMethod", 1);
6299 class = __ecereNameSpace__ecere__com__eSystem_RegisterClass(5, "ecere::com::Method", 0, sizeof(struct __ecereNameSpace__ecere__com__Method), 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__Method = class;
6302 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "name", "char *", arch_PointerSize, arch_PointerSize, 1);
6303 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "parent", "ecere::com::Method", arch_PointerSize, arch_PointerSize, 1);
6304 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "left", "ecere::com::Method", arch_PointerSize, arch_PointerSize, 1);
6305 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "right", "ecere::com::Method", arch_PointerSize, arch_PointerSize, 1);
6306 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "depth", "int", 4, 4, 1);
6307 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "function", "int( *)()", arch_PointerSize, arch_PointerSize, 1);
6308 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "vid", "int", 4, 4, 1);
6309 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "type", "ecere::com::MethodType", 4, 4, 1);
6310 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "_class", "ecere::com::Class", arch_PointerSize, arch_PointerSize, 1);
6311 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "symbol", "void *", arch_PointerSize, arch_PointerSize, 1);
6312 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "dataTypeString", "char *", arch_PointerSize, arch_PointerSize, 1);
6313 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "dataType", "Type", arch_PointerSize, arch_PointerSize, 1);
6314 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "memberAccess", "ecere::com::AccessMode", 4, 4, 1);
6315 if(class)
6316 class->fixed = (unsigned int)1;
6317 class = __ecereNameSpace__ecere__com__eSystem_RegisterClass(4, "ecere::com::ImportType", 0, 0, 0, 0, 0, module, 4, 1);
6318 if(((struct __ecereNameSpace__ecere__com__Module *)(((char *)module + structSize_Instance)))->application == ((struct __ecereNameSpace__ecere__com__Module *)(((char *)__thisModule + structSize_Instance)))->application && class)
6319 __ecereClass___ecereNameSpace__ecere__com__ImportType = class;
6320 __ecereNameSpace__ecere__com__eEnum_AddFixedValue(class, "normalImport", 0);
6321 __ecereNameSpace__ecere__com__eEnum_AddFixedValue(class, "staticImport", 1);
6322 __ecereNameSpace__ecere__com__eEnum_AddFixedValue(class, "remoteImport", 2);
6323 __ecereNameSpace__ecere__com__eEnum_AddFixedValue(class, "preDeclImport", 3);
6324 __ecereNameSpace__ecere__com__eEnum_AddFixedValue(class, "comCheckImport", 4);
6325 class = __ecereNameSpace__ecere__com__eSystem_RegisterClass(1, "ecere::com::NameSpace", 0, sizeof(struct __ecereNameSpace__ecere__com__NameSpace), 0, 0, 0, module, 4, 1);
6326 if(((struct __ecereNameSpace__ecere__com__Module *)(((char *)module + structSize_Instance)))->application == ((struct __ecereNameSpace__ecere__com__Module *)(((char *)__thisModule + structSize_Instance)))->application && class)
6327 __ecereClass___ecereNameSpace__ecere__com__NameSpace = class;
6328 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "name", "char *", arch_PointerSize, arch_PointerSize, 1);
6329 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "btParent", "ecere::com::NameSpace *", arch_PointerSize, arch_PointerSize, 1);
6330 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "left", "ecere::com::NameSpace *", arch_PointerSize, arch_PointerSize, 1);
6331 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "right", "ecere::com::NameSpace *", arch_PointerSize, arch_PointerSize, 1);
6332 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "depth", "int", 4, 4, 1);
6333 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "parent", "ecere::com::NameSpace *", arch_PointerSize, arch_PointerSize, 1);
6334 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "nameSpaces", "ecere::sys::BinaryTree", structSize_BinaryTree, arch_PointerSize, 1);
6335 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "classes", "ecere::sys::BinaryTree", structSize_BinaryTree, arch_PointerSize, 1);
6336 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "defines", "ecere::sys::BinaryTree", structSize_BinaryTree, arch_PointerSize, 1);
6337 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "functions", "ecere::sys::BinaryTree", structSize_BinaryTree, arch_PointerSize, 1);
6338 class = __ecereNameSpace__ecere__com__eSystem_RegisterClass(1, "ecere::com::DataValue", 0, sizeof(struct __ecereNameSpace__ecere__com__DataValue), 0, 0, 0, module, 4, 1);
6339 if(((struct __ecereNameSpace__ecere__com__Module *)(((char *)module + structSize_Instance)))->application == ((struct __ecereNameSpace__ecere__com__Module *)(((char *)__thisModule + structSize_Instance)))->application && class)
6340 __ecereClass___ecereNameSpace__ecere__com__DataValue = class;
6341 {
6342 struct __ecereNameSpace__ecere__com__DataMember * dataMember0 = __ecereNameSpace__ecere__com__eMember_New(1, 1);
6343
6344 __ecereNameSpace__ecere__com__eMember_AddDataMember(dataMember0, "c", "char", 1, 1, 1);
6345 __ecereNameSpace__ecere__com__eMember_AddDataMember(dataMember0, "uc", "byte", 1, 1, 1);
6346 __ecereNameSpace__ecere__com__eMember_AddDataMember(dataMember0, "s", "short", 2, 2, 1);
6347 __ecereNameSpace__ecere__com__eMember_AddDataMember(dataMember0, "us", "uint16", 2, 2, 1);
6348 __ecereNameSpace__ecere__com__eMember_AddDataMember(dataMember0, "i", "int", 4, 4, 1);
6349 __ecereNameSpace__ecere__com__eMember_AddDataMember(dataMember0, "ui", "uint", 4, 4, 1);
6350 __ecereNameSpace__ecere__com__eMember_AddDataMember(dataMember0, "p", "void *", arch_PointerSize, arch_PointerSize, 1);
6351 __ecereNameSpace__ecere__com__eMember_AddDataMember(dataMember0, "f", "float", 4, 4, 1);
6352 __ecereNameSpace__ecere__com__eMember_AddDataMember(dataMember0, "d", "double", 8, 8, 1);
6353 __ecereNameSpace__ecere__com__eMember_AddDataMember(dataMember0, "i64", "int64", 8, 8, 1);
6354 __ecereNameSpace__ecere__com__eMember_AddDataMember(dataMember0, "ui64", "uint64", 8, 8, 1);
6355 __ecereNameSpace__ecere__com__eClass_AddMember(class, dataMember0);
6356 }
6357 class = __ecereNameSpace__ecere__com__eSystem_RegisterClass(5, "ecere::com::DataMember", 0, sizeof(struct __ecereNameSpace__ecere__com__DataMember), 0, 0, 0, module, 4, 1);
6358 if(((struct __ecereNameSpace__ecere__com__Module *)(((char *)module + structSize_Instance)))->application == ((struct __ecereNameSpace__ecere__com__Module *)(((char *)__thisModule + structSize_Instance)))->application && class)
6359 __ecereClass___ecereNameSpace__ecere__com__DataMember = class;
6360 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "prev", "ecere::com::DataMember", arch_PointerSize, arch_PointerSize, 1);
6361 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "next", "ecere::com::DataMember", arch_PointerSize, arch_PointerSize, 1);
6362 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "name", "char *", arch_PointerSize, arch_PointerSize, 1);
6363 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "isProperty", "bool", 4, 4, 1);
6364 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "memberAccess", "ecere::com::AccessMode", 4, 4, 1);
6365 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "id", "int", 4, 4, 1);
6366 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "_class", "ecere::com::Class", arch_PointerSize, arch_PointerSize, 1);
6367 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "dataTypeString", "char *", arch_PointerSize, arch_PointerSize, 1);
6368 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "dataTypeClass", "ecere::com::Class", arch_PointerSize, arch_PointerSize, 1);
6369 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "dataType", "Type", arch_PointerSize, arch_PointerSize, 1);
6370 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "type", "ecere::com::DataMemberType", 4, 4, 1);
6371 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "offset", "int", 4, 4, 1);
6372 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "memberID", "int", 4, 4, 1);
6373 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "members", "ecere::sys::OldList", structSize_OldList, arch_PointerSize, 1);
6374 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "membersAlpha", "ecere::sys::BinaryTree", structSize_BinaryTree, arch_PointerSize, 1);
6375 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "memberOffset", "int", 4, 4, 1);
6376 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "structAlignment", "int", 4, 4, 1);
6377 if(class)
6378 class->fixed = (unsigned int)1;
6379 class = __ecereNameSpace__ecere__com__eSystem_RegisterClass(5, "ecere::com::BitMember", 0, sizeof(struct __ecereNameSpace__ecere__com__BitMember), 0, 0, 0, module, 4, 1);
6380 if(((struct __ecereNameSpace__ecere__com__Module *)(((char *)module + structSize_Instance)))->application == ((struct __ecereNameSpace__ecere__com__Module *)(((char *)__thisModule + structSize_Instance)))->application && class)
6381 __ecereClass___ecereNameSpace__ecere__com__BitMember = class;
6382 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "prev", "ecere::com::BitMember", arch_PointerSize, arch_PointerSize, 1);
6383 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "next", "ecere::com::BitMember", arch_PointerSize, arch_PointerSize, 1);
6384 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "name", "char *", arch_PointerSize, arch_PointerSize, 1);
6385 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "isProperty", "bool", 4, 4, 1);
6386 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "memberAccess", "ecere::com::AccessMode", 4, 4, 1);
6387 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "id", "int", 4, 4, 1);
6388 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "_class", "ecere::com::Class", arch_PointerSize, arch_PointerSize, 1);
6389 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "dataTypeString", "char *", arch_PointerSize, arch_PointerSize, 1);
6390 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "dataTypeClass", "ecere::com::Class", arch_PointerSize, arch_PointerSize, 1);
6391 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "dataType", "Type", arch_PointerSize, arch_PointerSize, 1);
6392 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "type", "ecere::com::DataMemberType", 4, 4, 1);
6393 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "size", "int", 4, 4, 1);
6394 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "pos", "int", 4, 4, 1);
6395 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "mask", "uint64", 8, 8, 1);
6396 if(class)
6397 class->fixed = (unsigned int)1;
6398 class = __ecereNameSpace__ecere__com__eSystem_RegisterClass(5, "ecere::com::ClassProperty", 0, sizeof(struct __ecereNameSpace__ecere__com__ClassProperty), 0, 0, 0, module, 4, 1);
6399 if(((struct __ecereNameSpace__ecere__com__Module *)(((char *)module + structSize_Instance)))->application == ((struct __ecereNameSpace__ecere__com__Module *)(((char *)__thisModule + structSize_Instance)))->application && class)
6400 __ecereClass___ecereNameSpace__ecere__com__ClassProperty = class;
6401 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "name", "char *", arch_PointerSize, arch_PointerSize, 1);
6402 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "parent", "ecere::com::ClassProperty", arch_PointerSize, arch_PointerSize, 1);
6403 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "left", "ecere::com::ClassProperty", arch_PointerSize, arch_PointerSize, 1);
6404 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "right", "ecere::com::ClassProperty", arch_PointerSize, arch_PointerSize, 1);
6405 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "depth", "int", 4, 4, 1);
6406 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "Set", "void( *)(ecere::com::Class, int64)", arch_PointerSize, arch_PointerSize, 1);
6407 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "Get", "int64( *)(ecere::com::Class)", arch_PointerSize, arch_PointerSize, 1);
6408 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "dataTypeString", "char *", arch_PointerSize, arch_PointerSize, 1);
6409 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "dataType", "Type", arch_PointerSize, arch_PointerSize, 1);
6410 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "constant", "bool", 4, 4, 1);
6411 if(class)
6412 class->fixed = (unsigned int)1;
6413 class = __ecereNameSpace__ecere__com__eSystem_RegisterClass(5, "ecere::com::DefinedExpression", 0, sizeof(struct __ecereNameSpace__ecere__com__DefinedExpression), 0, 0, 0, module, 4, 1);
6414 if(((struct __ecereNameSpace__ecere__com__Module *)(((char *)module + structSize_Instance)))->application == ((struct __ecereNameSpace__ecere__com__Module *)(((char *)__thisModule + structSize_Instance)))->application && class)
6415 __ecereClass___ecereNameSpace__ecere__com__DefinedExpression = class;
6416 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "prev", "ecere::com::DefinedExpression", arch_PointerSize, arch_PointerSize, 1);
6417 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "next", "ecere::com::DefinedExpression", arch_PointerSize, arch_PointerSize, 1);
6418 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "name", "char *", arch_PointerSize, arch_PointerSize, 1);
6419 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "value", "char *", arch_PointerSize, arch_PointerSize, 1);
6420 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "nameSpace", "ecere::com::NameSpace *", arch_PointerSize, arch_PointerSize, 1);
6421 if(class)
6422 class->fixed = (unsigned int)1;
6423 class = __ecereNameSpace__ecere__com__eSystem_RegisterClass(5, "ecere::com::GlobalFunction", 0, sizeof(struct __ecereNameSpace__ecere__com__GlobalFunction), 0, 0, 0, module, 4, 1);
6424 if(((struct __ecereNameSpace__ecere__com__Module *)(((char *)module + structSize_Instance)))->application == ((struct __ecereNameSpace__ecere__com__Module *)(((char *)__thisModule + structSize_Instance)))->application && class)
6425 __ecereClass___ecereNameSpace__ecere__com__GlobalFunction = class;
6426 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "prev", "ecere::com::GlobalFunction", arch_PointerSize, arch_PointerSize, 1);
6427 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "next", "ecere::com::GlobalFunction", arch_PointerSize, arch_PointerSize, 1);
6428 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "name", "char *", arch_PointerSize, arch_PointerSize, 1);
6429 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "function", "int( *)()", arch_PointerSize, arch_PointerSize, 1);
6430 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "module", "ecere::com::Module", arch_PointerSize, arch_PointerSize, 1);
6431 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "nameSpace", "ecere::com::NameSpace *", arch_PointerSize, arch_PointerSize, 1);
6432 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "dataTypeString", "char *", arch_PointerSize, arch_PointerSize, 1);
6433 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "dataType", "Type", arch_PointerSize, arch_PointerSize, 1);
6434 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "symbol", "void *", arch_PointerSize, arch_PointerSize, 1);
6435 if(class)
6436 class->fixed = (unsigned int)1;
6437 class = __ecereNameSpace__ecere__com__eSystem_RegisterClass(5, "ecere::com::EnumClassData", 0, sizeof(struct __ecereNameSpace__ecere__com__EnumClassData), 0, 0, 0, module, 4, 1);
6438 if(((struct __ecereNameSpace__ecere__com__Module *)(((char *)module + structSize_Instance)))->application == ((struct __ecereNameSpace__ecere__com__Module *)(((char *)__thisModule + structSize_Instance)))->application && class)
6439 __ecereClass___ecereNameSpace__ecere__com__EnumClassData = class;
6440 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "values", "ecere::sys::OldList", structSize_OldList, arch_PointerSize, 1);
6441 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "largest", "int", 4, 4, 1);
6442 if(class)
6443 class->fixed = (unsigned int)1;
6444 class = __ecereNameSpace__ecere__com__eSystem_RegisterClass(5, "ecere::com::Watcher", 0, sizeof(struct __ecereNameSpace__ecere__com__Watcher), 0, 0, 0, module, 2, 1);
6445 if(((struct __ecereNameSpace__ecere__com__Module *)(((char *)module + structSize_Instance)))->application == ((struct __ecereNameSpace__ecere__com__Module *)(((char *)__thisModule + structSize_Instance)))->application && class)
6446 __ecereClass___ecereNameSpace__ecere__com__Watcher = class;
6447 if(class)
6448 class->fixed = (unsigned int)1;
6449 class = __ecereNameSpace__ecere__com__eSystem_RegisterClass(5, "ecere::com::MemBlock", 0, sizeof(struct __ecereNameSpace__ecere__com__MemBlock), 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__MemBlock = class;
6452 class = __ecereNameSpace__ecere__com__eSystem_RegisterClass(5, "ecere::com::MemPart", 0, sizeof(struct __ecereNameSpace__ecere__com__MemPart), 0, 0, 0, module, 2, 1);
6453 if(((struct __ecereNameSpace__ecere__com__Module *)(((char *)module + structSize_Instance)))->application == ((struct __ecereNameSpace__ecere__com__Module *)(((char *)__thisModule + structSize_Instance)))->application && class)
6454 __ecereClass___ecereNameSpace__ecere__com__MemPart = class;
6455 class = __ecereNameSpace__ecere__com__eSystem_RegisterClass(1, "ecere::com::BlockPool", 0, sizeof(struct __ecereNameSpace__ecere__com__BlockPool), 0, 0, 0, module, 2, 1);
6456 if(((struct __ecereNameSpace__ecere__com__Module *)(((char *)module + structSize_Instance)))->application == ((struct __ecereNameSpace__ecere__com__Module *)(((char *)__thisModule + structSize_Instance)))->application && class)
6457 __ecereClass___ecereNameSpace__ecere__com__BlockPool = class;
6458 __ecereNameSpace__ecere__com__eClass_AddMethod(class, "Add", "ecere::com::MemBlock Add()", __ecereMethod___ecereNameSpace__ecere__com__BlockPool_Add, 1);
6459 __ecereNameSpace__ecere__com__eClass_AddMethod(class, "Expand", "bool Expand(unsigned int numBlocks)", __ecereMethod___ecereNameSpace__ecere__com__BlockPool_Expand, 1);
6460 __ecereNameSpace__ecere__com__eClass_AddMethod(class, "Remove", "void Remove(ecere::com::MemBlock block)", __ecereMethod___ecereNameSpace__ecere__com__BlockPool_Remove, 1);
6461 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "first", "ecere::com::MemBlock", arch_PointerSize, arch_PointerSize, 1);
6462 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "last", "ecere::com::MemBlock", arch_PointerSize, arch_PointerSize, 1);
6463 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "free", "ecere::com::MemBlock", arch_PointerSize, arch_PointerSize, 1);
6464 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "blockSize", "uint", 4, 4, 1);
6465 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "blockSpace", "uint", 4, 4, 1);
6466 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "numParts", "int", 4, 4, 1);
6467 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "numBlocks", "int", 4, 4, 1);
6468 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "totalSize", "uint", 4, 4, 1);
6469 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "usedSpace", "uint", 4, 4, 1);
6470 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("ecere::com::log2i", "uint ecere::com::log2i(uint number)", __ecereNameSpace__ecere__com__log2i, module, 4);
6471 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("ecere::com::pow2i", "uint ecere::com::pow2i(uint number)", __ecereNameSpace__ecere__com__pow2i, module, 4);
6472 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("ecere::com::memswap", "void ecere::com::memswap(byte * a, byte * b, uint size)", __ecereNameSpace__ecere__com__memswap, module, 4);
6473 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("ecere::com::CheckMemory", "void ecere::com::CheckMemory(void)", __ecereNameSpace__ecere__com__CheckMemory, module, 4);
6474 __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( *)(void *), void( *)(void *), ecere::com::Module module, ecere::com::AccessMode declMode, ecere::com::AccessMode inheritanceAccess)", __ecereNameSpace__ecere__com__eSystem_RegisterClass, module, 4);
6475 __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);
6476 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("ecere::com::_strtoi64", "int64 ecere::com::_strtoi64(char * string, char * * endString, int base)", __ecereNameSpace__ecere__com___strtoi64, module, 4);
6477 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("ecere::com::_strtoui64", "uint64 ecere::com::_strtoui64(char * string, char * * endString, int base)", __ecereNameSpace__ecere__com___strtoui64, module, 4);
6478 __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);
6479 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("ecere::com::DefaultFunction", "bool ecere::com::DefaultFunction(void)", __ecereNameSpace__ecere__com__DefaultFunction, module, 2);
6480 __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);
6481 __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);
6482 __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);
6483 __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);
6484 __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);
6485 __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);
6486 __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);
6487 __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);
6488 __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);
6489 __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);
6490 __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);
6491 __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);
6492 __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);
6493 __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);
6494 __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);
6495 __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);
6496 __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);
6497 __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);
6498 __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);
6499 __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);
6500 __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);
6501 __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);
6502 __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);
6503 __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);
6504 __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);
6505 __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);
6506 __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);
6507 __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);
6508 __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);
6509 __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);
6510 __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( *)(ecere::com::Module module), bool( *)(ecere::com::Module module))", __ecereNameSpace__ecere__com__eModule_LoadStatic, module, 4);
6511 __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);
6512 __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);
6513 __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);
6514 __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);
6515 __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);
6516 __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);
6517 __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);
6518 __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);
6519 __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);
6520 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("ecere::com::eSystem_New", "void * ecere::com::eSystem_New(uint size)", __ecereNameSpace__ecere__com__eSystem_New, module, 4);
6521 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("ecere::com::eSystem_New0", "void * ecere::com::eSystem_New0(uint size)", __ecereNameSpace__ecere__com__eSystem_New0, module, 4);
6522 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("ecere::com::eSystem_Delete", "void ecere::com::eSystem_Delete(void * memory)", __ecereNameSpace__ecere__com__eSystem_Delete, module, 4);
6523 __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);
6524 __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);
6525 __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);
6526 __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);
6527 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("ecere::com::eProperty_SelfWatch", "void ecere::com::eProperty_SelfWatch(ecere::com::Class _class, char * name, void( *)(void *))", __ecereNameSpace__ecere__com__eProperty_SelfWatch, module, 4);
6528 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("ecere::com::eInstance_Watch", "void ecere::com::eInstance_Watch(void * instance, ecere::com::Property _property, void * object, void( *)(void *, void *))", __ecereNameSpace__ecere__com__eInstance_Watch, module, 4);
6529 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("ecere::com::eInstance_WatchDestruction", "void ecere::com::eInstance_WatchDestruction(ecere::com::Instance instance, ecere::com::Instance object, void( *)(ecere::com::Instance, ecere::com::Instance))", __ecereNameSpace__ecere__com__eInstance_WatchDestruction, module, 4);
6530 __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);
6531 __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);
6532 __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);
6533 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("ecere::com::LocateModule", "bool ecere::com::LocateModule(char * name, char * fileName)", __ecereNameSpace__ecere__com__LocateModule, module, 4);
6534 __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);
6535 __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);
6536 __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);
6537 class = __ecereNameSpace__ecere__com__eSystem_RegisterClass(4, "ecere::com::Platform", 0, 0, 0, 0, 0, module, 4, 1);
6538 if(((struct __ecereNameSpace__ecere__com__Module *)(((char *)module + structSize_Instance)))->application == ((struct __ecereNameSpace__ecere__com__Module *)(((char *)__thisModule + structSize_Instance)))->application && class)
6539 __ecereClass___ecereNameSpace__ecere__com__Platform = class;
6540 __ecereNameSpace__ecere__com__eClass_AddMethod(class, "OnGetString", 0, __ecereMethod___ecereNameSpace__ecere__com__Platform_OnGetString, 1);
6541 __ecereNameSpace__ecere__com__eClass_AddMethod(class, "OnGetDataFromString", 0, __ecereMethod___ecereNameSpace__ecere__com__Platform_OnGetDataFromString, 1);
6542 __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);
6543 __ecereNameSpace__ecere__com__eEnum_AddFixedValue(class, "unknown", 0);
6544 __ecereNameSpace__ecere__com__eEnum_AddFixedValue(class, "win32", 1);
6545 __ecereNameSpace__ecere__com__eEnum_AddFixedValue(class, "tux", 2);
6546 __ecereNameSpace__ecere__com__eEnum_AddFixedValue(class, "apple", 3);
6547 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("ecere::com::GetRuntimePlatform", "ecere::com::Platform ecere::com::GetRuntimePlatform(void)", __ecereNameSpace__ecere__com__GetRuntimePlatform, module, 4);
6548 class = __ecereNameSpace__ecere__com__eSystem_RegisterClass(5, "ecere::com::ObjectInfo", 0, sizeof(struct __ecereNameSpace__ecere__com__ObjectInfo), 0, 0, 0, module, 4, 1);
6549 if(((struct __ecereNameSpace__ecere__com__Module *)(((char *)module + structSize_Instance)))->application == ((struct __ecereNameSpace__ecere__com__Module *)(((char *)__thisModule + structSize_Instance)))->application && class)
6550 __ecereClass___ecereNameSpace__ecere__com__ObjectInfo = class;
6551 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "prev", "ecere::com::ObjectInfo", arch_PointerSize, arch_PointerSize, 1);
6552 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "next", "ecere::com::ObjectInfo", arch_PointerSize, arch_PointerSize, 1);
6553 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "instance", "ecere::com::Instance", arch_PointerSize, arch_PointerSize, 1);
6554 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "name", "char *", arch_PointerSize, arch_PointerSize, 1);
6555 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "instCode", "Instantiation", arch_PointerSize, arch_PointerSize, 1);
6556 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "deleted", "bool", 4, 4, 1);
6557 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "oClass", "ecere::com::ObjectInfo", arch_PointerSize, arch_PointerSize, 1);
6558 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "instances", "ecere::sys::OldList", structSize_OldList, arch_PointerSize, 1);
6559 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "classDefinition", "ClassDefinition", arch_PointerSize, arch_PointerSize, 1);
6560 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "modified", "bool", 4, 4, 1);
6561 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);
6562 if(((struct __ecereNameSpace__ecere__com__Module *)(((char *)module + structSize_Instance)))->application == ((struct __ecereNameSpace__ecere__com__Module *)(((char *)__thisModule + structSize_Instance)))->application && class)
6563 __ecereClass___ecereNameSpace__ecere__com__DesignerBase = class;
6564 __ecereNameSpace__ecere__com__eClass_AddVirtualMethod(class, "FindObject", "bool FindObject(ecere::com::Instance * instance, char * string)", 0, 1);
6565 __ecereNameSpace__ecere__com__eClass_AddVirtualMethod(class, "RenameObject", "void RenameObject(ecere::com::ObjectInfo object, char * name)", 0, 1);
6566 __ecereNameSpace__ecere__com__eClass_AddVirtualMethod(class, "SelectObjectFromDesigner", "void SelectObjectFromDesigner(ecere::com::ObjectInfo object)", 0, 1);
6567 __ecereNameSpace__ecere__com__eClass_AddVirtualMethod(class, "CodeAddObject", "void CodeAddObject(ecere::com::Instance instance, ecere::com::ObjectInfo * object)", 0, 1);
6568 __ecereNameSpace__ecere__com__eClass_AddVirtualMethod(class, "SheetAddObject", "void SheetAddObject(ecere::com::ObjectInfo object)", 0, 1);
6569 __ecereNameSpace__ecere__com__eClass_AddVirtualMethod(class, "AddToolBoxClass", "void AddToolBoxClass(ecere::com::Class _class)", 0, 1);
6570 __ecereNameSpace__ecere__com__eClass_AddVirtualMethod(class, "AddDefaultMethod", "void AddDefaultMethod(ecere::com::Instance instance, ecere::com::Instance classInstance)", 0, 1);
6571 __ecereNameSpace__ecere__com__eClass_AddVirtualMethod(class, "DeleteObject", "void DeleteObject(ecere::com::ObjectInfo object)", 0, 1);
6572 __ecereNameSpace__ecere__com__eClass_AddVirtualMethod(class, "ObjectContainsCode", "bool ObjectContainsCode(ecere::com::ObjectInfo object)", 0, 1);
6573 __ecereNameSpace__ecere__com__eClass_AddVirtualMethod(class, "ModifyCode", "void ModifyCode(void)", 0, 1);
6574 __ecereNameSpace__ecere__com__eClass_AddVirtualMethod(class, "UpdateProperties", "void UpdateProperties(void)", 0, 1);
6575 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "classDesigner", "ecere::com::ClassDesignerBase", arch_PointerSize, arch_PointerSize, 1);
6576 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "objectClass", "char *", arch_PointerSize, arch_PointerSize, 1);
6577 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "isDragging", "bool", 4, 4, 1);
6578 __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);
6579 if(((struct __ecereNameSpace__ecere__com__Module *)(((char *)module + structSize_Instance)))->application == ((struct __ecereNameSpace__ecere__com__Module *)(((char *)__thisModule + structSize_Instance)))->application)
6580 __ecereProp___ecereNameSpace__ecere__com__DesignerBase_classDesigner = __ecerePropM___ecereNameSpace__ecere__com__DesignerBase_classDesigner, __ecerePropM___ecereNameSpace__ecere__com__DesignerBase_classDesigner = (void *)0;
6581 __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);
6582 if(((struct __ecereNameSpace__ecere__com__Module *)(((char *)module + structSize_Instance)))->application == ((struct __ecereNameSpace__ecere__com__Module *)(((char *)__thisModule + structSize_Instance)))->application)
6583 __ecereProp___ecereNameSpace__ecere__com__DesignerBase_objectClass = __ecerePropM___ecereNameSpace__ecere__com__DesignerBase_objectClass, __ecerePropM___ecereNameSpace__ecere__com__DesignerBase_objectClass = (void *)0;
6584 __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);
6585 if(((struct __ecereNameSpace__ecere__com__Module *)(((char *)module + structSize_Instance)))->application == ((struct __ecereNameSpace__ecere__com__Module *)(((char *)__thisModule + structSize_Instance)))->application)
6586 __ecereProp___ecereNameSpace__ecere__com__DesignerBase_isDragging = __ecerePropM___ecereNameSpace__ecere__com__DesignerBase_isDragging, __ecerePropM___ecereNameSpace__ecere__com__DesignerBase_isDragging = (void *)0;
6587 class = __ecereNameSpace__ecere__com__eSystem_RegisterClass(0, "ecere::com::ClassDesignerBase", "ecere::gui::Window", 0, 0, 0, 0, module, 4, 1);
6588 if(((struct __ecereNameSpace__ecere__com__Module *)(((char *)module + structSize_Instance)))->application == ((struct __ecereNameSpace__ecere__com__Module *)(((char *)__thisModule + structSize_Instance)))->application && class)
6589 __ecereClass___ecereNameSpace__ecere__com__ClassDesignerBase = class;
6590 __ecereNameSpace__ecere__com__eClass_AddVirtualMethod(class, "Reset", "void Reset(void)", 0, 1);
6591 __ecereNameSpace__ecere__com__eClass_AddVirtualMethod(class, "AddObject", "void AddObject(void)", 0, 1);
6592 __ecereNameSpace__ecere__com__eClass_AddVirtualMethod(class, "SelectObject", "void SelectObject(ecere::com::ObjectInfo object, ecere::com::Instance control)", 0, 1);
6593 __ecereNameSpace__ecere__com__eClass_AddVirtualMethod(class, "ListToolBoxClasses", "void ListToolBoxClasses(ecere::com::DesignerBase designer)", 0, 1);
6594 __ecereNameSpace__ecere__com__eClass_AddVirtualMethod(class, "PrepareTestObject", "void ::PrepareTestObject(ecere::com::DesignerBase designer, ecere::com::Instance test)", 0, 1);
6595 __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);
6596 __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);
6597 __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);
6598 __ecereNameSpace__ecere__com__eClass_AddVirtualMethod(class, "DestroyObject", "void ::DestroyObject(ecere::com::Instance object)", 0, 1);
6599 __ecereNameSpace__ecere__com__eClass_AddVirtualMethod(class, "FixProperty", "void ::FixProperty(ecere::com::Property prop, ecere::com::Instance object)", 0, 1);
6600 __ecereNameSpace__ecere__com__eClass_AddVirtualMethod(class, "CreateNew", "void ::CreateNew(EditBox editBox, Size clientSize, char * name, char * inherit)", 0, 1);
6601 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("ecere::com::SetActiveDesigner", "void ecere::com::SetActiveDesigner(ecere::com::DesignerBase designer)", __ecereNameSpace__ecere__com__SetActiveDesigner, module, 4);
6602 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("ecere::com::GetActiveDesigner", "ecere::com::DesignerBase ecere::com::GetActiveDesigner(void)", __ecereNameSpace__ecere__com__GetActiveDesigner, module, 4);
6603 __ecereNameSpace__ecere__com__eSystem_RegisterDefine("ecere::sys::LEAD_OFFSET", "0xD800 - (0x10000 >> 10)", module, 2);
6604 __ecereNameSpace__ecere__com__eSystem_RegisterDefine("ecere::sys::SURROGATE_OFFSET", "0x10000 - (0xD800 << 10) - 0xDC00", module, 2);
6605 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("ecere::sys::UTF8Validate", "bool ecere::sys::UTF8Validate(char * source)", __ecereNameSpace__ecere__sys__UTF8Validate, module, 4);
6606 __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);
6607 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("ecere::sys::UTF16toUTF8", "char * ecere::sys::UTF16toUTF8(uint16 * source)", __ecereNameSpace__ecere__sys__UTF16toUTF8, module, 4);
6608 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("ecere::sys::UTF16toUTF8Buffer", "int ecere::sys::UTF16toUTF8Buffer(uint16 * source, byte * dest, int max)", __ecereNameSpace__ecere__sys__UTF16toUTF8Buffer, module, 4);
6609 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("ecere::sys::UTF8GetChar", "ecere::com::unichar ecere::sys::UTF8GetChar(char * string, int * numBytes)", __ecereNameSpace__ecere__sys__UTF8GetChar, module, 4);
6610 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("ecere::sys::UTF8toUTF16Buffer", "int ecere::sys::UTF8toUTF16Buffer(char * source, uint16 * dest, int max)", __ecereNameSpace__ecere__sys__UTF8toUTF16Buffer, module, 4);
6611 __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);
6612 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("ecere::sys::UTF8toUTF16", "uint16 * ecere::sys::UTF8toUTF16(char * source, int * wordCount)", __ecereNameSpace__ecere__sys__UTF8toUTF16, module, 4);
6613 }
6614
6615 void __ecereUnregisterModule_instance(struct __ecereNameSpace__ecere__com__Instance * module)
6616 {
6617
6618 __ecerePropM___ecereNameSpace__ecere__com__DesignerBase_classDesigner = (void *)0;
6619 __ecerePropM___ecereNameSpace__ecere__com__DesignerBase_objectClass = (void *)0;
6620 __ecerePropM___ecereNameSpace__ecere__com__DesignerBase_isDragging = (void *)0;
6621 }
6622