def evaluate():
if history_length > 0:
self.definitions.add_rule(
'In', Rule(Expression('In', line_no), query))
if check_io_hook('System`$Pre'):
result = Expression('System`$Pre', query).evaluate(self)
else:
result = query.evaluate(self)
if check_io_hook('System`$Post'):
result = Expression('System`$Post', result).evaluate(self)
if history_length > 0:
if self.predetermined_out is not None:
out_result = self.predetermined_out
self.predetermined_out = None
else:
out_result = result
stored_result = self.get_stored_result(out_result)
self.definitions.add_rule(
'Out', Rule(Expression('Out', line_no), stored_result))
if result != Symbol('Null'):
if check_io_hook('System`$PrePrint'):
result = Expression('System`$PrePrint',
result).evaluate(self)
return self.format_output(result, self.format)
else:
return None
def evaluate():
if history_length > 0:
self.definitions.add_rule("In", Rule(Expression("In", line_no), query))
if check_io_hook("System`$Pre"):
self.last_eval = Expression("System`$Pre", query).evaluate(self)
else:
self.last_eval = query.evaluate(self)
if check_io_hook("System`$Post"):
self.last_eval = Expression("System`$Post", self.last_eval).evaluate(
self
)
if history_length > 0:
if self.predetermined_out is not None:
out_result = self.predetermined_out
self.predetermined_out = None
else:
out_result = self.last_eval
stored_result = self.get_stored_result(out_result)
self.definitions.add_rule(
"Out", Rule(Expression("Out", line_no), stored_result)
)
if self.last_eval != self.SymbolNull:
if check_io_hook("System`$PrePrint"):
self.last_eval = Expression(
"System`$PrePrint", self.last_eval
).evaluate(self)
return self.format_output(self.last_eval, format)
else:
self.exec_result = self.SymbolNull
return None
def evaluate(self):
if history_length > 0:
self.definitions.add_rule('In', Rule(Expression('In', line_no), query))
result = query.evaluate(self)
if history_length > 0:
stored_result = self.get_stored_result(result)
self.definitions.add_rule('Out', Rule(Expression('Out', line_no), stored_result))
if result != Symbol('Null'):
return self.format_output(result)
else:
return None
def create_rules(rules_expr, expr, name, evaluation, extra_args=[]):
if rules_expr.has_form('List', None):
rules = rules_expr.leaves
else:
rules = [rules_expr]
any_lists = any(item.has_form('List', None) for item in rules)
if any_lists:
all_lists = all(item.has_form('List', None) for item in rules)
if all_lists:
return Expression(
'List',
*[Expression(name, expr, item, *extra_args)
for item in rules]), True
else:
evaluation.message(name, 'rmix', rules_expr)
return None, True
else:
result = []
for rule in rules:
if rule.get_head_name() not in ('System`Rule',
'System`RuleDelayed'):
evaluation.message(name, 'reps', rule)
return None, True
elif len(rule.leaves) != 2:
evaluation.message(
# TODO: shorten names here
rule.get_head_name(),
'argrx',
rule.get_head_name(),
3,
2)
return None, True
else:
result.append(Rule(rule.leaves[0], rule.leaves[1]))
return result, False
def __init__(self, rulelist, evaluation):
self.src = Expression(SymbolList, *rulelist)
self.rules = [
Rule(rule._leaves[0], rule._leaves[1]) for rule in rulelist
]
self._leaves = None
self._head = Symbol("Dispatch")
def ensure_logical_algebraic_rules():
global logical_algebraic_rules
global remove_not_rules
if logical_algebraic_rules is None:
logical_algebraic_rules = []
for pattern, replace in logical_algebraic_rules_spec.items():
pattern = parse_builtin_rule(pattern, SystemDefinitions())
logical_algebraic_rules.append(
Rule(pattern, parse_builtin_rule(replace), system=True)
)
remove_not_rules = []
for pattern, replace in remove_not_rules_spec.items():
pattern = parse_builtin_rule(pattern, SystemDefinitions())
remove_not_rules.append(
Rule(pattern, parse_builtin_rule(replace), system=True)
)
return
def create_rules(rules_expr, expr, name, evaluation, extra_args=[]):
if isinstance(rules_expr, Dispatch):
return rules_expr.rules, False
elif rules_expr.has_form("Dispatch", None):
return Dispatch(rules_expr._leaves, evaluation)
if rules_expr.has_form("List", None):
rules = rules_expr.leaves
else:
rules = [rules_expr]
any_lists = any(
item.has_form(("List", "Dispatch"), None) for item in rules)
if any_lists:
all_lists = all(item.has_form("List", None) for item in rules)
if all_lists:
return (
Expression(
"List", *[
Expression(name, expr, item, *extra_args)
for item in rules
]),
True,
)
else:
evaluation.message(name, "rmix", rules_expr)
return None, True
else:
result = []
for rule in rules:
if rule.get_head_name() not in ("System`Rule",
"System`RuleDelayed"):
evaluation.message(name, "reps", rule)
return None, True
elif len(rule.leaves) != 2:
evaluation.message(
# TODO: shorten names here
rule.get_head_name(),
"argrx",
rule.get_head_name(),
3,
2,
)
return None, True
else:
result.append(Rule(rule.leaves[0], rule.leaves[1]))
return result, False
def apply(self, items, pattern, ls, evaluation, options):
"Cases[items_, pattern_, ls_:{1}, OptionsPattern[]]"
if items.is_atom():
return Expression(SymbolList)
from mathics.builtin.patterns import Matcher
if ls.has_form("Rule", 2):
if ls.leaves[0].get_name() == "System`Heads":
heads = ls.leaves[1].is_true()
ls = Expression("List", 1)
else:
return evaluation.message("Position", "level", ls)
else:
heads = self.get_option(options, "Heads", evaluation).is_true()
try:
start, stop = python_levelspec(ls)
except InvalidLevelspecError:
return evaluation.message("Position", "level", ls)
results = []
if pattern.has_form("Rule", 2) or pattern.has_form("RuleDelayed", 2):
match = Matcher(pattern.leaves[0]).match
rule = Rule(pattern.leaves[0], pattern.leaves[1])
def callback(level):
if match(level, evaluation):
result = rule.apply(level, evaluation)
result = result.evaluate(evaluation)
results.append(result)
return level
else:
match = Matcher(pattern).match
def callback(level):
if match(level, evaluation):
results.append(level)
return level
walk_levels(items, start, stop, heads=heads, callback=callback)
return Expression(SymbolList, *results)
def assign_elementary(self, lhs, rhs, evaluation, tags=None, upset=False):
name = lhs.get_head_name()
if name in system_symbols('OwnValues', 'DownValues', 'SubValues',
'UpValues', 'NValues', 'Options',
'DefaultValues', 'Attributes', 'Messages'):
if len(lhs.leaves) != 1:
evaluation.message_args(name, len(lhs.leaves), 1)
return False
tag = lhs.leaves[0].get_name()
if not tag:
evaluation.message(name, 'sym', lhs.leaves[0], 1)
return False
if tags is not None and tags != [tag]:
evaluation.message(name, 'tag', Symbol(name), Symbol(tag))
return False
if (name != 'System`Attributes' and 'System`Protected' # noqa
in evaluation.definitions.get_attributes(tag)):
evaluation.message(name, 'wrsym', Symbol(tag))
return False
if name == 'System`Options':
option_values = rhs.get_option_values(evaluation)
if option_values is None:
evaluation.message(name, 'options', rhs)
return False
evaluation.definitions.set_options(tag, option_values)
elif name == 'System`Attributes':
attributes = get_symbol_list(
rhs, lambda item: evaluation.message(name, 'sym', item, 1))
if attributes is None:
return False
if 'System`Locked' in evaluation.definitions.get_attributes(tag):
evaluation.message(name, 'locked', Symbol(tag))
return False
evaluation.definitions.set_attributes(tag, attributes)
else:
rules = rhs.get_rules_list()
if rules is None:
evaluation.message(name, 'vrule', lhs, rhs)
return False
evaluation.definitions.set_values(tag, name, rules)
return True
form = ''
nprec = None
default = False
message = False
allow_custom_tag = False
focus = lhs
if name == 'System`N':
if len(lhs.leaves) not in (1, 2):
evaluation.message_args('N', len(lhs.leaves), 1, 2)
return False
if len(lhs.leaves) == 1:
nprec = Symbol('MachinePrecision')
else:
nprec = lhs.leaves[1]
focus = lhs.leaves[0]
lhs = Expression('N', focus, nprec)
elif name == 'System`MessageName':
if len(lhs.leaves) != 2:
evaluation.message_args('MessageName', len(lhs.leaves), 2)
return False
focus = lhs.leaves[0]
message = True
elif name == 'System`Default':
if len(lhs.leaves) not in (1, 2, 3):
evaluation.message_args('Default', len(lhs.leaves), 1, 2, 3)
return False
focus = lhs.leaves[0]
default = True
elif name == 'System`Format':
if len(lhs.leaves) not in (1, 2):
evaluation.message_args('Format', len(lhs.leaves), 1, 2)
return False
if len(lhs.leaves) == 2:
form = lhs.leaves[1].get_name()
if not form:
evaluation.message('Format', 'fttp', lhs.leaves[1])
return False
else:
form = system_symbols(
'StandardForm', 'TraditionalForm', 'OutputForm',
'TeXForm', 'MathMLForm')
lhs = focus = lhs.leaves[0]
else:
allow_custom_tag = True
focus = focus.evaluate_leaves(evaluation)
if tags is None and not upset:
name = focus.get_lookup_name()
if not name:
evaluation.message(self.get_name(), 'setraw', focus)
return False
tags = [name]
elif upset:
if allow_custom_tag:
tags = []
if focus.is_atom():
evaluation.message(self.get_name(), 'normal')
return False
for leaf in focus.leaves:
name = leaf.get_lookup_name()
tags.append(name)
else:
tags = [focus.get_lookup_name()]
else:
allowed_names = [focus.get_lookup_name()]
if allow_custom_tag:
for leaf in focus.get_leaves():
allowed_names.append(leaf.get_lookup_name())
for name in tags:
if name not in allowed_names:
evaluation.message(self.get_name(), 'tagnfd', Symbol(name))
return False
ignore_protection = False
rhs_int_value = rhs.get_int_value()
lhs_name = lhs.get_name()
if lhs_name == 'System`$RecursionLimit':
# if (not rhs_int_value or rhs_int_value < 20) and not
# rhs.get_name() == 'System`Infinity':
if (not rhs_int_value or rhs_int_value < 20 or
rhs_int_value > settings.MAX_RECURSION_DEPTH): # nopep8
evaluation.message('$RecursionLimit', 'limset', rhs)
return False
try:
set_recursionlimit(rhs_int_value)
except OverflowError:
# TODO: Message
return False
ignore_protection = True
elif lhs_name == 'System`$ModuleNumber':
if not rhs_int_value or rhs_int_value <= 0:
evaluation.message('$ModuleNumber', 'set', rhs)
return False
ignore_protection = True
elif lhs_name in ('System`$Line', 'System`$HistoryLength'):
if rhs_int_value is None or rhs_int_value < 0:
evaluation.message(lhs_name, 'intnn', rhs)
return False
ignore_protection = True
elif lhs_name == 'System`$RandomState':
# TODO: allow setting of legal random states!
# (but consider pickle's insecurity!)
evaluation.message('$RandomState', 'rndst', rhs)
return False
elif lhs_name == 'System`$Context':
new_context = rhs.get_string_value()
if new_context is None or not valid_context_name(
new_context, allow_initial_backquote=True):
evaluation.message(lhs_name, 'cxset', rhs)
return False
# With $Context in Mathematica you can do some strange
# things: e.g. with $Context set to Global`, something
# like:
# $Context = "`test`"; newsym
# is accepted and creates Global`test`newsym.
# Implement this behaviour by interpreting
# $Context = "`test`"
# as
# $Context = $Context <> "test`"
#
if new_context.startswith('`'):
new_context = (evaluation.definitions.get_current_context() +
new_context.lstrip('`'))
evaluation.definitions.set_current_context(new_context)
ignore_protection = True
return True
elif lhs_name == 'System`$ContextPath':
context_path = [s.get_string_value() for s in rhs.get_leaves()]
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
return True
else:
evaluation.message(lhs_name, 'cxlist', rhs)
return False
elif lhs_name == 'System`$MinPrecision':
# $MinPrecision = Infinity is not allowed
if rhs_int_value is not None and rhs_int_value >= 0:
ignore_protection = True
max_prec = evaluation.definitions.get_config_value('$MaxPrecision')
if max_prec is not None and max_prec < rhs_int_value:
evaluation.message('$MinPrecision', 'preccon', Symbol('$MinPrecision'))
return True
else:
evaluation.message(lhs_name, 'precset', lhs, rhs)
return False
elif lhs_name == 'System`$MaxPrecision':
if rhs.has_form('DirectedInfinity', 1) and rhs.leaves[0].get_int_value() == 1:
ignore_protection = True
elif rhs_int_value is not None and rhs_int_value > 0:
ignore_protection = True
min_prec = evaluation.definitions.get_config_value('$MinPrecision')
if min_prec is not None and rhs_int_value < min_prec:
evaluation.message('$MaxPrecision', 'preccon', Symbol('$MaxPrecision'))
ignore_protection = True
return True
else:
evaluation.message(lhs_name, 'precset', lhs, rhs)
return False
rhs_name = rhs.get_head_name()
if rhs_name == 'System`Condition':
if len(rhs.leaves) != 2:
evaluation.message_args('Condition', len(rhs.leaves), 2)
return False
else:
lhs = Expression('Condition', lhs, rhs.leaves[1])
rhs = rhs.leaves[0]
rule = Rule(lhs, rhs)
count = 0
defs = evaluation.definitions
for tag in tags:
if (not ignore_protection and 'System`Protected' # noqa
in evaluation.definitions.get_attributes(tag)):
if lhs.get_name() == tag:
evaluation.message(self.get_name(), 'wrsym', Symbol(tag))
else:
evaluation.message(self.get_name(), 'write', Symbol(tag), lhs)
continue
count += 1
if form:
defs.add_format(tag, rule, form)
elif nprec:
defs.add_nvalue(tag, rule)
elif default:
defs.add_default(tag, rule)
elif message:
defs.add_message(tag, rule)
else:
if upset:
defs.add_rule(tag, rule, position='up')
else:
defs.add_rule(tag, rule)
if count == 0:
return False
return True
def contribute(self, definitions, pymodule=False):
from mathics.core.parser import parse_builtin_rule
name = self.get_name()
options = {}
option_syntax = 'Warn'
for option, value in self.options.items():
if option == '$OptionSyntax':
option_syntax = value
continue
option = ensure_context(option)
options[option] = parse_builtin_rule(value)
if option.startswith('System`'):
# Create a definition for the option's symbol.
# Otherwise it'll be created in Global` when it's
# used, so it won't work.
if option not in definitions.builtin:
definitions.builtin[option] = Definition(name=name,
attributes=set())
# Check if the given options are actually supported by the Builtin.
# If not, we might issue an optx error and abort. Using '$OptionSyntax'
# in your Builtin's 'options', you can specify the exact behaviour
# using one of the following values:
# - 'Strict': warn and fail with unsupported options
# - 'Warn': warn about unsupported options, but continue
# - 'Ignore': allow unsupported options, do not warn
if option_syntax in ('Strict', 'Warn', 'System`Strict', 'System`Warn'):
def check_options(options_to_check, evaluation):
name = self.get_name()
for key, value in options_to_check.items():
short_key = strip_context(key)
if not has_option(options, short_key, evaluation):
evaluation.message(
name, 'optx', Expression('Rule', short_key, value),
strip_context(name))
if option_syntax in ('Strict', 'System`Strict'):
return False
return True
elif option_syntax in ("Ignore", "System`Ignore"):
check_options = None
else:
raise ValueError('illegal option mode %s; check $OptionSyntax.' %
option_syntax)
rules = []
for pattern, function in self.get_functions():
rules.append(
BuiltinRule(name,
pattern,
function,
check_options,
system=True))
for pattern, replace in self.rules.items():
if not isinstance(pattern, BaseExpression):
pattern = pattern % {'name': name}
pattern = parse_builtin_rule(pattern)
replace = replace % {'name': name}
rules.append(
Rule(pattern, parse_builtin_rule(replace), system=True))
box_rules = []
if name != 'System`MakeBoxes':
new_rules = []
for rule in rules:
if rule.pattern.get_head_name() == 'System`MakeBoxes':
box_rules.append(rule)
else:
new_rules.append(rule)
rules = new_rules
def extract_forms(name, pattern):
# Handle a tuple of (forms, pattern) as well as a pattern
# on the left-hand side of a format rule. 'forms' can be
# an empty string (=> the rule applies to all forms), or a
# form name (like 'System`TraditionalForm'), or a sequence
# of form names.
def contextify_form_name(f):
# Handle adding 'System`' to a form name, unless it's
# '' (meaning the rule applies to all forms).
return '' if f == '' else ensure_context(f)
if isinstance(pattern, tuple):
forms, pattern = pattern
if isinstance(forms, str):
forms = [contextify_form_name(forms)]
else:
forms = [contextify_form_name(f) for f in forms]
else:
forms = ['']
return forms, pattern
formatvalues = {'': []}
for pattern, function in self.get_functions('format_'):
forms, pattern = extract_forms(name, pattern)
for form in forms:
if form not in formatvalues:
formatvalues[form] = []
formatvalues[form].append(
BuiltinRule(name, pattern, function, None, system=True))
for pattern, replace in self.formats.items():
forms, pattern = extract_forms(name, pattern)
for form in forms:
if form not in formatvalues:
formatvalues[form] = []
if not isinstance(pattern, BaseExpression):
pattern = pattern % {'name': name}
pattern = parse_builtin_rule(pattern)
replace = replace % {'name': name}
formatvalues[form].append(
Rule(pattern, parse_builtin_rule(replace), system=True))
for form, formatrules in formatvalues.items():
formatrules.sort()
messages = [
Rule(Expression('MessageName', Symbol(name), String(msg)),
String(value),
system=True) for msg, value in self.messages.items()
]
messages.append(
Rule(Expression('MessageName', Symbol(name), String('optx')),
String('`1` is not a supported option for `2`[].'),
system=True))
if name == 'System`MakeBoxes':
attributes = []
else:
attributes = ['System`Protected']
attributes += list(ensure_context(a) for a in self.attributes)
options = {}
for option, value in self.options.items():
option = ensure_context(option)
options[option] = parse_builtin_rule(value)
if option.startswith('System`'):
# Create a definition for the option's symbol.
# Otherwise it'll be created in Global` when it's
# used, so it won't work.
if option not in definitions.builtin:
definitions.builtin[option] = Definition(name=name,
attributes=set())
defaults = []
for spec, value in self.defaults.items():
value = parse_builtin_rule(value)
pattern = None
if spec is None:
pattern = Expression('Default', Symbol(name))
elif isinstance(spec, int):
pattern = Expression('Default', Symbol(name), Integer(spec))
if pattern is not None:
defaults.append(Rule(pattern, value, system=True))
definition = Definition(name=name,
rules=rules,
formatvalues=formatvalues,
messages=messages,
attributes=attributes,
options=options,
defaultvalues=defaults)
if pymodule:
definitions.pymathics[name] = definition
else:
definitions.builtin[name] = definition
makeboxes_def = definitions.builtin['System`MakeBoxes']
for rule in box_rules:
makeboxes_def.add_rule(rule)
def assign_elementary(self, lhs, rhs, evaluation, tags=None, upset=False):
name = lhs.get_head_name()
if name in ('OwnValues', 'DownValues', 'SubValues', 'UpValues',
'NValues', 'Options', 'DefaultValues', 'Attributes',
'Messages'):
if len(lhs.leaves) != 1:
evaluation.message_args(name, len(lhs.leaves), 1)
return False
tag = lhs.leaves[0].get_name()
if not tag:
evaluation.message(name, 'sym', lhs.leaves[0], 1)
return False
if tags is not None and tags != [tag]:
evaluation.message(name, 'tag', name, tag)
return False
if name != 'Attributes' and 'Protected' in evaluation.definitions.get_attributes(
tag):
evaluation.message(name, 'wrsym', tag)
return False
if name == 'Options':
option_values = rhs.get_option_values(evaluation)
if option_values is None:
evaluation.message(name, 'options', rhs)
return False
evaluation.definitions.set_options(tag, option_values)
elif name == 'Attributes':
attributes = get_symbol_list(
rhs, lambda item: evaluation.message(name, 'sym', item, 1))
if attributes is None:
return False
if 'Locked' in evaluation.definitions.get_attributes(tag):
evaluation.message(name, 'locked', tag)
return False
evaluation.definitions.set_attributes(tag, attributes)
else:
rules = rhs.get_rules_list()
if rules is None:
evaluation.message(name, 'vrule', lhs, rhs)
return False
evaluation.definitions.set_values(tag, name, rules)
return True
form = ''
nprec = None
default = False
message = False
allow_custom_tag = False
focus = lhs
if name == 'N':
if len(lhs.leaves) not in (1, 2):
evaluation.message_args('N', len(lhs.leaves), 1, 2)
return False
if len(lhs.leaves) == 1:
nprec = Symbol('MachinePrecision')
else:
nprec = lhs.leaves[1]
focus = lhs.leaves[0]
lhs = Expression('N', focus, nprec)
elif name == 'MessageName':
if len(lhs.leaves) != 2:
evaluation.message_args('MessageName', len(lhs.leaves), 2)
return False
focus = lhs.leaves[0]
message = True
elif name == 'Default':
if len(lhs.leaves) not in (1, 2, 3):
evaluation.message_args('Default', len(lhs.leaves), 1, 2, 3)
return False
focus = lhs.leaves[0]
default = True
elif name == 'Format':
if len(lhs.leaves) not in (1, 2):
evaluation.message_args('Format', len(lhs.leaves), 1, 2)
return False
if len(lhs.leaves) == 2:
form = lhs.leaves[1].get_name()
if not form:
evaluation.message('Format', 'fttp', lhs.leaves[1])
return False
else:
form = (
'StandardForm',
'TraditionalForm',
'OutputForm',
'TeXForm',
'MathMLForm',
)
lhs = focus = lhs.leaves[0]
else:
allow_custom_tag = True
focus = focus.evaluate_leaves(evaluation)
if tags is None and not upset:
name = focus.get_lookup_name()
if not name:
evaluation.message(self.get_name(), 'setraw', focus)
return False
tags = [name]
elif upset:
if allow_custom_tag:
tags = []
if focus.is_atom():
evaluation.message(self.get_name(), 'normal')
return False
for leaf in focus.leaves:
name = leaf.get_lookup_name()
tags.append(name)
else:
tags = [focus.get_lookup_name()]
else:
allowed_names = [focus.get_lookup_name()]
if allow_custom_tag:
for leaf in focus.get_leaves():
allowed_names.append(leaf.get_lookup_name())
for name in tags:
if name not in allowed_names:
evaluation.message(self.get_name(), 'tagnfd', name)
return False
ignore_protection = False
rhs_int_value = rhs.get_int_value()
lhs_name = lhs.get_name()
if lhs_name == '$RecursionLimit':
#if (not rhs_int_value or rhs_int_value < 20) and not rhs.get_name() == 'Infinity':
if not rhs_int_value or rhs_int_value < 20 or rhs_int_value > settings.MAX_RECURSION_DEPTH:
evaluation.message('$RecursionLimit', 'limset', rhs)
return False
ignore_protection = True
elif lhs_name == '$ModuleNumber':
if not rhs_int_value or rhs_int_value <= 0:
evaluation.message('$ModuleNumber', 'set', rhs)
return False
ignore_protection = True
elif lhs_name in ('$Line', '$HistoryLength'):
if rhs_int_value is None or rhs_int_value < 0:
evaluation.message(lhs_name, 'intnn', rhs)
return False
ignore_protection = True
elif lhs_name == '$RandomState':
# TODO: allow setting of legal random states!
# (but consider pickle's insecurity!)
evaluation.message('$RandomState', 'rndst', rhs)
return False
rhs_name = rhs.get_head_name()
if rhs_name == 'Condition':
if len(rhs.leaves) != 2:
evaluation.message_args('Condition', len(rhs.leaves), 2)
return False
else:
lhs = Expression('Condition', lhs, rhs.leaves[1])
rhs = rhs.leaves[0]
rule = Rule(lhs, rhs)
count = 0
defs = evaluation.definitions
for tag in tags:
if not ignore_protection and 'Protected' in evaluation.definitions.get_attributes(
tag):
if lhs.get_name() == tag:
evaluation.message(self.get_name(), 'wrsym', tag)
else:
evaluation.message(self.get_name(), 'write', tag, lhs)
continue
count += 1
if form:
defs.add_format(tag, rule, form)
elif nprec:
defs.add_nvalue(tag, rule)
elif default:
defs.add_default(tag, rule)
elif message:
defs.add_message(tag, rule)
else:
if upset:
defs.add_rule(tag, rule, position='up')
else:
defs.add_rule(tag, rule)
if count == 0:
return False
return True
def contribute(self, definitions):
from mathics.core.parser import parse
name = self.get_name()
rules = []
for pattern, function in self.get_functions():
rules.append(BuiltinRule(pattern, function, system=True))
for pattern, replace in self.rules.items():
if not isinstance(pattern, BaseExpression):
pattern = pattern % {'name': name}
pattern = parse(pattern)
replace = replace % {'name': name}
rules.append(Rule(pattern, parse(replace), system=True))
box_rules = []
if name != 'MakeBoxes':
new_rules = []
for rule in rules:
if rule.pattern.get_head_name() == 'MakeBoxes':
box_rules.append(rule)
else:
new_rules.append(rule)
rules = new_rules
formatvalues = {'': []}
for pattern, function in self.get_functions('format_'):
if isinstance(pattern, tuple):
forms, pattern = pattern
else:
forms = ['']
for form in forms:
if form not in formatvalues:
formatvalues[form] = []
formatvalues[form].append(BuiltinRule(pattern, function, system=True))
for pattern, replace in self.formats.items():
if isinstance(pattern, tuple):
forms, pattern = pattern
if not isinstance(forms, tuple):
forms = [forms]
else:
forms, pattern = [''], pattern
for form in forms:
if not form in formatvalues:
formatvalues[form] = []
formatvalues[form].append(Rule(parse(pattern), parse(replace), system=True))
for form, formatrules in formatvalues.items():
formatrules.sort()
messages = [Rule(Expression('MessageName', Symbol(name), String(msg)), String(value), system=True) for msg, value in self.messages.items()]
if name == 'MakeBoxes':
attributes = []
else:
attributes = ['Protected']
attributes += list(self.attributes)
options = {}
for option, value in self.options.iteritems():
options[option] = parse(value)
defaults = []
for spec, value in self.defaults.iteritems():
value = parse(value)
pattern = None
if spec is None:
pattern = Expression('Default', Symbol(name))
elif isinstance(spec, int):
pattern = Expression('Default', Symbol(name), Integer(spec))
if pattern is not None:
defaults.append(Rule(pattern, value, system=True))
definition = Definition(name=name, rules=rules, formatvalues=formatvalues,
messages=messages, attributes=attributes, options=options,
defaultvalues=defaults)
definitions.builtin[name] = definition
makeboxes_def = definitions.builtin['MakeBoxes']
for rule in box_rules:
makeboxes_def.add_rule(rule)
def __init__(
self,
definitions,
style: str,
want_completion: bool,
use_unicode: bool,
prompt: bool,
):
super(TerminalShellCommon, self).__init__("<stdin>")
self.input_encoding = locale.getpreferredencoding()
self.lineno = 0
self.terminal_formatter = None
self.mma_pygments_lexer = PygmentsLexer(MathematicaLexer)
self.prompt = prompt
self.session = PromptSession(history=FileHistory(HISTFILE))
# Try importing readline to enable arrow keys support etc.
self.using_readline = False
self.history_length = definitions.get_config_value(
"$HistoryLength", HISTSIZE)
self.using_readline = sys.stdin.isatty() and sys.stdout.isatty()
self.ansi_color_re = re.compile("\033\\[[0-9;]+m")
colorama_init()
if style == "None":
self.terminal_formatter = None
self.incolors = self.outcolors = ["", "", "", ""]
else:
# self.incolors = ["\033[34m", "\033[1m", "\033[22m", "\033[39m"]
self.incolors = ["\033[32m", "\033[1m", "\033[22m", "\033[39m"]
self.outcolors = ["\033[31m", "\033[1m", "\033[22m", "\033[39m"]
if style is not None and not is_pygments_style(style):
style = None
if style is None:
dark_background = is_dark_background()
if dark_background:
style = "inkpot"
else:
style = "colorful"
try:
self.terminal_formatter = Terminal256Formatter(style=style)
except ClassNotFound:
print(
"Pygments style name '%s' not found; No pygments style set"
% style)
self.pygments_style = style
self.definitions = definitions
self.definitions.set_ownvalue("Settings`$PygmentsShowTokens",
from_python(False))
self.definitions.set_ownvalue("Settings`$PygmentsStyle",
from_python(style))
self.definitions.set_ownvalue("Settings`$UseUnicode",
from_python(use_unicode))
self.definitions.set_ownvalue("Settings`PygmentsStylesAvailable",
from_python(ALL_PYGMENTS_STYLES))
read_inputrc(use_unicode=use_unicode)
self.definitions.add_message(
"Settings`PygmentsStylesAvailable",
Rule(
Expression(
"System`MessageName",
Symbol("Settings`PygmentsStylesAvailable"),
from_python("usage"),
),
from_python(
"A list of Pygments style that are valid in Settings`$PygmentsStyle."
),
),
)
self.definitions.set_attribute("Settings`PygmentsStylesAvailable",
"System`Protected")
self.definitions.set_attribute("Settings`PygmentsStylesAvailable",
"System`Locked")
self.definitions.set_attribute("Settings`$UseUnicode", "System`Locked")
self.completer = MathicsCompleter(
self.definitions) if want_completion else None
def get_assumption_rules_dispatch(evaluation):
# TODO: cache the generated rules...
assumptions_list = get_assumptions_list(evaluation)
if assumptions_list is None:
return None
# check for consistency:
consistent_assumptions = Expression("And", *assumptions_list)
val_consistent_assumptions = consistent_assumptions.evaluate(evaluation)
if val_consistent_assumptions == SymbolFalse:
evaluation.message("Inconsistent assumptions")
if assumptions_list is None:
return remove_nots_when_unnecesary(pred, evaluation).evaluate(evaluation)
# Expands Logically
assumptions_list, cont = logical_expand_assumptions(assumptions_list, evaluation)
while cont:
assumptions_list, cont = logical_expand_assumptions(
assumptions_list, evaluation
)
# Expands algebraically
assumptions_list, cont = algebraic_expand_assumptions(assumptions_list, evaluation)
while cont:
assumptions_list, cont = algebraic_expand_assumptions(
assumptions_list, evaluation
)
assumption_rules = []
for pat in assumptions_list:
value = True
while pat.has_form("Not", 1):
value = not value
pat = pat._leaves[0]
if value:
symbol_value = SymbolTrue
symbol_negate_value = SymbolFalse
else:
symbol_value = SymbolFalse
symbol_negate_value = SymbolTrue
if pat.has_form("Equal", 2):
if value:
lhs, rhs = pat._leaves
if lhs.is_numeric(evaluation):
assumption_rules.append(Rule(rhs, lhs))
else:
assumption_rules.append(Rule(lhs, rhs))
else:
assumption_rules.append(Rule(pat, SymbolFalse))
symm_pat = Expression(pat._head, pat._leaves[1], pat._leaves[0])
assumption_rules.append(Rule(symm_pat, SymbolFalse))
elif pat.has_form("Equivalent", 2):
assumption_rules.append(Rule(pat, symbol_value))
symm_pat = Expression(pat._head, pat._leaves[1], pat._leaves[0])
assumption_rules.append(Rule(symm_pat, symbol_value))
elif pat.has_form("Less", 2):
if value:
assumption_rules.append(Rule(pat, SymbolTrue))
assumption_rules.append(
Rule(
Expression(pat._head, pat._leaves[1], pat._leaves[0]),
SymbolFalse,
)
)
for head in ("Equal", "Equivalent"):
assumption_rules.append(
Rule(
Expression(head, pat._leaves[0], pat._leaves[1]),
SymbolFalse,
)
)
assumption_rules.append(
Rule(
Expression(head, pat._leaves[1], pat._leaves[0]),
SymbolFalse,
)
)
else:
assumption_rules.append(Rule(pat, SymbolFalse))
else:
assumption_rules.append(Rule(pat, symbol_value))
# TODO: expand the pred and assumptions into an standard,
# atomized form, and then apply the rules...
if len(assumption_rules) == 0:
return None
return assumption_rules
def contribute(self, definitions):
from mathics.core.parser import parse_builtin_rule
name = self.get_name()
rules = []
for pattern, function in self.get_functions():
rules.append(BuiltinRule(pattern, function, system=True))
for pattern, replace in self.rules.items():
if not isinstance(pattern, BaseExpression):
pattern = pattern % {'name': name}
pattern = parse_builtin_rule(pattern)
replace = replace % {'name': name}
rules.append(
Rule(pattern, parse_builtin_rule(replace), system=True))
box_rules = []
if name != 'System`MakeBoxes':
new_rules = []
for rule in rules:
if rule.pattern.get_head_name() == 'System`MakeBoxes':
box_rules.append(rule)
else:
new_rules.append(rule)
rules = new_rules
def extract_forms(name, pattern):
# Handle a tuple of (forms, pattern) as well as a pattern
# on the left-hand side of a format rule. 'forms' can be
# an empty string (=> the rule applies to all forms), or a
# form name (like 'System`TraditionalForm'), or a sequence
# of form names.
def contextify_form_name(f):
# Handle adding 'System`' to a form name, unless it's
# '' (meaning the rule applies to all forms).
return '' if f == '' else ensure_context(f)
if isinstance(pattern, tuple):
forms, pattern = pattern
if isinstance(forms, str):
forms = [contextify_form_name(forms)]
else:
forms = [contextify_form_name(f) for f in forms]
else:
forms = ['']
return forms, pattern
formatvalues = {'': []}
for pattern, function in self.get_functions('format_'):
forms, pattern = extract_forms(name, pattern)
for form in forms:
if form not in formatvalues:
formatvalues[form] = []
formatvalues[form].append(
BuiltinRule(pattern, function, system=True))
for pattern, replace in self.formats.items():
forms, pattern = extract_forms(name, pattern)
for form in forms:
if not form in formatvalues:
formatvalues[form] = []
if not isinstance(pattern, BaseExpression):
pattern = parse_builtin_rule(pattern)
formatvalues[form].append(
Rule(pattern, parse_builtin_rule(replace), system=True))
for form, formatrules in formatvalues.items():
formatrules.sort()
messages = [
Rule(Expression('MessageName', Symbol(name), String(msg)),
String(value),
system=True) for msg, value in self.messages.items()
]
if name == 'System`MakeBoxes':
attributes = []
else:
attributes = ['System`Protected']
attributes += list(ensure_context(a) for a in self.attributes)
options = {}
for option, value in self.options.iteritems():
option = ensure_context(option)
options[option] = parse_builtin_rule(value)
if option.startswith('System`'):
# Create a definition for the option's symbol.
# Otherwise it'll be created in Global` when it's
# used, so it won't work.
if option not in definitions.builtin:
definitions.builtin[option] = Definition(name=name,
attributes=set())
defaults = []
for spec, value in self.defaults.iteritems():
value = parse_builtin_rule(value)
pattern = None
if spec is None:
pattern = Expression('Default', Symbol(name))
elif isinstance(spec, int):
pattern = Expression('Default', Symbol(name), Integer(spec))
if pattern is not None:
defaults.append(Rule(pattern, value, system=True))
definition = Definition(name=name,
rules=rules,
formatvalues=formatvalues,
messages=messages,
attributes=attributes,
options=options,
defaultvalues=defaults)
definitions.builtin[name] = definition
makeboxes_def = definitions.builtin['System`MakeBoxes']
for rule in box_rules:
makeboxes_def.add_rule(rule)