diff --git a/src/analysis.zig b/src/analysis.zig index b2e30e5..9094e38 100644 --- a/src/analysis.zig +++ b/src/analysis.zig @@ -25,7 +25,7 @@ pub const Analyzer = struct { }; } - fn setErrContext(self: *@This(), comptime fmt: ?[]const u8, args: ...) void { + fn setErrContext(self: *@This(), comptime fmt: ?[]const u8, args: var) void { if (fmt == null) { self.err_ctx = null; return; @@ -76,7 +76,7 @@ pub const Analyzer = struct { var sym = ctx.symbol_table.get(val); if (sym == null) { - self.doError("Unknown type: '{}'", val); + self.doError("Unknown type: '{}'", .{val}); return null; } @@ -244,7 +244,7 @@ pub const Analyzer = struct { const name = struc.name.lexeme; var typ = self.resolveGlobalType(ctx, name); if (typ == null) { - self.doError("Unknown struct name '{}'\n", name); + self.doError("Unknown struct name '{}'\n", .{name}); return CompileError.TypeError; } @@ -346,7 +346,7 @@ pub const Analyzer = struct { .Assign => |assign| { if (ctx.current_scope == null) { - self.doError("Can't assign without a scope"); + self.doError("Can't assign without a scope", .{}); return CompileError.Invalid; } @@ -355,7 +355,7 @@ pub const Analyzer = struct { ); if (var_type == null) { - self.doError("Assign target variable not found"); + self.doError("Assign target variable not found", .{}); return CompileError.Invalid; } @@ -393,7 +393,7 @@ pub const Analyzer = struct { var var_type = try self.resolveExprType(ctx, vardecl.value); if (ctx.current_scope == null) { - self.doError("Can't declare without a scope"); + self.doError("Can't declare without a scope", .{}); return CompileError.Invalid; } @@ -462,7 +462,7 @@ pub const Analyzer = struct { node: *ast.Node, ) !void { self.setErrToken(null); - self.setErrContext(null); + self.setErrContext(null, .{}); // always reset the contexts' current function ctx.cur_function = null; @@ -472,7 +472,7 @@ pub const Analyzer = struct { .FnDecl => |decl| { self.setErrToken(decl.return_type); const name = decl.func_name.lexeme; - self.setErrContext("function {}", name); + self.setErrContext("function {}", .{name}); var ret_type = self.resolveGlobalType(ctx, decl.return_type.lexeme); std.debug.warn("start analysis of fn {}, ret type: {}\n", .{ decl.func_name.lexeme, ret_type }); @@ -496,10 +496,10 @@ pub const Analyzer = struct { try ctx.insertFn(decl, ret_type.?, parameters, scope); } else { if (ret_type != null) - self.doError("Return type was not fully resolved"); + self.doError("Return type was not fully resolved", .{}); if (parameters.len != decl.params.len) - self.doError("Fully analyzed {} parameters, wanted {}", parameters.len, decl.params.len); + self.doError("Fully analyzed {} parameters, wanted {}", .{ parameters.len, decl.params.len }); return CompileError.TypeError; } @@ -520,7 +520,7 @@ pub const Analyzer = struct { .Struct => |struc| { self.setErrToken(struc.name); - self.setErrContext("struct {}", struc.name.lexeme); + self.setErrContext("struct {}", .{struc.name.lexeme}); var types = comp.TypeList.init(self.allocator); @@ -543,7 +543,7 @@ pub const Analyzer = struct { // TODO change enums to u32 .Enum => |enu| { self.setErrToken(enu.name); - self.setErrContext("enum {}", enu.name.lexeme); + self.setErrContext("enum {}", .{enu.name.lexeme}); try ctx.insertEnum(enu); }, @@ -551,7 +551,7 @@ pub const Analyzer = struct { .ConstDecl => |constlist| { for (constlist.toSlice()) |constdecl| { self.setErrToken(constdecl.name); - self.setErrContext("const {}", constdecl.name.lexeme); + self.setErrContext("const {}", .{constdecl.name.lexeme}); var expr_type = try self.resolveExprType(ctx, constdecl.expr); try ctx.insertConst(constdecl, expr_type); @@ -559,7 +559,7 @@ pub const Analyzer = struct { }, .Block => { - self.doError("Block can't be found at root"); + self.doError("Block can't be found at root", .{}); return CompileError.Invalid; }, } diff --git a/src/ast_printer.zig b/src/ast_printer.zig index 1bdc248..42f1d4d 100644 --- a/src/ast_printer.zig +++ b/src/ast_printer.zig @@ -14,7 +14,7 @@ fn printIdent(ident: usize) void { } } -fn print(ident: usize, comptime fmt: []const u8, args: ...) void { +fn print(ident: usize, comptime fmt: []const u8, args: var) void { printIdent(ident); std.debug.warn(fmt, args); } @@ -29,9 +29,9 @@ fn printBlock(ident: usize, block: var, endNewline: bool) void { } if (endNewline) { - print(ident - 1, ")\n"); + print(ident - 1, ")\n", .{}); } else { - print(ident - 1, ")"); + print(ident - 1, ")", .{}); } } @@ -63,7 +63,7 @@ pub fn printNode(node: *const Node, ident: usize) void { }, .ConstDecl => |consts| { - print(ident, "(const (\n"); + print(ident, "(const (\n", .{}); for (consts.toSlice()) |const_decl| { print( @@ -76,11 +76,11 @@ pub fn printNode(node: *const Node, ident: usize) void { std.debug.warn(")\n", .{}); } - print(ident, "))\n"); + print(ident, "))\n", .{}); }, .Enum => |decl| { - print(ident, "(enum {} (\n", decl.name.lexeme); + print(ident, "(enum {} (\n", .{decl.name.lexeme}); for (decl.fields.toSlice()) |field| { print( @@ -90,7 +90,7 @@ pub fn printNode(node: *const Node, ident: usize) void { ); } - print(ident, "))\n"); + print(ident, "))\n", .{}); }, .Root => { @@ -100,15 +100,15 @@ pub fn printNode(node: *const Node, ident: usize) void { }, .Struct => |struc| { - print(ident, "(struct {} (\n", struc.name.lexeme); + print(ident, "(struct {} (\n", .{struc.name.lexeme}); for (struc.fields.toSlice()) |field| { - print(ident + 1, "({} {})\n", field.name.lexeme, field.typ.lexeme); + print(ident + 1, "({} {})\n", .{ field.name.lexeme, field.typ.lexeme }); } - print(ident, "))\n"); + print(ident, "))\n", .{}); }, else => { - print(ident, "unknown node: {}\n", node); + print(ident, "unknown node: {}\n", .{node}); }, } } @@ -330,7 +330,7 @@ pub fn printStmt(ident: usize, stmt: *const Stmt) void { // very bad but be like that fn retWithName(prefix: []const u8, inner: []const u8) []const u8 { var ret_nam_buf = std.heap.direct_allocator.alloc(u8, 256) catch unreachable; - return std.fmt.bufPrint(ret_nam_buf[0..], "{}({})", prefix, inner) catch unreachable; + return std.fmt.bufPrint(ret_nam_buf[0..], "{}({})", .{ prefix, inner }) catch unreachable; } fn prettyType(typ: SymbolUnderlyingType) []const u8 { @@ -347,11 +347,11 @@ fn prettyType(typ: SymbolUnderlyingType) []const u8 { } pub fn printScope(scope: *Scope, ident: usize) void { - print(ident, "scope '{}' at addr {}\n", scope.id, @ptrToInt(scope)); + print(ident, "scope '{}' at addr {}\n", .{ scope.id, @ptrToInt(scope) }); var it = scope.env.iterator(); while (it.next()) |kv| { - print(ident + 1, "sym: {}, typ: {}\n", kv.key, prettyType(kv.value)); + print(ident + 1, "sym: {}, typ: {}\n", .{ kv.key, prettyType(kv.value) }); } for (scope.children.toSlice()) |child| { @@ -365,19 +365,17 @@ pub fn printContext(ctx: CompilationContext) void { while (it.next()) |kv| { switch (kv.value.*) { .Function => |fn_sym| { - std.debug.warn( - "function {} returns {}\n", + std.debug.warn("function {} returns {}\n", .{ kv.key, prettyType(fn_sym.return_type), - ); + }); for (fn_sym.decl.params.toSlice()) |param| { var param_kv = fn_sym.parameters.get(param.name.lexeme).?; - std.debug.warn( - "\tparameter {} typ {}\n", + std.debug.warn("\tparameter {} typ {}\n", .{ param_kv.key, prettyType(param_kv.value.typ), - ); + }); } // go through scopes diff --git a/src/codegen/llvm.zig b/src/codegen/llvm.zig index 010dc1c..6aa092e 100644 --- a/src/codegen/llvm.zig +++ b/src/codegen/llvm.zig @@ -5,7 +5,7 @@ const comp = @import("../comp_ctx.zig"); const CompileError = @import("../codegen.zig").CompileError; fn sliceify(non_slice: ?[*:0]const u8) []const u8 { - return non_slice.?[0..std.mem.len(u8, non_slice.?)]; + return non_slice.?[0..std.mem.len(non_slice.?)]; } fn mkLLVMBool(val: bool) llvm.LLVMValueRef { @@ -71,11 +71,10 @@ pub const Codegen = struct { .Enum => |map| { var val = map.get(get.name.lexeme); if (val == null) { - std.debug.warn( - "enum {} does not have field {}\n", + std.debug.warn("enum {} does not have field {}\n", .{ vari.lexeme, get.name.lexeme, - ); + }); } return llvm.LLVMConstInt(llvm.LLVMInt32Type(), val.?.value, 1); }, diff --git a/src/comp_ctx.zig b/src/comp_ctx.zig index 6b69664..44f377b 100644 --- a/src/comp_ctx.zig +++ b/src/comp_ctx.zig @@ -224,11 +224,10 @@ pub const CompilationContext = struct { const parent_id: ?[]const u8 = if (self.current_scope.?.parent == null) null else self.current_scope.?.parent.?.id; - std.debug.warn( - "==scope dump== {} to {}\n", + std.debug.warn("==scope dump== {} to {}\n", .{ self.current_scope.?.id, parent_id, - ); + }); self.current_scope = self.current_scope.?.parent; } diff --git a/src/errors.zig b/src/errors.zig index d903dd3..88c05f1 100644 --- a/src/errors.zig +++ b/src/errors.zig @@ -12,7 +12,7 @@ pub fn reportN(line: usize, message: []const u8) void { report(line, "", message); } -pub fn reportFmt(line: usize, ctx_opt: ?[]const u8, comptime fmt: []const u8, args: ...) void { +pub fn reportFmt(line: usize, ctx_opt: ?[]const u8, comptime fmt: []const u8, args: var) void { if (ctx_opt) |ctx| { std.debug.warn("[line {}] Error on {}", .{ line, ctx }); } else { diff --git a/src/main.zig b/src/main.zig index 297ee9c..ba5d105 100644 --- a/src/main.zig +++ b/src/main.zig @@ -69,7 +69,7 @@ pub fn run(allocator: *std.mem.Allocator, slice: []const u8) !Result { } pub fn main() anyerror!void { - const allocator = std.heap.direct_allocator; + const allocator = std.heap.page_allocator; var args_it = std.process.args(); _ = args_it.skip(); diff --git a/src/parsers.zig b/src/parsers.zig index 97c6bd7..391b48e 100644 --- a/src/parsers.zig +++ b/src/parsers.zig @@ -94,7 +94,7 @@ pub const Parser = struct { self.tokens.deinit(); } - fn setErrContext(self: *Parser, comptime fmt: ?[]const u8, args: ...) void { + fn setErrContext(self: *Parser, comptime fmt: ?[]const u8, args: var) void { if (fmt == null) { self.err_ctx = null; return; @@ -104,7 +104,7 @@ pub const Parser = struct { self.err_ctx = std.fmt.bufPrint(buf, fmt.?, args) catch unreachable; } - fn doError(self: *Parser, comptime fmt: []const u8, args: ...) ParseError { + fn doError(self: *Parser, comptime fmt: []const u8, args: var) ParseError { self.hadError = true; std.debug.warn("parser error at line {}", .{self.scanner.line}); @@ -150,7 +150,10 @@ pub const Parser = struct { if (token.typ == .EOF) { ereport.report(token.line, " at end", self.err_ctx, msg); } else { - ereport.reportFmt(token.line, self.err_ctx, " at '{}': {}", token.lexeme, msg); + ereport.reportFmt(token.line, self.err_ctx, " at '{}': {}", .{ + token.lexeme, + msg, + }); } return ParseError.CompileError; @@ -203,12 +206,10 @@ pub const Parser = struct { // TODO maybe this could be entirely comptime? var buf_main: [1000]u8 = undefined; - var buf = try std.fmt.bufPrint( - buf_main[0..], - "expected {}, got {}", + var buf = try std.fmt.bufPrint(&buf_main, "expected {}, got {}", .{ ttype, self.peek().typ, - ); + }); return self.tokenError(self.peek(), buf); } @@ -466,7 +467,7 @@ pub const Parser = struct { break :blk orig_name; }; - self.setErrContext("function {}", name.lexeme); + self.setErrContext("function {}", .{name.lexeme}); _ = try self.consumeSingle(.LeftParen); @@ -529,14 +530,14 @@ pub const Parser = struct { var consts = ast.ConstList.init(self.allocator); errdefer consts.deinit(); - self.setErrContext("const"); + self.setErrContext("const", .{}); _ = try self.consumeSingle(.Const); _ = try self.consumeSingle(.LeftParen); while (self.peek().typ != .RightParen) { const const_name = try self.consumeSingle(.Identifier); - self.setErrContext("const {}", const_name); + self.setErrContext("const {}", .{const_name}); _ = try self.consumeSingle(.Equal); @@ -558,18 +559,18 @@ pub const Parser = struct { fn parseStructDecl(self: *@This()) !*Node { var fields = ast.FieldList.init(self.allocator); errdefer fields.deinit(); - self.setErrContext("struct"); + self.setErrContext("struct", .{}); _ = try self.consumeSingle(.Struct); var name = try self.consumeSingle(.Identifier); - self.setErrContext("struct {}", name); + self.setErrContext("struct {}", .{name}); _ = try self.consumeSingle(.LeftBrace); while (!self.check(.RightBrace)) { const field_name = try self.consumeSingle(.Identifier); - self.setErrContext("struct {} field {}", name, field_name); + self.setErrContext("struct {} field {}", .{ name, field_name }); const field_type = try self.consumeSingle(.Identifier); try fields.append(ast.StructField{ @@ -587,12 +588,12 @@ pub const Parser = struct { var fields = ast.TokenList.init(self.allocator); errdefer fields.deinit(); - self.setErrContext("enum"); + self.setErrContext("enum", .{}); _ = try self.consumeSingle(.Enum); const name = try self.consumeSingle(.Identifier); - self.setErrContext("enum {}", name); + self.setErrContext("enum {}", .{name}); _ = try self.consumeSingle(.LeftBrace); @@ -606,7 +607,7 @@ pub const Parser = struct { } fn parseTopDecl(self: *@This()) !*Node { - self.setErrContext(null); + self.setErrContext(null, .{}); return switch (self.peek().typ) { .Fn => try self.parseFnDecl(), @@ -615,7 +616,7 @@ pub const Parser = struct { .Enum => try self.parseEnumDecl(), else => |typ| blk: { - return self.doError("expected Fn, Const, Struct, got {}\n", typ); + return self.doError("expected Fn, Const, Struct, got {}\n", .{typ}); }, }; } @@ -837,7 +838,7 @@ pub const Parser = struct { switch (op_tok.typ) { // TODO remove .ColonEqual from language .ColonEqual => { - return self.doError("can not initialize struct field"); + return self.doError("can not initialize struct field", .{}); }, .Equal => return try self.mkSet(get.target, get.name, value), @@ -855,7 +856,7 @@ pub const Parser = struct { }, else => |expr_typ| { - return self.doError("Invalid assignment target {}", expr_typ); + return self.doError("Invalid assignment target {}", .{expr_typ}); }, } } @@ -1028,7 +1029,7 @@ pub const Parser = struct { // for this to work properly, must be Variable, since its a type. const expr_type = @as(ast.ExprType, expr.*); if (expr_type != .Variable) { - return self.doError("Expected variable for struct type, got {}", expr_type); + return self.doError("Expected variable for struct type, got {}", .{expr_type}); } var inits = ast.StructInitList.init(self.allocator); @@ -1065,11 +1066,10 @@ pub const Parser = struct { // parseInt(i64) on the catch block of parseInt(i32) var i32_num_opt: ?i32 = std.fmt.parseInt(i32, lexeme, 10) catch null; var i64_num: i64 = std.fmt.parseInt(i64, lexeme, 10) catch |err| { - return self.doError( - "Invalid integer (not 32bit or 64bit) '{}': {}", + return self.doError("Invalid integer (not 32bit or 64bit) '{}': {}", .{ lexeme, err, - ); + }); }; if (i32_num_opt) |i32_num| { @@ -1124,7 +1124,7 @@ pub const Parser = struct { }, else => blk: { - return self.doError("expected literal, got {}", curtype); + return self.doError("expected literal, got {}", .{curtype}); }, };