#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

95.21

/src/vhdlConvertor/exprParser.cpp

#include <hdlConvertor/notImplementedLogger.h>
#include <hdlConvertor/vhdlConvertor/operatorTypeParser.h>
#include <hdlConvertor/hdlAst/hdlOp.h>
#include <hdlConvertor/vhdlConvertor/directionParser.h>
#include <hdlConvertor/vhdlConvertor/exprParser.h>
#include <hdlConvertor/vhdlConvertor/literalParser.h>
#include <hdlConvertor/vhdlConvertor/referenceParser.h>
#include <hdlConvertor/vhdlConvertor/typeDeclarationParser.h>
#include <hdlConvertor/createObject.h>
#include <assert.h>

namespace hdlConvertor {
namespace vhdl {

using namespace hdlConvertor::hdlAst;
using namespace std;

unique_ptr<vector<unique_ptr<iHdlExprItem>>> VhdlExprParser::visitAssociation_list(
                vhdlParser::Association_listContext *ctx) {
        // association_list:
        //       association_element ( COMMA association_element )*
        // ;
        auto ae = make_unique<vector<unique_ptr<iHdlExprItem>>>();
        for (auto e : ctx->association_element()) {
                ae->push_back(visitAssociation_element(e));
        }
        return ae;
}

unique_ptr<iHdlExprItem> VhdlExprParser::visitAssociation_element(
                vhdlParser::Association_elementContext *ctx) {
        // association_element:
        //       ( formal_part ARROW )? actual_part
        // ;
        auto _ap = ctx->actual_part();
        auto ap = visitActual_part(_ap);
        auto fp = ctx->formal_part();
        if (fp) {
                return create_object<HdlOp>(ctx, visitFormal_part(fp), ARROW,
                                move(ap));
        }
        return ap;
}

unique_ptr<iHdlExprItem> VhdlExprParser::visitFormal_part(
                vhdlParser::Formal_partContext *ctx) {
        // formal_part:
        //       formal_designator
        //       | name LPAREN formal_designator RPAREN
        //       | type_mark LPAREN formal_designator RPAREN
        // ;
        // formal_part:
        //       name (LPAREN name RPAREN)?
        // ;
        auto names = ctx->name();
        auto id = VhdlReferenceParser::visitName(names[0]);
        if (names.size() > 1) {
                vector<unique_ptr<iHdlExprItem>> args;
                args.push_back(VhdlReferenceParser::visitName(names[1]));
                return HdlOp::call(ctx, move(id), args);
        } else {
                return id;
        }
}

unique_ptr<HdlOp> VhdlExprParser::visitExplicit_range(
                vhdlParser::Explicit_rangeContext *ctx) {
        // explicit_range
        // : simple_expression direction simple_expression
        // ;
        HdlOpType op;
        if (ctx->direction()->KW_DOWNTO()) {
                op = DOWNTO;
        } else {
                op = TO;
        }
        return create_object<HdlOp>(ctx,
                        visitSimple_expression(ctx->simple_expression(0)), op,
                        visitSimple_expression(ctx->simple_expression(1)));
}

unique_ptr<iHdlExprItem> VhdlExprParser::visitRange(
                vhdlParser::RangeContext *ctx) {
        //range:
        //      attribute_name
        //      | explicit_range
        //;
        auto an = ctx->attribute_name();
        if (an) {
                return VhdlReferenceParser::visitAttribute_name(an);
        } else {
                auto er = ctx->explicit_range();
                assert(er);
                return visitExplicit_range(er);
        }
}

unique_ptr<iHdlExprItem> VhdlExprParser::visitActual_part(
                vhdlParser::Actual_partContext *ctx) {
        // actual_part:
        //       name LPAREN actual_designator RPAREN
        //       | actual_designator
        // ;

        auto name = ctx->name();
        auto _ad = ctx->actual_designator();
        unique_ptr<iHdlExprItem> ad = visitActual_designator(_ad);
        if (name) {
                vector<unique_ptr<iHdlExprItem>> ops;
                ops.push_back(move(ad));
                return HdlOp::call(ctx, VhdlReferenceParser::visitName(name), ops);
        }
        return ad;
}
unique_ptr<iHdlExprItem> VhdlExprParser::visitActual_designator(
                vhdlParser::Actual_designatorContext *ctx) {
        //actual_designator:
        //      ( INERTIAL )? expression
        //      | subtype_indication
        //      | OPEN
        //;
        if (ctx->KW_OPEN())
                return update_code_position(HdlValueSymbol::open(), ctx);
        auto sti = ctx->subtype_indication();
        if (sti)
                return VhdlTypeDeclarationParser::visitSubtype_indication(sti);
        return visitExpression(ctx->expression());
}

unique_ptr<iHdlExprItem> VhdlExprParser::visitResolution_indication(
                vhdlParser::Resolution_indicationContext *ctx) {
        // resolution_indication:
        //       name | LPAREN element_resolution RPAREN
        // ;
        // element_resolution: array_element_resolution | record_resolution;
        auto n = ctx->name();
        if (n) {
                return VhdlReferenceParser::visitName(n);
        }

        NotImplementedLogger::print(
                        "ExprParser.visitResolution_indication - element_resolution", ctx);
        return create_object<HdlExprNotImplemented>(ctx);
}

unique_ptr<iHdlExprItem> VhdlExprParser::visitDiscrete_range(
                vhdlParser::Discrete_rangeContext *ctx) {
        // discrete_range
        // : range
        // | subtype_indication
        // ;
        auto r = ctx->range();
        if (r)
                return visitRange(r);
        return VhdlTypeDeclarationParser::visitSubtype_indication(ctx->subtype_indication());
}

HdlOpType VhdlExprParser::visitSign(vhdlParser::SignContext *ctx) {
        // sign: PLUS | MINUS;
        if (ctx->MINUS()) {
                return HdlOpType::SUB;
        } else {
                assert(ctx->PLUS());
                return HdlOpType::ADD;
        }
}

void aggregate_to_parenthesis(unique_ptr<iHdlExprItem> &o) {
        auto v = dynamic_cast<HdlValueArr*>(o.get());
        if (v && v->_arr && v->_arr->size() == 1) {
                o = move(v->_arr->at(0));
        }
}

unique_ptr<iHdlExprItem> VhdlExprParser::visitSimple_expression(
                vhdlParser::Simple_expressionContext *ctx) {
        // simple_expression:
        //       primary ( DOUBLESTAR primary )?
        //       | ( KW_ABS | KW_NOT | logical_operator | sign ) simple_expression
        //       | simple_expression multiplying_operator simple_expression
        //       | simple_expression adding_operator simple_expression
        // ;
        auto _primary = ctx->primary();
        if (_primary.size() == 1) {
                return visitPrimary(_primary[0]);
        } else if (_primary.size() == 2) {
                auto p0 = visitPrimary(_primary[0]);
                aggregate_to_parenthesis(p0);
                auto p1 = visitPrimary(_primary[1]);
                aggregate_to_parenthesis(p1);
                assert(ctx->DOUBLESTAR());
                return create_object<HdlOp>(ctx, move(p0), HdlOpType::POW,
                                move(p1));
        }
        auto se = ctx->simple_expression();
        HdlOpType op;
        if (se.size() == 1) {
                if (ctx->KW_ABS()) {
                        op = HdlOpType::ABS;
                } else if (ctx->KW_NOT()) {
                        op = HdlOpType::NEG;
                } else {
                        auto lo = ctx->logical_operator();
                        if (lo) {
                                op = HdlOpType_from(lo);
                        } else {
                                auto s = ctx->sign();
                                assert(s);
                                op = HdlOpType_from(s);
                        }
                        op = HdlOpType_toUnary(op);
                }
                auto se0 = visitSimple_expression(se[0]);
                aggregate_to_parenthesis(se0);
                return create_object<HdlOp>(ctx, op, move(se0));
        } else {
                assert(se.size() == 2);
                auto mo = ctx->multiplying_operator();
                if (mo) {
                        op = HdlOpType_from(mo);
                } else {
                        auto ao = ctx->adding_operator();
                        assert(ao);
                        op = HdlOpType_from(ao);
                }

                auto se0 = visitSimple_expression(se[0]);
                aggregate_to_parenthesis(se0);
                auto se1 = visitSimple_expression(se[1]);
                aggregate_to_parenthesis(se1);
                return create_object<HdlOp>(ctx, move(se0), op, move(se1));
        }
}
unique_ptr<iHdlExprItem> VhdlExprParser::visitExpression(
                vhdlParser::ExpressionContext *ctx) {
        // expression:
        //       COND_OP primary
        //       | simple_expression
        //       | expression shift_operator expression
        //       | expression relational_operator expression
        //       | expression logical_operator expression
        // ;

        if (ctx->COND_OP()) {
                NotImplementedLogger::print(
                                "ExprParser.visitExpression - CONDITION_OPERATOR", ctx);
                auto p = ctx->primary();
                assert(p);
                auto vp = visitPrimary(p);
                aggregate_to_parenthesis(vp);
                return vp;
        }
        auto _se = ctx->simple_expression();
        if (_se) {
                return visitSimple_expression(_se);
        }
        auto _ops = ctx->expression();
        assert(_ops.size() == 2);
        auto op0 = visitExpression(_ops[0]);
        auto op1 = visitExpression(_ops[1]);
        auto so = ctx->shift_operator();
        HdlOpType op;
        if (so) {
                op = HdlOpType_from(so);
        } else {
                auto ro = ctx->relational_operator();
                if (ro) {
                        op = HdlOpType_from(ro);
                } else {
                        auto lo = ctx->logical_operator();
                        assert(lo);
                        op = HdlOpType_from(lo);
                }
        }
        return create_object<HdlOp>(ctx, move(op0), op, move(op1));
}

unique_ptr<iHdlExprItem> VhdlExprParser::visitPrimary(
                vhdlParser::PrimaryContext *ctx) {
        //primary:
        //      numeric_literal             #primaryNum
        //      | BIT_STRING_LITERAL        #primaryBitStr
        //      | KW_NULL                   #primaryLiteral
        //      | allocator                 #primaryAllocator
        //      | aggregate                 #primaryAggregate
        //      | qualified_expression      #primaryQualifiedExpr
        //;
        auto nl = ctx->numeric_literal();
        if (nl)
                return VhdlLiteralParser::visitNumeric_literal(nl);

        if (ctx->KW_NULL())
                return update_code_position(HdlValueSymbol::null(), ctx);

        auto bsl = ctx->BIT_STRING_LITERAL();
        if (bsl) {
                return VhdlLiteralParser::visitBIT_STRING_LITERAL(bsl, bsl->getText());
        }
        auto al = ctx->allocator();
        if (al)
                return visitAllocator(al);
        auto ag = ctx->aggregate();
        if (ag) {
                return visitAggregate(ag);
        }
        auto qe = ctx->qualified_expression();
        assert(qe);
        return visitQualified_expression(qe);
}

unique_ptr<iHdlExprItem> VhdlExprParser::visitQualified_expression(
                vhdlParser::Qualified_expressionContext *ctx) {
        // qualified_expression:
        //       type_mark APOSTROPHE aggregate
        // ;
        auto _tm = ctx->type_mark();
        auto tm = visitType_mark(_tm);
        auto a = ctx->aggregate();
        auto e = visitAggregate(a);
        return create_object<HdlOp>(ctx, move(tm), HdlOpType::APOSTROPHE,
                        move(e));
}

unique_ptr<iHdlExprItem> VhdlExprParser::visitAllocator(
                vhdlParser::AllocatorContext *ctx) {
        // allocator
        // : KW_NEW ( qualified_expression | subtype_indication )
        // ;
        auto n = create_object<HdlValueId>(ctx->KW_NEW(), "new");
        unique_ptr<iHdlExprItem> e;
        auto qe = ctx->qualified_expression();
        if (qe)
                e = visitQualified_expression(qe);
        else {
                auto si = ctx->subtype_indication();
                e = VhdlTypeDeclarationParser::visitSubtype_indication(si);
        }
        return create_object<HdlOp>(ctx, move(n), HdlOpType::CALL, move(e));
}

unique_ptr<iHdlExprItem> VhdlExprParser::visitAggregate(
                vhdlParser::AggregateContext *ctx) {
        // aggregate:
        //    LPAREN element_association ( COMMA element_association )* RPAREN
        // ;
        vector<unique_ptr<iHdlExprItem>> elements;
        for (auto elm : ctx->element_association()) {
                auto e = visitElement_association(elm);
                elements.push_back(move(e));
        }
        if (elements.size() == 1) {
                auto e = dynamic_cast<HdlOp*>(elements[0].get());
                if (!e || e->op != HdlOpType::MAP_ASSOCIATION)
                        return move(elements[0]);
        }
        return create_object<HdlValueArr>(ctx, elements);
}

unique_ptr<iHdlExprItem> VhdlExprParser::visitElement_association(
                vhdlParser::Element_associationContext *ctx) {
        // ement_association
        //   : (  choices ARROW )? expression
        //   ;
        auto e = visitExpression(ctx->expression());
        auto _c = ctx->choices();
        if (_c) {
                auto ch = visitChoices(_c);
                if (ch.size() > 1) {
                        NotImplementedLogger::print(
                                        "ExprParser.visitElement_association - multiple choices",
                                        _c);
                }
                assert(ch.size());
                return create_object<HdlOp>(ctx, move(ch[0]),
                                HdlOpType::MAP_ASSOCIATION, move(e));
        }
        return e;
}

unique_ptr<iHdlExprItem> VhdlExprParser::visitTarget(
                vhdlParser::TargetContext *ctx) {
        // target
        // : name
        // | aggregate
        // ;
        auto n = ctx->name();
        if (n) {
                return VhdlReferenceParser::visitName(n);
        } else {
                return visitAggregate(ctx->aggregate());
        }
}

unique_ptr<iHdlExprItem> VhdlExprParser::visitWaveform(
                vhdlParser::WaveformContext *ctx) {
        // waveform :
        // waveform_element ( COMMA waveform_element )*
        // | UNAFFECTED
        // ;
        if (ctx->KW_UNAFFECTED()) {
                NotImplementedLogger::print("ExprParser.visitWaveform - UNAFFECTED",
                                ctx);
                return create_object<HdlExprNotImplemented>(ctx);
        }
        auto we = ctx->waveform_element();
        auto weIt = we.begin();

        auto top = visitWaveform_element(*weIt);
        ++weIt;
        while (weIt != we.end()) {
                top = create_object<HdlOp>(ctx, move(top), DOT,
                                visitWaveform_element(*weIt));
                ++weIt;
        }

        return top;
}

unique_ptr<iHdlExprItem> VhdlExprParser::visitCondition(
                vhdlParser::ConditionContext *ctx) {
        // condition
        // : expression
        // ;
        return VhdlExprParser::visitExpression(ctx->expression());
}

unique_ptr<iHdlExprItem> VhdlExprParser::visitConditional_waveforms(
                vhdlParser::Conditional_waveformsContext *ctx) {
        // conditional_waveforms:
        //       waveform WHEN condition
        //       ( ELSE waveform WHEN condition )*
        //       ( ELSE waveform )?
        // ;
        auto waveforms = ctx->waveform();
        auto conditions = ctx->condition();
        auto c = conditions.rbegin();
        unique_ptr<iHdlExprItem> res = nullptr;
        for (auto w = waveforms.rbegin(); w != waveforms.rend(); ++w) {
                auto w_expr = visitWaveform(*w);
                if (res == nullptr) {
                        // the first iteration
                        bool has_default_else = waveforms.size() > conditions.size();
                        if (has_default_else) {
                                // this waveform is a default else
                                res = move(w_expr);
                                continue;
                        }
                }
                auto c_expr = visitCondition(*c);
                res = HdlOp::ternary(*w, move(c_expr), move(w_expr), move(res));
                c++;
        }
        return res;
}

unique_ptr<iHdlExprItem> VhdlExprParser::visitWaveform_element(
                vhdlParser::Waveform_elementContext *ctx) {
        // waveform_element :
        // expression ( AFTER expression )?
        // ;
        auto ex = ctx->expression();
        auto e = ex.begin();
        auto top = visitExpression(*e);
        ++e;
        if (e != ex.end()) {
                NotImplementedLogger::print(
                                "ExprParser.visitWaveform_element - AFTER expression", ctx);
        }
        return top;
}

unique_ptr<iHdlExprItem> VhdlExprParser::visitChoice(
                vhdlParser::ChoiceContext *ctx) {
        // choice:
        //       discrete_range
        //       | simple_expression
        //       | OTHERS
        // ;

        auto dr = ctx->discrete_range();
        if (dr) {
                return visitDiscrete_range(dr);
        }
        auto se = ctx->simple_expression();
        if (se) {
                return VhdlExprParser::visitSimple_expression(se);
        }
#ifndef NDEBUG
        auto o = ctx->KW_OTHERS();
        assert(o);
#endif
        return update_code_position(HdlValueSymbol::others(), ctx);
}
vector<unique_ptr<iHdlExprItem>> VhdlExprParser::visitChoices(
                vhdlParser::ChoicesContext *ctx) {
        // choices: choice ( choice )*;
        vector<unique_ptr<iHdlExprItem>> res;
        auto _choice = ctx->choice();
        for (auto c : _choice) {
                res.push_back(visitChoice(c));
        }
        return res;
}

unique_ptr<iHdlExprItem> VhdlExprParser::visitProcedure_call_statement(
                vhdlParser::Procedure_call_statementContext *ctx) {
        // procedure_call_statement: procedure_call SEMI
        //   ;
        return visitProcedure_call(ctx->procedure_call());
}
unique_ptr<iHdlExprItem> VhdlExprParser::visitProcedure_call(
                vhdlParser::Procedure_callContext *ctx) {
        // procedure_call: name;
        auto fnCall = VhdlReferenceParser::visitName(ctx->name());
        auto c = dynamic_cast<HdlOp*>(fnCall.get());

        if (c == nullptr || c->op != HdlOpType::CALL) {
                if (c && c->op == HdlOpType::INDEX) {
                        c->op = HdlOpType::CALL;
                        return fnCall;
                }
                vector<unique_ptr<iHdlExprItem>> args;
                return HdlOp::call(ctx, move(fnCall), args);
        }
        return fnCall;
}

unique_ptr<iHdlExprItem> VhdlExprParser::visitType_mark(
                vhdlParser::Type_markContext *ctx) {
        // type_mark: name;
        auto n = ctx->name();
        return VhdlReferenceParser::visitName(n);
}

}
}

