#201

Committed 10 Jun 2025 02:39PM UTC coverage: 59.995% (-2.5%) from 62.506%

Build # #201

Build Type

push

travis-ci

Committed by

Nic30

Commit Message

Merge remote-tracking branch 'origin/mesonbuild'

Run Details

109 of 127 new or added lines in 14 files covered. (85.83%)

11 existing lines in 6 files now uncovered.

41572 of 69293 relevant lines covered (59.99%)

1047819.11 hits per line

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

88.57

/src/svConvertor/delayParser.cpp

#include <hdlConvertor/svConvertor/delayParser.h>
#include <hdlConvertor/svConvertor/exprParser.h>
#include <hdlConvertor/svConvertor/literalParser.h>
#include <hdlConvertor/svConvertor/eventExprParser.h>
#include <hdlConvertor/notImplementedLogger.h>
#include <hdlConvertor/createObject.h>



namespace hdlConvertor {
namespace sv {

using namespace std;
using namespace hdlConvertor::hdlAst;

VerDelayParser::HdlEventList VerDelayParser::visitEvent_control(
                sv2017Parser::Event_controlContext *ctx) {
        // event_control:
        //    AT ( LPAREN ( MUL
        //                 | event_expression
        //                 ) RPAREN
        //         | MUL
        //         | package_or_class_scoped_hier_id_with_select
        //       );
        auto res = make_unique<vector<unique_ptr<iHdlExprItem>>>();
        if (ctx->MUL()) {
                res->push_back(HdlValueSymbol::all());
                return res;
        }
        auto pid = ctx->package_or_class_scoped_hier_id_with_select();
        if (pid) {
                VerExprParser ep(this);
                res->push_back(
                                ep.visitPackage_or_class_scoped_hier_id_with_select(pid));
                return res;
        }
        auto ee = ctx->event_expression();
        assert(ee);
        VerEventExprParser eep(this);
        eep.visitEvent_expression(ee, *res);
        return res;
}

pair<unique_ptr<iHdlExprItem>, unique_ptr<vector<unique_ptr<iHdlExprItem>>>> VerDelayParser::visitProcedural_timing_control(
                sv2017Parser::Procedural_timing_controlContext *ctx) {
        // procedural_timing_control:
        //    delay_control
        //     | event_control
        //     | cycle_delay
        //     | cycle_delay_range
        // ;
        auto _dc = ctx->delay_control();
        if (_dc) {
                auto dc = visitDelay_control(_dc);
                return {move(dc), nullptr};
        }
        auto _ec = ctx->event_control();
        if (_ec) {
                auto ec = visitEvent_control(_ec);
                return {nullptr, move(ec)};
        }
        if (ctx->cycle_delay()) {
                NotImplementedLogger::print(
                                "VerDelayParser.visitProcedural_timing_control.cycle_delay",
                                ctx);
                return {create_object<HdlExprNotImplemented>(ctx), nullptr};
        }
        assert(ctx->cycle_delay_range());
        NotImplementedLogger::print(
                        "VerDelayParser.visitProcedural_timing_control.cycle_delay_range",
                        ctx);
        return {create_object<HdlExprNotImplemented>(ctx), nullptr};
}

unique_ptr<iHdlExprItem> VerDelayParser::visitDelay_control(
                sv2017Parser::Delay_controlContext *ctx) {
        // delay_control:
        //     HASH ( LPAREN mintypmax_expression RPAREN
        //            | delay_value
        //          );
        auto dv = ctx->delay_value();
        if (dv)
                return visitDelay_value(dv);
        else {
                auto me = ctx->mintypmax_expression();
                VerExprParser ep(this);
                return ep.visitMintypmax_expression(me);
        }
}

unique_ptr<iHdlExprItem> VerDelayParser::visitDelay_value(
                sv2017Parser::Delay_valueContext *ctx) {
        // delay_value:
        //     UNSIGNED_NUMBER
        //     | TIME_LITERAL
        //     | KW_1STEP
        //     | real_number
        //     | ps_identifier
        //     | hierarchical_identifier
        //     ;
        auto un = ctx->UNSIGNED_NUMBER();
        if (un) {
                return VerLiteralParser::visitUNSIGNED_NUMBER(un);
        }
        auto tl = ctx->TIME_LITERAL();
        if (tl) {
                return VerLiteralParser::visitTIME_LITERAL(tl);
        }
        if (ctx->KW_1STEP())
                return create_object<HdlValueId>(ctx, "1step");
        auto r = ctx->real_number();
        if (r) {
                return VerLiteralParser::visitReal_number(r);
        }
        auto pi = ctx->ps_identifier();
        if (pi) {
                return VerExprParser(this).visitPs_identifier(pi);
        }
        auto hi = ctx->hierarchical_identifier();
        assert(hi);
        return VerExprParser(this).visitHierarchical_identifier(hi);
}

pair<unique_ptr<iHdlExprItem>, VerDelayParser::HdlEventList> VerDelayParser::visitDelay_or_event_control(
                sv2017Parser::Delay_or_event_controlContext *ctx) {
        // delay_or_event_control:
        //     delay_control
        //     | ( KW_REPEAT LPAREN expression RPAREN )? event_control
        // ;
        auto _d = ctx->delay_control();
        if (_d) {
                auto d = visitDelay_control(_d);
                return {move(d), nullptr};
        }
        auto ec = ctx->event_control();
        auto e = ctx->expression();
        if (e) {
                NotImplementedLogger::print(
                                "VerStatementParser.visitDelay_or_event_control.repeat", e);
        }
        return {nullptr, visitEvent_control(ec)};
}

}
}

