#include #include #include #include #include #include #include #include #include #include "lexer.h" #include "parser.h" #include "pretty.h" #include "token.h" #include "string_buffer.h" #include "util.h" #include "symbol.h" #include "error_log.h" #include "code.h" #include "type.h" const char* usage_message = "\n\n" "Usage:\n" "\tbey [-en] [-tr]\n\n" "Global Options:\n" "\t-en\t\tDisplay warning/error messages in english\n" "\t-tr\t\tTürkçe uyarı/hata mesajlarını göster" "\n\n"; enum class Mode_priority { INVALID = -1, SCAN, PRINT_TOKENS, PARSE, PRETTY_PRINT, SYMBOL, SYMBOL_PRINT, TYPE, CODE }; std::unordered_map modes = { {"scan", Mode_priority::SCAN}, {"tokens", Mode_priority::PRINT_TOKENS}, {"parse", Mode_priority::PARSE}, {"pretty", Mode_priority::PRETTY_PRINT}, {"symbol", Mode_priority::SYMBOL}, {"symbol_print", Mode_priority::SYMBOL_PRINT}, {"type", Mode_priority::TYPE}, {"code", Mode_priority::CODE} }; Mode_priority get_mode_priority(const char* mode) { auto it = modes.find(std::string(mode)); if (it != modes.end()) return it->second; return Mode_priority::INVALID; } // Maps (Absolute source file path) -> (AST:File node) String_hash_map ast_map; bool load_language_file(const char* lang_file_name, String_handle bin_directory, String_buffer& buffer) { String_handle lang_file = buffer.push_string(lang_file_name); String_handle full_lang_file = append(bin_directory, lang_file, buffer); return init_lang_file(full_lang_file); } int main(int argc, char* argv[]) { using duration_unit = std::chrono::microseconds; const std::string duration_symbol = "μs"; auto start = std::chrono::high_resolution_clock::now(); String_buffer string_buffer; auto [bin_directory, bey] = split_path(string_buffer.push_string(argv[0]), string_buffer); // Validate & get input if (argc < 3) { fprintf(stderr, "Invalid number of arguments. %s", usage_message); return 1; } const char* lang_file_name = "en.json"; if (argc > 3) { if (strcmp(argv[3], "-tr") == 0) { lang_file_name = "tr.json"; } } if (!load_language_file(lang_file_name, bin_directory, string_buffer)) { fprintf(stderr, "Unable to find language file %s\n", lang_file_name); return 1; } char *mode = argv[1], *root_file = argv[2]; Mode_priority priority; if ((priority = get_mode_priority(mode)) == Mode_priority::INVALID) { fprintf(stderr, "Invalid mode \"%s\"\n %s", mode, usage_message); return 1; } // From the specified root source file specified from the command line, // we split it into directory & filename. We will change the working directory // of the process to this directory since all import statements should be relative // to this main file. String_handle source_file = string_buffer.push_string(root_file); auto [directory, filename] = split_path(std::move(source_file), string_buffer); change_working_dir(directory); // Now we can add the filename (w/ absolute path!) to the queue. std::deque files_to_process; files_to_process.push_back(get_absolute_path(filename, string_buffer)); // Pumping phase 1 Symbol_table* program_table = create_program_table(string_buffer); Lexer lexer(string_buffer); Parser parser; while (!files_to_process.empty()) { String_handle filepath = files_to_process.front(); files_to_process.pop_front(); // Ensure this file has not been previously processed. if (ast_map.exists(filepath)) { continue; } // Scan if (priority < Mode_priority::SCAN) continue; std::vector tokens; Char_stream cs(filepath->data()); if (!lexer.scan_next_file(cs, tokens)) { return 1; } if (priority == Mode_priority::PRINT_TOKENS) { print_tokens(tokens); } // Parse if (priority < Mode_priority::PARSE) continue; Token_stream ts(tokens); if (!parser.parse_next_file(ts, program_table, string_buffer, filepath)) { return 1; } ast_map.put(filepath, parser.current_file); // File discovery: from the import list of the current // file, we add these to the queue of files requiring // processing. for (const auto& h : parser.current_file->imports) { files_to_process.push_back(h); } if (priority == Mode_priority::PRETTY_PRINT) { pretty_print(parser.current_file); } } std::cout << BEY_MAGENTA << ast_map.size() << " file(s) discovered:" << RESET_COLOUR << '\n'; for (const auto& f : ast_map.keys()) { std::cout << '\t' << f->data() << '\n'; } if (priority >= Mode_priority::SYMBOL) { // Link each file scope to any imported scopes for (AST::File* file = parser.head_file; file; file = file->next) { for (const String_handle import : file->imports) { std::optional other = ast_map.get(import); assert(other); file->file_scope->import_scope((*other)->file_scope); } } if (!Symbol_pass_1::pass(parser.head_file)) return 1; if (!Symbol_pass_2::pass(parser.head_file)) return 1; if (!Symbol_pass_3::pass(parser.head_file)) return 1; // Finally, print the symbols to the console if (priority == Mode_priority::SYMBOL_PRINT) { for (const AST::File* f = parser.head_file; f; f = f->next) { std::cout << "~~~~ " << "Filename: " << f->filename->data() << " ~~~~" << "\n\n"; std::cout << Symbol_debug::get_file_string(f) << std::endl; } } } if (priority >= Mode_priority::TYPE) { Type_checker type_checker; for (AST::File* f = parser.head_file; f; f = f->next) { if (!type_checker.type_file(f)) { return 1; } } } if (priority >= Mode_priority::CODE) { // TODO: code generation llvm::LLVMContext llvm_context; Code_generator generator(&llvm_context); } auto stop = std::chrono::high_resolution_clock::now(); auto duration = std::chrono::duration_cast(stop - start); std::cout << '\n' << BEY_GREEN << "Finished compilation in: " << duration.count() << duration_symbol << RESET_COLOUR << std::endl; }