Railt\SDL\Frontend\Parser

Complexity

Total Complexity

10

Size/Duplication

Total Lines	86
Duplicated Lines	0 %

Importance

Changes

0

5 Methods

Rating	Name	Duplication	Size	Complexity
A	next()	0	11	2
A	build()	0	17	4
A	parse()	0	10	2
A	bootLexer()	0	3	1
A	__construct()	0	9	1

<?php

/**
 * This file is part of Railt package.
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

declare(strict_types=1);

namespace Railt\SDL\Frontend;

use Phplrt\Contracts\Grammar\RuleInterface;
use Phplrt\Contracts\Lexer\BufferInterface;
use Phplrt\Contracts\Lexer\Exception\LexerRuntimeExceptionInterface;
use Phplrt\Contracts\Lexer\LexerInterface;
use Phplrt\Contracts\Lexer\TokenInterface;
use Phplrt\Contracts\Source\ReadableInterface;
use Phplrt\Lexer\Lexer;
use Phplrt\Parser\Builder\BuilderInterface;
use Phplrt\Parser\Exception\ParserRuntimeException;
use Phplrt\Parser\Parser as BaseParser;
use Phplrt\Source\File;
use Railt\SDL\Exception\SyntaxErrorException;
use Railt\SDL\Frontend\Ast\Location;
use Railt\SDL\Frontend\Ast\Node;

/**
 * Class Parser
 */
final class Parser extends BaseParser implements BuilderInterface
{
    /**
     * @var array|\Closure[]
     */
    private array $reducers;

    /**
     * Parser constructor.
     */
    public function __construct()
    {
        $grammar = require __DIR__ . '/grammar.php';

        $this->reducers = $grammar['reducers'];

        parent::__construct($this->bootLexer($grammar), $grammar['grammar'], [
            parent::CONFIG_AST_BUILDER  => $this,
            parent::CONFIG_INITIAL_RULE => $grammar['initial'],
        ]);
    }

    /**
     * @param array $grammar
     * @return LexerInterface
     */
    private function bootLexer(array $grammar): LexerInterface
    {
        return new Lexer($grammar['lexemes'], $grammar['skips']);
    }

    /**
     * {@inheritDoc}
     * @throws SyntaxErrorException
     * @throws \Throwable
     */
    public function build(
        ReadableInterface $file,
        RuleInterface $rule,
        TokenInterface $token,
        $state,
        $children
    ) {
        try {
            if (isset($this->reducers[$state])) {
                return $this->reducers[$state]($children);
            }

            return null;
        } catch (SyntaxErrorException $e) {
            throw $e;
        } catch (\Exception $e) {
            throw SyntaxErrorException::fromToken($e->getMessage(), $file, $token);
        }
    }

    /**
     * {@inheritDoc}
     */
    public function parse($source): iterable
    {
        $source = File::new($source);

        try {
            return parent::parse($source);
        } catch (ParserRuntimeException|LexerRuntimeExceptionInterface $e) {
            $token = $e->getToken();

            throw SyntaxErrorException::fromToken($e->getMessage(), $source, $token);
        }
    }

    /**
     * {@inheritDoc}
     */
    protected function next(ReadableInterface $source, BufferInterface $buffer, $state)
    {
        $from = $buffer->current()->getOffset();

        $result = parent::next($source, $buffer, $state);

        if ($result instanceof Node) {
            $result->loc = new Location($source, $from, $buffer->current()->getOffset());
        }

        return $result;
    }
}