18073302777

Committed 28 Sep 2025 10:57AM UTC coverage: 97.448% (+0.1%) from 97.312%

Build # 18073302777

Build Type

Pull #536

github

Committed by

web-flow

Commit Message

Merge 4d67b9f24 into 9a044c88b

Pull Request Pull Request #536: Int handler

Coverage Stats

976 of 1001 new or added lines in 16 files covered. (97.5%)

2 existing lines in 1 file now uncovered.

13021 of 13362 relevant lines covered (97.45%)

765405.06 hits per line

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

98.47

/src_extra/c4/yml/extra/event_handler_ints_utils.cpp

#ifdef RYML_SINGLE_HEADER_INTS
    #ifndef _RYML_SINGLE_HEADER_AMALGAMATED_HPP_
        #include <ryml_ints.hpp>
    #endif
#elif defined(RYML_SINGLE_HEADER)
    #ifndef _RYML_SINGLE_HEADER_AMALGAMATED_HPP_
        #include <ryml_all.hpp>
    #endif
#endif

#ifndef _C4_YML_EXTRA_SCALAR_HPP_
#include "c4/yml/extra/scalar.hpp"
#endif

#ifndef _C4_YML_EXTRA_EVENT_HANDLER_INTS_UTILS_HPP_
#include "c4/yml/extra/event_handler_ints_utils.hpp"
#endif


C4_SUPPRESS_WARNING_GCC_WITH_PUSH("-Wold-style-cast")
C4_SUPPRESS_WARNING_CLANG_WITH_PUSH("-Wold-style-cast")
// NOLINTBEGIN(hicpp-signed-bitwise)

