parsers.c

   1 /*
   2  * This file is part of the sigrok 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 <stdio.h>
  21 #include <stdlib.h>
  22 #include <stdint.h>
  23 #include <string.h>
  24 #include <glib.h>
  25 #include <sigrok.h>
  26 #include "sigrok-cli.h"
  27
  28 char **parse_probestring(int max_probes, const char *probestring)
  29 {
  30         int tmp, b, e, i;
  31         char **tokens, **range, **probelist, *name, str[8];
  32         gboolean error;
  33
  34         error = FALSE;
  35         range = NULL;
  36         if (!(probelist = g_try_malloc0(max_probes * sizeof(char *)))) {
  37                 /* TODO: Handle errors. */
  38         }
  39         tokens = g_strsplit(probestring, ",", max_probes);
  40
  41         for (i = 0; tokens[i]; i++) {
  42                 if (strchr(tokens[i], '-')) {
  43                         /* A range of probes in the form 1-5. */
  44                         range = g_strsplit(tokens[i], "-", 2);
  45                         if (!range[0] || !range[1] || range[2]) {
  46                                 /* Need exactly two arguments. */
  47                                 g_critical("Invalid probe syntax '%s'.", tokens[i]);
  48                                 error = TRUE;
  49                                 break;
  50                         }
  51
  52                         b = strtol(range[0], NULL, 10);
  53                         e = strtol(range[1], NULL, 10);
  54                         if (b < 1 || e > max_probes || b >= e) {
  55                                 g_critical("Invalid probe range '%s'.", tokens[i]);
  56                                 error = TRUE;
  57                                 break;
  58                         }
  59
  60                         while (b <= e) {
  61                                 snprintf(str, 7, "%d", b);
  62                                 probelist[b - 1] = g_strdup(str);
  63                                 b++;
  64                         }
  65                 } else {
  66                         tmp = strtol(tokens[i], NULL, 10);
  67                         if (tmp < 1 || tmp > max_probes) {
  68                                 g_critical("Invalid probe %d.", tmp);
  69                                 error = TRUE;
  70                                 break;
  71                         }
  72
  73                         if ((name = strchr(tokens[i], '='))) {
  74                                 probelist[tmp - 1] = g_strdup(++name);
  75                                 if (strlen(probelist[tmp - 1]) > SR_MAX_PROBENAME_LEN)
  76                                         probelist[tmp - 1][SR_MAX_PROBENAME_LEN] = 0;
  77                         } else {
  78                                 snprintf(str, 7, "%d", tmp);
  79                                 probelist[tmp - 1] = g_strdup(str);
  80                         }
  81                 }
  82         }
  83
  84         if (error) {
  85                 for (i = 0; i < max_probes; i++)
  86                         if (probelist[i])
  87                                 g_free(probelist[i]);
  88                 g_free(probelist);
  89                 probelist = NULL;
  90         }
  91
  92         g_strfreev(tokens);
  93         if (range)
  94                 g_strfreev(range);
  95
  96         return probelist;
  97 }
  98
  99 GHashTable *parse_generic_arg(const char *arg)
 100 {
 101         GHashTable *hash;
 102         int i;
 103         char **elements, *e;
 104
 105         if (!arg || !arg[0])
 106                 return NULL;
 107
 108         hash = g_hash_table_new_full(g_str_hash, g_str_equal, g_free, g_free);
 109         elements = g_strsplit(arg, ":", 0);
 110         g_hash_table_insert(hash, g_strdup("sigrok_key"), g_strdup(elements[0]));
 111         for (i = 1; elements[i]; i++) {
 112                 e = strchr(elements[i], '=');
 113                 if (!e)
 114                         g_hash_table_insert(hash, g_strdup(elements[i]), NULL);
 115                 else {
 116                         *e++ = '\0';
 117                         g_hash_table_insert(hash, g_strdup(elements[i]), g_strdup(e));
 118                 }
 119         }
 120         g_strfreev(elements);
 121
 122         return hash;
 123 }
 124
 125 struct sr_dev *parse_devstring(const char *devstring)
 126 {
 127         struct sr_dev *dev, *d;
 128         struct sr_dev_driver **drivers;
 129         GSList *devs, *l;
 130         int i, num_devs, dev_num, dev_cnt;
 131         char *tmp;
 132
 133         if (!devstring)
 134                 return NULL;
 135
 136         dev = NULL;
 137         dev_num = strtol(devstring, &tmp, 10);
 138         if (tmp != devstring) {
 139                 /* argument is numeric, meaning a device ID. Make all drivers
 140                  * scan for devices.
 141                  */
 142                 num_devs = num_real_devs();
 143                 if (dev_num < 0 || dev_num >= num_devs)
 144                         return NULL;
 145
 146                 dev_cnt = 0;
 147                 devs = sr_dev_list();
 148                 for (l = devs; l; l = l->next) {
 149                         d = l->data;
 150                         if (sr_dev_has_hwcap(d, SR_HWCAP_DEMO_DEV))
 151                                 continue;
 152                         if (dev_cnt == dev_num) {
 153                                 if (dev_num == dev_cnt) {
 154                                         dev = d;
 155                                         break;
 156                                 }
 157                         }
 158                         dev_cnt++;
 159                 }
 160         } else {
 161                 /* select device by driver -- only initialize that driver,
 162                  * no need to let them all scan
 163                  */
 164                 dev = NULL;
 165                 drivers = sr_driver_list();
 166                 for (i = 0; drivers[i]; i++) {
 167                         if (strcmp(drivers[i]->name, devstring))
 168                                 continue;
 169                         num_devs = sr_driver_init(drivers[i]);
 170                         if (num_devs == 1) {
 171                                 devs = sr_dev_list();
 172                                 dev = devs->data;
 173                         } else if (num_devs > 1) {
 174                                 printf("driver '%s' found %d devices, select by ID instead.\n",
 175                                                 devstring, num_devs);
 176                         }
 177                         /* fall through: selected driver found no devices */
 178                         break;
 179                 }
 180         }
 181
 182         return dev;
 183 }
 184
 185 char *strcanon(const char *str)
 186 {
 187         int p0, p1;
 188         char *s;
 189
 190         /* Returns newly allocated string. */
 191         s = g_ascii_strdown(str, -1);
 192         for (p0 = p1 = 0; str[p0]; p0++) {
 193                 if ((s[p0] >= 'a' && s[p0] <= 'z')
 194                                 || (s[p0] >= '0' && s[p0] <= '9'))
 195                         s[p1++] = s[p0];
 196         }
 197         s[p1] = '\0';
 198
 199         return s;
 200 }
 201
 202 int canon_cmp(const char *str1, const char *str2)
 203 {
 204         int ret;
 205         char *s1, *s2;
 206
 207         s1 = strcanon(str1);
 208         s2 = strcanon(str2);
 209         ret = g_ascii_strcasecmp(s1, s2);
 210         g_free(s2);
 211         g_free(s1);
 212
 213         return ret;
 214 }