The Ecere SDK - sdk/blob - ecere/src/sys/JSON.ec

   1 namespace sys;
   2
   3 import "instance"
   4 import "System"
   5 import "Array"
   6
   7 default:
   8 __attribute__((unused)) static void UnusedFunction()
   9 {
  10    int a;
  11    a.OnGetDataFromString(null);
  12    a.OnGetString(null, 0, 0);
  13    a.OnFree();
  14 }
  15 extern int __ecereVMethodID_class_OnGetDataFromString;
  16 extern int __ecereVMethodID_class_OnGetString;
  17 extern int __ecereVMethodID_class_OnFree;
  18 private:
  19
  20 public enum JSONResult { syntaxError, success, typeMismatch, noItem };
  21
  22 public enum SetBool : uint
  23 {
  24    unset, false, true;
  25
  26    /*public property bool     // NOT WORKING!
  27    {
  28       set { return value ? true : false; }
  29       get { return (this == true); }
  30    }*/
  31 };
  32
  33
  34 public class ECONParser : JSONParser
  35 {
  36    eCON = true;
  37 }
  38
  39 public class JSONParser
  40 {
  41 public:
  42    File f;
  43 private:
  44    char ch;
  45    bool eCON;
  46
  47    void SkipEmpty()
  48    {
  49       if(eCON)
  50       {
  51          char pch;
  52          bool lineComment = false;
  53          bool comment = false;
  54          while(!f.Eof() && (!ch || lineComment || comment || ch == ' ' || ch == '\n' || ch == '\r' || ch == '\t' || ch == '/'))
  55          {
  56             pch = ch;
  57             f.Getc(&ch);
  58             if(!lineComment && !comment && pch == '/')
  59             {
  60                if(ch == '/')
  61                   lineComment = true;
  62                else if(ch == '*')
  63                   comment = true;
  64             }
  65             else if(lineComment && ch == '\n')
  66                lineComment = false;
  67             else if(comment && pch == '*' && ch == '/')
  68                comment = false;
  69          }
  70       }
  71       else
  72       {
  73          while(!f.Eof() && (!ch || ch == ' ' || ch == '\n' || ch == '\r' || ch == '\t' || ch == '/'))
  74          {
  75             f.Getc(&ch);
  76          }
  77       }
  78    }
  79
  80    void SkipExtraSemicolon()
  81    {
  82       while(!f.Eof() && (!ch || ch == ' ' || ch == '\n' || ch == '\r' || ch == '\t' || ch == ';'))
  83       {
  84          f.Getc(&ch);
  85       }
  86    }
  87
  88    JSONResult GetValue(Class type, DataValue value)
  89    {
  90       JSONResult result = syntaxError;
  91       ch = 0;
  92       SkipEmpty();
  93       if(ch == '\"')
  94       {
  95          String string;
  96          result = GetString(&string);
  97          if(result)
  98          {
  99             Property prop;
 100             if(type && (!strcmp(type.name, "String") || !strcmp(type.dataTypeString, "char *")))
 101             {
 102                value.p = string;
 103             }
 104             else if(type && (type.type == enumClass || type.type == unitClass))
 105             {
 106                if(((bool (*)(void *, void *, const char *))(void *)type._vTbl[__ecereVMethodID_class_OnGetDataFromString])(type, &value.i, string))
 107                   result = success;
 108                else
 109                   result = typeMismatch;
 110                delete string;
 111             }
 112             else if(type && (prop = eClass_FindProperty(type, "String", type.module)))
 113             {
 114                // TOFIX: Add more conversion property support... Expecting void * compatible here
 115                value.p = ((void *(*)())(void *)prop.Set)(string);
 116                result = success;
 117                delete string;
 118             }
 119             else if(type && eClass_IsDerived(type, class(ColorAlpha)))
 120             {
 121                result = GetColorAlpha(string, value);
 122                delete string;
 123             }
 124             else if(type && (type.type == structClass))
 125             {
 126                if(((bool (*)(void *, void *, const char *))(void *)type._vTbl[__ecereVMethodID_class_OnGetDataFromString])(type, value.p, string))
 127                   result = success;
 128                else
 129                   result = typeMismatch;
 130                delete string;
 131             }
 132             else
 133             {
 134                delete string;
 135                result = typeMismatch;
 136             }
 137          }
 138       }
 139       else if(ch == '[')
 140       {
 141          Container array;
 142          if(type && eClass_IsDerived(type, class(Map)))
 143          {
 144             result = GetMap(type, (Map *)&array);
 145          }
 146          else
 147             result = GetArray(type, &array);
 148
 149          if(result == success && type && eClass_IsDerived(type, class(Container)))
 150          {
 151             value.p = array;
 152          }
 153          else
 154          {
 155             if(array)
 156                array.Free();
 157             delete array;
 158             if(result != success)
 159                result = typeMismatch;
 160          }
 161       }
 162       else if(ch == '-' || isdigit(ch))
 163       {
 164          result = GetNumber(type, value);
 165       }
 166       else if(ch == '{')
 167       {
 168          void * object = value.p;
 169          result = GetObject(type, &object);
 170          if(result)
 171          {
 172             if(type && type.type == structClass);
 173             else if(type && (type.type == normalClass || type.type == noHeadClass || type.type == bitClass))
 174             {
 175                value.p = object;
 176             }
 177             else
 178             {
 179                result = typeMismatch;
 180                if(type)
 181                   ((void (*)(void *, void *))(void *)type._vTbl[__ecereVMethodID_class_OnFree])(type, object);
 182             }
 183          }
 184       }
 185       else if(isalpha(ch) || ch == '_')
 186       {
 187          if(eCON)
 188          {
 189             String string;
 190             if(GetIdentifier(&string, null))
 191             {
 192                result = success;
 193                if(eCON && type && (type.type == enumClass || type.type == unitClass))
 194                {
 195                   // should this be set by calling __ecereVMethodID_class_OnGetDataFromString ?
 196                   if(((bool (*)(void *, void *, const char *))(void *)type._vTbl[__ecereVMethodID_class_OnGetDataFromString])(type, &value.i, string))
 197                      result = success;
 198                   else
 199                      result = typeMismatch;
 200                }
 201                else if(type && !strcmp(type.name, "bool"))
 202                {
 203                   if(!strcmpi(string, "false")) value.i = 0;
 204                   else if(!strcmpi(string, "true")) value.i = 1;
 205                   else
 206                      result = typeMismatch;
 207                }
 208                else if(type && !strcmp(type.name, "SetBool"))
 209                {
 210                   if(!strcmpi(string, "false")) value.i = SetBool::false;
 211                   else if(!strcmpi(string, "true")) value.i = SetBool::true;
 212                   else
 213                      result = typeMismatch;
 214                }
 215                else if(type && !strcmpi(string, "null"))
 216                {
 217                   if(type.type != structClass)
 218                      value.p = 0;
 219                }
 220                else if(isSubclass(type, string))
 221                {
 222                   void * object = value.p;
 223                   Class subtype = superFindClass(string, type.module);
 224                   SkipEmpty();
 225                   result = GetObject(subtype, &object);
 226                   if(result)
 227                   {
 228                      if(subtype && subtype.type == structClass);
 229                      else if(subtype && (subtype.type == normalClass || subtype.type == noHeadClass || subtype.type == bitClass))
 230                      {
 231                         value.p = object;
 232                      }
 233                      else
 234                      {
 235                         result = typeMismatch;
 236                         if(subtype)
 237                            ((void (*)(void *, void *))(void *)subtype._vTbl[__ecereVMethodID_class_OnFree])(subtype, object);
 238                      }
 239                   }
 240                }
 241                else
 242                   result = typeMismatch;
 243             }
 244             delete string;
 245          }
 246          else
 247          {
 248             char buffer[256];
 249             int c = 0;
 250             while(c < sizeof(buffer)-1 && (isalpha(ch) || isdigit(ch) || ch == '_'))
 251             {
 252                buffer[c++] = ch;
 253                if(!f.Getc(&ch)) break;
 254             }
 255             buffer[c] = 0;
 256             result = success;
 257
 258             if(type)
 259             {
 260                if(!strcmp(type.name, "bool"))
 261                {
 262                   if(!strcmpi(buffer, "false")) value.i = 0;
 263                   else if(!strcmpi(buffer, "true")) value.i = 1;
 264                   else
 265                      result = typeMismatch;
 266                }
 267                else if(!strcmp(type.name, "SetBool"))
 268                {
 269                   if(!strcmpi(buffer, "false")) value.i = SetBool::false;
 270                   else if(!strcmpi(buffer, "true")) value.i = SetBool::true;
 271                   else
 272                      result = typeMismatch;
 273                }
 274                else if(!strcmpi(buffer, "null"))
 275                {
 276                   if(type.type != structClass)
 277                      value.p = 0;
 278                }
 279                else
 280                   result = typeMismatch;
 281             }
 282             else
 283                result = typeMismatch;
 284          }
 285       }
 286       else if(ch == '}' || ch == ']')
 287          result = noItem;
 288       if(result == typeMismatch)
 289          PrintLn("Warning: Value type mismatch");
 290       return result;
 291    }
 292
 293    JSONResult GetArray(Class type, Container * array)
 294    {
 295       JSONResult result = syntaxError;
 296       SkipEmpty();
 297       *array = null;
 298       if(ch == '[')
 299       {
 300          *array = eInstance_New(type);
 301          result = success;
 302          while(result)
 303          {
 304             DataValue value { };
 305             Class arrayType = null;
 306             JSONResult itemResult;
 307
 308             if(eClass_IsDerived(type, class(Container)))
 309             {
 310                arrayType = type.templateArgs[0].dataTypeClass;
 311             }
 312
 313             if(arrayType && arrayType.type == structClass)
 314                value.p = new0 byte[arrayType.structSize];
 315             itemResult = GetValue(arrayType, value);
 316             if(itemResult == success)
 317             {
 318                // TODO: Verify the matching between template type and uint64
 319                uint64 t;
 320                if(arrayType.type == structClass)
 321                {
 322                   t = (uint64)(uintptr)value.p;
 323                }
 324                else if(arrayType == class(double) || !strcmp(arrayType.dataTypeString, "double"))
 325                {
 326                   t = value.ui64; //*(uint64 *)&value.d;
 327                }
 328                else if(arrayType == class(float) || !strcmp(arrayType.dataTypeString, "float"))
 329                {
 330                   t = value.ui; //f*(uint *)&value.f;
 331                }
 332                else if(arrayType.typeSize == sizeof(int64) || !strcmp(arrayType.dataTypeString, "int64") ||
 333                   !strcmp(arrayType.dataTypeString, "unsigned int64") || !strcmp(arrayType.dataTypeString, "uint64"))
 334                {
 335                   t = value.ui64;
 336                }
 337                else if(arrayType.typeSize == sizeof(int) || !strcmp(arrayType.dataTypeString, "int") ||
 338                   !strcmp(arrayType.dataTypeString, "unsigned int") || !strcmp(arrayType.dataTypeString, "uint"))
 339                {
 340                   t = value.i;
 341                }
 342                else if(arrayType.typeSize == sizeof(short int) || !strcmp(arrayType.dataTypeString, "short") ||
 343                   !strcmp(arrayType.dataTypeString, "unsigned short") || !strcmp(arrayType.dataTypeString, "uint16") ||
 344                   !strcmp(arrayType.dataTypeString, "int16"))
 345                {
 346                   t = value.s;
 347                }
 348                else if(arrayType.typeSize == sizeof(byte) || !strcmp(arrayType.dataTypeString, "char") ||
 349                   !strcmp(arrayType.dataTypeString, "unsigned char") || !strcmp(arrayType.dataTypeString, "byte"))
 350                {
 351                   t = value.c;
 352                }
 353                else
 354                {
 355                   t = (uint64)(uintptr)value.p;
 356                }
 357                ((void *(*)(void *, uint64))(void *)array->Add)(*array, t);
 358
 359                if(arrayType && arrayType.type == structClass)
 360                   delete value.p;
 361             }
 362             else
 363             {
 364                if(itemResult == typeMismatch)
 365                {
 366                   if(arrayType)
 367                      PrintLn("Warning: Incompatible value for array value, expected ", (String)arrayType.name);
 368                }
 369                else if(itemResult == noItem)
 370                   result = success;
 371                else
 372                   result = itemResult;
 373             }
 374
 375             if(result != syntaxError)
 376             {
 377                if(ch != ']' && ch != ',')
 378                {
 379                   ch = 0;
 380                   SkipEmpty();
 381                }
 382                if(ch == ']')
 383                {
 384                   break;
 385                }
 386                else if(ch != ',')
 387                   result = syntaxError;
 388             }
 389          }
 390       }
 391       ch = 0;
 392       return result;
 393    }
 394
 395    JSONResult GetMap(Class type, Map * map)
 396    {
 397       JSONResult result = syntaxError;
 398       SkipEmpty();
 399       *map = null;
 400       if(ch == '[')
 401       {
 402          Class mapNodeType = type.templateArgs[0].dataTypeClass;
 403          Class keyType = mapNodeType.templateArgs[0].dataTypeClass;
 404          Property keyProp = null;
 405          if(keyType && !strcmp(keyType.dataTypeString, "char *"))
 406             keyProp = eClass_FindProperty(mapNodeType, "key", mapNodeType.module);
 407
 408          *map = eInstance_New(type);
 409          result = success;
 410
 411          while(result)
 412          {
 413             DataValue value { };
 414
 415             JSONResult itemResult;
 416
 417             itemResult = GetValue(mapNodeType, value);
 418             if(itemResult == success)
 419             {
 420                String s = keyProp ? ((void * (*)(void *))(void *)keyProp.Get)(value.p) : null;
 421                ((void *(*)(void *, uint64))(void *)map->Add)(*map, (uint64)(uintptr)value.p);
 422                // Must free String keys here
 423                delete s;
 424             }
 425             else
 426             {
 427                if(itemResult == typeMismatch)
 428                {
 429                   if(mapNodeType)
 430                      PrintLn("Warning: Incompatible value for array value, expected ", (String)mapNodeType.name);
 431                }
 432                else if(itemResult == noItem)
 433                   result = success;
 434                else
 435                   result = itemResult;
 436             }
 437
 438             if(result != syntaxError)
 439             {
 440                if(ch != ']' && ch != ',')
 441                {
 442                   ch = 0;
 443                   SkipEmpty();
 444                }
 445                if(ch == ']')
 446                {
 447                   break;
 448                }
 449                else if(ch != ',')
 450                   result = syntaxError;
 451             }
 452          }
 453       }
 454       ch = 0;
 455       return result;
 456    }
 457
 458    JSONResult GetIdentifier(String * string, bool * wasQuoted)
 459    {
 460       JSONResult result = syntaxError;
 461       Array<char> buffer { minAllocSize = 256 };
 462       bool comment = false;
 463       bool quoted = false;
 464
 465       *string = null;
 466       SkipEmpty();
 467       if(ch == '\"')
 468          quoted = true;
 469       else
 470          buffer.Add(ch);
 471       result = success;
 472       while(f.Getc(&ch))
 473       {
 474          if(!comment && ch == '/')
 475          {
 476             if(f.Getc(&ch))
 477             {
 478                if(ch == '/')
 479                   break;
 480                else if(ch == '*')
 481                   comment = true;
 482                else
 483                {
 484                   result = syntaxError;
 485                   break;
 486                }
 487             }
 488             else
 489             {
 490                result = syntaxError;
 491                break;
 492             }
 493          }
 494          else if(comment && ch == '*')
 495          {
 496             if(f.Getc(&ch))
 497             {
 498                if(ch == '/')
 499                {
 500                   comment = false;
 501                   ch = 0;
 502                }
 503             }
 504             else
 505             {
 506                result = syntaxError;
 507                break;
 508             }
 509          }
 510          else if(ch == '\"' || (!quoted && !comment && ch && !isalpha(ch) && !isdigit(ch) && ch != '_'))
 511          {
 512             if(quoted && ch == '\"' && wasQuoted)
 513                *wasQuoted = true;
 514             break;
 515          }
 516          else if(!comment && ch)
 517          {
 518             buffer.Add(ch);
 519             if(buffer.minAllocSize < buffer.count)
 520                buffer.minAllocSize *= 2;
 521          }
 522       }
 523       if(result != syntaxError)
 524       {
 525          buffer.Add(0);
 526          *string = CopyString(buffer.array);
 527       }
 528       delete buffer;
 529       if(ch != ',' && ch != '}' && ch != ';' && ch != '/' && ch != '=' && ch != ':')
 530          ch = 0;
 531       return result;
 532    }
 533
 534    JSONResult GetString(String * string)
 535    {
 536       JSONResult result = syntaxError;
 537       Array<char> buffer { minAllocSize = 256 };
 538       bool escaped = false;
 539
 540       *string = null;
 541       SkipEmpty();
 542       if(ch == '\"' || eCON)
 543       {
 544          while(f.Getc(&ch))
 545          {
 546             if(ch == '\\' && !escaped)
 547                escaped = true;
 548             else
 549             {
 550                if(escaped)
 551                {
 552                   if(ch == 'b') ch = '\b';
 553                   else if(ch == 'f') ch = '\f';
 554                   else if(ch == 'n') ch = '\n';
 555                   else if(ch == 'r') ch = '\r';
 556                   else if(ch == 't') ch = '\t';
 557                   else if(ch == 'u')
 558                   {
 559                      // SKIP FOR NOW...
 560                      char unicode[4];
 561                      f.Getc(&unicode[0]);
 562                      f.Getc(&unicode[1]);
 563                      f.Getc(&unicode[2]);
 564                      f.Getc(&unicode[3]);
 565                   }
 566                   escaped = false;
 567                }
 568                else if(eCON && ch == '\"')
 569                {
 570                   int seekback = 0;
 571                   char pch;
 572                   bool lineComment = false;
 573                   bool comment = false;
 574                   while(!f.Eof())
 575                   {
 576                      pch = ch;
 577                      f.Getc(&ch);
 578                      seekback--;
 579                      if(!lineComment && !comment && pch == '/')
 580                      {
 581                         if(ch == '/')
 582                            lineComment = true;
 583                         else if(ch == '*')
 584                            comment = true;
 585                      }
 586                      else if(lineComment && ch == '\n')
 587                         lineComment = false;
 588                      else if(comment && pch == '*' && ch == '/')
 589                         comment = false;
 590                      else if(ch == '=' || ch == ':' || ch == ';' || ch == ',' || ch == ']' || ch == '}')
 591                      {
 592                         ch = 0;
 593                         seekback = -1;
 594                         break;
 595                      }
 596                      else if(ch == '\"')
 597                      {
 598                         seekback = 0;
 599                         ch = 0;
 600                         break;
 601                      }
 602                   }
 603                   if(seekback != 0)
 604                   {
 605                      f.Seek(seekback, current);
 606                      break;
 607                   }
 608                }
 609                else if((!eCON && ch == '\"'))
 610                {
 611                   break;
 612                }
 613                if(ch)
 614                {
 615                   buffer.Add(ch);
 616                   if(buffer.minAllocSize < buffer.count)
 617                      buffer.minAllocSize *= 2;
 618                }
 619             }
 620          }
 621          buffer.Add(0);
 622          *string = CopyString(buffer.array);
 623          result = success;
 624       }
 625       delete buffer;
 626       if(ch != ',' && ch != '}' && (!eCON || (ch != ';' && ch != '/')))
 627          ch = 0;
 628       return result;
 629    }
 630
 631    public JSONResult GetObject(Class objectType, void ** object)
 632    {
 633       JSONResult result = syntaxError;
 634       if(!objectType || objectType.type != structClass)
 635          *object = null;
 636       SkipEmpty();
 637       if(ch == '{')
 638       {
 639          Class mapKeyClass = null, mapDataClass = null;
 640          Class curClass = null;
 641          DataMember curMember = null;
 642          DataMember subMemberStack[256];
 643          int subMemberStackPos = 0;
 644
 645          if(objectType && objectType.templateClass && eClass_IsDerived(objectType.templateClass, class(MapNode)))
 646          {
 647             mapKeyClass = objectType.templateArgs[0].dataTypeClass;
 648             mapDataClass = objectType.templateArgs[2].dataTypeClass;
 649          }
 650
 651          result = success;
 652          if(objectType && (objectType.type == noHeadClass || objectType.type == normalClass))
 653          {
 654             *object = eInstance_New(objectType);
 655          }
 656          else if(objectType && objectType.type != structClass)
 657          {
 658             *object = eSystem_New(objectType.typeSize);
 659          }
 660
 661          while(result)
 662          {
 663             String string;
 664             bool wasQuoted = false;
 665             int seek;
 666             ch = 0;
 667             if(eCON)
 668             {
 669                SkipExtraSemicolon();
 670                if(ch == '}')
 671                   break;
 672             }
 673             SkipEmpty();
 674             seek = f.Tell();
 675             if(eCON ? GetIdentifier(&string, &wasQuoted) : GetString(&string))
 676             {
 677                DataMember member = null;
 678                Property prop = null;
 679                Class type = null;
 680                bool isKey = false;
 681                bool isTemplateArg = false;
 682                uint offset = 0;
 683                if(eCON)
 684                {
 685                   SkipEmpty();
 686                   prop = null; member = null;
 687                   if(ch == '=' || ch == ':')
 688                   {
 689                      if(wasQuoted)
 690                         string[0] = (char)tolower(string[0]);
 691                      while(1)
 692                      {
 693                         eClass_FindNextMember(objectType, &curClass, &curMember, subMemberStack, &subMemberStackPos);
 694                         if(!curMember) break;
 695                         if(!strcmp(curMember.name, string))
 696                            break;
 697                      }
 698                   }
 699                   else
 700                      eClass_FindNextMember(objectType, &curClass, &curMember, subMemberStack, &subMemberStackPos);
 701                   if(curMember)
 702                   {
 703                      prop = curMember.isProperty ? (Property)curMember : null;
 704                      member = curMember.isProperty ? null : curMember;
 705
 706                      if(mapKeyClass && !strcmp(prop ? prop.name : member.name, "key"))
 707                      {
 708                         type = mapKeyClass;
 709                         isTemplateArg = true;
 710                         isKey = true;
 711                      }
 712                      else if(mapDataClass && !strcmp(prop ? prop.name : member.name, "value"))
 713                      {
 714                         type = mapDataClass;
 715                         isTemplateArg = true;
 716                         if(member)
 717                            offset = member._class.offset + member.offset;
 718                      }
 719                      else if(prop)
 720                         type = superFindClass(prop.dataTypeString, objectType.module);
 721                      else if(member)
 722                      {
 723                         type = superFindClass(member.dataTypeString, objectType.module);
 724                         offset = member._class.offset + member.offset;
 725                      }
 726                   }
 727                   else
 728                   {
 729                      if(ch == '=' || ch == ':')
 730                         PrintLn("Warning: member ", string, " not found in class ", (String)objectType.name);
 731                      else
 732                         PrintLn("Warning: default member assignment: no more members");
 733                   }
 734                }
 735                if(objectType && !eCON)
 736                {
 737                   string[0] = (char)tolower(string[0]);
 738                   if(mapKeyClass && !strcmp(string, "key"))
 739                   {
 740                      prop = eClass_FindProperty(objectType, "key", objectType.module);
 741                      type = mapKeyClass;
 742                      isTemplateArg = true;
 743                      isKey = true;
 744                   }
 745                   else if(mapDataClass && !strcmp(string, "value"))
 746                   {
 747                      prop = eClass_FindProperty(objectType, "value", objectType.module);
 748                      type = mapDataClass;
 749                      isTemplateArg = true;
 750                   }
 751                   else
 752                   {
 753                      member = eClass_FindDataMember(objectType, string, objectType.module, null, null);
 754                      if(member)
 755                      {
 756                         type = superFindClass(member.dataTypeString, objectType.module);
 757                         offset = member._class.offset + member.offset;
 758                      }
 759                      else if(!member)
 760                      {
 761                         prop = eClass_FindProperty(objectType, string, objectType.module);
 762                         if(prop)
 763                            type = superFindClass(prop.dataTypeString, objectType.module);
 764                         else
 765                            PrintLn("Warning: member ", string, " not found in class ", (String)objectType.name);
 766                      }
 767                   }
 768                }
 769                // Find Member in Object Class
 770                {
 771                   DataValue value { };
 772
 773                   if(type && type.type == structClass)
 774                   {
 775                      if(member)
 776                      {
 777                         value.p = (byte *)*object + offset;
 778                         memset(value.p, 0, type.structSize);
 779                      }
 780                      else if(prop)
 781                      {
 782                         value.p = new0 byte[type.structSize];
 783                      }
 784                   }
 785                   if(!eCON)
 786                   {
 787                      ch = 0;
 788                      SkipEmpty();
 789                   }
 790                   if(eCON && ch != '=' && ch != ':')
 791                   {
 792                      f.Seek(seek-1, start);
 793                      ch = 0;
 794                   }
 795                   if((ch == ':' || (eCON && ch == '=')) || (eCON && type && (prop || member)))
 796                   {
 797                      JSONResult itemResult = GetValue(type, value);
 798                      if(itemResult != syntaxError)
 799                      {
 800                         if(prop || member)
 801                         {
 802                            if(!type)
 803                               PrintLn("warning: Unresolved data type ", member ? (String)member.dataTypeString : (String)prop.dataTypeString);
 804                            else if(itemResult == success)
 805                            {
 806                               // Set value
 807                               if(member)
 808                               {
 809                                  // TOFIX: How to swiftly handle classes with base data type?
 810                                  if(type.type == structClass)
 811                                     ;
 812                                  else if(type.type == normalClass || type.type == noHeadClass)
 813                                  {
 814                                     void ** ptr = (void**)((byte *)*object + offset);
 815                                     if(eClass_IsDerived(type, class(Container)) && *ptr)
 816                                     {
 817                                        Container container = (Container)*ptr;
 818                                        container.Free();
 819                                        delete container;
 820                                     }
 821                                     *ptr = value.p;
 822                                  }
 823                                  else if(type == class(double) || !strcmp(type.dataTypeString, "double"))
 824                                  {
 825                                     *(double *)((byte *)*object + offset) = value.d;
 826                                  }
 827                                  else if(type == class(float) || !strcmp(type.dataTypeString, "float"))
 828                                  {
 829                                     *(float *)((byte *)*object + offset) = value.f;
 830                                  }
 831                                  else if(type.typeSize == sizeof(int64) || !strcmp(type.dataTypeString, "int64") ||
 832                                     !strcmp(type.dataTypeString, "unsigned int64") || !strcmp(type.dataTypeString, "uint64"))
 833                                  {
 834                                     *(uint64 *)((byte *)*object + offset) = value.ui64;
 835                                  }
 836                                  else if(type.typeSize == sizeof(int) || !strcmp(type.dataTypeString, "int") ||
 837                                     !strcmp(type.dataTypeString, "unsigned int") || !strcmp(type.dataTypeString, "uint"))
 838                                  {
 839                                     *(int *)((byte *)*object + offset) = value.i;
 840                                  }
 841                                  else if(type.typeSize == sizeof(short int) || !strcmp(type.dataTypeString, "short") ||
 842                                     !strcmp(type.dataTypeString, "unsigned short") || !strcmp(type.dataTypeString, "uint16") ||
 843                                     !strcmp(type.dataTypeString, "int16"))
 844                                  {
 845                                     *(short *)((byte *)*object + offset) = value.s;
 846                                  }
 847                                  else if(type.typeSize == sizeof(byte) || !strcmp(type.dataTypeString, "char") ||
 848                                     !strcmp(type.dataTypeString, "unsigned char") || !strcmp(type.dataTypeString, "byte"))
 849                                  {
 850                                     *(char *)((byte *)*object + offset) = value.c;
 851                                  }
 852                                  else
 853                                  {
 854                                     *(void **)((byte *)*object + offset) = value.p;
 855                                  }
 856                               }
 857                               else if(prop && prop.Set)
 858                               {
 859                                  if(!strcmp(type.dataTypeString, "char *"))
 860                                  {
 861                                     ((void (*)(void *, void *))(void *)prop.Set)(*object, value.p);
 862                                     if(!isKey)
 863                                        delete value.p;
 864                                  }
 865                                  else if(type.type == enumClass || type.type == bitClass || type.type == unitClass || type.type == systemClass)
 866                                  {
 867                                     // TOFIX: How to swiftly handle classes with base data type?
 868                                     if(type == class(double) || !strcmp(type.dataTypeString, "double"))
 869                                     {
 870                                        ((void (*)(void *, double))(void *)prop.Set)(*object, value.d);
 871                                     }
 872                                     else if(type == class(float) || !strcmp(type.dataTypeString, "float"))
 873                                     {
 874                                        ((void (*)(void *, float))(void *)prop.Set)(*object, value.f);
 875                                     }
 876                                     else if(type.typeSize == sizeof(int64) || !strcmp(type.dataTypeString, "int64") ||
 877                                        !strcmp(type.dataTypeString, "unsigned int64") || !strcmp(type.dataTypeString, "uint64"))
 878                                     {
 879                                        ((void (*)(void *, uint64))(void *)prop.Set)(*object, value.ui64);
 880                                     }
 881                                     else if(type.typeSize == sizeof(int) || !strcmp(type.dataTypeString, "int") ||
 882                                        !strcmp(type.dataTypeString, "unsigned int") || !strcmp(type.dataTypeString, "uint"))
 883                                     {
 884                                        ((void (*)(void *, int))(void *)prop.Set)(*object, value.i);
 885                                     }
 886                                     else if(type.typeSize == sizeof(short int) || !strcmp(type.dataTypeString, "short") ||
 887                                        !strcmp(type.dataTypeString, "unsigned short") || !strcmp(type.dataTypeString, "uint16") ||
 888                                        !strcmp(type.dataTypeString, "int16"))
 889                                     {
 890                                        ((void (*)(void *, short))(void *)prop.Set)(*object, value.s);
 891                                     }
 892                                     else if(type.typeSize == sizeof(byte) || !strcmp(type.dataTypeString, "char") ||
 893                                        !strcmp(type.dataTypeString, "unsigned char") || !strcmp(type.dataTypeString, "byte"))
 894                                     {
 895                                        ((void (*)(void *, char))(void *)prop.Set)(*object, value.c);
 896                                     }
 897                                     else
 898                                     {
 899                                        ((void (*)(void *, int))(void *)prop.Set)(*object, value.i);
 900                                     }
 901                                  }
 902                                  else
 903                                  {
 904                                     if(isTemplateArg)
 905                                        ((void (*)(void *, uint64))(void *)prop.Set)(*object, (uint64)(uintptr)value.p);
 906                                     else
 907                                        ((void (*)(void *, void *))(void *)prop.Set)(*object, value.p);
 908                                  }
 909                               }
 910                            }
 911                            else
 912                            {
 913                               PrintLn("Warning: Incompatible value for ", member ? (String)member.name : (String)prop.name,
 914                                  ", expected ", member ? (String)member.dataTypeString : (String)prop.dataTypeString);
 915                            }
 916                         }
 917                      }
 918                   }
 919                   else
 920                      result = syntaxError;
 921
 922                   if(prop && type && type.type == structClass)
 923                   {
 924                      delete value.p;
 925                   }
 926                }
 927             }
 928             else if(ch && ch != '}' && ch != ',' && (!eCON || ch != ';'))
 929                result = syntaxError;
 930             delete string;
 931
 932             if(result)
 933             {
 934                SkipEmpty();
 935                if(ch == '}')
 936                {
 937                   break;
 938                }
 939                else if(ch != ',' && (!eCON || ch != ';'))
 940                   result = syntaxError;
 941             }
 942          }
 943       }
 944       ch = 0;
 945       return result;
 946    }
 947
 948    JSONResult GetNumber(Class type, DataValue value)
 949    {
 950       JSONResult result = success;
 951       char buffer[256];
 952       int c = 0;
 953       bool comment = false;
 954       bool hexMode = false;
 955       if(eCON)
 956       {
 957          while(c < sizeof(buffer)-1 && (comment || ch == '-' || ch == '.' || tolower(ch) == 'f' ||
 958                      (c == 1 && tolower(ch) == 'x' && buffer[0] == '0') || tolower(ch) == 'e' || ch == '+' || isdigit(ch) || ch == '/' ||
 959                      (hexMode && ((ch >= 'a' && ch <= 'f') || (ch >= 'A' && ch <= 'F')))))
 960          {
 961             if(!comment && ch == '/')
 962             {
 963                if(f.Getc(&ch))
 964                {
 965                   if(ch == '*')
 966                      comment = true;
 967                }
 968                else
 969                {
 970                   result = syntaxError;
 971                   break;
 972                }
 973             }
 974             else if(comment && ch == '*')
 975             {
 976                if(f.Getc(&ch))
 977                {
 978                   if(ch == '/')
 979                      comment = false;
 980                }
 981                else
 982                {
 983                   result = syntaxError;
 984                   break;
 985                }
 986             }
 987             else if(!comment)
 988             {
 989                if(c == 1 && ch == 'x' && buffer[0] == '0')
 990                   hexMode = true;
 991                buffer[c++] = ch;
 992             }
 993             if(!f.Getc(&ch)) break;
 994          }
 995       }
 996       else
 997       {
 998          while(c < sizeof(buffer)-1 && (ch == '-' || ch == '.' || tolower(ch) == 'e' || ch == '+' || isdigit(ch)))
 999          {
1000             buffer[c++] = ch;
1001             if(!f.Getc(&ch)) break;
1002          }
1003       }
1004       buffer[c] = 0;
1005       //if(strchr(buffer, '.'))
1006       if(result == syntaxError)
1007          return result;
1008       if(!type) return success;
1009       result = syntaxError;
1010
1011       // TOFIX: How to swiftly handle classes with base data type?
1012       if(type == class(double) || !strcmp(type.dataTypeString, "double"))
1013       {
1014          value.d = strtod(buffer, null);
1015          result = success;
1016       }
1017       else if(type == class(float) || !strcmp(type.dataTypeString, "float"))
1018       {
1019          value.f = (float)strtod(buffer, null);
1020          result = success;
1021       }
1022       // TOFIX: int64 looks for class long long?
1023       //else if(type == class(int64) || !strcmp(type.dataTypeString, "int64"))
1024       else if(!strcmp(type.dataTypeString, "int64"))
1025       {
1026          value.i64 = strtol(buffer, null, eCON ? 0 : 10);  // TOFIX: 64 bit support
1027          result = success;
1028       }
1029       else if(type == class(uint64) || !strcmp(type.dataTypeString, "uint64"))
1030       {
1031          value.ui64 = strtoul(buffer, null, eCON ? 0 : 10);  // TOFIX: 64 bit support
1032          result = success;
1033       }
1034       else if(type == class(uint) || !strcmp(type.dataTypeString, "unsigned int") || !strcmp(type.dataTypeString, "uint"))
1035       {
1036          value.ui = (uint)strtoul(buffer, null, eCON ? 0 : 10);  // TOFIX: 64 bit support
1037          result = success;
1038       }
1039       else
1040       {
1041          value.i = (int)strtol(buffer, null, eCON ? 0 : 10);
1042          result = success;
1043       }
1044
1045       if(result == success && type.type == unitClass)
1046       {
1047          // Convert to reference unit
1048          Property prop;
1049          for(prop = type.conversions.first; prop; prop = prop.next)
1050          {
1051             bool refProp = false;
1052             if(!strcmp(prop.name, type.base.fullName))
1053                refProp = true;
1054             else
1055             {
1056                Class c = eSystem_FindClass(type.module, prop.name);
1057                if(!c)
1058                   c = eSystem_FindClass(type.module.application, prop.name);
1059                if(c)
1060                {
1061                   Property p;
1062                   for(p = c.conversions.first; p; p = p.next)
1063                   {
1064                      if(!strcmp(p.name, type.base.fullName) && !p.Set && !p.Get)
1065                      {
1066                         refProp = true;
1067                         break;
1068                      }
1069                   }
1070                }
1071             }
1072             if(refProp)
1073             {
1074                if(prop.Set && prop.Get)
1075                {
1076                   const String dts = type.base.dataTypeString;
1077                   if(!strcmp(dts, "double"))
1078                      value.d = ((double(*)(double))(void *)prop.Get)(value.d);
1079                   else if(!strcmp(dts, "float"))
1080                      value.f = ((float(*)(float))(void *)prop.Get)(value.f);
1081                   else if(!strcmp(dts, "int"))
1082                      value.i = ((int(*)(int))(void *)prop.Get)(value.i);
1083                   else if(!strcmp(dts, "int64"))
1084                      value.i64 = ((int64(*)(int64))(void *)prop.Get)(value.i64);
1085                   else if(!strcmp(dts, "unsigned int"))
1086                      value.ui = ((uint(*)(uint))(void *)prop.Get)(value.ui);
1087                   else if(!strcmp(dts, "uint64"))
1088                      value.ui64 = ((uint64(*)(uint64))(void *)prop.Get)(value.ui64);
1089                }
1090                else
1091                   break;
1092             }
1093          }
1094       }
1095       return result;
1096    }
1097
1098    JSONResult GetColorAlpha(String string, DataValue value)
1099    {
1100       ColorAlpha color = 0;
1101       DefinedColor c = 0;
1102       if(string)
1103       {
1104          if(string[0] == '0' && string[1] == 'x')
1105             color = (uint)strtoul(string, null, 0);
1106          else
1107          {
1108             char *d;
1109             byte a = 255;
1110             if((d = strchr(string, ',')))
1111             {
1112                a = (byte)atoi(string);
1113                d += 2;
1114             }
1115             else
1116                d = string;
1117             if(c.class::OnGetDataFromString(d))
1118             {
1119                color.a = a;
1120                color.color = c;
1121             }
1122             else
1123                color = (uint)strtoul(string, null, 16);
1124          }
1125       }
1126       value.i = color;
1127       return success;
1128    }
1129 }
1130
1131 static bool WriteMap(File f, Class type, Map map, int indent, bool eCON)
1132 {
1133    if(map)
1134    {
1135       int i;
1136       bool isFirst = true;
1137       MapIterator it { map = map };
1138       Class mapNodeClass = map._class.templateArgs[0].dataTypeClass;
1139       f.Puts("[\n");
1140       indent++;
1141
1142       while(it.Next())
1143       {
1144          MapNode n = (MapNode)it.pointer;
1145          if(!isFirst)
1146             f.Puts(",\n");
1147          else
1148             isFirst = false;
1149          for(i = 0; i<indent; i++) f.Puts("   ");
1150          WriteONObject(f, mapNodeClass, n, indent, eCON, eCON ? true : false);
1151       }
1152       f.Puts("\n");
1153       indent--;
1154       for(i = 0; i<indent; i++) f.Puts("   ");
1155       f.Puts("]");
1156    }
1157    else
1158       f.Puts("null");
1159    return true;
1160 }
1161
1162 static bool WriteArray(File f, Class type, Container array, int indent, bool eCON)
1163 {
1164    if(array)
1165    {
1166       int i;
1167       bool isFirst = true;
1168       Iterator it { array };
1169       Class arrayType = type.templateArgs[0].dataTypeClass;
1170       f.Puts("[\n");
1171       indent++;
1172
1173       while(it.Next())
1174       {
1175          DataValue value { };
1176          uint64 t = ((uint64(*)(void *, void *))(void *)array.GetData)(array, it.pointer);
1177          if(!isFirst)
1178             f.Puts(",\n");
1179          else
1180             isFirst = false;
1181
1182          // Add value
1183          // TODO: Verify the matching between template type and uint64
1184          if(arrayType.type == structClass)
1185          {
1186             value.p = (void *)(uintptr)t;
1187          }
1188          else if(arrayType == class(double) || !strcmp(arrayType.dataTypeString, "double"))
1189          {
1190             value.ui64 = t;
1191             //value.d = *(double *)&t;
1192          }
1193          else if(arrayType == class(float) || !strcmp(arrayType.dataTypeString, "float"))
1194          {
1195             value.ui = (uint)t;
1196             //value.f = *(float *)&t;
1197          }
1198          else if(arrayType.typeSize == sizeof(int64) || !strcmp(arrayType.dataTypeString, "int64") ||
1199             !strcmp(arrayType.dataTypeString, "unsigned int64") || !strcmp(arrayType.dataTypeString, "uint64"))
1200          {
1201             value.ui64 = t;
1202          }
1203          else if(arrayType.typeSize == sizeof(int) || !strcmp(arrayType.dataTypeString, "int") ||
1204             !strcmp(arrayType.dataTypeString, "unsigned int") || !strcmp(arrayType.dataTypeString, "uint"))
1205          {
1206             value.i = (int)t;
1207          }
1208          else if(arrayType.typeSize == sizeof(short int) || !strcmp(arrayType.dataTypeString, "short") ||
1209             !strcmp(arrayType.dataTypeString, "unsigned short") || !strcmp(arrayType.dataTypeString, "uint16") ||
1210             !strcmp(arrayType.dataTypeString, "int16"))
1211          {
1212             value.s = (short)t;
1213          }
1214          else if(arrayType.typeSize == sizeof(byte) || !strcmp(arrayType.dataTypeString, "char") ||
1215             !strcmp(arrayType.dataTypeString, "unsigned char") || !strcmp(arrayType.dataTypeString, "byte"))
1216          {
1217             value.c = (char)t;
1218          }
1219          else
1220          {
1221             value.p = (void *)(uintptr)t;
1222          }
1223          for(i = 0; i<indent; i++) f.Puts("   ");
1224          WriteValue(f, arrayType, value, indent, eCON);
1225       }
1226       f.Puts("\n");
1227       indent--;
1228       for(i = 0; i<indent; i++) f.Puts("   ");
1229       f.Puts("]");
1230    }
1231    else
1232       f.Puts("null");
1233    return true;
1234 }
1235
1236 static bool WriteNumber(File f, Class type, DataValue value, int indent, bool eCON, bool useHex)
1237 {
1238    char buffer[1024];
1239    bool needClass = eCON;
1240    bool quote;
1241    buffer[0] = 0;
1242    if(type == class(double) || !strcmp(type.dataTypeString, "double"))
1243       ((const char *(*)(void *, void *, char *, void *, bool *))(void *)type._vTbl[__ecereVMethodID_class_OnGetString])(type, &value.d, buffer, 0, &needClass);
1244    else if(type == class(float) || !strcmp(type.dataTypeString, "float"))
1245       ((const char *(*)(void *, void *, char *, void *, bool *))(void *)type._vTbl[__ecereVMethodID_class_OnGetString])(type, &value.f, buffer, null, &needClass);
1246    else if(!strcmp(type.dataTypeString, "int64"))
1247       ((const char *(*)(void *, void *, char *, void *, bool *))(void *)type._vTbl[__ecereVMethodID_class_OnGetString])(type, &value.i64, buffer, null, &needClass);
1248    else if(!strcmp(type.dataTypeString, "unsigned int64") || !strcmp(type.dataTypeString, "uint64") || type.typeSize == sizeof(int64))
1249    {
1250       if(useHex)
1251          sprintf(buffer, __runtimePlatform == win32 ? "0x%016I64X" : "0x%016llX", value.ui64);
1252       else
1253          ((const char *(*)(void *, void *, char *, void *, bool *))(void *)type._vTbl[__ecereVMethodID_class_OnGetString])(type, &value.ui64, buffer, null, &needClass);
1254    }
1255    else if(!strcmp(type.dataTypeString, "int"))
1256       ((const char *(*)(void *, void *, char *, void *, bool *))(void *)type._vTbl[__ecereVMethodID_class_OnGetString])(type, &value.i, buffer, null, &needClass);
1257    else if(!strcmp(type.dataTypeString, "unsigned int") || !strcmp(type.dataTypeString, "uint") || type.typeSize == sizeof(int))
1258    {
1259       if(useHex)
1260          sprintf(buffer, "0x%08X", value.ui);
1261       else
1262          ((const char *(*)(void *, void *, char *, void *, bool *))(void *)type._vTbl[__ecereVMethodID_class_OnGetString])(type, &value.ui, buffer, null, &needClass);
1263    }
1264    else if(!strcmp(type.dataTypeString, "short") || !strcmp(type.dataTypeString, "int16"))
1265       ((const char *(*)(void *, void *, char *, void *, bool *))(void *)type._vTbl[__ecereVMethodID_class_OnGetString])(type, &value.s, buffer, null, &needClass);
1266    else if(!strcmp(type.dataTypeString, "unsigned short") || !strcmp(type.dataTypeString, "uint16") || type.typeSize == sizeof(short int))
1267       ((const char *(*)(void *, void *, char *, void *, bool *))(void *)type._vTbl[__ecereVMethodID_class_OnGetString])(type, &value.us, buffer, null, &needClass);
1268    else if(!strcmp(type.dataTypeString, "char"))
1269       ((const char *(*)(void *, void *, char *, void *, bool *))(void *)type._vTbl[__ecereVMethodID_class_OnGetString])(type, &value.c, buffer, null, &needClass);
1270    else if(!strcmp(type.dataTypeString, "unsigned char") || !strcmp(type.dataTypeString, "byte") || type.typeSize == sizeof(byte))
1271       ((const char *(*)(void *, void *, char *, void *, bool *))(void *)type._vTbl[__ecereVMethodID_class_OnGetString])(type, &value.uc, buffer, null, &needClass);
1272
1273    quote = (type.type == unitClass && ((buffer[0] != '.' && !isdigit(buffer[0])) || strchr(buffer, ' '))) ||
1274            (type.type == enumClass && !eCON);
1275    if(quote) f.Puts("\"");
1276    f.Puts(buffer);
1277    if(quote) f.Puts("\"");
1278    return true;
1279 }
1280
1281 public bool WriteColorAlpha(File f, Class type, DataValue value, int indent, bool eCON)
1282 {
1283    char buffer[1024];
1284    char * string = buffer;
1285    ColorAlpha color = value.i;
1286    int a = color.a;
1287    int len;
1288    DefinedColor c = color;
1289    buffer[0] = '\0';
1290    if(a != 255)
1291    {
1292       a.class::OnGetString(buffer, null, null);
1293       len = strlen(buffer);
1294       buffer[len++] = ',';
1295       buffer[len++] = ' ';
1296       buffer[len] = '\0';
1297       string += len;
1298    }
1299    if(!c.class::OnGetString(string, null, null))
1300       sprintf(buffer, "0x%x", color);
1301    if(!eCON)
1302       f.Puts("\"");
1303    f.Puts(buffer);
1304    if(!eCON)
1305       f.Puts("\"");
1306    return true;
1307 }
1308
1309 static bool WriteValue(File f, Class type, DataValue value, int indent, bool eCON)
1310 {
1311    if(!strcmp(type.name, "String") || !strcmp(type.dataTypeString, "char *"))
1312    {
1313       if(!value.p)
1314          f.Puts("null");
1315       else
1316       {
1317          f.Puts("\"");
1318          //if(strchr(value.p, '\"') || strchr(value.p, '\\'))
1319          if(eCON)
1320          {
1321             int c = 0;
1322             int b = 0;
1323             char buffer[1024];
1324             char * string = value.p;
1325             char ch;
1326             while(true)
1327             {
1328                ch = string[c++];
1329                if(ch == '\"')
1330                {
1331                   buffer[b] = 0;
1332                   f.Puts(buffer);
1333                   f.Puts("\\\"");
1334                   b = 0;
1335                }
1336                else if(ch == '\\')
1337                {
1338                   buffer[b] = 0;
1339                   f.Puts(buffer);
1340                   f.Puts("\\\\");
1341                   b = 0;
1342                }
1343                else if(ch == '\t')
1344                {
1345                   buffer[b] = 0;
1346                   f.Puts(buffer);
1347                   f.Puts("\\t");
1348                   b = 0;
1349                }
1350                else if(ch == '\n')
1351                {
1352                   int i;
1353                   buffer[b] = 0;
1354                   f.Puts(buffer);
1355                   f.Puts("\\n\"\n");
1356                   for(i = 0; i<indent; i++) f.Puts("   ");
1357                   f.Puts("   \"");
1358                   b = 0;
1359                }
1360                else if(b == sizeof(buffer)-2 || !ch)
1361                {
1362                   buffer[b++] = ch;
1363                   if(ch) buffer[b] = 0;
1364                   f.Puts(buffer);
1365                   b = 0;
1366                   if(!ch) break;
1367                }
1368                else
1369                   buffer[b++] = ch;
1370             }
1371          }
1372          else
1373          {
1374             int c = 0;
1375             int b = 0;
1376             char buffer[1024];
1377             char * string = value.p;
1378             char ch;
1379             while(true)
1380             {
1381                ch = string[c++];
1382                if(ch == '\"')
1383                {
1384                   buffer[b] = 0;
1385                   f.Puts(buffer);
1386                   f.Puts("\\\"");
1387                   b = 0;
1388                }
1389                else if(ch == '\\')
1390                {
1391                   buffer[b] = 0;
1392                   f.Puts(buffer);
1393                   f.Puts("\\\\");
1394                   b = 0;
1395                }
1396                else if(b == sizeof(buffer)-2 || !ch)
1397                {
1398                   buffer[b++] = ch;
1399                   if(ch) buffer[b] = 0;
1400                   f.Puts(buffer);
1401                   b = 0;
1402                   if(!ch) break;
1403                }
1404                else
1405                   buffer[b++] = ch;
1406             }
1407          }
1408          /*else
1409             f.Puts(value.p);*/
1410          f.Puts("\"");
1411       }
1412    }
1413    else if(!strcmp(type.name, "bool"))
1414    {
1415       if(value.i)
1416          f.Puts("true");
1417       else
1418          f.Puts("false");
1419    }
1420    else if(!strcmp(type.name, "SetBool"))
1421    {
1422       if(value.i == SetBool::true)
1423          f.Puts("true");
1424       else if(value.i == SetBool::false)
1425          f.Puts("false");
1426       else
1427          f.Puts("unset");
1428    }
1429    else if(type.type == enumClass)
1430       WriteNumber(f, type, value, indent, eCON, false);
1431    else if(eClass_IsDerived(type, class(Map)))
1432    {
1433       WriteMap(f, type, value.p, indent, eCON);
1434    }
1435    else if(eClass_IsDerived(type, class(Container)))
1436    {
1437       WriteArray(f, type, value.p, indent, eCON);
1438    }
1439    else if(type.type == normalClass || type.type == noHeadClass || type.type == structClass)
1440    {
1441       WriteONObject(f, type, value.p, indent, eCON, false);
1442    }
1443    else if(eClass_IsDerived(type, class(ColorAlpha)))
1444    {
1445       WriteColorAlpha(f, type, value, indent, eCON);
1446    }
1447    else if(type.type == bitClass)
1448    {
1449       Class dataType;
1450       dataType = superFindClass(type.dataTypeString, type.module);
1451       WriteNumber(f, dataType, value, indent, eCON, true);
1452    }
1453    else if(type.type == systemClass || type.type == unitClass)
1454    {
1455       WriteNumber(f, type, value, indent, eCON, false);
1456    }
1457    return true;
1458 }
1459
1460 public bool WriteJSONObject(File f, Class objectType, void * object, int indent)
1461 {
1462    bool result = false;
1463    if(object)
1464    {
1465       result = WriteONObject(f, objectType, object, indent, false, false);
1466       f.Puts("\n");
1467    }
1468    return result;
1469 }
1470
1471 public bool WriteECONObject(File f, Class objectType, void * object, int indent)
1472 {
1473    bool result = false;
1474    if(object)
1475    {
1476       result = WriteONObject(f, objectType, object, indent, true, false);
1477       f.Puts("\n");
1478    }
1479    return result;
1480 }
1481
1482 static bool WriteONObject(File f, Class objectType, void * object, int indent, bool eCON, bool omitDefaultIdentifier)
1483 {
1484    if(object)
1485    {
1486       const char * string = null;
1487
1488       if(objectType._vTbl[__ecereVMethodID_class_OnGetString] != objectType.base._vTbl[__ecereVMethodID_class_OnGetString])
1489       {
1490          char buffer[1024];
1491          buffer[0] = 0;
1492          string = ((const char *(*)())(void *)objectType._vTbl[__ecereVMethodID_class_OnGetString])(objectType, object, buffer, null, null);
1493       }
1494       if(string)
1495       {
1496          // TOCHECK: ProjectNode.ec why do we add quotes in OnGetString there?
1497          if(string[0] == '\"')
1498             f.Puts(string);
1499          else
1500          {
1501             f.Puts("\"");
1502             f.Puts(string);
1503             f.Puts("\"");
1504          }
1505       }
1506       else
1507       {
1508          Class _class = (eCON && objectType.type == normalClass) ? ((Instance)object)._class : objectType;
1509          Property prop;
1510          int c;
1511          bool isFirst = true;
1512          Class mapKeyClass = null, mapDataClass = null;
1513          Class baseClass;
1514          List<Class> bases { };
1515
1516          if(objectType.templateClass && eClass_IsDerived(objectType.templateClass, class(MapNode)))
1517          {
1518             mapKeyClass = objectType.templateArgs[0].dataTypeClass;
1519             mapDataClass = objectType.templateArgs[2].dataTypeClass;
1520          }
1521
1522          if(eCON && _class != objectType && eClass_IsDerived(_class, objectType))
1523          {
1524             f.Puts(_class.name);
1525             f.Puts(" ");
1526          }
1527
1528          f.Puts("{\n");
1529          indent++;
1530
1531          for(baseClass = _class; baseClass; baseClass = baseClass.base)
1532          {
1533             if(baseClass.isInstanceClass || !baseClass.base)
1534                break;
1535             bases.Insert(null, baseClass);
1536          }
1537
1538          for(baseClass : bases)
1539          {
1540             for(prop = baseClass.membersAndProperties.first; prop; prop = prop.next)
1541             {
1542                if(prop.memberAccess != publicAccess || (prop.isProperty && (!prop.Set || !prop.Get))) continue;
1543                if(prop.isProperty)
1544                {
1545                   if(!prop.conversion && (!prop.IsSet || prop.IsSet(object)))
1546                   {
1547                      DataValue value { };
1548                      bool isTemplateArg = false;
1549                      Class type;
1550
1551                      if(mapKeyClass && !strcmp(prop.name, "key"))
1552                      {
1553                         isTemplateArg = true;
1554                         type = mapKeyClass;
1555                      }
1556                      else if(mapDataClass && !strcmp(prop.name, "value"))
1557                      {
1558                         isTemplateArg = true;
1559                         type = mapDataClass;
1560                      }
1561                      else
1562                         type = superFindClass(prop.dataTypeString, _class.module);
1563
1564                      if(!type)
1565                         PrintLn("warning: Unresolved data type ", (String)prop.dataTypeString);
1566                      else
1567                      {
1568                         if(type.type == enumClass || type.type == bitClass || type.type == unitClass || type.type == systemClass)
1569                         {
1570                            // TOFIX: How to swiftly handle classes with base data type?
1571                            if(type == class(double) || !strcmp(type.dataTypeString, "double"))
1572                            {
1573                               value.d = ((double (*)(void *))(void *)prop.Get)(object);
1574                            }
1575                            else if(type == class(float) || !strcmp(type.dataTypeString, "float"))
1576                            {
1577                               value.f = ((float (*)(void *))(void *)prop.Get)(object);
1578                            }
1579                            else if(type.typeSize == sizeof(int64) || !strcmp(type.dataTypeString, "int64") ||
1580                               !strcmp(type.dataTypeString, "unsigned int64") || !strcmp(type.dataTypeString, "uint64"))
1581                            {
1582                               value.ui64 = ((uint64 (*)(void *))(void *)prop.Get)(object);
1583                            }
1584                            else if(type.typeSize == sizeof(int) || !strcmp(type.dataTypeString, "int") ||
1585                               !strcmp(type.dataTypeString, "unsigned int") || !strcmp(type.dataTypeString, "uint"))
1586                            {
1587                               value.i = ((int (*)(void *))(void *)prop.Get)(object);
1588                            }
1589                            else if(type.typeSize == sizeof(short int) || !strcmp(type.dataTypeString, "short") ||
1590                               !strcmp(type.dataTypeString, "unsigned short") || !strcmp(type.dataTypeString, "uint16") ||
1591                               !strcmp(type.dataTypeString, "int16"))
1592                            {
1593                               value.s = ((short (*)(void *))(void *)prop.Get)(object);
1594                            }
1595                            else if(type.typeSize == sizeof(byte) || !strcmp(type.dataTypeString, "char") ||
1596                               !strcmp(type.dataTypeString, "unsigned char") || !strcmp(type.dataTypeString, "byte"))
1597                            {
1598                               value.c = ((char (*)(void *))(void *)prop.Get)(object);
1599                            }
1600                         }
1601                         else if(type.type == structClass)
1602                         {
1603                            value.p = new0 byte[type.structSize];
1604                            ((void (*)(void *, void *))(void *)prop.Get)(object, value.p);
1605                         }
1606                         else
1607                         {
1608                            if(isTemplateArg)
1609                               value.p = (void *)(uintptr)((uint64 (*)(void *))(void *)prop.Get)(object);
1610                            else
1611                               value.p = ((void *(*)(void *))(void *)prop.Get)(object);
1612                         }
1613
1614                         if(!isFirst) f.Puts(",\n");
1615                         for(c = 0; c<indent; c++) f.Puts("   ");
1616
1617                         if(!eCON)
1618                         {
1619                            f.Puts("\"");
1620                            f.Putc((char)toupper(prop.name[0]));
1621                            f.Puts(prop.name+1);
1622                            f.Puts("\" : ");
1623                         }
1624                         else if(!omitDefaultIdentifier)
1625                         {
1626                            f.Puts(prop.name);
1627                            f.Puts(" = ");
1628                         }
1629                         WriteValue(f, type, value, indent, eCON);
1630                         isFirst = false;
1631                         if(type.type == structClass)
1632                            delete value.p;
1633                      }
1634                   }
1635                }
1636                else
1637                {
1638                   DataMember member = (DataMember)prop;
1639                   DataValue value { };
1640                   uint offset;
1641                   Class type = superFindClass(member.dataTypeString, _class.module);
1642                   offset = member._class.offset + member.offset;
1643
1644                   if(type)
1645                   {
1646                      if(type.type == normalClass || type.type == noHeadClass || type.type == structClass || !strcmp(type.name, "String"))
1647                      {
1648                         if(type.type == structClass)
1649                            value.p = (void *)((byte *)object + offset);
1650                         else
1651                            value.p = *(void **)((byte *)object + offset);
1652                         if(!value.p)
1653                            continue;
1654                      }
1655                      else if(type == class(double) || !strcmp(type.dataTypeString, "double"))
1656                      {
1657                         value.d = *(double *)((byte *)object + offset);
1658                      }
1659                      else if(type == class(float) || !strcmp(type.dataTypeString, "float"))
1660                      {
1661                         value.f = *(float *)((byte *)object + offset);
1662                      }
1663                      else if(type.typeSize == sizeof(int64) || !strcmp(type.dataTypeString, "int64") ||
1664                         !strcmp(type.dataTypeString, "unsigned int64") || !strcmp(type.dataTypeString, "uint64"))
1665                      {
1666                         value.ui64 = *(uint64 *)((byte *)object + offset);
1667                      }
1668                      else if(type.typeSize == sizeof(int) || !strcmp(type.dataTypeString, "int") ||
1669                         !strcmp(type.dataTypeString, "unsigned int") || !strcmp(type.dataTypeString, "uint"))
1670                      {
1671                         value.i = *(int *)((byte *)object + offset);
1672                         if(!strcmp(type.name, "bool") || type.type == enumClass)
1673                            if(!value.i)
1674                               continue;
1675                      }
1676                      else if(type.typeSize == sizeof(short int) || !strcmp(type.dataTypeString, "short") ||
1677                         !strcmp(type.dataTypeString, "unsigned short") || !strcmp(type.dataTypeString, "uint16") ||
1678                         !strcmp(type.dataTypeString, "int16"))
1679                      {
1680                         value.s = *(short *)((byte *)object + offset);
1681                      }
1682                      else if(type.typeSize == sizeof(byte) || !strcmp(type.dataTypeString, "char") ||
1683                         !strcmp(type.dataTypeString, "unsigned char") || !strcmp(type.dataTypeString, "byte"))
1684                      {
1685                         value.c = *(char *)((byte *)object + offset);
1686                      }
1687                      else
1688                      {
1689                         value.i = *(int *)((byte *)object + offset);
1690                      }
1691
1692                      if(!isFirst) f.Puts(",\n");
1693                      for(c = 0; c<indent; c++) f.Puts("   ");
1694
1695                      if(!eCON)
1696                      {
1697                         f.Puts("\"");
1698                         f.Putc((char)toupper(member.name[0]));
1699                         f.Puts(member.name+1);
1700                         f.Puts("\" : ");
1701                      }
1702                      else if(!omitDefaultIdentifier)
1703                      {
1704                         f.Puts(member.name);
1705                         f.Puts(" = ");
1706                      }
1707                      WriteValue(f, type, value, indent, eCON);
1708                      isFirst = false;
1709                   }
1710                }
1711             }
1712          }
1713
1714          delete bases;
1715
1716          indent--;
1717          f.Puts("\n");
1718          for(c = 0; c<indent; c++) f.Puts("   "); f.Puts("}");
1719       }
1720    }
1721    else
1722       f.Puts("null");
1723    return true;
1724 }
1725
1726 static Class superFindClass(const String name, Module alternativeModule)
1727 {
1728    Class _class = eSystem_FindClass(__thisModule, name);
1729    if(!_class && alternativeModule)
1730       _class = eSystem_FindClass(alternativeModule, name);
1731    if(!_class)
1732       _class = eSystem_FindClass(__thisModule.application, name);
1733    return _class;
1734 }
1735
1736 static bool isSubclass(Class type, const String name)
1737 {
1738    Class _class = superFindClass(name, type.module);
1739    if(eClass_IsDerived(_class, type))
1740       return true;
1741    return false;
1742 }