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