Public

Checks if all configurations in configs are in a RuleStopState. Configurations
meeting this conditio

allConfigsInRuleStopStates

Get union of all alts from configs. @since 4.5.1

getAlts

This function gets the conflicting alt subsets from a configuration set. For
each configuration c in

getConflictingAltSubsets

getSingleViableAlt

Get a map from state to alt subset from a configuration set. For each
configuration c in configs: 
m

getStateToAltMap

Checks if any configuration in configs is in a RuleStopState. Configurations
meeting this condition 

hasConfigInRuleStopState

Determines if any single alternative subset in altsets contains more than one
alternative.

hasConflictingAltSet

Determines if any single alternative subset in altsets contains exactly one
alternative.

hasNonConflictingAltSet

hasStateAssociatedWithOneAlt

Determines if every alternative subset in altsets contains more than one
alternative.

allSubsetsConflict

Determines if every alternative subset in altsets is equivalent.

allSubsetsEqual

Computes the SLL prediction termination condition. This method computes the SLL
prediction terminati

hasSLLConflictTerminatingPrediction

Full LL prediction termination.Can we stop looking ahead during ATN simulation
or is there some unce

resolvesToJustOneViableAlt

PredictionMode

Finding current android device location

A flow layout arranges components in a left-to-right flow, much like lines of
text in a paragraph. F

java.awt.FlowLayout

An "abstract" representation of a file system entity identified by a pathname.
The pathname may be a

java.io.File

A controller for the selection of SelectableChannel objects. Selectable channels
can be registered w

java.nio.channels.Selector

A parser that parses a text string of primitive types and strings with the help
of regular expressio

java.util.Scanner

A java.util.Queue that additionally supports operations that wait for the queue
to become non-empty 

java.util.concurrent.BlockingQueue

This class provides random read access to a zip file. You pay more to read the
zip file's central di

java.util.zip.ZipFile

getApplicationContext

onRequestPermissionsResult

getContentResolver

