void stackOutput() { vector<const void *> stack; stackDump(&stack); vector<pair<string, string> > tokens; if(FLAGS_addr2line) { string line = "addr2line -f -e " + exeName() + " "; for(int i = 0; i < stack.size(); i++) line += Format("%08x ", (unsigned int)stack[i]); line += "> addr2linetmp.txt"; int rv = system(line.c_str()); if(!rv) { { ifstream ifs("addr2linetmp.txt"); string lin; while(getline(ifs, lin)) { string tlin; getline(ifs, tlin); tokens.push_back(make_pair(lin, tlin)); } } unlink("addr2linetmp.txt"); } else { dprintf("Couldn't call addr2line\n"); return; } { string line = "c++filt -n -s gnu-v3 "; for(int i = 0; i < tokens.size(); i++) line += tokens[i].first + " "; line += "> cppfilttmp.txt"; int rv = system(line.c_str()); if(!rv) { { ifstream ifs("cppfilttmp.txt"); string lin; int ct = 0; while(getline(ifs, lin)) { if(lin.size() && lin[0] == '_') lin.erase(lin.begin()); dprintf(" %s - %s", tokens[ct].second.c_str(), lin.c_str()); ct++; } } unlink("cppfilttmp.txt"); } else { dprintf("Couldn't call c++filt\n"); return; } } } else { for(int i = 0; i < stack.size(); i++) dprintf(" %08x", (unsigned int)stack[i]); } dprintf("\n"); }
int main(int argc, const char* argv[]) { std::string exeName("TEBNFCodeGenerator"); if(argc < 4) { if(1 == argc) { std::string strPath(argv[0]); auto pos = strPath.find_last_of("/\\"); exeName = std::string::npos != pos ? strPath.substr(pos + 1) : strPath; } std::cout << "Usage: " << exeName << " <source> <destination> <name>\n" << "Arguments:\n" << " source - Path of file containing TEBNF grammar, including file name.\n" << " destination - Path of the location on disk to write generated files.\n" << " name - Name to give to the generated application.\n"; } else { try { std::string srcFilePath(argv[1]); std::string destDirPath(argv[2]); std::string appName(argv[3]); Utils::Logger::setup(srcFilePath); //Setup static logger. Utils::Logger::log("\n--------- TEBNF Code Generator v" + Utils::getTEBNFVersion() + " ---------\n"); Reader::read(srcFilePath); Scanner::scan(Reader::getFileText()); Parser::parse(); Generator::generate(destDirPath, appName); return EXIT_SUCCESS; } catch(std::exception& ex) { std::cout << std::string(ex.what()) << std::endl; } } return EXIT_FAILURE; }
int compile(int debug, int printSource, int printAssembly, int optimisation, char *fname) { wchar_t *InputBuf; struct TokenStruct *Token; struct ContextStruct Context; int Result; /* Load the inputfile into memory. */ InputBuf = LoadInputFile(fname); if (InputBuf == NULL) exit(1); if(printSource) printf("Input MAlice program:\n-- %s --\n%ls---\n\n",fname,InputBuf); /* Run the Parser. */ Result = Parse(InputBuf,wcslen(InputBuf),TRIMREDUCTIONS,DEBUG,&Token); /* Interpret the results. */ if (Result != PARSEACCEPT) { ShowErrorMessage(Token,Result); printf("\n[EXIT] Syntax Error\n"); return 255; } else { /* Initialize the Context. */ Context.Debug = DEBUG; Context.Indent = 0; Context.ReturnValue = NULL; /* Start execution by calling the subroutine of the first Token on the TokenStack. It's the "Start Symbol" that is defined in the grammar. */ RuleJumpTable[Token->ReductionRule](Token,&Context); } //printTree(Token,0); int error = debug; // Used as debug flag and error reporting during CFG gen CFG * cfg = makeCFG(Token, optimisation, &error); if(error || cfg == 0) { printf("\n[EXIT] Compilation Error\n"); return 255; } char* asmfname; asmfname = asmName(fname); genCode(cfg, asmfname); if(printAssembly) { printf("Generated assembly code:\n-- %s --\n",asmfname); printFile(asmfname); printf("---\n\n"); } free(asmfname); char* exefname; exefname = exeName(fname); char fc[128]; char sc[128]; sprintf(fc ,"nasm -f elf32 %s.s -o %s.o", exefname, exefname); sprintf(sc ,"gcc -m32 %s.o -o %s", exefname, exefname); char * firstCommand = (char *)malloc(sizeof(char) * strlen(fc)); char * secondCommand = (char *)malloc(sizeof(char) * strlen(sc)); strcpy(firstCommand, fc); strcpy(secondCommand, sc); system(firstCommand); system(secondCommand); /* Cleanup. */ DeleteTokens(Token); free(InputBuf); return 0; }