Package persistence.antlr.preprocessor

Source Code of persistence.antlr.preprocessor.Preprocessor

// $ANTLR : "preproc.g" -> "Preprocessor.java"$

package persistence.antlr.preprocessor;

import persistence.antlr.TokenBuffer;
import persistence.antlr.TokenStreamException;
import persistence.antlr.TokenStreamIOException;
import persistence.antlr.ANTLRException;
import persistence.antlr.LLkParser;
import persistence.antlr.Token;
import persistence.antlr.TokenStream;
import persistence.antlr.RecognitionException;
import persistence.antlr.NoViableAltException;
import persistence.antlr.MismatchedTokenException;
import persistence.antlr.SemanticException;
import persistence.antlr.ParserSharedInputState;
import persistence.antlr.collections.impl.BitSet;

import persistence.antlr.collections.impl.IndexedVector;
import java.util.Hashtable;
import persistence.antlr.preprocessor.Grammar;

public class Preprocessor extends persistence.antlr.LLkParser       implements PreprocessorTokenTypes
{

  // This chunk of error reporting code provided by Brian Smith

    private persistence.antlr.Tool antlrTool;

    /** In order to make it so existing subclasses don't break, we won't require
     * that the persistence.antlr.Tool instance be passed as a constructor element. Instead,
     * the persistence.antlr.Tool instance should register itself via {@link #initTool(persistence.antlr.Tool)}
     * @throws IllegalStateException if a tool has already been registered
     * @since 2.7.2
     */
    public void setTool(persistence.antlr.Tool tool) {
        if (antlrTool == null) {
            antlrTool = tool;
    }
        else {
            throw new IllegalStateException("persistence.antlr.Tool already registered");
    }
    }

    /** @since 2.7.2 */
    protected persistence.antlr.Tool getTool() {
        return antlrTool;
    }

    /** Delegates the error message to the tool if any was registered via
     *  {@link #initTool(persistence.antlr.Tool)}
     @since 2.7.2
     */
    public void reportError(String s) {
        if (getTool() != null) {
            getTool().error(s, getFilename(), -1, -1);
    }
        else {
            super.reportError(s);
    }
    }

    /** Delegates the error message to the tool if any was registered via
     *  {@link #initTool(persistence.antlr.Tool)}
     @since 2.7.2
     */
    public void reportError(RecognitionException e) {
        if (getTool() != null) {
            getTool().error(e.getErrorMessage(), e.getFilename(), e.getLine(), e.getColumn());
    }
        else {
            super.reportError(e);
    }
    }

    /** Delegates the warning message to the tool if any was registered via
     *  {@link #initTool(persistence.antlr.Tool)}
     @since 2.7.2
     */
    public void reportWarning(String s) {
        if (getTool() != null) {
            getTool().warning(s, getFilename(), -1, -1);
    }
        else {
            super.reportWarning(s);
    }
    }

protected Preprocessor(TokenBuffer tokenBuf, int k) {
  super(tokenBuf,k);
  tokenNames = _tokenNames;
}

public Preprocessor(TokenBuffer tokenBuf) {
  this(tokenBuf,1);
}

protected Preprocessor(TokenStream lexer, int k) {
  super(lexer,k);
  tokenNames = _tokenNames;
}

public Preprocessor(TokenStream lexer) {
  this(lexer,1);
}

public Preprocessor(ParserSharedInputState state) {
  super(state,1);
  tokenNames = _tokenNames;
}

