Value Members

1.  object EbnfParser extends RegexParsers

   Parser for EBNF specifications

   Parser for EBNF specifications

   Intended usage is via the apply method to Strings, or via standard parser combinator mechanisms. apply returns either the error message or the org.benknoble.ebnf.Grammar in an Either.

   From Matt Might's specification

   BNF

   When describing languages, Backus-Naur form (BNF) is a formal notation for encoding grammars intended for human consumption.

   Many programming languages, protocols or formats have a BNF description in their specification.

   Every rule in Backus-Naur form has the following structure:

   name ::= expansion

   The symbol ::= means "may expand into" and "may be replaced with."

   In some texts, a name is also called a non-terminal symbol.

   Every name in Backus-Naur form is surrounded by angle brackets, < >, whether it appears on the left- or right-hand side of the rule.

   An expansion is an expression containing terminal symbols and non-terminal symbols, joined together by sequencing and choice.

   A terminal symbol is a literal like ("+" or "function") or a class of literals (like integer). It must be quoted using single quotes. Any metacharacters may appear within the quotes.

   Simply juxtaposing expressions indicates sequencing.

   A vertical bar | indicates choice.

   For example, in BNF, the classic expression grammar is:

   <expr> ::= <term> "+" <expr> |  <term>
   <term> ::= <factor> "*" <term> |  <factor>
   <factor> ::= "(" <expr> ")" |  <const>
   <const> ::= integer

   EBNF

   Extended Backus-Naur form (EBNF) is a collection of extensions to Backus-Naur form.

   More important than the minor syntactic differences between the forms of EBNF are the additional operations it allows in expansions.

   Option

   In EBNF, square brackets around an expansion, [ expansion ], indicates that this expansion is optional.

   For example, the rule:

   <term> ::= [ "-" ] <factor>

   allows factors to be negated.

   Repetition

   In EBNF, curly braces indicate that the expression may be repeated zero or more times.

   For example, the rule:

   <args> ::= <arg> { "," <arg> }

   defines a conventional comma-separated argument list.

   Grouping

   To indicate precedence, EBNF grammars may use parentheses, (), to explictly define the order of expansion.

   For example, the rule:

   <expr> ::= <term> ("+" | "-") <expr>

   defines an expression form that allows both addition and subtraction.

   Extensions

   This version of EBNF admits a "comment-like" extension syntax: a # escapes the rest of the line, such that it is not parsed at all. Indeed, it is not kept in the grammar object at all, so the result of formatting loses the comments (considered a feature: it cleans the output for consumption by another tool).

   The following grammar from the tests is thus valid:

   # this is a comment
   <A> ::= 'a'     # a values
           | 'b'   # b values
           | 'c'   # c values
           ;

   Annotations

   @JSExportTopLevel( "EbnfParser" )

2.  object Expr

   Provides helper methods for expressions

   Provides helper methods for expressions

   The most notable is reduceTree, which helps convert a Seq of org.benknoble.ebnf.Exprs to an org.benknoble.ebnf.Expr subtype representing an expression tree.

   Simple names are provided for the most common tree reductions.

   Used primarly by org.benknoble.ebnf.EbnfParser to map parser results into trees.

3.  object ExprImplicits

   Implicit conversions for Expr

   Implicit conversions for Expr

   Creates a DSL-like system, with Strings automatically converted to org.benknoble.ebnf.Terminals and Symbols converted to org.benknoble.ebnf.Nonterminal:

   scala> import org.benknoble.ebnf._
   import org.benknoble.ebnf._
   
   scala> import ExprImplicits._
   import ExprImplicits._
   
   scala> val p = 'A ::= ("abc" || 'B.?) ~ 'C.*
   p: org.benknoble.ebnf.Production = Production(Nonterminal('A), Sequence(Alternation(Terminal(abc),Option(Nonterminal('B))),Repetition(Nonterminal('C))))
   
   scala> val f = p.format
   f: String = <A> ::= ('abc'|[<B>]){<C>}

   Do note that val r: Expr = "abc".* will not work, due to ambiguity:

   scala> val r: Expr = "abc".*
   <console>:17: error: type mismatch;
    found   : String("abc")
    required: ?{def *: ?}
   Note that implicit conversions are not applicable because they are ambiguous:
    both method augmentString in object Predef of type (x: String)scala.collection.immutable.StringOps
    and method charToTerminal in object ExprImplicits of type (s: String)org.benknoble.ebnf.Terminal
    are possible conversion functions from String("abc") to ?{def *: ?}
          val r: Expr = "abc".*
                        ^
   <console>:17: error: value * is not a member of String
          val r: Expr = "abc".*
                              ^

4.  object Grammar

   Factory for org.benknoble.ebnf.Grammar instances.

5.  object Main
6.  object ε extends Word with Product with Serializable

   The empty expression (pronounced "epsilon")