const unsigned char pdl[] = 

	"primitive trivial_loop() {   "

	"}                            "

	;

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

	const unsigned char pdl[] = 

	"primitive trivial_loop() {   "

	"}                            "

	;

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

	"    while(true) {            "

	"        i = 0;               "

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

	"    }                        "

	"}                            "

	;

		forwards, num_options);

	unsigned char pdl[] = 

	"primitive recv_zero(in a) {  "

	"        msg m = get(a);      "

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

	"    }                        "

	// 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);\

	unsigned char pdl[] = "\

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

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

                put(b, m);\

                m = null;\

	// 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;\

    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_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

    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);

}

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));

    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]

    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();

    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.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();

        });

            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);

fn pdl_reo_lossy() {

    let pdl = b"

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

            msg m = null;

            if(fires(a)) {

                m = get(a);

    let pdl = b"

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

        msg m = null;

            if(m == null) {

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

            } else {

    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;

    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);

    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;

    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);

        }

    }

    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;

    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));

    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);

    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)) {

    }

    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);

    primitive count_stream(out<msg> o) {

        msg m = create(1);

        m[0] = 0;

            put(o, m);

            m[0] += 1;

        }

        while(i<8) {

            msg m = create(1);

            m[idx] = i;

            i += 1;

        }

    }

    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!

    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)) {

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

        u32 index = 0;

        while (index < loops) {

                auto value = get(request);

                put(response, value * 2);

            }

    const CODE: &'static str ="

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

        while (cur < last) {

                put(numbers, cur);

                cur += 1;

            }

    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;

    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);

            }

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

        u32 index = 0;

        while (index < loops) {

                auto req = get(input);

                put(output, req * 2);

            }

        while (loop_index < loops) {

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

                u32 edge_index = 0;

                u32 sum = 0;

                while (edge_index < num_edges) {

        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);

    ) {

        u32 loop_index = 0;

        while (loop_index < num_loops) {

                auto req = get(req_in);

                put(req_forward, req + 1);

                auto resp = get(resp_in);

    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);

            }

// 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

			^

// 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

				^

primitive main(in a, out b) {

	while (true) {

		channel x -> y;

	}

}

primitive main(in a) {

	while (true) {

			if (fires(a)) {

				return 5;

			} else {

	y %= x -= 3;

	x *= x * x *= 5;

	while (true) {

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

		}

	}

composite main(in a, out b) {

	channel x -> y;

	while (true) {

			skip;

		}

	}

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

		^

primitive main(int a) {

    while (true) {

            break; // not allowed

        }

    }

primitive main(int a) {

    loop: {

            goto loop; // not allowed

        }

    }

	msg y = create(0); // legal

	while (x < 10) {

		y = get(a); // illegal

			y = get(a); // legal

		}

	}

// duplicate formal parameters

composite main(in a, out a) {

}

// shadowing formal parameter

composite main(in a, out b) {

	channel c -> a;

}

// shadowing import

primitive syncdrain(in a, in b) {

	while (true) {

			if (!fires(a) || !fires(b)) {

				block(a);

				block(b);

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

    while (true) {

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

                msg x = get(a);

                put(b, x);

primitive syncdrain(in a, in b) {

    while (true) {

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

                get(a);

                get(b);

primitive fifo(in a, out b, msg init) {

    msg c = init;

    while (true) {

            if (c != null) {

                assert !fires(a);

                if (fires(b)) {

	while (true) {

	    boolean b = false;

		while (!b) {

				assert !fires(y);

				if (fires(x))

					b = true;

		}

		b = false;

		while (!b) {

				assert !fires(x);

				if (fires(y))

					b = true;

primitive example(in a, out[] b) {

	while (true) {

			if (fires(a)) {

				int i = 0;

				while (i < b.length) {

primitive main(in a, out b) {

	msg x = null;

	while (x == null) {

			if (fires(a))

				x = get(a);

		}

	}

	while (true) {

			if (fires(b))

				put(b, x);

		}

	y %= x -= 3;

	x *= x * (x *= 5);

	while (true) {

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

		}

	}

primitive resolve(in[] a, in[] b, out x) {

	while (true) {

			int i = 0;

			while (i < a.length && i < b.length) {

				if (fires(a[i]) && fires(b[i])) {

primitive async(in[] a) {

	while (true) {

			int i = 0;

			while (i < a.length)

				if (fires(a[i++])) break;

composite main(out c) {

	channel ao -> ai;

    channel bo -> bi;

	new binary_replicator(bi, ao, c);

}

primitive sync(in a, out b) {

    while (true) {

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

            	msg x = get(a);

            	put(b, x);

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

    while (true) {

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

                msg x = get(b);

                put(a, x);

	channel bo -> bi;

	channel axo -> axi;

	channel zo -> zi;

	new replicator(bi, {axo, c});

	new consensus({axi, zi}, ao);

	new generator(zo);

}

primitive a(in x) {

		msg m = get(x);

		assert m.length == 5;

		assert m[0] == 'h';

}

// or

primitive c(out x) {

		msg m = create(5);

		m[0] = 'h';

		m[1] = 'e';

	msg c = null;

	while (true) {

		if (c != null) {