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

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