Add PQL parser support for full grammar (#217)

pengnam · afterdusk · web-flow · commit d1d1da27413a · 2020-10-01T18:48:47.000+08:00
* Add support for AND parsing for relationship and pattern

* Add relationship specifications for Next,Affect,Call

* Refactor for proper pattern and parsing

* Add while and if pattern parsing

* Add multiple result parsing

* Change lexer delimiter due to stmt# usage in attrRef

* Add with statement parsing

* Add definitions for new PqlResult

* Define definitions for ref types

* Change order of structs in PQL.h

* Fix valid relationships

Co-authored-by: Evan (Liang Jun) &lt;afterdusk@users.noreply.github.com&gt;
diff --git a/Team20/Code20/UnitTesting/TestPQLParser.cpp b/Team20/Code20/UnitTesting/TestPQLParser.cpp
@@ -135,7 +135,7 @@ TEST_METHOD(TestParse_DeclarationsMultipleSynonyms) {
   Assert::IsTrue(actualResult == expectedDeclarations);
 } // namespace UnitTesting
 
-TEST_METHOD(TestParse_Select) {
+TEST_METHOD(TestParse_SimpleSelect) {
   const std::vector<PqlToken> input = {
       {TokenType::STMT},         {TokenType::SYNONYM, "p"},
       {TokenType::SEMICOLON},    {TokenType::STMT},
@@ -148,8 +148,46 @@ TEST_METHOD(TestParse_Select) {
   };
 
   const auto actualResult = Pql::parse(input).results;
-  const std::vector<std::string> expectedDeclarations = {"p"};
-  Assert::IsTrue(actualResult == expectedDeclarations);
+  const std::vector<std::string> expectedResults = {"p"};
+  Assert::IsTrue(actualResult == expectedResults);
+} // namespace UnitTesting
+
+TEST_METHOD(TestParse_SimpleSelectAttrRef) {
+  const std::vector<PqlToken> input = {
+      {TokenType::STMT},         {TokenType::SYNONYM, "p"},
+      {TokenType::SEMICOLON},    {TokenType::STMT},
+      {TokenType::SYNONYM, "q"}, {TokenType::SEMICOLON},
+      {TokenType::SELECT},       {TokenType::SYNONYM, "p"},
+      {TokenType::DOT},          {TokenType::STATEMENT_NUM},
+      {TokenType::SUCH},         {TokenType::THAT},
+      {TokenType::FOLLOWS},      {TokenType::OPEN_PARENTHESIS},
+      {TokenType::SYNONYM, "p"}, {TokenType::COMMA},
+      {TokenType::SYNONYM, "q"}, {TokenType::CLOSED_PARENTHESIS},
+  };
+
+  const auto actualResult = Pql::parse(input).results;
+  const std::vector<std::string> expectedResults = {"p"};
+  Assert::IsTrue(actualResult == expectedResults);
+} // namespace UnitTesting
+
+TEST_METHOD(TestParse_MultipleSelect) {
+  const std::vector<PqlToken> input = {
+      {TokenType::STMT},          {TokenType::SYNONYM, "p"},
+      {TokenType::SEMICOLON},     {TokenType::STMT},
+      {TokenType::SYNONYM, "q"},  {TokenType::SEMICOLON},
+      {TokenType::SELECT},        {TokenType::OPEN_ANGLED_BRACKET},
+      {TokenType::SYNONYM, "p"},  {TokenType::DOT},
+      {TokenType::STATEMENT_NUM}, {TokenType::COMMA},
+      {TokenType::SYNONYM, "q"},  {TokenType::CLOSED_ANGLED_BRACKET},
+      {TokenType::SUCH},          {TokenType::THAT},
+      {TokenType::FOLLOWS},       {TokenType::OPEN_PARENTHESIS},
+      {TokenType::SYNONYM, "p"},  {TokenType::COMMA},
+      {TokenType::SYNONYM, "q"},  {TokenType::CLOSED_PARENTHESIS},
+  };
+
+  const auto actualResult = Pql::parse(input).results;
+  const std::vector<std::string> expectedResults = {"p", "q"};
+  Assert::IsTrue(actualResult == expectedResults);
 } // namespace UnitTesting
 
 TEST_METHOD(TestParse_FollowsRelationshipTwoSynonyms) {
@@ -288,7 +326,133 @@ TEST_METHOD(TestParse_LHSPatternSynonymButNotVariable_ThrowsException) {
       {TokenType::UNDERSCORE},   {TokenType::CLOSED_PARENTHESIS}};
   Assert::ExpectException<const char *>([input] { Pql::parse(input); });
 } // namespace UnitTesting
+TEST_METHOD(TestParse_MultiplePatternsWithAnd) {
+  const std::vector<PqlToken> input = {{TokenType::ASSIGN},
+                                       {TokenType::SYNONYM, "a"},
+                                       {TokenType::SEMICOLON},
+                                       {TokenType::VARIABLE},
+                                       {TokenType::SYNONYM, "v"},
+                                       {TokenType::SEMICOLON},
+                                       {TokenType::SELECT},
+                                       {TokenType::SYNONYM, "a"},
+                                       {TokenType::PATTERN},
+                                       {TokenType::SYNONYM, "a"},
+                                       {TokenType::OPEN_PARENTHESIS},
+                                       {TokenType::SYNONYM, "v"},
+                                       {TokenType::COMMA},
+                                       {TokenType::UNDERSCORE},
+                                       {TokenType::CLOSED_PARENTHESIS},
+                                       {TokenType::AND},
+                                       {TokenType::SYNONYM, "a"},
+                                       {TokenType::OPEN_PARENTHESIS},
+                                       {TokenType::SYNONYM, "v"},
+                                       {TokenType::COMMA},
+                                       {TokenType::UNDERSCORE},
+                                       {TokenType::CLOSED_PARENTHESIS},
+                                       {TokenType::AND},
+                                       {TokenType::SYNONYM, "a"},
+                                       {TokenType::OPEN_PARENTHESIS},
+                                       {TokenType::SYNONYM, "v"},
+                                       {TokenType::COMMA},
+                                       {TokenType::UNDERSCORE},
+                                       {TokenType::CLOSED_PARENTHESIS}};
+  const auto actualResult = Pql::parse(input).patterns;
+  const std::vector<ParsedPattern> expectedPatterns{
+      ParsedPattern{{TokenType::ASSIGN, "a"},
+                    {TokenType::VARIABLE, "v"},
+                    PatternSpec{PatternMatchType::Any}},
+      ParsedPattern{{TokenType::ASSIGN, "a"},
+                    {TokenType::VARIABLE, "v"},
+                    PatternSpec{PatternMatchType::Any}},
+      ParsedPattern{{TokenType::ASSIGN, "a"},
+                    {TokenType::VARIABLE, "v"},
+                    PatternSpec{PatternMatchType::Any}}};
+  Assert::IsTrue(actualResult == expectedPatterns);
+}
+TEST_METHOD(TestParse_MultipleRelationshipsWithAnd) {
+  const std::vector<PqlToken> input = {
+      {TokenType::STMT},
+      {TokenType::SYNONYM, "s"},
+      {TokenType::SEMICOLON},
+      {TokenType::SELECT},
+      {TokenType::SYNONYM, "s"},
+      {TokenType::SUCH},
+      {TokenType::THAT},
+      {TokenType::MODIFIES},
+      {TokenType::OPEN_PARENTHESIS},
+      {TokenType::SYNONYM, "s"},
+      {TokenType::COMMA},
+      {TokenType::STRING, "x"},
+      {TokenType::CLOSED_PARENTHESIS},
+      {TokenType::AND},
+      {TokenType::USES},
+      {TokenType::OPEN_PARENTHESIS},
+      {TokenType::SYNONYM, "s"},
+      {TokenType::COMMA},
+      {TokenType::STRING, "x"},
+      {TokenType::CLOSED_PARENTHESIS},
+  };
+  const auto actualResult = Pql::parse(input).relationships;
+  const std::vector<ParsedRelationship> expectedRelationships = {
+      ParsedRelationship{TokenType::MODIFIES,
+                         {TokenType::STMT, "s"},
+                         {TokenType::STRING, "x"}},
+      ParsedRelationship{
+          TokenType::USES, {TokenType::STMT, "s"}, {TokenType::STRING, "x"}}};
+  Assert::IsTrue(actualResult == expectedRelationships);
+}
+TEST_METHOD(TestParse_WhilePatternStatement) {
+  const std::vector<PqlToken> input = {
+      {TokenType::WHILE},
+      {TokenType::SYNONYM, "w"},
+      {TokenType::SEMICOLON},
+      {TokenType::VARIABLE},
+      {TokenType::SYNONYM, "v"},
+      {TokenType::SEMICOLON},
+      {TokenType::SELECT},
+      {TokenType::SYNONYM, "w"},
+      {TokenType::PATTERN},
+      {TokenType::SYNONYM, "w"},
+      {TokenType::OPEN_PARENTHESIS},
+      {TokenType::SYNONYM, "v"},
+      {TokenType::COMMA},
+      {TokenType::UNDERSCORE},
+      {TokenType::CLOSED_PARENTHESIS},
+  };
+  const auto actualResult = Pql::parse(input).patterns;
+  const std::vector<ParsedPattern> expectedPatterns{
+      ParsedPattern{{TokenType::WHILE, "w"},
+                    {TokenType::VARIABLE, "v"},
+                    PatternSpec{PatternMatchType::Any}}};
+  Assert::IsTrue(actualResult == expectedPatterns);
+}
+TEST_METHOD(TestParse_IfPatternStatement) {
+  const std::vector<PqlToken> input = {
+      {TokenType::IF},
+      {TokenType::SYNONYM, "i"},
+      {TokenType::SEMICOLON},
+      {TokenType::VARIABLE},
+      {TokenType::SYNONYM, "v"},
+      {TokenType::SEMICOLON},
+      {TokenType::SELECT},
+      {TokenType::SYNONYM, "v"},
+      {TokenType::PATTERN},
+      {TokenType::SYNONYM, "i"},
+      {TokenType::OPEN_PARENTHESIS},
+      {TokenType::SYNONYM, "v"},
+      {TokenType::COMMA},
+      {TokenType::UNDERSCORE},
+      {TokenType::COMMA},
+      {TokenType::UNDERSCORE},
+      {TokenType::CLOSED_PARENTHESIS},
+  };
+  const auto actualResult = Pql::parse(input).patterns;
+  const std::vector<ParsedPattern> expectedPatterns{
+      ParsedPattern{{TokenType::IF, "i"},
+                    {TokenType::VARIABLE, "v"},
+                    PatternSpec{PatternMatchType::Any}}};
+  Assert::IsTrue(actualResult == expectedPatterns);
+}
 }
 ;
 }
-; // namespace UnitTesting
diff --git a/Team20/Code20/source/PQL.cpp b/Team20/Code20/source/PQL.cpp
@@ -29,7 +29,18 @@ std::unordered_map<std::string, TokenType> stringTokenMap = {
     {"_", TokenType::UNDERSCORE},
     {"(", TokenType::OPEN_PARENTHESIS},
     {")", TokenType::CLOSED_PARENTHESIS},
-    {",", TokenType::COMMA}};
+    {"<", TokenType::OPEN_ANGLED_BRACKET},
+    {">", TokenType::CLOSED_ANGLED_BRACKET},
+    {"BOOLEAN", TokenType::BOOLEAN},
+    {".", TokenType::DOT},
+    {"procName", TokenType::PROCNAME},
+    {"varName", TokenType::VARNAME},
+    {"value", TokenType::VALUE},
+    {"stmt#", TokenType::STATEMENT_NUM},
+    {",", TokenType::COMMA},
+    {"with", TokenType::WITH},
+    {"=", TokenType::EQUALS},
+    {"prog_line", TokenType::PROG_LINE}};
 
 ParsedQuery Pql::parse(std::vector<PqlToken> query) {
   auto parser = PqlParser(query);
diff --git a/Team20/Code20/source/PQL.h b/Team20/Code20/source/PQL.h
@@ -10,9 +10,9 @@
 
 enum class TokenType {
   STMT,
+  PROG_LINE,
   READ,
   PRINT,
-  CALL,
   WHILE,
   IF,
   ELSE,
@@ -31,18 +31,36 @@ enum class TokenType {
   PARENT_T,
   FOLLOWS,
   FOLLOWS_T,
+  AFFECTS,
+  AFFECTS_T,
+  NEXT,
+  NEXT_T,
+  CALL,
+  CALL_T,
   MODIFIES,
   USES,
   MATCH, // Representation of pattern clause as a relationship
 
   SUCH,
   THAT,
+  AND,
   PATTERN,
+  WITH,
 
   SEMICOLON,
   COMMA,
+  DOT,
   OPEN_PARENTHESIS,
   CLOSED_PARENTHESIS,
+  OPEN_ANGLED_BRACKET,
+  CLOSED_ANGLED_BRACKET,
+
+  PROCNAME,
+  VARNAME,
+  VALUE,
+  STATEMENT_NUM,
+  BOOLEAN,
+  EQUALS
 };
 
 /** @brief Token used as intermediary between the lexer and the parser
@@ -53,9 +71,55 @@ struct PqlToken {
   bool operator==(const PqlToken &other) const {
     return type == other.type && value == other.value;
   }
+  // Default constructor to construct an empty PqlToken
+  PqlToken() : type{TokenType::STRING}, value{""} {}
   PqlToken(TokenType specifiedTokenType, std::string specifiedValue = "")
       : type{specifiedTokenType}, value{specifiedValue} {}
 };
+enum class AttributeRefType {
+  PROCNAME,
+  VARNAME,
+  VALUE,
+  STATEMENT_NUM,
+  NONE,
+};
+
+struct Element {
+  std::string synonym;
+  AttributeRefType refType;
+  bool operator==(const Element &other) const {
+    return synonym == other.synonym && refType == other.refType;
+  }
+};
+
+// Used in attrCompare
+enum class ReferenceType { ELEMENT, RAW_VALUE };
+struct Reference {
+  ReferenceType referenceType;
+  PqlToken pqlToken;
+  Element element;
+  Reference(PqlToken specifiedToken)
+      : referenceType{ReferenceType::RAW_VALUE}, pqlToken{specifiedToken} {}
+  Reference(Element specifiedElement)
+      : referenceType{ReferenceType::ELEMENT}, element{specifiedElement} {}
+
+  bool operator==(const Reference &other) const {
+    return referenceType == other.referenceType && pqlToken == other.pqlToken &&
+           element == other.element;
+  }
+};
+
+typedef std::vector<Element> TUPLE;
+
+enum class PqlResultType { Boolean, Tuple };
+
+struct PqlResult {
+  PqlResultType resultType;
+  TUPLE results;
+  bool operator==(const PqlResult &other) const {
+    return resultType == other.resultType && results == other.results;
+  }
+};
 
 /** @brief ParsedRelationship holds the information of a parsed relationship
  */
diff --git a/Team20/Code20/source/PQLLexer.cpp b/Team20/Code20/source/PQLLexer.cpp
@@ -10,6 +10,8 @@
 #include <unordered_set>
 #include <vector>
 
+const char delimiter = '^';
+
 bool isAlphaNumeric(std::string s) {
   for (const auto c : s) {
     if (!isalnum(c)) {
@@ -90,7 +92,7 @@ std::vector<std::string> PqlLexer::delimit(std::string s) {
     case '\n':
     case '\t':
       if (!isWithinStringLiterals) {
-        result.push_back('#');
+        result.push_back(delimiter);
         continue;
       }
       break;
@@ -99,14 +101,18 @@ std::vector<std::string> PqlLexer::delimit(std::string s) {
     case ')':
     case '(':
       if (!isWithinStringLiterals) {
-        result.push_back('#');
+        result.push_back(delimiter);
       }
       break;
     // 1B. Characters that wont appear within string literals
     case ',':
     case ';':
     case '_':
-      result.push_back('#');
+    case '<':
+    case '>':
+    case '.':
+    case '=':
+      result.push_back(delimiter);
       break;
     default:
       break;
@@ -119,13 +125,17 @@ std::vector<std::string> PqlLexer::delimit(std::string s) {
     case '(':
     case ')':
       if (!isWithinStringLiterals) {
-        result.push_back('#');
+        result.push_back(delimiter);
       }
       break;
     // 3B. Characters that won't appear within string literals
     case '_':
     case ',':
-      result.push_back('#');
+    case '<':
+    case '>':
+    case '.':
+    case '=':
+      result.push_back(delimiter);
       break;
     default:
       break;
@@ -135,5 +145,5 @@ std::vector<std::string> PqlLexer::delimit(std::string s) {
     // TODO:
     std::cout << "EXCEPTION";
   }
-  return split(std::string(result.begin(), result.end()), '#');
+  return split(std::string(result.begin(), result.end()), delimiter);
 }
diff --git a/Team20/Code20/source/PQLParser.cpp b/Team20/Code20/source/PQLParser.cpp
diff --git a/Team20/Code20/source/PQLParser.h b/Team20/Code20/source/PQLParser.h
