🥮 mooncakes.io

minivcd_mbt

A lightweight VCD waveform parser and CLI written in MoonBit.

vcd
verilog
waveform
parser
cli
moon add alicedhaha/minivcd_mbt@0.1.4
Download zip
Version
0.1.4
License
MIT
Repository
Last updated
3 days ago
Downloads
14

Dependencies

README

#MiniVCD-MBT

A lightweight VCD waveform parser and CLI written in MoonBit.

MiniVCD-MBT reads a Value Change Dump file, extracts digital signal declarations and value changes, and provides small command-line queries and CSV export. It is intentionally a focused parser/viewer rather than a full EDA application.

#Features

  • VCD header parsing ($date, $version, $timescale)
  • Hierarchical signals from $scope and $upscope
  • Four-state scalar values (0, 1, x, z)
  • Binary vectors
  • Signal lookup, change history, and point-in-time value queries
  • Change count and basic rising/falling edge statistics
  • File summary and identifier-based query helpers
  • Signal descriptors, scope/type filtering, snapshots, timestamp buckets, and coverage summaries
  • Parsed-data validation diagnostics
  • Markdown and plain-text reports
  • VCD-to-VCD regression comparison for signal sets, timestamps, and values
  • CSV export
  • Single-signal CSV export
  • Six-command CLI

#Installation

Install a current MoonBit toolchain, then build the project:

moon update
moon build --target native

During development, run the CLI directly with moon run cmd/minivcd -- .... After the package is published, library users can install it with:

moon add alicedhaha/minivcd_mbt

#Usage

Show file metadata:

moon run cmd/minivcd -- info examples/demo.vcd

List signals:

moon run cmd/minivcd -- signals examples/demo.vcd

Show one signal's changes:

moon run cmd/minivcd -- changes examples/demo.vcd top.clk

Show one signal's statistics:

moon run cmd/minivcd -- stats examples/demo.vcd top.clk

Query the most recent value at or before a timestamp:

moon run cmd/minivcd -- value examples/demo.vcd top.counter 20

Export all changes:

moon run cmd/minivcd -- export examples/demo.vcd output.csv

The standalone executable uses the same commands with the shorter form minivcd <command> ....

#Library Example

Add alicedhaha/minivcd_mbt to the consuming package's moon.pkg, then call the parser and query API:

let text =
  #|$timescale 1ns $end
  #|$scope module top $end
  #|$var wire 1 ! clk $end
  #|$upscope $end
  #|$enddefinitions $end
  #|#0 0!
  #|#5 1!

let vcd = @minivcd_mbt.parse_vcd(text) catch { _ => panic() }
let value = @minivcd_mbt.value_at(vcd, "top.clk", 5L) catch { _ => panic() }
assert_eq(value, Some("1"))

The main public functions are parse_vcd/parse, list_signals, find_signal, find_signal_by_identifier, signal_changes, signal_changes_by_identifier, value_at, summary, signal_stats, export_csv, and export_signal_csv.

#Supported Features

  • Basic VCD headers and unknown skippable header commands
  • Simple module hierarchy
  • wire, reg, and other declared signal type names as metadata
  • Scalar digital changes
  • Binary vector changes
  • Non-negative timestamps
  • $dumpvars, $dumpall, $dumpon, and $dumpoff blocks
  • Point-in-time snapshots and timestamp buckets
  • Parsed-data validation, signal coverage summaries, Markdown reports, and VCD regression comparison helpers

Malformed input raises a readable VcdError; normal input errors do not panic.

#Limitations

MiniVCD-MBT does not support:

  • FSDB or FST files
  • Verilog/SystemVerilog compilation or simulation
  • A waveform GUI or waveform drawing
  • Real/string signal advanced processing
  • Streaming very large files
  • Clock frequency, duty-cycle, jitter, glitch, or activity analysis

#Testing

Run all tests with:

moon test

The repository currently includes 240 tests covering parser behavior, malformed inputs, scalar/vector values, query APIs, statistics, CSV export, diagnostics, snapshots, coverage summaries, Markdown reports, and VCD comparison helpers.

For stricter local validation:

moon check --deny-warn
moon test --deny-warn

#Contest Notes

