pydbc.py3 package

Submodules

pydbc.py3.dbcLexer module

class pydbc.py3.dbcLexer.dbcLexer(input=None, output: TextIO = <_io.TextIOWrapper name='<stdout>' mode='w' encoding='UTF-8'>)

Bases: antlr4.Lexer.Lexer

C_IDENTIFIER = 51
DUMMY_NODE_VECTOR = 50
FLOAT = 52
INT = 53
SIGN = 56
STRING = 55
T__0 = 1
T__1 = 2
T__10 = 11
T__11 = 12
T__12 = 13
T__13 = 14
T__14 = 15
T__15 = 16
T__16 = 17
T__17 = 18
T__18 = 19
T__19 = 20
T__2 = 3
T__20 = 21
T__21 = 22
T__22 = 23
T__23 = 24
T__24 = 25
T__25 = 26
T__26 = 27
T__27 = 28
T__28 = 29
T__29 = 30
T__3 = 4
T__30 = 31
T__31 = 32
T__32 = 33
T__33 = 34
T__34 = 35
T__35 = 36
T__36 = 37
T__37 = 38
T__38 = 39
T__39 = 40
T__4 = 5
T__40 = 41
T__41 = 42
T__42 = 43
T__43 = 44
T__44 = 45
T__45 = 46
T__46 = 47
T__47 = 48
T__48 = 49
T__5 = 6
T__6 = 7
T__7 = 8
T__8 = 9
T__9 = 10
WS = 54
atn = <antlr4.atn.ATN.ATN object>
channelNames = ['DEFAULT_TOKEN_CHANNEL', 'HIDDEN']
decisionsToDFA = [<antlr4.dfa.DFA.DFA object>, <antlr4.dfa.DFA.DFA object>, <antlr4.dfa.DFA.DFA object>, <antlr4.dfa.DFA.DFA object>, <antlr4.dfa.DFA.DFA object>, <antlr4.dfa.DFA.DFA object>, <antlr4.dfa.DFA.DFA object>, <antlr4.dfa.DFA.DFA object>, <antlr4.dfa.DFA.DFA object>, <antlr4.dfa.DFA.DFA object>, <antlr4.dfa.DFA.DFA object>, <antlr4.dfa.DFA.DFA object>, <antlr4.dfa.DFA.DFA object>, <antlr4.dfa.DFA.DFA object>, <antlr4.dfa.DFA.DFA object>, <antlr4.dfa.DFA.DFA object>]
grammarFileName = 'dbc.g4'
literalNames = ['<INVALID>', "'BO_TX_BU_'", "':'", "';'", "'SIG_VALTYPE_'", "'BO_'", "'SG_'", "'|'", "'@'", "'('", "','", "')'", "'['", "']'", "'VAL_TABLE_'", "'BU_'", "'BS_'", "'NS_'", "'NS_DESC_'", "'CM_'", "'BA_DEF_'", "'BA_'", "'VAL_'", "'CAT_DEF_'", "'CAT_'", "'FILTER'", "'BA_DEF_DEF_'", "'EV_DATA_'", "'ENVVAR_DATA_'", "'SGTYPE_'", "'SGTYPE_VAL_'", "'BA_DEF_SGTYPE_'", "'BA_SGTYPE_'", "'SIG_TYPE_REF_'", "'SIG_GROUP_'", "'SIGTYPE_VALTYPE_'", "'BA_DEF_REL_'", "'BA_REL_'", "'BA_DEF_DEF_REL_'", "'BU_SG_REL_'", "'BU_EV_REL_'", "'BU_BO_REL_'", "'SG_MUL_VAL_'", "'VERSION'", "'EV_'", "'INT'", "'HEX'", "'FLOAT'", "'STRING'", "'ENUM'"]
modeNames = ['DEFAULT_MODE']
ruleNames = ['T__0', 'T__1', 'T__2', 'T__3', 'T__4', 'T__5', 'T__6', 'T__7', 'T__8', 'T__9', 'T__10', 'T__11', 'T__12', 'T__13', 'T__14', 'T__15', 'T__16', 'T__17', 'T__18', 'T__19', 'T__20', 'T__21', 'T__22', 'T__23', 'T__24', 'T__25', 'T__26', 'T__27', 'T__28', 'T__29', 'T__30', 'T__31', 'T__32', 'T__33', 'T__34', 'T__35', 'T__36', 'T__37', 'T__38', 'T__39', 'T__40', 'T__41', 'T__42', 'T__43', 'T__44', 'T__45', 'T__46', 'T__47', 'T__48', 'DUMMY_NODE_VECTOR', 'C_IDENTIFIER', 'EXPONENT', 'FLOAT', 'INT', 'ESC_SEQ', 'WS', 'STRING', 'SIGN']
symbolicNames = ['<INVALID>', 'DUMMY_NODE_VECTOR', 'C_IDENTIFIER', 'FLOAT', 'INT', 'WS', 'STRING', 'SIGN']
pydbc.py3.dbcLexer.serializedATN()

pydbc.py3.dbcListener module

class pydbc.py3.dbcListener.dbcListener

Bases: antlr4.tree.Tree.ParseTreeListener

enterAccessNodes(ctx: pydbc.py3.dbcParser.dbcParser.AccessNodesContext)
enterAttributeDefault(ctx: pydbc.py3.dbcParser.dbcParser.AttributeDefaultContext)
enterAttributeDefaults(ctx: pydbc.py3.dbcParser.dbcParser.AttributeDefaultsContext)
enterAttributeDefinition(ctx: pydbc.py3.dbcParser.dbcParser.AttributeDefinitionContext)
enterAttributeDefinitions(ctx: pydbc.py3.dbcParser.dbcParser.AttributeDefinitionsContext)
enterAttributeValue(ctx: pydbc.py3.dbcParser.dbcParser.AttributeValueContext)
enterAttributeValueForObject(ctx: pydbc.py3.dbcParser.dbcParser.AttributeValueForObjectContext)
enterAttributeValueType(ctx: pydbc.py3.dbcParser.dbcParser.AttributeValueTypeContext)
enterAttributeValues(ctx: pydbc.py3.dbcParser.dbcParser.AttributeValuesContext)
enterBitTiming(ctx: pydbc.py3.dbcParser.dbcParser.BitTimingContext)
enterCategories(ctx: pydbc.py3.dbcParser.dbcParser.CategoriesContext)
enterCategory(ctx: pydbc.py3.dbcParser.dbcParser.CategoryContext)
enterCategoryDefinition(ctx: pydbc.py3.dbcParser.dbcParser.CategoryDefinitionContext)
enterCategoryDefinitions(ctx: pydbc.py3.dbcParser.dbcParser.CategoryDefinitionsContext)
enterComment(ctx: pydbc.py3.dbcParser.dbcParser.CommentContext)
enterComments(ctx: pydbc.py3.dbcParser.dbcParser.CommentsContext)
enterDbcfile(ctx: pydbc.py3.dbcParser.dbcParser.DbcfileContext)
enterEnvironmentVariable(ctx: pydbc.py3.dbcParser.dbcParser.EnvironmentVariableContext)
enterEnvironmentVariableData(ctx: pydbc.py3.dbcParser.dbcParser.EnvironmentVariableDataContext)
enterEnvironmentVariables(ctx: pydbc.py3.dbcParser.dbcParser.EnvironmentVariablesContext)
enterEnvironmentVariablesData(ctx: pydbc.py3.dbcParser.dbcParser.EnvironmentVariablesDataContext)
enterFloatValue(ctx: pydbc.py3.dbcParser.dbcParser.FloatValueContext)
enterIdentifierValue(ctx: pydbc.py3.dbcParser.dbcParser.IdentifierValueContext)
enterIntValue(ctx: pydbc.py3.dbcParser.dbcParser.IntValueContext)
enterMessage(ctx: pydbc.py3.dbcParser.dbcParser.MessageContext)
enterMessageTransmitter(ctx: pydbc.py3.dbcParser.dbcParser.MessageTransmitterContext)
enterMessageTransmitters(ctx: pydbc.py3.dbcParser.dbcParser.MessageTransmittersContext)
enterMessages(ctx: pydbc.py3.dbcParser.dbcParser.MessagesContext)
enterMultiplexerIndicator(ctx: pydbc.py3.dbcParser.dbcParser.MultiplexerIndicatorContext)
enterNewSymbols(ctx: pydbc.py3.dbcParser.dbcParser.NewSymbolsContext)
enterNodes(ctx: pydbc.py3.dbcParser.dbcParser.NodesContext)
enterNumber(ctx: pydbc.py3.dbcParser.dbcParser.NumberContext)
enterReceiver(ctx: pydbc.py3.dbcParser.dbcParser.ReceiverContext)
enterRelativeAttributeDefault(ctx: pydbc.py3.dbcParser.dbcParser.RelativeAttributeDefaultContext)
enterRelativeAttributeDefaults(ctx: pydbc.py3.dbcParser.dbcParser.RelativeAttributeDefaultsContext)
enterRelativeAttributeDefinition(ctx: pydbc.py3.dbcParser.dbcParser.RelativeAttributeDefinitionContext)
enterRelativeAttributeDefinitions(ctx: pydbc.py3.dbcParser.dbcParser.RelativeAttributeDefinitionsContext)
enterRelativeAttributeValueForObject(ctx: pydbc.py3.dbcParser.dbcParser.RelativeAttributeValueForObjectContext)
enterRelativeAttributeValues(ctx: pydbc.py3.dbcParser.dbcParser.RelativeAttributeValuesContext)
enterSignal(ctx: pydbc.py3.dbcParser.dbcParser.SignalContext)
enterSignalExtendedValueType(ctx: pydbc.py3.dbcParser.dbcParser.SignalExtendedValueTypeContext)
enterSignalExtendedValueTypeList(ctx: pydbc.py3.dbcParser.dbcParser.SignalExtendedValueTypeListContext)
enterSignalGroup(ctx: pydbc.py3.dbcParser.dbcParser.SignalGroupContext)
enterSignalGroups(ctx: pydbc.py3.dbcParser.dbcParser.SignalGroupsContext)
enterSignalType(ctx: pydbc.py3.dbcParser.dbcParser.SignalTypeContext)
enterSignalTypes(ctx: pydbc.py3.dbcParser.dbcParser.SignalTypesContext)
enterSpecializedValueDescription(ctx: pydbc.py3.dbcParser.dbcParser.SpecializedValueDescriptionContext)
enterStringValue(ctx: pydbc.py3.dbcParser.dbcParser.StringValueContext)
enterTransmitter(ctx: pydbc.py3.dbcParser.dbcParser.TransmitterContext)
enterValueDescription(ctx: pydbc.py3.dbcParser.dbcParser.ValueDescriptionContext)
enterValueDescriptions(ctx: pydbc.py3.dbcParser.dbcParser.ValueDescriptionsContext)
enterValueTable(ctx: pydbc.py3.dbcParser.dbcParser.ValueTableContext)
enterValueTables(ctx: pydbc.py3.dbcParser.dbcParser.ValueTablesContext)
enterVersion(ctx: pydbc.py3.dbcParser.dbcParser.VersionContext)
exitAccessNodes(ctx: pydbc.py3.dbcParser.dbcParser.AccessNodesContext)
exitAttributeDefault(ctx: pydbc.py3.dbcParser.dbcParser.AttributeDefaultContext)
exitAttributeDefaults(ctx: pydbc.py3.dbcParser.dbcParser.AttributeDefaultsContext)
exitAttributeDefinition(ctx: pydbc.py3.dbcParser.dbcParser.AttributeDefinitionContext)
exitAttributeDefinitions(ctx: pydbc.py3.dbcParser.dbcParser.AttributeDefinitionsContext)
exitAttributeValue(ctx: pydbc.py3.dbcParser.dbcParser.AttributeValueContext)
exitAttributeValueForObject(ctx: pydbc.py3.dbcParser.dbcParser.AttributeValueForObjectContext)
exitAttributeValueType(ctx: pydbc.py3.dbcParser.dbcParser.AttributeValueTypeContext)
exitAttributeValues(ctx: pydbc.py3.dbcParser.dbcParser.AttributeValuesContext)
exitBitTiming(ctx: pydbc.py3.dbcParser.dbcParser.BitTimingContext)
exitCategories(ctx: pydbc.py3.dbcParser.dbcParser.CategoriesContext)
exitCategory(ctx: pydbc.py3.dbcParser.dbcParser.CategoryContext)
exitCategoryDefinition(ctx: pydbc.py3.dbcParser.dbcParser.CategoryDefinitionContext)
exitCategoryDefinitions(ctx: pydbc.py3.dbcParser.dbcParser.CategoryDefinitionsContext)
exitComment(ctx: pydbc.py3.dbcParser.dbcParser.CommentContext)
exitComments(ctx: pydbc.py3.dbcParser.dbcParser.CommentsContext)
exitDbcfile(ctx: pydbc.py3.dbcParser.dbcParser.DbcfileContext)
exitEnvironmentVariable(ctx: pydbc.py3.dbcParser.dbcParser.EnvironmentVariableContext)
exitEnvironmentVariableData(ctx: pydbc.py3.dbcParser.dbcParser.EnvironmentVariableDataContext)
exitEnvironmentVariables(ctx: pydbc.py3.dbcParser.dbcParser.EnvironmentVariablesContext)
exitEnvironmentVariablesData(ctx: pydbc.py3.dbcParser.dbcParser.EnvironmentVariablesDataContext)
exitFloatValue(ctx: pydbc.py3.dbcParser.dbcParser.FloatValueContext)
exitIdentifierValue(ctx: pydbc.py3.dbcParser.dbcParser.IdentifierValueContext)
exitIntValue(ctx: pydbc.py3.dbcParser.dbcParser.IntValueContext)
exitMessage(ctx: pydbc.py3.dbcParser.dbcParser.MessageContext)
exitMessageTransmitter(ctx: pydbc.py3.dbcParser.dbcParser.MessageTransmitterContext)
exitMessageTransmitters(ctx: pydbc.py3.dbcParser.dbcParser.MessageTransmittersContext)
exitMessages(ctx: pydbc.py3.dbcParser.dbcParser.MessagesContext)
exitMultiplexerIndicator(ctx: pydbc.py3.dbcParser.dbcParser.MultiplexerIndicatorContext)
exitNewSymbols(ctx: pydbc.py3.dbcParser.dbcParser.NewSymbolsContext)
exitNodes(ctx: pydbc.py3.dbcParser.dbcParser.NodesContext)
exitNumber(ctx: pydbc.py3.dbcParser.dbcParser.NumberContext)
exitReceiver(ctx: pydbc.py3.dbcParser.dbcParser.ReceiverContext)
exitRelativeAttributeDefault(ctx: pydbc.py3.dbcParser.dbcParser.RelativeAttributeDefaultContext)
exitRelativeAttributeDefaults(ctx: pydbc.py3.dbcParser.dbcParser.RelativeAttributeDefaultsContext)
exitRelativeAttributeDefinition(ctx: pydbc.py3.dbcParser.dbcParser.RelativeAttributeDefinitionContext)
exitRelativeAttributeDefinitions(ctx: pydbc.py3.dbcParser.dbcParser.RelativeAttributeDefinitionsContext)
exitRelativeAttributeValueForObject(ctx: pydbc.py3.dbcParser.dbcParser.RelativeAttributeValueForObjectContext)
exitRelativeAttributeValues(ctx: pydbc.py3.dbcParser.dbcParser.RelativeAttributeValuesContext)
exitSignal(ctx: pydbc.py3.dbcParser.dbcParser.SignalContext)
exitSignalExtendedValueType(ctx: pydbc.py3.dbcParser.dbcParser.SignalExtendedValueTypeContext)
exitSignalExtendedValueTypeList(ctx: pydbc.py3.dbcParser.dbcParser.SignalExtendedValueTypeListContext)
exitSignalGroup(ctx: pydbc.py3.dbcParser.dbcParser.SignalGroupContext)
exitSignalGroups(ctx: pydbc.py3.dbcParser.dbcParser.SignalGroupsContext)
exitSignalType(ctx: pydbc.py3.dbcParser.dbcParser.SignalTypeContext)
exitSignalTypes(ctx: pydbc.py3.dbcParser.dbcParser.SignalTypesContext)
exitSpecializedValueDescription(ctx: pydbc.py3.dbcParser.dbcParser.SpecializedValueDescriptionContext)
exitStringValue(ctx: pydbc.py3.dbcParser.dbcParser.StringValueContext)
exitTransmitter(ctx: pydbc.py3.dbcParser.dbcParser.TransmitterContext)
exitValueDescription(ctx: pydbc.py3.dbcParser.dbcParser.ValueDescriptionContext)
exitValueDescriptions(ctx: pydbc.py3.dbcParser.dbcParser.ValueDescriptionsContext)
exitValueTable(ctx: pydbc.py3.dbcParser.dbcParser.ValueTableContext)
exitValueTables(ctx: pydbc.py3.dbcParser.dbcParser.ValueTablesContext)
exitVersion(ctx: pydbc.py3.dbcParser.dbcParser.VersionContext)

pydbc.py3.dbcParser module

class pydbc.py3.dbcParser.dbcParser(input: antlr4.BufferedTokenStream.TokenStream, output: TextIO = <_io.TextIOWrapper name='<stdout>' mode='w' encoding='UTF-8'>)

Bases: antlr4.Parser.Parser

class AccessNodesContext(parser, parent: antlr4.ParserRuleContext.ParserRuleContext = None, invokingState: int = -1)

Bases: antlr4.ParserRuleContext.ParserRuleContext

accept(visitor: antlr4.tree.Tree.ParseTreeVisitor)
enterRule(listener: antlr4.tree.Tree.ParseTreeListener)
exitRule(listener: antlr4.tree.Tree.ParseTreeListener)
getRuleIndex()
identifierValue(i: int = None)
class AttributeDefaultContext(parser, parent: antlr4.ParserRuleContext.ParserRuleContext = None, invokingState: int = -1)

Bases: antlr4.ParserRuleContext.ParserRuleContext

accept(visitor: antlr4.tree.Tree.ParseTreeVisitor)
attributeValue()
enterRule(listener: antlr4.tree.Tree.ParseTreeListener)
exitRule(listener: antlr4.tree.Tree.ParseTreeListener)
getRuleIndex()
stringValue()
class AttributeDefaultsContext(parser, parent: antlr4.ParserRuleContext.ParserRuleContext = None, invokingState: int = -1)

Bases: antlr4.ParserRuleContext.ParserRuleContext

