Thanks for catching that, Jim.
However, just fixing that still yields the same result. Here's the output from jdb:
(PLEXIL (ACTION maxTest (Concurrence (VARIABLE_DECLARATIONS (VARIABLE_DECLARATION Integer l) (VARIABLE_DECLARATION Integer m) (VARIABLE_DECLARATION Integer n)) (VARIABLE_DECLARATIONS (VARIABLE_DECLARATION Real x) (VARIABLE_DECLARATION Real y)) (PostCondition (&& (&& (&& (&& (! (isKnown l)) (== m 1)) (== n 2)) (== x 2.0)) (== y 7.1))) (ACTION unknownInts (ASSIGNMENT l (max l 0))) (ACTION equalInts (ASSIGNMENT m (max 1 1))) (ACTION unequalInts (ASSIGNMENT n (max 1 2))) (ACTION equalReals (ASSIGNMENT x (max 2.0 2.0))) (ACTION unequal (ASSIGNMENT y (max 7.0 7.1))))))
Exception occurred: org.antlr.runtime.tree.RewriteEmptyStreamException (to be caught at: plexil.PlexilTreeTransforms.associativeReduction(), line=785 bci=1,198)"thread=main", org.antlr.runtime.tree.RewriteRuleElementStream._next(), line=158 bci=20
[1] org.antlr.runtime.tree.RewriteRuleElementStream._next (RewriteRuleElementStream.java:158)
[2] org.antlr.runtime.tree.RewriteRuleSubtreeStream.nextNode (RewriteRuleSubtreeStream.java:77)
[3] plexil.PlexilTreeTransforms.associativeReduction (PlexilTreeTransforms.java:755)
Here's the ANTLR generated code in question. The throw happens in the line:
// $ANTLR start "associativeReduction"
// antlr/PlexilTreeTransforms.g:112:1: associativeReduction : ^(op1= associativeOp ^(op2= associativeOp (rest+= . )+ ) arg3= . {...}?) -> ^( $op2 ( $rest)+ $arg3) ;
public final PlexilTreeTransforms.associativeReduction_return associativeReduction() throws RecognitionException {
PlexilTreeTransforms.associativeReduction_return retval = new PlexilTreeTransforms.associativeReduction_return();
retval.start = input.LT(1);
PlexilTreeNode root_0 = null;
PlexilTreeNode _first_0 = null;
PlexilTreeNode _last = null;
PlexilTreeNode arg3=null;
PlexilTreeNode rest=null;
List<Object> list_rest=null;
TreeRuleReturnScope op1 =null;
TreeRuleReturnScope op2 =null;
PlexilTreeNode arg3_tree=null;
PlexilTreeNode rest_tree=null;
RewriteRuleSubtreeStream stream_associativeOp=new RewriteRuleSubtreeStream(adaptor,"rule associativeOp");
try {
// antlr/PlexilTreeTransforms.g:112:21: ( ^(op1= associativeOp ^(op2= associativeOp (rest+= . )+ ) arg3= . {...}?) -> ^( $op2 ( $rest)+ $arg3) )
// antlr/PlexilTreeTransforms.g:122:8: ^(op1= associativeOp ^(op2= associativeOp (rest+= . )+ ) arg3= . {...}?)
{
_last = (PlexilTreeNode)input.LT(1);
{
PlexilTreeNode _save_last_1 = _last;
PlexilTreeNode _first_1 = null;
_last = (PlexilTreeNode)input.LT(1);
pushFollow(FOLLOW_associativeOp_in_associativeReduction302);
op1=associativeOp();
state._fsp--;
if (state.failed) return retval;
if ( state.backtracking==1 ) stream_associativeOp.add(op1.getTree());
if ( state.backtracking==1 )
if ( _first_0==null ) _first_0 = (PlexilTreeNode)op1.getTree();
match(input, Token.DOWN, null); if (state.failed) return retval;
_last = (PlexilTreeNode)input.LT(1);
{
PlexilTreeNode _save_last_2 = _last;
PlexilTreeNode _first_2 = null;
_last = (PlexilTreeNode)input.LT(1);
pushFollow(FOLLOW_associativeOp_in_associativeReduction307);
op2=associativeOp();
state._fsp--;
if (state.failed) return retval;
if ( state.backtracking==1 ) stream_associativeOp.add(op2.getTree());
if ( state.backtracking==1 )
if ( _first_1==null ) _first_1 = (PlexilTreeNode)op2.getTree();
match(input, Token.DOWN, null); if (state.failed) return retval;
// antlr/PlexilTreeTransforms.g:122:48: (rest+= . )+
int cnt2=0;
loop2:
while (true) {
int alt2=2;
int LA2_0 = input.LA(1);
if ( ((LA2_0 >= ABS_KYWD && LA2_0 <= XOR_KYWD)) ) {
alt2=1;
}
switch (alt2) {
case 1 :
// antlr/PlexilTreeTransforms.g:122:49: rest+= .
{
_last = (PlexilTreeNode)input.LT(1);
rest=(PlexilTreeNode)input.LT(1);
matchAny(input); if (state.failed) return retval;
if ( state.backtracking==1 )
if ( _first_2==null ) _first_2 = rest;
if (list_rest==null) list_rest=new ArrayList<Object>();
list_rest.add(rest);
if ( state.backtracking==1 ) {
retval.tree = _first_0;
if ( adaptor.getParent(retval.tree)!=null && adaptor.isNil( adaptor.getParent(retval.tree) ) )
retval.tree = (PlexilTreeNode)adaptor.getParent(retval.tree);
}
}
break;
default :
if ( cnt2 >= 1 ) break loop2;
if (state.backtracking>0) {state.failed=true; return retval;}
EarlyExitException eee = new EarlyExitException(2, input);
throw eee;
}
cnt2++;
}
match(input, Token.UP, null); if (state.failed) return retval;
_last = _save_last_2;
}
_last = (PlexilTreeNode)input.LT(1);
arg3=(PlexilTreeNode)input.LT(1);
matchAny(input); if (state.failed) return retval;
if ( state.backtracking==1 )
if ( _first_1==null ) _first_1 = arg3;
if ( !(((op1!=null?((PlexilTreeNode)op1.start):null).getType() == (op2!=null?((PlexilTreeNode)op2.start):null).getType())) ) {
if (state.backtracking>0) {state.failed=true; return retval;}
throw new FailedPredicateException(input, "associativeReduction", "$op1.start.getType() == $op2.start.getType()");
}
match(input, Token.UP, null); if (state.failed) return retval;
_last = _save_last_1;
}
// AST REWRITE
// elements: rest, op2, arg3
// token labels:
// rule labels: op2, retval
// token list labels:
// rule list labels:
// wildcard labels: arg3, rest
if ( state.backtracking==1 ) {
retval.tree = root_0;
RewriteRuleSubtreeStream stream_arg3=new RewriteRuleSubtreeStream(adaptor,"wildcard arg3",arg3);
RewriteRuleSubtreeStream stream_rest=new RewriteRuleSubtreeStream(adaptor,"wildcard rest",list_rest);
RewriteRuleSubtreeStream stream_op2=new RewriteRuleSubtreeStream(adaptor,"rule op2",op2!=null?op2.getTree():null);
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
root_0 = (PlexilTreeNode)adaptor.nil();
// 123:4: -> ^( $op2 ( $rest)+ $arg3)
{
// antlr/PlexilTreeTransforms.g:123:7: ^( $op2 ( $rest)+ $arg3)
{
PlexilTreeNode root_1 = (PlexilTreeNode)adaptor.nil();
root_1 = (PlexilTreeNode)adaptor.becomeRoot(stream_op2.nextNode(), root_1);
if ( !(stream_rest.hasNext()) ) {
throw new RewriteEarlyExitException();
}
while ( stream_rest.hasNext() ) {
adaptor.addChild(root_1, stream_rest.nextTree());
}
stream_rest.reset();
adaptor.addChild(root_1, stream_arg3.nextTree());
adaptor.addChild(root_0, root_1);
}
}
retval.tree = (PlexilTreeNode)adaptor.rulePostProcessing(root_0);
input.replaceChildren(adaptor.getParent(retval.start),
adaptor.getChildIndex(retval.start),
adaptor.getChildIndex(_last),
retval.tree);
}
}
}
catch (RecognitionException re) {
reportError(re);
recover(input,re);
}
finally {
// do for sure before leaving
}
return retval;
}
// $ANTLR end "associativeReduction"