alec

Abstraction Layer for Escape Codes

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

commit	52dc5de05fbb271b2d50973f71c58114e2d363ce
parent	6afe33840c7ae7d9a1c1a6fc265d9b962fafb7e7
author	Dimitrije Dobrota <mail@dimitrijedobrota.com>
date	Thu, 30 Jan 2025 20:16:56 +0100

Revrite lexer, parser and generator in CPP

Diffstat:

M	.clang-tidy	\|	++++++-
M	CMakeLists.txt	\|	+++++++++++-------
M	example/alec_compile.cpp	\|	+++---
M	example/alec_runtime.cpp	\|	++++---
M	source/alec.rules.hpp	\|	+++++++++++++++++++++++++++++------------------------------
A	source/driver.hpp	\|	++++++++++++++++++++++++++++++++++++++
D	source/generator.c	\|	---------------------------------------------------------------------------------
A	source/generator.cpp	\|	+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
M	source/generator.h	\|	+++++++++++++------------------------------------------------
M	source/lexer.l	\|	++++++++++++++++++++++++++++++++++++++++++++++++++++++++++-----------------
A	source/location.hpp	\|	++++++++++++++++++
M	source/parser.y	\|	+++++++++++++++++++++++++++++++++++++++++++++++++++++++---------------------------

12 files changed, 404 insertions(+), 407 deletions(-)

diff --git a/.clang-tidy b/.clang-tidy

@@ -5,14 +5,19 @@

Checks: "*,\

-google-readability-todo,\

-altera-*,\

-cppcoreguidelines-avoid-magic-numbers,\

-fuchsia-*,\

fuchsia-multiple-inheritance,\

-llvm-header-guard,\

-llvm-include-order,\

-llvmlibc-*,\

-modernize-use-nodiscard,\

-misc-non-private-member-variables-in-classes"

-modernize-use-trailing-return-type,\

-misc-non-private-member-variables-in-classes,

-readability-magic-numbers

WarningsAsErrors: ''

ExcludeHeaderFilterRegex: 'parser.hpp'

CheckOptions:

- key: 'bugprone-argument-comment.StrictMode'

value: 'true'

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

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

project(

alec

VERSION 0.1.9

VERSION 0.1.10

DESCRIPTION "Abstraction Layer for Escape Codes"

HOMEPAGE_URL "git://git.dimitrijedobrota.com/alec.git"

LANGUAGES C CXX

LANGUAGES CXX

)

include(cmake/project-is-top-level.cmake)

@@ -21,19 +21,23 @@ file(MAKE_DIRECTORY ${PARSER_DIR})

find_package(FLEX)

find_package(BISON)

set(LEXER_OUT "${PARSER_DIR}/lexer.c")

set(PARSER_OUT "${PARSER_DIR}/parser.c")

set(LEXER_OUT "${PARSER_DIR}/lexer.cpp")

set(PARSER_OUT "${PARSER_DIR}/parser.cpp")

if(CMAKE_BUILD_TYPE STREQUAL "Debug")

set(FLAGS "--debug")

endif()

FLEX_TARGET(LEXER source/lexer.l "${LEXER_OUT}" DEFINES_FILE "${PARSER_DIR}/scanner.h" COMPILE_FLAGS "${FLAGS}")

BISON_TARGET(PARSER source/parser.y "${PARSER_OUT}" DEFINES_FILE "${PARSER_DIR}/parser.h" COMPILE_FLAGS "${FLAGS}")

FLEX_TARGET(LEXER source/lexer.l "${LEXER_OUT}" DEFINES_FILE "${PARSER_DIR}/scanner.hpp" COMPILE_FLAGS "${FLAGS}")

BISON_TARGET(PARSER source/parser.y "${PARSER_OUT}" DEFINES_FILE "${PARSER_DIR}/parser.hpp" COMPILE_FLAGS "${FLAGS}")

ADD_FLEX_BISON_DEPENDENCY(LEXER PARSER)

add_executable(generator "${LEXER_OUT}" "${PARSER_OUT}" source/generator.c)

set_source_files_properties(${LEXER_OUT} PROPERTIES SKIP_LINTING ON)

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_compile_features(generator PUBLIC cxx_std_20)

