int i, proto_components;

	proto_components = atoi(argv[1]);

	printf("proto_components: %d\n", proto_components);

	const unsigned char pdl[] = 

	"primitive trivial_loop() {   "

	"}                            "

	;

	Arc_ProtocolDescription * pd = protocol_description_parse(pdl, sizeof(pdl)-1);

	char logpath[] = "./bench_4.txt";

	Connector * c = connector_new_logging(pd, logpath, sizeof(logpath)-1);

	for (i=0; i<proto_components; i++) {

	port_pairs = atoi(argv[1]);

	proto_components = atoi(argv[2]);

	printf("port_pairs %d, proto_components: %d\n", port_pairs, proto_components);

	const unsigned char pdl[] = 

	"primitive trivial_loop() {   "

	"}                            "

	;

	Arc_ProtocolDescription * pd = protocol_description_parse(pdl, sizeof(pdl)-1);

	char logpath[] = "./bench_5.txt";

	Connector * c = connector_new_logging(pd, logpath, sizeof(logpath)-1);

	for (i=0; i<port_pairs; i++) {

	const unsigned char pdl[] = 

	"primitive presync_work() {   "

	"    int i = 0;               "

	"    while(true) {            "

	"        i = 0;               "

	"        while(i < 2)  i++;   "

	"    }                        "

	"}                            "

	;

	Arc_ProtocolDescription * pd = protocol_description_parse(pdl, sizeof(pdl)-1);

	char logpath[] = "./bench_4.txt";

	Connector * c = connector_new_logging(pd, logpath, sizeof(logpath)-1);

	forwards = atoi(argv[1]);

	num_options = atoi(argv[2]);

	printf("forwards %d, num_options %d\n",

		forwards, num_options);

	unsigned char pdl[] = 

	"primitive recv_zero(in a) {  "

	"        msg m = get(a);      "

	"        assert(m[0] == 0);   "

	"    }                        "

	"}                            "

	; 

	Arc_ProtocolDescription * pd = protocol_description_parse(pdl, sizeof(pdl)-1);

#include "../utility.c"

int main(int argc, char** argv) {

	int i;

	// unsigned char pdl[] = "\

	// primitive xrouter(in a, out b, out c) {\

 //            if(fires(a)) {\

 //                if(fires(b)) put(b, get(a));\

 //                else         put(c, get(a));\

 //            }\

 //        }\

 //    }"

 //    ;

	unsigned char pdl[] = "\

	primitive lossy(in a, out b) {\

            if(fires(a)) {\

                msg m = get(a);\

                if(fires(b)) put(b, m);\

            }\

        }\

    }\

    primitive sync_drain(in a, in b) {\

            if(fires(a)) {\

                get(a);\

                get(b);\

            }\

        }\

    }\

#include "../utility.c"

int main(int argc, char** argv) {

	int i, j;

	unsigned char pdl[] = "\

	primitive fifo1_init(msg m, in a, out b) {\

            if(m != null && fires(b)) {\

                put(b, m);\

                m = null;\

            } else if (m == null && fires(a)) {\

                m = get(a);\

            }\

        new replicator(m, n, c);\

    }"

    ;

	// unsigned char pdl[] = "\

	// primitive sequencer3(out a, out b, out c) {\

 //        int i = 0;\

 //            out to = a;\

 //            if     (i==1) to = b;\

 //            else if(i==2) to = c;\

 //            if(fires(to)) {\

 //                put(to, create(0));\

 //                i = (i + 1)%3;\

    char optimized = argv[1][0];

    rounds = atoi(argv[2]);

    printf("optimized %c, rounds %d\n", optimized, rounds);

    unsigned char pdl[] = "\

    primitive xrouter(in a, out b, out c) {\

            if(fires(a)) {\

                if(fires(b)) put(b, get(a));\

                else         put(c, get(a));\

            }\

        }\

    }\

primitive pres_2(in i, out o) {

    put(o, get(i));

  }

}

primitive together(in ia, in ib, out oa, out ob){

    if(fires(ia)) {

      put(oa, get(ia));

      put(ob, get(ib));

    }

  }	

}

primitive alt_round_merger(in a, in b, out c){

  while(true) {

  }	

}

pub(crate) const KW_STMT_ELSE:     &'static [u8] = b"else";

pub(crate) const KW_STMT_WHILE:    &'static [u8] = b"while";

pub(crate) const KW_STMT_BREAK:    &'static [u8] = b"break";