1	#include <hdlConvertor/svConvertor/delayParser.h>
2	#include <hdlConvertor/svConvertor/exprParser.h>
3	#include <hdlConvertor/svConvertor/literalParser.h>
4	#include <hdlConvertor/svConvertor/eventExprParser.h>
5	#include <hdlConvertor/notImplementedLogger.h>
6	#include <hdlConvertor/createObject.h>
7
8
9
10	namespace hdlConvertor {
11	namespace sv {
12
13	using namespace std;
14	using namespace hdlConvertor::hdlAst;
15
16	VerDelayParser::HdlEventList VerDelayParser::visitEvent_control(	5,991✔
17	sv2017Parser::Event_controlContext *ctx) {
18	// event_control:
19	// AT ( LPAREN ( MUL
20	// \| event_expression
21	// ) RPAREN
22	// \| MUL
23	// \| package_or_class_scoped_hier_id_with_select
24	// );
25	auto res = make_unique<vector<unique_ptr<iHdlExprItem>>>();	5,991✔
26	if (ctx->MUL()) {	5,991✔
27	res->push_back(HdlValueSymbol::all());	447✔
28	return res;	447✔
29	}
30	auto pid = ctx->package_or_class_scoped_hier_id_with_select();	5,544✔
31	if (pid) {	5,544✔
32	VerExprParser ep(this);	58✔
33	res->push_back(	116✔
34	ep.visitPackage_or_class_scoped_hier_id_with_select(pid));	116✔
35	return res;	58✔
36	}
37	auto ee = ctx->event_expression();	5,486✔
38	assert(ee);	5,486✔
39	VerEventExprParser eep(this);	5,486✔
40	eep.visitEvent_expression(ee, *res);	5,486✔
41	return res;	5,486✔
42	}	×
43
44	pair<unique_ptr<iHdlExprItem>, unique_ptr<vector<unique_ptr<iHdlExprItem>>>> VerDelayParser::visitProcedural_timing_control(	19,180✔
45	sv2017Parser::Procedural_timing_controlContext *ctx) {
46	// procedural_timing_control:
47	// delay_control
48	// \| event_control
49	// \| cycle_delay
50	// \| cycle_delay_range
51	// ;
52	auto _dc = ctx->delay_control();	19,180✔
53	if (_dc) {	19,180✔
54	auto dc = visitDelay_control(_dc);	13,266✔
55	return {move(dc), nullptr};	13,266✔
56	}	13,266✔
57	auto _ec = ctx->event_control();	5,914✔
58	if (_ec) {	5,914✔
59	auto ec = visitEvent_control(_ec);	5,913✔
60	return {nullptr, move(ec)};	5,913✔
61	}	5,913✔
62	if (ctx->cycle_delay()) {	1✔
63	NotImplementedLogger::print(	1✔
64	"VerDelayParser.visitProcedural_timing_control.cycle_delay",
65	ctx);
66	return {create_object<HdlExprNotImplemented>(ctx), nullptr};	1✔
67	}
68	assert(ctx->cycle_delay_range());	×
69	NotImplementedLogger::print(	×
70	"VerDelayParser.visitProcedural_timing_control.cycle_delay_range",
71	ctx);
72	return {create_object<HdlExprNotImplemented>(ctx), nullptr};	×
73	}
74
75	unique_ptr<iHdlExprItem> VerDelayParser::visitDelay_control(	13,619✔
76	sv2017Parser::Delay_controlContext *ctx) {
77	// delay_control:
78	// HASH ( LPAREN mintypmax_expression RPAREN
79	// \| delay_value
80	// );
81	auto dv = ctx->delay_value();	13,619✔
82	if (dv)	13,619✔
83	return visitDelay_value(dv);	13,498✔
84	else {
85	auto me = ctx->mintypmax_expression();	121✔
86	VerExprParser ep(this);	121✔
87	return ep.visitMintypmax_expression(me);	121✔
88	}
89	}
90
91	unique_ptr<iHdlExprItem> VerDelayParser::visitDelay_value(	13,498✔
92	sv2017Parser::Delay_valueContext *ctx) {
93	// delay_value:
94	// UNSIGNED_NUMBER
95	// \| TIME_LITERAL
96	// \| KW_1STEP
97	// \| real_number
98	// \| ps_identifier
99	// \| hierarchical_identifier
100	// ;
101	auto un = ctx->UNSIGNED_NUMBER();	13,498✔
102	if (un) {	13,498✔
103	return VerLiteralParser::visitUNSIGNED_NUMBER(un);	13,133✔
104	}
105	auto tl = ctx->TIME_LITERAL();	365✔
106	if (tl) {	365✔
107	return VerLiteralParser::visitTIME_LITERAL(tl);	16✔
108	}
109	if (ctx->KW_1STEP())	349✔
110	return create_object<HdlValueId>(ctx, "1step");	×
111	auto r = ctx->real_number();	349✔
112	if (r) {	349✔
113	return VerLiteralParser::visitReal_number(r);	241✔
114	}
115	auto pi = ctx->ps_identifier();	108✔
116	if (pi) {	108✔
117	return VerExprParser(this).visitPs_identifier(pi);	108✔
118	}
NEW 119	auto hi = ctx->hierarchical_identifier();	×
NEW 120	assert(hi);	×
NEW 121	return VerExprParser(this).visitHierarchical_identifier(hi);	×
122	}
123
124	pair<unique_ptr<iHdlExprItem>, VerDelayParser::HdlEventList> VerDelayParser::visitDelay_or_event_control(	431✔
125	sv2017Parser::Delay_or_event_controlContext *ctx) {
126	// delay_or_event_control:
127	// delay_control
128	// \| ( KW_REPEAT LPAREN expression RPAREN )? event_control
129	// ;
130	auto _d = ctx->delay_control();	431✔
131	if (_d) {	431✔
132	auto d = visitDelay_control(_d);	353✔
133	return {move(d), nullptr};	353✔
134	}	353✔
135	auto ec = ctx->event_control();	78✔
136	auto e = ctx->expression();	78✔
137	if (e) {	78✔
138	NotImplementedLogger::print(	40✔
139	"VerStatementParser.visitDelay_or_event_control.repeat", e);
140	}
141	return {nullptr, visitEvent_control(ec)};	78✔
142	}
143
144	}
145	}

Nic30 / hdlConvertor / #201

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