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

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