* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
+#include <config.h>
#include <stdlib.h>
#include <string.h>
#include <glib.h>
-#include "libsigrok.h"
+#include <libsigrok/libsigrok.h>
#include "libsigrok-internal.h"
#define LOG_PREFIX "input/csv"
uint64_t samplerate;
/* Number of channels. */
- gsize num_channels;
+ unsigned int num_channels;
/* Column delimiter character(s). */
GString *delimiter;
gboolean multi_column_mode;
/* Column number of the sample data in single column mode. */
- gsize single_column;
+ unsigned int single_column;
/*
* Number of the first column to parse. Equivalent to the number of the
* first channel in multi column mode and the single column number in
* single column mode.
*/
- gsize first_column;
+ unsigned int first_column;
/*
* Column number of the first channel in multi column mode and position of
* the bit for the first channel in single column mode.
*/
- gsize first_channel;
+ unsigned int first_channel;
/* Line number to start processing. */
- gsize start_line;
+ size_t start_line;
/*
* Determines if the first line should be treated as header and used for
int format;
/* Size of the sample buffer. */
- gsize sample_buffer_size;
+ size_t sample_buffer_size;
/* Buffer to store sample data. */
uint8_t *sample_buffer;
/* Current line number. */
- gsize line_number;
+ size_t line_number;
};
-static int format_match(GHashTable *metadata)
-{
- char *buf;
-
- buf = g_hash_table_lookup(metadata, GINT_TO_POINTER(SR_INPUT_META_MIMETYPE));
- if (!strcmp(buf, "text/csv"))
- return TRUE;
-
- return FALSE;
-}
-
static void strip_comment(char *buf, const GString *prefix)
{
char *ptr;
length = strlen(str);
if (!length) {
- sr_err("Column %zu in line %zu is empty.", inc->single_column,
+ sr_err("Column %u in line %zu is empty.", inc->single_column,
inc->line_number);
return SR_ERR;
}
if (str[length - i - 1] == '1') {
inc->sample_buffer[j / 8] |= (1 << (j % 8));
} else if (str[length - i - 1] != '0') {
- sr_err("Invalid value '%s' in column %zu in line %zu.",
+ sr_err("Invalid value '%s' in column %u in line %zu.",
str, inc->single_column, inc->line_number);
return SR_ERR;
}
length = strlen(str);
if (!length) {
- sr_err("Column %zu in line %zu is empty.", inc->single_column,
+ sr_err("Column %u in line %zu is empty.", inc->single_column,
inc->line_number);
return SR_ERR;
}
c = str[length - i - 1];
if (!g_ascii_isxdigit(c)) {
- sr_err("Invalid value '%s' in column %zu in line %zu.",
+ sr_err("Invalid value '%s' in column %u in line %zu.",
str, inc->single_column, inc->line_number);
return SR_ERR;
}
length = strlen(str);
if (!length) {
- sr_err("Column %zu in line %zu is empty.", inc->single_column,
+ sr_err("Column %u in line %zu is empty.", inc->single_column,
inc->line_number);
return SR_ERR;
}
c = str[length - i - 1];
if (c < '0' || c > '7') {
- sr_err("Invalid value '%s' in column %zu in line %zu.",
+ sr_err("Invalid value '%s' in column %u in line %zu.",
str, inc->single_column, inc->line_number);
return SR_ERR;
}
res = SR_ERR;
- switch(inc->format) {
+ switch (inc->format) {
case FORMAT_BIN:
res = parse_binstr(column, inc);
break;
struct context *inc;
const char *s;
- in->sdi = sr_dev_inst_new(0, SR_ST_ACTIVE, NULL, NULL, NULL);
+ in->sdi = g_malloc0(sizeof(struct sr_dev_inst));
in->priv = inc = g_malloc0(sizeof(struct context));
inc->single_column = g_variant_get_int32(g_hash_table_lookup(options, "single-column"));
g_string_truncate(inc->comment, 0);
}
- s = g_variant_get_string(g_hash_table_lookup(options, "samplerate"), NULL);
- if (sr_parse_sizestring(s, &inc->samplerate) != SR_OK) {
- sr_err("Invalid samplerate '%s'.", s);
- return SR_ERR_ARG;
- }
+ inc->samplerate = g_variant_get_uint64(g_hash_table_lookup(options, "samplerate"));
inc->first_channel = g_variant_get_int32(g_hash_table_lookup(options, "first-channel"));
inc->start_line = g_variant_get_int32(g_hash_table_lookup(options, "startline"));
if (inc->start_line < 1) {
- sr_err("Invalid start line %d.", inc->start_line);
+ sr_err("Invalid start line %zu.", inc->start_line);
return SR_ERR_ARG;
}
return SR_OK;
}
-static char *get_line_termination(GString *buf)
+static const char *get_line_termination(GString *buf)
{
- char *term;
+ const char *term;
term = NULL;
if (g_strstr_len(buf->str, buf->len, "\r\n"))
static int initial_parse(const struct sr_input *in, GString *buf)
{
struct context *inc;
- struct sr_channel *ch;
GString *channel_name;
- gsize num_columns, l, i;
- unsigned int line_number;
+ unsigned int num_columns, i;
+ size_t line_number, l;
int ret;
char **lines, **columns;
}
if (!lines[l]) {
/* Not enough data for a proper line yet. */
- ret = SR_OK_CONTINUE;
+ ret = SR_ERR_NA;
goto out;
}
/* Ensure that the first column is not out of bounds. */
if (!num_columns) {
- sr_err("Column %zu in line %zu is out of bounds.",
+ sr_err("Column %u in line %zu is out of bounds.",
inc->first_column, line_number);
ret = SR_ERR;
goto out;
*/
if (!inc->num_channels) {
inc->num_channels = num_columns;
- sr_dbg("Number of auto-detected channels: %zu.",
+ sr_dbg("Number of auto-detected channels: %u.",
inc->num_channels);
}
channel_name = g_string_sized_new(64);
for (i = 0; i < inc->num_channels; i++) {
- if (inc->header && inc->multi_column_mode && strlen(columns[i]))
+ if (inc->header && inc->multi_column_mode && columns[i][0] != '\0')
g_string_assign(channel_name, columns[i]);
else
- g_string_printf(channel_name, "%lu", i);
- ch = sr_channel_new(i, SR_CHANNEL_LOGIC, TRUE, channel_name->str);
- in->sdi->channels = g_slist_append(in->sdi->channels, ch);
+ g_string_printf(channel_name, "%u", i);
+ sr_channel_new(in->sdi, i, SR_CHANNEL_LOGIC, TRUE, channel_name->str);
}
g_string_free(channel_name, TRUE);
struct context *inc;
GString *new_buf;
int len, ret;
- char *termination, *p;
+ char *p;
+ const char *termination;
inc = in->priv;
if (!(termination = get_line_termination(in->buf)))
/* Don't have a full line yet. */
- return SR_OK_CONTINUE;
+ return SR_ERR_NA;
if (!(p = g_strrstr_len(in->buf->str, in->buf->len, termination)))
/* Don't have a full line yet. */
- return SR_OK_CONTINUE;
+ return SR_ERR_NA;
len = p - in->buf->str - 1;
new_buf = g_string_new_len(in->buf->str, len);
g_string_append_c(new_buf, '\0');
return ret;
}
-static int receive(const struct sr_input *in, GString *buf)
+static int process_buffer(struct sr_input *in)
{
struct sr_datafeed_packet packet;
struct sr_datafeed_meta meta;
int max_columns, ret, l;
char *p, **lines, **columns;
- g_string_append_len(in->buf, buf->str, buf->len);
-
inc = in->priv;
- if (!inc->termination) {
- ret = initial_receive(in);
- if (ret == SR_OK_CONTINUE)
- /* Not enough data yet. */
- return SR_OK_CONTINUE;
- else if (ret != SR_OK)
- return SR_ERR;
-
- inc->started = TRUE;
+ if (!inc->started) {
std_session_send_df_header(in->sdi, LOG_PREFIX);
if (inc->samplerate) {
src = sr_config_new(SR_CONF_SAMPLERATE, g_variant_new_uint64(samplerate));
meta.config = g_slist_append(NULL, src);
sr_session_send(in->sdi, &packet);
+ g_slist_free(meta.config);
sr_config_free(src);
}
+
+ inc->started = TRUE;
}
if (!(p = g_strrstr_len(in->buf->str, in->buf->len, inc->termination)))
else
max_columns = 1;
+ ret = SR_OK;
lines = g_strsplit_set(in->buf->str, "\r\n", 0);
for (l = 0; lines[l]; l++) {
inc->line_number++;
continue;
}
+ /* Skip the header line, its content was used as the channel names. */
+ if (inc->header) {
+ sr_spew("Header line %zu skipped.", inc->line_number);
+ inc->header = FALSE;
+ continue;
+ }
+
if (!(columns = parse_line(lines[l], inc, max_columns))) {
sr_err("Error while parsing line %zu.", inc->line_number);
return SR_ERR;
}
num_columns = g_strv_length(columns);
if (!num_columns) {
- sr_err("Column %zu in line %zu is out of bounds.",
+ sr_err("Column %u in line %zu is out of bounds.",
inc->first_column, inc->line_number);
g_strfreev(columns);
return SR_ERR;
g_strfreev(lines);
g_string_erase(in->buf, 0, p - in->buf->str + 1);
- return SR_OK;
+ return ret;
}
-static int cleanup(struct sr_input *in)
+static int receive(struct sr_input *in, GString *buf)
{
struct context *inc;
- struct sr_datafeed_packet packet;
+ int ret;
+
+ g_string_append_len(in->buf, buf->str, buf->len);
inc = in->priv;
- if (!inc)
+ if (!inc->termination) {
+ if ((ret = initial_receive(in)) == SR_ERR_NA)
+ /* Not enough data yet. */
+ return SR_OK;
+ else if (ret != SR_OK)
+ return SR_ERR;
+
+ /* sdi is ready, notify frontend. */
+ in->sdi_ready = TRUE;
return SR_OK;
+ }
+
+ ret = process_buffer(in);
+
+ return ret;
+}
+
+static int end(struct sr_input *in)
+{
+ struct context *inc;
+ struct sr_datafeed_packet packet;
+ int ret;
+
+ if (in->sdi_ready)
+ ret = process_buffer(in);
+ else
+ ret = SR_OK;
+ inc = in->priv;
if (inc->started) {
/* End of stream. */
packet.type = SR_DF_END;
sr_session_send(in->sdi, &packet);
}
+ return ret;
+}
+
+static void cleanup(struct sr_input *in)
+{
+ struct context *inc;
+
+ inc = in->priv;
+
if (inc->delimiter)
g_string_free(inc->delimiter, TRUE);
if (inc->comment)
g_string_free(inc->comment, TRUE);
- if (inc->termination)
- g_free(inc->termination);
-
- if (inc->sample_buffer)
- g_free(inc->sample_buffer);
-
- g_free(inc);
- in->priv = NULL;
-
- return SR_OK;
+ g_free(inc->termination);
+ g_free(inc->sample_buffer);
}
static struct sr_option options[] = {
{ "first-channel", "First channel", "Column number of first channel", NULL, NULL },
{ "header", "Header", "Treat first line as header with channel names", NULL, NULL },
{ "startline", "Start line", "Line number at which to start processing samples", NULL, NULL },
- { 0 }
+ ALL_ZERO
};
-static struct sr_option *get_options(void)
+static const struct sr_option *get_options(void)
{
if (!options[0].def) {
options[0].def = g_variant_ref_sink(g_variant_new_int32(0));
options[2].def = g_variant_ref_sink(g_variant_new_string(","));
options[3].def = g_variant_ref_sink(g_variant_new_string("bin"));
options[4].def = g_variant_ref_sink(g_variant_new_string(";"));
- options[5].def = g_variant_ref_sink(g_variant_new_string("0"));
+ options[5].def = g_variant_ref_sink(g_variant_new_uint64(0));
options[6].def = g_variant_ref_sink(g_variant_new_int32(0));
options[7].def = g_variant_ref_sink(g_variant_new_boolean(FALSE));
options[8].def = g_variant_ref_sink(g_variant_new_int32(1));
.id = "csv",
.name = "CSV",
.desc = "Comma-separated values",
- .metadata = { SR_INPUT_META_MIMETYPE },
+ .exts = (const char*[]){"csv", NULL},
.options = get_options,
- .format_match = format_match,
.init = init,
.receive = receive,
+ .end = end,
.cleanup = cleanup,
};