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 == 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       if(eCON)
 955       {
 956          while(c < sizeof(buffer)-1 && (comment || ch == '-' || ch == '.' || tolower(ch) == 'f' ||
 957                      tolower(ch) == 'x' || tolower(ch) == 'e' || ch == '+' || isdigit(ch) || ch == '/'))
 958          {
 959             if(!comment && ch == '/')
 960             {
 961                if(f.Getc(&ch))
 962                {
 963                   if(ch == '*')
 964                      comment = true;
 965                }
 966                else
 967                {
 968                   result = syntaxError;
 969                   break;
 970                }
 971             }
 972             else if(comment && ch == '*')
 973             {
 974                if(f.Getc(&ch))
 975                {
 976                   if(ch == '/')
 977                      comment = false;
 978                }
 979                else
 980                {
 981                   result = syntaxError;
 982                   break;
 983                }
 984             }
 985             else if(!comment)
 986                buffer[c++] = ch;
 987             if(!f.Getc(&ch)) break;
 988          }
 989       }
 990       else
 991       {
 992          while(c < sizeof(buffer)-1 && (ch == '-' || ch == '.' || tolower(ch) == 'e' || ch == '+' || isdigit(ch)))
 993          {
 994             buffer[c++] = ch;
 995             if(!f.Getc(&ch)) break;
 996          }
 997       }
 998       buffer[c] = 0;
 999       //if(strchr(buffer, '.'))
