Remove global mutable state from galgebra._utils.parser (#306)

This state is just an artefact of the weird two-stage printer API, and isn't part of the parsing at all.

Author: eric-wieser

galgebra/_utils/parser.py

@@ -1,25 +1,17 @@
 """ A private module to parse multivector expressions """
 import re
+from typing import List
 
-op_cntrct = re.compile(r'(([A-Za-z0-9\_\#]+)(\||<|>)([A-Za-z0-9\_\#]+))')
-op_wedge = re.compile(r'(([A-Za-z0-9\_\#]+)[\^]{1}([A-Za-z0-9\_\#]+)([\^]{1}([A-Za-z0-9\_\#]+))*)')
-ops = r'[\^\|\<\>]+'
-ops_search = re.compile(r'(\^|\||<|>)+')
-parse_paren_calls = 0
-op_dict = {}
-op_lst = []
 
-OPS = {'<>|': r'(([A-Za-z0-9\_\#]+)(\||<|>)([A-Za-z0-9\_\#]+))',
-       '^': r'(([A-Za-z0-9\_\#]+)[\^]{1}([A-Za-z0-9\_\#]+)([\^]{1}([A-Za-z0-9\_\#]+))*)',
-       '*': r'(([A-Za-z0-9\_\#]+)[\*]{1}([A-Za-z0-9\_\#]+)([\*]{1}([A-Za-z0-9\_\#]+))*)'}
+# The `#` character is included because we generate tokens containing it in
+# _parse_paren.
+_operand_re = r"([A-Za-z0-9\_\#]+)"
 
-
-def set_precedence(op_ord: str = '<>|,^,*') -> None:
-    global op_dict, op_lst
-    op_lst = op_ord.split(',')
-    op_dict = {}
-    for op in op_lst:
-        op_dict[op] = re.compile(OPS[op])
+_operator_res = {
+    '<>|': re.compile(r'(ARG(\||<|>)ARG)'.replace('ARG', _operand_re)),
+    '^': re.compile(r'(ARG[\^]ARG([\^]ARG)*)'.replace('ARG', _operand_re)),
+    '*': re.compile(r'(ARG[\*]ARG([\*]ARG)*)'.replace('ARG', _operand_re)),
+}
 
 
 def _contains_interval(interval1, interval2):  # interval1 inside interval2
@@ -29,9 +21,13 @@ def _contains_interval(interval1, interval2):  # interval1 inside interval2
         return False
 
 
+# counter to generate unique tokens
+_parse_paren_calls = 0
+
+
 def _parse_paren(line):
-    global parse_paren_calls
-    parse_paren_calls += 1
+    global _parse_paren_calls
+    _parse_paren_calls += 1
 
     if ('(' not in line) or (')' not in line):
         return [[[line]]]
@@ -82,7 +78,7 @@ def _parse_paren(line):
         for level in level_lst[1:]:
             igroup = 0
             for group in level:
-                token = '#' + str(parse_paren_calls) + '_' + str(ilevel) + '_' + str(igroup) + '#'
+                token = '#' + str(_parse_paren_calls) + '_' + str(ilevel) + '_' + str(igroup) + '#'
                 level_lst[ilevel][igroup].append(line[group[0]:group[1] + 1])
                 level_lst[ilevel][igroup].append(token)
                 igroup += 1
@@ -150,17 +146,21 @@ def _add_paren(line, re_exprs):
     return line
 
 
-def parse_line(line: str) -> str:
-    global op_lst, op_dict
+def validate_op_order(op_order: List[str]) -> None:
+    if not all(op in _operator_res for op in op_order):
+        raise ValueError("Illegal operator")
+
+
+def parse_line(line: str, op_order: List[str]) -> str:
     line = line.replace(' ', '')
     level_lst = _parse_paren(line)
     ilevel = 0
     for level in level_lst:
         igroup = 0
         for group in level:
             string = group[-1]
-            for op in op_lst:
-                string = _add_paren(string, op_dict[op])
+            for op in op_order:
+                string = _add_paren(string, _operator_res[op])
             level_lst[ilevel][igroup][-1] = string
             igroup += 1
         ilevel += 1

galgebra/printer.py

@@ -1182,7 +1182,8 @@ def Print_Function():
     return
 
 
-global_dict = {}
+_eval_global_dict = {}
+_eval_parse_order = []
 
 
 def def_prec(gd: dict, op_ord: str = '<>|,^,*') -> None:
@@ -1197,9 +1198,11 @@ def def_prec(gd: dict, op_ord: str = '<>|,^,*') -> None:
         The order of operator precedence from high to low with groups of equal precedence separated by commas.
         The default precedence, ``'<>|,^,*'``, is that used by Hestenes (:cite:`Hestenes`, p7, :cite:`Doran`, p38).
     """
-    global global_dict
-    global_dict = gd
-    _parser.set_precedence(op_ord)
+    global _eval_global_dict, _eval_parse_order
+    op_ord = op_ord.split(',')
+    _parser.validate_op_order(op_ord)
+    _eval_global_dict = gd
+    _eval_parse_order = op_ord
 
 
 def GAeval(s: str, pstr: bool = False):
@@ -1219,11 +1222,11 @@ def GAeval(s: str, pstr: bool = False):
         enforce operator precedence are printed.
     """
 
-    seval = _parser.parse_line(s)
+    seval = _parser.parse_line(s, _eval_parse_order)
     if pstr:
         print(s)
         print(seval)
-    return eval(seval, global_dict)
+    return eval(seval, _eval_global_dict)
 
 
 r"""