From dddcfc88394f2b9c73c7751d1e03c269a7eb96a2 Mon Sep 17 00:00:00 2001 From: bpodgursky Date: Wed, 12 Aug 2009 19:06:07 +0000 Subject: Wed Aug 12 19:02:39 UTC 2009 Ben Podgursky --- ChangeLog | 11 +- .../PDDLParser/src/pddl4j/lexer/Lexer.jj | 8581 ++++++++++++++++++++ .../PDDLParser/src/pddl4j/lexer/Lexer.jjt | 3466 ++++++++ 3 files changed, 12056 insertions(+), 2 deletions(-) create mode 100644 utils/PDDLtoSANetTranslator/PDDLParser/src/pddl4j/lexer/Lexer.jj create mode 100644 utils/PDDLtoSANetTranslator/PDDLParser/src/pddl4j/lexer/Lexer.jjt diff --git a/ChangeLog b/ChangeLog index d33149b68ca..3bd6c21d7eb 100644 --- a/ChangeLog +++ b/ChangeLog @@ -1,3 +1,10 @@ +Wed Aug 12 19:02:39 UTC 2009 Ben Podgursky + + * utils/PDDLtoSANetTranslator/PDDLParser/src/pddl4j/lexer/Lexer.jj: + * utils/PDDLtoSANetTranslator/PDDLParser/src/pddl4j/lexer/Lexer.jjt: + + Lexer files + Wed Aug 12 18:49:43 UTC 2009 Ben Podgursky * utils/PDDLtoSANetTranslator/PDDLParser/ferry-example.pddl: @@ -5,8 +12,8 @@ Wed Aug 12 18:49:43 UTC 2009 Ben Podgursky * utils/PDDLtoSANetTranslator/PDDLParser/src/PDDLtoSAN.java: - Domain files - + Domain files + Wed Aug 12 17:49:43 UTC 2009 Ben Podgursky * utils: diff --git a/utils/PDDLtoSANetTranslator/PDDLParser/src/pddl4j/lexer/Lexer.jj b/utils/PDDLtoSANetTranslator/PDDLParser/src/pddl4j/lexer/Lexer.jj new file mode 100644 index 00000000000..47c6b4ca7b1 --- /dev/null +++ b/utils/PDDLtoSANetTranslator/PDDLParser/src/pddl4j/lexer/Lexer.jj @@ -0,0 +1,8581 @@ +/*@bgen(jjtree) Generated By:JJTree: Do not edit this line. ./Lexer.jj */ +/*@egen*//* + * Copyright Dept. of Mathematics & Computer Science Univ. Paris-Descartes + * + * This software is governed by the CeCILL license under French law and + * abiding by the rules of distribution of free software. You can use, + * modify and/ or redistribute the software under the terms of the CeCILL + * license as circulated by CEA, CNRS and INRIA at the following URL + * "http://www.cecill.info". + * + * As a counterpart to the access to the source code and rights to copy, + * modify and redistribute granted by the license, users are provided only + * with a limited warranty and the software's author, the holder of the + * economic rights, and the successive licensors have only limited + * liability. + * + * In this respect, the user's attention is drawn to the risks associated + * with loading, using, modifying and/or developing or reproducing the + * software by the user in light of its specific status of free software, + * that may mean that it is complicated to manipulate, and that also + * therefore means that it is reserved for developers and experienced + * professionals having in-depth computer knowledge. Users are therefore + * encouraged to load and test the software's suitability as regards their + * requirements in conditions enabling the security of their systems and/or + * data to be ensured and, more generally, to use and operate it in the + * same conditions as regards security. + * + * The fact that you are presently reading this means that you have had + * knowledge of the CeCILL license and that you accept its terms. + */ + +options { + + + STATIC=false; + + + IGNORE_CASE=true; +} + +PARSER_BEGIN(Lexer) + +package pddl4j.lexer; + +import java.io.InputStream; +import java.io.File; +import java.util.ArrayList; +import java.util.List; + +import pddl4j.ErrorManager; +import pddl4j.ErrorManager.Message; + +public class Lexer/*@bgen(jjtree)*/implements LexerTreeConstants/*@egen*/ {/*@bgen(jjtree)*/ + protected JJTLexerState jjtree = new JJTLexerState(); + +/*@egen*/ + + private ErrorManager mgr; + private File file; + + private static final int[] BLOCKS = {REQUIREMENTS, + TYPES, + CONSTANTS, + PREDICATES, + FUNCTIONS, + ACTION, + DURATIVE_ACTION, + DERIVED, + OBJECTS, + INIT, + GOAL, + METRIC, + EOF}; + + private boolean isBlock(int token) { + int i = 0; + while (i < BLOCKS.length && (BLOCKS[i] != token)) i++; + return i == BLOCKS.length; + } + + private void error(Throwable e, int line, int column) throws ParseException { + String message = new String(); + if (e.getClass().equals(TokenMgrError.class)) { + String[] tmp = e.getMessage().split(" "); + int l = -1; + int c = -1; + int i = 0; + for (i = 0 ; i < tmp.length; i++) { + if (tmp[i].equals("line") && i+1 < tmp.length) { + l = Integer.parseInt(tmp[i+1].substring(0, tmp[i+1].length()-1)); + } + if (tmp[i].equals("column") && i+1 < tmp.length) { + c = Integer.parseInt(tmp[i+1].substring(0, tmp[i+1].length()-1)); + } + } + message = e.getMessage().split(". ")[1]; + this.mgr.logLexicalError(message, this.file, l, c); + } else if (e.getClass().equals(ParseException.class)) { + ParseException pe = (ParseException) e; + message = generateErrorMesssage(pe); + this.mgr.logLexicalError(message, this.file, pe.currentToken.beginLine, pe.currentToken.beginColumn); + } else if (e instanceof NullPointerException) { + // Do nothing + } else { + e.printStackTrace(); + throw new ParseException(e.getMessage()); + } + this.skipToNextBlock(); + } + + private void skipToNextBlock() { + Token t; + Token t2; + do { + t = getNextToken(); + t2 = getToken(2); + + } while (t2 != null && isBlock(t2.kind)); + } + + public void setErrorManager(ErrorManager mgr) { + this.mgr = mgr; + } + + public void setFile(File file) { + this.file = file; + } + + /** + * Creates the error message from a specific parse exception. + * + * @param pe the parse exception. + * @return the error message. + */ + private String generateErrorMesssage(ParseException pe) { + StringBuffer expected = new StringBuffer(); + boolean expectedSeq = false; + int maxSize = 0; + for (int i = 0; i < pe.expectedTokenSequences.length; i++) { + if (maxSize < pe.expectedTokenSequences[i].length) { + maxSize = pe.expectedTokenSequences[i].length; + } + for (int j = 0; j < pe.expectedTokenSequences[i].length; j++) { + expected.append(pe.tokenImage[pe.expectedTokenSequences[i][j]]).append(" "); + expectedSeq = true; + } + if (pe.expectedTokenSequences[i][pe.expectedTokenSequences[i].length - 1] != 0) { + expected.append("..."); + } + if (i < pe.expectedTokenSequences.length - 1) { + expected.append("\n").append(" "); + } + } + String retval = "unexpected token \"" + pe.currentToken.next.image + "\"."; + if (expectedSeq) { + if (pe.expectedTokenSequences.length == 1) { + retval += "\nWas expecting:" + "\n" + " "; + } else { + retval += "\nWas expecting one of:" + "\n" + " "; + } + retval += expected.toString(); + } + return retval; + } +} +PARSER_END(Lexer) + + +SKIP : +{ + " " +| "\t" +| "\n" +| "\r" +} +MORE : +{ + "//" : IN_SINGLE_LINE_COMMENT +| ";" : IN_SINGLE_LINE_COMMENT +| <"/**" ~["/"]> { input_stream.backup(1); } : IN_FORMAL_COMMENT +| "/*" : IN_MULTI_LINE_COMMENT +} + + SPECIAL_TOKEN : { + : DEFAULT + } + + SPECIAL_TOKEN : { + : DEFAULT + } + + SPECIAL_TOKEN : { + : DEFAULT + } + + MORE : { + < ~[] > +} + +TOKEN : +{ + < LPAREN: "("> +| < RPAREN: ")"> +} + +TOKEN : { + < DEFINE : "define" > +| < DOMAIN : "domain" > +| < REQUIREMENTS : ":requirements" > +| < TYPES : ":types" > +| < EITHER : "either" > +| < CONSTANTS : ":constants" > +| < PREDICATES : ":predicates" > +| < FUNCTIONS : ":functions" > +| < ACTION : ":action" > +| < PARAMETERS : ":parameters" > +| < PRECONDITION : ":precondition" > +| < EFFECT : ":effect" > +| < PREFERENCE : "preference" > +| < WHEN : "when" > +| < PROB : "probabilistic"> +| < DURATIVE_ACTION : ":durative-action" > +| < DURATION : ":duration" > +| < CONDITION : ":condition" > +| < DERIVED : ":derived" > +| < PROBLEM : "problem" > +| < P_DOMAIN : ":domain" > +| < OBJECTS : ":objects" > +| < INIT : ":init" > +| < GOAL: ":goal" > +| < METRIC : ":metric" > +} + +TOKEN : { + < STRIPS : ":strips" > +| < TYPING : ":typing" > +| < NEGATIVE_PRECONDITIONS : ":negative-preconditions" > +| < DISJUNCTIVE_PRECONDITIONS : ":disjunctive-preconditions" > +| < EQUALITY : ":equality" > +| < EXISTENTIAL_PRECONDITIONS : ":existential-preconditions" > +| < UNIVERSAL_PRECONDITIONS : ":universal-preconditions" > +| < QUANTIFIED_PRECONDITIONS : ":quantified-preconditions" > +| < CONDITIONAL_EFFECTS : ":conditional-effects" > +| < FLUENTS : ":fluents" > +| < ADL : ":adl" > +| < DURATIVE_ACTIONS : ":durative-actions" > +| < DERIVED_PREDICATES : ":derived-predicates" > +| < TIMED_INITIAL_LITERALS : ":timed-initial-literals" > +| < PREFERENCES : ":preferences" > +| < CONSTRAINTS : ":constraints" > +| < CONTINUS_EFFECTS : ":continus_effects" > +| < DURATION_INEQUALITIES : ":duration-inequalities" > +} + +TOKEN : +{ + < GREATER : ">" > +| < LESS : "<" > +| < GEQUAL : ">=" > +| < LEQUAL : "<=" > +| < EQUAL : "=" > +} + +TOKEN : +{ + < MUL : "*" > +| < DIV : "/" > +| < ADD : "+" > +| < SUB : "-" > +} + +TOKEN : +{ + +| +| +| +| +} + +TOKEN : +{ + < OR : "or" > +| < AND : "and" > +| < IMPLY : "imply" > +| < NOT : "not" > +| < FORALL : "forall" > +| < EXISTS : "exists" > +} + +TOKEN : +{ + < ALWAYS : "always" > +| < SOMETIME : "sometime" > +| < WITHIN : "within" > +| < AT_MOST_ONCE : "at-most-once" > +| < SOMETIME_AFTER : "sometime-after" > +| < SOMETIME_BEFORE : "sometime-before" > +| < ALWAYS_WITHIN : "always-within" > +| < HOLD_DURING : "hold-during" > +| < HOLD_AFTER : "hold-after" > +| < AT: "at" > +| < START : "start"> +| < END : "end"> +| < OVER : "over"> +| < ALL : "all"> +| < TOTAL_TIME : "total_time" > +| < MAXIMIZE : "maximize" > +| < MINIMIZE : "minimize" > +| < IS_VIOLATED : "is-violated" > +} + +TOKEN : +{ + < VAR_DURATION : "?duration" > +| < CONTINOUS_VARIABLE : "#t" > +} + +TOKEN : +{ + < NUMBER_TYPE : "number" > +| < OBJECT_TYPE : "object" > +} + + +TOKEN : +{ + < SYMBOL : (( ( | )*)) > +| < NUMBER : ()+ ("." ()*)? > +| < #DIGIT : ["0"-"9"] > +| < #LETTER : ["a"-"z","A"-"Z","_","-","#"] > +} + +SimpleNode parse() : +{/*@bgen(jjtree) ROOT */ + SimpleNode jjtn000 = new SimpleNode(this, JJTROOT); + boolean jjtc000 = true; + jjtree.openNodeScope(jjtn000); +/*@egen*/ + Token t= null; +} +{/*@bgen(jjtree) ROOT */ + try { +/*@egen*/ + try { + LOOKAHEAD(4) t=domain() + | LOOKAHEAD(4) t=problem() + } catch (Throwable e) { + this.mgr.logLexicalError("Lexical error file (" +file.getName() + ") : to many errors", file); + throw new ParseException(e.getMessage()); + }/*@bgen(jjtree)*/ + { + jjtree.closeNodeScope(jjtn000, true); + jjtc000 = false; + } +/*@egen*/ + { + jjtn000.setLine(t.beginLine); + jjtn000.setColumn(t.beginColumn); + return jjtn000; + }/*@bgen(jjtree)*/ + } catch (Throwable jjte000) { + if (jjtc000) { + jjtree.clearNodeScope(jjtn000); + jjtc000 = false; + } else { + jjtree.popNode(); + } + if (jjte000 instanceof RuntimeException) { + throw (RuntimeException)jjte000; + } + if (jjte000 instanceof ParseException) { + throw (ParseException)jjte000; + } + throw (Error)jjte000; + } finally { + if (jjtc000) { + jjtree.closeNodeScope(jjtn000, true); + } + } +/*@egen*/ + +} + +Token domain() : +{/*@bgen(jjtree) DOMAIN */ + SimpleNode jjtn000 = new SimpleNode(this, JJTDOMAIN); + boolean jjtc000 = true; + jjtree.openNodeScope(jjtn000); +/*@egen*/ + Token t = token; +} +{/*@bgen(jjtree) DOMAIN */ + try { +/*@egen*/ + try { + t= domain_name() + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + } + try { + [LOOKAHEAD(2) t=require_def()] + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + } + try { + [LOOKAHEAD(2) t=type_def()] + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + } + try { + [LOOKAHEAD(2) t=constants_def()] + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + } + try { + [LOOKAHEAD(2) t=predicates_def()] + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + } + try { + [LOOKAHEAD(2) t=functions_def()] + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + } + try { + [LOOKAHEAD(2) t=constraints()] + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + } + try { + (t=structure_def())* + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + } + try { + + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + }/*@bgen(jjtree)*/ + { + jjtree.closeNodeScope(jjtn000, true); + jjtc000 = false; + } +/*@egen*/ + + { + jjtn000.setLine(t.beginLine); + jjtn000.setColumn(t.beginColumn); + return t; + }/*@bgen(jjtree)*/ + } catch (Throwable jjte000) { + if (jjtc000) { + jjtree.clearNodeScope(jjtn000); + jjtc000 = false; + } else { + jjtree.popNode(); + } + if (jjte000 instanceof RuntimeException) { + throw (RuntimeException)jjte000; + } + if (jjte000 instanceof ParseException) { + throw (ParseException)jjte000; + } + throw (Error)jjte000; + } finally { + if (jjtc000) { + jjtree.closeNodeScope(jjtn000, true); + } + } +/*@egen*/ +} + +Token require_def() : +{/*@bgen(jjtree) REQUIRE_DEF */ + SimpleNode jjtn000 = new SimpleNode(this, JJTREQUIRE_DEF); + boolean jjtc000 = true; + jjtree.openNodeScope(jjtn000); +/*@egen*/ + Token t = token; +} +{/*@bgen(jjtree) REQUIRE_DEF */ + try { +/*@egen*/ + try { + t= (require_key())+ + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + }/*@bgen(jjtree)*/ + { + jjtree.closeNodeScope(jjtn000, true); + jjtc000 = false; + } +/*@egen*/ + { + jjtn000.setLine(t.beginLine); + jjtn000.setColumn(t.beginColumn); + return t; + }/*@bgen(jjtree)*/ + } catch (Throwable jjte000) { + if (jjtc000) { + jjtree.clearNodeScope(jjtn000); + jjtc000 = false; + } else { + jjtree.popNode(); + } + if (jjte000 instanceof RuntimeException) { + throw (RuntimeException)jjte000; + } + if (jjte000 instanceof ParseException) { + throw (ParseException)jjte000; + } + throw (Error)jjte000; + } finally { + if (jjtc000) { + jjtree.closeNodeScope(jjtn000, true); + } + } +/*@egen*/ +} + +Token require_key() : +{/*@bgen(jjtree) REQUIRE_KEY */ + SimpleNode jjtn000 = new SimpleNode(this, JJTREQUIRE_KEY); + boolean jjtc000 = true; + jjtree.openNodeScope(jjtn000); +/*@egen*/ + Token t = token; +} +{/*@bgen(jjtree) REQUIRE_KEY */ + try { +/*@egen*/ + try { + t= + | t= + | t= + | t= + | t= + | t= + | t= + | t= + | t= + | t= + | t= + | t= + | t= + | t= + | t= + | t= + | t= + | t= + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + }/*@bgen(jjtree)*/ + { + jjtree.closeNodeScope(jjtn000, true); + jjtc000 = false; + } +/*@egen*/ + { + jjtn000.setLine(t.beginLine); + jjtn000.setColumn(t.beginColumn); + jjtn000.setImage(t.image); + return t; + }/*@bgen(jjtree)*/ + } finally { + if (jjtc000) { + jjtree.closeNodeScope(jjtn000, true); + } + } +/*@egen*/ +} + +Token type_def() : +{/*@bgen(jjtree) TYPE_DEF */ + SimpleNode jjtn000 = new SimpleNode(this, JJTTYPE_DEF); + boolean jjtc000 = true; + jjtree.openNodeScope(jjtn000); +/*@egen*/ + Token t = token; +} +{/*@bgen(jjtree) TYPE_DEF */ + try { +/*@egen*/ + try { + t= typed_list(LexerTreeConstants.JJTPRIMITIVE_TYPE) + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + }/*@bgen(jjtree)*/ + { + jjtree.closeNodeScope(jjtn000, true); + jjtc000 = false; + } +/*@egen*/ + { + jjtn000.setLine(t.beginLine); + jjtn000.setColumn(t.beginColumn); + return t; + }/*@bgen(jjtree)*/ + } catch (Throwable jjte000) { + if (jjtc000) { + jjtree.clearNodeScope(jjtn000); + jjtc000 = false; + } else { + jjtree.popNode(); + } + if (jjte000 instanceof RuntimeException) { + throw (RuntimeException)jjte000; + } + if (jjte000 instanceof ParseException) { + throw (ParseException)jjte000; + } + throw (Error)jjte000; + } finally { + if (jjtc000) { + jjtree.closeNodeScope(jjtn000, true); + } + } +/*@egen*/ +} + +Token typed_list(int type) : +{/*@bgen(jjtree) TYPED_LIST */ + SimpleNode jjtn000 = new SimpleNode(this, JJTTYPED_LIST); + boolean jjtc000 = true; + jjtree.openNodeScope(jjtn000); +/*@egen*/ + Token t = token; +} +{/*@bgen(jjtree) TYPED_LIST */ + try { +/*@egen*/ + try { + LOOKAHEAD(2, {type == LexerTreeConstants.JJTPRIMITIVE_TYPE}) + (t=primitive_type())* ( type() typed_list(type))? + | LOOKAHEAD(2, {type == LexerTreeConstants.JJTCONSTANT}) + (t=constant())* ( type() typed_list(type))? + | LOOKAHEAD(2, {type == LexerTreeConstants.JJTVARIABLE}) + (t=variable())* ( type() typed_list(type))? + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + }/*@bgen(jjtree)*/ + { + jjtree.closeNodeScope(jjtn000, true); + jjtc000 = false; + } +/*@egen*/ + { + if (t != null) { + jjtn000.setLine(t.beginLine); + jjtn000.setColumn(t.beginColumn); + jjtn000.setTypeId(LexerTreeConstants.JJTVARIABLE); + } + return t; + }/*@bgen(jjtree)*/ + } catch (Throwable jjte000) { + if (jjtc000) { + jjtree.clearNodeScope(jjtn000); + jjtc000 = false; + } else { + jjtree.popNode(); + } + if (jjte000 instanceof RuntimeException) { + throw (RuntimeException)jjte000; + } + if (jjte000 instanceof ParseException) { + throw (ParseException)jjte000; + } + throw (Error)jjte000; + } finally { + if (jjtc000) { + jjtree.closeNodeScope(jjtn000, true); + } + } +/*@egen*/ +} + +Token type() : +{/*@bgen(jjtree) TYPE */ + SimpleNode jjtn000 = new SimpleNode(this, JJTTYPE); + boolean jjtc000 = true; + jjtree.openNodeScope(jjtn000); +/*@egen*/ + Token t = token; +} +{/*@bgen(jjtree) TYPE */ + try { +/*@egen*/ + try { + t= (primitive_type())+ + | t=primitive_type() + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + }/*@bgen(jjtree)*/ + { + jjtree.closeNodeScope(jjtn000, true); + jjtc000 = false; + } +/*@egen*/ + { + jjtn000.setLine(t.beginLine); + jjtn000.setColumn(t.beginColumn); + return t; + }/*@bgen(jjtree)*/ + } catch (Throwable jjte000) { + if (jjtc000) { + jjtree.clearNodeScope(jjtn000); + jjtc000 = false; + } else { + jjtree.popNode(); + } + if (jjte000 instanceof RuntimeException) { + throw (RuntimeException)jjte000; + } + if (jjte000 instanceof ParseException) { + throw (ParseException)jjte000; + } + throw (Error)jjte000; + } finally { + if (jjtc000) { + jjtree.closeNodeScope(jjtn000, true); + } + } +/*@egen*/ +} + +Token primitive_type() : +{/*@bgen(jjtree) PRIMITIVE_TYPE */ + SimpleNode jjtn000 = new SimpleNode(this, JJTPRIMITIVE_TYPE); + boolean jjtc000 = true; + jjtree.openNodeScope(jjtn000); +/*@egen*/ + Token t = token; +} +{/*@bgen(jjtree) PRIMITIVE_TYPE */ +try { +/*@egen*/ +( t= +| t= +| t=)/*@bgen(jjtree)*/ + { + jjtree.closeNodeScope(jjtn000, true); + jjtc000 = false; + } +/*@egen*/ + { + jjtn000.setLine(t.beginLine); + jjtn000.setColumn(t.beginColumn); + jjtn000.setImage(t.image); + return t; + }/*@bgen(jjtree)*/ +} finally { + if (jjtc000) { + jjtree.closeNodeScope(jjtn000, true); + } +} +/*@egen*/ +} + +Token constants_def() : +{/*@bgen(jjtree) CONSTANT_DEF */ + SimpleNode jjtn000 = new SimpleNode(this, JJTCONSTANT_DEF); + boolean jjtc000 = true; + jjtree.openNodeScope(jjtn000); +/*@egen*/ + Token t = token; +} +{/*@bgen(jjtree) CONSTANT_DEF */ + try { +/*@egen*/ + try { + t= typed_list(LexerTreeConstants.JJTCONSTANT) + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + }/*@bgen(jjtree)*/ + { + jjtree.closeNodeScope(jjtn000, true); + jjtc000 = false; + } +/*@egen*/ + { + jjtn000.setLine(t.beginLine); + jjtn000.setColumn(t.beginColumn); + return t; + }/*@bgen(jjtree)*/ + } catch (Throwable jjte000) { + if (jjtc000) { + jjtree.clearNodeScope(jjtn000); + jjtc000 = false; + } else { + jjtree.popNode(); + } + if (jjte000 instanceof RuntimeException) { + throw (RuntimeException)jjte000; + } + if (jjte000 instanceof ParseException) { + throw (ParseException)jjte000; + } + throw (Error)jjte000; + } finally { + if (jjtc000) { + jjtree.closeNodeScope(jjtn000, true); + } + } +/*@egen*/ +} + +Token constant() : +{/*@bgen(jjtree) CONSTANT */ + SimpleNode jjtn000 = new SimpleNode(this, JJTCONSTANT); + boolean jjtc000 = true; + jjtree.openNodeScope(jjtn000); +/*@egen*/ + Token t = token; +} +{/*@bgen(jjtree) CONSTANT */ + try { +/*@egen*/ + t=/*@bgen(jjtree)*/ + { + jjtree.closeNodeScope(jjtn000, true); + jjtc000 = false; + } +/*@egen*/ + { + jjtn000.setLine(t.beginLine); + jjtn000.setColumn(t.beginColumn); + jjtn000.setImage(t.image); + return t; + }/*@bgen(jjtree)*/ + } finally { + if (jjtc000) { + jjtree.closeNodeScope(jjtn000, true); + } + } +/*@egen*/ +} + +Token predicates_def() : +{/*@bgen(jjtree) PREDICATE_DEF */ + SimpleNode jjtn000 = new SimpleNode(this, JJTPREDICATE_DEF); + boolean jjtc000 = true; + jjtree.openNodeScope(jjtn000); +/*@egen*/ + Token t = token; +} +{/*@bgen(jjtree) PREDICATE_DEF */ + try { +/*@egen*/ + try { + t= (atomic_formula_skeleton())+ + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + }/*@bgen(jjtree)*/ + { + jjtree.closeNodeScope(jjtn000, true); + jjtc000 = false; + } +/*@egen*/ + { + jjtn000.setLine(t.beginLine); + jjtn000.setColumn(t.beginColumn); + return t; + }/*@bgen(jjtree)*/ + } catch (Throwable jjte000) { + if (jjtc000) { + jjtree.clearNodeScope(jjtn000); + jjtc000 = false; + } else { + jjtree.popNode(); + } + if (jjte000 instanceof RuntimeException) { + throw (RuntimeException)jjte000; + } + if (jjte000 instanceof ParseException) { + throw (ParseException)jjte000; + } + throw (Error)jjte000; + } finally { + if (jjtc000) { + jjtree.closeNodeScope(jjtn000, true); + } + } +/*@egen*/ +} + +Token atomic_formula_skeleton() : +{/*@bgen(jjtree) ATOMIC_FORMULA_SKELETON */ + SimpleNode jjtn000 = new SimpleNode(this, JJTATOMIC_FORMULA_SKELETON); + boolean jjtc000 = true; + jjtree.openNodeScope(jjtn000); +/*@egen*/ + Token t = token; +} +{/*@bgen(jjtree) ATOMIC_FORMULA_SKELETON */ + try { +/*@egen*/ + t= predicate() typed_list(LexerTreeConstants.JJTVARIABLE) /*@bgen(jjtree)*/ + { + jjtree.closeNodeScope(jjtn000, true); + jjtc000 = false; + } +/*@egen*/ + { + jjtn000.setLine(t.beginLine); + jjtn000.setColumn(t.beginColumn); + return t; + }/*@bgen(jjtree)*/ + } catch (Throwable jjte000) { + if (jjtc000) { + jjtree.clearNodeScope(jjtn000); + jjtc000 = false; + } else { + jjtree.popNode(); + } + if (jjte000 instanceof RuntimeException) { + throw (RuntimeException)jjte000; + } + if (jjte000 instanceof ParseException) { + throw (ParseException)jjte000; + } + throw (Error)jjte000; + } finally { + if (jjtc000) { + jjtree.closeNodeScope(jjtn000, true); + } + } +/*@egen*/ +} + +Token predicate() : +{/*@bgen(jjtree) PREDICATE */ + SimpleNode jjtn000 = new SimpleNode(this, JJTPREDICATE); + boolean jjtc000 = true; + jjtree.openNodeScope(jjtn000); +/*@egen*/ + Token t = token; +} +{/*@bgen(jjtree) PREDICATE */ + try { +/*@egen*/ + (t= | t=)/*@bgen(jjtree)*/ + { + jjtree.closeNodeScope(jjtn000, true); + jjtc000 = false; + } +/*@egen*/ + { + jjtn000.setLine(t.beginLine); + jjtn000.setColumn(t.beginColumn); + jjtn000.setImage(t.image); + return t; + }/*@bgen(jjtree)*/ + } finally { + if (jjtc000) { + jjtree.closeNodeScope(jjtn000, true); + } + } +/*@egen*/ +} + +Token variable() : +{/*@bgen(jjtree) VARIABLE */ + SimpleNode jjtn000 = new SimpleNode(this, JJTVARIABLE); + boolean jjtc000 = true; + jjtree.openNodeScope(jjtn000); +/*@egen*/ + Token t = token; +} +{/*@bgen(jjtree) VARIABLE */ + try { +/*@egen*/ + "?" (t= | t= | t=)/*@bgen(jjtree)*/ + { + jjtree.closeNodeScope(jjtn000, true); + jjtc000 = false; + } +/*@egen*/ + { + jjtn000.setLine(t.beginLine); + jjtn000.setColumn(t.beginColumn); + jjtn000.setImage(t.image); + return t; + }/*@bgen(jjtree)*/ + } finally { + if (jjtc000) { + jjtree.closeNodeScope(jjtn000, true); + } + } +/*@egen*/ +} + +Token functions_def() : +{/*@bgen(jjtree) FUNCTION_DEF */ + SimpleNode jjtn000 = new SimpleNode(this, JJTFUNCTION_DEF); + boolean jjtc000 = true; + jjtree.openNodeScope(jjtn000); +/*@egen*/ + Token t = token; +} +{/*@bgen(jjtree) FUNCTION_DEF */ + try { +/*@egen*/ + try { + t= function_typed_list(LexerTreeConstants.JJTATOMIC_FUNCTION_SKELETON) + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + }/*@bgen(jjtree)*/ + { + jjtree.closeNodeScope(jjtn000, true); + jjtc000 = false; + } +/*@egen*/ + { + jjtn000.setLine(t.beginLine); + jjtn000.setColumn(t.beginColumn); + return t; + }/*@bgen(jjtree)*/ + } catch (Throwable jjte000) { + if (jjtc000) { + jjtree.clearNodeScope(jjtn000); + jjtc000 = false; + } else { + jjtree.popNode(); + } + if (jjte000 instanceof RuntimeException) { + throw (RuntimeException)jjte000; + } + if (jjte000 instanceof ParseException) { + throw (ParseException)jjte000; + } + throw (Error)jjte000; + } finally { + if (jjtc000) { + jjtree.closeNodeScope(jjtn000, true); + } + } +/*@egen*/ +} + +Token atomic_function_skeleton() : +{/*@bgen(jjtree) ATOMIC_FUNCTION_SKELETON */ + SimpleNode jjtn000 = new SimpleNode(this, JJTATOMIC_FUNCTION_SKELETON); + boolean jjtc000 = true; + jjtree.openNodeScope(jjtn000); +/*@egen*/ + Token t = token; +} +{/*@bgen(jjtree) ATOMIC_FUNCTION_SKELETON */ + try { +/*@egen*/ + t= functor() typed_list(LexerTreeConstants.JJTVARIABLE) /*@bgen(jjtree)*/ + { + jjtree.closeNodeScope(jjtn000, true); + jjtc000 = false; + } +/*@egen*/ + { + jjtn000.setLine(t.beginLine); + jjtn000.setColumn(t.beginColumn); + return t; + }/*@bgen(jjtree)*/ + } catch (Throwable jjte000) { + if (jjtc000) { + jjtree.clearNodeScope(jjtn000); + jjtc000 = false; + } else { + jjtree.popNode(); + } + if (jjte000 instanceof RuntimeException) { + throw (RuntimeException)jjte000; + } + if (jjte000 instanceof ParseException) { + throw (ParseException)jjte000; + } + throw (Error)jjte000; + } finally { + if (jjtc000) { + jjtree.closeNodeScope(jjtn000, true); + } + } +/*@egen*/ +} + +Token functor() : +{/*@bgen(jjtree) FUNCTOR */ + SimpleNode jjtn000 = new SimpleNode(this, JJTFUNCTOR); + boolean jjtc000 = true; + jjtree.openNodeScope(jjtn000); +/*@egen*/ + Token t = token; +} +{/*@bgen(jjtree) FUNCTOR */ + try { +/*@egen*/ + t=/*@bgen(jjtree)*/ + { + jjtree.closeNodeScope(jjtn000, true); + jjtc000 = false; + } +/*@egen*/ + { + jjtn000.setLine(t.beginLine); + jjtn000.setColumn(t.beginColumn); + jjtn000.setImage(t.image); + return t; + }/*@bgen(jjtree)*/ + } finally { + if (jjtc000) { + jjtree.closeNodeScope(jjtn000, true); + } + } +/*@egen*/ +} + +Token function_typed_list(int type) : +{/*@bgen(jjtree) FUNCTION_TYPED_LIST */ + SimpleNode jjtn000 = new SimpleNode(this, JJTFUNCTION_TYPED_LIST); + boolean jjtc000 = true; + jjtree.openNodeScope(jjtn000); +/*@egen*/ + Token t = token; +} +{/*@bgen(jjtree) FUNCTION_TYPED_LIST */ + try { +/*@egen*/ + (t=atomic_function_skeleton())* ( function_type() function_typed_list(type))?/*@bgen(jjtree)*/ + { + jjtree.closeNodeScope(jjtn000, true); + jjtc000 = false; + } +/*@egen*/ + { + if (t != null) { + jjtn000.setLine(t.beginLine); + jjtn000.setColumn(t.beginColumn); + } + return t; + }/*@bgen(jjtree)*/ + } catch (Throwable jjte000) { + if (jjtc000) { + jjtree.clearNodeScope(jjtn000); + jjtc000 = false; + } else { + jjtree.popNode(); + } + if (jjte000 instanceof RuntimeException) { + throw (RuntimeException)jjte000; + } + if (jjte000 instanceof ParseException) { + throw (ParseException)jjte000; + } + throw (Error)jjte000; + } finally { + if (jjtc000) { + jjtree.closeNodeScope(jjtn000, true); + } + } +/*@egen*/ +} + +Token function_type() : +{/*@bgen(jjtree) FUNCTION_TYPE */ + SimpleNode jjtn000 = new SimpleNode(this, JJTFUNCTION_TYPE); + boolean jjtc000 = true; + jjtree.openNodeScope(jjtn000); +/*@egen*/ + Token t = token; +} +{/*@bgen(jjtree) FUNCTION_TYPE */ + try { +/*@egen*/ + t=/*@bgen(jjtree)*/ + { + jjtree.closeNodeScope(jjtn000, true); + jjtc000 = false; + } +/*@egen*/ + { + jjtn000.setLine(t.beginLine); + jjtn000.setColumn(t.beginColumn); + jjtn000.setImage(t.image); + return t; + }/*@bgen(jjtree)*/ + } finally { + if (jjtc000) { + jjtree.closeNodeScope(jjtn000, true); + } + } +/*@egen*/ +} + +Token con_gd() : +{/*@bgen(jjtree) CON_GD */ + SimpleNode jjtn000 = new SimpleNode(this, JJTCON_GD); + boolean jjtc000 = true; + jjtree.openNodeScope(jjtn000); +/*@egen*/ + Token t = token; +} +{/*@bgen(jjtree) CON_GD */ + try { +/*@egen*/ + try { + LOOKAHEAD(2) t=and_con_gd() + | LOOKAHEAD(2) t=forall_con_gd() + | LOOKAHEAD(2) t=at_end_con_gd() + | LOOKAHEAD(2) t=always_con_gd() + | LOOKAHEAD(2) t=sometime_con_gd() + | LOOKAHEAD(2) t=within_con_gd() + | LOOKAHEAD(2) t=at_most_once_con_gd() + | LOOKAHEAD(2) t=sometime_after_con_gd() + | LOOKAHEAD(2) t=sometime_before_con_gd() + | LOOKAHEAD(2) t=always_within_con_gd() + | LOOKAHEAD(2) t=hold_during_con_gd() + | LOOKAHEAD(2) t=hold_after_con_gd() + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + }/*@bgen(jjtree)*/ + { + jjtree.closeNodeScope(jjtn000, true); + jjtc000 = false; + } +/*@egen*/ + { + jjtn000.setLine(t.beginLine); + jjtn000.setColumn(t.beginColumn); + return t; + }/*@bgen(jjtree)*/ + } catch (Throwable jjte000) { + if (jjtc000) { + jjtree.clearNodeScope(jjtn000); + jjtc000 = false; + } else { + jjtree.popNode(); + } + if (jjte000 instanceof RuntimeException) { + throw (RuntimeException)jjte000; + } + if (jjte000 instanceof ParseException) { + throw (ParseException)jjte000; + } + throw (Error)jjte000; + } finally { + if (jjtc000) { + jjtree.closeNodeScope(jjtn000, true); + } + } +/*@egen*/ +} + +Token and_con_gd() : +{/*@bgen(jjtree) AND_CON_GD */ + SimpleNode jjtn000 = new SimpleNode(this, JJTAND_CON_GD); + boolean jjtc000 = true; + jjtree.openNodeScope(jjtn000); +/*@egen*/ + Token t = token; +} +{/*@bgen(jjtree) AND_CON_GD */ + try { +/*@egen*/ + try { + t= (con_gd())* + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + }/*@bgen(jjtree)*/ + { + jjtree.closeNodeScope(jjtn000, true); + jjtc000 = false; + } +/*@egen*/ + { + jjtn000.setLine(t.beginLine); + jjtn000.setColumn(t.beginColumn); + return t; + }/*@bgen(jjtree)*/ + } catch (Throwable jjte000) { + if (jjtc000) { + jjtree.clearNodeScope(jjtn000); + jjtc000 = false; + } else { + jjtree.popNode(); + } + if (jjte000 instanceof RuntimeException) { + throw (RuntimeException)jjte000; + } + if (jjte000 instanceof ParseException) { + throw (ParseException)jjte000; + } + throw (Error)jjte000; + } finally { + if (jjtc000) { + jjtree.closeNodeScope(jjtn000, true); + } + } +/*@egen*/ +} + +Token forall_con_gd() : +{/*@bgen(jjtree) FORALL_CON_GD */ + SimpleNode jjtn000 = new SimpleNode(this, JJTFORALL_CON_GD); + boolean jjtc000 = true; + jjtree.openNodeScope(jjtn000); +/*@egen*/ + Token t = token; +} +{/*@bgen(jjtree) FORALL_CON_GD */ + try { +/*@egen*/ + try { + t= typed_list(LexerTreeConstants.JJTVARIABLE) con_gd() + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + }/*@bgen(jjtree)*/ + { + jjtree.closeNodeScope(jjtn000, true); + jjtc000 = false; + } +/*@egen*/ + { + jjtn000.setLine(t.beginLine); + jjtn000.setColumn(t.beginColumn); + return t; + }/*@bgen(jjtree)*/ + } catch (Throwable jjte000) { + if (jjtc000) { + jjtree.clearNodeScope(jjtn000); + jjtc000 = false; + } else { + jjtree.popNode(); + } + if (jjte000 instanceof RuntimeException) { + throw (RuntimeException)jjte000; + } + if (jjte000 instanceof ParseException) { + throw (ParseException)jjte000; + } + throw (Error)jjte000; + } finally { + if (jjtc000) { + jjtree.closeNodeScope(jjtn000, true); + } + } +/*@egen*/ +} + +Token at_end_con_gd() : +{/*@bgen(jjtree) AT_END_CON_GD */ + SimpleNode jjtn000 = new SimpleNode(this, JJTAT_END_CON_GD); + boolean jjtc000 = true; + jjtree.openNodeScope(jjtn000); +/*@egen*/ + Token t = token; +} +{/*@bgen(jjtree) AT_END_CON_GD */ + try { +/*@egen*/ + try { + t= gd() + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + }/*@bgen(jjtree)*/ + { + jjtree.closeNodeScope(jjtn000, true); + jjtc000 = false; + } +/*@egen*/ + { + jjtn000.setLine(t.beginLine); + jjtn000.setColumn(t.beginColumn); + return t; + }/*@bgen(jjtree)*/ + } catch (Throwable jjte000) { + if (jjtc000) { + jjtree.clearNodeScope(jjtn000); + jjtc000 = false; + } else { + jjtree.popNode(); + } + if (jjte000 instanceof RuntimeException) { + throw (RuntimeException)jjte000; + } + if (jjte000 instanceof ParseException) { + throw (ParseException)jjte000; + } + throw (Error)jjte000; + } finally { + if (jjtc000) { + jjtree.closeNodeScope(jjtn000, true); + } + } +/*@egen*/ +} + +Token always_con_gd() : +{/*@bgen(jjtree) ALWAYS_CON_GD */ + SimpleNode jjtn000 = new SimpleNode(this, JJTALWAYS_CON_GD); + boolean jjtc000 = true; + jjtree.openNodeScope(jjtn000); +/*@egen*/ + Token t = token; +} +{/*@bgen(jjtree) ALWAYS_CON_GD */ + try { +/*@egen*/ + try { + t= gd() + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + }/*@bgen(jjtree)*/ + { + jjtree.closeNodeScope(jjtn000, true); + jjtc000 = false; + } +/*@egen*/ + { + jjtn000.setLine(t.beginLine); + jjtn000.setColumn(t.beginColumn); + return t; + }/*@bgen(jjtree)*/ + } catch (Throwable jjte000) { + if (jjtc000) { + jjtree.clearNodeScope(jjtn000); + jjtc000 = false; + } else { + jjtree.popNode(); + } + if (jjte000 instanceof RuntimeException) { + throw (RuntimeException)jjte000; + } + if (jjte000 instanceof ParseException) { + throw (ParseException)jjte000; + } + throw (Error)jjte000; + } finally { + if (jjtc000) { + jjtree.closeNodeScope(jjtn000, true); + } + } +/*@egen*/ +} + +Token sometime_con_gd() : +{/*@bgen(jjtree) SOMETIME_CON_GD */ + SimpleNode jjtn000 = new SimpleNode(this, JJTSOMETIME_CON_GD); + boolean jjtc000 = true; + jjtree.openNodeScope(jjtn000); +/*@egen*/ + Token t = token; +} +{/*@bgen(jjtree) SOMETIME_CON_GD */ + try { +/*@egen*/ + try { + t= gd() + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + }/*@bgen(jjtree)*/ + { + jjtree.closeNodeScope(jjtn000, true); + jjtc000 = false; + } +/*@egen*/ + { + jjtn000.setLine(t.beginLine); + jjtn000.setColumn(t.beginColumn); + return t; + }/*@bgen(jjtree)*/ + } catch (Throwable jjte000) { + if (jjtc000) { + jjtree.clearNodeScope(jjtn000); + jjtc000 = false; + } else { + jjtree.popNode(); + } + if (jjte000 instanceof RuntimeException) { + throw (RuntimeException)jjte000; + } + if (jjte000 instanceof ParseException) { + throw (ParseException)jjte000; + } + throw (Error)jjte000; + } finally { + if (jjtc000) { + jjtree.closeNodeScope(jjtn000, true); + } + } +/*@egen*/ +} + +Token within_con_gd() : +{/*@bgen(jjtree) WITHIN_CON_GD */ + SimpleNode jjtn000 = new SimpleNode(this, JJTWITHIN_CON_GD); + boolean jjtc000 = true; + jjtree.openNodeScope(jjtn000); +/*@egen*/ + Token t = token; +} +{/*@bgen(jjtree) WITHIN_CON_GD */ + try { +/*@egen*/ + try { + t= gd() + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + }/*@bgen(jjtree)*/ + { + jjtree.closeNodeScope(jjtn000, true); + jjtc000 = false; + } +/*@egen*/ + { + jjtn000.setLine(t.beginLine); + jjtn000.setColumn(t.beginColumn); + return t; + }/*@bgen(jjtree)*/ + } catch (Throwable jjte000) { + if (jjtc000) { + jjtree.clearNodeScope(jjtn000); + jjtc000 = false; + } else { + jjtree.popNode(); + } + if (jjte000 instanceof RuntimeException) { + throw (RuntimeException)jjte000; + } + if (jjte000 instanceof ParseException) { + throw (ParseException)jjte000; + } + throw (Error)jjte000; + } finally { + if (jjtc000) { + jjtree.closeNodeScope(jjtn000, true); + } + } +/*@egen*/ +} + +Token at_most_once_con_gd() : +{/*@bgen(jjtree) AT_MOST_ONCE_CON_GD */ + SimpleNode jjtn000 = new SimpleNode(this, JJTAT_MOST_ONCE_CON_GD); + boolean jjtc000 = true; + jjtree.openNodeScope(jjtn000); +/*@egen*/ + Token t = token; +} +{/*@bgen(jjtree) AT_MOST_ONCE_CON_GD */ + try { +/*@egen*/ + try { + t= gd() + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + }/*@bgen(jjtree)*/ + { + jjtree.closeNodeScope(jjtn000, true); + jjtc000 = false; + } +/*@egen*/ + { + jjtn000.setLine(t.beginLine); + jjtn000.setColumn(t.beginColumn); + return t; + }/*@bgen(jjtree)*/ + } catch (Throwable jjte000) { + if (jjtc000) { + jjtree.clearNodeScope(jjtn000); + jjtc000 = false; + } else { + jjtree.popNode(); + } + if (jjte000 instanceof RuntimeException) { + throw (RuntimeException)jjte000; + } + if (jjte000 instanceof ParseException) { + throw (ParseException)jjte000; + } + throw (Error)jjte000; + } finally { + if (jjtc000) { + jjtree.closeNodeScope(jjtn000, true); + } + } +/*@egen*/ +} + +Token sometime_after_con_gd() : +{/*@bgen(jjtree) SOMETIME_AFTER_CON_GD */ + SimpleNode jjtn000 = new SimpleNode(this, JJTSOMETIME_AFTER_CON_GD); + boolean jjtc000 = true; + jjtree.openNodeScope(jjtn000); +/*@egen*/ + Token t = token; +} +{/*@bgen(jjtree) SOMETIME_AFTER_CON_GD */ + try { +/*@egen*/ + try { + t= gd() gd() + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + }/*@bgen(jjtree)*/ + { + jjtree.closeNodeScope(jjtn000, true); + jjtc000 = false; + } +/*@egen*/ + { + jjtn000.setLine(t.beginLine); + jjtn000.setColumn(t.beginColumn); + return t; + }/*@bgen(jjtree)*/ + } catch (Throwable jjte000) { + if (jjtc000) { + jjtree.clearNodeScope(jjtn000); + jjtc000 = false; + } else { + jjtree.popNode(); + } + if (jjte000 instanceof RuntimeException) { + throw (RuntimeException)jjte000; + } + if (jjte000 instanceof ParseException) { + throw (ParseException)jjte000; + } + throw (Error)jjte000; + } finally { + if (jjtc000) { + jjtree.closeNodeScope(jjtn000, true); + } + } +/*@egen*/ +} + +Token sometime_before_con_gd() : +{/*@bgen(jjtree) SOMETIME_BEFORE_CON_GD */ + SimpleNode jjtn000 = new SimpleNode(this, JJTSOMETIME_BEFORE_CON_GD); + boolean jjtc000 = true; + jjtree.openNodeScope(jjtn000); +/*@egen*/ + Token t = token; +} +{/*@bgen(jjtree) SOMETIME_BEFORE_CON_GD */ + try { +/*@egen*/ + try { + t= gd() gd() + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + }/*@bgen(jjtree)*/ + { + jjtree.closeNodeScope(jjtn000, true); + jjtc000 = false; + } +/*@egen*/ + { + jjtn000.setLine(t.beginLine); + jjtn000.setColumn(t.beginColumn); + return t; + }/*@bgen(jjtree)*/ + } catch (Throwable jjte000) { + if (jjtc000) { + jjtree.clearNodeScope(jjtn000); + jjtc000 = false; + } else { + jjtree.popNode(); + } + if (jjte000 instanceof RuntimeException) { + throw (RuntimeException)jjte000; + } + if (jjte000 instanceof ParseException) { + throw (ParseException)jjte000; + } + throw (Error)jjte000; + } finally { + if (jjtc000) { + jjtree.closeNodeScope(jjtn000, true); + } + } +/*@egen*/ +} + +Token always_within_con_gd() : +{/*@bgen(jjtree) ALWAYS_WITHIN_CON_GD */ + SimpleNode jjtn000 = new SimpleNode(this, JJTALWAYS_WITHIN_CON_GD); + boolean jjtc000 = true; + jjtree.openNodeScope(jjtn000); +/*@egen*/ + Token t = token; +} +{/*@bgen(jjtree) ALWAYS_WITHIN_CON_GD */ + try { +/*@egen*/ + try { + t= gd() gd() + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + }/*@bgen(jjtree)*/ + { + jjtree.closeNodeScope(jjtn000, true); + jjtc000 = false; + } +/*@egen*/ + { + jjtn000.setLine(t.beginLine); + jjtn000.setColumn(t.beginColumn); + return t; + }/*@bgen(jjtree)*/ + } catch (Throwable jjte000) { + if (jjtc000) { + jjtree.clearNodeScope(jjtn000); + jjtc000 = false; + } else { + jjtree.popNode(); + } + if (jjte000 instanceof RuntimeException) { + throw (RuntimeException)jjte000; + } + if (jjte000 instanceof ParseException) { + throw (ParseException)jjte000; + } + throw (Error)jjte000; + } finally { + if (jjtc000) { + jjtree.closeNodeScope(jjtn000, true); + } + } +/*@egen*/ +} + +Token hold_during_con_gd() : +{/*@bgen(jjtree) HOLD_DURING_CON_GD */ + SimpleNode jjtn000 = new SimpleNode(this, JJTHOLD_DURING_CON_GD); + boolean jjtc000 = true; + jjtree.openNodeScope(jjtn000); +/*@egen*/ + Token t = token; +} +{/*@bgen(jjtree) HOLD_DURING_CON_GD */ + try { +/*@egen*/ + try { + t= gd() + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + }/*@bgen(jjtree)*/ + { + jjtree.closeNodeScope(jjtn000, true); + jjtc000 = false; + } +/*@egen*/ + { + jjtn000.setLine(t.beginLine); + jjtn000.setColumn(t.beginColumn); + return t; + }/*@bgen(jjtree)*/ + } catch (Throwable jjte000) { + if (jjtc000) { + jjtree.clearNodeScope(jjtn000); + jjtc000 = false; + } else { + jjtree.popNode(); + } + if (jjte000 instanceof RuntimeException) { + throw (RuntimeException)jjte000; + } + if (jjte000 instanceof ParseException) { + throw (ParseException)jjte000; + } + throw (Error)jjte000; + } finally { + if (jjtc000) { + jjtree.closeNodeScope(jjtn000, true); + } + } +/*@egen*/ +} + +Token hold_after_con_gd() : +{/*@bgen(jjtree) HOLD_AFTER_CON_GD */ + SimpleNode jjtn000 = new SimpleNode(this, JJTHOLD_AFTER_CON_GD); + boolean jjtc000 = true; + jjtree.openNodeScope(jjtn000); +/*@egen*/ + Token t = token; +} +{/*@bgen(jjtree) HOLD_AFTER_CON_GD */ + try { +/*@egen*/ + try { + t= gd() + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + }/*@bgen(jjtree)*/ + { + jjtree.closeNodeScope(jjtn000, true); + jjtc000 = false; + } +/*@egen*/ + { + jjtn000.setLine(t.beginLine); + jjtn000.setColumn(t.beginColumn); + return t; + }/*@bgen(jjtree)*/ + } catch (Throwable jjte000) { + if (jjtc000) { + jjtree.clearNodeScope(jjtn000); + jjtc000 = false; + } else { + jjtree.popNode(); + } + if (jjte000 instanceof RuntimeException) { + throw (RuntimeException)jjte000; + } + if (jjte000 instanceof ParseException) { + throw (ParseException)jjte000; + } + throw (Error)jjte000; + } finally { + if (jjtc000) { + jjtree.closeNodeScope(jjtn000, true); + } + } +/*@egen*/ +} + +Token gd() : +{/*@bgen(jjtree) GD */ + SimpleNode jjtn000 = new SimpleNode(this, JJTGD); + boolean jjtc000 = true; + jjtree.openNodeScope(jjtn000); +/*@egen*/ + Token t = token; +} +{/*@bgen(jjtree) GD */ + try { +/*@egen*/ + try { + LOOKAHEAD(2) t=atomic_formula(LexerTreeConstants.JJTTERM) +// | LOOKAHEAD(2) t=not_atomic_formula(LexerTreeConstants.JJTTERM) + | LOOKAHEAD(2) t=and_gd() + | LOOKAHEAD(2) t=or_gd() + | LOOKAHEAD(2) t=not_gd() + | LOOKAHEAD(2) t=imply_gd() + | LOOKAHEAD(2) t=exists_gd() + | LOOKAHEAD(2) t=forall_gd() + | LOOKAHEAD(2) t=f_comp() + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + }/*@bgen(jjtree)*/ + { + jjtree.closeNodeScope(jjtn000, true); + jjtc000 = false; + } +/*@egen*/ + { + jjtn000.setLine(t.beginLine); + jjtn000.setColumn(t.beginColumn); + return t; + }/*@bgen(jjtree)*/ + } catch (Throwable jjte000) { + if (jjtc000) { + jjtree.clearNodeScope(jjtn000); + jjtc000 = false; + } else { + jjtree.popNode(); + } + if (jjte000 instanceof RuntimeException) { + throw (RuntimeException)jjte000; + } + if (jjte000 instanceof ParseException) { + throw (ParseException)jjte000; + } + throw (Error)jjte000; + } finally { + if (jjtc000) { + jjtree.closeNodeScope(jjtn000, true); + } + } +/*@egen*/ +} + +Token and_gd() : +{/*@bgen(jjtree) AND_GD */ + SimpleNode jjtn000 = new SimpleNode(this, JJTAND_GD); + boolean jjtc000 = true; + jjtree.openNodeScope(jjtn000); +/*@egen*/ + Token t = token; +} +{/*@bgen(jjtree) AND_GD */ + try { +/*@egen*/ + try { + t= (gd())* + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + }/*@bgen(jjtree)*/ + { + jjtree.closeNodeScope(jjtn000, true); + jjtc000 = false; + } +/*@egen*/ + { + jjtn000.setLine(t.beginLine); + jjtn000.setColumn(t.beginColumn); + return t; + }/*@bgen(jjtree)*/ + } catch (Throwable jjte000) { + if (jjtc000) { + jjtree.clearNodeScope(jjtn000); + jjtc000 = false; + } else { + jjtree.popNode(); + } + if (jjte000 instanceof RuntimeException) { + throw (RuntimeException)jjte000; + } + if (jjte000 instanceof ParseException) { + throw (ParseException)jjte000; + } + throw (Error)jjte000; + } finally { + if (jjtc000) { + jjtree.closeNodeScope(jjtn000, true); + } + } +/*@egen*/ +} + +Token or_gd() : +{/*@bgen(jjtree) OR_GD */ + SimpleNode jjtn000 = new SimpleNode(this, JJTOR_GD); + boolean jjtc000 = true; + jjtree.openNodeScope(jjtn000); +/*@egen*/ + Token t = token; +} +{/*@bgen(jjtree) OR_GD */ + try { +/*@egen*/ + try { + t= (gd())* + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + }/*@bgen(jjtree)*/ + { + jjtree.closeNodeScope(jjtn000, true); + jjtc000 = false; + } +/*@egen*/ + { + jjtn000.setLine(t.beginLine); + jjtn000.setColumn(t.beginColumn); + return t; + }/*@bgen(jjtree)*/ + } catch (Throwable jjte000) { + if (jjtc000) { + jjtree.clearNodeScope(jjtn000); + jjtc000 = false; + } else { + jjtree.popNode(); + } + if (jjte000 instanceof RuntimeException) { + throw (RuntimeException)jjte000; + } + if (jjte000 instanceof ParseException) { + throw (ParseException)jjte000; + } + throw (Error)jjte000; + } finally { + if (jjtc000) { + jjtree.closeNodeScope(jjtn000, true); + } + } +/*@egen*/ +} + +Token not_gd() : +{/*@bgen(jjtree) NOT_GD */ + SimpleNode jjtn000 = new SimpleNode(this, JJTNOT_GD); + boolean jjtc000 = true; + jjtree.openNodeScope(jjtn000); +/*@egen*/ + Token t = token; +} +{/*@bgen(jjtree) NOT_GD */ + try { +/*@egen*/ + try { + t= gd() + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + }/*@bgen(jjtree)*/ + { + jjtree.closeNodeScope(jjtn000, true); + jjtc000 = false; + } +/*@egen*/ + { + jjtn000.setLine(t.beginLine); + jjtn000.setColumn(t.beginColumn); + return t; + }/*@bgen(jjtree)*/ + } catch (Throwable jjte000) { + if (jjtc000) { + jjtree.clearNodeScope(jjtn000); + jjtc000 = false; + } else { + jjtree.popNode(); + } + if (jjte000 instanceof RuntimeException) { + throw (RuntimeException)jjte000; + } + if (jjte000 instanceof ParseException) { + throw (ParseException)jjte000; + } + throw (Error)jjte000; + } finally { + if (jjtc000) { + jjtree.closeNodeScope(jjtn000, true); + } + } +/*@egen*/ +} + +Token imply_gd() : +{/*@bgen(jjtree) IMPLY_GD */ + SimpleNode jjtn000 = new SimpleNode(this, JJTIMPLY_GD); + boolean jjtc000 = true; + jjtree.openNodeScope(jjtn000); +/*@egen*/ + Token t = token; +} +{/*@bgen(jjtree) IMPLY_GD */ + try { +/*@egen*/ + try { + t= gd() gd() + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + }/*@bgen(jjtree)*/ + { + jjtree.closeNodeScope(jjtn000, true); + jjtc000 = false; + } +/*@egen*/ + { + jjtn000.setLine(t.beginLine); + jjtn000.setColumn(t.beginColumn); + return t; + }/*@bgen(jjtree)*/ + } catch (Throwable jjte000) { + if (jjtc000) { + jjtree.clearNodeScope(jjtn000); + jjtc000 = false; + } else { + jjtree.popNode(); + } + if (jjte000 instanceof RuntimeException) { + throw (RuntimeException)jjte000; + } + if (jjte000 instanceof ParseException) { + throw (ParseException)jjte000; + } + throw (Error)jjte000; + } finally { + if (jjtc000) { + jjtree.closeNodeScope(jjtn000, true); + } + } +/*@egen*/ +} + +Token exists_gd() : +{/*@bgen(jjtree) EXISTS_GD */ + SimpleNode jjtn000 = new SimpleNode(this, JJTEXISTS_GD); + boolean jjtc000 = true; + jjtree.openNodeScope(jjtn000); +/*@egen*/ + Token t = token; +} +{/*@bgen(jjtree) EXISTS_GD */ + try { +/*@egen*/ + try { + t= typed_list(LexerTreeConstants.JJTVARIABLE) gd() + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + }/*@bgen(jjtree)*/ + { + jjtree.closeNodeScope(jjtn000, true); + jjtc000 = false; + } +/*@egen*/ + { + jjtn000.setLine(t.beginLine); + jjtn000.setColumn(t.beginColumn); + return t; + }/*@bgen(jjtree)*/ + } catch (Throwable jjte000) { + if (jjtc000) { + jjtree.clearNodeScope(jjtn000); + jjtc000 = false; + } else { + jjtree.popNode(); + } + if (jjte000 instanceof RuntimeException) { + throw (RuntimeException)jjte000; + } + if (jjte000 instanceof ParseException) { + throw (ParseException)jjte000; + } + throw (Error)jjte000; + } finally { + if (jjtc000) { + jjtree.closeNodeScope(jjtn000, true); + } + } +/*@egen*/ +} + +Token forall_gd() : +{/*@bgen(jjtree) FORALL_GD */ + SimpleNode jjtn000 = new SimpleNode(this, JJTFORALL_GD); + boolean jjtc000 = true; + jjtree.openNodeScope(jjtn000); +/*@egen*/ + Token t = token; +} +{/*@bgen(jjtree) FORALL_GD */ + try { +/*@egen*/ + try { + t= typed_list(LexerTreeConstants.JJTVARIABLE) gd() + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + }/*@bgen(jjtree)*/ + { + jjtree.closeNodeScope(jjtn000, true); + jjtc000 = false; + } +/*@egen*/ + { + jjtn000.setLine(t.beginLine); + jjtn000.setColumn(t.beginColumn); + return t; + }/*@bgen(jjtree)*/ + } catch (Throwable jjte000) { + if (jjtc000) { + jjtree.clearNodeScope(jjtn000); + jjtc000 = false; + } else { + jjtree.popNode(); + } + if (jjte000 instanceof RuntimeException) { + throw (RuntimeException)jjte000; + } + if (jjte000 instanceof ParseException) { + throw (ParseException)jjte000; + } + throw (Error)jjte000; + } finally { + if (jjtc000) { + jjtree.closeNodeScope(jjtn000, true); + } + } +/*@egen*/ +} + +Token atomic_formula(int type) : +{/*@bgen(jjtree) ATOMIC_FORMULA */ + SimpleNode jjtn000 = new SimpleNode(this, JJTATOMIC_FORMULA); + boolean jjtc000 = true; + jjtree.openNodeScope(jjtn000); +/*@egen*/ + Token t = token; +} +{/*@bgen(jjtree) ATOMIC_FORMULA */ + try { +/*@egen*/ + try { + t= predicate() ( + LOOKAHEAD({ type == LexerTreeConstants.JJTCONSTANT } ) (constant())* { + jjtn000.setTypeId(LexerTreeConstants.JJTCONSTANT); + } + | LOOKAHEAD({ type == LexerTreeConstants.JJTTERM }) (term())* { + jjtn000.setTypeId(LexerTreeConstants.JJTTERM); + } + ) + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + }/*@bgen(jjtree)*/ + { + jjtree.closeNodeScope(jjtn000, true); + jjtc000 = false; + } +/*@egen*/ + { + jjtn000.setLine(t.beginLine); + jjtn000.setColumn(t.beginColumn); + return t; + }/*@bgen(jjtree)*/ + } catch (Throwable jjte000) { + if (jjtc000) { + jjtree.clearNodeScope(jjtn000); + jjtc000 = false; + } else { + jjtree.popNode(); + } + if (jjte000 instanceof RuntimeException) { + throw (RuntimeException)jjte000; + } + if (jjte000 instanceof ParseException) { + throw (ParseException)jjte000; + } + throw (Error)jjte000; + } finally { + if (jjtc000) { + jjtree.closeNodeScope(jjtn000, true); + } + } +/*@egen*/ +} + +Token term() : +{/*@bgen(jjtree) TERM */ + SimpleNode jjtn000 = new SimpleNode(this, JJTTERM); + boolean jjtc000 = true; + jjtree.openNodeScope(jjtn000); +/*@egen*/ + Token t = token; +} +{/*@bgen(jjtree) TERM */ + try { +/*@egen*/ + try { + t=constant() + | t=variable() + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + }/*@bgen(jjtree)*/ + { + jjtree.closeNodeScope(jjtn000, true); + jjtc000 = false; + } +/*@egen*/ + { + jjtn000.setLine(t.beginLine); + jjtn000.setColumn(t.beginColumn); + return t; + }/*@bgen(jjtree)*/ + } catch (Throwable jjte000) { + if (jjtc000) { + jjtree.clearNodeScope(jjtn000); + jjtc000 = false; + } else { + jjtree.popNode(); + } + if (jjte000 instanceof RuntimeException) { + throw (RuntimeException)jjte000; + } + if (jjte000 instanceof ParseException) { + throw (ParseException)jjte000; + } + throw (Error)jjte000; + } finally { + if (jjtc000) { + jjtree.closeNodeScope(jjtn000, true); + } + } +/*@egen*/ +} + +Token literal(int type) : +{/*@bgen(jjtree) LITERAL */ + SimpleNode jjtn000 = new SimpleNode(this, JJTLITERAL); + boolean jjtc000 = true; + jjtree.openNodeScope(jjtn000); +/*@egen*/ + Token t = token; +} +{/*@bgen(jjtree) LITERAL */ + try { +/*@egen*/ + + try { + LOOKAHEAD(2) t=atomic_formula(type) + | LOOKAHEAD(2) t=not_atomic_formula(type) + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + }/*@bgen(jjtree)*/ + { + jjtree.closeNodeScope(jjtn000, true); + jjtc000 = false; + } +/*@egen*/ + { + jjtn000.setLine(t.beginLine); + jjtn000.setColumn(t.beginColumn); + return t; + }/*@bgen(jjtree)*/ + } catch (Throwable jjte000) { + if (jjtc000) { + jjtree.clearNodeScope(jjtn000); + jjtc000 = false; + } else { + jjtree.popNode(); + } + if (jjte000 instanceof RuntimeException) { + throw (RuntimeException)jjte000; + } + if (jjte000 instanceof ParseException) { + throw (ParseException)jjte000; + } + throw (Error)jjte000; + } finally { + if (jjtc000) { + jjtree.closeNodeScope(jjtn000, true); + } + } +/*@egen*/ +} + +Token not_atomic_formula(int type) : +{/*@bgen(jjtree) NOT_ATOMIC_FORMULA */ + SimpleNode jjtn000 = new SimpleNode(this, JJTNOT_ATOMIC_FORMULA); + boolean jjtc000 = true; + jjtree.openNodeScope(jjtn000); +/*@egen*/ + Token t = token; +} +{/*@bgen(jjtree) NOT_ATOMIC_FORMULA */ + try { +/*@egen*/ + try { + t= atomic_formula(type) + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + }/*@bgen(jjtree)*/ + { + jjtree.closeNodeScope(jjtn000, true); + jjtc000 = false; + } +/*@egen*/ + { + jjtn000.setLine(t.beginLine); + jjtn000.setColumn(t.beginColumn); + return t; + }/*@bgen(jjtree)*/ + } catch (Throwable jjte000) { + if (jjtc000) { + jjtree.clearNodeScope(jjtn000); + jjtc000 = false; + } else { + jjtree.popNode(); + } + if (jjte000 instanceof RuntimeException) { + throw (RuntimeException)jjte000; + } + if (jjte000 instanceof ParseException) { + throw (ParseException)jjte000; + } + throw (Error)jjte000; + } finally { + if (jjtc000) { + jjtree.closeNodeScope(jjtn000, true); + } + } +/*@egen*/ +} + +Token f_comp() : +{/*@bgen(jjtree) F_COMP */ + SimpleNode jjtn000 = new SimpleNode(this, JJTF_COMP); + boolean jjtc000 = true; + jjtree.openNodeScope(jjtn000); +/*@egen*/ + Token t = token; +} +{/*@bgen(jjtree) F_COMP */ + try { +/*@egen*/ + try { + t=binary_comp() + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + }/*@bgen(jjtree)*/ + { + jjtree.closeNodeScope(jjtn000, true); + jjtc000 = false; + } +/*@egen*/ + { + jjtn000.setLine(t.beginLine); + jjtn000.setColumn(t.beginColumn); + return t; + }/*@bgen(jjtree)*/ + } catch (Throwable jjte000) { + if (jjtc000) { + jjtree.clearNodeScope(jjtn000); + jjtc000 = false; + } else { + jjtree.popNode(); + } + if (jjte000 instanceof RuntimeException) { + throw (RuntimeException)jjte000; + } + if (jjte000 instanceof ParseException) { + throw (ParseException)jjte000; + } + throw (Error)jjte000; + } finally { + if (jjtc000) { + jjtree.closeNodeScope(jjtn000, true); + } + } +/*@egen*/ +} + +Token binary_comp() : +{/*@bgen(jjtree) BINARY_COMP */ + SimpleNode jjtn000 = new SimpleNode(this, JJTBINARY_COMP); + boolean jjtc000 = true; + jjtree.openNodeScope(jjtn000); +/*@egen*/ + Token t = token; +} +{/*@bgen(jjtree) BINARY_COMP */ + try { +/*@egen*/ + try { + LOOKAHEAD(2) t=greater_comp() + | LOOKAHEAD(2) t=less_comp() + | LOOKAHEAD(2) t=greater_equal_comp() + | LOOKAHEAD(2) t=less_equal_comp() + | LOOKAHEAD(2) t=equal_comp() + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + }/*@bgen(jjtree)*/ + { + jjtree.closeNodeScope(jjtn000, true); + jjtc000 = false; + } +/*@egen*/ + { + jjtn000.setLine(t.beginLine); + jjtn000.setColumn(t.beginColumn); + return t; + }/*@bgen(jjtree)*/ + } catch (Throwable jjte000) { + if (jjtc000) { + jjtree.clearNodeScope(jjtn000); + jjtc000 = false; + } else { + jjtree.popNode(); + } + if (jjte000 instanceof RuntimeException) { + throw (RuntimeException)jjte000; + } + if (jjte000 instanceof ParseException) { + throw (ParseException)jjte000; + } + throw (Error)jjte000; + } finally { + if (jjtc000) { + jjtree.closeNodeScope(jjtn000, true); + } + } +/*@egen*/ +} + +Token greater_comp() : +{/*@bgen(jjtree) GREATER_COMP */ + SimpleNode jjtn000 = new SimpleNode(this, JJTGREATER_COMP); + boolean jjtc000 = true; + jjtree.openNodeScope(jjtn000); +/*@egen*/ + Token t = token; +} +{/*@bgen(jjtree) GREATER_COMP */ + try { +/*@egen*/ + try { + t= f_exp() f_exp() + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + }/*@bgen(jjtree)*/ + { + jjtree.closeNodeScope(jjtn000, true); + jjtc000 = false; + } +/*@egen*/ + { + jjtn000.setLine(t.beginLine); + jjtn000.setColumn(t.beginColumn); + return t; + }/*@bgen(jjtree)*/ + } catch (Throwable jjte000) { + if (jjtc000) { + jjtree.clearNodeScope(jjtn000); + jjtc000 = false; + } else { + jjtree.popNode(); + } + if (jjte000 instanceof RuntimeException) { + throw (RuntimeException)jjte000; + } + if (jjte000 instanceof ParseException) { + throw (ParseException)jjte000; + } + throw (Error)jjte000; + } finally { + if (jjtc000) { + jjtree.closeNodeScope(jjtn000, true); + } + } +/*@egen*/ +} + +Token greater_equal_comp() : +{/*@bgen(jjtree) GREATER_EQUAL_COMP */ + SimpleNode jjtn000 = new SimpleNode(this, JJTGREATER_EQUAL_COMP); + boolean jjtc000 = true; + jjtree.openNodeScope(jjtn000); +/*@egen*/ + Token t = token; +} +{/*@bgen(jjtree) GREATER_EQUAL_COMP */ + try { +/*@egen*/ + try { + t= f_exp() f_exp() + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + }/*@bgen(jjtree)*/ + { + jjtree.closeNodeScope(jjtn000, true); + jjtc000 = false; + } +/*@egen*/ + { + jjtn000.setLine(t.beginLine); + jjtn000.setColumn(t.beginColumn); + return t; + }/*@bgen(jjtree)*/ + } catch (Throwable jjte000) { + if (jjtc000) { + jjtree.clearNodeScope(jjtn000); + jjtc000 = false; + } else { + jjtree.popNode(); + } + if (jjte000 instanceof RuntimeException) { + throw (RuntimeException)jjte000; + } + if (jjte000 instanceof ParseException) { + throw (ParseException)jjte000; + } + throw (Error)jjte000; + } finally { + if (jjtc000) { + jjtree.closeNodeScope(jjtn000, true); + } + } +/*@egen*/ +} + +Token less_equal_comp() : +{/*@bgen(jjtree) LESS_EQUAL_COMP */ + SimpleNode jjtn000 = new SimpleNode(this, JJTLESS_EQUAL_COMP); + boolean jjtc000 = true; + jjtree.openNodeScope(jjtn000); +/*@egen*/ + Token t = token; +} +{/*@bgen(jjtree) LESS_EQUAL_COMP */ + try { +/*@egen*/ + try { + t= f_exp() f_exp() + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + }/*@bgen(jjtree)*/ + { + jjtree.closeNodeScope(jjtn000, true); + jjtc000 = false; + } +/*@egen*/ + { + jjtn000.setLine(t.beginLine); + jjtn000.setColumn(t.beginColumn); + return t; + }/*@bgen(jjtree)*/ + } catch (Throwable jjte000) { + if (jjtc000) { + jjtree.clearNodeScope(jjtn000); + jjtc000 = false; + } else { + jjtree.popNode(); + } + if (jjte000 instanceof RuntimeException) { + throw (RuntimeException)jjte000; + } + if (jjte000 instanceof ParseException) { + throw (ParseException)jjte000; + } + throw (Error)jjte000; + } finally { + if (jjtc000) { + jjtree.closeNodeScope(jjtn000, true); + } + } +/*@egen*/ +} + +Token less_comp() : +{/*@bgen(jjtree) LESS_COMP */ + SimpleNode jjtn000 = new SimpleNode(this, JJTLESS_COMP); + boolean jjtc000 = true; + jjtree.openNodeScope(jjtn000); +/*@egen*/ + Token t = token; +} +{/*@bgen(jjtree) LESS_COMP */ + try { +/*@egen*/ + try { + t= f_exp() f_exp() + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + }/*@bgen(jjtree)*/ + { + jjtree.closeNodeScope(jjtn000, true); + jjtc000 = false; + } +/*@egen*/ + { + jjtn000.setLine(t.beginLine); + jjtn000.setColumn(t.beginColumn); + return t; + }/*@bgen(jjtree)*/ + } catch (Throwable jjte000) { + if (jjtc000) { + jjtree.clearNodeScope(jjtn000); + jjtc000 = false; + } else { + jjtree.popNode(); + } + if (jjte000 instanceof RuntimeException) { + throw (RuntimeException)jjte000; + } + if (jjte000 instanceof ParseException) { + throw (ParseException)jjte000; + } + throw (Error)jjte000; + } finally { + if (jjtc000) { + jjtree.closeNodeScope(jjtn000, true); + } + } +/*@egen*/ +} + +Token equal_comp() : +{/*@bgen(jjtree) EQUAL_COMP */ + SimpleNode jjtn000 = new SimpleNode(this, JJTEQUAL_COMP); + boolean jjtc000 = true; + jjtree.openNodeScope(jjtn000); +/*@egen*/ + Token t = token; +} +{/*@bgen(jjtree) EQUAL_COMP */ + try { +/*@egen*/ + try { + t= f_exp() f_exp() + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + }/*@bgen(jjtree)*/ + { + jjtree.closeNodeScope(jjtn000, true); + jjtc000 = false; + } +/*@egen*/ + { + jjtn000.setLine(t.beginLine); + jjtn000.setColumn(t.beginColumn); + return t; + }/*@bgen(jjtree)*/ + } catch (Throwable jjte000) { + if (jjtc000) { + jjtree.clearNodeScope(jjtn000); + jjtc000 = false; + } else { + jjtree.popNode(); + } + if (jjte000 instanceof RuntimeException) { + throw (RuntimeException)jjte000; + } + if (jjte000 instanceof ParseException) { + throw (ParseException)jjte000; + } + throw (Error)jjte000; + } finally { + if (jjtc000) { + jjtree.closeNodeScope(jjtn000, true); + } + } +/*@egen*/ +} + +Token f_exp() : +{/*@bgen(jjtree) F_EXP */ + SimpleNode jjtn000 = new SimpleNode(this, JJTF_EXP); + boolean jjtc000 = true; + jjtree.openNodeScope(jjtn000); +/*@egen*/ + Token t = token; +} +{/*@bgen(jjtree) F_EXP */ + try { +/*@egen*/ + try { + t=number() + | LOOKAHEAD(2) t=op() + | LOOKAHEAD(2) t=f_head() + | LOOKAHEAD(2) t=variable() + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + }/*@bgen(jjtree)*/ + { + jjtree.closeNodeScope(jjtn000, true); + jjtc000 = false; + } +/*@egen*/ + { + jjtn000.setLine(t.beginLine); + jjtn000.setColumn(t.beginColumn); + return t; + }/*@bgen(jjtree)*/ + } catch (Throwable jjte000) { + if (jjtc000) { + jjtree.clearNodeScope(jjtn000); + jjtc000 = false; + } else { + jjtree.popNode(); + } + if (jjte000 instanceof RuntimeException) { + throw (RuntimeException)jjte000; + } + if (jjte000 instanceof ParseException) { + throw (ParseException)jjte000; + } + throw (Error)jjte000; + } finally { + if (jjtc000) { + jjtree.closeNodeScope(jjtn000, true); + } + } +/*@egen*/ +} + +Token number() : +{/*@bgen(jjtree) NUMBER */ + SimpleNode jjtn000 = new SimpleNode(this, JJTNUMBER); + boolean jjtc000 = true; + jjtree.openNodeScope(jjtn000); +/*@egen*/ + Token t = token; +} +{/*@bgen(jjtree) NUMBER */ + try { +/*@egen*/ + try { + t = + + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + }/*@bgen(jjtree)*/ + { + jjtree.closeNodeScope(jjtn000, true); + jjtc000 = false; + } +/*@egen*/ + { + + jjtn000.setLine(t.beginLine); + jjtn000.setColumn(t.beginColumn); + jjtn000.setImage(t.image); + return t; + }/*@bgen(jjtree)*/ + } finally { + if (jjtc000) { + jjtree.closeNodeScope(jjtn000, true); + } + } +/*@egen*/ +} + +Token op() : +{/*@bgen(jjtree) OP */ + SimpleNode jjtn000 = new SimpleNode(this, JJTOP); + boolean jjtc000 = true; + jjtree.openNodeScope(jjtn000); +/*@egen*/ + Token t = token; +} +{/*@bgen(jjtree) OP */ + try { +/*@egen*/ + try { + LOOKAHEAD(2) t=binary_operation() + | LOOKAHEAD(2) t=unary_op() + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + }/*@bgen(jjtree)*/ + { + jjtree.closeNodeScope(jjtn000, true); + jjtc000 = false; + } +/*@egen*/ + { + jjtn000.setLine(t.beginLine); + jjtn000.setColumn(t.beginColumn); + return t; + }/*@bgen(jjtree)*/ + } catch (Throwable jjte000) { + if (jjtc000) { + jjtree.clearNodeScope(jjtn000); + jjtc000 = false; + } else { + jjtree.popNode(); + } + if (jjte000 instanceof RuntimeException) { + throw (RuntimeException)jjte000; + } + if (jjte000 instanceof ParseException) { + throw (ParseException)jjte000; + } + throw (Error)jjte000; + } finally { + if (jjtc000) { + jjtree.closeNodeScope(jjtn000, true); + } + } +/*@egen*/ +} + +Token binary_operation() : +{/*@bgen(jjtree) BINARY_OPERATION */ + SimpleNode jjtn000 = new SimpleNode(this, JJTBINARY_OPERATION); + boolean jjtc000 = true; + jjtree.openNodeScope(jjtn000); +/*@egen*/ + Token t = token; +} +{/*@bgen(jjtree) BINARY_OPERATION */ + try { +/*@egen*/ + try{ + LOOKAHEAD(2) t=add_op() + | LOOKAHEAD(2) t=substract_op() + | LOOKAHEAD(2) t=multiply_op() + | LOOKAHEAD(2) t=divide_op() + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + }/*@bgen(jjtree)*/ + { + jjtree.closeNodeScope(jjtn000, true); + jjtc000 = false; + } +/*@egen*/ + { + jjtn000.setLine(t.beginLine); + jjtn000.setColumn(t.beginColumn); + return t; + }/*@bgen(jjtree)*/ + } catch (Throwable jjte000) { + if (jjtc000) { + jjtree.clearNodeScope(jjtn000); + jjtc000 = false; + } else { + jjtree.popNode(); + } + if (jjte000 instanceof RuntimeException) { + throw (RuntimeException)jjte000; + } + if (jjte000 instanceof ParseException) { + throw (ParseException)jjte000; + } + throw (Error)jjte000; + } finally { + if (jjtc000) { + jjtree.closeNodeScope(jjtn000, true); + } + } +/*@egen*/ +} + +Token add_op() : +{/*@bgen(jjtree) ADD_OP */ + SimpleNode jjtn000 = new SimpleNode(this, JJTADD_OP); + boolean jjtc000 = true; + jjtree.openNodeScope(jjtn000); +/*@egen*/ + Token t = token; +} +{/*@bgen(jjtree) ADD_OP */ + try { +/*@egen*/ + try { + t= f_exp() f_exp() + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + }/*@bgen(jjtree)*/ + { + jjtree.closeNodeScope(jjtn000, true); + jjtc000 = false; + } +/*@egen*/ + { + jjtn000.setLine(t.beginLine); + jjtn000.setColumn(t.beginColumn); + return t; + }/*@bgen(jjtree)*/ + } catch (Throwable jjte000) { + if (jjtc000) { + jjtree.clearNodeScope(jjtn000); + jjtc000 = false; + } else { + jjtree.popNode(); + } + if (jjte000 instanceof RuntimeException) { + throw (RuntimeException)jjte000; + } + if (jjte000 instanceof ParseException) { + throw (ParseException)jjte000; + } + throw (Error)jjte000; + } finally { + if (jjtc000) { + jjtree.closeNodeScope(jjtn000, true); + } + } +/*@egen*/ +} + +Token substract_op() : +{/*@bgen(jjtree) SUBSTRACT_OP */ + SimpleNode jjtn000 = new SimpleNode(this, JJTSUBSTRACT_OP); + boolean jjtc000 = true; + jjtree.openNodeScope(jjtn000); +/*@egen*/ + Token t = token; +} +{/*@bgen(jjtree) SUBSTRACT_OP */ + try { +/*@egen*/ + try { + t= f_exp() f_exp() + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + }/*@bgen(jjtree)*/ + { + jjtree.closeNodeScope(jjtn000, true); + jjtc000 = false; + } +/*@egen*/ + { + jjtn000.setLine(t.beginLine); + jjtn000.setColumn(t.beginColumn); + return t; + }/*@bgen(jjtree)*/ + } catch (Throwable jjte000) { + if (jjtc000) { + jjtree.clearNodeScope(jjtn000); + jjtc000 = false; + } else { + jjtree.popNode(); + } + if (jjte000 instanceof RuntimeException) { + throw (RuntimeException)jjte000; + } + if (jjte000 instanceof ParseException) { + throw (ParseException)jjte000; + } + throw (Error)jjte000; + } finally { + if (jjtc000) { + jjtree.closeNodeScope(jjtn000, true); + } + } +/*@egen*/ +} + +Token multiply_op() : +{/*@bgen(jjtree) MULTIPLY_OP */ + SimpleNode jjtn000 = new SimpleNode(this, JJTMULTIPLY_OP); + boolean jjtc000 = true; + jjtree.openNodeScope(jjtn000); +/*@egen*/ + Token t = token; +} +{/*@bgen(jjtree) MULTIPLY_OP */ + try { +/*@egen*/ + try { + t= f_exp() f_exp() + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + }/*@bgen(jjtree)*/ + { + jjtree.closeNodeScope(jjtn000, true); + jjtc000 = false; + } +/*@egen*/ + { + jjtn000.setLine(t.beginLine); + jjtn000.setColumn(t.beginColumn); + return t; + }/*@bgen(jjtree)*/ + } catch (Throwable jjte000) { + if (jjtc000) { + jjtree.clearNodeScope(jjtn000); + jjtc000 = false; + } else { + jjtree.popNode(); + } + if (jjte000 instanceof RuntimeException) { + throw (RuntimeException)jjte000; + } + if (jjte000 instanceof ParseException) { + throw (ParseException)jjte000; + } + throw (Error)jjte000; + } finally { + if (jjtc000) { + jjtree.closeNodeScope(jjtn000, true); + } + } +/*@egen*/ +} + +Token divide_op() : +{/*@bgen(jjtree) DIVIDE_OP */ + SimpleNode jjtn000 = new SimpleNode(this, JJTDIVIDE_OP); + boolean jjtc000 = true; + jjtree.openNodeScope(jjtn000); +/*@egen*/ + Token t = token; +} +{/*@bgen(jjtree) DIVIDE_OP */ + try { +/*@egen*/ + try { + t=
f_exp() f_exp() + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + }/*@bgen(jjtree)*/ + { + jjtree.closeNodeScope(jjtn000, true); + jjtc000 = false; + } +/*@egen*/ + { + jjtn000.setLine(t.beginLine); + jjtn000.setColumn(t.beginColumn); + return t; + }/*@bgen(jjtree)*/ + } catch (Throwable jjte000) { + if (jjtc000) { + jjtree.clearNodeScope(jjtn000); + jjtc000 = false; + } else { + jjtree.popNode(); + } + if (jjte000 instanceof RuntimeException) { + throw (RuntimeException)jjte000; + } + if (jjte000 instanceof ParseException) { + throw (ParseException)jjte000; + } + throw (Error)jjte000; + } finally { + if (jjtc000) { + jjtree.closeNodeScope(jjtn000, true); + } + } +/*@egen*/ +} + +Token unary_op() : +{/*@bgen(jjtree) UNARY_OP */ + SimpleNode jjtn000 = new SimpleNode(this, JJTUNARY_OP); + boolean jjtc000 = true; + jjtree.openNodeScope(jjtn000); +/*@egen*/ + Token t = token; +} +{/*@bgen(jjtree) UNARY_OP */ + try { +/*@egen*/ + try { + t= f_exp_da() + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + }/*@bgen(jjtree)*/ + { + jjtree.closeNodeScope(jjtn000, true); + jjtc000 = false; + } +/*@egen*/ + { + jjtn000.setLine(t.beginLine); + jjtn000.setColumn(t.beginColumn); + return t; + }/*@bgen(jjtree)*/ + } catch (Throwable jjte000) { + if (jjtc000) { + jjtree.clearNodeScope(jjtn000); + jjtc000 = false; + } else { + jjtree.popNode(); + } + if (jjte000 instanceof RuntimeException) { + throw (RuntimeException)jjte000; + } + if (jjte000 instanceof ParseException) { + throw (ParseException)jjte000; + } + throw (Error)jjte000; + } finally { + if (jjtc000) { + jjtree.closeNodeScope(jjtn000, true); + } + } +/*@egen*/ +} + +Token f_head() : +{/*@bgen(jjtree) F_HEAD */ + SimpleNode jjtn000 = new SimpleNode(this, JJTF_HEAD); + boolean jjtc000 = true; + jjtree.openNodeScope(jjtn000); +/*@egen*/ + Token t = token; +} +{/*@bgen(jjtree) F_HEAD */ + try { +/*@egen*/ + try { + t= functor() (term())* + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + }/*@bgen(jjtree)*/ + { + jjtree.closeNodeScope(jjtn000, true); + jjtc000 = false; + } +/*@egen*/ + { + jjtn000.setLine(t.beginLine); + jjtn000.setColumn(t.beginColumn); + return t; + }/*@bgen(jjtree)*/ + } catch (Throwable jjte000) { + if (jjtc000) { + jjtree.clearNodeScope(jjtn000); + jjtc000 = false; + } else { + jjtree.popNode(); + } + if (jjte000 instanceof RuntimeException) { + throw (RuntimeException)jjte000; + } + if (jjte000 instanceof ParseException) { + throw (ParseException)jjte000; + } + throw (Error)jjte000; + } finally { + if (jjtc000) { + jjtree.closeNodeScope(jjtn000, true); + } + } +/*@egen*/ +} + +Token structure_def() : +{/*@bgen(jjtree) STRUCTURE_DEF */ + SimpleNode jjtn000 = new SimpleNode(this, JJTSTRUCTURE_DEF); + boolean jjtc000 = true; + jjtree.openNodeScope(jjtn000); +/*@egen*/ + Token t = token; +} +{/*@bgen(jjtree) STRUCTURE_DEF */ + try { +/*@egen*/ + try { + LOOKAHEAD(2) t=action_def() + | LOOKAHEAD(2) t=durative_action_def() + | LOOKAHEAD(2) t=derived_def() + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + }/*@bgen(jjtree)*/ + { + jjtree.closeNodeScope(jjtn000, true); + jjtc000 = false; + } +/*@egen*/ + { + jjtn000.setLine(t.beginLine); + jjtn000.setColumn(t.beginColumn); + return t; + }/*@bgen(jjtree)*/ + } catch (Throwable jjte000) { + if (jjtc000) { + jjtree.clearNodeScope(jjtn000); + jjtc000 = false; + } else { + jjtree.popNode(); + } + if (jjte000 instanceof RuntimeException) { + throw (RuntimeException)jjte000; + } + if (jjte000 instanceof ParseException) { + throw (ParseException)jjte000; + } + throw (Error)jjte000; + } finally { + if (jjtc000) { + jjtree.closeNodeScope(jjtn000, true); + } + } +/*@egen*/ +} + +Token action_def() : +{/*@bgen(jjtree) ACTION_DEF */ + SimpleNode jjtn000 = new SimpleNode(this, JJTACTION_DEF); + boolean jjtc000 = true; + jjtree.openNodeScope(jjtn000); +/*@egen*/ + Token t = token; +} +{/*@bgen(jjtree) ACTION_DEF */ + try { +/*@egen*/ + try { + t= action_name() + typed_list(LexerTreeConstants.JJTVARIABLE) + action_def_body() + + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + }/*@bgen(jjtree)*/ + { + jjtree.closeNodeScope(jjtn000, true); + jjtc000 = false; + } +/*@egen*/ + { + jjtn000.setLine(t.beginLine); + jjtn000.setColumn(t.beginColumn); + return t; + }/*@bgen(jjtree)*/ + } catch (Throwable jjte000) { + if (jjtc000) { + jjtree.clearNodeScope(jjtn000); + jjtc000 = false; + } else { + jjtree.popNode(); + } + if (jjte000 instanceof RuntimeException) { + throw (RuntimeException)jjte000; + } + if (jjte000 instanceof ParseException) { + throw (ParseException)jjte000; + } + throw (Error)jjte000; + } finally { + if (jjtc000) { + jjtree.closeNodeScope(jjtn000, true); + } + } +/*@egen*/ +} + +Token action_name() : +{/*@bgen(jjtree) ACTION_NAME */ + SimpleNode jjtn000 = new SimpleNode(this, JJTACTION_NAME); + boolean jjtc000 = true; + jjtree.openNodeScope(jjtn000); +/*@egen*/ + Token t = token; +} +{/*@bgen(jjtree) ACTION_NAME */ + try { +/*@egen*/ + try { + t= + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + }/*@bgen(jjtree)*/ + { + jjtree.closeNodeScope(jjtn000, true); + jjtc000 = false; + } +/*@egen*/ + { + jjtn000.setLine(t.beginLine); + jjtn000.setColumn(t.beginColumn); + jjtn000.setImage(t.image); + return t; + }/*@bgen(jjtree)*/ + } finally { + if (jjtc000) { + jjtree.closeNodeScope(jjtn000, true); + } + } +/*@egen*/ +} + +Token action_def_body() : +{/*@bgen(jjtree) ACTION_DEF_BODY */ + SimpleNode jjtn000 = new SimpleNode(this, JJTACTION_DEF_BODY); + boolean jjtc000 = true; + jjtree.openNodeScope(jjtn000); +/*@egen*/ + Token t = token; +} +{/*@bgen(jjtree) ACTION_DEF_BODY */ + try { +/*@egen*/ + try { + t= pre_gd() + effect() + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + }/*@bgen(jjtree)*/ + { + jjtree.closeNodeScope(jjtn000, true); + jjtc000 = false; + } +/*@egen*/ + { + jjtn000.setLine(t.beginLine); + jjtn000.setColumn(t.beginColumn); + return t; + }/*@bgen(jjtree)*/ + } catch (Throwable jjte000) { + if (jjtc000) { + jjtree.clearNodeScope(jjtn000); + jjtc000 = false; + } else { + jjtree.popNode(); + } + if (jjte000 instanceof RuntimeException) { + throw (RuntimeException)jjte000; + } + if (jjte000 instanceof ParseException) { + throw (ParseException)jjte000; + } + throw (Error)jjte000; + } finally { + if (jjtc000) { + jjtree.closeNodeScope(jjtn000, true); + } + } +/*@egen*/ +} + +Token pre_gd() : +{/*@bgen(jjtree) PRE_GD */ + SimpleNode jjtn000 = new SimpleNode(this, JJTPRE_GD); + boolean jjtc000 = true; + jjtree.openNodeScope(jjtn000); +/*@egen*/ + Token t = token; +} +{/*@bgen(jjtree) PRE_GD */ + try { +/*@egen*/ + try { + LOOKAHEAD(2) t=empty_or() + | LOOKAHEAD(2) t=pref_gd() + | LOOKAHEAD(2) t=and_pre_gd() + | LOOKAHEAD(2) t=forall_pre_gd() + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + }/*@bgen(jjtree)*/ + { + jjtree.closeNodeScope(jjtn000, true); + jjtc000 = false; + } +/*@egen*/ + { + jjtn000.setLine(t.beginLine); + jjtn000.setColumn(t.beginColumn); + return t; + }/*@bgen(jjtree)*/ + } catch (Throwable jjte000) { + if (jjtc000) { + jjtree.clearNodeScope(jjtn000); + jjtc000 = false; + } else { + jjtree.popNode(); + } + if (jjte000 instanceof RuntimeException) { + throw (RuntimeException)jjte000; + } + if (jjte000 instanceof ParseException) { + throw (ParseException)jjte000; + } + throw (Error)jjte000; + } finally { + if (jjtc000) { + jjtree.closeNodeScope(jjtn000, true); + } + } +/*@egen*/ +} + +Token empty_or() : +{/*@bgen(jjtree) EMPTY_OR */ + SimpleNode jjtn000 = new SimpleNode(this, JJTEMPTY_OR); + boolean jjtc000 = true; + jjtree.openNodeScope(jjtn000); +/*@egen*/ + Token t = token; +} +{/*@bgen(jjtree) EMPTY_OR */ + try { +/*@egen*/ + try { + t= + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + }/*@bgen(jjtree)*/ + { + jjtree.closeNodeScope(jjtn000, true); + jjtc000 = false; + } +/*@egen*/ + { + jjtn000.setLine(t.beginLine); + jjtn000.setColumn(t.beginColumn); + return t; + }/*@bgen(jjtree)*/ + } finally { + if (jjtc000) { + jjtree.closeNodeScope(jjtn000, true); + } + } +/*@egen*/ +} + +Token and_pre_gd() : +{/*@bgen(jjtree) AND_PRE_GD */ + SimpleNode jjtn000 = new SimpleNode(this, JJTAND_PRE_GD); + boolean jjtc000 = true; + jjtree.openNodeScope(jjtn000); +/*@egen*/ + Token t = token; +} +{/*@bgen(jjtree) AND_PRE_GD */ + try { +/*@egen*/ + try { + t= (pre_gd())* + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + }/*@bgen(jjtree)*/ + { + jjtree.closeNodeScope(jjtn000, true); + jjtc000 = false; + } +/*@egen*/ + { + jjtn000.setLine(t.beginLine); + jjtn000.setColumn(t.beginColumn); + return t; + }/*@bgen(jjtree)*/ + } catch (Throwable jjte000) { + if (jjtc000) { + jjtree.clearNodeScope(jjtn000); + jjtc000 = false; + } else { + jjtree.popNode(); + } + if (jjte000 instanceof RuntimeException) { + throw (RuntimeException)jjte000; + } + if (jjte000 instanceof ParseException) { + throw (ParseException)jjte000; + } + throw (Error)jjte000; + } finally { + if (jjtc000) { + jjtree.closeNodeScope(jjtn000, true); + } + } +/*@egen*/ +} + +Token forall_pre_gd() : +{/*@bgen(jjtree) FORALL_PRE_GD */ + SimpleNode jjtn000 = new SimpleNode(this, JJTFORALL_PRE_GD); + boolean jjtc000 = true; + jjtree.openNodeScope(jjtn000); +/*@egen*/ + Token t = token; +} +{/*@bgen(jjtree) FORALL_PRE_GD */ + try { +/*@egen*/ + try { + t= typed_list(LexerTreeConstants.JJTVARIABLE) pre_gd() + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + }/*@bgen(jjtree)*/ + { + jjtree.closeNodeScope(jjtn000, true); + jjtc000 = false; + } +/*@egen*/ + { + jjtn000.setLine(t.beginLine); + jjtn000.setColumn(t.beginColumn); + return t; + }/*@bgen(jjtree)*/ + } catch (Throwable jjte000) { + if (jjtc000) { + jjtree.clearNodeScope(jjtn000); + jjtc000 = false; + } else { + jjtree.popNode(); + } + if (jjte000 instanceof RuntimeException) { + throw (RuntimeException)jjte000; + } + if (jjte000 instanceof ParseException) { + throw (ParseException)jjte000; + } + throw (Error)jjte000; + } finally { + if (jjtc000) { + jjtree.closeNodeScope(jjtn000, true); + } + } +/*@egen*/ +} + +Token pref_gd() : +{/*@bgen(jjtree) PREF_GD */ + SimpleNode jjtn000 = new SimpleNode(this, JJTPREF_GD); + boolean jjtc000 = true; + jjtree.openNodeScope(jjtn000); +/*@egen*/ + Token t = token; +} +{/*@bgen(jjtree) PREF_GD */ + try { +/*@egen*/ + try { + LOOKAHEAD(2) t=named_pref_gd() + | t=gd() + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + }/*@bgen(jjtree)*/ + { + jjtree.closeNodeScope(jjtn000, true); + jjtc000 = false; + } +/*@egen*/ + { + jjtn000.setLine(t.beginLine); + jjtn000.setColumn(t.beginColumn); + return t; + }/*@bgen(jjtree)*/ + } catch (Throwable jjte000) { + if (jjtc000) { + jjtree.clearNodeScope(jjtn000); + jjtc000 = false; + } else { + jjtree.popNode(); + } + if (jjte000 instanceof RuntimeException) { + throw (RuntimeException)jjte000; + } + if (jjte000 instanceof ParseException) { + throw (ParseException)jjte000; + } + throw (Error)jjte000; + } finally { + if (jjtc000) { + jjtree.closeNodeScope(jjtn000, true); + } + } +/*@egen*/ +} + +Token named_pref_gd() : +{/*@bgen(jjtree) NAMED_PREF_GD */ + SimpleNode jjtn000 = new SimpleNode(this, JJTNAMED_PREF_GD); + boolean jjtc000 = true; + jjtree.openNodeScope(jjtn000); +/*@egen*/ + Token t = token; +} +{/*@bgen(jjtree) NAMED_PREF_GD */ + try { +/*@egen*/ + try { + t= [pref_name()] gd() + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + }/*@bgen(jjtree)*/ + { + jjtree.closeNodeScope(jjtn000, true); + jjtc000 = false; + } +/*@egen*/ + { + jjtn000.setLine(t.beginLine); + jjtn000.setColumn(t.beginColumn); + return t; + }/*@bgen(jjtree)*/ + } catch (Throwable jjte000) { + if (jjtc000) { + jjtree.clearNodeScope(jjtn000); + jjtc000 = false; + } else { + jjtree.popNode(); + } + if (jjte000 instanceof RuntimeException) { + throw (RuntimeException)jjte000; + } + if (jjte000 instanceof ParseException) { + throw (ParseException)jjte000; + } + throw (Error)jjte000; + } finally { + if (jjtc000) { + jjtree.closeNodeScope(jjtn000, true); + } + } +/*@egen*/ +} + + +Token pref_name() : +{/*@bgen(jjtree) PREF_NAME */ + SimpleNode jjtn000 = new SimpleNode(this, JJTPREF_NAME); + boolean jjtc000 = true; + jjtree.openNodeScope(jjtn000); +/*@egen*/ + Token t = token; +} +{/*@bgen(jjtree) PREF_NAME */ + try { +/*@egen*/ + try { + t= + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + }/*@bgen(jjtree)*/ + { + jjtree.closeNodeScope(jjtn000, true); + jjtc000 = false; + } +/*@egen*/ + { + jjtn000.setLine(t.beginLine); + jjtn000.setColumn(t.beginColumn); + return t; + }/*@bgen(jjtree)*/ + } finally { + if (jjtc000) { + jjtree.closeNodeScope(jjtn000, true); + } + } +/*@egen*/ +} + +Token effect() : +{/*@bgen(jjtree) EFFECT */ + SimpleNode jjtn000 = new SimpleNode(this, JJTEFFECT); + boolean jjtc000 = true; + jjtree.openNodeScope(jjtn000); +/*@egen*/ + Token t = token; +} +{/*@bgen(jjtree) EFFECT */ + try { +/*@egen*/ + try { + LOOKAHEAD(2) t=and_c_effect() + | LOOKAHEAD(2) t=c_effect() + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + }/*@bgen(jjtree)*/ + { + jjtree.closeNodeScope(jjtn000, true); + jjtc000 = false; + } +/*@egen*/ + { + jjtn000.setLine(t.beginLine); + jjtn000.setColumn(t.beginColumn); + return t; + }/*@bgen(jjtree)*/ + } catch (Throwable jjte000) { + if (jjtc000) { + jjtree.clearNodeScope(jjtn000); + jjtc000 = false; + } else { + jjtree.popNode(); + } + if (jjte000 instanceof RuntimeException) { + throw (RuntimeException)jjte000; + } + if (jjte000 instanceof ParseException) { + throw (ParseException)jjte000; + } + throw (Error)jjte000; + } finally { + if (jjtc000) { + jjtree.closeNodeScope(jjtn000, true); + } + } +/*@egen*/ +} + +Token and_c_effect() : +{/*@bgen(jjtree) AND_C_EFFECT */ + SimpleNode jjtn000 = new SimpleNode(this, JJTAND_C_EFFECT); + boolean jjtc000 = true; + jjtree.openNodeScope(jjtn000); +/*@egen*/ + Token t = token; +} +{/*@bgen(jjtree) AND_C_EFFECT */ + try { +/*@egen*/ + try { + t= (c_effect())* + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + }/*@bgen(jjtree)*/ + { + jjtree.closeNodeScope(jjtn000, true); + jjtc000 = false; + } +/*@egen*/ + { + jjtn000.setLine(t.beginLine); + jjtn000.setColumn(t.beginColumn); + return t; + }/*@bgen(jjtree)*/ + } catch (Throwable jjte000) { + if (jjtc000) { + jjtree.clearNodeScope(jjtn000); + jjtc000 = false; + } else { + jjtree.popNode(); + } + if (jjte000 instanceof RuntimeException) { + throw (RuntimeException)jjte000; + } + if (jjte000 instanceof ParseException) { + throw (ParseException)jjte000; + } + throw (Error)jjte000; + } finally { + if (jjtc000) { + jjtree.closeNodeScope(jjtn000, true); + } + } +/*@egen*/ +} + +Token prob_effect() : +{/*@bgen(jjtree) PROB_EFFECT */ + SimpleNode jjtn000 = new SimpleNode(this, JJTPROB_EFFECT); + boolean jjtc000 = true; + jjtree.openNodeScope(jjtn000); +/*@egen*/ + Token t = token; +} +{/*@bgen(jjtree) PROB_EFFECT */ + try { +/*@egen*/ + try{ + t = (prob_term())* + }catch(Throwable e){ + + this.error(e, t.beginLine, t.beginColumn); + }/*@bgen(jjtree)*/ + { + jjtree.closeNodeScope(jjtn000, true); + jjtc000 = false; + } +/*@egen*/ + { + + jjtn000.setLine(t.beginLine); + jjtn000.setColumn(t.beginColumn); + return t; + }/*@bgen(jjtree)*/ + } catch (Throwable jjte000) { + if (jjtc000) { + jjtree.clearNodeScope(jjtn000); + jjtc000 = false; + } else { + jjtree.popNode(); + } + if (jjte000 instanceof RuntimeException) { + throw (RuntimeException)jjte000; + } + if (jjte000 instanceof ParseException) { + throw (ParseException)jjte000; + } + throw (Error)jjte000; + } finally { + if (jjtc000) { + jjtree.closeNodeScope(jjtn000, true); + } + } +/*@egen*/ +} + +Token prob_term() : +{/*@bgen(jjtree) PROB_TERM */ + SimpleNode jjtn000 = new SimpleNode(this, JJTPROB_TERM); + boolean jjtc000 = true; + jjtree.openNodeScope(jjtn000); +/*@egen*/ + Token t = token; +} +{/*@bgen(jjtree) PROB_TERM */ + try { +/*@egen*/ + try{ + LOOKAHEAD(3) t = number() c_effect() + | LOOKAHEAD(3) t = number() and_c_effect() + }catch(Throwable e){ + + this.error(e, t.beginLine, t.beginColumn); + }/*@bgen(jjtree)*/ + { + jjtree.closeNodeScope(jjtn000, true); + jjtc000 = false; + } +/*@egen*/ + { + + jjtn000.setLine(t.beginLine); + jjtn000.setColumn(t.beginColumn); + return t; + }/*@bgen(jjtree)*/ + } catch (Throwable jjte000) { + if (jjtc000) { + jjtree.clearNodeScope(jjtn000); + jjtc000 = false; + } else { + jjtree.popNode(); + } + if (jjte000 instanceof RuntimeException) { + throw (RuntimeException)jjte000; + } + if (jjte000 instanceof ParseException) { + throw (ParseException)jjte000; + } + throw (Error)jjte000; + } finally { + if (jjtc000) { + jjtree.closeNodeScope(jjtn000, true); + } + } +/*@egen*/ +} + +Token c_effect() : +{/*@bgen(jjtree) C_EFFECT */ + SimpleNode jjtn000 = new SimpleNode(this, JJTC_EFFECT); + boolean jjtc000 = true; + jjtree.openNodeScope(jjtn000); +/*@egen*/ + Token t = token; +} +{/*@bgen(jjtree) C_EFFECT */ + try { +/*@egen*/ + try { + LOOKAHEAD(2) t=forall_effect() + | LOOKAHEAD(2) t=when_con_effect() + | LOOKAHEAD(2) t=p_effect() + | LOOKAHEAD(2) t=prob_effect() + } catch (Throwable e) { + + this.error(e, t.beginLine, t.beginColumn); + }/*@bgen(jjtree)*/ + { + jjtree.closeNodeScope(jjtn000, true); + jjtc000 = false; + } +/*@egen*/ + { + + jjtn000.setLine(t.beginLine); + jjtn000.setColumn(t.beginColumn); + return t; + }/*@bgen(jjtree)*/ + } catch (Throwable jjte000) { + if (jjtc000) { + jjtree.clearNodeScope(jjtn000); + jjtc000 = false; + } else { + jjtree.popNode(); + } + if (jjte000 instanceof RuntimeException) { + throw (RuntimeException)jjte000; + } + if (jjte000 instanceof ParseException) { + throw (ParseException)jjte000; + } + throw (Error)jjte000; + } finally { + if (jjtc000) { + jjtree.closeNodeScope(jjtn000, true); + } + } +/*@egen*/ +} + +Token forall_effect() : +{/*@bgen(jjtree) FORALL_EFFECT */ + SimpleNode jjtn000 = new SimpleNode(this, JJTFORALL_EFFECT); + boolean jjtc000 = true; + jjtree.openNodeScope(jjtn000); +/*@egen*/ + Token t = token; +} +{/*@bgen(jjtree) FORALL_EFFECT */ + try { +/*@egen*/ + try { + t= typed_list(LexerTreeConstants.JJTVARIABLE) effect() + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + }/*@bgen(jjtree)*/ + { + jjtree.closeNodeScope(jjtn000, true); + jjtc000 = false; + } +/*@egen*/ + { + jjtn000.setLine(t.beginLine); + jjtn000.setColumn(t.beginColumn); + return t; + }/*@bgen(jjtree)*/ + } catch (Throwable jjte000) { + if (jjtc000) { + jjtree.clearNodeScope(jjtn000); + jjtc000 = false; + } else { + jjtree.popNode(); + } + if (jjte000 instanceof RuntimeException) { + throw (RuntimeException)jjte000; + } + if (jjte000 instanceof ParseException) { + throw (ParseException)jjte000; + } + throw (Error)jjte000; + } finally { + if (jjtc000) { + jjtree.closeNodeScope(jjtn000, true); + } + } +/*@egen*/ +} + +Token when_con_effect() : +{/*@bgen(jjtree) WHEN_CON_EFFECT */ + SimpleNode jjtn000 = new SimpleNode(this, JJTWHEN_CON_EFFECT); + boolean jjtc000 = true; + jjtree.openNodeScope(jjtn000); +/*@egen*/ + Token t = token; +} +{/*@bgen(jjtree) WHEN_CON_EFFECT */ + try { +/*@egen*/ + try { + t= gd() cond_effect() + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + }/*@bgen(jjtree)*/ + { + jjtree.closeNodeScope(jjtn000, true); + jjtc000 = false; + } +/*@egen*/ + { + jjtn000.setLine(t.beginLine); + jjtn000.setColumn(t.beginColumn); + return t; + }/*@bgen(jjtree)*/ + } catch (Throwable jjte000) { + if (jjtc000) { + jjtree.clearNodeScope(jjtn000); + jjtc000 = false; + } else { + jjtree.popNode(); + } + if (jjte000 instanceof RuntimeException) { + throw (RuntimeException)jjte000; + } + if (jjte000 instanceof ParseException) { + throw (ParseException)jjte000; + } + throw (Error)jjte000; + } finally { + if (jjtc000) { + jjtree.closeNodeScope(jjtn000, true); + } + } +/*@egen*/ +} + +Token cond_effect() : +{/*@bgen(jjtree) COND_EFFECT */ + SimpleNode jjtn000 = new SimpleNode(this, JJTCOND_EFFECT); + boolean jjtc000 = true; + jjtree.openNodeScope(jjtn000); +/*@egen*/ + Token t = token; +} +{/*@bgen(jjtree) COND_EFFECT */ + try { +/*@egen*/ + try { + LOOKAHEAD(2) t=and_c_effect() + | LOOKAHEAD(2) t=c_effect() + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + }/*@bgen(jjtree)*/ + { + jjtree.closeNodeScope(jjtn000, true); + jjtc000 = false; + } +/*@egen*/ + { + jjtn000.setLine(t.beginLine); + jjtn000.setColumn(t.beginColumn); + return t; + }/*@bgen(jjtree)*/ + } catch (Throwable jjte000) { + if (jjtc000) { + jjtree.clearNodeScope(jjtn000); + jjtc000 = false; + } else { + jjtree.popNode(); + } + if (jjte000 instanceof RuntimeException) { + throw (RuntimeException)jjte000; + } + if (jjte000 instanceof ParseException) { + throw (ParseException)jjte000; + } + throw (Error)jjte000; + } finally { + if (jjtc000) { + jjtree.closeNodeScope(jjtn000, true); + } + } +/*@egen*/ +} + +Token and_p_effect() : +{/*@bgen(jjtree) AND_P_EFFECT */ + SimpleNode jjtn000 = new SimpleNode(this, JJTAND_P_EFFECT); + boolean jjtc000 = true; + jjtree.openNodeScope(jjtn000); +/*@egen*/ + Token t = token; +} +{/*@bgen(jjtree) AND_P_EFFECT */ + try { +/*@egen*/ + try { + t= (p_effect())* + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + }/*@bgen(jjtree)*/ + { + jjtree.closeNodeScope(jjtn000, true); + jjtc000 = false; + } +/*@egen*/ + { + jjtn000.setLine(t.beginLine); + jjtn000.setColumn(t.beginColumn); + return t; + }/*@bgen(jjtree)*/ + } catch (Throwable jjte000) { + if (jjtc000) { + jjtree.clearNodeScope(jjtn000); + jjtc000 = false; + } else { + jjtree.popNode(); + } + if (jjte000 instanceof RuntimeException) { + throw (RuntimeException)jjte000; + } + if (jjte000 instanceof ParseException) { + throw (ParseException)jjte000; + } + throw (Error)jjte000; + } finally { + if (jjtc000) { + jjtree.closeNodeScope(jjtn000, true); + } + } +/*@egen*/ +} + +Token p_effect() : +{/*@bgen(jjtree) P_EFFECT */ + SimpleNode jjtn000 = new SimpleNode(this, JJTP_EFFECT); + boolean jjtc000 = true; + jjtree.openNodeScope(jjtn000); +/*@egen*/ + Token t = token; +} +{/*@bgen(jjtree) P_EFFECT */ + try { +/*@egen*/ + try { + LOOKAHEAD(2) t=assign_op() + | LOOKAHEAD(2) t=literal(LexerTreeConstants.JJTTERM) + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + }/*@bgen(jjtree)*/ + { + jjtree.closeNodeScope(jjtn000, true); + jjtc000 = false; + } +/*@egen*/ + { + jjtn000.setLine(t.beginLine); + jjtn000.setColumn(t.beginColumn); + return t; + }/*@bgen(jjtree)*/ + } catch (Throwable jjte000) { + if (jjtc000) { + jjtree.clearNodeScope(jjtn000); + jjtc000 = false; + } else { + jjtree.popNode(); + } + if (jjte000 instanceof RuntimeException) { + throw (RuntimeException)jjte000; + } + if (jjte000 instanceof ParseException) { + throw (ParseException)jjte000; + } + throw (Error)jjte000; + } finally { + if (jjtc000) { + jjtree.closeNodeScope(jjtn000, true); + } + } +/*@egen*/ +} + +Token assign_op() : +{/*@bgen(jjtree) ASSIGN_OP */ + SimpleNode jjtn000 = new SimpleNode(this, JJTASSIGN_OP); + boolean jjtc000 = true; + jjtree.openNodeScope(jjtn000); +/*@egen*/ + Token t = token; +} +{/*@bgen(jjtree) ASSIGN_OP */ + try { +/*@egen*/ + try { + LOOKAHEAD(2) t=assign() + | LOOKAHEAD(2) t=scale_up() + | LOOKAHEAD(2) t=scale_down() + | LOOKAHEAD(2) t=increase() + | LOOKAHEAD(2) t=decrease() + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + }/*@bgen(jjtree)*/ + { + jjtree.closeNodeScope(jjtn000, true); + jjtc000 = false; + } +/*@egen*/ + { + jjtn000.setLine(t.beginLine); + jjtn000.setColumn(t.beginColumn); + return t; + }/*@bgen(jjtree)*/ + } catch (Throwable jjte000) { + if (jjtc000) { + jjtree.clearNodeScope(jjtn000); + jjtc000 = false; + } else { + jjtree.popNode(); + } + if (jjte000 instanceof RuntimeException) { + throw (RuntimeException)jjte000; + } + if (jjte000 instanceof ParseException) { + throw (ParseException)jjte000; + } + throw (Error)jjte000; + } finally { + if (jjtc000) { + jjtree.closeNodeScope(jjtn000, true); + } + } +/*@egen*/ +} + +Token assign() : +{/*@bgen(jjtree) ASSIGN */ + SimpleNode jjtn000 = new SimpleNode(this, JJTASSIGN); + boolean jjtc000 = true; + jjtree.openNodeScope(jjtn000); +/*@egen*/ + Token t = token; +} +{/*@bgen(jjtree) ASSIGN */ + try { +/*@egen*/ + try { + t= f_head() f_exp() + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + } + { + jjtn000.setLine(t.beginLine); + jjtn000.setColumn(t.beginColumn); + return t; + }/*@bgen(jjtree)*/ + { + jjtree.closeNodeScope(jjtn000, true); + jjtc000 = false; + } +/*@egen*/ + { return t; }/*@bgen(jjtree)*/ + } catch (Throwable jjte000) { + if (jjtc000) { + jjtree.clearNodeScope(jjtn000); + jjtc000 = false; + } else { + jjtree.popNode(); + } + if (jjte000 instanceof RuntimeException) { + throw (RuntimeException)jjte000; + } + if (jjte000 instanceof ParseException) { + throw (ParseException)jjte000; + } + throw (Error)jjte000; + } finally { + if (jjtc000) { + jjtree.closeNodeScope(jjtn000, true); + } + } +/*@egen*/ +} + +Token scale_up() : +{/*@bgen(jjtree) SCALE_UP */ + SimpleNode jjtn000 = new SimpleNode(this, JJTSCALE_UP); + boolean jjtc000 = true; + jjtree.openNodeScope(jjtn000); +/*@egen*/ + Token t = token; +} +{/*@bgen(jjtree) SCALE_UP */ + try { +/*@egen*/ + try { + t= f_head() f_exp() + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + }/*@bgen(jjtree)*/ + { + jjtree.closeNodeScope(jjtn000, true); + jjtc000 = false; + } +/*@egen*/ + { + jjtn000.setLine(t.beginLine); + jjtn000.setColumn(t.beginColumn); + return t; + }/*@bgen(jjtree)*/ + } catch (Throwable jjte000) { + if (jjtc000) { + jjtree.clearNodeScope(jjtn000); + jjtc000 = false; + } else { + jjtree.popNode(); + } + if (jjte000 instanceof RuntimeException) { + throw (RuntimeException)jjte000; + } + if (jjte000 instanceof ParseException) { + throw (ParseException)jjte000; + } + throw (Error)jjte000; + } finally { + if (jjtc000) { + jjtree.closeNodeScope(jjtn000, true); + } + } +/*@egen*/ +} + +Token scale_down() : +{/*@bgen(jjtree) SCALE_DOWN */ + SimpleNode jjtn000 = new SimpleNode(this, JJTSCALE_DOWN); + boolean jjtc000 = true; + jjtree.openNodeScope(jjtn000); +/*@egen*/ + Token t = token; +} +{/*@bgen(jjtree) SCALE_DOWN */ + try { +/*@egen*/ + try { + t= f_head() f_exp() + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + }/*@bgen(jjtree)*/ + { + jjtree.closeNodeScope(jjtn000, true); + jjtc000 = false; + } +/*@egen*/ + { + jjtn000.setLine(t.beginLine); + jjtn000.setColumn(t.beginColumn); + return t; + }/*@bgen(jjtree)*/ + } catch (Throwable jjte000) { + if (jjtc000) { + jjtree.clearNodeScope(jjtn000); + jjtc000 = false; + } else { + jjtree.popNode(); + } + if (jjte000 instanceof RuntimeException) { + throw (RuntimeException)jjte000; + } + if (jjte000 instanceof ParseException) { + throw (ParseException)jjte000; + } + throw (Error)jjte000; + } finally { + if (jjtc000) { + jjtree.closeNodeScope(jjtn000, true); + } + } +/*@egen*/ +} + +Token increase() : +{/*@bgen(jjtree) INCREASE */ + SimpleNode jjtn000 = new SimpleNode(this, JJTINCREASE); + boolean jjtc000 = true; + jjtree.openNodeScope(jjtn000); +/*@egen*/ + Token t = token; +} +{/*@bgen(jjtree) INCREASE */ + try { +/*@egen*/ + try { + t= f_head() f_exp() + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + }/*@bgen(jjtree)*/ + { + jjtree.closeNodeScope(jjtn000, true); + jjtc000 = false; + } +/*@egen*/ + { + jjtn000.setLine(t.beginLine); + jjtn000.setColumn(t.beginColumn); + return t; + }/*@bgen(jjtree)*/ + } catch (Throwable jjte000) { + if (jjtc000) { + jjtree.clearNodeScope(jjtn000); + jjtc000 = false; + } else { + jjtree.popNode(); + } + if (jjte000 instanceof RuntimeException) { + throw (RuntimeException)jjte000; + } + if (jjte000 instanceof ParseException) { + throw (ParseException)jjte000; + } + throw (Error)jjte000; + } finally { + if (jjtc000) { + jjtree.closeNodeScope(jjtn000, true); + } + } +/*@egen*/ +} + +Token decrease() : +{/*@bgen(jjtree) DECREASE */ + SimpleNode jjtn000 = new SimpleNode(this, JJTDECREASE); + boolean jjtc000 = true; + jjtree.openNodeScope(jjtn000); +/*@egen*/ + Token t = token; +} +{/*@bgen(jjtree) DECREASE */ + try { +/*@egen*/ + try { + t= f_head() f_exp() + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + }/*@bgen(jjtree)*/ + { + jjtree.closeNodeScope(jjtn000, true); + jjtc000 = false; + } +/*@egen*/ + { + jjtn000.setLine(t.beginLine); + jjtn000.setColumn(t.beginColumn); + return t; + }/*@bgen(jjtree)*/ + } catch (Throwable jjte000) { + if (jjtc000) { + jjtree.clearNodeScope(jjtn000); + jjtc000 = false; + } else { + jjtree.popNode(); + } + if (jjte000 instanceof RuntimeException) { + throw (RuntimeException)jjte000; + } + if (jjte000 instanceof ParseException) { + throw (ParseException)jjte000; + } + throw (Error)jjte000; + } finally { + if (jjtc000) { + jjtree.closeNodeScope(jjtn000, true); + } + } +/*@egen*/ +} + +Token durative_action_def() : +{/*@bgen(jjtree) DURATION_ACTION_DEF */ + SimpleNode jjtn000 = new SimpleNode(this, JJTDURATION_ACTION_DEF); + boolean jjtc000 = true; + jjtree.openNodeScope(jjtn000); +/*@egen*/ + Token t = token; +} +{/*@bgen(jjtree) DURATION_ACTION_DEF */ + try { +/*@egen*/ + try { + t= da_symbol() + typed_list(LexerTreeConstants.JJTVARIABLE) + da_def_body() + + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + }/*@bgen(jjtree)*/ + { + jjtree.closeNodeScope(jjtn000, true); + jjtc000 = false; + } +/*@egen*/ + { + jjtn000.setLine(t.beginLine); + jjtn000.setColumn(t.beginColumn); + return t; + }/*@bgen(jjtree)*/ + } catch (Throwable jjte000) { + if (jjtc000) { + jjtree.clearNodeScope(jjtn000); + jjtc000 = false; + } else { + jjtree.popNode(); + } + if (jjte000 instanceof RuntimeException) { + throw (RuntimeException)jjte000; + } + if (jjte000 instanceof ParseException) { + throw (ParseException)jjte000; + } + throw (Error)jjte000; + } finally { + if (jjtc000) { + jjtree.closeNodeScope(jjtn000, true); + } + } +/*@egen*/ +} + +Token da_symbol() : +{/*@bgen(jjtree) DA_SYMBOL */ + SimpleNode jjtn000 = new SimpleNode(this, JJTDA_SYMBOL); + boolean jjtc000 = true; + jjtree.openNodeScope(jjtn000); +/*@egen*/ + Token t = token; +} +{/*@bgen(jjtree) DA_SYMBOL */ + try { +/*@egen*/ + try { + t= + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + }/*@bgen(jjtree)*/ + { + jjtree.closeNodeScope(jjtn000, true); + jjtc000 = false; + } +/*@egen*/ + { + jjtn000.setLine(t.beginLine); + jjtn000.setColumn(t.beginColumn); + jjtn000.setImage(t.image); + return t; + }/*@bgen(jjtree)*/ + } finally { + if (jjtc000) { + jjtree.closeNodeScope(jjtn000, true); + } + } +/*@egen*/ +} + +Token da_def_body() : +{/*@bgen(jjtree) DA_DEF_BODY */ + SimpleNode jjtn000 = new SimpleNode(this, JJTDA_DEF_BODY); + boolean jjtc000 = true; + jjtree.openNodeScope(jjtn000); +/*@egen*/ + Token t = token; +} +{/*@bgen(jjtree) DA_DEF_BODY */ + try { +/*@egen*/ + try { + t= duration_constraint() + da_gd() + da_effect() + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + }/*@bgen(jjtree)*/ + { + jjtree.closeNodeScope(jjtn000, true); + jjtc000 = false; + } +/*@egen*/ + { + jjtn000.setLine(t.beginLine); + jjtn000.setColumn(t.beginColumn); + return t; + }/*@bgen(jjtree)*/ + } catch (Throwable jjte000) { + if (jjtc000) { + jjtree.clearNodeScope(jjtn000); + jjtc000 = false; + } else { + jjtree.popNode(); + } + if (jjte000 instanceof RuntimeException) { + throw (RuntimeException)jjte000; + } + if (jjte000 instanceof ParseException) { + throw (ParseException)jjte000; + } + throw (Error)jjte000; + } finally { + if (jjtc000) { + jjtree.closeNodeScope(jjtn000, true); + } + } +/*@egen*/ +} + +Token duration_constraint() : +{/*@bgen(jjtree) DURATION_CONSTRAINT */ + SimpleNode jjtn000 = new SimpleNode(this, JJTDURATION_CONSTRAINT); + boolean jjtc000 = true; + jjtree.openNodeScope(jjtn000); +/*@egen*/ + Token t = token; +} +{/*@bgen(jjtree) DURATION_CONSTRAINT */ + try { +/*@egen*/ + try { + LOOKAHEAD(2) t=empty_or() + | LOOKAHEAD(2) t=and_simple_duration_constraint() + | LOOKAHEAD(2) t=simple_duration_constraint() + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + }/*@bgen(jjtree)*/ + { + jjtree.closeNodeScope(jjtn000, true); + jjtc000 = false; + } +/*@egen*/ + { + jjtn000.setLine(t.beginLine); + jjtn000.setColumn(t.beginColumn); + return t; + }/*@bgen(jjtree)*/ + } catch (Throwable jjte000) { + if (jjtc000) { + jjtree.clearNodeScope(jjtn000); + jjtc000 = false; + } else { + jjtree.popNode(); + } + if (jjte000 instanceof RuntimeException) { + throw (RuntimeException)jjte000; + } + if (jjte000 instanceof ParseException) { + throw (ParseException)jjte000; + } + throw (Error)jjte000; + } finally { + if (jjtc000) { + jjtree.closeNodeScope(jjtn000, true); + } + } +/*@egen*/ +} + +Token and_simple_duration_constraint() : +{/*@bgen(jjtree) AND_SIMPLE_DURATION_CONSTRAINT */ + SimpleNode jjtn000 = new SimpleNode(this, JJTAND_SIMPLE_DURATION_CONSTRAINT); + boolean jjtc000 = true; + jjtree.openNodeScope(jjtn000); +/*@egen*/ + Token t = token; +} +{/*@bgen(jjtree) AND_SIMPLE_DURATION_CONSTRAINT */ + try { +/*@egen*/ + try { + t= (simple_duration_constraint())+ + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + }/*@bgen(jjtree)*/ + { + jjtree.closeNodeScope(jjtn000, true); + jjtc000 = false; + } +/*@egen*/ + { + jjtn000.setLine(t.beginLine); + jjtn000.setColumn(t.beginColumn); + return t; + }/*@bgen(jjtree)*/ + } catch (Throwable jjte000) { + if (jjtc000) { + jjtree.clearNodeScope(jjtn000); + jjtc000 = false; + } else { + jjtree.popNode(); + } + if (jjte000 instanceof RuntimeException) { + throw (RuntimeException)jjte000; + } + if (jjte000 instanceof ParseException) { + throw (ParseException)jjte000; + } + throw (Error)jjte000; + } finally { + if (jjtc000) { + jjtree.closeNodeScope(jjtn000, true); + } + } +/*@egen*/ +} + +Token simple_duration_constraint() : +{/*@bgen(jjtree) SIMPLE_DURATION_CONSTRAINT */ + SimpleNode jjtn000 = new SimpleNode(this, JJTSIMPLE_DURATION_CONSTRAINT); + boolean jjtc000 = true; + jjtree.openNodeScope(jjtn000); +/*@egen*/ + Token t = token; +} +{/*@bgen(jjtree) SIMPLE_DURATION_CONSTRAINT */ + try { +/*@egen*/ + try { + LOOKAHEAD(2) t=d_op() + | LOOKAHEAD(2) t=at_simple_duration_constraint() + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + }/*@bgen(jjtree)*/ + { + jjtree.closeNodeScope(jjtn000, true); + jjtc000 = false; + } +/*@egen*/ + { + jjtn000.setLine(t.beginLine); + jjtn000.setColumn(t.beginColumn); + return t; + }/*@bgen(jjtree)*/ + } catch (Throwable jjte000) { + if (jjtc000) { + jjtree.clearNodeScope(jjtn000); + jjtc000 = false; + } else { + jjtree.popNode(); + } + if (jjte000 instanceof RuntimeException) { + throw (RuntimeException)jjte000; + } + if (jjte000 instanceof ParseException) { + throw (ParseException)jjte000; + } + throw (Error)jjte000; + } finally { + if (jjtc000) { + jjtree.closeNodeScope(jjtn000, true); + } + } +/*@egen*/ +} + +Token at_simple_duration_constraint() : +{/*@bgen(jjtree) AT_SIMPLE_DURATION_CONSTRAINT */ + SimpleNode jjtn000 = new SimpleNode(this, JJTAT_SIMPLE_DURATION_CONSTRAINT); + boolean jjtc000 = true; + jjtree.openNodeScope(jjtn000); +/*@egen*/ + Token t = token; +} +{/*@bgen(jjtree) AT_SIMPLE_DURATION_CONSTRAINT */ + try { +/*@egen*/ + try { + LOOKAHEAD(3) t=at_start_simple_duration_constraint() + | LOOKAHEAD(3) t=at_end_simple_duration_constraint() + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + }/*@bgen(jjtree)*/ + { + jjtree.closeNodeScope(jjtn000, true); + jjtc000 = false; + } +/*@egen*/ + { + jjtn000.setLine(t.beginLine); + jjtn000.setColumn(t.beginColumn); + return t; + }/*@bgen(jjtree)*/ + } catch (Throwable jjte000) { + if (jjtc000) { + jjtree.clearNodeScope(jjtn000); + jjtc000 = false; + } else { + jjtree.popNode(); + } + if (jjte000 instanceof RuntimeException) { + throw (RuntimeException)jjte000; + } + if (jjte000 instanceof ParseException) { + throw (ParseException)jjte000; + } + throw (Error)jjte000; + } finally { + if (jjtc000) { + jjtree.closeNodeScope(jjtn000, true); + } + } +/*@egen*/ +} + +Token at_start_simple_duration_constraint() : +{/*@bgen(jjtree) AT_START_SIMPLE_DURATION_CONSTRAINT */ + SimpleNode jjtn000 = new SimpleNode(this, JJTAT_START_SIMPLE_DURATION_CONSTRAINT); + boolean jjtc000 = true; + jjtree.openNodeScope(jjtn000); +/*@egen*/ + Token t = token; +} +{/*@bgen(jjtree) AT_START_SIMPLE_DURATION_CONSTRAINT */ + try { +/*@egen*/ + try { + t= simple_duration_constraint() + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + }/*@bgen(jjtree)*/ + { + jjtree.closeNodeScope(jjtn000, true); + jjtc000 = false; + } +/*@egen*/ + { + jjtn000.setLine(t.beginLine); + jjtn000.setColumn(t.beginColumn); + return t; + }/*@bgen(jjtree)*/ + } catch (Throwable jjte000) { + if (jjtc000) { + jjtree.clearNodeScope(jjtn000); + jjtc000 = false; + } else { + jjtree.popNode(); + } + if (jjte000 instanceof RuntimeException) { + throw (RuntimeException)jjte000; + } + if (jjte000 instanceof ParseException) { + throw (ParseException)jjte000; + } + throw (Error)jjte000; + } finally { + if (jjtc000) { + jjtree.closeNodeScope(jjtn000, true); + } + } +/*@egen*/ +} + +Token at_end_simple_duration_constraint() : +{/*@bgen(jjtree) AT_END_SIMPLE_DURATION_CONSTRAINT */ + SimpleNode jjtn000 = new SimpleNode(this, JJTAT_END_SIMPLE_DURATION_CONSTRAINT); + boolean jjtc000 = true; + jjtree.openNodeScope(jjtn000); +/*@egen*/ + Token t = token; +} +{/*@bgen(jjtree) AT_END_SIMPLE_DURATION_CONSTRAINT */ + try { +/*@egen*/ + try { + t= simple_duration_constraint() + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + }/*@bgen(jjtree)*/ + { + jjtree.closeNodeScope(jjtn000, true); + jjtc000 = false; + } +/*@egen*/ + { + jjtn000.setLine(t.beginLine); + jjtn000.setColumn(t.beginColumn); + return t; + }/*@bgen(jjtree)*/ + } catch (Throwable jjte000) { + if (jjtc000) { + jjtree.clearNodeScope(jjtn000); + jjtc000 = false; + } else { + jjtree.popNode(); + } + if (jjte000 instanceof RuntimeException) { + throw (RuntimeException)jjte000; + } + if (jjte000 instanceof ParseException) { + throw (ParseException)jjte000; + } + throw (Error)jjte000; + } finally { + if (jjtc000) { + jjtree.closeNodeScope(jjtn000, true); + } + } +/*@egen*/ +} + +Token d_op() : +{/*@bgen(jjtree) D_OP */ + SimpleNode jjtn000 = new SimpleNode(this, JJTD_OP); + boolean jjtc000 = true; + jjtree.openNodeScope(jjtn000); +/*@egen*/ + Token t = token; +} +{/*@bgen(jjtree) D_OP */ + try { +/*@egen*/ + try { + LOOKAHEAD(2) t=equal_d_op() + | LOOKAHEAD(2) t=gequal_d_op() + | LOOKAHEAD(2) t=lequal_d_op() + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + }/*@bgen(jjtree)*/ + { + jjtree.closeNodeScope(jjtn000, true); + jjtc000 = false; + } +/*@egen*/ + { + jjtn000.setLine(t.beginLine); + jjtn000.setColumn(t.beginColumn); + return t; + }/*@bgen(jjtree)*/ + } catch (Throwable jjte000) { + if (jjtc000) { + jjtree.clearNodeScope(jjtn000); + jjtc000 = false; + } else { + jjtree.popNode(); + } + if (jjte000 instanceof RuntimeException) { + throw (RuntimeException)jjte000; + } + if (jjte000 instanceof ParseException) { + throw (ParseException)jjte000; + } + throw (Error)jjte000; + } finally { + if (jjtc000) { + jjtree.closeNodeScope(jjtn000, true); + } + } +/*@egen*/ +} + +Token equal_d_op() : +{/*@bgen(jjtree) EQUAL_D_OP */ + SimpleNode jjtn000 = new SimpleNode(this, JJTEQUAL_D_OP); + boolean jjtc000 = true; + jjtree.openNodeScope(jjtn000); +/*@egen*/ + Token t = token; +} +{/*@bgen(jjtree) EQUAL_D_OP */ + try { +/*@egen*/ + try { + t= var_duration() d_value() + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + }/*@bgen(jjtree)*/ + { + jjtree.closeNodeScope(jjtn000, true); + jjtc000 = false; + } +/*@egen*/ + { + jjtn000.setLine(t.beginLine); + jjtn000.setColumn(t.beginColumn); + return t; + }/*@bgen(jjtree)*/ + } catch (Throwable jjte000) { + if (jjtc000) { + jjtree.clearNodeScope(jjtn000); + jjtc000 = false; + } else { + jjtree.popNode(); + } + if (jjte000 instanceof RuntimeException) { + throw (RuntimeException)jjte000; + } + if (jjte000 instanceof ParseException) { + throw (ParseException)jjte000; + } + throw (Error)jjte000; + } finally { + if (jjtc000) { + jjtree.closeNodeScope(jjtn000, true); + } + } +/*@egen*/ +} + +Token gequal_d_op() : +{/*@bgen(jjtree) GEQUAL_D_OP */ + SimpleNode jjtn000 = new SimpleNode(this, JJTGEQUAL_D_OP); + boolean jjtc000 = true; + jjtree.openNodeScope(jjtn000); +/*@egen*/ + Token t = token; +} +{/*@bgen(jjtree) GEQUAL_D_OP */ + try { +/*@egen*/ + try { + t= var_duration() d_value() + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + }/*@bgen(jjtree)*/ + { + jjtree.closeNodeScope(jjtn000, true); + jjtc000 = false; + } +/*@egen*/ + { + jjtn000.setLine(t.beginLine); + jjtn000.setColumn(t.beginColumn); + return t; + }/*@bgen(jjtree)*/ + } catch (Throwable jjte000) { + if (jjtc000) { + jjtree.clearNodeScope(jjtn000); + jjtc000 = false; + } else { + jjtree.popNode(); + } + if (jjte000 instanceof RuntimeException) { + throw (RuntimeException)jjte000; + } + if (jjte000 instanceof ParseException) { + throw (ParseException)jjte000; + } + throw (Error)jjte000; + } finally { + if (jjtc000) { + jjtree.closeNodeScope(jjtn000, true); + } + } +/*@egen*/ +} + +Token lequal_d_op() : +{/*@bgen(jjtree) LEQUAL_D_OP */ + SimpleNode jjtn000 = new SimpleNode(this, JJTLEQUAL_D_OP); + boolean jjtc000 = true; + jjtree.openNodeScope(jjtn000); +/*@egen*/ + Token t = token; +} +{/*@bgen(jjtree) LEQUAL_D_OP */ + try { +/*@egen*/ + try { + t= var_duration() d_value() + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + }/*@bgen(jjtree)*/ + { + jjtree.closeNodeScope(jjtn000, true); + jjtc000 = false; + } +/*@egen*/ + { + jjtn000.setLine(t.beginLine); + jjtn000.setColumn(t.beginColumn); + return t; + }/*@bgen(jjtree)*/ + } catch (Throwable jjte000) { + if (jjtc000) { + jjtree.clearNodeScope(jjtn000); + jjtc000 = false; + } else { + jjtree.popNode(); + } + if (jjte000 instanceof RuntimeException) { + throw (RuntimeException)jjte000; + } + if (jjte000 instanceof ParseException) { + throw (ParseException)jjte000; + } + throw (Error)jjte000; + } finally { + if (jjtc000) { + jjtree.closeNodeScope(jjtn000, true); + } + } +/*@egen*/ +} + +Token var_duration() : +{/*@bgen(jjtree) VAR_DURATION */ + SimpleNode jjtn000 = new SimpleNode(this, JJTVAR_DURATION); + boolean jjtc000 = true; + jjtree.openNodeScope(jjtn000); +/*@egen*/ + Token t = token; +} +{/*@bgen(jjtree) VAR_DURATION */ + try { +/*@egen*/ + try { + t= + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + }/*@bgen(jjtree)*/ + { + jjtree.closeNodeScope(jjtn000, true); + jjtc000 = false; + } +/*@egen*/ + { + jjtn000.setLine(t.beginLine); + jjtn000.setColumn(t.beginColumn); + return t; + }/*@bgen(jjtree)*/ + } finally { + if (jjtc000) { + jjtree.closeNodeScope(jjtn000, true); + } + } +/*@egen*/ +} + +Token d_value() : +{/*@bgen(jjtree) D_VALUE */ + SimpleNode jjtn000 = new SimpleNode(this, JJTD_VALUE); + boolean jjtc000 = true; + jjtree.openNodeScope(jjtn000); +/*@egen*/ + Token t = token; +} +{/*@bgen(jjtree) D_VALUE */ + try { +/*@egen*/ + try { + LOOKAHEAD(2) t=number() + | LOOKAHEAD(2) t=f_exp() + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + }/*@bgen(jjtree)*/ + { + jjtree.closeNodeScope(jjtn000, true); + jjtc000 = false; + } +/*@egen*/ + { + jjtn000.setLine(t.beginLine); + jjtn000.setColumn(t.beginColumn); + return t; + }/*@bgen(jjtree)*/ + } catch (Throwable jjte000) { + if (jjtc000) { + jjtree.clearNodeScope(jjtn000); + jjtc000 = false; + } else { + jjtree.popNode(); + } + if (jjte000 instanceof RuntimeException) { + throw (RuntimeException)jjte000; + } + if (jjte000 instanceof ParseException) { + throw (ParseException)jjte000; + } + throw (Error)jjte000; + } finally { + if (jjtc000) { + jjtree.closeNodeScope(jjtn000, true); + } + } +/*@egen*/ +} + +Token da_gd() : +{/*@bgen(jjtree) DA_GD */ + SimpleNode jjtn000 = new SimpleNode(this, JJTDA_GD); + boolean jjtc000 = true; + jjtree.openNodeScope(jjtn000); +/*@egen*/ + Token t = token; +} +{/*@bgen(jjtree) DA_GD */ + try { +/*@egen*/ + try { + LOOKAHEAD(2) t=pref_timed_gd() + | LOOKAHEAD(2) t=and_da_gd() + | LOOKAHEAD(2) t=forall_da_gd() + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + }/*@bgen(jjtree)*/ + { + jjtree.closeNodeScope(jjtn000, true); + jjtc000 = false; + } +/*@egen*/ + { + jjtn000.setLine(t.beginLine); + jjtn000.setColumn(t.beginColumn); + return t; + }/*@bgen(jjtree)*/ + } catch (Throwable jjte000) { + if (jjtc000) { + jjtree.clearNodeScope(jjtn000); + jjtc000 = false; + } else { + jjtree.popNode(); + } + if (jjte000 instanceof RuntimeException) { + throw (RuntimeException)jjte000; + } + if (jjte000 instanceof ParseException) { + throw (ParseException)jjte000; + } + throw (Error)jjte000; + } finally { + if (jjtc000) { + jjtree.closeNodeScope(jjtn000, true); + } + } +/*@egen*/ +} + +Token forall_da_gd() : +{/*@bgen(jjtree) FORALL_DA_GD */ + SimpleNode jjtn000 = new SimpleNode(this, JJTFORALL_DA_GD); + boolean jjtc000 = true; + jjtree.openNodeScope(jjtn000); +/*@egen*/ + Token t = token; +} +{/*@bgen(jjtree) FORALL_DA_GD */ + try { +/*@egen*/ + try { + t= typed_list(LexerTreeConstants.JJTVARIABLE) da_gd() + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + }/*@bgen(jjtree)*/ + { + jjtree.closeNodeScope(jjtn000, true); + jjtc000 = false; + } +/*@egen*/ + { + jjtn000.setLine(t.beginLine); + jjtn000.setColumn(t.beginColumn); + return t; + }/*@bgen(jjtree)*/ + } catch (Throwable jjte000) { + if (jjtc000) { + jjtree.clearNodeScope(jjtn000); + jjtc000 = false; + } else { + jjtree.popNode(); + } + if (jjte000 instanceof RuntimeException) { + throw (RuntimeException)jjte000; + } + if (jjte000 instanceof ParseException) { + throw (ParseException)jjte000; + } + throw (Error)jjte000; + } finally { + if (jjtc000) { + jjtree.closeNodeScope(jjtn000, true); + } + } +/*@egen*/ +} + +Token and_da_gd() : +{/*@bgen(jjtree) AND_DA_GD */ + SimpleNode jjtn000 = new SimpleNode(this, JJTAND_DA_GD); + boolean jjtc000 = true; + jjtree.openNodeScope(jjtn000); +/*@egen*/ + Token t = token; +} +{/*@bgen(jjtree) AND_DA_GD */ + try { +/*@egen*/ + try { + t= (da_gd())* + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + }/*@bgen(jjtree)*/ + { + jjtree.closeNodeScope(jjtn000, true); + jjtc000 = false; + } +/*@egen*/ + { + jjtn000.setLine(t.beginLine); + jjtn000.setColumn(t.beginColumn); + return t; + }/*@bgen(jjtree)*/ + } catch (Throwable jjte000) { + if (jjtc000) { + jjtree.clearNodeScope(jjtn000); + jjtc000 = false; + } else { + jjtree.popNode(); + } + if (jjte000 instanceof RuntimeException) { + throw (RuntimeException)jjte000; + } + if (jjte000 instanceof ParseException) { + throw (ParseException)jjte000; + } + throw (Error)jjte000; + } finally { + if (jjtc000) { + jjtree.closeNodeScope(jjtn000, true); + } + } +/*@egen*/ +} + + +Token pref_timed_gd() : +{/*@bgen(jjtree) PREF_TIMED_GD */ + SimpleNode jjtn000 = new SimpleNode(this, JJTPREF_TIMED_GD); + boolean jjtc000 = true; + jjtree.openNodeScope(jjtn000); +/*@egen*/ + Token t = token; +} +{/*@bgen(jjtree) PREF_TIMED_GD */ + try { +/*@egen*/ + try { + LOOKAHEAD(2) t=timed_gd() + | LOOKAHEAD(2) t=named_pref_timed_gd() + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + }/*@bgen(jjtree)*/ + { + jjtree.closeNodeScope(jjtn000, true); + jjtc000 = false; + } +/*@egen*/ + { + jjtn000.setLine(t.beginLine); + jjtn000.setColumn(t.beginColumn); + return t; + }/*@bgen(jjtree)*/ + } catch (Throwable jjte000) { + if (jjtc000) { + jjtree.clearNodeScope(jjtn000); + jjtc000 = false; + } else { + jjtree.popNode(); + } + if (jjte000 instanceof RuntimeException) { + throw (RuntimeException)jjte000; + } + if (jjte000 instanceof ParseException) { + throw (ParseException)jjte000; + } + throw (Error)jjte000; + } finally { + if (jjtc000) { + jjtree.closeNodeScope(jjtn000, true); + } + } +/*@egen*/ +} + +Token named_pref_timed_gd() : +{/*@bgen(jjtree) NAMED_PREF_TIMED_GD */ + SimpleNode jjtn000 = new SimpleNode(this, JJTNAMED_PREF_TIMED_GD); + boolean jjtc000 = true; + jjtree.openNodeScope(jjtn000); +/*@egen*/ + Token t = token; +} +{/*@bgen(jjtree) NAMED_PREF_TIMED_GD */ + try { +/*@egen*/ + try { + t= [pref_name()] timed_gd() + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + }/*@bgen(jjtree)*/ + { + jjtree.closeNodeScope(jjtn000, true); + jjtc000 = false; + } +/*@egen*/ + { + jjtn000.setLine(t.beginLine); + jjtn000.setColumn(t.beginColumn); + return t; + }/*@bgen(jjtree)*/ + } catch (Throwable jjte000) { + if (jjtc000) { + jjtree.clearNodeScope(jjtn000); + jjtc000 = false; + } else { + jjtree.popNode(); + } + if (jjte000 instanceof RuntimeException) { + throw (RuntimeException)jjte000; + } + if (jjte000 instanceof ParseException) { + throw (ParseException)jjte000; + } + throw (Error)jjte000; + } finally { + if (jjtc000) { + jjtree.closeNodeScope(jjtn000, true); + } + } +/*@egen*/ +} + +Token timed_gd() : +{/*@bgen(jjtree) TIMED_GD */ + SimpleNode jjtn000 = new SimpleNode(this, JJTTIMED_GD); + boolean jjtc000 = true; + jjtree.openNodeScope(jjtn000); +/*@egen*/ + Token t = token; +} +{/*@bgen(jjtree) TIMED_GD */ + try { +/*@egen*/ + try { + LOOKAHEAD(2) t=at_timed_gd() + | LOOKAHEAD(2) t=over_timed_gd() + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + }/*@bgen(jjtree)*/ + { + jjtree.closeNodeScope(jjtn000, true); + jjtc000 = false; + } +/*@egen*/ + { + jjtn000.setLine(t.beginLine); + jjtn000.setColumn(t.beginColumn); + return t; + }/*@bgen(jjtree)*/ + } catch (Throwable jjte000) { + if (jjtc000) { + jjtree.clearNodeScope(jjtn000); + jjtc000 = false; + } else { + jjtree.popNode(); + } + if (jjte000 instanceof RuntimeException) { + throw (RuntimeException)jjte000; + } + if (jjte000 instanceof ParseException) { + throw (ParseException)jjte000; + } + throw (Error)jjte000; + } finally { + if (jjtc000) { + jjtree.closeNodeScope(jjtn000, true); + } + } +/*@egen*/ +} + +Token over_timed_gd() : +{/*@bgen(jjtree) OVER_TIMED_GD */ + SimpleNode jjtn000 = new SimpleNode(this, JJTOVER_TIMED_GD); + boolean jjtc000 = true; + jjtree.openNodeScope(jjtn000); +/*@egen*/ + Token t = token; +} +{/*@bgen(jjtree) OVER_TIMED_GD */ + try { +/*@egen*/ + try { + t=over_all_timed_gd() + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + }/*@bgen(jjtree)*/ + { + jjtree.closeNodeScope(jjtn000, true); + jjtc000 = false; + } +/*@egen*/ + { + jjtn000.setLine(t.beginLine); + jjtn000.setColumn(t.beginColumn); + return t; + }/*@bgen(jjtree)*/ + } catch (Throwable jjte000) { + if (jjtc000) { + jjtree.clearNodeScope(jjtn000); + jjtc000 = false; + } else { + jjtree.popNode(); + } + if (jjte000 instanceof RuntimeException) { + throw (RuntimeException)jjte000; + } + if (jjte000 instanceof ParseException) { + throw (ParseException)jjte000; + } + throw (Error)jjte000; + } finally { + if (jjtc000) { + jjtree.closeNodeScope(jjtn000, true); + } + } +/*@egen*/ +} + +Token over_all_timed_gd() : +{/*@bgen(jjtree) OVER_ALL_TIMED_GD */ + SimpleNode jjtn000 = new SimpleNode(this, JJTOVER_ALL_TIMED_GD); + boolean jjtc000 = true; + jjtree.openNodeScope(jjtn000); +/*@egen*/ + Token t = token; +} +{/*@bgen(jjtree) OVER_ALL_TIMED_GD */ + try { +/*@egen*/ + try { + t= gd() + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + }/*@bgen(jjtree)*/ + { + jjtree.closeNodeScope(jjtn000, true); + jjtc000 = false; + } +/*@egen*/ + { + jjtn000.setLine(t.beginLine); + jjtn000.setColumn(t.beginColumn); + return t; + }/*@bgen(jjtree)*/ + } catch (Throwable jjte000) { + if (jjtc000) { + jjtree.clearNodeScope(jjtn000); + jjtc000 = false; + } else { + jjtree.popNode(); + } + if (jjte000 instanceof RuntimeException) { + throw (RuntimeException)jjte000; + } + if (jjte000 instanceof ParseException) { + throw (ParseException)jjte000; + } + throw (Error)jjte000; + } finally { + if (jjtc000) { + jjtree.closeNodeScope(jjtn000, true); + } + } +/*@egen*/ +} + +Token at_timed_gd() : +{/*@bgen(jjtree) AT_TIMED_GD */ + SimpleNode jjtn000 = new SimpleNode(this, JJTAT_TIMED_GD); + boolean jjtc000 = true; + jjtree.openNodeScope(jjtn000); +/*@egen*/ + Token t = token; +} +{/*@bgen(jjtree) AT_TIMED_GD */ + try { +/*@egen*/ + try { + LOOKAHEAD(3) t=at_start_timed_gd() + | LOOKAHEAD(2) t=at_end_timed_gd() + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + }/*@bgen(jjtree)*/ + { + jjtree.closeNodeScope(jjtn000, true); + jjtc000 = false; + } +/*@egen*/ + { + jjtn000.setLine(t.beginLine); + jjtn000.setColumn(t.beginColumn); + return t; + }/*@bgen(jjtree)*/ + } catch (Throwable jjte000) { + if (jjtc000) { + jjtree.clearNodeScope(jjtn000); + jjtc000 = false; + } else { + jjtree.popNode(); + } + if (jjte000 instanceof RuntimeException) { + throw (RuntimeException)jjte000; + } + if (jjte000 instanceof ParseException) { + throw (ParseException)jjte000; + } + throw (Error)jjte000; + } finally { + if (jjtc000) { + jjtree.closeNodeScope(jjtn000, true); + } + } +/*@egen*/ +} + +Token at_start_timed_gd() : +{/*@bgen(jjtree) AT_START_TIMED_GD */ + SimpleNode jjtn000 = new SimpleNode(this, JJTAT_START_TIMED_GD); + boolean jjtc000 = true; + jjtree.openNodeScope(jjtn000); +/*@egen*/ + Token t = token; +} +{/*@bgen(jjtree) AT_START_TIMED_GD */ + try { +/*@egen*/ + try { + t= gd() + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + }/*@bgen(jjtree)*/ + { + jjtree.closeNodeScope(jjtn000, true); + jjtc000 = false; + } +/*@egen*/ + { + jjtn000.setLine(t.beginLine); + jjtn000.setColumn(t.beginColumn); + return t; + }/*@bgen(jjtree)*/ + } catch (Throwable jjte000) { + if (jjtc000) { + jjtree.clearNodeScope(jjtn000); + jjtc000 = false; + } else { + jjtree.popNode(); + } + if (jjte000 instanceof RuntimeException) { + throw (RuntimeException)jjte000; + } + if (jjte000 instanceof ParseException) { + throw (ParseException)jjte000; + } + throw (Error)jjte000; + } finally { + if (jjtc000) { + jjtree.closeNodeScope(jjtn000, true); + } + } +/*@egen*/ +} + +Token at_end_timed_gd() : +{/*@bgen(jjtree) AT_END_TIMED_GD */ + SimpleNode jjtn000 = new SimpleNode(this, JJTAT_END_TIMED_GD); + boolean jjtc000 = true; + jjtree.openNodeScope(jjtn000); +/*@egen*/ + Token t = token; +} +{/*@bgen(jjtree) AT_END_TIMED_GD */ + try { +/*@egen*/ + try { + t= gd() + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + }/*@bgen(jjtree)*/ + { + jjtree.closeNodeScope(jjtn000, true); + jjtc000 = false; + } +/*@egen*/ + { + jjtn000.setLine(t.beginLine); + jjtn000.setColumn(t.beginColumn); + return t; + }/*@bgen(jjtree)*/ + } catch (Throwable jjte000) { + if (jjtc000) { + jjtree.clearNodeScope(jjtn000); + jjtc000 = false; + } else { + jjtree.popNode(); + } + if (jjte000 instanceof RuntimeException) { + throw (RuntimeException)jjte000; + } + if (jjte000 instanceof ParseException) { + throw (ParseException)jjte000; + } + throw (Error)jjte000; + } finally { + if (jjtc000) { + jjtree.closeNodeScope(jjtn000, true); + } + } +/*@egen*/ +} + +Token interval() : +{/*@bgen(jjtree) INTERVAL */ + SimpleNode jjtn000 = new SimpleNode(this, JJTINTERVAL); + boolean jjtc000 = true; + jjtree.openNodeScope(jjtn000); +/*@egen*/ + Token t = token; +} +{/*@bgen(jjtree) INTERVAL */ + try { +/*@egen*/ + try { + t= + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + }/*@bgen(jjtree)*/ + { + jjtree.closeNodeScope(jjtn000, true); + jjtc000 = false; + } +/*@egen*/ + { + jjtn000.setLine(t.beginLine); + jjtn000.setColumn(t.beginColumn); + return t; + }/*@bgen(jjtree)*/ + } finally { + if (jjtc000) { + jjtree.closeNodeScope(jjtn000, true); + } + } +/*@egen*/ +} + +Token da_effect() : +{/*@bgen(jjtree) DA_EFFECT */ + SimpleNode jjtn000 = new SimpleNode(this, JJTDA_EFFECT); + boolean jjtc000 = true; + jjtree.openNodeScope(jjtn000); +/*@egen*/ + Token t = token; +} +{/*@bgen(jjtree) DA_EFFECT */ + try { +/*@egen*/ + try { + LOOKAHEAD(2) t=timed_effect() + | LOOKAHEAD(2) t=and_da_effect() + | LOOKAHEAD(2) t=forall_da_effect() + | LOOKAHEAD(2) t=when_da_effect() + | LOOKAHEAD(2) t=da_assign_op() + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + }/*@bgen(jjtree)*/ + { + jjtree.closeNodeScope(jjtn000, true); + jjtc000 = false; + } +/*@egen*/ + { + jjtn000.setLine(t.beginLine); + jjtn000.setColumn(t.beginColumn); + return t; + }/*@bgen(jjtree)*/ + } catch (Throwable jjte000) { + if (jjtc000) { + jjtree.clearNodeScope(jjtn000); + jjtc000 = false; + } else { + jjtree.popNode(); + } + if (jjte000 instanceof RuntimeException) { + throw (RuntimeException)jjte000; + } + if (jjte000 instanceof ParseException) { + throw (ParseException)jjte000; + } + throw (Error)jjte000; + } finally { + if (jjtc000) { + jjtree.closeNodeScope(jjtn000, true); + } + } +/*@egen*/ +} + +Token da_assign_op() : +{/*@bgen(jjtree) DA_ASSIGN_OP */ + SimpleNode jjtn000 = new SimpleNode(this, JJTDA_ASSIGN_OP); + boolean jjtc000 = true; + jjtree.openNodeScope(jjtn000); +/*@egen*/ + Token t = token; +} +{/*@bgen(jjtree) DA_ASSIGN_OP */ + try { +/*@egen*/ + try { + LOOKAHEAD(2) t=da_assign() + | LOOKAHEAD(2) t=da_scale_up() + | LOOKAHEAD(2) t=da_scale_down() + | LOOKAHEAD(2) t=da_increase() + | LOOKAHEAD(2) t=da_decrease() + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + }/*@bgen(jjtree)*/ + { + jjtree.closeNodeScope(jjtn000, true); + jjtc000 = false; + } +/*@egen*/ + { + jjtn000.setLine(t.beginLine); + jjtn000.setColumn(t.beginColumn); + return t; + }/*@bgen(jjtree)*/ + } catch (Throwable jjte000) { + if (jjtc000) { + jjtree.clearNodeScope(jjtn000); + jjtc000 = false; + } else { + jjtree.popNode(); + } + if (jjte000 instanceof RuntimeException) { + throw (RuntimeException)jjte000; + } + if (jjte000 instanceof ParseException) { + throw (ParseException)jjte000; + } + throw (Error)jjte000; + } finally { + if (jjtc000) { + jjtree.closeNodeScope(jjtn000, true); + } + } +/*@egen*/ +} + +Token da_assign() : +{/*@bgen(jjtree) DA_ASSIGN */ + SimpleNode jjtn000 = new SimpleNode(this, JJTDA_ASSIGN); + boolean jjtc000 = true; + jjtree.openNodeScope(jjtn000); +/*@egen*/ + Token t = token; +} +{/*@bgen(jjtree) DA_ASSIGN */ + try { +/*@egen*/ + try { + t= f_head() f_exp_da() + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + }/*@bgen(jjtree)*/ + { + jjtree.closeNodeScope(jjtn000, true); + jjtc000 = false; + } +/*@egen*/ + { + jjtn000.setLine(t.beginLine); + jjtn000.setColumn(t.beginColumn); + return t; + }/*@bgen(jjtree)*/ + } catch (Throwable jjte000) { + if (jjtc000) { + jjtree.clearNodeScope(jjtn000); + jjtc000 = false; + } else { + jjtree.popNode(); + } + if (jjte000 instanceof RuntimeException) { + throw (RuntimeException)jjte000; + } + if (jjte000 instanceof ParseException) { + throw (ParseException)jjte000; + } + throw (Error)jjte000; + } finally { + if (jjtc000) { + jjtree.closeNodeScope(jjtn000, true); + } + } +/*@egen*/ +} + +Token da_scale_up() : +{/*@bgen(jjtree) DA_SCALE_UP */ + SimpleNode jjtn000 = new SimpleNode(this, JJTDA_SCALE_UP); + boolean jjtc000 = true; + jjtree.openNodeScope(jjtn000); +/*@egen*/ + Token t = token; +} +{/*@bgen(jjtree) DA_SCALE_UP */ + try { +/*@egen*/ + try { + t= f_head() f_exp_da() + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + }/*@bgen(jjtree)*/ + { + jjtree.closeNodeScope(jjtn000, true); + jjtc000 = false; + } +/*@egen*/ + { + jjtn000.setLine(t.beginLine); + jjtn000.setColumn(t.beginColumn); + return t; + }/*@bgen(jjtree)*/ + } catch (Throwable jjte000) { + if (jjtc000) { + jjtree.clearNodeScope(jjtn000); + jjtc000 = false; + } else { + jjtree.popNode(); + } + if (jjte000 instanceof RuntimeException) { + throw (RuntimeException)jjte000; + } + if (jjte000 instanceof ParseException) { + throw (ParseException)jjte000; + } + throw (Error)jjte000; + } finally { + if (jjtc000) { + jjtree.closeNodeScope(jjtn000, true); + } + } +/*@egen*/ +} + +Token da_scale_down() : +{/*@bgen(jjtree) DA_SCALE_DOWN */ + SimpleNode jjtn000 = new SimpleNode(this, JJTDA_SCALE_DOWN); + boolean jjtc000 = true; + jjtree.openNodeScope(jjtn000); +/*@egen*/ + Token t = token; +} +{/*@bgen(jjtree) DA_SCALE_DOWN */ + try { +/*@egen*/ + try { + t= f_head() f_exp_da() + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + }/*@bgen(jjtree)*/ + { + jjtree.closeNodeScope(jjtn000, true); + jjtc000 = false; + } +/*@egen*/ + { + jjtn000.setLine(t.beginLine); + jjtn000.setColumn(t.beginColumn); + return t; + }/*@bgen(jjtree)*/ + } catch (Throwable jjte000) { + if (jjtc000) { + jjtree.clearNodeScope(jjtn000); + jjtc000 = false; + } else { + jjtree.popNode(); + } + if (jjte000 instanceof RuntimeException) { + throw (RuntimeException)jjte000; + } + if (jjte000 instanceof ParseException) { + throw (ParseException)jjte000; + } + throw (Error)jjte000; + } finally { + if (jjtc000) { + jjtree.closeNodeScope(jjtn000, true); + } + } +/*@egen*/ + +} + +Token da_increase() : +{/*@bgen(jjtree) DA_INCREASE */ + SimpleNode jjtn000 = new SimpleNode(this, JJTDA_INCREASE); + boolean jjtc000 = true; + jjtree.openNodeScope(jjtn000); +/*@egen*/ + Token t = token; +} +{/*@bgen(jjtree) DA_INCREASE */ + try { +/*@egen*/ + try { + t= f_head() f_exp_da() + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + }/*@bgen(jjtree)*/ + { + jjtree.closeNodeScope(jjtn000, true); + jjtc000 = false; + } +/*@egen*/ + { + jjtn000.setLine(t.beginLine); + jjtn000.setColumn(t.beginColumn); + return t; + }/*@bgen(jjtree)*/ + } catch (Throwable jjte000) { + if (jjtc000) { + jjtree.clearNodeScope(jjtn000); + jjtc000 = false; + } else { + jjtree.popNode(); + } + if (jjte000 instanceof RuntimeException) { + throw (RuntimeException)jjte000; + } + if (jjte000 instanceof ParseException) { + throw (ParseException)jjte000; + } + throw (Error)jjte000; + } finally { + if (jjtc000) { + jjtree.closeNodeScope(jjtn000, true); + } + } +/*@egen*/ +} + +Token da_decrease() : +{/*@bgen(jjtree) DA_DECREASE */ + SimpleNode jjtn000 = new SimpleNode(this, JJTDA_DECREASE); + boolean jjtc000 = true; + jjtree.openNodeScope(jjtn000); +/*@egen*/ + Token t = token; +} +{/*@bgen(jjtree) DA_DECREASE */ + try { +/*@egen*/ + try { + t= f_head() f_exp_da() + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + }/*@bgen(jjtree)*/ + { + jjtree.closeNodeScope(jjtn000, true); + jjtc000 = false; + } +/*@egen*/ + { + jjtn000.setLine(t.beginLine); + jjtn000.setColumn(t.beginColumn); + return t; + }/*@bgen(jjtree)*/ + } catch (Throwable jjte000) { + if (jjtc000) { + jjtree.clearNodeScope(jjtn000); + jjtc000 = false; + } else { + jjtree.popNode(); + } + if (jjte000 instanceof RuntimeException) { + throw (RuntimeException)jjte000; + } + if (jjte000 instanceof ParseException) { + throw (ParseException)jjte000; + } + throw (Error)jjte000; + } finally { + if (jjtc000) { + jjtree.closeNodeScope(jjtn000, true); + } + } +/*@egen*/ +} + +Token when_da_effect() : +{/*@bgen(jjtree) WHEN_DA_EFFECT */ + SimpleNode jjtn000 = new SimpleNode(this, JJTWHEN_DA_EFFECT); + boolean jjtc000 = true; + jjtree.openNodeScope(jjtn000); +/*@egen*/ + Token t = token; +} +{/*@bgen(jjtree) WHEN_DA_EFFECT */ + try { +/*@egen*/ + try { + t= da_gd() timed_effect() + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + }/*@bgen(jjtree)*/ + { + jjtree.closeNodeScope(jjtn000, true); + jjtc000 = false; + } +/*@egen*/ + { + jjtn000.setLine(t.beginLine); + jjtn000.setColumn(t.beginColumn); + return t; + }/*@bgen(jjtree)*/ + } catch (Throwable jjte000) { + if (jjtc000) { + jjtree.clearNodeScope(jjtn000); + jjtc000 = false; + } else { + jjtree.popNode(); + } + if (jjte000 instanceof RuntimeException) { + throw (RuntimeException)jjte000; + } + if (jjte000 instanceof ParseException) { + throw (ParseException)jjte000; + } + throw (Error)jjte000; + } finally { + if (jjtc000) { + jjtree.closeNodeScope(jjtn000, true); + } + } +/*@egen*/ +} + + +Token forall_da_effect() : +{/*@bgen(jjtree) FORALL_DA_EFFECT */ + SimpleNode jjtn000 = new SimpleNode(this, JJTFORALL_DA_EFFECT); + boolean jjtc000 = true; + jjtree.openNodeScope(jjtn000); +/*@egen*/ + Token t = token; +} +{/*@bgen(jjtree) FORALL_DA_EFFECT */ + try { +/*@egen*/ + try { + t= typed_list(LexerTreeConstants.JJTVARIABLE) da_effect() + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + }/*@bgen(jjtree)*/ + { + jjtree.closeNodeScope(jjtn000, true); + jjtc000 = false; + } +/*@egen*/ + { + jjtn000.setLine(t.beginLine); + jjtn000.setColumn(t.beginColumn); + return t; + }/*@bgen(jjtree)*/ + } catch (Throwable jjte000) { + if (jjtc000) { + jjtree.clearNodeScope(jjtn000); + jjtc000 = false; + } else { + jjtree.popNode(); + } + if (jjte000 instanceof RuntimeException) { + throw (RuntimeException)jjte000; + } + if (jjte000 instanceof ParseException) { + throw (ParseException)jjte000; + } + throw (Error)jjte000; + } finally { + if (jjtc000) { + jjtree.closeNodeScope(jjtn000, true); + } + } +/*@egen*/ +} + +Token and_da_effect() : +{/*@bgen(jjtree) AND_DA_EFFECT */ + SimpleNode jjtn000 = new SimpleNode(this, JJTAND_DA_EFFECT); + boolean jjtc000 = true; + jjtree.openNodeScope(jjtn000); +/*@egen*/ + Token t = token; +} +{/*@bgen(jjtree) AND_DA_EFFECT */ + try { +/*@egen*/ + try { + t= (da_effect())* + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + }/*@bgen(jjtree)*/ + { + jjtree.closeNodeScope(jjtn000, true); + jjtc000 = false; + } +/*@egen*/ + { + jjtn000.setLine(t.beginLine); + jjtn000.setColumn(t.beginColumn); + return t; + }/*@bgen(jjtree)*/ + } catch (Throwable jjte000) { + if (jjtc000) { + jjtree.clearNodeScope(jjtn000); + jjtc000 = false; + } else { + jjtree.popNode(); + } + if (jjte000 instanceof RuntimeException) { + throw (RuntimeException)jjte000; + } + if (jjte000 instanceof ParseException) { + throw (ParseException)jjte000; + } + throw (Error)jjte000; + } finally { + if (jjtc000) { + jjtree.closeNodeScope(jjtn000, true); + } + } +/*@egen*/ +} + +Token timed_effect() : +{/*@bgen(jjtree) TIMED_EFFECT */ + SimpleNode jjtn000 = new SimpleNode(this, JJTTIMED_EFFECT); + boolean jjtc000 = true; + jjtree.openNodeScope(jjtn000); +/*@egen*/ + Token t = token; +} +{/*@bgen(jjtree) TIMED_EFFECT */ + try { +/*@egen*/ + try { + LOOKAHEAD(2) t=at_da_effect() + | LOOKAHEAD(2) t=at_f_assign_da_effect() + | LOOKAHEAD(2) t=assign_op_t() + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + }/*@bgen(jjtree)*/ + { + jjtree.closeNodeScope(jjtn000, true); + jjtc000 = false; + } +/*@egen*/ + { + jjtn000.setLine(t.beginLine); + jjtn000.setColumn(t.beginColumn); + return t; + }/*@bgen(jjtree)*/ + } catch (Throwable jjte000) { + if (jjtc000) { + jjtree.clearNodeScope(jjtn000); + jjtc000 = false; + } else { + jjtree.popNode(); + } + if (jjte000 instanceof RuntimeException) { + throw (RuntimeException)jjte000; + } + if (jjte000 instanceof ParseException) { + throw (ParseException)jjte000; + } + throw (Error)jjte000; + } finally { + if (jjtc000) { + jjtree.closeNodeScope(jjtn000, true); + } + } +/*@egen*/ +} + +Token at_f_assign_da_effect() : +{/*@bgen(jjtree) AT_F_ASSIGN_DA_EFFECT */ + SimpleNode jjtn000 = new SimpleNode(this, JJTAT_F_ASSIGN_DA_EFFECT); + boolean jjtc000 = true; + jjtree.openNodeScope(jjtn000); +/*@egen*/ + Token t = token; +} +{/*@bgen(jjtree) AT_F_ASSIGN_DA_EFFECT */ + try { +/*@egen*/ + try { + LOOKAHEAD(3) t=at_start_f_assign_da_effect() + | LOOKAHEAD(3) t=at_end_f_assign_da_effect() + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + }/*@bgen(jjtree)*/ + { + jjtree.closeNodeScope(jjtn000, true); + jjtc000 = false; + } +/*@egen*/ + { + jjtn000.setLine(t.beginLine); + jjtn000.setColumn(t.beginColumn); + return t; + }/*@bgen(jjtree)*/ + } catch (Throwable jjte000) { + if (jjtc000) { + jjtree.clearNodeScope(jjtn000); + jjtc000 = false; + } else { + jjtree.popNode(); + } + if (jjte000 instanceof RuntimeException) { + throw (RuntimeException)jjte000; + } + if (jjte000 instanceof ParseException) { + throw (ParseException)jjte000; + } + throw (Error)jjte000; + } finally { + if (jjtc000) { + jjtree.closeNodeScope(jjtn000, true); + } + } +/*@egen*/ +} + +Token at_start_f_assign_da_effect() : +{/*@bgen(jjtree) AT_START_F_ASSIGN_DA_EFFECT */ + SimpleNode jjtn000 = new SimpleNode(this, JJTAT_START_F_ASSIGN_DA_EFFECT); + boolean jjtc000 = true; + jjtree.openNodeScope(jjtn000); +/*@egen*/ + Token t = token; +} +{/*@bgen(jjtree) AT_START_F_ASSIGN_DA_EFFECT */ + try { +/*@egen*/ + try { + t= f_assign_da() + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + }/*@bgen(jjtree)*/ + { + jjtree.closeNodeScope(jjtn000, true); + jjtc000 = false; + } +/*@egen*/ + { + jjtn000.setLine(t.beginLine); + jjtn000.setColumn(t.beginColumn); + return t; + }/*@bgen(jjtree)*/ + } catch (Throwable jjte000) { + if (jjtc000) { + jjtree.clearNodeScope(jjtn000); + jjtc000 = false; + } else { + jjtree.popNode(); + } + if (jjte000 instanceof RuntimeException) { + throw (RuntimeException)jjte000; + } + if (jjte000 instanceof ParseException) { + throw (ParseException)jjte000; + } + throw (Error)jjte000; + } finally { + if (jjtc000) { + jjtree.closeNodeScope(jjtn000, true); + } + } +/*@egen*/ +} + + +Token at_end_f_assign_da_effect() : +{/*@bgen(jjtree) AT_END_F_ASSIGN_DA_EFFECT */ + SimpleNode jjtn000 = new SimpleNode(this, JJTAT_END_F_ASSIGN_DA_EFFECT); + boolean jjtc000 = true; + jjtree.openNodeScope(jjtn000); +/*@egen*/ + Token t = token; +} +{/*@bgen(jjtree) AT_END_F_ASSIGN_DA_EFFECT */ + try { +/*@egen*/ + try { + t= f_assign_da() + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + }/*@bgen(jjtree)*/ + { + jjtree.closeNodeScope(jjtn000, true); + jjtc000 = false; + } +/*@egen*/ + { + jjtn000.setLine(t.beginLine); + jjtn000.setColumn(t.beginColumn); + return t; + }/*@bgen(jjtree)*/ + } catch (Throwable jjte000) { + if (jjtc000) { + jjtree.clearNodeScope(jjtn000); + jjtc000 = false; + } else { + jjtree.popNode(); + } + if (jjte000 instanceof RuntimeException) { + throw (RuntimeException)jjte000; + } + if (jjte000 instanceof ParseException) { + throw (ParseException)jjte000; + } + throw (Error)jjte000; + } finally { + if (jjtc000) { + jjtree.closeNodeScope(jjtn000, true); + } + } +/*@egen*/ +} + +Token at_da_effect() : +{/*@bgen(jjtree) AT_DA_EFFECT */ + SimpleNode jjtn000 = new SimpleNode(this, JJTAT_DA_EFFECT); + boolean jjtc000 = true; + jjtree.openNodeScope(jjtn000); +/*@egen*/ + Token t = token; +} +{/*@bgen(jjtree) AT_DA_EFFECT */ + try { +/*@egen*/ + try { + LOOKAHEAD(4) t=at_start_da_effect() + | LOOKAHEAD(4) t=at_end_da_effect() + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + }/*@bgen(jjtree)*/ + { + jjtree.closeNodeScope(jjtn000, true); + jjtc000 = false; + } +/*@egen*/ + { + jjtn000.setLine(t.beginLine); + jjtn000.setColumn(t.beginColumn); + return t; + }/*@bgen(jjtree)*/ + } catch (Throwable jjte000) { + if (jjtc000) { + jjtree.clearNodeScope(jjtn000); + jjtc000 = false; + } else { + jjtree.popNode(); + } + if (jjte000 instanceof RuntimeException) { + throw (RuntimeException)jjte000; + } + if (jjte000 instanceof ParseException) { + throw (ParseException)jjte000; + } + throw (Error)jjte000; + } finally { + if (jjtc000) { + jjtree.closeNodeScope(jjtn000, true); + } + } +/*@egen*/ +} + +Token at_start_da_effect() : +{/*@bgen(jjtree) AT_START_DA_EFFECT */ + SimpleNode jjtn000 = new SimpleNode(this, JJTAT_START_DA_EFFECT); + boolean jjtc000 = true; + jjtree.openNodeScope(jjtn000); +/*@egen*/ + Token t = token; +} +{/*@bgen(jjtree) AT_START_DA_EFFECT */ + try { +/*@egen*/ + try { + t= literal(LexerTreeConstants.JJTTERM) + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + }/*@bgen(jjtree)*/ + { + jjtree.closeNodeScope(jjtn000, true); + jjtc000 = false; + } +/*@egen*/ + { + jjtn000.setLine(t.beginLine); + jjtn000.setColumn(t.beginColumn); + return t; + }/*@bgen(jjtree)*/ + } catch (Throwable jjte000) { + if (jjtc000) { + jjtree.clearNodeScope(jjtn000); + jjtc000 = false; + } else { + jjtree.popNode(); + } + if (jjte000 instanceof RuntimeException) { + throw (RuntimeException)jjte000; + } + if (jjte000 instanceof ParseException) { + throw (ParseException)jjte000; + } + throw (Error)jjte000; + } finally { + if (jjtc000) { + jjtree.closeNodeScope(jjtn000, true); + } + } +/*@egen*/ +} + + +Token at_end_da_effect() : +{/*@bgen(jjtree) AT_END_DA_EFFECT */ + SimpleNode jjtn000 = new SimpleNode(this, JJTAT_END_DA_EFFECT); + boolean jjtc000 = true; + jjtree.openNodeScope(jjtn000); +/*@egen*/ + Token t = token; +} +{/*@bgen(jjtree) AT_END_DA_EFFECT */ + try { +/*@egen*/ + try { + t= literal(LexerTreeConstants.JJTTERM) + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + }/*@bgen(jjtree)*/ + { + jjtree.closeNodeScope(jjtn000, true); + jjtc000 = false; + } +/*@egen*/ + { + jjtn000.setLine(t.beginLine); + jjtn000.setColumn(t.beginColumn); + return t; + }/*@bgen(jjtree)*/ + } catch (Throwable jjte000) { + if (jjtc000) { + jjtree.clearNodeScope(jjtn000); + jjtc000 = false; + } else { + jjtree.popNode(); + } + if (jjte000 instanceof RuntimeException) { + throw (RuntimeException)jjte000; + } + if (jjte000 instanceof ParseException) { + throw (ParseException)jjte000; + } + throw (Error)jjte000; + } finally { + if (jjtc000) { + jjtree.closeNodeScope(jjtn000, true); + } + } +/*@egen*/ +} + +Token assign_op_t() : +{/*@bgen(jjtree) ASSIGN_OP_T */ + SimpleNode jjtn000 = new SimpleNode(this, JJTASSIGN_OP_T); + boolean jjtc000 = true; + jjtree.openNodeScope(jjtn000); +/*@egen*/ + Token t = token; +} +{/*@bgen(jjtree) ASSIGN_OP_T */ + try { +/*@egen*/ + try { + LOOKAHEAD(2) t=increase_assign_op_t() + | LOOKAHEAD(2) t=decrease_assign_op_t() + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + }/*@bgen(jjtree)*/ + { + jjtree.closeNodeScope(jjtn000, true); + jjtc000 = false; + } +/*@egen*/ + { + jjtn000.setLine(t.beginLine); + jjtn000.setColumn(t.beginColumn); + return t; + }/*@bgen(jjtree)*/ + } catch (Throwable jjte000) { + if (jjtc000) { + jjtree.clearNodeScope(jjtn000); + jjtc000 = false; + } else { + jjtree.popNode(); + } + if (jjte000 instanceof RuntimeException) { + throw (RuntimeException)jjte000; + } + if (jjte000 instanceof ParseException) { + throw (ParseException)jjte000; + } + throw (Error)jjte000; + } finally { + if (jjtc000) { + jjtree.closeNodeScope(jjtn000, true); + } + } +/*@egen*/ +} + +Token increase_assign_op_t() : +{/*@bgen(jjtree) INCREASE_ASSIGN_OP_T */ + SimpleNode jjtn000 = new SimpleNode(this, JJTINCREASE_ASSIGN_OP_T); + boolean jjtc000 = true; + jjtree.openNodeScope(jjtn000); +/*@egen*/ + Token t = token; +} +{/*@bgen(jjtree) INCREASE_ASSIGN_OP_T */ + try { +/*@egen*/ + try { + t= f_head() f_exp_t() + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + }/*@bgen(jjtree)*/ + { + jjtree.closeNodeScope(jjtn000, true); + jjtc000 = false; + } +/*@egen*/ + { + jjtn000.setLine(t.beginLine); + jjtn000.setColumn(t.beginColumn); + return t; + }/*@bgen(jjtree)*/ + } catch (Throwable jjte000) { + if (jjtc000) { + jjtree.clearNodeScope(jjtn000); + jjtc000 = false; + } else { + jjtree.popNode(); + } + if (jjte000 instanceof RuntimeException) { + throw (RuntimeException)jjte000; + } + if (jjte000 instanceof ParseException) { + throw (ParseException)jjte000; + } + throw (Error)jjte000; + } finally { + if (jjtc000) { + jjtree.closeNodeScope(jjtn000, true); + } + } +/*@egen*/ +} + +Token decrease_assign_op_t() : +{/*@bgen(jjtree) DECREASE_ASSIGN_OP_T */ + SimpleNode jjtn000 = new SimpleNode(this, JJTDECREASE_ASSIGN_OP_T); + boolean jjtc000 = true; + jjtree.openNodeScope(jjtn000); +/*@egen*/ + Token t = token; +} +{/*@bgen(jjtree) DECREASE_ASSIGN_OP_T */ + try { +/*@egen*/ + try { + t= f_head() f_exp_t() + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + }/*@bgen(jjtree)*/ + { + jjtree.closeNodeScope(jjtn000, true); + jjtc000 = false; + } +/*@egen*/ + { + jjtn000.setLine(t.beginLine); + jjtn000.setColumn(t.beginColumn); + return t; + }/*@bgen(jjtree)*/ + } catch (Throwable jjte000) { + if (jjtc000) { + jjtree.clearNodeScope(jjtn000); + jjtc000 = false; + } else { + jjtree.popNode(); + } + if (jjte000 instanceof RuntimeException) { + throw (RuntimeException)jjte000; + } + if (jjte000 instanceof ParseException) { + throw (ParseException)jjte000; + } + throw (Error)jjte000; + } finally { + if (jjtc000) { + jjtree.closeNodeScope(jjtn000, true); + } + } +/*@egen*/ +} + +Token f_exp_t() : +{/*@bgen(jjtree) F_EXP_T */ + SimpleNode jjtn000 = new SimpleNode(this, JJTF_EXP_T); + boolean jjtc000 = true; + jjtree.openNodeScope(jjtn000); +/*@egen*/ + Token t = token; +} +{/*@bgen(jjtree) F_EXP_T */ + try { +/*@egen*/ + try { + LOOKAHEAD(2) t= continous_variable() f_exp() + | LOOKAHEAD(2) t= f_exp() continous_variable() + | LOOKAHEAD(2) t=continous_variable() + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + }/*@bgen(jjtree)*/ + { + jjtree.closeNodeScope(jjtn000, true); + jjtc000 = false; + } +/*@egen*/ + { + jjtn000.setLine(t.beginLine); + jjtn000.setColumn(t.beginColumn); + return t; + }/*@bgen(jjtree)*/ + } catch (Throwable jjte000) { + if (jjtc000) { + jjtree.clearNodeScope(jjtn000); + jjtc000 = false; + } else { + jjtree.popNode(); + } + if (jjte000 instanceof RuntimeException) { + throw (RuntimeException)jjte000; + } + if (jjte000 instanceof ParseException) { + throw (ParseException)jjte000; + } + throw (Error)jjte000; + } finally { + if (jjtc000) { + jjtree.closeNodeScope(jjtn000, true); + } + } +/*@egen*/ +} + +Token continous_variable() : +{/*@bgen(jjtree) CONTINOUS_VARIABLE */ + SimpleNode jjtn000 = new SimpleNode(this, JJTCONTINOUS_VARIABLE); + boolean jjtc000 = true; + jjtree.openNodeScope(jjtn000); +/*@egen*/ + Token t = token; +} +{/*@bgen(jjtree) CONTINOUS_VARIABLE */ + try { +/*@egen*/ + try { + t= + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + }/*@bgen(jjtree)*/ + { + jjtree.closeNodeScope(jjtn000, true); + jjtc000 = false; + } +/*@egen*/ + { + jjtn000.setLine(t.beginLine); + jjtn000.setColumn(t.beginColumn); + jjtn000.setImage(t.image); + return t; + }/*@bgen(jjtree)*/ + } finally { + if (jjtc000) { + jjtree.closeNodeScope(jjtn000, true); + } + } +/*@egen*/ + +} + +Token f_assign_da() : +{/*@bgen(jjtree) F_ASSIGN_DA */ + SimpleNode jjtn000 = new SimpleNode(this, JJTF_ASSIGN_DA); + boolean jjtc000 = true; + jjtree.openNodeScope(jjtn000); +/*@egen*/ + Token t = token; +} +{/*@bgen(jjtree) F_ASSIGN_DA */ + try { +/*@egen*/ + try { + LOOKAHEAD(2) t=da_assign() + | LOOKAHEAD(2) t=da_scale_up() + | LOOKAHEAD(2) t=da_scale_down() + | LOOKAHEAD(2) t=da_increase() + | LOOKAHEAD(2) t=da_decrease() + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + }/*@bgen(jjtree)*/ + { + jjtree.closeNodeScope(jjtn000, true); + jjtc000 = false; + } +/*@egen*/ + { + jjtn000.setLine(t.beginLine); + jjtn000.setColumn(t.beginColumn); + return t; + }/*@bgen(jjtree)*/ + } catch (Throwable jjte000) { + if (jjtc000) { + jjtree.clearNodeScope(jjtn000); + jjtc000 = false; + } else { + jjtree.popNode(); + } + if (jjte000 instanceof RuntimeException) { + throw (RuntimeException)jjte000; + } + if (jjte000 instanceof ParseException) { + throw (ParseException)jjte000; + } + throw (Error)jjte000; + } finally { + if (jjtc000) { + jjtree.closeNodeScope(jjtn000, true); + } + } +/*@egen*/ +} + +Token f_exp_da() : +{/*@bgen(jjtree) F_EXP_DA */ + SimpleNode jjtn000 = new SimpleNode(this, JJTF_EXP_DA); + boolean jjtc000 = true; + jjtree.openNodeScope(jjtn000); +/*@egen*/ + Token t = token; +} +{/*@bgen(jjtree) F_EXP_DA */ + try { +/*@egen*/ + try { + LOOKAHEAD(3) t=f_exp() + | LOOKAHEAD(3) t=da_binary_op() + | LOOKAHEAD(3) t=da_unary_op() + | LOOKAHEAD(3) t=var_duration() + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + }/*@bgen(jjtree)*/ + { + jjtree.closeNodeScope(jjtn000, true); + jjtc000 = false; + } +/*@egen*/ + { + jjtn000.setLine(t.beginLine); + jjtn000.setColumn(t.beginColumn); + return t; + }/*@bgen(jjtree)*/ + } catch (Throwable jjte000) { + if (jjtc000) { + jjtree.clearNodeScope(jjtn000); + jjtc000 = false; + } else { + jjtree.popNode(); + } + if (jjte000 instanceof RuntimeException) { + throw (RuntimeException)jjte000; + } + if (jjte000 instanceof ParseException) { + throw (ParseException)jjte000; + } + throw (Error)jjte000; + } finally { + if (jjtc000) { + jjtree.closeNodeScope(jjtn000, true); + } + } +/*@egen*/ +} + + +Token da_binary_op() : +{/*@bgen(jjtree) DA_BINARY_OP */ + SimpleNode jjtn000 = new SimpleNode(this, JJTDA_BINARY_OP); + boolean jjtc000 = true; + jjtree.openNodeScope(jjtn000); +/*@egen*/ + Token t = token; +} +{/*@bgen(jjtree) DA_BINARY_OP */ + try { +/*@egen*/ + try { + LOOKAHEAD(2) t=da_add_op() + | LOOKAHEAD(2) t=da_substract_op() + | LOOKAHEAD(2) t=da_multiply_op() + | LOOKAHEAD(2) t=da_divide_op() + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + }/*@bgen(jjtree)*/ + { + jjtree.closeNodeScope(jjtn000, true); + jjtc000 = false; + } +/*@egen*/ + { + jjtn000.setLine(t.beginLine); + jjtn000.setColumn(t.beginColumn); + return t; + }/*@bgen(jjtree)*/ + } catch (Throwable jjte000) { + if (jjtc000) { + jjtree.clearNodeScope(jjtn000); + jjtc000 = false; + } else { + jjtree.popNode(); + } + if (jjte000 instanceof RuntimeException) { + throw (RuntimeException)jjte000; + } + if (jjte000 instanceof ParseException) { + throw (ParseException)jjte000; + } + throw (Error)jjte000; + } finally { + if (jjtc000) { + jjtree.closeNodeScope(jjtn000, true); + } + } +/*@egen*/ +} + +Token da_add_op() : +{/*@bgen(jjtree) DA_ADD_OP */ + SimpleNode jjtn000 = new SimpleNode(this, JJTDA_ADD_OP); + boolean jjtc000 = true; + jjtree.openNodeScope(jjtn000); +/*@egen*/ + Token t = token; +} +{/*@bgen(jjtree) DA_ADD_OP */ + try { +/*@egen*/ + try { + t= f_head() f_exp_da() + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + }/*@bgen(jjtree)*/ + { + jjtree.closeNodeScope(jjtn000, true); + jjtc000 = false; + } +/*@egen*/ + { + jjtn000.setLine(t.beginLine); + jjtn000.setColumn(t.beginColumn); + return t; + }/*@bgen(jjtree)*/ + } catch (Throwable jjte000) { + if (jjtc000) { + jjtree.clearNodeScope(jjtn000); + jjtc000 = false; + } else { + jjtree.popNode(); + } + if (jjte000 instanceof RuntimeException) { + throw (RuntimeException)jjte000; + } + if (jjte000 instanceof ParseException) { + throw (ParseException)jjte000; + } + throw (Error)jjte000; + } finally { + if (jjtc000) { + jjtree.closeNodeScope(jjtn000, true); + } + } +/*@egen*/ +} + +Token da_substract_op() : +{/*@bgen(jjtree) DA_SUBSTRACT_OP */ + SimpleNode jjtn000 = new SimpleNode(this, JJTDA_SUBSTRACT_OP); + boolean jjtc000 = true; + jjtree.openNodeScope(jjtn000); +/*@egen*/ + Token t = token; +} +{/*@bgen(jjtree) DA_SUBSTRACT_OP */ + try { +/*@egen*/ + try { + t= f_head() f_exp_da() + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + }/*@bgen(jjtree)*/ + { + jjtree.closeNodeScope(jjtn000, true); + jjtc000 = false; + } +/*@egen*/ + { + jjtn000.setLine(t.beginLine); + jjtn000.setColumn(t.beginColumn); + return t; + }/*@bgen(jjtree)*/ + } catch (Throwable jjte000) { + if (jjtc000) { + jjtree.clearNodeScope(jjtn000); + jjtc000 = false; + } else { + jjtree.popNode(); + } + if (jjte000 instanceof RuntimeException) { + throw (RuntimeException)jjte000; + } + if (jjte000 instanceof ParseException) { + throw (ParseException)jjte000; + } + throw (Error)jjte000; + } finally { + if (jjtc000) { + jjtree.closeNodeScope(jjtn000, true); + } + } +/*@egen*/ +} + +Token da_multiply_op() : +{/*@bgen(jjtree) DA_MULTIPLY_OP */ + SimpleNode jjtn000 = new SimpleNode(this, JJTDA_MULTIPLY_OP); + boolean jjtc000 = true; + jjtree.openNodeScope(jjtn000); +/*@egen*/ + Token t = token; +} +{/*@bgen(jjtree) DA_MULTIPLY_OP */ + try { +/*@egen*/ + try { + t= f_head() f_exp_da() + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + }/*@bgen(jjtree)*/ + { + jjtree.closeNodeScope(jjtn000, true); + jjtc000 = false; + } +/*@egen*/ + { + jjtn000.setLine(t.beginLine); + jjtn000.setColumn(t.beginColumn); + return t; + }/*@bgen(jjtree)*/ + } catch (Throwable jjte000) { + if (jjtc000) { + jjtree.clearNodeScope(jjtn000); + jjtc000 = false; + } else { + jjtree.popNode(); + } + if (jjte000 instanceof RuntimeException) { + throw (RuntimeException)jjte000; + } + if (jjte000 instanceof ParseException) { + throw (ParseException)jjte000; + } + throw (Error)jjte000; + } finally { + if (jjtc000) { + jjtree.closeNodeScope(jjtn000, true); + } + } +/*@egen*/ +} + +Token da_divide_op() : +{/*@bgen(jjtree) DA_DIVIDE_OP */ + SimpleNode jjtn000 = new SimpleNode(this, JJTDA_DIVIDE_OP); + boolean jjtc000 = true; + jjtree.openNodeScope(jjtn000); +/*@egen*/ + Token t = token; +} +{/*@bgen(jjtree) DA_DIVIDE_OP */ + try { +/*@egen*/ + try { + t=
f_head() f_exp_da() + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + }/*@bgen(jjtree)*/ + { + jjtree.closeNodeScope(jjtn000, true); + jjtc000 = false; + } +/*@egen*/ + { + jjtn000.setLine(t.beginLine); + jjtn000.setColumn(t.beginColumn); + return t; + }/*@bgen(jjtree)*/ + } catch (Throwable jjte000) { + if (jjtc000) { + jjtree.clearNodeScope(jjtn000); + jjtc000 = false; + } else { + jjtree.popNode(); + } + if (jjte000 instanceof RuntimeException) { + throw (RuntimeException)jjte000; + } + if (jjte000 instanceof ParseException) { + throw (ParseException)jjte000; + } + throw (Error)jjte000; + } finally { + if (jjtc000) { + jjtree.closeNodeScope(jjtn000, true); + } + } +/*@egen*/ +} + +Token da_unary_op() : +{/*@bgen(jjtree) DA_UNARY_OP */ + SimpleNode jjtn000 = new SimpleNode(this, JJTDA_UNARY_OP); + boolean jjtc000 = true; + jjtree.openNodeScope(jjtn000); +/*@egen*/ + Token t = token; +} +{/*@bgen(jjtree) DA_UNARY_OP */ + try { +/*@egen*/ + try { + t= f_exp_da() + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + }/*@bgen(jjtree)*/ + { + jjtree.closeNodeScope(jjtn000, true); + jjtc000 = false; + } +/*@egen*/ + { + jjtn000.setLine(t.beginLine); + jjtn000.setColumn(t.beginColumn); + return t; + }/*@bgen(jjtree)*/ + } catch (Throwable jjte000) { + if (jjtc000) { + jjtree.clearNodeScope(jjtn000); + jjtc000 = false; + } else { + jjtree.popNode(); + } + if (jjte000 instanceof RuntimeException) { + throw (RuntimeException)jjte000; + } + if (jjte000 instanceof ParseException) { + throw (ParseException)jjte000; + } + throw (Error)jjte000; + } finally { + if (jjtc000) { + jjtree.closeNodeScope(jjtn000, true); + } + } +/*@egen*/ +} + +Token derived_def() : +{/*@bgen(jjtree) DERIVED_DEF */ + SimpleNode jjtn000 = new SimpleNode(this, JJTDERIVED_DEF); + boolean jjtc000 = true; + jjtree.openNodeScope(jjtn000); +/*@egen*/ + Token t = token; +} +{/*@bgen(jjtree) DERIVED_DEF */ + try { +/*@egen*/ + try { + t= atomic_formula(LexerTreeConstants.JJTVARIABLE) gd() + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + }/*@bgen(jjtree)*/ + { + jjtree.closeNodeScope(jjtn000, true); + jjtc000 = false; + } +/*@egen*/ + { + jjtn000.setLine(t.beginLine); + jjtn000.setColumn(t.beginColumn); + return t; + }/*@bgen(jjtree)*/ + } catch (Throwable jjte000) { + if (jjtc000) { + jjtree.clearNodeScope(jjtn000); + jjtc000 = false; + } else { + jjtree.popNode(); + } + if (jjte000 instanceof RuntimeException) { + throw (RuntimeException)jjte000; + } + if (jjte000 instanceof ParseException) { + throw (ParseException)jjte000; + } + throw (Error)jjte000; + } finally { + if (jjtc000) { + jjtree.closeNodeScope(jjtn000, true); + } + } +/*@egen*/ +} + +Token problem() : +{/*@bgen(jjtree) PROBLEM */ + SimpleNode jjtn000 = new SimpleNode(this, JJTPROBLEM); + boolean jjtc000 = true; + jjtree.openNodeScope(jjtn000); +/*@egen*/ + Token t = token; +} +{/*@bgen(jjtree) PROBLEM */ + try { +/*@egen*/ + try { + t= problem_name() + domain_name() + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + } + [LOOKAHEAD(2) require_def()] + [LOOKAHEAD(2) object_declaration()] + init() + goal() + [LOOKAHEAD(2) constraints()] + [LOOKAHEAD(2) metric_spec()] + // [length-spec()] not implemented + /*@bgen(jjtree)*/ + { + jjtree.closeNodeScope(jjtn000, true); + jjtc000 = false; + } +/*@egen*/ { + jjtn000.setLine(t.beginLine); + jjtn000.setColumn(t.beginColumn); + return t; + }/*@bgen(jjtree)*/ + } catch (Throwable jjte000) { + if (jjtc000) { + jjtree.clearNodeScope(jjtn000); + jjtc000 = false; + } else { + jjtree.popNode(); + } + if (jjte000 instanceof RuntimeException) { + throw (RuntimeException)jjte000; + } + if (jjte000 instanceof ParseException) { + throw (ParseException)jjte000; + } + throw (Error)jjte000; + } finally { + if (jjtc000) { + jjtree.closeNodeScope(jjtn000, true); + } + } +/*@egen*/ +} + +Token problem_name() : +{/*@bgen(jjtree) PROBLEM_NAME */ + SimpleNode jjtn000 = new SimpleNode(this, JJTPROBLEM_NAME); + boolean jjtc000 = true; + jjtree.openNodeScope(jjtn000); +/*@egen*/ + Token t = token; +} +{/*@bgen(jjtree) PROBLEM_NAME */ + try { +/*@egen*/ + try { + t= + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + }/*@bgen(jjtree)*/ + { + jjtree.closeNodeScope(jjtn000, true); + jjtc000 = false; + } +/*@egen*/ + { + jjtn000.setLine(t.beginLine); + jjtn000.setColumn(t.beginColumn); + jjtn000.setImage(t.image); + return t; + }/*@bgen(jjtree)*/ + } finally { + if (jjtc000) { + jjtree.closeNodeScope(jjtn000, true); + } + } +/*@egen*/ +} + +Token domain_name() : +{/*@bgen(jjtree) DOMAIN_NAME */ + SimpleNode jjtn000 = new SimpleNode(this, JJTDOMAIN_NAME); + boolean jjtc000 = true; + jjtree.openNodeScope(jjtn000); +/*@egen*/ + Token t = token; +} +{/*@bgen(jjtree) DOMAIN_NAME */ + try { +/*@egen*/ + try { + t= + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + }/*@bgen(jjtree)*/ + { + jjtree.closeNodeScope(jjtn000, true); + jjtc000 = false; + } +/*@egen*/ + { + jjtn000.setLine(t.beginLine); + jjtn000.setColumn(t.beginColumn); + jjtn000.setImage(t.image); + return t; + }/*@bgen(jjtree)*/ + } finally { + if (jjtc000) { + jjtree.closeNodeScope(jjtn000, true); + } + } +/*@egen*/ +} + +Token object_declaration() : +{/*@bgen(jjtree) OBJECT_DECLARATION */ + SimpleNode jjtn000 = new SimpleNode(this, JJTOBJECT_DECLARATION); + boolean jjtc000 = true; + jjtree.openNodeScope(jjtn000); +/*@egen*/ + Token t = token; +} +{/*@bgen(jjtree) OBJECT_DECLARATION */ + try { +/*@egen*/ + try { + t= typed_list(LexerTreeConstants.JJTCONSTANT) + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + }/*@bgen(jjtree)*/ + { + jjtree.closeNodeScope(jjtn000, true); + jjtc000 = false; + } +/*@egen*/ + { + jjtn000.setLine(t.beginLine); + jjtn000.setColumn(t.beginColumn); + return t; + }/*@bgen(jjtree)*/ + } catch (Throwable jjte000) { + if (jjtc000) { + jjtree.clearNodeScope(jjtn000); + jjtc000 = false; + } else { + jjtree.popNode(); + } + if (jjte000 instanceof RuntimeException) { + throw (RuntimeException)jjte000; + } + if (jjte000 instanceof ParseException) { + throw (ParseException)jjte000; + } + throw (Error)jjte000; + } finally { + if (jjtc000) { + jjtree.closeNodeScope(jjtn000, true); + } + } +/*@egen*/ +} + +Token init() : +{/*@bgen(jjtree) INIT */ + SimpleNode jjtn000 = new SimpleNode(this, JJTINIT); + boolean jjtc000 = true; + jjtree.openNodeScope(jjtn000); +/*@egen*/ + Token t = token; +} +{/*@bgen(jjtree) INIT */ + try { +/*@egen*/ + try { + t= (init_el())* + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + }/*@bgen(jjtree)*/ + { + jjtree.closeNodeScope(jjtn000, true); + jjtc000 = false; + } +/*@egen*/ + { + jjtn000.setLine(t.beginLine); + jjtn000.setColumn(t.beginColumn); + return t; + }/*@bgen(jjtree)*/ + } catch (Throwable jjte000) { + if (jjtc000) { + jjtree.clearNodeScope(jjtn000); + jjtc000 = false; + } else { + jjtree.popNode(); + } + if (jjte000 instanceof RuntimeException) { + throw (RuntimeException)jjte000; + } + if (jjte000 instanceof ParseException) { + throw (ParseException)jjte000; + } + throw (Error)jjte000; + } finally { + if (jjtc000) { + jjtree.closeNodeScope(jjtn000, true); + } + } +/*@egen*/ +} + +Token init_el() : +{/*@bgen(jjtree) INIT_EL */ + SimpleNode jjtn000 = new SimpleNode(this, JJTINIT_EL); + boolean jjtc000 = true; + jjtree.openNodeScope(jjtn000); +/*@egen*/ + Token t = token; +} +{/*@bgen(jjtree) INIT_EL */ + try { +/*@egen*/ + try { + LOOKAHEAD(2) t=literal(LexerTreeConstants.JJTCONSTANT) + | LOOKAHEAD(2) t=equal_init_el() + | LOOKAHEAD(3) t=timed_literal() + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + }/*@bgen(jjtree)*/ + { + jjtree.closeNodeScope(jjtn000, true); + jjtc000 = false; + } +/*@egen*/ + { + jjtn000.setLine(t.beginLine); + jjtn000.setColumn(t.beginColumn); + return t; + }/*@bgen(jjtree)*/ + } catch (Throwable jjte000) { + if (jjtc000) { + jjtree.clearNodeScope(jjtn000); + jjtc000 = false; + } else { + jjtree.popNode(); + } + if (jjte000 instanceof RuntimeException) { + throw (RuntimeException)jjte000; + } + if (jjte000 instanceof ParseException) { + throw (ParseException)jjte000; + } + throw (Error)jjte000; + } finally { + if (jjtc000) { + jjtree.closeNodeScope(jjtn000, true); + } + } +/*@egen*/ +} + +Token equal_init_el() : +{/*@bgen(jjtree) EQUAL_INIT_EL */ + SimpleNode jjtn000 = new SimpleNode(this, JJTEQUAL_INIT_EL); + boolean jjtc000 = true; + jjtree.openNodeScope(jjtn000); +/*@egen*/ + Token t = token; +} +{/*@bgen(jjtree) EQUAL_INIT_EL */ + try { +/*@egen*/ + try { + t= f_head() number() + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + }/*@bgen(jjtree)*/ + { + jjtree.closeNodeScope(jjtn000, true); + jjtc000 = false; + } +/*@egen*/ + { + jjtn000.setLine(t.beginLine); + jjtn000.setColumn(t.beginColumn); + return t; + }/*@bgen(jjtree)*/ + } catch (Throwable jjte000) { + if (jjtc000) { + jjtree.clearNodeScope(jjtn000); + jjtc000 = false; + } else { + jjtree.popNode(); + } + if (jjte000 instanceof RuntimeException) { + throw (RuntimeException)jjte000; + } + if (jjte000 instanceof ParseException) { + throw (ParseException)jjte000; + } + throw (Error)jjte000; + } finally { + if (jjtc000) { + jjtree.closeNodeScope(jjtn000, true); + } + } +/*@egen*/ +} + +Token timed_literal() : +{/*@bgen(jjtree) TIMED_LITERAL */ + SimpleNode jjtn000 = new SimpleNode(this, JJTTIMED_LITERAL); + boolean jjtc000 = true; + jjtree.openNodeScope(jjtn000); +/*@egen*/ + Token t = token; +} +{/*@bgen(jjtree) TIMED_LITERAL */ + try { +/*@egen*/ + try { + t= number() literal(LexerTreeConstants.JJTCONSTANT) + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + }/*@bgen(jjtree)*/ + { + jjtree.closeNodeScope(jjtn000, true); + jjtc000 = false; + } +/*@egen*/ + { + jjtn000.setLine(t.beginLine); + jjtn000.setColumn(t.beginColumn); + return t; + }/*@bgen(jjtree)*/ + } catch (Throwable jjte000) { + if (jjtc000) { + jjtree.clearNodeScope(jjtn000); + jjtc000 = false; + } else { + jjtree.popNode(); + } + if (jjte000 instanceof RuntimeException) { + throw (RuntimeException)jjte000; + } + if (jjte000 instanceof ParseException) { + throw (ParseException)jjte000; + } + throw (Error)jjte000; + } finally { + if (jjtc000) { + jjtree.closeNodeScope(jjtn000, true); + } + } +/*@egen*/ +} + +Token goal() : +{/*@bgen(jjtree) GOAL */ + SimpleNode jjtn000 = new SimpleNode(this, JJTGOAL); + boolean jjtc000 = true; + jjtree.openNodeScope(jjtn000); +/*@egen*/ + Token t = token; +} +{/*@bgen(jjtree) GOAL */ + try { +/*@egen*/ + try { + t= pre_gd() + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + }/*@bgen(jjtree)*/ + { + jjtree.closeNodeScope(jjtn000, true); + jjtc000 = false; + } +/*@egen*/ + { + jjtn000.setLine(t.beginLine); + jjtn000.setColumn(t.beginColumn); + return t; + }/*@bgen(jjtree)*/ + } catch (Throwable jjte000) { + if (jjtc000) { + jjtree.clearNodeScope(jjtn000); + jjtc000 = false; + } else { + jjtree.popNode(); + } + if (jjte000 instanceof RuntimeException) { + throw (RuntimeException)jjte000; + } + if (jjte000 instanceof ParseException) { + throw (ParseException)jjte000; + } + throw (Error)jjte000; + } finally { + if (jjtc000) { + jjtree.closeNodeScope(jjtn000, true); + } + } +/*@egen*/ +} + +Token constraints() : +{/*@bgen(jjtree) CONSTRAINTS */ + SimpleNode jjtn000 = new SimpleNode(this, JJTCONSTRAINTS); + boolean jjtc000 = true; + jjtree.openNodeScope(jjtn000); +/*@egen*/ + Token t = token; +} +{/*@bgen(jjtree) CONSTRAINTS */ + try { +/*@egen*/ + try { + t= pref_con_gd() + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + }/*@bgen(jjtree)*/ + { + jjtree.closeNodeScope(jjtn000, true); + jjtc000 = false; + } +/*@egen*/ + { + jjtn000.setLine(t.beginLine); + jjtn000.setColumn(t.beginColumn); + return t; + }/*@bgen(jjtree)*/ + } catch (Throwable jjte000) { + if (jjtc000) { + jjtree.clearNodeScope(jjtn000); + jjtc000 = false; + } else { + jjtree.popNode(); + } + if (jjte000 instanceof RuntimeException) { + throw (RuntimeException)jjte000; + } + if (jjte000 instanceof ParseException) { + throw (ParseException)jjte000; + } + throw (Error)jjte000; + } finally { + if (jjtc000) { + jjtree.closeNodeScope(jjtn000, true); + } + } +/*@egen*/ +} + +Token pref_con_gd() : +{/*@bgen(jjtree) PREF_CON_GD */ + SimpleNode jjtn000 = new SimpleNode(this, JJTPREF_CON_GD); + boolean jjtc000 = true; + jjtree.openNodeScope(jjtn000); +/*@egen*/ + Token t = token; +} +{/*@bgen(jjtree) PREF_CON_GD */ + try { +/*@egen*/ + try { + LOOKAHEAD(2) t=and_pref_con_gd() + | LOOKAHEAD(2) t=forall_pref_con_gd() + | LOOKAHEAD(2) t=named_pref_con_gd() + | LOOKAHEAD(2) t=con_gd() + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + }/*@bgen(jjtree)*/ + { + jjtree.closeNodeScope(jjtn000, true); + jjtc000 = false; + } +/*@egen*/ + { + jjtn000.setLine(t.beginLine); + jjtn000.setColumn(t.beginColumn); + return t; + }/*@bgen(jjtree)*/ + } catch (Throwable jjte000) { + if (jjtc000) { + jjtree.clearNodeScope(jjtn000); + jjtc000 = false; + } else { + jjtree.popNode(); + } + if (jjte000 instanceof RuntimeException) { + throw (RuntimeException)jjte000; + } + if (jjte000 instanceof ParseException) { + throw (ParseException)jjte000; + } + throw (Error)jjte000; + } finally { + if (jjtc000) { + jjtree.closeNodeScope(jjtn000, true); + } + } +/*@egen*/ +} + +Token and_pref_con_gd() : +{/*@bgen(jjtree) AND_PREF_CON_GD */ + SimpleNode jjtn000 = new SimpleNode(this, JJTAND_PREF_CON_GD); + boolean jjtc000 = true; + jjtree.openNodeScope(jjtn000); +/*@egen*/ + Token t = token; +} +{/*@bgen(jjtree) AND_PREF_CON_GD */ + try { +/*@egen*/ + try { + t= (pref_con_gd())* + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + }/*@bgen(jjtree)*/ + { + jjtree.closeNodeScope(jjtn000, true); + jjtc000 = false; + } +/*@egen*/ + { + jjtn000.setLine(t.beginLine); + jjtn000.setColumn(t.beginColumn); + return t; + }/*@bgen(jjtree)*/ + } catch (Throwable jjte000) { + if (jjtc000) { + jjtree.clearNodeScope(jjtn000); + jjtc000 = false; + } else { + jjtree.popNode(); + } + if (jjte000 instanceof RuntimeException) { + throw (RuntimeException)jjte000; + } + if (jjte000 instanceof ParseException) { + throw (ParseException)jjte000; + } + throw (Error)jjte000; + } finally { + if (jjtc000) { + jjtree.closeNodeScope(jjtn000, true); + } + } +/*@egen*/ +} + +Token named_pref_con_gd() : +{/*@bgen(jjtree) NAMED_PREF_CON_GD */ + SimpleNode jjtn000 = new SimpleNode(this, JJTNAMED_PREF_CON_GD); + boolean jjtc000 = true; + jjtree.openNodeScope(jjtn000); +/*@egen*/ + Token t = token; +} +{/*@bgen(jjtree) NAMED_PREF_CON_GD */ + try { +/*@egen*/ + try { + t= [pref_name()] con_gd() + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + }/*@bgen(jjtree)*/ + { + jjtree.closeNodeScope(jjtn000, true); + jjtc000 = false; + } +/*@egen*/ + { + jjtn000.setLine(t.beginLine); + jjtn000.setColumn(t.beginColumn); + return t; + }/*@bgen(jjtree)*/ + } catch (Throwable jjte000) { + if (jjtc000) { + jjtree.clearNodeScope(jjtn000); + jjtc000 = false; + } else { + jjtree.popNode(); + } + if (jjte000 instanceof RuntimeException) { + throw (RuntimeException)jjte000; + } + if (jjte000 instanceof ParseException) { + throw (ParseException)jjte000; + } + throw (Error)jjte000; + } finally { + if (jjtc000) { + jjtree.closeNodeScope(jjtn000, true); + } + } +/*@egen*/ +} + +Token forall_pref_con_gd() : +{/*@bgen(jjtree) FORALL_PREF_CON_GD */ + SimpleNode jjtn000 = new SimpleNode(this, JJTFORALL_PREF_CON_GD); + boolean jjtc000 = true; + jjtree.openNodeScope(jjtn000); +/*@egen*/ + Token t = token; +} +{/*@bgen(jjtree) FORALL_PREF_CON_GD */ + try { +/*@egen*/ + try { + t= typed_list(LexerTreeConstants.JJTVARIABLE) pref_con_gd() + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + }/*@bgen(jjtree)*/ + { + jjtree.closeNodeScope(jjtn000, true); + jjtc000 = false; + } +/*@egen*/ + { + jjtn000.setLine(t.beginLine); + jjtn000.setColumn(t.beginColumn); + return t; + }/*@bgen(jjtree)*/ + } catch (Throwable jjte000) { + if (jjtc000) { + jjtree.clearNodeScope(jjtn000); + jjtc000 = false; + } else { + jjtree.popNode(); + } + if (jjte000 instanceof RuntimeException) { + throw (RuntimeException)jjte000; + } + if (jjte000 instanceof ParseException) { + throw (ParseException)jjte000; + } + throw (Error)jjte000; + } finally { + if (jjtc000) { + jjtree.closeNodeScope(jjtn000, true); + } + } +/*@egen*/ +} + +Token metric_spec() : +{/*@bgen(jjtree) METRIC_SPEC */ + SimpleNode jjtn000 = new SimpleNode(this, JJTMETRIC_SPEC); + boolean jjtc000 = true; + jjtree.openNodeScope(jjtn000); +/*@egen*/ + Token t = token; +} +{/*@bgen(jjtree) METRIC_SPEC */ + try { +/*@egen*/ + try { + LOOKAHEAD(3) t=maximize() + | LOOKAHEAD(3) t=minimize() + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + }/*@bgen(jjtree)*/ + { + jjtree.closeNodeScope(jjtn000, true); + jjtc000 = false; + } +/*@egen*/ + { + jjtn000.setLine(t.beginLine); + jjtn000.setColumn(t.beginColumn); + return t; + }/*@bgen(jjtree)*/ + } catch (Throwable jjte000) { + if (jjtc000) { + jjtree.clearNodeScope(jjtn000); + jjtc000 = false; + } else { + jjtree.popNode(); + } + if (jjte000 instanceof RuntimeException) { + throw (RuntimeException)jjte000; + } + if (jjte000 instanceof ParseException) { + throw (ParseException)jjte000; + } + throw (Error)jjte000; + } finally { + if (jjtc000) { + jjtree.closeNodeScope(jjtn000, true); + } + } +/*@egen*/ +} + +Token maximize() : +{/*@bgen(jjtree) MAXIMIZE */ + SimpleNode jjtn000 = new SimpleNode(this, JJTMAXIMIZE); + boolean jjtc000 = true; + jjtree.openNodeScope(jjtn000); +/*@egen*/ + Token t = token; +} +{/*@bgen(jjtree) MAXIMIZE */ + try { +/*@egen*/ + try { + t= metric_f_exp() + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + }/*@bgen(jjtree)*/ + { + jjtree.closeNodeScope(jjtn000, true); + jjtc000 = false; + } +/*@egen*/ + { + jjtn000.setLine(t.beginLine); + jjtn000.setColumn(t.beginColumn); + return t; + }/*@bgen(jjtree)*/ + } catch (Throwable jjte000) { + if (jjtc000) { + jjtree.clearNodeScope(jjtn000); + jjtc000 = false; + } else { + jjtree.popNode(); + } + if (jjte000 instanceof RuntimeException) { + throw (RuntimeException)jjte000; + } + if (jjte000 instanceof ParseException) { + throw (ParseException)jjte000; + } + throw (Error)jjte000; + } finally { + if (jjtc000) { + jjtree.closeNodeScope(jjtn000, true); + } + } +/*@egen*/ +} + +Token minimize() : +{/*@bgen(jjtree) MINIMIZE */ + SimpleNode jjtn000 = new SimpleNode(this, JJTMINIMIZE); + boolean jjtc000 = true; + jjtree.openNodeScope(jjtn000); +/*@egen*/ + Token t = token; +} +{/*@bgen(jjtree) MINIMIZE */ + try { +/*@egen*/ + try { + t= metric_f_exp() + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + }/*@bgen(jjtree)*/ + { + jjtree.closeNodeScope(jjtn000, true); + jjtc000 = false; + } +/*@egen*/ + { + jjtn000.setLine(t.beginLine); + jjtn000.setColumn(t.beginColumn); + return t; + }/*@bgen(jjtree)*/ + } catch (Throwable jjte000) { + if (jjtc000) { + jjtree.clearNodeScope(jjtn000); + jjtc000 = false; + } else { + jjtree.popNode(); + } + if (jjte000 instanceof RuntimeException) { + throw (RuntimeException)jjte000; + } + if (jjte000 instanceof ParseException) { + throw (ParseException)jjte000; + } + throw (Error)jjte000; + } finally { + if (jjtc000) { + jjtree.closeNodeScope(jjtn000, true); + } + } +/*@egen*/ +} + +Token metric_f_exp() : +{/*@bgen(jjtree) METRIC_F_EXP */ + SimpleNode jjtn000 = new SimpleNode(this, JJTMETRIC_F_EXP); + boolean jjtc000 = true; + jjtree.openNodeScope(jjtn000); +/*@egen*/ + Token t = token; +} +{/*@bgen(jjtree) METRIC_F_EXP */ + try { +/*@egen*/ + try { + LOOKAHEAD(2) t=unary_op_metric_f_exp() + | LOOKAHEAD(2) t=binary_op_metric_f_exp() + | LOOKAHEAD(2) t=multi_op_metric_f_exp() + | LOOKAHEAD(2) t=number() + | LOOKAHEAD(2) t=constant_f_head() + | LOOKAHEAD(2) t=total_time() + | LOOKAHEAD(2) t=violated_pref_exp() + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + }/*@bgen(jjtree)*/ + { + jjtree.closeNodeScope(jjtn000, true); + jjtc000 = false; + } +/*@egen*/ + { + jjtn000.setLine(t.beginLine); + jjtn000.setColumn(t.beginColumn); + return t; + }/*@bgen(jjtree)*/ + } catch (Throwable jjte000) { + if (jjtc000) { + jjtree.clearNodeScope(jjtn000); + jjtc000 = false; + } else { + jjtree.popNode(); + } + if (jjte000 instanceof RuntimeException) { + throw (RuntimeException)jjte000; + } + if (jjte000 instanceof ParseException) { + throw (ParseException)jjte000; + } + throw (Error)jjte000; + } finally { + if (jjtc000) { + jjtree.closeNodeScope(jjtn000, true); + } + } +/*@egen*/ +} + +Token violated_pref_exp() : +{/*@bgen(jjtree) VIOLATED_PREF_EXP */ + SimpleNode jjtn000 = new SimpleNode(this, JJTVIOLATED_PREF_EXP); + boolean jjtc000 = true; + jjtree.openNodeScope(jjtn000); +/*@egen*/ + Token t = token; +} +{/*@bgen(jjtree) VIOLATED_PREF_EXP */ + try { +/*@egen*/ + try { + t= pref_name() + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + }/*@bgen(jjtree)*/ + { + jjtree.closeNodeScope(jjtn000, true); + jjtc000 = false; + } +/*@egen*/ + { + jjtn000.setLine(t.beginLine); + jjtn000.setColumn(t.beginColumn); + return t; + }/*@bgen(jjtree)*/ + } catch (Throwable jjte000) { + if (jjtc000) { + jjtree.clearNodeScope(jjtn000); + jjtc000 = false; + } else { + jjtree.popNode(); + } + if (jjte000 instanceof RuntimeException) { + throw (RuntimeException)jjte000; + } + if (jjte000 instanceof ParseException) { + throw (ParseException)jjte000; + } + throw (Error)jjte000; + } finally { + if (jjtc000) { + jjtree.closeNodeScope(jjtn000, true); + } + } +/*@egen*/ +} + +Token constant_f_head() : +{/*@bgen(jjtree) CONSTANT_F_HEAD */ + SimpleNode jjtn000 = new SimpleNode(this, JJTCONSTANT_F_HEAD); + boolean jjtc000 = true; + jjtree.openNodeScope(jjtn000); +/*@egen*/ + Token t = token; +} +{/*@bgen(jjtree) CONSTANT_F_HEAD */ + try { +/*@egen*/ + try { + t= functor() (constant())* + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + }/*@bgen(jjtree)*/ + { + jjtree.closeNodeScope(jjtn000, true); + jjtc000 = false; + } +/*@egen*/ + { + jjtn000.setLine(t.beginLine); + jjtn000.setColumn(t.beginColumn); + return t; + }/*@bgen(jjtree)*/ + } catch (Throwable jjte000) { + if (jjtc000) { + jjtree.clearNodeScope(jjtn000); + jjtc000 = false; + } else { + jjtree.popNode(); + } + if (jjte000 instanceof RuntimeException) { + throw (RuntimeException)jjte000; + } + if (jjte000 instanceof ParseException) { + throw (ParseException)jjte000; + } + throw (Error)jjte000; + } finally { + if (jjtc000) { + jjtree.closeNodeScope(jjtn000, true); + } + } +/*@egen*/ +} + +Token total_time() : +{/*@bgen(jjtree) TOTAL_TIME */ + SimpleNode jjtn000 = new SimpleNode(this, JJTTOTAL_TIME); + boolean jjtc000 = true; + jjtree.openNodeScope(jjtn000); +/*@egen*/ + Token t = token; +} +{/*@bgen(jjtree) TOTAL_TIME */ + try { +/*@egen*/ + try { + t= + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + }/*@bgen(jjtree)*/ + { + jjtree.closeNodeScope(jjtn000, true); + jjtc000 = false; + } +/*@egen*/ + { + jjtn000.setLine(t.beginLine); + jjtn000.setColumn(t.beginColumn); + return t; + }/*@bgen(jjtree)*/ + } finally { + if (jjtc000) { + jjtree.closeNodeScope(jjtn000, true); + } + } +/*@egen*/ +} + + +Token binary_op_metric_f_exp() : +{/*@bgen(jjtree) BINARY_OP_METRIC_F_EXP */ + SimpleNode jjtn000 = new SimpleNode(this, JJTBINARY_OP_METRIC_F_EXP); + boolean jjtc000 = true; + jjtree.openNodeScope(jjtn000); +/*@egen*/ + Token t = token; +} +{/*@bgen(jjtree) BINARY_OP_METRIC_F_EXP */ + try { +/*@egen*/ + try { + LOOKAHEAD(2) t=add_op_metric_f_exp() + | LOOKAHEAD(2) t=substract_op_metric_f_exp() + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + }/*@bgen(jjtree)*/ + { + jjtree.closeNodeScope(jjtn000, true); + jjtc000 = false; + } +/*@egen*/ + { + jjtn000.setLine(t.beginLine); + jjtn000.setColumn(t.beginColumn); + return t; + }/*@bgen(jjtree)*/ + } catch (Throwable jjte000) { + if (jjtc000) { + jjtree.clearNodeScope(jjtn000); + jjtc000 = false; + } else { + jjtree.popNode(); + } + if (jjte000 instanceof RuntimeException) { + throw (RuntimeException)jjte000; + } + if (jjte000 instanceof ParseException) { + throw (ParseException)jjte000; + } + throw (Error)jjte000; + } finally { + if (jjtc000) { + jjtree.closeNodeScope(jjtn000, true); + } + } +/*@egen*/ +} + +Token add_op_metric_f_exp() : +{/*@bgen(jjtree) ADD_OP_METRIC_F_EXP */ + SimpleNode jjtn000 = new SimpleNode(this, JJTADD_OP_METRIC_F_EXP); + boolean jjtc000 = true; + jjtree.openNodeScope(jjtn000); +/*@egen*/ + Token t = token; +} +{/*@bgen(jjtree) ADD_OP_METRIC_F_EXP */ + try { +/*@egen*/ + try { + t= metric_f_exp() metric_f_exp() + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + }/*@bgen(jjtree)*/ + { + jjtree.closeNodeScope(jjtn000, true); + jjtc000 = false; + } +/*@egen*/ + { + jjtn000.setLine(t.beginLine); + jjtn000.setColumn(t.beginColumn); + return t; + }/*@bgen(jjtree)*/ + } catch (Throwable jjte000) { + if (jjtc000) { + jjtree.clearNodeScope(jjtn000); + jjtc000 = false; + } else { + jjtree.popNode(); + } + if (jjte000 instanceof RuntimeException) { + throw (RuntimeException)jjte000; + } + if (jjte000 instanceof ParseException) { + throw (ParseException)jjte000; + } + throw (Error)jjte000; + } finally { + if (jjtc000) { + jjtree.closeNodeScope(jjtn000, true); + } + } +/*@egen*/ +} + +Token substract_op_metric_f_exp() : +{/*@bgen(jjtree) SUBSTRACT_OP_METRIC_F_EXP */ + SimpleNode jjtn000 = new SimpleNode(this, JJTSUBSTRACT_OP_METRIC_F_EXP); + boolean jjtc000 = true; + jjtree.openNodeScope(jjtn000); +/*@egen*/ + Token t = token; +} +{/*@bgen(jjtree) SUBSTRACT_OP_METRIC_F_EXP */ + try { +/*@egen*/ + try{ + t= metric_f_exp() metric_f_exp() + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + }/*@bgen(jjtree)*/ + { + jjtree.closeNodeScope(jjtn000, true); + jjtc000 = false; + } +/*@egen*/ + { + jjtn000.setLine(t.beginLine); + jjtn000.setColumn(t.beginColumn); + return t; + }/*@bgen(jjtree)*/ + } catch (Throwable jjte000) { + if (jjtc000) { + jjtree.clearNodeScope(jjtn000); + jjtc000 = false; + } else { + jjtree.popNode(); + } + if (jjte000 instanceof RuntimeException) { + throw (RuntimeException)jjte000; + } + if (jjte000 instanceof ParseException) { + throw (ParseException)jjte000; + } + throw (Error)jjte000; + } finally { + if (jjtc000) { + jjtree.closeNodeScope(jjtn000, true); + } + } +/*@egen*/ +} + +Token multi_op_metric_f_exp() : +{/*@bgen(jjtree) MULTI_OP_METRIC_F_EXP */ + SimpleNode jjtn000 = new SimpleNode(this, JJTMULTI_OP_METRIC_F_EXP); + boolean jjtc000 = true; + jjtree.openNodeScope(jjtn000); +/*@egen*/ + Token t = token; +} +{/*@bgen(jjtree) MULTI_OP_METRIC_F_EXP */ + try { +/*@egen*/ + try { + LOOKAHEAD(2) t=multiply_narity_op_metric_f_exp() + | LOOKAHEAD(2) t=add_narity_op_metric_f_exp() + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + }/*@bgen(jjtree)*/ + { + jjtree.closeNodeScope(jjtn000, true); + jjtc000 = false; + } +/*@egen*/ + { + jjtn000.setLine(t.beginLine); + jjtn000.setColumn(t.beginColumn); + return t; + }/*@bgen(jjtree)*/ + } catch (Throwable jjte000) { + if (jjtc000) { + jjtree.clearNodeScope(jjtn000); + jjtc000 = false; + } else { + jjtree.popNode(); + } + if (jjte000 instanceof RuntimeException) { + throw (RuntimeException)jjte000; + } + if (jjte000 instanceof ParseException) { + throw (ParseException)jjte000; + } + throw (Error)jjte000; + } finally { + if (jjtc000) { + jjtree.closeNodeScope(jjtn000, true); + } + } +/*@egen*/ +} + +Token multiply_narity_op_metric_f_exp() : +{/*@bgen(jjtree) MULTIPLY_NARITY_OP_METRIC_F_EXP */ + SimpleNode jjtn000 = new SimpleNode(this, JJTMULTIPLY_NARITY_OP_METRIC_F_EXP); + boolean jjtc000 = true; + jjtree.openNodeScope(jjtn000); +/*@egen*/ + Token t = token; +} +{/*@bgen(jjtree) MULTIPLY_NARITY_OP_METRIC_F_EXP */ + try { +/*@egen*/ + try { + t= metric_f_exp() (metric_f_exp())+ + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + }/*@bgen(jjtree)*/ + { + jjtree.closeNodeScope(jjtn000, true); + jjtc000 = false; + } +/*@egen*/ + { + jjtn000.setLine(t.beginLine); + jjtn000.setColumn(t.beginColumn); + return t; + }/*@bgen(jjtree)*/ + } catch (Throwable jjte000) { + if (jjtc000) { + jjtree.clearNodeScope(jjtn000); + jjtc000 = false; + } else { + jjtree.popNode(); + } + if (jjte000 instanceof RuntimeException) { + throw (RuntimeException)jjte000; + } + if (jjte000 instanceof ParseException) { + throw (ParseException)jjte000; + } + throw (Error)jjte000; + } finally { + if (jjtc000) { + jjtree.closeNodeScope(jjtn000, true); + } + } +/*@egen*/ +} + +Token add_narity_op_metric_f_exp() : +{/*@bgen(jjtree) ADD_NARITY_OP_METRIC_F_EXP */ + SimpleNode jjtn000 = new SimpleNode(this, JJTADD_NARITY_OP_METRIC_F_EXP); + boolean jjtc000 = true; + jjtree.openNodeScope(jjtn000); +/*@egen*/ + Token t = token; +} +{/*@bgen(jjtree) ADD_NARITY_OP_METRIC_F_EXP */ + try { +/*@egen*/ + try { + t= metric_f_exp() (metric_f_exp())+ + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + }/*@bgen(jjtree)*/ + { + jjtree.closeNodeScope(jjtn000, true); + jjtc000 = false; + } +/*@egen*/ + { + jjtn000.setLine(t.beginLine); + jjtn000.setColumn(t.beginColumn); + return t; + }/*@bgen(jjtree)*/ + } catch (Throwable jjte000) { + if (jjtc000) { + jjtree.clearNodeScope(jjtn000); + jjtc000 = false; + } else { + jjtree.popNode(); + } + if (jjte000 instanceof RuntimeException) { + throw (RuntimeException)jjte000; + } + if (jjte000 instanceof ParseException) { + throw (ParseException)jjte000; + } + throw (Error)jjte000; + } finally { + if (jjtc000) { + jjtree.closeNodeScope(jjtn000, true); + } + } +/*@egen*/ +} + +Token unary_op_metric_f_exp() : +{/*@bgen(jjtree) UNARY_OP_METRIC_F_EXP */ + SimpleNode jjtn000 = new SimpleNode(this, JJTUNARY_OP_METRIC_F_EXP); + boolean jjtc000 = true; + jjtree.openNodeScope(jjtn000); +/*@egen*/ + Token t = token; +} +{/*@bgen(jjtree) UNARY_OP_METRIC_F_EXP */ + try { +/*@egen*/ + try { + t= metric_f_exp() + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn);; + }/*@bgen(jjtree)*/ + { + jjtree.closeNodeScope(jjtn000, true); + jjtc000 = false; + } +/*@egen*/ + { + jjtn000.setLine(t.beginLine); + jjtn000.setColumn(t.beginColumn); + return t; + }/*@bgen(jjtree)*/ + } catch (Throwable jjte000) { + if (jjtc000) { + jjtree.clearNodeScope(jjtn000); + jjtc000 = false; + } else { + jjtree.popNode(); + } + if (jjte000 instanceof RuntimeException) { + throw (RuntimeException)jjte000; + } + if (jjte000 instanceof ParseException) { + throw (ParseException)jjte000; + } + throw (Error)jjte000; + } finally { + if (jjtc000) { + jjtree.closeNodeScope(jjtn000, true); + } + } +/*@egen*/ +} + + + diff --git a/utils/PDDLtoSANetTranslator/PDDLParser/src/pddl4j/lexer/Lexer.jjt b/utils/PDDLtoSANetTranslator/PDDLParser/src/pddl4j/lexer/Lexer.jjt new file mode 100644 index 00000000000..faf8c5a3038 --- /dev/null +++ b/utils/PDDLtoSANetTranslator/PDDLParser/src/pddl4j/lexer/Lexer.jjt @@ -0,0 +1,3466 @@ +/* + * Copyright Dept. of Mathematics & Computer Science Univ. Paris-Descartes + * + * This software is governed by the CeCILL license under French law and + * abiding by the rules of distribution of free software. You can use, + * modify and/ or redistribute the software under the terms of the CeCILL + * license as circulated by CEA, CNRS and INRIA at the following URL + * "http://www.cecill.info". + * + * As a counterpart to the access to the source code and rights to copy, + * modify and redistribute granted by the license, users are provided only + * with a limited warranty and the software's author, the holder of the + * economic rights, and the successive licensors have only limited + * liability. + * + * In this respect, the user's attention is drawn to the risks associated + * with loading, using, modifying and/or developing or reproducing the + * software by the user in light of its specific status of free software, + * that may mean that it is complicated to manipulate, and that also + * therefore means that it is reserved for developers and experienced + * professionals having in-depth computer knowledge. Users are therefore + * encouraged to load and test the software's suitability as regards their + * requirements in conditions enabling the security of their systems and/or + * data to be ensured and, more generally, to use and operate it in the + * same conditions as regards security. + * + * The fact that you are presently reading this means that you have had + * knowledge of the CeCILL license and that you accept its terms. + */ + +options { + //MULTI=true; + NODE_DEFAULT_VOID=false; + STATIC=false; + NODE_PREFIX="PDDL_"; + NODE_USES_PARSER=true; + IGNORE_CASE=true; +} + +PARSER_BEGIN(Lexer) + +package pddl4j.lexer; + +import java.io.InputStream; +import java.io.File; +import java.util.ArrayList; +import java.util.List; + +import pddl4j.ErrorManager; +import pddl4j.ErrorManager.Message; + +public class Lexer { + + private ErrorManager mgr; + private File file; + + private static final int[] BLOCKS = {REQUIREMENTS, + TYPES, + CONSTANTS, + PREDICATES, + FUNCTIONS, + ACTION, + DURATIVE_ACTION, + DERIVED, + OBJECTS, + INIT, + GOAL, + METRIC, + EOF}; + + private boolean isBlock(int token) { + int i = 0; + while (i < BLOCKS.length && (BLOCKS[i] != token)) i++; + return i == BLOCKS.length; + } + + private void error(Throwable e, int line, int column) throws ParseException { + String message = new String(); + if (e.getClass().equals(TokenMgrError.class)) { + String[] tmp = e.getMessage().split(" "); + int l = -1; + int c = -1; + int i = 0; + for (i = 0 ; i < tmp.length; i++) { + if (tmp[i].equals("line") && i+1 < tmp.length) { + l = Integer.parseInt(tmp[i+1].substring(0, tmp[i+1].length()-1)); + } + if (tmp[i].equals("column") && i+1 < tmp.length) { + c = Integer.parseInt(tmp[i+1].substring(0, tmp[i+1].length()-1)); + } + } + message = e.getMessage().split(". ")[1]; + this.mgr.logLexicalError(message, this.file, l, c); + } else if (e.getClass().equals(ParseException.class)) { + ParseException pe = (ParseException) e; + message = generateErrorMesssage(pe); + this.mgr.logLexicalError(message, this.file, pe.currentToken.beginLine, pe.currentToken.beginColumn); + } else if (e instanceof NullPointerException) { + // Do nothing + } else { + e.printStackTrace(); + throw new ParseException(e.getMessage()); + } + this.skipToNextBlock(); + } + + private void skipToNextBlock() { + Token t; + Token t2; + do { + t = getNextToken(); + t2 = getToken(2); + + } while (t2 != null && isBlock(t2.kind)); + } + + public void setErrorManager(ErrorManager mgr) { + this.mgr = mgr; + } + + public void setFile(File file) { + this.file = file; + } + + /** + * Creates the error message from a specific parse exception. + * + * @param pe the parse exception. + * @return the error message. + */ + private String generateErrorMesssage(ParseException pe) { + StringBuffer expected = new StringBuffer(); + boolean expectedSeq = false; + int maxSize = 0; + for (int i = 0; i < pe.expectedTokenSequences.length; i++) { + if (maxSize < pe.expectedTokenSequences[i].length) { + maxSize = pe.expectedTokenSequences[i].length; + } + for (int j = 0; j < pe.expectedTokenSequences[i].length; j++) { + expected.append(pe.tokenImage[pe.expectedTokenSequences[i][j]]).append(" "); + expectedSeq = true; + } + if (pe.expectedTokenSequences[i][pe.expectedTokenSequences[i].length - 1] != 0) { + expected.append("..."); + } + if (i < pe.expectedTokenSequences.length - 1) { + expected.append("\n").append(" "); + } + } + String retval = "unexpected token \"" + pe.currentToken.next.image + "\"."; + if (expectedSeq) { + if (pe.expectedTokenSequences.length == 1) { + retval += "\nWas expecting:" + "\n" + " "; + } else { + retval += "\nWas expecting one of:" + "\n" + " "; + } + retval += expected.toString(); + } + return retval; + } +} +PARSER_END(Lexer) + + +SKIP : +{ + " " +| "\t" +| "\n" +| "\r" +} +MORE : +{ + "//" : IN_SINGLE_LINE_COMMENT +| ";" : IN_SINGLE_LINE_COMMENT +| <"/**" ~["/"]> { input_stream.backup(1); } : IN_FORMAL_COMMENT +| "/*" : IN_MULTI_LINE_COMMENT +} + + SPECIAL_TOKEN : { + : DEFAULT + } + + SPECIAL_TOKEN : { + : DEFAULT + } + + SPECIAL_TOKEN : { + : DEFAULT + } + + MORE : { + < ~[] > +} + +TOKEN : +{ + < LPAREN: "("> +| < RPAREN: ")"> +} + +TOKEN : { + < DEFINE : "define" > +| < DOMAIN : "domain" > +| < REQUIREMENTS : ":requirements" > +| < TYPES : ":types" > +| < EITHER : "either" > +| < CONSTANTS : ":constants" > +| < PREDICATES : ":predicates" > +| < FUNCTIONS : ":functions" > +| < ACTION : ":action" > +| < PARAMETERS : ":parameters" > +| < PRECONDITION : ":precondition" > +| < EFFECT : ":effect" > +| < PREFERENCE : "preference" > +| < WHEN : "when" > +| < PROB : "probabilistic"> +| < DURATIVE_ACTION : ":durative-action" > +| < DURATION : ":duration" > +| < CONDITION : ":condition" > +| < DERIVED : ":derived" > +| < PROBLEM : "problem" > +| < P_DOMAIN : ":domain" > +| < OBJECTS : ":objects" > +| < INIT : ":init" > +| < GOAL: ":goal" > +| < METRIC : ":metric" > +} + +TOKEN : { + < STRIPS : ":strips" > +| < TYPING : ":typing" > +| < NEGATIVE_PRECONDITIONS : ":negative-preconditions" > +| < DISJUNCTIVE_PRECONDITIONS : ":disjunctive-preconditions" > +| < EQUALITY : ":equality" > +| < EXISTENTIAL_PRECONDITIONS : ":existential-preconditions" > +| < UNIVERSAL_PRECONDITIONS : ":universal-preconditions" > +| < QUANTIFIED_PRECONDITIONS : ":quantified-preconditions" > +| < CONDITIONAL_EFFECTS : ":conditional-effects" > +| < FLUENTS : ":fluents" > +| < ADL : ":adl" > +| < DURATIVE_ACTIONS : ":durative-actions" > +| < DERIVED_PREDICATES : ":derived-predicates" > +| < TIMED_INITIAL_LITERALS : ":timed-initial-literals" > +| < PREFERENCES : ":preferences" > +| < CONSTRAINTS : ":constraints" > +| < CONTINUS_EFFECTS : ":continus_effects" > +| < DURATION_INEQUALITIES : ":duration-inequalities" > +} + +TOKEN : +{ + < GREATER : ">" > +| < LESS : "<" > +| < GEQUAL : ">=" > +| < LEQUAL : "<=" > +| < EQUAL : "=" > +} + +TOKEN : +{ + < MUL : "*" > +| < DIV : "/" > +| < ADD : "+" > +| < SUB : "-" > +} + +TOKEN : +{ + +| +| +| +| +} + +TOKEN : +{ + < OR : "or" > +| < AND : "and" > +| < IMPLY : "imply" > +| < NOT : "not" > +| < FORALL : "forall" > +| < EXISTS : "exists" > +} + +TOKEN : +{ + < ALWAYS : "always" > +| < SOMETIME : "sometime" > +| < WITHIN : "within" > +| < AT_MOST_ONCE : "at-most-once" > +| < SOMETIME_AFTER : "sometime-after" > +| < SOMETIME_BEFORE : "sometime-before" > +| < ALWAYS_WITHIN : "always-within" > +| < HOLD_DURING : "hold-during" > +| < HOLD_AFTER : "hold-after" > +| < AT: "at" > +| < START : "start"> +| < END : "end"> +| < OVER : "over"> +| < ALL : "all"> +| < TOTAL_TIME : "total_time" > +| < MAXIMIZE : "maximize" > +| < MINIMIZE : "minimize" > +| < IS_VIOLATED : "is-violated" > +} + +TOKEN : +{ + < VAR_DURATION : "?duration" > +| < CONTINOUS_VARIABLE : "#t" > +} + +TOKEN : +{ + < NUMBER_TYPE : "number" > +| < OBJECT_TYPE : "object" > +} + + +TOKEN : +{ + < SYMBOL : (( ( | )*)) > +| < NUMBER : ()+ ("." ()*)? > +| < #DIGIT : ["0"-"9"] > +| < #LETTER : ["a"-"z","A"-"Z","_","-","#"] > +} + +SimpleNode parse() #ROOT: +{ + Token t= null; +} +{ + try { + LOOKAHEAD(4) t=domain() + | LOOKAHEAD(4) t=problem() + } catch (Throwable e) { + this.mgr.logLexicalError("Lexical error file (" +file.getName() + ") : to many errors", file); + throw new ParseException(e.getMessage()); + } + { + jjtThis.setLine(t.beginLine); + jjtThis.setColumn(t.beginColumn); + return jjtThis; + } + +} + +Token domain() #DOMAIN: +{ + Token t = token; +} +{ + try { + t= domain_name() + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + } + try { + [LOOKAHEAD(2) t=require_def()] + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + } + try { + [LOOKAHEAD(2) t=type_def()] + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + } + try { + [LOOKAHEAD(2) t=constants_def()] + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + } + try { + [LOOKAHEAD(2) t=predicates_def()] + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + } + try { + [LOOKAHEAD(2) t=functions_def()] + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + } + try { + [LOOKAHEAD(2) t=constraints()] + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + } + try { + (t=structure_def())* + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + } + try { + + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + } + + { + jjtThis.setLine(t.beginLine); + jjtThis.setColumn(t.beginColumn); + return t; + } +} + +Token require_def() #REQUIRE_DEF: +{ + Token t = token; +} +{ + try { + t= (require_key())+ + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + } + { + jjtThis.setLine(t.beginLine); + jjtThis.setColumn(t.beginColumn); + return t; + } +} + +Token require_key() #REQUIRE_KEY: +{ + Token t = token; +} +{ + try { + t= + | t= + | t= + | t= + | t= + | t= + | t= + | t= + | t= + | t= + | t= + | t= + | t= + | t= + | t= + | t= + | t= + | t= + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + } + { + jjtThis.setLine(t.beginLine); + jjtThis.setColumn(t.beginColumn); + jjtThis.setImage(t.image); + return t; + } +} + +Token type_def() #TYPE_DEF: +{ + Token t = token; +} +{ + try { + t= typed_list(LexerTreeConstants.JJTPRIMITIVE_TYPE) + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + } + { + jjtThis.setLine(t.beginLine); + jjtThis.setColumn(t.beginColumn); + return t; + } +} + +Token typed_list(int type) #TYPED_LIST: +{ + Token t = token; +} +{ + try { + LOOKAHEAD(2, {type == LexerTreeConstants.JJTPRIMITIVE_TYPE}) + (t=primitive_type())* ( type() typed_list(type))? + | LOOKAHEAD(2, {type == LexerTreeConstants.JJTCONSTANT}) + (t=constant())* ( type() typed_list(type))? + | LOOKAHEAD(2, {type == LexerTreeConstants.JJTVARIABLE}) + (t=variable())* ( type() typed_list(type))? + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + } + { + if (t != null) { + jjtThis.setLine(t.beginLine); + jjtThis.setColumn(t.beginColumn); + jjtThis.setTypeId(LexerTreeConstants.JJTVARIABLE); + } + return t; + } +} + +Token type() #TYPE: +{ + Token t = token; +} +{ + try { + t= (primitive_type())+ + | t=primitive_type() + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + } + { + jjtThis.setLine(t.beginLine); + jjtThis.setColumn(t.beginColumn); + return t; + } +} + +Token primitive_type() #PRIMITIVE_TYPE: +{ + Token t = token; +} +{ +( t= +| t= +| t=) + { + jjtThis.setLine(t.beginLine); + jjtThis.setColumn(t.beginColumn); + jjtThis.setImage(t.image); + return t; + } +} + +Token constants_def() #CONSTANT_DEF: +{ + Token t = token; +} +{ + try { + t= typed_list(LexerTreeConstants.JJTCONSTANT) + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + } + { + jjtThis.setLine(t.beginLine); + jjtThis.setColumn(t.beginColumn); + return t; + } +} + +Token constant() #CONSTANT: +{ + Token t = token; +} +{ + t= + { + jjtThis.setLine(t.beginLine); + jjtThis.setColumn(t.beginColumn); + jjtThis.setImage(t.image); + return t; + } +} + +Token predicates_def() #PREDICATE_DEF: +{ + Token t = token; +} +{ + try { + t= (atomic_formula_skeleton())+ + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + } + { + jjtThis.setLine(t.beginLine); + jjtThis.setColumn(t.beginColumn); + return t; + } +} + +Token atomic_formula_skeleton() #ATOMIC_FORMULA_SKELETON: +{ + Token t = token; +} +{ + t= predicate() typed_list(LexerTreeConstants.JJTVARIABLE) + { + jjtThis.setLine(t.beginLine); + jjtThis.setColumn(t.beginColumn); + return t; + } +} + +Token predicate() #PREDICATE: +{ + Token t = token; +} +{ + (t= | t=) + { + jjtThis.setLine(t.beginLine); + jjtThis.setColumn(t.beginColumn); + jjtThis.setImage(t.image); + return t; + } +} + +Token variable() #VARIABLE: +{ + Token t = token; +} +{ + "?" (t= | t= | t=) + { + jjtThis.setLine(t.beginLine); + jjtThis.setColumn(t.beginColumn); + jjtThis.setImage(t.image); + return t; + } +} + +Token functions_def() #FUNCTION_DEF: +{ + Token t = token; +} +{ + try { + t= function_typed_list(LexerTreeConstants.JJTATOMIC_FUNCTION_SKELETON) + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + } + { + jjtThis.setLine(t.beginLine); + jjtThis.setColumn(t.beginColumn); + return t; + } +} + +Token atomic_function_skeleton() #ATOMIC_FUNCTION_SKELETON: +{ + Token t = token; +} +{ + t= functor() typed_list(LexerTreeConstants.JJTVARIABLE) + { + jjtThis.setLine(t.beginLine); + jjtThis.setColumn(t.beginColumn); + return t; + } +} + +Token functor() #FUNCTOR: +{ + Token t = token; +} +{ + t= + { + jjtThis.setLine(t.beginLine); + jjtThis.setColumn(t.beginColumn); + jjtThis.setImage(t.image); + return t; + } +} + +Token function_typed_list(int type) #FUNCTION_TYPED_LIST: +{ + Token t = token; +} +{ + (t=atomic_function_skeleton())* ( function_type() function_typed_list(type))? + { + if (t != null) { + jjtThis.setLine(t.beginLine); + jjtThis.setColumn(t.beginColumn); + } + return t; + } +} + +Token function_type() #FUNCTION_TYPE: +{ + Token t = token; +} +{ + t= + { + jjtThis.setLine(t.beginLine); + jjtThis.setColumn(t.beginColumn); + jjtThis.setImage(t.image); + return t; + } +} + +Token con_gd() #CON_GD: +{ + Token t = token; +} +{ + try { + LOOKAHEAD(2) t=and_con_gd() + | LOOKAHEAD(2) t=forall_con_gd() + | LOOKAHEAD(2) t=at_end_con_gd() + | LOOKAHEAD(2) t=always_con_gd() + | LOOKAHEAD(2) t=sometime_con_gd() + | LOOKAHEAD(2) t=within_con_gd() + | LOOKAHEAD(2) t=at_most_once_con_gd() + | LOOKAHEAD(2) t=sometime_after_con_gd() + | LOOKAHEAD(2) t=sometime_before_con_gd() + | LOOKAHEAD(2) t=always_within_con_gd() + | LOOKAHEAD(2) t=hold_during_con_gd() + | LOOKAHEAD(2) t=hold_after_con_gd() + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + } + { + jjtThis.setLine(t.beginLine); + jjtThis.setColumn(t.beginColumn); + return t; + } +} + +Token and_con_gd() #AND_CON_GD: +{ + Token t = token; +} +{ + try { + t= (con_gd())* + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + } + { + jjtThis.setLine(t.beginLine); + jjtThis.setColumn(t.beginColumn); + return t; + } +} + +Token forall_con_gd() #FORALL_CON_GD: +{ + Token t = token; +} +{ + try { + t= typed_list(LexerTreeConstants.JJTVARIABLE) con_gd() + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + } + { + jjtThis.setLine(t.beginLine); + jjtThis.setColumn(t.beginColumn); + return t; + } +} + +Token at_end_con_gd() #AT_END_CON_GD: +{ + Token t = token; +} +{ + try { + t= gd() + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + } + { + jjtThis.setLine(t.beginLine); + jjtThis.setColumn(t.beginColumn); + return t; + } +} + +Token always_con_gd() #ALWAYS_CON_GD: +{ + Token t = token; +} +{ + try { + t= gd() + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + } + { + jjtThis.setLine(t.beginLine); + jjtThis.setColumn(t.beginColumn); + return t; + } +} + +Token sometime_con_gd() #SOMETIME_CON_GD: +{ + Token t = token; +} +{ + try { + t= gd() + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + } + { + jjtThis.setLine(t.beginLine); + jjtThis.setColumn(t.beginColumn); + return t; + } +} + +Token within_con_gd() #WITHIN_CON_GD: +{ + Token t = token; +} +{ + try { + t= gd() + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + } + { + jjtThis.setLine(t.beginLine); + jjtThis.setColumn(t.beginColumn); + return t; + } +} + +Token at_most_once_con_gd() #AT_MOST_ONCE_CON_GD: +{ + Token t = token; +} +{ + try { + t= gd() + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + } + { + jjtThis.setLine(t.beginLine); + jjtThis.setColumn(t.beginColumn); + return t; + } +} + +Token sometime_after_con_gd() #SOMETIME_AFTER_CON_GD: +{ + Token t = token; +} +{ + try { + t= gd() gd() + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + } + { + jjtThis.setLine(t.beginLine); + jjtThis.setColumn(t.beginColumn); + return t; + } +} + +Token sometime_before_con_gd() #SOMETIME_BEFORE_CON_GD: +{ + Token t = token; +} +{ + try { + t= gd() gd() + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + } + { + jjtThis.setLine(t.beginLine); + jjtThis.setColumn(t.beginColumn); + return t; + } +} + +Token always_within_con_gd() #ALWAYS_WITHIN_CON_GD: +{ + Token t = token; +} +{ + try { + t= gd() gd() + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + } + { + jjtThis.setLine(t.beginLine); + jjtThis.setColumn(t.beginColumn); + return t; + } +} + +Token hold_during_con_gd() #HOLD_DURING_CON_GD: +{ + Token t = token; +} +{ + try { + t= gd() + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + } + { + jjtThis.setLine(t.beginLine); + jjtThis.setColumn(t.beginColumn); + return t; + } +} + +Token hold_after_con_gd() #HOLD_AFTER_CON_GD: +{ + Token t = token; +} +{ + try { + t= gd() + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + } + { + jjtThis.setLine(t.beginLine); + jjtThis.setColumn(t.beginColumn); + return t; + } +} + +Token gd() #GD: +{ + Token t = token; +} +{ + try { + LOOKAHEAD(2) t=atomic_formula(LexerTreeConstants.JJTTERM) +// | LOOKAHEAD(2) t=not_atomic_formula(LexerTreeConstants.JJTTERM) + | LOOKAHEAD(2) t=and_gd() + | LOOKAHEAD(2) t=or_gd() + | LOOKAHEAD(2) t=not_gd() + | LOOKAHEAD(2) t=imply_gd() + | LOOKAHEAD(2) t=exists_gd() + | LOOKAHEAD(2) t=forall_gd() + | LOOKAHEAD(2) t=f_comp() + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + } + { + jjtThis.setLine(t.beginLine); + jjtThis.setColumn(t.beginColumn); + return t; + } +} + +Token and_gd() #AND_GD: +{ + Token t = token; +} +{ + try { + t= (gd())* + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + } + { + jjtThis.setLine(t.beginLine); + jjtThis.setColumn(t.beginColumn); + return t; + } +} + +Token or_gd() #OR_GD: +{ + Token t = token; +} +{ + try { + t= (gd())* + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + } + { + jjtThis.setLine(t.beginLine); + jjtThis.setColumn(t.beginColumn); + return t; + } +} + +Token not_gd() #NOT_GD: +{ + Token t = token; +} +{ + try { + t= gd() + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + } + { + jjtThis.setLine(t.beginLine); + jjtThis.setColumn(t.beginColumn); + return t; + } +} + +Token imply_gd() #IMPLY_GD: +{ + Token t = token; +} +{ + try { + t= gd() gd() + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + } + { + jjtThis.setLine(t.beginLine); + jjtThis.setColumn(t.beginColumn); + return t; + } +} + +Token exists_gd() #EXISTS_GD: +{ + Token t = token; +} +{ + try { + t= typed_list(LexerTreeConstants.JJTVARIABLE) gd() + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + } + { + jjtThis.setLine(t.beginLine); + jjtThis.setColumn(t.beginColumn); + return t; + } +} + +Token forall_gd() #FORALL_GD: +{ + Token t = token; +} +{ + try { + t= typed_list(LexerTreeConstants.JJTVARIABLE) gd() + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + } + { + jjtThis.setLine(t.beginLine); + jjtThis.setColumn(t.beginColumn); + return t; + } +} + +Token atomic_formula(int type) #ATOMIC_FORMULA: +{ + Token t = token; +} +{ + try { + t= predicate() ( + LOOKAHEAD({ type == LexerTreeConstants.JJTCONSTANT } ) (constant())* { + jjtThis.setTypeId(LexerTreeConstants.JJTCONSTANT); + } + | LOOKAHEAD({ type == LexerTreeConstants.JJTTERM }) (term())* { + jjtThis.setTypeId(LexerTreeConstants.JJTTERM); + } + ) + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + } + { + jjtThis.setLine(t.beginLine); + jjtThis.setColumn(t.beginColumn); + return t; + } +} + +Token term() #TERM: +{ + Token t = token; +} +{ + try { + t=constant() + | t=variable() + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + } + { + jjtThis.setLine(t.beginLine); + jjtThis.setColumn(t.beginColumn); + return t; + } +} + +Token literal(int type) #LITERAL: +{ + Token t = token; +} +{ + + try { + LOOKAHEAD(2) t=atomic_formula(type) + | LOOKAHEAD(2) t=not_atomic_formula(type) + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + } + { + jjtThis.setLine(t.beginLine); + jjtThis.setColumn(t.beginColumn); + return t; + } +} + +Token not_atomic_formula(int type) #NOT_ATOMIC_FORMULA: +{ + Token t = token; +} +{ + try { + t= atomic_formula(type) + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + } + { + jjtThis.setLine(t.beginLine); + jjtThis.setColumn(t.beginColumn); + return t; + } +} + +Token f_comp() #F_COMP: +{ + Token t = token; +} +{ + try { + t=binary_comp() + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + } + { + jjtThis.setLine(t.beginLine); + jjtThis.setColumn(t.beginColumn); + return t; + } +} + +Token binary_comp() #BINARY_COMP: +{ + Token t = token; +} +{ + try { + LOOKAHEAD(2) t=greater_comp() + | LOOKAHEAD(2) t=less_comp() + | LOOKAHEAD(2) t=greater_equal_comp() + | LOOKAHEAD(2) t=less_equal_comp() + | LOOKAHEAD(2) t=equal_comp() + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + } + { + jjtThis.setLine(t.beginLine); + jjtThis.setColumn(t.beginColumn); + return t; + } +} + +Token greater_comp() #GREATER_COMP: +{ + Token t = token; +} +{ + try { + t= f_exp() f_exp() + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + } + { + jjtThis.setLine(t.beginLine); + jjtThis.setColumn(t.beginColumn); + return t; + } +} + +Token greater_equal_comp() #GREATER_EQUAL_COMP: +{ + Token t = token; +} +{ + try { + t= f_exp() f_exp() + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + } + { + jjtThis.setLine(t.beginLine); + jjtThis.setColumn(t.beginColumn); + return t; + } +} + +Token less_equal_comp() #LESS_EQUAL_COMP: +{ + Token t = token; +} +{ + try { + t= f_exp() f_exp() + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + } + { + jjtThis.setLine(t.beginLine); + jjtThis.setColumn(t.beginColumn); + return t; + } +} + +Token less_comp() #LESS_COMP: +{ + Token t = token; +} +{ + try { + t= f_exp() f_exp() + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + } + { + jjtThis.setLine(t.beginLine); + jjtThis.setColumn(t.beginColumn); + return t; + } +} + +Token equal_comp() #EQUAL_COMP: +{ + Token t = token; +} +{ + try { + t= f_exp() f_exp() + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + } + { + jjtThis.setLine(t.beginLine); + jjtThis.setColumn(t.beginColumn); + return t; + } +} + +Token f_exp() #F_EXP: +{ + Token t = token; +} +{ + try { + t=number() + | LOOKAHEAD(2) t=op() + | LOOKAHEAD(2) t=f_head() + | LOOKAHEAD(2) t=variable() + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + } + { + jjtThis.setLine(t.beginLine); + jjtThis.setColumn(t.beginColumn); + return t; + } +} + +Token number() #NUMBER: +{ + Token t = token; +} +{ + try { + t = + + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + } + { + + jjtThis.setLine(t.beginLine); + jjtThis.setColumn(t.beginColumn); + jjtThis.setImage(t.image); + return t; + } +} + +Token op() #OP: +{ + Token t = token; +} +{ + try { + LOOKAHEAD(2) t=binary_operation() + | LOOKAHEAD(2) t=unary_op() + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + } + { + jjtThis.setLine(t.beginLine); + jjtThis.setColumn(t.beginColumn); + return t; + } +} + +Token binary_operation() #BINARY_OPERATION: +{ + Token t = token; +} +{ + try{ + LOOKAHEAD(2) t=add_op() + | LOOKAHEAD(2) t=substract_op() + | LOOKAHEAD(2) t=multiply_op() + | LOOKAHEAD(2) t=divide_op() + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + } + { + jjtThis.setLine(t.beginLine); + jjtThis.setColumn(t.beginColumn); + return t; + } +} + +Token add_op() #ADD_OP: +{ + Token t = token; +} +{ + try { + t= f_exp() f_exp() + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + } + { + jjtThis.setLine(t.beginLine); + jjtThis.setColumn(t.beginColumn); + return t; + } +} + +Token substract_op() #SUBSTRACT_OP: +{ + Token t = token; +} +{ + try { + t= f_exp() f_exp() + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + } + { + jjtThis.setLine(t.beginLine); + jjtThis.setColumn(t.beginColumn); + return t; + } +} + +Token multiply_op() #MULTIPLY_OP: +{ + Token t = token; +} +{ + try { + t= f_exp() f_exp() + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + } + { + jjtThis.setLine(t.beginLine); + jjtThis.setColumn(t.beginColumn); + return t; + } +} + +Token divide_op() #DIVIDE_OP: +{ + Token t = token; +} +{ + try { + t=
f_exp() f_exp() + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + } + { + jjtThis.setLine(t.beginLine); + jjtThis.setColumn(t.beginColumn); + return t; + } +} + +Token unary_op() #UNARY_OP: +{ + Token t = token; +} +{ + try { + t= f_exp_da() + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + } + { + jjtThis.setLine(t.beginLine); + jjtThis.setColumn(t.beginColumn); + return t; + } +} + +Token f_head() #F_HEAD: +{ + Token t = token; +} +{ + try { + t= functor() (term())* + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + } + { + jjtThis.setLine(t.beginLine); + jjtThis.setColumn(t.beginColumn); + return t; + } +} + +Token structure_def() #STRUCTURE_DEF: +{ + Token t = token; +} +{ + try { + LOOKAHEAD(2) t=action_def() + | LOOKAHEAD(2) t=durative_action_def() + | LOOKAHEAD(2) t=derived_def() + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + } + { + jjtThis.setLine(t.beginLine); + jjtThis.setColumn(t.beginColumn); + return t; + } +} + +Token action_def() #ACTION_DEF: +{ + Token t = token; +} +{ + try { + t= action_name() + typed_list(LexerTreeConstants.JJTVARIABLE) + action_def_body() + + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + } + { + jjtThis.setLine(t.beginLine); + jjtThis.setColumn(t.beginColumn); + return t; + } +} + +Token action_name() #ACTION_NAME: +{ + Token t = token; +} +{ + try { + t= + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + } + { + jjtThis.setLine(t.beginLine); + jjtThis.setColumn(t.beginColumn); + jjtThis.setImage(t.image); + return t; + } +} + +Token action_def_body() #ACTION_DEF_BODY: +{ + Token t = token; +} +{ + try { + t= pre_gd() + effect() + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + } + { + jjtThis.setLine(t.beginLine); + jjtThis.setColumn(t.beginColumn); + return t; + } +} + +Token pre_gd() #PRE_GD: +{ + Token t = token; +} +{ + try { + LOOKAHEAD(2) t=empty_or() + | LOOKAHEAD(2) t=pref_gd() + | LOOKAHEAD(2) t=and_pre_gd() + | LOOKAHEAD(2) t=forall_pre_gd() + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + } + { + jjtThis.setLine(t.beginLine); + jjtThis.setColumn(t.beginColumn); + return t; + } +} + +Token empty_or() #EMPTY_OR: +{ + Token t = token; +} +{ + try { + t= + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + } + { + jjtThis.setLine(t.beginLine); + jjtThis.setColumn(t.beginColumn); + return t; + } +} + +Token and_pre_gd() #AND_PRE_GD: +{ + Token t = token; +} +{ + try { + t= (pre_gd())* + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + } + { + jjtThis.setLine(t.beginLine); + jjtThis.setColumn(t.beginColumn); + return t; + } +} + +Token forall_pre_gd() #FORALL_PRE_GD: +{ + Token t = token; +} +{ + try { + t= typed_list(LexerTreeConstants.JJTVARIABLE) pre_gd() + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + } + { + jjtThis.setLine(t.beginLine); + jjtThis.setColumn(t.beginColumn); + return t; + } +} + +Token pref_gd() #PREF_GD: +{ + Token t = token; +} +{ + try { + LOOKAHEAD(2) t=named_pref_gd() + | t=gd() + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + } + { + jjtThis.setLine(t.beginLine); + jjtThis.setColumn(t.beginColumn); + return t; + } +} + +Token named_pref_gd() #NAMED_PREF_GD: +{ + Token t = token; +} +{ + try { + t= [pref_name()] gd() + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + } + { + jjtThis.setLine(t.beginLine); + jjtThis.setColumn(t.beginColumn); + return t; + } +} + + +Token pref_name() #PREF_NAME: +{ + Token t = token; +} +{ + try { + t= + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + } + { + jjtThis.setLine(t.beginLine); + jjtThis.setColumn(t.beginColumn); + return t; + } +} + +Token effect() #EFFECT: +{ + Token t = token; +} +{ + try { + LOOKAHEAD(2) t=and_c_effect() + | LOOKAHEAD(2) t=c_effect() + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + } + { + jjtThis.setLine(t.beginLine); + jjtThis.setColumn(t.beginColumn); + return t; + } +} + +Token and_c_effect() #AND_C_EFFECT: +{ + Token t = token; +} +{ + try { + t= (c_effect())* + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + } + { + jjtThis.setLine(t.beginLine); + jjtThis.setColumn(t.beginColumn); + return t; + } +} + +Token prob_effect() #PROB_EFFECT: +{ + Token t = token; +} +{ + try{ + t = (prob_term())* + }catch(Throwable e){ + + this.error(e, t.beginLine, t.beginColumn); + } + { + + jjtThis.setLine(t.beginLine); + jjtThis.setColumn(t.beginColumn); + return t; + } +} + +Token prob_term() #PROB_TERM: +{ + Token t = token; +} +{ + try{ + LOOKAHEAD(3) t = number() c_effect() + | LOOKAHEAD(3) t = number() and_c_effect() + }catch(Throwable e){ + + this.error(e, t.beginLine, t.beginColumn); + } + { + + jjtThis.setLine(t.beginLine); + jjtThis.setColumn(t.beginColumn); + return t; + } +} + +Token c_effect() #C_EFFECT: +{ + Token t = token; +} +{ + try { + LOOKAHEAD(2) t=forall_effect() + | LOOKAHEAD(2) t=when_con_effect() + | LOOKAHEAD(2) t=p_effect() + | LOOKAHEAD(2) t=prob_effect() + } catch (Throwable e) { + + this.error(e, t.beginLine, t.beginColumn); + } + { + + jjtThis.setLine(t.beginLine); + jjtThis.setColumn(t.beginColumn); + return t; + } +} + +Token forall_effect() #FORALL_EFFECT: +{ + Token t = token; +} +{ + try { + t= typed_list(LexerTreeConstants.JJTVARIABLE) effect() + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + } + { + jjtThis.setLine(t.beginLine); + jjtThis.setColumn(t.beginColumn); + return t; + } +} + +Token when_con_effect() #WHEN_CON_EFFECT: +{ + Token t = token; +} +{ + try { + t= gd() cond_effect() + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + } + { + jjtThis.setLine(t.beginLine); + jjtThis.setColumn(t.beginColumn); + return t; + } +} + +Token cond_effect() #COND_EFFECT: +{ + Token t = token; +} +{ + try { + LOOKAHEAD(2) t=and_c_effect() + | LOOKAHEAD(2) t=c_effect() + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + } + { + jjtThis.setLine(t.beginLine); + jjtThis.setColumn(t.beginColumn); + return t; + } +} + +Token and_p_effect() #AND_P_EFFECT: +{ + Token t = token; +} +{ + try { + t= (p_effect())* + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + } + { + jjtThis.setLine(t.beginLine); + jjtThis.setColumn(t.beginColumn); + return t; + } +} + +Token p_effect() #P_EFFECT: +{ + Token t = token; +} +{ + try { + LOOKAHEAD(2) t=assign_op() + | LOOKAHEAD(2) t=literal(LexerTreeConstants.JJTTERM) + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + } + { + jjtThis.setLine(t.beginLine); + jjtThis.setColumn(t.beginColumn); + return t; + } +} + +Token assign_op() #ASSIGN_OP: +{ + Token t = token; +} +{ + try { + LOOKAHEAD(2) t=assign() + | LOOKAHEAD(2) t=scale_up() + | LOOKAHEAD(2) t=scale_down() + | LOOKAHEAD(2) t=increase() + | LOOKAHEAD(2) t=decrease() + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + } + { + jjtThis.setLine(t.beginLine); + jjtThis.setColumn(t.beginColumn); + return t; + } +} + +Token assign() #ASSIGN: +{ + Token t = token; +} +{ + try { + t= f_head() f_exp() + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + } + { + jjtThis.setLine(t.beginLine); + jjtThis.setColumn(t.beginColumn); + return t; + } + { return t; } +} + +Token scale_up() #SCALE_UP: +{ + Token t = token; +} +{ + try { + t= f_head() f_exp() + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + } + { + jjtThis.setLine(t.beginLine); + jjtThis.setColumn(t.beginColumn); + return t; + } +} + +Token scale_down() #SCALE_DOWN: +{ + Token t = token; +} +{ + try { + t= f_head() f_exp() + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + } + { + jjtThis.setLine(t.beginLine); + jjtThis.setColumn(t.beginColumn); + return t; + } +} + +Token increase() #INCREASE: +{ + Token t = token; +} +{ + try { + t= f_head() f_exp() + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + } + { + jjtThis.setLine(t.beginLine); + jjtThis.setColumn(t.beginColumn); + return t; + } +} + +Token decrease() #DECREASE: +{ + Token t = token; +} +{ + try { + t= f_head() f_exp() + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + } + { + jjtThis.setLine(t.beginLine); + jjtThis.setColumn(t.beginColumn); + return t; + } +} + +Token durative_action_def() #DURATION_ACTION_DEF: +{ + Token t = token; +} +{ + try { + t= da_symbol() + typed_list(LexerTreeConstants.JJTVARIABLE) + da_def_body() + + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + } + { + jjtThis.setLine(t.beginLine); + jjtThis.setColumn(t.beginColumn); + return t; + } +} + +Token da_symbol() #DA_SYMBOL: +{ + Token t = token; +} +{ + try { + t= + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + } + { + jjtThis.setLine(t.beginLine); + jjtThis.setColumn(t.beginColumn); + jjtThis.setImage(t.image); + return t; + } +} + +Token da_def_body() #DA_DEF_BODY: +{ + Token t = token; +} +{ + try { + t= duration_constraint() + da_gd() + da_effect() + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + } + { + jjtThis.setLine(t.beginLine); + jjtThis.setColumn(t.beginColumn); + return t; + } +} + +Token duration_constraint() #DURATION_CONSTRAINT: +{ + Token t = token; +} +{ + try { + LOOKAHEAD(2) t=empty_or() + | LOOKAHEAD(2) t=and_simple_duration_constraint() + | LOOKAHEAD(2) t=simple_duration_constraint() + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + } + { + jjtThis.setLine(t.beginLine); + jjtThis.setColumn(t.beginColumn); + return t; + } +} + +Token and_simple_duration_constraint() #AND_SIMPLE_DURATION_CONSTRAINT: +{ + Token t = token; +} +{ + try { + t= (simple_duration_constraint())+ + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + } + { + jjtThis.setLine(t.beginLine); + jjtThis.setColumn(t.beginColumn); + return t; + } +} + +Token simple_duration_constraint() #SIMPLE_DURATION_CONSTRAINT: +{ + Token t = token; +} +{ + try { + LOOKAHEAD(2) t=d_op() + | LOOKAHEAD(2) t=at_simple_duration_constraint() + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + } + { + jjtThis.setLine(t.beginLine); + jjtThis.setColumn(t.beginColumn); + return t; + } +} + +Token at_simple_duration_constraint() #AT_SIMPLE_DURATION_CONSTRAINT: +{ + Token t = token; +} +{ + try { + LOOKAHEAD(3) t=at_start_simple_duration_constraint() + | LOOKAHEAD(3) t=at_end_simple_duration_constraint() + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + } + { + jjtThis.setLine(t.beginLine); + jjtThis.setColumn(t.beginColumn); + return t; + } +} + +Token at_start_simple_duration_constraint() #AT_START_SIMPLE_DURATION_CONSTRAINT: +{ + Token t = token; +} +{ + try { + t= simple_duration_constraint() + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + } + { + jjtThis.setLine(t.beginLine); + jjtThis.setColumn(t.beginColumn); + return t; + } +} + +Token at_end_simple_duration_constraint() #AT_END_SIMPLE_DURATION_CONSTRAINT: +{ + Token t = token; +} +{ + try { + t= simple_duration_constraint() + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + } + { + jjtThis.setLine(t.beginLine); + jjtThis.setColumn(t.beginColumn); + return t; + } +} + +Token d_op() #D_OP: +{ + Token t = token; +} +{ + try { + LOOKAHEAD(2) t=equal_d_op() + | LOOKAHEAD(2) t=gequal_d_op() + | LOOKAHEAD(2) t=lequal_d_op() + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + } + { + jjtThis.setLine(t.beginLine); + jjtThis.setColumn(t.beginColumn); + return t; + } +} + +Token equal_d_op() #EQUAL_D_OP: +{ + Token t = token; +} +{ + try { + t= var_duration() d_value() + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + } + { + jjtThis.setLine(t.beginLine); + jjtThis.setColumn(t.beginColumn); + return t; + } +} + +Token gequal_d_op() #GEQUAL_D_OP: +{ + Token t = token; +} +{ + try { + t= var_duration() d_value() + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + } + { + jjtThis.setLine(t.beginLine); + jjtThis.setColumn(t.beginColumn); + return t; + } +} + +Token lequal_d_op() #LEQUAL_D_OP: +{ + Token t = token; +} +{ + try { + t= var_duration() d_value() + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + } + { + jjtThis.setLine(t.beginLine); + jjtThis.setColumn(t.beginColumn); + return t; + } +} + +Token var_duration() #VAR_DURATION: +{ + Token t = token; +} +{ + try { + t= + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + } + { + jjtThis.setLine(t.beginLine); + jjtThis.setColumn(t.beginColumn); + return t; + } +} + +Token d_value() #D_VALUE: +{ + Token t = token; +} +{ + try { + LOOKAHEAD(2) t=number() + | LOOKAHEAD(2) t=f_exp() + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + } + { + jjtThis.setLine(t.beginLine); + jjtThis.setColumn(t.beginColumn); + return t; + } +} + +Token da_gd() #DA_GD: +{ + Token t = token; +} +{ + try { + LOOKAHEAD(2) t=pref_timed_gd() + | LOOKAHEAD(2) t=and_da_gd() + | LOOKAHEAD(2) t=forall_da_gd() + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + } + { + jjtThis.setLine(t.beginLine); + jjtThis.setColumn(t.beginColumn); + return t; + } +} + +Token forall_da_gd() #FORALL_DA_GD: +{ + Token t = token; +} +{ + try { + t= typed_list(LexerTreeConstants.JJTVARIABLE) da_gd() + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + } + { + jjtThis.setLine(t.beginLine); + jjtThis.setColumn(t.beginColumn); + return t; + } +} + +Token and_da_gd() #AND_DA_GD: +{ + Token t = token; +} +{ + try { + t= (da_gd())* + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + } + { + jjtThis.setLine(t.beginLine); + jjtThis.setColumn(t.beginColumn); + return t; + } +} + + +Token pref_timed_gd() #PREF_TIMED_GD: +{ + Token t = token; +} +{ + try { + LOOKAHEAD(2) t=timed_gd() + | LOOKAHEAD(2) t=named_pref_timed_gd() + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + } + { + jjtThis.setLine(t.beginLine); + jjtThis.setColumn(t.beginColumn); + return t; + } +} + +Token named_pref_timed_gd() #NAMED_PREF_TIMED_GD: +{ + Token t = token; +} +{ + try { + t= [pref_name()] timed_gd() + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + } + { + jjtThis.setLine(t.beginLine); + jjtThis.setColumn(t.beginColumn); + return t; + } +} + +Token timed_gd() #TIMED_GD: +{ + Token t = token; +} +{ + try { + LOOKAHEAD(2) t=at_timed_gd() + | LOOKAHEAD(2) t=over_timed_gd() + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + } + { + jjtThis.setLine(t.beginLine); + jjtThis.setColumn(t.beginColumn); + return t; + } +} + +Token over_timed_gd() #OVER_TIMED_GD: +{ + Token t = token; +} +{ + try { + t=over_all_timed_gd() + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + } + { + jjtThis.setLine(t.beginLine); + jjtThis.setColumn(t.beginColumn); + return t; + } +} + +Token over_all_timed_gd() #OVER_ALL_TIMED_GD: +{ + Token t = token; +} +{ + try { + t= gd() + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + } + { + jjtThis.setLine(t.beginLine); + jjtThis.setColumn(t.beginColumn); + return t; + } +} + +Token at_timed_gd() #AT_TIMED_GD: +{ + Token t = token; +} +{ + try { + LOOKAHEAD(3) t=at_start_timed_gd() + | LOOKAHEAD(2) t=at_end_timed_gd() + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + } + { + jjtThis.setLine(t.beginLine); + jjtThis.setColumn(t.beginColumn); + return t; + } +} + +Token at_start_timed_gd() #AT_START_TIMED_GD: +{ + Token t = token; +} +{ + try { + t= gd() + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + } + { + jjtThis.setLine(t.beginLine); + jjtThis.setColumn(t.beginColumn); + return t; + } +} + +Token at_end_timed_gd() #AT_END_TIMED_GD: +{ + Token t = token; +} +{ + try { + t= gd() + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + } + { + jjtThis.setLine(t.beginLine); + jjtThis.setColumn(t.beginColumn); + return t; + } +} + +Token interval() #INTERVAL: +{ + Token t = token; +} +{ + try { + t= + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + } + { + jjtThis.setLine(t.beginLine); + jjtThis.setColumn(t.beginColumn); + return t; + } +} + +Token da_effect() #DA_EFFECT: +{ + Token t = token; +} +{ + try { + LOOKAHEAD(2) t=timed_effect() + | LOOKAHEAD(2) t=and_da_effect() + | LOOKAHEAD(2) t=forall_da_effect() + | LOOKAHEAD(2) t=when_da_effect() + | LOOKAHEAD(2) t=da_assign_op() + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + } + { + jjtThis.setLine(t.beginLine); + jjtThis.setColumn(t.beginColumn); + return t; + } +} + +Token da_assign_op() #DA_ASSIGN_OP: +{ + Token t = token; +} +{ + try { + LOOKAHEAD(2) t=da_assign() + | LOOKAHEAD(2) t=da_scale_up() + | LOOKAHEAD(2) t=da_scale_down() + | LOOKAHEAD(2) t=da_increase() + | LOOKAHEAD(2) t=da_decrease() + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + } + { + jjtThis.setLine(t.beginLine); + jjtThis.setColumn(t.beginColumn); + return t; + } +} + +Token da_assign() #DA_ASSIGN: +{ + Token t = token; +} +{ + try { + t= f_head() f_exp_da() + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + } + { + jjtThis.setLine(t.beginLine); + jjtThis.setColumn(t.beginColumn); + return t; + } +} + +Token da_scale_up() #DA_SCALE_UP: +{ + Token t = token; +} +{ + try { + t= f_head() f_exp_da() + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + } + { + jjtThis.setLine(t.beginLine); + jjtThis.setColumn(t.beginColumn); + return t; + } +} + +Token da_scale_down() #DA_SCALE_DOWN: +{ + Token t = token; +} +{ + try { + t= f_head() f_exp_da() + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + } + { + jjtThis.setLine(t.beginLine); + jjtThis.setColumn(t.beginColumn); + return t; + } + +} + +Token da_increase() #DA_INCREASE: +{ + Token t = token; +} +{ + try { + t= f_head() f_exp_da() + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + } + { + jjtThis.setLine(t.beginLine); + jjtThis.setColumn(t.beginColumn); + return t; + } +} + +Token da_decrease() #DA_DECREASE: +{ + Token t = token; +} +{ + try { + t= f_head() f_exp_da() + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + } + { + jjtThis.setLine(t.beginLine); + jjtThis.setColumn(t.beginColumn); + return t; + } +} + +Token when_da_effect() #WHEN_DA_EFFECT: +{ + Token t = token; +} +{ + try { + t= da_gd() timed_effect() + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + } + { + jjtThis.setLine(t.beginLine); + jjtThis.setColumn(t.beginColumn); + return t; + } +} + + +Token forall_da_effect() #FORALL_DA_EFFECT: +{ + Token t = token; +} +{ + try { + t= typed_list(LexerTreeConstants.JJTVARIABLE) da_effect() + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + } + { + jjtThis.setLine(t.beginLine); + jjtThis.setColumn(t.beginColumn); + return t; + } +} + +Token and_da_effect() #AND_DA_EFFECT: +{ + Token t = token; +} +{ + try { + t= (da_effect())* + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + } + { + jjtThis.setLine(t.beginLine); + jjtThis.setColumn(t.beginColumn); + return t; + } +} + +Token timed_effect() #TIMED_EFFECT: +{ + Token t = token; +} +{ + try { + LOOKAHEAD(2) t=at_da_effect() + | LOOKAHEAD(2) t=at_f_assign_da_effect() + | LOOKAHEAD(2) t=assign_op_t() + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + } + { + jjtThis.setLine(t.beginLine); + jjtThis.setColumn(t.beginColumn); + return t; + } +} + +Token at_f_assign_da_effect() #AT_F_ASSIGN_DA_EFFECT: +{ + Token t = token; +} +{ + try { + LOOKAHEAD(3) t=at_start_f_assign_da_effect() + | LOOKAHEAD(3) t=at_end_f_assign_da_effect() + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + } + { + jjtThis.setLine(t.beginLine); + jjtThis.setColumn(t.beginColumn); + return t; + } +} + +Token at_start_f_assign_da_effect() #AT_START_F_ASSIGN_DA_EFFECT: +{ + Token t = token; +} +{ + try { + t= f_assign_da() + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + } + { + jjtThis.setLine(t.beginLine); + jjtThis.setColumn(t.beginColumn); + return t; + } +} + + +Token at_end_f_assign_da_effect() #AT_END_F_ASSIGN_DA_EFFECT: +{ + Token t = token; +} +{ + try { + t= f_assign_da() + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + } + { + jjtThis.setLine(t.beginLine); + jjtThis.setColumn(t.beginColumn); + return t; + } +} + +Token at_da_effect() #AT_DA_EFFECT: +{ + Token t = token; +} +{ + try { + LOOKAHEAD(4) t=at_start_da_effect() + | LOOKAHEAD(4) t=at_end_da_effect() + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + } + { + jjtThis.setLine(t.beginLine); + jjtThis.setColumn(t.beginColumn); + return t; + } +} + +Token at_start_da_effect() #AT_START_DA_EFFECT: +{ + Token t = token; +} +{ + try { + t= literal(LexerTreeConstants.JJTTERM) + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + } + { + jjtThis.setLine(t.beginLine); + jjtThis.setColumn(t.beginColumn); + return t; + } +} + + +Token at_end_da_effect() #AT_END_DA_EFFECT: +{ + Token t = token; +} +{ + try { + t= literal(LexerTreeConstants.JJTTERM) + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + } + { + jjtThis.setLine(t.beginLine); + jjtThis.setColumn(t.beginColumn); + return t; + } +} + +Token assign_op_t() #ASSIGN_OP_T: +{ + Token t = token; +} +{ + try { + LOOKAHEAD(2) t=increase_assign_op_t() + | LOOKAHEAD(2) t=decrease_assign_op_t() + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + } + { + jjtThis.setLine(t.beginLine); + jjtThis.setColumn(t.beginColumn); + return t; + } +} + +Token increase_assign_op_t() #INCREASE_ASSIGN_OP_T: +{ + Token t = token; +} +{ + try { + t= f_head() f_exp_t() + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + } + { + jjtThis.setLine(t.beginLine); + jjtThis.setColumn(t.beginColumn); + return t; + } +} + +Token decrease_assign_op_t() #DECREASE_ASSIGN_OP_T: +{ + Token t = token; +} +{ + try { + t= f_head() f_exp_t() + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + } + { + jjtThis.setLine(t.beginLine); + jjtThis.setColumn(t.beginColumn); + return t; + } +} + +Token f_exp_t() #F_EXP_T: +{ + Token t = token; +} +{ + try { + LOOKAHEAD(2) t= continous_variable() f_exp() + | LOOKAHEAD(2) t= f_exp() continous_variable() + | LOOKAHEAD(2) t=continous_variable() + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + } + { + jjtThis.setLine(t.beginLine); + jjtThis.setColumn(t.beginColumn); + return t; + } +} + +Token continous_variable() #CONTINOUS_VARIABLE: +{ + Token t = token; +} +{ + try { + t= + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + } + { + jjtThis.setLine(t.beginLine); + jjtThis.setColumn(t.beginColumn); + jjtThis.setImage(t.image); + return t; + } + +} + +Token f_assign_da() #F_ASSIGN_DA: +{ + Token t = token; +} +{ + try { + LOOKAHEAD(2) t=da_assign() + | LOOKAHEAD(2) t=da_scale_up() + | LOOKAHEAD(2) t=da_scale_down() + | LOOKAHEAD(2) t=da_increase() + | LOOKAHEAD(2) t=da_decrease() + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + } + { + jjtThis.setLine(t.beginLine); + jjtThis.setColumn(t.beginColumn); + return t; + } +} + +Token f_exp_da() #F_EXP_DA: +{ + Token t = token; +} +{ + try { + LOOKAHEAD(3) t=f_exp() + | LOOKAHEAD(3) t=da_binary_op() + | LOOKAHEAD(3) t=da_unary_op() + | LOOKAHEAD(3) t=var_duration() + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + } + { + jjtThis.setLine(t.beginLine); + jjtThis.setColumn(t.beginColumn); + return t; + } +} + + +Token da_binary_op() #DA_BINARY_OP: +{ + Token t = token; +} +{ + try { + LOOKAHEAD(2) t=da_add_op() + | LOOKAHEAD(2) t=da_substract_op() + | LOOKAHEAD(2) t=da_multiply_op() + | LOOKAHEAD(2) t=da_divide_op() + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + } + { + jjtThis.setLine(t.beginLine); + jjtThis.setColumn(t.beginColumn); + return t; + } +} + +Token da_add_op() #DA_ADD_OP: +{ + Token t = token; +} +{ + try { + t= f_head() f_exp_da() + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + } + { + jjtThis.setLine(t.beginLine); + jjtThis.setColumn(t.beginColumn); + return t; + } +} + +Token da_substract_op() #DA_SUBSTRACT_OP: +{ + Token t = token; +} +{ + try { + t= f_head() f_exp_da() + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + } + { + jjtThis.setLine(t.beginLine); + jjtThis.setColumn(t.beginColumn); + return t; + } +} + +Token da_multiply_op() #DA_MULTIPLY_OP: +{ + Token t = token; +} +{ + try { + t= f_head() f_exp_da() + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + } + { + jjtThis.setLine(t.beginLine); + jjtThis.setColumn(t.beginColumn); + return t; + } +} + +Token da_divide_op() #DA_DIVIDE_OP: +{ + Token t = token; +} +{ + try { + t=
f_head() f_exp_da() + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + } + { + jjtThis.setLine(t.beginLine); + jjtThis.setColumn(t.beginColumn); + return t; + } +} + +Token da_unary_op() #DA_UNARY_OP: +{ + Token t = token; +} +{ + try { + t= f_exp_da() + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + } + { + jjtThis.setLine(t.beginLine); + jjtThis.setColumn(t.beginColumn); + return t; + } +} + +Token derived_def() #DERIVED_DEF: +{ + Token t = token; +} +{ + try { + t= atomic_formula(LexerTreeConstants.JJTVARIABLE) gd() + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + } + { + jjtThis.setLine(t.beginLine); + jjtThis.setColumn(t.beginColumn); + return t; + } +} + +Token problem() #PROBLEM: +{ + Token t = token; +} +{ + try { + t= problem_name() + domain_name() + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + } + [LOOKAHEAD(2) require_def()] + [LOOKAHEAD(2) object_declaration()] + init() + goal() + [LOOKAHEAD(2) constraints()] + [LOOKAHEAD(2) metric_spec()] + // [length-spec()] not implemented + { + jjtThis.setLine(t.beginLine); + jjtThis.setColumn(t.beginColumn); + return t; + } +} + +Token problem_name() #PROBLEM_NAME: +{ + Token t = token; +} +{ + try { + t= + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + } + { + jjtThis.setLine(t.beginLine); + jjtThis.setColumn(t.beginColumn); + jjtThis.setImage(t.image); + return t; + } +} + +Token domain_name() #DOMAIN_NAME: +{ + Token t = token; +} +{ + try { + t= + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + } + { + jjtThis.setLine(t.beginLine); + jjtThis.setColumn(t.beginColumn); + jjtThis.setImage(t.image); + return t; + } +} + +Token object_declaration() #OBJECT_DECLARATION: +{ + Token t = token; +} +{ + try { + t= typed_list(LexerTreeConstants.JJTCONSTANT) + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + } + { + jjtThis.setLine(t.beginLine); + jjtThis.setColumn(t.beginColumn); + return t; + } +} + +Token init() #INIT: +{ + Token t = token; +} +{ + try { + t= (init_el())* + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + } + { + jjtThis.setLine(t.beginLine); + jjtThis.setColumn(t.beginColumn); + return t; + } +} + +Token init_el() #INIT_EL: +{ + Token t = token; +} +{ + try { + LOOKAHEAD(2) t=literal(LexerTreeConstants.JJTCONSTANT) + | LOOKAHEAD(2) t=equal_init_el() + | LOOKAHEAD(3) t=timed_literal() + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + } + { + jjtThis.setLine(t.beginLine); + jjtThis.setColumn(t.beginColumn); + return t; + } +} + +Token equal_init_el() #EQUAL_INIT_EL: +{ + Token t = token; +} +{ + try { + t= f_head() number() + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + } + { + jjtThis.setLine(t.beginLine); + jjtThis.setColumn(t.beginColumn); + return t; + } +} + +Token timed_literal() #TIMED_LITERAL: +{ + Token t = token; +} +{ + try { + t= number() literal(LexerTreeConstants.JJTCONSTANT) + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + } + { + jjtThis.setLine(t.beginLine); + jjtThis.setColumn(t.beginColumn); + return t; + } +} + +Token goal() #GOAL: +{ + Token t = token; +} +{ + try { + t= pre_gd() + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + } + { + jjtThis.setLine(t.beginLine); + jjtThis.setColumn(t.beginColumn); + return t; + } +} + +Token constraints() #CONSTRAINTS: +{ + Token t = token; +} +{ + try { + t= pref_con_gd() + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + } + { + jjtThis.setLine(t.beginLine); + jjtThis.setColumn(t.beginColumn); + return t; + } +} + +Token pref_con_gd() #PREF_CON_GD: +{ + Token t = token; +} +{ + try { + LOOKAHEAD(2) t=and_pref_con_gd() + | LOOKAHEAD(2) t=forall_pref_con_gd() + | LOOKAHEAD(2) t=named_pref_con_gd() + | LOOKAHEAD(2) t=con_gd() + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + } + { + jjtThis.setLine(t.beginLine); + jjtThis.setColumn(t.beginColumn); + return t; + } +} + +Token and_pref_con_gd() #AND_PREF_CON_GD: +{ + Token t = token; +} +{ + try { + t= (pref_con_gd())* + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + } + { + jjtThis.setLine(t.beginLine); + jjtThis.setColumn(t.beginColumn); + return t; + } +} + +Token named_pref_con_gd() #NAMED_PREF_CON_GD: +{ + Token t = token; +} +{ + try { + t= [pref_name()] con_gd() + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + } + { + jjtThis.setLine(t.beginLine); + jjtThis.setColumn(t.beginColumn); + return t; + } +} + +Token forall_pref_con_gd() #FORALL_PREF_CON_GD: +{ + Token t = token; +} +{ + try { + t= typed_list(LexerTreeConstants.JJTVARIABLE) pref_con_gd() + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + } + { + jjtThis.setLine(t.beginLine); + jjtThis.setColumn(t.beginColumn); + return t; + } +} + +Token metric_spec() #METRIC_SPEC: +{ + Token t = token; +} +{ + try { + LOOKAHEAD(3) t=maximize() + | LOOKAHEAD(3) t=minimize() + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + } + { + jjtThis.setLine(t.beginLine); + jjtThis.setColumn(t.beginColumn); + return t; + } +} + +Token maximize() #MAXIMIZE: +{ + Token t = token; +} +{ + try { + t= metric_f_exp() + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + } + { + jjtThis.setLine(t.beginLine); + jjtThis.setColumn(t.beginColumn); + return t; + } +} + +Token minimize() #MINIMIZE: +{ + Token t = token; +} +{ + try { + t= metric_f_exp() + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + } + { + jjtThis.setLine(t.beginLine); + jjtThis.setColumn(t.beginColumn); + return t; + } +} + +Token metric_f_exp() #METRIC_F_EXP: +{ + Token t = token; +} +{ + try { + LOOKAHEAD(2) t=unary_op_metric_f_exp() + | LOOKAHEAD(2) t=binary_op_metric_f_exp() + | LOOKAHEAD(2) t=multi_op_metric_f_exp() + | LOOKAHEAD(2) t=number() + | LOOKAHEAD(2) t=constant_f_head() + | LOOKAHEAD(2) t=total_time() + | LOOKAHEAD(2) t=violated_pref_exp() + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + } + { + jjtThis.setLine(t.beginLine); + jjtThis.setColumn(t.beginColumn); + return t; + } +} + +Token violated_pref_exp() #VIOLATED_PREF_EXP: +{ + Token t = token; +} +{ + try { + t= pref_name() + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + } + { + jjtThis.setLine(t.beginLine); + jjtThis.setColumn(t.beginColumn); + return t; + } +} + +Token constant_f_head() #CONSTANT_F_HEAD: +{ + Token t = token; +} +{ + try { + t= functor() (constant())* + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + } + { + jjtThis.setLine(t.beginLine); + jjtThis.setColumn(t.beginColumn); + return t; + } +} + +Token total_time() #TOTAL_TIME: +{ + Token t = token; +} +{ + try { + t= + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + } + { + jjtThis.setLine(t.beginLine); + jjtThis.setColumn(t.beginColumn); + return t; + } +} + + +Token binary_op_metric_f_exp() #BINARY_OP_METRIC_F_EXP: +{ + Token t = token; +} +{ + try { + LOOKAHEAD(2) t=add_op_metric_f_exp() + | LOOKAHEAD(2) t=substract_op_metric_f_exp() + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + } + { + jjtThis.setLine(t.beginLine); + jjtThis.setColumn(t.beginColumn); + return t; + } +} + +Token add_op_metric_f_exp() #ADD_OP_METRIC_F_EXP: +{ + Token t = token; +} +{ + try { + t= metric_f_exp() metric_f_exp() + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + } + { + jjtThis.setLine(t.beginLine); + jjtThis.setColumn(t.beginColumn); + return t; + } +} + +Token substract_op_metric_f_exp() #SUBSTRACT_OP_METRIC_F_EXP: +{ + Token t = token; +} +{ + try{ + t= metric_f_exp() metric_f_exp() + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + } + { + jjtThis.setLine(t.beginLine); + jjtThis.setColumn(t.beginColumn); + return t; + } +} + +Token multi_op_metric_f_exp() #MULTI_OP_METRIC_F_EXP: +{ + Token t = token; +} +{ + try { + LOOKAHEAD(2) t=multiply_narity_op_metric_f_exp() + | LOOKAHEAD(2) t=add_narity_op_metric_f_exp() + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + } + { + jjtThis.setLine(t.beginLine); + jjtThis.setColumn(t.beginColumn); + return t; + } +} + +Token multiply_narity_op_metric_f_exp() #MULTIPLY_NARITY_OP_METRIC_F_EXP: +{ + Token t = token; +} +{ + try { + t= metric_f_exp() (metric_f_exp())+ + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + } + { + jjtThis.setLine(t.beginLine); + jjtThis.setColumn(t.beginColumn); + return t; + } +} + +Token add_narity_op_metric_f_exp() #ADD_NARITY_OP_METRIC_F_EXP: +{ + Token t = token; +} +{ + try { + t= metric_f_exp() (metric_f_exp())+ + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn); + } + { + jjtThis.setLine(t.beginLine); + jjtThis.setColumn(t.beginColumn); + return t; + } +} + +Token unary_op_metric_f_exp() #UNARY_OP_METRIC_F_EXP: +{ + Token t = token; +} +{ + try { + t= metric_f_exp() + } catch (Throwable e) { + this.error(e, t.beginLine, t.beginColumn);; + } + { + jjtThis.setLine(t.beginLine); + jjtThis.setColumn(t.beginColumn); + return t; + } +} + + + -- cgit v1.2.1