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