mwSize *mxGetDimensions(const mxArray *ptr)
{
InternalType *pIT = (InternalType *)ptr;
if (pIT == NULL)
{
return NULL;
}
switch (pIT->getType())
{
case InternalType::ScilabList:
case InternalType::ScilabMList:
case InternalType::ScilabTList:
{
int *piDims = (int *)MALLOC(sizeof(int));
piDims[0] = pIT->getAs<Container>()->getSize();
return piDims;
}
default:
{
GenericType *pGT = pIT->getAs<GenericType>();
if (pGT == NULL)
{
return NULL;
}
return pGT->getDimsArray();
}
}
return NULL;
}
mxArray *mxDuplicateArray(const mxArray *ptr)
{
InternalType *pIT = (InternalType *)ptr;
if (pIT == NULL)
{
return 0;
}
return (mxArray *)pIT->clone();
}
double mxGetEps(void)
{
InternalType *pITEps = symbol::Context::getInstance()->get(symbol::Symbol(L"%eps"));
if (pITEps && pITEps->isDouble())
{
return pITEps->getAs<Double>()->get(0);
}
return -1;
}
double mxGetInf(void)
{
InternalType *pITInf = symbol::Context::getInstance()->get(symbol::Symbol(L"%inf"));
if (pITInf && pITInf->isDouble())
{
return pITInf->getAs<Double>()->get(0);
}
return -1;
}
std::wstring Inspector::showUnreferencedItem(size_t _iPos)
{
std::wstring st;
InternalType* pIT = getUnreferencedItem(_iPos);
if (pIT == NULL)
{
st = L"NULL";
}
else
{
st = pIT->getTypeStr();
}
return st;
}
List* Cell::extractCell(typed_list* _pArgs)
{
InternalType* pIT = extract(_pArgs);
if (pIT == NULL || pIT->isCell() == false)
{
return NULL;
}
List* pList = new List();
Cell* pCell = pIT->getAs<Cell>();
for (int i = 0 ; i < pCell->getSize() ; i++)
{
pList->append(pCell->get(i));
}
pCell->killMe();
return pList;
}
mxClassID mxGetClassID(const mxArray *ptr)
{
InternalType *pIT = dynamic_cast<InternalType*>((InternalType*)ptr);
if (pIT == NULL)
{
return mxUNKNOWN_CLASS;
}
switch (pIT->getType())
{
case InternalType::ScilabInt8:
return mxINT8_CLASS;
case InternalType::ScilabUInt8:
return mxUINT8_CLASS;
case InternalType::ScilabInt16:
return mxINT16_CLASS;
case InternalType::ScilabUInt16:
return mxUINT16_CLASS;
case InternalType::ScilabInt32:
return mxINT32_CLASS;
case InternalType::ScilabUInt32:
return mxUINT32_CLASS;
case InternalType::ScilabInt64:
return mxINT64_CLASS;
case InternalType::ScilabUInt64:
return mxUINT64_CLASS;
case InternalType::ScilabString:
return mxCHAR_CLASS;
case InternalType::ScilabDouble:
return mxDOUBLE_CLASS;
case InternalType::ScilabBool:
return mxLOGICAL_CLASS;
case InternalType::ScilabFloat:
return mxSINGLE_CLASS;
case InternalType::ScilabStruct:
return mxSTRUCT_CLASS;
case InternalType::ScilabCell:
return mxCELL_CLASS;
case InternalType::ScilabFunction:
return mxFUNCTION_CLASS;
default:
return mxUNKNOWN_CLASS;
}
}
int mxIsEmpty(const mxArray *ptr)
{
InternalType * pIT = (InternalType *)ptr;
if (pIT == NULL)
{
//true or false, whatever ;)
return 1;
}
switch (pIT->getType())
{
case InternalType::ScilabDouble:
{
Double *pD = pIT->getAs<Double>();
return pD->getSize() == 0;
}
case InternalType::ScilabCell:
{
Cell *pC = pIT->getAs<Cell>();
return pC->getSize() == 0;
}
case InternalType::ScilabContainer:
case InternalType::ScilabList:
case InternalType::ScilabMList:
case InternalType::ScilabTList:
{
Container *pC = pIT->getAs<Container>();
return pC->getSize() == 0;
}
default:
{
//other type can not be empty
return 0;
}
}
}
void RunVisitorT<T>::visitprivate(const LogicalOpExp &e)
{
try
{
InternalType *pITR = NULL; //assign only in non shortcut operations.
/*getting what to assign*/
e.getLeft().accept(*this);
InternalType *pITL = getResult();
if (isSingleResult() == false)
{
std::wostringstream os;
os << _W("Incompatible output argument.\n");
//os << ((Location)e.right_get().getLocation()).getLocationString() << std::endl;
throw ast::InternalError(os.str(), 999, e.getRight().getLocation());
}
setResult(NULL);
if (pITL->getType() == GenericType::ScilabImplicitList)
{
ImplicitList* pIL = pITL->getAs<ImplicitList>();
if (pIL->isComputable())
{
pITL = pIL->extractFullMatrix();
pIL->killMe();
}
}
InternalType *pResult = NULL;
switch (e.getOper())
{
case LogicalOpExp::logicalShortCutAnd :
{
pResult = GenericShortcutAnd(pITL);
if (pResult)
{
break;
}
//Continue to logicalAnd
}
case LogicalOpExp::logicalAnd :
{
/*getting what to assign*/
e.getRight().accept(*this);
pITR = getResult();
if (isSingleResult() == false)
{
std::wostringstream os;
os << _W("Incompatible output argument.\n");
//os << ((Location)e.right_get().getLocation()).getLocationString() << std::endl;
throw ast::InternalError(os.str(), 999, e.getRight().getLocation());
}
if (pITR->getType() == GenericType::ScilabImplicitList)
{
ImplicitList* pIR = pITR->getAs<ImplicitList>();
if (pIR->isComputable())
{
pITR = pIR->extractFullMatrix();
pIR->killMe();
}
}
pResult = GenericLogicalAnd(pITL, pITR);
break;
}
case LogicalOpExp::logicalShortCutOr :
{
pResult = GenericShortcutOr(pITL);
if (pResult)
{
break;
}
//Continue to logicalAnd
}
case LogicalOpExp::logicalOr :
{
/*getting what to assign*/
e.getRight().accept(*this);
pITR = getResult();
if (isSingleResult() == false)
{
std::wostringstream os;
os << _W("Incompatible output argument.\n");
//os << ((Location)e.right_get().getLocation()).getLocationString() << std::endl;
throw ast::InternalError(os.str(), 999, e.getRight().getLocation());
}
if (pITR->getType() == GenericType::ScilabImplicitList)
{
ImplicitList* pIR = pITR->getAs<ImplicitList>();
if (pIR->isComputable())
{
pITR = pIR->extractFullMatrix();
}
}
pResult = GenericLogicalOr(pITL, pITR);
break;
}
default :
break;
}
//overloading
if (pResult == NULL)
{
// We did not have any algorithm matching, so we try to call OverLoad
pResult = callOverloadOpExp(e.getOper(), pITL, pITR);
}
setResult(pResult);
// protect pResult in case where pITL or pITR equal pResult
pResult->IncreaseRef();
//clear left and/or right operands
pITL->killMe();
if (pITR)
{
pITR->killMe();
}
// unprotect pResult
pResult->DecreaseRef();
}
catch (ast::InternalError& error)
{
clearResult();
error.SetErrorLocation(e.getLocation());
throw error;
}
}
void RunVisitorT<T>::visitprivate(const OpExp &e)
{
InternalType * pITL = NULL, * pITR = NULL, * pResult = NULL;
try
{
/*getting what to assign*/
e.getLeft().accept(*this);
if (isSingleResult() == false)
{
clearResult();
std::wostringstream os;
os << _W("Incompatible output argument.\n");
//os << ((Location)e.right_get().getLocation()).getLocationString() << std::endl;
throw ast::InternalError(os.str(), 999, e.getRight().getLocation());
}
pITL = getResult();
/*getting what to assign*/
e.getRight().accept(*this);
if (isSingleResult() == false)
{
clearResult();
std::wostringstream os;
os << _W("Incompatible output argument.\n");
//os << ((Location)e.right_get().getLocation()).getLocationString() << std::endl;
throw ast::InternalError(os.str(), 999, e.getRight().getLocation());
}
pITR = getResult();
if (pITL->getType() == GenericType::ScilabImplicitList)
{
ImplicitList* pIL = pITL->getAs<ImplicitList>();
if (pIL->isComputable())
{
pITL = pIL->extractFullMatrix();
pIL->killMe();
}
}
if (pITR->getType() == GenericType::ScilabImplicitList)
{
ImplicitList* pIR = pITR->getAs<ImplicitList>();
if (pIR->isComputable())
{
pITR = pIR->extractFullMatrix();
pIR->killMe();
}
}
switch (e.getOper())
{
case OpExp::plus :
{
pResult = GenericPlus(pITL, pITR);
break;
}
case OpExp::unaryMinus :
{
pResult = GenericUnaryMinus(pITR);
break;
}
case OpExp::minus :
{
pResult = GenericMinus(pITL, pITR);
break;
}
case OpExp::times:
{
pResult = GenericTimes(pITL, pITR);
break;
}
case OpExp::ldivide:
{
pResult = GenericLDivide(pITL, pITR);
break;
}
case OpExp::dotldivide :
{
pResult = GenericDotLDivide(pITL, pITR);
break;
}
case OpExp::rdivide:
{
pResult = GenericRDivide(pITL, pITR);
break;
}
case OpExp::dotrdivide :
{
pResult = GenericDotRDivide(pITL, pITR);
break;
}
case OpExp::dottimes :
{
pResult = GenericDotTimes(pITL, pITR);
break;
}
case OpExp::dotpower :
{
pResult = GenericDotPower(pITL, pITR);
break;
}
case OpExp::eq :
{
pResult = GenericComparisonEqual(pITL, pITR);
break;
}
case OpExp::ne :
{
pResult = GenericComparisonNonEqual(pITL, pITR);
break;
}
case OpExp::lt :
{
pResult = GenericLess(pITL, pITR);
break;
}
case OpExp::le :
{
pResult = GenericLessEqual(pITL, pITR);
break;
}
case OpExp::gt :
{
pResult = GenericGreater(pITL, pITR);
break;
}
case OpExp::ge :
{
pResult = GenericGreaterEqual(pITL, pITR);
break;
}
case OpExp::power :
{
pResult = GenericPower(pITL, pITR);
break;
}
case OpExp::krontimes :
{
pResult = GenericKrontimes(pITL, pITR);
break;
}
case OpExp::kronrdivide :
{
pResult = GenericKronrdivide(pITL, pITR);
break;
}
case OpExp::kronldivide :
{
pResult = GenericKronldivide(pITL, pITR);
break;
}
default :
break;
}
//overloading
if (pResult == NULL)
{
// We did not have any algorithm matching, so we try to call OverLoad
pResult = callOverloadOpExp(e.getOper(), pITL, pITR);
}
setResult(pResult);
//clear left and/or right operands
if (pResult != pITL)
{
pITL->killMe();
}
if (pResult != pITR)
{
pITR->killMe();
}
}
catch (ast::InternalError& error)
{
setResult(NULL);
if (pResult)
{
pResult->killMe();
}
if (pITL && (pITL != pResult))
{
pITL->killMe();
}
if (pITR && (pITR != pResult))
{
pITR->killMe();
}
error.SetErrorLocation(e.getLocation());
throw error;
}
/*if (e.getDecorator().res.isConstant())
{
}*/
}
/*--------------------------------------------------------------------------*/
Function::ReturnValue sci_load(types::typed_list &in, int _iRetCount, types::typed_list &out)
{
if (in.size() < 1)
{
Scierror(999, _("%s: Wrong number of input argument(s): at least %d expected.\n"), fname.data(), 1);
return types::Function::Error;
}
InternalType* pIT = in[0];
if (pIT->getId() != InternalType::IdScalarString)
{
Scierror(999, _("%s: Wrong type for input argument #%d: A string expected.\n"), fname.data(), 1);
return Function::Error;
}
String *pS = pIT->getAs<types::String>();
wchar_t* pwstPathLib = expandPathVariableW(pS->get(0));
char* pstPath = wide_string_to_UTF8(pwstPathLib);
if (FileExist(pstPath))
{
if (isHDF5File(pstPath))
{
FREE(pstPath);
FREE(pwstPathLib);
//call overload
std::wstring wstFuncName = L"%_sodload";
ast::ExecVisitor exec;
Callable::ReturnValue Ret = Callable::Error;
Ret = Overload::call(wstFuncName, in, _iRetCount, out, &exec);
return Ret;
}
else
{
int err = 0;
Library* lib = loadlib(pS->get(0), &err);
FREE(pstPath);
switch (err)
{
case 0:
//no error
break;
case 1:
{
char* pstPath = wide_string_to_UTF8(pS->get(0));
Scierror(999, _("%s: %s is not a valid module file.\n"), fname.data(), pstPath);
FREE(pstPath);
return Function::Error;
}
case 2:
{
Scierror(999, "%s: %s", fname.data(), _("Redefining permanent variable.\n"));
return Function::Error;
}
default:
{
//nothing
}
}
FREE(pwstPathLib);
lib->killMe();
}
}
else
{
Scierror(999, _("%s: Unable to open file: \"%ls\".\n"), fname.data(), pwstPathLib);
FREE(pstPath);
FREE(pwstPathLib);
return Function::Error;
}
return Function::OK;
}
/**
** toString to display Structs
** FIXME : Find a better indentation process
*/
bool Cell::subMatrixToString(std::wostringstream& ostr, int* _piDims, int /*_iDims*/)
{
int iPrecision = ConfigVariable::getFormatSize();
if (isEmpty())
{
ostr << L" {}";
}
else
{
//max len for each column
int *piTypeLen = new int[getCols()];
int *piSizeLen = new int[getCols()];
memset(piTypeLen, 0x00, getCols() * sizeof(int));
memset(piSizeLen, 0x00, getCols() * sizeof(int));
for (int j = 0 ; j < getCols() ; j++)
{
for (int i = 0 ; i < getRows() ; i++)
{
_piDims[0] = i;
_piDims[1] = j;
int iPos = getIndex(_piDims);
InternalType* pIT = get(iPos);
if (pIT->isAssignable())
{
//compute number of digits to write dimensions
int iTypeLen = 0;
if (pIT->isGenericType())
{
GenericType* pGT = pIT->getAs<GenericType>();
for (int k = 0 ; k < pGT->getDims() ; k++)
{
iTypeLen += static_cast<int>(log10(static_cast<double>(pGT->getDimsArray()[k])) + 1);
}
piSizeLen[j] = std::max(piSizeLen[j], iTypeLen + (pGT->getDims() - 1));//add number of "x"
}
else
{
//types non derived from ArrayOf.
int iSize = static_cast<int>(log10(static_cast<double>(pIT->getAs<GenericType>()->getRows())) + 1);
piSizeLen[j] = std::max(piSizeLen[j], iSize);
}
}
else
{
//no size so let a white space, size == 1
piSizeLen[j] = std::max(piSizeLen[j], 1);
}
piTypeLen[j] = std::max(piTypeLen[j], static_cast<int>(pIT->getTypeStr().size()));
}
}
for (int i = 0 ; i < getRows() ; i++)
{
for (int j = 0 ; j < getCols() ; j++)
{
_piDims[0] = i;
_piDims[1] = j;
int iPos = getIndex(_piDims);
InternalType* pIT = get(iPos);
ostr << L" [";
if (pIT->isAssignable())
{
if (pIT->isGenericType())
{
//" ixjxkxl type "
GenericType* pGT = pIT->getAs<GenericType>();
std::wostringstream ostemp;
for (int k = 0 ; k < pGT->getDims() ; k++)
{
if (k != 0)
{
ostemp << L"x";
}
ostemp << pGT->getDimsArray()[k];
}
configureStream(&ostr, piSizeLen[j], iPrecision, ' ');
ostr << std::right << ostemp.str();
}
else
{
//" i "
configureStream(&ostr, piSizeLen[j], iPrecision, ' ');
if (pIT->isList())
{
ostr << std::right << pIT->getAs<List>()->getSize();
}
else
{
ostr << std::right << 1;
}
}
}
else
{
configureStream(&ostr, piSizeLen[j], iPrecision, ' ');
ostr << L"";//fill with space
}
ostr << L" ";
configureStream(&ostr, piTypeLen[j], iPrecision, ' ');
ostr << std::left << pIT->getTypeStr();
ostr << L"]";
}
ostr << std::endl;
}
delete[] piSizeLen;
delete[] piTypeLen;
}
ostr << std::endl;
return true;
}
double mxGetScalar(const mxArray *ptr)
{
// TODO: review spec
InternalType *pIT = (InternalType *)ptr;
if (pIT == NULL)
{
return 0;
}
switch (pIT->getType())
{
case InternalType::ScilabDouble:
{
Double *pD = pIT->getAs<Double>();
return pD->get(0);
}
case InternalType::ScilabBool:
{
Bool *pB = pIT->getAs<Bool>();
return (double)pB->get(0);
}
case InternalType::ScilabInt8:
{
Int8 *pI = pIT->getAs<Int8>();
return (double)pI->get(0);
}
case InternalType::ScilabUInt8:
{
UInt8 *pI = pIT->getAs<UInt8>();
return (double)pI->get(0);
}
case InternalType::ScilabInt16:
{
Int16 *pI = pIT->getAs<Int16>();
return (double)pI->get(0);
}
case InternalType::ScilabUInt16:
{
UInt16 *pI = pIT->getAs<UInt16>();
return (double)pI->get(0);
}
case InternalType::ScilabInt32:
{
Int32 *pI = pIT->getAs<Int32>();
return (double)pI->get(0);
}
case InternalType::ScilabUInt32:
{
UInt32 *pI = pIT->getAs<UInt32>();
return (double)pI->get(0);
}
case InternalType::ScilabInt64:
{
Int64 *pI = pIT->getAs<Int64>();
return (double)pI->get(0);
}
case InternalType::ScilabUInt64:
{
UInt64 *pI = pIT->getAs<UInt64>();
return (double)pI->get(0);
}
default:
return 0;
}
}
void *mxGetImagData(const mxArray *ptr)
{
InternalType *pIT = (InternalType *)ptr;
if (pIT == NULL)
{
return NULL;
}
switch (pIT->getType())
{
case InternalType::ScilabDouble:
{
Double *pD = pIT->getAs<Double>();
return pD->getImg();
}
case InternalType::ScilabBool:
{
Bool *pB = pIT->getAs<Bool>();
return pB->getImg();
}
case InternalType::ScilabInt8:
{
Int8 *pI = pIT->getAs<Int8>();
return pI->getImg();
}
case InternalType::ScilabUInt8:
{
UInt8 *pI = pIT->getAs<UInt8>();
return pI->getImg();
}
case InternalType::ScilabInt16:
{
Int16 *pI = pIT->getAs<Int16>();
return pI->getImg();
}
case InternalType::ScilabUInt16:
{
UInt16 *pI = pIT->getAs<UInt16>();
return pI->getImg();
}
case InternalType::ScilabInt32:
{
Int32 *pI = pIT->getAs<Int32>();
return pI->getImg();
}
case InternalType::ScilabUInt32:
{
UInt32 *pI = pIT->getAs<UInt32>();
return pI->getImg();
}
case InternalType::ScilabInt64:
{
Int64 *pI = pIT->getAs<Int64>();
return pI->getImg();
}
case InternalType::ScilabUInt64:
{
UInt64 *pI = pIT->getAs<UInt64>();
return pI->getImg();
}
default:
return NULL;
}
}
