Rename 'probe' to 'channel' (libsigrokdecode change).
authorUwe Hermann <uwe@hermann-uwe.de>
Sat, 12 Apr 2014 11:42:30 +0000 (13:42 +0200)
committerUwe Hermann <uwe@hermann-uwe.de>
Mon, 14 Apr 2014 19:54:42 +0000 (21:54 +0200)
The -p|--probes option is renamed to -C|--channels.

Variables of type 'struct srd_channel *' are consistently named 'pdch' to
make them easily distinguishable from libsigrok's 'struct sr_channel *'
variables that are consistently named 'ch'.

decode.c
doc/sigrok-cli.1
input.c
main.c
show.c
sigrok-cli.h

index c84539824b138639ae8315c102ec16843c56f6b1..add16f744815e3c7fa6211af2a94590006beb3e1 100644 (file)
--- a/decode.c
+++ b/decode.c
@@ -25,7 +25,7 @@
 static GHashTable *pd_ann_visible = NULL;
 static GHashTable *pd_meta_visible = NULL;
 static GHashTable *pd_binary_visible = NULL;
-static GHashTable *pd_probe_maps = NULL;
+static GHashTable *pd_channel_maps = NULL;
 
 extern struct srd_session *srd_sess;
 extern gint opt_loglevel;
@@ -88,25 +88,25 @@ static int move_hash_element(GHashTable *src, GHashTable *dest, void *key)
        return TRUE;
 }
 
