X-Git-Url: https://sigrok.org/gitweb/?p=sigrok-cli.git;a=blobdiff_plain;f=parsers.c;h=7f0d227a61b89eb97ff8b941735a0762cdefa02b;hp=d6642b351e47372e705bfa883f84d45a6079a3c3;hb=7c6a0420448760fc138cbe38579a5c9e0a46132c;hpb=96e7e071c6ebe939166c1fc7c11e9f5528ef4288 diff --git a/parsers.c b/parsers.c index d6642b3..7f0d227 100644 --- a/parsers.c +++ b/parsers.c @@ -1,5 +1,5 @@ /* - * This file is part of the sigrok project. + * This file is part of the sigrok-cli project. * * Copyright (C) 2011 Bert Vermeulen * @@ -17,88 +17,248 @@ * along with this program. If not, see . */ +#include "sigrok-cli.h" #include #include #include #include #include -#include -#include "sigrok-cli.h" -char **parse_probestring(int max_probes, const char *probestring) +struct sr_channel *find_channel(GSList *channellist, const char *channelname) { - int tmp, b, e, i; - char **tokens, **range, **probelist, *name, str[8]; - gboolean error; + struct sr_channel *ch; + GSList *l; - error = FALSE; - range = NULL; - if (!(probelist = g_try_malloc0(max_probes * sizeof(char *)))) { - /* TODO: Handle errors. */ + ch = NULL; + for (l = channellist; l; l = l->next) { + ch = l->data; + if (!strcmp(ch->name, channelname)) + break; } - tokens = g_strsplit(probestring, ",", max_probes); + ch = l ? l->data : NULL; + + return ch; +} + +GSList *parse_channelstring(struct sr_dev_inst *sdi, const char *channelstring) +{ + struct sr_channel *ch; + GSList *channellist; + int ret, n, b, e, i; + char **tokens, **range, **names, *eptr, str[8]; + + if (!channelstring || !channelstring[0]) + /* Use all channels by default. */ + return g_slist_copy(sdi->channels); + ret = SR_OK; + range = NULL; + names = NULL; + channellist = NULL; + tokens = g_strsplit(channelstring, ",", 0); for (i = 0; tokens[i]; i++) { + if (tokens[i][0] == '\0') { + g_critical("Invalid empty channel."); + ret = SR_ERR; + break; + } if (strchr(tokens[i], '-')) { - /* A range of probes in the form 1-5. */ + /* A range of channels in the form a-b. This will only work + * if the channels are named as numbers -- so every channel + * in the range must exist as a channel name string in the + * device. */ range = g_strsplit(tokens[i], "-", 2); if (!range[0] || !range[1] || range[2]) { /* Need exactly two arguments. */ - printf("Invalid probe syntax '%s'.\n", - tokens[i]); - error = TRUE; - break; + g_critical("Invalid channel syntax '%s'.", tokens[i]); + ret = SR_ERR; + goto range_fail; } - b = strtol(range[0], NULL, 10); + b = strtol(range[0], &eptr, 10); + if (eptr == range[0] || *eptr != '\0') { + g_critical("Invalid channel '%s'.", range[0]); + ret = SR_ERR; + goto range_fail; + } e = strtol(range[1], NULL, 10); - if (b < 1 || e > max_probes || b >= e) { - printf("Invalid probe range '%s'.\n", - tokens[i]); - error = TRUE; - break; + if (eptr == range[1] || *eptr != '\0') { + g_critical("Invalid channel '%s'.", range[1]); + ret = SR_ERR; + goto range_fail; + } + if (b < 0 || b >= e) { + g_critical("Invalid channel range '%s'.", tokens[i]); + ret = SR_ERR; + goto range_fail; } while (b <= e) { - snprintf(str, 7, "%d", b); - probelist[b - 1] = g_strdup(str); + n = snprintf(str, 8, "%d", b); + if (n < 0 || n > 8) { + g_critical("Invalid channel '%d'.", b); + ret = SR_ERR; + break; + } + ch = find_channel(sdi->channels, str); + if (!ch) { + g_critical("unknown channel '%d'.", b); + ret = SR_ERR; + break; + } + channellist = g_slist_append(channellist, ch); b++; } +range_fail: + if (range) + g_strfreev(range); + + if (ret != SR_OK) + break; } else { - tmp = strtol(tokens[i], NULL, 10); - if (tmp < 1 || tmp > max_probes) { - printf("Invalid probe %d.\n", tmp); - error = TRUE; + names = g_strsplit(tokens[i], "=", 2); + if (!names[0] || (names[1] && names[2])) { + /* Need one or two arguments. */ + g_critical("Invalid channel '%s'.", tokens[i]); + g_strfreev(names); + ret = SR_ERR; break; } - if ((name = strchr(tokens[i], '='))) { - probelist[tmp - 1] = g_strdup(++name); - if (strlen(probelist[tmp - 1]) > SR_MAX_PROBENAME_LEN) - probelist[tmp - 1][SR_MAX_PROBENAME_LEN] = 0; - } else { - snprintf(str, 7, "%d", tmp); - probelist[tmp - 1] = g_strdup(str); + ch = find_channel(sdi->channels, names[0]); + if (!ch) { + g_critical("unknown channel '%s'.", names[0]); + g_strfreev(names); + ret = SR_ERR; + break; + } + if (names[1]) { + /* Rename channel. */ + g_free(ch->name); + ch->name = g_strdup(names[1]); } + channellist = g_slist_append(channellist, ch); + + g_strfreev(names); } } - if (error) { - for (i = 0; i < max_probes; i++) - if (probelist[i]) - g_free(probelist[i]); - g_free(probelist); - probelist = NULL; + if (ret != SR_OK) { + g_slist_free(channellist); + channellist = NULL; } g_strfreev(tokens); - if (range) - g_strfreev(range); - return probelist; + return channellist; +} + +int parse_trigger_match(char c) +{ + int match; + + if (c == '0') + match = SR_TRIGGER_ZERO; + else if (c == '1') + match = SR_TRIGGER_ONE; + else if (c == 'r') + match = SR_TRIGGER_RISING; + else if (c == 'f') + match = SR_TRIGGER_FALLING; + else if (c == 'e') + match = SR_TRIGGER_EDGE; + else if (c == 'o') + match = SR_TRIGGER_OVER; + else if (c == 'u') + match = SR_TRIGGER_UNDER; + else + match = 0; + + return match; } -GHashTable *parse_generic_arg(const char *arg) +int parse_triggerstring(const struct sr_dev_inst *sdi, const char *s, + struct sr_trigger **trigger) +{ + struct sr_channel *ch; + struct sr_trigger_stage *stage; + GVariant *gvar; + GSList *l; + gsize num_matches; + gboolean found_match, error; + const int32_t *matches; + int32_t match; + unsigned int j; + int t, i; + char **tokens, *sep; + + if (sr_config_list(sdi->driver, sdi, NULL, SR_CONF_TRIGGER_MATCH, + &gvar) != SR_OK) { + g_critical("Device doesn't support any triggers."); + return FALSE; + } + matches = g_variant_get_fixed_array(gvar, &num_matches, sizeof(int32_t)); + + *trigger = sr_trigger_new(NULL); + error = FALSE; + tokens = g_strsplit(s, ",", -1); + for (i = 0; tokens[i]; i++) { + if (!(sep = strchr(tokens[i], '='))) { + g_critical("Invalid trigger '%s'.", tokens[i]); + error = TRUE; + break; + } + *sep++ = 0; + ch = NULL; + for (l = sdi->channels; l; l = l->next) { + ch = l->data; + if (ch->enabled && !strcmp(ch->name, tokens[i])) + break; + ch = NULL; + } + if (!ch) { + g_critical("Invalid channel '%s'.", tokens[i]); + error = TRUE; + break; + } + for (t = 0; sep[t]; t++) { + if (!(match = parse_trigger_match(sep[t]))) { + g_critical("Invalid trigger match '%c'.", sep[t]); + error = TRUE; + break; + } + found_match = FALSE; + for (j = 0; j < num_matches; j++) { + if (matches[j] == match) { + found_match = TRUE; + break; + } + } + if (!found_match) { + g_critical("Trigger match '%c' not supported by device.", sep[t]); + error = TRUE; + break; + } + /* Make sure this ends up in the right stage, creating + * them as needed. */ + while (!(stage = g_slist_nth_data((*trigger)->stages, t))) + sr_trigger_stage_add(*trigger); + if (sr_trigger_match_add(stage, ch, match, 0) != SR_OK) { + error = TRUE; + break; + } + } + } + g_strfreev(tokens); + g_variant_unref(gvar); + + if (error) + sr_trigger_free(*trigger); + + return !error; +} + +GHashTable *parse_generic_arg(const char *arg, gboolean sep_first) { GHashTable *hash; int i; @@ -107,10 +267,14 @@ GHashTable *parse_generic_arg(const char *arg) if (!arg || !arg[0]) return NULL; - hash = g_hash_table_new_full(g_str_hash, g_str_equal, g_free, g_free); + i = 0; + hash = g_hash_table_new_full(g_str_hash, g_str_equal, + g_free, g_free); elements = g_strsplit(arg, ":", 0); - g_hash_table_insert(hash, g_strdup("sigrok_key"), g_strdup(elements[0])); - for (i = 1; elements[i]; i++) { + if (sep_first) + g_hash_table_insert(hash, g_strdup("sigrok_key"), + g_strdup(elements[i++])); + for (; elements[i]; i++) { e = strchr(elements[i], '='); if (!e) g_hash_table_insert(hash, g_strdup(elements[i]), NULL); @@ -124,63 +288,33 @@ GHashTable *parse_generic_arg(const char *arg) return hash; } -struct sr_device *parse_devicestring(const char *devicestring) +static char *strcanon(const char *str) { - struct sr_device *device, *d; - struct sr_device_plugin *plugin; - GSList *devices, *plugins, *l, *p; - int num_devices, device_num, device_cnt; - char *tmp; + int p0, p1; + char *s; - if (!devicestring) - return NULL; - - device = NULL; - device_num = strtol(devicestring, &tmp, 10); - if (tmp != devicestring) { - /* argument is numeric, meaning a device ID. Make all driver - * plugins scan for devices. - */ - num_devices = num_real_devices(); - if (device_num < 0 || device_num >= num_devices) - return NULL; - - device_cnt = 0; - devices = sr_dev_list(); - for (l = devices; l; l = l->next) { - d = l->data; - if (sr_dev_has_hwcap(d, SR_HWCAP_DEMO_DEVICE)) - continue; - if (device_cnt == device_num) { - if (device_num == device_cnt) { - device = d; - break; - } - } - device_cnt++; - } - } else { - /* select device by driver -- only initialize that driver, - * no need to let them all scan - */ - device = NULL; - plugins = sr_list_hwplugins(); - for (p = plugins; p; p = p->next) { - plugin = p->data; - if (strcmp(plugin->name, devicestring)) - continue; - num_devices = sr_init_hwplugin(plugin); - if (num_devices == 1) { - devices = sr_dev_list(); - device = devices->data; - } else if (num_devices > 1) { - printf("driver '%s' found %d devices, select by ID instead.\n", - devicestring, num_devices); - } - /* fall through: selected driver found no devices */ - break; - } + /* Returns newly allocated string. */ + s = g_ascii_strdown(str, -1); + for (p0 = p1 = 0; str[p0]; p0++) { + if ((s[p0] >= 'a' && s[p0] <= 'z') + || (s[p0] >= '0' && s[p0] <= '9')) + s[p1++] = s[p0]; } + s[p1] = '\0'; + + return s; +} + +int canon_cmp(const char *str1, const char *str2) +{ + int ret; + char *s1, *s2; + + s1 = strcanon(str1); + s2 = strcanon(str2); + ret = g_ascii_strcasecmp(s1, s2); + g_free(s2); + g_free(s1); - return device; + return ret; }