ebnf 1.2.0 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: aae4c0b2a8f6d03654bc5436b36c90e577669c41ea4df25d881be3aef86e5ace
-  data.tar.gz: 7f1b7fe448ae87f3755e6da4fc0faf47dbb3d3b573a3e4a8be9b3066f0fac6fa
+  metadata.gz: 06a44ff62e466914a2d6f1d80d4eacae30745c5c7823799af847db98cd27c813
+  data.tar.gz: fa433cd2719ec088cadfd987d69effa5490a3219166bd93406b1e73537956056
 SHA512:
-  metadata.gz: 6d0f441731842af8ac38f98352b96a47cf6810bfe81ce620f8ef57af87ce6d65c679d88903c35dbce99617b24bdea8fbb70a23d4873d941ae151275a11561627
-  data.tar.gz: f19f527e041a8f1c48da918497660466c5df71a02077e2183472b157a8611cbf87903fe2b6858e889c119211a7fedb279ad4889d811bec5d6132dd9287d74314
+  metadata.gz: 335fb057c452beb803c64fdfcbe87bc908e26323904a9641892987f819beb87edea7c3ca2f2bfa1aa911fcbf4b642c41b5cfdf5ba77568a8455283482fcaeb7e
+  data.tar.gz: f4dd5ab8c0b86c2cf2ca2b1edc4f5d93ce3c86a6b5bb527f43def66c33374090873be59ecadb60874bea62d5f80bfa76c230dc7468caf5e8af3557125d887b85

data/README.md

@@ -2,13 +2,15 @@
 
 [EBNF][] parser and generic parser generator.
 
