Start Evaluation

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

Sources/Runtime/Parser.swift

@@ -18,16 +18,7 @@
 import Common
 import Lang
 
-
-
-extension ParserTransitionStatement: EvaluatableParserTransitionStatement {
-  // TODO: Currently transitions to accept.
-  func transition(execution: ProgramExecution) -> (ParserState, ProgramExecution) {
-    return (accept, execution)
-  }
-}
-
-extension ParserState: EvaluatableParserState {
+extension ParserState: EvaluatableParserTransition {
   public func evaluate(execution: ProgramExecution) -> (ParserState, ProgramExecution) {
     var currentExecution = execution
 
@@ -41,10 +32,34 @@ extension ParserState: EvaluatableParserState {
       currentExecution = statement.evaluate(execution: currentExecution)
     }
 
-    return if let transition = transition {
-      transition.transition(execution: currentExecution)
-    } else {
-      (reject, currentExecution)
+    if direct_transition() {
+      return (next_state!, currentExecution)
     }
+
+    if let transition_expression = self.transition,
+      let transition_select_expression = transition_expression.transition_expression
+    {
+      return transition_select_expression.evaluate(execution: currentExecution)
+    }
+    return (reject, currentExecution)
+  }
+}
+
+extension ParserTransitionSelectExpression: EvaluatableParserTransition {
+  func evaluate(execution: Common.ProgramExecution) -> (Lang.ParserState, Common.ProgramExecution) {
+    // First, evaluate the selector.
+
+    switch self.selector.evaluate(execution: execution) {
+    case .Ok(let selector_value):
+        for kse in self.keyset_expressions {
+          if case .Ok(let kse_key) = kse.key.evaluate(execution: execution),
+            kse_key.eq(rhs: selector_value)
+          {
+            return (kse.next_state!, execution)
+          }
+        }
+    case .Error(let e): return (reject, execution.setError(error: e))
+    }
+    return (reject, execution)
   }
 }

Sources/Runtime/Program.swift

@@ -30,4 +30,11 @@ extension ExpressionStatement: EvaluatableParserStatement {
   public func evaluate(execution: ProgramExecution) -> ProgramExecution {
     return execution
   }
+}
+
+// Variables are evaluatable because they can be looked up by identifiers.
+extension Identifier: EvaluatableExpression {
+    public func evaluate(execution: Common.ProgramExecution) -> Result<P4Value> {
+      return execution.scopes.evaluate(identifier: self)
+    }
 }

Sources/Runtime/Protocols.swift

@@ -18,7 +18,7 @@
 import Common
 import Lang
 
-protocol EvaluatableParserState {
+protocol EvaluatableParserTransition {
   func evaluate(execution: ProgramExecution) -> (ParserState, ProgramExecution)
 }
 

Sources/Runtime/Runtime.swift

@@ -20,14 +20,15 @@ import Lang
 
 /// The runtime for a parser
 public class ParserRuntime: CustomStringConvertible {
-  var execution: ParserInstance
+  var parser: ParserInstance
 
   init(execution: ParserInstance) {
-    self.execution = execution
+    self.parser = execution
   }
 
   /// Create a parser runtime from a P4 program
   public static func create(program: Lang.Program) -> Result<ParserRuntime> {
+
     return switch program.starting_parser() {
     case .Ok(let parser):
       switch ParserInstance.create(parser) {
@@ -40,12 +41,12 @@ public class ParserRuntime: CustomStringConvertible {
 
   /// Run the P4 parser on a given packet
   public func run(input: Packet) -> Result<(ParserState, ProgramExecution)> {
-    execution.scopes.enter()
-    return .Ok(execution.execute())
+    parser.scopes.enter()
+    return .Ok(parser.execute())
   }
 
   public var description: String {
-    return "Runtime:\nExecution: \(execution)"
+    return "Runtime:\nExecution: \(parser)"
   }
 }
 
@@ -57,7 +58,7 @@ extension ParserInstance: Execution {
 
     // Evaluate until the state is either accept or reject.
     while state != accept && state != reject {
-      (state, execution) = self.state.evaluate(execution: execution)
+      (state, execution) = state.evaluate(execution: execution)
     }
     return (state, execution)
   }