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