set(GENERATE_OUT_BIN "${PROJECT_BINARY_DIR}/bin")

set(GENERATE_OUT_INCLUDE "${PROJECT_BINARY_DIR}/include/alec")

diff --git a/example/alec_compile.cpp b/example/alec_compile.cpp

@@ -1,12 +1,12 @@

#include "alec/alec.hpp"

#include <iostream>

using namespace alec;

using namespace alec; // NOLINT

using enum Color;

using enum Decor;

int main(void) {

int main() {

std::cout << abuf_enable_v << cursor_hide_v;

std::cout << cursor_position_v<1, 1> << foreground_v<91> << "HELLO!\n";

@@ -21,7 +21,7 @@ int main(void) {

std::cout << cursor_down_v<10> << "General Kenobi!";

std::cout << cursor_position_v<10, 40> << "no pain no gain" << cursor_restore_v << cursor_show_v;

getchar();

(void) getchar();

std::cout << abuf_disable_v;

diff --git a/example/alec_runtime.cpp b/example/alec_runtime.cpp

@@ -1,11 +1,12 @@

#include "alec/alec.hpp"

#include <iostream>

using namespace alec;

using namespace alec; // NOLINT

using enum Color;

using enum Decor;

int main(void) {

int main() {

std::cout << abuf_enable() << cursor_hide();

std::cout << cursor_position(1, 1) << foreground(91) << "HELLO!\n";

@@ -20,7 +21,7 @@ int main(void) {

std::cout << cursor_down(10) << "General Kenobi!";

std::cout << cursor_position(10, 40) << "no pain no gain" << cursor_restore() << cursor_show();

getchar();

(void) getchar();

std::cout << abuf_disable();

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

@@ -1,9 +1,8 @@

#ifndef ALEC_ALEC_H

#define ALEC_ALEC_H

#pragma once

#include <algorithm>

#include <array>

#include <assert.h>

#include <cassert>

#include <cstdint>

#include <string>

#include <type_traits>

@@ -67,11 +66,13 @@ struct string_literal

};

namespace helper {

template <std::size_t N> static constexpr std::size_t size(string_literal<N> val) { return N; }

static constexpr std::size_t size(char val) { return 1; }

template <std::size_t N> static constexpr std::size_t size(string_literal<N> /*val*/) { return N; }

static constexpr std::size_t size(char /*val*/) { return 1; }

static constexpr std::size_t size(int val) {

std::size_t len = 1;

while (val /= 10) len++;

while ((val /= 10) != 0) {

len++;

}

return len;

}

@@ -88,12 +89,12 @@ namespace helper {

static constexpr char *append(char *ptr, int val) {

char *tmp = ptr += size(val);

do {

*--tmp = '0' + (val % 10);

} while (val /= 10);

*--tmp = '0' + static_cast<char>(val % 10);

} while ((val /= 10) != 0);

return ptr;

}

static const std::string make(auto... args) {

static constexpr std::string make(auto... args) {

std::string res((helper::size(args) + ... + 2), 0);

res[0] = Ctrl::ESC, res[1] = '[';

auto ptr = res.data() + 2;

@@ -111,7 +112,8 @@ namespace helper {

}();

static constexpr auto data = value.data();

};

} // namespace helper

template <auto... Args> static constexpr auto escape = helper::escape_t<Args...>().data;

template <details::string_literal... Strs> static constexpr auto escape_literal = escape<Strs...>;

@@ -120,14 +122,14 @@ template <details::string_literal... Strs> static constexpr auto escape_literal

// Tamplate parameter constraints

template <int n>

concept limit_256_v = n >= 0 && n < 256;

template <int N>

concept limit_256_v = N >= 0 && N < 256;

template <int n>

concept limit_pos_v = n >= 0;

template <int N>

concept limit_pos_v = N >= 0;

static inline bool limit_pos(int n) { return n >= 0; };

static inline bool limit_256(int n) { return n >= 0 && n < 256; };

static constexpr bool limit_pos(int n) { return n >= 0; }

static constexpr bool limit_256(int n) { return n >= 0 && n < 256; }

@@ -177,12 +179,12 @@ static inline bool limit_256(int n) { return n >= 0 && n < 256; };

erase_display

Motion m

(int)m, 'J'

static_cast<int>(m), 'J'

erase_line

Motion m

(int)m, 'K'

static_cast<int>(m), 'K'

// Scroll up/down

@@ -210,12 +212,12 @@ static inline bool limit_256(int n) { return n >= 0 && n < 256; };

foreground

Color color

(int)color + 30, 'm'

static_cast<int>(color) + 30, 'm'

background

Color color

(int)color + 40, 'm'

static_cast<int>(color) + 40, 'm'

// 256-color palette

@@ -232,26 +234,26 @@ static inline bool limit_256(int n) { return n >= 0 && n < 256; };

// RGB colors

foreground

int R, int G, int B

int red, int green, int blue

limit_256

38, ';', 2, ';', R, ';', G, ';', B, 'm'

38, ';', 2, ';', red, ';', green, ';', blue, 'm'

background

int R, int G, int B

int red, int green, int blue

limit_256

48, ';', 2, ';', R, ';', G, ';', B, 'm'

48, ';', 2, ';', red, ';', green, ';', blue, 'm'

// Set/reset text decorators

decor_set

Decor decor

(int)decor, 'm'

static_cast<int>(decor), 'm'

decor_reset

Decor decor

(int)decor + 20, 'm'

static_cast<int>(decor) + 20, 'm'

// Save/restore cursor position;

@@ -331,7 +333,4 @@ static inline bool limit_256(int n) { return n >= 0 && n < 256; };

// Keyboard string TODO

} // namespace ALEC

#endif

} // namespace alec

diff --git a/source/driver.hpp b/source/driver.hpp

@@ -0,0 +1,38 @@

#pragma once

#include <string>

#define yyFlexLexer yy_alec_FlexLexer

#if !defined(yyFlexLexerOnce)

# include <FlexLexer.h>

#endif

#include "location.hpp"

#include "parser.hpp"

namespace alec

{

class driver : public yy_alec_FlexLexer

{

int m_current_line = 0;

parser::semantic_type* m_yylval = nullptr;

location_t* m_yylloc = nullptr;

void copy_location()

{

*m_yylloc = location_t(m_current_line, m_current_line);

}

public:

driver(std::istream& ins, const bool debug)

: yy_alec_FlexLexer(&ins)

{

yy_alec_FlexLexer::set_debug(static_cast<int>(debug));

}

int yylex(parser::semantic_type* yylval, location_t* lloc);

};

} // namespace alec

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

@@ -1,265 +0,0 @@

#include "generator.h"

#include "parser.h"

#define MALLOC(x) \

do { \

x = malloc(sizeof(*x)); \

if (!x) yyerror("out of space"), exit(1); \

} while (0);

#ifndef YYDEBUG

int yydebug = 1;

#endif

list_t records = {0};

list_t epilogue = {0};

list_t prologue = {0};

int main(const int argc, char *argv[]) {

if (argc < 2) {

yyparse();

return 0;

}

for (int i = 1; i < argc; i++) {

FILE *f = fopen(argv[i], "r");

if (!f) {

perror(argv[1]);

return -1;

}

yyrestart(f);

yyparse();

fclose(f);

}

// print prologue section

for (node_t *p = prologue.head; p; p = p->next) {

printf("%s", p->data);

}

list_t dupes = {0};

record_dupes(&dupes, &records);

printf("\n/* Template compile-time variables */\n\n");

record_print_dupes(&dupes);

for (node_t *p = records.head; p; p = p->next) {

const record_t *r = (const record_t *)p->data;

record_print_template(r, list_find(&dupes, r->name, scmp));

}

printf("\n/* Run-time functions */\n\n");

for (node_t *p = records.head; p; p = p->next) {

const record_t *r = (const record_t *)p->data;

record_print_function(r);

}

// print epilogue section

for (node_t *p = epilogue.head; p; p = p->next) {

printf("%s", p->data);

}

list_free(&dupes, 0);

list_free(&prologue, free);

list_free(&records, record_free);

list_free(&epilogue, free);

yylex_destroy();

}

node_t *node_new(char *data) {

node_t *n;

MALLOC(n);

*n = (node_t){

.data = data,

.next = NULL,

};

return n;

}

list_t *list_new(char *data) {

list_t *l;

MALLOC(l);

*l = (list_t){0};

if (data) list_append(l, node_new(data));

return l;

}

void list_free(list_t *l, void (*free_data)(void *)) {

if (!l) return;

node_t *c = l->head, *t;

while (c) {

t = c;

c = c->next;

if (free_data) free_data((void *)t->data);

free(t);

}

void list_append(list_t *l, node_t *n) {

if (!l->head) l->head = l->tail = n;

else

l->tail = l->tail->next = n;

}

record_t *record_new(char *name, list_t *args, list_t *rules, list_t *recipe) {

record_t *rec;

MALLOC(rec);

*rec = (record_t){

.name = name,

.args = args,

.rules = rules,

.recipe = recipe,

};

return rec;

}

void record_free(void *rp) {

record_t *r = (record_t *)rp;

if (r->args) list_free(r->args, free), free(r->args);

if (r->rules) list_free(r->rules, free), free(r->rules);

if (r->recipe) list_free(r->recipe, free), free(r->recipe);

free(r->name);

free(r);

}

int list_find(list_t *l, void *data, cmp_f cmp) {

node_t *c = l->head;

while (c) {

if (!cmp(c->data, data)) return 1;

c = c->next;

}

return 0;

}

void record_print_dupes(const list_t *l) {

node_t *c = l->head;

while (c) {

printf("template <auto... val> static const char *%s_v;\n", c->data);

c = c->next;

}

printf("\n");

}

void record_print_function(const record_t *r) {

list_t dummy = {0};

if (!r->recipe) { // comment

printf("%s\n\n", r->name);

return;

}

printf("static constexpr auto %s(", r->name);

if (r->args) {

for (node_t *p = r->args->head; p; p = p->next) {

list_append(&dummy, node_new(strchr(p->data, ' ') + 1));

printf("%s", p->data);

if (p->next) printf(", ");

}

printf(") {\n");

if (r->rules) {

for (node_t *p = dummy.head; p; p = p->next) {

printf("\tassert(");

for (node_t *q = r->rules->head; q; q = q->next) {

printf("%s(%s)", q->data, p->data);

if (q->next) printf(" && ");

}

printf(");\n");

}

if (r->args) {

printf("\treturn details::helper::make(");

for (node_t *p = r->recipe->head; p; p = p->next) {

printf("%s", p->data);

if (p->next) printf(", ");

}

printf(")");

} else {

printf("\treturn %s_v", r->name);

}

printf(";\n}\n\n");

list_free(&dummy, NULL);

}

void record_print_template(const record_t *r, int dup) {

list_t dummy = {0};

if (!r->recipe) { // comment

printf("%s\n\n", r->name);

return;

}

if (r->args) {

printf("template <");

for (node_t *p = r->args->head; p; p = p->next) {

list_append(&dummy, node_new(strchr(p->data, ' ') + 1));

printf("%s", p->data);

if (p->next) printf(", ");

}

printf(">\n");

}

if (r->rules) {

printf("\trequires ");

for (node_t *p = dummy.head; p; p = p->next) {

for (node_t *q = r->rules->head; q; q = q->next) {

printf("%s_v<%s>", q->data, p->data);

if (q->next) printf(" && ");

}

if (p->next) printf(" && ");

}

printf("\n");

}

printf("static constexpr auto %s_v", r->name);

if (dup) {

printf("<");

for (node_t *p = dummy.head; p; p = p->next) {

printf("%s", p->data);

if (p->next) printf(", ");

}

printf(">");

}

if (r->recipe->head && r->recipe->head->data[0] == '"') {

printf("\n\t = details::escape_literal<%s>;", r->recipe->head->data);

} else {

printf("\n\t = details::escape<");

for (node_t *p = r->recipe->head; p; p = p->next) {

printf("%s", p->data);

if (p->next) printf(", ");

}

printf(">;");

}

printf("\n\n");

list_free(&dummy, NULL);

}

int scmp(const void *a, const void *b) { return strcmp((const char *)a, (const char *)b); }

void record_dupes(list_t *d, list_t *l) {

list_t s = {0};

for (node_t *p = records.head; p; p = p->next) {

const record_t *r = (const record_t *)p->data;

if (!list_find(&s, r->name, scmp)) list_append(&s, node_new(r->name));

else if (!list_find(d, r->name, scmp))

list_append(d, node_new(r->name));

}

list_free(&s, NULL);

}

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

@@ -0,0 +1,157 @@

#include <cstring>

#include <format>

#include <fstream>

#include <iostream>

#include <set>

#include <string>

#include <vector>

#include "generator.h"

#include "driver.hpp"

namespace alec

{

extern std::vector<record> records; // NOLINT

extern std::vector<std::string> epilogue; // NOLINT

extern std::vector<std::string> prologue; // NOLINT

} // namespace alec

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;

}

int main(const int argc, char* argv[])

{

using namespace alec; // NOLINT

const bool debug = argc > 1 && std::strcmp(argv[1], "--debug") == 0;

std::ifstream ifile;

if (argc != 1) {

ifile.open(argv[!debug ? 1 : 2]);

}

driver drv = argc == 1 ? driver(std::cin, debug) : driver(ifile, debug);

parser parser(drv, debug);

const int res = parser();

// print prologue section

for (const auto line : prologue) {

std::cout << line;

}

std::set<std::string> seen, dupes;

for (const auto& record : records) {

const auto [_, inserted] = seen.insert(record.name);

if (!inserted) {

dupes.insert(record.name);

}

std::cout << "\n/* Template compile-time variables */\n\n";

for (const auto& dup : dupes) {

std::cout << std::format(

"template <auto... val> static const char *{}_v;\n", dup);

}

for (const auto& record : records) {

if (record.recipe.empty()) {

// comment

std::cout << std::format("{}\n\n", record.name);

continue;

}

std::vector<std::string> params(record.args.size());

std::transform(record.args.begin(),

record.args.end(),

params.begin(),

[](const std::string& str)

{ return str.substr(str.find(' ') + 1); });

if (!record.args.empty()) {

std::cout << std::format("template <{}>\n", join(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 << std::format("static constexpr auto {}_v", record.name);

if (dupes.contains(record.name)) {

std::cout << std::format("<{}>", join(params, ", "));

}

if (!record.recipe.empty() && record.recipe[0][0] == '"') {

std::cout << std::format("\n\t = details::escape_literal<{}>;\n\n",

record.recipe[0]);

} else {

std::cout << std::format("\n\t = details::escape<{}>;\n\n",

join(record.recipe, ", "));

}

std::cout << "\n/* Run-time functions */\n\n";

for (const auto& record : records) {

if (record.recipe.empty()) {

// comment

std::cout << std::format("{}\n\n", record.name);

continue;

}

std::vector<std::string> params(record.args.size());

std::transform(record.args.begin(),

record.args.end(),

params.begin(),

[](const std::string& str)

{ return str.substr(str.find(' ') + 1); });

std::cout << std::format("static constexpr auto {}({}) {{\n",

record.name,

join(record.args, ", "));

if (!record.rules.empty()) {

for (const auto& param : params) {

std::vector<std::string> constraints;

for (const auto& rule : record.rules) {

constraints.emplace_back(std::format("{}({})", rule, param));

}

std::cout << std::format("\tassert({});\n", join(constraints, " && "));

}

if (record.args.empty()) {

std::cout << std::format("\treturn {}_v;", record.name);

} else {

std::cout << std::format("\treturn details::helper::make({});",

join(record.recipe, ", "));

}

std::cout << "\n}\n\n";

}

// print epilogue section

for (const auto line : epilogue) {

std::cout << line;

}

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

@@ -1,54 +1,19 @@

#ifndef ALEC_PARSER_H

#define ALEC_PARSER_H

#pragma once

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <string>

#include <vector>

extern int yylineno;

void yyerror(char *s, ...);

namespace alec

{

typedef struct node node_t;

typedef struct list list_t;

typedef struct record record_t;

struct record

{

std::string name;

std::vector<char*> args;

std::vector<char*> rules;

std::vector<char*> recipe;

struct node {

char *data;

node_t *next;

bool operator<(const record& rhs) const { return name < rhs.name; }

};

struct list {

node_t *head;

node_t *tail;

};

struct record {

char *name;

list_t *args;

list_t *rules;

list_t *recipe;

};

typedef void (*free_f)(void *);

typedef int (*cmp_f)(const void *, const void *);

int scmp(const void *a, const void *b);

node_t *node_new(char *data);

list_t *list_new(char *data);

void list_free(list_t *l, free_f free_data);

void list_append(list_t *l, node_t *n);

int list_find(list_t *l, void *data, cmp_f cmp);

struct record *record_new(char *name, list_t *args, list_t *rules, list_t *recipe);

void record_free(void *rp);

void record_dupes(list_t *d, list_t *l);

void record_print_template(const struct record *r, int dup);

void record_print_function(const struct record *r);

void record_print_dupes(const list_t *l);

#endif

} // namespace alec

diff --git a/source/lexer.l b/source/lexer.l

@@ -1,40 +1,81 @@

%option noyywrap nodefault yylineno

#include "generator.h"

#include "parser.h"

#include <ctype.h>

#include <stack>

#include "driver.hpp"

#include "parser.hpp"

using namespace alec;

#undef YY_DECL

#define YY_DECL int driver::yylex(parser::semantic_type* yylval, location_t *const lloc)

#define YY_USER_INIT m_yylloc = lloc;

#define YY_USER_ACTION copy_location();

std::stack<int> mode_st;

#define BEGIN_MODE(mode) do { \

if(yy_flex_debug) std::cerr<<"Starting mode: "<<mode<<std::endl; \

mode_st.push(YY_START); \

BEGIN((mode)); \

} while(0);

#define END_MODE() do { \

if(yy_flex_debug) std::cerr<<"Returning to mode: "<<mode_st.top()<<std::endl; \

BEGIN(mode_st.top()); \

mode_st.pop(); \

} while(0);

%option c++ noyywrap debug nodefault

%option yyclass = "driver"

%option prefix = "yy_alec_"

LINE_END (\n|\r|\r\n)

%x GEN

%x LAST

%x GEN LAST

using Token = parser::token;

"%%"{LINE_END} { BEGIN GEN; return SWITCH; }

.*{LINE_END} { yylval.n = strdup(yytext); return PROLOGUE; }

"%%"{LINE_END} { BEGIN_MODE(GEN); return Token::SWITCH; }

.*{LINE_END} {

yylval->emplace<char *>(strdup(yytext));

return Token::PROLOGUE;

}

<GEN>{LINE_END} { return EOL; }

<GEN>^[\t ]*{LINE_END} { return EOL; }

<GEN>^[\t ]*\|*[\t ]*{LINE_END} { return EMPTY; }

<GEN>{LINE_END} { return Token::EOL; }

<GEN>^[\t ]*{LINE_END} { return Token::EOL; }

<GEN>^[\t ]*\|*[\t ]*{LINE_END} { return Token::EMPTY; }

<GEN>^[\t ]*"//".* { yylval.n = strdup(yytext); return COMMENT; }

<GEN>^[\t ]*"//".* {

yylval->emplace<char *>(strdup(yytext));

return Token::COMMENT;

}

<GEN>, { return COMMA; }

<GEN>, { return Token::COMMA; }

<GEN>[^,\n]* {

char *p = yytext + strlen(yytext) - 1;

while(isspace(*p)) *p-- = '\0';

while(*yytext && isspace(*yytext)) yytext++;

yylval.n = strdup(yytext); return LITERAL;

yylval->emplace<char *>(strdup(yytext));

return Token::LITERAL;

}

<GEN>"%%"{LINE_END} { BEGIN LAST; return SWITCH; }

<GEN>"%%"{LINE_END} {

BEGIN_MODE(LAST);

return Token::SWITCH;

}

<LAST>.*{LINE_END} { yylval.n = strdup(yytext); return EPILOGUE; }

<LAST>.*{LINE_END} {

yylval->emplace<char *>(strdup(yytext));

return Token::EPILOGUE;

}

diff --git a/source/location.hpp b/source/location.hpp

@@ -0,0 +1,18 @@

#pragma once

#include <cstddef>

#include <ostream>

#include <utility>

namespace alec

{

using position_t = std::size_t;

using location_t = std::pair<std::size_t, std::size_t>;

} // namespace alec

inline std::ostream& operator<<(std::ostream& ost, const alec::location_t& loc)

{

return ost << "[" << loc.first << "-" << loc.second << "]";

}

diff --git a/source/parser.y b/source/parser.y

@@ -1,29 +1,60 @@

%require "3.8.2"

%language "c++"

%code requires {

#include <string>

#include <cstdint>

#include "location.hpp"

#include "generator.h"

#include <stdarg.h>

namespace alec {

class driver;

} // namespace alec

}

%define api.value.type union

%token <char *> n LITERAL COMMENT PROLOGUE EPILOGUE

%define api.namespace { alec }

%define api.parser.class { parser }

%define api.value.type variant

%define api.location.type { location_t }

%type <record_t *> record

%type <list_t *> list items

%type <char *> name

%locations

%define parse.error detailed

%token EOL COMMA SWITCH EMPTY

%header

%verbose

%parse-param {driver &drv}

%parse-param {const bool debug}

%initial-action

{

#if YYDEBUG != 0

set_debug_level(debug);

#endif

};

%code {

#include "driver.hpp"

%code provides {

int yylex(void);

int yyparse(void);

void yyrestart(FILE *);

int yylex_destroy(void);

namespace alec {

template<typename RHS>

void calcLocation(location_t &current, const RHS &rhs, const std::size_t n);

extern list_t records;

extern list_t epilogue;

extern list_t prologue;

std::vector<record> records;

std::vector<std::string> epilogue;

std::vector<std::string> prologue;

} // namespace alec

#define YYLLOC_DEFAULT(Cur, Rhs, N) calcLocation(Cur, Rhs, N)

#define yylex drv.yylex

}

%destructor { free($$); } <char *>

%left <char *> LITERAL COMMENT PROLOGUE EPILOGUE

%token EOL COMMA SWITCH EMPTY

%type <record> record

%type <std::vector<char*>> list items

%type <char *> name

%start document

@@ -32,41 +63,44 @@

document: prologue grammar epilogue

prologue: %empty

| prologue PROLOGUE { list_append(&prologue, node_new($2)); }

| prologue PROLOGUE { prologue.push_back($2); }

;

epilogue: SWITCH

| epilogue EPILOGUE { list_append(&epilogue, node_new($2)); }

| epilogue EPILOGUE { epilogue.push_back($2); }

;

grammar: SWITCH

| grammar EOL

| grammar record { list_append(&records, node_new((char *)$2)); }

| grammar record { records.push_back(std::move($2)); }

;

record: name list list list { $$ = record_new($1, $2, $3, $4); }

| COMMENT { $$ = record_new($1, NULL, NULL, NULL); }

record: name list list list { $$ = record($1, $2, $3, $4); }

| COMMENT { $$ = record($1, {}, {}, {}); }

;

name: LITERAL EOL { $$ = $1; }

;

list: EMPTY { $$ = NULL; }

list: EMPTY { $$ = {}; }

| items EOL { $$ = $1; }

;

items: LITERAL { $$ = list_new($1); }

| items COMMA LITERAL { list_append($1, node_new($3)); $$ = $1; }

items: LITERAL { $$ = { $1 }; }

| items COMMA LITERAL { $1.push_back($3); $$ = $1; }

;

void yyerror(char *s, ...) {

va_list ap;

va_start(ap, s);

fprintf(stderr, "%d: error: ", yylineno);

vfprintf(stderr, s, ap);

fprintf(stderr, "\n");

}

namespace alec {

template<typename RHS>

inline void calcLocation(location_t &current, const RHS &rhs, const std::size_t n)

{

current = location_t(YYRHSLOC(rhs, 0).first, YYRHSLOC(rhs, n).second);

}

void parser::error(const location_t &location, const std::string &message)

{

std::cerr << "Error at lines " << location << ": " << message << std::endl;

}

} // namespace alec