#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

89.96

/src/svConvertor/typeParser.cpp

#include <hdlConvertor/svConvertor/typeParser.h>

#include <hdlConvertor/createObject.h>
#include <hdlConvertor/notImplementedLogger.h>
#include <hdlConvertor/hdlAst/hdlOpType.h>
#include <hdlConvertor/svConvertor/utils.h>
#include <hdlConvertor/svConvertor/exprParser.h>
#include <hdlConvertor/hdlAst/hdlOp.h>


namespace hdlConvertor {
namespace sv {

using namespace std;
using namespace hdlConvertor::hdlAst;


unique_ptr<iHdlExprItem> VerTypeParser::visitType_reference(
                sv2017Parser::Type_referenceContext *ctx) {
        // type_reference:
        //     KW_TYPE LPAREN (
        //         expression
        //         | data_type
        //     ) RPAREN
        // ;
        unique_ptr<iHdlExprItem> res = nullptr;
        auto e = ctx->expression();
        if (e) {
                VerExprParser ep(this);
                res = ep.visitExpression(e);
        } else {
                auto dt = ctx->data_type();
                assert(dt);
                res = visitData_type(dt);
        }
        return create_object<HdlOp>(ctx, HdlOpType::TYPE_OF, move(res));
}

unique_ptr<iHdlExprItem> VerTypeParser::visitInteger_type(
                sv2017Parser::Integer_typeContext *ctx) {
        // integer_type:
        //     integer_vector_type
        //     | integer_atom_type
        // ;
        auto ivt = ctx->integer_vector_type();
        if (ivt)
                return visitInteger_vector_type(ivt);
        auto iat = ctx->integer_atom_type();
        assert(iat);
        return visitInteger_atom_type(iat);
}

unique_ptr<iHdlExprItem> VerTypeParser::visitNon_integer_type(
                sv2017Parser::Non_integer_typeContext *ctx) {
        // non_integer_type:
        //     KW_SHORTREAL
        //     | KW_REAL
        //     | KW_REALTIME
        // ;
        return create_object<HdlValueId>(ctx, ctx->getText());
}
unique_ptr<iHdlExprItem> VerTypeParser::visitInteger_atom_type(
                sv2017Parser::Integer_atom_typeContext *ctx) {
        // integer_atom_type:
        //     KW_BYTE
        //     | KW_SHORTINT
        //     | KW_INT
        //     | KW_LONGINT
        //     | KW_INTEGER
        //     | KW_TIME
        // ;
        return create_object<HdlValueId>(ctx, ctx->getText());
}

unique_ptr<iHdlExprItem> VerTypeParser::visitInteger_vector_type(
                sv2017Parser::Integer_vector_typeContext *ctx) {
        // integer_vector_type:
        //     KW_BIT
        //     | KW_LOGIC
        //     | KW_REG
        // ;
        return Utils::mkWireT(ctx, create_object<HdlValueId>(ctx, ctx->getText()),
                        HdlValueSymbol::null(), SIGNING_VAL::NO_SIGN);
}

unique_ptr<iHdlExprItem> VerTypeParser::visitData_type_primitive(
                sv2017Parser::Data_type_primitiveContext *ctx) {
        // data_type_primitive:
        //     integer_type ( signing )?
        //     | non_integer_type
        // ;
        auto it = ctx->integer_type();
        if (it) {
                auto t = visitInteger_type(it);
                auto sig = ctx->signing(); // [TODO] wire in correct format (parametrization <t, widt, sign>)
                if (sig) {
                        auto _sig = visitSigning(sig);
                        if (_sig != SIGNING_VAL::NO_SIGN) {
                                auto c = dynamic_cast<HdlOp*>(t.get());
                                auto sign = Utils::signing(_sig);
                                if (c && c->op == HdlOpType::PARAMETRIZATION
                                                && c->operands.size() == 3) {
                                        // fill up sign flag for wire/reg types
                                        c->operands[2] = move(sign);
                                } else {
                                        // specify sign for rest of the types
                                        vector<unique_ptr<iHdlExprItem>> args;
                                        args.push_back(
                                                        create_object<HdlOp>(ctx,
                                                                        make_unique<HdlValueId>("signed"),
                                                                        HdlOpType::MAP_ASSOCIATION, move(sign)));
                                        t = HdlOp::parametrization(ctx, move(t), args);
                                }
                        }
                }
                return t;
        } else {
                auto nit = ctx->non_integer_type();
                assert(nit);
                return visitNon_integer_type(nit);
        }
}

unique_ptr<iHdlExprItem> VerTypeParser::visitData_type(
                sv2017Parser::Data_typeContext *ctx) {
        // data_type:
        //     KW_STRING
        //     | KW_CHANDLE
        //     | KW_VIRTUAL ( KW_INTERFACE )? identifier ( parameter_value_assignment )? ( DOT identifier )?
        //     | KW_EVENT
        //     | ( data_type_primitive
        //         | KW_ENUM ( enum_base_type )?
        //            LBRACE enum_name_declaration  ( COMMA enum_name_declaration )* RBRACE
        //         | struct_union ( KW_PACKED ( signing )? )?
        //             LBRACE ( struct_union_member )+ RBRACE
        //         | package_or_class_scoped_path
        //       ) ( variable_dimension )*
        //     | type_reference
        // ;
        auto _s = ctx->KW_STRING();
        if (_s)
                return create_object<HdlValueId>(_s, "string");

        auto _c = ctx->KW_CHANDLE();
        if (_c)
                return create_object<HdlValueId>(_c, "chandle");

        if (ctx->KW_VIRTUAL()) {
                NotImplementedLogger::print("VerTypeParser.visitData_type - virtual",
                                ctx);
                auto ids = ctx->identifier();
                VerExprParser ep(this);
                auto t = ep.visitIdentifier(ids[0]);
                auto pva = ctx->parameter_value_assignment();
                if (pva) {
                        auto p = ep.visitParameter_value_assignment(pva);
                        t = HdlOp::parametrization(ctx, move(t), p);
                }
                if (ids.size() == 2) {
                        auto id = ep.visitIdentifier(ids[1]);
                        t = create_object<HdlOp>(ids[1], move(t), HdlOpType::DOT, move(id));
                } else {
                        assert(ids.size() == 1);
                }
                return t;
        }

        auto _e = ctx->KW_EVENT();
        if (_e)
                return create_object<HdlValueId>(_e, "event");
        auto _tr = ctx->type_reference();
        if (_tr) {
                return visitType_reference(_tr);
        }

        auto dtp = ctx->data_type_primitive();
        unique_ptr<iHdlExprItem> t = nullptr;
        if (dtp) {
                t = visitData_type_primitive(dtp);
        } else if (ctx->KW_ENUM()) {
                NotImplementedLogger::print("VerTypeParser.visitData_type - enum", ctx);
                t = create_object<HdlExprNotImplemented>(ctx);
        } else if (ctx->struct_union()) {
                NotImplementedLogger::print(
                                "VerTypeParser.visitData_type - struct or union", ctx);
                t = create_object<HdlExprNotImplemented>(ctx);
        } else {
                VerExprParser ep(this);
                auto _p = ctx->package_or_class_scoped_path();
                assert(_p);
                t = ep.visitPackage_or_class_scoped_path(_p);
        }
        VerTypeParser tp(this);
        auto vds = ctx->variable_dimension();
        t = tp.applyVariable_dimension(move(t), vds);
        return t;
}

unique_ptr<iHdlExprItem> VerTypeParser::visitData_type_or_implicit(
                sv2017Parser::Data_type_or_implicitContext *ctx,
                unique_ptr<iHdlExprItem> net_type) {
        // data_type_or_implicit:
        //     data_type
        //     | implicit_data_type
        // ;
        if (!ctx)
                return HdlValueSymbol::type_auto();

        auto dt = ctx->data_type();
        if (dt)
                return visitData_type(dt);
        auto idt = ctx->implicit_data_type();
        assert(idt);
        return visitImplicit_data_type(idt, move(net_type));
}

unique_ptr<iHdlExprItem> VerTypeParser::visitUnpacked_dimension(
                sv2017Parser::Unpacked_dimensionContext *ctx) {
        // unpacked_dimension: LSQUARE_BR range_expression RSQUARE_BR;
        auto ra = ctx->range_expression();
        return VerExprParser(this).visitRange_expression(ra);
}

unique_ptr<iHdlExprItem> VerTypeParser::applyUnpacked_dimension(
                unique_ptr<iHdlExprItem> base_expr,
                vector<sv2017Parser::Unpacked_dimensionContext*> &uds) {
        for (auto _ud : uds) {
                auto ud = visitUnpacked_dimension(_ud);
                base_expr = create_object<HdlOp>(_ud, move(base_expr), HdlOpType::INDEX,
                                move(ud));
        }
        return base_expr;
}

unique_ptr<iHdlExprItem> VerTypeParser::applyVariable_dimension(
                unique_ptr<iHdlExprItem> base_expr,
                vector<sv2017Parser::Variable_dimensionContext*> &vds) {
        // optionally fill up width of wire/reg datatypes
        auto wire_reg_parametrization = dynamic_cast<HdlOp*>(base_expr.get());
        if (wire_reg_parametrization) {
                if (wire_reg_parametrization->op != HdlOpType::PARAMETRIZATION) {
                        wire_reg_parametrization = nullptr;
                } else if (wire_reg_parametrization->operands.size() != 3) {
                        wire_reg_parametrization = nullptr;

                } else {
                        auto w =
                                        dynamic_cast<HdlValueSymbol*>(wire_reg_parametrization->operands[1].get());
                        if (w) {
                                if (w->symb != HdlValueSymbol_t::symb_NULL)
                                        wire_reg_parametrization = nullptr;
                        } else {
                                wire_reg_parametrization = nullptr;
                        }
                }
        }

        for (auto _vd : vds) {
                if (wire_reg_parametrization) {
                        auto d = _visitVariable_dimension(_vd);
                        if (d == nullptr)
                                d = HdlValueSymbol::null();
                        wire_reg_parametrization->operands[1] = move(d);

                        wire_reg_parametrization = nullptr;
                        continue;
                }
                base_expr = visitVariable_dimension(_vd, move(base_expr));
        }
        return base_expr;
}

unique_ptr<iHdlExprItem> VerTypeParser::visitPacked_dimension(
                sv2017Parser::Packed_dimensionContext *ctx) {
        // packed_dimension: LSQUARE_BR  ( range_expression )? RSQUARE_BR;
        auto ra = ctx->range_expression();
        if (ra)
                return VerExprParser(this).visitRange_expression(ra);
        return nullptr;
}

SIGNING_VAL VerTypeParser::visitSigning(sv2017Parser::SigningContext *ctx) {
        // signing:
        //     KW_SIGNED
        //     | KW_UNSIGNED
        // ;
        if (ctx->KW_SIGNED()) {
                return SIGNING_VAL::SIGNED;
        } else {
                assert(ctx->KW_UNSIGNED());
                return SIGNING_VAL::UNSIGNED;
        }
}

unique_ptr<iHdlExprItem> VerTypeParser::visitImplicit_data_type(
                sv2017Parser::Implicit_data_typeContext *ctx,
                unique_ptr<iHdlExprItem> net_type) {
        // implicit_data_type:
        //     signing ( packed_dimension )*
        //     | ( packed_dimension )+
        // ;
        if (!ctx) {
                if (net_type)
                        return net_type;
                else
                        return HdlValueSymbol::type_auto();
        }
        auto s = ctx->signing();
        SIGNING_VAL is_signed = SIGNING_VAL::NO_SIGN;
        auto pds = ctx->packed_dimension();
        if (s) {
                is_signed = visitSigning(s);
        }
        unique_ptr<iHdlExprItem> e = nullptr;
        auto it = pds.begin();
        if (it != pds.end()) {
                auto r0 = visitPacked_dimension(*it);
                if (r0 == nullptr)
                        r0 = HdlValueSymbol::null();
                e = Utils::mkWireT(*it, move(net_type), move(r0), is_signed);
                ++it;
        } else {
                e = Utils::mkWireT(nullptr, HdlValueSymbol::null(), is_signed);
        }
        for (; it != pds.end(); ++it) {
                auto pd = visitPacked_dimension(*it);
                if (pd) {
                        e = create_object<HdlOp>(*it, move(e), HdlOpType::INDEX, move(pd));
                } else {
                        e = create_object<HdlOp>(*it, HdlOpType::INDEX, move(e));

                }
        }
        return e;
}
unique_ptr<iHdlExprItem> VerTypeParser::_visitVariable_dimension(
                sv2017Parser::Variable_dimensionContext *ctx) {
        // variable_dimension:
        //     LSQUARE_BR ( MUL
        //              | data_type
        //              | array_range_expression
        //               )? RSQUARE_BR
        // ;
        unique_ptr<iHdlExprItem> index = nullptr;
        if (ctx->MUL()) {
                NotImplementedLogger::print(
                                "VerExprParser.visitVariable_dimension - MUL", ctx);
                return nullptr;
        }
        auto dt = ctx->data_type();
        if (dt) {
                index = VerTypeParser(this).visitData_type(dt);
        } else {
                auto are = ctx->array_range_expression();
                if (are) {
                        index = VerExprParser(this).visitArray_range_expression(are);
                }
        }
        return index;
}
unique_ptr<iHdlExprItem> VerTypeParser::visitVariable_dimension(
                sv2017Parser::Variable_dimensionContext *ctx,
                unique_ptr<iHdlExprItem> selected_name) {
        auto index = _visitVariable_dimension(ctx);
        if (index == nullptr) {
                return create_object<HdlOp>(ctx, HdlOpType::INDEX, move(selected_name));
        } else {
                return create_object<HdlOp>(ctx, move(selected_name), HdlOpType::INDEX,
                                move(index));
        }
}
unique_ptr<iHdlExprItem> VerTypeParser::visitNet_type(
                sv2017Parser::Net_typeContext *ctx) {
        // net_type:
        //     KW_SUPPLY0
        //     | KW_SUPPLY1
        //     | KW_TRI
        //     | KW_TRIAND
        //     | KW_TRIOR
        //     | KW_TRIREG
        //     | KW_TRI0
        //     | KW_TRI1
        //     | KW_UWIRE
        //     | KW_WIRE
        //     | KW_WAND
        //     | KW_WOR
        // ;
        return create_object<HdlValueId>(ctx, ctx->getText());
}
unique_ptr<iHdlExprItem> VerTypeParser::visitNet_port_type(
                sv2017Parser::Net_port_typeContext *ctx) {
        // net_port_type:
        //  KW_INTERCONNECT ( implicit_data_type )?
        //   | net_type ( data_type_or_implicit )?
        //   | data_type_or_implicit
        // ;
        if (!ctx)
                return HdlValueSymbol::type_auto();

        if (ctx->KW_INTERCONNECT()) {
                NotImplementedLogger::print(
                                "VerExprParser.visitNet_or_var_data_type.interconnect", ctx);
                auto idt = ctx->implicit_data_type();
                auto t = visitImplicit_data_type(idt, nullptr);
                return t;
        }
        unique_ptr<iHdlExprItem> net_type = nullptr;
        auto _nt = ctx->net_type();
        if (_nt)
                net_type = visitNet_type(_nt);
        auto dti = ctx->data_type_or_implicit();
        return visitData_type_or_implicit(dti, move(net_type));
}
pair<unique_ptr<iHdlExprItem>, bool> VerTypeParser::visitNet_or_var_data_type(
                sv2017Parser::Net_or_var_data_typeContext *ctx) {
        // net_or_var_data_type:
        //  KW_INTERCONNECT ( implicit_data_type )?
        //   | KW_VAR ( data_type_or_implicit )?
        //   | net_type ( data_type_or_implicit )?
        //   | data_type_or_implicit
        // ;
        if (!ctx)
                return {HdlValueSymbol::type_auto(), false};
        if (ctx->KW_INTERCONNECT()) {
                NotImplementedLogger::print(
                                "VerExprParser.visitNet_or_var_data_type.interconnect", ctx);
                auto idt = ctx->implicit_data_type();
                auto t = visitImplicit_data_type(idt, nullptr);
                return {move(t), false};
        }
        auto dti = ctx->data_type_or_implicit();
        if (ctx->KW_VAR()) {
                auto t = visitData_type_or_implicit(dti, nullptr);
                return {move(t), true};
        }
        auto nt = ctx->net_type();
        if (nt) {
                auto sub_t = visitNet_type(nt);
                auto t = visitData_type_or_implicit(dti, move(sub_t));
                return {move(t), false};
        }
        assert(dti);
        auto t = visitData_type_or_implicit(dti, nullptr);
        return {move(t), false};
}

bool VerTypeParser::visitLifetime(sv2017Parser::LifetimeContext *ctx) {
        // lifetime:
        //     KW_STATIC
        //     | KW_AUTOMATIC
        // ;
        return !ctx || ctx->KW_STATIC();
}

unique_ptr<iHdlExprItem> VerTypeParser::visitData_type_or_void(
                sv2017Parser::Data_type_or_voidContext *ctx) {
        // data_type_or_void:
        //    KW_VOID
        //    | data_type
        // ;
        if (ctx->KW_VOID()) {
                return create_object<HdlValueId>(ctx, "void");
        } else {
                auto dt = ctx->data_type();
                return visitData_type(dt);
        }
}
unique_ptr<iHdlExprItem> VerTypeParser::visitVar_data_type(
                sv2017Parser::Var_data_typeContext *ctx) {
        // var_data_type:
        //   KW_VAR ( data_type_or_implicit )?
        //    | data_type
        // ;
        if (!ctx)
                return HdlValueSymbol::type_auto();
        auto dti = ctx->data_type_or_implicit();
        if (dti)
                return visitData_type_or_implicit(dti, nullptr);
        auto dt = ctx->data_type();
        if (dt)
                return visitData_type(dt);
        else
                assert(ctx->KW_VAR());
        return HdlValueSymbol::type_auto();
}

unique_ptr<iHdlExprItem> VerTypeParser::visitFunction_data_type_or_implicit(
                sv2017Parser::Function_data_type_or_implicitContext *ctx) {
        // function_data_type_or_implicit:
        //     data_type_or_void
        //     | implicit_data_type
        // ;
        if (!ctx)
                return HdlValueSymbol::type_auto();

        auto dtv = ctx->data_type_or_void();
        if (dtv) {
                return visitData_type_or_void(dtv);
        } else {
                auto idt = ctx->implicit_data_type();
                assert(idt);
                return visitImplicit_data_type(idt, nullptr);
        }
}

}
}

