Workaround for GCC bug 61321

[icinga2] / lib / icinga / macroprocessor.cpp

diff --git a/lib/icinga/macroprocessor.cpp b/lib/icinga/macroprocessor.cpp
index 37d5d48cc77e76e0c0d836f401411eedb73b62d2..9789313f7601dceefa437105e2623041b5e94a24 100644 (file)
--- a/lib/icinga/macroprocessor.cpp
+++ b/lib/icinga/macroprocessor.cpp
@@ -28,7 +28,6 @@
 #include "base/scriptframe.hpp"
 #include "base/convert.hpp"
 #include "base/exception.hpp"
-#include <boost/assign.hpp>
 #include <boost/algorithm/string/split.hpp>
 #include <boost/algorithm/string/join.hpp>
 #include <boost/algorithm/string/classification.hpp>
@@ -181,30 +180,6 @@ bool MacroProcessor::ResolveMacro(const String& macro, const ResolverList& resol
        return false;
 }
 
-Value MacroProcessor::InternalResolveMacrosShim(const std::vector<Value>& args, const ResolverList& resolvers,
-    const CheckResult::Ptr& cr, const MacroProcessor::EscapeCallback& escapeFn, const Dictionary::Ptr& resolvedMacros,
-    bool useResolvedMacros, int recursionLevel)
-{
-       if (args.size() < 1)
-               BOOST_THROW_EXCEPTION(std::invalid_argument("Too few arguments for function"));
-
-       String missingMacro;
-
-       return MacroProcessor::InternalResolveMacros(args[0], resolvers, cr, &missingMacro, escapeFn,
-           resolvedMacros, useResolvedMacros, recursionLevel);
-}
-
-Value MacroProcessor::InternalResolveArgumentsShim(const std::vector<Value>& args, const ResolverList& resolvers,
-    const CheckResult::Ptr& cr, const Dictionary::Ptr& resolvedMacros,
-    bool useResolvedMacros, int recursionLevel)
-{
-       if (args.size() < 2)
-               BOOST_THROW_EXCEPTION(std::invalid_argument("Too few arguments for function"));
-
-       return MacroProcessor::ResolveArguments(args[0], args[1], resolvers, cr,
-           resolvedMacros, useResolvedMacros, recursionLevel);
-}
-
 Value MacroProcessor::EvaluateFunction(const Function::Ptr& func, const ResolverList& resolvers,
     const CheckResult::Ptr& cr, const MacroProcessor::EscapeCallback& escapeFn,
     const Dictionary::Ptr& resolvedMacros, bool useResolvedMacros, int recursionLevel)
@@ -215,15 +190,29 @@ Value MacroProcessor::EvaluateFunction(const Function::Ptr& func, const Resolver
                resolvers_this->Set(resolver.first, resolver.second);
        }
 
-       resolvers_this->Set("macro", new Function("macro (temporary)", boost::bind(&MacroProcessor::InternalResolveMacrosShim,
-           _1, boost::cref(resolvers), cr, MacroProcessor::EscapeCallback(), resolvedMacros, useResolvedMacros,
-           recursionLevel + 1)));
-       resolvers_this->Set("resolve_arguments", new Function("resolve_arguments (temporary)", boost::bind(&MacroProcessor::InternalResolveArgumentsShim,
-           _1, boost::cref(resolvers), cr, resolvedMacros, useResolvedMacros,
-           recursionLevel + 1)));
+       auto internalResolveMacrosShim = [resolvers, cr, resolvedMacros, useResolvedMacros, recursionLevel](const std::vector<Value>& args) {
+               if (args.size() < 1)
+                       BOOST_THROW_EXCEPTION(std::invalid_argument("Too few arguments for function"));
+
+               String missingMacro;
+
+               return MacroProcessor::InternalResolveMacros(args[0], resolvers, cr, &missingMacro, MacroProcessor::EscapeCallback(),
+                   resolvedMacros, useResolvedMacros, recursionLevel);
+       };
+
+       resolvers_this->Set("macro", new Function("macro (temporary)", internalResolveMacrosShim, { "str" }));
+
+       auto internalResolveArgumentsShim = [resolvers, cr, resolvedMacros, useResolvedMacros, recursionLevel](const std::vector<Value>& args) {
+               if (args.size() < 2)
+                       BOOST_THROW_EXCEPTION(std::invalid_argument("Too few arguments for function"));
+
+               return MacroProcessor::ResolveArguments(args[0], args[1], resolvers, cr,
+                   resolvedMacros, useResolvedMacros, recursionLevel + 1);
+       };
+
+       resolvers_this->Set("resolve_arguments", new Function("resolve_arguments (temporary)", internalResolveArgumentsShim, { "command", "args" }));
 
