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

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