Parser::exponent() - Code Metrics - Inspection of "fix exponent operator && repl script added" - drumser/arithmetic-parser - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( 8427a2...6e446b )

by Alexander

created 2019-08-31 18:34 UTC

Parser::exponent() A

↳ Parent: Parser

Complexity

Conditions	2
Paths	2

Size

Total Lines	11
Code Lines	6

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	2
eloc	6
nc	2
nop	0
dl	0
loc	11
rs	10
c	0
b	0
f	0

<?php


namespace App;


use App\Exception\ParseError;
use App\Node\BinaryOperator;
use App\Node\FunctionCall;
use App\Node\Integer;
use App\Node\Real;
use App\Node\UnaryOperator;
use App\Node\Visitable;

class Parser
{
    /**
     * @var Lexer
     */
    private $lexer;

    /**
     * @var Token
     */
    private $currentToken;

    /**
     * Parser constructor.
     * @param Lexer $lexer
     * @throws Exception\LexerException
     * @throws Exception\UnknownIdentifier
     */
    public function __construct(
        Lexer $lexer
    )
    {
        $this->lexer        = $lexer;
        $this->currentToken = $this->lexer->getNextToken();
    }

    /**
     * @param string $tokenType
     * @throws Exception\LexerException
     * @throws ParseError
     * @throws Exception\UnknownIdentifier
     */
    private function eat(string $tokenType): void
    {
        if ($this->currentToken->type === $tokenType) {
            $this->currentToken = $this->lexer->getNextToken();
        } else {
            throw new ParseError('Wrong token type');
        }
    }

    /**
     * @return FunctionCall
     * @throws Exception\LexerException
     * @throws Exception\UnknownIdentifier
     * @throws ParseError
     */
    private function parseFunction(): FunctionCall
    {
        $token = $this->currentToken;
        $this->eat(Token::FUNCTION_CALL);
        $this->eat(Token::LPAREN);
        $args = [];

        while (true) {
            $args[] = $this->expr();
            if ($this->currentToken->type === Token::COMMA) {
                $this->eat(Token::COMMA);
            } else {
                break;
            }
        }

        $this->eat(Token::RPAREN);

        return new FunctionCall($token, $args);
    }

    /**
     * @return Visitable
     * @throws Exception\LexerException
     * @throws ParseError
     * @throws Exception\UnknownIdentifier
     */
    private function factor(): Visitable
    {
        $token = $this->currentToken;

        if ($token->type === Token::PLUS) {
            $this->eat(Token::PLUS);
            return new UnaryOperator($token, $this->factor());
        }
        if ($token->type === Token::MINUS) {
            $this->eat(Token::MINUS);
            return new UnaryOperator($token, $this->factor());
        }

        if ($token->type === Token::INT) {
            $this->eat(Token::INT);
            return new Integer((int)$token->value);
        }

        if ($token->type === Token::REAL) {
            $this->eat(Token::REAL);
            return new Real((float)$token->value);
        }

        if ($token->type === Token::FUNCTION_CALL) {
            return $this->parseFunction();
        }

        if ($token->type === Token::LPAREN) {
            $this->eat(Token::LPAREN);
            $node = $this->expr();
            $this->eat(Token::RPAREN);
            return $node;
        }

        throw new ParseError('Unknown factor type');
    }

    /**
     * @throws Exception\LexerException
     * @throws Exception\UnknownIdentifier
     * @throws ParseError
     */
    private function exponent(): Visitable
    {
        $node = $this->factor();

        while ($this->currentToken->type === Token::POWER) {
            $operator = $this->currentToken;
            $this->eat(Token::POWER);
            $node = new BinaryOperator($node, $operator, $this->exponent());
        }

        return $node;
    }

    /**
     * @return Visitable
     * @throws Exception\LexerException
     * @throws ParseError
     * @throws Exception\UnknownIdentifier
     */
    private function term(): Visitable
    {
        $node = $this->exponent();

        while (in_array($this->currentToken->type, [Token::MUL, Token::REALDIV, Token::POWER], true)) {
            /** @var Token $operator */
            $operator = $this->currentToken;
            /** @psalm-suppress PossiblyNullArgument */
            $this->eat($this->currentToken->type);
            $node = new BinaryOperator($node, $operator, $this->exponent());
        }

        return $node;
    }

    /**
     * @return Visitable
     * @throws Exception\LexerException
     * @throws ParseError
     * @throws Exception\UnknownIdentifier
     */
    private function expr(): Visitable
    {
        $node = $this->term();

        while (in_array($this->currentToken->type, [Token::PLUS, Token::MINUS], true)) {
            /** @var Token $operator */
            $operator = $this->currentToken;
            /** @psalm-suppress PossiblyNullArgument */
            $this->eat($this->currentToken->type);
            $node = new BinaryOperator($node, $operator, $this->term());
        }

        return $node;
    }

    /**
     * @return Visitable
     * @throws Exception\LexerException
     * @throws ParseError
     * @throws Exception\UnknownIdentifier
     */
    public function parse(): Visitable
    {
        return $this->expr();
    }
}