accept(visitor: antlr4.tree.Tree.ParseTreeVisitor)
attributeDefault(i: int = None)
enterRule(listener: antlr4.tree.Tree.ParseTreeListener)
exitRule(listener: antlr4.tree.Tree.ParseTreeListener)
getRuleIndex()
class AttributeDefinitionContext(parser, parent: antlr4.ParserRuleContext.ParserRuleContext = None, invokingState: int = -1)

Bases: antlr4.ParserRuleContext.ParserRuleContext

accept(visitor: antlr4.tree.Tree.ParseTreeVisitor)
attributeValueType()
enterRule(listener: antlr4.tree.Tree.ParseTreeListener)
exitRule(listener: antlr4.tree.Tree.ParseTreeListener)
getRuleIndex()
stringValue()
class AttributeDefinitionsContext(parser, parent: antlr4.ParserRuleContext.ParserRuleContext = None, invokingState: int = -1)

Bases: antlr4.ParserRuleContext.ParserRuleContext

accept(visitor: antlr4.tree.Tree.ParseTreeVisitor)
attributeDefinition(i: int = None)
enterRule(listener: antlr4.tree.Tree.ParseTreeListener)
exitRule(listener: antlr4.tree.Tree.ParseTreeListener)
getRuleIndex()
class AttributeValueContext(parser, parent: antlr4.ParserRuleContext.ParserRuleContext = None, invokingState: int = -1)

Bases: antlr4.ParserRuleContext.ParserRuleContext

accept(visitor: antlr4.tree.Tree.ParseTreeVisitor)
enterRule(listener: antlr4.tree.Tree.ParseTreeListener)
exitRule(listener: antlr4.tree.Tree.ParseTreeListener)
getRuleIndex()
number()
stringValue()
class AttributeValueForObjectContext(parser, parent: antlr4.ParserRuleContext.ParserRuleContext = None, invokingState: int = -1)

Bases: antlr4.ParserRuleContext.ParserRuleContext

accept(visitor: antlr4.tree.Tree.ParseTreeVisitor)
attributeValue()
enterRule(listener: antlr4.tree.Tree.ParseTreeListener)
exitRule(listener: antlr4.tree.Tree.ParseTreeListener)
getRuleIndex()
identifierValue()
intValue()
stringValue()
class AttributeValueTypeContext(parser, parent: antlr4.ParserRuleContext.ParserRuleContext = None, invokingState: int = -1)

Bases: antlr4.ParserRuleContext.ParserRuleContext

accept(visitor: antlr4.tree.Tree.ParseTreeVisitor)
enterRule(listener: antlr4.tree.Tree.ParseTreeListener)
exitRule(listener: antlr4.tree.Tree.ParseTreeListener)
getRuleIndex()
intValue(i: int = None)
number(i: int = None)
stringValue(i: int = None)
class AttributeValuesContext(parser, parent: antlr4.ParserRuleContext.ParserRuleContext = None, invokingState: int = -1)

Bases: antlr4.ParserRuleContext.ParserRuleContext

accept(visitor: antlr4.tree.Tree.ParseTreeVisitor)
attributeValueForObject(i: int = None)
enterRule(listener: antlr4.tree.Tree.ParseTreeListener)
exitRule(listener: antlr4.tree.Tree.ParseTreeListener)
getRuleIndex()
class BitTimingContext(parser, parent: antlr4.ParserRuleContext.ParserRuleContext = None, invokingState: int = -1)

Bases: antlr4.ParserRuleContext.ParserRuleContext

accept(visitor: antlr4.tree.Tree.ParseTreeVisitor)
enterRule(listener: antlr4.tree.Tree.ParseTreeListener)
exitRule(listener: antlr4.tree.Tree.ParseTreeListener)
getRuleIndex()
intValue(i: int = None)
C_IDENTIFIER = 51
class CategoriesContext(parser, parent: antlr4.ParserRuleContext.ParserRuleContext = None, invokingState: int = -1)

Bases: antlr4.ParserRuleContext.ParserRuleContext

accept(visitor: antlr4.tree.Tree.ParseTreeVisitor)
category(i: int = None)
enterRule(listener: antlr4.tree.Tree.ParseTreeListener)
exitRule(listener: antlr4.tree.Tree.ParseTreeListener)
getRuleIndex()
class CategoryContext(parser, parent: antlr4.ParserRuleContext.ParserRuleContext = None, invokingState: int = -1)

Bases: antlr4.ParserRuleContext.ParserRuleContext

accept(visitor: antlr4.tree.Tree.ParseTreeVisitor)
enterRule(listener: antlr4.tree.Tree.ParseTreeListener)
exitRule(listener: antlr4.tree.Tree.ParseTreeListener)
getRuleIndex()
identifierValue()
intValue(i: int = None)
class CategoryDefinitionContext(parser, parent: antlr4.ParserRuleContext.ParserRuleContext = None, invokingState: int = -1)

Bases: antlr4.ParserRuleContext.ParserRuleContext

accept(visitor: antlr4.tree.Tree.ParseTreeVisitor)
enterRule(listener: antlr4.tree.Tree.ParseTreeListener)
exitRule(listener: antlr4.tree.Tree.ParseTreeListener)
getRuleIndex()
identifierValue()
intValue(i: int = None)
class CategoryDefinitionsContext(parser, parent: antlr4.ParserRuleContext.ParserRuleContext = None, invokingState: int = -1)

Bases: antlr4.ParserRuleContext.ParserRuleContext

accept(visitor: antlr4.tree.Tree.ParseTreeVisitor)
categoryDefinition(i: int = None)
enterRule(listener: antlr4.tree.Tree.ParseTreeListener)
exitRule(listener: antlr4.tree.Tree.ParseTreeListener)
getRuleIndex()
class CommentContext(parser, parent: antlr4.ParserRuleContext.ParserRuleContext = None, invokingState: int = -1)

Bases: antlr4.ParserRuleContext.ParserRuleContext

accept(visitor: antlr4.tree.Tree.ParseTreeVisitor)
enterRule(listener: antlr4.tree.Tree.ParseTreeListener)
exitRule(listener: antlr4.tree.Tree.ParseTreeListener)
getRuleIndex()
identifierValue()
intValue()
stringValue()
class CommentsContext(parser, parent: antlr4.ParserRuleContext.ParserRuleContext = None, invokingState: int = -1)

Bases: antlr4.ParserRuleContext.ParserRuleContext

accept(visitor: antlr4.tree.Tree.ParseTreeVisitor)
comment(i: int = None)
enterRule(listener: antlr4.tree.Tree.ParseTreeListener)
exitRule(listener: antlr4.tree.Tree.ParseTreeListener)
getRuleIndex()
DUMMY_NODE_VECTOR = 50
class DbcfileContext(parser, parent: antlr4.ParserRuleContext.ParserRuleContext = None, invokingState: int = -1)

Bases: antlr4.ParserRuleContext.ParserRuleContext

accept(visitor: antlr4.tree.Tree.ParseTreeVisitor)
attributeDefaults()
attributeDefinitions()
attributeValues()
bitTiming()
categories()
categoryDefinitions()
comments()
enterRule(listener: antlr4.tree.Tree.ParseTreeListener)
environmentVariables()
environmentVariablesData()
exitRule(listener: antlr4.tree.Tree.ParseTreeListener)
getRuleIndex()
messageTransmitters()
messages()
newSymbols()
nodes()
relativeAttributeDefaults()
relativeAttributeDefinitions()
relativeAttributeValues()
signalExtendedValueTypeList()
signalGroups()
signalTypes()
valueDescriptions()
valueTables()
version()
EOF = -1
class EnvironmentVariableContext(parser, parent: antlr4.ParserRuleContext.ParserRuleContext = None, invokingState: int = -1)

Bases: antlr4.ParserRuleContext.ParserRuleContext

DUMMY_NODE_VECTOR()
accept(visitor: antlr4.tree.Tree.ParseTreeVisitor)
accessNodes()
enterRule(listener: antlr4.tree.Tree.ParseTreeListener)
exitRule(listener: antlr4.tree.Tree.ParseTreeListener)
getRuleIndex()
identifierValue()
intValue(i: int = None)
number(i: int = None)
stringValue()
class EnvironmentVariableDataContext(parser, parent: antlr4.ParserRuleContext.ParserRuleContext = None, invokingState: int = -1)

Bases: antlr4.ParserRuleContext.ParserRuleContext

accept(visitor: antlr4.tree.Tree.ParseTreeVisitor)
enterRule(listener: antlr4.tree.Tree.ParseTreeListener)
exitRule(listener: antlr4.tree.Tree.ParseTreeListener)
getRuleIndex()
identifierValue()
intValue()
class EnvironmentVariablesContext(parser, parent: antlr4.ParserRuleContext.ParserRuleContext = None, invokingState: int = -1)

Bases: antlr4.ParserRuleContext.ParserRuleContext

accept(visitor: antlr4.tree.Tree.ParseTreeVisitor)
enterRule(listener: antlr4.tree.Tree.ParseTreeListener)
environmentVariable(i: int = None)
exitRule(listener: antlr4.tree.Tree.ParseTreeListener)
getRuleIndex()
class EnvironmentVariablesDataContext(parser, parent: antlr4.ParserRuleContext.ParserRuleContext = None, invokingState: int = -1)

Bases: antlr4.ParserRuleContext.ParserRuleContext

accept(visitor: antlr4.tree.Tree.ParseTreeVisitor)
enterRule(listener: antlr4.tree.Tree.ParseTreeListener)
environmentVariableData(i: int = None)
exitRule(listener: antlr4.tree.Tree.ParseTreeListener)
getRuleIndex()
FLOAT = 52
class FloatValueContext(parser, parent: antlr4.ParserRuleContext.ParserRuleContext = None, invokingState: int = -1)

Bases: antlr4.ParserRuleContext.ParserRuleContext

FLOAT()
accept(visitor: antlr4.tree.Tree.ParseTreeVisitor)
enterRule(listener: antlr4.tree.Tree.ParseTreeListener)
exitRule(listener: antlr4.tree.Tree.ParseTreeListener)
getRuleIndex()
INT = 53
class IdentifierValueContext(parser, parent: antlr4.ParserRuleContext.ParserRuleContext = None, invokingState: int = -1)

Bases: antlr4.ParserRuleContext.ParserRuleContext

C_IDENTIFIER()
accept(visitor: antlr4.tree.Tree.ParseTreeVisitor)
enterRule(listener: antlr4.tree.Tree.ParseTreeListener)
exitRule(listener: antlr4.tree.Tree.ParseTreeListener)
getRuleIndex()
class IntValueContext(parser, parent: antlr4.ParserRuleContext.ParserRuleContext = None, invokingState: int = -1)

Bases: antlr4.ParserRuleContext.ParserRuleContext

INT()
accept(visitor: antlr4.tree.Tree.ParseTreeVisitor)
enterRule(listener: antlr4.tree.Tree.ParseTreeListener)
exitRule(listener: antlr4.tree.Tree.ParseTreeListener)
getRuleIndex()
class MessageContext(parser, parent: antlr4.ParserRuleContext.ParserRuleContext = None, invokingState: int = -1)

Bases: antlr4.ParserRuleContext.ParserRuleContext

C_IDENTIFIER()
accept(visitor: antlr4.tree.Tree.ParseTreeVisitor)
enterRule(listener: antlr4.tree.Tree.ParseTreeListener)
exitRule(listener: antlr4.tree.Tree.ParseTreeListener)
getRuleIndex()
identifierValue()
intValue(i: int = None)
signal(i: int = None)
class MessageTransmitterContext(parser, parent: antlr4.ParserRuleContext.ParserRuleContext = None, invokingState: int = -1)

Bases: antlr4.ParserRuleContext.ParserRuleContext

accept(visitor: antlr4.tree.Tree.ParseTreeVisitor)
enterRule(listener: antlr4.tree.Tree.ParseTreeListener)
exitRule(listener: antlr4.tree.Tree.ParseTreeListener)
getRuleIndex()
intValue()
transmitter()
class MessageTransmittersContext(parser, parent: antlr4.ParserRuleContext.ParserRuleContext = None, invokingState: int = -1)

Bases: antlr4.ParserRuleContext.ParserRuleContext

accept(visitor: antlr4.tree.Tree.ParseTreeVisitor)
enterRule(listener: antlr4.tree.Tree.ParseTreeListener)
exitRule(listener: antlr4.tree.Tree.ParseTreeListener)
getRuleIndex()
messageTransmitter(i: int = None)
class MessagesContext(parser, parent: antlr4.ParserRuleContext.ParserRuleContext = None, invokingState: int = -1)

Bases: antlr4.ParserRuleContext.ParserRuleContext

accept(visitor: antlr4.tree.Tree.ParseTreeVisitor)
enterRule(listener: antlr4.tree.Tree.ParseTreeListener)
exitRule(listener: antlr4.tree.Tree.ParseTreeListener)
getRuleIndex()
message(i: int = None)
class MultiplexerIndicatorContext(parser, parent: antlr4.ParserRuleContext.ParserRuleContext = None, invokingState: int = -1)

Bases: antlr4.ParserRuleContext.ParserRuleContext

accept(visitor: antlr4.tree.Tree.ParseTreeVisitor)
enterRule(listener: antlr4.tree.Tree.ParseTreeListener)
exitRule(listener: antlr4.tree.Tree.ParseTreeListener)
getRuleIndex()
identifierValue()
class NewSymbolsContext(parser, parent: antlr4.ParserRuleContext.ParserRuleContext = None, invokingState: int = -1)

Bases: antlr4.ParserRuleContext.ParserRuleContext

accept(visitor: antlr4.tree.Tree.ParseTreeVisitor)
enterRule(listener: antlr4.tree.Tree.ParseTreeListener)
exitRule(listener: antlr4.tree.Tree.ParseTreeListener)
getRuleIndex()
class NodesContext(parser, parent: antlr4.ParserRuleContext.ParserRuleContext = None, invokingState: int = -1)

Bases: antlr4.ParserRuleContext.ParserRuleContext

accept(visitor: antlr4.tree.Tree.ParseTreeVisitor)
enterRule(listener: antlr4.tree.Tree.ParseTreeListener)
exitRule(listener: antlr4.tree.Tree.ParseTreeListener)
getRuleIndex()
identifierValue(i: int = None)
class NumberContext(parser, parent: antlr4.ParserRuleContext.ParserRuleContext = None, invokingState: int = -1)

Bases: antlr4.ParserRuleContext.ParserRuleContext

accept(visitor: antlr4.tree.Tree.ParseTreeVisitor)
enterRule(listener: antlr4.tree.Tree.ParseTreeListener)
exitRule(listener: antlr4.tree.Tree.ParseTreeListener)
floatValue()
getRuleIndex()
intValue()
RULE_accessNodes = 22
RULE_attributeDefault = 35
RULE_attributeDefaults = 34
RULE_attributeDefinition = 30
RULE_attributeDefinitions = 29
RULE_attributeValue = 38
RULE_attributeValueForObject = 40
RULE_attributeValueType = 33
RULE_attributeValues = 39
RULE_bitTiming = 15
RULE_categories = 47
RULE_category = 48
RULE_categoryDefinition = 46
RULE_categoryDefinitions = 45
RULE_comment = 28
RULE_comments = 27
RULE_dbcfile = 0
RULE_environmentVariable = 21
RULE_environmentVariableData = 24
RULE_environmentVariables = 20
RULE_environmentVariablesData = 23
RULE_floatValue = 50
RULE_identifierValue = 53
RULE_intValue = 49
RULE_message = 6
RULE_messageTransmitter = 2
RULE_messageTransmitters = 1
RULE_messages = 5
RULE_multiplexerIndicator = 10
RULE_newSymbols = 16
RULE_nodes = 14
RULE_number = 51
RULE_receiver = 8
RULE_relativeAttributeDefault = 37
RULE_relativeAttributeDefaults = 36
RULE_relativeAttributeDefinition = 32
RULE_relativeAttributeDefinitions = 31
RULE_relativeAttributeValueForObject = 42
RULE_relativeAttributeValues = 41
RULE_signal = 7
RULE_signalExtendedValueType = 4
RULE_signalExtendedValueTypeList = 3
RULE_signalGroup = 44
RULE_signalGroups = 43
RULE_signalType = 26
RULE_signalTypes = 25
RULE_specializedValueDescription = 19
RULE_stringValue = 52
RULE_transmitter = 9
RULE_valueDescription = 13
RULE_valueDescriptions = 18
RULE_valueTable = 12
RULE_valueTables = 11
RULE_version = 17
class ReceiverContext(parser, parent: antlr4.ParserRuleContext.ParserRuleContext = None, invokingState: int = -1)

Bases: antlr4.ParserRuleContext.ParserRuleContext

C_IDENTIFIER()
accept(visitor: antlr4.tree.Tree.ParseTreeVisitor)
enterRule(listener: antlr4.tree.Tree.ParseTreeListener)
exitRule(listener: antlr4.tree.Tree.ParseTreeListener)
getRuleIndex()
identifierValue(i: int = None)
class RelativeAttributeDefaultContext(parser, parent: antlr4.ParserRuleContext.ParserRuleContext = None, invokingState: int = -1)

Bases: antlr4.ParserRuleContext.ParserRuleContext

accept(visitor: antlr4.tree.Tree.ParseTreeVisitor)
attributeValue()
enterRule(listener: antlr4.tree.Tree.ParseTreeListener)
exitRule(listener: antlr4.tree.Tree.ParseTreeListener)
getRuleIndex()
stringValue()
class RelativeAttributeDefaultsContext(parser, parent: antlr4.ParserRuleContext.ParserRuleContext = None, invokingState: int = -1)

Bases: antlr4.ParserRuleContext.ParserRuleContext

accept(visitor: antlr4.tree.Tree.ParseTreeVisitor)
enterRule(listener: antlr4.tree.Tree.ParseTreeListener)
exitRule(listener: antlr4.tree.Tree.ParseTreeListener)
getRuleIndex()
relativeAttributeDefault(i: int = None)
class RelativeAttributeDefinitionContext(parser, parent: antlr4.ParserRuleContext.ParserRuleContext = None, invokingState: int = -1)

Bases: antlr4.ParserRuleContext.ParserRuleContext

accept(visitor: antlr4.tree.Tree.ParseTreeVisitor)
attributeValueType()
enterRule(listener: antlr4.tree.Tree.ParseTreeListener)
exitRule(listener: antlr4.tree.Tree.ParseTreeListener)
getRuleIndex()
stringValue()
class RelativeAttributeDefinitionsContext(parser, parent: antlr4.ParserRuleContext.ParserRuleContext = None, invokingState: int = -1)

