static void grab_location(struct debuggee* dbg, struct location* loc,
int addr_idx, int name_idx, int src_idx,
int line_idx, int module_idx)
{
loc->address = (addr_idx != -1) ? (void*)to_num(dbg, addr_idx) : NULL;
if (name_idx != -1)
{
int pos = rm[name_idx].rm_eo;
size_t len = rm[name_idx].rm_eo - rm[name_idx].rm_so;
char* end;
while (pos-- > rm[name_idx].rm_so)
{
if (dbg->cl.buf_ptr[pos] == '+')
{
len = pos - rm[name_idx].rm_so;
break;
}
}
if ((loc->name = malloc(len + 1)))
{
memcpy(loc->name, &dbg->cl.buf_ptr[rm[name_idx].rm_so], len);
loc->name[len] = '\0';
}
loc->offset = (pos > rm[name_idx].rm_so) ? strtoul(&dbg->cl.buf_ptr[pos], &end, 16) : 0;
}
else
{
loc->name = empty_str();
loc->offset = 0;
}
loc->srcfile = (src_idx != -1) ? to_string(dbg, src_idx) : empty_str();
loc->lineno = (line_idx != -1) ? to_num(dbg, line_idx) : 0;
loc->module = (module_idx != -1) ? to_string(dbg, module_idx) : empty_str();
}
int wdt_fetch_value(struct debuggee* dbg, struct mval* mv)
{
int ret = 0;
if (!dbg->cl.buf_ptr[0])
{
mv->type = mv_null;
}
else if (compare(re_float1, dbg->cl.buf_ptr) ||
compare(re_float2, dbg->cl.buf_ptr) ||
compare(re_float3, dbg->cl.buf_ptr))
{
mv->type = mv_float;
mv->u.flt_number = to_float(dbg, 1);
}
else if (compare(re_integer, dbg->cl.buf_ptr))
{
mv->type = mv_integer;
mv->u.integer = to_num(dbg, 1);
}
else if (compare(re_hexa, dbg->cl.buf_ptr))
{
mv->type = mv_hexa;
mv->u.integer = to_num(dbg, 1);
}
else if (compare(re_string, dbg->cl.buf_ptr))
{
mv->type = mv_string;
mv->u.str = to_string(dbg, 1);
}
else if (compare(re_char, dbg->cl.buf_ptr))
{
mv->type = mv_char;
mv->u.integer = dbg->cl.buf_ptr[rm[1].rm_so];
}
else if (compare(re_struct, dbg->cl.buf_ptr))
{
mv->type = mv_struct;
mv->u.str = to_string(dbg, 1);
}
else if (compare(re_func, dbg->cl.buf_ptr))
{
mv->type = mv_func;
mv->u.integer = to_num(dbg, 1);
}
else if (compare(re_id, dbg->cl.buf_ptr))
{
mv->type = mv_string;
mv->u.str = to_string(dbg, 1);
}
else
{
mv->type = mv_error;
ret = -1;
}
return ret;
}
int wdt_start(struct debuggee* dbg, char* start)
{
int ret;
if (!re_init_done)
{
int i, mx = 0;;
re_init_done = 1;
/* init re's */
for (i = 0; i < sizeof(re) / sizeof(re[0]); i++)
{
if (mx < re[i].num) mx = re[i].num;
regcomp(&re[i].re, re[i].init_string, REG_EXTENDED);
}
assert(sizeof(rm) / sizeof(rm[0]) >= mx + 1);
assert(re_last == sizeof(re) / sizeof(re[0]));
}
memset(dbg, 0, sizeof(*dbg));
wtcl_set_prompt(&dbg->cl, "Wine-dbg>");
if (wtcl_start(&dbg->cl, start, FALSE) == -1)
{
strcpy(dbg->err_msg, "Couldn't start WineDbg");
return -1;
}
/* sync up to first prompt */
ret = wtcl_recv_up_to_prompt(&dbg->cl);
TRACE("Got for start-cmd='%s': '%s'\n", start, dbg->cl.buf_ptr);
dump_data(dbg->cl.buf_ptr, "start> ");
if (ret == -1)
{
strcpy(dbg->err_msg, "Couldn't synchronize with WineDbg");
return -1;
}
if (compare(re_started, dbg->cl.buf_ptr))
{
TRACE("Started on pid='%.*s'\n",
(int)(rm[1].rm_eo - rm[1].rm_so), &dbg->cl.buf_ptr[rm[1].rm_so]);
dbg->status = ss_started;
if (to_num(dbg, 1) != dbg->cl.info.dwProcessId)
{
snprintf(dbg->err_msg, sizeof(dbg->err_msg), "Debugging wrong process (%lx/%x)\n",
to_num(dbg, 1), dbg->cl.info.dwProcessId);
return -1;
}
}
else dbg->status = ss_none;
/* setting another symbol picker for easier testing */
wdt_execute(dbg, "set ! symbol_picker scoped");
return 0;
}
void calcword(char *word){
char num[51] = "";
int lenw = 0, found = 0, possible = 0;
int i = 0, j = 0;
lenw = to_num(word, num);
for(i = 0; i <= lenpno - lenw; i++){
if(h[i][lenw] >= 0) continue;
for(found = 1, j = 0; j < lenw; j++){
if(pno[j + i] != num[j]){
found = 0;
break;
}
}
if(found == 1){
h[i][lenw] = dicsize;
possible = 1;
}
}
if(possible == 1){
memcpy(dicname + dicsize, word, lenw + 1);
dicsize++;
}
}
int wdt_backtrace_next(struct debuggee* dbg, int* frame, struct location* loc, char** args)
{
int ret = 0;
if (loc) memset(loc, 0, sizeof(*loc));
if (args) *args = NULL;
if (compare(re_backtrace_m, dbg->cl.buf_ptr))
{
/* FIXME:
* ebp -> _to_num(dbg, 8);
*/
TRACE("Found frame='%.*s' addr='%.*s' name='%.*s' srcfile='%.*s' args='%.*s'\n",
(int)(rm[1].rm_eo - rm[1].rm_so), &dbg->cl.buf_ptr[rm[1].rm_so],
(int)(rm[2].rm_eo - rm[2].rm_so), &dbg->cl.buf_ptr[rm[2].rm_so],
(int)(rm[3].rm_eo - rm[3].rm_so), &dbg->cl.buf_ptr[rm[3].rm_so],
(int)(rm[5].rm_eo - rm[5].rm_so), &dbg->cl.buf_ptr[rm[5].rm_so],
(int)(rm[4].rm_eo - rm[4].rm_so), &dbg->cl.buf_ptr[rm[4].rm_so]);
if (frame) *frame = to_num(dbg, 1);
if (loc) grab_location(dbg, loc, 2, 3, 5, 6, 7);
if (args) *args = to_string(dbg, 4);
dbg->cl.buf_ptr += (int)(rm[0].rm_eo - rm[0].rm_so);
}
else if (compare(re_backtrace_b, dbg->cl.buf_ptr))
{
/* FIXME:
* ebp -> _to_num(dbg, 7);
*/
TRACE("Found frame='%.*s' addr='%.*s' name='%.*s' srcfile='%.*s' args='%.*s'\n",
(int)(rm[1].rm_eo - rm[1].rm_so), &dbg->cl.buf_ptr[rm[1].rm_so],
(int)(rm[2].rm_eo - rm[2].rm_so), &dbg->cl.buf_ptr[rm[2].rm_so],
(int)(rm[3].rm_eo - rm[3].rm_so), &dbg->cl.buf_ptr[rm[3].rm_so],
(int)(rm[5].rm_eo - rm[5].rm_so), &dbg->cl.buf_ptr[rm[5].rm_so],
(int)(rm[4].rm_eo - rm[4].rm_so), &dbg->cl.buf_ptr[rm[4].rm_so]);
if (frame) *frame = to_num(dbg, 1);
if (loc) grab_location(dbg, loc, 2, 3, 5, 6, -1);
if (args) *args = to_string(dbg, 4);
dbg->cl.buf_ptr += (int)(rm[0].rm_eo - rm[0].rm_so);
}
else
{
printf("No RE-backtrace for %s\n", dbg->cl.buf_ptr);
ret = -1;
}
return ret;
}
static optional<mpz> to_num(expr const & e, bool first) {
if (is_zero(e)) {
return first ? some(mpz(0)) : optional<mpz>();
} else if (is_one(e)) {
return some(mpz(1));
} else if (auto a = is_bit0(e)) {
if (auto r = to_num(*a, false))
return some(2*(*r));
} else if (auto a = is_bit1(e)) {
if (auto r = to_num(*a, false))
return some(2*(*r)+1);
} else if (auto a = is_neg(e)) {
if (auto r = to_num(*a, false))
return some(neg(*r));
}
return optional<mpz>();
}
optional<char> to_char(expr const & e) {
buffer<expr> args;
expr const & fn = get_app_args(e, args);
if (fn == *g_fin_mk && args.size() == 3) {
if (auto n = to_num(args[1])) {
return optional<char>(n->get_unsigned_int());
} else {
return optional<char>();
}
} else if (fn == *g_char_of_nat && args.size() == 1) {
if (auto n = to_num(args[0])) {
return optional<char>(n->get_unsigned_int());
} else {
return optional<char>();
}
} else {
return optional<char>();
}
}
std::string croatia_general_pattern_recognizer::fit(const std::string &pattern) const
{
for(auto it = std::sregex_iterator(std::begin(pattern),
std::end(pattern), pattern_);
it != std::sregex_iterator(); ++it){
auto str = it->str();
std::string result;
switch(str.size()){
case 6:
{
// /w{2}/d{3}/w{1}
result += to_char(str.substr(0,2));
result += to_num(str.substr(2,3));
result += to_char(str.substr(5,1));
return result;
}
case 7:
{
// /w{2}/d{3,4}/w{1,2}
result += to_char(str.substr(0,2));
result += to_num(str.substr(2,3));
result += str.substr(5,1);
result += to_char(str.substr(6,1));
return result;
}
case 8:
{
// /w{2}/d{4}/w{2}
result += to_char(str.substr(0,2));
result += to_num(str.substr(2,4));
result += to_char(str.substr(6,2));
return result;
}
}
}
return {};
}
static int
xtonum (int *pval, const char *src, int base, int cnt)
{
int i, val;
for (i = 0, val = 0; i < cnt; i++, src++)
{
int n = *(unsigned char *) src;
if (n > 127 || (n = to_num (n)) >= base)
break;
val = val * base + n;
}
*pval = val;
return i;
}
int main() {
int choice, len;
int *p;
char buf[2];
char first_array[] = "first";
char second_array[] = "second";
/*
print_term("Rogue test\n\n");
print_term("0 - End test\n");
print_term("1 - NULL pointer dereference\n");
print_term("2 - Access memory in Kseg0\n");
print_term("3 - Operate a semaphore not in Useg3\n");
print_term("4 - Request to delay for < 0 seconds\n");
print_term("5 - Write to .text section\n");
print_term("6 - Buffer overflow!\n");
*/
do {
print_term("\nEnter your choice: ");
len = read_term(buf);
if (len > 2) len = 2;
buf[1] = '\0';
choice = to_num(buf);
} while((choice < 0) || (choice > 6));
switch (choice) {
case 0:
print_term("Terminating gracefully...\n");
return 0;
break;
case 1:
p = NULL;
*p = 10; /* Should kill the process */
print_term("Should not get here!\n");
break;
case 2:
p = (int *)(SEG1 + 4);
*p = 10;
print_term("Should not get here!\n");
break;
case 3:
p = (int *)(SEG2 + (20 * PAGE_SIZE));
*p = 0; /* Should succeed */
print_term("Set the semaphore to 0...\n");
V(p, 1); /* Should fail */
print_term("Should not get here!\n");
break;
case 4:
delay(-6);
print_term("Should not get here!\n");
break;
case 5:
p = (int *)(SEG2 + 10); /* This is in the .text section */
*p = 42;
print_term("Should not get here!\n");
break;
case 6:
print_term("\nfirst_array[] is ");
print_term(first_array);
print_term("\nsecond_array[] is ");
print_term(second_array);
print_term("\nnow enter a string longer than 6 characters...");
read_term(first_array);
print_term("\nnow first_array[] is ");
print_term(first_array);
print_term("\nand second_array[] is ");
print_term(second_array);
return 0;
default:
print_term("Should not get here...\n");
break;
}
print_term("Houston, we have a problem...\n");
return 0;
}
int wdt_execute(struct debuggee* dbg, const char* cmd, ...)
{
int ret;
va_list valist;
va_start(valist, cmd);
wtcl_send_vcmd(&dbg->cl, cmd, valist);
va_end(valist);
ret = wtcl_recv_up_to_prompt(&dbg->cl);
TRACE("Got for exec-cmd='%s': '%s'\n", cmd, dbg->cl.buf_ptr);
dump_data(dbg->cl.buf_ptr, "exec> ");
if (ret == -1)
{
snprintf(dbg->err_msg, sizeof(dbg->err_msg), "Couldn't execute command '%s' -> %s", cmd, dbg->cl.buf_ptr);
return -1;
}
if (dbg->num_display) free_display(dbg);
while (compare(re_display, dbg->cl.buf_ptr))
{
char* end;
TRACE("Got display #%.*s: '%.*s' = '%.*s'\n",
(int)(rm[1].rm_eo - rm[1].rm_so), &dbg->cl.buf_ptr[rm[1].rm_so],
(int)(rm[2].rm_eo - rm[2].rm_so), &dbg->cl.buf_ptr[rm[2].rm_so],
(int)(rm[3].rm_eo - rm[3].rm_so), &dbg->cl.buf_ptr[rm[3].rm_so]);
dbg->display = realloc(dbg->display, ++dbg->num_display * sizeof(dbg->display[0]));
if (dbg->num_display != to_num(dbg, 1))
{
free_display(dbg);
strcpy(dbg->err_msg, "Suspicious display index");
return -1;
}
dbg->display[dbg->num_display - 1].expr = to_string(dbg, 2);
end = dbg->cl.buf_ptr + rm[3].rm_eo;
end[0] = '\0';
dbg->cl.buf_ptr += rm[3].rm_so; /* start of expression */
wdt_fetch_value(dbg, &dbg->display[dbg->num_display - 1].mval);
dbg->cl.buf_ptr = end + 1;
}
/* different possible outputs:
* Breakpoint (bpnum) at 0x(addr) (name) [(srcfile):(lineno)] in (module) (refcount=2)
*/
if (compare(re_stopped_bp_m, dbg->cl.buf_ptr) || compare(re_stopped_wp_m, dbg->cl.buf_ptr))
{
TRACE("Stopped at xp='%.*s' addr='%.*s' name='%.*s' src='%.*s'/line=%.*s module='%.*s'\n",
(int)(rm[1].rm_eo - rm[1].rm_so), &dbg->cl.buf_ptr[rm[1].rm_so],
(int)(rm[2].rm_eo - rm[2].rm_so), &dbg->cl.buf_ptr[rm[2].rm_so],
(int)(rm[3].rm_eo - rm[3].rm_so), &dbg->cl.buf_ptr[rm[3].rm_so],
(int)(rm[4].rm_eo - rm[4].rm_so), &dbg->cl.buf_ptr[rm[4].rm_so],
(int)(rm[5].rm_eo - rm[5].rm_so), &dbg->cl.buf_ptr[rm[5].rm_so],
(int)(rm[6].rm_eo - rm[6].rm_so), &dbg->cl.buf_ptr[rm[6].rm_so]);
dbg->status = ss_xpoint;
dbg->info = to_num(dbg, 1);
wdt_free_location(&dbg->loc);
grab_location(dbg, &dbg->loc, 2, 3, 4, 5, 6);
}
else if (compare(re_stopped_bp_b, dbg->cl.buf_ptr) || compare(re_stopped_wp_b, dbg->cl.buf_ptr))
{
TRACE("Stopped at xp='%.*s' addr='%.*s' name='%.*s' src='%.*s'/line=%.*s\n",
(int)(rm[1].rm_eo - rm[1].rm_so), &dbg->cl.buf_ptr[rm[1].rm_so],
(int)(rm[2].rm_eo - rm[2].rm_so), &dbg->cl.buf_ptr[rm[2].rm_so],
(int)(rm[3].rm_eo - rm[3].rm_so), &dbg->cl.buf_ptr[rm[3].rm_so],
(int)(rm[4].rm_eo - rm[4].rm_so), &dbg->cl.buf_ptr[rm[4].rm_so],
(int)(rm[5].rm_eo - rm[5].rm_so), &dbg->cl.buf_ptr[rm[5].rm_so]);
dbg->status = ss_xpoint;
dbg->info = to_num(dbg, 1);
wdt_free_location(&dbg->loc);
grab_location(dbg, &dbg->loc, 2, 3, 4, 5, -1);
}
else if (compare(re_funcchange, dbg->cl.buf_ptr))
{
TRACE("Entering function %.*s src='%.*s'/line=%.*s\n",
(int)(rm[1].rm_eo - rm[1].rm_so), &dbg->cl.buf_ptr[rm[1].rm_so],
(int)(rm[2].rm_eo - rm[2].rm_so), &dbg->cl.buf_ptr[rm[2].rm_so],
(int)(rm[3].rm_eo - rm[3].rm_so), &dbg->cl.buf_ptr[rm[3].rm_so]);
dbg->status = ss_step;
wdt_free_location(&dbg->loc);
grab_location(dbg, &dbg->loc, -1, 1, 2, 3, -1);
}
else if (compare(re_srcline, dbg->cl.buf_ptr))
{
/* FIXME:
* - this is wrong if we change to another function in the same file
* - what happens if we move to a new function or file ??
*/
dbg->status = ss_step;
dbg->loc.lineno = to_num(dbg, 1);
}
else if (compare(re_asmline, dbg->cl.buf_ptr))
{
dbg->status = ss_step;
wdt_free_location(&dbg->loc);
grab_location(dbg, &dbg->loc, 1, 2, -1, -1, 3);
}
else if (compare(re_terminated, dbg->cl.buf_ptr))
{
TRACE("Terminated on pid %.*s\n",
(int)(rm[1].rm_eo - rm[1].rm_so), &dbg->cl.buf_ptr[rm[1].rm_so]);
if (to_num(dbg, 1) != dbg->cl.info.dwProcessId)
{
snprintf(dbg->err_msg, sizeof(dbg->err_msg), "Wrong pid termination (%lx/%x)\n",
to_num(dbg, 1), dbg->cl.info.dwProcessId);
ret = -1;
}
}
else TRACE("No RE-exec on '%s' for cmd=%s\n", dbg->cl.buf_ptr, cmd);
return ret;
}
int wdt_set_xpoint(struct debuggee* dbg, const char* cmd,
int* xp_num, struct location* loc)
{
int ret = 0;
if (loc) memset(loc, 0, sizeof(*loc));
if (wtcl_execute(&dbg->cl, cmd) == -1) return -1;
TRACE("Got for cmd='%s': '%s'\n", cmd, dbg->cl.buf_ptr);
/* Breakpoint 1 at 0x???????? main [srcfile:lineno] in module */
if (compare(re_set_break_m, dbg->cl.buf_ptr))
{
TRACE("Found bp='%.*s' addr='%.*s' name='%.*s' src='%.*s'/lineno='%.*s' module='%.*s'\n",
(int)(rm[1].rm_eo - rm[1].rm_so), &dbg->cl.buf_ptr[rm[1].rm_so],
(int)(rm[2].rm_eo - rm[2].rm_so), &dbg->cl.buf_ptr[rm[2].rm_so],
(int)(rm[3].rm_eo - rm[3].rm_so), &dbg->cl.buf_ptr[rm[3].rm_so],
(int)(rm[4].rm_eo - rm[4].rm_so), &dbg->cl.buf_ptr[rm[4].rm_so],
(int)(rm[5].rm_eo - rm[5].rm_so), &dbg->cl.buf_ptr[rm[5].rm_so],
(int)(rm[6].rm_eo - rm[6].rm_so), &dbg->cl.buf_ptr[rm[6].rm_so]);
if (xp_num) *xp_num = to_num(dbg, 1);
if (loc)
{
grab_location(dbg, loc, 2, 3, 4, 5, 6);
}
}
else if (compare(re_set_break_b, dbg->cl.buf_ptr))
{
TRACE("Found bp='%.*s' addr='%.*s' name='%.*s' src='%.*s'/lineno='%.*s'\n",
(int)(rm[1].rm_eo - rm[1].rm_so), &dbg->cl.buf_ptr[rm[1].rm_so],
(int)(rm[2].rm_eo - rm[2].rm_so), &dbg->cl.buf_ptr[rm[2].rm_so],
(int)(rm[3].rm_eo - rm[3].rm_so), &dbg->cl.buf_ptr[rm[3].rm_so],
(int)(rm[4].rm_eo - rm[4].rm_so), &dbg->cl.buf_ptr[rm[4].rm_so],
(int)(rm[5].rm_eo - rm[5].rm_so), &dbg->cl.buf_ptr[rm[5].rm_so]);
if (xp_num) *xp_num = to_num(dbg, 1);
if (loc)
{
grab_location(dbg, loc, 2, 3, 4, 5, -1);
}
}
else if (compare(re_set_watch1_m, dbg->cl.buf_ptr))
{
TRACE("Found wp='%.*s' addr='%.*s' name='%.*s' module='%.*s'\n",
(int)(rm[1].rm_eo - rm[1].rm_so), &dbg->cl.buf_ptr[rm[1].rm_so],
(int)(rm[2].rm_eo - rm[2].rm_so), &dbg->cl.buf_ptr[rm[2].rm_so],
(int)(rm[3].rm_eo - rm[3].rm_so), &dbg->cl.buf_ptr[rm[3].rm_so],
(int)(rm[4].rm_eo - rm[4].rm_so), &dbg->cl.buf_ptr[rm[4].rm_so]);
if (xp_num) *xp_num = to_num(dbg, 1);
if (loc) grab_location(dbg, loc, 2, 3, -1, -1, 4);
}
else if (compare(re_set_watch1_b, dbg->cl.buf_ptr))
{
TRACE("Found wp='%.*s' addr='%.*s' name='%.*s'\n",
(int)(rm[1].rm_eo - rm[1].rm_so), &dbg->cl.buf_ptr[rm[1].rm_so],
(int)(rm[2].rm_eo - rm[2].rm_so), &dbg->cl.buf_ptr[rm[2].rm_so],
(int)(rm[3].rm_eo - rm[3].rm_so), &dbg->cl.buf_ptr[rm[3].rm_so]);
if (xp_num) *xp_num = to_num(dbg, 1);
if (loc) grab_location(dbg, loc, 2, 3, -1, -1, -1);
}
else if (compare(re_set_watch2, dbg->cl.buf_ptr))
{
TRACE("Found wp='%.*s' addr='%.*s'\n",
(int)(rm[1].rm_eo - rm[1].rm_so), &dbg->cl.buf_ptr[rm[1].rm_so],
(int)(rm[2].rm_eo - rm[2].rm_so), &dbg->cl.buf_ptr[rm[2].rm_so]);
if (xp_num) *xp_num = to_num(dbg, 1);
if (loc) grab_location(dbg, loc, 2, -1, -1, -1, -1);
}
else
{
printf("No RE-set_bp for %s\n", dbg->cl.buf_ptr);
ret = -1;
}
return ret;
}
int sum(struct node *h1, struct node *h2) {
return to_num(h1) + to_num(h2);
}
int main(int argc, char *argv[]) {
int i, j, mat_a[ROW][COL], mat_b[ROW][COL];
int cnt = 0, a_row = 0, a_col = 0, b_row = 0, b_col = 0;
char *row = (char *) malloc(sizeof(char) * 128);
char *row_cpy = (char *) malloc(sizeof(char) * 128);
int number_token;
while (cnt != 1) {
fgets(row, 128, stdin);
row[strlen(row) - 1] = 0;
strcpy(row_cpy, row);
if (strlen(row) == 0) {
cnt++;
} else if (cnt == 0) {
if (a_col == 0) {
a_col = n_token(row_cpy);
strcpy(row_cpy, row);
int val = 0, tok_n = 0;
char *token = strtok(row_cpy, " ");
while (token) {
val = to_num(token);
mat_a[a_row][tok_n] = val;
tok_n++;
token = strtok(NULL, " ");
}
} else if ((number_token = n_token(row_cpy)) != a_col) {
printf("inconsistent number of columns\n");
exit(0);
} else {
strcpy(row_cpy, row);
int val = 0, tok_n = 0;
char *token = strtok(row_cpy, " ");
while (token) {
val = to_num(token);
mat_a[a_row][tok_n] = val;
tok_n++;
token = strtok(NULL, " ");
}
}
a_row++;
}
}
for (i = 0; i < a_row; i++) {
for (j = 0; j < a_col; j++) {
mat_b[j][i] = mat_a[i][j];
}
}
b_row = a_col;
b_col = a_row;
// printf("The transpose of the input matrix:\n");
for (i = 0; i < b_row; i++) {
for (j = 0; j < b_col; j++) {
printf("%d ", mat_b[i][j]);
}
printf("\n");
}
return 0;
}
optional<mpz> to_num(expr const & e) {
return to_num(e, true);
}
bool parse_arguments(int argc_, const char* argv_[], InputArguments& outArgs_)
{
outArgs_.mode = (argv_[1][0] == 'e') ? InputArguments::EncodeMode : InputArguments::DecodeMode;
// parse params
//
for (int i = 2; i < argc_; ++i)
{
const char* param = argv_[i];
if (param[0] != '-')
continue;
int pval = -1;
int len = strlen(param);
if (len > 2 && len < 10)
{
pval = to_num((const uchar*)param + 2, len - 2);
ASSERT(pval >= 0);
}
const char* str = param + 2;
const uint32 slen = len - 2;
switch (param[1])
{
case 'i': outArgs_.inputFile.assign(str, str + slen); break;
case 'o': outArgs_.outputFile.assign(str, str + slen); break;
case 'e': outArgs_.params.encodeThresholdValue = pval; break;
case 's': outArgs_.params.insertCost = pval; break;
case 'm': outArgs_.params.mismatchCost = pval; break;
case 't': outArgs_.threadsNum = pval; break;
case 'v': outArgs_.verboseMode = true; break;
#if (DEV_TWEAK_MODE)
case 'n': outArgs_.params.maxCostValue = pval; break;
case 'f': outArgs_.params.minBinSize = pval; break;
#endif
}
}
// check params
//
if (outArgs_.inputFile.size() == 0)
{
std::cerr << "Error: no input file specified\n";
return false;
}
if (outArgs_.outputFile.length() == 0)
{
std::cerr << "Error: no output file specified\n";
return false;
}
if (outArgs_.threadsNum == 0 || outArgs_.threadsNum > 64)
{
std::cerr << "Error: invalid number of threads specified\n";
return false;
}
return true;
}
