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