/**
	 * Computes the SLL prediction termination condition.
	 *
	 * 
	 * This method computes the SLL prediction termination condition for both of
	 * the following cases.
	 *
	 * <ul>
	 * <li>The usual SLL+LL fallback upon SLL conflict</li>
	 * <li>Pure SLL without LL fallback</li>
	 * </ul>
	 *
	 * COMBINED SLL+LL PARSING
	 *
	 * When LL-fallback is enabled upon SLL conflict, correct predictions are
	 * ensured regardless of how the termination condition is computed by this
	 * method. Due to the substantially higher cost of LL prediction, the
	 * prediction should only fall back to LL when the additional lookahead
	 * cannot lead to a unique SLL prediction.
	 *
	 * Assuming combined SLL+LL parsing, an SLL configuration set with only
	 * conflicting subsets should fall back to full LL, even if the
	 * configuration sets don't resolve to the same alternative (e.g.
	 * {@code {1,2}} and {@code {3,4}}. If there is at least one non-conflicting
	 * configuration, SLL could continue with the hopes that more lookahead will
	 * resolve via one of those non-conflicting configurations.
	 *
	 * Here's the prediction termination rule them: SLL (for SLL+LL parsing)
	 * stops when it sees only conflicting configuration subsets. In contrast,
	 * full LL keeps going when there is uncertainty.
	 *
	 * HEURISTIC
	 *
	 * As a heuristic, we stop prediction when we see any conflicting subset
	 * unless we see a state that only has one alternative associated with it.
	 * The single-alt-state thing lets prediction continue upon rules like
	 * (otherwise, it would admit defeat too soon):
	 *
	 * {@code [12|1|[], 6|2|[], 12|2|[]]. s : (ID | ID ID?) ';' ;}
	 *
	 * When the ATN simulation reaches the state before {@code ';'}, it has a
	 * DFA state that looks like: {@code [12|1|[], 6|2|[], 12|2|[]]}. Naturally
	 * {@code 12|1|[]} and {@code 12|2|[]} conflict, but we cannot stop
	 * processing this node because alternative to has another way to continue,
	 * via {@code [6|2|[]]}.
	 *
	 * It also let's us continue for this rule:
	 *
	 * {@code [1|1|[], 1|2|[], 8|3|[]] a : A | A | A B ;}
	 *
	 * After matching input A, we reach the stop state for rule A, state 1.
	 * State 8 is the state right before B. Clearly alternatives 1 and 2
	 * conflict and no amount of further lookahead will separate the two.
	 * However, alternative 3 will be able to continue and so we do not stop
	 * working on this state. In the previous example, we're concerned with
	 * states associated with the conflicting alternatives. Here alt 3 is not
	 * associated with the conflicting configs, but since we can continue
	 * looking for input reasonably, don't declare the state done.
	 *
	 * PURE SLL PARSING
	 *
	 * To handle pure SLL parsing, all we have to do is make sure that we
	 * combine stack contexts for configurations that differ only by semantic
	 * predicate. From there, we can do the usual SLL termination heuristic.
	 *
	 * PREDICATES IN SLL+LL PARSING
	 *
	 * SLL decisions don't evaluate predicates until after they reach DFA stop
	 * states because they need to create the DFA cache that works in all
	 * semantic situations. In contrast, full LL evaluates predicates collected
	 * during start state computation so it can ignore predicates thereafter.
	 * This means that SLL termination detection can totally ignore semantic
	 * predicates.
	 *
	 * Implementation-wise, {@link ATNConfigSet} combines stack contexts but not
	 * semantic predicate contexts so we might see two configurations like the
	 * following.
	 *
	 * {@code (s, 1, x, {}), (s, 1, x', {p})}
	 *
	 * Before testing these configurations against others, we have to merge
	 * {@code x} and {@code x'} (without modifying the existing configurations).
	 * For example, we test {@code (x+x')==x''} when looking for conflicts in
	 * the following configurations.
	 *
	 * {@code (s, 1, x, {}), (s, 1, x', {p}), (s, 2, x'', {})}
	 *
	 * If the configuration set has predicates (as indicated by
	 * {@link ATNConfigSet#hasSemanticContext}), this algorithm makes a copy of
	 * the configurations to strip out all of the predicates so that a standard
	 * {@link ATNConfigSet} will merge everything ignoring predicates.
	 */

/* Configs in rule stop states indicate reaching the end of the decision
		 * rule (local context) or end of start rule (full context). If all
		 * configs meet this condition, then none of the configurations is able
		 * to match additional input so we terminate prediction.
		 */

// Don't bother with combining configs from different semantic

// contexts if we can fail over to full LL; costs more time

// dup configs, tossing out semantic predicates

// now we have combined contexts for configs with dissimilar preds

// pure SLL or combined SLL+LL mode parsing

