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