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); }
void db_shutdown() { dump_database(DUMP_SHUTDOWN); free_str(input_db_name); free_str(dump_db_name); }
static void assert_tree_print(struct string *expected, struct tree_node *root) { struct string *str = alloc_str(); tree_print(root, str); assert_str_equals(expected->value, str->value); free_str(str); free_str(expected); }
void destroy_player(Player *p) { free_str(p->title); free_str(p->prompt); free_str(p->battlePrompt); destroy_flags(p->explored); destroy_flags(p->channels); free_mem(p); }
void db_destroy_object(Objid oid) { Object *o = dbpriv_find_object(oid); Verbdef *v, *w; int i; db_priv_affected_callable_verb_lookup(); if (!o) panic("DB_DESTROY_OBJECT: Invalid object!"); if (o->location != NOTHING || o->contents != NOTHING || o->parent != NOTHING || o->child != NOTHING) panic("DB_DESTROY_OBJECT: Not a barren orphan!"); if (is_user(oid)) { Var t; t.type = TYPE_OBJ; t.v.obj = oid; all_users = setremove(all_users, t); } free_str(o->name); for (i = 0; i < o->propdefs.cur_length; i++) { /* As an orphan, the only properties on this object are the ones * defined on it directly, so these two arrays must be the same length. */ free_str(o->propdefs.l[i].name); free_var(o->propval[i].var); } if (o->propval) myfree(o->propval, M_PVAL); if (o->propdefs.l) myfree(o->propdefs.l, M_PROPDEF); for (v = o->verbdefs; v; v = w) { if (v->program) free_program(v->program); free_str(v->name); w = v->next; myfree(v, M_VERBDEF); } myfree(objects[oid], M_OBJECT); objects[oid] = 0; }
/* * Append some optional data to the current request, and store its * length into the 16-bit field (network byte order) referenced by * "fld". Returns 0 on success, or -1 on failure. * * This function also frees the "cs" string data and initializes it * for the next time. */ static int add_str_16(struct tac_handle *h, u_int16_t *fld, struct clnt_str *cs) { size_t len; len = cs->len; if (cs->data == NULL) len = 0; if (len != 0) { int offset; if (len > 0xffff) { generr(h, "Field too long"); return -1; } offset = ntohl(h->request.length); if (offset + len > BODYSIZE) { generr(h, "Message too long"); return -1; } memcpy(h->request.u.body + offset, cs->data, len); h->request.length = htonl(offset + len); } *fld = htons(len); free_str(cs); return 0; }
void node_destroy( mxml_node * n ) { if ( n != NULL ) { mxml_node * temp = NULL; mxml_node * child = n->first_child; while ( child ) { temp = child->next; node_destroy( child ); child = temp; } if ( n->extend != NULL && n->type != type_node ) { switch( n->type ) { case type_element : destroy_element ( (mxml_element *)n->extend ); break; case type_attribute : destroy_attribute ( (mxml_attribute *)n->extend ); break; case type_declaration : destroy_declaration( (mxml_declaration *)n->extend ); break; case type_document : destroy_document ( (mxml_document *)n->extend ); break; } } free_str( &n->value ); free( n ); } }
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); } }
void free_nls(void) { struct nls *t; dolist (t, pNLS) free_str(&t->translation); freeall(&pNLS); nls_loaded = false; }
char *ft_strjoin_free(char *s1, char *s2, int free_token) { size_t i; size_t j; char *str; i = 0; j = 0; if ((str = ft_memalloc(ft_strlen(s1) + ft_strlen(s2) + 1)) == NULL) return (NULL); while (s1[i]) { str[i] = s1[i]; i++; } while (s2[j]) { str[i] = s2[j]; i++; j++; } str[i] = '\0'; free_str(&s1, &s2, free_token); return (str); }
SpecialFolder::~SpecialFolder() { // delete_the pidl-list and it's contents delete_pidl_list(&m_pidl_list); free_str(&m_pszExtra); // note: the drop-target is unregistered in the 'Menu' destructor }
/** FISSO = ([^/%] | "%%")+ */ int fisso(const char* schema, int offset, dynamic_str_t* fissi) { dynamic_str_t componenti_fisso; if (fissi) init_str(&componenti_fisso); if (!schema[offset] || schema[offset] == '/' || (schema[offset] == '%' && schema[offset+1] != '%')) return -1; // deve avere lunghezza > 0! int bkp = offset; for (; schema[offset] && schema[offset] != '/'; offset++) { if (schema[offset] == '%') { if (schema[offset+1] == '%') { if (fissi) { char tmp[offset-bkp+1]; tmp[0] = tmp[offset-bkp] = '\0'; strncpy(tmp, schema+bkp, offset-bkp); append_str(&componenti_fisso, tmp); } bkp = ++offset + 1; } else // dev'essere una keyword -> mi fermo break; } } if (fissi) { char tmp[offset-bkp+1]; tmp[0] = tmp[offset-bkp] = '\0'; strncpy(tmp, schema+bkp, offset-bkp); append_str(&componenti_fisso, tmp); append_str(fissi, join(componenti_fisso, '%')); free_str(&componenti_fisso); } return offset; }
void parse_query_string_len(nvlist_t *vars, const char *qs, size_t len) { struct qstr *name, *val; const char *cur, *end; int state; if (!qs || !len) return; name = alloc_str(VAR_NAME_MAXLEN); val = alloc_str(64 * 1024); ASSERT(name); ASSERT(val); state = QS_STATE_NAME; end = qs + len; cur = qs; for (; end > cur; cur++) { char c = *cur; if (state == QS_STATE_NAME) { if (c == '=') state = QS_STATE_VAL; else ASSERT0(append_char_str(name, c)); } else if (state == QS_STATE_VAL) { if (c == '&') { insert(vars, name, val); state = QS_STATE_NAME; reset_str(name); reset_str(val); } else { ASSERT0(append_char_str(val, c)); } } } if (state == QS_STATE_VAL) insert(vars, name, val); free_str(name); free_str(val); }
void str_test() { my_str *strp = alloc_str(test, strlen(test)); printf("content: %s, len: %d\n", STR_CONTENT(strp), STR_LENGTH(strp) + 1); free_str(strp); }
//================================================ void SpecialFolder::UpdateFolder(void) { // --------------------------------------- // remember the active item as text MenuItem *ActiveItem = m_pActiveItem; TCHAR *active_item_text = NULL; m_pLastChild = m_pChild; if (m_pLastChild) ActiveItem = m_pLastChild->m_pParentItem; if (ActiveItem) active_item_text = new_str(ActiveItem->m_pszTitle); // delete_old items DeleteMenuItems(); // load the folder contents MenuItem *Items = NULL; int r = 0; struct pidl_node *p; dolist (p, m_pidl_list) r |= MenuMaker_LoadFolder(&Items, p->v, m_pszExtra); if (Items) add_folder_contents(Items, NULL != m_pidl_list->next); else if (r) MakeMenuNOP(this, NLS0(_T("No Files"))); else MakeMenuNOP(this, NLS0(_T("Invalid Path"))); // --------------------------------------- // search by text the previously active item if (active_item_text) { dolist (ActiveItem, m_pMenuItems) if (0 == _tcscmp(active_item_text, ActiveItem->m_pszTitle)) break; free_str(&active_item_text); } // --------------------------------------- // possibly reconnect to an open child-folder if (m_pLastChild) { if (ActiveItem) { m_pLastChild->incref(); ActiveItem->LinkSubmenu(m_pLastChild); m_pLastChild->LinkToParentItem(ActiveItem); } else { m_pLastChild->Hide(); // lost child } m_pLastChild = NULL; } if (ActiveItem) ActiveItem->Active(2); }
/** rimuove ogni file descriptor watched da un'instanza di inotify Da notare come files e watch_fds devono essere della stessa lunghezza! \param inotify istanza di inotify_t a cui rimuovere tutti i file descriptors */ void rm_all_watches(inotify_t inotify) { for (int i=0; i<inotify.watch_fds.size; i++) if (inotify_rm_watch(inotify.instance, inotify.watch_fds.buf[i])==-1) { perror("inotify_rm_watch"); exit(EXIT_FAILURE); } free_int(&inotify.watch_fds); free_str(&inotify.files); }
MenuItem::~MenuItem() { UnlinkSubmenu(); if (m_pRightmenu) m_pRightmenu->decref(); free_str(&m_pszTitle); free_str(&m_pszCommand); free_str(&m_pszRightCommand); delete_pidl_list(&m_pidl_list); //#ifdef BBOPT_MENUICONS free_str(&m_pszIcon); if (m_hIcon) DestroyIcon(m_hIcon); //#endif --g_menu_item_count; }
void db_set_object_name(Objid oid, const char *name) { Object *o = objects[oid]; if (o->name) free_str(o->name); o->name = name; }
static void peg_node_free(struct peg_grammar *peg, int nn) { struct peg_node *pn; if ( nn < 0 || nn >= peg->max_nodes ) return; pn = NODE(peg, nn); switch ( pn->pn_type ) { case PEG_DEFINITION: peg_node_free(peg, pn->pd_id); peg_node_free(peg, pn->pd_expr); break; case PEG_SEQUENCE: peg_node_free(peg, pn->ps_pri); peg_node_free(peg, pn->pn_next); break; case PEG_PRIMARY: peg_node_free(peg, pn->pp_match); peg_node_free(peg, pn->pn_next); if ( pn->pp_action != PEG_ACT_NONE ) free_str(&pn->pp_label); break; case PEG_IDENTIFIER: --pn->pi_refcnt; if ( pn->pi_refcnt > 0 ) return; free_str(&pn->pi_name); break; case PEG_LITERAL: free_str(&pn->pl_value); break; case PEG_CLASS: free_str(&pn->pc_cset_raw); break; default: return; } abort_unless(peg->num_nodes > 0); --peg->num_nodes; pn->pn_type = PEG_NONE; }
static void close_nlistener(nlistener * l) { *(l->prev) = l->next; if (l->next) l->next->prev = l->prev; proto_close_listener(l->fd); free_str(l->name); myfree(l, M_NETWORK); }
void destroy_char(Character *ch) { free_str(ch->name); destroy_flags(ch->flags); destroy_flags(ch->affectedBy); free_str(ch->description); free_mem(ch->classes); if (ch->pc != 0) { destroy_player(ch->pc); } if (ch->npc != 0) { destroy_npc(ch->npc); } free_mem(ch); }
void replace_attr_string( pbs_attribute *attr, char *newval) { free_str(attr); attr->at_val.at_str = newval; attr->at_flags |= ATR_VFLAG_SET; return; } /* END replace_job_attr_string() */
static package bf_set_verb_info(Var arglist, Byte next, void *vdata, Objid progr) { /* (object, verb-desc, {owner, flags, names}) */ Objid oid = arglist.v.list[1].v.obj; Var desc = arglist.v.list[2]; Var info = arglist.v.list[3]; Objid new_owner; unsigned new_flags; const char *new_names; enum error e; db_verb_handle h; 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_info(info, &new_owner, &new_flags, &new_names); if (e != E_NONE) { free_var(arglist); return make_error_pack(e); } h = find_described_verb(oid, desc); free_var(arglist); if (!h.ptr) { free_str(new_names); return make_error_pack(E_VERBNF); } else if (!db_verb_allows(h, progr, VF_WRITE) || (!is_wizard(progr) && db_verb_owner(h) != new_owner)) { free_str(new_names); return make_error_pack(E_PERM); } db_set_verb_owner(h, new_owner); db_set_verb_flags(h, new_flags); db_set_verb_names(h, new_names); return no_var_pack(); }
static int save_str(struct tac_handle *h, struct clnt_str *cs, const void *data, size_t len) { free_str(cs); if (data != NULL && len != 0) { if ((cs->data = xmalloc(h, len)) == NULL) return -1; cs->len = len; memcpy(cs->data, data, len); } return 0; }
void show_function(void *addr) { struct string *str; str = alloc_str(); if (show_exe_function(addr, str)) { trace_printf("%s", str->value); } else { trace_printf("<unknown>\n"); } free_str(str); }
static void close_nhandle(nhandle * h) { text_block *b, *bb; (void) push_output(h); *(h->prev) = h->next; if (h->next) h->next->prev = h->prev; b = h->output_head; while (b) { bb = b->next; free_text_block(b); b = bb; } free_stream(h->input); proto_close_connection(h->rfd, h->wfd); free_str(h->name); myfree(h, M_NETWORK); }
/* drop reference, free if none left */ void strpool_decref(struct PStr *s) { struct StrPool *sp; if (!s) return; Assert(s->refcnt > 0); sp = s->pool; pthread_mutex_lock(&sp->mutex); s->refcnt--; if (s->refcnt > 0){ pthread_mutex_unlock(&sp->mutex); return; } /* remove */ sp->count--; cbtree_delete(sp->tree, s->str, s->len); free_str(NULL, s); pthread_mutex_unlock(&sp->mutex); }
void str_intern_close(void) { int i; struct intern_entry *e, *next; for (i = 0; i < intern_table_size; i++) { for (e = intern_table[i]; e; e = next) { next = e->next; free_str(e->s); /* myfree(e, M_INTERN_ENTRY); */ } } myfree(intern_table, M_INTERN_POINTER); intern_table = NULL; free_intern_entry_hunks(); oklog("INTERN: %d allocations saved, %d bytes\n", intern_allocations_saved, intern_bytes_saved); oklog("INTERN: at end, %d entries in a %d bucket hash table.\n", intern_table_count, intern_table_size); }
static void create_msg(struct tac_handle *h, int msg_type, int var, int type) { struct tac_msg *msg; int i; h->last_seq_no = 0; msg = &h->request; msg->type = msg_type; msg->version = protocol_version(msg_type, var, type); msg->flags = 0; /* encrypted packet body */ free_str(&h->user); free_str(&h->port); free_str(&h->rem_addr); free_str(&h->data); free_str(&h->user_msg); for (i=0; i<MAXAVPAIRS; i++) free_str(&(h->avs[i])); }
void tac_close(struct tac_handle *h) { int i, srv; if (h->fd != -1) close(h->fd); for (srv = 0; srv < h->num_servers; srv++) { memset(h->servers[srv].secret, 0, strlen(h->servers[srv].secret)); free(h->servers[srv].secret); } free_str(&h->user); free_str(&h->port); free_str(&h->rem_addr); free_str(&h->data); free_str(&h->user_msg); for (i=0; i<MAXAVPAIRS; i++) free_str(&(h->avs[i])); /* Clear everything else before freeing memory */ memset(h, 0, sizeof(struct tac_handle)); free(h); }