This repository is an original MoonBit implementation. The GitHub account alicedhaha and the GitLink account alicedhh both belong to the same contestant, Huang Donghong; the different names are only platform nicknames.

#License

MIT

#
VcdError

source
pub(all) suberror VcdError {
  VcdError(String)
} derive(
Debug)

A readable parse or query error. The library raises this instead of panicking on malformed VCD input or an invalid query.

#
LogicCounts

source
pub(all) struct LogicCounts {
  zeros : Int
  ones : Int
  unknowns : Int
  high_impedances : Int
  width : Int
} derive(Eq, 
Debug)

Per-character counts for a scalar or vector logic value.

#
RenderOptions

source
pub(all) struct RenderOptions {
  include_header : Bool
  include_empty_values : Bool
  separator : String
} derive(Eq, 
Debug)

A text rendering option bundle for CLI-style library reports.

#
Signal

source
pub(all) struct Signal {
  identifier : String
  name : String
  full_name : String
  width : Int
  signal_type : String
} derive(Eq, 
Debug)

A signal declared in the VCD header.

#
SignalChange

source
pub(all) struct SignalChange {
  timestamp : Int64
  identifier : String
  value : String
} derive(Eq, 
Debug)

One value change associated with a VCD identifier.

#
SignalCoverage

source
pub(all) struct SignalCoverage {
  full_name : String
  has_value : Bool
  first_change_time : Int64?
  last_change_time : Int64?
  change_count : Int
  transition_count : Int
  unknown_change_count : Int
  high_impedance_change_count : Int
} derive(Eq, 
Debug)

A per-signal coverage summary for review and diagnostics.

#
SignalDescriptor

source
pub(all) struct SignalDescriptor {
  identifier : String
  name : String
  full_name : String
  width : Int
  signal_type : String
  scope : String
  is_scalar : Bool
  is_vector : Bool
} derive(Eq, 
Debug)

A normalized signal declaration summary suitable for reports.

#
SignalMatch

source
pub(all) struct SignalMatch {
  signal : Signal
  reason : String
} derive(Eq, 
Debug)

A search result produced by name, scope, type, or identifier queries.

#
SignalSetDiff

source
pub(all) struct SignalSetDiff {
  common : Array[String]
  left_only : Array[String]
  right_only : Array[String]
  width_mismatches : Array[String]
  type_mismatches : Array[String]
} derive(Eq, 
Debug)

Difference between the signal declarations of two parsed VCD files.

#
SignalStats

source
pub(all) struct SignalStats {
  change_count : Int
  first_change_time : Int64?
  last_change_time : Int64?
  rising_edges : Int
  falling_edges : Int
} derive(Eq, 
Debug)

Basic activity statistics for one signal.

#
SignalTransition

source
pub(all) struct SignalTransition {
  timestamp : Int64
  previous : String
  current : String
} derive(Eq, 
Debug)

A transition between two consecutive known values of one signal.

#
SignalValue

source
pub(all) struct SignalValue {
  signal : Signal
  value : String?
} derive(Eq, 
Debug)

One signal value observed at a selected timestamp.

#
TimeWindow

source
pub(all) struct TimeWindow {
  start_time : Int64
  end_time : Int64
} derive(Eq, 
Debug)

A query window over VCD timestamps.

#
TimestampBucket

source
pub(all) struct TimestampBucket {
  timestamp : Int64
  changes : Array[SignalChange]
} derive(Eq, 
Debug)

A compact report of one timestamp and the changes that happened there.

#
TimestampDiff

source
pub(all) struct TimestampDiff {
  common : Array[Int64]
  left_only : Array[Int64]
  right_only : Array[Int64]
} derive(Eq, 
Debug)

Timestamp presence difference between two parsed VCD files.

#
ValueCount

source
pub(all) struct ValueCount {
  value : String
  count : Int
} derive(Eq, 
Debug)

Count of a concrete value in a signal change history.

#
ValueDiff

source
pub(all) struct ValueDiff {
  timestamp : Int64
  full_name : String
  left : String?
  right : String?
} derive(Eq, 
Debug)

Value difference for one signal at one timestamp.

#
ValueSpan

