From 00863566ec4601c65c435b74e575d49546a1c707 Mon Sep 17 00:00:00 2001 From: Egor Tensin Date: Sat, 7 Dec 2019 03:36:21 +0300 Subject: split server into multiple components In a vague attempt to make header files more readable, split server/ into a number of components. Also, refactor the unit tests to use the "Data-driven test cases" of Boost.Test. --- server/CMakeLists.txt | 15 +-- server/common/CMakeLists.txt | 6 + server/common/error.hpp | 15 +++ server/common/log.hpp | 49 ++++++++ server/error.hpp | 15 --- server/lexer.hpp | 261 ---------------------------------------- server/lexer/CMakeLists.txt | 2 + server/lexer/error.hpp | 16 +++ server/lexer/input.hpp | 42 +++++++ server/lexer/lexer.cpp | 206 +++++++++++++++++++++++++++++++ server/lexer/lexer.hpp | 61 ++++++++++ server/lexer/token.cpp | 71 +++++++++++ server/lexer/token.hpp | 49 ++++++++ server/lexer/token_type.cpp | 164 +++++++++++++++++++++++++ server/lexer/token_type.hpp | 37 ++++++ server/log.hpp | 49 -------- server/main.cpp | 34 ------ server/main/CMakeLists.txt | 13 ++ server/main/main.cpp | 34 ++++++ server/main/server.cpp | 112 +++++++++++++++++ server/main/server.hpp | 34 ++++++ server/main/session.cpp | 114 ++++++++++++++++++ server/main/session.hpp | 42 +++++++ server/main/session_manager.cpp | 38 ++++++ server/main/session_manager.hpp | 30 +++++ server/main/settings.hpp | 87 ++++++++++++++ server/parser.hpp | 168 -------------------------- server/parser/CMakeLists.txt | 2 + server/parser/error.hpp | 16 +++ server/parser/operator.hpp | 79 ++++++++++++ server/parser/parser.hpp | 89 ++++++++++++++ server/server.cpp | 111 ----------------- server/server.hpp | 34 ------ server/session.cpp | 113 ----------------- server/session.hpp | 42 ------- server/session_manager.cpp | 37 ------ server/session_manager.hpp | 30 ----- server/settings.hpp | 87 -------------- 38 files changed, 1412 insertions(+), 992 deletions(-) create mode 100644 server/common/CMakeLists.txt create mode 100644 server/common/error.hpp create mode 100644 server/common/log.hpp delete mode 100644 server/error.hpp delete mode 100644 server/lexer.hpp create mode 100644 server/lexer/CMakeLists.txt create mode 100644 server/lexer/error.hpp create mode 100644 server/lexer/input.hpp create mode 100644 server/lexer/lexer.cpp create mode 100644 server/lexer/lexer.hpp create mode 100644 server/lexer/token.cpp create mode 100644 server/lexer/token.hpp create mode 100644 server/lexer/token_type.cpp create mode 100644 server/lexer/token_type.hpp delete mode 100644 server/log.hpp delete mode 100644 server/main.cpp create mode 100644 server/main/CMakeLists.txt create mode 100644 server/main/main.cpp create mode 100644 server/main/server.cpp create mode 100644 server/main/server.hpp create mode 100644 server/main/session.cpp create mode 100644 server/main/session.hpp create mode 100644 server/main/session_manager.cpp create mode 100644 server/main/session_manager.hpp create mode 100644 server/main/settings.hpp delete mode 100644 server/parser.hpp create mode 100644 server/parser/CMakeLists.txt create mode 100644 server/parser/error.hpp create mode 100644 server/parser/operator.hpp create mode 100644 server/parser/parser.hpp delete mode 100644 server/server.cpp delete mode 100644 server/server.hpp delete mode 100644 server/session.cpp delete mode 100644 server/session.hpp delete mode 100644 server/session_manager.cpp delete mode 100644 server/session_manager.hpp delete mode 100644 server/settings.hpp (limited to 'server') diff --git a/server/CMakeLists.txt b/server/CMakeLists.txt index 7bf356a..4339da2 100644 --- a/server/CMakeLists.txt +++ b/server/CMakeLists.txt @@ -1,11 +1,4 @@ -find_package(Boost REQUIRED COMPONENTS filesystem program_options) - -option(DEBUG_ASIO "enable debug output for Boost.Asio" OFF) - -add_executable(server main.cpp server.cpp session.cpp session_manager.cpp) -target_include_directories(server SYSTEM PRIVATE ${Boost_INCLUDE_DIRS}) -target_link_libraries(server PRIVATE ${Boost_LIBRARIES}) - -if(DEBUG_ASIO) - target_compile_definitions(server PRIVATE BOOST_ASIO_ENABLE_HANDLER_TRACKING) -endif() +add_subdirectory(common) +add_subdirectory(lexer) +add_subdirectory(parser) +add_subdirectory(main) diff --git a/server/common/CMakeLists.txt b/server/common/CMakeLists.txt new file mode 100644 index 0000000..5655861 --- /dev/null +++ b/server/common/CMakeLists.txt @@ -0,0 +1,6 @@ +find_package(Boost REQUIRED) + +add_library(common INTERFACE) + +target_include_directories(common SYSTEM INTERFACE ${Boost_INCLUDE_DIRS}) +target_link_libraries(common INTERFACE ${Boost_LIBRARIES}) diff --git a/server/common/error.hpp b/server/common/error.hpp new file mode 100644 index 0000000..cbfbb1e --- /dev/null +++ b/server/common/error.hpp @@ -0,0 +1,15 @@ +#pragma once + +#include +#include + +namespace math::server { + +class Error : public std::runtime_error { +public: + explicit Error(const std::string& what) + : std::runtime_error{"server error: " + what} + { } +}; + +} diff --git a/server/common/log.hpp b/server/common/log.hpp new file mode 100644 index 0000000..ca0fafd --- /dev/null +++ b/server/common/log.hpp @@ -0,0 +1,49 @@ +#pragma once + +#include +#include + +#include + +#include +#include +#include +#include +#include +#include +#include + +namespace math::server::log { + +namespace details { + +inline std::thread::id get_tid() { return std::this_thread::get_id(); } + +inline std::string get_timestamp() { + const auto tt = std::time(nullptr); + std::ostringstream oss; + oss << std::put_time(std::gmtime(&tt), "%Y-%m-%d %H:%M:%S"); + return oss.str(); +} + +inline void log(const std::string& msg) { + std::clog << get_timestamp() << " | " << get_tid() << " | " << msg << '\n'; +} + +} + +template +inline void log(const std::string_view& fmt, Args&&... args) { + details::log(boost::str((boost::format(fmt.data()) % ... % args))); +} + +template +inline void error(const std::string_view& fmt, Args&&... args) { + details::log(boost::str((boost::format(fmt.data()) % ... % args))); +} + +inline void error(const boost::system::error_code& ec) { + details::log(ec.message()); +} + +} diff --git a/server/error.hpp b/server/error.hpp deleted file mode 100644 index cbfbb1e..0000000 --- a/server/error.hpp +++ /dev/null @@ -1,15 +0,0 @@ -#pragma once - -#include -#include - -namespace math::server { - -class Error : public std::runtime_error { -public: - explicit Error(const std::string& what) - : std::runtime_error{"server error: " + what} - { } -}; - -} diff --git a/server/lexer.hpp b/server/lexer.hpp deleted file mode 100644 index 8afe15c..0000000 --- a/server/lexer.hpp +++ /dev/null @@ -1,261 +0,0 @@ -#pragma once - -#include "error.hpp" - -#include - -#include -#include -#include -#include -#include -#include -#include -#include -#include - -namespace math::server { -namespace lexer { - -class Error : public server::Error { -public: - explicit Error(const std::string &what) - : server::Error{"lexer error: " + what} - { } -}; - -class Token { -public: - enum class Type { - LEFT_PAREN, - RIGHT_PAREN, - PLUS, - MINUS, - ASTERISK, - SLASH, - NUMBER, - }; - - explicit Token(Type type) - : m_type{type}, m_number_value{nan()} - { } - - explicit Token(double number_value) - : m_type{Type::NUMBER}, m_number_value{number_value} - { } - - bool operator==(const Token& other) const { - return m_type == other.m_type - && ((is_nan(m_number_value) && is_nan(other.m_number_value)) - || m_number_value == other.m_number_value); - } - - bool operator!=(const Token& other) const { return !(*this == other); } - - Type get_type() const { return m_type; } - - double get_number_value() const { - if (get_type() != Type::NUMBER) { - throw Error{"token must be a number to query its value"}; - } - return m_number_value; - } - -private: - static constexpr double nan() { return std::numeric_limits::quiet_NaN(); } - - static bool is_nan(double x) { return std::isnan(x); } - - Type m_type; - double m_number_value; -}; - -namespace details { - -inline std::string_view match_number(const std::string_view& input) { - static constexpr std::regex::flag_type flags = - std::regex_constants::ECMAScript | - std::regex_constants::icase; - // This is a hacky attempt to describe a C-like grammar for floating-point - // numbers using a regex (the tests seem to pass though). - // A proper NFA would be better, I guess. - static const std::regex number_regex{R"REGEX(^(?:\d+(?:\.\d*)?|\.\d+)(e[+-]?(\d*))?)REGEX", flags}; - - std::cmatch match; - if (!std::regex_search(input.cbegin(), input.cend(), match, number_regex)) { - return {}; - } - // If we have the numeric part of a number followed by 'e' and no digits, - // 1) that 'e' definitely belongs to this number token, - // 2) the user forgot to type in the required digits. - const auto& exponent = match[1]; - const auto& abs_power = match[2]; - if (exponent.matched && abs_power.matched && abs_power.length() == 0) { - throw lexer::Error{"exponent has no digits: " + match[0].str()}; - } - return {match[0].first, match[0].length()}; -} - -inline std::optional parse_number(const std::string_view& input, std::string_view& token) { - const auto view = match_number(input); - if (!view.data()) { - return {}; - } - try { - const auto result = std::stod(std::string{view}); - token = view; - return result; - } catch (const std::exception& e) { - throw lexer::Error{"couldn't parse number from: " + std::string{view}}; - } - return {}; -} - -inline std::optional parse_number(const std::string_view& input) { - std::string_view token; - return parse_number(input, token); -} - -inline bool starts_with(const std::string_view& a, const std::string_view& b) noexcept { - return a.length() >= b.length() - && a.compare(0, b.length(), b) == 0; -} - -inline std::optional parse_const_token(const std::string_view& input, std::string_view& token) { - // FIXME: Potentially error-prone if there's const token A which is a - // prefix of token B (if the map is not sorted, we'd parse token A, when it - // could've been token B). - // Can be solved by sorting the keys accordingly. - - static const std::unordered_map const_tokens{ - {"(", Token::Type::LEFT_PAREN}, - {")", Token::Type::RIGHT_PAREN}, - {"+", Token::Type::PLUS}, - {"-", Token::Type::MINUS}, - {"*", Token::Type::ASTERISK}, - {"/", Token::Type::SLASH}, - }; - - for (const auto& it : const_tokens) { - const auto& str = it.first; - const auto& type = it.second; - - if (starts_with(input, str)) { - token = input.substr(0, str.length()); - return type; - } - } - - return {}; -} - -inline std::optional parse_const_token(const std::string_view& input) { - std::string_view token; - return parse_const_token(input, token); -} - -inline std::string_view parse_whitespace(const std::string_view& input) { - static const std::regex ws_regex{R"(\s*)"}; - - std::cmatch match; - if (std::regex_search(input.cbegin(), input.cend(), match, ws_regex)) { - return {match[0].first, match[0].length()}; - } - return {}; -} - -} - -} - -class Lexer { -public: - explicit Lexer(const std::string_view& input) - : m_input{input} { - } - - using TokenProcessor = std::function; - - bool for_each_token(const TokenProcessor& process) { - parse_token(); - for (auto token = peek_token(); token.has_value(); drop_token(), token = peek_token()) { - if (!process(*token)) { - return false; - } - } - return true; - } - - std::vector get_tokens() { - std::vector tokens; - for_each_token([&tokens] (const lexer::Token& token) { - tokens.emplace_back(token); - return true; - }); - return tokens; - } - - void parse_token() { - if (m_input.length() == 0) { - return; - } - std::string_view token_view; - m_token_buffer = parse_token(token_view); - if (m_token_buffer.has_value()) { - m_input.remove_prefix(token_view.length()); - } - } - - bool has_token() const { - return peek_token().has_value(); - } - - std::optional peek_token() const { - return m_token_buffer; - } - - void drop_token() { - if (!has_token()) { - throw lexer::Error{"internal: no tokens to drop"}; - } - m_token_buffer = {}; - parse_token(); - } - - std::optional drop_token_if(lexer::Token::Type type) { - if (!has_token()) { - throw lexer::Error{"internal: no tokens to drop"}; - } - if (m_token_buffer.value().get_type() != type) { - return {}; - } - const auto result = m_token_buffer; - drop_token(); - return result; - } - -private: - void consume_whitespace() { - const auto ws = lexer::details::parse_whitespace(m_input); - m_input.remove_prefix(ws.length()); - } - - std::optional parse_token(std::string_view& token_view) { - consume_whitespace(); - if (m_input.length() == 0) { - return {}; - } - if (const auto const_token = lexer::details::parse_const_token(m_input, token_view); const_token.has_value()) { - return lexer::Token{*const_token}; - } - if (const auto number = lexer::details::parse_number(m_input, token_view); number.has_value()) { - return lexer::Token{*number}; - } - throw lexer::Error{"invalid input at: " + std::string{m_input}}; - } - - std::string_view m_input; - std::optional m_token_buffer; -}; - -} diff --git a/server/lexer/CMakeLists.txt b/server/lexer/CMakeLists.txt new file mode 100644 index 0000000..65523a7 --- /dev/null +++ b/server/lexer/CMakeLists.txt @@ -0,0 +1,2 @@ +add_library(lexer lexer.cpp token.cpp token_type.cpp) +target_link_libraries(lexer PUBLIC common) diff --git a/server/lexer/error.hpp b/server/lexer/error.hpp new file mode 100644 index 0000000..99944c7 --- /dev/null +++ b/server/lexer/error.hpp @@ -0,0 +1,16 @@ +#pragma once + +#include "../common/error.hpp" + +#include + +namespace math::server { + +class LexerError : public Error { +public: + explicit LexerError(const std::string &what) + : Error{"lexer error: " + what} + { } +}; + +} diff --git a/server/lexer/input.hpp b/server/lexer/input.hpp new file mode 100644 index 0000000..1104a4b --- /dev/null +++ b/server/lexer/input.hpp @@ -0,0 +1,42 @@ +#pragma once + +#include "error.hpp" + +#include + +#include + +namespace math::server::lexer { + +class Input { +public: + explicit Input(const std::string_view& input) + : m_pos{0}, m_input{input} + { } + + const std::string_view& get_input() const { return m_input; } + + std::size_t get_pos() const { return m_pos; } + + std::size_t get_length() const { return m_input.length(); } + + bool empty() const { return m_input.empty(); } + + void consume(std::size_t len) { + if (m_input.length() < len) { + throw LexerError{"internal: not enough input to consume"}; + } + m_pos += len; + m_input.remove_prefix(len); + } + + void consume(const std::string_view& sub) { + consume(sub.length()); + } + +private: + std::size_t m_pos; + std::string_view m_input; +}; + +} diff --git a/server/lexer/lexer.cpp b/server/lexer/lexer.cpp new file mode 100644 index 0000000..c7eea6d --- /dev/null +++ b/server/lexer/lexer.cpp @@ -0,0 +1,206 @@ +#include "error.hpp" +#include "lexer.hpp" +#include "token.hpp" +#include "token_type.hpp" + +#include +#include +#include +#include +#include +#include + +namespace math::server { +namespace lexer { +namespace { + +std::string_view match_number(const std::string_view& input) { + static constexpr std::regex::flag_type flags = + std::regex_constants::ECMAScript | + std::regex_constants::icase; + // This is a hacky attempt to describe a C-like grammar for floating-point + // numbers using a regex (the tests seem to pass though). + // A proper NFA would be better, I guess. + static const std::regex number_regex{R"REGEX(^(?:\d+(?:\.\d*)?|\.\d+)(e[+-]?(\d*))?)REGEX", flags}; + + std::cmatch match; + if (!std::regex_search(input.cbegin(), input.cend(), match, number_regex)) { + return {}; + } + { + // If we have the numeric part of a number followed by 'e' and no digits, + // 1) that 'e' definitely belongs to this number token, + // 2) the user forgot to type in the required digits. + const auto& exponent = match[1]; + const auto& abs_power = match[2]; + if (exponent.matched && abs_power.matched && abs_power.length() == 0) { + throw LexerError{"exponent has no digits: " + match[0].str()}; + } + } + return {match[0].first, match[0].length()}; +} + +std::optional parse_number(const std::string_view& input, std::string_view& token) { + const auto view = match_number(input); + if (!view.data()) { + return {}; + } + try { + const auto result = std::stod(std::string{view}); + token = view; + return result; + } catch (const std::exception& e) { + throw LexerError{"internal: couldn't parse number from: " + std::string{view}}; + } + return {}; +} + +bool starts_with(const std::string_view& a, const std::string_view& b) noexcept { + return a.length() >= b.length() + && a.compare(0, b.length(), b) == 0; +} + +std::optional parse_const_token(const std::string_view& input, std::string_view& token) { + for (const auto type : token::const_tokens()) { + const auto str = token::type_to_string(type); + if (starts_with(input, str)) { + token = {input.cbegin(), str.length()}; + return {type}; + } + } + return {}; +} + +} + +namespace details { + +std::optional parse_number(const std::string_view& input) { + std::string_view token; + return lexer::parse_number(input, token); +} + +std::optional parse_const_token(const std::string_view& input) { + std::string_view token; + return lexer::parse_const_token(input, token); +} + +std::string_view parse_whitespace(const std::string_view& input) { + static const std::regex ws_regex{R"(^\s+)"}; + + std::cmatch match; + if (std::regex_search(input.cbegin(), input.cend(), match, ws_regex)) { + return {match[0].first, match[0].length()}; + } + return {}; +} + +} +} + +Lexer::Lexer(const std::string_view& input) + : Lexer{lexer::Input{input}} { +} + +Lexer::Lexer(const lexer::Input& input) + : m_input{input} { + + consume_token(); +} + +bool Lexer::for_each_token(const TokenProcessor& process) { + for (auto token = peek_token(); token.has_value(); drop_token(), token = peek_token()) { + if (!process(*token)) { + return false; + } + } + return true; +} + +std::vector Lexer::get_tokens() { + std::vector tokens; + for_each_token([&tokens] (const ParsedToken& token) { + tokens.emplace_back(token); + return true; + }); + return tokens; +} + +void Lexer::drop_token() { + if (!has_token()) { + throw LexerError{"internal: no tokens to drop"}; + } + m_token_buffer = {}; + consume_token(); +} + +std::optional Lexer::drop_token_of_type(Type type) { + if (!has_token()) { + throw LexerError{"internal: no tokens to drop"}; + } + if (m_token_buffer.value().get_type() != type) { + return {}; + } + const auto result = m_token_buffer; + drop_token(); + return result; +} + +void Lexer::consume_whitespace() { + const auto ws = parse_whitespace(); + if (!ws.has_value()) { + return; + } + m_input.consume(ws->get_length()); +} + +void Lexer::consume_token() { + if (m_input.empty()) { + return; + } + consume_whitespace(); + if (m_input.empty()) { + return; + } + auto token{parse_token()}; + m_input.consume(token.get_length()); + m_token_buffer = std::move(token); +} + +std::optional Lexer::parse_whitespace() const { + const auto token_view = lexer::details::parse_whitespace(m_input.get_input()); + if (token_view.empty()) { + return {}; + } + return ParsedToken{Token{Token::Type::WHITESPACE}, m_input.get_pos(), token_view}; +} + +std::optional Lexer::parse_const_token() const { + std::string_view token_view; + const auto type = lexer::parse_const_token(m_input.get_input(), token_view); + if (!type.has_value()) { + return {}; + } + return ParsedToken{Token{*type}, m_input.get_pos(), token_view}; +} + +std::optional Lexer::parse_number() const { + std::string_view token_view; + const auto number = lexer::parse_number(m_input.get_input(), token_view); + if (!number.has_value()) { + return {}; + } + return ParsedToken{Token{*number}, m_input.get_pos(), token_view}; +} + +Lexer::ParsedToken Lexer::parse_token() const { + if (const auto const_token = parse_const_token(); const_token.has_value()) { + return *const_token; + } + if (const auto number = parse_number(); number.has_value()) { + return *number; + } + throw LexerError{"invalid input at: " + std::string{m_input.get_input()}}; +} + +} diff --git a/server/lexer/lexer.hpp b/server/lexer/lexer.hpp new file mode 100644 index 0000000..d08a2df --- /dev/null +++ b/server/lexer/lexer.hpp @@ -0,0 +1,61 @@ +#pragma once + +#include "input.hpp" +#include "token.hpp" +#include "token_type.hpp" + +#include +#include +#include +#include + +namespace math::server { +namespace lexer::details { + +// Exposed for testing: +std::string_view parse_whitespace(const std::string_view&); +std::optional parse_number(const std::string_view&); +std::optional parse_const_token(const std::string_view&); + +} + +class Lexer { +public: + explicit Lexer(const std::string_view& input); + explicit Lexer(const lexer::Input& input); + + using Token = lexer::Token; + using ParsedToken = lexer::ParsedToken; + using Type = Token::Type; + using TokenProcessor = std::function; + + bool for_each_token(const TokenProcessor& process); + + std::vector get_tokens(); + + bool has_token() const { + return peek_token().has_value(); + } + + std::optional peek_token() const { + return m_token_buffer; + } + + void drop_token(); + std::optional drop_token_of_type(Type type); + +private: + std::optional parse_whitespace() const; + std::optional parse_const_token() const; + std::optional parse_number() const; + + ParsedToken parse_token() const; + + void consume_whitespace(); + void consume_token(); + + lexer::Input m_input; + std::optional m_token_buffer; +}; + +} diff --git a/server/lexer/token.cpp b/server/lexer/token.cpp new file mode 100644 index 0000000..6ffb721 --- /dev/null +++ b/server/lexer/token.cpp @@ -0,0 +1,71 @@ +#include "error.hpp" +#include "token.hpp" +#include "token_type.hpp" + +#include + +#include +#include + +namespace math::server::lexer { +namespace { + +static constexpr double nan() { return std::numeric_limits::quiet_NaN(); } + +static bool is_nan(double x) { return std::isnan(x); } + +static bool numbers_equal(double x, double y) { + if (is_nan(x) && is_nan(y)) { + return true; + } + return x == y; +} + +} + +Token::Token(Type type) + : m_type{type} { + + if (token::token_has_value(type)) { + throw LexerError{"internal: must have a value: " + token::type_to_int_string(type)}; + } +} + +Token::Token(double value) + : m_type{Type::NUMBER}, m_value{value} +{ } + +bool Token::operator==(const Token& other) const { + if (m_type != other.m_type) { + return false; + } + if (token::is_const_token(m_type)) { + return true; + } + if (m_type == Type::NUMBER) { + return numbers_equal(as_number(), other.as_number()); + } + throw LexerError{"internal: can't compare tokens of type: " + token::type_to_int_string(m_type)}; +} + +double Token::as_number() const { + const auto type = get_type(); + if (type != Type::NUMBER) { + throw LexerError{"internal: not a number: " + token::type_to_int_string(type)}; + } + return std::get(m_value); +} + +std::ostream& operator<<(std::ostream& os, const Token& token) { + switch (token.m_type) { + case token::Type::NUMBER: + os << token.as_number(); + break; + default: + os << token::type_to_string(token.m_type); + break; + } + return os; +} + +} diff --git a/server/lexer/token.hpp b/server/lexer/token.hpp new file mode 100644 index 0000000..6f98383 --- /dev/null +++ b/server/lexer/token.hpp @@ -0,0 +1,49 @@ +#pragma once + +#include "token_type.hpp" + +#include + +#include +#include +#include + +namespace math::server::lexer { + +class Token { +public: + using Type = token::Type; + + explicit Token(token::Type type); + explicit Token(double value); + + bool operator==(const Token& other) const; + bool operator!=(const Token& other) const { return !(*this == other); } + + Type get_type() const { return m_type; } + + double as_number() const; + +private: + token::Type m_type; + std::variant m_value; + + friend std::ostream& operator<<(std::ostream&, const Token&); +}; + +class ParsedToken : public Token { +public: + ParsedToken(Token&& token, std::size_t pos, const std::string_view& view) + : Token{std::move(token)}, m_pos{pos}, m_view{view} { + } + + std::size_t get_pos() const { return m_pos; } + + std::size_t get_length() const { return m_view.length(); } + +private: + std::size_t m_pos; + std::string_view m_view; +}; + +} diff --git a/server/lexer/token_type.cpp b/server/lexer/token_type.cpp new file mode 100644 index 0000000..9a69ba1 --- /dev/null +++ b/server/lexer/token_type.cpp @@ -0,0 +1,164 @@ +#include "error.hpp" +#include "token_type.hpp" + +#include +#include +#include +#include +#include +#include + +namespace math::server::lexer::token { +namespace { + +using ToStringMap = std::unordered_map; +using FromStringMap = std::map>; + +class ToStringConverter { +public: + ToStringConverter() : m_map{to_string_map()} { + validate(); + } + + const ToStringMap& map() const { return m_map; } + +private: + static const ToStringMap& to_string_map() { + static const ToStringMap map{ + {Type::WHITESPACE, "whitespace"}, + {Type::PLUS, "+"}, + {Type::MINUS, "-"}, + {Type::ASTERISK, "*"}, + {Type::SLASH, "/"}, + {Type::LEFT_PAREN, "("}, + {Type::RIGHT_PAREN, ")"}, + {Type::NUMBER, "number"}, + }; + return map; + } + + void validate() const { + check_for_duplicates(); + } + + void check_for_duplicates() const { + std::unordered_set strings; + for (const auto& [type, str] : m_map) { + const auto [_, inserted] = strings.emplace(str); + if (!inserted) { + throw std::logic_error{"multiple tokens have the same string representation: " + str}; + } + } + } + + const ToStringMap& m_map; +}; + +const ToStringMap& to_string_map() { + static const ToStringConverter converter; + return converter.map(); +} + +class FromStringConverter { +public: + FromStringConverter(const ToStringMap& to_string) + : m_map{build_map(to_string)} { + } + + const FromStringMap& map() const { return m_map; } + +private: + static FromStringMap build_map(const ToStringMap& to_string) { + FromStringMap from_string; + for (const auto& [type, str] : to_string) { + const auto [_, inserted] = from_string.emplace(str, type); + if (!inserted) { + throw std::logic_error{"multiple tokens have the same string representation: " + str}; + } + } + return from_string; + } + + FromStringMap m_map; +}; + +const FromStringMap& from_string_map() { + static const FromStringConverter converter{to_string_map()}; + return converter.map(); +} + +class ConstTokens { +public: + ConstTokens() { + const auto& map = to_string_map(); + for (const auto& [type, _] : map) { + if (is_const_token(type)) { + m_set.emplace(type); + } + } + } + + const TypeSet& set() const { return m_set; } + +private: + TypeSet m_set; +}; + +} + +TypeInt type_to_int(Type type) { + return static_cast(type); +} + +std::string type_to_int_string(Type type) { + return std::to_string(type_to_int(type)); +} + +bool is_const_token(Type type) { + switch (type) { + case Type::WHITESPACE: + case Type::NUMBER: + return false; + default: + return true; + } +} + +const TypeSet& const_tokens() { + static const ConstTokens tokens; + return tokens.set(); +} + +bool token_has_value(Type type) { + switch (type) { + case Type::NUMBER: + return true; + default: + return false; + } +} + +std::string type_to_string(Type type) { + const auto& map = to_string_map(); + const auto it = map.find(type); + if (it == map.cend()) { + throw LexerError{"type_to_string: unsupported token type: " + type_to_int_string(type)}; + } + return it->second; +} + +Type type_from_string(const std::string& src) { + const auto& map = from_string_map(); + const auto it = map.find(src); + if (it == map.cend()) { + throw LexerError{"type_from_string: unsupported token: " + std::string{src}}; + } + return it->second; +} + +std::ostream& operator<<(std::ostream& os, const Type& type) { + os << type_to_int(type); + return os; +} + +} diff --git a/server/lexer/token_type.hpp b/server/lexer/token_type.hpp new file mode 100644 index 0000000..9489915 --- /dev/null +++ b/server/lexer/token_type.hpp @@ -0,0 +1,37 @@ +#pragma once + +#include +#include +#include +#include + +namespace math::server::lexer::token { + +enum class Type { + WHITESPACE, + PLUS, + MINUS, + ASTERISK, + SLASH, + LEFT_PAREN, + RIGHT_PAREN, + NUMBER, +}; + +using TypeInt = std::underlying_type::type; +using TypeSet = std::unordered_set; + +TypeInt type_to_int(Type); +std::string type_to_int_string(Type); + +bool is_const_token(Type); +const TypeSet& const_tokens(); + +bool token_has_value(Type); + +std::string type_to_string(Type); +Type type_from_string(const std::string&); + +std::ostream& operator<<(std::ostream&, const Type&); + +} diff --git a/server/log.hpp b/server/log.hpp deleted file mode 100644 index ca0fafd..0000000 --- a/server/log.hpp +++ /dev/null @@ -1,49 +0,0 @@ -#pragma once - -#include -#include - -#include - -#include -#include -#include -#include -#include -#include -#include - -namespace math::server::log { - -namespace details { - -inline std::thread::id get_tid() { return std::this_thread::get_id(); } - -inline std::string get_timestamp() { - const auto tt = std::time(nullptr); - std::ostringstream oss; - oss << std::put_time(std::gmtime(&tt), "%Y-%m-%d %H:%M:%S"); - return oss.str(); -} - -inline void log(const std::string& msg) { - std::clog << get_timestamp() << " | " << get_tid() << " | " << msg << '\n'; -} - -} - -template -inline void log(const std::string_view& fmt, Args&&... args) { - details::log(boost::str((boost::format(fmt.data()) % ... % args))); -} - -template -inline void error(const std::string_view& fmt, Args&&... args) { - details::log(boost::str((boost::format(fmt.data()) % ... % args))); -} - -inline void error(const boost::system::error_code& ec) { - details::log(ec.message()); -} - -} diff --git a/server/main.cpp b/server/main.cpp deleted file mode 100644 index 2cf6d35..0000000 --- a/server/main.cpp +++ /dev/null @@ -1,34 +0,0 @@ -#include "server.hpp" -#include "settings.hpp" - -#include - -#include -#include - -int main(int argc, char* argv[]) { - try { - math::server::SettingsParser parser{argv[0]}; - - try { - const auto settings = parser.parse(argc, argv); - if (settings.exit_with_usage()) { - parser.usage(); - return 0; - } - - math::server::Server server{settings}; - server.run(); - } catch (const boost::program_options::error& e) { - parser.usage_error(e); - return 1; - } - } catch (const std::exception& e) { - std::cerr << "An error occured: " << e.what() << "\n"; - return 1; - } catch (...) { - std::cerr << "An unknown error occured\n"; - return 1; - } - return 0; -} diff --git a/server/main/CMakeLists.txt b/server/main/CMakeLists.txt new file mode 100644 index 0000000..b322390 --- /dev/null +++ b/server/main/CMakeLists.txt @@ -0,0 +1,13 @@ +find_package(Boost REQUIRED COMPONENTS filesystem program_options) + +option(DEBUG_ASIO "enable debug output for Boost.Asio" OFF) + +add_executable(server main.cpp server.cpp session.cpp session_manager.cpp) +target_link_libraries(server PRIVATE common parser) + +target_include_directories(server SYSTEM PRIVATE ${Boost_INCLUDE_DIRS}) +target_link_libraries(server PRIVATE ${Boost_LIBRARIES}) + +if(DEBUG_ASIO) + target_compile_definitions(server PRIVATE BOOST_ASIO_ENABLE_HANDLER_TRACKING) +endif() diff --git a/server/main/main.cpp b/server/main/main.cpp new file mode 100644 index 0000000..2cf6d35 --- /dev/null +++ b/server/main/main.cpp @@ -0,0 +1,34 @@ +#include "server.hpp" +#include "settings.hpp" + +#include + +#include +#include + +int main(int argc, char* argv[]) { + try { + math::server::SettingsParser parser{argv[0]}; + + try { + const auto settings = parser.parse(argc, argv); + if (settings.exit_with_usage()) { + parser.usage(); + return 0; + } + + math::server::Server server{settings}; + server.run(); + } catch (const boost::program_options::error& e) { + parser.usage_error(e); + return 1; + } + } catch (const std::exception& e) { + std::cerr << "An error occured: " << e.what() << "\n"; + return 1; + } catch (...) { + std::cerr << "An unknown error occured\n"; + return 1; + } + return 0; +} diff --git a/server/main/server.cpp b/server/main/server.cpp new file mode 100644 index 0000000..3800144 --- /dev/null +++ b/server/main/server.cpp @@ -0,0 +1,112 @@ +#include "server.hpp" +#include "session.hpp" +#include "session_manager.hpp" +#include "settings.hpp" + +#include "../common/error.hpp" +#include "../common/log.hpp" + +#include +#include +#include + +#include + +#include +#include +#include + +namespace math::server { +namespace { + +boost::asio::ip::tcp::endpoint make_endpoint(unsigned port) { + return {boost::asio::ip::tcp::v4(), port}; +} + +void configure_acceptor(boost::asio::ip::tcp::acceptor& acceptor, unsigned port) { + try { + const auto endpoint = make_endpoint(port); + acceptor.open(endpoint.protocol()); + acceptor.set_option(boost::asio::ip::tcp::acceptor::reuse_address(true)); + acceptor.bind(endpoint); + acceptor.listen(); + } catch (const boost::system::system_error& e) { + throw Error{e.what()}; + } +} + +} + +Server::Server(const Settings& settings) + : Server{settings.m_port, settings.m_threads} +{ } + +Server::Server(unsigned port, unsigned threads) + : m_numof_threads{threads} + , m_signals{m_io_context} + , m_acceptor{m_io_context} { + + wait_for_signal(); + configure_acceptor(m_acceptor, port); + + accept(); +} + +void Server::run() { + std::vector threads{m_numof_threads}; + for (std::size_t i = 0; i < m_numof_threads; ++i) { + threads[i] = std::thread{[this] () { m_io_context.run(); }}; + } + + for (std::size_t i = 0; i < m_numof_threads; ++i) { + threads[i].join(); + } +} + +void Server::wait_for_signal() { + try { + m_signals.add(SIGINT); + m_signals.add(SIGTERM); + + m_signals.async_wait([this] (const boost::system::error_code& ec, int signo) { + handle_signal(ec, signo); + }); + } catch (const boost::system::system_error& e) { + throw Error{e.what()}; + } +} + +void Server::handle_signal(const boost::system::error_code& ec, int signo) { + if (ec) { + log::error("%1%: %2%", __func__, ec.message()); + } + + log::log("Caught signal %1%", signo); + + try { + m_acceptor.close(); + m_session_mgr.stop_all(); + } catch (const std::exception& e) { + log::error(e.what()); + } +} + +void Server::accept() { + const auto session = m_session_mgr.make_session(m_io_context); + m_acceptor.async_accept(session->socket(), + [session, this] (const boost::system::error_code& ec) { + handle_accept(session, ec); + }); +} + +void Server::handle_accept(SessionPtr session, const boost::system::error_code& ec) { + if (ec) { + log::error("%1%: %2%", __func__, ec.message()); + return; + } + + m_session_mgr.start(session); + accept(); +} + +} diff --git a/server/main/server.hpp b/server/main/server.hpp new file mode 100644 index 0000000..5524f88 --- /dev/null +++ b/server/main/server.hpp @@ -0,0 +1,34 @@ +#pragma once + +#include "session_manager.hpp" +#include "settings.hpp" + +#include +#include + +namespace math::server { + +class Server { +public: + Server(const Settings& settings); + Server(unsigned port, unsigned threads); + + void run(); + +private: + void wait_for_signal(); + void handle_signal(const boost::system::error_code&, int); + + void accept(); + void handle_accept(SessionPtr session, const boost::system::error_code& ec); + + const unsigned m_numof_threads; + + boost::asio::io_context m_io_context; + boost::asio::signal_set m_signals; + boost::asio::ip::tcp::acceptor m_acceptor; + + SessionManager m_session_mgr; +}; + +} diff --git a/server/main/session.cpp b/server/main/session.cpp new file mode 100644 index 0000000..0ee7f75 --- /dev/null +++ b/server/main/session.cpp @@ -0,0 +1,114 @@ +#include "session.hpp" +#include "session_manager.hpp" + +#include "../common/error.hpp" +#include "../common/log.hpp" +#include "../parser/parser.hpp" + +#include +#include +#include +#include + +#include + +#include +#include +#include + +namespace math::server { +namespace { + +std::string reply_to_string(double result) { + return boost::lexical_cast(result); +} + +std::string calc_reply(const std::string& input) { + std::string reply; + try { + reply = reply_to_string(Parser{input}.exec()); + } catch (const std::exception& e) { + reply = e.what(); + } + return reply; +} + +} + +Session::Session(SessionManager& mgr, boost::asio::io_context& io_context) + : m_session_mgr{mgr}, m_strand{io_context}, m_socket{io_context} +{ } + +boost::asio::ip::tcp::socket& Session::socket() { + return m_socket; +} + +void Session::start() { + read(); +} + +void Session::stop() { + close(); +} + +void Session::close() { + try { + m_socket.shutdown(boost::asio::ip::tcp::socket::shutdown_both); + m_socket.close(); + } catch (const boost::system::system_error& e) { + throw Error{e.what()}; + } +} + +void Session::read() { + const auto self = shared_from_this(); + + // Stop at LF + boost::asio::async_read_until(m_socket, m_buffer, '\n', boost::asio::bind_executor(m_strand, + [this, self] (const boost::system::error_code& ec, std::size_t bytes) { + handle_read(ec, bytes); + })); +} + +void Session::handle_read(const boost::system::error_code& ec, std::size_t bytes) { + if (ec) { + log::error("%1%: %2%", __func__, ec.message()); + m_session_mgr.stop(shared_from_this()); + return; + } + + write(calc_reply(consume_input(bytes))); +} + +std::string Session::consume_input(std::size_t bytes) { + const auto data = boost::asio::buffer_cast(m_buffer.data()); + const std::string input{data, bytes - 1}; + m_buffer.consume(bytes); + return input; +} + +void Session::write(std::string output) { + const auto self = shared_from_this(); + + // Include CR (so that Windows' telnet client works) + output += "\r\n"; + + boost::asio::const_buffer buffer{output.c_str(), output.length()}; + + boost::asio::async_write(m_socket, std::move(buffer), boost::asio::bind_executor(m_strand, + [this, self] (const boost::system::error_code& ec, std::size_t bytes) { + handle_write(ec, bytes); + })); +} + +void Session::handle_write(const boost::system::error_code& ec, std::size_t bytes) { + if (ec) { + log::error("%1%: %2%", __func__, ec.message()); + m_session_mgr.stop(shared_from_this()); + return; + } + + read(); +} + +} diff --git a/server/main/session.hpp b/server/main/session.hpp new file mode 100644 index 0000000..ace3755 --- /dev/null +++ b/server/main/session.hpp @@ -0,0 +1,42 @@ +#pragma once + +#include +#include + +#include + +#include +#include + +namespace math::server { + +class SessionManager; + +class Session : public std::enable_shared_from_this { +public: + Session(SessionManager& mgr, boost::asio::io_context& io_context); + + boost::asio::ip::tcp::socket& socket(); + + void start(); + void stop(); + +private: + void close(); + + void read(); + void write(std::string); + + void handle_read(const boost::system::error_code&, std::size_t); + void handle_write(const boost::system::error_code&, std::size_t); + + std::string consume_input(std::size_t); + + SessionManager& m_session_mgr; + + boost::asio::io_context::strand m_strand; + boost::asio::ip::tcp::socket m_socket; + boost::asio::streambuf m_buffer; +}; + +} diff --git a/server/main/session_manager.cpp b/server/main/session_manager.cpp new file mode 100644 index 0000000..c2aef6d --- /dev/null +++ b/server/main/session_manager.cpp @@ -0,0 +1,38 @@ +#include "session.hpp" +#include "session_manager.hpp" + +#include "../common/log.hpp" + +#include +#include + +namespace math::server { + +SessionPtr SessionManager::make_session(boost::asio::io_context& io_context) { + return std::make_shared(*this, io_context); +} + +void SessionManager::start(const SessionPtr& session) { + std::lock_guard lck{m_mtx}; + m_sessions.emplace(session); + session->start(); +} + +void SessionManager::stop(const SessionPtr& session) { + std::lock_guard lck{m_mtx}; + const auto removed = m_sessions.erase(session) > 0; + if (removed) { + session->stop(); + } +} + +void SessionManager::stop_all() { + std::lock_guard lck{m_mtx}; + log::log("Closing the remaining %1% session(s)...", m_sessions.size()); + for (const auto& session : m_sessions) { + session->stop(); + } + m_sessions.clear(); +} + +} diff --git a/server/main/session_manager.hpp b/server/main/session_manager.hpp new file mode 100644 index 0000000..f0bec0b --- /dev/null +++ b/server/main/session_manager.hpp @@ -0,0 +1,30 @@ +#pragma once + +#include + +#include +#include +#include + +namespace math::server { + +class Session; +using SessionPtr = std::shared_ptr; + +class SessionManager { +public: + SessionManager() = default; + + SessionPtr make_session(boost::asio::io_context&); + + void start(const SessionPtr&); + void stop(const SessionPtr&); + + void stop_all(); + +private: + std::mutex m_mtx; + std::unordered_set m_sessions; +}; + +} diff --git a/server/main/settings.hpp b/server/main/settings.hpp new file mode 100644 index 0000000..310163f --- /dev/null +++ b/server/main/settings.hpp @@ -0,0 +1,87 @@ +#pragma once + +#include +#include + +#include +#include +#include +#include +#include + +namespace math::server { + +struct Settings { + static constexpr unsigned DEFAULT_PORT = 18000; + + static unsigned default_threads() { return std::thread::hardware_concurrency(); } + + unsigned m_port; + unsigned m_threads; + + bool exit_with_usage() const { return m_vm.count("help"); } + + boost::program_options::variables_map m_vm; +}; + +class SettingsParser { +public: + explicit SettingsParser(const std::string& argv0) + : m_prog_name{extract_filename(argv0)} + { + m_visible.add_options() + ("help,h", + "show this message and exit") + ("port,p", + boost::program_options::value(&m_settings.m_port)->default_value(Settings::DEFAULT_PORT), + "server port number") + ("threads,n", + boost::program_options::value(&m_settings.m_threads)->default_value(Settings::default_threads()), + "number of threads"); + } + + static const char* get_short_description() { + return "[-h|--help] [-p|--port] [-n|--threads]"; + } + + Settings parse(int argc, char* argv[]) { + boost::program_options::store( + boost::program_options::command_line_parser{argc, argv} + .options(m_visible) + .run(), + m_settings.m_vm); + if (m_settings.exit_with_usage()) { + return m_settings; + } + boost::program_options::notify(m_settings.m_vm); + return m_settings; + } + + void usage() const { + std::cout << *this; + } + + void usage_error(const std::exception& e) const { + std::cerr << "usage error: " << e.what() << '\n'; + std::cerr << *this; + } + +private: + static std::string extract_filename(const std::string& path) { + return boost::filesystem::path{path}.filename().string(); + } + + const std::string m_prog_name; + + boost::program_options::options_description m_visible; + + Settings m_settings; + + friend std::ostream& operator<<(std::ostream& os, const SettingsParser& parser) { + os << "usage: " << parser.m_prog_name << ' ' << get_short_description() << '\n'; + os << parser.m_visible; + return os; + } +}; + +} diff --git a/server/parser.hpp b/server/parser.hpp deleted file mode 100644 index a9e5f54..0000000 --- a/server/parser.hpp +++ /dev/null @@ -1,168 +0,0 @@ -#pragma once - -#include "error.hpp" -#include "lexer.hpp" - -#include -#include -#include - -namespace math::server { -namespace parser { - -class Error : public server::Error { -public: - explicit Error(const std::string& what) - : server::Error{"parser error: " + what} - { } -}; - -class BinaryOp { -public: - static bool is(const lexer::Token& token) { - using Type = lexer::Token::Type; - switch (token.get_type()) { - case Type::PLUS: - case Type::MINUS: - case Type::ASTERISK: - case Type::SLASH: - return true; - - default: - return false; - } - } - - static BinaryOp from_token(const lexer::Token& token) { - if (!is(token)) { - throw Error{"internal: token is not a binary operator"}; - } - return BinaryOp{token}; - } - - static constexpr unsigned min_precedence() { return 0; } - - unsigned get_precedence() const { - using Type = lexer::Token::Type; - switch (m_type) { - case Type::PLUS: - case Type::MINUS: - return min_precedence(); - - case Type::ASTERISK: - case Type::SLASH: - return min_precedence() + 1; - - default: - throw Error{"internal: undefined operator precedence"}; - } - } - - double exec(double lhs, double rhs) const { - using Type = lexer::Token::Type; - switch (m_type) { - case Type::PLUS: - return lhs + rhs; - case Type::MINUS: - return lhs - rhs; - case Type::ASTERISK: - return lhs * rhs; - case Type::SLASH: - // Trapping the CPU would be better? - if (rhs == 0.) { - throw Error{"division by zero"}; - } - return lhs / rhs; - default: - throw Error{"internal: unsupported operator"}; - } - } - -private: - explicit BinaryOp(const lexer::Token& token) - : m_type{token.get_type()} - { } - - lexer::Token::Type m_type; -}; - -} - -class Parser { -public: - // I did simple recursive descent parsing a long time ago (see - // https://github.com/egor-tensin/simple-interpreter), this appears to be - // a finer algorithm for parsing arithmetic expressions. - // Reference: https://en.wikipedia.org/wiki/Operator-precedence_parser - - explicit Parser(const std::string_view& input) - : m_lexer{input} - { } - - double exec() { - m_lexer.parse_token(); - const auto result = exec_expr(); - if (m_lexer.has_token()) { - throw parser::Error{"expected a binary operator"}; - } - return result; - } - -private: - double exec_expr() { - return exec_expr(exec_primary(), parser::BinaryOp::min_precedence()); - } - - double exec_expr(double lhs, unsigned min_prec) { - for (auto op = peek_operator(); op.has_value() && op->get_precedence() >= min_prec;) { - const auto lhs_op = *op; - m_lexer.drop_token(); - auto rhs = exec_primary(); - - for (op = peek_operator(); op.has_value() && op->get_precedence() > lhs_op.get_precedence(); op = peek_operator()) { - rhs = exec_expr(rhs, op->get_precedence()); - } - - lhs = lhs_op.exec(lhs, rhs); - } - return lhs; - } - - std::optional peek_operator() { - const auto token = m_lexer.peek_token(); - if (!token.has_value() || !parser::BinaryOp::is(*token)) { - return {}; - } - return parser::BinaryOp::from_token(*token); - } - - double exec_primary() { - if (!m_lexer.has_token()) { - throw parser::Error{"expected '-', '(' or a number"}; - } - - using Type = lexer::Token::Type; - - if (m_lexer.drop_token_if(Type::MINUS).has_value()) { - return -exec_primary(); - } - - if (m_lexer.drop_token_if(Type::LEFT_PAREN).has_value()) { - const auto inner = exec_expr(); - if (!m_lexer.has_token() || !m_lexer.drop_token_if(Type::RIGHT_PAREN).has_value()) { - throw parser::Error{"missing closing ')'"}; - } - return inner; - } - - if (const auto token = m_lexer.drop_token_if(Type::NUMBER); token.has_value()) { - return token.value().get_number_value(); - } - - throw parser::Error{"expected '-', '(' or a number"}; - } - - Lexer m_lexer; -}; - -} diff --git a/server/parser/CMakeLists.txt b/server/parser/CMakeLists.txt new file mode 100644 index 0000000..2490e57 --- /dev/null +++ b/server/parser/CMakeLists.txt @@ -0,0 +1,2 @@ +add_library(parser INTERFACE) +target_link_libraries(parser INTERFACE common lexer) diff --git a/server/parser/error.hpp b/server/parser/error.hpp new file mode 100644 index 0000000..1ba29ed --- /dev/null +++ b/server/parser/error.hpp @@ -0,0 +1,16 @@ +#pragma once + +#include "../common/error.hpp" + +#include + +namespace math::server { + +class ParserError : public Error { +public: + explicit ParserError(const std::string& what) + : Error{"parser error: " + what} + { } +}; + +} diff --git a/server/parser/operator.hpp b/server/parser/operator.hpp new file mode 100644 index 0000000..4226078 --- /dev/null +++ b/server/parser/operator.hpp @@ -0,0 +1,79 @@ +#pragma once + +#include "error.hpp" + +#include "../lexer/token.hpp" +#include "../lexer/token_type.hpp" + +namespace math::server::parser { + +class BinaryOp { +public: + using Token = lexer::Token; + using Type = Token::Type; + + static bool is(const Token& token) { + switch (token.get_type()) { + case Type::PLUS: + case Type::MINUS: + case Type::ASTERISK: + case Type::SLASH: + return true; + + default: + return false; + } + } + + static BinaryOp from_token(const Token& token) { + if (!is(token)) { + throw ParserError{"internal: token is not a binary operator"}; + } + return BinaryOp{token}; + } + + static constexpr unsigned min_precedence() { return 0; } + + unsigned get_precedence() const { + switch (m_type) { + case Type::PLUS: + case Type::MINUS: + return min_precedence(); + + case Type::ASTERISK: + case Type::SLASH: + return min_precedence() + 1; + + default: + throw ParserError{"internal: undefined operator precedence"}; + } + } + + double exec(double lhs, double rhs) const { + switch (m_type) { + case Type::PLUS: + return lhs + rhs; + case Type::MINUS: + return lhs - rhs; + case Type::ASTERISK: + return lhs * rhs; + case Type::SLASH: + // Trapping the CPU would be better? + if (rhs == 0.) { + throw ParserError{"division by zero"}; + } + return lhs / rhs; + default: + throw ParserError{"internal: unsupported operator"}; + } + } + +private: + explicit BinaryOp(const Token& token) + : m_type{token.get_type()} + { } + + Type m_type; +}; + +} diff --git a/server/parser/parser.hpp b/server/parser/parser.hpp new file mode 100644 index 0000000..1197c31 --- /dev/null +++ b/server/parser/parser.hpp @@ -0,0 +1,89 @@ +#pragma once + +#include "error.hpp" +#include "operator.hpp" + +#include "../lexer/lexer.hpp" + +#include +#include + +namespace math::server { + +class Parser { +public: + // I did simple recursive descent parsing a long time ago (see + // https://github.com/egor-tensin/simple-interpreter), this appears to be + // a finer algorithm for parsing arithmetic expressions. + // Reference: https://en.wikipedia.org/wiki/Operator-precedence_parser + + explicit Parser(const std::string_view& input) + : m_lexer{input} + { } + + double exec() { + const auto result = exec_expr(); + if (m_lexer.has_token()) { + throw ParserError{"expected a binary operator"}; + } + return result; + } + +private: + double exec_expr() { + return exec_expr(exec_primary(), parser::BinaryOp::min_precedence()); + } + + double exec_expr(double lhs, unsigned min_prec) { + for (auto op = peek_operator(); op.has_value() && op->get_precedence() >= min_prec;) { + const auto lhs_op = *op; + m_lexer.drop_token(); + auto rhs = exec_primary(); + + for (op = peek_operator(); op.has_value() && op->get_precedence() > lhs_op.get_precedence(); op = peek_operator()) { + rhs = exec_expr(rhs, op->get_precedence()); + } + + lhs = lhs_op.exec(lhs, rhs); + } + return lhs; + } + + std::optional peek_operator() { + const auto token = m_lexer.peek_token(); + if (!token.has_value() || !parser::BinaryOp::is(*token)) { + return {}; + } + return parser::BinaryOp::from_token(*token); + } + + double exec_primary() { + if (!m_lexer.has_token()) { + throw ParserError{"expected '-', '(' or a number"}; + } + + using Type = lexer::Token::Type; + + if (m_lexer.drop_token_of_type(Type::MINUS).has_value()) { + return -exec_primary(); + } + + if (m_lexer.drop_token_of_type(Type::LEFT_PAREN).has_value()) { + const auto inner = exec_expr(); + if (!m_lexer.has_token() || !m_lexer.drop_token_of_type(Type::RIGHT_PAREN).has_value()) { + throw ParserError{"missing closing ')'"}; + } + return inner; + } + + if (const auto token = m_lexer.drop_token_of_type(Type::NUMBER); token.has_value()) { + return token.value().as_number(); + } + + throw ParserError{"expected '-', '(' or a number"}; + } + + Lexer m_lexer; +}; + +} diff --git a/server/server.cpp b/server/server.cpp deleted file mode 100644 index 4dc672c..0000000 --- a/server/server.cpp +++ /dev/null @@ -1,111 +0,0 @@ -#include "error.hpp" -#include "log.hpp" -#include "server.hpp" -#include "session.hpp" -#include "session_manager.hpp" -#include "settings.hpp" - -#include -#include -#include - -#include - -#include -#include -#include - -namespace math::server { -namespace { - -boost::asio::ip::tcp::endpoint make_endpoint(unsigned port) { - return {boost::asio::ip::tcp::v4(), port}; -} - -void configure_acceptor(boost::asio::ip::tcp::acceptor& acceptor, unsigned port) { - try { - const auto endpoint = make_endpoint(port); - acceptor.open(endpoint.protocol()); - acceptor.set_option(boost::asio::ip::tcp::acceptor::reuse_address(true)); - acceptor.bind(endpoint); - acceptor.listen(); - } catch (const boost::system::system_error& e) { - throw Error{e.what()}; - } -} - -} - -Server::Server(const Settings& settings) - : Server{settings.m_port, settings.m_threads} -{ } - -Server::Server(unsigned port, unsigned threads) - : m_numof_threads{threads} - , m_signals{m_io_context} - , m_acceptor{m_io_context} { - - wait_for_signal(); - configure_acceptor(m_acceptor, port); - - accept(); -} - -void Server::run() { - std::vector threads{m_numof_threads}; - for (std::size_t i = 0; i < m_numof_threads; ++i) { - threads[i] = std::thread{[this] () { m_io_context.run(); }}; - } - - for (std::size_t i = 0; i < m_numof_threads; ++i) { - threads[i].join(); - } -} - -void Server::wait_for_signal() { - try { - m_signals.add(SIGINT); - m_signals.add(SIGTERM); - - m_signals.async_wait([this] (const boost::system::error_code& ec, int signo) { - handle_signal(ec, signo); - }); - } catch (const boost::system::system_error& e) { - throw Error{e.what()}; - } -} - -void Server::handle_signal(const boost::system::error_code& ec, int signo) { - if (ec) { - log::error("%1%: %2%", __func__, ec.message()); - } - - log::log("Caught signal %1%", signo); - - try { - m_acceptor.close(); - m_session_mgr.stop_all(); - } catch (const std::exception& e) { - log::error(e.what()); - } -} - -void Server::accept() { - const auto session = m_session_mgr.make_session(m_io_context); - m_acceptor.async_accept(session->socket(), - [session, this] (const boost::system::error_code& ec) { - handle_accept(session, ec); - }); -} - -void Server::handle_accept(SessionPtr session, const boost::system::error_code& ec) { - if (ec) { - log::error("%1%: %2%", __func__, ec.message()); - return; - } - - m_session_mgr.start(session); - accept(); -} - -} diff --git a/server/server.hpp b/server/server.hpp deleted file mode 100644 index 5524f88..0000000 --- a/server/server.hpp +++ /dev/null @@ -1,34 +0,0 @@ -#pragma once - -#include "session_manager.hpp" -#include "settings.hpp" - -#include -#include - -namespace math::server { - -class Server { -public: - Server(const Settings& settings); - Server(unsigned port, unsigned threads); - - void run(); - -private: - void wait_for_signal(); - void handle_signal(const boost::system::error_code&, int); - - void accept(); - void handle_accept(SessionPtr session, const boost::system::error_code& ec); - - const unsigned m_numof_threads; - - boost::asio::io_context m_io_context; - boost::asio::signal_set m_signals; - boost::asio::ip::tcp::acceptor m_acceptor; - - SessionManager m_session_mgr; -}; - -} diff --git a/server/session.cpp b/server/session.cpp deleted file mode 100644 index 409ca5a..0000000 --- a/server/session.cpp +++ /dev/null @@ -1,113 +0,0 @@ -#include "error.hpp" -#include "log.hpp" -#include "parser.hpp" -#include "session.hpp" -#include "session_manager.hpp" - -#include -#include -#include -#include - -#include - -#include -#include -#include - -namespace math::server { -namespace { - -std::string reply_to_string(double result) { - return boost::lexical_cast(result); -} - -std::string calc_reply(const std::string& input) { - std::string reply; - try { - reply = reply_to_string(Parser{input}.exec()); - } catch (const std::exception& e) { - reply = e.what(); - } - return reply; -} - -} - -Session::Session(SessionManager& mgr, boost::asio::io_context& io_context) - : m_session_mgr{mgr}, m_strand{io_context}, m_socket{io_context} -{ } - -boost::asio::ip::tcp::socket& Session::socket() { - return m_socket; -} - -void Session::start() { - read(); -} - -void Session::stop() { - close(); -} - -void Session::close() { - try { - m_socket.shutdown(boost::asio::ip::tcp::socket::shutdown_both); - m_socket.close(); - } catch (const boost::system::system_error& e) { - throw Error{e.what()}; - } -} - -void Session::read() { - const auto self = shared_from_this(); - - // Stop at LF - boost::asio::async_read_until(m_socket, m_buffer, '\n', boost::asio::bind_executor(m_strand, - [this, self] (const boost::system::error_code& ec, std::size_t bytes) { - handle_read(ec, bytes); - })); -} - -void Session::handle_read(const boost::system::error_code& ec, std::size_t bytes) { - if (ec) { - log::error("%1%: %2%", __func__, ec.message()); - m_session_mgr.stop(shared_from_this()); - return; - } - - write(calc_reply(consume_input(bytes))); -} - -std::string Session::consume_input(std::size_t bytes) { - const auto data = boost::asio::buffer_cast(m_buffer.data()); - const std::string input{data, bytes - 1}; - m_buffer.consume(bytes); - return input; -} - -void Session::write(std::string output) { - const auto self = shared_from_this(); - - // Include CR (so that Windows' telnet client works) - output += "\r\n"; - - boost::asio::const_buffer buffer{output.c_str(), output.length()}; - - boost::asio::async_write(m_socket, std::move(buffer), boost::asio::bind_executor(m_strand, - [this, self] (const boost::system::error_code& ec, std::size_t bytes) { - handle_write(ec, bytes); - })); -} - -void Session::handle_write(const boost::system::error_code& ec, std::size_t bytes) { - if (ec) { - log::error("%1%: %2%", __func__, ec.message()); - m_session_mgr.stop(shared_from_this()); - return; - } - - read(); -} - -} diff --git a/server/session.hpp b/server/session.hpp deleted file mode 100644 index ace3755..0000000 --- a/server/session.hpp +++ /dev/null @@ -1,42 +0,0 @@ -#pragma once - -#include -#include - -#include - -#include -#include - -namespace math::server { - -class SessionManager; - -class Session : public std::enable_shared_from_this { -public: - Session(SessionManager& mgr, boost::asio::io_context& io_context); - - boost::asio::ip::tcp::socket& socket(); - - void start(); - void stop(); - -private: - void close(); - - void read(); - void write(std::string); - - void handle_read(const boost::system::error_code&, std::size_t); - void handle_write(const boost::system::error_code&, std::size_t); - - std::string consume_input(std::size_t); - - SessionManager& m_session_mgr; - - boost::asio::io_context::strand m_strand; - boost::asio::ip::tcp::socket m_socket; - boost::asio::streambuf m_buffer; -}; - -} diff --git a/server/session_manager.cpp b/server/session_manager.cpp deleted file mode 100644 index a42fca4..0000000 --- a/server/session_manager.cpp +++ /dev/null @@ -1,37 +0,0 @@ -#include "log.hpp" -#include "session.hpp" -#include "session_manager.hpp" - -#include -#include - -namespace math::server { - -SessionPtr SessionManager::make_session(boost::asio::io_context& io_context) { - return std::make_shared(*this, io_context); -} - -void SessionManager::start(const SessionPtr& session) { - std::lock_guard lck{m_mtx}; - m_sessions.emplace(session); - session->start(); -} - -void SessionManager::stop(const SessionPtr& session) { - std::lock_guard lck{m_mtx}; - const auto removed = m_sessions.erase(session) > 0; - if (removed) { - session->stop(); - } -} - -void SessionManager::stop_all() { - std::lock_guard lck{m_mtx}; - log::log("Closing the remaining %1% session(s)...", m_sessions.size()); - for (const auto& session : m_sessions) { - session->stop(); - } - m_sessions.clear(); -} - -} diff --git a/server/session_manager.hpp b/server/session_manager.hpp deleted file mode 100644 index f0bec0b..0000000 --- a/server/session_manager.hpp +++ /dev/null @@ -1,30 +0,0 @@ -#pragma once - -#include - -#include -#include -#include - -namespace math::server { - -class Session; -using SessionPtr = std::shared_ptr; - -class SessionManager { -public: - SessionManager() = default; - - SessionPtr make_session(boost::asio::io_context&); - - void start(const SessionPtr&); - void stop(const SessionPtr&); - - void stop_all(); - -private: - std::mutex m_mtx; - std::unordered_set m_sessions; -}; - -} diff --git a/server/settings.hpp b/server/settings.hpp deleted file mode 100644 index 310163f..0000000 --- a/server/settings.hpp +++ /dev/null @@ -1,87 +0,0 @@ -#pragma once - -#include -#include - -#include -#include -#include -#include -#include - -namespace math::server { - -struct Settings { - static constexpr unsigned DEFAULT_PORT = 18000; - - static unsigned default_threads() { return std::thread::hardware_concurrency(); } - - unsigned m_port; - unsigned m_threads; - - bool exit_with_usage() const { return m_vm.count("help"); } - - boost::program_options::variables_map m_vm; -}; - -class SettingsParser { -public: - explicit SettingsParser(const std::string& argv0) - : m_prog_name{extract_filename(argv0)} - { - m_visible.add_options() - ("help,h", - "show this message and exit") - ("port,p", - boost::program_options::value(&m_settings.m_port)->default_value(Settings::DEFAULT_PORT), - "server port number") - ("threads,n", - boost::program_options::value(&m_settings.m_threads)->default_value(Settings::default_threads()), - "number of threads"); - } - - static const char* get_short_description() { - return "[-h|--help] [-p|--port] [-n|--threads]"; - } - - Settings parse(int argc, char* argv[]) { - boost::program_options::store( - boost::program_options::command_line_parser{argc, argv} - .options(m_visible) - .run(), - m_settings.m_vm); - if (m_settings.exit_with_usage()) { - return m_settings; - } - boost::program_options::notify(m_settings.m_vm); - return m_settings; - } - - void usage() const { - std::cout << *this; - } - - void usage_error(const std::exception& e) const { - std::cerr << "usage error: " << e.what() << '\n'; - std::cerr << *this; - } - -private: - static std::string extract_filename(const std::string& path) { - return boost::filesystem::path{path}.filename().string(); - } - - const std::string m_prog_name; - - boost::program_options::options_description m_visible; - - Settings m_settings; - - friend std::ostream& operator<<(std::ostream& os, const SettingsParser& parser) { - os << "usage: " << parser.m_prog_name << ' ' << get_short_description() << '\n'; - os << parser.m_visible; - return os; - } -}; - -} -- cgit v1.2.3