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

Completely Refactor Execution

Browse Source 
Signed-off-by: Will Hawkins <hawkinsw@obs.cr>
This commit is contained in:
Will Hawkins
2026-03-06 21:40:19 -05:00
parent f96350f89d
commit eff19df968
15 changed files with 418 additions and 351 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Sources/P4Compiler/Expression.swift
+95 -1
View File
@@ -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)
)
}
}
Sources/P4Compiler/Parser.swift
+17 -127
View File
@@ -28,7 +28,7 @@ extension ParserAssignmentStatement: CompilableStatement {
) -> Result<(EvaluatableStatement, LexicalScopes)> {
#RequireNodeType<Node, (EvaluatableStatement, LexicalScopes)>(
node: node, type: "assignmentStatement", msg: "assignment statement")
node: node, type: "assignmentStatement", nice_type_name: "assignment statement")
guard let lvalue_node = node.child(at: 0),
lvalue_node.nodeType == "expression"
@@ -142,137 +142,26 @@ public struct Parser {
}
}
public struct TransitionSelectExpressionCaseStatement {
static func Compile(
node: Node, inTree tree: MutableTree, withLexicalScopes scopes: LexicalScopes
) -> 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: "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), scopes
))
}
}
public struct TransitionSelectExpression {
static func Compile(
node: Node, inTree tree: MutableTree, withScope scopes: LexicalScopes
) -> Result<(ParserTransitionSelectExpression, LexicalScopes)> {
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")
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.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()!)"
))
}
if body.isEmpty {
return .Error(Error(withMessage: "Could not find transition select expression body"))
}
let body_node = body[0].node
var kses: [KeysetExpression] = Array()
var kses_errors: [Error] = Array()
body_node.enumerateNamedChildren { current_node in
let maybe_parsed_kse = TransitionSelectExpressionCaseStatement.Compile(
node: current_node, inTree: tree, withLexicalScopes: scopes)
if case .Ok((let parsed_kse, _)) = maybe_parsed_kse {
kses.append(parsed_kse)
} 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(
(
ParserTransitionSelectExpression(withSelector: selector, withKeysetExpressions: kses),
scopes
))
}
}
public struct TransitionStatement {
static func Compile(
node: Node, inTree tree: MutableTree, withScope scopes: LexicalScopes
) -> Result<(ParserTransitionStatement, LexicalScopes)> {
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"))
#RequireNodeType<Node, (EvaluatableStatement, LexicalScopes)>(node: node, type: "parserTransitionStatement", nice_type_name: "parser transition statement")
guard let tse_node = node.child(at: 1),
tse_node.nodeType! == "transitionSelectionExpression" else {
return .Error(ErrorOnNode(node: node, withError: "Could not find transition select expression"))
}
let qr = next_state_query.execute(node: node, in: tree)
guard let next_node = tse_node.child(at: 0) else {
return .Error(ErrorOnNode(node: node, withError: "Could not find the next token in a transition selection expression"))
}
if let next_state_result = qr.next() {
let transition_capture = next_state_result.captures(named: "next-state")
// If the next node is an identifier, we have the simple form ...
if next_node.nodeType == "identifier" {
let maybe_parsed_next_state = Identifier.Compile(
node: transition_capture[0].node, inTree: tree, withScopes: scopes)
node: next_node, inTree: tree, withScopes: scopes)
if case .Ok(let next_state) = maybe_parsed_next_state {
return .Ok(
(ParserTransitionStatement(withNextState: next_state), scopes))
@@ -285,11 +174,12 @@ public struct Parser {
}
}
// We know that the next node is a select expression.
return
switch TransitionSelectExpression.Compile(node: node, inTree: tree, withScope: scopes)
switch SelectExpression.compile(node: next_node, inTree: tree, withScopes: scopes)
{
case .Ok((let tse, _)):
.Ok((ParserTransitionStatement(withTransitionExpression: tse), scopes))
case .Ok(let tse):
.Ok((ParserTransitionStatement(withTransitionExpression: tse! as! SelectExpression), scopes))
case .Error(let e): .Error(e)
}
}
Sources/P4Compiler/Statement.swift
+4 -20
View File
@@ -26,10 +26,7 @@ extension BlockStatement: CompilableStatement {
public static func Compile(
node: Node, inTree tree: MutableTree, withScopes scopes: LexicalScopes
) -> Result<(EvaluatableStatement, LexicalScopes)> {
if node.nodeType != "blockStatement" {
return Result.Error(
ErrorOnNode(node: node, withError: "Did not find expected block statement"))
}
#RequireNodeType<Node, (EvaluatableStatement, LexicalScopes)>(node: node, type: "blockStatement", nice_type_name: "block statement")
var currentChildIdx = 0
var currentChildIdxSafe = 1
@@ -94,12 +91,7 @@ extension ConditionalStatement: CompilableStatement {
node: Node, inTree tree: MutableTree, withScopes scopes: LexicalScopes
) -> Result<(EvaluatableStatement, LexicalScopes)> {
guard let node_type = node.nodeType,
node_type == "conditionalStatement"
else {
return Result.Error(
ErrorOnNode(node: node, withError: "Did not find expected conditional statement"))
}
#RequireNodeType<Node, (EvaluatableStatement, LexicalScopes)>(node: node, type: "conditionalStatement", nice_type_name: "conditional statement")
let maybe_condition_expression = node.child(at: 2)
guard let condition_expression = maybe_condition_expression,
@@ -166,12 +158,7 @@ extension VariableDeclarationStatement: CompilableStatement {
node: Node, inTree tree: MutableTree, withScopes scopes: LexicalScopes
) -> Result<(EvaluatableStatement, LexicalScopes)> {
guard let node_type = node.nodeType,
node_type == "variableDeclaration"
else {
return Result.Error(
ErrorOnNode(node: node, withError: "Did not find expected variable declaration statement"))
}
#RequireNodeType<Node, (EvaluatableStatement, LexicalScopes)>(node: node, type: "variableDeclaration", nice_type_name: "variable declaration statement")
let maybe_typeref = node.child(at: 0)
guard let typeref = maybe_typeref,
@@ -248,10 +235,7 @@ extension ExpressionStatement: CompilableStatement {
public static func Compile(
node: Node, inTree tree: MutableTree, withScopes scopes: LexicalScopes
) -> Result<(EvaluatableStatement, LexicalScopes)> {
if node.nodeType != "expressionStatement" {
return Result.Error(
ErrorOnNode(node: node, withError: "Did not find expected expression statement"))
}
#RequireNodeType<Node, (EvaluatableStatement, LexicalScopes)>(node: node, type: "expressionStatement", nice_type_name: "expression statement")
let _ = node.child(at: 0)