output/csv: use intermediate time_t var, silence compiler warning

[libsigrok.git] / src / input / vcd.c

/*
 * This file is part of the libsigrok project.
 *
 * Copyright (C) 2012 Petteri Aimonen <jpa@sr.mail.kapsi.fi>
 * Copyright (C) 2014 Bert Vermeulen <bert@biot.com>
 * Copyright (C) 2017-2020 Gerhard Sittig <gerhard.sittig@gmx.net>
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */

/*
 * The VCD input module has the following options. See the options[]
 * declaration near the bottom of the input module's source file.
 *
 * numchannels: Maximum number of sigrok channels to create. VCD signals
 *   are detected in their order of declaration in the VCD file header,
 *   and mapped to sigrok channels.
 *
 * skip: Allows to skip data at the start of the input file. This can
 *   speed up operation on long captures.
 *   Value < 0: Skip until first timestamp that is listed in the file.
 *     (This is the default behaviour.)
 *   Value = 0: Do not skip, instead generate samples beginning from
 *     timestamp 0.
 *   Value > 0: Start at the given timestamp.
 *
 * downsample: Divide the samplerate by the given factor. This can
 *   speed up operation on long captures.
 *
 * compress: Trim idle periods which are longer than this value to span
 *   only this many timescale ticks. This can speed up operation on long
 *   captures (default 0, don't compress).
 *
 * Based on Verilog standard IEEE Std 1364-2001 Version C
 *
 * Supported features:
 * - $var with 'wire' and 'reg' types of scalar variables
 * - $timescale definition for samplerate
 * - multiple character variable identifiers
 * - same identifer used for multiple signals (identical values)
 * - vector variables (bit vectors)
 * - integer variables (analog signals with 0 digits, passed as single
 *   precision float number)
 * - real variables (analog signals, passed on with single precision,
 *   arbitrary digits value, not user adjustable)
 * - nested $scope, results in prefixed sigrok channel names
 *
 * Most important unsupported features:
 * - $dumpvars initial value declaration (is not an issue if generators
 *   provide sample data for the #0 timestamp, otherwise session data
 *   starts from zero values, and catches up when the signal changes its
 *   state to a supported value)
 *
 * Implementor's note: This input module specifically does _not_ use
 * glib routines where they would hurt performance. Lots of memory
 * allocations increase execution time not by percents but by huge
 * factors. This motivated this module's custom code for splitting
 * words on text lines, and pooling previously allocated buffers.
 *
 * TODO (in arbitrary order)
 * - Map VCD scopes to sigrok channel groups?
 *   - Does libsigrok support nested channel groups? Or is this feature
 *     exclusive to Pulseview?
 * - Check VCD input to VCD output behaviour. Verify that export and
 *   re-import results in identical data (well, VCD's constraints on
 *   timescale values is known to result in differences).
 * - Check the minimum timestamp delta in the input data set, suggest
 *   the downsample=N option to users for reduced resource consumption.
 *   Popular VCD file creation utilities love to specify insanely tiny
 *   timescale values in the pico or even femto seconds range. Which
 *   results in huge sample counts after import, and potentially even
 *   terminates the application due to resource exhaustion. This issue
 *   only will vanish when common libsigrok infrastructure no longer
 *   depends on constant rate streams of samples at discrete points
 *   in time. The current input module implementation has code in place
 *   to gather timestamp statistics, but the most appropriate condition
 *   when to notify users is yet to be found.
 * - Cleanup the implementation.
 *   - Consistent use of the glib API (where appropriate).
 *   - More appropriate variable/function identifiers.
 *   - More robust handling of multi-word input phrases and chunked
 *     input buffers? This implementation assumes that e.g. b[01]+
 *     patterns are complete when they start, and the signal identifier
 *     is available as well. Which may be true assuming that input data
 *     comes in complete text lines.
 *   - See if other input modules have learned lessons that we could
 *     benefit from here as well? Pointless BOM (done), line oriented
 *     processing with EOL variants and with optional last EOL, module
 *     state reset and file re-read (stable channels list), buffered
 *     session feed, synchronized feed for mixed signal sources, digits
 *     or formats support for analog input, single vs double precision,
 *     etc.
 *   - Re-consider logging. Verbosity levels should be acceptable,
 *     but volume is an issue. Drop duplicates, and drop messages from
 *     known good code paths.
 */

#include <config.h>

#include <glib.h>
#include <libsigrok/libsigrok.h>
#include "libsigrok-internal.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define LOG_PREFIX "input/vcd"

#define CHUNK_SIZE (4 * 1024 * 1024)
#define SCOPE_SEP '.'

struct context {
	struct vcd_user_opt {
		size_t maxchannels; /* sigrok channels (output) */
		uint64_t downsample;
		uint64_t compress;
		uint64_t skip_starttime;
		gboolean skip_specified;
	} options;
	gboolean use_skip;
	gboolean started;
	gboolean got_header;
	uint64_t prev_timestamp;
	uint64_t samplerate;
	size_t vcdsignals; /* VCD signals (input) */
	GSList *ignored_signals;
	gboolean data_after_timestamp;
	gboolean ignore_end_keyword;
	gboolean skip_until_end;
	GSList *channels;
	size_t unit_size;
	size_t logic_count;
	size_t analog_count;
	uint8_t *current_logic;
	float *current_floats;
	struct {
		size_t max_bits;
		size_t unit_size;
		uint8_t *value;
		size_t sig_count;
	} conv_bits;
	GString *scope_prefix;
	struct feed_queue_logic *feed_logic;
	struct ts_stats {
		size_t total_ts_seen;
		uint64_t last_ts_value;
		uint64_t last_ts_delta;
		size_t min_count;
		struct {
			uint64_t delta;
			size_t count;
		} min_items[2];
		uint32_t early_check_shift;
		size_t early_last_emitted;
	} ts_stats;
	struct vcd_prev {
		GSList *sr_channels;
		GSList *sr_groups;
	} prev;
};

struct vcd_channel {
	char *name;
	char *identifier;
	size_t size;
	enum sr_channeltype type;
	size_t array_index;
	size_t byte_idx;
	uint8_t bit_mask;
	char *base_name;
	size_t range_lower, range_upper;
	int submit_digits;
	struct feed_queue_analog *feed_analog;
};

static void free_channel(void *data)
{
	struct vcd_channel *vcd_ch;

	vcd_ch = data;
	if (!vcd_ch)
		return;

	g_free(vcd_ch->name);
	g_free(vcd_ch->identifier);
	g_free(vcd_ch->base_name);
	feed_queue_analog_free(vcd_ch->feed_analog);

	g_free(vcd_ch);
}

/*
 * Another timestamp delta was observed, update statistics: Update the
 * sorted list of minimum values, and increment the occurance counter.
 * Returns the position of the item's statistics slot, or returns a huge
 * invalid index when the current delta is larger than previously found
 * values.
 */
static size_t ts_stats_update_min(struct ts_stats *stats, uint64_t delta)
{
	size_t idx, copy_idx;

	/* Advance over previously recorded values which are smaller. */
	idx = 0;
	while (idx < stats->min_count && stats->min_items[idx].delta < delta)
		idx++;
	if (idx == ARRAY_SIZE(stats->min_items))
		return idx;

	/* Found the exact value that previously was registered? */
	if (stats->min_items[idx].delta == delta) {
		stats->min_items[idx].count++;
		return idx;
	}

	/* Allocate another slot, bubble up larger values as needed. */
	if (stats->min_count < ARRAY_SIZE(stats->min_items))
		stats->min_count++;
	for (copy_idx = stats->min_count - 1; copy_idx > idx; copy_idx--)
		stats->min_items[copy_idx] = stats->min_items[copy_idx - 1];

	/* Start tracking this value in the found or freed slot. */
	memset(&stats->min_items[idx], 0, sizeof(stats->min_items[idx]));
	stats->min_items[idx].delta = delta;
	stats->min_items[idx].count++;

	return idx;
}

/*
 * Intermediate check for extreme oversampling in the input data. Rate
 * limited emission of warnings to avoid noise, "late" emission of the
 * first potential message to avoid false positives, yet need to  emit
 * the messages early (*way* before EOF) to raise awareness.
 *
 * TODO
 * Tune the limits, improve perception and usefulness of these checks.
 * Need to start emitting messages soon enough to be seen by users. Yet
 * avoid unnecessary messages for valid input's idle/quiet phases. Slow
 * input transitions are perfectly legal before bursty phases are seen
 * in the input data. Needs the check become an option, on by default,
 * but suppressable by users?
 */
