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); }