-static GHashTable *extract_probe_map(struct srd_decoder *dec, GHashTable *hash)
+static GHashTable *extract_channel_map(struct srd_decoder *dec, GHashTable *hash)
 {
-       GHashTable *probe_map;
-       struct srd_probe *p;
+       GHashTable *channel_map;
+       struct srd_channel *pdch;
        GSList *l;
 
-       probe_map = g_hash_table_new_full(g_str_hash, g_str_equal,
+       channel_map = g_hash_table_new_full(g_str_hash, g_str_equal,
                                          g_free, g_free);
 
-       for (l = dec->probes; l; l = l->next) {
-               p = l->data;
-               move_hash_element(hash, probe_map, p->id);
+       for (l = dec->channels; l; l = l->next) {
+               pdch = l->data;
+               move_hash_element(hash, channel_map, pdch->id);
        }
-       for (l = dec->opt_probes; l; l = l->next) {
-               p = l->data;
-               move_hash_element(hash, probe_map, p->id);
+       for (l = dec->opt_channels; l; l = l->next) {
+               pdch = l->data;
+               move_hash_element(hash, channel_map, pdch->id);
        }
 
-       return probe_map;
+       return channel_map;
 }
 
 /* Register the given PDs for this session.
@@ -117,7 +117,7 @@ static GHashTable *extract_probe_map(struct srd_decoder *dec, GHashTable *hash)
 int register_pds(const char *opt_pds, char *opt_pd_annotations)
 {
        struct srd_decoder *dec;
-       GHashTable *pd_opthash, *options, *probes;
+       GHashTable *pd_opthash, *options, *channels;
        GList *leftover, *l;
        struct srd_decoder_inst *di;
        int ret;
@@ -127,7 +127,7 @@ int register_pds(const char *opt_pds, char *opt_pd_annotations)
                                               g_free, NULL);
        ret = 0;
        pd_name = NULL;
-       pd_opthash = options = probes = pd_probe_maps = NULL;
+       pd_opthash = options = channels = pd_channel_maps = NULL;
        pdtokens = g_strsplit(opt_pds, ",", 0);
        for (pdtok = pdtokens; *pdtok; pdtok++) {
                if (!(pd_opthash = parse_generic_arg(*pdtok, TRUE))) {
@@ -144,17 +144,17 @@ int register_pds(const char *opt_pds, char *opt_pd_annotations)
                }
                dec = srd_decoder_get_by_id(pd_name);
 
-               /* Convert decoder option and probe values to GVariant. */
+               /* Convert decoder option and channel values to GVariant. */
                if (!opts_to_gvar(dec, pd_opthash, &options)) {
                        ret = 1;
                        break;
                }
-               probes = extract_probe_map(dec, pd_opthash);
+               channels = extract_channel_map(dec, pd_opthash);
 
                if (g_hash_table_size(pd_opthash) > 0) {
                        leftover = g_hash_table_get_keys(pd_opthash);
                        for (l = leftover; l; l = l->next)
-                               g_critical("Unknown option or probe '%s'", (char *)l->data);
+                               g_critical("Unknown option or channel '%s'", (char *)l->data);
                        g_list_free(leftover);
                        break;
                }
@@ -166,12 +166,14 @@ int register_pds(const char *opt_pds, char *opt_pd_annotations)
                }
 
                if (pdtok == pdtokens) {
-                       /* Save the probe setup for later, but only on the first
-                        * decoder -- stacked decoders don't get probes. */
-                       pd_probe_maps = g_hash_table_new_full(g_str_hash,
+                       /*
+                        * Save the channel setup for later, but only on the
+                        * first decoder (stacked decoders don't get channels).
+                        */
+                       pd_channel_maps = g_hash_table_new_full(g_str_hash,
                                        g_str_equal, g_free, (GDestroyNotify)g_hash_table_destroy);
-                       g_hash_table_insert(pd_probe_maps, g_strdup(di->inst_id), probes);
-                       probes = NULL;
+                       g_hash_table_insert(pd_channel_maps, g_strdup(di->inst_id), channels);
+                       channels = NULL;
                }
 
                /* If no annotation list was specified, add them all in now.
@@ -188,29 +190,29 @@ int register_pds(const char *opt_pds, char *opt_pd_annotations)
                g_hash_table_destroy(pd_opthash);
        if (options)
                g_hash_table_destroy(options);
-       if (probes)
-               g_hash_table_destroy(probes);
+       if (channels)
+               g_hash_table_destroy(channels);
        if (pd_name)
                g_free(pd_name);
 
        return ret;
 }
 
-static void map_pd_inst_probes(void *key, void *value, void *user_data)
+static void map_pd_inst_channels(void *key, void *value, void *user_data)
 {
-       GHashTable *probe_map;
-       GHashTable *probe_indices;
-       GSList *probe_list;
+       GHashTable *channel_map;
+       GHashTable *channel_indices;
+       GSList *channel_list;
        struct srd_decoder_inst *di;
        GVariant *var;
-       void *probe_id;
+       void *channel_id;
        void *channel_target;
        struct sr_channel *ch;
        GHashTableIter iter;
        int num_channels;
 
-       probe_map = value;
-       probe_list = user_data;
+       channel_map = value;
+       channel_list = user_data;
 
        di = srd_inst_find_by_id(srd_sess, key);
        if (!di) {
@@ -218,12 +220,12 @@ static void map_pd_inst_probes(void *key, void *value, void *user_data)
                           (char *)key);
                return;
        }
-       probe_indices = g_hash_table_new_full(g_str_hash, g_str_equal, g_free,
+       channel_indices = g_hash_table_new_full(g_str_hash, g_str_equal, g_free,
                                              (GDestroyNotify)g_variant_unref);
 
-       g_hash_table_iter_init(&iter, probe_map);
-       while (g_hash_table_iter_next(&iter, &probe_id, &channel_target)) {
-               ch = find_channel(probe_list, channel_target);
+       g_hash_table_iter_init(&iter, channel_map);
+       while (g_hash_table_iter_next(&iter, &channel_id, &channel_target)) {
+               ch = find_channel(channel_list, channel_target);
                if (!ch) {
                        g_printerr("cli: No channel with name \"%s\" found.\n",
                                   (char *)channel_target);
@@ -235,20 +237,20 @@ static void map_pd_inst_probes(void *key, void *value, void *user_data)
 
                var = g_variant_new_int32(ch->index);
                g_variant_ref_sink(var);
-               g_hash_table_insert(probe_indices, g_strdup(probe_id), var);
+               g_hash_table_insert(channel_indices, g_strdup(channel_id), var);
        }
 
-       num_channels = g_slist_length(probe_list);
-       srd_inst_probe_set_all(di, probe_indices, (num_channels + 7) / 8);
+       num_channels = g_slist_length(channel_list);
+       srd_inst_channel_set_all(di, channel_indices, (num_channels + 7) / 8);
 }
 
-void map_pd_probes(struct sr_dev_inst *sdi)
+void map_pd_channels(struct sr_dev_inst *sdi)
 {
-       if (pd_probe_maps) {
-               g_hash_table_foreach(pd_probe_maps, &map_pd_inst_probes,
+       if (pd_channel_maps) {
+               g_hash_table_foreach(pd_channel_maps, &map_pd_inst_channels,
                                     sdi->channels);
-               g_hash_table_destroy(pd_probe_maps);
-               pd_probe_maps = NULL;
+               g_hash_table_destroy(pd_channel_maps);
+               pd_channel_maps = NULL;
        }
 }
 
index e8d98b062db20ce05c11ae5fc338fa9a4997d142..dbc8467a2fb5ed0956d5577880d768e20fa6b111 100644 (file)
@@ -126,7 +126,7 @@ like this:
  0:11111111 11111111 11111111 11111111 [...]
  1:11111111 00000000 11111111 00000000 [...]
 .TP
-.BR "\-p, \-\-probes " <probelist>
+.BR "\-C, \-\-channels " <channellist>
 A comma-separated list of channels to be used in the session.
 .sp
 Note that sigrok always names the channels according to how they're shown on
@@ -145,7 +145,7 @@ Example:
 .sp
 .RB "  $ " "sigrok\-cli \-\-driver fx2lafw \-\-samples 100"
 .br
-.B "               \-\-probes 1=CLK,2\-4,7"
+.B "               \-\-channels 1=CLK,2\-4,7"
 .br
  CLK:11111111 11111111 11111111 11111111 [...]
    2:11111111 11111111 11111111 11111111 [...]
@@ -436,7 +436,7 @@ To capture data from the first 4 channels using the Openbench Logic Sniffer last
 .TP
 .nf
 \fBsigrok\-cli \-\-driver ols:conn=/dev/ttyACM0 \-\-config samplerate=10m \\\fP
-\fB\-\-output\-format bits \-\-probes 0\-3 \-\-wait\-trigger \\\fP
+\fB\-\-output\-format bits \-\-channels 0\-3 \-\-wait\-trigger \\\fP
 \fB\-\-triggers 0=1,1=r,2=0,3=1 \-\-time 100\fP
 .TP
 To turn on internal logging on a Lascar EL-USB series device:
diff --git a/input.c b/input.c
index 8cbfbc7edf17940e2093778a4def4d398fe62e59..566fd1d55dcf6b2f838f3de8b2f19b3db0245d46 100644 (file)
--- a/input.c
+++ b/input.c
@@ -27,7 +27,7 @@
 
 extern gchar *opt_input_file;
 extern gchar *opt_input_format;
-extern gchar *opt_probes;
+extern gchar *opt_channels;
 
 
 /**
diff --git a/main.c b/main.c
index f34007ceba4857480b386775d16babef11157d71..c751295a5cadfc49f1ef22d39a5fda4e3f491444 100644 (file)
--- a/main.c
+++ b/main.c
@@ -35,7 +35,7 @@ gchar *opt_input_file = NULL;
 gchar *opt_output_file = NULL;
 gchar *opt_drv = NULL;
 gchar *opt_config = NULL;
-static gchar *opt_probes = NULL;
+static gchar *opt_channels = NULL;
 gchar *opt_channel_group = NULL;
 gchar *opt_triggers = NULL;
 gchar *opt_pds = NULL;
@@ -71,8 +71,8 @@ static GOptionEntry optargs[] = {
                        "Save output to file", NULL},
        {"output-format", 'O', 0, G_OPTION_ARG_STRING, &opt_output_format,
                        "Output format", NULL},
-       {"probes", 'p', 0, G_OPTION_ARG_STRING, &opt_probes,
-                       "Probes to use", NULL},
+       {"channels", 'C', 0, G_OPTION_ARG_STRING, &opt_channels,
+                       "Channels to use", NULL},
        {"channel-group", 'g', 0, G_OPTION_ARG_STRING, &opt_channel_group,
                        "Channel groups", NULL},
        {"triggers", 't', 0, G_OPTION_ARG_STRING, &opt_triggers,
@@ -134,8 +134,8 @@ int select_channels(struct sr_dev_inst *sdi)
        struct sr_channel *ch;
        GSList *selected_channels, *l;
 
-       if (opt_probes) {
-               if (!(selected_channels = parse_channelstring(sdi, opt_probes)))
+       if (opt_channels) {
+               if (!(selected_channels = parse_channelstring(sdi, opt_channels)))
                        return SR_ERR;
 
                for (l = sdi->channels; l; l = l->next) {
@@ -148,7 +148,7 @@ int select_channels(struct sr_dev_inst *sdi)
                g_slist_free(selected_channels);
        }
 #ifdef HAVE_SRD
-       map_pd_probes(sdi);
+       map_pd_channels(sdi);
 #endif
        return SR_OK;
 }
diff --git a/show.c b/show.c
index 0b6d8f4fd5a9e2f9a824187fc6410338c94c6f11..25429b3e3d85c60ccb54276e2b4e33203c6edd9a 100644 (file)
--- a/show.c
+++ b/show.c
@@ -529,7 +529,7 @@ void show_pd_detail(void)
        struct srd_decoder *dec;
        struct srd_decoder_option *o;
        char **pdtokens, **pdtok, *optsep, **ann, *val, *doc;
-       struct srd_probe *p;
+       struct srd_channel *pdch;
        struct srd_decoder_annotation_row *r;
 
        pdtokens = g_strsplit(opt_pds, ",", -1);
@@ -565,22 +565,22 @@ void show_pd_detail(void)
                } else {
                        printf("None.\n");
                }
-               printf("Required probes:\n");
-               if (dec->probes) {
-                       for (l = dec->probes; l; l = l->next) {
-                               p = l->data;
+               printf("Required channels:\n");
+               if (dec->channels) {
+                       for (l = dec->channels; l; l = l->next) {
+                               pdch = l->data;
                                printf("- %s (%s): %s\n",
-                                      p->id, p->name, p->desc);
+                                      pdch->id, pdch->name, pdch->desc);
                        }
                } else {
                        printf("None.\n");
                }
-               printf("Optional probes:\n");
-               if (dec->opt_probes) {
-                       for (l = dec->opt_probes; l; l = l->next) {
-                               p = l->data;
+               printf("Optional channels:\n");
+               if (dec->opt_channels) {
+                       for (l = dec->opt_channels; l; l = l->next) {
+                               pdch = l->data;
                                printf("- %s (%s): %s\n",
-                                      p->id, p->name, p->desc);
+                                      pdch->id, pdch->name, pdch->desc);
                        }
                } else {
                        printf("None.\n");
index 754c58b4d6f0f0affc2cd630469ddeabe04bc2ca..52b673407f6e8cfb79f0aa3df7e5040ef0802c17 100644 (file)
@@ -65,7 +65,7 @@ int setup_pd_binary(char *opt_pd_binary);
 void show_pd_annotations(struct srd_proto_data *pdata, void *cb_data);
 void show_pd_meta(struct srd_proto_data *pdata, void *cb_data);
 void show_pd_binary(struct srd_proto_data *pdata, void *cb_data);
-void map_pd_probes(struct sr_dev_inst *sdi);
+void map_pd_channels(struct sr_dev_inst *sdi);
 #endif
 
 /* parsers.c */