Inital commit (parsing working)

.classpath

+<?xml version="1.0" encoding="UTF-8"?>
+<classpath>
+	<classpathentry kind="src" path="src/generated">
+		<attributes>
+			<attribute name="ignore_optional_problems" value="true"/>
+		</attributes>
+	</classpathentry>
+	<classpathentry including="**" kind="src" path="src/resource"/>
+	<classpathentry kind="src" path="src/java"/>
+	<classpathentry kind="lib" path="tools/beaver.jar"/>
+	<classpathentry kind="lib" path="tools/junit-4.11-SNAPSHOT.jar"/>
+	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER"/>
+	<classpathentry kind="output" path="bin"/>
+</classpath>

.gitignore

+.DS_Store
+.class
+.vimrc
+.*.swp
+*.relast
+
+/.settings
+/bin/
+/ant-bin/
+/compiler.jar
+/src/generated/
+/.gradle

.project

+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+	<name>rel-rag</name>
+	<comment></comment>
+	<projects>
+	</projects>
+	<buildSpec>
+		<buildCommand>
+			<name>org.eclipse.jdt.core.javabuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+	</buildSpec>
+	<natures>
+		<nature>org.eclipse.jdt.core.javanature</nature>
+	</natures>
+</projectDescription>

build.xml

+<project name="RelAstCompiler" default="build" basedir=".">
+	<property name="srcdir" value="${basedir}/src" />
+	<property name="resourcedir" value="${srcdir}/resource" />
+	<property name="gendir" value="${srcdir}/generated" />
+	<property name="bindir" value="${basedir}/ant-bin" />
+	<property name="docdir" value="${basedir}/doc" />
+	<property name="tools" value="${basedir}/tools"/>
+	<property name="test-reports.dir" location="report-tests"/>
+
+	<property name="jarfile" value="compiler.jar" />
+	<property name="junitjar" value="${tools}/junit-4.11-SNAPSHOT.jar" />
+
+	<!-- "package" is the directory where generated files will be stored -->
+	<property name="package" value="org.jastadd.relast.ast"/>
+	<loadresource property="package.path">
+		<propertyresource name="package"/>
+			<filterchain>
+				<tokenfilter>
+					<filetokenizer/>
+					<replacestring from="." to="/"/>
+				</tokenfilter>
+			</filterchain>
+	</loadresource>
+	
+	<!-- Define Ant tasks -->
+	<taskdef name="jastadd" classname="org.jastadd.JastAddTask" classpath="${tools}/jastadd2.jar"/>
+	<taskdef name="jflex" classname="jflex.anttask.JFlexTask" classpath="${tools}/JFlex.jar"/>
+	<taskdef name="beaver" classname="beaver.comp.run.AntTask" classpath="${tools}/beaver.jar"/>
+
+	<!-- compile sources -->
+	<target name="build" depends="gen">
+		<mkdir dir="${bindir}" />
+		<javac
+			debug="true"
+			nowarn="true"
+			srcdir="${basedir}"
+			destdir="${bindir}"
+			includes="src/**/*.java"
+			classpath=".:${tools}/beaver-rt.jar:${junitjar}"
+			fork="true"
+			includeAntRuntime="false"
+			memoryMaximumSize="128M"
+			target="8"
+			source="8"
+			/>
+		<copy todir="${bindir}/">
+			<fileset dir="${resourcedir}"/>
+		</copy>
+	</target>
+
+	<!-- generate compiler source files -->
+	<target name="gen" depends="scanner,parser">
+		<!-- create AST node types and weave aspect modules -->
+		<echo message = "Running JastAdd"/>
+		<jastadd package="${package}" rewrite="cnta" safeLazy="true" beaver="true" visitcheck="false"
+				lazyMaps="true" outdir="${gendir}" cache="all" lineColumnNumbers="true">
+			<fileset dir=".">
+				<include name="spec/jastadd/*.ast"/>
+				<include name="spec/jastadd/*.jadd"/>
+				<include name="spec/jastadd/*.jrag"/>
+			</fileset>
+		</jastadd>
+	</target>
+
+	<target name="scanner">
+		<jflex file="spec/scanner/RelAst.flex" outdir="${gendir}/${package.path}" InputStreamCtor="false" nobak="yes"/>
+	</target>
+
+	<target name="parser" depends="scanner">
+		<concat destfile="${gendir}/${package.path}/RelAstParser.all" binary="true" force="false">
+			<!-- we use filelist because the order is important -->
+			<filelist dir="spec/parser/">
+				<file name="Preamble.parser"/>
+				<file name="RelAstBase.parser"/>
+			</filelist>
+		</concat>
+
+		<!-- generate the parser phase 1, translating .parser to .beaver -->
+		<java classpath="${tools}/JastAddParser.jar:${tools}/beaver-rt.jar" classname="Main" fork="true">
+			<arg value="--no-beaver-symbol" />
+			<arg value="${gendir}/${package.path}/RelAstParser.all" />
+			<arg value="${gendir}/${package.path}/RelAstParser.beaver" />
+		</java>
+		<!-- generate the parser phase 2, translating .beaver to .java -->
+		<beaver file="${gendir}/${package.path}/RelAstParser.beaver" terminalNames="yes" compress="no" useSwitch="yes"/>
+	</target>
+
+	<!-- remove generated source files and .class files -->
+	<target name="clean">
+		<delete dir="${gendir}" />
+		<mkdir dir="${gendir}" />
+		<delete dir="${bindir}" />
+		<delete file="${jarfile}" />
+		<delete>
+			<fileset dir="." includes="**/*.class" excludes="bin/" />
+			<fileset dir="testfiles/code_generation/" includes="*.c *.executable *.out"/>
+		</delete>
+	</target>
+	
+	<target name="test" depends="build">
+		<mkdir dir="${test-reports.dir}"/>
+		<junit>
+			<classpath>
+				<pathelement path="${bindir}:${junitjar}:${tools}/beaver-rt.jar" />
+			</classpath>
+			<formatter type="brief" usefile="false" />
+
+			<batchtest todir="${test-reports.dir}">
+				<fileset dir="src/java">
+					<include name="org/jastadd/relast/tests/*.java" />
+					<include name="org/jastadd/relast/tests/codegen/*.java" />
+				</fileset>
+			</batchtest>
+
+			<formatter type="xml" />
+		</junit>
+	</target>
+
+	<target name="jar" depends="build">
+		<jar destfile="${jarfile}">
+			<fileset dir="${bindir}" includes="**/*.class,resource/" excludes="org/jastadd/relast/tests/*" />
+			<fileset dir="${srcdir}/java" includes="**/*.java" excludes="org/jastadd/relast/tests/*" />
+			<fileset dir="${resourcedir}" includes="**" />
+			<fileset dir="${gendir}" includes="**/*.java" />
+			<zipfileset includes="**/*.class" src="${tools}/beaver-rt.jar"/>
+			<manifest>
+				<attribute name="Main-Class" value="org.jastadd.relast.compiler.Compiler" />
+			</manifest>
+		</jar>
+	</target>
+	
+	<target name="doc" depends="build" description="generate documentation">
+		<mkdir dir="${docdir}"/>
+		<javadoc
+				classpath="${gendir}:${tools}/beaver.jar"
+				destdir="${docdir}"
+				docletpath="${tools}/RagDoll.jar"
+				doclet="ragdoll.RagDollDoclet"
+				sourcepath="${gendir}">
+			<arg value="-linksource"/>
+			<arg value="-ragroot"/>
+			<arg value="."/>
+		</javadoc>
+	</target>
+
+
+	<!-- Run DrAST. Clone and build DrAST if it's not there -->
+	<target name="drast" depends="drast-init" >
+		<java jar="drast/DrAST-1.2.0.jar" fork="true" spawn="true" />
+	</target>
+	<target name="drast-init" depends="drast-check" unless="drast.exists" >
+		<exec executable="git">
+			<arg value="clone"/>
+			<arg value="git@bitbucket.org:jastadd/drast.git"/>
+		</exec>
+		<exec dir="drast" executable="./gradlew" />
+	</target>
+	<target name="drast-check">
+		<condition property="drast.exists">
+			<available file="drast" type="dir" />
+		</condition>
+	</target>
+	<target name="drast-update">
+		<delete dir="drast" />
+		<antcall target="drast-init" />
+	</target>
+</project>