static void ts_stats_check_early(struct ts_stats *stats)
{
	static const struct {
		uint64_t delta;
		size_t count;
	} *cp, check_points[] = {
		{     100, 1000000, }, /* Still x100 after 1mio transitions. */
		{    1000,  100000, }, /* Still x1k after 100k transitions. */
		{   10000,   10000, }, /* Still x10k after 10k transitions. */
		{ 1000000,    2500, }, /* Still x1m after 2.5k transitions. */
	};

	size_t cp_idx;
	uint64_t seen_delta, check_delta;
	size_t seen_count;

	/* Get the current minimum's value and count. */
	if (!stats->min_count)
		return;
	seen_delta = stats->min_items[0].delta;
	seen_count = stats->min_items[0].count;

	/* Emit at most one weak message per import. */
	if (stats->early_last_emitted)
		return;

	/* Check arbitrary marks, emit rate limited warnings. */
	(void)seen_count;
	check_delta = seen_delta >> stats->early_check_shift;
	for (cp_idx = 0; cp_idx < ARRAY_SIZE(check_points); cp_idx++) {
		cp = &check_points[cp_idx];
		/* No other match can happen below. Done iterating. */
		if (stats->total_ts_seen > cp->count)
			return;
		/* Advance to the next checkpoint description. */
		if (stats->total_ts_seen != cp->count)
			continue;
		/* First occurance of that timestamp count. Check the value. */
		sr_dbg("TS early chk: total %zu, min delta %" PRIu64 " / %" PRIu64 ".",
			cp->count, seen_delta, check_delta);
		if (check_delta < cp->delta)
			return;
		sr_warn("Low change rate? (weak estimate, min TS delta %" PRIu64 " after %zu timestamps)",
			seen_delta, stats->total_ts_seen);
		sr_warn("Consider using the downsample=N option, or increasing its value.");
		stats->early_last_emitted = stats->total_ts_seen;
		return;
	}
}

/* Reset the internal state of the timestamp tracker. */
static int ts_stats_prep(struct context *inc)
{
	struct ts_stats *stats;
	uint64_t down_sample_value;
	uint32_t down_sample_shift;

	stats = &inc->ts_stats;
	memset(stats, 0, sizeof(*stats));

	down_sample_value = inc->options.downsample;
	down_sample_shift = 0;
	while (down_sample_value >= 2) {
		down_sample_shift++;
		down_sample_value /= 2;
	}
	stats->early_check_shift = down_sample_shift;

	return SR_OK;
}

/* Inspect another timestamp that was received. */
static int ts_stats_check(struct ts_stats *stats, uint64_t curr_ts)
{
	uint64_t last_ts, delta;

	last_ts = stats->last_ts_value;
	stats->last_ts_value = curr_ts;
	stats->total_ts_seen++;
	if (stats->total_ts_seen < 2)
		return SR_OK;

	delta = curr_ts - last_ts;
	stats->last_ts_delta = delta;
	(void)ts_stats_update_min(stats, delta);

	ts_stats_check_early(stats);

	return SR_OK;
}

/* Postprocess internal timestamp tracker state. */
static int ts_stats_post(struct context *inc, gboolean ignore_terminal)
{
	struct ts_stats *stats;
	size_t min_idx;
	uint64_t delta, over_sample, over_sample_scaled, suggest_factor;
	enum sr_loglevel log_level;
	gboolean is_suspicious, has_downsample;

	stats = &inc->ts_stats;

	/*
	 * Lookup the smallest timestamp delta which was found during
	 * data import. Ignore the last delta if its timestamp was never
	 * followed by data, and this was the only occurance. Absence of
	 * result data is non-fatal here -- this code exclusively serves
	 * to raise users' awareness of potential pitfalls, but does not
	 * change behaviour of data processing.
	 *
	 * TODO Also filter by occurance count? To not emit warnings when
	 * captured signals only change slowly by design. Only warn when
	 * the sample rate and samples count product exceeds a threshold?
	 * See below for the necessity (and potential) to adjust the log
	 * message's severity and content.
	 */
	min_idx = 0;
	if (ignore_terminal) do {
		if (min_idx >= stats->min_count)
			break;
		delta = stats->last_ts_delta;
		if (stats->min_items[min_idx].delta != delta)
			break;
		if (stats->min_items[min_idx].count != 1)
			break;
		min_idx++;
	} while (0);
	if (min_idx >= stats->min_count)
		return SR_OK;

	/*
	 * TODO Refine the condition whether to notify the user, and
	 * which severity to use after having inspected all input data.
	 * Any detail could get involved which previously was gathered
	 * during data processing: total sample count, channel count
	 * including their data type and bits width, the oversampling
	 * factor (minimum observed "change rate"), or any combination
	 * thereof. The current check is rather simple (unconditional
	 * warning for ratios starting at 100, regardless of sample or
	 * channel count).
	 */
	over_sample = stats->min_items[min_idx].delta;
	over_sample_scaled = over_sample / inc->options.downsample;
	sr_dbg("TS post stats: oversample unscaled %" PRIu64 ", scaled %" PRIu64,
		over_sample, over_sample_scaled);
	if (over_sample_scaled < 10) {
		sr_dbg("TS post stats: Low oversampling ratio, good.");
		return SR_OK;
	}

	/*
	 * Avoid constructing the message from several tiny pieces by
	 * design, because this would be hard on translators. Stick with
	 * complete sentences instead, and accept the redundancy in the
	 * user's interest.
	 */
	log_level = (over_sample_scaled > 20) ? SR_LOG_WARN : SR_LOG_INFO;
	is_suspicious = over_sample_scaled > 20;
	if (is_suspicious) {
		sr_log(log_level, LOG_PREFIX ": "
			"Suspiciously low overall change rate (total min TS delta %" PRIu64 ").",
			over_sample_scaled);
	} else {
		sr_log(log_level, LOG_PREFIX ": "
			"Low overall change rate (total min TS delta %" PRIu64 ").",
			over_sample_scaled);
	}
	has_downsample = inc->options.downsample > 1;
	suggest_factor = inc->options.downsample;
	while (over_sample_scaled >= 10) {
		suggest_factor *= 10;
		over_sample_scaled /= 10;
	}
	if (has_downsample) {
		sr_log(log_level, LOG_PREFIX ": "
			"Suggest higher downsample value, like %" PRIu64 ".",
			suggest_factor);
	} else {
		sr_log(log_level, LOG_PREFIX ": "
			"Suggest to downsample, value like %" PRIu64 ".",
			suggest_factor);
	}

	return SR_OK;
}

static void check_remove_bom(GString *buf)
{
	static const char *bom_text = "\xef\xbb\xbf";

	if (buf->len < strlen(bom_text))
		return;
	if (strncmp(buf->str, bom_text, strlen(bom_text)) != 0)
		return;
	g_string_erase(buf, 0, strlen(bom_text));
}

/*
 * Reads a single VCD section from input file and parses it to name/contents.
 * e.g. $timescale 1ps $end => "timescale" "1ps"
 *
 * The section (its content and its opening/closing markers) can span
 * multiple text lines. This routine must not modify the caller's input
 * buffer. Executes potentially multiple times on the same input data,
 * and executes outside of the processing of the file's data section.
 */
static gboolean parse_section(GString *buf, char **name, char **contents)
{
	static const char *end_text = "$end";

	gboolean status;
	size_t pos, len;
	const char *grab_start, *grab_end;
	GString *sname, *scontent;

	/* Preset falsy return values. Gets updated below. */
	*name = *contents = NULL;
	status = FALSE;

	/* Skip any initial white-space. */
	pos = 0;
	while (pos < buf->len && g_ascii_isspace(buf->str[pos]))
		pos++;

	/* Section tag should start with $. */
	if (buf->str[pos++] != '$')
		return FALSE;

	/* Read the section tag. */
	grab_start = &buf->str[pos];
	while (pos < buf->len && !g_ascii_isspace(buf->str[pos]))
		pos++;
	grab_end = &buf->str[pos];
	sname = g_string_new_len(grab_start, grab_end - grab_start);

	/* Skip whitespace before content. */
	while (pos < buf->len && g_ascii_isspace(buf->str[pos]))
		pos++;

	/* Read the content up to the '$end' marker. */
	scontent = g_string_sized_new(128);
	grab_start = &buf->str[pos];
	grab_end = g_strstr_len(grab_start, buf->len - pos, end_text);
	if (grab_end) {
		/* Advance 'pos' to after '$end' and more whitespace. */
		pos = grab_end - buf->str;
		pos += strlen(end_text);
		while (pos < buf->len && g_ascii_isspace(buf->str[pos]))
			pos++;

		/* Grab the (trimmed) content text. */
		while (grab_end > grab_start && g_ascii_isspace(grab_end[-1]))
			grab_end--;
		len = grab_end - grab_start;
		g_string_append_len(scontent, grab_start, len);
		if (sname->len)
			status = TRUE;

		/* Consume the input text which just was taken. */
		g_string_erase(buf, 0, pos);
	}

	/* Return section name and content if a section was seen. */
	*name = g_string_free(sname, !status);
	*contents = g_string_free(scontent, !status);

	return status;
}

