- examples/EBNF: new ebnf example

examples/Arithmetic/Arithmetic.ebnf

@@ -18,8 +18,8 @@
 #
 #######################################################################
 
-expression = term  { EXPR_OP term}
-term       = factor  { TERM_OP factor}
+expression = term  { EXPR_OP~ term}
+term       = factor  { TERM_OP~ factor}
 factor     = [SIGN] ( NUMBER | VARIABLE | group ) { VARIABLE | group }
 group      = "(" expression ")"
 
@@ -29,8 +29,8 @@ group      = "(" expression ")"
 #
 #######################################################################
 
-EXPR_OP    = "+" | "-"
-TERM_OP    = "*" | "/"
+EXPR_OP    = /\+/ | /-/
+TERM_OP    = /\*/ | /\//
 SIGN       = /-/
 
 NUMBER     = /(?:0|(?:[1-9]\d*))(?:\.\d+)?/~

examples/Arithmetic/ArithmeticCompiler.py

@@ -59,7 +59,7 @@ class ArithmeticGrammar(Grammar):
     r"""Parser for an Arithmetic source file.
     """
     expression = Forward()
-    source_hash__ = "5a5e8df98d9c78186acdd7f602aa51da"
+    source_hash__ = "48fe89871e7ba344eb238c1d1a927167"
     parser_initialization__ = ["upon instantiation"]
     resume_rules__ = {}
     COMMENT__ = r'#.*'
@@ -70,12 +70,12 @@ class ArithmeticGrammar(Grammar):
     VARIABLE = Series(RegExp('[A-Za-z]'), dwsp__)
     NUMBER = Series(RegExp('(?:0|(?:[1-9]\\d*))(?:\\.\\d+)?'), dwsp__)
     SIGN = RegExp('-')
-    TERM_OP = Alternative(Series(DropToken("*"), dwsp__), Series(DropToken("/"), dwsp__))
-    EXPR_OP = Alternative(Series(DropToken("+"), dwsp__), Series(DropToken("-"), dwsp__))
+    TERM_OP = Alternative(RegExp('\\*'), RegExp('/'))
+    EXPR_OP = Alternative(RegExp('\\+'), RegExp('-'))
     group = Series(Series(DropToken("("), dwsp__), expression, Series(DropToken(")"), dwsp__))
     factor = Series(Option(SIGN), Alternative(NUMBER, VARIABLE, group), ZeroOrMore(Alternative(VARIABLE, group)))
-    term = Series(factor, ZeroOrMore(Series(TERM_OP, factor)))
-    expression.set(Series(term, ZeroOrMore(Series(EXPR_OP, term))))
+    term = Series(factor, ZeroOrMore(Series(TERM_OP, dwsp__, factor)))
+    expression.set(Series(term, ZeroOrMore(Series(EXPR_OP, dwsp__, term))))
     root__ = expression
     
 def get_grammar() -> ArithmeticGrammar:

examples/EBNF/EBNF.ebnf

@@ -4,10 +4,14 @@
 @ whitespace = /\s*/                            # whitespace includes linefeed
 @ literalws  = right                            # trailing whitespace of literals will be ignored tacitly
 
+#: top-level
+
 syntax     = [~//] { definition | directive } §EOF
 definition = symbol §"=" expression
 directive  = "@" §symbol "=" (regexp | literal | symbol) { "," (regexp | literal | symbol) }
 
+#: components
+
 expression = term { "|" term }
 term       = { ["§"] factor }+                       # "§" means all following factors mandatory
 factor     = [flowmarker] [retrieveop] symbol !"="   # negative lookahead to be sure it's not a definition
@@ -21,16 +25,22 @@ factor     = [flowmarker] [retrieveop] symbol !"="   # negative lookahead to be
            | repetition
            | option
 
+#: flow-operators
+
 flowmarker = "!"  | "&"                         # '!' negative lookahead, '&' positive lookahead
            | "-!" | "-&"                        # '-' negative lookbehind, '-&' positive lookbehind
 retrieveop = "::" | ":"                         # '::' pop, ':' retrieve
 
+#: groups
+
 group      = "(" §expression ")"
 unordered  = "<" §expression ">"                # elements of expression in arbitrary order
 oneormore  = "{" expression "}+"
 repetition = "{" §expression "}"
 option     = "[" §expression "]"
 
+#: leaf-elements
+
 symbol     = /(?!\d)\w+/~                       # e.g. expression, factor, parameter_list
 literal    = /"(?:[^"]|\\")*?"/~                # e.g. "(", '+', 'while'
            | /'(?:[^']|\\')*?'/~                # whitespace following literals will be ignored tacitly.

