diff --git a/Package.resolved b/Package.resolved index 5c8c2bf..235c26b 100644 --- a/Package.resolved +++ b/Package.resolved @@ -1,5 +1,5 @@ { - "originHash" : "ef9c8ff40b986db3a591fe3c50d79e4fe2a9e11749d84a72fbe97babc9ba3683", + "originHash" : "87d6d60d6a77921d74305adbe82f77e088a6e06d44cb3db30aa4d25c864181fd", "pins" : [ { "identity" : "swift-argument-parser", @@ -15,8 +15,8 @@ "kind" : "remoteSourceControl", "location" : "https://github.com/apple/swift-docc-plugin", "state" : { - "revision" : "3e4f133a77e644a5812911a0513aeb7288b07d06", - "version" : "1.4.5" + "revision" : "647c708be89f834fa6a6d4945442793a77ddf5b6", + "version" : "1.5.0" } }, { @@ -52,7 +52,7 @@ "location" : "https://github.com/tree-sitter/swift-tree-sitter", "state" : { "branch" : "main", - "revision" : "769f4770fe8197e2f4ce810375e9b21398ae36d5" + "revision" : "f97df585296977d8fcaf644cbde567151d1367b8" } }, { diff --git a/Package.swift b/Package.swift index c319e07..1b5c79a 100644 --- a/Package.swift +++ b/Package.swift @@ -18,16 +18,8 @@ let package = Package( targets: ["Common"] ), .library( - name: "P4Lang", - targets: ["P4Lang"] - ), - .library( - name: "P4Runtime", - targets: ["P4Runtime"] - ), - .executable( - name: "p4ce", - targets: ["Cli"] + name: "P4CodeGen", + targets: ["P4CodeGen"] ), ], dependencies: [ @@ -37,6 +29,7 @@ let package = Package( .package(url: "https://github.com/swiftlang/swift-syntax", from: "602.0.0"), .package(url: "https://github.com/apple/swift-argument-parser", from: "1.0.0"), .package(url: "https://github.com/apple/swift-system", from: "1.6.1"), + //.package(url: "https://github.com/apple/swift-protobuf.git", from: "1.27.0"), ], targets: [ .macro( @@ -54,8 +47,6 @@ let package = Package( .product(name: "TreeSitterP4", package: "tree-sitter-p4"), .target(name: "TreeSitterExtensions"), .target(name: "Common"), - .target(name: "P4Lang"), - .target(name: "P4Runtime"), ], swiftSettings: [.enableExperimentalFeature("CodeItemMacros")], ), @@ -71,32 +62,25 @@ let package = Package( dependencies: [ "Macros", .product(name: "SystemPackage", package: "swift-system"), + .product(name: "SwiftTreeSitter", package: "swift-tree-sitter"), ], swiftSettings: [.enableExperimentalFeature("CodeItemMacros")], ), .target( - name: "P4Lang", - dependencies: ["Common"] - ), - .target( - name: "P4Runtime", - dependencies: ["P4Lang", "Common"] - ), - .executableTarget( - name: "Cli", + name: "P4CodeGen", dependencies: [ - "Common", "P4Lang", "P4Compiler", "P4Runtime", "Macros", - .product(name: "ArgumentParser", package: "swift-argument-parser"), - ], - swiftSettings: [.enableExperimentalFeature("CodeItemMacros")], + "P4Compiler", "Common", + //.product(name: "SwiftProtobuf", package: "swift-protobuf"), + ] ), .testTarget( name: "Tests", dependencies: [ - "P4Compiler", "P4Runtime", "P4Lang", "Macros", "TreeSitterExtensions", "Common", + "P4Compiler", "P4CodeGen", "Macros", "TreeSitterExtensions", "Common", .product(name: "SystemPackage", package: "swift-system"), ], + //swiftSettings: [.enableExperimentalFeature("CodeItemMacros"), .unsafeFlags(["-Xfrontend", "-dump-macro-expansions"])], swiftSettings: [.enableExperimentalFeature("CodeItemMacros")], ), ], diff --git a/Snippets/use-program-instanceswithtypes.swift b/Snippets/use-program-instanceswithtypes.swift index 02b6ba6..fb46fad 100644 --- a/Snippets/use-program-instanceswithtypes.swift +++ b/Snippets/use-program-instanceswithtypes.swift @@ -22,7 +22,6 @@ import SwiftTreeSitter import Testing import TreeSitter import TreeSitterP4 -import P4Lang import P4Compiler let p4_program_with_control_decl = """ @@ -37,7 +36,7 @@ let p4_program_with_control_decl = """ }; """ - +/* // snippet.include let flter = { (tipe: P4QualifiedType) -> Bool in switch tipe.baseType(){ @@ -48,3 +47,4 @@ let flter = { (tipe: P4QualifiedType) -> Bool in if case .Ok(let program) = SpecialCompilers.ProgramCompiler.Compile(p4_program_with_control_decl) { print(program.InstancesWithTypes(flter)) } +*/ \ No newline at end of file diff --git a/Snippets/use-program-typeswithtypes.swift b/Snippets/use-program-typeswithtypes.swift index 713c65b..31124cc 100644 --- a/Snippets/use-program-typeswithtypes.swift +++ b/Snippets/use-program-typeswithtypes.swift @@ -22,7 +22,6 @@ import SwiftTreeSitter import Testing import TreeSitter import TreeSitterP4 -import P4Lang import P4Compiler let p4_program_with_struct_decl = """ @@ -31,6 +30,7 @@ let p4_program_with_struct_decl = """ }; """ +/* // snippet.include let flter = { (tipe: P4Type) -> Bool in switch tipe { @@ -42,3 +42,4 @@ if case .Ok(let program) = SpecialCompilers.ProgramCompiler.Compile(p4_program_w print(program.TypesWithTypes(flter)) } +*/ \ No newline at end of file diff --git a/Sources/Cli/main.swift b/Sources/Cli/main.swift index d745283..4f01b7b 100644 --- a/Sources/Cli/main.swift +++ b/Sources/Cli/main.swift @@ -140,6 +140,7 @@ extension Cli { return } +/* let maybe_codegen = P4Runtime.CodeGenerator().codeGen(program) guard case .Ok(let codegen) = maybe_codegen else { let formatter = FormatterAnsi() @@ -148,6 +149,7 @@ extension Cli { } print("\(codegen.getGeneratedCode())") + */ } } } diff --git a/Sources/Common/Call.swift b/Sources/Common/Call.swift deleted file mode 100644 index 4eeb016..0000000 --- a/Sources/Common/Call.swift +++ /dev/null @@ -1,134 +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 . - -public struct Parameter: CustomStringConvertible, Equatable { - public static func == (lhs: Parameter, rhs: Parameter) -> Bool { - return lhs.name == rhs.name && lhs.type.eq(rhs.type) - } - - public var name: Identifier - public var type: P4QualifiedType - - public init( - identifier: Identifier, withType type: P4QualifiedType - ) { - self.name = identifier - self.type = type - } - - public var description: String { - return "Parameter: \(self.name) with type \(self.type)" - } - - /// Calculate whether the `argument` is compatible with this parameter. - public func compatible(_ argument: Argument) -> Bool { - let arg_type = argument.argument.type() - - // If the parameter is (in)out, then the argument must be an lvalue. - if let param_direction = self.type.direction(), - param_direction == Direction.In || param_direction == Direction.InOut - { - if !(argument.argument is P4LValueExpression) { - return false - } - } - return arg_type.baseType().eq(rhs: self.type.baseType()) - } - -} - -public struct ParameterList: CustomStringConvertible, Equatable { - public static func == (lhs: ParameterList, rhs: ParameterList) -> Bool { - if lhs.parameters.count != rhs.parameters.count { - return false - } - - return 0 - == zip(lhs.parameters, rhs.parameters).count { (lparam, rparam) in - return lparam != rparam - } - } - - public var parameters: [Parameter] - - public init() { - self.parameters = Array() - } - - public init(_ parameters: [Parameter]) { - self.parameters = parameters - } - - public func addParameter(_ parameter: Parameter) -> ParameterList { - return ParameterList(self.parameters + [parameter]) - } - - public var description: String { - let parameters = self.parameters.map { parameter in - parameter.description - }.joined(separator: ";") - return "Parameter list: \(parameters)" - } -} - -public struct ArgumentList { - public let arguments: [Argument] - - public init(_ arguments: [Argument] = []) { - self.arguments = arguments - } - - public func compatible(_ parameters: ParameterList) -> Result<()> { - if self.arguments.count != parameters.parameters.count { - return .Error( - Error( - withMessage: - "\(self.arguments.count) arguments found but \(parameters.parameters.count) required")) - } - - for (arg, param) in zip(self.arguments, parameters.parameters) { - let arg_index = arg.index - let arg_type = arg.argument.type() - if !param.compatible(arg) { - return .Error( - Error( - withMessage: - "Argument \(arg_index)'s type (\(arg_type)) is incompatible with the parameter type (\(param.type))" - )) - } - } - return .Ok(()) - } - - public func addArgument(_ argument: Argument) -> ArgumentList { - return ArgumentList(self.arguments + [argument]) - } - - public func count() -> Int { - return self.arguments.count - } -} - -public struct Argument { - public let index: Int - public let argument: P4Expression - - public init(_ argument: P4Expression, atIndex index: Int) { - self.argument = argument - self.index = index - } -} diff --git a/Sources/Common/Compiler.swift b/Sources/Common/Compiler.swift deleted file mode 100644 index a6bf391..0000000 --- a/Sources/Common/Compiler.swift +++ /dev/null @@ -1,203 +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 . - -/// A scope that resolves variable identifiers to their types. -public typealias VarTypeScope = Scope - -/// Scopes that resolve variable identifiers to their types. -public typealias VarTypeScopes = Scopes - -/// A scope that resolves type identifiers to their types. -public typealias TypeTypeScope = Scope - -/// Scopes that resolve type identifiers to their types. -public typealias TypeTypeScopes = Scopes - -/// Context for compilation -/// -/// It contains (at least) three important pieces of information: -/// 1. Instances: A ``VarTypeScopes`` that contains information about instantiated objects -/// (and their types) in scope -/// 1. Types: A ``TypeTypeScopes`` that contains information about declared types in scope. -/// 1. Expected Type: In certain situations, to typecheck an element of a P4 program requires -/// knowledge of an expected type. For instance, when compiling a return statement, the -/// compiler must know the return type of the function to type check. -public struct CompilerContext { - public let instances: StaticVarValueScopes - public let types: TypeTypeScopes - public let externs: TypeTypeScopes - public let ffis: [P4FFI] - public let expected_type: P4QualifiedType? - public let extern_context: Bool - public let lexical_context_name: Identifier? - public let lexical_context_statements: [P4Statement]? - - public init() { - instances = StaticVarValueScopes().enter() - types = TypeTypeScopes().enter() - externs = TypeTypeScopes().enter() - expected_type = .none - extern_context = false - ffis = Array() - lexical_context_name = .none - lexical_context_statements = .none - } - - public init(withInstances _instances: StaticVarValueScopes, withTypes _types: TypeTypeScopes) { - instances = _instances - types = _types - externs = TypeTypeScopes().enter() - expected_type = .none - extern_context = false - ffis = Array() - lexical_context_name = .none - lexical_context_statements = .none - } - - public init( - withInstances _instances: StaticVarValueScopes, withTypes _types: TypeTypeScopes, - withExpectation expectation: P4QualifiedType?, withExtern extern: Bool, - withExterns externs: TypeTypeScopes, withFFIs foreigns: [P4FFI], - withLexicalContextName lexical_context_name: Identifier?, - withLexicalContextStatements lexical_context_statements: [P4Statement]? - ) { - instances = _instances - types = _types - expected_type = expectation - extern_context = extern - self.externs = externs - ffis = foreigns - self.lexical_context_name = lexical_context_name - self.lexical_context_statements = lexical_context_statements - } - - /// Update a compiler context - /// - /// Create a new compiler context based on the current but new instances. - /// - /// - Parameter instances: a ``VarTypeScopes`` with the updated instances for the newly created compiler context. - /// - Returns: A new compiler context based on the current but new instances. - public func update(newInstances instances: StaticVarValueScopes) -> CompilerContext { - return CompilerContext( - withInstances: instances, withTypes: self.types, withExpectation: self.expected_type, - withExtern: self.extern_context, withExterns: self.externs, withFFIs: self.ffis, - withLexicalContextName: self.lexical_context_name, - withLexicalContextStatements: self.lexical_context_statements) - } - - /// Update a compiler context - /// - /// Create a new compiler context based on the current but new types. - /// - /// - Parameter types: a ``TypeTypeScopes`` with the updated types for the newly created compiler context. - /// - Returns: A new compiler context based on the current but new types. - public func update(newTypes types: TypeTypeScopes) -> CompilerContext { - return CompilerContext( - withInstances: self.instances, withTypes: types, withExpectation: self.expected_type, - withExtern: self.extern_context, withExterns: self.externs, withFFIs: self.ffis, - withLexicalContextName: self.lexical_context_name, - withLexicalContextStatements: self.lexical_context_statements) - } - - /// Update a compiler context - /// - /// Create a new compiler context based on the current but new expected type. - /// - /// - Parameter expectation: a ``P4Type?`` to (re)set the type the compiler is expecting. - /// - Returns: A new compiler context based on the current but new expected type. - public func update(newExpectation expectation: P4QualifiedType?) -> CompilerContext { - return CompilerContext( - withInstances: self.instances, withTypes: self.types, withExpectation: expectation, - withExtern: self.extern_context, withExterns: self.externs, withFFIs: self.ffis, - withLexicalContextName: self.lexical_context_name, - withLexicalContextStatements: self.lexical_context_statements) - } - - /// Update a compiler context - /// - /// Create a new compiler context based on the current but new extern context value. - /// - /// - Parameter extern: a ``Bool`` to (re)set whether the compiler is compiling in an extern context. - /// - Returns: A new compiler context based on the current but new extern context value. - public func update(newExtern extern: Bool) -> CompilerContext { - return CompilerContext( - withInstances: self.instances, withTypes: self.types, withExpectation: self.expected_type, - withExtern: extern, withExterns: self.externs, withFFIs: self.ffis, - withLexicalContextName: self.lexical_context_name, - withLexicalContextStatements: self.lexical_context_statements) - } - - /// Update a compiler context - /// - /// Create a new compiler context based on the current but new externs. - /// - /// - Parameter externs: a ``TypeTypeScopes`` to (re)set the list of extern-al declarations. - /// - Returns: A new compiler context based on the current but new list of external-al declarations. - public func update(newExterns externs: TypeTypeScopes) -> CompilerContext { - return CompilerContext( - withInstances: self.instances, withTypes: self.types, withExpectation: self.expected_type, - withExtern: self.extern_context, withExterns: externs, withFFIs: self.ffis, - withLexicalContextName: self.lexical_context_name, - withLexicalContextStatements: self.lexical_context_statements) - } - - /// Update a compiler context - /// - /// Create a new compiler context based on the current but new FFIs. - /// - /// - Parameter foreigns: an array of ``P4FFI`` to (re)set the list of foreign functions. - /// - Returns: A new compiler context based on the current but with a new list of foreign functions. - public func update(newFFIs foreigns: [P4FFI]) -> CompilerContext { - return CompilerContext( - withInstances: self.instances, withTypes: self.types, withExpectation: self.expected_type, - withExtern: self.extern_context, withExterns: externs, withFFIs: foreigns, - withLexicalContextName: self.lexical_context_name, - withLexicalContextStatements: self.lexical_context_statements) - } - - /// Update a compiler context - /// - /// Create a new compiler context based on the current but with a new lexical context name. - /// - /// - Parameter new_lexical_context_name: an optional new lexical context name; passing `.none` resets. - /// - Returns: A new compiler context based on the current but with a new lexical context name. - public func update(newLexicalContextName new_lexical_context_name: Identifier?) -> CompilerContext - { - return CompilerContext( - withInstances: self.instances, withTypes: self.types, withExpectation: self.expected_type, - withExtern: self.extern_context, withExterns: externs, withFFIs: self.ffis, - withLexicalContextName: new_lexical_context_name, - withLexicalContextStatements: self.lexical_context_statements) - } - - /// Update a compiler context - /// - /// Create a new compiler context based on the current but with a new set of lexical context statements. - /// - /// - Parameter new_lexical_context_statements: an optional new set of lexical context statements; passing `.none` resets. - /// - Returns: A new compiler context based on the current but with a new set of lexical context statements. - public func update( - newLexicalContextStatements new_lexical_context_statements: [P4Statement]? - ) -> CompilerContext { - return CompilerContext( - withInstances: self.instances, withTypes: self.types, withExpectation: self.expected_type, - withExtern: self.extern_context, withExterns: externs, withFFIs: self.ffis, - withLexicalContextName: self.lexical_context_name, - withLexicalContextStatements: new_lexical_context_statements) - } - -} diff --git a/Sources/Common/Execution.swift b/Sources/Common/Execution.swift deleted file mode 100644 index a0bd827..0000000 --- a/Sources/Common/Execution.swift +++ /dev/null @@ -1,285 +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 . - -public typealias ExecuteStatementResultHandlerT = (ControlFlow, ProgramExecution) -> ( - ControlFlow, ProgramExecution -) - -public typealias ExecuteStatementT = (EvaluatableStatement, ProgramExecution) -> ( - ControlFlow, ProgramExecution -) - -func CanonicalExecuteStatements( - _ statements: [EvaluatableStatement], inExecution execution: ProgramExecution, - _ executor: ExecuteStatementT -) -> (ControlFlow, ProgramExecution) { - var execution = execution - for s in statements { - // Execute the statement with the user-provided statement executor. - switch executor(s, execution) { - // And decide what to do next! - case (ControlFlow.Next, let handled_next_execution): execution = handled_next_execution - case (ControlFlow.Return(let value), let handled_next_execution): - return (ControlFlow.Return(value), handled_next_execution) - case (let handled_control_flow, let handled_next_execution): - return (handled_control_flow, handled_next_execution) - } - } - return (ControlFlow.Next, execution) -} - -public struct ClassicEvaluator: ProgramExecutionEvaluator { - public func ExecuteStatements( - _ statements: [EvaluatableStatement], inExecution execution: ProgramExecution, - _ handler: ExecuteStatementResultHandlerT? - ) -> (ControlFlow, ProgramExecution) { - - return CanonicalExecuteStatements(statements, inExecution: execution) { statement, execution in - let (cf, value) = statement.evaluate(execution: execution) - // Apply the user-specified handler before continuing. - guard let handler = handler else { - return (cf, value) - } - return handler(cf, value) - } - } - - public func EvaluateExpression( - _ expression: EvaluatableExpression, inExecution execution: ProgramExecution, - ) -> (Result, ProgramExecution) { - return expression.evaluate(execution: execution) - } -} - -public struct InterloperEvaluator: ProgramExecutionEvaluator { - var statement_interloper: StatementInterloper? - var expression_interloper: ExpressionInterloper? - - public init() {} - - public func getStatementInterloper() -> StatementInterloper? { - return self.statement_interloper - } - - public func setStatementInterloper( - _ interloper: @escaping StatementInterloper - ) -> InterloperEvaluator { - var pe = self - pe.statement_interloper = interloper - return pe - } - - public func getExpressionInterloper() -> ExpressionInterloper? { - return self.expression_interloper - } - - public func setExpressionInterloper( - _ interloper: @escaping ExpressionInterloper - ) -> InterloperEvaluator { - var pe = self - pe.expression_interloper = interloper - return pe - } - - public func ExecuteStatements( - _ statements: [EvaluatableStatement], inExecution execution: ProgramExecution, - _ handler: ExecuteStatementResultHandlerT? - ) -> (ControlFlow, ProgramExecution) { - - var debugger: StatementInterloper? = .none - var hasDebugInterloper = false - if let found_deb = self.getStatementInterloper() { - debugger = found_deb - hasDebugInterloper = true - } - - return CanonicalExecuteStatements(statements, inExecution: execution) { statement, execution in - let (cf, value) = statement.evaluate(execution: execution) - - let (handled_cf, handled_value) = - if let handler = handler { - handler(cf, value) - } else { - (cf, value) - } - if hasDebugInterloper { - debugger!(statement, handled_cf, handled_value) - } - return (handled_cf, handled_value) - /* - let (handled_cf, handled_value) = - if let handler = handler { - handler(cf, value) - } else { - (cf, value) - } - - if hasDebugInterloper { - debugger!(statement, handled_cf, handled_value) - } - */ - } - } - - public func EvaluateExpression( - _ expression: EvaluatableExpression, inExecution execution: ProgramExecution, - ) -> (Result, ProgramExecution) { - - var debugger: ExpressionInterloper? = .none - var hasDebugInterloper = false - if let found_deb = self.getExpressionInterloper() { - debugger = found_deb - hasDebugInterloper = true - } - - let (result, execution) = expression.evaluate(execution: execution) - - if hasDebugInterloper { - debugger!(expression, result, execution) - } - - return (result, execution) - - } -} - -public typealias StatementInterloper = (EvaluatableStatement, ControlFlow, ProgramExecution) -> Void -public typealias ExpressionInterloper = (EvaluatableExpression, Result, ProgramExecution) - -> Void - -open class ProgramExecution: CustomStringConvertible { - public var scopes: VarValueScopes = VarValueScopes() - var globalValues: VarValueScopes? - var error: (any Errorable)? - var debug: DebugLevel = DebugLevel.Error - public let evaluator: ProgramExecutionEvaluator - - init(copy: ProgramExecution) { - self.scopes = copy.scopes - self.globalValues = copy.globalValues - self.error = copy.error - self.debug = copy.debug - self.evaluator = copy.evaluator - } - - public init() { - globalValues = .none - evaluator = ClassicEvaluator() - } - - public init(_ evaluator: ProgramExecutionEvaluator) { - globalValues = .none - self.evaluator = evaluator - } - - open var description: String { - return "Runtime:\nScopes: \(scopes)" - } - - public func hasError() -> Bool { - return self.error != nil - } - - public func getError() -> (any Errorable)? { - return self.error - } - - public func setError(error: any Errorable) -> ProgramExecution { - let npe = ProgramExecution(copy: self) - npe.error = error - return npe - } - - public func getDebugLevel() -> DebugLevel { - return self.debug - } - - public func setDebugLevel(_ dl: DebugLevel) -> ProgramExecution { - let pe = ProgramExecution(copy: self) - pe.debug = dl - return pe - } - - open func isDone() -> Bool { - return false - } - - open func setDone() -> ProgramExecution { - // For a bare ProgramExecution, setDone is a noop. - return self - } - - public func enter_scope() -> ProgramExecution { - let new_pe = ProgramExecution(copy: self) - new_pe.scopes = new_pe.scopes.enter() - - return new_pe - } - - public func exit_scope() -> ProgramExecution { - let new_pe = ProgramExecution(copy: self) - new_pe.scopes = new_pe.scopes.exit() - - return new_pe - } - - public func replaceScopes(_ new_scopes: VarValueScopes) -> ProgramExecution { - let new_pe = ProgramExecution(copy: self) - new_pe.scopes = new_scopes - return new_pe - } - - public func declare(identifier: Identifier, withValue value: P4Value) -> ProgramExecution { - let new_pe = ProgramExecution(copy: self) - let new_scopes = new_pe.scopes.declare(identifier: identifier, withValue: value) - - new_pe.scopes = new_scopes - return new_pe - } - - public func getGlobalValues() -> VarValueScopes { - return self.globalValues ?? VarValueScopes() - } - - public func setGlobalValues(_ global_values: VarValueScopes) -> ProgramExecution { - let new_pe = ProgramExecution(copy: self) - new_pe.globalValues = global_values - return new_pe - } - -} - -/// A scope that resolves variable identifiers to their values. -public typealias VarValueScope = Scope - -/// Scopes that resolves variable identifiers to their values. -public typealias VarValueScopes = Scopes - -/// A scope that resolves variable identifiers to their values. -public typealias StaticVarValueScope = Scope<(P4QualifiedType, P4Value?)> - -/// Scopes that resolves variable identifiers to their values. -public typealias StaticVarValueScopes = Scopes<(P4QualifiedType, P4Value?)> - -/// Indicate the control flow result of a particular statement. -public enum ControlFlow { - case Next - case Continue - case Break - case Return(P4Value?) - case Error -} diff --git a/Sources/Common/FFI.swift b/Sources/Common/FFI.swift deleted file mode 100644 index 02c0f11..0000000 --- a/Sources/Common/FFI.swift +++ /dev/null @@ -1,22 +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 . - -public protocol P4FFI { - func execute(execution: ProgramExecution) -> (ControlFlow, ProgramExecution) - func type() -> P4QualifiedType - func parameters() -> ParameterList -} diff --git a/Sources/Common/Protocols.swift b/Sources/Common/Protocols.swift index dec209e..99209f6 100644 --- a/Sources/Common/Protocols.swift +++ b/Sources/Common/Protocols.swift @@ -58,67 +58,13 @@ public protocol Formattable { } public protocol P4Statement { - /// Evaluate a statement for a given execution - /// - Parameters - /// - execution: The execution context in which to evaluate the parser statement - /// - Returns: A tuple of - /// 1. Whether this statement affects control flow. - /// 2. An updated execution after evaluating the parser statement - func evaluate(execution: ProgramExecution) -> (ControlFlow, ProgramExecution) - - func effect(context: CompilerContext) -> CompilerContext } public protocol P4Expression { - func effect(context: CompilerContext) -> CompilerContext - func type() -> P4QualifiedType - /// Evaluate an expression for a given execution - /// - Parameters - /// - execution: The execution context in which to evaluate the expression - /// - Returns: The value of expression - func evaluate(execution: ProgramExecution) -> (Result, ProgramExecution) } extension P4Expression { - func effect(context: CompilerContext) -> CompilerContext { - return context - } } -public protocol P4LValueExpression { - func effect(context: CompilerContext) -> CompilerContext - func type() -> P4QualifiedType - func check(to: P4Expression, inScopes scopes: StaticVarValueScopes) -> Result<()> - func set( - to: P4Value, inScopes scopes: VarValueScopes, duringExecution execution: ProgramExecution - ) -> Result<(VarValueScopes, P4Value)> - -} - -/// TODO: Only generate these after going through the codegen! -public typealias EvaluatableStatement = P4Statement -public typealias EvaluatableLValueExpression = P4LValueExpression -public typealias EvaluatableExpression = P4Expression - -public protocol ProgramExecutionEvaluator { - func ExecuteStatements( - _ statements: [EvaluatableStatement], inExecution execution: ProgramExecution, - _ handler: ExecuteStatementResultHandlerT? - ) -> (ControlFlow, ProgramExecution) - - func ExecuteStatements( - _ statements: [EvaluatableStatement], inExecution execution: ProgramExecution - ) -> (ControlFlow, ProgramExecution) - - func EvaluateExpression( - _ expression: EvaluatableExpression, inExecution execution: ProgramExecution, - ) -> (Result, ProgramExecution) -} - -extension ProgramExecutionEvaluator { - public func ExecuteStatements( - _ statements: [EvaluatableStatement], inExecution execution: ProgramExecution - ) -> (ControlFlow, ProgramExecution) { - return ExecuteStatements(statements, inExecution: execution, .none) - } +extension P4Expression { } diff --git a/Sources/Macros/Macros.swift b/Sources/Macros/Macros.swift index 0382fb6..b8a4ef3 100644 --- a/Sources/Macros/Macros.swift +++ b/Sources/Macros/Macros.swift @@ -448,8 +448,8 @@ public enum DeriveCompilableStatement: MemberMacro { let implementation = DeclSyntax( """ public static func CompileStatement( - node: Node, withContext context: CompilerContext - ) -> Result { + node: Node, withContext context: ASTCompilerContext + ) -> Result { return switch Compile(node: node, withContext: context) { case .Ok(let res): .Ok(res) case .Error(let e): .Error(e) diff --git a/Sources/P4CodeGen/Serializer.swift b/Sources/P4CodeGen/Serializer.swift new file mode 100644 index 0000000..ec82e7c --- /dev/null +++ b/Sources/P4CodeGen/Serializer.swift @@ -0,0 +1,95 @@ +// 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 . + +import Common +import P4Compiler + +public struct TextSerializer { + public init() {} +} + +public struct TextSerializerContext { + public let serialized: String + + public init(_ serialized: String = "") { + self.serialized = serialized + } + + public func append(_ a: String) -> TextSerializerContext { + return TextSerializerContext(self.serialized + a) + } +} + +extension TextSerializer: ASTVisitor { + public func visit( + node: P4Compiler.AST.BinaryOperatorExpression, driver: P4Compiler.ASTVisitorDriver, + context: TextSerializerContext + ) -> Common.Result { + return .Ok(context.append("Binary Operator Expression")) + + } + + public func visit( + node: P4Compiler.AST.Literal, driver: P4Compiler.ASTVisitorDriver, + context: TextSerializerContext + ) -> Common.Result { + return .Ok(context.append("Literal Expression")) + } + + public func visit( + node: P4Compiler.AST.Identifier, driver: P4Compiler.ASTVisitorDriver, + context: TextSerializerContext + ) -> Common.Result { + return .Ok(context.append("Identifier Expression")) + } + + public func visit( + node: P4Compiler.AST.Parser, driver: P4Compiler.ASTVisitorDriver, context: TextSerializerContext + ) -> Common.Result { + var context = context.append("Identifier Expression") + for s in node.states.states { + switch driver.visit(state: s, visitor: self, context: context) { + case .Ok(let c): context = c + case .Error(let e): return .Error(e) + } + } + + return .Ok(context) + } + + public func visit( + node: P4Compiler.AST.ParserStateDirectTransition, driver: P4Compiler.ASTVisitorDriver, + context: TextSerializerContext + ) -> Common.Result { + return .Ok(context.append("State: Direct Transition")) + } + + public func visit( + node: P4Compiler.AST.ParserStateNoTransition, driver: P4Compiler.ASTVisitorDriver, + context: TextSerializerContext + ) -> Common.Result { + return .Ok(context.append("State: No Transition")) + } + + public func visit( + node: P4Compiler.AST.ParserStateSelectTransition, driver: P4Compiler.ASTVisitorDriver, + context: TextSerializerContext + ) -> Common.Result { + return .Ok(context.append("State: Direct Transition")) + } + +} diff --git a/Sources/P4Compiler/AST.swift b/Sources/P4Compiler/AST.swift new file mode 100644 index 0000000..8b3f94f --- /dev/null +++ b/Sources/P4Compiler/AST.swift @@ -0,0 +1,665 @@ +// 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 . + +import Common + +extension P4Value: AST.AnExpression {} + +public struct AST { + + public protocol AnExpression {} + public protocol AnStatement {} + public protocol AnState {} + + public struct Statement {} + struct Expression {} + + public struct VariableDeclarationStatement: AnStatement { + public var initializer: AnExpression? + public var identifier: AST.Identifier + public var tipe: AST.Tipe + + public init( + identifier: Identifier, withType tipe: AST.Tipe, withInitializer initializer: AnExpression? + ) { + self.identifier = identifier + self.initializer = initializer + self.tipe = tipe + } + } + + public struct ConditionalStatement: AnStatement { + public var condition: AnExpression + public var thenn: AnStatement + public var elss: AnStatement? + + public init(condition: AnExpression, withThen thenn: AnStatement) { + self.condition = condition + self.thenn = thenn + self.elss = .none + } + + public init( + condition: AnExpression, withThen thenn: AnStatement, + andElse elss: AnStatement + ) { + self.condition = condition + self.thenn = thenn + self.elss = elss + } + } + + public struct BlockStatement: AnStatement { + public var statements: [AnStatement] + + public init(_ statements: [AnStatement]) { + self.statements = statements + } + + } + + public struct ReturnStatement: AnStatement { + public let value: AnExpression + + public init(_ value: AnExpression) { + self.value = value + } + } + + public struct ApplyStatement: AnStatement { + public let body: AST.BlockStatement? + + public init() { self.body = .none } + public init(_ body: AST.BlockStatement) { + self.body = body + } + } + + public struct Action: CustomStringConvertible { + public var description: String { + return "Action: " + + "\(self.name) with parameters \(self.params) and body \(String(describing: self.body))" + } + + public var body: AST.BlockStatement? + public var params: AST.ParameterList + public var name: AST.Identifier + + public init( + named name: AST.Identifier = AST.Identifier(Common.Identifier(name: "")), + withParameters parameters: ParameterList = ParameterList([]), + withBody body: AST.BlockStatement? = .none + ) { + self.name = name + self.params = parameters + self.body = body + } + + } + + public struct Actions: CustomStringConvertible { + public let actions: [AST.Action] + public init(withActions actions: [AST.Action]) { + self.actions = actions + } + + public var description: String { + return "Actions: " + + actions.map { action in + return "\(action)" + }.joined(separator: ";") + } + } + + public enum TableKeyMatchType { + case Exact + } + + public struct TableKeyEntry: CustomStringConvertible { + public let key: AST.KeysetExpression + public let match_type: AST.TableKeyMatchType + + public init(_ key: AST.KeysetExpression, _ match: AST.TableKeyMatchType) { + self.key = key + self.match_type = match + } + + public var description: String { + return "Table Key Entry: " + "\(self.key): \(self.match_type)" + } + } + + public struct TableKeys: CustomStringConvertible { + public let keys: [AST.TableKeyEntry] + + public init(withEntries entries: [AST.TableKeyEntry]) { + self.keys = entries + } + public init() { + self.keys = [] + } + + public var description: String { + return "Table Keys: " + + self.keys.map { key in + return "\(key)" + }.joined(separator: ";") + } + } + + public struct TableActionsProperty: CustomStringConvertible { + public let actions: [AST.Identifier] + public init(_ actions: [AST.Identifier] = []) { + self.actions = actions + } + + public var description: String { + return "Table Actions: " + + self.actions.map { action in + return "\(action)" + }.joined(separator: ";") + } + } + + public struct TablePropertyList: CustomStringConvertible { + public let actions: AST.TableActionsProperty + public let keys: AST.TableKeys + public init(withActions actions: AST.TableActionsProperty, withKeys keys: AST.TableKeys) { + self.actions = actions + self.keys = keys + } + + public var description: String { + return "Table Property List: \(self.actions) \(self.keys)" + } + } + + public struct Table: CustomStringConvertible { + public let properties: AST.TablePropertyList + let name: AST.Identifier + public let entries: [(P4Value, AST.Identifier)] + + public init( + withName name: AST.Identifier, withPropertyList property_list: AST.TablePropertyList, + withEntries entries: [(P4Value, AST.Identifier)] = [] + ) { + self.name = name + self.properties = property_list + self.entries = entries + } + + public var description: String { + return "Table named: \(self.name) \(self.properties)" + } + + /// When the control is evaluated, the value of the x in the table is + /// compared to the entries and the match is assocated with an action + /// that is invoked when the match occurs! + + public func update(addEntry entry: (P4Value, AST.Identifier)) -> Table { + return Table( + withName: self.name, withPropertyList: self.properties, withEntries: self.entries + [entry]) + } + } + + public protocol AnDeclaration: AnStatement {} + + public struct Declaration {} + + public struct Control: CustomStringConvertible, AnDeclaration { + public var description: String { + return "Control named \(self._name) \(self.parameters) \(self.actions) \(self.table)" + } + + public let actions: AST.Actions + public let table: AST.Table + let _parameters: AST.ParameterList + let _name: AST.Identifier + let apply: AST.ApplyStatement + + public var parameters: AST.ParameterList { + _parameters + } + + public var name: AST.Identifier { + _name + } + + public init( + named: AST.Identifier, withParameters parameters: AST.ParameterList, + withTable table: AST.Table, + withActions actions: AST.Actions, withApply apply: AST.ApplyStatement + ) { + self._name = named + self._parameters = parameters + self.actions = actions + self.table = table + self.apply = apply + } + + public func updateTable(addEntry entry: (P4Value, AST.Identifier)) -> Control { + let table = self.table.update(addEntry: entry) + + return Control( + named: self.name, withParameters: self.parameters, withTable: table, + withActions: self.actions, withApply: self.apply) + } + + public func def() -> P4DataValue? { + return .none + } + + } + + public struct ExternDeclaration: AnDeclaration { + public let declaration: AST.AnDeclaration + + public init(_ declaration: AST.AnDeclaration) { + self.declaration = declaration + } + } + + public struct FunctionDeclaration: AnDeclaration { + public var description: String { + return "Function named \(self.name) that returns \(self.tipe) with parameters \(self.params)" + } + + public var body: AST.BlockStatement? + public var params: AST.ParameterList + public var name: AST.Identifier + public var tipe: AST.Tipe + + public init( + named name: AST.Identifier, ofType type: AST.Tipe, + withParameters parameters: AST.ParameterList, + withBody body: AST.BlockStatement? + ) { + self.name = name + self.tipe = type + self.params = parameters + self.body = body + } + } + + public struct StructDeclaration: AnDeclaration { + public let fields: [AST.VariableDeclarationStatement] + public let identifier: AST.Identifier + public init(_ id: AST.Identifier, _ fields: [AST.VariableDeclarationStatement]) { + self.identifier = id + self.fields = fields + } + } + + public struct Instantiation: AnStatement { + public let name: AST.Identifier + public var tipe: AST.Identifier + public let arguments: AST.ArgumentList + + public init(named name: AST.Identifier, withType tipe: AST.Identifier, withArguments arguments: AST.ArgumentList) { + self.name = name + self.arguments = arguments + self.tipe = tipe + } + } + + public struct ExpressionStatement: AnStatement { + public let expression: AnExpression + + public init(_ expr: AnExpression) { + self.expression = expr + } + } + + public struct Identifier: AnExpression { + public let id: Common.Identifier + public init(_ id: Common.Identifier) { + self.id = id + } + } + + public struct Literal: AnExpression { + public let literal: P4Value + public init(_ literal: P4Value) { + self.literal = literal + } + } + + public enum KeysetExpression: AnExpression { + case Default + case Value(AnExpression) + } + + public struct SelectCaseExpression: AnExpression { + public let key: AST.KeysetExpression + public let next_state_identifier: AST.Identifier + + public init(withKey key: AST.KeysetExpression, withNextState next_state_id: AST.Identifier) { + self.key = key + self.next_state_identifier = next_state_id + } + } + + public struct SelectExpression: AnExpression { + public let selector: AnExpression + public let case_expressions: [AST.SelectCaseExpression] + + public init( + withSelector selector: AnExpression, + withSelectCaseExpressions sces: [AST.SelectCaseExpression] + ) { + self.selector = selector + self.case_expressions = sces + } + + public func append_checked_sce(sce: AST.SelectCaseExpression) -> AST.SelectExpression { + var new_cses = self.case_expressions + new_cses.append(sce) + return SelectExpression( + withSelector: self.selector, withSelectCaseExpressions: new_cses) + } + } + + public enum BinaryOperatorExpressionType { + case Add + case Subtract + case Multiply + case Divide + case Lt + case Lte + case Gt + case Gte + case Eq + case And + case Or + } + + public struct BinaryOperatorExpression: AnExpression { + public let left: AnExpression + public let right: AnExpression + public let type: BinaryOperatorExpressionType + + public init( + withType tipe: BinaryOperatorExpressionType, + withLhs lhs: AnExpression, + withRhs rhs: AnExpression + ) { + self.type = tipe + self.left = lhs + self.right = rhs + } + } + + public struct ArrayAccessExpression: AnExpression { + public let indexor: AnExpression + public let name: AnExpression + + public init( + withName name: AnExpression, + withIndexor indexor: AnExpression + ) { + self.name = name + self.indexor = indexor + } + } + + public struct FieldAccessExpression: AnExpression { + public let field: Identifier + public let strct: AnExpression + + public init(withStruct strct: AnExpression, withField field: Identifier) { + self.strct = strct + self.field = field + } + } + + public struct FunctionCall: AnExpression { + public let callee: Identifier + public let arguments: ArgumentList + + public init(_ callee: Identifier, withArguments arguments: ArgumentList) { + self.callee = callee + self.arguments = arguments + } + } + + public struct LocalElements {} + + public struct LocalElement {} + + public struct ParserAssignmentStatement: AnStatement { + public let lvalue: AnExpression + public let value: AnExpression + + public init( + withLValue lvalue: AnExpression, withValue value: AnExpression + ) { + self.lvalue = lvalue + self.value = value + } + } + + /// A P4 Parser State + public class ParserState { + let name: Identifier + public let statements: [AnStatement] + + public var description: String { + return "Parser State named \(self.name)" + } + + public func getName() -> Identifier { + return self.name + } + + public func getStatements() -> [AnStatement] { + return self.statements + } + + /// Construct a ParserState + public init(_ name: Identifier, _ statements: [AnStatement] = Array()) { + self.name = name + self.statements = statements + } + } + + /// TransitionStatement + /// + /// Only defined to define Compilable extension. + public struct TransitionStatement {} + + public class ParserStateDirectTransition: ParserState, AnState { + public let next_state_identifier: Identifier? + + public init( + name: Identifier, withNextStateIdentifier next_state_id: Identifier, + withStatements stmts: [AnStatement] = Array(), + ) { + self.next_state_identifier = next_state_id + super.init(name, stmts) + } + } + + public class ParserStateNoTransition: ParserState, AnState { + /// Construct a ParserState + public init( + name: Identifier, withStatements stmts: [AnStatement] = Array(), + ) { + super.init(name, stmts) + } + } + + public class ParserStateSelectTransition: ParserState, AnState { + + public let te: SelectExpression + + public init( + name: Identifier, withTransitionExpression te: SelectExpression, + withStatements stmts: [AnStatement] = Array() + ) { + self.te = te + super.init(name, stmts) + } + } + + public struct ParserStates { + public var states: [AnState] = Array() + + public func count() -> Int { + return states.count + } + + public init(_ states: [AnState] = Array()) { + self.states = states + } + + public func append(state: AnState) -> ParserStates { + var new_states = self.states + new_states.append(state) + return ParserStates(new_states) + } + } + + /// A P4 Parser + /// + /// Note: A Parser is a type + public struct Parser: AnDeclaration { + public var states: ParserStates + + public var name: Identifier + public var parameters: ParameterList + + public init(withName name: Identifier) { + self.states = ParserStates() + self.parameters = ParameterList() + self.name = name + } + + public init(withName name: Identifier, withParameters parameters: ParameterList) { + self.states = ParserStates() + self.parameters = parameters + self.name = name + } + + public var description: String { + return "Parser \(self.name) with parameters: \(parameters) and states: \(self.states)" + } + } + + public struct Types {} + + public struct Tipe { + public let tipe: P4QualifiedType + public init(_ tipe: P4QualifiedType) { + self.tipe = tipe + } + } + + public struct Parameter: CustomStringConvertible { + public var name: AST.Identifier + public var type: AST.Tipe + + public init( + identifier: Identifier, withType type: AST.Tipe + ) { + self.name = identifier + self.type = type + } + + public var description: String { + return "Parameter: \(self.name) with type \(self.type)" + } + + } + + public struct ParameterList: CustomStringConvertible { + public var parameters: [AST.Parameter] + + public init() { + self.parameters = Array() + } + + public init(_ parameters: [AST.Parameter]) { + self.parameters = parameters + } + + public func addParameter(_ parameter: AST.Parameter) -> AST.ParameterList { + return AST.ParameterList(self.parameters + [parameter]) + } + + public var description: String { + let parameters = self.parameters.map { parameter in + parameter.description + }.joined(separator: ";") + return "Parameter list: \(parameters)" + } + } + + public struct ArgumentList { + public let arguments: [AST.Argument] + + public init(_ arguments: [AST.Argument] = []) { + self.arguments = arguments + } + + public func addArgument(_ argument: AST.Argument) -> AST.ArgumentList { + return ArgumentList(self.arguments + [argument]) + } + } + + public struct Argument { + public let index: Int + public let argument: AST.AnExpression + + public init(_ argument: AST.AnExpression, atIndex index: Int) { + self.argument = argument + self.index = index + } + } + + public struct Program { + public var statements: [AnStatement] + public init(_ stmts: [AnStatement] = Array()) { + self.statements = stmts + } + } +} + +public struct ASTCompilerContext { + public let lexical_context_name: AST.Identifier? + public let lexical_context_statements: [AST.AnStatement]? + public let extern_context: Bool + + public init(_ name: AST.Identifier? = .none, _ stmts: [AST.AnStatement]? = .none, _ extern: Bool = false) { + self.lexical_context_name = name + self.lexical_context_statements = stmts + self.extern_context = extern + } + + public func update(withContextName cn: AST.Identifier?) -> ASTCompilerContext { + return ASTCompilerContext(cn, self.lexical_context_statements, self.extern_context) + } + + public func update(withContextStatements stmts: [AST.AnStatement]?) -> ASTCompilerContext { + return ASTCompilerContext(self.lexical_context_name, stmts, self.extern_context) + } + + public func update(withExtern extern: Bool) -> ASTCompilerContext { + return ASTCompilerContext(self.lexical_context_name, self.lexical_context_statements, extern) + } +} + + diff --git a/Sources/P4Compiler/Common.swift b/Sources/P4Compiler/Common.swift index 0c2d2cb..b7df1f5 100644 --- a/Sources/P4Compiler/Common.swift +++ b/Sources/P4Compiler/Common.swift @@ -16,369 +16,10 @@ // along with this program. If not, see . import Common -import P4Lang -import P4Runtime import SwiftTreeSitter import TreeSitterExtensions import TreeSitterP4 -func parameter_list_compiler( - node: SwiftTreeSitter.Node, withContext context: CompilerContext -) -> Common.Result { - - var walker = Walker(node: node) - var current_node: Node? = .none - - if node.text == ")" { - // There are no parameters! - return Result.Ok(ParameterList([])) - } - - #RequireNodeType( - node: node, type: "parameter_list", nice_type_name: "Parameter List") - - var parameters: ParameterList = ParameterList([]) - - #MustOr( - result: current_node, thing: walker.getNext(), - or: Result.Error( - ErrorWithLocation( - sourceLocation: node.toSourceLocation(), withError: "Missing parameter list component"))) - - if current_node?.nodeType == "parameter_list" { - switch parameter_list_compiler(node: current_node!, withContext: context) { - case .Ok(let ps): - parameters = ps - case .Error(let e): return Result.Error(e) - } - walker.next() - } - - #MustOr( - result: current_node, thing: walker.getNext(), - or: Result.Error( - ErrorWithLocation( - sourceLocation: node.toSourceLocation(), withError: "Missing parameter list component"))) - - // If this is a ')', we are done. - if current_node?.text == ")" { - return Result.Ok(parameters) - } - - // If this is a comma, we skip it! - if current_node?.text == "," { - walker.next() - } - - #MustOr( - result: current_node, thing: walker.getNext(), - or: Result.Error( - ErrorWithLocation( - sourceLocation: node.toSourceLocation(), withError: "Missing parameter list component"))) - - // Otherwise, there should be one parameter left! - switch Parameter.Compile(node: current_node!, withContext: context) { - case .Ok(let parsed_parameter): - return Result.Ok(parameters.addParameter(parsed_parameter)) - case .Error(let e): return Result.Error(e) - } -} - -extension ParameterList: Compilable { - public typealias C = ParameterList - public static func Compile( - node: SwiftTreeSitter.Node, withContext context: CompilerContext - ) -> Common.Result { - - let parameter_node = node - #RequireNodeType( - node: parameter_node, type: "parameters", nice_type_name: "Parameters") - - var walker = Walker(node: parameter_node) - - var current_node: Node? = .none - - #MustOr( - result: current_node, thing: walker.getNext(), - or: Result.Error( - ErrorWithLocation( - sourceLocation: node.toSourceLocation(), - withError: "Missing '(' in parameter list component"))) - - walker.next() - #MustOr( - result: current_node, thing: walker.getNext(), - or: Result.Error( - ErrorWithLocation( - sourceLocation: node.toSourceLocation(), withError: "Missing parameter list component"))) - - return parameter_list_compiler(node: current_node!, withContext: context) - } -} - -extension Direction: Compilable { - public typealias C = Direction - public static func Compile( - node: Node, withContext context: CompilerContext - ) -> Result { - let direction_node = node - #RequireNodeType( - node: direction_node, type: "direction", nice_type_name: "direction") - let directions = [ - "in": Direction.In, - "out": Direction.Out, - "inout": Direction.InOut, - ] - - guard let parsed_direction = directions[direction_node.text!] else { - return .Error( - ErrorWithLocation( - sourceLocation: direction_node.toSourceLocation(), - withError: "\(direction_node.text!) is not a valid direction")) - } - - return .Ok(parsed_direction) - } -} - -extension Parameter: Compilable { - public typealias C = Parameter - public static func Compile( - node: Node, withContext context: CompilerContext - ) -> Result { - - #RequireNodeType( - node: node, type: "parameter", nice_type_name: "parameter") - - var walker = Walker(node: node) - var current_node: Node? = .none - - #MustOr( - result: current_node, thing: walker.getNext(), - or: Result.Error( - ErrorWithLocation( - sourceLocation: node.toSourceLocation(), - withError: "Missing parameter declaration component"))) - - // Annotation? - if current_node!.nodeType == "annotations" { - return .Error( - ErrorWithLocation( - sourceLocation: current_node!.toSourceLocation(), - withError: "Annotations in parameter declarations are not yet handled")) - // Will increment indexes here. - } - - #MustOr( - result: current_node, thing: walker.getNext(), - or: Result.Error( - ErrorWithLocation( - sourceLocation: node.toSourceLocation(), - withError: "Missing parameter declaration component"))) - - var direction: Direction? = .none - // Direction? - if current_node!.nodeType == "direction" { - - let maybe_parsed_direction = Direction.Compile(node: current_node!, withContext: context) - guard case .Ok(let parsed_direction) = maybe_parsed_direction else { - return .Error(maybe_parsed_direction.error()!) - } - direction = parsed_direction - - walker.next() - } - - #MustOr( - result: current_node, thing: walker.getNext(), - or: Result.Error( - ErrorWithLocation( - sourceLocation: node.toSourceLocation(), - withError: "Missing parameter declaration component"))) - - if current_node!.nodeType != "typeRef" { - return Result.Error( - ErrorWithLocation( - sourceLocation: node.toSourceLocation(), - withError: "Did not find type name for parameter declaration")) - } - - guard - case .Ok(let parameter_type) = Types.CompileType(type: current_node!, withContext: context) - else { - return Result.Error( - Error(withMessage: "Could not parse a P4 type from \(current_node!.text!)")) - } - - walker.next() - #MustOr( - result: current_node, thing: walker.getNext(), - or: Result.Error( - ErrorWithLocation( - sourceLocation: node.toSourceLocation(), - withError: "Missing parameter declaration component"))) - - if current_node!.nodeType != "identifier" { - return Result.Error( - ErrorWithLocation( - sourceLocation: node.toSourceLocation(), - withError: "Did not find identifier for parameter statement")) - } - - guard - case .Ok(let parameter_name) = Identifier.Compile(node: current_node!, withContext: context) - else { - return Result.Error( - Error(withMessage: "Could not parse a parameter name from \(current_node!.text!)")) - } - - return Result.Ok( - Parameter( - identifier: parameter_name, - withType: direction != nil - ? parameter_type.update(addAttribute: P4TypeQualifier.Direction(direction!)) - : parameter_type), - ) - } -} - -func argument_list_compiler( - node: SwiftTreeSitter.Node, withContext context: CompilerContext -) -> Common.Result { - - var walker = Walker(node: node) - var current_node: Node? = .none - - if node.text == ")" { - // There are no arguments! - return Result.Ok(ArgumentList([])) - } - - #RequireNodeType( - node: node, type: "argument_list", nice_type_name: "argument List") - - var arguments: ArgumentList = ArgumentList([]) - - #MustOr( - result: current_node, thing: walker.getNext(), - or: Result.Error( - ErrorWithLocation( - sourceLocation: node.toSourceLocation(), withError: "Missing argument list component"))) - - if current_node?.nodeType == "argument_list" { - switch argument_list_compiler(node: current_node!, withContext: context) { - case .Ok(let ps): - arguments = ps - case .Error(let e): return Result.Error(e) - } - - walker.next() - } - - // We may have moved nodes, check/reset current_node. - #MustOr( - result: current_node, thing: walker.getNext(), - or: Result.Error( - ErrorWithLocation( - sourceLocation: node.toSourceLocation(), withError: "Missing argument list component"))) - - // If this is a ')', we are done. - if current_node?.text == ")" { - return Result.Ok(arguments) - } - - // If this is a comma, we skip it! - if current_node?.text == "," { - walker.next() - } - - #MustOr( - result: current_node, thing: walker.getNext(), - or: Result.Error( - ErrorWithLocation( - sourceLocation: node.toSourceLocation(), withError: "Missing argument list component"))) - - // Otherwise, there should be one argument left! - switch Argument.Compile(node: current_node!, withContext: context) { - case .Ok(let ce): - return Result.Ok( - arguments.addArgument(Argument(ce, atIndex: arguments.count() + 1))) - case .Error(let e): return Result.Error(e) - } -} - -extension ArgumentList: Compilable { - public typealias C = ArgumentList - public static func Compile( - node: SwiftTreeSitter.Node, withContext context: CompilerContext - ) -> Common.Result { - - let argument_node = node - #RequireNodeType( - node: argument_node, type: "arguments", nice_type_name: "arguments") - - var walker = Walker(node: argument_node) - var current_node: Node? = .none - - #MustOr( - result: current_node, thing: walker.getNext(), - or: Result.Error( - ErrorWithLocation( - sourceLocation: node.toSourceLocation(), - withError: "Missing '(' in argument list component"))) - - walker.next() - - #MustOr( - result: current_node, thing: walker.getNext(), - or: Result.Error( - ErrorWithLocation( - sourceLocation: node.toSourceLocation(), withError: "Missing argument list component"))) - - return argument_list_compiler(node: current_node!, withContext: context) - } -} - -extension Argument: Compilable { - public typealias C = P4Expression - public static func Compile( - node: SwiftTreeSitter.Node, withContext context: CompilerContext - ) -> Common.Result { - let argument_node = node - #RequireNodeType( - node: argument_node, type: "argument", nice_type_name: "argument") - - let expression_node = node.child(at: 0)! - - return switch Expression.Compile(node: expression_node, withContext: context) { - case .Ok(let compiled_expression): .Ok(compiled_expression) - case .Error(let e): .Error(e) - } - } -} - -func ContainsInvalidStatements( - statement: P4Statement, invalids: [P4Statement.Type] -) -> Bool { - for es in invalids { - if type(of: statement) == es { - return true - } - } - return false -} - -func ContainsInvalidStatements(block: BlockStatement, invalids: [P4Statement.Type]) -> Bool { - return block.statements.contains { statement in - for es in invalids { - if type(of: statement) == es { - return true - } - } - return false - } -} - extension Node { public func toSourceLocation() -> SourceLocation { return SourceLocation(self.range.location, self.range.length) diff --git a/Sources/P4Compiler/Compiler.swift b/Sources/P4Compiler/Compiler.swift index 6ce95d1..45b30cd 100644 --- a/Sources/P4Compiler/Compiler.swift +++ b/Sources/P4Compiler/Compiler.swift @@ -16,7 +16,6 @@ // along with this program. If not, see . import Common -import P4Runtime import SwiftTreeSitter import TreeSitterExtensions import TreeSitterP4 diff --git a/Sources/P4Compiler/Declarations.swift b/Sources/P4Compiler/Declarations.swift index 919c724..a81ee7c 100644 --- a/Sources/P4Compiler/Declarations.swift +++ b/Sources/P4Compiler/Declarations.swift @@ -16,28 +16,15 @@ // along with this program. If not, see . import Common -import P4Lang -import P4Runtime import SwiftTreeSitter import TreeSitterExtensions import TreeSitterP4 -extension Declaration: CompilableStatement { - public static func CompileStatement( - node: Node, withContext context: CompilerContext - ) -> Result { - return switch Compile(node: node, withContext: context) { - case .Ok(let res): .Ok(res) - case .Error(let e): .Error(e) - } - } -} - -extension Declaration: Compilable { - public typealias C = Declaration +extension AST.Declaration: Compilable { + public typealias C = AST.AnDeclaration public static func Compile( - node: Node, withContext context: CompilerContext - ) -> Result { + node: Node, withContext context: ASTCompilerContext + ) -> Result { // Be kind to our user -- if we are at a declaration node, dive into it! let declaration_node = @@ -47,13 +34,13 @@ extension Declaration: Compilable { node } - let declaration_compilers: [String: any Compilable.Type] = [ - "function_declaration": FunctionDeclaration.self, - "control_declaration": Control.self, - "type_declaration": P4Struct.self, - "parserDeclaration": Parser.self, + let declaration_compilers: [String: any Compilable.Type] = [ + "function_declaration": AST.FunctionDeclaration.self, + "control_declaration": AST.Control.self, + //"type_declaration": AST.P4Struct.self, + "parserDeclaration": AST.Parser.self, /// ASSUME: Type declarations are struct declarations. - "extern_declaration": ExternDeclaration.self, + "extern_declaration": AST.ExternDeclaration.self, ] guard let declaration_compiler = declaration_compilers[declaration_node.nodeType!] else { @@ -70,13 +57,16 @@ extension Declaration: Compilable { } } -extension FunctionDeclaration: Compilable { - public typealias C = Declaration +@deriveCompilableStatement +extension AST.Declaration: CompilableStatement {} + +extension AST.FunctionDeclaration: Compilable { + public typealias C = AST.AnDeclaration public static func Compile( - node: SwiftTreeSitter.Node, withContext context: CompilerContext - ) -> Common.Result { + node: SwiftTreeSitter.Node, withContext context: ASTCompilerContext + ) -> Common.Result { let function_declaration_node = node - #RequireNodeType( + #RequireNodeType( node: function_declaration_node, type: "function_declaration", nice_type_name: "Function Declaration") @@ -85,12 +75,12 @@ extension FunctionDeclaration: Compilable { #MustOr( result: current_node, thing: walker.getNext(), - or: Result.Error( + or: Result.Error( ErrorWithLocation( sourceLocation: function_declaration_node.toSourceLocation(), withError: "Missing function declaration component"))) - let maybe_function_type = Types.CompileType(type: current_node!, withContext: context) + let maybe_function_type = AST.Types.CompileType(type: current_node!, withContext: context) guard case .Ok(let function_type) = maybe_function_type else { return .Error(maybe_function_type.error()!) } @@ -98,12 +88,12 @@ extension FunctionDeclaration: Compilable { walker.next() #MustOr( result: current_node, thing: walker.getNext(), - or: Result.Error( + or: Result.Error( ErrorWithLocation( sourceLocation: function_declaration_node.toSourceLocation(), withError: "Missing function declaration component"))) - let maybe_function_name = Identifier.Compile(node: current_node!, withContext: context) + let maybe_function_name = AST.Identifier.CompileExpression(node: current_node!, withContext: context) guard case .Ok(let function_name) = maybe_function_name else { return .Error(maybe_function_name.error()!) } @@ -111,32 +101,23 @@ extension FunctionDeclaration: Compilable { walker.next() #MustOr( result: current_node, thing: walker.getNext(), - or: Result.Error( + or: Result.Error( ErrorWithLocation( sourceLocation: function_declaration_node.toSourceLocation(), withError: "Missing function declaration component"))) - let maybe_function_parameters = ParameterList.Compile(node: current_node!, withContext: context) + let maybe_function_parameters = AST.ParameterList.Compile( + node: current_node!, withContext: context) guard case .Ok(let function_parameters) = maybe_function_parameters else { return .Error(maybe_function_parameters.error()!) } - var function_body: BlockStatement? = .none + var function_body: AST.BlockStatement? = .none walker.next() if let body = walker.getNext() { - // Add the parameters into scope. - var function_scope = context.instances.enter() - for parameter in function_parameters.parameters { - function_scope = function_scope.declare( - identifier: parameter.name, withValue: (parameter.type, .none)) - } - - let maybe_function_body = BlockStatement.Compile( - node: body, - withContext: context.update(newInstances: function_scope).update( - newExpectation: function_type)) + let maybe_function_body = AST.BlockStatement.Compile(node: body, withContext: context) guard case .Ok(let parsed_function_body) = maybe_function_body else { return .Error(maybe_function_body.error()!) @@ -154,13 +135,10 @@ extension FunctionDeclaration: Compilable { } } - let function_declaration = Declaration( - TypedIdentifier( - id: function_name, - withType: P4QualifiedType( - FunctionDeclaration( - named: function_name, ofType: function_type, withParameters: function_parameters, - withBody: function_body)))) + let function_declaration = AST.FunctionDeclaration( + named: function_name as! AST.Identifier, ofType: function_type, + withParameters: function_parameters, + withBody: function_body) // Do not use the updated context returned by parsing the body // and do not use the function_scope, either. @@ -172,16 +150,16 @@ extension FunctionDeclaration: Compilable { } } -extension P4Struct: Compilable { - public typealias C = Declaration +extension AST.StructDeclaration: Compilable { + public typealias C = AST.StructDeclaration static public func Compile( - node: Node, withContext context: CompilerContext - ) -> Result { + node: Node, withContext context: ASTCompilerContext + ) -> Result { let struct_declaration_node = node.child(at: 0)! var walker = Walker(node: struct_declaration_node) var currentNode: Node? = .none - #RequireNodeType>( + #RequireNodeType>( node: struct_declaration_node, type: "struct_declaration", nice_type_name: "struct declaration") @@ -189,13 +167,13 @@ extension P4Struct: Compilable { walker.next() #MustOr( result: currentNode, thing: walker.getNext(), - or: Result.Error( + or: Result.Error( ErrorWithLocation( sourceLocation: struct_declaration_node.toSourceLocation(), withError: "Missing function declaration component"))) // The name of the struct type. - let maybe_struct_identifier = Identifier.Compile( + let maybe_struct_identifier = AST.Identifier.CompileExpression( node: currentNode!, withContext: context) guard case Result.Ok(let struct_identifier) = maybe_struct_identifier else { return Result.Error(maybe_struct_identifier.error()!) @@ -206,34 +184,27 @@ extension P4Struct: Compilable { walker.next() #MustOr( result: currentNode, thing: walker.getNext(), - or: Result.Error( + or: Result.Error( ErrorWithLocation( sourceLocation: struct_declaration_node.toSourceLocation(), withError: "Missing function declaration component"))) // If there are no fields, it will be a "}" if currentNode!.nodeType == "}" { - let struc = Declaration( - TypedIdentifier( - id: struct_identifier, - withType: P4QualifiedType( - P4Struct(withName: struct_identifier, andFields: P4StructFields([]))))) + let struc = AST.StructDeclaration(struct_identifier as! AST.Identifier, []) return Result.Ok(struc) } var parse_errs: (any Errorable)? = .none - var parsed_fields: [P4StructFieldIdentifier] = Array() + var parsed_fields: [AST.VariableDeclarationStatement] = Array() if currentNode!.nodeType == "struct_declaration_fields" { currentNode!.enumerateNamedChildren { declaration_field in - switch VariableDeclarationStatement.Compile( + switch AST.VariableDeclarationStatement.Compile( node: declaration_field, withContext: context) { case .Ok(let variable_declaration): - parsed_fields.append( - P4StructFieldIdentifier( - id: variable_declaration.identifier, withType: variable_declaration.initializer.type() - )) + parsed_fields.append(variable_declaration) case .Error(let e): parse_errs = if let e = parse_errs { @@ -249,33 +220,25 @@ extension P4Struct: Compilable { return .Error(ErrorWithLabel("Error(s) parsing select cases", parse_errs)) } - let declared_struct = Declaration( - TypedIdentifier( - id: struct_identifier, - withType: P4QualifiedType( - P4Struct( - withName: struct_identifier, andFields: P4StructFields(parsed_fields))))) + let declared_struct = AST.StructDeclaration(struct_identifier as! AST.Identifier, parsed_fields) return .Ok(declared_struct) } } -extension P4Lang.Parser: Compilable { - public typealias C = Declaration - +extension AST.Parser: Compilable { + public typealias C = AST.AnDeclaration public static func Compile( - node: Node, withContext context: CompilerContext - ) -> Result { + node: Node, withContext context: ASTCompilerContext + ) -> Result { let parser_node = node - #RequireNodeType>( + #RequireNodeType>( node: parser_node, type: "parserDeclaration", nice_type_name: "parser declaration") - var current_context = context - var walker = Walker(node: parser_node) var current_node: Node? = .none #MustOr( result: current_node, thing: walker.getNext(), - or: Result.Error( + or: Result.Error( ErrorWithLocation( sourceLocation: parser_node.toSourceLocation(), withError: "Missing elements of parser declaration"))) @@ -288,10 +251,10 @@ extension P4Lang.Parser: Compilable { } let type_node = current_node - var parser_name: Common.Identifier? = .none + var parser_name: AST.Identifier? = .none /// TODO: Handle parser parameter lists. - var parameter_list = ParameterList() + var parameter_list = AST.ParameterList() do { var type_node_walker = Walker(node: type_node!) @@ -299,7 +262,7 @@ extension P4Lang.Parser: Compilable { #MustOr( result: type_node_child, thing: type_node_walker.getNext(), - or: Result.Error( + or: Result.Error( ErrorWithLocation( sourceLocation: parser_node.toSourceLocation(), withError: "Missing elements of parser type in parser declaration"))) @@ -315,13 +278,13 @@ extension P4Lang.Parser: Compilable { type_node_walker.next() #MustOr( result: type_node_child, thing: type_node_walker.getNext(), - or: Result.Error( + or: Result.Error( ErrorWithLocation( sourceLocation: type_node_child!.toSourceLocation(), withError: "Missing name in parser type declaration"))) - switch Identifier.Compile(node: type_node_child!, withContext: current_context) { - case .Ok(let id): parser_name = id + switch AST.Identifier.CompileExpression(node: type_node_child!, withContext: context) { + case .Ok(let id): parser_name = (id as! AST.Identifier) case .Error(let e): return .Error(e) } @@ -329,12 +292,12 @@ extension P4Lang.Parser: Compilable { type_node_walker.next() #MustOr( result: type_node_child, thing: type_node_walker.getNext(), - or: Result.Error( + or: Result.Error( ErrorWithLocation( sourceLocation: type_node_child!.toSourceLocation(), withError: "Missing parser parameters"))) - switch ParameterList.Compile(node: type_node_child!, withContext: current_context) { + switch AST.ParameterList.Compile(node: type_node_child!, withContext: context) { case .Ok(let parsed_parameter_list): parameter_list = parsed_parameter_list case .Error(let e): @@ -342,17 +305,10 @@ extension P4Lang.Parser: Compilable { } } - // Now, let's put the parameters into scope. - for parameter in parameter_list.parameters { - current_context = current_context.update( - newInstances: current_context.instances.declare( - identifier: parameter.name, withValue: (parameter.type, .none))) - } - walker.next() #MustOr( result: current_node, thing: walker.getNext(), - or: Result.Error( + or: Result.Error( ErrorWithLocation( sourceLocation: parser_node.toSourceLocation(), withError: "Missing parser declaration component"))) @@ -360,7 +316,7 @@ extension P4Lang.Parser: Compilable { walker.next() #MustOr( result: current_node, thing: walker.getNext(), - or: Result.Error( + or: Result.Error( ErrorWithLocation( sourceLocation: parser_node.toSourceLocation(), withError: "Missing elements of parser declaration"))) @@ -375,7 +331,7 @@ extension P4Lang.Parser: Compilable { #MustOr( result: current_node, thing: walker.getNext(), - or: Result.Error( + or: Result.Error( ErrorWithLocation( sourceLocation: parser_node.toSourceLocation(), withError: "Missing body of parser declaration"))) @@ -387,45 +343,37 @@ extension P4Lang.Parser: Compilable { /// TODO: Handle extern parsers. switch SpecialCompilers.CompileParserBody( withName: parser_name!, withParameters: parameter_list, node: current_node!, - withContext: current_context) + withContext: context) { - case Result.Ok(let parser): - let parser_declaration = Declaration( - TypedIdentifier(id: parser.name, withType: P4QualifiedType(parser))) - // Create a new context with the name of the parser that was just compiled in scope. - return .Ok( - parser_declaration, - ) + case Result.Ok(let parser): return .Ok(parser) case Result.Error(let error): return .Error(error) } } } -extension Control: Compilable { - public typealias C = Declaration +extension AST.Control: Compilable { + public typealias C = AST.AnDeclaration public static func Compile( - node: SwiftTreeSitter.Node, withContext context: CompilerContext - ) -> Common.Result { + node: SwiftTreeSitter.Node, withContext context: ASTCompilerContext + ) -> Common.Result { - #RequireNodeType>( + #RequireNodeType>( node: node, type: "control_declaration", nice_type_name: "control declaration") var walker = Walker(node: node) var current_node: Node? = .none - var local_context = context - walker.next() #MustOr( result: current_node, thing: walker.getNext(), - or: Result.Error( + or: Result.Error( ErrorWithLocation( sourceLocation: node.toSourceLocation(), withError: "Missing control declaration component"))) guard - case .Ok(let control_name) = Identifier.Compile( - node: current_node!, withContext: local_context) + case .Ok(let control_name) = AST.Identifier.CompileExpression( + node: current_node!, withContext: context) else { return Result.Error( Error(withMessage: "Could not parse a parameter name from \(current_node!.text!)")) @@ -434,60 +382,48 @@ extension Control: Compilable { walker.next() #MustOr( result: current_node, thing: walker.getNext(), - or: Result.Error( + or: Result.Error( ErrorWithLocation( sourceLocation: node.toSourceLocation(), withError: "Missing control declaration component"))) - let maybe_control_parameters = ParameterList.Compile( - node: current_node!, withContext: local_context) + let maybe_control_parameters = AST.ParameterList.Compile( + node: current_node!, withContext: context) guard case .Ok(let control_parameters) = maybe_control_parameters else { return .Error(maybe_control_parameters.error()!) } - // Before continuing, make sure to put the parameters into context. - var control_scope = local_context.instances.enter() - for parameter in control_parameters.parameters { - control_scope = control_scope.declare( - identifier: parameter.name, withValue: (parameter.type, .none)) - } - local_context = local_context.update(newInstances: control_scope) - walker.next() // Skip the '{' walker.next() #MustOr( result: current_node, thing: walker.getNext(), - or: Result.Error( + or: Result.Error( ErrorWithLocation( sourceLocation: node.toSourceLocation(), withError: "Missing control declaration component"))) - var actions: [Action] = Array() - var tables: [Table] = Array() - var apply: ApplyStatement? = .none + var actions: [AST.Action] = Array() + var tables: [AST.Table] = Array() + var apply: AST.ApplyStatement? = .none // Because the final child // is the '}'. // \/\/ let body_parse_results = walker.overUntil(n: node.childCount - 1) { current_node in if current_node.nodeType == "action_declaration" { - let maybe_action_declaration = Action.Compile( - node: current_node, withContext: local_context) + let maybe_action_declaration = AST.Action.Compile( + node: current_node, withContext: context) guard case .Ok(let action_declaration) = maybe_action_declaration else { return .Error(maybe_action_declaration.error()!) } actions.append(action_declaration) - // Now, add the declaration into the context. - local_context = local_context.update( - newTypes: local_context.types.declare( - identifier: action_declaration.name, withValue: action_declaration)) } else if current_node.nodeType == "table_declaration" { - let maybe_table_declaration = Table.Compile( - node: current_node, withContext: local_context) + let maybe_table_declaration = AST.Table.Compile( + node: current_node, withContext: context) guard case .Ok(let table_declaration) = maybe_table_declaration else { @@ -496,8 +432,8 @@ extension Control: Compilable { tables.append(table_declaration) } else if current_node.nodeType == "apply_statement" { // When we see an apply, that is it for the actions and the tables. - let maybe_apply_statement = ApplyStatement.Compile( - node: current_node, withContext: local_context) + let maybe_apply_statement = AST.ApplyStatement.Compile( + node: current_node, withContext: context) guard case .Ok(let apply_statement) = maybe_apply_statement else { @@ -540,27 +476,17 @@ extension Control: Compilable { )) } - let control = Control( - named: control_name, withParameters: control_parameters, withTable: tables[0], - withActions: Actions(withActions: actions), withApply: apply) - - let declared_control = - Declaration( - TypedIdentifier( - id: control_name, - withType: P4QualifiedType(control))) - - // Don't forget to add the newly declared Control to the instance that we were given - // (and not the one that we entered to do the parsing of this Control). - return .Ok(declared_control) + return .Ok(AST.Control( + named: control_name as! AST.Identifier, withParameters: control_parameters, withTable: tables[0], + withActions: AST.Actions(withActions: actions), withApply: apply)) } } -extension Action: Compilable { - public typealias C = Action +extension AST.Action: Compilable { + public typealias C = AST.Action public static func Compile( - node: SwiftTreeSitter.Node, withContext context: CompilerContext - ) -> Result { + node: SwiftTreeSitter.Node, withContext context: ASTCompilerContext + ) -> Result { #RequireNodeType( node: node, type: "action_declaration", nice_type_name: "Action Declaration") @@ -572,14 +498,14 @@ extension Action: Compilable { #MustOr( result: current_node, thing: walker.getNext(), - or: Result.Error( + or: Result.Error( ErrorWithLocation( sourceLocation: node.toSourceLocation(), withError: "Missing action declaration component" )) ) guard - case .Ok(let action_name) = Identifier.Compile( + case .Ok(let action_name) = AST.Identifier.CompileExpression( node: current_node!, withContext: context) else { return Result.Error( @@ -589,13 +515,13 @@ extension Action: Compilable { walker.next() #MustOr( result: current_node, thing: walker.getNext(), - or: Result.Error( + or: Result.Error( ErrorWithLocation( sourceLocation: node.toSourceLocation(), withError: "Missing action declaration component" )) ) - let maybe_action_parameters = ParameterList.Compile( + let maybe_action_parameters = AST.ParameterList.Compile( node: current_node!, withContext: context) guard case .Ok(let action_parameters) = maybe_action_parameters else { @@ -604,9 +530,9 @@ extension Action: Compilable { // Check whether the parameters are in the proper order. let remaining_parameters = action_parameters.parameters.drop(while: { - $0.type.direction() != .none + $0.type.tipe.direction() != .none }) - if remaining_parameters.contains(where: { $0.type.direction() != .none }) { + if remaining_parameters.contains(where: { $0.type.tipe.direction() != .none }) { return .Error( ErrorWithLocation( sourceLocation: current_node!.toSourceLocation(), @@ -616,21 +542,14 @@ extension Action: Compilable { walker.next() #MustOr( result: current_node, thing: walker.getNext(), - or: Result.Error( + or: Result.Error( ErrorWithLocation( sourceLocation: node.toSourceLocation(), withError: "Missing action declaration component" )) ) - // Add the parameters into scope. - var function_scope = context.instances.enter() - for parameter in action_parameters.parameters { - function_scope = function_scope.declare( - identifier: parameter.name, withValue: (parameter.type, .none)) - } - - let maybe_action_body = BlockStatement.Compile( - node: current_node!, withContext: context.update(newInstances: function_scope)) + let maybe_action_body = AST.BlockStatement.Compile( + node: current_node!, withContext: context) guard case .Ok(let action_body) = maybe_action_body else { return .Error(maybe_action_body.error()!) } @@ -638,19 +557,19 @@ extension Action: Compilable { /// TODO: Actions cannot contain switches! return .Ok( - Action( - named: action_name, withParameters: action_parameters, + AST.Action( + named: action_name as! AST.Identifier, withParameters: action_parameters, withBody: action_body)) } } -extension TableKeyEntry: Compilable { - public typealias C = TableKeyEntry +extension AST.TableKeyEntry: Compilable { + public typealias C = AST.TableKeyEntry public static func Compile( - node: SwiftTreeSitter.Node, withContext context: CompilerContext - ) -> Result { + node: SwiftTreeSitter.Node, withContext context: ASTCompilerContext + ) -> Result { - #RequireNodeType( + #RequireNodeType( node: node, type: "table_key_entry", nice_type_name: "Table Key Entry") var walker = Walker(node: node) @@ -659,12 +578,12 @@ extension TableKeyEntry: Compilable { #MustOr( result: current_node, thing: walker.getNext(), - or: Result.Error( + or: Result.Error( ErrorWithLocation( sourceLocation: node.toSourceLocation(), withError: "Missing table key entry declaration component"))) - let maybe_keyset_expression = KeysetExpression.compile( + let maybe_keyset_expression = AST.KeysetExpression.CompileExpression( node: current_node!, withContext: context) guard case .Ok(let keyset_expression) = maybe_keyset_expression else { return Result.Error(maybe_keyset_expression.error()!) @@ -675,31 +594,31 @@ extension TableKeyEntry: Compilable { walker.next() #MustOr( result: current_node, thing: walker.getNext(), - or: Result.Error( + or: Result.Error( ErrorWithLocation( sourceLocation: node.toSourceLocation(), withError: "Missing table key entry declaration component"))) - let maybe_match_type = TableKeyMatchType.Compile( + let maybe_match_type = AST.TableKeyMatchType.Compile( node: current_node!, withContext: context) guard case .Ok(let match_type) = maybe_match_type else { return .Error(maybe_match_type.error()!) } - return .Ok(TableKeyEntry(keyset_expression as! KeysetExpression, match_type)) + return .Ok(AST.TableKeyEntry(keyset_expression as! AST.KeysetExpression, match_type)) } } -extension TableKeyMatchType: Compilable { - public typealias C = TableKeyMatchType +extension AST.TableKeyMatchType: Compilable { + public typealias C = AST.TableKeyMatchType public static func Compile( - node: SwiftTreeSitter.Node, withContext context: CompilerContext - ) -> Result { - #RequireNodeType( + node: SwiftTreeSitter.Node, withContext context: ASTCompilerContext + ) -> Result { + #RequireNodeType( node: node, type: "table_key_match_type", nice_type_name: "Table Key Match Type") if node.text! == "exact" { - return .Ok(TableKeyMatchType.Exact) + return .Ok(AST.TableKeyMatchType.Exact) } return .Error( ErrorWithLocation( @@ -708,12 +627,12 @@ extension TableKeyMatchType: Compilable { } } -extension TableKeys: Compilable { - public typealias C = TableKeys +extension AST.TableKeys: Compilable { + public typealias C = AST.TableKeys public static func Compile( - node: SwiftTreeSitter.Node, withContext context: CompilerContext - ) -> Result { - #RequireNodeType( + node: SwiftTreeSitter.Node, withContext context: ASTCompilerContext + ) -> Result { + #RequireNodeType( node: node, type: "table_keys", nice_type_name: "Table Keys") var walker = Walker(node: node) @@ -728,14 +647,14 @@ extension TableKeys: Compilable { #MustOr( result: current_node, thing: walker.getNext(), - or: Result.Error( + or: Result.Error( ErrorWithLocation( sourceLocation: node.toSourceLocation(), withError: "Missing table keys declaration component in control declaration")) ) let (keys, errors) = walker.try_map(n: node.childCount - 1, onlyNamed: true) { current_node in - return switch TableKeyEntry.Compile(node: current_node, withContext: context) { + return switch AST.TableKeyEntry.Compile(node: current_node, withContext: context) { case .Ok(let keyset_expression): .Ok(keyset_expression) case .Error(let e): .Error(e) } @@ -751,16 +670,16 @@ extension TableKeys: Compilable { }.joined(separator: ";")))) } - return .Ok(TableKeys(withEntries: keys)) + return .Ok(AST.TableKeys(withEntries: keys)) } } -extension TableActionsProperty: Compilable { - public typealias C = TableActionsProperty +extension AST.TableActionsProperty: Compilable { + public typealias C = AST.TableActionsProperty public static func Compile( - node: SwiftTreeSitter.Node, withContext context: CompilerContext - ) -> Result { - #RequireNodeType( + node: SwiftTreeSitter.Node, withContext context: ASTCompilerContext + ) -> Result { + #RequireNodeType( node: node, type: "table_actions", nice_type_name: "Table Actions") var walker = Walker(node: node) @@ -775,7 +694,7 @@ extension TableActionsProperty: Compilable { #MustOr( result: current_node, thing: walker.getNext(), - or: Result.Error( + or: Result.Error( ErrorWithLocation( sourceLocation: node.toSourceLocation(), withError: "Missing table actions declaration component in control declaration")) @@ -783,19 +702,9 @@ extension TableActionsProperty: Compilable { let (actions, errors) = walker.try_map(n: node.childCount - 1, onlyNamed: true) { current_node in - switch Identifier.Compile(node: current_node, withContext: context) { + switch AST.Identifier.CompileExpression(node: current_node, withContext: context) { case .Ok(let listed_action): - switch context.types.lookup(identifier: listed_action) { - case .Ok(let maybe_action): - if maybe_action.eq(rhs: Action()) { - return .Ok(TypedIdentifier(id: listed_action, withType: P4QualifiedType(maybe_action))) - } - return .Error( - ErrorWithLocation( - sourceLocation: node.toSourceLocation(), - withError: "\(listed_action) does not name an action")) - case .Error(let e): return .Error(e) - } + return .Ok(listed_action as! AST.Identifier) case .Error(let e): return .Error(e) } } @@ -810,31 +719,31 @@ extension TableActionsProperty: Compilable { }.joined(separator: ";")))) } - return .Ok(TableActionsProperty(actions)) + return .Ok(AST.TableActionsProperty(actions)) } } -extension TablePropertyList: Compilable { - public typealias C = TablePropertyList +extension AST.TablePropertyList: Compilable { + public typealias C = AST.TablePropertyList public static func Compile( - node: SwiftTreeSitter.Node, withContext context: CompilerContext - ) -> Result { + node: SwiftTreeSitter.Node, withContext context: ASTCompilerContext + ) -> Result { - #RequireNodeType( + #RequireNodeType( node: node, type: "table_property_list", nice_type_name: "Table Property List") - var keys: [TableKeys] = Array() - var actions: [TableActionsProperty] = Array() + var keys: [AST.TableKeys] = Array() + var actions: [AST.TableActionsProperty] = Array() var errors: [any Errorable] = Array() node.enumerateNamedChildren { child in if child.nodeType == "table_keys" { - switch TableKeys.Compile(node: child, withContext: context) { + switch AST.TableKeys.Compile(node: child, withContext: context) { case .Ok(let table_key): keys.append(table_key) case .Error(let e): errors.append(e) } } else if child.nodeType == "table_actions" { - switch TableActionsProperty.Compile(node: child, withContext: context) { + switch AST.TableActionsProperty.Compile(node: child, withContext: context) { case .Ok(let table_action_property): actions.append(table_action_property) case .Error(let e): errors.append(e) @@ -875,22 +784,22 @@ extension TablePropertyList: Compilable { withError: "More than one actions in table property list")) } if actions.isEmpty { - actions.append(TableActionsProperty()) + actions.append(AST.TableActionsProperty()) } - return .Ok(TablePropertyList(withActions: actions[0], withKeys: keys[0])) + return .Ok(AST.TablePropertyList(withActions: actions[0], withKeys: keys[0])) } } -extension Table: Compilable { - public typealias C = Table +extension AST.Table: Compilable { + public typealias C = AST.Table public static func Compile( - node: SwiftTreeSitter.Node, withContext context: CompilerContext - ) -> Result { + node: SwiftTreeSitter.Node, withContext context: ASTCompilerContext + ) -> Result { let table_declaration_node = node - #RequireNodeType( + #RequireNodeType( node: table_declaration_node, type: "table_declaration", nice_type_name: "Table Declaration") var walker = Walker(node: table_declaration_node) @@ -900,13 +809,13 @@ extension Table: Compilable { walker.next() // Skip the XXX? #MustOr( result: current_node, thing: walker.getNext(), - or: Result
.Error( + or: Result.Error( ErrorWithLocation( sourceLocation: node.toSourceLocation(), withError: "Missing table declaration component") )) guard - case .Ok(let table_name) = Identifier.Compile( + case .Ok(let table_name) = AST.Identifier.CompileExpression( node: current_node!, withContext: context) else { return Result.Error( @@ -918,62 +827,386 @@ extension Table: Compilable { walker.next() #MustOr( result: current_node, thing: walker.getNext(), - or: Result
.Error( + or: Result.Error( ErrorWithLocation( sourceLocation: node.toSourceLocation(), withError: "Missing table declaration component") )) - let maybe_table_property_list = TablePropertyList.Compile( + let maybe_table_property_list = AST.TablePropertyList.Compile( node: current_node!, withContext: context) guard case .Ok(let table_property_list) = maybe_table_property_list else { return Result.Error(maybe_table_property_list.error()!) } - return .Ok(Table(withName: table_name, withPropertyList: table_property_list)) + return .Ok( + AST.Table(withName: table_name as! AST.Identifier, withPropertyList: table_property_list)) } } -extension ExternDeclaration: Compilable { - public typealias C = Declaration +extension AST.ExternDeclaration: Compilable { + public typealias C = AST.AnDeclaration public static func Compile( - node: SwiftTreeSitter.Node, withContext context: CompilerContext - ) -> Result { + node: SwiftTreeSitter.Node, withContext context: ASTCompilerContext + ) -> Result { let extern_declaration_node = node - #RequireNodeType( + #RequireNodeType( node: extern_declaration_node, type: "extern_declaration", nice_type_name: "Extern Declaration") let declaration_node = extern_declaration_node.child(at: 1)! - #RequireNodeType( + #RequireNodeType( node: declaration_node, type: "declaration", nice_type_name: "Declaration") let declarationed_node = declaration_node.child(at: 0)! - let maybe_declared = Declaration.Compile( - node: declarationed_node, withContext: context.update(newExtern: true)) + let maybe_declared = AST.Declaration.Compile( + node: declarationed_node, withContext: context.update(withExtern: true)) guard case .Ok(let declared) = maybe_declared else { return .Error(maybe_declared.error()!) } - - // Before we are okay with this declaration, it must already be registered as an extern - // with the matching "stuff". - - let found_ffi = context.ffis.first { ffi in - ffi.type().baseType().eq(rhs: declared.identifier.type.baseType()) - } - - guard let found_ffi = found_ffi else { - return .Error( - ErrorWithLocation( - sourceLocation: declarationed_node.toSourceLocation(), - withError: - "Could not find a foreign function that matches the extern declaration (\(declared))")) - } - - let extern_declaration = Declaration(extern: declared, ffi: found_ffi) + let extern_declaration = AST.ExternDeclaration(declared) return .Ok( extern_declaration, ) } } + +func parameter_list_compiler( + node: SwiftTreeSitter.Node, withContext context: ASTCompilerContext +) -> Common.Result { + + var walker = Walker(node: node) + var current_node: Node? = .none + + if node.text == ")" { + // There are no parameters! + return Result.Ok(AST.ParameterList([])) + } + + #RequireNodeType( + node: node, type: "parameter_list", nice_type_name: "Parameter List") + + var parameters: AST.ParameterList = AST.ParameterList([]) + + #MustOr( + result: current_node, thing: walker.getNext(), + or: Result.Error( + ErrorWithLocation( + sourceLocation: node.toSourceLocation(), withError: "Missing parameter list component"))) + + if current_node?.nodeType == "parameter_list" { + switch parameter_list_compiler(node: current_node!, withContext: context) { + case .Ok(let ps): + parameters = ps + case .Error(let e): return Result.Error(e) + } + walker.next() + } + + #MustOr( + result: current_node, thing: walker.getNext(), + or: Result.Error( + ErrorWithLocation( + sourceLocation: node.toSourceLocation(), withError: "Missing parameter list component"))) + + // If this is a ')', we are done. + if current_node?.text == ")" { + return Result.Ok(parameters) + } + + // If this is a comma, we skip it! + if current_node?.text == "," { + walker.next() + } + + #MustOr( + result: current_node, thing: walker.getNext(), + or: Result.Error( + ErrorWithLocation( + sourceLocation: node.toSourceLocation(), withError: "Missing parameter list component"))) + + // Otherwise, there should be one parameter left! + switch AST.Parameter.Compile(node: current_node!, withContext: context) { + case .Ok(let parsed_parameter): + return Result.Ok(parameters.addParameter(parsed_parameter)) + case .Error(let e): return Result.Error(e) + } +} + +extension AST.ParameterList: Compilable { + public typealias C = AST.ParameterList + public static func Compile( + node: SwiftTreeSitter.Node, withContext context: ASTCompilerContext + ) -> Result { + + let parameter_node = node + #RequireNodeType( + node: parameter_node, type: "parameters", nice_type_name: "Parameters") + + var walker = Walker(node: parameter_node) + + var current_node: Node? = .none + + #MustOr( + result: current_node, thing: walker.getNext(), + or: Result.Error( + ErrorWithLocation( + sourceLocation: node.toSourceLocation(), + withError: "Missing '(' in parameter list component"))) + + walker.next() + #MustOr( + result: current_node, thing: walker.getNext(), + or: Result.Error( + ErrorWithLocation( + sourceLocation: node.toSourceLocation(), withError: "Missing parameter list component"))) + + return parameter_list_compiler(node: current_node!, withContext: context) + } +} + +extension Direction: Compilable { + public typealias C = Direction + public static func Compile( + node: Node, withContext context: ASTCompilerContext + ) -> Result { + let direction_node = node + #RequireNodeType( + node: direction_node, type: "direction", nice_type_name: "direction") + let directions = [ + "in": Direction.In, + "out": Direction.Out, + "inout": Direction.InOut, + ] + + guard let parsed_direction = directions[direction_node.text!] else { + return .Error( + ErrorWithLocation( + sourceLocation: direction_node.toSourceLocation(), + withError: "\(direction_node.text!) is not a valid direction")) + } + + return .Ok(parsed_direction) + } +} + +extension AST.Parameter: Compilable { + public typealias C = AST.Parameter + public static func Compile( + node: Node, withContext context: ASTCompilerContext + ) -> Result { + + #RequireNodeType( + node: node, type: "parameter", nice_type_name: "parameter") + + var walker = Walker(node: node) + var current_node: Node? = .none + + #MustOr( + result: current_node, thing: walker.getNext(), + or: Result.Error( + ErrorWithLocation( + sourceLocation: node.toSourceLocation(), + withError: "Missing parameter declaration component"))) + + // Annotation? + if current_node!.nodeType == "annotations" { + return .Error( + ErrorWithLocation( + sourceLocation: current_node!.toSourceLocation(), + withError: "Annotations in parameter declarations are not yet handled")) + // Will increment indexes here. + } + + #MustOr( + result: current_node, thing: walker.getNext(), + or: Result.Error( + ErrorWithLocation( + sourceLocation: node.toSourceLocation(), + withError: "Missing parameter declaration component"))) + + var direction: Direction? = .none + // Direction? + if current_node!.nodeType == "direction" { + + let maybe_parsed_direction = Direction.Compile(node: current_node!, withContext: context) + guard case .Ok(let parsed_direction) = maybe_parsed_direction else { + return .Error(maybe_parsed_direction.error()!) + } + direction = parsed_direction + + walker.next() + } + + #MustOr( + result: current_node, thing: walker.getNext(), + or: Result.Error( + ErrorWithLocation( + sourceLocation: node.toSourceLocation(), + withError: "Missing parameter declaration component"))) + + if current_node!.nodeType != "typeRef" { + return Result.Error( + ErrorWithLocation( + sourceLocation: node.toSourceLocation(), + withError: "Did not find type name for parameter declaration")) + } + + guard + case .Ok(let parameter_type) = AST.Types.CompileType( + type: current_node!, withContext: context) + else { + return Result.Error( + Error(withMessage: "Could not parse a P4 type from \(current_node!.text!)")) + } + + walker.next() + #MustOr( + result: current_node, thing: walker.getNext(), + or: Result.Error( + ErrorWithLocation( + sourceLocation: node.toSourceLocation(), + withError: "Missing parameter declaration component"))) + + if current_node!.nodeType != "identifier" { + return Result.Error( + ErrorWithLocation( + sourceLocation: node.toSourceLocation(), + withError: "Did not find identifier for parameter statement")) + } + + guard + case .Ok(let parameter_name) = AST.Identifier.CompileExpression( + node: current_node!, withContext: context) + else { + return Result.Error( + Error(withMessage: "Could not parse a parameter name from \(current_node!.text!)")) + } + + let qualified_parameter_type = + direction != nil + ? parameter_type.tipe.update(addAttribute: P4TypeQualifier.Direction(direction!)) + : parameter_type.tipe + + return Result.Ok( + AST.Parameter( + identifier: parameter_name as! AST.Identifier, + withType: AST.Tipe(qualified_parameter_type))) + } +} + +func argument_list_compiler( + node: SwiftTreeSitter.Node, withContext context: ASTCompilerContext +) -> Common.Result { + + var walker = Walker(node: node) + var current_node: Node? = .none + + if node.text == ")" { + // There are no arguments! + return Result.Ok(AST.ArgumentList([])) + } + + #RequireNodeType( + node: node, type: "argument_list", nice_type_name: "argument List") + + var arguments: AST.ArgumentList = AST.ArgumentList([]) + + #MustOr( + result: current_node, thing: walker.getNext(), + or: Result.Error( + ErrorWithLocation( + sourceLocation: node.toSourceLocation(), withError: "Missing argument list component"))) + + if current_node?.nodeType == "argument_list" { + switch argument_list_compiler(node: current_node!, withContext: context) { + case .Ok(let ps): + arguments = ps + case .Error(let e): return Result.Error(e) + } + + walker.next() + } + + // We may have moved nodes, check/reset current_node. + #MustOr( + result: current_node, thing: walker.getNext(), + or: Result.Error( + ErrorWithLocation( + sourceLocation: node.toSourceLocation(), withError: "Missing argument list component"))) + + // If this is a ')', we are done. + if current_node?.text == ")" { + return Result.Ok(arguments) + } + + // If this is a comma, we skip it! + if current_node?.text == "," { + walker.next() + } + + #MustOr( + result: current_node, thing: walker.getNext(), + or: Result.Error( + ErrorWithLocation( + sourceLocation: node.toSourceLocation(), withError: "Missing argument list component"))) + + // Otherwise, there should be one argument left! + switch AST.Argument.Compile(node: current_node!, withContext: context) { + case .Ok(let ce): + return Result.Ok( + arguments.addArgument(AST.Argument(ce, atIndex: arguments.arguments.count + 1))) + case .Error(let e): return Result.Error(e) + } +} + +extension AST.ArgumentList: Compilable { + public typealias C = AST.ArgumentList + public static func Compile( + node: SwiftTreeSitter.Node, withContext context: ASTCompilerContext + ) -> Common.Result { + + let argument_node = node + #RequireNodeType( + node: argument_node, type: "arguments", nice_type_name: "arguments") + + var walker = Walker(node: argument_node) + var current_node: Node? = .none + + #MustOr( + result: current_node, thing: walker.getNext(), + or: Result.Error( + ErrorWithLocation( + sourceLocation: node.toSourceLocation(), + withError: "Missing '(' in argument list component"))) + + walker.next() + + #MustOr( + result: current_node, thing: walker.getNext(), + or: Result.Error( + ErrorWithLocation( + sourceLocation: node.toSourceLocation(), withError: "Missing argument list component"))) + + return argument_list_compiler(node: current_node!, withContext: context) + } +} + +extension AST.Argument: Compilable { + public typealias C = AST.AnExpression + public static func Compile( + node: SwiftTreeSitter.Node, withContext context: ASTCompilerContext + ) -> Common.Result { + let argument_node = node + #RequireNodeType( + node: argument_node, type: "argument", nice_type_name: "argument") + + let expression_node = node.child(at: 0)! + + return switch AST.Expression.Compile(node: expression_node, withContext: context) { + case .Ok(let compiled_expression): .Ok(compiled_expression) + case .Error(let e): .Error(e) + } + } +} diff --git a/Sources/P4Compiler/Expression.swift b/Sources/P4Compiler/Expression.swift index e55f90f..903008a 100644 --- a/Sources/P4Compiler/Expression.swift +++ b/Sources/P4Compiler/Expression.swift @@ -16,66 +16,34 @@ // along with this program. If not, see . import Common -import P4Lang -import P4Runtime import SwiftTreeSitter import TreeSitterP4 -extension TypedIdentifier: CompilableExpression { - public static func compile( - node: SwiftTreeSitter.Node, withContext context: CompilerContext - ) -> Result { +extension AST.Identifier: CompilableExpression { + public static func CompileExpression( + node: SwiftTreeSitter.Node, withContext context: ASTCompilerContext + ) -> Result { - let node = node.child(at: 0)! - #SkipUnlessNodeType( - node: node, type: "identifier") - - guard - case Result.Ok(let type) = context.instances.lookup( - identifier: Common.Identifier(name: node.text!)) - else { - return .Error( - ErrorWithLocation( - sourceLocation: node.toSourceLocation(), withError: "Cannot find \(node.text!) in scope")) - } + #RequireNodeType( + node: node, type: "identifier", nice_type_name: "Identifier") /// TODO: If there is a value here, then we can make this a compile-time constant! - return .Ok(TypedIdentifier(name: node.text!, withType: type.0)) - } -} - -extension TypedIdentifier: CompilableLValueExpression { - public static func compile_as_lvalue( - node: SwiftTreeSitter.Node, withContext context: CompilerContext - ) -> Result { - - let expression = node.child(at: 0)! - #SkipUnlessNodeType( - node: expression, type: "identifier") - - let maybe_parsed_expression = TypedIdentifier.compile(node: node, withContext: context) - guard case .Ok(let maybe_typed_identifier) = maybe_parsed_expression else { - return .Error(maybe_parsed_expression.error()!) - } - - let typed_identifier_expression = maybe_typed_identifier as! TypedIdentifier - - return Result.Ok(typed_identifier_expression) + return .Ok(AST.Identifier(Common.Identifier(name: node.text!))) } } extension P4BooleanValue: CompilableExpression { - public static func compile( - node: SwiftTreeSitter.Node, withContext context: CompilerContext - ) -> Result { + public static func CompileExpression( + node: SwiftTreeSitter.Node, withContext context: ASTCompilerContext + ) -> Result { let node = node.child(at: 0)! - #SkipUnlessNodeType( - node: node, type: "booleanLiteralExpression") + #RequireNodeType( + node: node, type: "booleanLiteralExpression", nice_type_name: "Boolean Literal Expression") if node.text == "false" { - return .Ok(P4Value(P4BooleanValue(withValue: false))) + return .Ok(AST.Literal(P4Value(P4BooleanValue(withValue: false)))) } else if node.text == "true" { - return .Ok(P4Value(P4BooleanValue(withValue: true))) + return .Ok(AST.Literal(P4Value(P4BooleanValue(withValue: true)))) } return .Error( @@ -86,13 +54,14 @@ extension P4BooleanValue: CompilableExpression { } extension P4IntValue: CompilableExpression { - public static func compile( - node: SwiftTreeSitter.Node, withContext context: CompilerContext - ) -> Result { + public static func CompileExpression( + node: SwiftTreeSitter.Node, withContext context: ASTCompilerContext + ) -> Result { let node = node.child(at: 0)! - #SkipUnlessNodesTypes( - node: node, types: ["integer", "integer_elaborated"]) + #RequireNodesType( + nodes: node, type: ["integer", "integer_elaborated"], + nice_type_names: ["Integer", "Elaborated Integer"]) var bit_width: BitWidth = BitWidth.Infinite let value_source: String @@ -124,7 +93,7 @@ extension P4IntValue: CompilableExpression { } if let parsed_int = Int(value_source) { - return .Ok(P4Value(P4IntValue(withValue: parsed_int, andWidth: bit_width))) + return .Ok(AST.Literal(P4Value(P4IntValue(withValue: parsed_int, andWidth: bit_width)))) } else { return .Error( ErrorWithLocation( @@ -135,131 +104,83 @@ extension P4IntValue: CompilableExpression { } extension P4StringValue: CompilableExpression { - public static func compile( - node: SwiftTreeSitter.Node, withContext scopes: CompilerContext - ) -> Result { + public static func CompileExpression( + node: SwiftTreeSitter.Node, withContext scopes: ASTCompilerContext + ) -> Result { let node = node.child(at: 0)! - #SkipUnlessNodeType( - node: node, type: "string_literal") - return .Ok(P4Value(P4StringValue(withValue: node.text!))) + #RequireNodeType( + node: node, type: "string_literal", nice_type_name: "String Literal") + return .Ok(AST.Literal(P4Value(P4StringValue(withValue: node.text!)))) } } -extension KeysetExpression: CompilableExpression { - public static func compile( - node: SwiftTreeSitter.Node, withContext context: CompilerContext - ) -> Result { +extension AST.Expression: Compilable { + public static func Compile( + node: Node, withContext context: ASTCompilerContext + ) -> Result { + #RequireNodeType( + node: node, type: "expression", nice_type_name: "expression") + + let expression_node = node.child(at: 0)! + #RequireNodesType( + nodes: expression_node, type: ["grouped_expression", "simple_expression"], + nice_type_names: ["grouped expression", "simple expression"]) + + // If this is a grouped expression, recurse! + if expression_node.nodeType == "grouped_expression" { + return AST.Expression.Compile(node: expression_node.child(at: 1)!, withContext: context) + } + + let expression_parsers: [CompilableExpression.Type] = [ + P4BooleanValue.self, P4StringValue.self, P4IntValue.self, AST.Identifier.self, + AST.BinaryOperatorExpression.self, AST.ArrayAccessExpression.self, AST.FieldAccessExpression.self, + AST.FunctionCall.self, + ] + + for candidate_expression_parser in expression_parsers { + switch candidate_expression_parser.CompileExpression( + node: expression_node, withContext: context) + { + case .Ok(let parsed): return .Ok(parsed) + case .Error(let e): return .Error(e) + } + } + + return Result.Error(Error(withMessage: "\(node.range): Could not parse into expression")) + } +} + +extension AST.KeysetExpression: CompilableExpression { + public static func CompileExpression( + node: SwiftTreeSitter.Node, withContext context: ASTCompilerContext + ) -> Result { let keyset_expression_node = node.child(at: 0)! - #RequireNodesType( + #RequireNodesType( nodes: keyset_expression_node, type: ["expression", "default_keyset"], nice_type_names: ["expression", "default keyset"]) // If there is a default keyset, that's easy! if keyset_expression_node.nodeType == "default_keyset" { - return .Ok(KeysetExpression(P4Value(P4SetDefaultValue(withType: context.expected_type!)))) + return .Ok(AST.KeysetExpression.Default) } // Compile the expression: - let maybe_compiled_set_expression = Expression.Compile( + let maybe_compiled_set_expression = AST.Expression.Compile( node: keyset_expression_node, withContext: context) guard case .Ok(let compiled_expression) = maybe_compiled_set_expression else { return .Error(maybe_compiled_set_expression.error()!) } - return .Ok(KeysetExpression(compiled_expression)) + return .Ok(AST.KeysetExpression.Value(compiled_expression)) } } -struct Expression { - public static func Compile( - node: Node, withContext context: CompilerContext - ) -> Result { - #RequireNodeType( - node: node, type: "expression", nice_type_name: "expression") - - let expression_node = node.child(at: 0)! - #RequireNodesType( - nodes: expression_node, type: ["grouped_expression", "simple_expression"], - nice_type_names: ["grouped expression", "simple expression"]) - - // If this is a grouped expression, recurse! - if expression_node.nodeType == "grouped_expression" { - return Expression.Compile(node: expression_node.child(at: 1)!, withContext: context) - } - - let expression_parsers: [CompilableExpression.Type] = [ - P4BooleanValue.self, P4StringValue.self, P4IntValue.self, TypedIdentifier.self, - BinaryOperatorExpression.self, ArrayAccessExpression.self, FieldAccessExpression.self, - FunctionCall.self, - ] - - for candidate_expression_parser in expression_parsers { - switch candidate_expression_parser.compile( - node: expression_node, withContext: context) - { - 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 Compile( - node: Node, withContext context: CompilerContext - ) -> Result { - #RequireNodeType( - node: node, type: "expression", nice_type_name: "expression") - - let expression_node = node.child(at: 0)! - #RequireNodesType( - nodes: expression_node, type: ["grouped_expression", "simple_expression"], - nice_type_names: ["grouped expression", "simple expression"]) - - // If this is a grouped expression, recurse! - if expression_node.nodeType == "grouped_expression" { - return LValue.Compile(node: expression_node.child(at: 1)!, withContext: context) - } - - let lvalue_parsers: [CompilableLValueExpression.Type] = [ - TypedIdentifier.self, FieldAccessExpression.self, ArrayAccessExpression.self, - ] - - for candidate_lvalue_parser in lvalue_parsers { - switch candidate_lvalue_parser.compile_as_lvalue( - node: expression_node, withContext: context) - { - 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 Identifier { - public static func Compile( - node: Node, withContext context: CompilerContext - ) -> Result { - 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)")) - } - } -} - -extension SelectExpression: CompilableExpression { - public static func compile( - node: Node, withContext context: CompilerContext - ) -> Result { - #RequireNodeType( +extension AST.SelectExpression: CompilableExpression { + public static func CompileExpression( + node: Node, withContext context: ASTCompilerContext + ) -> Result { + #RequireNodeType( node: node, type: "selectExpression", nice_type_name: "parser select expression") guard let selector_node = node.child(at: 2), @@ -279,7 +200,7 @@ extension SelectExpression: CompilableExpression { withError: "Could not find select expression body")) } - let maybe_selector = Expression.Compile(node: selector_node, withContext: context) + let maybe_selector = AST.Expression.Compile(node: selector_node, withContext: context) guard case .Ok(let selector) = maybe_selector else { return .Error( ErrorWithLocation( @@ -289,14 +210,14 @@ extension SelectExpression: CompilableExpression { )) } - var sces: [SelectCaseExpression] = Array() + var sces: [AST.SelectCaseExpression] = Array() var sces_errors: (any Errorable)? = .none select_body_node.enumerateNamedChildren { current_node in - let maybe_parsed_cse = SelectCaseExpression.compile( - node: current_node, withContext: context.update(newExpectation: selector.type())) + let maybe_parsed_cse = AST.SelectCaseExpression.CompileExpression( + node: current_node, withContext: context) switch maybe_parsed_cse { - case .Ok(let parsed_cse): sces.append(parsed_cse as! SelectCaseExpression) + case .Ok(let parsed_cse): sces.append(parsed_cse as! AST.SelectCaseExpression) case .Error(let e): sces_errors = if let sces_errors = sces_errors { @@ -312,18 +233,18 @@ extension SelectExpression: CompilableExpression { } return .Ok( - SelectExpression(withSelector: selector, withSelectCaseExpressions: sces), + AST.SelectExpression(withSelector: selector, withSelectCaseExpressions: sces), ) } } -extension SelectCaseExpression: CompilableExpression { - public static func compile( - node: Node, withContext context: CompilerContext - ) -> Result { - if node.nodeType != "selectCase" { - return Result.Error(Error(withMessage: "Expected select case not found")) - } +extension AST.SelectCaseExpression: CompilableExpression { + public static func CompileExpression( + node: Node, withContext context: ASTCompilerContext + ) -> Result { + + #RequireNodeType( + node: node, type: "selectCase", nice_type_name: "Select Case") guard let keysetexpression_node = node.child(at: 0), keysetexpression_node.nodeType == "keysetExpression" @@ -337,94 +258,56 @@ extension SelectCaseExpression: CompilableExpression { return Result.Error(Error(withMessage: "Missing target state in select case")) } - let maybe_parsed_keysetexpression = KeysetExpression.compile( + let maybe_parsed_keysetexpression = AST.KeysetExpression.CompileExpression( node: keysetexpression_node, withContext: context) guard case Result.Ok(let maybe_keysetexpression) = maybe_parsed_keysetexpression else { return Result.Error(maybe_parsed_keysetexpression.error()!) } - guard let maybe_keysetexpression = maybe_keysetexpression else { - return Result.Error( - ErrorWithLocation( - sourceLocation: keysetexpression_node.toSourceLocation(), - withError: "Missing expected keyset expression")) - } + let keysetexpression = maybe_keysetexpression as! AST.KeysetExpression - let keysetexpression = maybe_keysetexpression as! KeysetExpression - - if case .Error(let e) = keysetexpression.compatible(type: context.expected_type!) { - return .Error( - ErrorWithLocation( - sourceLocation: keysetexpression_node.toSourceLocation(), withError: e.msg())) - } - - let maybe_parsed_targetstate = Identifier.Compile( + let maybe_parsed_targetstate = AST.Identifier.CompileExpression( node: targetstate_node, withContext: context) guard case .Ok(let targetstate) = maybe_parsed_targetstate else { return Result.Error(maybe_parsed_targetstate.error()!) } return .Ok( - SelectCaseExpression( - withKey: keysetexpression, withNextState: targetstate) + AST.SelectCaseExpression( + withKey: keysetexpression, withNextState: targetstate as! AST.Identifier) ) } } -// swift-format-ignore -public typealias BinaryOperatorChecker = (P4Expression, P4Expression) -> Result<()> - -public func binary_and_or_operator_checker( - left: P4Expression, right: P4Expression -) -> Result<()> { - // Check that both are Boolean-typed things! - if !(left.type().baseType().eq(rhs: P4Boolean()) && right.type().baseType().eq(rhs: P4Boolean())) - { - return .Error(Error(withMessage: "And/Or on operands with non-bool type is not allowed")) - } - return .Ok(()) -} - -public func binary_int_math_operator_checker( - left: P4Expression, right: P4Expression -) -> Result<()> { - // Check that both are int-typed things! - if !(left.type().baseType().eq(rhs: P4Int()) && right.type().baseType().eq(rhs: P4Int())) { - return .Error( - Error(withMessage: "Mathematical operation on operands with non-int type is not allowed")) - } - return .Ok(()) -} - -extension BinaryOperatorExpression: CompilableExpression { - public static func compile( - node: SwiftTreeSitter.Node, withContext context: CompilerContext - ) -> Result<(P4Expression)?> { +extension AST.BinaryOperatorExpression: CompilableExpression { + public static func CompileExpression( + node: SwiftTreeSitter.Node, withContext context: ASTCompilerContext + ) -> Result { let expression = node.child(at: 0)! - #SkipUnlessNodeType( - node: expression, type: "binaryOperatorExpression") - + #RequireNodeType( + node: expression, type: "binaryOperatorExpression", + nice_type_name: "Binary Operator Expression") let binary_operator_expression_node = expression.child(at: 0)! var walker = Walker(node: binary_operator_expression_node) var current_node: Node? = .none #MustOr( result: current_node, thing: walker.getNext(), - or: Result.Error( + or: Result.Error( ErrorWithLocation( sourceLocation: node.toSourceLocation(), withError: "Malformed binary operator expression" ))) /// TODO: This macro cannot handle new lines in the arrays // swift-format-ignore - #RequireNodesType( + #RequireNodesType( nodes: binary_operator_expression_node, type: ["binaryEqualOperatorExpression", "binaryLessThanOperatorExpression", "binaryLessThanEqualOperatorExpression", "binaryGreaterThanOperatorExpression", "binaryGreaterThanEqualOperatorExpression", "binaryAndOperatorExpression", "binaryOrOperatorExpression", "binaryAddOperatorExpression", "binarySubtractOperatorExpression", "binaryMultiplyOperatorExpression", "binaryDivideOperatorExpression"], nice_type_names: [ "binary equal operator", "binary less than operator", "binary less than or equal to operator", "binary greater than operator", "binary greater than or equal to operator", "binary and operator", "binary or operator", "binary add operator", "binary subtract operator", "binary multiply operator", "binary divide operator"]) #MustOr( result: current_node, thing: walker.getNext(), - or: Result.Error( + or: Result.Error( ErrorWithLocation( sourceLocation: node.toSourceLocation(), withError: "Missing LHS for binary operator expression"))) @@ -434,7 +317,7 @@ extension BinaryOperatorExpression: CompilableExpression { walker.next() #MustOr( result: current_node, thing: walker.getNext(), - or: Result.Error( + or: Result.Error( ErrorWithLocation( sourceLocation: node.toSourceLocation(), withError: "Missing binary operator for binary operator expression"))) @@ -442,105 +325,92 @@ extension BinaryOperatorExpression: CompilableExpression { walker.next() #MustOr( result: current_node, thing: walker.getNext(), - or: Result.Error( + or: Result.Error( ErrorWithLocation( sourceLocation: node.toSourceLocation(), withError: "Missing RHS for binary operator expression"))) let right_hand_side_raw = current_node! - let maybe_left_hand_side = Expression.Compile(node: left_hand_side_raw, withContext: context) + let maybe_left_hand_side = AST.Expression.Compile( + node: left_hand_side_raw, withContext: context) guard case Result.Ok(let left_hand_side) = maybe_left_hand_side else { return Result.Error(maybe_left_hand_side.error()!) } - let maybe_right_hand_side = Expression.Compile(node: right_hand_side_raw, withContext: context) + let maybe_right_hand_side = AST.Expression.Compile( + node: right_hand_side_raw, withContext: context) guard case Result.Ok(let right_hand_side) = maybe_right_hand_side else { return Result.Error(maybe_right_hand_side.error()!) } - let evaluators: - [String: (String, P4QualifiedType, BinaryOperatorChecker?, BinaryOperatorEvaluator)] = [ - "binaryEqualOperatorExpression": ( - "Binary Equal", P4QualifiedType(P4Boolean()), Optional.none, - binary_equal_operator_evaluator - ), - "binaryLessThanOperatorExpression": ( - "Binary Less Than", P4QualifiedType(P4Boolean()), Optional.none, - binary_lt_operator_evaluator - ), - "binaryLessThanEqualOperatorExpression": ( - "Binary Less Than Or Equal", P4QualifiedType(P4Boolean()), - Optional.none, - binary_lte_operator_evaluator - ), - "binaryGreaterThanOperatorExpression": ( - "Binary Greater Than", P4QualifiedType(P4Boolean()), Optional.none, - binary_gt_operator_evaluator - ), - "binaryGreaterThanEqualOperatorExpression": ( - "Binary Greater Than Or Equal", P4QualifiedType(P4Boolean()), - Optional.none, - binary_gte_operator_evaluator - ), - "binaryAndOperatorExpression": ( - "Binary Or", P4QualifiedType(P4Boolean()), binary_and_or_operator_checker, - binary_and_operator_evaluator - ), - "binaryOrOperatorExpression": ( - "Binary And", P4QualifiedType(P4Boolean()), binary_and_or_operator_checker, - binary_or_operator_evaluator - ), - "binaryAddOperatorExpression": ( - "Binary Add", P4QualifiedType(P4Int()), binary_int_math_operator_checker, - binary_add_operator_evaluator - ), - "binarySubtractOperatorExpression": ( - "Binary Subtract", P4QualifiedType(P4Int()), binary_int_math_operator_checker, - binary_subtract_operator_evaluator - ), - "binaryMultiplyOperatorExpression": ( - "Binary Multiply", P4QualifiedType(P4Int()), binary_int_math_operator_checker, - binary_multiply_operator_evaluator - ), - "binaryDivideOperatorExpression": ( - "Binary Divide", P4QualifiedType(P4Int()), binary_int_math_operator_checker, - binary_divide_operator_evaluator - ), - ] - - if !left_hand_side.type().eq(right_hand_side.type()) { - return Result.Error( - Error(withMessage: "Types of values used with binary expression are not the same")) - } + let evaluators: [String: (String, P4QualifiedType, AST.BinaryOperatorExpressionType)] = [ + "binaryEqualOperatorExpression": ( + "Binary Equal", P4QualifiedType(P4Boolean()), + AST.BinaryOperatorExpressionType.Eq + ), + "binaryLessThanOperatorExpression": ( + "Binary Less Than", P4QualifiedType(P4Boolean()), + AST.BinaryOperatorExpressionType.Lt + ), + "binaryLessThanEqualOperatorExpression": ( + "Binary Less Than Or Equal", P4QualifiedType(P4Boolean()), + AST.BinaryOperatorExpressionType.Lte + ), + "binaryGreaterThanOperatorExpression": ( + "Binary Greater Than", P4QualifiedType(P4Boolean()), + AST.BinaryOperatorExpressionType.Gt + ), + "binaryGreaterThanEqualOperatorExpression": ( + "Binary Greater Than Or Equal", P4QualifiedType(P4Boolean()), + AST.BinaryOperatorExpressionType.Gte + ), + "binaryAndOperatorExpression": ( + "Binary Or", P4QualifiedType(P4Boolean()), + AST.BinaryOperatorExpressionType.And + ), + "binaryOrOperatorExpression": ( + "Binary And", P4QualifiedType(P4Boolean()), + AST.BinaryOperatorExpressionType.Or + ), + "binaryAddOperatorExpression": ( + "Binary Add", P4QualifiedType(P4Int()), + AST.BinaryOperatorExpressionType.Add + ), + "binarySubtractOperatorExpression": ( + "Binary Subtract", P4QualifiedType(P4Int()), + AST.BinaryOperatorExpressionType.Subtract + ), + "binaryMultiplyOperatorExpression": ( + "Binary Multiply", P4QualifiedType(P4Int()), + AST.BinaryOperatorExpressionType.Multiply + ), + "binaryDivideOperatorExpression": ( + "Binary Divide", P4QualifiedType(P4Int()), + AST.BinaryOperatorExpressionType.Divide + ), + ] guard let selected_evaluator = evaluators[binary_operator_expression_node.nodeType!] else { return Result.Error( Error(withMessage: "No evaluator for \(binary_operator_expression_node.nodeType!)")) } - if let checker = selected_evaluator.2, - case .Error(let e) = checker(left_hand_side, right_hand_side) - { - return Result.Error(e) - } - return .Ok( - BinaryOperatorExpression( - withEvaluator: (selected_evaluator.0, selected_evaluator.1, selected_evaluator.3), + AST.BinaryOperatorExpression( + withType: selected_evaluator.2, withLhs: left_hand_side, withRhs: right_hand_side)) } } -extension ArrayAccessExpression: CompilableExpression { - public static func compile( - node: SwiftTreeSitter.Node, withContext context: CompilerContext - ) -> Result { +extension AST.ArrayAccessExpression: CompilableExpression { + public static func CompileExpression( + node: SwiftTreeSitter.Node, withContext context: ASTCompilerContext + ) -> Result { let expression = node.child(at: 0)! - #SkipUnlessNodeType( - node: expression, type: "arrayAccessExpression") - + #RequireNodeType( + node: expression, type: "arrayAccessExpression", nice_type_name: "Array Access Expression") let array_access_expression_node = expression var walker = Walker(node: array_access_expression_node) @@ -548,11 +418,11 @@ extension ArrayAccessExpression: CompilableExpression { #MustOr( result: current_node, thing: walker.getNext(), - or: Result.Error( + or: Result.Error( ErrorWithLocation( sourceLocation: node.toSourceLocation(), withError: "Malformed array access expression"))) - #RequireNodeType( + #RequireNodeType( node: current_node!, type: "expression", nice_type_name: "array identifier expression") let array_access_identifier_node = current_node! @@ -560,7 +430,7 @@ extension ArrayAccessExpression: CompilableExpression { walker.next() #MustOr( result: current_node, thing: walker.getNext(), - or: Result.Error( + or: Result.Error( ErrorWithLocation( sourceLocation: node.toSourceLocation(), withError: "Missing [ for array access expression"))) @@ -569,52 +439,43 @@ extension ArrayAccessExpression: CompilableExpression { #MustOr( result: current_node, thing: walker.getNext(), - or: Result.Error( + or: Result.Error( ErrorWithLocation( sourceLocation: node.toSourceLocation(), withError: "Missing indexor expression for array access expression"))) - #RequireNodeType( + #RequireNodeType( node: current_node!, type: "expression", nice_type_name: "array indexor expression") let array_access_indexor_node = current_node! - let maybe_array_identifier = Expression.Compile( + let maybe_array_identifier = AST.Expression.Compile( node: array_access_identifier_node, withContext: context) guard case Result.Ok(let array_identifier) = maybe_array_identifier else { return Result.Error(maybe_array_identifier.error()!) } - let maybe_array_type = array_identifier.type() - guard let array_type = maybe_array_type.baseType() as? P4Array else { - return Result.Error( - ErrorWithLocation( - sourceLocation: array_access_identifier_node.toSourceLocation(), - withError: "\(array_identifier) does not name an array type") - ) - } - - let maybe_array_indexor = Expression.Compile( + let maybe_array_indexor = AST.Expression.Compile( node: array_access_indexor_node, withContext: context) guard case Result.Ok(let array_indexor) = maybe_array_indexor else { return Result.Error(maybe_array_indexor.error()!) } return .Ok( - ArrayAccessExpression( - withName: array_identifier, withType: array_type, withIndexor: array_indexor)) + AST.ArrayAccessExpression( + withName: array_identifier, withIndexor: array_indexor)) } } -extension FieldAccessExpression: CompilableExpression { - public static func compile( - node: SwiftTreeSitter.Node, withContext context: CompilerContext - ) -> Result { +extension AST.FieldAccessExpression: CompilableExpression { + public static func CompileExpression( + node: SwiftTreeSitter.Node, withContext context: ASTCompilerContext + ) -> Result { let expression = node.child(at: 0)! - #SkipUnlessNodeType( - node: expression, type: "fieldAccessExpression") + #RequireNodeType( + node: expression, type: "fieldAccessExpression", nice_type_name: "Array Access Expression") let field_access_expression_node = expression @@ -623,11 +484,11 @@ extension FieldAccessExpression: CompilableExpression { #MustOr( result: current_node, thing: walker.getNext(), - or: Result.Error( + or: Result.Error( ErrorWithLocation( sourceLocation: node.toSourceLocation(), withError: "Malformed field access expression"))) - #RequireNodeType( + #RequireNodeType( node: current_node!, type: "expression", nice_type_name: "struct identifier expression") let struct_identifier_node = current_node! @@ -635,7 +496,7 @@ extension FieldAccessExpression: CompilableExpression { walker.next() #MustOr( result: current_node, thing: walker.getNext(), - or: Result.Error( + or: Result.Error( ErrorWithLocation( sourceLocation: node.toSourceLocation(), withError: "Missing . for field access expression"))) @@ -643,198 +504,73 @@ extension FieldAccessExpression: CompilableExpression { walker.next() #MustOr( result: current_node, thing: walker.getNext(), - or: Result.Error( + or: Result.Error( ErrorWithLocation( sourceLocation: node.toSourceLocation(), withError: "Missing field name for field access expression"))) - #RequireNodeType( + #RequireNodeType( node: current_node!, type: "identifier", nice_type_name: "field name") let field_name_node = current_node! // Make sure that the identifier really identifies a struct. - let maybe_struct_identifier = Expression.Compile( + let maybe_struct_identifier = AST.Expression.Compile( node: struct_identifier_node, withContext: context) guard case Result.Ok(let struct_identifier) = maybe_struct_identifier else { return Result.Error(maybe_struct_identifier.error()!) } - guard let struct_type = struct_identifier.type().baseType() as? P4Struct else { - return .Error( - ErrorWithLocation( - sourceLocation: struct_identifier_node.toSourceLocation(), - withError: "\(struct_identifier_node.text!) does not have struct type")) - } - let maybe_field_name = Identifier.Compile( + let maybe_field_name = AST.Identifier.CompileExpression( node: field_name_node, withContext: context) guard case Result.Ok(let field_name) = maybe_field_name else { return Result.Error(maybe_field_name.error()!) } - // Make sure that the field is valid for the struct type. - let maybe_field_type = struct_type.fields.get_field_type(field_name) - guard let field_type = maybe_field_type else { - return .Error( - ErrorWithLocation( - sourceLocation: field_name_node.toSourceLocation(), - withError: "\(field_name) is not a valid field for struct with type \(struct_type)")) - } - return .Ok( - FieldAccessExpression( + AST.FieldAccessExpression( withStruct: struct_identifier, - withField: P4StructFieldIdentifier(id: field_name, withType: field_type))) + withField: field_name as! AST.Identifier)) } } -extension FieldAccessExpression: CompilableLValueExpression { - public static func compile_as_lvalue( - node: SwiftTreeSitter.Node, withContext context: CompilerContext - ) -> Result { - let expression = node.child(at: 0)! - #SkipUnlessNodeType( - node: expression, type: "fieldAccessExpression") - - let maybe_parsed_expression = FieldAccessExpression.compile(node: node, withContext: context) - guard case .Ok(let maybe_field_access_expression) = maybe_parsed_expression else { - return .Error(maybe_parsed_expression.error()!) - } - - let field_access_expression = maybe_field_access_expression as! FieldAccessExpression - - return Result.Ok(field_access_expression) - } -} - -extension ArrayAccessExpression: CompilableLValueExpression { - public static func compile_as_lvalue( - node: SwiftTreeSitter.Node, withContext context: CompilerContext - ) -> Result { - let expression = node.child(at: 0)! - #SkipUnlessNodeType( - node: expression, type: "arrayAccessExpression") - - let maybe_parsed_expression = ArrayAccessExpression.compile(node: node, withContext: context) - guard case .Ok(let maybe_array_access_expression) = maybe_parsed_expression else { - return .Error(maybe_parsed_expression.error()!) - } - - let array_access_expression = maybe_array_access_expression as! ArrayAccessExpression - - return Result.Ok(array_access_expression) - } -} - -extension FunctionCall: CompilableExpression { - public static func compile( - node: Node, withContext context: CompilerContext - ) -> Result { +extension AST.FunctionCall: CompilableExpression { + public static func CompileExpression( + node: Node, withContext context: ASTCompilerContext + ) -> Result { let expression = node.child(at: 0)! - #SkipUnlessNodeType( - node: expression, type: "function_call") + #RequireNodeType( + node: expression, type: "function_call", nice_type_name: "Function Call") var walker = Walker(node: expression) var current_node: Node? = .none #MustOr( result: current_node, thing: walker.getNext(), - or: Result.Error( + or: Result.Error( ErrorWithLocation( sourceLocation: node.toSourceLocation(), withError: "Missing function call component"))) - let maybe_callee_name = Identifier.Compile( + let maybe_callee_name = AST.Identifier.CompileExpression( node: current_node!, withContext: context) guard case .Ok(let callee_name) = maybe_callee_name else { return Result.Error(maybe_callee_name.error()!) } - - var maybe_callee: Result<(FunctionDeclaration?, Declaration?)> = - switch context.types.lookup(identifier: callee_name) { - case .Ok(let looked_up): - switch looked_up { - case let callee as FunctionDeclaration: - Result<(FunctionDeclaration?, Declaration?)>.Ok((callee, .none)) // What we found is actually a function declaration - default: - Result<(FunctionDeclaration?, Declaration?)>.Error( - ErrorWithLocation( - sourceLocation: current_node!.toSourceLocation(), - withError: "\(callee_name) is not a function")) - } - case .Error(let e): Result<(FunctionDeclaration?, Declaration?)>.Error(e) - } - - maybe_callee = - if case .Error(let e) = maybe_callee { - switch context.externs.lookup(identifier: callee_name) { - case .Ok(let callee as Declaration): - // Now, make sure that it is a function declaration! - switch callee.identifier.type.baseType() { - case is FunctionDeclaration: Result.Ok((.none, callee)) - default: - .Error( - ErrorWithLocation( - sourceLocation: current_node!.toSourceLocation(), - withError: "\(callee_name) is not a function")) - } - default: .Error(e) - } - } else { - maybe_callee - } - - guard case .Ok(let callee) = maybe_callee else { - return .Error(maybe_callee.error()!) - } - walker.next() #MustOr( result: current_node, thing: walker.getNext(), - or: Result.Error( + or: Result.Error( ErrorWithLocation( sourceLocation: node.toSourceLocation(), withError: "Missing function call component"))) - let maybe_argument_list = ArgumentList.Compile(node: current_node!, withContext: context) + let maybe_argument_list = AST.ArgumentList.Compile(node: current_node!, withContext: context) guard case .Ok(let arguments) = maybe_argument_list else { return .Error(maybe_argument_list.error()!) } - - // Now, compare the arguments with the parameters: - - let params = - switch callee { - case (.some(let callee), .none): Optional.some(callee.params) - case (.none, .some(let callee)): - Optional.some((callee.ffi!.type().baseType() as! FunctionDeclaration).params) - default: Optional.none - } - - guard case .some(let params) = params else { - return Result.Error( - ErrorWithLocation( - sourceLocation: node.toSourceLocation(), - withError: "Could not lookup the parameters for the called function (\(callee_name))")) - } - - if case .Error(let e) = arguments.compatible(params) { - return .Error(e) - } - - // All good! - - return switch callee { - case (.some(let callee), .none): .Ok(FunctionCall(callee, withArguments: arguments)) - case (.none, .some(let callee)): .Ok(FunctionCall(callee.ffi!, withArguments: arguments)) - default: - Result.Error( - ErrorWithLocation( - sourceLocation: node.toSourceLocation(), - withError: "Unexpected error occurred calling function named (\(callee_name))" - )) - } + return .Ok(AST.FunctionCall(callee_name as! AST.Identifier, withArguments: arguments)) } } diff --git a/Sources/P4Compiler/Parser.swift b/Sources/P4Compiler/Parser.swift index 8576f32..f39e4e1 100644 --- a/Sources/P4Compiler/Parser.swift +++ b/Sources/P4Compiler/Parser.swift @@ -16,17 +16,15 @@ // along with this program. If not, see . import Common -import P4Lang -import P4Runtime import SwiftTreeSitter import TreeSitterExtensions import TreeSitterP4 -extension Statement: Compilable { - public typealias C = P4Statement +extension AST.Statement: Compilable { + public typealias C = AST.AnStatement public static func Compile( - node: SwiftTreeSitter.Node, withContext context: CompilerContext - ) -> Result { + node: SwiftTreeSitter.Node, withContext context: ASTCompilerContext + ) -> Result { if node.nodeType != "parserStatement" && node.nodeType != "statement" { return Result.Error( @@ -38,11 +36,11 @@ extension Statement: Compilable { let statement = node.child(at: 0)! let statementParsers: [String: CompilableStatement.Type] = [ - "assignmentStatement": ParserAssignmentStatement.self, - "expressionStatement": ExpressionStatement.self, - "variableDeclaration": VariableDeclarationStatement.self, - "conditionalStatement": ConditionalStatement.self, "blockStatement": BlockStatement.self, - "return_statement": ReturnStatement.self, + "assignmentStatement": AST.ParserAssignmentStatement.self, + "expressionStatement": AST.ExpressionStatement.self, + "variableDeclaration": AST.VariableDeclarationStatement.self, + "conditionalStatement": AST.ConditionalStatement.self, "blockStatement": AST.BlockStatement.self, + "return_statement": AST.ReturnStatement.self, ] guard let parser = statementParsers[statement.nodeType ?? ""] else { return Result.Error( @@ -63,13 +61,13 @@ extension Statement: Compilable { } } -extension LocalElements: Compilable { - public typealias C = P4Statement +extension AST.LocalElements: Compilable { + public typealias C = AST.AnStatement public static func Compile( - node: Node, withContext context: CompilerContext - ) -> Result { + node: Node, withContext context: ASTCompilerContext + ) -> Result { let localElementsParsers: [String: CompilableStatement.Type] = [ - "variableDeclaration": VariableDeclarationStatement.self + "variableDeclaration": AST.VariableDeclarationStatement.self ] guard let parser = localElementsParsers[node.nodeType ?? ""] else { @@ -88,11 +86,11 @@ extension LocalElements: Compilable { } } -extension ParserState: Compilable { - public typealias C = ParserState +extension AST.ParserState: Compilable { + public typealias C = AST.AnState public static func Compile( - node: Node, withContext context: CompilerContext - ) -> Result { + node: Node, withContext context: ASTCompilerContext + ) -> Result { var walker = Walker(node: node) var current_node: Node? = .none @@ -108,7 +106,7 @@ extension ParserState: Compilable { #MustOr( result: current_node, thing: walker.getNext(), - or: Result.Error( + or: Result.Error( ErrorWithLocation( sourceLocation: node.toSourceLocation(), withError: "Missing elements in parser state declaration"))) @@ -126,12 +124,12 @@ extension ParserState: Compilable { walker.next() #MustOr( result: current_node, thing: walker.getNext(), - or: Result.Error( + or: Result.Error( ErrorWithLocation( sourceLocation: node.toSourceLocation(), withError: "Missing elements in parser state declaration"))) - let maybe_state_identifier = Identifier.Compile( + let maybe_state_identifier = AST.Identifier.CompileExpression( node: current_node!, withContext: context) guard case Result.Ok(let state_identifier) = maybe_state_identifier else { return Result.Error(maybe_state_identifier.error()!) @@ -142,13 +140,13 @@ extension ParserState: Compilable { walker.next() #MustOr( result: current_node, thing: walker.getNext(), - or: Result.Error( + or: Result.Error( ErrorWithLocation( sourceLocation: node.toSourceLocation(), withError: "Missing body of state declaration") )) var errors: (any Errorable)? = .none - var parsed_s: [P4Statement] = Array() + var parsed_s: [AST.AnStatement] = Array() if current_node!.nodeType == "parserStatements" { switch SpecialCompilers.Statements.Compile( @@ -173,14 +171,13 @@ extension ParserState: Compilable { #MustOr( result: current_node, thing: walker.getNext(), - or: Result.Error( + or: Result.Error( ErrorWithLocation( sourceLocation: node.toSourceLocation(), withError: "Missing transition statement of state declaration"))) - let updated_context = SpecialCompilers.Statements.effect(statements: parsed_s, context: context) - .update(newLexicalContextName: state_identifier).update(newLexicalContextStatements: parsed_s) + let updated_context = context.update(withContextName: (state_identifier as! AST.Identifier)).update(withContextStatements: parsed_s) - return TransitionStatement.Compile(node: current_node!, withContext: updated_context) + return AST.TransitionStatement.Compile(node: current_node!, withContext: updated_context) } -} +} \ No newline at end of file diff --git a/Sources/P4Compiler/Protocols.swift b/Sources/P4Compiler/Protocols.swift index da690bb..142f01e 100644 --- a/Sources/P4Compiler/Protocols.swift +++ b/Sources/P4Compiler/Protocols.swift @@ -16,8 +16,6 @@ // along with this program. If not, see . import Common -import P4Lang -import P4Runtime import SwiftTreeSitter import TreeSitterExtensions import TreeSitterP4 @@ -26,33 +24,44 @@ public protocol CompilableValue { static func CompileValue(withValue value: String) -> Result } +public protocol MaybeCompilableType { + static func MaybeCompileType( + type: SwiftTreeSitter.Node, withContext: ASTCompilerContext + ) -> Result +} + public protocol CompilableType { static func CompileType( - type: SwiftTreeSitter.Node, withContext: CompilerContext - ) -> Result + type: SwiftTreeSitter.Node, withContext: ASTCompilerContext + ) -> Result } - public protocol CompilableExpression { - static func compile( - node: Node, withContext context: CompilerContext - ) -> Result -} - -public protocol CompilableLValueExpression { - static func compile_as_lvalue( - node: Node, withContext context: CompilerContext - ) -> Result + static func CompileExpression( + node: Node, withContext context: ASTCompilerContext + ) -> Result } public protocol Compilable { associatedtype C static func Compile( - node: Node, withContext context: CompilerContext + node: Node, withContext context: ASTCompilerContext ) -> Result } public protocol CompilableStatement { static func CompileStatement( - node: Node, withContext context: CompilerContext - ) -> Result + node: Node, withContext context: ASTCompilerContext + ) -> Result } + +public protocol ASTVisitor { + associatedtype T + func visit(node: AST.BinaryOperatorExpression, driver: ASTVisitorDriver, context: T) -> Result + func visit(node: AST.Literal, driver: ASTVisitorDriver, context: T) -> Result + func visit(node: AST.Identifier, driver: ASTVisitorDriver, context: T) -> Result + + func visit(node: AST.Parser, driver: ASTVisitorDriver, context: T) -> Result + func visit(node: AST.ParserStateDirectTransition, driver: ASTVisitorDriver, context: T) -> Result + func visit(node: AST.ParserStateNoTransition, driver: ASTVisitorDriver, context: T) -> Result + func visit(node: AST.ParserStateSelectTransition, driver: ASTVisitorDriver, context: T) -> Result +} \ No newline at end of file diff --git a/Sources/P4Compiler/SpecialCompilers.swift b/Sources/P4Compiler/SpecialCompilers.swift index 070360d..ed8a0a0 100644 --- a/Sources/P4Compiler/SpecialCompilers.swift +++ b/Sources/P4Compiler/SpecialCompilers.swift @@ -16,22 +16,14 @@ // along with this program. If not, see . import Common -import P4Lang -import P4Runtime import SwiftTreeSitter import TreeSitterExtensions import TreeSitterP4 -protocol AnyCompilable { - static func Compile( - node: SwiftTreeSitter.Node, withContext context: CompilerContext - ) -> Common.Result<(Any, CompilerContext)> -} - -extension TransitionStatement: Compilable { +extension AST.TransitionStatement: Compilable { public static func Compile( - node: Node, withContext context: CompilerContext - ) -> Result { + node: Node, withContext context: ASTCompilerContext + ) -> Result { guard let state_identifier = context.lexical_context_name else { return .Error( @@ -71,51 +63,27 @@ extension TransitionStatement: Compilable { // If the next node is an identifier, we have the simple form ... if next_node.nodeType == "identifier" { - let maybe_parsed_next_state_id = Identifier.Compile( + let maybe_parsed_next_state_id = AST.Identifier.CompileExpression( node: next_node, withContext: context) - if case .Ok(let next_state_id) = maybe_parsed_next_state_id { - if case .Ok(let next_state) = context.instances.lookup(identifier: next_state_id) { - switch next_state { - case (_, .some(let instance)): - return .Ok( - ParserStateDirectTransition( - name: state_identifier, - withNextState: instance.dataValue() as! InstantiatedParserState, - withStatements: stmts, - ) - ) - case (_, .none): - return .Ok( - ParserStateDirectTransition( - name: state_identifier, - withNextStateIdentifier: next_state_id, withStatements: stmts) - ) - } - } else { - - return .Error( - Error( - withMessage: - "\(next_state_id) does not name a parser state in scope" - )) - } - } else { - return .Error( - Error( - withMessage: - "Could not parse the next state in a transition statement: \(maybe_parsed_next_state_id.error()!)" - )) + switch maybe_parsed_next_state_id { + case .Ok(let next_state_id): + return .Ok( + AST.ParserStateDirectTransition( + name: (state_identifier), + withNextStateIdentifier: next_state_id as! AST.Identifier, withStatements: stmts)) + case .Error(let e): + return .Error(e) } } // We know that the next node is a select expression. return - switch SelectExpression.compile(node: next_node, withContext: context) + switch AST.SelectExpression.CompileExpression(node: next_node, withContext: context) { case .Ok(let tse): .Ok( - ParserStateSelectTransition( - name: state_identifier, withTransitionExpression: tse as! SelectExpression, + AST.ParserStateSelectTransition( + name: state_identifier, withTransitionExpression: tse as! AST.SelectExpression, withStatements: stmts, ) ) @@ -127,8 +95,8 @@ extension TransitionStatement: Compilable { public struct SpecialCompilers { public struct Statements { static func Compile( - node: Node, withContext context: CompilerContext - ) -> Result<[P4Statement]> { + node: Node, withContext context: ASTCompilerContext + ) -> Result<[AST.AnStatement]> { if node.nodeType != "statements" && node.nodeType != "parserStatements" { return Result.Error( ErrorWithLocation( @@ -136,16 +104,14 @@ public struct SpecialCompilers { } var errors: (any Errorable)? = .none - var current_context = context - var parsed_s: [P4Statement] = Array() + var parsed_s: [AST.AnStatement] = Array() node.enumerateNamedChildren { node in - switch Statement.Compile( - node: node, withContext: current_context) + switch AST.Statement.Compile( + node: node, withContext: context) { case .Ok(let parsed_statement): parsed_s.append(parsed_statement) - current_context = parsed_statement.effect(context: current_context) case .Error(let e): errors = if let errors = errors { @@ -162,28 +128,18 @@ public struct SpecialCompilers { return Result.Ok(parsed_s) } - - static func effect(statements: [P4Statement], context: CompilerContext) -> CompilerContext { - var current = context - for s in statements { - current = s.effect(context: current) - } - return current - } - } static func CompileParserBody( - withName name: Common.Identifier, withParameters parameters: ParameterList, node: Node, - withContext context: CompilerContext - ) -> Result { + withName name: AST.Identifier, withParameters parameters: AST.ParameterList, node: Node, + withContext context: ASTCompilerContext + ) -> Result { - var parser = P4Lang.Parser(withName: name, withParameters: parameters) + var parser = AST.Parser(withName: name, withParameters: parameters) // Build a state from each one listed. - var error: (any Errorable)? = .none + var errors: (any Errorable)? = .none - var current_context = context /// TODO: Assert that there is only one. node.enumerateNamedChildren { parser_state in if parser_state.nodeType != "parserState" { @@ -191,53 +147,32 @@ public struct SpecialCompilers { } // Parse a state in a nested scope. - switch ParserState.Compile( + switch AST.ParserState.Compile( node: parser_state, - withContext: context.update(newInstances: current_context.instances.enter())) + withContext: context) { case Result.Ok(let state): - let statement = state as P4Statement - current_context = statement.effect(context: current_context) + // All states are instances inside the parser. parser.states = parser.states.append(state: state) - case Result.Error(let e): error = e + case Result.Error(let e): + errors = + if let errors = errors { + errors.append(error: e) + } else { + e + } } } - if let error = error { - return .Error(error) + if let errors = errors { + return .Error(errors) } - return Result.Ok(parser) + return .Ok(parser) } public struct ProgramCompiler { - public static func Compile(_ source: String) -> Result { - - // Certain names are always in scope during compilation. - var globals = StaticVarValueScopes().enter() - globals = globals.declare( - identifier: accept.state().getName(), - withValue: (P4QualifiedType(accept.type()), P4Value(accept)) - ) - .declare( - identifier: reject.state.getName(), - withValue: (P4QualifiedType(reject.type()), P4Value(reject))) - - return ProgramCompiler.Compile( - source, withGlobalInstances: globals, withGlobalTypes: .none, withFFIs: []) - } - - public static func Compile( - _ source: String, withGlobalInstances globalInstances: StaticVarValueScopes - ) -> Result { - return ProgramCompiler.Compile( - source, withGlobalInstances: globalInstances, withGlobalTypes: .none, withFFIs: []) - } - - public static func Compile( - _ source: String, withGlobalInstances globalInstances: StaticVarValueScopes?, - withGlobalTypes globalTypes: TypeTypeScopes?, withFFIs ffis: [P4FFI] = Array() - ) -> Result { + public static func Compile(_ source: String) -> Result { let maybe_parser = ConfigureP4Parser() guard case .Ok(let p) = maybe_parser else { @@ -252,38 +187,25 @@ public struct SpecialCompilers { return Result.Error(Error(withMessage: "Could not compile the P4 program")) } - var program = P4Lang.Program() + var program = AST.Program() // Set up a context for parsing. - var compilation_context = CompilerContext() - - // Add our FFIs - compilation_context = compilation_context.update(newFFIs: ffis) + let compilation_context = ASTCompilerContext() var errors: (any Errorable)? = .none - // If the caller gave any global instances, add them here. - if let globalInstances = globalInstances { - compilation_context = compilation_context.update(newInstances: globalInstances) - } - - // If the caller gave any global types, add them here. - if let globalTypes = globalTypes { - compilation_context = compilation_context.update(newTypes: globalTypes) - } - // Try to parse all top-level declarations. result?.rootNode?.enumerateNamedChildren { (declaration_node: Node) in let declaration_parsers: [String: CompilableStatement.Type] = [ - "declaration": Declaration.self, - "instantiation": Instantiation.self, + "declaration": AST.Declaration.self, + "instantiation": AST.Instantiation.self, ] if let parser = declaration_parsers[declaration_node.nodeType!] { let r = parser.CompileStatement(node: declaration_node, withContext: compilation_context) switch r { case .Ok(let compiled): - compilation_context = compiled.effect(context: compilation_context) + program.statements = program.statements + [compiled] case .Error(let e): errors = if let errors = errors { @@ -310,28 +232,8 @@ public struct SpecialCompilers { if let errors = errors { return .Error(errors) } - - // Any of the instances that are in the top-level scope should go into the program! - program.instances = Array( - compilation_context.instances.filter { (_, v) in - v.1 != nil - }.map { (_, v) in - v.1! - }) - - // Any of the types that are in the top-level scope should go into the program! - program.types = Array( - compilation_context.types.map { (_, v) in - v - }) - - // Any of the extern types that are in the top-level scope should go into the program! - program.externs = Array( - compilation_context.externs.map { (_, v) in - v - }) - return Result.Ok(program) + } } diff --git a/Sources/P4Compiler/Statement.swift b/Sources/P4Compiler/Statement.swift index 8275985..ee6df5e 100644 --- a/Sources/P4Compiler/Statement.swift +++ b/Sources/P4Compiler/Statement.swift @@ -16,18 +16,17 @@ // along with this program. If not, see . import Common -import P4Lang -import P4Runtime import SwiftTreeSitter import TreeSitterExtensions import TreeSitterP4 -extension BlockStatement: Compilable { - public typealias C = BlockStatement +extension AST.BlockStatement: Compilable { + public typealias C = AST.BlockStatement public static func Compile( - node: Node, withContext context: CompilerContext - ) -> Result { - #RequireNodeType( + node: Node, withContext context: ASTCompilerContext + ) -> Result { + /* + #RequireNodeType( node: node, type: "blockStatement", nice_type_name: "block statement") var walker = Walker(node: node) @@ -35,7 +34,7 @@ extension BlockStatement: Compilable { #MustOr( result: current_node, thing: walker.getNext(), - or: Result.Error( + or: Result.Error( ErrorWithLocation( sourceLocation: node.toSourceLocation(), withError: "Malformed block statement"))) @@ -46,13 +45,13 @@ extension BlockStatement: Compilable { withError: "Missing { on block statement")) } - var statements: [P4Statement] = Array() + var statements: [AST.AnStatement] = Array() var parse_err: (any Errorable)? = .none walker.next() #MustOr( result: current_node, thing: walker.getNext(), - or: Result.Error( + or: Result.Error( ErrorWithLocation( sourceLocation: node.toSourceLocation(), withError: "Malformed block statement"))) @@ -75,7 +74,7 @@ extension BlockStatement: Compilable { #MustOr( result: current_node, thing: walker.getNext(), - or: Result.Error( + or: Result.Error( ErrorWithLocation( sourceLocation: node.toSourceLocation(), withError: "Malformed block statement"))) @@ -86,20 +85,22 @@ extension BlockStatement: Compilable { withError: "Missing } on block statement")) } - return .Ok(BlockStatement(statements)) + return .Ok(AST.BlockStatement(statements)) + */ + return .Ok(AST.BlockStatement([])) } } @deriveCompilableStatement -extension BlockStatement: CompilableStatement {} +extension AST.BlockStatement: CompilableStatement {} -extension ConditionalStatement: Compilable { - public typealias C = ConditionalStatement +extension AST.ConditionalStatement: Compilable { + public typealias C = AST.ConditionalStatement public static func Compile( - node: Node, withContext context: CompilerContext - ) -> Result { + node: Node, withContext context: ASTCompilerContext + ) -> Result { - #RequireNodeType( + #RequireNodeType( node: node, type: "conditionalStatement", nice_type_name: "conditional statement") let maybe_condition_expression = node.child(at: 2) @@ -123,7 +124,7 @@ extension ConditionalStatement: Compilable { } guard - case .Ok(let condition) = Expression.Compile( + case .Ok(let condition) = AST.Expression.Compile( node: condition_expression, withContext: context) else { return Result.Error( @@ -131,7 +132,7 @@ extension ConditionalStatement: Compilable { } guard - case .Ok(let thenns) = Statement.Compile( + case .Ok(let thenns) = AST.Statement.Compile( node: thens, withContext: context) else { return Result.Error( @@ -140,10 +141,10 @@ extension ConditionalStatement: Compilable { "Could not parse the then block in a conditional statement")) } - let optional_elss: Result? = + let optional_elss: Result? = if let elss = node.child(at: 6) { .some( - Statement.Compile( + AST.Statement.Compile( node: elss, withContext: context)) } else { .none @@ -159,22 +160,22 @@ extension ConditionalStatement: Compilable { "Could not parse the else block in a conditional statement")) } return .Ok( - ConditionalStatement(condition: condition, withThen: thenns, andElse: elss)) + AST.ConditionalStatement(condition: condition, withThen: thenns, andElse: elss)) } - return .Ok(ConditionalStatement(condition: condition, withThen: thenns)) + return .Ok(AST.ConditionalStatement(condition: condition, withThen: thenns)) } } @deriveCompilableStatement -extension ConditionalStatement: CompilableStatement {} +extension AST.ConditionalStatement: CompilableStatement {} -extension VariableDeclarationStatement: Compilable { - public typealias C = VariableDeclarationStatement +extension AST.VariableDeclarationStatement: Compilable { + public typealias C = AST.VariableDeclarationStatement public static func Compile( - node: Node, withContext context: CompilerContext - ) -> Result { + node: Node, withContext context: ASTCompilerContext + ) -> Result { - #RequireNodeType( + #RequireNodeType( node: node, type: "variableDeclaration", nice_type_name: "variable declaration statement") let maybe_typeref = node.child(at: 0) @@ -200,20 +201,21 @@ extension VariableDeclarationStatement: Compilable { let maybe_rvalue = node.childCount > 3 ? node.child(at: 3) : .none guard - case .Ok(let parsed_variablename) = Identifier.Compile( + case .Ok(let parsed_variablename) = AST.Identifier.CompileExpression( node: variablename, withContext: context) else { return Result.Error( Error(withMessage: "Could not parse variable name")) } - guard case .Ok(let declaration_p4_type) = Types.CompileType(type: typeref, withContext: context) + guard + case .Ok(let declaration_p4_type) = AST.Types.CompileType(type: typeref, withContext: context) else { return Result.Error( Error(withMessage: "Could not parse a P4 type from \(typeref.text!)")) } - var initializer: P4Expression? = .none + var initializer: AST.AnExpression? = .none // If there is an initializer, it must be an expression. if let initializer_expression = maybe_rvalue { @@ -224,7 +226,7 @@ extension VariableDeclarationStatement: Compilable { withError: "initial value for declaration statement is not an expression")) } - let maybe_parsed_rvalue = Expression.Compile( + let maybe_parsed_rvalue = AST.Expression.Compile( node: initializer_expression, withContext: context) guard case .Ok(let parsed_rvalue) = maybe_parsed_rvalue @@ -232,67 +234,47 @@ extension VariableDeclarationStatement: Compilable { return .Error(maybe_parsed_rvalue.error()!) } - if parsed_rvalue.type().eq(declaration_p4_type) { - initializer = parsed_rvalue - } else { - return Result.Error( - Error( - withMessage: - "Cannot initialize \(parsed_variablename) (with type \(declaration_p4_type)) from expression with type \(parsed_rvalue.type())" - )) - } - } - - // If there is no initializer, then it must be defaultable. - - if initializer == nil { - initializer = declaration_p4_type.def() - } - - guard let initializer = initializer else { - return Result.Error( - ErrorWithLocation( - sourceLocation: node.toSourceLocation(), withError: "No initializer for declaration")) + initializer = parsed_rvalue } return Result.Ok( - VariableDeclarationStatement( - identifier: TypedIdentifier(id: parsed_variablename, withType: declaration_p4_type), + AST.VariableDeclarationStatement( + identifier: parsed_variablename as! AST.Identifier, withType: declaration_p4_type, withInitializer: initializer), ) } } @deriveCompilableStatement -extension VariableDeclarationStatement: CompilableStatement {} +extension AST.VariableDeclarationStatement: CompilableStatement {} -extension ExpressionStatement: Compilable { - public typealias C = ExpressionStatement +extension AST.ExpressionStatement: Compilable { + public typealias C = AST.ExpressionStatement public static func Compile( - node: Node, withContext context: CompilerContext - ) -> Result { + node: Node, withContext context: ASTCompilerContext + ) -> Result { #RequireNodeType( node: node, type: "expressionStatement", nice_type_name: "expression statement") let expression_node = node.child(at: 0)! - return switch Expression.Compile(node: expression_node, withContext: context) { - case .Ok(let expression): .Ok(ExpressionStatement(expression)) + return switch AST.Expression.Compile(node: expression_node, withContext: context) { + case .Ok(let expression): .Ok(AST.ExpressionStatement(expression)) case .Error(let e): .Error(e) } } } @deriveCompilableStatement -extension ExpressionStatement: CompilableStatement {} +extension AST.ExpressionStatement: CompilableStatement {} -extension ParserAssignmentStatement: Compilable { - public typealias C = ParserAssignmentStatement +extension AST.ParserAssignmentStatement: Compilable { + public typealias C = AST.ParserAssignmentStatement public static func Compile( - node: Node, withContext context: CompilerContext - ) -> Result { + node: Node, withContext context: ASTCompilerContext + ) -> Result { - #RequireNodeType( + #RequireNodeType( node: node, type: "assignmentStatement", nice_type_name: "assignment statement") guard let lvalue_node = node.child(at: 0), @@ -313,95 +295,77 @@ extension ParserAssignmentStatement: Compilable { withError: "Missing rvalue in assignment statement")) } - let maybe_parsed_rvalue = Expression.Compile( + let maybe_parsed_rvalue = AST.Expression.Compile( node: rvalue_node, withContext: context) guard case Result.Ok(let rvalue) = maybe_parsed_rvalue else { return Result.Error(maybe_parsed_rvalue.error()!) } - let maybe_parsed_lvalue = LValue.Compile(node: lvalue_node, withContext: context) - guard case .Ok(let lvalue_identifier) = maybe_parsed_lvalue else { + let maybe_parsed_lvalue = AST.Expression.Compile(node: lvalue_node, withContext: context) + guard case .Ok(let lvalue) = maybe_parsed_lvalue else { return Result.Error(maybe_parsed_lvalue.error()!) } - let check_result = lvalue_identifier.check(to: rvalue, inScopes: context.instances) - guard case .Ok(_) = check_result else { - return Result.Error( - ErrorWithLocation( - sourceLocation: lvalue_node.toSourceLocation(), - withError: "\(check_result.error()!)")) - } - return Result.Ok( - ParserAssignmentStatement( - withLValue: lvalue_identifier, + AST.ParserAssignmentStatement( + withLValue: lvalue, withValue: rvalue )) } } @deriveCompilableStatement -extension ParserAssignmentStatement: CompilableStatement {} +extension AST.ParserAssignmentStatement: CompilableStatement {} -extension ReturnStatement: Compilable { - public typealias C = ReturnStatement +extension AST.ReturnStatement: Compilable { + public typealias C = AST.ReturnStatement public static func Compile( - node: SwiftTreeSitter.Node, withContext context: CompilerContext - ) -> Result { - #RequireNodeType( + node: SwiftTreeSitter.Node, withContext context: ASTCompilerContext + ) -> Result { + #RequireNodeType( node: node, type: "return_statement", nice_type_name: "return statement") let expression_node = node.child(at: 1)! - return switch Expression.Compile(node: expression_node, withContext: context) { - case .Ok(let result): - if result.type().baseType().eq(rhs: context.expected_type!.baseType()) { - .Ok(ReturnStatement(result)) - } else { - .Error( - ErrorWithLocation( - sourceLocation: node.toSourceLocation(), - withError: - "Type of expression in return statement (\(result.type())) is not compatible with function return type (\(context.expected_type!))" - )) - } + return switch AST.Expression.Compile(node: expression_node, withContext: context) { + case .Ok(let result): .Ok(AST.ReturnStatement(result)) case .Error(let e): .Error(e) } } } @deriveCompilableStatement -extension ReturnStatement: CompilableStatement {} +extension AST.ReturnStatement: CompilableStatement {} -extension ApplyStatement: Compilable { - public typealias C = ApplyStatement +extension AST.ApplyStatement: Compilable { + public typealias C = AST.ApplyStatement public static func Compile( - node: SwiftTreeSitter.Node, withContext context: CompilerContext - ) -> Result { - #RequireNodeType( + node: SwiftTreeSitter.Node, withContext context: ASTCompilerContext + ) -> Result { + #RequireNodeType( node: node, type: "apply_statement", nice_type_name: "apply statement") let expression_node = node.child(at: 1)! - return switch BlockStatement.Compile(node: expression_node, withContext: context) { + return switch AST.BlockStatement.Compile(node: expression_node, withContext: context) { case .Ok(let statement): - .Ok(ApplyStatement(statement)) + .Ok(AST.ApplyStatement(statement)) case .Error(let e): .Error(e) } } } @deriveCompilableStatement -extension ApplyStatement: CompilableStatement {} +extension AST.ApplyStatement: CompilableStatement {} -extension Instantiation: Compilable { - public typealias C = Instantiation +extension AST.Instantiation: Compilable { + public typealias C = AST.Instantiation public static func Compile( - node: SwiftTreeSitter.Node, withContext context: CompilerContext - ) -> Result { + node: SwiftTreeSitter.Node, withContext context: ASTCompilerContext + ) -> Result { let expression = node - #RequireNodeType( + #RequireNodeType( node: expression, type: "instantiation", nice_type_name: "instantiation statement") var walker = Walker(node: expression) @@ -409,122 +373,48 @@ extension Instantiation: Compilable { #MustOr( result: current_node, thing: walker.getNext(), - or: Result.Error( + or: Result.Error( ErrorWithLocation( sourceLocation: node.toSourceLocation(), withError: "Missing function call component"))) - let maybe_instantiated_type_name = Identifier.Compile( + let maybe_instantiated_type_name = AST.Identifier.CompileExpression( node: current_node!, withContext: context) guard case .Ok(let instantiated_type_name) = maybe_instantiated_type_name else { return Result.Error(maybe_instantiated_type_name.error()!) } - - var maybe_instantiated_type: Result<(P4Lang.Parser?, Declaration?)> = - switch context.types.lookup(identifier: instantiated_type_name) { - case .Ok(let looked_up): - switch looked_up { - /// TODO: Further filter instantiable things. - case let instantiated_parser as P4Lang.Parser: - Result<(P4Lang.Parser?, Declaration?)>.Ok((instantiated_parser, .none)) // What we found is actually a parser declaration - default: - Result<(P4Lang.Parser?, Declaration?)>.Error( - ErrorWithLocation( - sourceLocation: current_node!.toSourceLocation(), - withError: "\(instantiated_type_name) cannot be instantiated")) - } - case .Error(let e): Result<(P4Lang.Parser?, Declaration?)>.Error(e) - } - - maybe_instantiated_type = - if case .Error(let e) = maybe_instantiated_type { - switch context.externs.lookup(identifier: instantiated_type_name) { - case .Ok(let callee as Declaration): - // Now, make sure that it is a function declaration! - switch callee.identifier.type.baseType() { - case is P4Lang.Parser: Result.Ok((.none, callee)) - default: - .Error( - ErrorWithLocation( - sourceLocation: current_node!.toSourceLocation(), - withError: "\(instantiated_type_name) cannot be instantiated")) - } - default: .Error(e) - } - } else { - maybe_instantiated_type - } - - guard case .Ok(let callee) = maybe_instantiated_type else { - return .Error(maybe_instantiated_type.error()!) - } - walker.next() #MustOr( result: current_node, thing: walker.getNext(), - or: Result.Error( + or: Result.Error( ErrorWithLocation( sourceLocation: node.toSourceLocation(), withError: "Missing instantiation component"))) - let maybe_argument_list = ArgumentList.Compile(node: current_node!, withContext: context) + let maybe_argument_list = AST.ArgumentList.Compile(node: current_node!, withContext: context) guard case .Ok(let arguments) = maybe_argument_list else { return .Error(maybe_argument_list.error()!) } - // Now, compare the arguments with the parameters: - - let params = - switch callee { - case (.some(let callee), .none): Optional.some(callee.parameters) - case (.none, .some(let callee)): - Optional.some((callee.ffi!.type().baseType() as! P4Lang.Parser).parameters) - default: Optional.none - } - - guard case .some(let params) = params else { - return Result.Error( - ErrorWithLocation( - sourceLocation: node.toSourceLocation(), - withError: - "Could not lookup the parameters for the instantiated parser (\(instantiated_type_name))" - )) - } - - if case .Error(let e) = arguments.compatible(params) { - return .Error(e) - } - walker.next() #MustOr( result: current_node, thing: walker.getNext(), - or: Result.Error( + or: Result.Error( ErrorWithLocation( sourceLocation: node.toSourceLocation(), withError: "Missing instantiation name"))) - let name = Identifier.Compile(node: current_node!, withContext: context) + let name = AST.Identifier.CompileExpression(node: current_node!, withContext: context) guard case .Ok(let name) = name else { return .Error(name.error()!) } - let inst: Result = - switch callee { - case (.some(let callee), .none): - .Ok(Instantiation(named: name, ofType: callee, withArguments: arguments)) - case (.none, .some(let callee)): - .Ok(Instantiation(named: name, ofType: callee, withArguments: arguments)) - default: - Result.Error( - ErrorWithLocation( - sourceLocation: node.toSourceLocation(), - withError: - "Unexpected error occurred calling function named (\(instantiated_type_name))" - )) - } - return inst + return .Ok( + AST.Instantiation( + named: name as! AST.Identifier, withType: instantiated_type_name as! AST.Identifier, + withArguments: arguments)) } } @deriveCompilableStatement -extension Instantiation: CompilableStatement {} +extension AST.Instantiation: CompilableStatement {} diff --git a/Sources/P4Compiler/Types.swift b/Sources/P4Compiler/Types.swift index 512c71d..8c4f437 100644 --- a/Sources/P4Compiler/Types.swift +++ b/Sources/P4Compiler/Types.swift @@ -16,24 +16,22 @@ // along with this program. If not, see . import Common -import P4Lang -import P4Runtime import SwiftTreeSitter import TreeSitterExtensions import TreeSitterP4 -extension P4Boolean: CompilableType { - public static func CompileType( - type: SwiftTreeSitter.Node, withContext: CompilerContext - ) -> Common.Result<(any Common.P4Type)?> { - return type.text == "bool" ? .Ok(P4Boolean()) : .Ok(.none) +extension P4Boolean: MaybeCompilableType { + public static func MaybeCompileType( + type: SwiftTreeSitter.Node, withContext: ASTCompilerContext + ) -> Common.Result<(AST.Tipe)?> { + return type.text == "bool" ? .Ok(AST.Tipe(P4QualifiedType(P4Boolean()))) : .Ok(.none) } } -extension P4Int: CompilableType { - public static func CompileType( - type: SwiftTreeSitter.Node, withContext: CompilerContext - ) -> Common.Result<(any Common.P4Type)?> { +extension P4Int: MaybeCompilableType { + public static func MaybeCompileType( + type: SwiftTreeSitter.Node, withContext: ASTCompilerContext + ) -> Common.Result<(AST.Tipe)?> { // Drill down, as appropriate. let base_type_node = type.child(at: 0)! @@ -50,7 +48,7 @@ extension P4Int: CompilableType { #MustOr( result: int_node, thing: walker.getNext(), - or: Result.Error( + or: Result.Error( ErrorWithLocation( sourceLocation: type_node.toSourceLocation(), withError: "Missing elements in int type declaration"))) @@ -67,49 +65,30 @@ extension P4Int: CompilableType { sourceLocation: bit_width_node.toSourceLocation(), withError: "Could not parse \(bit_width_node.text!) into integer")) } - return .Ok(P4Int(BitWidth.Width(bit_width))) + return .Ok(AST.Tipe(P4QualifiedType(P4Int(BitWidth.Width(bit_width))))) } - return .Ok(P4Int()) + return .Ok(AST.Tipe(P4QualifiedType(P4Int(BitWidth.Infinite)))) } } -extension P4String: CompilableType { +extension P4String: MaybeCompilableType { + public static func MaybeCompileType( + type: SwiftTreeSitter.Node, withContext: ASTCompilerContext + ) -> Common.Result<(AST.Tipe)?> { + return type.text == "string" ? .Ok(AST.Tipe(P4QualifiedType(P4String()))) : .Ok(.none) + } +} + +extension AST.Types: CompilableType { public static func CompileType( - type: SwiftTreeSitter.Node, withContext: CompilerContext - ) -> Common.Result<(any Common.P4Type)?> { - return type.text == "string" ? .Ok(P4String()) : .Ok(.none) - } -} - -extension P4Struct: CompilableType { - public static func CompileType( - type: SwiftTreeSitter.Node, withContext context: CompilerContext - ) -> Common.Result<(any Common.P4Type)?> { - - let maybe_parsed_type_id = Identifier.Compile(node: type, withContext: context) - guard case .Ok(let parsed_type_id) = maybe_parsed_type_id else { - return .Error(maybe_parsed_type_id.error()!) - } - - if case .Ok(let found_type) = context.types.lookup(identifier: parsed_type_id), - let found_struct_type = found_type as? P4Struct - { - return .Ok(found_struct_type) - } - return .Ok(.none) - } -} - -public struct Types { - static func CompileType( - type: SwiftTreeSitter.Node, withContext context: CompilerContext - ) -> Result { - let type_parsers: [CompilableType.Type] = [ - P4Boolean.self, P4Int.self, P4String.self, P4Struct.self, + type: SwiftTreeSitter.Node, withContext context: ASTCompilerContext + ) -> Result { + let type_parsers: [MaybeCompilableType.Type] = [ + P4Boolean.self, P4Int.self, P4String.self, /*P4Struct.self,*/ ] for type_parser in type_parsers { - switch type_parser.CompileType(type: type, withContext: context) { - case .Ok(.some(let type)): return .Ok(P4QualifiedType(type)) + switch type_parser.MaybeCompileType(type: type, withContext: context) { + case .Ok(.some(let type)): return .Ok(type) case .Ok(.none): continue case .Error(let e): return .Error(e) } diff --git a/Sources/P4Compiler/Visitor.swift b/Sources/P4Compiler/Visitor.swift new file mode 100644 index 0000000..7480322 --- /dev/null +++ b/Sources/P4Compiler/Visitor.swift @@ -0,0 +1,54 @@ +import Common + +public struct ASTVisitorDriver { + public init() {} + + public func visit( + expression: any AST.AnExpression, visitor: any ASTVisitor, context: T + ) -> Result { + return switch expression { + case let e as AST.BinaryOperatorExpression: + visitor.visit(node: e, driver: self, context: context) + case let e as AST.Literal: visitor.visit(node: e, driver: self, context: context) + default: .Error(Error(withMessage: "AST Expression Element Is Not Visitable")) + } + } + + public func visit( + state: any AST.AnState, visitor: any ASTVisitor, context: T + ) -> Result { + return switch state { + case let s as AST.ParserStateDirectTransition: + visitor.visit(node: s, driver: self, context: context) + case let s as AST.ParserStateNoTransition: + visitor.visit(node: s, driver: self, context: context) + case let s as AST.ParserStateSelectTransition: + visitor.visit(node: s, driver: self, context: context) + default: .Error(Error(withMessage: "AST State Element (\(state)) Is Not Visitable")) + } + } + + public func visit( + statement: any AST.AnStatement, visitor: any ASTVisitor, context: T + ) -> Result { + return switch statement { + case let s as AST.Parser: visitor.visit(node: s, driver: self, context: context) + default: .Error(Error(withMessage: "AST Statement Element Is Not Visitable")) + } + } + + public func visit( + program: AST.Program, visitor: any ASTVisitor, context: T + ) -> Result { + + var context = context + for s in program.statements { + switch visit(statement: s, visitor: visitor, context: context) { + case .Ok(let c): context = c + case .Error(let e): return .Error(e) + } + } + + return .Ok(context) + } +} diff --git a/Sources/P4Lang/Common.swift b/Sources/P4Lang/Common.swift deleted file mode 100644 index e69de29..0000000 diff --git a/Sources/P4Lang/Control.swift b/Sources/P4Lang/Control.swift deleted file mode 100644 index f47d125..0000000 --- a/Sources/P4Lang/Control.swift +++ /dev/null @@ -1,291 +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 . - -import Common - -public struct Action: CustomStringConvertible, P4Type, P4DataValue { - public func type() -> any P4Type { - return self - } - - public func eq(rhs: any Common.P4DataValue) -> Bool { - return switch rhs { - case let arhs as Action: self.name == arhs.name - default: false - } - } - - public func eq(rhs: any P4Type) -> Bool { - return switch rhs { - case is Action: true - default: false - } - } - public func lt(rhs: any Common.P4DataValue) -> Bool { - switch rhs { - case let arhs as Action: return self.name < arhs.name - default: return false - } - } - - public func lte(rhs: any Common.P4DataValue) -> Bool { - switch rhs { - case let arhs as Action: return self.name <= arhs.name - default: return false - } - - } - - public func gt(rhs: any Common.P4DataValue) -> Bool { - switch rhs { - case let arhs as Action: return self.name > arhs.name - default: return false - } - } - - public func gte(rhs: any Common.P4DataValue) -> Bool { - switch rhs { - case let arhs as Action: return self.name >= arhs.name - default: return false - } - } - - public func def() -> P4DataValue? { - return .none - } - - public var description: String { - return "Action: " - + "\(self.name) with parameters \(self.params) and body \(String(describing: self.body))" - } - - public var body: BlockStatement? - public var params: ParameterList - public var name: Identifier - - public init( - named name: Identifier = Identifier(name: ""), - withParameters parameters: ParameterList = ParameterList([]), - withBody body: BlockStatement? = .none - ) { - self.name = name - self.params = parameters - self.body = body - } - -} - -public struct Actions: CustomStringConvertible { - public let actions: [Action] - public init(withActions actions: [Action]) { - self.actions = actions - } - - public var description: String { - return "Actions: " - + actions.map { action in - return "\(action)" - }.joined(separator: ";") - } -} - -public enum TableKeyMatchType { - case Exact -} - -public struct TableKeyEntry: CustomStringConvertible { - public let key: KeysetExpression - public let match_type: TableKeyMatchType - - public init(_ key: KeysetExpression, _ match: TableKeyMatchType) { - self.key = key - self.match_type = match - } - - public var description: String { - return "Table Key Entry: " + "\(self.key): \(self.match_type)" - } -} - -public struct TableKeys: CustomStringConvertible { - public let keys: [TableKeyEntry] - - public init(withEntries entries: [TableKeyEntry]) { - self.keys = entries - } - public init() { - self.keys = [] - } - - public var description: String { - return "Table Keys: " - + self.keys.map { key in - return "\(key)" - }.joined(separator: ";") - } -} - -public struct TableActionsProperty: CustomStringConvertible { - public let actions: [TypedIdentifier] - public init(_ actions: [TypedIdentifier] = []) { - self.actions = actions - } - - public var description: String { - return "Table Actions: " - + self.actions.map { action in - return action.description - }.joined(separator: ";") - } -} - -public struct TablePropertyList: CustomStringConvertible { - public let actions: TableActionsProperty - public let keys: TableKeys - public init(withActions actions: TableActionsProperty, withKeys keys: TableKeys) { - self.actions = actions - self.keys = keys - } - - public var description: String { - return "Table Property List: \(self.actions) \(self.keys)" - } -} - -public struct Table: CustomStringConvertible { - public let properties: TablePropertyList - let name: Identifier - public let entries: [(P4Value, TypedIdentifier)] - - public init( - withName name: Identifier, withPropertyList property_list: TablePropertyList, - withEntries entries: [(P4Value, TypedIdentifier)] = [] - ) { - self.name = name - self.properties = property_list - self.entries = entries - } - - public var description: String { - return "Table named: \(self.name) \(self.properties)" - } - - /// When the control is evaluated, the value of the x in the table is - /// compared to the entries and the match is assocated with an action - /// that is invoked when the match occurs! - - public func update(addEntry entry: (P4Value, TypedIdentifier)) -> Table { - return Table( - withName: self.name, withPropertyList: self.properties, withEntries: self.entries + [entry]) - } -} - -public struct Control: P4Type, P4DataValue, Equatable, CustomStringConvertible { - public static func == (lhs: Control, rhs: Control) -> Bool { - // Two "bare" controls are always equal. - return true - } - - public func eq(rhs: any P4Type) -> Bool { - return switch rhs { - case is Control: true - default: false - } - } - - public func type() -> any P4Type { - return self - } - - // Any operation between two "bare" parser states is always true. - public func eq(rhs: any Common.P4DataValue) -> Bool { - return switch rhs { - case is Control: true - default: false - } - } - - public func lt(rhs: any Common.P4DataValue) -> Bool { - return switch rhs { - case is Control: true - default: false - } - } - - public func lte(rhs: any Common.P4DataValue) -> Bool { - return switch rhs { - case is Control: true - default: false - } - } - - public func gt(rhs: any Common.P4DataValue) -> Bool { - return switch rhs { - case is Control: true - default: false - } - } - - public func gte(rhs: any Common.P4DataValue) -> Bool { - return switch rhs { - case is Control: true - default: false - } - } - - public var description: String { - return "Control named \(self._name) \(self.parameters) \(self.actions) \(self.table)" - } - - public let actions: Actions - public let table: Table - let _parameters: ParameterList - let _name: Identifier - let apply: ApplyStatement - - public var parameters: ParameterList { - _parameters - } - - public var name: Identifier { - _name - } - - public init( - named: Identifier, withParameters parameters: ParameterList, withTable table: Table, - withActions actions: Actions, withApply apply: ApplyStatement - ) { - self._name = named - self._parameters = parameters - self.actions = actions - self.table = table - self.apply = apply - } - - public func updateTable(addEntry entry: (P4Value, TypedIdentifier)) -> Control { - let table = self.table.update(addEntry: entry) - - return Control( - named: self.name, withParameters: self.parameters, withTable: table, - withActions: self.actions, withApply: self.apply) - } - - public func def() -> P4DataValue? { - return .none - } - -} diff --git a/Sources/P4Lang/Declarations.swift b/Sources/P4Lang/Declarations.swift deleted file mode 100644 index e55fb67..0000000 --- a/Sources/P4Lang/Declarations.swift +++ /dev/null @@ -1,144 +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 . - -import Common - -public struct Declaration: P4Type { - public let identifier: TypedIdentifier - public let extern: Bool - public let ffi: P4FFI? - - public init(_ id: TypedIdentifier) { - identifier = id - ffi = .none - self.extern = false - } - - public init(extern: Declaration, ffi: P4FFI) { - identifier = extern.identifier - self.ffi = ffi - self.extern = true - } - - public func eq(rhs: any Common.P4Type) -> Bool { - return switch rhs { - case let rrhs as Declaration: - self.identifier.type.baseType().eq(rhs: rrhs.identifier.type.baseType()) - && self.extern == rrhs.extern - default: false - } - } - - public func def() -> P4DataValue? { - /// TODO: Is a default of the extern'd type the right way to go? - return self.identifier.type.baseType().def() - } - - public func type() -> any Common.P4Type { - return self - } - public var description: String { - return self.extern ? "Extern " : "" + "\(self.identifier)" - } -} - -public struct ExternDeclaration {} - -public struct FunctionDeclaration: P4Type, P4DataValue { - public func type() -> any Common.P4Type { - return self - } - - public func eq(rhs: any Common.P4Type) -> Bool { - switch rhs { - case let frhs as FunctionDeclaration: - return frhs.tipe.eq(self.tipe) && frhs.params == self.params - default: return false - } - } - - public func eq(rhs: any Common.P4DataValue) -> Bool { - switch rhs { - case let frhs as FunctionDeclaration: return self.eq(rhs: frhs as P4Type) - default: return false - } - } - - public func lt(rhs: any Common.P4DataValue) -> Bool { - switch rhs { - case let frhs as FunctionDeclaration: return self.name < frhs.name - default: return false - } - } - - public func lte(rhs: any Common.P4DataValue) -> Bool { - switch rhs { - case let frhs as FunctionDeclaration: return self.name <= frhs.name - default: return false - } - - } - - public func gt(rhs: any Common.P4DataValue) -> Bool { - switch rhs { - case let frhs as FunctionDeclaration: return self.name > frhs.name - default: return false - } - } - - public func gte(rhs: any Common.P4DataValue) -> Bool { - switch rhs { - case let frhs as FunctionDeclaration: return self.name >= frhs.name - default: return false - } - } - - public func def() -> P4DataValue? { - return .none - } - - public var description: String { - return "Function named \(self.name) that returns \(self.tipe) with parameters \(self.params)" - } - - public var body: BlockStatement? - public var params: ParameterList - public var name: Identifier - public var tipe: P4QualifiedType - - public init( - named name: Identifier, ofType type: P4QualifiedType, withParameters parameters: ParameterList, - withBody body: BlockStatement? - ) { - self.name = name - self.tipe = type - self.params = parameters - self.body = body - } -} - -public struct Instantiation { - public let name: Identifier - public let tipe: P4Type - public let arguments: ArgumentList - - public init(named name: Identifier, ofType tipe: P4Type, withArguments arguments: ArgumentList) { - self.name = name - self.tipe = tipe - self.arguments = arguments - } -} diff --git a/Sources/P4Lang/Expressions.swift b/Sources/P4Lang/Expressions.swift deleted file mode 100644 index cb49c7f..0000000 --- a/Sources/P4Lang/Expressions.swift +++ /dev/null @@ -1,149 +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 . - -import Common - -public struct KeysetExpression { - public let key: P4Expression - - public init(_ key: P4Expression) { - self.key = key - } - - public func compatible(type: P4QualifiedType) -> Result<()> { - if let key_type = self.key.type().baseType() as? P4Set { - if !key_type.set_type().eq(type) { - return .Error( - Error( - withMessage: - "Key expression of type set of type \(key_type.set_type()) is not compatible with selector type \(type)" - )) - } - } else if !self.key.type().eq(type) { - return .Error( - Error( - withMessage: - "Key expression of type \(self.key.type()) is not compatible with selector type \(type)" - )) - } - return .Ok(()) - } -} - -public struct SelectCaseExpression { - public let key: KeysetExpression - public let next_state_identifier: Identifier - public let next_state: ParserState? - - public init(withKey key: KeysetExpression, withNextState next_state_id: Identifier) { - self.key = key - self.next_state_identifier = next_state_id - self.next_state = .none - } - public init( - withKey key: KeysetExpression, withNextState next_state_id: Identifier, - withNextState next_state: ParserState? - ) { - self.key = key - self.next_state_identifier = next_state_id - self.next_state = next_state - } -} - -public struct SelectExpression { - public let selector: P4Expression - public let case_expressions: [SelectCaseExpression] - - public init( - withSelector selector: P4Expression, - withSelectCaseExpressions sces: [SelectCaseExpression] - ) { - self.selector = selector - self.case_expressions = sces - } - - public func append_checked_sce(sce: SelectCaseExpression) -> SelectExpression { - var new_cses = self.case_expressions - new_cses.append(sce) - return SelectExpression( - withSelector: self.selector, withSelectCaseExpressions: new_cses) - } -} - -public typealias NamedBinaryOperatorEvaluator = ( - String, P4QualifiedType, (P4Value, P4Value) -> P4DataValue -) -public typealias BinaryOperatorEvaluator = (P4Value, P4Value) -> P4DataValue - -public struct BinaryOperatorExpression { - public let evaluator: NamedBinaryOperatorEvaluator - public let left: EvaluatableExpression - public let right: EvaluatableExpression - - public init( - withEvaluator evaluator: NamedBinaryOperatorEvaluator, withLhs lhs: EvaluatableExpression, - withRhs rhs: EvaluatableExpression - ) { - self.evaluator = evaluator - self.left = lhs - self.right = rhs - } -} - -public struct ArrayAccessExpression { - public let indexor: P4Expression - public let name: P4Expression - public let type: P4Array - - public init( - withName name: P4Expression, withType type: P4Array, - withIndexor indexor: P4Expression - ) { - self.name = name - self.type = type - self.indexor = indexor - } -} - -public struct FieldAccessExpression { - public let field: P4StructFieldIdentifier - public let strct: P4Expression - - public init(withStruct strct: P4Expression, withField field: P4StructFieldIdentifier) { - self.strct = strct - self.field = field - } -} - -public struct FunctionCall { - public let callee: (FunctionDeclaration?, P4FFI?) - public let arguments: ArgumentList - public let return_type: P4Type - - public init(_ callee: FunctionDeclaration, withArguments arguments: ArgumentList) { - self.callee = (callee, .none) - self.arguments = arguments - self.return_type = callee.tipe.baseType() - } - - public init(_ callee: P4FFI, withArguments arguments: ArgumentList) { - self.callee = (.none, callee) - self.arguments = arguments - /// ASSUME: That the FFI has been checked and the type is always a function declaration. - self.return_type = (callee.type().baseType() as! FunctionDeclaration).tipe.baseType() - } -} diff --git a/Sources/P4Lang/FFI.swift b/Sources/P4Lang/FFI.swift deleted file mode 100644 index 37b6318..0000000 --- a/Sources/P4Lang/FFI.swift +++ /dev/null @@ -1,18 +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 . - -import Common diff --git a/Sources/P4Lang/Parser.swift b/Sources/P4Lang/Parser.swift deleted file mode 100644 index d4b2f55..0000000 --- a/Sources/P4Lang/Parser.swift +++ /dev/null @@ -1,395 +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 . - -import Common - -public struct LocalElements {} - -public struct LocalElement {} - -public struct ParserAssignmentStatement { - public let lvalue: P4LValueExpression - public let value: P4Expression - - public init( - withLValue lvalue: P4LValueExpression, withValue value: P4Expression - ) { - self.lvalue = lvalue - self.value = value - } -} - -/// A P4 Parser State -public class ParserState: P4Type, Equatable, CustomStringConvertible { - let name: Identifier - public let statements: [P4Statement] - - public static func == (lhs: ParserState, rhs: ParserState) -> Bool { - return lhs.eq(rhs: rhs) - } - - public func eq(rhs: any Common.P4Type) -> Bool { - return switch rhs { - case let rrhs as ParserState: self.name == rrhs.name - default: false - } - } - - public var description: String { - return "Parser State named \(self.name)" - } - - public func getName() -> Identifier { - return self.name - } - - public func getStatements() -> [P4Statement] { - return self.statements - } - - /// Construct a ParserState - public init(_ name: Identifier, _ statements: [P4Statement] = Array()) { - self.name = name - self.statements = statements - } - - public func def() -> P4DataValue? { - return .none - } - - public func instantiate(_ name: Identifier) -> InstantiatedParserState? { - return .none - } -} - -public class _AnyParserState: ParserState { - public override func eq(rhs: any Common.P4Type) -> Bool { - return switch rhs { - case is ParserState: true - default: false - } - } -} - -nonisolated(unsafe) public let AnyParserState = _AnyParserState(Identifier(name: "AnyParserState")) - -public struct TransitionStatement {} - -public class ParserStateDirectTransition: ParserState { - - public let next_state: InstantiatedParserState? - public let next_state_identifier: Identifier? - - /// Construct a ParserState - public init( - name: Identifier, withNextState next_state: InstantiatedParserState, - withStatements stmts: [P4Statement] = Array(), - ) { - self.next_state = next_state - self.next_state_identifier = .none - super.init(name, stmts) - } - - public init( - name: Identifier, withNextStateIdentifier next_state_id: Identifier, - withStatements stmts: [P4Statement] = Array(), - ) { - self.next_state = .none - self.next_state_identifier = next_state_id - super.init(name, stmts) - } - - public override func instantiate(_ name: Identifier) -> InstantiatedParserState? { - return if let next_state = self.next_state { - ParserStateDirectTransitionValue(name: name, withState: self, withNextState: next_state) - } else { - ParserStateDirectTransitionValue( - name: name, withState: self, withNextStateIdentifier: self.next_state_identifier!) - } - } -} - -public class ParserStateNoTransition: ParserState { - /// Construct a ParserState - public init( - name: Identifier, withStatements stmts: [P4Statement] = Array(), - ) { - super.init(name, stmts) - } - - public override func instantiate(_ name: Identifier) -> InstantiatedParserState? { - return ParserStateNoTransitionValue(name: name, withState: self) - } -} - -public class ParserStateSelectTransition: ParserState { - - public let te: SelectExpression - - public init( - name: Identifier, withTransitionExpression te: SelectExpression, - withStatements stmts: [P4Statement] = Array() - ) { - self.te = te - super.init(name, stmts) - } - - public override func instantiate(_ name: Identifier) -> InstantiatedParserState? { - return ParserStateSelectTransitionValue(name: name, withState: self, withSelectExpression: te) - } -} - -/// Instantiated Parser State -/// -public class InstantiatedParserState: P4DataValue { - public static func == (lhs: InstantiatedParserState, rhs: InstantiatedParserState) -> Bool { - return lhs.state == rhs.state - } - - public func type() -> any Common.P4Type { - return self.state - } - - public func eq(rhs: any Common.P4DataValue) -> Bool { - return switch rhs { - case let other as InstantiatedParserState: self.state == other.state - default: false - } - } - - public func lt(rhs: any Common.P4DataValue) -> Bool { - return switch rhs { - case let other as InstantiatedParserState: self.state.getName() < other.state.getName() - default: false - } - } - - public func lte(rhs: any Common.P4DataValue) -> Bool { - return switch rhs { - case let other as InstantiatedParserState: self.state.getName() <= other.state.getName() - default: false - } - } - - public func gt(rhs: any Common.P4DataValue) -> Bool { - return switch rhs { - case let other as InstantiatedParserState: self.state.getName() > other.state.getName() - default: false - } - } - - public func gte(rhs: any Common.P4DataValue) -> Bool { - return switch rhs { - case let other as InstantiatedParserState: self.state.getName() >= other.state.getName() - default: false - } - } - - public private(set) var state: ParserState - public private(set) var name: Identifier - - public var description: String { - return "Instance of state of type \(state) named \(name)" - } - - public init(_ name: Identifier, _ state: ParserState) { - self.name = name - self.state = state - } -} - -public class ParserStateDirectTransitionValue: InstantiatedParserState { - public let next_state: InstantiatedParserState? - public let next_state_identifier: Identifier? - - public init( - name: Identifier, withState state: ParserStateDirectTransition, - withNextState next_state: InstantiatedParserState - ) { - self.next_state = next_state - self.next_state_identifier = .none - super.init(name, state) - } - - public init( - name: Identifier, withState state: ParserStateDirectTransition, - withNextStateIdentifier next_state_id: Identifier - ) { - self.next_state = .none - self.next_state_identifier = next_state_id - super.init(name, state) - } -} - -public class ParserStateNoTransitionValue: InstantiatedParserState { - public init(name: Identifier, withState state: ParserStateNoTransition) { - super.init(name, state) - } -} - -public class ParserStateSelectTransitionValue: InstantiatedParserState { - public let te: SelectExpression - public init( - name: Identifier, withState state: ParserStateSelectTransition, - withSelectExpression te: SelectExpression - ) { - self.te = te - super.init(name, state) - } -} - -nonisolated(unsafe) private let accept_type = ParserStateNoTransition( - name: Identifier(name: "accept"), withStatements: []) -nonisolated(unsafe) private let reject_type = ParserStateNoTransition( - name: Identifier(name: "reject"), withStatements: []) - -nonisolated(unsafe) public let accept = ParserStateNoTransitionValue( - name: Identifier(name: "accept"), withState: accept_type) -nonisolated(unsafe) public let reject = ParserStateNoTransitionValue( - name: Identifier(name: "reject"), withState: reject_type) - -public struct ParserStates { - public var states: [ParserState] = Array() - - public func count() -> Int { - return states.count - } - - public func find(withIdentifier id: Identifier) -> ParserState? { - for state in states { - if state.getName() == id { - return .some(state) - } - } - return .none - } - - public init(_ states: [ParserState] = Array()) { - self.states = states - } - - public func append(state: ParserState) -> ParserStates { - var new_states = self.states - new_states.append(state) - return ParserStates(new_states) - } -} - -/// A P4 Parser -/// -/// Note: A Parser is a type -public struct Parser: P4Type { - public var states: ParserStates - - public var name: Identifier - public var parameters: ParameterList - - public init(withName name: Identifier) { - self.states = ParserStates() - self.parameters = ParameterList() - self.name = name - } - - public init(withName name: Identifier, withParameters parameters: ParameterList) { - self.states = ParserStates() - self.parameters = parameters - self.name = name - } - - public func findStartState() -> ParserState? { - return self.states.find(withIdentifier: Identifier(name: "start")) - } - - public var description: String { - return "Parser \(self.name) with parameters: \(parameters) and states: \(self.states)" - } - - public func def() -> P4DataValue? { - return .none - } - - public func eq(rhs: any Common.P4Type) -> Bool { - return switch rhs { - case let parser_rhs as Parser: self.name == parser_rhs.name - default: false - } - } - - public func instantiate(_ name: Identifier) -> ParserValue { - return ParserValue(self, name) - } -} - -/// A instance of a P4 Parser -/// -public struct ParserValue: P4DataValue { - public func type() -> P4Type { - return self.tipe - } - - public func eq(rhs: any Common.P4DataValue) -> Bool { - return switch rhs { - case let rrhs as ParserValue: rrhs.type().eq(rhs: self.type()) && self.name == rrhs.name - default: false - } - } - - public func lt(rhs: any Common.P4DataValue) -> Bool { - return switch rhs { - case let rrhs as ParserValue: rrhs.type().eq(rhs: self.type()) && self.name < rrhs.name - default: false - } - } - - public func lte(rhs: any Common.P4DataValue) -> Bool { - return switch rhs { - case let rrhs as ParserValue: rrhs.type().eq(rhs: self.type()) && self.name <= rrhs.name - default: false - } - } - - public func gt(rhs: any Common.P4DataValue) -> Bool { - return switch rhs { - case let rrhs as ParserValue: rrhs.type().eq(rhs: self.type()) && self.name > rrhs.name - default: false - } - } - - public func gte(rhs: any Common.P4DataValue) -> Bool { - return switch rhs { - case let rrhs as ParserValue: rrhs.type().eq(rhs: self.type()) && self.name >= rrhs.name - default: false - } - } - - public var tipe: Parser - public var name: Identifier - - public init(_ tipe: Parser, _ name: Identifier) { - self.tipe = tipe - self.name = name - } - - public var description: String { - return "Parser \(self.name) of type \(self.tipe)" - } - - public func def() -> P4DataValue? { - return self.tipe.def() - } - -} diff --git a/Sources/P4Lang/Program.swift b/Sources/P4Lang/Program.swift deleted file mode 100644 index 97afb00..0000000 --- a/Sources/P4Lang/Program.swift +++ /dev/null @@ -1,127 +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 . - -import Common - -public struct ExpressionStatement { - public let expression: P4Expression - - public init(_ expr: P4Expression) { - self.expression = expr - } -} - -public struct Program { - public var types: [P4Type] = Array() - public var externs: [P4Type] = Array() - public var instances: [P4Value] = Array() - - /// Type of closure for filtering results from ``Program/InstancesWithTypes(_:)`` - public typealias TypeFilter = (P4QualifiedType) -> Bool - /// Type of closure for filtering results from ``Program/TypesWithTypes(_:)`` - public typealias DataTypeFilter = (P4Type) -> Bool - - /// Retrieve global instances in the compiled P4 program. - public func InstancesWithTypes() -> [P4Value] { - return self.instances - } - - /// Retrieve global instances in the compiled P4 program. - /// - /// Use the given filter to select which of the global instances - /// from the compiled P4 program to retrieve. - /// - /// If the compiled P4 program (from the source in the - /// string `p4_program_with_control_decl`) has two Control - /// instances and you only want to select the one named simple, - /// you could use a filter like - /// - /// @Snippet(path: "use-program-instanceswithtypes", slice: "include") - /// - public func InstancesWithTypes(_ filter: TypeFilter) -> [P4Value] { - return self.instances.filter { instance in - filter(instance.type()) - } - } - - /// Retrieve global types in the compiled P4 program. - public func TypesWithTypes() -> [P4Type] { - return self.types - } - - /// Retrieve global types declared in the compiled P4 program. - /// - /// Use the given filter to select which of the global types - /// declared in the compiled P4 program to retrieve. - /// - /// If the compiled P4 program (from the source in the - /// string `p4_program_with_struct_decl`) has two structs declared and - /// you only want to select the one named `agg`, you could - /// use a filter like - /// - /// @Snippet(path: "use-program-typeswithtypes", slice: "include") - /// - public func TypesWithTypes(_ filter: DataTypeFilter) -> [P4Type] { - return self.types.filter { instance in - filter(instance) - } - } - - /// Retrieve extern types in the compiled P4 program. - public func Externs() -> [P4Type] { - return self.externs - } - - /// Retrieve extern types declared in the compiled P4 program. - /// - /// Use the given filter to select which of the extern types - /// declared in the compiled P4 program to retrieve. - /// - /// If the compiled P4 program (from the source in the - /// string `p4_program_with_struct_decl`) has two extern structs declared and - /// you only want to select the one named `agg`, you could - /// use a filter like - /// - /// @Snippet(path: "use-program-typeswithtypes", slice: "include") - /// - public func Externs(_ filter: DataTypeFilter) -> [P4Type] { - return self.externs.filter { instance in - filter(instance) - } - } - - /// Find the program's main parser - /// - /// Note: For now, the main parser is expected to be named main_parser. - public func starting_parser() -> Result { - return self.find_parser(withName: Identifier(name: "main_parser")) - } - - public func find_parser(withName name: Identifier) -> Result { - for instance in self.types { - guard let parser = instance as? Parser else { - continue - } - if parser.name == name { - return .Ok(parser) - } - } - return .Error(Error(withMessage: "Could not find parser named \(name)")) - } - - public init() {} -} diff --git a/Sources/P4Lang/Protocols.swift b/Sources/P4Lang/Protocols.swift deleted file mode 100644 index 98bbbde..0000000 --- a/Sources/P4Lang/Protocols.swift +++ /dev/null @@ -1,95 +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 . - -import Common - -public protocol Visitable { - -} - -public protocol LanguageVisitor { - associatedtype Context - - // Program - func visit(_ program: Program, _ c: VisitorContext) -> Result> - - // Parser - func visit(_ parser: Parser, _ c: VisitorContext) -> Result> - func visit( - _ parser_state: InstantiatedParserState, _ c: VisitorContext - ) -> Result> - - // Statements - func visit( - _ variable_declaration: VariableDeclarationStatement, _ c: VisitorContext - ) -> Result> - func visit( - _ conditional: ConditionalStatement, _ c: VisitorContext - ) -> Result> - func visit( - _ block: BlockStatement, _ c: VisitorContext - ) -> Result> - func visit( - _ rtn: ReturnStatement, _ c: VisitorContext - ) -> Result> - func visit( - _ apply: ApplyStatement, _ c: VisitorContext - ) -> Result> - - // Expressions - func visit( - _ keyset: KeysetExpression, _ c: VisitorContext - ) -> Result> - func visit( - _ select_case: SelectCaseExpression, _ c: VisitorContext - ) -> Result> - func visit( - _ select: SelectExpression, _ c: VisitorContext - ) -> Result> - func visit( - _ array_access: ArrayAccessExpression, _ c: VisitorContext - ) -> Result> - func visit( - _ field_access: FieldAccessExpression, _ c: VisitorContext - ) -> Result> - func visit( - _ function_call: FunctionCall, _ c: VisitorContext - ) -> Result> - func visit( - _ binary_operator: BinaryOperatorExpression, _ c: VisitorContext - ) -> Result> - - // Declarations - func visit(_ decl: Declaration, _ c: VisitorContext) -> Result> - func visit( - _ extern_decl: ExternDeclaration, _ c: VisitorContext - ) -> Result> - func visit( - _ func_decl: FunctionDeclaration, _ c: VisitorContext - ) -> Result> - - // Control - func visit(_ action: Action, _ c: VisitorContext) -> Result> - func visit( - _ table_key_entry: TableKeyEntry, _ c: VisitorContext - ) -> Result> - func visit( - _ table_property_list: TablePropertyList, _ c: VisitorContext - ) -> Result> - func visit(_ table: Table, _ c: VisitorContext) -> Result> - func visit(_ control: Control, _ c: VisitorContext) -> Result> -} diff --git a/Sources/P4Lang/Statement.swift b/Sources/P4Lang/Statement.swift deleted file mode 100644 index 66e3123..0000000 --- a/Sources/P4Lang/Statement.swift +++ /dev/null @@ -1,76 +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 . - -import Common - -public struct Statement {} - -public struct VariableDeclarationStatement { - public var initializer: P4Expression - public var identifier: TypedIdentifier - public init(identifier: TypedIdentifier, withInitializer initializer: P4Expression) { - self.identifier = identifier - self.initializer = initializer - } -} - -public struct ConditionalStatement { - public var condition: P4Expression - public var thenn: P4Statement - public var elss: P4Statement? - - public init(condition: P4Expression, withThen thenn: P4Statement) { - self.condition = condition - self.thenn = thenn - self.elss = .none - } - - public init( - condition: P4Expression, withThen thenn: P4Statement, - andElse elss: P4Statement - ) { - self.condition = condition - self.thenn = thenn - self.elss = elss - } -} - -public struct BlockStatement { - public var statements: [P4Statement] - - public init(_ statements: [P4Statement]) { - self.statements = statements - } - -} - -public struct ReturnStatement { - public let value: P4Expression - - public init(_ value: P4Expression) { - self.value = value - } -} - -public struct ApplyStatement { - public let body: BlockStatement? - - public init() { self.body = .none } - public init(_ body: BlockStatement) { - self.body = body - } -} diff --git a/Sources/P4Lang/Visitor.swift b/Sources/P4Lang/Visitor.swift deleted file mode 100644 index a3a9117..0000000 --- a/Sources/P4Lang/Visitor.swift +++ /dev/null @@ -1,130 +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 . - -import Common - -// Witness the parts of a P4 Program that are visitable. -extension Program: Visitable {} -extension Parser: Visitable {} -extension ParserState: Visitable {} -extension VariableDeclarationStatement: Visitable {} -extension ConditionalStatement: Visitable {} -extension BlockStatement: Visitable {} -extension ReturnStatement: Visitable {} -extension ApplyStatement: Visitable {} -extension KeysetExpression: Visitable {} -extension SelectCaseExpression: Visitable {} -extension SelectExpression: Visitable {} -extension ArrayAccessExpression: Visitable {} -extension FieldAccessExpression: Visitable {} -extension FunctionCall: Visitable {} -extension BinaryOperatorExpression: Visitable {} -extension Declaration: Visitable {} -extension ExternDeclaration: Visitable {} -extension FunctionDeclaration: Visitable {} -extension Action: Visitable {} -extension TableKeyEntry: Visitable {} -extension TablePropertyList: Visitable {} -extension Table: Visitable {} -extension Control: Visitable {} - -/// Context for the visiting process. -public struct VisitorContext { - let visitor: VisitorDriver - let uc: UserContext - public init(_ v: VisitorDriver, _ uc: UserContext) { - self.visitor = v - self.uc = uc - } - - public func getUserContext() -> UserContext { - return self.uc - } - - public func getVisitorDriver() -> VisitorDriver { - return self.visitor - } - - public func next(uc: UserContext) -> VisitorContext { - return VisitorContext(self.visitor, uc) - } -} - -/// A driver for visiting the components of a parsed P4 program. -public struct VisitorDriver { - let visitor: any LanguageVisitor - - public init(_ visitor: any LanguageVisitor) { - self.visitor = visitor - } - - public func generateContext(uc: UserContext) -> VisitorContext { - return VisitorContext(self, uc) - } - - /// Visit a `P4Type`. - public func visit( - _ t: P4Type, context: VisitorContext - ) -> Result> { - return switch t { - case let vv as Control: visitor.visit(vv, context) - case let vv as Parser: visitor.visit(vv, context) - default: .Error(Error(withMessage: "Could not visit type \(t)")) - } - } - - /// Visit a part of a P4 program. - public func visit( - _ v: Visitable, context: VisitorContext - ) -> Result> { - return switch v { - case let vv as Program: visitor.visit(vv, context) - case let vv as Parser: visitor.visit(vv, context) - case let vv as InstantiatedParserState: visitor.visit(vv, context) - case let vv as VariableDeclarationStatement: visitor.visit(vv, context) - case let vv as ConditionalStatement: visitor.visit(vv, context) - case let vv as BlockStatement: visitor.visit(vv, context) - case let vv as ReturnStatement: visitor.visit(vv, context) - case let vv as ApplyStatement: visitor.visit(vv, context) - case let vv as KeysetExpression: visitor.visit(vv, context) - case let vv as SelectCaseExpression: visitor.visit(vv, context) - case let vv as SelectExpression: visitor.visit(vv, context) - case let vv as ArrayAccessExpression: visitor.visit(vv, context) - case let vv as FieldAccessExpression: visitor.visit(vv, context) - case let vv as FunctionCall: visitor.visit(vv, context) - case let vv as BinaryOperatorExpression: visitor.visit(vv, context) - case let vv as Declaration: visitor.visit(vv, context) - case let vv as ExternDeclaration: visitor.visit(vv, context) - case let vv as FunctionDeclaration: visitor.visit(vv, context) - case let vv as Action: visitor.visit(vv, context) - case let vv as TableKeyEntry: visitor.visit(vv, context) - case let vv as TablePropertyList: visitor.visit(vv, context) - case let vv as Table: visitor.visit(vv, context) - case let vv as Control: visitor.visit(vv, context) - default: .Error(Error(withMessage: "Could not visit \(v)")) - } - } - - /// Start the process of visiting a P4 program. - public func start(_ v: Visitable, context: UserContext) -> Result { - let visit_result = self.visit(v, context: VisitorContext(self, context)) - return switch visit_result { - case .Ok(let vc): .Ok(vc.getUserContext()) - case .Error(let e): .Error(e) - } - } -} diff --git a/Sources/P4Runtime/CodeGen.swift b/Sources/P4Runtime/CodeGen.swift deleted file mode 100644 index 40d68b9..0000000 --- a/Sources/P4Runtime/CodeGen.swift +++ /dev/null @@ -1,291 +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 . - -import Common -import P4Lang - -public struct Generated { - let gen: String - public init(_ base: String = "") { - self.gen = base - } - - public func getGeneratedCode() -> String { - return self.gen - } - - public func append(_ a: String) -> Generated { - return Generated(self.gen + a) - } -} - -/// Generate code for a P4 program. -/// -/// See the [P4 behavioral model](https://github.com/p4lang/behavioral-model) for -/// the format. -public struct CodeGenerator: LanguageVisitor { - - public init() {} - - /// Generate code. - public func codeGen(_ node: any Visitable) -> Result { - let visitor = VisitorDriver(self) - let generated = Generated() - return visitor.start(node, context: generated) - } - - public typealias Context = Generated - - public func visit( - _ v: Program, _ c: VisitorContext - ) -> Result> { - - var result: Result> = Fold( - input: v.types, initial: .Ok(c.next(uc: c.getUserContext().append("["))) - ) { (current, acc) in - return switch acc { - case .Ok(let acc): acc.getVisitorDriver().visit(current, context: acc) - case .Error(let e): .Error(e) - } - } - - result = Fold( - input: v.externs, initial: result - ) { (current, acc) in - return switch acc { - case .Ok(let acc): acc.getVisitorDriver().visit(current, context: acc) - case .Error(let e): .Error(e) - } - } - - /// TODO: Handle instances. - /* - result = Fold( - input: v.instances, initial: result - ) { (current, acc) in - return switch acc { - case .Ok(let acc): acc.getVisitorDriver().visit(current, context: acc) - case .Error(let e): .Error(e) - } - }*/ - - result = result.map { - .Ok($0.next(uc: $0.getUserContext().append("]"))) - } - - return result - } - - public func visit( - _ v: Parser, _ c: VisitorContext - ) -> Result> { - var initial = "{" - initial += "name: \"\(v.name)\"," - initial += "init_state: \"start\"," - initial += "parse_states: [" - - let result: Result> = Fold( - input: v.states.states, initial: .Ok(c.next(uc: c.getUserContext().append(initial))) - ) { (current, acc) in - return switch acc { - case .Ok(let acc): - switch self.visit(current, acc) { - case .Ok(let gend): .Ok(gend.next(uc: gend.getUserContext().append(","))) - case .Error(let e): .Error(e) - } - case .Error(let e): .Error(e) - } - } - - return result.map { - .Ok($0.next(uc: $0.getUserContext().append("]}"))) - } - } - - public func visit( - _ v: ParserState, _ c: VisitorContext - ) -> Result> { - let direct_transition_codegen = { - ( - _: ParserStateDirectTransition, c: VisitorContext - ) -> Result> in - return .Ok(c.next(uc: c.getUserContext().append("[]"))) - } - - let no_transition_codegen = { - ( - _: ParserStateNoTransition, c: VisitorContext - ) -> Result> in - return .Ok(c.next(uc: c.getUserContext().append("[]"))) - } - - let select_transition_codegen = { - ( - state: ParserStateSelectTransition, c: VisitorContext - ) -> Result> in - return switch self.visit(state.te, c.next(uc: c.getUserContext().append("["))) { - case .Ok(let res): .Ok(res.next(uc: res.getUserContext().append("]"))) - case .Error(let e): .Error(e) - } - } - - var initial = "{" - initial += "name: \"\(v.getName())\"," - initial += "transitions: " - - let result: Result> = - switch v { - case let s as ParserStateSelectTransition: - select_transition_codegen(s, c.next(uc: c.getUserContext().append(initial))) - case let s as ParserStateDirectTransition: - direct_transition_codegen(s, c.next(uc: c.getUserContext().append(initial))) - case let s as ParserStateNoTransition: - no_transition_codegen(s, c.next(uc: c.getUserContext().append(initial))) - default: - .Error(Error(withMessage: "Could not code gen \(self)")) - } - - return result.map { - .Ok($0.next(uc: $0.getUserContext().append("}"))) - } - } - - public func visit( - _ v: VariableDeclarationStatement, _ c: VisitorContext - ) -> Result> { - - return .Ok(c) - } - - public func visit( - _ v: ConditionalStatement, _ c: VisitorContext - ) -> Result> { - return .Ok(c) - } - - public func visit( - _ v: BlockStatement, _ c: VisitorContext - ) -> Result> { - return .Ok(c) - } - - public func visit( - _ v: ReturnStatement, _ c: VisitorContext - ) -> Result> { - return .Ok(c) - } - - public func visit( - _ v: ApplyStatement, _ c: VisitorContext - ) -> Result> { - return .Ok(c) - } - - public func visit( - _ v: KeysetExpression, _ c: VisitorContext - ) -> Result> { - return .Ok(c) - } - - public func visit( - _ v: SelectCaseExpression, _ c: VisitorContext - ) -> Result> { - return .Ok(c) - } - - public func visit( - _ v: SelectExpression, _ c: VisitorContext - ) -> Result> { - return .Ok(c.next(uc: c.getUserContext().append("Select"))) - } - - public func visit( - _ v: ArrayAccessExpression, _ c: VisitorContext - ) -> Result> { - return .Ok(c) - } - - public func visit( - _ v: FieldAccessExpression, _ c: VisitorContext - ) -> Result> { - return .Ok(c) - } - - public func visit( - _ v: FunctionCall, _ c: VisitorContext - ) -> Result> { - return .Ok(c) - } - - public func visit( - _ v: BinaryOperatorExpression, _ c: VisitorContext - ) -> Result> { - return .Ok(c) - } - - public func visit( - _ v: Declaration, _ c: VisitorContext - ) -> Result> { - return .Ok(c) - } - - public func visit( - _ v: ExternDeclaration, _ c: VisitorContext - ) -> Result> { - return .Ok(c) - } - - public func visit( - _ v: FunctionDeclaration, _ c: VisitorContext - ) -> Result> { - return .Ok(c) - } - - public func visit( - _ v: Action, _ c: VisitorContext - ) -> Result> { - return .Ok(c) - } - - public func visit( - _ v: TableKeyEntry, _ c: VisitorContext - ) -> Result> { - return .Ok(c) - } - - public func visit( - _ v: TablePropertyList, _ c: VisitorContext - ) -> Result> { - return .Ok(c) - } - - public func visit(_ v: Table, _ c: VisitorContext) -> Result> - { - return .Ok(c) - } - - public func visit( - _ v: Control, _ c: VisitorContext - ) -> Result> { - return .Ok(c) - } - public func visit( - _ parser_state: InstantiatedParserState, _ c: VisitorContext - ) -> Common.Result> { - return .Ok(c) - } -} diff --git a/Sources/P4Runtime/Common.swift b/Sources/P4Runtime/Common.swift deleted file mode 100644 index 2516e08..0000000 --- a/Sources/P4Runtime/Common.swift +++ /dev/null @@ -1,86 +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 . - -import Common -import P4Lang - -public func Call( - body: (ProgramExecution) -> (Result, ProgramExecution), withArguments args: ArgumentList, - withParameters params: ParameterList, inExecution execution: ProgramExecution -) -> (Result, ProgramExecution) { - - if case .Error(let e) = args.compatible(params) { - return (.Error(e), execution) - } - - var called_execution = execution.enter_scope() - - for (parameter, argument) in zip(params.parameters, args.arguments) { - let arg_idx = argument.index - let arg_value = argument.argument - //let maybe_argument_value = arg_value.evaluate(execution: called_execution) - let maybe_argument_value = called_execution.evaluator.EvaluateExpression( - arg_value, inExecution: called_execution) - guard case (.Ok(let argument_value), let updated_execution) = maybe_argument_value else { - return ( - .Error(Error(withMessage: "Cannot evaluate argument \(arg_idx): \(argument)")), - called_execution.exit_scope() - ) - } - called_execution = updated_execution.declare( - identifier: parameter.name, withValue: argument_value) - } - - let (maybe_call_result, updated_execution) = body(called_execution) - guard case .Ok(let call_result) = maybe_call_result else { - return (.Error(maybe_call_result.error()!), updated_execution.exit_scope()) - } - - // Before returning, update the (in)out parameters! - var inout_scopes = updated_execution.exit_scope().scopes - - for (parameter, argument) in zip(params.parameters, args.arguments) { - if let param_direction = parameter.type.direction(), - param_direction == Direction.InOut || param_direction == Direction.Out - { - // Let's make sure that it is an evaluatable l value! - guard let arg_lvalue = argument.argument as? P4LValueExpression else { - return ( - .Error(Error(withMessage: "(in)out parameter argument is not lvalue")), - updated_execution.exit_scope() - ) - } - - guard - case .Ok(let arg_new_value) = updated_execution.scopes.lookup(identifier: parameter.name) - else { - return ( - .Error(Error(withMessage: "Could not get (in)out parameter value from scope")), - updated_execution.exit_scope() - ) - } - - switch arg_lvalue.set( - to: arg_new_value, inScopes: inout_scopes, duringExecution: updated_execution) - { - case .Ok((let updated_scopes, _)): inout_scopes = updated_scopes - case .Error(let e): return (.Error(e), updated_execution.exit_scope()) - } - } - } - return (.Ok(call_result), updated_execution.replaceScopes(inout_scopes)) -} diff --git a/Sources/P4Runtime/Control.swift b/Sources/P4Runtime/Control.swift deleted file mode 100644 index 22a6c9b..0000000 --- a/Sources/P4Runtime/Control.swift +++ /dev/null @@ -1,108 +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 . - -import Common -import P4Lang - -extension Control: LibraryCallable { - public typealias T = P4TableHitMissValue - public func call( - execution: Common.ProgramExecution, arguments: ArgumentList - ) -> (P4TableHitMissValue, Common.ProgramExecution) { - - var control_execution = execution.enter_scope() - - // Add initial values to the global scope - for (name, value) in execution.getGlobalValues() { - control_execution = control_execution.declare(identifier: name, withValue: value) - } - - let call_body: (ProgramExecution) -> (Result, ProgramExecution) = { - execution in - var control_execution = execution - - for action in self.actions.actions { - control_execution = control_execution.declare( - identifier: action.name, withValue: P4Value(action)) - } - - for key in self.table.properties.keys.keys { - // Every evaluation of the key starts from an unchanged execution context. - let (key_eval, updated_execution) = key.key.evaluate(execution: control_execution) - - guard case .Ok(let key_val) = key_eval else { - return (.Error(key_eval.error()!), updated_execution) - } - - /// ASSUME: The first matching entry is the one to do. - /// TODO: Check whether this matches architecture. - for (val, action) in self.table.entries { - - // Skip those with mismatching types. - - if !val.type().eq(key_val.type()) { - continue - } - - /// ASSUME: All matches are exact. - if val.eq(key_val) { - // Lookup action! - - let maybe_action = updated_execution.scopes.lookup(identifier: action) - guard case .Ok(let action) = maybe_action else { - return (.Error(maybe_action.error()!), updated_execution) - } - - let aaction = (action.dataValue() as! Action) - - return switch aaction.evaluate(execution: updated_execution) { - case (ControlFlow.Error, let updated_execution): - (.Error(updated_execution.getError()!), updated_execution) - case (_, let updated_execution): (.Ok(P4TableHitMissValue.Hit), updated_execution) - } - } - } - } - return (.Ok(P4TableHitMissValue.Miss), control_execution) - } - - switch Call( - body: call_body, withArguments: arguments, withParameters: self.parameters, - inExecution: control_execution) - { - case (.Ok(let r), let updated_execution): return (r, updated_execution) - case (.Error(let e), let updated_execution): - return (P4TableHitMissValue.Miss, updated_execution.setError(error: e)) - } - } -} - -extension Action: P4Statement { - public func effect(context: Common.CompilerContext) -> Common.CompilerContext { - return context - } - - public func evaluate( - execution: Common.ProgramExecution - ) -> (ControlFlow, Common.ProgramExecution) { - if let body = self.body { - return body.evaluate(execution: execution) - } - - return (ControlFlow.Next, execution) - } -} diff --git a/Sources/P4Runtime/Expressions.swift b/Sources/P4Runtime/Expressions.swift deleted file mode 100644 index 4e243c1..0000000 --- a/Sources/P4Runtime/Expressions.swift +++ /dev/null @@ -1,562 +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 . - -import Common -import P4Lang - -extension SelectCaseExpression: EvaluatableExpression { - public func evaluate(execution: ProgramExecution) -> (Result, ProgramExecution) { - return (execution.scopes.lookup(identifier: next_state_identifier), execution) - } - public func type() -> P4QualifiedType { - return P4QualifiedType(AnyParserState) - } - public func effect(context: CompilerContext) -> CompilerContext { - return context - } -} - -public func binary_equal_operator_evaluator(left: P4Value, right: P4Value) -> P4DataValue { - return Map(input: left.dataValue().eq(rhs: right.dataValue())) { input in - P4BooleanValue(withValue: input) - } -} - -public func binary_lt_operator_evaluator(left: P4Value, right: P4Value) -> P4DataValue { - return Map(input: left.dataValue().lt(rhs: right.dataValue())) { input in - P4BooleanValue(withValue: input) - } -} - -public func binary_lte_operator_evaluator(left: P4Value, right: P4Value) -> P4DataValue { - return Map(input: left.dataValue().lte(rhs: right.dataValue())) { input in - P4BooleanValue(withValue: input) - } -} - -public func binary_gt_operator_evaluator(left: P4Value, right: P4Value) -> P4DataValue { - return Map(input: left.dataValue().gt(rhs: right.dataValue())) { input in - P4BooleanValue(withValue: input) - } -} - -public func binary_gte_operator_evaluator(left: P4Value, right: P4Value) -> P4DataValue { - return Map(input: left.dataValue().gte(rhs: right.dataValue())) { input in - P4BooleanValue(withValue: input) - } -} - -public func binary_and_operator_evaluator(left: P4Value, right: P4Value) -> P4DataValue { - let bleft = left.dataValue() as! P4BooleanValue - let bright = right.dataValue() as! P4BooleanValue - return Map(input: bleft.access() && bright.access()) { input in - P4BooleanValue(withValue: input) - } -} - -public func binary_or_operator_evaluator(left: P4Value, right: P4Value) -> P4DataValue { - let bleft = left.dataValue() as! P4BooleanValue - let bright = right.dataValue() as! P4BooleanValue - return Map(input: bleft.access() || bright.access()) { input in - P4BooleanValue(withValue: input) - } -} - -public func binary_add_operator_evaluator(left: P4Value, right: P4Value) -> P4DataValue { - let ileft = left.dataValue() as! P4IntValue - let iright = right.dataValue() as! P4IntValue - return Map(input: ileft.access() + iright.access()) { input in - P4IntValue(withValue: input) - } -} - -public func binary_subtract_operator_evaluator(left: P4Value, right: P4Value) -> P4DataValue { - let ileft = left.dataValue() as! P4IntValue - let iright = right.dataValue() as! P4IntValue - return Map(input: ileft.access() - iright.access()) { input in - P4IntValue(withValue: input) - } -} - -public func binary_multiply_operator_evaluator(left: P4Value, right: P4Value) -> P4DataValue { - let ileft = left.dataValue() as! P4IntValue - let iright = right.dataValue() as! P4IntValue - return Map(input: ileft.access() * iright.access()) { input in - P4IntValue(withValue: input) - } -} - -public func binary_divide_operator_evaluator(left: P4Value, right: P4Value) -> P4DataValue { - let ileft = left.dataValue() as! P4IntValue - let iright = right.dataValue() as! P4IntValue - return Map(input: ileft.access() / iright.access()) { input in - P4IntValue(withValue: input) - } -} - -// swift-format-ignore -public typealias BinaryOperatorChecker = (EvaluatableExpression, P4Expression) -> Result<()> - -public func binary_and_or_operator_checker( - left: EvaluatableExpression, right: EvaluatableExpression -) -> Result<()> { - // Check that both are Boolean-typed things! - if !(left.type().baseType().eq(rhs: P4Boolean()) && right.type().baseType().eq(rhs: P4Boolean())) - { - return .Error(Error(withMessage: "And/Or on operands with non-bool type is not allowed")) - } - return .Ok(()) -} - -public func binary_int_math_operator_checker( - left: EvaluatableExpression, right: EvaluatableExpression -) -> Result<()> { - // Check that both are int-typed things! - if !(left.type().baseType().eq(rhs: P4Int()) && right.type().baseType().eq(rhs: P4Int())) { - return .Error( - Error(withMessage: "Mathematical operation on operands with non-int type is not allowed")) - } - return .Ok(()) -} - -extension BinaryOperatorExpression: EvaluatableExpression { - public func effect(context: CompilerContext) -> CompilerContext { - return context - } - - public func evaluate(execution: ProgramExecution) -> (Result, ProgramExecution) { - let updated_execution = execution - //let maybe_evaluated_left = self.left.evaluate(execution: updated_execution) - let maybe_evaluated_left = updated_execution.evaluator.EvaluateExpression( - self.left, inExecution: updated_execution) - guard case (.Ok(let evaluated_left), let updated_execution) = maybe_evaluated_left else { - return maybe_evaluated_left - } - - //let maybe_evaluated_right = self.right.evaluate(execution: updated_execution) - let maybe_evaluated_right = updated_execution.evaluator.EvaluateExpression( - self.right, inExecution: updated_execution) - guard case (.Ok(let evaluated_right), let updated_execution) = maybe_evaluated_right else { - return maybe_evaluated_right - } - - return (.Ok(P4Value(self.evaluator.2(evaluated_left, evaluated_right))), updated_execution) - } - - public func type() -> P4QualifiedType { - return self.evaluator.1 - } -} - -extension ArrayAccessExpression: EvaluatableExpression, EvaluatableLValueExpression { - - public func effect(context: CompilerContext) -> CompilerContext { - return context - } - public func evaluate(execution: ProgramExecution) -> (Result, ProgramExecution) { - let updated_execution = execution - //let maybe_name = self.name.evaluate(execution: updated_execution) - let maybe_name = updated_execution.evaluator.EvaluateExpression( - self.name, inExecution: updated_execution) - guard case (.Ok(let name), let updated_execution) = maybe_name else { - return maybe_name - } - - //let maybe_indexor = self.indexor.evaluate(execution: updated_execution) - let maybe_indexor = updated_execution.evaluator.EvaluateExpression( - self.indexor, inExecution: updated_execution) - guard case (.Ok(let indexor), let updated_execution) = maybe_indexor else { - return maybe_indexor - } - - guard let indexor_int = indexor.dataValue() as? P4IntValue else { - return (.Error(Error(withMessage: "\(indexor) cannot index an array")), updated_execution) - } - - guard let array = name.dataValue() as? P4ArrayValue else { - return (.Error(Error(withMessage: "\(name) does not name an array")), updated_execution) - } - let accessed = array.access(indexor_int.access()) - - return (.Ok(accessed), updated_execution) - } - - public func type() -> P4QualifiedType { - return self.type.value_type() - } - - public func set( - to: P4Value, inScopes scopes: Common.VarValueScopes, - duringExecution execution: ProgramExecution - ) -> Common.Result<(Common.VarValueScopes, P4Value)> { - - let updated_execution = execution - //let maybe_value = self.name.evaluate(execution: updated_execution) - let maybe_value = updated_execution.evaluator.EvaluateExpression( - self.name, inExecution: updated_execution) - guard case (.Ok(let value), let updated_execution) = maybe_value else { - return .Error( - Error(withMessage: "\(self.name) cannot be evaluated: \(maybe_value.0.error()!)")) - } - guard let array_value = value.dataValue() as? P4ArrayValue else { - return Result.Error(Error(withMessage: "\(self.name) does not identify an array")) - } - - // Now, get the indexor! - //let maybe_indexor_value = self.indexor.evaluate(execution: updated_execution) - let maybe_indexor_value = updated_execution.evaluator.EvaluateExpression( - self.indexor, inExecution: updated_execution) - guard case (.Ok(let indexor_value), let updated_execution) = maybe_indexor_value else { - return Result.Error( - Error(withMessage: "\(self.indexor) cannot be evaluated: \(maybe_indexor_value.0.error()!)") - ) - } - guard let indexor_int = indexor_value.dataValue() as? P4IntValue else { - return Result.Error(Error(withMessage: "\(self.indexor) cannot be used to index an array")) - } - - // Now we have an array and an index! - - let maybe_updated_array_data_value = array_value.set(index: indexor_int.access(), to: to) - guard case .Ok(let new_array_value) = maybe_updated_array_data_value else { - return .Error(maybe_updated_array_data_value.error()!) - } - - let maybe_updated_array_value = value.update(withNewValue: new_array_value) - guard case .Ok(let updated_array_value) = maybe_updated_array_value else { - return .Error(maybe_updated_array_value.error()!) - } - - let array_lvalue = self.name as! EvaluatableLValueExpression - return array_lvalue.set( - to: updated_array_value, inScopes: scopes, duringExecution: updated_execution) - } - - public func check( - to: any Common.EvaluatableExpression, inScopes scopes: Common.StaticVarValueScopes - ) -> Common.Result<()> { - - return switch self.type.value_type().assignableFromType(to.type()) { - case TypeCheckResults.IncompatibleTypes: - .Error( - Error( - withMessage: - "Cannot assign value of type \(to.type()) to array with values of type \(self.name.type())" - )) - case TypeCheckResults.ReadOnly: - .Error( - Error( - withMessage: "Cannot assign value of type \(to.type()) to array \(self) that is read only" - )) - case TypeCheckResults.WrongDirection: - .Error( - Error( - withMessage: - "Cannot assign value of type \(to.type()) to array \(self) that is in parameter")) - case TypeCheckResults.Ok: - // Now, check the type of the array itself. - switch self.name.type().assignable() { - case TypeCheckResults.ReadOnly: - .Error(Error(withMessage: "Cannot assign to array \(self) that is read only")) - case TypeCheckResults.WrongDirection: - .Error(Error(withMessage: "Cannot assign to array \(self) that is in parameter")) - case TypeCheckResults.Ok: .Ok(()) - default: .Error(Error(withMessage: "Cannot assign to array \(self)")) - } - } - } -} - -extension FieldAccessExpression: EvaluatableExpression, EvaluatableLValueExpression { - public func type() -> P4QualifiedType { - return self.field.type - } - public func effect(context: CompilerContext) -> CompilerContext { - return context - } - public func set( - to: P4Value, inScopes scopes: Common.VarValueScopes, - duringExecution execution: ProgramExecution - ) -> Common.Result<(Common.VarValueScopes, P4Value)> { - // For purposes of documentation, assume the field access expression we are evaluating is - // (strct_id).field_id = new_field_value - // where strct_id expands to - // (identifier.field_id1.field_id2...).field_id = new_field_value - - let updated_execution = execution - // First, evaluate strct_id and make sure that it names a struct. - //let maybe_value = self.strct.evaluate(execution: updated_execution) - let maybe_value = updated_execution.evaluator.EvaluateExpression( - self.strct, inExecution: updated_execution) - guard case (.Ok(let value), let updated_execution) = maybe_value else { - return .Error( - Error(withMessage: "\(self.strct) cannot be evaluated: \(maybe_value.0.error()!)")) - } - - guard let struct_value = value.dataValue() as? P4StructValue else { - return .Error(Error(withMessage: "\(self.strct) does not identify a struct")) - } - - // Now we know that struct_id identifies a structure value. - - // Update field_id of that structure and get the new structure value. - let maybe_new_struct_data_value = struct_value.set(field: self.field, to: to) - guard case .Ok(let new_struct_data_value) = maybe_new_struct_data_value else { - return .Error(maybe_new_struct_data_value.error()!) - } - - let maybe_new_struct_value = value.update(withNewValue: new_struct_data_value) - guard case .Ok(let new_struct_value) = maybe_new_struct_value else { - return .Error(maybe_new_struct_value.error()!) - } - - // That new structure value should be assignable to the lvalue that is strct_id. - // We use recursion here -- ultimately finding our way to a TypedIdentifier that - // will update the scope. Pretty cool! - let struct_lvalue = self.strct as! EvaluatableLValueExpression - return struct_lvalue.set( - to: new_struct_value, inScopes: scopes, duringExecution: updated_execution) - } - - public func check( - to: any Common.EvaluatableExpression, inScopes scopes: Common.StaticVarValueScopes - ) -> Common.Result<()> { - return switch self.field.type().assignableFromType(to.type()) { - case TypeCheckResults.IncompatibleTypes: - .Error( - Error( - withMessage: - "Cannot assign value of type \(to.type()) to field \(self.field) of type \(self.type())" - )) - case TypeCheckResults.ReadOnly: - .Error( - Error( - withMessage: - "Cannot assign value of type \(to.type()) to field \(self.field) that is read only" - )) - case TypeCheckResults.Ok: - // Now, check the type of the struct itself. - switch self.strct.type().assignable() { - case TypeCheckResults.ReadOnly: - .Error( - Error( - withMessage: "Cannot assign to field \(self.field) of \(self.strct) that is read only")) - case TypeCheckResults.WrongDirection: - .Error( - Error( - withMessage: - "Cannot assign to field \(self.field) of \(self.strct) that is in parameter")) - case TypeCheckResults.Ok: .Ok(()) - default: .Error(Error(withMessage: "Cannot assign to field \(self.field) of \(self.strct)")) - } - default: .Error(Error(withMessage: "Cannot assign to field \(self.field) of \(self.strct)")) - } - } - public func evaluate(execution: ProgramExecution) -> (Result, ProgramExecution) { - - let updated_execution = execution - //let maybe_struct = self.strct.evaluate(execution: updated_execution) - let maybe_struct = updated_execution.evaluator.EvaluateExpression( - self.strct, inExecution: updated_execution) - guard case (.Ok(let strct), let updated_execution) = maybe_struct else { - return maybe_struct - } - - guard let struct_strct = strct.dataValue() as? P4StructValue else { - return (.Error(Error(withMessage: "\(strct) does not identify a struct")), updated_execution) - } - - /// TODO: Create a default value? - guard let value = struct_strct.get(field: self.field) else { - return (.Error(Error(withMessage: "Missing value")), updated_execution) - } - - return (.Ok(value), updated_execution) - } -} - -extension KeysetExpression: EvaluatableExpression { - public func effect(context: CompilerContext) -> CompilerContext { - return context - } - public func evaluate(execution: ProgramExecution) -> (Result, ProgramExecution) { - //return self.key.evaluate(execution: execution) - return execution.evaluator.EvaluateExpression(self.key, inExecution: execution) - } - - public func type() -> P4QualifiedType { - return self.key.type() - } -} - -extension FunctionCall: EvaluatableExpression { - - public func effect(context: CompilerContext) -> CompilerContext { - return context - } - public func evaluate( - execution: Common.ProgramExecution - ) -> (Common.Result, ProgramExecution) { - - let body_params: - Result<((ProgramExecution) -> (ControlFlow, ProgramExecution), ParameterList)> = - switch self.callee { - case (.some(let callee), .none): - switch callee.body { - case .some(let body): - .Ok( - ( - { (execution: ProgramExecution) -> (ControlFlow, ProgramExecution) in - return body.evaluate(execution: execution) - }, callee.params - )) - case .none: .Error(Error(withMessage: "No body for called function (\(callee.name))")) - } - case (.none, .some(let callee)): - .Ok( - ( - { (execution: ProgramExecution) -> (ControlFlow, ProgramExecution) in - return callee.execute(execution: execution) - }, callee.parameters() - )) - default: .Error(Error(withMessage: "No callee found for function call")) - } - - guard case .Ok(let body) = body_params else { - return (.Error(body_params.error()!), execution) - } - - let call_body: (ProgramExecution) -> (Result, ProgramExecution) = { - (execution: ProgramExecution) in - let (control_flow, updated_execution) = body.0(execution) - return switch control_flow { - case ControlFlow.Return(.some(let value)): (.Ok(value), updated_execution) - default: - ( - .Error( - Error(withMessage: "No value returned from called function")), - execution - ) - } - } - - return Call( - body: call_body, withArguments: self.arguments, withParameters: body.1, - inExecution: execution) - } - - public func type() -> P4QualifiedType { - return P4QualifiedType(self.return_type) - } -} - -extension P4Value: EvaluatableExpression { - public func evaluate(execution: ProgramExecution) -> (Result, ProgramExecution) { - return (.Ok(self), execution) - } - - public func effect(context: CompilerContext) -> CompilerContext { - return context - } -} - -extension SelectExpression: EvaluatableExpression { - public func evaluate(execution: ProgramExecution) -> (Result, ProgramExecution) { - switch execution.evaluator.EvaluateExpression(self.selector, inExecution: execution) { - case (.Ok(let selector_value), let updated_execution): - for sce in self.case_expressions { - if case (.Ok(let kse), let updated_execution) = updated_execution.evaluator - .EvaluateExpression( - sce.key, inExecution: updated_execution), - kse.eq(selector_value) - { - //let result = sce.evaluate(execution: updated_execution) - let result = updated_execution.evaluator.EvaluateExpression( - sce, inExecution: updated_execution) - return result - } - } - return (.Error(Error(withMessage: "No key matched the selector")), updated_execution) - case (.Error(let e), let updated_execution): return (.Error(e), updated_execution) - } - } - - public func type() -> P4QualifiedType { - return P4QualifiedType(AnyParserState) - } - - public func effect(context: CompilerContext) -> CompilerContext { - return context - } -} - -// Variables are evaluatable because they can be looked up by identifiers. -extension TypedIdentifier: EvaluatableExpression, EvaluatableLValueExpression { - public func evaluate( - execution: Common.ProgramExecution - ) -> (Common.Result, Common.ProgramExecution) { - return (execution.scopes.lookup(identifier: self), execution) - } - - public func set( - to: P4Value, inScopes scopes: Common.VarValueScopes, - duringExecution execution: ProgramExecution - ) -> Common.Result<(Common.VarValueScopes, P4Value)> { - if case .Error(let e) = scopes.lookup(identifier: self) { - return .Error(e) - } - - return .Ok((scopes.set(identifier: self, withValue: to), to)) - } - - public func type() -> P4QualifiedType { - return self.type - } - - public func effect(context: CompilerContext) -> CompilerContext { - return context - } - - // Variables are evaluatable because they can be looked up by identifiers. - public func check( - to: P4Expression, inScopes scopes: Common.StaticVarValueScopes - ) -> Result<()> { - guard case .Ok(let type) = scopes.lookup(identifier: self) else { - return .Error(Error(withMessage: "Cannot assign to identifier not in scope")) - } - - return switch type.0.assignableFromType(to.type()) { - case TypeCheckResults.IncompatibleTypes: - .Error( - Error( - withMessage: - "Cannot assign value with type \(to.type()) to identifier \(self) with type \(type.0)")) - case TypeCheckResults.ReadOnly: - .Error( - Error( - withMessage: - "Cannot assign value with type \(to.type()) to identifier \(self) that is read only")) - case TypeCheckResults.WrongDirection: - .Error( - Error( - withMessage: - "Cannot assign value with type \(to.type()) to identifier \(self) that is in parameter") - ) - case TypeCheckResults.Ok: .Ok(()) - } - } -} diff --git a/Sources/P4Runtime/Parser.swift b/Sources/P4Runtime/Parser.swift deleted file mode 100644 index 028cb93..0000000 --- a/Sources/P4Runtime/Parser.swift +++ /dev/null @@ -1,214 +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 . - -import Common -import P4Lang - -extension ParserAssignmentStatement: P4Statement { - public func effect(context: Common.CompilerContext) -> Common.CompilerContext { - return context - } - - public func evaluate(execution: ProgramExecution) -> (ControlFlow, ProgramExecution) { - let updated_execution = execution - //let result = self.value.evaluate(execution: updated_execution) - let result = updated_execution.evaluator.EvaluateExpression( - self.value, inExecution: updated_execution) - guard case (.Ok(let value), let updated_execution) = result else { - return (ControlFlow.Error, execution.setError(error: result.0.error()!)) - } - - let maybe_updated_scopes = self.lvalue.set( - to: value, inScopes: execution.scopes, duringExecution: updated_execution) - guard case Result.Ok(let updated_scopes) = maybe_updated_scopes else { - return (ControlFlow.Error, execution.setError(error: maybe_updated_scopes.error()!)) - } - execution.scopes = updated_scopes.0 - - return (ControlFlow.Next, updated_execution) - } -} - -extension ParserStateDirectTransitionValue: EvaluatableParserState { - public func execute( - program: Common.ProgramExecution - ) -> (any EvaluatableParserState, Common.ProgramExecution) { - var program = program.enter_scope() - - let (control_flow, next_execution) = program.evaluator.ExecuteStatements( - self.state.statements, inExecution: program) - - switch control_flow { - case .Next: program = next_execution - case .Error: return (reject, next_execution.exit_scope()) - default: - return ( - reject, - next_execution.exit_scope().setError( - error: Error(withMessage: "Invalid control flow (\(control_flow) in parser)")) - ) - } - - return (self.next_state as! EvaluatableParserState, program.exit_scope()) - } - - public func done() -> Bool { - return false - } - - public func state() -> ParserState { - return self.state - } -} - -extension ParserStateNoTransitionValue: EvaluatableParserState { - public func execute( - program: Common.ProgramExecution - ) -> (any EvaluatableParserState, Common.ProgramExecution) { - return (self, program) - } - - public func done() -> Bool { - return true - } - - public func state() -> ParserState { - return self.state - } -} - -extension ParserStateSelectTransitionValue: EvaluatableParserState { - public func execute( - program: Common.ProgramExecution - ) -> (any EvaluatableParserState, Common.ProgramExecution) { - var program = program.enter_scope() - - let (control_flow, next_execution) = program.evaluator.ExecuteStatements( - self.state.statements, inExecution: program) - switch control_flow { - case .Next: program = next_execution - case .Error: return (reject, next_execution.exit_scope()) - default: - return ( - reject, - next_execution.exit_scope().setError( - error: Error(withMessage: "Invalid control flow (\(control_flow) in parser)")) - ) - } - - switch program.evaluator.EvaluateExpression(self.te, inExecution: program) { - case (.Ok(let value), let program): - if AnyParserState.eq(rhs: value.type().baseType()) { - return (value.dataValue() as! EvaluatableParserState, program.exit_scope()) - } else { - return ( - self, - program.setError( - error: Error(withMessage: "Select transition transitioned to a none state")) - ) - } - case (.Error(let e), let program): return (self, program.setError(error: e).exit_scope()) - } - } - - public func done() -> Bool { - return false - } - - public func state() -> ParserState { - return self.state - } -} - -extension ParserValue: LibraryCallable { - public typealias T = InstantiatedParserState - public func call( - execution: Common.ProgramExecution, arguments: ArgumentList - ) -> (InstantiatedParserState, Common.ProgramExecution) { - var execution = execution.enter_scope() - - execution = execution.declare( - identifier: accept.state().getName(), - withValue: P4Value(accept, P4QualifiedType.ReadOnly(accept.type()))) - execution = execution.declare( - identifier: reject.state().getName(), - withValue: P4Value(reject, P4QualifiedType.ReadOnly(reject.type()))) - - // Add initial values to the global scope - for (name, value) in execution.getGlobalValues() { - execution = execution.declare(identifier: name, withValue: value) - } - - // First, add every state to the scope! - for state in self.tipe.states.states { - guard let instantiated_state = state.instantiate(state.getName()) else { - return ( - reject, - execution.setError(error: Error(withMessage: "Could not instantiate \(state.getName())")) - ) - } - execution = execution.declare( - identifier: state.getName(), withValue: P4Value(instantiated_state)) - } - - guard let _current_state = self.tipe.findStartState(), - var current_state = _current_state.instantiate(Identifier(name: "start")) - as? EvaluatableParserState - else { - return ( - reject, execution.setError(error: Error(withMessage: "Could not find the start state")) - ) - } - - let call_body: (ProgramExecution) -> (Result, ProgramExecution) = { - (execution: ProgramExecution) in - var current_execution = execution - // Evaluate until the state is either accept or reject. - while !current_state.done() && !current_execution.hasError() { - (current_state, current_execution) = current_state.execute(program: current_execution) - } - return (.Ok(P4Value((current_state))), current_execution) - } - - return - switch Call( - body: call_body, withArguments: arguments, withParameters: self.tipe.parameters, - inExecution: execution) - { - case (.Ok(let value), let updated_execution): - (value.dataValue() as! InstantiatedParserState, updated_execution) - case (.Error(let e), let updated_execution): - (reject, updated_execution.setError(error: Error(withMessage: "Cannot call parser: \(e)"))) - } - } -} - -extension ParserState: P4Statement { - public func evaluate( - execution: Common.ProgramExecution - ) -> (Common.ControlFlow, Common.ProgramExecution) { - return ( - ControlFlow.Error, - execution.setError(error: Error(withMessage: "Cannot evaluate unspecialized parser state")) - ) - } - - public func effect(context: Common.CompilerContext) -> Common.CompilerContext { - return context.update( - newTypes: context.types.declare(identifier: self.getName(), withValue: self)) - } -} diff --git a/Sources/P4Runtime/Protocols.swift b/Sources/P4Runtime/Protocols.swift deleted file mode 100644 index c131ea0..0000000 --- a/Sources/P4Runtime/Protocols.swift +++ /dev/null @@ -1,35 +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 . - -import Common -import P4Lang - -public protocol Execution { - func execute(execution: ProgramExecution) -> ProgramExecution -} - -public protocol EvaluatableParserState: P4DataValue { - func execute(program: ProgramExecution) -> (EvaluatableParserState, ProgramExecution) - func done() -> Bool - func state() -> ParserState -} - -/// Defines an interface for P4 components that can be invoked directly by the p4rse library user -public protocol LibraryCallable { - associatedtype T - func call(execution: ProgramExecution, arguments: ArgumentList) -> (T, ProgramExecution) -} diff --git a/Sources/P4Runtime/Runtime.swift b/Sources/P4Runtime/Runtime.swift deleted file mode 100644 index 8ffc932..0000000 --- a/Sources/P4Runtime/Runtime.swift +++ /dev/null @@ -1,92 +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 . - -import Common -import P4Lang - -/// The runtime for a parser -public struct Runtime>: CustomStringConvertible { - public var callable: T - - let initialValues: VarValueScopes? - - init(callable: T) { - self.callable = callable - self.initialValues = .none - } - - init(callable: T, withGlobalValues initial: VarValueScopes?) { - self.callable = callable - self.initialValues = initial - } - - /// Create a parser runtime from a P4 program - public static func create( - program: Program - ) -> Result> { - return Runtime.create(program: program, withGlobalValues: .none) - } - - public static func create( - program: Program, withGlobalValues initial: VarValueScopes? - ) -> Result> { - return switch program.starting_parser() { - case .Ok(let parser): - .Ok( - P4Runtime.Runtime( - callable: parser.instantiate(Identifier(name: "starting_parser")), - withGlobalValues: initial)) - case .Error(let error): .Error(error) - } - } - - public static func create( - control: Control, withGlobalValues initial: VarValueScopes? - ) -> Result> { - return .Ok( - P4Runtime.Runtime(callable: control, withGlobalValues: initial)) - } - - /// Run a P4 parser with no arguments - public func run() -> Result<(U, ProgramExecution)> { - return self.run(withArguments: ArgumentList([])) - - } - - /// Run the P4 parser on a given packet - public func run( - withArguments arguments: ArgumentList, inExecution pe: ProgramExecution = ProgramExecution() - ) -> Result<(U, ProgramExecution)> { - - let npe = - if let globals = initialValues { - pe.setGlobalValues(globals) - } else { - pe - } - - let (end_state, execution) = callable.call(execution: npe, arguments: arguments) - if let error = execution.getError() { - return .Error(error) - } - return .Ok((end_state, execution)) - } - - public var description: String { - return "Runtime:\nExecution: \(callable)" - } -} diff --git a/Sources/P4Runtime/Statements.swift b/Sources/P4Runtime/Statements.swift deleted file mode 100644 index 71a856a..0000000 --- a/Sources/P4Runtime/Statements.swift +++ /dev/null @@ -1,193 +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 . - -import Common -import P4Lang - -extension BlockStatement: P4Statement { - public func effect(context: Common.CompilerContext) -> Common.CompilerContext { - return context - } - - public func evaluate(execution: ProgramExecution) -> (ControlFlow, ProgramExecution) { - return execution.evaluator.ExecuteStatements( - self.statements, inExecution: execution - ) { (cf, execution) in - switch cf { - case ControlFlow.Return(let value): return (ControlFlow.Return(value), execution) - case ControlFlow.Next: return (cf, execution) - case ControlFlow.Error: return (ControlFlow.Error, execution) - default: - return ( - ControlFlow.Error, - execution.setError( - error: Error(withMessage: "Invalid control flow \(cf) in block statement")) - ) - } - } - } -} - -extension VariableDeclarationStatement: P4Statement { - public func effect(context: Common.CompilerContext) -> Common.CompilerContext { - return context.update( - newInstances: context.instances.declare( - identifier: self.identifier, withValue: (self.identifier.type(), .none))) - - } - - public func evaluate(execution: ProgramExecution) -> (ControlFlow, ProgramExecution) { - guard - //case (.Ok(let initial_value), let execution) = self.initializer.evaluate(execution: execution) - case (.Ok(let initial_value), let execution) = execution.evaluator.EvaluateExpression( - self.initializer, inExecution: execution) - else { - return ( - ControlFlow.Error, - execution.setError(error: Error(withMessage: "Could not evaluate \(self.initializer)")) - ) - } - let new_scopes = execution.scopes.declare(identifier: self.identifier, withValue: initial_value) - execution.scopes = new_scopes - return (ControlFlow.Next, execution) - } -} - -extension ConditionalStatement: P4Statement { - public func effect(context: Common.CompilerContext) -> Common.CompilerContext { - return context - } - - public func evaluate(execution: ProgramExecution) -> (ControlFlow, ProgramExecution) { - guard - //case (.Ok(let evaluated_condition), let execution) = self.condition.evaluate(execution: execution) - case (.Ok(let evaluated_condition), let execution) = execution.evaluator.EvaluateExpression( - self.condition, inExecution: execution) - else { - return ( - ControlFlow.Error, - execution.setError(error: Error(withMessage: "Could not evaluate \(self.condition)")) - ) - } - - if !evaluated_condition.type().baseType().eq(rhs: P4Boolean()) { - return ( - ControlFlow.Error, - execution.setError(error: Error(withMessage: "Condition expression is not a Boolean")) - ) - } - - if evaluated_condition.dataValue().eq(rhs: P4BooleanValue.init(withValue: true)) { - let execution = execution.enter_scope() - switch self.thenn.evaluate(execution: execution) { - case (ControlFlow.Next, let result): return (ControlFlow.Next, result.exit_scope()) - case (ControlFlow.Error, let result): return (ControlFlow.Error, result.exit_scope()) - case (let cf, let result): - return ( - ControlFlow.Next, - result.setError( - error: Error(withMessage: "Invalid control flow \(cf) in conditional statement")) - ) - } - } else if let elss = self.elss { - let execution = execution.enter_scope() - switch elss.evaluate(execution: execution) { - case (ControlFlow.Next, let result): return (ControlFlow.Next, result.exit_scope()) - case (ControlFlow.Error, let result): return (ControlFlow.Error, result.exit_scope()) - case (let cf, let result): - return ( - ControlFlow.Next, - result.setError( - error: Error(withMessage: "Invalid control flow \(cf) in conditional statement")) - ) - } - } - return (ControlFlow.Next, execution) - } -} - -extension ExpressionStatement: P4Statement { - public func effect(context: Common.CompilerContext) -> Common.CompilerContext { - return context - } - - public func evaluate(execution: ProgramExecution) -> (ControlFlow, ProgramExecution) { - - // Evaluate, there might be side effects! - //return switch self.expression.evaluate(execution: execution) { - return switch execution.evaluator.EvaluateExpression(self.expression, inExecution: execution) { - case (.Ok(_), let updated_context): (ControlFlow.Next, updated_context) - case (.Error(let e), let updated_context): - (ControlFlow.Next, updated_context.setError(error: e)) - } - } -} - -extension ReturnStatement: P4Statement { - public func effect(context: Common.CompilerContext) -> Common.CompilerContext { - - return context - } - - public func evaluate(execution: ProgramExecution) -> (ControlFlow, ProgramExecution) { - //return switch self.value.evaluate(execution: execution) { - return switch execution.evaluator.EvaluateExpression(self.value, inExecution: execution) { - case (.Ok(let v), let execution): (ControlFlow.Return(v), execution) - case (.Error(let e), let execution): (ControlFlow.Error, execution.setError(error: e)) - } - } -} - -extension ApplyStatement: P4Statement { - public func effect(context: Common.CompilerContext) -> Common.CompilerContext { - - return context - } - - public func evaluate(execution: ProgramExecution) -> (ControlFlow, ProgramExecution) { - return (ControlFlow.Next, execution) - } -} - -extension Instantiation: P4Statement { - public func effect(context: Common.CompilerContext) -> Common.CompilerContext { - return context - } - - public func evaluate(execution: ProgramExecution) -> (ControlFlow, ProgramExecution) { - return (ControlFlow.Next, execution) - } -} - -extension Declaration: P4Statement { - public func effect(context: Common.CompilerContext) -> Common.CompilerContext { - if self.extern { - return context.update( - newExterns: context.externs.declare( - identifier: self.identifier, withValue: self)) - } - - return context.update( - newTypes: context.types.declare( - identifier: self.identifier, withValue: self.identifier.type().baseType())) - } - - public func evaluate(execution: ProgramExecution) -> (ControlFlow, ProgramExecution) { - //// TODO - return (ControlFlow.Next, execution) - } -} diff --git a/Tests/p4rseTests/ArrayTests.swift b/Tests/p4rseTests/ArrayTests.swift deleted file mode 100644 index b203091..0000000 --- a/Tests/p4rseTests/ArrayTests.swift +++ /dev/null @@ -1,335 +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 . - -import Common -import Foundation -import Macros -import P4Lang -import P4Runtime -import SwiftTreeSitter -import Testing -import TreeSitter -import TreeSitterP4 - -@testable import P4Compiler - -@Test func test_array_access() async throws { - let simple_parser_declaration = """ - parser main_parser() { - state start { - bool where_to = ta[1] == 2; - transition select (where_to) { - true: accept; - false: reject; - }; - } - }; - """ - var test_declarations = StaticVarValueScopes().enter() - test_declarations = test_declarations.declare( - identifier: Identifier(name: "ta"), - withValue: (P4QualifiedType(P4Array(withValueType: P4QualifiedType(P4Int()))), .none)) - - var test_values = VarValueScopes().enter() - - test_values = test_values.declare( - identifier: Identifier(name: "ta"), - withValue: P4Value( - P4ArrayValue( - withType: P4QualifiedType(P4Int()), - withValue: [ - P4Value(P4IntValue(withValue: 1)), P4Value(P4IntValue(withValue: 2)), - P4Value(P4IntValue(withValue: 3)), - ]))) - let program = try #UseOkResult( - SpecialCompilers.ProgramCompiler.Compile(simple_parser_declaration, withGlobalInstances: test_declarations)) - let runtime = try #UseOkResult( - P4Runtime.Runtime.create( - program: program, withGlobalValues: test_values)) - let (state_result, _) = try! #UseOkResult(runtime.run()) - - #expect(state_result == P4Lang.accept) -} - -@Test func test_array_access_invalid_type() async throws { - let simple_parser_declaration = """ - parser main_parser() { - state start { - bool where_to = ta[1]; - transition select (where_to) { - true: accept; - false: reject; - }; - } - }; - """ - var test_declarations = StaticVarValueScopes().enter() - test_declarations = test_declarations.declare( - identifier: Identifier(name: "ta"), withValue: (P4QualifiedType(P4Int()), .none)) - - #expect( - #RequireErrorResult( - Error( - withMessage: - "{49, 22}: Failed to parse a statement element: {65, 2}: ta does not name an array type" - ), - SpecialCompilers.ProgramCompiler.Compile(simple_parser_declaration, withGlobalInstances: test_declarations)) - ) -} - -@Test func test_array_access2() async throws { - let simple_parser_declaration = """ - parser main_parser() { - state start { - bool where_to = ta[0] == 2; - transition select (where_to) { - true: accept; - false: reject; - }; - } - }; - """ - var test_declarations = StaticVarValueScopes().enter() - test_declarations = test_declarations.declare( - identifier: Identifier(name: "ta"), - withValue: (P4QualifiedType(P4Array(withValueType: P4QualifiedType(P4Int()))), .none)) - var test_values = VarValueScopes().enter() - - test_values = test_values.declare( - identifier: Identifier(name: "ta"), - withValue: P4Value( - P4ArrayValue( - withType: P4QualifiedType(P4Int()), - withValue: [ - P4Value(P4IntValue(withValue: 1)), P4Value(P4IntValue(withValue: 2)), - P4Value(P4IntValue(withValue: 3)), - ]))) - let program = try #UseOkResult( - SpecialCompilers.ProgramCompiler.Compile(simple_parser_declaration, withGlobalInstances: test_declarations)) - let runtime = try #UseOkResult( - P4Runtime.Runtime.create( - program: program, withGlobalValues: test_values)) - let (state_result, _) = try! #UseOkResult(runtime.run()) - - #expect(state_result == P4Lang.reject) -} - -@Test func test_array_access3() async throws { - let simple_parser_declaration = """ - parser main_parser() { - state start { - transition select (ta[0] == 1) { - true: accept; - false: reject; - }; - } - }; - """ - var test_declarations = StaticVarValueScopes().enter() - test_declarations = test_declarations.declare( - identifier: Identifier(name: "ta"), - withValue: (P4QualifiedType(P4Array(withValueType: P4QualifiedType(P4Int()))), .none)) - - var test_values = VarValueScopes().enter() - test_values = test_values.declare( - identifier: Identifier(name: "ta"), - withValue: P4Value( - P4ArrayValue( - withType: P4QualifiedType(P4Int()), - withValue: [ - P4Value(P4IntValue(withValue: 1)), P4Value(P4IntValue(withValue: 2)), - P4Value(P4IntValue(withValue: 3)), - ]))) - let program = try #UseOkResult( - SpecialCompilers.ProgramCompiler.Compile(simple_parser_declaration, withGlobalInstances: test_declarations)) - let runtime = try #UseOkResult( - P4Runtime.Runtime.create( - program: program, withGlobalValues: test_values)) - let (state_result, _) = try! #UseOkResult(runtime.run()) - - #expect(state_result == P4Lang.accept) -} - -@Test func test_array_access4() async throws { - let simple_parser_declaration = """ - parser main_parser() { - state start { - transition select (ta[1] == 2) { - true: accept; - false: reject; - }; - } - }; - """ - var test_declarations = StaticVarValueScopes().enter() - test_declarations = test_declarations.declare( - identifier: Identifier(name: "ta"), - withValue: (P4QualifiedType(P4Array(withValueType: P4QualifiedType(P4Int()))), .none)) - var test_values = VarValueScopes().enter() - test_values = test_values.declare( - identifier: Identifier(name: "ta"), - withValue: P4Value( - P4ArrayValue( - withType: P4QualifiedType(P4Int()), - withValue: [ - P4Value(P4IntValue(withValue: 1)), P4Value(P4IntValue(withValue: 2)), - P4Value(P4IntValue(withValue: 3)), - ]))) - let program = try #UseOkResult( - SpecialCompilers.ProgramCompiler.Compile(simple_parser_declaration, withGlobalInstances: test_declarations)) - let runtime = try #UseOkResult( - P4Runtime.Runtime.create( - program: program, withGlobalValues: test_values)) - let (state_result, _) = try! #UseOkResult(runtime.run()) - - #expect(state_result == P4Lang.accept) -} - -@Test func test_array_access_nested() async throws { - let simple_parser_declaration = """ - parser main_parser() { - state start { - int where_to = ta[0][0]; - transition select (where_to == 5) { - true: accept; - false: reject; - }; - } - }; - """ - var test_declarations = StaticVarValueScopes().enter() - test_declarations = test_declarations.declare( - identifier: Identifier(name: "ta"), - withValue: ( - P4QualifiedType( - P4Array(withValueType: P4QualifiedType(P4Array(withValueType: P4QualifiedType(P4Int()))))), - .none - )) - var test_values = VarValueScopes().enter() - - let nested = P4Value( - P4ArrayValue( - withType: P4QualifiedType(P4Int()), - withValue: [ - P4Value(P4IntValue(withValue: 5)), P4Value(P4IntValue(withValue: 2)), - P4Value(P4IntValue(withValue: 3)), - ])) - - test_values = test_values.declare( - identifier: Identifier(name: "ta"), - withValue: P4Value( - P4ArrayValue( - withType: P4QualifiedType(P4Array(withValueType: P4QualifiedType(P4Int()))), - withValue: [nested]))) - - let program = try #UseOkResult( - SpecialCompilers.ProgramCompiler.Compile(simple_parser_declaration, withGlobalInstances: test_declarations)) - let runtime = try #UseOkResult( - P4Runtime.Runtime.create( - program: program, withGlobalValues: test_values)) - let (state_result, _) = try! #UseOkResult(runtime.run()) - - #expect(state_result == P4Lang.accept) -} - -@Test func test_array_set() async throws { - let simple_parser_declaration = """ - parser main_parser() { - state start { - ta[1] = 3; - bool where_to = ta[1] == 3; - transition select (where_to) { - true: accept; - false: reject; - }; - } - }; - """ - var test_declarations = StaticVarValueScopes().enter() - test_declarations = test_declarations.declare( - identifier: Identifier(name: "ta"), - withValue: (P4QualifiedType(P4Array(withValueType: P4QualifiedType(P4Int()))), .none)) - - var test_values = VarValueScopes().enter() - test_values = test_values.declare( - identifier: Identifier(name: "ta"), - withValue: P4Value( - P4ArrayValue( - withType: P4QualifiedType(P4Int()), - withValue: [ - P4Value(P4IntValue(withValue: 1)), P4Value(P4IntValue(withValue: 2)), - P4Value(P4IntValue(withValue: 3)), - ]))) - - let program = try #UseOkResult( - SpecialCompilers.ProgramCompiler.Compile(simple_parser_declaration, withGlobalInstances: test_declarations)) - let runtime = try #UseOkResult( - P4Runtime.Runtime.create( - program: program, withGlobalValues: test_values)) - let (state_result, _) = try! #UseOkResult(runtime.run()) - - #expect(state_result == P4Lang.accept) -} - -@Test func test_array_set_nested() async throws { - let simple_parser_declaration = """ - parser main_parser() { - state start { - ta[0][0] = 5; - int where_to = ta[0][0]; - transition select (where_to == 5) { - true: accept; - false: reject; - }; - } - }; - """ - var test_declarations = StaticVarValueScopes().enter() - test_declarations = test_declarations.declare( - identifier: Identifier(name: "ta"), - withValue: ( - P4QualifiedType( - P4Array(withValueType: P4QualifiedType(P4Array(withValueType: P4QualifiedType(P4Int()))))), - .none - )) - - var test_values = VarValueScopes().enter() - - let nested = P4Value( - P4ArrayValue( - withType: P4QualifiedType(P4Int()), - withValue: [ - P4Value(P4IntValue(withValue: 1)), P4Value(P4IntValue(withValue: 2)), - P4Value(P4IntValue(withValue: 3)), - ])) - - test_values = test_values.declare( - identifier: Identifier(name: "ta"), - withValue: P4Value( - P4ArrayValue( - withType: P4QualifiedType(P4Array(withValueType: P4QualifiedType(P4Int()))), - withValue: [nested]))) - - let program = try #UseOkResult( - SpecialCompilers.ProgramCompiler.Compile(simple_parser_declaration, withGlobalInstances: test_declarations)) - let runtime = try #UseOkResult( - P4Runtime.Runtime.create( - program: program, withGlobalValues: test_values)) - let (state_result, _) = try! #UseOkResult(runtime.run()) - - #expect(state_result == P4Lang.accept) -} diff --git a/Tests/p4rseTests/BinaryOperatorTests/AndOr.swift b/Tests/p4rseTests/BinaryOperatorTests/AndOr.swift deleted file mode 100644 index 0694168..0000000 --- a/Tests/p4rseTests/BinaryOperatorTests/AndOr.swift +++ /dev/null @@ -1,220 +0,0 @@ -// p4rse, Copyright 202false, 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 . - -import Common -import Foundation -import Macros -import P4Lang -import P4Runtime -import SwiftTreeSitter -import Testing -import TreeSitter -import TreeSitterP4 - -@testable import P4Compiler - -// And/Or binary operator tests ... - -@Test func test_simple_parser_binary_operator_and() async throws { - let simple = """ - parser main_parser() { - state start { - transition select (true && true) { - true: accept; - false: reject; - }; - } - }; - """ - - let program = try #UseOkResult(SpecialCompilers.ProgramCompiler.Compile(simple)) - let runtime = try #UseOkResult(P4Runtime.Runtime.create(program: program)) - let (state_result, _) = try! #UseOkResult(runtime.run()) - - #expect(state_result == P4Lang.accept) -} - -@Test func test_simple_parser_binary_operator_and2() async throws { - let simple = """ - parser main_parser() { - state start { - transition select (false && false) { - true: accept; - false: reject; - }; - } - }; - """ - - let program = try #UseOkResult(SpecialCompilers.ProgramCompiler.Compile(simple)) - let runtime = try #UseOkResult(P4Runtime.Runtime.create(program: program)) - let (state_result, _) = try! #UseOkResult(runtime.run()) - - #expect(state_result == P4Lang.reject) -} - -@Test func test_simple_parser_binary_operator_and3() async throws { - let simple = """ - parser main_parser() { - state start { - transition select (false && true) { - true: accept; - false: reject; - }; - } - }; - """ - - let program = try #UseOkResult(SpecialCompilers.ProgramCompiler.Compile(simple)) - let runtime = try #UseOkResult(P4Runtime.Runtime.create(program: program)) - let (state_result, _) = try! #UseOkResult(runtime.run()) - - #expect(state_result == P4Lang.reject) -} - -@Test func test_simple_parser_binary_operator_and4() async throws { - let simple = """ - parser main_parser() { - state start { - transition select (true && false) { - true: accept; - false: reject; - }; - } - }; - """ - - let program = try #UseOkResult(SpecialCompilers.ProgramCompiler.Compile(simple)) - let runtime = try #UseOkResult(P4Runtime.Runtime.create(program: program)) - let (state_result, _) = try! #UseOkResult(runtime.run()) - - #expect(state_result == P4Lang.reject) -} - -@Test func test_simple_parser_binary_operator_or() async throws { - let simple = """ - parser main_parser() { - state start { - transition select (true || true) { - true: accept; - false: reject; - }; - } - }; - """ - - let program = try #UseOkResult(SpecialCompilers.ProgramCompiler.Compile(simple)) - let runtime = try #UseOkResult(P4Runtime.Runtime.create(program: program)) - let (state_result, _) = try! #UseOkResult(runtime.run()) - - #expect(state_result == P4Lang.accept) -} - -@Test func test_simple_parser_binary_operator_or2() async throws { - let simple = """ - parser main_parser() { - state start { - transition select (true || false) { - true: accept; - false: reject; - }; - } - }; - """ - - let program = try #UseOkResult(SpecialCompilers.ProgramCompiler.Compile(simple)) - let runtime = try #UseOkResult(P4Runtime.Runtime.create(program: program)) - let (state_result, _) = try! #UseOkResult(runtime.run()) - - #expect(state_result == P4Lang.accept) -} - -@Test func test_simple_parser_binary_operator_or3() async throws { - let simple = """ - parser main_parser() { - state start { - transition select (false || true) { - true: accept; - false: reject; - }; - } - }; - """ - - let program = try #UseOkResult(SpecialCompilers.ProgramCompiler.Compile(simple)) - let runtime = try #UseOkResult(P4Runtime.Runtime.create(program: program)) - let (state_result, _) = try! #UseOkResult(runtime.run()) - - #expect(state_result == P4Lang.accept) -} - -@Test func test_simple_parser_binary_operator_or4() async throws { - let simple = """ - parser main_parser() { - state start { - transition select (false || false) { - true: accept; - false: reject; - }; - } - }; - """ - - let program = try #UseOkResult(SpecialCompilers.ProgramCompiler.Compile(simple)) - let runtime = try #UseOkResult(P4Runtime.Runtime.create(program: program)) - let (state_result, _) = try! #UseOkResult(runtime.run()) - - #expect(state_result == P4Lang.reject) -} - -@Test func test_simple_parser_binary_operator_grouped() async throws { - let simple = """ - parser main_parser() { - state start { - transition select (true && (false || true)) { - true: accept; - false: reject; - }; - } - }; - """ - - let program = try #UseOkResult(SpecialCompilers.ProgramCompiler.Compile(simple)) - let runtime = try #UseOkResult(P4Runtime.Runtime.create(program: program)) - let (state_result, _) = try! #UseOkResult(runtime.run()) - - #expect(state_result == P4Lang.accept) -} - -@Test func test_simple_parser_binary_operator_grouped2() async throws { - let simple = """ - parser main_parser() { - state start { - transition select (true && (false || false)) { - true: accept; - false: reject; - }; - } - }; - """ - - let program = try #UseOkResult(SpecialCompilers.ProgramCompiler.Compile(simple)) - let runtime = try #UseOkResult(P4Runtime.Runtime.create(program: program)) - let (state_result, _) = try! #UseOkResult(runtime.run()) - - #expect(state_result == P4Lang.reject) -} diff --git a/Tests/p4rseTests/BinaryOperatorTests/Bool.swift b/Tests/p4rseTests/BinaryOperatorTests/Bool.swift deleted file mode 100644 index 3b708d5..0000000 --- a/Tests/p4rseTests/BinaryOperatorTests/Bool.swift +++ /dev/null @@ -1,296 +0,0 @@ -// p4rse, Copyright 202false, 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 . - -import Common -import Foundation -import Macros -import P4Lang -import P4Runtime -import SwiftTreeSitter -import Testing -import TreeSitter -import TreeSitterP4 - -@testable import P4Compiler - -// Bool binary operator tests ... - -@Test func test_simple_parser_binary_operator_equal_bool() async throws { - let simple = """ - parser main_parser() { - state start { - transition select (true == true) { - true: accept; - false: reject; - }; - } - }; - """ - - let program = try #UseOkResult(SpecialCompilers.ProgramCompiler.Compile(simple)) - let runtime = try #UseOkResult(P4Runtime.Runtime.create(program: program)) - let (state_result, _) = try! #UseOkResult(runtime.run()) - - #expect(state_result == P4Lang.accept) -} - -@Test func test_simple_parser_binary_operator_equal_not_equal_bool() async throws { - let simple = """ - parser main_parser() { - state start { - transition select (true == false) { - true: accept; - false: reject; - }; - } - }; - """ - - let program = try #UseOkResult(SpecialCompilers.ProgramCompiler.Compile(simple)) - let runtime = try #UseOkResult(P4Runtime.Runtime.create(program: program)) - let (state_result, _) = try! #UseOkResult(runtime.run()) - - #expect(state_result == P4Lang.reject) -} - -@Test func test_simple_parser_binary_operator_less_than_bool() async throws { - let simple = """ - parser main_parser() { - state start { - transition select (false < true) { - true: accept; - false: reject; - }; - } - }; - """ - - let program = try #UseOkResult(SpecialCompilers.ProgramCompiler.Compile(simple)) - let runtime = try #UseOkResult(P4Runtime.Runtime.create(program: program)) - let (state_result, _) = try! #UseOkResult(runtime.run()) - - #expect(state_result == P4Lang.accept) -} - -@Test func test_simple_parser_binary_operator_less_than_equal_bool() async throws { - let simple = """ - parser main_parser() { - state start { - transition select (false <= true) { - true: accept; - false: reject; - }; - } - }; - """ - - let program = try #UseOkResult(SpecialCompilers.ProgramCompiler.Compile(simple)) - let runtime = try #UseOkResult(P4Runtime.Runtime.create(program: program)) - let (state_result, _) = try! #UseOkResult(runtime.run()) - - #expect(state_result == P4Lang.accept) -} - -@Test func test_simple_parser_binary_operator_less_than_equal_bool2() async throws { - let simple = """ - parser main_parser() { - state start { - transition select (true <= true) { - true: accept; - false: reject; - }; - } - }; - """ - - let program = try #UseOkResult(SpecialCompilers.ProgramCompiler.Compile(simple)) - let runtime = try #UseOkResult(P4Runtime.Runtime.create(program: program)) - let (state_result, _) = try! #UseOkResult(runtime.run()) - - #expect(state_result == P4Lang.accept) -} - -@Test func test_simple_parser_binary_operator_greater_than_bool() async throws { - let simple = """ - parser main_parser() { - state start { - transition select (true > false) { - true: accept; - false: reject; - }; - } - }; - """ - - let program = try #UseOkResult(SpecialCompilers.ProgramCompiler.Compile(simple)) - let runtime = try #UseOkResult(P4Runtime.Runtime.create(program: program)) - let (state_result, _) = try! #UseOkResult(runtime.run()) - - #expect(state_result == P4Lang.accept) -} - -@Test func test_simple_parser_binary_operator_greater_than_equal_bool() async throws { - let simple = """ - parser main_parser() { - state start { - transition select (false >= false) { - true: accept; - false: reject; - }; - } - }; - """ - - let program = try #UseOkResult(SpecialCompilers.ProgramCompiler.Compile(simple)) - let runtime = try #UseOkResult(P4Runtime.Runtime.create(program: program)) - let (state_result, _) = try! #UseOkResult(runtime.run()) - - #expect(state_result == P4Lang.accept) -} - -@Test func test_simple_parser_binary_operator_greater_than_equal_bool2() async throws { - let simple = """ - parser main_parser() { - state start { - transition select (true >= false) { - true: accept; - false: reject; - }; - } - }; - """ - - let program = try #UseOkResult(SpecialCompilers.ProgramCompiler.Compile(simple)) - let runtime = try #UseOkResult(P4Runtime.Runtime.create(program: program)) - let (state_result, _) = try! #UseOkResult(runtime.run()) - - #expect(state_result == P4Lang.accept) -} - -@Test func test_simple_parser_binary_operator_less_than_bool_not() async throws { - let simple = """ - parser main_parser() { - state start { - transition select (true < false) { - true: accept; - false: reject; - }; - } - }; - """ - - let program = try #UseOkResult(SpecialCompilers.ProgramCompiler.Compile(simple)) - let runtime = try #UseOkResult(P4Runtime.Runtime.create(program: program)) - let (state_result, _) = try! #UseOkResult(runtime.run()) - - #expect(state_result == P4Lang.reject) -} - -@Test func test_simple_parser_binary_operator_less_than_bool_not2() async throws { - let simple = """ - parser main_parser() { - state start { - transition select (true < true) { - true: accept; - false: reject; - }; - } - }; - """ - - let program = try #UseOkResult(SpecialCompilers.ProgramCompiler.Compile(simple)) - let runtime = try #UseOkResult(P4Runtime.Runtime.create(program: program)) - let (state_result, _) = try! #UseOkResult(runtime.run()) - - #expect(state_result == P4Lang.reject) -} - -@Test func test_simple_parser_binary_operator_less_than_equal_bool_not() async throws { - let simple = """ - parser main_parser() { - state start { - transition select (true <= false) { - true: accept; - false: reject; - }; - } - }; - """ - - let program = try #UseOkResult(SpecialCompilers.ProgramCompiler.Compile(simple)) - let runtime = try #UseOkResult(P4Runtime.Runtime.create(program: program)) - let (state_result, _) = try! #UseOkResult(runtime.run()) - - #expect(state_result == P4Lang.reject) -} - -@Test func test_simple_parser_binary_operator_greater_than_bool_not() async throws { - let simple = """ - parser main_parser() { - state start { - transition select (false > true) { - true: accept; - false: reject; - }; - } - }; - """ - - let program = try #UseOkResult(SpecialCompilers.ProgramCompiler.Compile(simple)) - let runtime = try #UseOkResult(P4Runtime.Runtime.create(program: program)) - let (state_result, _) = try! #UseOkResult(runtime.run()) - - #expect(state_result == P4Lang.reject) -} - -@Test func test_simple_parser_binary_operator_greater_than_bool_not2() async throws { - let simple = """ - parser main_parser() { - state start { - transition select (true > true) { - true: accept; - false: reject; - }; - } - }; - """ - - let program = try #UseOkResult(SpecialCompilers.ProgramCompiler.Compile(simple)) - let runtime = try #UseOkResult(P4Runtime.Runtime.create(program: program)) - let (state_result, _) = try! #UseOkResult(runtime.run()) - - #expect(state_result == P4Lang.reject) -} - -@Test func test_simple_parser_binary_operator_greater_than_equal_bool_not() async throws { - let simple = """ - parser main_parser() { - state start { - transition select (false >= true) { - true: accept; - false: reject; - }; - } - }; - """ - - let program = try #UseOkResult(SpecialCompilers.ProgramCompiler.Compile(simple)) - let runtime = try #UseOkResult(P4Runtime.Runtime.create(program: program)) - let (state_result, _) = try! #UseOkResult(runtime.run()) - - #expect(state_result == P4Lang.reject) -} diff --git a/Tests/p4rseTests/BinaryOperatorTests/Integer.swift b/Tests/p4rseTests/BinaryOperatorTests/Integer.swift deleted file mode 100644 index 86a06cd..0000000 --- a/Tests/p4rseTests/BinaryOperatorTests/Integer.swift +++ /dev/null @@ -1,549 +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 . - -import Common -import Foundation -import Macros -import P4Lang -import P4Runtime -import SwiftTreeSitter -import Testing -import TreeSitter -import TreeSitterP4 - -@testable import P4Compiler - -// Integer binary operator tests ... - -@Test func test_simple_parser_binary_operator_equal_integer() async throws { - let simple = """ - parser main_parser() { - state start { - transition select (5 == 5) { - true: accept; - false: reject; - }; - } - }; - """ - - let program = try #UseOkResult(SpecialCompilers.ProgramCompiler.Compile(simple)) - let runtime = try #UseOkResult(P4Runtime.Runtime.create(program: program)) - let (state_result, _) = try! #UseOkResult(runtime.run()) - - #expect(state_result == P4Lang.accept) -} - -@Test func test_simple_parser_binary_operator_equal_not_equal_integer() async throws { - let simple = """ - parser main_parser() { - state start { - transition select (5 == 6) { - true: accept; - false: reject; - }; - } - }; - """ - - let program = try #UseOkResult(SpecialCompilers.ProgramCompiler.Compile(simple)) - let runtime = try #UseOkResult(P4Runtime.Runtime.create(program: program)) - let (state_result, _) = try! #UseOkResult(runtime.run()) - - #expect(state_result == P4Lang.reject) -} - -@Test func test_simple_parser_binary_operator_less_than_integer() async throws { - let simple = """ - parser main_parser() { - state start { - transition select (5 < 6) { - true: accept; - false: reject; - }; - } - }; - """ - - let program = try #UseOkResult(SpecialCompilers.ProgramCompiler.Compile(simple)) - let runtime = try #UseOkResult(P4Runtime.Runtime.create(program: program)) - let (state_result, _) = try! #UseOkResult(runtime.run()) - - #expect(state_result == P4Lang.accept) -} - -@Test func test_simple_parser_binary_operator_less_than_equal_integer() async throws { - let simple = """ - parser main_parser() { - state start { - transition select (5 <= 6) { - true: accept; - false: reject; - }; - } - }; - """ - - let program = try #UseOkResult(SpecialCompilers.ProgramCompiler.Compile(simple)) - let runtime = try #UseOkResult(P4Runtime.Runtime.create(program: program)) - let (state_result, _) = try! #UseOkResult(runtime.run()) - - #expect(state_result == P4Lang.accept) -} - -@Test func test_simple_parser_binary_operator_less_than_equal_integer2() async throws { - let simple = """ - parser main_parser() { - state start { - transition select (6 <= 6) { - true: accept; - false: reject; - }; - } - }; - """ - - let program = try #UseOkResult(SpecialCompilers.ProgramCompiler.Compile(simple)) - let runtime = try #UseOkResult(P4Runtime.Runtime.create(program: program)) - let (state_result, _) = try! #UseOkResult(runtime.run()) - - #expect(state_result == P4Lang.accept) -} - -@Test func test_simple_parser_binary_operator_greater_than_integer() async throws { - let simple = """ - parser main_parser() { - state start { - transition select (7 > 6) { - true: accept; - false: reject; - }; - } - }; - """ - - let program = try #UseOkResult(SpecialCompilers.ProgramCompiler.Compile(simple)) - let runtime = try #UseOkResult(P4Runtime.Runtime.create(program: program)) - let (state_result, _) = try! #UseOkResult(runtime.run()) - - #expect(state_result == P4Lang.accept) -} - -@Test func test_simple_parser_binary_operator_greater_than_equal_integer() async throws { - let simple = """ - parser main_parser() { - state start { - transition select (6 >= 6) { - true: accept; - false: reject; - }; - } - }; - """ - - let program = try #UseOkResult(SpecialCompilers.ProgramCompiler.Compile(simple)) - let runtime = try #UseOkResult(P4Runtime.Runtime.create(program: program)) - let (state_result, _) = try! #UseOkResult(runtime.run()) - - #expect(state_result == P4Lang.accept) -} - -@Test func test_simple_parser_binary_operator_greater_than_equal_integer2() async throws { - let simple = """ - parser main_parser() { - state start { - transition select (7 >= 6) { - true: accept; - false: reject; - }; - } - }; - """ - - let program = try #UseOkResult(SpecialCompilers.ProgramCompiler.Compile(simple)) - let runtime = try #UseOkResult(P4Runtime.Runtime.create(program: program)) - let (state_result, _) = try! #UseOkResult(runtime.run()) - - #expect(state_result == P4Lang.accept) -} - -@Test func test_simple_parser_binary_operator_less_than_integer_not() async throws { - let simple = """ - parser main_parser() { - state start { - transition select (6 < 5) { - true: accept; - false: reject; - }; - } - }; - """ - - let program = try #UseOkResult(SpecialCompilers.ProgramCompiler.Compile(simple)) - let runtime = try #UseOkResult(P4Runtime.Runtime.create(program: program)) - let (state_result, _) = try! #UseOkResult(runtime.run()) - - #expect(state_result == P4Lang.reject) -} - -@Test func test_simple_parser_binary_operator_less_than_integer_not2() async throws { - let simple = """ - parser main_parser() { - state start { - transition select (5 < 5) { - true: accept; - false: reject; - }; - } - }; - """ - - let program = try #UseOkResult(SpecialCompilers.ProgramCompiler.Compile(simple)) - let runtime = try #UseOkResult(P4Runtime.Runtime.create(program: program)) - let (state_result, _) = try! #UseOkResult(runtime.run()) - - #expect(state_result == P4Lang.reject) -} - -@Test func test_simple_parser_binary_operator_less_than_equal_integer_not() async throws { - let simple = """ - parser main_parser() { - state start { - transition select (6 <= 5) { - true: accept; - false: reject; - }; - } - }; - """ - - let program = try #UseOkResult(SpecialCompilers.ProgramCompiler.Compile(simple)) - let runtime = try #UseOkResult(P4Runtime.Runtime.create(program: program)) - let (state_result, _) = try! #UseOkResult(runtime.run()) - - #expect(state_result == P4Lang.reject) -} - -@Test func test_simple_parser_binary_operator_greater_than_integer_not() async throws { - let simple = """ - parser main_parser() { - state start { - transition select (5 > 6) { - true: accept; - false: reject; - }; - } - }; - """ - - let program = try #UseOkResult(SpecialCompilers.ProgramCompiler.Compile(simple)) - let runtime = try #UseOkResult(P4Runtime.Runtime.create(program: program)) - let (state_result, _) = try! #UseOkResult(runtime.run()) - - #expect(state_result == P4Lang.reject) -} - -@Test func test_simple_parser_binary_operator_greater_than_integer_not2() async throws { - let simple = """ - parser main_parser() { - state start { - transition select (5 > 5) { - true: accept; - false: reject; - }; - } - }; - """ - - let program = try #UseOkResult(SpecialCompilers.ProgramCompiler.Compile(simple)) - let runtime = try #UseOkResult(P4Runtime.Runtime.create(program: program)) - let (state_result, _) = try! #UseOkResult(runtime.run()) - - #expect(state_result == P4Lang.reject) -} - -@Test func test_simple_parser_binary_operator_greater_than_equal_integer_not() async throws { - let simple = """ - parser main_parser() { - state start { - transition select (5 >= 6) { - true: accept; - false: reject; - }; - } - }; - """ - - let program = try #UseOkResult(SpecialCompilers.ProgramCompiler.Compile(simple)) - let runtime = try #UseOkResult(P4Runtime.Runtime.create(program: program)) - let (state_result, _) = try! #UseOkResult(runtime.run()) - - #expect(state_result == P4Lang.reject) -} - - -// Add Integers - -@Test func test_simple_parser_binary_operator_add_integer() async throws { - let simple = """ - parser main_parser() { - state start { - transition select (10 == (5 + 5)) { - true: accept; - false: reject; - }; - } - }; - """ - - let program = try #UseOkResult(SpecialCompilers.ProgramCompiler.Compile(simple)) - let runtime = try #UseOkResult(P4Runtime.Runtime.create(program: program)) - let (state_result, _) = try! #UseOkResult(runtime.run()) - - #expect(state_result == P4Lang.accept) -} - -@Test func test_simple_parser_binary_operator_add_non_integer() async throws { - let simple = """ - parser main_parser() { - state start { - transition select (true + false) { - true: accept; - false: reject; - }; - } - }; - """ - - #expect( - #RequireErrorResult( - Error( - withMessage: - "{72, 12}: Could not parse transition select expression selector expression: Mathematical operation on operands with non-int type is not allowed" - ), - SpecialCompilers.ProgramCompiler.Compile(simple))) -} - -@Test func test_simple_parser_binary_operator_add_non_integer2() async throws { - let simple = """ - parser main_parser() { - state start { - transition select (5 + false) { - true: accept; - false: reject; - }; - } - }; - """ - - #expect( - #RequireErrorResult( - Error( - withMessage: - "{72, 9}: Could not parse transition select expression selector expression: Types of values used with binary expression are not the same" - ), - SpecialCompilers.ProgramCompiler.Compile(simple))) -} - -// Subtract Integers - -@Test func test_simple_parser_binary_operator_subtract_integer() async throws { - let simple = """ - parser main_parser() { - state start { - transition select (0 == (5 - 5)) { - true: accept; - false: reject; - }; - } - }; - """ - - let program = try #UseOkResult(SpecialCompilers.ProgramCompiler.Compile(simple)) - let runtime = try #UseOkResult(P4Runtime.Runtime.create(program: program)) - let (state_result, _) = try! #UseOkResult(runtime.run()) - - #expect(state_result == P4Lang.accept) -} - -@Test func test_simple_parser_binary_operator_subtract_non_integer() async throws { - let simple = """ - parser main_parser() { - state start { - transition select (true - false) { - true: accept; - false: reject; - }; - } - }; - """ - - #expect( - #RequireErrorResult( - Error( - withMessage: - "{72, 12}: Could not parse transition select expression selector expression: Mathematical operation on operands with non-int type is not allowed" - ), - SpecialCompilers.ProgramCompiler.Compile(simple))) -} - -@Test func test_simple_parser_binary_operator_subtract_non_integer2() async throws { - let simple = """ - parser main_parser() { - state start { - transition select (5 - false) { - true: accept; - false: reject; - }; - } - }; - """ - - #expect( - #RequireErrorResult( - Error( - withMessage: - "{72, 9}: Could not parse transition select expression selector expression: Types of values used with binary expression are not the same" - ), - SpecialCompilers.ProgramCompiler.Compile(simple))) -} - -// Multiply Integers - -@Test func test_simple_parser_binary_operator_multiply_integer() async throws { - let simple = """ - parser main_parser() { - state start { - transition select (25 == (5 * 5)) { - true: accept; - false: reject; - }; - } - }; - """ - - let program = try #UseOkResult(SpecialCompilers.ProgramCompiler.Compile(simple)) - let runtime = try #UseOkResult(P4Runtime.Runtime.create(program: program)) - let (state_result, _) = try! #UseOkResult(runtime.run()) - - #expect(state_result == P4Lang.accept) -} - -@Test func test_simple_parser_binary_operator_multiply_non_integer() async throws { - let simple = """ - parser main_parser() { - state start { - transition select (true * false) { - true: accept; - false: reject; - }; - } - }; - """ - - #expect( - #RequireErrorResult( - Error( - withMessage: - "{72, 12}: Could not parse transition select expression selector expression: Mathematical operation on operands with non-int type is not allowed" - ), - SpecialCompilers.ProgramCompiler.Compile(simple))) -} - -@Test func test_simple_parser_binary_operator_multiply_non_integer2() async throws { - let simple = """ - parser main_parser() { - state start { - transition select (5 * false) { - true: accept; - false: reject; - }; - } - }; - """ - - #expect( - #RequireErrorResult( - Error( - withMessage: - "{72, 9}: Could not parse transition select expression selector expression: Types of values used with binary expression are not the same" - ), - SpecialCompilers.ProgramCompiler.Compile(simple))) -} - -// Divide Integers - -@Test func test_simple_parser_binary_operator_divide_integer() async throws { - let simple = """ - parser main_parser() { - state start { - transition select (1 == (5 / 5)) { - true: accept; - false: reject; - }; - } - }; - """ - - let program = try #UseOkResult(SpecialCompilers.ProgramCompiler.Compile(simple)) - let runtime = try #UseOkResult(P4Runtime.Runtime.create(program: program)) - let (state_result, _) = try! #UseOkResult(runtime.run()) - - #expect(state_result == P4Lang.accept) -} - -@Test func test_simple_parser_binary_operator_divide_non_integer() async throws { - let simple = """ - parser main_parser() { - state start { - transition select (true / false) { - true: accept; - false: reject; - }; - } - }; - """ - - #expect( - #RequireErrorResult( - Error( - withMessage: - "{72, 12}: Could not parse transition select expression selector expression: Mathematical operation on operands with non-int type is not allowed" - ), - SpecialCompilers.ProgramCompiler.Compile(simple))) -} - -@Test func test_simple_parser_binary_operator_divide_non_integer2() async throws { - let simple = """ - parser main_parser() { - state start { - transition select (5 / false) { - true: accept; - false: reject; - }; - } - }; - """ - - #expect( - #RequireErrorResult( - Error( - withMessage: - "{72, 9}: Could not parse transition select expression selector expression: Types of values used with binary expression are not the same" - ), - SpecialCompilers.ProgramCompiler.Compile(simple))) -} diff --git a/Tests/p4rseTests/BinaryOperatorTests/String.swift b/Tests/p4rseTests/BinaryOperatorTests/String.swift deleted file mode 100644 index 9593074..0000000 --- a/Tests/p4rseTests/BinaryOperatorTests/String.swift +++ /dev/null @@ -1,220 +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 . - -import Common -import Foundation -import Macros -import P4Lang -import P4Runtime -import SwiftTreeSitter -import Testing -import TreeSitter -import TreeSitterP4 - -@testable import P4Compiler - -// String binary operator tests ... - -@Test func test_simple_parser_binary_operator_equal_string() async throws { - let simple = """ - parser main_parser() { - state start { - transition select ("five" == "five") { - true: accept; - false: reject; - }; - } - }; - """ - - let program = try #UseOkResult(SpecialCompilers.ProgramCompiler.Compile(simple)) - let runtime = try #UseOkResult(P4Runtime.Runtime.create(program: program)) - let (state_result, _) = try! #UseOkResult(runtime.run()) - - #expect(state_result == P4Lang.accept) -} - -@Test func test_simple_parser_binary_operator_equal_not_equal_string() async throws { - let simple = """ - parser main_parser() { - state start { - transition select ("five" == "six") { - true: accept; - false: reject; - }; - } - }; - """ - - let program = try #UseOkResult(SpecialCompilers.ProgramCompiler.Compile(simple)) - let runtime = try #UseOkResult(P4Runtime.Runtime.create(program: program)) - let (state_result, _) = try! #UseOkResult(runtime.run()) - - #expect(state_result == P4Lang.reject) -} - -@Test func test_simple_parser_binary_operator_less_than_string() async throws { - let simple = """ - parser main_parser() { - state start { - transition select ("five" < "six") { - true: accept; - false: reject; - }; - } - }; - """ - - let program = try #UseOkResult(SpecialCompilers.ProgramCompiler.Compile(simple)) - let runtime = try #UseOkResult(P4Runtime.Runtime.create(program: program)) - let (state_result, _) = try! #UseOkResult(runtime.run()) - - #expect(state_result == P4Lang.accept) -} - -@Test func test_simple_parser_binary_operator_less_than_equal_string() async throws { - let simple = """ - parser main_parser() { - state start { - transition select ("six" <= "six") { - true: accept; - false: reject; - }; - } - }; - """ - - let program = try #UseOkResult(SpecialCompilers.ProgramCompiler.Compile(simple)) - let runtime = try #UseOkResult(P4Runtime.Runtime.create(program: program)) - let (state_result, _) = try! #UseOkResult(runtime.run()) - - #expect(state_result == P4Lang.accept) -} - -@Test func test_simple_parser_binary_operator_greater_than_string() async throws { - let simple = """ - parser main_parser() { - state start { - transition select ("twelve" > "six") { - true: accept; - false: reject; - }; - } - }; - """ - - let program = try #UseOkResult(SpecialCompilers.ProgramCompiler.Compile(simple)) - let runtime = try #UseOkResult(P4Runtime.Runtime.create(program: program)) - let (state_result, _) = try! #UseOkResult(runtime.run()) - - #expect(state_result == P4Lang.accept) -} - -@Test func test_simple_parser_binary_operator_greater_than_equal_string() async throws { - let simple = """ - parser main_parser() { - state start { - transition select ("twelve" >= "six") { - true: accept; - false: reject; - }; - } - }; - """ - - let program = try #UseOkResult(SpecialCompilers.ProgramCompiler.Compile(simple)) - let runtime = try #UseOkResult(P4Runtime.Runtime.create(program: program)) - let (state_result, _) = try! #UseOkResult(runtime.run()) - - #expect(state_result == P4Lang.accept) -} - -@Test func test_simple_parser_binary_operator_less_than_string_not() async throws { - let simple = """ - parser main_parser() { - state start { - transition select ("six" < "five") { - true: accept; - false: reject; - }; - } - }; - """ - - let program = try #UseOkResult(SpecialCompilers.ProgramCompiler.Compile(simple)) - let runtime = try #UseOkResult(P4Runtime.Runtime.create(program: program)) - let (state_result, _) = try! #UseOkResult(runtime.run()) - - #expect(state_result == P4Lang.reject) -} - -@Test func test_simple_parser_binary_operator_less_than_equal_string_not() async throws { - let simple = """ - parser main_parser() { - state start { - transition select ("six" <= "five") { - true: accept; - false: reject; - }; - } - }; - """ - - let program = try #UseOkResult(SpecialCompilers.ProgramCompiler.Compile(simple)) - let runtime = try #UseOkResult(P4Runtime.Runtime.create(program: program)) - let (state_result, _) = try! #UseOkResult(runtime.run()) - - #expect(state_result == P4Lang.reject) -} - -@Test func test_simple_parser_binary_operator_greater_than_string_not() async throws { - let simple = """ - parser main_parser() { - state start { - transition select ("five" > "six") { - true: accept; - false: reject; - }; - } - }; - """ - - let program = try #UseOkResult(SpecialCompilers.ProgramCompiler.Compile(simple)) - let runtime = try #UseOkResult(P4Runtime.Runtime.create(program: program)) - let (state_result, _) = try! #UseOkResult(runtime.run()) - - #expect(state_result == P4Lang.reject) -} - -@Test func test_simple_parser_binary_operator_greater_than_equal_string_not() async throws { - let simple = """ - parser main_parser() { - state start { - transition select ("five" >= "six") { - true: accept; - false: reject; - }; - } - }; - """ - - let program = try #UseOkResult(SpecialCompilers.ProgramCompiler.Compile(simple)) - let runtime = try #UseOkResult(P4Runtime.Runtime.create(program: program)) - let (state_result, _) = try! #UseOkResult(runtime.run()) - - #expect(state_result == P4Lang.reject) -} diff --git a/Tests/p4rseTests/BinaryOperatorTests/Struct.swift b/Tests/p4rseTests/BinaryOperatorTests/Struct.swift deleted file mode 100644 index e8b469c..0000000 --- a/Tests/p4rseTests/BinaryOperatorTests/Struct.swift +++ /dev/null @@ -1,196 +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 . - -import Common -import Foundation -import Macros -import P4Lang -import P4Runtime -import SwiftTreeSitter -import Testing -import TreeSitter -import TreeSitterP4 - -@testable import P4Compiler - -@Test func test_struct_equality_empty() async throws { - let simple_parser_declaration = """ - parser main_parser() { - state start { - Testing one; - Testing two; - transition select (one == two) { - true: accept; - false: reject; - }; - } - }; - """ - let fields = P4StructFields([ - P4StructFieldIdentifier(name: "yesno", withType: P4QualifiedType(P4Boolean())), - P4StructFieldIdentifier(name: "count", withType: P4QualifiedType(P4Int())), - ]) - var test_types = TypeTypeScopes().enter() - let struct_type = P4Struct(withName: Identifier(name: "Testing"), andFields: fields) - test_types = test_types.declare(identifier: Identifier(name: "Testing"), withValue: struct_type) - - let program = try #UseOkResult( - SpecialCompilers.ProgramCompiler.Compile(simple_parser_declaration, withGlobalInstances: .none, withGlobalTypes: test_types)) - - let runtime = try #UseOkResult(P4Runtime.Runtime.create(program: program)) - let (state_result, _) = try! #UseOkResult(runtime.run()) - #expect(state_result == P4Lang.accept) -} - -@Test func test_struct_equality_one_empty() async throws { - let simple_parser_declaration = """ - parser main_parser() { - state start { - Testing one; - Testing two; - - one.yesno = true; - - transition select (one == two) { - true: accept; - false: reject; - }; - } - }; - """ - let fields = P4StructFields([ - P4StructFieldIdentifier(name: "yesno", withType: P4QualifiedType(P4Boolean())), - P4StructFieldIdentifier(name: "count", withType: P4QualifiedType(P4Int())), - ]) - var test_types = TypeTypeScopes().enter() - let struct_type = P4Struct(withName: Identifier(name: "Testing"), andFields: fields) - test_types = test_types.declare(identifier: Identifier(name: "Testing"), withValue: struct_type) - - let program = try #UseOkResult( - SpecialCompilers.ProgramCompiler.Compile(simple_parser_declaration, withGlobalInstances: .none, withGlobalTypes: test_types)) - - let runtime = try #UseOkResult(P4Runtime.Runtime.create(program: program)) - let (state_result, _) = try! #UseOkResult(runtime.run()) - #expect(state_result == P4Lang.reject) -} - -@Test func test_struct_equality_neither_empty() async throws { - let simple_parser_declaration = """ - parser main_parser() { - state start { - Testing one; - Testing two; - - one.yesno = true; - two.yesno = true; - - transition select (one == two) { - true: accept; - false: reject; - }; - } - }; - """ - let fields = P4StructFields([ - P4StructFieldIdentifier(name: "yesno", withType: P4QualifiedType(P4Boolean())), - P4StructFieldIdentifier(name: "count", withType: P4QualifiedType(P4Int())), - ]) - var test_types = TypeTypeScopes().enter() - let struct_type = P4Struct(withName: Identifier(name: "Testing"), andFields: fields) - test_types = test_types.declare(identifier: Identifier(name: "Testing"), withValue: struct_type) - - let program = try #UseOkResult( - SpecialCompilers.ProgramCompiler.Compile(simple_parser_declaration, withGlobalInstances: .none, withGlobalTypes: test_types)) - - let runtime = try #UseOkResult(P4Runtime.Runtime.create(program: program)) - let (state_result, _) = try! #UseOkResult(runtime.run()) - #expect(state_result == P4Lang.accept) -} - -@Test func test_struct_equality_neither_empty2() async throws { - let simple_parser_declaration = """ - parser main_parser() { - state start { - Testing one; - Testing two; - - one.yesno = true; - two.yesno = true; - - one.count = 5; - two.count = 5; - - transition select (one == two) { - true: accept; - false: reject; - }; - } - }; - """ - let fields = P4StructFields([ - P4StructFieldIdentifier(name: "yesno", withType: P4QualifiedType(P4Boolean())), - P4StructFieldIdentifier(name: "count", withType: P4QualifiedType(P4Int())), - ]) - var test_types = TypeTypeScopes().enter() - let struct_type = P4Struct(withName: Identifier(name: "Testing"), andFields: fields) - test_types = test_types.declare(identifier: Identifier(name: "Testing"), withValue: struct_type) - - let program = try #UseOkResult( - SpecialCompilers.ProgramCompiler.Compile(simple_parser_declaration, withGlobalInstances: .none, withGlobalTypes: test_types)) - - let runtime = try #UseOkResult(P4Runtime.Runtime.create(program: program)) - let (state_result, _) = try! #UseOkResult(runtime.run()) - #expect(state_result == P4Lang.accept) -} - -@Test func test_struct_equality_neither_empty3() async throws { - let simple_parser_declaration = """ - parser main_parser() { - state start { - Testing one; - Testing two; - - one.yesno = true; - two.yesno = true; - - one.count = 5; - two.count = 6; - - transition select (one == two) { - true: accept; - false: reject; - }; - } - }; - """ - let fields = P4StructFields([ - P4StructFieldIdentifier(name: "yesno", withType: P4QualifiedType(P4Boolean())), - P4StructFieldIdentifier(name: "count", withType: P4QualifiedType(P4Int())), - ]) - var test_types = TypeTypeScopes().enter() - let struct_type = P4Struct(withName: Identifier(name: "Testing"), andFields: fields) - test_types = test_types.declare(identifier: Identifier(name: "Testing"), withValue: struct_type) - - let program = try #UseOkResult( - SpecialCompilers.ProgramCompiler.Compile(simple_parser_declaration, withGlobalInstances: .none, withGlobalTypes: test_types)) - - let runtime = try #UseOkResult(P4Runtime.Runtime.create(program: program)) - let (state_result, _) = try! #UseOkResult(runtime.run()) - #expect(state_result == P4Lang.reject) -} - - diff --git a/Tests/p4rseTests/CliTests/Cli.swift b/Tests/p4rseTests/CliTests/Cli.swift deleted file mode 100644 index 8216511..0000000 --- a/Tests/p4rseTests/CliTests/Cli.swift +++ /dev/null @@ -1,51 +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 . - -import Foundation -import Testing - -/// Success -/// -@CliTest() -func simple_cli_test() -> [String] { - return ["p4ce", "--plain", "compile", "simple.p4", "-I", "TestData/Sources/"] -} - -@CliTest() -func simple_cli_testa() -> [String] { - return ["p4ce", "--plain", "compile", "simple.p4", "-I", "TestData/Sources/"] -} - -@CliTest() -func simple_cli_preprocessor_test() -> [String] { - return ["p4ce", "--plain", "preprocess", "simple.p4", "-I", "TestData/Sources/"] -} - -@CliTest() -func simple_cli_preprocessor_test_file_not_found() -> [String] { - return ["p4ce", "--plain", "preprocess", "simple.p", "-I", "TestData/Sources/"] -} - -@CliTest() -func simple_cli_compilation_error() -> [String] { - return ["p4ce", "--plain", "compile", "action-parameters-wrong-order.p4", "-I", "TestData/Sources/"] -} - -@CliTest() -func simple_cli_compilation_error_with_includes() -> [String] { - return ["p4ce", "--plain", "compile", "file-loc-error.p4", "-I", "TestData/Sources/"] -} \ No newline at end of file diff --git a/Tests/p4rseTests/CodeGenTests/CodeGen.swift b/Tests/p4rseTests/CodeGenTests/CodeGen.swift deleted file mode 100644 index 320b80f..0000000 --- a/Tests/p4rseTests/CodeGenTests/CodeGen.swift +++ /dev/null @@ -1,97 +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 . - -import Common -import Foundation -import Macros -import P4Compiler -import P4Lang -import P4Runtime -import SwiftTreeSitter -import Testing -import TreeSitter -import TreeSitterP4 - -@testable import P4Runtime - -func shrink(_ from: String) -> String { - return from.replacing(Regex(#/\n[\s]+/#), with: "").replacing("\n", with: "") -} - -@Test func test_codegen_parser_state_direct_transition() async throws { - let simple_parser_declaration = """ - parser main_parser() { - state start { - true; - transition accept; - } - }; - """ - let program = try #UseOkResult(SpecialCompilers.ProgramCompiler.Compile(simple_parser_declaration)) - let cg = try #UseOkResult(CodeGenerator().codeGen(program)) - - let expected = shrink( - """ - [ - { - name: "main_parser", - init_state: "start", - parse_states: [ - { - name: "start", - transitions: [] - }, - ] - } - ] - """) - #expect(expected == cg.getGeneratedCode()) -} - -@Test func test_codegen_parser_state_select_transition() async throws { - let simple_parser_declaration = """ - parser main_parser() { - state start { - transition select (false) { - true: reject; - false: reject; - }; - } - }; - """ - let program = try #UseOkResult(SpecialCompilers.ProgramCompiler.Compile(simple_parser_declaration)) - let cg = try #UseOkResult(CodeGenerator().codeGen(program)) - - /// TODO: Fix this test. - let expected = shrink( - """ - [ - { - name: "main_parser", - init_state: "start", - parse_states: [ - { - name: "start", - transitions: [Select] - }, - ] - } - ] - """) - - #expect(expected == cg.getGeneratedCode()) -} diff --git a/Tests/p4rseTests/SupportTests/Macros.swift b/Tests/p4rseTests/CodeGenTests/Serializer.swift similarity index 55% rename from Tests/p4rseTests/SupportTests/Macros.swift rename to Tests/p4rseTests/CodeGenTests/Serializer.swift index b1732a3..f633c1c 100644 --- a/Tests/p4rseTests/SupportTests/Macros.swift +++ b/Tests/p4rseTests/CodeGenTests/Serializer.swift @@ -18,34 +18,33 @@ import Common import Foundation import Macros -import P4Lang -import P4Runtime import SwiftTreeSitter import Testing import TreeSitter import TreeSitterP4 +import P4CodeGen -@testable import Macros +@testable import P4Compiler -func wrapper_test_mustor() -> Int { - let x: Int? = 2 - var i = 0 - #MustOr(result: i, thing: x, or: 1) - return i -} - -func wrapper_test_mustor_none() -> Int { - let x: Int? = .none - var i = 0 - #MustOr(result: i, thing: x, or: 1) - return i -} - - -@Test func test_mustor() async throws { - #expect(wrapper_test_mustor() == 2) -} - -@Test func test_mustor_none() async throws { - #expect(wrapper_test_mustor_none() == 1) +@Test func test_text_serializer() async throws { + let simple_parser_declaration = """ + parser main_parser(inout int x) { + state start { + true; + transition accept; + } + state start { + transition select (true) { + true: accept; + false: reject; + }; + } + }; + """ + + let program = try #UseOkResult(SpecialCompilers.ProgramCompiler.Compile(simple_parser_declaration)) + let v = TextSerializer() + let c = TextSerializerContext(); + let vd = ASTVisitorDriver(); + #expect(#RequireOkResult((vd.visit(program: program, visitor: v, context: c)))) } diff --git a/Tests/p4rseTests/ConditionalTests.swift b/Tests/p4rseTests/ConditionalTests.swift deleted file mode 100644 index 6c51b50..0000000 --- a/Tests/p4rseTests/ConditionalTests.swift +++ /dev/null @@ -1,82 +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 . - -import Common -import Foundation -import Macros -import P4Lang -import P4Runtime -import SwiftTreeSitter -import Testing -import TreeSitter -import TreeSitterP4 - -@testable import P4Compiler - -@Test func test_simple_parser_with_conditional_statement() async throws { - let simple_parser_declaration = """ - parser main_parser() { - state start { - bool x = true; - string check = "Invalid"; - if (x) { - x = false; - check = "valid"; - } - transition select (x) { - false: reject; - true: accept; - }; - } - }; - """ - - let program = try #UseOkResult(SpecialCompilers.ProgramCompiler.Compile(simple_parser_declaration)) - let runtime = try #UseOkResult(P4Runtime.Runtime.create(program: program)) - let (state_result, _) = try! #UseOkResult(runtime.run()) - - #expect(state_result == P4Lang.reject) -} - -@Test func test_simple_parser_with_conditional_statement_and_else() async throws { - let simple_parser_declaration = """ - parser main_parser() { - state start { - bool x = false; - string check = "Invalid"; - if (x) { - x = false; - check = "a"; - } else { - x = true; - check = "b"; - } - transition select (x) { - false: reject; - true: accept; - }; - } - }; - """ - - let program = try #UseOkResult(SpecialCompilers.ProgramCompiler.Compile(simple_parser_declaration)) - let runtime = try #UseOkResult(P4Runtime.Runtime.create(program: program)) - let (state_result, _) = try! #UseOkResult(runtime.run()) - - #expect(state_result == P4Lang.accept) - -} diff --git a/Tests/p4rseTests/ControlTests/Compile.swift b/Tests/p4rseTests/ControlTests/Compile.swift deleted file mode 100644 index bf3f725..0000000 --- a/Tests/p4rseTests/ControlTests/Compile.swift +++ /dev/null @@ -1,402 +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 . - -import Common -import Foundation -import Macros -import P4Lang -import Runtime -import SwiftTreeSitter -import Testing -import TreeSitter -import TreeSitterP4 - -@testable import P4Compiler - -@Test func test_simple_control_declaration() async throws { - let simple_parser_declaration = """ - control simple() { - action a() { - } - table t { - key = { - true: exact; - } - } - apply { - } - }; - """ - let x = { (tipe: P4Type) -> Bool in - switch tipe { - case let c as Control: c.name == "simple" - default: false - } - } - let program = try! #UseOkResult(SpecialCompilers.ProgramCompiler.Compile(simple_parser_declaration)) - #expect(program.TypesWithTypes(x).count == 1) -} - -@Test func test_simple_control_declaration2() async throws { - let simple_parser_declaration = """ - struct Testing { - }; - control simple() { - action a() { - } - table t { - key = { - true: exact; - } - } - apply { - } - }; - control complex() { - action b() { - } - table t { - key = { - true: exact; - } - } - apply { - } - }; - """ - - let filter = { (tipe: P4Type) -> Bool in - switch tipe { - case let c as Control: c.name == "simple" || c.name == "complex" - default: false - } - } - let program = try! #UseOkResult(SpecialCompilers.ProgramCompiler.Compile(simple_parser_declaration)) - #expect(program.TypesWithTypes(filter).count == 2) -} - -@Test func test_simple_control_declaration_with_actions() async throws { - let simple_parser_declaration = """ - control simple() { - action a() { - } - table t { - key = { - true: exact; - } - actions = { - a; - } - } - apply { - } - }; - """ - let x = { (tipe: P4Type) -> Bool in - switch tipe { - case let c as Control: c.name == "simple" - default: false - } - } - let program = try! #UseOkResult(SpecialCompilers.ProgramCompiler.Compile(simple_parser_declaration)) - #expect(program.TypesWithTypes(x).count == 1) -} - -@Test func test_simple_control_declaration_with_misnamed_actions() async throws { - let simple_parser_declaration = """ - control simple() { - action a() { - } - table t { - key = { - true: exact; - } - actions = { - b; - } - } - apply { - } - }; - """ - #expect( - #RequireErrorResult( - Error( - withMessage: - "{54, 63}: Error(s) parsing property list: {91, 26}: Error(s) parsing table actions: Cannot find b in lexical scope." - ), - SpecialCompilers.ProgramCompiler.Compile(simple_parser_declaration)) - ) -} - -@Test func test_simple_control_declaration_with_misnamed_actions2() async throws { - let simple_parser_declaration = """ - control simple() { - action a() { - } - table t { - key = { - true: exact; - } - actions = { - a; - b; - } - } - apply { - } - }; - """ - #expect( - #RequireErrorResult( - Error( - withMessage: - "{54, 72}: Error(s) parsing property list: {91, 35}: Error(s) parsing table actions: Cannot find b in lexical scope." - ), - SpecialCompilers.ProgramCompiler.Compile(simple_parser_declaration)) - ) -} - -@Test func test_simple_control_declaration_with_mistyped_actions() async throws { - let simple_parser_declaration = """ - bool a() { - return true; - }; - control simple() { - table t { - key = { - true: exact; - } - actions = { - a; - } - } - apply { - } - }; - """ - #expect( - #RequireErrorResult( - Error( - withMessage: - "{64, 63}: Error(s) parsing property list: {101, 26}: Error(s) parsing table actions: {101, 26}: a does not name an action" - ), - SpecialCompilers.ProgramCompiler.Compile(simple_parser_declaration)) - ) -} - -@Test func test_simple_control_declaration_with_parameters() async throws { - let simple_parser_declaration = """ - control simple(bool x, bool y) { - action a() { - } - table t { - key = { - x: exact; - y: exact; - } - } - apply { - } - }; - """ - #expect(#RequireOkResult(SpecialCompilers.ProgramCompiler.Compile(simple_parser_declaration))) -} - -@Test func test_simple_control_declaration_with_multiple_tables() async throws { - let simple_parser_declaration = """ - control simple(bool x, bool y, bool a, bool b) { - action a() { - } - table t { - key = { - x: exact; - y: exact; - } - } - table u { - key = { - a: exact; - b: exact; - } - } - apply { - } - }; - """ - #expect( - #RequireErrorResult( - Error( - withMessage: "{0, 215}: More than one table in control declaration" - ), - SpecialCompilers.ProgramCompiler.Compile(simple_parser_declaration)) - ) -} - -@Test func test_simple_control_declaration_with_action_using_parameter() async throws { - let simple_parser_declaration = """ - control simple(bool x, bool y) { - action a(int z) { - z = 5; - } - table t { - key = { - x: exact; - y: exact; - } - } - apply { - } - }; - """ - #expect(#RequireOkResult(SpecialCompilers.ProgramCompiler.Compile(simple_parser_declaration))) -} - -@Test func test_simple_control_declaration_with_action_using_parameter_wrong_type() async throws { - let simple_parser_declaration = """ - control simple(bool x, bool y) { - action a(int z) { - z = false; - } - table t { - key = { - x: exact; - y: exact; - } - } - apply { - } - }; - """ - #expect( - #RequireErrorResult( - Error( - withMessage: - "{57, 10}: Failed to parse a statement element: {57, 1}: Cannot assign value with type Boolean to identifier z with type Int (width: Infinite)" - ), - SpecialCompilers.ProgramCompiler.Compile(simple_parser_declaration)) - ) -} - -@Test func test_simple_control_declaration_with_element_after_apply() async throws { - let simple_parser_declaration = """ - control simple(bool x, bool y) { - action a(int z) { - z = false; - } - table t { - key = { - x: exact; - y: exact; - } - } - apply { - } - table x { - key = { - x: exact; - y: exact; - } - } - }; - """ - #expect( - #RequireErrorResult( - Error( - withMessage: - "Could not compile the P4 program" - ), - SpecialCompilers.ProgramCompiler.Compile(simple_parser_declaration)) - ) -} - -@Test func test_simple_control_declaration_with_action_with_params_right_order() async throws { - let simple_parser_declaration = """ - control simple(int x, int y) { - action a(inout int ax, bool ay) { - ax = 5; - } - table t { - key = { - x: exact; - y: exact; - } - } - apply { - } - }; - """ - - let x = { (tipe: P4Type) -> Bool in - switch tipe { - case let c as Control: c.name == "simple" - default: false - } - } - let program = try! #UseOkResult(SpecialCompilers.ProgramCompiler.Compile(simple_parser_declaration)) - #expect(program.TypesWithTypes(x).count == 1) -} - -@Test func test_simple_control_declaration_with_action_with_params_wrong_order() async throws { - let simple_parser_declaration = """ - control simple(int x, int y) { - action a(int ax, inout bool ay) { - ay = false; - } - table t { - key = { - x: exact; - y: exact; - } - } - apply { - } - }; - """ - #expect( - #RequireErrorResult( - ErrorWithLocation( - sourceLocation: SourceLocation(41, 23), - withError: "All parameters with direction must precede directionless parameters"), - SpecialCompilers.ProgramCompiler.Compile(simple_parser_declaration)) - ) -} - -@Test func test_simple_control_declaration_with_action_with_params_wrong_order_interspersed() async throws { - let simple_parser_declaration = """ - control simple(int x, int y) { - action a(inout bool aa, int ax, inout bool ay) { - aa = false; - } - table t { - key = { - x: exact; - y: exact; - } - } - apply { - } - }; - """ - #expect( - #RequireErrorResult( - ErrorWithLocation( - sourceLocation: SourceLocation(41, 38), - withError: "All parameters with direction must precede directionless parameters"), - SpecialCompilers.ProgramCompiler.Compile(simple_parser_declaration)) - ) -} diff --git a/Tests/p4rseTests/ControlTests/Runtime.swift b/Tests/p4rseTests/ControlTests/Runtime.swift deleted file mode 100644 index ea11403..0000000 --- a/Tests/p4rseTests/ControlTests/Runtime.swift +++ /dev/null @@ -1,623 +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 . - -import Common -import Foundation -import Macros -import P4Lang -import P4Runtime -import SwiftTreeSitter -import Testing -import TreeSitter -import TreeSitterP4 - -@testable import P4Compiler - -@Test func test_control_single_key() async throws { - let simple_parser_declaration = """ - control simple(inout int result, bool x) { - action a() { - result = 5; - } - action b() { - result = 7; - } - table t { - key = { - x: exact; - } - actions = { - a; - b; - } - } - apply { - } - }; - """ - - let program = try! #UseOkResult(SpecialCompilers.ProgramCompiler.Compile(simple_parser_declaration)) - - // Pull the control out of the compiled program. - let controls = program.TypesWithTypes { (tipe: P4Type) -> Bool in - return switch tipe { - case let c as Control: c.name == "simple" - default: false - } - } - var control = ((controls[0]) as! Control) - - // Add entries to the table. - control = control.updateTable( - addEntry: ( - P4Value(P4BooleanValue(withValue: true)), - TypedIdentifier(name: "a", withType: P4QualifiedType(Action())) - ) - ).updateTable( - addEntry: ( - P4Value(P4BooleanValue(withValue: false)), - TypedIdentifier(name: "b", withType: P4QualifiedType(Action())) - )) - - // Set a variable in the global scope for the inout first parameter. - var global_values = VarValueScopes().enter() - global_values = global_values.declare( - identifier: Identifier(name: "result_arg"), - withValue: P4Value( - P4IntValue(withValue: 0), - P4QualifiedType(P4Int()))) - - let runtime = try #UseOkResult( - P4Runtime.Runtime.create( - control: control, withGlobalValues: global_values)) - - let (hit_miss, updated_execution) = try #UseOkResult( - runtime.run( - withArguments: ArgumentList([ - Argument( - TypedIdentifier(name: "result_arg", withType: P4QualifiedType(P4Int())), atIndex: 0), - Argument(P4Value(P4BooleanValue(withValue: true)), atIndex: 1), - ]))) - - // We expect there to be a hit. - #expect(hit_miss == P4TableHitMissValue.Hit) - - // And that the proper action was invoked. - let result_arg = try #UseOkResult( - updated_execution.scopes.lookup(identifier: Identifier(name: "result_arg"))) - #expect(result_arg.eq(P4Value(P4IntValue(withValue: 5)))) -} - -@Test func test_control_single_key_false() async throws { - let simple_parser_declaration = """ - control simple(inout int result, bool x) { - action a() { - result = 5; - } - action b() { - result = 7; - } - table t { - key = { - x: exact; - } - actions = { - a; - b; - } - } - apply { - } - }; - """ - - let program = try! #UseOkResult(SpecialCompilers.ProgramCompiler.Compile(simple_parser_declaration)) - - // Pull the control out of the compiled program. - let controls = program.TypesWithTypes { (tipe: P4Type) -> Bool in - switch tipe { - case let c as Control: c.name == "simple" - default: false - } - } - var control = ((controls[0]) as! Control) - - // Add entries to the table. - control = control.updateTable( - addEntry: ( - P4Value(P4BooleanValue(withValue: true)), - TypedIdentifier(name: "a", withType: P4QualifiedType(Action())) - ) - ).updateTable( - addEntry: ( - P4Value(P4BooleanValue(withValue: false)), - TypedIdentifier(name: "b", withType: P4QualifiedType(Action())) - )) - - // Set a variable in the global scope for the inout first parameter. - var global_values = VarValueScopes().enter() - global_values = global_values.declare( - identifier: Identifier(name: "result_arg"), - withValue: P4Value( - P4IntValue(withValue: 0), - P4QualifiedType(P4Int()))) - - let runtime = try #UseOkResult( - P4Runtime.Runtime.create( - control: control, withGlobalValues: global_values)) - - let (hit_miss, updated_execution) = try #UseOkResult( - runtime.run( - withArguments: ArgumentList([ - Argument( - TypedIdentifier(name: "result_arg", withType: P4QualifiedType(P4Int())), atIndex: 0), - Argument(P4Value(P4BooleanValue(withValue: false)), atIndex: 1), - ]))) - - // We expect there to be a hit. - #expect(hit_miss == P4TableHitMissValue.Hit) - - // And that the proper action was invoked. - let result_arg = try #UseOkResult( - updated_execution.scopes.lookup(identifier: Identifier(name: "result_arg"))) - #expect(result_arg.eq(P4Value(P4IntValue(withValue: 7)))) -} - -@Test func test_control_single_integer_key_hit() async throws { - let simple_parser_declaration = """ - control simple(inout int result, int x) { - action a() { - result = 5; - } - action b() { - result = 7; - } - table t { - key = { - x: exact; - } - actions = { - a; - b; - } - } - apply { - } - }; - """ - - let program = try! #UseOkResult(SpecialCompilers.ProgramCompiler.Compile(simple_parser_declaration)) - - // Pull the control out of the compiled program. - let controls = program.TypesWithTypes { (tipe: P4Type) -> Bool in - switch tipe { - case let c as Control: c.name == "simple" - default: false - } - } - var control = ((controls[0]) as! Control) - - // Add entries to the table. - control = control.updateTable( - addEntry: ( - P4Value(P4IntValue(withValue: 5)), - TypedIdentifier(name: "a", withType: P4QualifiedType(Action())) - ) - ).updateTable( - addEntry: ( - P4Value(P4IntValue(withValue: 2)), - TypedIdentifier(name: "b", withType: P4QualifiedType(Action())) - )) - - // Set a variable in the global scope for the inout first parameter. - var global_values = VarValueScopes().enter() - global_values = global_values.declare( - identifier: Identifier(name: "result_arg"), - withValue: P4Value( - P4IntValue(withValue: 0), - P4QualifiedType(P4Int()))) - - let runtime = try #UseOkResult( - P4Runtime.Runtime.create( - control: control, withGlobalValues: global_values)) - - let (hit_miss, updated_execution) = try #UseOkResult( - runtime.run( - withArguments: ArgumentList([ - Argument( - TypedIdentifier(name: "result_arg", withType: P4QualifiedType(P4Int())), atIndex: 0), - Argument(P4Value(P4IntValue(withValue: 5)), atIndex: 1), - ]))) - - // We expect there to be a hit. - #expect(hit_miss == P4TableHitMissValue.Hit) - - let result_arg = try #UseOkResult( - updated_execution.scopes.lookup(identifier: Identifier(name: "result_arg"))) - #expect(result_arg.eq(P4Value(P4IntValue(withValue: 5)))) -} - -@Test func test_control_single_integer_key_miss() async throws { - let simple_parser_declaration = """ - control simple(inout int result, int x) { - action a() { - result = 5; - } - action b() { - result = 7; - } - table t { - key = { - x: exact; - } - actions = { - a; - b; - } - } - apply { - } - }; - """ - - let program = try! #UseOkResult(SpecialCompilers.ProgramCompiler.Compile(simple_parser_declaration)) - - // Pull the control out of the compiled program. - let controls = program.TypesWithTypes { (tipe: P4Type) -> Bool in - return switch tipe { - case let c as Control: c.name == "simple" - default: false - } - } - var control = ((controls[0]) as! Control) - - // Add entries to the table. - control = control.updateTable( - addEntry: ( - P4Value(P4IntValue(withValue: 1)), - TypedIdentifier(name: "a", withType: P4QualifiedType(Action())) - ) - ).updateTable( - addEntry: ( - P4Value(P4IntValue(withValue: 2)), - TypedIdentifier(name: "b", withType: P4QualifiedType(Action())) - )) - - // Set a variable in the global scope for the inout first parameter. - var global_values = VarValueScopes().enter() - global_values = global_values.declare( - identifier: Identifier(name: "result_arg"), - withValue: P4Value( - P4IntValue(withValue: 0), - P4QualifiedType(P4Int()))) - - let runtime = try #UseOkResult( - P4Runtime.Runtime.create( - control: control, withGlobalValues: global_values)) - - let (hit_miss, updated_execution) = try #UseOkResult( - runtime.run( - withArguments: ArgumentList([ - Argument( - TypedIdentifier(name: "result_arg", withType: P4QualifiedType(P4Int())), atIndex: 0), - Argument(P4Value(P4IntValue(withValue: 3)), atIndex: 1), - ]))) - - // We expect there to be a hit. - #expect(hit_miss == P4TableHitMissValue.Miss) - - let result_arg = try #UseOkResult( - updated_execution.scopes.lookup(identifier: Identifier(name: "result_arg"))) - #expect(result_arg.eq(P4Value(P4IntValue(withValue: 0)))) -} - -@Test func test_control_multiple_keys() async throws { - let simple_parser_declaration = """ - control simple(inout int result, bool x, int f) { - action a() { - result = 5; - } - action b() { - result = 7; - } - table t { - key = { - x: exact; - f: exact; - } - actions = { - a; - b; - } - } - apply { - } - }; - """ - - let program = try! #UseOkResult(SpecialCompilers.ProgramCompiler.Compile(simple_parser_declaration)) - - // Pull the control out of the compiled program. - let controls = program.TypesWithTypes { (tipe: P4Type) -> Bool in - return switch tipe { - case let c as Control: c.name == "simple" - default: false - } - } - var control = ((controls[0]) as! Control) - - // Add entries to the table. - control = control.updateTable( - addEntry: ( - P4Value(P4BooleanValue(withValue: true)), - TypedIdentifier(name: "a", withType: P4QualifiedType(Action())) - ) - ).updateTable( - addEntry: ( - P4Value(P4IntValue(withValue: 5)), - TypedIdentifier(name: "b", withType: P4QualifiedType(Action())) - )) - - // Set a variable in the global scope for the inout first parameter. - var global_values = VarValueScopes().enter() - global_values = global_values.declare( - identifier: Identifier(name: "result_arg"), - withValue: P4Value( - P4IntValue(withValue: 0), - P4QualifiedType(P4Int()))) - - let runtime = try #UseOkResult( - P4Runtime.Runtime.create( - control: control, withGlobalValues: global_values)) - - let (hit_miss, updated_execution) = try #UseOkResult( - runtime.run( - withArguments: ArgumentList([ - Argument( - TypedIdentifier(name: "result_arg", withType: P4QualifiedType(P4Int())), atIndex: 0), - Argument(P4Value(P4BooleanValue(withValue: false)), atIndex: 1), // false will make the x key miss. - Argument(P4Value(P4IntValue(withValue: 5)), atIndex: 2), - ]))) - - // We expect there to be a hit -- but from the second key! - #expect(hit_miss == P4TableHitMissValue.Hit) - - // And that the proper action was invoked. - let result_arg = try #UseOkResult( - updated_execution.scopes.lookup(identifier: Identifier(name: "result_arg"))) - #expect(result_arg.eq(P4Value(P4IntValue(withValue: 7)))) -} - -@Test func test_control_key_from_struct() async throws { - let simple_parser_declaration = """ - struct K { - int i; - int j; - }; - control simple(inout int result, K k) { - action a() { - result = 5; - } - action b() { - result = 7; - } - table t { - key = { - k.i: exact; - } - actions = { - a; - b; - } - } - apply { - } - }; - """ - - let program = try! #UseOkResult(SpecialCompilers.ProgramCompiler.Compile(simple_parser_declaration)) - - // Pull the control out of the compiled program. - let controls = program.TypesWithTypes { (tipe: P4Type) -> Bool in - return switch tipe { - case let c as Control: c.name == "simple" - default: false - } - } - var control = ((controls[0]) as! Control) - - let k_fields = P4StructFields([ - P4StructFieldIdentifier(name: "i", withType: P4QualifiedType(P4Int())), - P4StructFieldIdentifier(name: "j", withType: P4QualifiedType(P4Int())), - ]) - let k_type = P4Struct(withName: Identifier(name: "K"), andFields: k_fields) - - let k_instance = P4StructValue( - withType: k_type, - andInitializers: [ - P4Value(P4IntValue(withValue: 5)), - P4Value(P4IntValue(withValue: 1)), - ]) - - // Add entries to the table. - control = control.updateTable( - addEntry: ( - P4Value(P4IntValue(withValue: 5)), - TypedIdentifier(name: "a", withType: P4QualifiedType(Action())) - ) - ).updateTable( - addEntry: ( - P4Value(P4IntValue(withValue: 4)), - TypedIdentifier(name: "b", withType: P4QualifiedType(Action())) - )) - - // Set a variable in the global scope for the inout first parameter. - var global_values = VarValueScopes().enter() - global_values = global_values.declare( - identifier: Identifier(name: "result_arg"), - withValue: P4Value( - P4IntValue(withValue: 0), - P4QualifiedType(P4Int()))) - - let runtime = try #UseOkResult( - P4Runtime.Runtime.create( - control: control, withGlobalValues: global_values)) - - let (hit_miss, updated_execution) = try #UseOkResult( - runtime.run( - withArguments: ArgumentList([ - Argument( - TypedIdentifier(name: "result_arg", withType: P4QualifiedType(P4Int())), atIndex: 0), - Argument(P4Value(k_instance), atIndex: 1), - ]))) - - // We expect there to be a hit. - #expect(hit_miss == P4TableHitMissValue.Hit) - - // And that the proper action was invoked. - let result_arg = try #UseOkResult( - updated_execution.scopes.lookup(identifier: Identifier(name: "result_arg"))) - #expect(result_arg.eq(P4Value(P4IntValue(withValue: 5)))) - - // Now, check whether the b action can be invoked. - let k_instance2 = P4StructValue( - withType: k_type, - andInitializers: [ - P4Value(P4IntValue(withValue: 4)), - P4Value(P4IntValue(withValue: 1)), - ]) - - // Set a variable in the global scope for the inout first parameter. - var next_global_values = VarValueScopes().enter() - next_global_values = global_values.declare( - identifier: Identifier(name: "result_arg"), - withValue: P4Value( - P4IntValue(withValue: 0), - P4QualifiedType(P4Int()))) - - let runtime2 = try #UseOkResult( - P4Runtime.Runtime.create( - control: control, withGlobalValues: next_global_values)) - - let (hit_miss2, updated_execution2) = try #UseOkResult( - runtime2.run( - withArguments: ArgumentList([ - Argument( - TypedIdentifier(name: "result_arg", withType: P4QualifiedType(P4Int())), atIndex: 0), - Argument(P4Value(k_instance2), atIndex: 1), - ]))) - - // We expect there to be a hit. - #expect(hit_miss2 == P4TableHitMissValue.Hit) - - // And that the proper action was invoked. - let result_arg2 = try #UseOkResult( - updated_execution2.scopes.lookup(identifier: Identifier(name: "result_arg"))) - #expect(result_arg2.eq(P4Value(P4IntValue(withValue: 7)))) -} - -@Test func test_control_key_from_struct_miss() async throws { - let simple_parser_declaration = """ - struct K { - int i; - int j; - }; - control simple(inout int result, K k) { - action a() { - result = 5; - } - action b() { - result = 7; - } - table t { - key = { - k.i: exact; - } - actions = { - a; - b; - } - } - apply { - } - }; - """ - - let program = try! #UseOkResult(SpecialCompilers.ProgramCompiler.Compile(simple_parser_declaration)) - - // Pull the control out of the compiled program. - let controls = program.TypesWithTypes { (tipe: P4Type) -> Bool in - return switch tipe { - case let c as Control: c.name == "simple" - default: false - } - } - var control = ((controls[0]) as! Control) - - let k_fields = P4StructFields([ - P4StructFieldIdentifier(name: "i", withType: P4QualifiedType(P4Int())), - P4StructFieldIdentifier(name: "j", withType: P4QualifiedType(P4Int())), - ]) - let k_type = P4Struct(withName: Identifier(name: "K"), andFields: k_fields) - - let k_instance = P4StructValue( - withType: k_type, - andInitializers: [ - P4Value(P4IntValue(withValue: 8)), - P4Value(P4IntValue(withValue: 1)), - ]) - - // Add entries to the table. - control = control.updateTable( - addEntry: ( - P4Value(P4IntValue(withValue: 5)), - TypedIdentifier(name: "a", withType: P4QualifiedType(Action())) - ) - ).updateTable( - addEntry: ( - P4Value(P4IntValue(withValue: 4)), - TypedIdentifier(name: "b", withType: P4QualifiedType(Action())) - )) - - // Set a variable in the global scope for the inout first parameter. - var global_values = VarValueScopes().enter() - global_values = global_values.declare( - identifier: Identifier(name: "result_arg"), - withValue: P4Value( - P4IntValue(withValue: 0), - P4QualifiedType(P4Int()))) - - let runtime = try #UseOkResult( - P4Runtime.Runtime.create( - control: control, withGlobalValues: global_values)) - - let (hit_miss, updated_execution) = try #UseOkResult( - runtime.run( - withArguments: ArgumentList([ - Argument( - TypedIdentifier(name: "result_arg", withType: P4QualifiedType(P4Int())), atIndex: 0), - Argument(P4Value(k_instance), atIndex: 1), - ]))) - - // We expect there to be a hit. - #expect(hit_miss == P4TableHitMissValue.Miss) - - // And that the proper action was invoked. - let result_arg = try #UseOkResult( - updated_execution.scopes.lookup(identifier: Identifier(name: "result_arg"))) - #expect(result_arg.eq(P4Value(P4IntValue(withValue: 0)))) -} diff --git a/Tests/p4rseTests/Declarations.swift b/Tests/p4rseTests/Declarations.swift deleted file mode 100644 index 7b3e5bf..0000000 --- a/Tests/p4rseTests/Declarations.swift +++ /dev/null @@ -1,205 +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 . - -import Common -import Foundation -import Macros -import P4Runtime -import P4Lang -import SwiftTreeSitter -import Testing -import TreeSitter -import TreeSitterP4 - -@testable import P4Compiler - -@Test func test_struct_declaration_and_field_write() async throws { - let simple_parser_declaration = """ - struct Testing { - bool yesno; - int count; - }; - parser main_parser() { - state start { - Testing ts; - ts.yesno = true; - bool where_to = ts.yesno; - transition select (where_to) { - true: accept; - false: reject; - }; - } - }; - """ - let program = try #UseOkResult( - SpecialCompilers.ProgramCompiler.Compile(simple_parser_declaration)) - let runtime = try #UseOkResult(P4Runtime.Runtime.create(program: program)) - let (state_result, _) = try! #UseOkResult(runtime.run()) - #expect(state_result == P4Lang.accept) -} - -@Test func test_struct_declaration_and_field_write_field_read() async throws { - let simple_parser_declaration = """ - struct Testing { - bool yesno; - int count; - }; - parser main_parser() { - state start { - Testing ts; - ts.yesno = true; - ts.count = 5; - transition select (ts.count == 5) { - true: accept; - false: reject; - }; - } - }; - """ - let program = try #UseOkResult( - SpecialCompilers.ProgramCompiler.Compile(simple_parser_declaration)) - let runtime = try #UseOkResult(P4Runtime.Runtime.create(program: program)) - let (state_result, _) = try! #UseOkResult(runtime.run()) - #expect(state_result == P4Lang.accept) -} - -@Test func test_struct_declaration_and_field_read_defaults() async throws { - let simple_parser_declaration = """ - struct Testing { - bool yesno; - int count; - }; - parser main_parser() { - state start { - Testing ts; - transition select (ts.count == 0) { - true: accept; - false: reject; - }; - } - }; - """ - let program = try #UseOkResult( - SpecialCompilers.ProgramCompiler.Compile(simple_parser_declaration)) - let runtime = try #UseOkResult(P4Runtime.Runtime.create(program: program)) - let (state_result, _) = try! #UseOkResult(runtime.run()) - #expect(state_result == P4Lang.accept) -} - -@Test func test_struct_declaration_and_field_read_defaults_sc() async throws { - let simple_parser_declaration = """ - struct Testing { - bool yesno; - int count; - }; - parser main_parser() { - state start { - Testing ts; - transition select (ts.count) { - 0: accept; - _: reject; - }; - } - }; - """ - let program = try #UseOkResult( - SpecialCompilers.ProgramCompiler.Compile(simple_parser_declaration)) - let runtime = try #UseOkResult(P4Runtime.Runtime.create(program: program)) - let (state_result, _) = try! #UseOkResult(runtime.run()) - #expect(state_result == P4Lang.accept) -} - -@Test func test_struct_declaration_and_field_read_defaults_sc2() async throws { - let simple_parser_declaration = """ - struct Testing { - bool yesno; - int count; - }; - parser main_parser() { - state start { - Testing ts; - ts.count = 1; - transition select (ts.count) { - 0: accept; - _: reject; - }; - } - }; - """ - let program = try #UseOkResult( - SpecialCompilers.ProgramCompiler.Compile(simple_parser_declaration)) - let runtime = try #UseOkResult(P4Runtime.Runtime.create(program: program)) - let (state_result, _) = try! #UseOkResult(runtime.run()) - #expect(state_result == P4Lang.reject) -} - -@Test func test_function_declaration() async throws { - let simple_parser_declaration = """ - bool functionb() { - int count; - }; - """ - #expect(#RequireOkResult(SpecialCompilers.ProgramCompiler.Compile(simple_parser_declaration))) -} - - -@Test func test_function_declaration_with_parameters() async throws { - let simple_parser_declaration = """ - bool functionb(bool x) { - x = true; - }; - """ - #expect(#RequireOkResult(SpecialCompilers.ProgramCompiler.Compile(simple_parser_declaration))) -} - -@Test func test_function_declaration_with_parameters_and_direction() async throws { - let simple_parser_declaration = """ - bool functionb(in bool x, out string y, inout int z) { - x = true; - }; - """ - #expect( - #RequireErrorResult( - Error( - withMessage: - "{63, 9}: Failed to parse a statement element: {63, 1}: Cannot assign value with type Boolean to identifier x that is in parameter" - ), - SpecialCompilers.ProgramCompiler.Compile(simple_parser_declaration)) - ) -} - -@Test func test_function_declaration_with_parameters_and_direction_struct() async throws { - let simple_parser_declaration = """ - struct Testing { - bool yesno; - int count; - }; - bool functionb(in Testing x, out string y, inout int z) { - x.yesno = true; - }; - """ - #expect( - #RequireErrorResult( - Error( - withMessage: - "{120, 15}: Failed to parse a statement element: {120, 7}: Cannot assign to field yesno of x that is in parameter" - ), - SpecialCompilers.ProgramCompiler.Compile(simple_parser_declaration)) - ) - -} - diff --git a/Tests/p4rseTests/ErrorTests/Formatting.swift b/Tests/p4rseTests/ErrorTests/Formatting.swift deleted file mode 100644 index 000fde1..0000000 --- a/Tests/p4rseTests/ErrorTests/Formatting.swift +++ /dev/null @@ -1,58 +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 . - -import Common -import Foundation -import Macros -import P4Lang -import P4Runtime -import SwiftTreeSitter -import Testing -import TreeSitter -import TreeSitterP4 - -@testable import P4Compiler - -@Test func test_error_with_location_formatting() async throws { - let formatter = FormatterAnsi() - let e = ErrorWithLocation(sourceLocation: SourceLocation(1, 5), withError: "There was an error") - let formatted = e.format(formatter) - #expect(formatted == "\u{1B}[31;1m{1, 5}\u{1B}[0m: There was an error") -} - -@Test func test_errors_with_location_no_formatting() async throws { - let e = ErrorWithLocation(sourceLocation: SourceLocation(1, 5), withError: "There was an error") - let e1 = ErrorWithLocation( - sourceLocation: SourceLocation(10, 5), withError: "There was another error") - - let formatted = e.append(error: e1).format(FormatterPlain()) - - #expect(formatted == "{1, 5}: There was an error\n{10, 5}: There was another error") -} - -@Test func test_errors_with_location_ansi_formatting() async throws { - let e = ErrorWithLocation(sourceLocation: SourceLocation(1, 5), withError: "There was an error") - let e1 = ErrorWithLocation( - sourceLocation: SourceLocation(10, 5), withError: "There was another error") - - let formatted = e.append(error: e1).format(FormatterAnsi()) - - #expect( - formatted - == "\u{1B}[31;1m{1, 5}\u{1B}[0m: There was an error\n\u{1B}[31;1m{10, 5}\u{1B}[0m: There was another error" - ) -} diff --git a/Tests/p4rseTests/ExpressionTests.swift b/Tests/p4rseTests/ExpressionTests.swift deleted file mode 100644 index 35a27ff..0000000 --- a/Tests/p4rseTests/ExpressionTests.swift +++ /dev/null @@ -1,88 +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 . - -import Common -import Foundation -import Macros -import P4Lang -import P4Runtime -import SwiftTreeSitter -import Testing -import TreeSitter -import TreeSitterP4 - -@testable import P4Compiler - -@Test func test_expression_grouped_equal() async throws { - let simple_parser_declaration = """ - parser main_parser() { - state start { - bool x = (true == (1 < 4)); - transition select (x) { - false: reject; - true: accept; - }; - } - }; - """ - - let program = try #UseOkResult(SpecialCompilers.ProgramCompiler.Compile(simple_parser_declaration)) - let runtime = try #UseOkResult(P4Runtime.Runtime.create(program: program)) - let (state_result, _) = try! #UseOkResult(runtime.run()) - - #expect(state_result == P4Lang.accept) -} - -@Test func test_expression_grouped_or() async throws { - let simple_parser_declaration = """ - parser main_parser() { - state start { - bool x = (false || (1 < 4)); - transition select (x) { - false: reject; - true: accept; - }; - } - }; - """ - - let program = try #UseOkResult(SpecialCompilers.ProgramCompiler.Compile(simple_parser_declaration)) - let runtime = try #UseOkResult(P4Runtime.Runtime.create(program: program)) - let (state_result, _) = try! #UseOkResult(runtime.run()) - - #expect(state_result == P4Lang.accept) -} - -@Test func test_expression_grouped_and() async throws { - let simple_parser_declaration = """ - parser main_parser() { - state start { - bool x = (false && (1 < 4)); - transition select (x) { - false: reject; - true: accept; - }; - } - }; - """ - - let program = try #UseOkResult(SpecialCompilers.ProgramCompiler.Compile(simple_parser_declaration)) - let runtime = try #UseOkResult(P4Runtime.Runtime.create(program: program)) - let (state_result, _) = try! #UseOkResult(runtime.run()) - - #expect(state_result == P4Lang.reject) -} diff --git a/Tests/p4rseTests/ExpressionTests/FunctionCall.swift b/Tests/p4rseTests/ExpressionTests/FunctionCall.swift deleted file mode 100644 index 6689f4b..0000000 --- a/Tests/p4rseTests/ExpressionTests/FunctionCall.swift +++ /dev/null @@ -1,186 +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 . - -import Common -import Foundation -import Macros -import P4Lang -import P4Runtime -import SwiftTreeSitter -import Testing -import TreeSitter -import TreeSitterP4 - -@testable import P4Compiler - -@Test func test_function_call_scoped_name_collision() async throws { - let simple_parser_declaration = """ - bool functionb(bool c) { - return c; - }; - parser main_parser() { - state start { - int c = 5; - bool b = functionb(true); - transition select (b) { - false: reject; - true: accept; - }; - } - }; - """ - - let program = try #UseOkResult(SpecialCompilers.ProgramCompiler.Compile(simple_parser_declaration)) - let parser = try #UseOkResult(program.find_parser(withName: Identifier(name: "main_parser"))) - let runtime = try #UseOkResult(P4Runtime.Runtime.create(program: program)) - let (state_result, _) = try! #UseOkResult(runtime.run()) - - #expect(parser.states.count() == 1) - - #expect(state_result == P4Lang.accept) -} - -@Test func test_function_call_scoped_name_collision2() async throws { - // Test whether the assignment to c leaks out of the function call scope. - let simple_parser_declaration = """ - bool functionb(bool c) { - c = true; - return c; - }; - parser main_parser() { - state start { - bool c = false; - bool b = functionb(true); - transition select (c) { - false: reject; - true: accept; - }; - } - }; - """ - - let program = try #UseOkResult(SpecialCompilers.ProgramCompiler.Compile(simple_parser_declaration)) - let parser = try #UseOkResult(program.find_parser(withName: Identifier(name: "main_parser"))) - let runtime = try #UseOkResult(P4Runtime.Runtime.create(program: program)) - let (state_result, _) = try! #UseOkResult(runtime.run()) - - #expect(parser.states.count() == 1) - - #expect(state_result == P4Lang.reject) -} - -@Test func test_function_call_scoped_name_collision_inout() async throws { - let simple_parser_declaration = """ - bool functionb(inout bool c) { - c = true; - return c; - }; - parser main_parser() { - state start { - bool c = false; - bool b = functionb(c); - transition select (c) { - false: reject; - true: accept; - }; - } - }; - """ - - let program = try #UseOkResult(SpecialCompilers.ProgramCompiler.Compile(simple_parser_declaration)) - let parser = try #UseOkResult(program.find_parser(withName: Identifier(name: "main_parser"))) - let runtime = try #UseOkResult(P4Runtime.Runtime.create(program: program)) - let (state_result, _) = try! #UseOkResult(runtime.run()) - - #expect(parser.states.count() == 1) - - #expect(state_result == P4Lang.accept) -} - - -@Test func test_function_call_integer_return_value() async throws { - let simple_parser_declaration = """ - int functionb(int c) { - return c; - }; - parser main_parser() { - state start { - int c = 5; - transition select (5 == functionb(c)) { - false: reject; - true: accept; - }; - } - }; - """ - - let program = try #UseOkResult(SpecialCompilers.ProgramCompiler.Compile(simple_parser_declaration)) - let parser = try #UseOkResult(program.find_parser(withName: Identifier(name: "main_parser"))) - let runtime = try #UseOkResult(P4Runtime.Runtime.create(program: program)) - let (state_result, _) = try! #UseOkResult(runtime.run()) - - #expect(parser.states.count() == 1) - - #expect(state_result == P4Lang.accept) -} - -@Test func test_function_call_integer_return_value2() async throws { - let simple_parser_declaration = """ - int functionb(int c) { - return c; - }; - parser main_parser() { - state start { - int c = 5; - transition select (4 == functionb(c)) { - false: reject; - true: accept; - }; - } - }; - """ - - let program = try #UseOkResult(SpecialCompilers.ProgramCompiler.Compile(simple_parser_declaration)) - let parser = try #UseOkResult(program.find_parser(withName: Identifier(name: "main_parser"))) - let runtime = try #UseOkResult(P4Runtime.Runtime.create(program: program)) - let (state_result, _) = try! #UseOkResult(runtime.run()) - - #expect(parser.states.count() == 1) - - #expect(state_result == P4Lang.reject) -} - -@Test func test_function_call_invalid_return_type() async throws { - let simple_parser_declaration = """ - int functionb(int c) { - return true; - }; - parser main_parser() { - state start { - int c = 5; - transition select (4 == functionb(c)) { - false: reject; - true: accept; - }; - } - }; - """ - - let error = try #UseErrorResult(SpecialCompilers.ProgramCompiler.Compile(simple_parser_declaration)) - - #expect(error.msg().contains("{29, 12}: Type of expression in return statement (Boolean) is not compatible with function return type (Int (width: Infinite))")) -} diff --git a/Tests/p4rseTests/ExpressionTests/SelectExpression.swift b/Tests/p4rseTests/ExpressionTests/SelectExpression.swift deleted file mode 100644 index 0b116d8..0000000 --- a/Tests/p4rseTests/ExpressionTests/SelectExpression.swift +++ /dev/null @@ -1,203 +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 . - -import Common -import Foundation -import Macros -import P4Lang -import P4Runtime -import SwiftTreeSitter -import Testing -import TreeSitter -import TreeSitterP4 - -@testable import P4Compiler - -@Test func test_simple_parser_with_transition_select_case_nondefault_expressions() async throws { - let simple_parser_declaration = """ - parser main_parser() { - state start { - transition select (true) { - false: reject; - true: accept; - }; - } - }; - """ - - let program = try #UseOkResult(SpecialCompilers.ProgramCompiler.Compile(simple_parser_declaration)) - let parser = try #UseOkResult(program.find_parser(withName: Identifier(name: "main_parser"))) - let runtime = try #UseOkResult(P4Runtime.Runtime.create(program: program)) - let (state_result, _) = try! #UseOkResult(runtime.run()) - - #expect(parser.states.count() == 1) - - #expect(state_result == P4Lang.accept) -} - -@Test func test_simple_parser_with_transition_select_case_default_expression() async throws { - let simple_parser_declaration = """ - parser main_parser() { - state start { - transition select (5) { - 5: reject; - _: accept; - }; - } - }; - """ - - let program = try #UseOkResult(SpecialCompilers.ProgramCompiler.Compile(simple_parser_declaration)) - let parser = try #UseOkResult(program.find_parser(withName: Identifier(name: "main_parser"))) - let runtime = try #UseOkResult(P4Runtime.Runtime.create(program: program)) - let (state_result, _) = try! #UseOkResult(runtime.run()) - - #expect(parser.states.count() == 1) - - #expect(state_result == P4Lang.reject) -} - -@Test func test_simple_parser_with_transition_select_case_default_expression2() async throws { - let simple_parser_declaration = """ - parser main_parser() { - state start { - transition select (1) { - 5: reject; - _: accept; - }; - } - }; - """ - - let program = try #UseOkResult(SpecialCompilers.ProgramCompiler.Compile(simple_parser_declaration)) - let parser = try #UseOkResult(program.find_parser(withName: Identifier(name: "main_parser"))) - let runtime = try #UseOkResult(P4Runtime.Runtime.create(program: program)) - let (state_result, _) = try! #UseOkResult(runtime.run()) - - #expect(parser.states.count() == 1) - - #expect(state_result == P4Lang.accept) -} - -@Test func test_simple_parser_with_transition_select_case_default_expression3() async throws { - let simple_parser_declaration = """ - parser main_parser() { - state start { - transition select (6) { - 5: reject; - 6: reject; - _: accept; - }; - } - }; - """ - let program = try #UseOkResult(SpecialCompilers.ProgramCompiler.Compile(simple_parser_declaration)) - let parser = try #UseOkResult(program.find_parser(withName: Identifier(name: "main_parser"))) - let runtime = try #UseOkResult(P4Runtime.Runtime.create(program: program)) - let (state_result, _) = try! #UseOkResult(runtime.run()) - - #expect(parser.states.count() == 1) - - #expect(state_result == P4Lang.reject) -} - -@Test func test_simple_parser_with_transition_select_case_invalid_type() async throws { - let simple_parser_declaration = """ - parser main_parser() { - state start { - transition select (6) { - true: reject; - 6: reject; - _: accept; - }; - } - }; - """ - - #expect( - #RequireErrorResult( - Error( - withMessage: - "Error(s) parsing select cases: {81, 4}: Key expression of type Boolean is not compatible with selector type Int (width: Infinite)" - ), - SpecialCompilers.ProgramCompiler.Compile(simple_parser_declaration))) -} - -@Test func test_select_expression_selection_order() async throws { - let simple_parser_declaration = """ - parser main_parser() { - state start { - transition select (5) { - 5: reject; - 5: accept; - _: accept; - }; - } - }; - """ - let program = try #UseOkResult(SpecialCompilers.ProgramCompiler.Compile(simple_parser_declaration)) - let parser = try #UseOkResult(program.find_parser(withName: Identifier(name: "main_parser"))) - let runtime = try #UseOkResult(P4Runtime.Runtime.create(program: program)) - let (state_result, _) = try! #UseOkResult(runtime.run()) - - #expect(parser.states.count() == 1) - - #expect(state_result == P4Lang.reject) - -} - -@Test func test_select_expression_from_parser_parameters() async throws { - let simple_parser_declaration = """ - parser main_parser(bool pmtr, string smtr, int imtr) { - state start { - transition select (pmtr) { - true: accept; - false: reject; - }; - } - }; - """ - let program = try #UseOkResult(SpecialCompilers.ProgramCompiler.Compile(simple_parser_declaration)) - let runtime = try #UseOkResult(P4Runtime.Runtime.create(program: program)) - - let args = ArgumentList([ - Argument(P4Value(P4BooleanValue(withValue: false)), atIndex: 1), Argument(P4Value(P4StringValue(withValue: "Testing")), atIndex: 2), Argument(P4Value(P4IntValue(withValue: 5)), atIndex: 3), - ]) - let (state_result, _) = try! #UseOkResult(runtime.run(withArguments: args)) - #expect(state_result == P4Lang.reject) -} - -@Test func test_select_expression_from_parser_parameters2() async throws { - let simple_parser_declaration = """ - parser main_parser(bool pmtr, string smtr, int imtr) { - state start { - transition select (imtr == 5) { - true: accept; - false: reject; - }; - } - }; - """ - let program = try #UseOkResult(SpecialCompilers.ProgramCompiler.Compile(simple_parser_declaration)) - let runtime = try #UseOkResult(P4Runtime.Runtime.create(program: program)) - - let args = ArgumentList([ - Argument(P4Value(P4BooleanValue(withValue: false)), atIndex: 1), Argument(P4Value(P4StringValue(withValue: "Testing")), atIndex: 2), Argument(P4Value(P4IntValue(withValue: 5)), atIndex: 3), - ]) - let (state_result, _) = try! #UseOkResult(runtime.run(withArguments: args)) - #expect(state_result == P4Lang.accept) -} \ No newline at end of file diff --git a/Tests/p4rseTests/ExternDeclarations.swift b/Tests/p4rseTests/ExternDeclarations.swift deleted file mode 100644 index cb2780f..0000000 --- a/Tests/p4rseTests/ExternDeclarations.swift +++ /dev/null @@ -1,124 +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 . - -import Common -import Foundation -import Macros -import P4Lang -import P4Runtime -import SwiftTreeSitter -import Testing -import TreeSitter -import TreeSitterP4 - -@testable import P4Compiler - -public struct Return5: P4FFI { - public func execute(execution: Common.ProgramExecution) -> ( - Common.ControlFlow, Common.ProgramExecution - ) { - return (ControlFlow.Return(P4Value(P4IntValue(withValue: 5))), execution) - } - - public func parameters() -> ParameterList { - return ParameterList() - } - - public func type() -> Common.P4QualifiedType { - return P4QualifiedType( - FunctionDeclaration( - named: Identifier(name: "externally"), ofType: P4QualifiedType(P4Int()), - withParameters: ParameterList(), withBody: .none?)) - } - - public init() {} -} - -public struct Return6: P4FFI { - public func execute(execution: Common.ProgramExecution) -> ( - Common.ControlFlow, Common.ProgramExecution - ) { - return (ControlFlow.Return(P4Value(P4IntValue(withValue: 6))), execution) - } - - public func parameters() -> ParameterList { - return ParameterList() - } - - public func type() -> Common.P4QualifiedType { - return P4QualifiedType( - FunctionDeclaration( - named: Identifier(name: "externally"), ofType: P4QualifiedType(P4Int()), - withParameters: ParameterList(), withBody: .none?)) - } - - public init() {} -} -@Test func test_extern_function_declaration() async throws { - let simple_parser_declaration = """ - extern int externally(); - parser main_parser() { - state start { - int t = externally(); - transition select (t == 5) { - true: accept; - false: reject; - }; - } - }; - """ - - let externally = Return5() - - let program = try! #UseOkResult( - SpecialCompilers.ProgramCompiler.Compile( - simple_parser_declaration, withGlobalInstances: .none, withGlobalTypes: .none, - withFFIs: [externally])) - - let runtime = try #UseOkResult(P4Runtime.Runtime.create(program: program)) - let (state_result, _) = try! #UseOkResult(runtime.run()) - - #expect(state_result == P4Lang.accept) - -} - -@Test func test_extern_function_declaration2() async throws { - let simple_parser_declaration = """ - extern int externally(); - parser main_parser() { - state start { - int t = externally(); - transition select (t == 5) { - true: accept; - false: reject; - }; - } - }; - """ - - let externally = Return6() - - let program = try! #UseOkResult( - SpecialCompilers.ProgramCompiler.Compile( - simple_parser_declaration, withGlobalInstances: .none, withGlobalTypes: .none, - withFFIs: [externally])) - - let runtime = try #UseOkResult(P4Runtime.Runtime.create(program: program)) - let (state_result, _) = try! #UseOkResult(runtime.run()) - - #expect(state_result == P4Lang.reject) -} diff --git a/Tests/p4rseTests/InterloperTests.swift b/Tests/p4rseTests/InterloperTests.swift deleted file mode 100644 index d31d5c0..0000000 --- a/Tests/p4rseTests/InterloperTests.swift +++ /dev/null @@ -1,115 +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 . - -import Common -import Foundation -import Macros -import P4Runtime -import P4Lang -import SwiftTreeSitter -import Testing -import TreeSitter -import TreeSitterP4 - -@testable import P4Compiler - -@Test func test_statement_interloper() async throws { - let simple_parser_declaration = """ - parser main_parser() { - state starts { - bool where_to = false; - int va = 5; - transition accept; - } - state start { - bool where_to = true; - where_to = true; - transition select (where_to) { - false: reject; - true: starts; - }; - } - }; - """ - - let program = try #UseOkResult(SpecialCompilers.ProgramCompiler.Compile(simple_parser_declaration)) - let runtime = try #UseOkResult(P4Runtime.Runtime.create(program: program)) - - var statements_executed: [String] = Array() - - let ev = InterloperEvaluator().setStatementInterloper() { (statement, cf, execution) in - statements_executed.append("\(statement)") - } - - let (state_result, _) = try! #UseOkResult(runtime.run(withArguments: ArgumentList(), inExecution: ProgramExecution(ev))) - - #expect(state_result == P4Lang.accept) - - print("statements_executed: \(statements_executed)") - - #expect(statements_executed[0].hasPrefix("VariableDeclarationStatement")) - #expect(statements_executed[1].hasPrefix("ParserAssignmentStatement")) - // Moved into starts - #expect(statements_executed[2].hasPrefix("VariableDeclarationStatement")) - #expect(statements_executed[3].hasPrefix("VariableDeclarationStatement")) -} - -@Test func test_expression_interloper() async throws { - let simple_parser_declaration = """ - parser main_parser() { - state starts { - bool where_to = false; - int va = 5; - transition accept; - } - state start { - bool where_to = true; - where_to = true; - transition select (where_to) { - false: reject; - true: starts; - }; - } - }; - """ - - let program = try #UseOkResult(SpecialCompilers.ProgramCompiler.Compile(simple_parser_declaration)) - let runtime = try #UseOkResult(P4Runtime.Runtime.create(program: program)) - - var expressions_evaluated: [String] = Array() - - let ev = InterloperEvaluator().setExpressionInterloper() { expression, result, execution in - expressions_evaluated.append("\(expression)") - } - - let (state_result, _) = try! #UseOkResult(runtime.run(withArguments: ArgumentList(), inExecution: ProgramExecution(ev))) - - #expect(state_result == P4Lang.accept) - - #expect(expressions_evaluated[0].hasPrefix("Value: true of Boolean")) - #expect(expressions_evaluated[1].hasPrefix("Value: true of Boolean")) - #expect(expressions_evaluated[2].hasPrefix("where_to")) - #expect(expressions_evaluated[3].hasPrefix("Value: false of Boolean")) - #expect(expressions_evaluated[4].hasPrefix("KeysetExpression")) - #expect(expressions_evaluated[5].hasPrefix("Value: true of Boolean")) - #expect(expressions_evaluated[6].hasPrefix("KeysetExpression")) - #expect(expressions_evaluated[7].hasPrefix("SelectCaseExpression")) - #expect(expressions_evaluated[8].hasPrefix("SelectExpression")) - // Moved into starts - #expect(expressions_evaluated[9].hasPrefix("Value: false of Boolean")) - #expect(expressions_evaluated[10].hasPrefix("Value: 5 of Int")) -} diff --git a/Tests/p4rseTests/ParserCompilerTests.swift b/Tests/p4rseTests/ParserCompilerTests.swift deleted file mode 100644 index fc11255..0000000 --- a/Tests/p4rseTests/ParserCompilerTests.swift +++ /dev/null @@ -1,197 +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 . - -import Common -import Foundation -import Macros -import Runtime -import SwiftTreeSitter -import Testing -import TreeSitter -import TreeSitterP4 -import P4Lang - -@testable import P4Compiler - -@Test func test_simple_parser_syntax_error() async throws { - let simple_parser_declaration = """ - parser main_parser() { - state - transition start; - } - }; - """ - #expect( - #RequireErrorResult( - Error(withMessage: "Could not compile the P4 program"), - SpecialCompilers.ProgramCompiler.Compile(simple_parser_declaration))) -} - -@Test func test_simple_compilation_with_statement() async throws { - let simple_parser_declaration = """ - parser main_parser() { - state start { - true; - transition accept; - } - }; - """ - - let program = try #UseOkResult(SpecialCompilers.ProgramCompiler.Compile(simple_parser_declaration)) - let parser = try #UseOkResult(program.find_parser(withName: Identifier(name: "main_parser"))) - - #expect(parser.states.count() == 1) - - let state = (try! #require(parser.states.find(withIdentifier: Identifier(name: "start")))) - #expect(state.getName() == Identifier(name: "start")) - #expect(state.statements.count == 1) -} - -@Test func test_invalid_transition_expression_keyset_expressions() async throws { - let simple_parser_declaration = """ - parser main_parser() { - state start { - transition select (false) { - asdf: reject; - asde: reject; - }; - } - }; - """ - - let compilation_error = try #UseErrorResult(SpecialCompilers.ProgramCompiler.Compile(simple_parser_declaration)) - - #expect(compilation_error.msg().contains("asde")) - #expect(compilation_error.msg().contains("asdf")) -} - -@Test func test_simple_compiler_macro_nodetype_test() async throws { - let simple = """ - parser main_parser() { - state start { - transition select (false) { - asdf: reject; - asde: reject; - }; - } - }; - """ - - let p = try! #UseOkResult(ConfigureP4Parser()) - let result = try! #require(p.parse(simple)) - - #expect( - #RequireErrorResult( - ErrorWithLocation(sourceLocation: SourceLocation(2, 154), withError: "Did not find assignment statement"), - ParserAssignmentStatement.Compile( // Note: Calling ParserAssignmentStatement compilation directly. - node: result.rootNode!, withContext: CompilerContext()))) -} - -@Test func test_simple_compiler_parser_with_parameters() async throws { - let simple = """ - parser main_parser(bool pmtr) { - state start { - transition accept; - } - }; - """ - - let program = try! #UseOkResult(SpecialCompilers.ProgramCompiler.Compile(simple)) - let parser = try! #UseOkResult(program.find_parser(withName: Identifier(name: "main_parser"))) - let parameters = parser.parameters - - // Check that the parameters match. - #expect(parameters.parameters.count == 1) - - #expect(parameters.parameters[0].name == Identifier(name: "pmtr")) - #expect(parameters.parameters[0].type.baseType().eq(rhs: P4Boolean())) -} - -@Test func test_simple_compiler_parser_with_multiple_parameters() async throws { - let simple = """ - parser main_parser(bool pmtr, string smtr) { - state start { - transition accept; - } - }; - """ - - let program = try! #UseOkResult(SpecialCompilers.ProgramCompiler.Compile(simple)) - let parser = try! #UseOkResult(program.find_parser(withName: Identifier(name: "main_parser"))) - let parameters = parser.parameters - - // Check that the parameters match. - #expect(parameters.parameters.count == 2) - - #expect(parameters.parameters[0].name == Identifier(name: "pmtr")) - #expect(parameters.parameters[0].type.baseType().eq(rhs: P4Boolean())) - - #expect(parameters.parameters[1].name == Identifier(name: "smtr")) - #expect(parameters.parameters[1].type.baseType().eq(rhs: P4String())) -} - -@Test func test_simple_compiler_parser_with_multiple_parameters2() async throws { - let simple = """ - parser main_parser(bool pmtr, string smtr, int imtr) { - state start { - transition accept; - } - }; - """ - - let program = try! #UseOkResult(SpecialCompilers.ProgramCompiler.Compile(simple)) - let parser = try! #UseOkResult(program.find_parser(withName: Identifier(name: "main_parser"))) - let parameters = parser.parameters - - // Check that the parameters match. - #expect(parameters.parameters.count == 3) - - #expect(parameters.parameters[0].name == Identifier(name: "pmtr")) - #expect(parameters.parameters[0].type.baseType().eq(rhs: P4Boolean())) - - #expect(parameters.parameters[1].name == Identifier(name: "smtr")) - #expect(parameters.parameters[1].type.baseType().eq(rhs: P4String())) - - #expect(parameters.parameters[2].name == Identifier(name: "imtr")) - #expect(parameters.parameters[2].type.baseType().eq(rhs: P4Int())) -} - -@Test func test_simple_compiler_parser_use_parameters() async throws { - let simple = """ - parser main_parser(bool pmtr, string smtr, int imtr) { - state start { - pmtr = true; - transition accept; - } - }; - """ - - #expect(#RequireOkResult(SpecialCompilers.ProgramCompiler.Compile(simple))) -} - -@Test func test_simple_compiler_with_instantiation() async throws { - let simple_instantiation_program = """ - parser MainParser() { - state start { - transition accept; - } - }; - - MainParser() mp; - """ - #expect(#RequireOkResult(SpecialCompilers.ProgramCompiler.Compile(simple_instantiation_program))) -} \ No newline at end of file diff --git a/Tests/p4rseTests/RuntimeTests.swift b/Tests/p4rseTests/RuntimeTests.swift deleted file mode 100644 index 5b9fb02..0000000 --- a/Tests/p4rseTests/RuntimeTests.swift +++ /dev/null @@ -1,173 +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 . - -import Common -import Foundation -import Macros -import P4Lang -import P4Runtime -import SwiftTreeSitter -import Testing -import TreeSitter -import TreeSitterP4 - -@testable import P4Compiler - -@Test func test_simple_runtime() async throws { - let simple_parser_declaration = """ - parser main_parser() { - state start { - true; - transition accept; - } - }; - """ - - let program = try #UseOkResult(SpecialCompilers.ProgramCompiler.Compile(simple_parser_declaration)) - let runtime = try #UseOkResult(P4Runtime.Runtime.create(program: program)) - let (state_result, _) = try! #UseOkResult(runtime.run()) - - // We should be in the accept state. - #expect(state_result == P4Lang.accept) -} - -@Test func test_simple_runtime_to_accept() async throws { - let simple_parser_declaration = """ - parser main_parser() { - state start { - true; - transition reject; - } - }; - """ - - let program = try #UseOkResult(SpecialCompilers.ProgramCompiler.Compile(simple_parser_declaration)) - let runtime = try #UseOkResult(P4Runtime.Runtime.create(program: program)) - let (state_result, _) = try! #UseOkResult(runtime.run()) - // We should be in the accept state. - #expect(state_result == P4Lang.reject) -} - -@Test func test_simple_runtime_no_start_state() async throws { - let simple_parser_declaration = """ - parser main_parser() { - state tart { - true; - transition reject; - } - }; - """ - - let program = try #UseOkResult(SpecialCompilers.ProgramCompiler.Compile(simple_parser_declaration)) - let runtime = try #UseOkResult(P4Runtime.Runtime.create(program: program)) - - #expect( - #RequireErrorResult<(InstantiatedParserState, ProgramExecution)>( - Error(withMessage: "Could not find the start state"), - runtime.run())) -} - -@Test func test_simple_runtime_parser_with_parameters() async throws { - let simple_parser_declaration = """ - parser main_parser(bool pmtr, string smtr, int imtr) { - state start { - transition select (pmtr) { - true: accept; - false: reject; - }; - } - }; - """ - let program = try #UseOkResult(SpecialCompilers.ProgramCompiler.Compile(simple_parser_declaration)) - let runtime = try #UseOkResult(P4Runtime.Runtime.create(program: program)) - - let args = ArgumentList([ - Argument(P4Value(P4BooleanValue(withValue: true)), atIndex: 1), Argument(P4Value(P4StringValue(withValue: "Testing")), atIndex: 2), Argument(P4Value(P4IntValue(withValue: 5)), atIndex: 3), - ]) - let (state_result, _) = try! #UseOkResult(runtime.run(withArguments: args)) - // We should be in the accept state. - #expect(state_result == P4Lang.accept) -} - -@Test func test_simple_runtime_parser_with_mismatched_parameter_types() async throws { - let simple_parser_declaration = """ - parser main_parser(bool pmtr, string smtr, int imtr) { - state start { - transition select (pmtr) { - true: accept; - false: reject; - }; - } - }; - """ - let program = try #UseOkResult(SpecialCompilers.ProgramCompiler.Compile(simple_parser_declaration)) - let runtime = try #UseOkResult(P4Runtime.Runtime.create(program: program)) - - let args = ArgumentList([ - Argument(P4Value(P4BooleanValue(withValue: true)), atIndex: 1), Argument(P4Value(P4BooleanValue(withValue: false)), atIndex: 2), Argument(P4Value(P4IntValue(withValue: 5)), atIndex: 3), - ]) - - #expect( - #RequireErrorResult<(InstantiatedParserState, ProgramExecution)>( - Error(withMessage: "Cannot call parser: Argument 2's type (Boolean) is incompatible with the parameter type (String)"), - runtime.run(withArguments: args))) -} - -@Test func test_simple_runtime_parser_with_mismatched_parameter_types2() async throws { - let simple_parser_declaration = """ - parser main_parser(bool pmtr, string smtr, int imtr) { - state start { - transition select (pmtr) { - true: accept; - false: reject; - }; - } - }; - """ - let program = try #UseOkResult(SpecialCompilers.ProgramCompiler.Compile(simple_parser_declaration)) - let runtime = try #UseOkResult(P4Runtime.Runtime.create(program: program)) - - let args = ArgumentList([ - Argument(P4Value(P4IntValue(withValue: 5)), atIndex: 1), Argument(P4Value(P4StringValue(withValue: "Testing")), atIndex: 2), Argument(P4Value(P4IntValue(withValue: 5)), atIndex: 3), - ]) - - #expect( - #RequireErrorResult<(InstantiatedParserState, ProgramExecution)>( - Error(withMessage: "Cannot call parser: Argument 1's type (Int (width: Infinite)) is incompatible with the parameter type (Boolean)"), - runtime.run(withArguments: args))) -} - -@Test func test_simple_runtime_parser_with_mismatched_parameter_counts() async throws { - let simple_parser_declaration = """ - parser main_parser(bool pmtr, string smtr, int imtr) { - state start { - transition select (pmtr) { - true: accept; - false: reject; - }; - } - }; - """ - let program = try #UseOkResult(SpecialCompilers.ProgramCompiler.Compile(simple_parser_declaration)) - let runtime = try #UseOkResult(P4Runtime.Runtime.create(program: program)) - let args = ArgumentList([Argument(P4Value(P4BooleanValue(withValue: true)), atIndex: 0)]) - - #expect( - #RequireErrorResult<(InstantiatedParserState, ProgramExecution)>( - Error(withMessage: "Cannot call parser: 1 arguments found but 3 required"), - runtime.run(withArguments: args))) -} diff --git a/Tests/p4rseTests/ScopeRuntimeTests.swift b/Tests/p4rseTests/ScopeRuntimeTests.swift deleted file mode 100644 index 55e868b..0000000 --- a/Tests/p4rseTests/ScopeRuntimeTests.swift +++ /dev/null @@ -1,159 +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 . - -import Common -import Foundation -import P4Lang -import Macros -import P4Runtime -import SwiftTreeSitter -import Testing -import TreeSitter -import TreeSitterP4 - -@testable import P4Compiler - -@Test func test_simple_local_element_variable_declaration() async throws { - let simple_parser_declaration = """ - parser main_parser() { - state start { - bool b = false; - string s = "testing"; - true; - false; - true; - transition reject; - } - }; - """ - - - let program = try #UseOkResult(SpecialCompilers.ProgramCompiler.Compile(simple_parser_declaration)) - let runtime = try #UseOkResult(P4Runtime.Runtime.create(program: program)) - let (state_result, _) = try! #UseOkResult(runtime.run()) - - #expect(state_result == P4Lang.reject) -} - -@Test func test_simple_scope() async throws { - let simple_parser_declaration = """ - parser main_parser() { - state starts { - bool where_to = false; - int va = 5; - transition accept; - } - state start { - bool where_to = true; - transition select (where_to) { - false: reject; - true: starts; - }; - } - }; - """ - - - let program = try #UseOkResult(SpecialCompilers.ProgramCompiler.Compile(simple_parser_declaration)) - let runtime = try #UseOkResult(P4Runtime.Runtime.create(program: program)) - let (state_result, _) = try! #UseOkResult(runtime.run()) - - #expect(state_result == P4Lang.accept) - -} - -@Test func test_simple_scope2() async throws { - let simple_parser_declaration = """ - parser main_parser() { - state starts { - bool where_to = false; - int va = 5; - transition accept; - } - state start { - bool where_to = true; - where_to = false; - transition select (where_to) { - false: reject; - true: starts; - }; - } - }; - """ - - - let program = try #UseOkResult(SpecialCompilers.ProgramCompiler.Compile(simple_parser_declaration)) - let runtime = try #UseOkResult(P4Runtime.Runtime.create(program: program)) - let (state_result, _) = try! #UseOkResult(runtime.run()) - - #expect(state_result == P4Lang.reject) -} - -@Test func test_simple_assignment() async throws { - let simple_parser_declaration = """ - parser main_parser() { - state start { - bool where_to = true; - string where_from = "here"; - where_to = false; - where_from = "there"; - transition select (where_to) { - false: reject; - true: accept; - }; - } - }; - """ - - - let program = try #UseOkResult(SpecialCompilers.ProgramCompiler.Compile(simple_parser_declaration)) - let runtime = try #UseOkResult(P4Runtime.Runtime.create(program: program)) - let (state_result, _) = try! #UseOkResult(runtime.run()) - - #expect(state_result == P4Lang.reject) - -} - -@Test func test_nested_declaration_assignment() async throws { - let simple_parser_declaration = """ - parser main_parser() { - state start { - bool where_to = true; - string where_from = "here"; - string where_where = "here"; - if (where_to) { - bool where_from = true; - if (where_from) { - where_to = false; - } - } - where_from = "there"; - transition select (where_to) { - false: reject; - true: accept; - }; - } - }; - """ - - - let program = try #UseOkResult(SpecialCompilers.ProgramCompiler.Compile(simple_parser_declaration)) - let runtime = try #UseOkResult(P4Runtime.Runtime.create(program: program)) - let (state_result, _) = try! #UseOkResult(runtime.run()) - - #expect(state_result == P4Lang.reject) -} \ No newline at end of file diff --git a/Tests/p4rseTests/ScopeTests.swift b/Tests/p4rseTests/ScopeTests.swift deleted file mode 100644 index bca1c5b..0000000 --- a/Tests/p4rseTests/ScopeTests.swift +++ /dev/null @@ -1,66 +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 . - -import Common -import Foundation -import Macros -import P4Runtime -import SwiftTreeSitter -import Testing -import TreeSitter -import TreeSitterP4 - -@testable import P4Compiler - -@Test func test_scope() async throws { - let s = VarTypeScope() - let s2 = s.declare(identifier: Identifier(name: "first"), withValue: P4QualifiedType(P4Int())) - let found_first = try! #require(s2.lookup(identifier: Identifier(name: "first"))) - - #expect(found_first.baseType().eq(rhs: P4Int())) - #expect(s2.count == 1) -} - -@Test func test_scope_no_set() async throws { - var ss = VarTypeScopes().enter() - ss = ss.declare(identifier: Identifier(name: "first"), withValue: P4QualifiedType(P4Int())) - ss = ss.enter() - ss = ss.declare(identifier: Identifier(name: "second"), withValue: P4QualifiedType(P4Boolean())) - - let found_first = try! #UseOkResult(ss.lookup(identifier: Identifier(name: "first"))) - let found_second = try! #UseOkResult(ss.lookup(identifier: Identifier(name: "second"))) - - #expect(found_first.baseType().eq(rhs: P4Int())) - #expect(found_second.baseType().eq(rhs: P4Boolean())) -} - -@Test func test_scope_set() async throws { - var ss = VarTypeScopes().enter() - let id = Identifier(name: "first") - let id_type = P4QualifiedType(P4Int()) - - ss = ss.declare(identifier: id, withValue: id_type) - ss = ss.enter() - ss = ss.declare(identifier: Identifier(name: "second"), withValue: P4QualifiedType(P4Boolean())) - // Change the value of `first`. - ss = ss.set(identifier: id, withValue: P4QualifiedType(P4String())) - - // Verify the change! - let found = try! #UseOkResult(ss.lookup(identifier: id)) - - #expect(found.baseType().eq(rhs: P4String())) -} diff --git a/Tests/p4rseTests/StructTests.swift b/Tests/p4rseTests/StructTests.swift deleted file mode 100644 index 77147ce..0000000 --- a/Tests/p4rseTests/StructTests.swift +++ /dev/null @@ -1,556 +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 . - -import Common -import Foundation -import Macros -import P4Lang -import P4Runtime -import SwiftTreeSitter -import Testing -import TreeSitter -import TreeSitterP4 - -@testable import P4Compiler - -@Test func test_field_access() async throws { - let simple_parser_declaration = """ - parser main_parser() { - state start { - bool where_to = ts.yesno; - transition select (where_to) { - true: accept; - false: reject; - }; - } - }; - """ - var test_declarations = StaticVarValueScopes().enter() - let fields = P4StructFields([ - P4StructFieldIdentifier(name: "yesno", withType: P4QualifiedType(P4Boolean())), - P4StructFieldIdentifier(name: "count", withType: P4QualifiedType(P4Int())), - ]) - let struct_type = P4Struct(withName: Identifier(name: "Testing"), andFields: fields) - test_declarations = test_declarations.declare( - identifier: Identifier(name: "ts"), withValue: (P4QualifiedType(struct_type), .none)) - - var test_values = VarValueScopes().enter() - test_values = test_values.declare( - identifier: Identifier(name: "ts"), - withValue: P4Value( - P4StructValue( - withType: struct_type, - andInitializers: [ - P4Value(P4BooleanValue(withValue: true)), - P4Value(P4IntValue(withValue: 5)), - ]))) - - let program = try #UseOkResult( - SpecialCompilers.ProgramCompiler.Compile(simple_parser_declaration, withGlobalInstances: test_declarations)) - let runtime = try #UseOkResult( - P4Runtime.Runtime.create( - program: program, withGlobalValues: test_values)) - let (state_result, _) = try! #UseOkResult(runtime.run()) - #expect(state_result == P4Lang.accept) -} - -@Test func test_field_access_declared() async throws { - let simple_parser_declaration = """ - parser main_parser() { - state start { - Testing ts; - ts.yesno = true; - bool where_to = ts.yesno; - transition select (where_to) { - true: accept; - false: reject; - }; - } - }; - """ - var test_types = TypeTypeScopes().enter() - let fields = P4StructFields([ - P4StructFieldIdentifier(name: "yesno", withType: P4QualifiedType(P4Boolean())), - P4StructFieldIdentifier(name: "count", withType: P4QualifiedType(P4Int())), - ]) - let struct_type = P4Struct(withName: Identifier(name: "Testing"), andFields: fields) - test_types = test_types.declare(identifier: Identifier(name: "Testing"), withValue: struct_type) - - let program = try #UseOkResult( - SpecialCompilers.ProgramCompiler.Compile( - simple_parser_declaration, withGlobalInstances: .none, withGlobalTypes: test_types)) - let runtime = try #UseOkResult( - P4Runtime.Runtime.create(program: program)) - let (state_result, _) = try! #UseOkResult(runtime.run()) - #expect(state_result == P4Lang.accept) -} - -@Test func test_field_access_declared2() async throws { - let simple_parser_declaration = """ - parser main_parser() { - state start { - Testing ts; - ts.yesno = true; - ts.count = 5; - bool where_to = ts.yesno; - transition select (ts.count == 5) { - true: accept; - false: reject; - }; - } - }; - """ - var test_declarations = TypeTypeScopes().enter() - let fields = P4StructFields([ - P4StructFieldIdentifier(name: "yesno", withType: P4QualifiedType(P4Boolean())), - P4StructFieldIdentifier(name: "count", withType: P4QualifiedType(P4Int())), - ]) - let struct_type = P4Struct(withName: Identifier(name: "Testing"), andFields: fields) - test_declarations = test_declarations.declare( - identifier: Identifier(name: "Testing"), withValue: struct_type) - - let program = try #UseOkResult( - SpecialCompilers.ProgramCompiler.Compile(simple_parser_declaration, withGlobalInstances: .none, withGlobalTypes: test_declarations)) - - let runtime = try #UseOkResult( - P4Runtime.Runtime.create(program: program)) - let (state_result, _) = try! #UseOkResult(runtime.run()) - #expect(state_result == P4Lang.accept) -} - -@Test func test_field_access_opp() async throws { - let simple_parser_declaration = """ - parser main_parser() { - state start { - bool where_to = ts.yesno; - transition select (where_to) { - true: accept; - false: reject; - }; - } - }; - """ - var test_declarations = StaticVarValueScopes().enter() - let fields = P4StructFields([ - P4StructFieldIdentifier(name: "yesno", withType: P4QualifiedType(P4Boolean())), - P4StructFieldIdentifier(name: "count", withType: P4QualifiedType(P4Int())), - ]) - let struct_type = P4Struct(withName: Identifier(name: "Testing"), andFields: fields) - test_declarations = test_declarations.declare( - identifier: Identifier(name: "ts"), withValue: (P4QualifiedType(struct_type), .none)) - - var test_values = VarValueScopes().enter() - test_values = test_values.declare( - identifier: Identifier(name: "ts"), - withValue: P4Value( - P4StructValue( - withType: struct_type, - andInitializers: [ - P4Value(P4BooleanValue(withValue: false)), - P4Value(P4IntValue(withValue: 5)), - ]))) - - let program = try #UseOkResult( - SpecialCompilers.ProgramCompiler.Compile(simple_parser_declaration, withGlobalInstances: test_declarations)) - let runtime = try #UseOkResult( - P4Runtime.Runtime.create( - program: program, withGlobalValues: test_values)) - let (state_result, _) = try! #UseOkResult(runtime.run()) - #expect(state_result == P4Lang.reject) -} - -@Test func test_field_access2() async throws { - let simple_parser_declaration = """ - parser main_parser() { - state start { - transition select (ts.count == 5) { - true: accept; - false: reject; - }; - } - }; - """ - var test_declarations = StaticVarValueScopes().enter() - let fields = P4StructFields([ - P4StructFieldIdentifier(name: "yesno", withType: P4QualifiedType(P4Boolean())), - P4StructFieldIdentifier(name: "count", withType: P4QualifiedType(P4Int())), - ]) - let struct_type = P4Struct(withName: Identifier(name: "Testing"), andFields: fields) - test_declarations = test_declarations.declare( - identifier: Identifier(name: "ts"), withValue: (P4QualifiedType(struct_type), .none)) - - var test_values = VarValueScopes().enter() - test_values = test_values.declare( - identifier: Identifier(name: "ts"), - withValue: P4Value( - P4StructValue( - withType: struct_type, - andInitializers: [ - P4Value(P4BooleanValue(withValue: true)), - P4Value(P4IntValue(withValue: 5)), - ]))) - - let program = try #UseOkResult( - SpecialCompilers.ProgramCompiler.Compile(simple_parser_declaration, withGlobalInstances: test_declarations)) - let runtime = try #UseOkResult( - P4Runtime.Runtime.create( - program: program, withGlobalValues: test_values)) - let (state_result, _) = try! #UseOkResult(runtime.run()) - #expect(state_result == P4Lang.accept) -} - -@Test func test_field_access2_opp() async throws { - let simple_parser_declaration = """ - parser main_parser() { - state start { - transition select (ts.count == 5) { - true: accept; - false: reject; - }; - } - }; - """ - var test_declarations = StaticVarValueScopes().enter() - let fields = P4StructFields([ - P4StructFieldIdentifier(name: "yesno", withType: P4QualifiedType(P4Boolean())), - P4StructFieldIdentifier(name: "count", withType: P4QualifiedType(P4Int())), - ]) - let struct_type = P4Struct(withName: Identifier(name: "Testing"), andFields: fields) - test_declarations = test_declarations.declare( - identifier: Identifier(name: "ts"), withValue: (P4QualifiedType(struct_type), .none)) - - var test_values = VarValueScopes().enter() - test_values = test_values.declare( - identifier: Identifier(name: "ts"), - withValue: P4Value( - P4StructValue( - withType: struct_type, - andInitializers: [ - P4Value(P4BooleanValue(withValue: true)), - P4Value(P4IntValue(withValue: 8)), - ]))) - - let program = try #UseOkResult( - SpecialCompilers.ProgramCompiler.Compile(simple_parser_declaration, withGlobalInstances: test_declarations)) - let runtime = try #UseOkResult( - P4Runtime.Runtime.create( - program: program, withGlobalValues: test_values)) - let (state_result, _) = try! #UseOkResult(runtime.run()) - #expect(state_result == P4Lang.reject) -} - -@Test func test_field_access_nested() async throws { - let simple_parser_declaration = """ - parser main_parser() { - state start { - int where_to = ts.ty.count; - transition select (where_to == 5) { - true: accept; - false: reject; - }; - } - }; - """ - var test_declarations = StaticVarValueScopes().enter() - - let ty_fields = P4StructFields([ - P4StructFieldIdentifier(name: "yesno", withType: P4QualifiedType(P4Boolean())), - P4StructFieldIdentifier(name: "count", withType: P4QualifiedType(P4Int())), - ]) - let ty_struct_type = P4Struct(withName: Identifier(name: "nested"), andFields: ty_fields) - - let ts_fields = P4StructFields([ - P4StructFieldIdentifier(name: "ty", withType: P4QualifiedType(ty_struct_type)) - ]) - let ts_struct_type = P4Struct(withName: Identifier(name: "outer"), andFields: ts_fields) - - test_declarations = test_declarations.declare( - identifier: Identifier(name: "ts"), withValue: (P4QualifiedType(ts_struct_type), .none)) - - var test_values = VarValueScopes().enter() - - test_values = test_values.declare( - identifier: Identifier(name: "ts"), - withValue: P4Value( - P4StructValue( - withType: ts_struct_type, - andInitializers: [ - P4Value( - P4StructValue( - withType: ty_struct_type, - andInitializers: [ - P4Value(P4BooleanValue(withValue: true)), - P4Value(P4IntValue(withValue: 5)), - ])) - ]))) - let program = try #UseOkResult( - SpecialCompilers.ProgramCompiler.Compile(simple_parser_declaration, withGlobalInstances: test_declarations)) - let runtime = try #UseOkResult( - P4Runtime.Runtime.create( - program: program, withGlobalValues: test_values)) - let (state_result, _) = try! #UseOkResult(runtime.run()) - #expect(state_result == P4Lang.accept) -} - -@Test func test_field_write() async throws { - let simple_parser_declaration = """ - parser main_parser() { - state start { - ts.yesno = true; - bool where_to = ts.yesno; - transition select (where_to) { - true: accept; - false: reject; - }; - } - }; - """ - var test_declarations = StaticVarValueScopes().enter() - let fields = P4StructFields([ - P4StructFieldIdentifier(name: "yesno", withType: P4QualifiedType(P4Boolean())), - P4StructFieldIdentifier(name: "count", withType: P4QualifiedType(P4Int())), - ]) - let struct_type = P4Struct(withName: Identifier(name: "Testing"), andFields: fields) - test_declarations = test_declarations.declare( - identifier: Identifier(name: "ts"), withValue: (P4QualifiedType(struct_type), .none)) - - var test_values = VarValueScopes().enter() - test_values = test_values.declare( - identifier: Identifier(name: "ts"), - withValue: P4Value( - P4StructValue( - withType: struct_type, - andInitializers: [ - P4Value(P4BooleanValue(withValue: false)), - P4Value(P4IntValue(withValue: 5)), - ]))) - - let program = try #UseOkResult( - SpecialCompilers.ProgramCompiler.Compile(simple_parser_declaration, withGlobalInstances: test_declarations)) - let runtime = try #UseOkResult( - P4Runtime.Runtime.create( - program: program, withGlobalValues: test_values)) - let (state_result, _) = try! #UseOkResult(runtime.run()) - #expect(state_result == P4Lang.accept) -} - -@Test func test_field_write_invalid_type() async throws { - let simple_parser_declaration = """ - parser main_parser() { - state start { - ts.yesno = 5; - transition accept; - } - }; - """ - var test_declarations = StaticVarValueScopes().enter() - let fields = P4StructFields([ - P4StructFieldIdentifier(name: "yesno", withType: P4QualifiedType(P4Boolean())), - P4StructFieldIdentifier(name: "count", withType: P4QualifiedType(P4Int())), - ]) - let struct_type = P4Struct(withName: Identifier(name: "Testing"), andFields: fields) - test_declarations = test_declarations.declare( - identifier: Identifier(name: "ts"), withValue: (P4QualifiedType(struct_type), .none)) - - #expect( - #RequireErrorResult( - Error( - withMessage: - "{49, 13}: Failed to parse a statement element: {49, 8}: Cannot assign value of type Int (width: Infinite) to field yesno of type Boolean" - ), - SpecialCompilers.ProgramCompiler.Compile(simple_parser_declaration, withGlobalInstances: test_declarations)) - ) -} - -@Test func test_field_write_nested() async throws { - let simple_parser_declaration = """ - parser main_parser() { - state start { - ts.ty.count = 5; - int where_to = ts.ty.count; - transition select (where_to == 5) { - true: accept; - false: reject; - }; - } - }; - """ - var test_declarations = StaticVarValueScopes().enter() - - let ty_fields = P4StructFields([ - P4StructFieldIdentifier(name: "yesno", withType: P4QualifiedType(P4Boolean())), - P4StructFieldIdentifier(name: "count", withType: P4QualifiedType(P4Int())), - ]) - let ty_struct_type = P4Struct(withName: Identifier(name: "nested"), andFields: ty_fields) - - let ts_fields = P4StructFields([ - P4StructFieldIdentifier(name: "ty", withType: P4QualifiedType(ty_struct_type)) - ]) - let ts_struct_type = P4Struct(withName: Identifier(name: "outer"), andFields: ts_fields) - - test_declarations = test_declarations.declare( - identifier: Identifier(name: "ts"), withValue: (P4QualifiedType(ts_struct_type), .none)) - - var test_values = VarValueScopes().enter() - - test_values = test_values.declare( - identifier: Identifier(name: "ts"), - withValue: P4Value( - P4StructValue( - withType: ts_struct_type, - andInitializers: [ - P4Value( - P4StructValue( - withType: ty_struct_type, - andInitializers: [ - P4Value(P4BooleanValue(withValue: true)), - P4Value(P4IntValue(withValue: 7)), - ])) - ]))) - let program = try #UseOkResult( - SpecialCompilers.ProgramCompiler.Compile(simple_parser_declaration, withGlobalInstances: test_declarations)) - let runtime = try #UseOkResult( - P4Runtime.Runtime.create( - program: program, withGlobalValues: test_values)) - let (state_result, _) = try! #UseOkResult(runtime.run()) - #expect(state_result == P4Lang.accept) -} - -@Test func test_field_write_nested2() async throws { - let simple_parser_declaration = """ - parser main_parser() { - state start { - ts.ty.count = 3; - ts.ty.count = 5; - int where_to = ts.ty.count; - transition select (where_to == 5) { - true: accept; - false: reject; - }; - } - }; - """ - var test_declarations = StaticVarValueScopes().enter() - - let ty_fields = P4StructFields([ - P4StructFieldIdentifier(name: "yesno", withType: P4QualifiedType(P4Boolean())), - P4StructFieldIdentifier(name: "count", withType: P4QualifiedType(P4Int())), - ]) - let ty_struct_type = P4Struct(withName: Identifier(name: "nested"), andFields: ty_fields) - - let ts_fields = P4StructFields([ - P4StructFieldIdentifier(name: "ty", withType: P4QualifiedType(ty_struct_type)) - ]) - let ts_struct_type = P4Struct(withName: Identifier(name: "outer"), andFields: ts_fields) - - test_declarations = test_declarations.declare( - identifier: Identifier(name: "ts"), withValue: (P4QualifiedType(ts_struct_type), .none)) - - var test_values = VarValueScopes().enter() - - test_values = test_values.declare( - identifier: Identifier(name: "ts"), - withValue: P4Value( - P4StructValue( - withType: ts_struct_type, - andInitializers: [ - P4Value( - P4StructValue( - withType: ty_struct_type, - andInitializers: [ - P4Value(P4BooleanValue(withValue: true)), - P4Value(P4IntValue(withValue: 7)), - ])) - ]))) - let program = try #UseOkResult( - SpecialCompilers.ProgramCompiler.Compile(simple_parser_declaration, withGlobalInstances: test_declarations)) - let runtime = try #UseOkResult( - P4Runtime.Runtime.create( - program: program, withGlobalValues: test_values)) - let (state_result, _) = try! #UseOkResult(runtime.run()) - #expect(state_result == P4Lang.accept) -} - -@Test func test_field_write_nested_invalid_type() async throws { - let simple_parser_declaration = """ - parser main_parser() { - state start { - ts.ty.count = false; - int where_to = ts.ty.count; - transition select (where_to == 5) { - true: accept; - false: reject; - }; - } - }; - """ - var test_declarations = StaticVarValueScopes().enter() - - let ty_fields = P4StructFields([ - P4StructFieldIdentifier(name: "yesno", withType: P4QualifiedType(P4Boolean())), - P4StructFieldIdentifier(name: "count", withType: P4QualifiedType(P4Int())), - ]) - let ty_struct_type = P4Struct(withName: Identifier(name: "nested"), andFields: ty_fields) - - let ts_fields = P4StructFields([ - P4StructFieldIdentifier(name: "ty", withType: P4QualifiedType(ty_struct_type)) - ]) - let ts_struct_type = P4Struct(withName: Identifier(name: "outer"), andFields: ts_fields) - - test_declarations = test_declarations.declare( - identifier: Identifier(name: "ts"), withValue: (P4QualifiedType(ts_struct_type), .none)) - - #expect( - #RequireErrorResult( - Error( - withMessage: - "{49, 20}: Failed to parse a statement element: {49, 11}: Cannot assign value of type Boolean to field count of type Int (width: Infinite)" - ), - SpecialCompilers.ProgramCompiler.Compile(simple_parser_declaration, withGlobalInstances: test_declarations)) - ) - -} - -@Test func test_field_read_equality_invalid_type() async throws { - let simple_parser_declaration = """ - parser main_parser() { - state start { - transition select (ts.yesno == "testing") { - true: accept; - false: reject; - }; - } - }; - """ - var test_declarations = StaticVarValueScopes().enter() - let fields = P4StructFields([ - P4StructFieldIdentifier(name: "yesno", withType: P4QualifiedType(P4Boolean())), - P4StructFieldIdentifier(name: "count", withType: P4QualifiedType(P4Int())), - ]) - let struct_type = P4Struct(withName: Identifier(name: "Testing"), andFields: fields) - test_declarations = test_declarations.declare( - identifier: Identifier(name: "ts"), withValue: (P4QualifiedType(struct_type), .none)) - - #expect( - #RequireErrorResult( - Error( - withMessage: - "{68, 21}: Could not parse transition select expression selector expression: Types of values used with binary expression are not the same" - ), - SpecialCompilers.ProgramCompiler.Compile(simple_parser_declaration, withGlobalInstances: test_declarations)) - ) -} diff --git a/Tests/p4rseTests/StyleTests/Style.swift b/Tests/p4rseTests/StyleTests/Style.swift deleted file mode 100644 index 3afeead..0000000 --- a/Tests/p4rseTests/StyleTests/Style.swift +++ /dev/null @@ -1,57 +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 . - -import Common -import Foundation -import Macros -import P4Runtime -import P4Lang -import SwiftTreeSitter -import Testing -import TreeSitter -import TreeSitterP4 - -@testable import P4Compiler - -@Test func test_style_add_format() async throws { - let red = Style(StyleColor.Red) - let bold_red = red.update(addFormat: StyleFormat.Bold) - - #expect(bold_red == Style(StyleColor.Red, [StyleFormat.Bold])) -} - -@Test func test_style_add_format2() async throws { - let bold_red = Style(StyleColor.Red, [StyleFormat.Bold]) - let bold_underline_red = bold_red.update(addFormat: StyleFormat.Underline) - - #expect(bold_underline_red == Style(StyleColor.Red, [StyleFormat.Bold, StyleFormat.Underline])) -} - - -@Test func test_style_remove_format() async throws { - let bold_red = Style(StyleColor.Red, [StyleFormat.Bold]) - let red = bold_red.update(removeFormat: StyleFormat.Bold) - - #expect(red == Style(StyleColor.Red)) -} - -@Test func test_style_remove_format2() async throws { - let bold_underline_red = Style(StyleColor.Red, [StyleFormat.Bold, StyleFormat.Underline]) - let underline_red = bold_underline_red.update(removeFormat: StyleFormat.Bold) - - #expect(underline_red == Style(StyleColor.Red, [StyleFormat.Underline])) -} diff --git a/Tests/p4rseTests/SupportTests.swift b/Tests/p4rseTests/SupportTests.swift deleted file mode 100644 index 108855f..0000000 --- a/Tests/p4rseTests/SupportTests.swift +++ /dev/null @@ -1,49 +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 . - -import Foundation -import Common -import Macros -import SwiftTreeSitter -import Testing -import TreeSitter -import TreeSitterP4 - -@testable import P4Compiler - -struct NotStringConvertible {} - -struct StringConvertible: CustomStringConvertible { - public var description: String { - return "CONVERTED" - } -} - -@Test func test_result_type_description_not_convertible() async throws { - let result: Result = Result.Ok(NotStringConvertible()); - #expect("\(result)" == "Ok(Tests.NotStringConvertible())") -} - -@Test func test_result_type_description_convertible() async throws { - let result: Result = Result.Ok(StringConvertible()); - #expect("\(result)" == "Ok: CONVERTED") -} - -@Test func test_result_type_p4value_convertible() async throws { - let result = Result.Ok(P4Value(P4IntValue(withValue: 5))) - #expect("\(result)" == "Ok: Value: 5 of Int (width: Infinite) type of type Int (width: Infinite)") -} \ No newline at end of file diff --git a/Tests/p4rseTests/SupportTests/InvalidStatements.swift b/Tests/p4rseTests/SupportTests/InvalidStatements.swift deleted file mode 100644 index 4c19192..0000000 --- a/Tests/p4rseTests/SupportTests/InvalidStatements.swift +++ /dev/null @@ -1,58 +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 . - -import Common -import Foundation -import Macros -import P4Lang -import P4Runtime -import SwiftTreeSitter -import Testing -import TreeSitter -import TreeSitterP4 - -@testable import P4Compiler - -@Test func test_invalid_statements() async throws { - - let ret = ReturnStatement(P4Value(P4IntValue(withValue: 5))) - let block = BlockStatement([ret]) - - #expect(ContainsInvalidStatements(block: block, invalids: [ReturnStatement.self])) -} - -@Test func test_no_invalid_statements() async throws { - - let exprs = ExpressionStatement(P4Value(P4IntValue(withValue: 5))) - let block = BlockStatement([exprs]) - - #expect(!ContainsInvalidStatements(block: block, invalids: [ReturnStatement.self])) -} - -@Test func test_is_invalid_statement() async throws { - - let ret = ReturnStatement(P4Value(P4IntValue(withValue: 5))) - - #expect(ContainsInvalidStatements(statement: ret, invalids: [ReturnStatement.self])) -} - -@Test func test_no_is_invalid_statement() async throws { - - let exprs = ExpressionStatement(P4Value(P4IntValue(withValue: 5))) - - #expect(!ContainsInvalidStatements(statement: exprs, invalids: [ReturnStatement.self])) -} diff --git a/Tests/p4rseTests/SupportTests/SourceCode.swift b/Tests/p4rseTests/SupportTests/SourceCode.swift deleted file mode 100644 index b0af010..0000000 --- a/Tests/p4rseTests/SupportTests/SourceCode.swift +++ /dev/null @@ -1,258 +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 . - -import Foundation -import Macros -import P4Compiler -import P4Lang -import P4Runtime -import SwiftTreeSitter -import SystemPackage -import Testing -import TreeSitter -import TreeSitterP4 - -@testable import Common - -@Test func test_preprocessor() async throws { - let sm = SourceManager(["./TestData/Sources/"]) - let prep = SourceCodePreprocessor(sm) - let file = FilePath.init(stringLiteral: "simple.p4") - - let source = try! (#UseOkResult(prep.preprocess(file))) - let program = try! #UseOkResult(SpecialCompilers.ProgramCompiler.Compile(source.getSource())) - #expect(#RequireOkResult((program.find_parser(withName: Identifier(name: "main_parser"))))) - #expect(source.getLocations().getPath() == file) -} - -@Test func test_preprocessor_search_for_file() async throws { - let sm = SourceManager(["./TestData/Sources/"]) - let prep = SourceCodePreprocessor(sm) - let file = FilePath.init(stringLiteral: "simple.p4") - - let source = try! (#UseOkResult(prep.preprocess(file))) - let program = try! #UseOkResult(SpecialCompilers.ProgramCompiler.Compile(source.getSource())) - #expect(#RequireOkResult((program.find_parser(withName: Identifier(name: "main_parser"))))) - #expect(source.getLocations().getPath() == file) -} - -@Test func test_preprocessor_nested_includes() async throws { - let sm = SourceManager(["./TestData/Sources/"]) - let prep = SourceCodePreprocessor(sm) - let file = FilePath.init(stringLiteral: "simple-split.p4") - - #expect(#RequireOkResult(prep.preprocess(file))) - - let source = try! (#UseOkResult(prep.preprocess(file))) - let program = try! #UseOkResult(SpecialCompilers.ProgramCompiler.Compile(source.getSource())) - #expect(#RequireOkResult((program.find_parser(withName: Identifier(name: "main_parser"))))) - #expect(source.getLocations().getPath() == file) -} - -@Test func test_preprocessor_oneline_includes() async throws { - let sm = SourceManager(["./TestData/Sources/"]) - let prep = SourceCodePreprocessor(sm) - let file = FilePath.init(stringLiteral: "simple-split-oneline.p4") - - #expect(#RequireOkResult(prep.preprocess(file))) - - let source = try! (#UseOkResult(prep.preprocess(file))) - let program = try! #UseOkResult(SpecialCompilers.ProgramCompiler.Compile(source.getSource())) - #expect(#RequireOkResult((program.find_parser(withName: Identifier(name: "main_parser"))))) - #expect(source.getLocations().getPath() == file) -} - -@Test func test_preprocessor_missing_file() async throws { - let sm = SourceManager(["./TestData/Sources/"]) - let prep = SourceCodePreprocessor(sm) - let file = FilePath.init(stringLiteral: "./TestData/Sources/unfound.p4") - - #expect( - #RequireErrorResult( - Error(withMessage: "Could not open ./TestData/Sources/unfound.p4 for preprocessing"), - (prep.preprocess(file)))) - -} - -@Test func test_preprocessor_missing_included_file() async throws { - let sm = SourceManager(["./TestData/Sources/"]) - let prep = SourceCodePreprocessor(sm) - let file = FilePath.init(stringLiteral: "simple-unfound.p4") - - #expect( - #RequireErrorResult( - Error(withMessage: "Could not open unfound.p4 for preprocessing"), (prep.preprocess(file)))) - -} - -@Test func test_preprocessor_no_change_locations() async throws { - let sm = SourceManager(["./TestData/Sources/"]) - let prep = SourceCodePreprocessor(sm) - let file = FilePath.init(stringLiteral: "testing.p4") - - let source = try! (#UseOkResult(prep.preprocess(file))) - - #expect(source.getLocations().getLocation() == SourceLocation(0..<173)) -} - -@Test func test_preprocessor_change_locations() async throws { - let sm = SourceManager(["./TestData/Sources/"]) - let prep = SourceCodePreprocessor(sm) - let file = FilePath.init(stringLiteral: "testing-split-a.p4") - - let source = try! (#UseOkResult(prep.preprocess(file))) - - #expect(source.getLocations().getLocation() == SourceLocation(0..<173)) - #expect(source.getLocations().getNestedLocations()[0].getLocation() == SourceLocation(48..<173)) -} - -@Test func test_preprocessor_oneline_includes_locations() async throws { - let sm = SourceManager(["./TestData/Sources/"]) - let prep = SourceCodePreprocessor(sm) - let file = FilePath.init(stringLiteral: "simple-split-oneline.p4") - - #expect(#RequireOkResult(prep.preprocess(file))) - - let source = try! (#UseOkResult(prep.preprocess(file))) - - #expect(source.getLocations().getLocation() == SourceLocation(0..<173)) - #expect(source.getLocations().getNestedLocations()[0].getLocation() == SourceLocation(0..<70)) - #expect(source.getLocations().getNestedLocations()[1].getLocation() == SourceLocation(70..<173)) -} - -@Test func test_preprocessor_nested_includes_locations() async throws { - let sm = SourceManager(["./TestData/Sources/"]) - let prep = SourceCodePreprocessor(sm) - let file = FilePath.init(stringLiteral: "nested-split.p4") - - #expect(#RequireOkResult(prep.preprocess(file))) - - let source = try! (#UseOkResult(prep.preprocess(file))) - - #expect(source.getLocations().getLocation() == SourceLocation(0..<173)) - /* - #expect( - source.getLocations().getNestedLocations()[0].getNestedLocations()[0].getLocation() - == SourceLocation(27..<47)) - #expect( - source.getLocations().getNestedLocations()[0].getNestedLocations()[1].getLocation() - == SourceLocation(48..<166)) - */ -} - -@Test func test_preprocessor_nested_includes_annotated_source() async throws { - let sm = SourceManager(["./TestData/Sources/"]) - let prep = SourceCodePreprocessor(sm) - let file = FilePath.init(stringLiteral: "annotate.p4") - - let expected = """ - - }; - - }>> - """ - - #expect(#RequireOkResult(prep.preprocess(file))) - let source = try! (#UseOkResult(prep.preprocess(file))) - #expect(source.getSource(annotated: true) == expected) -} - -@Test func test_preprocessor_nested_includes_get_file_location() async throws { - let sm = SourceManager(["./TestData/Sources/"], FileManager()) // Add a FileManager to get absolute paths. - let prep = SourceCodePreprocessor(sm) - let file = FilePath.init(stringLiteral: "file-loc.p4") - - let source = try! (#UseOkResult(prep.preprocess(file))) - - let expected_file = file - let expected_nested_file = FilePath(stringLiteral: "file-loc-parser.p4") - let expected_nested_nested_file = FilePath(stringLiteral: "file-loc-parser-state.p4") - - let found_nested_files = try! #require(source.pathForLocation(78)) - - #expect(found_nested_files[0].path == expected_file) - #expect(found_nested_files[1].path == expected_nested_file) - #expect(found_nested_files[2].path == expected_nested_nested_file) -} - -@Test func test_source_location_contains() async throws { - let outer = SourceLocation(0..<500) - let inner = SourceLocation(0..<499) - - #expect(outer.contains(inner)) -} - -@Test func test_source_location_contains_a() async throws { - let outer = SourceLocation(0, 500) - let inner = SourceLocation(0, 499) - - #expect(outer.contains(inner)) -} - -@Test func test_source_location_contains2() async throws { - let outer = SourceLocation(0..<500) - let not_inner = SourceLocation(0..<501) - - #expect(!outer.contains(not_inner)) -} - -@Test func test_source_location_contains2_a() async throws { - let outer = SourceLocation(0, 500) - let not_inner = SourceLocation(0, 501) - - #expect(!outer.contains(not_inner)) -} - -@Test func test_source_location_contains3() async throws { - let outer = SourceLocation(200..<500) - let inner = SourceLocation(200..<499) - - #expect(outer.contains(inner)) -} - -@Test func test_source_location_contains3_a() async throws { - let outer = SourceLocation(200, 300) - let inner = SourceLocation(200, 299) - - #expect(outer.contains(inner)) -} - -@Test func test_source_location_contains4() async throws { - let outer = SourceLocation(200..<500) - let inner = SourceLocation(200, 299) - - #expect(outer.contains(inner)) -} - -@Test func test_source_location_contains5() async throws { - let outer = SourceLocation(200..<300) - let not_inner = SourceLocation(200, 101) - - #expect(!outer.contains(not_inner)) -} diff --git a/Tests/p4rseTests/TransitionTests.swift b/Tests/p4rseTests/TransitionTests.swift deleted file mode 100644 index 5dd9fa3..0000000 --- a/Tests/p4rseTests/TransitionTests.swift +++ /dev/null @@ -1,91 +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 . - -import Common -import Foundation -import Macros -import P4Lang -import P4Runtime -import SwiftTreeSitter -import Testing -import TreeSitter -import TreeSitterP4 - -@testable import P4Compiler - -@Test func test_simple_parser_with_transition_select_expression() async throws { - let simple_parser_declaration = """ - parser main_parser() { - state start { - transition select (true) { - false: reject; - true: accept; - }; - } - }; - """ - - let program = try #UseOkResult(SpecialCompilers.ProgramCompiler.Compile(simple_parser_declaration)) - let parser = try #UseOkResult(program.find_parser(withName: Identifier(name: "main_parser"))) - let runtime = try #UseOkResult(P4Runtime.Runtime.create(program: program)) - let (state_result, _) = try! #UseOkResult(runtime.run()) - - #expect(parser.states.count() == 1) - - #expect(state_result == P4Lang.accept) -} - -@Test func test_simple_parser_with_transition_select_expression_to_reject() async throws { - let simple_parser_declaration = """ - parser main_parser() { - state start { - transition select (false) { - false: reject; - true: accept; - }; - } - }; - """ - - let program = try #UseOkResult(SpecialCompilers.ProgramCompiler.Compile(simple_parser_declaration)) - let parser = try #UseOkResult(program.find_parser(withName: Identifier(name: "main_parser"))) - let runtime = try #UseOkResult(P4Runtime.Runtime.create(program: program)) - let (state_result, _) = try! #UseOkResult(runtime.run()) - - #expect(parser.states.count() == 1) - #expect(state_result == P4Lang.reject) -} - -@Test func test_no_matching_key_transition() async throws { - let simple_parser_declaration = """ - parser main_parser() { - state start { - transition select (false) { - true: accept; - }; - } - }; - """ - - let program = try #UseOkResult(SpecialCompilers.ProgramCompiler.Compile(simple_parser_declaration)) - let runtime = try #UseOkResult(P4Runtime.Runtime.create(program: program)) - - #expect( - #RequireErrorResult<(InstantiatedParserState, ProgramExecution)>( - Error(withMessage: "No key matched the selector"), - runtime.run())) -} \ No newline at end of file diff --git a/Tests/p4rseTests/TypeTests.swift b/Tests/p4rseTests/TypeTests.swift deleted file mode 100644 index e07ad34..0000000 --- a/Tests/p4rseTests/TypeTests.swift +++ /dev/null @@ -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 . - -import Foundation -import Macros -import SwiftTreeSitter -import Testing -import TreeSitter -import TreeSitterP4 - -@testable import Common - -@Test func test_simple_struct() async throws { - let fields = P4StructFields([ - P4StructFieldIdentifier(name: "yesno", withType: P4QualifiedType(P4Boolean())), - P4StructFieldIdentifier(name: "count", withType: P4QualifiedType(P4Int())), - ]) - - let struct_type = P4Struct(withName: Identifier(name: "Testing"), andFields: fields) - - #expect(struct_type.fields.count() == 2) - #expect(struct_type.fields == fields) -} \ No newline at end of file diff --git a/Tests/p4rseTests/Unsupported.swift b/Tests/p4rseTests/Unsupported.swift deleted file mode 100644 index 38141b5..0000000 --- a/Tests/p4rseTests/Unsupported.swift +++ /dev/null @@ -1,56 +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 . - -import Common -import Foundation -import Macros -import P4Lang -import Runtime -import SwiftTreeSitter -import Testing -import TreeSitter -import TreeSitterP4 - -@testable import P4Compiler - -@Test func test_unsupported_annotations() async throws { - let simple_annotated_parser_declaration = """ - @testing parser main_parser() { - state start { - transition start; - } - }; - """ - #expect( - #RequireErrorResult( - Error(withMessage: "{0, 8}: Annotations in parser type are not yet handled."), - SpecialCompilers.ProgramCompiler.Compile(simple_annotated_parser_declaration))) -} - -@Test func test_unsupported_annotations_state() async throws { - let simple_annotated_parser_declaration = """ - parser main_parser() { - @testing state start { - transition start; - } - }; - """ - #expect( - #RequireErrorResult( - Error(withMessage: "{26, 8}: Annotations in parser state are not yet handled."), - SpecialCompilers.ProgramCompiler.Compile(simple_annotated_parser_declaration))) -} diff --git a/Tests/p4rseTests/ValueTypeParserTests.swift b/Tests/p4rseTests/ValueTypeParserTests.swift deleted file mode 100644 index fb40702..0000000 --- a/Tests/p4rseTests/ValueTypeParserTests.swift +++ /dev/null @@ -1,373 +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 . - -import Common -import Foundation -import Macros -import P4Lang -import P4Runtime -import SwiftTreeSitter -import Testing -import TreeSitter -import TreeSitterP4 - -@testable import P4Compiler - -@Test func test_invalid_types() async throws { - for invalid_type_name in ["boo", "str", "in"] { - let simple_parser_declaration = """ - parser main_parser() { - state start { - \(invalid_type_name) v = 1; - transition reject; - } - }; - """ - - let err = SpecialCompilers.ProgramCompiler.Compile(simple_parser_declaration) - guard case Result.Error(let e) = err else { - assert(false, "Expected an error, but had success") - } - #expect( - e.msg().contains( - "Failed to parse a statement element: Could not parse a P4 type from \(invalid_type_name)")) - } -} - -@Test func test_invalid_type_in_assignment() async throws { - let simple_parser_declaration = """ - parser main_parser() { - state start { - string g = "Testing"; - string where_to = "Testing"; - where_to = true; - transition reject; - } - }; - """ - - #expect( - #RequireErrorResult( - Error( - withMessage: - "{112, 16}: Failed to parse a statement element: {112, 8}: Cannot assign value with type Boolean to identifier where_to with type String" - ), - SpecialCompilers.ProgramCompiler.Compile(simple_parser_declaration))) -} - -@Test func test_invalid_type_in_assignment2() async throws { - let simple_parser_declaration = """ - parser main_parser() { - state start { - bool where_to = true; - string where_from = "testing"; - where_to = where_from; - transition reject; - } - }; - """ - - #expect( - #RequireErrorResult( - Error( - withMessage: - "{114, 22}: Failed to parse a statement element: {114, 8}: Cannot assign value with type String to identifier where_to with type Boolean" - ), - SpecialCompilers.ProgramCompiler.Compile(simple_parser_declaration))) -} - -@Test func test_invalid_type_in_declaration() async throws { - let simple_parser_declaration = """ - parser main_parser() { - state start { - string where_from = "testing"; - bool where_to = where_from; - transition reject; - } - }; - """ - - #expect( - #RequireErrorResult( - Error( - withMessage: - "{86, 27}: Failed to parse a statement element: Cannot initialize where_to (with type Boolean) from expression with type String" - ), - SpecialCompilers.ProgramCompiler.Compile(simple_parser_declaration))) -} - -@Test func test_invalid_type_in_declaration2() async throws { - let simple_parser_declaration = """ - parser main_parser() { - state start { - bool where_to = true; - string where_from = where_to; - transition reject; - } - }; - """ - - #expect( - #RequireErrorResult( - Error( - withMessage: - "{77, 29}: Failed to parse a statement element: Cannot initialize where_from (with type String) from expression with type Boolean" - ), - SpecialCompilers.ProgramCompiler.Compile(simple_parser_declaration))) -} - -@Test func test_invalid_type_in_declaration3() async throws { - let simple_parser_declaration = """ - parser main_parser() { - state start { - int<5> specific_width_int = 5; - int unspecific_width_int = specific_width_int; - transition reject; - } - }; - """ - - let error = try! #UseErrorResult(SpecialCompilers.ProgramCompiler.Compile(simple_parser_declaration)) - - #expect( - error.msg().contains( - "Cannot initialize specific_width_int (with type Int (width: Width(5))) from expression with type Int (width: Infinite)" - )) -} - -@Test func test_valid_specific_width_int_type_in_declaration() async throws { - let simple_parser_declaration = """ - parser main_parser() { - state start { - int<5> specific_width_int = 5w5; - int<5> unspecific_width_int = specific_width_int; - transition reject; - } - }; - """ - - #expect(#RequireOkResult(SpecialCompilers.ProgramCompiler.Compile(simple_parser_declaration))) -} - -@Test func test_expression_in_declaration_initializer_specific_width_int_type() async throws { - let simple_parser_declaration = """ - parser main_parser() { - state start { - int<5> specific_width_int = 5w5; - bool where_to = 5w5 == specific_width_int == true; - transition select (where_to) { - true: accept; - false: reject; - }; - } - }; - """ - - let program = try #UseOkResult(SpecialCompilers.ProgramCompiler.Compile(simple_parser_declaration)) - let runtime = try #UseOkResult( - P4Runtime.Runtime.create(program: program)) - let (state_result, _) = try! #UseOkResult(runtime.run()) - - // 5w5 == specific_width_int == true - // true == true - // true - #expect(state_result == P4Lang.accept) -} - -@Test func test_expression_in_declaration_initializer_specific_width_int_type2() async throws { - let simple_parser_declaration = """ - parser main_parser() { - state start { - int<5> specific_width_int = 5w5; - bool where_to = 5w6 == specific_width_int == false; - transition select (where_to) { - true: accept; - false: reject; - }; - } - }; - """ - - let program = try #UseOkResult(SpecialCompilers.ProgramCompiler.Compile(simple_parser_declaration)) - let runtime = try #UseOkResult( - P4Runtime.Runtime.create(program: program)) - let (state_result, _) = try! #UseOkResult(runtime.run()) - - // 5w6 == specific_width_int == false - // false == false - // true - #expect(state_result == P4Lang.accept) -} - -@Test func test_expression_in_declaration_initializer() async throws { - let simple_parser_declaration = """ - parser main_parser() { - state start { - bool where_to = 5 == 5 == true; - transition select (where_to) { - true: accept; - false: reject; - }; - } - }; - """ - let program = try #UseOkResult(SpecialCompilers.ProgramCompiler.Compile(simple_parser_declaration)) - let runtime = try #UseOkResult( - P4Runtime.Runtime.create(program: program)) - let (state_result, _) = try! #UseOkResult(runtime.run()) - - // 5 == 5 == true - // true == true - // true - #expect(state_result == P4Lang.accept) -} - -@Test func test_expression_in_declaration_initializer2() async throws { - let simple_parser_declaration = """ - parser main_parser() { - state start { - bool where_to = 5 == 5 == false; - transition select (where_to) { - true: accept; - false: reject; - }; - } - }; - """ - let program = try #UseOkResult(SpecialCompilers.ProgramCompiler.Compile(simple_parser_declaration)) - let runtime = try #UseOkResult( - P4Runtime.Runtime.create(program: program)) - let (state_result, _) = try! #UseOkResult(runtime.run()) - - // 5 == 5 == true - // true == false - // false - #expect(state_result == P4Lang.reject) -} - -@Test func test_expression_in_declaration_initializer_false() async throws { - let simple_parser_declaration = """ - parser main_parser() { - state start { - bool where_to = 6 == 5 == true; - transition select (where_to) { - true: accept; - false: reject; - }; - } - }; - """ - let program = try #UseOkResult(SpecialCompilers.ProgramCompiler.Compile(simple_parser_declaration)) - let runtime = try #UseOkResult( - P4Runtime.Runtime.create(program: program)) - let (state_result, _) = try! #UseOkResult(runtime.run()) - - // 6 == 5 == true - // false == true - // false - #expect(state_result == P4Lang.reject) -} - -@Test func test_expression_in_declaration_initializer_false2() async throws { - let simple_parser_declaration = """ - parser main_parser() { - state start { - bool where_to = 6 == 5 == false; - transition select (where_to) { - true: accept; - false: reject; - }; - } - }; - """ - let program = try #UseOkResult(SpecialCompilers.ProgramCompiler.Compile(simple_parser_declaration)) - let runtime = try #UseOkResult( - P4Runtime.Runtime.create(program: program)) - let (state_result, _) = try! #UseOkResult(runtime.run()) - - // 6 == 5 == false - // false == false - // true - #expect(state_result == P4Lang.accept) -} - -@Test func test_expression_in_declaration_initializer_invalid_types() async throws { - let simple_parser_declaration = """ - parser main_parser() { - state start { - bool where_to = false == 5 == true; - transition select (where_to) { - true: accept; - false: reject; - }; - } - }; - """ - - #expect( - #RequireErrorResult( - Error( - withMessage: - "{49, 35}: Failed to parse a statement element: Types of values used with binary expression are not the same" - ), - SpecialCompilers.ProgramCompiler.Compile(simple_parser_declaration))) - -} - -@Test func test_expression_in_declaration_initializer_invalid_types2() async throws { - let simple_parser_declaration = """ - parser main_parser() { - state start { - bool where_to = ta[0]; - transition select (where_to) { - true: accept; - false: reject; - }; - } - }; - """ - var test_declarations = StaticVarValueScopes().enter() - test_declarations = test_declarations.declare( - identifier: Identifier(name: "ta"), - withValue: (P4QualifiedType(P4Array(withValueType: P4QualifiedType(P4Int()))), .none)) - - #expect( - #RequireErrorResult( - Error( - withMessage: - "{49, 22}: Failed to parse a statement element: Cannot initialize where_to (with type Boolean) from expression with type Int (width: Infinite)" - ), - SpecialCompilers.ProgramCompiler.Compile(simple_parser_declaration, withGlobalInstances: test_declarations))) -} - -@Test func test_simple_compiler_parser_parameters_invalid_types() async throws { - let simple_parser_declaration = """ - parser main_parser(bool pmtr, string smtr, int imtr) { - state start { - pmtr = 1; - transition accept; - } - }; - """ - #expect( - #RequireErrorResult( - Error( - withMessage: - "{85, 9}: Failed to parse a statement element: {85, 4}: Cannot assign value with type Int (width: Infinite) to identifier pmtr with type Boolean" - ), - SpecialCompilers.ProgramCompiler.Compile(simple_parser_declaration))) -}