Antlr\Antlr4\Runtime\Atn\ParserATNSimulator::computeReachSet()

Complexity

Conditions	28
Paths	4168

Size

Total Lines	149
Code Lines	48

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	33
CRAP Score	55.2876

Importance

Changes	1
Bugs	0	Features	0

<?php
    protected function computeReachSet(ATNConfigSet $closure, int $t, bool $fullCtx) : ?ATNConfigSet
    {
        if (self::$debug) {
            $this->log[] = \sprintf('In computeReachSet, starting closure: %s', (string) $closure);
        }

        if ($this->mergeCache === null) {
            $this->mergeCache = new DoubleKeyMap();
        }

        $intermediate = new ATNConfigSet($fullCtx);

        /*
         * Configurations already in a rule stop state indicate reaching the end
         * of the decision rule (local context) or end of the start rule (full
         * context). Once reached, these configurations are never updated by a
         * closure operation, so they are handled separately for the performance
         * advantage of having a smaller intermediate set when calling closure.
         *
         * For full-context reach operations, separate handling is required to
         * ensure that the alternative matching the longest overall sequence is
         * chosen when multiple such configurations can match the input.
         */
        $skippedStopStates = null;

        // First figure out where we can reach on input t
        foreach ($closure->elements() as $c) {
            if (self::$debug_add) {
                $this->log[] = \sprintf('Testing %s at %s', $this->getTokenName($t), (string) $c);
            }

            if ($c->state instanceof RuleStopState) {
                if ($c->context !== null && !$c->context->isEmpty()) {
                    throw new \RuntimeException('Context cannot be empty.');
                }

                if ($fullCtx || $t === IntStream::EOF) {
                    if ($skippedStopStates === null) {
                        $skippedStopStates = [];
                    }

                    $skippedStopStates[] = $c;

                    if (self::$debug_add) {
                        $this->log[] = \sprintf('Added %s to skippedStopStates', (string) $c);
                    }
                }

                continue;
            }

            foreach ($c->state->getTransitions() as $trans) {
                $target = $this->getReachableTarget($trans, $t);

                if ($target !== null) {
                    $cfg = new ATNConfig($c, $target);
                    $intermediate->add($cfg, $this->mergeCache);

                    if (self::$debug_add) {
                        $this->log[] = \sprintf('Added %s to intermediate', (string) $cfg);
                    }
                }
            }
        }

        // Now figure out where the reach operation can take us...

        $reach = null;

        /* This block optimizes the reach operation for intermediate sets which
         * trivially indicate a termination state for the overall
         * adaptivePredict operation.
         *
         * The conditions assume that intermediate contains all configurations
         * relevant to the reach set, but this condition is not true when one
         * or more configurations have been withheld in skippedStopStates, or
         * when the current symbol is EOF.
         */
        if ($skippedStopStates === null && $t !== Token::EOF) {
            if (\count($intermediate->elements()) === 1) {
                // Don't pursue the closure if there is just one state.
                // It can only have one alternative; just add to result
                // Also don't pursue the closure if there is unique alternative
                // among the configurations.

                $reach = $intermediate;
            } elseif (self::getUniqueAlt($intermediate) !== ATN::INVALID_ALT_NUMBER) {
                // Also don't pursue the closure if there is unique alternative among the configurations.
                $reach = $intermediate;
            }
        }

        // If the reach set could not be trivially determined, perform a closure
        // operation on the intermediate set to compute its initial value.
        if ($reach === null) {
            $reach = new ATNConfigSet($fullCtx);
            $closureBusy = new Set();
            $treatEofAsEpsilon = $t === Token::EOF;

            foreach ($intermediate->elements() as $item) {
                $this->closure($item, $reach, $closureBusy, false, $fullCtx, $treatEofAsEpsilon);
            }
        }

        if ($t === IntStream::EOF) {
            /* After consuming EOF no additional input is possible, so we are
             * only interested in configurations which reached the end of the
             * decision rule (local context) or end of the start rule (full
             * context). Update reach to contain only these configurations. This
             * handles both explicit EOF transitions in the grammar and implicit
             * EOF transitions following the end of the decision or start rule.
             *
             * When reach==intermediate, no closure operation was performed. In
             * this case, removeAllConfigsNotInRuleStopState needs to check for
             * reachable rule stop states as well as configurations already in
             * a rule stop state.
             *
             * This is handled before the configurations in skippedStopStates,
             * because any configurations potentially added from that list are
             * already guaranteed to meet this condition whether or not it's
             * required.
             */

            $reach = $this->removeAllConfigsNotInRuleStopState($reach, $reach->equals($intermediate));
        }

        /* If `skippedStopStates !== null`, then it contains at least one
         * configuration. For full-context reach operations, these
         * configurations reached the end of the start rule, in which case we
         * only add them back to reach if no configuration during the current
         * closure operation reached such a state. This ensures adaptivePredict
         * chooses an alternative matching the longest overall sequence when
         * multiple alternatives are viable.*/

        if ($skippedStopStates !== null && (!$fullCtx || !PredictionMode::hasConfigInRuleStopState($reach))) {

The condition $skippedStopStates !== null is always false.

            if (\count($skippedStopStates) === 0) {
                throw new \RuntimeException('Skipped stop states cannot be empty.');
            }

            foreach ($skippedStopStates as $lValue) {
                $reach->add($lValue, $this->mergeCache);
            }
        }

        if ($reach->isEmpty()) {
            return null;
        }

        return $reach;
    }