hawkinsw/gp4
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Start Moving Away From Queries

Browse Source 
Signed-off-by: Will Hawkins <hawkinsw@obs.cr>
This commit is contained in:
Will Hawkins
2026-02-27 06:16:14 -05:00
parent 2c7f71dbd4
commit 2c5bfc3e1c
7 changed files with 171 additions and 117 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Sources/P4Lang/Parser.swift
+25 -25
View File
@@ -37,20 +37,20 @@ public struct ParserAssignmentStatement {
public struct KeysetExpression {
public let key: EvaluatableExpression
public let next_state_name: String
public let next_state_identifier: Identifier
public let next_state: ParserState?
public init(withKey key: EvaluatableExpression, withNextStateName next_state_name: String) {
public init(withKey key: EvaluatableExpression, withNextState next_state_id: Identifier) {
self.key = key
self.next_state_name = next_state_name
self.next_state_identifier = next_state_id
self.next_state = .none
}
public init(
withKey key: EvaluatableExpression, withNextStateName next_state_name: String,
withKey key: EvaluatableExpression, withNextState next_state_id: Identifier,
withNextState next_state: ParserState
) {
self.key = key
self.next_state_name = next_state_name
self.next_state_identifier = next_state_id
self.next_state = next_state
}
@@ -76,28 +76,28 @@ public struct ParserTransitionSelectExpression {
}
public struct ParserTransitionStatement {
public let next_state_name: String?
public let next_state: Identifier?
public let transition_expression: ParserTransitionSelectExpression?
public init() {
self.next_state_name = .none
self.next_state = .none
self.transition_expression = .none
}
public init(withTransitionExpression transition_expression: ParserTransitionSelectExpression) {
self.next_state_name = .none
self.next_state = .none
self.transition_expression = transition_expression
}
public init(withNextState next_state_name: String) {
self.next_state_name = next_state_name
public init(withNextState next_state: Identifier) {
self.next_state = next_state
self.transition_expression = .none
}
}
public class ParserState: Equatable, CustomStringConvertible, Comparable {
public private(set) var state_name: String
public private(set) var state: Identifier
public private(set) var local_elements: [EvaluatableStatement]
public private(set) var statements: [EvaluatableStatement]
public private(set) var transition: ParserTransitionStatement?
@@ -111,20 +111,20 @@ public class ParserState: Equatable, CustomStringConvertible, Comparable {
}
public var description: String {
return "Name: \(state_name)"
return "Name: \(state)"
}
public static func == (lhs: ParserState, rhs: ParserState) -> Bool {
return lhs.state_name == rhs.state_name
return lhs.state == rhs.state
}
/// Construct a ParserState
public init(
name: String, withLocalElements localElements: [EvaluatableStatement]?,
name: Identifier, withLocalElements localElements: [EvaluatableStatement]?,
withStatements stmts: [EvaluatableStatement]?,
withTransition transitionStatement: ParserTransitionStatement
) {
state_name = name
state = name
transition = transitionStatement
local_elements = localElements ?? Array()
statements = stmts ?? Array()
@@ -135,8 +135,8 @@ public class ParserState: Equatable, CustomStringConvertible, Comparable {
return self == accept || self == reject
}
if let next_state_name = transition.next_state_name,
let next_state = states.find(withName: next_state_name)
if let next_state = transition.next_state,
let next_state = states.find(withIdentifier: next_state)
{
self.next_state = next_state
return true
@@ -148,8 +148,8 @@ public class ParserState: Equatable, CustomStringConvertible, Comparable {
/// (private) constructor (no transition)
///
/// accept and reject are the only final states and they are constructed internally.
init(name: String) {
state_name = name
init(name: Identifier) {
state = name
transition = .none
local_elements = Array()
statements = Array()
@@ -158,7 +158,7 @@ public class ParserState: Equatable, CustomStringConvertible, Comparable {
public func direct_transition() -> Bool {
return
if let transition = self.transition,
transition.next_state_name != nil
transition.next_state != nil
{
true
} else {
@@ -167,8 +167,8 @@ public class ParserState: Equatable, CustomStringConvertible, Comparable {
}
}
nonisolated(unsafe) public let accept: ParserState = ParserState(name: "accept")
nonisolated(unsafe) public let reject: ParserState = ParserState(name: "reject")
nonisolated(unsafe) public let accept: ParserState = ParserState(name: Identifier(name: "accept"))
nonisolated(unsafe) public let reject: ParserState = ParserState(name: Identifier(name: "reject"))
public struct ParserStates {
public var states: [ParserState] = Array()
@@ -177,9 +177,9 @@ public struct ParserStates {
return states.count
}
public func find(withName name: String) -> ParserState? {
public func find(withIdentifier id: Identifier) -> ParserState? {
for state in states {
if state.state_name == name {
if state.state == id {
return .some(state)
}
}
@@ -233,7 +233,7 @@ public struct Parser: P4Type {
public func findStartState() -> ParserState? {
for state in states.states {
if state.state_name == "start" {
if state.state == Identifier(name:"start") {
return state
}
}
Sources/P4Parser/Expression.swift
+25 -1
View File
@@ -51,7 +51,7 @@ extension TypedIdentifier: ParseableEvaluatableExpression {
let value_capture = result.captures(named: "identifier")
guard
case Result.Ok(let type) = scopes.lookup(
identifier: Identifier(name: value_capture[0].node.text!))
identifier: Common.Identifier(name: value_capture[0].node.text!))
else {
return .Error(Error(withMessage: "Cannot find \(result.captures[0].node.text!) in scope"))
}
@@ -178,3 +178,27 @@ struct Expression {
return Result.Error(Error(withMessage: "Could not parse into expression."))
}
}
struct LValue {
public static func Parse(
node: Node, inTree: MutableTree, withScopes scopes: LexicalScopes
) -> Result<Common.Identifier> {
return if let node_text_value = node.text {
.Ok(Common.Identifier(name: node_text_value))
} else {
.Error(Error(withMessage: "Could not parse an identifier for an LValue"))
}
}
}
struct Identifier {
public static func Parse(
node: Node, inTree: MutableTree, withScopes scopes: LexicalScopes
) -> Result<Common.Identifier> {
return if let node_text_value = node.text {
.Ok(Common.Identifier(name: node_text_value))
} else {
.Error(Error(withMessage: "Could not parse an identifier from \(node)"))
}
}
}
Sources/P4Parser/Parser.swift
+107 -77
View File
@@ -28,40 +28,21 @@ extension ParserAssignmentStatement: ParseableStatement {
public static func Parse(
node: Node, inTree tree: MutableTree, withScopes scopes: LexicalScopes
) -> Result<(EvaluatableStatement?, LexicalScopes)> {
guard
let parser_assignment_statement_query = try? SwiftTreeSitter.Query(
language: p4lang,
data: String(
"(assignmentStatement (expression) @lvalue (assignment) (expression) @value) @assignment"
).data(using: String.Encoding.utf8)!)
if node.nodeType != "assignmentStatement" {
return Result.Ok((.none, scopes))
}
guard let lvalue_node = node.child(at: 0),
lvalue_node.nodeType == "expression"
else {
return Result.Ok((.none, scopes))
return Result.Error(Error(withMessage: "Missing lvalue in assignment statement"))
}
let qr = parser_assignment_statement_query.execute(node: node, in: tree)
guard let parser_assignment_statement = qr.next() else {
return Result.Ok((.none, scopes))
}
let assignment_capture = parser_assignment_statement.captures(named: "assignment")
let lvalue_capture = parser_assignment_statement.captures(named: "lvalue")
let rvalue_capture = parser_assignment_statement.captures(named: "value")
// There must be a type name and a variable name
guard !lvalue_capture.isEmpty,
!rvalue_capture.isEmpty,
let lvalue_expression_raw = lvalue_capture[0].node.text
guard let rvalue_node = node.child(at: 2),
rvalue_node.nodeType == "expression"
else {
return Result.Error(
Error(withMessage: "Could not parse a parser assignment statement"))
}
let rvalue_node = rvalue_capture[0].node
let lvalue_node = lvalue_capture[0].node
let assignment_node = assignment_capture[0].node
if assignment_node.parent != node.parent {
return Result.Ok((.none, scopes))
return Result.Error(Error(withMessage: "Missing lvalue in assignment statement"))
}
let maybe_parsed_rvalue = Expression.Parse(node: rvalue_node, inTree: tree, withScopes: scopes)
@@ -69,7 +50,10 @@ extension ParserAssignmentStatement: ParseableStatement {
return Result.Error(maybe_parsed_rvalue.error()!)
}
let lvalue_identifier = Identifier(name: lvalue_expression_raw)
let maybe_parsed_lvalue = LValue.Parse(node: lvalue_node, inTree: tree, withScopes: scopes)
guard case .Ok(let lvalue_identifier) = maybe_parsed_lvalue else {
return Result.Error(maybe_parsed_lvalue.error()!)
}
guard case Result.Ok(let lvalue_type) = scopes.lookup(identifier: lvalue_identifier) else {
return Result.Error(
Error(withMessage: "Cannot assign to variable \(lvalue_identifier) not in scope"))
@@ -149,44 +133,47 @@ public struct Parser {
public struct TransitionSelectExpressionCaseStatement {
static func Parse(
node: Node, inTree tree: MutableTree, withLexicalScopes scopes: LexicalScopes
) -> Result<([KeysetExpression], LexicalScopes)> {
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)!)
) -> Result<(KeysetExpression, LexicalScopes)> {
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: "Could not compile the tree sitter query"))
return Result.Error(Error(withMessage: "Missing keyset expression in select case"))
}
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, withScopes: scopes
)
.map(block: { expression in
kses.append(
KeysetExpression(
withKey: expression, withNextStateName: next_state_name))
return .Ok(expression)
}) {
return .Error(e)
}
guard let targetstate_node = node.child(at: 2),
targetstate_node.nodeType == "identifier"
else {
return Result.Error(Error(withMessage: "Missing target state in select case"))
}
return .Ok((kses, scopes))
let maybe_parsed_keysetexpression = Expression.Parse(
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.Parse(
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), scopes
))
}
}
public struct TransitionSelectExpression {
static func Parse(
node: Node, inTree tree: MutableTree, withScope scopes: LexicalScopes
) -> Result<(ParserTransitionStatement?, LexicalScopes)> {
) -> Result<(ParserTransitionSelectExpression, LexicalScopes)> {
guard
let transition_selection_expression_query = try? SwiftTreeSitter.Query(
language: p4lang,
@@ -206,22 +193,50 @@ public struct Parser {
let selector = query_result.captures(named: "selector")
let body = query_result.captures(named: "body")
return Expression.Parse(node: selector[0].node, inTree: tree, withScopes: scopes).map {
expression in
return
switch TransitionSelectExpressionCaseStatement.Parse(
node: body[0].node, inTree: tree, withLexicalScopes: scopes)
{
case .Ok((let kse, let newLexicalScopes)):
Result<(ParserTransitionStatement?, LexicalScopes)>.Ok(
(
ParserTransitionStatement(
withTransitionExpression: ParserTransitionSelectExpression(
withSelector: expression, withKeysetExpressions: kse)), newLexicalScopes
))
case .Error(let e): Result.Error(e)
if selector.isEmpty {
return .Error(
Error(withMessage: "Could not find transition select expression selector expression"))
}
let selector_node = selector[0].node
let maybe_selector = Expression.Parse(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()!)"
))
}
if body.isEmpty {
return .Error(Error(withMessage: "Could not find transition select expression body"))
}
let body_node = body[0].node
var kses: [KeysetExpression] = Array()
for childidx in 0..<body_node.childCount {
if !childidx.isMultiple(of: 2) {
let maybe_semicolon = body_node.child(at: childidx)!
if maybe_semicolon.nodeType != "semicolon" {
return .Error(Error(withMessage: "Expected a semicolon but saw \(maybe_semicolon)"))
}
continue
}
let maybe_parsed_kse = TransitionSelectExpressionCaseStatement.Parse(
node: body_node.child(at: childidx)!, inTree: tree, withLexicalScopes: scopes)
if case .Ok((let parsed_kse, _)) = maybe_parsed_kse {
kses.append(parsed_kse)
} else {
return .Error(
Error(withMessage: "Error when parsing select case: \(maybe_parsed_kse.error()!)"))
}
}
return .Ok(
(
ParserTransitionSelectExpression(withSelector: selector, withKeysetExpressions: kses),
scopes
))
}
}
@@ -243,11 +258,25 @@ public struct Parser {
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!), scopes))
let maybe_parsed_next_state = Identifier.Parse(
node: transition_capture[0].node, inTree: tree, withScopes: scopes)
if case .Ok(let next_state) = maybe_parsed_next_state {
return .Ok(
(ParserTransitionStatement(withNextState: next_state), scopes))
} else {
return .Error(
Error(
withMessage:
"Could not parse the next state in a transition statement: \(maybe_parsed_next_state.error()!)"
))
}
}
return TransitionSelectExpression.Parse(node: node, inTree: tree, withScope: scopes)
return switch TransitionSelectExpression.Parse(node: node, inTree: tree, withScope: scopes) {
case .Ok((let tse, _)):
.Ok((ParserTransitionStatement(withTransitionExpression: tse), scopes))
case .Error(let e): .Error(e)
}
}
}
@@ -325,7 +354,8 @@ public struct Parser {
// TODO: Now that scopes are involved, doing this out of order will not work!
guard !state_name_capture.isEmpty,
!transition_capture.isEmpty,
let parsed_state_name = state_name_capture[0].node.text
case .Ok(let parsed_state_name) = Identifier.Parse(
node: state_name_capture[0].node, inTree: tree, withScopes: scopes)
else {
return Result.Error(Error(withMessage: "Could not parse a parser declaration"))
}
@@ -349,7 +379,7 @@ public struct Parser {
}
static func Parse(
withName name: Identifier, node: Node, inTree tree: MutableTree,
withName name: Common.Identifier, node: Node, inTree tree: MutableTree,
withLexicalScopes scopes: LexicalScopes
) -> Result<(P4Lang.Parser, LexicalScopes)> {
guard
Sources/P4Parser/Program.swift
+1 -1
View File
@@ -60,7 +60,7 @@ public struct Program {
for parser_declaration in parser_qc {
switch Parser.Parse(
withName: Identifier(name: parser_declaration.nodes[0].text!),
withName: Common.Identifier(name: parser_declaration.nodes[0].text!),
node: parser_declaration.nodes[1], inTree: tree, withLexicalScopes: program_scope)
{
case Result.Ok((let parser, let new_program_scope)):
Sources/P4Parser/Statement.swift
+2 -2
View File
@@ -207,9 +207,9 @@ extension VariableDeclarationStatement: ParseableStatement {
return Result.Ok(
(
VariableDeclarationStatement(
identifier: Identifier(name: variable_name), withInitializer: rvalue),
identifier: Common.Identifier(name: variable_name), withInitializer: rvalue),
scopes.declare(
identifier: Identifier(name: variable_name), withValue: declaration_p4_type)
identifier: Common.Identifier(name: variable_name), withValue: declaration_p4_type)
))
} else {
Sources/P4Runtime/Parser.swift
+9 -9
View File
@@ -129,7 +129,7 @@ public struct ParserStateSelectTransition: ParserStateInstance {
}
extension ParserState: Compilable {
public typealias ToCompile = (ParserState, [String: ParserStateInstance])
public typealias ToCompile = (ParserState, [Identifier: ParserStateInstance])
public typealias Compiled = ParserStateInstance
public static func compile(_ parser: ToCompile) -> Result<Compiled> {
let (state, current) = parser
@@ -142,7 +142,7 @@ extension ParserState: Compilable {
{
return .Ok(
ParserStateDirectTransition(
currrent_state: state, next_state: current[transition_statement.next_state_name!]!))
currrent_state: state, next_state: current[transition_statement.next_state!]!))
}
if let transition_select_statement = state.transition,
@@ -153,9 +153,9 @@ extension ParserState: Compilable {
var states: [any ParserStateInstance] = Array()
for kse in transition_select_expression.keyset_expressions {
guard let next_state = current[kse.next_state_name] else {
guard let next_state = current[kse.next_state_identifier] else {
return .Error(
Error(withMessage: "Cannot find \(kse.next_state_name) as transition target"))
Error(withMessage: "Cannot find \(kse.next_state_identifier) as transition target"))
}
keys.append(kse.key)
states.append(next_state)
@@ -174,21 +174,21 @@ extension ParserStates: Compilable {
public typealias ToCompile = ParserStates
public typealias Compiled = ParserStateInstance
public static func compile(_ parser: ToCompile) -> Result<Compiled> {
var compiled_states = [String: ParserStateInstance]()
var compiled_states = [Identifier: ParserStateInstance]()
compiled_states["accept"] = ParserStateNoTransition(currrent_state: accept)
compiled_states["reject"] = ParserStateNoTransition(currrent_state: reject)
compiled_states[Identifier(name: "accept")] = ParserStateNoTransition(currrent_state: accept)
compiled_states[Identifier(name: "reject")] = ParserStateNoTransition(currrent_state: reject)
// TODO: We assume that states are in transition-order!
for state in parser.states {
switch ParserState.compile((state, compiled_states)) {
case .Ok(let compiled): compiled_states[state.state_name] = compiled
case .Ok(let compiled): compiled_states[state.state] = compiled
case .Error(let e): return .Error(e)
}
}
// Now, find the start state:
if let start_state = compiled_states["start"] {
if let start_state = compiled_states[Identifier(name: "start")] {
return .Ok(start_state)
} else {
return .Error(Error(withMessage: "No start state defined"))
Tests/p4rseTests/ParserTests.swift
+2 -2
View File
@@ -55,8 +55,8 @@ import TreeSitterP4
#expect(parser.states.count() == 1)
let state = try! #require(parser.states.find(withName: "start"))
#expect(state.state_name == "start")
let state = try! #require(parser.states.find(withIdentifier: Identifier(name: "start")))
#expect(state.state == Identifier(name: "start"))
#expect(state.statements.count == 1)
}