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)