Bases: antlr4.ParserRuleContext.ParserRuleContext

accept(visitor: antlr4.tree.Tree.ParseTreeVisitor)
enterRule(listener: antlr4.tree.Tree.ParseTreeListener)
exitRule(listener: antlr4.tree.Tree.ParseTreeListener)
getRuleIndex()
relativeAttributeDefinition(i: int = None)
class RelativeAttributeValueForObjectContext(parser, parent: antlr4.ParserRuleContext.ParserRuleContext = None, invokingState: int = -1)

Bases: antlr4.ParserRuleContext.ParserRuleContext

accept(visitor: antlr4.tree.Tree.ParseTreeVisitor)
attributeValue()
enterRule(listener: antlr4.tree.Tree.ParseTreeListener)
exitRule(listener: antlr4.tree.Tree.ParseTreeListener)
getRuleIndex()
identifierValue(i: int = None)
intValue()
stringValue()
class RelativeAttributeValuesContext(parser, parent: antlr4.ParserRuleContext.ParserRuleContext = None, invokingState: int = -1)

Bases: antlr4.ParserRuleContext.ParserRuleContext

accept(visitor: antlr4.tree.Tree.ParseTreeVisitor)
enterRule(listener: antlr4.tree.Tree.ParseTreeListener)
exitRule(listener: antlr4.tree.Tree.ParseTreeListener)
getRuleIndex()
relativeAttributeValueForObject(i: int = None)
SIGN = 56
STRING = 55
class SignalContext(parser, parent: antlr4.ParserRuleContext.ParserRuleContext = None, invokingState: int = -1)

Bases: antlr4.ParserRuleContext.ParserRuleContext

SIGN()
accept(visitor: antlr4.tree.Tree.ParseTreeVisitor)
enterRule(listener: antlr4.tree.Tree.ParseTreeListener)
exitRule(listener: antlr4.tree.Tree.ParseTreeListener)
getRuleIndex()
identifierValue()
intValue(i: int = None)
multiplexerIndicator()
number(i: int = None)
receiver()
stringValue()
class SignalExtendedValueTypeContext(parser, parent: antlr4.ParserRuleContext.ParserRuleContext = None, invokingState: int = -1)

Bases: antlr4.ParserRuleContext.ParserRuleContext

accept(visitor: antlr4.tree.Tree.ParseTreeVisitor)
enterRule(listener: antlr4.tree.Tree.ParseTreeListener)
exitRule(listener: antlr4.tree.Tree.ParseTreeListener)
getRuleIndex()
identifierValue()
intValue(i: int = None)
class SignalExtendedValueTypeListContext(parser, parent: antlr4.ParserRuleContext.ParserRuleContext = None, invokingState: int = -1)

Bases: antlr4.ParserRuleContext.ParserRuleContext

accept(visitor: antlr4.tree.Tree.ParseTreeVisitor)
enterRule(listener: antlr4.tree.Tree.ParseTreeListener)
exitRule(listener: antlr4.tree.Tree.ParseTreeListener)
getRuleIndex()
signalExtendedValueType(i: int = None)
class SignalGroupContext(parser, parent: antlr4.ParserRuleContext.ParserRuleContext = None, invokingState: int = -1)

Bases: antlr4.ParserRuleContext.ParserRuleContext

accept(visitor: antlr4.tree.Tree.ParseTreeVisitor)
enterRule(listener: antlr4.tree.Tree.ParseTreeListener)
exitRule(listener: antlr4.tree.Tree.ParseTreeListener)
getRuleIndex()
identifierValue(i: int = None)
intValue(i: int = None)
class SignalGroupsContext(parser, parent: antlr4.ParserRuleContext.ParserRuleContext = None, invokingState: int = -1)

Bases: antlr4.ParserRuleContext.ParserRuleContext

accept(visitor: antlr4.tree.Tree.ParseTreeVisitor)
enterRule(listener: antlr4.tree.Tree.ParseTreeListener)
exitRule(listener: antlr4.tree.Tree.ParseTreeListener)
getRuleIndex()
signalGroup(i: int = None)
class SignalTypeContext(parser, parent: antlr4.ParserRuleContext.ParserRuleContext = None, invokingState: int = -1)

Bases: antlr4.ParserRuleContext.ParserRuleContext

SIGN()
accept(visitor: antlr4.tree.Tree.ParseTreeVisitor)
enterRule(listener: antlr4.tree.Tree.ParseTreeListener)
exitRule(listener: antlr4.tree.Tree.ParseTreeListener)
getRuleIndex()
identifierValue(i: int = None)
intValue()
number(i: int = None)
stringValue()
class SignalTypesContext(parser, parent: antlr4.ParserRuleContext.ParserRuleContext = None, invokingState: int = -1)

Bases: antlr4.ParserRuleContext.ParserRuleContext

accept(visitor: antlr4.tree.Tree.ParseTreeVisitor)
enterRule(listener: antlr4.tree.Tree.ParseTreeListener)
exitRule(listener: antlr4.tree.Tree.ParseTreeListener)
getRuleIndex()
signalType(i: int = None)
class SpecializedValueDescriptionContext(parser, parent: antlr4.ParserRuleContext.ParserRuleContext = None, invokingState: int = -1)

Bases: antlr4.ParserRuleContext.ParserRuleContext

accept(visitor: antlr4.tree.Tree.ParseTreeVisitor)
enterRule(listener: antlr4.tree.Tree.ParseTreeListener)
exitRule(listener: antlr4.tree.Tree.ParseTreeListener)
getRuleIndex()
identifierValue()
intValue()
valueDescription(i: int = None)
class StringValueContext(parser, parent: antlr4.ParserRuleContext.ParserRuleContext = None, invokingState: int = -1)

Bases: antlr4.ParserRuleContext.ParserRuleContext

STRING()
accept(visitor: antlr4.tree.Tree.ParseTreeVisitor)
enterRule(listener: antlr4.tree.Tree.ParseTreeListener)
exitRule(listener: antlr4.tree.Tree.ParseTreeListener)
getRuleIndex()
T__0 = 1
T__1 = 2
T__10 = 11
T__11 = 12
T__12 = 13
T__13 = 14
T__14 = 15
T__15 = 16
T__16 = 17
T__17 = 18
T__18 = 19
T__19 = 20
T__2 = 3
T__20 = 21
T__21 = 22
T__22 = 23
T__23 = 24
T__24 = 25
T__25 = 26
T__26 = 27
T__27 = 28
T__28 = 29
T__29 = 30
T__3 = 4
T__30 = 31
T__31 = 32
T__32 = 33
T__33 = 34
T__34 = 35
T__35 = 36
T__36 = 37
T__37 = 38
T__38 = 39
T__39 = 40
T__4 = 5
T__40 = 41
T__41 = 42
T__42 = 43
T__43 = 44
T__44 = 45
T__45 = 46
T__46 = 47
T__47 = 48
T__48 = 49
T__5 = 6
T__6 = 7
T__7 = 8
T__8 = 9
T__9 = 10
class TransmitterContext(parser, parent: antlr4.ParserRuleContext.ParserRuleContext = None, invokingState: int = -1)

Bases: antlr4.ParserRuleContext.ParserRuleContext

accept(visitor: antlr4.tree.Tree.ParseTreeVisitor)
enterRule(listener: antlr4.tree.Tree.ParseTreeListener)
exitRule(listener: antlr4.tree.Tree.ParseTreeListener)
getRuleIndex()
identifierValue(i: int = None)
class ValueDescriptionContext(parser, parent: antlr4.ParserRuleContext.ParserRuleContext = None, invokingState: int = -1)

Bases: antlr4.ParserRuleContext.ParserRuleContext

accept(visitor: antlr4.tree.Tree.ParseTreeVisitor)
enterRule(listener: antlr4.tree.Tree.ParseTreeListener)
exitRule(listener: antlr4.tree.Tree.ParseTreeListener)
getRuleIndex()
number()
stringValue()
class ValueDescriptionsContext(parser, parent: antlr4.ParserRuleContext.ParserRuleContext = None, invokingState: int = -1)

Bases: antlr4.ParserRuleContext.ParserRuleContext

accept(visitor: antlr4.tree.Tree.ParseTreeVisitor)
enterRule(listener: antlr4.tree.Tree.ParseTreeListener)
exitRule(listener: antlr4.tree.Tree.ParseTreeListener)
getRuleIndex()
specializedValueDescription(i: int = None)
class ValueTableContext(parser, parent: antlr4.ParserRuleContext.ParserRuleContext = None, invokingState: int = -1)

Bases: antlr4.ParserRuleContext.ParserRuleContext

accept(visitor: antlr4.tree.Tree.ParseTreeVisitor)
enterRule(listener: antlr4.tree.Tree.ParseTreeListener)
exitRule(listener: antlr4.tree.Tree.ParseTreeListener)
getRuleIndex()
identifierValue()
valueDescription(i: int = None)
class ValueTablesContext(parser, parent: antlr4.ParserRuleContext.ParserRuleContext = None, invokingState: int = -1)

Bases: antlr4.ParserRuleContext.ParserRuleContext

accept(visitor: antlr4.tree.Tree.ParseTreeVisitor)
enterRule(listener: antlr4.tree.Tree.ParseTreeListener)
exitRule(listener: antlr4.tree.Tree.ParseTreeListener)
getRuleIndex()
valueTable(i: int = None)
class VersionContext(parser, parent: antlr4.ParserRuleContext.ParserRuleContext = None, invokingState: int = -1)

Bases: antlr4.ParserRuleContext.ParserRuleContext

accept(visitor: antlr4.tree.Tree.ParseTreeVisitor)
enterRule(listener: antlr4.tree.Tree.ParseTreeListener)
exitRule(listener: antlr4.tree.Tree.ParseTreeListener)
getRuleIndex()
stringValue()
WS = 54
accessNodes()
atn = <antlr4.atn.ATN.ATN object>
attributeDefault()
attributeDefaults()
attributeDefinition()
attributeDefinitions()
attributeValue()
attributeValueForObject()
attributeValueType()
attributeValues()
bitTiming()
categories()
category()
categoryDefinition()
categoryDefinitions()
comment()
comments()
dbcfile()
decisionsToDFA = [<antlr4.dfa.DFA.DFA object>, <antlr4.dfa.DFA.DFA object>, <antlr4.dfa.DFA.DFA object>, <antlr4.dfa.DFA.DFA object>, <antlr4.dfa.DFA.DFA object>, <antlr4.dfa.DFA.DFA object>, <antlr4.dfa.DFA.DFA object>, <antlr4.dfa.DFA.DFA object>, <antlr4.dfa.DFA.DFA object>, <antlr4.dfa.DFA.DFA object>, <antlr4.dfa.DFA.DFA object>, <antlr4.dfa.DFA.DFA object>, <antlr4.dfa.DFA.DFA object>, <antlr4.dfa.DFA.DFA object>, <antlr4.dfa.DFA.DFA object>, <antlr4.dfa.DFA.DFA object>, <antlr4.dfa.DFA.DFA object>, <antlr4.dfa.DFA.DFA object>, <antlr4.dfa.DFA.DFA object>, <antlr4.dfa.DFA.DFA object>, <antlr4.dfa.DFA.DFA object>, <antlr4.dfa.DFA.DFA object>, <antlr4.dfa.DFA.DFA object>, <antlr4.dfa.DFA.DFA object>, <antlr4.dfa.DFA.DFA object>, <antlr4.dfa.DFA.DFA object>, <antlr4.dfa.DFA.DFA object>, <antlr4.dfa.DFA.DFA object>, <antlr4.dfa.DFA.DFA object>, <antlr4.dfa.DFA.DFA object>, <antlr4.dfa.DFA.DFA object>, <antlr4.dfa.DFA.DFA object>, <antlr4.dfa.DFA.DFA object>, <antlr4.dfa.DFA.DFA object>, <antlr4.dfa.DFA.DFA object>, <antlr4.dfa.DFA.DFA object>, <antlr4.dfa.DFA.DFA object>, <antlr4.dfa.DFA.DFA object>, <antlr4.dfa.DFA.DFA object>, <antlr4.dfa.DFA.DFA object>, <antlr4.dfa.DFA.DFA object>]
environmentVariable()
environmentVariableData()
environmentVariables()
environmentVariablesData()
floatValue()
grammarFileName = 'dbc.g4'
identifierValue()
intValue()
literalNames = ['<INVALID>', "'BO_TX_BU_'", "':'", "';'", "'SIG_VALTYPE_'", "'BO_'", "'SG_'", "'|'", "'@'", "'('", "','", "')'", "'['", "']'", "'VAL_TABLE_'", "'BU_'", "'BS_'", "'NS_'", "'NS_DESC_'", "'CM_'", "'BA_DEF_'", "'BA_'", "'VAL_'", "'CAT_DEF_'", "'CAT_'", "'FILTER'", "'BA_DEF_DEF_'", "'EV_DATA_'", "'ENVVAR_DATA_'", "'SGTYPE_'", "'SGTYPE_VAL_'", "'BA_DEF_SGTYPE_'", "'BA_SGTYPE_'", "'SIG_TYPE_REF_'", "'SIG_GROUP_'", "'SIGTYPE_VALTYPE_'", "'BA_DEF_REL_'", "'BA_REL_'", "'BA_DEF_DEF_REL_'", "'BU_SG_REL_'", "'BU_EV_REL_'", "'BU_BO_REL_'", "'SG_MUL_VAL_'", "'VERSION'", "'EV_'", "'INT'", "'HEX'", "'FLOAT'", "'STRING'", "'ENUM'"]
message()
messageTransmitter()
messageTransmitters()
messages()
multiplexerIndicator()
newSymbols()
nodes()
number()
receiver()
relativeAttributeDefault()
relativeAttributeDefaults()
relativeAttributeDefinition()
relativeAttributeDefinitions()
relativeAttributeValueForObject()
relativeAttributeValues()
ruleNames = ['dbcfile', 'messageTransmitters', 'messageTransmitter', 'signalExtendedValueTypeList', 'signalExtendedValueType', 'messages', 'message', 'signal', 'receiver', 'transmitter', 'multiplexerIndicator', 'valueTables', 'valueTable', 'valueDescription', 'nodes', 'bitTiming', 'newSymbols', 'version', 'valueDescriptions', 'specializedValueDescription', 'environmentVariables', 'environmentVariable', 'accessNodes', 'environmentVariablesData', 'environmentVariableData', 'signalTypes', 'signalType', 'comments', 'comment', 'attributeDefinitions', 'attributeDefinition', 'relativeAttributeDefinitions', 'relativeAttributeDefinition', 'attributeValueType', 'attributeDefaults', 'attributeDefault', 'relativeAttributeDefaults', 'relativeAttributeDefault', 'attributeValue', 'attributeValues', 'attributeValueForObject', 'relativeAttributeValues', 'relativeAttributeValueForObject', 'signalGroups', 'signalGroup', 'categoryDefinitions', 'categoryDefinition', 'categories', 'category', 'intValue', 'floatValue', 'number', 'stringValue', 'identifierValue']
sharedContextCache = <antlr4.PredictionContext.PredictionContextCache object>
signal()
signalExtendedValueType()
signalExtendedValueTypeList()
signalGroup()
signalGroups()
signalType()
signalTypes()
specializedValueDescription()
stringValue()
symbolicNames = ['<INVALID>', '<INVALID>', '<INVALID>', '<INVALID>', '<INVALID>', '<INVALID>', '<INVALID>', '<INVALID>', '<INVALID>', '<INVALID>', '<INVALID>', '<INVALID>', '<INVALID>', '<INVALID>', '<INVALID>', '<INVALID>', '<INVALID>', '<INVALID>', '<INVALID>', '<INVALID>', '<INVALID>', '<INVALID>', '<INVALID>', '<INVALID>', '<INVALID>', '<INVALID>', '<INVALID>', '<INVALID>', '<INVALID>', '<INVALID>', '<INVALID>', '<INVALID>', '<INVALID>', '<INVALID>', '<INVALID>', '<INVALID>', '<INVALID>', '<INVALID>', '<INVALID>', '<INVALID>', '<INVALID>', '<INVALID>', '<INVALID>', '<INVALID>', '<INVALID>', '<INVALID>', '<INVALID>', '<INVALID>', '<INVALID>', '<INVALID>', 'DUMMY_NODE_VECTOR', 'C_IDENTIFIER', 'FLOAT', 'INT', 'WS', 'STRING', 'SIGN']
transmitter()
valueDescription()
valueDescriptions()
valueTable()
valueTables()
version()
pydbc.py3.dbcParser.serializedATN()

pydbc.py3.dbcVisitor module

class pydbc.py3.dbcVisitor.dbcVisitor

Bases: antlr4.tree.Tree.ParseTreeVisitor