static gboolean have_header(GString *buf)
{
	static const char *enddef_txt = "$enddefinitions";
	static const char *end_txt = "$end";

	char *p, *p_stop;

	/* Search for "end of definitions" section keyword. */
	p = g_strstr_len(buf->str, buf->len, enddef_txt);
	if (!p)
		return FALSE;
	p += strlen(enddef_txt);

	/*
	 * Search for end of section (content expected to be empty).
	 * Uses DIY logic to scan for the literals' presence including
	 * empty space between keywords. MUST NOT modify the caller's
	 * input data, potentially executes several times on the same
	 * receive buffer, and executes outside of the processing the
	 * file's data section.
	 */
	p_stop = &buf->str[buf->len];
	p_stop -= strlen(end_txt);
	while (p < p_stop && g_ascii_isspace(*p))
		p++;
	if (strncmp(p, end_txt, strlen(end_txt)) != 0)
		return FALSE;
	p += strlen(end_txt);

	return TRUE;
}

static int parse_timescale(struct context *inc, char *contents)
{
	uint64_t p, q;

	/*
	 * The standard allows for values 1, 10 or 100
	 * and units s, ms, us, ns, ps and fs.
	 */
	if (sr_parse_period(contents, &p, &q) != SR_OK) {
		sr_err("Parsing $timescale failed.");
		return SR_ERR_DATA;
	}

	inc->samplerate = q / p;
	sr_dbg("Samplerate: %" PRIu64, inc->samplerate);
	if (q % p != 0) {
		/* Does not happen unless time value is non-standard */
		sr_warn("Inexact rounding of samplerate, %" PRIu64 " / %" PRIu64 " to %" PRIu64 " Hz.",
			q, p, inc->samplerate);
	}

	return SR_OK;
}

/*
 * Handle '$scope' and '$upscope' sections in the input file. Assume that
 * input signals have a "base name", which may be ambiguous within the
 * file. These names get declared within potentially nested scopes, which
 * this implementation uses to create longer but hopefully unique and
 * thus more usable sigrok channel names.
 *
 * Track the currently effective scopes in a string variable to simplify
 * the channel name creation. Start from an empty string, then append the
 * scope name and a separator when a new scope opens, and remove the last
 * scope name when a scope closes. This allows to simply prefix basenames
 * with the current scope to get a full name.
 *
 * It's an implementation detail to keep the trailing NUL here in the
 * GString member, to simplify the g_strconcat() call in the channel name
 * creation.
 *
 * TODO
 * - Check whether scope types must get supported, this implementation
 *   does not distinguish between 'module' and 'begin' and what else
 *   may be seen. The first word simply gets ignored.
 * - Check the allowed alphabet for scope names. This implementation
 *   assumes "programming language identifier" style (alphanumeric with
 *   underscores, plus brackets since we've seen them in example files).
 */
static int parse_scope(struct context *inc, char *contents, gboolean is_up)
{
	char *sep_pos, *name_pos, *type_pos;
	size_t length;

	/*
	 * The 'upscope' case, drop one scope level (if available). Accept
	 * excess 'upscope' calls, assume that a previous 'scope' section
	 * was ignored because it referenced our software package's name.
	 */
	if (is_up) {
		/*
		 * Check for a second right-most separator (and position
		 * right behind that, which is the start of the last
		 * scope component), or fallback to the start of string.
		 * g_string_erase() from that positon to the end to drop
		 * the last component.
		 */
		name_pos = inc->scope_prefix->str;
		do {
			sep_pos = strrchr(name_pos, SCOPE_SEP);
			if (!sep_pos)
				break;
			*sep_pos = '\0';
			sep_pos = strrchr(name_pos, SCOPE_SEP);
			if (!sep_pos)
				break;
			name_pos = ++sep_pos;
		} while (0);
		length = name_pos - inc->scope_prefix->str;
		g_string_truncate(inc->scope_prefix, length);
		g_string_append_c(inc->scope_prefix, '\0');
		sr_dbg("$upscope, prefix now: \"%s\"", inc->scope_prefix->str);
		return SR_OK;
	}

	/*
	 * The 'scope' case, add another scope level. But skip our own
	 * package name, assuming that this is an artificial node which
	 * was emitted by libsigrok's VCD output module.
	 */
	sr_spew("$scope, got: \"%s\"", contents);
	type_pos = sr_text_next_word(contents, &contents);
	if (!type_pos) {
		sr_err("Cannot parse 'scope' directive");
		return SR_ERR_DATA;
	}
	name_pos = sr_text_next_word(contents, &contents);
	if (!name_pos || contents) {
		sr_err("Cannot parse 'scope' directive");
		return SR_ERR_DATA;
	}

	if (strcmp(name_pos, PACKAGE_NAME) == 0) {
		sr_info("Skipping scope with application's package name: %s",
			name_pos);
		*name_pos = '\0';
	}
	if (*name_pos) {
		/* Drop NUL, append scope name and separator, and re-add NUL. */
		g_string_truncate(inc->scope_prefix, inc->scope_prefix->len - 1);
		g_string_append_printf(inc->scope_prefix,
			"%s%c%c", name_pos, SCOPE_SEP, '\0');
	}
	sr_dbg("$scope, prefix now: \"%s\"", inc->scope_prefix->str);

	return SR_OK;
}

/**
 * Parse a $var section which describes a VCD signal ("variable").
 *
 * @param[in] inc Input module context.
 * @param[in] contents Input text, content of $var section.
 */
static int parse_header_var(struct context *inc, char *contents)
{
	char *type, *size_txt, *id, *ref, *idx;
	gboolean is_reg, is_wire, is_real, is_int;
	gboolean is_str;
	enum sr_channeltype ch_type;
	size_t size, next_size;
	struct vcd_channel *vcd_ch;

	/*
	 * Format of $var or $reg header specs:
	 * $var type size identifier reference [opt-index] $end
	 */
	type = sr_text_next_word(contents, &contents);
	size_txt = sr_text_next_word(contents, &contents);
	id = sr_text_next_word(contents, &contents);
	ref = sr_text_next_word(contents, &contents);
	idx = sr_text_next_word(contents, &contents);
	if (idx && !*idx)
		idx = NULL;
	if (!type || !size_txt || !id || !ref || contents) {
		sr_warn("$var section should have 4 or 5 items");
		return SR_ERR_DATA;
	}

	is_reg = g_strcmp0(type, "reg") == 0;
	is_wire = g_strcmp0(type, "wire") == 0;
	is_real = g_strcmp0(type, "real") == 0;
	is_int = g_strcmp0(type, "integer") == 0;
	is_str = g_strcmp0(type, "string") == 0;

	if (is_reg || is_wire) {
		ch_type = SR_CHANNEL_LOGIC;
	} else if (is_real || is_int) {
		ch_type = SR_CHANNEL_ANALOG;
	} else if (is_str) {
		sr_warn("Skipping id %s, name '%s%s', unsupported type '%s'.",
			id, ref, idx ? idx : "", type);
		inc->ignored_signals = g_slist_append(inc->ignored_signals,
			g_strdup(id));
		return SR_OK;
	} else {
		sr_err("Unsupported signal type: '%s'", type);
		return SR_ERR_DATA;
	}

	size = strtol(size_txt, NULL, 10);
	if (ch_type == SR_CHANNEL_ANALOG) {
		if (is_real && size != 32 && size != 64) {
			/*
			 * The VCD input module does not depend on the
			 * specific width of the floating point value.
			 * This is just for information. Upon value
			 * changes, a mere string gets converted to
			 * float, so we may not care at all.
			 *
			 * Strictly speaking we might warn for 64bit
			 * (double precision) declarations, because
			 * sigrok internally uses single precision
			 * (32bit) only.
			 */
			sr_info("Unexpected real width: '%s'", size_txt);
		}
		/* Simplify code paths below, by assuming size 1. */
		size = 1;
	}
	if (!size) {
		sr_warn("Unsupported signal size: '%s'", size_txt);
		return SR_ERR_DATA;
	}
	if (inc->conv_bits.max_bits < size)
		inc->conv_bits.max_bits = size;
	next_size = inc->logic_count + inc->analog_count + size;
	if (inc->options.maxchannels && next_size > inc->options.maxchannels) {
		sr_warn("Skipping '%s%s', exceeds requested channel count %zu.",
			ref, idx ? idx : "", inc->options.maxchannels);
		inc->ignored_signals = g_slist_append(inc->ignored_signals,
			g_strdup(id));
		return SR_OK;
	}

	vcd_ch = g_malloc0(sizeof(*vcd_ch));
	vcd_ch->identifier = g_strdup(id);
	vcd_ch->name = g_strconcat(inc->scope_prefix->str, ref, idx, NULL);
	vcd_ch->size = size;
	vcd_ch->type = ch_type;
	switch (ch_type) {
	case SR_CHANNEL_LOGIC:
		vcd_ch->array_index = inc->logic_count;
		vcd_ch->byte_idx = vcd_ch->array_index / 8;
		vcd_ch->bit_mask = 1 << (vcd_ch->array_index % 8);
		inc->logic_count += size;
		break;
	case SR_CHANNEL_ANALOG:
		vcd_ch->array_index = inc->analog_count++;
		/* TODO: Use proper 'digits' value for this input module. */
		vcd_ch->submit_digits = is_real ? 2 : 0;
		break;
	}
	inc->vcdsignals++;
	sr_spew("VCD signal %zu '%s' ID '%s' (size %zu), sr type %s, idx %zu.",
		inc->vcdsignals, vcd_ch->name,
		vcd_ch->identifier, vcd_ch->size,
		vcd_ch->type == SR_CHANNEL_ANALOG ? "A" : "L",
		vcd_ch->array_index);
	inc->channels = g_slist_append(inc->channels, vcd_ch);

	return SR_OK;
}

