Glib::VariantBase ConfigKey::parse_string(string value) const
{
GVariant *variant;
uint64_t p, q;
switch (data_type()->id())
{
case SR_T_UINT64:
check(sr_parse_sizestring(value.c_str(), &p));
variant = g_variant_new_uint64(p);
break;
case SR_T_STRING:
variant = g_variant_new_string(value.c_str());
break;
case SR_T_BOOL:
variant = g_variant_new_boolean(sr_parse_boolstring(value.c_str()));
break;
case SR_T_FLOAT:
variant = g_variant_new_double(stod(value));
break;
case SR_T_RATIONAL_PERIOD:
check(sr_parse_period(value.c_str(), &p, &q));
variant = g_variant_new("(tt)", p, q);
break;
case SR_T_RATIONAL_VOLT:
check(sr_parse_voltage(value.c_str(), &p, &q));
variant = g_variant_new("(tt)", p, q);
break;
case SR_T_INT32:
variant = g_variant_new_int32(stoi(value));
break;
default:
throw Error(SR_ERR_BUG);
}
return Glib::VariantBase(variant, false);
}
int opt_to_gvar(char *key, char *value, struct sr_config *src)
{
const struct sr_config_info *srci;
double tmp_double, dlow, dhigh;
uint64_t tmp_u64, p, q, low, high;
GVariant *rational[2], *range[2];
gboolean tmp_bool;
int ret;
if (!(srci = sr_config_info_name_get(key))) {
g_critical("Unknown device option '%s'.", (char *) key);
return -1;
}
src->key = srci->key;
if ((value == NULL) &&
(srci->datatype != SR_T_BOOL)) {
g_critical("Option '%s' needs a value.", (char *)key);
return -1;
}
ret = 0;
switch (srci->datatype) {
case SR_T_UINT64:
ret = sr_parse_sizestring(value, &tmp_u64);
if (ret != 0)
break;
src->data = g_variant_new_uint64(tmp_u64);
break;
case SR_T_INT32:
ret = sr_parse_sizestring(value, &tmp_u64);
if (ret != 0)
break;
src->data = g_variant_new_int32(tmp_u64);
break;
case SR_T_STRING:
src->data = g_variant_new_string(value);
break;
case SR_T_BOOL:
if (!value)
tmp_bool = TRUE;
else
tmp_bool = sr_parse_boolstring(value);
src->data = g_variant_new_boolean(tmp_bool);
break;
case SR_T_FLOAT:
tmp_double = strtof(value, NULL);
src->data = g_variant_new_double(tmp_double);
break;
case SR_T_RATIONAL_PERIOD:
if ((ret = sr_parse_period(value, &p, &q)) != SR_OK)
break;
rational[0] = g_variant_new_uint64(p);
rational[1] = g_variant_new_uint64(q);
src->data = g_variant_new_tuple(rational, 2);
break;
case SR_T_RATIONAL_VOLT:
if ((ret = sr_parse_voltage(value, &p, &q)) != SR_OK)
break;
rational[0] = g_variant_new_uint64(p);
rational[1] = g_variant_new_uint64(q);
src->data = g_variant_new_tuple(rational, 2);
break;
case SR_T_UINT64_RANGE:
if (sscanf(value, "%"PRIu64"-%"PRIu64, &low, &high) != 2) {
ret = -1;
break;
} else {
range[0] = g_variant_new_uint64(low);
range[1] = g_variant_new_uint64(high);
src->data = g_variant_new_tuple(range, 2);
}
break;
case SR_T_DOUBLE_RANGE:
if (sscanf(value, "%lf-%lf", &dlow, &dhigh) != 2) {
ret = -1;
break;
} else {
range[0] = g_variant_new_double(dlow);
range[1] = g_variant_new_double(dhigh);
src->data = g_variant_new_tuple(range, 2);
}
break;
default:
ret = -1;
}
return ret;
}
/* Parse VCD header to get values for context structure.
* The context structure should be zeroed before calling this.
*/
static gboolean parse_header(FILE *file, struct context *ctx)
{
uint64_t p, q;
gchar *name = NULL, *contents = NULL;
gboolean status = FALSE;
struct probe *probe;
while (parse_section(file, &name, &contents))
{
sr_dbg("Section '%s', contents '%s'.", name, contents);
if (g_strcmp0(name, "enddefinitions") == 0)
{
status = TRUE;
break;
}
else if (g_strcmp0(name, "timescale") == 0)
{
/* The standard allows for values 1, 10 or 100
* and units s, ms, us, ns, ps and fs. */
if (sr_parse_period(contents, &p, &q) == SR_OK)
{
ctx->samplerate = q / p;
if (q % p != 0)
{
/* Does not happen unless time value is non-standard */
sr_warn("Inexact rounding of samplerate, %" PRIu64 " / %" PRIu64 " to %" PRIu64 " Hz.",
q, p, ctx->samplerate);
}
sr_dbg("Samplerate: %" PRIu64, ctx->samplerate);
}
else
{
sr_err("Parsing timescale failed.");
}
}
else if (g_strcmp0(name, "var") == 0)
{
/* Format: $var type size identifier reference $end */
gchar **parts = g_strsplit_set(contents, " \r\n\t", 0);
remove_empty_parts(parts);
if (g_strv_length(parts) != 4)
{
sr_warn("$var section should have 4 items");
}
else if (g_strcmp0(parts[0], "reg") != 0 && g_strcmp0(parts[0], "wire") != 0)
{
sr_info("Unsupported signal type: '%s'", parts[0]);
}
else if (strtol(parts[1], NULL, 10) != 1)
{
sr_info("Unsupported signal size: '%s'", parts[1]);
}
else if (ctx->probecount >= ctx->maxprobes)
{
sr_warn("Skipping '%s' because only %d probes requested.", parts[3], ctx->maxprobes);
}
else
{
sr_info("Probe %d is '%s' identified by '%s'.", ctx->probecount, parts[3], parts[2]);
probe = g_malloc(sizeof(struct probe));
probe->identifier = g_strdup(parts[2]);
probe->name = g_strdup(parts[3]);
ctx->probes = g_slist_append(ctx->probes, probe);
ctx->probecount++;
}
g_strfreev(parts);
}
g_free(name); name = NULL;
g_free(contents); contents = NULL;
}
g_free(name);
g_free(contents);
return status;
}
static int set_dev_options(struct sr_dev *dev, GHashTable *args)
{
GHashTableIter iter;
gpointer key, value;
int ret, i;
float tmp_float;
uint64_t tmp_u64;
struct sr_rational tmp_rat;
gboolean tmp_bool;
gboolean found;
g_hash_table_iter_init(&iter, args);
while (g_hash_table_iter_next(&iter, &key, &value)) {
found = FALSE;
for (i = 0; sr_hwcap_options[i].hwcap; i++) {
if (strcmp(sr_hwcap_options[i].shortname, key))
continue;
if ((value == NULL) &&
(sr_hwcap_options[i].type != SR_T_BOOL)) {
g_critical("Option '%s' needs a value.", (char *)key);
return SR_ERR;
}
found = TRUE;
switch (sr_hwcap_options[i].type) {
case SR_T_UINT64:
ret = sr_parse_sizestring(value, &tmp_u64);
if (ret != SR_OK)
break;
ret = dev->driver->dev_config_set(dev->driver_index,
sr_hwcap_options[i].hwcap, &tmp_u64);
break;
case SR_T_CHAR:
ret = dev->driver->dev_config_set(dev->driver_index,
sr_hwcap_options[i].hwcap, value);
break;
case SR_T_BOOL:
if (!value)
tmp_bool = TRUE;
else
tmp_bool = sr_parse_boolstring(value);
ret = dev->driver->dev_config_set(dev->driver_index,
sr_hwcap_options[i].hwcap,
GINT_TO_POINTER(tmp_bool));
break;
case SR_T_FLOAT:
tmp_float = strtof(value, NULL);
ret = dev->driver->dev_config_set(dev->driver_index,
sr_hwcap_options[i].hwcap, &tmp_float);
break;
case SR_T_RATIONAL_PERIOD:
if ((ret = sr_parse_period(value, &tmp_rat)) != SR_OK)
break;
ret = dev->driver->dev_config_set(dev->driver_index,
sr_hwcap_options[i].hwcap, &tmp_rat);
break;
case SR_T_RATIONAL_VOLT:
if ((ret = sr_parse_voltage(value, &tmp_rat)) != SR_OK)
break;
ret = dev->driver->dev_config_set(dev->driver_index,
sr_hwcap_options[i].hwcap, &tmp_rat);
break;
default:
ret = SR_ERR;
}
if (ret != SR_OK) {
g_critical("Failed to set device option '%s'.", (char *)key);
return ret;
}
else
break;
}
if (!found) {
g_critical("Unknown device option '%s'.", (char *) key);
return SR_ERR;
}
}
return SR_OK;
}
