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

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