jau::cfmt: cleanup and add robusteness, adding alternative recursive version

2 files changed, 921 insertions, 34 deletions

diff --git a/test/string_cfmt2.hpp b/test/string_cfmt2.hpp
new file mode 100644
index 0000000..6f2ff49
--- /dev/null
+++ b/test/string_cfmt2.hpp
@@ -0,0 +1,803 @@
+/**
+ * Copyright the Collabora Online contributors.
+ * Copyright Gothel Software e.K.
+ *
+ * ***
+ *
+ * SPDX-License-Identifier: MPL-2.0
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * ***
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ * This Source Code Form is subject to the terms of the MIT License
+ * If a copy of the MIT was not distributed with this
+ * file, You can obtain one at https://opensource.org/license/mit/.
+ *
+ */
+
+#ifndef JAU_STRING_CFMT2_HPP_
+#define JAU_STRING_CFMT2_HPP_
+
+#include <bits/types/wint_t.h>
+#include <sys/types.h>
+#include <cassert>
+#include <cerrno>
+#include <cstddef>
+#include <cstdio>
+#include <cstdlib>
+#include <cstring>
+#include <limits>
+#include <string>
+#include <string_view>
+#include <type_traits>
+#include <iostream>
+
+#include <jau/byte_util.hpp>
+#include <jau/cpp_lang_util.hpp>
+#include <jau/packed_attribute.hpp>
+#include <jau/type_traits_queries.hpp>
+
+#include <jau/cpp_pragma.hpp>
+
+/**
+ * @anchor jau_cfmt_header
+ * ## `snprintf` argument type checker `jau::cfmt`
+ *
+ * ### Features
+ * - jau::cfmt::check() provides strict type matching of arguments against the format string.
+ * - Have jau::cfmt::check() to be passed _before_ using std::snprintf(),
+ *   removing safety concerns of the latter and benefit from its formatting and performance.
+ * - Follows [C++ Reference](https://en.cppreference.com/w/cpp/io/c/fprintf)
+ *
+ * ### Type Conversion 
+ * Implementation follows type conversion rules as described 
+ * in [Variadic Default Conversion](https://en.cppreference.com/w/cpp/language/variadic_arguments#Default_conversions)
+ *   - float to double promotion
+ *   - bool, char, short, and unscoped enumerations are converted to int or wider integer types
+ * as well as in [va_arg](https://en.cppreference.com/w/cpp/utility/variadic/va_arg)
+ *   - ignore signed/unsigned type differences for integral types
+ *   - void pointer tolerance
+ *
+ * ### Implementation Details
+ * - Validates arguments against format string at compile time or runtime, 
+ *   depending whether passed arguments are of constexpr nature (compile time).  
+ * - Written in C++20 using template argument pack w/ save argument type checks
+ * - Written as constexpr, capable to be utilized at compile-time.
+ *
+ * #### Supported Conversion Specifiers and Data Types
+ *
+ * The following conversion specifiers are supported:
+ * - `c`, `s`, `d`, `o`, `x`, `X`, `u`, `f`, `e`, `E`, `a`, `A`, `g`, `G`, `p`
+ * - Their synonyms 
+ *   - `i` -> `d`
+ *   - `F` -> `f`
+ * - Flags `-`, `+`, ` `, `0` and `#`
+ * - Asterisk `*` for field width and precision
+ *
+ * The following length modifiers are supported where allowed
+ * - `hh` [unsigned] char
+ * - `h` [unsigned] short
+ * - `l` [unsigned] long
+ * - `ll` [unsigned] long long
+ * - 'j' uintmax_t or intmax_t
+ * - 'z' size_t or ssize_t
+ * - 't' ptrdiff_t
+ * - 'L' long double
+ *
+ * See [C++ Reference](https://en.cppreference.com/w/cpp/io/c/fprintf) for details. 
+ *
+ * ### Further Documentation 
+ * - [C++ Reference](https://en.cppreference.com/w/cpp/io/c/fprintf)
+ * - [Linux snprintf(3) man page](https://www.man7.org/linux/man-pages/man3/snprintf.3p.html)
+ * - [FreeBSD snprintf(3) man page](https://man.freebsd.org/cgi/man.cgi?snprintf(3))
+ */
+namespace jau::cfmt2 {
+
+    /** \addtogroup StringUtils
+     *
+     *  @{
+     */
+
+    enum class pstate_t {
+        error,
+        outside,
+        start,
+        field_width,
+        precision
+    };
+    constexpr static const char *to_string(pstate_t s) noexcept {
+        switch( s ) {
+            case pstate_t::outside:     return "outside";
+            case pstate_t::start:       return "start";
+            case pstate_t::field_width: return "width";
+            case pstate_t::precision:   return "precision";
+            default:                    return "error";
+        }
+    }
+    enum class plength_t {
+        hh,
+        h,
+        none,
+        l,
+        ll,
+        j,
+        z,
+        t,
+        L
+    };
+    constexpr static const char *to_string(plength_t s) noexcept {
+        switch( s ) {
+            case plength_t::hh:   return "hh";
+            case plength_t::h:    return "h";
+            case plength_t::none: return "";
+            case plength_t::l:    return "l";
+            case plength_t::ll:   return "ll";
+            case plength_t::j:    return "j";
+            case plength_t::z:    return "z";
+            case plength_t::t:    return "t";
+            case plength_t::L:    return "L";
+            default:              return "n/a";
+        }
+    }
+
+    static constexpr bool isDigit(const char c) noexcept { return '0' <= c && c <= '9'; }
+
+    namespace impl {
+        template <typename T>
+        class Parser;  // fwd
+    }
+    
+    struct PResult {
+        const std::string_view fmt;
+        const size_t pos;
+        const ssize_t arg_count;
+        const int line;
+        const pstate_t state;
+        const plength_t length_mod;
+        const bool precision_set;
+        
+        template <size_t N>
+        constexpr PResult(const char (&fmt_)[N]) noexcept
+        : fmt(fmt_, N), pos(0), arg_count(0), line(0), state(pstate_t::outside), length_mod(plength_t::none), precision_set(false) { }
+
+        constexpr PResult(const std::string_view fmt_) noexcept
+        : fmt(fmt_), pos(0), arg_count(0), line(0), state(pstate_t::outside), length_mod(plength_t::none), precision_set(false) { }
+        
+        constexpr PResult(const PResult &pre) noexcept = default;
+
+        constexpr PResult &operator=(const PResult &x) noexcept = delete;
+
+        constexpr bool hasNext() const noexcept {
+            return !error() && pos < fmt.length() - 1;
+        }
+
+        constexpr ssize_t argCount() const noexcept { return arg_count; }
+        constexpr bool error() const noexcept { return pstate_t::error == state; }
+        constexpr char sym() const noexcept { return fmt[pos]; }
+
+        std::string toString() const {
+            const char c = pos < fmt.length() ? fmt[pos] : '@';
+            std::string s = "args ";
+            s.append(std::to_string(arg_count))
+             .append(", state ")
+             .append(to_string(state))
+             .append(", line ")
+             .append(std::to_string(line))
+             .append(", pos ")
+             .append(std::to_string(pos))
+             .append(", char `")
+             .append(std::string(1, c))
+             .append("`, length `")
+             .append(to_string(length_mod))
+             .append("`, precision ")
+             .append(std::to_string(precision_set))
+             .append(", fmt `")
+             .append(fmt)
+             .append("`");
+            return s;
+        }
+
+      private:
+        template <typename T>
+        friend class impl::Parser;
+
+        constexpr PResult(const PResult &pre, size_t pos2) noexcept
+        : fmt(pre.fmt), pos(pos2), arg_count(pre.arg_count), line(pre.line), state(pre.state), length_mod(pre.length_mod), precision_set(pre.precision_set) {} 
+        
+        constexpr PResult(const PResult &pre, size_t pos2, ssize_t arg_count2) noexcept
+        : fmt(pre.fmt), pos(pos2), arg_count(arg_count2), line(pre.line), state(pre.state), length_mod(pre.length_mod), precision_set(pre.precision_set) {}
+        
+        constexpr PResult(const PResult &pre, pstate_t state2) noexcept
+        : fmt(pre.fmt), pos(pre.pos), arg_count(pre.arg_count), line(pre.line), state(state2), length_mod(pre.length_mod), precision_set(pre.precision_set) {} 
+        
+        constexpr PResult(const PResult &pre, pstate_t state2, size_t pos2) noexcept
+        : fmt(pre.fmt), pos(pos2), arg_count(pre.arg_count), line(pre.line), state(state2), length_mod(pre.length_mod), precision_set(pre.precision_set) {} 
+        
+        constexpr PResult(const PResult &pre, pstate_t state2, size_t pos2, ssize_t arg_count2, int line2) noexcept
+        : fmt(pre.fmt), pos(pos2), arg_count(arg_count2), line(line2), state(state2), length_mod(pre.length_mod), precision_set(pre.precision_set) {} 
+         
+        constexpr PResult(const PResult &pre, plength_t length_mod2, bool precision_set2) noexcept
+        : fmt(pre.fmt), pos(pre.pos), arg_count(pre.arg_count), line(pre.line), state(pre.state), length_mod(length_mod2), precision_set(precision_set2) {} 
+        
+        constexpr PResult nextSymbol() const noexcept {
+            if( pos < fmt.length() - 1 ) {
+                return PResult(*this, pos+1);
+            } else {
+                return *this;
+            }
+        }
+        constexpr PResult toConversion() const noexcept {
+            if( pstate_t::outside != state ) {
+                return PResult(*this);  // inside conversion specifier
+            } else if( fmt[pos] == '%' ) {
+                return PResult(*this, pstate_t::start, pos); // just at start of conversion specifier
+            } else {
+                // seek next conversion specifier
+                const size_t q = fmt.find('%', pos + 1);
+                if( q == std::string::npos ) {
+                    // no conversion specifier found
+                    return PResult(*this, fmt.length());
+                } else {
+                    // new conversion specifier found
+                    return PResult(*this, pstate_t::start, q);
+                }
+            }
+        }
+
+        constexpr PResult setError(int l) const noexcept {
+            ssize_t arg_count2;
+            if( 0 == arg_count ) {
+                arg_count2 = std::numeric_limits<ssize_t>::min();
+            } else if( 0 < arg_count ) {
+                arg_count2 = arg_count * -1;
+            } else {
+                arg_count2 = arg_count;
+            }
+            return PResult(*this, pstate_t::error, pos, arg_count2, l);
+        }
+    };
+
+    inline std::ostream &operator<<(std::ostream &out, const PResult &pc) {
+        out << pc.toString();
+        return out;
+    }
+
+    namespace impl {
+
+        static constexpr bool verbose_error = true;
+
+        enum class no_type_t {};
+
+        template <typename T>
+        class Parser {
+          public:
+            constexpr Parser() noexcept = delete;
+
+            /**
+             * Parse the given argument against the current conversion specifier of the format string.
+             *
+             * Multiple rounds of parsing calls might be required, each passing the next argument or null.
+             *
+             * Parsing is completed when method returns false, either signaling an error() or completion.
+             *
+             * @tparam T The type of the given argument
+             * @return true if no error _and_ not complete, i.e. further calls with subsequent parameter required. Otherwise parsing is done due to error or completeness.
+             */
+            static constexpr const PResult parseOne(const PResult pc) noexcept {
+                if( !pc.hasNext() ) {
+                    return pc; // done or error
+                }
+
+                const PResult pc2 = pc.toConversion();
+                if( !pc2.hasNext() ) {
+                    return pc2; // done
+                }
+                
+                // pstate_t::outside != _state
+                
+                /* skip '%' or previous `*` */
+                const PResult pc3 = pc2.nextSymbol();
+
+                if( pstate_t::start == pc3.state ) {
+                    const PResult pc4 = parseFlags(PResult(pc3, pstate_t::field_width));
+
+                    /* parse field width */
+                    bool next_arg = false;
+                    const PResult pc5 = parseFieldWidth(pc4, next_arg);
+                    if( next_arg || pc5.error() ) {
+                        return pc5;  // error or continue with next argument for same conversion -> field_width
+                    }
+                    return parseP2(pc5);
+                } else {
+                    return parseP2(pc3);
+                }
+            }
+
+          private:
+            
+            static constexpr const PResult parseP2(const PResult pc) noexcept {
+                if( pstate_t::field_width == pc.state ) {
+                    /* parse precision */
+                    const PResult pc2 = PResult(pc, pstate_t::precision);
+                    if( pc2.sym() == '.' ) {
+                        const PResult pc3 = PResult(pc2, pc2.length_mod, true);
+                        bool next_arg = false;
+                        const PResult pc4 = parsePrecision(pc3, next_arg);
+                        if( next_arg || pc4.error() ) {
+                            return pc4;  // error or continue with next argument for same conversion -> precision
+                        }
+                        return parseP3(pc4);
+                    } else {
+                        return parseP3(pc2);
+                    }
+                } else {
+                    return parseP3(pc);
+                }
+            }
+            
+            static constexpr const PResult parseP3(const PResult pc) noexcept {
+                const PResult pc2 = parseLengthMods(pc);
+                if( pc2.error() ) {
+                    return pc2;  // error
+                }
+
+                const PResult pc3 = parseFmtSpec(pc2);
+                if( pc3.error() ) {
+                    return pc3;  // error
+                }
+
+                // next conversion specifier
+                const PResult pc4 = PResult(pc3, pstate_t::outside);
+                if( !pc4.hasNext() ) {
+                    return pc4; // done
+                }
+                return PResult(pc4.nextSymbol(), plength_t::none, false); // clear length_mod and precision_set
+            }
+          
+            static constexpr const PResult parseFlags(const PResult pc) noexcept {
+                switch( pc.sym() ) {
+                    case '0':  break;
+                    case '-':  break;
+                    case '+':  break;
+                    case ' ':  break;
+                    case '#':  break;
+                    case '\'': break;
+                    default:   return pc;  // done, not a flag
+                }
+                if( pc.hasNext() ) {
+                    return parseFlags(pc.nextSymbol());
+                } else {
+                    return pc;
+                }
+            }
+
+            static constexpr const PResult parseDigit(const PResult pc) noexcept {
+                if( !pc.hasNext() || !isDigit(pc.sym()) ) { return pc; }
+                return parseDigit( pc.nextSymbol() );
+            }
+            
+            /* parse field width, returns true if parsing can continue or false if next argument is required or error */            
+            static constexpr const PResult parseFieldWidth(const PResult pc, bool& next_arg) noexcept {
+                next_arg = false;
+                if( pc.sym() == '*' ) {
+                    if( !pc.hasNext() ) { return pc; }
+                    const PResult pc2 = pc.nextSymbol();
+
+                    using U = std::remove_cv_t<T>;
+
+                    if constexpr( std::is_same_v<no_type_t, T> ) {
+                        return pc2.setError(__LINE__);
+                    }
+                    const PResult pc3 = PResult(pc2, pc.arg_count+1);
+                    if constexpr( !std::is_same_v<int, U> ) {
+                        return pc3.setError(__LINE__);
+                    }
+                    next_arg = true;
+                    return pc3; // next argument is required
+                } else {
+                    // continue with current argument
+                    return parseDigit(pc);                    
+                }
+            }
+
+            /* parse precision, returns true if parsing can continue or false if next argument is required or error */            
+            static constexpr const PResult parsePrecision(const PResult pc, bool &next_arg) noexcept {
+                next_arg = false;                
+                if( !pc.hasNext() ) { return pc; }
+                const PResult pc2 = pc.nextSymbol();
+                const char c = pc.fmt[pc.pos];
+                if( c == '*' ) {
+                    if( !pc2.hasNext() ) { return pc2; }
+                    const PResult pc3 = pc2.nextSymbol();
+
+                    using U = std::remove_cv_t<T>;
+
+                    if constexpr( std::is_same_v<no_type_t, T> ) {
+                        return pc3.setError(__LINE__);
+                    }
+                    const PResult pc4 = PResult(pc3, pc.arg_count+1);
+                    if constexpr( !std::is_same_v<int, U> ) {
+                        return pc4.setError(__LINE__);
+                    }
+                    next_arg = true;
+                    return pc4;  // next argument is required
+                } else {
+                    // continue with current argument
+                    return parseDigit(pc2);                    
+                }
+            }
+
+            static constexpr const PResult parseLengthMods(const PResult pc) noexcept {
+                const char sym = pc.sym();
+                if( 'h' == sym ) {
+                    if( !pc.hasNext() ) { return pc.setError(__LINE__); }
+                    const PResult pc2 = pc.nextSymbol();
+                    if( 'h' == pc2.sym() ) {
+                        if( !pc2.hasNext() ) { return pc2.setError(__LINE__); }
+                        return PResult(pc2.nextSymbol(), plength_t::hh, pc2.precision_set);
+                    } else {
+                        return PResult(pc2, plength_t::h, pc2.precision_set);
+                    }
+                } else if( 'l' == sym ) {
+                    if( !pc.hasNext() ) { return pc.setError(__LINE__); }
+                    const PResult pc2 = pc.nextSymbol();
+                    if( 'l' == pc2.sym() ) {
+                        if( !pc2.hasNext() ) { return pc2.setError(__LINE__); }
+                        return PResult(pc2.nextSymbol(), plength_t::ll, pc2.precision_set);
+                    } else {
+                        return PResult(pc2, plength_t::l, pc2.precision_set);
+                    }
+                } else if( 'j' == sym ) {
+                    if( !pc.hasNext() ) { return pc.setError(__LINE__); }
+                    return PResult(pc.nextSymbol(), plength_t::j, pc.precision_set);
+                } else if( 'z' == sym ) {
+                    if( !pc.hasNext() ) { return pc.setError(__LINE__); }
+                    return PResult(pc.nextSymbol(), plength_t::z, pc.precision_set);
+                } else if( 't' == sym ) {
+                    if( !pc.hasNext() ) { return pc.setError(__LINE__); }
+                    return PResult(pc.nextSymbol(), plength_t::t, pc.precision_set);
+                } else if( 'L' == sym ) {
+                    if( !pc.hasNext() ) { return pc.setError(__LINE__); }
+                    return PResult(pc.nextSymbol(), plength_t::L, pc.precision_set);
+                } else {
+                    return PResult(pc, plength_t::none, pc.precision_set);
+                }
+            }
+            
+            static constexpr const PResult parseFmtSpec(const PResult pc) noexcept {
+                const char fmt_literal = unaliasFmtSpec( pc.sym() );
+
+                switch( fmt_literal ) {
+                    case '%':
+                    case 'c':
+                    case 's':
+                        return parseStringFmtSpec(pc, fmt_literal);
+                    case 'p':
+                        return parseAPointerFmtSpec(pc);
+                    case 'd':
+                        return parseSignedFmtSpec(pc);
+                    case 'o':
+                    case 'x':
+                    case 'X':
+                    case 'u':
+                        return parseUnsignedFmtSpec(pc, fmt_literal);
+                    case 'f':
+                    case 'e':
+                    case 'E':
+                    case 'a':
+                    case 'A':
+                    case 'g':
+                    case 'G':
+                        return parseFloatFmtSpec(pc, fmt_literal);
+                    default:
+                        return pc.setError(__LINE__);
+                }  // switch( fmt_literal )
+            }
+
+            static constexpr char unaliasFmtSpec(const char fmt_literal) noexcept {
+                switch( fmt_literal ) {
+                    case 'i': return 'd';
+                    case 'F': return 'f';
+                    default:  return fmt_literal;
+                }
+            }
+            
+            static constexpr const PResult parseStringFmtSpec(const PResult pc, const char fmt_literal) noexcept {
+                if constexpr( std::is_same_v<no_type_t, T> ) {
+                    return pc.setError(__LINE__);
+                }
+                switch( fmt_literal ) {
+                    case '%':
+                        break;
+                    case 'c': {
+                        const PResult pc2 = PResult(pc, pc.pos, pc.arg_count+1);
+                        using U = std::remove_cv_t<T>;
+                        switch( pc2.length_mod ) {
+                            case plength_t::none:
+                                if constexpr( !std::is_same_v<char, U> ||
+                                              !std::is_same_v<int, U> ) {
+                                    return pc2.setError(__LINE__);
+                                }
+                                break;
+                            case plength_t::l:
+                                if constexpr( !std::is_same_v<wchar_t, U> ||
+                                              !std::is_same_v<wint_t, U> ) {
+                                    return pc2.setError(__LINE__);
+                                }
+                                break;
+                            default:
+                                return pc2.setError(__LINE__);
+                        }
+                        return pc2;
+                    }
+                    case 's': {
+                        const PResult pc2 = PResult(pc, pc.pos, pc.arg_count+1);
+                        switch( pc2.length_mod ) {
+                            case plength_t::none:
+                                if constexpr( !std::is_pointer_v<T> ||
+                                              !std::is_same_v<char, std::remove_cv_t<std::remove_pointer_t<T>>> ) {
+                                    return pc2.setError(__LINE__);
+                                }
+                                break;
+                            case plength_t::l:
+                                if constexpr( !std::is_pointer_v<T> ||
+                                              !std::is_same_v<wchar_t, std::remove_cv_t<std::remove_pointer_t<T>>> ) {
+                                    return pc2.setError(__LINE__);
+                                }
+                                break;
+                            default:
+                                return pc2.setError(__LINE__);
+                        }
+                        return pc2;
+                    }
+                    default: return pc.setError(__LINE__);
+                }
+                return pc;
+            }
+            
+            static constexpr const PResult parseAPointerFmtSpec(const PResult pc) noexcept {
+                const PResult pc2 = PResult(pc, plength_t::none, pc.precision_set);
+                if constexpr( std::is_same_v<no_type_t, T> ) {
+                    return pc2.setError(__LINE__);
+                }
+                const PResult pc3 = PResult(pc2, pc2.pos, pc2.arg_count+1);
+                if constexpr( !std::is_pointer_v<T> ) {
+                    return pc3.setError(__LINE__);
+                }
+                return pc3;
+            }
+            
+            static constexpr const PResult parseSignedFmtSpec(const PResult pc) noexcept {
+                if constexpr( std::is_same_v<no_type_t, T> ) {
+                    return pc.setError(__LINE__);
+                }
+                const PResult pc2 = PResult(pc, pc.pos, pc.arg_count+1);
+
+                using U = std::remove_cv_t<T>;
+                // using U = std::conditional<std::is_integral_v<T> && std::is_unsigned_v<T>, std::make_signed<T>, T>::type; // triggers the instantiating the 'other' case and hence fails
+                using V = typename std::conditional_t<std::is_integral_v<U> && std::is_unsigned_v<U>, std::make_signed<U>, std::type_identity<U>>::type;  // NOLINT
+
+                switch( pc2.length_mod ) {
+                    case plength_t::hh:
+                        if constexpr( !std::is_same_v<char, V> && (!std::is_integral_v<V> || sizeof(V) > sizeof(char)) ) {
+                            return pc2.setError(__LINE__);
+                        }
+                        break;
+                    case plength_t::h:
+                        if constexpr( !std::is_same_v<short, V> && (!std::is_integral_v<V> || sizeof(V) > sizeof(short)) ) {
+                            return pc2.setError(__LINE__);
+                        }
+                        break;
+                    case plength_t::none:
+                        if constexpr( !std::is_same_v<int, V> && (!std::is_integral_v<V> || sizeof(V) > sizeof(int)) ) {
+                            return pc2.setError(__LINE__);
+                        }
+                        break;
+                    case plength_t::l:
+                        if constexpr( !std::is_same_v<long, V> && (!std::is_integral_v<V> || sizeof(V) > sizeof(long)) ) {
+                            return pc2.setError(__LINE__);
+                        }
+                        break;
+                    case plength_t::ll:
+                        if constexpr( !std::is_same_v<long long, V> && (!std::is_integral_v<V> || sizeof(V) > sizeof(long long)) ) {
+                            return pc2.setError(__LINE__);
+                        }
+                        break;
+                    case plength_t::j:
+                        if constexpr( !std::is_same_v<intmax_t, V> && (!std::is_integral_v<V> || sizeof(V) > sizeof(intmax_t)) ) {
+                            return pc2.setError(__LINE__);
+                        }
+                        break;
+                    case plength_t::z:
+                        if constexpr( !std::is_same_v<ssize_t, V> && (!std::is_integral_v<V> || sizeof(V) > sizeof(ssize_t)) ) {
+                            return pc2.setError(__LINE__);
+                        }
+                        break;
+                    case plength_t::t:
+                        if constexpr( !std::is_same_v<ptrdiff_t, V> && (!std::is_integral_v<V> || sizeof(V) > sizeof(ptrdiff_t)) ) {
+                            return pc2.setError(__LINE__);
+                        }
+                        break;
+                    default:
+                        return pc2.setError(__LINE__);
+                }
+                return pc2;
+            }
+            
+            static constexpr const PResult parseUnsignedFmtSpec(const PResult pc, const char /*fmt_literal*/) noexcept {
+                if constexpr( std::is_same_v<no_type_t, T> ) {
+                    return pc.setError(__LINE__);
+                }
+                const PResult pc2 = PResult(pc, pc.pos, pc.arg_count+1);
+
+                using U = std::remove_cv_t<T>;
+                // using U = std::conditional_t<std::is_integral_v<T> && std::is_signed_v<T>, std::make_unsigned_t<T>, T>; // triggers the instantiating the 'other' case and hence fails
+                using V = typename std::conditional_t<std::is_integral_v<U> && std::is_signed_v<U>, std::make_unsigned<U>, std::type_identity<U>>::type;  // NOLINT
+
+                switch( pc2.length_mod ) {
+                    case plength_t::hh:
+                        if constexpr( !std::is_same_v<unsigned char, V> && (!std::is_integral_v<V> || sizeof(V) > sizeof(unsigned char)) ) {
+                            return pc2.setError(__LINE__);
+                        }
+                        break;
+                    case plength_t::h:
+                        if constexpr( !std::is_same_v<unsigned short, V> && (!std::is_integral_v<V> || sizeof(V) > sizeof(unsigned short)) ) {
+                            return pc2.setError(__LINE__);
+                        }
+                        break;
+                    case plength_t::none:
+                        if constexpr( !std::is_same_v<unsigned int, V> && (!std::is_integral_v<V> || sizeof(V) > sizeof(unsigned int)) ) {
+                            return pc2.setError(__LINE__);
+                        }
+                        break;
+                    case plength_t::l:
+                        if constexpr( !std::is_same_v<unsigned long, V> && (!std::is_integral_v<V> || sizeof(V) > sizeof(unsigned long)) ) {
+                            return pc2.setError(__LINE__);
+                        }
+                        break;
+                    case plength_t::ll:
+                        if constexpr( !std::is_same_v<unsigned long long, V> && (!std::is_integral_v<V> || sizeof(V) > sizeof(unsigned long long)) ) {
+                            return pc2.setError(__LINE__);
+                        }
+                        break;
+                    case plength_t::j:
+                        if constexpr( !std::is_same_v<uintmax_t, V> && (!std::is_integral_v<V> || sizeof(V) > sizeof(uintmax_t)) ) {
+                            return pc2.setError(__LINE__);
+                        }
+                        break;
+                    case plength_t::z:
+                        if constexpr( !std::is_same_v<size_t, V> && (!std::is_integral_v<V> || sizeof(V) > sizeof(size_t)) ) {
+                            return pc2.setError(__LINE__);
+                        }
+                        break;
+#if 0
+                    case plength_t::t:
+                        if constexpr( !std::is_same_v<unsigned ptrdiff_t, U> ) {
+                            return pc2.setError(__LINE__);
+                        }
+                        break;
+#endif
+                    default:
+                        return pc2.setError(__LINE__);
+                }
+                return pc2;
+            }
+            
+            static constexpr const PResult parseFloatFmtSpec(const PResult pc, const char /*fmt_literal*/) noexcept {
+                if constexpr( std::is_same_v<no_type_t, T> ) {
+                    return pc.setError(__LINE__);
+                }
+                const PResult pc2 = PResult(pc, pc.pos, pc.arg_count+1);
+
+                using U = std::remove_cv_t<T>;
+
+                switch( pc2.length_mod ) {
+                    case plength_t::none:
+                    case plength_t::l:
+                        if constexpr( !std::is_same_v<float, U> &&
+                                      !std::is_same_v<double, U> ) {
+                            return pc2.setError(__LINE__);
+                        }
+                        break;
+                    case plength_t::L:
+                        if constexpr( !std::is_same_v<float, U> &&
+                                      !std::is_same_v<double, U> &&
+                                      !std::is_same_v<long double, U> ) {
+                        } else {
+                            return pc2.setError(__LINE__);
+                        }
+                        break;
+                    default:
+                        return pc2.setError(__LINE__);
+                }
+                return pc2;
+            }
+        };
+
+        constexpr const PResult checkRec(const PResult ctx) noexcept {
+            return Parser<no_type_t>::parseOne(ctx);
+        }
+        
+        template <typename Targ, typename... Tnext>
+        constexpr const PResult checkRec(const PResult ctx) noexcept {
+            if constexpr( 0 < sizeof...(Tnext) ) {
+                return checkRec<Tnext...>( Parser<Targ>::parseOne(ctx) );
+            } else {
+                return Parser<no_type_t>::parseOne( Parser<Targ>::parseOne(ctx) );
+            }
+        }
+
+    }  // namespace impl
+
+    /**
+     * Strict type validation of arguments against the format string.
+     *
+     * See @ref jau_cfmt_header for details
+     *
+     * @tparam Targs the argument template type pack to be validated against the format string
+     * @param fmt the snprintf format string
+     * @param args passed arguments, used for template type deduction only
+     * @return true if successfully parsed format and arguments, false otherwise.
+     * @see @ref jau_cfmt_header
+     */
+    template <typename... Targs>
+    constexpr bool check(const std::string_view fmt, const Targs &...) noexcept {
+        return !impl::checkRec<Targs...>( PResult(fmt) ).error();
+    }
+    
+    /**
+     * Strict type validation of arguments against the format string.
+     *
+     * See @ref jau_cfmt_header for details
+     *
+     * @tparam Targs the argument template type pack to be validated against the format string
+     * @param fmt the snprintf format string
+     * @return true if successfully parsed format and arguments, false otherwise.
+     * @see @ref jau_cfmt_header
+     */
+    template <typename... Targs>
+    constexpr bool check2(const std::string_view fmt) noexcept {
+        return !impl::checkRec<Targs...>( PResult(fmt) ).error();
+    }
+    
+    /**
+     * Strict type validation of arguments against the format string.
+     *
+     * See @ref jau_cfmt_header for details
+     *
+     * @tparam Targs the argument template type pack to be validated against the format string
+     * @param fmt the snprintf format string
+     * @param args passed arguments, used for template type deduction only
+     * @return PContext result object for further inspection.
+     * @see @ref jau_cfmt_header
+     */
+    template <typename... Targs>
+    constexpr const PResult checkR(const std::string_view fmt, const Targs &...) noexcept {
+        return impl::checkRec<Targs...>( PResult(fmt) );
+    }
+
+    /**
+     * Strict type validation of arguments against the format string.
+     *
+     * See @ref jau_cfmt_header for details
+     *
+     * @tparam Targs the argument template type pack to be validated against the format string
+     * @param fmt the snprintf format string
+     * @return PContext result object for further inspection.
+     * @see @ref jau_cfmt_header
+     */
+    template <typename... Targs>
+    constexpr const PResult checkR2(const std::string_view fmt) noexcept {
+        return impl::checkRec<Targs...>( PResult(fmt) );
+    }
+
+    /**@}*/
+
+} // namespace jau::cfmt2
+
+#endif  // JAU_STRING_CFMT2_HPP_
diff --git a/test/test_stringfmt01.cpp b/test/test_stringfmt01.cpp
index e19ca6c..279d9bb 100644
--- a/test/test_stringfmt01.cpp
+++ b/test/test_stringfmt01.cpp
@@ -19,6 +19,7 @@
  * file, You can obtain one at https://opensource.org/license/mit/.
  *
  */
