PrologParser

open class PrologParser : DynamicParser

Constructors

PrologParser

open fun PrologParser(input: TokenStream)

Types

BlockContext

open class BlockContext : ParserRuleContext

ClauseContext

open class ClauseContext : ParserRuleContext

ExpressionContext

open class ExpressionContext : ParserRuleContext

IntegerContext

open class IntegerContext : ParserRuleContext

ListContext

open class ListContext : ParserRuleContext

NumberContext

open class NumberContext : ParserRuleContext

OpContext

open class OpContext : ParserRuleContext

OptClauseContext

open class OptClauseContext : ParserRuleContext

OptExpressionContext

open class OptExpressionContext : ParserRuleContext

OuterContext

open class OuterContext : ParserRuleContext

RealContext

open class RealContext : ParserRuleContext

SingletonExpressionContext

open class SingletonExpressionContext : ParserRuleContext

SingletonTermContext

open class SingletonTermContext : ParserRuleContext

StructureContext

open class StructureContext : ParserRuleContext

TermContext

open class TermContext : ParserRuleContext

TheoryContext

open class TheoryContext : ParserRuleContext

VariableContext

open class VariableContext : ParserRuleContext

Functions

action

open fun action(_localctx: RuleContext, ruleIndex: Int, actionIndex: Int)

addErrorListener

open fun addErrorListener(listener: ANTLRErrorListener)

addOperator

open fun addOperator(functor: String, associativity: Associativity, priority: Int)

addParseListener

open fun addParseListener(listener: ParseTreeListener)

block

fun block(): PrologParser.BlockContext

clause

fun clause(): PrologParser.ClauseContext

compileParseTreePattern

open fun compileParseTreePattern(pattern: String, patternRuleIndex: Int): ParseTreePattern

consume

open fun consume(): Token

createErrorNode

open fun createErrorNode(parent: ParserRuleContext, t: Token): ErrorNode

createTerminalNode

open fun createTerminalNode(parent: ParserRuleContext, t: Token): TerminalNode

dumpDFA

open fun dumpDFA()

enterOuterAlt

open fun enterOuterAlt(localctx: ParserRuleContext, altNum: Int)

enterRecursionRule

open fun enterRecursionRule(localctx: ParserRuleContext, ruleIndex: Int)

enterRule

open fun enterRule(localctx: ParserRuleContext, state: Int, ruleIndex: Int)

exitRule

open fun exitRule()

expression

fun expression(priority: Int, disabled: Array<String>): PrologParser.ExpressionContext

getATN

open fun getATN(): ATN

abstract fun getATN(): ATN

getATNWithBypassAlts

open fun getATNWithBypassAlts(): ATN

getBuildParseTree

open fun getBuildParseTree(): Boolean

getContext

open fun getContext(): ParserRuleContext

getCurrentToken

open fun getCurrentToken(): Token

getDFAStrings

open fun getDFAStrings(): List<String>

getErrorHandler

open fun getErrorHandler(): ANTLRErrorStrategy

getErrorHeader

open fun getErrorHeader(e: RecognitionException): String

getErrorListenerDispatch

open fun getErrorListenerDispatch(): ANTLRErrorListener

getErrorListeners

open fun getErrorListeners(): List<out ANTLRErrorListener>

getExpectedTokens

open fun getExpectedTokens(): IntervalSet

getExpectedTokensWithinCurrentRule

open fun getExpectedTokensWithinCurrentRule(): IntervalSet

getGrammarFileName

open fun getGrammarFileName(): String

abstract fun getGrammarFileName(): String

getInputStream

open fun getInputStream(): TokenStream

abstract fun getInputStream(): IntStream

getInterpreter

open fun getInterpreter(): ATNInterpreter

getInvokingContext

open fun getInvokingContext(ruleIndex: Int): ParserRuleContext

getLexer

open fun getLexer(): DynamicLexer

getNumberOfSyntaxErrors

open fun getNumberOfSyntaxErrors(): Int

getOperatorPriority

open fun getOperatorPriority(operator: String, associativity: Associativity): Int

open fun getOperatorPriority(operator: Token, associativity: Associativity): Int

getParseInfo

open fun getParseInfo(): ParseInfo

getParseListeners

open fun getParseListeners(): List<ParseTreeListener>

getPrecedence

fun getPrecedence(): Int

getRuleContext

open fun getRuleContext(): ParserRuleContext

getRuleIndex

open fun getRuleIndex(ruleName: String): Int

getRuleIndexMap

open fun getRuleIndexMap(): Map<String, Integer>

getRuleInvocationStack

open fun getRuleInvocationStack(): List<String>

getRuleNames

abstract fun getRuleNames(): Array<String>

getSerializedATN

open fun getSerializedATN(): String

getSourceName

open fun getSourceName(): String

getState

fun getState(): Int

getTokenErrorDisplay

open fun getTokenErrorDisplay(t: Token): String

getTokenFactory

open fun getTokenFactory(): TokenFactory<out Any>

getTokenNames

abstract fun getTokenNames(): Array<String>

getTokenStream

open fun getTokenStream(): TokenStream

getTokenType

open fun getTokenType(tokenName: String): Int

getTokenTypeMap

open fun getTokenTypeMap(): Map<String, Integer>

getTrimParseTree

open fun getTrimParseTree(): Boolean

getVocabulary

open fun getVocabulary(): Vocabulary

inContext

open fun inContext(context: String): Boolean

integer

fun integer(): PrologParser.IntegerContext

isExpectedToken

open fun isExpectedToken(symbol: Int): Boolean

isMatchedEOF

open fun isMatchedEOF(): Boolean

isOperator

