Fix error that exceed Clang's default -fconstexpr-steps value

runtime/NanoLogCpp17.h

@@ -17,10 +17,12 @@
 
 #include <cstdint>
 #include <cstring>
+#include <cstddef>
 
 #include <algorithm>
 #include <iostream>
 #include <utility>
+#include <array>
 
 #include "Common.h"
 #include "Cycles.h"
@@ -43,6 +45,21 @@
  */
 namespace NanoLogInternal {
 
+/**
+ * A struct that contains a list of ParamType enum alongside with its actual
+ * size. Mainly used as return type of getParamInfos to store the ParamType
+ * extracted from format string.
+ *
+ * \tparam N
+ *      The maximum number of elements avaliable in this struct.
+ */
+
+ template <std::size_t N>
+ struct ParamTypeContainer{
+     std::array<ParamType, N> data;
+     std::size_t size;
+ };
+
 /**
  * Checks whether a character is with the terminal set of format specifier
  * characters according to the printf specification:
@@ -116,26 +133,29 @@ isDigit(char c) {
 
 /**
  * Analyzes a static printf style format string and extracts type information
- * about the p-th parameter that would be used in a corresponding NANO_LOG()
+ * about all of the parameters that would be used in a corresponding NANO_LOG()
  * invocation.
  *
  * \tparam N
  *      Length of the static format string (automatically deduced)
  * \param fmt
  *      Format string to parse
- * \param paramNum
- *      p-th parameter to return type information for (starts from zero)
  * \return
- *      Returns an ParamType enum describing the type of the parameter
+ *      Returns a ParamTypeContainer<N> struct that contains all ParamType info
+ *      in order. Note: The maximum avaliable size template parameter N is set
+ *      with the fact that, the number of parameters in the format string shall
+ *      be less than the length of that string. And exceeding the maximum size
+ *      limit in core constant expression anyways will cause the program to be
+ *      ill-formed.
  */
-template<int N>
-constexpr inline ParamType
-getParamInfo(const char (&fmt)[N],
-             int paramNum=0)
+template <std::size_t N>
+constexpr inline ParamTypeContainer<N>
+getParamInfos(const char (&fmt)[N])
 {
-    int pos = 0;
-    while (pos < N - 1) {
-
+    ParamTypeContainer<N> paramTypes = {};
+    std::size_t pos = 0;
+    std::size_t paramIdx = 0;
+    while (pos + 1 < N) {
         // The code below searches for something that looks like a printf
         // specifier (i.e. something that follows the format of
         // %<flags><width>.<precision><length><terminal>). We only care
@@ -163,10 +183,9 @@ getParamInfo(const char (&fmt)[N],
 
                 // Consume width
                 if (fmt[pos] == '*') {
-                    if (paramNum == 0)
-                        return ParamType::DYNAMIC_WIDTH;
+                    paramTypes.data[paramIdx] = ParamType::DYNAMIC_WIDTH;
 
-                    --paramNum;
+                    ++paramIdx;
                     ++pos;
                 } else {
                     while (NanoLogInternal::isDigit(fmt[pos]))
@@ -180,11 +199,11 @@ getParamInfo(const char (&fmt)[N],
                     ++pos;  // consume '.'
 
                     if (fmt[pos] == '*') {
-                        if (paramNum == 0)
-                            return ParamType::DYNAMIC_PRECISION;
+                        paramTypes.data[paramIdx] =
+                                ParamType::DYNAMIC_PRECISION;
 
                         hasDynamicPrecision = true;
-                        --paramNum;
+                        ++paramIdx;
                         ++pos;
                     } else {
                         precision = 0;
@@ -212,128 +231,90 @@ getParamInfo(const char (&fmt)[N],
                             "%n specifiers are not support in NanoLog!");
                 }
 
-                if (paramNum != 0) {
-                    --paramNum;
-                    ++pos;
-                    continue;
+                if (fmt[pos] != 's'){
+                    paramTypes.data[paramIdx] = ParamType::NON_STRING;
+                    ++paramIdx;
+                } else if (hasDynamicPrecision) {
+                    paramTypes.data[paramIdx] =
+                            ParamType::STRING_WITH_DYNAMIC_PRECISION;
+                    ++paramIdx;
+                } else if (precision == -1) {
+                    paramTypes.data[paramIdx] =
+                            ParamType::STRING_WITH_NO_PRECISION;
+                    ++paramIdx;
                 } else {
-                    if (fmt[pos] != 's')
-                        return ParamType::NON_STRING;
-
-                    if (hasDynamicPrecision)
-                        return ParamType::STRING_WITH_DYNAMIC_PRECISION;
-
-                    if (precision == -1)
-                        return ParamType::STRING_WITH_NO_PRECISION;
-                    else
-                        return ParamType(precision);
+                    paramTypes.data[paramIdx] = ParamType(precision);
+                    ++paramIdx;
                 }
             }
         }
     }
 
-    return ParamType::INVALID;
-}
-
-
-/**
- * Helper to analyzeFormatString. This level of indirection is needed to
- * unpack the index_sequence generated in analyzeFormatString and
- * use the sequence as indices for calling getParamInfo.
- *
- * \tparam N
- *      Length of the format string (automatically deduced)
- * \tparam Indices
- *      An index sequence from [0, N) where N is the number of parameters in
- *      the format string (automatically deduced)
- *
- * \param fmt
- *      printf format string to analyze
- *
- * \return
- *      An std::array describing the types at each index (zero based).
- */
-template<int N, std::size_t... Indices>
-constexpr std::array<ParamType, sizeof...(Indices)>
-analyzeFormatStringHelper(const char (&fmt)[N], std::index_sequence<Indices...>)
-{
-    return {{ getParamInfo(fmt, Indices)... }};
+    paramTypes.size = paramIdx;
+    return paramTypes;
 }
 
 
 /**
  * Computes a ParamType array describing the parameters that would be used
- * with the provided printf style format string. The indices of the array
- * correspond with the parameter position in the variable args portion of
- * the invocation.
+ * with the provided ParamTypeContainer analyzed from the printf style format
+ * string. The indices of the array correspond with the parameter position in
+ * the variable args portion of the invocation.
  *
  * \template NParams
  *      The number of additional format parameters that follow the format
  *      string in a printf-like function. For example printf("%*.*d", 9, 8, 7)
  *      would have NParams = 3
  * \template N
- *      length of the printf style format string (automatically deduced)
- *
- * \param fmt
- *      Format string to generate the array for
+ *      template parameter N of the ParamTypeContainer parameter (automatically
+ *      deduced)
+ * \param paramTypes
+ *      ParamTypeContainer object to generate the array for
  *
  * \return
  *      An std::array where the n-th index indicates that the
  *      n-th format parameter is a "%s" or not.
  */
-template<int NParams, size_t N>
+template<int NParams, std::size_t N>
 constexpr std::array<ParamType, NParams>
-analyzeFormatString(const char (&fmt)[N])
-{
-    return analyzeFormatStringHelper(fmt, std::make_index_sequence<NParams>{});
-}
-
-/**
- * Counts the number of parameters that need to be passed in for a particular
- * printf style format string.
- *
- * One subtle point is that we are counting parameters, not specifiers, so a
- * specifier of "%*.*d" will actually count as 3 since the two '*" will result
- * in a parameter being passed in each.
- *
- * \tparam N
- *      length of the printf style format string (automatically deduced)
- *
- * \param fmt
- *      printf style format string to analyze
- *
- * @return
- */
-template<int N>
-constexpr inline int
-countFmtParams(const char (&fmt)[N])
+analyzeParamTypeContainer(const ParamTypeContainer<N> &paramTypes)
 {
-    int count = 0;
-    while (getParamInfo(fmt, count) != ParamType::INVALID)
-        ++count;
-    return count;
+    std::array<ParamType, NParams> ret = {};
+    int fillSize = NParams;
+    if (NParams > static_cast<int>(paramTypes.size))
+        fillSize = static_cast<int>(paramTypes.size);
+    for (int i = 0; i < fillSize; ++i) {
+        ret[i] = paramTypes.data[i];
+    }
+    if (NParams > static_cast<int>(paramTypes.size)) {
+        for (int i = paramTypes.size; i < NParams; ++i) {
+            ret[i] = ParamType::INVALID;
+        }
+    }
+    return ret;
 }
 
 /**
  * Counts the number of nibbles that would be needed to represent all
  * the non-string and dynamic width/precision specifiers for a given
- * printf style format string in the NanoLog system.
+ * ParamTypeContainer in the NanoLog system.
  *
  * \tparam N
- *      length of the printf style format string (automatically deduced)
- * \param fmt
- *      printf style format string to analyze
+ *      template parameter N of the ParamTypeContainer parameter (automatically
+ *      deduced)
+ * \param paramTypes
+ *      ParamTypeContainer object to analyze
  *
  * \return
- *      Number of non-string specifiers in the format string
+ *      Number of non-string specifiers in the paramTypes object.
  */
 template<size_t N>
 constexpr int
-getNumNibblesNeeded(const char (&fmt)[N])
+getNumNibblesNeeded(const ParamTypeContainer<N> &paramTypes)
 {
     int numNibbles = 0;
-    for (int i = 0; i < countFmtParams(fmt); ++i) {
-        ParamType t = getParamInfo(fmt, i);
+    for (int i = 0; i < paramTypes.size; ++i) {
+        ParamType t = paramTypes.data[i];
         if (t == NON_STRING || t == DYNAMIC_PRECISION || t == DYNAMIC_WIDTH)
             ++numNibbles;
     }
@@ -1071,8 +1052,9 @@ checkFormat(NANOLOG_PRINTF_FORMAT const char *, ...) {}
  *      Log arguments associated with the printf-like string.
  */
 #define NANO_LOG(severity, format, ...) do { \
-    constexpr int numNibbles = NanoLogInternal::getNumNibblesNeeded(format); \
-    constexpr int nParams = NanoLogInternal::countFmtParams(format); \
+    constexpr auto paramTypeInfo = NanoLogInternal::getParamInfos(format); \
+    constexpr int numNibbles = NanoLogInternal::getNumNibblesNeeded(paramTypeInfo); \
+    constexpr int nParams = paramTypeInfo.size; \
     \
     /*** Very Important*** These must be 'static' so that we can save pointers
      * to these variables and have them persist beyond the invocation.
@@ -1081,7 +1063,7 @@ checkFormat(NANOLOG_PRINTF_FORMAT const char *, ...) {}
      * used by the compression function, which is invoked in another thread
      * at a much later time. */ \
     static constexpr std::array<NanoLogInternal::ParamType, nParams> paramTypes = \
-                                NanoLogInternal::analyzeFormatString<nParams>(format); \
+                                NanoLogInternal::analyzeParamTypeContainer<nParams>(paramTypeInfo); \
     static int logId = NanoLogInternal::UNASSIGNED_LOGID; \
     \
     if (NanoLog::severity > NanoLog::getLogLevel()) \