Changeset 106:3ed5f8f4f9fc

Timestamp:

02/20/10 14:33:55 (7 months ago)

Author:

Roger Gammans <rgammans@…>

Branch:

right-recursive-macro-grammar

Message:

A right-recursive version of our grammar which allows Expr to used as literals.

In my opinion at the moment this is a dead-end , as the grammar is
ambigous with the extensions to the query op to allow expression
in all places. Additionally I don't think this ambiguity wins us
anything in practice as I can't imagine where we would use it.

However I'm committed it as a dead-head in case it becomes usefiul
later

Files:

• MysteryMachine/parsetools/grammar.py (modified) (4 diffs)
• tests/grammarTest.py (modified) (3 diffs)

MysteryMachine/parsetools/grammar.py

@@ -2 +2 @@
 
 ###Grammar stuff
-from pyparsing import  Regex,Optional,ZeroOrMore, QuotedString , Literal, Word, alphas , nums , printables  , CharsNotIn , stringEnd
+from pyparsing import Group, Forward,Regex,Optional,ZeroOrMore, QuotedString , Literal, Word, alphas , nums ,  CharsNotIn , stringEnd
 from functools import partial
 
@@ -26 +26 @@
 
 ExprLimit  =   Regex("[^ \n\t]*[ \n\t]")
-Value      =   QuotedString('"') 
+LiteralVal =   QuotedString('"') 
+
+def outparseState(s,loc,toks):
+    print s,loc,toks
+    return toks
+
+class BoolPartVal:
+    """
+    Store the left hand part of a bool expr for later evalation.
+    """
+    def  __init__(self,op,value,*args):
+        self.opsense = (op == "!=")
+        self.value   = value
+
+    def cmp(self,ovalue):
+        return self.opsense ^ (self.value == ovalue)
+
+
+class QueryExprVal:
+    """
+    Store the left hand part of a query expr for later evalution.
+    """
+    def  __init__(self,boolpart,query,tval,seperator,fval,*args):
+        self.boolpart = boolpart
+        self.tval     = tval
+        self.fval     = fval
+        assert(query == "?")
+        assert(seperator == "/")
+
+    def eval(self,oval):
+        if self.boolpart.cmp(oval):
+            return self.tval
+        else: return self.fval
+
+def EvalExpr(s,loc,toks):
+    """
+    Walk down a list of query expression resovling them as we go
+    """    
+    c=toks[0]
+    for q in toks[1:]:
+        c=q.eval(c)
+    return c
+
+
+def getField(s,loc,toks):
+        modlogger.debug( "getField(%s)\n" % toks)
+        field=toks[2]
+        obj=toks[0]
+        return obj[field]
 
 
@@ -36 +84 @@
 
     NamedField  =   ObjectUID + seperator +fieldName
-    ExprField   =   ObjectUID ^  \
-                NamedField
 
-    BoolExpr   =    ExprField + cfoperator + Value.copy() 
-    QueryExpr  =    BoolExpr + queryOp + Value.copy() + "/" +Value.copy()
+    LValue     =    Forward()
 
-    ExprText   =    ExprField ^ \
-                QueryExpr
+    ExprField   =   ObjectUID ^ \
+                    NamedField
 
-    #Error      =   openExpr + ExprLimit 
+    #"""
 
-    #These production are about handling expressions
-    # in run of text. The use is mainly historical.
-    Expr       =   openExpr + ExprText + closeExpr
+    LToken      =   LiteralVal ^ \
+                    ExprField
 
-    textEle    =   NonExpr  ^ \
-                   Expr 
-       
-    text       =   ZeroOrMore(textEle)
+    BoolPart    =   cfoperator + LValue.copy()
+    QueryExpr   =   BoolPart  + queryOp + LValue.copy() + "/" + LValue.copy()
+    ExprText    =   LToken + ZeroOrMore(QueryExpr)
+    LValue      <<  ( ExprText ^ LToken )
 
 
+    BoolPart.setParseAction(lambda s,loc,toks:BoolPartVal(*toks))
+    QueryExpr.setParseAction(lambda s,loc,toks:QueryExprVal(*toks))
+    ExprText.setParseAction(EvalExpr)
     ## Functions for parsing.
-
-    def getField(s,loc,toks):
-        modlogger.debug( "getField(%s)\n" % toks)
-        field=toks[2]
-        obj=toks[0]
-        return obj[field]
-
-
-    def doBool(s,loc,toks):
-        modlogger.debug( "getbol\n")
-        sense=(toks[1]=="!=")
-        return sense ^ ( str(toks[0]) == toks[2])
-
-
-    def doQuery(s,loc,toks):
-        modlogger.debug( "doing query\n")
-        if toks[0]:
-                return toks[2]
-        else:
-                return toks[4]
 
     def initFromParse(s,loc,toks):
@@ -86 +113 @@
         else:              return home.get_root().get_object(toks[0],toks[2])
 
-    #def gotError(s,loc,toks):
-    #   sys.stderr.write("BARR")
-
-    ## Bind functions to parse actions
     
     NamedField.setParseAction(getField)
-
-    BoolExpr.setParseAction(doBool)
-    QueryExpr.setParseAction(doQuery)
-    Expr.setParseAction(lambda s,loc,tok:tok[1])
-    #Error.setParseAction(gotError)
-
     ObjectUID.setParseAction(initFromParse)
     
+    ExprText.enablePackrat() 
+    ExprText.validate() 
     return ExprText + stringEnd
+
+
+if __name__ == "__main__":
+    f = Grammar(None)
+    print f.parseString(":name=\"X\"?\"Y\"/\"Z\"")
+    #This is ambigous the second query could be have he first as it paramater
+    # or be inside he final element of the first.
+    print f.parseString(":name=\"X\"?\"Y\"/\"Z\"=\"Z\"?\"R\"/\"S\"")

tests/grammarTest.py

@@ -19 +19 @@
 # 
 """
-Tests for the MysteryMachine.VersionNr class
+Tests for the MysteryMachine.parsetools.gramar file
 """
 
-from MysteryMachine import * 
 from MysteryMachine.parsetools.grammar import Grammar
  
@@ -61 +60 @@
 class GraamarTest(unittest.TestCase):
     def setUp(self):
-        StartApp(["--cfgengine=ConfigDict", "--cfgfile=test.cfg", "--testmode"]) 
-        self.parserA=Grammar( ObjectProxy( name="TestName",  title="A Title") )
+        self.A = ( ObjectProxy( name="TestName",  title="A Title", yes="YEAH!", no="Nope") )
+        self.parserA=Grammar( self.A )
         self.parserB=Grammar( ObjectProxy( name="WrongName", title="A Title") )
 
@@ -92 +91 @@
         self.assertEqual(helper(self.parserA,":name=\"TestName\"?\"Yes\"/\"No\""),"Yes")
         self.assertEqual(helper(self.parserA,":name=\"WrongName\"?\":Yes\"/\"No\""),"No")
+        #Now check with different lvalues..
+        self.assertEqual(helper(self.parserA,":name=\"TestName\"?:yes/:no"),"YEAH!")
+        self.assertEqual(helper(self.parserA,":name=\"WrongName\"?:yes/:no"),"Nope")
+        self.assertEqual(helper(self.parserA,":name=:title?:yes/:no"),"Nope")
+        #Check Not equals
+        self.assertEqual(helper(self.parserA,":name!=\"WrongName\"?:yes/:no"),"YEAH!")
+
 
     # Test handling of parse errors.