spec/jastadd/Analysis.jrag

+import java.util.*;
+
+
+aspect Analysis {
+
+}
\ No newline at end of file

spec/jastadd/DumpTree.jrag

+import java.io.ByteArrayOutputStream;
+import java.io.PrintStream;
+import java.lang.reflect.InvocationTargetException;
+
+// We have been careful to not import many types here because the imports are added for
+// _ALL_ AST nodes and can cause collisions in the abstract grammar namespace.
+
+aspect DumpTree {
+	private static final String ASTNode.DUMP_TREE_INDENT = "  ";
+
+	public String ASTNode.dumpTree() {
+		ByteArrayOutputStream bytes = new ByteArrayOutputStream();
+		dumpTree(new PrintStream(bytes));
+		return bytes.toString();
+	}
+
+	public void ASTNode.dumpTree(PrintStream out) {
+		dumpTree(out, "");
+		out.flush();
+	}
+
+	public void ASTNode.dumpTree(PrintStream out, String indent) {
+		out.print(indent + getClass().getSimpleName());
+		out.println(getTokens());
+		String childIndent = indent + DUMP_TREE_INDENT;
+		for (ASTNode child : astChildren()) {
+			if (child == null) {
+				out.println(childIndent + "null");
+			} else {
+				child.dumpTree(out, childIndent);
+			}
+		}
+	}
+
+	public String ASTNode.getTokens() {
+		java.util.TreeSet<java.lang.reflect.Method> methods = new java.util.TreeSet<>(
+				new java.util.Comparator<java.lang.reflect.Method>() {
+					public int compare(java.lang.reflect.Method m1, java.lang.reflect.Method m2) {
+						return m1.getName().compareTo(m2.getName());
+					}
+				});
+
+		methods.addAll(java.util.Arrays.asList(getClass().getMethods()));
+
+		String result = "";
+		for (java.lang.reflect.Method method : methods) {
+			ASTNodeAnnotation.Token token = method.getAnnotation(ASTNodeAnnotation.Token.class);
+			if (token != null) {
+				try {
+					result += String.format(" %s=\"%s\"", token.name(), method.invoke(this));
+				} catch (IllegalAccessException ignored) {
+				} catch (InvocationTargetException ignored) {
+				}
+			}
+		}
+		return result;
+	}
+}
\ No newline at end of file