namespace c4 {
namespace yml {
namespace extra {

void print_events_ints(csubstr parsed_yaml, csubstr arena, ievt::DataType const* evts, ievt::DataType evts_sz)
{
    char buf[200];
    for(ievt::DataType evtpos = 0, evtnumber = 0;
        evtpos < evts_sz;
        ++evtnumber,
            evtpos += ((evts[evtpos] & ievt::WSTR) ? 3 : 1))
    {
        ievt::DataType evt = evts[evtpos];
        {
            csubstr str = ievt::mkstring(evt, buf);
            printf("[%d][%d] %.*s(0x%x)", evtnumber, evtpos, (int)str.len, str.str, evt);
        }
        if (evt & ievt::WSTR)
        {
            bool in_arena = evt & ievt::AREN;
            csubstr region = !in_arena ? parsed_yaml : arena;
            bool safe = (evts[evtpos + 1] >= 0)
                && (evts[evtpos + 2] >= 0)
                && (evts[evtpos + 1] <= (int)region.len)
                && ((evts[evtpos + 1] + evts[evtpos + 2]) <= (int)region.len);
            const char *str = safe ? (region.str + evts[evtpos + 1]) : "ERR!!!";
            int len = safe ? evts[evtpos + 2] : 6;
            printf(": %d [%d]~~~%.*s~~~", evts[evtpos+1], evts[evtpos+2], len, str);
            if(in_arena)
                printf(" (arenasz=%zu)", arena.len);
            else
                printf(" (srcsz=%zu)", parsed_yaml.len);
        }
        printf("\n");
    }
}

size_t emit_events_test_suite_from_ints(csubstr parsed_yaml,
                                        csubstr arena,
                                        ievt::DataType const* evts_ints,
                                        ievt::DataType evts_ints_sz,
                                        substr evts_test_suite)
{
    auto getstr = [&](ievt::DataType i){
        bool in_arena = evts_ints[i] & ievt::AREN;
        csubstr region = !in_arena ? parsed_yaml : arena;
        return region.sub((size_t)evts_ints[i+1], (size_t)evts_ints[i+2]);
    };
    size_t sz = 0;
    auto append = [&](csubstr s){
        size_t next = sz + s.len;
        if (s.len && (next <= evts_test_suite.len && evts_test_suite.len))
            memcpy(evts_test_suite.str + sz, s.str, s.len);
        sz = next;
    };
    bool has_tag = false;
    csubstr tag;
    auto maybe_append_tag = [&]{
        if(has_tag)
        {
            if(tag.begins_with('<'))
            {
                append(" ");
                append(tag);
            }
            else if(tag.begins_with("!<"))
            {
                append(" ");
                append(tag.sub(1));
            }
            else if(tag.begins_with('!'))
            {
                append(" <");
                append(tag);
                append(">");
            }
            else
            {
                append(" <!");
                append(tag);
                append(">");
            }
        }
        has_tag = false;
    };
    bool has_anchor = false;
    csubstr anchor;
    auto maybe_append_anchor = [&]{
        if(has_anchor)
        {
            append(" &");
            append(anchor);
        }
        has_anchor = false;
    };
    auto append_cont = [&](csubstr evt, csubstr style){
        append(evt);
        if(style.len)
        {
            append(" ");
            append(style);
        }
        maybe_append_anchor();
        maybe_append_tag();
        append("\n");
    };
    auto append_val = [&](csubstr evt, csubstr val){
        append("=VAL");
        maybe_append_anchor();
        maybe_append_tag();
        append(" ");
        append(evt);
        substr buf = sz <= evts_test_suite.len ? evts_test_suite.sub(sz) : evts_test_suite.last(0);
        sz += escape_scalar(buf, val);
        append("\n");
    };
    for(ievt::DataType i = 0; i < evts_ints_sz; )
    {
        ievt::DataType evt = evts_ints[i];
        if(evt & ievt::SCLR)
        {
            csubstr s = getstr(i);
            if(evt & ievt::SQUO)
                append_val("'", s);
            else if(evt & ievt::DQUO)
                append_val("\"", s);
            else if(evt & ievt::LITL)
                append_val("|", s);
            else if(evt & ievt::FOLD)
                append_val(">", s);
            else //if(evt & ievt::PLAI)
                append_val(":", s);
        }
        else if(evt & ievt::BSEQ)
        {
            if(evt & ievt::FLOW)
                append_cont("+SEQ", "[]");
            else
                append_cont("+SEQ", "");
        }
        else if(evt & ievt::ESEQ)
        {
            append("-SEQ\n");
        }
        else if(evt & ievt::BMAP)
        {
            if(evt & ievt::FLOW)
                append_cont("+MAP", "{}");
            else
                append_cont("+MAP", "");
        }
        else if(evt & ievt::EMAP)
        {
            append("-MAP\n");
        }
        else if(evt & ievt::ALIA)
        {
            append("=ALI *");
            append(getstr(i));
            append("\n");
        }
        else if(evt & ievt::TAG_)
        {
            has_tag = true;
            tag = getstr(i);
        }
        else if(evt & ievt::ANCH)
        {
            has_anchor = true;
            anchor = getstr(i);
        }
        else if(evt & ievt::BDOC)
        {
            if(evt & ievt::EXPL)
                append("+DOC ---\n");
            else
                append("+DOC\n");
        }
        else if(evt & ievt::EDOC)
        {
            if(evt & ievt::EXPL)
                append("-DOC ...\n");
            else
                append("-DOC\n");
        }
        else if(evt & ievt::BSTR)
        {
             append("+STR\n");
        }
        else if(evt & ievt::ESTR)
        {
            append("-STR\n");
        }

        i += (evt & ievt::WSTR) ? 3 : 1;
    }
    return sz;
}

} // namespace extra
} // namespace yml
} // namespace c4

// NOLINTEND(hicpp-signed-bitwise)
C4_SUPPRESS_WARNING_CLANG_POP
C4_SUPPRESS_WARNING_GCC_POP