-[![Gem Version](https://badge.fury.io/rb/ebnf.png)](http://badge.fury.io/rb/ebnf)
-[![Build Status](https://secure.travis-ci.org/dryruby/ebnf.png?branch=master)](http://travis-ci.org/dryruby/ebnf)
+[![Gem Version](https://badge.fury.io/rb/ebnf.png)](https://badge.fury.io/rb/ebnf)
+[![Build Status](https://secure.travis-ci.org/dryruby/ebnf.png?branch=master)](https://travis-ci.org/dryruby/ebnf)
 [![Coverage Status](https://coveralls.io/repos/dryruby/ebnf/badge.svg)](https://coveralls.io/r/dryruby/ebnf)
-[![Dependency Status](https://gemnasium.com/dryruby/ebnf.png)](https://gemnasium.com/dryruby/ebnf)
 
 ## Description
-This is a [Ruby][] implementation of an [EBNF][] and [BNF][] parser and parser generator. It parses [EBNF][] grammars to [BNF][], generates [First/Follow][] and Branch tables for [LL(1)][] grammars, which can be used with the stream [Tokenizer][] and [LL(1) Parser][].
+This is a [Ruby][] implementation of an [EBNF][] and [BNF][] parser and parser generator.
+
+### LL(1) Parser
+In one mode, it parses [EBNF][] grammars to [BNF][], generates [First/Follow][] and Branch tables for [LL(1)][] grammars, which can be used with the stream [Tokenizer][] and [LL(1) Parser][].
 
 As LL(1) grammars operate using `alt` and `seq` primitives, allowing for a match on alternative productions or a sequence of productions, generating a parser requires turning the EBNF rules into BNF:
 
@@ -23,8 +25,13 @@ As LL(1) grammars operate using `alt` and `seq` primitives, allowing for a match
 
 Of note in this implementation is that the tokenizer and parser are streaming, so that they can process inputs of arbitrary size.
 
+See {EBNF::LL1} and {EBNF::LL1::Parser} for further information.
+
+### [PEG][]/[Packrat][] Parser
+An additional Parsing Expression Grammar ([PEG][]) parser generator is also supported. This performs more minmal transformations on the parsed grammar to extract sub-productions, which allows each component of a rule to generate its own parsing event.
+
 ## Usage
-### Parsing an LL(1) Grammar
+### Parsing an EBNF Grammar
 
     require 'ebnf'
 
@@ -37,199 +44,165 @@ Output rules and terminals as S-Expressions, Turtle, HTML or BNF
     puts ebnf.to_html
     puts ebnf.to_s
 
-Transform EBNF to BNF (generates sub-productions using `alt` or `seq` from `plus`, `star` or `opt`)
+Transform EBNF to PEG (generates sub-rules for embedded expressions) and the RULES table as Ruby for parsing grammars:
+
+    ebnf.make_peg
+    ebnf.to_ruby
+
+Transform EBNF to BNF (generates sub-rules using `alt` or `seq` from `plus`, `star` or `opt`)
 
     ebnf.make_bnf
 
-Generate [First/Follow][] rules for BNF grammars
+Generate [First/Follow][] rules for BNF grammars (using "ebnf" as the starting production):
 
     ebnf.first_follow(:ebnf)
 
-Generate Terminal, [First/Follow][], Cleanup and Branch tables as Ruby for parsing grammars
+Generate Terminal, [First/Follow][], Cleanup and Branch tables as Ruby for parsing grammars:
 
     ebnf.build_tables
     ebnf.to_ruby
 
-Generate formatted grammar using HTML (requires [Haml][Haml] gem)
+Generate formatted grammar using HTML (requires [Haml][Haml] gem):
 
     ebnf.to_html
 
-### Parser S-Expressions
-Intermediate representations of the grammar may be serialized to Lisp-like S-Expressions. For example, the rule `[1] ebnf        ::= (declaration | rule)*` is serialized as `(rule ebnf "1" (star (alt declaration rule)))`.
-
-Once the [LL(1)][] conversion is made, the [First/Follow][] table is generated, this rule expands as follows:
-
-     (rule ebnf "1"
-      (start #t)
-      (first "@pass" "@terminals" LHS _eps)
-      (follow _eof)
-      (cleanup star)
-      (alt _empty _ebnf_2))
-     (rule _ebnf_1 "1.1"
-      (first "@pass" "@terminals" LHS)
-      (follow "@pass" "@terminals" LHS _eof)
-      (alt declaration rule))
-     (rule _ebnf_2 "1.2"
-      (first "@pass" "@terminals" LHS)
-      (follow _eof)
-      (cleanup merge)
-      (seq _ebnf_1 ebnf))
-     (rule _ebnf_3 "1.3" (first "@pass" "@terminals" LHS _eps) (follow _eof) (seq ebnf))
-
-### Creating terminal definitions and parser rules to parse generated grammars
-The parser is initialized to callbacks invoked on entry and exit
-to each `terminal` and `production`. A trivial parser loop can be described as follows:
-
-    require 'ebnf/ll1/parser'
-    require 'meta'
-
-    class Parser
-      include Meta
-
-      terminal(:SYMBOL, /([a-z]|[A-Z]|[0-9]|_)+/) do |prod, token, input|
-        # Add data based on scanned token to input
-        input[:symbol] = token.value
-      end
-
-      start_production(:rule) do |input, current, callback|
-        # Process on start of production
-        # Set state for entry into recursed rules through current
-
-        # Callback to parser loop with callback
-      end
-
-      production(:rule) do |input, current, callback|
-        # Process on end of production
-        # return results in input, retrieve results from recursed rules in current
-
-        # Callback to parser loop with callback
-      end
-
-      def initialize(input)
-        parser_options = {
-          branch: BRANCH,
-          first: FIRST,
-          follow: FOLLOW,
-          cleanup: CLEANUP
-        }
-        parse(input, start_symbol, parser_options) do |context, *data|
-          # Process calls from callback from productions
-
-        rescue ArgumentError, RDF::LL1::Parser::Error => e
-          progress("Parsing completed with errors:\n\t#{e.message}")
-          raise RDF::ReaderError, e.message if validate?
-        end
-
-### Branch Table
-The Branch table is a hash mapping production rules to a hash relating terminals appearing in input to sequence of productions to follow when the corresponding input terminal is found. This allows either the `seq` primitive, where all terminals map to the same sequence of productions, or the `alt` primitive, where each terminal may map to a different production.
-
-    BRANCH = {
-      :alt => {
-        "(" => [:seq, :_alt_1],
-        :ENUM => [:seq, :_alt_1],
-        :HEX => [:seq, :_alt_1],
-        :O_ENUM => [:seq, :_alt_1],
-        :O_RANGE => [:seq, :_alt_1],
-        :RANGE => [:seq, :_alt_1],
-        :STRING1 => [:seq, :_alt_1],
-        :STRING2 => [:seq, :_alt_1],
-        :SYMBOL => [:seq, :_alt_1],
-      },
-      ...
-      :declaration => {
-        "@pass" => [:pass],
-        "@terminals" => ["@terminals"],
-      },
-      ...
-    }
-
-In this case the `alt` rule is `seq ('|' seq)*` can happen when any of the specified tokens appears on the input stream. The all cause the same token to be passed to the `seq` rule and follow with `_alt_1`, which handles the `('|' seq)*` portion of the rule, after the first sequence is matched.
-
-The `declaration` rule is `@terminals' | pass` using the `alt` primitive determining the production to run based on the terminal appearing on the input stream. Eventually, a terminal production is found and the token is consumed.
-
-### First/Follow Table
-The [First/Follow][] table is a hash mapping production rules to the terminals that may proceed or follow the rule. For example:
-
-    FIRST = {
-      :alt => [
-        :HEX,
-        :SYMBOL,
-        :ENUM,
-        :O_ENUM,
-        :RANGE,
-        :O_RANGE,
-        :STRING1,
-        :STRING2,
-        "("],
-      ...
-    }
-
-### Terminals Table
-This table is a simple list of the terminal productions found in the grammar. For example:
-
-    TERMINALS = ["(", ")", "-",
-      "@pass", "@terminals",
-      :ENUM, :HEX, :LHS, :O_ENUM, :O_RANGE,:POSTFIX,
-      :RANGE, :STRING1, :STRING2, :SYMBOL,"|"
-    ].freeze
-
-### Cleanup Table
-This table identifies productions which used EBNF rules, which are transformed to BNF for actual parsing. This allows the parser, in some cases, to reproduce *star*, *plus*, and *opt* rule matches. For example:
-
-    CLEANUP = {
-      :_alt_1 => :star,
-      :_alt_3 => :merge,
-      :_diff_1 => :opt,
-      :ebnf => :star,
-      :_ebnf_2 => :merge,
-      :_postfix_1 => :opt,
-      :seq => :plus,
-      :_seq_1 => :star,
-      :_seq_2 => :merge,
-    }.freeze
-
-In this case the `ebnf` rule was `(declaration | rule)*`. As BNF does not support a star operator, this is decomposed into a set of rules using `alt` and `seq` primitives:
-
-    ebnf    ::= _empty _ebnf_2
-    _ebnf_1 ::= declaration | rule
-    _ebnf_2 ::= _ebnf_1 ebnf
-    _ebnf_3 ::= ebnf
-
-The `_empty` production matches an empty string, so allows for now value. `_ebnf_2` matches `declaration | rule` (using the `alt` primitive) followed by `ebnf`, creating a sequence of zero or more `declaration` or `alt` members.
+### Parser debugging
 
-## EBNF Grammar
-The [EBNF][] variant used here is based on [W3C](http://w3.org/) [EBNF][] (see {file:etc/ebnf.ebnf EBNF grammar}) as defined in the
-[XML 1.0 recommendation](http://www.w3.org/TR/REC-xml/), with minor extensions:
+Inevitably while implementing a parser for some specific grammar, a developer will need greater insight into the operation of the parser. While this can involve sorting through a tremendous amount of data, the parser can be provided a [Logger][] instance which will output messages at varying levels of detail to document the state of the parser at any given point. Most useful is likely the `INFO` level of debugging, but even more detail is revealed using the `DEBUG` level. `WARN` and `ERROR` statements will typically also be provided as part of an exception if parsing fails, but can be shown in the context of other parsing state with appropriate indentation as part of the logger.
+
+### Parser errors
+On a parsing failure, and exception is raised with information that may be useful in determining the source of the error.
 
-* Comments include `\\` and `#` through end of line (other than hex character) and `/* ... */ (* ... *) which may cross lines`
+## EBNF Grammar
+The [EBNF][] variant used here is based on [W3C](https://w3.org/) [EBNF][] (see {file:etc/ebnf.ebnf EBNF grammar}) as defined in the
+[XML 1.0 recommendation](https://www.w3.org/TR/REC-xml/), with minor extensions:
+
+The general form of a rule is:
+
+    symbol ::= expression
+
+which can also be proceeded by an optional number enclosed in square brackets to identify the rule number:
+
+    [1] symbol ::= expression
+
+Symbols are written with an initial capital letter if they are the start symbol of a regular language (terminals), otherwise with an initial lowercase letter (non-terminals). Literal strings are quoted.
+
+Within the expression on the right-hand side of a rule, the following expressions are used to match strings of one or more characters:
+
+<table>
+  <tr><td><code>#xN</code></td>
+    <td>where <code>N</code> is a hexadecimal integer, the expression matches the character whose number (code point) in ISO/IEC 10646 is <code>N</code>. The number of leading zeros in the <code>#xN</code> form is insignificant.</td></tr>
+  <tr><td><code>[a-zA-Z], [#xN-#xN]</code>
+    <td>matches any Char with a value in the range(s) indicated (inclusive).</td></tr>
+  <tr><td><code>[abc], [#xN#xN#xN]</code></td>
+    <td>matches any Char with a value among the characters enumerated. Enumerations and ranges can be mixed in one set of brackets.</td></tr>
+  <tr><td><code>[^a-z], [^#xN-#xN]</code></td>
+    <td>matches any Char with a value outside the range indicated.</td></tr>
+  <tr><td><code>[^abc], [^#xN#xN#xN]</code></td>
+    <td>matches any Char with a value not among the characters given. Enumerations and ranges of forbidden values can be mixed in one set of brackets.</td></tr>
+  <tr><td><code>"string"</code></td>
+    <td>matches a literal string matching that given inside the double quotes.</td></tr>
+  <tr><td><code>'string'</code></td>
+    <td>matches a literal string matching that given inside the single quotes.</td></tr>
+  <tr><td><code>A (B | C)</code></td>
+    <td><code>(B | C)</code> is treated as a unit and may be combined as described in this list.</td></tr>
+  <tr><td><code>A?</code></td>
+    <td>matches A or nothing; optional A.</td></tr>
+  <tr><td><code>A B</code></td>
+    <td>matches <code>A</code> followed by <code>B</code>. This operator has higher precedence than alternation; thus <code>A B | C D</code> is identical to <code>(A B) | (C D)</code>.</td></tr>
+  <tr><td><code>A | B</code></td>
+    <td>matches <code>A</code> or <code>B</code>.</td></tr>
+  <tr><td><code>A - B</code></td>
+    <td>matches any string that matches <code>A</code> but does not match <code>B</code>.</td></tr>
+  <tr><td><code>A+</code></td>
+    <td>matches one or more occurrences of <code>A</code>. Concatenation has higher precedence than alternation; thus <code>A+ | B+</code> is identical to <code>(A+) | (B+)</code>.</td></tr>
+  <tr><td><code>A*</code></td>
+    <td>matches zero or more occurrences of <code>A</code>. Concatenation has higher precedence than alternation; thus <code>A* | B*</code> is identical to <code>(A*) | (B*)</code>.</td></tr>
+  <tr><td><code>@pass " "*</code></td>
+    <td>Defines consumed whitespace in the document. Any whitespace found between non-terminal rules is consumed and ignored.</td></tr>
+  <tr><td><code>@terminals</code></td>
+    <td>Introduces terminal rules. All rules defined after this point are treated as terminals.</td></tr>
+</table>
+
+* Comments include `//` and `#` through end of line (other than hex character) and `/* ... */ (* ... *) which may cross lines`
 * All rules **MAY** start with an identifier, contained within square brackets. For example `[1] rule`, where the value within the brackets is a symbol `([a-z] | [A-Z] | [0-9] | "_" | ".")+`
-* `@terminals` causes following rules to be treated as terminals. Any terminal which are entirely upper-case are also treated as terminals
+* `@terminals` causes following rules to be treated as terminals. Any terminal which is all upper-case (eg`TERMINAL`), or any rules with expressions that match characters (`#xN`, `[a-z]`, `[^a-z]`, `[abc]`, `[^abc]`, `"string"`, `'string'`, or `A - B`), are also treated as terminals.
 * `@pass` defines the expression used to detect whitespace, which is removed in processing.
 * No support for `wfc` (well-formedness constraint) or `vc` (validity constraint).
 
-Parsing this grammar yields an S-Expression version: {file:etc/ebnf.ll1.sxp}.
+Parsing this grammar yields an S-Expression version: {file:etc/ebnf.sxp} (or [LL(1)][] version {file:etc/ebnf.ll1.sxp} or [PEG][] version {file:etc/ebnf.peg.sxp}).
+
+### Parser S-Expressions
+Intermediate representations of the grammar may be serialized to Lisp-like S-Expressions. For example, the rule
+
+    [1] ebnf        ::= (declaration | rule)*
+
+is serialized as
+
+    (rule ebnf "1" (star (alt declaration rule)))
+
+Different components of an EBNF rule expression are transformed into their own operator:
+
+<table>
+  <tr><td><code>#xN</code></td><td><code>(hex "#xN")</code></td></tr>
+  <tr><td><code>[a-z#xN-#xN]</code></td><td><code>(range "a-z#xN-#xN")</code></td></tr>
+  <tr><td><code>[abc#xN]</code></td><td><code>(range "abc#xN")</code></td></tr>
+  <tr><td><code>[^a-z#xN-#xN]</code></td><td><code>(range "^a-z#xN-#xN")</code></td></tr>
+  <tr><td><code>[^abc#xN]</code></td><td><code>(range "^abc#xN")</code></td></tr>
+  <tr><td><code>"string"</code></td><td><code>"string"</code></td></tr>
+  <tr><td><code>'string'</code></td><td><code>"string"</code></td></tr>
+  <tr><td><code>A (B | C)</code></td><td><code>(seq (A (alt B C)))</code></td></tr>
+  <tr><td><code>A?</code></td><td><code>(opt A)</code></td></tr>
+  <tr><td><code>A B</code></td><td><code>(seq A B)</code></td></tr>
+  <tr><td><code>A | B</code></td><td><code>(alt A B)</code></td></tr>
+  <tr><td><code>A - B</code></td><td><code>(diff A B)</code></td></tr>
+  <tr><td><code>A+</code></td><td><code>(plus A)</code></td></tr>
+  <tr><td><code>A*</code></td><td><code>(star A)</code></td></tr>
+  <tr><td><code>@pass " "*</code></td><td><code>(pass (star " "))</code></td></tr>
+  <tr><td><code>@terminals</code></td><td></td></tr>
+</table>
+
+Additionally, rules defined with an UPPERCASE symbol are treated as terminals.
+
+For an [LL(1)][] parser generator, the {EBNF::BNF.make_bnf} method can be used to transform the EBNF rule into a BNF rule.
+
+    (rule ebnf "1" (alt _empty _ebnf_2))
+    (rule _ebnf_1 "1.1" (alt declaration rule))
+    (rule _ebnf_2 "1.2" (seq _ebnf_1 ebnf))
+    (rule _ebnf_3 "1.3" (seq ebnf))
+
+This allows [First/Follow][] and other tables used by a parser to parse examples of the associated grammar. For more, see {EBNF::LL1}.
+
+For a [PEG][] parser generator, there is a simpler transformation that reduces rules containing sub-expressions (composed of `star`, `alt`, `seq` and similar expressions) and creates named rules to allow appropriate callbacks and for naming elements of the generating abstract syntax tree. The {EBNF::PEG.make_peg} method transforms the original rule into the following two rules:
+
+    (rule ebnf "1" (star _ebnf_1))
+    (rule _ebnf_1 "1.1" (alt declaration rule))
+
+## Example parsers
+For a [PEG][] parser for a simple grammar implementing a calculator see [Calc example](http://dryruby.github.io/ebnf/examples/calc/doc/calc.html
+
+For an example parser built using this gem that parses the [EBNF][] grammar, see [EBNF PEG Parser example](http://dryruby.github.io/ebnf/examples/ebnf-peg-parser/doc/parser.html). This example creates a parser for the [EBNF][] grammar which generates the same Abstract Syntax Tree as the built-in parser in the gem.
 
-## Example parser
-For an example parser built using this gem, see {file:examples/ebnf-parser/README EBNF Parser example}. This example creates a parser for the [EBNF][] grammar which generates the same Abstract Syntax Tree as the built-in parser in the gem.
+There is also an
+[EBNF LL(1) Parser example](http://dryruby.github.io/ebnf/examples/ebnf-peg-parser/doc/parser.html).
 
 ##  Acknowledgements
 Much of this work, particularly the generic parser, is inspired by work originally done by
-Tim Berners-Lee's Python [predictive parser](http://www.w3.org/2000/10/swap/grammar/predictiveParser.py).
+Tim Berners-Lee's Python [predictive parser](https://www.w3.org/2000/10/swap/grammar/predictiveParser.py).
 
-The EBNF parser was inspired by Dan Connolly's
-[EBNF to Turtle processor](http://www.w3.org/2000/10/swap/grammar/ebnf2turtle.py),
-[EBNF to BNF Notation-3 rules](http://www.w3.org/2000/10/swap/grammar/ebnf2bnf.n3),
-and [First Follow Notation-3 rules](http://www.w3.org/2000/10/swap/grammar/first_follow.n3). 
+The [LL(1)][] parser was inspired by Dan Connolly's
+[EBNF to Turtle processor](https://www.w3.org/2000/10/swap/grammar/ebnf2turtle.py),
+[EBNF to BNF Notation-3 rules](https://www.w3.org/2000/10/swap/grammar/ebnf2bnf.n3),
+and [First Follow Notation-3 rules](https://www.w3.org/2000/10/swap/grammar/first_follow.n3). 
 
 ## Documentation
 Full documentation available on [Rubydoc.info][EBNF doc].
 
 ## Future Work
 * Better LL(1) parser tests
-* Either generate [Packrat parser][Packrat] for a [Parsing Regular Expression Grammar][PEG], or integrate with [Treetop][] or similar.
 
 ## Author
-* [Gregg Kellogg](http://github.com/gkellogg) - <http://greggkellogg.net/>
+* [Gregg Kellogg](https://github.com/gkellogg) - <https://greggkellogg.net/>
 
 ## Contributing
 This repository uses [Git Flow](https://github.com/nvie/gitflow) to mange development and release activity. All submissions _must_ be on a feature branch based on the _develop_ branch to ease staging and integration.
@@ -248,22 +221,24 @@ This repository uses [Git Flow](https://github.com/nvie/gitflow) to mange develo
 
 ## License
 This is free and unencumbered public domain software. For more information,
-see <http://unlicense.org/> or the accompanying {file:UNLICENSE} file.
-
-A copy of the [Turtle EBNF][] and derived parser files are included in the repository, which are not covered under the UNLICENSE. These files are covered via the [W3C Document License](http://www.w3.org/Consortium/Legal/2002/copyright-documents-20021231).
-
-[Ruby]:         http://ruby-lang.org/
-[YARD]:         http://yardoc.org/
-[YARD-GS]:      http://rubydoc.info/docs/yard/file/docs/GettingStarted.md
-[PDD]:          http://lists.w3.org/Archives/Public/public-rdf-ruby/2010May/0013.html
-[EBNF]:         http://www.w3.org/TR/REC-xml/#sec-notation
-[EBNF doc]:     http://rubydoc.info/github/dryruby/ebnf/master/frames
-[First/Follow]: http://en.wikipedia.org/wiki/LL_parser#Constructing_an_LL.281.29_parsing_table
-[LL(1)]:        http://www.csd.uwo.ca/~moreno//CS447/Lectures/Syntax.html/node14.html
-[LL(1) Parser]: http://en.wikipedia.org/wiki/LL_parser
-[Tokenizer]:    http://en.wikipedia.org/wiki/Lexical_analysis#Tokenizer
-[Turtle EBNF]:  http://dvcs.w3.org/hg/rdf/file/default/rdf-turtle/turtle.bnf
-[Packrat]:      http://pdos.csail.mit.edu/~baford/packrat/thesis/
-[PEG]:          http://en.wikipedia.org/wiki/Parsing_expression_grammar
-[Treetop]:      http://rubygems.org/gems/treetop
-[Haml]:         http://rubygems.org/gems/haml
+see <https://unlicense.org/> or the accompanying {file:UNLICENSE} file.
+
+A copy of the [Turtle EBNF][] and derived parser files are included in the repository, which are not covered under the UNLICENSE. These files are covered via the [W3C Document License](https://www.w3.org/Consortium/Legal/2002/copyright-documents-20021231).
+
+[Ruby]:         https://ruby-lang.org/
+[YARD]:         https://yardoc.org/
+[YARD-GS]:      https://rubydoc.info/docs/yard/file/docs/GettingStarted.md
+[PDD]:          https://lists.w3.org/Archives/Public/public-rdf-ruby/2010May/0013.html
+[BNF]:          https://en.wikipedia.org/wiki/Backus–Naur_form
+[EBNF]:         https://www.w3.org/TR/REC-xml/#sec-notation
+[EBNF doc]:     https://rubydoc.info/github/dryruby/ebnf
+[First/Follow]: https://en.wikipedia.org/wiki/LL_parser#Constructing_an_LL.281.29_parsing_table
+[LL(1)]:        https://www.csd.uwo.ca/~moreno//CS447/Lectures/Syntax.html/node14.html
+[LL(1) Parser]: https://en.wikipedia.org/wiki/LL_parser
+[Logger]:       https://ruby-doc.org/stdlib-2.4.0/libdoc/logger/rdoc/Logger.html
+[Tokenizer]:    https://en.wikipedia.org/wiki/Lexical_analysis#Tokenizer
+[Turtle EBNF]:  https://dvcs.w3.org/hg/rdf/file/default/rdf-turtle/turtle.bnf
+[Packrat]:      https://pdos.csail.mit.edu/~baford/packrat/thesis/
+[PEG]:          https://en.wikipedia.org/wiki/Parsing_expression_grammar
+[Treetop]:      https://rubygems.org/gems/treetop
+[Haml]:         https://rubygems.org/gems/haml

data/UNLICENSE

@@ -21,4 +21,4 @@ OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
 ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
 OTHER DEALINGS IN THE SOFTWARE.
 
-For more information, please refer to <http://unlicense.org/>
+For more information, please refer to <https://unlicense.org/>

data/VERSION

@@ -1 +1 @@
-1.2.0
+2.0.0

data/bin/ebnf

@@ -28,6 +28,7 @@ OPT_ARGS = [
   ["--input-format",    GetoptLong::REQUIRED_ARGUMENT,"Specify input format one of ebnf or sxp"],
   ["--mod-name",        GetoptLong::REQUIRED_ARGUMENT,"Module name used when creating ruby tables"],
   ["--output", "-o",    GetoptLong::REQUIRED_ARGUMENT,"Output to the specified file path"],
+  ["--peg",             GetoptLong::NO_ARGUMENT,      "Transform EBNF to PEG"],
   ["--prefix", "-p",    GetoptLong::REQUIRED_ARGUMENT,"Prefix to use when generating Turtle"],
   ["--progress", "-v",  GetoptLong::NO_ARGUMENT,      "Detail on execution"],
   ["--namespace", "-n", GetoptLong::REQUIRED_ARGUMENT,"Namespace to use when generating Turtle"],
@@ -58,9 +59,10 @@ opts.each do |opt, arg|
   when '--evaluate'     then input = arg
   when '--input-format' then options[:format] = arg.to_sym
   when '--format'       then options[:output_format] = arg.to_sym
-  when '--ll1'          then (options[:ll1] ||= []) <<arg.to_sym
+  when '--ll1'          then (options[:ll1] ||= []) << arg.to_sym
   when '--mod-name'     then options[:mod_name] = arg
   when '--output'       then out = File.open(arg, "w")
+  when '--peg'          then options[:peg] = true
   when '--prefix'       then options[:prefix] = arg
   when '--namespace'    then options[:namespace] = arg
   when '--progress'     then options[:progress] = true
@@ -68,8 +70,8 @@ opts.each do |opt, arg|
   end
 end
 
-if options[:output_format] == :rb && !options[:ll1]
-  STDERR.puts "outputing in .rb format requires -ll"
+if options[:output_format] == :rb && !(options[:ll1] || options[:peg])
+  STDERR.puts "outputing in .rb format requires --ll or --peg"
   exit(1)
 end
 
@@ -77,6 +79,7 @@ input = File.open(ARGV[0]) if ARGV[0]
 
 ebnf = EBNF.parse(input || STDIN, **options)
 ebnf.make_bnf if options[:bnf] || options[:ll1]
+ebnf.make_peg if options[:peg]
 if options[:ll1]
   ebnf.first_follow(*options[:ll1])
   ebnf.build_tables