// Generated from STEP.g4 by ANTLR 4.5.1
package parser // STEP

import (
    "antlr4"
    "reflect"
    "fmt"
    "strconv"
)

// Stopgap to suppress unused import error. We aren't certain
// to have these imports used in the generated code below

var _ = fmt.Printf
var _ = reflect.Copy
var _ = strconv.Itoa


var parserATN = []uint16{ 3,1072,54993,33286,44333,17431,44785,36224,43741,
    3,16,38,4,2,9,2,4,3,9,3,4,4,9,4,3,2,3,2,3,2,3,2,3,2,3,2,3,3,3,3,3,3,
    3,3,3,3,7,3,20,10,3,12,3,14,3,23,11,3,3,3,3,3,5,3,27,10,3,3,4,3,4,3,
    4,3,4,3,4,3,4,3,4,5,4,36,10,4,3,4,2,2,5,2,4,6,2,2,42,2,8,3,2,2,2,4,26,
    3,2,2,2,6,35,3,2,2,2,8,9,7,9,2,2,9,10,7,3,2,2,10,11,7,10,2,2,11,12,5,
    4,3,2,12,13,7,4,2,2,13,3,3,2,2,2,14,27,7,5,2,2,15,16,7,6,2,2,16,21,5,
    6,4,2,17,18,7,7,2,2,18,20,5,6,4,2,19,17,3,2,2,2,20,23,3,2,2,2,21,19,
    3,2,2,2,21,22,3,2,2,2,22,24,3,2,2,2,23,21,3,2,2,2,24,25,7,8,2,2,25,27,
    3,2,2,2,26,14,3,2,2,2,26,15,3,2,2,2,27,5,3,2,2,2,28,36,7,11,2,2,29,36,
    7,12,2,2,30,36,7,13,2,2,31,36,7,14,2,2,32,36,7,15,2,2,33,36,7,9,2,2,
    34,36,5,4,3,2,35,28,3,2,2,2,35,29,3,2,2,2,35,30,3,2,2,2,35,31,3,2,2,
    2,35,32,3,2,2,2,35,33,3,2,2,2,35,34,3,2,2,2,36,7,3,2,2,2,5,21,26,35, }

var deserializer = antlr4.NewATNDeserializer(nil)
var deserializedATN = deserializer.DeserializeFromUInt16( parserATN )

var literalNames = []string{ "", "'='", "';'", "'()'", "'('", "','", "')'" }
var symbolicNames = []string{ "", "", "", "", "", "", "", "Id", "Funcname", 
                              "Number", "ByteString", "String", "Enum", 
                              "Empty", "WS" }
var ruleNames =  []string{ "inst", "parameters", "parameter" }

type STEPParser struct {
    *antlr4.BaseParser
}

func NewSTEPParser(input antlr4.TokenStream) *STEPParser {

    var decisionToDFA = make([]*antlr4.DFA,len(deserializedATN.DecisionToState))
    var sharedContextCache = antlr4.NewPredictionContextCache()

    for index, ds := range deserializedATN.DecisionToState {
        decisionToDFA[index] = antlr4.NewDFA(ds, index)
    }

    this := new(STEPParser)

    this.BaseParser = antlr4.NewBaseParser(input)

    this.Interpreter = antlr4.NewParserATNSimulator(this, deserializedATN, decisionToDFA, sharedContextCache)
    this.RuleNames = ruleNames
    this.LiteralNames = literalNames
    this.SymbolicNames = symbolicNames
    this.GrammarFileName = "STEP.g4"

    return this
}


const(
    STEPParserEOF = antlr4.TokenEOF
    STEPParserT__0 = 1
    STEPParserT__1 = 2
    STEPParserT__2 = 3
    STEPParserT__3 = 4
    STEPParserT__4 = 5
    STEPParserT__5 = 6
    STEPParserId = 7
    STEPParserFuncname = 8
    STEPParserNumber = 9
    STEPParserByteString = 10
    STEPParserString = 11
    STEPParserEnum = 12
    STEPParserEmpty = 13
    STEPParserWS = 14
)

