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