From 03561ebe6ab486feaea2114dacbb84383d1a00b3 Mon Sep 17 00:00:00 2001 From: Luna Date: Thu, 23 Jul 2020 16:42:49 -0300 Subject: [PATCH 1/6] zig fmt pass --- src/analysis.zig | 4 ++-- src/ast_printer.zig | 6 +++--- src/codegen/llvm.zig | 6 +++--- src/errors.zig | 2 +- src/parsers.zig | 4 ++-- 5 files changed, 11 insertions(+), 11 deletions(-) diff --git a/src/analysis.zig b/src/analysis.zig index bc35d32..078d116 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: var) void { + fn setErrContext(self: *@This(), comptime fmt: ?[]const u8, args: anytype) void { if (fmt == null) { self.err_ctx = null; return; @@ -42,7 +42,7 @@ pub const Analyzer = struct { self.err_tok = tok; } - fn doError(self: *@This(), comptime fmt: []const u8, args: var) void { + fn doError(self: *@This(), comptime fmt: []const u8, args: anytype) void { self.hadError = true; std.debug.warn("analysis error", .{}); diff --git a/src/ast_printer.zig b/src/ast_printer.zig index 328f880..1f248ee 100644 --- a/src/ast_printer.zig +++ b/src/ast_printer.zig @@ -14,12 +14,12 @@ fn printIdent(ident: usize) void { } } -fn print(ident: usize, comptime fmt: []const u8, args: var) void { +fn print(ident: usize, comptime fmt: []const u8, args: anytype) void { printIdent(ident); std.debug.warn(fmt, args); } -fn printBlock(ident: usize, block: var, endNewline: bool) void { +fn printBlock(ident: usize, block: anytype, endNewline: bool) void { std.debug.warn("(\n", .{}); for (block.toSlice()) |stmt| { @@ -156,7 +156,7 @@ fn binOpToStr(op: BinaryOperator) ?[]const u8 { return null; } -fn printBinOp(inner: var) void { +fn printBinOp(inner: anytype) void { std.debug.warn("({}", .{binOpToStr(inner.op)}); printTwoExprs(inner.left, inner.right); std.debug.warn(")", .{}); diff --git a/src/codegen/llvm.zig b/src/codegen/llvm.zig index ff2d6f6..ccde966 100644 --- a/src/codegen/llvm.zig +++ b/src/codegen/llvm.zig @@ -64,7 +64,7 @@ pub const Codegen = struct { }; } - fn emitForVariableType(self: *@This(), vari: var, get: var, kv: var) !llvm.LLVMValueRef { + fn emitForVariableType(self: *@This(), vari: anytype, get: anytype, kv: anytype) !llvm.LLVMValueRef { var sym = kv.value; switch (sym.*) { @@ -89,7 +89,7 @@ pub const Codegen = struct { fn emitExpr( self: *Codegen, - builder: var, + builder: anytype, expr: *const ast.Expr, ) anyerror!llvm.LLVMValueRef { return switch (expr.*) { @@ -260,7 +260,7 @@ pub const Codegen = struct { }; } - fn emitStmt(self: *Codegen, builder: var, stmt: *ast.Stmt) anyerror!void { + fn emitStmt(self: *Codegen, builder: anytype, stmt: *ast.Stmt) anyerror!void { std.debug.warn("cgen: emitting stmt {}\n", .{@as(ast.StmtType, stmt.*)}); switch (stmt.*) { diff --git a/src/errors.zig b/src/errors.zig index 88c05f1..5eb089e 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: var) void { +pub fn reportFmt(line: usize, ctx_opt: ?[]const u8, comptime fmt: []const u8, args: anytype) void { if (ctx_opt) |ctx| { std.debug.warn("[line {}] Error on {}", .{ line, ctx }); } else { diff --git a/src/parsers.zig b/src/parsers.zig index 391b48e..1f19895 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: var) void { + fn setErrContext(self: *Parser, comptime fmt: ?[]const u8, args: anytype) 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: var) ParseError { + fn doError(self: *Parser, comptime fmt: []const u8, args: anytype) ParseError { self.hadError = true; std.debug.warn("parser error at line {}", .{self.scanner.line}); From e0f0ae7f244485af73e29f7c91a30334c062d48d Mon Sep 17 00:00:00 2001 From: Luna Date: Thu, 23 Jul 2020 16:42:59 -0300 Subject: [PATCH 2/6] toSlice -> items --- src/analysis.zig | 18 +++++++++--------- src/ast_printer.zig | 22 +++++++++++----------- src/codegen/llvm.zig | 20 ++++++++++---------- src/comp_ctx.zig | 6 +++--- 4 files changed, 33 insertions(+), 33 deletions(-) diff --git a/src/analysis.zig b/src/analysis.zig index 078d116..5545f1c 100644 --- a/src/analysis.zig +++ b/src/analysis.zig @@ -257,7 +257,7 @@ pub const Analyzer = struct { var symbol = try ctx.fetchGlobalSymbol(func_name, .Function); var func_sym = symbol.Function; - for (call.arguments.toSlice()) |arg_expr, idx| { + for (call.arguments.items) |arg_expr, idx| { var param_type = func_sym.parameter_list.at(idx); var arg_type = try self.resolveExprType(ctx, &arg_expr); @@ -411,7 +411,7 @@ pub const Analyzer = struct { try ctx.bumpScope("if_then"); - for (ifstmt.then_branch.toSlice()) |then_stmt| { + for (ifstmt.then_branch.items) |then_stmt| { try self.stmtPass(ctx, then_stmt); } @@ -421,7 +421,7 @@ pub const Analyzer = struct { try ctx.bumpScope("if_else"); defer ctx.dumpScope(); - for (else_branch.toSlice()) |else_stmt| { + for (else_branch.items) |else_stmt| { try self.stmtPass(ctx, else_stmt); } } @@ -437,7 +437,7 @@ pub const Analyzer = struct { try ctx.bumpScope("loop"); - for (loop.then_branch.toSlice()) |then_stmt| { + for (loop.then_branch.items) |then_stmt| { try self.stmtPass(ctx, then_stmt); } @@ -476,7 +476,7 @@ pub const Analyzer = struct { }); var parameters = comp.TypeList.init(self.allocator); - for (decl.params.toSlice()) |param| { + for (decl.params.items) |param| { var param_type = self.resolveGlobalType(ctx, param.typ.lexeme); if (param_type == null) continue; try parameters.append(param_type.?); @@ -507,7 +507,7 @@ pub const Analyzer = struct { std.debug.assert(ctx.current_scope == null); ctx.setScope(scope); - for (decl.body.toSlice()) |stmt| { + for (decl.body.items) |stmt| { try self.stmtPass(ctx, stmt); } @@ -522,7 +522,7 @@ pub const Analyzer = struct { var types = comp.TypeList.init(self.allocator); - for (struc.fields.toSlice()) |field| { + for (struc.fields.items) |field| { self.setErrToken(field.name); var field_type = self.resolveGlobalType(ctx, field.typ.lexeme); if (field_type == null) continue; @@ -547,7 +547,7 @@ pub const Analyzer = struct { }, .ConstDecl => |constlist| { - for (constlist.toSlice()) |constdecl| { + for (constlist.items) |constdecl| { self.setErrToken(constdecl.name); self.setErrContext("const {}", .{constdecl.name.lexeme}); @@ -566,7 +566,7 @@ pub const Analyzer = struct { pub fn pass(self: *@This(), root: *ast.Node) !comp.CompilationContext { var ctx = comp.CompilationContext.init(self.allocator); - var slice = root.Root.toSlice(); + var slice = root.Root.items; for (slice) |_, idx| { try self.nodePass(&ctx, &slice[idx]); } diff --git a/src/ast_printer.zig b/src/ast_printer.zig index 1f248ee..fd628ca 100644 --- a/src/ast_printer.zig +++ b/src/ast_printer.zig @@ -22,7 +22,7 @@ fn print(ident: usize, comptime fmt: []const u8, args: anytype) void { fn printBlock(ident: usize, block: anytype, endNewline: bool) void { std.debug.warn("(\n", .{}); - for (block.toSlice()) |stmt| { + for (block.items) |stmt| { printIdent(ident); printStmt(ident, &stmt); std.debug.warn("\n", .{}); @@ -53,7 +53,7 @@ pub fn printNode(node: *const Node, ident: usize) void { warn("(fn {} {} (", .{ name, ret_type }); } - for (decl.params.toSlice()) |param| { + for (decl.params.items) |param| { warn(" ({} {})", .{ param.name.lexeme, param.typ.lexeme }); } warn(") ", .{}); @@ -65,7 +65,7 @@ pub fn printNode(node: *const Node, ident: usize) void { .ConstDecl => |consts| { print(ident, "(const (\n", .{}); - for (consts.toSlice()) |const_decl| { + for (consts.items) |const_decl| { print(ident + 1, "({} ", .{ const_decl.name.lexeme, }); @@ -80,7 +80,7 @@ pub fn printNode(node: *const Node, ident: usize) void { .Enum => |decl| { print(ident, "(enum {} (\n", .{decl.name.lexeme}); - for (decl.fields.toSlice()) |field| { + for (decl.fields.items) |field| { print(ident + 1, "{}\n", .{ field.lexeme, }); @@ -90,14 +90,14 @@ pub fn printNode(node: *const Node, ident: usize) void { }, .Root => { - for (node.Root.toSlice()) |child| { + for (node.Root.items) |child| { printNode(&child, ident + 1); } }, .Struct => |struc| { print(ident, "(struct {} (\n", .{struc.name.lexeme}); - for (struc.fields.toSlice()) |field| { + for (struc.fields.items) |field| { print(ident + 1, "({} {})\n", .{ field.name.lexeme, field.typ.lexeme }); } print(ident, "))\n", .{}); @@ -203,7 +203,7 @@ pub fn printExpr(expr: *const Expr) void { .Float => |val| std.debug.warn("{}", .{val}), .String => |val| std.debug.warn("'{}'", .{val}), .Array => |exprs| { - parenthetize("array", exprs.toSlice()); + parenthetize("array", exprs.items); }, else => |typ| std.debug.warn("UnknownLiteral-{}", .{typ}), } @@ -222,7 +222,7 @@ pub fn printExpr(expr: *const Expr) void { std.debug.warn("(", .{}); printExpr(call.callee); - for (call.arguments.toSlice()) |arg| { + for (call.arguments.items) |arg| { std.debug.warn(" ", .{}); printExpr(&arg); } @@ -233,7 +233,7 @@ pub fn printExpr(expr: *const Expr) void { .Struct => |val| { std.debug.warn("({} (", .{val.name.lexeme}); - for (val.inits.toSlice()) |init| { + for (val.inits.items) |init| { std.debug.warn(" ({} ", .{init.field.lexeme}); printExpr(init.expr); std.debug.warn(")", .{}); @@ -350,7 +350,7 @@ pub fn printScope(scope: *Scope, ident: usize) void { print(ident + 1, "sym: {}, typ: {}\n", .{ kv.key, prettyType(kv.value) }); } - for (scope.children.toSlice()) |child| { + for (scope.children.items) |child| { printScope(child, ident + 1); } } @@ -366,7 +366,7 @@ pub fn printContext(ctx: CompilationContext) void { prettyType(fn_sym.return_type), }); - for (fn_sym.decl.params.toSlice()) |param| { + for (fn_sym.decl.params.items) |param| { var param_kv = fn_sym.parameters.get(param.name.lexeme).?; std.debug.warn("\tparameter {} typ {}\n", .{ param_kv.key, diff --git a/src/codegen/llvm.zig b/src/codegen/llvm.zig index ccde966..32e4bc7 100644 --- a/src/codegen/llvm.zig +++ b/src/codegen/llvm.zig @@ -185,12 +185,12 @@ pub const Codegen = struct { var args = LLVMValueList.init(self.allocator); errdefer args.deinit(); - for (call.arguments.toSlice()) |arg_expr| { + for (call.arguments.items) |arg_expr| { var arg_val = try self.emitExpr(builder, &arg_expr); try args.append(arg_val); } - var args_slice = args.toSlice(); + var args_slice = args.items; return llvm.LLVMBuildCall( builder, @@ -294,7 +294,7 @@ pub const Codegen = struct { self.ctx.setScope(self.ctx.current_scope.?.nextChild()); - var then_branch = ifstmt.then_branch.toSlice(); + var then_branch = ifstmt.then_branch.items; for (then_branch) |_, idx| { // keep emitting until branch has ret var then_stmt = &then_branch[idx]; @@ -326,7 +326,7 @@ pub const Codegen = struct { if (ifstmt.else_branch) |else_block| { self.ctx.setScope(self.ctx.current_scope.?.nextChild()); - var else_slice = else_block.toSlice(); + var else_slice = else_block.items; for (else_slice) |_, idx| { // keep emitting until branch has ret var else_stmt = &else_slice[idx]; @@ -418,7 +418,7 @@ pub const Codegen = struct { var param_types = llvm.LLVMTypeList.init(self.allocator); errdefer param_types.deinit(); - for (decl.params.toSlice()) |param| { + for (decl.params.items) |param| { try param_types.append(try self.typeToLLVM(fn_sym.parameters.get( param.name.lexeme, ).?.value.typ)); @@ -426,7 +426,7 @@ pub const Codegen = struct { var llvm_ret_type = llvm.LLVMFunctionType( try self.typeToLLVM(fn_sym.return_type), - param_types.toSlice().ptr, + param_types.items.ptr, @intCast(c_uint, param_types.len), 0, ); @@ -444,7 +444,7 @@ pub const Codegen = struct { // to have the ability to mutate parameters, we must allocate them on // the stack - var params_slice = decl.params.toSlice(); + var params_slice = decl.params.items; for (params_slice) |param_node, idx| { var param = fn_sym.parameters.get(param_node.name.lexeme).?.value; @@ -467,7 +467,7 @@ pub const Codegen = struct { // TODO check if stmt is return and if we already // returned before - var body_slice = decl.body.toSlice(); + var body_slice = decl.body.items; for (body_slice) |_, idx| { try self.emitStmt(builder, &body_slice[idx]); } @@ -480,7 +480,7 @@ pub const Codegen = struct { .Enum => {}, .ConstDecl => |constdecls| { - for (constdecls.toSlice()) |constdecl| { + for (constdecls.items) |constdecl| { const name = constdecl.name.lexeme; var const_type = self.ctx.symbol_table.get(name).?.value; @@ -515,7 +515,7 @@ pub const Codegen = struct { var mod = llvm.LLVMModuleCreateWithName("awoo").?; defer llvm.LLVMDisposeModule(mod); - var root_slice = root.Root.toSlice(); + var root_slice = root.Root.items; for (root_slice) |_, idx| { try self.genNode(mod, &root_slice[idx]); } diff --git a/src/comp_ctx.zig b/src/comp_ctx.zig index 44f377b..05a8896 100644 --- a/src/comp_ctx.zig +++ b/src/comp_ctx.zig @@ -271,7 +271,7 @@ pub const CompilationContext = struct { pub fn insertStruct(self: *@This(), struc: ast.Struct, field_types: TypeList) !void { var type_map = UnderlyingTypeMap.init(self.allocator); - for (struc.fields.toSlice()) |field, idx| { + for (struc.fields.items) |field, idx| { _ = try type_map.put(field.name.lexeme, field_types.at(idx)); } @@ -289,7 +289,7 @@ pub const CompilationContext = struct { ) !void { var param_map = ParameterMap.init(self.allocator); - for (decl.params.toSlice()) |param, idx| { + for (decl.params.items) |param, idx| { var param_sym = try self.allocator.create(Parameter); param_sym.* = Parameter{ @@ -326,7 +326,7 @@ pub const CompilationContext = struct { errdefer ident_map.deinit(); // TODO change this when enums get support for custom values - for (enu.fields.toSlice()) |token, idx| { + for (enu.fields.items) |token, idx| { _ = try ident_map.put(token.lexeme, @intCast(u32, idx)); } From 56be677c7ad5156e27efc0c6560a0a3f95fea89e Mon Sep 17 00:00:00 2001 From: Luna Date: Thu, 23 Jul 2020 16:46:46 -0300 Subject: [PATCH 3/6] at() -> items[] --- src/analysis.zig | 4 ++-- src/comp_ctx.zig | 6 +++--- src/parsers.zig | 4 ++-- 3 files changed, 7 insertions(+), 7 deletions(-) diff --git a/src/analysis.zig b/src/analysis.zig index 5545f1c..2907ac4 100644 --- a/src/analysis.zig +++ b/src/analysis.zig @@ -258,7 +258,7 @@ pub const Analyzer = struct { var func_sym = symbol.Function; for (call.arguments.items) |arg_expr, idx| { - var param_type = func_sym.parameter_list.at(idx); + var param_type = func_sym.parameter_list.items[idx]; var arg_type = try self.resolveExprType(ctx, &arg_expr); self.expectSymUnTypeEqual(arg_type, param_type) catch { @@ -490,7 +490,7 @@ pub const Analyzer = struct { // we intentionally insert the function so that: // - we can do return statement validation // - we have parameter types fully analyzed - if (ret_type != null and parameters.len == decl.params.len) { + if (ret_type != null and parameters.items.len == decl.params.items.len) { try ctx.insertFn(decl, ret_type.?, parameters, scope); } else { if (ret_type != null) diff --git a/src/comp_ctx.zig b/src/comp_ctx.zig index 05a8896..4498400 100644 --- a/src/comp_ctx.zig +++ b/src/comp_ctx.zig @@ -70,7 +70,7 @@ pub const Scope = struct { } pub fn nextChild(self: *@This()) *Scope { - var child = self.children.at(self.cur_child_idx); + var child = self.children.items[self.cur_child_idx]; self.cur_child_idx += 1; return child; } @@ -272,7 +272,7 @@ pub const CompilationContext = struct { var type_map = UnderlyingTypeMap.init(self.allocator); for (struc.fields.items) |field, idx| { - _ = try type_map.put(field.name.lexeme, field_types.at(idx)); + _ = try type_map.put(field.name.lexeme, field_types.items[idx]); } var symbol = try self.allocator.create(SymbolData); @@ -295,7 +295,7 @@ pub const CompilationContext = struct { param_sym.* = Parameter{ .name = param.name.lexeme, .idx = idx, - .typ = param_types.at(idx), + .typ = param_types.items[idx], }; _ = try param_map.put(param.name.lexeme, param_sym); } diff --git a/src/parsers.zig b/src/parsers.zig index 1f19895..d8a2448 100644 --- a/src/parsers.zig +++ b/src/parsers.zig @@ -138,11 +138,11 @@ pub const Parser = struct { } fn peek(self: *Parser) Token { - return self.tokens.at(self.tokens.len - 1); + return self.tokens.items[self.tokens.items.len - 1]; } fn previous(self: *Parser) Token { - return self.tokens.at(self.tokens.len - 2); + return self.tokens.items[self.tokens.items.len - 2]; } fn tokenError(self: *Parser, token: Token, msg: []const u8) ParseError { From 0265eddb2ebb0d7238fc7578e418ff82e731f518 Mon Sep 17 00:00:00 2001 From: Luna Date: Thu, 23 Jul 2020 16:56:37 -0300 Subject: [PATCH 4/6] hashmap changes --- src/analysis.zig | 16 ++++++++-------- src/codegen/llvm.zig | 26 +++++++++++++------------- src/comp_ctx.zig | 11 ++++++----- 3 files changed, 27 insertions(+), 26 deletions(-) diff --git a/src/analysis.zig b/src/analysis.zig index 2907ac4..1169761 100644 --- a/src/analysis.zig +++ b/src/analysis.zig @@ -80,14 +80,14 @@ pub const Analyzer = struct { return null; } - return switch (sym.?.value.*) { + return switch (sym.?.*) { .Struct => SymbolUnderlyingType{ .Struct = val }, .Enum => SymbolUnderlyingType{ .Enum = val }, else => blk: { self.doError("expected struct or enum for '{}', got {}", .{ val, - @tagName(@as(comp.SymbolType, sym.?.value.*)), + @tagName(@as(comp.SymbolType, sym.?.*)), }); break :blk null; }, @@ -314,7 +314,7 @@ pub const Analyzer = struct { .Enum => |enum_identifier| { // fetch an enum off symbol table, then we use the // identifier map to ensure get.name exists in the enum - var map = ctx.symbol_table.get(enum_identifier).?.value.Enum; + var map = ctx.symbol_table.get(enum_identifier).?.Enum; const name = get.name.lexeme; var kv = map.get(name); @@ -355,8 +355,8 @@ pub const Analyzer = struct { } var value_type = try self.resolveExprType(ctx, assign.value); - try self.expectSymUnTypeEqual(var_type.?.value, value_type); - return var_type.?.value; + try self.expectSymUnTypeEqual(var_type.?, value_type); + return var_type.?; }, .Set => @panic("TODO analysis of Set exprs"), @@ -496,8 +496,8 @@ pub const Analyzer = struct { if (ret_type != null) 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 }); + if (parameters.items.len != decl.params.items.len) + self.doError("Fully analyzed {} parameters, wanted {}", .{ parameters.items.len, decl.params.items.len }); return CompileError.TypeError; } @@ -534,7 +534,7 @@ pub const Analyzer = struct { // we don't return type errors from the main loop so we can // keep going and find more type errors - if (types.len == struc.fields.len) + if (types.items.len == struc.fields.items.len) try ctx.insertStruct(struc, types); }, diff --git a/src/codegen/llvm.zig b/src/codegen/llvm.zig index 32e4bc7..aa6647d 100644 --- a/src/codegen/llvm.zig +++ b/src/codegen/llvm.zig @@ -46,7 +46,7 @@ pub const Codegen = struct { }, .Struct, .Enum => |lex| blk: { - var sym_data = self.ctx.symbol_table.get(lex).?.value; + var sym_data = self.ctx.symbol_table.get(lex).?; break :blk switch (sym_data.*) { .Struct => unreachable, .Enum => llvm.LLVMInt32Type(), @@ -76,7 +76,7 @@ pub const Codegen = struct { get.name.lexeme, }); } - return llvm.LLVMConstInt(llvm.LLVMInt32Type(), val.?.value, 1); + return llvm.LLVMConstInt(llvm.LLVMInt32Type(), val.?, 1); }, .Struct => @panic("TODO handle struct"), @@ -194,7 +194,7 @@ pub const Codegen = struct { return llvm.LLVMBuildCall( builder, - llvm_func.?.value, + llvm_func.?, args_slice.ptr, @intCast(c_uint, args_slice.len), "call", @@ -203,10 +203,10 @@ pub const Codegen = struct { .Assign => |assign| { const name = assign.name.lexeme; - var meta = self.ctx.current_scope.?.meta_map.get(name).?.value; + var meta = self.ctx.current_scope.?.meta_map.get(name).?; var assign_expr = try self.emitExpr(builder, assign.value); var llvm_alloca: llvm.LLVMValueRef = switch (meta.using) { - .Function => meta.from_function.?.parameters.get(name).?.value.llvm_alloca.?, + .Function => meta.from_function.?.parameters.get(name).?.llvm_alloca.?, .Scope => meta.llvm_alloca.?, }; @@ -224,7 +224,7 @@ pub const Codegen = struct { // we have metadata, which means we can check if the variable // is coming from the scope or from the function - var metadata = kv_opt.?.value; + var metadata = kv_opt.?; std.debug.warn("!! LOAD FROM VAR META {}\n", .{@ptrToInt(metadata)}); var buf = try self.allocator.alloc(u8, 512); @@ -237,13 +237,13 @@ pub const Codegen = struct { return switch (metadata.using) { .Function => blk: { - var param = metadata.from_function.?.parameters.get(vari.lexeme).?.value; + var param = metadata.from_function.?.parameters.get(vari.lexeme).?; break :blk llvm.LLVMBuildLoad(builder, param.llvm_alloca.?, load_cstr.ptr); }, .Scope => blk: { var llvm_alloca = metadata.llvm_alloca.?; - //var var_typ = metadata.from_scope.?.env.get(vari.lexeme).?.value; + //var var_typ = metadata.from_scope.?.env.get(vari.lexeme).?; break :blk llvm.LLVMBuildLoad(builder, llvm_alloca, load_cstr.ptr); }, }; @@ -361,7 +361,7 @@ pub const Codegen = struct { // analyze pass and the current scope contains the variable's // type(hopefully), so we resolve it const name = vardecl.name.lexeme; - var var_metadata = self.ctx.current_scope.?.meta_map.get(name).?.value; + var var_metadata = self.ctx.current_scope.?.meta_map.get(name).?; var name_cstr = try std.cstr.addNullByte(self.allocator, name); errdefer self.allocator.free(name_cstr); @@ -392,7 +392,7 @@ pub const Codegen = struct { } fn getFnSymbol(self: *@This(), name: []const u8) *comp.FunctionSymbol { - var fn_sym_search = self.ctx.symbol_table.get(name).?.value; + var fn_sym_search = self.ctx.symbol_table.get(name).?; std.debug.assert(@as(comp.SymbolType, fn_sym_search.*) == .Function); return &fn_sym_search.Function; } @@ -421,7 +421,7 @@ pub const Codegen = struct { for (decl.params.items) |param| { try param_types.append(try self.typeToLLVM(fn_sym.parameters.get( param.name.lexeme, - ).?.value.typ)); + ).?.typ)); } var llvm_ret_type = llvm.LLVMFunctionType( @@ -446,7 +446,7 @@ pub const Codegen = struct { // the stack var params_slice = decl.params.items; for (params_slice) |param_node, idx| { - var param = fn_sym.parameters.get(param_node.name.lexeme).?.value; + var param = fn_sym.parameters.get(param_node.name.lexeme).?; const param_name_cstr = try std.cstr.addNullByte(self.allocator, param_node.name.lexeme); errdefer self.allocator.free(param_name_cstr); @@ -483,7 +483,7 @@ pub const Codegen = struct { for (constdecls.items) |constdecl| { const name = constdecl.name.lexeme; - var const_type = self.ctx.symbol_table.get(name).?.value; + var const_type = self.ctx.symbol_table.get(name).?; var const_llvm_type = try self.typeToLLVM(const_type.Const); const const_name = try std.cstr.addNullByte(self.allocator, name); diff --git a/src/comp_ctx.zig b/src/comp_ctx.zig index 4498400..54ac03f 100644 --- a/src/comp_ctx.zig +++ b/src/comp_ctx.zig @@ -76,7 +76,8 @@ pub const Scope = struct { } pub fn deinit(self: *const @This()) void { - self.env.deinit(); + // XXX: fix this someday + // self.env.deinit(); } }; @@ -318,7 +319,7 @@ pub const CompilationContext = struct { _ = try self.symbol_table.put(lex, symbol); var kv = self.symbol_table.get(lex); - self.cur_function = &kv.?.value.Function; + self.cur_function = &kv.?.Function; } pub fn insertEnum(self: *@This(), enu: ast.Enum) !void { @@ -352,7 +353,7 @@ pub const CompilationContext = struct { return CompilationError.TypeError; } - var value = sym_kv.?.value; + var value = sym_kv.?; var sym_typ = @as(SymbolType, value.*); if (sym_typ != typ) { @@ -378,7 +379,7 @@ pub const CompilationContext = struct { return try VariableMetadata.withScope( self.allocator, scope, - kv.value, + kv, ); } else { return null; @@ -408,7 +409,7 @@ pub const CompilationContext = struct { return try VariableMetadata.withParam( self.allocator, cur_function, - kv.value.typ, + kv.typ, ); } else { return null; From b0ddffd5fe820278f518563ade30bee00b51db81 Mon Sep 17 00:00:00 2001 From: Luna Date: Thu, 23 Jul 2020 17:06:38 -0300 Subject: [PATCH 5/6] hashmap changes, part 2 --- src/ast_printer.zig | 5 ++--- src/codegen/llvm.zig | 2 +- 2 files changed, 3 insertions(+), 4 deletions(-) diff --git a/src/ast_printer.zig b/src/ast_printer.zig index fd628ca..6b8f85c 100644 --- a/src/ast_printer.zig +++ b/src/ast_printer.zig @@ -345,9 +345,8 @@ fn prettyType(typ: SymbolUnderlyingType) []const u8 { pub fn printScope(scope: *Scope, ident: usize) void { 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) }); + while (scope.env.items()) |entry| { + print(ident + 1, "sym: {}, typ: {}\n", .{ entry.key, prettyType(entry.value) }); } for (scope.children.items) |child| { diff --git a/src/codegen/llvm.zig b/src/codegen/llvm.zig index aa6647d..890b64d 100644 --- a/src/codegen/llvm.zig +++ b/src/codegen/llvm.zig @@ -427,7 +427,7 @@ pub const Codegen = struct { var llvm_ret_type = llvm.LLVMFunctionType( try self.typeToLLVM(fn_sym.return_type), param_types.items.ptr, - @intCast(c_uint, param_types.len), + @intCast(c_uint, param_types.items.len), 0, ); From 5713df2a8b4d97756d505ab76a354d79d073a91b Mon Sep 17 00:00:00 2001 From: Luna Date: Thu, 23 Jul 2020 17:17:06 -0300 Subject: [PATCH 6/6] more fixes --- src/ast_printer.zig | 8 ++++---- src/codegen/llvm.zig | 2 +- src/parsers.zig | 2 +- 3 files changed, 6 insertions(+), 6 deletions(-) diff --git a/src/ast_printer.zig b/src/ast_printer.zig index 6b8f85c..69d7629 100644 --- a/src/ast_printer.zig +++ b/src/ast_printer.zig @@ -345,7 +345,7 @@ fn prettyType(typ: SymbolUnderlyingType) []const u8 { pub fn printScope(scope: *Scope, ident: usize) void { print(ident, "scope '{}' at addr {}\n", .{ scope.id, @ptrToInt(scope) }); - while (scope.env.items()) |entry| { + for (scope.env.items()) |entry| { print(ident + 1, "sym: {}, typ: {}\n", .{ entry.key, prettyType(entry.value) }); } @@ -366,10 +366,10 @@ pub fn printContext(ctx: CompilationContext) void { }); for (fn_sym.decl.params.items) |param| { - var param_kv = fn_sym.parameters.get(param.name.lexeme).?; + var actual_param = fn_sym.parameters.get(param.name.lexeme).?; std.debug.warn("\tparameter {} typ {}\n", .{ - param_kv.key, - prettyType(param_kv.value.typ), + param.name.lexeme, + prettyType(actual_param.typ), }); } diff --git a/src/codegen/llvm.zig b/src/codegen/llvm.zig index 890b64d..f0894fb 100644 --- a/src/codegen/llvm.zig +++ b/src/codegen/llvm.zig @@ -65,7 +65,7 @@ pub const Codegen = struct { } fn emitForVariableType(self: *@This(), vari: anytype, get: anytype, kv: anytype) !llvm.LLVMValueRef { - var sym = kv.value; + var sym = kv; switch (sym.*) { .Enum => |map| { diff --git a/src/parsers.zig b/src/parsers.zig index d8a2448..db41947 100644 --- a/src/parsers.zig +++ b/src/parsers.zig @@ -215,7 +215,7 @@ pub const Parser = struct { } /// check() against multiple tokens - fn compareAnyOf(self: *@This(), ttypes: []TokenType) bool { + fn compareAnyOf(self: *@This(), ttypes: []const TokenType) bool { for (ttypes) |typ| { if (self.check(typ)) return true; }