/**
 * Construct the name of the nth sigrok channel for a VCD signal.
 *
 * Uses the VCD signal name for scalar types and single-bit signals.
 * Uses "signal.idx" for multi-bit VCD signals without a range spec in
 * their declaration. Uses "signal[idx]" when a range is known and was
 * verified.
 *
 * @param[in] vcd_ch The VCD signal's description.
 * @param[in] idx The sigrok channel's index within the VCD signal's group.
 *
 * @return An allocated text buffer which callers need to release, #NULL
 *   upon failure to create a sigrok channel name.
 */
static char *get_channel_name(struct vcd_channel *vcd_ch, size_t idx)
{
	char *open_pos, *close_pos, *check_pos, *endptr;
	gboolean has_brackets, has_range;
	size_t upper, lower, tmp;
	char *ch_name;

	/* Handle simple scalar types, and single-bit logic first. */
	if (vcd_ch->size <= 1)
		return g_strdup(vcd_ch->name);

	/*
	 * If not done before: Search for a matching pair of brackets in
	 * the right-most position at the very end of the string. Get the
	 * two colon separated numbers between the brackets, which are
	 * the range limits for array indices into the multi-bit signal.
	 * Grab the "base name" of the VCD signal.
	 *
	 * Notice that arrays can get nested. Earlier path components can
	 * be indexed as well, that's why we need the right-most range.
	 * This implementation does not handle bit vectors of size 1 here
	 * by explicit logic. The check for a [0:0] range would even fail.
	 * But the case of size 1 is handled above, and "happens to" give
	 * the expected result (just the VCD signal name).
	 *
	 * This implementation also deals with range limits in the reverse
	 * order, as well as ranges which are not 0-based (like "[4:7]").
	 */
	if (!vcd_ch->base_name) {
		has_range = TRUE;
		open_pos = strrchr(vcd_ch->name, '[');
		close_pos = strrchr(vcd_ch->name, ']');
		if (close_pos && close_pos[1])
			close_pos = NULL;
		has_brackets = open_pos && close_pos && close_pos > open_pos;
		if (!has_brackets)
			has_range = FALSE;
		if (has_range) {
			check_pos = &open_pos[1];
			endptr = NULL;
			upper = strtoul(check_pos, &endptr, 10);
			if (!endptr || *endptr != ':')
				has_range = FALSE;
		}
		if (has_range) {
			check_pos = &endptr[1];
			endptr = NULL;
			lower = strtoul(check_pos, &endptr, 10);
			if (!endptr || endptr != close_pos)
				has_range = FALSE;
		}
		if (has_range && lower > upper) {
			tmp = lower;
			lower = upper;
			upper = tmp;
		}
		if (has_range) {
			if (lower >= upper)
				has_range = FALSE;
			if (upper + 1 - lower != vcd_ch->size)
				has_range = FALSE;
		}
		if (has_range) {
			/* Temporarily patch the VCD channel's name. */
			*open_pos = '\0';
			vcd_ch->base_name = g_strdup(vcd_ch->name);
			*open_pos = '[';
			vcd_ch->range_lower = lower;
			vcd_ch->range_upper = upper;
		}
	}
	has_range = vcd_ch->range_lower + vcd_ch->range_upper;
	if (has_range && idx >= vcd_ch->size)
		has_range = FALSE;
	if (!has_range)
		return g_strdup_printf("%s.%zu", vcd_ch->name, idx);

	/*
	 * Create a sigrok channel name with just the bit's index in
	 * brackets. This avoids "name[7:0].3" results, instead results
	 * in "name[3]".
	 */
	ch_name = g_strdup_printf("%s[%zu]",
		vcd_ch->base_name, vcd_ch->range_lower + idx);
	return ch_name;
}

/*
 * Create (analog or logic) sigrok channels for the VCD signals. Create
 * multiple sigrok channels for vector input since sigrok has no concept
 * of multi-bit signals. Create a channel group for the vector's bits
 * though to reflect that they form a unit. This is beneficial when UIs
 * support optional "collapsed" displays of channel groups (like
 * "parallel bus, hex output").
 *
 * Defer channel creation until after completion of parsing the input
 * file header. Make sure to create all logic channels first before the
 * analog channels get created. This avoids issues with the mapping of
 * channel indices to bitmap positions in the sample buffer.
 */
static void create_channels(const struct sr_input *in,
	struct sr_dev_inst *sdi, enum sr_channeltype ch_type)
{
	struct context *inc;
	size_t ch_idx;
	GSList *l;
	struct vcd_channel *vcd_ch;
	size_t size_idx;
	char *ch_name;
	struct sr_channel_group *cg;
	struct sr_channel *ch;

	inc = in->priv;

	ch_idx = 0;
	if (ch_type > SR_CHANNEL_LOGIC)
		ch_idx += inc->logic_count;
	if (ch_type > SR_CHANNEL_ANALOG)
		ch_idx += inc->analog_count;
	for (l = inc->channels; l; l = l->next) {
		vcd_ch = l->data;
		if (vcd_ch->type != ch_type)
			continue;
		cg = NULL;
		if (vcd_ch->size != 1)
			cg = sr_channel_group_new(sdi, vcd_ch->name, NULL);
		for (size_idx = 0; size_idx < vcd_ch->size; size_idx++) {
			ch_name = get_channel_name(vcd_ch, size_idx);
			sr_dbg("sigrok channel idx %zu, name %s, type %s, en %d.",
				ch_idx, ch_name,
				ch_type == SR_CHANNEL_ANALOG ? "A" : "L", TRUE);
			ch = sr_channel_new(sdi, ch_idx, ch_type, TRUE, ch_name);
			g_free(ch_name);
			ch_idx++;
			if (cg)
				cg->channels = g_slist_append(cg->channels, ch);
		}
	}
}

static void create_feeds(const struct sr_input *in)
{
	struct context *inc;
	GSList *l;
	struct vcd_channel *vcd_ch;
	size_t ch_idx;
	struct sr_channel *ch;

	inc = in->priv;

	/* Create one feed for logic data. */
	if (inc->logic_count) {
		inc->unit_size = (inc->logic_count + 7) / 8;
		inc->feed_logic = feed_queue_logic_alloc(in->sdi,
			CHUNK_SIZE / inc->unit_size, inc->unit_size);
	}

	/* Create one feed per analog channel. */
	for (l = inc->channels; l; l = l->next) {
		vcd_ch = l->data;
		if (vcd_ch->type != SR_CHANNEL_ANALOG)
			continue;
		ch_idx = vcd_ch->array_index;
		ch_idx += inc->logic_count;
		ch = g_slist_nth_data(in->sdi->channels, ch_idx);
		vcd_ch->feed_analog = feed_queue_analog_alloc(in->sdi,
			CHUNK_SIZE / sizeof(float),
			vcd_ch->submit_digits, ch);
	}
}

/*
 * Keep track of a previously created channel list, in preparation of
 * re-reading the input file. Gets called from reset()/cleanup() paths.
 */
static void keep_header_for_reread(const struct sr_input *in)
{
	struct context *inc;

	inc = in->priv;

	g_slist_free_full(inc->prev.sr_groups, sr_channel_group_free_cb);
	inc->prev.sr_groups = in->sdi->channel_groups;
	in->sdi->channel_groups = NULL;

	g_slist_free_full(inc->prev.sr_channels, sr_channel_free_cb);
	inc->prev.sr_channels = in->sdi->channels;
	in->sdi->channels = NULL;
}

/*
 * Check whether the input file is being re-read, and refuse operation
 * when essential parameters of the acquisition have changed in ways
 * that are unexpected to calling applications. Gets called after the
 * file header got parsed (again).
 *
 * Changing the channel list across re-imports of the same file is not
 * supported, by design and for valid reasons, see bug #1215 for details.
 * Users are expected to start new sessions when they change these
 * essential parameters in the acquisition's setup. When we accept the
 * re-read file, then make sure to keep using the previous channel list,
 * applications may still reference them.
 */
static gboolean check_header_in_reread(const struct sr_input *in)
{
	struct context *inc;

	if (!in)
		return FALSE;
	inc = in->priv;
	if (!inc)
		return FALSE;
	if (!inc->prev.sr_channels)
		return TRUE;

	if (sr_channel_lists_differ(inc->prev.sr_channels, in->sdi->channels)) {
		sr_err("Channel list change not supported for file re-read.");
		return FALSE;
	}

	g_slist_free_full(in->sdi->channel_groups, sr_channel_group_free_cb);
	in->sdi->channel_groups = inc->prev.sr_groups;
	inc->prev.sr_groups = NULL;

	g_slist_free_full(in->sdi->channels, sr_channel_free_cb);
	in->sdi->channels = inc->prev.sr_channels;
	inc->prev.sr_channels = NULL;

	return TRUE;
}

