提交: b7dd492c2c77fcae68e6a5668eb1d5a841189628 - CCastle2 (hg)

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

Commit MetaInfo

• 修訂: b7dd492c2c77fcae68e6a5668eb1d5a841189628 (tree)
• 時間: 2022-02-12 06:15:35
• 作者: Albert Mietus < albert AT mietus DOT nl >
• Commiter: Albert Mietus < albert AT mietus DOT nl >

Log Message

AST-2-XML:: OrderedChoice (alternativies) works

Change Summary

• modified: castle/ast/ast2xml.py
• modified: castle/readers/parser/visitor.py
• modified: pytst/ast/XML_serialization/__init__.py
• modified: pytst/ast/XML_serialization/test_1_simpleXML.py
• modified: pytst/readers/parser/grammar.peg

差異

diff -r a27eaba4f334 -r b7dd492c2c77 castle/ast/ast2xml.py
--- a/castle/ast/ast2xml.py	Fri Feb 11 20:19:22 2022 +0100
+++ b/castle/ast/ast2xml.py	Fri Feb 11 22:15:35 2022 +0100
@@ -81,6 +81,11 @@
     def ZeroOrMore2xml(self, ast, parent): 	self._quantity_op(ast, parent, 'ZeroOrMore')
     def OneOrMore2xml(self, ast, parent): 	self._quantity_op(ast, parent, 'OneOrMore')
 
+    def OrderedChoice2xml(self, ast, parent) ->None:
+        oc = ET.SubElement(parent, 'OrderedChoice')
+        for c in ast:
+            self._ast2xml(c,oc)
+
 #############
 
 ##    def Setting2xml(self, ast, parent) ->None:
@@ -92,7 +97,7 @@
 
 
 
-#    def OrderedChoice 2xml(self, ast, parent) ->None: ...
+
 #    def AndPredicate2xml(self, ast, parent) ->None: ...
 #    def NotPredicate2xml(self, ast, parent) ->None: ...
 

diff -r a27eaba4f334 -r b7dd492c2c77 castle/readers/parser/visitor.py
--- a/castle/readers/parser/visitor.py	Fri Feb 11 20:19:22 2022 +0100
+++ b/castle/readers/parser/visitor.py	Fri Feb 11 22:15:35 2022 +0100
@@ -17,7 +17,8 @@
 #NO_VISITOR_NEEDED: visit_term
 #NO_VISITOR_NEEDED: visit_re_no_slash
 #NO_VISITOR_NEEDED: visit_group
-#NO_VISITOR_NEEDED: visit_op_quantity -- handle in visit_single_expr
+#NO_VISITOR_NEEDED: visit_op_quantity		-- handled in visit_single_expr
+#NO_VISITOR_NEEDED: visit_op_alternative	-- handled in visit_expression
 
 class PegVisitor(arpeggio.PTNodeVisitor):
     def _logstr_node_children(self, node, children):
@@ -64,19 +65,12 @@
             raise  NotImplementedError("visit_single_expr, len>2")      # XXX -- Is this possible?
 
 
-    def visit_expression(self, node, children):                  # ( expressions, op_alternatives )
+    def visit_expression(self, node, children):                  # expression <- expressionS, op_alternative; op_alternative <- ('|' expression)?
         logger.debug('visit_expression::' + self._logstr_node_children(node, children))
         if len(children) == 1: #Only expressions
             return children[0]
-        elif len(children) == 2: # So, having with alternatives
-            # The 1st kid is a peg.Sequence ``expr``
-            # The 2nd kid can be a
-            # - peg.Sequence  `` | expr ``, OR
-            # - peg.OrderedChoice  `` | expr | expr``
+        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.
-#           return peg.OrderedChoice(children = ((children[0].value,) +
-#                                                children[1]._childeren if isinstance(children[1], peg.OrderedChoice) else children[1].value), #XXX HACK
-#                                    parse_tree=node)
             if isinstance(children[1], peg.OrderedChoice):
                 alternatives = [children[0]] + [alt for alt in children[1]]
             else:

diff -r a27eaba4f334 -r b7dd492c2c77 pytst/ast/XML_serialization/__init__.py
--- a/pytst/ast/XML_serialization/__init__.py	Fri Feb 11 20:19:22 2022 +0100
+++ b/pytst/ast/XML_serialization/__init__.py	Fri Feb 11 22:15:35 2022 +0100
@@ -20,28 +20,32 @@
         assert_xml_Element(txt, tag='.//RegExpTerm', value=self.v3)
 
 
