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