ce646f97-37a3-405d-9336-73b2c85f2bb2

Committed 06 Jun 2024 04:23PM UTC coverage: 80.792% (-0.4%) from 81.165%

Build # ce646f97-37a3-405d-9336-73b2c85f2bb2

Build Type

push

circleci

Committed by

Nic30

Commit Message

Revert "feat(VcdVarIdScope): check for duplicit names"

This reverts commit 7a120b772.

Run Details

63 of 94 branches covered (67.02%)

Branch coverage included in aggregate %.

7 of 7 new or added lines in 1 file covered. (100.0%)

5 existing lines in 1 file now uncovered.

345 of 411 relevant lines covered (83.94%)

0.84 hits per line

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

91.07

/pyDigitalWaveTools/vcd/writer.py

#!/usr/bin/env python3
# -*- coding: utf-8 -*-

import sys

from pyDigitalWaveTools.vcd.common import VcdVarScope, VCD_SIG_TYPE, VcdVarInfo
from pyDigitalWaveTools.vcd.value_format import LogValueFormatter


class VarAlreadyRegistered(Exception):
    pass


class VcdVarWritingInfo(VcdVarInfo):
    """
    Container of informations about variable in VCD for VCD file generating
    """

    def __init__(self, vcdId, name, width, sigType, parent,
                 valueFormatter: LogValueFormatter):
        super(VcdVarWritingInfo, self).__init__(
            vcdId, name, width, sigType, parent)
        valueFormatter.bind_var_info(self)
        self.valueFormatter = valueFormatter.format


class VcdVarIdScope(dict):

    def __init__(self):
        super(VcdVarIdScope, self).__init__()
        self._nextId = 0
        self._idChars = [chr(i) for i in range(ord("!"), ord("~") + 1)]
        self._idCharsCnt = len(self._idChars)

    def _idToStr(self, x):
        """
        Convert VCD id in int to string
        """
        if x < 0:
            sign = -1
        elif x == 0:
            return self._idChars[0]
        else:
            sign = 1
        x *= sign
        digits = []
        while x:
            digits.append(self._idChars[x % self._idCharsCnt])
            x //= self._idCharsCnt
        if sign < 0:
            digits.append('-')
        digits.reverse()

        return ''.join(digits)

    def registerVariable(self, sig: object, name: str, parent: VcdVarScope,
                         width: int, sigType: VCD_SIG_TYPE,
                         valueFormatter: LogValueFormatter):
        varId = self._idToStr(self._nextId)
        if sig is not None and sig in self:
            raise VarAlreadyRegistered(f"{sig} is already registered")
        vInf = VcdVarWritingInfo(
            varId, name, width, sigType, parent, valueFormatter)
        self[sig] = vInf
        self._nextId += 1
        return vInf


class VcdVarWritingScope(VcdVarScope):
    """
    Vcd module - container for variables

    :ivar ~.oFile: output file to write vcd to
    :ivar ~.name: name of scope
    :ivar ~.vars: subscopes or signals
    """

    def __init__(self, name, writer, parent=None):
        super(VcdVarWritingScope, self).__init__(name, parent=parent)
        self._writer = writer

    def addVar(self, sig: object, name: str, sigType: VCD_SIG_TYPE, width: int,
               valueFormatter: LogValueFormatter):
        """
        Add variable to scope

        :ivar ~.sig: user specified object to keep track of VcdVarInfo in change()
        :ivar ~.sigType: vcd type name
        :ivar ~.valueFormatter: value which converts new value in change() to vcd string
        """
        assert name, sig
        vInf = self._writer._idScope.registerVariable(sig, name, self, width,
                                                      sigType, valueFormatter)
        self.children[vInf.name] = vInf
        self._writer._oFile.write(f"$var {sigType:s} {vInf.width:d} {vInf.vcdId:s} {vInf.name:s} $end\n")

    def varScope(self, name):
        """
        Create sub variable scope with defined name
        """
        ch = self.__class__(name, self._writer, parent=self)
        assert name not in self.children, (name, "Names of scopes and variables must be unique")
        self.children[name] = ch
        return ch

    def __enter__(self) -> "VcdVarWritingScope":
        self._writeHeader()
        return self

    def __exit__(self, exc_type, exc_val, exc_tb):
        if exc_type is None:
            self._writeFooter()

    def _writeHeader(self):
        self._writer._oFile.write(f"$scope module {self.name:s} $end\n")

    def _writeFooter(self):
        self._writer._oFile.write("$upscope $end\n")


