Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance. Project price only 1 $
You can buy this project and download/modify it how often you want.
// Copyright 2017-present Strumenta and contributors, licensed under Apache 2.0.
// Copyright 2024-present Strumenta and contributors, licensed under BSD 3-Clause.
package org.antlr.v4.kotlinruntime.atn
import org.antlr.v4.kotlinruntime.Token
import org.antlr.v4.kotlinruntime.misc.IntervalSet
/**
* @author Sam Harwell
*/
public open class ATNDeserializer(private val deserializationOptions: ATNDeserializationOptions = ATNDeserializationOptions.defaultOptions) {
public companion object {
public const val SERIALIZED_VERSION: Int = 4
}
public open fun deserialize(data: CharArray): ATN =
deserialize(decodeIntsEncodedAs16BitWords(data))
public open fun deserialize(data: IntArray): ATN {
var p = 0
val version = data[p++]
if (version != SERIALIZED_VERSION) {
val reason = "Could not deserialize ATN with version $version (expected $SERIALIZED_VERSION)."
throw UnsupportedOperationException(/* InvalidClassException(ATN::class), */ reason)
}
val grammarType = ATNType.entries[data[p++]]
val maxTokenType = data[p++]
val atn = ATN(grammarType, maxTokenType)
//
// STATES
//
val loopBackStateNumbers = ArrayList>()
val endStateNumbers = ArrayList>()
val nStates = data[p++]
for (i in 0..()
p = deserializeSets(data, p, sets)
//
// EDGES
//
val nEdges = data[p++]
for (i in 0.. 0) {
val transition = atn.ruleToStartState!![i].removeTransition(atn.ruleToStartState!![i].numberOfTransitions - 1)
bypassStart.addTransition(transition)
}
// Link the new states
atn.ruleToStartState!![i].addTransition(EpsilonTransition(bypassStart))
bypassStop.addTransition(EpsilonTransition(endState!!))
val matchState = BasicState()
atn.addState(matchState)
matchState.addTransition(AtomTransition(bypassStop, atn.ruleToTokenType!![i]))
bypassStart.addTransition(EpsilonTransition(matchState))
}
if (deserializationOptions.isVerifyATN) {
// Re-verify after modification
verifyATN(atn)
}
}
return atn
}
private fun deserializeSets(data: IntArray, p: Int, sets: MutableList): Int {
var pp = p
val nSets = data[pp++]
for (i in 0.. {
checkCondition(state.transition(1).target is LoopEndState)
checkCondition(!state.nonGreedy)
}
is LoopEndState -> {
checkCondition(state.transition(1).target is StarBlockStartState)
checkCondition(state.nonGreedy)
}
else -> throw IllegalStateException()
}
}
if (state is StarLoopbackState) {
checkCondition(state.numberOfTransitions == 1)
checkCondition(state.transition(0).target is StarLoopEntryState)
}
if (state is LoopEndState) {
checkCondition(state.loopBackState != null)
}
if (state is RuleStartState) {
checkCondition(state.stopState != null)
}
if (state is BlockStartState) {
checkCondition(state.endState != null)
}
if (state is BlockEndState) {
checkCondition(state.startState != null)
}
if (state is DecisionState) {
checkCondition(state.numberOfTransitions <= 1 || state.decision >= 0)
} else {
checkCondition(state.numberOfTransitions <= 1 || state is RuleStopState)
}
}
}
public open fun checkCondition(condition: Boolean, message: String? = null) {
if (!condition) {
throw IllegalStateException(message)
}
}
public open fun edgeFactory(
atn: ATN,
type: Int,
src: Int,
trg: Int,
arg1: Int,
arg2: Int,
arg3: Int,
sets: List,
): Transition {
val target = atn.states[trg]!!
return when (type) {
Transition.EPSILON -> {
EpsilonTransition(target)
}
Transition.RANGE -> {
if (arg3 != 0) {
RangeTransition(target, Token.EOF, arg2)
} else {
RangeTransition(target, arg1, arg2)
}
}
Transition.RULE -> {
RuleTransition(atn.states[arg1] as RuleStartState, arg2, arg3, target)
}
Transition.PREDICATE -> {
PredicateTransition(target, arg1, arg2, arg3 != 0)
}
Transition.PRECEDENCE -> {
PrecedencePredicateTransition(target, arg1)
}
Transition.ATOM -> {
if (arg3 != 0) {
AtomTransition(target, Token.EOF)
} else {
AtomTransition(target, arg1)
}
}
Transition.ACTION -> {
ActionTransition(target, arg1, arg2, arg3 != 0)
}
Transition.SET -> {
SetTransition(target, sets[arg1])
}
Transition.NOT_SET -> {
NotSetTransition(target, sets[arg1])
}
Transition.WILDCARD -> {
WildcardTransition(target)
}
else -> throw IllegalArgumentException("The specified transition type is not valid.")
}
}
public open fun stateFactory(type: Int, ruleIndex: Int): ATNState? {
val s: ATNState = when (type) {
ATNState.INVALID_TYPE -> return null
ATNState.BASIC -> BasicState()
ATNState.RULE_START -> RuleStartState()
ATNState.BLOCK_START -> BasicBlockStartState()
ATNState.PLUS_BLOCK_START -> PlusBlockStartState()
ATNState.STAR_BLOCK_START -> StarBlockStartState()
ATNState.TOKEN_START -> TokensStartState()
ATNState.RULE_STOP -> RuleStopState()
ATNState.BLOCK_END -> BlockEndState()
ATNState.STAR_LOOP_BACK -> StarLoopbackState()
ATNState.STAR_LOOP_ENTRY -> StarLoopEntryState()
ATNState.PLUS_LOOP_BACK -> PlusLoopbackState()
ATNState.LOOP_END -> LoopEndState()
else -> throw IllegalArgumentException("The specified state type $type is not valid.")
}
s.ruleIndex = ruleIndex
return s
}
protected open fun lexerActionFactory(type: LexerActionType, data1: Int, data2: Int): LexerAction =
when (type) {
LexerActionType.CHANNEL -> LexerChannelAction(data1)
LexerActionType.CUSTOM -> LexerCustomAction(data1, data2)
LexerActionType.MODE -> LexerModeAction(data1)
LexerActionType.MORE -> LexerMoreAction
LexerActionType.POP_MODE -> LexerPopModeAction
LexerActionType.PUSH_MODE -> LexerPushModeAction(data1)
LexerActionType.SKIP -> LexerSkipAction
LexerActionType.TYPE -> LexerTypeAction(data1)
}
/**
* Convert a list of chars (16 uint) that represent a serialized and compressed list of ints for an ATN.
*/
public open fun decodeIntsEncodedAs16BitWords(data16: CharArray, trimToSize: Boolean = false): IntArray {
// Will be strictly smaller, but we waste bit of space to avoid copying during initialization of parsers
val data = IntArray(data16.size)
var i = 0
var i2 = 0
while (i < data16.size) {
val v = data16[i++]
if (v.code and 0x8000 == 0) {
// Hi-bit not set? Implies 1-word value
// 7 bit int
data[i2++] = v.code
} else {
// Hi.bit set. Implies 2-word value
val vnext = data16[i++]
if (v.code == 0xFFFF && vnext.code == 0xFFFF) { // Is it -1?
data[i2++] = -1
} else {
// 31-bit int
data[i2++] = (v.code and 0x7FFF) shl 16 or (vnext.code and 0xFFFF)
}
}
}
if (trimToSize) {
return data.copyOfRange(0, i2)
}
return data
}
}