  public final void grammarFile(
    Hierarchy hier, String file
  ) throws RecognitionException, TokenStreamException {
   
    Token  hdr = null;
   
      Grammar gr;
      IndexedVector opt=null;
   
   
    try {      // for error handling
      {
      _loop265:
      do {
        if ((LA(1)==HEADER_ACTION)) {
          hdr = LT(1);
          match(HEADER_ACTION);
          hier.getFile(file).addHeaderAction(hdr.getText());
        }
        else {
          break _loop265;
        }
       
      } while (true);
      }
      {
      switch ( LA(1)) {
      case OPTIONS_START:
      {
        opt=optionSpec(null);
        break;
      }
      case EOF:
      case ACTION:
      case LITERAL_class:
      {
        break;
      }
      default:
      {
        throw new NoViableAltException(LT(1), getFilename());
      }
      }
      }
      {
      _loop268:
      do {
        if ((LA(1)==ACTION||LA(1)==LITERAL_class)) {
          gr=class_def(file, hier);
         
                if ( gr!=null && opt!=null ) {
                  hier.getFile(file).setOptions(opt);
                }
                if ( gr!=null ) {
                  gr.setFileName(file);
                  hier.addGrammar(gr);
                }
               
        }
        else {
          break _loop268;
        }
       
      } while (true);
      }
      match(Token.EOF_TYPE);
    }
    catch (RecognitionException ex) {
      reportError(ex);
      consume();
      consumeUntil(_tokenSet_0);
    }
  }
 
  public final IndexedVector  optionSpec(
    Grammar gr
  ) throws RecognitionException, TokenStreamException {
    IndexedVector options;
   
    Token  op = null;
    Token  rhs = null;
   
      options = new IndexedVector();
   
   
    try {      // for error handling
      match(OPTIONS_START);
      {
      _loop280:
      do {
        if ((LA(1)==ID)) {
          op = LT(1);
          match(ID);
          rhs = LT(1);
          match(ASSIGN_RHS);
         
                  Option newOp = new Option(op.getText(),rhs.getText(),gr);
                  options.appendElement(newOp.getName(),newOp);
                  if ( gr!=null && op.getText().equals("importVocab") ) {
                    gr.specifiedVocabulary = true;
                    gr.importVocab = rhs.getText();
                  }
                  else if ( gr!=null && op.getText().equals("exportVocab") ) {
                    // don't want ';' included in outputVocab.
                    // This is heinously inconsistent!  Ugh.
                    gr.exportVocab = rhs.getText().substring(0,rhs.getText().length()-1);
                    gr.exportVocab = gr.exportVocab.trim();
                  }
                 
        }
        else {
          break _loop280;
        }
       
      } while (true);
      }
      match(RCURLY);
    }
    catch (RecognitionException ex) {
      reportError(ex);
      consume();
      consumeUntil(_tokenSet_1);
    }
    return options;
  }
 