examples/EBNF/README.md

+# EBNF
+
+PLACE A SHORT DESCRIPTION HERE
+
+Author: AUTHOR'S NAME <EMAIL>, AFFILIATION
+
+
+## License
+
+EBNF is open source software under the [Apache 2.0 License](https://www.apache.org/licenses/LICENSE-2.0)
+
+Copyright YEAR AUTHOR'S NAME <EMAIL>, AFFILIATION
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    https://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.

examples/EBNF/example_1.dsl

+# Arithmetic-grammar
+
+#######################################################################
+#
+#  EBNF-Directives
+#
+#######################################################################
+
+@ whitespace  = vertical           # implicit whitespace, includes any number of line feeds
+@ literalws   = right              # literals have implicit whitespace on the right hand side
+@ comment     = /#.*/              # comments range from a '#'-character to the end of the line
+@ ignorecase  = False              # literals and regular expressions are case-sensitive
+@ drop        = whitespace, token  # drop anonymous whitespace
+
+#######################################################################
+#
+#  Structure and Components
+#
+#######################################################################
+
+expression = term  { EXPR_OP~ term}
+term       = factor  { TERM_OP~ factor}
+factor     = [SIGN] ( NUMBER | VARIABLE | group ) { VARIABLE | group }
+group      = "(" expression ")"
+
+#######################################################################
+#
+# "Leaf"-Expressions
+#
+#######################################################################
+
+EXPR_OP    = /\+/ | /-/
+TERM_OP    = /\*/ | /\//
+SIGN       = /-/
+
+NUMBER     = /(?:0|(?:[1-9]\d*))(?:\.\d+)?/~
+VARIABLE   = /[A-Za-z]/~

examples/EBNF/example_2.dsl

+# EBNF-Grammar in EBNF
+
+@ comment    = /#.*(?:\n|$)/                    # comments start with '#' and eat all chars up to and including '\n'
+@ whitespace = /\s*/                            # whitespace includes linefeed
+@ literalws  = right                            # trailing whitespace of literals will be ignored tacitly
+
+syntax     = [~//] { definition | directive } §EOF
+definition = symbol §"=" expression
+directive  = "@" §symbol "=" (regexp | literal | symbol) { "," (regexp | literal | symbol) }
+
+expression = term { "|" term }
+term       = { ["§"] factor }+                       # "§" means all following factors mandatory
+factor     = [flowmarker] [retrieveop] symbol !"="   # negative lookahead to be sure it's not a definition
+           | [flowmarker] literal
+           | [flowmarker] plaintext
+           | [flowmarker] regexp
+           | [flowmarker] whitespace
+           | [flowmarker] oneormore
+           | [flowmarker] group
+           | [flowmarker] unordered
+           | repetition
+           | option
+
+flowmarker = "!"  | "&"                         # '!' negative lookahead, '&' positive lookahead
+           | "-!" | "-&"                        # '-' negative lookbehind, '-&' positive lookbehind
+retrieveop = "::" | ":"                         # '::' pop, ':' retrieve
+
+group      = "(" §expression ")"
+unordered  = "<" §expression ">"                # elements of expression in arbitrary order
+oneormore  = "{" expression "}+"
+repetition = "{" §expression "}"
+option     = "[" §expression "]"
+
+symbol     = /(?!\d)\w+/~                       # e.g. expression, factor, parameter_list
+literal    = /"(?:[^"]|\\")*?"/~                # e.g. "(", '+', 'while'
+           | /'(?:[^']|\\')*?'/~                # whitespace following literals will be ignored tacitly.
+plaintext  = /`(?:[^"]|\\")*?`/~                # like literal but does not eat whitespace
+regexp     = /\/(?:\\\/|[^\/])*?\//~            # e.g. /\w+/, ~/#.*(?:\n|$)/~
+whitespace = /~/~                               # insignificant whitespace
+
+EOF = !/./

examples/EBNF/tst_EBNF_grammar.py

