ast_printer: tuple-ify

This commit is contained in:
Luna 2020-04-01 16:03:46 -03:00
parent ebf4af6537
commit cf22d47e13

View file

@ -10,7 +10,7 @@ const warn = std.debug.warn;
fn printIdent(ident: usize) void {
var i: usize = 0;
while (i < ident) : (i += 1) {
std.debug.warn("\t");
std.debug.warn("\t", .{});
}
}
@ -20,12 +20,12 @@ fn print(ident: usize, comptime fmt: []const u8, args: ...) void {
}
fn printBlock(ident: usize, block: var, endNewline: bool) void {
std.debug.warn("(\n");
std.debug.warn("(\n", .{});
for (block.toSlice()) |stmt| {
printIdent(ident);
printStmt(ident, &stmt);
std.debug.warn("\n");
std.debug.warn("\n", .{});
}
if (endNewline) {
@ -48,18 +48,18 @@ pub fn printNode(node: *const Node, ident: usize) void {
const vari = method.variable.lexeme;
const typ = method.typ.lexeme;
warn("(method {} {} {} {} (", vari, typ, name, ret_type);
warn("(method {} {} {} {} (", .{ vari, typ, name, ret_type });
} else {
warn("(fn {} {} (", name, ret_type);
warn("(fn {} {} (", .{ name, ret_type });
}
for (decl.params.toSlice()) |param| {
warn(" ({} {})", param.name.lexeme, param.typ.lexeme);
warn(" ({} {})", .{ param.name.lexeme, param.typ.lexeme });
}
warn(") ");
warn(") ", .{});
printBlock(ident + 1, decl.body, false);
warn("\n");
warn("\n", .{});
},
.ConstDecl => |consts| {
@ -73,7 +73,7 @@ pub fn printNode(node: *const Node, ident: usize) void {
);
printExpr(const_decl.expr);
std.debug.warn(")\n");
std.debug.warn(")\n", .{});
}
print(ident, "))\n");
@ -114,20 +114,20 @@ pub fn printNode(node: *const Node, ident: usize) void {
}
fn parenthetize(name: []const u8, exprs: []const Expr) void {
std.debug.warn("({}", name);
std.debug.warn("({}", .{name});
for (exprs) |expr| {
std.debug.warn(" ");
std.debug.warn(" ", .{});
printExpr(&expr);
}
std.debug.warn(")");
std.debug.warn(")", .{});
}
fn printTwoExprs(expr_a: *const Expr, expr_b: *const Expr) void {
std.debug.warn(" ");
std.debug.warn(" ", .{});
printExpr(expr_a);
std.debug.warn(" ");
std.debug.warn(" ", .{});
printExpr(expr_b);
}
@ -161,9 +161,9 @@ fn binOpToStr(op: BinaryOperator) ?[]const u8 {
}
fn printBinOp(inner: var) void {
std.debug.warn("({}", binOpToStr(inner.op));
std.debug.warn("({}", .{binOpToStr(inner.op)});
printTwoExprs(inner.left, inner.right);
std.debug.warn(")");
std.debug.warn(")", .{});
}
const unary_operator_tokens = [_][]const u8{
@ -187,9 +187,9 @@ fn printSingleOp(op: UnaryOperator, applied: *const Expr) void {
}
fn printSimpleOp(op: ?[]const u8, applied: *const Expr) void {
std.debug.warn("({}", op);
std.debug.warn("({}", .{op});
printExpr(applied);
std.debug.warn(")");
std.debug.warn(")", .{});
}
pub fn printExpr(expr: *const Expr) void {
@ -201,66 +201,66 @@ pub fn printExpr(expr: *const Expr) void {
.Literal => |literal| {
switch (literal) {
.Bool => |val| std.debug.warn("{}", val),
.Integer32 => |val| std.debug.warn("{}", val),
.Integer64 => |val| std.debug.warn("{}", val),
.Float => |val| std.debug.warn("{}", val),
.String => |val| std.debug.warn("'{}'", val),
.Bool => |val| std.debug.warn("{}", .{val}),
.Integer32 => |val| std.debug.warn("{}", .{val}),
.Integer64 => |val| std.debug.warn("{}", .{val}),
.Float => |val| std.debug.warn("{}", .{val}),
.String => |val| std.debug.warn("'{}'", .{val}),
.Array => |exprs| {
parenthetize("array", exprs.toSlice());
},
else => |typ| std.debug.warn("UnknownLiteral-{}", typ),
else => |typ| std.debug.warn("UnknownLiteral-{}", .{typ}),
}
},
.Variable => |token| std.debug.warn("{}", token.lexeme),
.Variable => |token| std.debug.warn("{}", .{token.lexeme}),
.Assign => |assign| {
std.debug.warn("(set ");
std.debug.warn("{} ", assign.name.lexeme);
std.debug.warn("(set ", .{});
std.debug.warn("{} ", .{assign.name.lexeme});
printExpr(assign.value);
std.debug.warn(")");
std.debug.warn(")", .{});
},
.Call => |call| {
std.debug.warn("(");
std.debug.warn("(", .{});
printExpr(call.callee);
for (call.arguments.toSlice()) |arg| {
std.debug.warn(" ");
std.debug.warn(" ", .{});
printExpr(&arg);
}
std.debug.warn(")");
std.debug.warn(")", .{});
},
.Struct => |val| {
std.debug.warn("({} (", val.name.lexeme);
std.debug.warn("({} (", .{val.name.lexeme});
for (val.inits.toSlice()) |init| {
std.debug.warn(" ({} ", init.field.lexeme);
std.debug.warn(" ({} ", .{init.field.lexeme});
printExpr(init.expr);
std.debug.warn(")");
std.debug.warn(")", .{});
}
std.debug.warn("))");
std.debug.warn("))", .{});
},
.Get => |get| {
warn("(");
warn("(", .{});
printExpr(get.target);
warn(".{})", get.name.lexeme);
},
.Set => |set| {
warn("(set ");
warn("(set ", .{});
printExpr(set.struc);
warn(" {} ", set.field.lexeme);
warn(" {} ", .{set.field.lexeme});
printExpr(set.value);
warn(")");
warn(")", .{});
},
else => std.debug.warn("UnknownExpr-{}", @tagName(expr.*)),
else => std.debug.warn("UnknownExpr-{}", .{@tagName(expr.*)}),
}
}
@ -270,60 +270,60 @@ pub fn printStmt(ident: usize, stmt: *const Stmt) void {
.Expr => |expr| printExpr(expr),
.VarDecl => |decl| {
std.debug.warn("(let {} ", decl.name.lexeme);
std.debug.warn("(let {} ", .{decl.name.lexeme});
printExpr(decl.value);
std.debug.warn(")");
std.debug.warn(")", .{});
},
.If => |ifstmt| {
std.debug.warn("(if ");
std.debug.warn("(if ", .{});
printExpr(ifstmt.condition);
std.debug.warn(" ");
std.debug.warn(" ", .{});
printBlock(ident + 1, ifstmt.then_branch, false);
if (ifstmt.else_branch) |else_branch| {
std.debug.warn(" else ");
std.debug.warn(" else ", .{});
printBlock(ident + 1, else_branch, false);
}
std.debug.warn(")\n");
std.debug.warn(")\n", .{});
},
.Loop => |loop| {
std.debug.warn("(loop ");
std.debug.warn("(loop ", .{});
if (loop.condition) |cond| {
printExpr(cond);
} else {
std.debug.warn("true");
std.debug.warn("true", .{});
}
std.debug.warn(" ");
std.debug.warn(" ", .{});
printBlock(ident + 1, loop.then_branch, false);
std.debug.warn(")\n");
std.debug.warn(")\n", .{});
},
.For => |forstmt| {
std.debug.warn("(for ");
std.debug.warn("(for ", .{});
if (forstmt.index) |index| {
std.debug.warn("({} {}) ", index.lexeme, forstmt.value.lexeme);
std.debug.warn("({} {}) ", .{ index.lexeme, forstmt.value.lexeme });
} else {
std.debug.warn("{} ", forstmt.value.lexeme);
std.debug.warn("{} ", .{forstmt.value.lexeme});
}
std.debug.warn("{} ", forstmt.array.lexeme);
std.debug.warn("{} ", .{forstmt.array.lexeme});
printBlock(ident + 1, forstmt.block, false);
std.debug.warn(")\n");
std.debug.warn(")\n", .{});
},
.Return => |ret| {
std.debug.warn("(return ");
std.debug.warn("(return ", .{});
printExpr(ret.value);
std.debug.warn(")\n");
std.debug.warn(")\n", .{});
},
else => std.debug.warn("UnknownStmt-{}", @tagName(stmt.*)),
else => std.debug.warn("UnknownStmt-{}", .{@tagName(stmt.*)}),
}
}
@ -381,12 +381,12 @@ pub fn printContext(ctx: CompilationContext) void {
}
// go through scopes
std.debug.warn("scope info:\n");
std.debug.warn("scope info:\n", .{});
printScope(fn_sym.scope, 1);
},
.Struct => |typemap| {
std.debug.warn("struct '{}'\n", kv.key);
std.debug.warn("struct '{}'\n", .{kv.key});
var map_it = typemap.iterator();
while (map_it.next()) |map_kv| {
std.debug.warn(
@ -404,21 +404,21 @@ pub fn printContext(ctx: CompilationContext) void {
),
.Enum => |identmap| {
std.debug.warn("enum {}:", kv.key);
std.debug.warn("enum {}:", .{kv.key});
var mapit = identmap.iterator();
while (mapit.next()) |field_kv| {
std.debug.warn("\t{} => {}\n", field_kv.key, field_kv.value);
std.debug.warn("\t{} => {}\n", .{ field_kv.key, field_kv.value });
}
},
.Const => |typ| {
std.debug.warn("const '{}', typ={}\n", kv.key, prettyType(typ));
std.debug.warn("const '{}', typ={}\n", .{ kv.key, prettyType(typ) });
},
else => {
std.debug.warn("TODO handle print of {}\n", kv.value);
std.debug.warn("TODO handle print of {}\n", .{kv.value});
unreachable;
},
}