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; }