void test_char_rnn(char *cfgfile, char *weightfile, int num, char *seed, float temp, int rseed, char *token_file)
{
char **tokens = 0;
if(token_file){
size_t n;
tokens = read_tokens(token_file, &n);
}
srand(rseed);
char *base = basecfg(cfgfile);
fprintf(stderr, "%s\n", base);
network net = parse_network_cfg(cfgfile);
if(weightfile){
load_weights(&net, weightfile);
}
int inputs = get_network_input_size(net);
int i, j;
for(i = 0; i < net.n; ++i) net.layers[i].temperature = temp;
int c = 0;
int len = strlen(seed);
float *input = calloc(inputs, sizeof(float));
/*
fill_cpu(inputs, 0, input, 1);
for(i = 0; i < 10; ++i){
network_predict(net, input);
}
fill_cpu(inputs, 0, input, 1);
*/
for(i = 0; i < len-1; ++i){
c = seed[i];
input[c] = 1;
network_predict(net, input);
input[c] = 0;
print_symbol(c, tokens);
}
if(len) c = seed[len-1];
print_symbol(c, tokens);
for(i = 0; i < num; ++i){
input[c] = 1;
float *out = network_predict(net, input);
input[c] = 0;
for(j = 32; j < 127; ++j){
//printf("%d %c %f\n",j, j, out[j]);
}
for(j = 0; j < inputs; ++j){
if (out[j] < .0001) out[j] = 0;
}
c = sample_array(out, inputs);
print_symbol(c, tokens);
}
printf("\n");
}
bool test_cond()
{
list *l;
environment *env = new_env();
macro *m;
l = read_tokens(expand_readmacro(
tokenize("(cond ((+ 1 2) (+ 2 3)) (else 0))")));
m = eval(eval(l, env), env);
assert(integer_to_int(m) == 5);
l = read_tokens(expand_readmacro(
tokenize("(cond (#f (+ 2 3)) (#f (+ 2 3))(else 0))")));
m = eval(eval(l, env), env);
assert(integer_to_int(m) == 0);
return true;
}
void test_tactic_rnn_multi(char *cfgfile, char *weightfile, int num,
real_t temp, int rseed, char *token_file) {
char **tokens = 0;
if (token_file) {
size_t n;
tokens = read_tokens(token_file, &n);
}
srand(rseed);
char *base = basecfg(cfgfile);
fprintf(stderr, "%s\n", base);
network *net = load_network(cfgfile, weightfile, 0);
int inputs = net->inputs;
int i, j;
for (i = 0; i < net->n; ++i)
net->layers[i].temperature = temp;
int c = 0;
real_t *input = calloc(inputs, sizeof(real_t));
real_t *out = 0;
while (1) {
reset_network_state(net, 0);
while ((c = getc(stdin)) != EOF && c != 0) {
input[c] = 1;
out = network_predict(net, input);
input[c] = 0;
}
for (i = 0; i < num; ++i) {
for (j = 0; j < inputs; ++j) {
if (out[j] < .0001)
out[j] = 0;
}
int next = sample_array(out, inputs);
if (c == '.' && next == '\n')
break;
c = next;
print_symbol(c, tokens);
input[c] = 1;
out = network_predict(net, input);
input[c] = 0;
}
printf("\n");
}
}
bool test_macro()
{
list *l;
environment *env = new_env();
macro *m;
list *arg;
list *body;
l = read_tokens(expand_readmacro(
tokenize("(defmacro m (x) `(,x ,x))")));
m = eval(eval(l, env), env);
arg = car(m);
body = cdr(m);
assert(equal_symbol(car(arg), new_symbol("x")));
assert(equal_symbol(car(body), new_symbol("quasiquote")));
return true;
}
void test_tactic_rnn(char *cfgfile, char *weightfile, int num, float temp, int rseed, char *token_file)
{
char **tokens = 0;
if(token_file){
size_t n;
tokens = read_tokens(token_file, &n);
}
srand(rseed);
char *base = basecfg(cfgfile);
fprintf(stderr, "%s\n", base);
network net = parse_network_cfg(cfgfile);
if(weightfile){
load_weights(&net, weightfile);
}
int inputs = get_network_input_size(net);
int i, j;
for(i = 0; i < net.n; ++i) net.layers[i].temperature = temp;
int c = 0;
float *input = calloc(inputs, sizeof(float));
float *out = 0;
while((c = getc(stdin)) != EOF){
input[c] = 1;
out = network_predict(net, input);
input[c] = 0;
}
for(i = 0; i < num; ++i){
for(j = 0; j < inputs; ++j){
if (out[j] < .0001) out[j] = 0;
}
int next = sample_array(out, inputs);
if(c == '.' && next == '\n') break;
c = next;
print_symbol(c, tokens);
input[c] = 1;
out = network_predict(net, input);
input[c] = 0;
}
printf("\n");
}
int main(int argc, char *argv[])
{
struct state_machine *sm;
char *filename;
int nstates;
int i;
int use_goto;
use_goto = is_goto(argc, argv);
sm = sm_make();
sm->tokens = read_tokens();
if (sm->tokens == NULL)
panic("Invalid token input");
read_nstates(sm);
read_initial_state(sm);
read_final_states(sm);
setup_transitions(sm);
printf("Output filename: ");
fflush(stdout);
filename = read_line();
if (use_goto)
write_output_goto(sm, filename);
else
write_output_func(sm, filename);
sm_free(sm);
return 0;
}
int test_read_tokens()
{
environment *env = new_env();
integer *i;
list *l;
list *r;
l = tokenize("10");
r = read_tokens(l);
r = expand_readmacro(r);
i = eval(r, env);
assert(integer_to_int(i) == 10);
l = tokenize("(+ 5 5)");
r = read_tokens(l);
r = expand_readmacro(r);
i = eval(r, env);
assert(integer_to_int(i) == 10);
l = tokenize("(+ (+ 1 4) (+ 2 3))");
r = read_tokens(l);
r = expand_readmacro(r);
i = eval(r, env);
assert(integer_to_int(i) == 10);
l = tokenize("(+ (+ 1 2) (+ 2 3) (+ 3 4))");
r = read_tokens(l);
r = expand_readmacro(r);
i = eval(r, env);
assert(integer_to_int(i) == 15);
l = tokenize("(+ (+ (+ 1 2) (+ 2 3)) (+ 3 4))");
r = read_tokens(l);
r = expand_readmacro(r);
i = eval(r, env);
assert(integer_to_int(i) == 15);
l = tokenize("((lambda (x) (+ x 1)) 10)");
r = read_tokens(l);
r = expand_readmacro(r);
i = eval(r, env);
assert(integer_to_int(i) == 11);
l = tokenize("(define x 10)");
r = read_tokens(l);
r = expand_readmacro(r);
i = eval(r, env);
l = tokenize("x");
r = read_tokens(l);
r = expand_readmacro(r);
i = eval(r, env);
assert(integer_to_int(i) == 10);
l = tokenize("(define y (lambda (a) (+ a x)))");
r = read_tokens(l);
r = expand_readmacro(r);
i = eval(r, env);
l = tokenize("(y 1)");
r = expand_readmacro(r);
r = read_tokens(l);
i = eval(r, env);
assert(integer_to_int(i) == 11);
l = tokenize("'(1 . 2)");
l = expand_readmacro(l);
r = read_tokens(l);
i = eval(r, env);
assert(integer_to_int(car(i)) == 1);
assert(integer_to_int(cdr(i)) == 2);
l = tokenize("`(1 2)");
l = expand_readmacro(l);
r = read_tokens(l);
i = eval(r, env);
assert(integer_to_int(car(i)) == 1);
assert(integer_to_int(car(cdr(i))) == 2);
l = tokenize("`(,x ,x)");
l = expand_readmacro(l);
r = read_tokens(l);
i = eval(r, env);
assert(integer_to_int(car(i)) == 10);
assert(integer_to_int(car(cdr(i))) == 10);
l = tokenize("`(,(+ 5 5) ,(+ 5 5))");
l = expand_readmacro(l);
r = read_tokens(l);
i = eval(r, env);
assert(integer_to_int(car(i)) == 10);
assert(integer_to_int(car(cdr(i))) == 10);
l = tokenize("(define y `(,x ,x))");
l = expand_readmacro(l);
r = read_tokens(l);
i = eval(r, env);
l = tokenize("`(,@y)");
l = expand_readmacro(l);
r = read_tokens(l);
i = eval(r, env);
assert(integer_to_int(car(i)) == 10);
assert(integer_to_int(car(cdr(i))) == 10);
l = tokenize("`(1 ,@y 3)");
l = expand_readmacro(l);
r = read_tokens(l);
i = eval(r, env);
assert(integer_to_int(car(i)) == 1);
assert(integer_to_int(car(cdr(i))) == 10);
assert(integer_to_int(car(cdr(cdr(i)))) == 10);
assert(integer_to_int(car(cdr(cdr(cdr(i))))) == 3);
l = tokenize("()");
l = expand_readmacro(l);
r = read_tokens(l);
i = eval(r, env);
assert(i == NULL);
l = tokenize("'( ) ");
l = expand_readmacro(l);
r = read_tokens(l);
i = eval(r, env);
assert(i == NULL);
return 1;
}
int taint_debug(int argc, char** argv)
{
int infd = 0;
struct taint_op top;
long taint_ops = 0;
struct stat buf;
int rc;
loff_t bytes_read = 0;
char* group_dir;
char taint_structures_filename[256];
char results_filename[256];
char filenames_filename[256];
char options_filename[256];
char tokens_filename[256];
char debug_filename[256];
if (argc < 2) {
usage();
}
group_dir = argv[1];
snprintf(taint_structures_filename, 256, "%s/taint_structures", group_dir);
snprintf(results_filename, 256, "%s/dataflow.result", group_dir);
snprintf(filenames_filename, 256, "%s/filenames", group_dir);
snprintf(options_filename, 256, "%s/options", group_dir);
snprintf(tokens_filename, 256, "%s/tokens", group_dir);
snprintf(debug_filename, 256, "%s/trace_taint_ops", group_dir);
leaf_node_table = g_hash_table_new(g_direct_hash, g_direct_equal);
merge_node_table = g_hash_table_new(g_direct_hash, g_direct_equal);
merge_index_table = g_hash_table_new(g_int64_hash, g_int64_equal);
option_info_table = g_hash_table_new(g_direct_hash, g_direct_equal);
filename_table = g_hash_table_new(g_direct_hash, g_direct_equal);
taint_operations_table = g_hash_table_new(g_direct_hash, g_direct_equal);
read_tokens(tokens_filename, option_info_table);
read_filename_mappings(filenames_filename, filename_table);
parse_taint_structures(taint_structures_filename,
leaf_node_table,
merge_node_table,
merge_index_table);
infd = open(debug_filename, O_RDONLY | O_LARGEFILE);
if (infd < 0) {
fprintf(stderr, "could not open %s, rc %d, errno %d\n", debug_filename, infd, errno);
exit(-1);
}
rc = fstat(infd, &buf);
if (rc == -1) {
fprintf(stderr, "could not stat debug file: %s, errno %d\n", debug_filename, errno);
exit(-1);
}
while(bytes_read < buf.st_size) {
bytes_read += read_taint_op_extended(infd, &top, 0);
g_hash_table_insert(taint_operations_table,
GINT_TO_POINTER(top.taint_op),
GINT_TO_POINTER(1));
taint_ops++;
if (taint_ops % 1000000 == 0) {
fprintf(stdout, "num taint ops %ld\n", taint_ops);
}
}
fprintf(stdout, "debug done\n");
print_unique_taint_ops(taint_operations_table);
return 0;
}
