Format files

src/Core/Toolchains/XcodeToolchain.cs

@@ -72,7 +72,8 @@ namespace CppSharp
         {
             try
             {
-                var xcodeSelect = Process.Start(new ProcessStartInfo("xcode-select", "--print-path") {
+                var xcodeSelect = Process.Start(new ProcessStartInfo("xcode-select", "--print-path")
+                {
                     RedirectStandardOutput = true,
                     UseShellExecute = false
                 });
@@ -85,7 +86,9 @@ namespace CppSharp
                     if (extraStuffIndex >= 0)
                         return result.Remove(extraStuffIndex);
                 }
-            } catch {
+            }
+            catch
+            {
                 // TODO: Log exception?
             }
             return null;

src/Generator/Generators/C/CppTypePrinter.cs

@@ -237,8 +237,12 @@ namespace CppSharp.Generators.C
             if (ResolveTypedefs && !typedef.Declaration.Type.IsPointerTo(out FunctionType _))
             {
                 TypePrinterResult type = typedef.Declaration.QualifiedType.Visit(this);
-                return new TypePrinterResult { Type = $"{qual}{type.Type}",
-                    NamePrefix = type.NamePrefix, NameSuffix = type.NameSuffix };
+                return new TypePrinterResult
+                {
+                    Type = $"{qual}{type.Type}",
+                    NamePrefix = type.NamePrefix,
+                    NameSuffix = type.NameSuffix
+                };
             }
 
             var result = typedef.Declaration.Visit(this);

src/Generator/Generators/CSharp/CSharpSources.cs

@@ -1067,7 +1067,8 @@ internal static bool {Helpers.TryGetNativeToManagedMappingIdentifier}(IntPtr nat
                     f => f.FieldPtr == field.OriginalPtr).Name;
                 if (@class.IsValueType)
                     returnVar = $"{Helpers.InstanceField}.{name}";
-                else {
+                else
+                {
                     var typeName = TypePrinter.PrintNative(@class);
                     if (IsInternalClassNested(field.Class))
                         typeName.RemoveNamespace();
@@ -1649,7 +1650,8 @@ internal static bool {Helpers.TryGetNativeToManagedMappingIdentifier}(IntPtr nat
             if (!isIndexer)
                 return prop.Name;
 
-            var @params = prop.Parameters.Select(param => {
+            var @params = prop.Parameters.Select(param =>
+            {
                 var p = new Parameter(param);
                 p.Usage = ParameterUsage.In;
                 return p;
@@ -1671,7 +1673,8 @@ internal static bool {Helpers.TryGetNativeToManagedMappingIdentifier}(IntPtr nat
 
             if (variable.Initializer != null && !string.IsNullOrWhiteSpace(variable.Initializer.String))
                 GeneratePropertyGetterForVariableWithInitializer(variable, signature);
-            else {
+            else
+            {
                 WriteLine(signature);
                 WriteOpenBraceAndIndent();
 

src/Generator/Generators/CSharp/CSharpTypePrinter.cs

@@ -467,15 +467,19 @@ namespace CppSharp.Generators.CSharp
                 case PrimitiveType.LongLong:
                 case PrimitiveType.ULongLong:
                     return GetIntString(primitive, Context.TargetInfo);
-                case PrimitiveType.Int128: return new TypePrinterResult("fixed byte",
+                case PrimitiveType.Int128:
+                    return new TypePrinterResult("fixed byte",
 "[16]"); // The type is always 128 bits wide
-                case PrimitiveType.UInt128: return new TypePrinterResult("fixed byte",
+                case PrimitiveType.UInt128:
+                    return new TypePrinterResult("fixed byte",
 "[16]"); // The type is always 128 bits wide
-                case PrimitiveType.Half: return new TypePrinterResult("fixed byte",
+                case PrimitiveType.Half:
+                    return new TypePrinterResult("fixed byte",
 $"[{Context.TargetInfo.HalfWidth}]");
                 case PrimitiveType.Float: return "float";
                 case PrimitiveType.Double: return "double";
-                case PrimitiveType.LongDouble: return new TypePrinterResult("fixed byte",
+                case PrimitiveType.LongDouble:
+                    return new TypePrinterResult("fixed byte",
 $"[{Context.TargetInfo.LongDoubleWidth}]");
                 case PrimitiveType.IntPtr: return IntPtrType;
                 case PrimitiveType.UIntPtr: return QualifiedType("System.UIntPtr");

src/Generator/Utils/FSM/ConsoleWriter.cs

@@ -1,18 +1,23 @@
 using System;
 
-namespace CppSharp.Utils.FSM{
-   public class ConsoleWriter{
-      public static void Failure(string message){
+namespace CppSharp.Utils.FSM
+{
+    public class ConsoleWriter
+    {
+        public static void Failure(string message)
+        {
             Console.ForegroundColor = ConsoleColor.DarkRed;
             Write(message);
         }
 
-      public static void Success(string message){
+        public static void Success(string message)
+        {
             Console.ForegroundColor = ConsoleColor.DarkGreen;
             Write(message);
         }
 
-      private static void Write(string message){
+        private static void Write(string message)
+        {
             Console.WriteLine(message);
             Console.ResetColor();
         }

src/Generator/Utils/FSM/DFSM.cs

@@ -4,7 +4,8 @@ using System.Text;
 
 namespace CppSharp.Utils.FSM
 {
-   public class DFSM{
+    public class DFSM
+    {
         public readonly List<string> Q = new List<string>();
         public readonly List<char> Sigma = new List<char>();
         public readonly List<Transition> Delta = new List<Transition>();
@@ -12,7 +13,8 @@ namespace CppSharp.Utils.FSM
         public List<string> F = new List<string>();
 
         public DFSM(IEnumerable<string> q, IEnumerable<char> sigma, IEnumerable<Transition> delta,
-         IEnumerable<string> q0, IEnumerable<string> f){
+           IEnumerable<string> q0, IEnumerable<string> f)
+        {
             Q = q.ToList();
             Sigma = sigma.ToList();
             AddTransitions(delta);
@@ -20,48 +22,61 @@ namespace CppSharp.Utils.FSM
             AddFinalStates(f);
         }
 
-      private void AddTransitions(IEnumerable<Transition> transitions){
-         foreach (var transition in transitions.Where(ValidTransition)){
+        private void AddTransitions(IEnumerable<Transition> transitions)
+        {
+            foreach (var transition in transitions.Where(ValidTransition))
+            {
                 Delta.Add(transition);
             }
         }
 
-      private bool ValidTransition(Transition transition){
+        private bool ValidTransition(Transition transition)
+        {
             return Q.Contains(transition.StartState) &&
                    Q.Contains(transition.EndState) &&
                    Sigma.Contains(transition.Symbol) &&
                    !TransitionAlreadyDefined(transition);
         }
 
-      private bool TransitionAlreadyDefined(Transition transition){
+        private bool TransitionAlreadyDefined(Transition transition)
+        {
             return Delta.Any(t => t.StartState == transition.StartState &&
                                   t.Symbol == transition.Symbol);
         }
 
-      private void AddInitialStates(IEnumerable<string> q0){
-         foreach (var startingState in q0.Where(q => q != null && Q.Contains(q))){
+        private void AddInitialStates(IEnumerable<string> q0)
+        {
+            foreach (var startingState in q0.Where(q => q != null && Q.Contains(q)))
+            {
                 Q0.Add(startingState);
             }
         }
 
-      private void AddFinalStates(IEnumerable<string> finalStates){
-         foreach (var finalState in finalStates.Where(finalState => Q.Contains(finalState))){
+        private void AddFinalStates(IEnumerable<string> finalStates)
+        {
+            foreach (var finalState in finalStates.Where(finalState => Q.Contains(finalState)))
+            {
                 F.Add(finalState);
             }
         }
 
-      public void Accepts(string input){
+        public void Accepts(string input)
+        {
             ConsoleWriter.Success("Trying to parse: " + input);
-         if (InvalidInputOrFSM(input)){
+            if (InvalidInputOrFSM(input))
+            {
                 return;
             }
-         foreach (var q0 in Q0){
+            foreach (var q0 in Q0)
+            {
                 var currentState = q0;
                 var steps = new StringBuilder();
-            foreach (var symbol in input.ToCharArray()){
+                foreach (var symbol in input.ToCharArray())
+                {
                     var transition = Delta.Find(t => t.StartState == currentState &&
                                                      t.Symbol == symbol);
-               if (transition == null){
+                    if (transition == null)
+                    {
                         ConsoleWriter.Failure("No transitions for current state and symbol");
                         ConsoleWriter.Failure(steps.ToString());
                         continue;
@@ -69,7 +84,8 @@ namespace CppSharp.Utils.FSM
                     currentState = transition.EndState;
                     steps.Append(transition + "\n");
                 }
-            if (F.Contains(currentState)){
+                if (F.Contains(currentState))
+                {
                     ConsoleWriter.Success("Accepted the input with steps:\n" + steps);
                     return;
                 }
@@ -79,43 +95,54 @@ namespace CppSharp.Utils.FSM
             }
         }
 
-      private bool InvalidInputOrFSM(string input){
-         if (InputContainsNotDefinedSymbols(input)){
+        private bool InvalidInputOrFSM(string input)
+        {
+            if (InputContainsNotDefinedSymbols(input))
+            {
                 return true;
             }
-         if (InitialStateNotSet()){
+            if (InitialStateNotSet())
+            {
                 ConsoleWriter.Failure("No initial state has been set");
                 return true;
             }
-         if (NoFinalStates()){
+            if (NoFinalStates())
+            {
                 ConsoleWriter.Failure("No final states have been set");
                 return true;
             }
             return false;
         }
 
-      private bool InputContainsNotDefinedSymbols(string input){
-         foreach (var symbol in input.ToCharArray().Where(symbol => !Sigma.Contains(symbol))){
+        private bool InputContainsNotDefinedSymbols(string input)
+        {
+            foreach (var symbol in input.ToCharArray().Where(symbol => !Sigma.Contains(symbol)))
+            {
                 ConsoleWriter.Failure("Could not accept the input since the symbol " + symbol + " is not part of the alphabet");
                 return true;
             }
             return false;
         }
 
-      private bool InitialStateNotSet(){
+        private bool InitialStateNotSet()
+        {
             return Q0.Count == 0;
         }
 
-      private bool NoFinalStates(){
+        private bool NoFinalStates()
+        {
             return F.Count == 0;
         }
 
-      public void RemoveUnreachableStates(){
+        public void RemoveUnreachableStates()
+        {
             var reachableStates = new HashSet<string>(Q0);
             var newStates = new HashSet<string>(Q0);
-         do{
+            do
+            {
                 var temp = new HashSet<string>();
-            foreach (var q in newStates){
+                foreach (var q in newStates)
+                {
                     var reachableFromQ = Delta.FindAll(t => t.StartState == q).Select(t => t.EndState);
                     temp.UnionWith(reachableFromQ);
                 }
@@ -124,14 +151,17 @@ namespace CppSharp.Utils.FSM
                 reachableStates.UnionWith(newStates);
             } while (newStates.Count > 0);
             var unreachableStates = Q.Where(q => !reachableStates.Contains(q));
-         for (int i = Delta.Count - 1; i > 0; i--){
+            for (int i = Delta.Count - 1; i > 0; i--)
+            {
                 var transition = Delta[i];
                 if (unreachableStates.Contains(transition.EndState) ||
-                unreachableStates.Contains(transition.StartState)){
+                    unreachableStates.Contains(transition.StartState))
+                {
                     Delta.Remove(transition);
                 }
             }
-         foreach (var unrechableState in unreachableStates){
+            foreach (var unrechableState in unreachableStates)
+            {
                 Q.Remove(unrechableState);
             }
         }

src/Generator/Utils/FSM/Minimize.cs

@@ -1,24 +1,30 @@
 using System.Collections.Generic;
 using System.Linq;
 
-namespace CppSharp.Utils.FSM{
-   internal class Minimize{
-      public static DFSM MinimizeDFSM(DFSM fsm){
+namespace CppSharp.Utils.FSM
+{
+    internal class Minimize
+    {
+        public static DFSM MinimizeDFSM(DFSM fsm)
+        {
             var reversedNDFSM = Reverse(fsm);
             var reversedDFSM = PowersetConstruction(reversedNDFSM);
             var NDFSM = Reverse(reversedDFSM);
             return PowersetConstruction(NDFSM);
         }
 
-      private static NDFSM Reverse(DFSM d){
+        private static NDFSM Reverse(DFSM d)
+        {
             var delta = new List<Transition>();
-         foreach (var transition in d.Delta){
+            foreach (var transition in d.Delta)
+            {
                 delta.Add(new Transition(transition.EndState, transition.Symbol, transition.StartState));
             }
             return new NDFSM(d.Q, d.Sigma, delta, d.F, d.Q0);
         }
 
-      public static DFSM PowersetConstruction(NDFSM ndfsm){
+        public static DFSM PowersetConstruction(NDFSM ndfsm)
+        {
             var Q = new List<string>();
             var Sigma = ndfsm.Sigma.ToList();
             var Delta = new List<Transition>();
@@ -29,14 +35,17 @@ namespace CppSharp.Utils.FSM{
             var queue = new Queue<string>();
             queue.Enqueue(string.Join(",", ndfsm.Q0));
 
-         while (queue.Count > 0){
+            while (queue.Count > 0)
+            {
                 var setState = queue.Dequeue();
                 processed.Add(setState);
                 Q.Add(CleanupState(setState));
 
                 var statesInCurrentSetState = setState.Split(',').ToList();
-            foreach (var state in statesInCurrentSetState){
-               if (ndfsm.F.Contains(state)){
+                foreach (var state in statesInCurrentSetState)
+                {
+                    if (ndfsm.F.Contains(state))
+                    {
                         F.Add(CleanupState(setState));
                         break;
                     }
@@ -45,7 +54,8 @@ namespace CppSharp.Utils.FSM{
                    .Where(t => statesInCurrentSetState.Contains(t.StartState))
                    .Select(t => t.Symbol)
                    .Distinct();
-            foreach (var symbol in symbols){
+                foreach (var symbol in symbols)
+                {
                     var reachableStates =
                        ndfsm.Delta
                           .Where(t => t.Symbol == symbol &&
@@ -56,7 +66,8 @@ namespace CppSharp.Utils.FSM{
 
                     Delta.Add(new Transition(CleanupState(setState), symbol, CleanupState(reachableSetState)));
 
-               if (!processed.Contains(reachableSetState)){
+                    if (!processed.Contains(reachableSetState))
+                    {
                         queue.Enqueue(reachableSetState);
                     }
                 }
@@ -64,7 +75,8 @@ namespace CppSharp.Utils.FSM{
             return new DFSM(Q, Sigma, Delta, Q0, F);
         }
 
-      private static string CleanupState(string state){
+        private static string CleanupState(string state)
+        {
             return state.Replace(",", " ");
         }
     }

src/Generator/Utils/FSM/NDFSM.cs

@@ -2,8 +2,10 @@
 using System.Linq;
 using System.Text;
 
-namespace CppSharp.Utils.FSM{
-   public class NDFSM{
+namespace CppSharp.Utils.FSM
+{
+    public class NDFSM
+    {
         private readonly List<string> Q = new List<string>();
         public readonly List<char> Sigma = new List<char>();
         public readonly List<Transition> Delta = new List<Transition>();
@@ -11,7 +13,8 @@ namespace CppSharp.Utils.FSM{
         public readonly List<string> F = new List<string>();
 
         public NDFSM(IEnumerable<string> q, IEnumerable<char> sigma,
-         IEnumerable<Transition> delta, IEnumerable<string> q0, IEnumerable<string> f){
+           IEnumerable<Transition> delta, IEnumerable<string> q0, IEnumerable<string> f)
+        {
             Q = q.ToList();
             Sigma = sigma.ToList();
             AddTransitions(delta);
@@ -19,50 +22,64 @@ namespace CppSharp.Utils.FSM{
             AddFinalStates(f);
         }
 
-      private void AddTransitions(IEnumerable<Transition> transitions){
-         foreach (var transition in transitions.Where(ValidTransition)){
+        private void AddTransitions(IEnumerable<Transition> transitions)
+        {
+            foreach (var transition in transitions.Where(ValidTransition))
+            {
                 Delta.Add(transition);
             }
         }
 
-      private bool ValidTransition(Transition transition){
+        private bool ValidTransition(Transition transition)
+        {
             return Q.Contains(transition.StartState) &&
                    Q.Contains(transition.EndState) &&
                    Sigma.Contains(transition.Symbol);
         }
 
-      private void AddInitialStates(IEnumerable<string> q0){
-         foreach (var startingState in q0.Where(q => q != null && Q.Contains(q))){
+        private void AddInitialStates(IEnumerable<string> q0)
+        {
+            foreach (var startingState in q0.Where(q => q != null && Q.Contains(q)))
+            {
                 Q0.Add(startingState);
             }
         }
 
-      private void AddFinalStates(IEnumerable<string> finalStates){
-         foreach (var finalState in finalStates.Where(finalState => Q.Contains(finalState))){
+        private void AddFinalStates(IEnumerable<string> finalStates)
+        {
+            foreach (var finalState in finalStates.Where(finalState => Q.Contains(finalState)))
+            {
                 F.Add(finalState);
             }
         }
 
-      public void Accepts(string input){
+        public void Accepts(string input)
+        {
             ConsoleWriter.Success("Trying to accept: " + input);
-         if (Q0.Any(q0 => Accepts(q0, input, new StringBuilder()))){
+            if (Q0.Any(q0 => Accepts(q0, input, new StringBuilder())))
+            {
                 return;
             }
             ConsoleWriter.Failure("Could not accept the input: " + input);
         }
 
-      private bool Accepts(string currentState, string input, StringBuilder steps){
-         if (input.Length > 0){
+        private bool Accepts(string currentState, string input, StringBuilder steps)
+        {
+            if (input.Length > 0)
+            {
                 var transitions = GetAllTransitions(currentState, input[0]);
-            foreach (var transition in transitions){
+                foreach (var transition in transitions)
+                {
                     var currentSteps = new StringBuilder(steps.ToString() + transition);
-               if (Accepts(transition.EndState, input.Substring(1), currentSteps)){
+                    if (Accepts(transition.EndState, input.Substring(1), currentSteps))
+                    {
                         return true;
                     }
                 }
                 return false;
             }
-         if (F.Contains(currentState)){
+            if (F.Contains(currentState))
+            {
                 ConsoleWriter.Success("Successfully accepted the input " + input + " " +
                                       "in the final state " + currentState +
                                       " with steps:\n" + steps);
@@ -71,7 +88,8 @@ namespace CppSharp.Utils.FSM{
             return false;
         }
 
-      private IEnumerable<Transition> GetAllTransitions(string currentState, char symbol){
+        private IEnumerable<Transition> GetAllTransitions(string currentState, char symbol)
+        {
             return Delta.FindAll(t => t.StartState == currentState &&
                                       t.Symbol == symbol);
         }

src/Generator/Utils/FSM/Program.cs

@@ -1,8 +1,11 @@
 using System.Collections.Generic;
 
-namespace CppSharp.Utils.FSM{
-   internal class Program{
-      private static void Main(string[] args){
+namespace CppSharp.Utils.FSM
+{
+    internal class Program
+    {
+        private static void Main(string[] args)
+        {
             var Q = new List<string> { "q0", "q1" };
             var Sigma = new List<char> { '0', '1' };
             var Delta = new List<Transition>{

src/Generator/Utils/FSM/Transition.cs

@@ -1,16 +1,20 @@
-namespace CppSharp.Utils.FSM{
-   public class Transition{
+namespace CppSharp.Utils.FSM
+{
+    public class Transition
+    {
         public string StartState { get; private set; }
         public char Symbol { get; private set; }
         public string EndState { get; private set; }
 
-      public Transition(string startState, char symbol, string endState){
+        public Transition(string startState, char symbol, string endState)
+        {
             StartState = startState;
             Symbol = symbol;
             EndState = endState;
         }
 
-      public override string ToString(){
+        public override string ToString()
+        {
             return string.Format("({0}, {1}) -> {2}\n", StartState, Symbol, EndState);
         }
     }

src/Generator/Utils/HtmlEncoder.cs

@@ -63,8 +63,10 @@ namespace System.Web.Util
             StringBuilder output = new StringBuilder();
             int len = s.Length;
 
-			for (int i = 0; i < len; i++) {
-				switch (s [i]) {
+            for (int i = 0; i < len; i++)
+            {
+                switch (s[i])
+                {
                     case '&':
                         output.Append("&amp;");
                         break;
@@ -87,11 +89,13 @@ namespace System.Web.Util
 
                     default:
                         char ch = s[i];
-						if (ch > 159 && ch < 256) {
+                        if (ch > 159 && ch < 256)
+                        {
                             output.Append("&#");
                             output.Append(((int)ch).ToString(CultureInfo.InvariantCulture));
                             output.Append(";");
-						} else
+                        }
+                        else
                             output.Append(ch);
                         break;
                 }
@@ -115,7 +119,8 @@ namespace System.Web.Util
             StringBuilder output = new StringBuilder();
             int len = s.Length;
             for (int i = 0; i < len; i++)
-				switch (s [i]) {
+                switch (s[i])
+                {
                     case '&':
                         output.Append("&amp;");
                         break;
@@ -156,22 +161,29 @@ namespace System.Web.Util
             bool is_hex_value = false;
             bool have_trailing_digits = false;
 
-			for (int i = 0; i < len; i++) {
+            for (int i = 0; i < len; i++)
+            {
                 char c = s[i];
-				if (state == 0) {
-					if (c == '&') {
+                if (state == 0)
+                {
+                    if (c == '&')
+                    {
                         entity.Append(c);
                         rawEntity.Append(c);
                         state = 1;
-					} else {
+                    }
+                    else
+                    {
                         output.Append(c);
                     }
                     continue;
                 }
 
-				if (c == '&') {
+                if (c == '&')
+                {
                     state = 1;
-					if (have_trailing_digits) {
+                    if (have_trailing_digits)
+                    {
                         entity.Append(number.ToString(CultureInfo.InvariantCulture));
                         have_trailing_digits = false;
                     }
@@ -182,22 +194,29 @@ namespace System.Web.Util
                     continue;
                 }
 
-				if (state == 1) {
-					if (c == ';') {
+                if (state == 1)
+                {
+                    if (c == ';')
+                    {
                         state = 0;
                         output.Append(entity);
                         output.Append(c);
                         entity.Length = 0;
-					} else {
+                    }
+                    else
+                    {
                         number = 0;
                         is_hex_value = false;
                         state = c != '#' ? 2 : 3;
                         entity.Append(c);
                         rawEntity.Append(c);
                     }
-				} else if (state == 2) {
+                }
+                else if (state == 2)
+                {
                     entity.Append(c);
-					if (c == ';') {
+                    if (c == ';')
+                    {
                         string key = entity.ToString();
                         if (key.Length > 1 && entities.ContainsKey(key.Substring(1, key.Length - 2)))
                             key = entities[key.Substring(1, key.Length - 2)].ToString();
@@ -207,35 +226,50 @@ namespace System.Web.Util
                         entity.Length = 0;
                         rawEntity.Length = 0;
                     }
-				} else if (state == 3) {
-					if (c == ';') {
+                }
+                else if (state == 3)
+                {
+                    if (c == ';')
+                    {
                         if (number == 0)
                             output.Append(rawEntity + ";");
-						else if (number > 65535) {
+                        else if (number > 65535)
+                        {
                             output.Append("&#");
                             output.Append(number.ToString(CultureInfo.InvariantCulture));
                             output.Append(";");
-						} else {
+                        }
+                        else
+                        {
                             output.Append((char)number);
                         }
                         state = 0;
                         entity.Length = 0;
                         rawEntity.Length = 0;
                         have_trailing_digits = false;
-					} else if (is_hex_value &&  Uri.IsHexDigit(c)) {
+                    }
+                    else if (is_hex_value && Uri.IsHexDigit(c))
+                    {
                         number = number * 16 + Uri.FromHex(c);
                         have_trailing_digits = true;
                         rawEntity.Append(c);
-					} else if (Char.IsDigit (c)) {
+                    }
+                    else if (Char.IsDigit(c))
+                    {
                         number = number * 10 + (c - '0');
                         have_trailing_digits = true;
                         rawEntity.Append(c);
-					} else if (number == 0 && (c == 'x' || c == 'X')) {
+                    }
+                    else if (number == 0 && (c == 'x' || c == 'X'))
+                    {
                         is_hex_value = true;
                         rawEntity.Append(c);
-					} else {
+                    }
+                    else
+                    {
                         state = 2;
-						if (have_trailing_digits) {
+                        if (have_trailing_digits)
+                        {
                             entity.Append(number.ToString(CultureInfo.InvariantCulture));
                             have_trailing_digits = false;
                         }
@@ -244,9 +278,12 @@ namespace System.Web.Util
                 }
             }
 
-			if (entity.Length > 0) {
+            if (entity.Length > 0)
+            {
                 output.Append(entity);
-			} else if (have_trailing_digits) {
+            }
+            else if (have_trailing_digits)
+            {
                 output.Append(number.ToString(CultureInfo.InvariantCulture));
             }
             return output.ToString();

tests/StandardLib/StandardLib.Tests.cs

@@ -57,4 +57,3 @@ public class StandardLibTests
         Assert.AreEqual(testString, stringWriter.ToString());
     }
 }
-