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
@@ -25,8 +25,65 @@ public struct LocalElement {

 }

+public struct KeysetExpression {
+  public let key: EvaluatableExpression
+  public let next_state_name: String
+  public let next_state: ParserState?
+
+  public init(withKey key: EvaluatableExpression, withNextStateName next_state_name: String) {
+    self.key = key
+    self.next_state_name = next_state_name
+    self.next_state = .none
+  }
+  public init(
+    withKey key: EvaluatableExpression, withNextStateName next_state_name: String,
+    withNextState next_state: ParserState
+  ) {
+    self.key = key
+    self.next_state_name = next_state_name
+    self.next_state = next_state
+  }
+
+}
+
+public struct ParserTransitionSelectExpression {
+  public let selector: EvaluatableExpression
+  public let keyset_expressions: [KeysetExpression]
+
+  public init(
+    withSelector selector: EvaluatableExpression, withKeysetExpressions kses: [KeysetExpression]
+  ) {
+    self.selector = selector
+    self.keyset_expressions = kses
+  }
+
+  public func append_checked_kse(kse: KeysetExpression) -> ParserTransitionSelectExpression {
+    var new_kse = self.keyset_expressions
+    new_kse.append(kse)
+    return ParserTransitionSelectExpression(
+      withSelector: self.selector, withKeysetExpressions: new_kse)
+  }
+
+}
+
 public struct ParserTransitionStatement {
-  public init() {}
+  public let next_state_name: String?
+  public let transition_expression: ParserTransitionSelectExpression?
+
+  public init() {
+    self.next_state_name = .none
+    self.transition_expression = .none
+  }
+
+  public init(withTransitionExpression transition_expression: ParserTransitionSelectExpression) {
+    self.next_state_name = .none
+    self.transition_expression = transition_expression
+  }
+
+  public init(withNextState next_state_name: String) {
+    self.next_state_name = next_state_name
+    self.transition_expression = .none
+  }
 }

 public struct VariableDeclarationStatement {
@@ -36,16 +93,13 @@ public struct VariableDeclarationStatement {
  }
 }

-public struct ExpressionStatement {
-  public init() {}
-}
-
-public struct ParserState: Equatable, CustomStringConvertible {
+public class ParserState: Equatable, CustomStringConvertible {

  public private(set) var state_name: String
  public private(set) var local_elements: [EvaluatableParserStatement]
  public private(set) var statements: [EvaluatableParserStatement]
  public private(set) var transition: ParserTransitionStatement?
+  public private(set) var next_state: ParserState?

  public var description: String {
    return "Name: \(state_name)"
@@ -67,6 +121,37 @@ public struct ParserState: Equatable, CustomStringConvertible {
    self.statements = statements ?? Array()
  }

+  public func semantic_check(states: ParserStates) -> Bool {
+    guard let transition = transition else {
+      return self == accept || self == reject 
+    }
+
+    if let transition_select_expression = transition.transition_expression {
+      var updated_tse = ParserTransitionSelectExpression(
+        withSelector: transition_select_expression.selector, withKeysetExpressions: [])
+
+      for kse in transition_select_expression.keyset_expressions {
+        guard let next_state = states.find(withName: kse.next_state_name) else {
+          return false
+        }
+        let new_kse = KeysetExpression(
+          withKey: kse.key, withNextStateName: kse.next_state_name, withNextState: next_state)
+        updated_tse = updated_tse.append_checked_kse(kse: new_kse)
+      }
+      self.transition = ParserTransitionStatement(withTransitionExpression: updated_tse)
+      return true
+    }
+
+    if let next_state_name = transition.next_state_name,
+      let next_state = states.find(withName: next_state_name)
+    {
+      self.next_state = next_state
+      return true
+    }
+
+    return false
+  }
+
  /// (private) constructor (no transition)
  ///
  /// accept and reject are the only final states and they are constructed internally.
@@ -76,24 +161,76 @@ public struct ParserState: Equatable, CustomStringConvertible {
    local_elements = Array()
    statements = Array()
  }
+
+  public func direct_transition() -> Bool {
+    return
+      if let transition = self.transition,
+      transition.next_state_name != nil
+    {
+      true
+    } else {
+      false
+    }
+  }
 }

 public struct ParserStates {
  public var states: [ParserState] = Array()
+
+  public func count() -> Int {
+    return states.count
+  }
+
+  public func find(withName name: String) -> ParserState? {
+    for state in states {
+      if state.state_name == name {
+        return .some(state)
+      }
+    }
+    return .none
+  }
+
+  public func semantic_check() -> Result<()> {
+    // Check whether all the states referred to in the transition statements are
+    // valid.
+    let errors = states.filter { state in
+      return !state.semantic_check(states: self)
+    }.map { state in
+      return Result<()>.Error(Error(withMessage: "State \(state) has invalid transition"))
+    }
+
+    if !errors.isEmpty {
+      return errors[0]
+    }
+
+    return .Ok(())
+  }
+
+  public init() {
+    self.states = Array()
+  }
+
+  private init(withStates states: [ParserState]) {
+    self.states = states
+  }
+
+  public func append(state: ParserState) -> ParserStates {
+    var new_states = self.states
+    new_states.append(state)
+    return ParserStates(withStates: new_states)
+  }
 }

 nonisolated(unsafe) public let accept: ParserState = ParserState(name: "accept")
 nonisolated(unsafe) public let reject: ParserState = ParserState(name: "reject")

 public struct Parser: P4Type {
-  public var states: [ParserState] = Array()
-  public var count: Int {
-    states.count
-  }
+  public var states: ParserStates

  public var name: Identifier

  public init(withName name: Identifier) {
+    self.states = ParserStates()
    self.name = name
  }

@@ -102,40 +239,52 @@ public struct Parser: P4Type {
  }

  public func findStartState() -> ParserState? {
-    for state in states {
+    for state in states.states {
      if state.state_name == "start" {
        return state
      }
    }
    return .none
  }
+
+  public func semantic_check() -> Result<()> {
+    return self.states.semantic_check()
+  }
 }

 public class ParserInstance: ProgramExecution {

-    private init(state: ParserState) {
-      self.state = state
-      super.init()
+  public var state: ParserState
+
+  private init(state: ParserState) {
+    self.state = state
+    super.init()
+  }
+
+  public static func create(_ parser: Parser) -> Result<ParserInstance> {
+
+    var augmented_parser = Parser(withName: parser.name)
+    augmented_parser.states = parser.states.append(state: accept).append(state: reject)
+
+    if case .Error(let e) = augmented_parser.semantic_check() {
+      return .Error(e)
    }

-    public static func create(_ parser: Parser) -> Result<ParserInstance> {
-        guard let start_state = parser.findStartState() else {
-            return Result.Error(Error(withMessage: "Could not find the start state"))
-        }
-        let new = ParserInstance(state: start_state)
-
-        return Result.Ok(new)
+    guard let start_state = augmented_parser.findStartState() else {
+      return Result.Error(Error(withMessage: "Could not find the start state"))
    }
+    let new = ParserInstance(state: start_state)

-    public var state: ParserState
+    return Result.Ok(new)
+  }

-    public func transition(toNextState state: ParserState) -> ParserInstance {
-        let next = self
-        next.state = state
-        return next
-    }
+  public func transition(toNextState state: ParserState) -> ParserInstance {
+    let next = self
+    next.state = state
+    return next
+  }

-    public override var description: String {
-        return "Execution: \(super.description)\nCurrent State: \(state)"
-    }
-}
+  public override var description: String {
+    return "Execution: \(super.description)\nCurrent State: \(state)"
+  }
+}