1			<?php
2
3
4			namespace App;
5
6
7			use App\Exception\ParseError;
8			use App\Node\BinaryOperator;
9			use App\Node\FunctionCall;
10			use App\Node\Integer;
11			use App\Node\Real;
12			use App\Node\UnaryOperator;
13			use App\Node\Visitable;
14
15			class Parser
16			{
17			/**
18			* @var Lexer
19			*/
20			private $lexer;
21
22			/**
23			* @var Token
24			*/
25			private $currentToken;
26
27			/**
28			* Parser constructor.
29			* @param Lexer $lexer
30			* @throws Exception\LexerException
31			* @throws Exception\UnknownIdentifier
32			*/
33			public function __construct(
34			Lexer $lexer
35			)
36			{
37			$this->lexer = $lexer;
38			$this->currentToken = $this->lexer->getNextToken();
39			}
40
41			/**
42			* @param string $tokenType
43			* @throws Exception\LexerException
44			* @throws ParseError
45			* @throws Exception\UnknownIdentifier
46			*/
47			private function eat(string $tokenType): void
48			{
49			if ($this->currentToken->type === $tokenType) {
50			$this->currentToken = $this->lexer->getNextToken();
51			} else {
52			throw new ParseError('Wrong token type');
53			}
54			}
55
56			/**
57			* @return FunctionCall
58			* @throws Exception\LexerException
59			* @throws Exception\UnknownIdentifier
60			* @throws ParseError
61			*/
62			private function parseFunction(): FunctionCall
63			{
64			$token = $this->currentToken;
65			$this->eat(Token::FUNCTION_CALL);
66			$this->eat(Token::LPAREN);
67			$args = [];
68
69			while (true) {
70			$args[] = $this->expr();
71			if ($this->currentToken->type === Token::COMMA) {
72			$this->eat(Token::COMMA);
73			} else {
74			break;
75			}
76			}
77
78			$this->eat(Token::RPAREN);
79
80			return new FunctionCall($token, $args);
81			}
82
83			/**
84			* @return Visitable
85			* @throws Exception\LexerException
86			* @throws ParseError
87			* @throws Exception\UnknownIdentifier
88			*/
89			private function factor(): Visitable
90			{
91			$token = $this->currentToken;
92
93			if ($token->type === Token::PLUS) {
94			$this->eat(Token::PLUS);
95			return new UnaryOperator($token, $this->factor());
96			}
97			if ($token->type === Token::MINUS) {
98			$this->eat(Token::MINUS);
99			return new UnaryOperator($token, $this->factor());
100			}
101
102			if ($token->type === Token::INT) {
103			$this->eat(Token::INT);
104			return new Integer((int)$token->value);
105			}
106
107			if ($token->type === Token::REAL) {
108			$this->eat(Token::REAL);
109			return new Real((float)$token->value);
110			}
111
112			if ($token->type === Token::FUNCTION_CALL) {
113			return $this->parseFunction();
114			}
115
116			if ($token->type === Token::LPAREN) {
117			$this->eat(Token::LPAREN);
118			$node = $this->expr();
119			$this->eat(Token::RPAREN);
120			return $node;
121			}
122
123			throw new ParseError('Unknown factor type');
124			}
125
126			/**
127			* @throws Exception\LexerException
128			* @throws Exception\UnknownIdentifier
129			* @throws ParseError
130			*/
131			private function exponent(): Visitable
132			{
133			$node = $this->factor();
134
135			while ($this->currentToken->type === Token::POWER) {
136			$operator = $this->currentToken;
137			$this->eat(Token::POWER);
138			$node = new BinaryOperator($node, $operator, $this->exponent());
139			}
140
141			return $node;
142			}
143
144			/**
145			* @return Visitable
146			* @throws Exception\LexerException
147			* @throws ParseError
148			* @throws Exception\UnknownIdentifier
149			*/
150			private function term(): Visitable
151			{
152			$node = $this->exponent();
153
154			while (in_array($this->currentToken->type, [Token::MUL, Token::REALDIV, Token::POWER], true)) {
155			/** @var Token $operator */
156			$operator = $this->currentToken;
157			/** @psalm-suppress PossiblyNullArgument */
158			$this->eat($this->currentToken->type);
159			$node = new BinaryOperator($node, $operator, $this->exponent());
160			}
161
162			return $node;
163			}
164
165			/**
166			* @return Visitable
167			* @throws Exception\LexerException
168			* @throws ParseError
169			* @throws Exception\UnknownIdentifier
170			*/
171			private function expr(): Visitable
172			{
173			$node = $this->term();
174
175			while (in_array($this->currentToken->type, [Token::PLUS, Token::MINUS], true)) {
176			/** @var Token $operator */
177			$operator = $this->currentToken;
178			/** @psalm-suppress PossiblyNullArgument */
179			$this->eat($this->currentToken->type);
180			$node = new BinaryOperator($node, $operator, $this->term());
181			}
182
183			return $node;
184			}
185
186			/**
187			* @return Visitable
188			* @throws Exception\LexerException
189			* @throws ParseError
190			* @throws Exception\UnknownIdentifier
191			*/
192			public function parse(): Visitable
193			{
194			return $this->expr();
195			}
196			}

drumser / arithmetic-parser

Push — master ( 8427a2...6e446b )

Parser::exponent() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like