提交: 5800f73c267c1a8b3e80a2ebeb809f5d9a6fd66a - CCastle2 (hg)

Castle: The best Real-Time/Embedded/HighTech language EVER. Attempt 2

Commit MetaInfo

• 修订版: 5800f73c267c1a8b3e80a2ebeb809f5d9a6fd66a (tree)
• 时间: 2022-02-12 07:09:00
• 作者: Albert Mietus < albert AT mietus DOT nl >
• Commiter: Albert Mietus < albert AT mietus DOT nl >

Log Message

Refactored: renamed expressions into sequence; in GRAMMER (and all other files)

更改概述

• modified: castle/ast/peg.py
• modified: castle/readers/parser/grammar.py
• modified: castle/readers/parser/visitor.py
• modified: demos/readers/parser/test_Rule.py
• modified: pytst/readers/parser/d1_parse_tree/test_3_expr.py
• modified: pytst/readers/parser/d2_ast/test_1_term.py
• modified: pytst/readers/parser/d2_ast/test_2_ID.py
• modified: pytst/readers/parser/d2_ast/test_3_Seq.py
• modified: pytst/readers/parser/grammar.peg
• modified: pytst/writers/python/test_1_rules.py

差异

diff -r 5821f8fe1033 -r 5800f73c267c castle/ast/peg.py
--- a/castle/ast/peg.py	Fri Feb 11 22:21:13 2022 +0100
+++ b/castle/ast/peg.py	Fri Feb 11 23:09:00 2022 +0100
@@ -114,7 +114,7 @@
 
 
 class UnorderedGroup(MixIn_expr_attribute, Group):                      # It looks like a Quantity, but is a group
