OKW_Parser.cs

//------------------------------------------------------------------------------
// <auto-generated>
//     This code was generated by a tool.
//     ANTLR Version: 4.3
//
//     Changes to this file may cause incorrect behavior and will be lost if
//     the code is regenerated.
// </auto-generated>
//------------------------------------------------------------------------------

// Generated from C:\GIT\okw\OKWANTL\OKW_Parser.g4 by ANTLR 4.3

// Unreachable code detected
#pragma warning disable 0162
// The variable '...' is assigned but its value is never used
#pragma warning disable 0219
// Missing XML comment for publicly visible type or member '...'
#pragma warning disable 1591

namespace OKW.ANTLR4 {
using Antlr4.Runtime;
using Antlr4.Runtime.Atn;
using Antlr4.Runtime.Misc;
using Antlr4.Runtime.Tree;
using System.Collections.Generic;
using DFA = Antlr4.Runtime.Dfa.DFA;

[System.CodeDom.Compiler.GeneratedCode("ANTLR", "4.3")]
[System.CLSCompliant(false)]
public partial class OKW_Parser : Parser {
    public const int
        KLAMMERZU=4, ENVVAL=15, WS=3, FOLDER_LOGMESSAGES=5, FILE_OKW_KEYMAPS_XML=11, 
        FILE_OKW_MEMORIZE_XML=12, FOLDER_XML=6, FILE_OKW_CONST_XML=7, VALUE=16, 
        TEXT=2, FILE_OKW_INI_XML=10, KEYVALUE=14, FILE_OKW_IMPLEMENTATIONMATRIX_XML=9, 
        KLAMMERAUF=1, KEYPREFIX=13, FILE_OKW_DOCU_XML=8;
    public static readonly string[] tokenNames = {
        "<INVALID>", "'${'", "TEXT", "WS", "'}'", "'Folder_LogMessages'", "'Folder_XML'", 
        "'File_OKW_Const_xml'", "'File_OKW_Docu_xml'", "'File_OKW_ImplementationMatrix_xml'", 
        "'File_OKW_Ini_xml'", "'File_OKW_Keymaps_xml'", "'File_OKW_Memorize_xml'", 
        "'Taste.'", "KEYVALUE", "ENVVAL", "VALUE"
    };
    public const int
        RULE_root = 0, RULE_okw_internal_var = 1, RULE_okw_typekey = 2, RULE_keyvalue = 3, 
        RULE_okw_env_var = 4, RULE_envvalue = 5, RULE_text = 6;
    public static readonly string[] ruleNames = {
        "root", "okw_internal_var", "okw_typekey", "keyvalue", "okw_env_var", 
        "envvalue", "text"
    };

    public override string GrammarFileName { get { return "OKW_Parser.g4"; } }

    public override string[] TokenNames { get { return tokenNames; } }

    public override string[] RuleNames { get { return ruleNames; } }

    public override string SerializedAtn { get { return _serializedATN; } }

    public OKW_Parser(ITokenStream input)
        : base(input)
    {
        _interp = new ParserATNSimulator(this,_ATN);
    }
    public partial class RootContext : ParserRuleContext {
        public IReadOnlyList<TextContext> text() {
            return GetRuleContexts<TextContext>();
        }
        public IReadOnlyList<Okw_internal_varContext> okw_internal_var() {
            return GetRuleContexts<Okw_internal_varContext>();
        }
        public Okw_typekeyContext okw_typekey(int i) {
            return GetRuleContext<Okw_typekeyContext>(i);
        }
        public TextContext text(int i) {
            return GetRuleContext<TextContext>(i);
        }
        public IReadOnlyList<Okw_env_varContext> okw_env_var() {
            return GetRuleContexts<Okw_env_varContext>();
        }
        public Okw_internal_varContext okw_internal_var(int i) {
            return GetRuleContext<Okw_internal_varContext>(i);
        }
        public Okw_env_varContext okw_env_var(int i) {
            return GetRuleContext<Okw_env_varContext>(i);
        }
        public IReadOnlyList<Okw_typekeyContext> okw_typekey() {
            return GetRuleContexts<Okw_typekeyContext>();
        }
        public RootContext(ParserRuleContext parent, int invokingState)
            : base(parent, invokingState)
        {
        }
        public override int RuleIndex { get { return RULE_root; } }
        public override void EnterRule(IParseTreeListener listener) {
            IOKW_ParserListener typedListener = listener as IOKW_ParserListener;
            if (typedListener != null) typedListener.EnterRoot(this);
        }
        public override void ExitRule(IParseTreeListener listener) {
            IOKW_ParserListener typedListener = listener as IOKW_ParserListener;
            if (typedListener != null) typedListener.ExitRoot(this);
        }
        public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
            IOKW_ParserVisitor<TResult> typedVisitor = visitor as IOKW_ParserVisitor<TResult>;
            if (typedVisitor != null) return typedVisitor.VisitRoot(this);
            else return visitor.VisitChildren(this);
        }
    }

