// Network Topology:

//  two nodes, a and b, and two channels

// Node a:

//  Two ports, a0 and a1, where a0 is passive and a1 is active

// Node b:

//  Two ports, b0 and b1, where b0 is active and b1 is passive

// Channel a0--b0, where b0 initiates

// Channel a1--b1, where a1 initiates

primitive main(in a0, in a1) {

    while (true) {

        synchronous {

            if (fires(a0)) {

                msg x = get(a0);

            }

        }

        synchronous {

            if (fires(a1)) {

                msg y = get(a1);

            }

        }

    }

}

// Network Topology:

//  two nodes, a and b, and two channels

// Node a:

//  Two ports, a0 and a1, where a0 is passive and a1 is active

// Node b:

//  Two ports, b0 and b1, where b0 is active and b1 is passive

// Channel a0--b0, where b0 initiates

// Channel a1--b1, where a1 initiates

primitive main(out b0, out b1) {

    synchronous {}

    synchronous {}

    synchronous {

        msg x = create(0);

        put(b0, x);

    }

    synchronous {}

    synchronous {

        msg y = create(0);

        put(b1, y);

    }

    while (true) {

        synchronous {}

    }

}

#version 100

composite main() {}

int test() {

	int x = 5;

	x++;

	return x;

}

6

#version 100

composite main() {}

int test() {

	int x = 5;

	if (x < 5) {

	    x = --x;

	}

	x++;

	return x;

}

6

#version 100

composite main() {}

int test() {

	int x = 5;

	if (x >= 5) { // true

	    int y = 2;

	    x -= --y; // --y is 1, so x -= 1 results in 4

	}

	x++; // becomes 5

	return x;

}

5

#version 100

composite main() {}

int test() {

	int x = 5;

	while (x < 10) {

	    x += 2;

	    if (x == 10) return x; // never taken

	}

	return x;

}

11

#version 100

composite main() {}

int test() {

	int x = 5;

l:	while (x < 10) {

	    if (x % 2 == 0) {

	        x += 1; // if even, add one, making it odd

	    } else {

	        x += 3; // if odd, add three, making it even

	    }

	}

	if (x > 10) {

	    x -= 10; // keep under 10

	    goto l;

	}

	return x;

}

10

#version 100

composite main() {}

int test() {

	msg x = create(5);

	x[0] = 1;

	x[1] = 2;

	x[2] = 3;

	x[3] = 4;

	x[4] = 5;

	return x;

}

#msg(5;1,2,3,4,5)

#version 100

// sync block nested twice in primitive

primitive main(in a, out b) {

	while (true) {

		synchronous {

			synchronous {}

		}

	}

}

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

			synchronous {}

			^

#version 100

// sync block nested in sync block

