@@ -4,9 +4,10 @@ In order to build a proper parser, grammar of the expressions is needed to be de
 Working with tokens instead of raw string is a good practice when implementing a parser.
 
 1. Grammar
-Expression := {Operator} Number {Operator Number}
-Operator := "+" | "-"
-Number := Digit{Digit}
+Expression := [ "-" ] Term { ("+" | "-") Term }
+Term := Factor { ( "*" | "/" ) Factor }
+Factor := RealNumber [ "^" "(" Factor ")" ] | "(" Expression ")"
+RealNumber := Digit{Digit} [ "." Digit{Digit} ]
 Digit := "0" | "1" | "2" | "3" | "4" | "5" | "6" | "7" | "8" | "9"
 
 [] - optional

@@ -2,76 +2,137 @@ const Tokenizer = require('./Tokenizer').Tokenizer;
 const OperatorToken = require('./tokens/OperatorToken').OperatorToken;
 const PlusToken = require('./tokens/PlusToken').PlusToken;
 const MinusToken = require('./tokens/MinusToken').MinusToken;
+const MultiplicationToken = require('./tokens/MultiplicationToken').MultiplicationToken;
+const DivisionToken = require('./tokens/DivisionToken').DivisionToken;
+const OpeningBracketToken = require('./tokens/OpeningBracketToken').OpeningBracketToken;
+const ClosingBracketToken = require('./tokens/ClosingBracketToken').ClosingBracketToken;
 const NumberToken = require('./tokens/NumberToken').NumberToken;
