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