+#include <sys/types.h>
 #include <cassert>
 #include <cinttypes>
 #include <cstdint>
@@ -36,28 +37,20 @@
 #include <jau/string_cfmt.hpp>
 #include <jau/string_util.hpp>
 #include <jau/test/catch2_ext.hpp>
+#include <jau/type_traits_queries.hpp>
+
+#include "string_cfmt2.hpp"
 
 #ifdef HAS_STD_FORMAT
     #include <format>
 #endif
 
+using namespace std::literals;
+
 using namespace jau::float_literals;
 
 using namespace jau::int_literals;
 
-#define format_string_static_assert(...) \
-    jau::format_string(__VA_ARGS__);     \
-    static_assert( 0 <= jau::cfmt::checkR(__VA_ARGS__).argCount() ); // compile time validation!
-
-#if 0
-// sadly doesn't work .. 'format' not constexpr ..
-template <typename... Args>
-constexpr std::string format_string_static_assert2(const std::string_view format, const Args &...args) {
-    static_assert(jau::cfmt::check2<Args...>(format));
-    return jau::format_string(format, args...);
-}
-#endif
-
 template <typename... Args>
 constexpr std::string format_string000(const std::size_t maxStrLen, const std::string_view format, const Args &...args) {
     std::string str;
@@ -217,6 +210,34 @@ void format_0b() {
 #endif
 }
 
+template <typename... Args>
+constexpr std::string format_string_static2(const std::string_view fmt, const Args &...) {
+    // constexpr const std::string format2(format);
+    // constexpr const bool b = jau::cfmt::check2<Args...>("Haus"sv);
+    constexpr const bool b = jau::cfmt::check3<Args...>(fmt);
+    static_assert( b );
+    (void)b;
+    return ""; // jau::format_string_v(1024, format, args...);
+}
+
+
+template <typename... Targs>
+constexpr jau::cfmt2::PResult check(const std::string_view fmt, const Targs &...) noexcept {
+    return jau::cfmt2::impl::checkRec<Targs...>( jau::cfmt2::PResult(fmt) );
+}
+
+template <typename... Targs>
+constexpr std::string format_string_static3(const std::string_view format, const Targs &...args) {
+    // constexpr const jau::cfmt2::PResult ctx2 = jau::cfmt2::impl::checkRec<Targs...>( jau::cfmt2::PResult(format) );
+    // static_assert( 0 <= jau::cfmt2::impl::checkRec<Targs...>( jau::cfmt2::PResult(format)).argCount() );
+    if( 0 <= jau::cfmt2::impl::checkRec<Targs...>( jau::cfmt2::PResult(format)).argCount() ) {
+        return jau::format_string_v(1024, format, args...);
+    } else {
+        return "";
+    }
+}
+
+
 TEST_CASE("jau::cfmt_00", "[jau][std::string][jau::cfmt]") {
     char buf[1024];
     constexpr float fa = 1.123456f, fb = 2.2f;
@@ -226,10 +247,51 @@ TEST_CASE("jau::cfmt_00", "[jau][std::string][jau::cfmt]") {
     const float *pf = &fa;
 
     {
+        constexpr jau::cfmt2::PResult pr = jau::cfmt2::checkR("lala %d", 2);
+        std::cerr << "XXX: " << __LINE__ << ": " << pr << std::endl;
+        static_assert( 0 <= pr.argCount() );
+    }
+    {   // 'format_check: %.2f, %2.2f, %zu, %lu, %03d'
+        constexpr  jau::cfmt2::PResult pc = jau::cfmt2::checkR("format_check: %.2f, %2.2f, %zu, %" PRIu64 ", %03d\n",
+                                                               fa, fb, sz1, sz2, i);
+        std::cerr << "XXX: " << __LINE__ << ": " << pc << std::endl;
+        // static_assert( 5 == pc.argCount() );
+        REQUIRE(5 == pc.argCount());
+    }
+    {
+        constexpr jau::cfmt2::PResult pr = jau::cfmt2::checkR("lala %d - end", 2);
+        std::cerr << "XXX: " << __LINE__ << ": " << pr << std::endl;
+        // static_assert( 0 <= pr.argCount() );
+        REQUIRE(0 <= pr.argCount());
+    }
+    {
+        constexpr const bool b1 = jau::cfmt::check("lala %d", 2);
+        static_assert( b1 );
+
+        constexpr const bool b2 = jau::cfmt::check2<int>("lala %d");
+        static_assert( b2 );
+
+        // constexpr jau::cfmt2::PResult pr1 = check(fmt3, 2);
+        constexpr jau::cfmt2::PResult pr1 = check("Hello %d", 2);
+        std::cerr << "XXX: " << __LINE__ << ": " << pr1 << std::endl;
+        static_assert( 0 <= pr1.argCount() );
+
+        std::string s3 = format_string_static3("Hello %d", 2);
+        std::cerr << "XXX: " << __LINE__ << ": " << s3 << std::endl;
+        REQUIRE( s3.length() > 0 );
+
+    // constexpr const std::string f2 = "Hello %d"s;
+    // constexpr const std::string_view f2v = "Hello %d"sv;
+    // format_string_static2(f2v, (int)2);
+    // constexpr const std::string_view f3 = "Hello %d"sv;
+    // constexpr const char f3[] = "Hello %d";
+    // format_string_static2("Hello %d"sv, (int)2);
+    }
+    {
         static_assert(false == std::is_signed_v<const float*>);
         static_assert(false == std::is_unsigned_v<const float*>);
-        
-        static_assert(true == std::is_signed_v<float>);        
+
+        static_assert(true == std::is_signed_v<float>);
         static_assert(false == std::is_unsigned_v<float>);
     }
     {
@@ -250,13 +312,13 @@ TEST_CASE("jau::cfmt_00", "[jau][std::string][jau::cfmt]") {
     }
     {
         // we shall ignore signedness like snprintf
-        static_assert(true == jau::cfmt::check("         int -> int %d", (int)1));
+        static_assert(true == jau::cfmt::check("         int -> int %d", 1));
         static_assert(true == jau::cfmt::check("unsigned int -> int %d", (unsigned int)1));
         static_assert(true == jau::cfmt::check("unsigned int -> unsigned int %u", (unsigned int)1));
-        static_assert(true == jau::cfmt::check("         int -> unsigned int %u", (int)1));
+        static_assert(true == jau::cfmt::check("         int -> unsigned int %u", 1));
         static_assert(true == jau::cfmt::check("        char -> int %d", (char)1)); // integral target type > given type
         static_assert(false == jau::cfmt::check(" error long -> int %d", (long)1)); // error: integral target type < given type
-        
+
         static_assert(true == jau::cfmt::check(" %d", i));
         static_assert(true == jau::cfmt::check(" %f", fa));
         static_assert(true == jau::cfmt::check(" %zd", (ssize_t)1));
@@ -264,14 +326,14 @@ TEST_CASE("jau::cfmt_00", "[jau][std::string][jau::cfmt]") {
         static_assert(true == jau::cfmt::check(" %" PRIi64 ".", (int64_t)1));
         static_assert(true == jau::cfmt::check(" %" PRIi64 ".", sz2));
         static_assert(true == jau::cfmt::check(" %p", pf));
-        
+
         static_assert(0 == jau::cfmt::checkR("Hello World").argCount());
         static_assert(1 == jau::cfmt::checkR("Hello World %d", 1).argCount());
         static_assert(1 == jau::cfmt::checkR("Hello 1 %d", i).argCount());
         static_assert(true == jau::cfmt::check("Hello World"));
         static_assert(true == jau::cfmt::check("Hello World %d", 1));
         static_assert(true == jau::cfmt::check("Hello 1 %d", i));
-        
+
         static_assert(1 == jau::cfmt::checkR("Hello 1 %.2f", fa).argCount());
         static_assert(1 == jau::cfmt::checkR("Hello 1 %.2f - end", fa).argCount());
         static_assert(2 == jau::cfmt::checkR("Hello 1 %.2f, 2 %2.2f - end", fa, fb).argCount());
@@ -290,8 +352,8 @@ TEST_CASE("jau::cfmt_00", "[jau][std::string][jau::cfmt]") {
         static_assert(false == jau::cfmt::check("Hello 1 %.2f, 2 %2.2f, 3 %zu, 4 %" PRIi64 ", 5 %03d, 6 %p - end",
                                               fa, fb, sz1, sz2, i, i));
 
-        const std::string s = format_string_static_assert("format_020a: %f, %f, %zu, %" PRIu64 ", %d\n",
-                                                          fa + 1.0_f32, fb + 1.0_f32, sz1 + 1, sz2 + 1_u64, i + 1);                                                          
+        const std::string s = jau_format_string_static("format_020a: %f, %f, %zu, %" PRIu64 ", %d\n",
+                                                       fa + 1.0_f32, fb + 1.0_f32, sz1 + 1, sz2 + 1_u64, i + 1);
         (void)s;
     }
     {
@@ -299,15 +361,21 @@ TEST_CASE("jau::cfmt_00", "[jau][std::string][jau::cfmt]") {
         static_assert( b1, "Not Assignable" );
         constexpr bool b2 = std::is_nothrow_assignable_v<unsigned int&, long double>;
         static_assert( b2, "Not Assignable" );
-        format_string_static_assert("Hello");
-        format_string_static_assert("Hello %d", (unsigned int)2);
-        format_string_static_assert("Hello %u", (int)2);
-        
+        jau_format_string_static("Hello");
+        jau_format_string_static("Hello %d", (int)2);
+        jau_format_string_static("Hello %d", (unsigned int)2);
+        jau_format_string_static("Hello %u", (unsigned int)2);
+        jau_format_string_static("Hello %u", (int)2);
+
+        // constexpr std::string_view fmt2 = "Hello %d"sv;
+        // format_string_static2("Hello %d"sv, (int)2);
+        // format_string_static2("Hello %d"s, (int)2);
+
         constexpr jau::cfmt::PResult c1 = jau::cfmt::checkR("Hello %u", (unsigned int)1);
         std::cerr << "XXX: " << __LINE__ << ": " << c1 << std::endl;
         REQUIRE(false == c1.error());
     }
-    {        
+    {
         constexpr jau::cfmt::PResult c1 = jau::cfmt::checkR("Hello World");
         REQUIRE(false == c1.error());
         REQUIRE(0 == c1.argCount());
@@ -320,17 +388,17 @@ TEST_CASE("jau::cfmt_00", "[jau][std::string][jau::cfmt]") {
         // `Hello 1 %.2f, 2 %2.2f, 3 %zu, 4 %li, 5 %03d, 6 %p - end`
         REQUIRE(1 == jau::cfmt::checkR("Hello 1 %.2f", fa).argCount());
         REQUIRE(1 == jau::cfmt::checkR("Hello 1 %.2f - end", fa).argCount());
-        
+
         // 'Hello 1 %.2f, 2 %2.2f - end'
         jau::cfmt::PResult pc = jau::cfmt::checkR("Hello 1 %.2f, 2 %2.2f - end", fa, fb);
-        std::cerr << "XXX: " << __LINE__ << ": " << pc << std::endl;        
+        std::cerr << "XXX: " << __LINE__ << ": " << pc << std::endl;
         REQUIRE(2 == jau::cfmt::checkR("Hello 1 %.2f, 2 %2.2f - end", fa, fb).argCount());
-        
+
         // `Hello 1 %.2f, 2 %2.2f, 3 %zu - end`
         pc = jau::cfmt::checkR("Hello 1 %.2f, 2 %2.2f, 3 %zu - end", fa, fb, sz1);
         std::cerr << "XXX: " << __LINE__ << ": " << pc << std::endl;
         REQUIRE(3 == jau::cfmt::checkR("Hello 1 %.2f, 2 %2.2f, 3 %zu - end", fa, fb, sz1).argCount());
-        
+
         REQUIRE(4 == jau::cfmt::checkR("Hello 1 %.2f, 2 %2.2f, 3 %zu, 4 %" PRIi64 " - end", fa, fb, sz1, sz2).argCount());
         REQUIRE(5 == jau::cfmt::checkR("Hello 1 %.2f, 2 %2.2f, 3 %zu, 4 %" PRIi64 ", 5 %03d - end", fa, fb, sz1, sz2, i).argCount());
         REQUIRE(6 == jau::cfmt::checkR("Hello 1 %.2f, 2 %2.2f, 3 %zu, 4 %" PRIi64 ", 5 %03d, 6 %p - end", fa, fb, sz1, sz2, i, pf).argCount());
@@ -352,7 +420,7 @@ TEST_CASE("jau::cfmt_01", "[jau][std::string][format_string]") {
 
 /// Execute with `test_stringfmt --perf_analysis`
 TEST_CASE("jau::cfmt_10", "[benchmark][jau][std::string][format_string]") {
-    const size_t loops = catch_auto_run ? 1000 : 1000;
+    const size_t loops = 1000; // catch_auto_run ? 1000 : 1000;
     WARN("Benchmark with " + std::to_string(loops) + " loops");
     CHECK(true);
 
@@ -387,6 +455,22 @@ TEST_CASE("jau::cfmt_10", "[benchmark][jau][std::string][format_string]") {
         }
         return res;
     };
+    BENCHMARK("fmt__check cnstexp2   bench") {
+        volatile size_t res = 0;
+        for( size_t i = 0; i < loops; ++i ) {
+            constexpr float fa = 1.1f, fb = 2.2f;
+            constexpr size_t sz1 = 1;
+            constexpr uint64_t sz2 = 2;
+            constexpr int i1 = 3;
+
+            constexpr  jau::cfmt2::PResult pc = jau::cfmt2::checkR("format_check: %.2f, %2.2f, %zu, %" PRIu64 ", %03d\n",
+                                                                   fa, fb, sz1, sz2, i1);
+            constexpr size_t r = pc.argCount();
+            REQUIRE(5 == r);
+            res = res + r;
+        }
+        return res;
+    };
     BENCHMARK("format_000a_vsnprintf bench") {
         volatile size_t res = 0;
         for( size_t i = 0; i < loops; ++i ) {
@@ -409,8 +493,8 @@ TEST_CASE("jau::cfmt_10", "[benchmark][jau][std::string][format_string]") {
                 constexpr size_t sz1 = 1;
                 constexpr uint64_t a_u64 = 2;
                 constexpr int j = 3;
-                const std::string s = format_string_static_assert("format_020a: %f, %f, %zu, %" PRIu64 ", %d\n",
-                                                                  fa + 1.0_f32, fb + 1.0_f32, sz1 + 1, a_u64 + 1_u64, j + 1);
+                const std::string s = jau_format_string_static("format_020a: %f, %f, %zu, %" PRIu64 ", %d\n",
+                                                               fa + 1.0_f32, fb + 1.0_f32, sz1 + 1, a_u64 + 1_u64, j + 1);
                 res = res + s.length();
             }
         }