alec

Abstraction Layer for Escape Codes

git clone git://git.dimitrijedobrota.com/alec.git

generator.cpp (4354B)

1 #include <cstring> 2 #include <fstream> 3 #include <iostream> 4 #include <set> 5 #include <span> 6 #include <string> 7 #include <vector> 8 9 #include "generator.h" 10 11 #include <cemplate/cemplate.hpp> 12 13 #include "driver.hpp" 14 15 namespace alec 16 { 17 18 extern std::vector<record> records; // NOLINT 19 extern std::vector<std::string> epilogue; // NOLINT 20 extern std::vector<std::string> prologue; // NOLINT 21 22 } // namespace alec 23 24 namespace 25 { 26 27 auto generate_dupes() 28 { 29 std::set<std::string> dupes; 30 std::set<std::string> seen; 31 for (const auto& record : alec::records) { 32 const auto [_, inserted] = seen.insert(record.name); 33 if (!inserted) { 34 dupes.insert(record.name); 35 } 36 } 37 return dupes; 38 } 39 40 void generate_variables() 41 { 42 using namespace cemplate; // NOLINT 43 44 Program prog(std::cout); 45 46 prog.comment("Template compile-time variables\n"); 47 prog.comment("Forward-declare templates\n"); 48 49 const auto dupes = generate_dupes(); 50 for (const auto& dup : dupes) { 51 prog.template_decl({"auto... val"}); 52 prog.declaration("static const char* const", dup + "_v", string("")); 53 prog.line_empty(); 54 } 55 56 prog.comment("Template specializations\n"); 57 for (const auto& record : alec::records) { 58 if (record.recipe.empty()) { // comment 59 std::cout << record.name << '\n'; 60 continue; 61 } 62 63 std::vector<std::string> params; 64 params.reserve(record.args.size()); 65 for (const auto& arg : record.args) { 66 params.emplace_back(arg.substr(arg.find(' ') + 1)); 67 } 68 69 if (!record.args.empty()) { 70 prog.template_decl(record.args); 71 } 72 73 if (!record.rules.empty()) { 74 prog.require(join(std::begin(params), 75 std::end(params), 76 " && ", 77 [&](const auto& param) 78 { 79 return join( 80 std::begin(record.rules), 81 std::end(record.rules), 82 " && ", 83 [&](const auto& rule) 84 { return template_def(rule + "_v", {param}); }); 85 })); 86 } 87 88 const auto var = record.name + "_v"; 89 90 const auto type = 91 dupes.contains(record.name) ? template_def(var, params) : var; 92 93 const auto* temp = !record.recipe.empty() && record.recipe[0][0] == '"' 94 ? "details::escape_literal" 95 : "details::escape"; 96 97 prog.declaration( 98 "static constexpr auto", type, template_def(temp, record.recipe)); 99 100 prog.line_empty(); 101 } 102 } 103 104 void generate_functions() 105 { 106 using namespace cemplate; // NOLINT 107 108 Program prog(std::cout); 109 110 prog.comment("Run-time functions\n"); 111 for (const auto& record : alec::records) { 112 if (record.recipe.empty()) { // comment 113 std::cout << record.name << '\n'; 114 continue; 115 } 116 117 std::vector<std::string> params; 118 params.reserve(record.args.size()); 119 for (const auto& arg : record.args) { 120 params.emplace_back(arg.substr(arg.find(' ') + 1)); 121 } 122 123 prog.function_open(record.name, "static constexpr auto", record.args); 124 125 if (!record.rules.empty()) { 126 for (const auto& param : params) { 127 prog.call( 128 "assert", 129 join(std::begin(record.rules), 130 std::end(record.rules), 131 " && ", 132 [&](const std::string& rule) { return call(rule, {param}); })); 133 } 134 } 135 136 if (record.args.empty()) { 137 prog.ret(record.name + "_v"); 138 } else { 139 prog.ret(call("details::helper::make", record.recipe)); 140 } 141 142 prog.function_close(record.name); 143 } 144 } 145 146 } // namespace 147 148 int main(int argc, char* argv[]) 149 { 150 const std::span args(argv, static_cast<std::size_t>(argc)); 151 152 const bool debug = argc > 1 && std::strcmp(args[1], "--debug") == 0; 153 std::ifstream ifile; 154 if (argc != 1) { 155 ifile.open(args[!debug ? 1 : 2]); 156 } 157 158 using namespace alec; // NOLINT 159 160 driver drv = argc == 1 ? driver(std::cin, debug) : driver(ifile, debug); 161 parser parser(drv, debug); 162 const int res = parser(); 163 164 if (res != 0) { 165 std::cerr << "Parser error"; 166 return -1; 167 } 168 169 // print prologue section 170 for (const auto& line : prologue) { 171 std::cout << line; 172 } 173 174 generate_variables(); 175 generate_functions(); 176 177 // print epilogue section 178 for (const auto& line : epilogue) { 179 std::cout << line; 180 } 181 }