/*
* TODO
*
- * - Determine how the text line handling can get improved, regarding
- * all of robustness and flexibility and correctness.
- * - The current implementation splits on "any run of CR and LF". Which
- * translates to: Line numbers are wrong in the presence of empty
- * lines in the input stream. See below for an (expensive) fix.
- * - Dropping support for CR style end-of-line markers could improve
- * the situation a lot. Code could search for and split on LF, and
- * trim optional trailing CR. This would result in proper support
- * for CRLF (Windows) as well as LF (Unix), and allow for correct
- * line number counts.
- * - When support for CR-only line termination cannot get dropped,
- * then the current implementation is inappropriate. Currently the
- * input stream is scanned for the first occurance of either of the
- * supported termination styles (which is good). For the remaining
- * session a consistent encoding of the text lines is assumed (which
- * is acceptable).
- * - When line numbers need to be correct and reliable, _and_ the full
- * set of previously supported line termination sequences are required,
- * and potentially more are to get added for improved compatibility
- * with more platforms or generators, then the current approach of
- * splitting on runs of termination characters needs to get replaced,
- * by the more expensive approach to scan for and count the initially
- * determined termination sequence.
- *
* - Add support for analog input data? (optional)
- * - Needs a syntax first for user specs which channels (columns) are
- * logic and which are analog. May need heuristics(?) to guess from
- * input data in the absence of user provided specs.
+ * - Extend the set of supported column types. Just grab a double
+ * value from floating point format input text.
+ * - Optionally get precision ('digits') from the column's format spec?
+ * From the position which is "bit count" for logic channels?
+ * - Optionally get sample rate from timestamp column. Just best-effort
+ * approach, not necessarily reliable. Users can always specify rates.
+ * - Add a test suite for input modules in general, and CSV in specific?
+ * Becomes more important with the multitude of options and their
+ * interaction. Could cover edge cases (BOM presence, line termination
+ * absence, etc) and auto-stuff as well (channel names, channel counts,
+ * samplerates, etc).
*/
/* Single column formats. */
struct sr_datafeed_packet packet;
struct sr_datafeed_meta meta;
struct sr_config *src;
- uint64_t samplerate;
struct sr_datafeed_logic logic;
int rc;
if (inc->samplerate && !inc->samplerate_sent) {
packet.type = SR_DF_META;
packet.payload = &meta;
- samplerate = inc->samplerate;
- src = sr_config_new(SR_CONF_SAMPLERATE, g_variant_new_uint64(samplerate));
+ src = sr_config_new(SR_CONF_SAMPLERATE, g_variant_new_uint64(inc->samplerate));
meta.config = g_slist_append(NULL, src);
sr_session_send(in->sdi, &packet);
g_slist_free(meta.config);
/* Get the (optional, decimal, default 1) column count. Accept '*'. */
endp = NULL;
if (*spec == '*') {
+ /* Workaround, strtoul("*") won't always yield expected endp. */
count = 0;
endp = (char *)&spec[1];
} else {
/* Get the (mandatory, single letter) type spec (-/xob/l). */
format_char = *spec++;
switch (format_char) {
- case '-': /* Might conflict with number-parsing. */
+ case '-':
case '/':
format_char = '-';
format_code = FORMAT_NONE;
return SR_OK;
}
-static int make_column_details_from_format(struct context *inc,
- const char *column_format)
+static int make_column_details_from_format(const struct sr_input *in,
+ const char *column_format, char **column_texts)
{
+ struct context *inc;
char **formats, *format;
size_t format_count, column_count, bit_count;
size_t auto_column_count;
size_t format_idx, c, b, column_idx, channel_idx;
enum single_col_format f;
struct column_details *detail;
+ GString *channel_name;
+ size_t create_idx;
+ char *column;
+ const char *caption;
int ret;
+ inc = in->priv;
+ inc->column_seen_count = g_strv_length(column_texts);
+
/* Split the input spec, count involved columns and bits. */
formats = g_strsplit(column_format, ",", 0);
if (!formats) {
sr_dbg("Column format %s -> %zu columns, %zu logic channels.",
column_format, column_count, bit_count);
- /* Allocate and fill in "column processing" details. */
+ /* Allocate and fill in "column processing" details. Create channels. */
inc->column_want_count = column_count;
+ if (inc->column_seen_count < inc->column_want_count) {
+ sr_err("Insufficient input text width for desired data amount, got %zu but want %zu columns.",
+ inc->column_seen_count, inc->column_want_count);
+ g_strfreev(formats);
+ return SR_ERR_ARG;
+ }
inc->column_details = g_malloc0_n(column_count, sizeof(inc->column_details[0]));
column_idx = channel_idx = 0;
+ channel_name = g_string_sized_new(64);
for (format_idx = 0; format_idx < format_count; format_idx++) {
+ /* Process a format field, which can span multiple columns. */
format = formats[format_idx];
(void)split_column_format(format, &c, &f, &b);
if (f && !c)
c = auto_column_count;
while (c-- > 0) {
+ /* Fill in a column's processing details. */
detail = &inc->column_details[column_idx++];
detail->col_nr = column_idx;
detail->text_format = f;
sr_dbg("detail -> col %zu, fmt %s, ch off/cnt %zu/%zu",
detail->col_nr, col_format_text[detail->text_format],
detail->channel_offset, detail->channel_count);
+ if (!detail->text_format)
+ continue;
+ /*
+ * Create channels with appropriate names. Optionally
+ * use text from a header line (when requested by the
+ * user). In the absence of header text, channels are
+ * assigned rather generic names.
+ *
+ * Manipulation of the column's caption (when a header
+ * line is seen) is acceptable, because this header
+ * line won't get processed another time.
+ */
+ column = column_texts[detail->col_nr - 1];
+ if (inc->use_header && column && *column)
+ caption = sr_scpi_unquote_string(column);
+ else
+ caption = NULL;
+ if (!caption || !*caption)
+ caption = NULL;
+ for (create_idx = 0; create_idx < detail->channel_count; create_idx++) {
+ if (caption && detail->channel_count == 1) {
+ g_string_assign(channel_name, caption);
+ } else if (caption) {
+ g_string_printf(channel_name, "%s[%zu]",
+ caption, create_idx);
+ } else {
+ g_string_printf(channel_name, "%zu",
+ detail->channel_offset + create_idx);
+ }
+ sr_channel_new(in->sdi, detail->channel_offset + create_idx,
+ SR_CHANNEL_LOGIC, TRUE, channel_name->str);
+ }
}
}
inc->logic_channels = channel_idx;
+ g_string_free(channel_name, TRUE);
g_strfreev(formats);
return SR_OK;
in->priv = inc = g_malloc0(sizeof(*inc));
single_column = g_variant_get_uint32(g_hash_table_lookup(options, "single_column"));
-
logic_channels = g_variant_get_uint32(g_hash_table_lookup(options, "logic_channels"));
-
inc->delimiter = g_string_new(g_variant_get_string(
g_hash_table_lookup(options, "column_separator"), NULL));
if (!inc->delimiter->len) {
sr_err("Column separator cannot be empty.");
return SR_ERR_ARG;
}
-
s = g_variant_get_string(g_hash_table_lookup(options, "single_format"), NULL);
if (g_ascii_strncasecmp(s, "bin", 3) == 0) {
format = FORMAT_BIN;
sr_err("Invalid single-column format: '%s'", s);
return SR_ERR_ARG;
}
-
inc->comment = g_string_new(g_variant_get_string(
g_hash_table_lookup(options, "comment_leader"), NULL));
if (g_string_equal(inc->comment, inc->delimiter)) {
sr_warn("Comment leader and column separator conflict, disabling comment support.");
g_string_truncate(inc->comment, 0);
}
-
inc->samplerate = g_variant_get_uint64(g_hash_table_lookup(options, "samplerate"));
-
first_column = g_variant_get_uint32(g_hash_table_lookup(options, "first_column"));
-
inc->use_header = g_variant_get_boolean(g_hash_table_lookup(options, "header"));
-
inc->start_line = g_variant_get_uint32(g_hash_table_lookup(options, "start_line"));
if (inc->start_line < 1) {
sr_err("Invalid start line %zu.", inc->start_line);
static int initial_parse(const struct sr_input *in, GString *buf)
{
struct context *inc;
- GString *channel_name;
- size_t num_columns, ch_idx, ch_name_idx, col_idx, col_nr;
+ size_t num_columns;
size_t line_number, line_idx;
int ret;
- char **lines, *line, **columns, *column;
- const char *col_caption;
- gboolean got_caption;
- const struct column_details *detail;
+ char **lines, *line, **columns;
ret = SR_OK;
inc = in->priv;
columns = NULL;
+ /* Search for the first line to process (header or data). */
line_number = 0;
if (inc->termination)
lines = g_strsplit(buf->str, inc->termination, 0);
goto out;
}
- /* See how many columns the current line has. */
+ /* Get the number of columns in the line. */
columns = split_line(line, inc);
if (!columns) {
sr_err("Error while parsing line %zu.", line_number);
sr_dbg("DIAG Got %zu columns in text line: %s.", num_columns, line);
/*
- * Track the observed number of columns in the input file. Do
- * process the previously gathered columns format spec now that
- * automatic channel count can be dealt with.
+ * Interpret the user provided column format specs. This might
+ * involve inspection of the now received input text, to support
+ * e.g. automatic detection of channel counts in the absence of
+ * user provided specs. Optionally a header line is used to get
+ * channels' names.
+ *
+ * Check the then created channels for consistency across .reset
+ * and .receive sequences (file re-load).
*/
- inc->column_seen_count = num_columns;
- ret = make_column_details_from_format(inc, inc->column_formats);
+ ret = make_column_details_from_format(in, inc->column_formats, columns);
if (ret != SR_OK) {
sr_err("Cannot parse columns format using line %zu.", line_number);
goto out;
}
-
- /*
- * Assume all lines have equal length (column count). Bail out
- * early on suspicious or insufficient input data (check input
- * which became available here against previous user specs or
- * auto-determined properties, regardless of layout variant).
- */
- if (num_columns < inc->column_want_count) {
- sr_err("Insufficient input text width for desired data amount, got %zu but want %zu columns.",
- num_columns, inc->column_want_count);
- ret = SR_ERR;
- goto out;
- }
-
- /*
- * Determine channel names. Optionally use text from a header
- * line (when requested by the user, and only works in multi
- * column mode). In the absence of header text, or in single
- * column mode, channels are assigned rather generic names.
- *
- * Manipulation of the column's caption is acceptable here, the
- * header line will never get processed another time.
- */
- channel_name = g_string_sized_new(64);
- for (col_idx = 0; col_idx < inc->column_want_count; col_idx++) {
-
- col_nr = col_idx + 1;
- detail = lookup_column_details(inc, col_nr);
- if (detail->text_format == FORMAT_NONE)
- continue;
- column = columns[col_idx];
- col_caption = sr_scpi_unquote_string(column);
- got_caption = inc->use_header && *col_caption;
- sr_dbg("DIAG col %zu, ch count %zu, text %s.",
- col_nr, detail->channel_count, col_caption);
- for (ch_idx = 0; ch_idx < detail->channel_count; ch_idx++) {
- ch_name_idx = detail->channel_offset + ch_idx;
- if (got_caption && detail->channel_count == 1)
- g_string_assign(channel_name, col_caption);
- else if (got_caption)
- g_string_printf(channel_name, "%s[%zu]",
- col_caption, ch_idx);
- else
- g_string_printf(channel_name, "%zu", ch_name_idx);
- sr_dbg("DIAG ch idx %zu, name %s.", ch_name_idx, channel_name->str);
- sr_channel_new(in->sdi, ch_name_idx, SR_CHANNEL_LOGIC, TRUE,
- channel_name->str);
- }
- }
- g_string_free(channel_name, TRUE);
if (!check_header_in_reread(in)) {
ret = SR_ERR_DATA;
goto out;
}
/*
+ * Allocate buffer memory for datafeed submission of sample data.
* Calculate the minimum buffer size to store the set of samples
* of all channels (unit size). Determine a larger buffer size
* for datafeed submission that is a multiple of the unit size.
projects / libsigrok.git / blobdiff