Reindent all code using latest Xcode

Author: Frizlab

Sources/SignalHandling/CStructsInSwift/Sigaction.swift

@@ -10,13 +10,13 @@ public struct Sigaction : Equatable, RawRepresentable {
 	public static let defaultAction = Sigaction(handler: .defaultHandler)
 
 	/**
-	Check if the given signal is ignored using `sigaction`. */
+	 Check if the given signal is ignored using `sigaction`. */
 	public static func isSignalIgnored(_ signal: Signal) throws -> Bool {
 		return try Sigaction(signal: signal).handler == .ignoreHandler
 	}
 
 	/**
-	Check if the given signal is handled with default action using `sigaction`. */
+	 Check if the given signal is handled with default action using `sigaction`. */
 	public static func isSignalDefaultAction(_ signal: Signal) throws -> Bool {
 		return try Sigaction(signal: signal).handler == .defaultHandler
 	}
@@ -36,32 +36,32 @@ public struct Sigaction : Equatable, RawRepresentable {
 	}
 
 	/**
-	Create a `Sigaction` from a `sigaction`.
-	
-	If the handler of the sigaction is `SIG_IGN` or `SIG_DFL`, we check the
-	`sa_flags` not to contains the `SA_SIGINFO` bit. If they do, we log an error,
-	as this is invalid. */
+	 Create a `Sigaction` from a `sigaction`.
+	 
+	 If the handler of the sigaction is `SIG_IGN` or `SIG_DFL`, we check the
+	 `sa_flags` not to contains the `SA_SIGINFO` bit. If they do, we log an
+	 error, as this is invalid. */
 	public init(rawValue: sigaction) {
 		self.mask = Signal.set(from: rawValue.sa_mask)
 		self.flags = SigactionFlags(rawValue: rawValue.sa_flags)
 
-		#if !os(Linux)
+#if !os(Linux)
 		switch OpaquePointer(bitPattern: unsafeBitCast(rawValue.__sigaction_u.__sa_handler, to: Int.self)) {
 			case OpaquePointer(bitPattern: unsafeBitCast(SIG_IGN, to: Int.self)): self.handler = .ignoreHandler
 			case OpaquePointer(bitPattern: unsafeBitCast(SIG_DFL, to: Int.self)): self.handler = .defaultHandler
 			default:
 				if flags.contains(.siginfo) {self.handler = .posix(rawValue.__sigaction_u.__sa_sigaction)}
 				else                        {self.handler = .ansiC(rawValue.__sigaction_u.__sa_handler)}
 		}
-		#else
+#else
 		switch OpaquePointer(bitPattern: unsafeBitCast(rawValue.__sigaction_handler.sa_handler, to: Int.self)) {
 			case OpaquePointer(bitPattern: unsafeBitCast(SIG_IGN, to: Int.self)): self.handler = .ignoreHandler
 			case OpaquePointer(bitPattern: unsafeBitCast(SIG_DFL, to: Int.self)): self.handler = .defaultHandler
 			default:
 				if flags.contains(.siginfo) {self.handler = .posix(rawValue.__sigaction_handler.sa_sigaction)}
 				else                        {self.handler = .ansiC(rawValue.__sigaction_handler.sa_handler)}
 		}
-		#endif
+#endif
 
 		if !isValid {
 			SignalHandlingConfig.logger?.warning("Initialized an invalid Sigaction.")
@@ -85,42 +85,42 @@ public struct Sigaction : Equatable, RawRepresentable {
 		ret.sa_mask = Signal.sigset(from: mask)
 		ret.sa_flags = flags.rawValue
 
-		#if !os(Linux)
+#if !os(Linux)
 		switch handler {
 			case .ignoreHandler:  ret.__sigaction_u.__sa_handler = SIG_IGN
 			case .defaultHandler: ret.__sigaction_u.__sa_handler = SIG_DFL
 			case .ansiC(let h):   ret.__sigaction_u.__sa_handler = h
 			case .posix(let h):   ret.__sigaction_u.__sa_sigaction = h
 		}
-		#else
+#else
 		switch handler {
 			case .ignoreHandler:  ret.__sigaction_handler.sa_handler = SIG_IGN
 			case .defaultHandler: ret.__sigaction_handler.sa_handler = SIG_DFL
 			case .ansiC(let h):   ret.__sigaction_handler.sa_handler = h
 			case .posix(let h):   ret.__sigaction_handler.sa_sigaction = h
 		}
-		#endif
+#endif
 
 		return ret
 	}
 
 	/**
-	Only one check: do the flags **not** contain `siginfo` if handler is either
-	`.ignoreHandler` or `.defaultHandler`. */
+	 Only one check: do the flags **not** contain `siginfo` if handler is either
+	 `.ignoreHandler` or `.defaultHandler`. */
 	public var isValid: Bool {
 		return !flags.contains(.siginfo) || (handler != .ignoreHandler && handler != .defaultHandler)
 	}
 
 	/**
-	Installs the sigaction and returns the old one if different.
-	
-	It is impossible for a sigaction handler to be `nil`. If the method returns
-	`nil`, the previous handler was exactly the same as the one you installed.
-	Note however the sigaction function is always called in this method.
-	
-	If `updateUnsigRegistrations` is true (default), If there are delayed
-	sigactions registered with `SigactionDelayer_Unsig`, these registrations will
-	be updated and `sigaction` will not be called. */
+	 Installs the sigaction and returns the old one if different.
+	 
+	 It is impossible for a sigaction handler to be `nil`. If the method returns
+	 `nil`, the previous handler was exactly the same as the one you installed.
+	 Note however the sigaction function is always called in this method.
+	 
+	 If `updateUnsigRegistrations` is true (default), If there are delayed
+	 sigactions registered with `SigactionDelayer_Unsig`, these registrations
+	 will be updated and `sigaction` will not be called. */
 	@discardableResult
 	public func install(on signal: Signal, revertIfIgnored: Bool = true, updateUnsigRegistrations: Bool = true) throws -> Sigaction? {
 		if updateUnsigRegistrations, let oldSigaction = SigactionDelayer_Unsig.updateOriginalSigaction(for: signal, to: self) {

Sources/SignalHandling/CStructsInSwift/SigactionFlag.swift

@@ -6,41 +6,41 @@ import Foundation
 public struct SigactionFlags : OptionSet {
 
 	/**
-	If this bit is set when installing a catching function for the `SIGCHLD`
-	signal, the `SIGCHLD` signal will be generated only when a child process
-	exits, not when a child process stops. */
+	 If this bit is set when installing a catching function for the `SIGCHLD`
+	 signal, the `SIGCHLD` signal will be generated only when a child process
+	 exits, not when a child process stops. */
 	public static let noChildStop = SigactionFlags(rawValue: SA_NOCLDSTOP)
 
 	/**
-	If this bit is set when calling `sigaction()` for the `SIGCHLD` signal, the
-	system will not create zombie processes when children of the calling process
-	exit. If the calling process subsequently issues a `wait(2)` (or equivalent),
-	it blocks until all of the calling process’s child processes terminate, and
-	then returns a value of -1 with errno set to ECHILD. */
+	 If this bit is set when calling `sigaction()` for the `SIGCHLD` signal, the
+	 system will not create zombie processes when children of the calling process
+	 exit. If the calling process subsequently issues a `wait(2)` (or
+	 equivalent), it blocks until all of the calling process’s child processes
+	 terminate, and then returns a value of -1 with errno set to ECHILD. */
 	public static let noChildWait = SigactionFlags(rawValue: SA_NOCLDWAIT)
 
 	/**
-	If this bit is set, the system will deliver the signal to the process on a
-	signal stack, specified with `sigaltstack(2)`. */
+	 If this bit is set, the system will deliver the signal to the process on a
+	 signal stack, specified with `sigaltstack(2)`. */
 	public static let onStack = SigactionFlags(rawValue: SA_ONSTACK)
 
 	/**
-	If this bit is set, further occurrences of the delivered signal are not
-	masked during the execution of the handler. */
+	 If this bit is set, further occurrences of the delivered signal are not
+	 masked during the execution of the handler. */
 	public static let noDefer = SigactionFlags(rawValue: SA_NODEFER)
 
 	/**
-	If this bit is set, the handler is reset back to `SIG_DFL` at the moment the
-	signal is delivered. */
+	 If this bit is set, the handler is reset back to `SIG_DFL` at the moment the
+	 signal is delivered. */
 	public static let resetHandler = SigactionFlags(rawValue: CInt(SA_RESETHAND) /* On Linux, an UInt32 instead of Int32, so we cast… */)
 
 	/** See `sigaction(2)`. */
 	public static let restart = SigactionFlags(rawValue: SA_RESTART)
 
 	/**
-	If this bit is set, the handler function is assumed to be pointed to by the
-	`sa_sigaction` member of struct sigaction and should match the matching
-	prototype. This bit should not be set when assigning `SIG_DFL` or `SIG_IGN`. */
+	 If this bit is set, the handler function is assumed to be pointed to by the
+	 `sa_sigaction` member of struct sigaction and should match the matching
+	 prototype. This bit should not be set when assigning `SIG_DFL` or `SIG_IGN`. */
 	public static let siginfo = SigactionFlags(rawValue: SA_SIGINFO)
 
 	public let rawValue: CInt

Sources/SignalHandling/CStructsInSwift/SigactionHandler.swift

@@ -3,18 +3,18 @@ import Foundation
 
 
 /**
-A `sigaction` handler.
-
-Two `SigactionHandler`s are equal iif their cases are equal and the handler
-they contain point to the same address (if applicable). */
+ A `sigaction` handler.
+ 
+ Two `SigactionHandler`s are equal iif their cases are equal and the handler
+ they contain point to the same address (if applicable). */
 public enum SigactionHandler : Equatable {
 
 	/* The ignore and default handlers are special cases represented respectively
-	 * by the `SIG_IGN` and `SIG_DFL` values in C.
-	 * We choose the represent them using a special case in the enum. You should
-	 * not (though you could) use `.ansiC(SIG_IGN)` (it is not possible with
-	 * `SIG_DFL` because `SIG_DFL` is optional… and nil).
-	 * In particular, `.ignoreHandler != .ansiC(SIG_IGN)` */
+	 * by the `SIG_IGN` and `SIG_DFL` values in C.
+	 * We choose the represent them using a special case in the enum. You should
+	 * not (though you could) use `.ansiC(SIG_IGN)` (it is not possible with
+	 * `SIG_DFL` because `SIG_DFL` is optional… and nil).
+	 * In particular, `.ignoreHandler != .ansiC(SIG_IGN)` */
 	case ignoreHandler
 	case defaultHandler
 
@@ -29,8 +29,8 @@ public enum SigactionHandler : Equatable {
 			case (.ansiC, .ansiC), (.posix, .posix):
 				return lhs.asOpaquePointer == rhs.asOpaquePointer
 
-			/* Using this matching patterns instead of simply default, we force a
-			 * compilation error in case more cases are added later. */
+				/* Using this matching patterns instead of simply default, we force
+				 * a compilation error in case more cases are added later. */
 			case (.ignoreHandler, _), (.defaultHandler, _), (.ansiC, _), (.posix, _):
 				return false
 		}