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