org.antlr.runtime.BaseRecognizer Java Examples

/**
 * {@inheritDoc}
 */
@Override
public void syntaxError(BaseRecognizer recognizer, String[] tokenNames, RecognitionException e)
{
    String hdr = recognizer.getErrorHeader(e);
    String msg = recognizer.getErrorMessage(e, tokenNames);

    StringBuilder builder = new StringBuilder().append(hdr)
            .append(' ')
            .append(msg);

    if (recognizer instanceof Parser)
        appendQuerySnippet((Parser) recognizer, builder);

    errorMsgs.add(builder.toString());
}
 

public DFA21(BaseRecognizer recognizer) {
    this.recognizer = recognizer;
    this.decisionNumber = 21;
    this.eot = DFA21_eot;
    this.eof = DFA21_eof;
    this.min = DFA21_min;
    this.max = DFA21_max;
    this.accept = DFA21_accept;
    this.special = DFA21_special;
    this.transition = DFA21_transition;
}
 

public DFA19( BaseRecognizer recognizer ) {
    this.recognizer = recognizer;
    this.decisionNumber = 19;
    this.eot = DFA19_eot;
    this.eof = DFA19_eof;
    this.min = DFA19_min;
    this.max = DFA19_max;
    this.accept = DFA19_accept;
    this.special = DFA19_special;
    this.transition = DFA19_transition;
}
 

public DFA11( BaseRecognizer recognizer ) {
    this.recognizer = recognizer;
    this.decisionNumber = 11;
    this.eot = DFA11_eot;
    this.eof = DFA11_eof;
    this.min = DFA11_min;
    this.max = DFA11_max;
    this.accept = DFA11_accept;
    this.special = DFA11_special;
    this.transition = DFA11_transition;
}
 

private static void checkError(BaseRecognizer recognizer)
        throws ParserException {
    int errorCount = recognizer.getNumberOfSyntaxErrors();
    if (0 < errorCount)
        throw new ParserException("Encountered " + errorCount
                + " parsing errors in the query");
}
 

/**
 * Format an error message as expected by ANTLR. It is basically the
 * same error message that ANTL BaseRecognizer generates with some
 * additional data.
 * Also used to log debugging information.
 * @param log the logger to use at debug time
 * @param recognizer the lexer or parser who generated the error
 * @param e the exception that occured
 * @param superMessage the error message that the super class generated
 * @param tokenNames list of token names
 * @return a formatted error message
 */
public static String getErrorMessage(
        final Logger log,
        final BaseRecognizer recognizer,
        final RecognitionException e,
        final String superMessage,
        final String[] tokenNames) {
    if (log.isDebugEnabled()) {
        List < ? > stack = BaseRecognizer.getRuleInvocationStack(
                e, recognizer.getClass().getSuperclass().getName());
        String debugMsg = recognizer.getErrorHeader(e)
            + " " + e.getClass().getSimpleName()
            + ": " + superMessage
            + ":";
        if (e instanceof NoViableAltException) {
            NoViableAltException nvae = (NoViableAltException) e;
            debugMsg += " (decision=" + nvae.decisionNumber
            + " state=" + nvae.stateNumber + ")"
            + " decision=<<" + nvae.grammarDecisionDescription + ">>";
        } else if (e instanceof UnwantedTokenException) {
            UnwantedTokenException ute = (UnwantedTokenException) e;
            debugMsg += " (unexpected token=" + toString(ute.getUnexpectedToken(), tokenNames) + ")";

        } else if (e instanceof EarlyExitException) {
            EarlyExitException eea = (EarlyExitException) e;
            debugMsg += " (decision=" + eea.decisionNumber + ")";
        }
        debugMsg += " ruleStack=" + stack.toString();
        log.debug(debugMsg);
    }

    return makeUserMsg(e, superMessage);
}
 

public DFA24(BaseRecognizer recognizer) {
    this.recognizer = recognizer;
    this.decisionNumber = 24;
    this.eot = DFA24_eot;
    this.eof = DFA24_eof;
    this.min = DFA24_min;
    this.max = DFA24_max;
    this.accept = DFA24_accept;
    this.special = DFA24_special;
    this.transition = DFA24_transition;
}
 

public DFA16(BaseRecognizer recognizer) {
	this.recognizer = recognizer;
	this.decisionNumber = 16;
	this.eot = DFA16_eot;
	this.eof = DFA16_eof;
	this.min = DFA16_min;
	this.max = DFA16_max;
	this.accept = DFA16_accept;
	this.special = DFA16_special;
	this.transition = DFA16_transition;
}
 