source
pub(all) struct ValueSpan {
  start_time : Int64
  end_time : Int64?
  value : String
} derive(Eq, 
Debug)

A half-open time interval over which a signal keeps the same value.

#
VcdDiff

source
pub(all) struct VcdDiff {
  signal_diff : SignalSetDiff
  timestamp_diff : TimestampDiff
  value_diffs : Array[ValueDiff]
} derive(Eq, 
Debug)

Compact comparison between two parsed VCD files.

#
VcdFile

source
pub(all) struct VcdFile {
  date : String
  version : String
  timescale : String
  signals : Array[Signal]
  changes : Array[SignalChange]
} derive(Eq, 
Debug)

Parsed VCD metadata, declarations, and value changes.

#
VcdHealth

source
pub(all) struct VcdHealth {
  signal_count : Int
  scalar_signal_count : Int
  vector_signal_count : Int
  change_count : Int
  unknown_value_change_count : Int
  high_impedance_change_count : Int
  issue_count : Int
} derive(Eq, 
Debug)

Counts of scalar/vector/unknown-state signals and changes.

#
VcdIssue

source
pub(all) struct VcdIssue {
  code : String
  message : String
  timestamp : Int64?
  signal : String?
} derive(Eq, 
Debug)

A validation issue discovered after parsing a VCD file.

#
VcdSnapshot

source
pub(all) struct VcdSnapshot {
  timestamp : Int64
  values : Array[SignalValue]
} derive(Eq, 
Debug)

A point-in-time view of every declared signal.

#
VcdSummary

source
pub(all) struct VcdSummary {
  signal_count : Int
  change_count : Int
  start_time : Int64?
  end_time : Int64?
} derive(Eq, 
Debug)

File-level counts and time bounds.

#
all_signal_coverage

source
fn all_signal_coverage(vcd : VcdFile) -> Array[SignalCoverage] raise VcdError

Return coverage summaries for all declared signals.

#
binary_value_to_int64

source
fn binary_value_to_int64(value : String) -> Int64?

Convert a known binary value to Int64 when it fits.

#
change_count_at_timestamp

source
fn change_count_at_timestamp(vcd : VcdFile, timestamp : Int64) -> Int

Count changes that happened at one timestamp.

#
change_count_in_window

source
fn change_count_in_window(vcd : VcdFile, window : TimeWindow) -> Int raise VcdError

Count all changes inside an inclusive time window.

#
changes_at_timestamp

source
fn changes_at_timestamp(vcd : VcdFile, timestamp : Int64) -> Array[SignalChange]

Return changes that occurred at one timestamp.

#
changes_in_window

source
fn changes_in_window(vcd : VcdFile, window : TimeWindow) -> Array[SignalChange] raise VcdError

Return all changes in an inclusive time window.

#
classify_value

source
fn classify_value(value : String) -> String

Return a compact textual classification of a parsed value.

#
compare_and_render

source
fn compare_and_render(left : VcdFile, right : VcdFile) -> String raise VcdError

#
compare_and_render_markdown

source
fn compare_and_render_markdown(left : VcdFile, right : VcdFile) -> String raise VcdError

#
compare_signal_sets

source
fn compare_signal_sets(left : VcdFile, right : VcdFile) -> SignalSetDiff

#
compare_timestamps

source
fn compare_timestamps(left : VcdFile, right : VcdFile) -> TimestampDiff

#
compare_values_at

source
fn compare_values_at(left : VcdFile, right : VcdFile, timestamp : Int64) -> Array[ValueDiff] raise VcdError

#
compare_values_on_union_timeline

source
fn compare_values_on_union_timeline(left : VcdFile, right : VcdFile) -> Array[ValueDiff] raise VcdError

#
compare_vcd

source
fn compare_vcd(left : VcdFile, right : VcdFile) -> VcdDiff raise VcdError

#
comparison_manifest

source
fn comparison_manifest(diff : VcdDiff) -> String

#
count_signals_by_type

source
fn count_signals_by_type(vcd : VcdFile, signal_type : String) -> Int

Count declarations of a given VCD signal type such as wire or reg.

#
count_value

source
fn count_value(vcd : VcdFile, full_name : String, value : String) -> Int raise VcdError

