bool IsscalarAnalyzer::analyze(AnalysisVisitor & visitor, const unsigned int lhs, ast::CallExp & e) { if (lhs != 1) { return false; } const ast::exps_t args = e.getArgs(); if (args.size() != 1) { return false; } ast::Exp * first = args.front(); first->accept(visitor); Result & R1 = visitor.getResult(); TIType & type1 = R1.getType(); if (!type1.ismatrix()) { return false; } if (type1.isscalar()) { TIType type(visitor.getGVN(), TIType::BOOLEAN); Result & res = e.getDecorator().setResult(type); res.getConstant() = new types::Bool(1); e.getDecorator().setCall(L"isscalar"); visitor.setResult(res); return true; } return false; }
void DeprecatedChecker::__Mfprintf::preCheckNode(const ast::Exp & e, SLintContext & context, SLintResult & result) { const ast::CallExp & ce = static_cast<const ast::CallExp &>(e); const ast::exps_t args = ce.getArgs(); if (args.size() != 0) { const ast::Exp & first = *args.front(); if (first.isDoubleExp() && static_cast<const ast::DoubleExp &>(first).getValue() == -1) { result.report(context, e.getLocation(), *this, _("mfprintf(-1, ...) is deprecated.")); } } }
bool IconvertAnalyzer::analyze(AnalysisVisitor & visitor, const unsigned int lhs, ast::CallExp & e) { if (lhs != 1) { return false; } const ast::exps_t args = e.getArgs(); if (args.size() != 2) { return false; } ast::Exp * first = args.front(); ast::Exp * second = args.back(); first->accept(visitor); Result R1 = visitor.getResult(); TIType & type1 = R1.getType(); if (!type1.ismatrix()) { return false; } second->accept(visitor); Result & R2 = visitor.getResult(); double val; unsigned char ival; if (R2.getConstant().getDblValue(val) && tools::asInteger<unsigned char>(val, ival)) { TIType::Type type; switch (ival) { case 0: type = TIType::DOUBLE; break; case 1: type = TIType::INT8; break; case 2: type = TIType::INT16; break; case 4: type = TIType::INT32; break; case 8: type = TIType::INT64; break; case 11: type = TIType::UINT8; break; case 12: type = TIType::UINT16; break; case 14: type = TIType::UINT32; break; case 18: type = TIType::UINT64; break; default: return false; } TIType typ(visitor.getGVN(), type, type1.rows, type1.cols); Result & res = e.getDecorator().setResult(typ); e.getDecorator().setCall(L"iconvert"); visitor.setResult(res); return true; } return false; }
void AnalysisVisitor::visit(ast::IfExp & e) { logger.log(L"IfExp", e.getLocation()); ast::Exp * shortcutExp = nullptr; // we apply the ConstantVisitor e.getTest().accept(cv); ast::Exp & test = e.getTest(); if (cv.getResult() && test.isConstExp()) { e.accept(cv); // we have a constant ! ast::ConstExp & ce = static_cast<ast::ConstExp &>(test); types::InternalType * pIT = ce.getConstant(); if (!pIT) { test.accept(cv.getExec()); pIT = ce.getConstant(); } if (pIT) { const bool result = pIT->isTrue(); if (result) { shortcutExp = &e.getThen(); e.getExps()[1] = nullptr; } else { shortcutExp = &e.getElse(); e.getExps()[2] = nullptr; } } } else { ast::Exp * val = nullptr; bool isEq; if (test.isOpExp()) { ast::OpExp & oe = static_cast<ast::OpExp &>(test); isEq = oe.getOper() == ast::OpExp::eq; if (isEq || oe.getOper() == ast::OpExp::ne) { if (oe.getLeft().isDoubleExp()) { ast::DoubleExp & de = static_cast<ast::DoubleExp &>(oe.getLeft()); if (types::InternalType * pIT = de.getConstant()) { if (pIT->isDouble()) { types::Double * pDbl = static_cast<types::Double *>(pIT); if (pDbl->isEmpty()) { val = &oe.getRight(); } } } } else if (oe.getRight().isDoubleExp()) { ast::DoubleExp & de = static_cast<ast::DoubleExp &>(oe.getRight()); if (types::InternalType * pIT = de.getConstant()) { if (pIT->isDouble()) { types::Double * pDbl = static_cast<types::Double *>(pIT); if (pDbl->isEmpty()) { val = &oe.getLeft(); } } } } } } else { ast::CallExp * ce = nullptr; if (test.isNotExp()) { ast::NotExp & ne = static_cast<ast::NotExp &>(test); if (ne.getExp().isCallExp()) { ce = &static_cast<ast::CallExp &>(ne.getExp()); isEq = false; } } else if (test.isCallExp()) { ce = &static_cast<ast::CallExp &>(test); isEq = true; } if (ce && ce->getName().isSimpleVar()) { ast::SimpleVar & var = static_cast<ast::SimpleVar &>(ce->getName()); const symbol::Symbol & sym = var.getSymbol(); const std::wstring & name = sym.getName(); if (name == L"isempty" && getCM().checkGlobalConstant(sym)) { const ast::exps_t args = ce->getArgs(); if (args.size() == 1) { val = args.front(); } } } } if (val) { // test is something like val == [], isempty(val), val ~= [], ~isempty(val) val->accept(*this); Result & res = getResult(); TIType & ty = res.getType(); if ((ty.ismatrix() && ty.isscalar()) || (getCM().check(ConstraintManager::STRICT_POSITIVE, ty.rows.getValue()) || getCM().check(ConstraintManager::STRICT_POSITIVE, ty.cols.getValue()))) { if (isEq) { shortcutExp = &e.getElse(); e.getExps()[2] = nullptr; } else { shortcutExp = &e.getThen(); e.getExps()[1] = nullptr; } } } } if (shortcutExp) { e.replace(shortcutExp); shortcutExp->accept(*this); } else { dm.addBlock(Block::EXCLUSIVE, &e); e.getTest().accept(*this); dm.releaseTmp(getResult().getTempId()); dm.addBlock(Block::NORMAL, &e.getThen()); e.getThen().accept(*this); dm.finalizeBlock(); dm.addBlock(Block::NORMAL, e.hasElse() ? &e.getElse() : nullptr); if (e.hasElse()) { e.getElse().accept(*this); } dm.finalizeBlock(); dm.finalizeBlock(); } }
bool AnalysisVisitor::analyzeIndices(TIType & type, ast::CallExp & ce) { const ast::exps_t args = ce.getArgs(); const unsigned int size = args.size(); if (size >= 3) { // Not handle yet... // TODO return false; } if (size == 0) { Result & res = ce.getDecorator().setResult(type); setResult(res); return true; } SymbolicDimension first, second; bool safe, ret; argIndices.emplace(static_cast<ast::SimpleVar &>(ce.getName()), size, 1); if (size == 1) { // when there is one argument, a(?) is equivalent to A(?,1) // where A = matrix(a, r_a * c_a, 1) SymbolicDimension rows(type.rows); second = SymbolicDimension(getGVN(), 1); if (type.cols != 1) { rows *= type.cols; } ret = getDimension(rows, *args.front(), safe, first); } else { bool _safe; ret = getDimension(type.rows, *args.front(), _safe, first); if (ret) { argIndices.top().getIndex() = 2; ret = getDimension(type.cols, *args.back(), safe, second); safe = safe && _safe; } else { safe = _safe; } } argIndices.pop(); if (ret) { TIType typ(getGVN(), type.type, first, second); Result & _res = ce.getDecorator().setResult(typ); setResult(_res); ce.getDecorator().safe = safe; } return ret; }