diff options
| author | Toni Uhlig <matzeton@googlemail.com> | 2021-11-15 12:51:20 +0100 |
|---|---|---|
| committer | Toni Uhlig <matzeton@googlemail.com> | 2021-11-15 12:51:20 +0100 |
| commit | 662f5a771f3807bf7ebd5a3989230d5d0a26659d (patch) | |
| tree | 51cf82d5f470a0f4a9613bccbb3da3492f9eee34 /include | |
| parent | 514cb71a6a3e116c229c5dc874369f8632530dc7 (diff) | |
Squashed 'deps/inja/' changes from 811e173..eb04bfc
eb04bfc clang-format
81cfa14 init LiteralNode with string view, code cleaning
2da715a parse_filename without json
623c267 make_result and code cleaning
1206913 rename json -> data
d38c07e clang 5 minimum
a067a8b make all tests C++17
098de66 inja_test C++17
173c1f5 fix C++17
2239e23 remove string view polyfill
fb55f2e update minimum compiler
751d27d fix MIT license
635e1fb change readme example
5a4ac92 update single include
d038c53 set .cpp in readme
cf71b54 add include callback
9b9dd96 introduce INJA_DATA_TYPE
12a2c9b unify json data type
4505fd0 add tests for assignments
2d51507 set version 3.3
2ba5783 Merge branch 'master' of github.com:pantor/inja
99b85d6 remove headers in files, add central header
14f0d38 Fixed an issue with round (#207)
c70fd58 Merge branch 'master' of github.com:pantor/inja
8a9aee1 add jinja python test script
91c93bf add join function (#204)
9cf7db8 add warnings for benchmark, fix for inja_throw
e91a2fd #ifndef INJA_THROW
8d65633 add warnings for clang and fix them
eaec58d update nlohmann/json to master
4ccadd5 update to json=3.9.1, doctest=2.4.6
83feb26 update single include
4e90947 at function for objects
b473873 compactify assignments readme
798a0b9 Add support for setting subobjects via JSON pointer in set statements. (#202)
86f38f0 update single include
d9ad8d1 whitespace control for comments
95af782 Add Child Inheritance Feature (#198)
b4b9d8d Fix build warnings for Clang and MSVC (#197)
b14f8a1 add ci for gcc 10, 11
06ff271 add no excpetion test
2491980 Fix inclusion in translation units with exceptions disabled. (#196)
4d5a7d1 fix single include
eac2162 fix include of in-memory templates
ca3c7a0 add test for short circuit evaluation
389c1d6 short circuit evaluation
git-subtree-dir: deps/inja
git-subtree-split: eb04bfc7d3cf0a5fbd0ed37a88d064230d0af377
Diffstat (limited to 'include')
| -rw-r--r-- | include/inja/config.hpp | 11 | ||||
| -rw-r--r-- | include/inja/environment.hpp | 87 | ||||
| -rw-r--r-- | include/inja/exceptions.hpp | 21 | ||||
| -rw-r--r-- | include/inja/function_storage.hpp | 86 | ||||
| -rw-r--r-- | include/inja/inja.hpp | 48 | ||||
| -rw-r--r-- | include/inja/lexer.hpp | 77 | ||||
| -rw-r--r-- | include/inja/node.hpp | 262 | ||||
| -rw-r--r-- | include/inja/parser.hpp | 273 | ||||
| -rw-r--r-- | include/inja/renderer.hpp | 524 | ||||
| -rw-r--r-- | include/inja/statistics.hpp | 37 | ||||
| -rw-r--r-- | include/inja/string_view.hpp | 1416 | ||||
| -rw-r--r-- | include/inja/template.hpp | 8 | ||||
| -rw-r--r-- | include/inja/token.hpp | 11 | ||||
| -rw-r--r-- | include/inja/utils.hpp | 40 |
14 files changed, 846 insertions, 2055 deletions
diff --git a/include/inja/config.hpp b/include/inja/config.hpp index 3f284a4..0a8f9b7 100644 --- a/include/inja/config.hpp +++ b/include/inja/config.hpp @@ -1,12 +1,10 @@ -// Copyright (c) 2019 Pantor. All rights reserved. - #ifndef INCLUDE_INJA_CONFIG_HPP_ #define INCLUDE_INJA_CONFIG_HPP_ #include <functional> #include <string> -#include "string_view.hpp" +#include "template.hpp" namespace inja { @@ -25,7 +23,9 @@ struct LexerConfig { std::string expression_close {"}}"}; std::string expression_close_force_rstrip {"-}}"}; std::string comment_open {"{#"}; + std::string comment_open_force_lstrip {"{#-"}; std::string comment_close {"#}"}; + std::string comment_close_force_rstrip {"-#}"}; std::string open_chars {"#{"}; bool trim_blocks {false}; @@ -54,6 +54,9 @@ struct LexerConfig { if (open_chars.find(comment_open[0]) == std::string::npos) { open_chars += comment_open[0]; } + if (open_chars.find(comment_open_force_lstrip[0]) == std::string::npos) { + open_chars += comment_open_force_lstrip[0]; + } } }; @@ -62,6 +65,8 @@ struct LexerConfig { */ struct ParserConfig { bool search_included_templates_in_files {true}; + + std::function<Template(const std::string&, const std::string&)> include_callback; }; /*! diff --git a/include/inja/environment.hpp b/include/inja/environment.hpp index ed99537..a652935 100644 --- a/include/inja/environment.hpp +++ b/include/inja/environment.hpp @@ -1,5 +1,3 @@ -// Copyright (c) 2019 Pantor. All rights reserved. - #ifndef INCLUDE_INJA_ENVIRONMENT_HPP_ #define INCLUDE_INJA_ENVIRONMENT_HPP_ @@ -8,21 +6,17 @@ #include <memory> #include <sstream> #include <string> - -#include <nlohmann/json.hpp> +#include <string_view> #include "config.hpp" #include "function_storage.hpp" #include "parser.hpp" #include "renderer.hpp" -#include "string_view.hpp" #include "template.hpp" #include "utils.hpp" namespace inja { -using json = nlohmann::json; - /*! * \brief Class for changing the configuration. */ @@ -38,15 +32,14 @@ class Environment { TemplateStorage template_storage; public: - Environment() : Environment("") {} + Environment(): Environment("") {} - explicit Environment(const std::string &global_path) : input_path(global_path), output_path(global_path) {} + explicit Environment(const std::string& global_path): input_path(global_path), output_path(global_path) {} - Environment(const std::string &input_path, const std::string &output_path) - : input_path(input_path), output_path(output_path) {} + Environment(const std::string& input_path, const std::string& output_path): input_path(input_path), output_path(output_path) {} /// Sets the opener and closer for template statements - void set_statement(const std::string &open, const std::string &close) { + void set_statement(const std::string& open, const std::string& close) { lexer_config.statement_open = open; lexer_config.statement_open_no_lstrip = open + "+"; lexer_config.statement_open_force_lstrip = open + "-"; @@ -56,13 +49,13 @@ public: } /// Sets the opener for template line statements - void set_line_statement(const std::string &open) { + void set_line_statement(const std::string& open) { lexer_config.line_statement = open; lexer_config.update_open_chars(); } /// Sets the opener and closer for template expressions - void set_expression(const std::string &open, const std::string &close) { + void set_expression(const std::string& open, const std::string& close) { lexer_config.expression_open = open; lexer_config.expression_open_force_lstrip = open + "-"; lexer_config.expression_close = close; @@ -71,9 +64,11 @@ public: } /// Sets the opener and closer for template comments - void set_comment(const std::string &open, const std::string &close) { + void set_comment(const std::string& open, const std::string& close) { lexer_config.comment_open = open; + lexer_config.comment_open_force_lstrip = open + "-"; lexer_config.comment_close = close; + lexer_config.comment_close_force_rstrip = "-" + close; lexer_config.update_open_chars(); } @@ -97,75 +92,79 @@ public: render_config.throw_at_missing_includes = will_throw; } - Template parse(nonstd::string_view input) { + Template parse(std::string_view input) { Parser parser(parser_config, lexer_config, template_storage, function_storage); return parser.parse(input); } - Template parse_template(const std::string &filename) { + Template parse_template(const std::string& filename) { Parser parser(parser_config, lexer_config, template_storage, function_storage); auto result = Template(parser.load_file(input_path + static_cast<std::string>(filename))); parser.parse_into_template(result, input_path + static_cast<std::string>(filename)); return result; } - Template parse_file(const std::string &filename) { + Template parse_file(const std::string& filename) { return parse_template(filename); } - std::string render(nonstd::string_view input, const json &data) { return render(parse(input), data); } + std::string render(std::string_view input, const json& data) { + return render(parse(input), data); + } - std::string render(const Template &tmpl, const json &data) { + std::string render(const Template& tmpl, const json& data) { std::stringstream os; render_to(os, tmpl, data); return os.str(); } - std::string render_file(const std::string &filename, const json &data) { + std::string render_file(const std::string& filename, const json& data) { return render(parse_template(filename), data); } - std::string render_file_with_json_file(const std::string &filename, const std::string &filename_data) { + std::string render_file_with_json_file(const std::string& filename, const std::string& filename_data) { const json data = load_json(filename_data); return render_file(filename, data); } - void write(const std::string &filename, const json &data, const std::string &filename_out) { + void write(const std::string& filename, const json& data, const std::string& filename_out) { std::ofstream file(output_path + filename_out); file << render_file(filename, data); file.close(); } - void write(const Template &temp, const json &data, const std::string &filename_out) { + void write(const Template& temp, const json& data, const std::string& filename_out) { std::ofstream file(output_path + filename_out); file << render(temp, data); file.close(); } - void write_with_json_file(const std::string &filename, const std::string &filename_data, - const std::string &filename_out) { + void write_with_json_file(const std::string& filename, const std::string& filename_data, const std::string& filename_out) { const json data = load_json(filename_data); write(filename, data, filename_out); } - void write_with_json_file(const Template &temp, const std::string &filename_data, const std::string &filename_out) { + void write_with_json_file(const Template& temp, const std::string& filename_data, const std::string& filename_out) { const json data = load_json(filename_data); write(temp, data, filename_out); } - std::ostream &render_to(std::ostream &os, const Template &tmpl, const json &data) { + std::ostream& render_to(std::ostream& os, const Template& tmpl, const json& data) { Renderer(render_config, template_storage, function_storage).render_to(os, tmpl, data); return os; } - std::string load_file(const std::string &filename) { + std::string load_file(const std::string& filename) { Parser parser(parser_config, lexer_config, template_storage, function_storage); return parser.load_file(input_path + filename); } - json load_json(const std::string &filename) { + json load_json(const std::string& filename) { std::ifstream file; - open_file_or_throw(input_path + filename, file); + file.open(input_path + filename); + if (file.fail()) { + INJA_THROW(FileError("failed accessing file at '" + input_path + filename + "'")); + } json j; file >> j; return j; @@ -174,51 +173,61 @@ public: /*! @brief Adds a variadic callback */ - void add_callback(const std::string &name, const CallbackFunction &callback) { + void add_callback(const std::string& name, const CallbackFunction& callback) { add_callback(name, -1, callback); } /*! @brief Adds a variadic void callback */ - void add_void_callback(const std::string &name, const VoidCallbackFunction &callback) { + void add_void_callback(const std::string& name, const VoidCallbackFunction& callback) { add_void_callback(name, -1, callback); } /*! @brief Adds a callback with given number or arguments */ - void add_callback(const std::string &name, int num_args, const CallbackFunction &callback) { + void add_callback(const std::string& name, int num_args, const CallbackFunction& callback) { function_storage.add_callback(name, num_args, callback); } /*! @brief Adds a void callback with given number or arguments */ - void add_void_callback(const std::string &name, int num_args, const VoidCallbackFunction &callback) { - function_storage.add_callback(name, num_args, [callback](Arguments& args) { callback(args); return json(); }); + void add_void_callback(const std::string& name, int num_args, const VoidCallbackFunction& callback) { + function_storage.add_callback(name, num_args, [callback](Arguments& args) { + callback(args); + return json(); + }); } /** Includes a template with a given name into the environment. * Then, a template can be rendered in another template using the * include "<name>" syntax. */ - void include_template(const std::string &name, const Template &tmpl) { + void include_template(const std::string& name, const Template& tmpl) { template_storage[name] = tmpl; } + + /*! + @brief Sets a function that is called when an included file is not found + */ + void set_include_callback(const std::function<Template(const std::string&, const std::string&)>& callback) { + parser_config.include_callback = callback; + } }; /*! @brief render with default settings to a string */ -inline std::string render(nonstd::string_view input, const json &data) { +inline std::string render(std::string_view input, const json& data) { return Environment().render(input, data); } /*! @brief render with default settings to the given output stream */ -inline void render_to(std::ostream &os, nonstd::string_view input, const json &data) { +inline void render_to(std::ostream& os, std::string_view input, const json& data) { Environment env; env.render_to(os, env.parse(input), data); } diff --git a/include/inja/exceptions.hpp b/include/inja/exceptions.hpp index 2784da8..f0dc8aa 100644 --- a/include/inja/exceptions.hpp +++ b/include/inja/exceptions.hpp @@ -1,5 +1,3 @@ -// Copyright (c) 2020 Pantor. All rights reserved. - #ifndef INCLUDE_INJA_EXCEPTIONS_HPP_ #define INCLUDE_INJA_EXCEPTIONS_HPP_ @@ -19,30 +17,29 @@ struct InjaError : public std::runtime_error { const SourceLocation location; - explicit InjaError(const std::string &type, const std::string &message) + explicit InjaError(const std::string& type, const std::string& message) : std::runtime_error("[inja.exception." + type + "] " + message), type(type), message(message), location({0, 0}) {} - explicit InjaError(const std::string &type, const std::string &message, SourceLocation location) - : std::runtime_error("[inja.exception." + type + "] (at " + std::to_string(location.line) + ":" + - std::to_string(location.column) + ") " + message), + explicit InjaError(const std::string& type, const std::string& message, SourceLocation location) + : std::runtime_error("[inja.exception." + type + "] (at " + std::to_string(location.line) + ":" + std::to_string(location.column) + ") " + message), type(type), message(message), location(location) {} }; struct ParserError : public InjaError { - explicit ParserError(const std::string &message, SourceLocation location) : InjaError("parser_error", message, location) {} + explicit ParserError(const std::string& message, SourceLocation location): InjaError("parser_error", message, location) {} }; struct RenderError : public InjaError { - explicit RenderError(const std::string &message, SourceLocation location) : InjaError("render_error", message, location) {} + explicit RenderError(const std::string& message, SourceLocation location): InjaError("render_error", message, location) {} }; struct FileError : public InjaError { - explicit FileError(const std::string &message) : InjaError("file_error", message) {} - explicit FileError(const std::string &message, SourceLocation location) : InjaError("file_error", message, location) {} + explicit FileError(const std::string& message): InjaError("file_error", message) {} + explicit FileError(const std::string& message, SourceLocation location): InjaError("file_error", message, location) {} }; -struct JsonError : public InjaError { - explicit JsonError(const std::string &message, SourceLocation location) : InjaError("json_error", message, location) {} +struct DataError : public InjaError { + explicit DataError(const std::string& message, SourceLocation location): InjaError("data_error", message, location) {} }; } // namespace inja diff --git a/include/inja/function_storage.hpp b/include/inja/function_storage.hpp index b0091bd..891e45f 100644 --- a/include/inja/function_storage.hpp +++ b/include/inja/function_storage.hpp @@ -1,19 +1,14 @@ -// Copyright (c) 2020 Pantor. All rights reserved. - #ifndef INCLUDE_INJA_FUNCTION_STORAGE_HPP_ #define INCLUDE_INJA_FUNCTION_STORAGE_HPP_ +#include <string_view> #include <vector> -#include "string_view.hpp" - namespace inja { -using json = nlohmann::json; - -using Arguments = std::vector<const json *>; -using CallbackFunction = std::function<json(Arguments &args)>; -using VoidCallbackFunction = std::function<void(Arguments &args)>; +using Arguments = std::vector<const json*>; +using CallbackFunction = std::function<json(Arguments& args)>; +using VoidCallbackFunction = std::function<void(Arguments& args)>; /*! * \brief Class for builtin functions and user-defined callbacks. @@ -64,6 +59,8 @@ public: Round, Sort, Upper, + Super, + Join, Callback, ParenLeft, ParenRight, @@ -71,7 +68,7 @@ public: }; struct FunctionData { - explicit FunctionData(const Operation &op, const CallbackFunction &cb = CallbackFunction{}) : operation(op), callback(cb) {} + explicit FunctionData(const Operation& op, const CallbackFunction& cb = CallbackFunction {}): operation(op), callback(cb) {} const Operation operation; const CallbackFunction callback; }; @@ -80,49 +77,52 @@ private: const int VARIADIC {-1}; std::map<std::pair<std::string, int>, FunctionData> function_storage = { - {std::make_pair("at", 2), FunctionData { Operation::At }}, - {std::make_pair("default", 2), FunctionData { Operation::Default }}, - {std::make_pair("divisibleBy", 2), FunctionData { Operation::DivisibleBy }}, - {std::make_pair("even", 1), FunctionData { Operation::Even }}, - {std::make_pair("exists", 1), FunctionData { Operation::Exists }}, - {std::make_pair("existsIn", 2), FunctionData { Operation::ExistsInObject }}, - {std::make_pair("first", 1), FunctionData { Operation::First }}, - {std::make_pair("float", 1), FunctionData { Operation::Float }}, - {std::make_pair("int", 1), FunctionData { Operation::Int }}, - {std::make_pair("isArray", 1), FunctionData { Operation::IsArray }}, - {std::make_pair("isBoolean", 1), FunctionData { Operation::IsBoolean }}, - {std::make_pair("isFloat", 1), FunctionData { Operation::IsFloat }}, - {std::make_pair("isInteger", 1), FunctionData { Operation::IsInteger }}, - {std::make_pair("isNumber", 1), FunctionData { Operation::IsNumber }}, - {std::make_pair("isObject", 1), FunctionData { Operation::IsObject }}, - {std::make_pair("isString", 1), FunctionData { Operation::IsString }}, - {std::make_pair("last", 1), FunctionData { Operation::Last }}, - {std::make_pair("length", 1), FunctionData { Operation::Length }}, - {std::make_pair("lower", 1), FunctionData { Operation::Lower }}, - {std::make_pair("max", 1), FunctionData { Operation::Max }}, - {std::make_pair("min", 1), FunctionData { Operation::Min }}, - {std::make_pair("odd", 1), FunctionData { Operation::Odd }}, - {std::make_pair("range", 1), FunctionData { Operation::Range }}, - {std::make_pair("round", 2), FunctionData { Operation::Round }}, - {std::make_pair("sort", 1), FunctionData { Operation::Sort }}, - {std::make_pair("upper", 1), FunctionData { Operation::Upper }}, + {std::make_pair("at", 2), FunctionData {Operation::At}}, + {std::make_pair("default", 2), FunctionData {Operation::Default}}, + {std::make_pair("divisibleBy", 2), FunctionData {Operation::DivisibleBy}}, + {std::make_pair("even", 1), FunctionData {Operation::Even}}, + {std::make_pair("exists", 1), FunctionData {Operation::Exists}}, + {std::make_pair("existsIn", 2), FunctionData {Operation::ExistsInObject}}, + {std::make_pair("first", 1), FunctionData {Operation::First}}, + {std::make_pair("float", 1), FunctionData {Operation::Float}}, + {std::make_pair("int", 1), FunctionData {Operation::Int}}, + {std::make_pair("isArray", 1), FunctionData {Operation::IsArray}}, + {std::make_pair("isBoolean", 1), FunctionData {Operation::IsBoolean}}, + {std::make_pair("isFloat", 1), FunctionData {Operation::IsFloat}}, + {std::make_pair("isInteger", 1), FunctionData {Operation::IsInteger}}, + {std::make_pair("isNumber", 1), FunctionData {Operation::IsNumber}}, + {std::make_pair("isObject", 1), FunctionData {Operation::IsObject}}, + {std::make_pair("isString", 1), FunctionData {Operation::IsString}}, + {std::make_pair("last", 1), FunctionData {Operation::Last}}, + {std::make_pair("length", 1), FunctionData {Operation::Length}}, + {std::make_pair("lower", 1), FunctionData {Operation::Lower}}, + {std::make_pair("max", 1), FunctionData {Operation::Max}}, + {std::make_pair("min", 1), FunctionData {Operation::Min}}, + {std::make_pair("odd", 1), FunctionData {Operation::Odd}}, + {std::make_pair("range", 1), FunctionData {Operation::Range}}, + {std::make_pair("round", 2), FunctionData {Operation::Round}}, + {std::make_pair("sort", 1), FunctionData {Operation::Sort}}, + {std::make_pair("upper", 1), FunctionData {Operation::Upper}}, + {std::make_pair("super", 0), FunctionData {Operation::Super}}, + {std::make_pair("super", 1), FunctionData {Operation::Super}}, + {std::make_pair("join", 2), FunctionData {Operation::Join}}, }; public: - void add_builtin(nonstd::string_view name, int num_args, Operation op) { - function_storage.emplace(std::make_pair(static_cast<std::string>(name), num_args), FunctionData { op }); + void add_builtin(std::string_view name, int num_args, Operation op) { + function_storage.emplace(std::make_pair(static_cast<std::string>(name), num_args), FunctionData {op}); } - void add_callback(nonstd::string_view name, int num_args, const CallbackFunction &callback) { - function_storage.emplace(std::make_pair(static_cast<std::string>(name), num_args), FunctionData { Operation::Callback, callback }); + void add_callback(std::string_view name, int num_args, const CallbackFunction& callback) { + function_storage.emplace(std::make_pair(static_cast<std::string>(name), num_args), FunctionData {Operation::Callback, callback}); } - FunctionData find_function(nonstd::string_view name, int num_args) const { + FunctionData find_function(std::string_view name, int num_args) const { auto it = function_storage.find(std::make_pair(static_cast<std::string>(name), num_args)); if (it != function_storage.end()) { return it->second; - // Find variadic function + // Find variadic function } else if (num_args > 0) { it = function_storage.find(std::make_pair(static_cast<std::string>(name), VARIADIC)); if (it != function_storage.end()) { @@ -130,7 +130,7 @@ public: } } - return FunctionData { Operation::None }; + return FunctionData {Operation::None}; } }; diff --git a/include/inja/inja.hpp b/include/inja/inja.hpp index 86b8a0a..381da4b 100644 --- a/include/inja/inja.hpp +++ b/include/inja/inja.hpp @@ -1,22 +1,60 @@ -// Copyright (c) 2020 Pantor. All rights reserved. +/* + ___ _ Version 3.3 + |_ _|_ __ (_) __ _ https://github.com/pantor/inja + | || '_ \ | |/ _` | Licensed under the MIT License <http://opensource.org/licenses/MIT>. + | || | | || | (_| | + |___|_| |_|/ |\__,_| Copyright (c) 2018-2021 Lars Berscheid + |__/ +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. +*/ #ifndef INCLUDE_INJA_INJA_HPP_ #define INCLUDE_INJA_INJA_HPP_ #include <nlohmann/json.hpp> +namespace inja { +#ifndef INJA_DATA_TYPE +using json = nlohmann::json; +#else +using json = INJA_DATA_TYPE; +#endif +} // namespace inja + #if (defined(__cpp_exceptions) || defined(__EXCEPTIONS) || defined(_CPPUNWIND)) && !defined(INJA_NOEXCEPTION) - #define INJA_THROW(exception) throw exception +#ifndef INJA_THROW +#define INJA_THROW(exception) throw exception +#endif #else - #include <cstdlib> - #define INJA_THROW(exception) std::abort() +#include <cstdlib> +#ifndef INJA_THROW +#define INJA_THROW(exception) \ + std::abort(); \ + std::ignore = exception +#endif +#ifndef INJA_NOEXCEPTION +#define INJA_NOEXCEPTION +#endif #endif #include "environment.hpp" #include "exceptions.hpp" #include "parser.hpp" #include "renderer.hpp" -#include "string_view.hpp" #include "template.hpp" #endif // INCLUDE_INJA_INJA_HPP_ diff --git a/include/inja/lexer.hpp b/include/inja/lexer.hpp index e31c3d6..c777600 100644 --- a/include/inja/lexer.hpp +++ b/include/inja/lexer.hpp @@ -1,5 +1,3 @@ -// Copyright (c) 2020 Pantor. All rights reserved. - #ifndef INCLUDE_INJA_LEXER_HPP_ #define INCLUDE_INJA_LEXER_HPP_ @@ -28,6 +26,7 @@ class Lexer { StatementStartForceLstrip, StatementBody, CommentStart, + CommentStartForceLstrip, CommentBody, }; @@ -36,22 +35,21 @@ class Lexer { Number, }; - const LexerConfig &config; + const LexerConfig& config; State state; MinusState minus_state; - nonstd::string_view m_in; + std::string_view m_in; size_t tok_start; size_t pos; - - Token scan_body(nonstd::string_view close, Token::Kind closeKind, nonstd::string_view close_trim = nonstd::string_view(), bool trim = false) { + Token scan_body(std::string_view close, Token::Kind closeKind, std::string_view close_trim = std::string_view(), bool trim = false) { again: // skip whitespace (except for \n as it might be a close) if (tok_start >= m_in.size()) { return make_token(Token::Kind::Eof); } - char ch = m_in[tok_start]; + const char ch = m_in[tok_start]; if (ch == ' ' || ch == '\t' || ch == '\r') { tok_start += 1; goto again; @@ -61,7 +59,7 @@ class Lexer { if (!close_trim.empty() && inja::string_view::starts_with(m_in.substr(tok_start), close_trim)) { state = State::Text; pos = tok_start + close_trim.size(); - Token tok = make_token(closeKind); + const Token tok = make_token(closeKind); skip_whitespaces_and_newlines(); return tok; } @@ -69,7 +67,7 @@ class Lexer { if (inja::string_view::starts_with(m_in.substr(tok_start), close)) { state = State::Text; pos = tok_start + close.size(); - Token tok = make_token(closeKind); + const Token tok = make_token(closeKind); if (trim) { skip_whitespaces_and_first_newline(); } @@ -88,7 +86,7 @@ class Lexer { return scan_id(); } - MinusState current_minus_state = minus_state; + const MinusState current_minus_state = minus_state; if (minus_state == MinusState::Operator) { minus_state = MinusState::Number; } @@ -183,7 +181,7 @@ class Lexer { if (pos >= m_in.size()) { break; } - char ch = m_in[pos]; + const char ch = m_in[pos]; if (!std::isalnum(ch) && ch != '.' && ch != '/' && ch != '_' && ch != '-') { break; } @@ -197,7 +195,7 @@ class Lexer { if (pos >= m_in.size()) { break; } - char ch = m_in[pos]; + const char ch = m_in[pos]; // be very permissive in lexer (we'll catch errors when conversion happens) if (!std::isdigit(ch) && ch != '.' && ch != 'e' && ch != 'E' && ch != '+' && ch != '-') { break; @@ -213,7 +211,7 @@ class Lexer { if (pos >= m_in.size()) { break; } - char ch = m_in[pos++]; + const char ch = m_in[pos++]; if (ch == '\\') { escape = true; } else if (!escape && ch == m_in[tok_start]) { @@ -225,7 +223,9 @@ class Lexer { return make_token(Token::Kind::String); } - Token make_token(Token::Kind kind) const { return Token(kind, string_view::slice(m_in, tok_start, pos)); } + Token make_token(Token::Kind kind) const { + return Token(kind, string_view::slice(m_in, tok_start, pos)); + } void skip_whitespaces_and_newlines() { if (pos < m_in.size()) { @@ -243,7 +243,7 @@ class Lexer { } if (pos < m_in.size()) { - char ch = m_in[pos]; + const char ch = m_in[pos]; if (ch == '\n') { pos += 1; } else if (ch == '\r') { @@ -255,10 +255,10 @@ class Lexer { } } - static nonstd::string_view clear_final_line_if_whitespace(nonstd::string_view text) { - nonstd::string_view result = text; + static std::string_view clear_final_line_if_whitespace(std::string_view text) { + std::string_view result = text; while (!result.empty()) { - char ch = result.back(); + const char ch = result.back(); if (ch == ' ' || ch == '\t') { result.remove_suffix(1); } else if (ch == '\n' || ch == '\r') { @@ -271,13 +271,13 @@ class Lexer { } public: - explicit Lexer(const LexerConfig &config) : config(config), state(State::Text), minus_state(MinusState::Number) {} + explicit Lexer(const LexerConfig& config): config(config), state(State::Text), minus_state(MinusState::Number) {} SourceLocation current_position() const { return get_source_location(m_in, tok_start); } - void start(nonstd::string_view input) { + void start(std::string_view input) { m_in = input; tok_start = 0; pos = 0; @@ -302,8 +302,8 @@ public: default: case State::Text: { // fast-scan to first open character - size_t open_start = m_in.substr(pos).find_first_of(config.open_chars); - if (open_start == nonstd::string_view::npos) { + const size_t open_start = m_in.substr(pos).find_first_of(config.open_chars); + if (open_start == std::string_view::npos) { // didn't find open, return remaining text as text token pos = m_in.size(); return make_token(Token::Kind::Text); @@ -311,7 +311,7 @@ public: pos += open_start; // try to match one of the opening sequences, and get the close - nonstd::string_view open_str = m_in.substr(pos); + std::string_view open_str = m_in.substr(pos); bool must_lstrip = false; if (inja::string_view::starts_with(open_str, config.expression_open)) { if (inja::string_view::starts_with(open_str, config.expression_open_force_lstrip)) { @@ -323,7 +323,7 @@ public: } else if (inja::string_view::starts_with(open_str, config.statement_open)) { if (inja::string_view::starts_with(open_str, config.statement_open_no_lstrip)) { state = State::StatementStartNoLstrip; - } else if (inja::string_view::starts_with(open_str, config.statement_open_force_lstrip )) { + } else if (inja::string_view::starts_with(open_str, config.statement_open_force_lstrip)) { state = State::StatementStartForceLstrip; must_lstrip = true; } else { @@ -331,8 +331,13 @@ public: must_lstrip = config.lstrip_blocks; } } else if (inja::string_view::starts_with(open_str, config.comment_open)) { - state = State::CommentStart; - must_lstrip = config.lstrip_blocks; + if (inja::string_view::starts_with(open_str, config.comment_open_force_lstrip)) { + state = State::CommentStartForceLstrip; + must_lstrip = true; + } else { + state = State::CommentStart; + must_lstrip = config.lstrip_blocks; + } } else if ((pos == 0 || m_in[pos - 1] == '\n') && inja::string_view::starts_with(open_str, config.line_statement)) { state = State::LineStart; } else { @@ -340,7 +345,7 @@ public: goto again; } - nonstd::string_view text = string_view::slice(m_in, tok_start, pos); + std::string_view text = string_view::slice(m_in, tok_start, pos); if (must_lstrip) { text = clear_final_line_if_whitespace(text); } @@ -385,6 +390,11 @@ public: pos += config.comment_open.size(); return make_token(Token::Kind::CommentOpen); } + case State::CommentStartForceLstrip: { + state = State::CommentBody; + pos += config.comment_open_force_lstrip.size(); + return make_token(Token::Kind::CommentOpen); + } case State::ExpressionBody: return scan_body(config.expression_close, Token::Kind::ExpressionClose, config.expression_close_force_rstrip); case State::LineBody: @@ -393,16 +403,21 @@ public: return scan_body(config.statement_close, Token::Kind::StatementClose, config.statement_close_force_rstrip, config.trim_blocks); case State::CommentBody: { // fast-scan to comment close - size_t end = m_in.substr(pos).find(config.comment_close); - if (end == nonstd::string_view::npos) { + const size_t end = m_in.substr(pos).find(config.comment_close); + if (end == std::string_view::npos) { pos = m_in.size(); return make_token(Token::Kind::Eof); } + + // Check for trim pattern + const bool must_rstrip = inja::string_view::starts_with(m_in.substr(pos + end - 1), config.comment_close_force_rstrip); + // return the entire comment in the close token state = State::Text; pos += end + config.comment_close.size(); Token tok = make_token(Token::Kind::CommentClose); - if (config.trim_blocks) { + + if (must_rstrip || config.trim_blocks) { skip_whitespaces_and_first_newline(); } return tok; @@ -410,7 +425,7 @@ public: } } - const LexerConfig &get_config() const { + const LexerConfig& get_config() const { return config; } }; diff --git a/include/inja/node.hpp b/include/inja/node.hpp index 84a8b8a..1946805 100644 --- a/include/inja/node.hpp +++ b/include/inja/node.hpp @@ -1,16 +1,12 @@ -// Copyright (c) 2020 Pantor. All rights reserved. - #ifndef INCLUDE_INJA_NODE_HPP_ #define INCLUDE_INJA_NODE_HPP_ #include <string> +#include <string_view> #include <utility> -#include <nlohmann/json.hpp> - #include "function_storage.hpp" -#include "string_view.hpp" - +#include "utils.hpp" namespace inja { @@ -19,7 +15,7 @@ class BlockNode; class TextNode; class ExpressionNode; class LiteralNode; -class JsonNode; +class DataNode; class FunctionNode; class ExpressionListNode; class StatementNode; @@ -28,16 +24,19 @@ class ForArrayStatementNode; class ForObjectStatementNode; class IfStatementNode; class IncludeStatementNode; +class ExtendsStatementNode; +class BlockStatementNode; class SetStatementNode; - class NodeVisitor { public: + virtual ~NodeVisitor() = default; + virtual void visit(const BlockNode& node) = 0; virtual void visit(const TextNode& node) = 0; virtual void visit(const ExpressionNode& node) = 0; virtual void visit(const LiteralNode& node) = 0; - virtual void visit(const JsonNode& node) = 0; + virtual void visit(const DataNode& node) = 0; virtual void visit(const FunctionNode& node) = 0; virtual void visit(const ExpressionListNode& node) = 0; virtual void visit(const StatementNode& node) = 0; @@ -46,6 +45,8 @@ public: virtual void visit(const ForObjectStatementNode& node) = 0; virtual void visit(const IfStatementNode& node) = 0; virtual void visit(const IncludeStatementNode& node) = 0; + virtual void visit(const ExtendsStatementNode& node) = 0; + virtual void visit(const BlockStatementNode& node) = 0; virtual void visit(const SetStatementNode& node) = 0; }; @@ -58,16 +59,15 @@ public: size_t pos; - AstNode(size_t pos) : pos(pos) { } - virtual ~AstNode() { }; + AstNode(size_t pos): pos(pos) {} + virtual ~AstNode() {} }; - class BlockNode : public AstNode { public: std::vector<std::shared_ptr<AstNode>> nodes; - explicit BlockNode() : AstNode(0) {} + explicit BlockNode(): AstNode(0) {} void accept(NodeVisitor& v) const { v.visit(*this); @@ -78,7 +78,7 @@ class TextNode : public AstNode { public: const size_t length; - explicit TextNode(size_t pos, size_t length): AstNode(pos), length(length) { } + explicit TextNode(size_t pos, size_t length): AstNode(pos), length(length) {} void accept(NodeVisitor& v) const { v.visit(*this); @@ -87,7 +87,7 @@ public: class ExpressionNode : public AstNode { public: - explicit ExpressionNode(size_t pos) : AstNode(pos) {} + explicit ExpressionNode(size_t pos): AstNode(pos) {} void accept(NodeVisitor& v) const { v.visit(*this); @@ -96,24 +96,24 @@ public: class LiteralNode : public ExpressionNode { public: - const nlohmann::json value; + const json value; - explicit LiteralNode(const nlohmann::json& value, size_t pos) : ExpressionNode(pos), value(value) { } + explicit LiteralNode(std::string_view data_text, size_t pos): ExpressionNode(pos), value(json::parse(data_text)) {} void accept(NodeVisitor& v) const { v.visit(*this); } }; -class JsonNode : public ExpressionNode { +class DataNode : public ExpressionNode { public: const std::string name; const json::json_pointer ptr; - static std::string convert_dot_to_json_ptr(nonstd::string_view ptr_name) { + static std::string convert_dot_to_ptr(std::string_view ptr_name) { std::string result; do { - nonstd::string_view part; + std::string_view part; std::tie(part, ptr_name) = string_view::split(ptr_name, '.'); result.push_back('/'); result.append(part.begin(), part.end()); @@ -121,7 +121,7 @@ public: return result; } - explicit JsonNode(nonstd::string_view ptr_name, size_t pos) : ExpressionNode(pos), name(ptr_name), ptr(json::json_pointer(convert_dot_to_json_ptr(ptr_name))) { } + explicit DataNode(std::string_view ptr_name, size_t pos): ExpressionNode(pos), name(ptr_name), ptr(json::json_pointer(convert_dot_to_ptr(ptr_name))) {} void accept(NodeVisitor& v) const { v.visit(*this); @@ -144,83 +144,102 @@ public: std::string name; int number_args; // Should also be negative -> -1 for unknown number + std::vector<std::shared_ptr<ExpressionNode>> arguments; CallbackFunction callback; - explicit FunctionNode(nonstd::string_view name, size_t pos) : ExpressionNode(pos), precedence(8), associativity(Associativity::Left), operation(Op::Callback), name(name), number_args(1) { } - explicit FunctionNode(Op operation, size_t pos) : ExpressionNode(pos), operation(operation), number_args(1) { + explicit FunctionNode(std::string_view name, size_t pos) + : ExpressionNode(pos), precedence(8), associativity(Associativity::Left), operation(Op::Callback), name(name), number_args(1) {} + explicit FunctionNode(Op operation, size_t pos): ExpressionNode(pos), operation(operation), number_args(1) { switch (operation) { - case Op::Not: { - precedence = 4; - associativity = Associativity::Left; - } break; - case Op::And: { - precedence = 1; - associativity = Associativity::Left; - } break; - case Op::Or: { - precedence = 1; - associativity = Associativity::Left; - } break; - case Op::In: { - precedence = 2; - associativity = Associativity::Left; - } break; - case Op::Equal: { - precedence = 2; - associativity = Associativity::Left; - } break; - case Op::NotEqual: { - precedence = 2; - associativity = Associativity::Left; - } break; - case Op::Greater: { - precedence = 2; - associativity = Associativity::Left; - } break; - case Op::GreaterEqual: { - precedence = 2; - associativity = Associativity::Left; - } break; - case Op::Less: { - precedence = 2; - associativity = Associativity::Left; - } break; - case Op::LessEqual: { - precedence = 2; - associativity = Associativity::Left; - } break; - case Op::Add: { - precedence = 3; - associativity = Associativity::Left; - } break; - case Op::Subtract: { - precedence = 3; - associativity = Associativity::Left; - } break; - case Op::Multiplication: { - precedence = 4; - associativity = Associativity::Left; - } break; - case Op::Division: { - precedence = 4; - associativity = Associativity::Left; - } break; - case Op::Power: { - precedence = 5; - associativity = Associativity::Right; - } break; - case Op::Modulo: { - precedence = 4; - associativity = Associativity::Left; - } break; - case Op::AtId: { - precedence = 8; - associativity = Associativity::Left; - } break; - default: { - precedence = 1; - associativity = Associativity::Left; - } + case Op::Not: { + number_args = 1; + precedence = 4; + associativity = Associativity::Left; + } break; + case Op::And: { + number_args = 2; + precedence = 1; + associativity = Associativity::Left; + } break; + case Op::Or: { + number_args = 2; + precedence = 1; + associativity = Associativity::Left; + } break; + case Op::In: { + number_args = 2; + precedence = 2; + associativity = Associativity::Left; + } break; + case Op::Equal: { + number_args = 2; + precedence = 2; + associativity = Associativity::Left; + } break; + case Op::NotEqual: { + number_args = 2; + precedence = 2; + associativity = Associativity::Left; + } break; + case Op::Greater: { + number_args = 2; + precedence = 2; + associativity = Associativity::Left; + } break; + case Op::GreaterEqual: { + number_args = 2; + precedence = 2; + associativity = Associativity::Left; + } break; + case Op::Less: { + number_args = 2; + precedence = 2; + associativity = Associativity::Left; + } break; + case Op::LessEqual: { + number_args = 2; + precedence = 2; + associativity = Associativity::Left; + } break; + case Op::Add: { + number_args = 2; + precedence = 3; + associativity = Associativity::Left; + } break; + case Op::Subtract: { + number_args = 2; + precedence = 3; + associativity = Associativity::Left; + } break; + case Op::Multiplication: { + number_args = 2; + precedence = 4; + associativity = Associativity::Left; + } break; + case Op::Division: { + number_args = 2; + precedence = 4; + associativity = Associativity::Left; + } break; + case Op::Power: { + number_args = 2; + precedence = 5; + associativity = Associativity::Right; + } break; + case Op::Modulo: { + number_args = 2; + precedence = 4; + associativity = Associativity::Left; + } break; + case Op::AtId: { + number_args = 2; + precedence = 8; + associativity = Associativity::Left; + } break; + default: { + precedence = 1; + associativity = Associativity::Left; + } } } @@ -231,10 +250,10 @@ public: class ExpressionListNode : public AstNode { public: - std::vector<std::shared_ptr<ExpressionNode>> rpn_output; + std::shared_ptr<ExpressionNode> root; - explicit ExpressionListNode() : AstNode(0) { } - explicit ExpressionListNode(size_t pos) : AstNode(pos) { } + explicit ExpressionListNode(): AstNode(0) {} + explicit ExpressionListNode(size_t pos): AstNode(pos) {} void accept(NodeVisitor& v) const { v.visit(*this); @@ -243,7 +262,7 @@ public: class StatementNode : public AstNode { public: - StatementNode(size_t pos) : AstNode(pos) { } + StatementNode(size_t pos): AstNode(pos) {} virtual void accept(NodeVisitor& v) const = 0; }; @@ -252,9 +271,9 @@ class ForStatementNode : public StatementNode { public: ExpressionListNode condition; BlockNode body; - BlockNode *const parent; + BlockNode* const parent; - ForStatementNode(BlockNode *const parent, size_t pos) : StatementNode(pos), parent(parent) { } + ForStatementNode(BlockNode* const parent, size_t pos): StatementNode(pos), parent(parent) {} virtual void accept(NodeVisitor& v) const = 0; }; @@ -263,7 +282,7 @@ class ForArrayStatementNode : public ForStatementNode { public: const std::string value; - explicit ForArrayStatementNode(const std::string& value, BlockNode *const parent, size_t pos) : ForStatementNode(parent, pos), value(value) { } + explicit ForArrayStatementNode(const std::string& value, BlockNode* const parent, size_t pos): ForStatementNode(parent, pos), value(value) {} void accept(NodeVisitor& v) const { v.visit(*this); @@ -275,7 +294,8 @@ public: const std::string key; const std::string value; - explicit ForObjectStatementNode(const std::string& key, const std::string& value, BlockNode *const parent, size_t pos) : ForStatementNode(parent, pos), key(key), value(value) { } + explicit ForObjectStatementNode(const std::string& key, const std::string& value, BlockNode* const parent, size_t pos) + : ForStatementNode(parent, pos), key(key), value(value) {} void accept(NodeVisitor& v) const { v.visit(*this); @@ -287,13 +307,13 @@ public: ExpressionListNode condition; BlockNode true_statement; BlockNode false_statement; - BlockNode *const parent; + BlockNode* const parent; const bool is_nested; bool has_false_statement {false}; - explicit IfStatementNode(BlockNode *const parent, size_t pos) : StatementNode(pos), parent(parent), is_nested(false) { } - explicit IfStatementNode(bool is_nested, BlockNode *const parent, size_t pos) : StatementNode(pos), parent(parent), is_nested(is_nested) { } + explicit IfStatementNode(BlockNode* const parent, size_t pos): StatementNode(pos), parent(parent), is_nested(false) {} + explicit IfStatementNode(bool is_nested, BlockNode* const parent, size_t pos): StatementNode(pos), parent(parent), is_nested(is_nested) {} void accept(NodeVisitor& v) const { v.visit(*this); @@ -304,7 +324,31 @@ class IncludeStatementNode : public StatementNode { public: const std::string file; - explicit IncludeStatementNode(const std::string& file, size_t pos) : StatementNode(pos), file(file) { } + explicit IncludeStatementNode(const std::string& file, size_t pos): StatementNode(pos), file(file) {} + + void accept(NodeVisitor& v) const { + v.visit(*this); + } +}; + +class ExtendsStatementNode : public StatementNode { +public: + const std::string file; + + explicit ExtendsStatementNode(const std::string& file, size_t pos): StatementNode(pos), file(file) {} + + void accept(NodeVisitor& v) const { + v.visit(*this); + }; +}; + +class BlockStatementNode : public StatementNode { +public: + const std::string name; + BlockNode block; + BlockNode* const parent; + + explicit BlockStatementNode(BlockNode* const parent, const std::string& name, size_t pos): StatementNode(pos), name(name), parent(parent) {} void accept(NodeVisitor& v) const { v.visit(*this); @@ -316,11 +360,11 @@ public: const std::string key; ExpressionListNode expression; - explicit SetStatementNode(const std::string& key, size_t pos) : StatementNode(pos), key(key) { } + explicit SetStatementNode(const std::string& key, size_t pos): StatementNode(pos), key(key) {} void accept(NodeVisitor& v) const { v.visit(*this); - }; + } }; } // namespace inja diff --git a/include/inja/parser.hpp b/include/inja/parser.hpp index 6266c4a..3ea1793 100644 --- a/include/inja/parser.hpp +++ b/include/inja/parser.hpp @@ -1,5 +1,3 @@ -// Copyright (c) 2020 Pantor. All rights reserved. - #ifndef INCLUDE_INJA_PARSER_HPP_ #define INCLUDE_INJA_PARSER_HPP_ @@ -7,7 +5,6 @@ #include <stack> #include <string> #include <utility> -#include <queue> #include <vector> #include "config.hpp" @@ -19,19 +16,17 @@ #include "token.hpp" #include "utils.hpp" -#include <nlohmann/json.hpp> - namespace inja { /*! * \brief Class for parsing an inja Template. */ class Parser { - const ParserConfig &config; + const ParserConfig& config; Lexer lexer; - TemplateStorage &template_storage; - const FunctionStorage &function_storage; + TemplateStorage& template_storage; + const FunctionStorage& function_storage; Token tok, peek_tok; bool have_peek_tok {false}; @@ -40,21 +35,23 @@ class Parser { size_t current_bracket_level {0}; size_t current_brace_level {0}; - nonstd::string_view json_literal_start; + std::string_view literal_start; - BlockNode *current_block {nullptr}; - ExpressionListNode *current_expression_list {nullptr}; + BlockNode* current_block {nullptr}; + ExpressionListNode* current_expression_list {nullptr}; std::stack<std::pair<FunctionNode*, size_t>> function_stack; + std::vector<std::shared_ptr<ExpressionNode>> arguments; std::stack<std::shared_ptr<FunctionNode>> operator_stack; std::stack<IfStatementNode*> if_statement_stack; std::stack<ForStatementNode*> for_statement_stack; + std::stack<BlockStatementNode*> block_statement_stack; - void throw_parser_error(const std::string &message) { + inline void throw_parser_error(const std::string& message) const { INJA_THROW(ParserError(message, lexer.current_position())); } - void get_next_token() { + inline void get_next_token() { if (have_peek_tok) { tok = peek_tok; have_peek_tok = false; @@ -63,49 +60,108 @@ class Parser { } } - void get_peek_token() { + inline void get_peek_token() { if (!have_peek_tok) { peek_tok = lexer.scan(); have_peek_tok = true; } } - void add_json_literal(const char* content_ptr) { - nonstd::string_view json_text(json_literal_start.data(), tok.text.data() - json_literal_start.data() + tok.text.size()); - current_expression_list->rpn_output.emplace_back(std::make_shared<LiteralNode>(json::parse(json_text), json_text.data() - content_ptr)); + inline void add_literal(const char* content_ptr) { + std::string_view data_text(literal_start.data(), tok.text.data() - literal_start.data() + tok.text.size()); + arguments.emplace_back(std::make_shared<LiteralNode>(data_text, data_text.data() - content_ptr)); + } + + inline void add_operator() { + auto function = operator_stack.top(); + operator_stack.pop(); + + for (int i = 0; i < function->number_args; ++i) { + function->arguments.insert(function->arguments.begin(), arguments.back()); + arguments.pop_back(); + } + arguments.emplace_back(function); + } + + void add_to_template_storage(std::string_view path, std::string& template_name) { + if (template_storage.find(template_name) != template_storage.end()) { + return; + } + + std::string original_path = static_cast<std::string>(path); + std::string original_name = template_name; + + if (config.search_included_templates_in_files) { + // Build the relative path + template_name = original_path + original_name; + if (template_name.compare(0, 2, "./") == 0) { + template_name.erase(0, 2); + } + + if (template_storage.find(template_name) == template_storage.end()) { + // Load file + std::ifstream file; + file.open(template_name); + if (!file.fail()) { + std::string text((std::istreambuf_iterator<char>(file)), std::istreambuf_iterator<char>()); + + auto include_template = Template(text); + template_storage.emplace(template_name, include_template); + parse_into_template(template_storage[template_name], template_name); + return; + } else if (!config.include_callback) { + INJA_THROW(FileError("failed accessing file at '" + template_name + "'")); + } + } + } + + // Try include callback + if (config.include_callback) { + auto include_template = config.include_callback(original_path, original_name); + template_storage.emplace(template_name, include_template); + } + } + + std::string parse_filename(const Token& tok) const { + if (tok.kind != Token::Kind::String) { + throw_parser_error("expected string, got '" + tok.describe() + "'"); + } + + if (tok.text.length() < 2) { + throw_parser_error("expected filename, got '" + static_cast<std::string>(tok.text) + "'"); + } + + // Remove first and last character "" + return std::string {tok.text.substr(1, tok.text.length() - 2)}; } - bool parse_expression(Template &tmpl, Token::Kind closing) { + bool parse_expression(Template& tmpl, Token::Kind closing) { while (tok.kind != closing && tok.kind != Token::Kind::Eof) { // Literals switch (tok.kind) { case Token::Kind::String: { if (current_brace_level == 0 && current_bracket_level == 0) { - json_literal_start = tok.text; - add_json_literal(tmpl.content.c_str()); + literal_start = tok.text; + add_literal(tmpl.content.c_str()); } - } break; case Token::Kind::Number: { if (current_brace_level == 0 && current_bracket_level == 0) { - json_literal_start = tok.text; - add_json_literal(tmpl.content.c_str()); + literal_start = tok.text; + add_literal(tmpl.content.c_str()); } - } break; case Token::Kind::LeftBracket: { if (current_brace_level == 0 && current_bracket_level == 0) { - json_literal_start = tok.text; + literal_start = tok.text; } current_bracket_level += 1; - } break; case Token::Kind::LeftBrace: { if (current_brace_level == 0 && current_bracket_level == 0) { - json_literal_start = tok.text; + literal_start = tok.text; } current_brace_level += 1; - } break; case Token::Kind::RightBracket: { if (current_bracket_level == 0) { @@ -114,9 +170,8 @@ class Parser { current_bracket_level -= 1; if (current_brace_level == 0 && current_bracket_level == 0) { - add_json_literal(tmpl.content.c_str()); + add_literal(tmpl.content.c_str()); } - } break; case Token::Kind::RightBrace: { if (current_brace_level == 0) { @@ -125,35 +180,35 @@ class Parser { current_brace_level -= 1; if (current_brace_level == 0 && current_bracket_level == 0) { - add_json_literal(tmpl.content.c_str()); + add_literal(tmpl.content.c_str()); } - } break; case Token::Kind::Id: { get_peek_token(); - // Json Literal - if (tok.text == static_cast<decltype(tok.text)>("true") || tok.text == static_cast<decltype(tok.text)>("false") || tok.text == static_cast<decltype(tok.text)>("null")) { + // Data Literal + if (tok.text == static_cast<decltype(tok.text)>("true") || tok.text == static_cast<decltype(tok.text)>("false") || + tok.text == static_cast<decltype(tok.text)>("null")) { if (current_brace_level == 0 && current_bracket_level == 0) { - json_literal_start = tok.text; - add_json_literal(tmpl.content.c_str()); + literal_start = tok.text; + add_literal(tmpl.content.c_str()); } - // Operator + // Operator } else if (tok.text == "and" || tok.text == "or" || tok.text == "in" || tok.text == "not") { goto parse_operator; - // Functions + // Functions } else if (peek_tok.kind == Token::Kind::LeftParen) { operator_stack.emplace(std::make_shared<FunctionNode>(static_cast<std::string>(tok.text), tok.text.data() - tmpl.content.c_str())); - function_stack.emplace(operator_stack.top().get(), current_paren_level); + function_stack.emplace(operator_stack.top().get(), current_paren_level); - // Variables + // Variables } else { - current_expression_list->rpn_output.emplace_back(std::make_shared<JsonNode>(static_cast<std::string>(tok.text), tok.text.data() - tmpl.content.c_str())); + arguments.emplace_back(std::make_shared<DataNode>(static_cast<std::string>(tok.text), tok.text.data() - tmpl.content.c_str())); } - // Operators + // Operators } break; case Token::Kind::Equal: case Token::Kind::NotEqual: @@ -169,7 +224,7 @@ class Parser { case Token::Kind::Percent: case Token::Kind::Dot: { - parse_operator: + parse_operator: FunctionStorage::Operation operation; switch (tok.kind) { case Token::Kind::Id: { @@ -230,13 +285,14 @@ class Parser { } auto function_node = std::make_shared<FunctionNode>(operation, tok.text.data() - tmpl.content.c_str()); - while (!operator_stack.empty() && ((operator_stack.top()->precedence > function_node->precedence) || (operator_stack.top()->precedence == function_node->precedence && function_node->associativity == FunctionNode::Associativity::Left)) && (operator_stack.top()->operation != FunctionStorage::Operation::ParenLeft)) { - current_expression_list->rpn_output.emplace_back(operator_stack.top()); - operator_stack.pop(); + while (!operator_stack.empty() && + ((operator_stack.top()->precedence > function_node->precedence) || + (operator_stack.top()->precedence == function_node->precedence && function_node->associativity == FunctionNode::Associativity::Left)) && + (operator_stack.top()->operation != FunctionStorage::Operation::ParenLeft)) { + add_operator(); } operator_stack.emplace(function_node); - } break; case Token::Kind::Comma: { if (current_brace_level == 0 && current_bracket_level == 0) { @@ -246,13 +302,11 @@ class Parser { function_stack.top().first->number_args += 1; } - } break; case Token::Kind::Colon: { if (current_brace_level == 0 && current_bracket_level == 0) { throw_parser_error("unexpected ':'"); } - } break; case Token::Kind::LeftParen: { current_paren_level += 1; @@ -264,13 +318,11 @@ class Parser { function_stack.top().first->number_args = 0; } } - } break; case Token::Kind::RightParen: { current_paren_level -= 1; while (!operator_stack.empty() && operator_stack.top()->operation != FunctionStorage::Operation::ParenLeft) { - current_expression_list->rpn_output.emplace_back(operator_stack.top()); - operator_stack.pop(); + add_operator(); } if (!operator_stack.empty() && operator_stack.top()->operation == FunctionStorage::Operation::ParenLeft) { @@ -292,8 +344,7 @@ class Parser { throw_parser_error("internal error at function " + func->name); } - current_expression_list->rpn_output.emplace_back(operator_stack.top()); - operator_stack.pop(); + add_operator(); function_stack.pop(); } } @@ -305,14 +356,20 @@ class Parser { } while (!operator_stack.empty()) { - current_expression_list->rpn_output.emplace_back(operator_stack.top()); - operator_stack.pop(); + add_operator(); + } + + if (arguments.size() == 1) { + current_expression_list->root = arguments[0]; + arguments = {}; + } else if (arguments.size() > 1) { + throw_parser_error("malformed expression"); } return true; } - bool parse_statement(Template &tmpl, Token::Kind closing, nonstd::string_view path) { + bool parse_statement(Template& tmpl, Token::Kind closing, std::string_view path) { if (tok.kind != Token::Kind::Id) { return false; } @@ -329,12 +386,11 @@ class Parser { if (!parse_expression(tmpl, closing)) { return false; } - } else if (tok.text == static_cast<decltype(tok.text)>("else")) { if (if_statement_stack.empty()) { throw_parser_error("else without matching if"); } - auto &if_statement_data = if_statement_stack.top(); + auto& if_statement_data = if_statement_stack.top(); get_next_token(); if_statement_data->has_false_statement = true; @@ -354,7 +410,6 @@ class Parser { return false; } } - } else if (tok.text == static_cast<decltype(tok.text)>("endif")) { if (if_statement_stack.empty()) { throw_parser_error("endif without matching if"); @@ -365,12 +420,40 @@ class Parser { if_statement_stack.pop(); } - auto &if_statement_data = if_statement_stack.top(); + auto& if_statement_data = if_statement_stack.top(); get_next_token(); current_block = if_statement_data->parent; if_statement_stack.pop(); + } else if (tok.text == static_cast<decltype(tok.text)>("block")) { + get_next_token(); + + if (tok.kind != Token::Kind::Id) { + throw_parser_error("expected block name, got '" + tok.describe() + "'"); + } + + const std::string block_name = static_cast<std::string>(tok.text); + + auto block_statement_node = std::make_shared<BlockStatementNode>(current_block, block_name, tok.text.data() - tmpl.content.c_str()); + current_block->nodes.emplace_back(block_statement_node); + block_statement_stack.emplace(block_statement_node.get()); + current_block = &block_statement_node->block; + auto success = tmpl.block_storage.emplace(block_name, block_statement_node); + if (!success.second) { + throw_parser_error("block with the name '" + block_name + "' does already exist"); + } + + get_next_token(); + } else if (tok.text == static_cast<decltype(tok.text)>("endblock")) { + if (block_statement_stack.empty()) { + throw_parser_error("endblock without matching block"); + } + + auto& block_statement_data = block_statement_stack.top(); + get_next_token(); + current_block = block_statement_data->parent; + block_statement_stack.pop(); } else if (tok.text == static_cast<decltype(tok.text)>("for")) { get_next_token(); @@ -394,11 +477,13 @@ class Parser { value_token = tok; get_next_token(); - for_statement_node = std::make_shared<ForObjectStatementNode>(static_cast<std::string>(key_token.text), static_cast<std::string>(value_token.text), current_block, tok.text.data() - tmpl.content.c_str()); + for_statement_node = std::make_shared<ForObjectStatementNode>(static_cast<std::string>(key_token.text), static_cast<std::string>(value_token.text), + current_block, tok.text.data() - tmpl.content.c_str()); - // Array type + // Array type } else { - for_statement_node = std::make_shared<ForArrayStatementNode>(static_cast<std::string>(value_token.text), current_block, tok.text.data() - tmpl.content.c_str()); + for_statement_node = + std::make_shared<ForArrayStatementNode>(static_cast<std::string>(value_token.text), current_block, tok.text.data() - tmpl.content.c_str()); } current_block->nodes.emplace_back(for_statement_node); @@ -414,44 +499,34 @@ class Parser { if (!parse_expression(tmpl, closing)) { return false; } - } else if (tok.text == static_cast<decltype(tok.text)>("endfor")) { if (for_statement_stack.empty()) { throw_parser_error("endfor without matching for"); } - auto &for_statement_data = for_statement_stack.top(); + auto& for_statement_data = for_statement_stack.top(); get_next_token(); current_block = for_statement_data->parent; for_statement_stack.pop(); - } else if (tok.text == static_cast<decltype(tok.text)>("include")) { get_next_token(); - if (tok.kind != Token::Kind::String) { - throw_parser_error("expected string, got '" + tok.describe() + "'"); - } + std::string template_name = parse_filename(tok); + add_to_template_storage(path, template_name); - // Build the relative path - json json_name = json::parse(tok.text); - std::string pathname = static_cast<std::string>(path); - pathname += json_name.get_ref<const std::string &>(); - if (pathname.compare(0, 2, "./") == 0) { - pathname.erase(0, 2); - } - // sys::path::remove_dots(pathname, true, sys::path::Style::posix); + current_block->nodes.emplace_back(std::make_shared<IncludeStatementNode>(template_name, tok.text.data() - tmpl.content.c_str())); - if (config.search_included_templates_in_files && template_storage.find(pathname) == template_storage.end()) { - auto include_template = Template(load_file(pathname)); - template_storage.emplace(pathname, include_template); - parse_into_template(template_storage[pathname], pathname); - } + get_next_token(); + } else if (tok.text == static_cast<decltype(tok.text)>("extends")) { + get_next_token(); - current_block->nodes.emplace_back(std::make_shared<IncludeStatementNode>(pathname, tok.text.data() - tmpl.content.c_str())); + std::string template_name = parse_filename(tok); + add_to_template_storage(path, template_name); - get_next_token(); + current_block->nodes.emplace_back(std::make_shared<ExtendsStatementNode>(template_name, tok.text.data() - tmpl.content.c_str())); + get_next_token(); } else if (tok.text == static_cast<decltype(tok.text)>("set")) { get_next_token(); @@ -474,14 +549,13 @@ class Parser { if (!parse_expression(tmpl, closing)) { return false; } - } else { return false; } return true; } - void parse_into(Template &tmpl, nonstd::string_view path) { + void parse_into(Template& tmpl, std::string_view path) { lexer.start(tmpl.content); current_block = &tmpl.root; @@ -495,7 +569,8 @@ class Parser { if (!for_statement_stack.empty()) { throw_parser_error("unmatched for"); } - } return; + } + return; case Token::Kind::Text: { current_block->nodes.emplace_back(std::make_shared<TextNode>(tok.text.data() - tmpl.content.c_str(), tok.text.size())); } break; @@ -545,33 +620,35 @@ class Parser { } } - public: - explicit Parser(const ParserConfig &parser_config, const LexerConfig &lexer_config, - TemplateStorage &template_storage, const FunctionStorage &function_storage) - : config(parser_config), lexer(lexer_config), template_storage(template_storage), function_storage(function_storage) { } + explicit Parser(const ParserConfig& parser_config, const LexerConfig& lexer_config, TemplateStorage& template_storage, + const FunctionStorage& function_storage) + : config(parser_config), lexer(lexer_config), template_storage(template_storage), function_storage(function_storage) {} - Template parse(nonstd::string_view input, nonstd::string_view path) { + Template parse(std::string_view input, std::string_view path) { auto result = Template(static_cast<std::string>(input)); parse_into(result, path); return result; } - Template parse(nonstd::string_view input) { + Template parse(std::string_view input) { return parse(input, "./"); } - void parse_into_template(Template& tmpl, nonstd::string_view filename) { - nonstd::string_view path = filename.substr(0, filename.find_last_of("/\\") + 1); + void parse_into_template(Template& tmpl, std::string_view filename) { + std::string_view path = filename.substr(0, filename.find_last_of("/\\") + 1); // StringRef path = sys::path::parent_path(filename); auto sub_parser = Parser(config, lexer.get_config(), template_storage, function_storage); sub_parser.parse_into(tmpl, path); } - std::string load_file(nonstd::string_view filename) { + std::string load_file(const std::string& filename) { std::ifstream file; - open_file_or_throw(static_cast<std::string>(filename), file); + file.open(filename); + if (file.fail()) { + INJA_THROW(FileError("failed accessing file at '" + filename + "'")); + } std::string text((std::istreambuf_iterator<char>(file)), std::istreambuf_iterator<char>()); return text; } diff --git a/include/inja/renderer.hpp b/include/inja/renderer.hpp index 7bc518f..f24bb91 100644 --- a/include/inja/renderer.hpp +++ b/include/inja/renderer.hpp @@ -1,5 +1,3 @@ -// Copyright (c) 2020 Pantor. All rights reserved. - #ifndef INCLUDE_INJA_RENDERER_HPP_ #define INCLUDE_INJA_RENDERER_HPP_ @@ -9,8 +7,6 @@ #include <utility> #include <vector> -#include <nlohmann/json.hpp> - #include "config.hpp" #include "exceptions.hpp" #include "node.hpp" @@ -22,25 +18,31 @@ namespace inja { /*! * \brief Class for rendering a Template with data. */ -class Renderer : public NodeVisitor { +class Renderer : public NodeVisitor { using Op = FunctionStorage::Operation; const RenderConfig config; - const Template *current_template; - const TemplateStorage &template_storage; - const FunctionStorage &function_storage; + const TemplateStorage& template_storage; + const FunctionStorage& function_storage; + + const Template* current_template; + size_t current_level {0}; + std::vector<const Template*> template_stack; + std::vector<const BlockStatementNode*> block_statement_stack; - const json *json_input; - std::ostream *output_stream; + const json* data_input; + std::ostream* output_stream; - json json_additional_data; - json* current_loop_data = &json_additional_data["loop"]; + json additional_data; + json* current_loop_data = &additional_data["loop"]; - std::vector<std::shared_ptr<json>> json_tmp_stack; - std::stack<const json*> json_eval_stack; - std::stack<const JsonNode*> not_found_stack; + std::vector<std::shared_ptr<json>> data_tmp_stack; + std::stack<const json*> data_eval_stack; + std::stack<const DataNode*> not_found_stack; - bool truthy(const json* data) const { + bool break_rendering {false}; + + static bool truthy(const json* data) { if (data->is_boolean()) { return data->get<bool>(); } else if (data->is_number()) { @@ -51,7 +53,7 @@ class Renderer : public NodeVisitor { return !data->empty(); } - void print_json(const std::shared_ptr<json> value) { + void print_data(const std::shared_ptr<json> value) { if (value->is_string()) { *output_stream << value->get_ref<const json::string_t&>(); } else if (value->is_number_integer()) { @@ -63,18 +65,20 @@ class Renderer : public NodeVisitor { } const std::shared_ptr<json> eval_expression_list(const ExpressionListNode& expression_list) { - for (auto& expression : expression_list.rpn_output) { - expression->accept(*this); + if (!expression_list.root) { + throw_renderer_error("empty expression", expression_list); } - if (json_eval_stack.empty()) { + expression_list.root->accept(*this); + + if (data_eval_stack.empty()) { throw_renderer_error("empty expression", expression_list); - } else if (json_eval_stack.size() != 1) { + } else if (data_eval_stack.size() != 1) { throw_renderer_error("malformed expression", expression_list); } - auto result = json_eval_stack.top(); - json_eval_stack.pop(); + const auto result = data_eval_stack.top(); + data_eval_stack.pop(); if (!result) { if (not_found_stack.empty()) { @@ -89,51 +93,68 @@ class Renderer : public NodeVisitor { return std::make_shared<json>(*result); } - void throw_renderer_error(const std::string &message, const AstNode& node) { + void throw_renderer_error(const std::string& message, const AstNode& node) { SourceLocation loc = get_source_location(current_template->content, node.pos); INJA_THROW(RenderError(message, loc)); } - template<size_t N, bool throw_not_found=true> - std::array<const json*, N> get_arguments(const AstNode& node) { - if (json_eval_stack.size() < N) { - throw_renderer_error("function needs " + std::to_string(N) + " variables, but has only found " + std::to_string(json_eval_stack.size()), node); + void make_result(const json&& result) { + auto result_ptr = std::make_shared<json>(result); + data_tmp_stack.push_back(result_ptr); + data_eval_stack.push(result_ptr.get()); + } + + template <size_t N, size_t N_start = 0, bool throw_not_found = true> std::array<const json*, N> get_arguments(const FunctionNode& node) { + if (node.arguments.size() < N_start + N) { + throw_renderer_error("function needs " + std::to_string(N_start + N) + " variables, but has only found " + std::to_string(node.arguments.size()), node); + } + + for (size_t i = N_start; i < N_start + N; i += 1) { + node.arguments[i]->accept(*this); + } + + if (data_eval_stack.size() < N) { + throw_renderer_error("function needs " + std::to_string(N) + " variables, but has only found " + std::to_string(data_eval_stack.size()), node); } std::array<const json*, N> result; for (size_t i = 0; i < N; i += 1) { - result[N - i - 1] = json_eval_stack.top(); - json_eval_stack.pop(); + result[N - i - 1] = data_eval_stack.top(); + data_eval_stack.pop(); if (!result[N - i - 1]) { - auto json_node = not_found_stack.top(); + const auto data_node = not_found_stack.top(); not_found_stack.pop(); if (throw_not_found) { - throw_renderer_error("variable '" + static_cast<std::string>(json_node->name) + "' not found", *json_node); + throw_renderer_error("variable '" + static_cast<std::string>(data_node->name) + "' not found", *data_node); } } } return result; } - template<bool throw_not_found=true> - Arguments get_argument_vector(size_t N, const AstNode& node) { - if (json_eval_stack.size() < N) { - throw_renderer_error("function needs " + std::to_string(N) + " variables, but has only found " + std::to_string(json_eval_stack.size()), node); + template <bool throw_not_found = true> Arguments get_argument_vector(const FunctionNode& node) { + const size_t N = node.arguments.size(); + for (auto a : node.arguments) { + a->accept(*this); + } + + if (data_eval_stack.size() < N) { + throw_renderer_error("function needs " + std::to_string(N) + " variables, but has only found " + std::to_string(data_eval_stack.size()), node); } Arguments result {N}; for (size_t i = 0; i < N; i += 1) { - result[N - i - 1] = json_eval_stack.top(); - json_eval_stack.pop(); + result[N - i - 1] = data_eval_stack.top(); + data_eval_stack.pop(); if (!result[N - i - 1]) { - auto json_node = not_found_stack.top(); + const auto data_node = not_found_stack.top(); not_found_stack.pop(); if (throw_not_found) { - throw_renderer_error("variable '" + static_cast<std::string>(json_node->name) + "' not found", *json_node); + throw_renderer_error("variable '" + static_cast<std::string>(data_node->name) + "' not found", *data_node); } } } @@ -143,6 +164,10 @@ class Renderer : public NodeVisitor { void visit(const BlockNode& node) { for (auto& n : node.nodes) { n->accept(*this); + + if (break_rendering) { + break; + } } } @@ -150,325 +175,294 @@ class Renderer : public NodeVisitor { output_stream->write(current_template->content.c_str() + node.pos, node.length); } - void visit(const ExpressionNode&) { } + void visit(const ExpressionNode&) {} void visit(const LiteralNode& node) { - json_eval_stack.push(&node.value); + data_eval_stack.push(&node.value); } - void visit(const JsonNode& node) { - if (json_additional_data.contains(node.ptr)) { - json_eval_stack.push(&(json_additional_data[node.ptr])); - - } else if (json_input->contains(node.ptr)) { - json_eval_stack.push(&(*json_input)[node.ptr]); - + void visit(const DataNode& node) { + if (additional_data.contains(node.ptr)) { + data_eval_stack.push(&(additional_data[node.ptr])); + } else if (data_input->contains(node.ptr)) { + data_eval_stack.push(&(*data_input)[node.ptr]); } else { // Try to evaluate as a no-argument callback - auto function_data = function_storage.find_function(node.name, 0); + const auto function_data = function_storage.find_function(node.name, 0); if (function_data.operation == FunctionStorage::Operation::Callback) { Arguments empty_args {}; - auto value = std::make_shared<json>(function_data.callback(empty_args)); - json_tmp_stack.push_back(value); - json_eval_stack.push(value.get()); - + const auto value = std::make_shared<json>(function_data.callback(empty_args)); + data_tmp_stack.push_back(value); + data_eval_stack.push(value.get()); } else { - json_eval_stack.push(nullptr); + data_eval_stack.push(nullptr); not_found_stack.emplace(&node); } } } void visit(const FunctionNode& node) { - std::shared_ptr<json> result_ptr; - switch (node.operation) { case Op::Not: { - auto args = get_arguments<1>(node); - result_ptr = std::make_shared<json>(!truthy(args[0])); - json_tmp_stack.push_back(result_ptr); - json_eval_stack.push(result_ptr.get()); + const auto args = get_arguments<1>(node); + make_result(!truthy(args[0])); } break; case Op::And: { - auto args = get_arguments<2>(node); - result_ptr = std::make_shared<json>(truthy(args[0]) && truthy(args[1])); - json_tmp_stack.push_back(result_ptr); - json_eval_stack.push(result_ptr.get()); + make_result(truthy(get_arguments<1, 0>(node)[0]) && truthy(get_arguments<1, 1>(node)[0])); } break; case Op::Or: { - auto args = get_arguments<2>(node); - result_ptr = std::make_shared<json>(truthy(args[0]) || truthy(args[1])); - json_tmp_stack.push_back(result_ptr); - json_eval_stack.push(result_ptr.get()); + make_result(truthy(get_arguments<1, 0>(node)[0]) || truthy(get_arguments<1, 1>(node)[0])); } break; case Op::In: { - auto args = get_arguments<2>(node); - result_ptr = std::make_shared<json>(std::find(args[1]->begin(), args[1]->end(), *args[0]) != args[1]->end()); - json_tmp_stack.push_back(result_ptr); - json_eval_stack.push(result_ptr.get()); + const auto args = get_arguments<2>(node); + make_result(std::find(args[1]->begin(), args[1]->end(), *args[0]) != args[1]->end()); } break; case Op::Equal: { - auto args = get_arguments<2>(node); - result_ptr = std::make_shared<json>(*args[0] == *args[1]); - json_tmp_stack.push_back(result_ptr); - json_eval_stack.push(result_ptr.get()); + const auto args = get_arguments<2>(node); + make_result(*args[0] == *args[1]); } break; case Op::NotEqual: { - auto args = get_arguments<2>(node); - result_ptr = std::make_shared<json>(*args[0] != *args[1]); - json_tmp_stack.push_back(result_ptr); - json_eval_stack.push(result_ptr.get()); + const auto args = get_arguments<2>(node); + make_result(*args[0] != *args[1]); } break; case Op::Greater: { - auto args = get_arguments<2>(node); - result_ptr = std::make_shared<json>(*args[0] > *args[1]); - json_tmp_stack.push_back(result_ptr); - json_eval_stack.push(result_ptr.get()); + const auto args = get_arguments<2>(node); + make_result(*args[0] > *args[1]); } break; case Op::GreaterEqual: { - auto args = get_arguments<2>(node); - result_ptr = std::make_shared<json>(*args[0] >= *args[1]); - json_tmp_stack.push_back(result_ptr); - json_eval_stack.push(result_ptr.get()); + const auto args = get_arguments<2>(node); + make_result(*args[0] >= *args[1]); } break; case Op::Less: { - auto args = get_arguments<2>(node); - result_ptr = std::make_shared<json>(*args[0] < *args[1]); - json_tmp_stack.push_back(result_ptr); - json_eval_stack.push(result_ptr.get()); + const auto args = get_arguments<2>(node); + make_result(*args[0] < *args[1]); } break; case Op::LessEqual: { - auto args = get_arguments<2>(node); - result_ptr = std::make_shared<json>(*args[0] <= *args[1]); - json_tmp_stack.push_back(result_ptr); - json_eval_stack.push(result_ptr.get()); + const auto args = get_arguments<2>(node); + make_result(*args[0] <= *args[1]); } break; case Op::Add: { - auto args = get_arguments<2>(node); + const auto args = get_arguments<2>(node); if (args[0]->is_string() && args[1]->is_string()) { - result_ptr = std::make_shared<json>(args[0]->get_ref<const std::string&>() + args[1]->get_ref<const std::string&>()); - json_tmp_stack.push_back(result_ptr); + make_result(args[0]->get_ref<const std::string&>() + args[1]->get_ref<const std::string&>()); } else if (args[0]->is_number_integer() && args[1]->is_number_integer()) { - result_ptr = std::make_shared<json>(args[0]->get<int>() + args[1]->get<int>()); - json_tmp_stack.push_back(result_ptr); + make_result(args[0]->get<int>() + args[1]->get<int>()); } else { - result_ptr = std::make_shared<json>(args[0]->get<double>() + args[1]->get<double>()); - json_tmp_stack.push_back(result_ptr); + make_result(args[0]->get<double>() + args[1]->get<double>()); } - json_eval_stack.push(result_ptr.get()); } break; case Op::Subtract: { - auto args = get_arguments<2>(node); + const auto args = get_arguments<2>(node); if (args[0]->is_number_integer() && args[1]->is_number_integer()) { - result_ptr = std::make_shared<json>(args[0]->get<int>() - args[1]->get<int>()); - json_tmp_stack.push_back(result_ptr); + make_result(args[0]->get<int>() - args[1]->get<int>()); } else { - result_ptr = std::make_shared<json>(args[0]->get<double>() - args[1]->get<double>()); - json_tmp_stack.push_back(result_ptr); + make_result(args[0]->get<double>() - args[1]->get<double>()); } - json_eval_stack.push(result_ptr.get()); } break; case Op::Multiplication: { - auto args = get_arguments<2>(node); + const auto args = get_arguments<2>(node); if (args[0]->is_number_integer() && args[1]->is_number_integer()) { - result_ptr = std::make_shared<json>(args[0]->get<int>() * args[1]->get<int>()); - json_tmp_stack.push_back(result_ptr); + make_result(args[0]->get<int>() * args[1]->get<int>()); } else { - result_ptr = std::make_shared<json>(args[0]->get<double>() * args[1]->get<double>()); - json_tmp_stack.push_back(result_ptr); + make_result(args[0]->get<double>() * args[1]->get<double>()); } - json_eval_stack.push(result_ptr.get()); } break; case Op::Division: { - auto args = get_arguments<2>(node); + const auto args = get_arguments<2>(node); if (args[1]->get<double>() == 0) { throw_renderer_error("division by zero", node); } - result_ptr = std::make_shared<json>(args[0]->get<double>() / args[1]->get<double>()); - json_tmp_stack.push_back(result_ptr); - json_eval_stack.push(result_ptr.get()); + make_result(args[0]->get<double>() / args[1]->get<double>()); } break; case Op::Power: { - auto args = get_arguments<2>(node); + const auto args = get_arguments<2>(node); if (args[0]->is_number_integer() && args[1]->get<int>() >= 0) { - int result = std::pow(args[0]->get<int>(), args[1]->get<int>()); - result_ptr = std::make_shared<json>(std::move(result)); - json_tmp_stack.push_back(result_ptr); + int result = static_cast<int>(std::pow(args[0]->get<int>(), args[1]->get<int>())); + make_result(result); } else { double result = std::pow(args[0]->get<double>(), args[1]->get<int>()); - result_ptr = std::make_shared<json>(std::move(result)); - json_tmp_stack.push_back(result_ptr); + make_result(result); } - json_eval_stack.push(result_ptr.get()); } break; case Op::Modulo: { - auto args = get_arguments<2>(node); - result_ptr = std::make_shared<json>(args[0]->get<int>() % args[1]->get<int>()); - json_tmp_stack.push_back(result_ptr); - json_eval_stack.push(result_ptr.get()); + const auto args = get_arguments<2>(node); + make_result(args[0]->get<int>() % args[1]->get<int>()); } break; case Op::AtId: { - json_eval_stack.pop(); // Pop id nullptr - auto container = get_arguments<1, false>(node)[0]; + const auto container = get_arguments<1, 0, false>(node)[0]; + node.arguments[1]->accept(*this); if (not_found_stack.empty()) { throw_renderer_error("could not find element with given name", node); } - auto id_node = not_found_stack.top(); + const auto id_node = not_found_stack.top(); not_found_stack.pop(); - json_eval_stack.push(&container->at(id_node->name)); + data_eval_stack.pop(); + data_eval_stack.push(&container->at(id_node->name)); } break; case Op::At: { - auto args = get_arguments<2>(node); - json_eval_stack.push(&args[0]->at(args[1]->get<int>())); + const auto args = get_arguments<2>(node); + if (args[0]->is_object()) { + data_eval_stack.push(&args[0]->at(args[1]->get<std::string>())); + } else { + data_eval_stack.push(&args[0]->at(args[1]->get<int>())); + } } break; case Op::Default: { - auto default_arg = get_arguments<1>(node)[0]; - auto test_arg = get_arguments<1, false>(node)[0]; - json_eval_stack.push(test_arg ? test_arg : default_arg); + const auto test_arg = get_arguments<1, 0, false>(node)[0]; + data_eval_stack.push(test_arg ? test_arg : get_arguments<1, 1>(node)[0]); } break; case Op::DivisibleBy: { - auto args = get_arguments<2>(node); - int divisor = args[1]->get<int>(); - result_ptr = std::make_shared<json>((divisor != 0) && (args[0]->get<int>() % divisor == 0)); - json_tmp_stack.push_back(result_ptr); - json_eval_stack.push(result_ptr.get()); + const auto args = get_arguments<2>(node); + const int divisor = args[1]->get<int>(); + make_result((divisor != 0) && (args[0]->get<int>() % divisor == 0)); } break; case Op::Even: { - result_ptr = std::make_shared<json>(get_arguments<1>(node)[0]->get<int>() % 2 == 0); - json_tmp_stack.push_back(result_ptr); - json_eval_stack.push(result_ptr.get()); + make_result(get_arguments<1>(node)[0]->get<int>() % 2 == 0); } break; case Op::Exists: { - auto &&name = get_arguments<1>(node)[0]->get_ref<const std::string &>(); - result_ptr = std::make_shared<json>(json_input->contains(json::json_pointer(JsonNode::convert_dot_to_json_ptr(name)))); - json_tmp_stack.push_back(result_ptr); - json_eval_stack.push(result_ptr.get()); + auto&& name = get_arguments<1>(node)[0]->get_ref<const std::string&>(); + make_result(data_input->contains(json::json_pointer(DataNode::convert_dot_to_ptr(name)))); } break; case Op::ExistsInObject: { - auto args = get_arguments<2>(node); - auto &&name = args[1]->get_ref<const std::string &>(); - result_ptr = std::make_shared<json>(args[0]->find(name) != args[0]->end()); - json_tmp_stack.push_back(result_ptr); - json_eval_stack.push(result_ptr.get()); + const auto args = get_arguments<2>(node); + auto&& name = args[1]->get_ref<const std::string&>(); + make_result(args[0]->find(name) != args[0]->end()); } break; case Op::First: { - auto result = &get_arguments<1>(node)[0]->front(); - json_eval_stack.push(result); + const auto result = &get_arguments<1>(node)[0]->front(); + data_eval_stack.push(result); } break; case Op::Float: { - result_ptr = std::make_shared<json>(std::stod(get_arguments<1>(node)[0]->get_ref<const std::string &>())); - json_tmp_stack.push_back(result_ptr); - json_eval_stack.push(result_ptr.get()); + make_result(std::stod(get_arguments<1>(node)[0]->get_ref<const std::string&>())); } break; case Op::Int: { - result_ptr = std::make_shared<json>(std::stoi(get_arguments<1>(node)[0]->get_ref<const std::string &>())); - json_tmp_stack.push_back(result_ptr); - json_eval_stack.push(result_ptr.get()); + make_result(std::stoi(get_arguments<1>(node)[0]->get_ref<const std::string&>())); } break; case Op::Last: { - auto result = &get_arguments<1>(node)[0]->back(); - json_eval_stack.push(result); + const auto result = &get_arguments<1>(node)[0]->back(); + data_eval_stack.push(result); } break; case Op::Length: { - auto val = get_arguments<1>(node)[0]; + const auto val = get_arguments<1>(node)[0]; if (val->is_string()) { - result_ptr = std::make_shared<json>(val->get_ref<const std::string &>().length()); + make_result(val->get_ref<const std::string&>().length()); } else { - result_ptr = std::make_shared<json>(val->size()); + make_result(val->size()); } - json_tmp_stack.push_back(result_ptr); - json_eval_stack.push(result_ptr.get()); } break; case Op::Lower: { std::string result = get_arguments<1>(node)[0]->get<std::string>(); std::transform(result.begin(), result.end(), result.begin(), ::tolower); - result_ptr = std::make_shared<json>(std::move(result)); - json_tmp_stack.push_back(result_ptr); - json_eval_stack.push(result_ptr.get()); + make_result(std::move(result)); } break; case Op::Max: { - auto args = get_arguments<1>(node); - auto result = std::max_element(args[0]->begin(), args[0]->end()); - json_eval_stack.push(&(*result)); + const auto args = get_arguments<1>(node); + const auto result = std::max_element(args[0]->begin(), args[0]->end()); + data_eval_stack.push(&(*result)); } break; case Op::Min: { - auto args = get_arguments<1>(node); - auto result = std::min_element(args[0]->begin(), args[0]->end()); - json_eval_stack.push(&(*result)); + const auto args = get_arguments<1>(node); + const auto result = std::min_element(args[0]->begin(), args[0]->end()); + data_eval_stack.push(&(*result)); } break; case Op::Odd: { - result_ptr = std::make_shared<json>(get_arguments<1>(node)[0]->get<int>() % 2 != 0); - json_tmp_stack.push_back(result_ptr); - json_eval_stack.push(result_ptr.get()); + make_result(get_arguments<1>(node)[0]->get<int>() % 2 != 0); } break; case Op::Range: { std::vector<int> result(get_arguments<1>(node)[0]->get<int>()); std::iota(result.begin(), result.end(), 0); - result_ptr = std::make_shared<json>(std::move(result)); - json_tmp_stack.push_back(result_ptr); - json_eval_stack.push(result_ptr.get()); + make_result(std::move(result)); } break; case Op::Round: { - auto args = get_arguments<2>(node); - int precision = args[1]->get<int>(); - double result = std::round(args[0]->get<double>() * std::pow(10.0, precision)) / std::pow(10.0, precision); - result_ptr = std::make_shared<json>(std::move(result)); - json_tmp_stack.push_back(result_ptr); - json_eval_stack.push(result_ptr.get()); + const auto args = get_arguments<2>(node); + const int precision = args[1]->get<int>(); + const double result = std::round(args[0]->get<double>() * std::pow(10.0, precision)) / std::pow(10.0, precision); + if (precision == 0) { + make_result(int(result)); + } else { + make_result(result); + } } break; case Op::Sort: { - result_ptr = std::make_shared<json>(get_arguments<1>(node)[0]->get<std::vector<json>>()); + auto result_ptr = std::make_shared<json>(get_arguments<1>(node)[0]->get<std::vector<json>>()); std::sort(result_ptr->begin(), result_ptr->end()); - json_tmp_stack.push_back(result_ptr); - json_eval_stack.push(result_ptr.get()); + data_tmp_stack.push_back(result_ptr); + data_eval_stack.push(result_ptr.get()); } break; case Op::Upper: { std::string result = get_arguments<1>(node)[0]->get<std::string>(); std::transform(result.begin(), result.end(), result.begin(), ::toupper); - result_ptr = std::make_shared<json>(std::move(result)); - json_tmp_stack.push_back(result_ptr); - json_eval_stack.push(result_ptr.get()); + make_result(std::move(result)); } break; case Op::IsBoolean: { - result_ptr = std::make_shared<json>(get_arguments<1>(node)[0]->is_boolean()); - json_tmp_stack.push_back(result_ptr); - json_eval_stack.push(result_ptr.get()); + make_result(get_arguments<1>(node)[0]->is_boolean()); } break; case Op::IsNumber: { - result_ptr = std::make_shared<json>(get_arguments<1>(node)[0]->is_number()); - json_tmp_stack.push_back(result_ptr); - json_eval_stack.push(result_ptr.get()); + make_result(get_arguments<1>(node)[0]->is_number()); } break; case Op::IsInteger: { - result_ptr = std::make_shared<json>(get_arguments<1>(node)[0]->is_number_integer()); - json_tmp_stack.push_back(result_ptr); - json_eval_stack.push(result_ptr.get()); + make_result(get_arguments<1>(node)[0]->is_number_integer()); } break; case Op::IsFloat: { - result_ptr = std::make_shared<json>(get_arguments<1>(node)[0]->is_number_float()); - json_tmp_stack.push_back(result_ptr); - json_eval_stack.push(result_ptr.get()); + make_result(get_arguments<1>(node)[0]->is_number_float()); } break; case Op::IsObject: { - result_ptr = std::make_shared<json>(get_arguments<1>(node)[0]->is_object()); - json_tmp_stack.push_back(result_ptr); - json_eval_stack.push(result_ptr.get()); + make_result(get_arguments<1>(node)[0]->is_object()); } break; case Op::IsArray: { - result_ptr = std::make_shared<json>(get_arguments<1>(node)[0]->is_array()); - json_tmp_stack.push_back(result_ptr); - json_eval_stack.push(result_ptr.get()); + make_result(get_arguments<1>(node)[0]->is_array()); } break; case Op::IsString: { - result_ptr = std::make_shared<json>(get_arguments<1>(node)[0]->is_string()); - json_tmp_stack.push_back(result_ptr); - json_eval_stack.push(result_ptr.get()); + make_result(get_arguments<1>(node)[0]->is_string()); } break; case Op::Callback: { - auto args = get_argument_vector(node.number_args, node); - result_ptr = std::make_shared<json>(node.callback(args)); - json_tmp_stack.push_back(result_ptr); - json_eval_stack.push(result_ptr.get()); + auto args = get_argument_vector(node); + make_result(node.callback(args)); + } break; + case Op::Super: { + const auto args = get_argument_vector(node); + const size_t old_level = current_level; + const size_t level_diff = (args.size() == 1) ? args[0]->get<int>() : 1; + const size_t level = current_level + level_diff; + + if (block_statement_stack.empty()) { + throw_renderer_error("super() call is not within a block", node); + } + + if (level < 1 || level > template_stack.size() - 1) { + throw_renderer_error("level of super() call does not match parent templates (between 1 and " + std::to_string(template_stack.size() - 1) + ")", node); + } + + const auto current_block_statement = block_statement_stack.back(); + const Template* new_template = template_stack.at(level); + const Template* old_template = current_template; + const auto block_it = new_template->block_storage.find(current_block_statement->name); + if (block_it != new_template->block_storage.end()) { + current_template = new_template; + current_level = level; + block_it->second->block.accept(*this); + current_level = old_level; + current_template = old_template; + } else { + throw_renderer_error("could not find block with name '" + current_block_statement->name + "'", node); + } + make_result(nullptr); + } break; + case Op::Join: { + const auto args = get_arguments<2>(node); + const auto separator = args[1]->get<std::string>(); + std::ostringstream os; + std::string sep; + for (const auto& value : *args[0]) { + os << sep; + if (value.is_string()) { + os << value.get<std::string>(); // otherwise the value is surrounded with "" + } else { + os << value; + } + sep = separator; + } + make_result(os.str()); } break; case Op::ParenLeft: case Op::ParenRight: @@ -478,15 +472,15 @@ class Renderer : public NodeVisitor { } void visit(const ExpressionListNode& node) { - print_json(eval_expression_list(node)); + print_data(eval_expression_list(node)); } - void visit(const StatementNode&) { } + void visit(const StatementNode&) {} - void visit(const ForStatementNode&) { } + void visit(const ForStatementNode&) {} void visit(const ForArrayStatementNode& node) { - auto result = eval_expression_list(node.condition); + const auto result = eval_expression_list(node.condition); if (!result->is_array()) { throw_renderer_error("object must be an array", node); } @@ -500,7 +494,7 @@ class Renderer : public NodeVisitor { (*current_loop_data)["is_first"] = true; (*current_loop_data)["is_last"] = (result->size() <= 1); for (auto it = result->begin(); it != result->end(); ++it) { - json_additional_data[static_cast<std::string>(node.value)] = *it; + additional_data[static_cast<std::string>(node.value)] = *it; (*current_loop_data)["index"] = index; (*current_loop_data)["index1"] = index + 1; @@ -515,17 +509,17 @@ class Renderer : public NodeVisitor { ++index; } - json_additional_data[static_cast<std::string>(node.value)].clear(); + additional_data[static_cast<std::string>(node.value)].clear(); if (!(*current_loop_data)["parent"].empty()) { - auto tmp = (*current_loop_data)["parent"]; + const auto tmp = (*current_loop_data)["parent"]; *current_loop_data = std::move(tmp); } else { - current_loop_data = &json_additional_data["loop"]; + current_loop_data = &additional_data["loop"]; } } void visit(const ForObjectStatementNode& node) { - auto result = eval_expression_list(node.condition); + const auto result = eval_expression_list(node.condition); if (!result->is_object()) { throw_renderer_error("object must be an object", node); } @@ -538,8 +532,8 @@ class Renderer : public NodeVisitor { (*current_loop_data)["is_first"] = true; (*current_loop_data)["is_last"] = (result->size() <= 1); for (auto it = result->begin(); it != result->end(); ++it) { - json_additional_data[static_cast<std::string>(node.key)] = it.key(); - json_additional_data[static_cast<std::string>(node.value)] = it.value(); + additional_data[static_cast<std::string>(node.key)] = it.key(); + additional_data[static_cast<std::string>(node.value)] = it.value(); (*current_loop_data)["index"] = index; (*current_loop_data)["index1"] = index + 1; @@ -554,17 +548,17 @@ class Renderer : public NodeVisitor { ++index; } - json_additional_data[static_cast<std::string>(node.key)].clear(); - json_additional_data[static_cast<std::string>(node.value)].clear(); + additional_data[static_cast<std::string>(node.key)].clear(); + additional_data[static_cast<std::string>(node.value)].clear(); if (!(*current_loop_data)["parent"].empty()) { *current_loop_data = std::move((*current_loop_data)["parent"]); } else { - current_loop_data = &json_additional_data["loop"]; + current_loop_data = &additional_data["loop"]; } } void visit(const IfStatementNode& node) { - auto result = eval_expression_list(node.condition); + const auto result = eval_expression_list(node.condition); if (truthy(result.get())) { node.true_statement.accept(*this); } else if (node.has_false_statement) { @@ -574,35 +568,63 @@ class Renderer : public NodeVisitor { void visit(const IncludeStatementNode& node) { auto sub_renderer = Renderer(config, template_storage, function_storage); - auto included_template_it = template_storage.find(node.file); - + const auto included_template_it = template_storage.find(node.file); if (included_template_it != template_storage.end()) { - sub_renderer.render_to(*output_stream, included_template_it->second, *json_input, &json_additional_data); + sub_renderer.render_to(*output_stream, included_template_it->second, *data_input, &additional_data); } else if (config.throw_at_missing_includes) { throw_renderer_error("include '" + node.file + "' not found", node); } } + void visit(const ExtendsStatementNode& node) { + const auto included_template_it = template_storage.find(node.file); + if (included_template_it != template_storage.end()) { + const Template* parent_template = &included_template_it->second; + render_to(*output_stream, *parent_template, *data_input, &additional_data); + break_rendering = true; + } else if (config.throw_at_missing_includes) { + throw_renderer_error("extends '" + node.file + "' not found", node); + } + } + + void visit(const BlockStatementNode& node) { + const size_t old_level = current_level; + current_level = 0; + current_template = template_stack.front(); + const auto block_it = current_template->block_storage.find(node.name); + if (block_it != current_template->block_storage.end()) { + block_statement_stack.emplace_back(&node); + block_it->second->block.accept(*this); + block_statement_stack.pop_back(); + } + current_level = old_level; + current_template = template_stack.back(); + } + void visit(const SetStatementNode& node) { - json_additional_data[node.key] = *eval_expression_list(node.expression); + std::string ptr = node.key; + replace_substring(ptr, ".", "/"); + ptr = "/" + ptr; + additional_data[json::json_pointer(ptr)] = *eval_expression_list(node.expression); } public: - Renderer(const RenderConfig& config, const TemplateStorage &template_storage, const FunctionStorage &function_storage) - : config(config), template_storage(template_storage), function_storage(function_storage) { } + Renderer(const RenderConfig& config, const TemplateStorage& template_storage, const FunctionStorage& function_storage) + : config(config), template_storage(template_storage), function_storage(function_storage) {} - void render_to(std::ostream &os, const Template &tmpl, const json &data, json *loop_data = nullptr) { + void render_to(std::ostream& os, const Template& tmpl, const json& data, json* loop_data = nullptr) { output_stream = &os; current_template = &tmpl; - json_input = &data; + data_input = &data; if (loop_data) { - json_additional_data = *loop_data; - current_loop_data = &json_additional_data["loop"]; + additional_data = *loop_data; + current_loop_data = &additional_data["loop"]; } + template_stack.emplace_back(current_template); current_template->root.accept(*this); - json_tmp_stack.clear(); + data_tmp_stack.clear(); } }; diff --git a/include/inja/statistics.hpp b/include/inja/statistics.hpp index 71fc719..da33593 100644 --- a/include/inja/statistics.hpp +++ b/include/inja/statistics.hpp @@ -1,11 +1,8 @@ -// Copyright (c) 2019 Pantor. All rights reserved. - #ifndef INCLUDE_INJA_STATISTICS_HPP_ #define INCLUDE_INJA_STATISTICS_HPP_ #include "node.hpp" - namespace inja { /*! @@ -18,24 +15,26 @@ class StatisticsVisitor : public NodeVisitor { } } - void visit(const TextNode&) { } - void visit(const ExpressionNode&) { } - void visit(const LiteralNode&) { } + void visit(const TextNode&) {} + void visit(const ExpressionNode&) {} + void visit(const LiteralNode&) {} - void visit(const JsonNode&) { + void visit(const DataNode&) { variable_counter += 1; } - void visit(const FunctionNode&) { } - - void visit(const ExpressionListNode& node) { - for (auto& n : node.rpn_output) { + void visit(const FunctionNode& node) { + for (auto& n : node.arguments) { n->accept(*this); } } - void visit(const StatementNode&) { } - void visit(const ForStatementNode&) { } + void visit(const ExpressionListNode& node) { + node.root->accept(*this); + } + + void visit(const StatementNode&) {} + void visit(const ForStatementNode&) {} void visit(const ForArrayStatementNode& node) { node.condition.accept(*this); @@ -53,14 +52,20 @@ class StatisticsVisitor : public NodeVisitor { node.false_statement.accept(*this); } - void visit(const IncludeStatementNode&) { } + void visit(const IncludeStatementNode&) {} + + void visit(const ExtendsStatementNode&) {} + + void visit(const BlockStatementNode& node) { + node.block.accept(*this); + } - void visit(const SetStatementNode&) { } + void visit(const SetStatementNode&) {} public: unsigned int variable_counter; - explicit StatisticsVisitor() : variable_counter(0) { } + explicit StatisticsVisitor(): variable_counter(0) {} }; } // namespace inja diff --git a/include/inja/string_view.hpp b/include/inja/string_view.hpp deleted file mode 100644 index 2bb50c9..0000000 --- a/include/inja/string_view.hpp +++ /dev/null @@ -1,1416 +0,0 @@ -// Copyright 2017-2019 by Martin Moene -// -// string-view lite, a C++17-like string_view for C++98 and later. -// For more information see https://github.com/martinmoene/string-view-lite -// -// Distributed under the Boost Software License, Version 1.0. -// (See accompanying file LICENSE.txt or copy at http://www.boost.org/LICENSE_1_0.txt) - -#pragma once - -#ifndef NONSTD_SV_LITE_H_INCLUDED -#define NONSTD_SV_LITE_H_INCLUDED - -#define string_view_lite_MAJOR 1 -#define string_view_lite_MINOR 4 -#define string_view_lite_PATCH 0 - -#define string_view_lite_VERSION \ - nssv_STRINGIFY(string_view_lite_MAJOR) "." nssv_STRINGIFY(string_view_lite_MINOR) "." nssv_STRINGIFY( \ - string_view_lite_PATCH) - -#define nssv_STRINGIFY(x) nssv_STRINGIFY_(x) -#define nssv_STRINGIFY_(x) #x - -// string-view lite configuration: - -#define nssv_STRING_VIEW_DEFAULT 0 -#define nssv_STRING_VIEW_NONSTD 1 -#define nssv_STRING_VIEW_STD 2 - -#if !defined(nssv_CONFIG_SELECT_STRING_VIEW) -#define nssv_CONFIG_SELECT_STRING_VIEW (nssv_HAVE_STD_STRING_VIEW ? nssv_STRING_VIEW_STD : nssv_STRING_VIEW_NONSTD) -#endif - -#if defined(nssv_CONFIG_SELECT_STD_STRING_VIEW) || defined(nssv_CONFIG_SELECT_NONSTD_STRING_VIEW) -#error nssv_CONFIG_SELECT_STD_STRING_VIEW and nssv_CONFIG_SELECT_NONSTD_STRING_VIEW are deprecated and removed, please use nssv_CONFIG_SELECT_STRING_VIEW=nssv_STRING_VIEW_... -#endif - -#ifndef nssv_CONFIG_STD_SV_OPERATOR -#define nssv_CONFIG_STD_SV_OPERATOR 0 -#endif - -#ifndef nssv_CONFIG_USR_SV_OPERATOR -#define nssv_CONFIG_USR_SV_OPERATOR 1 -#endif - -#ifdef nssv_CONFIG_CONVERSION_STD_STRING -#define nssv_CONFIG_CONVERSION_STD_STRING_CLASS_METHODS nssv_CONFIG_CONVERSION_STD_STRING -#define nssv_CONFIG_CONVERSION_STD_STRING_FREE_FUNCTIONS nssv_CONFIG_CONVERSION_STD_STRING -#endif - -#ifndef nssv_CONFIG_CONVERSION_STD_STRING_CLASS_METHODS -#define nssv_CONFIG_CONVERSION_STD_STRING_CLASS_METHODS 1 -#endif - -#ifndef nssv_CONFIG_CONVERSION_STD_STRING_FREE_FUNCTIONS -#define nssv_CONFIG_CONVERSION_STD_STRING_FREE_FUNCTIONS 1 -#endif - -// Control presence of exception handling (try and auto discover): - -#ifndef nssv_CONFIG_NO_EXCEPTIONS -#if defined(__cpp_exceptions) || defined(__EXCEPTIONS) || defined(_CPPUNWIND) -#define nssv_CONFIG_NO_EXCEPTIONS 0 -#else -#define nssv_CONFIG_NO_EXCEPTIONS 1 -#endif -#endif - -// C++ language version detection (C++20 is speculative): -// Note: VC14.0/1900 (VS2015) lacks too much from C++14. - -#ifndef nssv_CPLUSPLUS -#if defined(_MSVC_LANG) && !defined(__clang__) -#define nssv_CPLUSPLUS (_MSC_VER == 1900 ? 201103L : _MSVC_LANG) -#else -#define nssv_CPLUSPLUS __cplusplus -#endif -#endif - -#define nssv_CPP98_OR_GREATER (nssv_CPLUSPLUS >= 199711L) -#define nssv_CPP11_OR_GREATER (nssv_CPLUSPLUS >= 201103L) -#define nssv_CPP11_OR_GREATER_ (nssv_CPLUSPLUS >= 201103L) -#define nssv_CPP14_OR_GREATER (nssv_CPLUSPLUS >= 201402L) -#define nssv_CPP17_OR_GREATER (nssv_CPLUSPLUS >= 201703L) -#define nssv_CPP20_OR_GREATER (nssv_CPLUSPLUS >= 202000L) - -// use C++17 std::string_view if available and requested: - -#if nssv_CPP17_OR_GREATER && defined(__has_include) -#if __has_include(<string_view> ) -#define nssv_HAVE_STD_STRING_VIEW 1 -#else -#define nssv_HAVE_STD_STRING_VIEW 0 -#endif -#else -#define nssv_HAVE_STD_STRING_VIEW 0 -#endif - -#define nssv_USES_STD_STRING_VIEW \ - ((nssv_CONFIG_SELECT_STRING_VIEW == nssv_STRING_VIEW_STD) || \ - ((nssv_CONFIG_SELECT_STRING_VIEW == nssv_STRING_VIEW_DEFAULT) && nssv_HAVE_STD_STRING_VIEW)) - -#define nssv_HAVE_STARTS_WITH (nssv_CPP20_OR_GREATER || !nssv_USES_STD_STRING_VIEW) -#define nssv_HAVE_ENDS_WITH nssv_HAVE_STARTS_WITH - -// -// Use C++17 std::string_view: -// - -#if nssv_USES_STD_STRING_VIEW - -#include <string_view> - -// Extensions for std::string: - -#if nssv_CONFIG_CONVERSION_STD_STRING_FREE_FUNCTIONS - -namespace nonstd { - -template <class CharT, class Traits, class Allocator = std::allocator<CharT>> -std::basic_string<CharT, Traits, Allocator> to_string(std::basic_string_view<CharT, Traits> v, - Allocator const &a = Allocator()) { - return std::basic_string<CharT, Traits, Allocator>(v.begin(), v.end(), a); -} - -template <class CharT, class Traits, class Allocator> -std::basic_string_view<CharT, Traits> to_string_view(std::basic_string<CharT, Traits, Allocator> const &s) { - return std::basic_string_view<CharT, Traits>(s.data(), s.size()); -} - -// Literal operators sv and _sv: - -#if nssv_CONFIG_STD_SV_OPERATOR - -using namespace std::literals::string_view_literals; - -#endif - -#if nssv_CONFIG_USR_SV_OPERATOR - -inline namespace literals { -inline namespace string_view_literals { - -constexpr std::string_view operator"" _sv(const char *str, size_t len) noexcept // (1) -{ - return std::string_view {str, len}; -} - -constexpr std::u16string_view operator"" _sv(const char16_t *str, size_t len) noexcept // (2) -{ - return std::u16string_view {str, len}; -} - -constexpr std::u32string_view operator"" _sv(const char32_t *str, size_t len) noexcept // (3) -{ - return std::u32string_view {str, len}; -} - -constexpr std::wstring_view operator"" _sv(const wchar_t *str, size_t len) noexcept // (4) -{ - return std::wstring_view {str, len}; -} - -} // namespace string_view_literals -} // namespace literals - -#endif // nssv_CONFIG_USR_SV_OPERATOR - -} // namespace nonstd - -#endif // nssv_CONFIG_CONVERSION_STD_STRING_FREE_FUNCTIONS - -namespace nonstd { - -using std::basic_string_view; -using std::string_view; -using std::u16string_view; -using std::u32string_view; -using std::wstring_view; - -// literal "sv" and "_sv", see above - -using std::operator==; -using std::operator!=; -using std::operator<; -using std::operator<=; -using std::operator>; -using std::operator>=; - -using std::operator<<; - -} // namespace nonstd - -#else // nssv_HAVE_STD_STRING_VIEW - -// -// Before C++17: use string_view lite: -// - -// Compiler versions: -// -// MSVC++ 6.0 _MSC_VER == 1200 (Visual Studio 6.0) -// MSVC++ 7.0 _MSC_VER == 1300 (Visual Studio .NET 2002) -// MSVC++ 7.1 _MSC_VER == 1310 (Visual Studio .NET 2003) -// MSVC++ 8.0 _MSC_VER == 1400 (Visual Studio 2005) -// MSVC++ 9.0 _MSC_VER == 1500 (Visual Studio 2008) -// MSVC++ 10.0 _MSC_VER == 1600 (Visual Studio 2010) -// MSVC++ 11.0 _MSC_VER == 1700 (Visual Studio 2012) -// MSVC++ 12.0 _MSC_VER == 1800 (Visual Studio 2013) -// MSVC++ 14.0 _MSC_VER == 1900 (Visual Studio 2015) -// MSVC++ 14.1 _MSC_VER >= 1910 (Visual Studio 2017) - -#if defined(_MSC_VER) && !defined(__clang__) -#define nssv_COMPILER_MSVC_VER (_MSC_VER) -#define nssv_COMPILER_MSVC_VERSION (_MSC_VER / 10 - 10 * (5 + (_MSC_VER < 1900))) -#else -#define nssv_COMPILER_MSVC_VER 0 -#define nssv_COMPILER_MSVC_VERSION 0 -#endif - -#define nssv_COMPILER_VERSION(major, minor, patch) (10 * (10 * (major) + (minor)) + (patch)) - -#if defined(__clang__) -#define nssv_COMPILER_CLANG_VERSION nssv_COMPILER_VERSION(__clang_major__, __clang_minor__, __clang_patchlevel__) -#else -#define nssv_COMPILER_CLANG_VERSION 0 -#endif - -#if defined(__GNUC__) && !defined(__clang__) -#define nssv_COMPILER_GNUC_VERSION nssv_COMPILER_VERSION(__GNUC__, __GNUC_MINOR__, __GNUC_PATCHLEVEL__) -#else -#define nssv_COMPILER_GNUC_VERSION 0 -#endif - -// half-open range [lo..hi): -#define nssv_BETWEEN(v, lo, hi) ((lo) <= (v) && (v) < (hi)) - -// Presence of language and library features: - -#ifdef _HAS_CPP0X -#define nssv_HAS_CPP0X _HAS_CPP0X -#else -#define nssv_HAS_CPP0X 0 -#endif - -// Unless defined otherwise below, consider VC14 as C++11 for variant-lite: - -#if nssv_COMPILER_MSVC_VER >= 1900 -#undef nssv_CPP11_OR_GREATER -#define nssv_CPP11_OR_GREATER 1 -#endif - -#define nssv_CPP11_90 (nssv_CPP11_OR_GREATER_ || nssv_COMPILER_MSVC_VER >= 1500) -#define nssv_CPP11_100 (nssv_CPP11_OR_GREATER_ || nssv_COMPILER_MSVC_VER >= 1600) -#define nssv_CPP11_110 (nssv_CPP11_OR_GREATER_ || nssv_COMPILER_MSVC_VER >= 1700) -#define nssv_CPP11_120 (nssv_CPP11_OR_GREATER_ || nssv_COMPILER_MSVC_VER >= 1800) -#define nssv_CPP11_140 (nssv_CPP11_OR_GREATER_ || nssv_COMPILER_MSVC_VER >= 1900) -#define nssv_CPP11_141 (nssv_CPP11_OR_GREATER_ || nssv_COMPILER_MSVC_VER >= 1910) - -#define nssv_CPP14_000 (nssv_CPP14_OR_GREATER) -#define nssv_CPP17_000 (nssv_CPP17_OR_GREATER) - -// Presence of C++11 language features: - -#define nssv_HAVE_CONSTEXPR_11 nssv_CPP11_140 -#define nssv_HAVE_EXPLICIT_CONVERSION nssv_CPP11_140 -#define nssv_HAVE_INLINE_NAMESPACE nssv_CPP11_140 -#define nssv_HAVE_NOEXCEPT nssv_CPP11_140 -#define nssv_HAVE_NULLPTR nssv_CPP11_100 -#define nssv_HAVE_REF_QUALIFIER nssv_CPP11_140 -#define nssv_HAVE_UNICODE_LITERALS nssv_CPP11_140 -#define nssv_HAVE_USER_DEFINED_LITERALS nssv_CPP11_140 -#define nssv_HAVE_WCHAR16_T nssv_CPP11_100 -#define nssv_HAVE_WCHAR32_T nssv_CPP11_100 - -#if !((nssv_CPP11_OR_GREATER && nssv_COMPILER_CLANG_VERSION) || nssv_BETWEEN(nssv_COMPILER_CLANG_VERSION, 300, 400)) -#define nssv_HAVE_STD_DEFINED_LITERALS nssv_CPP11_140 -#else -#define nssv_HAVE_STD_DEFINED_LITERALS 0 -#endif - -// Presence of C++14 language features: - -#define nssv_HAVE_CONSTEXPR_14 nssv_CPP14_000 - -// Presence of C++17 language features: - -#define nssv_HAVE_NODISCARD nssv_CPP17_000 - -// Presence of C++ library features: - -#define nssv_HAVE_STD_HASH nssv_CPP11_120 - -// C++ feature usage: - -#if nssv_HAVE_CONSTEXPR_11 -#define nssv_constexpr constexpr -#else -#define nssv_constexpr /*constexpr*/ -#endif - -#if nssv_HAVE_CONSTEXPR_14 -#define nssv_constexpr14 constexpr -#else -#define nssv_constexpr14 /*constexpr*/ -#endif - -#if nssv_HAVE_EXPLICIT_CONVERSION -#define nssv_explicit explicit -#else -#define nssv_explicit /*explicit*/ -#endif - -#if nssv_HAVE_INLINE_NAMESPACE -#define nssv_inline_ns inline -#else -#define nssv_inline_ns /*inline*/ -#endif - -#if nssv_HAVE_NOEXCEPT -#define nssv_noexcept noexcept -#else -#define nssv_noexcept /*noexcept*/ -#endif - -//#if nssv_HAVE_REF_QUALIFIER -//# define nssv_ref_qual & -//# define nssv_refref_qual && -//#else -//# define nssv_ref_qual /*&*/ -//# define nssv_refref_qual /*&&*/ -//#endif - -#if nssv_HAVE_NULLPTR -#define nssv_nullptr nullptr -#else -#define nssv_nullptr NULL -#endif - -#if nssv_HAVE_NODISCARD -#define nssv_nodiscard [[nodiscard]] -#else -#define nssv_nodiscard /*[[nodiscard]]*/ -#endif - -// Additional includes: - -#include <algorithm> -#include <cassert> -#include <iterator> -#include <limits> -#include <ostream> -#include <string> // std::char_traits<> - -#if !nssv_CONFIG_NO_EXCEPTIONS -#include <stdexcept> -#endif - -#if nssv_CPP11_OR_GREATER -#include <type_traits> -#endif - -// Clang, GNUC, MSVC warning suppression macros: - -#if defined(__clang__) -#pragma clang diagnostic ignored "-Wreserved-user-defined-literal" -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wuser-defined-literals" -#elif defined(__GNUC__) -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wliteral-suffix" -#endif // __clang__ - -#if nssv_COMPILER_MSVC_VERSION >= 140 -#define nssv_SUPPRESS_MSGSL_WARNING(expr) [[gsl::suppress(expr)]] -#define nssv_SUPPRESS_MSVC_WARNING(code, descr) __pragma(warning(suppress : code)) -#define nssv_DISABLE_MSVC_WARNINGS(codes) __pragma(warning(push)) __pragma(warning(disable : codes)) -#else -#define nssv_SUPPRESS_MSGSL_WARNING(expr) -#define nssv_SUPPRESS_MSVC_WARNING(code, descr) -#define nssv_DISABLE_MSVC_WARNINGS(codes) -#endif - -#if defined(__clang__) -#define nssv_RESTORE_WARNINGS() _Pragma("clang diagnostic pop") -#elif defined(__GNUC__) -#define nssv_RESTORE_WARNINGS() _Pragma("GCC diagnostic pop") -#elif nssv_COMPILER_MSVC_VERSION >= 140 -#define nssv_RESTORE_WARNINGS() __pragma(warning(pop)) -#else -#define nssv_RESTORE_WARNINGS() -#endif - -// Suppress the following MSVC (GSL) warnings: -// - C4455, non-gsl : 'operator ""sv': literal suffix identifiers that do not -// start with an underscore are reserved -// - C26472, gsl::t.1 : don't use a static_cast for arithmetic conversions; -// use brace initialization, gsl::narrow_cast or gsl::narow -// - C26481: gsl::b.1 : don't use pointer arithmetic. Use span instead - -nssv_DISABLE_MSVC_WARNINGS(4455 26481 26472) - // nssv_DISABLE_CLANG_WARNINGS( "-Wuser-defined-literals" ) - // nssv_DISABLE_GNUC_WARNINGS( -Wliteral-suffix ) - - namespace nonstd { - namespace sv_lite { - -#if nssv_CPP11_OR_GREATER - - namespace detail { - - // Expect tail call optimization to make length() non-recursive: - - template <typename CharT> inline constexpr std::size_t length(CharT *s, std::size_t result = 0) { - return *s == '\0' ? result : length(s + 1, result + 1); - } - - } // namespace detail - -#endif // nssv_CPP11_OR_GREATER - - template <class CharT, class Traits = std::char_traits<CharT>> class basic_string_view; - - // - // basic_string_view: - // - - template <class CharT, class Traits /* = std::char_traits<CharT> */ - > - class basic_string_view { - public: - // Member types: - - typedef Traits traits_type; - typedef CharT value_type; - - typedef CharT *pointer; - typedef CharT const *const_pointer; - typedef CharT &reference; - typedef CharT const &const_reference; - - typedef const_pointer iterator; - typedef const_pointer const_iterator; - typedef std::reverse_iterator<const_iterator> reverse_iterator; - typedef std::reverse_iterator<const_iterator> const_reverse_iterator; - - typedef std::size_t size_type; - typedef std::ptrdiff_t difference_type; - - // 24.4.2.1 Construction and assignment: - - nssv_constexpr basic_string_view() nssv_noexcept : data_(nssv_nullptr), size_(0) {} - -#if nssv_CPP11_OR_GREATER - nssv_constexpr basic_string_view(basic_string_view const &other) nssv_noexcept = default; -#else - nssv_constexpr basic_string_view(basic_string_view const &other) nssv_noexcept : data_(other.data_), - size_(other.size_) {} -#endif - - nssv_constexpr basic_string_view(CharT const *s, size_type count) nssv_noexcept // non-standard noexcept - : data_(s), - size_(count) {} - - nssv_constexpr basic_string_view(CharT const *s) nssv_noexcept // non-standard noexcept - : data_(s) -#if nssv_CPP17_OR_GREATER - , - size_(Traits::length(s)) -#elif nssv_CPP11_OR_GREATER - , - size_(detail::length(s)) -#else - , - size_(Traits::length(s)) -#endif - { - } - - // Assignment: - -#if nssv_CPP11_OR_GREATER - nssv_constexpr14 basic_string_view &operator=(basic_string_view const &other) nssv_noexcept = default; -#else - nssv_constexpr14 basic_string_view &operator=(basic_string_view const &other) nssv_noexcept { - data_ = other.data_; - size_ = other.size_; - return *this; - } -#endif - - // 24.4.2.2 Iterator support: - - nssv_constexpr const_iterator begin() const nssv_noexcept { return data_; } - nssv_constexpr const_iterator end() const nssv_noexcept { return data_ + size_; } - - nssv_constexpr const_iterator cbegin() const nssv_noexcept { return begin(); } - nssv_constexpr const_iterator cend() const nssv_noexcept { return end(); } - - nssv_constexpr const_reverse_iterator rbegin() const nssv_noexcept { return const_reverse_iterator(end()); } - nssv_constexpr const_reverse_iterator rend() const nssv_noexcept { return const_reverse_iterator(begin()); } - - nssv_constexpr const_reverse_iterator crbegin() const nssv_noexcept { return rbegin(); } - nssv_constexpr const_reverse_iterator crend() const nssv_noexcept { return rend(); } - - // 24.4.2.3 Capacity: - - nssv_constexpr size_type size() const nssv_noexcept { return size_; } - nssv_constexpr size_type length() const nssv_noexcept { return size_; } - nssv_constexpr size_type max_size() const nssv_noexcept { return (std::numeric_limits<size_type>::max)(); } - - // since C++20 - nssv_nodiscard nssv_constexpr bool empty() const nssv_noexcept { return 0 == size_; } - - // 24.4.2.4 Element access: - - nssv_constexpr const_reference operator[](size_type pos) const { return data_at(pos); } - - nssv_constexpr14 const_reference at(size_type pos) const { -#if nssv_CONFIG_NO_EXCEPTIONS - assert(pos < size()); -#else - if (pos >= size()) { - throw std::out_of_range("nonstd::string_view::at()"); - } -#endif - return data_at(pos); - } - - nssv_constexpr const_reference front() const { return data_at(0); } - nssv_constexpr const_reference back() const { return data_at(size() - 1); } - - nssv_constexpr const_pointer data() const nssv_noexcept { return data_; } - - // 24.4.2.5 Modifiers: - - nssv_constexpr14 void remove_prefix(size_type n) { - assert(n <= size()); - data_ += n; - size_ -= n; - } - - nssv_constexpr14 void remove_suffix(size_type n) { - assert(n <= size()); - size_ -= n; - } - - nssv_constexpr14 void swap(basic_string_view &other) nssv_noexcept { - using std::swap; - swap(data_, other.data_); - swap(size_, other.size_); - } - - // 24.4.2.6 String operations: - - size_type copy(CharT *dest, size_type n, size_type pos = 0) const { -#if nssv_CONFIG_NO_EXCEPTIONS - assert(pos <= size()); -#else - if (pos > size()) { - throw std::out_of_range("nonstd::string_view::copy()"); - } -#endif - const size_type rlen = (std::min)(n, size() - pos); - - (void)Traits::copy(dest, data() + pos, rlen); - - return rlen; - } - - nssv_constexpr14 basic_string_view substr(size_type pos = 0, size_type n = npos) const { -#if nssv_CONFIG_NO_EXCEPTIONS - assert(pos <= size()); -#else - if (pos > size()) { - throw std::out_of_range("nonstd::string_view::substr()"); - } -#endif - return basic_string_view(data() + pos, (std::min)(n, size() - pos)); - } - - // compare(), 6x: - - nssv_constexpr14 int compare(basic_string_view other) const nssv_noexcept // (1) - { - if (const int result = Traits::compare(data(), other.data(), (std::min)(size(), other.size()))) { - return result; - } - - return size() == other.size() ? 0 : size() < other.size() ? -1 : 1; - } - - nssv_constexpr int compare(size_type pos1, size_type n1, basic_string_view other) const // (2) - { - return substr(pos1, n1).compare(other); - } - - nssv_constexpr int compare(size_type pos1, size_type n1, basic_string_view other, size_type pos2, - size_type n2) const // (3) - { - return substr(pos1, n1).compare(other.substr(pos2, n2)); - } - - nssv_constexpr int compare(CharT const *s) const // (4) - { - return compare(basic_string_view(s)); - } - - nssv_constexpr int compare(size_type pos1, size_type n1, CharT const *s) const // (5) - { - return substr(pos1, n1).compare(basic_string_view(s)); - } - - nssv_constexpr int compare(size_type pos1, size_type n1, CharT const *s, size_type n2) const // (6) - { - return substr(pos1, n1).compare(basic_string_view(s, n2)); - } - - // 24.4.2.7 Searching: - - // starts_with(), 3x, since C++20: - - nssv_constexpr bool starts_with(basic_string_view v) const nssv_noexcept // (1) - { - return size() >= v.size() && compare(0, v.size(), v) == 0; - } - - nssv_constexpr bool starts_with(CharT c) const nssv_noexcept // (2) - { - return starts_with(basic_string_view(&c, 1)); - } - - nssv_constexpr bool starts_with(CharT const *s) const // (3) - { - return starts_with(basic_string_view(s)); - } - - // ends_with(), 3x, since C++20: - - nssv_constexpr bool ends_with(basic_string_view v) const nssv_noexcept // (1) - { - return size() >= v.size() && compare(size() - v.size(), npos, v) == 0; - } - - nssv_constexpr bool ends_with(CharT c) const nssv_noexcept // (2) - { - return ends_with(basic_string_view(&c, 1)); - } - - nssv_constexpr bool ends_with(CharT const *s) const // (3) - { - return ends_with(basic_string_view(s)); - } - - // find(), 4x: - - nssv_constexpr14 size_type find(basic_string_view v, size_type pos = 0) const nssv_noexcept // (1) - { - return assert(v.size() == 0 || v.data() != nssv_nullptr), - pos >= size() ? npos : to_pos(std::search(cbegin() + pos, cend(), v.cbegin(), v.cend(), Traits::eq)); - } - - nssv_constexpr14 size_type find(CharT c, size_type pos = 0) const nssv_noexcept // (2) - { - return find(basic_string_view(&c, 1), pos); - } - - nssv_constexpr14 size_type find(CharT const *s, size_type pos, size_type n) const // (3) - { - return find(basic_string_view(s, n), pos); - } - - nssv_constexpr14 size_type find(CharT const *s, size_type pos = 0) const // (4) - { - return find(basic_string_view(s), pos); - } - - // rfind(), 4x: - - nssv_constexpr14 size_type rfind(basic_string_view v, size_type pos = npos) const nssv_noexcept // (1) - { - if (size() < v.size()) { - return npos; - } - - if (v.empty()) { - return (std::min)(size(), pos); - } - - const_iterator last = cbegin() + (std::min)(size() - v.size(), pos) + v.size(); - const_iterator result = std::find_end(cbegin(), last, v.cbegin(), v.cend(), Traits::eq); - - return result != last ? size_type(result - cbegin()) : npos; - } - - nssv_constexpr14 size_type rfind(CharT c, size_type pos = npos) const nssv_noexcept // (2) - { - return rfind(basic_string_view(&c, 1), pos); - } - - nssv_constexpr14 size_type rfind(CharT const *s, size_type pos, size_type n) const // (3) - { - return rfind(basic_string_view(s, n), pos); - } - - nssv_constexpr14 size_type rfind(CharT const *s, size_type pos = npos) const // (4) - { - return rfind(basic_string_view(s), pos); - } - - // find_first_of(), 4x: - - nssv_constexpr size_type find_first_of(basic_string_view v, size_type pos = 0) const nssv_noexcept // (1) - { - return pos >= size() ? npos - : to_pos(std::find_first_of(cbegin() + pos, cend(), v.cbegin(), v.cend(), Traits::eq)); - } - - nssv_constexpr size_type find_first_of(CharT c, size_type pos = 0) const nssv_noexcept // (2) - { - return find_first_of(basic_string_view(&c, 1), pos); - } - - nssv_constexpr size_type find_first_of(CharT const *s, size_type pos, size_type n) const // (3) - { - return find_first_of(basic_string_view(s, n), pos); - } - - nssv_constexpr size_type find_first_of(CharT const *s, size_type pos = 0) const // (4) - { - return find_first_of(basic_string_view(s), pos); - } - - // find_last_of(), 4x: - - nssv_constexpr size_type find_last_of(basic_string_view v, size_type pos = npos) const nssv_noexcept // (1) - { - return empty() ? npos - : pos >= size() ? find_last_of(v, size() - 1) - : to_pos(std::find_first_of(const_reverse_iterator(cbegin() + pos + 1), crend(), - v.cbegin(), v.cend(), Traits::eq)); - } - - nssv_constexpr size_type find_last_of(CharT c, size_type pos = npos) const nssv_noexcept // (2) - { - return find_last_of(basic_string_view(&c, 1), pos); - } - - nssv_constexpr size_type find_last_of(CharT const *s, size_type pos, size_type count) const // (3) - { - return find_last_of(basic_string_view(s, count), pos); - } - - nssv_constexpr size_type find_last_of(CharT const *s, size_type pos = npos) const // (4) - { - return find_last_of(basic_string_view(s), pos); - } - - // find_first_not_of(), 4x: - - nssv_constexpr size_type find_first_not_of(basic_string_view v, size_type pos = 0) const nssv_noexcept // (1) - { - return pos >= size() ? npos : to_pos(std::find_if(cbegin() + pos, cend(), not_in_view(v))); - } - - nssv_constexpr size_type find_first_not_of(CharT c, size_type pos = 0) const nssv_noexcept // (2) - { - return find_first_not_of(basic_string_view(&c, 1), pos); - } - - nssv_constexpr size_type find_first_not_of(CharT const *s, size_type pos, size_type count) const // (3) - { - return find_first_not_of(basic_string_view(s, count), pos); - } - - nssv_constexpr size_type find_first_not_of(CharT const *s, size_type pos = 0) const // (4) - { - return find_first_not_of(basic_string_view(s), pos); - } - - // find_last_not_of(), 4x: - - nssv_constexpr size_type find_last_not_of(basic_string_view v, size_type pos = npos) const nssv_noexcept // (1) - { - return empty() ? npos - : pos >= size() - ? find_last_not_of(v, size() - 1) - : to_pos(std::find_if(const_reverse_iterator(cbegin() + pos + 1), crend(), not_in_view(v))); - } - - nssv_constexpr size_type find_last_not_of(CharT c, size_type pos = npos) const nssv_noexcept // (2) - { - return find_last_not_of(basic_string_view(&c, 1), pos); - } - - nssv_constexpr size_type find_last_not_of(CharT const *s, size_type pos, size_type count) const // (3) - { - return find_last_not_of(basic_string_view(s, count), pos); - } - - nssv_constexpr size_type find_last_not_of(CharT const *s, size_type pos = npos) const // (4) - { - return find_last_not_of(basic_string_view(s), pos); - } - - // Constants: - -#if nssv_CPP17_OR_GREATER - static nssv_constexpr size_type npos = size_type(-1); -#elif nssv_CPP11_OR_GREATER - enum : size_type { npos = size_type(-1) }; -#else - enum { npos = size_type(-1) }; -#endif - - private: - struct not_in_view { - const basic_string_view v; - - nssv_constexpr explicit not_in_view(basic_string_view v) : v(v) {} - - nssv_constexpr bool operator()(CharT c) const { return npos == v.find_first_of(c); } - }; - - nssv_constexpr size_type to_pos(const_iterator it) const { return it == cend() ? npos : size_type(it - cbegin()); } - - nssv_constexpr size_type to_pos(const_reverse_iterator it) const { - return it == crend() ? npos : size_type(crend() - it - 1); - } - - nssv_constexpr const_reference data_at(size_type pos) const { -#if nssv_BETWEEN(nssv_COMPILER_GNUC_VERSION, 1, 500) - return data_[pos]; -#else - return assert(pos < size()), data_[pos]; -#endif - } - - private: - const_pointer data_; - size_type size_; - - public: -#if nssv_CONFIG_CONVERSION_STD_STRING_CLASS_METHODS - - template <class Allocator> - basic_string_view(std::basic_string<CharT, Traits, Allocator> const &s) nssv_noexcept : data_(s.data()), - size_(s.size()) {} - -#if nssv_HAVE_EXPLICIT_CONVERSION - - template <class Allocator> explicit operator std::basic_string<CharT, Traits, Allocator>() const { - return to_string(Allocator()); - } - -#endif // nssv_HAVE_EXPLICIT_CONVERSION - -#if nssv_CPP11_OR_GREATER - - template <class Allocator = std::allocator<CharT>> - std::basic_string<CharT, Traits, Allocator> to_string(Allocator const &a = Allocator()) const { - return std::basic_string<CharT, Traits, Allocator>(begin(), end(), a); - } - -#else - - std::basic_string<CharT, Traits> to_string() const { return std::basic_string<CharT, Traits>(begin(), end()); } - - template <class Allocator> std::basic_string<CharT, Traits, Allocator> to_string(Allocator const &a) const { - return std::basic_string<CharT, Traits, Allocator>(begin(), end(), a); - } - -#endif // nssv_CPP11_OR_GREATER - -#endif // nssv_CONFIG_CONVERSION_STD_STRING_CLASS_METHODS - }; - - // - // Non-member functions: - // - - // 24.4.3 Non-member comparison functions: - // lexicographically compare two string views (function template): - - template <class CharT, class Traits> - nssv_constexpr bool operator==(basic_string_view<CharT, Traits> lhs, - basic_string_view<CharT, Traits> rhs) nssv_noexcept { - return lhs.compare(rhs) == 0; - } - - template <class CharT, class Traits> - nssv_constexpr bool operator!=(basic_string_view<CharT, Traits> lhs, - basic_string_view<CharT, Traits> rhs) nssv_noexcept { - return lhs.compare(rhs) != 0; - } - - template <class CharT, class Traits> - nssv_constexpr bool operator<(basic_string_view<CharT, Traits> lhs, - basic_string_view<CharT, Traits> rhs) nssv_noexcept { - return lhs.compare(rhs) < 0; - } - - template <class CharT, class Traits> - nssv_constexpr bool operator<=(basic_string_view<CharT, Traits> lhs, - basic_string_view<CharT, Traits> rhs) nssv_noexcept { - return lhs.compare(rhs) <= 0; - } - - template <class CharT, class Traits> - nssv_constexpr bool operator>(basic_string_view<CharT, Traits> lhs, - basic_string_view<CharT, Traits> rhs) nssv_noexcept { - return lhs.compare(rhs) > 0; - } - - template <class CharT, class Traits> - nssv_constexpr bool operator>=(basic_string_view<CharT, Traits> lhs, - basic_string_view<CharT, Traits> rhs) nssv_noexcept { - return lhs.compare(rhs) >= 0; - } - - // Let S be basic_string_view<CharT, Traits>, and sv be an instance of S. - // Implementations shall provide sufficient additional overloads marked - // constexpr and noexcept so that an object t with an implicit conversion - // to S can be compared according to Table 67. - -#if !nssv_CPP11_OR_GREATER || nssv_BETWEEN(nssv_COMPILER_MSVC_VERSION, 100, 141) - - // accomodate for older compilers: - - // == - - template <class CharT, class Traits> - nssv_constexpr bool operator==(basic_string_view<CharT, Traits> lhs, char const *rhs) nssv_noexcept { - return lhs.compare(rhs) == 0; - } - - template <class CharT, class Traits> - nssv_constexpr bool operator==(char const *lhs, basic_string_view<CharT, Traits> rhs) nssv_noexcept { - return rhs.compare(lhs) == 0; - } - - template <class CharT, class Traits> - nssv_constexpr bool operator==(basic_string_view<CharT, Traits> lhs, - std::basic_string<CharT, Traits> rhs) nssv_noexcept { - return lhs.size() == rhs.size() && lhs.compare(rhs) == 0; - } - - template <class CharT, class Traits> - nssv_constexpr bool operator==(std::basic_string<CharT, Traits> rhs, - basic_string_view<CharT, Traits> lhs) nssv_noexcept { - return lhs.size() == rhs.size() && lhs.compare(rhs) == 0; - } - - // != - - template <class CharT, class Traits> - nssv_constexpr bool operator!=(basic_string_view<CharT, Traits> lhs, char const *rhs) nssv_noexcept { - return lhs.compare(rhs) != 0; - } - - template <class CharT, class Traits> - nssv_constexpr bool operator!=(char const *lhs, basic_string_view<CharT, Traits> rhs) nssv_noexcept { - return rhs.compare(lhs) != 0; - } - - template <class CharT, class Traits> - nssv_constexpr bool operator!=(basic_string_view<CharT, Traits> lhs, - std::basic_string<CharT, Traits> rhs) nssv_noexcept { - return lhs.size() != rhs.size() && lhs.compare(rhs) != 0; - } - - template <class CharT, class Traits> - nssv_constexpr bool operator!=(std::basic_string<CharT, Traits> rhs, - basic_string_view<CharT, Traits> lhs) nssv_noexcept { - return lhs.size() != rhs.size() || rhs.compare(lhs) != 0; - } - - // < - - template <class CharT, class Traits> - nssv_constexpr bool operator<(basic_string_view<CharT, Traits> lhs, char const *rhs) nssv_noexcept { - return lhs.compare(rhs) < 0; - } - - template <class CharT, class Traits> - nssv_constexpr bool operator<(char const *lhs, basic_string_view<CharT, Traits> rhs) nssv_noexcept { - return rhs.compare(lhs) > 0; - } - - template <class CharT, class Traits> - nssv_constexpr bool operator<(basic_string_view<CharT, Traits> lhs, - std::basic_string<CharT, Traits> rhs) nssv_noexcept { - return lhs.compare(rhs) < 0; - } - - template <class CharT, class Traits> - nssv_constexpr bool operator<(std::basic_string<CharT, Traits> rhs, - basic_string_view<CharT, Traits> lhs) nssv_noexcept { - return rhs.compare(lhs) > 0; - } - - // <= - - template <class CharT, class Traits> - nssv_constexpr bool operator<=(basic_string_view<CharT, Traits> lhs, char const *rhs) nssv_noexcept { - return lhs.compare(rhs) <= 0; - } - - template <class CharT, class Traits> - nssv_constexpr bool operator<=(char const *lhs, basic_string_view<CharT, Traits> rhs) nssv_noexcept { - return rhs.compare(lhs) >= 0; - } - - template <class CharT, class Traits> - nssv_constexpr bool operator<=(basic_string_view<CharT, Traits> lhs, - std::basic_string<CharT, Traits> rhs) nssv_noexcept { - return lhs.compare(rhs) <= 0; - } - - template <class CharT, class Traits> - nssv_constexpr bool operator<=(std::basic_string<CharT, Traits> rhs, - basic_string_view<CharT, Traits> lhs) nssv_noexcept { - return rhs.compare(lhs) >= 0; - } - - // > - - template <class CharT, class Traits> - nssv_constexpr bool operator>(basic_string_view<CharT, Traits> lhs, char const *rhs) nssv_noexcept { - return lhs.compare(rhs) > 0; - } - - template <class CharT, class Traits> - nssv_constexpr bool operator>(char const *lhs, basic_string_view<CharT, Traits> rhs) nssv_noexcept { - return rhs.compare(lhs) < 0; - } - - template <class CharT, class Traits> - nssv_constexpr bool operator>(basic_string_view<CharT, Traits> lhs, - std::basic_string<CharT, Traits> rhs) nssv_noexcept { - return lhs.compare(rhs) > 0; - } - - template <class CharT, class Traits> - nssv_constexpr bool operator>(std::basic_string<CharT, Traits> rhs, - basic_string_view<CharT, Traits> lhs) nssv_noexcept { - return rhs.compare(lhs) < 0; - } - - // >= - - template <class CharT, class Traits> - nssv_constexpr bool operator>=(basic_string_view<CharT, Traits> lhs, char const *rhs) nssv_noexcept { - return lhs.compare(rhs) >= 0; - } - - template <class CharT, class Traits> - nssv_constexpr bool operator>=(char const *lhs, basic_string_view<CharT, Traits> rhs) nssv_noexcept { - return rhs.compare(lhs) <= 0; - } - - template <class CharT, class Traits> - nssv_constexpr bool operator>=(basic_string_view<CharT, Traits> lhs, - std::basic_string<CharT, Traits> rhs) nssv_noexcept { - return lhs.compare(rhs) >= 0; - } - - template <class CharT, class Traits> - nssv_constexpr bool operator>=(std::basic_string<CharT, Traits> rhs, - basic_string_view<CharT, Traits> lhs) nssv_noexcept { - return rhs.compare(lhs) <= 0; - } - -#else // newer compilers: - -#define nssv_BASIC_STRING_VIEW_I(T, U) typename std::decay<basic_string_view<T, U>>::type - -#if nssv_BETWEEN(nssv_COMPILER_MSVC_VERSION, 140, 150) -#define nssv_MSVC_ORDER(x) , int = x -#else -#define nssv_MSVC_ORDER(x) /*, int=x*/ -#endif - - // == - - template <class CharT, class Traits nssv_MSVC_ORDER(1)> - nssv_constexpr bool operator==(basic_string_view<CharT, Traits> lhs, - nssv_BASIC_STRING_VIEW_I(CharT, Traits) rhs) nssv_noexcept { - return lhs.compare(rhs) == 0; - } - - template <class CharT, class Traits nssv_MSVC_ORDER(2)> - nssv_constexpr bool operator==(nssv_BASIC_STRING_VIEW_I(CharT, Traits) lhs, - basic_string_view<CharT, Traits> rhs) nssv_noexcept { - return lhs.size() == rhs.size() && lhs.compare(rhs) == 0; - } - - // != - - template <class CharT, class Traits nssv_MSVC_ORDER(1)> - nssv_constexpr bool operator!=(basic_string_view<CharT, Traits> lhs, - nssv_BASIC_STRING_VIEW_I(CharT, Traits) rhs) nssv_noexcept { - return lhs.size() != rhs.size() || lhs.compare(rhs) != 0; - } - - template <class CharT, class Traits nssv_MSVC_ORDER(2)> - nssv_constexpr bool operator!=(nssv_BASIC_STRING_VIEW_I(CharT, Traits) lhs, - basic_string_view<CharT, Traits> rhs) nssv_noexcept { - return lhs.compare(rhs) != 0; - } - - // < - - template <class CharT, class Traits nssv_MSVC_ORDER(1)> - nssv_constexpr bool operator<(basic_string_view<CharT, Traits> lhs, - nssv_BASIC_STRING_VIEW_I(CharT, Traits) rhs) nssv_noexcept { - return lhs.compare(rhs) < 0; - } - - template <class CharT, class Traits nssv_MSVC_ORDER(2)> - nssv_constexpr bool operator<(nssv_BASIC_STRING_VIEW_I(CharT, Traits) lhs, - basic_string_view<CharT, Traits> rhs) nssv_noexcept { - return lhs.compare(rhs) < 0; - } - - // <= - - template <class CharT, class Traits nssv_MSVC_ORDER(1)> - nssv_constexpr bool operator<=(basic_string_view<CharT, Traits> lhs, - nssv_BASIC_STRING_VIEW_I(CharT, Traits) rhs) nssv_noexcept { - return lhs.compare(rhs) <= 0; - } - - template <class CharT, class Traits nssv_MSVC_ORDER(2)> - nssv_constexpr bool operator<=(nssv_BASIC_STRING_VIEW_I(CharT, Traits) lhs, - basic_string_view<CharT, Traits> rhs) nssv_noexcept { - return lhs.compare(rhs) <= 0; - } - - // > - - template <class CharT, class Traits nssv_MSVC_ORDER(1)> - nssv_constexpr bool operator>(basic_string_view<CharT, Traits> lhs, - nssv_BASIC_STRING_VIEW_I(CharT, Traits) rhs) nssv_noexcept { - return lhs.compare(rhs) > 0; - } - - template <class CharT, class Traits nssv_MSVC_ORDER(2)> - nssv_constexpr bool operator>(nssv_BASIC_STRING_VIEW_I(CharT, Traits) lhs, - basic_string_view<CharT, Traits> rhs) nssv_noexcept { - return lhs.compare(rhs) > 0; - } - - // >= - - template <class CharT, class Traits nssv_MSVC_ORDER(1)> - nssv_constexpr bool operator>=(basic_string_view<CharT, Traits> lhs, - nssv_BASIC_STRING_VIEW_I(CharT, Traits) rhs) nssv_noexcept { - return lhs.compare(rhs) >= 0; - } - - template <class CharT, class Traits nssv_MSVC_ORDER(2)> - nssv_constexpr bool operator>=(nssv_BASIC_STRING_VIEW_I(CharT, Traits) lhs, - basic_string_view<CharT, Traits> rhs) nssv_noexcept { - return lhs.compare(rhs) >= 0; - } - -#undef nssv_MSVC_ORDER -#undef nssv_BASIC_STRING_VIEW_I - -#endif // compiler-dependent approach to comparisons - - // 24.4.4 Inserters and extractors: - - namespace detail { - - template <class Stream> void write_padding(Stream &os, std::streamsize n) { - for (std::streamsize i = 0; i < n; ++i) - os.rdbuf()->sputc(os.fill()); - } - - template <class Stream, class View> Stream &write_to_stream(Stream &os, View const &sv) { - typename Stream::sentry sentry(os); - - if (!os) - return os; - - const std::streamsize length = static_cast<std::streamsize>(sv.length()); - - // Whether, and how, to pad: - const bool pad = (length < os.width()); - const bool left_pad = pad && (os.flags() & std::ios_base::adjustfield) == std::ios_base::right; - - if (left_pad) - write_padding(os, os.width() - length); - - // Write span characters: - os.rdbuf()->sputn(sv.begin(), length); - - if (pad && !left_pad) - write_padding(os, os.width() - length); - - // Reset output stream width: - os.width(0); - - return os; - } - - } // namespace detail - - template <class CharT, class Traits> - std::basic_ostream<CharT, Traits> &operator<<(std::basic_ostream<CharT, Traits> &os, - basic_string_view<CharT, Traits> sv) { - return detail::write_to_stream(os, sv); - } - - // Several typedefs for common character types are provided: - - typedef basic_string_view<char> string_view; - typedef basic_string_view<wchar_t> wstring_view; -#if nssv_HAVE_WCHAR16_T - typedef basic_string_view<char16_t> u16string_view; - typedef basic_string_view<char32_t> u32string_view; -#endif - - } // namespace sv_lite -} // namespace nonstd::sv_lite - -// -// 24.4.6 Suffix for basic_string_view literals: -// - -#if nssv_HAVE_USER_DEFINED_LITERALS - -namespace nonstd { -nssv_inline_ns namespace literals { - nssv_inline_ns namespace string_view_literals { - -#if nssv_CONFIG_STD_SV_OPERATOR && nssv_HAVE_STD_DEFINED_LITERALS - - nssv_constexpr nonstd::sv_lite::string_view operator"" sv(const char *str, size_t len) nssv_noexcept // (1) - { - return nonstd::sv_lite::string_view {str, len}; - } - - nssv_constexpr nonstd::sv_lite::u16string_view operator"" sv(const char16_t *str, size_t len) nssv_noexcept // (2) - { - return nonstd::sv_lite::u16string_view {str, len}; - } - - nssv_constexpr nonstd::sv_lite::u32string_view operator"" sv(const char32_t *str, size_t len) nssv_noexcept // (3) - { - return nonstd::sv_lite::u32string_view {str, len}; - } - - nssv_constexpr nonstd::sv_lite::wstring_view operator"" sv(const wchar_t *str, size_t len) nssv_noexcept // (4) - { - return nonstd::sv_lite::wstring_view {str, len}; - } - -#endif // nssv_CONFIG_STD_SV_OPERATOR && nssv_HAVE_STD_DEFINED_LITERALS - -#if nssv_CONFIG_USR_SV_OPERATOR - - nssv_constexpr nonstd::sv_lite::string_view operator"" _sv(const char *str, size_t len) nssv_noexcept // (1) - { - return nonstd::sv_lite::string_view {str, len}; - } - - nssv_constexpr nonstd::sv_lite::u16string_view operator"" _sv(const char16_t *str, size_t len) nssv_noexcept // (2) - { - return nonstd::sv_lite::u16string_view {str, len}; - } - - nssv_constexpr nonstd::sv_lite::u32string_view operator"" _sv(const char32_t *str, size_t len) nssv_noexcept // (3) - { - return nonstd::sv_lite::u32string_view {str, len}; - } - - nssv_constexpr nonstd::sv_lite::wstring_view operator"" _sv(const wchar_t *str, size_t len) nssv_noexcept // (4) - { - return nonstd::sv_lite::wstring_view {str, len}; - } - -#endif // nssv_CONFIG_USR_SV_OPERATOR - } -} -} // namespace nonstd - -#endif - -// -// Extensions for std::string: -// - -#if nssv_CONFIG_CONVERSION_STD_STRING_FREE_FUNCTIONS - -namespace nonstd { -namespace sv_lite { - -// Exclude MSVC 14 (19.00): it yields ambiguous to_string(): - -#if nssv_CPP11_OR_GREATER && nssv_COMPILER_MSVC_VERSION != 140 - -template <class CharT, class Traits, class Allocator = std::allocator<CharT>> -std::basic_string<CharT, Traits, Allocator> to_string(basic_string_view<CharT, Traits> v, - Allocator const &a = Allocator()) { - return std::basic_string<CharT, Traits, Allocator>(v.begin(), v.end(), a); -} - -#else - -template <class CharT, class Traits> std::basic_string<CharT, Traits> to_string(basic_string_view<CharT, Traits> v) { - return std::basic_string<CharT, Traits>(v.begin(), v.end()); -} - -template <class CharT, class Traits, class Allocator> -std::basic_string<CharT, Traits, Allocator> to_string(basic_string_view<CharT, Traits> v, Allocator const &a) { - return std::basic_string<CharT, Traits, Allocator>(v.begin(), v.end(), a); -} - -#endif // nssv_CPP11_OR_GREATER - -template <class CharT, class Traits, class Allocator> -basic_string_view<CharT, Traits> to_string_view(std::basic_string<CharT, Traits, Allocator> const &s) { - return basic_string_view<CharT, Traits>(s.data(), s.size()); -} - -} // namespace sv_lite -} // namespace nonstd - -#endif // nssv_CONFIG_CONVERSION_STD_STRING_FREE_FUNCTIONS - -// -// make types and algorithms available in namespace nonstd: -// - -namespace nonstd { - -using sv_lite::basic_string_view; -using sv_lite::string_view; -using sv_lite::wstring_view; - -#if nssv_HAVE_WCHAR16_T -using sv_lite::u16string_view; -#endif -#if nssv_HAVE_WCHAR32_T -using sv_lite::u32string_view; -#endif - -// literal "sv" - -using sv_lite::operator==; -using sv_lite::operator!=; -using sv_lite::operator<; -using sv_lite::operator<=; -using sv_lite::operator>; -using sv_lite::operator>=; - -using sv_lite::operator<<; - -#if nssv_CONFIG_CONVERSION_STD_STRING_FREE_FUNCTIONS -using sv_lite::to_string; -using sv_lite::to_string_view; -#endif - -} // namespace nonstd - -// 24.4.5 Hash support (C++11): - -// Note: The hash value of a string view object is equal to the hash value of -// the corresponding string object. - -#if nssv_HAVE_STD_HASH - -#include <functional> - -namespace std { - -template <> struct hash<nonstd::string_view> { -public: - std::size_t operator()(nonstd::string_view v) const nssv_noexcept { - return std::hash<std::string>()(std::string(v.data(), v.size())); - } -}; - -template <> struct hash<nonstd::wstring_view> { -public: - std::size_t operator()(nonstd::wstring_view v) const nssv_noexcept { - return std::hash<std::wstring>()(std::wstring(v.data(), v.size())); - } -}; - -template <> struct hash<nonstd::u16string_view> { -public: - std::size_t operator()(nonstd::u16string_view v) const nssv_noexcept { - return std::hash<std::u16string>()(std::u16string(v.data(), v.size())); - } -}; - -template <> struct hash<nonstd::u32string_view> { -public: - std::size_t operator()(nonstd::u32string_view v) const nssv_noexcept { - return std::hash<std::u32string>()(std::u32string(v.data(), v.size())); - } -}; - -} // namespace std - -#endif // nssv_HAVE_STD_HASH - -nssv_RESTORE_WARNINGS() - -#endif // nssv_HAVE_STD_STRING_VIEW -#endif // NONSTD_SV_LITE_H_INCLUDED diff --git a/include/inja/template.hpp b/include/inja/template.hpp index 9de0a96..a396dd5 100644 --- a/include/inja/template.hpp +++ b/include/inja/template.hpp @@ -1,5 +1,3 @@ -// Copyright (c) 2019 Pantor. All rights reserved. - #ifndef INCLUDE_INJA_TEMPLATE_HPP_ #define INCLUDE_INJA_TEMPLATE_HPP_ @@ -11,7 +9,6 @@ #include "node.hpp" #include "statistics.hpp" - namespace inja { /*! @@ -20,9 +17,10 @@ namespace inja { struct Template { BlockNode root; std::string content; + std::map<std::string, std::shared_ptr<BlockStatementNode>> block_storage; - explicit Template() { } - explicit Template(const std::string& content): content(content) { } + explicit Template() {} + explicit Template(const std::string& content): content(content) {} /// Return number of variables (total number, not distinct ones) in the template int count_variables() { diff --git a/include/inja/token.hpp b/include/inja/token.hpp index c000138..207e78e 100644 --- a/include/inja/token.hpp +++ b/include/inja/token.hpp @@ -1,11 +1,8 @@ -// Copyright (c) 2020 Pantor. All rights reserved. - #ifndef INCLUDE_INJA_TOKEN_HPP_ #define INCLUDE_INJA_TOKEN_HPP_ #include <string> - -#include "string_view.hpp" +#include <string_view> namespace inja { @@ -50,12 +47,12 @@ struct Token { Unknown, Eof, }; - + Kind kind {Kind::Unknown}; - nonstd::string_view text; + std::string_view text; explicit constexpr Token() = default; - explicit constexpr Token(Kind kind, nonstd::string_view text) : kind(kind), text(text) {} + explicit constexpr Token(Kind kind, std::string_view text): kind(kind), text(text) {} std::string describe() const { switch (kind) { diff --git a/include/inja/utils.hpp b/include/inja/utils.hpp index fb1736c..4de05fd 100644 --- a/include/inja/utils.hpp +++ b/include/inja/utils.hpp @@ -1,53 +1,42 @@ -// Copyright (c) 2020 Pantor. All rights reserved. - #ifndef INCLUDE_INJA_UTILS_HPP_ #define INCLUDE_INJA_UTILS_HPP_ #include <algorithm> #include <fstream> #include <string> +#include <string_view> #include <utility> #include "exceptions.hpp" -#include "string_view.hpp" namespace inja { -inline void open_file_or_throw(const std::string &path, std::ifstream &file) { - file.exceptions(std::ifstream::failbit | std::ifstream::badbit); - try { - file.open(path); - } catch (const std::ios_base::failure & /*e*/) { - INJA_THROW(FileError("failed accessing file at '" + path + "'")); - } -} - namespace string_view { -inline nonstd::string_view slice(nonstd::string_view view, size_t start, size_t end) { +inline std::string_view slice(std::string_view view, size_t start, size_t end) { start = std::min(start, view.size()); end = std::min(std::max(start, end), view.size()); return view.substr(start, end - start); } -inline std::pair<nonstd::string_view, nonstd::string_view> split(nonstd::string_view view, char Separator) { +inline std::pair<std::string_view, std::string_view> split(std::string_view view, char Separator) { size_t idx = view.find(Separator); - if (idx == nonstd::string_view::npos) { - return std::make_pair(view, nonstd::string_view()); + if (idx == std::string_view::npos) { + return std::make_pair(view, std::string_view()); } - return std::make_pair(slice(view, 0, idx), slice(view, idx + 1, nonstd::string_view::npos)); + return std::make_pair(slice(view, 0, idx), slice(view, idx + 1, std::string_view::npos)); } -inline bool starts_with(nonstd::string_view view, nonstd::string_view prefix) { +inline bool starts_with(std::string_view view, std::string_view prefix) { return (view.size() >= prefix.size() && view.compare(0, prefix.size(), prefix) == 0); } } // namespace string_view -inline SourceLocation get_source_location(nonstd::string_view content, size_t pos) { +inline SourceLocation get_source_location(std::string_view content, size_t pos) { // Get line and offset position (starts at 1:1) auto sliced = string_view::slice(content, 0, pos); std::size_t last_newline = sliced.rfind("\n"); - if (last_newline == nonstd::string_view::npos) { + if (last_newline == std::string_view::npos) { return {1, sliced.length() + 1}; } @@ -65,6 +54,17 @@ inline SourceLocation get_source_location(nonstd::string_view content, size_t po return {count_lines + 1, sliced.length() - last_newline}; } +inline void replace_substring(std::string& s, const std::string& f, const std::string& t) { + if (f.empty()) { + return; + } + for (auto pos = s.find(f); // find first occurrence of f + pos != std::string::npos; // make sure f was found + s.replace(pos, f.size(), t), // replace with t, and + pos = s.find(f, pos + t.size())) // find next occurrence of f + {} +} + } // namespace inja #endif // INCLUDE_INJA_UTILS_HPP_ |