Count writes of a concrete value for a signal.

#
count_value_diffs_at

source
fn count_value_diffs_at(left : VcdFile, right : VcdFile, timestamp : Int64) -> Int raise VcdError

#
covered_signal_count

source
fn covered_signal_count(vcd : VcdFile) -> Int raise VcdError

Count signals with at least one value.

#
default_render_options

source
fn default_render_options() -> RenderOptions

Return the default text-rendering options used by the report helpers.

#
describe_signal

source
fn describe_signal(signal : Signal) -> SignalDescriptor

Build a normalized descriptor for one signal declaration.

#
describe_signals

source
fn describe_signals(vcd : VcdFile) -> Array[SignalDescriptor]

Build descriptors for every declared signal in source order.

#
distinct_values

source
fn distinct_values(vcd : VcdFile, full_name : String) -> Array[String] raise VcdError

Return all distinct values written to a signal.

#
end_time

source
fn end_time(vcd : VcdFile) -> Int64?

Latest timestamp in the file, if any changes exist.

#
export_csv

source
fn export_csv(vcd : VcdFile) -> String raise VcdError

Export all parsed changes in timestamp,signal,value form.

#
export_signal_csv

source
fn export_signal_csv(vcd : VcdFile, full_name : String) -> String raise VcdError

Export one signal in timestamp,signal,value form.

#
file_high_impedance_change_count

source
fn file_high_impedance_change_count(vcd : VcdFile) -> Int

Count all changes whose value contains z.

#
file_unknown_change_count

source
fn file_unknown_change_count(vcd : VcdFile) -> Int

Count all changes whose value contains x.

#
find_signal

source
fn find_signal(vcd : VcdFile, full_name : String) -> Signal?

Find a signal by hierarchical full name.

#
find_signal_by_identifier

source
fn find_signal_by_identifier(vcd : VcdFile, identifier : String) -> Signal?

Find a signal by raw VCD identifier.

#
first_change_at_or_after

source
fn first_change_at_or_after(vcd : VcdFile, full_name : String, timestamp : Int64) -> SignalChange? raise VcdError

Return the first change at or after a timestamp.

#
first_time_in_window

source
fn first_time_in_window(vcd : VcdFile, window : TimeWindow) -> Int64? raise VcdError

Return the first timestamp in a window, if the file has any matching change.

#
first_value

source
fn first_value(vcd : VcdFile, full_name : String) -> String? raise VcdError

Return the first parsed value of a signal.

#
first_value_diff

source
fn first_value_diff(left : VcdFile, right : VcdFile) -> ValueDiff? raise VcdError

#
hamming_distance

source
fn hamming_distance(left : String, right : String) -> Int?

Count bit positions that differ between two equal-width known or four-state values.

#
has_high_impedance_bit

source
fn has_high_impedance_bit(value : String) -> Bool

Return true when a value has any high-impedance bit.

#
has_unknown_bit

source
fn has_unknown_bit(value : String) -> Bool

Return true when a value has any unknown bit.

#
health

source
fn health(vcd : VcdFile) -> VcdHealth

Build a compact health summary from declarations, changes, and validation.

#
high_impedance_bit_count

source
fn high_impedance_bit_count(value : String) -> Int

Count high-impedance bits in a scalar or vector value.

#
high_impedance_change_count

source
fn high_impedance_change_count(vcd : VcdFile, full_name : String) -> Int raise VcdError

Count changes for a signal whose value contains z.

#
is_known_binary

source
fn is_known_binary(value : String) -> Bool

Return true when a value contains only known binary bits.

#
is_scalar_logic_value

source
fn is_scalar_logic_value(value : String) -> Bool

Return true when the value is exactly one scalar logic character.

#
is_valid_vcd

source
fn is_valid_vcd(vcd : VcdFile) -> Bool

Return true when validate_vcd finds no issues.

#
is_vector_logic_value

source
fn is_vector_logic_value(value : String) -> Bool

Return true when the value has more than one valid logic character.

#
last_change_at_or_before

source
fn last_change_at_or_before(vcd : VcdFile, full_name : String, timestamp : Int64) -> SignalChange? raise VcdError