-def assert_xml_Element(txt, tag,
-                       version="0.0",
-                       **attribs,):
+def assert_xml_Element(txt, tag, version="0.0", child_count=None, **attribs,):
     """Partially verify an xml-string; focusing on 'tag' -- a real tag, or a (limited) XPATH-expression.
 
     This `tag` (expression) should result in a single hit!. *Use e.g `[0]` as suffix to select one from a list*.
-    Pass ``key=value`` **attribs** to verify the found tag has those attribs and values
-    """
+    Pass ``key=value`` **attribs** to verify the found tag has those attribs and values."""
 
     tree = ET.fromstring(txt)
     if version:
         assert tree.attrib['version'] == version
+
     founds = tree.findall(tag)
     assert len(founds) == 1, f"Expected only one element; got: {len(founds)} :{founds}"
+
     found = founds[0]
     logger.debug(f'XXX1 tag={tag}:: found={found}')
+
     for attrib, value in attribs.items():
         logger.debug(f'XXX2 tag={tag}:: attrib={attrib}, value={value}')
         assert found.attrib[attrib] == value
 
+    if child_count:
+        assert len(found) == child_count, f"The number of children of '{tag}' is {len(found)}, which does not match the specified child_count={child_count}"
 
-def assert_QuantityGroup(xml_serialize, pegGrp, tagName):
+
+
+def verify_QuantityGroup(xml_serialize, pegGrp, tagName):
     seq = StdSequence_withAsserts()
     txt = xml_serialize(pegGrp(expr=seq.seq))
     logger.debug(f'XML:: {txt}')
@@ -49,7 +53,8 @@
     assert_xml_Element(txt, tagName)
     seq.assert_xml_Element(txt)
 
-def assert_QuantityID(xml_serialize, pegGrp, tagName, id_name='JustAName'):
+
+def verify_QuantityID(xml_serialize, pegGrp, tagName, id_name='JustAName'):
     txt = xml_serialize(pegGrp(expr=peg.ID(name=id_name)))
     logger.debug(f'XML:: {txt}')
 

diff -r a27eaba4f334 -r b7dd492c2c77 pytst/ast/XML_serialization/test_1_simpleXML.py
--- a/pytst/ast/XML_serialization/test_1_simpleXML.py	Fri Feb 11 20:19:22 2022 +0100
+++ b/pytst/ast/XML_serialization/test_1_simpleXML.py	Fri Feb 11 22:15:35 2022 +0100
@@ -4,7 +4,7 @@
 
 from castle.ast import  peg, serialization
 
-from . import StdSequence_withAsserts, assert_xml_Element, assert_QuantityGroup, assert_QuantityID
+from . import StdSequence_withAsserts, assert_xml_Element, verify_QuantityGroup, verify_QuantityID
 
 
 @pytest.fixture
@@ -84,24 +84,29 @@
     assert  tree.findall('.//Rule[2]//StrTerm')[0].attrib['value'] == 'str2'
 
 
-def test_OptionalSeq(xml_serialize):   assert_QuantityGroup(xml_serialize, peg.Optional, 'Optional')  			##  ` ( ...)? `
-def test_ZeroOrMoreSeq(xml_serialize): assert_QuantityGroup(xml_serialize, peg.ZeroOrMore, 'ZeroOrMore')		##  ` ( ...)* `
-def test_OneOrMoreSeq(xml_serialize):  assert_QuantityGroup(xml_serialize, peg.OneOrMore, 'OneOrMore')			##  ` ( ...)+ `
-def test_UnorderedGroup(xml_serialize): assert_QuantityGroup(xml_serialize, peg.UnorderedGroup, 'UnorderedGroup')  	##  ` ( ...)# ` # Only useful for a group/sequence!!
+def test_OptionalSeq(xml_serialize):    verify_QuantityGroup(xml_serialize, peg.Optional, 'Optional')  			##  ` ( ...)? `
+def test_ZeroOrMoreSeq(xml_serialize):  verify_QuantityGroup(xml_serialize, peg.ZeroOrMore, 'ZeroOrMore')		##  ` ( ...)* `
+def test_OneOrMoreSeq(xml_serialize):   verify_QuantityGroup(xml_serialize, peg.OneOrMore, 'OneOrMore')			##  ` ( ...)+ `
+def test_UnorderedGroup(xml_serialize): verify_QuantityGroup(xml_serialize, peg.UnorderedGroup, 'UnorderedGroup')  	##  ` ( ...)# ` # Only useful for a group/sequence!!
+
+def test_OptionalID(xml_serialize):    verify_QuantityID(xml_serialize, peg.Optional, 'Optional')
+def test_ZeroOrMoreID(xml_serialize):  verify_QuantityID(xml_serialize, peg.ZeroOrMore, 'ZeroOrMore')
+def test_OneOrMoreID(xml_serialize):   verify_QuantityID(xml_serialize, peg.OneOrMore, 'OneOrMore')
+def test_UnorderedID(xml_serialize):   verify_QuantityID(xml_serialize, peg.UnorderedGroup, 'UnorderedGroup', 'strange') ## A bit uncommon: an unordered group of ONE! But it should work.
 
 
-def test_OptionalID(xml_serialize):   assert_QuantityID(xml_serialize, peg.Optional, 'Optional')
-def test_ZeroOrMoreID(xml_serialize): assert_QuantityID(xml_serialize, peg.ZeroOrMore, 'ZeroOrMore')
-def test_OneOrMoreID(xml_serialize):  assert_QuantityID(xml_serialize, peg.OneOrMore, 'OneOrMore')
-## A bit uncommon: unordered group  of ONE  :`` Always#`` but it should work
-def test_UnorderedID(xml_serialize):  assert_QuantityID(xml_serialize, peg.UnorderedGroup, 'UnorderedGroup', 'strange')
+def test_OC3(xml_serialize): # e1 | e2 | e2
+    e1, e2, e3 = peg.ID(name='ID_1'), peg.StrTerm(value='str_2'), peg.RegExpTerm(value='regexp_3')
+    txt = xml_serialize(peg.OrderedChoice(children=[e1,e2,e3]))
+    logger.debug(f'XML:: {txt}')
+
+    assert_xml_Element(txt, tag='OrderedChoice', child_count=3)
 
 
[e-mail](reason="Can't test as peg.OrderedChoice() isn't implemented")
-def test_OrderedChoice(xml_serialize): # e1 | e2 | e2
-    e1 = peg.ID(name='ID_1')
-    e2 = peg.StrTerm(value='str_2')
-    e3 = peg.RegExpTerm(value='regexp_3')
-    txt = xml_serialize(peg.OrderedChoice())                            # not implemented; never peg.OrderedChoice is never called
+def test_OC_long(xml_serialize): # e1 | e2a e2b e2c
+    e1, seq = peg.ID(name='single_ID'), StdSequence_withAsserts()
+    txt = xml_serialize(peg.OrderedChoice(children=[e1, seq.seq]))
+    logger.debug(f'XML:: {txt}')
 
-    assert False
+    assert_xml_Element(txt, tag='OrderedChoice', child_count=2)
+

diff -r a27eaba4f334 -r b7dd492c2c77 pytst/readers/parser/grammar.peg
--- a/pytst/readers/parser/grammar.peg	Fri Feb 11 20:19:22 2022 +0100
+++ b/pytst/readers/parser/grammar.peg	Fri Feb 11 22:15:35 2022 +0100
@@ -2,10 +2,14 @@
 
 peg_grammar	<-  rules ;
 rules		<-  rule+ ;
-rule		<-  rule_name '<-' expressions ';' ;
+rule		<-  rule_name '<-' expression ';' ;
 
-expressions	<-  single_expr+ ( '|' expressions )? ;
-single_expr	<-  ( rule_crossref | term | group | predicate ) ( '?' | '*' | '+' | '#' )? ;
+expression	<-  expressions op_alternative ;
+expressions     <-  single_expr+ ;
+single_expr	<-  ( rule_crossref | term | group | predicate )  op_quantity ;
+
+op_alternative  <-  ( '|' expression )? ;
+op_quantity     <-  ( '?' | '*' | '+' | '#' )? ;
 
 term		<-  str_term | regex_term ;
 group		<-  '(' expressions ')' ;