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