Package com.hp.jena.ymris.grammar

Source Code of com.hp.jena.ymris.grammar.Ymris

/* Generated By:JavaCC: Do not edit this line. Ymris.java */
/*
    (c) Copyright 2008 Hewlett-Packard Development Company, LP
    All rights reserved.
*/
package com.hp.jena.ymris.grammar;

import java.util.*;
import java.io.*;
import com.hp.jena.ymris.util.Pair;
import com.hp.jena.ymris.yast.*;
import com.hp.jena.ymris.yast.YAST.RawTerms;
import com.hp.jena.ymris.yast.expr.*;

import run.acceptance.gui.GUIMaster;

@SuppressWarnings("all")
public class Ymris implements YmrisConstants {
    static int count = 0;

    public static void main( String [] args )
        {
        GUIMaster.Convert runParser = new GUIMaster.Convert()
            {
            public String convert( String source )
                {
                try
                    {
                    Ymris y = new Ymris( new StringReader( source ) );
                    YAST yast = y.ymris();
                    return
                        "<html>"
                        + "\u005cn<head>"
                        + "\u005cn<title>OK</title>"
                        // + "\n" + NetToHTML.styles()
                        + "</head>"
                        + "\u005cn<body>"
                        + "OK.\u005cn"
                        + "<pre>" + yast.prettyString() + "</pre>"
                        // + "<pre>" + translate( yast ) + "</pre>"
                        + "</body>"
                        + "</head>"
                        ;
                    }
                catch (TokenMgrError e)
                    { return oops( source, e ); }
                catch (Exception e)
                    { return oops( source, e ); }
                }

            String oops( String source, Throwable e )
                {
                return
                    "<html>"
                    + "\u005cn<head>"
                    + "\u005cn<title>titular</title>"
                    // + "\n" + NetToHTML.styles()
                    + "\u005cn</head>"
                    + "\u005cn<body>"
                    + "\u005cnOOPS: we had an exception while parsing, viz:"
                    + "\u005cn" + "<pre>" + e + stackTrace( e ) + "</pre>"
                    + "\u005cnthe source code was:"
                    + "\u005cn" + "<pre>" + source + "</pre>"
                    + "\u005cn</body>"
                    + "\u005cn</html>"
                    ;
                }

            String stackTrace( Throwable e )
                {
                ByteArrayOutputStream out = new ByteArrayOutputStream();
                PrintStream pout = new PrintStream( out );
                e.printStackTrace( pout );
                pout.flush();
                return out.toString();
                }
            };
        new GUIMaster( "RULES", runParser );
        }

