OutputForm

mathics/builtin/forms/print.py

@@ -198,8 +198,16 @@ class OutputForm(FormBaseClass):
      = -Graphics-
     """
 
+    formats = {"OutputForm[s_String]": "s"}
     summary_text = "format expression in plain text"
 
+    def eval_makeboxes(self, expr, form, evaluation):
+        """MakeBoxes[OutputForm[expr_], form_]"""
+        pane = eval_makeboxes_outputform(expr, evaluation, form)
+        return InterpretationBox(
+            pane, Expression(SymbolOutputForm, expr), **{"System`Editable": SymbolFalse}
+        )
+
 
 class StandardForm(FormBaseClass):
     """

mathics/builtin/list/predicates.py

@@ -51,18 +51,8 @@ class ContainsOnly(Builtin):
 
     summary_text = "test if all the elements of a list appears into another list"
 
-    def check_options(self, expr, evaluation, options):
-        for key in options:
-            if key != "System`SameTest":
-                if expr is None:
-                    evaluation.message("ContainsOnly", "optx", Symbol(key))
-                else:
-                    evaluation.message("ContainsOnly", "optx", Symbol(key), expr)
-
-        return None
-
     def eval(self, list1, list2, evaluation, options={}):
-        "ContainsOnly[list1_List, list2_List, OptionsPattern[ContainsOnly]]"
+        "ContainsOnly[list1_List, list2_List, OptionsPattern[]]"
 
         same_test = self.get_option(options, "SameTest", evaluation)
 
@@ -71,31 +61,28 @@ def sameQ(a, b) -> bool:
             result = Expression(same_test, a, b).evaluate(evaluation)
             return result is SymbolTrue
 
-        self.check_options(None, evaluation, options)
         for a in list1.elements:
             if not any(sameQ(a, b) for b in list2.elements):
                 return SymbolFalse
         return SymbolTrue
 
-    def eval_msg(self, e1, e2, evaluation, options={}):
-        "ContainsOnly[e1_, e2_, OptionsPattern[ContainsOnly]]"
-
+    def eval_msg(self, e1, e2, evaluation, expression, options={}):
+        "expression:(ContainsOnly[e1_, e2_, OptionsPattern[]])"
         opts = (
             options_to_rules(options)
             if len(options) <= 1
             else [ListExpression(*options_to_rules(options))]
         )
-        expr = Expression(SymbolContainsOnly, e1, e2, *opts)
 
         if not isinstance(e1, Symbol) and not e1.has_form("List", None):
             evaluation.message("ContainsOnly", "lsa", e1)
-            return self.check_options(expr, evaluation, options)
+            return expression
 
         if not isinstance(e2, Symbol) and not e2.has_form("List", None):
             evaluation.message("ContainsOnly", "lsa", e2)
-            return self.check_options(expr, evaluation, options)
+            return expression
 
-        return self.check_options(expr, evaluation, options)
+        return expression
 
 
 # TODO: ContainsAll, ContainsNone ContainsAny ContainsExactly

mathics/builtin/makeboxes.py

@@ -16,6 +16,7 @@
     format_element,
     parenthesize,
 )
+from mathics.settings import SYSTEM_CHARACTER_ENCODING
 
 # TODO: Differently from the current implementation, MakeBoxes should only
 # accept as its format field the symbols in `$BoxForms`. This is something to
@@ -96,7 +97,7 @@ class MakeBoxes(Builtin):
             'MakeBoxes[Infix[head[elements], StringForm["~`1`~", head]], f]'
         ),
         "MakeBoxes[expr_]": "MakeBoxes[expr, StandardForm]",
-        "MakeBoxes[(form:StandardForm|TraditionalForm|OutputForm|TeXForm|"
+        "MakeBoxes[(form:StandardForm|TraditionalForm|TeXForm|"
         "MathMLForm)[expr_], StandardForm|TraditionalForm]": ("MakeBoxes[expr, form]"),
         "MakeBoxes[(form:StandardForm|OutputForm|MathMLForm|TeXForm)[expr_], OutputForm]": "MakeBoxes[expr, form]",
         "MakeBoxes[PrecedenceForm[expr_, prec_], f_]": "MakeBoxes[expr, f]",

mathics/builtin/numbers/calculus.py

