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

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