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))
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):
verify_exact_callable_length(self, 2, len(operands))
name = operands[0]
if not isinstance(name, Symbol):
raise OperandDeduceError(f"Expected a Symbol, not {name}, as the first operand of set!")
frame.mutate(name, evaluate(operands[1], frame, gui_holder.expression.children[2]))
return Undefined
def execute(self, operands: List[Expression], frame: Frame,
gui_holder: Holder):
verify_min_callable_length(self, 2, len(operands))
params = operands[0]
if isinstance(params, Symbol):
verify_exact_callable_length(self, 2, len(operands))
frame.assign(
params,
evaluate(operands[1], frame,
gui_holder.expression.children[2]))
return params
elif isinstance(params, Pair):
name = params.first
operands[0] = params.rest
if (not isinstance(name, Symbol)):
raise OperandDeduceError(''.join(
['Expected a Symbol, not ', '{}'.format(name), '.']))
frame.assign(
name,
Lambda().execute(operands, frame, gui_holder, name.value))
return name
else:
raise OperandDeduceError(''.join([
'Expected a Pair, not ', '{}'.format(params),
', as the first operand of define-macro.'
]))
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_evaluated(self, operands: List[Expression],
frame: Frame) -> Expression:
verify_exact_callable_length(self, 2, len(operands))
assert_all_numbers(operands)
negate = (operands[0].value < 0) != (operands[1].value < 0)
negate = -1 if negate else 1
return Number(negate * operands[0].value // operands[1].value)
def execute_evaluated(self, operands: List[Expression],
frame: Frame) -> Expression:
verify_exact_callable_length(self, 0, len(operands))
if log.logger.fragile:
raise IrreversibleOperationError()
log.logger.raw_out("DISABLE_AUTODRAW[]\n")
return Undefined
def execute_evaluated(self, operands: List[Expression], frame: Frame):
verify_exact_callable_length(self, 2, len(operands))
for operand in operands:
if (not isinstance(operand, Number)):
raise OperandDeduceError(
''.join(['Expected operand to be Number, not ', '{}'.format(operand)]))
log.logger.get_canvas().move(operands[0].value, (- operands[1].value))
return Undefined
def execute_evaluated(self, operands: List[Expression], frame: Frame):
verify_exact_callable_length(self, 2, len(operands))
if all(isinstance(x, ValueHolder) for x in operands):
if isinstance(operands[0], Number):
return bools[operands[0] is operands[1]]
else:
return bools[operands[0].value == operands[1].value]
return bools[operands[0] is operands[1]]
def execute_evaluated(self, operands: List[Expression], frame: Frame):
verify_exact_callable_length(self, 2, len(operands))
for operand in operands:
if not isinstance(operand, Number):
raise OperandDeduceError(
f"Expected operand to be Number, not {operand}")
log.logger.get_canvas().move(operands[0].value, -operands[1].value)
return Undefined
def execute_evaluated(self, operands: List[Expression], frame: Frame):
verify_exact_callable_length(self, 2, len(operands))
if all(isinstance(x, ValueHolder) for x in operands):
return bools[operands[0].value == operands[1].value]
elif all(isinstance(x, Pair) for x in operands):
return bools[IsEqual().execute_evaluated([operands[0].first, operands[1].first], frame) is SingletonTrue and \
IsEqual().execute_evaluated([operands[0].rest, operands[1].rest], frame) is SingletonTrue]
else:
return IsEqv().execute_evaluated(operands, frame)
def execute_evaluated(self, operands: List[Expression], frame: Frame) -> Expression:
verify_exact_callable_length(self, 3, len(operands))
(x, y, c) = operands
for v in (x, y):
if (not isinstance(v, Number)):
raise OperandDeduceError(
''.join(['Expected operand to be Number, not ', '{}'.format(v)]))
log.logger.get_canvas().pixel(x.value, y.value, make_color(c))
return Undefined
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 quasiquote_evaluate(cls, expr: Expression, frame: Frame, gui_holder: Holder, splicing=False):
is_well_formed = False
if isinstance(expr, Pair):
try:
lst = pair_to_list(expr)
except OperandDeduceError:
pass
else:
is_well_formed = not any(map(
lambda x: isinstance(x, Symbol) and x.value in ["unquote", "quasiquote", "unquote-splicing"], lst))
visual_expression = gui_holder.expression
if not is_well_formed:
visual_expression.children[2:] = []
if isinstance(expr, Pair):
if isinstance(expr.first, Symbol) and expr.first.value in ("unquote", "unquote-splicing"):
if expr.first.value == "unquote-splicing" and not splicing:
raise OperandDeduceError("Unquote-splicing must be in list template.")
gui_holder.evaluate()
verify_exact_callable_length(expr.first, 1, len(pair_to_list(expr)) - 1)
out = evaluate(expr.rest.first, frame, visual_expression.children[1])
visual_expression.value = out
gui_holder.complete()
return out
elif isinstance(expr.first, Symbol) and expr.first.value == "quasiquote":
visual_expression.value = expr
gui_holder.complete()
return expr
else:
if is_well_formed:
out = []
for sub_expr, holder in zip(pair_to_list(expr), visual_expression.children):
splicing = isinstance(sub_expr, Pair) and isinstance(sub_expr.first, Symbol) \
and sub_expr.first.value == "unquote-splicing"
evaluated = Quasiquote.quasiquote_evaluate(sub_expr, frame, holder, splicing)
if splicing:
if not isinstance(evaluated, (Pair, NilType)):
raise TypeMismatchError(f"Can only splice lists, not {evaluated}.")
out.extend(pair_to_list(evaluated))
else:
out.append(evaluated)
out = make_list(out)
else:
if not logger.dotted:
raise OperandDeduceError(f"{expr} is an ill-formed quasiquotation.")
out = Pair(Quasiquote.quasiquote_evaluate(expr.first, frame, visual_expression.children[0]),
Quasiquote.quasiquote_evaluate(expr.rest, frame, visual_expression.children[1]))
visual_expression.value = out
gui_holder.complete()
return out
else:
visual_expression.value = expr
gui_holder.complete()
return expr
def execute_evaluated(self, operands: List[Expression], frame: Frame) -> Expression:
verify_exact_callable_length(self, 2, len(operands))
if log.logger.fragile:
raise IrreversibleOperationError()
pair, val = operands
if not isinstance(pair, Pair):
raise OperandDeduceError(f"set-car! expected a Pair, received {pair}.")
pair.first = val
log.logger.raw_out("WARNING: Mutation operations on pairs are not yet supported by the debugger.")
return Undefined
def execute_evaluated(self, operands: List[Expression],
frame: Frame) -> Expression:
verify_exact_callable_length(self, 3, len(operands))
x, y, c, = operands
for v in x, y:
if not isinstance(v, Number):
raise OperandDeduceError(
f"Expected operand to be Number, not {v}")
log.logger.get_canvas().pixel(x.value, y.value, make_color(c))
return Undefined
def execute_evaluated(self, operands: List[Expression], frame: Frame) -> Expression:
verify_exact_callable_length(self, 3, len(operands))
for operand in operands:
if (not isinstance(operand, Number)):
raise OperandDeduceError(
''.join(['Expected operand to be Number, not ', '{}'.format(operand)]))
if (not (0 <= operand.value <= 1)):
raise OperandDeduceError(
''.join(['RGB values must be between 0 and 1, not ', '{}'.format(operand)]))
return String(('#' + ''.join(('{:02X}'.format(int((x.value * 255))) for x in operands))))
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:])
raise SchemeError(operands[0])
def execute(self, operands: List[Expression], frame: Frame, gui_holder: Holder):
verify_min_callable_length(self, 2, len(operands))
if len(operands) > 3:
verify_exact_callable_length(self, 3, len(operands))
if evaluate(operands[0], frame, gui_holder.expression.children[1]) is SingletonFalse:
if len(operands) == 2:
return Undefined
else:
return evaluate(operands[2], frame, gui_holder.expression.children[3], True)
else:
return evaluate(operands[1], frame, gui_holder.expression.children[2], True)
def execute_evaluated(self, operands: List[Expression],
frame: Frame) -> Expression:
verify_exact_callable_length(self, 3, len(operands))
for operand in operands:
if not isinstance(operand, Number):
raise OperandDeduceError(
f"Expected operand to be Number, not {operand}")
if not 0 <= operand.value <= 1:
raise OperandDeduceError(
f"RGB values must be between 0 and 1, not {operand}")
return String("#" + "".join('{:02X}'.format(int(x.value * 255))
for x in operands))
def execute_evaluated(self, operands: List[Expression], frame: Frame) -> Expression:
verify_exact_callable_length(self, 2, len(operands))
if log.logger.fragile:
raise IrreversibleOperationError()
(pair, val) = operands
if (not isinstance(pair, Pair)):
raise OperandDeduceError(
''.join(['set-car! expected a Pair, received ', '{}'.format(pair), '.']))
pair.first = val
log.logger.raw_out(
'WARNING: Mutation operations on pairs are not yet supported by the debugger.')
return Undefined
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_evaluated(self, operands: List[Expression], frame: Frame) -> Expression:
verify_min_callable_length(self, 1, len(operands))
if (len(operands) > 2):
verify_exact_callable_length(self, 2, len(operands))
if (not isinstance(operands[0], Number)):
raise OperandDeduceError(
''.join(['Expected radius to be Number, not ', '{}'.format(operands[0])]))
if ((len(operands) > 2) and (not isinstance(operands[1], Number))):
raise OperandDeduceError(
''.join(['Expected angle to be Number, not ', '{}'.format(operands[1])]))
degs = (360 if (len(operands) == 1) else operands[1].value)
log.logger.get_canvas().arc(operands[0].value, degs)
return Undefined
def execute_evaluated(self, operands: List[Expression],
frame: Frame) -> Expression:
verify_min_callable_length(self, 1, len(operands))
if len(operands) > 2:
verify_exact_callable_length(self, 2, len(operands))
if not isinstance(operands[0], Number):
raise OperandDeduceError(
f"Expected radius to be Number, not {operands[0]}")
if len(operands) > 2 and not isinstance(operands[1], Number):
raise OperandDeduceError(
f"Expected angle to be Number, not {operands[1]}")
degs = 360 if len(operands) == 1 else operands[1].value
log.logger.get_canvas().arc(operands[0].value, degs)
return Undefined
def execute(self, operands: List[Expression], frame: Frame,
gui_holder: Holder):
verify_exact_callable_length(self, 2, len(operands))
case = operands[0]
operands[0] = evaluate(operands[0], frame,
gui_holder.expression.children[1])
if not IsEqual().execute_evaluated(operands, frame).value:
log.logger.raw_out(
f"Evaluated {case}, expected {operands[1]}, got {operands[0]}.\n"
)
else:
log.logger.raw_out(
f"Evaluated {case}, got {operands[0]}, as expected.\n")
return Undefined
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)
def execute_evaluated(self, operands: List[Expression], frame: Frame) -> Expression:
verify_exact_callable_length(self, 1, len(operands))
operand = operands[0]
return self.execute_simple(operand)
def execute(self, operands: List[Expression], frame: Frame,
gui_holder: Holder):
verify_exact_callable_length(self, 2, len(operands))
operands[0] = evaluate(operands[0], frame,
gui_holder.expression.children[1])
return Pair(operands[0], Promise(operands[1], frame))
def execute(self, operands: List[Expression], frame: Frame,
gui_holder: Holder):
verify_exact_callable_length(self, 1, len(operands))
return Promise(operands[0], frame)