antlr 使用 locals 和 @init @after 的例子

grammar CSV;
@member{

}
@header{
import java.util.*;
}
file
locals [int i=0]
: hdr ( rows+=row[$hdr.text.split(",")] {$i++;} )+

{
System.out.println($i+" rows");
for (RowContext r : $rows) {
System.out.println("row token interval: "+r.getSourceInterval());
}
}
;
hdr : row[null] {System.out.println("header: '"+$text.trim()+"'");} ;

row[String[]columns] returns [Map<String,String> values]
locals [int col=0]

@init{
$values= new HashMap<String,String>();
}

@after {
if ($values!=null && $values.size()>0) {
System.out.println("values = "+$values);
}
}
: field
{
if ($columns!=null) {
$values.put($columns[$col++].trim(), $field.text.trim());
}}(
',' field
{
if ($columns!=null) {
$values.put($columns[$col++].trim(), $field.text.trim());
}}
)* '\r'? '\n'
;

field
: TEXT
| STRING
|
;

TEXT : ~[,\n\r"]+ ;
STRING : '"' ('""'|~'"')* '"' ; // quote-quote is an escaped quote

 

// Generated from E:\资料\开发工具\IdeaProjects\antlr\CSV.g4 by ANTLR 4.1

import java.util.*;

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;

@SuppressWarnings({"all", "warnings", "unchecked", "unused", "cast"})
public class CSVParser extends Parser {
    protected static final DFA[] _decisionToDFA;
    protected static final PredictionContextCache _sharedContextCache =
        new PredictionContextCache();
    public static final int
        T__2=1, T__1=2, T__0=3, TEXT=4, STRING=5;
    public static final String[] tokenNames = {
        "<INVALID>", "','", "'\n'", "'\r'", "TEXT", "STRING"
    };
    public static final int
        RULE_file = 0, RULE_hdr = 1, RULE_row = 2, RULE_field = 3;
    public static final String[] ruleNames = {
        "file", "hdr", "row", "field"
    };

    @Override
    public String getGrammarFileName() { return "CSV.g4"; }

    @Override
    public String[] getTokenNames() { return tokenNames; }

    @Override
    public String[] getRuleNames() { return ruleNames; }

    @Override
    public ATN getATN() { return _ATN; }

    public CSVParser(TokenStream input) {
        super(input);
        _interp = new ParserATNSimulator(this,_ATN,_decisionToDFA,_sharedContextCache);
    }
    public static class FileContext extends ParserRuleContext {
        public int i=0;
        public HdrContext hdr;
        public RowContext row;
        public List<RowContext> rows = new ArrayList<RowContext>();
        public HdrContext hdr() {
            return getRuleContext(HdrContext.class,0);
        }
        public RowContext row(int i) {
            return getRuleContext(RowContext.class,i);
        }
        public List<RowContext> row() {
            return getRuleContexts(RowContext.class);
        }
        public FileContext(ParserRuleContext parent, int invokingState) {
            super(parent, invokingState);
        }
        @Override public int getRuleIndex() { return RULE_file; }
        @Override
        public void enterRule(ParseTreeListener listener) {
            if ( listener instanceof CSVListener ) ((CSVListener)listener).enterFile(this);
        }
        @Override
        public void exitRule(ParseTreeListener listener) {
            if ( listener instanceof CSVListener ) ((CSVListener)listener).exitFile(this);
        }
        @Override
        public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
            if ( visitor instanceof CSVVisitor ) return ((CSVVisitor<? extends T>)visitor).visitFile(this);
            else return visitor.visitChildren(this);
        }
    }

    public final FileContext file() throws RecognitionException {
        FileContext _localctx = new FileContext(_ctx, getState());
        enterRule(_localctx, 0, RULE_file);
        int _la;
        try {
            enterOuterAlt(_localctx, 1);
            {
            setState(8); ((FileContext)_localctx).hdr = hdr();
            setState(12); 
            _errHandler.sync(this);
            _la = _input.LA(1);
            do {
                {
                {
                setState(9); ((FileContext)_localctx).row = row((((FileContext)_localctx).hdr!=null?_input.getText(((FileContext)_localctx).hdr.start,((FileContext)_localctx).hdr.stop):null).split(","));
                ((FileContext)_localctx).rows.add(((FileContext)_localctx).row);
                _localctx.i++;
                }
                }
                setState(14); 
                _errHandler.sync(this);
                _la = _input.LA(1);
            } while ( (((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << 1) | (1L << 2) | (1L << 3) | (1L << TEXT) | (1L << STRING))) != 0) );
//                {
//                    System.out.println($i+" rows");
//                    for (RowContext r : $rows) {
//                        System.out.println("row token interval: "+r.getSourceInterval());
//                    }
//                }
            System.out.println(_localctx.i+" rows");
            for (RowContext r : ((FileContext)_localctx).rows) {
            System.out.println("row token interval: "+r.getSourceInterval());
            }

            }
        }
        catch (RecognitionException re) {
            _localctx.exception = re;
            _errHandler.reportError(this, re);
            _errHandler.recover(this, re);
        }
        finally {
            exitRule();
        }
        return _localctx;
    }

    public static class HdrContext extends ParserRuleContext {
        public RowContext row() {
            return getRuleContext(RowContext.class,0);
        }
        public HdrContext(ParserRuleContext parent, int invokingState) {
            super(parent, invokingState);
        }
        @Override public int getRuleIndex() { return RULE_hdr; }
        @Override
        public void enterRule(ParseTreeListener listener) {
            if ( listener instanceof CSVListener ) ((CSVListener)listener).enterHdr(this);
        }
        @Override
        public void exitRule(ParseTreeListener listener) {
            if ( listener instanceof CSVListener ) ((CSVListener)listener).exitHdr(this);
        }
        @Override
        public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
            if ( visitor instanceof CSVVisitor ) return ((CSVVisitor<? extends T>)visitor).visitHdr(this);
            else return visitor.visitChildren(this);
        }
    }

    public final HdrContext hdr() throws RecognitionException {
        HdrContext _localctx = new HdrContext(_ctx, getState());
        enterRule(_localctx, 2, RULE_hdr);
        try {
            enterOuterAlt(_localctx, 1);
            {
            setState(18); row(null);
            System.out.println("header: '"+_input.getText(_localctx.start, _input.LT(-1)).trim()+"'");
            }
        }
        catch (RecognitionException re) {
            _localctx.exception = re;
            _errHandler.reportError(this, re);
            _errHandler.recover(this, re);
        }
        finally {
            exitRule();
        }
        return _localctx;
    }

    public static class RowContext extends ParserRuleContext {
        public String[]columns;
        public Map<String,String> values;
        public int col=0;
        public FieldContext field;
        public FieldContext field(int i) {
            return getRuleContext(FieldContext.class,i);
        }
        public List<FieldContext> field() {
            return getRuleContexts(FieldContext.class);
        }
        public RowContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); }
        public RowContext(ParserRuleContext parent, int invokingState, String[] columns) {
            super(parent, invokingState);
            this.columns = columns;
        }
        @Override public int getRuleIndex() { return RULE_row; }
        @Override
        public void enterRule(ParseTreeListener listener) {
            if ( listener instanceof CSVListener ) ((CSVListener)listener).enterRow(this);
        }
        @Override
        public void exitRule(ParseTreeListener listener) {
            if ( listener instanceof CSVListener ) ((CSVListener)listener).exitRow(this);
        }
        @Override
        public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
            if ( visitor instanceof CSVVisitor ) return ((CSVVisitor<? extends T>)visitor).visitRow(this);
            else return visitor.visitChildren(this);
        }
    }

    public final RowContext row(String[] columns) throws RecognitionException {
        RowContext _localctx = new RowContext(_ctx, getState(), columns);
        enterRule(_localctx, 4, RULE_row);
/*
 @init{
$values= new HashMap<String,String>();
}
*/
        ((RowContext)_localctx).values =  new HashMap<String,String>();

        int _la;
        try {
            enterOuterAlt(_localctx, 1);
            {
            setState(21); ((RowContext)_localctx).field = field();
//                {
//                    if ($columns!=null) {
//                        $values.put($columns[$col++].trim(), $field.text.trim());
//                    }}
            if (_localctx.columns!=null) {
            _localctx.values.put(_localctx.columns[_localctx.col++].trim(),
                    (((RowContext)_localctx).field!=null?_input.getText(((RowContext)_localctx).field.start,
                            ((RowContext)_localctx).field.stop):null).trim());
            }
            setState(29);
            _errHandler.sync(this);
            _la = _input.LA(1);
            while (_la==1) {
                {
                {
                setState(23); match(1);
                setState(24); ((RowContext)_localctx).field = field();
//                    {
//                        if ($columns!=null) {
//                            $values.put($columns[$col++].trim(), $field.text.trim());
//                        }}
                if (_localctx.columns!=null) {
                _localctx.values.put(_localctx.columns[_localctx.col++].trim(), (((RowContext)_localctx).field!=null?_input.getText(((RowContext)_localctx).field.start,((RowContext)_localctx).field.stop):null).trim());
                }
                }
                }
                setState(31);
                _errHandler.sync(this);
                _la = _input.LA(1);
            }
            setState(33);
            _la = _input.LA(1);
            if (_la==3) {
                {
                setState(32); match(3);
                }
            }

            setState(35); match(2);
            }
           /*
            @after {
                if ($values!=null && $values.size()>0) {
                    System.out.println("values = "+$values);
                }

                */
            if (_localctx.values!=null && _localctx.values.size()>0) {
            System.out.println("values = "+_localctx.values);
            }

        }
        catch (RecognitionException re) {
            _localctx.exception = re;
            _errHandler.reportError(this, re);
            _errHandler.recover(this, re);
        }
        finally {
            exitRule();
        }
        return _localctx;
    }

    public static class FieldContext extends ParserRuleContext {
        public TerminalNode TEXT() { return getToken(CSVParser.TEXT, 0); }
        public TerminalNode STRING() { return getToken(CSVParser.STRING, 0); }
        public FieldContext(ParserRuleContext parent, int invokingState) {
            super(parent, invokingState);
        }
        @Override public int getRuleIndex() { return RULE_field; }
        @Override
        public void enterRule(ParseTreeListener listener) {
            if ( listener instanceof CSVListener ) ((CSVListener)listener).enterField(this);
        }
        @Override
        public void exitRule(ParseTreeListener listener) {
            if ( listener instanceof CSVListener ) ((CSVListener)listener).exitField(this);
        }
        @Override
        public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
            if ( visitor instanceof CSVVisitor ) return ((CSVVisitor<? extends T>)visitor).visitField(this);
            else return visitor.visitChildren(this);
        }
    }

    public final FieldContext field() throws RecognitionException {
        FieldContext _localctx = new FieldContext(_ctx, getState());
        enterRule(_localctx, 6, RULE_field);
        try {
            setState(40);
            switch (_input.LA(1)) {
            case TEXT:
                enterOuterAlt(_localctx, 1);
                {
                setState(37); match(TEXT);
                }
                break;
            case STRING:
                enterOuterAlt(_localctx, 2);
                {
                setState(38); match(STRING);
                }
                break;
            case 1:
            case 2:
            case 3:
                enterOuterAlt(_localctx, 3);
                {
                }
                break;
            default:
                throw new NoViableAltException(this);
            }
        }
        catch (RecognitionException re) {
            _localctx.exception = re;
            _errHandler.reportError(this, re);
            _errHandler.recover(this, re);
        }
        finally {
            exitRule();
        }
        return _localctx;
    }

    public static final String _serializedATN =
        "\3\uacf5\uee8c\u4f5d\u8b0d\u4a45\u78bd\u1b2f\u3378\3\7-\4\2\t\2\4\3\t"+
        "\3\4\4\t\4\4\5\t\5\3\2\3\2\3\2\3\2\6\2\17\n\2\r\2\16\2\20\3\2\3\2\3\3"+
        "\3\3\3\3\3\4\3\4\3\4\3\4\3\4\3\4\7\4\36\n\4\f\4\16\4!\13\4\3\4\5\4$\n"+
        "\4\3\4\3\4\3\5\3\5\3\5\5\5+\n\5\3\5\2\6\2\4\6\b\2\2-\2\n\3\2\2\2\4\24"+
        "\3\2\2\2\6\27\3\2\2\2\b*\3\2\2\2\n\16\5\4\3\2\13\f\5\6\4\2\f\r\b\2\1\2"+
        "\r\17\3\2\2\2\16\13\3\2\2\2\17\20\3\2\2\2\20\16\3\2\2\2\20\21\3\2\2\2"+
        "\21\22\3\2\2\2\22\23\b\2\1\2\23\3\3\2\2\2\24\25\5\6\4\2\25\26\b\3\1\2"+
        "\26\5\3\2\2\2\27\30\5\b\5\2\30\37\b\4\1\2\31\32\7\3\2\2\32\33\5\b\5\2"+
        "\33\34\b\4\1\2\34\36\3\2\2\2\35\31\3\2\2\2\36!\3\2\2\2\37\35\3\2\2\2\37"+
        " \3\2\2\2 #\3\2\2\2!\37\3\2\2\2\"$\7\5\2\2#\"\3\2\2\2#$\3\2\2\2$%\3\2"+
        "\2\2%&\7\4\2\2&\7\3\2\2\2\'+\7\6\2\2(+\7\7\2\2)+\3\2\2\2*\'\3\2\2\2*("+
        "\3\2\2\2*)\3\2\2\2+\t\3\2\2\2\6\20\37#*";
    public static final ATN _ATN =
        ATNSimulator.deserialize(_serializedATN.toCharArray());
    static {
        _decisionToDFA = new DFA[_ATN.getNumberOfDecisions()];
        for (int i = 0; i < _ATN.getNumberOfDecisions(); i++) {
            _decisionToDFA[i] = new DFA(_ATN.getDecisionState(i), i);
        }
    }
}