1000       if(result == syntaxError)
1001          return result;
1002       if(!type) return success;
1003       result = syntaxError;
1004
1005       // TOFIX: How to swiftly handle classes with base data type?
1006       if(type == class(double) || !strcmp(type.dataTypeString, "double"))
1007       {
1008          value.d = strtod(buffer, null);
1009          result = success;
1010       }
1011       else if(type == class(float) || !strcmp(type.dataTypeString, "float"))
1012       {
1013          value.f = (float)strtod(buffer, null);
1014          result = success;
1015       }
1016       // TOFIX: int64 looks for class long long?
1017       //else if(type == class(int64) || !strcmp(type.dataTypeString, "int64"))
1018       else if(!strcmp(type.dataTypeString, "int64"))
1019       {
1020          value.i64 = strtol(buffer, null, eCON ? 0 : 10);  // TOFIX: 64 bit support
1021          result = success;
1022       }
1023       else if(type == class(uint64) || !strcmp(type.dataTypeString, "uint64"))
1024       {
1025          value.ui64 = strtoul(buffer, null, eCON ? 0 : 10);  // TOFIX: 64 bit support
1026          result = success;
1027       }
1028       else if(type == class(uint) || !strcmp(type.dataTypeString, "unsigned int"))
1029       {
1030          value.ui = (uint)strtoul(buffer, null, eCON ? 0 : 10);  // TOFIX: 64 bit support
1031          result = success;
1032       }
1033       else
1034       {
1035          value.i = (int)strtol(buffer, null, eCON ? 0 : 10);
1036          result = success;
1037       }
1038
1039       if(result == success && type.type == unitClass)
1040       {
1041          // Convert to reference unit
1042          Property prop;
1043          for(prop = type.conversions.first; prop; prop = prop.next)
1044          {
1045             bool refProp = false;
1046             if(!strcmp(prop.name, type.base.fullName))
1047                refProp = true;
1048             else
1049             {
1050                Class c = eSystem_FindClass(type.module, prop.name);
1051                if(!c)
1052                   c = eSystem_FindClass(type.module.application, prop.name);
1053                if(c)
1054                {
1055                   Property p;
1056                   for(p = c.conversions.first; p; p = p.next)
1057                   {
1058                      if(!strcmp(p.name, type.base.fullName) && !p.Set && !p.Get)
1059                      {
1060                         refProp = true;
1061                         break;
1062                      }
1063                   }
1064                }
1065             }
1066             if(refProp)
1067             {
1068                if(prop.Set && prop.Get)
1069                {
1070                   const String dts = type.base.dataTypeString;
1071                   if(!strcmp(dts, "double"))
1072                      value.d = ((double(*)(double))(void *)prop.Get)(value.d);
1073                   else if(!strcmp(dts, "float"))
1074                      value.f = ((float(*)(float))(void *)prop.Get)(value.f);
1075                   else if(!strcmp(dts, "int"))
1076                      value.i = ((int(*)(int))(void *)prop.Get)(value.i);
1077                   else if(!strcmp(dts, "int64"))
1078                      value.i64 = ((int64(*)(int64))(void *)prop.Get)(value.i64);
1079                   else if(!strcmp(dts, "unsigned int"))
1080                      value.ui = ((uint(*)(uint))(void *)prop.Get)(value.ui);
1081                   else if(!strcmp(dts, "uint64"))
1082                      value.ui64 = ((uint64(*)(uint64))(void *)prop.Get)(value.ui64);
1083                }
1084                else
1085                   break;
1086             }
1087          }
1088       }
1089       return result;
1090    }
1091
1092    JSONResult GetColorAlpha(String string, DataValue value)
1093    {
1094       ColorAlpha color = 0;
1095       DefinedColor c = 0;
1096       if(string)
1097       {
1098          if(string[0] == '0' && string[1] == 'x')
1099             color = (uint)strtoul(string, null, 0);
1100          else
1101          {
1102             char *d;
1103             byte a = 255;
1104             if((d = strchr(string, ',')))
1105             {
1106                a = (byte)atoi(string);
1107                d += 2;
1108             }
1109             else
1110                d = string;
1111             if(c.class::OnGetDataFromString(d))
1112             {
1113                color.a = a;
1114                color.color = c;
1115             }
1116             else
1117                color = (uint)strtoul(string, null, 16);
1118          }
1119       }
1120       value.i = color;
1121       return success;
1122    }
1123 }
1124
1125 static bool WriteMap(File f, Class type, Map map, int indent, bool eCON)
1126 {
1127    if(map)
1128    {
1129       int i;
1130       bool isFirst = true;
1131       MapIterator it { map = map };
1132       Class mapNodeClass = map._class.templateArgs[0].dataTypeClass;
1133       f.Puts("[\n");
1134       indent++;
1135
1136       while(it.Next())
1137       {
1138          MapNode n = (MapNode)it.pointer;
1139          if(!isFirst)
1140             f.Puts(",\n");
1141          else
1142             isFirst = false;
1143          for(i = 0; i<indent; i++) f.Puts("   ");
1144          WriteONObject(f, mapNodeClass, n, indent, eCON, eCON ? true : false);
1145       }
1146       f.Puts("\n");
1147       indent--;
1148       for(i = 0; i<indent; i++) f.Puts("   ");
1149       f.Puts("]");
1150    }
1151    else
1152       f.Puts("null");
1153    return true;
1154 }
1155
1156 static bool WriteArray(File f, Class type, Container array, int indent, bool eCON)
1157 {
1158    if(array)
1159    {
1160       int i;
1161       bool isFirst = true;
1162       Iterator it { array };
1163       Class arrayType = type.templateArgs[0].dataTypeClass;
1164       f.Puts("[\n");
1165       indent++;
1166
1167       while(it.Next())
1168       {
1169          DataValue value { };
1170          uint64 t = ((uint64(*)(void *, void *))(void *)array.GetData)(array, it.pointer);
1171          if(!isFirst)
1172             f.Puts(",\n");
1173          else
1174             isFirst = false;
1175
1176          // Add value
1177          // TODO: Verify the matching between template type and uint64
1178          if(arrayType.type == structClass)
1179          {
1180             value.p = (void *)(uintptr)t;
1181          }
1182          else if(arrayType == class(double) || !strcmp(arrayType.dataTypeString, "double"))
1183          {
1184             value.ui64 = t;
1185             //value.d = *(double *)&t;
1186          }
1187          else if(arrayType == class(float) || !strcmp(arrayType.dataTypeString, "float"))
1188          {
1189             value.ui = (uint)t;
1190             //value.f = *(float *)&t;
1191          }
1192          else if(arrayType.typeSize == sizeof(int64) || !strcmp(arrayType.dataTypeString, "int64") ||
1193             !strcmp(arrayType.dataTypeString, "unsigned int64") || !strcmp(arrayType.dataTypeString, "uint64"))
1194          {
1195             value.ui64 = t;
1196          }
1197          else if(arrayType.typeSize == sizeof(int) || !strcmp(arrayType.dataTypeString, "int") ||
1198             !strcmp(arrayType.dataTypeString, "unsigned int") || !strcmp(arrayType.dataTypeString, "uint"))
1199          {
1200             value.i = (int)t;
1201          }
1202          else if(arrayType.typeSize == sizeof(short int) || !strcmp(arrayType.dataTypeString, "short") ||
1203             !strcmp(arrayType.dataTypeString, "unsigned short") || !strcmp(arrayType.dataTypeString, "uint16") ||
1204             !strcmp(arrayType.dataTypeString, "int16"))
1205          {
1206             value.s = (short)t;
1207          }
1208          else if(arrayType.typeSize == sizeof(byte) || !strcmp(arrayType.dataTypeString, "char") ||
1209             !strcmp(arrayType.dataTypeString, "unsigned char") || !strcmp(arrayType.dataTypeString, "byte"))
1210          {
1211             value.c = (char)t;
1212          }
1213          else
1214          {
1215             value.p = (void *)(uintptr)t;
1216          }
1217          for(i = 0; i<indent; i++) f.Puts("   ");
1218          WriteValue(f, arrayType, value, indent, eCON);
1219       }
1220       f.Puts("\n");
1221       indent--;
1222       for(i = 0; i<indent; i++) f.Puts("   ");
1223       f.Puts("]");
1224    }
1225    else
1226       f.Puts("null");
1227    return true;
1228 }
1229
1230 static bool WriteNumber(File f, Class type, DataValue value, int indent, bool eCON)
1231 {
1232    char buffer[1024];
1233    bool needClass = eCON;
1234    bool quote;
1235    buffer[0] = 0;
1236    if(type == class(double) || !strcmp(type.dataTypeString, "double"))
1237       ((const char *(*)(void *, void *, char *, void *, bool *))(void *)type._vTbl[__ecereVMethodID_class_OnGetString])(type, &value.d, buffer, 0, &needClass);
1238    else if(type == class(float) || !strcmp(type.dataTypeString, "float"))
1239       ((const char *(*)(void *, void *, char *, void *, bool *))(void *)type._vTbl[__ecereVMethodID_class_OnGetString])(type, &value.f, buffer, null, &needClass);
1240    else if(!strcmp(type.dataTypeString, "int64"))
1241       ((const char *(*)(void *, void *, char *, void *, bool *))(void *)type._vTbl[__ecereVMethodID_class_OnGetString])(type, &value.i64, buffer, null, &needClass);
1242    else if(!strcmp(type.dataTypeString, "unsigned int64") || !strcmp(type.dataTypeString, "uint64") || type.typeSize == sizeof(int64))
1243       ((const char *(*)(void *, void *, char *, void *, bool *))(void *)type._vTbl[__ecereVMethodID_class_OnGetString])(type, &value.ui64, buffer, null, &needClass);
1244    else if(!strcmp(type.dataTypeString, "int"))
1245       ((const char *(*)(void *, void *, char *, void *, bool *))(void *)type._vTbl[__ecereVMethodID_class_OnGetString])(type, &value.i, buffer, null, &needClass);
1246    else if(!strcmp(type.dataTypeString, "unsigned int") || !strcmp(type.dataTypeString, "uint") || type.typeSize == sizeof(int))
1247       ((const char *(*)(void *, void *, char *, void *, bool *))(void *)type._vTbl[__ecereVMethodID_class_OnGetString])(type, &value.ui, buffer, null, &needClass);
1248    else if(!strcmp(type.dataTypeString, "short") || !strcmp(type.dataTypeString, "int16"))
1249       ((const char *(*)(void *, void *, char *, void *, bool *))(void *)type._vTbl[__ecereVMethodID_class_OnGetString])(type, &value.s, buffer, null, &needClass);
1250    else if(!strcmp(type.dataTypeString, "unsigned short") || !strcmp(type.dataTypeString, "uint16") || type.typeSize == sizeof(short int))
1251       ((const char *(*)(void *, void *, char *, void *, bool *))(void *)type._vTbl[__ecereVMethodID_class_OnGetString])(type, &value.us, buffer, null, &needClass);
1252    else if(!strcmp(type.dataTypeString, "char"))
1253       ((const char *(*)(void *, void *, char *, void *, bool *))(void *)type._vTbl[__ecereVMethodID_class_OnGetString])(type, &value.c, buffer, null, &needClass);
1254    else if(!strcmp(type.dataTypeString, "unsigned char") || !strcmp(type.dataTypeString, "byte") || type.typeSize == sizeof(byte))
1255       ((const char *(*)(void *, void *, char *, void *, bool *))(void *)type._vTbl[__ecereVMethodID_class_OnGetString])(type, &value.uc, buffer, null, &needClass);
1256
1257    quote = (type.type == unitClass && ((buffer[0] != '.' && !isdigit(buffer[0])) || strchr(buffer, ' '))) ||
1258            (type.type == enumClass && !eCON);
1259    if(quote) f.Puts("\"");
1260    f.Puts(buffer);
1261    if(quote) f.Puts("\"");
1262    return true;
1263 }
1264
1265 public bool WriteColorAlpha(File f, Class type, DataValue value, int indent, bool eCON)
1266 {
1267    char buffer[1024];
1268    char * string = buffer;
1269    ColorAlpha color = value.i;
1270    int a = color.a;
1271    int len;
1272    DefinedColor c = color;
1273    buffer[0] = '\0';
1274    if(a != 255)
1275    {
1276       a.class::OnGetString(buffer, null, null);
1277       len = strlen(buffer);
1278       buffer[len++] = ',';
1279       buffer[len++] = ' ';
1280       buffer[len] = '\0';
1281       string += len;
1282    }
1283    if(!c.class::OnGetString(string, null, null))
1284       sprintf(buffer, "0x%x", color);
1285    if(!eCON)
1286       f.Puts("\"");
1287    f.Puts(buffer);
1288    if(!eCON)
1289       f.Puts("\"");
1290    return true;
1291 }
1292
1293 static bool WriteValue(File f, Class type, DataValue value, int indent, bool eCON)
1294 {
1295    if(!strcmp(type.name, "String") || !strcmp(type.dataTypeString, "char *"))
1296    {
1297       if(!value.p)
1298          f.Puts("null");
1299       else
1300       {
1301          f.Puts("\"");
1302          //if(strchr(value.p, '\"') || strchr(value.p, '\\'))
1303          if(eCON)
1304          {
1305             int c = 0;
1306             int b = 0;
1307             char buffer[1024];
1308             char * string = value.p;
1309             char ch;
1310             while(true)
1311             {
1312                ch = string[c++];
1313                if(ch == '\"')
1314                {
1315                   buffer[b] = 0;
1316                   f.Puts(buffer);
1317                   f.Puts("\\\"");
1318                   b = 0;
1319                }
1320                else if(ch == '\\')
1321                {
1322                   buffer[b] = 0;
1323                   f.Puts(buffer);
1324                   f.Puts("\\\\");
1325                   b = 0;
1326                }
1327                else if(ch == '\t')
1328                {
1329                   buffer[b] = 0;
1330                   f.Puts(buffer);
1331                   f.Puts("\\t");
1332                   b = 0;
1333                }
1334                else if(ch == '\n')
1335                {
1336                   int i;
1337                   buffer[b] = 0;
1338                   f.Puts(buffer);
1339                   f.Puts("\\n\"\n");
1340                   for(i = 0; i<indent; i++) f.Puts("   ");
1341                   f.Puts("   \"");
1342                   b = 0;
1343                }
1344                else if(b == sizeof(buffer)-2 || !ch)
1345                {
1346                   buffer[b++] = ch;
1347                   if(ch) buffer[b] = 0;
1348                   f.Puts(buffer);
1349                   b = 0;
1350                   if(!ch) break;
1351                }
1352                else
1353                   buffer[b++] = ch;
1354             }
1355          }
1356          else
1357          {
1358             int c = 0;
1359             int b = 0;
1360             char buffer[1024];
1361             char * string = value.p;
1362             char ch;
1363             while(true)
1364             {
1365                ch = string[c++];
1366                if(ch == '\"')
1367                {
1368                   buffer[b] = 0;
1369                   f.Puts(buffer);
1370                   f.Puts("\\\"");
1371                   b = 0;
1372                }
1373                else if(ch == '\\')
1374                {
1375                   buffer[b] = 0;
1376                   f.Puts(buffer);
1377                   f.Puts("\\\\");
1378                   b = 0;
1379                }
1380                else if(b == sizeof(buffer)-2 || !ch)
1381                {
1382                   buffer[b++] = ch;
1383                   if(ch) buffer[b] = 0;
1384                   f.Puts(buffer);
1385                   b = 0;
1386                   if(!ch) break;
1387                }
1388                else
1389                   buffer[b++] = ch;
1390             }
1391          }
1392          /*else
1393             f.Puts(value.p);*/
1394          f.Puts("\"");
1395       }
1396    }
1397    else if(!strcmp(type.name, "bool"))
1398    {
1399       if(value.i)
1400          f.Puts("true");
1401       else
1402          f.Puts("false");
1403    }
1404    else if(!strcmp(type.name, "SetBool"))
1405    {
1406       if(value.i == SetBool::true)
1407          f.Puts("true");
1408       else if(value.i == SetBool::false)
1409          f.Puts("false");
1410       else
1411          f.Puts("unset");
1412    }
1413    else if(type.type == enumClass)
1414       WriteNumber(f, type, value, indent, eCON);
1415    else if(eClass_IsDerived(type, class(Map)))
1416    {
1417       WriteMap(f, type, value.p, indent, eCON);
1418    }
1419    else if(eClass_IsDerived(type, class(Container)))
1420    {
1421       WriteArray(f, type, value.p, indent, eCON);
1422    }
1423    else if(type.type == normalClass || type.type == noHeadClass || type.type == structClass)
1424    {
1425       WriteONObject(f, type, value.p, indent, eCON, false);
1426    }
1427    else if(eClass_IsDerived(type, class(ColorAlpha)))
1428    {
1429       WriteColorAlpha(f, type, value, indent, eCON);
1430    }
1431    else if(type.type == bitClass)
1432    {
1433       Class dataType;
1434       dataType = superFindClass(type.dataTypeString, type.module);
1435       WriteNumber(f, dataType, value, indent, eCON);
1436    }
1437    else if(type.type == systemClass || type.type == unitClass)
1438    {
1439       WriteNumber(f, type, value, indent, eCON);
1440    }
1441    return true;
1442 }
1443
1444 public bool WriteJSONObject(File f, Class objectType, void * object, int indent)
1445 {
1446    bool result = false;
1447    if(object)
1448    {
1449       result = WriteONObject(f, objectType, object, indent, false, false);
1450       f.Puts("\n");
1451    }
1452    return result;
1453 }
1454
1455 public bool WriteECONObject(File f, Class objectType, void * object, int indent)
1456 {
1457    bool result = false;
1458    if(object)
1459    {
1460       result = WriteONObject(f, objectType, object, indent, true, false);
1461       f.Puts("\n");
1462    }
1463    return result;
1464 }
1465
1466 static bool WriteONObject(File f, Class objectType, void * object, int indent, bool eCON, bool omitDefaultIdentifier)
1467 {
1468    if(object)
1469    {
1470       const char * string = null;
1471
1472       if(objectType._vTbl[__ecereVMethodID_class_OnGetString] != objectType.base._vTbl[__ecereVMethodID_class_OnGetString])
1473       {
1474          char buffer[1024];
1475          buffer[0] = 0;
1476          string = ((const char *(*)())(void *)objectType._vTbl[__ecereVMethodID_class_OnGetString])(objectType, object, buffer, null, null);
1477       }
1478       if(string)
1479       {
1480          // TOCHECK: ProjectNode.ec why do we add quotes in OnGetString there?
1481          if(string[0] == '\"')
1482             f.Puts(string);
1483          else
1484          {
1485             f.Puts("\"");
1486             f.Puts(string);
1487             f.Puts("\"");
1488          }
1489       }
1490       else
1491       {
1492          Class _class = (eCON && objectType.type == normalClass) ? ((Instance)object)._class : objectType;
1493          Property prop;
1494          int c;
1495          bool isFirst = true;
1496          Class mapKeyClass = null, mapDataClass = null;
1497          Class baseClass;
1498          List<Class> bases { };
1499
1500          if(objectType.templateClass && eClass_IsDerived(objectType.templateClass, class(MapNode)))
1501          {
1502             mapKeyClass = objectType.templateArgs[0].dataTypeClass;
1503             mapDataClass = objectType.templateArgs[2].dataTypeClass;
1504          }
1505
1506          if(eCON && _class != objectType && eClass_IsDerived(_class, objectType))
1507          {
1508             f.Puts(_class.name);
1509             f.Puts(" ");
1510          }
1511
1512          f.Puts("{\n");
1513          indent++;
1514
1515          for(baseClass = _class; baseClass; baseClass = baseClass.base)
1516          {
1517             if(baseClass.isInstanceClass || !baseClass.base)
1518                break;
1519             bases.Insert(null, baseClass);
1520          }
1521
1522          for(baseClass : bases)
1523          {
1524             for(prop = baseClass.membersAndProperties.first; prop; prop = prop.next)
1525             {
1526                if(prop.memberAccess != publicAccess || (prop.isProperty && (!prop.Set || !prop.Get))) continue;
1527                if(prop.isProperty)
1528                {
1529                   if(!prop.conversion && (!prop.IsSet || prop.IsSet(object)))
1530                   {
1531                      DataValue value { };
1532                      bool isTemplateArg = false;
1533                      Class type;
1534
1535                      if(mapKeyClass && !strcmp(prop.name, "key"))
1536                      {
1537                         isTemplateArg = true;
1538                         type = mapKeyClass;
1539                      }
1540                      else if(mapDataClass && !strcmp(prop.name, "value"))
1541                      {
1542                         isTemplateArg = true;
1543                         type = mapDataClass;
1544                      }
1545                      else
1546                         type = superFindClass(prop.dataTypeString, _class.module);
1547
1548                      if(!type)
1549                         PrintLn("warning: Unresolved data type ", (String)prop.dataTypeString);
1550                      else
1551                      {
1552                         if(type.type == enumClass || type.type == bitClass || type.type == unitClass || type.type == systemClass)
1553                         {
1554                            // TOFIX: How to swiftly handle classes with base data type?
1555                            if(type == class(double) || !strcmp(type.dataTypeString, "double"))
1556                            {
1557                               value.d = ((double (*)(void *))(void *)prop.Get)(object);
1558                            }
1559                            else if(type == class(float) || !strcmp(type.dataTypeString, "float"))
1560                            {
1561                               value.f = ((float (*)(void *))(void *)prop.Get)(object);
1562                            }
1563                            else if(type.typeSize == sizeof(int64) || !strcmp(type.dataTypeString, "int64") ||
1564                               !strcmp(type.dataTypeString, "unsigned int64") || !strcmp(type.dataTypeString, "uint64"))
1565                            {
1566                               value.ui64 = ((uint64 (*)(void *))(void *)prop.Get)(object);
1567                            }
1568                            else if(type.typeSize == sizeof(int) || !strcmp(type.dataTypeString, "int") ||
1569                               !strcmp(type.dataTypeString, "unsigned int") || !strcmp(type.dataTypeString, "uint"))
1570                            {
1571                               value.i = ((int (*)(void *))(void *)prop.Get)(object);
1572                            }
1573                            else if(type.typeSize == sizeof(short int) || !strcmp(type.dataTypeString, "short") ||
1574                               !strcmp(type.dataTypeString, "unsigned short") || !strcmp(type.dataTypeString, "uint16") ||
1575                               !strcmp(type.dataTypeString, "int16"))
1576                            {
1577                               value.s = ((short (*)(void *))(void *)prop.Get)(object);
1578                            }
1579                            else if(type.typeSize == sizeof(byte) || !strcmp(type.dataTypeString, "char") ||
1580                               !strcmp(type.dataTypeString, "unsigned char") || !strcmp(type.dataTypeString, "byte"))
1581                            {
1582                               value.c = ((char (*)(void *))(void *)prop.Get)(object);
1583                            }
1584                         }
1585                         else if(type.type == structClass)
1586                         {
1587                            value.p = new0 byte[type.structSize];
1588                            ((void (*)(void *, void *))(void *)prop.Get)(object, value.p);
1589                         }
1590                         else
1591                         {
1592                            if(isTemplateArg)
1593                               value.p = (void *)(uintptr)((uint64 (*)(void *))(void *)prop.Get)(object);
1594                            else
1595                               value.p = ((void *(*)(void *))(void *)prop.Get)(object);
1596                         }
1597
1598                         if(!isFirst) f.Puts(",\n");
1599                         for(c = 0; c<indent; c++) f.Puts("   ");
1600
1601                         if(!eCON)
1602                         {
1603                            f.Puts("\"");
1604                            f.Putc((char)toupper(prop.name[0]));
1605                            f.Puts(prop.name+1);
1606                            f.Puts("\" : ");
1607                         }
1608                         else if(!omitDefaultIdentifier)
1609                         {
1610                            f.Puts(prop.name);
1611                            f.Puts(" = ");
1612                         }
1613                         WriteValue(f, type, value, indent, eCON);
1614                         isFirst = false;
1615                         if(type.type == structClass)
1616                            delete value.p;
1617                      }
1618                   }
1619                }
1620                else
1621                {
1622                   DataMember member = (DataMember)prop;
1623                   DataValue value { };
1624                   uint offset;
1625                   Class type = superFindClass(member.dataTypeString, _class.module);
1626                   offset = member._class.offset + member.offset;
1627
1628                   if(type)
1629                   {
1630                      if(type.type == normalClass || type.type == noHeadClass || type.type == structClass || !strcmp(type.name, "String"))
1631                      {
1632                         if(type.type == structClass)
1633                            value.p = (void *)((byte *)object + offset);
1634                         else
1635                            value.p = *(void **)((byte *)object + offset);
1636                         if(!value.p)
1637                            continue;
1638                      }
1639                      else if(type == class(double) || !strcmp(type.dataTypeString, "double"))
1640                      {
1641                         value.d = *(double *)((byte *)object + offset);
1642                      }
1643                      else if(type == class(float) || !strcmp(type.dataTypeString, "float"))
1644                      {
1645                         value.f = *(float *)((byte *)object + offset);
1646                      }
1647                      else if(type.typeSize == sizeof(int64) || !strcmp(type.dataTypeString, "int64") ||
1648                         !strcmp(type.dataTypeString, "unsigned int64") || !strcmp(type.dataTypeString, "uint64"))
1649                      {
1650                         value.ui64 = *(uint64 *)((byte *)object + offset);
1651                      }
1652                      else if(type.typeSize == sizeof(int) || !strcmp(type.dataTypeString, "int") ||
1653                         !strcmp(type.dataTypeString, "unsigned int") || !strcmp(type.dataTypeString, "uint"))
1654                      {
1655                         value.i = *(int *)((byte *)object + offset);
1656                         if(!strcmp(type.name, "bool") || type.type == enumClass)
1657                            if(!value.i)
1658                               continue;
1659                      }
1660                      else if(type.typeSize == sizeof(short int) || !strcmp(type.dataTypeString, "short") ||
1661                         !strcmp(type.dataTypeString, "unsigned short") || !strcmp(type.dataTypeString, "uint16") ||
1662                         !strcmp(type.dataTypeString, "int16"))
1663                      {
1664                         value.s = *(short *)((byte *)object + offset);
1665                      }
1666                      else if(type.typeSize == sizeof(byte) || !strcmp(type.dataTypeString, "char") ||
1667                         !strcmp(type.dataTypeString, "unsigned char") || !strcmp(type.dataTypeString, "byte"))
1668                      {
1669                         value.c = *(char *)((byte *)object + offset);
1670                      }
1671                      else
1672                      {
1673                         value.i = *(int *)((byte *)object + offset);
1674                      }
1675
1676                      if(!isFirst) f.Puts(",\n");
1677                      for(c = 0; c<indent; c++) f.Puts("   ");
1678
1679                      if(!eCON)
1680                      {
1681                         f.Puts("\"");
1682                         f.Putc((char)toupper(member.name[0]));
1683                         f.Puts(member.name+1);
1684                         f.Puts("\" : ");
1685                      }
1686                      else if(!omitDefaultIdentifier)
1687                      {
1688                         f.Puts(member.name);
1689                         f.Puts(" = ");
1690                      }
1691                      WriteValue(f, type, value, indent, eCON);
1692                      isFirst = false;
1693                   }
1694                }
1695             }
1696          }
1697
1698          delete bases;
1699
1700          indent--;
1701          f.Puts("\n");
1702          for(c = 0; c<indent; c++) f.Puts("   "); f.Puts("}");
1703       }
1704    }
1705    else
1706       f.Puts("null");
1707    return true;
1708 }
1709
1710 static Class superFindClass(const String name, Module alternativeModule)
1711 {
1712    Class _class = eSystem_FindClass(__thisModule, name);
1713    if(!_class && alternativeModule)
1714       _class = eSystem_FindClass(alternativeModule, name);
1715    if(!_class)
1716       _class = eSystem_FindClass(__thisModule.application, name);
1717    return _class;
1718 }
1719
1720 static bool isSubclass(Class type, const String name)
1721 {
1722    Class _class = superFindClass(name, type.module);
1723    if(eClass_IsDerived(_class, type))
1724       return true;
1725    return false;
1726 }