parser-core/it.unibo.tuprolog.core.parsing

Package-level declarations

Types

InvalidTermTypeException

class InvalidTermTypeException(input: Any?, val term: Term, val type: KClass<out Term>, offendingSymbol: String = input as? String ?: term.toString(), line: Int = 1, column: Int = 1, message: String? = "Expected ", throwable: Throwable? = null) : ParseException

Indicates that valid Prolog syntax produced a term of a different type than the caller requested.

open class ParseException(var input: Any?, var offendingSymbol: String?, var line: Int, var column: Int, message: String?, throwable: Throwable?) : TuPrologException

Reports a failure while turning Prolog source into a tuProlog domain object.

PrologTermParserVisitor

open class PrologTermParserVisitor(val scope: Scope) : SyntaxNodeVisitor<Term>

Converts parser concrete-syntax nodes into tuProlog Terms allocated in scope.

interface TermParser

Parses one Prolog expression from a String and maps it to the tuProlog term model.

class TermParserImpl(val scope: Scope, val defaultOperatorSet: OperatorSet, lexerOptions: LexerOptions = LexerOptions(), parserOptions: ParserOptions = ParserOptions()) : TermParser

Configurable default implementation of TermParser.

interface TermReader

Lazily reads Prolog terms from JVM character or byte streams.

class TermReaderImpl(val scope: Scope, val defaultOperatorSet: OperatorSet, lexerOptions: LexerOptions = LexerOptions(), parserOptions: ParserOptions = ParserOptions()) : TermReader

Configurable JVM implementation of TermReader.

Functions

fun Atom.Companion.parse(input: String): Atom

Parses input as an atom.

fun Clause.Companion.parse(input: String): Clause

Parses input as a clause.

fun Constant.Companion.parse(input: String): Constant

Parses input as a constant.

fun Directive.Companion.parse(input: String): Directive

Parses input as a directive.

fun Fact.Companion.parse(input: String): Fact

Parses input as a fact.

fun Integer.Companion.parse(input: String): Integer

Parses input as an integer.

fun Numeric.Companion.parse(input: String): Numeric

Parses input as a numeric term.

fun Real.Companion.parse(input: String): Real

Parses input as a real.

fun Rule.Companion.parse(input: String): Rule

Parses input as a rule.

fun Struct.Companion.parse(input: String): Struct

Parses input as a structure.

fun Term.Companion.parse(input: String): Term

Parses input as a term using default operators.

fun Var.Companion.parse(input: String): Var

Parses input as a variable.

fun Atom.Companion.parse(input: String, operators: OperatorSet): Atom

Parses input as an atom using operators.

fun Clause.Companion.parse(input: String, operators: OperatorSet): Clause

Parses input as a clause using operators.

fun Constant.Companion.parse(input: String, operators: OperatorSet): Constant

Parses input as a constant using operators.

fun Directive.Companion.parse(input: String, operators: OperatorSet): Directive

Parses input as a directive using operators.

fun Fact.Companion.parse(input: String, operators: OperatorSet): Fact

Parses input as a fact using operators.

fun Integer.Companion.parse(input: String, operators: OperatorSet): Integer

Parses input as an integer using operators.

fun Numeric.Companion.parse(input: String, operators: OperatorSet): Numeric

Parses input as a numeric term using operators.

fun Real.Companion.parse(input: String, operators: OperatorSet): Real

Parses input as a real using operators.

fun Rule.Companion.parse(input: String, operators: OperatorSet): Rule

Parses input as a rule using operators.

fun Struct.Companion.parse(input: String, operators: OperatorSet): Struct

Parses input as a structure using operators.

fun Term.Companion.parse(input: String, operators: OperatorSet): Term

Parses input as a term using operators.

fun Var.Companion.parse(input: String, operators: OperatorSet): Var

Parses input as a variable using operators.

fun String.parseAsAtom(): Atom

Parses this string as an atom.

fun String.parseAsAtom(operators: OperatorSet): Atom

Parses this string as an atom using operators.

fun String.parseAsClause(): Clause

Parses this string as a clause.

fun String.parseAsClause(operators: OperatorSet): Clause

Parses this string as a clause using operators.

parseAsConstant

fun String.parseAsConstant(): Constant

Parses this string as a constant.

fun String.parseAsConstant(operators: OperatorSet): Constant

Parses this string as a constant using operators.

parseAsDirective

fun String.parseAsDirective(): Directive

Parses this string as a directive.

fun String.parseAsDirective(operators: OperatorSet): Directive

Parses this string as a directive using operators.

fun String.parseAsFact(): Fact

Parses this string as a fact.

fun String.parseAsFact(operators: OperatorSet): Fact

Parses this string as a fact using operators.

fun String.parseAsInteger(): Integer

Parses this string as an integer.

fun String.parseAsInteger(operators: OperatorSet): Integer

Parses this string as an integer using operators.

fun String.parseAsNumeric(): Numeric

Parses this string as a numeric term.

fun String.parseAsNumeric(operators: OperatorSet): Numeric

Parses this string as a numeric term using operators.

fun String.parseAsReal(): Real

Parses this string as a real.

fun String.parseAsReal(operators: OperatorSet): Real

Parses this string as a real using operators.

fun String.parseAsRule(): Rule

Parses this string as a rule.

fun String.parseAsRule(operators: OperatorSet): Rule

Parses this string as a rule using operators.

fun String.parseAsStruct(): Struct

Parses this string as a structure.

fun String.parseAsStruct(operators: OperatorSet): Struct

Parses this string as a structure using operators.

fun String.parseAsTerm(): Term

Parses this string as a term using default operators.

fun String.parseAsTerm(operators: OperatorSet): Term

Parses this string as a term using operators.

fun String.parseAsVar(): Var

Parses this string as a variable.

fun String.parseAsVar(operators: OperatorSet): Var

Parses this string as a variable using operators.

toAssociativity

fun Specifier.toAssociativity(): Associativity

Converts a core Prolog operator specifier to its parser-level equivalent.

fun Term.toClause(source: Any? = null, line: Int = 0, column: Int = 0): Clause

Converts this term to a clause, promoting a Struct to a fact when necessary.

fun Operator.toDefinition(): OperatorDefinition

Converts a core operator to the representation consumed by parser-impl.

fun OperatorDefinition.toOperator(): Operator

Converts a parser-level operator definition to its core equivalent.

toOperatorTable

fun OperatorSet.toOperatorTable(): OperatorTable

Creates an immutable parser-level table containing all operators in this set.

toParseException

fun PrologSyntaxException.toParseException(input: Any?): ParseException

fun Associativity.toSpecifier(): Specifier

Converts a parser-level Prolog associativity specifier to its core equivalent.