visitAccessNodes(ctx: pydbc.py3.dbcParser.dbcParser.AccessNodesContext)
visitAttributeDefault(ctx: pydbc.py3.dbcParser.dbcParser.AttributeDefaultContext)
visitAttributeDefaults(ctx: pydbc.py3.dbcParser.dbcParser.AttributeDefaultsContext)
visitAttributeDefinition(ctx: pydbc.py3.dbcParser.dbcParser.AttributeDefinitionContext)
visitAttributeDefinitions(ctx: pydbc.py3.dbcParser.dbcParser.AttributeDefinitionsContext)
visitAttributeValue(ctx: pydbc.py3.dbcParser.dbcParser.AttributeValueContext)
visitAttributeValueForObject(ctx: pydbc.py3.dbcParser.dbcParser.AttributeValueForObjectContext)
visitAttributeValueType(ctx: pydbc.py3.dbcParser.dbcParser.AttributeValueTypeContext)
visitAttributeValues(ctx: pydbc.py3.dbcParser.dbcParser.AttributeValuesContext)
visitBitTiming(ctx: pydbc.py3.dbcParser.dbcParser.BitTimingContext)
visitCategories(ctx: pydbc.py3.dbcParser.dbcParser.CategoriesContext)
visitCategory(ctx: pydbc.py3.dbcParser.dbcParser.CategoryContext)
visitCategoryDefinition(ctx: pydbc.py3.dbcParser.dbcParser.CategoryDefinitionContext)
visitCategoryDefinitions(ctx: pydbc.py3.dbcParser.dbcParser.CategoryDefinitionsContext)
visitComment(ctx: pydbc.py3.dbcParser.dbcParser.CommentContext)
visitComments(ctx: pydbc.py3.dbcParser.dbcParser.CommentsContext)
visitDbcfile(ctx: pydbc.py3.dbcParser.dbcParser.DbcfileContext)
visitEnvironmentVariable(ctx: pydbc.py3.dbcParser.dbcParser.EnvironmentVariableContext)
visitEnvironmentVariableData(ctx: pydbc.py3.dbcParser.dbcParser.EnvironmentVariableDataContext)
visitEnvironmentVariables(ctx: pydbc.py3.dbcParser.dbcParser.EnvironmentVariablesContext)
visitEnvironmentVariablesData(ctx: pydbc.py3.dbcParser.dbcParser.EnvironmentVariablesDataContext)
visitFloatValue(ctx: pydbc.py3.dbcParser.dbcParser.FloatValueContext)
visitIdentifierValue(ctx: pydbc.py3.dbcParser.dbcParser.IdentifierValueContext)
visitIntValue(ctx: pydbc.py3.dbcParser.dbcParser.IntValueContext)
visitMessage(ctx: pydbc.py3.dbcParser.dbcParser.MessageContext)
visitMessageTransmitter(ctx: pydbc.py3.dbcParser.dbcParser.MessageTransmitterContext)
visitMessageTransmitters(ctx: pydbc.py3.dbcParser.dbcParser.MessageTransmittersContext)
visitMessages(ctx: pydbc.py3.dbcParser.dbcParser.MessagesContext)
visitMultiplexerIndicator(ctx: pydbc.py3.dbcParser.dbcParser.MultiplexerIndicatorContext)
visitNewSymbols(ctx: pydbc.py3.dbcParser.dbcParser.NewSymbolsContext)
visitNodes(ctx: pydbc.py3.dbcParser.dbcParser.NodesContext)
visitNumber(ctx: pydbc.py3.dbcParser.dbcParser.NumberContext)
visitReceiver(ctx: pydbc.py3.dbcParser.dbcParser.ReceiverContext)
visitRelativeAttributeDefault(ctx: pydbc.py3.dbcParser.dbcParser.RelativeAttributeDefaultContext)
visitRelativeAttributeDefaults(ctx: pydbc.py3.dbcParser.dbcParser.RelativeAttributeDefaultsContext)
visitRelativeAttributeDefinition(ctx: pydbc.py3.dbcParser.dbcParser.RelativeAttributeDefinitionContext)
visitRelativeAttributeDefinitions(ctx: pydbc.py3.dbcParser.dbcParser.RelativeAttributeDefinitionsContext)
visitRelativeAttributeValueForObject(ctx: pydbc.py3.dbcParser.dbcParser.RelativeAttributeValueForObjectContext)
visitRelativeAttributeValues(ctx: pydbc.py3.dbcParser.dbcParser.RelativeAttributeValuesContext)
visitSignal(ctx: pydbc.py3.dbcParser.dbcParser.SignalContext)
visitSignalExtendedValueType(ctx: pydbc.py3.dbcParser.dbcParser.SignalExtendedValueTypeContext)
visitSignalExtendedValueTypeList(ctx: pydbc.py3.dbcParser.dbcParser.SignalExtendedValueTypeListContext)
visitSignalGroup(ctx: pydbc.py3.dbcParser.dbcParser.SignalGroupContext)
visitSignalGroups(ctx: pydbc.py3.dbcParser.dbcParser.SignalGroupsContext)
visitSignalType(ctx: pydbc.py3.dbcParser.dbcParser.SignalTypeContext)
visitSignalTypes(ctx: pydbc.py3.dbcParser.dbcParser.SignalTypesContext)
visitSpecializedValueDescription(ctx: pydbc.py3.dbcParser.dbcParser.SpecializedValueDescriptionContext)
visitStringValue(ctx: pydbc.py3.dbcParser.dbcParser.StringValueContext)
visitTransmitter(ctx: pydbc.py3.dbcParser.dbcParser.TransmitterContext)
visitValueDescription(ctx: pydbc.py3.dbcParser.dbcParser.ValueDescriptionContext)
visitValueDescriptions(ctx: pydbc.py3.dbcParser.dbcParser.ValueDescriptionsContext)
visitValueTable(ctx: pydbc.py3.dbcParser.dbcParser.ValueTableContext)
visitValueTables(ctx: pydbc.py3.dbcParser.dbcParser.ValueTablesContext)
visitVersion(ctx: pydbc.py3.dbcParser.dbcParser.VersionContext)

pydbc.py3.ldfLexer module

class pydbc.py3.ldfLexer.ldfLexer(input=None, output: TextIO = <_io.TextIOWrapper name='<stdout>' mode='w' encoding='UTF-8'>)

Bases: antlr4.Lexer.Lexer

COMMENT = 61
C_IDENTIFIER = 56
FLOAT = 57
HEX = 59
INT = 58
SIGN = 63
STRING = 62
T__0 = 1
T__1 = 2
T__10 = 11
T__11 = 12
T__12 = 13
T__13 = 14
T__14 = 15
T__15 = 16
T__16 = 17
T__17 = 18
T__18 = 19
T__19 = 20
T__2 = 3
T__20 = 21
T__21 = 22
T__22 = 23
T__23 = 24
T__24 = 25
T__25 = 26
T__26 = 27
T__27 = 28
T__28 = 29
T__29 = 30
T__3 = 4
T__30 = 31
T__31 = 32
T__32 = 33
T__33 = 34
T__34 = 35
T__35 = 36
T__36 = 37
T__37 = 38
T__38 = 39
T__39 = 40
T__4 = 5
T__40 = 41
T__41 = 42
T__42 = 43
T__43 = 44
T__44 = 45
T__45 = 46
T__46 = 47
T__47 = 48
T__48 = 49
T__49 = 50
T__5 = 6
T__50 = 51
T__51 = 52
T__52 = 53
T__53 = 54
T__54 = 55
T__6 = 7
T__7 = 8
T__8 = 9
T__9 = 10
WS = 60
atn = <antlr4.atn.ATN.ATN object>
channelNames = ['DEFAULT_TOKEN_CHANNEL', 'HIDDEN']
decisionsToDFA = [<antlr4.dfa.DFA.DFA object>, <antlr4.dfa.DFA.DFA object>, <antlr4.dfa.DFA.DFA object>, <antlr4.dfa.DFA.DFA object>, <antlr4.dfa.DFA.DFA object>, <antlr4.dfa.DFA.DFA object>, <antlr4.dfa.DFA.DFA object>, <antlr4.dfa.DFA.DFA object>, <antlr4.dfa.DFA.DFA object>, <antlr4.dfa.DFA.DFA object>, <antlr4.dfa.DFA.DFA object>, <antlr4.dfa.DFA.DFA object>, <antlr4.dfa.DFA.DFA object>, <antlr4.dfa.DFA.DFA object>, <antlr4.dfa.DFA.DFA object>, <antlr4.dfa.DFA.DFA object>, <antlr4.dfa.DFA.DFA object>, <antlr4.dfa.DFA.DFA object>, <antlr4.dfa.DFA.DFA object>, <antlr4.dfa.DFA.DFA object>, <antlr4.dfa.DFA.DFA object>]
grammarFileName = 'ldf.g4'
literalNames = ['<INVALID>', "'LIN_description_file'", "';'", "'LIN_protocol_version'", "'='", "'LIN_language_version'", "'LDF_file_revision'", "'LIN_speed'", "'kbps'", "'Channel_name'", "'Nodes'", "'{'", "'Master'", "':'", "','", "'ms'", "'Slaves'", "'}'", "'Node_attributes'", "'LIN_protocol'", "'configured_NAD'", "'initial_NAD'", "'product_id'", "'response_error'", "'fault_state_signals'", "'P2_min'", "'ST_min'", "'N_As_timeout'", "'N_Cr_timeout'", "'configurable_frames'", "'composite'", "'configuration'", "'Signals'", "'Diagnostic_signals'", "'Signal_groups'", "'Frames'", "'Sporadic_frames'", "'Event_triggered_frames'", "'Diagnostic_frames'", "'MasterReq'", "'SlaveResp'", "'Schedule_tables'", "'delay'", "'AssignNAD'", "'ConditionalChangeNAD'", "'DataDump'", "'SaveConfiguration'", "'AssignFrameIdRange'", "'FreeFormat'", "'AssignFrameId'", "'Signal_encoding_types'", "'logical_value'", "'physical_value'", "'bcd_value'", "'ascii_value'", "'Signal_representation'"]
modeNames = ['DEFAULT_MODE']
ruleNames = ['T__0', 'T__1', 'T__2', 'T__3', 'T__4', 'T__5', 'T__6', 'T__7', 'T__8', 'T__9', 'T__10', 'T__11', 'T__12', 'T__13', 'T__14', 'T__15', 'T__16', 'T__17', 'T__18', 'T__19', 'T__20', 'T__21', 'T__22', 'T__23', 'T__24', 'T__25', 'T__26', 'T__27', 'T__28', 'T__29', 'T__30', 'T__31', 'T__32', 'T__33', 'T__34', 'T__35', 'T__36', 'T__37', 'T__38', 'T__39', 'T__40', 'T__41', 'T__42', 'T__43', 'T__44', 'T__45', 'T__46', 'T__47', 'T__48', 'T__49', 'T__50', 'T__51', 'T__52', 'T__53', 'T__54', 'C_IDENTIFIER', 'EXPONENT', 'FLOAT', 'INT', 'HEX', 'HEX_DIGIT', 'ESC_SEQ', 'WS', 'COMMENT', 'STRING', 'SIGN']
symbolicNames = ['<INVALID>', 'C_IDENTIFIER', 'FLOAT', 'INT', 'HEX', 'WS', 'COMMENT', 'STRING', 'SIGN']
pydbc.py3.ldfLexer.serializedATN()

pydbc.py3.ldfListener module

pydbc.py3.ldfParser module

class pydbc.py3.ldfParser.ldfParser(input: antlr4.BufferedTokenStream.TokenStream, output: TextIO = <_io.TextIOWrapper name='<stdout>' mode='w' encoding='UTF-8'>)

Bases: antlr4.Parser.Parser

class Ascii_valueContext(parser, parent: antlr4.ParserRuleContext.ParserRuleContext = None, invokingState: int = -1)

Bases: antlr4.ParserRuleContext.ParserRuleContext

accept(visitor: antlr4.tree.Tree.ParseTreeVisitor)
enterRule(listener: antlr4.tree.Tree.ParseTreeListener)
exitRule(listener: antlr4.tree.Tree.ParseTreeListener)
getRuleIndex()
class Attributes_defContext(parser, parent: antlr4.ParserRuleContext.ParserRuleContext = None, invokingState: int = -1)

Bases: antlr4.ParserRuleContext.ParserRuleContext

accept(visitor: antlr4.tree.Tree.ParseTreeVisitor)
configurable_frames()
enterRule(listener: antlr4.tree.Tree.ParseTreeListener)
exitRule(listener: antlr4.tree.Tree.ParseTreeListener)
getRuleIndex()
identifierValue(i: int = None)
intValue(i: int = None)
number(i: int = None)
class Bcd_valueContext(parser, parent: antlr4.ParserRuleContext.ParserRuleContext = None, invokingState: int = -1)

Bases: antlr4.ParserRuleContext.ParserRuleContext

accept(visitor: antlr4.tree.Tree.ParseTreeVisitor)
enterRule(listener: antlr4.tree.Tree.ParseTreeListener)
exitRule(listener: antlr4.tree.Tree.ParseTreeListener)
getRuleIndex()
COMMENT = 61
C_IDENTIFIER = 56
class Channel_name_defContext(parser, parent: antlr4.ParserRuleContext.ParserRuleContext = None, invokingState: int = -1)

Bases: antlr4.ParserRuleContext.ParserRuleContext

accept(visitor: antlr4.tree.Tree.ParseTreeVisitor)
enterRule(listener: antlr4.tree.Tree.ParseTreeListener)
exitRule(listener: antlr4.tree.Tree.ParseTreeListener)
getRuleIndex()
identifierValue()
class CommandContext(parser, parent: antlr4.ParserRuleContext.ParserRuleContext = None, invokingState: int = -1)

Bases: antlr4.ParserRuleContext.ParserRuleContext

accept(visitor: antlr4.tree.Tree.ParseTreeVisitor)
enterRule(listener: antlr4.tree.Tree.ParseTreeListener)
exitRule(listener: antlr4.tree.Tree.ParseTreeListener)
getRuleIndex()
identifierValue(i: int = None)
intValue(i: int = None)
class Configurable_frameContext(parser, parent: antlr4.ParserRuleContext.ParserRuleContext = None, invokingState: int = -1)

Bases: antlr4.ParserRuleContext.ParserRuleContext

accept(visitor: antlr4.tree.Tree.ParseTreeVisitor)
enterRule(listener: antlr4.tree.Tree.ParseTreeListener)
exitRule(listener: antlr4.tree.Tree.ParseTreeListener)
getRuleIndex()
identifierValue()
intValue()
class Configurable_framesContext(parser, parent: antlr4.ParserRuleContext.ParserRuleContext = None, invokingState: int = -1)

Bases: antlr4.ParserRuleContext.ParserRuleContext

accept(visitor: antlr4.tree.Tree.ParseTreeVisitor)
configurable_frame(i: int = None)
enterRule(listener: antlr4.tree.Tree.ParseTreeListener)
exitRule(listener: antlr4.tree.Tree.ParseTreeListener)
getRuleIndex()
class ConfigurationContext(parser, parent: antlr4.ParserRuleContext.ParserRuleContext = None, invokingState: int = -1)

Bases: antlr4.ParserRuleContext.ParserRuleContext

accept(visitor: antlr4.tree.Tree.ParseTreeVisitor)
configuration_item(i: int = None)
enterRule(listener: antlr4.tree.Tree.ParseTreeListener)
exitRule(listener: antlr4.tree.Tree.ParseTreeListener)
getRuleIndex()
identifierValue()
class Configuration_itemContext(parser, parent: antlr4.ParserRuleContext.ParserRuleContext = None, invokingState: int = -1)

Bases: antlr4.ParserRuleContext.ParserRuleContext

accept(visitor: antlr4.tree.Tree.ParseTreeVisitor)
enterRule(listener: antlr4.tree.Tree.ParseTreeListener)
exitRule(listener: antlr4.tree.Tree.ParseTreeListener)
getRuleIndex()
identifierValue(i: int = None)
class Diag_frame_defContext(parser, parent: antlr4.ParserRuleContext.ParserRuleContext = None, invokingState: int = -1)

Bases: antlr4.ParserRuleContext.ParserRuleContext

accept(visitor: antlr4.tree.Tree.ParseTreeVisitor)
diag_frame_item(i: int = None)
enterRule(listener: antlr4.tree.Tree.ParseTreeListener)
exitRule(listener: antlr4.tree.Tree.ParseTreeListener)
getRuleIndex()
intValue(i: int = None)
class Diag_frame_itemContext(parser, parent: antlr4.ParserRuleContext.ParserRuleContext = None, invokingState: int = -1)

Bases: antlr4.ParserRuleContext.ParserRuleContext

accept(visitor: antlr4.tree.Tree.ParseTreeVisitor)
enterRule(listener: antlr4.tree.Tree.ParseTreeListener)
exitRule(listener: antlr4.tree.Tree.ParseTreeListener)
getRuleIndex()
identifierValue()
intValue()
class Diagnostic_itemContext(parser, parent: antlr4.ParserRuleContext.ParserRuleContext = None, invokingState: int = -1)

Bases: antlr4.ParserRuleContext.ParserRuleContext

accept(visitor: antlr4.tree.Tree.ParseTreeVisitor)
enterRule(listener: antlr4.tree.Tree.ParseTreeListener)
exitRule(listener: antlr4.tree.Tree.ParseTreeListener)
getRuleIndex()
identifierValue()
init_value(i: int = None)
class Diagnostic_signal_defContext(parser, parent: antlr4.ParserRuleContext.ParserRuleContext = None, invokingState: int = -1)

Bases: antlr4.ParserRuleContext.ParserRuleContext

accept(visitor: antlr4.tree.Tree.ParseTreeVisitor)
diagnostic_item(i: int = None)
enterRule(listener: antlr4.tree.Tree.ParseTreeListener)
exitRule(listener: antlr4.tree.Tree.ParseTreeListener)
getRuleIndex()
EOF = -1
class Event_triggered_frame_defContext(parser, parent: antlr4.ParserRuleContext.ParserRuleContext = None, invokingState: int = -1)

Bases: antlr4.ParserRuleContext.ParserRuleContext

accept(visitor: antlr4.tree.Tree.ParseTreeVisitor)
enterRule(listener: antlr4.tree.Tree.ParseTreeListener)
event_triggered_frame_item(i: int = None)
exitRule(listener: antlr4.tree.Tree.ParseTreeListener)
getRuleIndex()
class Event_triggered_frame_itemContext(parser, parent: antlr4.ParserRuleContext.ParserRuleContext = None, invokingState: int = -1)

Bases: antlr4.ParserRuleContext.ParserRuleContext

accept(visitor: antlr4.tree.Tree.ParseTreeVisitor)
enterRule(listener: antlr4.tree.Tree.ParseTreeListener)
exitRule(listener: antlr4.tree.Tree.ParseTreeListener)
getRuleIndex()
identifierValue(i: int = None)
intValue()
FLOAT = 57
class FloatValueContext(parser, parent: antlr4.ParserRuleContext.ParserRuleContext = None, invokingState: int = -1)

Bases: antlr4.ParserRuleContext.ParserRuleContext

FLOAT()
accept(visitor: antlr4.tree.Tree.ParseTreeVisitor)
enterRule(listener: antlr4.tree.Tree.ParseTreeListener)
exitRule(listener: antlr4.tree.Tree.ParseTreeListener)
getRuleIndex()
class Frame_defContext(parser, parent: antlr4.ParserRuleContext.ParserRuleContext = None, invokingState: int = -1)

Bases: antlr4.ParserRuleContext.ParserRuleContext

accept(visitor: antlr4.tree.Tree.ParseTreeVisitor)
enterRule(listener: antlr4.tree.Tree.ParseTreeListener)
exitRule(listener: antlr4.tree.Tree.ParseTreeListener)
frame_item(i: int = None)
getRuleIndex()
class Frame_itemContext(parser, parent: antlr4.ParserRuleContext.ParserRuleContext = None, invokingState: int = -1)

Bases: antlr4.ParserRuleContext.ParserRuleContext