1	#ifdef RYML_SINGLE_HEADER_INTS
2	#ifndef _RYML_SINGLE_HEADER_AMALGAMATED_HPP_
3	#include <ryml_ints.hpp>
4	#endif
5	#elif defined(RYML_SINGLE_HEADER)
6	#ifndef _RYML_SINGLE_HEADER_AMALGAMATED_HPP_
7	#include <ryml_all.hpp>
8	#endif
9	#endif
10
11	#ifndef _C4_YML_EXTRA_SCALAR_HPP_
12	#include "c4/yml/extra/scalar.hpp"
13	#endif
14
15	#ifndef _C4_YML_EXTRA_EVENT_HANDLER_INTS_UTILS_HPP_
16	#include "c4/yml/extra/event_handler_ints_utils.hpp"
17	#endif
18
19
20	C4_SUPPRESS_WARNING_GCC_WITH_PUSH("-Wold-style-cast")
21	C4_SUPPRESS_WARNING_CLANG_WITH_PUSH("-Wold-style-cast")
22	// NOLINTBEGIN(hicpp-signed-bitwise)
23
24	namespace c4 {
25	namespace yml {
26	namespace extra {
27
28	void print_events_ints(csubstr parsed_yaml, csubstr arena, ievt::DataType const* evts, ievt::DataType evts_sz)	13,916✔
29	{
30	char buf[200];
31	for(ievt::DataType evtpos = 0, evtnumber = 0;	13,916✔
32	evtpos < evts_sz;	214,664✔
33	++evtnumber,	200,748✔
34	evtpos += ((evts[evtpos] & ievt::WSTR) ? 3 : 1))	200,748✔
35	{
36	ievt::DataType evt = evts[evtpos];	200,748✔
37	{
38	csubstr str = ievt::mkstring(evt, buf);	200,748✔
39	printf("[%d][%d] %.*s(0x%x)", evtnumber, evtpos, (int)str.len, str.str, evt);	200,748✔
40	}
41	if (evt & ievt::WSTR)	200,748✔
42	{
43	bool in_arena = evt & ievt::AREN;	85,004✔
44	csubstr region = !in_arena ? parsed_yaml : arena;	85,004✔
45	bool safe = (evts[evtpos + 1] >= 0)	170,008✔
46	&& (evts[evtpos + 2] >= 0)	85,004✔
47	&& (evts[evtpos + 1] <= (int)region.len)	85,004✔
48	&& ((evts[evtpos + 1] + evts[evtpos + 2]) <= (int)region.len);	170,008✔
49	const char *str = safe ? (region.str + evts[evtpos + 1]) : "ERR!!!";	85,004✔
50	int len = safe ? evts[evtpos + 2] : 6;	85,004✔
51	printf(": %d [%d]~~~%.*s~~~", evts[evtpos+1], evts[evtpos+2], len, str);	85,004✔
52	if(in_arena)	85,004✔
53	printf(" (arenasz=%zu)", arena.len);	512✔
54	else
55	printf(" (srcsz=%zu)", parsed_yaml.len);	84,492✔
56	}
57	printf("\n");	200,748✔
58	}
59	}	13,916✔
60
61	size_t emit_events_test_suite_from_ints(csubstr parsed_yaml,	63,712✔
62	csubstr arena,
63	ievt::DataType const* evts_ints,
64	ievt::DataType evts_ints_sz,
65	substr evts_test_suite)
66	{
67	auto getstr = [&](ievt::DataType i){	411,296✔
68	bool in_arena = evts_ints[i] & ievt::AREN;	411,296✔
69	csubstr region = !in_arena ? parsed_yaml : arena;	411,296✔
70	return region.sub((size_t)evts_ints[i+1], (size_t)evts_ints[i+2]);	822,592✔
71	};	63,712✔
72	size_t sz = 0;	63,712✔
73	auto append = [&](csubstr s){	2,244,720✔
74	size_t next = sz + s.len;	2,244,720✔
75	if (s.len && (next <= evts_test_suite.len && evts_test_suite.len))	2,244,720✔
76	memcpy(evts_test_suite.str + sz, s.str, s.len);	1,122,352✔
77	sz = next;	2,244,720✔
78	};	2,308,432✔
79	bool has_tag = false;	63,712✔
80	csubstr tag;	63,712✔
81	auto maybe_append_tag = [&]{	454,256✔
82	if(has_tag)	454,256✔
83	{
84	if(tag.begins_with('<'))	39,632✔
85	{
NEW 86	append(" ");	×
NEW 87	append(tag);	×
88	}
89	else if(tag.begins_with("!<"))	39,632✔
90	{
91	append(" ");	560✔
92	append(tag.sub(1));	1,120✔
93	}
94	else if(tag.begins_with('!'))	39,072✔
95	{
96	append(" <");	37,552✔
97	append(tag);	37,552✔
98	append(">");	37,552✔
99	}
100	else
101	{
102	append(" <!");	1,520✔
103	append(tag);	1,520✔
104	append(">");	1,520✔
105	}
106	}
107	has_tag = false;	454,256✔
108	};	517,968✔
109	bool has_anchor = false;	63,712✔
110	csubstr anchor;	63,712✔
111	auto maybe_append_anchor = [&]{	454,256✔
112	if(has_anchor)	454,256✔
113	{
114	append(" &");	39,408✔
115	append(anchor);	39,408✔
116	}
117	has_anchor = false;	454,256✔
118	};	517,968✔
119	auto append_cont = [&](csubstr evt, csubstr style){	128,080✔
120	append(evt);	128,080✔
121	if(style.len)	128,080✔
122	{
123	append(" ");	34,912✔
124	append(style);	34,912✔
125	}
126	maybe_append_anchor();	128,080✔
127	maybe_append_tag();	128,080✔
128	append("\n");	128,080✔
129	};	191,792✔
130	auto append_val = [&](csubstr evt, csubstr val){	326,176✔
131	append("=VAL");	326,176✔
132	maybe_append_anchor();	326,176✔
133	maybe_append_tag();	326,176✔
134	append(" ");	326,176✔
135	append(evt);	326,176✔
136	substr buf = sz <= evts_test_suite.len ? evts_test_suite.sub(sz) : evts_test_suite.last(0);	489,264✔
137	sz += escape_scalar(buf, val);	326,176✔
138	append("\n");	326,176✔
139	};	326,176✔
140	for(ievt::DataType i = 0; i < evts_ints_sz; )	1,001,728✔
141	{
142	ievt::DataType evt = evts_ints[i];	938,016✔
143	if(evt & ievt::SCLR)	938,016✔
144	{
145	csubstr s = getstr(i);	326,176✔
146	if(evt & ievt::SQUO)	326,176✔
147	append_val("'", s);	6,256✔
148	else if(evt & ievt::DQUO)	319,920✔
149	append_val("\"", s);	15,344✔
150	else if(evt & ievt::LITL)	304,576✔
151	append_val("\|", s);	9,456✔
152	else if(evt & ievt::FOLD)	295,120✔
153	append_val(">", s);	5,648✔
154	else //if(evt & ievt::PLAI)
155	append_val(":", s);	289,472✔
156	}
157	else if(evt & ievt::BSEQ)	611,840✔
158	{
159	if(evt & ievt::FLOW)	42,016✔
160	append_cont("+SEQ", "[]");	15,584✔
161	else
162	append_cont("+SEQ", "");	26,432✔
163	}
164	else if(evt & ievt::ESEQ)	569,824✔
165	{
166	append("-SEQ\n");	42,016✔
167	}
168	else if(evt & ievt::BMAP)	527,808✔
169	{
170	if(evt & ievt::FLOW)	86,064✔
171	append_cont("+MAP", "{}");	19,328✔
172	else
173	append_cont("+MAP", "");	66,736✔
174	}
175	else if(evt & ievt::EMAP)	441,744✔
176	{
177	append("-MAP\n");	86,064✔
178	}
179	else if(evt & ievt::ALIA)	355,680✔
180	{
181	append("=ALI *");	6,080✔
182	append(getstr(i));	6,080✔
183	append("\n");	6,080✔
184	}
185	else if(evt & ievt::TAG_)	349,600✔
186	{
187	has_tag = true;	39,632✔
188	tag = getstr(i);	39,632✔
189	}
190	else if(evt & ievt::ANCH)	309,968✔
191	{
192	has_anchor = true;	39,408✔
193	anchor = getstr(i);	39,408✔
194	}
195	else if(evt & ievt::BDOC)	270,560✔
196	{
197	if(evt & ievt::EXPL)	71,568✔
198	append("+DOC ---\n");	22,144✔
199	else
200	append("+DOC\n");	49,424✔
201	}
202	else if(evt & ievt::EDOC)	198,992✔
203	{
204	if(evt & ievt::EXPL)	71,568✔
205	append("-DOC ...\n");	5,264✔
206	else
207	append("-DOC\n");	66,304✔
208	}
209	else if(evt & ievt::BSTR)	127,424✔
210	{
211	append("+STR\n");	63,712✔
212	}
213	else if(evt & ievt::ESTR)	63,712✔
214	{
215	append("-STR\n");	63,712✔
216	}
217
218	i += (evt & ievt::WSTR) ? 3 : 1;	938,016✔
219	}
220	return sz;	63,712✔
221	}
222
223	} // namespace extra
224	} // namespace yml
225	} // namespace c4
226
227	// NOLINTEND(hicpp-signed-bitwise)
228	C4_SUPPRESS_WARNING_CLANG_POP
229	C4_SUPPRESS_WARNING_GCC_POP

biojppm / rapidyaml / 18073302777

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