/**
	 * Computes the SLL prediction termination condition.
	 *
	 * 
	 * This method computes the SLL prediction termination condition for both of
	 * the following cases.
	 *
	 * <ul>
	 * <li>The usual SLL+LL fallback upon SLL conflict</li>
	 * <li>Pure SLL without LL fallback</li>
	 * </ul>
	 *
	 * COMBINED SLL+LL PARSING
	 *
	 * When LL-fallback is enabled upon SLL conflict, correct predictions are
	 * ensured regardless of how the termination condition is computed by this
	 * method. Due to the substantially higher cost of LL prediction, the
	 * prediction should only fall back to LL when the additional lookahead
	 * cannot lead to a unique SLL prediction.
	 *
	 * Assuming combined SLL+LL parsing, an SLL configuration set with only
	 * conflicting subsets should fall back to full LL, even if the
	 * configuration sets don't resolve to the same alternative (e.g.
	 * {@code {1,2}} and {@code {3,4}}. If there is at least one non-conflicting
	 * configuration, SLL could continue with the hopes that more lookahead will
	 * resolve via one of those non-conflicting configurations.
	 *
	 * Here's the prediction termination rule them: SLL (for SLL+LL parsing)
	 * stops when it sees only conflicting configuration subsets. In contrast,
	 * full LL keeps going when there is uncertainty.
	 *
	 * HEURISTIC
	 *
	 * As a heuristic, we stop prediction when we see any conflicting subset
	 * unless we see a state that only has one alternative associated with it.
	 * The single-alt-state thing lets prediction continue upon rules like
	 * (otherwise, it would admit defeat too soon):
	 *
	 * {@code [12|1|[], 6|2|[], 12|2|[]]. s : (ID | ID ID?) ';' ;}
	 *
	 * When the ATN simulation reaches the state before {@code ';'}, it has a
	 * DFA state that looks like: {@code [12|1|[], 6|2|[], 12|2|[]]}. Naturally
	 * {@code 12|1|[]} and {@code 12|2|[]} conflict, but we cannot stop
	 * processing this node because alternative to has another way to continue,
	 * via {@code [6|2|[]]}.
	 *
	 * It also let's us continue for this rule:
	 *
	 * {@code [1|1|[], 1|2|[], 8|3|[]] a : A | A | A B ;}
	 *
	 * After matching input A, we reach the stop state for rule A, state 1.
	 * State 8 is the state right before B. Clearly alternatives 1 and 2
	 * conflict and no amount of further lookahead will separate the two.
	 * However, alternative 3 will be able to continue and so we do not stop
	 * working on this state. In the previous example, we're concerned with
	 * states associated with the conflicting alternatives. Here alt 3 is not
	 * associated with the conflicting configs, but since we can continue
	 * looking for input reasonably, don't declare the state done.
	 *
	 * PURE SLL PARSING
	 *
	 * To handle pure SLL parsing, all we have to do is make sure that we
	 * combine stack contexts for configurations that differ only by semantic
	 * predicate. From there, we can do the usual SLL termination heuristic.
	 *
	 * PREDICATES IN SLL+LL PARSING
	 *
	 * SLL decisions don't evaluate predicates until after they reach DFA stop
	 * states because they need to create the DFA cache that works in all
	 * semantic situations. In contrast, full LL evaluates predicates collected
	 * during start state computation so it can ignore predicates thereafter.
	 * This means that SLL termination detection can totally ignore semantic
	 * predicates.
	 *
	 * Implementation-wise, {@link ATNConfigSet} combines stack contexts but not
	 * semantic predicate contexts so we might see two configurations like the
	 * following.
	 *
	 * {@code (s, 1, x, {}), (s, 1, x', {p})}
	 *
	 * Before testing these configurations against others, we have to merge
	 * {@code x} and {@code x'} (without modifying the existing configurations).
	 * For example, we test {@code (x+x')==x''} when looking for conflicts in
	 * the following configurations.
	 *
	 * {@code (s, 1, x, {}), (s, 1, x', {p}), (s, 2, x'', {})}
	 *
	 * If the configuration set has predicates (as indicated by
	 * {@link ATNConfigSet#hasSemanticContext}), this algorithm makes a copy of
	 * the configurations to strip out all of the predicates so that a standard
	 * {@link ATNConfigSet} will merge everything ignoring predicates.
	 */

/* Configs in rule stop states indicate reaching the end of the decision
		 * rule (local context) or end of start rule (full context). If all
		 * configs meet this condition, then none of the configurations is able
		 * to match additional input so we terminate prediction.
		 */

How to use hasConflictingAltSetmethodin org.antlr.v4.runtime.atn.PredictionMode

Best Java code snippets using org.antlr.v4.runtime.atn.PredictionMode.hasConflictingAltSet (Showing top 5 results out of 315)

How to use
hasConflictingAltSet
method
in
org.antlr.v4.runtime.atn.PredictionMode