pub(crate) const KW_STMT_CONTINUE: &'static [u8] = b"continue";

pub(crate) const KW_STMT_GOTO:     &'static [u8] = b"goto";

pub(crate) const KW_STMT_RETURN:   &'static [u8] = b"return";

pub(crate) const KW_STMT_NEW:      &'static [u8] = b"new";

// Keywords - types

// Since types are needed for returning diagnostic information to the user, the

// string variants are put here as well.

pub(crate) const KW_TYPE_IN_PORT_STR:  &'static str = "in";

    let path = dir_path.join(format!("cid_{:?}.txt", connector_id));

    let file = File::create(path).expect("Failed to create log output file!");

    let file_logger = Box::new(FileLogger::new(connector_id, file));

    Connector::new(file_logger, pd, connector_id)

}

static MINIMAL_PDL: &'static [u8] = b"

    while (true) {

            if (fires(a) && fires(b)) {

            	msg x = get(a);

            	put(b, x);

            } else {

                assert(!fires(a) && !fires(b));

            }

        }

    }

}

primitive together(in<msg> ia, in<msg> ib, out<msg> oa, out<msg> ob){

    if(fires(ia)) {

      put(oa, get(ia));

      put(ob, get(ib));

    }

  } 

}

#[test]

fn new_sync() {

    let test_log_path = Path::new("./logs/new_sync");

    let mut c = file_logged_connector(0, test_log_path);

    let [o, i] = c.new_port_pair();

}

#[test]

fn new_net_port() {

    let test_log_path = Path::new("./logs/new_net_port");

    let mut c = file_logged_connector(0, test_log_path);

    /*

    native p|-->|g sync

    */

    let test_log_path = Path::new("./logs/cannot_use_moved_ports");

    let mut c = file_logged_connector(0, test_log_path);

    let [p, g] = c.new_port_pair();

    c.connect(SEC1).unwrap();

    c.put(p, TEST_MSG.clone()).unwrap_err();

    c.get(g).unwrap_err();

}