  public final Grammar  class_def(
    String file, Hierarchy hier
  ) throws RecognitionException, TokenStreamException {
    Grammar gr;
   
    Token  preamble = null;
    Token  sub = null;
    Token  sup = null;
    Token  tk = null;
    Token  memberA = null;
   
      gr=null;
      IndexedVector rules = new IndexedVector(100);
      IndexedVector classOptions = null;
      String sc = null;
   
   
    try {      // for error handling
      {
      switch ( LA(1)) {
      case ACTION:
      {
        preamble = LT(1);
        match(ACTION);
        break;
      }
      case LITERAL_class:
      {
        break;
      }
      default:
      {
        throw new NoViableAltException(LT(1), getFilename());
      }
      }
      }
      match(LITERAL_class);
      sub = LT(1);
      match(ID);
      match(LITERAL_extends);
      sup = LT(1);
      match(ID);
      {
      switch ( LA(1)) {
      case SUBRULE_BLOCK:
      {
        sc=superClass();
        break;
      }
      case SEMI:
      {
        break;
      }
      default:
      {
        throw new NoViableAltException(LT(1), getFilename());
      }
      }
      }
      match(SEMI);
     
            gr = (Grammar)hier.getGrammar(sub.getText());
            if ( gr!=null ) {
      //        antlr.Tool.toolError("redefinition of grammar "+gr.getName()+" ignored");
              gr=null;
              throw new SemanticException("redefinition of grammar "+sub.getText(), file, sub.getLine(), sub.getColumn());
            }
            else {
              gr = new Grammar(hier.getTool(), sub.getText(), sup.getText(), rules);
              gr.superClass=sc;
              if ( preamble!=null ) {
                gr.setPreambleAction(preamble.getText());
              }
            }
         
      {
      switch ( LA(1)) {
      case OPTIONS_START:
      {
        classOptions=optionSpec(gr);
        break;
      }
      case ACTION:
      case ID:
      case TOKENS_SPEC:
      case LITERAL_protected:
      case LITERAL_private:
      case LITERAL_public:
      {
        break;
      }
      default:
      {
        throw new NoViableAltException(LT(1), getFilename());
      }
      }
      }
     
          if ( gr!=null ) {
            gr.setOptions(classOptions);
          }
         
      {
      switch ( LA(1)) {
      case TOKENS_SPEC:
      {
        tk = LT(1);
        match(TOKENS_SPEC);
        gr.setTokenSection(tk.getText());
        break;
      }
      case ACTION:
      case ID:
      case LITERAL_protected:
      case LITERAL_private:
      case LITERAL_public:
      {
        break;
      }
      default:
      {
        throw new NoViableAltException(LT(1), getFilename());
      }
      }
      }
      {
      switch ( LA(1)) {
      case ACTION:
      {
        memberA = LT(1);
        match(ACTION);
        gr.setMemberAction(memberA.getText());
        break;
      }
      case ID:
      case LITERAL_protected:
      case LITERAL_private:
      case LITERAL_public:
      {
        break;
      }
      default:
      {
        throw new NoViableAltException(LT(1), getFilename());
      }
      }
      }
      {
      int _cnt277=0;
      _loop277:
      do {
        if ((_tokenSet_2.member(LA(1)))) {
          rule(gr);
        }
        else {
          if ( _cnt277>=1 ) { break _loop277; } else {throw new NoViableAltException(LT(1), getFilename());}
        }
       
        _cnt277++;
      } while (true);
      }
    }
    catch (RecognitionException ex) {
      reportError(ex);
      consume();
      consumeUntil(_tokenSet_3);
    }
    return gr;
  }
 
  public final String  superClass() throws RecognitionException, TokenStreamException {
    String sup;
   
    sup=LT(1).getText();
   
    try {      // for error handling
      match(SUBRULE_BLOCK);
    }
    catch (RecognitionException ex) {
      reportError(ex);
      consume();
      consumeUntil(_tokenSet_4);
    }
    return sup;
  }
 