+const DotToken = require('./tokens/DotToken').DotToken;
+const CaretToken = require('./tokens/CaretToken').CaretToken;
 
 module.exports.MathParser = class MathParser {
 constructor(expression) {
 this.tokenizer = new Tokenizer(expression);
 }
 
-parse() {
-let result = this.parseExpression();
-const nextToken = this.tokenizer.getNext();
+// Expression := [ "-" ] Term { ("+" | "-") Term }
+parseExpression() {
+const isNegative = this.nextIsMinus();
+if (isNegative) {
+this.tokenizer.getNext();
+}
+let valueOfExpression = this.parseTerm();
+if (isNegative) {
+valueOfExpression = -valueOfExpression;
+}
+while (this.nextIsMinusOrPlus()) {
+const operand = this.tokenizer.getNext();
+const nextTermValue = this.parseTerm();
+if (operand instanceof PlusToken) {
+valueOfExpression += nextTermValue;
+} else {
+valueOfExpression -= nextTermValue;
+}
+}
+return valueOfExpression;
+}
+
+// Term := Factor { ( "*" | "/" ) Factor }
+parseTerm() {
+let totalValue = this.parseFactor();
+while (this.nextIsMultiplicationOrDivision()) {
+const operand = this.tokenizer.getNext();
+const nextFactor = this.parseFactor();
+
+if (operand instanceof MultiplicationToken) {
+totalValue *= nextFactor;
+} else {
+totalValue /= nextFactor;
+}
+}
+return totalValue;
+}
 
-if (nextToken instanceof OperatorToken) {
-const operator = nextToken;
-const secondNumber = this.parse();
+// Factor := RealNumber [ "^" "(" Factor ")" ] | "(" Expression ")"
+parseFactor() {
+if (this.nextIsDigit()) {
+let number = this.parseNumber();
 
-if (operator instanceof PlusToken || operator instanceof MinusToken) {
-return result + secondNumber;
+if (this.nextIsCaret()) {
+number = this.parseExponent(number);
 }
 
-throw new Error(`Unknown operator: ${operator}`);
+return number;
 }
 
-return result;
-}
-
-parseExpression() {
-const firstToken = this.tokenizer.getCurrent();
-let firstNumber;
-
-if (firstToken instanceof MinusToken) {
-this.tokenizer.moveForward();
-firstNumber = this.parseNumber() * -1;
-} else if (firstToken instanceof PlusToken) {
-this.tokenizer.moveForward();
-firstNumber = this.parseNumber();
-} else {
-firstNumber = this.parseNumber();
+if (!this.nextIsOpeningBracket()) {
+throw new Error(`Expected number or '(', but got: ${this.tokenizer.getNext()}`);
 }
 
-const nextToken = this.tokenizer.getNext();
+this.tokenizer.getNext();
+let value = this.parseExpression();
 
-if (!nextToken) {
-return firstNumber;
+if (!this.nextIsClosingBracket()) {
+throw new Error(`Expected ')', but got: ${this.tokenizer.getNext()}`);
 }
+this.tokenizer.getNext();
+if (this.nextIsCaret()) {
+value = this.parseExponent(value);
+}
+return value;
+}
 
-if (nextToken instanceof OperatorToken) {
-const operator = nextToken;
-this.tokenizer.getNext();
+nextIsMinus() {
+return this.tokenizer.isNextOfType(MinusToken);
+}
 
-const secondNumber = this.parseNumber();
+nextIsMinusOrPlus() {
+return this.tokenizer.isNextOfType(MinusToken) || this.tokenizer.isNextOfType(PlusToken);
+}
+
+nextIsMultiplicationOrDivision() {
+return this.tokenizer.isNextOfType(MultiplicationToken) || this.tokenizer.isNextOfType(DivisionToken);
+}
 
-if (operator instanceof PlusToken) {
-return firstNumber + secondNumber;
-}
+nextIsDigit() {
+return this.tokenizer.isNextOfType(NumberToken);
+}
 
-if (operator instanceof MinusToken) {
-return firstNumber - secondNumber;
-}
+nextIsDot() {
+return this.tokenizer.isNextOfType(DotToken);
+}
 
-throw new Error(`Unknown operator: ${operator}`);
-}
+nextIsOpeningBracket() {
+return this.tokenizer.isNextOfType(OpeningBracketToken);
+}
+
+nextIsClosingBracket() {
+return this.tokenizer.isNextOfType(ClosingBracketToken);
+}
 
-throw new Error(`Expected operator after number but got: ${nextToken}`);
+nextIsCaret() {
+return this.tokenizer.isNextOfType(CaretToken);
 }
 
+// RealNumber := Digit{Digit} [ "." Digit{Digit} ]
 parseNumber() {
-const token = this.tokenizer.getCurrent();
-if (token instanceof NumberToken) {
-return token.value;
+const token = this.tokenizer.getNext();
+if (!(token instanceof NumberToken)) {
+throw new Error(`Expected a number but found: ${token}`);
 }
-throw new Error(`Expected a number but found: ${token}`);
+const digits = [];
+digits.push(token.value);
+while (this.nextIsDigit() || this.nextIsDot()) {
+const nextToken = this.tokenizer.getNext();
+digits.push(nextToken.value);
+}
+const number = digits.join("");
+return +number;
+}
+
+parseExponent(base) {
+this.tokenizer.getNext();
+const exponentValue = this.parseFactor();
+return Math.pow(base, exponentValue);
 }
 }

@@ -1,24 +1,38 @@
 const NumberToken = require('./tokens/NumberToken').NumberToken;
 const PlusToken = require('./tokens/PlusToken').PlusToken;
 const MinusToken = require('./tokens/MinusToken').MinusToken;
+const MultiplicationToken = require('./tokens/MultiplicationToken').MultiplicationToken;
+const DivisionToken = require('./tokens/DivisionToken').DivisionToken;
+const OpeningBracketToken = require('./tokens/OpeningBracketToken').OpeningBracketToken;
+const ClosingBracketToken = require('./tokens/ClosingBracketToken').ClosingBracketToken;
+const DotToken = require('./tokens/DotToken').DotToken;
+const CaretToken = require('./tokens/CaretToken').CaretToken;
 
 module.exports.Tokenizer = class Tokenizer {
 constructor(expression) {
 this.tokens = this.tokenize(expression);
-this.currIdx = 0;
+this.currentIndex = -1;
 }
 
-moveForward() {
-this.currIdx += 1;
+getCurrent() {
+return this.tokens[this.currentIndex];
+}
+
+areThereMoreTokens() {
+return this.currentIndex < this.tokens.length;
 }
 
 getNext() {
-this.currIdx += 1;
-return this.tokens[this.currIdx];
+this.currentIndex = this.currentIndex + 1;
+return this.tokens[this.currentIndex];
 }
 
-getCurrent() {
-return this.tokens[this.currIdx];
+peekNext() {
+return this.tokens[this.currentIndex + 1];
+}
+
+isNextOfType(type) {
+return this.peekNext() instanceof type;
 }
 
 tokenize(expression) {
@@ -40,6 +54,36 @@ module.exports.Tokenizer = class Tokenizer {
 tokens.push(minusToken);
 }
 
+else if (char === "*") {
+const multiplicationToken = new MultiplicationToken();
+tokens.push(multiplicationToken);
+}
+
+else if (char === "/") {
+const divisionToken = new DivisionToken();
+tokens.push(divisionToken);
+}
+
+else if (char === "(") {
+const openingBracketToken = new OpeningBracketToken();
+tokens.push(openingBracketToken);
+}
+
+else if (char === ")") {
+const closingBracketToken = new ClosingBracketToken();
+tokens.push(closingBracketToken);
+}
+
+else if (char === ".") {
+const dotToken = new DotToken(".");
+tokens.push(dotToken);
+}
+
+else if (char === "^") {
+const caretToken = new CaretToken();
+tokens.push(caretToken);
+}
+
 else {
 throw Error(`Unknown token: ${char}`);
 }