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         probelist = g_malloc0(max_probes * sizeof(char *));
  37         tokens = g_strsplit(probestring, ",", max_probes);
  38
  39         for (i = 0; tokens[i]; i++) {
  40                 if (strchr(tokens[i], '-')) {
  41                         /* A range of probes in the form 1-5. */
  42                         range = g_strsplit(tokens[i], "-", 2);
  43                         if (!range[0] || !range[1] || range[2]) {
  44                                 /* Need exactly two arguments. */
  45                                 printf("Invalid probe syntax '%s'.\n",
  46                                        tokens[i]);
  47                                 error = TRUE;
  48                                 break;
  49                         }
  50
  51                         b = strtol(range[0], NULL, 10);
  52                         e = strtol(range[1], NULL, 10);
  53                         if (b < 1 || e > max_probes || b >= e) {
  54                                 printf("Invalid probe range '%s'.\n",
  55                                        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                                 printf("Invalid probe %d.\n", 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_device *parse_devicestring(const char *devicestring)
 126 {
 127         struct sr_device *device, *d;
 128         struct sr_device_plugin *plugin;
 129         GSList *devices, *plugins, *l, *p;
 130         int num_devices, device_num, device_cnt;
 131         char *tmp;
 132
 133         if (!devicestring)
 134                 return NULL;
 135
 136         device = NULL;
 137         device_num = strtol(devicestring, &tmp, 10);
 138         if (tmp != devicestring) {
 139                 /* argument is numeric, meaning a device ID. Make all driver
 140                  * plugins scan for devices.
 141                  */
 142                 num_devices = num_real_devices();
 143                 if (device_num < 0 || device_num >= num_devices)
 144                         return NULL;
 145
 146                 device_cnt = 0;
 147                 devices = sr_device_list();
 148                 for (l = devices; l; l = l->next) {
 149                         d = l->data;
 150                         if (sr_device_has_hwcap(d, SR_HWCAP_DEMO_DEVICE))
 151                                 continue;
 152                         if (device_cnt == device_num) {
 153                                 if (device_num == device_cnt) {
 154                                         device = d;
 155                                         break;
 156                                 }
 157                         }
 158                         device_cnt++;
 159                 }
 160         } else {
 161                 /* select device by driver -- only initialize that driver,
 162                  * no need to let them all scan
 163                  */
 164                 device = NULL;
 165                 plugins = sr_list_hwplugins();
 166                 for (p = plugins; p; p = p->next) {
 167                         plugin = p->data;
 168                         if (strcmp(plugin->name, devicestring))
 169                                 continue;
 170                         num_devices = sr_init_hwplugins(plugin);
 171                         if (num_devices == 1) {
 172                                 devices = sr_device_list();
 173                                 device = devices->data;
 174                         } else if (num_devices > 1) {
 175                                 printf("driver '%s' found %d devices, select by ID instead.\n",
 176                                                 devicestring, num_devices);
 177                         }
 178                         /* fall through: selected driver found no devices */
 179                         break;
 180                 }
 181         }
 182
 183         return device;
 184 }