  final public YAST ymris() throws ParseException {
                 List<RuleSet> ruleSets = new ArrayList<RuleSet>();
    rulesets(ruleSets);
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    case APPLICATION:
      application();
      rulesets(ruleSets);
      break;
    default:
      jj_la1[0] = jj_gen;
      ;
    }
    jj_consume_token(0);
      {if (true) return new YAST( ruleSets );}
    throw new Error("Missing return statement in function");
  }

  final public void application() throws ParseException {
    jj_consume_token(APPLICATION);
    naming();
    prolog();
    datasets();
    run();
  }

  final public void datasets() throws ParseException {
    label_1:
    while (true) {
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case FROM:
        ;
        break;
      default:
        jj_la1[1] = jj_gen;
        break label_1;
      }
      jj_consume_token(FROM);
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case NAMED:
        jj_consume_token(NAMED);
        break;
      default:
        jj_la1[2] = jj_gen;
        ;
      }
      iriExpr();
    }
  }

  final public void run() throws ParseException {
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    case RUN:
      jj_consume_token(RUN);
      runExpression();
      break;
    default:
      jj_la1[3] = jj_gen;
      ;
    }
  }

  final public void runExpression() throws ParseException {
    parallel();
  }

  final public void parallel() throws ParseException {
    runSeq();
    label_2:
    while (true) {
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case PAR:
        ;
        break;
      default:
        jj_la1[4] = jj_gen;
        break label_2;
      }
      jj_consume_token(PAR);
      runSeq();
    }
  }

  final public void runSeq() throws ParseException {
    runSoup();
    label_3:
    while (true) {
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case SEMICOLON:
        ;
        break;
      default:
        jj_la1[5] = jj_gen;
        break label_3;
      }
      jj_consume_token(SEMICOLON);
      runSoup();
    }
  }

  final public void runSoup() throws ParseException {
    processDesignator();
    label_4:
    while (true) {
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case COMMA:
        ;
        break;
      default:
        jj_la1[6] = jj_gen;
        break label_4;
      }
      jj_consume_token(COMMA);
      processDesignator();
    }
  }

  final public void processDesignator() throws ParseException {
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    case Q_IRIref:
    case QNAME_NS:
    case QNAME_LN:
    case NAME:
      iriExpr();
      break;
    case LPAREN:
      jj_consume_token(LPAREN);
      runExpression();
      jj_consume_token(RPAREN);
      break;
    default:
      jj_la1[7] = jj_gen;
      jj_consume_token(-1);
      throw new ParseException();
    }
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    case STAR:
      jj_consume_token(STAR);
      break;
    default:
      jj_la1[8] = jj_gen;
      ;
    }
  }

  final public YNode iriExpr() throws ParseException {
                    YNode it; Token t;
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    case Q_IRIref:
    case QNAME_NS:
    case QNAME_LN:
      it = anyIRIReference();
                             {if (true) return it;}
      break;
    case NAME:
      t = jj_consume_token(NAME);
                   {if (true) return YAST.nodeName( t );}
      break;
    default:
      jj_la1[9] = jj_gen;
      jj_consume_token(-1);
      throw new ParseException();
    }
    throw new Error("Missing return statement in function");
  }

  final public void rulesets(List<RuleSet> ruleSets) throws ParseException {
                                            RuleSet rs;
    implicitRuleset(ruleSets);
    label_5:
    while (true) {
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case RULESET:
        ;
        break;
      default:
        jj_la1[10] = jj_gen;
        break label_5;
      }
      rs = explicitRuleset();
                              ruleSets.add( rs );
    }
  }

  final public void implicitRuleset(List<RuleSet> ruleSets) throws ParseException {
                                                   List<Rule> rules;
    rules = rules();
      if (!rules.isEmpty()) ruleSets.add( YAST.ruleSet( rules ) );
  }

  final public RuleSet explicitRuleset() throws ParseException {
                              List<Rule> rules; Prolog p;
    jj_consume_token(RULESET);
    naming();
    p = prolog();
    rules = rules();
      {if (true) return YAST.ruleSet( p, rules );}
    throw new Error("Missing return statement in function");
  }

  final public List<Rule> rules() throws ParseException {
                       Rule r; List<Rule> result = new ArrayList<Rule>();
    label_6:
    while (true) {
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case RULE:
        ;
        break;
      default:
        jj_la1[11] = jj_gen;
        break label_6;
      }
      r = rule();
                  result.add( r );
    }
      {if (true) return result;}
    throw new Error("Missing return statement in function");
  }

  final public Rule rule() throws ParseException {
                MetaData md; RuleBody rb; Prolog p;
    jj_consume_token(RULE);
    md = naming();
    p = prolog();
    rb = ruleBody();
      {if (true) return YAST.rule( md, p, rb );}
    throw new Error("Missing return statement in function");
  }

  final public RuleBody ruleBody() throws ParseException {
                        RuleBody rb;
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    case CONSTRUCT:
      rb = sparqlConstructQuery();
      break;
    case ARROW:
    case LBRACE:
      rb = premisesImplyConclusion();
      break;
    default:
      jj_la1[12] = jj_gen;
      jj_consume_token(-1);
      throw new ParseException();
    }
      {if (true) return rb;}
    throw new Error("Missing return statement in function");
  }

  final public RuleBody premisesImplyConclusion() throws ParseException {
      RawTerms P = new RawTerms()
    ; RawTerms C = new RawTerms()
    ;
    premises(P);
    jj_consume_token(ARROW);
    conclusions(C);
      {if (true) return YAST.ruleBody( P.cook(), C.cook() );}
    throw new Error("Missing return statement in function");
  }

  final public RuleBody sparqlConstructQuery() throws ParseException {
      RawTerms P = new RawTerms()
    ; RawTerms C = new RawTerms()
    ;
    jj_consume_token(CONSTRUCT);
    conclusions(C);
    jj_consume_token(WHERE);
    premises(P);
      {if (true) return YAST.ruleBody( P.cook(), C.cook() );}
    throw new Error("Missing return statement in function");
  }

  final public void premises(RawTerms raw) throws ParseException {
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    case LBRACE:
      bracedTriplePatterns(raw);
      break;
    default:
      jj_la1[13] = jj_gen;
      ;
    }
  }

  final public void conclusions(RawTerms raw) throws ParseException {
    actions(raw);
    bracedTriplePatterns(raw);
  }

  final public void actions(RawTerms raw) throws ParseException {
    label_7:
    while (true) {
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case DO:
      case LET:
        ;
        break;
      default:
        jj_la1[14] = jj_gen;
        break label_7;
      }
      action(raw);
    }
  }

  final public void action(RawTerms raw) throws ParseException {
                                Token t; Expr e; List<Expr> el;
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    case DO:
      jj_consume_token(DO);
      el = expressionList();
          raw.addActions( el );
      break;
    case LET:
      jj_consume_token(LET);
      t = jj_consume_token(VAR);
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case EQ:
        jj_consume_token(EQ);
        break;
      case BECOMES:
        jj_consume_token(BECOMES);
        break;
      default:
        jj_la1[15] = jj_gen;
        jj_consume_token(-1);
        throw new ParseException();
      }
      e = expression();
          raw.addAction( YAST.let( t, e ) );
      break;
    default:
      jj_la1[16] = jj_gen;
      jj_consume_token(-1);
      throw new ParseException();
    }
  }

  final public void bracedTriplePatterns(RawTerms raw) throws ParseException {
    jj_consume_token(LBRACE);
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    case Q_IRIref:
    case QNAME_NS:
    case QNAME_LN:
    case BLANK_NODE_LABEL:
    case VAR:
    case DOLLAR:
    case ALL:
    case LET:
    case UNLESS:
    case FILTER:
    case LPAREN:
    case NIL:
    case LBRACKET:
    case ANON:
      constructTriples(raw);
      break;
    default:
      jj_la1[17] = jj_gen;
      ;
    }
    jj_consume_token(RBRACE);
  }

  final public void constructTriples(RawTerms raw) throws ParseException {
    label_8:
    while (true) {
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case FILTER:
        ;
        break;
      default:
        jj_la1[18] = jj_gen;
        break label_8;
      }
      filter(raw);
    }
    label_9:
    while (true) {
      triplesSameSubject(raw);
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case DOT:
        jj_consume_token(DOT);
        break;
      default:
        jj_la1[19] = jj_gen;
        ;
      }
      label_10:
      while (true) {
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case FILTER:
          ;
          break;
        default:
          jj_la1[20] = jj_gen;
          break label_10;
        }
        filter(raw);
      }
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case Q_IRIref:
      case QNAME_NS:
      case QNAME_LN:
      case BLANK_NODE_LABEL:
      case VAR:
      case DOLLAR:
      case ALL:
      case LET:
      case UNLESS:
      case LPAREN:
      case NIL:
      case LBRACKET:
      case ANON:
        ;
        break;
      default:
        jj_la1[21] = jj_gen;
        break label_9;
      }
    }
  }

  final public void filter(RawTerms raw) throws ParseException {
                                Expr e;
    jj_consume_token(FILTER);
    e = expression();
                                raw.addFilter( e );
  }

  final public Expr expression() throws ParseException {
                      Expr e;
    e = orExpression();
                         {if (true) return e;}
    throw new Error("Missing return statement in function");
  }

  final public Expr orExpression() throws ParseException {
                        Expr e, other;
    e = andExpression();
    label_11:
    while (true) {
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case SC_OR:
        ;
        break;
      default:
        jj_la1[22] = jj_gen;
        break label_11;
      }
      jj_consume_token(SC_OR);
      other = andExpression();
                                       e = YAST.or( e, other );
    }
      {if (true) return e;}
    throw new Error("Missing return statement in function");
  }

  final public Expr andExpression() throws ParseException {
                         Expr e, other;
    e = relExpression();
    label_12:
    while (true) {
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case SC_AND:
        ;
        break;
      default:
        jj_la1[23] = jj_gen;
        break label_12;
      }
      jj_consume_token(SC_AND);
      other = relExpression();
                                        e = YAST.and( e, other );
    }
      {if (true) return e;}
    throw new Error("Missing return statement in function");
  }

  final public Expr relExpression() throws ParseException {
                         Expr e, other; Token op;
    e = addExpression();
    label_13:
    while (true) {
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case EQ:
      case NE:
      case GT:
      case LT:
      case LE:
      case GE:
        ;
        break;
      default:
        jj_la1[24] = jj_gen;
        break label_13;
      }
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case EQ:
        op = jj_consume_token(EQ);
        break;
      case NE:
        op = jj_consume_token(NE);
        break;
      case LT:
        op = jj_consume_token(LT);
        break;
      case GT:
        op = jj_consume_token(GT);
        break;
      case LE:
        op = jj_consume_token(LE);
        break;
      case GE:
        op = jj_consume_token(GE);
        break;
      default:
        jj_la1[25] = jj_gen;
        jj_consume_token(-1);
        throw new ParseException();
      }
      other = addExpression();
          e = YAST.relation( e, op.image, other );
    }
      {if (true) return e;}
    throw new Error("Missing return statement in function");
  }

  final public Expr addExpression() throws ParseException {
                         Expr e, other; Token op;
    e = mulExpression();
    label_14:
    while (true) {
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case PLUS:
      case MINUS:
        ;
        break;
      default:
        jj_la1[26] = jj_gen;
        break label_14;
      }
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case PLUS:
        op = jj_consume_token(PLUS);
        break;
      case MINUS:
        op = jj_consume_token(MINUS);
        break;
      default:
        jj_la1[27] = jj_gen;
        jj_consume_token(-1);
        throw new ParseException();
      }
      other = mulExpression();
          e = YAST.infix( e, op.image, other );
    }
      {if (true) return e;}
    throw new Error("Missing return statement in function");
  }

  final public Expr mulExpression() throws ParseException {
                         Expr e, other; Token op;
    e = unary();
    label_15:
    while (true) {
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case STAR:
      case SLASH:
        ;
        break;
      default:
        jj_la1[28] = jj_gen;
        break label_15;
      }
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case STAR:
        op = jj_consume_token(STAR);
        break;
      case SLASH:
        op = jj_consume_token(SLASH);
        break;
      default:
        jj_la1[29] = jj_gen;
        jj_consume_token(-1);
        throw new ParseException();
      }
      other = unary();
          e = YAST.infix( e, op.image, other );
    }
      {if (true) return e;}
    throw new Error("Missing return statement in function");
  }

  final public Expr unary() throws ParseException {
                 Expr e; Token op;
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    case BANG:
    case PLUS:
    case MINUS:
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case BANG:
        op = jj_consume_token(BANG);
        break;
      case PLUS:
        op = jj_consume_token(PLUS);
        break;
      case MINUS:
        op = jj_consume_token(MINUS);
        break;
      default:
        jj_la1[30] = jj_gen;
        jj_consume_token(-1);
        throw new ParseException();
      }
      e = primary();
          {if (true) return YAST.unary( op.image, e );}
      break;
    case Q_IRIref:
    case QNAME_NS:
    case QNAME_LN:
    case VAR:
    case DOLLAR:
    case CALLING:
    case TRUE:
    case FALSE:
    case INTEGER:
    case DECIMAL:
    case DOUBLE:
    case STRING_LITERAL1:
    case STRING_LITERAL2:
    case STRING_LITERAL_LONG1:
    case STRING_LITERAL_LONG2:
    case LPAREN:
    case NIL:
      e = primary();
          {if (true) return e;}
      break;
    default:
      jj_la1[31] = jj_gen;
      jj_consume_token(-1);
      throw new ParseException();
    }
    throw new Error("Missing return statement in function");
  }

  final public Expr primary() throws ParseException {
                   YNode n; Expr e;
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    case Q_IRIref:
    case QNAME_NS:
    case QNAME_LN:
    case VAR:
    case DOLLAR:
    case TRUE:
    case FALSE:
    case INTEGER:
    case DECIMAL:
    case DOUBLE:
    case STRING_LITERAL1:
    case STRING_LITERAL2:
    case STRING_LITERAL_LONG1:
    case STRING_LITERAL_LONG2:
    case NIL:
      n = itemForPrimary();
                             {if (true) return YAST.primitive( n );}
      break;
    case CALLING:
      e = functionCall();
                           {if (true) return e;}
      break;
    case LPAREN:
      jj_consume_token(LPAREN);
      e = expression();
      jj_consume_token(RPAREN);
                                           {if (true) return e;}
      break;
    default:
      jj_la1[32] = jj_gen;
      jj_consume_token(-1);
      throw new ParseException();
    }
    throw new Error("Missing return statement in function");
  }

  final public Expr functionCall() throws ParseException {
                        Token t; List<Expr> a;
    t = jj_consume_token(CALLING);
    a = argList();
      {if (true) return YAST.apply( t.image, a );}
    throw new Error("Missing return statement in function");
  }

  final public List<Expr> argList() throws ParseException {
                         List<Expr> result;
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    case NIL:
      jj_consume_token(NIL);
          result = new ArrayList<Expr>();
      break;
    case LPAREN:
      jj_consume_token(LPAREN);
      result = expressionList();
      jj_consume_token(RPAREN);
      break;
    default:
      jj_la1[33] = jj_gen;
      jj_consume_token(-1);
      throw new ParseException();
    }
      {if (true) return result;}
    throw new Error("Missing return statement in function");
  }

  final public List<Expr> expressionList() throws ParseException {
        List<Expr> result = new ArrayList<Expr>(); Expr e;
    e = expression();
                       result.add( e );
    label_16:
    while (true) {
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case COMMA:
        ;
        break;
      default:
        jj_la1[34] = jj_gen;
        break label_16;
      }
      jj_consume_token(COMMA);
      e = expression();
                                result.add( e );
    }
      {if (true) return result;}
    throw new Error("Missing return statement in function");
  }

  final public void triplesSameSubject(RawTerms raw) throws ParseException {
                                            YNode S; Token tok;
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    case Q_IRIref:
    case QNAME_NS:
    case QNAME_LN:
    case BLANK_NODE_LABEL:
    case VAR:
    case DOLLAR:
    case LPAREN:
    case NIL:
    case LBRACKET:
    case ANON:
      S = subject(raw);
      propertyList(S, raw);
      break;
    case ALL:
          RawTerms allPremises = new RawTerms();
          RawTerms allConclusions = new RawTerms();
      jj_consume_token(ALL);
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case DISTINCT:
        jj_consume_token(DISTINCT);
        break;
      default:
        jj_la1[35] = jj_gen;
        ;
      }
      tok = jj_consume_token(VAR);
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case DOT:
        jj_consume_token(DOT);
        break;
      default:
        jj_la1[36] = jj_gen;
        ;
      }
      bracedTriplePatterns(allPremises);
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case ARROW:
        jj_consume_token(ARROW);
        bracedTriplePatterns(allConclusions);
        break;
      default:
        jj_la1[37] = jj_gen;
        ;
      }
          raw.addAllTerm( tok, allPremises, allConclusions );
      break;
    case UNLESS:
      jj_consume_token(UNLESS);
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case GIVEN:
        jj_consume_token(GIVEN);
        break;
      default:
        jj_la1[38] = jj_gen;
        ;
      }
          RawTerms uRaw = new RawTerms();
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case Q_IRIref:
      case QNAME_NS:
      case QNAME_LN:
      case BLANK_NODE_LABEL:
      case VAR:
      case DOLLAR:
      case ALL:
      case LET:
      case UNLESS:
      case LPAREN:
      case NIL:
      case LBRACKET:
      case ANON:
        triplesSameSubject(uRaw);
        break;
      case LBRACE:
              List<Expr> uFilters = new ArrayList<Expr>();
        bracedTriplePatterns(uRaw);
        break;
      default:
        jj_la1[39] = jj_gen;
        jj_consume_token(-1);
        throw new ParseException();
      }
          raw.addUnless( uRaw.cook() );
      break;
    case LET:
          Expr e;
      jj_consume_token(LET);
      tok = jj_consume_token(VAR);
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case EQ:
        jj_consume_token(EQ);
        break;
      case BECOMES:
        jj_consume_token(BECOMES);
        break;
      default:
        jj_la1[40] = jj_gen;
        jj_consume_token(-1);
        throw new ParseException();
      }
      e = expression();
          raw.addLet( YAST.let( tok, e ) );
      break;
    default:
      jj_la1[41] = jj_gen;
      jj_consume_token(-1);
      throw new ParseException();
    }
  }

  final public YNode subject(RawTerms raw) throws ParseException {
                                  YNode S;
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    case Q_IRIref:
    case QNAME_NS:
    case QNAME_LN:
    case VAR:
    case DOLLAR:
    case LPAREN:
    case NIL:
      S = itemNotLiteral(raw);
      break;
    case BLANK_NODE_LABEL:
    case LBRACKET:
    case ANON:
      S = blankNode(raw);
      break;
    default:
      jj_la1[42] = jj_gen;
      jj_consume_token(-1);
      throw new ParseException();
    }
      {if (true) return S;}
    throw new Error("Missing return statement in function");
  }

  final public YNode parseList(RawTerms raw) throws ParseException {
                                    YNode it; List<YNode> elements = new ArrayList<YNode>();
    jj_consume_token(LPAREN);
    label_17:
    while (true) {
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case Q_IRIref:
      case QNAME_NS:
      case QNAME_LN:
      case BLANK_NODE_LABEL:
      case VAR:
      case DOLLAR:
      case TRUE:
      case FALSE:
      case INTEGER:
      case DECIMAL:
      case DOUBLE:
      case STRING_LITERAL1:
      case STRING_LITERAL2:
      case STRING_LITERAL_LONG1:
      case STRING_LITERAL_LONG2:
      case LPAREN:
      case NIL:
      case LBRACKET:
      case ANON:
      case PLUS:
      case MINUS:
        ;
        break;
      default:
        jj_la1[43] = jj_gen;
        break label_17;
      }
      it = item(raw);
                         elements.add( it );
    }
    jj_consume_token(RPAREN);
      {if (true) return YAST.elementsToRDFList( raw, elements );}
    throw new Error("Missing return statement in function");
  }

  final public YNode item(RawTerms raw) throws ParseException {
                               Token t; YNode n;
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    case BLANK_NODE_LABEL:
    case LBRACKET:
    case ANON:
      n = blankNode(raw);
                            {if (true) return n;}
      break;
    case Q_IRIref:
    case QNAME_NS:
    case QNAME_LN:
    case VAR:
    case DOLLAR:
    case TRUE:
    case FALSE:
    case INTEGER:
    case DECIMAL:
    case DOUBLE:
    case STRING_LITERAL1:
    case STRING_LITERAL2:
    case STRING_LITERAL_LONG1:
    case STRING_LITERAL_LONG2:
    case LPAREN:
    case NIL:
    case PLUS:
    case MINUS:
      n = itemNotBlank(raw);
                                {if (true) return n;}
      break;
    default:
      jj_la1[44] = jj_gen;
      jj_consume_token(-1);
      throw new ParseException();
    }
    throw new Error("Missing return statement in function");
  }

  final public YNode itemNotBlank(RawTerms raw) throws ParseException {
                                       Token t; YNode n;
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    case Q_IRIref:
    case QNAME_NS:
    case QNAME_LN:
    case VAR:
    case DOLLAR:
    case TRUE:
    case FALSE:
    case INTEGER:
    case DECIMAL:
    case DOUBLE:
    case STRING_LITERAL1:
    case STRING_LITERAL2:
    case STRING_LITERAL_LONG1:
    case STRING_LITERAL_LONG2:
    case NIL:
      n = itemForPrimary();
      break;
    case PLUS:
    case MINUS:
      n = signedNumber();
      break;
    case LPAREN:
      n = parseList(raw);
      break;
    default:
      jj_la1[45] = jj_gen;
      jj_consume_token(-1);
      throw new ParseException();
    }
      {if (true) return n;}
    throw new Error("Missing return statement in function");
  }

  final public YNode itemForPrimary() throws ParseException {
                           YNode n;
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    case Q_IRIref:
    case QNAME_NS:
    case QNAME_LN:
    case VAR:
    case DOLLAR:
    case NIL:
      n = itemNotLiteralOrList();
                                   {if (true) return n;}
      break;
    case STRING_LITERAL1:
    case STRING_LITERAL2:
    case STRING_LITERAL_LONG1:
    case STRING_LITERAL_LONG2:
      n = typedString();
                          {if (true) return n;}
      break;
    case INTEGER:
    case DECIMAL:
    case DOUBLE:
      n = unsignedNumber();
                             {if (true) return n;}
      break;
    case TRUE:
      jj_consume_token(TRUE);
               {if (true) return YAST.RDF_TRUE;}
      break;
    case FALSE:
      jj_consume_token(FALSE);
                {if (true) return YAST.RDF_FALSE;}
      break;
    default:
      jj_la1[46] = jj_gen;
      jj_consume_token(-1);
      throw new ParseException();
    }
    throw new Error("Missing return statement in function");
  }

  final public YNode itemNotLiteral(RawTerms raw) throws ParseException {
                                         Token t; YNode n;
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    case Q_IRIref:
    case QNAME_NS:
    case QNAME_LN:
    case VAR:
    case DOLLAR:
    case NIL:
      n = itemNotLiteralOrList();
                                   {if (true) return n;}
      break;
    case LPAREN:
      n = parseList(raw);
                             {if (true) return n;}
      break;
    default:
      jj_la1[47] = jj_gen;
      jj_consume_token(-1);
      throw new ParseException();
    }
    throw new Error("Missing return statement in function");
  }

  final public YNode itemNotLiteralOrList() throws ParseException {
                                 Token t; YNode n;
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    case VAR:
      t = jj_consume_token(VAR);
                 {if (true) return YAST.nodeVar( t );}
      break;
    case Q_IRIref:
    case QNAME_NS:
    case QNAME_LN:
      n = anyIRIReference();
                              {if (true) return n;}
      break;
    case NIL:
      jj_consume_token(NIL);
              {if (true) return YAST.RDF_NIL;}
      break;
    case DOLLAR:
      n = oldStyleFunctor();
                              {if (true) return n;}
      break;
    default:
      jj_la1[48] = jj_gen;
      jj_consume_token(-1);
      throw new ParseException();
    }
    throw new Error("Missing return statement in function");
  }

  final public YNode oldStyleFunctor() throws ParseException {
                            String name; List<Expr> args;
    jj_consume_token(DOLLAR);
    name = jj_consume_token(CALLING).image;
    args = argList();
      {if (true) return YAST.functor( name, args );}
    throw new Error("Missing return statement in function");
  }

  final public YNode typedString() throws ParseException {
                        Token t; String spelling; YNode type;
    spelling = string();
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    case LANGTAG:
      t = jj_consume_token(LANGTAG);
                       {if (true) return YAST.langLiteral( spelling, t );}
      break;
    case DATATYPE:
      jj_consume_token(DATATYPE);
      type = anyIRIReference();
                                            {if (true) return YAST.typedLiteral( spelling, type );}
      break;
    default:
      jj_la1[49] = jj_gen;
        {if (true) return YAST.plainLiteral( spelling );}
    }
    throw new Error("Missing return statement in function");
  }

  final public YNode unsignedNumber() throws ParseException {
                           Token spelling;
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    case INTEGER:
      spelling = jj_consume_token(INTEGER);
                            {if (true) return YAST.plainInteger( spelling );}
      break;
    case DECIMAL:
      spelling = jj_consume_token(DECIMAL);
                             {if (true) return YAST.plainDecimal( spelling );}
      break;
    case DOUBLE:
      spelling = jj_consume_token(DOUBLE);
                            {if (true) return YAST.plainDouble( spelling );}
      break;
    default:
      jj_la1[50] = jj_gen;
      jj_consume_token(-1);
      throw new ParseException();
    }
    throw new Error("Missing return statement in function");
  }

  final public YNode signedNumber() throws ParseException {
                         Token sign, spelling;
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    case MINUS:
      sign = jj_consume_token(MINUS);
      break;
    case PLUS:
      sign = jj_consume_token(PLUS);
      break;
    default:
      jj_la1[51] = jj_gen;
      jj_consume_token(-1);
      throw new ParseException();
    }
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    case INTEGER:
      spelling = jj_consume_token(INTEGER);
                            {if (true) return YAST.plainInteger( sign, spelling );}
      break;
    case DECIMAL:
      spelling = jj_consume_token(DECIMAL);
                             {if (true) return YAST.plainDecimal( sign, spelling );}
      break;
    case DOUBLE:
      spelling = jj_consume_token(DOUBLE);
                            {if (true) return YAST.plainDouble( sign, spelling );}
      break;
    default:
      jj_la1[52] = jj_gen;
      jj_consume_token(-1);
      throw new ParseException();
    }
    throw new Error("Missing return statement in function");
  }

  final public YNode blankNode(RawTerms raw) throws ParseException {
                                    YNode b = YAST.nodeAnon(); Token t;
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    case ANON:
      jj_consume_token(ANON);
          {if (true) return b;}
      break;
    case BLANK_NODE_LABEL:
      t = jj_consume_token(BLANK_NODE_LABEL);
          {if (true) return YAST.nodeBlank( t );}
      break;
    case LBRACKET:
      jj_consume_token(LBRACKET);
      propertyList(b, raw);
      jj_consume_token(RBRACKET);
          {if (true) return b;}
      break;
    default:
      jj_la1[53] = jj_gen;
      jj_consume_token(-1);
      throw new ParseException();
    }
    throw new Error("Missing return statement in function");
  }

  final public String string() throws ParseException {
                    Token t;
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    case STRING_LITERAL1:
      t = jj_consume_token(STRING_LITERAL1);
                                      {if (true) return YAST.unQuote( t, 1 );}
      break;
    case STRING_LITERAL2:
      t = jj_consume_token(STRING_LITERAL2);
                                      {if (true) return YAST.unQuote( t, 1 );}
      break;
    case STRING_LITERAL_LONG1:
      t = jj_consume_token(STRING_LITERAL_LONG1);
                                      {if (true) return YAST.unQuote( t, 3 );}
      break;
    case STRING_LITERAL_LONG2:
      t = jj_consume_token(STRING_LITERAL_LONG2);
                                      {if (true) return YAST.unQuote( t, 3 );}
      break;
    default:
      jj_la1[54] = jj_gen;
      jj_consume_token(-1);
      throw new ParseException();
    }
    throw new Error("Missing return statement in function");
  }

  final public void optionalPropertyList(YNode S, RawTerms raw) throws ParseException {
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    case Q_IRIref:
    case QNAME_NS:
    case QNAME_LN:
    case VAR:
    case KW_A:
      propertyList(S, raw);
      break;
    default:
      jj_la1[55] = jj_gen;
      ;
    }
  }

  final public void propertyList(YNode S, RawTerms raw) throws ParseException {
                                               YNode P;
    P = verb();
    objectList(S, P, raw);
    propertyListTail(S, raw);
  }

  final public void propertyListTail(YNode S, RawTerms raw) throws ParseException {
                                                   YNode P;
    label_18:
    while (true) {
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case SEMICOLON:
        ;
        break;
      default:
        jj_la1[56] = jj_gen;
        break label_18;
      }
      jj_consume_token(SEMICOLON);
      P = verb();
      objectList(S, P, raw);
    }
  }

  final public YNode verb() throws ParseException {
                 YNode P; Token t;
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    case KW_A:
      jj_consume_token(KW_A);
             {if (true) return YAST.RDF_TYPE;}
      break;
    case VAR:
      t = jj_consume_token(VAR);
                  {if (true) return YAST.nodeVar( t );}
      break;
    case Q_IRIref:
    case QNAME_NS:
    case QNAME_LN:
      P = anyIRIReference();
                              {if (true) return P;}
      break;
    default:
      jj_la1[57] = jj_gen;
      jj_consume_token(-1);
      throw new ParseException();
    }
    throw new Error("Missing return statement in function");
  }

  final public YNode anyIRIReference() throws ParseException {
                            Token t;
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    case QNAME_LN:
      t = jj_consume_token(QNAME_LN);
                     {if (true) return YAST.nodeQName( t );}
      break;
    case QNAME_NS:
      t = jj_consume_token(QNAME_NS);
                       {if (true) return YAST.nodeNs( t );}
      break;
    case Q_IRIref:
      t = jj_consume_token(Q_IRIref);
                       {if (true) return YAST.nodeIRI( t );}
      break;
    default:
      jj_la1[58] = jj_gen;
      jj_consume_token(-1);
      throw new ParseException();
    }
    throw new Error("Missing return statement in function");
  }

  final public void objectList(YNode S, YNode P, RawTerms raw) throws ParseException {
                                                      YNode O;
    O = itemOrExpr(raw);
                            raw.addTriple( YAST.triple( S, P, O ) );
    label_19:
    while (true) {
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case COMMA:
        ;
        break;
      default:
        jj_la1[59] = jj_gen;
        break label_19;
      }
      jj_consume_token(COMMA);
      O = item(raw);
                               raw.addTriple( YAST.triple( S, P, O ) );
    }
  }

  final public YNode itemOrExpr(RawTerms raw) throws ParseException {
                                     YNode O; Expr e;
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    case Q_IRIref:
    case QNAME_NS:
    case QNAME_LN:
    case BLANK_NODE_LABEL:
    case VAR:
    case DOLLAR:
    case TRUE:
    case FALSE:
    case INTEGER:
    case DECIMAL:
    case DOUBLE:
    case STRING_LITERAL1:
    case STRING_LITERAL2:
    case STRING_LITERAL_LONG1:
    case STRING_LITERAL_LONG2:
    case LPAREN:
    case NIL:
    case LBRACKET:
    case ANON:
    case PLUS:
    case MINUS:
      O = item(raw);
          {if (true) return O;}
      break;
    case CALLING:
      e = functionCall();
          {if (true) return YAST.exprAsNode( e );}
      break;
    default:
      jj_la1[60] = jj_gen;
      jj_consume_token(-1);
      throw new ParseException();
    }
    throw new Error("Missing return statement in function");
  }

  final public MetaData naming() throws ParseException {
                      YNode S; RawTerms raw = new RawTerms();
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    case Q_IRIref:
    case QNAME_NS:
    case QNAME_LN:
    case NAME:
      S = iriExpr();
      break;
    default:
      jj_la1[61] = jj_gen;
                        S = YAST.nodeAnon();
    }
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    case Q_IRIref:
    case QNAME_NS:
    case QNAME_LN:
    case BLANK_NODE_LABEL:
    case VAR:
    case DOLLAR:
    case CALLING:
    case TRUE:
    case FALSE:
    case INTEGER:
    case DECIMAL:
    case DOUBLE:
    case STRING_LITERAL1:
    case STRING_LITERAL2:
    case STRING_LITERAL_LONG1:
    case STRING_LITERAL_LONG2:
    case LPAREN:
    case NIL:
    case LBRACKET:
    case ANON:
    case PLUS:
    case MINUS:
      objectList(S, YAST.RDFS_LABEL, raw);
      break;
    default:
      jj_la1[62] = jj_gen;
      ;
    }
    propertyListTail(S, raw);
      {if (true) return YAST.metaData( S, raw );}
    throw new Error("Missing return statement in function");
  }

  final public Prolog prolog() throws ParseException {
                    YNode base = null; List<Pair<String, YNode>> prefixes = new ArrayList<Pair<String, YNode>>();
    label_20:
    while (true) {
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case BASE:
      case PREFIX:
        ;
        break;
      default:
        jj_la1[63] = jj_gen;
        break label_20;
      }
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case BASE:
        jj_consume_token(BASE);
        base = iriExpr();
        break;
      case PREFIX:
        jj_consume_token(PREFIX);
          String prefix; YNode suffix;
        prefix = jj_consume_token(QNAME_NS).image;
        suffix = iriExpr();
          prefixes.add( new Pair<String, YNode>( prefix, suffix ) );
        break;
      default:
        jj_la1[64] = jj_gen;
        jj_consume_token(-1);
        throw new ParseException();
      }
    }
      {if (true) return YAST.prolog( base, prefixes );}
    throw new Error("Missing return statement in function");
  }

  /** Generated Token Manager. */
  public YmrisTokenManager token_source;
  JavaCharStream jj_input_stream;
  /** Current token. */
  public Token token;
  /** Next token. */
  public Token jj_nt;
  private int jj_ntk;
  private int jj_gen;
  final private int[] jj_la1 = new int[65];
  static private int[] jj_la1_0;
  static private int[] jj_la1_1;
  static private int[] jj_la1_2;
  static private int[] jj_la1_3;
  static {
      jj_la1_init_0();
      jj_la1_init_1();
      jj_la1_init_2();
      jj_la1_init_3();
   }
   private static void jj_la1_init_0() {
      jj_la1_0 = new int[] {0x4000000,0x0,0x0,0x0,0x0,0x0,0x0,0x700,0x0,0x700,0x10000000,0x20000000,0x1000000,0x0,0x40100000,0x0,0x40100000,0xc2003f00,0x0,0x0,0x0,0xc2003f00,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x23700,0x23700,0x0,0x0,0x800000,0x0,0x0,0x0,0xc2003f00,0x0,0xc2003f00,0x3f00,0x3f00,0x3f00,0x3700,0x3700,0x3700,0x3700,0x4000,0x0,0x0,0x0,0x800,0x0,0x41700,0x0,0x41700,0x700,0x0,0x23f00,0x700,0x23f00,0x480000,0x480000,};
   }
   private static void jj_la1_init_1() {
      jj_la1_1 = new int[] {0x0,0x20,0x10,0x8,0x0,0x0,0x0,0x20008000,0x0,0x8000,0x0,0x0,0x10000000,0x0,0x0,0x0,0x0,0xa0000800,0x800,0x0,0x800,0xa0000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xa7873000,0xa7873000,0xa0000000,0x0,0x0,0x0,0x10000000,0x1,0xa0000000,0x0,0xa0000000,0xa0000000,0xa7873000,0xa7873000,0xa7873000,0x87873000,0xa0000000,0x80000000,0x0,0x70000,0x0,0x70000,0x0,0x7800000,0x0,0x0,0x0,0x0,0x0,0xa7873000,0x8000,0xa7873000,0x0,0x0,};
   }
   private static void jj_la1_init_2() {
      jj_la1_2 = new int[] {0x0,0x0,0x0,0x0,0x20000,0x20,0x40,0x0,0x400000,0x0,0x0,0x0,0x1,0x1,0x0,0x4000100,0x0,0x14,0x0,0x80,0x0,0x14,0x40000,0x80000,0x3f00,0x3f00,0x300000,0x300000,0xc00000,0xc00000,0x304000,0x304000,0x0,0x0,0x40,0x0,0x80,0x0,0x0,0x15,0x4000100,0x14,0x14,0x300014,0x300014,0x300000,0x0,0x0,0x0,0x1000000,0x0,0x300000,0x0,0x14,0x0,0x0,0x20,0x0,0x0,0x40,0x300014,0x0,0x300014,0x0,0x0,};
   }
   private static void jj_la1_init_3() {
      jj_la1_3 = new int[] {0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,};
   }

  /** Constructor with InputStream. */
  public Ymris(java.io.InputStream stream) {
     this(stream, null);
  }
  /** Constructor with InputStream and supplied encoding */
  public Ymris(java.io.InputStream stream, String encoding) {
    try { jj_input_stream = new JavaCharStream(stream, encoding, 1, 1); } catch(java.io.UnsupportedEncodingException e) { throw new RuntimeException(e); }
    token_source = new YmrisTokenManager(jj_input_stream);
    token = new Token();
    jj_ntk = -1;
    jj_gen = 0;
    for (int i = 0; i < 65; i++) jj_la1[i] = -1;
  }

  /** Reinitialise. */
  public void ReInit(java.io.InputStream stream) {
     ReInit(stream, null);
  }
  /** Reinitialise. */
  public void ReInit(java.io.InputStream stream, String encoding) {
    try { jj_input_stream.ReInit(stream, encoding, 1, 1); } catch(java.io.UnsupportedEncodingException e) { throw new RuntimeException(e); }
    token_source.ReInit(jj_input_stream);
    token = new Token();
    jj_ntk = -1;
    jj_gen = 0;
    for (int i = 0; i < 65; i++) jj_la1[i] = -1;
  }

  /** Constructor. */
  public Ymris(java.io.Reader stream) {
    jj_input_stream = new JavaCharStream(stream, 1, 1);
    token_source = new YmrisTokenManager(jj_input_stream);
    token = new Token();
    jj_ntk = -1;
    jj_gen = 0;
    for (int i = 0; i < 65; i++) jj_la1[i] = -1;
  }

  /** Reinitialise. */
  public void ReInit(java.io.Reader stream) {
    jj_input_stream.ReInit(stream, 1, 1);
    token_source.ReInit(jj_input_stream);
    token = new Token();
    jj_ntk = -1;
    jj_gen = 0;
    for (int i = 0; i < 65; i++) jj_la1[i] = -1;
  }

  /** Constructor with generated Token Manager. */
  public Ymris(YmrisTokenManager tm) {
    token_source = tm;
    token = new Token();
    jj_ntk = -1;
    jj_gen = 0;
    for (int i = 0; i < 65; i++) jj_la1[i] = -1;
  }

  /** Reinitialise. */
  public void ReInit(YmrisTokenManager tm) {
    token_source = tm;
    token = new Token();
    jj_ntk = -1;
    jj_gen = 0;
    for (int i = 0; i < 65; i++) jj_la1[i] = -1;
  }

  private Token jj_consume_token(int kind) throws ParseException {
    Token oldToken;
    if ((oldToken = token).next != null) token = token.next;
    else token = token.next = token_source.getNextToken();
    jj_ntk = -1;
    if (token.kind == kind) {
      jj_gen++;
      return token;
    }
    token = oldToken;
    jj_kind = kind;
    throw generateParseException();
  }


