/**** Global functions definitions. ****/ TA_Dict *TA_DictAlloc( unsigned int flags, void (*freeValueFunc)( void *) ) { TA_PrivDictInfo *theDict; /* Alloc the structure used as an handle for this dictionary. */ theDict = (TA_PrivDictInfo *) TA_Malloc( sizeof( TA_PrivDictInfo ) ); if( !theDict ) return NULL; theDict->flags = flags; /* Create the Kazlib dictionary. */ if( flags & TA_DICT_KEY_ONE_STRING ) dict_init( &theDict->d, DICTCOUNT_T_MAX, compareFunction_S ); else if( flags & TA_DICT_KEY_TWO_STRING ) dict_init( &theDict->d, DICTCOUNT_T_MAX, compareFunction_S ); else if( flags & TA_DICT_KEY_INTEGER ) dict_init( &theDict->d, DICTCOUNT_T_MAX, compareFunction_I ); /* Keep a copy of the freeValueFunc pointer for later use. */ theDict->freeValueFunc = freeValueFunc; return (TA_Dict *)theDict; }
/**** Global functions definitions. ****/ TA_Dict *TA_DictAlloc( TA_Libc *libHandle, unsigned int flags, void (*freeValueFunc)( TA_Libc *libHandle, void *) ) { TA_PrivDictInfo *theDict; if( !libHandle ) return NULL; /* Alloc the structure used as an handle for this dictionary. */ theDict = (TA_PrivDictInfo *) TA_Malloc( libHandle, sizeof( TA_PrivDictInfo ) ); if( !theDict ) return NULL; theDict->flags = flags; /* Create the Kazlib dictionary. */ if( flags & TA_DICT_KEY_ONE_STRING ) dict_init( libHandle, &theDict->d, DICTCOUNT_T_MAX, compareFunction_S ); else if( flags & TA_DICT_KEY_TWO_STRING ) dict_init( libHandle, &theDict->d, DICTCOUNT_T_MAX, compareFunction_S ); else if( flags & TA_DICT_KEY_INTEGER ) dict_init( libHandle, &theDict->d, DICTCOUNT_T_MAX, compareFunction_I ); /* Keep a copy of the freeValueFunc pointer for later use. */ theDict->freeValueFunc = freeValueFunc; /* Remember to which memory context we belong. */ theDict->libHandle = libHandle; return (TA_Dict *)theDict; }
int main(int argc, char *argv[]) { bin_mdef_t *mdef; dict_t *dict; cmd_ln_t *config; int i; char buf[100]; TEST_ASSERT(config = cmd_ln_init(NULL, NULL, FALSE, "-dict", MODELDIR "/en-us/cmudict-en-us.dict", "-fdict", MODELDIR "/en-us/en-us/noisedict", NULL)); /* Test dictionary in standard fashion. */ TEST_ASSERT(mdef = bin_mdef_read(NULL, MODELDIR "/en-us/en-us/mdef")); TEST_ASSERT(dict = dict_init(config, mdef, NULL)); printf("Word ID (CARNEGIE) = %d\n", dict_wordid(dict, "CARNEGIE")); printf("Word ID (ASDFASFASSD) = %d\n", dict_wordid(dict, "ASDFASFASSD")); TEST_EQUAL(0, dict_write(dict, "_cmu07a.dic", NULL)); TEST_EQUAL(0, system("diff -uw " MODELDIR "/en-us/cmudict-en-us.dict _cmu07a.dic")); dict_free(dict); bin_mdef_free(mdef); /* Now test an empty dictionary. */ TEST_ASSERT(dict = dict_init(NULL, NULL, NULL)); printf("Word ID(<s>) = %d\n", dict_wordid(dict, "<s>")); TEST_ASSERT(BAD_S3WID != dict_add_word(dict, "FOOBIE", NULL, 0)); TEST_ASSERT(BAD_S3WID != dict_add_word(dict, "BLETCH", NULL, 0)); printf("Word ID(FOOBIE) = %d\n", dict_wordid(dict, "FOOBIE")); printf("Word ID(BLETCH) = %d\n", dict_wordid(dict, "BLETCH")); TEST_ASSERT(dict_real_word(dict, dict_wordid(dict, "FOOBIE"))); TEST_ASSERT(dict_real_word(dict, dict_wordid(dict, "BLETCH"))); TEST_ASSERT(!dict_real_word(dict, dict_wordid(dict, "</s>"))); dict_free(dict); /* Test to add 500k words. */ TEST_ASSERT(dict = dict_init(NULL, NULL, NULL)); for (i = 0; i < 500000; i++) { sprintf(buf, "word_%d", i); TEST_ASSERT(BAD_S3WID != dict_add_word(dict, buf, NULL, 0)); } dict_free(dict); cmd_ln_free_r(config); return 0; }
Node* node_new(int type) { Node* node = mem_new(Node); node->type = type; node->filename = NULL; node->line = -1; array_init( &(node->children), Node*); dict_init( &(node->props_strings), sizeof(char*), sizeof(char*), dict_hash_string, dict_equal_string ); dict_init( &(node->props_nodes), sizeof(char*), sizeof(Node*), dict_hash_string, dict_equal_string ); return node; }
/* * Load and cross-check all models (acoustic/lexical/linguistic). */ static void models_init ( void ) { dict_t *dict; /* HMM model definition */ mdef = mdef_init ((char *) cmd_ln_access("-mdeffn")); /* Dictionary */ dict = dict_init ((char *) cmd_ln_access("-dictfn"), (char *) cmd_ln_access("-fdictfn")); /* HACK!! Make sure SILENCE_WORD, START_WORD and FINISH_WORD are in dictionary */ silwid = dict_wordid (SILENCE_WORD); startwid = dict_wordid (START_WORD); finishwid = dict_wordid (FINISH_WORD); if (NOT_WID(silwid) || NOT_WID(startwid) || NOT_WID(finishwid)) { E_FATAL("%s, %s, or %s missing from dictionary\n", SILENCE_WORD, START_WORD, FINISH_WORD); } if ((dict->filler_start > dict->filler_end) || (! dict_filler_word (silwid))) E_FATAL("%s must occur (only) in filler dictionary\n", SILENCE_WORD); /* No check that alternative pronunciations for filler words are in filler range!! */ /* LM */ lm_read ((char *) cmd_ln_access("-lmfn"), ""); /* Filler penalties */ fillpen_init ((char *) cmd_ln_access("-fillpenfn"), dict->filler_start, dict->filler_end); }
static int index_storage_get_dict(struct mailbox *box, enum mail_attribute_type type, struct dict **dict_r, const char **mailbox_prefix_r) { struct mail_storage *storage = box->storage; struct mail_namespace *ns; struct mailbox_metadata metadata; struct dict_settings set; const char *error; if (mailbox_get_metadata(box, MAILBOX_METADATA_GUID, &metadata) < 0) return -1; *mailbox_prefix_r = guid_128_to_string(metadata.guid); ns = mailbox_get_namespace(box); if (type == MAIL_ATTRIBUTE_TYPE_PRIVATE) { /* private attributes are stored in user's own dict */ return index_storage_get_user_dict(storage, storage->user, dict_r); } else if (ns->user == ns->owner) { /* user owns the mailbox. shared attributes are stored in the same dict. */ return index_storage_get_user_dict(storage, storage->user, dict_r); } else if (ns->owner != NULL) { /* accessing shared attribute of a shared mailbox. use the owner's dict. */ return index_storage_get_user_dict(storage, ns->owner, dict_r); } /* accessing shared attributes of a public mailbox. no user owns it, so use the storage's dict. */ if (storage->_shared_attr_dict != NULL) { *dict_r = storage->_shared_attr_dict; return 0; } if (*storage->set->mail_attribute_dict == '\0') { mail_storage_set_error(storage, MAIL_ERROR_NOTPOSSIBLE, "Mailbox attributes not enabled"); return -1; } if (storage->shared_attr_dict_failed) { mail_storage_set_internal_error(storage); return -1; } memset(&set, 0, sizeof(set)); set.username = storage->user->username; set.base_dir = storage->user->set->base_dir; if (mail_user_get_home(storage->user, &set.home_dir) <= 0) set.home_dir = NULL; if (dict_init(storage->set->mail_attribute_dict, &set, &storage->_shared_attr_dict, &error) < 0) { mail_storage_set_critical(storage, "mail_attribute_dict: dict_init(%s) failed: %s", storage->set->mail_attribute_dict, error); storage->shared_attr_dict_failed = TRUE; return -1; } *dict_r = storage->_shared_attr_dict; return 0; }
static void models_init(void) { mdef = mdef_init(cmd_ln_str_r(config, "-mdef"), 1); dict = dict_init(mdef, cmd_ln_str_r(config, "-dict"), cmd_ln_str_r(config, "-fdict"), cmd_ln_boolean_r(config, "-lts_mismatch"), cmd_ln_boolean_r(config, "-mdef_fillers"), FALSE, TRUE); lmset = lmset_init(cmd_ln_str_r(config, "-lm"), cmd_ln_str_r(config, "-lmctlfn"), cmd_ln_str_r(config, "-ctl_lm"), cmd_ln_str_r(config, "-lmname"), cmd_ln_str_r(config, "-lmdumpdir"), cmd_ln_float32_r(config, "-lw"), cmd_ln_float32_r(config, "-wip"), cmd_ln_float32_r(config, "-uw"), dict, logmath); /* Filler penalties */ fpen = fillpen_init(dict, cmd_ln_str_r(config, "-fillpen"), cmd_ln_float32_r(config, "-silprob"), cmd_ln_float32_r(config, "-fillprob"), cmd_ln_float32_r(config, "-lw"), cmd_ln_float32_r(config, "-wip"), logmath); }
int sieve_dict_storage_get_dict (struct sieve_dict_storage *dstorage, struct dict **dict_r, enum sieve_error *error_r) { struct sieve_storage *storage = &dstorage->storage; struct sieve_instance *svinst = storage->svinst; struct dict_settings dict_set; const char *error; int ret; if ( dstorage->dict == NULL ) { memset(&dict_set, 0, sizeof(dict_set)); dict_set.username = dstorage->username; dict_set.base_dir = svinst->base_dir; ret = dict_init(dstorage->uri, &dict_set, &dstorage->dict, &error); if ( ret < 0 ) { sieve_storage_set_critical(storage, "Failed to initialize dict with data `%s' for user `%s': %s", dstorage->uri, dstorage->username, error); *error_r = SIEVE_ERROR_TEMP_FAILURE; return -1; } } *dict_r = dstorage->dict; return 0; }
main (int32 argc, char *argv[]) { mdef_t *m; dict_t *d; char wd[1024]; s3wid_t wid; int32 p; if (argc < 3) E_FATAL("Usage: %s {mdeffile | NULL} dict [fillerdict]\n", argv[0]); m = (strcmp (argv[1], "NULL") != 0) ? mdef_init (argv[1]) : NULL; d = dict_init (m, argv[2], ((argc > 3) ? argv[3] : NULL), '_'); for (;;) { printf ("word> "); scanf ("%s", wd); wid = dict_wordid (d, wd); if (NOT_WID(wid)) E_ERROR("Unknown word\n"); else { for (wid = dict_basewid(d, wid); IS_WID(wid); wid = d->word[wid].alt) { printf ("%s\t", dict_wordstr(d, wid)); for (p = 0; p < d->word[wid].pronlen; p++) printf (" %s", dict_ciphone_str (d, wid, p)); printf ("\n"); } } } }
Dict* dict_new(uint16 key_size, uint16 value_size, DictHashFunc hash_func, DictEqualFunc equal_func) { Dict* d = mem_new(Dict); dict_init(d, key_size, value_size, hash_func, equal_func); return d; }
int main(int argc, char *argv[]) { int ret = 0; DICT_STR *my_dict_str = NULL; ret = dict_init(&my_dict_str, argc, argv); if (ERRNO_INIT == ret) { /* 如果没有初始化此结构体,说明用户执行 --help , * 并没有出错,所有此处不打印出错信息,直接返回。 * 而对于程序来说,--help或者错误的参数也是程序 * 没有正确执行的一部分,所以main仍返回错误。*/ if (NULL != my_dict_str) printf("[DICT]%s: Initialization Failed.", __func__); return ret; } ret = dict_exec(my_dict_str); if (ERRNO_EXEC == ret) printf("[DICT]%s: Execution Failed.", __func__); dict_free(my_dict_str); return ret; }
/////////////////////// //test <test.dict> int main(int argc, char * argv[]) { struct mg_server * server; // if(argc < 2) { printf("demo: %s <test.dict>\n", argv[0]); exit(0); } // dbox = dict_init(); dict_load(dbox, argv[1]); // server = mg_create_server(NULL, ev_handler); // mg_set_option(server, "listening_port", "8089"); // for(;;) { mg_poll_server(server, 1000); } // mg_destroy_server(&server); // dict_free(dbox); // return 0; }
static int clone_breakpoints(Process * proc, Process * orig_proc) { /* When copying breakpoints, we also have to copy the * referenced symbols, and link them properly. */ Dict * map = dict_init(&dict_key2hash_int, &dict_key_cmp_int); struct library_symbol * it = proc->list_of_symbols; proc->list_of_symbols = NULL; for (; it != NULL; it = it->next) { struct library_symbol * libsym = clone_library_symbol(it); if (libsym == NULL) { int save_errno; err: save_errno = errno; destroy_library_symbol_chain(proc->list_of_symbols); dict_clear(map); errno = save_errno; return -1; } libsym->next = proc->list_of_symbols; proc->list_of_symbols = libsym; if (dict_enter(map, it, libsym) != 0) goto err; } proc->breakpoints = dict_clone2(orig_proc->breakpoints, address_clone, breakpoint_clone, map); if (proc->breakpoints == NULL) goto err; dict_clear(map); return 0; }
const char * my_demangle(const char *function_name) { const char *tmp, *fn_copy; #ifdef USE_CXA_DEMANGLE extern char *__cxa_demangle(const char *, char *, size_t *, int *); #endif debug(DEBUG_FUNCTION, "my_demangle(name=%s)", function_name); if (!d) d = dict_init(dict_key2hash_string, dict_key_cmp_string); tmp = dict_find_entry(d, (void *)function_name); if (!tmp) { fn_copy = strdup(function_name); #ifdef HAVE_LIBIBERTY tmp = cplus_demangle(function_name, DMGL_ANSI | DMGL_PARAMS); #elif defined USE_CXA_DEMANGLE int status = 0; tmp = __cxa_demangle(function_name, NULL, NULL, &status); #endif if (!tmp) tmp = fn_copy; if (tmp) dict_enter(d, (void *)fn_copy, (void *)tmp); } return tmp; }
static struct dict * cmd_dict_init_full(int *argc, char **argv[], int own_arg_count, int key_arg_idx, doveadm_command_t *cmd, enum dict_iterate_flags *iter_flags) { const char *getopt_args = iter_flags == NULL ? "u:" : "1Ru:V"; struct dict *dict; const char *error, *username = ""; int c; while ((c = getopt(*argc, *argv, getopt_args)) > 0) { switch (c) { case '1': i_assert(iter_flags != NULL); *iter_flags |= DICT_ITERATE_FLAG_EXACT_KEY; break; case 'R': i_assert(iter_flags != NULL); *iter_flags |= DICT_ITERATE_FLAG_RECURSE; break; case 'V': i_assert(iter_flags != NULL); *iter_flags |= DICT_ITERATE_FLAG_NO_VALUE; break; case 'u': username = optarg; break; default: dict_cmd_help(cmd); } } *argc -= optind; *argv += optind; if (*argc != 1 + own_arg_count) dict_cmd_help(cmd); dict_drivers_register_builtin(); if (dict_init((*argv)[0], DICT_DATA_TYPE_STRING, username, doveadm_settings->base_dir, &dict, &error) < 0) i_fatal("dict_init(%s) failed: %s", (*argv)[0], error); *argc += 1; *argv += 1; if (key_arg_idx >= 0) { const char *key = (*argv)[key_arg_idx]; if (strncmp(key, DICT_PATH_PRIVATE, strlen(DICT_PATH_PRIVATE)) != 0 && strncmp(key, DICT_PATH_SHARED, strlen(DICT_PATH_SHARED)) != 0) { i_fatal("Key must begin with '"DICT_PATH_PRIVATE "' or '"DICT_PATH_SHARED"': %s", key); } if (username[0] == '\0' && strncmp(key, DICT_PATH_PRIVATE, strlen(DICT_PATH_PRIVATE)) == 0) i_fatal("-u must be specified for "DICT_PATH_PRIVATE" keys"); } return dict; }
Dict* dict_new(uint16 key_size, uint16 value_size, DictHashFunc hash_func, DictEqualFunc equal_func) { assert(key_size > 0); assert(value_size > 0); assert(hash_func != NULL); assert(equal_func != NULL); Dict* d = mem_new(Dict); dict_init(d, key_size, value_size, hash_func, equal_func); return d; }
dict_t *dict_create(dictcount_t maxcount, dict_comp_t comp) { dict_t *dict = (dict_t *) malloc(sizeof *dict); if (dict) dict_init(dict, maxcount, comp); return dict; }
END_TEST START_TEST(test_dict_create2) { Dict dict; dict_init(&dict); for (int i = 0; i < 256; i++) ck_assert_int_eq(dict.nodes[i].icount, 0); dict_destroy(&dict); }
int ps_load_dict(ps_decoder_t *ps, char const *dictfile, char const *fdictfile, char const *format) { cmd_ln_t *newconfig; dict2pid_t *d2p; dict_t *dict; hash_iter_t *search_it; /* Create a new scratch config to load this dict (so existing one * won't be affected if it fails) */ newconfig = cmd_ln_init(NULL, ps_args(), TRUE, NULL); cmd_ln_set_boolean_r(newconfig, "-dictcase", cmd_ln_boolean_r(ps->config, "-dictcase")); cmd_ln_set_str_r(newconfig, "-dict", dictfile); if (fdictfile) cmd_ln_set_str_r(newconfig, "-fdict", fdictfile); else cmd_ln_set_str_r(newconfig, "-fdict", cmd_ln_str_r(ps->config, "-fdict")); /* Try to load it. */ if ((dict = dict_init(newconfig, ps->acmod->mdef, ps->acmod->lmath)) == NULL) { cmd_ln_free_r(newconfig); return -1; } /* Reinit the dict2pid. */ if ((d2p = dict2pid_build(ps->acmod->mdef, dict)) == NULL) { cmd_ln_free_r(newconfig); return -1; } /* Success! Update the existing config to reflect new dicts and * drop everything into place. */ cmd_ln_free_r(newconfig); cmd_ln_set_str_r(ps->config, "-dict", dictfile); if (fdictfile) cmd_ln_set_str_r(ps->config, "-fdict", fdictfile); dict_free(ps->dict); ps->dict = dict; dict2pid_free(ps->d2p); ps->d2p = d2p; /* And tell all searches to reconfigure themselves. */ for (search_it = hash_table_iter(ps->searches); search_it; search_it = hash_table_iter_next(search_it)) { if (ps_search_reinit(hash_entry_val(search_it->ent), dict, d2p) < 0) { hash_table_iter_free(search_it); return -1; } } return 0; }
int ps_load_dict(ps_decoder_t *ps, char const *dictfile, char const *fdictfile, char const *format) { cmd_ln_t *newconfig; dict2pid_t *d2p; dict_t *dict; gnode_t *gn; int rv; /* Create a new scratch config to load this dict (so existing one * won't be affected if it fails) */ newconfig = cmd_ln_init(NULL, ps_args(), TRUE, NULL); cmd_ln_set_boolean_r(newconfig, "-dictcase", cmd_ln_boolean_r(ps->config, "-dictcase")); cmd_ln_set_str_r(newconfig, "-dict", dictfile); if (fdictfile) cmd_ln_set_str_r(newconfig, "-fdict", fdictfile); else cmd_ln_set_str_r(newconfig, "-fdict", cmd_ln_str_r(ps->config, "-fdict")); /* Try to load it. */ if ((dict = dict_init(newconfig, ps->acmod->mdef)) == NULL) { cmd_ln_free_r(newconfig); return -1; } /* Reinit the dict2pid. */ if ((d2p = dict2pid_build(ps->acmod->mdef, dict)) == NULL) { cmd_ln_free_r(newconfig); return -1; } /* Success! Update the existing config to reflect new dicts and * drop everything into place. */ cmd_ln_free_r(newconfig); cmd_ln_set_str_r(ps->config, "-dict", dictfile); if (fdictfile) cmd_ln_set_str_r(ps->config, "-fdict", fdictfile); dict_free(ps->dict); ps->dict = dict; dict2pid_free(ps->d2p); ps->d2p = d2p; /* And tell all searches to reconfigure themselves. */ for (gn = ps->searches; gn; gn = gnode_next(gn)) { ps_search_t *search = gnode_ptr(gn); if ((rv = ps_search_reinit(search, dict, d2p)) < 0) return rv; } return 0; }
int main(int argc, char *argv[]) { ngram_trie_t *t; dict_t *dict; bin_mdef_t *mdef; logmath_t *lmath; cmd_ln_t *config; FILE *arpafh; config = cmd_ln_init(NULL, ps_args(), TRUE, "-hmm", TESTDATADIR "/hub4wsj_sc_8k", "-dict", TESTDATADIR "/bn10000.homos.dic", NULL); ps_init_defaults(config); lmath = logmath_init(cmd_ln_float32_r(config, "-logbase"), 0, FALSE); mdef = bin_mdef_read(config, cmd_ln_str_r(config, "-mdef")); dict = dict_init(config, mdef); t = ngram_trie_init(dict, lmath); arpafh = fopen(TESTDATADIR "/bn10000.3g.arpa", "r"); ngram_trie_read_arpa(t, arpafh); fclose(arpafh); /* Test 1, 2, 3-gram probs without backoff. */ test_lookups(t, lmath); arpafh = fopen("tmp.bn10000.3g.arpa", "w"); ngram_trie_write_arpa(t, arpafh); fclose(arpafh); ngram_trie_free(t); t = ngram_trie_init(dict, lmath); arpafh = fopen("tmp.bn10000.3g.arpa", "r"); ngram_trie_read_arpa(t, arpafh); fclose(arpafh); /* Test 1, 2, 3-gram probs without backoff. */ test_lookups(t, lmath); /* Test adding nodes. */ test_add_nodes(t, lmath); ngram_trie_free(t); dict_free(dict); logmath_free(lmath); bin_mdef_free(mdef); cmd_ln_free_r(config); return 0; }
dict_t *fc_solve_kaz_tree_create(dict_comp_t comp, void * context) #endif { dict_t *dict = (dict_t *) malloc(sizeof *dict); if (dict) dict_init(dict, comp); dict->context = context; return dict; }
void dictExample() { dict_t *d = (dict_t *)malloc(sizeof(dict_t)); char *var; char *key1 = strToHeap("key1"); char *key2 = strToHeap("key2"); char *key3 = strToHeap("key3"); char *value1 = strToHeap("var1"); char *value2 = strToHeap("var2"); char *value3 = strToHeap("var3"); dict_init(d); dict_set(d, key1, value1); dict_set(d, key2, value2); dict_set(d, key3, value3); dict_get(d, "key1", (void **)&var); printf("key1=>%s\n", var); dict_get(d, "key2", (void **)&var); printf("key1=>%s\n", var); dict_get(d, "key3", (void **)&var); printf("key1=>%s\n", var); printf("dict size:%d\n", dict_size(d)); if (1 == dict_del(d, key3)) { key3 = NULL; value3 = NULL; printf("del key3 done\n"); } char **ks = (char **)malloc(dict_size(d)*sizeof(char*)); int i; dict_keys(d, ks); for(i = 0; i < dict_size(d); i++) printf("%s ",*(ks+i) ); printf("\n"); char *k, *v; while(dict_iter(d, &k, (void **)&v)) printf("%s = >%s\n", k, v); dict_reset(d); dict_destory(d); free(d); }
main (int32 argc, char *argv[]) { dict_t **d; int32 i, k, p, wid; char line[16384], *wp[1024]; if (argc < 2) { E_INFO("Usage: %s dictfile [dictfile ...] < vocabfile\n", argv[0]); exit(0); } d = (dict_t **) ckd_calloc (argc-1, sizeof(dict_t *)); for (i = 1; i < argc; i++) d[i-1] = dict_init (NULL, argv[i], NULL, 0); while (fgets (line, sizeof(line), stdin) != NULL) { if ((k = str2words (line, wp, 1024)) < 0) E_FATAL("Line too long: %s\n", line); if (k > 2) E_FATAL("Vocab entry contains too many words\n"); if (k == 0) continue; if (k == 1) wp[1] = wp[0]; /* Look up word in each dictionary until found */ k = 0; for (i = 0; (i < argc-1) && (k == 0); i++) { wid = dict_wordid (d[i], wp[1]); if (NOT_WID(wid)) continue; for (wid = dict_basewid(d[i], wid); IS_WID(wid); wid = dict_nextalt(d[i], wid)) { k++; if (k == 1) printf ("%s\t", wp[0]); else printf ("%s(%d)\t", wp[0], k); for (p = 0; p < dict_pronlen(d[i], wid); p++) printf (" %s", dict_ciphone_str (d[i], wid, p)); printf ("\n"); } } if (k == 0) E_ERROR("No pronunciation for: '%s'\n", wp[0]); } }
/* * Do any per-module initialization. e.g. set up connections * to external databases, read configuration files, set up * dictionary entries, etc. * */ static int radius_init(void) { /* Initialize the dictionary */ if (dict_init(radius_dir, RADIUS_DICTIONARY) != 0) { radlog(L_ERR|L_CONS, "Errors reading dictionary %s/%s: %s", radius_dir, RADIUS_DICTIONARY, librad_errstr); return -1; } /* * Everything's OK, return without an error. */ return 0; }
void test_dict_large(const dict_api* api, uint64_t N) { dict* table; dict_init(&table, api); log_info("Testing inserting %" PRIu64 " elements into %s...", N, api->name); for (uint64_t i = 0; i < N; i++) { if (i % 100000 == 0) log_info("%" PRIu64, i); const uint64_t key = make_key(i), value = make_value(i); // log_info("%" PRIu64 " => %" PRIu64, key, value); CHECK(dict_insert(table, key, value), "cannot insert"); } dict_destroy(&table); }
ledger_status ledger_open_context(ledger_ctx *ctx, const char *root_directory) { ledger_status rc; ctx->root_directory = root_directory; dict_init(&ctx->topics, MAX_TOPICS, (dict_comp_t)strcmp); ledger_position_storage_init(&ctx->position_storage); rc = ledger_position_storage_open(&ctx->position_storage, root_directory); ledger_check_rc(rc == LEDGER_OK, rc, "Failed to open position storage"); return LEDGER_OK; error: return rc; }
main (int32 argc, char *argv[]) { char *reffile, *mdeffile, *dictfile, *fdictfile, *homfile; if (argc == 1) { cmd_ln_print_help (stderr, arglist); exit(0); } cmd_ln_parse (arglist, argc, argv); if ((mdeffile = (char *) cmd_ln_access ("-mdef")) == NULL) E_FATAL("-mdef argument missing\n"); if ((dictfile = (char *) cmd_ln_access ("-dict")) == NULL) E_FATAL("-dict argument missing\n"); if ((fdictfile = (char *) cmd_ln_access ("-fdict")) == NULL) E_FATAL("-fdict argument missing\n"); if ((reffile = (char *) cmd_ln_access ("-ref")) == NULL) E_FATAL("-ref argument missing\n"); unlimit(); mdef = mdef_init (mdeffile); if (mdef->n_ciphone <= 0) E_FATAL("0 CIphones in %s\n", mdeffile); dict = dict_init (mdef, dictfile, fdictfile); oovbegin = dict->n_word; startwid = dict_wordid (dict, "<s>"); finishwid = dict_wordid (dict, "</s>"); silwid = dict_wordid (dict, (char *) cmd_ln_access("-sil")); assert (dict_filler_word (dict, silwid)); homlist = NULL; if ((homfile = (char *) cmd_ln_access ("-hom")) != NULL) homfile_load (homfile); process_reffile (reffile); #if (0 && (! WIN32)) fflush (stdout); fflush (stderr); system ("ps aguxwww | grep dpalign"); #endif exit(0); }
static int index_storage_get_user_dict(struct mail_storage *err_storage, struct mail_user *user, struct dict **dict_r) { struct dict_settings dict_set; struct mail_namespace *ns; struct mail_storage *attr_storage; const char *error; if (user->_attr_dict != NULL) { *dict_r = user->_attr_dict; return 0; } if (user->attr_dict_failed) { mail_storage_set_internal_error(err_storage); return -1; } ns = mail_user_find_attribute_namespace(user); if (ns == NULL) { /* probably never happens? */ mail_storage_set_error(err_storage, MAIL_ERROR_NOTPOSSIBLE, "Mailbox attributes not available for this mailbox"); return -1; } attr_storage = mail_namespace_get_default_storage(ns); if (*attr_storage->set->mail_attribute_dict == '\0') { mail_storage_set_error(err_storage, MAIL_ERROR_NOTPOSSIBLE, "Mailbox attributes not enabled"); return -1; } memset(&dict_set, 0, sizeof(dict_set)); dict_set.username = user->username; dict_set.base_dir = user->set->base_dir; if (dict_init(attr_storage->set->mail_attribute_dict, &dict_set, &user->_attr_dict, &error) < 0) { mail_storage_set_critical(err_storage, "mail_attribute_dict: dict_init(%s) failed: %s", attr_storage->set->mail_attribute_dict, error); user->attr_dict_failed = TRUE; return -1; } *dict_r = user->_attr_dict; return 0; }
main (int32 argc, char *argv[]) { mdef_t *mdef; dict_t *dict; dict2pid_t *d2p; if (argc != 4) usage(argv[0]); logs3_init (1.0003); mdef = mdef_init (argv[1]); dict = dict_init (mdef, argv[2], argv[3], 0); d2p = dict2pid_build (mdef, dict); dict2pid_dump (stdout, d2p, mdef, dict); }