1	#include <hdlConvertor/notImplementedLogger.h>
2	#include <hdlConvertor/vhdlConvertor/operatorTypeParser.h>
3	#include <hdlConvertor/hdlAst/hdlOp.h>
4	#include <hdlConvertor/vhdlConvertor/directionParser.h>
5	#include <hdlConvertor/vhdlConvertor/exprParser.h>
6	#include <hdlConvertor/vhdlConvertor/literalParser.h>
7	#include <hdlConvertor/vhdlConvertor/referenceParser.h>
8	#include <hdlConvertor/vhdlConvertor/typeDeclarationParser.h>
9	#include <hdlConvertor/createObject.h>
10	#include <assert.h>
11
12	namespace hdlConvertor {
13	namespace vhdl {
14
15	using namespace hdlConvertor::hdlAst;
16	using namespace std;
17
18	unique_ptr<vector<unique_ptr<iHdlExprItem>>> VhdlExprParser::visitAssociation_list(	68,944✔
19	vhdlParser::Association_listContext *ctx) {
20	// association_list:
21	// association_element ( COMMA association_element )*
22	// ;
23	auto ae = make_unique<vector<unique_ptr<iHdlExprItem>>>();	68,944✔
24	for (auto e : ctx->association_element()) {	182,636✔
25	ae->push_back(visitAssociation_element(e));	113,692✔
26	}	68,944✔
27	return ae;	68,944✔
28	}	×
29
30	unique_ptr<iHdlExprItem> VhdlExprParser::visitAssociation_element(	113,692✔
31	vhdlParser::Association_elementContext *ctx) {
32	// association_element:
33	// ( formal_part ARROW )? actual_part
34	// ;
35	auto _ap = ctx->actual_part();	113,692✔
36	auto ap = visitActual_part(_ap);	113,692✔
37	auto fp = ctx->formal_part();	113,692✔
38	if (fp) {	113,692✔
39	return create_object<HdlOp>(ctx, visitFormal_part(fp), ARROW,	16,934✔
40	move(ap));	16,934✔
41	}
42	return ap;	105,225✔
43	}	113,692✔
44
45	unique_ptr<iHdlExprItem> VhdlExprParser::visitFormal_part(	8,467✔
46	vhdlParser::Formal_partContext *ctx) {
47	// formal_part:
48	// formal_designator
49	// \| name LPAREN formal_designator RPAREN
50	// \| type_mark LPAREN formal_designator RPAREN
51	// ;
52	// formal_part:
53	// name (LPAREN name RPAREN)?
54	// ;
55	auto names = ctx->name();	8,467✔
56	auto id = VhdlReferenceParser::visitName(names[0]);	8,467✔
57	if (names.size() > 1) {	8,467✔
58	vector<unique_ptr<iHdlExprItem>> args;	×
59	args.push_back(VhdlReferenceParser::visitName(names[1]));	×
60	return HdlOp::call(ctx, move(id), args);	×
61	} else {	×
62	return id;	8,467✔
63	}
64	}	8,467✔
65
66	unique_ptr<HdlOp> VhdlExprParser::visitExplicit_range(	15,287✔
67	vhdlParser::Explicit_rangeContext *ctx) {
68	// explicit_range
69	// : simple_expression direction simple_expression
70	// ;
71	HdlOpType op;
72	if (ctx->direction()->KW_DOWNTO()) {	15,287✔
73	op = DOWNTO;	10,641✔
74	} else {
75	op = TO;	4,646✔
76	}
77	return create_object<HdlOp>(ctx,
78	visitSimple_expression(ctx->simple_expression(0)), op,	30,574✔
79	visitSimple_expression(ctx->simple_expression(1)));	45,861✔
80	}
81
82	unique_ptr<iHdlExprItem> VhdlExprParser::visitRange(	2,531✔
83	vhdlParser::RangeContext *ctx) {
84	//range:
85	// attribute_name
86	// \| explicit_range
87	//;
88	auto an = ctx->attribute_name();	2,531✔
89	if (an) {	2,531✔
90	return VhdlReferenceParser::visitAttribute_name(an);	9✔
91	} else {
92	auto er = ctx->explicit_range();	2,522✔
93	assert(er);	2,522✔
94	return visitExplicit_range(er);	2,522✔
95	}
96	}
97
98	unique_ptr<iHdlExprItem> VhdlExprParser::visitActual_part(	113,692✔
99	vhdlParser::Actual_partContext *ctx) {
100	// actual_part:
101	// name LPAREN actual_designator RPAREN
102	// \| actual_designator
103	// ;
104
105	auto name = ctx->name();	113,692✔
106	auto _ad = ctx->actual_designator();	113,692✔
107	unique_ptr<iHdlExprItem> ad = visitActual_designator(_ad);	113,692✔
108	if (name) {	113,692✔
109	vector<unique_ptr<iHdlExprItem>> ops;	6,490✔
110	ops.push_back(move(ad));	6,490✔
111	return HdlOp::call(ctx, VhdlReferenceParser::visitName(name), ops);	6,490✔
112	}	6,490✔
113	return ad;	107,202✔
114	}	113,692✔
115	unique_ptr<iHdlExprItem> VhdlExprParser::visitActual_designator(	113,692✔
116	vhdlParser::Actual_designatorContext *ctx) {
117	//actual_designator:
118	// ( INERTIAL )? expression
119	// \| subtype_indication
120	// \| OPEN
121	//;
122	if (ctx->KW_OPEN())	113,692✔
123	return update_code_position(HdlValueSymbol::open(), ctx);	89✔
124	auto sti = ctx->subtype_indication();	113,603✔
125	if (sti)	113,603✔
126	return VhdlTypeDeclarationParser::visitSubtype_indication(sti);	4✔
127	return visitExpression(ctx->expression());	113,599✔
128	}
129
130	unique_ptr<iHdlExprItem> VhdlExprParser::visitResolution_indication(	48✔
131	vhdlParser::Resolution_indicationContext *ctx) {
132	// resolution_indication:
133	// name \| LPAREN element_resolution RPAREN
134	// ;
135	// element_resolution: array_element_resolution \| record_resolution;
136	auto n = ctx->name();	48✔
137	if (n) {	48✔
138	return VhdlReferenceParser::visitName(n);	36✔
139	}
140
141	NotImplementedLogger::print(	12✔
142	"ExprParser.visitResolution_indication - element_resolution", ctx);
143	return create_object<HdlExprNotImplemented>(ctx);	12✔
144	}
145
146	unique_ptr<iHdlExprItem> VhdlExprParser::visitDiscrete_range(	10,645✔
147	vhdlParser::Discrete_rangeContext *ctx) {
148	// discrete_range
149	// : range
150	// \| subtype_indication
151	// ;
152	auto r = ctx->range();	10,645✔
153	if (r)	10,645✔
154	return visitRange(r);	1,935✔
155	return VhdlTypeDeclarationParser::visitSubtype_indication(ctx->subtype_indication());	8,710✔
156	}
157
158	HdlOpType VhdlExprParser::visitSign(vhdlParser::SignContext *ctx) {	×
159	// sign: PLUS \| MINUS;
160	if (ctx->MINUS()) {	×
161	return HdlOpType::SUB;	×
162	} else {
163	assert(ctx->PLUS());	×
164	return HdlOpType::ADD;	×
165	}
166	}
167
168	void aggregate_to_parenthesis(unique_ptr<iHdlExprItem> &o) {	53,975✔
169	auto v = dynamic_cast<HdlValueArr*>(o.get());	53,975✔
170	if (v && v->_arr && v->_arr->size() == 1) {	53,975✔
171	o = move(v->_arr->at(0));	47✔
172	}
173	}	53,975✔
174
175	unique_ptr<iHdlExprItem> VhdlExprParser::visitSimple_expression(	353,544✔
176	vhdlParser::Simple_expressionContext *ctx) {
177	// simple_expression:
178	// primary ( DOUBLESTAR primary )?
179	// \| ( KW_ABS \| KW_NOT \| logical_operator \| sign ) simple_expression
180	// \| simple_expression multiplying_operator simple_expression
181	// \| simple_expression adding_operator simple_expression
182	// ;
183	auto _primary = ctx->primary();	353,544✔
184	if (_primary.size() == 1) {	353,544✔
185	return visitPrimary(_primary[0]);	323,881✔
186	} else if (_primary.size() == 2) {	29,663✔
187	auto p0 = visitPrimary(_primary[0]);	321✔
188	aggregate_to_parenthesis(p0);	321✔
189	auto p1 = visitPrimary(_primary[1]);	321✔
190	aggregate_to_parenthesis(p1);	321✔
191	assert(ctx->DOUBLESTAR());	321✔
192	return create_object<HdlOp>(ctx, move(p0), HdlOpType::POW,	642✔
193	move(p1));	642✔
194	}	321✔
195	auto se = ctx->simple_expression();	29,342✔
196	HdlOpType op;
197	if (se.size() == 1) {	29,342✔
198	if (ctx->KW_ABS()) {	5,376✔
199	op = HdlOpType::ABS;	136✔
200	} else if (ctx->KW_NOT()) {	5,240✔
201	op = HdlOpType::NEG;	3,294✔
202	} else {
203	auto lo = ctx->logical_operator();	1,946✔
204	if (lo) {	1,946✔
205	op = HdlOpType_from(lo);	138✔
206	} else {
207	auto s = ctx->sign();	1,808✔
208	assert(s);	1,808✔
209	op = HdlOpType_from(s);	1,808✔
210	}
211	op = HdlOpType_toUnary(op);	1,946✔
212	}
213	auto se0 = visitSimple_expression(se[0]);	5,376✔
214	aggregate_to_parenthesis(se0);	5,376✔
215	return create_object<HdlOp>(ctx, op, move(se0));	5,376✔
216	} else {	5,376✔
217	assert(se.size() == 2);	23,966✔
218	auto mo = ctx->multiplying_operator();	23,966✔
219	if (mo) {	23,966✔
220	op = HdlOpType_from(mo);	3,531✔
221	} else {
222	auto ao = ctx->adding_operator();	20,435✔
223	assert(ao);	20,435✔
224	op = HdlOpType_from(ao);	20,435✔
225	}
226
227	auto se0 = visitSimple_expression(se[0]);	23,966✔
228	aggregate_to_parenthesis(se0);	23,966✔
229	auto se1 = visitSimple_expression(se[1]);	23,966✔
230	aggregate_to_parenthesis(se1);	23,966✔
231	return create_object<HdlOp>(ctx, move(se0), op, move(se1));	23,966✔
232	}	23,966✔
233	}	353,544✔
234	unique_ptr<iHdlExprItem> VhdlExprParser::visitExpression(	309,529✔
235	vhdlParser::ExpressionContext *ctx) {
236	// expression:
237	// COND_OP primary
238	// \| simple_expression
239	// \| expression shift_operator expression
240	// \| expression relational_operator expression
241	// \| expression logical_operator expression
242	// ;
243
244	if (ctx->COND_OP()) {	309,529✔
245	NotImplementedLogger::print(	25✔
246	"ExprParser.visitExpression - CONDITION_OPERATOR", ctx);
247	auto p = ctx->primary();	25✔
248	assert(p);	25✔
249	auto vp = visitPrimary(p);	25✔
250	aggregate_to_parenthesis(vp);	25✔
251	return vp;	25✔
UNCOV 252	}	×
253	auto _se = ctx->simple_expression();	309,504✔
254	if (_se) {	309,504✔
255	return visitSimple_expression(_se);	268,365✔
256	}
257	auto _ops = ctx->expression();	41,139✔
258	assert(_ops.size() == 2);	41,139✔
259	auto op0 = visitExpression(_ops[0]);	41,139✔
260	auto op1 = visitExpression(_ops[1]);	41,139✔
261	auto so = ctx->shift_operator();	41,139✔
262	HdlOpType op;
263	if (so) {	41,139✔
264	op = HdlOpType_from(so);	120✔
265	} else {
266	auto ro = ctx->relational_operator();	41,019✔
267	if (ro) {	41,019✔
268	op = HdlOpType_from(ro);	15,567✔
269	} else {
270	auto lo = ctx->logical_operator();	25,452✔
271	assert(lo);	25,452✔
272	op = HdlOpType_from(lo);	25,452✔
273	}
274	}
275	return create_object<HdlOp>(ctx, move(op0), op, move(op1));	41,139✔
276	}	41,139✔
277
278	unique_ptr<iHdlExprItem> VhdlExprParser::visitPrimary(	324,548✔
279	vhdlParser::PrimaryContext *ctx) {
280	//primary:
281	// numeric_literal #primaryNum
282	// \| BIT_STRING_LITERAL #primaryBitStr
283	// \| KW_NULL #primaryLiteral
284	// \| allocator #primaryAllocator
285	// \| aggregate #primaryAggregate
286	// \| qualified_expression #primaryQualifiedExpr
287	//;
288	auto nl = ctx->numeric_literal();	324,548✔
289	if (nl)	324,548✔
290	return VhdlLiteralParser::visitNumeric_literal(nl);	301,615✔
291
292	if (ctx->KW_NULL())	22,933✔
293	return update_code_position(HdlValueSymbol::null(), ctx);	95✔
294
295	auto bsl = ctx->BIT_STRING_LITERAL();	22,838✔
296	if (bsl) {	22,838✔
297	return VhdlLiteralParser::visitBIT_STRING_LITERAL(bsl, bsl->getText());	3,475✔
298	}
299	auto al = ctx->allocator();	19,363✔
300	if (al)	19,363✔
301	return visitAllocator(al);	140✔
302	auto ag = ctx->aggregate();	19,223✔
303	if (ag) {	19,223✔
304	return visitAggregate(ag);	18,245✔
305	}
306	auto qe = ctx->qualified_expression();	978✔
307	assert(qe);	978✔
308	return visitQualified_expression(qe);	978✔
309	}
310
311	unique_ptr<iHdlExprItem> VhdlExprParser::visitQualified_expression(	1,040✔
312	vhdlParser::Qualified_expressionContext *ctx) {
313	// qualified_expression:
314	// type_mark APOSTROPHE aggregate
315	// ;
316	auto _tm = ctx->type_mark();	1,040✔
317	auto tm = visitType_mark(_tm);	1,040✔
318	auto a = ctx->aggregate();	1,040✔
319	auto e = visitAggregate(a);	1,040✔
320	return create_object<HdlOp>(ctx, move(tm), HdlOpType::APOSTROPHE,	2,080✔
321	move(e));	3,120✔
322	}	1,040✔
323
324	unique_ptr<iHdlExprItem> VhdlExprParser::visitAllocator(	140✔
325	vhdlParser::AllocatorContext *ctx) {
326	// allocator
327	// : KW_NEW ( qualified_expression \| subtype_indication )
328	// ;
329	auto n = create_object<HdlValueId>(ctx->KW_NEW(), "new");	140✔
330	unique_ptr<iHdlExprItem> e;	140✔
331	auto qe = ctx->qualified_expression();	140✔
332	if (qe)	140✔
333	e = visitQualified_expression(qe);	62✔
334	else {
335	auto si = ctx->subtype_indication();	78✔
336	e = VhdlTypeDeclarationParser::visitSubtype_indication(si);	78✔
337	}
338	return create_object<HdlOp>(ctx, move(n), HdlOpType::CALL, move(e));	280✔
339	}	140✔
340
341	unique_ptr<iHdlExprItem> VhdlExprParser::visitAggregate(	19,313✔
342	vhdlParser::AggregateContext *ctx) {
343	// aggregate:
344	// LPAREN element_association ( COMMA element_association )* RPAREN
345	// ;
346	vector<unique_ptr<iHdlExprItem>> elements;	19,313✔
347	for (auto elm : ctx->element_association()) {	50,058✔
348	auto e = visitElement_association(elm);	30,745✔
349	elements.push_back(move(e));	30,745✔
350	}	50,058✔
351	if (elements.size() == 1) {	19,313✔
352	auto e = dynamic_cast<HdlOp*>(elements[0].get());	16,998✔
353	if (!e \|\| e->op != HdlOpType::MAP_ASSOCIATION)	16,998✔
354	return move(elements[0]);	14,233✔
355	}
356	return create_object<HdlValueArr>(ctx, elements);	5,080✔
357	}	19,313✔
358
359	unique_ptr<iHdlExprItem> VhdlExprParser::visitElement_association(	30,745✔
360	vhdlParser::Element_associationContext *ctx) {
361	// ement_association
362	// : ( choices ARROW )? expression
363	// ;
364	auto e = visitExpression(ctx->expression());	30,745✔
365	auto _c = ctx->choices();	30,745✔
366	if (_c) {	30,745✔
367	auto ch = visitChoices(_c);	6,531✔
368	if (ch.size() > 1) {	6,531✔
369	NotImplementedLogger::print(	110✔
370	"ExprParser.visitElement_association - multiple choices",
371	_c);
372	}
373	assert(ch.size());	6,531✔
374	return create_object<HdlOp>(ctx, move(ch[0]),	13,062✔
375	HdlOpType::MAP_ASSOCIATION, move(e));	13,062✔
376	}	6,531✔
377	return e;	24,214✔
378	}	30,745✔
379
380	unique_ptr<iHdlExprItem> VhdlExprParser::visitTarget(	26,275✔
381	vhdlParser::TargetContext *ctx) {
382	// target
383	// : name
384	// \| aggregate
385	// ;
386	auto n = ctx->name();	26,275✔
387	if (n) {	26,275✔
388	return VhdlReferenceParser::visitName(n);	26,247✔
389	} else {
390	return visitAggregate(ctx->aggregate());	28✔
391	}
392	}
393
394	unique_ptr<iHdlExprItem> VhdlExprParser::visitWaveform(	10,685✔
395	vhdlParser::WaveformContext *ctx) {
396	// waveform :
397	// waveform_element ( COMMA waveform_element )*
398	// \| UNAFFECTED
399	// ;
400	if (ctx->KW_UNAFFECTED()) {	10,685✔
401	NotImplementedLogger::print("ExprParser.visitWaveform - UNAFFECTED",	×
402	ctx);
403	return create_object<HdlExprNotImplemented>(ctx);	×
404	}
405	auto we = ctx->waveform_element();	10,685✔
406	auto weIt = we.begin();	10,685✔
407
408	auto top = visitWaveform_element(*weIt);	10,685✔
409	++weIt;	10,685✔
410	while (weIt != we.end()) {	10,752✔
411	top = create_object<HdlOp>(ctx, move(top), DOT,	134✔
412	visitWaveform_element(*weIt));	201✔
413	++weIt;	67✔
414	}
415
416	return top;	10,685✔
417	}	10,685✔
418
419	unique_ptr<iHdlExprItem> VhdlExprParser::visitCondition(	15,933✔
420	vhdlParser::ConditionContext *ctx) {
421	// condition
422	// : expression
423	// ;
424	return VhdlExprParser::visitExpression(ctx->expression());	15,933✔
425	}
426
427	unique_ptr<iHdlExprItem> VhdlExprParser::visitConditional_waveforms(	571✔
428	vhdlParser::Conditional_waveformsContext *ctx) {
429	// conditional_waveforms:
430	// waveform WHEN condition
431	// ( ELSE waveform WHEN condition )*
432	// ( ELSE waveform )?
433	// ;
434	auto waveforms = ctx->waveform();	571✔
435	auto conditions = ctx->condition();	571✔
436	auto c = conditions.rbegin();	571✔
437	unique_ptr<iHdlExprItem> res = nullptr;	571✔
438	for (auto w = waveforms.rbegin(); w != waveforms.rend(); ++w) {	1,742✔
439	auto w_expr = visitWaveform(*w);	1,171✔
440	if (res == nullptr) {	1,171✔
441	// the first iteration
442	bool has_default_else = waveforms.size() > conditions.size();	571✔
443	if (has_default_else) {	571✔
444	// this waveform is a default else
445	res = move(w_expr);	544✔
446	continue;	544✔
447	}
448	}
449	auto c_expr = visitCondition(*c);	627✔
450	res = HdlOp::ternary(*w, move(c_expr), move(w_expr), move(res));	627✔
451	c++;	627✔
452	}	1,171✔
453	return res;	571✔
454	}	571✔
455
456	unique_ptr<iHdlExprItem> VhdlExprParser::visitWaveform_element(	10,752✔
457	vhdlParser::Waveform_elementContext *ctx) {
458	// waveform_element :
459	// expression ( AFTER expression )?
460	// ;
461	auto ex = ctx->expression();	10,752✔
462	auto e = ex.begin();	10,752✔
463	auto top = visitExpression(*e);	10,752✔
464	++e;	10,752✔
465	if (e != ex.end()) {	10,752✔
466	NotImplementedLogger::print(	333✔
467	"ExprParser.visitWaveform_element - AFTER expression", ctx);
468	}
469	return top;	10,752✔
470	}	10,752✔
471
472	unique_ptr<iHdlExprItem> VhdlExprParser::visitChoice(	11,481✔
473	vhdlParser::ChoiceContext *ctx) {
474	// choice:
475	// discrete_range
476	// \| simple_expression
477	// \| OTHERS
478	// ;
479
480	auto dr = ctx->discrete_range();	11,481✔
481	if (dr) {	11,481✔
482	return visitDiscrete_range(dr);	6,889✔
483	}
484	auto se = ctx->simple_expression();	4,592✔
485	if (se) {	4,592✔
486	return VhdlExprParser::visitSimple_expression(se);	1,297✔
487	}
488	#ifndef NDEBUG
489	auto o = ctx->KW_OTHERS();	3,295✔
490	assert(o);	3,295✔
491	#endif
492	return update_code_position(HdlValueSymbol::others(), ctx);	3,295✔
493	}
494	vector<unique_ptr<iHdlExprItem>> VhdlExprParser::visitChoices(	10,625✔
495	vhdlParser::ChoicesContext *ctx) {
496	// choices: choice ( choice )*;
497	vector<unique_ptr<iHdlExprItem>> res;	10,625✔
498	auto _choice = ctx->choice();	10,625✔
499	for (auto c : _choice) {	22,106✔
500	res.push_back(visitChoice(c));	11,481✔
501	}
502	return res;	10,625✔
503	}	10,625✔
504
505	unique_ptr<iHdlExprItem> VhdlExprParser::visitProcedure_call_statement(	14,785✔
506	vhdlParser::Procedure_call_statementContext *ctx) {
507	// procedure_call_statement: procedure_call SEMI
508	// ;
509	return visitProcedure_call(ctx->procedure_call());	14,785✔
510	}
511	unique_ptr<iHdlExprItem> VhdlExprParser::visitProcedure_call(	14,785✔
512	vhdlParser::Procedure_callContext *ctx) {
513	// procedure_call: name;
514	auto fnCall = VhdlReferenceParser::visitName(ctx->name());	14,785✔
515	auto c = dynamic_cast<HdlOp*>(fnCall.get());	14,785✔
516
517	if (c == nullptr \|\| c->op != HdlOpType::CALL) {	14,785✔
518	if (c && c->op == HdlOpType::INDEX) {	14,785✔
519	c->op = HdlOpType::CALL;	13,903✔
520	return fnCall;	13,903✔
521	}
522	vector<unique_ptr<iHdlExprItem>> args;	882✔
523	return HdlOp::call(ctx, move(fnCall), args);	882✔
524	}	882✔
525	return fnCall;	×
526	}	14,785✔
527
528	unique_ptr<iHdlExprItem> VhdlExprParser::visitType_mark(	92,648✔
529	vhdlParser::Type_markContext *ctx) {
530	// type_mark: name;
531	auto n = ctx->name();	92,648✔
532	return VhdlReferenceParser::visitName(n);	92,648✔
533	}
534
535	}
536	}

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