accept(visitor: antlr4.tree.Tree.ParseTreeVisitor)
enterRule(listener: antlr4.tree.Tree.ParseTreeListener)
exitRule(listener: antlr4.tree.Tree.ParseTreeListener)
frame_signal(i: int = None)
getRuleIndex()
identifierValue(i: int = None)
intValue(i: int = None)
class Frame_signalContext(parser, parent: antlr4.ParserRuleContext.ParserRuleContext = None, invokingState: int = -1)

Bases: antlr4.ParserRuleContext.ParserRuleContext

accept(visitor: antlr4.tree.Tree.ParseTreeVisitor)
enterRule(listener: antlr4.tree.Tree.ParseTreeListener)
exitRule(listener: antlr4.tree.Tree.ParseTreeListener)
getRuleIndex()
identifierValue()
intValue()
HEX = 59
INT = 58
class IdentifierValueContext(parser, parent: antlr4.ParserRuleContext.ParserRuleContext = None, invokingState: int = -1)

Bases: antlr4.ParserRuleContext.ParserRuleContext

C_IDENTIFIER()
accept(visitor: antlr4.tree.Tree.ParseTreeVisitor)
enterRule(listener: antlr4.tree.Tree.ParseTreeListener)
exitRule(listener: antlr4.tree.Tree.ParseTreeListener)
getRuleIndex()
class Init_valueContext(parser, parent: antlr4.ParserRuleContext.ParserRuleContext = None, invokingState: int = -1)

Bases: antlr4.ParserRuleContext.ParserRuleContext

accept(visitor: antlr4.tree.Tree.ParseTreeVisitor)
enterRule(listener: antlr4.tree.Tree.ParseTreeListener)
exitRule(listener: antlr4.tree.Tree.ParseTreeListener)
getRuleIndex()
init_value_array()
init_value_scalar()
class Init_value_arrayContext(parser, parent: antlr4.ParserRuleContext.ParserRuleContext = None, invokingState: int = -1)

Bases: antlr4.ParserRuleContext.ParserRuleContext

accept(visitor: antlr4.tree.Tree.ParseTreeVisitor)
enterRule(listener: antlr4.tree.Tree.ParseTreeListener)
exitRule(listener: antlr4.tree.Tree.ParseTreeListener)
getRuleIndex()
intValue(i: int = None)
class Init_value_scalarContext(parser, parent: antlr4.ParserRuleContext.ParserRuleContext = None, invokingState: int = -1)

Bases: antlr4.ParserRuleContext.ParserRuleContext

accept(visitor: antlr4.tree.Tree.ParseTreeVisitor)
enterRule(listener: antlr4.tree.Tree.ParseTreeListener)
exitRule(listener: antlr4.tree.Tree.ParseTreeListener)
getRuleIndex()
intValue()
class IntValueContext(parser, parent: antlr4.ParserRuleContext.ParserRuleContext = None, invokingState: int = -1)

Bases: antlr4.ParserRuleContext.ParserRuleContext

HEX()
INT()
accept(visitor: antlr4.tree.Tree.ParseTreeVisitor)
enterRule(listener: antlr4.tree.Tree.ParseTreeListener)
exitRule(listener: antlr4.tree.Tree.ParseTreeListener)
getRuleIndex()
class Lin_description_fileContext(parser, parent: antlr4.ParserRuleContext.ParserRuleContext = None, invokingState: int = -1)

Bases: antlr4.ParserRuleContext.ParserRuleContext

accept(visitor: antlr4.tree.Tree.ParseTreeVisitor)
channel_name_def()
diag_frame_def()
diagnostic_signal_def()
enterRule(listener: antlr4.tree.Tree.ParseTreeListener)
event_triggered_frame_def()
exitRule(listener: antlr4.tree.Tree.ParseTreeListener)
frame_def()
getRuleIndex()
lin_file_revision_def()
lin_language_version_def()
lin_protocol_version_def()
lin_speed_def()
node_attributes_def()
node_composition_def()
node_def()
schedule_table_def()
signal_def()
signal_encoding_type_def()
signal_groups_def()
signal_representation_def()
sporadic_frame_def()
class Lin_file_revision_defContext(parser, parent: antlr4.ParserRuleContext.ParserRuleContext = None, invokingState: int = -1)

Bases: antlr4.ParserRuleContext.ParserRuleContext

accept(visitor: antlr4.tree.Tree.ParseTreeVisitor)
enterRule(listener: antlr4.tree.Tree.ParseTreeListener)
exitRule(listener: antlr4.tree.Tree.ParseTreeListener)
getRuleIndex()
stringValue()
class Lin_language_version_defContext(parser, parent: antlr4.ParserRuleContext.ParserRuleContext = None, invokingState: int = -1)

Bases: antlr4.ParserRuleContext.ParserRuleContext

accept(visitor: antlr4.tree.Tree.ParseTreeVisitor)
enterRule(listener: antlr4.tree.Tree.ParseTreeListener)
exitRule(listener: antlr4.tree.Tree.ParseTreeListener)
getRuleIndex()
stringValue()
class Lin_protocol_version_defContext(parser, parent: antlr4.ParserRuleContext.ParserRuleContext = None, invokingState: int = -1)

Bases: antlr4.ParserRuleContext.ParserRuleContext

accept(visitor: antlr4.tree.Tree.ParseTreeVisitor)
enterRule(listener: antlr4.tree.Tree.ParseTreeListener)
exitRule(listener: antlr4.tree.Tree.ParseTreeListener)
getRuleIndex()
stringValue()
class Lin_speed_defContext(parser, parent: antlr4.ParserRuleContext.ParserRuleContext = None, invokingState: int = -1)

Bases: antlr4.ParserRuleContext.ParserRuleContext

accept(visitor: antlr4.tree.Tree.ParseTreeVisitor)
enterRule(listener: antlr4.tree.Tree.ParseTreeListener)
exitRule(listener: antlr4.tree.Tree.ParseTreeListener)
getRuleIndex()
number()
class Logical_valueContext(parser, parent: antlr4.ParserRuleContext.ParserRuleContext = None, invokingState: int = -1)

Bases: antlr4.ParserRuleContext.ParserRuleContext

accept(visitor: antlr4.tree.Tree.ParseTreeVisitor)
enterRule(listener: antlr4.tree.Tree.ParseTreeListener)
exitRule(listener: antlr4.tree.Tree.ParseTreeListener)
getRuleIndex()
intValue()
stringValue()
class Node_attributeContext(parser, parent: antlr4.ParserRuleContext.ParserRuleContext = None, invokingState: int = -1)

Bases: antlr4.ParserRuleContext.ParserRuleContext

accept(visitor: antlr4.tree.Tree.ParseTreeVisitor)
attributes_def()
enterRule(listener: antlr4.tree.Tree.ParseTreeListener)
exitRule(listener: antlr4.tree.Tree.ParseTreeListener)
getRuleIndex()
identifierValue()
intValue(i: int = None)
stringValue()
class Node_attributes_defContext(parser, parent: antlr4.ParserRuleContext.ParserRuleContext = None, invokingState: int = -1)

Bases: antlr4.ParserRuleContext.ParserRuleContext

accept(visitor: antlr4.tree.Tree.ParseTreeVisitor)
enterRule(listener: antlr4.tree.Tree.ParseTreeListener)
exitRule(listener: antlr4.tree.Tree.ParseTreeListener)
getRuleIndex()
node_attribute(i: int = None)
class Node_composition_defContext(parser, parent: antlr4.ParserRuleContext.ParserRuleContext = None, invokingState: int = -1)

Bases: antlr4.ParserRuleContext.ParserRuleContext

accept(visitor: antlr4.tree.Tree.ParseTreeVisitor)
configuration(i: int = None)
enterRule(listener: antlr4.tree.Tree.ParseTreeListener)
exitRule(listener: antlr4.tree.Tree.ParseTreeListener)
getRuleIndex()
class Node_defContext(parser, parent: antlr4.ParserRuleContext.ParserRuleContext = None, invokingState: int = -1)

Bases: antlr4.ParserRuleContext.ParserRuleContext

accept(visitor: antlr4.tree.Tree.ParseTreeVisitor)
enterRule(listener: antlr4.tree.Tree.ParseTreeListener)
exitRule(listener: antlr4.tree.Tree.ParseTreeListener)
getRuleIndex()
identifierValue(i: int = None)
number(i: int = None)
class NumberContext(parser, parent: antlr4.ParserRuleContext.ParserRuleContext = None, invokingState: int = -1)

Bases: antlr4.ParserRuleContext.ParserRuleContext

accept(visitor: antlr4.tree.Tree.ParseTreeVisitor)
enterRule(listener: antlr4.tree.Tree.ParseTreeListener)
exitRule(listener: antlr4.tree.Tree.ParseTreeListener)
floatValue()
getRuleIndex()
intValue()
class Physical_rangeContext(parser, parent: antlr4.ParserRuleContext.ParserRuleContext = None, invokingState: int = -1)

Bases: antlr4.ParserRuleContext.ParserRuleContext

accept(visitor: antlr4.tree.Tree.ParseTreeVisitor)
enterRule(listener: antlr4.tree.Tree.ParseTreeListener)
exitRule(listener: antlr4.tree.Tree.ParseTreeListener)
getRuleIndex()
intValue(i: int = None)
number(i: int = None)
stringValue()
RULE_ascii_value = 44
RULE_attributes_def = 9
RULE_bcd_value = 43
RULE_channel_name_def = 5
RULE_command = 37
RULE_configurable_frame = 11
RULE_configurable_frames = 10
RULE_configuration = 13
RULE_configuration_item = 14
RULE_diag_frame_def = 32
RULE_diag_frame_item = 33
RULE_diagnostic_item = 21
RULE_diagnostic_signal_def = 20
RULE_event_triggered_frame_def = 30
RULE_event_triggered_frame_item = 31
RULE_floatValue = 48
RULE_frame_def = 25
RULE_frame_item = 26
RULE_frame_signal = 27
RULE_identifierValue = 51
RULE_init_value = 17
RULE_init_value_array = 19
RULE_init_value_scalar = 18
RULE_intValue = 47
RULE_lin_description_file = 0
RULE_lin_file_revision_def = 3
RULE_lin_language_version_def = 2
RULE_lin_protocol_version_def = 1
RULE_lin_speed_def = 4
RULE_logical_value = 41
RULE_node_attribute = 8
RULE_node_attributes_def = 7
RULE_node_composition_def = 12
RULE_node_def = 6
RULE_number = 49
RULE_physical_range = 42
RULE_schedule_table_command = 36
RULE_schedule_table_def = 34
RULE_schedule_table_entry = 35
RULE_signal_def = 15
RULE_signal_encoding_entry = 39
RULE_signal_encoding_type_def = 38
RULE_signal_encoding_value = 40
RULE_signal_group = 23
RULE_signal_group_item = 24
RULE_signal_groups_def = 22
RULE_signal_item = 16
RULE_signal_representation_def = 45
RULE_signal_representation_entry = 46
RULE_sporadic_frame_def = 28
RULE_sporadic_frame_item = 29
RULE_stringValue = 50
SIGN = 63
STRING = 62
class Schedule_table_commandContext(parser, parent: antlr4.ParserRuleContext.ParserRuleContext = None, invokingState: int = -1)

Bases: antlr4.ParserRuleContext.ParserRuleContext

accept(visitor: antlr4.tree.Tree.ParseTreeVisitor)
command()
enterRule(listener: antlr4.tree.Tree.ParseTreeListener)
exitRule(listener: antlr4.tree.Tree.ParseTreeListener)
getRuleIndex()
number()
class Schedule_table_defContext(parser, parent: antlr4.ParserRuleContext.ParserRuleContext = None, invokingState: int = -1)

Bases: antlr4.ParserRuleContext.ParserRuleContext

accept(visitor: antlr4.tree.Tree.ParseTreeVisitor)
enterRule(listener: antlr4.tree.Tree.ParseTreeListener)
exitRule(listener: antlr4.tree.Tree.ParseTreeListener)
getRuleIndex()
schedule_table_entry(i: int = None)
class Schedule_table_entryContext(parser, parent: antlr4.ParserRuleContext.ParserRuleContext = None, invokingState: int = -1)

Bases: antlr4.ParserRuleContext.ParserRuleContext

accept(visitor: antlr4.tree.Tree.ParseTreeVisitor)
enterRule(listener: antlr4.tree.Tree.ParseTreeListener)
exitRule(listener: antlr4.tree.Tree.ParseTreeListener)
getRuleIndex()
identifierValue()
schedule_table_command(i: int = None)
class Signal_defContext(parser, parent: antlr4.ParserRuleContext.ParserRuleContext = None, invokingState: int = -1)

Bases: antlr4.ParserRuleContext.ParserRuleContext

accept(visitor: antlr4.tree.Tree.ParseTreeVisitor)
enterRule(listener: antlr4.tree.Tree.ParseTreeListener)
exitRule(listener: antlr4.tree.Tree.ParseTreeListener)
getRuleIndex()
signal_item(i: int = None)
class Signal_encoding_entryContext(parser, parent: antlr4.ParserRuleContext.ParserRuleContext = None, invokingState: int = -1)

Bases: antlr4.ParserRuleContext.ParserRuleContext

accept(visitor: antlr4.tree.Tree.ParseTreeVisitor)
enterRule(listener: antlr4.tree.Tree.ParseTreeListener)
exitRule(listener: antlr4.tree.Tree.ParseTreeListener)
getRuleIndex()
identifierValue()
signal_encoding_value(i: int = None)
class Signal_encoding_type_defContext(parser, parent: antlr4.ParserRuleContext.ParserRuleContext = None, invokingState: int = -1)

Bases: antlr4.ParserRuleContext.ParserRuleContext

accept(visitor: antlr4.tree.Tree.ParseTreeVisitor)
enterRule(listener: antlr4.tree.Tree.ParseTreeListener)
exitRule(listener: antlr4.tree.Tree.ParseTreeListener)
getRuleIndex()
signal_encoding_entry(i: int = None)
class Signal_encoding_valueContext(parser, parent: antlr4.ParserRuleContext.ParserRuleContext = None, invokingState: int = -1)

Bases: antlr4.ParserRuleContext.ParserRuleContext

accept(visitor: antlr4.tree.Tree.ParseTreeVisitor)
ascii_value()
bcd_value()
enterRule(listener: antlr4.tree.Tree.ParseTreeListener)
exitRule(listener: antlr4.tree.Tree.ParseTreeListener)
getRuleIndex()
logical_value()
physical_range()
class Signal_groupContext(parser, parent: antlr4.ParserRuleContext.ParserRuleContext = None, invokingState: int = -1)

Bases: antlr4.ParserRuleContext.ParserRuleContext

accept(visitor: antlr4.tree.Tree.ParseTreeVisitor)
enterRule(listener: antlr4.tree.Tree.ParseTreeListener)
exitRule(listener: antlr4.tree.Tree.ParseTreeListener)
getRuleIndex()
identifierValue()
intValue()
signal_group_item(i: int = None)
class Signal_group_itemContext(parser, parent: antlr4.ParserRuleContext.ParserRuleContext = None, invokingState: int = -1)

Bases: antlr4.ParserRuleContext.ParserRuleContext

accept(visitor: antlr4.tree.Tree.ParseTreeVisitor)
enterRule(listener: antlr4.tree.Tree.ParseTreeListener)
exitRule(listener: antlr4.tree.Tree.ParseTreeListener)
getRuleIndex()
identifierValue()
intValue()
class Signal_groups_defContext(parser, parent: antlr4.ParserRuleContext.ParserRuleContext = None, invokingState: int = -1)

Bases: antlr4.ParserRuleContext.ParserRuleContext

accept(visitor: antlr4.tree.Tree.ParseTreeVisitor)
enterRule(listener: antlr4.tree.Tree.ParseTreeListener)
exitRule(listener: antlr4.tree.Tree.ParseTreeListener)
getRuleIndex()
signal_group(i: int = None)
class Signal_itemContext(parser, parent: antlr4.ParserRuleContext.ParserRuleContext = None, invokingState: int = -1)

Bases: antlr4.ParserRuleContext.ParserRuleContext

accept(visitor: antlr4.tree.Tree.ParseTreeVisitor)
enterRule(listener: antlr4.tree.Tree.ParseTreeListener)
exitRule(listener: antlr4.tree.Tree.ParseTreeListener)
getRuleIndex()
identifierValue(i: int = None)
init_value()
intValue()
class Signal_representation_defContext(parser, parent: antlr4.ParserRuleContext.ParserRuleContext = None, invokingState: int = -1)

Bases: antlr4.ParserRuleContext.ParserRuleContext

accept(visitor: antlr4.tree.Tree.ParseTreeVisitor)
enterRule(listener: antlr4.tree.Tree.ParseTreeListener)
exitRule(listener: antlr4.tree.Tree.ParseTreeListener)
getRuleIndex()
signal_representation_entry(i: int = None)
class Signal_representation_entryContext(parser, parent: antlr4.ParserRuleContext.ParserRuleContext = None, invokingState: int = -1)

Bases: antlr4.ParserRuleContext.ParserRuleContext

accept(visitor: antlr4.tree.Tree.ParseTreeVisitor)
enterRule(listener: antlr4.tree.Tree.ParseTreeListener)
exitRule(listener: antlr4.tree.Tree.ParseTreeListener)
getRuleIndex()
identifierValue(i: int = None)
class Sporadic_frame_defContext(parser, parent: antlr4.ParserRuleContext.ParserRuleContext = None, invokingState: int = -1)

Bases: antlr4.ParserRuleContext.ParserRuleContext

accept(visitor: antlr4.tree.Tree.ParseTreeVisitor)
enterRule(listener: antlr4.tree.Tree.ParseTreeListener)
exitRule(listener: antlr4.tree.Tree.ParseTreeListener)
getRuleIndex()
sporadic_frame_item(i: int = None)
class Sporadic_frame_itemContext(parser, parent: antlr4.ParserRuleContext.ParserRuleContext = None, invokingState: int = -1)

Bases: antlr4.ParserRuleContext.ParserRuleContext

accept(visitor: antlr4.tree.Tree.ParseTreeVisitor)
enterRule(listener: antlr4.tree.Tree.ParseTreeListener)
exitRule(listener: antlr4.tree.Tree.ParseTreeListener)
getRuleIndex()
identifierValue(i: int = None)
class StringValueContext(parser, parent: antlr4.ParserRuleContext.ParserRuleContext = None, invokingState: int = -1)

Bases: antlr4.ParserRuleContext.ParserRuleContext

