| // Copyright 2019 The Fuchsia Authors. All rights reserved. | |
| // Use of this source code is governed by a BSD-style license that can be | |
| // found in the LICENSE file. | |
| // This is the filter language parser. Given a filter specification string, the goal is to construct | |
| // an object that represents the filter described by the specification. | |
| // | |
| // The parser is composed of a public interface, described in this file, and internal syntax and | |
| // state implemented in the other parser files. The current design is that the parser is coupled | |
| // with the lexer, as the knowledge about reserved keywords in the filter language must be shared | |
| // between them. However, the parser is agnostic to the concrete form the filter object takes. | |
| // In the classes relating to the parser, the template argument `T` is the type of the filter object | |
| // that will be constructed. | |
| // | |
| // Key to the public parser interface is the `FilterBuilder<T>` class, declared in its own file. Due | |
| // to template classes, the body of parser code is organized as a series of header files. | |
| #ifndef SRC_CONNECTIVITY_NETWORK_NETDUMP_PARSER_H_ | |
| #define SRC_CONNECTIVITY_NETWORK_NETDUMP_PARSER_H_ | |
| #include <ostream> | |
| #include <sstream> | |
| #include <variant> | |
| #include "parser_internal.h" | |
| namespace netdump::parser { | |
| // ANSI escape sequences used for highlighting. | |
| constexpr auto ANSI_BOLD = "\033[1m"; | |
| constexpr auto ANSI_HIGHLIGHT = "\033[1;30;43m"; | |
| constexpr auto ANSI_HIGHLIGHT_ERROR = "\033[4;31;43m"; | |
| constexpr auto ANSI_RESET = "\033[0m"; | |
| using ParseError = std::string; | |
| // Clients access the parsing functionality through this class. | |
| class Parser { | |
| public: | |
| // Specifies the `Tokenizer` to use for parsing. | |
| explicit Parser(const Tokenizer& tkz) : tkz_(tkz) {} | |
| // Attempt a parse of `filter_spec` and return a filter of type `T` built with `builder`. | |
| // If the input is successfully parsed, a `T` (variant index 0) is returned. | |
| // If parsing is unsuccessful, an `Error` (index 1) is returned that explains the syntax error. | |
| template <class T> | |
| std::variant<T, ParseError> parse(const std::string& filter_spec, FilterBuilder<T>* builder) { | |
| Environment env(tkz_.tokenize(filter_spec)); | |
| if (env.at_end()) { | |
| return error_result<T>("Filter string expected.\n"); | |
| } | |
| std::optional<T> filter = parse(&env, builder); | |
| if (filter != std::nullopt) { | |
| // Parse success, return the filter. | |
| return filter_result(std::move(*filter)); | |
| } | |
| // On parse error, build the error message. | |
| std::string msg = highlight_error(filter_spec, &env); | |
| return error_result<T>(msg + "\nFilter syntax error: " + env.error_cause + "\n"); | |
| } | |
| Parser(const Parser&) = delete; | |
| Parser& operator=(const Parser&) = delete; | |
| protected: // Protected instead of private for testing. | |
| const Tokenizer& tkz_; | |
| // Allow subclasses to inject a custom `Environment`, e.g. for testing. | |
| template <class T> | |
| inline std::optional<T> parse(Environment* env, FilterBuilder<T>* builder) { | |
| return Syntax<T>(tkz_, env, builder).parse(); | |
| } | |
| // Insert some ANSI escape characters to highlight the syntax error in console. | |
| // If the error is at the end location, highlight this by reproducing `filter_spec` and | |
| // appending an error marker. Otherwise, the the tokens in `env` are reproduced, and the | |
| // location where the error occurred is highlighted. | |
| std::string highlight_error(const std::string& filter_spec, Environment* env) { | |
| if (!env->error_loc.has_value()) { | |
| return filter_spec; | |
| } | |
| std::stringstream msg; | |
| auto error_loc = *(env->error_loc); | |
| if (error_loc == env->end()) { | |
| // The mistake is at the end of the input. | |
| msg << filter_spec << ANSI_HIGHLIGHT_ERROR << "*" << ANSI_RESET; | |
| return msg.str(); | |
| } | |
| // Go to the mistake and highlight it. | |
| env->reset(); | |
| while (!env->at_end()) { | |
| if (error_loc == env->cur()) { | |
| msg << ANSI_HIGHLIGHT_ERROR << (**env)->get_term() << ANSI_RESET; | |
| } else { | |
| msg << (**env)->get_term(); | |
| } | |
| ++(*env); | |
| if (!env->at_end()) { | |
| msg << " "; | |
| } | |
| } | |
| return msg.str(); | |
| } | |
| template <class T> | |
| inline std::variant<T, ParseError> filter_result(T filter) { | |
| return std::variant<T, ParseError>(std::in_place_index_t<0>(), std::move(filter)); | |
| } | |
| template <class T> | |
| inline std::variant<T, ParseError> error_result(std::string msg) { | |
| return std::variant<T, ParseError>(std::in_place_index_t<1>(), std::move(msg)); | |
| } | |
| }; | |
| // Write a human-readable description of the parser syntax to `output`, | |
| // such as for display on screen. No significant logic should be performed. | |
| void parser_syntax(std::ostream* output); | |
| } // namespace netdump::parser | |
| #endif // SRC_CONNECTIVITY_NETWORK_NETDUMP_PARSER_H_ |