Return the last change at or before a timestamp.

#
last_time_in_window

source
fn last_time_in_window(vcd : VcdFile, window : TimeWindow) -> Int64? raise VcdError

Return the last timestamp in a window, if the file has any matching change.

#
last_value

source
fn last_value(vcd : VcdFile, full_name : String) -> String? raise VcdError

Return the last parsed value of a signal.

#
list_signals

source
fn list_signals(vcd : VcdFile) -> Array[Signal]

Return the declared signals in source order.

#
logic_counts

source
fn logic_counts(value : String) -> LogicCounts

Return per-character counts for one value.

#
manifest_line

source
fn manifest_line(vcd : VcdFile) -> String

Render a plain one-line manifest useful for logs.

#
markdown_buckets

source
fn markdown_buckets(vcd : VcdFile) -> String

Render a timestamp-bucket overview as Markdown.

#
markdown_changes

source
fn markdown_changes(vcd : VcdFile) -> String

Render all parsed changes as a Markdown table.

#
markdown_coverage

source
fn markdown_coverage(vcd : VcdFile) -> String raise VcdError

Render coverage summaries for all signals as Markdown.

#
markdown_issues

source
fn markdown_issues(vcd : VcdFile) -> String

Render validation issues as Markdown.

#
markdown_report

source
fn markdown_report(vcd : VcdFile) -> String raise VcdError

Render a compact Markdown report covering the most useful library outputs.

#
markdown_signal_changes

source
fn markdown_signal_changes(vcd : VcdFile, full_name : String) -> String raise VcdError

Render one signal's changes as a Markdown table.

#
markdown_signal_set_diff

source
fn markdown_signal_set_diff(diff : SignalSetDiff) -> String

#
markdown_signal_stats

source
fn markdown_signal_stats(vcd : VcdFile, full_name : String) -> String raise VcdError

Render basic statistics for one signal as Markdown.

#
markdown_signals

source
fn markdown_signals(vcd : VcdFile) -> String

Render all signal declarations as a Markdown table.

#
markdown_snapshot

source
fn markdown_snapshot(snapshot : VcdSnapshot) -> String

Render a snapshot as a Markdown table.

#
markdown_summary

source
fn markdown_summary(vcd : VcdFile) -> String

Render a Markdown summary section for the parsed file.

#
markdown_timestamp_diff

source
fn markdown_timestamp_diff(diff : TimestampDiff) -> String

#
markdown_value_counts

source
fn markdown_value_counts(vcd : VcdFile, full_name : String) -> String raise VcdError

Render one signal's value-count table as Markdown.

#
markdown_value_diffs

source
fn markdown_value_diffs(diffs : Array[ValueDiff]) -> String

#
markdown_vcd_diff

source
fn markdown_vcd_diff(diff : VcdDiff) -> String

#
one_bit_count

source
fn one_bit_count(value : String) -> Int

Count ones in a scalar or vector value.

#
parse

source
fn parse(text : String) -> VcdFile raise VcdError

Short alias for parse_vcd.

#
parse_vcd

source
fn parse_vcd(text : String) -> VcdFile raise VcdError

Parse a complete VCD document held in memory.

#
render_buckets

source
fn render_buckets(vcd : VcdFile) -> String

Render timestamp buckets.

#
render_change

source
fn render_change(vcd : VcdFile, change : SignalChange) -> String

Render one value change using the signal full name when possible.

#
render_coverage

source
fn render_coverage(vcd : VcdFile) -> String raise VcdError

Render signal coverage summaries.

#
render_health

source
fn render_health(vcd : VcdFile) -> String

Render a health summary intended for human-readable diagnostics.

#
render_info

source
fn render_info(vcd : VcdFile) -> String

Render file summary in the same style as the CLI info command.

#
render_issues

source
fn render_issues(issues : Array[VcdIssue]) -> String

Render validation issues, one per line.

#
render_signal

source
fn render_signal(signal : Signal) -> String

Render one signal declaration as a compact text line.

#
render_signal_changes

source
fn render_signal_changes(vcd : VcdFile, full_name : String) -> String raise VcdError

Render one signal's change history.

#
render_signal_set_diff

