Completely Refactor Execution

Signed-off-by: Will Hawkins <hawkinsw@obs.cr>

Sources/P4Compiler/Expression.swift

@@ -101,7 +101,7 @@ struct Expression {
 
     #RequireNodesType<Node, EvaluatableExpression>(
       nodes: node, type: ["expression", "keysetExpression"],
-      msg: ["expression", "keyset expression"])
+      nice_type_names: ["expression", "keyset expression"])
 
     // If the node is a keyset expression, then dig out the expression:
     let node =
@@ -152,3 +152,97 @@ struct Identifier {
     }
   }
 }
+
+extension SelectExpression: CompilableExpression {
+  static func compile(
+    node: Node, inTree tree: MutableTree, withScopes scopes: LexicalScopes
+  ) -> Result<EvaluatableExpression?> {
+    #RequireNodeType<Node, (SelectExpression, LexicalScopes)>(
+      node: node, type: "selectExpression", nice_type_name: "parser select expression")
+
+    guard let selector_node = node.child(at: 2),
+      selector_node.nodeType == "expression"
+    else {
+      return .Error(ErrorOnNode(node: node, withError: "Could not find selector expression"))
+    }
+
+    guard let select_body_node = node.child(at: 5),
+      select_body_node.nodeType == "selectBody"
+    else {
+      return .Error(ErrorOnNode(node: node, withError: "Could not find select expression body"))
+    }
+
+    let maybe_selector = Expression.Compile(node: selector_node, inTree: tree, withScopes: scopes)
+    guard case .Ok(let selector) = maybe_selector else {
+      return .Error(
+        Error(
+          withMessage:
+            "Could not parse transition select expression selector expression: \(maybe_selector.error()!)"
+        ))
+    }
+
+    var kses: [KeysetExpression] = Array()
+    var kses_errors: [Error] = Array()
+
+    select_body_node.enumerateNamedChildren() { current_node in
+      let maybe_parsed_kse = KeysetExpression.compile(node: current_node, inTree: tree, withScopes: scopes)
+      if case .Ok(let parsed_kse) = maybe_parsed_kse {
+        kses.append(parsed_kse as! KeysetExpression)
+      } else {
+        kses_errors.append(Error(withMessage: "\(maybe_parsed_kse.error()!)"))
+      }
+    }
+
+    if !kses_errors.isEmpty {
+      return .Error(
+        Error(
+          withMessage: "Error(s) parsing select cases: "
+            + (kses_errors.map { error in
+              return "\(error.msg)"
+            }.joined(separator: ";\n"))))
+    }
+    return .Ok(
+        SelectExpression(withSelector: selector, withKeysetExpressions: kses),
+      )
+  }
+}
+
+extension KeysetExpression: CompilableExpression {
+  static func compile(
+    node: Node, inTree tree: MutableTree, withScopes scopes: LexicalScopes
+  ) -> Result<EvaluatableExpression?> {
+      if node.nodeType != "selectCase" {
+        return Result.Error(Error(withMessage: "Expected select case not found"))
+      }
+
+      guard let keysetexpression_node = node.child(at: 0),
+        keysetexpression_node.nodeType == "keysetExpression"
+      else {
+        return Result.Error(Error(withMessage: "Missing keyset expression in select case"))
+      }
+
+      guard let targetstate_node = node.child(at: 2),
+        targetstate_node.nodeType == "identifier"
+      else {
+        return Result.Error(Error(withMessage: "Missing target state in select case"))
+      }
+
+      let maybe_parsed_keysetexpression = Expression.Compile(
+        node: keysetexpression_node, inTree: tree, withScopes: scopes)
+      guard case Result.Ok(let keysetexpression) = maybe_parsed_keysetexpression else {
+        return Result.Error(maybe_parsed_keysetexpression.error()!)
+      }
+
+      let maybe_parsed_targetstate = Identifier.Compile(
+        node: targetstate_node, inTree: tree, withScopes: scopes)
+      guard case .Ok(let targetstate) = maybe_parsed_targetstate else {
+        return Result.Error(maybe_parsed_targetstate.error()!)
+      }
+
+      return .Ok(
+          KeysetExpression(
+            withKey: keysetexpression, withNextState: targetstate) 
+        )
+    }
+  }
+