STRING()
accept(visitor: antlr4.tree.Tree.ParseTreeVisitor)
enterRule(listener: antlr4.tree.Tree.ParseTreeListener)
exitRule(listener: antlr4.tree.Tree.ParseTreeListener)
getRuleIndex()
T__0 = 1
T__1 = 2
T__10 = 11
T__11 = 12
T__12 = 13
T__13 = 14
T__14 = 15
T__15 = 16
T__16 = 17
T__17 = 18
T__18 = 19
T__19 = 20
T__2 = 3
T__20 = 21
T__21 = 22
T__22 = 23
T__23 = 24
T__24 = 25
T__25 = 26
T__26 = 27
T__27 = 28
T__28 = 29
T__29 = 30
T__3 = 4
T__30 = 31
T__31 = 32
T__32 = 33
T__33 = 34
T__34 = 35
T__35 = 36
T__36 = 37
T__37 = 38
T__38 = 39
T__39 = 40
T__4 = 5
T__40 = 41
T__41 = 42
T__42 = 43
T__43 = 44
T__44 = 45
T__45 = 46
T__46 = 47
T__47 = 48
T__48 = 49
T__49 = 50
T__5 = 6
T__50 = 51
T__51 = 52
T__52 = 53
T__53 = 54
T__54 = 55
T__6 = 7
T__7 = 8
T__8 = 9
T__9 = 10
WS = 60
ascii_value()
atn = <antlr4.atn.ATN.ATN object>
attributes_def()
bcd_value()
channel_name_def()
command()
configurable_frame()
configurable_frames()
configuration()
configuration_item()
decisionsToDFA = [<antlr4.dfa.DFA.DFA object>, <antlr4.dfa.DFA.DFA object>, <antlr4.dfa.DFA.DFA object>, <antlr4.dfa.DFA.DFA object>, <antlr4.dfa.DFA.DFA object>, <antlr4.dfa.DFA.DFA object>, <antlr4.dfa.DFA.DFA object>, <antlr4.dfa.DFA.DFA object>, <antlr4.dfa.DFA.DFA object>, <antlr4.dfa.DFA.DFA object>, <antlr4.dfa.DFA.DFA object>, <antlr4.dfa.DFA.DFA object>, <antlr4.dfa.DFA.DFA object>, <antlr4.dfa.DFA.DFA object>, <antlr4.dfa.DFA.DFA object>, <antlr4.dfa.DFA.DFA object>, <antlr4.dfa.DFA.DFA object>, <antlr4.dfa.DFA.DFA object>, <antlr4.dfa.DFA.DFA object>, <antlr4.dfa.DFA.DFA object>, <antlr4.dfa.DFA.DFA object>, <antlr4.dfa.DFA.DFA object>, <antlr4.dfa.DFA.DFA object>, <antlr4.dfa.DFA.DFA object>, <antlr4.dfa.DFA.DFA object>, <antlr4.dfa.DFA.DFA object>, <antlr4.dfa.DFA.DFA object>, <antlr4.dfa.DFA.DFA object>, <antlr4.dfa.DFA.DFA object>, <antlr4.dfa.DFA.DFA object>, <antlr4.dfa.DFA.DFA object>, <antlr4.dfa.DFA.DFA object>, <antlr4.dfa.DFA.DFA object>, <antlr4.dfa.DFA.DFA object>, <antlr4.dfa.DFA.DFA object>, <antlr4.dfa.DFA.DFA object>, <antlr4.dfa.DFA.DFA object>, <antlr4.dfa.DFA.DFA object>, <antlr4.dfa.DFA.DFA object>, <antlr4.dfa.DFA.DFA object>, <antlr4.dfa.DFA.DFA object>, <antlr4.dfa.DFA.DFA object>, <antlr4.dfa.DFA.DFA object>, <antlr4.dfa.DFA.DFA object>, <antlr4.dfa.DFA.DFA object>, <antlr4.dfa.DFA.DFA object>, <antlr4.dfa.DFA.DFA object>, <antlr4.dfa.DFA.DFA object>, <antlr4.dfa.DFA.DFA object>, <antlr4.dfa.DFA.DFA object>, <antlr4.dfa.DFA.DFA object>, <antlr4.dfa.DFA.DFA object>, <antlr4.dfa.DFA.DFA object>, <antlr4.dfa.DFA.DFA object>]
diag_frame_def()
diag_frame_item()
diagnostic_item()
diagnostic_signal_def()
event_triggered_frame_def()
event_triggered_frame_item()
floatValue()
frame_def()
frame_item()
frame_signal()
grammarFileName = 'ldf.g4'
identifierValue()
init_value()
init_value_array()
init_value_scalar()
intValue()
lin_description_file()
lin_file_revision_def()
lin_language_version_def()
lin_protocol_version_def()
lin_speed_def()
literalNames = ['<INVALID>', "'LIN_description_file'", "';'", "'LIN_protocol_version'", "'='", "'LIN_language_version'", "'LDF_file_revision'", "'LIN_speed'", "'kbps'", "'Channel_name'", "'Nodes'", "'{'", "'Master'", "':'", "','", "'ms'", "'Slaves'", "'}'", "'Node_attributes'", "'LIN_protocol'", "'configured_NAD'", "'initial_NAD'", "'product_id'", "'response_error'", "'fault_state_signals'", "'P2_min'", "'ST_min'", "'N_As_timeout'", "'N_Cr_timeout'", "'configurable_frames'", "'composite'", "'configuration'", "'Signals'", "'Diagnostic_signals'", "'Signal_groups'", "'Frames'", "'Sporadic_frames'", "'Event_triggered_frames'", "'Diagnostic_frames'", "'MasterReq'", "'SlaveResp'", "'Schedule_tables'", "'delay'", "'AssignNAD'", "'ConditionalChangeNAD'", "'DataDump'", "'SaveConfiguration'", "'AssignFrameIdRange'", "'FreeFormat'", "'AssignFrameId'", "'Signal_encoding_types'", "'logical_value'", "'physical_value'", "'bcd_value'", "'ascii_value'", "'Signal_representation'"]
logical_value()
node_attribute()
node_attributes_def()
node_composition_def()
node_def()
number()
physical_range()
ruleNames = ['lin_description_file', 'lin_protocol_version_def', 'lin_language_version_def', 'lin_file_revision_def', 'lin_speed_def', 'channel_name_def', 'node_def', 'node_attributes_def', 'node_attribute', 'attributes_def', 'configurable_frames', 'configurable_frame', 'node_composition_def', 'configuration', 'configuration_item', 'signal_def', 'signal_item', 'init_value', 'init_value_scalar', 'init_value_array', 'diagnostic_signal_def', 'diagnostic_item', 'signal_groups_def', 'signal_group', 'signal_group_item', 'frame_def', 'frame_item', 'frame_signal', 'sporadic_frame_def', 'sporadic_frame_item', 'event_triggered_frame_def', 'event_triggered_frame_item', 'diag_frame_def', 'diag_frame_item', 'schedule_table_def', 'schedule_table_entry', 'schedule_table_command', 'command', 'signal_encoding_type_def', 'signal_encoding_entry', 'signal_encoding_value', 'logical_value', 'physical_range', 'bcd_value', 'ascii_value', 'signal_representation_def', 'signal_representation_entry', 'intValue', 'floatValue', 'number', 'stringValue', 'identifierValue']
schedule_table_command()
schedule_table_def()
schedule_table_entry()
sharedContextCache = <antlr4.PredictionContext.PredictionContextCache object>
signal_def()
signal_encoding_entry()
signal_encoding_type_def()
signal_encoding_value()
signal_group()
signal_group_item()
signal_groups_def()
signal_item()
signal_representation_def()
signal_representation_entry()
sporadic_frame_def()
sporadic_frame_item()
stringValue()
symbolicNames = ['<INVALID>', '<INVALID>', '<INVALID>', '<INVALID>', '<INVALID>', '<INVALID>', '<INVALID>', '<INVALID>', '<INVALID>', '<INVALID>', '<INVALID>', '<INVALID>', '<INVALID>', '<INVALID>', '<INVALID>', '<INVALID>', '<INVALID>', '<INVALID>', '<INVALID>', '<INVALID>', '<INVALID>', '<INVALID>', '<INVALID>', '<INVALID>', '<INVALID>', '<INVALID>', '<INVALID>', '<INVALID>', '<INVALID>', '<INVALID>', '<INVALID>', '<INVALID>', '<INVALID>', '<INVALID>', '<INVALID>', '<INVALID>', '<INVALID>', '<INVALID>', '<INVALID>', '<INVALID>', '<INVALID>', '<INVALID>', '<INVALID>', '<INVALID>', '<INVALID>', '<INVALID>', '<INVALID>', '<INVALID>', '<INVALID>', '<INVALID>', '<INVALID>', '<INVALID>', '<INVALID>', '<INVALID>', '<INVALID>', '<INVALID>', 'C_IDENTIFIER', 'FLOAT', 'INT', 'HEX', 'WS', 'COMMENT', 'STRING', 'SIGN']
pydbc.py3.ldfParser.serializedATN()

pydbc.py3.ldfVisitor module

class pydbc.py3.ldfVisitor.ldfVisitor

Bases: antlr4.tree.Tree.ParseTreeVisitor

visitAscii_value(ctx: pydbc.py3.ldfParser.ldfParser.Ascii_valueContext)
visitAttributes_def(ctx: pydbc.py3.ldfParser.ldfParser.Attributes_defContext)
visitBcd_value(ctx: pydbc.py3.ldfParser.ldfParser.Bcd_valueContext)
visitChannel_name_def(ctx: pydbc.py3.ldfParser.ldfParser.Channel_name_defContext)
visitCommand(ctx: pydbc.py3.ldfParser.ldfParser.CommandContext)
visitConfigurable_frame(ctx: pydbc.py3.ldfParser.ldfParser.Configurable_frameContext)
visitConfigurable_frames(ctx: pydbc.py3.ldfParser.ldfParser.Configurable_framesContext)
visitConfiguration(ctx: pydbc.py3.ldfParser.ldfParser.ConfigurationContext)
visitConfiguration_item(ctx: pydbc.py3.ldfParser.ldfParser.Configuration_itemContext)
visitDiag_frame_def(ctx: pydbc.py3.ldfParser.ldfParser.Diag_frame_defContext)
visitDiag_frame_item(ctx: pydbc.py3.ldfParser.ldfParser.Diag_frame_itemContext)
visitDiagnostic_item(ctx: pydbc.py3.ldfParser.ldfParser.Diagnostic_itemContext)
visitDiagnostic_signal_def(ctx: pydbc.py3.ldfParser.ldfParser.Diagnostic_signal_defContext)
visitEvent_triggered_frame_def(ctx: pydbc.py3.ldfParser.ldfParser.Event_triggered_frame_defContext)
visitEvent_triggered_frame_item(ctx: pydbc.py3.ldfParser.ldfParser.Event_triggered_frame_itemContext)
visitFloatValue(ctx: pydbc.py3.ldfParser.ldfParser.FloatValueContext)
visitFrame_def(ctx: pydbc.py3.ldfParser.ldfParser.Frame_defContext)
visitFrame_item(ctx: pydbc.py3.ldfParser.ldfParser.Frame_itemContext)
visitFrame_signal(ctx: pydbc.py3.ldfParser.ldfParser.Frame_signalContext)
visitIdentifierValue(ctx: pydbc.py3.ldfParser.ldfParser.IdentifierValueContext)
visitInit_value(ctx: pydbc.py3.ldfParser.ldfParser.Init_valueContext)
visitInit_value_array(ctx: pydbc.py3.ldfParser.ldfParser.Init_value_arrayContext)
visitInit_value_scalar(ctx: pydbc.py3.ldfParser.ldfParser.Init_value_scalarContext)
visitIntValue(ctx: pydbc.py3.ldfParser.ldfParser.IntValueContext)
visitLin_description_file(ctx: pydbc.py3.ldfParser.ldfParser.Lin_description_fileContext)
visitLin_file_revision_def(ctx: pydbc.py3.ldfParser.ldfParser.Lin_file_revision_defContext)
visitLin_language_version_def(ctx: pydbc.py3.ldfParser.ldfParser.Lin_language_version_defContext)
visitLin_protocol_version_def(ctx: pydbc.py3.ldfParser.ldfParser.Lin_protocol_version_defContext)
visitLin_speed_def(ctx: pydbc.py3.ldfParser.ldfParser.Lin_speed_defContext)
visitLogical_value(ctx: pydbc.py3.ldfParser.ldfParser.Logical_valueContext)
visitNode_attribute(ctx: pydbc.py3.ldfParser.ldfParser.Node_attributeContext)
visitNode_attributes_def(ctx: pydbc.py3.ldfParser.ldfParser.Node_attributes_defContext)
visitNode_composition_def(ctx: pydbc.py3.ldfParser.ldfParser.Node_composition_defContext)
visitNode_def(ctx: pydbc.py3.ldfParser.ldfParser.Node_defContext)
visitNumber(ctx: pydbc.py3.ldfParser.ldfParser.NumberContext)
visitPhysical_range(ctx: pydbc.py3.ldfParser.ldfParser.Physical_rangeContext)
visitSchedule_table_command(ctx: pydbc.py3.ldfParser.ldfParser.Schedule_table_commandContext)
visitSchedule_table_def(ctx: pydbc.py3.ldfParser.ldfParser.Schedule_table_defContext)
visitSchedule_table_entry(ctx: pydbc.py3.ldfParser.ldfParser.Schedule_table_entryContext)
visitSignal_def(ctx: pydbc.py3.ldfParser.ldfParser.Signal_defContext)
visitSignal_encoding_entry(ctx: pydbc.py3.ldfParser.ldfParser.Signal_encoding_entryContext)
visitSignal_encoding_type_def(ctx: pydbc.py3.ldfParser.ldfParser.Signal_encoding_type_defContext)
visitSignal_encoding_value(ctx: pydbc.py3.ldfParser.ldfParser.Signal_encoding_valueContext)
visitSignal_group(ctx: pydbc.py3.ldfParser.ldfParser.Signal_groupContext)
visitSignal_group_item(ctx: pydbc.py3.ldfParser.ldfParser.Signal_group_itemContext)
visitSignal_groups_def(ctx: pydbc.py3.ldfParser.ldfParser.Signal_groups_defContext)
visitSignal_item(ctx: pydbc.py3.ldfParser.ldfParser.Signal_itemContext)
visitSignal_representation_def(ctx: pydbc.py3.ldfParser.ldfParser.Signal_representation_defContext)
visitSignal_representation_entry(ctx: pydbc.py3.ldfParser.ldfParser.Signal_representation_entryContext)
visitSporadic_frame_def(ctx: pydbc.py3.ldfParser.ldfParser.Sporadic_frame_defContext)
visitSporadic_frame_item(ctx: pydbc.py3.ldfParser.ldfParser.Sporadic_frame_itemContext)
visitStringValue(ctx: pydbc.py3.ldfParser.ldfParser.StringValueContext)

pydbc.py3.ncfLexer module

class pydbc.py3.ncfLexer.ncfLexer(input=None, output: TextIO = <_io.TextIOWrapper name='<stdout>' mode='w' encoding='UTF-8'>)

Bases: antlr4.Lexer.Lexer

COMMENT = 62
C_IDENTIFIER = 57
FLOAT = 58
HEX = 60
INT = 59
SIGN = 64
STRING = 63
T__0 = 1
T__1 = 2
T__10 = 11
T__11 = 12
T__12 = 13
T__13 = 14
T__14 = 15
T__15 = 16
T__16 = 17
T__17 = 18
T__18 = 19
T__19 = 20
T__2 = 3
T__20 = 21
T__21 = 22
T__22 = 23
T__23 = 24
T__24 = 25
T__25 = 26
T__26 = 27
T__27 = 28
T__28 = 29
T__29 = 30
T__3 = 4
T__30 = 31
T__31 = 32
T__32 = 33
T__33 = 34
T__34 = 35
T__35 = 36
T__36 = 37
T__37 = 38
T__38 = 39
T__39 = 40
T__4 = 5
T__40 = 41
T__41 = 42
T__42 = 43
T__43 = 44
T__44 = 45
T__45 = 46
T__46 = 47
T__47 = 48
T__48 = 49
T__49 = 50
T__5 = 6
T__50 = 51
T__51 = 52
T__52 = 53
T__53 = 54
T__54 = 55
T__55 = 56
T__6 = 7
T__7 = 8
T__8 = 9
T__9 = 10
WS = 61
atn = <antlr4.atn.ATN.ATN object>
channelNames = ['DEFAULT_TOKEN_CHANNEL', 'HIDDEN']
decisionsToDFA = [<antlr4.dfa.DFA.DFA object>, <antlr4.dfa.DFA.DFA object>, <antlr4.dfa.DFA.DFA object>, <antlr4.dfa.DFA.DFA object>, <antlr4.dfa.DFA.DFA object>, <antlr4.dfa.DFA.DFA object>, <antlr4.dfa.DFA.DFA object>, <antlr4.dfa.DFA.DFA object>, <antlr4.dfa.DFA.DFA object>, <antlr4.dfa.DFA.DFA object>, <antlr4.dfa.DFA.DFA object>, <antlr4.dfa.DFA.DFA object>, <antlr4.dfa.DFA.DFA object>, <antlr4.dfa.DFA.DFA object>, <antlr4.dfa.DFA.DFA object>, <antlr4.dfa.DFA.DFA object>, <antlr4.dfa.DFA.DFA object>, <antlr4.dfa.DFA.DFA object>, <antlr4.dfa.DFA.DFA object>, <antlr4.dfa.DFA.DFA object>, <antlr4.dfa.DFA.DFA object>]
grammarFileName = 'ncf.g4'
literalNames = ['<INVALID>', "'node_capability_file'", "';'", "'LIN_language_version'", "'='", "'node'", "'{'", "'}'", "'general'", "'LIN_protocol_version'", "'supplier'", "'function'", "'variant'", "'bitrate'", "'sends_wake_up_signal'", "'yes'", "'no'", "'volt_range'", "','", "'temp_range'", "'conformance'", "'automatic'", "'min'", "'max'", "'select'", "'kbps'", "'diagnostic'", "'NAD'", "'to'", "'diagnostic_class'", "'P2_min'", "'ms'", "'ST_min'", "'N_As_timeout'", "'N_Cr_timeout'", "'support_sid'", "'max_message_length'", "'frames'", "'publish'", "'subscribe'", "'length'", "'min_period'", "'max_period'", "'event_triggered_frame'", "'signals'", "'size'", "'offset'", "'init_value'", "'encoding'", "'logical_value'", "'physical_value'", "'bcd_value'", "'ascii_value'", "'status_management'", "'response_error'", "'fault_state_signals'", "'free_text'"]
modeNames = ['DEFAULT_MODE']
ruleNames = ['T__0', 'T__1', 'T__2', 'T__3', 'T__4', 'T__5', 'T__6', 'T__7', 'T__8', 'T__9', 'T__10', 'T__11', 'T__12', 'T__13', 'T__14', 'T__15', 'T__16', 'T__17', 'T__18', 'T__19', 'T__20', 'T__21', 'T__22', 'T__23', 'T__24', 'T__25', 'T__26', 'T__27', 'T__28', 'T__29', 'T__30', 'T__31', 'T__32', 'T__33', 'T__34', 'T__35', 'T__36', 'T__37', 'T__38', 'T__39', 'T__40', 'T__41', 'T__42', 'T__43', 'T__44', 'T__45', 'T__46', 'T__47', 'T__48', 'T__49', 'T__50', 'T__51', 'T__52', 'T__53', 'T__54', 'T__55', 'C_IDENTIFIER', 'EXPONENT', 'FLOAT', 'INT', 'HEX', 'HEX_DIGIT', 'ESC_SEQ', 'WS', 'COMMENT', 'STRING', 'SIGN']
symbolicNames = ['<INVALID>', 'C_IDENTIFIER', 'FLOAT', 'INT', 'HEX', 'WS', 'COMMENT', 'STRING', 'SIGN']
pydbc.py3.ncfLexer.serializedATN()

