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

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