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