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