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