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

   1 /* Code generated from eC source file: dataTypes.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 #   else
  42 #      define ecere_stdcall __stdcall
  43 #   endif
  44 #else
  45 #   define ecere_stdcall
  46 #endif
  47 #include <stdint.h>
  48 #include <sys/types.h>
  49 extern int runtimePlatform;
  50
  51
  52
  53
  54
  55
  56
  57
  58
  59
  60
  61
  62
  63
  64
  65
  66
  67
  68 typedef __builtin_va_list va_list;
  69
  70 void exit(int status);
  71
  72 void * calloc(size_t nmemb, size_t size);
  73
  74 void free(void * ptr);
  75
  76 void * malloc(size_t size);
  77
  78 void * realloc(void * ptr, size_t size);
  79
  80 long int strtol(const char * nptr, char ** endptr, int base);
  81
  82 long long int strtoll(const char * nptr, char ** endptr, int base);
  83
  84 unsigned long long int strtoull(const char * nptr, char ** endptr, int base);
  85
  86 typedef void FILE;
  87
  88 FILE * bsl_stdin(void);
  89
  90 FILE * bsl_stdout(void);
  91
  92 FILE * bsl_stderr(void);
  93
  94 char * fgets(char * s, int size, FILE * stream);
  95
  96 FILE * fopen(const char * path, const char * mode);
  97
  98 int fclose(FILE * fp);
  99
 100 int fflush(FILE * stream);
 101
 102 int fgetc(FILE * stream);
 103
 104 int fprintf(FILE * stream, const char * format, ...);
 105
 106 int fputc(int c, FILE * stream);
 107
 108 size_t fread(void * ptr, size_t size, size_t nmemb, FILE * stream);
 109
 110 size_t fwrite(const void * ptr, size_t size, size_t nmemb, FILE * stream);
 111
 112 int vsnprintf(char *, size_t, const char *, va_list args);
 113
 114 int snprintf(char * str, size_t, const char * format, ...);
 115
 116 int fseek(FILE * stream, long offset, int whence);
 117
 118 long ftell(FILE * stream);
 119
 120 int feof(FILE * stream);
 121
 122 int ferror(FILE * stream);
 123
 124 int fileno(FILE * stream);
 125
 126 FILE * eC_stdout(void);
 127
 128 FILE * eC_stderr(void);
 129
 130 unsigned int Float_isNan(float n);
 131
 132 unsigned int Float_isInf(float n);
 133
 134 int Float_signBit(float n);
 135
 136 float Float_nan(void);
 137
 138 float Float_inf(void);
 139
 140 unsigned int Double_isNan(double n);
 141
 142 unsigned int Double_isInf(double n);
 143
 144 int Double_signBit(double n);
 145
 146 double Double_nan(void);
 147
 148 double Double_inf(void);
 149
 150 extern int __ecereVMethodID_class_OnGetString;
 151
 152 extern int __ecereVMethodID_class_OnGetDataFromString;
 153
 154 extern int __ecereVMethodID_class_OnCompare;
 155
 156 extern int __ecereVMethodID_class_OnSerialize;
 157
 158 extern int __ecereVMethodID_class_OnUnserialize;
 159
 160 extern int __ecereVMethodID_class_OnCopy;
 161
 162 struct __ecereNameSpace__ecere__com__SerialBuffer
 163 {
 164 unsigned char * _buffer;
 165 unsigned int count;
 166 unsigned int _size;
 167 unsigned int pos;
 168 } __attribute__ ((gcc_struct));
 169
 170 extern struct __ecereNameSpace__ecere__com__Property * __ecereProp_float_isInf;
 171
 172 extern struct __ecereNameSpace__ecere__com__Property * __ecereProp_float_signBit;
 173
 174 extern struct __ecereNameSpace__ecere__com__Property * __ecereProp_float_isNan;
 175
 176 extern struct __ecereNameSpace__ecere__com__Property * __ecereProp_double_isInf;
 177
 178 extern struct __ecereNameSpace__ecere__com__Property * __ecereProp_double_signBit;
 179
 180 extern struct __ecereNameSpace__ecere__com__Property * __ecereProp_double_isNan;
 181
 182 struct __ecereNameSpace__ecere__com__StaticString
 183 {
 184 char string[1];
 185 } __attribute__ ((gcc_struct));
 186
 187 struct __ecereNameSpace__ecere__sys__BTNode;
 188
 189 struct __ecereNameSpace__ecere__sys__OldList
 190 {
 191 void *  first;
 192 void *  last;
 193 int count;
 194 unsigned int offset;
 195 unsigned int circ;
 196 } __attribute__ ((gcc_struct));
 197
 198 struct __ecereNameSpace__ecere__com__DataValue
 199 {
 200 union
 201 {
 202 char c;
 203 unsigned char uc;
 204 short s;
 205 unsigned short us;
 206 int i;
 207 unsigned int ui;
 208 void *  p;
 209 float f;
 210 double d;
 211 long long i64;
 212 uint64 ui64;
 213 } __attribute__ ((gcc_struct)) __anon1;
 214 } __attribute__ ((gcc_struct));
 215
 216 extern void *  __ecereNameSpace__ecere__com__eSystem_New(unsigned int size);
 217
 218 extern void *  __ecereNameSpace__ecere__com__eSystem_New0(unsigned int size);
 219
 220 extern void *  __ecereNameSpace__ecere__com__eSystem_Renew(void *  memory, unsigned int size);
 221
 222 extern void *  __ecereNameSpace__ecere__com__eSystem_Renew0(void *  memory, unsigned int size);
 223
 224 extern void __ecereNameSpace__ecere__com__eSystem_Delete(void *  memory);
 225
 226 extern void *  memcpy(void * , const void * , size_t size);
 227
 228 extern int strcmp(const char * , const char * );
 229
 230 extern char *  strcpy(char * , const char * );
 231
 232 extern int toupper(int);
 233
 234 extern int strcasecmp(const char * , const char * );
 235
 236 extern char *  strchr(const char * , int);
 237
 238 extern char *  strcat(char * , const char * );
 239
 240 extern size_t strlen(const char * );
 241
 242 extern void *  memset(void *  area, int value, size_t count);
 243
 244 extern char *  __ecereNameSpace__ecere__sys__TrimRSpaces(const char *  string, char *  output);
 245
 246 extern int sprintf(char * , const char * , ...);
 247
 248 extern unsigned long strtoul(const char *  nptr, char * *  endptr, int base);
 249
 250 extern long long __ecereNameSpace__ecere__com___strtoi64(const char *  string, const char * *  endString, int base);
 251
 252 extern uint64 __ecereNameSpace__ecere__com___strtoui64(const char *  string, const char * *  endString, int base);
 253
 254 extern char *  __ecereNameSpace__ecere__sys__CopyString(const char *  string);
 255
 256 extern double strtod(const char * , char * * );
 257
 258 extern unsigned int __ecereNameSpace__ecere__sys__UTF8Validate(const char *  source);
 259
 260 extern int __ecereNameSpace__ecere__sys__ISO8859_1toUTF8(const char *  source, char *  dest, int max);
 261
 262 extern int puts(const char * );
 263
 264 extern int fputs(const char * , void *  stream);
 265
 266 struct __ecereNameSpace__ecere__com__DefinedExpression;
 267
 268 struct __ecereNameSpace__ecere__com__GlobalFunction;
 269
 270 int __ecereVMethodID_class_OnGetString;
 271
 272 int __ecereVMethodID_class_OnFree;
 273
 274 int __ecereVMethodID_class_OnCopy;
 275
 276 int __ecereVMethodID_class_OnCompare;
 277
 278 int __ecereVMethodID_class_OnGetDataFromString;
 279
 280 extern unsigned int (* __ecereProp_float_Get_isInf)(float this);
 281
 282 extern int (* __ecereProp_float_Get_signBit)(float this);
 283
 284 extern unsigned int (* __ecereProp_float_Get_isNan)(float this);
 285
 286 extern unsigned int (* __ecereProp_double_Get_isInf)(double this);
 287
 288 extern int (* __ecereProp_double_Get_signBit)(double this);
 289
 290 extern unsigned int (* __ecereProp_double_Get_isNan)(double this);
 291
 292 struct __ecereNameSpace__ecere__com__EnumClassData
 293 {
 294 struct __ecereNameSpace__ecere__sys__OldList values;
 295 long long largest;
 296 } __attribute__ ((gcc_struct));
 297
 298 struct __ecereNameSpace__ecere__com__Property;
 299
 300 extern void __ecereNameSpace__ecere__com__eInstance_Watch(void *  instance, struct __ecereNameSpace__ecere__com__Property * _property, void *  object, void (*  callback)(void * , void * ));
 301
 302 static __attribute__((unused)) struct __ecereNameSpace__ecere__com__Property * __ecereProp___ecereNameSpace__ecere__com__SerialBuffer_buffer, * __ecerePropM___ecereNameSpace__ecere__com__SerialBuffer_buffer;
 303
 304 static __attribute__((unused)) struct __ecereNameSpace__ecere__com__Property * __ecereProp___ecereNameSpace__ecere__com__SerialBuffer_size, * __ecerePropM___ecereNameSpace__ecere__com__SerialBuffer_size;
 305
 306 struct __ecereNameSpace__ecere__com__Class;
 307
 308 struct __ecereNameSpace__ecere__com__Instance
 309 {
 310 void * *  _vTbl;
 311 struct __ecereNameSpace__ecere__com__Class * _class;
 312 int _refCount;
 313 } __attribute__ ((gcc_struct));
 314
 315 extern long long __ecereNameSpace__ecere__com__eClass_GetProperty(struct __ecereNameSpace__ecere__com__Class * _class, const char *  name);
 316
 317 extern void __ecereNameSpace__ecere__com__eClass_SetProperty(struct __ecereNameSpace__ecere__com__Class * _class, const char *  name, long long value);
 318
 319 extern void *  __ecereNameSpace__ecere__com__eInstance_New(struct __ecereNameSpace__ecere__com__Class * _class);
 320
 321 static int __ecereNameSpace__ecere__com__Integer_OnCompare(struct __ecereNameSpace__ecere__com__Class * _class, int * data1, int * data2)
 322 {
 323 int result = 0;
 324
 325 if(!data1 && !data2)
 326 result = 0;
 327 else if(data1 && !data2)
 328 result = 1;
 329 else if(!data1 && data2)
 330 result = -1;
 331 else if(*data1 > *data2)
 332 result = 1;
 333 else if(*data1 < *data2)
 334 result = -1;
 335 return result;
 336 }
 337
 338 const char * __ecereNameSpace__ecere__com__Integer_OnGetString(struct __ecereNameSpace__ecere__com__Class * _class, int * data, char * string, void * fieldData, unsigned int * needClass)
 339 {
 340 sprintf(string, "%d", *data);
 341 return string;
 342 }
 343
 344 static unsigned int __ecereNameSpace__ecere__com__Integer_OnGetDataFromString(struct __ecereNameSpace__ecere__com__Class * _class, int * data, const char * string)
 345 {
 346 char * end;
 347 int result = (int)strtol(string, &end, 0);
 348
 349 if(end > string)
 350 {
 351 *data = result;
 352 return 1;
 353 }
 354 return 0;
 355 }
 356
 357 static const char * __ecereNameSpace__ecere__com__Int16_OnGetString(struct __ecereNameSpace__ecere__com__Class * _class, short * data, char * string, void * fieldData, unsigned int * needClass)
 358 {
 359 sprintf(string, "%d", (int)*data);
 360 return string;
 361 }
 362
 363 static unsigned int __ecereNameSpace__ecere__com__Int16_OnGetDataFromString(struct __ecereNameSpace__ecere__com__Class * _class, short * data, const char * string)
 364 {
 365 char * end;
 366 short result = (short)strtol(string, &end, 0);
 367
 368 if(end > string)
 369 {
 370 *data = result;
 371 return 1;
 372 }
 373 return 0;
 374 }
 375
 376 static int __ecereNameSpace__ecere__com__Int16_OnCompare(struct __ecereNameSpace__ecere__com__Class * _class, short * data1, short * data2)
 377 {
 378 int result = 0;
 379
 380 if(!data1 && !data2)
 381 result = 0;
 382 else if(data1 && !data2)
 383 result = 1;
 384 else if(!data1 && data2)
 385 result = -1;
 386 else if(*data1 > *data2)
 387 result = 1;
 388 else if(*data1 < *data2)
 389 result = -1;
 390 return result;
 391 }
 392
 393 static int __ecereNameSpace__ecere__com__UInteger_OnCompare(struct __ecereNameSpace__ecere__com__Class * _class, unsigned int * data1, unsigned int * data2)
 394 {
 395 int result = 0;
 396
 397 if(!data1 && !data2)
 398 result = 0;
 399 else if(data1 && !data2)
 400 result = 1;
 401 else if(!data1 && data2)
 402 result = -1;
 403 else if(*data1 > *data2)
 404 result = 1;
 405 else if(*data1 < *data2)
 406 result = -1;
 407 return result;
 408 }
 409
 410 static const char * __ecereNameSpace__ecere__com__UInteger_OnGetString(struct __ecereNameSpace__ecere__com__Class * _class, unsigned int * data, char * string, void * fieldData, unsigned int * needClass)
 411 {
 412 sprintf(string, "%u", *data);
 413 return string;
 414 }
 415
 416 static int __ecereNameSpace__ecere__com__UInt16_OnCompare(struct __ecereNameSpace__ecere__com__Class * _class, unsigned short * data1, unsigned int * data2)
 417 {
 418 int result = 0;
 419
 420 if(!data1 && !data2)
 421 result = 0;
 422 else if(data1 && !data2)
 423 result = 1;
 424 else if(!data1 && data2)
 425 result = -1;
 426 else if(*data1 > *data2)
 427 result = 1;
 428 else if(*data1 < *data2)
 429 result = -1;
 430 return result;
 431 }
 432
 433 static const char * __ecereNameSpace__ecere__com__UInt16_OnGetString(struct __ecereNameSpace__ecere__com__Class * _class, unsigned short * data, char * string, void * fieldData, unsigned int * needClass)
 434 {
 435 sprintf(string, "%u", (unsigned int)*data);
 436 return string;
 437 }
 438
 439 static const char * __ecereNameSpace__ecere__com__UIntegerHex_OnGetString(struct __ecereNameSpace__ecere__com__Class * _class, unsigned int * data, char * string, void * fieldData, unsigned int * needClass)
 440 {
 441 sprintf(string, "%x", *data);
 442 return string;
 443 }
 444
 445 static unsigned int __ecereNameSpace__ecere__com__UInteger_OnGetDataFromString(struct __ecereNameSpace__ecere__com__Class * _class, unsigned int * data, const char * string)
 446 {
 447 char * end;
 448 unsigned int result = (unsigned int)strtoul(string, &end, 0);
 449
 450 if(end > string)
 451 {
 452 *data = result;
 453 return 1;
 454 }
 455 return 0;
 456 }
 457
 458 static unsigned int __ecereNameSpace__ecere__com__UInt16_OnGetDataFromString(struct __ecereNameSpace__ecere__com__Class * _class, unsigned short * data, const char * string)
 459 {
 460 char * end;
 461 unsigned short result = (unsigned short)strtoul(string, &end, 0);
 462
 463 if(end > string)
 464 {
 465 *data = result;
 466 return 1;
 467 }
 468 return 0;
 469 }
 470
 471 static int __ecereNameSpace__ecere__com__Byte_OnCompare(struct __ecereNameSpace__ecere__com__Class * _class, unsigned char * data1, unsigned char * data2)
 472 {
 473 int result = 0;
 474
 475 if(!data1 && !data2)
 476 result = 0;
 477 else if(data1 && !data2)
 478 result = 1;
 479 else if(!data1 && data2)
 480 result = -1;
 481 else if(*data1 > *data2)
 482 result = 1;
 483 else if(*data1 < *data2)
 484 result = -1;
 485 return result;
 486 }
 487
 488 static const char * __ecereNameSpace__ecere__com__Byte_OnGetString(struct __ecereNameSpace__ecere__com__Class * _class, unsigned char * data, char * string, void * fieldData, unsigned int * needClass)
 489 {
 490 sprintf(string, "%u", (int)*data);
 491 return string;
 492 }
 493
 494 static const char * __ecereNameSpace__ecere__com__Char_OnGetString(struct __ecereNameSpace__ecere__com__Class * _class, char * data, char * string, void * fieldData, unsigned int * needClass)
 495 {
 496 if(needClass && *needClass)
 497 {
 498 char ch = *data;
 499
 500 if(ch == '\t')
 501 strcpy(string, "'\\t'");
 502 else if(ch == '\n')
 503 strcpy(string, "'\\n'");
 504 else if(ch == '\r')
 505 strcpy(string, "'\\r'");
 506 else if(ch == '\a')
 507 strcpy(string, "'\\a'");
 508 else if(ch == '\\')
 509 strcpy(string, "'\\\\'");
 510 else if(ch < (char)32 || ch >= (char)127)
 511 sprintf(string, "'\\x%x'", ch);
 512 else
 513 sprintf(string, "'%c'", ch);
 514 }
 515 else
 516 sprintf(string, "%c", *data);
 517 return string;
 518 }
 519
 520 static unsigned int __ecereNameSpace__ecere__com__Byte_OnGetDataFromString(struct __ecereNameSpace__ecere__com__Class * _class, unsigned char * data, const char * string)
 521 {
 522 char * end;
 523 unsigned char result = (unsigned char)strtoul(string, &end, 0);
 524
 525 if(end > string)
 526 {
 527 *data = result;
 528 return 1;
 529 }
 530 return 0;
 531 }
 532
 533 static int __ecereNameSpace__ecere__com__Int64_OnCompare(struct __ecereNameSpace__ecere__com__Class * _class, long long * data1, long long * data2)
 534 {
 535 int result = 0;
 536
 537 if(!data1 && !data2)
 538 result = 0;
 539 else if(data1 && !data2)
 540 result = 1;
 541 else if(!data1 && data2)
 542 result = -1;
 543 else if(*data1 > *data2)
 544 result = 1;
 545 else if(*data1 < *data2)
 546 result = -1;
 547 return result;
 548 }
 549
 550 static int __ecereNameSpace__ecere__com__UInt64_OnCompare(struct __ecereNameSpace__ecere__com__Class * _class, uint64 * data1, uint64 * data2)
 551 {
 552 int result = 0;
 553
 554 if(!data1 && !data2)
 555 result = 0;
 556 else if(data1 && !data2)
 557 result = 1;
 558 else if(!data1 && data2)
 559 result = -1;
 560 else if(*data1 > *data2)
 561 result = 1;
 562 else if(*data1 < *data2)
 563 result = -1;
 564 return result;
 565 }
 566
 567 static int __ecereNameSpace__ecere__com__IntPtr64_OnCompare(struct __ecereNameSpace__ecere__com__Class * _class, long long data1, long long data2)
 568 {
 569 int result = 0;
 570
 571 if(data1 > data2)
 572 result = 1;
 573 else if(data1 < data2)
 574 result = -1;
 575 return result;
 576 }
 577
 578 static int __ecereNameSpace__ecere__com__IntPtr32_OnCompare(struct __ecereNameSpace__ecere__com__Class * _class, int data1, int data2)
 579 {
 580 int result = 0;
 581
 582 if(data1 > data2)
 583 result = 1;
 584 else if(data1 < data2)
 585 result = -1;
 586 return result;
 587 }
 588
 589 static int __ecereNameSpace__ecere__com__UIntPtr64_OnCompare(struct __ecereNameSpace__ecere__com__Class * _class, uint64 data1, uint64 data2)
 590 {
 591 int result = 0;
 592
 593 if(data1 > data2)
 594 result = 1;
 595 else if(data1 < data2)
 596 result = -1;
 597 return result;
 598 }
 599
 600 static int __ecereNameSpace__ecere__com__UIntPtr32_OnCompare(struct __ecereNameSpace__ecere__com__Class * _class, unsigned int data1, unsigned int data2)
 601 {
 602 int result = 0;
 603
 604 if(data1 > data2)
 605 result = 1;
 606 else if(data1 < data2)
 607 result = -1;
 608 return result;
 609 }
 610
 611 static const char * __ecereNameSpace__ecere__com__Int64_OnGetString(struct __ecereNameSpace__ecere__com__Class * _class, long long * data, char * string, void * fieldData, unsigned int * needClass)
 612 {
 613 sprintf(string, ((__runtimePlatform == 1) ? "%I64d" : "%lld"), *data);
 614 return string;
 615 }
 616
 617 static const char * __ecereNameSpace__ecere__com__UInt64_OnGetString(struct __ecereNameSpace__ecere__com__Class * _class, uint64 * data, char * string, void * fieldData, unsigned int * needClass)
 618 {
 619 sprintf(string, ((__runtimePlatform == 1) ? "%I64u" : "%llu"), *data);
 620 return string;
 621 }
 622
 623 static const char * __ecereNameSpace__ecere__com__UInt64Hex_OnGetString(struct __ecereNameSpace__ecere__com__Class * _class, uint64 * data, char * string, void * fieldData, unsigned int * needClass)
 624 {
 625 sprintf(string, ((__runtimePlatform == 1) ? "0x%I64X" : "0x%llX"), *data);
 626 return string;
 627 }
 628
 629 static unsigned int __ecereNameSpace__ecere__com__Int64_OnGetDataFromString(struct __ecereNameSpace__ecere__com__Class * _class, long long * data, const char * string)
 630 {
 631 const char * end;
 632 uint64 result = __ecereNameSpace__ecere__com___strtoi64(string, &end, 0);
 633
 634 if(end > string)
 635 {
 636 *data = result;
 637 return 1;
 638 }
 639 return 0;
 640 }
 641
 642 static unsigned int __ecereNameSpace__ecere__com__UInt64_OnGetDataFromString(struct __ecereNameSpace__ecere__com__Class * _class, uint64 * data, const char * string)
 643 {
 644 const char * end;
 645 uint64 result = __ecereNameSpace__ecere__com___strtoui64(string, &end, 0);
 646
 647 if(end > string)
 648 {
 649 *data = result;
 650 return 1;
 651 }
 652 return 0;
 653 }
 654
 655 static int __ecereNameSpace__ecere__com__Float_OnCompare(struct __ecereNameSpace__ecere__com__Class * _class, float * data1, float * data2)
 656 {
 657 int result = 0;
 658
 659 if(!data1 && !data2)
 660 result = 0;
 661 else if(data1 && !data2)
 662 result = 1;
 663 else if(!data1 && data2)
 664 result = -1;
 665 else if(*data1 > *data2)
 666 result = 1;
 667 else if(*data1 < *data2)
 668 result = -1;
 669 return result;
 670 }
 671
 672 static char * __ecereNameSpace__ecere__com__Float_OnGetString(struct __ecereNameSpace__ecere__com__Class * _class, float * data, char * string, void * fieldData, unsigned int * needClass)
 673 {
 674 float f = *data;
 675
 676 if(__ecereProp_float_Get_isInf(f))
 677 {
 678 if(__ecereProp_float_Get_signBit(f))
 679 strcpy(string, "-inf");
 680 else
 681 strcpy(string, "inf");
 682 }
 683 else if(__ecereProp_float_Get_isNan(f))
 684 {
 685 if(__ecereProp_float_Get_signBit(f))
 686 strcpy(string, "-nan");
 687 else
 688 strcpy(string, "nan");
 689 }
 690 else
 691 {
 692 int c;
 693 int last = 0;
 694 int numDigits = 7, num = 1;
 695 char format[10];
 696
 697 while(numDigits && (float)num < f)
 698 numDigits--, num *= 10;
 699 sprintf(format, "%%.%df", numDigits);
 700 sprintf(string, format, f);
 701 c = strlen(string) - 1;
 702 for(; c >= 0; c--)
 703 {
 704 if(string[c] != '0')
 705 last = ((last > c) ? last : c);
 706 if(string[c] == '.')
 707 {
 708 if(last == c)
 709 string[c] = (char)0;
 710 else
 711 string[last + 1] = (char)0;
 712 break;
 713 }
 714 }
 715 }
 716 return string;
 717 }
 718
 719 static unsigned int __ecereNameSpace__ecere__com__Float_OnGetDataFromString(struct __ecereNameSpace__ecere__com__Class * _class, float * data, char * string)
 720 {
 721 char * end;
 722 float result = (float)strtod(string, &end);
 723
 724 if(end > string)
 725 {
 726 *data = result;
 727 return 1;
 728 }
 729 return 0;
 730 }
 731
 732 extern 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);
 733
 734 static int __ecereNameSpace__ecere__com__Double_OnCompare(struct __ecereNameSpace__ecere__com__Class * _class, double * data1, double * data2)
 735 {
 736 int result = 0;
 737
 738 if(!data1 && !data2)
 739 result = 0;
 740 else if(data1 && !data2)
 741 result = 1;
 742 else if(!data1 && data2)
 743 result = -1;
 744 else if(*data1 > *data2)
 745 result = 1;
 746 else if(*data1 < *data2)
 747 result = -1;
 748 return result;
 749 }
 750
 751 static char * __ecereNameSpace__ecere__com__Double_OnGetString(struct __ecereNameSpace__ecere__com__Class * _class, double * data, char * string, void * fieldData, unsigned int * needClass)
 752 {
 753 double f = *data;
 754
 755 if(__ecereProp_double_Get_isInf(f))
 756 {
 757 if(__ecereProp_double_Get_signBit(f))
 758 strcpy(string, "-inf");
 759 else
 760 strcpy(string, "inf");
 761 }
 762 else if(__ecereProp_double_Get_isNan(f))
 763 {
 764 if(__ecereProp_double_Get_signBit(f))
 765 strcpy(string, "-nan");
 766 else
 767 strcpy(string, "nan");
 768 }
 769 else
 770 {
 771 int c;
 772 int last = 0;
 773
 774 if(runtimePlatform == 1)
 775 sprintf(string, "%.15g", f);
 776 else
 777 sprintf(string, "%.13lf", f);
 778 c = strlen(string) - 1;
 779 for(; c >= 0; c--)
 780 {
 781 if(string[c] != '0')
 782 last = ((last > c) ? last : c);
 783 if(string[c] == '.')
 784 {
 785 if(last == c)
 786 string[c] = (char)0;
 787 else
 788 string[last + 1] = (char)0;
 789 break;
 790 }
 791 }
 792 }
 793 return string;
 794 }
 795
 796 static unsigned int __ecereNameSpace__ecere__com__Double_OnGetDataFromString(struct __ecereNameSpace__ecere__com__Class * _class, double * data, char * string)
 797 {
 798 char * end;
 799 double result;
 800
 801 result = strtod(string, &end);
 802 if(end > string)
 803 {
 804 *data = result;
 805 return 1;
 806 }
 807 return 0;
 808 }
 809
 810 static void __ecereNameSpace__ecere__com__String_OnCopy(struct __ecereNameSpace__ecere__com__Class * _class, char ** data, char * newData)
 811 {
 812 if(newData)
 813 {
 814 int len = strlen(newData);
 815
 816 if(len)
 817 {
 818 *data = __ecereNameSpace__ecere__com__eSystem_New(len + 1);
 819 memcpy(*data, newData, len + 1);
 820 }
 821 else
 822 *data = (((void *)0));
 823 }
 824 else
 825 *data = (((void *)0));
 826 }
 827
 828 static unsigned int __ecereNameSpace__ecere__com__String_OnGetDataFromString(struct __ecereNameSpace__ecere__com__Class * _class, char ** data, char * newData)
 829 {
 830 if(newData)
 831 {
 832 int len = strlen(newData);
 833
 834 if(len)
 835 {
 836 *data = __ecereNameSpace__ecere__com__eSystem_New(len + 1);
 837 memcpy(*data, newData, len + 1);
 838 }
 839 else
 840 *data = (((void *)0));
 841 }
 842 return 1;
 843 }
 844
 845 int __ecereNameSpace__ecere__com__String_OnCompare(struct __ecereNameSpace__ecere__com__Class * _class, const char * string1, const char * string2)
 846 {
 847 int result = 0;
 848
 849 if(string1 && string2)
 850 result = (strcasecmp)(string1, string2);
 851 else if(!string1 && string2)
 852 result = 1;
 853 else if(string1 && !string2)
 854 result = -1;
 855 return result;
 856 }
 857
 858 static char * __ecereNameSpace__ecere__com__String_OnGetString(struct __ecereNameSpace__ecere__com__Class * _class, char * string, char * tempString, void * fieldData, unsigned int * needClass)
 859 {
 860 return string;
 861 }
 862
 863 static void __ecereNameSpace__ecere__com__String_OnFree(struct __ecereNameSpace__ecere__com__Class * _class, char * string)
 864 {
 865 if(string)
 866 {
 867 __ecereNameSpace__ecere__com__eSystem_Delete(string);
 868 }
 869 }
 870
 871 int __ecereVMethodID___ecereNameSpace__ecere__com__IOChannel_WriteData;
 872
 873 int __ecereVMethodID___ecereNameSpace__ecere__com__IOChannel_ReadData;
 874
 875 struct __ecereNameSpace__ecere__com__Property
 876 {
 877 struct __ecereNameSpace__ecere__com__Property * prev;
 878 struct __ecereNameSpace__ecere__com__Property * next;
 879 const char *  name;
 880 unsigned int isProperty;
 881 int memberAccess;
 882 int id;
 883 struct __ecereNameSpace__ecere__com__Class * _class;
 884 const char *  dataTypeString;
 885 struct __ecereNameSpace__ecere__com__Class * dataTypeClass;
 886 struct __ecereNameSpace__ecere__com__Instance * dataType;
 887 void (*  Set)(void * , int);
 888 int (*  Get)(void * );
 889 unsigned int (*  IsSet)(void * );
 890 void *  data;
 891 void *  symbol;
 892 int vid;
 893 unsigned int conversion;
 894 unsigned int watcherOffset;
 895 const char *  category;
 896 unsigned int compiled;
 897 unsigned int selfWatchable;
 898 unsigned int isWatchable;
 899 } __attribute__ ((gcc_struct));
 900
 901 extern void __ecereNameSpace__ecere__com__eInstance_FireSelfWatchers(struct __ecereNameSpace__ecere__com__Instance * instance, struct __ecereNameSpace__ecere__com__Property * _property);
 902
 903 extern void __ecereNameSpace__ecere__com__eInstance_SetMethod(struct __ecereNameSpace__ecere__com__Instance * instance, const char *  name, void *  function);
 904
 905 extern void __ecereNameSpace__ecere__com__eInstance_IncRef(struct __ecereNameSpace__ecere__com__Instance * instance);
 906
 907 extern void __ecereNameSpace__ecere__com__eInstance_StopWatching(struct __ecereNameSpace__ecere__com__Instance * instance, struct __ecereNameSpace__ecere__com__Property * _property, struct __ecereNameSpace__ecere__com__Instance * object);
 908
 909 extern void __ecereNameSpace__ecere__com__eInstance_FireWatchers(struct __ecereNameSpace__ecere__com__Instance * instance, struct __ecereNameSpace__ecere__com__Property * _property);
 910
 911 unsigned char *  __ecereProp___ecereNameSpace__ecere__com__SerialBuffer_Get_buffer(struct __ecereNameSpace__ecere__com__Instance * this);
 912
 913 void __ecereProp___ecereNameSpace__ecere__com__SerialBuffer_Set_buffer(struct __ecereNameSpace__ecere__com__Instance * this, unsigned char *  value);
 914
 915 unsigned int __ecereProp___ecereNameSpace__ecere__com__SerialBuffer_Get_size(struct __ecereNameSpace__ecere__com__Instance * this);
 916
 917 void __ecereProp___ecereNameSpace__ecere__com__SerialBuffer_Set_size(struct __ecereNameSpace__ecere__com__Instance * this, unsigned int value);
 918
 919 extern void __ecereNameSpace__ecere__com__eInstance_DecRef(struct __ecereNameSpace__ecere__com__Instance * instance);
 920
 921 int __ecereVMethodID_class_OnSaveEdit;
 922
 923 int __ecereVMethodID_class_OnEdit;
 924
 925 int __ecereVMethodID_class_OnSerialize;
 926
 927 int __ecereVMethodID_class_OnUnserialize;
 928
 929 static const char * __ecereNameSpace__ecere__com__IntPtr32_OnGetString(struct __ecereNameSpace__ecere__com__Class * _class, int data, char * string, void * fieldData, unsigned int * needClass)
 930 {
 931 return __ecereNameSpace__ecere__com__Integer_OnGetString(_class, &data, string, fieldData, needClass);
 932 }
 933
 934 static const char * __ecereNameSpace__ecere__com__UIntPtr32_OnGetString(struct __ecereNameSpace__ecere__com__Class * _class, unsigned int data, char * string, void * fieldData, unsigned int * needClass)
 935 {
 936 return __ecereNameSpace__ecere__com__UIntegerHex_OnGetString(_class, &data, string, fieldData, needClass);
 937 }
 938
 939 static const char * __ecereNameSpace__ecere__com__IntPtr64_OnGetString(struct __ecereNameSpace__ecere__com__Class * _class, long long data, char * string, void * fieldData, unsigned int * needClass)
 940 {
 941 return __ecereNameSpace__ecere__com__Int64_OnGetString(_class, &data, string, fieldData, needClass);
 942 }
 943
 944 static const char * __ecereNameSpace__ecere__com__UIntPtr64_OnGetString(struct __ecereNameSpace__ecere__com__Class * _class, uint64 data, char * string, void * fieldData, unsigned int * needClass)
 945 {
 946 return __ecereNameSpace__ecere__com__UInt64Hex_OnGetString(_class, &data, string, fieldData, needClass);
 947 }
 948
 949 struct __ecereNameSpace__ecere__sys__NamedLink64;
 950
 951 struct __ecereNameSpace__ecere__sys__NamedLink64
 952 {
 953 struct __ecereNameSpace__ecere__sys__NamedLink64 * prev;
 954 struct __ecereNameSpace__ecere__sys__NamedLink64 * next;
 955 char *  name;
 956 long long data;
 957 } __attribute__ ((gcc_struct));
 958
 959 struct __ecereNameSpace__ecere__sys__BinaryTree;
 960
 961 struct __ecereNameSpace__ecere__sys__BinaryTree
 962 {
 963 struct __ecereNameSpace__ecere__sys__BTNode * root;
 964 int count;
 965 int (*  CompareKey)(struct __ecereNameSpace__ecere__sys__BinaryTree * tree, uintptr_t a, uintptr_t b);
 966 void (*  FreeKey)(void *  key);
 967 } __attribute__ ((gcc_struct));
 968
 969 struct __ecereNameSpace__ecere__com__DataMember;
 970
 971 struct __ecereNameSpace__ecere__com__DataMember
 972 {
 973 struct __ecereNameSpace__ecere__com__DataMember * prev;
 974 struct __ecereNameSpace__ecere__com__DataMember * next;
 975 const char *  name;
 976 unsigned int isProperty;
 977 int memberAccess;
 978 int id;
 979 struct __ecereNameSpace__ecere__com__Class * _class;
 980 const char *  dataTypeString;
 981 struct __ecereNameSpace__ecere__com__Class * dataTypeClass;
 982 struct __ecereNameSpace__ecere__com__Instance * dataType;
 983 int type;
 984 int offset;
 985 int memberID;
 986 struct __ecereNameSpace__ecere__sys__OldList members;
 987 struct __ecereNameSpace__ecere__sys__BinaryTree membersAlpha;
 988 int memberOffset;
 989 short structAlignment;
 990 short pointerAlignment;
 991 } __attribute__ ((gcc_struct));
 992
 993 extern 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);
 994
 995 extern 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);
 996
 997 struct __ecereNameSpace__ecere__com__Method;
 998
 999 struct __ecereNameSpace__ecere__com__ClassTemplateArgument
1000 {
1001 union
1002 {
1003 struct
1004 {
1005 const char *  dataTypeString;
1006 struct __ecereNameSpace__ecere__com__Class * dataTypeClass;
1007 } __attribute__ ((gcc_struct)) __anon1;
1008 struct __ecereNameSpace__ecere__com__DataValue expression;
1009 struct
1010 {
1011 const char *  memberString;
1012 union
1013 {
1014 struct __ecereNameSpace__ecere__com__DataMember * member;
1015 struct __ecereNameSpace__ecere__com__Property * prop;
1016 struct __ecereNameSpace__ecere__com__Method * method;
1017 } __attribute__ ((gcc_struct)) __anon1;
1018 } __attribute__ ((gcc_struct)) __anon2;
1019 } __attribute__ ((gcc_struct)) __anon1;
1020 } __attribute__ ((gcc_struct));
1021
1022 struct __ecereNameSpace__ecere__com__Method
1023 {
1024 const char *  name;
1025 struct __ecereNameSpace__ecere__com__Method * parent;
1026 struct __ecereNameSpace__ecere__com__Method * left;
1027 struct __ecereNameSpace__ecere__com__Method * right;
1028 int depth;
1029 int (*  function)();
1030 int vid;
1031 int type;
1032 struct __ecereNameSpace__ecere__com__Class * _class;
1033 void *  symbol;
1034 const char *  dataTypeString;
1035 struct __ecereNameSpace__ecere__com__Instance * dataType;
1036 int memberAccess;
1037 } __attribute__ ((gcc_struct));
1038
1039 extern 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);
1040
1041 extern 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);
1042
1043 struct __ecereNameSpace__ecere__com__Module;
1044
1045 extern struct __ecereNameSpace__ecere__com__Class * __ecereNameSpace__ecere__com__eSystem_FindClass(struct __ecereNameSpace__ecere__com__Instance * module, const char *  name);
1046
1047 extern 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);
1048
1049 extern 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);
1050
1051 extern 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);
1052
1053 extern struct __ecereNameSpace__ecere__com__DefinedExpression * __ecereNameSpace__ecere__com__eSystem_RegisterDefine(const char *  name, const char *  value, struct __ecereNameSpace__ecere__com__Instance * module, int declMode);
1054
1055 extern struct __ecereNameSpace__ecere__com__Instance * __thisModule;
1056
1057 extern 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);
1058
1059 struct __ecereNameSpace__ecere__com__BitMember;
1060
1061 struct __ecereNameSpace__ecere__com__BitMember
1062 {
1063 struct __ecereNameSpace__ecere__com__BitMember * prev;
1064 struct __ecereNameSpace__ecere__com__BitMember * next;
1065 const char *  name;
1066 unsigned int isProperty;
1067 int memberAccess;
1068 int id;
1069 struct __ecereNameSpace__ecere__com__Class * _class;
1070 const char *  dataTypeString;
1071 struct __ecereNameSpace__ecere__com__Class * dataTypeClass;
1072 struct __ecereNameSpace__ecere__com__Instance * dataType;
1073 int type;
1074 int size;
1075 int pos;
1076 uint64 mask;
1077 } __attribute__ ((gcc_struct));
1078
1079 struct __ecereNameSpace__ecere__com__NameSpace;
1080
1081 struct __ecereNameSpace__ecere__com__NameSpace
1082 {
1083 const char *  name;
1084 struct __ecereNameSpace__ecere__com__NameSpace *  btParent;
1085 struct __ecereNameSpace__ecere__com__NameSpace *  left;
1086 struct __ecereNameSpace__ecere__com__NameSpace *  right;
1087 int depth;
1088 struct __ecereNameSpace__ecere__com__NameSpace *  parent;
1089 struct __ecereNameSpace__ecere__sys__BinaryTree nameSpaces;
1090 struct __ecereNameSpace__ecere__sys__BinaryTree classes;
1091 struct __ecereNameSpace__ecere__sys__BinaryTree defines;
1092 struct __ecereNameSpace__ecere__sys__BinaryTree functions;
1093 } __attribute__ ((gcc_struct));
1094
1095 struct __ecereNameSpace__ecere__com__Class
1096 {
1097 struct __ecereNameSpace__ecere__com__Class * prev;
1098 struct __ecereNameSpace__ecere__com__Class * next;
1099 const char *  name;
1100 int offset;
1101 int structSize;
1102 void * *  _vTbl;
1103 int vTblSize;
1104 unsigned int (*  Constructor)(void * );
1105 void (*  Destructor)(void * );
1106 int offsetClass;
1107 int sizeClass;
1108 struct __ecereNameSpace__ecere__com__Class * base;
1109 struct __ecereNameSpace__ecere__sys__BinaryTree methods;
1110 struct __ecereNameSpace__ecere__sys__BinaryTree members;
1111 struct __ecereNameSpace__ecere__sys__BinaryTree prop;
1112 struct __ecereNameSpace__ecere__sys__OldList membersAndProperties;
1113 struct __ecereNameSpace__ecere__sys__BinaryTree classProperties;
1114 struct __ecereNameSpace__ecere__sys__OldList derivatives;
1115 int memberID;
1116 int startMemberID;
1117 int type;
1118 struct __ecereNameSpace__ecere__com__Instance * module;
1119 struct __ecereNameSpace__ecere__com__NameSpace *  nameSpace;
1120 const char *  dataTypeString;
1121 struct __ecereNameSpace__ecere__com__Instance * dataType;
1122 int typeSize;
1123 int defaultAlignment;
1124 void (*  Initialize)();
1125 int memberOffset;
1126 struct __ecereNameSpace__ecere__sys__OldList selfWatchers;
1127 const char *  designerClass;
1128 unsigned int noExpansion;
1129 const char *  defaultProperty;
1130 unsigned int comRedefinition;
1131 int count;
1132 int isRemote;
1133 unsigned int internalDecl;
1134 void *  data;
1135 unsigned int computeSize;
1136 short structAlignment;
1137 short pointerAlignment;
1138 int destructionWatchOffset;
1139 unsigned int fixed;
1140 struct __ecereNameSpace__ecere__sys__OldList delayedCPValues;
1141 int inheritanceAccess;
1142 const char *  fullName;
1143 void *  symbol;
1144 struct __ecereNameSpace__ecere__sys__OldList conversions;
1145 struct __ecereNameSpace__ecere__sys__OldList templateParams;
1146 struct __ecereNameSpace__ecere__com__ClassTemplateArgument *  templateArgs;
1147 struct __ecereNameSpace__ecere__com__Class * templateClass;
1148 struct __ecereNameSpace__ecere__sys__OldList templatized;
1149 int numParams;
1150 unsigned int isInstanceClass;
1151 unsigned int byValueSystemClass;
1152 } __attribute__ ((gcc_struct));
1153
1154 struct __ecereNameSpace__ecere__com__Application
1155 {
1156 int argc;
1157 const char * *  argv;
1158 int exitCode;
1159 unsigned int isGUIApp;
1160 struct __ecereNameSpace__ecere__sys__OldList allModules;
1161 char *  parsedCommand;
1162 struct __ecereNameSpace__ecere__com__NameSpace systemNameSpace;
1163 } __attribute__ ((gcc_struct));
1164
1165 static struct __ecereNameSpace__ecere__com__Class * __ecereClass___ecereNameSpace__ecere__com__IOChannel;
1166
1167 static struct __ecereNameSpace__ecere__com__Class * __ecereClass___ecereNameSpace__ecere__com__SerialBuffer;
1168
1169 static struct __ecereNameSpace__ecere__com__Class * __ecereClass___ecereNameSpace__ecere__com__StaticString;
1170
1171 void __ecereMethod___ecereNameSpace__ecere__com__IOChannel_Serialize(struct __ecereNameSpace__ecere__com__Instance * this, struct __ecereNameSpace__ecere__com__Class * class, const void * data)
1172 {
1173 ((void (*)(struct __ecereNameSpace__ecere__com__Class *, const void *, struct __ecereNameSpace__ecere__com__Instance * channel))class->_vTbl[__ecereVMethodID_class_OnSerialize])(class, data, this);
1174 }
1175
1176 void __ecereMethod___ecereNameSpace__ecere__com__IOChannel_Unserialize(struct __ecereNameSpace__ecere__com__Instance * this, struct __ecereNameSpace__ecere__com__Class * class, void * * data)
1177 {
1178 ((void (*)(struct __ecereNameSpace__ecere__com__Class *, const void *, struct __ecereNameSpace__ecere__com__Instance * channel))class->_vTbl[__ecereVMethodID_class_OnUnserialize])(class, data, this);
1179 }
1180
1181 void __ecereMethod___ecereNameSpace__ecere__com__IOChannel_Put(struct __ecereNameSpace__ecere__com__Instance * this, struct __ecereNameSpace__ecere__com__Class * class, const void * data)
1182 {
1183 ((void (*)(struct __ecereNameSpace__ecere__com__Class *, const void *, struct __ecereNameSpace__ecere__com__Instance * channel))class->_vTbl[__ecereVMethodID_class_OnSerialize])(class, data, this);
1184 }
1185
1186 void __ecereMethod___ecereNameSpace__ecere__com__IOChannel_Get(struct __ecereNameSpace__ecere__com__Instance * this, struct __ecereNameSpace__ecere__com__Class * class, void * * data)
1187 {
1188 ((void (*)(struct __ecereNameSpace__ecere__com__Class *, const void *, struct __ecereNameSpace__ecere__com__Instance * channel))class->_vTbl[__ecereVMethodID_class_OnUnserialize])(class, data, this);
1189 }
1190
1191 const char * __ecereNameSpace__ecere__com__Enum_OnGetString(struct __ecereNameSpace__ecere__com__Class * _class, void * data, char * tempString, void * fieldData, unsigned int * needClass)
1192 {
1193 struct __ecereNameSpace__ecere__sys__NamedLink64 * item = (((void *)0));
1194 struct __ecereNameSpace__ecere__com__Class * b;
1195 long long i64Data = 0;
1196
1197 switch(_class->typeSize)
1198 {
1199 case 1:
1200 i64Data = !strcmp(_class->dataTypeString, "byte") ? *(unsigned char *)data : *(char *)data;
1201 break;
1202 case 2:
1203 i64Data = !strcmp(_class->dataTypeString, "uint16") ? *(unsigned short *)data : *(short *)data;
1204 break;
1205 case 4:
1206 i64Data = !strcmp(_class->dataTypeString, "uint") ? *(unsigned int *)data : *(int *)data;
1207 break;
1208 case 8:
1209 i64Data = !strcmp(_class->dataTypeString, "uint64") ? *(long long *)data : *(long long *)data;
1210 break;
1211 }
1212 for(b = _class; !item && b && b->type == 4; b = b->base)
1213 {
1214 struct __ecereNameSpace__ecere__com__EnumClassData * enumeration = (struct __ecereNameSpace__ecere__com__EnumClassData *)b->data;
1215
1216 for(item = enumeration->values.first; item; item = item->next)
1217 if(item->data == i64Data)
1218 break;
1219 }
1220 if(item)
1221 {
1222 strcpy(tempString, item->name);
1223 if(!needClass || !*needClass)
1224 tempString[0] = (char)toupper(tempString[0]);
1225 return tempString;
1226 }
1227 else
1228 return (((void *)0));
1229 }
1230
1231 static unsigned int __ecereNameSpace__ecere__com__Enum_OnGetDataFromString(struct __ecereNameSpace__ecere__com__Class * _class, void * data, const char * string)
1232 {
1233 struct __ecereNameSpace__ecere__sys__NamedLink64 * item = (((void *)0));
1234 struct __ecereNameSpace__ecere__com__Class * b;
1235
1236 for(b = _class; !item && b && b->type == 4; b = b->base)
1237 {
1238 struct __ecereNameSpace__ecere__com__EnumClassData * enumeration = (struct __ecereNameSpace__ecere__com__EnumClassData *)_class->data;
1239
1240 for(item = enumeration->values.first; item; item = item->next)
1241 {
1242 if(item->name && !(strcasecmp)(item->name, string))
1243 break;
1244 }
1245 }
1246 if(item)
1247 {
1248 switch(_class->typeSize)
1249 {
1250 case 1:
1251 if(!strcmp(_class->dataTypeString, "byte"))
1252 *(unsigned char *)data = (unsigned char)item->data;
1253 else
1254 *(char *)data = (char)item->data;
1255 break;
1256 case 2:
1257 if(!strcmp(_class->dataTypeString, "uint16"))
1258 *(unsigned short *)data = (unsigned short)item->data;
1259 else
1260 *(short *)data = (short)item->data;
1261 break;
1262 case 4:
1263 if(!strcmp(_class->dataTypeString, "uint"))
1264 *(unsigned int *)data = (unsigned int)item->data;
1265 else
1266 *(int *)data = (int)item->data;
1267 break;
1268 case 8:
1269 if(!strcmp(_class->dataTypeString, "uint64"))
1270 *(uint64 *)data = *(uint64 *)&item->data;
1271 else
1272 *(long long *)data = item->data;
1273 break;
1274 }
1275 return 1;
1276 }
1277 else
1278 return __ecereNameSpace__ecere__com__Int64_OnGetDataFromString(_class, data, string);
1279 return 0;
1280 }
1281
1282 static void __ecereNameSpace__ecere__com__OnFree(struct __ecereNameSpace__ecere__com__Class * _class, void * data)
1283 {
1284 if(_class->templateClass)
1285 _class = _class->templateClass;
1286 if(_class->type == 0)
1287 {
1288 __ecereNameSpace__ecere__com__eInstance_DecRef(data);
1289 }
1290 else if(_class->type == 5 && data)
1291 {
1292 while(_class && _class->type == 5)
1293 {
1294 if(_class->Destructor)
1295 _class->Destructor(data);
1296 _class = _class->base;
1297 }
1298 (__ecereNameSpace__ecere__com__eSystem_Delete(data), data = 0);
1299 }
1300 }
1301
1302 static int __ecereNameSpace__ecere__com__DataMember_OnCompare(struct __ecereNameSpace__ecere__com__DataMember * parentMember, void * data1, void * data2)
1303 {
1304 struct __ecereNameSpace__ecere__com__DataMember * member;
1305 struct __ecereNameSpace__ecere__com__Instance * module = parentMember->_class->module;
1306
1307 for(member = parentMember->members.first; member; member = member->next)
1308 {
1309 int memberResult = 0;
1310
1311 if(member->type == 0)
1312 {
1313 struct __ecereNameSpace__ecere__com__Class * memberType = member->dataTypeClass;
1314
1315 if(!memberType)
1316 memberType = member->dataTypeClass = __ecereNameSpace__ecere__com__eSystem_FindClass(module, member->dataTypeString);
1317 if(!memberType)
1318 memberType = member->dataTypeClass = __ecereNameSpace__ecere__com__eSystem_FindClass(module, "int");
1319 if(memberType->type == 1 || memberType->type == 0 || memberType->type == 5)
1320 {
1321 memberResult = ((int (*)(void *, void *, void *))(void *)memberType->_vTbl[__ecereVMethodID_class_OnCompare])(memberType, (unsigned char *)data1 + member->offset, (unsigned char *)data2 + member->offset);
1322 if(memberResult)
1323 return memberResult;
1324 }
1325 else
1326 {
1327 struct __ecereNameSpace__ecere__com__DataValue value1, value2;
1328
1329 value1.__anon1.i = *(int *)((unsigned char *)data1 + member->offset);
1330 value2.__anon1.i = *(int *)((unsigned char *)data2 + member->offset);
1331 memberResult = ((int (*)(void *, void *, void *))(void *)memberType->_vTbl[__ecereVMethodID_class_OnCompare])(memberType, &value1, &value2);
1332 if(memberResult)
1333 return memberResult;
1334 }
1335 }
1336 else
1337 {
1338 memberResult = __ecereNameSpace__ecere__com__DataMember_OnCompare(member, (unsigned char *)data1 + member->offset, (unsigned char *)data2 + member->offset);
1339 if(memberResult)
1340 return memberResult;
1341 }
1342 }
1343 return 0;
1344 }
1345
1346 static void __ecereNameSpace__ecere__com__OnCopy(struct __ecereNameSpace__ecere__com__Class * _class, void ** data, void * newData)
1347 {
1348 if(_class->type == 3 || _class->type == 2 || _class->type == 4)
1349 {
1350 struct __ecereNameSpace__ecere__com__Class * dataType = __ecereNameSpace__ecere__com__eSystem_FindClass(_class->module, _class->dataTypeString);
1351
1352 if(dataType)
1353 ((void (*)(void *, void *, void *))(void *)dataType->_vTbl[__ecereVMethodID_class_OnCopy])(dataType, data, newData);
1354 }
1355 else if(_class->type != 1 && (_class->type != 1000 || _class->byValueSystemClass))
1356 {
1357 *data = newData;
1358 }
1359 else if(newData)
1360 memcpy(data, newData, _class->typeSize);
1361 else
1362 memset(data, 0, _class->typeSize);
1363 }
1364
1365 static int __ecereNameSpace__ecere__com__DataMember_OnSerialize(struct __ecereNameSpace__ecere__com__DataMember * parentMember, void * data, struct __ecereNameSpace__ecere__com__Instance * channel)
1366 {
1367 struct __ecereNameSpace__ecere__com__DataMember * member;
1368 struct __ecereNameSpace__ecere__com__Instance * module = parentMember->_class->module;
1369
1370 for(member = parentMember->members.first; member; member = member->next)
1371 {
1372 if(member->type == 0)
1373 {
1374 struct __ecereNameSpace__ecere__com__Class * memberType = member->dataTypeClass;
1375
1376 if(!memberType)
1377 memberType = member->dataTypeClass = __ecereNameSpace__ecere__com__eSystem_FindClass(module, member->dataTypeString);
1378 if(!memberType)
1379 memberType = member->dataTypeClass = __ecereNameSpace__ecere__com__eSystem_FindClass(module, "int");
1380 if(memberType->type == 1 || memberType->type == 0 || memberType->type == 5)
1381 {
1382 ((void (*)(void *, void *, void *))(void *)memberType->_vTbl[__ecereVMethodID_class_OnSerialize])(memberType, (unsigned char *)data + member->offset, channel);
1383 }
1384 else
1385 {
1386 struct __ecereNameSpace__ecere__com__DataValue value;
1387
1388 value.__anon1.i = *(int *)((unsigned char *)data + member->offset);
1389 ((void (*)(void *, void *, void *))(void *)memberType->_vTbl[__ecereVMethodID_class_OnSerialize])(memberType, &value, channel);
1390 }
1391 }
1392 else
1393 {
1394 __ecereNameSpace__ecere__com__DataMember_OnSerialize(member, (unsigned char *)data + member->offset, channel);
1395 }
1396 }
1397 return 0;
1398 }
1399
1400 static int __ecereNameSpace__ecere__com__DataMember_OnUnserialize(struct __ecereNameSpace__ecere__com__DataMember * parentMember, void * data, struct __ecereNameSpace__ecere__com__Instance * channel)
1401 {
1402 struct __ecereNameSpace__ecere__com__DataMember * member;
1403 struct __ecereNameSpace__ecere__com__Instance * module = parentMember->_class->module;
1404
1405 for(member = parentMember->members.first; member; member = member->next)
1406 {
1407 if(member->type == 0)
1408 {
1409 struct __ecereNameSpace__ecere__com__Class * memberType = member->dataTypeClass;
1410
1411 if(!memberType)
1412 memberType = member->dataTypeClass = __ecereNameSpace__ecere__com__eSystem_FindClass(module, member->dataTypeString);
1413 if(!memberType)
1414 memberType = member->dataTypeClass = __ecereNameSpace__ecere__com__eSystem_FindClass(module, "int");
1415 if(memberType->type == 1 || memberType->type == 0 || memberType->type == 5)
1416 {
1417 ((void (*)(void *, void *, void *))(void *)memberType->_vTbl[__ecereVMethodID_class_OnUnserialize])(memberType, (unsigned char *)data + member->offset, channel);
1418 }
1419 else
1420 {
1421 struct __ecereNameSpace__ecere__com__DataValue value;
1422
1423 ((void (*)(void *, void *, void *))(void *)memberType->_vTbl[__ecereVMethodID_class_OnUnserialize])(memberType, &value, channel);
1424 *(int *)((unsigned char *)data + member->offset) = value.__anon1.i;
1425 }
1426 }
1427 else
1428 {
1429 __ecereNameSpace__ecere__com__DataMember_OnUnserialize(member, (unsigned char *)data + member->offset, channel);
1430 }
1431 }
1432 return 0;
1433 }
1434
1435 int __ecereMethod___ecereNameSpace__ecere__com__StaticString_OnCompare(struct __ecereNameSpace__ecere__com__Class * class, struct __ecereNameSpace__ecere__com__StaticString * this, struct __ecereNameSpace__ecere__com__StaticString * string2)
1436 {
1437 int result = 0;
1438
1439 if(this && string2)
1440 result = (strcasecmp)(this->string, string2->string);
1441 else if(!this && string2)
1442 result = -1;
1443 else if(this && !string2)
1444 result = 1;
1445 return result;
1446 }
1447
1448 const char * __ecereMethod___ecereNameSpace__ecere__com__StaticString_OnGetString(struct __ecereNameSpace__ecere__com__Class * class, struct __ecereNameSpace__ecere__com__StaticString * this, char * tempString, void * fieldData, unsigned int * needClass)
1449 {
1450 return this ? this->string : (((void *)0));
1451 }
1452
1453 void __ecereMethod___ecereNameSpace__ecere__com__StaticString_OnFree(struct __ecereNameSpace__ecere__com__Class * class, struct __ecereNameSpace__ecere__com__StaticString * this)
1454 {
1455 }
1456
1457 int __ecereNameSpace__ecere__com__PrintStdArgsToBuffer(char * buffer, int maxLen, struct __ecereNameSpace__ecere__com__Class * class, const void * object, va_list args)
1458 {
1459 int len = 0;
1460 const char * result = ((const char *  (*)(struct __ecereNameSpace__ecere__com__Class *, const void *, char *  tempString, void *  fieldData, unsigned int *  needClass))class->_vTbl[__ecereVMethodID_class_OnGetString])(class, object, buffer, (((void *)0)), (((void *)0)));
1461
1462 if(result)
1463 {
1464 len = strlen(result);
1465 if(len >= maxLen)
1466 len = maxLen - 1;
1467 if(result != buffer)
1468 memcpy(buffer, result, len);
1469 }
1470 while(1)
1471 {
1472 struct __ecereNameSpace__ecere__com__Class * _class = (((void *)0));
1473 void * data = (((void *)0));
1474
1475 _class = __builtin_va_arg(args, void *);
1476 if(!_class)
1477 break;
1478 data = __builtin_va_arg(args, void *);
1479 if(data)
1480 {
1481 result = ((const char * (*)(void *, void *, char *, void *, unsigned int *))(void *)_class->_vTbl[__ecereVMethodID_class_OnGetString])(_class, data, buffer + len, (((void *)0)), (((void *)0)));
1482 if(result)
1483 {
1484 int newLen = strlen(result);
1485
1486 if(len + newLen >= maxLen)
1487 newLen = maxLen - 1 - len;
1488 if(result != buffer + len)
1489 memcpy(buffer + len, result, newLen);
1490 len += newLen;
1491 }
1492 }
1493 }
1494 buffer[len] = (char)0;
1495 return len;
1496 }
1497
1498 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_int;
1499
1500 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_double;
1501
1502 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_float;
1503
1504 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_int64;
1505
1506 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass___ecereNameSpace__ecere__com__Instance;
1507
1508 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass___ecereNameSpace__ecere__com__Module;
1509
1510 struct __ecereNameSpace__ecere__com__Module
1511 {
1512 struct __ecereNameSpace__ecere__com__Instance * application;
1513 struct __ecereNameSpace__ecere__sys__OldList classes;
1514 struct __ecereNameSpace__ecere__sys__OldList defines;
1515 struct __ecereNameSpace__ecere__sys__OldList functions;
1516 struct __ecereNameSpace__ecere__sys__OldList modules;
1517 struct __ecereNameSpace__ecere__com__Instance * prev;
1518 struct __ecereNameSpace__ecere__com__Instance * next;
1519 const char *  name;
1520 void *  library;
1521 void *  Unload;
1522 int importType;
1523 int origImportType;
1524 struct __ecereNameSpace__ecere__com__NameSpace privateNameSpace;
1525 struct __ecereNameSpace__ecere__com__NameSpace publicNameSpace;
1526 } __attribute__ ((gcc_struct));
1527
1528 void __ecereNameSpace__ecere__com__Byte_OnSerialize(struct __ecereNameSpace__ecere__com__Class * _class, unsigned char * data, struct __ecereNameSpace__ecere__com__Instance * channel)
1529 {
1530 ((unsigned int (*)(struct __ecereNameSpace__ecere__com__Instance *, const void *  data, unsigned int numBytes))__extension__ ({
1531 struct __ecereNameSpace__ecere__com__Instance * __internal_ClassInst = channel;
1532
1533 __internal_ClassInst ? __internal_ClassInst->_vTbl : __ecereClass___ecereNameSpace__ecere__com__IOChannel->_vTbl;
1534 })[__ecereVMethodID___ecereNameSpace__ecere__com__IOChannel_WriteData])(channel, data, 1);
1535 }
1536
1537 void __ecereNameSpace__ecere__com__Byte_OnUnserialize(struct __ecereNameSpace__ecere__com__Class * _class, unsigned char * data, struct __ecereNameSpace__ecere__com__Instance * channel)
1538 {
1539 if(((unsigned int (*)(struct __ecereNameSpace__ecere__com__Instance *, void *  data, unsigned int numBytes))__extension__ ({
1540 struct __ecereNameSpace__ecere__com__Instance * __internal_ClassInst = channel;
1541
1542 __internal_ClassInst ? __internal_ClassInst->_vTbl : __ecereClass___ecereNameSpace__ecere__com__IOChannel->_vTbl;
1543 })[__ecereVMethodID___ecereNameSpace__ecere__com__IOChannel_ReadData])(channel, data, 1) != 1)
1544 *data = (unsigned char)0;
1545 }
1546
1547 void __ecereNameSpace__ecere__com__Int_OnSerialize(struct __ecereNameSpace__ecere__com__Class * _class, int * data, struct __ecereNameSpace__ecere__com__Instance * channel)
1548 {
1549 unsigned char bytes[4];
1550
1551 (bytes)[0] = (unsigned char)(((*data) >> 24) & 0xFF);
1552 (bytes)[1] = (unsigned char)(((*data) >> 16) & 0xFF);
1553 (bytes)[2] = (unsigned char)(((*data) >> 8) & 0xFF);
1554 (bytes)[3] = (unsigned char)((*data) & 0xFF);
1555 ;
1556 ((unsigned int (*)(struct __ecereNameSpace__ecere__com__Instance *, const void *  data, unsigned int numBytes))__extension__ ({
1557 struct __ecereNameSpace__ecere__com__Instance * __internal_ClassInst = channel;
1558
1559 __internal_ClassInst ? __internal_ClassInst->_vTbl : __ecereClass___ecereNameSpace__ecere__com__IOChannel->_vTbl;
1560 })[__ecereVMethodID___ecereNameSpace__ecere__com__IOChannel_WriteData])(channel, bytes, 4);
1561 }
1562
1563 void __ecereNameSpace__ecere__com__IntPtr32_OnSerialize(struct __ecereNameSpace__ecere__com__Class * _class, int data, struct __ecereNameSpace__ecere__com__Instance * channel)
1564 {
1565 unsigned char bytes[4];
1566
1567 (bytes)[0] = (unsigned char)(((data) >> 24) & 0xFF);
1568 (bytes)[1] = (unsigned char)(((data) >> 16) & 0xFF);
1569 (bytes)[2] = (unsigned char)(((data) >> 8) & 0xFF);
1570 (bytes)[3] = (unsigned char)((data) & 0xFF);
1571 ;
1572 ((unsigned int (*)(struct __ecereNameSpace__ecere__com__Instance *, const void *  data, unsigned int numBytes))__extension__ ({
1573 struct __ecereNameSpace__ecere__com__Instance * __internal_ClassInst = channel;
1574
1575 __internal_ClassInst ? __internal_ClassInst->_vTbl : __ecereClass___ecereNameSpace__ecere__com__IOChannel->_vTbl;
1576 })[__ecereVMethodID___ecereNameSpace__ecere__com__IOChannel_WriteData])(channel, bytes, 4);
1577 }
1578
1579 void __ecereNameSpace__ecere__com__Int_OnUnserialize(struct __ecereNameSpace__ecere__com__Class * _class, int * data, struct __ecereNameSpace__ecere__com__Instance * channel)
1580 {
1581 unsigned char bytes[4];
1582
1583 if(((unsigned int (*)(struct __ecereNameSpace__ecere__com__Instance *, void *  data, unsigned int numBytes))__extension__ ({
1584 struct __ecereNameSpace__ecere__com__Instance * __internal_ClassInst = channel;
1585
1586 __internal_ClassInst ? __internal_ClassInst->_vTbl : __ecereClass___ecereNameSpace__ecere__com__IOChannel->_vTbl;
1587 })[__ecereVMethodID___ecereNameSpace__ecere__com__IOChannel_ReadData])(channel, bytes, 4) == 4)
1588 *data = (unsigned int)(((bytes)[0] << (unsigned char)24) | ((bytes)[1] << (unsigned char)16) | ((bytes)[2] << (unsigned char)8) | (bytes)[3]);
1589 else
1590 *data = 0;
1591 }
1592
1593 void __ecereNameSpace__ecere__com__Int64_OnSerialize(struct __ecereNameSpace__ecere__com__Class * _class, long long * data, struct __ecereNameSpace__ecere__com__Instance * channel)
1594 {
1595 unsigned char bytes[8];
1596
1597 (bytes)[0] = (unsigned char)(((*data) >> 56) & 0xFF);
1598 (bytes)[1] = (unsigned char)(((*data) >> 48) & 0xFF);
1599 (bytes)[2] = (unsigned char)(((*data) >> 40) & 0xFF);
1600 (bytes)[3] = (unsigned char)(((*data) >> 32) & 0xFF);
1601 (bytes)[4] = (unsigned char)(((*data) >> 24) & 0xFF);
1602 (bytes)[5] = (unsigned char)(((*data) >> 16) & 0xFF);
1603 (bytes)[6] = (unsigned char)(((*data) >> 8) & 0xFF);
1604 (bytes)[7] = (unsigned char)((*data) & 0xFF);
1605 ;
1606 ((unsigned int (*)(struct __ecereNameSpace__ecere__com__Instance *, const void *  data, unsigned int numBytes))__extension__ ({
1607 struct __ecereNameSpace__ecere__com__Instance * __internal_ClassInst = channel;
1608
1609 __internal_ClassInst ? __internal_ClassInst->_vTbl : __ecereClass___ecereNameSpace__ecere__com__IOChannel->_vTbl;
1610 })[__ecereVMethodID___ecereNameSpace__ecere__com__IOChannel_WriteData])(channel, bytes, 8);
1611 }
1612
1613 static void __ecereNameSpace__ecere__com__IntPtr64_OnSerialize(struct __ecereNameSpace__ecere__com__Class * _class, long long data, struct __ecereNameSpace__ecere__com__Instance * channel)
1614 {
1615 unsigned char bytes[8];
1616
1617 (bytes)[0] = (unsigned char)(((data) >> 56) & 0xFF);
1618 (bytes)[1] = (unsigned char)(((data) >> 48) & 0xFF);
1619 (bytes)[2] = (unsigned char)(((data) >> 40) & 0xFF);
1620 (bytes)[3] = (unsigned char)(((data) >> 32) & 0xFF);
1621 (bytes)[4] = (unsigned char)(((data) >> 24) & 0xFF);
1622 (bytes)[5] = (unsigned char)(((data) >> 16) & 0xFF);
1623 (bytes)[6] = (unsigned char)(((data) >> 8) & 0xFF);
1624 (bytes)[7] = (unsigned char)((data) & 0xFF);
1625 ;
1626 ((unsigned int (*)(struct __ecereNameSpace__ecere__com__Instance *, const void *  data, unsigned int numBytes))__extension__ ({
1627 struct __ecereNameSpace__ecere__com__Instance * __internal_ClassInst = channel;
1628
1629 __internal_ClassInst ? __internal_ClassInst->_vTbl : __ecereClass___ecereNameSpace__ecere__com__IOChannel->_vTbl;
1630 })[__ecereVMethodID___ecereNameSpace__ecere__com__IOChannel_WriteData])(channel, bytes, 8);
1631 }
1632
1633 void __ecereNameSpace__ecere__com__Int64_OnUnserialize(struct __ecereNameSpace__ecere__com__Class * _class, long long * data, struct __ecereNameSpace__ecere__com__Instance * channel)
1634 {
1635 unsigned char bytes[8];
1636
1637 if(((unsigned int (*)(struct __ecereNameSpace__ecere__com__Instance *, void *  data, unsigned int numBytes))__extension__ ({
1638 struct __ecereNameSpace__ecere__com__Instance * __internal_ClassInst = channel;
1639
1640 __internal_ClassInst ? __internal_ClassInst->_vTbl : __ecereClass___ecereNameSpace__ecere__com__IOChannel->_vTbl;
1641 })[__ecereVMethodID___ecereNameSpace__ecere__com__IOChannel_ReadData])(channel, bytes, 8) == 8)
1642 *data = (((uint64)(bytes)[0] << 56) | ((uint64)(bytes)[1] << 48) | ((uint64)(bytes)[2] << 40) | ((uint64)(bytes)[3] << 32) | ((uint64)(bytes)[4] << 24) | ((bytes)[5] << (unsigned char)16) | ((bytes)[6] << (unsigned char)8) | (bytes)[7]);
1643 else
1644 *data = 0;
1645 }
1646
1647 void __ecereNameSpace__ecere__com__Word_OnSerialize(struct __ecereNameSpace__ecere__com__Class * _class, unsigned short * data, struct __ecereNameSpace__ecere__com__Instance * channel)
1648 {
1649 unsigned char bytes[2];
1650
1651 (bytes)[0] = (unsigned char)(((*data) >> (unsigned short)8) & (unsigned short)0xFF);
1652 (bytes)[1] = (unsigned char)(((*data)) & (unsigned short)0xFF);
1653 ;
1654 ((unsigned int (*)(struct __ecereNameSpace__ecere__com__Instance *, const void *  data, unsigned int numBytes))__extension__ ({
1655 struct __ecereNameSpace__ecere__com__Instance * __internal_ClassInst = channel;
1656
1657 __internal_ClassInst ? __internal_ClassInst->_vTbl : __ecereClass___ecereNameSpace__ecere__com__IOChannel->_vTbl;
1658 })[__ecereVMethodID___ecereNameSpace__ecere__com__IOChannel_WriteData])(channel, bytes, 2);
1659 }
1660
1661 void __ecereNameSpace__ecere__com__Word_OnUnserialize(struct __ecereNameSpace__ecere__com__Class * _class, unsigned short * data, struct __ecereNameSpace__ecere__com__Instance * channel)
1662 {
1663 unsigned char bytes[2];
1664
1665 if(((unsigned int (*)(struct __ecereNameSpace__ecere__com__Instance *, void *  data, unsigned int numBytes))__extension__ ({
1666 struct __ecereNameSpace__ecere__com__Instance * __internal_ClassInst = channel;
1667
1668 __internal_ClassInst ? __internal_ClassInst->_vTbl : __ecereClass___ecereNameSpace__ecere__com__IOChannel->_vTbl;
1669 })[__ecereVMethodID___ecereNameSpace__ecere__com__IOChannel_ReadData])(channel, bytes, 2) == 2)
1670 *data = (unsigned short)(((bytes)[0] << (unsigned char)8) | (bytes)[1]);
1671 else
1672 *data = (unsigned short)0;
1673 }
1674
1675 static void __ecereNameSpace__ecere__com__Float_OnSerialize(struct __ecereNameSpace__ecere__com__Class * _class, float * data, struct __ecereNameSpace__ecere__com__Instance * channel)
1676 {
1677 unsigned char bytes[4];
1678
1679 (bytes)[0] = (unsigned char)(((*(unsigned int *)data) >> 24) & 0xFF);
1680 (bytes)[1] = (unsigned char)(((*(unsigned int *)data) >> 16) & 0xFF);
1681 (bytes)[2] = (unsigned char)(((*(unsigned int *)data) >> 8) & 0xFF);
1682 (bytes)[3] = (unsigned char)((*(unsigned int *)data) & 0xFF);
1683 ;
1684 ((unsigned int (*)(struct __ecereNameSpace__ecere__com__Instance *, const void *  data, unsigned int numBytes))__extension__ ({
1685 struct __ecereNameSpace__ecere__com__Instance * __internal_ClassInst = channel;
1686
1687 __internal_ClassInst ? __internal_ClassInst->_vTbl : __ecereClass___ecereNameSpace__ecere__com__IOChannel->_vTbl;
1688 })[__ecereVMethodID___ecereNameSpace__ecere__com__IOChannel_WriteData])(channel, bytes, 4);
1689 }
1690
1691 static void __ecereNameSpace__ecere__com__Float_OnUnserialize(struct __ecereNameSpace__ecere__com__Class * _class, float * data, struct __ecereNameSpace__ecere__com__Instance * channel)
1692 {
1693 unsigned char bytes[4];
1694
1695 if(((unsigned int (*)(struct __ecereNameSpace__ecere__com__Instance *, void *  data, unsigned int numBytes))__extension__ ({
1696 struct __ecereNameSpace__ecere__com__Instance * __internal_ClassInst = channel;
1697
1698 __internal_ClassInst ? __internal_ClassInst->_vTbl : __ecereClass___ecereNameSpace__ecere__com__IOChannel->_vTbl;
1699 })[__ecereVMethodID___ecereNameSpace__ecere__com__IOChannel_ReadData])(channel, bytes, 4) == 4)
1700 *(unsigned int *)data = (unsigned int)(((bytes)[0] << (unsigned char)24) | ((bytes)[1] << (unsigned char)16) | ((bytes)[2] << (unsigned char)8) | (bytes)[3]);
1701 else
1702 *data = 0;
1703 }
1704
1705 static void __ecereNameSpace__ecere__com__Double_OnSerialize(struct __ecereNameSpace__ecere__com__Class * _class, double * data, struct __ecereNameSpace__ecere__com__Instance * channel)
1706 {
1707 unsigned char bytes[8];
1708
1709 (bytes)[0] = (unsigned char)(((*(uint64 *)data) >> 56) & 0xFF);
1710 (bytes)[1] = (unsigned char)(((*(uint64 *)data) >> 48) & 0xFF);
1711 (bytes)[2] = (unsigned char)(((*(uint64 *)data) >> 40) & 0xFF);
1712 (bytes)[3] = (unsigned char)(((*(uint64 *)data) >> 32) & 0xFF);
1713 (bytes)[4] = (unsigned char)(((*(uint64 *)data) >> 24) & 0xFF);
1714 (bytes)[5] = (unsigned char)(((*(uint64 *)data) >> 16) & 0xFF);
1715 (bytes)[6] = (unsigned char)(((*(uint64 *)data) >> 8) & 0xFF);
1716 (bytes)[7] = (unsigned char)((*(uint64 *)data) & 0xFF);
1717 ;
1718 ((unsigned int (*)(struct __ecereNameSpace__ecere__com__Instance *, const void *  data, unsigned int numBytes))__extension__ ({
1719 struct __ecereNameSpace__ecere__com__Instance * __internal_ClassInst = channel;
1720
1721 __internal_ClassInst ? __internal_ClassInst->_vTbl : __ecereClass___ecereNameSpace__ecere__com__IOChannel->_vTbl;
1722 })[__ecereVMethodID___ecereNameSpace__ecere__com__IOChannel_WriteData])(channel, bytes, 8);
1723 }
1724
1725 static void __ecereNameSpace__ecere__com__Double_OnUnserialize(struct __ecereNameSpace__ecere__com__Class * _class, double * data, struct __ecereNameSpace__ecere__com__Instance * channel)
1726 {
1727 unsigned char bytes[8];
1728
1729 if(((unsigned int (*)(struct __ecereNameSpace__ecere__com__Instance *, void *  data, unsigned int numBytes))__extension__ ({
1730 struct __ecereNameSpace__ecere__com__Instance * __internal_ClassInst = channel;
1731
1732 __internal_ClassInst ? __internal_ClassInst->_vTbl : __ecereClass___ecereNameSpace__ecere__com__IOChannel->_vTbl;
1733 })[__ecereVMethodID___ecereNameSpace__ecere__com__IOChannel_ReadData])(channel, bytes, 8) == 8)
1734 *(uint64 *)data = (((uint64)(bytes)[0] << 56) | ((uint64)(bytes)[1] << 48) | ((uint64)(bytes)[2] << 40) | ((uint64)(bytes)[3] << 32) | ((uint64)(bytes)[4] << 24) | ((bytes)[5] << (unsigned char)16) | ((bytes)[6] << (unsigned char)8) | (bytes)[7]);
1735 else
1736 *data = 0;
1737 }
1738
1739 void __ecereMethod___ecereNameSpace__ecere__com__StaticString_OnSerialize(struct __ecereNameSpace__ecere__com__Class * class, struct __ecereNameSpace__ecere__com__StaticString * this, struct __ecereNameSpace__ecere__com__Instance * channel)
1740 {
1741 unsigned int len = this ? strlen(this->string) : 0;
1742
1743 ((unsigned int (*)(struct __ecereNameSpace__ecere__com__Instance *, const void *  data, unsigned int numBytes))__extension__ ({
1744 struct __ecereNameSpace__ecere__com__Instance * __internal_ClassInst = channel;
1745
1746 __internal_ClassInst ? __internal_ClassInst->_vTbl : __ecereClass___ecereNameSpace__ecere__com__IOChannel->_vTbl;
1747 })[__ecereVMethodID___ecereNameSpace__ecere__com__IOChannel_WriteData])(channel, this ? this->string : "", len + 1);
1748 }
1749
1750 void __ecereMethod___ecereNameSpace__ecere__com__StaticString_OnUnserialize(struct __ecereNameSpace__ecere__com__Class * class, struct __ecereNameSpace__ecere__com__StaticString * this, struct __ecereNameSpace__ecere__com__Instance * channel)
1751 {
1752 if(this)
1753 {
1754 int c;
1755
1756 for(c = 0; ((unsigned int (*)(struct __ecereNameSpace__ecere__com__Instance *, void *  data, unsigned int numBytes))__extension__ ({
1757 struct __ecereNameSpace__ecere__com__Instance * __internal_ClassInst = channel;
1758
1759 __internal_ClassInst ? __internal_ClassInst->_vTbl : __ecereClass___ecereNameSpace__ecere__com__IOChannel->_vTbl;
1760 })[__ecereVMethodID___ecereNameSpace__ecere__com__IOChannel_ReadData])(channel, &(*this).string[c], 1) && (*this).string[c]; c++)
1761 ;
1762 (*this).string[c++] = '\0';
1763 }
1764 }
1765
1766 static void __ecereNameSpace__ecere__com__String_OnSerialize(struct __ecereNameSpace__ecere__com__Class * _class, char * string, struct __ecereNameSpace__ecere__com__Instance * channel)
1767 {
1768 int len = string ? strlen(string) : 0;
1769
1770 ((unsigned int (*)(struct __ecereNameSpace__ecere__com__Instance *, const void *  data, unsigned int numBytes))__extension__ ({
1771 struct __ecereNameSpace__ecere__com__Instance * __internal_ClassInst = channel;
1772
1773 __internal_ClassInst ? __internal_ClassInst->_vTbl : __ecereClass___ecereNameSpace__ecere__com__IOChannel->_vTbl;
1774 })[__ecereVMethodID___ecereNameSpace__ecere__com__IOChannel_WriteData])(channel, string ? string : "", len + 1);
1775 }
1776
1777 static void __ecereNameSpace__ecere__com__String_OnUnserialize(struct __ecereNameSpace__ecere__com__Class * _class, char ** string, struct __ecereNameSpace__ecere__com__Instance * channel)
1778 {
1779 if(string)
1780 {
1781 int c;
1782 unsigned int size = 64;
1783
1784 *string = __ecereNameSpace__ecere__com__eSystem_New(sizeof(char) * (size));
1785 for(c = 0; ((unsigned int (*)(struct __ecereNameSpace__ecere__com__Instance *, void *  data, unsigned int numBytes))__extension__ ({
1786 struct __ecereNameSpace__ecere__com__Instance * __internal_ClassInst = channel;
1787
1788 __internal_ClassInst ? __internal_ClassInst->_vTbl : __ecereClass___ecereNameSpace__ecere__com__IOChannel->_vTbl;
1789 })[__ecereVMethodID___ecereNameSpace__ecere__com__IOChannel_ReadData])(channel, &(*string)[c], 1) && (*string)[c]; c++)
1790 {
1791 if(c == size - 1)
1792 {
1793 size += size / 2;
1794 *string = __ecereNameSpace__ecere__com__eSystem_Renew(*string, sizeof(char) * (size));
1795 }
1796 }
1797 (*string)[c++] = '\0';
1798 if(!__ecereNameSpace__ecere__sys__UTF8Validate(*string))
1799 {
1800 char * newString = __ecereNameSpace__ecere__com__eSystem_New(sizeof(char) * (c * 2));
1801
1802 __ecereNameSpace__ecere__sys__ISO8859_1toUTF8(*string, newString, c * 2);
1803 (__ecereNameSpace__ecere__com__eSystem_Delete(*string), *string = 0);
1804 *string = __ecereNameSpace__ecere__com__eSystem_Renew(newString, sizeof(char) * (strlen(newString) + 1));
1805 }
1806 else
1807 *string = __ecereNameSpace__ecere__com__eSystem_Renew(*string, sizeof(char) * (c));
1808 }
1809 }
1810
1811 unsigned int __ecereMethod___ecereNameSpace__ecere__com__SerialBuffer_WriteData(struct __ecereNameSpace__ecere__com__Instance * this, const void * bytes, unsigned int numBytes)
1812 {
1813 __attribute__((unused)) struct __ecereNameSpace__ecere__com__SerialBuffer * __ecerePointer___ecereNameSpace__ecere__com__SerialBuffer = (struct __ecereNameSpace__ecere__com__SerialBuffer *)(this ? (((char *)this) + __ecereClass___ecereNameSpace__ecere__com__SerialBuffer->offset) : 0);
1814
1815 if(this != (((void *)0)))
1816 {
1817 if(__ecerePointer___ecereNameSpace__ecere__com__SerialBuffer->count + numBytes > __ecerePointer___ecereNameSpace__ecere__com__SerialBuffer->_size)
1818 {
1819 __ecerePointer___ecereNameSpace__ecere__com__SerialBuffer->_size = __ecerePointer___ecereNameSpace__ecere__com__SerialBuffer->count + numBytes;
1820 __ecerePointer___ecereNameSpace__ecere__com__SerialBuffer->_size += __ecerePointer___ecereNameSpace__ecere__com__SerialBuffer->_size / 2;
1821 __ecerePointer___ecereNameSpace__ecere__com__SerialBuffer->_buffer = __ecereNameSpace__ecere__com__eSystem_Renew(__ecerePointer___ecereNameSpace__ecere__com__SerialBuffer->_buffer, sizeof(unsigned char) * (__ecerePointer___ecereNameSpace__ecere__com__SerialBuffer->_size));
1822 }
1823 memcpy(__ecerePointer___ecereNameSpace__ecere__com__SerialBuffer->_buffer + __ecerePointer___ecereNameSpace__ecere__com__SerialBuffer->count, bytes, numBytes);
1824 __ecerePointer___ecereNameSpace__ecere__com__SerialBuffer->count += numBytes;
1825 return numBytes;
1826 }
1827 return 0;
1828 }
1829
1830 unsigned int __ecereMethod___ecereNameSpace__ecere__com__SerialBuffer_ReadData(struct __ecereNameSpace__ecere__com__Instance * this, void * bytes, unsigned int numBytes)
1831 {
1832 __attribute__((unused)) struct __ecereNameSpace__ecere__com__SerialBuffer * __ecerePointer___ecereNameSpace__ecere__com__SerialBuffer = (struct __ecereNameSpace__ecere__com__SerialBuffer *)(this ? (((char *)this) + __ecereClass___ecereNameSpace__ecere__com__SerialBuffer->offset) : 0);
1833
1834 if(this != (((void *)0)))
1835 {
1836 unsigned int __simpleStruct0;
1837 int read = (__simpleStruct0 = __ecerePointer___ecereNameSpace__ecere__com__SerialBuffer->count - __ecerePointer___ecereNameSpace__ecere__com__SerialBuffer->pos, (numBytes < __simpleStruct0) ? numBytes : __simpleStruct0);
1838
1839 memcpy(bytes, __ecerePointer___ecereNameSpace__ecere__com__SerialBuffer->_buffer + __ecerePointer___ecereNameSpace__ecere__com__SerialBuffer->pos, read);
1840 __ecerePointer___ecereNameSpace__ecere__com__SerialBuffer->pos += read;
1841 return read;
1842 }
1843 return 0;
1844 }
1845
1846 void __ecereMethod___ecereNameSpace__ecere__com__SerialBuffer_Free(struct __ecereNameSpace__ecere__com__Instance * this)
1847 {
1848 __attribute__((unused)) struct __ecereNameSpace__ecere__com__SerialBuffer * __ecerePointer___ecereNameSpace__ecere__com__SerialBuffer = (struct __ecereNameSpace__ecere__com__SerialBuffer *)(this ? (((char *)this) + __ecereClass___ecereNameSpace__ecere__com__SerialBuffer->offset) : 0);
1849
1850 if(this)
1851 {
1852 (__ecereNameSpace__ecere__com__eSystem_Delete(__ecerePointer___ecereNameSpace__ecere__com__SerialBuffer->_buffer), __ecerePointer___ecereNameSpace__ecere__com__SerialBuffer->_buffer = 0);
1853 __ecerePointer___ecereNameSpace__ecere__com__SerialBuffer->count = 0;
1854 __ecerePointer___ecereNameSpace__ecere__com__SerialBuffer->_size = 0;
1855 __ecerePointer___ecereNameSpace__ecere__com__SerialBuffer->pos = 0;
1856 }
1857 }
1858
1859 unsigned char *  __ecereProp___ecereNameSpace__ecere__com__SerialBuffer_Get_buffer(struct __ecereNameSpace__ecere__com__Instance * this)
1860 {
1861 __attribute__((unused)) struct __ecereNameSpace__ecere__com__SerialBuffer * __ecerePointer___ecereNameSpace__ecere__com__SerialBuffer = (struct __ecereNameSpace__ecere__com__SerialBuffer *)(this ? (((char *)this) + __ecereClass___ecereNameSpace__ecere__com__SerialBuffer->offset) : 0);
1862
1863 return __ecerePointer___ecereNameSpace__ecere__com__SerialBuffer->_buffer + __ecerePointer___ecereNameSpace__ecere__com__SerialBuffer->pos;
1864 }
1865
1866 void __ecereProp___ecereNameSpace__ecere__com__SerialBuffer_Set_buffer(struct __ecereNameSpace__ecere__com__Instance * this, unsigned char *  value)
1867 {
1868 __attribute__((unused)) struct __ecereNameSpace__ecere__com__SerialBuffer * __ecerePointer___ecereNameSpace__ecere__com__SerialBuffer = (struct __ecereNameSpace__ecere__com__SerialBuffer *)(this ? (((char *)this) + __ecereClass___ecereNameSpace__ecere__com__SerialBuffer->offset) : 0);
1869
1870 __ecerePointer___ecereNameSpace__ecere__com__SerialBuffer->_buffer = value;
1871 __ecereNameSpace__ecere__com__eInstance_FireSelfWatchers(this, __ecereProp___ecereNameSpace__ecere__com__SerialBuffer_buffer), __ecereNameSpace__ecere__com__eInstance_FireSelfWatchers(this, __ecerePropM___ecereNameSpace__ecere__com__SerialBuffer_buffer);
1872 }
1873
1874 unsigned int __ecereProp___ecereNameSpace__ecere__com__SerialBuffer_Get_size(struct __ecereNameSpace__ecere__com__Instance * this)
1875 {
1876 __attribute__((unused)) struct __ecereNameSpace__ecere__com__SerialBuffer * __ecerePointer___ecereNameSpace__ecere__com__SerialBuffer = (struct __ecereNameSpace__ecere__com__SerialBuffer *)(this ? (((char *)this) + __ecereClass___ecereNameSpace__ecere__com__SerialBuffer->offset) : 0);
1877
1878 return __ecerePointer___ecereNameSpace__ecere__com__SerialBuffer->count - __ecerePointer___ecereNameSpace__ecere__com__SerialBuffer->pos;
1879 }
1880
1881 void __ecereProp___ecereNameSpace__ecere__com__SerialBuffer_Set_size(struct __ecereNameSpace__ecere__com__Instance * this, unsigned int value)
1882 {
1883 __attribute__((unused)) struct __ecereNameSpace__ecere__com__SerialBuffer * __ecerePointer___ecereNameSpace__ecere__com__SerialBuffer = (struct __ecereNameSpace__ecere__com__SerialBuffer *)(this ? (((char *)this) + __ecereClass___ecereNameSpace__ecere__com__SerialBuffer->offset) : 0);
1884
1885 __ecerePointer___ecereNameSpace__ecere__com__SerialBuffer->count = value;
1886 __ecereNameSpace__ecere__com__eInstance_FireSelfWatchers(this, __ecereProp___ecereNameSpace__ecere__com__SerialBuffer_size), __ecereNameSpace__ecere__com__eInstance_FireSelfWatchers(this, __ecerePropM___ecereNameSpace__ecere__com__SerialBuffer_size);
1887 }
1888
1889 static int __ecereNameSpace__ecere__com__OnCompare(struct __ecereNameSpace__ecere__com__Class * _class, void * data1, void * data2)
1890 {
1891 struct __ecereNameSpace__ecere__com__Instance * module = _class->module;
1892
1893 if(_class->type == 0 || _class->type == 5 || _class->type == 1)
1894 {
1895 if(data1 && data2)
1896 {
1897 for(; _class && _class->type != 1000; _class = _class->base)
1898 {
1899 struct __ecereNameSpace__ecere__com__DataMember * member;
1900
1901 if(_class->noExpansion)
1902 {
1903 if(data1 > data2)
1904 return 1;
1905 else if(data1 < data2)
1906 return -1;
1907 else
1908 return 0;
1909 }
1910 for(member = _class->membersAndProperties.first; member; member = member->next)
1911 {
1912 int memberResult = 0;
1913
1914 if(member->id < 0)
1915 continue;
1916 if(member->isProperty || member->type == 0)
1917 {
1918 struct __ecereNameSpace__ecere__com__Class * memberType = member->dataTypeClass;
1919
1920 if(!memberType)
1921 memberType = member->dataTypeClass = __ecereNameSpace__ecere__com__eSystem_FindClass(module, member->dataTypeString);
1922 if(memberType)
1923 {
1924 if(member->isProperty)
1925 {
1926 struct __ecereNameSpace__ecere__com__Property * prop = (struct __ecereNameSpace__ecere__com__Property *)member;
1927
1928 if(!prop->conversion && prop->Get && prop->Set)
1929 {
1930 if(memberType->type == 1 || memberType->type == 0 || memberType->type == 5)
1931 {
1932 if(!strcmp(memberType->dataTypeString, "char *"))
1933 {
1934 char * a = ((char * (*)(void *))(void *)prop->Get)(data1);
1935 char * b = ((char * (*)(void *))(void *)prop->Get)(data2);
1936
1937 memberResult = ((int (*)(void *, void *, void *))(void *)memberType->_vTbl[__ecereVMethodID_class_OnCompare])(memberType, a, b);
1938 }
1939 }
1940 else
1941 {
1942 struct __ecereNameSpace__ecere__com__DataValue value1, value2;
1943
1944 if(!strcmp(memberType->dataTypeString, "float"))
1945 {
1946 value1.__anon1.f = ((float (*)(void *))(void *)prop->Get)(data1);
1947 value2.__anon1.f = ((float (*)(void *))(void *)prop->Get)(data2);
1948 }
1949 else
1950 {
1951 value1.__anon1.i = ((int (*)(void *))(void *)prop->Get)(data1);
1952 value2.__anon1.i = ((int (*)(void *))(void *)prop->Get)(data2);
1953 }
1954 memberResult = ((int (*)(void *, void *, void *))(void *)memberType->_vTbl[__ecereVMethodID_class_OnCompare])(memberType, &value1, &value2);
1955 }
1956 }
1957 }
1958 else
1959 {
1960 if(memberType->type == 1 || memberType->type == 0 || memberType->type == 5)
1961 {
1962 if(memberType->type == 0 || memberType->type == 5)
1963 {
1964 memberResult = ((int (*)(void *, void *, void *))(void *)memberType->_vTbl[__ecereVMethodID_class_OnCompare])(memberType, *(void **)((unsigned char *)data1 + (((member->_class->type == 0) ? member->_class->offset : 0) + member->offset)), *(void **)((unsigned char *)data2 + (((member->_class->type == 0) ? member->_class->offset : 0) + member->offset)));
1965 }
1966 else
1967 {
1968 memberResult = ((int (*)(void *, void *, void *))(void *)memberType->_vTbl[__ecereVMethodID_class_OnCompare])(memberType, (unsigned char *)data1 + (((member->_class->type == 0) ? member->_class->offset : 0) + member->offset), (unsigned char *)data2 + (((member->_class->type == 0) ? member->_class->offset : 0) + member->offset));
1969 }
1970 }
1971 else
1972 {
1973 struct __ecereNameSpace__ecere__com__DataValue value1, value2;
1974
1975 if(memberType->typeSize == 8)
1976 {
1977 value1.__anon1.ui64 = *(uint64 *)((unsigned char *)data1 + (((member->_class->type == 0) ? member->_class->offset : 0) + member->offset));
1978 value2.__anon1.ui64 = *(uint64 *)((unsigned char *)data2 + (((member->_class->type == 0) ? member->_class->offset : 0) + member->offset));
1979 }
1980 else
1981 {
1982 value1.__anon1.i = *(int *)((unsigned char *)data1 + (((member->_class->type == 0) ? member->_class->offset : 0) + member->offset));
1983 value2.__anon1.i = *(int *)((unsigned char *)data2 + (((member->_class->type == 0) ? member->_class->offset : 0) + member->offset));
1984 }
1985 memberResult = ((int (*)(void *, void *, void *))(void *)memberType->_vTbl[__ecereVMethodID_class_OnCompare])(memberType, &value1, &value2);
1986 }
1987 }
1988 }
1989 else
1990 {
1991 }
1992 }
1993 else
1994 {
1995 memberResult = __ecereNameSpace__ecere__com__DataMember_OnCompare(member, (unsigned char *)data1 + (((member->_class->type == 0) ? member->_class->offset : 0) + member->offset), (unsigned char *)data2 + (((member->_class->type == 0) ? member->_class->offset : 0) + member->offset));
1996 }
1997 if(memberResult)
1998 return memberResult;
1999 }
2000 }
2001 }
2002 else if(!data1 && data2)
2003 return 1;
2004 else if(data1 && !data2)
2005 return -1;
2006 }
2007 else if(_class->type == 3)
2008 {
2009 struct __ecereNameSpace__ecere__com__Class * dataType = __ecereNameSpace__ecere__com__eSystem_FindClass(module, _class->dataTypeString);
2010
2011 return ((int (*)(void *, void *, void *))(void *)dataType->_vTbl[__ecereVMethodID_class_OnCompare])(dataType, data1, data2);
2012 }
2013 else
2014 {
2015 int result = 0;
2016
2017 if(data1 && data2)
2018 {
2019 if(_class->typeSize == 8)
2020 {
2021 if(*(uint64 *)data1 > *(uint64 *)data2)
2022 result = 1;
2023 else if(*(uint64 *)data1 < *(uint64 *)data2)
2024 result = -1;
2025 }
2026 else
2027 {
2028 if(*(unsigned int *)data1 > *(unsigned int *)data2)
2029 result = 1;
2030 else if(*(unsigned int *)data1 < *(unsigned int *)data2)
2031 result = -1;
2032 }
2033 }
2034 else if(!data1 && data2)
2035 return 1;
2036 else if(data1 && !data2)
2037 return -1;
2038 return result;
2039 }
2040 return 0;
2041 }
2042
2043 static void __ecereNameSpace__ecere__com__OnSerialize(struct __ecereNameSpace__ecere__com__Class * _class, void * data, struct __ecereNameSpace__ecere__com__Instance * channel)
2044 {
2045 struct __ecereNameSpace__ecere__com__Instance * module = _class->module;
2046
2047 if(_class->type == 3 || _class->type == 2 || _class->type == 4)
2048 {
2049 struct __ecereNameSpace__ecere__com__Class * dataType = __ecereNameSpace__ecere__com__eSystem_FindClass(module, _class->dataTypeString);
2050
2051 if(dataType)
2052 ((void (*)(void *, void *, void *))(void *)dataType->_vTbl[__ecereVMethodID_class_OnSerialize])(dataType, data, channel);
2053 }
2054 else if(_class->type == 0 || _class->type == 5 || _class->type == 1)
2055 {
2056 {
2057 struct __ecereNameSpace__ecere__com__Class * lastClass = (((void *)0));
2058
2059 while(lastClass != _class)
2060 {
2061 struct __ecereNameSpace__ecere__com__DataMember * member;
2062 struct __ecereNameSpace__ecere__com__Class * c;
2063
2064 for(c = _class; c && (!c->base || c->base->type != 1000) && c->base != lastClass; c = c->base)
2065 ;
2066 lastClass = c;
2067 for(member = c->membersAndProperties.first; member; member = member->next)
2068 {
2069 if(member->id < 0)
2070 continue;
2071 if(member->isProperty || member->type == 0)
2072 {
2073 struct __ecereNameSpace__ecere__com__Class * memberType = member->dataTypeClass;
2074
2075 if(!memberType)
2076 memberType = member->dataTypeClass = __ecereNameSpace__ecere__com__eSystem_FindClass(module, member->dataTypeString);
2077 if(memberType)
2078 {
2079 if(member->isProperty)
2080 {
2081 }
2082 else
2083 {
2084 if(!strcmp(memberType->name, "String") || memberType->type == 0 || memberType->type == 5)
2085 {
2086 ((void (*)(void *, void *, void *))(void *)memberType->_vTbl[__ecereVMethodID_class_OnSerialize])(memberType, data ? (*(void **)((unsigned char *)data + member->_class->offset + member->offset)) : (((void *)0)), channel);
2087 }
2088 else
2089 ((void (*)(void *, void *, void *))(void *)memberType->_vTbl[__ecereVMethodID_class_OnSerialize])(memberType, data ? (((unsigned char *)data + (((member->_class->type == 0) ? member->_class->offset : 0) + member->offset))) : (((void *)0)), channel);
2090 }
2091 }
2092 else
2093 {
2094 }
2095 }
2096 else
2097 {
2098 __ecereNameSpace__ecere__com__DataMember_OnSerialize(member, data ? ((unsigned char *)data + (((member->_class->type == 0) ? member->_class->offset : 0) + member->offset)) : (((void *)0)), channel);
2099 }
2100 }
2101 }
2102 }
2103 }
2104 }
2105
2106 int __ecereNameSpace__ecere__com__PrintBuf(char * buffer, int maxLen, struct __ecereNameSpace__ecere__com__Class * class, const void * object, ...)
2107 {
2108 va_list args;
2109 int len;
2110
2111 __builtin_va_start(args, object);
2112 len = __ecereNameSpace__ecere__com__PrintStdArgsToBuffer(buffer, maxLen, class, object, args);
2113 __builtin_va_end(args);
2114 return len;
2115 }
2116
2117 int __ecereNameSpace__ecere__com__PrintLnBuf(char * buffer, int maxLen, struct __ecereNameSpace__ecere__com__Class * class, const void * object, ...)
2118 {
2119 va_list args;
2120 int len;
2121
2122 __builtin_va_start(args, object);
2123 len = __ecereNameSpace__ecere__com__PrintStdArgsToBuffer(buffer, maxLen - 1, class, object, args);
2124 buffer[len++] = '\n';
2125 buffer[len] = '\0';
2126 __builtin_va_end(args);
2127 return len;
2128 }
2129
2130 char * __ecereNameSpace__ecere__com__PrintString(struct __ecereNameSpace__ecere__com__Class * class, const void * object, ...)
2131 {
2132 char buffer[4096];
2133 va_list args;
2134 char * string;
2135 int len;
2136
2137 __builtin_va_start(args, object);
2138 len = __ecereNameSpace__ecere__com__PrintStdArgsToBuffer(buffer, sizeof (buffer), class, object, args);
2139 string = __ecereNameSpace__ecere__com__eSystem_New(sizeof(char) * (len + 1));
2140 memcpy(string, buffer, len + 1);
2141 __builtin_va_end(args);
2142 return string;
2143 }
2144
2145 char * __ecereNameSpace__ecere__com__PrintLnString(struct __ecereNameSpace__ecere__com__Class * class, const void * object, ...)
2146 {
2147 char buffer[4096];
2148 va_list args;
2149 char * string;
2150 int len;
2151
2152 __builtin_va_start(args, object);
2153 len = __ecereNameSpace__ecere__com__PrintStdArgsToBuffer(buffer, sizeof (buffer), class, object, args);
2154 string = __ecereNameSpace__ecere__com__eSystem_New(sizeof(char) * (len + 2));
2155 memcpy(string, buffer, len);
2156 string[len++] = '\n';
2157 string[len] = '\0';
2158 __builtin_va_end(args);
2159 return string;
2160 }
2161
2162 void __ecereNameSpace__ecere__com__PrintLn(struct __ecereNameSpace__ecere__com__Class * class, const void * object, ...)
2163 {
2164 va_list args;
2165 char buffer[4096];
2166
2167 __builtin_va_start(args, object);
2168 __ecereNameSpace__ecere__com__PrintStdArgsToBuffer(buffer, sizeof (buffer), class, object, args);
2169 __builtin_va_end(args);
2170 puts(buffer);
2171 }
2172
2173 void __ecereNameSpace__ecere__com__Print(struct __ecereNameSpace__ecere__com__Class * class, const void * object, ...)
2174 {
2175 va_list args;
2176 char buffer[4096];
2177
2178 __builtin_va_start(args, object);
2179 __ecereNameSpace__ecere__com__PrintStdArgsToBuffer(buffer, sizeof (buffer), class, object, args);
2180 __builtin_va_end(args);
2181 fputs(buffer, eC_stdout());
2182 }
2183
2184 __attribute__((unused)) static void __ecereNameSpace__ecere__com__UnusedFunction()
2185 {
2186 int __internalValue001;
2187 int __internalValue000;
2188 int a;
2189
2190 ((const char *  (*)(struct __ecereNameSpace__ecere__com__Class *, const void *, char *  tempString, void *  fieldData, unsigned int *  needClass))__ecereClass_int->_vTbl[__ecereVMethodID_class_OnGetString])(__ecereClass_int, (void *)&a, 0, 0, 0);
2191 ((void (*)(struct __ecereNameSpace__ecere__com__Class *, const void *))__ecereClass_int->_vTbl[__ecereVMethodID_class_OnFree])(__ecereClass_int, (void *)&a);
2192 ((void (*)(struct __ecereNameSpace__ecere__com__Class *, const void *, const void * newData))__ecereClass_int->_vTbl[__ecereVMethodID_class_OnCopy])(__ecereClass_int, (void *)&a, __extension__ ({
2193 __internalValue000 = 0;
2194 &__internalValue000;
2195 }));
2196 ((int (*)(struct __ecereNameSpace__ecere__com__Class *, const void *, const void * object))__ecereClass_int->_vTbl[__ecereVMethodID_class_OnCompare])(__ecereClass_int, (void *)&a, __extension__ ({
2197 __internalValue001 = 0;
2198 &__internalValue001;
2199 }));
2200 ((unsigned int (*)(struct __ecereNameSpace__ecere__com__Class *, const void *, struct __ecereNameSpace__ecere__com__Instance * window, void *  object))__ecereClass_int->_vTbl[__ecereVMethodID_class_OnSaveEdit])(__ecereClass_int, (void *)&a, (((void *)0)), 0);
2201 ((struct __ecereNameSpace__ecere__com__Instance * (*)(struct __ecereNameSpace__ecere__com__Class *, const void *, struct __ecereNameSpace__ecere__com__Instance * dataBox, struct __ecereNameSpace__ecere__com__Instance * obsolete, int x, int y, int w, int h, void *  userData))__ecereClass_int->_vTbl[__ecereVMethodID_class_OnEdit])(__ecereClass_int, (void *)&a, (((void *)0)), (((void *)0)), 0, 0, 0, 20, 0);
2202 ((unsigned int (*)(struct __ecereNameSpace__ecere__com__Class *, const void *, const char *  string))__ecereClass_int->_vTbl[__ecereVMethodID_class_OnGetDataFromString])(__ecereClass_int, (void *)&a, (((void *)0)));
2203 }
2204
2205 static const char * __ecereNameSpace__ecere__com__OnGetString(struct __ecereNameSpace__ecere__com__Class * _class, void * data, char * tempString, void * fieldData, unsigned int * needClass)
2206 {
2207 struct __ecereNameSpace__ecere__com__Instance * module = _class->templateClass ? _class->templateClass->module : _class->module;
2208
2209 if(_class->type == 0 && _class->base && !_class->base->base)
2210 {
2211 if(sizeof(size_t) == 8)
2212 return __ecereNameSpace__ecere__com__UInt64Hex_OnGetString(_class, (void *)&data, tempString, fieldData, needClass);
2213 else
2214 return __ecereNameSpace__ecere__com__UIntegerHex_OnGetString(_class, (void *)&data, tempString, fieldData, needClass);
2215 }
2216 else if(_class->type == 4)
2217 {
2218 return __ecereNameSpace__ecere__com__Enum_OnGetString(_class, data, tempString, fieldData, needClass);
2219 }
2220 else if(_class->type == 3)
2221 {
2222 struct __ecereNameSpace__ecere__com__Class * dataType;
2223 struct __ecereNameSpace__ecere__com__Property * prop;
2224
2225 for(prop = _class->conversions.first; prop; prop = prop->next)
2226 {
2227 unsigned int refProp = 0;
2228 struct __ecereNameSpace__ecere__com__Class * c;
2229
2230 if(!strcmp(prop->name, _class->base->fullName))
2231 refProp = 1;
2232 else if((c = __ecereNameSpace__ecere__com__eSystem_FindClass(_class->module, prop->name)))
2233 {
2234 struct __ecereNameSpace__ecere__com__Property * p;
2235
2236 for(p = c->conversions.first; p; p = p->next)
2237 {
2238 if(!strcmp(p->name, _class->base->fullName) && !p->Set && !p->Get)
2239 {
2240 refProp = 1;
2241 break;
2242 }
2243 }
2244 }
2245 if(refProp)
2246 {
2247 if(prop->Set && prop->Get)
2248 {
2249 const char * dts = _class->base->dataTypeString;
2250
2251 if(!strcmp(dts, "double"))
2252 {
2253 double d = ((double (*)(double))(void *)prop->Set)(*(double *)data);
2254
2255 return ((const char * (*)(void *, void *, char *, void *, unsigned int *))(void *)__ecereClass_double->_vTbl[__ecereVMethodID_class_OnGetString])(__ecereClass_double, &d, tempString, fieldData, needClass);
2256 }
2257 else if(!strcmp(dts, "float"))
2258 {
2259 float d = ((float (*)(float))(void *)prop->Set)(*(float *)data);
2260
2261 return ((const char * (*)(void *, void *, char *, void *, unsigned int *))(void *)__ecereClass_float->_vTbl[__ecereVMethodID_class_OnGetString])(__ecereClass_float, &d, tempString, fieldData, needClass);
2262 }
2263 else if(!strcmp(dts, "int"))
2264 {
2265 int d = ((int (*)(int))(void *)prop->Set)(*(int *)data);
2266
2267 return ((const char * (*)(void *, void *, char *, void *, unsigned int *))(void *)__ecereClass_int->_vTbl[__ecereVMethodID_class_OnGetString])(__ecereClass_int, &d, tempString, fieldData, needClass);
2268 }
2269 else if(!strcmp(dts, "int64"))
2270 {
2271 long long d = ((long long (*)(long long))(void *)prop->Set)(*(long long *)data);
2272
2273 return ((const char * (*)(void *, void *, char *, void *, unsigned int *))(void *)__ecereClass_int64->_vTbl[__ecereVMethodID_class_OnGetString])(__ecereClass_int64, &d, tempString, fieldData, needClass);
2274 }
2275 }
2276 else
2277 break;
2278 }
2279 }
2280 dataType = __ecereNameSpace__ecere__com__eSystem_FindClass(module, _class->dataTypeString);
2281 return ((const char * (*)(void *, void *, char *, void *, unsigned int *))(void *)dataType->_vTbl[__ecereVMethodID_class_OnGetString])(dataType, data, tempString, fieldData, needClass);
2282 }
2283 else
2284 {
2285 unsigned int atMember = 1;
2286 unsigned int prev = 0;
2287 struct __ecereNameSpace__ecere__com__Class * mainClass = _class;
2288
2289 _class = (((void *)0));
2290 tempString[0] = '\0';
2291 if(!data && (mainClass->type == 0 || mainClass->type == 5))
2292 return tempString;
2293 while(_class != mainClass)
2294 {
2295 struct __ecereNameSpace__ecere__com__DataMember * member;
2296 struct __ecereNameSpace__ecere__com__Class * lastClass = _class;
2297
2298 for(_class = mainClass; _class->base != lastClass && _class->base->type != 1000; _class = _class->base)
2299 ;
2300 for(member = _class->membersAndProperties.first; member; member = member->next)
2301 {
2302 char memberString[1024];
2303 struct __ecereNameSpace__ecere__com__Class * memberType = member->dataTypeClass;
2304 const char * name = member->name;
2305
2306 if(member->id < 0)
2307 continue;
2308 memberString[0] = (char)0;
2309 if(!memberType)
2310 memberType = member->dataTypeClass = __ecereNameSpace__ecere__com__eSystem_FindClass(module, member->dataTypeString);
2311 if(!memberType)
2312 memberType = member->dataTypeClass = __ecereNameSpace__ecere__com__eSystem_FindClass(module, "int");
2313 if(member->isProperty)
2314 {
2315 struct __ecereNameSpace__ecere__com__Property * prop = (struct __ecereNameSpace__ecere__com__Property *)member;
2316
2317 if(!prop->conversion && prop->Get && prop->Set && (!prop->IsSet || prop->IsSet(data)))
2318 {
2319 if(memberType->type != 1 && (memberType->type != 0 || !strcmp(memberType->dataTypeString, "char *")) && memberType->type != 2 && data)
2320 {
2321 struct __ecereNameSpace__ecere__com__DataValue value =
2322 {
2323
2324 .__anon1 = {
2325 .c = 0
2326 }
2327 };
2328
2329 if(!strcmp(prop->dataTypeString, "float"))
2330 {
2331 value.__anon1.f = ((float (*)(void *))(void *)prop->Get)(data);
2332 if(value.__anon1.f)
2333 {
2334 unsigned int needClass = 1;
2335 const char * result = ((const char * (*)(void *, void *, char *, void *, unsigned int *))(void *)memberType->_vTbl[__ecereVMethodID_class_OnGetString])(memberType, &value, memberString, (((void *)0)), &needClass);
2336
2337 if(result && result != memberString)
2338 strcpy(memberString, result);
2339 if(strchr(memberString, '.'))
2340 strcat(memberString, "f");
2341 }
2342 }
2343 else if(memberType->type == 0 || memberType->type == 5)
2344 {
2345 value.__anon1.p = ((void * (*)(void *))(void *)prop->Get)(data);
2346 if(value.__anon1.p || prop->IsSet)
2347 {
2348 unsigned int needClass = 1;
2349 const char * result = ((const char * (*)(void *, void *, char *, void *, unsigned int *))(void *)memberType->_vTbl[__ecereVMethodID_class_OnGetString])(memberType, (memberType->type == 0) ? value.__anon1.p : &value, memberString, (((void *)0)), &needClass);
2350
2351 if(result && result != memberString)
2352 strcpy(memberString, result);
2353 }
2354 }
2355 else
2356 {
2357 value.__anon1.i = ((int (*)(void *))(void *)prop->Get)(data);
2358 if(value.__anon1.i || prop->IsSet)
2359 {
2360 unsigned int needClass = 1;
2361 const char * result = ((const char * (*)(void *, void *, char *, void *, unsigned int *))(void *)memberType->_vTbl[__ecereVMethodID_class_OnGetString])(memberType, &value, memberString, (((void *)0)), &needClass);
2362
2363 if(result && result != memberString)
2364 strcpy(memberString, result);
2365 }
2366 }
2367 }
2368 }
2369 }
2370 else
2371 {
2372 if(member->type == 0)
2373 {
2374 if(memberType->type == 1 || memberType->type == 0)
2375 {
2376 char internalMemberString[1024];
2377 unsigned char * memberData = ((unsigned char *)data + (((member->_class->type == 0) ? member->_class->offset : 0) + member->offset));
2378 int c;
2379 unsigned int typeSize = (memberType->type == 0) ? memberType->typeSize : memberType->structSize;
2380
2381 for(c = 0; c < typeSize; c++)
2382 if(memberData[c])
2383 break;
2384 if(c < typeSize)
2385 {
2386 unsigned int needClass = 1;
2387 const char * result;
2388
2389 if(memberType->type == 0)
2390 result = ((const char * (*)(void *, void *, char *, void *, unsigned int *))(void *)memberType->_vTbl[__ecereVMethodID_class_OnGetString])(memberType, *(struct __ecereNameSpace__ecere__com__Instance **)memberData, internalMemberString, (((void *)0)), &needClass);
2391 else
2392 result = ((const char * (*)(void *, void *, char *, void *, unsigned int *))(void *)memberType->_vTbl[__ecereVMethodID_class_OnGetString])(memberType, memberData, internalMemberString, (((void *)0)), &needClass);
2393 if(needClass && strcmp(memberType->dataTypeString, "char *"))
2394 {
2395 strcat(memberString, "{ ");
2396 if(result)
2397 strcat(memberString, result);
2398 strcat(memberString, " }");
2399 }
2400 else if(result)
2401 strcpy(memberString, result);
2402 }
2403 }
2404 else
2405 {
2406 struct __ecereNameSpace__ecere__com__DataValue value =
2407 {
2408
2409 .__anon1 = {
2410 .c = 0
2411 }
2412 };
2413
2414 if(_class->type == 2)
2415 {
2416 struct __ecereNameSpace__ecere__com__BitMember * bitMember = (struct __ecereNameSpace__ecere__com__BitMember *)member;
2417
2418 value.__anon1.ui64 = ((*(unsigned int *)data & bitMember->mask) >> bitMember->pos);
2419 if(value.__anon1.ui64)
2420 {
2421 unsigned int needClass = 1;
2422 char internalMemberString[1024];
2423 const char * result = ((const char * (*)(void *, void *, char *, void *, unsigned int *))(void *)memberType->_vTbl[__ecereVMethodID_class_OnGetString])(memberType, &value, internalMemberString, (((void *)0)), &needClass);
2424
2425 if(needClass && memberType->type != 1000 && memberType->type != 4 && memberType->type != 3)
2426 {
2427 strcat(memberString, " { ");
2428 if(result)
2429 strcat(memberString, result);
2430 strcat(memberString, " }");
2431 }
2432 else if(result)
2433 strcpy(memberString, result);
2434 }
2435 }
2436 else if(!memberType->noExpansion)
2437 {
2438 if(memberType->typeSize <= 4)
2439 {
2440 value.__anon1.i = *(int *)((unsigned char *)data + (((member->_class->type == 0) ? member->_class->offset : 0) + member->offset));
2441 if(value.__anon1.i)
2442 {
2443 unsigned int needClass = 1;
2444 const char * result = ((const char * (*)(void *, void *, char *, void *, unsigned int *))(void *)memberType->_vTbl[__ecereVMethodID_class_OnGetString])(memberType, &value, memberString, (((void *)0)), &needClass);
2445
2446 if(result && memberString != result)
2447 strcpy(memberString, result);
2448 }
2449 }
2450 else
2451 {
2452 unsigned int needClass = 1;
2453 const char * result = ((const char * (*)(void *, void *, char *, void *, unsigned int *))(void *)memberType->_vTbl[__ecereVMethodID_class_OnGetString])(memberType, ((unsigned char *)data + (((member->_class->type == 0) ? member->_class->offset : 0) + member->offset)), memberString, (((void *)0)), &needClass);
2454
2455 if(result && memberString != result)
2456 strcpy(memberString, result);
2457 }
2458 }
2459 }
2460 }
2461 }
2462 if(memberString[0])
2463 {
2464 if(prev)
2465 strcat(tempString, ", ");
2466 if(!atMember || !strcmp(memberType->name, "bool"))
2467 {
2468 strcat(tempString, name);
2469 strcat(tempString, " = ");
2470 }
2471 if(!strcmp(memberType->name, "char *"))
2472 {
2473 int len = strlen(tempString);
2474 int c;
2475
2476 strcat(tempString, "\"");
2477 len++;
2478 for(c = 0; memberString[c]; c++)
2479 {
2480 if(memberString[c] == '\"')
2481 {
2482 strcat(tempString, "\\\"");
2483 len += 2;
2484 }
2485 else if(memberString[c] == '\\')
2486 {
2487 strcat(tempString, "\\\\");
2488 len += 2;
2489 }
2490 else
2491 {
2492 tempString[len++] = memberString[c];
2493 tempString[len] = (char)0;
2494 }
2495 }
2496 strcat(tempString, "\"");
2497 }
2498 else
2499 strcat(tempString, memberString);
2500 atMember = 1;
2501 prev = 1;
2502 }
2503 else if(member && (!member->isProperty || !((struct __ecereNameSpace__ecere__com__Property *)member)->conversion))
2504 atMember = 0;
2505 }
2506 }
2507 }
2508 return tempString;
2509 }
2510
2511 static unsigned int __ecereNameSpace__ecere__com__OnGetDataFromString(struct __ecereNameSpace__ecere__com__Class * _class, void ** data, const char * string)
2512 {
2513 unsigned int result;
2514 struct __ecereNameSpace__ecere__com__Instance * module = _class->module;
2515
2516 if(_class->type == 4)
2517 result = __ecereNameSpace__ecere__com__Enum_OnGetDataFromString(_class, (long long *)data, string);
2518 else if(_class->type == 3)
2519 {
2520 struct __ecereNameSpace__ecere__com__Class * dataType;
2521 struct __ecereNameSpace__ecere__com__Property * prop;
2522
2523 for(prop = _class->conversions.first; prop; prop = prop->next)
2524 {
2525 unsigned int refProp = 0;
2526 struct __ecereNameSpace__ecere__com__Class * c;
2527
2528 if(!strcmp(prop->name, _class->base->fullName))
2529 refProp = 1;
2530 else if((c = __ecereNameSpace__ecere__com__eSystem_FindClass(_class->module, prop->name)))
2531 {
2532 struct __ecereNameSpace__ecere__com__Property * p;
2533
2534 for(p = c->conversions.first; p; p = p->next)
2535 {
2536 if(!strcmp(p->name, _class->base->fullName) && !p->Set && !p->Get)
2537 {
2538 refProp = 1;
2539 break;
2540 }
2541 }
2542 }
2543 if(refProp)
2544 {
2545 if(prop->Set && prop->Get)
2546 {
2547 const char * dts = _class->base->dataTypeString;
2548
2549 if(!strcmp(dts, "double"))
2550 {
2551 double d;
2552 unsigned int result = ((unsigned int (*)(void *, void *, const char *))(void *)__ecereClass_double->_vTbl[__ecereVMethodID_class_OnGetDataFromString])(__ecereClass_double, &d, string);
2553
2554 *(double *)data = ((double (*)(double))(void *)prop->Get)(d);
2555 return result;
2556 }
2557 else if(!strcmp(dts, "float"))
2558 {
2559 float d;
2560 unsigned int result = ((unsigned int (*)(void *, void *, const char *))(void *)__ecereClass_float->_vTbl[__ecereVMethodID_class_OnGetDataFromString])(__ecereClass_float, &d, string);
2561
2562 *(float *)data = ((float (*)(float))(void *)prop->Get)(d);
2563 return result;
2564 }
2565 else if(!strcmp(dts, "int"))
2566 {
2567 int d;
2568 unsigned int result = ((unsigned int (*)(void *, void *, const char *))(void *)__ecereClass_int->_vTbl[__ecereVMethodID_class_OnGetDataFromString])(__ecereClass_int, &d, string);
2569
2570 *(int *)data = ((int (*)(int))(void *)prop->Get)(d);
2571 return result;
2572 }
2573 else if(!strcmp(dts, "int64"))
2574 {
2575 long long d;
2576 unsigned int result = ((unsigned int (*)(void *, void *, const char *))(void *)__ecereClass_int64->_vTbl[__ecereVMethodID_class_OnGetDataFromString])(__ecereClass_int64, &d, string);
2577
2578 *(long long *)data = ((long long (*)(long long))(void *)prop->Get)(d);
2579 return result;
2580 }
2581 }
2582 else
2583 break;
2584 }
2585 }
2586 dataType = __ecereNameSpace__ecere__com__eSystem_FindClass(module, _class->dataTypeString);
2587 return ((unsigned int (*)(void *, void *, const char *))(void *)dataType->_vTbl[__ecereVMethodID_class_OnGetDataFromString])(dataType, data, string);
2588 }
2589 else if(!string[0] && _class->type == 0)
2590 {
2591 *data = (((void *)0));
2592 return 1;
2593 }
2594 else
2595 {
2596 int c;
2597 char memberName[1024];
2598 char memberString[10240];
2599 int count = 0;
2600 unsigned int quoted = 0;
2601 int brackets = 0;
2602 char ch;
2603 unsigned int escape = 0;
2604 unsigned int gotChar;
2605 unsigned int memberOffset;
2606 struct __ecereNameSpace__ecere__com__Class * curClass = (((void *)0));
2607 struct __ecereNameSpace__ecere__com__DataMember * curMember = (((void *)0));
2608 struct __ecereNameSpace__ecere__com__DataMember * subMemberStack[256];
2609 int subMemberStackPos = 0;
2610
2611 result = 1;
2612 if(_class->type == 5 || _class->type == 0)
2613 {
2614 data = *data = __ecereNameSpace__ecere__com__eInstance_New(_class);
2615 if(_class->type == 0)
2616 ((struct __ecereNameSpace__ecere__com__Instance *)(char *)((struct __ecereNameSpace__ecere__com__Instance *)data))->_refCount++;
2617 }
2618 else if(_class->type == 1)
2619 memset(data, 0, _class->structSize);
2620 memberName[0] = '\0';
2621 for(c = 0; string[c] && count < sizeof (memberString); )
2622 {
2623 unsigned int found = 0;
2624 struct __ecereNameSpace__ecere__com__DataMember * thisMember = (((void *)0));
2625
2626 brackets = 0;
2627 gotChar = 0;
2628 for(; (ch = string[c]) && count < sizeof (memberString); c++)
2629 {
2630 if(ch == '\"' && !escape)
2631 {
2632 quoted ^= 1;
2633 }
2634 else if(quoted)
2635 {
2636 if(!escape && ch == '\\')
2637 {
2638 escape = 1;
2639 }
2640 else
2641 {
2642 memberString[count++] = ch;
2643 escape = 0;
2644 }
2645 }
2646 else if(ch == ' ')
2647 {
2648 if(gotChar)
2649 memberString[count++] = ch;
2650 }
2651 else if(ch == ',')
2652 {
2653 if(brackets)
2654 {
2655 memberString[count++] = ch;
2656 }
2657 else
2658 {
2659 c++;
2660 break;
2661 }
2662 }
2663 else if(ch == '{')
2664 {
2665 if(gotChar && !brackets)
2666 {
2667 count = 0;
2668 gotChar = 0;
2669 }
2670 if(brackets)
2671 {
2672 memberString[count++] = ch;
2673 gotChar = 1;
2674 }
2675 brackets++;
2676 }
2677 else if(ch == '}')
2678 {
2679 brackets--;
2680 if(brackets)
2681 {
2682 gotChar = 1;
2683 memberString[count++] = ch;
2684 }
2685 }
2686 else if(ch == '=')
2687 {
2688 if(brackets)
2689 {
2690 memberString[count++] = ch;
2691 }
2692 else
2693 {
2694 memberString[count] = '\0';
2695 __ecereNameSpace__ecere__sys__TrimRSpaces(memberString, memberName);
2696 count = 0;
2697 gotChar = 0;
2698 }
2699 }
2700 else
2701 {
2702 memberString[count++] = ch;
2703 gotChar = 1;
2704 }
2705 }
2706 memberString[count] = '\0';
2707 __ecereNameSpace__ecere__sys__TrimRSpaces(memberString, memberString);
2708 if(memberName[0])
2709 {
2710 struct __ecereNameSpace__ecere__com__DataMember * _subMemberStack[256];
2711 int _subMemberStackPos = 0;
2712
2713 thisMember = __ecereNameSpace__ecere__com__eClass_FindDataMemberAndOffset(_class, memberName, &memberOffset, _class->module, _subMemberStack, &_subMemberStackPos);
2714 if(!thisMember)
2715 thisMember = (struct __ecereNameSpace__ecere__com__DataMember *)__ecereNameSpace__ecere__com__eClass_FindProperty(_class, memberName, _class->module);
2716 if(thisMember)
2717 {
2718 if(thisMember->memberAccess == 1)
2719 {
2720 curMember = thisMember;
2721 curClass = thisMember->_class;
2722 memcpy(subMemberStack, _subMemberStack, sizeof(int) * _subMemberStackPos);
2723 subMemberStackPos = _subMemberStackPos;
2724 }
2725 found = 1;
2726 }
2727 }
2728 else
2729 {
2730 __ecereNameSpace__ecere__com__eClass_FindNextMember(_class, &curClass, &curMember, subMemberStack, &subMemberStackPos);
2731 thisMember = curMember;
2732 if(thisMember)
2733 {
2734 found = 1;
2735 __ecereNameSpace__ecere__com__eClass_FindDataMemberAndOffset(_class, thisMember->name, &memberOffset, _class->module, (((void *)0)), (((void *)0)));
2736 }
2737 }
2738 if(found)
2739 {
2740 struct __ecereNameSpace__ecere__com__Class * memberType = thisMember->dataTypeClass;
2741
2742 if(!memberType)
2743 memberType = thisMember->dataTypeClass = __ecereNameSpace__ecere__com__eSystem_FindClass(module, thisMember->dataTypeString);
2744 if(!memberType)
2745 memberType = thisMember->dataTypeClass = __ecereNameSpace__ecere__com__eSystem_FindClass(module, "int");
2746 if(memberType->type == 1)
2747 {
2748 if(thisMember)
2749 {
2750 if(!((unsigned int (*)(void *, void *, const char *))(void *)memberType->_vTbl[__ecereVMethodID_class_OnGetDataFromString])(memberType, (unsigned char *)data + (((thisMember->_class->type == 0) ? thisMember->_class->offset : 0) + memberOffset), memberString))
2751 result = 0;
2752 }
2753 }
2754 else
2755 {
2756 struct __ecereNameSpace__ecere__com__DataValue value =
2757 {
2758
2759 .__anon1 = {
2760 .c = 0
2761 }
2762 };
2763
2764 if(memberType->_vTbl[__ecereVMethodID_class_OnGetDataFromString] == _class->_vTbl[__ecereVMethodID_class_OnGetDataFromString])
2765 {
2766 if(!__ecereNameSpace__ecere__com__OnGetDataFromString(memberType, (void **)&value, memberString))
2767 result = 0;
2768 }
2769 else if(!((unsigned int (*)(void *, void *, const char *))(void *)memberType->_vTbl[__ecereVMethodID_class_OnGetDataFromString])(memberType, &value, memberString))
2770 result = 0;
2771 if(thisMember && !thisMember->isProperty)
2772 {
2773 if(_class->type == 2)
2774 {
2775 struct __ecereNameSpace__ecere__com__BitMember * bitMember = (struct __ecereNameSpace__ecere__com__BitMember *)thisMember;
2776
2777 *(unsigned int *)data = (unsigned int)(((*(unsigned int *)data & ~bitMember->mask)) | ((value.__anon1.ui64 << bitMember->pos) & bitMember->mask));
2778 }
2779 else
2780 *(int *)((unsigned char *)data + (((thisMember->_class->type == 0) ? thisMember->_class->offset : 0) + thisMember->offset)) = value.__anon1.i;
2781 }
2782 else if(thisMember->isProperty && ((struct __ecereNameSpace__ecere__com__Property *)thisMember)->Set)
2783 {
2784 if(memberType->type == 5 || memberType->type == 0 || memberType->type == 1)
2785 ((void (*)(void *, void *))(void *)((struct __ecereNameSpace__ecere__com__Property *)thisMember)->Set)(data, value.__anon1.p);
2786 else
2787 ((void (*)(void *, int))(void *)((struct __ecereNameSpace__ecere__com__Property *)thisMember)->Set)(data, value.__anon1.i);
2788 }
2789 }
2790 }
2791 else
2792 result = 0;
2793 count = 0;
2794 memberName[0] = '\0';
2795 }
2796 }
2797 return result;
2798 }
2799
2800 static void __ecereNameSpace__ecere__com__OnUnserialize(struct __ecereNameSpace__ecere__com__Class * _class, void ** data, struct __ecereNameSpace__ecere__com__Instance * channel)
2801 {
2802 struct __ecereNameSpace__ecere__com__Instance * module = _class->module;
2803
2804 if(_class->type == 3 || _class->type == 2 || _class->type == 4)
2805 {
2806 struct __ecereNameSpace__ecere__com__Class * dataType = __ecereNameSpace__ecere__com__eSystem_FindClass(module, _class->dataTypeString);
2807
2808 if(dataType)
2809 ((void (*)(void *, void *, void *))(void *)dataType->_vTbl[__ecereVMethodID_class_OnUnserialize])(dataType, data, channel);
2810 }
2811 else if(_class->type == 0 || _class->type == 5 || _class->type == 1)
2812 {
2813 if(data)
2814 {
2815 struct __ecereNameSpace__ecere__com__Class * lastClass = (((void *)0));
2816
2817 if(_class->type == 0 || _class->type == 5)
2818 {
2819 data = *data = __ecereNameSpace__ecere__com__eInstance_New(_class);
2820 if(_class->type == 0)
2821 ((struct __ecereNameSpace__ecere__com__Instance *)(char *)((struct __ecereNameSpace__ecere__com__Instance *)data))->_refCount++;
2822 }
2823 else if(_class->type == 1)
2824 memset(data, 0, _class->structSize);
2825 while(lastClass != _class)
2826 {
2827 struct __ecereNameSpace__ecere__com__DataMember * member;
2828 struct __ecereNameSpace__ecere__com__Class * c;
2829
2830 for(c = _class; c && (!c->base || c->base->type != 1000) && c->base != lastClass; c = c->base)
2831 ;
2832 lastClass = c;
2833 for(member = c->membersAndProperties.first; member; member = member->next)
2834 {
2835 if(member->id < 0)
2836 continue;
2837 if(member->isProperty || member->type == 0)
2838 {
2839 struct __ecereNameSpace__ecere__com__Class * memberType = member->dataTypeClass;
2840
2841 if(!memberType)
2842 memberType = member->dataTypeClass = __ecereNameSpace__ecere__com__eSystem_FindClass(module, member->dataTypeString);
2843 if(memberType)
2844 {
2845 if(member->isProperty)
2846 {
2847 }
2848 else
2849 ((void (*)(void *, void *, void *))(void *)memberType->_vTbl[__ecereVMethodID_class_OnUnserialize])(memberType, (unsigned char *)data + (((member->_class->type == 0) ? member->_class->offset : 0) + member->offset), channel);
2850 }
2851 else
2852 {
2853 }
2854 }
2855 else
2856 {
2857 __ecereNameSpace__ecere__com__DataMember_OnUnserialize(member, (unsigned char *)data + (((member->_class->type == 0) ? member->_class->offset : 0) + member->offset), channel);
2858 }
2859 }
2860 }
2861 }
2862 }
2863 }
2864
2865 void __ecereUnregisterModule_dataTypes(struct __ecereNameSpace__ecere__com__Instance * module)
2866 {
2867
2868 __ecerePropM___ecereNameSpace__ecere__com__SerialBuffer_buffer = (void *)0;
2869 __ecerePropM___ecereNameSpace__ecere__com__SerialBuffer_size = (void *)0;
2870 }
2871
2872 void __ecereNameSpace__ecere__com__Enum_OnSerialize(struct __ecereNameSpace__ecere__com__Class * _class, int * data, struct __ecereNameSpace__ecere__com__Instance * channel)
2873 {
2874 struct __ecereNameSpace__ecere__com__Class * dataType = strcmp(_class->dataTypeString, "int") ? __ecereNameSpace__ecere__com__eSystem_FindClass(_class->module, _class->dataTypeString) : (((void *)0));
2875
2876 if(dataType)
2877 ((void (*)(void *, void *, void *))(void *)dataType->_vTbl[__ecereVMethodID_class_OnSerialize])(dataType, data, channel);
2878 else
2879 __ecereNameSpace__ecere__com__Int_OnSerialize(_class, data, channel);
2880 }
2881
2882 void __ecereNameSpace__ecere__com__Enum_OnUnserialize(struct __ecereNameSpace__ecere__com__Class * _class, int * data, struct __ecereNameSpace__ecere__com__Instance * channel)
2883 {
2884 struct __ecereNameSpace__ecere__com__Class * dataType = strcmp(_class->dataTypeString, "int") ? __ecereNameSpace__ecere__com__eSystem_FindClass(_class->module, _class->dataTypeString) : (((void *)0));
2885
2886 if(dataType)
2887 ((void (*)(void *, void *, void *))(void *)dataType->_vTbl[__ecereVMethodID_class_OnUnserialize])(dataType, data, channel);
2888 else
2889 __ecereNameSpace__ecere__com__Int_OnUnserialize(_class, data, channel);
2890 }
2891
2892 static void __ecereNameSpace__ecere__com__RegisterClass_Integer(struct __ecereNameSpace__ecere__com__Instance * module)
2893 {
2894 struct __ecereNameSpace__ecere__com__Class * integerClass = __ecereNameSpace__ecere__com__eSystem_RegisterClass(0, "int", (((void *)0)), 0, 0, (((void *)0)), (((void *)0)), module, 4, 1);
2895
2896 integerClass->type = 1000;
2897 (__ecereNameSpace__ecere__com__eSystem_Delete((void *)integerClass->dataTypeString), integerClass->dataTypeString = 0);
2898 integerClass->dataTypeString = __ecereNameSpace__ecere__sys__CopyString("int");
2899 integerClass->structSize = 0;
2900 integerClass->typeSize = sizeof(int);
2901 __ecereNameSpace__ecere__com__eClass_AddMethod(integerClass, "OnCompare", (((void *)0)), __ecereNameSpace__ecere__com__Integer_OnCompare, 1);
2902 __ecereNameSpace__ecere__com__eClass_AddMethod(integerClass, "OnGetString", (((void *)0)), __ecereNameSpace__ecere__com__Integer_OnGetString, 1);
2903 __ecereNameSpace__ecere__com__eClass_AddMethod(integerClass, "OnGetDataFromString", (((void *)0)), __ecereNameSpace__ecere__com__Integer_OnGetDataFromString, 1);
2904 __ecereNameSpace__ecere__com__eClass_AddMethod(integerClass, "OnSerialize", (((void *)0)), __ecereNameSpace__ecere__com__Int_OnSerialize, 1);
2905 __ecereNameSpace__ecere__com__eClass_AddMethod(integerClass, "OnUnserialize", (((void *)0)), __ecereNameSpace__ecere__com__Int_OnUnserialize, 1);
2906 integerClass = __ecereNameSpace__ecere__com__eSystem_RegisterClass(0, "int64", (((void *)0)), 0, 0, (((void *)0)), (((void *)0)), module, 4, 1);
2907 integerClass->type = 1000;
2908 integerClass->structSize = 0;
2909 integerClass->typeSize = sizeof(long long);
2910 (__ecereNameSpace__ecere__com__eSystem_Delete((void *)integerClass->dataTypeString), integerClass->dataTypeString = 0);
2911 integerClass->dataTypeString = __ecereNameSpace__ecere__sys__CopyString("int64");
2912 __ecereNameSpace__ecere__com__eClass_AddMethod(integerClass, "OnGetString", (((void *)0)), __ecereNameSpace__ecere__com__Int64_OnGetString, 1);
2913 __ecereNameSpace__ecere__com__eClass_AddMethod(integerClass, "OnCompare", (((void *)0)), __ecereNameSpace__ecere__com__Int64_OnCompare, 1);
2914 __ecereNameSpace__ecere__com__eClass_AddMethod(integerClass, "OnGetDataFromString", (((void *)0)), __ecereNameSpace__ecere__com__Int64_OnGetDataFromString, 1);
2915 __ecereNameSpace__ecere__com__eClass_AddMethod(integerClass, "OnSerialize", (((void *)0)), __ecereNameSpace__ecere__com__Int64_OnSerialize, 1);
2916 __ecereNameSpace__ecere__com__eClass_AddMethod(integerClass, "OnUnserialize", (((void *)0)), __ecereNameSpace__ecere__com__Int64_OnUnserialize, 1);
2917 integerClass = __ecereNameSpace__ecere__com__eSystem_RegisterClass(0, "uint", (((void *)0)), 0, 0, (((void *)0)), (((void *)0)), module, 4, 1);
2918 integerClass->type = 1000;
2919 (__ecereNameSpace__ecere__com__eSystem_Delete((void *)integerClass->dataTypeString), integerClass->dataTypeString = 0);
2920 integerClass->dataTypeString = __ecereNameSpace__ecere__sys__CopyString("unsigned int");
2921 integerClass->structSize = 0;
2922 integerClass->typeSize = sizeof(unsigned int);
2923 __ecereNameSpace__ecere__com__eClass_AddMethod(integerClass, "OnCompare", (((void *)0)), __ecereNameSpace__ecere__com__UInteger_OnCompare, 1);
2924 __ecereNameSpace__ecere__com__eClass_AddMethod(integerClass, "OnGetString", (((void *)0)), __ecereNameSpace__ecere__com__UInteger_OnGetString, 1);
2925 __ecereNameSpace__ecere__com__eClass_AddMethod(integerClass, "OnGetDataFromString", (((void *)0)), __ecereNameSpace__ecere__com__UInteger_OnGetDataFromString, 1);
2926 __ecereNameSpace__ecere__com__eClass_AddMethod(integerClass, "OnSerialize", (((void *)0)), __ecereNameSpace__ecere__com__Int_OnSerialize, 1);
2927 __ecereNameSpace__ecere__com__eClass_AddMethod(integerClass, "OnUnserialize", (((void *)0)), __ecereNameSpace__ecere__com__Int_OnUnserialize, 1);
2928 integerClass = __ecereNameSpace__ecere__com__eSystem_RegisterClass(0, "unsigned int", (((void *)0)), 0, 0, (((void *)0)), (((void *)0)), module, 4, 1);
2929 integerClass->type = 1000;
2930 (__ecereNameSpace__ecere__com__eSystem_Delete((void *)integerClass->dataTypeString), integerClass->dataTypeString = 0);
2931 integerClass->dataTypeString = __ecereNameSpace__ecere__sys__CopyString("unsigned int");
2932 integerClass->structSize = 0;
2933 integerClass->typeSize = sizeof(unsigned int);
2934 __ecereNameSpace__ecere__com__eClass_AddMethod(integerClass, "OnCompare", (((void *)0)), __ecereNameSpace__ecere__com__UInteger_OnCompare, 1);
2935 __ecereNameSpace__ecere__com__eClass_AddMethod(integerClass, "OnGetString", (((void *)0)), __ecereNameSpace__ecere__com__UInteger_OnGetString, 1);
2936 __ecereNameSpace__ecere__com__eClass_AddMethod(integerClass, "OnGetDataFromString", (((void *)0)), __ecereNameSpace__ecere__com__UInteger_OnGetDataFromString, 1);
2937 __ecereNameSpace__ecere__com__eClass_AddMethod(integerClass, "OnSerialize", (((void *)0)), __ecereNameSpace__ecere__com__Int_OnSerialize, 1);
2938 __ecereNameSpace__ecere__com__eClass_AddMethod(integerClass, "OnUnserialize", (((void *)0)), __ecereNameSpace__ecere__com__Int_OnUnserialize, 1);
2939 integerClass = __ecereNameSpace__ecere__com__eSystem_RegisterClass(0, "uint16", (((void *)0)), 0, 0, (((void *)0)), (((void *)0)), module, 4, 1);
2940 integerClass->type = 1000;
2941 (__ecereNameSpace__ecere__com__eSystem_Delete((void *)integerClass->dataTypeString), integerClass->dataTypeString = 0);
2942 integerClass->dataTypeString = __ecereNameSpace__ecere__sys__CopyString("unsigned short");
2943 integerClass->structSize = 0;
2944 integerClass->typeSize = sizeof(unsigned short);
2945 __ecereNameSpace__ecere__com__eClass_AddMethod(integerClass, "OnSerialize", (((void *)0)), __ecereNameSpace__ecere__com__Word_OnSerialize, 1);
2946 __ecereNameSpace__ecere__com__eClass_AddMethod(integerClass, "OnUnserialize", (((void *)0)), __ecereNameSpace__ecere__com__Word_OnUnserialize, 1);
2947 __ecereNameSpace__ecere__com__eClass_AddMethod(integerClass, "OnCompare", (((void *)0)), __ecereNameSpace__ecere__com__UInt16_OnCompare, 1);
2948 __ecereNameSpace__ecere__com__eClass_AddMethod(integerClass, "OnGetString", (((void *)0)), __ecereNameSpace__ecere__com__UInt16_OnGetString, 1);
2949 __ecereNameSpace__ecere__com__eClass_AddMethod(integerClass, "OnGetDataFromString", (((void *)0)), __ecereNameSpace__ecere__com__UInt16_OnGetDataFromString, 1);
2950 integerClass = __ecereNameSpace__ecere__com__eSystem_RegisterClass(0, "short", (((void *)0)), 0, 0, (((void *)0)), (((void *)0)), module, 4, 1);
2951 integerClass->type = 1000;
2952 (__ecereNameSpace__ecere__com__eSystem_Delete((void *)integerClass->dataTypeString), integerClass->dataTypeString = 0);
2953 integerClass->dataTypeString = __ecereNameSpace__ecere__sys__CopyString("short");
2954 integerClass->structSize = 0;
2955 integerClass->typeSize = sizeof(short);
2956 __ecereNameSpace__ecere__com__eClass_AddMethod(integerClass, "OnSerialize", (((void *)0)), __ecereNameSpace__ecere__com__Word_OnSerialize, 1);
2957 __ecereNameSpace__ecere__com__eClass_AddMethod(integerClass, "OnUnserialize", (((void *)0)), __ecereNameSpace__ecere__com__Word_OnUnserialize, 1);
2958 __ecereNameSpace__ecere__com__eClass_AddMethod(integerClass, "OnCompare", (((void *)0)), __ecereNameSpace__ecere__com__Int16_OnCompare, 1);
2959 __ecereNameSpace__ecere__com__eClass_AddMethod(integerClass, "OnGetString", (((void *)0)), __ecereNameSpace__ecere__com__Int16_OnGetString, 1);
2960 __ecereNameSpace__ecere__com__eClass_AddMethod(integerClass, "OnGetDataFromString", (((void *)0)), __ecereNameSpace__ecere__com__Int16_OnGetDataFromString, 1);
2961 integerClass = __ecereNameSpace__ecere__com__eSystem_RegisterClass(0, "uint32", "uint", 0, 0, (((void *)0)), (((void *)0)), module, 4, 1);
2962 integerClass->type = 1000;
2963 (__ecereNameSpace__ecere__com__eSystem_Delete((void *)integerClass->dataTypeString), integerClass->dataTypeString = 0);
2964 integerClass->dataTypeString = __ecereNameSpace__ecere__sys__CopyString("unsigned int");
2965 integerClass->structSize = 0;
2966 integerClass->typeSize = sizeof(unsigned int);
2967 integerClass = __ecereNameSpace__ecere__com__eSystem_RegisterClass(0, "uint64", (((void *)0)), 0, 0, (((void *)0)), (((void *)0)), module, 4, 1);
2968 integerClass->type = 1000;
2969 (__ecereNameSpace__ecere__com__eSystem_Delete((void *)integerClass->dataTypeString), integerClass->dataTypeString = 0);
2970 integerClass->dataTypeString = __ecereNameSpace__ecere__sys__CopyString("uint64");
2971 integerClass->structSize = 0;
2972 integerClass->typeSize = sizeof(uint64);
2973 __ecereNameSpace__ecere__com__eClass_AddMethod(integerClass, "OnGetString", (((void *)0)), __ecereNameSpace__ecere__com__UInt64_OnGetString, 1);
2974 __ecereNameSpace__ecere__com__eClass_AddMethod(integerClass, "OnGetDataFromString", (((void *)0)), __ecereNameSpace__ecere__com__UInt64_OnGetDataFromString, 1);
2975 __ecereNameSpace__ecere__com__eClass_AddMethod(integerClass, "OnSerialize", (((void *)0)), __ecereNameSpace__ecere__com__Int64_OnSerialize, 1);
2976 __ecereNameSpace__ecere__com__eClass_AddMethod(integerClass, "OnUnserialize", (((void *)0)), __ecereNameSpace__ecere__com__Int64_OnUnserialize, 1);
2977 __ecereNameSpace__ecere__com__eClass_AddMethod(integerClass, "OnCompare", (((void *)0)), __ecereNameSpace__ecere__com__UInt64_OnCompare, 1);
2978 integerClass = __ecereNameSpace__ecere__com__eSystem_RegisterClass(0, "byte", (((void *)0)), 0, 0, (((void *)0)), (((void *)0)), module, 4, 1);
2979 integerClass->type = 1000;
2980 (__ecereNameSpace__ecere__com__eSystem_Delete((void *)integerClass->dataTypeString), integerClass->dataTypeString = 0);
2981 integerClass->dataTypeString = __ecereNameSpace__ecere__sys__CopyString("unsigned char");
2982 integerClass->structSize = 0;
2983 integerClass->typeSize = sizeof(unsigned char);
2984 __ecereNameSpace__ecere__com__eClass_AddMethod(integerClass, "OnCompare", (((void *)0)), __ecereNameSpace__ecere__com__Byte_OnCompare, 1);
2985 __ecereNameSpace__ecere__com__eClass_AddMethod(integerClass, "OnGetString", (((void *)0)), __ecereNameSpace__ecere__com__Byte_OnGetString, 1);
2986 __ecereNameSpace__ecere__com__eClass_AddMethod(integerClass, "OnGetDataFromString", (((void *)0)), __ecereNameSpace__ecere__com__Byte_OnGetDataFromString, 1);
2987 __ecereNameSpace__ecere__com__eClass_AddMethod(integerClass, "OnSerialize", (((void *)0)), __ecereNameSpace__ecere__com__Byte_OnSerialize, 1);
2988 __ecereNameSpace__ecere__com__eClass_AddMethod(integerClass, "OnUnserialize", (((void *)0)), __ecereNameSpace__ecere__com__Byte_OnUnserialize, 1);
2989 integerClass = __ecereNameSpace__ecere__com__eSystem_RegisterClass(0, "char", (((void *)0)), 0, 0, (((void *)0)), (((void *)0)), module, 4, 1);
2990 integerClass->type = 1000;
2991 (__ecereNameSpace__ecere__com__eSystem_Delete((void *)integerClass->dataTypeString), integerClass->dataTypeString = 0);
2992 integerClass->dataTypeString = __ecereNameSpace__ecere__sys__CopyString("char");
2993 integerClass->structSize = 0;
2994 integerClass->typeSize = sizeof(char);
2995 __ecereNameSpace__ecere__com__eClass_AddMethod(integerClass, "OnCompare", (((void *)0)), __ecereNameSpace__ecere__com__Byte_OnCompare, 1);
2996 __ecereNameSpace__ecere__com__eClass_AddMethod(integerClass, "OnGetString", (((void *)0)), __ecereNameSpace__ecere__com__Char_OnGetString, 1);
2997 __ecereNameSpace__ecere__com__eClass_AddMethod(integerClass, "OnGetDataFromString", (((void *)0)), __ecereNameSpace__ecere__com__Byte_OnGetDataFromString, 1);
2998 __ecereNameSpace__ecere__com__eClass_AddMethod(integerClass, "OnSerialize", (((void *)0)), __ecereNameSpace__ecere__com__Byte_OnSerialize, 1);
2999 __ecereNameSpace__ecere__com__eClass_AddMethod(integerClass, "OnUnserialize", (((void *)0)), __ecereNameSpace__ecere__com__Byte_OnUnserialize, 1);
3000 integerClass = __ecereNameSpace__ecere__com__eSystem_RegisterClass(0, "intsize", (((void *)0)), 0, 0, (((void *)0)), (((void *)0)), module, 4, 1);
3001 integerClass->type = 1000;
3002 (__ecereNameSpace__ecere__com__eSystem_Delete((void *)integerClass->dataTypeString), integerClass->dataTypeString = 0);
3003 integerClass->dataTypeString = __ecereNameSpace__ecere__sys__CopyString("ssize_t");
3004 integerClass->structSize = 0;
3005 integerClass->typeSize = sizeof(ssize_t);
3006 if(sizeof(ssize_t) == 8)
3007 {
3008 __ecereNameSpace__ecere__com__eClass_AddMethod(integerClass, "OnGetString", (((void *)0)), __ecereNameSpace__ecere__com__Int64_OnGetString, 1);
3009 __ecereNameSpace__ecere__com__eClass_AddMethod(integerClass, "OnGetDataFromString", (((void *)0)), __ecereNameSpace__ecere__com__Int64_OnGetDataFromString, 1);
3010 __ecereNameSpace__ecere__com__eClass_AddMethod(integerClass, "OnSerialize", (((void *)0)), __ecereNameSpace__ecere__com__Int64_OnSerialize, 1);
3011 __ecereNameSpace__ecere__com__eClass_AddMethod(integerClass, "OnUnserialize", (((void *)0)), __ecereNameSpace__ecere__com__Int64_OnUnserialize, 1);
3012 __ecereNameSpace__ecere__com__eClass_AddMethod(integerClass, "OnCompare", (((void *)0)), __ecereNameSpace__ecere__com__Int64_OnCompare, 1);
3013 }
3014 else
3015 {
3016 __ecereNameSpace__ecere__com__eClass_AddMethod(integerClass, "OnCompare", (((void *)0)), __ecereNameSpace__ecere__com__Integer_OnCompare, 1);
3017 __ecereNameSpace__ecere__com__eClass_AddMethod(integerClass, "OnGetString", (((void *)0)), __ecereNameSpace__ecere__com__Integer_OnGetString, 1);
3018 __ecereNameSpace__ecere__com__eClass_AddMethod(integerClass, "OnGetDataFromString", (((void *)0)), __ecereNameSpace__ecere__com__Integer_OnGetDataFromString, 1);
3019 __ecereNameSpace__ecere__com__eClass_AddMethod(integerClass, "OnSerialize", (((void *)0)), __ecereNameSpace__ecere__com__Int_OnSerialize, 1);
3020 __ecereNameSpace__ecere__com__eClass_AddMethod(integerClass, "OnUnserialize", (((void *)0)), __ecereNameSpace__ecere__com__Int_OnUnserialize, 1);
3021 }
3022 integerClass = __ecereNameSpace__ecere__com__eSystem_RegisterClass(0, "uintsize", (((void *)0)), 0, 0, (((void *)0)), (((void *)0)), module, 4, 1);
3023 integerClass->type = 1000;
3024 (__ecereNameSpace__ecere__com__eSystem_Delete((void *)integerClass->dataTypeString), integerClass->dataTypeString = 0);
3025 integerClass->dataTypeString = __ecereNameSpace__ecere__sys__CopyString("size_t");
3026 integerClass->structSize = 0;
3027 integerClass->typeSize = sizeof(size_t);
3028 if(sizeof(size_t) == 8)
3029 {
3030 __ecereNameSpace__ecere__com__eClass_AddMethod(integerClass, "OnGetString", (((void *)0)), __ecereNameSpace__ecere__com__UInt64Hex_OnGetString, 1);
3031 __ecereNameSpace__ecere__com__eClass_AddMethod(integerClass, "OnGetDataFromString", (((void *)0)), __ecereNameSpace__ecere__com__UInt64_OnGetDataFromString, 1);
3032 __ecereNameSpace__ecere__com__eClass_AddMethod(integerClass, "OnSerialize", (((void *)0)), __ecereNameSpace__ecere__com__Int64_OnSerialize, 1);
3033 __ecereNameSpace__ecere__com__eClass_AddMethod(integerClass, "OnUnserialize", (((void *)0)), __ecereNameSpace__ecere__com__Int64_OnUnserialize, 1);
3034 __ecereNameSpace__ecere__com__eClass_AddMethod(integerClass, "OnCompare", (((void *)0)), __ecereNameSpace__ecere__com__UInt64_OnCompare, 1);
3035 }
3036 else
3037 {
3038 __ecereNameSpace__ecere__com__eClass_AddMethod(integerClass, "OnGetString", (((void *)0)), __ecereNameSpace__ecere__com__UIntegerHex_OnGetString, 1);
3039 __ecereNameSpace__ecere__com__eClass_AddMethod(integerClass, "OnGetDataFromString", (((void *)0)), __ecereNameSpace__ecere__com__UInteger_OnGetDataFromString, 1);
3040 __ecereNameSpace__ecere__com__eClass_AddMethod(integerClass, "OnSerialize", (((void *)0)), __ecereNameSpace__ecere__com__Int_OnSerialize, 1);
3041 __ecereNameSpace__ecere__com__eClass_AddMethod(integerClass, "OnUnserialize", (((void *)0)), __ecereNameSpace__ecere__com__Int_OnUnserialize, 1);
3042 __ecereNameSpace__ecere__com__eClass_AddMethod(integerClass, "OnCompare", (((void *)0)), __ecereNameSpace__ecere__com__UInteger_OnCompare, 1);
3043 }
3044 integerClass = __ecereNameSpace__ecere__com__eSystem_RegisterClass(0, "uintptr", (((void *)0)), 0, 0, (((void *)0)), (((void *)0)), module, 4, 1);
3045 integerClass->type = 1000;
3046 (__ecereNameSpace__ecere__com__eSystem_Delete((void *)integerClass->dataTypeString), integerClass->dataTypeString = 0);
3047 integerClass->dataTypeString = __ecereNameSpace__ecere__sys__CopyString("uintptr_t");
3048 integerClass->structSize = 0;
3049 integerClass->typeSize = sizeof(uintptr_t);
3050 integerClass->byValueSystemClass = 1;
3051 if(sizeof(uintptr_t) == 8)
3052 {
3053 __ecereNameSpace__ecere__com__eClass_AddMethod(integerClass, "OnGetString", (((void *)0)), __ecereNameSpace__ecere__com__UIntPtr64_OnGetString, 1);
3054 __ecereNameSpace__ecere__com__eClass_AddMethod(integerClass, "OnGetDataFromString", (((void *)0)), __ecereNameSpace__ecere__com__UInt64_OnGetDataFromString, 1);
3055 __ecereNameSpace__ecere__com__eClass_AddMethod(integerClass, "OnSerialize", (((void *)0)), __ecereNameSpace__ecere__com__IntPtr64_OnSerialize, 1);
3056 __ecereNameSpace__ecere__com__eClass_AddMethod(integerClass, "OnUnserialize", (((void *)0)), __ecereNameSpace__ecere__com__Int64_OnUnserialize, 1);
3057 __ecereNameSpace__ecere__com__eClass_AddMethod(integerClass, "OnCompare", (((void *)0)), __ecereNameSpace__ecere__com__UIntPtr64_OnCompare, 1);
3058 }
3059 else
3060 {
3061 __ecereNameSpace__ecere__com__eClass_AddMethod(integerClass, "OnGetString", (((void *)0)), __ecereNameSpace__ecere__com__UIntPtr32_OnGetString, 1);
3062 __ecereNameSpace__ecere__com__eClass_AddMethod(integerClass, "OnGetDataFromString", (((void *)0)), __ecereNameSpace__ecere__com__UInteger_OnGetDataFromString, 1);
3063 __ecereNameSpace__ecere__com__eClass_AddMethod(integerClass, "OnSerialize", (((void *)0)), __ecereNameSpace__ecere__com__IntPtr32_OnSerialize, 1);
3064 __ecereNameSpace__ecere__com__eClass_AddMethod(integerClass, "OnUnserialize", (((void *)0)), __ecereNameSpace__ecere__com__Int_OnUnserialize, 1);
3065 __ecereNameSpace__ecere__com__eClass_AddMethod(integerClass, "OnCompare", (((void *)0)), __ecereNameSpace__ecere__com__UIntPtr32_OnCompare, 1);
3066 }
3067 integerClass = __ecereNameSpace__ecere__com__eSystem_RegisterClass(0, "intptr", (((void *)0)), 0, 0, (((void *)0)), (((void *)0)), module, 4, 1);
3068 integerClass->type = 1000;
3069 (__ecereNameSpace__ecere__com__eSystem_Delete((void *)integerClass->dataTypeString), integerClass->dataTypeString = 0);
3070 integerClass->dataTypeString = __ecereNameSpace__ecere__sys__CopyString("intptr_t");
3071 integerClass->structSize = 0;
3072 integerClass->typeSize = sizeof(intptr_t);
3073 integerClass->byValueSystemClass = 1;
3074 if(sizeof(intptr_t) == 8)
3075 {
3076 __ecereNameSpace__ecere__com__eClass_AddMethod(integerClass, "OnGetString", (((void *)0)), __ecereNameSpace__ecere__com__IntPtr64_OnGetString, 1);
3077 __ecereNameSpace__ecere__com__eClass_AddMethod(integerClass, "OnGetDataFromString", (((void *)0)), __ecereNameSpace__ecere__com__Int64_OnGetDataFromString, 1);
3078 __ecereNameSpace__ecere__com__eClass_AddMethod(integerClass, "OnSerialize", (((void *)0)), __ecereNameSpace__ecere__com__IntPtr64_OnSerialize, 1);
3079 __ecereNameSpace__ecere__com__eClass_AddMethod(integerClass, "OnUnserialize", (((void *)0)), __ecereNameSpace__ecere__com__Int64_OnUnserialize, 1);
3080 __ecereNameSpace__ecere__com__eClass_AddMethod(integerClass, "OnCompare", (((void *)0)), __ecereNameSpace__ecere__com__IntPtr64_OnCompare, 1);
3081 }
3082 else
3083 {
3084 __ecereNameSpace__ecere__com__eClass_AddMethod(integerClass, "OnGetString", (((void *)0)), __ecereNameSpace__ecere__com__IntPtr32_OnGetString, 1);
3085 __ecereNameSpace__ecere__com__eClass_AddMethod(integerClass, "OnGetDataFromString", (((void *)0)), __ecereNameSpace__ecere__com__Integer_OnGetDataFromString, 1);
3086 __ecereNameSpace__ecere__com__eClass_AddMethod(integerClass, "OnSerialize", (((void *)0)), __ecereNameSpace__ecere__com__IntPtr32_OnSerialize, 1);
3087 __ecereNameSpace__ecere__com__eClass_AddMethod(integerClass, "OnUnserialize", (((void *)0)), __ecereNameSpace__ecere__com__Int_OnUnserialize, 1);
3088 __ecereNameSpace__ecere__com__eClass_AddMethod(integerClass, "OnCompare", (((void *)0)), __ecereNameSpace__ecere__com__IntPtr32_OnCompare, 1);
3089 }
3090 }
3091
3092 static void __ecereNameSpace__ecere__com__RegisterClass_Float(struct __ecereNameSpace__ecere__com__Instance * module)
3093 {
3094 struct __ecereNameSpace__ecere__com__Class * floatClass = __ecereNameSpace__ecere__com__eSystem_RegisterClass(0, "float", (((void *)0)), 0, 0, (((void *)0)), (((void *)0)), module, 4, 1);
3095
3096 floatClass->type = 1000;
3097 (__ecereNameSpace__ecere__com__eSystem_Delete((void *)floatClass->dataTypeString), floatClass->dataTypeString = 0);
3098 floatClass->dataTypeString = __ecereNameSpace__ecere__sys__CopyString("float");
3099 floatClass->structSize = 0;
3100 floatClass->typeSize = sizeof(float);
3101 __ecereNameSpace__ecere__com__eClass_AddMethod(floatClass, "OnCompare", (((void *)0)), __ecereNameSpace__ecere__com__Float_OnCompare, 1);
3102 __ecereNameSpace__ecere__com__eClass_AddMethod(floatClass, "OnGetString", (((void *)0)), __ecereNameSpace__ecere__com__Float_OnGetString, 1);
3103 __ecereNameSpace__ecere__com__eClass_AddMethod(floatClass, "OnGetDataFromString", (((void *)0)), __ecereNameSpace__ecere__com__Float_OnGetDataFromString, 1);
3104 __ecereNameSpace__ecere__com__eClass_AddMethod(floatClass, "OnSerialize", (((void *)0)), __ecereNameSpace__ecere__com__Float_OnSerialize, 1);
3105 __ecereNameSpace__ecere__com__eClass_AddMethod(floatClass, "OnUnserialize", (((void *)0)), __ecereNameSpace__ecere__com__Float_OnUnserialize, 1);
3106 __ecereNameSpace__ecere__com__eClass_AddMethod(floatClass, "nan", "float ::nan(void)", Float_nan, 1);
3107 __ecereNameSpace__ecere__com__eClass_AddMethod(floatClass, "inf", "float ::inf(void)", Float_inf, 1);
3108 __ecereNameSpace__ecere__com__eClass_AddProperty(floatClass, "isNan", "bool", (((void *)0)), Float_isNan, 1);
3109 __ecereNameSpace__ecere__com__eClass_AddProperty(floatClass, "isInf", "bool", (((void *)0)), Float_isInf, 1);
3110 __ecereNameSpace__ecere__com__eClass_AddProperty(floatClass, "signBit", "int", (((void *)0)), Float_signBit, 1);
3111 }
3112
3113 static void __ecereNameSpace__ecere__com__RegisterClass_Double(struct __ecereNameSpace__ecere__com__Instance * module)
3114 {
3115 struct __ecereNameSpace__ecere__com__Class * doubleClass = __ecereNameSpace__ecere__com__eSystem_RegisterClass(0, "double", (((void *)0)), 0, 0, (((void *)0)), (((void *)0)), module, 4, 1);
3116
3117 doubleClass->type = 1000;
3118 (__ecereNameSpace__ecere__com__eSystem_Delete((void *)doubleClass->dataTypeString), doubleClass->dataTypeString = 0);
3119 doubleClass->dataTypeString = __ecereNameSpace__ecere__sys__CopyString("double");
3120 doubleClass->structSize = 0;
3121 doubleClass->typeSize = sizeof(double);
3122 __ecereNameSpace__ecere__com__eClass_AddMethod(doubleClass, "OnCompare", (((void *)0)), __ecereNameSpace__ecere__com__Double_OnCompare, 1);
3123 __ecereNameSpace__ecere__com__eClass_AddMethod(doubleClass, "OnGetString", (((void *)0)), __ecereNameSpace__ecere__com__Double_OnGetString, 1);
3124 __ecereNameSpace__ecere__com__eClass_AddMethod(doubleClass, "OnGetDataFromString", (((void *)0)), __ecereNameSpace__ecere__com__Double_OnGetDataFromString, 1);
3125 __ecereNameSpace__ecere__com__eClass_AddMethod(doubleClass, "OnSerialize", (((void *)0)), __ecereNameSpace__ecere__com__Double_OnSerialize, 1);
3126 __ecereNameSpace__ecere__com__eClass_AddMethod(doubleClass, "OnUnserialize", (((void *)0)), __ecereNameSpace__ecere__com__Double_OnUnserialize, 1);
3127 __ecereNameSpace__ecere__com__eClass_AddProperty(doubleClass, "isNan", "bool", (((void *)0)), Double_isNan, 1);
3128 __ecereNameSpace__ecere__com__eClass_AddProperty(doubleClass, "isInf", "bool", (((void *)0)), Double_isInf, 1);
3129 __ecereNameSpace__ecere__com__eClass_AddProperty(doubleClass, "signBit", "int", (((void *)0)), Double_signBit, 1);
3130 __ecereNameSpace__ecere__com__eClass_AddMethod(doubleClass, "nan", "double ::nan(void)", Double_nan, 1);
3131 __ecereNameSpace__ecere__com__eClass_AddMethod(doubleClass, "inf", "double ::inf(void)", Double_inf, 1);
3132 }
3133
3134 static void __ecereNameSpace__ecere__com__RegisterClass_String(struct __ecereNameSpace__ecere__com__Instance * module)
3135 {
3136 struct __ecereNameSpace__ecere__com__Class * stringClass = __ecereNameSpace__ecere__com__eSystem_RegisterClass(0, "char *", (((void *)0)), 0, 0, (((void *)0)), (((void *)0)), module, 4, 1);
3137
3138 (__ecereNameSpace__ecere__com__eSystem_Delete((void *)stringClass->dataTypeString), stringClass->dataTypeString = 0);
3139 stringClass->dataTypeString = __ecereNameSpace__ecere__sys__CopyString("char *");
3140 stringClass->structSize = 0;
3141 stringClass->computeSize = 0;
3142 __ecereNameSpace__ecere__com__eClass_AddMethod(stringClass, "OnCompare", (((void *)0)), __ecereNameSpace__ecere__com__String_OnCompare, 1);
3143 __ecereNameSpace__ecere__com__eClass_AddMethod(stringClass, "OnCopy", (((void *)0)), __ecereNameSpace__ecere__com__String_OnCopy, 1);
3144 __ecereNameSpace__ecere__com__eClass_AddMethod(stringClass, "OnFree", (((void *)0)), __ecereNameSpace__ecere__com__String_OnFree, 1);
3145 __ecereNameSpace__ecere__com__eClass_AddMethod(stringClass, "OnGetString", (((void *)0)), __ecereNameSpace__ecere__com__String_OnGetString, 1);
3146 __ecereNameSpace__ecere__com__eClass_AddMethod(stringClass, "OnGetDataFromString", (((void *)0)), __ecereNameSpace__ecere__com__String_OnGetDataFromString, 1);
3147 __ecereNameSpace__ecere__com__eClass_AddMethod(stringClass, "OnSerialize", (((void *)0)), __ecereNameSpace__ecere__com__String_OnSerialize, 1);
3148 __ecereNameSpace__ecere__com__eClass_AddMethod(stringClass, "OnUnserialize", (((void *)0)), __ecereNameSpace__ecere__com__String_OnUnserialize, 1);
3149 stringClass = __ecereNameSpace__ecere__com__eSystem_RegisterClass(0, "String", "char *", 0, 0, (((void *)0)), (((void *)0)), module, 4, 1);
3150 stringClass->structSize = 0;
3151 stringClass->computeSize = 0;
3152 __ecereNameSpace__ecere__com__eClass_AddProperty(stringClass, (((void *)0)), "char *", (((void *)0)), (((void *)0)), 1);
3153 }
3154
3155 void __ecereDestructor___ecereNameSpace__ecere__com__SerialBuffer(struct __ecereNameSpace__ecere__com__Instance * this)
3156 {
3157 __attribute__((unused)) struct __ecereNameSpace__ecere__com__SerialBuffer * __ecerePointer___ecereNameSpace__ecere__com__SerialBuffer = (struct __ecereNameSpace__ecere__com__SerialBuffer *)(this ? (((char *)this) + __ecereClass___ecereNameSpace__ecere__com__SerialBuffer->offset) : 0);
3158
3159 {
3160 __ecereMethod___ecereNameSpace__ecere__com__SerialBuffer_Free(this);
3161 }
3162 }
3163
3164 void __ecereNameSpace__ecere__com__InitializeDataTypes1(struct __ecereNameSpace__ecere__com__Instance * module)
3165 {
3166 struct __ecereNameSpace__ecere__com__Class * baseClass = __ecereNameSpace__ecere__com__eSystem_FindClass(module, "class");
3167
3168 __ecereNameSpace__ecere__com__eClass_AddVirtualMethod(baseClass, "OnDisplay", "void typed_object::OnDisplay(Surface surface, int x, int y, int width, void * fieldData, Alignment alignment, DataDisplayFlags displayFlags)", (((void *)0)), 1);
3169 __ecereNameSpace__ecere__com__eClass_AddVirtualMethod(baseClass, "OnCompare", "int typed_object::OnCompare(any_object object)", __ecereNameSpace__ecere__com__OnCompare, 1);
3170 __ecereNameSpace__ecere__com__eClass_AddVirtualMethod(baseClass, "OnCopy", "void typed_object&::OnCopy(any_object newData)", __ecereNameSpace__ecere__com__OnCopy, 1);
3171 __ecereNameSpace__ecere__com__eClass_AddVirtualMethod(baseClass, "OnFree", "void typed_object::OnFree(void)", __ecereNameSpace__ecere__com__OnFree, 1);
3172 __ecereNameSpace__ecere__com__eClass_AddVirtualMethod(baseClass, "OnGetString", "const char * typed_object::OnGetString(char * tempString, void * fieldData, bool * needClass)", __ecereNameSpace__ecere__com__OnGetString, 1);
3173 __ecereNameSpace__ecere__com__eClass_AddVirtualMethod(baseClass, "OnGetDataFromString", "bool typed_object&::OnGetDataFromString(const char * string)", __ecereNameSpace__ecere__com__OnGetDataFromString, 1);
3174 __ecereNameSpace__ecere__com__eClass_AddVirtualMethod(baseClass, "OnEdit", "Window typed_object::OnEdit(DataBox dataBox, DataBox obsolete, int x, int y, int w, int h, void * userData)", (((void *)0)), 1);
3175 __ecereNameSpace__ecere__com__eClass_AddVirtualMethod(baseClass, "OnSerialize", "void typed_object::OnSerialize(IOChannel channel)", __ecereNameSpace__ecere__com__OnSerialize, 1);
3176 __ecereNameSpace__ecere__com__eClass_AddVirtualMethod(baseClass, "OnUnserialize", "void typed_object&::OnUnserialize(IOChannel channel)", __ecereNameSpace__ecere__com__OnUnserialize, 1);
3177 __ecereNameSpace__ecere__com__eClass_AddVirtualMethod(baseClass, "OnSaveEdit", "bool typed_object&::OnSaveEdit(Window window, void * object)", (((void *)0)), 1);
3178 }
3179
3180 void __ecereNameSpace__ecere__com__InitializeDataTypes(struct __ecereNameSpace__ecere__com__Instance * module)
3181 {
3182 struct __ecereNameSpace__ecere__com__Class * enumClass = __ecereNameSpace__ecere__com__eSystem_FindClass(module, "enum");
3183
3184 __ecereNameSpace__ecere__com__eClass_AddMethod(enumClass, "OnSerialize", (((void *)0)), __ecereNameSpace__ecere__com__Enum_OnSerialize, 1);
3185 __ecereNameSpace__ecere__com__eClass_AddMethod(enumClass, "OnUnserialize", (((void *)0)), __ecereNameSpace__ecere__com__Enum_OnUnserialize, 1);
3186 __ecereNameSpace__ecere__com__RegisterClass_Integer(module);
3187 __ecereNameSpace__ecere__com__RegisterClass_Float(module);
3188 __ecereNameSpace__ecere__com__RegisterClass_Double(module);
3189 __ecereNameSpace__ecere__com__RegisterClass_String(module);
3190 }
3191
3192 void __ecereRegisterModule_dataTypes(struct __ecereNameSpace__ecere__com__Instance * module)
3193 {
3194 struct __ecereNameSpace__ecere__com__Class __attribute__((unused)) * class;
3195
3196 __ecereNameSpace__ecere__com__eSystem_RegisterDefine("ecere::com::MAXBYTE", "0xff", module, 4);
3197 __ecereNameSpace__ecere__com__eSystem_RegisterDefine("ecere::com::MAXWORD", "0xffff", module, 4);
3198 __ecereNameSpace__ecere__com__eSystem_RegisterDefine("ecere::com::MININT", "((int)0x80000000)", module, 4);
3199 __ecereNameSpace__ecere__com__eSystem_RegisterDefine("ecere::com::MAXINT", "((int)0x7fffffff)", module, 4);
3200 __ecereNameSpace__ecere__com__eSystem_RegisterDefine("ecere::com::MININT64", "((long long)0x8000000000000000LL)", module, 4);
3201 __ecereNameSpace__ecere__com__eSystem_RegisterDefine("ecere::com::MAXINT64", "((long long)0x7fffffffffffffffLL)", module, 4);
3202 __ecereNameSpace__ecere__com__eSystem_RegisterDefine("ecere::com::MAXDWORD", "0xffffffff", module, 4);
3203 __ecereNameSpace__ecere__com__eSystem_RegisterDefine("ecere::com::MAXQWORD", "0xffffffffffffffffLL", module, 4);
3204 __ecereNameSpace__ecere__com__eSystem_RegisterDefine("ecere::com::MINFLOAT", "1.17549435082228750e-38f", module, 4);
3205 __ecereNameSpace__ecere__com__eSystem_RegisterDefine("ecere::com::MAXFLOAT", "3.40282346638528860e+38f", module, 4);
3206 __ecereNameSpace__ecere__com__eSystem_RegisterDefine("ecere::com::MINDOUBLE", "2.2250738585072014e-308", module, 4);
3207 __ecereNameSpace__ecere__com__eSystem_RegisterDefine("ecere::com::MAXDOUBLE", "1.7976931348623158e+308", module, 4);
3208 __ecereNameSpace__ecere__com__eSystem_RegisterDefine("ecere::com::FORMAT64HEXLL", "(__runtimePlatform == win32) ? \"0x%I64XLL\" : \"0x%llXLL\"", module, 4);
3209 __ecereNameSpace__ecere__com__eSystem_RegisterDefine("ecere::com::FORMAT64HEX", "(__runtimePlatform == win32) ? \"0x%I64X\" : \"0x%llX\"", module, 4);
3210 __ecereNameSpace__ecere__com__eSystem_RegisterDefine("ecere::com::FORMAT64DLL", "(__runtimePlatform == win32) ? \"%I64dLL\" : \"%lldLL\"", module, 4);
3211 __ecereNameSpace__ecere__com__eSystem_RegisterDefine("ecere::com::FORMAT64D", "(__runtimePlatform == win32) ? \"%I64d\" : \"%lld\"", module, 4);
3212 __ecereNameSpace__ecere__com__eSystem_RegisterDefine("ecere::com::FORMAT64U", "(__runtimePlatform == win32) ? \"%I64u\" : \"%llu\"", module, 4);
3213 class = __ecereNameSpace__ecere__com__eSystem_RegisterClass(0, "ecere::com::IOChannel", 0, 0, 0, (void *)0, (void *)0, module, 4, 1);
3214 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)
3215 __ecereClass___ecereNameSpace__ecere__com__IOChannel = class;
3216 __ecereNameSpace__ecere__com__eClass_AddVirtualMethod(class, "WriteData", "uint WriteData(const void * data, unsigned int numBytes)", 0, 1);
3217 __ecereNameSpace__ecere__com__eClass_AddVirtualMethod(class, "ReadData", "uint ReadData(void * data, unsigned int numBytes)", 0, 1);
3218 __ecereNameSpace__ecere__com__eClass_AddMethod(class, "Get", "void Get(typed_object * data)", __ecereMethod___ecereNameSpace__ecere__com__IOChannel_Get, 1);
3219 __ecereNameSpace__ecere__com__eClass_AddMethod(class, "Put", "void Put(typed_object data)", __ecereMethod___ecereNameSpace__ecere__com__IOChannel_Put, 1);
3220 __ecereNameSpace__ecere__com__eClass_AddMethod(class, "Serialize", "void Serialize(typed_object data)", __ecereMethod___ecereNameSpace__ecere__com__IOChannel_Serialize, 1);
3221 __ecereNameSpace__ecere__com__eClass_AddMethod(class, "Unserialize", "void Unserialize(typed_object * data)", __ecereMethod___ecereNameSpace__ecere__com__IOChannel_Unserialize, 1);
3222 class = __ecereNameSpace__ecere__com__eSystem_RegisterClass(0, "ecere::com::SerialBuffer", "ecere::com::IOChannel", sizeof(struct __ecereNameSpace__ecere__com__SerialBuffer), 0, (void *)0, (void *)__ecereDestructor___ecereNameSpace__ecere__com__SerialBuffer, module, 4, 1);
3223 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)
3224 __ecereClass___ecereNameSpace__ecere__com__SerialBuffer = class;
3225 __ecereNameSpace__ecere__com__eClass_AddMethod(class, "WriteData", 0, __ecereMethod___ecereNameSpace__ecere__com__SerialBuffer_WriteData, 1);
3226 __ecereNameSpace__ecere__com__eClass_AddMethod(class, "ReadData", 0, __ecereMethod___ecereNameSpace__ecere__com__SerialBuffer_ReadData, 1);
3227 __ecereNameSpace__ecere__com__eClass_AddMethod(class, "Free", "void Free()", __ecereMethod___ecereNameSpace__ecere__com__SerialBuffer_Free, 1);
3228 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "_buffer", "byte *", sizeof(void *), 0xF000F000, 1);
3229 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "count", "uint", 4, 4, 1);
3230 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "_size", "uint", 4, 4, 1);
3231 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "pos", "uint", 4, 4, 1);
3232 __ecerePropM___ecereNameSpace__ecere__com__SerialBuffer_buffer = __ecereNameSpace__ecere__com__eClass_AddProperty(class, "buffer", "byte *", __ecereProp___ecereNameSpace__ecere__com__SerialBuffer_Set_buffer, __ecereProp___ecereNameSpace__ecere__com__SerialBuffer_Get_buffer, 1);
3233 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)
3234 __ecereProp___ecereNameSpace__ecere__com__SerialBuffer_buffer = __ecerePropM___ecereNameSpace__ecere__com__SerialBuffer_buffer, __ecerePropM___ecereNameSpace__ecere__com__SerialBuffer_buffer = (void *)0;
3235 __ecerePropM___ecereNameSpace__ecere__com__SerialBuffer_size = __ecereNameSpace__ecere__com__eClass_AddProperty(class, "size", "uint", __ecereProp___ecereNameSpace__ecere__com__SerialBuffer_Set_size, __ecereProp___ecereNameSpace__ecere__com__SerialBuffer_Get_size, 1);
3236 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)
3237 __ecereProp___ecereNameSpace__ecere__com__SerialBuffer_size = __ecerePropM___ecereNameSpace__ecere__com__SerialBuffer_size, __ecerePropM___ecereNameSpace__ecere__com__SerialBuffer_size = (void *)0;
3238 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("ecere::com::Enum_OnGetString", "const char * ecere::com::Enum_OnGetString(ecere::com::Class _class, void * data, char * tempString, void * fieldData, bool * needClass)", __ecereNameSpace__ecere__com__Enum_OnGetString, module, 4);
3239 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("ecere::com::Integer_OnGetString", "const char * ecere::com::Integer_OnGetString(ecere::com::Class _class, int * data, char * string, void * fieldData, bool * needClass)", __ecereNameSpace__ecere__com__Integer_OnGetString, module, 4);
3240 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("ecere::com::Byte_OnSerialize", "void ecere::com::Byte_OnSerialize(ecere::com::Class _class, byte * data, ecere::com::IOChannel channel)", __ecereNameSpace__ecere__com__Byte_OnSerialize, module, 4);
3241 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("ecere::com::Byte_OnUnserialize", "void ecere::com::Byte_OnUnserialize(ecere::com::Class _class, byte * data, ecere::com::IOChannel channel)", __ecereNameSpace__ecere__com__Byte_OnUnserialize, module, 4);
3242 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("ecere::com::Int_OnSerialize", "void ecere::com::Int_OnSerialize(ecere::com::Class _class, int * data, ecere::com::IOChannel channel)", __ecereNameSpace__ecere__com__Int_OnSerialize, module, 4);
3243 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("ecere::com::IntPtr32_OnSerialize", "void ecere::com::IntPtr32_OnSerialize(ecere::com::Class _class, int data, ecere::com::IOChannel channel)", __ecereNameSpace__ecere__com__IntPtr32_OnSerialize, module, 4);
3244 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("ecere::com::Int_OnUnserialize", "void ecere::com::Int_OnUnserialize(ecere::com::Class _class, int * data, ecere::com::IOChannel channel)", __ecereNameSpace__ecere__com__Int_OnUnserialize, module, 4);
3245 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("ecere::com::Enum_OnSerialize", "void ecere::com::Enum_OnSerialize(ecere::com::Class _class, int * data, ecere::com::IOChannel channel)", __ecereNameSpace__ecere__com__Enum_OnSerialize, module, 4);
3246 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("ecere::com::Enum_OnUnserialize", "void ecere::com::Enum_OnUnserialize(ecere::com::Class _class, int * data, ecere::com::IOChannel channel)", __ecereNameSpace__ecere__com__Enum_OnUnserialize, module, 4);
3247 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("ecere::com::Int64_OnSerialize", "void ecere::com::Int64_OnSerialize(ecere::com::Class _class, int64 * data, ecere::com::IOChannel channel)", __ecereNameSpace__ecere__com__Int64_OnSerialize, module, 4);
3248 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("ecere::com::Int64_OnUnserialize", "void ecere::com::Int64_OnUnserialize(ecere::com::Class _class, int64 * data, ecere::com::IOChannel channel)", __ecereNameSpace__ecere__com__Int64_OnUnserialize, module, 4);
3249 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("ecere::com::Word_OnSerialize", "void ecere::com::Word_OnSerialize(ecere::com::Class _class, uint16 * data, ecere::com::IOChannel channel)", __ecereNameSpace__ecere__com__Word_OnSerialize, module, 4);
3250 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("ecere::com::Word_OnUnserialize", "void ecere::com::Word_OnUnserialize(ecere::com::Class _class, uint16 * data, ecere::com::IOChannel channel)", __ecereNameSpace__ecere__com__Word_OnUnserialize, module, 4);
3251 class = __ecereNameSpace__ecere__com__eSystem_RegisterClass(1, "ecere::com::StaticString", 0, sizeof(struct __ecereNameSpace__ecere__com__StaticString), 0, (void *)0, (void *)0, module, 4, 1);
3252 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)
3253 __ecereClass___ecereNameSpace__ecere__com__StaticString = class;
3254 __ecereNameSpace__ecere__com__eClass_AddMethod(class, "OnCompare", 0, __ecereMethod___ecereNameSpace__ecere__com__StaticString_OnCompare, 1);
3255 __ecereNameSpace__ecere__com__eClass_AddMethod(class, "OnFree", 0, __ecereMethod___ecereNameSpace__ecere__com__StaticString_OnFree, 1);
3256 __ecereNameSpace__ecere__com__eClass_AddMethod(class, "OnGetString", 0, __ecereMethod___ecereNameSpace__ecere__com__StaticString_OnGetString, 1);
3257 __ecereNameSpace__ecere__com__eClass_AddMethod(class, "OnSerialize", 0, __ecereMethod___ecereNameSpace__ecere__com__StaticString_OnSerialize, 1);
3258 __ecereNameSpace__ecere__com__eClass_AddMethod(class, "OnUnserialize", 0, __ecereMethod___ecereNameSpace__ecere__com__StaticString_OnUnserialize, 1);
3259 __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "string", "char[1]", 1, 1, 1);
3260 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("ecere::com::String_OnCompare", "int ecere::com::String_OnCompare(ecere::com::Class _class, const char * string1, const char * string2)", __ecereNameSpace__ecere__com__String_OnCompare, module, 4);
3261 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("ecere::com::InitializeDataTypes1", "void ecere::com::InitializeDataTypes1(ecere::com::Module module)", __ecereNameSpace__ecere__com__InitializeDataTypes1, module, 4);
3262 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("ecere::com::InitializeDataTypes", "void ecere::com::InitializeDataTypes(ecere::com::Module module)", __ecereNameSpace__ecere__com__InitializeDataTypes, module, 4);
3263 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("ecere::com::PrintStdArgsToBuffer", "int ecere::com::PrintStdArgsToBuffer(char * buffer, int maxLen, typed_object object, __builtin_va_list args)", __ecereNameSpace__ecere__com__PrintStdArgsToBuffer, module, 4);
3264 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("ecere::com::PrintBuf", "int ecere::com::PrintBuf(char * buffer, int maxLen, typed_object object, ...)", __ecereNameSpace__ecere__com__PrintBuf, module, 4);
3265 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("ecere::com::PrintLnBuf", "int ecere::com::PrintLnBuf(char * buffer, int maxLen, typed_object object, ...)", __ecereNameSpace__ecere__com__PrintLnBuf, module, 4);
3266 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("ecere::com::PrintString", "char * ecere::com::PrintString(typed_object object, ...)", __ecereNameSpace__ecere__com__PrintString, module, 4);
3267 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("ecere::com::PrintLnString", "char * ecere::com::PrintLnString(typed_object object, ...)", __ecereNameSpace__ecere__com__PrintLnString, module, 4);
3268 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("ecere::com::PrintLn", "void ecere::com::PrintLn(typed_object object, ...)", __ecereNameSpace__ecere__com__PrintLn, module, 4);
3269 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("ecere::com::Print", "void ecere::com::Print(typed_object object, ...)", __ecereNameSpace__ecere__com__Print, module, 4);
3270 }
3271