4786b3d5-2c0a-4dcc-9603-9e1f17164010

Committed 22 May 2024 11:43AM UTC coverage: 91.569% (-0.09%) from 91.659%

Build # 4786b3d5-2c0a-4dcc-9603-9e1f17164010

Build Type

push

circleci

Committed by

Nic30

Commit Message

refactor!: unify naming convention for .name, ._name, ._hdl_name attrs

* Nic30/hwt#17

Run Details

175 of 205 branches covered (85.37%)

Branch coverage included in aggregate %.

1 of 2 new or added lines in 2 files covered. (50.0%)

3 existing lines in 1 file now uncovered.

759 of 815 relevant lines covered (93.13%)

0.93 hits per line

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

94.07

/ipCorePackager/intfIpMeta.py

from typing import List, Dict, Union

from ipCorePackager.constants import INTF_DIRECTION
from ipCorePackager.otherXmlObjs import Parameter
from ipCorePackager.type import Type


class IntfIpMetaNotSpecifiedError(Exception):
    """
    This error means that you need to implement this function
    to use this functionality

    e.g. you have to implement Simulation agent for interface
    if you create new one and you can not use existing
    """
    pass


class VALUE_RESOLVE:
    IMMEDIATE = "immediate"
    USER = "user"
    NONE = None


class IntfIpMeta(Type):

    def __init__(self):
        self.parameters = []

        self.name = None
        self.quartus_name = None

        self.map = {}
        self.quartus_map = None

    def _asQuartusTcl(self, buff: List[str], version: str, intfName: str,
                      component: "Component", packager: "IpPackager",
                      thisIf: 'HwIO', intfMapOrName: Dict[str, Union[Dict, str]]):
        """
        Add interface to Quartus tcl by specified name map

        :param buff: line buffer for output
        :param version: Quartus version
        :param intfName: name of top interface
        :param component: component object from ipcore generator
        :param packager: instance of IpPackager which is packaging current design
        :param thisIf: interface to add into Quartus TCL
        :param intfMapOrName: Quartus name string for this interface
            or dictionary to map child HwIO instances
        """

        if isinstance(intfMapOrName, str):
            self.quartus_add_interface_port(
                buff, intfName, thisIf, intfMapOrName, packager)
        else:
            for thisIf_ in thisIf._hwIOs:
                v = intfMapOrName[thisIf_._name]
                self._asQuartusTcl(buff, version, intfName, component,
                                   packager, thisIf_, v)

    def asQuartusTcl(self, buff: List[str], version: str, component: "Component",
                     packager: "IpPackager", thisIf: 'HwIO'):
        """
        Add interface to Quartus tcl

        :param buff: line buffer for output
        :param version: Quartus version
        :param intfName: name of top interface
        :param component: component object from ipcore generator
        :param packager: instance of IpPackager which is packaging current design
        :param allInterfaces: list of all interfaces of top unit
        :param thisIf: interface to add into Quartus TCL
        """
        name = packager.getInterfaceLogicalName(thisIf)
        self.quartus_tcl_add_interface(buff, thisIf, packager)
        clk = thisIf._getAssociatedClk()
        if clk is not None:
            self.quartus_prop(buff, name, "associatedClock",
                              clk._sigInside._name, escapeStr=False)
        rst = thisIf._getAssociatedRst()
        if rst is not None:
            self.quartus_prop(buff, name, "associatedReset",
                              rst._sigInside._name, escapeStr=False)

        m = self.get_quartus_map()
        if m:
            intfMapOrName = m
        else:
            intfMapOrName = thisIf._name
        self._asQuartusTcl(buff, version, name, component,
                           packager, thisIf, intfMapOrName)

    def get_quartus_map(self):
        if self.quartus_map is None:
            return self.map
        else:
            return self.quartus_map

    def get_quartus_name(self):
        if self.quartus_name is None:
            return self.name
        else:
            return self.quartus_name

    def addWidthParam(self, thisIntfName: str, name: str, value, packager: "IpCorePackager"):
        _, v_str, v_is_const = packager.serialzeValueToTCL(value, do_eval=True)
        p = self.addSimpleParam(thisIntfName, name, v_str)
        if v_is_const:
            p.value.resolve = VALUE_RESOLVE.USER

    def addSimpleParam(self, interfaceLogicalName: str, paramName: str, value: str,
                       resolve=VALUE_RESOLVE.IMMEDIATE):
        p = Parameter()
        p.name = paramName
        if resolve is not VALUE_RESOLVE.NONE:
            p.value.resolve = resolve
        p.value.id = "BUSIFPARAM_VALUE.%s.%s" % (interfaceLogicalName.upper(),
                                                 paramName.upper())
        p.value.text = value
        self.parameters.append(p)
        return p

    def postProcess(self, component, packager, thisIf):
        pass

    def quartus_tcl_add_interface(self, buff, thisIntf, packager):
        """
        Create interface in Quartus TCL

        :return: add_interface command string
        """
        if packager.getInterfaceDirection(thisIntf) == INTF_DIRECTION.MASTER:
            dir_ = "start"
        else:
            dir_ = "end"

        name = packager.getInterfaceLogicalName(thisIntf)
        q_name =  self.get_quartus_name()
        buff.extend([f"add_interface {name:s} {q_name:s} {dir_:s}"])

        self.quartus_prop(buff, name, "ENABLED", True)
        self.quartus_prop(buff, name, "EXPORT_OF", "")
        self.quartus_prop(buff, name, "PORT_NAME_MAP", "")
        self.quartus_prop(buff, name, "CMSIS_SVD_VARIABLES", "")
        self.quartus_prop(buff, name, "SVD_ADDRESS_GROUP", "")

    def quartus_prop(self, buff: List[str], intfName: str, name: str, value,
                     escapeStr=True):
        """
        Set property on interface in Quartus TCL

        :param buff: line buffer for output
        :param intfName: name of interface to set property on
        :param name: property name
        :param value: property value
        :param escapeStr: flag, if True put string properties to extra ""
        """
        if escapeStr and isinstance(value, str):
            value = '"%s"' % value
        elif isinstance(value, bool):
            value = str(value).lower()
        else:
            value = str(value)

        buff.append(f"set_interface_property {intfName:s} {name:s} {value:s}")

    def quartus_add_interface_port(self, buff: List[str], intfName: str, signal,
                                   logicName: str, packager: "IpCorePackager"):
        """
        Add subinterface to Quartus interface

        :param buff: line buffer for output
        :param intfName: name of top interface
        :param signal: subinterface to create port for
        :param logicName: name of port in Quartus
        """
        d = signal._direction
        if d == INTF_DIRECTION.MASTER:
            dir_ = "Output"
        elif d == INTF_DIRECTION.SLAVE:
            dir_ = "Input"
        else:
            raise ValueError(d)

        _, width, _ = packager.getTypeWidth(packager.getInterfaceType(signal), do_eval=True)

        phy_name = packager.getInterfacePhysicalName(signal)
        buff.append(f"add_interface_port {intfName:s} {phy_name:s} {logicName:s} {dir_:s} {width:s}")

