void jl_gc_init(void) { int szc[N_POOLS] = { 8, 12, 16, 20, 24, 28, 32, 36, 40, 44, 48, 52, 56, 64, 72, 80, 88, 96, //#=18 112, 128, 144, 160, 176, 192, 208, 224, 240, 256, 288, 320, 352, 384, 416, 448, 480, 512, 640, 768, 896, 1024, 1536, 2048 }; int i; for(i=0; i < N_POOLS; i++) { norm_pools[i].osize = szc[i]; norm_pools[i].pages = NULL; norm_pools[i].freelist = NULL; ephe_pools[i].osize = szc[i]; ephe_pools[i].pages = NULL; ephe_pools[i].freelist = NULL; } htable_new(&finalizer_table, 0); arraylist_new(&to_finalize, 0); arraylist_new(&preserved_values, 0); arraylist_new(&weak_refs, 0); #ifdef OBJPROFILE htable_new(&obj_counts, 0); #endif }
jl_module_t *jl_new_module(jl_sym_t *name) { jl_module_t *m = (jl_module_t*)allocb(sizeof(jl_module_t)); m->name = name; htable_new(&m->bindings, 0); htable_new(&m->macros, 0); htable_new(&m->modules, 0); arraylist_new(&m->imports, 0); return m; }
jl_module_t *jl_new_module(jl_sym_t *name) { jl_module_t *m = (jl_module_t*)allocobj(sizeof(jl_module_t)); m->type = (jl_type_t*)jl_module_type; m->name = name; htable_new(&m->bindings, 0); htable_new(&m->macros, 0); jl_set_const(m, name, (jl_value_t*)m); if (jl_current_module) jl_set_const(m, jl_current_module->name, (jl_value_t*)jl_current_module); //arraylist_new(&m->imports, 0); return m; }
/** * Creates a hashtable, and inserts words into it. The table is then printed before we free the memory allocated to it. Note: The tablesize of the hashtable is determined by the first command line argument if there is one, with a default table tablesize of 113. The number of statistical snapshots to print is determined by the second command line argument if there is one, with a default number of 10. tablesize = the maximum number of positions in the hash table. word = the string to be inserted into the hash table. ht = the hash table using eith double hashing or linear probing. snapshots = the number of statistical snapshots to be used. @param argc the number of command-line arguments. @param argv an array of strings containing the command-line arguments. @return EXIT_SUCCESS if the program is successful. */ int main(int argc, char **argv) { time_t start,end; bool_t entire_table = FALSE, double_hashing = FALSE, print_stats = FALSE, do_spell_check = FALSE; int tablesize = 113, snapshots = 10; char word[256]; char *filename; htable ht; set_flags(argc, argv, &do_spell_check, &filename, &double_hashing, &entire_table, &print_stats, &snapshots, &tablesize); ht = htable_new(tablesize, (double_hashing) ? DOUBLE_H : LINEAR_P); start = clock(); while (getword(word, sizeof word, stdin) != EOF) { htable_insert(ht, word); } end = clock(); if(do_spell_check) { spell_check(ht,filename,(end-start)/(double)CLOCKS_PER_SEC); } if (entire_table) { htable_print_entire_table(ht, stderr); } if (print_stats) { htable_print_stats(ht, stdout, snapshots); } else if (!do_spell_check){ /* print words and frequencies */ htable_print(ht, stdout); } htable_delete(ht); return EXIT_SUCCESS; }
int main(int argc, char **argv) { int i, len, res; struct htable *table; table = htable_new(16, 0, &htable_cstring_cmpfn, &string_copyfn, &string_freefn); assert(table != NULL); len = sizeof(string_data)/sizeof(string_data[0]); for (i = 0; i < 4; i++) { res = htable_add(table, strlen(string_data[i]), string_data[i], NULL); assert(res == 1); assert(strcmp(table->entries[i]->key, string_data[i]) == 0); } assert(htable_resize(table, 0, 1024) == 1); for (i = 4; i < len; i++) { res = htable_add(table, strlen(string_data[i]), string_data[i], NULL); assert(res == 1); assert(strcmp(table->entries[i]->key, string_data[i]) == 0); } assert(htable_resize(table, 0, 512) == 1); for (i = 0; i < len; i++) { assert(strcmp(table->entries[i]->key, string_data[i]) == 0); } htable_delete(table); return 0; }
fifo_t *fifo_new(size_t size, size_t nmemb) { fifo_t *r; r = malloc(sizeof(fifo_t)); if (!r) goto fail; r->page = malloc(nmemb * sizeof(struct fifo_page)); if (!r->page) goto fail_page; r->data = malloc(nmemb * size); if (!r->data) goto fail_data; r->t = htable_new(nmemb); if (!r->t) goto fail_htable; r->size = size; r->nmemb = nmemb; r->active = 0; r->head = 0; return r; fail_htable: free(r->data); fail_data: free(r->page); fail_page: free(r); fail: return NULL; }
JL_DLLEXPORT jl_module_t *jl_new_module(jl_sym_t *name) { jl_ptls_t ptls = jl_get_ptls_states(); jl_module_t *m = (jl_module_t*)jl_gc_alloc(ptls, sizeof(jl_module_t), jl_module_type); JL_GC_PUSH1(&m); assert(jl_is_symbol(name)); m->name = name; m->parent = NULL; m->istopmod = 0; static unsigned int mcounter; // simple counter backup, in case hrtime is not incrementing m->uuid = jl_hrtime() + (++mcounter); if (!m->uuid) m->uuid++; // uuid 0 is invalid m->counter = 0; htable_new(&m->bindings, 0); arraylist_new(&m->usings, 0); if (jl_core_module) { jl_module_using(m, jl_core_module); } // export own name, so "using Foo" makes "Foo" itself visible jl_set_const(m, name, (jl_value_t*)m); jl_module_export(m, name); JL_GC_POP(); return m; }
/** * @brief Setup routing table */ int tils_routes_init() { _routes = htable_new(); if (_routes == NULL) { return -1; } else { return 0; } }
void init_variables(void) { struct var_entry *p; var_table = htable_new(); for (p = &def_vars[0]; p < &def_vars[sizeof(def_vars) / sizeof(def_vars[0])]; p++) set_variable(p->var, p->val); }
int main(void) { int value; bool done, result; char *cmd, *key, *end, *str_value; char input[256]; struct htable* tbl = htable_new(); if(tbl == NULL) { printf("ERROR: tbl == NULL\n"); return 1; } while(fgets(input, sizeof(input), stdin)) { end = strstr(input, "\n"); if(!end) break; *end = '\0'; if(strcmp(input, "quit") == 0) break; if(strcmp(input, "exit") == 0) break; done = false; value = 0; cmd = input; key = strstr(input, " "); if(key) { *key++ = '\0'; str_value = strstr(key, " "); if(str_value) { *str_value++ = '\0'; value = atoi(str_value); if(strcmp(cmd, "set") == 0) { done = true; result = htable_set(tbl, key, strlen(key), value); } } else { if(strcmp(cmd, "get") == 0) { done = true; result = htable_get(tbl, key, strlen(key), &value); } else if(strcmp(cmd, "del") == 0) { done = true; result = htable_del(tbl, key, strlen(key)); } } } if(done == true) { printf("+OK, cmd = %s, key = %s, value = %d, result = %d, last_error = %d, size = %d, items = %d\n", cmd, key, value, result, tbl->last_error, tbl->size, tbl->items); } else { printf("-INVALID COMMAND, 'set key value', 'get key', 'del key' or 'quit' expected\n"); } } printf("+GOODBYE\n"); htable_free(tbl); return 0; }
void jl_gc_init(void) { int szc[N_POOLS] = { 8, 12, 16, 20, 24, 28, 32, 36, 40, 44, 48, 52, 56, 64, 72, 80, 88, 96, //#=18 112, 128, 144, 160, 176, 192, 208, 224, 240, 256, 288, 320, 352, 384, 416, 448, 480, 512, 640, 768, 896, 1024, 1536, 2048 }; int i; for(i=0; i < N_POOLS; i++) { norm_pools[i].osize = szc[i]; norm_pools[i].pages = NULL; norm_pools[i].freelist = NULL; ephe_pools[i].osize = szc[i]; ephe_pools[i].pages = NULL; ephe_pools[i].freelist = NULL; } htable_new(&finalizer_table, 0); arraylist_new(&to_finalize, 0); arraylist_new(&preserved_values, 0); arraylist_new(&weak_refs, 0); #ifdef OBJPROFILE htable_new(&obj_counts, 0); #endif #ifdef GC_FINAL_STATS process_t0 = clock_now(); #endif #ifdef _P64 // on a big memory machine, set max_collect_interval to totalmem/ncores/2 size_t maxmem = (uv_get_total_memory()/jl_cpu_cores())/2; if (maxmem > max_collect_interval) max_collect_interval = maxmem; #endif }
int main(void) { htable h = htable_new(18143); char word[256]; while (getword(word, sizeof word, stdin) != EOF) { htable_insert(h, word); } htable_print(h, stdout); htable_free(h); return EXIT_SUCCESS; }
value_t fl_read_sexpr(value_t f) { value_t v; fl_readstate_t state; state.prev = readstate; htable_new(&state.backrefs, 8); htable_new(&state.gensyms, 8); state.source = f; readstate = &state; assert(toktype == TOK_NONE); fl_gc_handle(&tokval); v = do_read_sexpr(UNBOUND); fl_free_gc_handles(1); readstate = state.prev; free_readstate(&state); return v; }
jl_module_t *jl_new_module(jl_sym_t *name) { jl_module_t *m = (jl_module_t*)allocobj(sizeof(jl_module_t)); m->type = (jl_value_t*)jl_module_type; m->name = name; htable_new(&m->bindings, 0); jl_set_const(m, name, (jl_value_t*)m); arraylist_new(&m->usings, 0); if (jl_core_module) { jl_module_using(m, jl_core_module); } // export own name, so "using Foo" makes "Foo" itself visible jl_module_export(m, name); return m; }
void test_memory_copy() { int i, len, res; struct htable *table; table = htable_new(512, 0, &htable_cstring_cmpfn, &string_copyfn, &string_freefn); assert(table != NULL); len = sizeof(string_data)/sizeof(string_data[0]); for (i = 0; i < len; i++) { res = htable_add(table, strlen(string_data[i]), string_data[i], NULL); assert(res == 1); assert(strcmp((char *)table->entries[i]->key, string_data[i]) == 0); } htable_delete(table); }
// chars that can follow an operator (e.g. +) and be parsed as part of the operator int jl_op_suffix_char(uint32_t wc) { static htable_t jl_opsuffs; if (!jl_opsuffs.size) { // initialize hash table of suffixes size_t i, opsuffs_len = sizeof(opsuffs) / (sizeof(uint32_t)); htable_t *h = htable_new(&jl_opsuffs, opsuffs_len); assert(sizeof(uint32_t) <= sizeof(void*)); for (i = 0; i < opsuffs_len; ++i) wcharhash_put_r(h, (void*)((uintptr_t)opsuffs[i]), NULL, NULL); } if (wc < 0xA1 || wc > 0x10ffff) return 0; utf8proc_category_t cat = utf8proc_category((utf8proc_int32_t) wc); if (cat == UTF8PROC_CATEGORY_MN || cat == UTF8PROC_CATEGORY_MC || cat == UTF8PROC_CATEGORY_ME) return 1; // use hash table of other allowed characters: primes and sub/superscripts return HT_NOTFOUND != wcharhash_get_r(&jl_opsuffs, (void*)((uintptr_t)wc), NULL); }
int main(int argc, char **argv) { int size; htable h; char word[256]; if (argc <=1 ){ size = 25013; fprintf(stderr, "No arguments given, set htable size to %d\n", size); } else { size = atoi(argv[1]); } h = htable_new(size); while (getword(word, sizeof word, stdin) != EOF) { htable_insert(h, word); } htable_print(h, stdout); htable_free(h); return EXIT_SUCCESS; }
int main(int argc, char **argv) { int i, len, res; struct htable *table; table = htable_new(512, 0, &htable_int32_cmpfn, ©fn, &freefn); assert(table != NULL); len = sizeof(data)/sizeof(data[0]); for (i = 0; i < len; i++) { res = htable_add(table, 4, &data[i], NULL); assert(res == 1); assert(*(int*)table->entries[i]->key == data[i]); } htable_delete(table); return 0; }
long _likely_trace(bool cond, bool expect, const char *condstr, const char *file, unsigned int line) { struct trace *p, trace; if (!htable) htable = htable_new(rehash, NULL); init_trace(&trace, condstr, file, line, expect); p = htable_get(htable, hash_trace(&trace), hash_cmp, &trace); if (!p) p = add_trace(condstr, file, line, expect); p->count++; if (cond == expect) p->right++; return cond; }
utf8proc_int32_t jl_charmap_map(utf8proc_int32_t c, void *ctx) { static htable_t jl_charmap; if (!jl_charmap.size) { // initialize hash table size_t i, charmap_len = sizeof(charmap) / (2*sizeof(uint32_t)); htable_t *h = htable_new(&jl_charmap, charmap_len); assert(sizeof(uint32_t) <= sizeof(void*)); for (i = 0; i < charmap_len; ++i) { /* Store charmap in a hash table. Typecasting codepoints directly to pointer keys works because pointers are at least 32 bits on all Julia-supported systems, and because we never map anything to U+0001 (since HT_NOTFOUND is (void*)1). */ assert((void*)(uintptr_t)charmap[i][1] != HT_NOTFOUND); wcharhash_put_r(h, (void*)((uintptr_t)charmap[i][0]), (void*)((uintptr_t)charmap[i][1]), NULL); } } void *v = wcharhash_get_r(&jl_charmap, (void*)((uintptr_t)c), NULL); return v == HT_NOTFOUND ? c : (utf8proc_int32_t) ((uintptr_t) v); }
JL_DLLEXPORT jl_module_t *jl_new_module(jl_sym_t *name) { jl_module_t *m = (jl_module_t*)jl_gc_allocobj(sizeof(jl_module_t)); jl_set_typeof(m, jl_module_type); JL_GC_PUSH1(&m); assert(jl_is_symbol(name)); m->name = name; m->parent = NULL; m->istopmod = 0; m->uuid = uv_now(uv_default_loop()); m->counter = 0; htable_new(&m->bindings, 0); arraylist_new(&m->usings, 0); if (jl_core_module) { jl_module_using(m, jl_core_module); } // export own name, so "using Foo" makes "Foo" itself visible jl_set_const(m, name, (jl_value_t*)m); jl_module_export(m, name); JL_GC_POP(); return m; }
void jl_init_serializer(void) { htable_new(&ser_tag, 0); htable_new(&deser_tag, 0); htable_new(&fptr_to_id, 0); htable_new(&id_to_fptr, 0); htable_new(&backref_table, 50000); void *tags[] = { jl_symbol_type, jl_tag_kind, jl_bits_kind, jl_struct_kind, jl_func_kind, jl_tuple_type, jl_array_type, jl_expr_type, (void*)LongSymbol_tag, (void*)LongTuple_tag, (void*)LongExpr_tag, (void*)LiteralVal_tag, (void*)SmallInt64_tag, jl_methtable_type, jl_module_type, jl_lambda_info_type, jl_tvar_type, jl_null, jl_any_type, jl_symbol("Any"), jl_symbol("Array"), jl_symbol("TypeVar"), jl_symbol("FuncKind"), jl_symbol("Box"), lambda_sym, body_sym, return_sym, call_sym, colons_sym, null_sym, goto_ifnot_sym, assign_sym, jl_symbol("a"), jl_symbol("b"), jl_symbol("c"), jl_symbol("d"), jl_symbol("e"), jl_symbol("f"), jl_symbol("g"), jl_symbol("h"), jl_symbol("i"), jl_symbol("j"), jl_symbol("k"), jl_symbol("l"), jl_symbol("m"), jl_symbol("n"), jl_symbol("o"), jl_symbol("p"), jl_symbol("q"), jl_symbol("r"), jl_symbol("s"), jl_symbol("t"), jl_symbol("u"), jl_symbol("v"), jl_symbol("w"), jl_symbol("x"), jl_symbol("y"), jl_symbol("z"), jl_symbol("A"), jl_symbol("B"), jl_symbol("C"), jl_symbol("M"), jl_symbol("I"), jl_symbol("N"), jl_symbol("T"), jl_symbol("S"), jl_symbol("X"), jl_symbol("Y"), jl_symbol("add_int"), jl_symbol("sub_int"), jl_symbol("mul_int"), jl_symbol("add_float"), jl_symbol("sub_float"), jl_symbol("mul_float"), jl_symbol("unbox"), jl_symbol("unbox8"), jl_symbol("unbox16"), jl_symbol("unbox32"), jl_symbol("unbox64"), jl_symbol("box"), jl_symbol("boxf32"), jl_symbol("boxf64"), jl_symbol("boxsi32"), jl_symbol("boxsi64"), jl_symbol("eq_int"), jl_symbol("slt_int"), jl_symbol("sle_int"), jl_symbol("ne_int"), jl_symbol("arrayset"), jl_symbol("arrayref"), jl_symbol("convert"), jl_symbol("typeassert"), jl_symbol("getfield"), jl_symbol("_setfield"), jl_symbol("tupleref"), jl_symbol("tuplelen"), jl_symbol("apply_type"), jl_symbol("tuple"), jl_false, jl_true, jl_box_int32(0), jl_box_int32(1), jl_box_int32(2), jl_box_int32(3), jl_box_int32(4), jl_box_int32(5), jl_box_int32(6), jl_box_int32(7), jl_box_int32(8), jl_box_int32(9), jl_box_int32(10), jl_box_int32(11), jl_box_int32(12), jl_box_int32(13), jl_box_int32(14), jl_box_int32(15), jl_box_int32(16), jl_box_int32(17), jl_box_int32(18), jl_box_int32(19), jl_box_int32(20), jl_box_int32(21), jl_box_int32(22), jl_box_int32(23), jl_box_int32(24), jl_box_int32(25), jl_box_int32(26), jl_box_int32(27), jl_box_int32(28), jl_box_int32(29), jl_box_int32(30), jl_box_int32(31), jl_box_int32(32), #ifndef __LP64__ jl_box_int32(33), jl_box_int32(34), jl_box_int32(35), jl_box_int32(36), jl_box_int32(37), jl_box_int32(38), jl_box_int32(39), jl_box_int32(40), jl_box_int32(41), jl_box_int32(42), jl_box_int32(43), jl_box_int32(44), jl_box_int32(45), jl_box_int32(46), jl_box_int32(47), jl_box_int32(48), jl_box_int32(49), jl_box_int32(50), jl_box_int32(51), jl_box_int32(52), jl_box_int32(53), jl_box_int32(54), jl_box_int32(55), jl_box_int32(56), jl_box_int32(57), jl_box_int32(58), jl_box_int32(59), jl_box_int32(60), jl_box_int32(61), jl_box_int32(62), jl_box_int32(63), jl_box_int32(64), #endif jl_box_int64(0), jl_box_int64(1), jl_box_int64(2), jl_box_int64(3), jl_box_int64(4), jl_box_int64(5), jl_box_int64(6), jl_box_int64(7), jl_box_int64(8), jl_box_int64(9), jl_box_int64(10), jl_box_int64(11), jl_box_int64(12), jl_box_int64(13), jl_box_int64(14), jl_box_int64(15), jl_box_int64(16), jl_box_int64(17), jl_box_int64(18), jl_box_int64(19), jl_box_int64(20), jl_box_int64(21), jl_box_int64(22), jl_box_int64(23), jl_box_int64(24), jl_box_int64(25), jl_box_int64(26), jl_box_int64(27), jl_box_int64(28), jl_box_int64(29), jl_box_int64(30), jl_box_int64(31), jl_box_int64(32), #ifdef __LP64__ jl_box_int64(33), jl_box_int64(34), jl_box_int64(35), jl_box_int64(36), jl_box_int64(37), jl_box_int64(38), jl_box_int64(39), jl_box_int64(40), jl_box_int64(41), jl_box_int64(42), jl_box_int64(43), jl_box_int64(44), jl_box_int64(45), jl_box_int64(46), jl_box_int64(47), jl_box_int64(48), jl_box_int64(49), jl_box_int64(50), jl_box_int64(51), jl_box_int64(52), jl_box_int64(53), jl_box_int64(54), jl_box_int64(55), jl_box_int64(56), jl_box_int64(57), jl_box_int64(58), jl_box_int64(59), jl_box_int64(60), jl_box_int64(61), jl_box_int64(62), jl_box_int64(63), jl_box_int64(64), #endif jl_labelnode_type, jl_linenumbernode_type, jl_gotonode_type, jl_quotenode_type, jl_topnode_type, jl_type_type, jl_bottom_type, jl_pointer_type, jl_seq_type, jl_ntuple_type, jl_abstractarray_type, jl_box_type, jl_typector_type, jl_undef_type, jl_top_type, jl_any_func, jl_typename_type, jl_task_type, jl_union_kind, jl_function_type, jl_typetype_type, jl_typetype_tvar, jl_ANY_flag, jl_array_any_type, jl_intrinsic_type, jl_symbol_type->name, jl_pointer_type->name, jl_tag_kind->name, jl_union_kind->name, jl_bits_kind->name, jl_struct_kind->name, jl_func_kind->name, jl_array_type->name, jl_expr_type->name, jl_typename_type->name, jl_type_type->name, jl_methtable_type->name, jl_tvar_type->name, jl_seq_type->name, jl_ntuple_type->name, jl_abstractarray_type->name, jl_lambda_info_type->name, jl_module_type->name, jl_box_type->name, jl_typector_type->name, jl_intrinsic_type->name, jl_undef_type->name, jl_task_type->name, jl_labelnode_type->name, jl_linenumbernode_type->name, jl_gotonode_type->name, jl_quotenode_type->name, jl_topnode_type->name, jl_root_task, NULL }; ptrint_t i=2; while (tags[i-2] != NULL) { ptrhash_put(&ser_tag, tags[i-2], (void*)i); ptrhash_put(&deser_tag, (void*)i, tags[i-2]); i += 1; } assert(i <= Null_tag); VALUE_TAGS = (ptrint_t)ptrhash_get(&ser_tag, jl_null); void *fptrs[] = { jl_f_new_expr, jl_f_new_box, jl_f_throw, jl_f_is, jl_f_no_function, jl_f_typeof, jl_f_subtype, jl_f_isa, jl_f_typeassert, jl_f_apply, jl_f_top_eval, jl_f_isbound, jl_f_tuple, jl_f_tupleref, jl_f_tuplelen, jl_f_get_field, jl_f_set_field, jl_f_field_type, jl_f_arraylen, jl_f_arrayref, jl_f_arrayset, jl_f_arraysize, jl_f_instantiate_type, jl_f_convert_default, jl_f_convert_tuple, jl_trampoline, jl_f_new_struct_type, jl_f_new_struct_fields, jl_f_new_type_constructor, jl_f_new_tag_type, jl_f_new_tag_type_super, jl_f_new_bits_type, jl_f_def_macro, jl_f_typevar, jl_f_union, jl_f_methodexists, jl_f_applicable, jl_f_invoke, jl_apply_generic, jl_unprotect_stack, jl_f_task, jl_f_yieldto, jl_f_ctor_trampoline, NULL }; i=2; while (fptrs[i-2] != NULL) { ptrhash_put(&fptr_to_id, fptrs[i-2], (void*)i); ptrhash_put(&id_to_fptr, (void*)i, fptrs[i-2]); i += 1; } }
/** * main programme will be excuted. * By default, words are read from stdin and * added to hashtable before being printed out * alongside their frequencies to stdout. * @param argc an integer saying how many arguments * there are argc for “argument count” * @param argv an array of strings in which the arguments * are stored (argv for “argument vector ”). * @return integer 1 to indicate if the programme excuted successfully or not. */ int main(int argc, char *argv[]) { const char *optstring = "ht:c:deps:"; char option; char word[256]; int capacity = 113; FILE *infile = NULL; clock_t start, end; hashing_t method = LINEAR_P; double fillTime; double searchTime; int unknownWords = 0; int numOfSnapshot = 0; htable h; char *fileToBeChecked = NULL; int withC = 0; int withE = 0; int withP = 0; int withS = 0; /* * Begin processing the argument from the command line */ while ((option = getopt(argc, argv, optstring)) != EOF) { switch (option) { case 't': if (atoi(optarg) <= 0){ capacity = 113; }else { capacity = primegt(atoi(optarg)); } break; case 'd': method = DOUBLE_H; break; case 'c': withC = 1; fileToBeChecked = optarg; break; case 'e': withE = 1; break; case 's': numOfSnapshot = atoi(optarg); if (numOfSnapshot <= 0) { numOfSnapshot = 10; } withS = 1; break; case 'p': withP = 1; break; case 'h': printHelpInfo(); return EXIT_SUCCESS; default: printHelpInfo(); return EXIT_FAILURE; } } h = htable_new(capacity, method); start = clock(); while (getword(word, sizeof word, stdin) != EOF) { htable_insert(h, word); } end = clock(); fillTime = (end-start)/(double)CLOCKS_PER_SEC; /* prints all the details of the table (-e argument)*/ if (withE == 1) { htable_print_entire_table(h, stderr); } /* Checks the input file against a dictionary (-c <filename> argument)*/ if (withC == 1) { /*open file and check if it is valid*/ if (NULL == (infile = fopen(fileToBeChecked, "r"))) { fprintf(stderr, "Can't open file '%s' using mode r\n", fileToBeChecked); htable_free(h); return EXIT_FAILURE; } start = clock(); /*Get words from input file, and search for them in the dictionary*/ while (getword(word, sizeof word, infile) != EOF) { /*If the word isn't in the dictionary*/ if (htable_search(h, word) == 0) { printf("%s\n", word); unknownWords += 1; } } end = clock(); fclose(infile); searchTime = (end-start)/(double)CLOCKS_PER_SEC; fprintf(stderr, "Fill time\t:%f\n", fillTime); fprintf(stderr, "Search time\t:%f\n", searchTime); fprintf(stderr, "Unknown words = %d\n", unknownWords); htable_free(h); return EXIT_SUCCESS; } /*Prints table stats (-p -s arguments)*/ if (withP == 1 && withS == 0) { htable_print_stats(h, stdout, 10); } else if (withP == 1 && withS == 1) { htable_print_stats(h, stdout, numOfSnapshot); } else { htable_print(h, print_info); } htable_free(h); return EXIT_SUCCESS; }
void comparehash_init() { htable_new(&equal_eq_hashtable, 512); }