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