parsers.c

   1 /*
   2  * This file is part of the sigrok-cli project.
   3  *
   4  * Copyright (C) 2011 Bert Vermeulen <bert@biot.com>
   5  *
   6  * This program is free software: you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License as published by
   8  * the Free Software Foundation, either version 3 of the License, or
   9  * (at your option) any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  18  */
  19
  20 #include <config.h>
  21 #include <stdio.h>
  22 #include <stdlib.h>
  23 #include <stdint.h>
  24 #include <string.h>
  25 #include <glib.h>
  26 #include "sigrok-cli.h"
  27
  28 struct sr_channel *find_channel(GSList *channellist, const char *channelname)
  29 {
  30         struct sr_channel *ch;
  31         GSList *l;
  32
  33         ch = NULL;
  34         for (l = channellist; l; l = l->next) {
  35                 ch = l->data;
  36                 if (!strcmp(ch->name, channelname))
  37                         break;
  38         }
  39         ch = l ? l->data : NULL;
  40
  41         return ch;
  42 }
  43
  44 GSList *parse_channelstring(struct sr_dev_inst *sdi, const char *channelstring)
  45 {
  46         struct sr_channel *ch;
  47         GSList *channellist, *channels;
  48         int ret, n, b, e, i;
  49         char **tokens, **range, **names, *eptr, str[8];
  50
  51         channels = sr_dev_inst_channels_get(sdi);
  52
  53         if (!channelstring || !channelstring[0])
  54                 /* Use all channels by default. */
  55                 return g_slist_copy(channels);
  56
  57         ret = SR_OK;
  58         range = NULL;
  59         names = NULL;
  60         channellist = NULL;
  61         tokens = g_strsplit(channelstring, ",", 0);
  62         for (i = 0; tokens[i]; i++) {
  63                 if (tokens[i][0] == '\0') {
  64                         g_critical("Invalid empty channel.");
  65                         ret = SR_ERR;
  66                         break;
  67                 }
  68                 if (strchr(tokens[i], '-')) {
  69                         /*
  70                          * A range of channels in the form a-b. This will only work
  71                          * if the channels are named as numbers -- so every channel
  72                          * in the range must exist as a channel name string in the
  73                          * device.
  74                          */
  75                         range = g_strsplit(tokens[i], "-", 2);
  76                         if (!range[0] || !range[1] || range[2]) {
  77                                 /* Need exactly two arguments. */
  78                                 g_critical("Invalid channel syntax '%s'.", tokens[i]);
  79                                 ret = SR_ERR;
  80                                 goto range_fail;
  81                         }
  82
  83                         b = strtol(range[0], &eptr, 10);
  84                         if (eptr == range[0] || *eptr != '\0') {
  85                                 g_critical("Invalid channel '%s'.", range[0]);
  86                                 ret = SR_ERR;
  87                                 goto range_fail;
  88                         }
  89                         e = strtol(range[1], NULL, 10);
  90                         if (eptr == range[1] || *eptr != '\0') {
  91                                 g_critical("Invalid channel '%s'.", range[1]);
  92                                 ret = SR_ERR;
  93                                 goto range_fail;
  94                         }
  95                         if (b < 0 || b >= e) {
  96                                 g_critical("Invalid channel range '%s'.", tokens[i]);
  97                                 ret = SR_ERR;
  98                                 goto range_fail;
  99                         }
 100
 101                         while (b <= e) {
 102                                 n = snprintf(str, 8, "%d", b);
 103                                 if (n < 0 || n > 8) {
 104                                         g_critical("Invalid channel '%d'.", b);
 105                                         ret = SR_ERR;
 106                                         break;
 107                                 }
 108                                 ch = find_channel(channels, str);
 109                                 if (!ch) {
 110                                         g_critical("unknown channel '%d'.", b);
 111                                         ret = SR_ERR;
 112                                         break;
 113                                 }
 114                                 channellist = g_slist_append(channellist, ch);
 115                                 b++;
 116                         }
 117 range_fail:
 118                         if (range)
 119                                 g_strfreev(range);
 120
 121                         if (ret != SR_OK)
 122                                 break;
 123                 } else {
 124                         names = g_strsplit(tokens[i], "=", 2);
 125                         if (!names[0] || (names[1] && names[2])) {
 126                                 /* Need one or two arguments. */
 127                                 g_critical("Invalid channel '%s'.", tokens[i]);
 128                                 g_strfreev(names);
 129                                 ret = SR_ERR;
 130                                 break;
 131                         }
 132
 133                         ch = find_channel(channels, names[0]);
 134                         if (!ch) {
 135                                 g_critical("unknown channel '%s'.", names[0]);
 136                                 g_strfreev(names);
 137                                 ret = SR_ERR;
 138                                 break;
 139                         }
 140                         if (names[1]) {
 141                                 /* Rename channel. */
 142                                 g_free(ch->name);
 143                                 ch->name = g_strdup(names[1]);
 144                         }
 145                         channellist = g_slist_append(channellist, ch);
 146
 147                         g_strfreev(names);
 148                 }
 149         }
 150
 151         if (ret != SR_OK) {
 152                 g_slist_free(channellist);
 153                 channellist = NULL;
 154         }
 155
 156         g_strfreev(tokens);
 157
 158         return channellist;
 159 }
 160
 161 int parse_trigger_match(char c)
 162 {
 163         int match;
 164
 165         if (c == '0')
 166                 match = SR_TRIGGER_ZERO;
 167         else if (c == '1')
 168                 match = SR_TRIGGER_ONE;
 169         else if (c == 'r')
 170                 match = SR_TRIGGER_RISING;
 171         else if (c == 'f')
 172                 match = SR_TRIGGER_FALLING;
 173         else if (c == 'e')
 174                 match = SR_TRIGGER_EDGE;
 175         else if (c == 'o')
 176                 match = SR_TRIGGER_OVER;
 177         else if (c == 'u')
 178                 match = SR_TRIGGER_UNDER;
 179         else
 180                 match = 0;
 181
 182         return match;
 183 }
 184
 185 int parse_triggerstring(const struct sr_dev_inst *sdi, const char *s,
 186                 struct sr_trigger **trigger)
 187 {
 188         struct sr_channel *ch;
 189         struct sr_trigger_stage *stage;
 190         GVariant *gvar;
 191         GSList *l, *channels;
 192         gsize num_matches;
 193         gboolean found_match, error;
 194         const int32_t *matches;
 195         int32_t match;
 196         unsigned int j;
 197         int t, i;
 198         char **tokens, *sep;
 199         struct sr_dev_driver *driver;
 200
 201         driver = sr_dev_inst_driver_get(sdi);
 202         channels = sr_dev_inst_channels_get(sdi);
 203
 204         if (maybe_config_list(driver, sdi, NULL, SR_CONF_TRIGGER_MATCH,
 205                         &gvar) != SR_OK) {
 206                 g_critical("Device doesn't support any triggers.");
 207                 return FALSE;
 208         }
 209         matches = g_variant_get_fixed_array(gvar, &num_matches, sizeof(int32_t));
 210
 211         *trigger = sr_trigger_new(NULL);
 212         error = FALSE;
 213         tokens = g_strsplit(s, ",", -1);
 214         for (i = 0; tokens[i]; i++) {
 215                 if (!(sep = strchr(tokens[i], '='))) {
 216                         g_critical("Invalid trigger '%s'.", tokens[i]);
 217                         error = TRUE;
 218                         break;
 219                 }
 220                 *sep++ = 0;
 221                 ch = NULL;
 222                 for (l = channels; l; l = l->next) {
 223                         ch = l->data;
 224                         if (ch->enabled && !strcmp(ch->name, tokens[i]))
 225                                 break;
 226                         ch = NULL;
 227                 }
 228                 if (!ch) {
 229                         g_critical("Invalid channel '%s'.", tokens[i]);
 230                         error = TRUE;
 231                         break;
 232                 }
 233                 for (t = 0; sep[t]; t++) {
 234                         if (!(match = parse_trigger_match(sep[t]))) {
 235                                 g_critical("Invalid trigger match '%c'.", sep[t]);
 236                                 error = TRUE;
 237                                 break;
 238                         }
 239                         found_match = FALSE;
 240                         for (j = 0; j < num_matches; j++) {
 241                                 if (matches[j] == match) {
 242                                         found_match = TRUE;
 243                                         break;
 244                                 }
 245                         }
 246                         if (!found_match) {
 247                                 g_critical("Trigger match '%c' not supported by device.", sep[t]);
 248                                 error = TRUE;
 249                                 break;
 250                         }
 251                         /* Make sure this ends up in the right stage, creating
 252                          * them as needed. */
 253                         while (!(stage = g_slist_nth_data((*trigger)->stages, t)))
 254                                 sr_trigger_stage_add(*trigger);
 255                         if (sr_trigger_match_add(stage, ch, match, 0) != SR_OK) {
 256                                 error = TRUE;
 257                                 break;
 258                         }
 259                 }
 260         }
 261         g_strfreev(tokens);
 262         g_variant_unref(gvar);
 263
 264         if (error)
 265                 sr_trigger_free(*trigger);
 266
 267         return !error;
 268 }
 269
 270 /**
 271  * Create hash table from colon separated key-value pairs input text.
 272  *
 273  * Accepts input text as it was specified by users. Splits the colon
 274  * separated key-value pairs and creates a hash table from these items.
 275  * Optionally supports special forms which are useful for different CLI
 276  * features.
 277  *
 278  * Typical form: <key>=<val>[:<key>=<val>]*
 279  * Generic list of key-value pairs, all items being equal. Mere set.
 280  *
 281  * ID form: <id>[:<key>=<val>]*
 282  * First item is not a key-value pair, instead it's an identifier. Used
 283  * to specify a protocol decoder, or a device driver, or an input/output
 284  * file format, optionally followed by more parameters' values. The ID
 285  * part of the input spec is not optional.
 286  *
 287  * Optional ID: [<sel>=<id>][:<key>=<val>]*
 288  * All items are key-value pairs. The first item _may_ be an identifier,
 289  * if its key matches a caller specified key name. Otherwise the input
 290  * text is the above typical form, a mere list of key-value pairs while
 291  * none of them is special.
 292  *
 293  * @param[in] arg Input text.
 294  * @param[in] sep_first Boolean, whether ID form is required.
 295  * @param[in] key_first Keyword name if optional ID is applicable.
 296  *
 297  * @returns A hash table which contains the key/value pairs, or #NULL
 298  *   when the input is invalid.
 299  */
 300 GHashTable *parse_generic_arg(const char *arg,
 301         gboolean sep_first, const char *key_first)
 302 {
 303         GHashTable *hash;
 304         int i;
 305         char **elements, *e;
 306         int l;
 307         const char *s;
 308
 309         if (!arg || !arg[0])
 310                 return NULL;
 311
 312         i = 0;
 313         hash = g_hash_table_new_full(g_str_hash, g_str_equal,
 314                         g_free, g_free);
 315         elements = g_strsplit(arg, ":", 0);
 316         if (sep_first) {
 317                 /*
 318                  * Caller requested "<id>[:<key>=<val>]*" case, Consume the
 319                  * first item, before processing more key-value pairs below.
 320                  */
 321                 g_hash_table_insert(hash, g_strdup("sigrok_key"),
 322                                 g_strdup(elements[i++]));
 323         } else if (key_first && *key_first) {
 324                 /*
 325                  * Caller requested "[<sig>=<id>][:<key>=<val>]*" case.
 326                  * Optional special handling of the first item, but only
 327                  * consume this first item here when its keyword matched
 328                  * the caller's specification.
 329                  */
 330                 l = strlen(key_first);
 331                 s = elements[i];
 332                 e = strchr(s, '=');
 333                 if (e && e - s == l && g_str_has_prefix(s, key_first)) {
 334                         g_hash_table_insert(hash,
 335                                 g_strdup("sigrok_key"), g_strdup(++e));
 336                         i++;
 337                 }
 338         }
 339         for (; elements[i]; i++) {
 340                 e = strchr(elements[i], '=');
 341                 if (!e)
 342                         g_hash_table_insert(hash, g_strdup(elements[i]), NULL);
 343                 else {
 344                         *e++ = '\0';
 345                         g_hash_table_insert(hash, g_strdup(elements[i]), g_strdup(e));
 346                 }
 347         }
 348         g_strfreev(elements);
 349
 350         return hash;
 351 }
 352
 353 GSList *check_unknown_keys(const struct sr_option **avail, GHashTable *used)
 354 {
 355         GSList *unknown;
 356         GHashTableIter iter;
 357         void *key;
 358         const char *used_id;
 359         size_t avail_idx;
 360         const char *avail_id, *found_id;
 361
 362         /* Collect a list of used but not available keywords. */
 363         unknown = NULL;
 364         g_hash_table_iter_init(&iter, used);
 365         while (g_hash_table_iter_next(&iter, &key, NULL)) {
 366                 used_id = key;
 367                 found_id = NULL;
 368                 for (avail_idx = 0; avail[avail_idx] && avail[avail_idx]->id; avail_idx++) {
 369                         avail_id = avail[avail_idx]->id;
 370                         if (strcmp(avail_id, used_id) == 0) {
 371                                 found_id = avail_id;
 372                                 break;
 373                         }
 374                 }
 375                 if (!found_id)
 376                         unknown = g_slist_append(unknown, g_strdup(used_id));
 377         }
 378
 379         /* Return the list of unknown keywords, or NULL if empty. */
 380         return unknown;
 381 }
 382
 383 gboolean warn_unknown_keys(const struct sr_option **avail, GHashTable *used,
 384         const char *caption)
 385 {
 386         GSList *unknown, *l;
 387         gboolean had_unknown;
 388         const char *s;
 389
 390         if (!caption || !*caption)
 391                 caption = "Unknown keyword";
 392
 393         unknown = check_unknown_keys(avail, used);
 394         had_unknown = unknown != NULL;
 395         for (l = unknown; l; l = l->next) {
 396                 s = l->data;
 397                 g_warning("%s: %s.", caption, s);
 398         }
 399         g_slist_free_full(unknown, g_free);
 400
 401         return had_unknown;
 402 }
 403
 404 GHashTable *generic_arg_to_opt(const struct sr_option **opts, GHashTable *genargs)
 405 {
 406         GHashTable *hash;
 407         GVariant *gvar;
 408         int i;
 409         char *s;
 410         gboolean b;
 411
 412         hash = g_hash_table_new_full(g_str_hash, g_str_equal, g_free,
 413                         (GDestroyNotify)g_variant_unref);
 414         for (i = 0; opts[i]; i++) {
 415                 if (!(s = g_hash_table_lookup(genargs, opts[i]->id)))
 416                         continue;
 417                 if (g_variant_is_of_type(opts[i]->def, G_VARIANT_TYPE_UINT32)) {
 418                         gvar = g_variant_new_uint32(strtoul(s, NULL, 10));
 419                         g_hash_table_insert(hash, g_strdup(opts[i]->id),
 420                                         g_variant_ref_sink(gvar));
 421                 } else if (g_variant_is_of_type(opts[i]->def, G_VARIANT_TYPE_INT32)) {
 422                         gvar = g_variant_new_int32(strtoul(s, NULL, 10));
 423                         g_hash_table_insert(hash, g_strdup(opts[i]->id),
 424                                         g_variant_ref_sink(gvar));
 425                 } else if (g_variant_is_of_type(opts[i]->def, G_VARIANT_TYPE_UINT64)) {
 426                         gvar = g_variant_new_uint64(strtoul(s, NULL, 10));
 427                         g_hash_table_insert(hash, g_strdup(opts[i]->id),
 428                                         g_variant_ref_sink(gvar));
 429                 } else if (g_variant_is_of_type(opts[i]->def, G_VARIANT_TYPE_DOUBLE)) {
 430                         gvar = g_variant_new_double(strtod(s, NULL));
 431                         g_hash_table_insert(hash, g_strdup(opts[i]->id),
 432                                         g_variant_ref_sink(gvar));
 433                 } else if (g_variant_is_of_type(opts[i]->def, G_VARIANT_TYPE_STRING)) {
 434                         gvar = g_variant_new_string(s);
 435                         g_hash_table_insert(hash, g_strdup(opts[i]->id),
 436                                         g_variant_ref_sink(gvar));
 437                 } else if (g_variant_is_of_type(opts[i]->def, G_VARIANT_TYPE_BOOLEAN)) {
 438                         b = TRUE;
 439                         if (0 == strcmp(s, "false") || 0 == strcmp(s, "no")) {
 440                                 b = FALSE;
 441                         } else if (!(0 == strcmp(s, "true") || 0 == strcmp(s, "yes"))) {
 442                                 g_critical("Unable to convert '%s' to boolean!", s);
 443                         }
 444
 445                         gvar = g_variant_new_boolean(b);
 446                         g_hash_table_insert(hash, g_strdup(opts[i]->id),
 447                                         g_variant_ref_sink(gvar));
 448                 } else {
 449                         g_critical("Don't know GVariant type for option '%s'!", opts[i]->id);
 450                  }
 451         }
 452
 453         return hash;
 454 }
 455
 456 static char *strcanon(const char *str)
 457 {
 458         int p0, p1;
 459         char *s;
 460
 461         /* Returns newly allocated string. */
 462         s = g_ascii_strdown(str, -1);
 463         for (p0 = p1 = 0; str[p0]; p0++) {
 464                 if ((s[p0] >= 'a' && s[p0] <= 'z')
 465                                 || (s[p0] >= '0' && s[p0] <= '9'))
 466                         s[p1++] = s[p0];
 467         }
 468         s[p1] = '\0';
 469
 470         return s;
 471 }
 472
 473 int canon_cmp(const char *str1, const char *str2)
 474 {
 475         int ret;
 476         char *s1, *s2;
 477
 478         s1 = strcanon(str1);
 479         s2 = strcanon(str2);
 480         ret = g_ascii_strcasecmp(s1, s2);
 481         g_free(s2);
 482         g_free(s1);
 483
 484         return ret;
 485 }
 486
 487 /* Convert driver options hash to GSList of struct sr_config. */
 488 static GSList *hash_to_hwopt(GHashTable *hash)
 489 {
 490         struct sr_config *src;
 491         GList *gl, *keys;
 492         GSList *opts;
 493         char *key;
 494
 495         keys = g_hash_table_get_keys(hash);
 496         opts = NULL;
 497         for (gl = keys; gl; gl = gl->next) {
 498                 key = gl->data;
 499                 src = g_malloc(sizeof(struct sr_config));
 500                 if (opt_to_gvar(key, g_hash_table_lookup(hash, key), src) != 0)
 501                         return NULL;
 502                 opts = g_slist_append(opts, src);
 503         }
 504         g_list_free(keys);
 505
 506         return opts;
 507 }
 508
 509 int parse_driver(char *arg, struct sr_dev_driver **driver, GSList **drvopts)
 510 {
 511         struct sr_dev_driver **drivers;
 512         GHashTable *drvargs;
 513         int i;
 514         char *drvname;
 515
 516         if (!arg)
 517                 return FALSE;
 518
 519         drvargs = parse_generic_arg(arg, TRUE, NULL);
 520
 521         drvname = g_strdup(g_hash_table_lookup(drvargs, "sigrok_key"));
 522         g_hash_table_remove(drvargs, "sigrok_key");
 523         *driver = NULL;
 524         drivers = sr_driver_list(sr_ctx);
 525         for (i = 0; drivers[i]; i++) {
 526                 if (strcmp(drivers[i]->name, drvname))
 527                         continue;
 528                 *driver = drivers[i];
 529         }
 530         if (!*driver) {
 531                 g_critical("Driver %s not found.", drvname);
 532                 g_hash_table_destroy(drvargs);
 533                 g_free(drvname);
 534                 return FALSE;
 535         }
 536         g_free(drvname);
 537         if (sr_driver_init(sr_ctx, *driver) != SR_OK) {
 538                 g_critical("Failed to initialize driver.");
 539                 g_hash_table_destroy(drvargs);
 540                 return FALSE;
 541         }
 542
 543         if (drvopts) {
 544                 *drvopts = NULL;
 545                 if (g_hash_table_size(drvargs) > 0) {
 546                         if (!(*drvopts = hash_to_hwopt(drvargs))) {
 547                                 /* Unknown options, already logged. */
 548                                 g_hash_table_destroy(drvargs);
 549                                 return FALSE;
 550                         }
 551                 }
 552         }
 553
 554         g_hash_table_destroy(drvargs);
 555
 556         return TRUE;
 557 }