fixing Names, Protect and Unprotect

Author: mmatera

mathics/builtin/attributes.py

@@ -201,17 +201,52 @@ def apply(self, symbols, evaluation):
 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
@@ -313,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)]