  public final void rule(
    Grammar gr
  ) throws RecognitionException, TokenStreamException {
   
    Token  r = null;
    Token  arg = null;
    Token  ret = null;
    Token  init = null;
    Token  blk = null;
   
      IndexedVector o = null// options for rule
      String vis = null;
      boolean bang=false;
      String eg=null, thr="";
   
   
    try {      // for error handling
      {
      switch ( LA(1)) {
      case LITERAL_protected:
      {
        match(LITERAL_protected);
        vis="protected";
        break;
      }
      case LITERAL_private:
      {
        match(LITERAL_private);
        vis="private";
        break;
      }
      case LITERAL_public:
      {
        match(LITERAL_public);
        vis="public";
        break;
      }
      case ID:
      {
        break;
      }
      default:
      {
        throw new NoViableAltException(LT(1), getFilename());
      }
      }
      }
      r = LT(1);
      match(ID);
      {
      switch ( LA(1)) {
      case BANG:
      {
        match(BANG);
        bang=true;
        break;
      }
      case ACTION:
      case OPTIONS_START:
      case ARG_ACTION:
      case LITERAL_returns:
      case RULE_BLOCK:
      case LITERAL_throws:
      {
        break;
      }
      default:
      {
        throw new NoViableAltException(LT(1), getFilename());
      }
      }
      }
      {
      switch ( LA(1)) {
      case ARG_ACTION:
      {
        arg = LT(1);
        match(ARG_ACTION);
        break;
      }
      case ACTION:
      case OPTIONS_START:
      case LITERAL_returns:
      case RULE_BLOCK:
      case LITERAL_throws:
      {
        break;
      }
      default:
      {
        throw new NoViableAltException(LT(1), getFilename());
      }
      }
      }
      {
      switch ( LA(1)) {
      case LITERAL_returns:
      {
        match(LITERAL_returns);
        ret = LT(1);
        match(ARG_ACTION);
        break;
      }
      case ACTION:
      case OPTIONS_START:
      case RULE_BLOCK:
      case LITERAL_throws:
      {
        break;
      }
      default:
      {
        throw new NoViableAltException(LT(1), getFilename());
      }
      }
      }
      {
      switch ( LA(1)) {
      case LITERAL_throws:
      {
        thr=throwsSpec();
        break;
      }
      case ACTION:
      case OPTIONS_START:
      case RULE_BLOCK:
      {
        break;
      }
      default:
      {
        throw new NoViableAltException(LT(1), getFilename());
      }
      }
      }
      {
      switch ( LA(1)) {
      case OPTIONS_START:
      {
        o=optionSpec(null);
        break;
      }
      case ACTION:
      case RULE_BLOCK:
      {
        break;
      }
      default:
      {
        throw new NoViableAltException(LT(1), getFilename());
      }
      }
      }
      {
      switch ( LA(1)) {
      case ACTION:
      {
        init = LT(1);
        match(ACTION);
        break;
      }
      case RULE_BLOCK:
      {
        break;
      }
      default:
      {
        throw new NoViableAltException(LT(1), getFilename());
      }
      }
      }
      blk = LT(1);
      match(RULE_BLOCK);
      eg=exceptionGroup();
     
          String rtext = blk.getText()+eg;
          Rule ppr = new Rule(r.getText(),rtext,o,gr);
          ppr.setThrowsSpec(thr);
          if ( arg!=null ) {
            ppr.setArgs(arg.getText());
          }
          if ( ret!=null ) {
            ppr.setReturnValue(ret.getText());
          }
          if ( init!=null ) {
            ppr.setInitAction(init.getText());
          }
          if ( bang ) {
            ppr.setBang();
          }
          ppr.setVisibility(vis);
          if ( gr!=null ) {
            gr.addRule(ppr);
          }
         
    }
    catch (RecognitionException ex) {
      reportError(ex);
      consume();
      consumeUntil(_tokenSet_5);
    }
  }
 
  public final String  throwsSpec() throws RecognitionException, TokenStreamException {
    String t;
   
    Token  a = null;
    Token  b = null;
    t="throws ";
   
    try {      // for error handling
      match(LITERAL_throws);
      a = LT(1);
      match(ID);
      t+=a.getText();
      {
      _loop291:
      do {
        if ((LA(1)==COMMA)) {
          match(COMMA);
          b = LT(1);
          match(ID);
          t+=","+b.getText();
        }
        else {
          break _loop291;
        }
       
      } while (true);
      }
    }
    catch (RecognitionException ex) {
      reportError(ex);
      consume();
      consumeUntil(_tokenSet_6);
    }
    return t;
  }
 
  public final String  exceptionGroup() throws RecognitionException, TokenStreamException {
    String g;
   
    String e=null; g="";
   
    try {      // for error handling
      {
      _loop294:
      do {
        if ((LA(1)==LITERAL_exception)) {
          e=exceptionSpec();
          g += e;
        }
        else {
          break _loop294;
        }
       
      } while (true);
      }
    }
    catch (RecognitionException ex) {
      reportError(ex);
      consume();
      consumeUntil(_tokenSet_5);
    }
    return g;
  }
 
  public final String  exceptionSpec() throws RecognitionException, TokenStreamException {
    String es;
   
    Token  aa = null;
    String h=null;
    es = System.getProperty("line.separator")+"exception ";
   
   
    try {      // for error handling
      match(LITERAL_exception);
      {
      switch ( LA(1)) {
      case ARG_ACTION:
      {
        aa = LT(1);
        match(ARG_ACTION);
        es += aa.getText();
        break;
      }
      case EOF:
      case ACTION:
      case LITERAL_class:
      case ID:
      case LITERAL_protected:
      case LITERAL_private:
      case LITERAL_public:
      case LITERAL_exception:
      case LITERAL_catch:
      {
        break;
      }
      default:
      {
        throw new NoViableAltException(LT(1), getFilename());
      }
      }
      }
      {
      _loop298:
      do {
        if ((LA(1)==LITERAL_catch)) {
          h=exceptionHandler();
          es += h;
        }
        else {
          break _loop298;
        }
       
      } while (true);
      }
    }
    catch (RecognitionException ex) {
      reportError(ex);
      consume();
      consumeUntil(_tokenSet_7);
    }
    return es;
  }
 
