/** * Initialize dynamic hits. */ G_GNUC_COLD void dh_init(void) { by_muid = htable_create(HASH_KEY_FIXED, GUID_RAW_SIZE); by_muid_old = htable_create(HASH_KEY_FIXED, GUID_RAW_SIZE); last_rotation = tm_time(); }
QMGR_TRANSPORT *qmgr_transport_create(const char *name) { QMGR_TRANSPORT *transport; if (htable_find(qmgr_transport_byname, name) != 0) msg_panic("qmgr_transport_create: transport exists: %s", name); transport = (QMGR_TRANSPORT *) mymalloc(sizeof(QMGR_TRANSPORT)); transport->flags = 0; transport->pending = 0; transport->name = mystrdup(name); /* * Use global configuration settings or transport-specific settings. */ transport->dest_concurrency_limit = get_mail_conf_int2(name, _DEST_CON_LIMIT, var_dest_con_limit, 0, 0); transport->recipient_limit = get_mail_conf_int2(name, _DEST_RCPT_LIMIT, var_dest_rcpt_limit, 0, 0); transport->init_dest_concurrency = get_mail_conf_int2(name, _INIT_DEST_CON, var_init_dest_concurrency, 1, 0); transport->xport_rate_delay = get_mail_conf_time2(name, _XPORT_RATE_DELAY, var_xport_rate_delay, 's', 0, 0); transport->rate_delay = get_mail_conf_time2(name, _DEST_RATE_DELAY, var_dest_rate_delay, 's', 0, 0); if (transport->rate_delay > 0) transport->dest_concurrency_limit = 1; if (transport->dest_concurrency_limit != 0 && transport->dest_concurrency_limit < transport->init_dest_concurrency) transport->init_dest_concurrency = transport->dest_concurrency_limit; transport->queue_byname = htable_create(0); QMGR_LIST_INIT(transport->queue_list); transport->dsn = 0; qmgr_feedback_init(&transport->pos_feedback, name, _CONC_POS_FDBACK, VAR_CONC_POS_FDBACK, var_conc_pos_feedback); qmgr_feedback_init(&transport->neg_feedback, name, _CONC_NEG_FDBACK, VAR_CONC_NEG_FDBACK, var_conc_neg_feedback); transport->fail_cohort_limit = get_mail_conf_int2(name, _CONC_COHORT_LIM, var_conc_cohort_limit, 0, 0); if (qmgr_transport_byname == 0) qmgr_transport_byname = htable_create(10); htable_enter(qmgr_transport_byname, name, (void *) transport); QMGR_LIST_APPEND(qmgr_transport_list, transport); if (msg_verbose) msg_info("qmgr_transport_create: %s concurrency %d recipients %d", transport->name, transport->dest_concurrency_limit, transport->recipient_limit); return (transport); }
static void hash_parameters(void) { const CONFIG_TIME_TABLE *ctt; const CONFIG_BOOL_TABLE *cbt; const CONFIG_INT_TABLE *cit; const CONFIG_STR_TABLE *cst; const CONFIG_STR_FN_TABLE *csft; const CONFIG_RAW_TABLE *rst; const CONFIG_NINT_TABLE *nst; param_table = htable_create(100); for (ctt = time_table; ctt->name; ctt++) htable_enter(param_table, ctt->name, (char *) ctt); for (cbt = bool_table; cbt->name; cbt++) htable_enter(param_table, cbt->name, (char *) cbt); for (cit = int_table; cit->name; cit++) htable_enter(param_table, cit->name, (char *) cit); for (cst = str_table; cst->name; cst++) htable_enter(param_table, cst->name, (char *) cst); for (csft = str_fn_table; csft->name; csft++) htable_enter(param_table, csft->name, (char *) csft); for (csft = str_fn_table_2; csft->name; csft++) htable_enter(param_table, csft->name, (char *) csft); for (rst = raw_table; rst->name; rst++) htable_enter(param_table, rst->name, (char *) rst); for (nst = nint_table; nst->name; nst++) htable_enter(param_table, nst->name, (char *) nst); }
int main(int unused_argc, char **argv) { HTABLE *table = htable_create(1); msg_vstream_init(argv[0], VSTREAM_ERR); msg_verbose = 1; htable_enter(table, "foo-name", mystrdup("foo-value")); htable_enter(table, "bar-name", mystrdup("bar-value")); attr_print64(VSTREAM_OUT, ATTR_FLAG_NONE, SEND_ATTR_INT(ATTR_NAME_INT, 4711), SEND_ATTR_LONG(ATTR_NAME_LONG, 1234L), SEND_ATTR_STR(ATTR_NAME_STR, "whoopee"), SEND_ATTR_DATA(ATTR_NAME_DATA, strlen("whoopee"), "whoopee"), SEND_ATTR_HASH(table), SEND_ATTR_LONG(ATTR_NAME_LONG, 4321L), ATTR_TYPE_END); attr_print64(VSTREAM_OUT, ATTR_FLAG_NONE, SEND_ATTR_INT(ATTR_NAME_INT, 4711), SEND_ATTR_LONG(ATTR_NAME_LONG, 1234L), SEND_ATTR_STR(ATTR_NAME_STR, "whoopee"), SEND_ATTR_DATA(ATTR_NAME_DATA, strlen("whoopee"), "whoopee"), ATTR_TYPE_END); if (vstream_fflush(VSTREAM_OUT) != 0) msg_fatal("write error: %m"); htable_free(table, myfree); return (0); }
void test_htable_rehash() { htable *ht = htable_create(); assert(htable_capacity(ht) == MIN_HASH_SIZE && "Size is MIN_HASH_SIZE after creation."); htable_insert(ht, "one", "1st value"); htable_insert(ht, "two", "2nd value"); htable_insert(ht, "three", "3rd value"); htable_insert(ht, "four", "4th value"); htable_insert(ht, "five", "5th value"); htable_insert(ht, "six", "6th value"); htable_insert(ht, "seven", "7th value"); htable_insert(ht, "eight", "8th value"); htable_insert(ht, "nine", "9th value"); htable_insert(ht, "ten", "10th value"); htable_insert(ht, "eleven", "11th value"); htable_insert(ht, "twelve", "12th value"); assert(htable_capacity(ht) == 29 && "Size is 29 after rehash."); assert(0 == strcmp("1st value", htable_get(ht, "one")) && "First value should be equal to 1st value"); assert(0 == strcmp("2nd value", htable_get(ht, "two")) && "Second value should be equal to 2nd value"); assert(0 == strcmp("7th value", htable_get(ht, "seven")) && "Third value should be equal to 3rd value"); htable_destroy(ht); }
/** * Initialize the wait queue layer. */ void wq_init(void) { g_assert(NULL == waitqueue); waitqueue = htable_create(HASH_KEY_SELF, 0); }
int main(int unused_argc, char **argv) { HTABLE *table = htable_create(1); msg_vstream_init(argv[0], VSTREAM_ERR); msg_verbose = 1; htable_enter(table, "foo-name", mystrdup("foo-value")); htable_enter(table, "bar-name", mystrdup("bar-value")); attr_print64(VSTREAM_OUT, ATTR_FLAG_NONE, ATTR_TYPE_NUM, ATTR_NAME_NUM, 4711, ATTR_TYPE_LONG, ATTR_NAME_LONG, 1234, ATTR_TYPE_STR, ATTR_NAME_STR, "whoopee", ATTR_TYPE_HASH, table, ATTR_TYPE_END); attr_print64(VSTREAM_OUT, ATTR_FLAG_NONE, ATTR_TYPE_NUM, ATTR_NAME_NUM, 4711, ATTR_TYPE_LONG, ATTR_NAME_LONG, 1234, ATTR_TYPE_STR, ATTR_NAME_STR, "whoopee", ATTR_TYPE_END); if (vstream_fflush(VSTREAM_OUT) != 0) msg_fatal("write error: %m"); htable_free(table, myfree); return (0); }
static struct mypasswd *mypwenter(const struct passwd * pwd) { struct mypasswd *mypwd; /* * Initialize on the fly. */ if (mypwcache_name == 0) { mypwcache_name = htable_create(0); mypwcache_uid = binhash_create(0); } mypwd = (struct mypasswd *) mymalloc(sizeof(*mypwd)); mypwd->refcount = 0; mypwd->pw_name = mystrdup(pwd->pw_name); mypwd->pw_passwd = mystrdup(pwd->pw_passwd); mypwd->pw_uid = pwd->pw_uid; mypwd->pw_gid = pwd->pw_gid; mypwd->pw_gecos = mystrdup(pwd->pw_gecos); mypwd->pw_dir = mystrdup(pwd->pw_dir); mypwd->pw_shell = mystrdup(*pwd->pw_shell ? pwd->pw_shell : _PATH_BSHELL); /* * Avoid mypwcache_uid memory leak when multiple names have the same UID. * This makes the lookup result dependent on program history. But, it was * already history-dependent before we added this extra check. */ htable_enter(mypwcache_name, mypwd->pw_name, (char *) mypwd); if (binhash_locate(mypwcache_uid, (char *) &mypwd->pw_uid, sizeof(mypwd->pw_uid)) == 0) binhash_enter(mypwcache_uid, (char *) &mypwd->pw_uid, sizeof(mypwd->pw_uid), (char *) mypwd); return (mypwd); }
static void initialize_storage_table (storage_t *storage) { storage->words = htable_create (16, (unsigned (*)(void *)) phrase_hash, (int (*)(void *, void *)) phrase_compare); }
int tls_mgr_policy(const char *unused_type, int *cachable) { if (cache_enabled && tls_cache == 0) tls_cache = htable_create(1); *cachable = cache_enabled; return (TLS_MGR_STAT_OK); }
static QMGR_JOB *qmgr_job_create(QMGR_MESSAGE *message, QMGR_TRANSPORT *transport) { QMGR_JOB *job; job = (QMGR_JOB *) mymalloc(sizeof(QMGR_JOB)); job->message = message; QMGR_LIST_APPEND(message->job_list, job, message_peers); htable_enter(transport->job_byname, message->queue_id, (void *) job); job->transport = transport; QMGR_LIST_INIT(job->transport_peers); QMGR_LIST_INIT(job->time_peers); job->stack_parent = 0; QMGR_LIST_INIT(job->stack_children); QMGR_LIST_INIT(job->stack_siblings); job->stack_level = -1; job->blocker_tag = 0; job->peer_byname = htable_create(0); QMGR_LIST_INIT(job->peer_list); job->slots_used = 0; job->slots_available = 0; job->selected_entries = 0; job->read_entries = 0; job->rcpt_count = 0; job->rcpt_limit = 0; return (job); }
int test_create__destroy(){ hashtable* myhtable; hsize size=101; myhtable=htable_create(size,NULL); htable_destroy(myhtable); myhtable=NULL; return 1; }
/** * Initialize the upload statistics GUI. * * Initialize the upload statistics GUI. Define the * GtkTreeModel used to store the information as well * as rendering and sorting functions to use on the * cells and columns. */ static void upload_stats_gui_init_intern(gboolean intern) { static const struct { const guint id; const gchar * const title; const gfloat align; const GtkTreeIterCompareFunc func; } columns[] = { { c_us_filename, N_("Filename"), 0.0, upload_stats_gui_cmp_filename }, { c_us_size, N_("Size"), 1.0, upload_stats_gui_cmp_size }, { c_us_attempts, N_("Attempts"), 1.0, upload_stats_gui_cmp_attempts }, { c_us_complete, N_("Complete"), 1.0, upload_stats_gui_cmp_complete }, { c_us_norm, N_("Normalized"), 1.0, upload_stats_gui_cmp_norm }, { c_us_rtime, N_("Last Request"), 0.0, upload_stats_gui_cmp_rtime }, { c_us_dtime, N_("Last Upload"), 0.0, upload_stats_gui_cmp_dtime }, }; static gboolean initialized = FALSE; GtkTreeModel *model; guint i; STATIC_ASSERT(G_N_ELEMENTS(columns) == UPLOAD_STATS_GUI_VISIBLE_COLUMNS); if (!initialized) { initialized = TRUE; ht_uploads = htable_create(HASH_KEY_SELF, 0); popup_upload_stats = create_popup_upload_stats(); model = GTK_TREE_MODEL(gtk_list_store_new(1, G_TYPE_POINTER)); upload_stats_treeview = GTK_TREE_VIEW( gui_main_window_lookup("treeview_ul_stats")); gtk_tree_view_set_model(upload_stats_treeview, model); g_object_unref(model); for (i = 0; i < G_N_ELEMENTS(columns); i++) { add_column(upload_stats_treeview, columns[i].id, _(columns[i].title), columns[i].align, columns[i].func, cell_renderer_func); } gui_signal_connect(upload_stats_treeview, "button_press_event", on_button_press_event, NULL); } if (!intern) { /* upload_stats_gui_init_intern() might be called internally before * settings_gui_init(). If it's called externally it's called from * main_gui_init() and the GUI properties are intialized. */ tree_view_restore_widths(upload_stats_treeview, PROP_UL_STATS_COL_WIDTHS); tree_view_restore_visibility(upload_stats_treeview, PROP_UL_STATS_COL_VISIBLE); } }
BH_TABLE *been_here_init(int limit, int flags) { BH_TABLE *dup_filter; dup_filter = (BH_TABLE *) mymalloc(sizeof(*dup_filter)); dup_filter->limit = limit; dup_filter->flags = flags; dup_filter->table = htable_create(0); return (dup_filter); }
void sip_calls_clear() { // Create again the callid hash table htable_destroy(calls.callids); calls.callids = htable_create(calls.limit); // Remove all items from vector vector_clear(calls.list); vector_clear(calls.active); }
int main(int unused_argc, char **unused_argv) { VSTRING *buf = vstring_alloc(100); VSTRING *result = vstring_alloc(100); char *cp; char *name; char *value; HTABLE *table; int stat; while (!vstream_feof(VSTREAM_IN)) { table = htable_create(0); /* * Read a block of definitions, terminated with an empty line. */ while (vstring_get_nonl(buf, VSTREAM_IN) != VSTREAM_EOF) { vstream_printf("<< %s\n", vstring_str(buf)); vstream_fflush(VSTREAM_OUT); if (VSTRING_LEN(buf) == 0) break; cp = vstring_str(buf); name = mystrtok(&cp, " \t\r\n="); value = mystrtok(&cp, " \t\r\n="); htable_enter(table, name, value ? mystrdup(value) : 0); } /* * Read a block of patterns, terminated with an empty line or EOF. */ while (vstring_get_nonl(buf, VSTREAM_IN) != VSTREAM_EOF) { vstream_printf("<< %s\n", vstring_str(buf)); vstream_fflush(VSTREAM_OUT); if (VSTRING_LEN(buf) == 0) break; cp = vstring_str(buf); VSTRING_RESET(result); stat = mac_expand(result, vstring_str(buf), MAC_EXP_FLAG_NONE, (char *) 0, lookup, (char *) table); vstream_printf("stat=%d result=%s\n", stat, vstring_str(result)); vstream_fflush(VSTREAM_OUT); } htable_free(table, myfree); vstream_printf("\n"); } /* * Clean up. */ vstring_free(buf); vstring_free(result); exit(0); }
int test_add_element_and_find_it(){ hashtable* myhtable; hsize size=101; myhtable=htable_create(size,NULL); htable_insert(myhtable,"Hugo","Yvaon"); assert(!strcmp("Yvaon",htable_get(myhtable,"Hugo"))); htable_destroy(myhtable); myhtable=NULL; return 1; }
static struct server * server_init(void) { struct server *s = malloc(sizeof(struct server)); if (s == NULL) dns_error(0, "out of memory in server_init"); s->nfetcher = FETCHER_NUM; s->nquizzer = QUIZZER_NUM; s->authors = NULL; s->fetchers = NULL; s->pkg = 0; pthread_spin_init(&s->eventlist.lock, 0); //pthread_mutex_init(&s->lock,NULL); s->eventlist.head = NULL; if ((s->ludp = create_listen_ports(SERVER_PORT, UDP, (uchar *)SRV_ADDR)) < 0) dns_error(0, "can not open udp"); set_sock_buff(s->ludp, 10); if ((s->ltcp = create_listen_ports(SERVER_PORT, TCP, (uchar *)SRV_ADDR)) < 0) dns_error(0, "can not open tcp"); s->datasets = htable_create(NULL, dict_comp_str_equ, HASH_TABLE_SIZE, MULTI_HASH); if (s->datasets == NULL) dns_error(0, "htable create"); s->forward = htable_create(NULL, dict_comp_str_equ, 1024, 1); if (s->forward == NULL) dns_error(0, "create forward"); s->qlist = htable_create(NULL, dict_comp_str_equ, QLIST_TABLE_SIZE, 1); if (s->qlist == NULL) dns_error(0, "create qlist"); s->ttlexp = create_rbtree(rbt_comp_ttl_gt, NULL); if (s->ttlexp == NULL) dns_error(0, "create ttl tree"); s->recordsindb = 0; s->refreshflag = 0; s->lastrefresh = global_now; s->is_forward = 0; return s; }
void psc_dnsbl_init(void) { const char *myname = "psc_dnsbl_init"; ARGV *dnsbl_site = argv_split(var_psc_dnsbl_sites, CHARS_COMMA_SP); char **cpp; /* * Sanity check. */ if (dnsbl_site_cache != 0) msg_panic("%s: called more than once", myname); /* * pre-compute the DNSBLOG socket name. */ psc_dnsbl_service = concatenate(MAIL_CLASS_PRIVATE, "/", var_dnsblog_service, (char *) 0); /* * Prepare for quick iteration when sending out queries to all DNSBL * servers, and for quick lookup when a reply arrives from a specific * DNSBL server. */ dnsbl_site_cache = htable_create(13); for (cpp = dnsbl_site->argv; *cpp; cpp++) psc_dnsbl_add_site(*cpp); argv_free(dnsbl_site); dnsbl_site_list = htable_list(dnsbl_site_cache); /* * The per-client blocklist score. */ dnsbl_score_cache = htable_create(13); /* * Space for ad-hoc DNSBLOG server request/reply parameters. */ reply_client = vstring_alloc(100); reply_dnsbl = vstring_alloc(100); reply_addr = vstring_alloc(100); }
static void dict_open_init(void) { const char *myname = "dict_open_init"; const DICT_OPEN_INFO *dp; if (dict_open_hash != 0) msg_panic("%s: multiple initialization", myname); dict_open_hash = htable_create(10); for (dp = dict_open_info; dp->type; dp++) htable_enter(dict_open_hash, dp->type, (char *) dp); }
static void mkmap_open_init(void) { static const char myname[] = "mkmap_open_init"; const MKMAP_OPEN_INFO *mp; if (mkmap_open_hash != 0) msg_panic("%s: multiple initialization", myname); mkmap_open_hash = htable_create(10); for (mp = mkmap_open_info; mp->type; mp++) htable_enter(mkmap_open_hash, mp->type, (char *) mp); }
int forward_init(void) { /* * Sanity checks. */ if (forward_dt != 0) msg_panic("forward_init: missing forward_finish call"); forward_dt = htable_create(0); return (0); }
void test_htable_erase() { htable *ht = htable_create(); htable_insert(ht, "one", "1st value"); htable_insert(ht, "two", "2nd value"); htable_erase(ht, "one"); assert(0 == htable_count(ht, "one") && "Bucket with key one should not exist."); htable_destroy(ht); }
static void post_jail_init(char *service_name, char **unused_argv) { const char *sep = ", \t\r\n"; char *saved_filter; char *bp; char *type_name; /* * Are we proxy writer? */ if (strcmp(service_name, MAIL_SERVICE_PROXYWRITE) == 0) proxy_writer = 1; else if (strcmp(service_name, MAIL_SERVICE_PROXYMAP) != 0) msg_fatal("service name must be one of %s or %s", MAIL_SERVICE_PROXYMAP, MAIL_SERVICE_PROXYMAP); /* * Pre-allocate buffers. */ request = vstring_alloc(10); request_map = vstring_alloc(10); request_key = vstring_alloc(10); request_value = vstring_alloc(10); map_type_name_flags = vstring_alloc(10); /* * Prepare the pre-approved list of proxied tables. */ saved_filter = bp = mystrdup(proxy_writer ? var_proxy_write_maps : var_proxy_read_maps); proxy_auth_maps = htable_create(13); while ((type_name = mystrtok(&bp, sep)) != 0) { if (strncmp(type_name, PROXY_COLON, PROXY_COLON_LEN)) continue; do { type_name += PROXY_COLON_LEN; } while (!strncmp(type_name, PROXY_COLON, PROXY_COLON_LEN)); if (strchr(type_name, ':') != 0 && htable_locate(proxy_auth_maps, type_name) == 0) (void) htable_enter(proxy_auth_maps, type_name, (char *) 0); } myfree(saved_filter); /* * Never, ever, get killed by a master signal, as that could corrupt a * persistent database when we're in the middle of an update. */ if (proxy_writer != 0) setsid(); }
/** * Clear all upload statistic entries from the GtkTreeModel. * */ void upload_stats_gui_clear_model(void) { GtkListStore *store; store = GTK_LIST_STORE(gtk_tree_view_get_model(upload_stats_treeview)); if (store) { gtk_list_store_clear(store); } if (ht_uploads) { htable_foreach(ht_uploads, free_upload_data, NULL); htable_free_null(&ht_uploads); ht_uploads = NOT_LEAKING(htable_create(HASH_KEY_SELF, 0)); } }
void fiber_io_check(void) { if (__thread_fiber != NULL) { if (__thread_fiber->ev_fiber == NULL) { __thread_fiber->ev_fiber = acl_fiber_create( fiber_io_loop, __thread_fiber->event, STACK_SIZE); __thread_fiber->io_count = 0; __thread_fiber->nsleeping = 0; __thread_fiber->io_stop = 0; ring_init(&__thread_fiber->ev_timer); } return; } if (pthread_once(&__once_control, thread_init) != 0) { msg_fatal("%s(%d), %s: pthread_once error %s", __FILE__, __LINE__, __FUNCTION__, last_serror()); } var_maxfd = open_limit(0); if (var_maxfd <= 0) { var_maxfd = MAXFD; } __thread_fiber = (FIBER_TLS *) malloc(sizeof(FIBER_TLS)); __thread_fiber->event = event_create(var_maxfd); __thread_fiber->ev_fiber = acl_fiber_create(fiber_io_loop, __thread_fiber->event, STACK_SIZE); __thread_fiber->io_count = 0; __thread_fiber->nsleeping = 0; __thread_fiber->io_stop = 0; ring_init(&__thread_fiber->ev_timer); #ifdef SYS_WIN __thread_fiber->events = htable_create(var_maxfd); #else __thread_fiber->events = (FILE_EVENT **) calloc(var_maxfd, sizeof(FILE_EVENT*)); #endif if (__pthread_self() == main_thread_self()) { __main_fiber = __thread_fiber; atexit(fiber_io_main_free); } else if (pthread_setspecific(__fiber_key, __thread_fiber) != 0) { msg_fatal("pthread_setspecific error!"); } }
DELIVERED_HDR_INFO *delivered_hdr_init(VSTREAM *fp, off_t offset, int flags) { char *cp; DELIVERED_HDR_INFO *info; const HEADER_OPTS *hdr; /* * Sanity check. */ info = (DELIVERED_HDR_INFO *) mymalloc(sizeof(*info)); info->flags = flags; info->buf = vstring_alloc(10); info->table = htable_create(0); if (vstream_fseek(fp, offset, SEEK_SET) < 0) msg_fatal("seek queue file %s: %m", VSTREAM_PATH(fp)); /* * XXX Assume that mail_copy() produces delivered-to headers that fit in * a REC_TYPE_NORM record. Lowercase the delivered-to addresses for * consistency. * * XXX Don't get bogged down by gazillions of delivered-to headers. */ #define DELIVERED_HDR_LIMIT 1000 while (rec_get(fp, info->buf, 0) == REC_TYPE_NORM && info->table->used < DELIVERED_HDR_LIMIT) { if (is_header(STR(info->buf))) { if ((hdr = header_opts_find(STR(info->buf))) != 0 && hdr->type == HDR_DELIVERED_TO) { cp = STR(info->buf) + strlen(hdr->name) + 1; while (ISSPACE(*cp)) cp++; if (info->flags & FOLD_ADDR_ALL) fold_addr(cp, info->flags); if (msg_verbose) msg_info("delivered_hdr_init: %s", cp); htable_enter(info->table, cp, (char *) 0); } } else if (ISSPACE(STR(info->buf)[0])) { continue; } else { break; } } return (info); }
DICT *dict_ht_open(const char *name, int unused_open_flags, int dict_flags) { DICT_HT *dict_ht; dict_ht = (DICT_HT *) dict_alloc(DICT_TYPE_HT, name, sizeof(*dict_ht)); dict_ht->dict.lookup = dict_ht_lookup; dict_ht->dict.update = dict_ht_update; dict_ht->dict.sequence = dict_ht_sequence; dict_ht->dict.close = dict_ht_close; dict_ht->dict.flags = dict_flags | DICT_FLAG_FIXED; if (dict_flags & DICT_FLAG_FOLD_FIX) dict_ht->dict.fold_buf = vstring_alloc(10); dict_ht->table = htable_create(0); dict_ht->dict.owner.status = DICT_OWNER_TRUSTED; return (&dict_ht->dict); }
void test_htable_get() { htable *ht = htable_create(); htable_insert(ht, "two", "2nd value"); assert(NULL == htable_get(ht, "one") && "First value should be NULL"); assert(NULL != htable_get(ht, "two") && "Second value should not equal NULL"); assert(0 == strcmp("2nd value", htable_get(ht, "two")) && "Second value should be equal to 2nd value"); htable_destroy(ht); }
DR_EXPORT void dr_init(client_id_t id) { htable_mutex = dr_mutex_create(); /* global HASH_BITS-bit addressed hash table */ htable = htable_create(NULL/*global*/); dr_register_exit_event(event_exit); dr_register_bb_event(event_basic_block); dr_register_delete_event(event_fragment_deleted); dr_register_end_trace_event(query_end_trace); /* make it easy to tell, by looking at log file, which client executed */ dr_log(NULL, LOG_ALL, 1, "Client 'inline' initializing\n"); num_complete_inlines = 0; }