444 lines
16 KiB
C++
444 lines
16 KiB
C++
#pragma once
|
|
/*
|
|
* Copyright (C) 2024 Brett Terpstra
|
|
*
|
|
* This program is free software: you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation, either version 3 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program. If not, see <https://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
#ifndef BLT_TEMPLATING_H
|
|
#define BLT_TEMPLATING_H
|
|
|
|
#include <string>
|
|
#include <string_view>
|
|
#include <utility>
|
|
#include <vector>
|
|
#include <utility>
|
|
#include <blt/std/hashmap.h>
|
|
#include <blt/std/types.h>
|
|
#include <blt/std/expected.h>
|
|
#include <variant>
|
|
|
|
namespace blt
|
|
{
|
|
|
|
template<typename Storage, typename Consumable>
|
|
class template_consumer_base_t
|
|
{
|
|
public:
|
|
explicit template_consumer_base_t(Storage storage): storage(std::move(storage))
|
|
{}
|
|
|
|
[[nodiscard]] Consumable next(size_t offset = 0) const
|
|
{
|
|
return storage[current_index + offset];
|
|
}
|
|
|
|
void advance(size_t offset = 1)
|
|
{
|
|
current_index += offset;
|
|
}
|
|
|
|
[[nodiscard]] bool hasNext(size_t offset = 1) const
|
|
{
|
|
return (current_index + (offset - 1)) < storage.size();
|
|
}
|
|
|
|
[[nodiscard]] Consumable consume()
|
|
{
|
|
Consumable c = next();
|
|
advance();
|
|
return c;
|
|
}
|
|
|
|
[[nodiscard]] size_t getCurrentIndex() const
|
|
{
|
|
return current_index;
|
|
}
|
|
|
|
[[nodiscard]] size_t getPreviousIndex() const
|
|
{
|
|
return current_index - 1;
|
|
}
|
|
|
|
protected:
|
|
size_t current_index = 0;
|
|
Storage storage;
|
|
};
|
|
|
|
enum class template_token_t
|
|
{
|
|
//STRING, // A string of characters not $ { or }
|
|
IDENT, // $
|
|
ADD, // +
|
|
CURLY_OPEN, // {
|
|
CURLY_CLOSE, // }
|
|
IF, // IF
|
|
ELSE, // ELSE
|
|
PAR_OPEN, // (
|
|
PAR_CLOSE, // )
|
|
OR, // ||
|
|
AND, // &&
|
|
XOR, // ^
|
|
NOT, // !
|
|
QUOTE, // "
|
|
SEMI, // ;
|
|
COMMA, // ,
|
|
PERIOD, // .
|
|
FUNCTION, // ~
|
|
STRING // variable name
|
|
};
|
|
|
|
namespace detail
|
|
{
|
|
inline const blt::hashmap_t<std::string_view, template_token_t> identifiers = {
|
|
{"IF", template_token_t::IF},
|
|
{"ELSE", template_token_t::ELSE}
|
|
};
|
|
}
|
|
|
|
inline std::string template_token_to_string(template_token_t token)
|
|
{
|
|
switch (token)
|
|
{
|
|
case template_token_t::IDENT:
|
|
return "[Template Identifier]";
|
|
case template_token_t::CURLY_OPEN:
|
|
return "[Curly Open]";
|
|
case template_token_t::CURLY_CLOSE:
|
|
return "[Curly Close]";
|
|
case template_token_t::IF:
|
|
return "[IF]";
|
|
case template_token_t::ELSE:
|
|
return "[ELSE]";
|
|
case template_token_t::PAR_OPEN:
|
|
return "[Par Open]";
|
|
case template_token_t::PAR_CLOSE:
|
|
return "[Par Close]";
|
|
case template_token_t::OR:
|
|
return "[OR]";
|
|
case template_token_t::AND:
|
|
return "[AND]";
|
|
case template_token_t::XOR:
|
|
return "[XOR]";
|
|
case template_token_t::NOT:
|
|
return "[NOT]";
|
|
case template_token_t::QUOTE:
|
|
return "[QUOTE]";
|
|
case template_token_t::FUNCTION:
|
|
return "[FUNC]";
|
|
case template_token_t::STRING:
|
|
return "[STR]";
|
|
case template_token_t::SEMI:
|
|
return "[SEMI]";
|
|
case template_token_t::COMMA:
|
|
return "[COMMA]";
|
|
case template_token_t::PERIOD:
|
|
return "[PERIOD]";
|
|
case template_token_t::ADD:
|
|
return "[ADD]";
|
|
}
|
|
}
|
|
|
|
enum class template_tokenizer_failure_t
|
|
{
|
|
MISMATCHED_CURLY,
|
|
MISMATCHED_PAREN,
|
|
MISMATCHED_QUOTE,
|
|
};
|
|
|
|
enum class template_parser_failure_t
|
|
{
|
|
SUBSTITUTION_NOT_FOUND,
|
|
TOKENIZER_FAILURE,
|
|
NO_MATCHING_CURLY,
|
|
MISSING_IDENT_BRACES,
|
|
FUNCTION_EXPECTED_STRING,
|
|
FUNCTION_NOT_FOUND,
|
|
FUNCTION_DISCARD,
|
|
STRING_EXPECTED_CONCAT,
|
|
IF_EXPECTED_PAREN,
|
|
BOOL_EXPECTED_PAREN,
|
|
UNKNOWN_STATEMENT_ERROR,
|
|
UNKNOWN_ERROR
|
|
};
|
|
|
|
struct template_token_data_t
|
|
{
|
|
template_token_t type;
|
|
size_t level;
|
|
std::string_view token;
|
|
size_t paren_level = 0;
|
|
|
|
template_token_data_t(template_token_t type, size_t level, const std::string_view& token): type(type), level(level), token(token)
|
|
{}
|
|
|
|
template_token_data_t(template_token_t type, size_t level, const std::string_view& token, size_t parenLevel):
|
|
type(type), level(level), token(token), paren_level(parenLevel)
|
|
{}
|
|
};
|
|
|
|
class template_char_consumer_t : public template_consumer_base_t<std::string_view, char>
|
|
{
|
|
public:
|
|
explicit template_char_consumer_t(std::string_view statement): template_consumer_base_t(statement)
|
|
{}
|
|
|
|
[[nodiscard]] std::string_view from(size_t begin, size_t end)
|
|
{
|
|
return std::string_view{&storage[begin], end - begin};
|
|
}
|
|
};
|
|
|
|
class template_token_consumer_t : public template_consumer_base_t<std::vector<template_token_data_t>, template_token_data_t>
|
|
{
|
|
public:
|
|
explicit template_token_consumer_t(const std::vector<template_token_data_t>& statement): template_consumer_base_t(statement)
|
|
{}
|
|
|
|
std::string_view from_last(std::string_view raw_string)
|
|
{
|
|
if (current_index == 0)
|
|
return "";
|
|
auto token = storage[getPreviousIndex()];
|
|
auto len = (&token.token.back() - &raw_string.front()) - last_read_index;
|
|
auto str = std::string_view(&raw_string[last_read_index], len);
|
|
last_read_index += len;
|
|
return str;
|
|
}
|
|
|
|
void back()
|
|
{
|
|
current_index--;
|
|
}
|
|
|
|
private:
|
|
size_t last_read_index = 0;
|
|
};
|
|
|
|
class template_parser_t
|
|
{
|
|
public:
|
|
using estring = blt::expected<std::string, template_parser_failure_t>;
|
|
using ebool = blt::expected<bool, template_parser_failure_t>;
|
|
|
|
template_parser_t(blt::hashmap_t<std::string, std::string>& substitutions, template_token_consumer_t& consumer):
|
|
substitutions(substitutions), consumer(consumer)
|
|
{}
|
|
|
|
estring parse()
|
|
{
|
|
auto next = consumer.consume();
|
|
if (next.type == template_token_t::IDENT && consumer.next().type == template_token_t::CURLY_OPEN)
|
|
{
|
|
consumer.advance();
|
|
auto str = statement();
|
|
consumer.advance();
|
|
return str;
|
|
}
|
|
return blt::unexpected(template_parser_failure_t::MISSING_IDENT_BRACES);
|
|
}
|
|
|
|
private:
|
|
estring statement()
|
|
{
|
|
auto next = consumer.consume();
|
|
if (next.type == template_token_t::STRING || next.type == template_token_t::QUOTE)
|
|
{
|
|
consumer.back();
|
|
return string();
|
|
} else if (next.type == template_token_t::FUNCTION)
|
|
{
|
|
return function();
|
|
} else if (next.type == template_token_t::IDENT && consumer.hasNext() && consumer.next().type == template_token_t::CURLY_OPEN)
|
|
{
|
|
consumer.advance();
|
|
auto stmt = statement();
|
|
// should never occur
|
|
if (consumer.hasNext() && consumer.next().type != template_token_t::CURLY_CLOSE)
|
|
return blt::unexpected(template_parser_failure_t::NO_MATCHING_CURLY);
|
|
consumer.advance();
|
|
return stmt;
|
|
} else if (next.type == template_token_t::IF)
|
|
{
|
|
return if_func();
|
|
}
|
|
return blt::unexpected(template_parser_failure_t::UNKNOWN_STATEMENT_ERROR);
|
|
}
|
|
|
|
estring function()
|
|
{
|
|
auto str = consumer.consume();
|
|
if (str.type != template_token_t::STRING)
|
|
return blt::unexpected(template_parser_failure_t::FUNCTION_EXPECTED_STRING);
|
|
if (str.token == "DISCARD")
|
|
return blt::unexpected(template_parser_failure_t::FUNCTION_DISCARD);
|
|
return blt::unexpected(template_parser_failure_t::FUNCTION_NOT_FOUND);
|
|
}
|
|
|
|
estring if_func()
|
|
{
|
|
// IF(
|
|
if (consumer.consume().type != template_token_t::PAR_OPEN)
|
|
return blt::unexpected(template_parser_failure_t::IF_EXPECTED_PAREN);
|
|
// (statement)
|
|
auto bool_eval = bool_statement();
|
|
if (!bool_eval)
|
|
return blt::unexpected(bool_eval.error());
|
|
if (consumer.consume().type != template_token_t::PAR_CLOSE)
|
|
return blt::unexpected(template_parser_failure_t::IF_EXPECTED_PAREN);
|
|
auto true_statement = statement();
|
|
estring false_statement = blt::unexpected(template_parser_failure_t::UNKNOWN_ERROR);
|
|
if (consumer.next().type == template_token_t::ELSE)
|
|
{
|
|
consumer.advance();
|
|
false_statement = statement();
|
|
}
|
|
if (bool_eval.value())
|
|
{
|
|
return true_statement;
|
|
} else
|
|
{
|
|
if (false_statement)
|
|
return false_statement;
|
|
return "";
|
|
}
|
|
}
|
|
|
|
estring string()
|
|
{
|
|
auto next = consumer.consume();
|
|
if (next.type == template_token_t::STRING)
|
|
{
|
|
if (!substitutions.contains(next.token))
|
|
return blt::unexpected(template_parser_failure_t::SUBSTITUTION_NOT_FOUND);
|
|
if (consumer.next().type == template_token_t::SEMI)
|
|
{
|
|
consumer.advance();
|
|
return substitutions[next.token];
|
|
}
|
|
if (consumer.next().type != template_token_t::ADD)
|
|
return blt::unexpected(template_parser_failure_t::STRING_EXPECTED_CONCAT);
|
|
consumer.advance();
|
|
auto str = string();
|
|
if (str)
|
|
return substitutions[next.token] + str.value();
|
|
else
|
|
return str;
|
|
} else
|
|
{
|
|
if (consumer.next().type == template_token_t::SEMI)
|
|
{
|
|
consumer.advance();
|
|
return std::string(next.token);
|
|
}
|
|
auto str = string();
|
|
if (str)
|
|
return std::string(next.token) + str.value();
|
|
else
|
|
return str;
|
|
}
|
|
}
|
|
|
|
ebool bool_statement()
|
|
{
|
|
auto next = consumer.next();
|
|
if (next.type == template_token_t::PAR_OPEN)
|
|
{
|
|
consumer.advance();
|
|
auto b = bool_statement();
|
|
if (consumer.consume().type != template_token_t::PAR_CLOSE)
|
|
return blt::unexpected(template_parser_failure_t::BOOL_EXPECTED_PAREN);
|
|
return b;
|
|
}
|
|
return bool_expression();
|
|
}
|
|
|
|
ebool bool_expression()
|
|
{
|
|
auto next = consumer.next();
|
|
if (next.type == template_token_t::PAR_OPEN)
|
|
return bool_statement();
|
|
consumer.advance();
|
|
if (next.type == template_token_t::NOT)
|
|
{
|
|
auto b = bool_statement();
|
|
if (b)
|
|
return !b.value();
|
|
else
|
|
return b;
|
|
} else if (next.type == template_token_t::STRING)
|
|
{
|
|
auto bool_val = next.token.empty();
|
|
next = consumer.next();
|
|
if (next.type == template_token_t::PAR_CLOSE)
|
|
return bool_val;
|
|
consumer.advance();
|
|
if (next.type == template_token_t::AND)
|
|
{
|
|
auto other_val = bool_expression();
|
|
if (!other_val)
|
|
return other_val;
|
|
return bool_val && other_val.value();
|
|
} else if (next.type == template_token_t::OR)
|
|
{
|
|
auto other_val = bool_expression();
|
|
if (!other_val)
|
|
return other_val;
|
|
return bool_val || other_val.value();
|
|
} else if (next.type == template_token_t::XOR)
|
|
{
|
|
auto other_val = bool_expression();
|
|
if (!other_val)
|
|
return other_val;
|
|
return bool_val ^ other_val.value();
|
|
}
|
|
}
|
|
return unexpected(template_parser_failure_t::UNKNOWN_ERROR);
|
|
}
|
|
|
|
blt::hashmap_t<std::string, std::string>& substitutions;
|
|
template_token_consumer_t& consumer;
|
|
};
|
|
|
|
class template_engine_t
|
|
{
|
|
public:
|
|
inline std::string& operator[](const std::string& key)
|
|
{
|
|
return substitutions[key];
|
|
}
|
|
|
|
inline std::string& operator[](std::string_view key)
|
|
{
|
|
return substitutions[key];
|
|
}
|
|
|
|
inline template_engine_t& set(std::string_view key, std::string_view replacement)
|
|
{
|
|
substitutions[key] = replacement;
|
|
return *this;
|
|
}
|
|
|
|
static blt::expected<std::vector<template_token_data_t>, template_tokenizer_failure_t> process_string(std::string_view str);
|
|
|
|
blt::expected<std::string, template_parser_failure_t> evaluate(std::string_view str);
|
|
|
|
private:
|
|
blt::hashmap_t<std::string, std::string> substitutions;
|
|
};
|
|
|
|
}
|
|
|
|
#endif //BLT_TEMPLATING_H
|