alec

Abstraction Layer for Escape Codes
git clone git://git.dimitrijedobrota.com/alec.git
Log | Files | Refs | README | LICENSE | HACKING | CONTRIBUTING | CODE_OF_CONDUCT | BUILDING
commit398a154e3ad307db53420ee5a2e511721a41fe86
parentaee951d624bef631e5adf2461b8d8b86d0f1b801
authorDimitrije Dobrota <mail@dimitrijedobrota.com>
dateMon, 24 Feb 2025 15:17:23 +0100

Use Cemplate for code generatin

Diffstat:
MCMakeLists.txt|+++++-
Msource/alec.rules.hpp|+-
Msource/generator.cpp|++++++++++++++++++++++++++++++++++++----------------------------------------------

3 files changed, 47 insertions(+), 55 deletions(-)

diff --git a/CMakeLists.txt b/CMakeLists.txt

@@ -4,7 +4,7 @@ include(cmake/prelude.cmake)

project(
alec
VERSION 0.1.15
VERSION 0.1.16
DESCRIPTION "Abstraction Layer for Escape Codes"
HOMEPAGE_URL "git://git.dimitrijedobrota.com/alec.git"
LANGUAGES CXX

@@ -13,6 +13,7 @@ project(

include(cmake/project-is-top-level.cmake)
include(cmake/variables.cmake)
find_package(cemplate 0.1.7 CONFIG REQUIRED)
# ---- Build library ----
set(PARSER_DIR "${CMAKE_CURRENT_BINARY_DIR}/source")

@@ -37,8 +38,11 @@ set_source_files_properties(${PARSER_OUT} PROPERTIES SKIP_LINTING ON)

add_executable(generator "${LEXER_OUT}" "${PARSER_OUT}" source/generator.cpp)
target_include_directories(generator PRIVATE source ${PARSER_DIR})
target_link_libraries(generator PRIVATE cemplate::cemplate)
target_compile_features(generator PUBLIC cxx_std_20)
set(GENERATE_OUT_BIN "${PROJECT_BINARY_DIR}/bin")
set(GENERATE_OUT_INCLUDE "${PROJECT_BINARY_DIR}/include/alec")
file(MAKE_DIRECTORY ${GENERATE_OUT_BIN} ${GENERATE_OUT_INCLUDE})

diff --git a/source/alec.rules.hpp b/source/alec.rules.hpp

@@ -3,7 +3,7 @@

#include <algorithm>
#include <array>
#include <cassert>
#include <cinttypes>
#include <cstdint>
#include <optional>
#include <stdexcept>
#include <string>

diff --git a/source/generator.cpp b/source/generator.cpp

@@ -1,5 +1,4 @@

#include <cstring>
#include <format>
#include <fstream>
#include <iostream>
#include <set>

@@ -8,6 +7,8 @@

#include "generator.h"
#include <cemplate/cemplate.hpp>
#include "driver.hpp"
namespace alec

@@ -22,22 +23,6 @@ extern std::vector<std::string> prologue; // NOLINT

namespace
{
template<typename T>
std::string join(const std::vector<T>& vec, const std::string& delim)
{
std::string res;
if (!vec.empty()) {
res += vec[0];
for (size_t idx = 1; idx < vec.size(); idx++) {
res += delim + vec[idx];
}
}
return res;
}
auto generate_dupes()
{
std::set<std::string> dupes;

@@ -53,20 +38,21 @@ auto generate_dupes()

void generate_variables()
{
using namespace cemplate; // NOLINT
std::cout << "\n/* Template compile-time variables */\n";
std::cout << "\n/* Forward-declare templates */\n";
const auto dupes = generate_dupes();
for (const auto& dup : dupes) {
std::cout << std::format(
"template <auto... val> static const char * const {}_v = \"\";\n", dup);
std::cout << "template <auto... val> static const char * const " << dup
<< "_v = \"\";\n";
}
std::cout << "\n/* Template specialization */\n\n";
for (const auto& record : alec::records) {
if (record.recipe.empty()) {
// comment
std::cout << std::format("{}\n", record.name);
if (record.recipe.empty()) { // comment
std::cout << record.name << '\n';
continue;
}

@@ -77,42 +63,47 @@ void generate_variables()

}
if (!record.args.empty()) {
std::cout << std::format("template <{}>\n", join(record.args, ", "));
std::cout << tmplate(record.args);
}
if (!record.rules.empty()) {
std::vector<std::string> constraints;
for (const auto& param : params) {
for (const auto& rule : record.rules) {
constraints.emplace_back(std::format("{}_v<{}>", rule, param));
}
}
std::cout << std::format("\trequires {}\n", join(constraints, " && "));
std::cout << rquires(accumulate(
params,
" && ",
[&](const auto& param)
{
return accumulate(record.rules,
" && ",
[&](const auto& rule)
{ return tmplate_spec(rule + "_v", param); });
}));
}
std::cout << std::format("static constexpr auto {}_v", record.name);
std::cout << "static constexpr auto " << record.name + "_v";
if (dupes.contains(record.name)) {
std::cout << std::format("<{}>", join(params, ", "));
std::cout << tmplate_spec("", accumulate(params, ", "));
}
std::cout << " = ";
if (!record.recipe.empty() && record.recipe[0][0] == '"') {
std::cout << std::format("\n\t = details::escape_literal<{}>;\n\n",
record.recipe[0]);
std::cout << tmplate_spec("details::escape_literal", record.recipe[0]);
} else {
std::cout << std::format("\n\t = details::escape<{}>;\n\n",
join(record.recipe, ", "));
std::cout << tmplate_spec("details::escape",
accumulate(record.recipe, ", "));
}
std::cout << ";\n\n";
}
}
void generate_functions()
{
using namespace cemplate; // NOLINT
std::cout << "\n/* Run-time functions */\n\n";
for (const auto& record : alec::records) {
if (record.recipe.empty()) {
// comment
std::cout << std::format("{}\n", record.name);
if (record.recipe.empty()) { // comment
std::cout << record.name << '\n';
continue;
}

@@ -122,29 +113,26 @@ void generate_functions()

params.emplace_back(arg.substr(arg.find(' ') + 1));
}
std::cout << std::format("static constexpr auto {}({})\n{{\n",
record.name,
join(record.args, ", "));
std::cout << func(record.name, "static constexpr auto", record.args);
if (!record.rules.empty()) {
for (const auto& param : params) {
std::vector<std::string> constraints;
constraints.reserve(record.rules.size());
for (const auto& rule : record.rules) {
constraints.emplace_back(std::format("{}({})", rule, param));
}
std::cout << std::format("\tassert({});\n", join(constraints, " && "));
std::cout << call_s("assert",
accumulate(record.rules,
" && ",
[&](const std::string& rule)
{ return call(rule, param); }));
}
}
if (record.args.empty()) {
std::cout << std::format("\treturn {}_v;", record.name);
std::cout << ret(record.name + "_v");
} else {
std::cout << std::format("\treturn details::helper::make({});",
join(record.recipe, ", "));
std::cout << ret(
call("details::helper::make", accumulate(record.recipe, ", ")));
}
std::cout << "\n}\n\n";
std::cout << func(record.name);
}
}