  public final String  exceptionHandler() throws RecognitionException, TokenStreamException {
    String h;
   
    Token  a1 = null;
    Token  a2 = null;
    h=null;
   
    try {      // for error handling
      match(LITERAL_catch);
      a1 = LT(1);
      match(ARG_ACTION);
      a2 = LT(1);
      match(ACTION);
      h = System.getProperty("line.separator")+
             "catch "+a1.getText()+" "+a2.getText();
    }
    catch (RecognitionException ex) {
      reportError(ex);
      consume();
      consumeUntil(_tokenSet_8);
    }
    return h;
  }
 
 
  public static final String[] _tokenNames = {
    "<0>",
    "EOF",
    "<2>",
    "NULL_TREE_LOOKAHEAD",
    "\"tokens\"",
    "HEADER_ACTION",
    "SUBRULE_BLOCK",
    "ACTION",
    "\"class\"",
    "ID",
    "\"extends\"",
    "SEMI",
    "TOKENS_SPEC",
    "OPTIONS_START",
    "ASSIGN_RHS",
    "RCURLY",
    "\"protected\"",
    "\"private\"",
    "\"public\"",
    "BANG",
    "ARG_ACTION",
    "\"returns\"",
    "RULE_BLOCK",
    "\"throws\"",
    "COMMA",
    "\"exception\"",
    "\"catch\"",
    "ALT",
    "ELEMENT",
    "LPAREN",
    "RPAREN",
    "ID_OR_KEYWORD",
    "CURLY_BLOCK_SCARF",
    "WS",
    "NEWLINE",
    "COMMENT",
    "SL_COMMENT",
    "ML_COMMENT",
    "CHAR_LITERAL",
    "STRING_LITERAL",
    "ESC",
    "DIGIT",
    "XDIGIT"
  };
 
  private static final long[] mk_tokenSet_0() {
    long[] data = { 2L, 0L};
    return data;
  }
  public static final BitSet _tokenSet_0 = new BitSet(mk_tokenSet_0());
  private static final long[] mk_tokenSet_1() {
    long[] data = { 4658050L, 0L};
    return data;
  }
  public static final BitSet _tokenSet_1 = new BitSet(mk_tokenSet_1());
  private static final long[] mk_tokenSet_2() {
    long[] data = { 459264L, 0L};
    return data;
  }
  public static final BitSet _tokenSet_2 = new BitSet(mk_tokenSet_2());
  private static final long[] mk_tokenSet_3() {
    long[] data = { 386L, 0L};
    return data;
  }
  public static final BitSet _tokenSet_3 = new BitSet(mk_tokenSet_3());
  private static final long[] mk_tokenSet_4() {
    long[] data = { 2048L, 0L};
    return data;
  }
  public static final BitSet _tokenSet_4 = new BitSet(mk_tokenSet_4());
  private static final long[] mk_tokenSet_5() {
    long[] data = { 459650L, 0L};
    return data;
  }
  public static final BitSet _tokenSet_5 = new BitSet(mk_tokenSet_5());
  private static final long[] mk_tokenSet_6() {
    long[] data = { 4202624L, 0L};
    return data;
  }
  public static final BitSet _tokenSet_6 = new BitSet(mk_tokenSet_6());
  private static final long[] mk_tokenSet_7() {
    long[] data = { 34014082L, 0L};
    return data;
  }
  public static final BitSet _tokenSet_7 = new BitSet(mk_tokenSet_7());
  private static final long[] mk_tokenSet_8() {
    long[] data = { 101122946L, 0L};
    return data;
  }
  public static final BitSet _tokenSet_8 = new BitSet(mk_tokenSet_8());
 
  }
TOP

Related Classes of persistence.antlr.preprocessor.Preprocessor

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.