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

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