Refactor Parsing -> Compiling
Signed-off-by: Will Hawkins <hawkinsw@obs.cr>
This commit is contained in:
Will Hawkins
@@ -1,206 +0,0 @@
|
||||
// p4rse, Copyright 2026, Will Hawkins
|
||||
//
|
||||
// This file is part of p4rse.
|
||||
//
|
||||
// This file is free software: you can redistribute it and/or modify
|
||||
// it under the terms of the GNU General Public License as published by
|
||||
// the Free Software Foundation, either version 3 of the License, or
|
||||
// (at your option) any later version.
|
||||
//
|
||||
// This program is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
// GNU General Public License for more details.
|
||||
//
|
||||
// You should have received a copy of the GNU General Public License
|
||||
// along with this program. If not, see <https://www.gnu.org/licenses/>.
|
||||
|
||||
import Common
|
||||
import P4Lang
|
||||
import SwiftTreeSitter
|
||||
import TreeSitterP4
|
||||
|
||||
protocol ParseableEvaluatableExpression {
|
||||
static func parse(
|
||||
node: Node, inTree tree: MutableTree, withScopes scopes: LexicalScopes
|
||||
) -> Result<EvaluatableExpression?>
|
||||
}
|
||||
|
||||
extension TypedIdentifier: ParseableEvaluatableExpression {
|
||||
static func parse(
|
||||
node: SwiftTreeSitter.Node, inTree tree: SwiftTreeSitter.MutableTree,
|
||||
withScopes scopes: LexicalScopes
|
||||
) -> Result<EvaluatableExpression?> {
|
||||
|
||||
guard
|
||||
let parser_statement_query = try? SwiftTreeSitter.Query(
|
||||
language: p4lang,
|
||||
data: String(
|
||||
"(expression (identifier) @identifier)"
|
||||
).data(using: String.Encoding.utf8)!)
|
||||
else {
|
||||
return Result.Error(Error(withMessage: "Could not compile the tree sitter query"))
|
||||
}
|
||||
|
||||
let qr = parser_statement_query.execute(node: node, in: tree)
|
||||
|
||||
guard let result = qr.next() else {
|
||||
return .Ok(.none)
|
||||
}
|
||||
|
||||
let value_capture = result.captures(named: "identifier")
|
||||
guard
|
||||
case Result.Ok(let type) = scopes.lookup(
|
||||
identifier: Common.Identifier(name: value_capture[0].node.text!))
|
||||
else {
|
||||
return .Error(Error(withMessage: "Cannot find \(result.captures[0].node.text!) in scope"))
|
||||
}
|
||||
|
||||
return .Ok(TypedIdentifier(name: result.captures[0].node.text!, withType: type))
|
||||
}
|
||||
}
|
||||
|
||||
extension P4BooleanValue: ParseableEvaluatableExpression {
|
||||
static func parse(
|
||||
node: SwiftTreeSitter.Node, inTree tree: SwiftTreeSitter.MutableTree,
|
||||
withScopes scopes: LexicalScopes
|
||||
) -> Result<EvaluatableExpression?> {
|
||||
|
||||
guard
|
||||
let true_query = try? SwiftTreeSitter.Query(
|
||||
language: p4lang,
|
||||
data: String(
|
||||
"(expression (true))"
|
||||
).data(using: String.Encoding.utf8)!)
|
||||
else {
|
||||
return Result.Error(Error(withMessage: "Could not compile the tree sitter query"))
|
||||
}
|
||||
|
||||
let true_qr = true_query.execute(node: node, in: tree)
|
||||
|
||||
if true_qr.next() != nil {
|
||||
return .Ok(P4BooleanValue(withValue: true))
|
||||
}
|
||||
|
||||
guard
|
||||
let false_query = try? SwiftTreeSitter.Query(
|
||||
language: p4lang,
|
||||
data: String(
|
||||
"(expression (false))"
|
||||
).data(using: String.Encoding.utf8)!)
|
||||
else {
|
||||
return Result.Error(Error(withMessage: "Could not compile the tree sitter query"))
|
||||
}
|
||||
|
||||
let false_qr = false_query.execute(node: node, in: tree)
|
||||
|
||||
if false_qr.next() != nil {
|
||||
return .Ok(P4BooleanValue(withValue: false))
|
||||
}
|
||||
return .Ok(.none)
|
||||
}
|
||||
}
|
||||
|
||||
extension P4IntValue: ParseableEvaluatableExpression {
|
||||
static func parse(
|
||||
node: SwiftTreeSitter.Node, inTree tree: SwiftTreeSitter.MutableTree,
|
||||
withScopes scopes: LexicalScopes
|
||||
) -> Result<EvaluatableExpression?> {
|
||||
|
||||
guard
|
||||
let integer_query = try? SwiftTreeSitter.Query(
|
||||
language: p4lang,
|
||||
data: String(
|
||||
"(expression (integer) @value)"
|
||||
).data(using: String.Encoding.utf8)!)
|
||||
else {
|
||||
return Result.Error(Error(withMessage: "Could not compile the tree sitter query"))
|
||||
}
|
||||
|
||||
let integer_qr = integer_query.execute(node: node, in: tree)
|
||||
|
||||
guard let result = integer_qr.next() else {
|
||||
return .Ok(.none)
|
||||
}
|
||||
|
||||
let value_capture = result.captures(named: "value")
|
||||
if let parsed_int = Int(value_capture[0].node.text!) {
|
||||
return .Ok(P4IntValue(withValue: parsed_int))
|
||||
} else {
|
||||
print("HERE!!")
|
||||
return .Error(Error(withMessage: "Failed to parse integer: \(result.captures[0].node.text!)"))
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
extension P4StringValue: ParseableEvaluatableExpression {
|
||||
static func parse(
|
||||
node: SwiftTreeSitter.Node, inTree tree: SwiftTreeSitter.MutableTree,
|
||||
withScopes scopes: LexicalScopes
|
||||
) -> Result<EvaluatableExpression?> {
|
||||
|
||||
guard
|
||||
let string_query = try? SwiftTreeSitter.Query(
|
||||
language: p4lang,
|
||||
data: String(
|
||||
"(expression (string_literal) @value)"
|
||||
).data(using: String.Encoding.utf8)!)
|
||||
else {
|
||||
return Result.Error(Error(withMessage: "Could not compile the tree sitter query"))
|
||||
}
|
||||
|
||||
let string_qr = string_query.execute(node: node, in: tree)
|
||||
|
||||
guard let result = string_qr.next() else {
|
||||
return .Ok(.none)
|
||||
}
|
||||
|
||||
return .Ok(P4StringValue(withValue: result.captures[0].node.text!))
|
||||
}
|
||||
}
|
||||
|
||||
struct Expression {
|
||||
public static func Parse(
|
||||
node: Node, inTree: MutableTree, withScopes scopes: LexicalScopes
|
||||
) -> Result<EvaluatableExpression> {
|
||||
let localElementsParsers: [ParseableEvaluatableExpression.Type] = [
|
||||
P4BooleanValue.self, P4StringValue.self, P4IntValue.self, TypedIdentifier.self,
|
||||
]
|
||||
|
||||
for le_parser in localElementsParsers {
|
||||
switch le_parser.parse(
|
||||
node: node, inTree: inTree, withScopes: scopes)
|
||||
{
|
||||
case .Ok(.some(let parsed)): return .Ok(parsed)
|
||||
case .Error(let e): return .Error(e)
|
||||
default: continue
|
||||
}
|
||||
}
|
||||
|
||||
return Result.Error(Error(withMessage: "\(node.range): 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)"))
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1,21 +0,0 @@
|
||||
// p4rse, Copyright 2026, Will Hawkins
|
||||
//
|
||||
// This file is part of p4rse.
|
||||
//
|
||||
// This file is free software: you can redistribute it and/or modify
|
||||
// it under the terms of the GNU General Public License as published by
|
||||
// the Free Software Foundation, either version 3 of the License, or
|
||||
// (at your option) any later version.
|
||||
//
|
||||
// This program is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
// GNU General Public License for more details.
|
||||
//
|
||||
// You should have received a copy of the GNU General Public License
|
||||
// along with this program. If not, see <https://www.gnu.org/licenses/>.
|
||||
|
||||
import Common
|
||||
|
||||
public typealias LexicalScope = Scope<P4Type>
|
||||
public typealias LexicalScopes = Scopes<P4Type>
|
||||
@@ -1,424 +0,0 @@
|
||||
// p4rse, Copyright 2026, Will Hawkins
|
||||
//
|
||||
// This file is part of p4rse.
|
||||
//
|
||||
// This file is free software: you can redistribute it and/or modify
|
||||
// it under the terms of the GNU General Public License as published by
|
||||
// the Free Software Foundation, either version 3 of the License, or
|
||||
// (at your option) any later version.
|
||||
//
|
||||
// This program is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
// GNU General Public License for more details.
|
||||
//
|
||||
// You should have received a copy of the GNU General Public License
|
||||
// along with this program. If not, see <https://www.gnu.org/licenses/>.
|
||||
|
||||
import Common
|
||||
import P4Lang
|
||||
import P4Runtime
|
||||
import SwiftTreeSitter
|
||||
import TreeSitterExtensions
|
||||
import TreeSitterP4
|
||||
|
||||
let p4lang = Language(tree_sitter_p4())
|
||||
|
||||
extension ParserAssignmentStatement: ParseableStatement {
|
||||
public static func Parse(
|
||||
node: Node, inTree tree: MutableTree, withScopes scopes: LexicalScopes
|
||||
) -> Result<(EvaluatableStatement?, LexicalScopes)> {
|
||||
|
||||
if node.nodeType != "assignmentStatement" {
|
||||
return Result.Ok((.none, scopes))
|
||||
}
|
||||
|
||||
guard let lvalue_node = node.child(at: 0),
|
||||
lvalue_node.nodeType == "expression"
|
||||
else {
|
||||
return Result.Error(Error(withMessage: "Missing lvalue in assignment statement"))
|
||||
}
|
||||
|
||||
guard let rvalue_node = node.child(at: 2),
|
||||
rvalue_node.nodeType == "expression"
|
||||
else {
|
||||
return Result.Error(Error(withMessage: "Missing lvalue in assignment statement"))
|
||||
}
|
||||
|
||||
let maybe_parsed_rvalue = Expression.Parse(node: rvalue_node, inTree: tree, withScopes: scopes)
|
||||
guard case Result.Ok(let rvalue) = maybe_parsed_rvalue else {
|
||||
return Result.Error(maybe_parsed_rvalue.error()!)
|
||||
}
|
||||
|
||||
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"))
|
||||
}
|
||||
|
||||
if rvalue.type().eq(rhs: lvalue_type) {
|
||||
return Result.Ok(
|
||||
(
|
||||
ParserAssignmentStatement(
|
||||
withLValue: TypedIdentifier(name: lvalue_node.text!, withType: lvalue_type),
|
||||
withValue: rvalue
|
||||
), scopes
|
||||
))
|
||||
|
||||
} else {
|
||||
return Result.Error(
|
||||
Error(
|
||||
withMessage:
|
||||
"Cannot assign value of type \(rvalue.type()) to \(lvalue_identifier) (with type \(lvalue_type))"
|
||||
))
|
||||
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
public struct Parser {
|
||||
public struct LocalElements {
|
||||
static func Parse(
|
||||
node: Node, inTree tree: MutableTree, withScope scopes: LexicalScopes
|
||||
) -> Result<(EvaluatableStatement, LexicalScopes)> {
|
||||
let localElementsParsers: [ParseableStatement.Type] = [
|
||||
VariableDeclarationStatement.self
|
||||
]
|
||||
|
||||
for local_element_parser in localElementsParsers {
|
||||
switch local_element_parser.Parse(node: node, inTree: tree, withScopes: scopes) {
|
||||
case Result.Ok((.some(let parsed), let parsed_updated_scopes)):
|
||||
return Result.Ok((parsed, parsed_updated_scopes))
|
||||
case Result.Error(let e):
|
||||
return Result.Error(Error(withMessage: "Failed to parse local element: \(e)"))
|
||||
default: continue
|
||||
}
|
||||
}
|
||||
|
||||
return Result.Error(
|
||||
Error(
|
||||
withMessage:
|
||||
"Failed to parse any local elements from specified local elements: \(node.text!)")
|
||||
)
|
||||
}
|
||||
}
|
||||
|
||||
public struct Statements {
|
||||
static func Parse(
|
||||
node: Node, inTree tree: MutableTree, withScope scopes: LexicalScopes
|
||||
) -> Result<(EvaluatableStatement, LexicalScopes)> {
|
||||
let statementParsers: [ParseableStatement.Type] = [
|
||||
ParserAssignmentStatement.self, ExpressionStatement.self,
|
||||
VariableDeclarationStatement.self, ConditionalStatement.self, BlockStatement.self,
|
||||
]
|
||||
|
||||
// Iterate through statement parsers and give each one a chance.
|
||||
for parser in statementParsers {
|
||||
switch parser.Parse(node: node, inTree: tree, withScopes: scopes) {
|
||||
case Result.Ok((.some(let parsed), let updatedLexicalScopes)):
|
||||
return .Ok((parsed, updatedLexicalScopes))
|
||||
case Result.Error(let e):
|
||||
return .Error(Error(withMessage: "Failed to parse a statement element: \(e)"))
|
||||
default: continue
|
||||
}
|
||||
}
|
||||
return Result.Error(
|
||||
Error(withMessage: "Failed to parse a statement element: \(node.text!)"))
|
||||
}
|
||||
}
|
||||
|
||||
public struct TransitionSelectExpressionCaseStatement {
|
||||
static func Parse(
|
||||
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.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<(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.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()
|
||||
var kses_errors: [Error] = Array()
|
||||
|
||||
body_node.enumerateNamedChildren { current_node in
|
||||
let maybe_parsed_kse = TransitionSelectExpressionCaseStatement.Parse(
|
||||
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 Parse(
|
||||
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"))
|
||||
}
|
||||
|
||||
let qr = next_state_query.execute(node: node, in: tree)
|
||||
|
||||
if let next_state_result = qr.next() {
|
||||
let transition_capture = next_state_result.captures(named: "next-state")
|
||||
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 switch TransitionSelectExpression.Parse(node: node, inTree: tree, withScope: scopes) {
|
||||
case .Ok((let tse, _)):
|
||||
.Ok((ParserTransitionStatement(withTransitionExpression: tse), scopes))
|
||||
case .Error(let e): .Error(e)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
public struct State {
|
||||
static func Parse(
|
||||
node: Node, inTree tree: MutableTree, withLexicalScopes scopes: LexicalScopes
|
||||
) -> Result<(ParserState, LexicalScopes)> {
|
||||
guard
|
||||
let parser_state_query = try? SwiftTreeSitter.Query(
|
||||
language: p4lang,
|
||||
data: String(
|
||||
"(parserState (state) (identifier) @state-name (parserLocalElements ((parserLocalElement) @state-local-element)*)? (parserStatements ((parserStatement) @state-statement)*)? (parserTransitionStatement) @transition)"
|
||||
).data(using: String.Encoding.utf8)!)
|
||||
else {
|
||||
return Result.Error(Error(withMessage: "Could not compile the tree sitter query"))
|
||||
}
|
||||
|
||||
let qr = parser_state_query.execute(node: node, in: tree)
|
||||
|
||||
let parser_declaration = qr.next()!
|
||||
|
||||
let transition_capture = parser_declaration.captures(named: "transition")
|
||||
let state_name_capture = parser_declaration.captures(named: "state-name")
|
||||
let state_le_capture = parser_declaration.captures(named: "state-local-element")
|
||||
let statements_capture = parser_declaration.captures(named: "state-statement")
|
||||
|
||||
var parsed_les: [EvaluatableStatement] = Array()
|
||||
var parse_err: Error? = .none
|
||||
var current_scopes = scopes.enter()
|
||||
|
||||
defer {
|
||||
current_scopes = current_scopes.exit()
|
||||
}
|
||||
|
||||
for state_le in state_le_capture {
|
||||
state_le.node.enumerateNamedChildren { node in
|
||||
switch LocalElements.Parse(
|
||||
node: node, inTree: tree, withScope: current_scopes)
|
||||
{
|
||||
case .Ok((let le, let le_parsed_scopes)):
|
||||
current_scopes = le_parsed_scopes
|
||||
parsed_les.append(le)
|
||||
case .Error(let e):
|
||||
parse_err = e
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if let parse_err = parse_err {
|
||||
return Result.Error(parse_err)
|
||||
}
|
||||
|
||||
var parsed_s: [EvaluatableStatement] = Array()
|
||||
|
||||
if !statements_capture.isEmpty {
|
||||
for statement in statements_capture {
|
||||
statement.node.enumerateNamedChildren { node in
|
||||
switch Statements.Parse(
|
||||
node: node, inTree: tree, withScope: current_scopes)
|
||||
{
|
||||
case .Ok((let le, let le_parsed_scopes)):
|
||||
current_scopes = le_parsed_scopes
|
||||
parsed_s.append(le)
|
||||
case .Error(let e):
|
||||
parse_err = e
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if let parse_err = parse_err {
|
||||
return Result.Error(parse_err)
|
||||
}
|
||||
|
||||
// TODO: Now that scopes are involved, doing this out of order will not work!
|
||||
guard !state_name_capture.isEmpty,
|
||||
!transition_capture.isEmpty,
|
||||
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"))
|
||||
}
|
||||
|
||||
switch TransitionStatement.Parse(
|
||||
node: transition_capture[0].node, inTree: tree, withScope: current_scopes)
|
||||
{
|
||||
case .Ok((.some(let transition_statement), let current_scopes)):
|
||||
return Result.Ok(
|
||||
(
|
||||
ParserState(
|
||||
name: parsed_state_name, withLocalElements: parsed_les,
|
||||
withStatements: parsed_s,
|
||||
withTransition: transition_statement), current_scopes
|
||||
))
|
||||
case .Error(let e): return .Error(e)
|
||||
case .Ok((.none, _)): return .Error(Error(withMessage: "Missing transition statement"))
|
||||
}
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
static func Parse(
|
||||
withName name: Common.Identifier, node: Node, inTree tree: MutableTree,
|
||||
withLexicalScopes scopes: LexicalScopes
|
||||
) -> Result<(P4Lang.Parser, LexicalScopes)> {
|
||||
guard
|
||||
let parser_state_query = try? SwiftTreeSitter.Query(
|
||||
language: p4lang,
|
||||
data: String(
|
||||
"(parserStates) @parser-states"
|
||||
).data(using: String.Encoding.utf8)!)
|
||||
else {
|
||||
return Result.Error(
|
||||
Error(withMessage: "Could not compile the parser state tree sitter query"))
|
||||
}
|
||||
|
||||
var parser = P4Lang.Parser(withName: name)
|
||||
|
||||
// Build a state from each one listed.
|
||||
let qr = parser_state_query.execute(node: node, in: tree)
|
||||
let qr_value = qr.next()!
|
||||
let captures = qr_value.captures(named: "parser-states")
|
||||
|
||||
var error: Error? = .none
|
||||
|
||||
var parser_scopes = scopes
|
||||
|
||||
// TODO: Assert that there is only one.
|
||||
captures[0].node.enumerateChildren { parser_state in
|
||||
switch Parser.State.Parse(node: parser_state, inTree: tree, withLexicalScopes: scopes) {
|
||||
case Result.Ok(let (state, new_parser_scopes)):
|
||||
parser.states = parser.states.append(state: state)
|
||||
parser_scopes = new_parser_scopes
|
||||
case Result.Error(let e): error = e
|
||||
}
|
||||
}
|
||||
|
||||
if let error = error {
|
||||
return .Error(error)
|
||||
}
|
||||
|
||||
return Result.Ok((parser, parser_scopes))
|
||||
}
|
||||
}
|
||||
@@ -1,75 +0,0 @@
|
||||
// p4rse, Copyright 2026, Will Hawkins
|
||||
//
|
||||
// This file is part of p4rse.
|
||||
//
|
||||
// This file is free software: you can redistribute it and/or modify
|
||||
// it under the terms of the GNU General Public License as published by
|
||||
// the Free Software Foundation, either version 3 of the License, or
|
||||
// (at your option) any later version.
|
||||
//
|
||||
// This program is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
// GNU General Public License for more details.
|
||||
//
|
||||
// You should have received a copy of the GNU General Public License
|
||||
// along with this program. If not, see <https://www.gnu.org/licenses/>.
|
||||
|
||||
import Common
|
||||
import P4Lang
|
||||
import P4Runtime
|
||||
import SwiftTreeSitter
|
||||
import TreeSitterExtensions
|
||||
import TreeSitterP4
|
||||
|
||||
public struct Program {
|
||||
public static func Parse(_ source: String) -> Result<P4Lang.Program> {
|
||||
let p = SwiftTreeSitter.Parser.init()
|
||||
|
||||
do {
|
||||
try p.setLanguage(p4lang)
|
||||
} catch {
|
||||
return Result.Error(Error(withMessage: "Could not configure the P4 parser"))
|
||||
}
|
||||
|
||||
let result = p.parse(source)
|
||||
guard let tree = result,
|
||||
!tree.isError(lang: p4lang),
|
||||
!tree.containsMissing(lang: p4lang)
|
||||
else {
|
||||
return Result.Error(Error(withMessage: "Could not compile the P4 program"))
|
||||
}
|
||||
|
||||
guard
|
||||
let parser_declaration_query = try? SwiftTreeSitter.Query(
|
||||
language: p4lang,
|
||||
data: String(
|
||||
"(parserDeclaration (parserType parser_name: (identifier) @parser-name) (parserStates) @parser-states)"
|
||||
).data(using: String.Encoding.utf8)!)
|
||||
else {
|
||||
return Result.Error(
|
||||
Error(withMessage: "Could not compile the parser declaration tree sitter query"))
|
||||
}
|
||||
|
||||
var program = P4Lang.Program()
|
||||
|
||||
// Set up a lexical scope for parsing.
|
||||
var program_scope = LexicalScopes().enter()
|
||||
|
||||
let parser_qc = parser_declaration_query.execute(in: tree)
|
||||
|
||||
for parser_declaration in parser_qc {
|
||||
switch Parser.Parse(
|
||||
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)):
|
||||
program.types.append(parser)
|
||||
program_scope = new_program_scope
|
||||
case Result.Error(let error): return Result.Error(error)
|
||||
}
|
||||
}
|
||||
|
||||
return Result.Ok(program)
|
||||
}
|
||||
}
|
||||
@@ -1,37 +0,0 @@
|
||||
// p4rse, Copyright 2026, Will Hawkins
|
||||
//
|
||||
// This file is part of p4rse.
|
||||
//
|
||||
// This file is free software: you can redistribute it and/or modify
|
||||
// it under the terms of the GNU General Public License as published by
|
||||
// the Free Software Foundation, either version 3 of the License, or
|
||||
// (at your option) any later version.
|
||||
//
|
||||
// This program is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
// GNU General Public License for more details.
|
||||
//
|
||||
// You should have received a copy of the GNU General Public License
|
||||
// along with this program. If not, see <https://www.gnu.org/licenses/>.
|
||||
|
||||
import Common
|
||||
import P4Lang
|
||||
import P4Runtime
|
||||
import SwiftTreeSitter
|
||||
import TreeSitterExtensions
|
||||
import TreeSitterP4
|
||||
|
||||
public protocol ParseableStatement {
|
||||
static func Parse(
|
||||
node: Node, inTree tree: MutableTree, withScopes scopes: LexicalScopes
|
||||
) -> Result<(EvaluatableStatement?, LexicalScopes)>
|
||||
}
|
||||
|
||||
public protocol ParseableValue {
|
||||
static func ParseValue(withValue value: String) -> Result<P4Value>
|
||||
}
|
||||
|
||||
public protocol ParseableType {
|
||||
static func ParseType(type: String) -> Result<P4Type?>
|
||||
}
|
||||
@@ -1,253 +0,0 @@
|
||||
// p4rse, Copyright 2026, Will Hawkins
|
||||
//
|
||||
// This file is part of p4rse.
|
||||
//
|
||||
// This file is free software: you can redistribute it and/or modify
|
||||
// it under the terms of the GNU General Public License as published by
|
||||
// the Free Software Foundation, either version 3 of the License, or
|
||||
// (at your option) any later version.
|
||||
//
|
||||
// This program is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
// GNU General Public License for more details.
|
||||
//
|
||||
// You should have received a copy of the GNU General Public License
|
||||
// along with this program. If not, see <https://www.gnu.org/licenses/>.
|
||||
|
||||
import Common
|
||||
import P4Lang
|
||||
import P4Runtime
|
||||
import SwiftTreeSitter
|
||||
import TreeSitterExtensions
|
||||
import TreeSitterP4
|
||||
|
||||
extension BlockStatement: ParseableStatement {
|
||||
public static func Parse(
|
||||
node: Node, inTree tree: MutableTree, withScopes scopes: LexicalScopes
|
||||
) -> Result<(EvaluatableStatement?, LexicalScopes)> {
|
||||
// TODO: Make sure that this works.
|
||||
// (And apply in other places!)
|
||||
guard
|
||||
let block_statement_query = try? SwiftTreeSitter.Query(
|
||||
language: p4lang,
|
||||
data: String(
|
||||
"(statement . (blockStatement . (statements . ((statement) @astatement)*) @statements) @block-statement) @statement"
|
||||
).data(using: String.Encoding.utf8)!)
|
||||
else {
|
||||
return Result.Ok((.none, scopes))
|
||||
}
|
||||
|
||||
let qr = block_statement_query.execute(node: node, in: tree)
|
||||
guard let variable_declaration = qr.next() else {
|
||||
return .Ok((.none, scopes))
|
||||
}
|
||||
|
||||
let statement_capture = variable_declaration.captures(named: "statement")
|
||||
let blockstatement_capture = variable_declaration.captures(named: "block-statement")
|
||||
let astatement_capture = variable_declaration.captures(named: "astatement")
|
||||
let statements_capture = variable_declaration.captures(named: "statements")
|
||||
|
||||
if statement_capture.isEmpty || blockstatement_capture.isEmpty {
|
||||
return .Error(Error(withMessage: "Could not parse a block statement"))
|
||||
}
|
||||
|
||||
let statement_node = statement_capture[0].node
|
||||
let blockstatement_capture_node = blockstatement_capture[0].node
|
||||
let statements_capture_node = statements_capture[0].node
|
||||
|
||||
/*
|
||||
if statement_node.parent != node.parent
|
||||
{
|
||||
return .Ok((.none, scopes))
|
||||
}
|
||||
*/
|
||||
var statements: [EvaluatableStatement] = Array()
|
||||
var parse_err: Error? = .none
|
||||
|
||||
for statement in astatement_capture {
|
||||
if let statement_node = statement.node.child(
|
||||
at: 0) /*
|
||||
let statement_node_parent = statement_node.parent,
|
||||
statement_node_parent.parent == statements_capture_node
|
||||
*/
|
||||
{
|
||||
switch P4Parser.Parser.Statements.Parse(
|
||||
node: statement_node, inTree: tree, withScope: scopes.enter())
|
||||
{
|
||||
case .Ok((let parsed_statement, _)): statements.append(parsed_statement)
|
||||
case .Error(let e):
|
||||
parse_err = e
|
||||
break
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if let err = parse_err {
|
||||
return .Error(err)
|
||||
}
|
||||
|
||||
return .Ok((BlockStatement(statements), scopes))
|
||||
}
|
||||
}
|
||||
|
||||
extension ConditionalStatement: ParseableStatement {
|
||||
public static func Parse(
|
||||
node: Node, inTree tree: MutableTree, withScopes scopes: LexicalScopes
|
||||
) -> Result<(EvaluatableStatement?, LexicalScopes)> {
|
||||
|
||||
guard let node_type = node.nodeType,
|
||||
node_type == "conditionalStatement"
|
||||
else {
|
||||
return Result.Ok((.none, scopes))
|
||||
}
|
||||
|
||||
let maybe_condition_expression = node.child(at: 2)
|
||||
guard let condition_expression = maybe_condition_expression,
|
||||
condition_expression.nodeType == "expression"
|
||||
else {
|
||||
return Result.Ok((.none, scopes))
|
||||
}
|
||||
|
||||
let maybe_thens = node.child(at: 4)
|
||||
guard let thens = maybe_thens,
|
||||
thens.nodeType == "statement"
|
||||
else {
|
||||
return Result.Ok((.none, scopes))
|
||||
}
|
||||
|
||||
guard
|
||||
case .Ok(let condition) = Expression.Parse(
|
||||
node: condition_expression, inTree: tree, withScopes: scopes.enter())
|
||||
else {
|
||||
return Result.Error(
|
||||
Error(withMessage: "Could not parse a conditional expression in a conditional statement"))
|
||||
}
|
||||
|
||||
guard
|
||||
case .Ok((let thenns, _)) = Parser.Statements.Parse(
|
||||
node: thens, inTree: tree, withScope: scopes.enter())
|
||||
else {
|
||||
return Result.Error(
|
||||
Error(
|
||||
withMessage:
|
||||
"Could not parse the then block in a conditional statement"))
|
||||
}
|
||||
|
||||
let optional_elss: Result<(any EvaluatableStatement, LexicalScopes)>? =
|
||||
if let elss = node.child(at: 6) {
|
||||
.some(
|
||||
Parser.Statements.Parse(
|
||||
node: elss, inTree: tree, withScope: scopes.enter()))
|
||||
} else {
|
||||
.none
|
||||
}
|
||||
|
||||
if let parsed_elss = optional_elss {
|
||||
guard
|
||||
case .Ok((let elss, _)) = parsed_elss
|
||||
else {
|
||||
return Result.Error(
|
||||
Error(
|
||||
withMessage:
|
||||
"Could not parse the else block in a conditional statement"))
|
||||
}
|
||||
return .Ok(
|
||||
(ConditionalStatement(condition: condition, withThen: thenns, andElse: elss), scopes))
|
||||
}
|
||||
return .Ok((ConditionalStatement(condition: condition, withThen: thenns), scopes))
|
||||
}
|
||||
}
|
||||
|
||||
extension VariableDeclarationStatement: ParseableStatement {
|
||||
public static func Parse(
|
||||
node: Node, inTree tree: MutableTree, withScopes scopes: LexicalScopes
|
||||
) -> Result<(EvaluatableStatement?, LexicalScopes)> {
|
||||
guard
|
||||
let variable_declaration_query = try? SwiftTreeSitter.Query(
|
||||
language: p4lang,
|
||||
data: String(
|
||||
"(variableDeclaration (annotations)? (typeRef) @type-name variable_name: (identifier) @identifier ((assignment) (expression) @value)?)"
|
||||
).data(using: String.Encoding.utf8)!)
|
||||
else {
|
||||
return Result.Ok((.none, scopes))
|
||||
}
|
||||
|
||||
let qr = variable_declaration_query.execute(node: node, in: tree)
|
||||
guard let variable_declaration = qr.next() else {
|
||||
return .Ok((.none, scopes))
|
||||
}
|
||||
|
||||
let type_name_capture = variable_declaration.captures(named: "type-name")
|
||||
let variable_name_capture = variable_declaration.captures(named: "identifier")
|
||||
let value_capture = variable_declaration.captures(named: "value")
|
||||
|
||||
// There must be a type name and a variable name
|
||||
guard !type_name_capture.isEmpty,
|
||||
!variable_name_capture.isEmpty,
|
||||
!value_capture.isEmpty,
|
||||
let variable_name = variable_name_capture[0].node.text,
|
||||
let type_name = type_name_capture[0].node.text
|
||||
else {
|
||||
return Result.Error(
|
||||
Error(withMessage: "Could not parse a parser variable declaration statement"))
|
||||
}
|
||||
|
||||
guard case .Ok(let declaration_p4_type) = Types.ParseBasicType(type: type_name) else {
|
||||
return Result.Error(
|
||||
Error(withMessage: "Could not parse a P4 type from \(type_name)"))
|
||||
}
|
||||
|
||||
let rvalue_raw = value_capture[0].node
|
||||
let maybe_parsed_rvalue = Expression.Parse(node: rvalue_raw, inTree: tree, withScopes: scopes)
|
||||
guard case Result.Ok(let rvalue) = maybe_parsed_rvalue else {
|
||||
return Result.Error(maybe_parsed_rvalue.error()!)
|
||||
}
|
||||
|
||||
if rvalue.type().eq(rhs: declaration_p4_type) {
|
||||
return Result.Ok(
|
||||
(
|
||||
VariableDeclarationStatement(
|
||||
identifier: Common.Identifier(name: variable_name), withInitializer: rvalue),
|
||||
scopes.declare(
|
||||
identifier: Common.Identifier(name: variable_name), withValue: declaration_p4_type)
|
||||
))
|
||||
|
||||
} else {
|
||||
return Result.Error(
|
||||
Error(
|
||||
withMessage:
|
||||
"Cannot initialize \(variable_name) (with type \(declaration_p4_type)) from rvalue with type \(rvalue.type())"
|
||||
))
|
||||
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
extension ExpressionStatement: ParseableStatement {
|
||||
public static func Parse(
|
||||
node: Node, inTree tree: MutableTree, withScopes scopes: LexicalScopes
|
||||
) -> Result<(EvaluatableStatement?, LexicalScopes)> {
|
||||
guard
|
||||
let expression_statement_query = try? SwiftTreeSitter.Query(
|
||||
language: p4lang,
|
||||
data: String(
|
||||
"(expressionStatement (expression) @expression)"
|
||||
).data(using: String.Encoding.utf8)!)
|
||||
else {
|
||||
return Result.Ok((.none, scopes))
|
||||
}
|
||||
|
||||
let qr = expression_statement_query.execute(node: node, in: tree)
|
||||
guard let query_result = qr.next() else {
|
||||
return Result.Ok((.none, scopes))
|
||||
}
|
||||
|
||||
let expression_capture = query_result.captures(named: "expression")
|
||||
if !expression_capture.isEmpty {
|
||||
// TODO: Actually create an ExpressionStatement
|
||||
return Result.Ok((ExpressionStatement(), scopes))
|
||||
}
|
||||
return Result.Ok((.none, scopes))
|
||||
}
|
||||
}
|
||||
@@ -1,54 +0,0 @@
|
||||
// p4rse, Copyright 2026, Will Hawkins
|
||||
//
|
||||
// This file is part of p4rse.
|
||||
//
|
||||
// This file is free software: you can redistribute it and/or modify
|
||||
// it under the terms of the GNU General Public License as published by
|
||||
// the Free Software Foundation, either version 3 of the License, or
|
||||
// (at your option) any later version.
|
||||
//
|
||||
// This program is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
// GNU General Public License for more details.
|
||||
//
|
||||
// You should have received a copy of the GNU General Public License
|
||||
// along with this program. If not, see <https://www.gnu.org/licenses/>.
|
||||
|
||||
import Common
|
||||
import P4Lang
|
||||
import P4Runtime
|
||||
import SwiftTreeSitter
|
||||
import TreeSitterExtensions
|
||||
import TreeSitterP4
|
||||
|
||||
extension P4Boolean: ParseableType {
|
||||
public static func ParseType(type: String) -> Common.Result<(any Common.P4Type)?> {
|
||||
return type == "bool" ? .Ok(P4Boolean.create()) : .Ok(.none)
|
||||
}
|
||||
}
|
||||
|
||||
extension P4Int: ParseableType {
|
||||
public static func ParseType(type: String) -> Common.Result<(any Common.P4Type)?> {
|
||||
return type == "int" ? .Ok(P4Int.create()) : .Ok(.none)
|
||||
}
|
||||
}
|
||||
|
||||
extension P4String: ParseableType {
|
||||
public static func ParseType(type: String) -> Common.Result<(any Common.P4Type)?> {
|
||||
return type == "string" ? .Ok(P4String.create()) : .Ok(.none)
|
||||
}
|
||||
}
|
||||
public struct Types {
|
||||
static func ParseBasicType(type: String) -> Result<P4Type> {
|
||||
let type_parsers: [ParseableType.Type] = [P4Boolean.self, P4Int.self, P4String.self]
|
||||
for type_parser in type_parsers {
|
||||
switch type_parser.ParseType(type: type) {
|
||||
case .Ok(.some(let type)): return .Ok(type)
|
||||
case .Ok(.none): continue
|
||||
case .Error(let e): return .Error(e)
|
||||
}
|
||||
}
|
||||
return Result.Error(Error(withMessage: "Type name not recognized"))
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user