Start Evaluation

Signed-off-by: Will Hawkins <hawkinsw@obs.cr>
2026-02-10 03:37:57 -05:00
parent 0dd5ce4be3
commit 3693bdc02d
15 changed files with 635 additions and 119 deletions
@@ -0,0 +1,109 @@
+// p4rse, Copyright 2026, Will Hawkins
+//
+// This file is part of p4rse.
+//
+// This file is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program. If not, see <https://www.gnu.org/licenses/>.
+
+// expression: $ => choice($.identifier, $.integer, $.true, $.false, $.string_literal), // Very limited.
+
+import Common
+import SwiftTreeSitter
+import TreeSitterP4
+
+protocol ParseableEvaluatableExpression {
+  static func parse(node: Node, inTree tree: MutableTree) -> Result<EvaluatableExpression?>
+}
+
+extension Identifier: ParseableEvaluatableExpression {
+  static func parse(
+    node: SwiftTreeSitter.Node, inTree tree: SwiftTreeSitter.MutableTree
+  ) -> Result<EvaluatableExpression?> {
+
+    guard
+      let parser_statement_query = try? SwiftTreeSitter.Query(
+        language: p4lang,
+        data: String(
+          "(expression (identifier) @identifier)"
+        ).data(using: String.Encoding.utf8)!)
+    else {
+      return Result.Error(Error(withMessage: "Could not compile the tree sitter query"))
+    }
+
+    let qr = parser_statement_query.execute(node: node, in: tree)
+
+    guard let result = qr.next() else {
+      return .Ok(.none)
+    }
+
+    return .Ok(Identifier(name: result.captures[0].node.text!))
+  }
+}
+
+extension P4BooleanValue: ParseableEvaluatableExpression {
+  static func parse(
+    node: SwiftTreeSitter.Node, inTree tree: SwiftTreeSitter.MutableTree
+  ) -> Result<EvaluatableExpression?> {
+
+    guard
+      let true_query = try? SwiftTreeSitter.Query(
+        language: p4lang,
+        data: String(
+          "(expression (true))"
+        ).data(using: String.Encoding.utf8)!)
+    else {
+      return Result.Error(Error(withMessage: "Could not compile the tree sitter query"))
+    }
+
+    let true_qr = true_query.execute(node: node, in: tree)
+
+    if true_qr.next() != nil {
+      return .Ok(P4BooleanValue(withValue: true))
+    }
+
+    guard
+      let false_query = try? SwiftTreeSitter.Query(
+        language: p4lang,
+        data: String(
+          "(expression (false))"
+        ).data(using: String.Encoding.utf8)!)
+    else {
+      return Result.Error(Error(withMessage: "Could not compile the tree sitter query"))
+    }
+
+    let false_qr = false_query.execute(node: node, in: tree)
+
+    if false_qr.next() != nil {
+      return .Ok(P4BooleanValue(withValue: false))
+    }
+    return .Ok(.none)
+  }
+}
+
+struct Expression {
+  public static func Parse(node: Node, inTree: MutableTree) -> Result<EvaluatableExpression> {
+    let localElementsParsers: [ParseableEvaluatableExpression.Type] = [
+      P4BooleanValue.self, Identifier.self,
+    ]
+
+    for le_parser in localElementsParsers {
+      if case Result.Ok(.some(let parsed)) = le_parser.parse(
+        node: node, inTree: inTree)
+      {
+        return .Ok(parsed)
+      }
+    }
+
+    return Result.Error(Error(withMessage: "Could not parse into expression."))
+  }
+}
@@ -229,10 +229,95 @@ public struct Parser {
      return Result.Ok(statements)
    }