1	from typing import List, Dict, Union	1✔
2
3	from ipCorePackager.constants import INTF_DIRECTION	1✔
4	from ipCorePackager.otherXmlObjs import Parameter	1✔
5	from ipCorePackager.type import Type	1✔
6
7
8	class IntfIpMetaNotSpecifiedError(Exception):	1✔
9	"""
10	This error means that you need to implement this function
11	to use this functionality
12
13	e.g. you have to implement Simulation agent for interface
14	if you create new one and you can not use existing
15	"""
16	pass	1✔
17
18
19	class VALUE_RESOLVE:	1✔
20	IMMEDIATE = "immediate"	1✔
21	USER = "user"	1✔
22	NONE = None	1✔
23
24
25	class IntfIpMeta(Type):	1✔
26
27	def __init__(self):	1✔
28	self.parameters = []	1✔
29
30	self.name = None	1✔
31	self.quartus_name = None	1✔
32
33	self.map = {}	1✔
34	self.quartus_map = None	1✔
35
36	def _asQuartusTcl(self, buff: List[str], version: str, intfName: str,	1✔
37	component: "Component", packager: "IpPackager",
38	thisIf: 'HwIO', intfMapOrName: Dict[str, Union[Dict, str]]):
39	"""
40	Add interface to Quartus tcl by specified name map
41
42	:param buff: line buffer for output
43	:param version: Quartus version
44	:param intfName: name of top interface
45	:param component: component object from ipcore generator
46	:param packager: instance of IpPackager which is packaging current design
47	:param thisIf: interface to add into Quartus TCL
48	:param intfMapOrName: Quartus name string for this interface
49	or dictionary to map child HwIO instances
50	"""
51
52	if isinstance(intfMapOrName, str):	1✔
53	self.quartus_add_interface_port(	1✔
54	buff, intfName, thisIf, intfMapOrName, packager)
55	else:
56	for thisIf_ in thisIf._hwIOs:	1✔
57	v = intfMapOrName[thisIf_._name]	1✔
58	self._asQuartusTcl(buff, version, intfName, component,	1✔
59	packager, thisIf_, v)
60
61	def asQuartusTcl(self, buff: List[str], version: str, component: "Component",	1✔
62	packager: "IpPackager", thisIf: 'HwIO'):
63	"""
64	Add interface to Quartus tcl
65
66	:param buff: line buffer for output
67	:param version: Quartus version
68	:param intfName: name of top interface
69	:param component: component object from ipcore generator
70	:param packager: instance of IpPackager which is packaging current design
71	:param allInterfaces: list of all interfaces of top unit
72	:param thisIf: interface to add into Quartus TCL
73	"""
74	name = packager.getInterfaceLogicalName(thisIf)	1✔
75	self.quartus_tcl_add_interface(buff, thisIf, packager)	1✔
76	clk = thisIf._getAssociatedClk()	1✔
77	if clk is not None:	1!
78	self.quartus_prop(buff, name, "associatedClock",	1✔
79	clk._sigInside._name, escapeStr=False)
80	rst = thisIf._getAssociatedRst()	1✔
81	if rst is not None:	1!
82	self.quartus_prop(buff, name, "associatedReset",	1✔
83	rst._sigInside._name, escapeStr=False)
84
85	m = self.get_quartus_map()	1✔
86	if m:	1!
87	intfMapOrName = m	1✔
88	else:
NEW 89	intfMapOrName = thisIf._name	×
90	self._asQuartusTcl(buff, version, name, component,	1✔
91	packager, thisIf, intfMapOrName)
92
93	def get_quartus_map(self):	1✔
94	if self.quartus_map is None:	1✔
95	return self.map	1✔
96	else:
97	return self.quartus_map	1✔
98
99	def get_quartus_name(self):	1✔
100	if self.quartus_name is None:	1✔
101	return self.name	1✔
102	else:
103	return self.quartus_name	1✔
104
105	def addWidthParam(self, thisIntfName: str, name: str, value, packager: "IpCorePackager"):	1✔
106	_, v_str, v_is_const = packager.serialzeValueToTCL(value, do_eval=True)	1✔
107	p = self.addSimpleParam(thisIntfName, name, v_str)	1✔
108	if v_is_const:	1!
109	p.value.resolve = VALUE_RESOLVE.USER	1✔
110
111	def addSimpleParam(self, interfaceLogicalName: str, paramName: str, value: str,	1✔
112	resolve=VALUE_RESOLVE.IMMEDIATE):
113	p = Parameter()	1✔
114	p.name = paramName	1✔
115	if resolve is not VALUE_RESOLVE.NONE:	1✔
116	p.value.resolve = resolve	1✔
117	p.value.id = "BUSIFPARAM_VALUE.%s.%s" % (interfaceLogicalName.upper(),	1✔
118	paramName.upper())
119	p.value.text = value	1✔
120	self.parameters.append(p)	1✔
121	return p	1✔
122
123	def postProcess(self, component, packager, thisIf):	1✔
124	pass	1✔
125
126	def quartus_tcl_add_interface(self, buff, thisIntf, packager):	1✔
127	"""
128	Create interface in Quartus TCL
129
130	:return: add_interface command string
131	"""
132	if packager.getInterfaceDirection(thisIntf) == INTF_DIRECTION.MASTER:	1✔
133	dir_ = "start"	1✔
134	else:
135	dir_ = "end"	1✔
136
137	name = packager.getInterfaceLogicalName(thisIntf)	1✔
138	q_name = self.get_quartus_name()	1✔
139	buff.extend([f"add_interface {name:s} {q_name:s} {dir_:s}"])	1✔
140
141	self.quartus_prop(buff, name, "ENABLED", True)	1✔
142	self.quartus_prop(buff, name, "EXPORT_OF", "")	1✔
143	self.quartus_prop(buff, name, "PORT_NAME_MAP", "")	1✔
144	self.quartus_prop(buff, name, "CMSIS_SVD_VARIABLES", "")	1✔
145	self.quartus_prop(buff, name, "SVD_ADDRESS_GROUP", "")	1✔
146
147	def quartus_prop(self, buff: List[str], intfName: str, name: str, value,	1✔
148	escapeStr=True):
149	"""
150	Set property on interface in Quartus TCL
151
152	:param buff: line buffer for output
153	:param intfName: name of interface to set property on
154	:param name: property name
155	:param value: property value
156	:param escapeStr: flag, if True put string properties to extra ""
157	"""
158	if escapeStr and isinstance(value, str):	1✔
159	value = '"%s"' % value	1✔
160	elif isinstance(value, bool):	1✔
161	value = str(value).lower()	1✔
162	else:
163	value = str(value)	1✔
164
165	buff.append(f"set_interface_property {intfName:s} {name:s} {value:s}")	1✔
166
167	def quartus_add_interface_port(self, buff: List[str], intfName: str, signal,	1✔
168	logicName: str, packager: "IpCorePackager"):
169	"""
170	Add subinterface to Quartus interface
171
172	:param buff: line buffer for output
173	:param intfName: name of top interface
174	:param signal: subinterface to create port for
175	:param logicName: name of port in Quartus
176	"""
177	d = signal._direction	1✔
178	if d == INTF_DIRECTION.MASTER:	1✔
179	dir_ = "Output"	1✔
180	elif d == INTF_DIRECTION.SLAVE:	1!
181	dir_ = "Input"	1✔
182	else:
183	raise ValueError(d)	×
184
185	_, width, _ = packager.getTypeWidth(packager.getInterfaceType(signal), do_eval=True)	1✔
186
187	phy_name = packager.getInterfacePhysicalName(signal)	1✔
188	buff.append(f"add_interface_port {intfName:s} {phy_name:s} {logicName:s} {dir_:s} {width:s}")	1✔

Nic30 / ipCorePackager / 4786b3d5-2c0a-4dcc-9603-9e1f17164010

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