18649960093

Committed 20 Oct 2025 11:02AM UTC coverage: 97.642% (-0.008%) from 97.65%

Build # 18649960093

Build Type

Pull #503

github

Committed by

web-flow

Commit Message

Merge 779b983dc into 48acea949

Pull Request Pull Request #503: Improve error model, callbacks

Run Details

1823 of 1870 new or added lines in 32 files covered. (97.49%)

38 existing lines in 4 files now uncovered.

13623 of 13952 relevant lines covered (97.64%)

537812.42 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

95.92

/src/c4/yml/detail/dbgprint.hpp

#ifndef _C4_YML_DETAIL_DBGPRINT_HPP_
#define _C4_YML_DETAIL_DBGPRINT_HPP_

#ifndef _C4_YML_COMMON_HPP_
#include "../common.hpp"
#endif

#ifdef RYML_DBG
#include <cstdio>
#endif


//-----------------------------------------------------------------------------
// debug prints

#ifndef RYML_DBG
#   define _c4dbgt(fmt, ...)
#   define _c4dbgpf(fmt, ...)
#   define _c4dbgpf_(fmt, ...)
#   define _c4dbgp(msg)
#   define _c4dbgp_(msg)
#   define _c4dbgq(msg)
#   define _c4presc(...)
#   define _c4prscalar(msg, scalar, keep_newlines)
#else
#   define _c4dbgt(fmt, ...)   do { if(_dbg_enabled()) {                \
                               this->_dbg ("{}:{}: "   fmt     , __FILE__, __LINE__, __VA_ARGS__); } } while(0)
#   define _c4dbgpf(fmt, ...)  _dbg_printf("{}:{}: "   fmt "\n", __FILE__, __LINE__, __VA_ARGS__)
#   define _c4dbgpf_(fmt, ...) _dbg_printf("{}:{}: "   fmt     , __FILE__, __LINE__, __VA_ARGS__)
#   define _c4dbgp(msg)        _dbg_printf("{}:{}: "   msg "\n", __FILE__, __LINE__             )
#   define _c4dbgp_(msg)       _dbg_printf("{}:{}: "   msg     , __FILE__, __LINE__             )
#   define _c4dbgq(msg)        _dbg_printf(msg "\n")
#   define _c4presc(...)       do { if(_dbg_enabled()) __c4presc(__VA_ARGS__); } while(0)
#   define _c4prscalar(msg, scalar, keep_newlines)                  \
    do {                                                            \
        _c4dbgpf_("{}: [{}]~~~", msg, scalar.len);                  \
        if(_dbg_enabled()) {                                        \
            __c4presc((scalar), (keep_newlines)); \
        }                                                           \
        _c4dbgq("~~~");                                             \
    } while(0)
#endif // RYML_DBG


//-----------------------------------------------------------------------------

#ifdef RYML_DBG

#if defined(C4_MSVC) || defined(C4_MINGW)
#include <malloc.h>
#else
#include <alloca.h>
#endif
#define RYML_LOGBUF_SIZE_MAX RYML_ERRMSG_SIZE

#include <c4/dump.hpp>

C4_SUPPRESS_WARNING_GCC_WITH_PUSH("-Wattributes")