-       std::vector<Value> args;
-       return func->Invoke(resolvers_this, args);
+       return func->InvokeThis(resolvers_this);
 }
 
 Value MacroProcessor::InternalResolveMacros(const String& str, const ResolverList& resolvers,
@@ -292,7 +281,7 @@ Value MacroProcessor::InternalResolveMacros(const String& str, const ResolverLis
                                for (const Value& value : arr) {
                                        if (value.IsScalar()) {
                                                resolved_arr->Add(InternalResolveMacros(value,
-                                                       resolvers, cr, missingMacro, EscapeCallback(), Dictionary::Ptr(),
+                                                       resolvers, cr, missingMacro, EscapeCallback(), nullptr,
                                                        false, recursionLevel + 1));
                                        } else
                                                resolved_arr->Add(value);
@@ -301,7 +290,7 @@ Value MacroProcessor::InternalResolveMacros(const String& str, const ResolverLis
                                resolved_macro = resolved_arr;
                        } else if (resolved_macro.IsString()) {
                                resolved_macro = InternalResolveMacros(resolved_macro,
-                                       resolvers, cr, missingMacro, EscapeCallback(), Dictionary::Ptr(),
+                                       resolvers, cr, missingMacro, EscapeCallback(), nullptr,
                                        false, recursionLevel + 1);
                        }
                }
@@ -376,7 +365,7 @@ void MacroProcessor::ValidateCustomVars(const ConfigObject::Ptr& object, const D
                                        continue;
 
                                if (!ValidateMacroString(kv_var.second))
-                                       BOOST_THROW_EXCEPTION(ValidationError(object.get(), boost::assign::list_of<String>("vars")(kv.first)(kv_var.first), "Closing $ not found in macro format string '" + kv_var.second + "'."));
+                                       BOOST_THROW_EXCEPTION(ValidationError(object.get(), { "vars", kv.first, kv_var.first }, "Closing $ not found in macro format string '" + kv_var.second + "'."));
                        }
                } else if (varval.IsObjectType<Array>()) {
                        /* check all array entries */
@@ -388,7 +377,7 @@ void MacroProcessor::ValidateCustomVars(const ConfigObject::Ptr& object, const D
                                        continue;
 
                                if (!ValidateMacroString(arrval)) {
-                                       BOOST_THROW_EXCEPTION(ValidationError(object.get(), boost::assign::list_of<String>("vars")(kv.first), "Closing $ not found in macro format string '" + arrval + "'."));
+                                       BOOST_THROW_EXCEPTION(ValidationError(object.get(), { "vars", kv.first }, "Closing $ not found in macro format string '" + arrval + "'."));
                                }
                        }
                } else {
@@ -396,7 +385,7 @@ void MacroProcessor::ValidateCustomVars(const ConfigObject::Ptr& object, const D
                                continue;
 
                        if (!ValidateMacroString(varval))
-                               BOOST_THROW_EXCEPTION(ValidationError(object.get(), boost::assign::list_of<String>("vars")(kv.first), "Closing $ not found in macro format string '" + varval + "'."));
+                               BOOST_THROW_EXCEPTION(ValidationError(object.get(), { "vars", kv.first }, "Closing $ not found in macro format string '" + varval + "'."));
                }
        }
 }
@@ -456,7 +445,7 @@ Value MacroProcessor::ResolveArguments(const Value& command, const Dictionary::P
 {
        Value resolvedCommand;
        if (!arguments || command.IsObjectType<Array>() || command.IsObjectType<Function>())
-               resolvedCommand = MacroProcessor::ResolveMacros(command, resolvers, cr, NULL,
+               resolvedCommand = MacroProcessor::ResolveMacros(command, resolvers, cr, nullptr,
                    EscapeMacroShellArg, resolvedMacros, useResolvedMacros, recursionLevel + 1);
        else {
                Array::Ptr arr = new Array();
@@ -542,7 +531,7 @@ Value MacroProcessor::ResolveArguments(const Value& command, const Dictionary::P
                                continue;
                        }
 
-                       args.push_back(arg);
+                       args.emplace_back(std::move(arg));
                }
 
                std::sort(args.begin(), args.end());