primitive main(in a, out b) {

	while (true) {

		synchronous {

			if (false || true) {

				synchronous {

					skip;

				}

			}

		}

	} 

}

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

				synchronous {

				^

#version 100

// illegal node declaration

primitive main(in a, out b) {

	while (true) {

		channel x -> y;

		synchronous {}

	}

}

Parse error at 12.pdl:6:3: Illegal channel delcaration

		channel x -> y;

		^

#version 100

// function statement must return

int myfun(int x) {

	if (x > 0) {

		while (x > 0) {

			x--;

			if (x == 0) skip; // illegal!

			else return x;

		}

	} else {

		int y = 0;

label:  if (y >= 0) {

			goto label;

		} else {

			y = 5;

			return myfun(x + 1);

		}

	}

}

Parse error at 13.pdl:8:16: Function definition must return

			if (x == 0) skip; // illegal!

			            ^

#version 100

// illegal builtin

composite main(in a, out b) {

	int x = get(a);

	skip;

}

Parse error at 14.pdl:5:10: Illegal built-in occurrence

	int x = get(a);

	        ^

#version 100

// illegal assignment

primitive main(in a, out b) {

	int x = 0;

	int y = 0;

	x + y = 0;

}

Parse error at 17.pdl:7:4: Unassignable expression

	x + y = 0;

	  ^

#version 100

// illegal subject

primitive main(in a, out b) {

	int x = 0;

	int[] y = {x, x, x};

	y[0] = (x+y)[0];

}

Parse error at 18.pdl:7:11: Unindexable expression

	y[0] = (x+y)[0];

	         ^

#version 100

primitive main(in a) {

	while (true) {

		synchronous {

			if (fires(a)) {

				return 5;

			} else {

				block(a);

			}

		}

	}

}

Parse error at 19.pdl:7:5: Component definition must not return

				return 5;

				^

#version 100

// duplicate procedures

composite main(in a, out b) {

	id(a, d); 

}

primitive main(in a, out b) {

	skip;

}

Parse error at 2.pdl:8:1: Defined symbol clash: main

primitive main(in a, out b) {

^

#version 100

primitive main(in a) {

	int[] x = {1,2,3};

	x[1] = (x[0] < x[2] ? x[1:2] : x[0:1])[0:0][0];

	x[1] = x[1][0:1];

}

Parse error at 20.pdl:6:10: Unindexable expression

	x[1] = x[1][0:1];

	        ^

#version 100

int main(int a) {

dupl:

	while (a >= 2) {

		a -= 2;

dupl:	while (a < 10) {

			a++;

			if (a % 5 == 0)

				break dupl;

		}

	}

	goto dupl;

}

Parse error at 22.pdl:7:1: Duplicate label

dupl:	while (a < 10) {

^

#version 100

int main(int a) {

outer:

	while (a >= 2) {

		a -= 2;

		while (a < 10) {

unreach:	a++;

			if (a % 5 == 0)

				break outer;

		}

	}

	goto unreach;

}

Parse error at 23.pdl:13:7: Unresolved label

	goto unreach;

	     ^

#version 100

primitive main(in a, out b) {

	int x = 0;

	int y = 0;

	x += y + 5;

	y %= x -= 3;

	x *= x * x *= 5;

	while (true) {

		synchronous {

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

		}

	}

}

Parse error at 24.pdl:8:9: Unassignable expression

	x *= x * x *= 5;

	       ^

#version 100

primitive main(in a, out b) {

	int x = 0;

	int y = 0;

	while (true) {

		synchronous (int x) { // illegal

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

		}

	}

}

Parse error at 25.pdl:7:20: Declared variable clash

		synchronous (int x) { // illegal

		                 ^

#version 100

primitive main(in a, out b) {

	break; // illegal

}

Parse error at 26.pdl:4:2: Illegal break: no surrounding while statement

	break; // illegal

	^

#version 100

int main(int a) {

	while (a >= 2) {

		a -= 2;

dupl:	while (a < 10) {

			a++;

			if (a % 5 == 0)

				break dupl;

		}

	}

	skip;

dupl:

	while (true) goto dupl;

}

Parse error at 27.pdl:6:1: Duplicate label

dupl:	while (a < 10) {

^

#version 100

int main(int a) {

    int x = 0;

    (x + 5)++; // not assignable

    return x;

}

Parse error at 28.pdl:5:8: Unassignable expression

    (x + 5)++; // not assignable

       ^

#version 100

int main(int a) {

    int[] x = {};

    ++(x[0..5][2 - x[0]].length); // not assignable

    return x;

}

Parse error at 29.pdl:5:25: Unassignable expression

    ++(x[0..5][2 - x[0]].length); // not assignable

                        ^

#version 100

// sync block nested deeply in composite

composite main(in a, out b) {

	channel x -> y;

	while (true) {

		synchronous {

			skip;

		}

	}

}

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

		synchronous {

		^

#version 100

int main(int a) {

    int x = 5;

    int y = x + 5;

    int z = z; // now allowed

}

Parse error at 30.pdl:6:13: Unresolved variable

    int z = z; // now allowed

            ^

#version 100

primitive main(int a) {

    while (true) {

        synchronous {

            break; // not allowed

        }

    }

}

Parse error at 31.pdl:6:13: Illegal break: synchronous statement escape

            break; // not allowed

            ^

#version 100

primitive main(int a) {

    loop: {

        synchronous {

            goto loop; // not allowed

        }

    }

}

Parse error at 32.pdl:6:13: Illegal goto: synchronous statement escape

            goto loop; // not allowed

            ^

#version 100

// built-in outside sync block

primitive main(in a, out b) {

	int x = 0;

	msg y = create(0); // legal

	while (x < 10) {

		y = get(a); // illegal

		synchronous {

			y = get(a); // legal

		}

	}

}

Parse error at 4.pdl:8:7: Illegal built-in occurrence

		y = get(a); // illegal

		    ^

#version 100

// unresolved component

composite main(in a, out b) {

	sync(a, b);

}

Parse error at 5.pdl:5:2: Unresolved method

	sync(a, b);

	^

#version 100

import std.reo;

// duplicate formal parameters

composite main(in a, out a) {

	new sync(a, a);

}

Parse error at 6.pdl:6:26: Declared variable clash

composite main(in a, out a) {

                         ^

#version 100

import std.reo;

// shadowing formal parameter

composite main(in a, out b) {

	channel c -> a;

	new sync(a, b);

}

Parse error at 7.pdl:7:15: Declared variable clash

	channel c -> a;

	             ^

#version 100

import std.reo;

composite main(in a, out b) {

	channel c -> d;

	syncdrain(a, b);

}

// shadowing import

primitive syncdrain(in a, in b) {

	while (true) {

		synchronous {

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

				block(a);

				block(b);