spec/jastadd/Errors.jrag

+import java.util.Set;
+import java.util.TreeSet;
+import java.util.LinkedList;
+
+aspect Errors {
+//	coll Set<ErrorMessage> Program.errors()
+//		[new TreeSet<ErrorMessage>()]
+//		root Program;
+}
+
+aspect HelpAttributes {
+//	inh Program ASTNode.program();
+//	eq Program.getChild().program() = this;
+}
+
+aspect ErrorMessage {
+	public class ErrorMessage implements Comparable<ErrorMessage> {
+		private final ASTNode node;
+		private final int line;
+		private final int col;
+		private final String message;
+		
+		public ErrorMessage(ASTNode node, String message) {
+			this.node = node;
+			this.line = node.getStartLine();
+			this.col = node.getStartColumn();
+			this.message = message;
+		}
+		
+		public ASTNode getNode() {
+			return node;
+		}
+		public int getLine() {
+			return line;
+		}
+		public int getCol() {
+			return col;
+		}
+		public String getMessage() {
+			return message;
+		}
+		
+		public String toString() {
+			return "Line " + line + ", column " + col + ": " + message;
+		}
+
+		@Override
+		public int compareTo(ErrorMessage err) {
+			int n = line - err.line;
+			if (n != 0) {
+				return n;
+			}
+			
+			n = col-err.col;
+			if (n != 0) {
+				return n;
+			}
+			
+			return message.compareTo(err.message);
+		}
+	}
+	
+	protected ErrorMessage ASTNode.error(String message) {
+		return new ErrorMessage(this, message);
+	}
+}
\ No newline at end of file

spec/jastadd/RelAst.ast

+Program ::= TypeDecl* Relation*;
+TypeDecl ::= <ID> <Abstract:boolean> [Super:TypeUse] Component*;
+
+abstract Component ::= <ID> TypeUse;
+NormalComponent : Component;
+ListComponent : Component;
+TokenComponent : Component;
+OptComponent : Component;
+
+TypeUse ::= <ID>;
+
+Relation ::= Left:RelationSide Direction Right:RelationSide;
+abstract RelationSide ::= TypeUse <ID>;
+OneRelationSide : RelationSide;
+OptionalRelationSide : RelationSide;
+ManyRelationSide : RelationSide;
+
+
+abstract Direction;
+RightDirection : Direction;
+Bidirectional : Direction;
\ No newline at end of file

spec/parser/Preamble.parser

+%header {:
+	package org.jastadd.relast.ast;
+:};
+
+%goal goal;
\ No newline at end of file

spec/parser/RelAstBase.parser

+Program goal = 
+	type_decls.t relations.r {: return new Program(t, r); :}
+	| STRING_LITERAL STAR {: return new Program(); :}
+	;
+
+List type_decls =
+	/* empty */ {: return new List(); :}
+	| type_decls.l type_decl.d {: return l.add(d); :}
+	;
+
+TypeDecl type_decl =
+	ID type_decl_super.s components_opt.c SCOL 
+	{: return new TypeDecl(ID, false, s, c); :}
+	| ABSTRACT ID type_decl_super.s components_opt.c SCOL 
+	{: return new TypeDecl(ID, true, s, c); :}
+	;
+
+Opt type_decl_super =
+	/* empty */ {: return new Opt(); :}
+	| COL type_use.u {: return new Opt(u); :}
+	;
+
+TypeUse type_use =
+	ID {: return new TypeUse(ID); :}
+	;
+
+List components_opt =
+	/* empty */ {: return new List(); :}
+	| ASSIGN components.l {: return l; :}
+	;
+
+List components =
+	{: return new List(); :}
+	| components.l component.c {: return l.add(c); :}
+	;
+
+Component component =
+	ID COL type_use.u {: return new NormalComponent(ID, u); :}
+	| type_use.u {: return new NormalComponent(u.getID(), u); :}
+	// List
+	| ID COL type_use.u STAR {: return new ListComponent(ID, u); :}
+	| type_use.u STAR {: return new ListComponent(u.getID(), u); :}
+	// Opt
+	| LBRACKET ID COL type_use.u RBRACKET {: return new OptComponent(ID, u); :}
+	| LBRACKET type_use.u RBRACKET {: return new OptComponent(u.getID(), u); :}
+	// Token
+	| LT ID COL type_use.u GT {: return new TokenComponent(ID, u); :}
+	| LT ID GT {: return new TokenComponent(ID, new TypeUse("String")); :}
+	;
+
+List relations =
+	/* empty */ {: return new List(); :}
+	| relations.l relation.r {: return l.add(r); :}
+	;
+
+Relation relation =
+	RELATION relation_side.l direction relation_side.r SCOL 
+	{: return new Relation(l, direction, r); :}
+	;
+
+RelationSide relation_side =
+	// One
+	type_use.u DOT ID {: return new OneRelationSide(u, ID); :}
+	| type_use.u {: return new OneRelationSide(u, ""); :}
+	// Optional
+	| LBRACKET type_use.u DOT ID RBRACKET {: return new OptionalRelationSide(u, ID); :}
+	| LBRACKET type_use.u RBRACKET {: return new OptionalRelationSide(u, ""); :}
+	// Many
+	| type_use.u STAR DOT ID {: return new ManyRelationSide(u, ID); :}
+	| type_use.u STAR {: return new ManyRelationSide(u, ""); :}
+	;
+
+Direction direction =
+	RIGHT {: return new RightDirection(); :}
+	| BIDIRECTIONAL {: return new Bidirectional(); :}
+	;
\ No newline at end of file

