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