Move name mapping from compile time to runtime

format.cc

@@ -686,6 +686,20 @@ void fmt::BasicWriter<Char>::write_str(
   write_str(str_value, str_size, spec);
 }
 
+template <typename Char>
+inline Arg fmt::BasicFormatter<Char>::get_arg(
+  const BasicStringRef<Char>& arg_name, const char *&error) {
+  if (check_no_auto_index(error)) {
+    next_arg_index_ = -1;
+    map_.init(args_);
+    const Arg* arg = map_.find(arg_name);
+    if (arg)
+      return *arg;
+    error = "argument not found";
+  }
+  return Arg();
+}
+
 template <typename Char>
 inline Arg fmt::BasicFormatter<Char>::parse_arg_index(const Char *&s) {
   const char *error = 0;
@@ -716,8 +730,13 @@ inline Arg fmt::BasicFormatter<Char>::parse_arg_name(const Char *&s) {
 FMT_FUNC Arg fmt::internal::FormatterBase::do_get_arg(
     unsigned arg_index, const char *&error) {
   Arg arg = args_[arg_index];
-  if (arg.type == Arg::NONE)
+  switch (arg.type) {
+  case Arg::NONE:
     error = "argument index out of range";
+    break;
+  case Arg::NAMED_ARG:
+    arg = *static_cast<const internal::Arg*>(arg.pointer);
+  }
   return arg;
 }
 
@@ -728,25 +747,20 @@ inline Arg fmt::internal::FormatterBase::next_arg(const char *&error) {
   return Arg();
 }
 
+inline bool fmt::internal::FormatterBase::check_no_auto_index(const char *&error) {
+  if (next_arg_index_ > 0) {
+    error = "cannot switch from automatic to manual argument indexing";
+    return false;
+  }
+  return true;
+}
+
 inline Arg fmt::internal::FormatterBase::get_arg(
     unsigned arg_index, const char *&error) {
-  if (next_arg_index_ <= 0) {
+  if (check_no_auto_index(error)) {
     next_arg_index_ = -1;
     return do_get_arg(arg_index, error);
   }
-  error = "cannot switch from automatic to manual argument indexing";
-  return Arg();
-}
-
-template <typename Char>
-inline Arg fmt::internal::FormatterBase::get_arg(
-  const BasicStringRef<Char>& arg_name, const char *&error) {
-  const BasicArgMap<Char>* map = args_.get_arg_map<Char>();
-  assert(map);
-  const unsigned* index = map->find(arg_name);
-  if (index)
-    return get_arg(*index, error);
-  error = "argument not found";
   return Arg();
 }
 

format.h

@@ -39,6 +39,7 @@
 #include <stdexcept>
 #include <string>
 #include <sstream>
+#include <map>
 
 #if _SECURE_SCL
 # include <iterator>
@@ -227,11 +228,6 @@ class BasicStringRef {
   std::size_t size_;
 
  public:
-  /**
-    Constructs an empty string reference object.
-   */
-   BasicStringRef() : data_(), size_() {}
-
   /**
     Constructs a string reference object from a C string and a size.
    */
@@ -758,7 +754,7 @@ struct Value {
   };
 
   enum Type {
-    NONE,
+    NONE, NAMED_ARG,
     // Integer types should go first,
     INT, UINT, LONG_LONG, ULONG_LONG, CHAR, LAST_INTEGER_TYPE = CHAR,
     // followed by floating-point types.
@@ -767,25 +763,15 @@ struct Value {
   };
 };
 
-template <typename Char, typename T>
-struct NamedArg {
-  BasicStringRef<Char> name;
-  T const& arg;
-
-  NamedArg(BasicStringRef<Char> name, T const& arg) : name(name), arg(arg) {}
-
-private:
-
-  // Suppress MSVC warning : assignment operator could not be generated
-  NamedArg& operator=(const NamedArg&);
-};
-
 // A formatting argument. It is a POD type to allow storage in
 // internal::MemoryBuffer.
 struct Arg : Value {
   Type type;
 };
 
+template <typename Char>
+struct NamedArg;
+
 template <typename T = void>
 struct None {};
 
@@ -981,17 +967,24 @@ class MakeValue : public Arg {
   static uint64_t type(const T &) {
     return IsConvertibleToInt<T>::value ? Arg::INT : Arg::CUSTOM;
   }
+
+  template <typename Char_>
+  MakeValue(const NamedArg<Char_> &value) { pointer = &value; }
+
+  template <typename Char_>
+  static uint64_t type(const NamedArg<Char_> &) { return Arg::NAMED_ARG; }
 };
 
-template <typename T>
+template <typename Char>
-inline const T &strip_name(const T &arg) {
+struct NamedArg : Arg {
-  return arg;
+  BasicStringRef<Char> name;
-}
 
-template <typename Char, typename T>
+  template <typename T>
-inline const T &strip_name(const NamedArg<Char, T> &namedArg) {
+  NamedArg(BasicStringRef<Char> name, const T &value)
-  return namedArg.arg;
+  : name(name), Arg(MakeValue<Char>(value)) {
-}
+    type = static_cast<internal::Arg::Type>(MakeValue<Char>::type(value));
+  }
+};
 
 #define FMT_DISPATCH(call) static_cast<Impl*>(this)->call
 
@@ -1112,45 +1105,6 @@ class RuntimeError : public std::runtime_error {
 
 template <typename Char>
 class ArgFormatter;
-
-template <typename Char>
-struct BasicArgMap {
-  typedef std::pair<BasicStringRef<Char>, unsigned> value_type;
-
-  struct Compare {
-    bool operator()(const value_type &lhs, const value_type &rhs) const {
-      return lhs.first < rhs.first;
-    }
-  };
-
-  BasicArgMap() : map_(), size_() {}
-
-  BasicArgMap(value_type* map, unsigned size)
-  : map_(map), size_(size) {
-    std::sort(map, map + size, Compare());
-  }
-
-  const unsigned* find(BasicStringRef<Char> name) const {
-    value_type* first = map_;
-    value_type* last = map_ + size_;
-    while (first != last)
-    {
-      value_type* it(first + ((last - first) >> 1));
-      if (name < it->first)
-        last = it;
-      else if (it->first < name)
-        first = ++it;
-      else
-        return &it->second;
-    }
-    return 0;
-  }
-
-private:
-
-  value_type* map_;
-  unsigned size_;
-};
 }  // namespace internal
 
 /** An argument list. */
@@ -1168,7 +1122,6 @@ class ArgList {
     const internal::Value *values_;
     const internal::Arg *args_;
   };
-  const void* map_;
 
   internal::Arg::Type type(unsigned index) const {
     unsigned shift = index * 4;
@@ -1181,15 +1134,15 @@ class ArgList {
   // Maximum number of arguments with packed types.
   enum { MAX_PACKED_ARGS = 16 };
 
-  ArgList() : types_(0), map_() {}
-
   template <typename Char>
-  ArgList(ULongLong types, const internal::Value *values, const internal::BasicArgMap<Char>* map)
+  struct Map;
-  : types_(types), values_(values), map_(map) {}
 
-  template <typename Char>
+  ArgList() : types_(0) {}
-  ArgList(ULongLong types, const internal::Arg *args, const internal::BasicArgMap<Char>* map)
+
-  : types_(types), args_(args), map_(map) {}
+  ArgList(ULongLong types, const internal::Value *values)
+  : types_(types), values_(values) {}
+  ArgList(ULongLong types, const internal::Arg *args)
+  : types_(types), args_(args) {}
 
   /** Returns the argument at specified index. */
   internal::Arg operator[](unsigned index) const {
@@ -1216,11 +1169,62 @@ class ArgList {
     }
     return args_[index];
   }
+};
 
-  template <typename Char>
+template <typename Char>
-  const internal::BasicArgMap<Char>* get_arg_map() const {
+struct fmt::ArgList::Map {
-    return static_cast<const internal::BasicArgMap<Char>*>(map_);
+  typedef std::map<fmt::BasicStringRef<Char>, internal::Arg> MapType;
+  typedef typename MapType::value_type Pair;
+
+  void init(const ArgList &args) {
+    if (!map_.empty())
+      return;
+    bool use_values = args.type(MAX_PACKED_ARGS - 1) == internal::Arg::NONE;
+    if (use_values) {
+      add_packed(args, args.values_);
+      return;
+    }
+    add_packed(args, args.args_);
+    const internal::NamedArg<Char>* named_arg;
+    for (unsigned i = MAX_PACKED_ARGS; ; ++i) {
+      switch (args.args_[i].type) {
+      case internal::Arg::NONE:
+        return;
+      case internal::Arg::NAMED_ARG:
+        named_arg = static_cast<const internal::NamedArg<Char>*>(args.args_[i].pointer);
+        map_.insert(Pair(named_arg->name, *named_arg));
+        break;
+      }
+    }
   }
+
+  const internal::Arg* find(const fmt::BasicStringRef<Char> &name) const
+  {
+      typename MapType::const_iterator it = map_.find(name);
+      if (it != map_.end())
+          return &it->second;
+      return 0;
+  }
+
+private:
+
+  template <typename T>
+  void add_packed(const ArgList &args, const T* data) {
+    const internal::NamedArg<Char>* named_arg;
+    for (unsigned i = 0; i != MAX_PACKED_ARGS; ++i) {
+      internal::Arg::Type arg_type = args.type(i);
+      switch (arg_type) {
+      case internal::Arg::NONE:
+        return;
+      case internal::Arg::NAMED_ARG:
+        named_arg = static_cast<const internal::NamedArg<Char>*>(data[i].pointer);
+        map_.insert(Pair(named_arg->name, *named_arg));
+        break;
+      }
+    }
+  }
+
+  MapType map_;
 };
 
 struct FormatSpec;
@@ -1228,7 +1232,7 @@ struct FormatSpec;
 namespace internal {
 
 class FormatterBase {
- private:
+ protected:
   ArgList args_;
   int next_arg_index_;
 
@@ -1248,10 +1252,7 @@ class FormatterBase {
   // specified index.
   Arg get_arg(unsigned arg_index, const char *&error);
 
-  // Checks if manual indexing is used and returns the argument with
+  bool check_no_auto_index(const char *&error);
-  // specified name.
-  template <typename Char>
-  Arg get_arg(const BasicStringRef<Char>& arg_name, const char *&error);
 
   template <typename Char>
   void write(BasicWriter<Char> &w, const Char *start, const Char *end) {
@@ -1286,9 +1287,16 @@ class BasicFormatter : private internal::FormatterBase {
  private:
   BasicWriter<Char> &writer_;
   const Char *start_;
+  ArgList::Map<Char> map_;
   
   FMT_DISALLOW_COPY_AND_ASSIGN(BasicFormatter);
 
+  using FormatterBase::get_arg;
+
+  // Checks if manual indexing is used and returns the argument with
+  // specified name.
+  internal::Arg get_arg(const BasicStringRef<Char>& arg_name, const char *&error);
+
   // Parses argument index and returns corresponding argument.
   internal::Arg parse_arg_index(const Char *&s);
 
@@ -1563,14 +1571,6 @@ struct ArgArray {
     (N < ArgList::MAX_PACKED_ARGS), Value, Arg>::type Type[SIZE];
 };
 
-template <typename NameIndexPair, typename T>
-inline void add_named_arg(NameIndexPair*, const T &, unsigned) {}
-
-template <typename NameIndexPair, typename Char, typename T>
-inline void add_named_arg(NameIndexPair*& map, const NamedArg<Char, T> &namedArg, unsigned n) {
-  *map++ = NameIndexPair(namedArg.name, n);
-}
-
 #if FMT_USE_VARIADIC_TEMPLATES
 template <typename Arg, typename... Args>
 inline uint64_t make_type(const Arg &first, const Args & ... tail) {
@@ -1611,36 +1611,12 @@ inline void store_args(Arg *args, const T &arg, const Args & ... tail) {
 
 template <typename Char, typename... Args>
 ArgList make_arg_list(typename ArgArray<sizeof...(Args)>::Type array,
-                      const BasicArgMap<Char>* map,
                       const Args & ... args) {
   if (check(sizeof...(Args) >= ArgList::MAX_PACKED_ARGS))
     set_types(array, args...);
   store_args<Char>(array, args...);
-  return ArgList(make_type(args...), array, map);
+  return ArgList(make_type(args...), array);
 }
-
-template <typename... T>
-struct NamedArgsCounter {
-  static const int value = 0;
-};
-
-template <typename T, typename... U>
-struct NamedArgsCounter<T, U...> : NamedArgsCounter<U...> {};
-
-template <typename Char, typename T, typename... U>
-struct NamedArgsCounter<NamedArg<Char, T>, U...> {
-  static const int value = 1 + NamedArgsCounter<U...>::value;
-};
-
-template <unsigned N, typename NameIndexPair>
-inline void add_named_args(NameIndexPair*) {}
-
-template <unsigned N, typename NameIndexPair, typename T, typename... U>
-inline void add_named_args(NameIndexPair* map, const T &arg, const U &... rest) {
-  add_named_arg(map, arg, N);
-  add_named_args<N + 1>(map, rest...);
-}
-
 #else
 
 struct ArgType {
@@ -1666,6 +1642,8 @@ inline uint64_t make_type(FMT_GEN15(FMT_ARG_TYPE_DEFAULT)) {
 # define FMT_MAKE_TEMPLATE_ARG(n) typename T##n
 # define FMT_MAKE_ARG_TYPE(n) T##n
 # define FMT_MAKE_ARG(n) const T##n &v##n
+# define FMT_MAKE_REF_char(n) fmt::internal::MakeValue<char>(v##n)
+# define FMT_MAKE_REF_wchar_t(n) fmt::internal::MakeValue<wchar_t>(v##n)
 
 #if FMT_USE_VARIADIC_TEMPLATES
 // Defines a variadic function returning void.
@@ -1673,11 +1651,7 @@ inline uint64_t make_type(FMT_GEN15(FMT_ARG_TYPE_DEFAULT)) {
   template <typename... Args> \
   void func(arg_type arg0, const Args & ... args) { \
     typename fmt::internal::ArgArray<sizeof...(Args)>::Type array; \
-    const int count = fmt::internal::NamedArgsCounter<Args...>::value; \
+    func(arg0, fmt::internal::make_arg_list<Char>(array, args...)); \
-    typename fmt::internal::BasicArgMap<Char>::value_type mapArray[count + 1]; \
-    fmt::internal::add_named_args<0>(mapArray, args...); \
-    fmt::internal::BasicArgMap<Char> map(mapArray, count); \
-    func(arg0, fmt::internal::make_arg_list<Char>(array, &map, fmt::internal::strip_name(args)...)); \
   }
 
 // Defines a variadic constructor.
@@ -1685,32 +1659,22 @@ inline uint64_t make_type(FMT_GEN15(FMT_ARG_TYPE_DEFAULT)) {
   template <typename... Args> \
   ctor(arg0_type arg0, arg1_type arg1, const Args & ... args) { \
     typename fmt::internal::ArgArray<sizeof...(Args)>::Type array; \
-    const int count = fmt::internal::NamedArgsCounter<Args...>::value; \
+    func(arg0, arg1, fmt::internal::make_arg_list<Char>(array, args...)); \
-    typename fmt::internal::BasicArgMap<Char>::value_type mapArray[count + 1]; \
-    fmt::internal::add_named_args<0>(mapArray, args...); \
-    fmt::internal::BasicArgMap<Char> map(mapArray, count); \
-    func(arg0, arg1, fmt::internal::make_arg_list<Char>(array, &map, fmt::internal::strip_name(args)...)); \
   }
 
 #else
 
-# define FMT_MAKE_REF(n) fmt::internal::MakeValue<Char>(fmt::internal::strip_name(v##n))
+# define FMT_MAKE_REF(n) fmt::internal::MakeValue<Char>(v##n)
-# define FMT_MAKE_REF2(n) fmt::internal::strip_name(v##n)
+# define FMT_MAKE_REF2(n) v##n
-# define FMT_ADD_NAMED_ARG(n) fmt::internal::add_named_arg(mapPtr, v##n, n)
 
 // Defines a wrapper for a function taking one argument of type arg_type
 // and n additional arguments of arbitrary types.
 # define FMT_WRAP1(func, arg_type, n) \
   template <FMT_GEN(n, FMT_MAKE_TEMPLATE_ARG)> \
   inline void func(arg_type arg1, FMT_GEN(n, FMT_MAKE_ARG)) { \
-    typedef typename fmt::internal::BasicArgMap<Char>::value_type ArgMapValue; \
     const fmt::internal::ArgArray<n>::Type array = {FMT_GEN(n, FMT_MAKE_REF)}; \
-    ArgMapValue mapArray[n]; \
-    ArgMapValue* mapPtr = mapArray; \
-    FMT_GEN(n, FMT_ADD_NAMED_ARG); \
-    fmt::internal::BasicArgMap<Char> map(mapArray, unsigned(mapPtr - mapArray)); \
     func(arg1, fmt::ArgList( \
-      fmt::internal::make_type(FMT_GEN(n, FMT_MAKE_REF2)), array, &map)); \
+      fmt::internal::make_type(FMT_GEN(n, FMT_MAKE_REF2)), array)); \
   }
 
 // Emulates a variadic function returning void on a pre-C++11 compiler.
@@ -1725,14 +1689,9 @@ inline uint64_t make_type(FMT_GEN15(FMT_ARG_TYPE_DEFAULT)) {
 # define FMT_CTOR(ctor, func, arg0_type, arg1_type, n) \
   template <FMT_GEN(n, FMT_MAKE_TEMPLATE_ARG)> \
   ctor(arg0_type arg0, arg1_type arg1, FMT_GEN(n, FMT_MAKE_ARG)) { \
-    typedef typename fmt::internal::BasicArgMap<Char>::value_type ArgMapValue; \
     const fmt::internal::ArgArray<n>::Type array = {FMT_GEN(n, FMT_MAKE_REF)}; \
-    ArgMapValue mapArray[n]; \
-    ArgMapValue* mapPtr = mapArray; \
-    FMT_GEN(n, FMT_ADD_NAMED_ARG); \
-    fmt::internal::BasicArgMap<Char> map(mapArray, unsigned(mapPtr - mapArray)); \
     func(arg0, arg1, fmt::ArgList( \
-      fmt::internal::make_type(FMT_GEN(n, FMT_MAKE_REF2)), array, &map)); \
+      fmt::internal::make_type(FMT_GEN(n, FMT_MAKE_REF2)), array)); \
   }
 
 // Emulates a variadic constructor on a pre-C++11 compiler.
@@ -2804,7 +2763,6 @@ inline void format_decimal(char *&buffer, T value) {
   buffer += num_digits;
 }
 
-
 /**
   \rst
   Returns a named argument for formatting functions.
@@ -2816,13 +2774,13 @@ inline void format_decimal(char *&buffer, T value) {
   \endrst
  */
 template <typename T>
-inline internal::NamedArg<char, T> arg(StringRef name, const T &arg) {
+inline internal::NamedArg<char> arg(StringRef name, const T &arg) {
-  return internal::NamedArg<char, T>(name, arg);
+  return internal::NamedArg<char>(name, arg);
 }
 
 template <typename T>
-inline internal::NamedArg<wchar_t, T> arg(WStringRef name, const T &arg) {
+inline internal::NamedArg<wchar_t> arg(WStringRef name, const T &arg) {
-  return internal::NamedArg<wchar_t, T>(name, arg);
+  return internal::NamedArg<wchar_t>(name, arg);
 }
 }
 
@@ -2859,29 +2817,19 @@ inline internal::NamedArg<wchar_t, T> arg(WStringRef name, const T &arg) {
   ReturnType func(FMT_FOR_EACH(FMT_ADD_ARG_NAME, __VA_ARGS__), \
       const Args & ... args) { \
     typename fmt::internal::ArgArray<sizeof...(Args)>::Type array; \
-    const int count = fmt::internal::NamedArgsCounter<Args...>::value; \
-    fmt::internal::BasicArgMap<Char>::value_type mapArray[count + 1]; \
-    fmt::internal::add_named_args<0>(mapArray, args...); \
-    fmt::internal::BasicArgMap<Char> map(mapArray, count); \
     call(FMT_FOR_EACH(FMT_GET_ARG_NAME, __VA_ARGS__), \
-      fmt::internal::make_arg_list<Char>(array, &map, fmt::internal::strip_name(args)...)); \
+      fmt::internal::make_arg_list<Char>(array, args...)); \
   }
 #else
 // Defines a wrapper for a function taking __VA_ARGS__ arguments
 // and n additional arguments of arbitrary types.
-# define FMT_WRAP(Char_, ReturnType, func, call, n, ...) \
+# define FMT_WRAP(Char, ReturnType, func, call, n, ...) \
   template <FMT_GEN(n, FMT_MAKE_TEMPLATE_ARG)> \
   inline ReturnType func(FMT_FOR_EACH(FMT_ADD_ARG_NAME, __VA_ARGS__), \
       FMT_GEN(n, FMT_MAKE_ARG)) { \
-    typedef Char_ Char; \
+    fmt::internal::ArgArray<n>::Type arr = {FMT_GEN(n, FMT_MAKE_REF_##Char)}; \
-    typedef fmt::internal::BasicArgMap<Char>::value_type ArgMapValue; \
-    fmt::internal::ArgArray<n>::Type arr = {FMT_GEN(n, FMT_MAKE_REF)}; \
-    ArgMapValue mapArray[n]; \
-    ArgMapValue* mapPtr = mapArray; \
-    FMT_GEN(n, FMT_ADD_NAMED_ARG); \
-    fmt::internal::BasicArgMap<Char> map(mapArray, unsigned(mapPtr - mapArray)); \
     call(FMT_FOR_EACH(FMT_GET_ARG_NAME, __VA_ARGS__), fmt::ArgList( \
-      fmt::internal::make_type(FMT_GEN(n, FMT_MAKE_REF2)), arr, &map)); \
+      fmt::internal::make_type(FMT_GEN(n, FMT_MAKE_REF2)), arr)); \
   }
 
 # define FMT_VARIADIC_(Char, ReturnType, func, call, ...) \