コード例 #1
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)
コード例 #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(''.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)
コード例 #3
0
def string_exec(strings, out, visualize_tail_calls, global_frame=None):
    import log

    empty = False

    if global_frame is None:
        empty = True
        from environment import build_global_frame
        log.logger.f_delta -= 1
        global_frame = build_global_frame()
        log.logger.active_frames.pop(0)  # clear builtin frame
        log.logger.f_delta += 1
        log.logger.global_frame = log.logger.frame_lookup[id(global_frame)]
        log.logger.graphics_lookup[id(global_frame)] = Canvas()

    log.logger.export_states = []
    log.logger.roots = []
    log.logger.frame_updates = []
    log.logger._out = []
    log.logger.visualize_tail_calls(visualize_tail_calls)

    for i, string in enumerate(strings):
        try:
            if not string.strip():
                continue
            buff = TokenBuffer([string])
            while not buff.done:
                expr = get_expression(buff)
                if expr is None:
                    continue
                empty = False
                log.logger.new_expr()
                holder = Holder(expr, None)
                Root.setroot(holder)
                res = evaluate(expr, global_frame, holder)
                if res is not Undefined:
                    out(res)
                if not log.logger.fragile and log.logger.autodraw:
                    try:
                        log.logger.raw_out("AUTODRAW" +
                                           json.dumps([log.logger.i, log.logger.heap.record(res)]) + "\n")
                    except RecursionError:
                        pass
        except (SchemeError, ZeroDivisionError, RecursionError, ValueError) as e:
            if isinstance(e, ParseError):
                log.logger.new_expr()
                raise
            if not log.logger.fragile:
                log.logger.raw_out("Traceback (most recent call last)\n")
                for j, expr in enumerate(log.logger.eval_stack[:MAX_TRACEBACK_LENGTH - 1]):
                    log.logger.raw_out(str(j).ljust(3) + " " + expr + "\n")
                truncated = len(log.logger.eval_stack) - MAX_TRACEBACK_LENGTH
                if len(log.logger.eval_stack) > MAX_TRACEBACK_LENGTH:
                    log.logger.raw_out(f"[{truncated} lines omitted from traceback]\n")
                    log.logger.raw_out(
                        str(len(log.logger.eval_stack) - 1).ljust(3) + " " + log.logger.eval_stack[-1] + "\n"
                    )
            log.logger.out(e)
        except TimeLimitException:
            if not log.logger.fragile:
                log.logger.out("Time limit exceeded.")
        log.logger.new_expr()

    if empty:
        log.logger.new_expr()
        holder = Holder(Undefined, None)
        Root.setroot(holder)
        evaluate(Undefined, global_frame, holder)
        log.logger.new_expr()
コード例 #4
0
def string_exec(strings, out, global_frame=None):
    import log
    empty = False
    if (global_frame is None):
        empty = True
        from environment import build_global_frame
        log.logger.f_delta -= 1
        global_frame = build_global_frame()
        log.logger.active_frames.pop(0)
        log.logger.f_delta += 1
        log.logger.global_frame = log.logger.frame_lookup[id(global_frame)]
        log.logger.graphics_lookup[id(global_frame)] = Canvas()
    log.logger.export_states = []
    log.logger.roots = []
    log.logger.frame_updates = []
    log.logger._out = []
    for (i, string) in enumerate(strings):
        try:
            if (not string.strip()):
                continue
            buff = TokenBuffer([string])
            while (not buff.done):
                expr = get_expression(buff)
                if (expr is None):
                    continue
                empty = False
                log.logger.new_expr()
                holder = Holder(expr, None)
                Root.setroot(holder)
                res = evaluate(expr, global_frame, holder)
                if (res is not Undefined):
                    out(res)
                if ((not log.logger.fragile) and log.logger.autodraw
                        and isinstance(res, Pair)):
                    log.logger.raw_out((('AUTODRAW' + json.dumps(
                        [log.logger.i,
                         log.logger.heap.record(res)])) + '\n'))
        except (SchemeError, ZeroDivisionError, RecursionError,
                ValueError) as e:
            if isinstance(e, ParseError):
                log.logger.new_expr()
                raise
            if (not log.logger.fragile):
                log.logger.raw_out('Traceback (most recent call last)\n')
                for (j, expr) in enumerate(
                        log.logger.eval_stack[:(MAX_TRACEBACK_LENGTH - 1)]):
                    log.logger.raw_out(
                        (((str(j).ljust(3) + ' ') + expr) + '\n'))
                truncated = (len(log.logger.eval_stack) - MAX_TRACEBACK_LENGTH)
                if (len(log.logger.eval_stack) > MAX_TRACEBACK_LENGTH):
                    log.logger.raw_out(''.join([
                        '[', '{}'.format(truncated),
                        ' lines omitted from traceback]\n'
                    ]))
                    log.logger.raw_out((((str(
                        (len(log.logger.eval_stack) - 1)).ljust(3) + ' ') +
                                         log.logger.eval_stack[(-1)]) + '\n'))
            log.logger.out(e)
        except TimeLimitException:
            if (not log.logger.fragile):
                log.logger.out('Time limit exceeded.')
        log.logger.new_expr()
    if empty:
        log.logger.new_expr()
        holder = Holder(Undefined, None)
        Root.setroot(holder)
        evaluate(Undefined, global_frame, holder)
        log.logger.new_expr()