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