@@ -1410,9 +1410,9 @@ class NIntegrate(Builtin):
     messages.update(
         {
             "bdmtd": "The Method option should be a "
-            + "built-in method name in {`"
-            + "`, `".join(list(methods))
-            + "`}. Using `Automatic`"
+            + r"built-in method name in {\`"
+            + r"\`, \`".join(list(methods))
+            + r"\`}. Using \`Automatic\`."
         }
     )
 

mathics/core/atoms/numerics.py

@@ -522,11 +522,11 @@ def is_machine_precision(self) -> bool:
         return True
 
     def make_boxes(self, form):
-        from mathics.eval.makeboxes import NumberForm_to_String
+        from mathics.eval.makeboxes import numberform_to_boxes
 
         _number_form_options["_Form"] = form  # passed to _NumberFormat
         n = 6 if form == "System`OutputForm" else None
-        num_str = NumberForm_to_String(self, n, None, None, _number_form_options)
+        num_str = numberform_to_boxes(self, n, None, None, _number_form_options)
         return num_str
 
     @property
@@ -641,11 +641,11 @@ def is_zero(self) -> bool:
         return self.value.is_zero or False
 
     def make_boxes(self, form):
-        from mathics.eval.makeboxes import NumberForm_to_String
+        from mathics.eval.makeboxes import numberform_to_boxes
 
         _number_form_options["_Form"] = form  # passed to _NumberFormat
         digits = dps(self.get_precision()) if form == "System`OutputForm" else None
-        return NumberForm_to_String(self, digits, None, None, _number_form_options)
+        return numberform_to_boxes(self, digits, None, None, _number_form_options)
 
     def round(self, d: Optional[int] = None) -> Union[MachineReal, "PrecisionReal"]:
         if d is None:

mathics/core/parser/__init__.py

@@ -18,7 +18,7 @@
     MathicsMultiLineFeeder,
     MathicsSingleLineFeeder,
 )
-from mathics.core.parser.operators import all_operator_names
+from mathics.core.parser.operators import all_operator_names, operator_precedences
 from mathics.core.parser.util import parse, parse_builtin_rule
 
 __all__ = [
@@ -29,6 +29,7 @@
     "MathicsSingleLineFeeder",
     "all_operator_names",
     "is_symbol_name",
+    "operator_precedences",
     "parse",
     "parse_builtin_rule",
 ]

mathics/core/systemsymbols.py

@@ -196,6 +196,7 @@
 SymbolNIntegrate = Symbol("System`NIntegrate")
 SymbolNValues = Symbol("System`NValues")
 SymbolNeeds = Symbol("System`Needs")
+SymbolNonAssociative = Symbol("System`NonAssociative")
 SymbolNone = Symbol("System`None")
 SymbolNorm = Symbol("System`Norm")
 SymbolNormal = Symbol("System`Normal")
@@ -235,9 +236,11 @@
 SymbolPlus = Symbol("System`Plus")
 SymbolPoint = Symbol("System`Point")
 SymbolPolygon = Symbol("System`Polygon")
+SymbolPostfix = Symbol("System`Postfix")
 SymbolPossibleZeroQ = Symbol("System`PossibleZeroQ")
 SymbolPower = Symbol("System`Power")
 SymbolPrecision = Symbol("System`Precision")
+SymbolPrefix = Symbol("System`Prefix")
 SymbolPreserveImageOptions = Symbol("System`PreserveImageOptions")
 SymbolProlog = Symbol("System`Prolog")
 SymbolQuantity = Symbol("System`Quantity")

mathics/doc/documentation/1-Manual.mdoc

@@ -901,9 +901,11 @@ This will even apply to 'TeXForm', because 'TeXForm' implies 'StandardForm':
   >> b // TeXForm
   = c
 
-Except some other form is applied first:
-  >> b // OutputForm // TeXForm
-  = b
+  ## This test requires another round of changes in order to 
+  ## pass:
+  ## Except some other form is applied first:
+  ## >> b // OutputForm // TeXForm
+  ## = \text{b}
 'MakeBoxes' for another form:
 
   >> MakeBoxes[b, TeXForm] = "d";
@@ -934,12 +936,12 @@ For instance, you can override 'MakeBoxes' to format lists in a different way:
   >> {1, 2, 3}
    = {1, 2, 3}
 