/* Parse VCD file header sections (rate and variables declarations). */
static int parse_header(const struct sr_input *in, GString *buf)
{
	struct context *inc;
	gboolean enddef_seen, header_valid;
	char *name, *contents;
	size_t size;
	int ret;

	inc = in->priv;

	/* Parse sections until complete header was seen. */
	enddef_seen = FALSE;
	header_valid = TRUE;
	name = contents = NULL;
	inc->conv_bits.max_bits = 1;
	while (parse_section(buf, &name, &contents)) {
		sr_dbg("Section '%s', contents '%s'.", name, contents);

		if (g_strcmp0(name, "enddefinitions") == 0) {
			enddef_seen = TRUE;
			goto done_section;
		}
		if (g_strcmp0(name, "timescale") == 0) {
			if (parse_timescale(inc, contents) != SR_OK)
				header_valid = FALSE;
			goto done_section;
		}
		if (g_strcmp0(name, "scope") == 0) {
			if (parse_scope(inc, contents, FALSE) != SR_OK)
				header_valid = FALSE;
			goto done_section;
		}
		if (g_strcmp0(name, "upscope") == 0) {
			if (parse_scope(inc, NULL, TRUE) != SR_OK)
				header_valid = FALSE;
			goto done_section;
		}
		if (g_strcmp0(name, "var") == 0) {
			if (parse_header_var(inc, contents) != SR_OK)
				header_valid = FALSE;
			goto done_section;
		}

done_section:
		g_free(name);
		name = NULL;
		g_free(contents);
		contents = NULL;

		if (enddef_seen)
			break;
	}
	g_free(name);
	g_free(contents);

	inc->got_header = enddef_seen && header_valid;
	if (!inc->got_header)
		return SR_ERR_DATA;

	/* Create sigrok channels here, late, logic before analog. */
	create_channels(in, in->sdi, SR_CHANNEL_LOGIC);
	create_channels(in, in->sdi, SR_CHANNEL_ANALOG);
	if (!check_header_in_reread(in))
		return SR_ERR_DATA;
	create_feeds(in);

	/*
	 * Allocate space for text to number conversion, and buffers to
	 * hold current sample values before submission to the session
	 * feed. Allocate one buffer for all logic bits, and another for
	 * all floating point values of all analog channels.
	 *
	 * The buffers get updated when the VCD input stream communicates
	 * value changes. Upon reception of VCD timestamps, the buffer can
	 * provide the previously received values, to "fill in the gaps"
	 * in the generation of a continuous stream of samples for the
	 * sigrok session.
	 */
	size = (inc->conv_bits.max_bits + 7) / 8;
	inc->conv_bits.unit_size = size;
	inc->conv_bits.value = g_malloc0(size);
	if (!inc->conv_bits.value)
		return SR_ERR_MALLOC;

	size = (inc->logic_count + 7) / 8;
	inc->unit_size = size;
	inc->current_logic = g_malloc0(size);
	if (inc->unit_size && !inc->current_logic)
		return SR_ERR_MALLOC;
	size = sizeof(inc->current_floats[0]) * inc->analog_count;
	inc->current_floats = g_malloc0(size);
	if (size && !inc->current_floats)
		return SR_ERR_MALLOC;
	for (size = 0; size < inc->analog_count; size++)
		inc->current_floats[size] = 0.;

	ret = ts_stats_prep(inc);
	if (ret != SR_OK)
		return ret;

	return SR_OK;
}

/*
 * Add N copies of previously received values to the session, before
 * subsequent value changes will update the data buffer. Locally buffer
 * sample data to minimize the number of send() calls.
 */
static void add_samples(const struct sr_input *in, size_t count, gboolean flush)
{
	struct context *inc;
	GSList *ch_list;
	struct vcd_channel *vcd_ch;
	struct feed_queue_analog *q;
	float value;

	inc = in->priv;

	if (inc->logic_count) {
		feed_queue_logic_submit_one(inc->feed_logic,
			inc->current_logic, count);
		if (flush)
			feed_queue_logic_flush(inc->feed_logic);
	}
	for (ch_list = inc->channels; ch_list; ch_list = ch_list->next) {
		vcd_ch = ch_list->data;
		if (vcd_ch->type != SR_CHANNEL_ANALOG)
			continue;
		q = vcd_ch->feed_analog;
		if (!q)
			continue;
		value = inc->current_floats[vcd_ch->array_index];
		feed_queue_analog_submit_one(q, value, count);
		if (flush)
			feed_queue_analog_flush(q);
	}
}

static gint vcd_compare_id(gconstpointer a, gconstpointer b)
{
	return strcmp((const char *)a, (const char *)b);
}

static gboolean is_ignored(struct context *inc, const char *id)
{
	GSList *ignored;

	ignored = g_slist_find_custom(inc->ignored_signals, id, vcd_compare_id);
	return ignored != NULL;
}

/*
 * Get an analog channel's value from a bit pattern (VCD 'integer' type).
 * The implementation assumes a maximum integer width (64bit), the API
 * doesn't (beyond the return data type). The use of SR_CHANNEL_ANALOG
 * channels may further constraint the number of significant digits
 * (current asumption: float -> 23bit).
 */
static float get_int_val(uint8_t *in_bits_data, size_t in_bits_count)
{
	uint64_t int_value;
	size_t byte_count, byte_idx;
	float flt_value; /* typeof(inc->current_floats[0]) */

	/* Convert bit pattern to integer number (limited range). */
	int_value = 0;
	byte_count = (in_bits_count + 7) / 8;
	for (byte_idx = 0; byte_idx < byte_count; byte_idx++) {
		if (byte_idx >= sizeof(int_value))
			break;
		int_value |= *in_bits_data++ << (byte_idx * 8);
	}
	flt_value = int_value;

	return flt_value;
}

/*
 * Set a logic channel's level depending on the VCD signal's identifier
 * and parsed value. Multi-bit VCD values will affect several sigrok
 * channels. One VCD signal name can translate to several sigrok channels.
 */
static void process_bits(struct context *inc, char *identifier,
	uint8_t *in_bits_data, size_t in_bits_count)
{
	size_t size;
	gboolean have_int;
	GSList *l;
	struct vcd_channel *vcd_ch;
	float int_val;
	size_t bit_idx;
	uint8_t *in_bit_ptr, in_bit_mask;
	uint8_t *out_bit_ptr, out_bit_mask;
	uint8_t bit_val;

	size = 0;
	have_int = FALSE;
	int_val = 0;
	for (l = inc->channels; l; l = l->next) {
		vcd_ch = l->data;
		if (g_strcmp0(identifier, vcd_ch->identifier) != 0)
			continue;
		if (vcd_ch->type == SR_CHANNEL_ANALOG) {
			/* Special case for 'integer' VCD signal types. */
			size = vcd_ch->size; /* Flag for "VCD signal found". */
			if (!have_int) {
				int_val = get_int_val(in_bits_data, in_bits_count);
				have_int = TRUE;
			}
			inc->current_floats[vcd_ch->array_index] = int_val;
			continue;
		}
		if (vcd_ch->type != SR_CHANNEL_LOGIC)
			continue;
		sr_spew("Processing %s data, id '%s', ch %zu sz %zu",
			(size == 1) ? "bit" : "vector",
			identifier, vcd_ch->array_index, vcd_ch->size);

		/* Found our (logic) channel. Setup in/out bit positions. */
		size = vcd_ch->size;
		in_bit_ptr = in_bits_data;
		in_bit_mask = 1 << 0;
		out_bit_ptr = &inc->current_logic[vcd_ch->byte_idx];
		out_bit_mask = vcd_ch->bit_mask;

		/*
		 * Pass VCD input bit(s) to sigrok logic bits. Conversion
		 * must be done repeatedly because one VCD signal name
		 * can translate to several sigrok channels, and shifting
		 * a previously computed bit field to another channel's
		 * position in the buffer would be nearly as expensive,
		 * and certain would increase complexity of the code.
		 */
		for (bit_idx = 0; bit_idx < size; bit_idx++) {
			/* Get the bit value from input data. */
			bit_val = 0;
			if (bit_idx < in_bits_count) {
				bit_val = *in_bit_ptr & in_bit_mask;
				in_bit_mask <<= 1;
				if (!in_bit_mask) {
					in_bit_mask = 1 << 0;
					in_bit_ptr++;
				}
			}
			/* Manipulate the sample buffer data image. */
			if (bit_val)
				*out_bit_ptr |= out_bit_mask;
			else
				*out_bit_ptr &= ~out_bit_mask;
			/* Update output position after bitmap update. */
			out_bit_mask <<= 1;
			if (!out_bit_mask) {
				out_bit_mask = 1 << 0;
				out_bit_ptr++;
			}
		}
	}
	if (!size && !is_ignored(inc, identifier))
		sr_warn("VCD signal not found for ID '%s'.", identifier);
}

/*
 * Set an analog channel's value from a floating point number. One
 * VCD signal name can translate to several sigrok channels.
 */
