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

Make Formatter Happy

Browse Source 
Signed-off-by: Will Hawkins <hawkinsw@obs.cr>
This commit is contained in:
Will Hawkins
2026-04-20 05:54:00 -04:00
parent d33066c543
commit 883b4127e8
9 changed files with 50 additions and 33 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Sources/Common/Execution.swift
+8 -4
View File
@@ -16,7 +16,8 @@
// along with this program. If not, see <https://www.gnu.org/licenses/>.
public typealias StatementInterloper = (EvaluatableStatement, ControlFlow, ProgramExecution) -> Void
public typealias ExpressionInterloper = (EvaluatableExpression, Result<P4Value>, ProgramExecution) -> Void
public typealias ExpressionInterloper = (EvaluatableExpression, Result<P4Value>, ProgramExecution)
-> Void
open class ProgramExecution: CustomStringConvertible {
public var scopes: VarValueScopes = VarValueScopes()
@@ -75,7 +76,9 @@ open class ProgramExecution: CustomStringConvertible {
return self.statement_interloper
}
public func setStatementInterloper(_ interloper: @escaping StatementInterloper) -> ProgramExecution {
public func setStatementInterloper(
_ interloper: @escaping StatementInterloper
) -> ProgramExecution {
let pe = ProgramExecution(copy: self)
pe.statement_interloper = interloper
return pe
@@ -85,7 +88,9 @@ open class ProgramExecution: CustomStringConvertible {
return self.expression_interloper
}
public func setExpressionInterloper(_ interloper: @escaping ExpressionInterloper) -> ProgramExecution {
public func setExpressionInterloper(
_ interloper: @escaping ExpressionInterloper
) -> ProgramExecution {
let pe = ProgramExecution(copy: self)
pe.expression_interloper = interloper
return pe
@@ -138,7 +143,6 @@ open class ProgramExecution: CustomStringConvertible {
return new_pe
}
}
/// A scope that resolves variable identifiers to their values.
Sources/P4Compiler/Common.swift
+3 -2
View File
@@ -363,8 +363,9 @@ func ContainsInvalidStatements(
return false
}
func ContainsInvalidStatements(block: BlockStatement, invalids: [EvaluatableStatement.Type]) -> Bool {
return block.statements.contains() { statement in
func ContainsInvalidStatements(block: BlockStatement, invalids: [EvaluatableStatement.Type]) -> Bool
{
return block.statements.contains { statement in
for es in invalids {
if type(of: statement) == es {
return true
Sources/P4Compiler/Declarations.swift
+4 -2
View File
@@ -492,7 +492,7 @@ extension Control: CompilableDeclaration {
apply = (apply_statement as! ApplyStatement)
// The apply is the last thing in a control declaration.
break;
break
} else {
return .Error(
ErrorOnNode(node: currentChild, withError: "Uknown node type in control declaration"))
@@ -603,7 +603,9 @@ extension Action: Compilable {
return .Ok(
(
Action(named: action_name, withParameters: action_parameters, withBody: (action_body as! BlockStatement)),
Action(
named: action_name, withParameters: action_parameters,
withBody: (action_body as! BlockStatement)),
current_context
))
}
Sources/P4Compiler/Statement.swift
+4 -3
View File
@@ -247,8 +247,8 @@ extension ExpressionStatement: CompilableStatement {
let expression_node = node.child(at: 0)!
return switch Expression.Compile(node: expression_node, withContext: context) {
case .Ok(let expression): .Ok((ExpressionStatement(expression), context))
case .Error(let e): .Error(e)
case .Ok(let expression): .Ok((ExpressionStatement(expression), context))
case .Error(let e): .Error(e)
}
}
}
@@ -340,7 +340,8 @@ extension ApplyStatement: CompilableStatement {
let expression_node = node.child(at: 1)!
return switch BlockStatement.Compile(node: expression_node, withContext: context) {
case .Ok((let statement, let updated_context)): .Ok((ApplyStatement(statement as! BlockStatement), updated_context))
case .Ok((let statement, let updated_context)):
.Ok((ApplyStatement(statement as! BlockStatement), updated_context))
case .Error(let e): .Error(e)
}
}
Sources/P4Runtime/Common.swift
+5 -2
View File
@@ -84,7 +84,9 @@ public func Call<T>(
return (.Ok(call_result), updated_execution.replaceScopes(inout_scopes))
}
public typealias ExecuteStatementResultHandler = (ControlFlow, ProgramExecution) -> (ControlFlow, ProgramExecution)
public typealias ExecuteStatementResultHandler = (ControlFlow, ProgramExecution) -> (
ControlFlow, ProgramExecution
)
public func ExecuteStatement(
_ statements: [EvaluatableStatement], handleResult handler: ExecuteStatementResultHandler,
@@ -119,7 +121,8 @@ public func ExecuteStatement(
public func ExecuteStatement(
_ statement: EvaluatableStatement, handleResult handler: ExecuteStatementResultHandler,
inExecution execution: ProgramExecution) -> (ControlFlow, ProgramExecution) {
inExecution execution: ProgramExecution
) -> (ControlFlow, ProgramExecution) {
return ExecuteStatement([statement], handleResult: handler, inExecution: execution)
}
Sources/P4Runtime/Expressions.swift
+2 -1
View File
@@ -33,7 +33,8 @@ extension SelectExpression: EvaluatableExpression {
switch 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) = EvaluateExpression(sce.key, inExecution: updated_execution),
if case (.Ok(let kse), let updated_execution) = EvaluateExpression(
sce.key, inExecution: updated_execution),
kse.eq(selector_value)
{
//let result = sce.evaluate(execution: updated_execution)
Sources/P4Runtime/Parser.swift
+8 -8
View File
@@ -44,12 +44,12 @@ extension ParserStateDirectTransition: EvaluatableParserState {
) -> (any EvaluatableParserState, Common.ProgramExecution) {
var program = program.enter_scope()
let (control_flow, next_execution) = ExecuteStatement(statements, handleResult: { (control_flow, execution) in
return (control_flow, execution)
let (control_flow, next_execution) = ExecuteStatement(
statements,
handleResult: { (control_flow, execution) in
return (control_flow, execution)
}, inExecution: program)
switch control_flow {
case .Next: program = next_execution
case .Error: return (reject, next_execution.exit_scope())
@@ -105,11 +105,12 @@ extension ParserStateSelectTransition: EvaluatableParserState {
) -> (any EvaluatableParserState, Common.ProgramExecution) {
var program = program.enter_scope()
let (control_flow, next_execution) = ExecuteStatement(statements, handleResult: { (control_flow, execution) in
return (control_flow, execution)
let (control_flow, next_execution) = ExecuteStatement(
statements,
handleResult: { (control_flow, execution) in
return (control_flow, execution)
}, inExecution: program)
switch control_flow {
case .Next: program = next_execution
case .Error: return (reject, next_execution.exit_scope())
@@ -121,7 +122,6 @@ extension ParserStateSelectTransition: EvaluatableParserState {
)
}
//switch self.selectExpression.evaluate(execution: program) {
switch EvaluateExpression(self.selectExpression, inExecution: program) {
case (.Ok(let value), let program):
Sources/P4Runtime/Runtime.swift
+11 -8
View File
@@ -55,7 +55,8 @@ public struct ParserRuntime: CustomStringConvertible {
}
public func run(withArguments arguments: ArgumentList) -> Result<(ParserState, ProgramExecution)> {
public func run(withArguments arguments: ArgumentList) -> Result<(ParserState, ProgramExecution)>
{
let pe =
if let initial = initialValues {
ProgramExecution(withGlobalValues: initial)
@@ -67,14 +68,16 @@ public struct ParserRuntime: CustomStringConvertible {
}
/// Run the P4 parser on a given packet
public func run(withArguments arguments: ArgumentList, inExecution pe: ProgramExecution) -> Result<(ParserState, ProgramExecution)>
{
public func run(
withArguments arguments: ArgumentList, inExecution pe: ProgramExecution
) -> Result<(ParserState, ProgramExecution)> {
let pe = if let globals = initialValues {
pe.setGlobalValues(globals)
} else {
pe
}
let pe =
if let globals = initialValues {
pe.setGlobalValues(globals)
} else {
pe
}
let (end_state, execution) = parser.call(execution: pe, arguments: arguments)
if let error = execution.getError() {
Sources/P4Runtime/Statements.swift
+4 -2
View File
@@ -44,7 +44,8 @@ extension VariableDeclarationStatement: EvaluatableStatement {
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) = EvaluateExpression(self.initializer, inExecution: execution)
case (.Ok(let initial_value), let execution) = EvaluateExpression(
self.initializer, inExecution: execution)
else {
return (
ControlFlow.Error,
@@ -61,7 +62,8 @@ extension ConditionalStatement: EvaluatableStatement {
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) = EvaluateExpression(self.condition, inExecution: execution)
case (.Ok(let evaluated_condition), let execution) = EvaluateExpression(
self.condition, inExecution: execution)
else {
return (
ControlFlow.Error,