[The "BSD licence"]

Copyright (c) 2005-2008 Terence Parr

All rights reserved.

Redistribution and use in source and binary forms, with or without

modification, are permitted provided that the following conditions

are met:

1. Redistributions of source code must retain the above copyright

    notice, this list of conditions and the following disclaimer.

2. Redistributions in binary form must reproduce the above copyright

    notice, this list of conditions and the following disclaimer in the

    documentation and/or other materials provided with the distribution.

3. The name of the author may not be used to endorse or promote products

    derived from this software without specific prior written permission.

THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR

IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES

OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.

IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,

INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT

NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,

DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY

THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF

THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

*/

  package org.antlr.codegen;

    import org.antlr.tool.*;

    import org.antlr.analysis.*;

    import org.antlr.misc.*;

  import java.util.*;

  import org.antlr.stringtemplate.*;

    import antlr.TokenWithIndex;

    import antlr.CommonToken;

*  a bigger and bigger StringTemplate.

*

*  Terence Parr

*  University of San Francisco

*  June 15, 2004

*/

{

  protected static final int RULE_BLOCK_NESTING_LEVEL = 0;

  protected static final int OUTER_REWRITE_NESTING_LEVEL = 0;

    protected String currentRuleName = null;

    protected int blockNestingLevel = 0;

    protected int rewriteBlockNestingLevel = 0;

  protected int outerAltNum = 0;

    protected StringTemplate currentBlockST = null;

    protected boolean currentAltHasASTRewrite = false;

    protected int rewriteTreeNestingLevel = 0;

    protected Set rewriteRuleRefs = null;

    public void reportError(RecognitionException ex) {

    Token token = null;

    if ( ex instanceof MismatchedTokenException ) {

      token = ((MismatchedTokenException)ex).token;

    }

    else if ( ex instanceof NoViableAltException ) {

      token = ((NoViableAltException)ex).token;

    }

        ErrorManager.syntaxError(

            ErrorManager.MSG_SYNTAX_ERROR,

            grammar,

            token,

            "codegen: "+ex.toString(),

            ex);

    }

    public void reportError(String s) {

        System.out.println("codegen: error: " + s);

    }

    protected CodeGenerator generator;

    protected Grammar grammar;

    protected StringTemplateGroup templates;

    /** The overall lexer/parser template; simulate dynamically scoped

     *  attributes by making this an instance var of the walker.

     */

    protected StringTemplate recognizerST;

    protected StringTemplate outputFileST;

    protected StringTemplate headerFileST;

    protected String outputOption = "";

  protected StringTemplate getWildcardST(GrammarAST elementAST, GrammarAST ast_suffix, String label) {

    String name = "wildcard";

    if ( grammar.type==Grammar.LEXER ) {

      name = "wildcardChar";

    }

    return getTokenElementST(name, name, elementAST, ast_suffix, label);

  }

  protected StringTemplate getRuleElementST(String name,

                          String ruleTargetName,

                        GrammarAST elementAST,

                          GrammarAST ast_suffix,

                          String label)

  {

    String suffix = getSTSuffix(ast_suffix,label);

    name += suffix;

    // if we're building trees and there is no label, gen a label

    // unless we're in a synpred rule.

    Rule r = grammar.getRule(currentRuleName);

    if ( (grammar.buildAST()||suffix.length()>0) && label==null &&

         (r==null || !r.isSynPred) )

    {

      // we will need a label to do the AST or tracking, make one

      label = generator.createUniqueLabel(ruleTargetName);

      CommonToken labelTok = new CommonToken(ANTLRParser.ID, label);

      grammar.defineRuleRefLabel(currentRuleName, labelTok, elementAST);

    }

    StringTemplate elementST = templates.getInstanceOf(name);

    if ( label!=null ) {

      elementST.setAttribute("label", label);

    }

    return elementST;

  }

  protected StringTemplate getTokenElementST(String name,

                         String elementName,

                         GrammarAST elementAST,

                         GrammarAST ast_suffix,

                         String label)

  {

    String suffix = getSTSuffix(ast_suffix,label);

    name += suffix;

    // if we're building trees and there is no label, gen a label

    // unless we're in a synpred rule.

    Rule r = grammar.getRule(currentRuleName);

    if ( (grammar.buildAST()||suffix.length()>0) && label==null &&

         (r==null || !r.isSynPred) )

    {

      label = generator.createUniqueLabel(elementName);

      CommonToken labelTok = new CommonToken(ANTLRParser.ID, label);

      grammar.defineTokenRefLabel(currentRuleName, labelTok, elementAST);

    }

    StringTemplate elementST = templates.getInstanceOf(name);

    if ( label!=null ) {

      elementST.setAttribute("label", label);

    }

    return elementST;

  }

    public boolean isListLabel(String label) {

    boolean hasListLabel=false;

    if ( label!=null ) {

      Rule r = grammar.getRule(currentRuleName);

      String stName = null;

      if ( r!=null ) {

        Grammar.LabelElementPair pair = r.getLabel(label);

        if ( pair!=null &&

           (pair.type==Grammar.TOKEN_LIST_LABEL||

            pair.type==Grammar.RULE_LIST_LABEL) )

        {

          hasListLabel=true;

        }

      }

    }

        return hasListLabel;

    }

  /** Return a non-empty template name suffix if the token is to be

   *  tracked, added to a tree, or both.

   */

  protected String getSTSuffix(GrammarAST ast_suffix, String label) {

    if ( grammar.type==Grammar.LEXER ) {

      return "";

    }

    // handle list label stuff; make element use "Track"

    String operatorPart = "";

    String rewritePart = "";

    String listLabelPart = "";

    Rule ruleDescr = grammar.getRule(currentRuleName);

    if ( ast_suffix!=null && !ruleDescr.isSynPred ) {

      if ( ast_suffix.getType()==ANTLRParser.ROOT ) {

          operatorPart = "RuleRoot";

        }

        else if ( ast_suffix.getType()==ANTLRParser.BANG ) {

          operatorPart = "Bang";

        }

       }

    if ( currentAltHasASTRewrite ) {

      rewritePart = "Track";

    }

    if ( isListLabel(label) ) {

      listLabelPart = "AndListLabel";

    }

    String STsuffix = operatorPart+rewritePart+listLabelPart;

    //System.out.println("suffix = "+STsuffix);

      return STsuffix;

  }

    /** Convert rewrite AST lists to target labels list */

    protected List<String> getTokenTypesAsTargetLabels(Set<GrammarAST> refs) {

        if ( refs==null || refs.size()==0 ) {

            return null;

        }

        List<String> labels = new ArrayList<String>(refs.size());

        for (GrammarAST t : refs) {

            String label;

            if ( t.getType()==ANTLRParser.RULE_REF ) {

                label = t.getText();

            }

            else if ( t.getType()==ANTLRParser.LABEL ) {

                label = t.getText();

            }

            else {

                // must be char or string literal

                label = generator.getTokenTypeAsTargetLabel(

                            grammar.getTokenType(t.getText()));

            }

            labels.add(label);

        }

        return labels;

    }

    public void init(Grammar g) {

        this.grammar = g;

        this.generator = grammar.getCodeGenerator();

        this.templates = generator.getTemplates();

    }

  tokenNames = _tokenNames;

  public final void grammar(AST _t,

    Grammar g,

        StringTemplate recognizerST,

        StringTemplate outputFileST,

        StringTemplate headerFileST

  ) throws RecognitionException {

   

    GrammarAST grammar_AST_in = (_t == ASTNULL) ? null : (GrammarAST)_t;

   

    init(g);

    this.recognizerST = recognizerST;

    this.outputFileST = outputFileST;

    this.headerFileST = headerFileST;

    String superClass = (String)g.getOption("superClass");

    outputOption = (String)g.getOption("output");

    recognizerST.setAttribute("superClass", superClass);

    if ( g.type!=Grammar.LEXER ) {

        recognizerST.setAttribute("ASTLabelType", g.getOption("ASTLabelType"));

      }

    if ( g.type==Grammar.TREE_PARSER && g.getOption("ASTLabelType")==null ) {

        ErrorManager.grammarWarning(ErrorManager.MSG_MISSING_AST_TYPE_IN_TREE_GRAMMAR,

                       g,

                       null,

                       g.name);

      }

    if ( g.type!=Grammar.TREE_PARSER ) {

        recognizerST.setAttribute("labelType", g.getOption("TokenLabelType"));

      }

      recognizerST.setAttribute("numRules", grammar.getRules().size());

      outputFileST.setAttribute("numRules", grammar.getRules().size());

      headerFileST.setAttribute("numRules", grammar.getRules().size());

   

   

    try {      // for error handling

      {

      if (_t==null) _t=ASTNULL;

      switch ( _t.getType()) {

      case LEXER_GRAMMAR:

      {

        AST __t3 = _t;

        GrammarAST tmp1_AST_in = (GrammarAST)_t;

        match(_t,LEXER_GRAMMAR);

        _t = _t.getFirstChild();

        grammarSpec(_t);

        _t = _retTree;

        _t = __t3;

        _t = _t.getNextSibling();

        break;

      }

      case PARSER_GRAMMAR:

      {

        AST __t4 = _t;

        GrammarAST tmp2_AST_in = (GrammarAST)_t;

        match(_t,PARSER_GRAMMAR);

        _t = _t.getFirstChild();

        grammarSpec(_t);

        _t = _retTree;

        _t = __t4;

        _t = _t.getNextSibling();

        break;

      }

      case TREE_GRAMMAR:

      {

        AST __t5 = _t;

        GrammarAST tmp3_AST_in = (GrammarAST)_t;

        match(_t,TREE_GRAMMAR);

        _t = _t.getFirstChild();

        grammarSpec(_t);

        _t = _retTree;

        _t = __t5;

        _t = _t.getNextSibling();

        break;

      }

      case COMBINED_GRAMMAR:

      {

        AST __t6 = _t;

        GrammarAST tmp4_AST_in = (GrammarAST)_t;

        match(_t,COMBINED_GRAMMAR);

        _t = _t.getFirstChild();

        grammarSpec(_t);

        _t = _retTree;

        _t = __t6;

        _t = _t.getNextSibling();

        break;

      }

      default:

      {

        throw new NoViableAltException(_t);

      }

      }

      }

    }

    catch (RecognitionException ex) {

      reportError(ex);

      if (_t!=null) {_t = _t.getNextSibling();}

    }

    _retTree = _t;

  }

 

  public final void grammarSpec(AST _t) throws RecognitionException {

   

    GrammarAST grammarSpec_AST_in = (_t == ASTNULL) ? null : (GrammarAST)_t;

    GrammarAST name = null;

    GrammarAST cmt = null;

   

    try {      // for error handling

      name = (GrammarAST)_t;

      match(_t,ID);

      _t = _t.getNextSibling();

      {

      if (_t==null) _t=ASTNULL;

      switch ( _t.getType()) {

      case DOC_COMMENT:

      {

        cmt = (GrammarAST)_t;

        match(_t,DOC_COMMENT);

        _t = _t.getNextSibling();

       

             outputFileST.setAttribute("docComment", cmt.getText());

             headerFileST.setAttribute("docComment", cmt.getText());

           

        break;

      }

      case OPTIONS:

      case TOKENS:

      case RULE:

      case SCOPE:

      case IMPORT:

      case AMPERSAND:

      {

        break;

      }

      default:

      {

        throw new NoViableAltException(_t);

      }

      }

      }

     

          recognizerST.setAttribute("name", grammar.getRecognizerName());

          outputFileST.setAttribute("name", grammar.getRecognizerName());

          headerFileST.setAttribute("name", grammar.getRecognizerName());

          recognizerST.setAttribute("scopes", grammar.getGlobalScopes());