namespace c4 {
inline bool& _dbg_enabled() { static bool enabled = true; return enabled; }
inline C4_NO_INLINE void _dbg_set_enabled(bool yes) { _dbg_enabled() = yes; }
inline C4_NO_INLINE void _dbg_dumper(csubstr s)
{
    _RYML_ASSERT_BASIC(s.str || !s.len);
    if(s.len)
        fwrite(s.str, 1, s.len, stdout);
}
template<class DumpFn, class ...Args>
C4_NO_INLINE void _dbg_dump(DumpFn &&dumpfn, csubstr fmt, Args&& ...args)
{
    DumpResults results;
    // try writing everything:
    {
        // buffer for converting individual arguments. it is defined
        // in a child scope to free it in case the buffer is too small
        // for any of the arguments.
        char writebuf[RYML_LOGBUF_SIZE];
        results = format_dump_resume(std::forward<DumpFn>(dumpfn), writebuf, fmt, std::forward<Args>(args)...);
    }
    // if any of the arguments failed to fit the buffer, allocate a
    // larger buffer (up to a limit) and resume writing.
    //
    // results.bufsize is set to the size of the largest element
    // serialized. Eg int(1) will require 1 byte.
    if(C4_UNLIKELY(results.bufsize > RYML_LOGBUF_SIZE))
    {
        const size_t bufsize = results.bufsize <= RYML_LOGBUF_SIZE_MAX ? results.bufsize : RYML_LOGBUF_SIZE_MAX;
        #ifdef C4_MSVC
        substr largerbuf = {static_cast<char*>(_alloca(bufsize)), bufsize};
        #else
        substr largerbuf = {static_cast<char*>(alloca(bufsize)), bufsize};
        #endif
        results = format_dump_resume(std::forward<DumpFn>(dumpfn), results, largerbuf, fmt, std::forward<Args>(args)...);
    }
}
template<class ...Args>
C4_NO_INLINE void _dbg_printf(csubstr fmt, Args const& ...args)
{
    if(_dbg_enabled())
        _dbg_dump(&_dbg_dumper, fmt, args...);
}
inline C4_NO_INLINE void __c4presc(csubstr s, bool keep_newlines=false)
{
    if(!_dbg_enabled())
        return; // LCOV_EXCL_LINE
    _RYML_ASSERT_BASIC(s.str || !s.len);
    size_t prev = 0;
    for(size_t i = 0; i < s.len; ++i)
    {
        switch(s.str[i])
        {
        case '\n'  : _dbg_dumper(s.range(prev, i)); _dbg_dumper("\\n"); if(keep_newlines) { _dbg_dumper("\n"); } prev = i+1; break;
        case '\t'  : _dbg_dumper(s.range(prev, i)); _dbg_dumper("\\t"); prev = i+1; break;
        case '\0'  : _dbg_dumper(s.range(prev, i)); _dbg_dumper("\\0"); prev = i+1; break;
        case '\r'  : _dbg_dumper(s.range(prev, i)); _dbg_dumper("\\r"); prev = i+1; break;
        case '\f'  : _dbg_dumper(s.range(prev, i)); _dbg_dumper("\\f"); prev = i+1; break;
        case '\b'  : _dbg_dumper(s.range(prev, i)); _dbg_dumper("\\b"); prev = i+1; break;
        case '\v'  : _dbg_dumper(s.range(prev, i)); _dbg_dumper("\\v"); prev = i+1; break;
        case '\a'  : _dbg_dumper(s.range(prev, i)); _dbg_dumper("\\a"); prev = i+1; break;
        case '\x1b': _dbg_dumper(s.range(prev, i)); _dbg_dumper("\\x1b"); prev = i+1; break;
        case -0x3e/*0xc2u*/:
            if(i+1 < s.len)
            {
                if(s.str[i+1] == -0x60/*0xa0u*/)
                {
                    _dbg_dumper(s.range(prev, i)); _dbg_dumper("\\_"); prev = i+1;
                }
                else if(s.str[i+1] == -0x7b/*0x85u*/)
                {
                    _dbg_dumper(s.range(prev, i)); _dbg_dumper("\\N"); prev = i+1;
                }
            }
            break;
        case -0x1e/*0xe2u*/:
            if(i+2 < s.len && s.str[i+1] == -0x80/*0x80u*/)
            {
                if(s.str[i+2] == -0x58/*0xa8u*/)
                {
                    _dbg_dumper(s.range(prev, i)); _dbg_dumper("\\L"); prev = i+1;
                }
                else if(s.str[i+2] == -0x57/*0xa9u*/)
                {
                    _dbg_dumper(s.range(prev, i)); _dbg_dumper("\\P"); prev = i+1;
                }
            }
            break;
        }
    }
    if(s.len > prev)
        _dbg_dumper(s.sub(prev));
}
inline C4_NO_INLINE void __c4presc(const char *s, size_t len, bool keep_newlines=false)
{
    __c4presc(csubstr(s, len), keep_newlines);
}
} // namespace c4

C4_SUPPRESS_WARNING_GCC_POP

#endif // RYML_DBG

#endif /* _C4_YML_DETAIL_DBGPRINT_HPP_ */

