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

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