// Test put and get functions int test_hmap_2() { hmap_handle* hmap; hmap = hmap_create(); int* data1; int* data2; int* data3; data1 = new(int); *data1 = 0; hmap_put(hmap, (long) (*data1), data1); data2 = new(int); *data2 = 1; hmap_put(hmap, (long) (*data2), data2); data3 = new(int); *data3 = 2; hmap_put(hmap, (long) (*data3), data3); if (hmap_get(hmap, (long) (*data1)) != data1 || hmap_get(hmap, (long) (*data2)) != data2 || hmap_get(hmap, (long) (*data3)) != data3) { kfree(data1); kfree(data2); kfree(data3); hmap_free(hmap); return TEST_FAIL; } return TEST_OK; }
void main() { hashmap *hMap; hMap = hmap_creat(int_hash_fn, int_eq_fn, int_del_fn); if(!hmap_put(hMap, (void*)"test", (void*)"value")) return; printf( "%s\n", (char*)hmap_get(hMap, (void*)"test") ); free_hmap(hMap); hMap = NULL; }
/* param: char*, filename * param: Agg_Data * func: Do a DFS starting at char* * flag vlaues: * 0: not discovered on current search * 1: discovered (but not done)( to find cycles) * 2: finished (so that cross edges can still use finished nodes * ret: * 0: no bad edge (good) * 1: has bad edge (bad) */ int has_bad_edge( char* filename, HMAP_PTR hmap, Fdata* files, int numFData){ //printf("filename:%s:\n", filename); if( hmap_contains( hmap, filename) ){ Fdata Curfile = hmap_get( hmap, filename); Curfile->flag = 1; int i; for( i=0; i<Curfile->numDepends; ++i){ //for every dependency // printf("CHECKING DEPEND:%s:\n", Curfile->dependsOn[i]); Fdata depends = (Fdata)hmap_get( hmap, (Curfile->dependsOn)[i] ); if(depends->flag == 1) return 1; //back edge if( has_bad_edge( (Curfile->dependsOn)[i], hmap, files, numFData) ) return 1; } Curfile->flag = 2; return 0; } else{ //file never existed fprintf(stderr, "ERROR, file doesn't exist\n"); return 1; } }
static int bldg_add(fixed x, fixed z, mesh_s *mesh) { int idx = bldg_count++; bldg_s *bldg = &bldg_list[idx]; memset(bldg, 0, sizeof(bldg_s)); bldg->pos[0] = x; bldg->pos[1] = hmap_get(x, z); bldg->pos[2] = z; bldg->mesh = mesh; return idx; }
/* Create a new user info structure, representing a user on the hub. */ DCUserInfo * user_info_new(const char *nick) { DCUserInfo *info; char *ucname; info = (DCUserInfo*) xmalloc(sizeof(DCUserInfo)); info->nick = xstrdup(nick); info->description = NULL; info->speed = NULL; info->level = 0; info->email = NULL; info->share_size = 0; info->active_state = DC_ACTIVE_UNKNOWN; info->download_queue = ptrv_new(); info->slot_granted = false; info->refcount = 1; info->is_operator = false; info->info_quered = false; info->conn_count = 0; /* XXX Find existing connections to this user... */ ucname = xasprintf("%s|%s", nick, _("UL")); info->conn[info->conn_count] = (DCUserConn*) hmap_get(user_conns, ucname); if (info->conn[info->conn_count] != NULL) info->conn_count++; free(ucname); ucname = xasprintf("%s|%s", nick, _("DL")); info->conn[info->conn_count] = (DCUserConn*) hmap_get(user_conns, ucname); if (info->conn[info->conn_count] != NULL) info->conn_count++; free(ucname); ucname = xasprintf("%s|", nick); info->conn[info->conn_count] = (DCUserConn*) hmap_get(user_conns, ucname); if (info->conn[info->conn_count] != NULL) info->conn_count++; free(ucname); return info; }
int main() { hashmap* h = mk_hmap(str_hash_fn, str_eq_fn, str_del_fn); char* s = (char*) malloc(8); char* k = (char*) malloc(8); sprintf(s, "hello"); sprintf(k, "world"); hmap_add(h, s, k); // map "hello" to "world" hmap_add(h, k, s); // map "world" to "hello" char* x = (char*) hmap_get(h, k); printf("%s ", x); x = (char*) hmap_get(h, s); printf("%s!\n", x); free_hmap(h); return 0; }
struct variable *vm_mem(struct ymd_mach *vm, void *o, const char *field) { struct variable k, *v = NULL; switch (gcx(o)->type) { case T_HMAP: setv_kstr(&k, kstr_fetch(vm, field, -1)); v = hmap_get(o, &k); break; case T_SKLS: setv_kstr(&k, kstr_fetch(vm, field, -1)); v = skls_get(vm, o, &k); break; default: assert(!"No reached."); break; } return v; }
struct variable *vm_get(struct ymd_mach *vm, struct variable *var, const struct variable *key) { struct ymd_context *l = ioslate(vm); if (is_nil(key)) ymd_panic(l, "No any key will be `nil`"); switch (ymd_type(var)) { case T_SKLS: return skls_get(vm, skls_x(var), key); case T_HMAP: return hmap_get(hmap_x(var), key); case T_DYAY: return vm_at(vm, dyay_x(var), int_of(l, key)); case T_MAND: if (!mand_x(var)->proto) ymd_panic(l, "Management memory has no metatable yet"); return mand_get(vm, mand_x(var), key); default: ymd_panic(l, "Variable can not be index"); break; } assert(!"No reached."); return NULL; }
static bool validate_nick(DCUserConn *uc, const char *nick) { DCUserInfo *ui; ui = (DCUserInfo*) hmap_remove(pending_userinfo, nick); if (ui != NULL) { if (ui->conn_count < DC_USER_MAX_CONN) { uc->info = ui; uc->info->refcount++; uc->info->conn[uc->info->conn_count++] = uc; hmap_remove(pending_userinfo, ui->nick); user_info_free(ui); update_user_connection_name(uc, "%s|", uc->info->nick); return true; } warn(_("No more connections to user %s allowed.\n"), quotearg(nick)); user_info_free(ui); return false; } ui = (DCUserInfo*) hmap_get(hub_users, nick); if (ui != NULL) { if (ui->conn_count < DC_USER_MAX_CONN) { uc->info = ui; uc->info->refcount++; uc->info->conn[uc->info->conn_count++] = uc; update_user_connection_name(uc, "%s|", uc->info->nick); return true; } warn(_("No more connections to user %s allowed.\n"), quotearg(nick)); return false; } return false; }
static void hub_handle_command(char *buf, uint32_t len) { char *hub_my_nick; /* XXX */ hub_my_nick = main_to_hub_string(my_nick); if (len >= 6 && strncmp(buf, "$Lock ", 6) == 0) { char *key; if (!check_state(buf, (DCUserState) DC_HUB_LOCK)) goto hub_handle_command_cleanup; key = (char*) memmem(buf+6, len-6, " Pk=", 4); if (key == NULL) { warn(_("Invalid $Lock message: Missing Pk value\n")); key = buf+len; } key = decode_lock(buf+6, key-buf-6, DC_CLIENT_BASE_KEY); if (strleftcmp("EXTENDEDPROTOCOL", buf+6) == 0) { if (!hub_putf("$Supports TTHSearch NoGetINFO NoHello|")) { free(key); goto hub_handle_command_cleanup; } } if (!hub_putf("$Key %s|", key)) { free(key); goto hub_handle_command_cleanup; } free(key); if (!hub_putf("$ValidateNick %s|", hub_my_nick)) goto hub_handle_command_cleanup; hub_state = DC_HUB_HELLO; } else if (len >= 10 && strncmp(buf, "$Supports ", 10) == 0) { char *p0, *p1; hub_extensions = 0; for (p0 = buf+10; (p1 = strchr(p0, ' ')) != NULL; p0 = p1+1) { *p1 = '\0'; parse_hub_extension(p0); } if (*p0 != '\0') parse_hub_extension(p0); } else if (strcmp(buf, "$GetPass") == 0) { if (my_password == NULL) { screen_putf(_("Hub requires password.\n")); hub_disconnect(); goto hub_handle_command_cleanup; } screen_putf(_("Sending password to hub.\n")); if (!hub_putf("$MyPass %s|", my_password)) goto hub_handle_command_cleanup; } else if (strcmp(buf, "$BadPass") == 0) { warn(_("Password not accepted.\n")); hub_disconnect(); } else if (strcmp(buf, "$LogedIn") == 0) { screen_putf(_("You have received operator status.\n")); } else if (len >= 9 && strncmp(buf, "$HubName ", 9) == 0) { free(hub_name); hub_name = hub_to_main_string(buf + 9); screen_putf(_("Hub name is %s.\n"), quotearg(hub_name)); } else if (strcmp(buf, "$GetNetInfo") == 0) { hub_putf("$NetInfo %d$1$%c|", my_ul_slots, is_active ? 'A' : 'P'); } else if (strcmp(buf, "$ValidateDenide") == 0) { if (!check_state(buf, (DCUserState) DC_HUB_HELLO)) goto hub_handle_command_cleanup; /* DC++ disconnects immediately if this is received. * But shouldn't we give the client a chance to change the nick? * Also what happens if we receive this when correctly logged in? */ warn(_("Hub did not accept nick. Nick may be in use.\n")); hub_disconnect(); } else if (len >= 7 && strncmp(buf, "$Hello ", 7) == 0) { DCUserInfo *ui; char *conv_nick; conv_nick = hub_to_main_string(buf + 7); if (hub_state == DC_HUB_HELLO) { if (strcmp(buf+7, hub_my_nick) == 0) { screen_putf(_("Nick accepted. You are now logged in.\n")); } else { /* This probably won't happen, but better safe... */ free(my_nick); my_nick = xstrdup(conv_nick); free(hub_my_nick); hub_my_nick = xstrdup(buf + 7); screen_putf(_("Nick accepted but modified to %s. You are now logged in.\n"), quotearg(my_nick)); } ui = user_info_new(conv_nick); ui->info_quered = true; /* Hub is sending this automaticly */ hmap_put(hub_users, ui->nick, ui); free (conv_nick); if (!hub_putf("$Version 1,0091|")) goto hub_handle_command_cleanup; if (!hub_putf("$GetNickList|")) goto hub_handle_command_cleanup; if (!send_my_info()) goto hub_handle_command_cleanup; hub_state = DC_HUB_LOGGED_IN; } else { flag_putf(DC_DF_JOIN_PART, _("User %s logged in.\n"), quotearg(conv_nick)); ui = user_info_new(conv_nick); hmap_put(hub_users, ui->nick, ui); free (conv_nick); if ((hub_extensions & HUB_EXT_NOGETINFO) == 0) { if (!hub_putf("$GetINFO %s %s|", buf+7, hub_my_nick)) goto hub_handle_command_cleanup; ui->info_quered = true; } } } else if (len >= 8 && strncmp(buf, "$MyINFO ", 8) == 0) { DCUserInfo *ui; char *token; uint32_t len; char* conv_buf; char *work_buf; buf += 8; work_buf = conv_buf = hub_to_main_string(buf); token = strsep(&work_buf, " "); if (strcmp(token, "$ALL") != 0) { warn(_("Invalid $MyINFO message: Missing $ALL parameter, ignoring\n")); free(conv_buf); goto hub_handle_command_cleanup; } token = strsep(&work_buf, " "); if (token == NULL) { warn(_("Invalid $MyINFO message: Missing nick parameter, ignoring\n")); free(conv_buf); goto hub_handle_command_cleanup; } ui = (DCUserInfo*) hmap_get(hub_users, token); if (ui == NULL) { /* * if the full buf has not been converted from hub to local charset, * we should try to convert nick only */ /* char *conv_nick = hub_to_main_string(token); if ((ui = hmap_get(hub_users, conv_nick)) == NULL) { */ ui = user_info_new(token); ui->info_quered = true; hmap_put(hub_users, ui->nick, ui); /* } free(conv_nick); */ } token = strsep(&work_buf, "$"); if (token == NULL) { warn(_("Invalid $MyINFO message: Missing description parameter, ignoring\n")); free(conv_buf); goto hub_handle_command_cleanup; } free(ui->description); ui->description = xstrdup(token); token = strsep(&work_buf, "$"); if (token == NULL) { warn(_("Invalid $MyINFO message: Missing description separator, ignoring\n")); free(conv_buf); goto hub_handle_command_cleanup; } token = strsep(&work_buf, "$"); if (token == NULL) { warn(_("Invalid $MyINFO message: Missing connection speed, ignoring\n")); free(conv_buf); goto hub_handle_command_cleanup; } len = strlen(token); free(ui->speed); if (len == 0) { ui->speed = xstrdup(""); ui->level = 0; /* XXX: or 1? acceptable level? */ } else { ui->speed = xstrndup(token, len-1); ui->level = token[len-1]; } token = strsep(&work_buf, "$"); if (token == NULL) { warn(_("Invalid $MyINFO message: Missing e-mail address, ignoring\n")); free(conv_buf); goto hub_handle_command_cleanup; } free(ui->email); ui->email = xstrdup(token); token = strsep(&work_buf, "$"); if (token == NULL) { warn(_("Invalid $MyINFO message: Missing share size, ignoring\n")); free(conv_buf); goto hub_handle_command_cleanup; } if (!parse_uint64(token, &ui->share_size)) { warn(_("Invalid $MyINFO message: Invalid share size, ignoring\n")); free(conv_buf); goto hub_handle_command_cleanup; } if (ui->active_state == DC_ACTIVE_RECEIVED_PASSIVE || ui->active_state == DC_ACTIVE_KNOWN_ACTIVE) ui->active_state = DC_ACTIVE_UNKNOWN; /* XXX: Now that user's active_state may have changed, try queue again? */ free(conv_buf); } else if (strcmp(buf, "$HubIsFull") == 0) { warn(_("Hub is full.\n")); /* DC++ does not disconnect immediately. So I guess we won't either. */ /* Maybe we should be expecting an "hub follow" message? */ /* hub_disconnect(); */ } else if (len >= 3 && (buf[0] == '<' || strncmp(buf, " * ", 3) == 0)) { char *head; char *tail; char *msg; bool first = true; /* int scrwidth; size_t firstlen; size_t otherlen; screen_get_size(NULL, &scrwidth); firstlen = scrwidth - strlen(_("Public:")); otherlen = scrwidth - strlen(_(" | ")); */ msg = prepare_chat_string_for_display(buf); for (head = msg; (tail = strchr(head, '\n')) != NULL; head = tail+1) { /*PtrV *wrapped;*/ if (tail[-1] == '\r') /* end > buf here, buf[0] == '<' or ' ' */ tail[-1] = '\0'; else tail[0] = '\0'; /*wrapped = wordwrap(quotearg(buf), first ? firstlen : otherlen, otherlen); for (c = 0; c < wrapped->cur; c++) flag_putf(DC_DF_PUBLIC_CHAT, first ? _("Public: %s\n") : _(" | %s\n"), ); ptrv_foreach(wrapped, free); ptrv_free(wrapped);*/ flag_putf(DC_DF_PUBLIC_CHAT, first ? _("Public: %s\n") : _(" | %s\n"), quotearg(head)); first = false; } flag_putf(DC_DF_PUBLIC_CHAT, first ? _("Public: %s\n") : _(" | %s\n"), quotearg(head)); free(msg); } else if (len >= 5 && strncmp(buf, "$To: ", 5) == 0) { char *msg; char *tail; char *frm; char *head; bool first = true; msg = strchr(buf+5, '$'); if (msg == NULL) { warn(_("Invalid $To message: Missing text separator, ignoring\n")); goto hub_handle_command_cleanup; } *msg = '\0'; msg++; /* FIXME: WTF is this? Remove multiple "From: "? Why!? */ frm = buf+5; while ((tail = strstr(msg, "From: ")) != NULL && tail < msg) frm = tail+6; msg = prepare_chat_string_for_display(msg); frm = prepare_chat_string_for_display(frm); for (head = msg; (tail = strchr(head, '\n')) != NULL; head = tail+1) { if (tail[-1] == '\r') /* tail > buf here because head[0] == '<' or ' ' */ tail[-1] = '\0'; else tail[0] = '\0'; if (first) { screen_putf(_("Private: [%s] %s\n"), quotearg_n(0, frm), quotearg_n(1, head)); first = false; } else { screen_putf(_(" | %s\n"), quotearg(head)); } } if (first) { screen_putf(_("Private: [%s] %s\n"), quotearg_n(0, frm), quotearg_n(1, head)); } else { screen_putf(_(" | %s\n"), quotearg(head)); } free(msg); free(frm); } else if (len >= 13 && strncmp(buf, "$ConnectToMe ", 13) == 0) { struct sockaddr_in addr; buf += 13; if (strsep(&buf, " ") == NULL) { warn(_("Invalid $ConnectToMe message: Missing or invalid nick\n")); goto hub_handle_command_cleanup; } if (!parse_ip_and_port(buf, &addr, 0)) { warn(_("Invalid $ConnectToMe message: Invalid address specification.\n")); goto hub_handle_command_cleanup; } flag_putf(DC_DF_CONNECTIONS, _("Connecting to user on %s\n"), sockaddr_in_str(&addr)); user_connection_new(&addr, -1); } else if (len >= 16 && strncmp(buf, "$RevConnectToMe ", 16) == 0) { char *nick; char *local_nick; DCUserInfo *ui; nick = strtok(buf+16, " "); if (nick == NULL) { warn(_("Invalid $RevConnectToMe message: Missing nick parameter\n")); goto hub_handle_command_cleanup; } if (strcmp(nick, hub_my_nick) == 0) { warn(_("Invalid $RevConnectToMe message: Remote nick is our nick\n")); goto hub_handle_command_cleanup; } local_nick = hub_to_main_string(nick); ui = (DCUserInfo*) hmap_get(hub_users, local_nick); if (ui == NULL) { warn(_("Invalid $RevConnectToMe message: Unknown user %s, ignoring\n"), quotearg(local_nick)); free(local_nick); goto hub_handle_command_cleanup; } free(local_nick); if (ui->conn_count >= DC_USER_MAX_CONN) { warn(_("No more connections to user %s allowed.\n"), quotearg(ui->nick)); goto hub_handle_command_cleanup; } if (!is_active) { if (ui->active_state == DC_ACTIVE_SENT_PASSIVE) { warn(_("User %s is also passive. Cannot establish connection.\n"), quotearg(ui->nick)); /* We could set this to DC_ACTIVE_UNKNOWN too. This would mean * we would keep sending RevConnectToMe next time the download * queue is modified or some timer expired and told us to retry * download. The remote would then send back RevConnectToMe * and this would happen again. This way we would try again - * maybe remote has become active since last time we checked? * But no - DC++ only replies with RevConnectToMe to our first * RevConnectToMe. After that it ignores them all. */ ui->active_state = DC_ACTIVE_RECEIVED_PASSIVE; if (hmap_remove(pending_userinfo, ui->nick) != NULL) ui->refcount--; goto hub_handle_command_cleanup; } if (ui->active_state != DC_ACTIVE_RECEIVED_PASSIVE) { /* Inform remote that we are also passive. */ if (!hub_putf("$RevConnectToMe %s %s|", hub_my_nick, nick)) goto hub_handle_command_cleanup; } } ui->active_state = DC_ACTIVE_RECEIVED_PASSIVE; if (!hub_connect_user(ui)) goto hub_handle_command_cleanup; } else if ( (len >= 10 && strncmp(buf, "$NickList ", 10) == 0) || (len >= 8 && strncmp(buf, "$OpList ", 8) == 0) ) { char *nick; char *end; int oplist; char *conv_nick; if ( strncmp(buf, "$NickList ", 10) == 0) { nick = buf + 10; oplist = 0; } else { nick = buf + 8; oplist = 1; } for (; (end = strstr(nick, "$$")) != NULL; nick = end+2) { DCUserInfo *ui; *end = '\0'; conv_nick = hub_to_main_string(nick); ui = (DCUserInfo*) hmap_get(hub_users, conv_nick); if (ui == NULL) { ui = user_info_new(conv_nick); hmap_put(hub_users, ui->nick, ui); } free(conv_nick); if (!ui->info_quered && (hub_extensions & HUB_EXT_NOGETINFO) == 0) { if (!hub_putf("$GetINFO %s %s|", nick, hub_my_nick)) { goto hub_handle_command_cleanup; } ui->info_quered = true; } if (oplist) ui->is_operator = true; } } else if (len >= 6 && strncmp(buf, "$Quit ", 6) == 0) { DCUserInfo *ui; char *conv_nick = hub_to_main_string(buf+6); // I don't want these messages. //flag_putf(DC_DF_JOIN_PART, "User %s quits.\n", quotearg(conv_nick)); ui = (DCUserInfo*) hmap_remove(hub_users, conv_nick); if (ui == NULL) { /* Some hubs print quit messages for users that never joined, * so print this as debug only. */ flag_putf(DC_DF_DEBUG, _("Invalid $Quit message: Unknown user %s.\n"), quotearg(conv_nick)); } else user_info_free(ui); free(conv_nick); } else if (len >= 8 && strncmp(buf, "$Search ", 8) == 0) { char *source; int parse_result = 0; DCSearchSelection sel; sel.patterns = NULL; buf += 8; source = strsep(&buf, " "); if (source == NULL) { warn(_("Invalid $Search message: Missing source specification.\n")); goto hub_handle_command_cleanup; } /* charset handling is in parse_search_selection */ parse_result = parse_search_selection(buf, &sel); if (parse_result != 1) { if (sel.patterns != NULL) { int i = 0; for (i = 0; i < sel.patterncount; i++) { search_string_free(sel.patterns+i); } free(sel.patterns); } if (parse_result == 0) warn(_("Invalid $Search message: %s: Invalid search specification.\n"), buf); goto hub_handle_command_cleanup; } if (strncmp(source, "Hub:", 4) == 0) { DCUserInfo *ui; char *conv_nick = hub_to_main_string(source+4); ui = (DCUserInfo*) hmap_get(hub_users, conv_nick); if (ui == NULL) { warn(_("Invalid $Search message: Unknown user %s.\n"), quotearg(conv_nick)); if (sel.patterns != NULL) { int i = 0; for (i = 0; i < sel.patterncount; i++) { search_string_free(sel.patterns+i); } free(sel.patterns); } free(conv_nick); goto hub_handle_command_cleanup; } free(conv_nick); if (strcmp(ui->nick, my_nick) == 0) { if (sel.patterns != NULL) { int i = 0; for (i = 0; i < sel.patterncount; i++) { search_string_free(sel.patterns+i); } free(sel.patterns); } goto hub_handle_command_cleanup; } perform_inbound_search(&sel, ui, NULL); if (sel.patterns != NULL) { int i = 0; for (i = 0; i < sel.patterncount; i++) { search_string_free(sel.patterns+i); } free(sel.patterns); } } else { struct sockaddr_in addr; if (!parse_ip_and_port(source, &addr, DC_CLIENT_UDP_PORT)) { warn(_("Invalid $Search message: Invalid address specification.\n")); if (sel.patterns != NULL) { int i = 0; for (i = 0; i < sel.patterncount; i++) { search_string_free(sel.patterns+i); } free(sel.patterns); } goto hub_handle_command_cleanup; } if (local_addr.sin_addr.s_addr == addr.sin_addr.s_addr && listen_port == ntohs(addr.sin_port)) { if (sel.patterns != NULL) { int i = 0; for (i = 0; i < sel.patterncount; i++) { search_string_free(sel.patterns+i); } free(sel.patterns); } goto hub_handle_command_cleanup; } perform_inbound_search(&sel, NULL, &addr); if (sel.patterns != NULL) { int i = 0; for (i = 0; i < sel.patterncount; i++) { search_string_free(sel.patterns+i); } free(sel.patterns); } } } else if (len >= 4 && strncmp(buf, "$SR ", 4) == 0) { handle_search_result(buf, len); } else if (len == 0) { /* Ignore empty commands. */ } hub_handle_command_cleanup: free(hub_my_nick); }
struct variable *vm_getg(struct ymd_mach *vm, const char *field) { struct variable k, *v; setv_kstr(&k, kstr_fetch(vm, field, -1)); v = hmap_get(vm->global, &k); return v; }
/* MaxWalkSAT */ void mw_sat(samp_table_t *table, int32_t num_trials, double rvar_probability, int32_t max_flips, uint32_t timeout) { rule_inst_table_t *rule_inst_table = &table->rule_inst_table; atom_table_t *atom_table = &table->atom_table; int32_t i, j; time_t fintime; if (timeout != 0) { fintime = time(NULL) + timeout; } double best_cost = DBL_MAX; for (i = 0; i < num_trials; i++) { init_random_assignment(table); //scan_rule_instances(table); for (j = 0; j < rule_inst_table->num_rule_insts; j++) { if (rule_inst_table->rule_insts[j]->weight == DBL_MAX) rule_inst_table->assignment[j] = v_up_true; else rule_inst_table->assignment[j] = v_true; } init_live_clauses(table); scan_live_clauses(table); if (get_verbosity_level() >= 3) { printf("\n[mw_sat] Trial %d: \n", i); print_live_clauses(table); } for (j = 0; j < max_flips; j++) { if (timeout != 0 && time(NULL) >= fintime) { printf("Timeout after %"PRIu32" samples\n", i); break; } if (rule_inst_table->unsat_clauses.length == 0 && rule_inst_table->unsat_soft_rules.nelems == 0) { return; } int32_t c = genrand_uint(rule_inst_table->unsat_clauses.length + rule_inst_table->unsat_soft_rules.nelems); if (c < rule_inst_table->unsat_clauses.length) { /* picked a hard clause */ samp_clause_t *clause = choose_random_clause(&rule_inst_table->unsat_clauses); int32_t litidx = choose_clause_var(table, clause, rvar_probability); if (litidx == clause->num_lits) { if (get_verbosity_level() >= 3) { printf("[flip_rule_to_unsat] Rule %d: ", clause->rule_index); print_rule_instance(rule_inst_table->rule_insts[clause->rule_index], table); printf("\n"); } /* picked the rule auxiliary variable, i.e., rinst T -> F */ hmap_get(&rule_inst_table->unsat_soft_rules, clause->rule_index); rule_inst_table->assignment[clause->rule_index] = v_false; rule_inst_t *rinst = rule_inst_table->rule_insts[clause->rule_index]; rule_inst_table->unsat_weight += rinst->weight; /* Is this really going to do the right thing?? */ rule_inst_table->sat_weight -= rinst->weight; /* move unsat_clauses to live_clause_list and rescan */ clause_list_concat(&rule_inst_table->unsat_clauses, &rule_inst_table->live_clauses); scan_live_clauses(table); } else { flip_unfixed_variable(table, var_of(clause->disjunct[litidx])); } } else { /* picked a soft rule auxiliary variable, i.e., rinst F -> T */ int32_t rule_index = hmap_remove_random(&rule_inst_table->unsat_soft_rules); rule_inst_table->assignment[rule_index] = v_true; rule_inst_t *rinst = rule_inst_table->rule_insts[rule_index]; rule_inst_table->unsat_weight -= rinst->weight; rule_inst_table->sat_weight += rinst->weight; if (get_verbosity_level() >= 3) { printf("[flip_rule_to_sat] Rule %d: ", rule_index); print_rule_instance(rinst, table); printf("\n"); } /* move watch[~r] to live_clause_list and rescan */ clause_list_concat(&rule_inst_table->rule_watched[rule_index], &rule_inst_table->live_clauses); scan_live_clauses(table); } if (get_verbosity_level() >= 1) { printf("[mw_sat] Flip %d: # unsat hard = %d, # unsat soft = %d, " "weight of unsat soft = %f; weight of sat soft = %f\n", j, rule_inst_table->unsat_clauses.length, rule_inst_table->unsat_soft_rules.nelems, rule_inst_table->unsat_weight, rule_inst_table->sat_weight ); } if (get_verbosity_level() >= 3) { print_live_clauses(table); } if (best_cost > rule_inst_table->unsat_weight) { best_cost = rule_inst_table->unsat_weight; copy_assignment_array(atom_table); } } } restore_assignment_array(atom_table); }