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

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