wavekit 0.2.0__tar.gz → 0.3.0__tar.gz

{wavekit-0.2.0 → wavekit-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: wavekit
-Version: 0.2.0
+Version: 0.3.0
 Summary: a fundamental package for digital circuit waveform analysis
 License-File: LICENSE
 Author: cxzzzz
@@ -78,7 +78,7 @@ with VcdReader("jtag.vcd") as f:
     # Returns: { ('state',): Waveform(...), ('next',): Waveform(...) }
     waves = f.load_matched_waveforms(
         "tb.u0.J_{state,next}[3:0]",
-        clock="tb.tck"
+        clock_pattern="tb.tck"
     )
 
     for (suffix,), wave in waves.items():
@@ -96,7 +96,7 @@ with VcdReader("jtag.vcd") as f:
     regex_pattern = r"tb.u0.@J_([a-z]+)"
 
     # Returns: { ('state',): Waveform(...), ('next',): Waveform(...) }
-    waves = f.load_matched_waveforms(regex_pattern, clock="tb.tck")
+    waves = f.load_matched_waveforms(regex_pattern, clock_pattern="tb.tck")
 
     for (name_part,), wave in waves.items():
         print(f"Matched: {name_part}")
@@ -149,6 +149,63 @@ with VcdReader("bus_tb.vcd") as f:
     print(f"First valid data: {hex(valid_data.value[0])}")
 ```
 
+### Expression Evaluation
+
+Use `eval` to compute waveform expressions directly from signal path strings, without manually loading each signal.
+
+**Single mode** — all paths match exactly one signal, returns a single `Waveform`:
+
+```python
+from wavekit import VcdReader
+
+with VcdReader("fifo_tb.vcd") as f:
+    clock = "fifo_tb.clk"
+
+    # Equivalent to loading w_ptr and r_ptr separately and computing the difference
+    occupancy = f.eval(
+        "fifo_tb.s_fifo.w_ptr[2:0] - fifo_tb.s_fifo.r_ptr[2:0]",
+        clock=clock,
+    )
+    print(f"Occupancy width: {occupancy.width}")
+```
+
+Bit-slicing on the expression result is also supported:
+
+```python
+    # Load a 4-bit signal and slice out the lower 2 bits
+    low_bits = f.eval("tb.dut.data[3:0][1:0]", clock=clock)
+    assert low_bits.width == 2
+```
+
+**Zip mode** — paths with brace/regex patterns expand to multiple signals; the expression is evaluated once per matched key and a `dict` is returned:
+
+```python
+with VcdReader("multi_fifo_tb.vcd") as f:
+    clock = "tb.clk"
+
+    # Evaluate occupancy for fifo_0, fifo_1, fifo_2, fifo_3 in one call
+    # Returns: { (0,): Waveform, (1,): Waveform, (2,): Waveform, (3,): Waveform }
+    occupancies = f.eval(
+        "tb.fifo_{0..3}.w_ptr[2:0] - tb.fifo_{0..3}.r_ptr[2:0]",
+        clock=clock,
+        mode="zip",
+    )
+
+    for (idx,), wave in occupancies.items():
+        print(f"fifo_{idx} occupancy width: {wave.width}")
+```
+
+Single-match paths in zip mode are **broadcast** — the same waveform is reused across all keys:
+
+```python
+    # base_offset matches one signal; it is reused for every fifo index
+    adjusted = f.eval(
+        "tb.fifo_{0..3}.w_ptr[2:0] - tb.dut.base_offset[2:0]",
+        clock=clock,
+        mode="zip",
+    )
+```
+
 ## 🛠️ Development
 
 This project adheres to strict code quality standards using modern Python tooling:

{wavekit-0.2.0 → wavekit-0.3.0}/README.md

@@ -57,7 +57,7 @@ with VcdReader("jtag.vcd") as f:
     # Returns: { ('state',): Waveform(...), ('next',): Waveform(...) }
     waves = f.load_matched_waveforms(
         "tb.u0.J_{state,next}[3:0]",
-        clock="tb.tck"
+        clock_pattern="tb.tck"
     )
 
     for (suffix,), wave in waves.items():
@@ -75,7 +75,7 @@ with VcdReader("jtag.vcd") as f:
     regex_pattern = r"tb.u0.@J_([a-z]+)"
 
     # Returns: { ('state',): Waveform(...), ('next',): Waveform(...) }
-    waves = f.load_matched_waveforms(regex_pattern, clock="tb.tck")
+    waves = f.load_matched_waveforms(regex_pattern, clock_pattern="tb.tck")
 
     for (name_part,), wave in waves.items():
         print(f"Matched: {name_part}")
@@ -128,6 +128,63 @@ with VcdReader("bus_tb.vcd") as f:
     print(f"First valid data: {hex(valid_data.value[0])}")
 ```
 
+### Expression Evaluation
+
+Use `eval` to compute waveform expressions directly from signal path strings, without manually loading each signal.
+
+**Single mode** — all paths match exactly one signal, returns a single `Waveform`:
+
+```python
+from wavekit import VcdReader
+
+with VcdReader("fifo_tb.vcd") as f:
+    clock = "fifo_tb.clk"
+
+    # Equivalent to loading w_ptr and r_ptr separately and computing the difference
+    occupancy = f.eval(
+        "fifo_tb.s_fifo.w_ptr[2:0] - fifo_tb.s_fifo.r_ptr[2:0]",
+        clock=clock,
+    )
+    print(f"Occupancy width: {occupancy.width}")
+```
+
+Bit-slicing on the expression result is also supported:
+
+```python
+    # Load a 4-bit signal and slice out the lower 2 bits
+    low_bits = f.eval("tb.dut.data[3:0][1:0]", clock=clock)
+    assert low_bits.width == 2
+```
+
+**Zip mode** — paths with brace/regex patterns expand to multiple signals; the expression is evaluated once per matched key and a `dict` is returned:
+
+```python
+with VcdReader("multi_fifo_tb.vcd") as f:
+    clock = "tb.clk"
+
+    # Evaluate occupancy for fifo_0, fifo_1, fifo_2, fifo_3 in one call
+    # Returns: { (0,): Waveform, (1,): Waveform, (2,): Waveform, (3,): Waveform }
+    occupancies = f.eval(
+        "tb.fifo_{0..3}.w_ptr[2:0] - tb.fifo_{0..3}.r_ptr[2:0]",
+        clock=clock,
+        mode="zip",
+    )
+
+    for (idx,), wave in occupancies.items():
+        print(f"fifo_{idx} occupancy width: {wave.width}")
+```
+
+Single-match paths in zip mode are **broadcast** — the same waveform is reused across all keys:
+
+```python
+    # base_offset matches one signal; it is reused for every fifo index
+    adjusted = f.eval(
+        "tb.fifo_{0..3}.w_ptr[2:0] - tb.dut.base_offset[2:0]",
+        clock=clock,
+        mode="zip",
+    )
+```
+
 ## 🛠️ Development
 
 This project adheres to strict code quality standards using modern Python tooling:

{wavekit-0.2.0 → wavekit-0.3.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "wavekit"
-version = "0.2.0"
+version = "0.3.0"
 description = "a fundamental package for digital circuit waveform analysis"
 authors = ["cxzzzz <cxz19961010@outlook.com>"]
 readme = "README.md"

{wavekit-0.2.0 → wavekit-0.3.0}/src/wavekit/__init__.py

@@ -19,3 +19,10 @@ from .signal import Signal as Signal
 from .waveform import Waveform as Waveform
 
 __all__ = ['Waveform', 'VcdReader', 'FsdbReader', 'Scope', 'Signal']
+
+try:
+    from .readers.fsdb.reader import FsdbReader as FsdbReader
+
+    __all__.append('FsdbReader')
+except ImportError:
+    pass

wavekit-0.3.0/src/wavekit/readers/base.py

@@ -0,0 +1,281 @@
+from __future__ import annotations
+
+import ast
+from abc import abstractmethod
+from collections.abc import Sequence
+from typing import Any, Literal
+
+import numpy as np
+
+from ..scope import Scope, traverse_scope
+from ..signal import Signal
+from ..waveform import Waveform
+from .expr_parser import extract_wave_paths
+from .pattern_parser import (
+    PatternMap,
+    expand_brace_pattern,
+    split_by_hierarchy,
+)
+from .value_change import value_change_to_value_array
+
+
+class Reader:
+    def __init__(self):
+        pass
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        self.close()
+        # exception wont be suppressed
+        return False
+
+    @abstractmethod
+    def load_waveform(
+        self,
+        signal: str,
+        clock: str,
+        xz_value: int = 0,
+        signed: bool = False,
+        sample_on_posedge: bool = False,
+        begin_time: int | None = None,
+        end_time: int | None = None,
+    ) -> Waveform:
+        pass
+
+    @abstractmethod
+    def get_signal_width(self, signal: str) -> int:
+        pass
+
+    @abstractmethod
+    def get_signal_range(self, signal: str) -> tuple[int]:
+        pass
+
+    @staticmethod
+    def value_change_to_waveform(
+        value_change: np.ndarray,
+        clock_changes: np.ndarray,
+        width: int | None,
+        signed: bool,
+        sample_on_posedge: bool = False,
+        signal: str = '',
+    ) -> Waveform:
+        value, clock, time = value_change_to_value_array(
+            value_change, clock_changes, sample_on_posedge=sample_on_posedge
+        )
+
+        return Waveform(
+            value=value,
+            clock=clock,
+            time=time,
+            signal=Signal(signal, width, signed),
+        )
+
+    @abstractmethod
+    def top_scope_list(self) -> Sequence[Scope]:
+        pass
+
+    def get_matched_signals(
+        self,
+        pattern: str,
+    ) -> dict[tuple[Any, ...], str]:
+        def combine_dict(
+            dict1: dict[tuple[Any, ...], str],
+            dict2: dict[tuple[Any, ...], str],
+        ) -> dict[tuple[Any, ...], str]:
+            common_keys = set(dict1.keys()).intersection(dict2.keys())
+
+            if common_keys:
+                signal1s = [dict1[k] for k in common_keys]
+                signal2s = [dict2[k] for k in common_keys]
+                raise Exception(
+                    'found more than one signal with the same keys: '
+                    f'keys:{list(common_keys)} , signals:{signal1s + signal2s}'
+                )
+
+            return {**dict1, **dict2}
+
+        pattern = pattern.strip()
+        expanded_pattern_list: list[PatternMap] = [
+            expand_brace_pattern(p) for p in split_by_hierarchy(pattern)
+        ]
+
+        matched_signals: dict[tuple[Any, ...], str] = {}
+        for scope in self.top_scope_list():
+            matched_signals = combine_dict(
+                matched_signals,
+                traverse_scope(scope, expanded_pattern_list),
+            )
+        return matched_signals
+
+    def load_matched_waveforms(
+        self,
+        pattern: str,
+        clock_pattern: str,
+        xz_value: int = 0,
+        signed: bool = False,
+        sample_on_posedge: bool = False,
+        begin_time: int | None = None,
+        end_time: int | None = None,
+    ) -> dict[tuple[Any, ...], Waveform]:
+        matched_clocks = self.get_matched_signals(clock_pattern)
+        if not matched_clocks:
+            raise Exception(f'clock pattern {clock_pattern} can not match any signal')
+
+        matched_signals = self.get_matched_signals(pattern)
+
+        load_kwargs: dict[str, Any] = dict(
+            xz_value=xz_value,
+            signed=signed,
+            sample_on_posedge=sample_on_posedge,
+            begin_time=begin_time,
+            end_time=end_time,
+        )
+
+        if len(matched_clocks) == 1:
+            # Broadcast: single clock shared by all matched signals
+            clock_full_name = next(iter(matched_clocks.values()))
+            return {
+                k: self.load_waveform(s, clock_full_name, **load_kwargs)
+                for k, s in matched_signals.items()
+            }
+        else:
+            # Per-signal clock: keys must match exactly
+            if set(matched_clocks.keys()) != set(matched_signals.keys()):
+                raise Exception(
+                    f'clock pattern {clock_pattern!r} matched keys {sorted(matched_clocks.keys())} '
+                    f'which do not match signal pattern keys {sorted(matched_signals.keys())}'
+                )
+            return {
+                k: self.load_waveform(s, matched_clocks[k], **load_kwargs)
+                for k, s in matched_signals.items()
+            }
+
+    @abstractmethod
+    def close(self):
+        pass
+
+    # ------------------------------------------------------------------
+    # High-level expression APIs
+    # ------------------------------------------------------------------
+
+    def eval(
+        self,
+        expr: str,
+        clock: str,
+        xz_value: int = 0,
+        signed: bool = False,
+        sample_on_posedge: bool = False,
+        begin_time: int | None = None,
+        end_time: int | None = None,
+        mode: Literal['single', 'zip'] = 'single',
+    ) -> Waveform | dict[tuple[Any, ...], Waveform]:
+        """Evaluate a waveform expression string.
+
+        Wave signal paths embedded in *expr* are automatically extracted,
+        loaded, and substituted before evaluating the resulting Python
+        arithmetic expression.
+
+        Parameters
+        ----------
+        expr:
+            Expression string.
+            Single mode example: ``"tb.dut.w_ptr[3:0] - tb.dut.r_ptr[3:0]"``.
+            Zip mode example: ``"tb.dut.fifo_{0..3}.w_ptr[3:0] - tb.dut.fifo_{0..3}.r_ptr[3:0]"``.
+        clock:
+            Clock signal used for all waveform loads.
+        mode:
+            ``'single'`` (default) — every path must match exactly one
+            signal; returns a single :class:`Waveform`.
+            ``'zip'`` — paths matching multiple signals must all share the
+            same set of pattern keys; single-match paths are broadcast;
+            returns ``dict[tuple, Waveform]``.
+        """
+        substituted, path_entries = extract_wave_paths(expr)
+
+        load_kwargs: dict[str, Any] = dict(
+            clock=clock,
+            xz_value=xz_value,
+            signed=signed,
+            sample_on_posedge=sample_on_posedge,
+            begin_time=begin_time,
+            end_time=end_time,
+        )
+
+        # Resolve each path to its matched signal(s)
+        matched_per_path: list[tuple[str, str, dict[tuple[Any, ...], str]]] = []
+        for placeholder, path in path_entries:
+            matched = self.get_matched_signals(path)
+            if not matched:
+                raise ValueError(f"path '{path}' matched no signals")
+            matched_per_path.append((placeholder, path, matched))
+
+        if mode == 'single':
+            for _placeholder, path, matched in matched_per_path:
+                if len(matched) > 1:
+                    raise ValueError(
+                        f"path '{path}' matched {len(matched)} signals in mode='single',"
+                        f" use mode='zip'. Matched: {list(matched.values())}"
+                    )
+            ns: dict[str, Any] = {
+                placeholder: self.load_waveform(next(iter(matched.values())), **load_kwargs)
+                for placeholder, _, matched in matched_per_path
+            }
+            try:
+                code = compile(ast.parse(substituted, mode='eval'), '<eval_expr>', 'eval')
+                return eval(code, {'__builtins__': {}}, ns)  # noqa: S307
+            except Exception as exc:
+                raise ValueError(
+                    f"failed to evaluate expression '{expr}' (substituted: '{substituted}')"
+                ) from exc
+
+        elif mode == 'zip':
+            multi_paths = [(ph, p, m) for ph, p, m in matched_per_path if len(m) > 1]
+            single_paths = [(ph, p, m) for ph, p, m in matched_per_path if len(m) == 1]
+
+            if multi_paths:
+                # All multi-match paths must share identical key sets
+                ref_ph, ref_p, ref_matched = multi_paths[0]
+                ref_keys = set(ref_matched.keys())
+                for _ph, p, matched in multi_paths[1:]:
+                    if set(matched.keys()) != ref_keys:
+                        raise ValueError(
+                            f'inconsistent match keys between paths: '
+                            f"'{ref_p}' has keys {sorted(ref_keys)}, "
+                            f"'{p}' has keys {sorted(matched.keys())}"
+                        )
+                zip_keys: list[tuple[Any, ...]] = list(ref_keys)
+            else:
+                # All paths are single-match; degenerate to single behaviour
+                zip_keys = [()]
+
+            # Pre-load broadcast waveforms (single-match paths)
+            broadcast_ns: dict[str, Waveform] = {
+                placeholder: self.load_waveform(next(iter(matched.values())), **load_kwargs)
+                for placeholder, _, matched in single_paths
+            }
+
+            result: dict[tuple[Any, ...], Waveform] = {}
+            try:
+                code = compile(ast.parse(substituted, mode='eval'), '<eval_expr>', 'eval')
+            except SyntaxError as exc:
+                raise ValueError(
+                    f"invalid expression '{expr}' (substituted: '{substituted}')"
+                ) from exc
+
+            for key in zip_keys:
+                ns = dict(broadcast_ns)
+                for placeholder, _, matched in multi_paths:
+                    ns[placeholder] = self.load_waveform(matched[key], **load_kwargs)
+                try:
+                    result[key] = eval(code, {'__builtins__': {}}, ns)  # noqa: S307
+                except Exception as exc:
+                    raise ValueError(
+                        f"failed to evaluate expression '{expr}' for key {key}"
+                    ) from exc
+
+            return result
+
+        else:
+            raise ValueError(f"unknown mode '{mode}', expected 'single' or 'zip'")

wavekit-0.3.0/src/wavekit/readers/expr_parser.py

@@ -0,0 +1,65 @@
+from __future__ import annotations
+
+import re
+
+# Matches a waveform signal path token in an expression.
+# A valid path is one of:
+#   - Starts with $$ or $ (module search)
+#   - Starts with @ (regex pattern)
+#   - Contains at least one . separator (hierarchical path)
+#
+# Path structure:
+#   [$$|$|@]  first_ident  (.segment[{brace}])*  ([N:M]|[N])?
+#
+# The trailing [N:M] / [N] is consumed as the signal range (not a bit-slice).
+# Any further [N:M] after the placeholder in the resulting expression will be
+# handled as a Python subscript on the Waveform object (i.e. bit-slicing).
+_WAVE_PATH_RE = re.compile(
+    r'(?P<path>'
+    r'(?:[$]{1,2}|@)?'  # optional prefix $$ / $ / @
+    r'(?:[A-Za-z_][A-Za-z0-9_]*)'  # first identifier segment
+    r'(?:[.][A-Za-z_][A-Za-z0-9_{}.,]*)*'  # dot-separated segments (allow braces, no [ ])
+    r'(?:\[\d+(?::\d+)?\])?'  # optional trailing [N:M] or [N] range
+    r')'
+)
+
+
+def _is_wave_path(token: str) -> bool:
+    """Return True if token looks like a waveform signal path."""
+    if token.startswith('$') or token.startswith('@'):
+        return True
+    # Must contain a dot (hierarchy) but not look like a floating-point literal
+    if '.' in token:
+        try:
+            float(token)
+            return False  # it's a numeric literal like "1.0"
+        except ValueError:
+            return True
+    return False
+
+
+def extract_wave_paths(expr: str) -> tuple[str, list[tuple[str, str]]]:
+    """Parse *expr* and replace wave path tokens with placeholder identifiers.
+
+    Returns
+    -------
+    substituted_expr : str
+        The expression with every wave path replaced by ``__wave_N__``.
+    paths : list of (placeholder, original_path)
+        The ordered list of substitutions made.
+    """
+    paths: list[tuple[str, str]] = []
+    counter = 0
+
+    def replacer(m: re.Match) -> str:
+        nonlocal counter
+        token = m.group('path')
+        if not _is_wave_path(token):
+            return token
+        placeholder = f'__wave_{counter}__'
+        paths.append((placeholder, token))
+        counter += 1
+        return placeholder
+
+    substituted = _WAVE_PATH_RE.sub(replacer, expr)
+    return substituted, paths

{wavekit-0.2.0 → wavekit-0.3.0}/src/wavekit/readers/fsdb/npi_fsdb.pxd

@@ -82,8 +82,13 @@ cdef extern from "npi_fsdb.h":
         npiFsdbScopeFullName
         npiFsdbScopeDefName
         npiFsdbScopeType
-
-
+    
+    ctypedef enum npiFsdbSigCompositeType_e:
+        npiFsdbSigCtArray
+        npiFsdbSigCtStruct
+        npiFsdbSigCtUnion
+        npiFsdbSigCtTaggedUnion
+        npiFsdbSigCtRecord
 
 
     npiFsdbFileHandle npi_fsdb_open( const NPI_BYTE8* name )
@@ -113,3 +118,5 @@ cdef extern from "npi_fsdb.h":
     npiFsdbSigHandle npi_fsdb_iter_sig_next( npiFsdbSigIter iter )
     npiFsdbSigIter npi_fsdb_iter_sig( npiFsdbScopeHandle scope )
     npiFsdbSigIter npi_fsdb_iter_member( npiFsdbSigHandle sig )
+    NPI_INT32 npi_fsdb_iter_scope_stop( npiFsdbScopeIter iter )
+    NPI_INT32 npi_fsdb_iter_sig_stop( npiFsdbSigIter iter )

{wavekit-0.2.0 → wavekit-0.3.0}/src/wavekit/readers/fsdb/npi_fsdb_reader.pyx

@@ -10,37 +10,53 @@ from libc.stdlib cimport malloc, free
 from libc.string cimport strcpy, strlen
 from .npi_fsdb cimport *
 
+
 cdef class NpiFsdbScope:
+    pass
+
+
+cdef class NpiFsdbNormalScope(NpiFsdbScope):
     cdef npiFsdbScopeHandle scope_handle
 
     @staticmethod
     cdef init(npiFsdbScopeHandle scope_handle):
-        scope = NpiFsdbScope()
+        scope = NpiFsdbNormalScope()
         scope.scope_handle = scope_handle
         return scope
 
     def __init__(self):
         self.scope_handle = NULL
 
-    def child_scope_list(self) -> list[NpiFsdbScope]:
+    def child_scope_list(self, include_signal_scope:bool = True) -> list[NpiFsdbScope]:
         assert self.scope_handle != NULL
-
         res = []
         child_scope_handle_iter = npi_fsdb_iter_child_scope(self.scope_handle)
+        
         cdef npiFsdbScopeHandle child_scope_handle
         while True:
             child_scope_handle = npi_fsdb_iter_scope_next(child_scope_handle_iter)
             if child_scope_handle == NULL:
                 break
-            res.append(NpiFsdbScope.init(child_scope_handle))
-
+            res.append(NpiFsdbNormalScope.init(child_scope_handle))
+        npi_fsdb_iter_scope_stop(child_scope_handle_iter)
+
+
+        cdef npiFsdbSigHandle child_sig_handle
+        if include_signal_scope:
+            child_sig_handle_iter = npi_fsdb_iter_sig(self.scope_handle)
+            while True:
+                child_sig_handle = npi_fsdb_iter_sig_next(child_sig_handle_iter)
+                if child_sig_handle == NULL:
+                    break
+                res.append(NpiFsdbSignalScope.init(child_sig_handle))
+            npi_fsdb_iter_sig_stop(child_sig_handle_iter)
         return res
 
     def signal_list(self) -> list[str]:
         assert self.scope_handle != NULL
 
         res = []
-        cdef npiFsdbScopeHandle sig_handle_iter = npi_fsdb_iter_sig(self.scope_handle)
+        sig_handle_iter = npi_fsdb_iter_sig(self.scope_handle)
         cdef npiFsdbSigHandle sig_handle
         cdef const char* c_str
         while True:
@@ -50,21 +66,92 @@ cdef class NpiFsdbScope:
             c_str = npi_fsdb_sig_property_str(npiFsdbSigName, sig_handle)
             name = c_str.decode('ascii')
             res.append(name)
+        npi_fsdb_iter_sig_stop(sig_handle_iter)
 
         return res
 
     def name(self) -> str:
         assert self.scope_handle != NULL
-        return npi_fsdb_scope_property_str(npiFsdbScopeName, self.scope_handle).decode('ascii')
+        name = npi_fsdb_scope_property_str(npiFsdbScopeName, self.scope_handle).decode('ascii')
+        return name
 
     def type(self) -> str:
         assert self.scope_handle != NULL
-        return npi_fsdb_scope_property_str(npiFsdbScopeType, self.scope_handle).decode('ascii')
+        type_str = npi_fsdb_scope_property_str(npiFsdbScopeType, self.scope_handle).decode('ascii')
+        return type_str
 
     def def_name(self) -> str:
         assert self.scope_handle != NULL
-        return npi_fsdb_scope_property_str(npiFsdbScopeDefName, self.scope_handle).decode('ascii')
+        def_name = npi_fsdb_scope_property_str(npiFsdbScopeDefName, self.scope_handle).decode('ascii')
+        return def_name
+
+cdef class NpiFsdbSignalScope(NpiFsdbScope):
+    cdef npiFsdbSigHandle sig_handle
+
+    @staticmethod
+    cdef init(npiFsdbSigHandle sig_handle):
+        scope = NpiFsdbSignalScope()
+        scope.sig_handle = sig_handle
+        return scope
+
+    def __init__(self):
+        self.sig_handle = NULL
+
+    def child_scope_list(self, include_signal_scope:bool = True) -> list[NpiFsdbScope]:
+        assert self.sig_handle != NULL
+
+        cdef int has_member
+        cdef npiFsdbSigIter member_iter
+        cdef npiFsdbSigHandle member_handle
+
+        res = []
+        if include_signal_scope:
+            if npi_fsdb_sig_property(npiFsdbSigHasMember, self.sig_handle, &has_member) and has_member:
+                member_iter = npi_fsdb_iter_member(self.sig_handle)
+                while True:
+                    member_handle = npi_fsdb_iter_sig_next(member_iter)
+                    if member_handle == NULL:
+                        break
+                    res.append(NpiFsdbSignalScope.init(member_handle))
+                npi_fsdb_iter_sig_stop(member_iter)
+        return res
+
+    def signal_list(self) -> list[str]:
+        assert self.sig_handle != NULL
+
+        cdef const char* c_str
+        cdef npiFsdbSigIter member_iter
+        cdef npiFsdbSigHandle member_handle
+        cdef int has_member
+        res = []
 
+        if npi_fsdb_sig_property(npiFsdbSigHasMember, self.sig_handle, &has_member) and has_member:
+            member_iter = npi_fsdb_iter_member(self.sig_handle)
+            while True:
+                member_handle = npi_fsdb_iter_sig_next(member_iter)
+                if member_handle == NULL:
+                    break
+                c_str = npi_fsdb_sig_property_str(npiFsdbSigName, member_handle)
+                name = c_str.decode('ascii')
+                name = name.split(".")
+                name = name[len(name)-1]
+                res.append(name)
+            npi_fsdb_iter_sig_stop(member_iter)
+        return res
+
+    def name(self) -> str:
+        assert self.sig_handle != NULL
+        name = npi_fsdb_sig_property_str(npiFsdbSigName, self.sig_handle).decode('ascii')
+        #TODO: this only works for non-array type (array's name is like data[0],can't be split by ".")
+        name = name.split(".")
+        name = name[len(name)-1]
+        return name
+
+    def type(self) -> str:
+        raise NotImplementedError("type property of signal scope is not supported")
+
+    def def_name(self) -> str:
+        raise NotImplementedError("def_name property of signal scope is not supported")
 @cython.boundscheck(False)  # 关闭边界检查以提升性能
 @cython.wraparound(False)   # 关闭负索引检查以提升性能
 cdef inline cstr_to_ull(char* str, unsigned int xz_value, int max_bit_num = 2147483647):
@@ -150,7 +237,7 @@ cdef inline fsdb_read_value_change(vct_handle: npiFsdbVctHandle, begin_time, end
 
     return result
 
-cdef get_signal_handle_width( npiFsdbSigHandle signal_handle):
+cdef get_signal_handle_width(npiFsdbSigHandle signal_handle):
     cdef int has_member
     cdef int width
     cdef npiFsdbSigIter sub_signal_iter
@@ -167,11 +254,33 @@ cdef get_signal_handle_width( npiFsdbSigHandle signal_handle):
             width += get_signal_handle_width(sub_signal)
         return width
 
+cdef get_signal_handle_range(npiFsdbSigHandle signal_handle):
+    cdef int has_member
+    cdef int type
+    cdef int left_range, right_range
+    assert(npi_fsdb_sig_property(npiFsdbSigHasMember, signal_handle, &has_member))
+    assert(npi_fsdb_sig_property(npiFsdbSigLeftRange, signal_handle, &left_range))
+    assert(npi_fsdb_sig_property(npiFsdbSigRightRange, signal_handle, &right_range))
+    return (left_range, right_range)
+
+    if(has_member != 0):
+        assert(npi_fsdb_sig_property(npiFsdbSigCompositeType, signal_handle, &type))
+        if(type == <int>npiFsdbSigCtArray):
+            return (left_range, right_range)
+    return None
+
 cdef class NpiFsdbReader:
     cdef npiFsdbFileHandle fsdb_handle
     cdef str file
 
     def __init__(self, str file):
+        import os
+        
+        # 检查VERDI_HOME环境变量
+        verdi_home = os.environ.get('VERDI_HOME')
+        if verdi_home:
+            npi_lib_path = os.path.join(verdi_home, 'share/NPI/lib/LINUX64/libNPI.so')
+        
         #cdef int argc = len(sys.argv)
         #cdef char** argv = <char**>malloc((argc + 1) * sizeof(char*))
 
@@ -188,6 +297,8 @@ cdef class NpiFsdbReader:
         file_str = file.encode('utf-8')
         cdef char* file_s = file_str
         self.fsdb_handle = npi_fsdb_open(file_s)
+        if(self.fsdb_handle == NULL):
+            raise OSError(f"Failed to open fsdb file :{file_str}")
 
 
 
@@ -195,10 +306,22 @@ cdef class NpiFsdbReader:
         self,
         str signal
     ) -> int:
+        
+        cdef npiFsdbSigHandle signal_handle = npi_fsdb_sig_by_name(self.fsdb_handle,  signal.encode('ascii'), NULL)
+        assert signal_handle != NULL, f"can't find signal: {signal}"
+        
+        cdef int width = get_signal_handle_width(signal_handle)
+        return width
 
+    def get_signal_range(
+        self,
+        str signal
+    ) -> tuple[int,int]:
+        
         cdef npiFsdbSigHandle signal_handle = npi_fsdb_sig_by_name(self.fsdb_handle,  signal.encode('ascii'), NULL)
         assert signal_handle != NULL, f"can't find signal: {signal}"
-        return get_signal_handle_width(signal_handle)
+
+        return get_signal_handle_range(signal_handle)
 
     @cython.boundscheck(False)  # 关闭边界检查以提升性能
     @cython.wraparound(False)   # 关闭负索引检查以提升性能
@@ -209,7 +332,7 @@ cdef class NpiFsdbReader:
         unsigned long long end_time,
         int xz_value
     ) -> np.ndarray:
-
+        
         cdef npiFsdbSigHandle signal_handle = npi_fsdb_sig_by_name(self.fsdb_handle,  signal.encode('ascii'), NULL)
         assert signal_handle != NULL, f"can't find signal: {signal}"
         cdef int width = get_signal_handle_width(signal_handle)
@@ -235,6 +358,7 @@ cdef class NpiFsdbReader:
                     stat = npi_fsdb_goto_time(signal_vct_handle,  <npiFsdbTime> begin_time)
             else:
                 stat = npi_fsdb_goto_next(signal_vct_handle)
+            
             if stat == 0:
                 break
 
@@ -245,6 +369,7 @@ cdef class NpiFsdbReader:
             if cur_time > end_time:
                 break
             time_array.push_back(cur_time)
+            first = False
 
             if width == 1: # opt for clk
                 value_array[0].push_back(cstr_to_bit(<char*>cur_value.value.str, xz_value))
@@ -287,7 +412,8 @@ cdef class NpiFsdbReader:
             top_scope_handle = npi_fsdb_iter_scope_next(top_scope_iter)
             if top_scope_handle == NULL:
                 break
-            res.append(NpiFsdbScope.init(top_scope_handle))
+            res.append(NpiFsdbNormalScope.init(top_scope_handle))
+        npi_fsdb_iter_scope_stop(top_scope_iter)
         return res
 
     def min_time(self) -> int:

{wavekit-0.2.0 → wavekit-0.3.0}/src/wavekit/readers/fsdb/reader.py

@@ -10,7 +10,7 @@ from ...scope import Scope
 from ...signal import Signal
 from ...waveform import Waveform
 from ..base import Reader
-from .npi_fsdb_reader import NpiFsdbReader, NpiFsdbScope
+from .npi_fsdb_reader import NpiFsdbReader, NpiFsdbScope, NpiFsdbSignalScope
 
 
 class FsdbScope(Scope):
@@ -39,6 +39,13 @@ class FsdbScope(Scope):
     def child_scope_list(self) -> Sequence[Scope]:
         return [FsdbScope(c, self, self.reader) for c in self.handle.child_scope_list()]
 
+    @cached_property
+    def child_normal_scope_list(self) -> Sequence[Scope]:
+        return [
+            FsdbScope(c, self, self.reader)
+            for c in self.handle.child_scope_list(include_signal_scope=False)
+        ]
+
     @property
     def type(self) -> str:
         if not hasattr(self, '_type'):
@@ -65,8 +72,11 @@ class FsdbScope(Scope):
         return self.parent_scope.end_time if self.parent_scope else 0
 
     def preload_module_scope(self):
+        if isinstance(self.handle, NpiFsdbSignalScope):
+            return {}
+
         preloaded_module_scope = defaultdict(list)
-        for c in self.child_scope_list:
+        for c in self.child_normal_scope_list:
             for module_name, module_scope_list in c.preload_module_scope().items():
                 preloaded_module_scope[module_name].extend(module_scope_list)
 
@@ -141,6 +151,9 @@ class FsdbReader(Reader):
     def get_signal_width(self, signal: str) -> int:
         return self.file_handle.get_signal_width(signal)
 
+    def get_signal_range(self, signal: str) -> tuple[int]:
+        return self.file_handle.get_signal_range(signal)
+
     @property
     def begin_time(self) -> str:
         return self.file_handle.min_time()

wavekit-0.2.0/src/wavekit/readers/base.py

@@ -1,142 +0,0 @@
-from __future__ import annotations
-
-from abc import abstractmethod
-from collections.abc import Sequence
-from typing import Any
-
-import numpy as np
-
-from ..scope import Scope, traverse_scope
-from ..signal import Signal
-from ..waveform import Waveform
-from .pattern_parser import (
-    PatternMap,
-    expand_brace_pattern,
-    split_by_hierarchy,
-)
-from .value_change import value_change_to_value_array
-
-
-class Reader:
-    def __init__(self):
-        pass
-
-    def __enter__(self):
-        return self
-
-    def __exit__(self, exc_type, exc_val, exc_tb):
-        self.close()
-        # exception wont be suppressed
-        return False
-
-    @abstractmethod
-    def load_waveform(
-        self,
-        signal: str,
-        clock: str,
-        xz_value: int = 0,
-        signed: bool = False,
-        sample_on_posedge: bool = False,
-        begin_time: int | None = None,
-        end_time: int | None = None,
-    ) -> Waveform:
-        pass
-
-    @abstractmethod
-    def get_signal_width(self, signal: str) -> int:
-        pass
-
-    @staticmethod
-    def value_change_to_waveform(
-        value_change: np.ndarray,
-        clock_changes: np.ndarray,
-        width: int | None,
-        signed: bool,
-        sample_on_posedge: bool = False,
-        signal: str = '',
-    ) -> Waveform:
-        value, clock, time = value_change_to_value_array(
-            value_change, clock_changes, sample_on_posedge=sample_on_posedge
-        )
-
-        return Waveform(
-            value=value,
-            clock=clock,
-            time=time,
-            signal=Signal(signal, width, signed),
-        )
-
-    @abstractmethod
-    def top_scope_list(self) -> Sequence[Scope]:
-        pass
-
-    def get_matched_signals(
-        self,
-        pattern: str,
-    ) -> dict[tuple[Any, ...], str]:
-        def combine_dict(
-            dict1: dict[tuple[Any, ...], str],
-            dict2: dict[tuple[Any, ...], str],
-        ) -> dict[tuple[Any, ...], str]:
-            common_keys = set(dict1.keys()).intersection(dict2.keys())
-
-            if common_keys:
-                signal1s = [dict1[k] for k in common_keys]
-                signal2s = [dict2[k] for k in common_keys]
-                raise Exception(
-                    'found more than one signal with the same keys: '
-                    f'keys:{list(common_keys)} , signals:{signal1s + signal2s}'
-                )
-
-            return {**dict1, **dict2}
-
-        pattern = pattern.strip()
-        expanded_pattern_list: list[PatternMap] = [
-            expand_brace_pattern(p) for p in split_by_hierarchy(pattern)
-        ]
-
-        matched_signals: dict[tuple[Any, ...], str] = {}
-        for scope in self.top_scope_list():
-            matched_signals = combine_dict(
-                matched_signals,
-                traverse_scope(scope, expanded_pattern_list),
-            )
-        return matched_signals
-
-    def load_matched_waveforms(
-        self,
-        pattern: str,
-        clock_pattern: str,
-        xz_value: int = 0,
-        signed: bool = False,
-        sample_on_posedge: bool = False,
-        begin_time: int | None = None,
-        end_time: int | None = None,
-    ) -> dict[tuple[Any, ...], Waveform]:
-        clock_patterns = self.get_matched_signals(clock_pattern)
-        if not clock_patterns:
-            raise Exception(f'clock pattern {clock_pattern} can not match any signal')
-        if len(clock_patterns) > 1:
-            raise Exception(
-                f'clock pattern {clock_pattern} match more than one signal: {clock_patterns}'
-            )
-        clock_full_name = next(iter(clock_patterns.values()))
-
-        matched_signals = self.get_matched_signals(pattern)
-
-        return {
-            k: self.load_waveform(
-                s,
-                clock_full_name,
-                xz_value=xz_value,
-                signed=signed,
-                sample_on_posedge=sample_on_posedge,
-                begin_time=begin_time,
-                end_time=end_time,
-            )
-            for k, s in matched_signals.items()
-        }
-
-    @abstractmethod
-    def close(self):
-        pass