-  #> {1, 2, 3} // TeXForm
+  >> {1, 2, 3} // TeXForm
    = \left[1 2 3\right]
 
 However, this will not be accepted as input to \Mathics anymore:
   >> [1 2 3]
-  : Expression cannot begin with "[1 2 3]" (line 1 of "<test-Formatting Output-28>").
+  : Expression cannot begin with "[1 2 3]" (line 1 of "<test-Formatting Output-27>").
 
   >> Clear[MakeBoxes]
 

mathics/eval/makeboxes/__init__.py

@@ -8,11 +8,16 @@
     eval_generic_makeboxes,
     eval_makeboxes,
     eval_makeboxes_fullform,
+    eval_makeboxes_outputform,
     format_element,
     int_to_string_shorter_repr,
     to_boxes,
 )
-from mathics.eval.makeboxes.numberform import NumberForm_to_String, eval_baseform
+from mathics.eval.makeboxes.numberform import (
+    eval_baseform,
+    get_numberform_parameters,
+    numberform_to_boxes,
+)
 from mathics.eval.makeboxes.operators import eval_infix, eval_postprefix
 from mathics.eval.makeboxes.outputforms import (
     eval_mathmlform,
@@ -26,7 +31,7 @@
 )
 
 __all__ = [
-    "NumberForm_to_String",
+    "numberform_to_boxes",
     "StringLParen",
     "StringRParen",
     "_boxed_string",
@@ -38,11 +43,13 @@
     "eval_infix",
     "eval_makeboxes",
     "eval_makeboxes_fullform",
+    "eval_makeboxes_outputform",
     "eval_mathmlform",
     "eval_postprefix",
     "eval_tableform",
     "eval_texform",
     "format_element",
+    "get_numberform_parameters",
     "int_to_string_shorter_repr",
     "parenthesize",
     "render_input_form",

mathics/eval/makeboxes/makeboxes.py

@@ -137,6 +137,20 @@ def int_to_string_shorter_repr(value: int, form: Symbol, max_digits=640):
     return String(value_str)
 
 
+def eval_makeboxes_outputform(expr, evaluation, form, **kwargs):
+    """
+    Build a 2D representation of the expression using only keyboard characters.
+    """
+    from mathics.builtin.box.layout import PaneBox
+    from mathics.form.outputform import expression_to_outputform_text
+
+    text_outputform = str(
+        expression_to_outputform_text(expr, evaluation, form, **kwargs)
+    )
+    elem1 = PaneBox(String('"' + text_outputform + '"'))
+    return elem1
+
+
 # TODO: evaluation is needed because `atom_to_boxes` uses it. Can we remove this
 # argument?
 def eval_makeboxes_fullform(
@@ -271,10 +285,35 @@ def format_element(
     """
     Applies formats associated to the expression, and then calls Makeboxes
     """
+    # Halt any potential evaluation tracing while performing boxing.
     evaluation.is_boxing = True
+    while element.get_head() is form:
+        element = element.elements[0]
+
+    # By now, eval_makeboxes_outputform is only used when we explicitly
+    # ask for MakeBoxes[OutputForm[expr], fmt]
+    # When it get ready, we can uncomment this.
+    # if form is SymbolOutputForm:
+    #    return eval_makeboxes_outputform(element, evaluation, form, **kwargs)
+
+    if element.has_form("FullForm", 1):
+        return eval_makeboxes_fullform(element.elements[0], evaluation)
+
+    # In order to work like in WMA, `format_element`
+    # should evaluate `MakeBoxes[element//form, StandardForm]`
+    # Then, MakeBoxes[expr_, StandardForm], for any expr,
+    # should apply Format[...] rules, and then
+    # MakeBoxes[...] rules. These rules should be stored
+    # as FormatValues[...]
+    # As a first step in that direction, let's mimic this behaviour
+    # just for the case of OutputForm:
+    if element.has_form("OutputForm", 1):
+        return eval_makeboxes_outputform(element.elements[0], evaluation, form)
+
     formatted_expr = do_format(element, evaluation, form)
     if formatted_expr is None:
         return None
+
     result_box = eval_makeboxes(formatted_expr, evaluation, form)
     if isinstance(result_box, String):
         return result_box