All Downloads are FREE. Search and download functionalities are using the official Maven repository.
Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $
You can buy this project and download/modify it how often you want.
persistence.antlr.debug.LLkDebuggingParser Maven / Gradle / Ivy
package persistence.antlr.debug;
import persistence.antlr.ParserSharedInputState;
import persistence.antlr.TokenStreamException;
import persistence.antlr.LLkParser;
import persistence.antlr.TokenBuffer;
import persistence.antlr.TokenStream;
import persistence.antlr.MismatchedTokenException;
import persistence.antlr.RecognitionException;
import persistence.antlr.collections.impl.BitSet;
import java.io.IOException;
import persistence.antlr.TokenStreamException;
import persistence.antlr.debug.ParserEventSupport;
import java.lang.reflect.Constructor;
public class LLkDebuggingParser extends LLkParser implements DebuggingParser {
protected ParserEventSupport parserEventSupport = new ParserEventSupport(this);
private boolean _notDebugMode = false;
protected String ruleNames[];
protected String semPredNames[];
public LLkDebuggingParser(int k_) {
super(k_);
}
public LLkDebuggingParser(ParserSharedInputState state, int k_) {
super(state, k_);
}
public LLkDebuggingParser(TokenBuffer tokenBuf, int k_) {
super(tokenBuf, k_);
}
public LLkDebuggingParser(TokenStream lexer, int k_) {
super(lexer, k_);
}
public void addMessageListener(MessageListener l) {
parserEventSupport.addMessageListener(l);
}
public void addParserListener(ParserListener l) {
parserEventSupport.addParserListener(l);
}
public void addParserMatchListener(ParserMatchListener l) {
parserEventSupport.addParserMatchListener(l);
}
public void addParserTokenListener(ParserTokenListener l) {
parserEventSupport.addParserTokenListener(l);
}
public void addSemanticPredicateListener(SemanticPredicateListener l) {
parserEventSupport.addSemanticPredicateListener(l);
}
public void addSyntacticPredicateListener(SyntacticPredicateListener l) {
parserEventSupport.addSyntacticPredicateListener(l);
}
public void addTraceListener(TraceListener l) {
parserEventSupport.addTraceListener(l);
}
/**Get another token object from the token stream */
public void consume() {
int la_1 = -99;
try {la_1 = LA(1);}
catch (TokenStreamException ignoreAnException) {}
super.consume();
parserEventSupport.fireConsume(la_1);
}
protected void fireEnterRule(int num,int data) {
if (isDebugMode())
parserEventSupport.fireEnterRule(num,inputState.guessing,data);
}
protected void fireExitRule(int num,int data) {
if (isDebugMode())
parserEventSupport.fireExitRule(num,inputState.guessing,data);
}
protected boolean fireSemanticPredicateEvaluated(int type, int num, boolean condition) {
if (isDebugMode())
return parserEventSupport.fireSemanticPredicateEvaluated(type,num,condition,inputState.guessing);
else
return condition;
}
protected void fireSyntacticPredicateFailed() {
if (isDebugMode())
parserEventSupport.fireSyntacticPredicateFailed(inputState.guessing);
}
protected void fireSyntacticPredicateStarted() {
if (isDebugMode())
parserEventSupport.fireSyntacticPredicateStarted(inputState.guessing);
}
protected void fireSyntacticPredicateSucceeded() {
if (isDebugMode())
parserEventSupport.fireSyntacticPredicateSucceeded(inputState.guessing);
}
public String getRuleName(int num) {
return ruleNames[num];
}
public String getSemPredName(int num) {
return semPredNames[num];
}
public synchronized void goToSleep() {
try {wait();}
catch (InterruptedException e) { }
}
public boolean isDebugMode() {
return !_notDebugMode;
}
public boolean isGuessing() {
return inputState.guessing > 0;
}
/** Return the token type of the ith token of lookahead where i=1
* is the current token being examined by the parser (i.e., it
* has not been matched yet).
*/
public int LA(int i) throws TokenStreamException {
int la = super.LA(i);
parserEventSupport.fireLA(i, la);
return la;
}
/**Make sure current lookahead symbol matches token type t .
* Throw an exception upon mismatch, which is catch by either the
* error handler or by the syntactic predicate.
*/
public void match(int t) throws MismatchedTokenException, TokenStreamException {
String text = LT(1).getText();
int la_1 = LA(1);
try {
super.match(t);
parserEventSupport.fireMatch(t, text, inputState.guessing);
}
catch (MismatchedTokenException e) {
if (inputState.guessing == 0)
parserEventSupport.fireMismatch(la_1, t, text, inputState.guessing);
throw e;
}
}
/**Make sure current lookahead symbol matches the given set
* Throw an exception upon mismatch, which is catch by either the
* error handler or by the syntactic predicate.
*/
public void match(BitSet b) throws MismatchedTokenException, TokenStreamException {
String text = LT(1).getText();
int la_1 = LA(1);
try {
super.match(b);
parserEventSupport.fireMatch(la_1,b, text, inputState.guessing);
}
catch (MismatchedTokenException e) {
if (inputState.guessing == 0)
parserEventSupport.fireMismatch(la_1, b, text, inputState.guessing);
throw e;
}
}
public void matchNot(int t) throws MismatchedTokenException, TokenStreamException {
String text = LT(1).getText();
int la_1 = LA(1);
try {
super.matchNot(t);
parserEventSupport.fireMatchNot(la_1, t, text, inputState.guessing);
}
catch (MismatchedTokenException e) {
if (inputState.guessing == 0)
parserEventSupport.fireMismatchNot(la_1, t, text, inputState.guessing);
throw e;
}
}
public void removeMessageListener(MessageListener l) {
parserEventSupport.removeMessageListener(l);
}
public void removeParserListener(ParserListener l) {
parserEventSupport.removeParserListener(l);
}
public void removeParserMatchListener(ParserMatchListener l) {
parserEventSupport.removeParserMatchListener(l);
}
public void removeParserTokenListener(ParserTokenListener l) {
parserEventSupport.removeParserTokenListener(l);
}
public void removeSemanticPredicateListener(SemanticPredicateListener l) {
parserEventSupport.removeSemanticPredicateListener(l);
}
public void removeSyntacticPredicateListener(SyntacticPredicateListener l) {
parserEventSupport.removeSyntacticPredicateListener(l);
}
public void removeTraceListener(TraceListener l) {
parserEventSupport.removeTraceListener(l);
}
/** Parser error-reporting function can be overridden in subclass */
public void reportError(RecognitionException ex) {
parserEventSupport.fireReportError(ex);
super.reportError(ex);
}
/** Parser error-reporting function can be overridden in subclass */
public void reportError(String s) {
parserEventSupport.fireReportError(s);
super.reportError(s);
}
/** Parser warning-reporting function can be overridden in subclass */
public void reportWarning(String s) {
parserEventSupport.fireReportWarning(s);
super.reportWarning(s);
}
public void setDebugMode(boolean value) {
_notDebugMode = !value;
}
public void setupDebugging(TokenBuffer tokenBuf) {
setupDebugging(null, tokenBuf);
}
public void setupDebugging(TokenStream lexer) {
setupDebugging(lexer, null);
}
/** User can override to do their own debugging */
protected void setupDebugging(TokenStream lexer, TokenBuffer tokenBuf) {
setDebugMode(true);
// default parser debug setup is ParseView
try {
try {
Class.forName("javax.swing.JButton");
}
catch (ClassNotFoundException e) {
System.err.println("Swing is required to use ParseView, but is not present in your CLASSPATH");
System.exit(1);
}
Class c = Class.forName("antlr.parseview.ParseView");
Constructor constructor = c.getConstructor(new Class[] {LLkDebuggingParser.class, TokenStream.class, TokenBuffer.class});
constructor.newInstance(new Object[] {this, lexer, tokenBuf});
}
catch(Exception e) {
System.err.println("Error initializing ParseView: "+e);
System.err.println("Please report this to Scott Stanchfield, [email protected] ");
System.exit(1);
}
}
public synchronized void wakeUp() {
notify();
}
}
