Railt\SDL\Frontend\Builder\Value\NumberValueBuilder

Complexity

Total Complexity

20

Size/Duplication

Total Lines	142
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	5

Importance

Changes

0

13 Methods

Rating	Name	Duplication	Size	Complexity
A	match()	0	4	1
A	reduce()	0	6	2
B	parse()	0	24	6
A	isHex()	0	4	1
A	parseHex()	0	4	1
A	isBinary()	0	4	1
A	parseBin()	0	4	1
A	isExponential()	0	4	1
A	parseExponential()	0	4	1
A	isFloat()	0	4	1
A	parseFloat()	0	4	1
A	isInt()	0	4	2
A	parseInt()	0	4	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\Builder\Value;

use Railt\Parser\Ast\LeafInterface;
use Railt\Parser\Ast\RuleInterface;
use Railt\SDL\Frontend\Builder\BaseBuilder;
use Railt\SDL\Frontend\Context\ContextInterface;
use Railt\SDL\Frontend\Parser;
use Railt\SDL\IR\SymbolTable\Value;
use Railt\SDL\IR\SymbolTable\ValueInterface;
use Railt\SDL\IR\Type;

/**
 * Class NumberValueBuilder
 */
class NumberValueBuilder extends BaseBuilder
{
    /**
     * @param RuleInterface $rule
     * @return bool
     */
    public function match(RuleInterface $rule): bool
    {
        return $rule->getName() === 'NumberValue';
    }

    /**
     * @param ContextInterface $ctx
     * @param RuleInterface $rule
     * @return ValueInterface
     */
    public function reduce(ContextInterface $ctx, RuleInterface $rule): ValueInterface
    {
        $value = $this->parse($rule);

        return new Value($value, \is_int($value) ? Type::int() : Type::float());

It seems like \is_int($value) ? \Railt\SDL\IR\Type::int() : \Railt\SDL\IR\Type::float() can also be of type object<Railt\SDL\IR\Type\TypeConstructors\RuntimeTypeConstructors>; however, Railt\SDL\IR\SymbolTable\Value::__construct() does only seem to accept object<Railt\SDL\IR\Type\TypeInterface>, maybe add an additional type check?

    }

    /**
     * @param RuleInterface $rule
     * @return float|int
     */
    private function parse(RuleInterface $rule)
    {
        /** @var LeafInterface $value */
        $value = $rule->getChild(0);

        switch (true) {
            case $this->isHex($value):
                return $this->parseHex($value->getValue(1));

            case $this->isBinary($value):
                return $this->parseBin($value->getValue(1));

            case $this->isExponential($value):
                return $this->parseExponential($value->getValue());

            case $this->isFloat($value):
                return $this->parseFloat($value->getValue());

            case $this->isInt($value):
                return $this->parseInt($value->getValue());
        }

        return (float)$value->getValue();
    }

    /**
     * @param LeafInterface $leaf
     * @return bool
     */
    private function isHex(LeafInterface $leaf): bool
    {
        return $leaf->getName() === Parser::T_HEX_NUMBER;
    }

    /**
     * @param string $value
     * @return int
     */
    private function parseHex(string $value): int
    {
        return \hexdec($value);
    }

    /**
     * @param LeafInterface $leaf
     * @return bool
     */
    private function isBinary(LeafInterface $leaf): bool
    {
        return $leaf->getName() === Parser::T_BIN_NUMBER;
    }

    /**
     * @param string $value
     * @return int
     */
    private function parseBin(string $value): int
    {
        return \bindec($value);
    }

    /**
     * @param LeafInterface $leaf
     * @return bool
     */
    private function isExponential(LeafInterface $leaf): bool
    {
        return \substr_count(\mb_strtolower($leaf->getValue()), 'e') !== 0;
    }

    /**
     * @param string $value
     * @return float
     */
    private function parseExponential(string $value): float
    {
        return (float)$value;
    }

    /**
     * @param LeafInterface $leaf
     * @return bool
     */
    private function isFloat(LeafInterface $leaf): bool
    {
        return \substr_count($leaf->getValue(), '.') !== 0;
    }

    /**
     * @param string $value
     * @return float
     */
    private function parseFloat(string $value): float
    {
        return (float)$value;
    }

    /**
     * @param LeafInterface $leaf
     * @return bool
     */
    private function isInt(LeafInterface $leaf): bool
    {
        return $leaf->getName() === Parser::T_NUMBER && \substr_count($leaf->getValue(), '.') === 0;
    }

    /**
     * @param string $value
     * @return int
     */
    private function parseInt(string $value): int
    {
        return $value >> 0;
    }
}