class VcdWriter():

    def __init__(self, oFile=sys.stdout):
        self._oFile = oFile
        self._idScope = VcdVarIdScope()
        self.scopes = []
        self.lastTime = -1

    def date(self, text):
        d = str(text)
        self._oFile.write(f"$date\n   {d:s}\n$end\n")

    def version(self, text):
        self._oFile.write(f"$version   \n{text:s}\n$end\n")

    def timescale(self, picoSeconds):
        self._oFile.write(f"$timescale {picoSeconds:d}ps $end\n")

    def varScope(self, name) -> VcdVarWritingScope:
        """
        Create sub variable scope with defined name
        """
        s = VcdVarWritingScope(name, self, parent=self)
        self.scopes.append(s)
        return s

    def enddefinitions(self):
        self._oFile.write("$enddefinitions $end\n")

    def setTime(self, t):
        lt = self.lastTime
        if lt == t:
            return
        elif lt < t:
            self.lastTime = t
            self._oFile.write(f"#{t:d}\n")
        else:
            raise Exception(f"VcdWriter invalid time update {lt:d} -> {t:d}")

    def logChange(self, time, sig, newVal, valueUpdater):
        self.setTime(time)
        varInfo = self._idScope[sig]
        varInfo.valueFormatter(newVal, valueUpdater, time, self._oFile)


if __name__ == "__main__":
    from datetime import datetime
    from pyDigitalWaveTools.vcd.value_format import VcdBitsFormatter
    from tests.vcdWriter_test import example_dump_values0

    vcd = VcdWriter()
    vcd.date(datetime.now())
    vcd.timescale(1)
    example_dump_values0(vcd, VcdBitsFormatter)


