Adjust further code formatting

Laupetin · Nov 19, 2023 · 19ed3e8 · 19ed3e8
1 parent 46e8c58
commit 19ed3e8
Show file tree

Hide file tree

Showing 96 changed files with 4,085 additions and 2,290 deletions.
diff --git a/src/ObjLoading/ObjLoading.cpp b/src/ObjLoading/ObjLoading.cpp
@@ -14,7 +14,13 @@
 
 ObjLoading::Configuration_t ObjLoading::Configuration;
 
-const IObjLoader* const OBJ_LOADERS[]{new IW3::ObjLoader(), new IW4::ObjLoader(), new IW5::ObjLoader(), new T5::ObjLoader(), new T6::ObjLoader()};
+const IObjLoader* const OBJ_LOADERS[]{
+    new IW3::ObjLoader(),
+    new IW4::ObjLoader(),
+    new IW5::ObjLoader(),
+    new T5::ObjLoader(),
+    new T6::ObjLoader(),
+};
 
 void ObjLoading::LoadReferencedContainersForZone(ISearchPath* searchPath, Zone* zone)
 {

diff --git a/src/ObjLoading/Parsing/Menu/Matcher/MenuExpressionMatchers.cpp b/src/ObjLoading/Parsing/Menu/Matcher/MenuExpressionMatchers.cpp
@@ -30,15 +30,22 @@ std::unique_ptr<SimpleExpressionMatchers::matcher_t> MenuExpressionMatchers::Par
 {
     const MenuMatcherFactory create(labelSupplier);
 
-    return create.Or({create
-                          .And({create.Identifier().Capture(CAPTURE_FUNCTION_NAME),
-                                create.Char('('),
-                                create.Optional(create.And({
-                                    create.Label(LABEL_EXPRESSION),
-                                    create.OptionalLoop(create.And({create.Char(','), create.Label(LABEL_EXPRESSION)})),
-                                })),
-                                create.Char(')').Tag(TAG_EXPRESSION_FUNCTION_CALL_END)})
-                          .Tag(TAG_EXPRESSION_FUNCTION_CALL)});
+    return create.Or({
+        create
+            .And({
+                create.Identifier().Capture(CAPTURE_FUNCTION_NAME),
+                create.Char('('),
+                create.Optional(create.And({
+                    create.Label(LABEL_EXPRESSION),
+                    create.OptionalLoop(create.And({
+                        create.Char(','),
+                        create.Label(LABEL_EXPRESSION),
+                    })),
+                })),
+                create.Char(')').Tag(TAG_EXPRESSION_FUNCTION_CALL_END),
+            })
+            .Tag(TAG_EXPRESSION_FUNCTION_CALL),
+    });
 }
 
 const std::map<std::string, size_t>& MenuExpressionMatchers::GetBaseFunctionMapForFeatureLevel(const FeatureLevel featureLevel)

diff --git a/src/ObjLoading/Parsing/Menu/Matcher/MenuMatcherFactory.cpp b/src/ObjLoading/Parsing/Menu/Matcher/MenuMatcherFactory.cpp
@@ -13,57 +13,75 @@ MenuMatcherFactory::MenuMatcherFactory(const IMatcherForLabelSupplier<SimplePars
 
 MatcherFactoryWrapper<SimpleParserValue> MenuMatcherFactory::StringChain() const
 {
-    return Or({And({String(), Loop(String())})
-                   .Transform(
-                       [](const token_list_t& tokens) -> SimpleParserValue
-                       {
-                           std::ostringstream ss;
-
-                           for (const auto& token : tokens)
-                           {
-                               ss << token.get().StringValue();
-                           }
-
-                           return SimpleParserValue::String(tokens[0].get().GetPos(), new std::string(ss.str()));
-                       }),
-               String()});
+    return Or({
+        And({
+                String(),
+                Loop(String()),
+            })
+            .Transform(
+                [](const token_list_t& tokens) -> SimpleParserValue
+                {
+                    std::ostringstream ss;
+
+                    for (const auto& token : tokens)
+                    {
+                        ss << token.get().StringValue();
+                    }
+
+                    return SimpleParserValue::String(tokens[0].get().GetPos(), new std::string(ss.str()));
+                }),
+        String(),
+    });
 }
 
 MatcherFactoryWrapper<SimpleParserValue> MenuMatcherFactory::Text() const
 {
-    return MatcherFactoryWrapper(Or({StringChain(), Identifier()}));
+    return MatcherFactoryWrapper(Or({
+        StringChain(),
+        Identifier(),
+    }));
 }
 
 MatcherFactoryWrapper<SimpleParserValue> MenuMatcherFactory::TextNoChain() const
 {
-    return MatcherFactoryWrapper(Or({String(), Identifier()}));
+    return MatcherFactoryWrapper(Or({
+        String(),
+        Identifier(),
+    }));
 }
 
 MatcherFactoryWrapper<SimpleParserValue> MenuMatcherFactory::Numeric() const
 {
-    return MatcherFactoryWrapper(Or({FloatingPoint(), Integer()}));
+    return MatcherFactoryWrapper(Or({
+        FloatingPoint(),
+        Integer(),
+    }));
 }
 
 MatcherFactoryWrapper<SimpleParserValue> MenuMatcherFactory::IntExpression() const
 {
-    return MatcherFactoryWrapper(Or({Integer().Tag(TAG_INT).Capture(CAPTURE_INT),
-                                     And({
-                                             Char('(').Capture(CAPTURE_FIRST_TOKEN),
-                                             Label(MenuExpressionMatchers::LABEL_EXPRESSION),
-                                             Char(')'),
-                                         })
-                                         .Tag(TAG_EXPRESSION)}));
+    return MatcherFactoryWrapper(Or({
+        Integer().Tag(TAG_INT).Capture(CAPTURE_INT),
+        And({
+                Char('(').Capture(CAPTURE_FIRST_TOKEN),
+                Label(MenuExpressionMatchers::LABEL_EXPRESSION),
+                Char(')'),
+            })
+            .Tag(TAG_EXPRESSION),
+    }));
 }
 
 MatcherFactoryWrapper<SimpleParserValue> MenuMatcherFactory::NumericExpression() const
 {
-    return MatcherFactoryWrapper(Or({Numeric().Tag(TAG_NUMERIC).Capture(CAPTURE_NUMERIC),
-                                     And({
-                                             Char('(').Capture(CAPTURE_FIRST_TOKEN),
-                                             Label(MenuExpressionMatchers::LABEL_EXPRESSION),
-                                             Char(')'),
-                                         })
-                                         .Tag(TAG_EXPRESSION)}));
+    return MatcherFactoryWrapper(Or({
+        Numeric().Tag(TAG_NUMERIC).Capture(CAPTURE_NUMERIC),
+        And({
+                Char('(').Capture(CAPTURE_FIRST_TOKEN),
+                Label(MenuExpressionMatchers::LABEL_EXPRESSION),
+                Char(')'),
+            })
+            .Tag(TAG_EXPRESSION),
+    }));
 }
 
 int MenuMatcherFactory::TokenNumericIntValue(const SimpleParserValue& value)