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;
}
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())
{
}*/
}
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;
}
}
