From 1cec086a6034ad546977cae7aeaf4bb876d21970 Mon Sep 17 00:00:00 2001 From: Bruce Hill Date: Sun, 21 Sep 2025 16:54:36 -0400 Subject: Deprecate `>> x ... = val` form of doctests and rename them to 'debug logs', also add multi-expression support --- src/compile/debuglog.c | 115 +++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 115 insertions(+) create mode 100644 src/compile/debuglog.c (limited to 'src/compile/debuglog.c') diff --git a/src/compile/debuglog.c b/src/compile/debuglog.c new file mode 100644 index 00000000..498820ee --- /dev/null +++ b/src/compile/debuglog.c @@ -0,0 +1,115 @@ +// This file defines how to compile debug_log + +#include "../ast.h" +#include "../config.h" +#include "../environment.h" +#include "../stdlib/datatypes.h" +#include "../stdlib/text.h" +#include "../stdlib/util.h" +#include "../typecheck.h" +#include "compilation.h" + +public +Text_t compile_debug_log(env_t *env, ast_t *ast) { + DeclareMatch(debug, ast, DebugLog); + Text_t code = EMPTY_TEXT; + for (ast_list_t *value = debug->values; value; value = value->next) { + type_t *expr_t = get_type(env, value->ast); + if (!expr_t) code_err(value->ast, "I couldn't figure out the type of this expression"); + + Text_t setup = EMPTY_TEXT; + Text_t value_code; + if (value->ast->tag == Declare) { + DeclareMatch(decl, value->ast, Declare); + type_t *t = decl->type ? parse_type_ast(env, decl->type) : get_type(env, decl->value); + if (t->tag == FunctionType) t = Type(ClosureType, t); + Text_t var = Texts("_$", Match(decl->var, Var)->name); + Text_t val_code = compile_declared_value(env, value->ast); + setup = Texts(compile_declaration(t, var), ";\n"); + value_code = Texts("(", var, " = ", val_code, ")"); + expr_t = t; + } else if (value->ast->tag == Assign) { + DeclareMatch(assign, value->ast, Assign); + if (!assign->targets->next && assign->targets->ast->tag == Var && is_idempotent(assign->targets->ast)) { + // Common case: assigning to one variable: + type_t *lhs_t = get_type(env, assign->targets->ast); + if (assign->targets->ast->tag == Index && lhs_t->tag == OptionalType + && value_type(get_type(env, Match(assign->targets->ast, Index)->indexed))->tag == TableType) + lhs_t = Match(lhs_t, OptionalType)->type; + if (has_stack_memory(lhs_t)) + code_err(value->ast, "Stack references cannot be assigned " + "to variables because the " + "variable's scope may outlive the " + "scope of the stack memory."); + env_t *val_scope = with_enum_scope(env, lhs_t); + value_code = Texts("(", + compile_assignment(env, assign->targets->ast, + compile_to_type(val_scope, assign->values->ast, lhs_t)), + ")"); + expr_t = lhs_t; + } else { + // Multi-assign or assignment to potentially non-idempotent + // targets + value_code = Text("({ // Assignment\n"); + + int64_t i = 1; + for (ast_list_t *target = assign->targets, *assign_value = assign->values; target && assign_value; + target = target->next, assign_value = assign_value->next) { + type_t *lhs_t = get_type(env, target->ast); + if (target->ast->tag == Index && lhs_t->tag == OptionalType + && value_type(get_type(env, Match(target->ast, Index)->indexed))->tag == TableType) + lhs_t = Match(lhs_t, OptionalType)->type; + if (has_stack_memory(lhs_t)) + code_err(ast, "Stack references cannot be assigned to " + "variables because the " + "variable's scope may outlive the scope " + "of the stack memory."); + if (target == assign->targets) expr_t = lhs_t; + env_t *val_scope = with_enum_scope(env, lhs_t); + Text_t val_code = compile_to_type(val_scope, assign_value->ast, lhs_t); + value_code = Texts(value_code, compile_type(lhs_t), " $", i, " = ", val_code, ";\n"); + i += 1; + } + i = 1; + for (ast_list_t *target = assign->targets; target; target = target->next) { + value_code = Texts(value_code, compile_assignment(env, target->ast, Texts("$", i)), ";\n"); + i += 1; + } + + value_code = Texts(value_code, "$1; })"); + } + } else if (is_update_assignment(value->ast)) { + binary_operands_t update = UPDATE_OPERANDS(value->ast); + type_t *lhs_t = get_type(env, update.lhs); + if (update.lhs->tag == Index) { + type_t *indexed = value_type(get_type(env, Match(update.lhs, Index)->indexed)); + if (indexed->tag == TableType && Match(indexed, TableType)->default_value == NULL) + code_err(update.lhs, "Update assignments are not currently " + "supported for tables"); + } + + ast_t *update_var = new (ast_t); + *update_var = *value->ast; + update_var->__data.PlusUpdate.lhs = LiteralCode(Text("(*expr)"), .type = lhs_t); // UNSAFE + value_code = + Texts("({", compile_declaration(Type(PointerType, lhs_t), Text("expr")), " = &(", + compile_lvalue(env, update.lhs), "); ", compile_statement(env, update_var), "; *expr; })"); + expr_t = lhs_t; + } else if (expr_t->tag == VoidType || expr_t->tag == AbortType || expr_t->tag == ReturnType) { + value_code = Texts("({", compile_statement(env, value->ast), " NULL;})"); + } else { + value_code = compile(env, value->ast); + } + if (expr_t->tag == VoidType || expr_t->tag == AbortType) { + value_code = Texts(setup, "inspect_void(", value_code, ", ", compile_type_info(expr_t), ", ", + (int64_t)(value->ast->start - value->ast->file->text), ", ", + (int64_t)(value->ast->end - value->ast->file->text), ");"); + } else { + value_code = Texts(setup, "inspect(", compile_type(expr_t), ", ", value_code, ", ", + compile_type_info(expr_t), ", ", (int64_t)(value->ast->start - value->ast->file->text), + ", ", (int64_t)(value->ast->end - value->ast->file->text), ");"); + } + code = Texts(code, value_code); + } + return code; +} -- cgit v1.2.3