pydbc.py3.ncfListener module

pydbc.py3.ncfParser module

class pydbc.py3.ncfParser.ncfParser(input: antlr4.BufferedTokenStream.TokenStream, output: TextIO = <_io.TextIOWrapper name='<stdout>' mode='w' encoding='UTF-8'>)

Bases: antlr4.Parser.Parser

class Ascii_valueContext(parser, parent: antlr4.ParserRuleContext.ParserRuleContext = None, invokingState: int = -1)

Bases: antlr4.ParserRuleContext.ParserRuleContext

accept(visitor: antlr4.tree.Tree.ParseTreeVisitor)
enterRule(listener: antlr4.tree.Tree.ParseTreeListener)
exitRule(listener: antlr4.tree.Tree.ParseTreeListener)
getRuleIndex()
class Bcd_valueContext(parser, parent: antlr4.ParserRuleContext.ParserRuleContext = None, invokingState: int = -1)

Bases: antlr4.ParserRuleContext.ParserRuleContext

accept(visitor: antlr4.tree.Tree.ParseTreeVisitor)
enterRule(listener: antlr4.tree.Tree.ParseTreeListener)
exitRule(listener: antlr4.tree.Tree.ParseTreeListener)
getRuleIndex()
class BitrateContext(parser, parent: antlr4.ParserRuleContext.ParserRuleContext = None, invokingState: int = -1)

Bases: antlr4.ParserRuleContext.ParserRuleContext

accept(visitor: antlr4.tree.Tree.ParseTreeVisitor)
enterRule(listener: antlr4.tree.Tree.ParseTreeListener)
exitRule(listener: antlr4.tree.Tree.ParseTreeListener)
getRuleIndex()
number()
class Bitrate_definitionContext(parser, parent: antlr4.ParserRuleContext.ParserRuleContext = None, invokingState: int = -1)

Bases: antlr4.ParserRuleContext.ParserRuleContext

accept(visitor: antlr4.tree.Tree.ParseTreeVisitor)
bitrate(i: int = None)
enterRule(listener: antlr4.tree.Tree.ParseTreeListener)
exitRule(listener: antlr4.tree.Tree.ParseTreeListener)
getRuleIndex()
COMMENT = 62
C_IDENTIFIER = 57
class Diagnostic_definitionContext(parser, parent: antlr4.ParserRuleContext.ParserRuleContext = None, invokingState: int = -1)

Bases: antlr4.ParserRuleContext.ParserRuleContext

accept(visitor: antlr4.tree.Tree.ParseTreeVisitor)
enterRule(listener: antlr4.tree.Tree.ParseTreeListener)
exitRule(listener: antlr4.tree.Tree.ParseTreeListener)
getRuleIndex()
intValue(i: int = None)
number(i: int = None)
EOF = -1
class Encoding_definitionContext(parser, parent: antlr4.ParserRuleContext.ParserRuleContext = None, invokingState: int = -1)

Bases: antlr4.ParserRuleContext.ParserRuleContext

accept(visitor: antlr4.tree.Tree.ParseTreeVisitor)
encoding_definition_entry(i: int = None)
enterRule(listener: antlr4.tree.Tree.ParseTreeListener)
exitRule(listener: antlr4.tree.Tree.ParseTreeListener)
getRuleIndex()
class Encoding_definition_entryContext(parser, parent: antlr4.ParserRuleContext.ParserRuleContext = None, invokingState: int = -1)

Bases: antlr4.ParserRuleContext.ParserRuleContext

accept(visitor: antlr4.tree.Tree.ParseTreeVisitor)
encoding_definition_value(i: int = None)
encoding_name()
enterRule(listener: antlr4.tree.Tree.ParseTreeListener)
exitRule(listener: antlr4.tree.Tree.ParseTreeListener)
getRuleIndex()
class Encoding_definition_valueContext(parser, parent: antlr4.ParserRuleContext.ParserRuleContext = None, invokingState: int = -1)

Bases: antlr4.ParserRuleContext.ParserRuleContext

accept(visitor: antlr4.tree.Tree.ParseTreeVisitor)
ascii_value()
bcd_value()
enterRule(listener: antlr4.tree.Tree.ParseTreeListener)
exitRule(listener: antlr4.tree.Tree.ParseTreeListener)
getRuleIndex()
logical_value()
physical_range()
class Encoding_nameContext(parser, parent: antlr4.ParserRuleContext.ParserRuleContext = None, invokingState: int = -1)

Bases: antlr4.ParserRuleContext.ParserRuleContext

accept(visitor: antlr4.tree.Tree.ParseTreeVisitor)
enterRule(listener: antlr4.tree.Tree.ParseTreeListener)
exitRule(listener: antlr4.tree.Tree.ParseTreeListener)
getRuleIndex()
identifierValue()
FLOAT = 58
class FloatValueContext(parser, parent: antlr4.ParserRuleContext.ParserRuleContext = None, invokingState: int = -1)

Bases: antlr4.ParserRuleContext.ParserRuleContext

FLOAT()
accept(visitor: antlr4.tree.Tree.ParseTreeVisitor)
enterRule(listener: antlr4.tree.Tree.ParseTreeListener)
exitRule(listener: antlr4.tree.Tree.ParseTreeListener)
getRuleIndex()
class Frame_definitionContext(parser, parent: antlr4.ParserRuleContext.ParserRuleContext = None, invokingState: int = -1)

Bases: antlr4.ParserRuleContext.ParserRuleContext

accept(visitor: antlr4.tree.Tree.ParseTreeVisitor)
enterRule(listener: antlr4.tree.Tree.ParseTreeListener)
exitRule(listener: antlr4.tree.Tree.ParseTreeListener)
getRuleIndex()
single_frame(i: int = None)
class Frame_kindContext(parser, parent: antlr4.ParserRuleContext.ParserRuleContext = None, invokingState: int = -1)

Bases: antlr4.ParserRuleContext.ParserRuleContext

accept(visitor: antlr4.tree.Tree.ParseTreeVisitor)
enterRule(listener: antlr4.tree.Tree.ParseTreeListener)
exitRule(listener: antlr4.tree.Tree.ParseTreeListener)
getRuleIndex()
class Frame_nameContext(parser, parent: antlr4.ParserRuleContext.ParserRuleContext = None, invokingState: int = -1)

Bases: antlr4.ParserRuleContext.ParserRuleContext

accept(visitor: antlr4.tree.Tree.ParseTreeVisitor)
enterRule(listener: antlr4.tree.Tree.ParseTreeListener)
exitRule(listener: antlr4.tree.Tree.ParseTreeListener)
getRuleIndex()
identifierValue()
class Frame_propertiesContext(parser, parent: antlr4.ParserRuleContext.ParserRuleContext = None, invokingState: int = -1)

Bases: antlr4.ParserRuleContext.ParserRuleContext

accept(visitor: antlr4.tree.Tree.ParseTreeVisitor)
enterRule(listener: antlr4.tree.Tree.ParseTreeListener)
exitRule(listener: antlr4.tree.Tree.ParseTreeListener)
getRuleIndex()
identifierValue()
intValue(i: int = None)
class Free_text_definitionContext(parser, parent: antlr4.ParserRuleContext.ParserRuleContext = None, invokingState: int = -1)

Bases: antlr4.ParserRuleContext.ParserRuleContext

accept(visitor: antlr4.tree.Tree.ParseTreeVisitor)
enterRule(listener: antlr4.tree.Tree.ParseTreeListener)
exitRule(listener: antlr4.tree.Tree.ParseTreeListener)
getRuleIndex()
stringValue()
class Function_idContext(parser, parent: antlr4.ParserRuleContext.ParserRuleContext = None, invokingState: int = -1)

Bases: antlr4.ParserRuleContext.ParserRuleContext

accept(visitor: antlr4.tree.Tree.ParseTreeVisitor)
enterRule(listener: antlr4.tree.Tree.ParseTreeListener)
exitRule(listener: antlr4.tree.Tree.ParseTreeListener)
getRuleIndex()
intValue()
class General_definitionContext(parser, parent: antlr4.ParserRuleContext.ParserRuleContext = None, invokingState: int = -1)

Bases: antlr4.ParserRuleContext.ParserRuleContext

accept(visitor: antlr4.tree.Tree.ParseTreeVisitor)
bitrate_definition()
enterRule(listener: antlr4.tree.Tree.ParseTreeListener)
exitRule(listener: antlr4.tree.Tree.ParseTreeListener)
function_id()
getRuleIndex()
number(i: int = None)
protocol_version()
stringValue()
supplier_id()
variant_id()
HEX = 60
INT = 59
class IdentifierValueContext(parser, parent: antlr4.ParserRuleContext.ParserRuleContext = None, invokingState: int = -1)

Bases: antlr4.ParserRuleContext.ParserRuleContext

C_IDENTIFIER()
accept(visitor: antlr4.tree.Tree.ParseTreeVisitor)
enterRule(listener: antlr4.tree.Tree.ParseTreeListener)
exitRule(listener: antlr4.tree.Tree.ParseTreeListener)
getRuleIndex()
class Init_valueContext(parser, parent: antlr4.ParserRuleContext.ParserRuleContext = None, invokingState: int = -1)

Bases: antlr4.ParserRuleContext.ParserRuleContext

accept(visitor: antlr4.tree.Tree.ParseTreeVisitor)
enterRule(listener: antlr4.tree.Tree.ParseTreeListener)
exitRule(listener: antlr4.tree.Tree.ParseTreeListener)
getRuleIndex()
init_value_array()
init_value_scalar()
class Init_value_arrayContext(parser, parent: antlr4.ParserRuleContext.ParserRuleContext = None, invokingState: int = -1)

Bases: antlr4.ParserRuleContext.ParserRuleContext

accept(visitor: antlr4.tree.Tree.ParseTreeVisitor)
enterRule(listener: antlr4.tree.Tree.ParseTreeListener)
exitRule(listener: antlr4.tree.Tree.ParseTreeListener)
getRuleIndex()
intValue(i: int = None)
class Init_value_scalarContext(parser, parent: antlr4.ParserRuleContext.ParserRuleContext = None, invokingState: int = -1)

Bases: antlr4.ParserRuleContext.ParserRuleContext

accept(visitor: antlr4.tree.Tree.ParseTreeVisitor)
enterRule(listener: antlr4.tree.Tree.ParseTreeListener)
exitRule(listener: antlr4.tree.Tree.ParseTreeListener)
getRuleIndex()
intValue()
class IntValueContext(parser, parent: antlr4.ParserRuleContext.ParserRuleContext = None, invokingState: int = -1)

Bases: antlr4.ParserRuleContext.ParserRuleContext

HEX()
INT()
accept(visitor: antlr4.tree.Tree.ParseTreeVisitor)
enterRule(listener: antlr4.tree.Tree.ParseTreeListener)
exitRule(listener: antlr4.tree.Tree.ParseTreeListener)
getRuleIndex()
class Language_versionContext(parser, parent: antlr4.ParserRuleContext.ParserRuleContext = None, invokingState: int = -1)

Bases: antlr4.ParserRuleContext.ParserRuleContext

accept(visitor: antlr4.tree.Tree.ParseTreeVisitor)
enterRule(listener: antlr4.tree.Tree.ParseTreeListener)
exitRule(listener: antlr4.tree.Tree.ParseTreeListener)
getRuleIndex()
stringValue()
class Logical_valueContext(parser, parent: antlr4.ParserRuleContext.ParserRuleContext = None, invokingState: int = -1)

Bases: antlr4.ParserRuleContext.ParserRuleContext

accept(visitor: antlr4.tree.Tree.ParseTreeVisitor)
enterRule(listener: antlr4.tree.Tree.ParseTreeListener)
exitRule(listener: antlr4.tree.Tree.ParseTreeListener)
getRuleIndex()
signal_value()
text_info()
class Max_valueContext(parser, parent: antlr4.ParserRuleContext.ParserRuleContext = None, invokingState: int = -1)

Bases: antlr4.ParserRuleContext.ParserRuleContext

accept(visitor: antlr4.tree.Tree.ParseTreeVisitor)
enterRule(listener: antlr4.tree.Tree.ParseTreeListener)
exitRule(listener: antlr4.tree.Tree.ParseTreeListener)
getRuleIndex()
intValue()
class Min_valueContext(parser, parent: antlr4.ParserRuleContext.ParserRuleContext = None, invokingState: int = -1)

Bases: antlr4.ParserRuleContext.ParserRuleContext

accept(visitor: antlr4.tree.Tree.ParseTreeVisitor)
enterRule(listener: antlr4.tree.Tree.ParseTreeListener)
exitRule(listener: antlr4.tree.Tree.ParseTreeListener)
getRuleIndex()
intValue()
class Node_definitionContext(parser, parent: antlr4.ParserRuleContext.ParserRuleContext = None, invokingState: int = -1)

Bases: antlr4.ParserRuleContext.ParserRuleContext

accept(visitor: antlr4.tree.Tree.ParseTreeVisitor)
diagnostic_definition()
encoding_definition()
enterRule(listener: antlr4.tree.Tree.ParseTreeListener)
exitRule(listener: antlr4.tree.Tree.ParseTreeListener)
frame_definition()
free_text_definition()
general_definition()
getRuleIndex()
node_name()
status_management()
class Node_nameContext(parser, parent: antlr4.ParserRuleContext.ParserRuleContext = None, invokingState: int = -1)

Bases: antlr4.ParserRuleContext.ParserRuleContext

accept(visitor: antlr4.tree.Tree.ParseTreeVisitor)
enterRule(listener: antlr4.tree.Tree.ParseTreeListener)
exitRule(listener: antlr4.tree.Tree.ParseTreeListener)
getRuleIndex()
identifierValue()
class NumberContext(parser, parent: antlr4.ParserRuleContext.ParserRuleContext = None, invokingState: int = -1)

Bases: antlr4.ParserRuleContext.ParserRuleContext

accept(visitor: antlr4.tree.Tree.ParseTreeVisitor)
enterRule(listener: antlr4.tree.Tree.ParseTreeListener)
exitRule(listener: antlr4.tree.Tree.ParseTreeListener)
floatValue()
getRuleIndex()
intValue()
class OffsetContext(parser, parent: antlr4.ParserRuleContext.ParserRuleContext = None, invokingState: int = -1)

Bases: antlr4.ParserRuleContext.ParserRuleContext

accept(visitor: antlr4.tree.Tree.ParseTreeVisitor)
enterRule(listener: antlr4.tree.Tree.ParseTreeListener)
exitRule(listener: antlr4.tree.Tree.ParseTreeListener)
getRuleIndex()
number()
class Physical_rangeContext(parser, parent: antlr4.ParserRuleContext.ParserRuleContext = None, invokingState: int = -1)

Bases: antlr4.ParserRuleContext.ParserRuleContext

accept(visitor: antlr4.tree.Tree.ParseTreeVisitor)
enterRule(listener: antlr4.tree.Tree.ParseTreeListener)
exitRule(listener: antlr4.tree.Tree.ParseTreeListener)
getRuleIndex()
max_value()
min_value()
offset()
scale()
text_info()
class Protocol_versionContext(parser, parent: antlr4.ParserRuleContext.ParserRuleContext = None, invokingState: int = -1)

Bases: antlr4.ParserRuleContext.ParserRuleContext

accept(visitor: antlr4.tree.Tree.ParseTreeVisitor)
enterRule(listener: antlr4.tree.Tree.ParseTreeListener)
exitRule(listener: antlr4.tree.Tree.ParseTreeListener)
getRuleIndex()
stringValue()
class Published_signalContext(parser, parent: antlr4.ParserRuleContext.ParserRuleContext = None, invokingState: int = -1)

Bases: antlr4.ParserRuleContext.ParserRuleContext

accept(visitor: antlr4.tree.Tree.ParseTreeVisitor)
enterRule(listener: antlr4.tree.Tree.ParseTreeListener)
exitRule(listener: antlr4.tree.Tree.ParseTreeListener)
getRuleIndex()
identifierValue()
RULE_ascii_value = 31
RULE_bcd_value = 30
RULE_bitrate = 10
RULE_bitrate_definition = 9
RULE_diagnostic_definition = 11
RULE_encoding_definition = 24
RULE_encoding_definition_entry = 25
RULE_encoding_definition_value = 26
RULE_encoding_name = 27
RULE_floatValue = 42
RULE_frame_definition = 12
RULE_frame_kind = 14
RULE_frame_name = 15
RULE_frame_properties = 16
RULE_free_text_definition = 40
RULE_function_id = 7
RULE_general_definition = 4
RULE_identifierValue = 45
RULE_init_value = 21
RULE_init_value_array = 23
RULE_init_value_scalar = 22
RULE_intValue = 41
RULE_language_version = 1
RULE_logical_value = 28
RULE_max_value = 34
RULE_min_value = 33
RULE_node_definition = 2
RULE_node_name = 3
RULE_number = 43
RULE_offset = 36
RULE_physical_range = 29
RULE_protocol_version = 5
RULE_published_signal = 39
RULE_scale = 35
RULE_signal_definition = 17
RULE_signal_definition_entry = 18
RULE_signal_name = 19
RULE_signal_properties = 20
RULE_signal_value = 32
RULE_single_frame = 13
RULE_status_management = 38
RULE_stringValue = 44
RULE_supplier_id = 6
RULE_text_info = 37
RULE_toplevel = 0
RULE_variant_id = 8
SIGN = 64
STRING = 63
class ScaleContext(parser, parent: antlr4.ParserRuleContext.ParserRuleContext = None, invokingState: int = -1)

