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