1	#include <hdlConvertor/svConvertor/typeParser.h>
2
3	#include <hdlConvertor/createObject.h>
4	#include <hdlConvertor/notImplementedLogger.h>
5	#include <hdlConvertor/hdlAst/hdlOpType.h>
6	#include <hdlConvertor/svConvertor/utils.h>
7	#include <hdlConvertor/svConvertor/exprParser.h>
8	#include <hdlConvertor/hdlAst/hdlOp.h>
9
10
11	namespace hdlConvertor {
12	namespace sv {
13
14	using namespace std;
15	using namespace hdlConvertor::hdlAst;
16
17
18	unique_ptr<iHdlExprItem> VerTypeParser::visitType_reference(	2✔
19	sv2017Parser::Type_referenceContext *ctx) {
20	// type_reference:
21	// KW_TYPE LPAREN (
22	// expression
23	// \| data_type
24	// ) RPAREN
25	// ;
26	unique_ptr<iHdlExprItem> res = nullptr;	2✔
27	auto e = ctx->expression();	2✔
28	if (e) {	2✔
29	VerExprParser ep(this);	2✔
30	res = ep.visitExpression(e);	2✔
31	} else {
32	auto dt = ctx->data_type();	×
33	assert(dt);	×
34	res = visitData_type(dt);	×
35	}
36	return create_object<HdlOp>(ctx, HdlOpType::TYPE_OF, move(res));	4✔
37	}	2✔
38
39	unique_ptr<iHdlExprItem> VerTypeParser::visitInteger_type(	26,300✔
40	sv2017Parser::Integer_typeContext *ctx) {
41	// integer_type:
42	// integer_vector_type
43	// \| integer_atom_type
44	// ;
45	auto ivt = ctx->integer_vector_type();	26,300✔
46	if (ivt)	26,300✔
47	return visitInteger_vector_type(ivt);	20,377✔
48	auto iat = ctx->integer_atom_type();	5,923✔
49	assert(iat);	5,923✔
50	return visitInteger_atom_type(iat);	5,923✔
51	}
52
53	unique_ptr<iHdlExprItem> VerTypeParser::visitNon_integer_type(	1,044✔
54	sv2017Parser::Non_integer_typeContext *ctx) {
55	// non_integer_type:
56	// KW_SHORTREAL
57	// \| KW_REAL
58	// \| KW_REALTIME
59	// ;
60	return create_object<HdlValueId>(ctx, ctx->getText());	1,044✔
61	}
62	unique_ptr<iHdlExprItem> VerTypeParser::visitInteger_atom_type(	5,923✔
63	sv2017Parser::Integer_atom_typeContext *ctx) {
64	// integer_atom_type:
65	// KW_BYTE
66	// \| KW_SHORTINT
67	// \| KW_INT
68	// \| KW_LONGINT
69	// \| KW_INTEGER
70	// \| KW_TIME
71	// ;
72	return create_object<HdlValueId>(ctx, ctx->getText());	5,923✔
73	}
74
75	unique_ptr<iHdlExprItem> VerTypeParser::visitInteger_vector_type(	20,377✔
76	sv2017Parser::Integer_vector_typeContext *ctx) {
77	// integer_vector_type:
78	// KW_BIT
79	// \| KW_LOGIC
80	// \| KW_REG
81	// ;
82	return Utils::mkWireT(ctx, create_object<HdlValueId>(ctx, ctx->getText()),	40,754✔
83	HdlValueSymbol::null(), SIGNING_VAL::NO_SIGN);	61,131✔
84	}
85
86	unique_ptr<iHdlExprItem> VerTypeParser::visitData_type_primitive(	27,344✔
87	sv2017Parser::Data_type_primitiveContext *ctx) {
88	// data_type_primitive:
89	// integer_type ( signing )?
90	// \| non_integer_type
91	// ;
92	auto it = ctx->integer_type();	27,344✔
93	if (it) {	27,344✔
94	auto t = visitInteger_type(it);	26,300✔
95	auto sig = ctx->signing(); // [TODO] wire in correct format (parametrization <t, widt, sign>)	26,300✔
96	if (sig) {	26,300✔
97	auto _sig = visitSigning(sig);	2,199✔
98	if (_sig != SIGNING_VAL::NO_SIGN) {	2,199✔
99	auto c = dynamic_cast<HdlOp*>(t.get());	2,199✔
100	auto sign = Utils::signing(_sig);	2,199✔
101	if (c && c->op == HdlOpType::PARAMETRIZATION	1,746✔
102	&& c->operands.size() == 3) {	3,945✔
103	// fill up sign flag for wire/reg types
104	c->operands[2] = move(sign);	1,746✔
105	} else {
106	// specify sign for rest of the types
107	vector<unique_ptr<iHdlExprItem>> args;	453✔
108	args.push_back(	453✔
109	create_object<HdlOp>(ctx,	906✔
110	make_unique<HdlValueId>("signed"),	453✔
111	HdlOpType::MAP_ASSOCIATION, move(sign)));	453✔
112	t = HdlOp::parametrization(ctx, move(t), args);	453✔
113	}	453✔
114	}	2,199✔
115	}
116	return t;	26,300✔
UNCOV 117	} else {	×
118	auto nit = ctx->non_integer_type();	1,044✔
119	assert(nit);	1,044✔
120	return visitNon_integer_type(nit);	1,044✔
121	}
122	}
123
124	unique_ptr<iHdlExprItem> VerTypeParser::visitData_type(	35,117✔
125	sv2017Parser::Data_typeContext *ctx) {
126	// data_type:
127	// KW_STRING
128	// \| KW_CHANDLE
129	// \| KW_VIRTUAL ( KW_INTERFACE )? identifier ( parameter_value_assignment )? ( DOT identifier )?
130	// \| KW_EVENT
131	// \| ( data_type_primitive
132	// \| KW_ENUM ( enum_base_type )?
133	// LBRACE enum_name_declaration ( COMMA enum_name_declaration )* RBRACE
134	// \| struct_union ( KW_PACKED ( signing )? )?
135	// LBRACE ( struct_union_member )+ RBRACE
136	// \| package_or_class_scoped_path
137	// ) ( variable_dimension )*
138	// \| type_reference
139	// ;
140	auto _s = ctx->KW_STRING();	35,117✔
141	if (_s)	35,117✔
142	return create_object<HdlValueId>(_s, "string");	211✔
143
144	auto _c = ctx->KW_CHANDLE();	34,906✔
145	if (_c)	34,906✔
146	return create_object<HdlValueId>(_c, "chandle");	26✔
147
148	if (ctx->KW_VIRTUAL()) {	34,880✔
149	NotImplementedLogger::print("VerTypeParser.visitData_type - virtual",	6✔
150	ctx);
151	auto ids = ctx->identifier();	6✔
152	VerExprParser ep(this);	6✔
153	auto t = ep.visitIdentifier(ids[0]);	6✔
154	auto pva = ctx->parameter_value_assignment();	6✔
155	if (pva) {	6✔
156	auto p = ep.visitParameter_value_assignment(pva);	5✔
157	t = HdlOp::parametrization(ctx, move(t), p);	5✔
158	}	5✔
159	if (ids.size() == 2) {	6✔
160	auto id = ep.visitIdentifier(ids[1]);	2✔
161	t = create_object<HdlOp>(ids[1], move(t), HdlOpType::DOT, move(id));	2✔
162	} else {	2✔
163	assert(ids.size() == 1);	4✔
164	}
165	return t;	6✔
166	}	6✔
167
168	auto _e = ctx->KW_EVENT();	34,874✔
169	if (_e)	34,874✔
170	return create_object<HdlValueId>(_e, "event");	130✔
171	auto _tr = ctx->type_reference();	34,744✔
172	if (_tr) {	34,744✔
173	return visitType_reference(_tr);	2✔
174	}
175
176	auto dtp = ctx->data_type_primitive();	34,742✔
177	unique_ptr<iHdlExprItem> t = nullptr;	34,742✔
178	if (dtp) {	34,742✔
179	t = visitData_type_primitive(dtp);	27,344✔
180	} else if (ctx->KW_ENUM()) {	7,398✔
181	NotImplementedLogger::print("VerTypeParser.visitData_type - enum", ctx);	140✔
182	t = create_object<HdlExprNotImplemented>(ctx);	140✔
183	} else if (ctx->struct_union()) {	7,258✔
184	NotImplementedLogger::print(	268✔
185	"VerTypeParser.visitData_type - struct or union", ctx);
186	t = create_object<HdlExprNotImplemented>(ctx);	268✔
187	} else {
188	VerExprParser ep(this);	6,990✔
189	auto _p = ctx->package_or_class_scoped_path();	6,990✔
190	assert(_p);	6,990✔
191	t = ep.visitPackage_or_class_scoped_path(_p);	6,990✔
192	}
193	VerTypeParser tp(this);	34,742✔
194	auto vds = ctx->variable_dimension();	34,742✔
195	t = tp.applyVariable_dimension(move(t), vds);	34,742✔
196	return t;	34,742✔
197	}	34,742✔
198
199	unique_ptr<iHdlExprItem> VerTypeParser::visitData_type_or_implicit(	48,127✔
200	sv2017Parser::Data_type_or_implicitContext *ctx,
201	unique_ptr<iHdlExprItem> net_type) {
202	// data_type_or_implicit:
203	// data_type
204	// \| implicit_data_type
205	// ;
206	if (!ctx)	48,127✔
207	return HdlValueSymbol::type_auto();	7,592✔
208
209	auto dt = ctx->data_type();	40,535✔
210	if (dt)	40,535✔
211	return visitData_type(dt);	27,797✔
212	auto idt = ctx->implicit_data_type();	12,738✔
213	assert(idt);	12,738✔
214	return visitImplicit_data_type(idt, move(net_type));	12,738✔
215	}
216
217	unique_ptr<iHdlExprItem> VerTypeParser::visitUnpacked_dimension(	355✔
218	sv2017Parser::Unpacked_dimensionContext *ctx) {
219	// unpacked_dimension: LSQUARE_BR range_expression RSQUARE_BR;
220	auto ra = ctx->range_expression();	355✔
221	return VerExprParser(this).visitRange_expression(ra);	355✔
222	}
223
224	unique_ptr<iHdlExprItem> VerTypeParser::applyUnpacked_dimension(	18,804✔
225	unique_ptr<iHdlExprItem> base_expr,
226	vector<sv2017Parser::Unpacked_dimensionContext*> &uds) {
227	for (auto _ud : uds) {	19,159✔
228	auto ud = visitUnpacked_dimension(_ud);	355✔
229	base_expr = create_object<HdlOp>(_ud, move(base_expr), HdlOpType::INDEX,	710✔
230	move(ud));	710✔
231	}	355✔
232	return base_expr;	18,804✔
233	}
234
235	unique_ptr<iHdlExprItem> VerTypeParser::applyVariable_dimension(	89,638✔
236	unique_ptr<iHdlExprItem> base_expr,
237	vector<sv2017Parser::Variable_dimensionContext*> &vds) {
238	// optionally fill up width of wire/reg datatypes
239	auto wire_reg_parametrization = dynamic_cast<HdlOp*>(base_expr.get());	89,638✔
240	if (wire_reg_parametrization) {	89,638✔
241	if (wire_reg_parametrization->op != HdlOpType::PARAMETRIZATION) {	52,505✔
242	wire_reg_parametrization = nullptr;	418✔
243	} else if (wire_reg_parametrization->operands.size() != 3) {	52,087✔
244	wire_reg_parametrization = nullptr;	960✔
245
246	} else {
247	auto w =
248	dynamic_cast<HdlValueSymbol*>(wire_reg_parametrization->operands[1].get());	51,127✔
249	if (w) {	51,127✔
250	if (w->symb != HdlValueSymbol_t::symb_NULL)	28,779✔
251	wire_reg_parametrization = nullptr;	×
252	} else {
253	wire_reg_parametrization = nullptr;	22,348✔
254	}
255	}
256	}
257
258	for (auto _vd : vds) {	105,655✔
259	if (wire_reg_parametrization) {	16,017✔
260	auto d = _visitVariable_dimension(_vd);	13,613✔
261	if (d == nullptr)	13,613✔
262	d = HdlValueSymbol::null();	1✔
263	wire_reg_parametrization->operands[1] = move(d);	13,613✔
264
265	wire_reg_parametrization = nullptr;	13,613✔
266	continue;	13,613✔
267	}	13,613✔
268	base_expr = visitVariable_dimension(_vd, move(base_expr));	2,404✔
269	}
270	return base_expr;	89,638✔
271	}
272
273	unique_ptr<iHdlExprItem> VerTypeParser::visitPacked_dimension(	13,364✔
274	sv2017Parser::Packed_dimensionContext *ctx) {
275	// packed_dimension: LSQUARE_BR ( range_expression )? RSQUARE_BR;
276	auto ra = ctx->range_expression();	13,364✔
277	if (ra)	13,364✔
278	return VerExprParser(this).visitRange_expression(ra);	13,364✔
279	return nullptr;	×
280	}
281
282	SIGNING_VAL VerTypeParser::visitSigning(sv2017Parser::SigningContext *ctx) {	3,188✔
283	// signing:
284	// KW_SIGNED
285	// \| KW_UNSIGNED
286	// ;
287	if (ctx->KW_SIGNED()) {	3,188✔
288	return SIGNING_VAL::SIGNED;	2,151✔
289	} else {
290	assert(ctx->KW_UNSIGNED());	1,037✔
291	return SIGNING_VAL::UNSIGNED;	1,037✔
292	}
293	}
294
295	unique_ptr<iHdlExprItem> VerTypeParser::visitImplicit_data_type(	13,396✔
296	sv2017Parser::Implicit_data_typeContext *ctx,
297	unique_ptr<iHdlExprItem> net_type) {
298	// implicit_data_type:
299	// signing ( packed_dimension )*
300	// \| ( packed_dimension )+
301	// ;
302	if (!ctx) {	13,396✔
303	if (net_type)	×
304	return net_type;	×
305	else
306	return HdlValueSymbol::type_auto();	×
307	}
308	auto s = ctx->signing();	13,396✔
309	SIGNING_VAL is_signed = SIGNING_VAL::NO_SIGN;	13,396✔
310	auto pds = ctx->packed_dimension();	13,396✔
311	if (s) {	13,396✔
312	is_signed = visitSigning(s);	989✔
313	}
314	unique_ptr<iHdlExprItem> e = nullptr;	13,396✔
315	auto it = pds.begin();	13,396✔
316	if (it != pds.end()) {	13,396✔
317	auto r0 = visitPacked_dimension(*it);	13,353✔
318	if (r0 == nullptr)	13,353✔
319	r0 = HdlValueSymbol::null();	×
320	e = Utils::mkWireT(*it, move(net_type), move(r0), is_signed);	13,353✔
321	++it;	13,353✔
322	} else {	13,353✔
323	e = Utils::mkWireT(nullptr, HdlValueSymbol::null(), is_signed);	43✔
324	}
325	for (; it != pds.end(); ++it) {	13,407✔
326	auto pd = visitPacked_dimension(*it);	11✔
327	if (pd) {	11✔
328	e = create_object<HdlOp>(*it, move(e), HdlOpType::INDEX, move(pd));	11✔
329	} else {
330	e = create_object<HdlOp>(*it, HdlOpType::INDEX, move(e));	×
331
332	}
333	}	11✔
334	return e;	13,396✔
335	}	13,396✔
336	unique_ptr<iHdlExprItem> VerTypeParser::_visitVariable_dimension(	16,017✔
337	sv2017Parser::Variable_dimensionContext *ctx) {
338	// variable_dimension:
339	// LSQUARE_BR ( MUL
340	// \| data_type
341	// \| array_range_expression
342	// )? RSQUARE_BR
343	// ;
344	unique_ptr<iHdlExprItem> index = nullptr;	16,017✔
345	if (ctx->MUL()) {	16,017✔
346	NotImplementedLogger::print(	1✔
347	"VerExprParser.visitVariable_dimension - MUL", ctx);
348	return nullptr;	1✔
349	}
350	auto dt = ctx->data_type();	16,016✔
351	if (dt) {	16,016✔
352	index = VerTypeParser(this).visitData_type(dt);	70✔
353	} else {
354	auto are = ctx->array_range_expression();	15,946✔
355	if (are) {	15,946✔
356	index = VerExprParser(this).visitArray_range_expression(are);	15,850✔
357	}
358	}
359	return index;	16,016✔
360	}	16,017✔
361	unique_ptr<iHdlExprItem> VerTypeParser::visitVariable_dimension(	2,404✔
362	sv2017Parser::Variable_dimensionContext *ctx,
363	unique_ptr<iHdlExprItem> selected_name) {
364	auto index = _visitVariable_dimension(ctx);	2,404✔
365	if (index == nullptr) {	2,404✔
366	return create_object<HdlOp>(ctx, HdlOpType::INDEX, move(selected_name));	96✔
367	} else {
368	return create_object<HdlOp>(ctx, move(selected_name), HdlOpType::INDEX,	4,616✔
369	move(index));	4,616✔
370	}
371	}	2,404✔
372	unique_ptr<iHdlExprItem> VerTypeParser::visitNet_type(	11,944✔
373	sv2017Parser::Net_typeContext *ctx) {
374	// net_type:
375	// KW_SUPPLY0
376	// \| KW_SUPPLY1
377	// \| KW_TRI
378	// \| KW_TRIAND
379	// \| KW_TRIOR
380	// \| KW_TRIREG
381	// \| KW_TRI0
382	// \| KW_TRI1
383	// \| KW_UWIRE
384	// \| KW_WIRE
385	// \| KW_WAND
386	// \| KW_WOR
387	// ;
388	return create_object<HdlValueId>(ctx, ctx->getText());	11,944✔
389	}
390	unique_ptr<iHdlExprItem> VerTypeParser::visitNet_port_type(	116✔
391	sv2017Parser::Net_port_typeContext *ctx) {
392	// net_port_type:
393	// KW_INTERCONNECT ( implicit_data_type )?
394	// \| net_type ( data_type_or_implicit )?
395	// \| data_type_or_implicit
396	// ;
397	if (!ctx)	116✔
398	return HdlValueSymbol::type_auto();	28✔
399
400	if (ctx->KW_INTERCONNECT()) {	88✔
401	NotImplementedLogger::print(	×
402	"VerExprParser.visitNet_or_var_data_type.interconnect", ctx);
403	auto idt = ctx->implicit_data_type();	×
404	auto t = visitImplicit_data_type(idt, nullptr);	×
405	return t;	×
406	}	×
407	unique_ptr<iHdlExprItem> net_type = nullptr;	88✔
408	auto _nt = ctx->net_type();	88✔
409	if (_nt)	88✔
410	net_type = visitNet_type(_nt);	2✔
411	auto dti = ctx->data_type_or_implicit();	88✔
412	return visitData_type_or_implicit(dti, move(net_type));	88✔
413	}	88✔
414	pair<unique_ptr<iHdlExprItem>, bool> VerTypeParser::visitNet_or_var_data_type(	13,510✔
415	sv2017Parser::Net_or_var_data_typeContext *ctx) {
416	// net_or_var_data_type:
417	// KW_INTERCONNECT ( implicit_data_type )?
418	// \| KW_VAR ( data_type_or_implicit )?
419	// \| net_type ( data_type_or_implicit )?
420	// \| data_type_or_implicit
421	// ;
422	if (!ctx)	13,510✔
423	return {HdlValueSymbol::type_auto(), false};	5,823✔
424	if (ctx->KW_INTERCONNECT()) {	7,687✔
425	NotImplementedLogger::print(	1✔
426	"VerExprParser.visitNet_or_var_data_type.interconnect", ctx);
427	auto idt = ctx->implicit_data_type();	1✔
428	auto t = visitImplicit_data_type(idt, nullptr);	1✔
429	return {move(t), false};	1✔
430	}	1✔
431	auto dti = ctx->data_type_or_implicit();	7,686✔
432	if (ctx->KW_VAR()) {	7,686✔
433	auto t = visitData_type_or_implicit(dti, nullptr);	21✔
434	return {move(t), true};	21✔
435	}	21✔
436	auto nt = ctx->net_type();	7,665✔
437	if (nt) {	7,665✔
438	auto sub_t = visitNet_type(nt);	843✔
439	auto t = visitData_type_or_implicit(dti, move(sub_t));	843✔
440	return {move(t), false};	843✔
441	}	843✔
442	assert(dti);	6,822✔
443	auto t = visitData_type_or_implicit(dti, nullptr);	6,822✔
444	return {move(t), false};	6,822✔
445	}	6,822✔
446
447	bool VerTypeParser::visitLifetime(sv2017Parser::LifetimeContext *ctx) {	26,425✔
448	// lifetime:
449	// KW_STATIC
450	// \| KW_AUTOMATIC
451	// ;
452	return !ctx \|\| ctx->KW_STATIC();	26,425✔
453	}
454
455	unique_ptr<iHdlExprItem> VerTypeParser::visitData_type_or_void(	749✔
456	sv2017Parser::Data_type_or_voidContext *ctx) {
457	// data_type_or_void:
458	// KW_VOID
459	// \| data_type
460	// ;
461	if (ctx->KW_VOID()) {	749✔
462	return create_object<HdlValueId>(ctx, "void");	217✔
463	} else {
464	auto dt = ctx->data_type();	532✔
465	return visitData_type(dt);	532✔
466	}
467	}
468	unique_ptr<iHdlExprItem> VerTypeParser::visitVar_data_type(	×
469	sv2017Parser::Var_data_typeContext *ctx) {
470	// var_data_type:
471	// KW_VAR ( data_type_or_implicit )?
472	// \| data_type
473	// ;
474	if (!ctx)	×
475	return HdlValueSymbol::type_auto();	×
476	auto dti = ctx->data_type_or_implicit();	×
477	if (dti)	×
478	return visitData_type_or_implicit(dti, nullptr);	×
479	auto dt = ctx->data_type();	×
480	if (dt)	×
481	return visitData_type(dt);	×
482	else
483	assert(ctx->KW_VAR());	×
484	return HdlValueSymbol::type_auto();	×
485	}
486
487	unique_ptr<iHdlExprItem> VerTypeParser::visitFunction_data_type_or_implicit(	1,991✔
488	sv2017Parser::Function_data_type_or_implicitContext *ctx) {
489	// function_data_type_or_implicit:
490	// data_type_or_void
491	// \| implicit_data_type
492	// ;
493	if (!ctx)	1,991✔
494	return HdlValueSymbol::type_auto();	585✔
495
496	auto dtv = ctx->data_type_or_void();	1,406✔
497	if (dtv) {	1,406✔
498	return visitData_type_or_void(dtv);	749✔
499	} else {
500	auto idt = ctx->implicit_data_type();	657✔
501	assert(idt);	657✔
502	return visitImplicit_data_type(idt, nullptr);	657✔
503	}
504	}
505
506	}
507	}

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