/*
.protocol {
name 0 : string
tag 1 : integer
request 2 : integer
response 3 : integer
}
*/
static const uint8_t *
import_protocol(struct sproto *s, struct protocol *p, const uint8_t * stream) {
uint32_t sz = todword(stream);
stream += SIZEOF_LENGTH;
const uint8_t * result = stream + sz;
int fn = struct_field(stream, sz);
stream += SIZEOF_HEADER;
p->name = NULL;
p->tag = -1;
p->p[SPROTO_REQUEST] = NULL;
p->p[SPROTO_RESPONSE] = NULL;
int i;
for (i=0;i<fn;i++) {
int value = toword(stream + SIZEOF_FIELD * i);
if (value & 1)
return NULL;
value = value/2 - 1;
switch (i) {
case 0: // name
if (value != -1) {
return NULL;
}
p->name = import_string(s, stream + SIZEOF_FIELD *fn);
break;
case 1: // tag
if (value < 0) {
return NULL;
}
p->tag = value;
break;
case 2: // request
if (value < 0 || value>=s->type_n)
return NULL;
p->p[SPROTO_REQUEST] = &s->type[value];
break;
case 3: // response
if (value < 0 || value>=s->type_n)
return NULL;
p->p[SPROTO_RESPONSE] = &s->type[value];
break;
default:
return NULL;
}
}
if (p->name == NULL || p->tag<0 || p->p[SPROTO_REQUEST] == NULL) {
return NULL;
}
return result;
}
/*
.type {
.field {
name 0 : string
buildin 1 : integer
type 2 : integer
tag 3 : integer
array 4 : boolean
}
name 0 : string
fields 1 : *field
}
*/
static const uint8_t *
import_type(struct sproto *s, struct sproto_type *t, const uint8_t * stream) {
uint32_t sz = todword(stream);
stream += SIZEOF_LENGTH;
const uint8_t * result = stream + sz;
int fn = struct_field(stream, sz);
if (fn <= 0 || fn > 2)
return NULL;
int i;
for (i=0;i<fn*SIZEOF_FIELD;i+=SIZEOF_FIELD) {
// name and fields must encode to 0
int v = toword(stream + SIZEOF_HEADER + i);
if (v != 0)
return NULL;
}
memset(t, 0, sizeof(*t));
stream += SIZEOF_HEADER + fn * SIZEOF_FIELD;
t->name = import_string(s, stream);
if (fn == 1) {
return result;
}
stream += todword(stream)+SIZEOF_LENGTH; // second data
int n = count_array(stream);
if (n<0)
return NULL;
stream += SIZEOF_LENGTH;
int maxn = n;
int last = -1;
t->n = n;
t->f = pool_alloc(&s->memory, sizeof(struct field) * n);
for (i=0;i<n;i++) {
struct field *f = &t->f[i];
stream = import_field(s, f, stream);
if (stream == NULL)
return NULL;
int tag = f->tag;
if (tag < last)
return NULL; // tag must in ascending order
if (tag > last+1) {
++maxn;
}
last = tag;
}
t->maxn = maxn;
t->base = t->f[0].tag;
n = t->f[n-1].tag - t->base + 1;
if (n != t->n) {
t->base = -1;
}
return result;
}
void command_reader::apply_parent(object_type &object, object_type &parent) {
import_string(object.collection_strategy, parent.collection_strategy);
import_string(object.buffer_size, parent.buffer_size);
import_string(object.type, parent.type);
}
static bool import_data(int* pvCtx, int _iDatasetId, int _iItemPos, int *_piAddress, char *_pstVarname)
{
bool bRet = false;
//get var type
int iVarType = getScilabTypeFromDataSet(_iDatasetId);
switch (iVarType)
{
case sci_matrix:
{
bRet = import_double(pvCtx, _iDatasetId, _iItemPos, _piAddress, _pstVarname);
break;
}
case sci_strings:
{
bRet = import_string(pvCtx, _iDatasetId, _iItemPos, _piAddress, _pstVarname);
break;
}
case sci_list:
case sci_tlist:
case sci_mlist:
{
bRet = import_hypermat(pvCtx, _iDatasetId, iVarType, _iItemPos, _piAddress, _pstVarname);
if (bRet == false)
{
bRet = import_struct(pvCtx, _iDatasetId, iVarType, _iItemPos, _piAddress, _pstVarname);
}
if (bRet == false)
{
bRet = import_cell(pvCtx, _iDatasetId, iVarType, _iItemPos, _piAddress, _pstVarname);
}
if (bRet == false)
{
bRet = import_list(pvCtx, _iDatasetId, iVarType, _iItemPos, _piAddress, _pstVarname);
}
break;
}
case sci_boolean:
{
bRet = import_boolean(pvCtx, _iDatasetId, _iItemPos, _piAddress, _pstVarname);
break;
}
case sci_poly:
{
bRet = import_poly(pvCtx, _iDatasetId, _iItemPos, _piAddress, _pstVarname);
break;
}
case sci_ints:
{
bRet = import_integer(pvCtx, _iDatasetId, _iItemPos, _piAddress, _pstVarname);
break;
}
case sci_sparse:
{
bRet = import_sparse(pvCtx, _iDatasetId, _iItemPos, _piAddress, _pstVarname);
break;
}
case sci_boolean_sparse:
{
bRet = import_boolean_sparse(pvCtx, _iDatasetId, _iItemPos, _piAddress, _pstVarname);
break;
}
case sci_void: //void item only on list variable
{
bRet = import_void(pvCtx, _iDatasetId, _iItemPos, _piAddress, _pstVarname);
break;
}
case sci_undefined: //undefined item only on list variable
{
bRet = import_undefined(pvCtx, _iDatasetId, _iItemPos, _piAddress, _pstVarname);
break;
}
default:
{
Scierror(999, _("%s: Invalid HDF5 Scilab format.\n"), fname.data());
}
}
return bRet;
}
types::InternalType* import_data(int dataset)
{
//get var type
char* ctype = getScilabTypeFromDataSet6(dataset);
std::string type(ctype);
FREE(ctype);
if (type == g_SCILAB_CLASS_DOUBLE)
{
return import_double(dataset);
}
if (type == g_SCILAB_CLASS_STRING)
{
return import_string(dataset);
}
if (type == g_SCILAB_CLASS_INT)
{
return import_int(dataset);
}
if (type == g_SCILAB_CLASS_BOOLEAN)
{
return import_boolean(dataset);
}
if (type == g_SCILAB_CLASS_LIST)
{
return import_list(dataset, new types::List());
}
if (type == g_SCILAB_CLASS_TLIST)
{
return import_list(dataset, new types::TList());
}
if (type == g_SCILAB_CLASS_MLIST)
{
return import_list(dataset, new types::MList());
}
if (type == g_SCILAB_CLASS_STRUCT)
{
return import_struct(dataset);
}
if (type == g_SCILAB_CLASS_POLY)
{
return import_poly(dataset);
}
if (type == g_SCILAB_CLASS_SPARSE)
{
return import_sparse(dataset);
}
if (type == g_SCILAB_CLASS_BSPARSE)
{
return import_boolean_sparse(dataset);
}
if (type == g_SCILAB_CLASS_CELL)
{
return import_cell(dataset);
}
if (type == g_SCILAB_CLASS_HANDLE)
{
return import_handles(dataset);
}
if (type == g_SCILAB_CLASS_MACRO)
{
return import_macro(dataset);
}
if (type == g_SCILAB_CLASS_VOID)
{
closeDataSet(dataset);
return new types::Void();
}
if (type == g_SCILAB_CLASS_UNDEFINED)
{
closeDataSet(dataset);
return new types::ListUndefined();
}
if (type == g_SCILAB_CLASS_USERTYPE)
{
return import_usertype(dataset);
}
return nullptr;
}
static const uint8_t *
import_field(struct sproto *s, struct field *f, const uint8_t * stream) {
f->tag = -1;
f->type = -1;
f->name = NULL;
f->st = NULL;
uint32_t sz = todword(stream);
stream += SIZEOF_LENGTH;
const uint8_t * result = stream + sz;
int fn = struct_field(stream, sz);
if (fn < 0)
return NULL;
stream += SIZEOF_HEADER;
int i;
int array = 0;
int tag = -1;
for (i=0;i<fn;i++) {
++tag;
int value = toword(stream + SIZEOF_FIELD * i);
if (value & 1) {
tag+= value/2;
continue;
}
if (tag == 0) { // name
if (value != 0)
return NULL;
f->name = import_string(s, stream + fn * SIZEOF_FIELD);
continue;
}
if (value == 0)
return NULL;
value = value/2 - 1;
switch(tag) {
case 1: // buildin
if (value >= SPROTO_TSTRUCT)
return NULL; // invalid buildin type
f->type = value;
break;
case 2: // type index
if (value >= s->type_n)
return NULL; // invalid type index
if (f->type >= 0)
return NULL;
f->type = SPROTO_TSTRUCT;
f->st = &s->type[value];
break;
case 3: // tag
f->tag = value;
break;
case 4: // array
if (value)
array = SPROTO_TARRAY;
break;
default:
return NULL;
}
}
if (f->tag < 0 || f->type < 0 || f->name == NULL)
return NULL;
f->type |= array;
return result;
}