public DFA5(BaseRecognizer recognizer) {
    this.recognizer = recognizer;
    this.decisionNumber = 5;
    this.eot = DFA5_eot;
    this.eof = DFA5_eof;
    this.min = DFA5_min;
    this.max = DFA5_max;
    this.accept = DFA5_accept;
    this.special = DFA5_special;
    this.transition = DFA5_transition;
}
 

public DFA5(BaseRecognizer recognizer) {
    this.recognizer = recognizer;
    this.decisionNumber = 5;
    this.eot = DFA5_eot;
    this.eof = DFA5_eof;
    this.min = DFA5_min;
    this.max = DFA5_max;
    this.accept = DFA5_accept;
    this.special = DFA5_special;
    this.transition = DFA5_transition;
}
 

public DFA1(final BaseRecognizer recognizer) {
  this.recognizer = recognizer;
  this.decisionNumber = 1;
  this.eot = DFA1_eot;
  this.eof = DFA1_eof;
  this.min = DFA1_min;
  this.max = DFA1_max;
  this.accept = DFA1_accept;
  this.special = DFA1_special;
  this.transition = DFA1_transition;
}
 

public DFA32(BaseRecognizer recognizer) {
	this.recognizer = recognizer;
	this.decisionNumber = 32;
	this.eot = DFA32_eot;
	this.eof = DFA32_eof;
	this.min = DFA32_min;
	this.max = DFA32_max;
	this.accept = DFA32_accept;
	this.special = DFA32_special;
	this.transition = DFA32_transition;
}
 

public DFA4(final BaseRecognizer recognizer) {
  this.recognizer = recognizer;
  decisionNumber = 4;
  eot = DFA4_eot;
  eof = DFA4_eof;
  min = DFA4_min;
  max = DFA4_max;
  accept = DFA4_accept;
  special = DFA4_special;
  transition = DFA4_transition;
}
 

public DFA4(final BaseRecognizer recognizer) {
  this.recognizer = recognizer;
  decisionNumber = 4;
  eot = DFA4_eot;
  eof = DFA4_eof;
  min = DFA4_min;
  max = DFA4_max;
  accept = DFA4_accept;
  special = DFA4_special;
  transition = DFA4_transition;
}
 

public DFA30(BaseRecognizer recognizer) {
	this.recognizer = recognizer;
	this.decisionNumber = 30;
	this.eot = DFA30_eot;
	this.eof = DFA30_eof;
	this.min = DFA30_min;
	this.max = DFA30_max;
	this.accept = DFA30_accept;
	this.special = DFA30_special;
	this.transition = DFA30_transition;
}
 

@Override
public void initializeWith(BaseRecognizer recognizer) {
	helper.initializeWith(recognizer);
}
 

protected BaseRecognizer getRecognizer() {
	return recognizer;
}
 

@Override
public void initializeWith(BaseRecognizer recognizer) {
	this.recognizer = recognizer;
}
 

/**
 * {@inheritDoc}
 */
@Override
public void syntaxError(BaseRecognizer recognizer, String errorMsg)
{
    errorMsgs.add(errorMsg);
}
 

@Override
public void syntaxError(BaseRecognizer recognizer, String[] tokenNames, RecognitionException e)
{
    count++;
}
 

@Override
public void syntaxError(BaseRecognizer recognizer, String errorMsg)
{
    count++;
}
 

@Override
public void initializeWith(BaseRecognizer recognizer) {
	// ignore
}
 

public ParsingFailureException(Class<? extends BaseRecognizer> clazz) {
    super( "Parsing failures dected by " + clazz.getSimpleName() );
    this.parsingClass = clazz;
}
 

public Class<? extends BaseRecognizer> getParsingClass() {
    return parsingClass;
}
 

/**
 * Invoked when a syntax error occurs.
 *
 * @param recognizer the parser or lexer that emitted the error
 * @param tokenNames the token names
 * @param e the exception
 */
void syntaxError(BaseRecognizer recognizer, String[] tokenNames, RecognitionException e);
 

/**
 * Invoked when a syntax error with a specified message occurs.
 *
 * @param recognizer the parser or lexer that emitted the error
 * @param errorMsg the error message
 */
void syntaxError(BaseRecognizer recognizer, String errorMsg);
 

/**
 * Initializes this helper with the given recognizer.
 */
void initializeWith(BaseRecognizer recognizer);