static types::InternalType* import_cell(int dataset)
{
//get sparse dimensions
int complex = 0;
std::vector<int> pdims;
int size = getDimsNode(dataset, &complex, pdims);
if (size == 0)
{
closeList6(dataset);
return new types::Cell();
}
//open __refs__ node
int refs = getDataSetIdFromName(dataset, "__refs__");
std::vector<types::InternalType*> data(size);
for (int i = 0; i < size; ++i)
{
int ref = getDataSetIdFromName(refs, std::to_string(i).data());
types::InternalType* val = import_data(ref);
if (val == nullptr)
{
return nullptr;
}
data[i] = val;
}
types::Cell* cell = new types::Cell(static_cast<int>(pdims.size()), pdims.data(), data.data());
closeList6(refs);
closeList6(dataset);
return cell;
}
static bool import_variable(int file, std::string& name)
{
int dataset = getDataSetIdFromName(file, name.data());
if (dataset <= 0)
{
return false;
}
types::InternalType* data = import_data(dataset);
if (data != nullptr)
{
wchar_t* var = to_wide_string(name.data());
//update macro name
if (data->isMacro())
{
types::Macro* macro = data->getAs<types::Macro>();
macro->setName(var);
symbol::Context::getInstance()->addMacro(macro);
}
else
{
//add to context
symbol::Context::getInstance()->put(symbol::Symbol(var), data);
}
FREE(var);
return true;
}
return false;
}
static bool import_variable(int* pvCtx, int _iFile, char* _pstVarName)
{
int iDataSetId = getDataSetIdFromName(_iFile, _pstVarName);
if (iDataSetId <= 0)
{
return false;
}
return import_data(pvCtx, iDataSetId, 0, NULL, _pstVarName);
}
int main(int argc, char ** argv)
{
if(argc < 3) {
cerr << "Usage: " << argv[0] << " sample_data.csv kdtree.log"<< endl;
exit(-1);
}
vector<Point> sample_points;
import_data(argv[1], sample_points);
KDTree kd_tree(sample_points);
kd_tree.save(argv[2]);
return 0;
}
static types::InternalType* import_list(int dataset, types::List* lst)
{
int count = 0;
int ret = getListDims6(dataset, &count);
if (ret)
{
closeList6(dataset);
delete lst;
return nullptr;
}
if (count == 0)
{
closeList6(dataset);
return lst;
}
//get children
for (int i = 0; i < count; ++i)
{
int data = getDataSetIdFromName(dataset, std::to_string(i).data());
if (data <= 0)
{
closeList6(dataset);
delete lst;
return nullptr;
}
types::InternalType* child = import_data(data);
if (child == nullptr)
{
closeList6(dataset);
delete lst;
return nullptr;
}
lst->append(child);
if (child->isList())
{
child->killMe();
}
}
closeList6(dataset);
return lst;
}
void test_contig_alicont2()
{
contig<Alphabet, RegionProp> my_contig("CONTIG-TEST", Alphabet::getAlphabet());
//import_data("../data/germline/human/VH.fasta", my_contig);
import_data("../data/other/VH_corrected.fasta", my_contig);
std::string query = "CAGGTTCAGCTGGTGCAGTCTGGGGCTGAGGTGAAGAAGCCTGGGGCCTCAGTGAAGGTTTCCTGCAAGGCTTCTGGATACACCTTCACTAGCTATGCTATGCATTGGGTGCGCCAGGCCCCCGGACAAAGGCTTGAGTGGATGGGATGGAGCAACGCTGGCAATGGTAACACAAAATATTCACAGGAGTTCCAGGGCAGAGTCACCATTACCAGGGACACATCCGCGAGCACAGCCTACATGGAGCTGAGCAGCCTGAGATCTGAGGACATGGCTGTGTATTACTGTGCGAGAGA";
score_matrix m("../data/NUC4.4.txt");
time_t t = clock();
auto r = my_contig.align_sc(query.begin(), query.end(), -5, m, 0.8);
std::cout << "Alignment time: " << (double)(clock() - t) / CLOCKS_PER_SEC << std::endl;
for (auto i : r)
{
std::cout << i.score << " (" << i.target_id << ")" << std::endl
<< i.first << std::endl
<< i.second << std::endl << std::endl;
}
std::cout << std::endl;
}
void test_fasta()
{
time_t c = clock();
std::pair<Read, size_t> p;
size_t real_length = 0;
igc::contig<Alphabet, RegionProp> my_contig("CONTIG-TEST", Alphabet::getAlphabet());
p = import_data("../../../../data/germline/human/VH.fasta", my_contig);
real_length += p.second;
// p = import_data("/home/mactep/Data/NGS-llama/out2/VL/VL.fasta", my_contig);
// real_length += p.second;
// p = import_data("/home/mactep/Data/NGS-llama/out2/VK/VK.fasta", my_contig);
// real_length += p.second;
std::cout << "FOUND: "
<< my_contig.find(p.first.seq.begin() + 12,
p.first.seq.begin() + 22).size()
<< std::endl;
c = clock() - c;
std::cout << "Compression: " << (double)my_contig.size() / real_length << std::endl;
std::cout << "Real time: " << (double)c / CLOCKS_PER_SEC << std::endl;
}
static bool import_cell(int* pvCtx, int _iDatasetId, int _iVarType, int _iItemPos, int *_piAddress, char *_pstVarname)
{
int iRet = 0;
int iComplex = 0;
int iDims = 0;
int iItems = 0;
hobj_ref_t *piItemRef = NULL;
// an hypermatrix is stored in an mlist
if (_iVarType != sci_mlist)
{
return false;
}
iRet = getListDims(_iDatasetId, &iItems);
if (iRet)
{
return false;
}
if (iItems != 3)
{
// cell have 3 elements
return false;
}
iRet = getListItemReferences(_iDatasetId, &piItemRef);
if (iRet)
{
deleteListItemReferences(_iDatasetId, piItemRef);
return false;
}
// get first item
int iItemDataset = 0;
iRet = getListItemDataset(_iDatasetId, piItemRef, 0, &iItemDataset);
if (iRet || iItemDataset == 0)
{
deleteListItemReferences(_iDatasetId, piItemRef);
return false;
}
// get first item type
int iItemType = getScilabTypeFromDataSet(iItemDataset);
if (iItemType != sci_strings)
{
deleteListItemReferences(_iDatasetId, piItemRef);
return false;
}
// get size of first item
iRet = getDatasetInfo(iItemDataset, &iComplex, &iDims, NULL);
if (iRet < 0 || iDims != 2)
{
deleteListItemReferences(_iDatasetId, piItemRef);
return false;
}
int* piDims = new int[2];
int iSize = getDatasetInfo(iItemDataset, &iComplex, &iDims, piDims);
if (iSize != 3)
{
deleteListItemReferences(_iDatasetId, piItemRef);
delete[] piDims;
return false;
}
delete[] piDims;
piDims = NULL;
// get data of first item for check the type of mlist
char** pstData = new char*[iSize];
iRet = readStringMatrix(iItemDataset, pstData);
if (iRet || strcmp(pstData[0], "ce") != 0)
{
// if not the good type, do not h5close (deleteListItemReferences)
FREE(piItemRef);
freeStringMatrix(iItemDataset, pstData);
delete[] pstData;
return false;
}
freeStringMatrix(iItemDataset, pstData);
delete[] pstData;
pstData = NULL;
// get second item, the Size of cell
iRet = getListItemDataset(_iDatasetId, piItemRef, 1, &iItemDataset);
if (iRet)
{
deleteListItemReferences(_iDatasetId, piItemRef);
return false;
}
iRet = getDatasetInfo(iItemDataset, &iComplex, &iDims, NULL);
if (iRet < 0 || iDims != 2)
{
deleteListItemReferences(_iDatasetId, piItemRef);
return false;
}
piDims = new int[2];
iSize = getDatasetInfo(iItemDataset, &iComplex, &iDims, piDims);
if (piDims[0] != 1)
{
deleteListItemReferences(_iDatasetId, piItemRef);
delete[] piDims;
return false;
}
int* piDimsArray = new int[piDims[1]];
iRet = readInteger32Matrix(iItemDataset, piDimsArray);
if (iRet)
{
deleteListItemReferences(_iDatasetId, piItemRef);
delete[] piDims;
delete[] piDimsArray;
return false;
}
types::Cell* pCell = new types::Cell(piDims[1], piDimsArray);
types::List* pList = new types::List();
pList->set(0, types::Double::Empty());
iRet = getListItemDataset(_iDatasetId, piItemRef, 2, &iItemDataset);
if (iRet || iItemDataset == 0)
{
deleteListItemReferences(_iDatasetId, piItemRef);
delete pList;
delete pCell;
return false;
}
bool bRet = import_data(pvCtx, iItemDataset, 1, (int*)pList, NULL);
if (bRet == false)
{
deleteListItemReferences(_iDatasetId, piItemRef);
delete pList;
delete pCell;
return false;
}
types::List* pListData = pList->get(0)->getAs<types::List>();
for (int iWriteData = 0; iWriteData < pCell->getSize(); ++iWriteData)
{
pCell->set(iWriteData, pListData->get(iWriteData));
}
delete pList;
if (_piAddress == NULL)
{
wchar_t* pwstName = to_wide_string(_pstVarname);
symbol::Context::getInstance()->put(symbol::Symbol(pwstName), pCell);
FREE(pwstName);
}
else
{
types::List* pParentList = (types::List*)_piAddress;
pParentList->set(_iItemPos - 1, pCell);
}
iRet = deleteListItemReferences(_iDatasetId, piItemRef);
if (iRet)
{
return false;
}
return true;
}
static bool import_struct(int* pvCtx, int _iDatasetId, int _iVarType, int _iItemPos, int *_piAddress, char *_pstVarname)
{
int iRet = 0;
int iComplex = 0;
int iDims = 0;
int iItems = 0;
hobj_ref_t *piItemRef = NULL;
// an struct is stored in an mlist
if (_iVarType != sci_mlist)
{
return false;
}
iRet = getListDims(_iDatasetId, &iItems);
if (iRet)
{
return false;
}
if (iItems < 2)
{
// struct have 2 elements minimal
return false;
}
iRet = getListItemReferences(_iDatasetId, &piItemRef);
if (iRet)
{
deleteListItemReferences(_iDatasetId, piItemRef);
return false;
}
// get first item
int iItemDataset = 0;
iRet = getListItemDataset(_iDatasetId, piItemRef, 0, &iItemDataset);
if (iRet || iItemDataset == 0)
{
deleteListItemReferences(_iDatasetId, piItemRef);
return false;
}
// get first item type
int iItemType = getScilabTypeFromDataSet(iItemDataset);
if (iItemType != sci_strings)
{
deleteListItemReferences(_iDatasetId, piItemRef);
return false;
}
// get size of first item
iRet = getDatasetInfo(iItemDataset, &iComplex, &iDims, NULL);
if (iRet < 0 || iDims != 2)
{
deleteListItemReferences(_iDatasetId, piItemRef);
return false;
}
int* piDims = new int[2];
int iSize = getDatasetInfo(iItemDataset, &iComplex, &iDims, piDims);
if (iSize != iItems)
{
deleteListItemReferences(_iDatasetId, piItemRef);
delete[] piDims;
return false;
}
delete[] piDims;
piDims = NULL;
// get data of first item for check the type of mlist
char** pstData = new char*[iSize];
char** pstDataSave = new char*[iSize - 2];
iRet = readStringMatrix(iItemDataset, pstData);
if (iRet || strcmp(pstData[0], "st") != 0)
{
// if not the good type, do not h5close (deleteListItemReferences)
FREE(piItemRef);
freeStringMatrix(iItemDataset, pstData);
delete[] pstData;
delete[] pstDataSave;
return false;
}
for (int i = 2; i < iSize; ++i)
{
pstDataSave[-2 + i] = new char[strlen(pstData[i]) + 1];
strcpy(pstDataSave[-2 + i], pstData[i]);
}
freeStringMatrix(iItemDataset, pstData);
delete[] pstData;
pstData = NULL;
// get second item, the Size of struct
iRet = getListItemDataset(_iDatasetId, piItemRef, 1, &iItemDataset);
if (iRet)
{
deleteListItemReferences(_iDatasetId, piItemRef);
for (int i = 0; i < (-2 + iItems); ++i)
{
delete pstDataSave[i];
}
delete[] pstDataSave;
pstDataSave = NULL;
return false;
}
iRet = getDatasetInfo(iItemDataset, &iComplex, &iDims, NULL);
if (iRet < 0 || iDims != 2)
{
deleteListItemReferences(_iDatasetId, piItemRef);
for (int i = 0; i < (-2 + iItems); ++i)
{
delete pstDataSave[i];
}
delete[] pstDataSave;
pstDataSave = NULL;
return false;
}
piDims = new int[2];
iSize = getDatasetInfo(iItemDataset, &iComplex, &iDims, piDims);
if (piDims[0] != 1)
{
deleteListItemReferences(_iDatasetId, piItemRef);
for (int i = 0; i < (-2 + iItems); ++i)
{
delete pstDataSave[i];
}
delete[] pstDataSave;
pstDataSave = NULL;
delete[] piDims;
return false;
}
int* piDimsArray = new int[piDims[1]];
iRet = readInteger32Matrix(iItemDataset, piDimsArray);
if (iRet)
{
deleteListItemReferences(_iDatasetId, piItemRef);
for (int i = 0; i < (-2 + iItems); ++i)
{
delete pstDataSave[i];
}
delete[] pstDataSave;
pstDataSave = NULL;
delete[] piDims;
delete[] piDimsArray;
return false;
}
types::Struct* pStruct = new types::Struct(piDims[1], piDimsArray);
wchar_t* pwstName = NULL;
for (int i = 0; i < (-2 + iItems); ++i)
{
pwstName = to_wide_string(pstDataSave[i]);
pStruct->addField(pwstName);
delete pstDataSave[i];
FREE(pwstName);
}
delete[] pstDataSave;
pstDataSave = NULL;
types::SingleStruct** ppSStruct = pStruct->get();
types::String* pStr = pStruct->getFieldNames();
types::List* pList = new types::List();
// fill the list to avoid api_scilab error about the list size.
pList->set(0, types::Double::Empty());
if (pStruct->getSize() == 1)
{
types::InternalType* pIT = NULL;
for (int i = 0; i < pStr->getSize(); ++i)
{
int iItemDataset = 0;
iRet = getListItemDataset(_iDatasetId, piItemRef, i + 2, &iItemDataset);
if (iRet || iItemDataset == 0)
{
deleteListItemReferences(_iDatasetId, piItemRef);
delete pList;
delete pStruct;
return false;
}
wchar_t* pwcsName = pStr->get(i);
char* pcName = wide_string_to_UTF8(pwcsName);
bool bRet = import_data(pvCtx, iItemDataset, 1, (int*)pList, pcName);
if (bRet == false)
{
deleteListItemReferences(_iDatasetId, piItemRef);
delete pList;
delete pStruct;
return false;
}
pIT = pList->get(0);
ppSStruct[0]->set(pwcsName, pIT);
FREE(pcName);
}
}
else if (pStruct->getSize() > 1)
{
for (int i = 0; i < pStr->getSize(); ++i)
{
int iItemDataset = 0;
iRet = getListItemDataset(_iDatasetId, piItemRef, i + 2, &iItemDataset);
if (iRet || iItemDataset == 0)
{
deleteListItemReferences(_iDatasetId, piItemRef);
delete pList;
delete pStruct;
return false;
}
wchar_t* pwcsName = pStr->get(i);
char* pcName = wide_string_to_UTF8(pwcsName);
bool bRet = import_data(pvCtx, iItemDataset, 1, (int*)pList, pcName);
if (bRet == false)
{
deleteListItemReferences(_iDatasetId, piItemRef);
delete pList;
delete pStruct;
return false;
}
types::List* pListData = pList->get(0)->getAs<types::List>();
for (int iWriteData = 0; iWriteData < pStruct->getSize(); ++iWriteData)
{
ppSStruct[iWriteData]->set(pwcsName, pListData->get(iWriteData));
}
FREE(pcName);
}
}
delete pList;
if (_piAddress == NULL)
{
pwstName = to_wide_string(_pstVarname);
symbol::Context::getInstance()->put(symbol::Symbol(pwstName), pStruct);
FREE(pwstName);
}
else
{
types::List* pParentList = (types::List*)_piAddress;
pParentList->set(_iItemPos - 1, pStruct);
}
iRet = deleteListItemReferences(_iDatasetId, piItemRef);
if (iRet)
{
return false;
}
return true;
}
static bool import_hypermat(int* pvCtx, int _iDatasetId, int _iVarType, int _iItemPos, int *_piAddress, char *_pstVarname)
{
int iRet = 0;
int iComplex = 0;
int iDims = 0;
int iItems = 0;
hobj_ref_t *piItemRef = NULL;
// an hypermatrix is stored in an mlist
if (_iVarType != sci_mlist)
{
return false;
}
iRet = getListDims(_iDatasetId, &iItems);
if (iRet)
{
return false;
}
if (iItems != 3)
{
// hypermatrix have 3 elements
return false;
}
iRet = getListItemReferences(_iDatasetId, &piItemRef);
if (iRet)
{
deleteListItemReferences(_iDatasetId, piItemRef);
return false;
}
// get first item
int iItemDataset = 0;
iRet = getListItemDataset(_iDatasetId, piItemRef, 0, &iItemDataset);
if (iRet || iItemDataset == 0)
{
deleteListItemReferences(_iDatasetId, piItemRef);
return false;
}
// get first item type
int iItemType = getScilabTypeFromDataSet(iItemDataset);
if (iItemType != sci_strings)
{
deleteListItemReferences(_iDatasetId, piItemRef);
return false;
}
// get size of first item
iRet = getDatasetInfo(iItemDataset, &iComplex, &iDims, NULL);
if (iRet < 0 || iDims != 2)
{
deleteListItemReferences(_iDatasetId, piItemRef);
return false;
}
int* piDims = new int[2];
int iSize = getDatasetInfo(iItemDataset, &iComplex, &iDims, piDims);
if (iSize != 3)
{
deleteListItemReferences(_iDatasetId, piItemRef);
delete[] piDims;
return false;
}
delete[] piDims;
piDims = NULL;
// get data of first item for check the type of mlist
char** pstData = new char*[iSize];
iRet = readStringMatrix(iItemDataset, pstData);
if (iRet || strcmp(pstData[0], "hm") != 0)
{
// if not the good type, do not h5close (deleteListItemReferences)
FREE(piItemRef);
freeStringMatrix(iItemDataset, pstData);
delete[] pstData;
return false;
}
freeStringMatrix(iItemDataset, pstData);
delete[] pstData;
pstData = NULL;
// get second item, the Size of hypermatrix
iRet = getListItemDataset(_iDatasetId, piItemRef, 1, &iItemDataset);
if (iRet)
{
deleteListItemReferences(_iDatasetId, piItemRef);
return false;
}
iRet = getDatasetInfo(iItemDataset, &iComplex, &iDims, NULL);
if (iRet < 0 || iDims != 2)
{
deleteListItemReferences(_iDatasetId, piItemRef);
return false;
}
piDims = new int[2];
iSize = getDatasetInfo(iItemDataset, &iComplex, &iDims, piDims);
if (piDims[0] != 1)
{
deleteListItemReferences(_iDatasetId, piItemRef);
delete[] piDims;
return false;
}
int* piDimsArray = new int[piDims[1]];
iRet = readInteger32Matrix(iItemDataset, piDimsArray);
if (iRet)
{
deleteListItemReferences(_iDatasetId, piItemRef);
delete[] piDims;
delete[] piDimsArray;
return false;
}
// get third item, the Data of hypermatrix
// import data like a "type" (Double, Int, ...) instead of mlist
iRet = getListItemDataset(_iDatasetId, piItemRef, 2, &iItemDataset);
bool bRet = import_data(pvCtx, iItemDataset, _iItemPos, _piAddress, _pstVarname);
if (bRet == false)
{
deleteListItemReferences(_iDatasetId, piItemRef);
delete[] piDims;
delete[] piDimsArray;
return false;
}
// get imported hypermatrix from List or Context
types::GenericType* pGT = NULL;
types::InternalType* pIT = NULL;
if (_piAddress)
{
types::List* pL = (types::List*)_piAddress;
pIT = pL->get(_iItemPos - 1);
}
else
{
wchar_t* pwcsName = to_wide_string(_pstVarname);
pIT = symbol::Context::getInstance()->getCurrentLevel(symbol::Symbol(pwcsName));
FREE(pwcsName);
}
// reshape data with size of hypermatrix
pGT = pIT->getAs<types::GenericType>();
pGT->reshape(piDimsArray, piDims[1]);
delete[] piDims;
delete[] piDimsArray;
iRet = deleteListItemReferences(_iDatasetId, piItemRef);
if (iRet)
{
return false;
}
return true;
}
static bool import_list(int* pvCtx, int _iDatasetId, int _iVarType, int _iItemPos, int *_piAddress, char *_pstVarname)
{
int iRet = 0;
int i = 0;
int iItems = 0;
int *piListAddr = NULL;
hobj_ref_t *piItemRef = NULL;
SciErr sciErr;
iRet = getListDims(_iDatasetId, &iItems);
if (iRet)
{
return false;
}
if (iItems == 0)
{
//special case for empty list
}
else
{
iRet = getListItemReferences(_iDatasetId, &piItemRef);
if (iRet)
{
return false;
}
}
if (_piAddress == 0)
{
switch (_iVarType)
{
case sci_list:
sciErr = createNamedList(pvCtx, _pstVarname, iItems, &piListAddr);
break;
case sci_tlist:
sciErr = createNamedTList(pvCtx, _pstVarname, iItems, &piListAddr);
break;
case sci_mlist:
sciErr = createNamedMList(pvCtx, _pstVarname, iItems, &piListAddr);
break;
default:
return false;
}
}
else //if not null this variable is in a list
{
switch (_iVarType)
{
case sci_list:
sciErr = createListInNamedList(pvCtx, _pstVarname, _piAddress, _iItemPos, iItems, &piListAddr);
break;
case sci_tlist:
sciErr = createTListInNamedList(pvCtx, _pstVarname, _piAddress, _iItemPos, iItems, &piListAddr);
break;
case sci_mlist:
sciErr = createMListInNamedList(pvCtx, _pstVarname, _piAddress, _iItemPos, iItems, &piListAddr);
break;
default:
return false;
}
}
if (sciErr.iErr)
{
printError(&sciErr, 0);
return false;
}
for (i = 0; i < iItems; i++)
{
int iItemDataset = 0;
iRet = getListItemDataset(_iDatasetId, piItemRef, i, &iItemDataset);
if (iRet || iItemDataset == 0)
{
return false;
}
bool bRet = import_data(pvCtx, iItemDataset, i + 1, piListAddr, _pstVarname);
if (bRet == false)
{
return false;
}
}
iRet = deleteListItemReferences(_iDatasetId, piItemRef);
if (iRet)
{
return false;
}
return true;
}
static types::InternalType* import_struct(int dataset)
{
//get struct dims node
int complex = 0;
std::vector<int> pdims;
int size = getDimsNode(dataset, &complex, pdims);
types::Struct* str = new types::Struct(static_cast<int>(pdims.size()), pdims.data());
size = str->getSize();
if (size == 0)
{
//empty struct
closeList6(dataset);
delete str;
return new types::Struct();
}
types::SingleStruct** sstr = str->get();
int fieldCount = 0;
int ret = getListDims6(dataset, &fieldCount);
if (ret < 0)
{
closeList6(dataset);
return str;
}
//get fields name
int dfield = getDataSetIdFromName(dataset, "__fields__");
int dim = 0;
getDatasetInfo(dfield, &complex, &dim, NULL);
std::vector<int> d(dim);
size = getDatasetInfo(dfield, &complex, &dim, d.data());
if (size < 0)
{
closeList6(dataset);
delete str;
return nullptr;
}
//get dims value
std::vector<char*> fields(size);
readStringMatrix(dfield, fields.data());
//open __refs__ node
int refs = getDataSetIdFromName(dataset, "__refs__");
for (const auto & name : fields)
{
wchar_t* field = to_wide_string(name);
str->addField(field);
int dataref = getDataSetIdFromName(dataset, name);
if (dataref < 0)
{
closeList6(dataset);
freeStringMatrix(dfield, fields.data());
FREE(field);
delete str;
return nullptr;
}
int refdim = 0;
getDatasetInfo(dataref, &complex, &refdim, NULL);
std::vector<int> refdims(refdim);
int refcount = getDatasetInfo(dataref, &complex, &refdim, refdims.data());
std::vector<hobj_ref_t> vrefs(refcount);
ret = H5Dread(dataref, H5T_STD_REF_OBJ, H5S_ALL, H5S_ALL, H5P_DEFAULT, vrefs.data());
if (ret < 0)
{
freeStringMatrix(dfield, fields.data());
FREE(field);
delete str;
return nullptr;
}
//import field
for (int j = 0; j < refcount; ++j)
{
int data = H5Rdereference(refs, H5R_OBJECT, &vrefs[j]);
if (data < 0)
{
freeStringMatrix(dfield, fields.data());
FREE(field);
delete str;
return nullptr;
}
types::InternalType* val = import_data(data);
if (val == nullptr)
{
freeStringMatrix(dfield, fields.data());
FREE(field);
delete str;
return nullptr;
}
sstr[j]->set(field, val);
}
FREE(field);
closeDataSet(dataref);
}
freeStringMatrix(dfield, fields.data());
closeList6(refs);
closeList6(dataset);
return str;
}
int pack_rom(const char *loader_filename, int majver, int minver, int subver, const char *image_filename, const char *outfile)
{
time_t nowtime;
struct tm local_time;
int i;
struct _rkfw_header rom_header = {
.head_code = "RKFW",
.head_len = 0x66,
.loader_offset = 0x66
};
struct update_header rkaf_header;
struct bootloader_header loader_header;
rom_header.chip = chiptype;
rom_header.version = (((majver) << 24) + ((minver) << 16) + (subver));
rom_header.code = 0x01030000;
nowtime = time(NULL);
localtime_r(&nowtime, &local_time);
rom_header.year = local_time.tm_year + 1900;
rom_header.month = local_time.tm_mon + 1;
rom_header.day = local_time.tm_mday;
rom_header.hour = local_time.tm_hour;
rom_header.minute = local_time.tm_min;
rom_header.second = local_time.tm_sec;
FILE *fp = fopen(outfile, "wb+");
if (!fp)
{
fprintf(stderr, "Can't open file %s\n, reason: %s\n", outfile, strerror(errno));
goto pack_fail;
}
unsigned char buffer[0x66];
if (1 != fwrite(buffer, 0x66, 1, fp))
goto pack_fail;
printf("rom version: %x.%x.%x\n",
(rom_header.version >> 24) & 0xFF,
(rom_header.version >> 16) & 0xFF,
(rom_header.version) & 0xFFFF);
printf("build time: %d-%02d-%02d %02d:%02d:%02d\n",
rom_header.year, rom_header.month, rom_header.day,
rom_header.hour, rom_header.minute, rom_header.second);
printf("chip: %x\n", rom_header.chip);
fseek(fp, rom_header.loader_offset, SEEK_SET);
fprintf(stderr, "generate image...\n");
rom_header.loader_length = import_data(loader_filename, &loader_header, sizeof(loader_header), fp);
if (rom_header.loader_length < sizeof(loader_header))
{
fprintf(stderr, "invalid loader :\"\%s\"\n", loader_filename);
goto pack_fail;
}
rom_header.image_offset = rom_header.loader_offset + rom_header.loader_length;
rom_header.image_length = import_data(image_filename, &rkaf_header, sizeof(rkaf_header), fp);
if (rom_header.image_length < sizeof(rkaf_header))
{
fprintf(stderr, "invalid rom :\"\%s\"\n", image_filename);
goto pack_fail;
}
