Skeletik

Tiny lexical analyzer

npm i --save-dev skeletik

API

const parse = skeletik({
	// Ranges
	//  key — name of range
	//  value — array of symbols and intervals (ex 0-9 or a-b)
	'$number': ['0-9'],
	'$binary': ['+', '-', '/', '*'],
}, {
	// States
	'': { // <- initial and also default state
		// State Rules
		//  key — one symbol or region name
		//  value — handler or next name of a state
		'$number': 'NUMBER',

		// any
		'': (lex, bone) => lex.error(`Invalid character \`${lex.getChar()}\`, state: ${lex.state}`, bone);
	},

	'NUMBER': {
		// ...
	}
});

Example

// Tokens
const T_GROUP = 'group';
const T_NUMBER = 'number';
const T_BINARY = 'binary';

// Priority of operations
const PRIORITY = {
	'/': 1,
	'*': 1,
};

// Бинарные опреации
const BINARY = {
	'/': function (a, b) { return a / b },
	'*': function (a, b) { return a * b },
	'+': function (a, b) { return a + b },
	'-': function (a, b) { return a - b },
};

// Create parser
const ast = {};
const parse = skeletik({
	'number': ['0-9'],
	'binary': ['+', '-', '/', '*'],
}, {
	// Inited state
	'': {
		'number'(lex, bone) {
			const chr = lex.getChar();
			const last = bone.last;

			if (last && (last.type === T_NUMBER || !last.prev || last.prev.type === T_BINARY)) {
				last.type = T_NUMBER;
				last.raw += chr;
			} else {
				bone.add(T_NUMBER, chr);
			}
		},

		'binary'(lex, bone) {
			bone.add(T_BINARY, lex.getChar());
		},

		'(': (lex, bone) => bone.add(T_GROUP).last,
		')': (lex, bone) => bone.parent,
	},
});

function calculator(expr) {
	const root = parse(expr);

	return (function _calc(root) {
		const stack = [];
		const ops = [];

		for (let i = 0; i < root.length; i++) {
			const bone = root.nodes[i];

			if (bone.type === T_BINARY) {
				if (PRIORITY[bone.raw]) {
					stack[stack.length - 1] = BINARY[bone.raw](stack[stack.length - 1], +bone.next.raw);
					i++;
				} else {
					ops.push(bone.raw);
				}
			} else {
				stack.push(bone.type === T_GROUP ? _calc(bone) : +bone.raw);
			}
		}

		let results = stack.pop();

		while (ops.length) {
			results = BINARY[ops.pop()](results, stack.pop());
		}

		return results;
	})(root);
};

const str = '(1 + 2) * 4 / -3 + 1';
console.log('results:', calculator(str), eval(str) === calculator(str));