Add prefix operators, revise tables

named-characgters.yml: Add DifferentialD and Integrate even though we
don't have a full set of prefix operators.

Add "ascii" entry for DifferentialD

Add admin-tools script to build all tables.

Author: rocky

admin-tools/make-tables.sh

@@ -0,0 +1,9 @@
+#!/bin/bash
+# Create a complete set of tables.
+# This just runs build_tables.py in this distribution
+bs=${BASH_SOURCE[0]}
+mydir=$(dirname $bs)
+PYTHON=${PYTHON:-python}
+
+cd $mydir/../mathics_scanner/data
+$PYTHON ../generate/build_tables.py -o characters.json

mathics_scanner/data/named-characters.yml

@@ -653,6 +653,7 @@ CapitalDelta:
 
 CapitalDifferentialD:
   amslatex: "\\CapitalDifferentialD"
+  ascii: "d"
   esc-alias: DD
   has-unicode-inverse: true
   is-letter-like: true
@@ -1787,6 +1788,8 @@ DifferentialD:
   has-unicode-inverse: true
   # This can't be letter-like because it is used in derivatives as a function
   is-letter-like: false
+  # TODO: This should be a prefix operator
+  operator-name: DifferentialD
   unicode-equivalent: "\U0001D451"
   unicode-equivalent-name: MATHEMATICAL ITALIC SMALL D
   wl-unicode: "\uF74C"
@@ -5026,6 +5029,7 @@ Integral:
   esc-alias: int
   has-unicode-inverse: false
   is-letter-like: false
+  # TODO: This should be a prefix operator
   operator-name: Integral
   unicode-equivalent: "\u222B"
   unicode-equivalent-name: INTEGRAL

mathics_scanner/generate/build_tables.py

@@ -118,6 +118,13 @@ def compile_tables(data: dict) -> dict:
         if "operator-name" in v and ("unicode-equivalent" in v or "ascii" in v)
     }
 
+    # operator-to-ascii or character symbol name
+    operator_to_ascii = {
+        v["operator-name"]: v.get("ascii", rf'\[{v["operator-name"]}]')
+        for k, v in data.items()
+        if "operator-name" in v and ("unicode-equivalent" in v or "ascii" in v)
+    }
+
     # Conversion from unicode or ascii to wl dictionary entry.
     # We filter the dictionary after it's first created to redundant entries
     unicode_to_wl_dict = {
@@ -145,7 +152,8 @@ def compile_tables(data: dict) -> dict:
     operator_names = sorted([k for k, v in data.items() if "operator-name" in v])
 
     ascii_operators = []
-    ascii_operator_to_name = {}
+    ascii_operator_to_character_symbol = {}
+    ascii_operator_to_symbol = {}
     ascii_operator_to_unicode = {}
     ascii_operator_to_wl_unicode = {}
 
@@ -155,7 +163,8 @@ def compile_tables(data: dict) -> dict:
         ascii_name = v.get("ascii", None)
         if ascii_name is not None:
             ascii_operators.append(v["ascii"])
-            ascii_operator_to_name[ascii_name] = rf'\[{v["operator-name"]}]'
+            ascii_operator_to_character_symbol[ascii_name] = rf'\[{v["operator-name"]}]'
+            ascii_operator_to_symbol[ascii_name] = v["operator-name"]
             # Mathics core stores the ascii operator value, Use that to get standard unicode
             # symbol, and failing use the ASCII sequence.
             ascii_operator_to_unicode[ascii_name] = v.get(
@@ -193,13 +202,15 @@ def compile_tables(data: dict) -> dict:
     return {
         "aliased-characters": aliased_characters,
         "ascii-operators": ascii_operators,
-        "ascii-operator-to-name": ascii_operator_to_name,
+        "ascii-operator-to-symbol": ascii_operator_to_symbol,
+        "ascii-operator-to-character-symbol": ascii_operator_to_character_symbol,
         "ascii-operator-to-unicode": ascii_operator_to_unicode,
         "ascii-operator-to-wl-unicode": ascii_operator_to_wl_unicode,
         "letterlikes": letterlikes,
         "named-characters": named_characters,
         "operator-names": operator_names,
         "operator-to-precedence": operator_to_precedence,
+        "operator-to-ascii": operator_to_ascii,
         "operator-to-unicode": operator_to_unicode,
         # unicode-operators is irregular, but this is what
         # mathics-pygments uses
@@ -219,12 +230,14 @@ def compile_tables(data: dict) -> dict:
 ALL_FIELDS = [
     "aliased-characters",
     "ascii-operators",
-    "ascii-operator-to-name",
+    "ascii-operator-to-character-symbol",
+    "ascii-operator-to-symbol",
     "ascii-operator-to-unicode",
     "ascii-operator-to-wl-unicode",
     "letterlikes",
     "named-characters",
     "operator-names",
+    "operator-to-ascii",
     "operator-to-precedence",
     "operator-to-unicode",
     "unicode-operators",

test/test_ascii.py

@@ -10,17 +10,19 @@
 
 
 def test_ascii():
-    ascii_operator_to_name = json_data["ascii-operator-to-name"]
+    ascii_operator_to_character_symbol = json_data["ascii-operator-to-character-symbol"]
+    ascii_operator_to_symbol = json_data["ascii-operator-to-symbol"]
     ascii_operators = json_data["ascii-operators"]
-    operator_keys = frozenset(ascii_operator_to_name.keys())
+    operator_keys = frozenset(ascii_operator_to_symbol.keys())
     # operator_to_precedence = json_data["operator-to-precedence"]
     for chars in json_data["ascii-operators"]:
         assert chars in ascii_operators
         assert chars in operator_keys
         # assert chars in unicode_to_operator.keys()
-        name = ascii_operator_to_name.get(chars)
-        assert name is not None
-        assert name.startswith(r"\[")
-        assert name.endswith(r"]")
-        raw_name = name[len(r"\[") : -len(r"]")]
-        assert raw_name in yaml_data
+        char_symbol = ascii_operator_to_character_symbol.get(chars)
+        assert char_symbol is not None
+        assert char_symbol.startswith(r"\[")
+        assert char_symbol.endswith(r"]")
+        raw_char_symbol = char_symbol[len(r"\[") : -len(r"]")]
+        assert raw_char_symbol in yaml_data
+        assert raw_char_symbol in ascii_operator_to_symbol.values()