Merge pull request #1003 from mathics/assignnamepattern

Extends Protect and Unprotect to include string patterns

Author: rocky

mathics/builtin/assignment.py

@@ -17,6 +17,28 @@
 from mathics.core.definitions import PyMathicsLoadException
 
 
+def repl_pattern_by_symbol(expr):
+    leaves = expr.get_leaves()
+    if len(leaves) == 0:
+        return expr
+
+    headname = expr.get_head_name()
+    if headname == "System`Pattern":
+        return leaves[0]
+
+    changed = False
+    newleaves = []
+    for leave in leaves:
+        l = repl_pattern_by_symbol(leave)
+        if not(l is leave):
+            changed = True
+        newleaves.append(l)
+    if changed:
+        return Expression(headname,*newleaves)
+    else:
+        return expr
+
+
 def get_symbol_list(list, error_callback):
     if list.has_form('List', None):
         list = list.leaves
@@ -38,6 +60,13 @@ def assign_elementary(self, lhs, rhs, evaluation, tags=None, upset=False):
         name = lhs.get_head_name()
         lhs._format_cache = None
 
+        if name == "System`Pattern":
+            lhsleaves= lhs.get_leaves()
+            lhs = lhsleaves[1]
+            rulerepl = (lhsleaves[0], repl_pattern_by_symbol(lhs))
+            rhs, status = rhs.apply_rules([Rule(*rulerepl)], evaluation)
+            name = lhs.get_head_name()
+
         if name in system_symbols('OwnValues', 'DownValues', 'SubValues',
                                   'UpValues', 'NValues', 'Options',
                                   'DefaultValues', 'Attributes', 'Messages'):
@@ -220,7 +249,7 @@ def assign_elementary(self, lhs, rhs, evaluation, tags=None, upset=False):
         elif lhs_name == 'System`$ContextPath':
             currContext = evaluation.definitions.get_current_context()
             context_path = [s.get_string_value()  for s in rhs.get_leaves()]
-            context_path = [s if (s is None or s[0]!="`") else currContext +s for s in context_path]
+            context_path = [s if (s is None or s[0]!="`") else currContext[:-1] +s for s in context_path]
             if rhs.has_form('List', None) and all(valid_context_name(s) for s in context_path):
                 evaluation.definitions.set_context_path(context_path)
                 ignore_protection = True
@@ -1037,15 +1066,27 @@ def do_clear(self, definition):
 
     def apply(self, symbols, evaluation):
         '%(name)s[symbols___]'
-
-        for symbol in symbols.get_sequence():
+        if isinstance(symbols ,Symbol):
+            symbols = [symbols]
+        elif isinstance(symbols, Expression):
+            symbols = symbols.get_leaves()
+        elif isinstance(symbols ,String):
+            symbols = [symbols]
+        else:
+            symbols = symbols.get_sequence()
+ 
+        for symbol in symbols:
             if isinstance(symbol, Symbol):
                 names = [symbol.get_name()]
             else:
                 pattern = symbol.get_string_value()
                 if not pattern:
                     evaluation.message('Clear', 'ssym', symbol)
                     continue
+                if pattern[0] == "`":
+                    pattern = (evaluation.definitions.get_current_context()
+                               + pattern[1:])
+
                 names = evaluation.definitions.get_matching_names(pattern)
             for name in names:
                 attributes = evaluation.definitions.get_attributes(name)

mathics/builtin/attributes.py

@@ -10,7 +10,8 @@
 
 
 from mathics.builtin.base import Predefined, Builtin
-from mathics.core.expression import Symbol, Expression
+from mathics.builtin.evaluation import Sequence
+from mathics.core.expression import Expression, Symbol, String
 from mathics.builtin.assignment import get_symbol_list
 
 
