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