--- /dev/null
+#include "postfix.h"
+#include "token.h"
+
+#include <string>
+#include <vector>
+#include <stack>
+#include <map>
+#include <istream>
+
+#include <sstream>
+#include <algorithm>
+#include <iterator>
+
+// PUBLIC
+
+Postfix::Postfix(std::string const& infix_string) : expr{}
+{
+ std::istringstream is{infix_string};
+ expr = make_postfix(is);
+}
+
+std::string Postfix::to_string() const
+{
+ std::ostringstream os;
+ std::copy( std::begin(expr), std::end(expr),
+ std::ostream_iterator<std::string>{os, " "});
+ return os.str();
+}
+
+Postfix::operator std::string() const
+{
+ return to_string();
+}
+
+bool Postfix::operator==(std::string const& rhs) const
+{
+ return to_string() == rhs;
+}
+
+
+// PRIVATE
+
+// right associative operators have input priority > stack priority
+// left associative operators have input priority < stack priority
+const Postfix::priority_table Postfix::operator_table {
+ // {symbol, input prio, stack prio}
+ {"^", {8, 7}},
+ {"*", {5, 6}},
+ {"/", {5, 6}},
+ {"%", {5, 6}},
+ {"+", {3, 4}},
+ {"-", {3, 4}},
+ {"=", {2, 1}}
+};
+
+bool Postfix::is_operator(const std::string& token)
+{
+ // C++20: return operator_table.contains( token );
+ return ( operator_table.count( token ) > 0 );
+}
+
+Postfix::expression Postfix::make_postfix(std::istream& is, bool match_parenthesis) const
+{
+ using namespace std::literals; // for string literals ""s
+
+ op_stack operator_stack;
+ expression postfix;
+ Token token;
+ int unused_operands{0};
+
+ while (is >> token && token != ")"s )
+ {
+ if ( is_operator(token) )
+ {
+ while ( ! operator_stack.empty() &&
+ operator_table.at(token).input <=
+ operator_table.at(operator_stack.top()).stack )
+ {
+ postfix.push_back( operator_stack.top() );
+ unused_operands -= 1; // uses 2 but creates 1
+ operator_stack.pop();
+ }
+ operator_stack.push(token);
+ }
+ else if (token == "("s)
+ {
+ expression parentesis{ make_postfix(is, true) };
+ std::copy( std::begin(parentesis), std::end(parentesis), std::back_inserter(postfix) );
+ unused_operands += 1; // entire postix is 1 operand
+ }
+ else
+ {
+ postfix.push_back( token );
+ unused_operands += 1;
+ }
+ }
+
+ if ( postfix.empty() && match_parenthesis && token == ")"s )
+ {
+ throw Infix_Error{"Empty parenthesis"};
+ }
+
+ if ( match_parenthesis && token != ")"s )
+ {
+ throw Infix_Error{"Missing ending parenthesis"};
+ }
+
+ if ( ! match_parenthesis && token == ")"s )
+ {
+ throw Infix_Error{"Missing starting parenthesis"};
+ }
+
+ while ( ! operator_stack.empty() )
+ {
+ postfix.push_back( operator_stack.top() );
+ unused_operands -= 1; // uses 2 but creates 1
+ operator_stack.pop();
+ }
+
+ if ( unused_operands != 1 ) // the last one is the answer
+ {
+ if ( unused_operands > 1 )
+ throw Infix_Error{"Missing operator"};
+ else
+ throw Infix_Error{"Missing operand"};
+ }
+
+ return postfix;
+}
--- /dev/null
+#ifndef POSTFIX_H
+#define POSTFIX_H
+
+#include <string>
+#include <vector>
+#include <stack>
+#include <map>
+#include <istream>
+#include <stdexcept>
+
+class Infix_Error : public std::logic_error
+{
+ using std::logic_error::logic_error;
+};
+
+// Creates a Postfix from a given infix string. All operands and
+// operators are required to be separated by at least one space.
+class Postfix
+{
+public:
+ Postfix(std::string const& infix_string);
+
+ std::string to_string() const;
+ operator std::string() const;
+ bool operator==(std::string const& rhs) const;
+
+private:
+ using op_stack = std::stack<std::string>;
+ using expression = std::vector<std::string>;
+
+ expression expr;
+
+ struct priority
+ {
+ int input;
+ int stack;
+ };
+
+ using priority_table = std::map<std::string, Postfix::priority>;
+
+ static const priority_table operator_table;
+
+ static bool is_operator(const std::string& token);
+
+ expression make_postfix(std::istream& is, bool match_parenthesis = false) const;
+};
+
+#endif
--- /dev/null
+#include <iostream>
+#include <iomanip>
+#include <string>
+#include <set>
+#include <algorithm>
+#include <cctype>
+
+#include "token.h"
+
+using namespace std;
+
+// Public
+
+set<string> const Token::default_operators{
+ "+", "-", "*", "/", "%", "^", "=", "(", ")", "?", "£", "$"
+ };
+
+string const Token::default_separators{" \t\n\r"};
+
+Token::Token(set<string> const& ops, string const& sep)
+ : operators{ops}, separators{sep}, token{}
+{
+}
+
+istream& operator>>(istream& iss, Token& t)
+{
+ return t.next(iss);
+}
+
+ostream& operator<<(ostream& oss, Token const& t)
+{
+ return oss << t.token;
+}
+
+bool Token::is_operator() const
+{
+ return operators.count( token ) == 1;
+}
+
+bool Token::is_integer() const
+{
+ return all_of(token.begin(), token.end(), ::isdigit);
+}
+
+bool Token::is_decimal() const
+{
+ bool valid_chars = all_of(token.begin(), token.end(), [](char c)->bool
+ {
+ return c == '.' || isdigit(c);
+ });
+ bool one_dot = count(token.begin(), token.end(), '.') == 1;
+ return valid_chars && one_dot;
+}
+
+bool Token::is_identifier() const
+{
+ return all_of(token.begin(), token.end(), [](char c)->bool
+ {
+ return c == '_' || isalnum(c);
+ });
+}
+
+// Private
+
+bool Token::is_separator(int c) const
+{
+ return ( separators.find(c) != string::npos );
+}
+
+bool Token::is_delimeter(int c) const
+{
+ if ( c == -1 ) // Traits::eof()
+ return true;
+
+ if ( is_separator( c ) )
+ return true;
+
+ auto b{ operators.begin() };
+ auto e{ operators.end() };
+
+ for ( ; b != e; ++b )
+ {
+ if ( b->at(0) == c )
+ return true;
+ }
+ return false;
+}
+
+bool Token::is_candidate() const
+{
+ auto b{ operators.begin() };
+ auto e{ operators.end() };
+
+ for ( ; b != e; ++b )
+ {
+ if ( b->find( token ) == 0 && *b != token )
+ return true;
+ }
+ return false;
+}
+
+void Token::append(int c)
+{
+ token.push_back( static_cast<char>(c) );
+}
+
+void Token::ignore_separators(istream& iss)
+{
+ auto c{ iss.peek() };
+
+ while ( c != -1 ) // Traits::eof()
+ {
+ if ( ! is_separator( c ) )
+ return;
+
+ iss.get();
+ c = iss.peek();
+ }
+}
+
+istream& Token::next(istream& iss)
+{
+ token.clear();
+
+ ignore_separators( iss );
+
+ auto c{ iss.peek() };
+
+ bool prev_is_op{false};
+
+ while ( c != -1 ) // Traits::eof()
+ {
+ append( c );
+
+ bool is_op{ is_operator() };
+ bool is_can{ is_candidate() };
+ bool is_del{ is_delimeter(c) };
+
+ if ( is_op && ! is_can )
+ {
+ iss.get();
+ return iss;
+ }
+
+ if ( prev_is_op && ! is_op && ! is_can )
+ {
+ token.pop_back();
+ return iss;
+ }
+
+ if ( is_del && ! is_can )
+ {
+ token.pop_back();
+ return iss;
+ }
+
+ prev_is_op = is_op;
+ iss.get();
+ c = iss.peek();
+ }
+
+ return iss;
+}
--- /dev/null
+#ifndef TOKEN_H
+#define TOKEN_H
+
+#include <iostream>
+#include <string>
+#include <set>
+
+// A class to read strings from an istream just like std::string,
+// but tokens are separated not only by space, but also by operators.
+//
+// You should be able to just change from "std::string" to "Token" in
+// your program unless you do something special with your strings.
+//
+// Tokens can be classified as integers, deciamls, identifiers or operators.
+//
+class Token
+{
+public:
+
+ // interoperability with standard library (STL)
+ using token_t = std::string;
+
+ using value_type = token_t::value_type;
+ using size_type = token_t::size_type;
+ using pointer = token_t::pointer;
+ using reference = token_t::reference;
+ using iterator = token_t::const_iterator;
+
+ iterator begin() const { return token.begin(); }
+ iterator end() const { return token.end(); }
+ size_type size() const { return token.size(); }
+ size_type length() const { return token.length(); }
+ value_type at(int i) const { return token.at(i); }
+
+ // static constants for default values
+ static std::set<std::string> const default_operators;
+ static std::string const default_separators;
+
+ // public members
+ Token(std::set<std::string> const& operators = default_operators,
+ std::string const& separators = default_separators);
+
+ friend std::istream& operator>>(std::istream& iss, Token& t);
+
+ friend std::ostream& operator<<(std::ostream& oss, Token const& t);
+
+ operator std::string() const { return token; }
+
+ bool operator==(std::string const& rhs) { return token == rhs; }
+ bool operator!=(std::string const& rhs) { return token != rhs; }
+
+ bool is_operator() const;
+ bool is_integer() const;
+ bool is_decimal() const;
+ bool is_identifier() const;
+
+private:
+
+ // help functions
+ bool is_delimeter(int c) const;
+ bool is_separator(int c) const;
+
+ bool is_candidate() const;
+
+ void append(int c);
+ void ignore_separators(std::istream& iss);
+
+ std::istream& next(std::istream& iss);
+
+ // data members
+ std::set<std::string> const& operators;
+ std::string const& separators;
+ std::string token;
+
+ friend class Token_Private_Tester;
+};
+
+#endif
--- /dev/null
+#define CATCH_CONFIG_RUNNER
+#include "catch.hpp"
+
+#include <iostream>
+#include <sstream>
+
+#include "token.h"
+
+using namespace std;
+
+const std::set<std::string> my_operators{
+ "+", "+-+", "-", "*", "/", "%", "^", "=", "==", "(", ")", "?", "£", "$", "####"
+ };
+
+class Token_Private_Tester
+{
+public:
+ Token_Private_Tester(Token& t) : t{t} {}
+
+ bool is_delimeter(int c) const { return t.is_delimeter(c); }
+ bool is_separator(int c) const { return t.is_separator(c); }
+
+ bool is_candidate() const { return t.is_candidate(); }
+
+ bool check_candidate(string const& s) { t.token = s; return t.is_candidate(); }
+
+ Token& set(string const& s) { t.token = s; return t; }
+
+private:
+ Token& t;
+};
+
+TEST_CASE("help functions")
+{
+ Token tok{my_operators};
+ Token_Private_Tester t{tok};
+
+ CHECK( t.is_delimeter('+') );
+ CHECK( t.is_delimeter('#') );
+ CHECK( t.is_delimeter(' ') );
+ CHECK_FALSE( t.is_delimeter('.') );
+
+ CHECK( t.is_separator(' ') );
+ CHECK_FALSE( t.is_separator('0') );
+
+ CHECK( t.check_candidate("+") );
+ CHECK( t.check_candidate("+-") );
+ CHECK_FALSE( t.check_candidate("+-+") );
+ CHECK_FALSE( t.check_candidate("+-++") );
+
+}
+
+TEST_CASE("classifier functions")
+{
+ Token tok{my_operators};
+ Token_Private_Tester t{tok};
+
+ CHECK( t.set("+").is_operator() );
+ CHECK_FALSE( t.set("+-").is_operator() );
+ CHECK( t.set("+-+").is_operator() );
+ CHECK_FALSE( t.set("+-++").is_operator() );
+
+ CHECK( t.set("123").is_integer() );
+ CHECK( t.set("3.14").is_decimal() );
+ CHECK( t.set("x_34").is_identifier() );
+
+ CHECK_FALSE( t.set("123a").is_integer() );
+ CHECK_FALSE( t.set("3.14.").is_decimal() );
+ CHECK_FALSE( t.set("=x_34").is_identifier() );
+}
+
+TEST_CASE("normal input output")
+{
+ Token t{my_operators};
+ istringstream iss{"1+2*34-sfd"};
+ ostringstream oss{};
+
+ while ( iss >> t )
+ {
+ oss << t << " ";
+ }
+ CHECK( oss.str() == "1 + 2 * 34 - sfd ");
+}
+
+TEST_CASE("normal input output, default operators")
+{
+ Token t;
+ istringstream iss{"1+2*34-sfd"};
+ ostringstream oss{};
+
+ while ( iss >> t )
+ {
+ oss << t << " ";
+ }
+ CHECK( oss.str() == "1 + 2 * 34 - sfd ");
+}
+
+TEST_CASE("multichar operator input output")
+{
+ Token t{my_operators};
+ istringstream iss{"1+-++2===as#####fgh"};
+ ostringstream oss{};
+
+ while ( iss >> t )
+ {
+ oss << t << " ";
+ }
+ CHECK( oss.str() == "1 +-+ + 2 == = as #### #fgh ");
+}
+
+int main(int argc, char* argv[] __attribute__((unused)))
+{
+ Catch::Session session;
+
+ session.run();
+
+
+ Token t{my_operators};
+ string s;
+
+ if ( argc <= 1 )
+ return 0;
+
+ cout << "Manual test mode, press Ctrl-D to exit. "
+ << "Please enter lines to split: " << endl;
+ while ( getline(cin, s) )
+ {
+ istringstream iss{s};
+
+ while ( iss >> t )
+ {
+ if ( t.is_operator() )
+ cout << "op: '" << t << "', ";
+ else if ( t.is_integer() )
+ cout << "int: '" << t << "', ";
+ else if ( t.is_decimal() )
+ cout << "double: '" << t << "', ";
+ else if ( t.is_identifier() )
+ cout << "var: '" << t << "', ";
+ else
+ cout << "token: '" << t << "', ";
+ }
+ cout << endl;
+ }
+ return 0;
+}
--- /dev/null
+#include <iostream>
+
+using namespace std;
+
+int main()
+{
+ string line;
+ while ( getline(cin, line) )
+ {
+ Expression e{line};
+ cout << e.to_string() << endl
+ << e.evaluate() << endl;
+ }
+ return 0;
+}
projects / TDDC76.git / commitdiff