Runtime Work

Signed-off-by: Will Hawkins <hawkinsw@obs.cr>
2026-01-23 23:30:28 -05:00
parent f9ed3e7fbd
commit d6d5cc8df7
10 changed files with 532 additions and 137 deletions
@@ -7,7 +7,6 @@ import TreeSitterP4

 extension MutableTree {
    public func isError(lang: Language) -> Bool {
-        // TODO: Make a function.
        guard
            let parser_error_query = try? SwiftTreeSitter.Query(
                language: lang,
@@ -22,7 +21,6 @@ extension MutableTree {
        for _ in error_qr {
            return true
        }
-
        return false
    }
 }
@@ -30,40 +28,129 @@ extension MutableTree {
 let p4lang = Language(tree_sitter_p4())

 public protocol ParseableParserStatement {
-    static func Parse(node: Node, inTree tree: MutableTree) -> P4.ParserStatement?
+    static func Parse(node: Node, inTree tree: MutableTree) -> Result<P4.ParserStatement?>
 }

-extension P4.ExpressionStatement : ParseableParserStatement{
-    public static func Parse(node: Node, inTree tree: MutableTree) -> P4.ParserStatement? {
-        return P4.ExpressionStatement()
+extension P4.ExpressionStatement: ParseableParserStatement {
+    public static func Parse(node: Node, inTree tree: MutableTree) -> Result<P4.ParserStatement?> {
+        guard
+            let parser_state_query = try? SwiftTreeSitter.Query(
+                language: p4lang,
+                data: String(
+                    "(expressionStatement (expression) @expression)"
+                ).data(using: String.Encoding.utf8)!)
+        else {
+            return Result.Ok(.none)
+        }
+
+        let qr = parser_state_query.execute(node: node, in: tree)
+        let query_result = qr.next()!
+        let expression_capture = query_result.captures(named: "expression")
+        if !expression_capture.isEmpty {
+            // TODO: Actually create an ExpressionStatement
+            return Result.Ok(P4.ExpressionStatement())
+        }
+
+        return Result.Ok(.none)
+
+    }
+}
+
+extension P4.VariableDeclarationStatement: ParseableParserStatement {
+    public static func Parse(node: Node, inTree tree: MutableTree) -> Result<P4.ParserStatement?> {
+        guard
+            let parser_state_query = try? SwiftTreeSitter.Query(
+                language: p4lang,
+                data: String(
+                    "((annotations)? (typeRef) @type-name variable_name: (identifier) @identifier)"
+                ).data(using: String.Encoding.utf8)!)
+        else {
+            return Result.Ok(.none)
+        }
+
+        let qr = parser_state_query.execute(node: node, in: tree)
+        let parser_declaration = qr.next()!
+
+        let type_name_capture = parser_declaration.captures(named: "type-name")
+        let variable_name_capture = parser_declaration.captures(named: "identifier")
+
+        // There must be a state name and there must be a transition statement.
+        guard !type_name_capture.isEmpty,
+            !variable_name_capture.isEmpty,
+            let variable_name = variable_name_capture[0].node.text
+        else {
+            return Result.Error(Error(withMessage: "Could not parse a parser declaration"))
+        }
+
+        return Result.Ok(
+            // TODO: Add support for parsing the value.
+            P4.VariableDeclarationStatement(
+                withIdentifier: Identifier(
+                    name: variable_name, withValue: Value(withValue: ValueType.Boolean(true)))))
    }
 }

 public struct Parser {
-    static func ParserStatements(capture: [QueryCapture], inTree tree: MutableTree) -> [P4.ParserStatement]? {
-        var statements: [P4.ParserStatement] = Array()
+    static func ParserLocalElements(capture: [QueryCapture], inTree tree: MutableTree) -> Result<
+        [P4.ParserStatement]
+    > {
+        let localElementsParsers: [ParseableParserStatement.Type] = [
+            P4.VariableDeclarationStatement.self
+        ]

-        let statementParsers = [P4.ExpressionStatement.self]
+        var localElements: [P4.ParserStatement] = Array()

-        for raw_statement in capture {
-                var parsed_statement: Optional<P4.ParserStatement> = .none
+        for raw_le_statement in capture {
+            var parsed_le_statement: P4.ParserStatement? = .none

-                // Iterate through statement parsers and give each one a chance.
-                for parser in statementParsers {
-                    if let parsed = parser.Parse(node: raw_statement.node, inTree: tree) {
-                        parsed_statement = parsed
-                    }
+            for le_parser in localElementsParsers {
+                if case Result.Ok(.some(let parsed)) = le_parser.Parse(node: raw_le_statement.node, inTree: tree) {
+                    parsed_le_statement = parsed
+                    break
                }
+            }

-                if let statement = parsed_statement {
-                    statements.append(statement)
-                }  else {
-                    // There were no parseable statements.
-                    return nil
-                }
+            if let le_statement = parsed_le_statement {
+                localElements.append(le_statement)
+            } else {
+                // There were no parseable statements.
+                return Result.Error(
+                    Error(withMessage: "Failed to parse a local element: \(raw_le_statement)"))
+            }
        }

-        return statements
+        return Result.Ok(localElements)
+    }
+
+    static func ParserStatements(capture: [QueryCapture], inTree tree: MutableTree) -> Result<
+        [P4.ParserStatement]
+    > {
+        let statementParsers: [ParseableParserStatement.Type] = [
+            P4.ExpressionStatement.self, P4.VariableDeclarationStatement.self,
+        ]
+
+        var statements: [P4.ParserStatement] = Array()
+
+        for raw_statement in capture {
+            var parsed_statement: P4.ParserStatement? = .none
+
+            // Iterate through statement parsers and give each one a chance.
+            for parser in statementParsers {
+                if case Result.Ok(.some(let parsed)) = parser.Parse(node: raw_statement.node, inTree: tree) {
+                    parsed_statement = parsed
+                    break
+                }
+            }
+
+            if let statement = parsed_statement {
+                statements.append(statement)
+            } else {
+                // There were no parseable statements.
+                return Result.Error(
+                    Error(withMessage: "Failed to parse a statement element: \(raw_statement)"))
+            }
+        }
+        return Result.Ok(statements)
    }

    static func ParserTransitionStatement(node: Node, inTree tree: MutableTree) -> P4
@@ -72,51 +159,67 @@ public struct Parser {
        return P4.ParserTransitionStatement()
    }

-    static func ParserState(node: Node, inTree tree: MutableTree) -> P4.ParserState? {
+    static func ParserState(node: Node, inTree tree: MutableTree) -> Result<P4.ParserState> {
        guard
            let parser_state_query = try? SwiftTreeSitter.Query(
                language: p4lang,
                data: String(
-                    "(parserState (state) (identifier) @state-name (parserStatements)? @state-statements (parserTransitionStatement) @transition)"
+                    "(parserState (state) (identifier) @state-name (parserLocalElements)? @state-local-elements (parserStatements)? @state-statements (parserTransitionStatement) @transition)"
                ).data(using: String.Encoding.utf8)!)
        else {
-            return nil
+            return Result.Error(Error(withMessage: "Could not compile the tree sitter query"))
        }

        let qr = parser_state_query.execute(node: node, in: tree)

-        // TODO: Assert that there is only one value here.
-        for parser_declaration in qr {
+        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-elements")
+        let statements_capture = parser_declaration.captures(named: "state-statements")

-            let transition_capture = parser_declaration.captures(
-                named: "transition")
-            let state_name_capture = parser_declaration.captures(named: "state-name")
-            let statements_capture = parser_declaration.captures(named: "state-statements")
-
-            guard !state_name_capture.isEmpty,
-                !transition_capture.isEmpty,
-                let parsed_state_name = state_name_capture[0].node.text,
-                let transition_statement = ParserTransitionStatement(
-                    node: transition_capture[0].node, inTree: tree)
-            else {
-                return nil
-            }
-
-            let parsed_statements = if !statements_capture.isEmpty {
-                ParserStatements(capture: statements_capture, inTree: tree)
-            } else {
-                Optional<[P4.ParserStatement]>.none
-            }
-
-            // TODO: Validate that there is only one!
-            return P4.ParserState(name: parsed_state_name, withStatements: parsed_statements, withTransition: transition_statement)
+        // There must be a state name and there must be a transition statement.
+        guard !state_name_capture.isEmpty,
+            !transition_capture.isEmpty,
+            let parsed_state_name = state_name_capture[0].node.text,
+            let transition_statement = ParserTransitionStatement(
+                node: transition_capture[0].node, inTree: tree)
+        else {
+            return Result.Error(Error(withMessage: "Could not parse a parser declaration"))
        }

-        return nil
+        let maybe_parsed_les =
+            if !state_le_capture.isEmpty {
+                ParserLocalElements(capture: state_le_capture, inTree: tree)
+            } else {
+                Result.Ok([P4.ParserStatement]())
+            }
+
+        guard case Result<[P4.ParserStatement]>.Ok(let parsed_les) = maybe_parsed_les else {
+            return Result.Error(maybe_parsed_les.error()!)
+        }
+
+        let maybe_parsed_statements =
+            if !statements_capture.isEmpty {
+                ParserStatements(capture: statements_capture, inTree: tree)
+            } else {
+                Result.Ok([P4.ParserStatement]())
+            }
+        guard case Result<[P4.ParserStatement]>.Ok(let parsed_statements) = maybe_parsed_statements
+        else {
+            return Result.Error(maybe_parsed_statements.error()!)
+        }
+
+        // TODO: Validate that there is only one!
+        return Result.Ok(
+            P4.ParserState(
+                name: parsed_state_name, withLocalElements: parsed_les,
+                withStatements: parsed_statements,
+                withTransition: transition_statement))
    }

-    static func Parser(node: Node, inTree tree: MutableTree) -> P4.Parser? {
+    static func Parser(node: Node, inTree tree: MutableTree) -> Result<P4.Parser> {
        guard
            let parser_state_query = try? SwiftTreeSitter.Query(
                language: p4lang,
@@ -124,42 +227,39 @@ public struct Parser {
                    "(parserStates) @parser-states"
                ).data(using: String.Encoding.utf8)!)
        else {
-            return nil
+            return Result.Error(
+                Error(withMessage: "Could not compile the parser state tree sitter query"))
        }

        var parser = P4.Parser()

-
        // Build a state from each one listed.
        for parser_states in parser_state_query.execute(node: node, in: tree) {
-            if let state = ParserState(node: parser_states.nodes[0], inTree: tree) {
-                parser.states.append(state)
+            switch ParserState(node: parser_states.nodes[0], inTree: tree) {
+            case Result.Ok(let state): parser.states.append(state)
+            case Result.Error(let error): return Result.Error(error)
            }
        }
-
-        return parser
+        return Result.Ok(parser)
    }

-    public static func Program(_ source: String) -> P4.Program? {
+    public static func Program(_ source: String) -> Result<P4.Program> {

        let p = SwiftTreeSitter.Parser.init()

        do {
            try p.setLanguage(p4lang)
        } catch {
-            return nil
+            return Result.Error(Error(withMessage: "Could not configure the P4 parser"))
        }

-        // Parse and check whether it is valid.
        let result = p.parse(source)
        guard let tree = result,
            !tree.isError(lang: p4lang)
        else {
-
-            return nil
+            return Result.Error(Error(withMessage: "Could not compile the P4 program"))
        }

-        // Query for the parser declarations.
        guard
            let parser_declaration_query = try? SwiftTreeSitter.Query(
                language: p4lang,
@@ -167,7 +267,8 @@ public struct Parser {
                    "(parserDeclaration (parserType) (parserStates) @parser-states)"
                ).data(using: String.Encoding.utf8)!)
        else {
-            return nil
+            return Result.Error(
+                Error(withMessage: "Could not compile the parser declaration tree sitter query"))
        }

        var program: P4.Program = P4.Program()
@@ -175,13 +276,12 @@ public struct Parser {
        let parser_qc = parser_declaration_query.execute(in: tree)

        for parser_declaration in parser_qc {
-            if let parser = Parser(
-                node: parser_declaration.nodes[0], inTree: tree)
-            {
-                program.parsers.append(parser)
+            switch Parser(node: parser_declaration.nodes[0], inTree: tree) {
+            case Result.Ok(let parser): program.parsers.append(parser)
+            case Result.Error(let error): return Result.Error(error)
            }
        }

-        return program
+        return Result.Ok(program)
    }
 }