Refactor Library And Start Runtime

Signed-off-by: Will Hawkins <hawkinsw@obs.cr>

Sources/Parser/Parser.swift

@@ -0,0 +1,187 @@
+// The Swift Programming Language
+// https://docs.swift.org/swift-book
+
+import P4
+import SwiftTreeSitter
+import TreeSitterP4
+
+extension MutableTree {
+    public func isError(lang: Language) -> Bool {
+        // TODO: Make a function.
+        guard
+            let parser_error_query = try? SwiftTreeSitter.Query(
+                language: lang,
+                data: String(
+                    "(ERROR)"
+                ).data(using: String.Encoding.utf8)!)
+        else {
+            return false
+        }
+
+        let error_qr = parser_error_query.execute(in: self)
+        for _ in error_qr {
+            return true
+        }
+
+        return false
+    }
+}
+
+let p4lang = Language(tree_sitter_p4())
+
+public protocol ParseableParserStatement {
+    static func Parse(node: Node, inTree tree: MutableTree) -> P4.ParserStatement?
+}
+
+extension P4.ExpressionStatement : ParseableParserStatement{
+    public static func Parse(node: Node, inTree tree: MutableTree) -> P4.ParserStatement? {
+        return P4.ExpressionStatement()
+    }
+}
+
+public struct Parser {
+    static func ParserStatements(capture: [QueryCapture], inTree tree: MutableTree) -> [P4.ParserStatement]? {
+        var statements: [P4.ParserStatement] = Array()
+
+        let statementParsers = [P4.ExpressionStatement.self]
+
+        for raw_statement in capture {
+                var parsed_statement: Optional<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
+                    }
+                }
+
+                if let statement = parsed_statement {
+                    statements.append(statement)
+                }  else {
+                    // There were no parseable statements.
+                    return nil
+                }
+        }
+
+        return statements
+    }
+
+    static func ParserTransitionStatement(node: Node, inTree tree: MutableTree) -> P4
+        .ParserTransitionStatement?
+    {
+        return P4.ParserTransitionStatement()
+    }
+
+    static func ParserState(node: Node, inTree tree: MutableTree) -> P4.ParserState? {
+        guard
+            let parser_state_query = try? SwiftTreeSitter.Query(
+                language: p4lang,
+                data: String(
+                    "(parserState (state) (identifier) @state-name (parserStatements)? @state-statements (parserTransitionStatement) @transition)"
+                ).data(using: String.Encoding.utf8)!)
+        else {
+            return nil
+        }
+
+        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 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)
+        }
+
+        return nil
+    }
+
+    static func Parser(node: Node, inTree tree: MutableTree) -> P4.Parser? {
+        guard
+            let parser_state_query = try? SwiftTreeSitter.Query(
+                language: p4lang,
+                data: String(
+                    "(parserStates) @parser-states"
+                ).data(using: String.Encoding.utf8)!)
+        else {
+            return nil
+        }
+
+        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)
+            }
+        }
+
+        return parser
+    }
+
+    public static func Program(_ source: String) -> P4.Program? {
+
+        let p = SwiftTreeSitter.Parser.init()
+
+        do {
+            try p.setLanguage(p4lang)
+        } catch {
+            return nil
+        }
+
+        // Parse and check whether it is valid.
+        let result = p.parse(source)
+        guard let tree = result,
+            !tree.isError(lang: p4lang)
+        else {
+
+            return nil
+        }
+
+        // Query for the parser declarations.
+        guard
+            let parser_declaration_query = try? SwiftTreeSitter.Query(
+                language: p4lang,
+                data: String(
+                    "(parserDeclaration (parserType) (parserStates) @parser-states)"
+                ).data(using: String.Encoding.utf8)!)
+        else {
+            return nil
+        }
+
+        var program: P4.Program = P4.Program()
+
+        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)
+            }
+        }
+
+        return program
+    }
+}