scilabVar API_PROTO(createStructMatrix)(scilabEnv env, int dim, const int* dims)
{
#ifdef __API_SCILAB_SAFE__
if (dims == nullptr)
{
scilab_setInternalError(env, L"createStructMatrix", _W("dims array cannot be NULL"));
return nullptr;
}
for (int i = 0; i < dim; ++i)
{
if (dims[i] < 0)
{
scilab_setInternalError(env, L"createStructMatrix", _W("dimensions cannot be negative"));
return nullptr;
}
}
#endif
types::Struct* s = new types::Struct(dim, dims);
#ifdef __API_SCILAB_SAFE__
if (s == nullptr)
{
scilab_setInternalError(env, L"createStructMatrix", _W("memory allocation error"));
return nullptr;
}
#endif
return (scilabVar)s;
}
int API_PROTO(getFields)(scilabEnv env, scilabVar var, wchar_t*** fields)
{
types::Struct* s = (types::Struct*)var;
#ifdef __API_SCILAB_SAFE__
if (s->isStruct() == false)
{
scilab_setInternalError(env, L"getFields", _W("var must be a struct variable"));
return STATUS_ERROR;
}
#endif
if (s->getSize() == 0)
{
return 0;
}
std::unordered_map<std::wstring, int> fieldsMap = s->get(0)->getFields();
*fields = new wchar_t*[fieldsMap.size()];
for (const auto & field : fieldsMap)
{
(*fields)[field.second] = os_wcsdup(field.first.data());
}
return (int)fieldsMap.size();
}
scilabStatus API_PROTO(call)(scilabEnv env, const wchar_t* name, int nin, scilabVar* in, int nout, scilabVar* out)
{
types::typed_list inCall;
types::typed_list outCall;
for (int i = 0; i < nin; i++)
{
inCall.push_back((types::InternalType*)in[i]);
inCall.back()->IncreaseRef();
}
types::Function::ReturnValue callResult = Overload::call(name, inCall, nout, outCall);
for (int i = 0; i < nin; i++)
{
inCall[i]->DecreaseRef();
}
if (callResult != types::Function::OK)
{
scilab_setInternalError(env, L"call", _W("error in called function"));
return STATUS_ERROR;
}
for (int i = 0; i < nout; ++i)
{
out[i] = (scilabVar)outCall[i];
}
return STATUS_OK;
}
scilabVar API_PROTO(createStruct)(scilabEnv env)
{
types::Struct* s = new types::Struct(1, 1);
#ifdef __API_SCILAB_SAFE__
if (s == nullptr)
{
scilab_setInternalError(env, L"createStruct", _W("memory allocation error"));
return nullptr;
}
#endif
return (scilabVar)s;
}
scilabVar API_PROTO(getMListField)(scilabEnv env, scilabVar var, const wchar_t* field)
{
types::MList* l = (types::MList*)var;
#ifdef __API_SCILAB_SAFE__
if (l->isMList() == false)
{
scilab_setInternalError(env, L"getMListField", _W("var must be a mlist variable"));
return nullptr;
}
#endif
return (scilabVar)l->getField(field);
}
scilabVar API_PROTO(createUnsignedInteger64Matrix)(scilabEnv env, int dim, const int* dims)
{
#ifdef __API_SCILAB_SAFE__
if (dims == nullptr)
{
scilab_setInternalError(env, L"createUnsignedIntegerMatrix64", _W("dims array cannot be NULL"));
return nullptr;
}
for (int i = 0; i < dim; ++i)
{
if (dims[i] < 0)
{
scilab_setInternalError(env, L"createUnsignedIntegerMatrix64", _W("dimensions cannot be negative"));
return nullptr;
}
}
#endif
return (scilabVar)new types::UInt64(dim, dims);
}
scilabVar API_PROTO(getListItem)(scilabEnv env, scilabVar var, int index)
{
types::List* l = (types::List*)var;
#ifdef __API_SCILAB_SAFE__
if (l->isList() == false)
{
scilab_setInternalError(env, L"getListItem", _W("var must be a list variable"));
return nullptr;
}
#endif
if (index < 0 || index >= l->getSize())
{
#ifdef __API_SCILAB_SAFE__
scilab_setInternalError(env, L"getListItem", _W("index out of bounds"));
#endif
return nullptr;
}
return (scilabVar)l->get(index);
}
scilabStatus API_PROTO(getInteger64Array)(scilabEnv env, scilabVar var, long long** vals)
{
types::Int64* i = (types::Int64*)var;
#ifdef __API_SCILAB_SAFE__
if (i->isInt64() == false)
{
scilab_setInternalError(env, L"getInteger64Array", _W("var must be a int64 variable"));
return STATUS_ERROR;
}
#endif
*vals = i->get();
return STATUS_OK;
}
scilabStatus API_PROTO(getUnsignedInteger64)(scilabEnv env, scilabVar var, unsigned long long* val)
{
types::UInt64* i = (types::UInt64*)var;
#ifdef __API_SCILAB_SAFE__
if (i->isUInt64() == false || i->isScalar() == false)
{
scilab_setInternalError(env, L"getUnsignedInteger64", _W("var must be a scalar uint64 variable"));
return STATUS_ERROR;
}
#endif
*val = i->get()[0];
return STATUS_OK;
}
scilabStatus API_PROTO(getInteger32)(scilabEnv env, scilabVar var, int* val)
{
types::Int32* i = (types::Int32*)var;
#ifdef __API_SCILAB_SAFE__
if (i->isInt32() == false || i->isScalar() == false)
{
scilab_setInternalError(env, L"getInteger32", _W("var must be a scalar int32 variable"));
return STATUS_ERROR;
}
#endif
*val = i->get()[0];
return STATUS_OK;
}
scilabStatus API_PROTO(setInteger32Array)(scilabEnv env, scilabVar var, const int* vals)
{
types::Int32* i = (types::Int32*)var;
#ifdef __API_SCILAB_SAFE__
if (i->isInt32() == false)
{
scilab_setInternalError(env, L"setInteger32Array", _W("var must be a int32 variable"));
return STATUS_ERROR;
}
#endif
i->set(vals);
return STATUS_OK;
}
scilabStatus API_PROTO(setUnsignedInteger64Array)(scilabEnv env, scilabVar var, const unsigned long long* vals)
{
types::UInt64* i = (types::UInt64*)var;
#ifdef __API_SCILAB_SAFE__
if (i->isUInt64() == false)
{
scilab_setInternalError(env, L"setUnsignedInteger64Array", _W("var must be a uint64 variable"));
return STATUS_ERROR;
}
#endif
i->set(vals);
return STATUS_OK;
}
scilabStatus API_PROTO(setStructMatrixData)(scilabEnv env, scilabVar var, const wchar_t* field, const int* index, scilabVar data)
{
types::Struct* s = (types::Struct*)var;
#ifdef __API_SCILAB_SAFE__
if (s->isStruct() == false)
{
scilab_setInternalError(env, L"setStructMatrixData", _W("var must be a struct variable"));
return STATUS_ERROR;
}
#endif
types::SingleStruct* ss = s->get(s->getIndex(index));
return ss->set(field, (types::InternalType*)data) ? STATUS_OK : STATUS_ERROR;
}
scilabStatus API_PROTO(appendToList)(scilabEnv env, scilabVar var, scilabVar val)
{
types::List* l = (types::List*)var;
#ifdef __API_SCILAB_SAFE__
if (l->isList() == false)
{
scilab_setInternalError(env, L"appendToList", _W("var must be a list variable"));
return STATUS_ERROR;
}
#endif
l->append((types::InternalType*)val);
return STATUS_OK;
}
scilabStatus API_PROTO(addField)(scilabEnv env, scilabVar var, const wchar_t* field)
{
types::Struct* s = (types::Struct*)var;
#ifdef __API_SCILAB_SAFE__
if (s->isStruct() == false)
{
scilab_setInternalError(env, L"addField", _W("var must be a struct variable"));
return STATUS_ERROR;
}
#endif
s->addField(field);
return STATUS_OK;
}
scilabStatus API_PROTO(setPointer)(scilabEnv env, scilabVar var, void* val)
{
types::Pointer* p = (types::Pointer*)var;
#ifdef __API_SCILAB_SAFE__
if (p->isPointer() == false)
{
scilab_setInternalError(env, L"setPointer", _W("var must be a pointer variable"));
return STATUS_ERROR;
}
#endif
p->set(val);
return STATUS_OK;
}
scilabStatus API_PROTO(getUnsignedInteger32Array)(scilabEnv env, scilabVar var, unsigned int** vals)
{
types::UInt32* i = (types::UInt32*)var;
#ifdef __API_SCILAB_SAFE__
if (i->isUInt32() == false)
{
scilab_setInternalError(env, L"getUnsignedInteger32Array", _W("var must be a uint32 variable"));
return STATUS_ERROR;
}
#endif
*vals = i->get();
return STATUS_OK;
}
scilabVar API_PROTO(getStructMatrix2dData)(scilabEnv env, scilabVar var, const wchar_t* field, int row, int col)
{
int index[2] = {row, col};
types::Struct* s = (types::Struct*)var;
#ifdef __API_SCILAB_SAFE__
if (s->isStruct() == false)
{
scilab_setInternalError(env, L"getStructMatrix2dData", _W("var must be a struct variable"));
return nullptr;
}
#endif
types::SingleStruct* ss = s->get(s->getIndex(index));
return (scilabVar)ss->get(field);
}
scilabStatus API_PROTO(setListItem)(scilabEnv env, scilabVar var, int index, scilabVar val)
{
types::List* l = (types::List*)var;
#ifdef __API_SCILAB_SAFE__
if (l->isList() == false)
{
scilab_setInternalError(env, L"setListItem", _W("var must be a list variable"));
return STATUS_ERROR;
}
#endif
bool ret = l->set(index, (types::InternalType*)val) != nullptr;
return ret ? STATUS_OK : STATUS_ERROR;
}
scilabVar API_PROTO(createStructMatrix2d)(scilabEnv env, int row, int col)
{
int dims[2] = {row, col};
#ifdef __API_SCILAB_SAFE__
for (int i = 0; i < 2; ++i)
{
if (dims[i] < 0)
{
scilab_setInternalError(env, L"createStructMatrix2d", _W("dimensions cannot be negative"));
return nullptr;
}
}
#endif
types::Struct* s = new types::Struct(2, dims);
#ifdef __API_SCILAB_SAFE__
if (s == nullptr)
{
scilab_setInternalError(env, L"createStructMatrix2d", _W("memory allocation error"));
return nullptr;
}
#endif
return (scilabVar)s;
}
int API_PROTO(getMListFieldNames)(scilabEnv env, scilabVar var, wchar_t*** fieldnames)
{
types::MList* l = (types::MList*)var;
#ifdef __API_SCILAB_SAFE__
if (l->isTList() == false)
{
scilab_setInternalError(env, L"getMListFieldNames", _W("var must be a tlist variable"));
return 0;
}
#endif
types::String* names = l->getFieldNames();
*fieldnames = names->get();
return names->getSize();
}
int API_PROTO(isUndefined)(scilabEnv env, scilabVar var, int index)
{
types::List* l = (types::List*)var;
#ifdef __API_SCILAB_SAFE__
if (l->isList() == false)
{
scilab_setInternalError(env, L"isUndefined", _W("var must be a list variable"));
return STATUS_ERROR;
}
#endif
types::InternalType* item = l->get(index);
if (item->isListUndefined())
{
return 1;
}
return 0;
}
/*fields*/
scilabStatus API_PROTO(addFields)(scilabEnv env, scilabVar var, int count, const wchar_t** fields)
{
types::Struct* s = (types::Struct*)var;
#ifdef __API_SCILAB_SAFE__
if (s->isStruct() == false)
{
scilab_setInternalError(env, L"addFields", _W("var must be a struct variable"));
return STATUS_ERROR;
}
#endif
for (int i = 0; i < count; ++i)
{
s->addField(fields[i]);
}
return STATUS_OK;
}
/*functions*/
scilabStatus API_PROTO(overload)(scilabEnv env, scilabVar var, int nin, scilabVar* in, int nout, scilabVar* out)
{
std::string &fname = ((types::GatewayCStruct*)env)->name;
wchar_t* pwstName = to_wide_string(fname.data());
std::wstring wsFunName(pwstName);
FREE(pwstName);
types::typed_list inCall;
types::typed_list outCall;
for (int i = 0; i < nin; i++)
{
inCall.push_back((types::InternalType*)in[i]);
inCall.back()->IncreaseRef();
}
types::Function::ReturnValue callResult = Overload::generateNameAndCall(wsFunName, inCall, nout, outCall);
for (int i = 0; i < nin; i++)
{
inCall[i]->DecreaseRef();
}
if (callResult != types::Function::OK)
{
scilab_setInternalError(env, L"call", _W("error in called function"));
return STATUS_ERROR;
}
for (int i = 0; i < nout; ++i)
{
out[i] = (scilabVar)outCall[i];
}
return STATUS_OK;
}
scilabStatus API_PROTO(setMListField)(scilabEnv env, scilabVar var, const wchar_t* field, scilabVar val)
{
types::MList* l = (types::MList*)var;
#ifdef __API_SCILAB_SAFE__
if (l->isMList() == false)
{
scilab_setInternalError(env, L"setMListField", _W("var must be a mlist variable"));
return STATUS_ERROR;
}
#endif
if (l->getIndexFromString(field) < 0)
{
//field does not, append it at last position
types::String* fields = l->getFieldNames();
fields->resize(1, fields->getSize() + 1);
fields->set(fields->getSize() - 1, field);
}
bool ret = l->set(field, (types::InternalType*)val) != nullptr;
return ret ? STATUS_OK : STATUS_ERROR;
}
