Remove rule and library from the expression grammar.

1 files changed, 47 insertions, 52 deletions

diff --git a/scss/expression.py b/scss/expression.py
index e701185..4aa677f 100644
--- a/scss/expression.py
+++ b/scss/expression.py
@@ -68,9 +68,9 @@ def eval_expr(expr, rule, library, raw=False):
             results = expr_cache[expr]
         else:
             try:
-                P = Calculator(CalculatorScanner(), library)
+                P = Calculator(CalculatorScanner())
                 P.reset(expr)
-                results = P.goal(rule)
+                results = P.goal()
                 results = results.evaluate(rule, library)
             except SyntaxError:
                 if config.DEBUG:
@@ -368,120 +368,120 @@ class CalculatorScanner(CachedScanner):
 
 
 class Calculator(Parser):
-    def goal(self, R):
-        expr_lst = self.expr_lst(R)
+    def goal(self):
+        expr_lst = self.expr_lst()
         v = expr_lst
         END = self._scan('END')
         return v
 
-    def expr(self, R):
-        and_test = self.and_test(R)
+    def expr(self):
+        and_test = self.and_test()
         v = and_test
         while self._peek(self.expr_rsts) == 'OR':
             OR = self._scan('OR')
-            and_test = self.and_test(R)
+            and_test = self.and_test()
             v = AnyOp(v, and_test)
         return v
 
-    def and_test(self, R):
-        not_test = self.not_test(R)
+    def and_test(self):
+        not_test = self.not_test()
         v = not_test
         while self._peek(self.and_test_rsts) == 'AND':
             AND = self._scan('AND')
-            not_test = self.not_test(R)
+            not_test = self.not_test()
             v = AllOp(v, not_test)
         return v
 
-    def not_test(self, R):
+    def not_test(self):
         _token_ = self._peek(self.not_test_rsts)
         if _token_ != 'NOT':
-            comparison = self.comparison(R)
+            comparison = self.comparison()
             return comparison
         else:  # == 'NOT'
             NOT = self._scan('NOT')
-            not_test = self.not_test(R)
+            not_test = self.not_test()
             return NotOp(not_test)
 
-    def comparison(self, R):
-        a_expr = self.a_expr(R)
+    def comparison(self):
+        a_expr = self.a_expr()
         v = a_expr
         while self._peek(self.comparison_rsts) in self.comparison_chks:
             _token_ = self._peek(self.comparison_chks)
             if _token_ == 'LT':
                 LT = self._scan('LT')
-                a_expr = self.a_expr(R)
+                a_expr = self.a_expr()
                 v = BinaryOp(operator.lt, v, a_expr)
             elif _token_ == 'GT':
                 GT = self._scan('GT')
-                a_expr = self.a_expr(R)
+                a_expr = self.a_expr()
                 v = BinaryOp(operator.gt, v, a_expr)
             elif _token_ == 'LE':
                 LE = self._scan('LE')
-                a_expr = self.a_expr(R)
+                a_expr = self.a_expr()
                 v = BinaryOp(operator.le, v, a_expr)
             elif _token_ == 'GE':
                 GE = self._scan('GE')
-                a_expr = self.a_expr(R)
+                a_expr = self.a_expr()
                 v = BinaryOp(operator.ge, v, a_expr)
             elif _token_ == 'EQ':
                 EQ = self._scan('EQ')
-                a_expr = self.a_expr(R)
+                a_expr = self.a_expr()
                 v = BinaryOp(operator.eq, v, a_expr)
             else:  # == 'NE'
                 NE = self._scan('NE')
-                a_expr = self.a_expr(R)
+                a_expr = self.a_expr()
                 v = BinaryOp(operator.ne, v, a_expr)
         return v
 
-    def a_expr(self, R):
-        m_expr = self.m_expr(R)
+    def a_expr(self):
+        m_expr = self.m_expr()
         v = m_expr
         while self._peek(self.a_expr_rsts) in self.a_expr_chks:
             _token_ = self._peek(self.a_expr_chks)
             if _token_ == 'ADD':
                 ADD = self._scan('ADD')
-                m_expr = self.m_expr(R)
+                m_expr = self.m_expr()
                 v = BinaryOp(operator.add, v, m_expr)
             else:  # == 'SUB'
                 SUB = self._scan('SUB')
-                m_expr = self.m_expr(R)
+                m_expr = self.m_expr()
                 v = BinaryOp(operator.sub, v, m_expr)
         return v
 
