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