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