static void process_real(struct context *inc, char *identifier, float real_val)
{
	gboolean found;
	GSList *l;
	struct vcd_channel *vcd_ch;

	found = FALSE;
	for (l = inc->channels; l; l = l->next) {
		vcd_ch = l->data;
		if (vcd_ch->type != SR_CHANNEL_ANALOG)
			continue;
		if (g_strcmp0(identifier, vcd_ch->identifier) != 0)
			continue;

		/* Found our (analog) channel. */
		found = TRUE;
		sr_spew("Processing real data, id '%s', ch %zu, val %.16g",
			identifier, vcd_ch->array_index, real_val);
		inc->current_floats[vcd_ch->array_index] = real_val;
	}
	if (!found && !is_ignored(inc, identifier))
		sr_warn("VCD signal not found for ID '%s'.", identifier);
}

/*
 * Converts a bit position's text character to a number value.
 *
 * TODO Check for complete coverage of Verilog's standard logic values
 * (IEEE-1364). The set is said to be “01XZHUWL-”, which only a part of
 * is handled here. What would be the complete mapping?
 * - 0/L -> bit value 0
 * - 1/H -> bit value 1
 * - X "don't care" -> TODO
 * - Z "high impedance" -> TODO
 * - W "weak(?)" -> TODO
 * - U "undefined" -> TODO
 * - '-' "TODO" -> TODO
 *
 * For simplicity, this input module implementation maps "known low"
 * values to 0, and "known high" values to 1. All other values will
 * end up assuming "low" (return number 0), while callers might warn.
 * It's up to users to provide compatible input data, or accept the
 * warnings. Silently accepting unknown input data is not desirable.
 */
static uint8_t vcd_char_to_value(char bit_char, int *warn)
{

	bit_char = g_ascii_tolower(bit_char);

	/* Convert the "undisputed" variants. */
	if (bit_char == '0' || bit_char == 'l')
		return 0;
	if (bit_char == '1' || bit_char == 'h')
		return 1;

	/* Convert the "uncertain" variants. */
	if (warn)
		*warn = 1;
	if (bit_char == 'x' || bit_char == 'z')
		return 0;
	if (bit_char == 'u')
		return 0;
	if (bit_char == '-')
		return 0;

	/* Unhandled input text. */
	return ~0;
}

/*
 * Check the validity of a VCD string value. It's essential to reliably
 * accept valid data which the community uses in the field, yet robustly
 * reject invalid data for users' awareness. Since IEEE 1800-2017 would
 * not discuss the representation of this data type, it's assumed to not
 * be an official feature of the VCD file format. This implementation is
 * an educated guess after inspection of other arbitrary implementations,
 * not backed by any specification or public documentation.
 *
 * A quick summary of the implemented assumptions: Must be a sequence of
 * ASCII printables. Must not contain whitespace. Might contain escape
 * sequences: A backslash followed by a single character, like '\n' or
 * '\\'. Or a backslash and the letter x followed by two hex digits,
 * like '\x20'. Or a backslash followed by three octal digits, like
 * '\007'. As an exception also accepts a single digit '\0' but only at
 * the text end. The string value may be empty, but must not be NULL.
 *
 * This implementation assumes an ASCII based platform for simplicity
 * and readability. Should be a given on sigrok supported platforms.
 */
static gboolean vcd_string_valid(const char *s)
{
	char c;

	if (!s)
		return FALSE;

	while (*s) {
		c = *s++;
		/* Reject non-printable ASCII chars including DEL. */
		if (c < ' ')
			return FALSE;
		if (c > '~')
			return FALSE;
		/* Deeper inspection of escape sequences. */
		if (c == '\\') {
			c = *s++;
			switch (c) {
			case 'a': /* BEL, bell aka "alarm" */
			case 'b': /* BS, back space */
			case 't': /* TAB, tabulator */
			case 'n': /* NL, newline */
			case 'v': /* VT, vertical tabulator */
			case 'f': /* FF, form feed */
			case 'r': /* CR, carriage return */
			case '"': /* double quotes */
			case '\'': /* tick, single quote */
			case '?': /* question mark */
			case '\\': /* backslash */
				continue;
			case 'x': /* \xNN two hex digits */
				c = *s++;
				if (!g_ascii_isxdigit(c))
					return FALSE;
				c = *s++;
				if (!g_ascii_isxdigit(c))
					return FALSE;
				continue;
			case '0': /* \NNN three octal digits */
			case '1':
			case '2':
			case '3':
			case '4':
			case '5':
			case '6':
			case '7':
				/* Special case '\0' at end of text. */
				if (c == '0' && !*s)
					return TRUE;
				/*
				 * First digit was covered by the outer
				 * switch(). Two more digits to check.
				 */
				c = *s++;
				if (!g_ascii_isdigit(c) || c > '7')
					return FALSE;
				c = *s++;
				if (!g_ascii_isdigit(c) || c > '7')
					return FALSE;
				continue;
			default:
				return FALSE;
			}
		}
	}

	return TRUE;
}

