Change PD options to be a tuple of dictionaries.
authorBert Vermeulen <bert@biot.com>
Sun, 9 Mar 2014 22:48:27 +0000 (23:48 +0100)
committerBert Vermeulen <bert@biot.com>
Sun, 9 Mar 2014 23:47:30 +0000 (00:47 +0100)
Each option consists of a dictionary with the following keys:

  id      The option id, which is passed in when setting a value.
  desc    A description of the option, suitable for display.
  def     The default value for this option.
  values  (optional) If present, a tuple containing values the option
          may take. They must be of the same type as the default.

Valid types for the options are UTF-8-encoded strings, integers, and
floating point values.

13 files changed:
decoder.c
decoders/can/pd.py
decoders/i2c/pd.py
decoders/i2cfilter/pd.py
decoders/lm75/pd.py
decoders/onewire_link/pd.py
decoders/parallel/pd.py
decoders/spi/pd.py
decoders/uart/pd.py
decoders/usb_packet/pd.py
decoders/usb_signalling/pd.py
instance.c
libsigrokdecode.h

index becd78516199ec88fe2581ff4a4eb99b2c2f027f..18b0b58de636785344a42122b49e0b50c76ebc34 100644 (file)
--- a/decoder.c
+++ b/decoder.c
@@ -152,91 +152,137 @@ static int get_probes(const struct srd_decoder *d, const char *attr,
 
 static int get_options(struct srd_decoder *d)
 {
-       PyObject *py_opts, *py_keys, *py_values, *py_val, *py_desc, *py_default;
-       Py_ssize_t i;
+       PyObject *py_opts, *py_opt, *py_val, *py_default, *py_item;
+       Py_ssize_t opt, i;
        struct srd_decoder_option *o;
-       gint64 def_long;
-       int num_keys, overflow, ret;
-       char *key, *def_str;
-
-       ret = SRD_ERR_PYTHON;
-       key = NULL;
+       GVariant *gvar;
+       gint64 lval;
+       double dval;
+       int overflow;
+       char *sval;
 
        if (!PyObject_HasAttrString(d->py_dec, "options"))
-               /* That's fine. */
+               /* No options, that's fine. */
                return SRD_OK;
 
-       /* If present, options must be a dictionary. */
+       /* If present, options must be a tuple. */
        py_opts = PyObject_GetAttrString(d->py_dec, "options");
-       if (!PyDict_Check(py_opts)) {
-               srd_err("Protocol decoder %s options attribute is not "
-                       "a dictionary.", d->name);
-               goto err_out;
+       if (!PyTuple_Check(py_opts)) {
+               srd_err("Protocol decoder %s: options attribute is not "
+                               "a tuple.", d->id);
+               return SRD_ERR_PYTHON;
        }
 
-       py_keys = PyDict_Keys(py_opts);
-       py_values = PyDict_Values(py_opts);
-       num_keys = PyList_Size(py_keys);
-       for (i = 0; i < num_keys; i++) {
-               py_str_as_str(PyList_GetItem(py_keys, i), &key);
-               srd_dbg("option '%s'", key);
-               py_val = PyList_GetItem(py_values, i);
-               if (!PyList_Check(py_val) || PyList_Size(py_val) != 2) {
-                       srd_err("Protocol decoder %s option '%s' value must be "
-                                       "a list with two elements.", d->name, key);
-                       goto err_out;
-               }
-               py_desc = PyList_GetItem(py_val, 0);
-               if (!PyUnicode_Check(py_desc)) {
-                       srd_err("Protocol decoder %s option '%s' has no "
-                                       "description.", d->name, key);
-                       goto err_out;
+       for (opt = 0; opt < PyTuple_Size(py_opts); opt++) {
+               py_opt = PyTuple_GetItem(py_opts, opt);
+               if (!PyDict_Check(py_opt)) {
+                       srd_err("Protocol decoder %s options: each option "
+                                       "must consist of a dictionary.", d->name);
+                       return SRD_ERR_PYTHON;
                }
-               py_default = PyList_GetItem(py_val, 1);
-               if (!PyUnicode_Check(py_default) && !PyLong_Check(py_default)) {
-                       srd_err("Protocol decoder %s option '%s' has default "
-                                       "of unsupported type '%s'.", d->name, key,
-                                       Py_TYPE(py_default)->tp_name);
-                       goto err_out;
+               if (!(py_val = PyDict_GetItemString(py_opt, "id"))) {
+                       srd_err("Protocol decoder %s option %d has no "
+                                       "id.", d->name);
+                       return SRD_ERR_PYTHON;
                }
-               if (!(o = g_try_malloc(sizeof(struct srd_decoder_option)))) {
-                       srd_err("option malloc failed");
-                       goto err_out;
+               o = g_malloc0(sizeof(struct srd_decoder_option));
+               py_str_as_str(py_val, &o->id);
+
+               if ((py_val = PyDict_GetItemString(py_opt, "desc")))
+                       py_str_as_str(py_val, &o->desc);
+
+               if ((py_default = PyDict_GetItemString(py_opt, "default"))) {
+                       if (PyUnicode_Check(py_default)) {
+                               /* UTF-8 string */
+                               py_str_as_str(py_default, &sval);
+                               o->def = g_variant_new_string(sval);
+                               g_free(sval);
+                       } else if (PyLong_Check(py_default)) {
+                               /* Long */
+                               lval = PyLong_AsLongAndOverflow(py_default, &overflow);
+                               if (overflow) {
+                                       /* Value is < LONG_MIN or > LONG_MAX */
+                                       PyErr_Clear();
+                                       srd_err("Protocol decoder %s option 'default' has "
+                                                       "invalid default value.", d->name);
+                                       return SRD_ERR_PYTHON;
+                               }
+                               o->def = g_variant_new_int64(lval);
+                       } else if (PyFloat_Check(py_default)) {
+                               /* Float */
+                               if ((dval = PyFloat_AsDouble(py_default)) == -1.0) {
+                                       PyErr_Clear();
+                                       srd_err("Protocol decoder %s option 'default' has "
+                                                       "invalid default value.", d->name);
+                                       return SRD_ERR_PYTHON;
+                               }
+                               o->def = g_variant_new_double(dval);
+                       } else {
+                               srd_err("Protocol decoder %s option 'default' has "
+                                               "value of unsupported type '%s'.", d->name,
+                                               Py_TYPE(py_default)->tp_name);
+                               return SRD_ERR_PYTHON;
+                       }
+                       g_variant_ref_sink(o->def);
                }
-               o->id = g_strdup(key);
-               py_str_as_str(py_desc, &o->desc);
-               if (PyUnicode_Check(py_default)) {
-                       /* UTF-8 string */
-                       py_str_as_str(py_default, &def_str);
-                       o->def = g_variant_new_string(def_str);
-                       g_free(def_str);
-               } else {
-                       /* Long */
-                       def_long = PyLong_AsLongAndOverflow(py_default, &overflow);
-                       if (overflow) {
-                               /* Value is < LONG_MIN or > LONG_MAX */
-                               PyErr_Clear();
-                               srd_err("Protocol decoder %s option '%s' has "
-                                               "invalid default value.", d->name, key);
-                               goto err_out;
+
+               if ((py_val = PyDict_GetItemString(py_opt, "values"))) {
+                       /* A default is required if a list of values is
+                        * given, since it's used to verify their type. */
+                       if (!o->def) {
+                               srd_err("No default for option '%s'", o->id);
+                               return SRD_ERR_PYTHON;
+                       }
+                       if (!PyTuple_Check(py_val)) {
+                               srd_err("Option '%s' values should be a tuple.", o->id);
+                               return SRD_ERR_PYTHON;
+                       }
+                       for (i = 0; i < PyTuple_Size(py_val); i++) {
+                               py_item = PyTuple_GetItem(py_val, i);
+                               if (Py_TYPE(py_default) != Py_TYPE(py_item)) {
+                                       srd_err("All values for option '%s' must be "
+                                                       "of the same type as the default.",
+                                                       o->id);
+                                       return SRD_ERR_PYTHON;
+                               }
+                               if (PyUnicode_Check(py_item)) {
+                                       /* UTF-8 string */
+                                       py_str_as_str(py_item, &sval);
+                                       gvar = g_variant_new_string(sval);
+                                       g_variant_ref_sink(gvar);
+                                       g_free(sval);
+                                       o->values = g_slist_append(o->values, gvar);
+                               } else if (PyLong_Check(py_item)) {
+                                       /* Long */
+                                       lval = PyLong_AsLongAndOverflow(py_default, &overflow);
+                                       if (overflow) {
+                                               /* Value is < LONG_MIN or > LONG_MAX */
+                                               PyErr_Clear();
+                                               srd_err("Protocol decoder %s option 'values' "
+                                                               "has invalid value.", d->name);
+                                               return SRD_ERR_PYTHON;
+                                       }
+                                       gvar = g_variant_new_int64(lval);
+                                       g_variant_ref_sink(gvar);
+                                       o->values = g_slist_append(o->values, gvar);
+                               } else if (PyFloat_Check(py_default)) {
+                                       /* Float */
+                                       if ((dval = PyFloat_AsDouble(py_default)) == -1.0) {
+                                               PyErr_Clear();
+                                               srd_err("Protocol decoder %s option 'default' has "
+                                                               "invalid default value.", d->name);
+                                               return SRD_ERR_PYTHON;
+                                       }
+                                       gvar = g_variant_new_double(dval);
+                                       g_variant_ref_sink(gvar);
+                                       o->values = g_slist_append(o->values, gvar);
+                               }
                        }
-                       o->def = g_variant_new_int64(def_long);
                }
-               g_variant_ref_sink(o->def);
                d->options = g_slist_append(d->options, o);
-               g_free(key);
-               key = NULL;
        }
-       Py_DecRef(py_keys);
-       Py_DecRef(py_values);
-
-       ret = SRD_OK;
-
-err_out:
-       Py_XDECREF(py_opts);
-       g_free(key);
 
-       return ret;
+       return SRD_OK;
 }
 
 /**
@@ -338,6 +384,23 @@ SRD_API int srd_decoder_load(const char *module_name)
        }
        Py_CLEAR(py_method);
 
+       /* Store required fields in newly allocated strings. */
+       if (py_attr_as_str(d->py_dec, "id", &(d->id)) != SRD_OK)
+               goto err_out;
+
+       if (py_attr_as_str(d->py_dec, "name", &(d->name)) != SRD_OK)
+               goto err_out;
+
+       if (py_attr_as_str(d->py_dec, "longname", &(d->longname)) != SRD_OK)
+               goto err_out;
+
+       if (py_attr_as_str(d->py_dec, "desc", &(d->desc)) != SRD_OK)
+               goto err_out;
+
+       if (py_attr_as_str(d->py_dec, "license", &(d->license)) != SRD_OK)
+               goto err_out;
+
+       /* All options and their default values. */
        if (get_options(d) != SRD_OK)
                goto err_out;
 
@@ -362,22 +425,6 @@ SRD_API int srd_decoder_load(const char *module_name)
                p->order += g_slist_length(d->probes);
        }
 
-       /* Store required fields in newly allocated strings. */
-       if (py_attr_as_str(d->py_dec, "id", &(d->id)) != SRD_OK)
-               goto err_out;
-
-       if (py_attr_as_str(d->py_dec, "name", &(d->name)) != SRD_OK)
-               goto err_out;
-
-       if (py_attr_as_str(d->py_dec, "longname", &(d->longname)) != SRD_OK)
-               goto err_out;
-
-       if (py_attr_as_str(d->py_dec, "desc", &(d->desc)) != SRD_OK)
-               goto err_out;
-
-       if (py_attr_as_str(d->py_dec, "license", &(d->license)) != SRD_OK)
-               goto err_out;
-
        /* Convert annotation class attribute to GSList of char **. */
        d->annotations = NULL;
        if (PyObject_HasAttrString(d->py_dec, "annotations")) {
index c394cf1faa84bb77ab1957bb05ba6c4444e69426..e2b55fa3c62f89fd3a2a3e6f9403710b1a37084e 100644 (file)
@@ -33,10 +33,10 @@ class Decoder(srd.Decoder):
         {'id': 'can_rx', 'name': 'CAN RX', 'desc': 'CAN bus line'},
     ]
     optional_probes = []
-    options = {
-        'bitrate': ['Bitrate', 1000000], # 1Mbit/s
-        'sample_point': ['Sample point', 70], # 70%
-    }
+    options = (
+        {'id': 'bitrate', 'desc': 'Bitrate', 'default': 1000000}, # 1Mbit/s
+        {'id': 'sample_point', 'desc': 'Sample point', 'default': 70}, # 70%
+    )
     annotations = [
         ['data', 'CAN payload data'],
         ['sof', 'Start of frame'],
index 2db7d21f6a74ca7bf3d35ed0e8d32995ce6a908d..9cbdd533c4012f01f706f6b5f1f4479f18e11ae4 100644 (file)
@@ -77,9 +77,10 @@ class Decoder(srd.Decoder):
         {'id': 'sda', 'name': 'SDA', 'desc': 'Serial data line'},
     ]
     optional_probes = []
-    options = {
-        'address_format': ['Displayed slave address format', 'shifted'],
-    }
+    options = (
+        {'id': 'address_format', 'desc': 'Displayed slave address format',
+            'default': 'shifted', 'values': ('shifted', 'unshifted')},
+    )
     annotations = [
         ['start', 'Start condition'],
         ['repeat-start', 'Repeat start condition'],
index 09c12f1f69182fd9af3f6cc547db50a61136f85b..91269c0862b186b7dc07c6960a328d84b355aab1 100644 (file)
@@ -33,10 +33,12 @@ class Decoder(srd.Decoder):
     outputs = ['i2c']
     probes = []
     optional_probes = []
-    options = {
-        'address': ['Address to filter out of the I²C stream', 0],
-        'direction': ['Direction to filter (read/write/both)', 'both']
-    }
+    options = (
+        {'id': 'address', 'desc': 'Address to filter out of the I²C stream',
+            'default': 0},
+        {'id': 'direction', 'desc': 'Direction to filter', 'default': 'both',
+            'values': ('read', 'write', 'both')}
+    )
     annotations = []
 
     def __init__(self, **kwargs):
index 58c2c89a6c4a433ed8c8e3978a33673153c136f9..84cc26a01b952fe91aa1944510c8ef53babb9612 100644 (file)
@@ -55,10 +55,11 @@ class Decoder(srd.Decoder):
         {'id': 'a1', 'name': 'A1', 'desc': 'I²C slave address input 1'},
         {'id': 'a2', 'name': 'A2', 'desc': 'I²C slave address input 2'},
     ]
-    options = {
-        'sensor': ['Sensor type', 'lm75'],
-        'resolution': ['Resolution', 9], # 9-12 bit, sensor/config dependent
-    }
+    options = (
+        {'id': 'sensor', 'desc': 'Sensor type', 'default': 'lm75'},
+        {'id': 'resolution', 'desc': 'Resolution', 'default': 9,
+            'values': (9, 10, 11, 12)},
+    )
     annotations = [
         ['celsius', 'Temperature in degrees Celsius'],
         ['kelvin', 'Temperature in Kelvin'],
index 5b5ebd01c6df1c8d2cb057035c39d6c3b5bc65a2..38ef8ccea3b5907fa1f020ba4964741e853bcb9d 100644 (file)
@@ -35,19 +35,36 @@ class Decoder(srd.Decoder):
     optional_probes = [
         {'id': 'pwr', 'name': 'PWR', 'desc': '1-Wire power supply pin'},
     ]
-    options = {
-        'overdrive': ['Overdrive mode', 'no'],
+    options = (
+        {'id': 'overdrive',
+            'desc': 'Overdrive mode',
+            'default': 'no'},
         # Time options (specified in microseconds):
-        'cnt_normal_bit': ['Normal mode sample bit time (µs)', 15],
-        'cnt_normal_slot': ['Normal mode data slot time (µs)', 60],
-        'cnt_normal_presence': ['Normal mode sample presence time (µs)', 75],
-        'cnt_normal_reset': ['Normal mode reset time (µs)', 480],
-        'cnt_overdrive_bit': ['Overdrive mode sample bit time (µs)', 2],
-        # 'cnt_overdrive_slot': ['Overdrive mode data slot time (µs)', 7.3],
-        'cnt_overdrive_slot': ['Overdrive mode data slot time (µs)', 7],
-        'cnt_overdrive_presence': ['Overdrive mode sample presence time (µs)', 10],
-        'cnt_overdrive_reset': ['Overdrive mode reset time (µs)', 48],
-    }
+        {'id': 'cnt_normal_bit',
+            'desc': 'Normal mode sample bit time (μs)',
+            'default': 15},
+        {'id': 'cnt_normal_slot',
+            'desc': 'Normal mode data slot time (μs)',
+            'default': 60},
+        {'id': 'cnt_normal_presence',
+            'desc': 'Normal mode sample presence time (μs)',
+            'default': 75},
+        {'id': 'cnt_normal_reset',
+            'desc': 'Normal mode reset time (μs)',
+            'default': 480},
+        {'id': 'cnt_overdrive_bit',
+            'desc': 'Overdrive mode sample bit time (μs)',
+            'default': 2},
+        {'id': 'cnt_overdrive_slot',
+            'desc': 'Overdrive mode data slot time (μs)',
+            'default': 7.3},
+        {'id': 'cnt_overdrive_presence',
+            'desc': 'Overdrive mode sample presence time (μs)',
+            'default': 10},
+        {'id': 'cnt_overdrive_reset',
+            'desc': 'Overdrive mode reset time (μs)',
+            'default': 48},
+    )
     annotations = [
         ['bit', 'Bit'],
         ['warnings', 'Warnings'],
index b2903d20e4b41425a4edc2163d990f095d1ee0e8..8f2176c70e8988c439246fdf2f44f670710a9457 100644 (file)
@@ -72,12 +72,14 @@ class Decoder(srd.Decoder):
     outputs = ['parallel']
     probes = []
     optional_probes = probe_list(8)
-    options = {
-        'clock_edge': ['Clock edge to sample on', 'rising'],
-        'wordsize': ['Word size of the data', 1],
-        'endianness': ['Endianness of the data', 'little'],
-        'format': ['Data format', 'hex'],
-    }
+    options = (
+        {'id': 'clock_edge', 'desc': 'Clock edge to sample on',
+            'default': 'rising', 'values': ('rising', 'falling')},
+        {'id': 'wordsize', 'desc': 'Word size of the data',
+            'default': 1},
+        {'id': 'endianness', 'desc': 'Endianness of the data',
+            'default': 'little', 'values': ('little', 'big')},
+    )
     annotations = [
         ['items', 'Items'],
         ['words', 'Words'],
index 2cde8bc4170bb1ac2249594a70fddea6b0b11039..6a2b5faff082c7e2d1369d44009d321ac14ec82d 100644 (file)
@@ -77,14 +77,17 @@ class Decoder(srd.Decoder):
         {'id': 'mosi', 'name': 'MOSI', 'desc': 'Master out, slave in'},
         {'id': 'cs', 'name': 'CS#', 'desc': 'Chip-select'},
     ]
-    options = {
-        'cs_polarity': ['CS# polarity', 'active-low'],
-        'cpol': ['Clock polarity', 0],
-        'cpha': ['Clock phase', 0],
-        'bitorder': ['Bit order within the SPI data', 'msb-first'],
-        'wordsize': ['Word size of SPI data', 8], # 1-64?
-        'format': ['Data format', 'hex'],
-    }
+    options = (
+        {'id': 'cs_polarity', 'desc': 'CS# polarity', 'default': 'active-low',
+            'values': ('active-low', 'active-high')},
+        {'id': 'cpol', 'desc': 'Clock polarity', 'default': 0,
+            'values': (0, 1)},
+        {'id': 'cpha', 'desc': 'Clock phase', 'default': 0,
+            'values': (0, 1)},
+        {'id': 'bitorder', 'desc': 'Bit order within the SPI data',
+            'default': 'msb-first', 'values': ('msb-first', 'lsb-first')},
+        {'id': 'wordsize', 'desc': 'Word size of SPI data', 'default': 8},
+    )
     annotations = [
         ['miso-data', 'MISO data'],
         ['mosi-data', 'MOSI data'],
index 8de84a4858c011bd1a696472c5056427e3d55c66..f01cacece3e86b18274432a0ba1e4d87a7b0e4f2 100644 (file)
@@ -85,16 +85,22 @@ class Decoder(srd.Decoder):
         {'id': 'rx', 'name': 'RX', 'desc': 'UART receive line'},
         {'id': 'tx', 'name': 'TX', 'desc': 'UART transmit line'},
     ]
-    options = {
-        'baudrate': ['Baud rate', 115200],
-        'num_data_bits': ['Data bits', 8], # Valid: 5-9.
-        'parity_type': ['Parity type', 'none'],
-        'parity_check': ['Check parity?', 'yes'], # TODO: Bool supported?
-        'num_stop_bits': ['Stop bit(s)', '1'], # String! 0, 0.5, 1, 1.5.
-        'bit_order': ['Bit order', 'lsb-first'],
-        'format': ['Data format', 'ascii'], # ascii/dec/hex/oct/bin
+    options = (
+        {'id': 'baudrate', 'desc': 'Baud rate', 'default': 115200},
+        {'id': 'num_data_bits', 'desc': 'Data bits', 'default': 8,
+            'values': (5, 6, 7, 8, 9)},
+        {'id': 'parity_type', 'desc': 'Parity type', 'default': 'none',
+            'values': ('none', 'odd', 'even', 'zero', 'one')},
+        {'id': 'parity_check', 'desc': 'Check parity?', 'default': 'yes',
+            'values': ('yes', 'no')},
+        {'id': 'num_stop_bits', 'desc': 'Stop bits', 'default': 1.0,
+            'values': (0.0, 0.5, 1.0, 1.5)},
+        {'id': 'bit_order', 'desc': 'Bit order', 'default': 'lsb-first',
+            'values': ('lsb-first', 'msb-first')},
+        {'id': 'format', 'desc': 'Data format', 'default': 'ascii',
+            'values': ('ascii', 'dec', 'hex', 'oct', 'bin')},
         # TODO: Options to invert the signal(s).
-    }
+    )
     annotations = [
         ['rx-data', 'RX data'],
         ['tx-data', 'TX data'],
index 752419467f28c1e3601b8fd71b7ffba3d49db747..d45e3bddc5ac9eb9b322ee88d77d088e609521ca 100644 (file)
@@ -153,9 +153,9 @@ class Decoder(srd.Decoder):
     outputs = ['usb_packet']
     probes = []
     optional_probes = []
-    options = {
-        'signalling': ['Signalling', 'full-speed'],
-    }
+    options = (
+        {'id': 'signalling', 'desc': 'Signalling', 'default': 'full-speed'},
+    )
     annotations = [
         ['sync-ok', 'SYNC'],
         ['sync-err', 'SYNC (error)'],
index 543089e041ef76dbbd51b153eed128a792a200c6..6f3ceffca75e771f22653b095bff6eaf74b877e1 100644 (file)
@@ -80,9 +80,10 @@ class Decoder(srd.Decoder):
         {'id': 'dm', 'name': 'D-', 'desc': 'USB D- signal'},
     ]
     optional_probes = []
-    options = {
-        'signalling': ['Signalling', 'full-speed'],
-    }
+    options = (
+        {'id': 'signalling', 'desc': 'Signalling',
+            'default': 'full-speed', 'values': ('full-speed', 'low-speed')},
+    )
     annotations = [
         ['sym', 'Symbol'],
         ['sop', 'Start of packet (SOP)'],
index 0a930bf184ca7a7c7ff6cfc499d2d74762ce81c6..e72fc966104d843e68aa5579d76780f6799bec9b 100644 (file)
@@ -64,15 +64,14 @@ extern SRD_PRIV PyTypeObject srd_logic_type;
 SRD_API int srd_inst_option_set(struct srd_decoder_inst *di,
                GHashTable *options)
 {
-       PyObject *py_dec_options, *py_dec_optkeys, *py_di_options, *py_optval;
-       PyObject *py_optlist, *py_classval;
-       Py_UNICODE *py_ustr;
+    struct srd_decoder_option *sdo;
+       PyObject *py_di_options, *py_optval;
        GVariant *value;
-       unsigned long long int val_ull;
+    GSList *l;
+    double val_double;
        gint64 val_int;
-       int num_optkeys, ret, size, i;
+       int ret;
        const char *val_str;
-       char *dbg, *key;
 
        if (!di) {
                srd_err("Invalid decoder instance.");
@@ -97,17 +96,10 @@ SRD_API int srd_inst_option_set(struct srd_decoder_inst *di,
        }
 
        ret = SRD_ERR_PYTHON;
-       key = NULL;
-       py_dec_options = py_dec_optkeys = py_di_options = py_optval = NULL;
-       py_optlist = py_classval = NULL;
-       py_dec_options = PyObject_GetAttrString(di->decoder->py_dec, "options");
-
-       /* All of these are synthesized objects, so they're good. */
-       py_dec_optkeys = PyDict_Keys(py_dec_options);
-       num_optkeys = PyList_Size(py_dec_optkeys);
+    py_optval = NULL;
 
        /*
-        * The 'options' dictionary is a class variable, but we need to
+        * The 'options' tuple is a class variable, but we need to
         * change it. Changing it directly will affect the entire class,
         * so we need to create a new object for it, and populate that
         * instead.
@@ -117,89 +109,58 @@ SRD_API int srd_inst_option_set(struct srd_decoder_inst *di,
        Py_DECREF(py_di_options);
        py_di_options = PyDict_New();
        PyObject_SetAttrString(di->py_inst, "options", py_di_options);
-       for (i = 0; i < num_optkeys; i++) {
-               /* Get the default class value for this option. */
-               py_str_as_str(PyList_GetItem(py_dec_optkeys, i), &key);
-               if (!(py_optlist = PyDict_GetItemString(py_dec_options, key)))
-                       goto err_out;
-               if (!(py_classval = PyList_GetItem(py_optlist, 1)))
-                       goto err_out;
-               if (!PyUnicode_Check(py_classval) && !PyLong_Check(py_classval)) {
-                       srd_err("Options of type %s are not yet supported.",
-                               Py_TYPE(py_classval)->tp_name);
-                       goto err_out;
-               }
-
-               if ((value = g_hash_table_lookup(options, key))) {
-                       dbg = g_variant_print(value, TRUE);
-                       srd_dbg("got option '%s' = %s", key, dbg);
-                       g_free(dbg);
-                       /* An override for this option was provided. */
-                       if (PyUnicode_Check(py_classval)) {
-                               if (!g_variant_is_of_type(value, G_VARIANT_TYPE_STRING)) {
-                                       srd_err("Option '%s' requires a string value.", key);
-                                       goto err_out;
-                               }
-                               val_str = g_variant_get_string(value, NULL);
-                               if (!(py_optval = PyUnicode_FromString(val_str))) {
-                                       /* Some UTF-8 encoding error. */
-                                       PyErr_Clear();
-                                       srd_err("Option '%s' requires a UTF-8 string value.", key);
-                                       goto err_out;
-                               }
-                       } else if (PyLong_Check(py_classval)) {
-                               if (!g_variant_is_of_type(value, G_VARIANT_TYPE_INT64)) {
-                                       srd_err("Option '%s' requires an integer value.", key);
-                                       goto err_out;
-                               }
-                               val_int = g_variant_get_int64(value);
-                               if (!(py_optval = PyLong_FromLong(val_int))) {
-                                       /* ValueError Exception */
-                                       PyErr_Clear();
-                                       srd_err("Option '%s' has invalid integer value.", key);
-                                       goto err_out;
-                               }
-                       }
-                       g_hash_table_remove(options, key);
-               } else {
-                       /* Use the class default for this option. */
-                       if (PyUnicode_Check(py_classval)) {
-                               /* Make a brand new copy of the string. */
-                               py_ustr = PyUnicode_AS_UNICODE(py_classval);
-                               size = PyUnicode_GET_SIZE(py_classval);
-                               py_optval = PyUnicode_FromUnicode(py_ustr, size);
-                       } else if (PyLong_Check(py_classval)) {
-                               /* Make a brand new copy of the integer. */
-                               val_ull = PyLong_AsUnsignedLongLong(py_classval);
-                               if (val_ull == (unsigned long long)-1) {
-                                       /* OverFlowError exception */
-                                       PyErr_Clear();
-                                       srd_err("Invalid integer value for %s: "
-                                               "expected integer.", key);
-                                       goto err_out;
-                               }
-                               if (!(py_optval = PyLong_FromUnsignedLongLong(val_ull)))
-                                       goto err_out;
-                       }
-               }
 
-               /*
-                * If we got here, py_optval holds a known good new reference
-                * to the instance option to set.
-                */
-               if (PyDict_SetItemString(py_di_options, key, py_optval) == -1)
+    for (l = di->decoder->options; l; l = l->next) {
+        sdo = l->data;
+        if ((value = g_hash_table_lookup(options, sdo->id))) {
+            /* A value was supplied for this option. */
+            if (!g_variant_type_equal(g_variant_get_type(value),
+                    g_variant_get_type(sdo->def))) {
+                srd_err("Option '%s' should have the same type "
+                        "as the default value.", sdo->id);
+                goto err_out;
+            }
+        } else {
+            /* Use default for this option. */
+            value = sdo->def;
+        }
+        if (g_variant_is_of_type(value, G_VARIANT_TYPE_STRING)) {
+            val_str = g_variant_get_string(value, NULL);
+            if (!(py_optval = PyUnicode_FromString(val_str))) {
+                /* Some UTF-8 encoding error. */
+                PyErr_Clear();
+                srd_err("Option '%s' requires a UTF-8 string value.", sdo->id);
+                goto err_out;
+            }
+        } else if (g_variant_is_of_type(value, G_VARIANT_TYPE_INT64)) {
+            val_int = g_variant_get_int64(value);
+            if (!(py_optval = PyLong_FromLong(val_int))) {
+                /* ValueError Exception */
+                PyErr_Clear();
+                srd_err("Option '%s' has invalid integer value.", sdo->id);
+                goto err_out;
+            }
+        } else if (g_variant_is_of_type(value, G_VARIANT_TYPE_DOUBLE)) {
+            val_double = g_variant_get_int64(value);
+            if (!(py_optval = PyFloat_FromDouble(val_double))) {
+                /* ValueError Exception */
+                PyErr_Clear();
+                srd_err("Option '%s' has invalid float value.", sdo->id);
+                goto err_out;
+            }
+        }
+               if (PyDict_SetItemString(py_di_options, sdo->id, py_optval) == -1)
                        goto err_out;
-               g_free(key);
-               key = NULL;
-       }
+        /* Not harmful even if we used the default. */
+        g_hash_table_remove(options, sdo->id);
+    }
+    if (g_hash_table_size(options) != 0)
+        srd_warn("Unknown options specified for '%s'", di->inst_id);
 
        ret = SRD_OK;
 
 err_out:
-       Py_XDECREF(py_di_options);
-       Py_XDECREF(py_dec_optkeys);
-       Py_XDECREF(py_dec_options);
-       g_free(key);
+       Py_XDECREF(py_optval);
        if (PyErr_Occurred()) {
                srd_exception_catch("Stray exception in srd_inst_option_set().");
                ret = SRD_ERR_PYTHON;
index fdf60526657c21bb280f6c5236f90944669942fa..f07e1ee32da91542e506ec2b9ef3c81e234e4161 100644 (file)
@@ -209,6 +209,7 @@ struct srd_decoder_option {
        char *id;
        char *desc;
        GVariant *def;
+    GSList *values;
 };
 
 struct srd_decoder_annotation_row {