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

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