Adds support of nullable sequences.

Author: arnoldlankamp

src/org/rascalmpl/parser/gtd/SGTDBF.java

@@ -1301,7 +1301,7 @@ else if (!stack.isExpandable()) { // A 'normal' non-terminal.
 					expanded = true;
 				}
 
-				if(stack.canBeEmpty()){ // Star list or optional.
+				if(stack.canBeEmpty()){ // Star list, optional or empty sequence.
 					AbstractStackNode<P> empty =
 						stack.getEmptyChild().getCleanCopyWithResult(location, EpsilonStackNode.EPSILON_RESULT);
 					empty.initEdges();

src/org/rascalmpl/parser/gtd/stack/SequenceStackNode.java

@@ -20,6 +20,7 @@ public class SequenceStackNode<P> extends AbstractExpandableStackNode<P>{
 	private final String name;
 
 	private final AbstractStackNode<P>[] children;
+	private final AbstractStackNode<P> emptyChild;
 
 	public SequenceStackNode(int id, int dot, P production, AbstractStackNode<P>[] children){
 		super(id, dot);
@@ -28,6 +29,7 @@ public SequenceStackNode(int id, int dot, P production, AbstractStackNode<P>[] c
 		this.name = String.valueOf(id);
 
 		this.children = generateChildren(children);
+		this.emptyChild = children.length == 0 ? generateEmptyChild() : null;
 	}
 
 	public SequenceStackNode(int id, int dot, P production, AbstractStackNode<P>[] children, IEnterFilter[] enterFilters, ICompletionFilter[] completionFilters){
@@ -37,6 +39,7 @@ public SequenceStackNode(int id, int dot, P production, AbstractStackNode<P>[] c
 		this.name = String.valueOf(id);
 
 		this.children = generateChildren(children);
+		this.emptyChild = children.length == 0 ? generateEmptyChild() : null;
 	}
 
 	private SequenceStackNode(SequenceStackNode<P> original, int startLocation){
@@ -46,13 +49,18 @@ private SequenceStackNode(SequenceStackNode<P> original, int startLocation){
 		name = original.name;
 
 		children = original.children;
+		this.emptyChild = original.emptyChild;
 	}
 
 	/**
 	 * Generates and initializes the alternatives for this sequence.
 	 */
 	@SuppressWarnings("unchecked")
 	private AbstractStackNode<P>[] generateChildren(AbstractStackNode<P>[] children){
+		if(children.length == 0){
+			return new AbstractStackNode[]{};
+		}
+
 		AbstractStackNode<P>[] prod = (AbstractStackNode<P>[]) new AbstractStackNode[children.length];
 
 		for(int i = children.length - 1; i >= 0; --i){
@@ -65,6 +73,16 @@ private AbstractStackNode<P>[] generateChildren(AbstractStackNode<P>[] children)
 
 		return (AbstractStackNode<P>[]) new AbstractStackNode[]{prod[0]};
 	}
+
+	/**
+	 * Generates and initializes the empty child for usage in empty sequences.
+	 */
+	@SuppressWarnings("unchecked")
+	private AbstractStackNode<P> generateEmptyChild(){
+		AbstractStackNode<P> empty = (AbstractStackNode<P>) EMPTY.getCleanCopy(DEFAULT_START_LOCATION);
+		empty.setAlternativeProduction(production);
+		return empty;
+	}
 
 	public String getName(){
 		return name;
@@ -79,11 +97,14 @@ public AbstractStackNode<P>[] getChildren(){
 	}
 
 	public boolean canBeEmpty(){
-		return false;
+		return children.length == 0;
 	}
 
 	public AbstractStackNode<P> getEmptyChild(){
-		throw new UnsupportedOperationException();
+		if(children.length > 0) {
+			throw new UnsupportedOperationException();
+		}
+		return emptyChild;
 	}
 
 	@Override

test/org/rascalmpl/test/parser/Sequence4.java

@@ -0,0 +1,67 @@
+package org.rascalmpl.test.parser;
+
+import java.io.IOException;
+import java.io.StringReader;
+
+import org.rascalmpl.parser.gtd.SGTDBF;
+import org.rascalmpl.parser.gtd.result.out.DefaultNodeFlattener;
+import org.rascalmpl.parser.gtd.stack.AbstractStackNode;
+import org.rascalmpl.parser.gtd.stack.LiteralStackNode;
+import org.rascalmpl.parser.gtd.stack.NonTerminalStackNode;
+import org.rascalmpl.parser.gtd.stack.SequenceStackNode;
+import org.rascalmpl.parser.uptr.UPTRNodeFactory;
+import io.usethesource.vallang.IConstructor;
+import io.usethesource.vallang.ISourceLocation;
+import io.usethesource.vallang.IValue;
+import io.usethesource.vallang.io.StandardTextReader;
+
+import org.rascalmpl.values.RascalFunctionValueFactory;
+import org.rascalmpl.values.RascalValueFactory;
+import org.rascalmpl.values.ValueFactoryFactory;
+import org.rascalmpl.values.parsetrees.ITree;
+/*
+S ::= (A () B)
+A ::= a
+B ::= b
+*/
+@SuppressWarnings({"unchecked", "cast"})
+public class Sequence4 extends SGTDBF<IConstructor, ITree, ISourceLocation> implements IParserTest{
+	private final static IConstructor SYMBOL_START_S = VF.constructor(RascalValueFactory.Symbol_Sort, VF.string("S"));
+	private final static IConstructor SYMBOL_SEQ = VF.constructor(RascalValueFactory.Symbol_Seq, VF.list());
+	
+	private final static IConstructor PROD_S_SEQ_AB = VF.constructor(RascalValueFactory.Production_Default,  SYMBOL_START_S, VF.list(SYMBOL_SEQ), VF.set());
+	private final static IConstructor PROD_SEQUENCE = VF.constructor(RascalValueFactory.Production_Default,  SYMBOL_SEQ, VF.list(), VF.set());
+	
+	private final static AbstractStackNode<IConstructor> NONTERMINAL_START_S = new NonTerminalStackNode<IConstructor>(AbstractStackNode.START_SYMBOL_ID, 0, "S");
+	private final static AbstractStackNode<IConstructor> SEQUENCE4 = new SequenceStackNode<IConstructor>(3, 0, PROD_SEQUENCE, new AbstractStackNode[]{});
+	
+	private final static AbstractStackNode<IConstructor>[] S_EXPECT_1 = (AbstractStackNode<IConstructor>[]) new AbstractStackNode[1];
+	static{
+		S_EXPECT_1[0] = SEQUENCE4;
+		S_EXPECT_1[0].setProduction(S_EXPECT_1);
+		S_EXPECT_1[0].setAlternativeProduction(PROD_S_SEQ_AB);
+	}
+	
+	public Sequence4(){
+		super();
+	}
+	
+	public AbstractStackNode<IConstructor>[] S(){
+		return (AbstractStackNode<IConstructor>[]) new AbstractStackNode[]{S_EXPECT_1[0]};
+	}
+	
+	public ITree executeParser(){
+		return parse(NONTERMINAL_START_S, null, "".toCharArray(), new DefaultNodeFlattener<IConstructor, ITree, ISourceLocation>(), new UPTRNodeFactory(true));
+	}
+	
+	public IValue getExpectedResult() throws IOException{
+		String expectedInput = "appl(prod(sort(\"S\"),[seq([])],{}),[appl(prod(seq([]),[],{}),[])])";
+		return new StandardTextReader().read(ValueFactoryFactory.getValueFactory(), RascalValueFactory.uptr, RascalValueFactory.Tree, new StringReader(expectedInput));
+	}
+
+	public static void main(String[] args){
+		Sequence4 s4 = new Sequence4();
+		IConstructor result = s4.executeParser();
+		System.out.println(result);
+	}
+}