1	#ifndef _C4_YML_DETAIL_DBGPRINT_HPP_
2	#define _C4_YML_DETAIL_DBGPRINT_HPP_
3
4	#ifndef _C4_YML_COMMON_HPP_
5	#include "../common.hpp"
6	#endif
7
8	#ifdef RYML_DBG
9	#include <cstdio>
10	#endif
11
12
13	//-----------------------------------------------------------------------------
14	// debug prints
15
16	#ifndef RYML_DBG
17	# define _c4dbgt(fmt, ...)
18	# define _c4dbgpf(fmt, ...)
19	# define _c4dbgpf_(fmt, ...)
20	# define _c4dbgp(msg)
21	# define _c4dbgp_(msg)
22	# define _c4dbgq(msg)
23	# define _c4presc(...)
24	# define _c4prscalar(msg, scalar, keep_newlines)
25	#else
26	# define _c4dbgt(fmt, ...) do { if(_dbg_enabled()) { \
27	this->_dbg ("{}:{}: " fmt , __FILE__, __LINE__, __VA_ARGS__); } } while(0)
28	# define _c4dbgpf(fmt, ...) _dbg_printf("{}:{}: " fmt "\n", __FILE__, __LINE__, __VA_ARGS__)
29	# define _c4dbgpf_(fmt, ...) _dbg_printf("{}:{}: " fmt , __FILE__, __LINE__, __VA_ARGS__)
30	# define _c4dbgp(msg) _dbg_printf("{}:{}: " msg "\n", __FILE__, __LINE__ )
31	# define _c4dbgp_(msg) _dbg_printf("{}:{}: " msg , __FILE__, __LINE__ )
32	# define _c4dbgq(msg) _dbg_printf(msg "\n")
33	# define _c4presc(...) do { if(_dbg_enabled()) __c4presc(__VA_ARGS__); } while(0)
34	# define _c4prscalar(msg, scalar, keep_newlines) \
35	do { \
36	_c4dbgpf_("{}: [{}]~~~", msg, scalar.len); \
37	if(_dbg_enabled()) { \
38	__c4presc((scalar), (keep_newlines)); \
39	} \
40	_c4dbgq("~~~"); \
41	} while(0)
42	#endif // RYML_DBG
43
44
45	//-----------------------------------------------------------------------------
46
47	#ifdef RYML_DBG
48
49	#if defined(C4_MSVC) \|\| defined(C4_MINGW)
50	#include <malloc.h>
51	#else
52	#include <alloca.h>
53	#endif
54	#define RYML_LOGBUF_SIZE_MAX RYML_ERRMSG_SIZE
55
56	#include <c4/dump.hpp>
57
58	C4_SUPPRESS_WARNING_GCC_WITH_PUSH("-Wattributes")
59
60	namespace c4 {
61	inline bool& _dbg_enabled() { static bool enabled = true; return enabled; }	28,872,860✔
62	inline C4_NO_INLINE void _dbg_set_enabled(bool yes) { _dbg_enabled() = yes; }
63	inline C4_NO_INLINE void _dbg_dumper(csubstr s)	447,484,604✔
64	{
65	_RYML_ASSERT_BASIC(s.str \|\| !s.len);	447,484,604✔
66	if(s.len)	447,484,604✔
67	fwrite(s.str, 1, s.len, stdout);	412,443,424✔
68	}	447,484,604✔
69	template<class DumpFn, class ...Args>
70	C4_NO_INLINE void _dbg_dump(DumpFn &&dumpfn, csubstr fmt, Args&& ...args)	32,913,138✔
71	{
72	DumpResults results;	32,913,138✔
73	// try writing everything:
74	{
75	// buffer for converting individual arguments. it is defined
76	// in a child scope to free it in case the buffer is too small
77	// for any of the arguments.
78	char writebuf[RYML_LOGBUF_SIZE];
79	results = format_dump_resume(std::forward<DumpFn>(dumpfn), writebuf, fmt, std::forward<Args>(args)...);	64,836,814✔
80	}
81	// if any of the arguments failed to fit the buffer, allocate a
82	// larger buffer (up to a limit) and resume writing.
83	//
84	// results.bufsize is set to the size of the largest element
85	// serialized. Eg int(1) will require 1 byte.
86	if(C4_UNLIKELY(results.bufsize > RYML_LOGBUF_SIZE))	32,913,138✔
87	{
88	const size_t bufsize = results.bufsize <= RYML_LOGBUF_SIZE_MAX ? results.bufsize : RYML_LOGBUF_SIZE_MAX;	508✔
89	#ifdef C4_MSVC
90	substr largerbuf = {static_cast<char*>(_alloca(bufsize)), bufsize};
91	#else
92	substr largerbuf = {static_cast<char*>(alloca(bufsize)), bufsize};	508✔
93	#endif
94	results = format_dump_resume(std::forward<DumpFn>(dumpfn), results, largerbuf, fmt, std::forward<Args>(args)...);	1,016✔
95	}
96	}	32,913,138✔
97	template<class ...Args>
98	C4_NO_INLINE void _dbg_printf(csubstr fmt, Args const& ...args)	25,190,886✔
99	{
100	if(_dbg_enabled())	25,190,886✔
101	_dbg_dump(&_dbg_dumper, fmt, args...);	25,190,886✔
102	}	25,190,886✔
103	inline C4_NO_INLINE void __c4presc(csubstr s, bool keep_newlines=false)	214,128✔
104	{
105	if(!_dbg_enabled())	214,128✔
106	return; // LCOV_EXCL_LINE
107	_RYML_ASSERT_BASIC(s.str \|\| !s.len);	214,128✔
108	size_t prev = 0;	214,128✔
109	for(size_t i = 0; i < s.len; ++i)	4,087,076✔
110	{
111	switch(s.str[i])	3,872,948✔
112	{
113	case '\n' : _dbg_dumper(s.range(prev, i)); _dbg_dumper("\\n"); if(keep_newlines) { _dbg_dumper("\n"); } prev = i+1; break;	752,922✔
114	case '\t' : _dbg_dumper(s.range(prev, i)); _dbg_dumper("\\t"); prev = i+1; break;	101,034✔
115	case '\0' : _dbg_dumper(s.range(prev, i)); _dbg_dumper("\\0"); prev = i+1; break;	195,372✔
116	case '\r' : _dbg_dumper(s.range(prev, i)); _dbg_dumper("\\r"); prev = i+1; break;	162,402✔
117	case '\f' : _dbg_dumper(s.range(prev, i)); _dbg_dumper("\\f"); prev = i+1; break;	2,226✔
118	case '\b' : _dbg_dumper(s.range(prev, i)); _dbg_dumper("\\b"); prev = i+1; break;	570✔
119	case '\v' : _dbg_dumper(s.range(prev, i)); _dbg_dumper("\\v"); prev = i+1; break;	366✔
120	case '\a' : _dbg_dumper(s.range(prev, i)); _dbg_dumper("\\a"); prev = i+1; break;	84✔
121	case '\x1b': _dbg_dumper(s.range(prev, i)); _dbg_dumper("\\x1b"); prev = i+1; break;	84✔
122	case -0x3e/0xc2u/:	14✔
123	if(i+1 < s.len)	14✔
124	{
125	if(s.str[i+1] == -0x60/0xa0u/)	14✔
126	{
127	_dbg_dumper(s.range(prev, i)); _dbg_dumper("\\_"); prev = i+1;	8✔
128	}
129	else if(s.str[i+1] == -0x7b/0x85u/)	10✔
130	{
131	_dbg_dumper(s.range(prev, i)); _dbg_dumper("\\N"); prev = i+1;	8✔
132	}
133	}
134	break;	14✔
135	case -0x1e/0xe2u/:	836✔
136	if(i+2 < s.len && s.str[i+1] == -0x80/0x80u/)	836✔
137	{
138	if(s.str[i+2] == -0x58/0xa8u/)	4✔
139	{
NEW 140	_dbg_dumper(s.range(prev, i)); _dbg_dumper("\\L"); prev = i+1;	×
141	}
142	else if(s.str[i+2] == -0x57/0xa9u/)	4✔
143	{
NEW 144	_dbg_dumper(s.range(prev, i)); _dbg_dumper("\\P"); prev = i+1;	×
145	}
146	}
147	break;	836✔
148	}
149	}
150	if(s.len > prev)	214,128✔
151	_dbg_dumper(s.sub(prev));	160,356✔
152	}
153	inline C4_NO_INLINE void __c4presc(const char *s, size_t len, bool keep_newlines=false)
154	{
155	__c4presc(csubstr(s, len), keep_newlines);
156	}
157	} // namespace c4
158
159	C4_SUPPRESS_WARNING_GCC_POP
160
161	#endif // RYML_DBG
162
163	#endif /* _C4_YML_DETAIL_DBGPRINT_HPP_ */

biojppm / rapidyaml / 18649960093

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous