owl_variable *owl_variable_get_var(owl_vardict *d, char *name, int require_type) {
owl_variable *v;
if (!name) return(NULL);
v = owl_dict_find_element(d, name);
if (v == NULL || !v->get_fn || v->type != require_type) return(NULL);
return v;
}
int owl_variable_get_tostring(owl_vardict *d, char *name, char *buf, int bufsize) {
owl_variable *v;
if (!name) return(-1);
v = owl_dict_find_element(d, name);
if (v == NULL || !v->get_tostring_fn) return(-1);
return v->get_tostring_fn(v, buf, bufsize, v->val);
}
/* returns 0 on success, prints a status msg if msg is true */
int owl_variable_set_fromstring(owl_vardict *d, char *name, char *value, int msg, int requirebool) {
owl_variable *v;
char buff2[1024];
if (!name) return(-1);
v = owl_dict_find_element(d, name);
if (v == NULL) {
if (msg) owl_function_error("Unknown variable %s", name);
return -1;
}
if (!v->set_fromstring_fn) {
if (msg) owl_function_error("Variable %s is read-only", name);
return -1;
}
if (requirebool && v->type!=OWL_VARIABLE_BOOL) {
if (msg) owl_function_error("Variable %s is not a boolean", name);
return -1;
}
if (0 != v->set_fromstring_fn(v, value)) {
if (msg) owl_function_error("Unable to set %s (must be %s)", name,
owl_variable_get_validsettings(v));
return -1;
}
if (msg && v->get_tostring_fn) {
v->get_tostring_fn(v, buff2, 1024, v->val);
owl_function_makemsg("%s = '%s'", name, buff2);
}
return 0;
}
int owl_variable_set_int(owl_vardict *d, char *name, int newval) {
owl_variable *v;
if (!name) return(-1);
v = owl_dict_find_element(d, name);
if (v == NULL || !v->set_fn) return(-1);
if (v->type!=OWL_VARIABLE_INT && v->type!=OWL_VARIABLE_BOOL) return(-1);
return v->set_fn(v, &newval);
}
int owl_variable_set_string(owl_vardict *d, char *name, char *newval) {
owl_variable *v;
if (!name) return(-1);
v = owl_dict_find_element(d, name);
if (v == NULL || !v->set_fn) return(-1);
if (v->type!=OWL_VARIABLE_STRING) return(-1);
return v->set_fn(v, (void*)newval);
}
/* sets the active keymap, which will also reset any key state.
* returns the new keymap, or NULL on failure. */
const owl_keymap *owl_keyhandler_activate(owl_keyhandler *kh, const char *mapname)
{
const owl_keymap *km;
if (kh->active && !strcmp(mapname, kh->active->name)) return(kh->active);
km = owl_dict_find_element(&kh->keymaps, mapname);
if (!km) return(NULL);
owl_keyhandler_reset(kh);
kh->active = km;
return(km);
}
int owl_variable_get_default_tostring(owl_vardict *d, char *name, char *buf, int bufsize) {
owl_variable *v;
if (!name) return(-1);
v = owl_dict_find_element(d, name);
if (v == NULL || !v->get_tostring_fn) return(-1);
if (v->type == OWL_VARIABLE_INT || v->type == OWL_VARIABLE_BOOL) {
return v->get_tostring_fn(v, buf, bufsize, &(v->ival_default));
} else {
return v->get_tostring_fn(v, buf, bufsize, v->pval_default);
}
}
/* caller must free the return */
CALLER_OWN char *_owl_cmddict_execute(const owl_cmddict *cd, const owl_context *ctx, const char *const *argv, int argc, const char *buff)
{
char *retval = NULL;
const owl_cmd *cmd;
if (!strcmp(argv[0], "")) {
} else if (NULL != (cmd = owl_dict_find_element(cd, argv[0]))) {
retval = owl_cmd_execute(cmd, cd, ctx, argc, argv, buff);
/* redraw the sepbar; TODO: don't violate layering */
owl_global_sepbar_dirty(&g);
} else {
owl_function_makemsg("Unknown command '%s'.", buff);
}
return retval;
}
void owl_cmd_get_help(const owl_cmddict *d, const char *name, owl_fmtext *fm) {
const char *s;
char *indent;
owl_cmd *cmd;
if (!name || (cmd = owl_dict_find_element(d, name)) == NULL) {
owl_fmtext_append_bold(fm, "OWL HELP\n\n");
owl_fmtext_append_normal(fm, "No such command...\n");
return;
}
owl_fmtext_append_bold(fm, "OWL HELP\n\n");
owl_fmtext_append_bold(fm, "NAME\n\n");
owl_fmtext_append_normal(fm, OWL_TABSTR);
owl_fmtext_append_normal(fm, cmd->name);
if (cmd->summary && *cmd->summary) {
owl_fmtext_append_normal(fm, " - ");
owl_fmtext_append_normal(fm, cmd->summary);
}
owl_fmtext_append_normal(fm, "\n");
if (cmd->usage && *cmd->usage) {
s = cmd->usage;
indent = owl_text_indent(s, OWL_TAB, true);
owl_fmtext_append_bold(fm, "\nSYNOPSIS\n");
owl_fmtext_append_normal(fm, indent);
owl_fmtext_append_normal(fm, "\n");
g_free(indent);
} else {
owl_fmtext_append_bold(fm, "\nSYNOPSIS\n");
owl_fmtext_append_normal(fm, OWL_TABSTR);
owl_fmtext_append_normal(fm, cmd->name);
owl_fmtext_append_normal(fm, "\n");
}
if (cmd->description && *cmd->description) {
s = cmd->description;
indent = owl_text_indent(s, OWL_TAB, true);
owl_fmtext_append_bold(fm, "\nDESCRIPTION\n");
owl_fmtext_append_normal(fm, indent);
owl_fmtext_append_normal(fm, "\n");
g_free(indent);
}
owl_fmtext_append_normal(fm, "\n\n");
}
void owl_variable_get_help(owl_vardict *d, char *name, owl_fmtext *fm) {
char buff[1024];
int bufflen = 1023;
owl_variable *v;
if (!name
|| (v = owl_dict_find_element(d, name)) == NULL
|| !v->get_fn) {
owl_fmtext_append_normal(fm, "No such variable...\n");
return;
}
owl_fmtext_append_bold(fm, "OWL VARIABLE\n\n");
owl_fmtext_append_normal(fm, OWL_TABSTR);
owl_fmtext_append_normal(fm, name);
owl_fmtext_append_normal(fm, " - ");
owl_fmtext_append_normal(fm, v->summary);
owl_fmtext_append_normal(fm, "\n\n");
owl_fmtext_append_normal(fm, "Current: ");
owl_variable_get_tostring(d, name, buff, bufflen);
owl_fmtext_append_normal(fm, buff);
owl_fmtext_append_normal(fm, "\n\n");
if (v->type == OWL_VARIABLE_INT || v->type == OWL_VARIABLE_BOOL) {
v->get_tostring_fn(v, buff, bufflen, &(v->ival_default));
} else {
v->get_tostring_fn(v, buff, bufflen, v->pval_default);
}
owl_fmtext_append_normal(fm, "Default: ");
owl_fmtext_append_normal(fm, buff);
owl_fmtext_append_normal(fm, "\n\n");
owl_fmtext_append_normal(fm, "Valid Settings: ");
owl_fmtext_append_normal(fm, owl_variable_get_validsettings(v));
owl_fmtext_append_normal(fm, "\n\n");
if (v->description && *v->description) {
owl_fmtext_append_normal(fm, "Description:\n");
owl_fmtext_append_normal(fm, owl_variable_get_description(v));
owl_fmtext_append_normal(fm, "\n\n");
}
}
HV *owl_new_hv(const owl_dict *d, SV *(*to_sv)(const void *))
{
HV *ret;
owl_list l;
const char *key;
void *element;
int i;
ret = newHV();
/* TODO: add an iterator-like interface to owl_dict */
owl_dict_get_keys(d, &l);
for (i = 0; i < owl_list_get_size(&l); i++) {
key = owl_list_get_element(&l, i);
element = owl_dict_find_element(d, key);
(void)hv_store(ret, key, strlen(key), to_sv(element), 0);
}
owl_list_cleanup(&l, owl_free);
return ret;
}
CALLER_OWN HV *owl_new_hv(const owl_dict *d, SV *(*to_sv)(const void *))
{
HV *ret;
GPtrArray *keys;
const char *key;
void *element;
int i;
ret = newHV();
/* TODO: add an iterator-like interface to owl_dict */
keys = owl_dict_get_keys(d);
for (i = 0; i < keys->len; i++) {
key = keys->pdata[i];
element = owl_dict_find_element(d, key);
(void)hv_store(ret, key, strlen(key), to_sv(element), 0);
}
owl_ptr_array_free(keys, g_free);
return ret;
}
void owl_variable_describe(owl_vardict *d, char *name, owl_fmtext *fm) {
char defaultbuf[50];
char buf[1024];
int buflen = 1023;
owl_variable *v;
if (!name
|| (v = owl_dict_find_element(d, name)) == NULL
|| !v->get_fn) {
snprintf(buf, buflen, " No such variable '%s'\n", name);
owl_fmtext_append_normal(fm, buf);
return;
}
if (v->type == OWL_VARIABLE_INT || v->type == OWL_VARIABLE_BOOL) {
v->get_tostring_fn(v, defaultbuf, 50, &(v->ival_default));
} else {
v->get_tostring_fn(v, defaultbuf, 50, v->pval_default);
}
snprintf(buf, buflen, OWL_TABSTR "%-20s - %s (default: '%s')\n",
v->name,
owl_variable_get_summary(v), defaultbuf);
owl_fmtext_append_normal(fm, buf);
}
int owl_dict_regtest(void) {
owl_dict d;
owl_list l;
int numfailed=0;
char *av="aval", *bv="bval", *cv="cval", *dv="dval";
printf("# BEGIN testing owl_dict\n");
FAIL_UNLESS("create", 0==owl_dict_create(&d));
FAIL_UNLESS("insert b", 0==owl_dict_insert_element(&d, "b", bv, owl_dict_noop_delete));
FAIL_UNLESS("insert d", 0==owl_dict_insert_element(&d, "d", dv, owl_dict_noop_delete));
FAIL_UNLESS("insert a", 0==owl_dict_insert_element(&d, "a", av, owl_dict_noop_delete));
FAIL_UNLESS("insert c", 0==owl_dict_insert_element(&d, "c", cv, owl_dict_noop_delete));
FAIL_UNLESS("reinsert d (no replace)", -2==owl_dict_insert_element(&d, "d", dv, 0));
FAIL_UNLESS("find a", av==owl_dict_find_element(&d, "a"));
FAIL_UNLESS("find b", bv==owl_dict_find_element(&d, "b"));
FAIL_UNLESS("find c", cv==owl_dict_find_element(&d, "c"));
FAIL_UNLESS("find d", dv==owl_dict_find_element(&d, "d"));
FAIL_UNLESS("find e (non-existent)", NULL==owl_dict_find_element(&d, "e"));
FAIL_UNLESS("remove d", dv==owl_dict_remove_element(&d, "d"));
FAIL_UNLESS("find d (post-removal)", NULL==owl_dict_find_element(&d, "d"));
FAIL_UNLESS("get_size", 3==owl_dict_get_size(&d));
FAIL_UNLESS("get_keys", 0==owl_dict_get_keys(&d, &l));
FAIL_UNLESS("get_keys result size", 3==owl_list_get_size(&l));
/* these assume the returned keys are sorted */
FAIL_UNLESS("get_keys result val",0==strcmp("a",owl_list_get_element(&l,0)));
FAIL_UNLESS("get_keys result val",0==strcmp("b",owl_list_get_element(&l,1)));
FAIL_UNLESS("get_keys result val",0==strcmp("c",owl_list_get_element(&l,2)));
owl_list_cleanup(&l, owl_free);
owl_dict_cleanup(&d, NULL);
/* if (numfailed) printf("*** WARNING: failures encountered with owl_dict\n"); */
printf("# END testing owl_dict (%d failures)\n", numfailed);
return(numfailed);
}
owl_variable *owl_variable_get_var(const owl_vardict *d, const char *name)
{
return owl_dict_find_element(d, name);
}
/* Return the style with name 'name'. If it does not exist return
* NULL */
const owl_style *owl_global_get_style_by_name(const owl_global *g, const char *name)
{
return owl_dict_find_element(&(g->styledict), name);
}
owl_filter *owl_global_get_filter(const owl_global *g, const char *name) {
owl_global_filter_ent *e = owl_dict_find_element(&(g->filters), name);
if (e) return e->f;
return NULL;
}
const owl_cmd *owl_cmddict_find(const owl_cmddict *d, const char *name) {
return owl_dict_find_element(d, name);
}
owl_keymap *owl_keyhandler_get_keymap(const owl_keyhandler *kh, const char *mapname)
{
return owl_dict_find_element(&kh->keymaps, mapname);
}
