/**
* Prepis programu wordcount z C++ do C zo zadania.
*/
int main(void)
{
htab_t *t=htab_init(HTAB_SIZE);
if(!t)
{
fprintf(stderr, "[wordcount]\t-htable was not allocated\n");
return EXIT_FAILURE;
}
char word[WORD_LIMIT+1]={0};
while(fgetw(word, WORD_LIMIT, stdin)!=EOF)
{
if(!htab_lookup(t, word))
{
fprintf(stderr, "[wordcount]\t-[htab_lookup] allocation fail\n");
htab_free(t);
return EXIT_FAILURE;
}
}
htab_foreach(t, &print_items);
//htab_statistics(t); /// vypis statistiky udajov tabulky
htab_free(t);
return EXIT_SUCCESS;
}
void
os_free(struct os *os)
{
int i;
#ifdef HAS_HTAB
if (!os->cached_partition_info[1].sfw_tlb) {
htab_free(os);
}
#endif /* HAS_HTAB */
if (os->po_psm)
os_psm_destroy(os->po_psm);
for (i = 0; i < os->installed_cpus; i++) {
cpu_free(os->cpu[i]);
os->cpu[i] = NULL;
}
ht_remove(&os_hash, os->po_lpid);
os->po_lpid = -1;
hfree(os, sizeof(*os));
}
/*
* Read words from stdin and print number of occurrences
* @param argc number of arguments
* @param argv arguments
* @return success code
*
*/
int main(int argc, char* argv[])
{
// This size is used, because it is enought for entire book (tested on Alice's Adventures in Wonderland and Pride and Prejudice)
// and average number is between 0.5-2 - is used more than half and is average not more than 2 items
htab_t* htab = htab_init(7000);
htab_listitem* item;
char word[128];
while(fgetw(word, 127,stdin) != EOF)
{
item = htab_lookup(htab,word);
item->data++;
}
htab_foreach(htab, &print_word);
//htab_statistics(htab);
htab_free(htab);
return 0;
}
void
moto_freeEnv(MotoEnv *env) {
Enumeration *e;
/* Free any outstanding frames */
while(vec_size(env->frames) > 0) {
moto_freeFrame(env);
}
/* Free all the globals */
e = stab_getKeys(env->globals);
while (enum_hasNext(e)) {
char* n = (char*)enum_next(e);
MotoVar* var = stab_get(env->globals,n);
if(env->mode != COMPILER_MODE) {
moto_freeVal(env,var->vs);
} else {
opool_release(env->valpool,var->vs);
}
free(var);
}
enum_free(e);
stab_free(env->globals);
/* free all cached regular expressions */
e = stab_getKeys(env->rxcache);
while (enum_hasNext(e)) {
char *rx = (char *)enum_next(e);
MDFA *mdfa = (MDFA *)stab_get(env->rxcache, rx);
if (mdfa != NULL) {
mdfa_free(mdfa);
}
}
enum_free(e);
/* free all remaining pointers */
e = hset_elements(env->ptrs);
while (enum_hasNext(e)) {
void *ptr = enum_next(e);
if (shared_check(ptr)) {
free(ptr);
}
}
enum_free(e);
/* free all errors */
e = sset_elements(env->errs);
while (enum_hasNext(e)) {
void *ptr = enum_next(e);
if (shared_check(ptr)) {
free(ptr);
}
}
enum_free(e);
/* free all scopes */
e = stack_elements(env->scope);
while (enum_hasNext(e)) {
free(enum_next(e));
}
enum_free(e);
/* free all cells */
moto_freeTreeCells(env);
/* free all class defs */
stab_free(env->cdefs);
/* free remainder of env struct */
hset_free(env->ptrs);
buf_free(env->out);
buf_free(env->err);
stab_free(env->types);
vec_free(env->frames);
ftab_free(env->ftable);
/* Free all the stuff that got put in the mpool ... this includes
MotoFunctions and MotoClassDefinitions */
mpool_free(env->mpool);
stack_free(env->scope);
stab_free(env->rxcache);
//stack_free(env->callstack);
sset_free(env->errs);
sset_free(env->uses);
sset_free(env->includes);
buf_free(env->fcodebuffer);
istack_free(env->scopeIDStack);
htab_free(env->fdefs);
htab_free(env->adefs);
buf_free(env->constantPool);
moto_freeTree(env->tree);
opool_free(env->valpool);
opool_free(env->bufpool);
opool_free(env->stkpool);
e = stab_getKeys(env->fcache);
while (enum_hasNext(e))
free((char *)enum_next(e));
enum_free(e);
stab_free(env->fcache);
free(env);
}
void
moto_clearEnv(MotoEnv *env) {
Enumeration *e;
int size;
//hset_free(env->ptrs);
//mpool_free(env->mpool);
/* Clear out the globals */
e = stab_getKeys(env->globals);
while (enum_hasNext(e)) {
char* n = (char*)enum_next(e);
MotoVar* var = stab_get(env->globals,n);
if(env->mode != COMPILER_MODE) {
moto_freeVal(env,var->vs);
} else {
opool_release(env->valpool,var->vs);
}
free(var);
}
enum_free(e);
stab_clear(env->globals);
/* Clear out the frames */
size = vec_size(env->frames);
while (--size >= 0) {
MotoFrame *frame = (MotoFrame *)vec_get(env->frames, size);
stack_free(frame->opstack);
stab_free(frame->symtab);
buf_free(frame->out);
free(frame);
}
vec_clear(env->frames);
e = stack_elements(env->scope);
while (enum_hasNext(e)) {
free(enum_next(e));
}
enum_free(e);
stack_clear(env->scope);
buf_clear(env->out);
buf_clear(env->err);
// stab_free(env->types);
// ftab_free(env->ftable);
// stab_free(env->rxcache);
// stack_clear(env->callstack);
sset_clear(env->errs);
// sset_clear(env->uses);
if (env->mode == COMPILER_MODE) {
sset_free(env->includes);
htab_free(env->fdefs);
htab_free(env->adefs);
buf_free(env->constantPool);
buf_free(env->fcodebuffer);
istack_free(env->scopeIDStack);
}
env->frameindex = -1;
/* error stuff */
env->meta.filename = env->filename;
env->meta.caller = NULL;
env->meta.macroname = NULL;
env->meta.lineno = 1;
env->errflag = 0;
//free(env);
}
