static int _get_value(Tcl_Interp *interp, jackctl_parameter_t *parameter, Tcl_Obj *value, union jackctl_parameter_value *result) {
switch (jackctl_parameter_get_type(parameter)) {
case JackParamInt: return Tcl_GetIntFromObj(interp, value, &result->i);
case JackParamUInt: return Tcl_GetIntFromObj(interp, value, &result->ui);
case JackParamChar: {
int length;
result->c = *Tcl_GetStringFromObj(value, &length);
if (length == 1)
return TCL_OK;
return fw_error_str(interp, "character parameter is not one character long");
}
case JackParamString: {
int length;
strncpy(result->str, Tcl_GetStringFromObj(value, &length), JACK_PARAM_STRING_MAX);
if (length <= JACK_PARAM_STRING_MAX)
return TCL_OK;
return fw_error_str(interp, "string parameter is too long");
}
case JackParamBool: {
int b;
if (Tcl_GetBooleanFromObj(interp, value, &b) != TCL_OK)
return TCL_ERROR;
result->b = b;
return TCL_OK;
}
}
return fw_error_obj(interp, Tcl_ObjPrintf("unknown type %d returned by jackctl_parameter_get_type", jackctl_parameter_get_type(parameter)));
}
// jackctl_param_type_t jackctl_parameter_get_type(jackctl_parameter_t * parameter);
static int _parameter_get_type(ClientData clientData, Tcl_Interp *interp, int argc, Tcl_Obj* const *objv) {
if (argc != 3) return fw_error_str(interp, "usage: jack-ctl parameter-get-type parameter");
jackctl_parameter_t * parameter;
if (_get_pointer(interp, objv[2], (void**)¶meter) != TCL_OK)
return TCL_ERROR;
return _return_string(interp, jack_parameter_types[jackctl_parameter_get_type(parameter)]);
}
static Tcl_Obj *_make_value(jackctl_parameter_t *parameter, union jackctl_parameter_value value) {
switch (jackctl_parameter_get_type(parameter)) {
case JackParamInt: return Tcl_NewIntObj(value.i);
case JackParamUInt: return Tcl_NewIntObj(value.ui);
case JackParamChar: return Tcl_NewStringObj(&value.c, 1);
case JackParamString: return Tcl_NewStringObj(value.str, -1);
case JackParamBool: return Tcl_NewBooleanObj(value.b);
default: return Tcl_ObjPrintf("unknown type %d returned by jackctl_parameter_get_type", jackctl_parameter_get_type(parameter));
}
}
static void print_parameters(const JSList * node_ptr)
{
while (node_ptr != NULL) {
jackctl_parameter_t * parameter = (jackctl_parameter_t *)node_ptr->data;
printf("\nparameter name = %s\n", jackctl_parameter_get_name(parameter));
printf("parameter id = %c\n", jackctl_parameter_get_id(parameter));
printf("parameter short decs = %s\n", jackctl_parameter_get_short_description(parameter));
printf("parameter long decs = %s\n", jackctl_parameter_get_long_description(parameter));
print_value(jackctl_parameter_get_default_value(parameter), jackctl_parameter_get_type(parameter));
node_ptr = jack_slist_next(node_ptr);
}
}
EXPORT int
jackctl_parse_driver_params (jackctl_driver *driver_ptr, int argc, char* argv[])
{
struct option * long_options;
char * options, * options_ptr;
unsigned long i;
int opt;
JSList * node_ptr;
jackctl_parameter_t * param = NULL;
union jackctl_parameter_value value;
if (argc <= 1)
return 0;
const JSList * driver_params = jackctl_driver_get_parameters(driver_ptr);
if (driver_params == NULL)
return 1;
jack_driver_desc_t * desc = jackctl_driver_get_desc(driver_ptr);
/* check for help */
if (strcmp (argv[1], "-h") == 0 || strcmp (argv[1], "--help") == 0) {
if (argc > 2) {
for (i = 0; i < desc->nparams; i++) {
if (strcmp (desc->params[i].name, argv[2]) == 0) {
jack_print_driver_param_usage (desc, i, stdout);
return 1;
}
}
fprintf (stderr, "jackd: unknown option '%s' "
"for driver '%s'\n", argv[2],
desc->name);
}
jack_log("Parameters for driver '%s' (all parameters are optional):", desc->name);
jack_print_driver_options (desc, stdout);
return 1;
}
/* set up the stuff for getopt */
options = (char*)calloc (desc->nparams * 3 + 1, sizeof (char));
long_options = (option*)calloc (desc->nparams + 1, sizeof (struct option));
options_ptr = options;
for (i = 0; i < desc->nparams; i++) {
sprintf (options_ptr, "%c::", desc->params[i].character);
options_ptr += 3;
long_options[i].name = desc->params[i].name;
long_options[i].flag = NULL;
long_options[i].val = desc->params[i].character;
long_options[i].has_arg = optional_argument;
}
/* create the params */
optind = 0;
opterr = 0;
while ((opt = getopt_long(argc, argv, options, long_options, NULL)) != -1) {
if (opt == ':' || opt == '?') {
if (opt == ':') {
fprintf (stderr, "Missing option to argument '%c'\n", optopt);
} else {
fprintf (stderr, "Unknownage with option '%c'\n", optopt);
}
fprintf (stderr, "Options for driver '%s':\n", desc->name);
jack_print_driver_options(desc, stderr);
return 1;
}
node_ptr = (JSList *)driver_params;
while (node_ptr) {
param = (jackctl_parameter_t*)node_ptr->data;
if (opt == jackctl_parameter_get_id(param)) {
break;
}
node_ptr = node_ptr->next;
}
if (!optarg && optind < argc &&
strlen(argv[optind]) &&
argv[optind][0] != '-') {
optarg = argv[optind];
}
if (optarg) {
switch (jackctl_parameter_get_type(param)) {
case JackDriverParamInt:
value.i = atoi (optarg);
jackctl_parameter_set_value(param, &value);
break;
case JackDriverParamUInt:
value.ui = strtoul (optarg, NULL, 10);
jackctl_parameter_set_value(param, &value);
break;
case JackDriverParamChar:
value.c = optarg[0];
jackctl_parameter_set_value(param, &value);
break;
case JackDriverParamString:
strncpy (value.str, optarg, JACK_DRIVER_PARAM_STRING_MAX);
jackctl_parameter_set_value(param, &value);
break;
case JackDriverParamBool:
/*
if (strcasecmp ("false", optarg) == 0 ||
strcasecmp ("off", optarg) == 0 ||
strcasecmp ("no", optarg) == 0 ||
strcasecmp ("0", optarg) == 0 ||
strcasecmp ("(null)", optarg) == 0 ) {
*/
// steph
if (strcmp ("false", optarg) == 0 ||
strcmp ("off", optarg) == 0 ||
strcmp ("no", optarg) == 0 ||
strcmp ("0", optarg) == 0 ||
strcmp ("(null)", optarg) == 0 ) {
value.i = false;
} else {
value.i = true;
}
jackctl_parameter_set_value(param, &value);
break;
}
} else {
if (jackctl_parameter_get_type(param) == JackParamBool) {
value.i = true;
} else {
value = jackctl_parameter_get_default_value(param);
}
jackctl_parameter_set_value(param, &value);
}
}
free(options);
free(long_options);
return 0;
}
