Nearley

home code menu_book edit

Nearley is an open source grammar language created in 2014.

Source code:

git clone https://github.com/Hardmath123/nearley

#161on PLDB

10Years Old

53Repos

📜🔜🌲 Simple, fast, powerful parser toolkit for JavaScript.

Nearley website
Nearley is developed on GitHub and has 3,231 stars
Nearley docs
There are at least 53 Nearley repos on GitHub
Nearley first developed in https://github.com/kach/nearley/issues
file extensions for Nearley include ne and nearley
Nearley is written in JavaScript
The Google BigQuery Public Dataset GitHub snapshot shows 32 users using Nearley in 33 repos on GitHub
GitHub supports syntax highlighting for Nearley

Example from Linguist:

# nearley grammar
@builtin "string.ne"

@{%

function insensitive(sl) {
    var s = sl.literal;
    result = [];
    for (var i=0; i<s.length; i++) {
        var c = s.charAt(i);
        if (c.toUpperCase() !== c || c.toLowerCase() !== c) {
            result.push(new RegExp("[" + c.toLowerCase() + c.toUpperCase() + "]"));
        } else {
            result.push({literal: c});
        }
    }
    return {subexpression: [{tokens: result, postprocess: function(d) {return d.join(""); }}]};
}

%}

final -> whit? prog whit?  {% function(d) { return d[1]; } %}

prog -> prod  {% function(d) { return [d[0]]; } %}
      | prod whit prog  {% function(d) { return [d[0]].concat(d[2]); } %}

prod -> word whit? ("-"|"="):+ ">" whit? expression+  {% function(d) { return {name: d[0], rules: d[5]}; } %}
      | word "[" wordlist "]" whit? ("-"|"="):+ ">" whit? expression+ {% function(d) {return {macro: d[0], args: d[2], exprs: d[8]}} %}
      | "@" whit? js  {% function(d) { return {body: d[2]}; } %}
      | "@" word whit word  {% function(d) { return {config: d[1], value: d[3]}; } %}
      | "@include"  whit? string {% function(d) {return {include: d[2].literal, builtin: false}} %}
      | "@builtin"  whit? string {% function(d) {return {include: d[2].literal, builtin: true }} %}

expression+ -> completeexpression
             | expression+ whit? "|" whit? completeexpression  {% function(d) { return d[0].concat([d[4]]); } %}

expressionlist -> completeexpression
             | expressionlist whit? "," whit? completeexpression {% function(d) { return d[0].concat([d[4]]); } %}

wordlist -> word
            | wordlist whit? "," whit? word {% function(d) { return d[0].concat([d[4]]); } %}

completeexpression -> expr  {% function(d) { return {tokens: d[0]}; } %}
                    | expr whit? js  {% function(d) { return {tokens: d[0], postprocess: d[2]}; } %}

expr_member ->
      word {% id %}
    | "$" word {% function(d) {return {mixin: d[1]}} %}
    | word "[" expressionlist "]" {% function(d) {return {macrocall: d[0], args: d[2]}} %} 
    | string "i":? {% function(d) { if (d[1]) {return insensitive(d[0]); } else {return d[0]; } } %}
    | "%" word {% function(d) {return {token: d[1]}} %}
    | charclass {% id %}
    | "(" whit? expression+ whit? ")" {% function(d) {return {'subexpression': d[2]} ;} %}
    | expr_member whit? ebnf_modifier {% function(d) {return {'ebnf': d[0], 'modifier': d[2]}; } %}

ebnf_modifier -> ":+" {% id %} | ":*" {% id %} | ":?" {% id %}

expr -> expr_member
      | expr whit expr_member  {% function(d){ return d[0].concat([d[2]]); } %}

word -> [\w\?\+]  {% function(d){ return d[0]; } %}
      | word [\w\?\+]  {% function(d){ return d[0]+d[1]; } %}

string -> dqstring {% function(d) {return { literal: d[0] }; } %}
#string -> "\"" charset "\""  {% function(d) { return { literal: d[1].join("") }; } %}
#
#charset -> null
#         | charset char  {% function(d) { return d[0].concat([d[1]]); } %}
#
#char -> [^\\"]  {% function(d) { return d[0]; } %}
#      | "\\" .  {% function(d) { return JSON.parse("\""+"\\"+d[1]+"\""); } %}

charclass -> "."  {% function(d) { return new RegExp("."); } %}
           | "[" charclassmembers "]"  {% function(d) { return new RegExp("[" + d[1].join('') + "]"); } %}

charclassmembers -> null
                  | charclassmembers charclassmember  {% function(d) { return d[0].concat([d[1]]); } %}

charclassmember -> [^\\\]]  {% function(d) { return d[0]; } %}
                 | "\\" .  {% function(d) { return d[0] + d[1]; } %}

js -> "{" "%" jscode "%" "}"  {% function(d) { return d[2]; } %}

jscode -> null  {% function() {return "";} %}
        | jscode [^%]  {% function(d) {return d[0] + d[1];} %}
        | jscode "%" [^}] {% function(d) {return d[0] + d[1] + d[2]; } %}

# Whitespace with a comment
whit -> whitraw
      | whitraw? comment whit?

# Optional whitespace with a comment
whit? -> null
       | whit

# Literally a string of whitespace
whitraw -> [\s]
         | whitraw [\s]

# A string of whitespace OR the empty string
whitraw? -> null
          | whitraw

comment -> "#" commentchars "\n"
commentchars -> null
              | commentchars [^\n]

Feature	Supported	Token	Example
Booleans	✓	true false
Comments	✓		# A comment
Line Comments	✓	#	# A comment
Semantic Indentation	X

Nearley - Grammar language

Language features