Awesome

mr-parser

Parses mathematical expressions and outputs an AST

Description
- why?
- Grammar
Install
Usage
API
- Parser = require('mr-parser').Parser
  - Parser.parse(expression)

Description

mr-parser is a lightweight mathematical parser inspired by math.js expression parser, unlike math.js expression parser the AST nodes contain no info on how to compile a node which makes the parser modular

why?

I felt that I had to make another parser because:

math-parser is too simple for me, it just operates on numbers and has the following operators +, -, *, / and ^ and doesn't have variable substitution
math.js expression parser is perfect but it's not modularized yet, to use it one would have to include all the source code of math.js
math.js expression parser AST nodes have info about how to compile a node, I think it's better to let another module do that

Grammar

program          : block (; block)*

block            : assignment

assignment       : ternary
                 | symbol `=` assignment

ternary          : logicalOR
                 | logicalOR `?` ternary `:` ternary

logicalOR        : logicalXOR
                 | logicalXOR (`||`,`or`) logicalOR

logicalXOR       : logicalAND
                 : logicalAND `xor` logicalXOR

logicalAND       : bitwiseOR
                 | bitwiseOR (`&&`,`and`) logicalAND

bitwiseOR        : bitwiseXOR
                 | bitwiseXOR `|` bitwiseOR

bitwiseXOR       : bitwiseAND
                 | bitwiseAND `^|` bitwiseXOR

bitwiseAND       : relational
                 | relational `&` bitwiseAND

relational       : shift
                 | shift (`!=` | `==` | `>` | '<' | '<=' |'>=') shift)

shift            : additive
                 | additive (`>>` | `<<` | `>>>`) shift

additive         : multiplicative
                 | multiplicative (`+` | `-`) additive

multiplicative   : unary
                 | unary (`*` | `/` | `%`) multiplicative
                 | unary symbol

unary            : pow
                 | (`-` | `+` | `~`) unary

pow              : factorial
                 | factorial (`^`, '**') unary

factorial        : symbol
                 | symbol (`!`)

symbol           : symbolToken
                 | symbolToken functionCall
                 | string

functionCall     : `(` `)`
                 | `(` ternary (, ternary)* `)`

string           : `'` (character)* `'`
                 : `"` (character)* `"`
                 | array

array            : `[` `]`
                 | `[` assignment (, assignment)* `]`
                 | number

number           : number-token
                 | parentheses

parentheses      : `(` assignment `)`
                 : end

end              : null-token

Install

$ npm install --save mr-parser

Usage

var Parser = require('mr-parser').Parser;
Parser.parse('1 * (2 + 3) * 4')

// returns
{
  blocks:[{
    op: '*',
    args: [{
      value: '1',
      valueType: 'number'
    }, {
      op: '*',
      args: [{
        op: '+',
        args: [
          { value: '2', valueType: 'number' },
          { value: '3', valueType: 'number' }
        ]
      }, {
        value: '4',
        valueType: 'number'
      }]
    }]
  }]
} 

Parser.parse('2x')

// returns
{
  blocks: [{
    op: '*',
    args: [
      { value: '2', valueType: 'number' },
      { name: 'x' }
    ]
  }]
}

API

`Parser = require('mr-parser').Parser`

`Parser.parse(expression)`

params

expression {string} the expression to be parsed

returns

Returns an array of possibly nested nodes which is the AST that represents the expression