org.antlr.v4.tool.templates.codegen.Java.Java.stg Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of virtdata-lib-realer Show documentation
Show all versions of virtdata-lib-realer Show documentation
With inspiration from other libraries
/*
* [The "BSD license"]
* Copyright (c) 2012-2016 Terence Parr
* Copyright (c) 2012-2016 Sam Harwell
* 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.
*/
javaTypeInitMap ::= [
"int":"0",
"long":"0",
"float":"0.0f",
"double":"0.0",
"boolean":"false",
"byte":"0",
"short":"0",
"char":"0",
default:"null" // anything other than a primitive type is an object
]
// args must be ,
ParserFile(file, parser, namedActions, contextSuperClass) ::= <<
package ;
import org.antlr.v4.runtime.atn.*;
import org.antlr.v4.runtime.dfa.DFA;
import org.antlr.v4.runtime.*;
import org.antlr.v4.runtime.misc.*;
import org.antlr.v4.runtime.tree.*;
import java.util.List;
import java.util.Iterator;
import java.util.ArrayList;
>>
ListenerFile(file, header, namedActions) ::= <<
package ;
import org.antlr.v4.runtime.tree.ParseTreeListener;
/**
* This interface defines a complete listener for a parse tree produced by
* {@link }.
*/
public interface Listener extends ParseTreeListener {
* Enter a parse tree produced by the {@code \}
* labeled alternative in {@link #\}.
* Enter a parse tree produced by {@link #\}.
* @param ctx the parse tree
*/
void enter(.Context ctx);
/**
* Exit a parse tree produced by the {@code \}
* labeled alternative in {@link #\}.
* Exit a parse tree produced by {@link #\}.
* @param ctx the parse tree
*/
void exit(.Context ctx);}; separator="\n">
}
>>
BaseListenerFile(file, header, namedActions) ::= <<
package ;
import org.antlr.v4.runtime.ParserRuleContext;
import org.antlr.v4.runtime.tree.ErrorNode;
import org.antlr.v4.runtime.tree.TerminalNode;
/**
* This class provides an empty implementation of {@link Listener},
* which can be extended to create a listener which only needs to handle a subset
* of the available methods.
*/
public class BaseListener implements Listener {
The default implementation does nothing.\
*/
@Override public void enter(.Context ctx) { \}
/**
* {@inheritDoc\}
*
* \The default implementation does nothing.\
*/
@Override public void exit(.Context ctx) { \}}; separator="\n">
/**
* {@inheritDoc\}
*
* \The default implementation does nothing.\
*/
@Override public void enterEveryRule(ParserRuleContext ctx) { }
/**
* {@inheritDoc\}
*
* \The default implementation does nothing.\
*/
@Override public void exitEveryRule(ParserRuleContext ctx) { }
/**
* {@inheritDoc\}
*
* \The default implementation does nothing.\
*/
@Override public void visitTerminal(TerminalNode node) { }
/**
* {@inheritDoc\}
*
* \The default implementation does nothing.\
*/
@Override public void visitErrorNode(ErrorNode node) { }
}
>>
VisitorFile(file, header, namedActions) ::= <<
package ;
import org.antlr.v4.runtime.tree.ParseTreeVisitor;
/**
* This interface defines a complete generic visitor for a parse tree produced
* by {@link }.
*
* @param \ The return type of the visit operation. Use {@link Void} for
* operations with no return type.
*/
public interface Visitor\ extends ParseTreeVisitor\ {
* Visit a parse tree produced by the {@code \}
* labeled alternative in {@link #\}.
* Visit a parse tree produced by {@link #\}.
* @param ctx the parse tree
* @return the visitor result
*/
T visit(.Context ctx);}; separator="\n">
}
>>
BaseVisitorFile(file, header, namedActions) ::= <<
package ;
import org.antlr.v4.runtime.tree.AbstractParseTreeVisitor;
/**
* This class provides an empty implementation of {@link Visitor},
* which can be extended to create a visitor which only needs to handle a subset
* of the available methods.
*
* @param \ The return type of the visit operation. Use {@link Void} for
* operations with no return type.
*/
public class BaseVisitor\ extends AbstractParseTreeVisitor\ implements Visitor\ {
The default implementation returns the result of calling
* {@link #visitChildren\} on {@code ctx\}.\
*/
@Override public T visit(.Context ctx) { return visitChildren(ctx); \}}; separator="\n">
}
>>
fileHeader(grammarFileName, ANTLRVersion) ::= <<
// Generated from by ANTLR
>>
Parser(parser, funcs, atn, sempredFuncs, superClass) ::= <<
>>
Parser_(parser, funcs, atn, sempredFuncs, ctor, superClass) ::= <<
@SuppressWarnings({"all", "warnings", "unchecked", "unused", "cast"})
public class extends {
static { RuntimeMetaData.checkVersion("", RuntimeMetaData.VERSION); }
protected static final DFA[] _decisionToDFA;
protected static final PredictionContextCache _sharedContextCache =
new PredictionContextCache();
public static final int
=}; separator=", ", wrap, anchor>;
public static final int
= }; separator=", ", wrap, anchor>;
public static final String[] ruleNames = {
"}; separator=", ", wrap, anchor>
};
@Override
public String getGrammarFileName() { return ""; }
@Override
public String[] getRuleNames() { return ruleNames; }
@Override
public String getSerializedATN() { return _serializedATN; }
@Override
public ATN getATN() { return _ATN; }
public boolean sempred(RuleContext _localctx, int ruleIndex, int predIndex) {
switch (ruleIndex) {
:
return _sempred(()_localctx, predIndex);}; separator="\n">
}
return true;
}
}
>>
vocabulary(literalNames, symbolicNames) ::= <<
private static final String[] _LITERAL_NAMES = {
}; null="null", separator=", ", wrap, anchor>
};
private static final String[] _SYMBOLIC_NAMES = {
}; null="null", separator=", ", wrap, anchor>
};
public static final Vocabulary VOCABULARY = new VocabularyImpl(_LITERAL_NAMES, _SYMBOLIC_NAMES);
/**
* @deprecated Use {@link #VOCABULARY} instead.
*/
@Deprecated
public static final String[] tokenNames;
static {
tokenNames = new String[_SYMBOLIC_NAMES.length];
for (int i = 0; i \< tokenNames.length; i++) {
tokenNames[i] = VOCABULARY.getLiteralName(i);
if (tokenNames[i] == null) {
tokenNames[i] = VOCABULARY.getSymbolicName(i);
}
if (tokenNames[i] == null) {
tokenNames[i] = "\";
}
}
}
@Override
@Deprecated
public String[] getTokenNames() {
return tokenNames;
}
@Override
public Vocabulary getVocabulary() {
return VOCABULARY;
}
>>
dumpActions(recog, argFuncs, actionFuncs, sempredFuncs) ::= <<
@Override
public void action(RuleContext _localctx, int ruleIndex, int actionIndex) {
switch (ruleIndex) {
:
_action(()_localctx, actionIndex);
break;}; separator="\n">
}
}
@Override
public boolean sempred(RuleContext _localctx, int ruleIndex, int predIndex) {
switch (ruleIndex) {
:
return _sempred(()_localctx, predIndex);}; separator="\n">
}
return true;
}
>>
parser_ctor(p) ::= <<
public (TokenStream input) {
super(input);
_interp = new ParserATNSimulator(this,_ATN,_decisionToDFA,_sharedContextCache);
}
>>
/* This generates a private method since the actionIndex is generated, making an
* overriding implementation impossible to maintain.
*/
RuleActionFunction(r, actions) ::= <<
private void _action( _localctx, int actionIndex) {
switch (actionIndex) {
:
break;}; separator="\n">
}
}
>>
/* This generates a private method since the predIndex is generated, making an
* overriding implementation impossible to maintain.
*/
RuleSempredFunction(r, actions) ::= <<
private boolean _sempred( _localctx, int predIndex) {
switch (predIndex) {
:
return ;}; separator="\n">
}
return true;
}
>>
RuleFunction(currentRule,args,code,locals,ruleCtx,altLabelCtxs,namedActions,finallyAction,postamble,exceptions) ::= <<
}; separator="\n">
}>public final () throws RecognitionException {
_localctx = new (_ctx, getState()}>);
enterRule(_localctx, , RULE_);
try {
int _alt;
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
>>
LeftRecursiveRuleFunction(currentRule,args,code,locals,ruleCtx,altLabelCtxs,
namedActions,finallyAction,postamble) ::=
<<
}; separator="\n">
}>public final () throws RecognitionException {
return (0}>);
}
private (int _p}>) throws RecognitionException {
ParserRuleContext _parentctx = _ctx;
int _parentState = getState();
_localctx = new (_ctx, _parentState}>);
_prevctx = _localctx;
int _startState = ;
enterRecursionRule(_localctx, , RULE_, _p);
try {
int _alt;
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
unrollRecursionContexts(_parentctx);
}
return _localctx;
}
>>
CodeBlockForOuterMostAlt(currentOuterMostAltCodeBlock, locals, preamble, ops) ::= <<
_localctx = new Context(_localctx);
enterOuterAlt(_localctx, );
>>
CodeBlockForAlt(currentAltCodeBlock, locals, preamble, ops) ::= <<
{
}
>>
LL1AltBlock(choice, preamble, alts, error) ::= <<
setState();
_errHandler.sync(this);
= _input.LT(1);
switch (_input.LA(1)) {
break;}; separator="\n">
default:
}
>>
LL1OptionalBlock(choice, alts, error) ::= <<
setState();
_errHandler.sync(this);
switch (_input.LA(1)) {
break;}; separator="\n">
default:
break;
}
>>
LL1OptionalBlockSingleAlt(choice, expr, alts, preamble, error, followExpr) ::= <<
setState();
_errHandler.sync(this);
if () {
}
) ) !>
>>
LL1StarBlockSingleAlt(choice, loopExpr, alts, preamble, iteration) ::= <<
setState();
_errHandler.sync(this);
while () {
setState();
_errHandler.sync(this);
}
>>
LL1PlusBlockSingleAlt(choice, loopExpr, alts, preamble, iteration) ::= <<
setState();
_errHandler.sync(this);
do {
setState();
_errHandler.sync(this);
} while ( );
>>
// LL(*) stuff
AltBlock(choice, preamble, alts, error) ::= <<
setState();
_errHandler.sync(this);
= _input.LT(1);
switch ( getInterpreter().adaptivePredict(_input,,_ctx) ) {
:
break;}; separator="\n">
}
>>
OptionalBlock(choice, alts, error) ::= <<
setState();
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,,_ctx) ) {
+1:
break;}; separator="\n">
}
>>
StarBlock(choice, alts, sync, iteration) ::= <<
setState();
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,,_ctx);
while ( _alt!= && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1+1 ) {