source
fn render_signal_set_diff(diff : SignalSetDiff) -> String

#
render_signals

source
fn render_signals(vcd : VcdFile) -> String

Render the declared signal table.

#
render_snapshot

source
fn render_snapshot(snapshot : VcdSnapshot, options : RenderOptions) -> String

Render one snapshot as text.

#
render_timeline

source
fn render_timeline(vcd : VcdFile, options : RenderOptions) -> String raise VcdError

Render all snapshots at recorded timestamps.

#
render_timestamp_diff

source
fn render_timestamp_diff(diff : TimestampDiff) -> String

#
render_value_counts

source
fn render_value_counts(vcd : VcdFile, full_name : String) -> String raise VcdError

Render value counts for one signal.

#
render_value_diff

source
fn render_value_diff(diff : ValueDiff) -> String

#
render_value_diffs

source
fn render_value_diffs(diffs : Array[ValueDiff]) -> String

#
render_vcd_diff

source
fn render_vcd_diff(diff : VcdDiff) -> String

#
scalar_signals

source
fn scalar_signals(vcd : VcdFile) -> Array[Signal]

Return one-bit signals.

#
search_signals

source
fn search_signals(vcd : VcdFile, text : String) -> Array[SignalMatch]

Search signals by a text fragment in full name, short name, identifier, or type.

#
signal_changes

source
fn signal_changes(vcd : VcdFile, full_name : String) -> Array[SignalChange] raise VcdError

Get every change for a signal selected by full name.

#
signal_changes_by_identifier

source
fn signal_changes_by_identifier(vcd : VcdFile, identifier : String) -> Array[SignalChange] raise VcdError

Get every change for a signal selected by VCD identifier.

#
signal_changes_in_window

source
fn signal_changes_in_window(vcd : VcdFile, full_name : String, window : TimeWindow) -> Array[SignalChange] raise VcdError

Return changes inside an inclusive time window.

#
signal_changes_inside_window

source
fn signal_changes_inside_window(vcd : VcdFile, full_name : String, window : TimeWindow) -> Bool raise VcdError

Return true if a signal changes inside an inclusive time window.

#
signal_coverage

source
fn signal_coverage(vcd : VcdFile, full_name : String) -> SignalCoverage raise VcdError

Summarize how completely one signal is covered by changes.

#
signal_full_names

source
fn signal_full_names(vcd : VcdFile) -> Array[String]

Return full hierarchical names in declaration order.

#
signal_has_changes

source
fn signal_has_changes(vcd : VcdFile, full_name : String) -> Bool raise VcdError

Return true when a signal has at least one value change.

#
signal_has_high_impedance

source
fn signal_has_high_impedance(vcd : VcdFile, full_name : String) -> Bool raise VcdError

Return true when the signal ever contains a z value.

#
signal_has_unknown

source
fn signal_has_unknown(vcd : VcdFile, full_name : String) -> Bool raise VcdError

Return true when the signal ever contains an x value.

#
signal_identifiers

source
fn signal_identifiers(vcd : VcdFile) -> Array[String]

Return raw VCD identifiers in declaration order.

#
signal_manifest

source
fn signal_manifest(vcd : VcdFile) -> String

Render signal names as a newline-delimited manifest.

#
signal_stats

source
fn signal_stats(vcd : VcdFile, full_name : String) -> SignalStats raise VcdError

Compute change count, time bounds, and 1-bit rising/falling edges.

#
signal_transitions

source
fn signal_transitions(vcd : VcdFile, full_name : String) -> Array[SignalTransition] raise VcdError

Return transitions between consecutive known parsed values of one signal.

#
signal_types

source
fn signal_types(vcd : VcdFile) -> Array[String]

Return every unique signal type seen in declarations.

#
signal_value_diff_count

source
fn signal_value_diff_count(left : VcdFile, right : VcdFile, full_name : String) -> Int raise VcdError

#
signals_by_type

source
fn signals_by_type(vcd : VcdFile, signal_type : String) -> Array[Signal]

Return declarations whose VCD type matches signal_type.

#
signals_under_scope

source
fn signals_under_scope(vcd : VcdFile, scope_prefix : String) -> Array[Signal]

