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)
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)
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
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)
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)
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)
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
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)