bool QueryEvaluator::evaluatePTClause(TNode * PT_node, vector<int> row, vector<vector<int>> * new_rows, ResultTable * temp_result) { TNode * stmt_node = PT_node->getChildAtIndex(0); string stmt_name = stmt_node->getValue(); Symbol stmt_type = SyntaxHelper::getSymbolType(table.getType(stmt_name)); int stmt_index=row[0]; // get stmt_index from row if (stmt_index==-1) { // retrieve a list of values of stmt_type from PKB vector<int> stmt_indexes = getAllPKBValues(stmt_name); for (size_t i=0; i<stmt_indexes.size(); i++) { //save back stmt_indexes[i] to row row[0] = stmt_indexes[i]; //recursive call to update new_rows vector<vector<int>> rows; bool isSatisfied = evaluatePTClause(PT_node, row, &rows, temp_result); if (isSatisfied) { for (size_t j=0; j<rows.size(); j++) { new_rows->push_back(rows[j]); } } } } else { // from here is hell of logic // get ASTNode of this Stmt TNode * root = PKB::getASTRoot(); AST tree; tree.setRoot(root); TNode * ast_node = tree.findNodeOfStmt(stmt_index); // handle first argument node TNode * arg1_node = stmt_node->getChildAtIndex(0); if (!evaluatePTArgNode(arg1_node, ast_node, ARG1, row, new_rows)) return false; switch(stmt_type) { case Assign: { TNode * expr_node = stmt_node->getChildAtIndex(1); if (!evaluateExprNode(expr_node, ast_node)) return false; return true; } case While: { break; } case If: { break; } default: break; } } if (!new_rows->empty()) return true; return false; }
/// Read-Eval-Print-Loop static void repl(CEnv& cenv, ExecutionEngine* engine) { while (1) { std::cout << "> "; std::cout.flush(); SExp exp = readExpression(std::cin); try { AST* ast = parseExpression(exp); if (ast->evaluatable()) { ASTPrototype* proto = new ASTPrototype(false, "", vector<string>()); ASTFunction* func = new ASTFunction(proto, ast); Function* code = func->Funcgen(cenv); void* fp = engine->getPointerToFunction(code); double (*f)() = (double (*)())fp; std::cout << f() << endl; } else { Value* code = ast->Codegen(cenv); std::cout << "Generated code:" << endl; code->dump(); } } catch (SyntaxError e) { std::cerr << "Syntax error: " << e.what() << endl; } } }
int __etest(const char *program) { FILE *f = fopen("/tmp/tmp", "w"); if (f == NULL) { //fprintf(stderr, "open fail %s (%s)\n", strerror(errno), argv[1]); exit(-1); } fwrite(program, 1, strlen(program), f); fclose(f); SCParser parser; AST *ast = parser.parse("/tmp/tmp"); assert(ast); DBG("%s", ast->toString().c_str()); DBG("\n"); DBG("%s", ast->toSource().c_str()); TypeCheck typeCheck; ast->accept(&typeCheck); DBG("%s\n", SymbolTable.toString().c_str()); int err = typeCheck.getLastError(); return err; }
void DepGenerator::analyse(const AST& ast) { const string& modName = ast.getModuleName(); const string& fileName = ast.getFileName(); ModInfo* info = getInfo(modName); info->addFile(fileName, ast); }
int main() { AST *ast = new ASTree(); ast->ShowTree(); //ast.GetCurrentElement() }
AST* ASTHelper::retrieveMethodAST( IPosition<SourceToken>& p ) { AST* ast = this->ast.copySubtree( p ); ast->storeIndent(); return ast; }
void testFile(const char *file) { SCParser parser; AST *ast = parser.parse(file); if (ast) { DBG("%s", ast->toString().c_str()); DBG("\n"); DBG("%s", ast->toSource().c_str()); } }
int main () { AST* id = new ID_NODE("may_var"); AST* val = new VAL_NODE(5.5); AST* opr = new OPR_NODE('+', id, val); opr->process(); return 0; }
void MittenSource::onNode(AST &a, ASTBuilder &b, ErrorHandler &e, StructureParser &p) { MittenErrorHandler &meh = dynamic_cast<MittenErrorHandler &>(e); if (a.isBranch() && a.name().compare("line") == 0) { cout << "LINE: " << a.display() << "\n"; if (a.size() == 2) { if (a[0].isLeaf() && a[0].leaf().value().compare("include") == 0) { if (a[1].isBranch()) { if (a[1].size() == 1) { if (a[1][0].size() == 1) { if (a[1][0][0].isLeaf()) { Token inc = a[1][0][0].leaf(); if (inc.tag() == SymbolTag) cout << "INCLUDE MODULE '" << inc.value() << "'\n"; else if (inc.tag() == StringLiteralTag) cout << "INCLUDE FILE '" << inc.value() << "'\n"; else meh.includeRequiresModuleOrFileName(a[0].leaf()); } else { meh.includeRequiresModuleOrFileName(a[0].leaf()); } } else { meh.includeRequiresOneArgument(a[0].leaf()); } } else { meh.includeRequiresOneArgument(a[0].leaf()); } } else { meh.includeRequiresArgumentList(a[0].leaf()); } } } } }
int Calculator::eval(string expr, bool flag) { Parser* parser = new Parser(new istringstream(expr), flag); AST* tree = parser->parse(); int result = tree->evaluate(); delete tree; delete parser; return result; }
void testFile(const char *file) { SCParser parser; AST *ast = parser.parse(file); if (ast) { DBG("%s", ast->toString().c_str()); DBG("\n"); DBG("%s", ast->toSource().c_str()); } TypeCheck typeCheck; ast->accept(&typeCheck); //int err = typeCheck.getLastError(); }
size_t CFG::_varcnt_(void) { size_t cnt = 0; for (ssize_t i = 0; i < this->length(); ++i) { AST *child = (AST *)this->child(i); switch(child->type()) { case AST_ASSIGN: if (0 != child->length() && 0 == child->child(0)->length()) { cnt ++; } break; case AST_FUNC: if (0 != child->length() && 0 != child->child(0)->length()) { cnt += child->child(0)->child(0)->length(); } break; default: _D(LOG_DEBUG, "Need NOT count on %s", child->data().c_str()); break; } } cnt += (NULL == this->nextCFG(true) ? 0 : this->nextCFG(true)->_varcnt_()); cnt += (NULL == this->nextCFG(false) ? 0 : this->nextCFG(false)->_varcnt_()); return cnt; }
void scopeOfNode( AST* ast, QStringList& scope ) { if( !ast ) return; if( ast->parent() ) scopeOfNode( ast->parent(), scope ); QString s; switch( ast->nodeType() ) { case NodeType_ClassSpecifier: if( ((ClassSpecifierAST*)ast)->name() ){ s = ((ClassSpecifierAST*)ast)->name()->text(); s = s.isEmpty() ? QString::fromLatin1("<unnamed>") : s; scope.push_back( s ); } break; case NodeType_Namespace: { AST* namespaceName = ((NamespaceAST*)ast)->namespaceName(); s = namespaceName ? namespaceName->text() : QString::fromLatin1("<unnamed>"); scope.push_back( s ); } break; case NodeType_FunctionDefinition: { FunctionDefinitionAST* funDef = static_cast<FunctionDefinitionAST*>( ast ); DeclaratorAST* d = funDef->initDeclarator()->declarator(); // hotfix for bug #68726 if ( !d->declaratorId() ) break; QList<ClassOrNamespaceNameAST*> l = d->declaratorId()->classOrNamespaceNameList(); for( int i = 0; i < l.size(); ++i ) { AST* name = l.at(i)->name(); scope.push_back( name->text() ); } } break; default: break; } }
int main() { Parser parser; parser.parse(); AST ast = parser.ast(); if (ast.printErrors(std::cerr)) return -1; int code = SymbolResolver::resolve(ast, std::cerr); if (code) return code; PrintVisitor::print(std::cerr, ast); PrintCode::print(std::cout, ast, true); }
C2Sema::C2Sema(SourceManager& sm_, DiagnosticsEngine& Diags_, AST& ast_, clang::Preprocessor& PP_) : SourceMgr(sm_) , Diags(Diags_) , typeContext(ast_.getTypeContext()) , ast(ast_) , PP(PP_) {}
bool C2Builder::checkModuleImports(ParseHelper& helper, Component* component, Module* module, ImportsQueue& queue, const LibInfo* lib) { if (!module->isLoaded()) { assert(lib); if (options.verbose) log(COL_VERBOSE, "parsing (%s) %s", component->getName().c_str(), lib->c2file.c_str()); if (!helper.parse(*component, module, lib->c2file, (options.printAST0 && options.printASTLib))) { return false; } } if (options.verbose) log(COL_VERBOSE, "checking imports for module (%s) %s", component->getName().c_str(), module->getName().c_str()); bool ok = true; const AstList& files = module->getFiles(); for (unsigned a=0; a<files.size(); a++) { AST* ast = files[a]; for (unsigned u=1; u<ast->numImports(); u++) { // NOTE: first import is module decl ImportDecl* D = ast->getImport(u); const std::string& targetModuleName = D->getModuleName(); // handle c2 pseudo-module if (targetModuleName == "c2") { createC2Module(); D->setModule(c2Mod); continue; } const LibInfo* target = libLoader.findModuleLib(targetModuleName); if (!target) { helper.Diags.Report(D->getLocation(), clang::diag::err_unknown_module) << targetModuleName; ok = false; continue; } D->setModule(target->module); if (target->component != component) { // check that imports are in directly dependent component (no indirect component) if (!component->hasDep(target->component)) { helper.Diags.Report(D->getLocation(), clang::diag::err_indirect_component) << component->getName() << target->component->getName() << targetModuleName; ok = false; continue; } } if (target->module->isLoaded()) continue; queue.push_back(targetModuleName); } } return ok; }
QList<CppQuickFixOperation::Ptr> CompleteSwitchCaseStatement::match( const QSharedPointer<const CppEditor::Internal::CppQuickFixAssistInterface> &interface) { const QList<AST *> &path = interface->path(); if (path.isEmpty()) return noResult(); // nothing to do // look for switch statement for (int depth = path.size() - 1; depth >= 0; --depth) { AST *ast = path.at(depth); SwitchStatementAST *switchStatement = ast->asSwitchStatement(); if (switchStatement) { if (!interface->isCursorOn(switchStatement->switch_token) || !switchStatement->statement) return noResult(); CompoundStatementAST *compoundStatement = switchStatement->statement->asCompoundStatement(); if (!compoundStatement) // we ignore pathologic case "switch (t) case A: ;" return noResult(); // look if the condition's type is an enum if (Enum *e = conditionEnum(interface, switchStatement)) { // check the possible enum values QStringList values; Overview prettyPrint; for (unsigned i = 0; i < e->memberCount(); ++i) { if (Declaration *decl = e->memberAt(i)->asDeclaration()) { values << prettyPrint(LookupContext::fullyQualifiedName(decl)); } } // Get the used values Block *block = switchStatement->symbol; CaseStatementCollector caseValues(interface->semanticInfo().doc, interface->snapshot(), interface->semanticInfo().doc->scopeAt(block->line(), block->column())); QStringList usedValues = caseValues(switchStatement); // save the values that would be added foreach (const QString &usedValue, usedValues) values.removeAll(usedValue); if (values.isEmpty()) return noResult(); else return singleResult(new Operation(interface, depth, compoundStatement, values)); } return noResult(); } }
template <typename T> T* BuildASTVisitor::stackPop() { if( aststack.isEmpty() ) { kDebug(9024) << kBacktrace(); kFatal(9024) << "ERROR: AST stack is empty, this should never happen"; exit(255); } AST* tmp = aststack.pop(); T* ast = dynamic_cast<T*>(tmp); if( !ast ) { kDebug(9024) << kBacktrace(); kFatal(9024) << "ERROR: AST stack is screwed, doing a hard exit" << tmp->type(); exit(255); } return ast; }
PKB Parser::parseSource( string source ) { trim(source); addNewLineString(source); list<std::pair<int, string>> sourceCodeList; buildSourceCodeList(source, sourceCodeList); processSourceCodeList(sourceCodeList); cout << "end of everything before ast." << endl; AST ast = AST(); ast.acceptStatements(sourceCodeList); pkb.setAST(ast); return pkb; }
Value* ASTIf::Codegen(CEnv& cenv) { Value* condV = _cond->Codegen(cenv); // Convert condition to a bool by comparing equal to 0.0. condV = cenv.builder.CreateFCmpONE( condV, ConstantFP::get(APFloat(0.0)), "ifcond"); Function* parent = cenv.builder.GetInsertBlock()->getParent(); // Create blocks for the then and else cases. // Insert the 'then' block at the end of the function. BasicBlock* thenBB = BasicBlock::Create("then", parent); BasicBlock* elseBB = BasicBlock::Create("else"); BasicBlock* mergeBB = BasicBlock::Create("ifcont"); cenv.builder.CreateCondBr(condV, thenBB, elseBB); // Emit then value. cenv.builder.SetInsertPoint(thenBB); Value* thenV = _then->Codegen(cenv); cenv.builder.CreateBr(mergeBB); // Codegen of 'Then' can change the current block, update thenBB thenBB = cenv.builder.GetInsertBlock(); // Emit else block. parent->getBasicBlockList().push_back(elseBB); cenv.builder.SetInsertPoint(elseBB); Value* elseV = _else->Codegen(cenv); cenv.builder.CreateBr(mergeBB); // Codegen of 'Else' can change the current block, update elseBB elseBB = cenv.builder.GetInsertBlock(); // Emit merge block. parent->getBasicBlockList().push_back(mergeBB); cenv.builder.SetInsertPoint(mergeBB); PHINode* pn = cenv.builder.CreatePHI(Type::DoubleTy, "iftmp"); pn->addIncoming(thenV, thenBB); pn->addIncoming(elseV, elseBB); return pn; }
void ParserTest::testMultipleProcedures() { Parser p; std::string src; src = "procedure main{\n" " a = a + 2;}\n" "procedure text1{\n" " b = a * (2 + c);\n" " c = c - 2;}" "procedure text2{\n" " while a{\n" " d = d - 2;}\n" " e = e + 1;\n" " if a then {\n" " h = h * (a * b);\n" " b = b + 1;}\n" " else{\n" " c = b;\n" " while z{\n" " abc = xyz;\n" " abc1 = xyz2 * xyz + h - y;}\n" " a=abc1*2;}}"; p.setSource(src); CPPUNIT_ASSERT_EQUAL(1, p.startParse()); PKB *pkb = p.getPKB(); // AST Test AST *ast = pkb->getRootAST(); CPPUNIT_ASSERT(pkb->getType(ast->getRightSibling()) == PROCEDURE); CPPUNIT_ASSERT(pkb->getType(ast->getRightSibling()->getRightSibling()) == PROCEDURE); CPPUNIT_ASSERT(pkb->getType(ast->getRightSibling()->getRightSibling()->getFirstDescendant()->getFirstDescendant()) == WHILE); // Parent Test to ensure insertion is correct. CPPUNIT_ASSERT(!pkb->isParent(1, 9)); CPPUNIT_ASSERT(pkb->isParent(4, 5)); // Follow Test CPPUNIT_ASSERT(!pkb->isFollows(1, 2)); CPPUNIT_ASSERT(!pkb->isFollows(3, 4)); CPPUNIT_ASSERT(pkb->isFollows(4, 6)); }
CodeGen hex(AST &ast){ CodeGen cg; cg.generate(ast.get_root()); cg.back_patch(); cg.fill(); // cg.print_hex(); // cg.print_tables(); return cg; }
void ASTTest::testAcrossMethods() { AST* asd = (AST::getInstance()); CPPUNIT_ASSERT(asd->contains("Alice")); CPPUNIT_ASSERT(asd->contains("Bob")); ProcNode* pget = asd->getProcNode("Bob"); CPPUNIT_ASSERT(NULL != pget); string expname = "Bob"; CPPUNIT_ASSERT_EQUAL(expname, pget->getName()); //CPPUNIT_ASSERT_EQUAL(pn, pget); StmtLstNode* sget = pget->getStmtLstNode(); //CPPUNIT_ASSERT_EQUAL(sln, sget); string sname = "then"; CPPUNIT_ASSERT_EQUAL(sname, sget->getName()); return; }
void ASTTest::testInstances() { CPPUNIT_ASSERT(dynamic_cast<AST*>(ast)); AST* asd = AST::getInstance(); AST* qwe = AST::getInstance(); CPPUNIT_ASSERT(asd->contains("Alice")); CPPUNIT_ASSERT(qwe->contains("Alice")); ProcNode* pn = new ProcNode("Bob"); StmtLstNode* sln = new StmtLstNode("then"); pn->linkStmtLstNode(sln); asd->addProcNode(pn); ProcNode* pget = asd->getProcNode("Bob"); CPPUNIT_ASSERT(NULL != pget); string expname = "Bob"; CPPUNIT_ASSERT_EQUAL(expname, pget->getName()); CPPUNIT_ASSERT_EQUAL(pn, pget); StmtLstNode* sget = pget->getStmtLstNode(); CPPUNIT_ASSERT_EQUAL(sln, sget); string sname = "then"; CPPUNIT_ASSERT_EQUAL(sname, sget->getName()); return; }
void P::parse_action(ASTBase **_root,int *_retsignal ) { zzRULE; int _signal=NoSignal; *_retsignal = NoSignal; loop_clause_nest_level = 0; *_root = new AST(TOK_STATEMENTS); tracein("action"); while ( 1 ) { statement( _root, &_signal ); _signal = NoSignal; if ( LA(1) == Eof ) break; } ASTBase::tmake( NULL, (*_root)->bottom(), (new AST(Eof)) , NULL); if ( dumpflag && (*_root) ) { ((AST *)(*_root))->dumpTree("\nAST tree", ascii_buffer); printf("--------------------------------------------------\n"); if (relocflag) { printf("Relocatable ASTs:\n"); AST *look = ttr->getItemHead(); while (look) { look->dumpNode(" "); look = look->getItemNext(); } printf("--------------------------------------------------\n"); } } traceout("action"); return; }
AST* Parser::parse_case_branch(void) { AST* res = new AST(); res->kind = AST_CASE_BRANCH; // Patron AST* pattern = parse_expression(); if (!is_pattern(pattern)) { cerr << "Error en el case:" << endl; pattern->show(cerr, 1); cerr << endl; cerr << "no es un patron." << endl; exit(1); } res->children.push_back(pattern); assert_type(TOK_FAT_ARROW); _tokenizer.next(); // Resultado res->children.push_back(parse_expression()); return res; }
// parent is either a FunctionDefinitionAST or a SimpleDeclarationAST // line and column are 1-based static bool findDeclOrDef(const Document::Ptr &doc, int line, int column, DeclarationAST **parent, DeclaratorAST **decl, FunctionDeclaratorAST **funcDecl) { QList<AST *> path = ASTPath(doc)(line, column); // for function definitions, simply scan for FunctionDefinitionAST not preceded // by CompoundStatement/CtorInitializer // for function declarations, look for SimpleDeclarations with a single Declarator // with a FunctionDeclarator postfix FunctionDefinitionAST *funcDef = 0; SimpleDeclarationAST *simpleDecl = 0; *decl = 0; for (int i = path.size() - 1; i > 0; --i) { AST *ast = path.at(i); if (ast->asCompoundStatement() || ast->asCtorInitializer()) break; if ((funcDef = ast->asFunctionDefinition()) != 0) { *parent = funcDef; *decl = funcDef->declarator; break; } if ((simpleDecl = ast->asSimpleDeclaration()) != 0) { *parent = simpleDecl; if (!simpleDecl->declarator_list || !simpleDecl->declarator_list->value) break; *decl = simpleDecl->declarator_list->value; break; } } if (!*parent || !*decl) return false; if (!(*decl)->postfix_declarator_list || !(*decl)->postfix_declarator_list->value) return false; *funcDecl = (*decl)->postfix_declarator_list->value->asFunctionDeclarator(); return *funcDecl; }
void Error::complain(const AST &node, const char *fmt, ...) { char buf[255] = { 0 }; va_list list; // get compile source file path and name LocationMgr *locationMgr = getLocationMgr(); string sourcePath = locationMgr->getCompileSourcePath(); string sourceFile = locationMgr->getCompileSourceFile(); int lineno = node.getLocation().getLineno(); va_start(list, fmt); vsprintf(buf, fmt, list); std::cout << sourcePath << "/" << sourceFile << ":" << lineno << ":" << buf << std::endl; va_end(list); }
void TagWriter::analyse(const AST& ast) { currentFile = getFile(ast.getFileName()); for (unsigned i=0; i<ast.numTypes(); i++) { TagVisitor visitor(*this, ast.getType(i), SM); visitor.run(); } for (unsigned i=0; i<ast.numVars(); i++) { TagVisitor visitor(*this, ast.getVar(i), SM); visitor.run(); } for (unsigned i=0; i<ast.numFunctions(); i++) { TagVisitor visitor(*this, ast.getFunction(i), SM); visitor.run(); } // TODO TypeDecls ArrayValueDecls }
void DepGenerator::writeAST(const AST& ast, StringBuilder& output, unsigned indent) const { if (showExternals) { for (unsigned i=0; i<ast.numImports(); i++) { const ImportDecl* U = ast.getImport(i); QualType Q = U->getType(); const ModuleType* T = cast<ModuleType>(Q.getTypePtr()); const Module* P = T->getModule(); assert(P); if (P->isExternal()) addExternal(P); } } for (unsigned i=0; i<ast.numTypes(); i++) { writeDecl(ast.getType(i), output, indent); } for (unsigned i=0; i<ast.numVars(); i++) { writeDecl(ast.getVar(i), output, indent); } for (unsigned i=0; i<ast.numFunctions(); i++) { writeDecl(ast.getFunction(i), output, indent); } }