const (
    STEPParserRULE_inst = 0
    STEPParserRULE_parameters = 1
    STEPParserRULE_parameter = 2
)

// an interface to support dynamic dispatch (subclassing)

type IInstContext interface {
    antlr4.ParserRuleContext

    GetParser() antlr4.Parser
    getInstContext() // to differentiate from other interfaces

}

type InstContext struct {
    *antlr4.BaseParserRuleContext

    parser antlr4.Parser
}

func NewEmptyInstContext() *InstContext {
    var p = new(InstContext)
    p.BaseParserRuleContext = antlr4.NewBaseParserRuleContext( nil, -1 )
    p.RuleIndex = STEPParserRULE_inst
    return p
}

func (*InstContext) getInstContext() {}

func NewInstContext(parser antlr4.Parser, parent antlr4.ParserRuleContext, invokingState int) *InstContext {

    var p = new(InstContext)

    p.BaseParserRuleContext = antlr4.NewBaseParserRuleContext( parent, invokingState )

    p.parser = parser
    p.RuleIndex = STEPParserRULE_inst

    return p
}

func (s *InstContext) GetParser() antlr4.Parser { return s.parser }


func (s *InstContext) Id() antlr4.TerminalNode {
    return s.GetToken(STEPParserId, 0)
}

func (s *InstContext) Funcname() antlr4.TerminalNode {
    return s.GetToken(STEPParserFuncname, 0)
}

func (s *InstContext) Parameters() IParametersContext {
    v := s.GetTypedRuleContext( reflect.TypeOf((*IParametersContext)(nil)).Elem(),0);

    if v == nil {
        return nil
    }

    return v.(IParametersContext)
}

func (s *InstContext) GetRuleContext() antlr4.RuleContext { return s }

func (s *InstContext) EnterRule(listener antlr4.ParseTreeListener) {
    if listenerT, ok := listener.(STEPListener); ok {
        listenerT.EnterInst(s)
    }
}
func (s *InstContext) ExitRule(listener antlr4.ParseTreeListener) {
    if listenerT, ok := listener.(STEPListener); ok {
        listenerT.ExitInst(s)
    }
}



func (p *STEPParser) Inst() (localctx IInstContext) {

    localctx = NewInstContext(p, p.GetParserRuleContext(), p.GetState())
    p.EnterRule(localctx, 0, STEPParserRULE_inst)

    defer func(){
        p.ExitRule()
    }()

    defer func() {
        if err := recover(); err != nil {
            if v, ok := err.(antlr4.RecognitionException); ok {
                localctx.SetException( v )
                p.GetErrorHandler().ReportError(p, v)
                p.GetErrorHandler().Recover(p, v)
            } else {
                panic(err)
            }
        }
    }()

    p.EnterOuterAlt(localctx, 1)
    p.SetState(6)
    p.Match(STEPParserId)
    p.SetState(7)
    p.Match(STEPParserT__0)
    p.SetState(8)
    p.Match(STEPParserFuncname)
    p.SetState(9)
    p.Parameters()
    p.SetState(10)
    p.Match(STEPParserT__1)

    return localctx
}

// an interface to support dynamic dispatch (subclassing)

type IParametersContext interface {
    antlr4.ParserRuleContext

    GetParser() antlr4.Parser
    getParametersContext() // to differentiate from other interfaces

}

type ParametersContext struct {
    *antlr4.BaseParserRuleContext

    parser antlr4.Parser
}

func NewEmptyParametersContext() *ParametersContext {
    var p = new(ParametersContext)
    p.BaseParserRuleContext = antlr4.NewBaseParserRuleContext( nil, -1 )
    p.RuleIndex = STEPParserRULE_parameters
    return p
}

func (*ParametersContext) getParametersContext() {}