spec/scanner/RelAst.flex

+package org.jastadd.relast.ast;
+
+import org.jastadd.relast.ast.RelAstParser.Terminals;
+
+%%
+
+%public
+%final
+%class RelAstScanner
+%extends beaver.Scanner
+
+%type beaver.Symbol 
+%function nextToken 
+%yylexthrow beaver.Scanner.Exception
+%scanerror RelAstScanner.ScannerError
+
+%line
+%column
+%{
+  private StringBuilder stringLitSb = new StringBuilder();
+  
+  private beaver.Symbol sym(short id) {
+    return new beaver.Symbol(id, yyline + 1, yycolumn + 1, yylength(), yytext());
+  }
+
+  private beaver.Symbol sym(short id, String text) {
+    return new beaver.Symbol(id, yyline + 1, yycolumn + 1, yylength(), text);
+  }
+
+  
+  public static class ScannerError extends Error {
+  	public ScannerError(String message) {
+  		super(message);
+  	}
+  } 
+%}
+
+WhiteSpace = [ ] | \t | \f | \n | \r | \r\n
+TraditionalComment   = "/*" [^*] ~"*/" | "/*" "*"+ "/"
+EndOfLineComment = "//" [^\n|\r|\r\n]*
+Comment = {TraditionalComment} | {EndOfLineComment}
+
+ID = [a-zA-Z$][a-zA-Z0-9$_]*
+FLOAT  = -?[0-9]+ \. [0-9]+ {Exponent}?
+Exponent = [eE] [+-]? [0-9]+
+NUM = -?[0-9]+
+
+%state STRING
+
+%%
+<YYINITIAL> {
+	{WhiteSpace} 	{ /* ignore */ }
+	{Comment}		{ /* ignore */ }
+
+	"abstract"		{ return sym(Terminals.ABSTRACT); }
+	"rel"			{ return sym(Terminals.RELATION); }
+
+	";"				{ return sym(Terminals.SCOL); }
+	":"				{ return sym(Terminals.COL); }
+	"::="			{ return sym(Terminals.ASSIGN); }
+	"*"				{ return sym(Terminals.STAR); }
+	"."				{ return sym(Terminals.DOT); }
+	"<"				{ return sym(Terminals.LT); }
+	">"				{ return sym(Terminals.GT); }
+	"["				{ return sym(Terminals.LBRACKET); }
+	"]"				{ return sym(Terminals.RBRACKET); }
+	"->"			{ return sym(Terminals.RIGHT); }
+	"<->"			{ return sym(Terminals.BIDIRECTIONAL); }
+
+	// ID
+	{ID}			{ return sym(Terminals.ID); }
+	\"				{ stringLitSb.setLength(0); yybegin(STRING); }
+	<<EOF>> 		{ return sym(Terminals.EOF); }
+}
+
+<STRING> {
+	\"				{ yybegin(YYINITIAL); return sym(Terminals.STRING_LITERAL, stringLitSb.toString()); }
+	[^\n\r\"\\]+	{ stringLitSb.append( yytext() ); }
+	\\t				{ stringLitSb.append('\t'); }
+	\\n				{ stringLitSb.append('\n'); }
+	\\r				{ stringLitSb.append('\r'); }
+	\\\"			{ stringLitSb.append('\"'); }
+	\\				{ stringLitSb.append('\\'); }
+}
+
+
+[^]				{ throw new ScannerError((yyline+1) +"," + (yycolumn+1) + ": Illegal character <"+yytext()+">"); }

src/java/org/jastadd/relast/compiler/Compiler.java

+package org.jastadd.relast.compiler;
+import org.jastadd.relast.ast.*;
+
+
+import static org.jastadd.relast.compiler.Utils.filterToList;
+
+import java.io.*;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.regex.Pattern;
+import org.jastadd.relast.compiler.options.CommandLine;
+import org.jastadd.relast.compiler.options.EnumOption;
+import org.jastadd.relast.compiler.options.FlagOption;
+import org.jastadd.relast.compiler.options.Option;
+import org.jastadd.relast.compiler.options.StringOption;
+import org.jastadd.relast.compiler.options.CommandLine.CommandLineException;
+
+import beaver.Parser;
+
+public class Compiler {
+	protected ArrayList<Option<?>> options;
+	protected FlagOption optionPrintDot;
+	protected FlagOption optionFlatPrettyPrint;
+	protected CommandLine commandLine;
+
+	public Compiler(String args[]) throws CommandLineException {
+		options = new ArrayList<>();
+		addOptions();
+
+		commandLine = new CommandLine(options);
+		commandLine.parse(args);
+
+		Program p = parseProgram(commandLine.getArguments().get(0));
+
+		System.out.println(p.dumpTree());
+		/*if (!p.errors().isEmpty()) {
+			System.err.println("Errors:");
+			for (ErrorMessage e: p.errors()) {
+				System.err.println(e);
+			}
+			System.exit(1);
+		} else {
+			if (optionPrintDot.isSet()) {
+				System.out.println(p.genDot());
+			} else if (optionFlatPrettyPrint.isSet()) {
+				System.out.println(p.flatPrettyPrint());
+			} else {
+				System.out.println("# AST");
+				System.out.println(p.dumpTree());
+
+				FlatState s = p.stoppingState();
+				for (FlatDependency d: s.getDependencyList()) {
+					System.out.println(d.sourceDecl());
+					System.out.println(d.sourceDecl().getAccess() + " " + d.targetDecl().getAccess());
+				}
+				for (Node n: s.getNodes()) {
+					System.out.println(n + ", succ: " + n.succ());
+				}
+				System.out.println(s.startingNodes());
+				System.out.println(s.endingNodes());
+				System.out.println("# Transitive reduction");
+				System.out.println(p.startingState().transitiveReduction());
+			}
+		}*/
+	}
+
+
+	protected void addOptions() {
+		optionPrintDot = addOption(new FlagOption("dot", "print DOT format"));
+		optionFlatPrettyPrint = addOption(new FlagOption("flat", "flat pretty print"));
+	}
+
+	protected <OptionType extends Option<?>> OptionType addOption(OptionType option) {
+		options.add(option);
+		return option;
+	}
+
+	private Program parseProgram(String file) {
+		FileReader reader = null;
+		try {
+			reader = new FileReader(file);
+		} catch (FileNotFoundException e) {
+			System.err.println(e.getMessage());
+			System.exit(1);
+		}
+		return parse(reader, file);
+	}
+
+	private Program parse(Reader reader, String file) {
+		RelAstScanner scanner = new RelAstScanner(reader);
+		RelAstParser parser = new RelAstParser();
+
+		try {
+			return (Program) parser.parse(scanner);
+		} catch (IOException e) {
+			System.err.println(e.getMessage());
+			System.exit(1);
+		} catch (Parser.Exception e) {
+			System.err.println("Parse error in file " + file);
+			System.err.println(e.getMessage());
+			System.exit(1);
+		} /*catch (ScannerError e) {
+			System.err.println("Scanner error in file " + file);
+			System.err.println(e.getMessage());
+			System.exit(1);
+		}*/
+		return null;
+	}
+
+	private void showUsageAndExit() {
+		//System.out.println("Usage: java -jar bloqqi-compiler.jar [--option1] [--option2=value] ...  <filename1> [filename2] [filename3] ...");
+		//System.exit(1);
+	}
+
+	public static void main(String[] args) {
+		try {
+			new Compiler(args);
+		} catch (CommandLineException e) {
+			System.out.println(e.getMessage());
+			System.exit(1);
+		}
+	}
+}
+

src/java/org/jastadd/relast/compiler/Utils.java

+package org.jastadd.relast.compiler;
+
+import static java.util.stream.Collectors.toList;
+
+import java.util.*;
+import java.util.function.Predicate;
+
+public class Utils {
+	public static <T> List<T> filterToList(Collection<T> collection, Predicate<T> predicate) {
+		return collection.stream().filter(predicate).collect(toList());
+	}
+
+	public static <T> Set<T> asSet(T... t) {
+		return new HashSet<T>(Arrays.asList(t));
+	}
+}

src/java/org/jastadd/relast/compiler/options/CommandLine.java

+package org.jastadd.relast.compiler.options;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.TreeSet;
+
+public class CommandLine {
+	private final Collection<Option<?>> options;
+	private final Map<String, Option<?>> mapping;
+	private final List<String> arguments;
+	
+	public CommandLine(Collection<Option<?>> options) {
+		this.options = options;
+		this.mapping = new HashMap<>();
+		for (Option<?> option: options) {
+			mapping.put(option.getName(), option);
+		}
+		this.arguments = new ArrayList<>();
+	}
+	
+	public void parse(String args[]) throws CommandLineException {
+		int i = 0;
+		while (i < args.length) {
+			if (args[i].startsWith(Option.PREFIX)) {
+				int argumentIndex = args[i].indexOf("=");
+				String name;
+				String argument = null;
+				if (argumentIndex > 0) {
+					name = args[i].substring(2, argumentIndex);
+					argument = args[i].substring(argumentIndex+1);
+				} else {
+					name = args[i].substring(2);
+				}
+				Option<?> option = mapping.get(name);
+				if (option == null) {
+					throw new CommandLineException("Option " + Option.PREFIX + name + " not found");
+				}
+				match(option, argument);
+			} else {
+				arguments.add(args[i]);
+			}
+			i++;
+		}
+	}
+
+	public void match(Option<?> option, String argument) throws CommandLineException {
+		try {
+			switch (option.hasArgument()) {
+			case NO:
+				if (argument == null) {
+					option.match(null);
+				} else {
+					throw new CommandLineException("Option " + option + " is not allowed to have an argument");
+				}
+				break;
+			case OPTIONAL:
+				option.match(argument);
+				break;
+			case YES:
+				if (argument != null) {
+					option.match(argument);
+				} else {
+					throw new CommandLineException("Option " + option + " requires an argument");
+				}
+				break;
+			}
+		} catch (Option.IllegalMatchException e) {
+			throw new CommandLineException("Invalid value for option " + option + ": " + e.getMessage());
+		}
+	}
+	
+	public List<String> getArguments() {
+		return arguments;
+	}
+	
+	public String printOptionHelp() {
+		StringBuilder sb = new StringBuilder();
+		int longestOption = 0;
+		for (Option<?> option: options) {
+			if (longestOption < option.getName().length()) {
+				longestOption = option.getName().length();
+			}
+		}
+		for (Option<?> option: new TreeSet<>(options)) {
+			String s = String.format("  %s%-" + (longestOption+6) + "s %s%n", 
+					Option.PREFIX, option.getName(), option.getDescription());
+			sb.append(s);
+		}
+		return sb.toString();
+	}
+	
+	public static class CommandLineException extends Exception {
+		private static final long serialVersionUID = 1L;
+		public CommandLineException(String message) {
+			super(message);
+		}
+	}
+}

src/java/org/jastadd/relast/compiler/options/EnumOption.java

+package org.jastadd.relast.compiler.options;
+
+import java.util.Collection;
+import java.util.TreeSet;
+
+public class EnumOption extends Option<String> {
+	private final TreeSet<String> allowedValues;
+	private final String defaultValue;
+	private String value;
+	private boolean isSet;
+
+	public EnumOption(String name, String description, Collection<String> allowedValues, String defaultValue) {
+		super(name, description);
+		this.allowedValues = new TreeSet<>(allowedValues);
+		this.defaultValue = defaultValue;
+		this.value = defaultValue;
+		this.isSet = false;
+	}
+
+	public boolean addAllowedValue(String allowedValue) {
+		return allowedValues.add(allowedValue);
+	}
+
+	@Override
+	public String getValue() {
+		return value;
+	}
+
+	@Override
+	public Option.HasArgument hasArgument() {
+		return Option.HasArgument.OPTIONAL;
+	}
+	
+	@Override
+	public void match(String argument) throws IllegalMatchException {
+		if (argument == null) {
+			isSet = true;
+			value = defaultValue;
+		} else if (allowedValues.contains(argument)) {
+			isSet = true;
+			value = argument;
+		} else {
+			throw new IllegalMatchException(argument 
+					+ " is not allowed, allowed values are " + allowedValues);
+		}
+	}
+	
+	@Override
+	public boolean isSet() {
+		return isSet;
+	}
+
+	@Override
+	public String getDescription() {
+		String allowedValuesStr = allowedValues.toString();
+		allowedValuesStr = allowedValuesStr.substring(1);
+		allowedValuesStr = allowedValuesStr.substring(0, allowedValuesStr.length()-1);
+		return super.getDescription() + " (allowed values: " + allowedValuesStr + ")";
+	}
+}

src/java/org/jastadd/relast/compiler/options/FlagOption.java

+package org.jastadd.relast.compiler.options;
+
+public class FlagOption extends Option<Boolean> {
+	private boolean value;
+	
+	public FlagOption(String name, String description) {
+		super(name, description);
+		value = false;
+	}
+
+	@Override
+	public Boolean getValue() {
+		return value;
+	}
+
+	@Override
+	public Option.HasArgument hasArgument() {
+		return Option.HasArgument.NO;
+	}
+	
+	@Override
+	public void match(String string) throws IllegalMatchException {
+		value = true;
+	}
+
+	@Override
+	public boolean isSet() {
+		return getValue();
+	}
+}

src/java/org/jastadd/relast/compiler/options/Option.java

+package org.jastadd.relast.compiler.options;
+
+abstract public class Option<ValueType> implements Comparable<Option<?>> {
+	public final static String PREFIX = "--";
+	public static enum HasArgument {
+		NO,
+		OPTIONAL,
+		YES
+	}
+	
+	private final String name;
+	private final String description;
+	
+	public Option(String name, String description) {
+		this.name = name;
+		this.description = description;
+	}
+	
+	public String getName() {
+		return name;
+	}
+	
+	public String getDescription() {
+		return description;
+	}
+	
+	@Override
+	public int compareTo(Option<?> o) {
+		return name.compareTo(o.name);
+	}
+	
+	@Override
+	public boolean equals(Object other) {
+		if (other instanceof Option) {
+			return compareTo((Option<?>) other) == 0;
+		}
+		return false;
+	}
+	
+	@Override
+	public String toString() {
+		return PREFIX + name;
+	}
+
+	abstract public boolean isSet();
+	abstract public ValueType getValue();
+	abstract public HasArgument hasArgument();
+	abstract public void match(String input) throws IllegalMatchException;
+	
+	public static class IllegalMatchException extends Exception {
+		private static final long serialVersionUID = 1L;
+		public IllegalMatchException(String message) {
+			super(message);
+		}
+	}
+}

src/java/org/jastadd/relast/compiler/options/StringOption.java

+package org.jastadd.relast.compiler.options;
+
+public class StringOption extends Option<String> {
+	private String value;
+	private boolean isSet;
+	
+	public StringOption(String name, String description) {
+		this(name, description, "");
+	}
+	
+	public StringOption(String name, String description, String defaultValue) {
+		super(name, description);
+		value = defaultValue;
+		isSet = false;
+	}
+
+	@Override
+	public String getValue() {
+		return value;
+	}
+	
+	@Override
+	public Option.HasArgument hasArgument() {
+		return Option.HasArgument.YES;
+	}
+	
+	@Override
+	public void match(String value) throws IllegalMatchException {
+		this.value = value;
+		isSet = true;
+	}
+
+	@Override
+	public boolean isSet() {
+		return isSet;
+	}
+}

src/java/org/jastadd/relast/tests/AnalysisTests.java

+package org.jastadd.relast.tests;
+
+import org.junit.Test;
+import java.util.Iterator;
+
+import static org.junit.Assert.*;
+import static org.jastadd.relast.compiler.Utils.asSet;
+
+import org.jastadd.relast.ast.*;
+import org.jastadd.relast.tests.testsuite.TestSuite;
+
+public class AnalysisTests extends TestSuite {
+
+}

src/java/org/jastadd/relast/tests/testsuite/TestSuite.java

+package org.jastadd.relast.tests.testsuite;
+
+import static org.junit.Assert.*;
+
+import java.io.BufferedReader;
+import java.io.BufferedWriter;
+import java.io.ByteArrayOutputStream;
+import java.io.File;
+import java.io.FileNotFoundException;
+import java.io.FileOutputStream;
+import java.io.FileReader;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.io.OutputStreamWriter;
+import java.io.PrintStream;
+import java.io.Reader;
+import java.io.StringReader;
+import java.io.Writer;
+import java.util.concurrent.TimeUnit;
+
+import org.jastadd.relast.ast.*;
+
+abstract public class TestSuite {
+//	protected static final String TEST_FILES_PATH = "testfiles/";
+//	protected static final int DEFAULT_EXECUTION_TIMEOUT = 3000; // In ms
+//
+//	/**
+//	 * Parse a program and return the corresponding AST.
+//	 * The test will fail if the program contains semantic errors.
+//	 */
+//	protected static Program parseValidProgram(String program) {
+//		Program p = parseProgram(program);
+//		assertEquals("Program contains errors", "", getErrors(p));
+//		return p;
+//	}
+//	
+//	/**
+//	 * Parse a program given a filename and return the corresponding AST.
+//	 * The test will fail if the program contains semantic errors.
+//	 */
+//	protected static Program parseValidProgramFile(String filename) {
+//		return parseValidProgramFile(new File(TEST_FILES_PATH, filename));
+//	}
+//
+//	/**
+//	 * Parse a program given a file object and return the corresponding AST.
+//	 * The test will fail if the program contains semantic errors.
+//	 */
+//	protected static Program parseValidProgramFile(File file) {
+//		Program p = parseProgramFile(file);
+//		assertEquals("Program in file " + file.getAbsolutePath() + " contains errors", "", getErrors(p));
+//		return p;
+//	}
+//
+//	
+//	/**
+//	 * Parse a program given a filename and compare the errors
+//	 * with expected errors that are read from an error file. 
+//	 */
+//	protected static void checkErrors(String filename) {
+//		Program p = parseProgramFile(filename + ".dia");
+//		String expectedErrors = readTestFile(filename + ".err");
+//		String actualErrors = getErrors(p);
+//		assertEquals(expectedErrors.trim(), actualErrors.trim());
+//	}
+//	
+//	protected static void checkSyntaxErrors(String filename) {
+//		String actualSyntaxError = "";
+//		try {
+//			parseProgramFile(filename + ".dia");
+//		} catch (StateScanner.ScannerError e) {
+//			actualSyntaxError = e.getMessage();
+//		}
+//		String expectedSyntaxError = readTestFile(filename + ".err");
+//		assertEquals(expectedSyntaxError.trim(), actualSyntaxError.trim());
+//	}
+//	
+//	/**
+//	 * Parse a program given a filename and return the corresponding AST.
+//	 */
+//	protected static Program parseProgramFile(String filename) {
+//		return parseProgramFile(new File(TEST_FILES_PATH, filename));
+//	}
+//	
+//	/**
+//	 * Parse a program given a filename and return the corresponding AST.
+//	 */
+//	protected static Program parseProgramFile(File file) {
+//		try {
+//			Reader r = new FileReader(file);
+//			return parseProgram(r, "Error when parsing the file " + file.getAbsolutePath());
+//		} catch (FileNotFoundException e) {
+//			fail(e.getMessage());
+//			return null;
+//		}
+//	}
+//
+//	
+//	/**
+//	 * Parse a program and return the corresponding AST. 
+//	 */
+//	protected static Program parseProgram(String program) {
+//		Reader r = new StringReader(program);
+//		return parseProgram(r, "Error when parsing string " + program);
+//	}
+//
+//	/**
+//	 * Parse a program and return the corresponding AST.
+//	 */
+//	protected static Program parseProgram(Reader reader, String errorMessage) {
+//		PrintStream err = System.err;
+//		ByteArrayOutputStream os = new ByteArrayOutputStream();
+//		PrintStream ps = new PrintStream(os);
+//
+//		try {
+//			System.setErr(ps);
+//
+//			CompilationUnit cu = parse(reader);
+//			if (os.size() > 0) {
+//				// The parser should not recover from anything, such errors
+//				// should not be put in a test case (otherwise it should be
+//				// stated explicitly).
+//				fail("Parser recovery:\n" + os.toString());
+//			}
+//			Program p = new Program();
+//			p.addCompilationUnit(cu);
+//			return p;
+//		} catch (Exception e) {
+//			fail(errorMessage + ":\n " + e.getMessage() + "\n" + os.toString());
+//			return null; // This line is required to remove compile errors...
+//		} finally {
+//			System.setErr(err);
+//		}
+//	}
+//	
+//	protected static String getErrors(Program p) {
+//		StringBuilder sb = new StringBuilder();
+//		for (CompilationUnit cu: p.getCompilationUnits()) {
+//			/*for (ErrorMessage e: cu.errors()) {
+//				sb.append(e + "\n");
+//			}*/
+//		}
+//		return sb.toString();
+//	}
+//	
+//	//-----------------------------------------------------------
+//	//
+//	// Helper methods
+//	//
+//	//-----------------------------------------------------------
+//
+//	protected static String readTestFile(String filename) {
+//		return readFile(TEST_FILES_PATH + filename);
+//	}
+//	protected static String readFile(String filename) {
+//		StringBuilder sb = new StringBuilder();
+//		BufferedReader br = null;
+//		try {
+//			File file = new File(filename);
+//			br = new BufferedReader(new FileReader(file));
+//			String line;
+//			while ((line = br.readLine()) != null) {
+//			  sb.append(line).append("\n");
+//			}
+//		} catch (IOException e) {
+//			fail(e.getMessage());
+//		} finally {
+//			if (br != null) {
+//				{ try { br.close();} catch (IOException ignored) { } }
+//			}
+//		}
+//		return sb.toString();
+//	}
+//	
+//	protected static void writeToFile(String filename, String content) {
+//		try (Writer writer = new BufferedWriter(new OutputStreamWriter(
+//				new FileOutputStream(filename), "utf-8"))) {
+//			writer.write(content);
+//		} catch (Exception e) {
+//			fail(e.getMessage());
+//		}
+//	}
+//	
+//	protected static String execute(java.util.List<String> cmd) throws IOException, InterruptedException {
+//		return execute(cmd, DEFAULT_EXECUTION_TIMEOUT);
+//	}
+//	protected static String execute(java.util.List<String> cmd, int timeoutMillis) throws IOException, InterruptedException {
+//		ProcessBuilder pb = new ProcessBuilder(cmd);
+//		Process process = pb.start();
+//		process.getOutputStream().close();
+//		
+//		if (!process.waitFor(timeoutMillis, TimeUnit.MILLISECONDS)) {
+//			process.destroy();
+//			fail("Command " + cmd + " could not complete within " + timeoutMillis + " ms");
+//		}
+//
+//		String standardError = inputStreamToString(process.getErrorStream());
+//		assertEquals("Standard error was not empty", "", standardError);
+//		assertEquals("Exit code was not zero => error occured", 0, process.exitValue());
+//
+//		return inputStreamToString(process.getInputStream());
+//	}
+//	
+//	protected static String inputStreamToString(InputStream is) {
+//		StringBuilder sb = new StringBuilder();
+//		try {
+//			BufferedReader br = new BufferedReader(new InputStreamReader(is));
+//			String line;
+//			while ((line = br.readLine()) != null) {
+//				sb.append(line).append("\n");
+//			}
+//		} catch (IOException e) {
+//			throw new RuntimeException(e.getMessage());
+//		}
+//		return sb.toString();
+//	}
+//	
+//	private static CompilationUnit parse(Reader reader) throws IOException,
+//			beaver.Parser.Exception {
+//		StateScanner scanner = new StateScanner(reader);
+//		StateParser parser = new StateParser();
+//		return (CompilationUnit) parser.parse(scanner);
+//	}
+//	
+}