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

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