/* Parse one text line of the data section. */
static int parse_textline(const struct sr_input *in, char *line)
{
	struct context *inc;
	int ret;
	char *curr_word, curr_first;
	gboolean is_timestamp, is_section;
	gboolean is_real, is_multibit, is_singlebit, is_string;
	uint64_t timestamp;
	char *identifier, *endptr;
	size_t count;

	inc = in->priv;

	/*
	 * Consume space separated words from a caller's text line. Note
	 * that many words are self contained, but some require another
	 * word to follow. This implementation assumes that both words
	 * (when involved) become available in the same invocation, that
	 * is that both words reside on the same text line of the file.
	 * The fact that callers always pass complete text lines should
	 * make this assumption acceptable. No generator is known to
	 * split two corresponding words across text lines.
	 *
	 * This constraint applies to bit vector data, multi-bit integer
	 * and real (float) values, text strings, as well as single-bit
	 * values with whitespace before their identifiers (if that is
	 * valid in VCD, we'd accept it here; if generators don't create
	 * such input, then support for it does not harm).
	 */
	ret = SR_OK;
	while (line) {
		/*
		 * Lookup one word here which is mandatory. Locations
		 * below conditionally lookup another word as needed.
		 */
		curr_word = sr_text_next_word(line, &line);
		if (!curr_word)
			break;
		if (!*curr_word)
			continue;
		curr_first = g_ascii_tolower(curr_word[0]);

		/*
		 * Optionally skip some sections that can be interleaved
		 * with data (and may or may not be supported by this
		 * input module). If the section is not skipped but the
		 * $end keyword needs to get tracked, specifically handle
		 * this case, for improved robustness (still reject files
		 * which happen to use invalid syntax).
		 */
		if (inc->skip_until_end) {
			if (strcmp(curr_word, "$end") == 0) {
				/* Done with unhandled/unknown section. */
				sr_dbg("done skipping until $end");
				inc->skip_until_end = FALSE;
			} else {
				sr_spew("skipping word: %s", curr_word);
			}
			continue;
		}
		if (inc->ignore_end_keyword) {
			if (strcmp(curr_word, "$end") == 0) {
				sr_dbg("done ignoring $end keyword");
				inc->ignore_end_keyword = FALSE;
				continue;
			}
		}

		/*
		 * There may be $keyword sections inside the data part of
		 * the input file. Do inspect some of the sections' content
		 * but ignore their surrounding keywords. Silently skip
		 * unsupported section types (which transparently covers
		 * $comment sections).
		 */
		is_section = curr_first == '$' && curr_word[1];
		if (is_section) {
			gboolean inspect_data;

			inspect_data = FALSE;
			inspect_data |= g_strcmp0(curr_word, "$dumpvars") == 0;
			inspect_data |= g_strcmp0(curr_word, "$dumpon") == 0;
			inspect_data |= g_strcmp0(curr_word, "$dumpoff") == 0;
			if (inspect_data) {
				/* Ignore keywords, yet parse contents. */
				sr_dbg("%s section, will parse content", curr_word);
				inc->ignore_end_keyword = TRUE;
			} else {
				/* Ignore section from here up to $end. */
				sr_dbg("%s section, will skip until $end", curr_word);
				inc->skip_until_end = TRUE;
			}
			continue;
		}

		/*
		 * Numbers prefixed by '#' are timestamps, which translate
		 * to sigrok sample numbers. Apply optional downsampling,
		 * and apply the 'skip' logic. Check the recent timestamp
		 * for plausibility. Submit the corresponding number of
		 * samples of previously accumulated data values to the
		 * session feed.
		 */
		is_timestamp = curr_first == '#' && g_ascii_isdigit(curr_word[1]);
		if (is_timestamp) {
			endptr = NULL;
			timestamp = strtoull(&curr_word[1], &endptr, 10);
			if (!endptr || *endptr) {
				sr_err("Invalid timestamp: %s.", curr_word);
				ret = SR_ERR_DATA;
				break;
			}
			sr_spew("Got timestamp: %" PRIu64, timestamp);
			ret = ts_stats_check(&inc->ts_stats, timestamp);
			if (ret != SR_OK)
				break;
			if (inc->options.downsample > 1) {
				timestamp /= inc->options.downsample;
				sr_spew("Downsampled timestamp: %" PRIu64, timestamp);
			}

			/*
			 * Skip < 0 => skip until first timestamp.
			 * Skip = 0 => don't skip
			 * Skip > 0 => skip until timestamp >= skip.
			 */
			if (inc->options.skip_specified && !inc->use_skip) {
				sr_dbg("Seeding skip from user spec %" PRIu64,
					inc->options.skip_starttime);
				inc->prev_timestamp = inc->options.skip_starttime;
				inc->use_skip = TRUE;
			}
			if (!inc->use_skip) {
				sr_dbg("Seeding skip from first timestamp");
				inc->options.skip_starttime = timestamp;
				inc->prev_timestamp = timestamp;
				inc->use_skip = TRUE;
				continue;
			}
			if (inc->options.skip_starttime && timestamp < inc->options.skip_starttime) {
				sr_spew("Timestamp skipped, before user spec");
				inc->prev_timestamp = inc->options.skip_starttime;
				continue;
			}
			if (timestamp == inc->prev_timestamp) {
				/*
				 * Ignore repeated timestamps (e.g. sigrok
				 * outputs these). Can also happen when
				 * downsampling makes distinct input values
				 * end up at the same scaled down value.
				 * Also transparently covers the initial
				 * timestamp.
				 */
				sr_spew("Timestamp is identical to previous timestamp");
				continue;
			}
			if (timestamp < inc->prev_timestamp) {
				sr_err("Invalid timestamp: %" PRIu64 " (leap backwards).", timestamp);
				ret = SR_ERR_DATA;
				break;
			}
			if (inc->options.compress) {
				/* Compress long idle periods */
				count = timestamp - inc->prev_timestamp;
				if (count > inc->options.compress) {
					sr_dbg("Long idle period, compressing");
					count = timestamp - inc->options.compress;
					inc->prev_timestamp = count;
				}
			}

			/* Generate samples from prev_timestamp up to timestamp - 1. */
			count = timestamp - inc->prev_timestamp;
			sr_spew("Got a new timestamp, feeding %zu samples", count);
			add_samples(in, count, FALSE);
			inc->prev_timestamp = timestamp;
			inc->data_after_timestamp = FALSE;
			continue;
		}
		inc->data_after_timestamp = TRUE;

		/*
		 * Data values come in different formats, are associated
		 * with channel identifiers, and correspond to the period
		 * of time from the most recent timestamp to the next
		 * timestamp.
		 *
		 * Supported input data formats are:
		 * - S<value> <sep> <id> (value not used, VCD type 'string').
		 * - R<value> <sep> <id> (analog channel, VCD type 'real').
		 * - B<value> <sep> <id> (analog channel, VCD type 'integer').
		 * - B<value> <sep> <id> (logic channels, VCD bit vectors).
		 * - <value> <id> (logic channel, VCD single-bit values).
		 *
		 * Input values can be:
		 * - Floating point numbers.
		 * - Bit strings (which covers multi-bit aka integers
		 *   as well as vectors).
		 * - Single bits.
		 *
		 * Things to note:
		 * - Individual bits can be 0/1 which is supported by
		 *   libsigrok, or x or z which is treated like 0 here
		 *   (sigrok lacks support for ternary logic, neither is
		 *   there support for the full IEEE set of values).
		 * - Single-bit values typically won't be separated from
		 *   the signal identifer, multi-bit values and floats
		 *   are separated (will reference the next word). This
		 *   implementation silently accepts separators for
		 *   single-bit values, too.
		 */
		is_real = curr_first == 'r' && curr_word[1];
		is_multibit = curr_first == 'b' && curr_word[1];
		is_singlebit = curr_first == '0' || curr_first == '1';
		is_singlebit |= curr_first == 'l' || curr_first == 'h';
		is_singlebit |= curr_first == 'x' || curr_first == 'z';
		is_singlebit |= curr_first == 'u' || curr_first == '-';
		is_string = curr_first == 's';
		if (is_real) {
			char *real_text;
			float real_val;

			real_text = &curr_word[1];
			identifier = sr_text_next_word(line, &line);
			if (!*real_text || !identifier || !*identifier) {
				sr_err("Unexpected real format.");
				ret = SR_ERR_DATA;
				break;
			}
			sr_spew("Got real data %s for id '%s'.",
				real_text, identifier);
			if (sr_atof_ascii(real_text, &real_val) != SR_OK) {
				sr_err("Cannot convert value: %s.", real_text);
				ret = SR_ERR_DATA;
				break;
			}
			process_real(inc, identifier, real_val);
			continue;
		}
		if (is_multibit) {
			char *bits_text_start;
			size_t bit_count;
			char *bits_text, bit_char;
			uint8_t bit_value;
			uint8_t *value_ptr, value_mask;
			GString *bits_val_text;

			/* TODO
			 * Fold in single-bit code path here? To re-use
			 * the X/Z support. Current redundancy is few so
			 * there is little pressure to unify code paths.
			 * Also multi-bit handling is often different
			 * from single-bit handling, so the "unified"
			 * path would often check for special cases. So
			 * we may never unify code paths at all here.
			 */
			bits_text = &curr_word[1];
			identifier = sr_text_next_word(line, &line);

			if (!*bits_text || !identifier || !*identifier) {
				sr_err("Unexpected integer/vector format.");
				ret = SR_ERR_DATA;
				break;
			}
			sr_spew("Got integer/vector data %s for id '%s'.",
				bits_text, identifier);

			/*
			 * Accept a bit string of arbitrary length (sort
			 * of, within the limits of the previously setup
			 * conversion buffer). The input text omits the
			 * leading zeroes, hence we convert from end to
			 * the start, to get the significant bits. There
			 * should only be errors for invalid input, or
			 * for input that is rather strange (data holds
			 * more bits than the signal's declaration in
			 * the header suggested). Silently accept data
			 * that fits in the conversion buffer, and has
			 * more significant bits than the signal's type
			 * (that'd be non-sence yet acceptable input).
			 */
			bits_text_start = bits_text;
			bits_text += strlen(bits_text);
			bit_count = bits_text - bits_text_start;
			if (bit_count > inc->conv_bits.max_bits) {
				sr_err("Value exceeds conversion buffer: %s",
					bits_text_start);
				ret = SR_ERR_DATA;
				break;
			}
			memset(inc->conv_bits.value, 0, inc->conv_bits.unit_size);
			value_ptr = &inc->conv_bits.value[0];
			value_mask = 1 << 0;
			inc->conv_bits.sig_count = 0;
			while (bits_text > bits_text_start) {
				inc->conv_bits.sig_count++;
				bit_char = *(--bits_text);
				bit_value = vcd_char_to_value(bit_char, NULL);
				if (bit_value == 0) {
					/* EMPTY */
				} else if (bit_value == 1) {
					*value_ptr |= value_mask;
				} else {
					inc->conv_bits.sig_count = 0;
					break;
				}
				value_mask <<= 1;
				if (!value_mask) {
					value_ptr++;
					value_mask = 1 << 0;
				}
			}
			if (!inc->conv_bits.sig_count) {
				sr_err("Unexpected vector format: %s",
					bits_text_start);
				ret = SR_ERR_DATA;
				break;
			}
			if (sr_log_loglevel_get() >= SR_LOG_SPEW) {
				bits_val_text = sr_hexdump_new(inc->conv_bits.value,
					value_ptr - inc->conv_bits.value + 1);
				sr_spew("Vector value: %s.", bits_val_text->str);
				sr_hexdump_free(bits_val_text);
			}

			process_bits(inc, identifier,
				inc->conv_bits.value, inc->conv_bits.sig_count);
			continue;
		}
		if (is_singlebit) {
			char *bits_text, bit_char;
			uint8_t bit_value;

			/* Get the value text, and signal identifier. */
			bits_text = &curr_word[0];
			bit_char = *bits_text;
			if (!bit_char) {
				sr_err("Bit value missing.");
				ret = SR_ERR_DATA;
				break;
			}
			identifier = ++bits_text;
			if (!*identifier)
				identifier = sr_text_next_word(line, &line);
			if (!identifier || !*identifier) {
				sr_err("Identifier missing.");
				ret = SR_ERR_DATA;
				break;
			}

			/* Convert value text to single-bit number. */
			bit_value = vcd_char_to_value(bit_char, NULL);
			if (bit_value != 0 && bit_value != 1) {
				sr_err("Unsupported bit value '%c'.", bit_char);
				ret = SR_ERR_DATA;
				break;
			}
			inc->conv_bits.value[0] = bit_value;
			process_bits(inc, identifier, inc->conv_bits.value, 1);
			continue;
		}
		if (is_string) {
			const char *str_value;

			str_value = &curr_word[1];
			identifier = sr_text_next_word(line, &line);
			if (!vcd_string_valid(str_value)) {
				sr_err("Invalid string data: %s", str_value);
				ret = SR_ERR_DATA;
				break;
			}
			if (!identifier || !*identifier) {
				sr_err("String value without identifier.");
				ret = SR_ERR_DATA;
				break;
			}
			sr_spew("Got string data, id '%s', value \"%s\".",
				identifier, str_value);
			if (!is_ignored(inc, identifier)) {
				sr_err("String value for identifier '%s'.",
					identifier);
				ret = SR_ERR_DATA;
				break;
			}
			continue;
		}

		/* Design choice: Consider unsupported input fatal. */
		sr_err("Unknown token '%s'.", curr_word);
		ret = SR_ERR_DATA;
		break;
	}

	return ret;
}

