The Ecere SDK - sdk/blob - ecere/src/com/dataTypes.ec

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