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

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