func NewParametersContext(parser antlr4.Parser, parent antlr4.ParserRuleContext, invokingState int) *ParametersContext {

    var p = new(ParametersContext)

    p.BaseParserRuleContext = antlr4.NewBaseParserRuleContext( parent, invokingState )

    p.parser = parser
    p.RuleIndex = STEPParserRULE_parameters

    return p
}

func (s *ParametersContext) GetParser() antlr4.Parser { return s.parser }


func (s *ParametersContext) Parameter(i int) []IParameterContext {
    var ts []antlr4.RuleContext;

    if i < 0 {
        ts = s.GetTypedRuleContexts( reflect.TypeOf((*IParameterContext)(nil)).Elem())
    } else {
        ts = []antlr4.RuleContext { s.GetTypedRuleContext( reflect.TypeOf((*IParameterContext)(nil)).Elem(),i) }
    }

    var tst []IParameterContext = make([]IParameterContext, len(ts))
    for i, t := range ts {
        if t == nil {
            tst[i] = nil
        } else {
            tst[i] = t.(IParameterContext)
        }
    }

    return tst
}

func (s *ParametersContext) GetRuleContext() antlr4.RuleContext { return s }

func (s *ParametersContext) EnterRule(listener antlr4.ParseTreeListener) {
    if listenerT, ok := listener.(STEPListener); ok {
        listenerT.EnterParameters(s)
    }
}
func (s *ParametersContext) ExitRule(listener antlr4.ParseTreeListener) {
    if listenerT, ok := listener.(STEPListener); ok {
        listenerT.ExitParameters(s)
    }
}



func (p *STEPParser) Parameters() (localctx IParametersContext) {

    localctx = NewParametersContext(p, p.GetParserRuleContext(), p.GetState())
    p.EnterRule(localctx, 2, STEPParserRULE_parameters)
    var _la int

    defer func(){
        p.ExitRule()
    }()

    defer func() {
        if err := recover(); err != nil {
            if v, ok := err.(antlr4.RecognitionException); ok {
                localctx.SetException( v )
                p.GetErrorHandler().ReportError(p, v)
                p.GetErrorHandler().Recover(p, v)
            } else {
                panic(err)
            }
        }
    }()

    p.SetState(24)
    switch p.GetTokenStream().LA(1) {
    case STEPParserT__2:
        p.EnterOuterAlt(localctx, 1)
        p.SetState(12)
        p.Match(STEPParserT__2)
        break 
    case STEPParserT__3:
        p.EnterOuterAlt(localctx, 2)
        p.SetState(13)
        p.Match(STEPParserT__3)
        p.SetState(14)
        p.Parameter()
        p.SetState(19)
        p.GetErrorHandler().Sync(p)
        _la = p.GetTokenStream().LA(1);
        for _la==STEPParserT__4 {
            p.SetState(15)
            p.Match(STEPParserT__4)
            p.SetState(16)
            p.Parameter()
            p.SetState(21)
            p.GetErrorHandler().Sync(p)
            _la = p.GetTokenStream().LA(1);
        }
        p.SetState(22)
        p.Match(STEPParserT__5)
        break 
    default:
        panic(antlr4.NewNoViableAltException(p, nil, nil, nil, nil, nil))
    }

    return localctx
}

// an interface to support dynamic dispatch (subclassing)

type IParameterContext interface {
    antlr4.ParserRuleContext

    GetParser() antlr4.Parser
    getParameterContext() // to differentiate from other interfaces

}

type ParameterContext struct {
    *antlr4.BaseParserRuleContext

    parser antlr4.Parser
}

func NewEmptyParameterContext() *ParameterContext {
    var p = new(ParameterContext)
    p.BaseParserRuleContext = antlr4.NewBaseParserRuleContext( nil, -1 )
    p.RuleIndex = STEPParserRULE_parameter
    return p
}

func (*ParameterContext) getParameterContext() {}