#[test]

           g1|<--|p1

    */

    let test_log_path = Path::new("./logs/sync_sync");

    let mut c = file_logged_connector(0, test_log_path);

    let [p0, g0] = c.new_port_pair();

    let [p1, g1] = c.new_port_pair();

    c.connect(SEC1).unwrap();

    c.put(p0, TEST_MSG.clone()).unwrap();

    c.get(g1).unwrap();

    c.sync(SEC1).unwrap();

    c.gotten(g1).unwrap();

}

            */

            let mut c = file_logged_connector(0, test_log_path);

            let [p, g] = [

                c.new_net_port(Putter, sock_addrs[0], Active).unwrap(),

                c.new_net_port(Getter, sock_addrs[1], Active).unwrap(),

            ];

            c.connect(SEC1).unwrap();

            c.sync(SEC1).unwrap();

        });

        s.spawn(|_| {

            /*

            native p|-->

        });

        s.spawn(|_| {

            // "bob"

            let pdl = b"

            primitive ac_not_b(in<msg> a, in<msg> b, out<msg> c){

                // forward A to C but keep B silent

            }";

            let pd = Arc::new(reowolf::ProtocolDescription::parse(pdl).unwrap());

            let mut c = file_logged_configured_connector(1, test_log_path, pd);

            let p0 = c.new_net_port(Getter, sock_addrs[0], Passive).unwrap();

            let p1 = c.new_net_port(Getter, sock_addrs[1], Passive).unwrap();

            let [a, b] = c.new_port_pair();

}

#[test]

fn pdl_reo_lossy() {

    let pdl = b"

    primitive lossy(in<msg> a, out<msg> b) {

            msg m = null;

            if(fires(a)) {

                m = get(a);

                if(fires(b)) {

                    put(b, m);

                }

#[test]

fn pdl_reo_fifo1() {

    let pdl = b"

    primitive fifo1(in<msg> a, out<msg> b) {

        msg m = null;

            if(m == null) {

                if(fires(a)) m=get(a);

            } else {

                if(fires(b)) put(b, m);

                m = null;

            }

fn pdl_reo_fifo1full() {

    let test_log_path = Path::new("./logs/pdl_reo_fifo1full");

    let pdl = b"

    primitive fifo1full(in<msg> a, out<msg> b) {

        bool is_set = true;

        msg m = create(0);

            if(!is_set) {

                if(fires(a)) m=get(a);

                is_set = false;

            } else {

                if(fires(b)) put(b, m);

                is_set = true;

#[test]

fn pdl_msg_consensus() {

    let test_log_path = Path::new("./logs/pdl_msg_consensus");

    let pdl = b"

    primitive msgconsensus(in<msg> a, in<msg> b) {

            msg x = get(a);

            msg y = get(b);

            assert(x == y);

        }

    }

    ";

#[test]

fn sequencer3_prim() {

    let test_log_path = Path::new("./logs/sequencer3_prim");

    let pdl = b"

    primitive sequencer3(out<msg> a, out<msg> b, out<msg> c) {

        u32 i = 0;

            out to = a;

            if     (i==1) to = b;

            else if(i==2) to = c;

            if(fires(to)) {

                put(to, create(0));

                i = (i + 1)%3;

#[test]

fn sequencer3_comp() {

    let test_log_path = Path::new("./logs/sequencer3_comp");

    let pdl = b"

    primitive replicator<T>(in<T> a, out<T> b, out<T> c) {

        while (true) {

                if (fires(a) && fires(b) && fires(c)) {

                    msg x = get(a);

                    put(b, x);

                    put(c, x);

                } else {

                    assert(!fires(a) && !fires(b) && !fires(c));

                }

            }

        }

    }

    primitive fifo1_init<T>(bool has_value, T m, in<T> a, out<T> b) {

            if(has_value && fires(b)) {

                put(b, m);

                has_value = false;

            } else if (!has_value && fires(a)) {

                m = get(a);

                has_value = true;

#[test]

fn xrouter_prim() {

    let test_log_path = Path::new("./logs/xrouter_prim");

    let pdl = b"

    primitive xrouter(in<msg> a, out<msg> b, out<msg> c) {

            if(fires(a)) {

                if(fires(b)) put(b, get(a));

                else         put(c, get(a));

            }

        }

    }

#[test]

fn xrouter_comp() {

    let test_log_path = Path::new("./logs/xrouter_comp");

    let pdl = b"

    primitive replicator<T>(in<T> a, out<T> b, out<T> c) {

        while (true) {

                if (fires(a) && fires(b) && fires(c)) {

                    msg x = get(a);

                    put(b, x);

                    put(c, x);

                } else {

                    assert(!fires(a) && !fires(b) && !fires(c));

            }

        }

    }

    primitive merger(in<msg> a, in<msg> b, out<msg> c) {

        while (true) {

                if (fires(a) && !fires(b) && fires(c)) {

                    put(c, get(a));

                } else if (!fires(a) && fires(b) && fires(c)) {

                    put(c, get(b));

                } else {

                    assert(!fires(a) && !fires(b) && !fires(c));

                }

            }

        }

    }

    primitive lossy<T>(in<T> a, out<T> b) {

            if(fires(a)) {

                auto m = get(a);

                if(fires(b)) put(b, m);

            }

        }

    }

    primitive sync_drain<T>(in<T> a, in<T> b) {

            if(fires(a)) {

                msg drop_it = get(a);

                msg on_the_floor = get(b);

            }

        }

    }

fn count_stream() {

    let test_log_path = Path::new("./logs/count_stream");

    let pdl = b"

    primitive count_stream(out<msg> o) {

        msg m = create(1);

        m[0] = 0;

            put(o, m);

            m[0] += 1;

        }

    }

    ";

    let pd = reowolf::ProtocolDescription::parse(pdl).unwrap();

    primitive for_msg_byte(out<msg> o) {

        u8 i = 0;

        u32 idx = 0;

        while(i<8) {

            msg m = create(1);

            m[idx] = i;

            i += 1;

        }

    }

    ";

    let pd = reowolf::ProtocolDescription::parse(pdl).unwrap();

    let mut c = file_logged_configured_connector(0, test_log_path, Arc::new(pd));

fn eq_causality() {

    let test_log_path = Path::new("./logs/eq_causality");

    let pdl = b"

    primitive eq(in<msg> a, in<msg> b, out<msg> c) {

        msg ma = create(0);

        msg mb = create(0);

            if(fires(a)) {

                // b and c also fire!

                // left first!

                ma = get(a);

                put(c, ma);

                mb = get(b);

        channel leftfirsto -> leftfirsti;

        new eqinner(a, b, c, leftfirsto, leftfirsti);

    }

    primitive eqinner(in<msg> a, in<msg> b, out<msg> c, out<msg> leftfirsto, in<msg> leftfirsti) {

        msg ma = create(0);

        msg mb = create(0);

            if(fires(a)) {

                // b and c also fire!

                if(fires(leftfirsti)) {

                    // left first! DO USE DUMMY

                    ma = get(a);

                    put(c, ma);

#[test]

fn test_put_and_get() {

    const CODE: &'static str = "

    primitive handler(in<u32> request, out<u32> response, u32 loops) {

        u32 index = 0;

        while (index < loops) {

                auto value = get(request);

                put(response, value * 2);

            }

            index += 1;

        }

    }

#[test]

fn test_getting_from_component() {

    const CODE: &'static str ="

    primitive loop_sender(out<u32> numbers, u32 cur, u32 last) {

        while (cur < last) {

                put(numbers, cur);

                cur += 1;

            }

        }

    }";

#[test]

fn test_putting_to_component() {

    const CODE: &'static str = "

    primitive loop_receiver(in<u32> numbers, u32 cur, u32 last) {

        while (cur < last) {

                auto number = get(numbers);

                assert(number == cur);

                cur += 1;

            }

        }

    }

#[test]

fn test_put_and_get() {

    const CODE: &'static str = "

    primitive putter(out<bool> sender, u32 loops) {

        u32 index = 0;

        while (index < loops) {

                put(sender, true);

            }

            index += 1;

        }

    }

    primitive getter(in<bool> receiver, u32 loops) {

        u32 index = 0;

        while (index < loops) {

                auto result = get(receiver);

                assert(result);

            }

            index += 1;

        }

    }

#[test]

fn test_star_shaped_request() {

    const CODE: &'static str = "

    primitive edge(in<u32> input, out<u32> output, u32 loops) {

        u32 index = 0;

        while (index < loops) {

                auto req = get(input);

                put(output, req * 2);

            }

            index += 1;

        }

    }

    primitive center(out<u32>[] requests, in<u32>[] responses, u32 loops) {

        u32 loop_index = 0;

        auto num_edges = length(requests);

        while (loop_index < loops) {

            // print(\"starting loop\");

                u32 edge_index = 0;

                u32 sum = 0;

                while (edge_index < num_edges) {

                    put(requests[edge_index], edge_index);

                    auto response = get(responses[edge_index]);

                    sum += response;

fn test_conga_line_request() {

    const CODE: &'static str = "

    primitive start(out<u32> req, in<u32> resp, u32 num_nodes, u32 num_loops) {

        u32 loop_index = 0;

        u32 initial_value = 1337;

        while (loop_index < num_loops) {

                put(req, initial_value);

                auto result = get(resp);

                assert(result == initial_value + num_nodes * 2);

            }

            loop_index += 1;

        }

        in<u32> req_in, out<u32> req_forward,

        in<u32> resp_in, out<u32> resp_forward,

        u32 num_loops

    ) {

        u32 loop_index = 0;

        while (loop_index < num_loops) {

                auto req = get(req_in);

                put(req_forward, req + 1);

                auto resp = get(resp_in);

                put(resp_forward, resp + 1);

            }

            loop_index += 1;

        }

    }

    primitive end(in<u32> req_in, out<u32> resp_out, u32 num_loops) {

        u32 loop_index = 0;

        while (loop_index < num_loops) {

                auto req = get(req_in);

                put(resp_out, req);

            }

            loop_index += 1;

        }

    }

#version 100

// sync block nested twice in primitive

primitive main(in a, out b) {

	while (true) {

		}

	}

}

Parse error at 1.pdl:7:4: Illegal nested synchronous statement

			^

#version 100

// sync block nested in sync block

primitive main(in a, out b) {

	while (true) {

			if (false || true) {

					skip;

				}

			}

		}

	} 

}

Parse error at 10.pdl:8:5: Illegal nested synchronous statement

				^

#version 100

// illegal node declaration

primitive main(in a, out b) {

	while (true) {

		channel x -> y;

	}

}

#version 100

primitive main(in a) {

	while (true) {

			if (fires(a)) {

				return 5;

			} else {

				block(a);

			}

		}

	int x = 0;

	int y = 0;

	x += y + 5;

	y %= x -= 3;

	x *= x * x *= 5;

	while (true) {

			assert fires(a) == fires(b);

		}

	}

}

#version 100

// sync block nested deeply in composite

composite main(in a, out b) {

	channel x -> y;

	while (true) {

			skip;

		}

	}

}

Parse error at 3.pdl:7:3: Illegal nested synchronous statement

		^

#version 100