1	#!/usr/bin/env python3
2	# -- coding: utf-8 --
3
4	import sys	1✔
5
6	from pyDigitalWaveTools.vcd.common import VcdVarScope, VCD_SIG_TYPE, VcdVarInfo	1✔
7	from pyDigitalWaveTools.vcd.value_format import LogValueFormatter	1✔
8
9
10	class VarAlreadyRegistered(Exception):	1✔
11	pass	1✔
12
13
14	class VcdVarWritingInfo(VcdVarInfo):	1✔
15	"""
16	Container of informations about variable in VCD for VCD file generating
17	"""
18
19	def __init__(self, vcdId, name, width, sigType, parent,	1✔
20	valueFormatter: LogValueFormatter):
21	super(VcdVarWritingInfo, self).__init__(	1✔
22	vcdId, name, width, sigType, parent)
23	valueFormatter.bind_var_info(self)	1✔
24	self.valueFormatter = valueFormatter.format	1✔
25
26
27	class VcdVarIdScope(dict):	1✔
28
29	def __init__(self):	1✔
30	super(VcdVarIdScope, self).__init__()	1✔
31	self._nextId = 0	1✔
32	self._idChars = [chr(i) for i in range(ord("!"), ord("~") + 1)]	1✔
33	self._idCharsCnt = len(self._idChars)	1✔
34
35	def _idToStr(self, x):	1✔
36	"""
37	Convert VCD id in int to string
38	"""
39	if x < 0:	1!
UNCOV 40	sign = -1	×
41	elif x == 0:	1✔
42	return self._idChars[0]	1✔
43	else:
44	sign = 1	1✔
45	x *= sign	1✔
46	digits = []	1✔
47	while x:	1✔
48	digits.append(self._idChars[x % self._idCharsCnt])	1✔
49	x //= self._idCharsCnt	1✔
50	if sign < 0:	1!
UNCOV 51	digits.append('-')	×
52	digits.reverse()	1✔
53
54	return ''.join(digits)	1✔
55
56	def registerVariable(self, sig: object, name: str, parent: VcdVarScope,	1✔
57	width: int, sigType: VCD_SIG_TYPE,
58	valueFormatter: LogValueFormatter):
59	varId = self._idToStr(self._nextId)	1✔
60	if sig is not None and sig in self:	1!
UNCOV 61	raise VarAlreadyRegistered(f"{sig} is already registered")	×
62	vInf = VcdVarWritingInfo(	1✔
63	varId, name, width, sigType, parent, valueFormatter)
64	self[sig] = vInf	1✔
65	self._nextId += 1	1✔
66	return vInf	1✔
67
68
69	class VcdVarWritingScope(VcdVarScope):	1✔
70	"""
71	Vcd module - container for variables
72
73	:ivar ~.oFile: output file to write vcd to
74	:ivar ~.name: name of scope
75	:ivar ~.vars: subscopes or signals
76	"""
77
78	def __init__(self, name, writer, parent=None):	1✔
79	super(VcdVarWritingScope, self).__init__(name, parent=parent)	1✔
80	self._writer = writer	1✔
81
82	def addVar(self, sig: object, name: str, sigType: VCD_SIG_TYPE, width: int,	1✔
83	valueFormatter: LogValueFormatter):
84	"""
85	Add variable to scope
86
87	:ivar ~.sig: user specified object to keep track of VcdVarInfo in change()
88	:ivar ~.sigType: vcd type name
89	:ivar ~.valueFormatter: value which converts new value in change() to vcd string
90	"""
91	assert name, sig	1✔
92	vInf = self._writer._idScope.registerVariable(sig, name, self, width,	1✔
93	sigType, valueFormatter)
94	self.children[vInf.name] = vInf	1✔
95	self._writer._oFile.write(f"$var {sigType:s} {vInf.width:d} {vInf.vcdId:s} {vInf.name:s} $end\n")	1✔
96
97	def varScope(self, name):	1✔
98	"""
99	Create sub variable scope with defined name
100	"""
101	ch = self.__class__(name, self._writer, parent=self)	1✔
102	assert name not in self.children, (name, "Names of scopes and variables must be unique")	1✔
103	self.children[name] = ch	1✔
104	return ch	1✔
105
106	def __enter__(self) -> "VcdVarWritingScope":	1✔
107	self._writeHeader()	1✔
108	return self	1✔
109
110	def __exit__(self, exc_type, exc_val, exc_tb):	1✔
111	if exc_type is None:	1!
112	self._writeFooter()	1✔
113
114	def _writeHeader(self):	1✔
115	self._writer._oFile.write(f"$scope module {self.name:s} $end\n")	1✔
116
117	def _writeFooter(self):	1✔
118	self._writer._oFile.write("$upscope $end\n")	1✔
119
120
121	class VcdWriter():	1✔
122
123	def __init__(self, oFile=sys.stdout):	1✔
124	self._oFile = oFile	1✔
125	self._idScope = VcdVarIdScope()	1✔
126	self.scopes = []	1✔
127	self.lastTime = -1	1✔
128
129	def date(self, text):	1✔
130	d = str(text)	1✔
131	self._oFile.write(f"$date\n {d:s}\n$end\n")	1✔
132
133	def version(self, text):	1✔
UNCOV 134	self._oFile.write(f"$version \n{text:s}\n$end\n")	×
135
136	def timescale(self, picoSeconds):	1✔
137	self._oFile.write(f"$timescale {picoSeconds:d}ps $end\n")	1✔
138
139	def varScope(self, name) -> VcdVarWritingScope:	1✔
140	"""
141	Create sub variable scope with defined name
142	"""
143	s = VcdVarWritingScope(name, self, parent=self)	1✔
144	self.scopes.append(s)	1✔
145	return s	1✔
146
147	def enddefinitions(self):	1✔
148	self._oFile.write("$enddefinitions $end\n")	1✔
149
150	def setTime(self, t):	1✔
151	lt = self.lastTime	1✔
152	if lt == t:	1✔
153	return	1✔
154	elif lt < t:	1!
155	self.lastTime = t	1✔
156	self._oFile.write(f"#{t:d}\n")	1✔
157	else:
UNCOV 158	raise Exception(f"VcdWriter invalid time update {lt:d} -> {t:d}")	×
159
160	def logChange(self, time, sig, newVal, valueUpdater):	1✔
161	self.setTime(time)	1✔
162	varInfo = self._idScope[sig]	1✔
163	varInfo.valueFormatter(newVal, valueUpdater, time, self._oFile)	1✔
164
165
166	if __name__ == "__main__":
167	from datetime import datetime
168	from pyDigitalWaveTools.vcd.value_format import VcdBitsFormatter
169	from tests.vcdWriter_test import example_dump_values0
170
171	vcd = VcdWriter()
172	vcd.date(datetime.now())
173	vcd.timescale(1)
174	example_dump_values0(vcd, VcdBitsFormatter)
175

Nic30 / pyDigitalWaveTools / ce646f97-37a3-405d-9336-73b2c85f2bb2

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