int main(int argc, char** argv) {
if (argc != 2) { // ocekavame PRAVE JEDEN argument (+ nazev souboru)
fprintf(stderr, "Nespravny pocet argumentu testovaciho programu.\n");
return -1; //!! predelat na spravnou konstantu
}
FILE * f = fopen(argv[1], "r");
if (f == NULL ) {
fprintf(stderr, "Testovacimu souboru se nepodarilo otevrit soubor s aplikaci.\n");
return internalError();
}
initGarbageCollector();
//nastav soubor, ze ktereho scanner cte
setSourceFile(f);
htable_t* fT;
tIlist iL;
listInit(&iL);
fT = htable_init(HTABLE_SIZE);
htableStack *sS = gcMalloc(sizeof(htableStack));
if (sS == NULL) return internalError();
sS = htable_stack_init();
htable_t *mainTable ;
mainTable = htable_init(HTABLE_SIZE);
htable_stack_push(sS,mainTable);
int result = parse(fT, &iL,sS);
if (result != EOK)
{
fclose(f);
freeGarbage();
return result;
// jinak probehlo vse v poradku, muzeme provadet kod
}
result = (interpret(&iL,fT,sS));
freeGarbage();
fclose(f);
if(result != EOK){
return result;
}
return EOK;
}
int kmscon_hashtable_new(struct kmscon_hashtable **out,
kmscon_hash_cb hash_cb,
kmscon_equal_cb equal_cb,
kmscon_free_cb free_key,
kmscon_free_cb free_value)
{
struct kmscon_hashtable *tbl;
if (!out || !hash_cb || !equal_cb)
return -EINVAL;
tbl = malloc(sizeof(*tbl));
if (!tbl)
return -ENOMEM;
memset(tbl, 0, sizeof(*tbl));
tbl->hash_cb = hash_cb;
tbl->equal_cb = equal_cb;
tbl->free_key = free_key;
tbl->free_value = free_value;
htable_init(&tbl->tbl, rehash, tbl);
*out = tbl;
return 0;
}
int main(int argc, char **argv)
{
struct htable ht;
foobar_t *foo;
foobar_t *ret;
htable_init(&ht, rehash, NULL);
foo = malloc(sizeof(foobar_t));
foo->name = strdup("fumier");
foo->blah = 123;
htable_add(&ht, hash_string(foo->name), foo);
ret = (foobar_t *)htable_get(&ht, hash_string("gugus"), streq, "gugus");
if (ret) {
printf("Found\n");
} else {
printf("Not found\n");
}
free(foo->name);
free(foo);
return 0;
}
int main() {
FILE *f = stdin;
// f = fopen("/home/Ondra/ahoj1.txt", "r"); // smazat
char string[MAX_LEN];
int len;
htable_t* table = htable_init(HTABLE_SIZE);
htable_listitem *item;
while ( (len = fgetword(string, MAX_LEN, f)) != 0 ) {
if((item = htable_lookup(table, string)) == NULL) {
fprintf(stderr, "Chyba pri alokaci pameti.\n");
return EXIT_FAILURE;
}
}
// fclose(f); //smazat
htable_iterator b = htable_begin(table);
htable_iterator *bg = &b;
htable_iterator end = htable_end(table);
while( !htable_iter_eq(bg, &end) ) {
if(htable_iter_deref(bg) == NULL)
break;
printf("%s\t%d\n", bg->ptr->key, bg->ptr->data);
bg = htable_iter_next(bg);
}
if(end.ptr != NULL)
printf("%s\t%d\n", end.ptr->key, end.ptr->data);
// Uklid haldu
htable_free(table);
return EXIT_SUCCESS;
}
void opt_init(){
ReferItem r;
scan_htable=htable_init((char*)&r.next-(char*)&r,4,32); // 32 ¸öcontainer
max_factor=1.0/G_CAPPING_T;
cur_factor=max_factor;
rewrite_size=0;
memset(factor_buckets,0,sizeof(factor_buckets));
printf("max_factor:%f , cur_factor:%f \n",max_factor,cur_factor);
}
void *sec_mod_client_db_init(sec_mod_st *sec)
{
struct htable *db = talloc(sec, struct htable);
if (db == NULL)
return NULL;
htable_init(db, rehash, NULL);
sec->client_db = db;
return db;
}
int main(void) {
char line[MAXLINE];
node *hashtable;
hashtable = (node *)malloc(HASHSIZE * sizeof(node));
htable_init(hashtable);
while((fgets(line, MAXLINE, stdin)) != NULL)
htable_insert(hashtable, line);
htable_display(hashtable);
return 0;
}
/**
* Zaciatok programu
*/
int main(void)
{
Th_table *htable = htable_init(TABLESIZE);
if (htable == NULL)
printError("Nepodarilo sa alokovat pamet pre hash table!", htable);
//alokujem si do ktoreho budem ukladat slova z funkcie fgetword
char *word = (char *)calloc(WORDLENGTHMAX, sizeof(char));
if (word == NULL)
printError("Nepodarilo sa alokovat pamet pre pole!", htable);
Thtable_listitem *item = NULL;
//nacitanie slov do hash table
while(fgetword(word, WORDLENGTHMAX, stdin) != 0)
{
item = htable_lookup(htable, word);
if (item == NULL)
{
free(word);
printError("Nepodarilo sa alokovat pamet pre novu polozku!", htable);
}
//pocita vyskity slova
item->data++;
}
//vypis slovo pocetVyskitov
/////////////////////////////////////////////
//nastavim iterator na prvu polozku
Thtable_iterator iteratorBegin = htable_begin(htable);
//nastavim iterator na poslednu polozku
Thtable_iterator iteratorEnd = htable_end(htable);
//vypis key data
while (htable_iter_eq(iteratorBegin, iteratorEnd) == false)
{
item = htable_iter_deref(iteratorBegin);
printf("%s\t%d\n", item->key, item->data);
iteratorBegin = htable_iter_next(iteratorBegin);
}
//uvolnit alokovane polia..
htable_free(htable);
free(word);
return EXIT_SUCCESS;
}
faup_snapshot_item_t *faup_snapshot_item_new(char *key)
{
faup_snapshot_item_t *item;
item = malloc(sizeof(faup_snapshot_item_t));
if (!item) {
fprintf(stderr, "Cannot allocatate a snapshot_item item!\n");
return NULL;
}
item->length = 0;
item->key = strdup(key);
htable_init(&item->values, rehash, NULL);
return item;
}
int main(int argc, char **argv)
{
/* Initializations */
output = fopen("trace.out", "w");
instr_count = 0;
max_instr_count = 0;
htable_init(&addresses, addr_hash, NULL);
PIN_InitSymbols();
PIN_Init(argc, argv);
/* Instrumentation */
RTN_AddInstrumentFunction(Routine, 0);
INS_AddInstrumentFunction(Instruction, 0);
PIN_AddFiniFunction(fini, 0);
PIN_StartProgram();
return 0;
}
int main(int argc, char *argv[])
{
struct htable ht;
uint64_t val[NUM_VALS];
unsigned int i;
plan_tests((NUM_VALS) * 2);
for (i = 0; i < NUM_VALS; i++)
val[i] = i;
htable_init(&ht, hash, NULL);
for (i = 0; i < NUM_VALS; i++) {
ok1(ht.max >= i);
ok1(ht.max <= i * 2);
htable_add(&ht, hash(&val[i], NULL), &val[i]);
}
htable_clear(&ht);
return exit_status();
}
static void tracer_init(pid_t pid) {
PAGESIZE = sysconf(_SC_PAGESIZE);
event_t e = wait_event(pid);
assert(e.signo == SIGSTOP);
follow_threads(pid);
create_dump_dir();
debug_print("%s\n", "Tracer initialized");
if (firsttouch_active) {
htable_init(&firsttouch, rehash, NULL);
stop_all_except(pid);
tracer_lock_mem(pid);
debug_print("%s\n", "******* TRACER_FIRSTTOUCH");
tracer_state = TRACER_FIRSTTOUCH;
} else {
debug_print("%s\n", "******* TRACER_UNLOCKED");
tracer_state = TRACER_UNLOCKED;
}
continue_all();
}
htable* htable_new(size_t estimated_size) { // {{{
return htable_init(calloc(1, sizeof(htable)), estimated_size);
} // }}}
static void plain_group_list(void *pool, void *additional, char ***groupname, unsigned *groupname_size)
{
FILE *fp;
char line[512];
ssize_t ll;
char *p, *sp;
unsigned i;
size_t hval;
struct htable_iter iter;
char *tgroup[MAX_GROUPS];
unsigned tgroup_size;
struct htable hash;
struct plain_cfg_st *config = additional;
htable_init(&hash, rehash, NULL);
pool = talloc_init("plain");
fp = fopen(config->passwd, "r");
if (fp == NULL) {
syslog(LOG_AUTH,
"error in plain authentication; cannot open: %s",
(char*)config->passwd);
return;
}
line[sizeof(line)-1] = 0;
while ((p=fgets(line, sizeof(line)-1, fp)) != NULL) {
ll = strlen(p);
if (ll <= 4)
continue;
if (line[ll - 1] == '\n') {
ll--;
line[ll] = 0;
}
if (line[ll - 1] == '\r') {
ll--;
line[ll] = 0;
}
#ifdef HAVE_STRSEP
sp = line;
p = strsep(&sp, ":");
if (p != NULL) {
p = strsep(&sp, ":");
#else
p = strtok_r(line, ":", &sp);
if (p != NULL) {
p = strtok_r(NULL, ":", &sp);
#endif
if (p != NULL) {
break_group_list(pool, p, tgroup, &tgroup_size);
for (i=0; i<tgroup_size; i++) {
hval = rehash(tgroup[i], NULL);
if (htable_get(&hash, hval, str_cmp, tgroup[i]) == NULL) {
if (strlen(tgroup[i]) > 1)
htable_add(&hash, hval, tgroup[i]);
}
}
}
}
}
*groupname_size = 0;
*groupname = talloc_size(pool, sizeof(char*)*MAX_GROUPS);
if (*groupname == NULL) {
goto exit;
}
p = htable_first(&hash, &iter);
while (p != NULL && (*groupname_size) < MAX_GROUPS) {
(*groupname)[(*groupname_size)] = talloc_strdup(*groupname, p);
p = htable_next(&hash, &iter);
(*groupname_size)++;
}
/* always succeed */
exit:
htable_clear(&hash);
safe_memset(line, 0, sizeof(line));
fclose(fp);
return;
}
const struct auth_mod_st plain_auth_funcs = {
.type = AUTH_TYPE_PLAIN | AUTH_TYPE_USERNAME_PASS,
.allows_retries = 1,
.global_init = plain_global_init,
.auth_init = plain_auth_init,
.auth_deinit = plain_auth_deinit,
.auth_msg = plain_auth_msg,
.auth_pass = plain_auth_pass,
.auth_user = plain_auth_user,
.auth_group = plain_auth_group,
.group_list = plain_group_list
};
int main(int argc, char *argv[])
{
unsigned int i;
uintptr_t perfect_bit;
struct htable ht;
uint64_t val[NUM_VALS];
uint64_t dne;
void *p;
struct htable_iter iter;
plan_tests(29);
for (i = 0; i < NUM_VALS; i++)
val[i] = i;
dne = i;
htable_init(&ht, hash, NULL);
ok1(ht.max == 0);
ok1(ht.bits == 0);
/* We cannot find an entry which doesn't exist. */
ok1(!htable_get(&ht, hash(&dne, NULL), objcmp, &dne));
/* This should increase it once. */
add_vals(&ht, val, 0, 1);
ok1(ht.bits == 1);
ok1(ht.max == 1);
ok1(ht.common_mask == -1);
/* Mask should be set. */
ok1(check_mask(&ht, val, 1));
/* This should increase it again. */
add_vals(&ht, val, 1, 1);
ok1(ht.bits == 2);
ok1(ht.max == 3);
/* Mask should be set. */
ok1(ht.common_mask != 0);
ok1(ht.common_mask != -1);
ok1(check_mask(&ht, val, 2));
/* Now do the rest. */
add_vals(&ht, val, 2, NUM_VALS - 2);
/* Find all. */
find_vals(&ht, val, NUM_VALS);
ok1(!htable_get(&ht, hash(&dne, NULL), objcmp, &dne));
/* Walk once, should get them all. */
i = 0;
for (p = htable_first(&ht,&iter); p; p = htable_next(&ht, &iter))
i++;
ok1(i == NUM_VALS);
/* Delete all. */
del_vals(&ht, val, NUM_VALS);
ok1(!htable_get(&ht, hash(&val[0], NULL), objcmp, &val[0]));
/* Worst case, a "pointer" which doesn't have any matching bits. */
htable_add(&ht, 0, (void *)~(uintptr_t)&val[NUM_VALS-1]);
htable_add(&ht, hash(&val[NUM_VALS-1], NULL), &val[NUM_VALS-1]);
ok1(ht.common_mask == 0);
ok1(ht.common_bits == 0);
/* Get rid of bogus pointer before we trip over it! */
htable_del(&ht, 0, (void *)~(uintptr_t)&val[NUM_VALS-1]);
/* Add the rest. */
add_vals(&ht, val, 0, NUM_VALS-1);
/* Check we can find them all. */
find_vals(&ht, val, NUM_VALS);
ok1(!htable_get(&ht, hash(&dne, NULL), objcmp, &dne));
/* Corner cases: wipe out the perfect bit using bogus pointer. */
htable_clear(&ht);
htable_add(&ht, 0, (void *)((uintptr_t)&val[NUM_VALS-1]));
ok1(ht.perfect_bit);
perfect_bit = ht.perfect_bit;
htable_add(&ht, 0, (void *)((uintptr_t)&val[NUM_VALS-1]
| perfect_bit));
ok1(ht.perfect_bit == 0);
htable_del(&ht, 0, (void *)((uintptr_t)&val[NUM_VALS-1] | perfect_bit));
/* Enlarging should restore it... */
add_vals(&ht, val, 0, NUM_VALS-1);
ok1(ht.perfect_bit != 0);
htable_clear(&ht);
return exit_status();
}
int main(int argc, char **argv)
{
const char *dictfilename = "diceware.txt";
const char *randomdevice = NULL;
int words = 6;
int i = 0;
struct htable dict;
struct randgen *randgen = NULL;
int rc = 0;
memset(&dict, 0, sizeof(dict));
for (i = 1; i < argc; ++i)
{
if (!strcmp(argv[i], "-d") && i+1 < argc)
{
dictfilename = argv[++i];
}
else if (!strcmp(argv[i], "-n") && i+1 < argc)
{
words = atoi(argv[++i]);
}
#ifndef _WIN32
else if (!strcmp(argv[i], "-r") && i+1 < argc)
{
randomdevice = argv[++i];
}
#endif
else if (!strcmp(argv[i], "-h"))
{
usage(argv[0]);
}
else
{
usage(argv[0]);
}
}
if ((randgen = randgen_open(randomdevice)) == NULL)
goto error;
htable_init(&dict, 11000);
if (load_dictionary(dictfilename, &dict) == -1)
goto error;
for (i = 0; i < words; ++i)
{
char *word = get_random_word(randgen, &dict);
if (!word)
{
goto error;
}
printf("%s%s", i ? " " : "", word);
}
printf("\n");
goto finally;
error:
rc = 1;
finally:
randgen_close(randgen);
htable_deinit(&dict);
return rc;
}
void ip_lease_init(struct ip_lease_db_st* db)
{
htable_init(&db->ht, rehash, NULL);
}
Set *set_init()
{
return set_init_ex(htable_init());
}
int ipm_init(int flags)
{
int i, state, rv;
double t_init;
char cmdline[MAXSIZE_CMDLINE];
char realpath[MAXSIZE_CMDLINE];
char *target;
state=ipm_state;
ipm_state=STATE_IN_INIT;
/* check if IPM_TARGET is set and if it is,
only monitor matching processes */
target=getenv("IPM_TARGET");
ipm_get_exec_cmdline(cmdline,realpath);
/* IPM_TARGET specifies string that has to appear in cmdline */
if( target && target[0]!='!' && !strstr(cmdline,target) ) {
ipm_state=STATE_NOTACTIVE;
return IPM_OK;
}
/* IPM_TARGET specifies string that must not appear in cmdline */
if( target && target[0]=='!' && strstr(cmdline,target) ) {
ipm_state=STATE_NOTACTIVE;
return IPM_OK;
}
ipm_time_init(flags);
rstack_init(flags);
t_init = ipm_wtime();
taskdata_init(&task);
htable_init(ipm_htable);
/* need to get env variables before modules init */
ipm_get_env();
/* init local data structures */
for( i=0; i<MAXNUM_MODULES; i++ ) {
ipm_module_init( &(modules[i]) );
}
/* --- initialize modules --- */
#ifdef HAVE_MPI
modules[IPM_MODULE_MPI].init=mod_mpi_init;
#endif
#ifdef HAVE_POSIXIO
modules[IPM_MODULE_POSIXIO].init=mod_posixio_init;
#endif
#ifdef HAVE_MPIIO
modules[IPM_MODULE_MPIIO].init=mod_mpiio_init;
#endif
#ifdef HAVE_CALLPATH
modules[IPM_MODULE_CALLPATH].init=mod_callpath_init;
#endif
#ifdef HAVE_KEYHIST
modules[IPM_MODULE_KEYHIST].init=mod_keyhist_init;
#endif
#ifdef HAVE_PAPI
modules[IPM_MODULE_PAPI].init=mod_papi_init;
#endif
#ifdef HAVE_SELFMONITOR
modules[IPM_MODULE_SELFMONITOR].init=mod_selfmonitor_init;
#endif
#ifdef HAVE_PROCCTRL
modules[IPM_MODULE_PROCCTRL].init=mod_procctrl_init;
#endif
#ifdef HAVE_CLUSTERING
modules[IPM_MODULE_CLUSTERING].init=mod_clustering_init;
#endif
#ifdef HAVE_OMPTRACEPOINTS
modules[IPM_MODULE_OMPTRACEPOINTS].init=mod_omptracepoints_init;
#endif
#ifdef HAVE_CUDA
modules[IPM_MODULE_CUDA].init=mod_cuda_init;
#endif
#ifdef HAVE_CUFFT
modules[IPM_MODULE_CUFFT].init=mod_cufft_init;
#endif
#ifdef HAVE_CUBLAS
modules[IPM_MODULE_CUBLAS].init=mod_cublas_init;
#endif
/* TODO: handle errors in module initialization, set
ipm_state to STATE_ERROR */
for( i=0; i<MAXNUM_MODULES; i++ ) {
if( modules[i].init ) { /* call init function if it is set */
rv=modules[i].init(&(modules[i]), flags);
if(rv!=IPM_OK) {
IPMERR("Error initializing module %d (%s), error %d\n",
i, modules[i].name?modules[i].name:"", rv);
}
#ifdef HAVE_MPI
if( i==IPM_MODULE_POSIXIO )
modules[i].state=STATE_NOTACTIVE;
#endif
}
}
/* --- done initializing modules --- */
#ifdef DELAYED_MPI_FINALIZE
rv = atexit(ipm_atexit_handler);
if(!rv) {
task.flags|=FLAG_USING_ATEXIT;
} else {
IPMERR("Error installing atexit() handler\n");
task.flags&=~FLAG_USING_ATEXIT;
}
#endif
signal(SIGXCPU, ipm_sig_handler);
signal(SIGTERM, ipm_sig_handler);
signal(SIGABRT, ipm_sig_handler);
#ifdef HAVE_SELFMONITOR
ipm_selfmon.t_init = ipm_wtime()-t_init;
#endif
/* this should be close to user code */
ipm_region(1, "ipm_main");
ipm_region_begin(&ipm_app);
ipm_state=STATE_ACTIVE;
return IPM_OK;
}
zend_object *set_create_object(zend_class_entry *ce)
{
return set_create_object_ex(htable_init());
}
void capping_init(){
CapItem r;
cap_htable=htable_init((char*)&r.next-(char*)&r,4,32); // 32 ¸öcontainer
}