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