static int process_buffer(struct sr_input *in, gboolean is_eof)
{
	struct context *inc;
	uint64_t samplerate;
	GVariant *gvar;
	int ret;
	char *rdptr, *line;
	size_t taken, rdlen;

	inc = in->priv;

	if (!inc->got_header)
		return SR_ERR_DATA;

	/* Send feed header and samplerate (once) before sample data. */
	if (!inc->started) {
		std_session_send_df_header(in->sdi);

		samplerate = inc->samplerate / inc->options.downsample;
		if (samplerate) {
			gvar = g_variant_new_uint64(samplerate);
			sr_session_send_meta(in->sdi, SR_CONF_SAMPLERATE, gvar);
		}

		inc->started = TRUE;
	}

	/*
	 * Workaround broken generators which output incomplete text
	 * lines. Enforce the trailing line feed. Proper input is not
	 * harmed by another empty line of input data.
	 */
	if (is_eof)
		g_string_append_c(in->buf, '\n');

	/* Find and process complete text lines in the input data. */
	ret = SR_OK;
	rdptr = in->buf->str;
	taken = 0;
	while (rdptr) {
		rdlen = &in->buf->str[in->buf->len] - rdptr;
		line = sr_text_next_line(rdptr, rdlen, &rdptr, &taken);
		if (!line)
			break;
		if (!*line)
			continue;
		ret = parse_textline(in, line);
		if (ret != SR_OK)
			break;
	}
	g_string_erase(in->buf, 0, taken);

	return ret;
}

static int format_match(GHashTable *metadata, unsigned int *confidence)
{
	GString *buf, *tmpbuf;
	gboolean status;
	char *name, *contents;

	buf = g_hash_table_lookup(metadata,
		GINT_TO_POINTER(SR_INPUT_META_HEADER));
	tmpbuf = g_string_new_len(buf->str, buf->len);

	/*
	 * If we can parse the first section correctly, then it is
	 * assumed that the input is in VCD format.
	 */
	check_remove_bom(tmpbuf);
	status = parse_section(tmpbuf, &name, &contents);
	g_string_free(tmpbuf, TRUE);
	g_free(name);
	g_free(contents);

	if (!status)
		return SR_ERR;

	*confidence = 1;
	return SR_OK;
}

static int init(struct sr_input *in, GHashTable *options)
{
	struct context *inc;
	GVariant *data;

	inc = g_malloc0(sizeof(*inc));

	data = g_hash_table_lookup(options, "numchannels");
	inc->options.maxchannels = g_variant_get_uint32(data);

	data = g_hash_table_lookup(options, "downsample");
	inc->options.downsample = g_variant_get_uint64(data);
	if (inc->options.downsample < 1)
		inc->options.downsample = 1;

	data = g_hash_table_lookup(options, "compress");
	inc->options.compress = g_variant_get_uint64(data);
	inc->options.compress /= inc->options.downsample;

	data = g_hash_table_lookup(options, "skip");
	if (data) {
		inc->options.skip_specified = TRUE;
		inc->options.skip_starttime = g_variant_get_uint64(data);
		if (inc->options.skip_starttime == ~UINT64_C(0)) {
			inc->options.skip_specified = FALSE;
			inc->options.skip_starttime = 0;
		}
		inc->options.skip_starttime /= inc->options.downsample;
	}

	in->sdi = g_malloc0(sizeof(*in->sdi));
	in->priv = inc;

	inc->scope_prefix = g_string_new("\0");

	return SR_OK;
}

static int receive(struct sr_input *in, GString *buf)
{
	struct context *inc;
	int ret;

	inc = in->priv;

	/* Collect all input chunks, potential deferred processing. */
	g_string_append_len(in->buf, buf->str, buf->len);
	if (!inc->got_header && in->buf->len == buf->len)
		check_remove_bom(in->buf);

	/* Must complete reception of the VCD header first. */
	if (!inc->got_header) {
		if (!have_header(in->buf))
			return SR_OK;
		ret = parse_header(in, in->buf);
		if (ret != SR_OK)
			return ret;
		/* sdi is ready, notify frontend. */
		in->sdi_ready = TRUE;
		return SR_OK;
	}

	/* Process sample data. */
	ret = process_buffer(in, FALSE);

	return ret;
}

static int end(struct sr_input *in)
{
	struct context *inc;
	int ret;
	size_t count;

	inc = in->priv;

	/* Must complete processing of previously received chunks. */
	if (in->sdi_ready)
		ret = process_buffer(in, TRUE);
	else
		ret = SR_OK;

	/* Flush most recently queued sample data when EOF is seen. */
	if (inc->got_header && ret == SR_OK) {
		count = inc->data_after_timestamp ? 1 : 0;
		add_samples(in, count, TRUE);
	}

	/* Optionally suggest downsampling after all input data was seen. */
	if (inc->got_header)
		(void)ts_stats_post(inc, !inc->data_after_timestamp);

	/* Must send DF_END when DF_HEADER was sent before. */
	if (inc->started)
		std_session_send_df_end(in->sdi);

	return ret;
}

static void cleanup(struct sr_input *in)
{
	struct context *inc;

	inc = in->priv;

	keep_header_for_reread(in);

	g_slist_free_full(inc->channels, free_channel);
	inc->channels = NULL;
	feed_queue_logic_free(inc->feed_logic);
	inc->feed_logic = NULL;
	g_free(inc->conv_bits.value);
	inc->conv_bits.value = NULL;
	g_free(inc->current_logic);
	inc->current_logic = NULL;
	g_free(inc->current_floats);
	inc->current_floats = NULL;
	g_string_free(inc->scope_prefix, TRUE);
	inc->scope_prefix = NULL;
	g_slist_free_full(inc->ignored_signals, g_free);
	inc->ignored_signals = NULL;
}

static int reset(struct sr_input *in)
{
	struct context *inc;
	struct vcd_user_opt save;
	struct vcd_prev prev;

	inc = in->priv;

	/* Relase previously allocated resources. */
	cleanup(in);
	g_string_truncate(in->buf, 0);

	/* Restore part of the context, init() won't run again. */
	save = inc->options;
	prev = inc->prev;
	memset(inc, 0, sizeof(*inc));
	inc->options = save;
	inc->prev = prev;
	inc->scope_prefix = g_string_new("\0");

	return SR_OK;
}

enum vcd_option_t {
	OPT_NUM_CHANS,
	OPT_DOWN_SAMPLE,
	OPT_SKIP_COUNT,
	OPT_COMPRESS,
	OPT_MAX,
};

static struct sr_option options[] = {
	[OPT_NUM_CHANS] = {
		"numchannels", "Max number of sigrok channels",
		"The maximum number of sigrok channels to create for VCD input signals.",
		NULL, NULL,
	},
	[OPT_DOWN_SAMPLE] = {
		"downsample", "Downsampling factor",
		"Downsample the input file's samplerate, i.e. divide by the specified factor.",
		NULL, NULL,
	},
	[OPT_SKIP_COUNT] = {
		"skip", "Skip this many initial samples",
		"Skip samples until the specified timestamp. "
		"By default samples start at the first timestamp in the file. "
		"Value 0 creates samples starting at timestamp 0. "
		"Values above 0 only start processing at the given timestamp.",
		NULL, NULL,
	},
	[OPT_COMPRESS] = {
		"compress", "Compress idle periods",
		"Compress idle periods which are longer than the specified number of timescale ticks.",
		NULL, NULL,
	},
	[OPT_MAX] = ALL_ZERO,
};

static const struct sr_option *get_options(void)
{
	if (!options[0].def) {
		options[OPT_NUM_CHANS].def = g_variant_ref_sink(g_variant_new_uint32(0));
		options[OPT_DOWN_SAMPLE].def = g_variant_ref_sink(g_variant_new_uint64(1));
		options[OPT_SKIP_COUNT].def = g_variant_ref_sink(g_variant_new_uint64(~UINT64_C(0)));
		options[OPT_COMPRESS].def = g_variant_ref_sink(g_variant_new_uint64(0));
	}

	return options;
}

SR_PRIV struct sr_input_module input_vcd = {
	.id = "vcd",
	.name = "VCD",
	.desc = "Value Change Dump data",
	.exts = (const char*[]){"vcd", NULL},
	.metadata = { SR_INPUT_META_HEADER | SR_INPUT_META_REQUIRED },
	.options = get_options,
	.format_match = format_match,
	.init = init,
	.receive = receive,
	.end = end,
	.cleanup = cleanup,
	.reset = reset,
};