コード例 #1
0
ファイル: primitives.py プロジェクト: SallyPeng00/61a
 def execute(self, operands: List[Expression], frame: Frame, gui_holder: Holder, eval_operands=True) -> Expression:
     if eval_operands:
         operands = evaluate_all(
             operands, frame, gui_holder.expression.children[1:])
     gui_holder.expression.set_entries([])
     gui_holder.apply()
     return self.execute_evaluated(operands, frame)
コード例 #2
0
 def execute(self,
             operands: List[Expression],
             frame: Frame,
             gui_holder: Holder,
             eval_operands=True):
     verify_exact_callable_length(self, 1, len(operands))
     if eval_operands:
         operands = evaluate_all(operands, frame,
                                 gui_holder.expression.children[1:])
     if not isinstance(operands[0], Symbol):
         raise OperandDeduceError(
             f"Load expected a Symbol, received {operands[0]}.")
     if logger.fragile:
         raise IrreversibleOperationError()
     try:
         with open(f"{operands[0].value}.scm") as file:
             code = "(begin-noexcept" + "\n".join(file.readlines()) + "\n)"
             buffer = TokenBuffer([code])
             expr = get_expression(buffer)
             gui_holder.expression.set_entries([
                 VisualExpression(expr, gui_holder.expression.display_value)
             ])
             gui_holder.apply()
             return evaluate(expr, frame, gui_holder.expression.children[0],
                             True)
     except OSError as e:
         raise LoadError(e)
コード例 #3
0
 def execute(self,
             operands: List[Expression],
             frame: Frame,
             gui_holder: Holder,
             eval_operands=True):
     verify_exact_callable_length(self, 1, len(operands))
     operand = operands[0]
     if eval_operands:
         operand = evaluate_all(operands, frame,
                                gui_holder.expression.children[1:])[0]
     if not isinstance(operand, Promise):
         raise OperandDeduceError(
             f"Force expected a Promise, received {operand}")
     if operand.forced:
         return operand.expr
     if logger.fragile:
         raise IrreversibleOperationError()
     gui_holder.expression.set_entries([
         VisualExpression(operand.expr, gui_holder.expression.display_value)
     ])
     gui_holder.apply()
     evaluated = evaluate(operand.expr, operand.frame,
                          gui_holder.expression.children[0])
     if not logger.dotted and not isinstance(evaluated, (Pair, NilType)):
         raise TypeMismatchError(
             f"Unable to force a Promise evaluating to {operand.expr}, expected another Pair or Nil"
         )
     operand.expr = evaluated
     operand.force()
     return operand.expr
コード例 #4
0
 def execute(self,
             operands: List[Expression],
             frame: Frame,
             gui_holder: Holder,
             eval_operands=True):
     verify_exact_callable_length(self, 1, len(operands))
     if eval_operands:
         operands = evaluate_all(operands, frame,
                                 gui_holder.expression.children[1:])
     if (not isinstance(operands[0], Symbol)):
         raise OperandDeduceError(''.join([
             'Load expected a Symbol, received ', '{}'.format(operands[0]),
             '.'
         ]))
     if logger.fragile:
         raise IrreversibleOperationError()
     try:
         with open(''.join(['{}'.format(operands[0].value),
                            '.scm'])) as file:
             code = (('(begin' + '\n'.join(file.readlines())) + '\n)')
             buffer = TokenBuffer([code])
             expr = get_expression(buffer)
             gui_holder.expression.set_entries([
                 VisualExpression(expr, gui_holder.expression.display_value)
             ])
             gui_holder.apply()
             return evaluate(expr, frame, gui_holder.expression.children[0],
                             True)
     except OSError as e:
         raise LoadError(e)
コード例 #5
0
 def execute(self, operands: List[Expression], frame: Frame, gui_holder: Holder, eval_operands=True):
     verify_exact_callable_length(self, 1, len(operands))
     if eval_operands:
         operand = evaluate(operands[0], frame, gui_holder.expression.children[1])
     else:
         operand = operands[0]
     gui_holder.expression.set_entries([VisualExpression(operand, gui_holder.expression.display_value)])
     gui_holder.apply()
     return evaluate(operand, frame, gui_holder.expression.children[0], True)
コード例 #6
0
 def execute(self, operands: List[Expression], frame: Frame, gui_holder: Holder, eval_operands=True):
     verify_exact_callable_length(self, 2, len(operands))
     if eval_operands:
         operands = evaluate_all(operands, frame, gui_holder.expression.children[1:])
     func, args = operands
     if not isinstance(func, Applicable):
         raise OperandDeduceError(f"Unable to apply {func}.")
     gui_holder.expression.set_entries([VisualExpression(Pair(func, args), gui_holder.expression.display_value)])
     gui_holder.expression.children[0].expression.children = []
     gui_holder.apply()
     args = pair_to_list(args)
     return func.execute(args, frame, gui_holder.expression.children[0], False)
コード例 #7
0
    def execute(self,
                operands: List[Expression],
                frame: Frame,
                gui_holder: Holder,
                eval_operands=True):
        new_frame = Frame(self.name,
                          self.frame if self.lexically_scoped else frame)

        if eval_operands and self.evaluates_operands:
            operands = evaluate_all(operands, frame,
                                    gui_holder.expression.children[1:])

        if self.var_param:
            verify_min_callable_length(self, len(self.params), len(operands))
        else:
            verify_exact_callable_length(self, len(self.params), len(operands))

        if len(self.body) > 1:
            body = [Pair(Symbol("begin"), make_list(self.body))]
        else:
            body = self.body

        for param, value in zip(self.params, operands):
            new_frame.assign(param, value)

        if self.var_param:
            new_frame.assign(self.var_param,
                             make_list(operands[len(self.params):]))

        out = None
        gui_holder.expression.set_entries([
            VisualExpression(expr, gui_holder.expression.display_value)
            for expr in body
        ])

        gui_holder.apply()

        for i, expression in enumerate(body):
            out = evaluate(expression,
                           new_frame,
                           gui_holder.expression.children[i],
                           self.evaluates_operands and i == len(body) - 1,
                           log_stack=len(self.body) == 1)

        new_frame.assign(return_symbol, out)

        if not self.evaluates_operands:
            gui_holder.expression.set_entries(
                [VisualExpression(out, gui_holder.expression.display_value)])
            out = evaluate(out, frame, gui_holder.expression.children[i], True)

        return out
コード例 #8
0
 def execute(self, operands: List[Expression], frame: Frame, gui_holder: Holder, eval_operands=True):
     verify_exact_callable_length(self, 1, len(operands))
     if eval_operands:
         operands = evaluate_all(operands, frame, gui_holder.expression.children[1:])
     if not isinstance(operands[0], String):
         raise OperandDeduceError(f"Load expected a String, received {operands[0]}.")
     if logger.fragile:
         raise IrreversibleOperationError()
     from os import listdir
     from os.path import join
     directory = operands[0].value
     try:
         targets = sorted(listdir(directory))
         targets = [join(directory, target) for target in targets if target.endswith(".scm")]
         exprs = [make_list([Symbol("load"), make_list([Symbol("quote"), Symbol(x[:-4])])]) for x in targets]
         equiv = make_list([Symbol("begin-noexcept")] + exprs)
         gui_holder.expression.set_entries([equiv])
         gui_holder.apply()
         return evaluate(equiv, frame, gui_holder.expression.children[0], True)
     except Exception as e:
         raise SchemeError(e)