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