@@ -140,8 +141,11 @@ def apply(self, symbols, attributes, evaluation):
 class Protect(Builtin):
     """
     <dl>
-    <dt>'Protect'[$s1$, $s2$, ...]
-        <dd>sets the attribute 'Protected' for the symbols $si$.
+      <dt>'Protect'[$s1$, $s2$, ...]
+      <dd>sets the attribute 'Protected' for the symbols $si$.
+
+      <dt>'Protect'[$str1$, $str2$, ...]
+      <dd>protects all symbols whose names textually match $stri$.
     </dl>
 
     >> A = {1, 2, 3};
@@ -153,26 +157,96 @@ class Protect(Builtin):
     """
 
     attributes = ('HoldAll',)
-
-    rules = {
-        'Protect[symbols__]': 'SetAttributes[{symbols}, Protected]',
+    messages = {
+        'ssym': "`1` is not a symbol or a string.",
     }
 
+    def apply(self, symbols, evaluation):
+        "Protect[symbols___]"
+        protected = Symbol("System`Protected")
+        items = []
+
+        if isinstance(symbols ,Symbol):
+            symbols = [symbols]
+        elif isinstance(symbols, String):
+            symbols = [symbols]
+        elif isinstance(symbols, Expression):
+            if symbols.get_head_name() in ("System`Sequence", "System`List"):
+                symbols = symbols.get_leaves()
+            else:
+                evaluation.message('Protect', 'ssym', symbol)
+                return Symbol("Null")
+ 
+        for symbol in symbols:
+            if isinstance(symbol, Symbol):
+                items.append(symbol)
+            else:
+                pattern = symbol.get_string_value()
+                if not pattern or pattern=="":
+                    evaluation.message('Protect', 'ssym', symbol)
+                    continue
+
+                if pattern[0] == "`":
+                    pattern = evaluation.definitions.get_current_context() + pattern[1:]
+                names = evaluation.definitions.get_matching_names(pattern)
+                for defn in names:
+                    symbol = Symbol(defn)
+                    if not 'System`Locked' in evaluation.definitions.get_attributes(defn):
+                        items.append(symbol)
+
+        Expression("SetAttributes", Expression("List", *items), protected).evaluate(evaluation)
+        return Symbol('Null')
+
 
 class Unprotect(Builtin):
     """
     <dl>
-    <dt>'Unprotect'[$s1$, $s2$, ...]
-        <dd>removes the attribute 'Protected' for the symbols $si$.
+      <dt>'Unprotect'[$s1$, $s2$, ...]
+      <dd>removes the attribute 'Protected' for the symbols $si$.
+
+      <dt>'Unprotect'[$str$]
+      <dd>unprotects symbols whose names textually match $str$.
     </dl>
     """
 
     attributes = ('HoldAll',)
-
-    rules = {
-        'Unprotect[symbols__]': 'ClearAttributes[{symbols}, Protected]',
+    messages = {
+        'ssym': "`1` is not a symbol or a string.",
     }
 
+    def apply(self, symbols, evaluation):
+        "Unprotect[symbols___]"
+        protected = Symbol("System`Protected")
+        items = []
+        if isinstance(symbols ,Symbol):
+            symbols = [symbols]
+        elif isinstance(symbols, Expression):
+            symbols = symbols.get_leaves()
+        elif isinstance(symbols ,String):
+            symbols = [symbols]
+        else:
+            symbols = symbols.get_sequence()
+
+        for symbol in symbols:
+            if isinstance(symbol, Symbol):
+                items.append(symbol)
+            else:
+                pattern = symbol.get_string_value()
+                if not pattern or pattern=="":
+                    evaluation.message('Unprotect', 'ssym', symbol)
+                    continue
+
+                if pattern[0] == "`":
+                    pattern = evaluation.definitions.get_current_context() + pattern[1:]
+                names = evaluation.definitions.get_matching_names(pattern)
+                for defn in names:
+                    symbol = Symbol(defn)
+                    if not 'System`Locked' in evaluation.definitions.get_attributes(defn):
+                        items.append(symbol)
+
+        Expression("ClearAttributes", Expression("List", *items), protected).evaluate(evaluation)
+        return Symbol('Null')
+
 
 class Protected(Predefined):
     """

mathics/builtin/system.py

@@ -9,10 +9,12 @@
 import os
 import platform
 import sys
+import re
 
 from mathics.core.expression import Expression, Integer, String, Symbol, strip_context
 from mathics.builtin.base import Builtin, Predefined
 from mathics import version_string
+from mathics.builtin.strings import StringExpression, to_regex
 
 
 class Aborted(Predefined):
@@ -194,8 +196,12 @@ class Names(Builtin):
 
     def apply(self, pattern, evaluation):
         "Names[pattern_]"
+        headname = pattern.get_head_name()
+        if headname == "System`StringExpression":
+            pattern = re.compile(to_regex(pattern, evaluation))
+        else:
+            pattern = pattern.get_string_value()
 
-        pattern = pattern.get_string_value()
         if pattern is None:
             return
 

mathics/core/definitions.py

@@ -21,7 +21,7 @@
 )
 from mathics.core.characters import letters, letterlikes
 
-
+type_compiled_pattern = type(re.compile("a.a"))
 names_wildcards = "@*"
 base_names_pattern = r"((?![0-9])([0-9${0}{1}{2}])+)".format(
     letters, letterlikes, names_wildcards
@@ -64,6 +64,7 @@ def __init__(
         self.lookup_cache = {}
         self.proxy = defaultdict(set)
         self.now = 0  # increments whenever something is updated
+        self._packages = []
 
         if add_builtin:
             from mathics.builtin import modules, contribute
@@ -312,37 +313,38 @@ def get_matching_names(self, pattern) -> typing.List[str]:
         which aren't uppercase letters. In the context pattern, both
         '*' and '@' match context marks.
         """
-
-        if re.match(full_names_pattern, pattern) is None:
-            # The pattern contained characters which weren't allowed
-            # in symbols and aren't valid wildcards. Hence, the
-            # pattern can't match any symbols.
-            return []
-
-        # If we get here, there aren't any regexp metacharacters in
-        # the pattern.
-
-        if "`" in pattern:
-            ctx_pattern, short_pattern = pattern.rsplit("`", 1)
-            ctx_pattern = (
-                (ctx_pattern + "`")
-                .replace("@", "[^A-Z`]+")
-                .replace("*", ".*")
-                .replace("$", r"\$")
-            )
+        if isinstance(pattern, type_compiled_pattern):
+            regex = pattern
         else:
-            short_pattern = pattern
-            # start with a group matching the accessible contexts
-            ctx_pattern = "(?:%s)" % "|".join(
-                re.escape(c) for c in self.get_accessible_contexts()
-            )
-
-        short_pattern = (
-            short_pattern.replace("@", "[^A-Z]+")
-            .replace("*", "[^`]*")
-            .replace("$", r"\$")
-        )
-        regex = re.compile("^" + ctx_pattern + short_pattern + "$")
+            if re.match(full_names_pattern, pattern) is None:
+                # The pattern contained characters which weren't allowed
+                # in symbols and aren't valid wildcards. Hence, the
+                # pattern can't match any symbols.
+                return []
+
+            # If we get here, there aren't any regexp metacharacters in
+            # the pattern.
+
+            if '`' in pattern:
+                ctx_pattern, short_pattern = pattern.rsplit('`', 1)
+                if ctx_pattern == "":
+                    ctx_pattern="System`"
+                else:
+                    ctx_pattern = ((ctx_pattern + '`')
+                                   .replace('@', '[^A-Z`]+')
+                                   .replace('*', '.*')
+                                   .replace('$', r'\$'))
+            else:
+                short_pattern = pattern
+                # start with a group matching the accessible contexts
+                ctx_pattern = "(?:%s)" % "|".join(
+                    re.escape(c) for c in self.get_accessible_contexts())
+
+            short_pattern = (short_pattern
+                             .replace('@', '[^A-Z]+')
+                             .replace('*', '[^`]*')
+                             .replace('$', r'\$'))
+            regex = re.compile('^' + ctx_pattern + short_pattern + '$')
 
         return [name for name in self.get_names() if regex.match(name)]