/** Get the next Token. */
  final public Token getNextToken() {
    if (token.next != null) token = token.next;
    else token = token.next = token_source.getNextToken();
    jj_ntk = -1;
    jj_gen++;
    return token;
  }

/** Get the specific Token. */
  final public Token getToken(int index) {
    Token t = token;
    for (int i = 0; i < index; i++) {
      if (t.next != null) t = t.next;
      else t = t.next = token_source.getNextToken();
    }
    return t;
  }

  private int jj_ntk() {
    if ((jj_nt=token.next) == null)
      return (jj_ntk = (token.next=token_source.getNextToken()).kind);
    else
      return (jj_ntk = jj_nt.kind);
  }

  private java.util.List<int[]> jj_expentries = new java.util.ArrayList<int[]>();
  private int[] jj_expentry;
  private int jj_kind = -1;

  /** Generate ParseException. */
  public ParseException generateParseException() {
    jj_expentries.clear();
    boolean[] la1tokens = new boolean[98];
    if (jj_kind >= 0) {
      la1tokens[jj_kind] = true;
      jj_kind = -1;
    }
    for (int i = 0; i < 65; i++) {
      if (jj_la1[i] == jj_gen) {
        for (int j = 0; j < 32; j++) {
          if ((jj_la1_0[i] & (1<<j)) != 0) {
            la1tokens[j] = true;
          }
          if ((jj_la1_1[i] & (1<<j)) != 0) {
            la1tokens[32+j] = true;
          }
          if ((jj_la1_2[i] & (1<<j)) != 0) {
            la1tokens[64+j] = true;
          }
          if ((jj_la1_3[i] & (1<<j)) != 0) {
            la1tokens[96+j] = true;
          }
        }
      }
    }
    for (int i = 0; i < 98; i++) {
      if (la1tokens[i]) {
        jj_expentry = new int[1];
        jj_expentry[0] = i;
        jj_expentries.add(jj_expentry);
      }
    }
    int[][] exptokseq = new int[jj_expentries.size()][];
    for (int i = 0; i < jj_expentries.size(); i++) {
      exptokseq[i] = jj_expentries.get(i);
    }
    return new ParseException(token, exptokseq, tokenImage);
  }

  /** Enable tracing. */
  final public void enable_tracing() {
  }

  /** Disable tracing. */
  final public void disable_tracing() {
  }

    }
TOP

Related Classes of com.hp.jena.ymris.grammar.Ymris

TOP
Copyright © 2018 www.massapi.com. All rights reserved.
All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.