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(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_evaluated(self, operands: List[Expression], frame: Frame) -> Expression:
if len(operands) == 0:
return Nil
exprs = []
for operand in operands[:-1]:
if not isinstance(operand, Pair) and operand is not Nil:
raise OperandDeduceError(f"Expected operand to be valid list, not {operand}")
exprs.extend(pair_to_list(operand))
out = operands[-1]
for expr in reversed(exprs):
out = Pair(expr, out)
return out
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:
if (len(operands) == 0):
return Nil
exprs = []
for operand in operands[:(- 1)]:
if ((not isinstance(operand, Pair)) and (operand is not Nil)):
raise OperandDeduceError(
''.join(['Expected operand to be valid list, not ', '{}'.format(operand)]))
exprs.extend(pair_to_list(operand))
out = operands[(- 1)]
for expr in reversed(exprs):
out = Pair(expr, out)
return out
def make_list(exprs: List[Expression], last: Expression = Nil) -> Union[(Pair, NilType)]:
out = last
for expr in reversed(exprs):
out = Pair(expr, out)
return out
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 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 = VisualExpression(expr)
gui_holder.link_visual(visual_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(''.join([
'Can only splice lists, not ',
'{}'.format(evaluated), '.'
]))
out.extend(pair_to_list(evaluated))
else:
out.append(evaluated)
out = make_list(out)
else:
if (not logger.dotted):
raise OperandDeduceError(''.join([
'{}'.format(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 make_list(exprs: List[Expression],
last: Expression = Nil) -> Union[(Pair, NilType)]:
if (len(exprs) == 0):
return last
return Pair(exprs[0], make_list(exprs[1:], last))
def execute_evaluated(self, operands: List[Expression],
frame: Frame) -> Expression:
verify_exact_callable_length(self, 2, len(operands))
return Pair(operands[0], operands[1])
