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

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