    [RuleVersion(0)]
    public RootContext root() {
        RootContext _localctx = new RootContext(_ctx, State);
        EnterRule(_localctx, 0, RULE_root);
        int _la;
        try {
            EnterOuterAlt(_localctx, 1);
            {
            State = 18;
            _errHandler.Sync(this);
            _la = _input.La(1);
            do {
                {
                State = 18;
                switch ( Interpreter.AdaptivePredict(_input,0,_ctx) ) {
                case 1:
                    {
                    State = 14; okw_internal_var();
                    }
                    break;

                case 2:
                    {
                    State = 15; okw_env_var();
                    }
                    break;

                case 3:
                    {
                    State = 16; okw_typekey();
                    }
                    break;

                case 4:
                    {
                    State = 17; text();
                    }
                    break;
                }
                }
                State = 20;
                _errHandler.Sync(this);
                _la = _input.La(1);
            } while ( _la==KLAMMERAUF || _la==TEXT );
            }
        }
        catch (RecognitionException re) {
            _localctx.exception = re;
            _errHandler.ReportError(this, re);
            _errHandler.Recover(this, re);
        }
        finally {
            ExitRule();
        }
        return _localctx;
    }

    public partial class Okw_internal_varContext : ParserRuleContext {
        public ITerminalNode FOLDER_XML() { return GetToken(OKW_Parser.FOLDER_XML, 0); }
        public ITerminalNode FILE_OKW_INI_XML() { return GetToken(OKW_Parser.FILE_OKW_INI_XML, 0); }
        public ITerminalNode FILE_OKW_KEYMAPS_XML() { return GetToken(OKW_Parser.FILE_OKW_KEYMAPS_XML, 0); }
        public ITerminalNode FILE_OKW_DOCU_XML() { return GetToken(OKW_Parser.FILE_OKW_DOCU_XML, 0); }
        public ITerminalNode FILE_OKW_MEMORIZE_XML() { return GetToken(OKW_Parser.FILE_OKW_MEMORIZE_XML, 0); }
        public ITerminalNode KLAMMERAUF() { return GetToken(OKW_Parser.KLAMMERAUF, 0); }
        public ITerminalNode FILE_OKW_CONST_XML() { return GetToken(OKW_Parser.FILE_OKW_CONST_XML, 0); }
        public ITerminalNode FOLDER_LOGMESSAGES() { return GetToken(OKW_Parser.FOLDER_LOGMESSAGES, 0); }
        public ITerminalNode KLAMMERZU() { return GetToken(OKW_Parser.KLAMMERZU, 0); }
        public ITerminalNode FILE_OKW_IMPLEMENTATIONMATRIX_XML() { return GetToken(OKW_Parser.FILE_OKW_IMPLEMENTATIONMATRIX_XML, 0); }
        public Okw_internal_varContext(ParserRuleContext parent, int invokingState)
            : base(parent, invokingState)
        {
        }
        public override int RuleIndex { get { return RULE_okw_internal_var; } }
        public override void EnterRule(IParseTreeListener listener) {
            IOKW_ParserListener typedListener = listener as IOKW_ParserListener;
            if (typedListener != null) typedListener.EnterOkw_internal_var(this);
        }
        public override void ExitRule(IParseTreeListener listener) {
            IOKW_ParserListener typedListener = listener as IOKW_ParserListener;
            if (typedListener != null) typedListener.ExitOkw_internal_var(this);
        }
        public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
            IOKW_ParserVisitor<TResult> typedVisitor = visitor as IOKW_ParserVisitor<TResult>;
            if (typedVisitor != null) return typedVisitor.VisitOkw_internal_var(this);
            else return visitor.VisitChildren(this);
        }
    }

    [RuleVersion(0)]
    public Okw_internal_varContext okw_internal_var() {
        Okw_internal_varContext _localctx = new Okw_internal_varContext(_ctx, State);
        EnterRule(_localctx, 2, RULE_okw_internal_var);
        int _la;
        try {
            EnterOuterAlt(_localctx, 1);
            {
            State = 22; Match(KLAMMERAUF);
            State = 23;
            _la = _input.La(1);
            if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << FOLDER_LOGMESSAGES) | (1L << FOLDER_XML) | (1L << FILE_OKW_CONST_XML) | (1L << FILE_OKW_DOCU_XML) | (1L << FILE_OKW_IMPLEMENTATIONMATRIX_XML) | (1L << FILE_OKW_INI_XML) | (1L << FILE_OKW_KEYMAPS_XML) | (1L << FILE_OKW_MEMORIZE_XML))) != 0)) ) {
            _errHandler.RecoverInline(this);
            }
            Consume();
            State = 24; Match(KLAMMERZU);
            }
        }
        catch (RecognitionException re) {
            _localctx.exception = re;
            _errHandler.ReportError(this, re);
            _errHandler.Recover(this, re);
        }
        finally {
            ExitRule();
        }
        return _localctx;
    }

    public partial class Okw_typekeyContext : ParserRuleContext {
        public ITerminalNode KLAMMERAUF() { return GetToken(OKW_Parser.KLAMMERAUF, 0); }
        public ITerminalNode KEYPREFIX() { return GetToken(OKW_Parser.KEYPREFIX, 0); }
        public ITerminalNode KLAMMERZU() { return GetToken(OKW_Parser.KLAMMERZU, 0); }
        public KeyvalueContext keyvalue() {
            return GetRuleContext<KeyvalueContext>(0);
        }
        public Okw_typekeyContext(ParserRuleContext parent, int invokingState)
            : base(parent, invokingState)
        {
        }
        public override int RuleIndex { get { return RULE_okw_typekey; } }
        public override void EnterRule(IParseTreeListener listener) {
            IOKW_ParserListener typedListener = listener as IOKW_ParserListener;
            if (typedListener != null) typedListener.EnterOkw_typekey(this);
        }
        public override void ExitRule(IParseTreeListener listener) {
            IOKW_ParserListener typedListener = listener as IOKW_ParserListener;
            if (typedListener != null) typedListener.ExitOkw_typekey(this);
        }
        public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
            IOKW_ParserVisitor<TResult> typedVisitor = visitor as IOKW_ParserVisitor<TResult>;
            if (typedVisitor != null) return typedVisitor.VisitOkw_typekey(this);
            else return visitor.VisitChildren(this);
        }
    }

    [RuleVersion(0)]
    public Okw_typekeyContext okw_typekey() {
        Okw_typekeyContext _localctx = new Okw_typekeyContext(_ctx, State);
        EnterRule(_localctx, 4, RULE_okw_typekey);
        try {
            EnterOuterAlt(_localctx, 1);
            {
            State = 26; Match(KLAMMERAUF);
            State = 27; Match(KEYPREFIX);
            State = 28; keyvalue();
            State = 29; Match(KLAMMERZU);
            }
        }
        catch (RecognitionException re) {
            _localctx.exception = re;
            _errHandler.ReportError(this, re);
            _errHandler.Recover(this, re);
        }
        finally {
            ExitRule();
        }
        return _localctx;
    }

    public partial class KeyvalueContext : ParserRuleContext {
        public ITerminalNode KEYVALUE() { return GetToken(OKW_Parser.KEYVALUE, 0); }
        public KeyvalueContext(ParserRuleContext parent, int invokingState)
            : base(parent, invokingState)
        {
        }
        public override int RuleIndex { get { return RULE_keyvalue; } }
        public override void EnterRule(IParseTreeListener listener) {
            IOKW_ParserListener typedListener = listener as IOKW_ParserListener;
            if (typedListener != null) typedListener.EnterKeyvalue(this);
        }
        public override void ExitRule(IParseTreeListener listener) {
            IOKW_ParserListener typedListener = listener as IOKW_ParserListener;
            if (typedListener != null) typedListener.ExitKeyvalue(this);
        }
        public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
            IOKW_ParserVisitor<TResult> typedVisitor = visitor as IOKW_ParserVisitor<TResult>;
            if (typedVisitor != null) return typedVisitor.VisitKeyvalue(this);
            else return visitor.VisitChildren(this);
        }
    }

    [RuleVersion(0)]
    public KeyvalueContext keyvalue() {
        KeyvalueContext _localctx = new KeyvalueContext(_ctx, State);
        EnterRule(_localctx, 6, RULE_keyvalue);
        try {
            EnterOuterAlt(_localctx, 1);
            {
            State = 31; Match(KEYVALUE);
            }
        }
        catch (RecognitionException re) {
            _localctx.exception = re;
            _errHandler.ReportError(this, re);
            _errHandler.Recover(this, re);
        }
        finally {
            ExitRule();
        }
        return _localctx;
    }

    public partial class Okw_env_varContext : ParserRuleContext {
        public EnvvalueContext envvalue() {
            return GetRuleContext<EnvvalueContext>(0);
        }
        public ITerminalNode KLAMMERAUF() { return GetToken(OKW_Parser.KLAMMERAUF, 0); }
        public ITerminalNode KLAMMERZU() { return GetToken(OKW_Parser.KLAMMERZU, 0); }
        public Okw_env_varContext(ParserRuleContext parent, int invokingState)
            : base(parent, invokingState)
        {
        }
        public override int RuleIndex { get { return RULE_okw_env_var; } }
        public override void EnterRule(IParseTreeListener listener) {
            IOKW_ParserListener typedListener = listener as IOKW_ParserListener;
            if (typedListener != null) typedListener.EnterOkw_env_var(this);
        }
        public override void ExitRule(IParseTreeListener listener) {
            IOKW_ParserListener typedListener = listener as IOKW_ParserListener;
            if (typedListener != null) typedListener.ExitOkw_env_var(this);
        }
        public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
            IOKW_ParserVisitor<TResult> typedVisitor = visitor as IOKW_ParserVisitor<TResult>;
            if (typedVisitor != null) return typedVisitor.VisitOkw_env_var(this);
            else return visitor.VisitChildren(this);
        }
    }

    [RuleVersion(0)]
    public Okw_env_varContext okw_env_var() {
        Okw_env_varContext _localctx = new Okw_env_varContext(_ctx, State);
        EnterRule(_localctx, 8, RULE_okw_env_var);
        try {
            EnterOuterAlt(_localctx, 1);
            {
            State = 33; Match(KLAMMERAUF);
            State = 34; envvalue();
            State = 35; Match(KLAMMERZU);
            }
        }
        catch (RecognitionException re) {
            _localctx.exception = re;
            _errHandler.ReportError(this, re);
            _errHandler.Recover(this, re);
        }
        finally {
            ExitRule();
        }
        return _localctx;
    }

    public partial class EnvvalueContext : ParserRuleContext {
        public ITerminalNode ENVVAL() { return GetToken(OKW_Parser.ENVVAL, 0); }
        public EnvvalueContext(ParserRuleContext parent, int invokingState)
            : base(parent, invokingState)
        {
        }
        public override int RuleIndex { get { return RULE_envvalue; } }
        public override void EnterRule(IParseTreeListener listener) {
            IOKW_ParserListener typedListener = listener as IOKW_ParserListener;
            if (typedListener != null) typedListener.EnterEnvvalue(this);
        }
        public override void ExitRule(IParseTreeListener listener) {
            IOKW_ParserListener typedListener = listener as IOKW_ParserListener;
            if (typedListener != null) typedListener.ExitEnvvalue(this);
        }
        public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
            IOKW_ParserVisitor<TResult> typedVisitor = visitor as IOKW_ParserVisitor<TResult>;
            if (typedVisitor != null) return typedVisitor.VisitEnvvalue(this);
            else return visitor.VisitChildren(this);
        }
    }

    [RuleVersion(0)]
    public EnvvalueContext envvalue() {
        EnvvalueContext _localctx = new EnvvalueContext(_ctx, State);
        EnterRule(_localctx, 10, RULE_envvalue);
        try {
            EnterOuterAlt(_localctx, 1);
            {
            State = 37; Match(ENVVAL);
            }
        }
        catch (RecognitionException re) {
            _localctx.exception = re;
            _errHandler.ReportError(this, re);
            _errHandler.Recover(this, re);
        }
        finally {
            ExitRule();
        }
        return _localctx;
    }

    public partial class TextContext : ParserRuleContext {
        public ITerminalNode TEXT() { return GetToken(OKW_Parser.TEXT, 0); }
        public TextContext(ParserRuleContext parent, int invokingState)
            : base(parent, invokingState)
        {
        }
        public override int RuleIndex { get { return RULE_text; } }
        public override void EnterRule(IParseTreeListener listener) {
            IOKW_ParserListener typedListener = listener as IOKW_ParserListener;
            if (typedListener != null) typedListener.EnterText(this);
        }
        public override void ExitRule(IParseTreeListener listener) {
            IOKW_ParserListener typedListener = listener as IOKW_ParserListener;
            if (typedListener != null) typedListener.ExitText(this);
        }
        public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
            IOKW_ParserVisitor<TResult> typedVisitor = visitor as IOKW_ParserVisitor<TResult>;
            if (typedVisitor != null) return typedVisitor.VisitText(this);
            else return visitor.VisitChildren(this);
        }
    }

    [RuleVersion(0)]
    public TextContext text() {
        TextContext _localctx = new TextContext(_ctx, State);
        EnterRule(_localctx, 12, RULE_text);
        try {
            EnterOuterAlt(_localctx, 1);
            {
            State = 39; Match(TEXT);
            }
        }
        catch (RecognitionException re) {
            _localctx.exception = re;
            _errHandler.ReportError(this, re);
            _errHandler.Recover(this, re);
        }
        finally {
            ExitRule();
        }
        return _localctx;
    }

    public static readonly string _serializedATN =
        "\x3\xAF6F\x8320\x479D\xB75C\x4880\x1605\x191C\xAB37\x3\x12,\x4\x2\t\x2"+
        "\x4\x3\t\x3\x4\x4\t\x4\x4\x5\t\x5\x4\x6\t\x6\x4\a\t\a\x4\b\t\b\x3\x2\x3"+
        "\x2\x3\x2\x3\x2\x6\x2\x15\n\x2\r\x2\xE\x2\x16\x3\x3\x3\x3\x3\x3\x3\x3"+
        "\x3\x4\x3\x4\x3\x4\x3\x4\x3\x4\x3\x5\x3\x5\x3\x6\x3\x6\x3\x6\x3\x6\x3"+
        "\a\x3\a\x3\b\x3\b\x3\b\x2\x2\x2\t\x2\x2\x4\x2\x6\x2\b\x2\n\x2\f\x2\xE"+
        "\x2\x2\x3\x3\x2\a\xE(\x2\x14\x3\x2\x2\x2\x4\x18\x3\x2\x2\x2\x6\x1C\x3"+
        "\x2\x2\x2\b!\x3\x2\x2\x2\n#\x3\x2\x2\x2\f\'\x3\x2\x2\x2\xE)\x3\x2\x2\x2"+
        "\x10\x15\x5\x4\x3\x2\x11\x15\x5\n\x6\x2\x12\x15\x5\x6\x4\x2\x13\x15\x5"+
        "\xE\b\x2\x14\x10\x3\x2\x2\x2\x14\x11\x3\x2\x2\x2\x14\x12\x3\x2\x2\x2\x14"+
        "\x13\x3\x2\x2\x2\x15\x16\x3\x2\x2\x2\x16\x14\x3\x2\x2\x2\x16\x17\x3\x2"+
        "\x2\x2\x17\x3\x3\x2\x2\x2\x18\x19\a\x3\x2\x2\x19\x1A\t\x2\x2\x2\x1A\x1B"+
        "\a\x6\x2\x2\x1B\x5\x3\x2\x2\x2\x1C\x1D\a\x3\x2\x2\x1D\x1E\a\xF\x2\x2\x1E"+
        "\x1F\x5\b\x5\x2\x1F \a\x6\x2\x2 \a\x3\x2\x2\x2!\"\a\x10\x2\x2\"\t\x3\x2"+
        "\x2\x2#$\a\x3\x2\x2$%\x5\f\a\x2%&\a\x6\x2\x2&\v\x3\x2\x2\x2\'(\a\x11\x2"+
        "\x2(\r\x3\x2\x2\x2)*\a\x4\x2\x2*\xF\x3\x2\x2\x2\x4\x14\x16";
    public static readonly ATN _ATN =
        new ATNDeserializer().Deserialize(_serializedATN.ToCharArray());
}
} // namespace OKW.ANTLR4