+#!/usr/bin/python3
+
+"""tst_EBNF_grammar.py - runs the unit tests for the EBNF-grammar
+"""
+
+import os
+import sys
+
+LOGGING = False
+
+sys.path.append(r'/home/eckhart/Entwicklung/DHParser')
+
+scriptpath = os.path.dirname(__file__)
+
+
+try:
+    from DHParser import dsl
+    import DHParser.log
+    from DHParser import testing
+except ModuleNotFoundError:
+    print('Could not import DHParser. Please adjust sys.path in file '
+          '"%s" manually' % __file__)
+    sys.exit(1)
+
+
+def recompile_grammar(grammar_src, force):
+    with DHParser.log.logging(LOGGING):
+        # recompiles Grammar only if it has changed
+        if not dsl.recompile_grammar(grammar_src, force=force):
+            print('\nErrors while recompiling "%s":' % grammar_src +
+                  '\n--------------------------------------\n\n')
+            with open('EBNF_ebnf_ERRORS.txt') as f:
+                print(f.read())
+            sys.exit(1)
+
+
+def run_grammar_tests(glob_pattern):
+    with DHParser.log.logging(LOGGING):
+        error_report = testing.grammar_suite(
+            os.path.join(scriptpath, 'grammar_tests'),
+            get_grammar, get_transformer,
+            fn_patterns=[glob_pattern], report=True, verbose=True)
+    return error_report
+
+
+if __name__ == '__main__':
+    argv = sys.argv[:]
+    if len(argv) > 1 and sys.argv[1] == "--debug":
+        LOGGING = True
+        del argv[1]
+    if (len(argv) >= 2 and (argv[1].endswith('.ebnf') or
+        os.path.splitext(argv[1])[1].lower() in testing.TEST_READERS.keys())):
+        # if called with a single filename that is either an EBNF file or a known
+        # test file type then use the given argument
+        arg = argv[1]
+    else:
+        # otherwise run all tests in the test directory
+        arg = '*_test_*.ini'
+    if arg.endswith('.ebnf'):
+        recompile_grammar(arg, force=True)
+    else:
+        recompile_grammar(os.path.join(scriptpath, 'EBNF.ebnf'),
+                          force=False)
+        sys.path.append('.')
+        from EBNFCompiler import get_grammar, get_transformer
+        error_report = run_grammar_tests(glob_pattern=arg)
+        if error_report:
+            print('\n')
+            print(error_report)
+            sys.exit(1)
+        print('ready.\n')

examples/EBNF_old/EBNF.ebnf

+# EBNF-Grammar in EBNF
+
+@ comment    = /#.*(?:\n|$)/                    # comments start with '#' and eat all chars up to and including '\n'
+@ whitespace = /\s*/                            # whitespace includes linefeed
+@ literalws  = right                            # trailing whitespace of literals will be ignored tacitly
+
+syntax     = [~//] { definition | directive } §EOF
+definition = symbol §"=" expression
+directive  = "@" §symbol "=" (regexp | literal | symbol) { "," (regexp | literal | symbol) }
+
+expression = term { "|" term }
+term       = { ["§"] factor }+                       # "§" means all following factors mandatory
+factor     = [flowmarker] [retrieveop] symbol !"="   # negative lookahead to be sure it's not a definition
+           | [flowmarker] literal
+           | [flowmarker] plaintext
+           | [flowmarker] regexp
+           | [flowmarker] whitespace
+           | [flowmarker] oneormore
+           | [flowmarker] group
+           | [flowmarker] unordered
+           | repetition
+           | option
+
+flowmarker = "!"  | "&"                         # '!' negative lookahead, '&' positive lookahead
+           | "-!" | "-&"                        # '-' negative lookbehind, '-&' positive lookbehind
+retrieveop = "::" | ":"                         # '::' pop, ':' retrieve
+
+group      = "(" §expression ")"
+unordered  = "<" §expression ">"                # elements of expression in arbitrary order
+oneormore  = "{" expression "}+"
+repetition = "{" §expression "}"
+option     = "[" §expression "]"
+
+symbol     = /(?!\d)\w+/~                       # e.g. expression, factor, parameter_list
+literal    = /"(?:[^"]|\\")*?"/~                # e.g. "(", '+', 'while'
+           | /'(?:[^']|\\')*?'/~                # whitespace following literals will be ignored tacitly.
+plaintext  = /`(?:[^"]|\\")*?`/~                # like literal but does not eat whitespace
+regexp     = /\/(?:\\\/|[^\/])*?\//~            # e.g. /\w+/, ~/#.*(?:\n|$)/~
+whitespace = /~/~                               # insignificant whitespace
+
+EOF = !/./