Implementing grammars and adding example ContextFree Grammars

Author: Jonathon Ian Belotti

grammars/contextFree.py

@@ -1,3 +1,17 @@
+from unrestricted import UnrestrictedGrammar
+from contextSensitive import ContextSensitiveGrammar
+from grammar import isVariable
+
+class ContextFreeGrammar(ContextSensitiveGrammar):
+
+    def validRule(self, r ):
+        if not super(ContextFreeGrammar, self).validRule(r):
+            if r.rhs: return False
+        elif len(r.lhs) != 1 or not isVariable(r.lhs[0]):
+            return False
+        return True
+
+
 """
 Algorithm 4.2.1
 Construction of the Set of Nullable Variables

grammars/contextSensitive

@@ -0,0 +1,11 @@
+from unrestricted import UnrestrictedGrammar
+
+
+class ContextSensitiveGrammar(UnrestrictedGrammar):
+
+    def validRule(self, r ):
+        if not super(ContextFreeGrammar, self).validRule(r):
+            return False
+        elif len(r.rhs) < len(r.lhs):
+            return False
+        return True

grammars/contextSensitive.py

@@ -0,0 +1,49 @@
+from contextFree import ContextFreeGrammar
+from grammar import Rule
+
+def buildCFGWithChainRules():
+    g = ContextFreeGrammar()
+    rules = []
+    rules.extend( Rule(["A"],["a"]), Rule(["A"],["a","A"]), Rule(["A"],["B"]))
+    rules.extend( Rule(["B"],["b","B"]), Rule(["B"],["b"]), Rule(["B"],["C"]))
+    g.addRules(rules)
+    return g
+
+def buildCFGWtihNullableVars():
+    g = ContextFreeGrammar()
+    rules = []
+    rules.extend( Rule(["S"],["A","C","A"]), Rule(["A"],["a","A","a"]))
+    rules.extend( Rule(["A"],["B"]), Rule(["A"],["C"]), Rule(["B"],["b","B"]))
+    rules.extend( Rule(["B"],["b"]), Rule(["C"],["c","C"]), Rule(["C"],[]))
+    g.addRules(rules)
+    return g
+
+def buildCFGWithRecursiveStartSymbol():
+    g = ContextFreeGrammar()
+    rules = []
+    rules.extend( Rule(["S"],["a","S"]), Rule(["S"],["A","B"]), Rule(["S"],["A","C"]))
+    rules.extend( Rule(["A"],["a","A"]), Rule(["A"],[]), Rule(["B"],["b","B"]))
+    rules.extend( Rule(["B"],["b","S"]), Rule(["C"],["c","C"]), Rule(["C"],[]))
+    g.addRules(rules)
+    return g
+
+def buildCFGWithVarsThatDontDeriveTerminalStrings():
+    g = ContextFreeGrammar()
+    rules = []
+    rules.extend( Rule(["S"],["A","C"]), Rule(["S"],["B","S"]), Rule(["S"],["B"]))
+    rules.extend( Rule(["A"],["a","A"]), Rule(["A"],["a","F"]), Rule(["B"],["C","F"]))
+    rules.extend( Rule(["B"],["b"]), Rule(["C"],["c","C"]), Rule(["C"],["D"]))
+    rules.extend( Rule(["D"],["a","D"]), Rule(["D"],["B","D"]), Rule(["D"],["C"]))
+    rules.extend( Rule(["E"],["a","A"]), Rule(["E"],["B","S","A"]), Rule(["F"],["b","B"]))
+    rules.extend( Rule(["F"],["b"]))
+    g.addRules(rules)
+    return g
+
+def buildCFGForReachableVars:
+    g = ContextFreeGrammar()
+    rules = []
+    rules.extend( Rule(["S"],["B","S"]), Rule(["S"],["B"]), Rule(["A"],["a","A"]))
+    rules.extend( Rule(["A"],["a","F"]), Rule(["B"],["b"]), Rule(["E"],["a","A"]))
+    rules.extend( Rule(["E"],["B","S","A"]), Rule(["F"],["b","B"]), Rule(["F"],["b"]))
+    g.addRules(rules)
+    return g

grammars/factories/contextFreeFactory.py

@@ -0,0 +1,21 @@
+
+STARTSYMBOL = "S"
+ALT_STARTSYMBOL = "S`"
+
+def isVariable( elem ):
+    return True if elem.isupper() else (True if elem == ALT_STARTSYMBOL else False)
+
+def isTerminal( elem ):
+    return True if elem.isLower() else False
+
+class Rule(object):
+
+    def __init__(self, lhs, rhs=None):
+        self.lhs = lhs.split(",")
+        self.rhs = rhs.split(",")
+
+    def __str__(self):
+        if(self.rhs):
+            return " ".join(self.lhs) + " -> " + " ".join(self.rhs)
+        else:
+            return " ".join(self.lhs) + " -> null"

grammars/grammar.py

@@ -0,0 +1,15 @@
+from contextFree import ContextFreeGrammar
+from grammar import isVariable, isTerminal
+
+class RegularGrammar(ContextFreeGrammar):
+
+    def validRule(self, r ):
+        if not super(RegularGrammar, self).validRule(r):
+            return False
+        elif not r.rhs: # rhs is null - valid
+            return True
+        elif len(r.rhs) == 2 and isTerminal(r.rhs[0]) and isVariable(r.rhs[1]):
+            return True
+        elif len(r.rhs) == 1 and isTerminal(r.lhs[0]):
+            return True
+        return False

grammars/regular.py

@@ -0,0 +1 @@
+

grammars/rule.py

@@ -0,0 +1,45 @@
+from grammar import isVariable, isTerminal, STARTSYMBOL, ALT_STARTSYMBOL
+
+class UnrestrictedGrammar(object):
+
+    def __init__(self):
+        self.rules = []
+        self.vars = set()
+        self.terminals = set()
+
+    def __str__(self):
+        output = ""
+        output += "VARIABLES: " + ",".join(self.vars) + '\n'
+        output += "TERMINALS: " + ",".join(self.terminals) + '\n'
+        output += "RULES: " + '\n' + [(str(rule) + '\n') for rule in self.rules]
+        return output
+
+    def addRules( rules ):
+        if all(validRule(r) for r in rules):
+            self.rules.extend(rules)
+            return True
+        else:
+            return False
+
+    def addRule( self, r ):
+        if validRule(r):
+            self.rules.append(r)
+            return True
+        else: return False
+
+    def validRule( self, r ):
+        if r.lhs: return True
+        else: return False
+
+    def updateVarsAndTerminals(self, rule=None):
+        if rule:
+            self.vars.update([x for x in (rule.lhs + rule.rhs) if isVariable(x)])
+            self.terminals.update([x for x in (rule.lhs + rule.rhs) if isTerminal(x)])
+        else:
+            self.vars = set()
+            self.terminals = set()
+            for r in self.rules:
+                updateVarsAndTerminals(self, rule=r)
+
+    def getStartSymbol(self):
+        return ALT_STARTSYMBOL if ALT_STARTSYMBOL in self.vars else STARTSYMBOL