* than 0. The default line number to start processing is 1.
*/
+/*
+ * 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.
+ */
+
/* Single column formats. */
enum {
FORMAT_BIN,
return SR_OK;
}
+static const char *delim_set = "\r\n";
+
static const char *get_line_termination(GString *buf)
{
const char *term;
columns = NULL;
line_number = 0;
- lines = g_strsplit_set(buf->str, "\r\n", 0);
+ lines = g_strsplit_set(buf->str, delim_set, 0);
for (l = 0; lines[l]; l++) {
line_number++;
line = lines[l];
return ret;
}
+/*
+ * Gets called from initial_receive(), which runs until the end-of-line
+ * encoding of the input stream could get determined. Assumes that this
+ * routine receives enough buffered initial input data to either see the
+ * BOM when there is one, or that no BOM will follow when a text line
+ * termination sequence was seen. Silently drops the UTF-8 BOM sequence
+ * from the input buffer if one was seen. Does not care to protect
+ * against multiple execution or dropping the BOM multiple times --
+ * there should be at most one in the input stream.
+ */
+static void initial_bom_check(const struct sr_input *in)
+{
+ static const char *utf8_bom = "\xef\xbb\xbf";
+
+ if (in->buf->len < strlen(utf8_bom))
+ return;
+ if (strncmp(in->buf->str, utf8_bom, strlen(utf8_bom)) != 0)
+ return;
+ g_string_erase(in->buf, 0, strlen(utf8_bom));
+}
+
static int initial_receive(const struct sr_input *in)
{
struct context *inc;
char *p;
const char *termination;
+ initial_bom_check(in);
+
inc = in->priv;
termination = get_line_termination(in->buf);
return ret;
}
-static int process_buffer(struct sr_input *in)
+static int process_buffer(struct sr_input *in, gboolean is_eof)
{
struct sr_datafeed_packet packet;
struct sr_datafeed_meta meta;
inc->started = TRUE;
}
- p = g_strrstr_len(in->buf->str, in->buf->len, inc->termination);
- if (!p)
- /* Don't have a full line. */
- return SR_ERR;
-
- *p = '\0';
- g_strstrip(in->buf->str);
-
/* Limit the number of columns to parse. */
if (inc->multi_column_mode)
max_columns = inc->num_channels;
else
max_columns = 1;
+ /*
+ * Consider empty input non-fatal. Keep accumulating input until
+ * at least one full text line has become available. Grab the
+ * maximum amount of accumulated data that consists of full text
+ * lines, and process what has been received so far, leaving not
+ * yet complete lines for the next invocation.
+ *
+ * Enforce that all previously buffered data gets processed in
+ * the "EOF" condition. Do not insist in the presence of the
+ * termination sequence for the last line (may often be missing
+ * on Windows). A present termination sequence will just result
+ * in the "execution of an empty line", and does not harm.
+ */
+ if (!in->buf->len)
+ return SR_OK;
+ if (is_eof) {
+ p = in->buf->str + in->buf->len;
+ } else {
+ p = g_strrstr_len(in->buf->str, in->buf->len, inc->termination);
+ if (!p)
+ return SR_ERR;
+ *p = '\0';
+ p += strlen(inc->termination);
+ }
+ g_strstrip(in->buf->str);
+
ret = SR_OK;
- lines = g_strsplit_set(in->buf->str, "\r\n", 0);
+ lines = g_strsplit_set(in->buf->str, delim_set, 0);
for (l = 0; lines[l]; l++) {
inc->line_number++;
line = lines[l];
g_strfreev(columns);
}
g_strfreev(lines);
- g_string_erase(in->buf, 0, p - in->buf->str + 1);
+ g_string_erase(in->buf, 0, p - in->buf->str);
return ret;
}
return SR_OK;
}
- ret = process_buffer(in);
+ ret = process_buffer(in, FALSE);
return ret;
}
int ret;
if (in->sdi_ready)
- ret = process_buffer(in);
+ ret = process_buffer(in, TRUE);
else
ret = SR_OK;