func NewParameterContext(parser antlr4.Parser, parent antlr4.ParserRuleContext, invokingState int) *ParameterContext {

    var p = new(ParameterContext)

    p.BaseParserRuleContext = antlr4.NewBaseParserRuleContext( parent, invokingState )

    p.parser = parser
    p.RuleIndex = STEPParserRULE_parameter

    return p
}

func (s *ParameterContext) GetParser() antlr4.Parser { return s.parser }


func (s *ParameterContext) Number() antlr4.TerminalNode {
    return s.GetToken(STEPParserNumber, 0)
}

func (s *ParameterContext) ByteString() antlr4.TerminalNode {
    return s.GetToken(STEPParserByteString, 0)
}

func (s *ParameterContext) String() antlr4.TerminalNode {
    return s.GetToken(STEPParserString, 0)
}

func (s *ParameterContext) Enum() antlr4.TerminalNode {
    return s.GetToken(STEPParserEnum, 0)
}

func (s *ParameterContext) Empty() antlr4.TerminalNode {
    return s.GetToken(STEPParserEmpty, 0)
}

func (s *ParameterContext) Id() antlr4.TerminalNode {
    return s.GetToken(STEPParserId, 0)
}

func (s *ParameterContext) Parameters() IParametersContext {
    v := s.GetTypedRuleContext( reflect.TypeOf((*IParametersContext)(nil)).Elem(),0);

    if v == nil {
        return nil
    }

    return v.(IParametersContext)
}

func (s *ParameterContext) GetRuleContext() antlr4.RuleContext { return s }

func (s *ParameterContext) EnterRule(listener antlr4.ParseTreeListener) {
    if listenerT, ok := listener.(STEPListener); ok {
        listenerT.EnterParameter(s)
    }
}
func (s *ParameterContext) ExitRule(listener antlr4.ParseTreeListener) {
    if listenerT, ok := listener.(STEPListener); ok {
        listenerT.ExitParameter(s)
    }
}



func (p *STEPParser) Parameter() (localctx IParameterContext) {

    localctx = NewParameterContext(p, p.GetParserRuleContext(), p.GetState())
    p.EnterRule(localctx, 4, STEPParserRULE_parameter)

    defer func(){
        p.ExitRule()
    }()

    defer func() {
        if err := recover(); err != nil {
            if v, ok := err.(antlr4.RecognitionException); ok {
                localctx.SetException( v )
                p.GetErrorHandler().ReportError(p, v)
                p.GetErrorHandler().Recover(p, v)
            } else {
                panic(err)
            }
        }
    }()

    p.SetState(33)
    switch p.GetTokenStream().LA(1) {
    case STEPParserNumber:
        p.EnterOuterAlt(localctx, 1)
        p.SetState(26)
        p.Match(STEPParserNumber)
        break 
    case STEPParserByteString:
        p.EnterOuterAlt(localctx, 2)
        p.SetState(27)
        p.Match(STEPParserByteString)
        break 
    case STEPParserString:
        p.EnterOuterAlt(localctx, 3)
        p.SetState(28)
        p.Match(STEPParserString)
        break 
    case STEPParserEnum:
        p.EnterOuterAlt(localctx, 4)
        p.SetState(29)
        p.Match(STEPParserEnum)
        break 
    case STEPParserEmpty:
        p.EnterOuterAlt(localctx, 5)
        p.SetState(30)
        p.Match(STEPParserEmpty)
        break 
    case STEPParserId:
        p.EnterOuterAlt(localctx, 6)
        p.SetState(31)
        p.Match(STEPParserId)
        break 
    case STEPParserT__2:fallthrough 
    case STEPParserT__3:
        p.EnterOuterAlt(localctx, 7)
        p.SetState(32)
        p.Parameters()
        break 
    default:
        panic(antlr4.NewNoViableAltException(p, nil, nil, nil, nil, nil))
    }

    return localctx
}