From d07643690cc7730bae09618ff85074a181c17aad Mon Sep 17 00:00:00 2001 From: Robert Date: Sun, 17 Oct 2021 20:01:16 +0200 Subject: [PATCH] Add .gitignore and .gitattributes. --- .gitattributes | 63 +++++++++++++ .gitignore | 3 + CMakeLists.txt | 9 ++ README.md | 3 + ZOLparser/CMakeLists.txt | 9 ++ ZOLparser/Error.hpp | 20 +++++ ZOLparser/Expression.cpp | 6 ++ ZOLparser/Expression.hpp | 125 ++++++++++++++++++++++++++ ZOLparser/Parser.cpp | 188 +++++++++++++++++++++++++++++++++++++++ ZOLparser/Parser.hpp | 30 +++++++ ZOLparser/Token.hpp | 19 ++++ ZOLparser/grammar.txt | 5 ++ ZOLparser/main.cpp | 80 +++++++++++++++++ 13 files changed, 560 insertions(+) create mode 100644 .gitattributes create mode 100644 .gitignore create mode 100644 CMakeLists.txt create mode 100644 README.md create mode 100644 ZOLparser/CMakeLists.txt create mode 100644 ZOLparser/Error.hpp create mode 100644 ZOLparser/Expression.cpp create mode 100644 ZOLparser/Expression.hpp create mode 100644 ZOLparser/Parser.cpp create mode 100644 ZOLparser/Parser.hpp create mode 100644 ZOLparser/Token.hpp create mode 100644 ZOLparser/grammar.txt create mode 100644 ZOLparser/main.cpp diff --git a/.gitattributes b/.gitattributes new file mode 100644 index 0000000..1ff0c42 --- /dev/null +++ b/.gitattributes @@ -0,0 +1,63 @@ +############################################################################### +# Set default behavior to automatically normalize line endings. +############################################################################### +* text=auto + +############################################################################### +# Set default behavior for command prompt diff. +# +# This is need for earlier builds of msysgit that does not have it on by +# default for csharp files. +# Note: This is only used by command line +############################################################################### +#*.cs diff=csharp + +############################################################################### +# Set the merge driver for project and solution files +# +# Merging from the command prompt will add diff markers to the files if there +# are conflicts (Merging from VS is not affected by the settings below, in VS +# the diff markers are never inserted). Diff markers may cause the following +# file extensions to fail to load in VS. An alternative would be to treat +# these files as binary and thus will always conflict and require user +# intervention with every merge. To do so, just uncomment the entries below +############################################################################### +#*.sln merge=binary +#*.csproj merge=binary +#*.vbproj merge=binary +#*.vcxproj merge=binary +#*.vcproj merge=binary +#*.dbproj merge=binary +#*.fsproj merge=binary +#*.lsproj merge=binary +#*.wixproj merge=binary +#*.modelproj merge=binary +#*.sqlproj merge=binary +#*.wwaproj merge=binary + +############################################################################### +# behavior for image files +# +# image files are treated as binary by default. +############################################################################### +#*.jpg binary +#*.png binary +#*.gif binary + +############################################################################### +# diff behavior for common document formats +# +# Convert binary document formats to text before diffing them. This feature +# is only available from the command line. Turn it on by uncommenting the +# entries below. +############################################################################### +#*.doc diff=astextplain +#*.DOC diff=astextplain +#*.docx diff=astextplain +#*.DOCX diff=astextplain +#*.dot diff=astextplain +#*.DOT diff=astextplain +#*.pdf diff=astextplain +#*.PDF diff=astextplain +#*.rtf diff=astextplain +#*.RTF diff=astextplain diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..adc00e9 --- /dev/null +++ b/.gitignore @@ -0,0 +1,3 @@ +out/ +.vs/ +*.json \ No newline at end of file diff --git a/CMakeLists.txt b/CMakeLists.txt new file mode 100644 index 0000000..7aaa5ee --- /dev/null +++ b/CMakeLists.txt @@ -0,0 +1,9 @@ +# CMakeList.txt : Top-level CMake project file, do global configuration +# and include sub-projects here. +# +cmake_minimum_required (VERSION 3.8) + +project ("ZOLparser") + +# Include sub-projects. +add_subdirectory ("ZOLparser") diff --git a/README.md b/README.md new file mode 100644 index 0000000..50dd643 --- /dev/null +++ b/README.md @@ -0,0 +1,3 @@ +# ZOL Parser + +ZOL stands for zeroth order logic, so this program can parse zeroth order logic. \ No newline at end of file diff --git a/ZOLparser/CMakeLists.txt b/ZOLparser/CMakeLists.txt new file mode 100644 index 0000000..7d45343 --- /dev/null +++ b/ZOLparser/CMakeLists.txt @@ -0,0 +1,9 @@ +# CMakeList.txt : CMake project for ZOLparser, include source and define +# project specific logic here. +# +cmake_minimum_required (VERSION 3.8) + +# Add source to this project's executable. +add_executable (ZOLparser "main.cpp" "Token.hpp" "Parser.hpp" "Parser.cpp" "Error.hpp" "Expression.hpp" "Expression.cpp") + +# TODO: Add tests and install targets if needed. diff --git a/ZOLparser/Error.hpp b/ZOLparser/Error.hpp new file mode 100644 index 0000000..f5c37c2 --- /dev/null +++ b/ZOLparser/Error.hpp @@ -0,0 +1,20 @@ +#pragma once + +#include +#include + +class SyntaxError : public std::runtime_error +{ +public: + SyntaxError(unsigned int position) : + std::runtime_error(std::string("Syntax error at position ") + std::to_string(position)), pos(position) + {} + + unsigned int where() + { + return pos; + } + +private: + unsigned int pos; +}; \ No newline at end of file diff --git a/ZOLparser/Expression.cpp b/ZOLparser/Expression.cpp new file mode 100644 index 0000000..36fc3c8 --- /dev/null +++ b/ZOLparser/Expression.cpp @@ -0,0 +1,6 @@ +#include "Expression.hpp" + +IdentifierExpression IdentifierExpression::p; +IdentifierExpression IdentifierExpression::q; +IdentifierExpression IdentifierExpression::r; +IdentifierExpression IdentifierExpression::s; diff --git a/ZOLparser/Expression.hpp b/ZOLparser/Expression.hpp new file mode 100644 index 0000000..acafd1f --- /dev/null +++ b/ZOLparser/Expression.hpp @@ -0,0 +1,125 @@ +#pragma once + +class Expression +{ +public: + virtual bool Eval() const = 0; + virtual unsigned int Size() const = 0; + virtual unsigned int VarCount() const = 0; +}; + +class IdentifierExpression : public Expression +{ +public: + static IdentifierExpression p; + static IdentifierExpression q; + static IdentifierExpression r; + static IdentifierExpression s; + +public: + void SetTruthValue(bool value) + { + truthValue = value; + } + + bool Eval() const override + { + return truthValue; + } + + unsigned int Size() const override { return 1; } + unsigned int VarCount() const override {return 1; } + +private: + IdentifierExpression() : + truthValue(false) + { } + +private: + bool truthValue; +}; + + +class NegationExpression : public Expression +{ +public: + NegationExpression(const Expression* operand) : + operand(operand) + { + + } + + bool Eval() const override + { + return !(operand->Eval()); + } + + unsigned int Size() const override { return 1 + operand->Size(); } + unsigned int VarCount() const override { return operand->VarCount(); } + +private: + const Expression* operand; +}; + + +class BinaryExpression : public Expression +{ +public: + BinaryExpression(const Expression* left, const Expression* right) : + left(left), right(right) + { + + } + + unsigned int Size() const override { return 1 + left->Size() + right->Size(); } + unsigned int VarCount() const override { return left->VarCount() + right->VarCount(); } + +protected: + const Expression* left; + const Expression* right; +}; + + +class ConjunctionExpression : public BinaryExpression +{ +public: + using BinaryExpression::BinaryExpression; + + bool Eval() const override + { + return left->Eval() && right->Eval(); + } +}; + +class DisjunctionExpression : public BinaryExpression +{ +public: + using BinaryExpression::BinaryExpression; + + bool Eval() const override + { + return left->Eval() || right->Eval(); + } +}; + +class ImplicationExpression : public BinaryExpression +{ +public: + using BinaryExpression::BinaryExpression; + + bool Eval() const override + { + return !(left->Eval()) || right->Eval(); + } +}; + +class EquivalenceExpression : public BinaryExpression +{ +public: + using BinaryExpression::BinaryExpression; + + bool Eval() const override + { + return left->Eval() == right->Eval(); + } +}; \ No newline at end of file diff --git a/ZOLparser/Parser.cpp b/ZOLparser/Parser.cpp new file mode 100644 index 0000000..55ce849 --- /dev/null +++ b/ZOLparser/Parser.cpp @@ -0,0 +1,188 @@ +#include "Parser.hpp" +#include +#include + +Parser::Parser(const std::string& text) +{ + unsigned int pos = 0; + for (std::string::const_iterator it = text.begin(); it != text.end(); it++) + { + TokenType type; + std::string lexeme(1, *it); + + switch (*it) + { + case 'p': + case 'q': + case 'r': + case 's': + type = TokenType::Atom; + break; + + case '~': + type = TokenType::Unary; + break; + + case '^': + case 'v': + type = TokenType::Binary; + break; + + case '-': + if (*(++it) == '>') + { + lexeme += *it; + type = TokenType::Binary; + break; + } + throw SyntaxError(std::distance(text.begin(), it)); + + case '<': + if (*(++it) == '-' && *(++it) == '>') + { + lexeme += "->"; + type = TokenType::Binary; + break; + } + throw SyntaxError(std::distance(text.begin(), it)); + + case '(': + case ')': + type = TokenType::Parenthesis; + break; + + default: + throw SyntaxError(std::distance(text.begin(), it)); + } + + tokens.emplace_back(Token{ type, lexeme, pos}); + pos++; + } + tokens.emplace_back(Token{ TokenType::EOL, "", pos }); + + nextToken = tokens.begin(); + + expressionTree = ParseExpression(); + if (nextToken->type != TokenType::EOL) + { + throw SyntaxError(nextToken->position); + } +} + +const Token* Parser::ScanToken() +{ + const Token* returnVal = &(*nextToken); + + if (nextToken->type != TokenType::EOL) { + returnVal = &(*nextToken); + nextToken++; + } + + return returnVal; +} + +Expression* Parser::ParseExpression() +{ + Expression* expr = ParseWedge(); + + while (nextToken->lexeme == "->" || nextToken->lexeme == "<->") + { + const Token* t = ScanToken(); + Expression* right = ParseWedge(); + if (t->lexeme == "->") + { + expr = new ImplicationExpression(expr, right); + } + else + { + expr = new EquivalenceExpression(expr, right); + } + } + + return expr; +} + +Expression* Parser::ParseWedge() +{ + Expression* expr = ParseUnary(); + + while (nextToken->lexeme == "^" || nextToken->lexeme == "v") + { + const Token* t = ScanToken(); + Expression* right = ParseUnary(); + if (t->lexeme == "^") + { + expr = new ConjunctionExpression(expr, right); + } + else + { + expr = new DisjunctionExpression(expr, right); + } + } + + return expr; +} + +Expression* Parser::ParseUnary() +{ + Expression* expr = nullptr; + + if (nextToken->lexeme == "~") + { + ScanToken(); + expr = new NegationExpression(ParseUnary()); + } + else + { + expr = ParsePrimary(); + } + + return expr; +} + +Expression* Parser::ParsePrimary() +{ + Expression* expr = nullptr; + + if (nextToken->type == TokenType::Atom) + { + const Token* t = ScanToken(); + switch (t->lexeme[0]) + { + case 'p': expr = &IdentifierExpression::p; break; + case 'q': expr = &IdentifierExpression::q; break; + case 'r': expr = &IdentifierExpression::r; break; + case 's': expr = &IdentifierExpression::s; break; + } + } + else if(nextToken->lexeme == "(") + { + ScanToken(); + expr = ParseExpression(); + if (ScanToken()->lexeme != ")") + { + throw SyntaxError(nextToken->position); + } + } + else + { + throw SyntaxError(nextToken->position); + } + + return expr; +} + +bool Parser::Evaluate() const +{ + return expressionTree->Eval(); +} + +unsigned Parser::Size() const +{ + return expressionTree->Size(); +} + +unsigned Parser::VarCount() const +{ + return expressionTree->VarCount(); +} diff --git a/ZOLparser/Parser.hpp b/ZOLparser/Parser.hpp new file mode 100644 index 0000000..3ff3f15 --- /dev/null +++ b/ZOLparser/Parser.hpp @@ -0,0 +1,30 @@ +#pragma once + +#include +#include "Token.hpp" +#include "Expression.hpp" + +#include "Error.hpp" + +class Parser +{ +public: + Parser(const std::string& text); + + const Token* ScanToken(); + + Expression* ParseExpression(); + Expression* ParseWedge(); + Expression* ParseUnary(); + Expression* ParsePrimary(); + + bool Evaluate() const; + unsigned Size() const; + unsigned VarCount() const; + +private: + std::vector tokens; + std::vector::const_iterator nextToken; + + Expression* expressionTree = nullptr; +}; \ No newline at end of file diff --git a/ZOLparser/Token.hpp b/ZOLparser/Token.hpp new file mode 100644 index 0000000..96ffea7 --- /dev/null +++ b/ZOLparser/Token.hpp @@ -0,0 +1,19 @@ +#pragma once + +#include + +enum class TokenType +{ + Atom, + Parenthesis, + Unary, + Binary, + EOL +}; + +struct Token +{ + TokenType type; + std::string lexeme; + unsigned int position; +}; \ No newline at end of file diff --git a/ZOLparser/grammar.txt b/ZOLparser/grammar.txt new file mode 100644 index 0000000..dc71e3d --- /dev/null +++ b/ZOLparser/grammar.txt @@ -0,0 +1,5 @@ +expression -> wedge ( ( "->" | "<->" ) wedge)* +wedge -> unary ( ( "^" | "v" ) unary)*; +unary -> "~" unary | primary; +primary -> atom | "(" expression ")" ; +atom -> [pqrs] ; \ No newline at end of file diff --git a/ZOLparser/main.cpp b/ZOLparser/main.cpp new file mode 100644 index 0000000..e1c7ab7 --- /dev/null +++ b/ZOLparser/main.cpp @@ -0,0 +1,80 @@ +#include +#include "Parser.hpp" + +void PrintHelp(); + +int main(int argc, char** argv) +{ + std::string text; + Parser* parser; + + std::cout << "Zeroth order logic evaluator" << std::endl; + std::cout << "Enter expression or ?: "; + std::cin >> text; + + if (text == "?") + { + PrintHelp(); + return 0; + } + + try + { + parser = new Parser(text); + } + catch (SyntaxError err) + { + std::cerr << err.what() << std::endl; + std::cerr << text << std::endl; + for (int i = 0; i < err.where(); i++) + std::cerr << " "; + std::cerr << "^" << std::endl; + return 1; + } + + unsigned int tableLength = sizeof("| p | q | r | s || ") + text.length() + 2; + // Print table header + std::cout << "+---+---+---+---++-" << std::string(text.length(), '-') << "-+" << std::endl; + std::cout << "| p | q | r | s || " << text << " |" << std::endl; + std::cout << "+---+---+---+---++-" << std::string(text.length(), '-') << "-+" << std::endl; + + for (int p = 0; p != 2; p++) + { + IdentifierExpression::p.SetTruthValue(p); + for (int q = 0; q != 2; q++) + { + IdentifierExpression::q.SetTruthValue(q); + for (int r = 0; r != 2; r++) + { + IdentifierExpression::r.SetTruthValue(r); + for (int s = 0; s != 2; s++) + { + IdentifierExpression::s.SetTruthValue(s); + + std::cout << "| " << p << " | " << q << " | " << r << " | " << s << " || " << std::string(text.length() / 2, ' ') << parser->Evaluate() << std::string(text.length() - text.length() / 2, ' ') << "|" << std::endl; + + } + } + } + } + + std::cout << "+---+---+---+---++-" << std::string(text.length(), '-') << "-+" << std::endl; + + std::cout << "Size = " << parser->Size() << std::endl; + std::cout << "VarCount = " << parser->VarCount() << std::endl; + + return 0; +} + +void PrintHelp() +{ + std::cout << "This program creates truth value tables for zeroth order logic expressions with up to four atoms." << std::endl; + std::cout << "Syntax:" << std::endl; + std::cout << " p,q,r,s - Atom" << std::endl; + std::cout << " ~ - Negation (unary)" << std::endl; + std::cout << " ^ - Conjunction (binary)" << std::endl; + std::cout << " v - Disjunction (binary)" << std::endl; + std::cout << " -> - Implication (binary)" << std::endl; + std::cout << " <-> - Implication (binary)" << std::endl; + std::cout << std::endl << "~ binds stronger than (^, v) which bind stronger than (->, <->)" << std::endl; +}