scilab/modules/hdf5/sci_gateway/cpp/sci_hdf5_load_v3.cpp

   1 /*
   2 * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
   3 * Copyright (C) 2015 - Scilab Enterprises - Antoine ELIAS
   4 *
   5  * Copyright (C) 2012 - 2016 - Scilab Enterprises
   6  *
   7  * This file is hereby licensed under the terms of the GNU GPL v2.0,
   8  * pursuant to article 5.3.4 of the CeCILL v.2.1.
   9  * This file was originally licensed under the terms of the CeCILL v2.1,
  10  * and continues to be available under such terms.
  11  * For more information, see the COPYING file which you should have received
  12  * along with this program.
  13 *
  14 */
  15 #include <list>
  16 #include <unordered_map>
  17
  18 #include <hdf5.h>
  19 #include "hdf5_gw.hxx"
  20 #include "context.hxx"
  21 #include "string.hxx"
  22 #include "double.hxx"
  23 #include "struct.hxx"
  24 #include "cell.hxx"
  25 #include "int.hxx"
  26 #include "list.hxx"
  27 #include "tlist.hxx"
  28 #include "mlist.hxx"
  29 #include "polynom.hxx"
  30 #include "sparse.hxx"
  31 #include "graphichandle.hxx"
  32 #include "macro.hxx"
  33 #include "void.hxx"
  34 #include "listundefined.hxx"
  35 #include "context.hxx"
  36 #include "handle_properties.hxx"
  37 #include "deserializervisitor.hxx"
  38 #include "overload.hxx"
  39
  40 std::unordered_map<int, Links::PathList> Links::paths;
  41
  42 extern "C"
  43 {
  44 #include "sci_malloc.h"
  45 #include "Scierror.h"
  46 #include "localization.h"
  47 #include "freeArrayOfString.h"
  48 #include "os_string.h"
  49 #include "deleteafile.h"
  50 #include "expandPathVariable.h"
  51 #include "h5_fileManagement.h"
  52 #include "h5_writeDataToFile.h"
  53 #include "h5_readDataFromFile.h"
  54 #include "h5_attributeConstants.h"
  55 #include "HandleManagement.h"
  56
  57 }
  58 /*--------------------------------------------------------------------------*/
  59 static bool import_variable(int file, std::string& name);
  60 types::InternalType* import_data(int dataset);
  61 static types::InternalType* import_double(int dataset);
  62 static types::InternalType* import_string(int dataset);
  63 static types::InternalType* import_boolean(int dataset);
  64 static types::InternalType* import_int(int dataset);
  65 static types::InternalType* import_list(int dataset, types::List* lst);
  66 static types::InternalType* import_struct(int dataset);
  67 static types::InternalType* import_poly(int dataset);
  68 static types::InternalType* import_cell(int dataset);
  69 static types::InternalType* import_handles(int dataset);
  70 static types::InternalType* import_sparse(int dataset);
  71 static types::InternalType* import_boolean_sparse(int dataset);
  72 static types::InternalType* import_macro(int dataset);
  73 static types::InternalType* import_usertype(int dataset);
  74
  75
  76 /*--------------------------------------------------------------------------*/
  77 static const std::string fname("load");
  78 /*--------------------------------------------------------------------------*/
  79 types::Function::ReturnValue sci_hdf5_load_v3(types::typed_list &in, int _iRetCount, types::typed_list &out)
  80 {
  81     std::string filename;
  82     int rhs = static_cast<int>(in.size());
  83
  84     if (rhs < 1)
  85     {
  86         Scierror(999, _("%s: Wrong number of input argument(s): at least %d expected.\n"), fname.data(), 1);
  87         return types::Function::Error;
  88     }
  89
  90     if (in[0]->getId() != types::InternalType::IdScalarString)
  91     {
  92         Scierror(999, _("%s: Wrong size for input argument #%d: string expected.\n"), fname.data(), 1);
  93         return types::Function::Error;
  94     }
  95
  96     wchar_t* wfilename = expandPathVariableW(in[0]->getAs<types::String>()->get()[0]);
  97     char* cfilename = wide_string_to_UTF8(wfilename);
  98     filename = cfilename;
  99     FREE(wfilename);
 100     FREE(cfilename);
 101
 102     int iFile = openHDF5File(filename.data(), 0);
 103     if (iFile < 0)
 104     {
 105         Scierror(999, _("%s: Unable to open file: %s\n"), fname.data(), filename.data());
 106         return types::Function::Error;
 107     }
 108
 109     //manage version information
 110     int iVersion = getSODFormatAttribute(iFile);
 111     if (iVersion != SOD_FILE_VERSION)
 112     {
 113         //can't read file with version newer that me !
 114         Scierror(999, _("%s: Wrong SOD file format version. Expected: %d Found: %d\n"), fname.data(), SOD_FILE_VERSION, iVersion);
 115         return types::Function::Error;
 116     }
 117
 118     if (rhs > 1)
 119     {
 120         for (int i = 1; i < rhs; ++i)
 121         {
 122             std::string var;
 123             char* cvar = wide_string_to_UTF8(in[i]->getAs<types::String>()->get()[0]);
 124             var = cvar;
 125             FREE(cvar);
 126
 127             if (import_variable(iFile, var) == false)
 128             {
 129                 Scierror(999, _("%s: Unable to load \'%s\'.\n"), fname.data(), var.data());
 130                 return types::Function::Error;
 131             }
 132         }
 133     }
 134     else
 135     {
 136         //restore all variables
 137         int iNbItem = 0;
 138         iNbItem = getVariableNames6(iFile, NULL);
 139         if (iNbItem != 0)
 140         {
 141             std::vector<char*> vars(iNbItem);
 142             iNbItem = getVariableNames6(iFile, vars.data());
 143             for (auto & var : vars)
 144             {
 145                 std::string s(var);
 146                 FREE(var);
 147                 if (import_variable(iFile, s) == false)
 148                 {
 149                     Scierror(999, _("%s: Unable to load \'%s\'.\n"), fname.data(), s.data());
 150                     return types::Function::Error;
 151                 }
 152             }
 153         }
 154     }
 155
 156     //close the file
 157     closeHDF5File(iFile);
 158
 159     out.push_back(new types::Bool(1));
 160     return types::Function::OK;
 161 }
 162
 163 static bool import_variable(int file, std::string& name)
 164 {
 165     int dataset = getDataSetIdFromName(file, name.data());
 166     if (dataset <= 0)
 167     {
 168         return false;
 169     }
 170
 171     types::InternalType* data = import_data(dataset);
 172     if (data != nullptr)
 173     {
 174         wchar_t* var = to_wide_string(name.data());
 175         //update macro name
 176         if (data->isMacro())
 177         {
 178             types::Macro* macro = data->getAs<types::Macro>();
 179             macro->setName(var);
 180             symbol::Context::getInstance()->addMacro(macro);
 181         }
 182         else
 183         {
 184             //add to context
 185             symbol::Context::getInstance()->put(symbol::Symbol(var), data);
 186         }
 187         FREE(var);
 188         return true;
 189     }
 190
 191     return false;
 192 }
 193
 194 types::InternalType* import_data(int dataset)
 195 {
 196     //get var type
 197     char* ctype = getScilabTypeFromDataSet6(dataset);
 198     std::string type(ctype);
 199     FREE(ctype);
 200
 201     if (type == g_SCILAB_CLASS_DOUBLE)
 202     {
 203         return import_double(dataset);
 204     }
 205
 206     if (type == g_SCILAB_CLASS_STRING)
 207     {
 208         return import_string(dataset);
 209     }
 210
 211     if (type == g_SCILAB_CLASS_INT)
 212     {
 213         return import_int(dataset);
 214     }
 215
 216     if (type == g_SCILAB_CLASS_BOOLEAN)
 217     {
 218         return import_boolean(dataset);
 219     }
 220
 221     if (type == g_SCILAB_CLASS_LIST)
 222     {
 223         return import_list(dataset, new types::List());
 224     }
 225
 226     if (type == g_SCILAB_CLASS_TLIST)
 227     {
 228         return import_list(dataset, new types::TList());
 229     }
 230
 231     if (type == g_SCILAB_CLASS_MLIST)
 232     {
 233         return import_list(dataset, new types::MList());
 234     }
 235
 236     if (type == g_SCILAB_CLASS_STRUCT)
 237     {
 238         return import_struct(dataset);
 239     }
 240
 241     if (type == g_SCILAB_CLASS_POLY)
 242     {
 243         return import_poly(dataset);
 244     }
 245
 246     if (type == g_SCILAB_CLASS_SPARSE)
 247     {
 248         return import_sparse(dataset);
 249     }
 250
 251     if (type == g_SCILAB_CLASS_BSPARSE)
 252     {
 253         return import_boolean_sparse(dataset);
 254     }
 255
 256     if (type == g_SCILAB_CLASS_CELL)
 257     {
 258         return import_cell(dataset);
 259     }
 260
 261     if (type == g_SCILAB_CLASS_HANDLE)
 262     {
 263         return import_handles(dataset);
 264     }
 265
 266     if (type == g_SCILAB_CLASS_MACRO)
 267     {
 268         return import_macro(dataset);
 269     }
 270
 271     if (type == g_SCILAB_CLASS_VOID)
 272     {
 273         closeDataSet(dataset);
 274         return new types::Void();
 275     }
 276
 277     if (type == g_SCILAB_CLASS_UNDEFINED)
 278     {
 279         closeDataSet(dataset);
 280         return new types::ListUndefined();
 281     }
 282
 283     if (type == g_SCILAB_CLASS_USERTYPE)
 284     {
 285         return import_usertype(dataset);
 286     }
 287
 288
 289     return nullptr;
 290 }
 291
 292 static types::InternalType* import_double(int dataset)
 293 {
 294     int complex = 0;
 295     int dims = 0;
 296     int ret = getDatasetInfo(dataset, &complex, &dims, NULL);
 297     if (ret < 0)
 298     {
 299         closeDataSet(dataset);
 300         return nullptr;
 301     }
 302
 303     std::vector<int> d(dims);
 304     int size = getDatasetInfo(dataset, &complex, &dims, d.data());
 305
 306
 307     if (dims == 0 || size == 0)
 308     {
 309         closeDataSet(dataset);
 310         return types::Double::Empty();
 311     }
 312
 313     types::Double* dbl = new types::Double(dims, d.data(), complex == 1);
 314
 315     double* real = dbl->get();
 316     double* img = dbl->getImg();
 317
 318     if (complex)
 319     {
 320         readDoubleComplexMatrix(dataset, real, img);
 321     }
 322     else
 323     {
 324         readDoubleMatrix(dataset, real);
 325     }
 326     return dbl;
 327 }
 328
 329 static types::InternalType* import_string(int dataset)
 330 {
 331     int complex = 0;
 332     int dims = 0;
 333     int ret = getDatasetInfo(dataset, &complex, &dims, NULL);
 334     if (ret < 0)
 335     {
 336         closeDataSet(dataset);
 337         return nullptr;
 338     }
 339
 340
 341     std::vector<int> d(dims);
 342     int size = getDatasetInfo(dataset, &complex, &dims, d.data());
 343
 344
 345     if (dims == 0 || size == 0)
 346     {
 347         closeDataSet(dataset);
 348         return types::Double::Empty();
 349     }
 350
 351     std::vector<char*> s(size);
 352     ret = readStringMatrix(dataset, s.data());
 353
 354     types::String* str = new types::String(dims, d.data());
 355     wchar_t** pstr = str->get();
 356
 357     for (int i = 0; i < size; ++i)
 358     {
 359         pstr[i] = to_wide_string(s[i]);
 360     }
 361
 362     freeStringMatrix(dataset, s.data());
 363
 364     return str;
 365 }
 366
 367 static types::InternalType* import_boolean(int dataset)
 368 {
 369     int complex = 0;
 370     int dims = 0;
 371     int ret = getDatasetInfo(dataset, &complex, &dims, NULL);
 372     if (ret < 0)
 373     {
 374         closeDataSet(dataset);
 375         return nullptr;
 376     }
 377
 378     std::vector<int> d(dims);
 379     int size = getDatasetInfo(dataset, &complex, &dims, d.data());
 380
 381
 382     if (dims == 0 || size == 0)
 383     {
 384         closeDataSet(dataset);
 385         return types::Double::Empty();
 386     }
 387
 388     types::Bool* bools = new types::Bool(dims, d.data());
 389
 390     int* b = bools->get();
 391     readBooleanMatrix(dataset, b);
 392     return bools;
 393 }
 394
 395 static types::InternalType* import_int(int dataset)
 396 {
 397     types::InternalType* pOut = nullptr;
 398     int complex = 0;
 399     int dims = 0;
 400     int ret = getDatasetInfo(dataset, &complex, &dims, NULL);
 401     if (ret < 0)
 402     {
 403         closeDataSet(dataset);
 404         return nullptr;
 405     }
 406
 407     std::vector<int> d(dims);
 408     int size = getDatasetInfo(dataset, &complex, &dims, d.data());
 409
 410
 411     if (dims == 0 || size == 0)
 412     {
 413         closeDataSet(dataset);
 414         return types::Double::Empty();
 415     }
 416
 417     int prec = 0;
 418     ret = getDatasetPrecision(dataset, &prec);
 419     if (ret != 0)
 420     {
 421         closeDataSet(dataset);
 422         return nullptr;
 423     }
 424
 425     switch (prec)
 426     {
 427         case SCI_INT8:
 428         {
 429             types::Int8* pi = new types::Int8(dims, d.data());
 430             ret = readInteger8Matrix(dataset, pi->get());
 431             pOut = pi;
 432             break;
 433         }
 434         case SCI_INT16:
 435         {
 436             types::Int16* pi = new types::Int16(dims, d.data());
 437             ret = readInteger16Matrix(dataset, pi->get());
 438             pOut = pi;
 439             break;
 440         }
 441         case SCI_INT32:
 442         {
 443             types::Int32* pi = new types::Int32(dims, d.data());
 444             ret = readInteger32Matrix(dataset, pi->get());
 445             pOut = pi;
 446             break;
 447         }
 448         case SCI_INT64:
 449         {
 450             types::Int64* pi = new types::Int64(dims, d.data());
 451             ret = readInteger64Matrix(dataset, pi->get());
 452             pOut = pi;
 453             break;
 454         }
 455         case SCI_UINT8:
 456         {
 457             types::UInt8* pi = new types::UInt8(dims, d.data());
 458             ret = readUnsignedInteger8Matrix(dataset, pi->get());
 459             pOut = pi;
 460             break;
 461         }
 462         case SCI_UINT16:
 463         {
 464             types::UInt16* pi = new types::UInt16(dims, d.data());
 465             ret = readUnsignedInteger16Matrix(dataset, pi->get());
 466             pOut = pi;
 467             break;
 468         }
 469         case SCI_UINT32:
 470         {
 471             types::UInt32* pi = new types::UInt32(dims, d.data());
 472             ret = readUnsignedInteger32Matrix(dataset, pi->get());
 473             pOut = pi;
 474             break;
 475         }
 476         case SCI_UINT64:
 477         {
 478             types::UInt64* pi = new types::UInt64(dims, d.data());
 479             ret = readUnsignedInteger64Matrix(dataset, pi->get());
 480             pOut = pi;
 481             break;
 482         }
 483         default:
 484             return nullptr;
 485             break;
 486     }
 487
 488     return pOut;
 489 }
 490
 491 static types::InternalType* import_list(int dataset, types::List* lst)
 492 {
 493     int count = 0;
 494     int ret  = getListDims6(dataset, &count);
 495     if (ret)
 496     {
 497         closeList6(dataset);
 498         delete lst;
 499         return nullptr;
 500     }
 501
 502     if (count == 0)
 503     {
 504         closeList6(dataset);
 505         return lst;
 506     }
 507
 508     //get children
 509
 510     for (int i = 0; i < count; ++i)
 511     {
 512         int data = getDataSetIdFromName(dataset, std::to_string(i).data());
 513         if (data <= 0)
 514         {
 515             closeList6(dataset);
 516             delete lst;
 517             return nullptr;
 518         }
 519
 520         types::InternalType* child = import_data(data);
 521         if (child == nullptr)
 522         {
 523             closeList6(dataset);
 524             delete lst;
 525             return nullptr;
 526         }
 527
 528         lst->append(child);
 529         if (child->isList())
 530         {
 531             child->killMe();
 532         }
 533     }
 534
 535     closeList6(dataset);
 536     return lst;
 537 }
 538
 539 static int getDimsNode(int dataset, int* complex, std::vector<int>& dims)
 540 {
 541     dims.clear();
 542     int id = getDataSetIdFromName(dataset, "__dims__");
 543     if (id < 0)
 544     {
 545         return 0;
 546     }
 547
 548     //get dims dimension count
 549     int dim = 0;
 550     getDatasetInfo(id, complex, &dim, NULL);
 551     //get dims dimension
 552     std::vector<int> d(dim);
 553     int size = getDatasetInfo(id, complex, &dim, d.data());
 554
 555     //get dims value
 556     dims.resize(size);
 557     readInteger32Matrix(id, dims.data());
 558
 559     size = dims[0];
 560     for (int i = 1; i < dims.size(); ++i)
 561     {
 562         size *= dims[i];
 563     }
 564     return size;
 565 }
 566
 567 static types::InternalType* import_struct(int dataset)
 568 {
 569     //get struct dims node
 570     int complex = 0;
 571     std::vector<int> pdims;
 572     int size = getDimsNode(dataset, &complex, pdims);
 573
 574     types::Struct* str = new types::Struct(static_cast<int>(pdims.size()), pdims.data());
 575     size = str->getSize();
 576     if (size == 0)
 577     {
 578         //empty struct
 579         closeList6(dataset);
 580         delete str;
 581         return new types::Struct();
 582     }
 583
 584     types::SingleStruct** sstr = str->get();
 585
 586     int fieldCount = 0;
 587     int ret = getListDims6(dataset, &fieldCount);
 588     if (ret < 0)
 589     {
 590         closeList6(dataset);
 591         return str;
 592     }
 593
 594     //get fields name
 595     int dfield = getDataSetIdFromName(dataset, "__fields__");
 596     int dim = 0;
 597     getDatasetInfo(dfield, &complex, &dim, NULL);
 598     std::vector<int> d(dim);
 599     size = getDatasetInfo(dfield, &complex, &dim, d.data());
 600
 601     //get dims value
 602     std::vector<char*> fields(size);
 603     readStringMatrix(dfield, fields.data());
 604
 605     //open __refs__ node
 606     int refs = getDataSetIdFromName(dataset, "__refs__");
 607
 608     for (const auto & name : fields)
 609     {
 610         wchar_t* field = to_wide_string(name);
 611         str->addField(field);
 612
 613         int dataref = getDataSetIdFromName(dataset, name);
 614         if (dataref < 0)
 615         {
 616             closeList6(dataset);
 617             freeStringMatrix(dfield, fields.data());
 618             FREE(field);
 619             delete str;
 620             return nullptr;
 621         }
 622
 623         int refdim = 0;
 624         getDatasetInfo(dataref, &complex, &refdim, NULL);
 625         std::vector<int> refdims(refdim);
 626         int refcount = getDatasetInfo(dataref, &complex, &refdim, refdims.data());
 627         std::vector<hobj_ref_t> vrefs(refcount);
 628         ret = H5Dread(dataref, H5T_STD_REF_OBJ, H5S_ALL, H5S_ALL, H5P_DEFAULT, vrefs.data());
 629         if (ret < 0)
 630         {
 631             freeStringMatrix(dfield, fields.data());
 632             FREE(field);
 633             delete str;
 634             return nullptr;
 635         }
 636
 637
 638         //import field
 639         for (int j = 0; j < refcount; ++j)
 640         {
 641             int data = H5Rdereference(refs, H5R_OBJECT, &vrefs[j]);
 642             if (data < 0)
 643             {
 644                 freeStringMatrix(dfield, fields.data());
 645                 FREE(field);
 646                 delete str;
 647                 return nullptr;
 648             }
 649
 650             types::InternalType* val = import_data(data);
 651             if (val == nullptr)
 652             {
 653                 freeStringMatrix(dfield, fields.data());
 654                 FREE(field);
 655                 delete str;
 656                 return nullptr;
 657             }
 658
 659             sstr[j]->set(field, val);
 660
 661         }
 662
 663         FREE(field);
 664         closeDataSet(dataref);
 665     }
 666
 667     freeStringMatrix(dfield, fields.data());
 668     closeList6(refs);
 669     closeList6(dataset);
 670     return str;
 671 }
 672
 673 static types::InternalType* import_poly(int dataset)
 674 {
 675     //get poly dims node
 676     int complex = 0;
 677     std::vector<int> pdims;
 678     int size = getDimsNode(dataset, &complex, pdims);
 679
 680     //get variable name
 681     char* var = NULL;
 682     int varname = getDataSetIdFromName(dataset, "__varname__");
 683     readStringMatrix(varname, &var);
 684     wchar_t* wvar = to_wide_string(var);
 685     std::wstring wvarname(wvar);
 686     FREE(wvar);
 687     freeStringMatrix(varname, &var);
 688
 689     types::Polynom* p = new types::Polynom(wvarname, static_cast<int>(pdims.size()), pdims.data());
 690     types::SinglePoly** pss = p->get();
 691
 692     //open __refs__ node
 693     int refs = getDataSetIdFromName(dataset, "__refs__");
 694     size = p->getSize();
 695
 696     //loop on children
 697     for (int i = 0; i < size; ++i)
 698     {
 699         //forge name
 700         std::string polyname(std::to_string(i));
 701         int poly = getDataSetIdFromName(refs, polyname.data());
 702
 703         //get dims
 704         complex = 0;
 705         int dims = 0;
 706         int ret = getDatasetInfo(poly, &complex, &dims, NULL);
 707         if (ret < 0)
 708         {
 709             return nullptr;
 710         }
 711
 712         std::vector<int> d(dims);
 713         int datasize = getDatasetInfo(poly, &complex, &dims, d.data());
 714
 715         types::SinglePoly* ss = NULL;
 716
 717         //get coef
 718         if (dims == 0 || datasize == 0)
 719         {
 720             ss = new types::SinglePoly();
 721         }
 722         else if (complex)
 723         {
 724             double* real = NULL;
 725             double* img = NULL;
 726             //create singlepoly
 727             ss = new types::SinglePoly(&real, &img, datasize - 1);
 728             readDoubleComplexMatrix(poly, real, img);
 729         }
 730         else
 731         {
 732             double* real = NULL;
 733             ss = new types::SinglePoly(&real, datasize - 1);
 734             readDoubleMatrix(poly, real);
 735         }
 736
 737         pss[i] = ss;
 738     }
 739
 740     closeList6(refs);
 741     closeList6(dataset);
 742     return p;
 743 }
 744
 745 static types::InternalType* import_sparse(int dataset)
 746 {
 747     types::Sparse* sp = nullptr;
 748     //get sparse dimensions
 749     int complex = 0;
 750     std::vector<int> pdims;
 751     int size = getDimsNode(dataset, &complex, pdims);
 752
 753     //get non zeros count
 754     int nnz = 0;
 755     int datannz = getDataSetIdFromName(dataset, "__nnz__");
 756     readInteger32Matrix(datannz, &nnz);
 757
 758     if (nnz == 0)
 759     {
 760         closeList6(dataset);
 761         return new types::Sparse(pdims[0], pdims[1]);
 762     }
 763
 764     //get inner vector
 765     int datain = getDataSetIdFromName(dataset, "__inner__");
 766     int dimin = 0;
 767     int sizein = getDatasetInfo(datain, &complex, &dimin, NULL);
 768     std::vector<int> dimsin(dimin);
 769     sizein = getDatasetInfo(datain, &complex, &dimin, dimsin.data());
 770
 771     std::vector<int> in(sizein);
 772     int ret = readInteger32Matrix(datain, in.data());
 773     if (ret < 0)
 774     {
 775         closeList6(dataset);
 776         return nullptr;
 777     }
 778
 779     //get outer vector
 780     int dataout = getDataSetIdFromName(dataset, "__outer__");
 781     int dimout = 0;
 782     int sizeout = getDatasetInfo(dataout, &complex, &dimout, NULL);
 783     std::vector<int> dimsout(dimout);
 784     sizeout = getDatasetInfo(dataout, &complex, &dimout, dimsout.data());
 785
 786     std::vector<int> out(sizeout);
 787     ret = readInteger32Matrix(dataout, out.data());
 788     if (ret < 0)
 789     {
 790         closeList6(dataset);
 791         return nullptr;
 792     }
 793
 794     //get data
 795     int ddata = getDataSetIdFromName(dataset, "__data__");
 796     int dimdata = 0;
 797     int sizedata = getDatasetInfo(ddata, &complex, &dimdata, NULL);
 798     std::vector<int> dimsdata(dimdata);
 799     sizedata = getDatasetInfo(ddata, &complex, &dimdata, dimsdata.data());
 800
 801     std::vector<double> real(sizedata);
 802
 803     if (complex)
 804     {
 805         std::vector<double> img(sizedata);
 806         ret = readDoubleComplexMatrix(ddata, real.data(), img.data());
 807         if (ret < 0)
 808         {
 809             closeList6(dataset);
 810             return nullptr;
 811         }
 812
 813         sp = new types::Sparse(pdims[0], pdims[1], nnz, in.data(), out.data(), real.data(), img.data());
 814     }
 815     else
 816     {
 817         ret = readDoubleMatrix(ddata, real.data());
 818         if (ret < 0)
 819         {
 820             closeList6(dataset);
 821             return nullptr;
 822         }
 823
 824         sp = new types::Sparse(pdims[0], pdims[1], nnz, in.data(), out.data(), real.data(), nullptr);
 825     }
 826
 827     closeList6(dataset);
 828     return sp;
 829 }
 830
 831 static types::InternalType* import_boolean_sparse(int dataset)
 832 {
 833     //get sparse dimensions
 834     int complex = 0;
 835     std::vector<int> pdims;
 836     int size = getDimsNode(dataset, &complex, pdims);
 837
 838     //get non zeros count
 839     int nnz = 0;
 840     int datannz = getDataSetIdFromName(dataset, "__nnz__");
 841     readInteger32Matrix(datannz, &nnz);
 842
 843     if (nnz == 0)
 844     {
 845         closeList6(dataset);
 846         return new types::SparseBool(pdims[0], pdims[1]);
 847     }
 848
 849     //get inner vector
 850     int datain = getDataSetIdFromName(dataset, "__inner__");
 851     int dimin = 0;
 852     int sizein = getDatasetInfo(datain, &complex, &dimin, NULL);
 853     std::vector<int> dimsin(dimin);
 854     sizein = getDatasetInfo(datain, &complex, &dimin, dimsin.data());
 855
 856     std::vector<int> in(sizein);
 857     int ret = readInteger32Matrix(datain, in.data());
 858     if (ret < 0)
 859     {
 860         closeList6(dataset);
 861         return nullptr;
 862     }
 863
 864     //get outer vector
 865     int dataout = getDataSetIdFromName(dataset, "__outer__");
 866     int dimout = 0;
 867     int sizeout = getDatasetInfo(dataout, &complex, &dimout, NULL);
 868     std::vector<int> dimsout(dimout);
 869     sizeout = getDatasetInfo(dataout, &complex, &dimout, dimsout.data());
 870
 871     std::vector<int> out(sizeout);
 872     ret = readInteger32Matrix(dataout, out.data());
 873     if (ret < 0)
 874     {
 875         closeList6(dataset);
 876         return nullptr;
 877     }
 878
 879     closeList6(dataset);
 880
 881     return new types::SparseBool(pdims[0], pdims[1], nnz, in.data(), out.data());
 882 }
 883
 884 static types::InternalType* import_cell(int dataset)
 885 {
 886     //get sparse dimensions
 887     int complex = 0;
 888     std::vector<int> pdims;
 889     int size = getDimsNode(dataset, &complex, pdims);
 890
 891     if (size == 0)
 892     {
 893         closeList6(dataset);
 894         return new types::Cell();
 895     }
 896
 897     //open __refs__ node
 898     int refs = getDataSetIdFromName(dataset, "__refs__");
 899     std::vector<types::InternalType*> data(size);
 900     for (int i = 0; i < size; ++i)
 901     {
 902         int ref = getDataSetIdFromName(refs, std::to_string(i).data());
 903         types::InternalType* val = import_data(ref);
 904         if (val == nullptr)
 905         {
 906             return nullptr;
 907         }
 908
 909         data[i] = val;
 910     }
 911
 912     types::Cell* cell = new types::Cell(static_cast<int>(pdims.size()), pdims.data(), data.data());
 913
 914     closeList6(refs);
 915     closeList6(dataset);
 916     return cell;
 917 }
 918
 919 static types::InternalType* import_handles(int dataset)
 920 {
 921     //get sparse dimensions
 922     int complex = 0;
 923     std::vector<int> pdims;
 924     int size = getDimsNode(dataset, &complex, pdims);
 925
 926     if (size == 0)
 927     {
 928         closeList6(dataset);
 929         return nullptr;
 930     }
 931
 932     //open __refs__ node
 933     int refs = getDataSetIdFromName(dataset, "__refs__");
 934     types::GraphicHandle* handles = new types::GraphicHandle(static_cast<int>(pdims.size()), pdims.data());
 935     long long* h = handles->get();
 936
 937     if (size == 1)
 938     {
 939         //%h_copy
 940         int ref = getDataSetIdFromName(refs, std::to_string(0).data());
 941         int val = add_current_entity(ref);
 942         if (val < 0)
 943         {
 944             return nullptr;
 945         }
 946
 947         h[0] = getHandle(val);
 948     }
 949     else
 950     {
 951         for (int i = 0; i < size; ++i)
 952         {
 953             int ref = getDataSetIdFromName(refs, std::to_string(i).data());
 954             int val = import_handle(ref, -1);
 955             if (val < 0)
 956             {
 957                 return nullptr;
 958             }
 959
 960             h[i] = getHandle(val);
 961         }
 962     }
 963     closeList6(refs);
 964     closeList6(dataset);
 965
 966
 967     //update links property of legend handle
 968     if (Links::count())
 969     {
 970         std::list<int> legends = Links::legends();
 971         for (auto & i : legends)
 972         {
 973             Links::PathList paths = Links::get(i);
 974             update_link_path(i, paths);
 975         }
 976     }
 977
 978     return handles;
 979 }
 980
 981 static types::InternalType* import_macro(int dataset)
 982 {
 983     int complex = 0;
 984     int dims = 0;
 985     int size = 0;
 986     std::vector<int> d(2);
 987
 988     std::list<symbol::Variable*>* inputList = new std::list<symbol::Variable*>();
 989     std::list<symbol::Variable*>* outputList = new std::list<symbol::Variable*>();
 990     ast::Exp* body = nullptr;
 991
 992     symbol::Context* ctx = symbol::Context::getInstance();
 993
 994     //inputs
 995     int inputNode = getDataSetIdFromName(dataset, "inputs");
 996     size = getDatasetInfo(inputNode, &complex, &dims, d.data());
 997     std::vector<char*> inputNames(size);
 998
 999     if (size != 0)
1000     {
1001         readStringMatrix(inputNode, inputNames.data());
1002
1003         for (auto & input : inputNames)
1004         {
1005             wchar_t* winput = to_wide_string(input);
1006             symbol::Variable* var = ctx->getOrCreate(symbol::Symbol(winput));
1007             FREE(winput);
1008             inputList->push_back(var);
1009         }
1010
1011         freeStringMatrix(inputNode, inputNames.data());
1012     }
1013     else
1014     {
1015         closeDataSet(inputNode);
1016     }
1017
1018     //outputs
1019     int outputNode = getDataSetIdFromName(dataset, "outputs");
1020     size = getDatasetInfo(outputNode, &complex, &dims, d.data());
1021     std::vector<char*> outputNames(size);
1022
1023     if (size != 0)
1024     {
1025         readStringMatrix(outputNode, outputNames.data());
1026
1027         for (auto & output : outputNames)
1028         {
1029             wchar_t* woutput = to_wide_string(output);
1030             symbol::Variable* var = ctx->getOrCreate(symbol::Symbol(woutput));
1031             FREE(woutput);
1032             outputList->push_back(var);
1033         }
1034
1035         freeStringMatrix(outputNode, outputNames.data());
1036     }
1037     else
1038     {
1039         closeDataSet(outputNode);
1040     }
1041
1042     //body
1043     int bodyNode = getDataSetIdFromName(dataset, "body");
1044     size = getDatasetInfo(bodyNode, &complex, &dims, d.data());
1045     std::vector<unsigned char> bodybin(size);
1046     readUnsignedInteger8Matrix(bodyNode, bodybin.data());
1047
1048     ast::DeserializeVisitor ds(bodybin.data());
1049     body = ds.deserialize();
1050
1051     //wname+1 is to remove "/" at the start of the var name from HDF5
1052     types::Macro* macro = new types::Macro(L"", *inputList, *outputList, *body->getAs<ast::SeqExp>(), L"script");
1053     delete body;
1054     closeList6(dataset);
1055     return macro;
1056 }
1057
1058 static types::InternalType* import_usertype(int dataset)
1059 {
1060     types::InternalType* it = import_struct(dataset);
1061     if (it == nullptr || it->isStruct() == false)
1062     {
1063         delete it;
1064         return nullptr;
1065     }
1066
1067
1068     types::Struct* str = it->getAs<types::Struct>();
1069
1070     if (str->isScalar() == false)
1071     {
1072         delete it;
1073         return nullptr;
1074     }
1075
1076     types::SingleStruct* ss = str->get()[0];
1077
1078     //extract type from struct
1079     types::InternalType* itType  = ss->get(L"type");
1080     if (itType == nullptr || itType->getId() != types::InternalType::IdScalarString)
1081     {
1082         delete it;
1083         return nullptr;
1084     }
1085
1086     types::String* s = it->getAs<types::String>();
1087     wchar_t* type = s->get()[0];
1088
1089     types::InternalType* data = ss->get(L"data");
1090     if (data == nullptr)
1091     {
1092         delete it;
1093         return nullptr;
1094     }
1095
1096     //call %yourtype_load overload
1097     types::typed_list in;
1098     in.push_back(data);
1099
1100     types::typed_list out;
1101     //overload
1102     // rational case
1103     std::wstring wstFuncName = L"%" + data->getShortTypeStr() + L"_load";
1104     types::Callable::ReturnValue ret = Overload::call(wstFuncName, in, 1, out);
1105
1106     //clean temporary variables
1107     delete it; //included type and data
1108
1109     if (ret != types::Callable::OK)
1110     {
1111         return nullptr;
1112     }
1113
1114     if (out.size() != 1)
1115     {
1116         for (auto & i : out)
1117         {
1118             i->killMe();
1119         }
1120
1121         return nullptr;
1122     }
1123
1124     return out[0];
1125 }