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

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