Bases: antlr4.ParserRuleContext.ParserRuleContext

accept(visitor: antlr4.tree.Tree.ParseTreeVisitor)
enterRule(listener: antlr4.tree.Tree.ParseTreeListener)
exitRule(listener: antlr4.tree.Tree.ParseTreeListener)
getRuleIndex()
number()
class Signal_definitionContext(parser, parent: antlr4.ParserRuleContext.ParserRuleContext = None, invokingState: int = -1)

Bases: antlr4.ParserRuleContext.ParserRuleContext

accept(visitor: antlr4.tree.Tree.ParseTreeVisitor)
enterRule(listener: antlr4.tree.Tree.ParseTreeListener)
exitRule(listener: antlr4.tree.Tree.ParseTreeListener)
getRuleIndex()
signal_definition_entry(i: int = None)
class Signal_definition_entryContext(parser, parent: antlr4.ParserRuleContext.ParserRuleContext = None, invokingState: int = -1)

Bases: antlr4.ParserRuleContext.ParserRuleContext

accept(visitor: antlr4.tree.Tree.ParseTreeVisitor)
enterRule(listener: antlr4.tree.Tree.ParseTreeListener)
exitRule(listener: antlr4.tree.Tree.ParseTreeListener)
getRuleIndex()
signal_name()
signal_properties()
class Signal_nameContext(parser, parent: antlr4.ParserRuleContext.ParserRuleContext = None, invokingState: int = -1)

Bases: antlr4.ParserRuleContext.ParserRuleContext

accept(visitor: antlr4.tree.Tree.ParseTreeVisitor)
enterRule(listener: antlr4.tree.Tree.ParseTreeListener)
exitRule(listener: antlr4.tree.Tree.ParseTreeListener)
getRuleIndex()
identifierValue()
class Signal_propertiesContext(parser, parent: antlr4.ParserRuleContext.ParserRuleContext = None, invokingState: int = -1)

Bases: antlr4.ParserRuleContext.ParserRuleContext

accept(visitor: antlr4.tree.Tree.ParseTreeVisitor)
encoding_name()
enterRule(listener: antlr4.tree.Tree.ParseTreeListener)
exitRule(listener: antlr4.tree.Tree.ParseTreeListener)
getRuleIndex()
init_value()
intValue(i: int = None)
class Signal_valueContext(parser, parent: antlr4.ParserRuleContext.ParserRuleContext = None, invokingState: int = -1)

Bases: antlr4.ParserRuleContext.ParserRuleContext

accept(visitor: antlr4.tree.Tree.ParseTreeVisitor)
enterRule(listener: antlr4.tree.Tree.ParseTreeListener)
exitRule(listener: antlr4.tree.Tree.ParseTreeListener)
getRuleIndex()
intValue()
class Single_frameContext(parser, parent: antlr4.ParserRuleContext.ParserRuleContext = None, invokingState: int = -1)

Bases: antlr4.ParserRuleContext.ParserRuleContext

accept(visitor: antlr4.tree.Tree.ParseTreeVisitor)
enterRule(listener: antlr4.tree.Tree.ParseTreeListener)
exitRule(listener: antlr4.tree.Tree.ParseTreeListener)
frame_kind()
frame_name()
frame_properties()
getRuleIndex()
signal_definition()
class Status_managementContext(parser, parent: antlr4.ParserRuleContext.ParserRuleContext = None, invokingState: int = -1)

Bases: antlr4.ParserRuleContext.ParserRuleContext

accept(visitor: antlr4.tree.Tree.ParseTreeVisitor)
enterRule(listener: antlr4.tree.Tree.ParseTreeListener)
exitRule(listener: antlr4.tree.Tree.ParseTreeListener)
getRuleIndex()
identifierValue(i: int = None)
class StringValueContext(parser, parent: antlr4.ParserRuleContext.ParserRuleContext = None, invokingState: int = -1)

Bases: antlr4.ParserRuleContext.ParserRuleContext

STRING()
accept(visitor: antlr4.tree.Tree.ParseTreeVisitor)
enterRule(listener: antlr4.tree.Tree.ParseTreeListener)
exitRule(listener: antlr4.tree.Tree.ParseTreeListener)
getRuleIndex()
class Supplier_idContext(parser, parent: antlr4.ParserRuleContext.ParserRuleContext = None, invokingState: int = -1)

Bases: antlr4.ParserRuleContext.ParserRuleContext

accept(visitor: antlr4.tree.Tree.ParseTreeVisitor)
enterRule(listener: antlr4.tree.Tree.ParseTreeListener)
exitRule(listener: antlr4.tree.Tree.ParseTreeListener)
getRuleIndex()
intValue()
T__0 = 1
T__1 = 2
T__10 = 11
T__11 = 12
T__12 = 13
T__13 = 14
T__14 = 15
T__15 = 16
T__16 = 17
T__17 = 18
T__18 = 19
T__19 = 20
T__2 = 3
T__20 = 21
T__21 = 22
T__22 = 23
T__23 = 24
T__24 = 25
T__25 = 26
T__26 = 27
T__27 = 28
T__28 = 29
T__29 = 30
T__3 = 4
T__30 = 31
T__31 = 32
T__32 = 33
T__33 = 34
T__34 = 35
T__35 = 36
T__36 = 37
T__37 = 38
T__38 = 39
T__39 = 40
T__4 = 5
T__40 = 41
T__41 = 42
T__42 = 43
T__43 = 44
T__44 = 45
T__45 = 46
T__46 = 47
T__47 = 48
T__48 = 49
T__49 = 50
T__5 = 6
T__50 = 51
T__51 = 52
T__52 = 53
T__53 = 54
T__54 = 55
T__55 = 56
T__6 = 7
T__7 = 8
T__8 = 9
T__9 = 10
class Text_infoContext(parser, parent: antlr4.ParserRuleContext.ParserRuleContext = None, invokingState: int = -1)

Bases: antlr4.ParserRuleContext.ParserRuleContext

accept(visitor: antlr4.tree.Tree.ParseTreeVisitor)
enterRule(listener: antlr4.tree.Tree.ParseTreeListener)
exitRule(listener: antlr4.tree.Tree.ParseTreeListener)
getRuleIndex()
stringValue()
class ToplevelContext(parser, parent: antlr4.ParserRuleContext.ParserRuleContext = None, invokingState: int = -1)

Bases: antlr4.ParserRuleContext.ParserRuleContext

accept(visitor: antlr4.tree.Tree.ParseTreeVisitor)
enterRule(listener: antlr4.tree.Tree.ParseTreeListener)
exitRule(listener: antlr4.tree.Tree.ParseTreeListener)
getRuleIndex()
language_version()
node_definition(i: int = None)
class Variant_idContext(parser, parent: antlr4.ParserRuleContext.ParserRuleContext = None, invokingState: int = -1)

Bases: antlr4.ParserRuleContext.ParserRuleContext

accept(visitor: antlr4.tree.Tree.ParseTreeVisitor)
enterRule(listener: antlr4.tree.Tree.ParseTreeListener)
exitRule(listener: antlr4.tree.Tree.ParseTreeListener)
getRuleIndex()
intValue()
WS = 61
ascii_value()
atn = <antlr4.atn.ATN.ATN object>
bcd_value()
bitrate()
bitrate_definition()
decisionsToDFA = [<antlr4.dfa.DFA.DFA object>, <antlr4.dfa.DFA.DFA object>, <antlr4.dfa.DFA.DFA object>, <antlr4.dfa.DFA.DFA object>, <antlr4.dfa.DFA.DFA object>, <antlr4.dfa.DFA.DFA object>, <antlr4.dfa.DFA.DFA object>, <antlr4.dfa.DFA.DFA object>, <antlr4.dfa.DFA.DFA object>, <antlr4.dfa.DFA.DFA object>, <antlr4.dfa.DFA.DFA object>, <antlr4.dfa.DFA.DFA object>, <antlr4.dfa.DFA.DFA object>, <antlr4.dfa.DFA.DFA object>, <antlr4.dfa.DFA.DFA object>, <antlr4.dfa.DFA.DFA object>, <antlr4.dfa.DFA.DFA object>, <antlr4.dfa.DFA.DFA object>, <antlr4.dfa.DFA.DFA object>, <antlr4.dfa.DFA.DFA object>, <antlr4.dfa.DFA.DFA object>, <antlr4.dfa.DFA.DFA object>, <antlr4.dfa.DFA.DFA object>, <antlr4.dfa.DFA.DFA object>, <antlr4.dfa.DFA.DFA object>, <antlr4.dfa.DFA.DFA object>, <antlr4.dfa.DFA.DFA object>, <antlr4.dfa.DFA.DFA object>, <antlr4.dfa.DFA.DFA object>, <antlr4.dfa.DFA.DFA object>, <antlr4.dfa.DFA.DFA object>, <antlr4.dfa.DFA.DFA object>, <antlr4.dfa.DFA.DFA object>, <antlr4.dfa.DFA.DFA object>, <antlr4.dfa.DFA.DFA object>, <antlr4.dfa.DFA.DFA object>, <antlr4.dfa.DFA.DFA object>, <antlr4.dfa.DFA.DFA object>, <antlr4.dfa.DFA.DFA object>]
diagnostic_definition()
encoding_definition()
encoding_definition_entry()
encoding_definition_value()
encoding_name()
floatValue()
frame_definition()
frame_kind()
frame_name()
frame_properties()
free_text_definition()
function_id()
general_definition()
grammarFileName = 'ncf.g4'
identifierValue()
init_value()
init_value_array()
init_value_scalar()
intValue()
language_version()
literalNames = ['<INVALID>', "'node_capability_file'", "';'", "'LIN_language_version'", "'='", "'node'", "'{'", "'}'", "'general'", "'LIN_protocol_version'", "'supplier'", "'function'", "'variant'", "'bitrate'", "'sends_wake_up_signal'", "'yes'", "'no'", "'volt_range'", "','", "'temp_range'", "'conformance'", "'automatic'", "'min'", "'max'", "'select'", "'kbps'", "'diagnostic'", "'NAD'", "'to'", "'diagnostic_class'", "'P2_min'", "'ms'", "'ST_min'", "'N_As_timeout'", "'N_Cr_timeout'", "'support_sid'", "'max_message_length'", "'frames'", "'publish'", "'subscribe'", "'length'", "'min_period'", "'max_period'", "'event_triggered_frame'", "'signals'", "'size'", "'offset'", "'init_value'", "'encoding'", "'logical_value'", "'physical_value'", "'bcd_value'", "'ascii_value'", "'status_management'", "'response_error'", "'fault_state_signals'", "'free_text'"]
logical_value()
max_value()
min_value()
node_definition()
node_name()
number()
offset()
physical_range()
protocol_version()
published_signal()
ruleNames = ['toplevel', 'language_version', 'node_definition', 'node_name', 'general_definition', 'protocol_version', 'supplier_id', 'function_id', 'variant_id', 'bitrate_definition', 'bitrate', 'diagnostic_definition', 'frame_definition', 'single_frame', 'frame_kind', 'frame_name', 'frame_properties', 'signal_definition', 'signal_definition_entry', 'signal_name', 'signal_properties', 'init_value', 'init_value_scalar', 'init_value_array', 'encoding_definition', 'encoding_definition_entry', 'encoding_definition_value', 'encoding_name', 'logical_value', 'physical_range', 'bcd_value', 'ascii_value', 'signal_value', 'min_value', 'max_value', 'scale', 'offset', 'text_info', 'status_management', 'published_signal', 'free_text_definition', 'intValue', 'floatValue', 'number', 'stringValue', 'identifierValue']
scale()
sharedContextCache = <antlr4.PredictionContext.PredictionContextCache object>
signal_definition()
signal_definition_entry()
signal_name()
signal_properties()
signal_value()
single_frame()
status_management()
stringValue()
supplier_id()
symbolicNames = ['<INVALID>', '<INVALID>', '<INVALID>', '<INVALID>', '<INVALID>', '<INVALID>', '<INVALID>', '<INVALID>', '<INVALID>', '<INVALID>', '<INVALID>', '<INVALID>', '<INVALID>', '<INVALID>', '<INVALID>', '<INVALID>', '<INVALID>', '<INVALID>', '<INVALID>', '<INVALID>', '<INVALID>', '<INVALID>', '<INVALID>', '<INVALID>', '<INVALID>', '<INVALID>', '<INVALID>', '<INVALID>', '<INVALID>', '<INVALID>', '<INVALID>', '<INVALID>', '<INVALID>', '<INVALID>', '<INVALID>', '<INVALID>', '<INVALID>', '<INVALID>', '<INVALID>', '<INVALID>', '<INVALID>', '<INVALID>', '<INVALID>', '<INVALID>', '<INVALID>', '<INVALID>', '<INVALID>', '<INVALID>', '<INVALID>', '<INVALID>', '<INVALID>', '<INVALID>', '<INVALID>', '<INVALID>', '<INVALID>', '<INVALID>', '<INVALID>', 'C_IDENTIFIER', 'FLOAT', 'INT', 'HEX', 'WS', 'COMMENT', 'STRING', 'SIGN']
text_info()
toplevel()
variant_id()
pydbc.py3.ncfParser.serializedATN()

pydbc.py3.ncfVisitor module

class pydbc.py3.ncfVisitor.ncfVisitor

Bases: antlr4.tree.Tree.ParseTreeVisitor

visitAscii_value(ctx: pydbc.py3.ncfParser.ncfParser.Ascii_valueContext)
visitBcd_value(ctx: pydbc.py3.ncfParser.ncfParser.Bcd_valueContext)
visitBitrate(ctx: pydbc.py3.ncfParser.ncfParser.BitrateContext)
visitBitrate_definition(ctx: pydbc.py3.ncfParser.ncfParser.Bitrate_definitionContext)
visitDiagnostic_definition(ctx: pydbc.py3.ncfParser.ncfParser.Diagnostic_definitionContext)
visitEncoding_definition(ctx: pydbc.py3.ncfParser.ncfParser.Encoding_definitionContext)
visitEncoding_definition_entry(ctx: pydbc.py3.ncfParser.ncfParser.Encoding_definition_entryContext)
visitEncoding_definition_value(ctx: pydbc.py3.ncfParser.ncfParser.Encoding_definition_valueContext)
visitEncoding_name(ctx: pydbc.py3.ncfParser.ncfParser.Encoding_nameContext)
visitFloatValue(ctx: pydbc.py3.ncfParser.ncfParser.FloatValueContext)
visitFrame_definition(ctx: pydbc.py3.ncfParser.ncfParser.Frame_definitionContext)
visitFrame_kind(ctx: pydbc.py3.ncfParser.ncfParser.Frame_kindContext)
visitFrame_name(ctx: pydbc.py3.ncfParser.ncfParser.Frame_nameContext)
visitFrame_properties(ctx: pydbc.py3.ncfParser.ncfParser.Frame_propertiesContext)
visitFree_text_definition(ctx: pydbc.py3.ncfParser.ncfParser.Free_text_definitionContext)
visitFunction_id(ctx: pydbc.py3.ncfParser.ncfParser.Function_idContext)
visitGeneral_definition(ctx: pydbc.py3.ncfParser.ncfParser.General_definitionContext)
visitIdentifierValue(ctx: pydbc.py3.ncfParser.ncfParser.IdentifierValueContext)
visitInit_value(ctx: pydbc.py3.ncfParser.ncfParser.Init_valueContext)
visitInit_value_array(ctx: pydbc.py3.ncfParser.ncfParser.Init_value_arrayContext)
visitInit_value_scalar(ctx: pydbc.py3.ncfParser.ncfParser.Init_value_scalarContext)
visitIntValue(ctx: pydbc.py3.ncfParser.ncfParser.IntValueContext)
visitLanguage_version(ctx: pydbc.py3.ncfParser.ncfParser.Language_versionContext)
visitLogical_value(ctx: pydbc.py3.ncfParser.ncfParser.Logical_valueContext)
visitMax_value(ctx: pydbc.py3.ncfParser.ncfParser.Max_valueContext)
visitMin_value(ctx: pydbc.py3.ncfParser.ncfParser.Min_valueContext)
visitNode_definition(ctx: pydbc.py3.ncfParser.ncfParser.Node_definitionContext)
visitNode_name(ctx: pydbc.py3.ncfParser.ncfParser.Node_nameContext)
visitNumber(ctx: pydbc.py3.ncfParser.ncfParser.NumberContext)
visitOffset(ctx: pydbc.py3.ncfParser.ncfParser.OffsetContext)
visitPhysical_range(ctx: pydbc.py3.ncfParser.ncfParser.Physical_rangeContext)
visitProtocol_version(ctx: pydbc.py3.ncfParser.ncfParser.Protocol_versionContext)
visitPublished_signal(ctx: pydbc.py3.ncfParser.ncfParser.Published_signalContext)
visitScale(ctx: pydbc.py3.ncfParser.ncfParser.ScaleContext)
visitSignal_definition(ctx: pydbc.py3.ncfParser.ncfParser.Signal_definitionContext)
visitSignal_definition_entry(ctx: pydbc.py3.ncfParser.ncfParser.Signal_definition_entryContext)
visitSignal_name(ctx: pydbc.py3.ncfParser.ncfParser.Signal_nameContext)
visitSignal_properties(ctx: pydbc.py3.ncfParser.ncfParser.Signal_propertiesContext)
visitSignal_value(ctx: pydbc.py3.ncfParser.ncfParser.Signal_valueContext)
visitSingle_frame(ctx: pydbc.py3.ncfParser.ncfParser.Single_frameContext)
visitStatus_management(ctx: pydbc.py3.ncfParser.ncfParser.Status_managementContext)
visitStringValue(ctx: pydbc.py3.ncfParser.ncfParser.StringValueContext)
visitSupplier_id(ctx: pydbc.py3.ncfParser.ncfParser.Supplier_idContext)
visitText_info(ctx: pydbc.py3.ncfParser.ncfParser.Text_infoContext)
visitToplevel(ctx: pydbc.py3.ncfParser.ncfParser.ToplevelContext)
visitVariant_id(ctx: pydbc.py3.ncfParser.ncfParser.Variant_idContext)

Module contents