open fun isOperator(functor: String): Boolean

open fun isOperator(token: Token): Boolean

isOperatorAssociativity

open fun isOperatorAssociativity(functor: String, a: Associativity): Boolean

open fun isOperatorAssociativity(token: Token, associativity: Associativity): Boolean

isTrace

open fun isTrace(): Boolean

list

fun list(): PrologParser.ListContext

match

open fun match(ttype: Int): Token

matchWildcard

open fun matchWildcard(): Token

notifyErrorListeners

fun notifyErrorListeners(msg: String)

number

fun number(): PrologParser.NumberContext

fun op(associativity: Associativity): PrologParser.OpContext

optClause

fun optClause(): PrologParser.OptClauseContext

optExpression

fun optExpression(): PrologParser.OptExpressionContext

outer

fun outer(top: Int, bottom: Int, disabled: Array<String>): PrologParser.OuterContext

precpred

open fun precpred(localctx: RuleContext, precedence: Int): Boolean

pushNewRecursionContext

open fun pushNewRecursionContext(localctx: ParserRuleContext, state: Int, ruleIndex: Int)

real

fun real(): PrologParser.RealContext

removeErrorListener

open fun removeErrorListener(listener: ANTLRErrorListener)

removeErrorListeners

open fun removeErrorListeners()

removeOperator

open fun removeOperator(functor: String)

removeParseListener

open fun removeParseListener(listener: ParseTreeListener)

removeParseListeners

open fun removeParseListeners()

reset

open fun reset()

sempred

open fun sempred(_localctx: RuleContext, ruleIndex: Int, predIndex: Int): Boolean

open fun sempred(_localctx: RuleContext, ruleIndex: Int, actionIndex: Int): Boolean

setBuildParseTree

open fun setBuildParseTree(buildParseTrees: Boolean)

setContext

open fun setContext(ctx: ParserRuleContext)

setErrorHandler

open fun setErrorHandler(handler: ANTLRErrorStrategy)

setInputStream

fun setInputStream(input: IntStream)

setInterpreter

open fun setInterpreter(interpreter: ATNInterpreter)

setLexer

open fun setLexer(lexer: DynamicLexer)

setProfile

open fun setProfile(profile: Boolean)

setState

fun setState(atnState: Int)

setTokenFactory

open fun setTokenFactory(factory: TokenFactory<out Any>)

setTokenStream

open fun setTokenStream(input: TokenStream)

setTrace

open fun setTrace(trace: Boolean)

setTrimParseTree

open fun setTrimParseTree(trimParseTrees: Boolean)

singletonExpression

fun singletonExpression(): PrologParser.SingletonExpressionContext

singletonTerm

fun singletonTerm(): PrologParser.SingletonTermContext

structure

fun structure(): PrologParser.StructureContext

term

fun term(): PrologParser.TermContext

theory

fun theory(): PrologParser.TheoryContext

unrollRecursionContexts

open fun unrollRecursionContexts(_parentctx: ParserRuleContext)

variable

fun variable(): PrologParser.VariableContext

Properties

_ATN

val _ATN: ATN

_serializedATN

val _serializedATN: String

ATOM

val ATOM: Int

BINARY

val BINARY: Int

BOOL

val BOOL: Int

BOTTOM

val BOTTOM: Int

CHAR

val CHAR: Int

COMMA

val COMMA: Int

COMMENT

val COMMENT: Int

CUT

val CUT: Int

DQ_STRING

val DQ_STRING: Int

EMPTY_LIST

val EMPTY_LIST: Int

EMPTY_SET

val EMPTY_SET: Int

FLOAT

val FLOAT: Int

FULL_STOP

val FULL_STOP: Int

HEX

val HEX: Int

INTEGER

val INTEGER: Int

LBRACE

val LBRACE: Int

LINE_COMMENT

val LINE_COMMENT: Int

LPAR

val LPAR: Int

LSQUARE

val LSQUARE: Int

NO_COMMA

val NO_COMMA: Array<String>

NO_COMMA_PIPE

val NO_COMMA_PIPE: Array<String>

NO_ROOT

val NO_ROOT: PrologParser.ExpressionContext

OCT

val OCT: Int

OPERATOR

val OPERATOR: Int

val P0: Int

PIPE

val PIPE: Int

RBRACE

val RBRACE: Int

RPAR

val RPAR: Int

RSQUARE

val RSQUARE: Int

RULE_block

val RULE_block: Int

RULE_clause

val RULE_clause: Int

RULE_expression

val RULE_expression: Int

RULE_integer

val RULE_integer: Int

RULE_list

val RULE_list: Int

RULE_number

val RULE_number: Int

RULE_op

val RULE_op: Int

RULE_optClause

val RULE_optClause: Int

RULE_optExpression

val RULE_optExpression: Int

RULE_outer

val RULE_outer: Int

RULE_real

val RULE_real: Int

RULE_singletonExpression

val RULE_singletonExpression: Int

RULE_singletonTerm

val RULE_singletonTerm: Int

RULE_structure

val RULE_structure: Int

RULE_term

val RULE_term: Int

RULE_theory

val RULE_theory: Int

RULE_variable

val RULE_variable: Int

ruleNames

val ruleNames: Array<String>

SIGN

val SIGN: Int

SQ_STRING

val SQ_STRING: Int

tokenNames

@Deprecated()

val tokenNames: Array<String>

Use VOCABULARY instead.

TOP

val TOP: Int

VARIABLE

val VARIABLE: Int

VOCABULARY

val VOCABULARY: Vocabulary

WHITE_SPACES

val WHITE_SPACES: Int

WITH_COMMA

val WITH_COMMA: Array<String>