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