int main(){ printf("******* INTIATING COMPILER ***********\n"); //printf("Choose Relevant stage of compiler:\n"); //printf("1. Lexical Analysis\n"); //printf("2. Parsing\n"); //printf("3. Semantic Analysis\n"); //printf("4. Code Generation\n"); int choice,i; char c; if(1){ hashTable* T = build_hash(); // build the hash table to maintain state of tokens printStoreHash(T); // store hashTable in a file Dnode* DFA = buildDFA(); memset(LexicalUnits,'\0',sizeof(LexicalUnits)); lexerCode(DFA,T,LexicalUnits,tokenValue,line); printf("\nLexer tokens have been generated in Lexer Tokens.txt\n"); pnode* root=NULL; root=parse(LexicalUnits,tokenValue,line); printf("\nParse tree generated in parseTree.txt\n"); pnode* ast=getAST(root); printf("\nAbstarct Syntax Tree Generated in AbstractSyntaxTree.txt\n"); Master *sym = (Master*)malloc(sizeof (Master)); getSymbolTable(sym,ast); printf("\nSymbol Table Generated in symbolTable.txt\n"); GenerateCode(sym,ast); printf("\nCode Generation Successfull\n\n"); } return 0; }
void run_code(const char* code) { NExpression* root_expr = getAST(code); if (root_expr == NULL) { std::cout << "Root expression was null! Ahhhhhhhhhhhhh!" << std::endl; return; } std::string error_str; llvm::Module* module = new llvm::Module("top", llvm::getGlobalContext()); llvm::ExecutionEngine* execution_engine = llvm::EngineBuilder(module).setErrorStr(&error_str).setEngineKind(llvm::EngineKind::JIT).create(); CodeGen code_gen(module); std::cout << "execution engine " << execution_engine << std::endl; if (execution_engine == NULL) { std::cout << "Unable to create execution engine." << std::endl; return; } NFunction main_fn(root_expr, NType::int_ty()); // llvm::Value* root_val = root_expr->gen_code(&code_gen); // std::cout << "Root val code:" << std::endl; // root_val->dump(); llvm::Function* main_fn_val = (llvm::Function*) main_fn.gen_code(&code_gen); std::cout << "Main fn code:" << std::endl; main_fn_val->dump(); void* fn_ptr = execution_engine->getPointerToFunction(main_fn_val); int32_t (*fn_ptr_native)() = (int32_t (*)()) fn_ptr; int32_t ret = fn_ptr_native(); std::cout << "Main fn at " << fn_ptr << "; executed: " << ret << std::endl; }
void MallocState::print(llvm::raw_ostream &Out, seec::util::IndentationGuide &Indentation) const { std::string AddressString; { llvm::raw_string_ostream AddressStringStream(AddressString); seec::util::write_hex_padded(AddressStringStream, this->getAddress()); } auto const LazyDescription = seec::LazyMessageByRef::create("SeeCClang", {"states", "MallocState"}, std::make_pair("size", int64_t(this->getSize())), std::make_pair("address", AddressString.c_str())); UErrorCode ICUStatus = U_ZERO_ERROR; auto const Description = LazyDescription->get(ICUStatus, Locale()); if (U_FAILURE(ICUStatus)) return; Out << Indentation.getString() << Description << "\n"; auto const Mapping = this->getAllocatorInstMapping(); if (auto const Stmt = Mapping.getStmt()) { Indentation.indent(); auto const &AST = Mapping.getAST()->getASTUnit(); auto const &SrcManager = AST.getSourceManager(); auto const LocStart = Stmt->getLocStart(); auto const Filename = SrcManager.getFilename(LocStart); auto const Line = SrcManager.getSpellingLineNumber(LocStart); auto const Column = SrcManager.getSpellingColumnNumber(LocStart); auto const LazyLocation = seec::LazyMessageByRef::create("SeeCClang", {"states", "MallocStateAllocatedAt"}, std::make_pair("filename", Filename.str().c_str()), std::make_pair("line", int64_t(Line)), std::make_pair("column", int64_t(Column))); auto const Location = LazyLocation->get(ICUStatus, Locale()); if (U_SUCCESS(ICUStatus)) Out << Indentation.getString() << Location << "\n"; Indentation.unindent(); } }
int main (int argc, char** argv) { while (gets (in)) { ltl_formula *formula = getAST(in); print_formula(formula); puts(""); destroy_formula(formula); } return (EXIT_SUCCESS); }
int main(void) { std::string str; getFileContents(str, "test.d"); // yydebug = 1; ModuleNode* e; e = getAST(str.c_str()); if (!e) { std::cerr << "MainError" << std::endl; exit(1); } std::cout << *e << std::endl; return 0; }