-    """See a set (aka "group") of expressions that **all** have to be matched, but the **order** is a don't care.
+    """A set (aka "group") of expressions that **all** have to be matched, but the **order** is a don't care.
 
        Possible an extension of Arpeggio (see: https://textx.github.io/Arpeggio/stable/grammars/), possible a generic one."""
 

diff -r 5821f8fe1033 -r 5800f73c267c castle/readers/parser/grammar.py
--- a/castle/readers/parser/grammar.py	Fri Feb 11 22:21:13 2022 +0100
+++ b/castle/readers/parser/grammar.py	Fri Feb 11 23:09:00 2022 +0100
@@ -6,8 +6,8 @@
 def rules(): 		return OneOrMore(rule)
 def rule():		return rule_name, '<-', expression, ";"
 
-def expression():	return expressions, op_alternative
-def expressions():	return OneOrMore(single_expr)
+def expression():	return sequence, op_alternative
+def sequence():		return OneOrMore(single_expr)
 def single_expr():	return [ rule_crossref, term, group, predicate ], op_quantity
 
 def op_alternative():   return Optional( '|' , expression )

diff -r 5821f8fe1033 -r 5800f73c267c castle/readers/parser/visitor.py
--- a/castle/readers/parser/visitor.py	Fri Feb 11 22:21:13 2022 +0100
+++ b/castle/readers/parser/visitor.py	Fri Feb 11 23:09:00 2022 +0100
@@ -3,6 +3,7 @@
 from castle.ast import peg
 
 import logging;logger = logging.getLogger(__name__)
+from typing import Union
 
 class QuantityError(ValueError): pass
 class PredicateError(ValueError): pass
@@ -65,9 +66,10 @@
             raise  NotImplementedError("visit_single_expr, len>2")      # XXX -- Is this possible?
 
 
-    def visit_expression(self, node, children):                  # expression <- expressionS, op_alternative; op_alternative <- ('|' expression)?
+    # expression <- sequence, op_alternative; op_alternative <- ('|' expression)?
+    def visit_expression(self, node, children) -> Union[peg.Sequence,  peg.OrderedChoice]:
         logger.debug('visit_expression::' + self._logstr_node_children(node, children))
-        if len(children) == 1: #Only expressions
+        if len(children) == 1: #Only sequence
             return children[0]
         elif len(children) == 2: # So, having 1 or more alternatives in children[1]
             # In all cased a (single) OrderedChoice with a list of alternatives should be returned.
@@ -79,9 +81,9 @@
         else:
             raise NotImplementedError("visit_expression, len>2")
 
-
-    def visit_expressions(self, node, children):                 # OneOrMore(single_expr)
-        logger.debug(f'visit_expressions::{self._logstr_node_children(node, children)}')
+    # OneOrMore(single_expr)
+    def visit_sequence(self, node, children) -> peg.Sequence:
+        logger.debug(f'visit_sequence::{self._logstr_node_children(node, children)}')
         return peg.Sequence(value=children, parse_tree=node)
 
 

diff -r 5821f8fe1033 -r 5800f73c267c demos/readers/parser/test_Rule.py
--- a/demos/readers/parser/test_Rule.py	Fri Feb 11 22:21:13 2022 +0100
+++ b/demos/readers/parser/test_Rule.py	Fri Feb 11 23:09:00 2022 +0100
@@ -59,4 +59,4 @@
 
 def test_QAZ_rule_name():    	QAZ("""aName""",	grammar.rule_name,	label="rule_name")
 def test_QAZ_rule_crossref():	QAZ("""aName""",	grammar.rule_crossref,	label="rule_crossref")
-def test_QAZ_expressions():	QAZ("""aName""",	grammar.expressions,	label="expressions")
+def test_QAZ_expression():	QAZ("""aName""",	grammar.expression,	label="expression")

diff -r 5821f8fe1033 -r 5800f73c267c pytst/readers/parser/d1_parse_tree/test_3_expr.py
--- a/pytst/readers/parser/d1_parse_tree/test_3_expr.py	Fri Feb 11 22:21:13 2022 +0100
+++ b/pytst/readers/parser/d1_parse_tree/test_3_expr.py	Fri Feb 11 23:09:00 2022 +0100
@@ -9,7 +9,12 @@
 P = grammar.predicate.__name__
 G = grammar.group.__name__
 
-def parse_expression(txt, pattern=None):
+
+def validate_expression(txt, pattern):
+    parse_tree = parse_expression(txt)
+    validate_pattern(parse_tree, pattern=pattern)
+
+def parse_expression(txt):
     parser = arpeggio.ParserPython(grammar.expression)
     parse_tree = parser.parse(txt)
     logger.debug("\nPARSE-TREE\n" + parse_tree.tree_str()+'\n')
@@ -17,15 +22,14 @@
     assert parse_tree.position_end == len(txt) , f"Not parsed whole input; Only: >>{txt[parse_tree.position: parse_tree.position_end]}<<; Not: >>{txt[parse_tree.position_end:]}<<."
     assert parse_tree.rule_name == "expression"
 
-    if pattern: validate_pattern(parse_tree, pattern=pattern)
-
     return parse_tree
 
+
 def validate_pattern(pt, pattern=None):
-    expressions = pt[0]
-    assert len(expressions) == len(pattern), f"Not correct number-of-element"
+    elements = pt[0]
+    assert len(elements) == len(pattern), f"Not correct number-of-element"
 
-    for p, s in zip(pattern, expressions):
+    for p, s in zip(pattern, elements):
         if p is None: continue
         if p == X:
             assert s[0].rule_name == p
@@ -40,19 +44,19 @@
             assert False, "To Do: More"
 
 
-def test_simple_1():	parse_expression(r"abc",	pattern=[X])
-def test_simple_2():	parse_expression(r'A  Bc',	pattern=[X, X])
-
-def test_string_1():	parse_expression(r"'abc'",	pattern=[S])
-def test_regexp_1():	parse_expression(r"/re/",	pattern=[R])
+def test_simple_1():	validate_expression(r"abc",	pattern=[X])
+def test_simple_2():	validate_expression(r'A  Bc',	pattern=[X, X])
 
-def test_mix():		parse_expression(r'/regex/ "string" crossref crossref',	pattern=[R,S, X, X])
+def test_string_1():	validate_expression(r"'abc'",	pattern=[S])
+def test_regexp_1():	validate_expression(r"/re/",	pattern=[R])
 
-def test_sub():		parse_expression(r'( A  B )',	pattern=[(X, X)])
-def test_mix_nosub():	parse_expression(r'/regex/ "string" ( A  B ) crossref',	pattern=[R,S, None, X])
-def test_mix_sub():	parse_expression(r'/regex/ "string" ( A  B ) crossref',	pattern=[R,S, (X, X), X])
+def test_mix():		validate_expression(r'/regex/ "string" crossref crossref',	pattern=[R,S, X, X])
 
-def test_sub_sub():	parse_expression(r'level0 ( level1_1  (level2a level2b ) level1_2) level0', pattern=[X, (X, (X,X), X), X])
+def test_sub():		validate_expression(r'( A  B )',	pattern=[(X, X)])
+def test_mix_nosub():	validate_expression(r'/regex/ "string" ( A  B ) crossref',	pattern=[R,S, None, X])
+def test_mix_sub():	validate_expression(r'/regex/ "string" ( A  B ) crossref',	pattern=[R,S, (X, X), X])
+
+def test_sub_sub():	validate_expression(r'level0 ( level1_1  (level2a level2b ) level1_2) level0', pattern=[X, (X, (X,X), X), X])
 
 
 def test_bug1():	parse_expression(r"""( rule_crossref | term | group | predicate ) ( '?' | '*' | '+' | '#' )?""")

diff -r 5821f8fe1033 -r 5800f73c267c pytst/readers/parser/d2_ast/test_1_term.py
--- a/pytst/readers/parser/d2_ast/test_1_term.py	Fri Feb 11 22:21:13 2022 +0100
+++ b/pytst/readers/parser/d2_ast/test_1_term.py	Fri Feb 11 23:09:00 2022 +0100
@@ -50,9 +50,9 @@
     regex_variants(txt:='''r"""re__rstr_d3"""''', expect=txt[4:-3])
 
 
-def test_term_as_expressions():                                         # A term is **ALSO an expressions
+def test_term_as_expression():                                         # A term is **ALSO an expression
     txt="'a string'"
-    ast = parse(txt, grammar.expressions)
+    ast = parse(txt, grammar.expression)
     # result is same a above
     assert isinstance(ast, peg.Expression),	"A (str)term is also an Expression"
     assert len(ast.value) == 1,			"An expression with length==1"

diff -r 5821f8fe1033 -r 5800f73c267c pytst/readers/parser/d2_ast/test_2_ID.py
--- a/pytst/readers/parser/d2_ast/test_2_ID.py	Fri Feb 11 22:21:13 2022 +0100
+++ b/pytst/readers/parser/d2_ast/test_2_ID.py	Fri Feb 11 23:09:00 2022 +0100
@@ -15,18 +15,18 @@
 
 
 def test_rule_crossref():
-    """The rule's expressions can also refer an ID"""
+    """The rule's expression can also refer an ID"""
 
     txt="aRef"
     ast = parse(txt, grammar.rule_crossref)
     assert_ID(ast, name=txt)
 
 
-def test_ID_as_expressions():
+def test_ID_as_expression():
     """ An ID is also an expression"""
 
     txt="aRef"
-    ast = parse(txt, grammar.expressions)
+    ast = parse(txt, grammar.expression)
 
     assert isinstance(ast, peg.Expression),	"A crossref is also an Expression"
     assert len(ast.value) == 1,			"An expression with length==1"

diff -r 5821f8fe1033 -r 5800f73c267c pytst/readers/parser/d2_ast/test_3_Seq.py
--- a/pytst/readers/parser/d2_ast/test_3_Seq.py	Fri Feb 11 22:21:13 2022 +0100
+++ b/pytst/readers/parser/d2_ast/test_3_Seq.py	Fri Feb 11 23:09:00 2022 +0100
@@ -1,4 +1,4 @@
-"""Test that a sequence of expressions is an Expression()
+"""Test that a kind of  sequence's are Expression()
 """
 
 import pytest

diff -r 5821f8fe1033 -r 5800f73c267c pytst/readers/parser/grammar.peg
--- a/pytst/readers/parser/grammar.peg	Fri Feb 11 22:21:13 2022 +0100
+++ b/pytst/readers/parser/grammar.peg	Fri Feb 11 23:09:00 2022 +0100
@@ -4,15 +4,15 @@
 rules		<-  rule+ ;
 rule		<-  rule_name '<-' expression ';' ;
 
-expression	<-  expressions op_alternative ;
-expressions     <-  single_expr+ ;
+expression	<-  sequence op_alternative ;
+sequence        <-  single_expr+ ;
 single_expr	<-  ( rule_crossref | term | group | predicate )  op_quantity ;
 
 op_alternative  <-  ( '|' expression )? ;
 op_quantity     <-  ( '?' | '*' | '+' | '#' )? ;
 
 term		<-  str_term | regex_term ;
-group		<-  '(' expressions ')' ;
+group		<-  '(' expression ')' ;
 predicate	<-   ( '&' | '!' ) single_expr ;
 
 str_term	<- "'"    str_no_s1  "'"

diff -r 5821f8fe1033 -r 5800f73c267c pytst/writers/python/test_1_rules.py
--- a/pytst/writers/python/test_1_rules.py	Fri Feb 11 22:21:13 2022 +0100
+++ b/pytst/writers/python/test_1_rules.py	Fri Feb 11 23:09:00 2022 +0100
@@ -14,8 +14,3 @@
     id_rn = peg.ID(name="rule_crossref")
     id_xr = peg.ID(name="ID")
 
-    
-##    expressions = peg.Sequence(value=id_xr
-##    rule = peg.Rule(name=id_rn, expr=expressions)
-
-##    Template("""def {{rule.name}}()\treturn{rule.expro