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; }
bool MatrixAnalyzer::analyze(AnalysisVisitor & visitor, const unsigned int lhs, ast::CallExp & e) { if (lhs > 1) { return false; } const ast::exps_t args = e.getArgs(); const unsigned int size = args.size(); if (size != 2 && size != 3) { return false; } if (size == 2) { return analyze2Args(visitor, args, e); } ast::Exp * first = args[0]; ast::Exp * second = args[1]; ast::Exp * third = args[2]; first->accept(visitor); Result R1 = visitor.getResult(); if (!R1.getType().ismatrix()) { return false; } second->accept(visitor); Result R2 = visitor.getResult(); third->accept(visitor); Result & R3 = visitor.getResult(); double val; SymbolicDimension rows; SymbolicDimension cols; if (R2.getConstant().getDblValue(val)) { const int nrows = tools::cast<int>(val); if (nrows <= 0) { return false; } else { rows = SymbolicDimension(visitor.getGVN(), nrows); } } else if (GVN::Value * gvnValue = R2.getConstant().getGVNValue()) { if (gvnValue->poly->isConstant() && gvnValue->poly->constant <= 0) { return false; } rows.setValue(gvnValue); rows.setGVN(&visitor.getGVN()); } else { return false; } if (R3.getConstant().getDblValue(val)) { const int ncols = tools::cast<int>(val); if (ncols <= 0) { return false; } else { cols = SymbolicDimension(visitor.getGVN(), ncols); } } else if (GVN::Value * gvnValue = R3.getConstant().getGVNValue()) { if (gvnValue->poly->isConstant() && gvnValue->poly->constant <= 0) { return false; } cols.setValue(gvnValue); cols.setGVN(&visitor.getGVN()); } else { return false; } const TIType & type = R1.getType(); SymbolicDimension prod1 = type.rows * type.cols; SymbolicDimension prod2 = rows * cols; bool res = visitor.getCM().check(ConstraintManager::EQUAL, prod1.getValue(), prod2.getValue()); if (res) { res = visitor.getCM().check(ConstraintManager::POSITIVE, rows.getValue()); if (!res) { return false; } } else { return false; } TIType resT(visitor.getGVN(), R1.getType().type, rows, cols); int tempId; if (R1.getTempId() != -1) { tempId = R1.getTempId(); } else { tempId = visitor.getDM().getTmpId(resT, false); } Result & _res = e.getDecorator().setResult(Result(resT, tempId)); visitor.setResult(_res); return true; }
bool MatrixAnalyzer::analyze2Args(AnalysisVisitor & visitor, const ast::exps_t & args, ast::CallExp & e) { ast::Exp * first = args[0]; ast::Exp * second = args[1]; first->accept(visitor); Result R1 = visitor.getResult(); if (!R1.getType().ismatrix()) { return false; } SymbolicDimension rows; SymbolicDimension cols; bool hasRC = false; if (second->isCallExp()) { ast::CallExp & ce = static_cast<ast::CallExp &>(*second); if (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"size" && visitor.getCM().checkGlobalConstant(sym)) { const ast::exps_t size_args = ce.getArgs(); if (size_args.size() == 1) { ast::Exp * e = size_args[0]; e->accept(visitor); Result & res = visitor.getResult(); if (res.getType().ismatrix()) { rows = res.getType().rows; cols = res.getType().cols; hasRC = true; } } } } } if (hasRC) { const TIType & type = R1.getType(); SymbolicDimension prod1 = type.rows * type.cols; SymbolicDimension prod2 = rows * cols; bool res = visitor.getCM().check(ConstraintManager::EQUAL, prod1.getValue(), prod2.getValue()); if (res) { TIType resT(visitor.getGVN(), R1.getType().type, rows, cols); int tempId; if (R1.getTempId() != -1) { tempId = R1.getTempId(); } else { tempId = visitor.getDM().getTmpId(resT, false); } Result & _res = e.getDecorator().setResult(Result(resT, tempId)); visitor.setResult(_res); return true; } } return false; }
bool SymbolicList::get(AnalysisVisitor & visitor, ast::ListExp & le, SymbolicList & sl) { le.getStart().accept(visitor); Result Rstart = visitor.getResult(); le.getEnd().accept(visitor); Result Rend = visitor.getResult(); le.getStep().accept(visitor); Result & Rstep = visitor.getResult(); double start, step, end; if (Rstart.getConstant().getDblValue(start) && Rstep.getConstant().getDblValue(step) && Rend.getConstant().getDblValue(end)) { if (tools::isAnInt(start) && tools::isAnInt(step) && tools::isAnInt(end)) { sl = SymbolicList(start, step, end); return true; } return false; } GVN::Value * gvnStart, * gvnStep, * gvnEnd; if (Rstart.getConstant().getDblValue(start)) { int64_t _start; if (tools::asInteger(start, _start)) { gvnStart = visitor.getGVN().getValue(_start); } else { return false; } } else if (GVN::Value * v = Rstart.getConstant().getGVNValue()) { gvnStart = v; } else { return false; } if (Rstep.getConstant().getDblValue(step)) { int64_t _step; if (tools::asInteger(step, _step)) { gvnStep = visitor.getGVN().getValue(_step); } else { return false; } } else if (GVN::Value * v = Rstep.getConstant().getGVNValue()) { gvnStep = v; } else { return false; } if (Rend.getConstant().getDblValue(end)) { int64_t _end; if (tools::asInteger(end, _end)) { gvnEnd = visitor.getGVN().getValue(_end); } else { return false; } } else if (GVN::Value * v = Rend.getConstant().getGVNValue()) { gvnEnd = v; } else { return false; } sl = SymbolicList(gvnStart, gvnStep, gvnEnd); return true; }
std::vector<TIType> Block::addCall(AnalysisVisitor & visitor, const unsigned int lhs, const symbol::Symbol & sym, std::vector<TIType> & in, ast::CallExp * callexp) { tools::SymbolMap<Info>::iterator it; Block * block = getDefBlock(sym, it, false); types::InternalType * pIT = nullptr; std::vector<TIType> out(lhs, TIType(visitor.getGVN())); TIType type; if (block) { type = it->second.type; } else { type = DataManager::getSymInScilabContext(getGVN(), sym, pIT); } switch (type.type) { case TIType::FUNCTION: { if (lhs > 0) { TIType ty = Checkers::check(getGVN(), sym.getName(), in); if (ty.type != TIType::UNKNOWN && ty.hasInvalidDims()) { out[0] = ty.asUnknownMatrix(); } else { out[0] = ty; } } break; } case TIType::MACRO: { if (pIT) { visitor.getPMC().getOutTypes(visitor, dm->getMacroDef(static_cast<types::Macro *>(pIT)), in, out); } else { if (it->second.exp && it->second.exp->isFunctionDec()) { DeclaredMacroDef macrodef(static_cast<ast::FunctionDec *>(it->second.exp)); visitor.getPMC().getOutTypes(visitor, ¯odef, in, out); } else { DataManager::getSymInScilabContext(getGVN(), sym, pIT); visitor.getPMC().getOutTypes(visitor, dm->getMacroDef(static_cast<types::Macro *>(pIT)), in, out); } } break; } case TIType::MACROFILE: { DataManager::getSymInScilabContext(getGVN(), sym, pIT); visitor.getPMC().getOutTypes(visitor, dm->getMacroDef(static_cast<types::MacroFile *>(pIT)->getMacro()), in, out); break; } default: { } } return out; }
bool MemInitAnalyzer::analyze(AnalysisVisitor & visitor, const unsigned int lhs, ast::CallExp & e) { const ast::exps_t args = e.getArgs(); if (args.size() == 2) { ast::Exp * first = *args.begin(); ast::Exp * second = *std::next(args.begin()); first->accept(visitor); Result R1 = visitor.getResult(); visitor.getDM().releaseTmp(R1.getTempId(), first); second->accept(visitor); Result & R2 = visitor.getResult(); visitor.getDM().releaseTmp(R2.getTempId(), second); double val; SymbolicDimension rows, cols; bool empty = false; if (R1.getConstant().getDblValue(val)) { const int nrows = tools::cast<int>(val); if (nrows <= 0) { empty = true; } else { rows = SymbolicDimension(visitor.getGVN(), nrows); } } else if (GVN::Value * gvnValue = R1.getConstant().getGVNValue()) { rows.setValue(gvnValue); rows.setGVN(&visitor.getGVN()); } else { return false; } if (!empty) { if (R2.getConstant().getDblValue(val)) { const int ncols = tools::cast<int>(val); if (ncols <= 0) { empty = true; } else { cols = SymbolicDimension(visitor.getGVN(), ncols); } } else if (GVN::Value * gvnValue = R2.getConstant().getGVNValue()) { cols.setValue(gvnValue); cols.setGVN(&visitor.getGVN()); } else { return false; } } if (empty) { e.getDecorator().setResult(TIType(visitor.getGVN(), TIType::EMPTY)); } else { bool res = visitor.getCM().check(ConstraintManager::POSITIVE, rows.getValue()); if (res) { res = visitor.getCM().check(ConstraintManager::POSITIVE, cols.getValue()); if (!res) { return false; } } else { return false; } TIType resT(visitor.getGVN(), TIType::DOUBLE, rows, cols); e.getDecorator().setResult(Result(resT, visitor.getDM().getTmpId(resT, false))); } visitor.setResult(e.getDecorator().res); return true; } return false; }
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; }
bool SizeAnalyzer::analyze(AnalysisVisitor & visitor, const unsigned int lhs, ast::CallExp & e) { if (lhs > 2) { return false; } const ast::exps_t args = e.getArgs(); enum Kind { ROWS, COLS, ROWSTIMESCOLS, ROWSCOLS, ONE, BOTH, DUNNO } kind = DUNNO; const std::size_t size = args.size(); if (size == 0 || size >= 3) { return false; } ast::Exp * first = *args.begin(); if (!first) { return false; } first->accept(visitor); Result & res = visitor.getResult(); if (!res.getType().ismatrix()) { visitor.getDM().releaseTmp(res.getTempId(), first); return false; } switch (size) { case 1: if (lhs == 1) { kind = BOTH; } else if (lhs == 2) { kind = ROWSCOLS; } break; case 2: { ast::Exp * second = *std::next(args.begin()); if (second && lhs == 1) { if (second->isStringExp()) { const std::wstring & arg2 = static_cast<ast::StringExp *>(second)->getValue(); if (arg2 == L"r") { kind = ROWS; } else if (arg2 == L"c") { kind = COLS; } else if (arg2 == L"*") { kind = ROWSTIMESCOLS; } else { visitor.getDM().releaseTmp(res.getTempId(), first); return false; } } else if (second->isDoubleExp()) { const double arg2 = static_cast<ast::DoubleExp *>(second)->getValue(); if (arg2 == 1) { kind = ROWS; } else if (arg2 == 2) { kind = COLS; } else if (arg2 >= 3) { // TODO: we should handle hypermatrix kind = ONE; } else { visitor.getDM().releaseTmp(res.getTempId(), first); return false; } } } else { visitor.getDM().releaseTmp(res.getTempId(), first); return false; } break; } default: visitor.getDM().releaseTmp(res.getTempId(), first); return false; } TIType type(visitor.getGVN(), TIType::DOUBLE); switch (kind) { case ROWS: { SymbolicDimension & rows = res.getType().rows; Result & _res = e.getDecorator().setResult(type); _res.getConstant() = rows.getValue(); e.getDecorator().setCall(new SizeCall(SizeCall::R)); visitor.setResult(_res); break; } case COLS: { SymbolicDimension & cols = res.getType().cols; Result & _res = e.getDecorator().setResult(type); _res.getConstant() = cols.getValue(); e.getDecorator().setCall(new SizeCall(SizeCall::C)); visitor.setResult(_res); break; } case ROWSTIMESCOLS: { SymbolicDimension & rows = res.getType().rows; SymbolicDimension & cols = res.getType().cols; SymbolicDimension prod = rows * cols; Result & _res = e.getDecorator().setResult(type); _res.getConstant() = prod.getValue(); e.getDecorator().setCall(new SizeCall(SizeCall::RC)); visitor.setResult(_res); break; } case ROWSCOLS: { SymbolicDimension & rows = res.getType().rows; SymbolicDimension & cols = res.getType().cols; std::vector<Result> & mlhs = visitor.getLHSContainer(); mlhs.clear(); mlhs.reserve(2); mlhs.emplace_back(type); mlhs.back().getConstant() = rows.getValue(); mlhs.emplace_back(type); mlhs.back().getConstant() = cols.getValue(); e.getDecorator().setCall(new SizeCall(SizeCall::R_C)); break; } case ONE: { Result & _res = e.getDecorator().setResult(type); _res.getConstant() = new types::Double(1); e.getDecorator().setCall(new SizeCall(SizeCall::ONE)); visitor.setResult(_res); break; } case BOTH: { TIType _type(visitor.getGVN(), TIType::DOUBLE, 1, 2); Result & _res = e.getDecorator().setResult(_type); e.getDecorator().setCall(new SizeCall(SizeCall::BOTH)); visitor.setResult(_res); break; } default: return false; } return true; }