+    static func TransitionKeysetExpression(
+      node: Node, inTree tree: MutableTree
+    ) -> Result<[KeysetExpression]> {
+      guard
+        let transition_selection_expression_query = try? SwiftTreeSitter.Query(
+          language: p4lang,
+          data: String(
+            "((keysetExpression (expression) @ks) (colon) (identifier) @next-state)"
+          ).data(using: String.Encoding.utf8)!)
+      else {
+        return Result.Error(Error(withMessage: "Could not compile the tree sitter query"))
+      }
+
+      let qr = transition_selection_expression_query.execute(node: node, in: tree)
+
+      var kses: [KeysetExpression] = Array()
+
+      for expression in qr {
+        let next_state_name = expression.captures[1].node.text!
+        if case .Error(let e) = Expression.Parse(node: expression.captures[0].node, inTree: tree)
+          .map(block: { expression in
+            kses.append(
+              KeysetExpression(
+                withKey: expression, withNextStateName: next_state_name))
+            return .Ok(expression)
+          })
+        {
+          return .Error(e)
+        }
+      }
+
+      return .Ok(kses)
+    }
+
+    static func TransitionSelectExpression(
+      node: Node, inTree tree: MutableTree
+    ) -> Result<ParserTransitionStatement> {
+      guard
+        let transition_selection_expression_query = try? SwiftTreeSitter.Query(
+          language: p4lang,
+          data: String(
+            "(parserTransitionStatement (transition) (transitionSelectionExpression (selectExpression (select) (expression) @selector (selectBody) @body)))"
+          ).data(using: String.Encoding.utf8)!)
+      else {
+        return Result.Error(Error(withMessage: "Could not compile the tree sitter query"))
+      }
+
+      let qr = transition_selection_expression_query.execute(node: node, in: tree)
+
+      guard let query_result = qr.next() else {
+        return .Error(Error(withMessage: "Could not find transition select expression"))
+      }
+
+      let selector = query_result.captures(named: "selector")
+      let body = query_result.captures(named: "body")
+
+      return Expression.Parse(node: selector[0].node, inTree: tree).map { expression in
+        return switch TransitionKeysetExpression(node: body[0].node, inTree: tree) {
+        case .Ok(let kse):
+          Result<ParserTransitionStatement>.Ok(
+            ParserTransitionStatement(
+              withTransitionExpression: ParserTransitionSelectExpression(
+                withSelector: expression, withKeysetExpressions: kse)))
+        case .Error(let e): Result<ParserTransitionStatement>.Error(e)
+        }
+      }
+    }
+
    static func TransitionStatement(
      node: Node, inTree tree: MutableTree
-    ) -> ParserTransitionStatement? {
-      return ParserTransitionStatement()
+    ) -> Result<ParserTransitionStatement> {
+      guard
+        let next_state_query = try? SwiftTreeSitter.Query(
+          language: p4lang,
+          data: String(
+            "(parserTransitionStatement (transition) (transitionSelectionExpression (identifier) @next-state))"
+          ).data(using: String.Encoding.utf8)!)
+      else {
+        return Result.Error(Error(withMessage: "Could not compile the tree sitter query"))
+      }
+
+      let qr = next_state_query.execute(node: node, in: tree)
+
+      if let next_state_result = qr.next() {
+        let transition_capture = next_state_result.captures(named: "next-state")
+        return .Ok(ParserTransitionStatement(withNextState: transition_capture[0].node.text!))
+      }
+
+      return TransitionSelectExpression(node: node, inTree: tree)
    }

    static func State(node: Node, inTree tree: MutableTree) -> Result<ParserState> {
@@ -259,7 +344,7 @@ public struct Parser {
      guard !state_name_capture.isEmpty,
        !transition_capture.isEmpty,
        let parsed_state_name = state_name_capture[0].node.text,
-        let transition_statement = TransitionStatement(
+        case .Ok(let transition_statement) = TransitionStatement(
          node: transition_capture[0].node, inTree: tree)
      else {
        return Result.Error(Error(withMessage: "Could not parse a parser declaration"))
@@ -297,7 +382,9 @@ public struct Parser {
          withTransition: transition_statement))
    }
  }
-  static func Parser(withName name: Identifier, node: Node, inTree tree: MutableTree) -> Result<Lang.Parser> {
+  static func Parser(
+    withName name: Identifier, node: Node, inTree tree: MutableTree
+  ) -> Result<Lang.Parser> {
    guard
      let parser_state_query = try? SwiftTreeSitter.Query(
        language: p4lang,
@@ -312,12 +399,23 @@ public struct Parser {
    var parser = Lang.Parser(withName: name)

    // Build a state from each one listed.
-    for parser_states in parser_state_query.execute(node: node, in: tree) {
-      switch P4Parser.State(node: parser_states.nodes[0], inTree: tree) {
-      case Result.Ok(let state): parser.states.append(state)
-      case Result.Error(let error): return Result.Error(error)
+    let qr = parser_state_query.execute(node: node, in: tree)
+    let qr_value = qr.next()!
+    let captures = qr_value.captures(named: "parser-states")
+
+    var error: Error? = .none
+
+    // TODO: Assert that there is only one.
+    captures[0].node.enumerateChildren { parser_state in
+      switch P4Parser.State(node: parser_state, inTree: tree) {
+      case Result.Ok(let state): parser.states = parser.states.append(state: state)
+      case Result.Error(let e): error = e
      }
    }
+
+    if let error = error {
+      return .Error(error)
+    }
    return Result.Ok(parser)
  }

@@ -354,7 +452,10 @@ public struct Parser {
    let parser_qc = parser_declaration_query.execute(in: tree)

    for parser_declaration in parser_qc {
-      switch Parser(withName: Identifier(name: parser_declaration.nodes[0].text!), node: parser_declaration.nodes[1], inTree: tree) {
+      switch Parser(
+        withName: Identifier(name: parser_declaration.nodes[0].text!),
+        node: parser_declaration.nodes[1], inTree: tree)
+      {
      case Result.Ok(let parser): program.types.append(parser)
      case Result.Error(let error): return Result.Error(error)
      }