Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
   /* Generated By:JavaCC: Do not edit this line. as2j.java */
     package jason.asSyntax.parser;
   
     import java.util.*;
     import java.io.*;
     import java.util.logging.*;
   
     import jason.*;
     import jason.asSemantics.*;
    import jason.bb.*;
    import jason.asSyntax.*;
    import jason.jeditplugin.*;
  
    public class as2j implements as2jConstants {
      private String asSource = null;
      private Agent  curAg    = null;
  
      private static Logger logger = Logger.getLogger("aslparser");
      private static Set<StringparsedFiles = new HashSet<String>();
      private static Config config = Config.get(false);
  
      public void setAg(Agent ag) {  = ag; }
  
      private String getSourceRef(SourceInfo s) {
          if (s == null)
              return "[]";
          else
              return "["+s.getSrcFile()+":"+s.getBeginSrcLine()+"]";
      }
      private String getSourceRef(DefaultTerm t) {
          return getSourceReft.getSrcInfo());
      }
      private String getSourceRef(Object t) {
          if (t instanceof DefaultTerm)
              return getSourceRef((DefaultTerm)t);
          else if (t instanceof SourceInfo)
              return getSourceRef((SourceInfo)t);
          else
              return "[]";
      }
  
          private InternalActionLiteral checkInternalActionsInContext(LogicalFormula fAgent agthrows Exception {
              if (f != null) {
                  if (f instanceof InternalActionLiteral) {
                      InternalActionLiteral ial = (InternalActionLiteral)f;
                      if (! ial.getIA(ag).canBeUsedInContext())
                         return ial;
                  } else if (f instanceof LogExpr) {
                      LogExpr le = (LogExpr)f;
                      InternalActionLiteral ial = checkInternalActionsInContext(le.getLHS(), ag);
                      if (ial != null)
                          return ial;
                      if (!le.isUnary())
                          return checkInternalActionsInContext(le.getRHS(), ag);
                  }
          }
          return null;
      }
  
      private ArithFunction getArithFunction(Literal l) {
          ArithFunction af = null;
          if ( != null)
             // try to find the function in agent register
             af = .getFunction(l.getFunctor(), l.getArity());
          if (af == null)
             // try global function
             af = FunctionRegister.getFunction(l.getFunctor(), l.getArity());
          return af;
      }
  
      private Term changeToAtom(Object o) {
          Term u = (Term)o;
          if (u == .)
              return u;
          if (u == .)
              return u;
          if (u.isAtom())
             return new Atom((Literal)u);
          return u;
      }
  
  /* AgentSpeak Grammar */
  
  /*   agent ::= bels goals plans
  
       returns true if achieved the end of file
       returns false if achieved a "{ end }" directive  
  */
    final public boolean agent(Agent athrows ParseExceptionjason.JasonException {
                                  Literal b;
                                  Literal g;
                                  Plan    p;
                                  = a;
                                 if (a != null && a.getASLSrc() != null = a.getASLSrc();
                                 boolean endDir = false;
     label_1:
     while (true) {
       switch ((==-1)?jj_ntk():) {
       case 30:
         ;
         break;
       default:
         [0] = ;
         break label_1;
       }
       endDir = directive(a);
                                 if (endDir) {if (truereturn false;}
     }
     label_2:
     while (true) {
       switch ((==-1)?jj_ntk():) {
       case :
       case :
       case :
       case :
       case :
       case :
       case :
       case :
         ;
         break;
       default:
         [1] = ;
         break label_2;
       }
       b = belief();
                                 if (a != nulla.addInitialBel(b);
       label_3:
       while (true) {
         switch ((==-1)?jj_ntk():) {
         case 30:
           ;
           break;
         default:
           [2] = ;
           break label_3;
         }
         endDir = directive(a);
                                 if (endDir) {if (truereturn false;}
       }
     }
     label_4:
     while (true) {
       switch ((==-1)?jj_ntk():) {
       case 34:
         ;
         break;
       default:
         [3] = ;
         break label_4;
       }
       g = initial_goal();
                                 if (a != nulla.addInitialGoal(g);
       label_5:
       while (true) {
         switch ((==-1)?jj_ntk():) {
         case 30:
           ;
           break;
         default:
           [4] = ;
           break label_5;
         }
         endDir = directive(a);
                                 if (endDir) {if (truereturn false;}
       }
     }
     label_6:
     while (true) {
       switch ((==-1)?jj_ntk():) {
       case :
       case 37:
       case 38:
       case 39:
         ;
         break;
       default:
         [5] = ;
         break label_6;
       }
       p = plan();
                                 if (a != null) {
                                    a.getPL().add(p);
                                    // warning only not parsed files
                                    if (.getBoolean(.) && !.contains()) {
                                       List<VarTermsingletonVars = p.getSingletonVars();
                                       if (singletonVars.size() > 0) {
                                          .warning(getSourceRef(p.getSrcInfo())+" warning: the plan for event '"+p.getTrigger()+"' has the following singleton variables: "+singletonVars);
                                       }
                                    }
                                 }
       label_7:
       while (true) {
         switch ((==-1)?jj_ntk():) {
         case :
         case :
         case :
         case :
         case :
         case :
         case :
         case :
           ;
           break;
         default:
           [6] = ;
           break label_7;
         }
         b = belief();
                                 if (a != null) {
                                   if (b.isRule()) {
                                       a.addInitialBel(b);
                                       //if (!parsedFiles.contains(asSource))
                                       //   logger.warning(getSourceRef(b)+" warning: avoid to mix rules and plans ('"+b+"').");
                                   } else {
                                       {if (truethrow new ParseException(getSourceRef(b)+" The belief '"+b+"' is not in the begin of the source code!");}
                                   }
                                 }
       }
       label_8:
       while (true) {
         switch ((==-1)?jj_ntk():) {
         case 30:
           ;
           break;
         default:
           [7] = ;
           break label_8;
         }
         endDir = directive(a);
                                 if (endDir) {if (truereturn false;}
       }
     }
     jj_consume_token(0);
                                 if (a != null.add(a.getASLSrc());
                                 {if (truereturn true;}
     throw new Error("Missing return statement in function");
   }
 
 /* Directive 
 
    returns true if the directive is "{ end }", false otherwise
 */
   final public boolean directive(Agent outerAgthrows ParseExceptionjason.JasonException {
                                 Pred dir = null;
                                 Agent resultOfDirective = null;
                                 Agent bakAg = ;
                                 boolean isEOF = false;
     jj_consume_token(30);
     if (jj_2_1(4)) {
       dir = pred();
       jj_consume_token(31);
                                 Agent innerAg = new Agent(); innerAg.initAg();
       isEOF = agent(innerAg);
                                 if (isEOF)
                                    {if (truethrow new ParseException(getSourceRef(dir)+" The directive '{ begin "+dir+"}' does not end with '{ end }'.");}
                                 else
                                    resultOfDirective = DirectiveProcessor.process(dirouterAginnerAg);
     } else {
       switch ((==-1)?jj_ntk():) {
       case :
       case :
       case :
         dir = pred();
         jj_consume_token(31);
                                 if (dir.toString().equals("end"))
                                    {if (truereturn true;}
                                 else
                                    resultOfDirective = DirectiveProcessor.process(dirouterAgnull);
         break;
       default:
         [8] = ;
         jj_consume_token(-1);
         throw new ParseException();
       }
     }
                                 if (resultOfDirective != null && outerAg != null) {
                                   // import bels, plans and initial goals from agent resultOfDirective
                                   outerAg.importComponents(resultOfDirective);
                                 }
                                  = bakAg;
                                 {if (truereturn false;}
     throw new Error("Missing return statement in function");
   }
 
 /* Beliefs & Rules */
   final public Literal belief() throws ParseException {
                      Literal hObject t;
     h = literal();
                                if (h.isVar()) {
                                   {if (truethrow new ParseException(getSourceRef(h)+" variables cannot be beliefs!");}
                                }
     switch ((==-1)?jj_ntk():) {
     case 32:
       jj_consume_token(32);
       t = log_expr();
                                h = new Rule(h,(LogicalFormula)t);
                                // warning only not parsed files
                                if (.getBoolean(.) && !.contains()) {
                                   List<VarTermsingletonVars = h.getSingletonVars();
                                   if (singletonVars.size() > 0) {
                                      .warning(getSourceRef(h)+" warning: the rule with head '"+((Rule)h).headClone()+"' has the following singleton variables: "+singletonVars);
                                   }
                                }
       break;
     default:
       [9] = ;
       ;
     }
     jj_consume_token(33);
                                {if (truereturn h;}
     throw new Error("Missing return statement in function");
   }
 
 /* Initial goals */
   final public Literal initial_goal() throws ParseException {
                            Literal g;
     jj_consume_token(34);
     g = literal();
     jj_consume_token(33);
                            if (g.isVar()) {
                                   {if (truethrow new ParseException(getSourceRef(g)+". a variable cannot be a goal!");}
                            }
                            {if (truereturn g;}
     throw new Error("Missing return statement in function");
   }
 
 /* Plan */
   final public Plan plan() throws ParseException {
                         Token k;
                         Pred L = null;
                         Trigger T;
                         Object C = null;
                         PlanBody B = null;
                         int start = -1, end;
     switch ((==-1)?jj_ntk():) {
     case :
       k = jj_consume_token();
       L = pred();
                                     start = k.beginLine;
       break;
     default:
       [10] = ;
       ;
     }
     T = trigger();
     switch ((==-1)?jj_ntk():) {
     case 35:
       k = jj_consume_token(35);
       C = log_expr();
                                    if (start == -1) start = k.beginLine;
       break;
     default:
       [11] = ;
       ;
     }
     switch ((==-1)?jj_ntk():) {
     case 36:
       k = jj_consume_token(36);
       B = plan_body();
                                    if (start == -1) start = k.beginLine;
       break;
     default:
       [12] = ;
       ;
     }
     k = jj_consume_token(33);
                                    if (start == -1) start = k.beginLine;
                      end = k.beginLine;
                      InternalActionLiteral ial = null;
                      try { ial = checkInternalActionsInContext((LogicalFormula)C); } catch (Exception e) {}
                      if (ial != null)
                         {if (truethrow new ParseException(getSourceRef(ial)+" The internal action '"+ial+"' can not be used in plan's context!");}
                          if (B != null && B.getBodyTerm().equals(.))
                             B = (PlanBody)B.getBodyNext();
                      Plan p = new Plan(L,T,(LogicalFormula)CB);
                      p.setSrcInfo(new SourceInfo(,start,end));
                      {if (truereturn p;}
     throw new Error("Missing return statement in function");
   }
 
 /* Trigger */
   final public Trigger trigger() throws ParseException {
                         TEOperator teOp;
                                 TEType     teType = .;
                                         Literal F;
     switch ((==-1)?jj_ntk():) {
     case 37:
       jj_consume_token(37);
                  teOp = .;
       break;
     case 38:
       jj_consume_token(38);
                  teOp = .;
       break;
     case 39:
       jj_consume_token(39);
                  teOp = .;
       break;
     default:
       [13] = ;
       jj_consume_token(-1);
       throw new ParseException();
     }
     switch ((==-1)?jj_ntk():) {
     case 34:
     case 40:
       switch ((==-1)?jj_ntk():) {
       case 34:
         jj_consume_token(34);
                  teType = .;
         break;
       case 40:
         jj_consume_token(40);
                  teType = .;
         break;
       default:
         [14] = ;
         jj_consume_token(-1);
         throw new ParseException();
       }
       break;
     default:
       [15] = ;
       ;
     }
     F = literal();
                  {if (truereturn new Trigger(teOp,teType,F);}
     throw new Error("Missing return statement in function");
   }
 
 /* Plan body */
   final public PlanBody plan_body() throws ParseException {
                              Object FPlanBody R = nullboolean hasPV = falseboolean isControl = true;
     switch ((==-1)?jj_ntk():) {
     case :
       F = stmtIF();
       break;
     case :
       F = stmtFOR();
       break;
     case :
       F = stmtWHILE();
       break;
     case :
     case :
     case :
     case :
     case :
     case :
     case :
     case :
     case :
     case :
     case :
     case 34:
     case 37:
     case 38:
     case 40:
     case 42:
     case 44:
       F = body_formula();
                              isControl = falseif (!(F instanceof PlanBody)) {if (truethrow new ParseException(getSourceRef(F)+" "+F+" is not a body literal!");}
       break;
     default:
       [16] = ;
       jj_consume_token(-1);
       throw new ParseException();
     }
     switch ((==-1)?jj_ntk():) {
     case 41:
       jj_consume_token(41);
                              hasPV = true;
       break;
     default:
       [17] = ;
       ;
     }
     switch ((==-1)?jj_ntk():) {
     case :
     case :
     case :
     case :
     case :
     case :
     case :
     case :
     case :
     case :
     case :
     case :
     case :
     case :
     case 34:
     case 37:
     case 38:
     case 40:
     case 42:
     case 44:
       R = plan_body();
       break;
     default:
       [18] = ;
       ;
     }
                              if (R != null) {
                                 if (!isControl && !hasPV) {
                                      {if (truethrow new ParseException(getSourceRef(F)+" Expected ';' after '"+F+"'.");}
                                 }
                                 ((PlanBody)F).setBodyNextR );
                              }
 
                              {if (truereturn (PlanBody)F;}
     throw new Error("Missing return statement in function");
   }
 
   final public PlanBody stmtIF() throws ParseException {
                          Object BTerm T1Term T2 = nullLiteral stmtLiteralboolean useElse = false;
     jj_consume_token(42);
     B = log_expr();
     jj_consume_token(43);
     T1 = plan_term();
     switch ((==-1)?jj_ntk():) {
     case :
     case 30:
       switch ((==-1)?jj_ntk():) {
       case :
         jj_consume_token();
                          useElse = true;
         break;
       default:
         [19] = ;
         ;
       }
       T2 = plan_term();
       break;
     default:
       [20] = ;
       ;
     }
                          try {
                             if (T2 == null) {
                                 stmtLiteral = new InternalActionLiteral(ASSyntax.createStructure(".if_then_else", (Term)BT1), );
                                 stmtLiteral.setSrcInfo( ((Term)B).getSrcInfo() );
                             } else {
                                 stmtLiteral = new InternalActionLiteral(ASSyntax.createStructure(".if_then_else", (Term)BT1T2), );
                                 stmtLiteral.setSrcInfo( ((Term)B).getSrcInfo() );
                                 if (! useElse) {
                                    .warning(getSourceRef(stmtLiteral)+" warning: use keyword 'else' before the else part of if.");
                                 }
                             }
                             {if (truereturn new PlanBodyImpl(.stmtLiteral);}
                          } catch (Exception e) {
                             e.printStackTrace();
                          }
     throw new Error("Missing return statement in function");
   }
 
   final public PlanBody stmtFOR() throws ParseException {
                          Object BTerm T1Literal stmtLiteral;
     jj_consume_token(42);
     B = log_expr();
     jj_consume_token(43);
     T1 = plan_term();
                          try {
                             stmtLiteral = new InternalActionLiteral(ASSyntax.createStructure(".foreach", (Term)BT1), );
                             stmtLiteral.setSrcInfo( ((Term)B).getSrcInfo() );
                             {if (truereturn new PlanBodyImpl(.stmtLiteral);}
                          } catch (Exception e) {
                             e.printStackTrace();
                          }
     throw new Error("Missing return statement in function");
   }
 
   final public PlanBody stmtWHILE() throws ParseException {
                          Object BTerm T1Literal stmtLiteral;
     jj_consume_token(42);
     B = log_expr();
     jj_consume_token(43);
     T1 = plan_term();
                          try {
                             stmtLiteral = new InternalActionLiteral(ASSyntax.createStructure(".loop", (Term)BT1), );
                             stmtLiteral.setSrcInfo( ((Term)B).getSrcInfo() );
                             {if (truereturn new PlanBodyImpl(.stmtLiteral);}
                          } catch (Exception e) {
                             e.printStackTrace();
                          }
     throw new Error("Missing return statement in function");
   }
 
   final public Object body_formula() throws ParseException {
                          BodyType formType = .;  Object B;
     switch ((==-1)?jj_ntk():) {
     case 34:
     case 37:
     case 38:
     case 40:
     case 44:
       switch ((==-1)?jj_ntk():) {
       case 34:
         jj_consume_token(34);
                          formType = .;
         break;
       case 44:
         jj_consume_token(44);
                          formType = .;
         break;
       case 40:
         jj_consume_token(40);
                          formType = .;
         break;
       case 37:
         jj_consume_token(37);
                          formType = .;
         switch ((==-1)?jj_ntk():) {
         case 37:
         case 45:
         case 46:
           switch ((==-1)?jj_ntk():) {
           case 37:
             jj_consume_token(37);
                          formType = .;
             break;
           case 45:
             jj_consume_token(45);
                          formType = .;
             break;
           case 46:
             jj_consume_token(46);
                          formType = .;
             break;
           default:
             [21] = ;
             jj_consume_token(-1);
             throw new ParseException();
           }
           break;
         default:
           [22] = ;
           ;
         }
         break;
       case 38:
         jj_consume_token(38);
                          formType = .;
         switch ((==-1)?jj_ntk():) {
         case 37:
           jj_consume_token(37);
                          formType = .;
           break;
         default:
           [23] = ;
           ;
         }
         break;
       default:
         [24] = ;
         jj_consume_token(-1);
         throw new ParseException();
       }
       break;
     default:
       [25] = ;
       ;
     }
     B = log_expr();
                          if (formType == . && B instanceof RelExpr) {
                             {if (truereturn new PlanBodyImpl(., (RelExpr)B);} // constraint
                          } else if (B instanceof Literal) {
                             if ( ((Literal)B).isInternalAction() )
                                formType = .;
                             {if (truereturn new PlanBodyImpl(formType, (Literal)B);}
                          } else {
                                 if (formType == .) {
                                    if (B instanceof LogicalFormula)
                                       {if (truereturn new PlanBodyImpl(., (Term)B);}  // used in ?(a & b)
                                    else
                                       {if (truethrow new ParseException(getSourceRef(B)+" The argument for ? is not a logical formula.");}
                                 } else {
                                {if (truereturn B;}
                                 }
                          }
     throw new Error("Missing return statement in function");
   }
 
   final public Term plan_term() throws ParseException {
                                Trigger T = nullObject C = nullPlanBody B = nullB1 = nullPlan P = nullboolean pb = truePred L = null;
     jj_consume_token(30);
     if (jj_2_2(4)) {
       switch ((==-1)?jj_ntk():) {
       case :
         jj_consume_token();
         L = pred();
                               pb = false;
         break;
       default:
         [26] = ;
         ;
       }
       T = trigger();
                               if (T.getType() != .pb = false;
       switch ((==-1)?jj_ntk():) {
       case 35:
         jj_consume_token(35);
         C = log_expr();
                               pb = false;
         break;
       default:
         [27] = ;
         ;
       }
       switch ((==-1)?jj_ntk():) {
       case 36:
       case 41:
         switch ((==-1)?jj_ntk():) {
         case 36:
           jj_consume_token(36);
                               pb = false;
           break;
         case 41:
           jj_consume_token(41);
                               if (!pb) {if (truethrow new ParseException(getSourceRef(T)+" Wrong place for ';'");}
           break;
         default:
           [28] = ;
           jj_consume_token(-1);
           throw new ParseException();
         }
         break;
       default:
         [29] = ;
         ;
       }
     } else {
       ;
     }
     switch ((==-1)?jj_ntk():) {
     case :
     case :
     case :
     case :
     case :
     case :
     case :
     case :
     case :
     case :
     case :
     case :
     case :
     case :
     case 34:
     case 37:
     case 38:
     case 40:
     case 42:
     case 44:
       B = plan_body();
       break;
     default:
       [30] = ;
       ;
     }
     jj_consume_token(31);
                              if (T != null) {
                                 // handle the case of "+a1", parsed as TE, need to be changed to plan's body
                                 // handle the case of "+a1; +a2", parsed as "TE; Body"
                                 if (pb && L == null) {
                                   if (T.isAddition())
                                      B1 = new PlanBodyImpl(.T.getLiteral(), true);
                                   else
                                      B1 = new PlanBodyImpl(.T.getLiteral(), true);
                                   if (B != null)
                                      B1.setBodyNext(B);
                                   {if (truereturn B1;}
                                 }
                                 if (C == null && B == null && L == null) {
                                     // handle the case of a single trigger
                                     T.setAsTriggerTerm(true);
                                     {if (truereturn T;}
                                 } else {
                                     // handle the case of a entire plan
                                     Plan p = new Plan(L,T,(LogicalFormula)CB);
                                     p.setSrcInfo(T.getSrcInfo());
                                     p.setAsPlanTerm(true);
                                     {if (truereturn p;}
                                 }
                              }
 
                              // the case of a simple plan body term
                              if (B == null)
                                 B = new PlanBodyImpl();
                              B.setAsBodyTerm(true);
 
                              {if (truereturn B;}
     throw new Error("Missing return statement in function");
   }
 
 /* Literal */
   final public Literal literal() throws ParseException {
                                 Pred FToken kboolean type = .;
     switch ((==-1)?jj_ntk():) {
     case :
     case :
     case :
     case :
     case :
     case :
       switch ((==-1)?jj_ntk():) {
       case :
         jj_consume_token();
                                 type = .;
         break;
       default:
         [31] = ;
         ;
       }
       switch ((==-1)?jj_ntk():) {
       case :
       case :
       case :
         F = pred();
                                 if (F.getFunctor().indexOf(".") >= 0) {
                                    if (F.hasAnnot())
                                       {if (truethrow new ParseException(getSourceRef(F)+" Internal actions cannot have annotations.");}
                                    if (type == .)
                                       {if (truethrow new ParseException(getSourceRef(F)+" Internal actions cannot be negated.");}
                                                                    try {
                                                                       {if (truereturn new InternalActionLiteral(F);}
                                    } catch (Exception e) {
                                       if (getArithFunction(F) == null// it is not a registered function
                                          .warning(getSourceRef(F)+" warning: The internal action class for '"+F+"' was not loaded! Error: "+e);
                                    }
                                 }
                                 {if (truereturn new LiteralImpl(type,F);}
         break;
       case :
       case :
         F = var();
                                 VarTerm vt = (VarTerm)F;
                                 vt.setNegated(type);
                                 {if (truereturn vt;}
         break;
       default:
         [32] = ;
         jj_consume_token(-1);
         throw new ParseException();
       }
       break;
     case :
       k = jj_consume_token();
                                 {if (truereturn .;}
       break;
     case :
       k = jj_consume_token();
                                 {if (truereturn .;}
       break;
     default:
       [33] = ;
       jj_consume_token(-1);
       throw new ParseException();
     }
     throw new Error("Missing return statement in function");
   }
 
 /* Annotated Formulae */
   final public Pred pred() throws ParseException {
                         Token KPred pList lListTerm ltTerm b;
     switch ((==-1)?jj_ntk():) {
     case :
       K = jj_consume_token();
       break;
     case :
       K = jj_consume_token();
       break;
     case :
       K = jj_consume_token();
       break;
     default:
       [34] = ;
       jj_consume_token(-1);
       throw new ParseException();
     }
                          p = new Pred(K.image);
                          p.setSrcInfo(new SourceInfo(K.beginLine));
     switch ((==-1)?jj_ntk():) {
     case 42:
       jj_consume_token(42);
       l = terms();
       jj_consume_token(43);
                          p.setTerms(l);
       break;
     default:
       [35] = ;
       ;
     }
     label_9:
     while (true) {
       switch ((==-1)?jj_ntk():) {
       case 30:
         ;
         break;
       default:
         [36] = ;
         break label_9;
       }
       b = plan_term();
                          p.addTerm(b);
     }
     switch ((==-1)?jj_ntk():) {
     case 48:
       lt = list();
                          p.setAnnots(lt);
       break;
     default:
       [37] = ;
       ;
     }
                          {if (truereturn p;}
     throw new Error("Missing return statement in function");
   }
 
 /* List of terms */
   final public List terms() throws ParseException {
                     ArrayList listTerms = new ArrayList(); Term vPlanBody o;
     v = term();
                          listTerms.add(v);
     label_10:
     while (true) {
       switch ((==-1)?jj_ntk():) {
       case 47:
         ;
         break;
       default:
         [38] = ;
         break label_10;
       }
       jj_consume_token(47);
       v = term();
                          listTerms.add(v);
     }
                          listTerms.trimToSize();
                          {if (truereturn listTerms;}
     throw new Error("Missing return statement in function");
   }
 
   final public Term term() throws ParseException {
                          Object o;
     switch ((==-1)?jj_ntk():) {
     case 48:
       o = list();
       break;
     case 30:
       o = plan_term();
       break;
     case :
     case :
     case :
     case :
     case :
     case :
     case :
     case :
     case :
     case :
     case :
     case 37:
     case 38:
     case 42:
       o = log_expr();
       break;
     default:
       [39] = ;
       jj_consume_token(-1);
       throw new ParseException();
     }
                          {if (truereturn changeToAtom(o);}
     throw new Error("Missing return statement in function");
   }
 
   final public ListTermImpl list() throws ParseException {
                             ListTermImpl lt = new ListTermImpl(); ListTerm lastToken KTerm f;
     jj_consume_token(48);
     switch ((==-1)?jj_ntk():) {
     case :
     case :
     case :
     case :
    case :
    case :
    case :
    case :
    case :
    case :
    case 30:
    case 37:
    case 38:
    case 42:
    case 48:
      f = term_in_list();
                            last = lt.append(f); lt.setSrcInfo(f.getSrcInfo());
      label_11:
      while (true) {
        switch ((==-1)?jj_ntk():) {
        case 47:
          ;
          break;
        default:
          [40] = ;
          break label_11;
        }
        jj_consume_token(47);
        f = term_in_list();
                            last = last.append(f);
      }
      switch ((==-1)?jj_ntk():) {
      case 49:
        jj_consume_token(49);
        switch ((==-1)?jj_ntk():) {
        case :
          K = jj_consume_token();
                            last.setNext(new VarTerm(K.image));
          break;
        case :
          K = jj_consume_token();
                            last.setNext(UnnamedVar.create(K.image));
          break;
        case 48:
          f = list();
                            last = last.concat((ListTerm)f);
          break;
        default:
          [41] = ;
          jj_consume_token(-1);
          throw new ParseException();
        }
        break;
      default:
        [42] = ;
        ;
      }
      break;
    default:
      [43] = ;
      ;
    }
                            {if (truereturn lt;}
    throw new Error("Missing return statement in function");
  }
// term_in_list is the same as term, but log_expr/plan_body must be enclosed by "("....")" to avoid problem with |
  final public Term term_in_list() throws ParseException {
                            Object o;
    switch ((==-1)?jj_ntk():) {
    case 48:
      o = list();
      break;
    case :
    case :
    case :
    case :
    case :
    case :