-    def m_expr(self, R):
-        u_expr = self.u_expr(R)
+    def m_expr(self):
+        u_expr = self.u_expr()
         v = u_expr
         while self._peek(self.m_expr_rsts) in self.m_expr_chks:
             _token_ = self._peek(self.m_expr_chks)
             if _token_ == 'MUL':
                 MUL = self._scan('MUL')
-                u_expr = self.u_expr(R)
+                u_expr = self.u_expr()
                 v = BinaryOp(operator.mul, v, u_expr)
             else:  # == 'DIV'
                 DIV = self._scan('DIV')
-                u_expr = self.u_expr(R)
+                u_expr = self.u_expr()
                 v = BinaryOp(operator.div, v, u_expr)
         return v
 
-    def u_expr(self, R):
+    def u_expr(self):
         _token_ = self._peek(self.u_expr_rsts)
         if _token_ == 'SIGN':
             SIGN = self._scan('SIGN')
-            u_expr = self.u_expr(R)
+            u_expr = self.u_expr()
             return UnaryOp(operator.neg, u_expr)
         elif _token_ == 'ADD':
             ADD = self._scan('ADD')
-            u_expr = self.u_expr(R)
+            u_expr = self.u_expr()
             return UnaryOp(operator.pos, u_expr)
         else:  # in self.u_expr_chks
-            atom = self.atom(R)
+            atom = self.atom()
             return atom
 
-    def atom(self, R):
+    def atom(self):
         _token_ = self._peek(self.u_expr_chks)
         if _token_ == 'LPAR':
             LPAR = self._scan('LPAR')
-            expr_lst = self.expr_lst(R)
+            expr_lst = self.expr_lst()
             RPAR = self._scan('RPAR')
             return expr_lst
         elif _token_ == 'ID':
@@ -492,7 +492,7 @@ class Calculator(Parser):
             v = ArgspecLiteral([])
             LPAR = self._scan('LPAR')
             if self._peek(self.atom_rsts) != 'RPAR':
-                argspec = self.argspec(R)
+                argspec = self.argspec()
                 v = argspec
             RPAR = self._scan('RPAR')
             return CallOp(FNCT, v)
@@ -518,16 +518,16 @@ class Calculator(Parser):
             VAR = self._scan('VAR')
             return Variable(VAR)
 
-    def argspec(self, R):
-        argspec_item = self.argspec_item(R)
+    def argspec(self):
+        argspec_item = self.argspec_item()
         v = [argspec_item]
         while self._peek(self.argspec_rsts) == 'COMMA':
             COMMA = self._scan('COMMA')
-            argspec_item = self.argspec_item(R)
+            argspec_item = self.argspec_item()
             v.append(argspec_item)
         return ArgspecLiteral(v)
 
-    def argspec_item(self, R):
+    def argspec_item(self):
         var = None
         if self._peek(self.argspec_item_rsts) == 'VAR':
             VAR = self._scan('VAR')
@@ -535,23 +535,23 @@ class Calculator(Parser):
                 self._scan('":"')
                 var = VAR
             else: self._rewind()
-        expr_slst = self.expr_slst(R)
+        expr_slst = self.expr_slst()
         return (var, expr_slst)
 
-    def expr_lst(self, R):
-        expr_slst = self.expr_slst(R)
+    def expr_lst(self):
+        expr_slst = self.expr_slst()
         v = [expr_slst]
         while self._peek(self.expr_lst_rsts) == 'COMMA':
             COMMA = self._scan('COMMA')
-            expr_slst = self.expr_slst(R)
+            expr_slst = self.expr_slst()
             v.append(expr_slst)
         return ListLiteral(v) if len(v) > 1 else v[0]
 
-    def expr_slst(self, R):
-        expr = self.expr(R)
+    def expr_slst(self):
+        expr = self.expr()
         v = [expr]
         while self._peek(self.expr_slst_rsts) not in self.expr_lst_rsts:
-            expr = self.expr(R)
+            expr = self.expr()
             v.append(expr)
         return ListLiteral(v, comma=False) if len(v) > 1 else v[0]
 
@@ -577,11 +577,6 @@ class Calculator(Parser):
 
     expr_lst_rsts_ = None
 
-    def __init__(self, scanner, library):
-        self._library = library
-        super(Calculator, self).__init__(scanner)
-
-
 ### Grammar ends.
 ################################################################################