Return signals whose full hierarchical name starts with scope_prefix.

#
single_signal_report

source
fn single_signal_report(vcd : VcdFile, full_name : String) -> String raise VcdError

Render a lightweight report for one signal.

#
snapshot_at

source
fn snapshot_at(vcd : VcdFile, timestamp : Int64) -> VcdSnapshot raise VcdError

Build a point-in-time snapshot for every declared signal.

#
snapshot_is_complete

source
fn snapshot_is_complete(vcd : VcdFile, timestamp : Int64) -> Bool raise VcdError

Return true when every declared signal has a value at timestamp.

#
snapshot_value

source
fn snapshot_value(snapshot : VcdSnapshot, full_name : String) -> String?

Return the value for a signal inside a snapshot.

#
snapshots

source
fn snapshots(vcd : VcdFile) -> Array[VcdSnapshot] raise VcdError

Build snapshots for every timestamp present in the VCD.

#
start_time

source
fn start_time(vcd : VcdFile) -> Int64?

Earliest timestamp in the file, if any changes exist.

#
summary

source
fn summary(vcd : VcdFile) -> VcdSummary

Summarize file-wide counts and time bounds.

#
timestamp_buckets

source
fn timestamp_buckets(vcd : VcdFile) -> Array[TimestampBucket]

Group all changes into timestamp buckets.

#
timestamp_count

source
fn timestamp_count(vcd : VcdFile) -> Int

Count unique timestamps.

#
timestamps

source
fn timestamps(vcd : VcdFile) -> Array[Int64]

Return all unique timestamps seen in change order.

#
transition_count

source
fn transition_count(vcd : VcdFile, full_name : String) -> Int raise VcdError

Count value transitions, ignoring repeated writes of the same value.

#
unchanged_signals

source
fn unchanged_signals(vcd : VcdFile) -> Array[Signal]

Return signals that never receive a value change.

#
uncovered_signal_count

source
fn uncovered_signal_count(vcd : VcdFile) -> Int

Count signals that never receive a value.

#
undefined_signals_at

source
fn undefined_signals_at(vcd : VcdFile, timestamp : Int64) -> Array[Signal] raise VcdError

Return signals that have no value at timestamp.

#
unknown_bit_count

source
fn unknown_bit_count(value : String) -> Int

Count unknown bits in a scalar or vector value.

#
unknown_change_count

source
fn unknown_change_count(vcd : VcdFile, full_name : String) -> Int raise VcdError

Count changes for a signal whose value contains x.

#
validate_vcd

source
fn validate_vcd(vcd : VcdFile) -> Array[VcdIssue]

Validate parsed invariants that should hold after parse_vcd.

#
value_at

source
fn value_at(vcd : VcdFile, full_name : String, timestamp : Int64) -> String? raise VcdError

Return the most recent value at or before timestamp.

#
value_counts

source
fn value_counts(vcd : VcdFile, full_name : String) -> Array[ValueCount] raise VcdError

Count occurrences of each value in a signal change history.

#
value_diff_count

source
fn value_diff_count(left : VcdFile, right : VcdFile) -> Int raise VcdError

#
value_spans

source
fn value_spans(vcd : VcdFile, full_name : String) -> Array[ValueSpan] raise VcdError

Return value spans from each change until the next change.

#
vcds_are_equivalent

source
fn vcds_are_equivalent(left : VcdFile, right : VcdFile) -> Bool raise VcdError

#
vcds_have_same_signal_set

source
fn vcds_have_same_signal_set(left : VcdFile, right : VcdFile) -> Bool

#
vcds_have_same_timestamps

source
fn vcds_have_same_timestamps(left : VcdFile, right : VcdFile) -> Bool

#
vcds_have_same_values

source
fn vcds_have_same_values(left : VcdFile, right : VcdFile) -> Bool raise VcdError

#
vector_signals

source
fn vector_signals(vcd : VcdFile) -> Array[Signal]

Return multi-bit signals.

#
zero_bit_count

source
fn zero_bit_count(value : String) -> Int

Count zeros in a scalar or vector value.

Source Files

Powered by MoonBit

Site sourceReport issuePackagesBuild queueSkillsStatistics

© 2026 mooncakes.io