static package
bf_make(Var arglist, Byte next, void *vdata, Objid progr)
{
Var ret, elt;
int n=arglist.v.list[1].v.num, i;
if(n < 0) {
free_var(arglist);
make_error_pack(E_INVARG);
}
ret = new_list(n);
InitListToZero(ret);
if(arglist.v.list[0].v.num == 2) {
elt = var_dup(arglist.v.list[2]);
} else {
elt.type = TYPE_INT;
elt.v.num = 0;
}
for(i = 1; i <= n; i++)
ret.v.list[i] = var_dup(elt);
free_var(elt);
free_var(arglist);
return make_var_pack(ret);
}
static package
bf_slice(Var arglist, Byte next, void *vdata, Objid progr)
{
Var ret, list=arglist.v.list[1];
int n=list.v.list[0].v.num, c, i;
if(n < 0) {
free_var(arglist);
make_error_pack(E_INVARG);
}
ret = new_list(n);
InitListToZero(ret);
if(arglist.v.list[0].v.num == 2)
c = arglist.v.list[2].v.num;
else
c = 1;
for(i = 1; i <= n; i++)
if( list.v.list[i].type != TYPE_LIST || list.v.list[i].v.list[0].v.num < c ) {
free_var(ret);
free_var(arglist);
return make_error_pack(E_INVARG);
} else {
ret.v.list[i] = var_dup(list.v.list[i].v.list[c]);
}
free_var(arglist);
return make_var_pack(ret);
}
static package bf_mysql_escape( Var arglist, Byte next, void *vdata, Objid progr)
{
Var r;
MYSQL_CONN *wrapper;
if (!is_wizard(progr))
{
free_var(arglist);
return make_error_pack(E_PERM);
}
Objid oid = arglist.v.list[1].v.obj;
wrapper = resolve_mysql_connection(oid);
if (wrapper == NULL || wrapper->conn == NULL || wrapper->active == 0)
{
free_var(arglist);
return make_error_pack(E_INVARG);
}
const char *string = arglist.v.list[2].v.str;
free_var(arglist);
ulong bytes = strlen(string);
char ostring[(2 * bytes)+1];
mysql_real_escape_string(wrapper->conn,ostring,string,bytes);
r.type = TYPE_STR;
r.v.str = str_dup(ostring);
return make_var_pack(r);
}
static package
bf_set_verb_args(Var arglist, Byte next, void *vdata, Objid progr)
{ /* (object, verb-desc, {dobj, prep, iobj}) */
Objid oid = arglist.v.list[1].v.obj;
Var desc = arglist.v.list[2];
Var args = arglist.v.list[3];
enum error e;
db_verb_handle h;
db_arg_spec dobj, iobj;
db_prep_spec prep;
if ((e = validate_verb_descriptor(desc)) != E_NONE); /* Do nothing; e is already set. */
else if (!valid(oid))
e = E_INVARG;
else
e = validate_verb_args(args, &dobj, &prep, &iobj);
if (e != E_NONE) {
free_var(arglist);
return make_error_pack(e);
}
h = find_described_verb(oid, desc);
free_var(arglist);
if (!h.ptr)
return make_error_pack(E_VERBNF);
else if (!db_verb_allows(h, progr, VF_WRITE))
return make_error_pack(E_PERM);
db_set_verb_arg_specs(h, dobj, prep, iobj);
return no_var_pack();
}
static package
bf_verb_args(Var arglist, Byte next, void *vdata, Objid progr)
{ /* (object, verb-desc) */
Objid oid = arglist.v.list[1].v.obj;
Var desc = arglist.v.list[2];
db_verb_handle h;
db_arg_spec dobj, iobj;
db_prep_spec prep;
Var r;
enum error e;
if ((e = validate_verb_descriptor(desc)) != E_NONE
|| (e = E_INVARG, !valid(oid))) {
free_var(arglist);
return make_error_pack(e);
}
h = find_described_verb(oid, desc);
free_var(arglist);
if (!h.ptr)
return make_error_pack(E_VERBNF);
else if (!db_verb_allows(h, progr, VF_READ))
return make_error_pack(E_PERM);
db_verb_arg_specs(h, &dobj, &prep, &iobj);
r = new_list(3);
r.v.list[1].type = TYPE_STR;
r.v.list[1].v.str = unparse_arg_spec(dobj);
r.v.list[2].type = TYPE_STR;
r.v.list[2].v.str = str_dup(db_unparse_prep(prep));
r.v.list[3].type = TYPE_STR;
r.v.list[3].v.str = unparse_arg_spec(iobj);
return make_var_pack(r);
}
static package
bf_has_callable_verb(Var arglist, Byte next, void *vdata, Objid progr)
{ /* (object) */
Objid oid = arglist.v.list[1].v.obj;
if (!valid(oid)) {
free_var(arglist);
return make_error_pack(E_INVARG);
} else if (!db_object_allows(oid, progr, FLAG_READ)) {
free_var(arglist);
return make_error_pack(E_PERM);
} else {
db_verb_handle vh;
Var result;
vh = db_find_callable_verb(oid, arglist.v.list[2].v.str);
if (vh.ptr) {
result = new_list(1);
result.v.list[1].type = TYPE_OBJ;
result.v.list[1].v.obj = db_verb_definer(vh);
} else {
result = new_list(0);
}
free_var(arglist);
return make_var_pack(result);
}
}
static package
bf_verb_code(Var arglist, Byte next, void *vdata, Objid progr)
{ /* (object, verb-desc [, fully-paren [, indent]]) */
int nargs = arglist.v.list[0].v.num;
Objid oid = arglist.v.list[1].v.obj;
Var desc = arglist.v.list[2];
int parens = nargs >= 3 && is_true(arglist.v.list[3]);
int indent = nargs < 4 || is_true(arglist.v.list[4]);
db_verb_handle h;
Var code;
enum error e;
if ((e = validate_verb_descriptor(desc)) != E_NONE
|| (e = E_INVARG, !valid(oid))) {
free_var(arglist);
return make_error_pack(e);
}
h = find_described_verb(oid, desc);
free_var(arglist);
if (!h.ptr)
return make_error_pack(E_VERBNF);
else if (!db_verb_allows(h, progr, VF_READ))
return make_error_pack(E_PERM);
code = new_list(0);
unparse_program(db_verb_program(h), lister, &code, parens, indent,
MAIN_VECTOR);
return make_var_pack(code);
}
void gui_setFileSelectionBoxPseudoResources(Widget widget, Var* dvStruct, Narray* publicResources)
{
int i, cont;
char* name;
Var* value;
#if DEBUG
fprintf(stderr,
"DEBUG: gui_setFileSelectionBoxPseudoResources(widget = %ld, "
"dvStruct = %ld, publicResources = %ld)\n",
widget, dvStruct, publicResources);
#endif
/* Iterate over the struct, extracting any pseudo-resource items that
* we set. Delete the items from the struct, and start iterating at the
* beginning again. This is not really efficient, but I'm not sure how
* else to do it without mucking about with Davinci's structures more than
* I'd like to, or keeping track of what has/hasn't been set.
*/
cont = 1;
while (cont && get_struct_count(dvStruct)) {
cont = 0;
for (i = 0; i < get_struct_count(dvStruct); i++) {
get_struct_element(dvStruct, i, &name, &value);
if (!strcmp(name, "dirListItemCount")) {
/* Extrapolated from dirListItems. */
parse_error("WARNING: ignoring dirListItemCount");
free_var(Narray_delete(V_STRUCT(dvStruct), "dirListItemCount"));
cont = 1;
break;
}
if (!strcmp(name, "fileListItemCount")) {
/* Extrapolated from fileListItems. */
parse_error("WARNING: ignoring fileListItemCount");
free_var(Narray_delete(V_STRUCT(dvStruct), "fileListItemCount"));
cont = 1;
break;
}
if (!strcmp(name, "dirListItems")) {
setItems(widget, name, "dirListItemCount", value);
free_var(Narray_delete(V_STRUCT(dvStruct), "dirListItems"));
Narray_add(publicResources, name, NULL);
cont = 1;
break;
}
if (!strcmp(name, "fileListItems")) {
setItems(widget, name, "fileListItemCount", value);
free_var(Narray_delete(V_STRUCT(dvStruct), "fileListItems"));
Narray_add(publicResources, name, NULL);
cont = 1;
break;
}
/* ...new comparisons go here. */
}
}
}
static package
bf_mysql_connect(Var arglist, Byte next, void *vdata, Objid progr)
{
#ifdef OUTBOUND_NETWORK
Var r;
char error_string[MOOSQL_ERROR_LEN];
MYSQL_CONN *wrapper;
if (!is_wizard(progr))
{
free_var(arglist);
return make_error_pack(E_PERM);
}
const char *hostname = arglist.v.list[1].v.str;
const int port = arglist.v.list[2].v.num;
const char *username = arglist.v.list[3].v.str;
const char *password = arglist.v.list[4].v.str;
const char *dbname = arglist.v.list[5].v.str;
free_var(arglist); /* get rid of that now */
/* try to connect to mysql server */
/* check if we have enough connection slots. */
int index=-1;
index = connection_array_index();
if (index == -1)
return make_error_pack(E_QUOTA);
#ifdef MOOSQL_MULTIPLE_STATEMENTS
wrapper = do_mysql_connect(hostname, username, password, dbname, port, NULL, CLIENT_MULTI_STATEMENTS, error_string);
#else
wrapper = do_mysql_connect(hostname, username, password, dbname, port, NULL, 0, error_string);
#endif
if (wrapper == NULL || wrapper->conn == NULL)
{
/* an error happened in the connect, return that as a STR */
r.type = TYPE_STR;
r.v.str = str_dup(error_string);
return make_var_pack(r);
}
r.type = TYPE_OBJ;
r.v.obj = wrapper->id;
return make_var_pack(r);
#else /* !OUTBOUND_NETWORK */
/* This function is disabled in this server. */
free_var(arglist);
return make_error_pack(E_PERM);
#endif
}
static package bf_mysql_status(Var arglist, Byte next, void *vdata, Objid progr)
{
Var r;
Objid oid = arglist.v.list[1].v.obj;
free_var(arglist);
if (!is_wizard(progr))
return make_error_pack(E_PERM);
MYSQL_CONN *wrapper;
wrapper = resolve_mysql_connection(oid);
if (wrapper == NULL || wrapper->active == 0)
return make_error_pack(E_INVARG);
r = new_list(7);
r.v.list[1].type = TYPE_STR;
r.v.list[1].v.str = str_dup(wrapper->server);
r.v.list[2].type = TYPE_INT;
r.v.list[2].v.num = wrapper->port;
r.v.list[3].type = TYPE_STR;
r.v.list[3].v.str = str_dup(wrapper->username);
r.v.list[4].type = TYPE_STR;
r.v.list[4].v.str = str_dup(wrapper->database);
r.v.list[5].type = TYPE_INT;
r.v.list[5].v.num = wrapper->connect_time;
r.v.list[6].type = TYPE_INT;
r.v.list[6].v.num = wrapper->last_query_time;
r.v.list[7].type = TYPE_INT;
r.v.list[7].v.num = mysql_get_server_version(wrapper->conn);
return make_var_pack(r);
}
static package
bf_parse_xml_tree(Var arglist, Byte next, void *vdata, Objid progr)
{
package result = parse_xml(arglist.v.list[1].v.str, 0);
free_var(arglist);
return result;
}
static package
bf_clear_prop(Var arglist, Byte next, void *vdata, Objid progr)
{ /* (object, prop-name) */
Objid oid = arglist.v.list[1].v.obj;
const char *pname = arglist.v.list[2].v.str;
db_prop_handle h;
Var value;
enum error e;
if (!valid(oid))
e = E_INVARG;
else {
h = db_find_property(oid, pname, 0);
if (!h.ptr)
e = E_PROPNF;
else if (h.built_in
|| (progr != db_property_owner(h) && !is_wizard(progr)))
e = E_PERM;
else if (h.definer == oid)
e = E_INVARG;
else {
value.type = TYPE_CLEAR;
db_set_property_value(h, value);
e = E_NONE;
}
}
free_var(arglist);
if (e == E_NONE)
return no_var_pack();
else
return make_error_pack(e);
}
static package
bf_is_clear_prop(Var arglist, Byte next, void *vdata, Objid progr)
{ /* (object, prop-name) */
Objid oid = arglist.v.list[1].v.obj;
const char *pname = arglist.v.list[2].v.str;
Var r;
db_prop_handle h;
enum error e;
if (!valid(oid))
e = E_INVARG;
else {
h = db_find_property(oid, pname, 0);
if (!h.ptr)
e = E_PROPNF;
else if (!h.built_in && !db_property_allows(h, progr, PF_READ))
e = E_PERM;
else {
r.type = TYPE_INT;
r.v.num = (!h.built_in && db_property_value(h).type == TYPE_CLEAR);
e = E_NONE;
}
}
free_var(arglist);
if (e == E_NONE)
return make_var_pack(r);
else
return make_error_pack(e);
}
static variable_t *
free_var(variable_t *var) {
variable_t *next = var->next;
/* free name */
if (var->name) {
free((void*)var->name);
var->name = NULL;
}
/* free values */
switch(var->type) {
case VT_NUMBER:
break;
case VT_STRING:
free((void*)var->str);
var->str = NULL;
break;
case VT_LISTITEM:
{
/* free subitems in listitem */
variable_t *v;
for (v=var->items; v; v = free_var(v))
;
var->items = NULL;
}
break;
}
free((void*)var);
return next;
}
int find_insert(Var lst, Var key) {
/* find_insert(sortedlist,key) => index of first element in sortedlist
> key. sortedlist is assumed to bem sorted in increasing order and
the number returned is anywhere from 1 to length(sortedlist)+1,
inclusive. */
/* returns -10 if an E_TYPE occurs */
Var compare;
int r = lst.v.list[0].v.num, l=1, i;
while(r >= l) {
compare = value_compare(var_ref(key), var_ref(lst.v.list[i = ((r + l) / 2)] ) );
if(compare.type == TYPE_ERR) {
free_var(compare);
return -10;
}
if(compare.v.num < 0) {
r = i - 1;
} else {
l = i + 1;
}
}
return l;
}
void
free_program(Program * p)
{
unsigned i;
p->ref_count--;
if (p->ref_count == 0) {
for (i = 0; i < p->num_literals; i++)
/* can't be a list--strings and floats need to be freed, though. */
free_var(p->literals[i]);
if (p->literals)
myfree(p->literals, M_LIT_LIST);
for (i = 0; i < p->fork_vectors_size; i++)
myfree(p->fork_vectors[i].vector, M_BYTECODES);
if (p->fork_vectors_size)
myfree(p->fork_vectors, M_FORK_VECTORS);
for (i = 0; i < p->num_var_names; i++)
free_str(p->var_names[i]);
myfree(p->var_names, M_NAMES);
myfree(p->main_vector.vector, M_BYTECODES);
myfree(p, M_PROGRAM);
}
}
Var* saito_grassfire(Var* input, int ignore)
{
// Euclidian distance computation
size_t dx = GetX(input);
size_t dy = GetY(input);
Var* sdt_x = newVal(BSQ, dx, dy, 1, DV_INT32, calloc(dx * dy, sizeof(int)));
if (sdt_x == NULL) {
parse_error("Unable to allocate memory.");
return (NULL);
}
Var* sdt_xy = newVal(BSQ, dx, dy, 1, DV_INT32, calloc(dx * dy, sizeof(int)));
if (sdt_xy == NULL) {
parse_error("Unable to allocate memory.");
free(sdt_x);
return (NULL);
}
phaseSaitoX(input, ignore, sdt_x);
phaseSaitoY(sdt_x, sdt_xy);
phaseSaitoZ(sdt_xy, sdt_x); // We reuse sdt_x to store the final result!!
mem_claim(sdt_xy);
free_var(sdt_xy);
return (sdt_x);
}
static package
bf_add_verb(Var arglist, Byte next, void *vdata, Objid progr)
{ /* (object, info, args) */
Objid oid = arglist.v.list[1].v.obj;
Var info = arglist.v.list[2];
Var args = arglist.v.list[3];
Objid owner;
unsigned flags;
const char *names;
db_arg_spec dobj, iobj;
db_prep_spec prep;
enum error e;
if ((e = validate_verb_info(info, &owner, &flags, &names)) != E_NONE); /* Already failed */
else if ((e = validate_verb_args(args, &dobj, &prep, &iobj)) != E_NONE)
free_str(names);
else if (!valid(oid)) {
free_str(names);
e = E_INVARG;
} else if (!db_object_allows(oid, progr, FLAG_WRITE)
|| (progr != owner && !is_wizard(progr))) {
free_str(names);
e = E_PERM;
} else
db_add_verb(oid, names, owner, flags, dobj, prep, iobj);
free_var(arglist);
if (e == E_NONE)
return no_var_pack();
else
return make_error_pack(e);
}
Program *
null_program(void)
{
static Program *p = 0;
Var code, errors;
if (!p) {
code = new_list(0);
p = parse_list_as_program(code, &errors);
if (!p)
panic("Can't create the null program!");
free_var(code);
free_var(errors);
}
return p;
}
static package bf_mysql_close(Var arglist, Byte next, void *vdata, Objid progr)
{
Var r;
Objid oid = arglist.v.list[1].v.obj;
r.type = TYPE_INT;
free_var(arglist);
MYSQL_CONN *wrapper;
if (!is_wizard(progr))
return make_error_pack(E_PERM);
wrapper = resolve_mysql_connection(oid);
if (wrapper == NULL)
{
r.v.num = 0;
return make_var_pack(r);
}
else
{
wrapper->active = 0;
wrapper->id = 0;
wrapper->port = 0;
wrapper->connect_time = 0;
wrapper->last_query_time = 0;
r.v.num = 1;
}
if (mysql_connection_status(wrapper) != 0)
{
do_mysql_disconnect(wrapper);
wrapper->conn = NULL;
r.v.num = 1;
}
return make_var_pack(r);
}
/*
** Implementation of ff_unload_dv_module() above.
*/
int unload_dv_module(char* module_name)
{
Var* v;
/* v = get_global_sym(module_name); */
v = search_in_list_of_loaded_modules(module_name);
if (v) {
if (VERBOSE) {
parse_error("Unloading module %s.", module_name);
}
/*
** Print module dependencies. So that the user knows
** that unloding this module can cause problems.
*/
print_dependents(module_name);
/*
** free_var() bounces back to ff_modules.c::del_module() above
** where uninit_dv_module() is called.
*/
free_var(v);
} else {
parse_error("Module %s is not loaded. So, it cannot be unloaded.", module_name);
}
return 1;
}
static package
bf_delete_verb(Var arglist, Byte next, void *vdata, Objid progr)
{ /* (object, verb-desc) */
Objid oid = arglist.v.list[1].v.obj;
Var desc = arglist.v.list[2];
db_verb_handle h;
enum error e;
if ((e = validate_verb_descriptor(desc)) != E_NONE); /* Do nothing; e is already set. */
else if (!valid(oid))
e = E_INVARG;
else if (!db_object_allows(oid, progr, FLAG_WRITE))
e = E_PERM;
else {
h = find_described_verb(oid, desc);
if (h.ptr)
db_delete_verb(h);
else
e = E_VERBNF;
}
free_var(arglist);
if (e == E_NONE)
return no_var_pack();
else
return make_error_pack(e);
}
static package
bf_add_prop(Var arglist, Byte next, void *vdata, Objid progr)
{ /* (object, prop-name, initial-value, initial-info) */
Objid oid = arglist.v.list[1].v.obj;
const char *pname = arglist.v.list[2].v.str;
Var value = arglist.v.list[3];
Var info = arglist.v.list[4];
Objid owner;
unsigned flags;
const char *new_name;
enum error e;
if ((e = validate_prop_info(info, &owner, &flags, &new_name)) != E_NONE); /* Already failed */
else if (new_name)
e = E_TYPE;
else if (!valid(oid))
e = E_INVARG;
else if (!db_object_allows(oid, progr, FLAG_WRITE)
|| (progr != owner && !is_wizard(progr)))
e = E_PERM;
else if (!db_add_propdef(oid, pname, value, owner, flags))
e = E_INVARG;
free_var(arglist);
if (e == E_NONE)
return no_var_pack();
else
return make_error_pack(e);
}
static package bf_urldecode( Var arglist, Byte next, void *vdata, Objid progr)
{
Var r;
CURL *curl_handle;
const char *string = arglist.v.list[1].v.str;
free_var(arglist);
curl_global_init(CURL_GLOBAL_ALL);
curl_handle = curl_easy_init();
r.type = TYPE_STR;
char *output = curl_easy_unescape(curl_handle,string,0,NULL);
if(output == NULL)
{
curl_free(output);
return make_error_pack(E_INVARG);
}
r.v.str = str_dup(output);
curl_free(output);
curl_easy_cleanup(curl_handle);
curl_global_cleanup();
return make_var_pack(r);
}
Var* new_module(char* module_name)
{
Var* v;
if (module_name == NULL) {
if (debug > DEBUG_THRESHOLD) {
parse_error("Cannot create a module with (null) name.");
}
return NULL;
}
if (search_in_list_of_loaded_modules(module_name) != NULL) {
/* If module already loaded, don't load it again */
parse_error("Module %s already loaded.", module_name);
return NULL;
}
v = newVar();
memset(&V_MODULE(v), 0, sizeof(dvModule));
/* make scope not clean this variable */
mem_claim(v);
V_TYPE(v) = ID_MODULE;
V_NAME(v) = strdup(module_name);
if (V_NAME(v) == NULL) {
parse_error("Mem allocation error in new_module().");
free_var(v);
return NULL;
}
V_MODULE(v).functions = Narray_create(10);
V_MODULE(v).name = V_NAME(v);
/* keep track of available modules */
if (!add_to_list_of_loaded_modules(v)) {
/* Addition into the list of loaded modules failed. Abort. */
free_var(v);
return NULL;
}
V_MODULE(v).stage = MOD_LST_ADDED;
return v;
}
static package
bf_generate_json(Var arglist, Byte next, void *vdata, Objid progr)
{
yajl_gen g;
yajl_gen_config cfg = { 0, "" };
struct generate_context gctx;
gctx.mode = MODE_COMMON_SUBSET;
const char *buf;
unsigned int len;
Var json;
package pack;
if (1 < arglist.v.list[0].v.num) {
if (!mystrcasecmp(arglist.v.list[2].v.str, "common-subset")) {
gctx.mode = MODE_COMMON_SUBSET;
} else if (!mystrcasecmp(arglist.v.list[2].v.str, "embedded-types")) {
gctx.mode = MODE_EMBEDDED_TYPES;
} else {
free_var(arglist);
return make_error_pack(E_INVARG);
}
}
g = yajl_gen_alloc(&cfg, NULL);
if (yajl_gen_status_ok == generate(g, arglist.v.list[1], &gctx)) {
yajl_gen_get_buf(g, (const unsigned char **)&buf, &len);
json.type = TYPE_STR;
json.v.str = str_dup(buf);
pack = make_var_pack(json);
} else {
pack = make_error_pack(E_INVARG);
}
yajl_gen_clear(g);
yajl_gen_free(g);
free_var(arglist);
return pack;
}
static void
free_node(XMLdata *data)
{
free_var(data->element);
if(data->body != NULL)
free_stream(data->body);
myfree(data, M_XML_DATA);
}
int
matches(char *subject, const char *pattern)
{
Var ans, req;
int result;
req = new_list(2);
req.v.list[1].type = TYPE_STR;
req.v.list[2].type = TYPE_STR;
req.v.list[1].v.str = str_dup(subject);
req.v.list[2].v.str = str_dup(pattern);
ans = do_match(req, 0);
result = is_true(ans);
free_var(ans);
free_var(req);
return result;
}
static package
bf_sort(Var arglist, Byte next, void *vdata, Objid progr)
{
/* sort(list) => sorts and returns list.
sort({1,3,2}) => {1,2,3} */
/* returns E_TYPE is list is not all the same type */
Var sorted = new_list(0), tmp;
Var e;
int i, l;
e.type=TYPE_NONE;
for(i = 1; i <= arglist.v.list[1].v.list[0].v.num; i++) {
e = var_ref(arglist.v.list[1].v.list[i]);
l = find_insert(sorted, e);
if(l == -10) {
free_var(arglist);
free_var(sorted);
free_var(e);
return make_error_pack(E_TYPE);
}
tmp = listinsert(var_ref(sorted), var_ref(e), l);
free_var(sorted);
sorted = var_ref(tmp);
free_var(tmp);
}
free_var(arglist);
free_var(e);
return make_var_pack(sorted);
}
static package
bf_verb_info(Var arglist, Byte next, void *vdata, Objid progr)
{ /* (object, verb-desc) */
Objid oid = arglist.v.list[1].v.obj;
Var desc = arglist.v.list[2];
db_verb_handle h;
Var r;
unsigned flags;
char perms[5], *s;
enum error e;
if ((e = validate_verb_descriptor(desc)) != E_NONE
|| (e = E_INVARG, !valid(oid))) {
free_var(arglist);
return make_error_pack(e);
}
h = find_described_verb(oid, desc);
free_var(arglist);
if (!h.ptr)
return make_error_pack(E_VERBNF);
else if (!db_verb_allows(h, progr, VF_READ))
return make_error_pack(E_PERM);
r = new_list(3);
r.v.list[1].type = TYPE_OBJ;
r.v.list[1].v.obj = db_verb_owner(h);
r.v.list[2].type = TYPE_STR;
s = perms;
flags = db_verb_flags(h);
if (flags & VF_READ)
*s++ = 'r';
if (flags & VF_WRITE)
*s++ = 'w';
if (flags & VF_EXEC)
*s++ = 'x';
if (flags & VF_DEBUG)
*s++ = 'd';
*s = '\0';
r.v.list[2].v.str = str_dup(perms);
r.v.list[3].type = TYPE_STR;
r.v.list[3].v.str = str_ref(db_verb_names(h));
return make_var_pack(r);
}
