Adds support of nullable alternatives.

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, optional or empty sequence.
+				if(stack.canBeEmpty()){ // Star list, optional or empty sequence / alternative.
 					AbstractStackNode<P> empty =
 						stack.getEmptyChild().getCleanCopyWithResult(location, EpsilonStackNode.EPSILON_RESULT);
 					empty.initEdges();

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

@@ -20,6 +20,7 @@ public class AlternativeStackNode<P> extends AbstractExpandableStackNode<P>{
 	private final String name;
 
 	private final AbstractStackNode<P>[] children;
+	private final AbstractStackNode<P> emptyChild;
 
 	public AlternativeStackNode(int id, int dot, P production, AbstractStackNode<P>[] alternatives){
 		super(id, dot);
@@ -28,6 +29,7 @@ public AlternativeStackNode(int id, int dot, P production, AbstractStackNode<P>[
 		this.name = String.valueOf(id);
 
 		this.children = generateAlternatives(alternatives);
+		this.emptyChild = children.length == 0 ? generateEmptyChild() : null;
 	}
 
 	public AlternativeStackNode(int id, int dot, P production, AbstractStackNode<P>[] alternatives, IEnterFilter[] enterFilters, ICompletionFilter[] completionFilters){
@@ -37,6 +39,7 @@ public AlternativeStackNode(int id, int dot, P production, AbstractStackNode<P>[
 		this.name = String.valueOf(id);
 
 		this.children = generateAlternatives(alternatives);
+		this.emptyChild = children.length == 0 ? generateEmptyChild() : null;
 	}
 
 	private AlternativeStackNode(AlternativeStackNode<P> original, int startLocation){
@@ -46,6 +49,7 @@ private AlternativeStackNode(AlternativeStackNode<P> original, int startLocation
 		name = original.name;
 
 		children = original.children;
+		this.emptyChild = original.emptyChild;
 	}
 
 	/**
@@ -67,6 +71,16 @@ private AbstractStackNode<P>[] generateAlternatives(AbstractStackNode<P>[] alter
 
 		return children;
 	}
+
+	/**
+	 * Generates and initializes the empty child for usage in empty alternatives.
+	 */
+	@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;
@@ -81,11 +95,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/Alternative2.java

@@ -0,0 +1,70 @@
+/*******************************************************************************
+ * Copyright (c) 2009-2011 CWI
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+
+ *   * Arnold Lankamp - [email protected]
+*******************************************************************************/
+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.AlternativeStackNode;
+import org.rascalmpl.parser.gtd.stack.NonTerminalStackNode;
+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.RascalValueFactory;
+import org.rascalmpl.values.ValueFactoryFactory;
+import org.rascalmpl.values.parsetrees.ITree;
+
+@SuppressWarnings({"unchecked", "cast"})
+public class Alternative2 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_ALT = VF.constructor(RascalValueFactory.Symbol_Alt, VF.set());
+	
+	private final static IConstructor PROD_S_ALT = VF.constructor(RascalValueFactory.Production_Default,  SYMBOL_START_S, VF.list(SYMBOL_ALT), VF.set());
+	private final static IConstructor PROD_ALT = VF.constructor(RascalValueFactory.Production_Default, SYMBOL_ALT, 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>[] S_EXPECT_1 = (AbstractStackNode<IConstructor>[]) new AbstractStackNode[1];
+	static{
+		S_EXPECT_1[0] = new AlternativeStackNode<IConstructor>(4, 0, PROD_ALT, (AbstractStackNode<IConstructor>[]) new AbstractStackNode[]{});
+		S_EXPECT_1[0].setProduction(S_EXPECT_1);
+		S_EXPECT_1[0].setAlternativeProduction(PROD_S_ALT);
+	}
+	
+	public Alternative2(){
+		super();
+	}
+	
+	public AbstractStackNode<IConstructor>[] S(){
+		return 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\"),[alt({})],{}),[appl(prod(alt({})),[])])";
+		return new StandardTextReader().read(ValueFactoryFactory.getValueFactory(), RascalValueFactory.uptr, RascalValueFactory.Tree, new StringReader(expectedInput));
+	}
+	
+	public static void main(String[] args){
+		Alternative2 a2 = new Alternative2();
+		IConstructor result = a2.executeParser();
+		System.out.println(result);
+	}
+}