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

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