Misc: Rename allocator

3 files changed, 32 insertions, 34 deletions

diff --git a/src/evaluator.zig b/src/evaluator.zig
index 798d66c..ec6a698 100644
--- a/src/evaluator.zig
+++ b/src/evaluator.zig
@@ -18,15 +18,14 @@ pub const Evaluator = struct {
     ast: ?*parser.Node,
     environment: *Environment,
 
-    allocator: std.mem.Allocator,
+    arena: std.mem.Allocator,
 
-    pub fn init(arena_allocator: *std.heap.ArenaAllocator) !*Evaluator {
-        const allocator = arena_allocator.allocator();
-        const evaluator = try allocator.create(Evaluator);
+    pub fn init(arena_allocator: std.mem.Allocator) !*Evaluator {
+        const evaluator = try arena_allocator.create(Evaluator);
         evaluator.* = .{
             .ast = null,
             .environment = try Environment.init(arena_allocator),
-            .allocator = allocator,
+            .arena = arena_allocator,
         };
         return evaluator;
     }
@@ -248,7 +247,7 @@ pub const Evaluator = struct {
     }
 
     fn create_variable(self: *Evaluator, variable_value: Variable) !*Variable {
-        const variable = try self.allocator.create(Variable);
+        const variable = try self.arena.create(Variable);
         variable.* = variable_value;
         return variable;
     }
@@ -261,15 +260,14 @@ const Scope = struct {
 const Environment = struct {
     scope_stack: std.ArrayList(*Scope),
 
-    allocator: std.mem.Allocator,
+    arena: std.mem.Allocator,
 
-    fn init(arena_allocator: *std.heap.ArenaAllocator) !*Environment {
-        const allocator = arena_allocator.allocator();
-        const self = try allocator.create(Environment);
+    fn init(arena_allocator: std.mem.Allocator) !*Environment {
+        const self = try arena_allocator.create(Environment);
 
         self.* = .{
-            .scope_stack = std.ArrayList(*Scope).init(allocator),
-            .allocator = allocator,
+            .scope_stack = std.ArrayList(*Scope).init(arena_allocator),
+            .arena = arena_allocator,
         };
 
         // Create global scope
@@ -279,9 +277,9 @@ const Environment = struct {
     }
 
     fn create_scope(self: *Environment) !void {
-        const scope = try self.allocator.create(Scope);
+        const scope = try self.arena.create(Scope);
         scope.* = .{
-            .variables = std.StringHashMap(?*Variable).init(self.allocator),
+            .variables = std.StringHashMap(?*Variable).init(self.arena),
         };
         try self.scope_stack.append(scope);
     }
diff --git a/src/main.zig b/src/main.zig
index 089ef69..94105b0 100644
--- a/src/main.zig
+++ b/src/main.zig
@@ -20,7 +20,7 @@ pub fn main() !void {
     var arena = std.heap.ArenaAllocator.init(allocator);
     defer arena.deinit();
 
-    const source_evaluator = try evaluator.Evaluator.init(&arena);
+    const source_evaluator = try evaluator.Evaluator.init(arena.allocator());
 
     if (std.mem.eql(u8, path, "-i")) {
         while (true) {
@@ -29,7 +29,7 @@ pub fn main() !void {
             const buf = try stdin.readUntilDelimiterAlloc(allocator, '\n', 1024);
             defer allocator.free(buf);
 
-            process_buf(buf, allocator, &arena, source_evaluator) catch |err| {
+            process_buf(buf, allocator, arena.allocator(), source_evaluator) catch |err| {
                 try stdout.print("Error processing line: {any}\n", .{err});
             };
         }
@@ -38,11 +38,11 @@ pub fn main() !void {
         const file = try std.fs.cwd().openFile(path, .{});
         const buf = try file.readToEndAlloc(allocator, 1 * 1024 * 1024);
         defer allocator.free(buf);
-        try process_buf(buf, allocator, &arena, source_evaluator);
+        try process_buf(buf, allocator, arena.allocator(), source_evaluator);
     }
 }
 
-fn process_buf(buf: []u8, allocator: std.mem.Allocator, arena: *std.heap.ArenaAllocator, source_evaluator: *evaluator.Evaluator) !void {
+fn process_buf(buf: []u8, allocator: std.mem.Allocator, arena: std.mem.Allocator, source_evaluator: *evaluator.Evaluator) !void {
     std.debug.print("Buf:\n{s}\n", .{buf});
 
     var token_list = std.ArrayList(tokenizer.Token).init(allocator);
diff --git a/src/parser.zig b/src/parser.zig
index 9b86f4c..184dd29 100644
--- a/src/parser.zig
+++ b/src/parser.zig
@@ -75,16 +75,16 @@ pub const Parser = struct {
     tokens: []tokenizer.Token,
     offset: u32,
 
-    allocator: std.mem.Allocator,
+    arena: std.mem.Allocator,
 
     try_context: bool, //TODO: I dont like this
 
-    pub fn init(tokens: []tokenizer.Token, arena_allocator: *std.heap.ArenaAllocator) ParserError!*Parser {
-        const parser = try arena_allocator.allocator().create(Parser);
+    pub fn init(tokens: []tokenizer.Token, arena_allocator: std.mem.Allocator) ParserError!*Parser {
+        const parser = try arena_allocator.create(Parser);
         parser.* = .{
             .tokens = tokens,
             .offset = 0,
-            .allocator = arena_allocator.allocator(),
+            .arena = arena_allocator,
             .try_context = false,
         };
         return parser;
@@ -96,7 +96,7 @@ pub const Parser = struct {
 
     // Program ::= Statement+
     fn parse_program(self: *Parser) !*Node {
-        var nodes = std.ArrayList(*Node).init(self.allocator);
+        var nodes = std.ArrayList(*Node).init(self.arena);
         while (self.offset < self.tokens.len) {
             try nodes.append(@constCast(try self.parse_statement()));
         }
@@ -143,7 +143,7 @@ pub const Parser = struct {
         return self.create_node(.{
             .ASSIGNMENT_STATEMENT = .{
                 .is_declaration = is_declaration,
-                .name = try self.allocator.dupe(u8, identifier.type.IDENTIFIER),
+                .name = try self.arena.dupe(u8, identifier.type.IDENTIFIER),
                 .expression = @constCast(expression),
             },
         });
@@ -162,7 +162,7 @@ pub const Parser = struct {
         _ = try self.parse_token(tokenizer.TokenType.RPAREN);
 
         return self.create_node(.{ .FUNCTION_CALL_STATEMENT = .{
-            .name = try self.allocator.dupe(u8, identifier.type.IDENTIFIER),
+            .name = try self.arena.dupe(u8, identifier.type.IDENTIFIER),
             .arguments = arguments,
         } });
     }
@@ -170,7 +170,7 @@ pub const Parser = struct {
     // FunctionArguments ::= Expression ("," Expression)*
     fn parse_function_arguments(self: *Parser) ParserError![]*Node {
         errdefer if (!self.try_context) std.debug.print("Error parsing function arguments\n", .{});
-        var node_list = std.ArrayList(*Node).init(self.allocator);
+        var node_list = std.ArrayList(*Node).init(self.arena);
 
         var first = true;
         while (true) {
@@ -195,7 +195,7 @@ pub const Parser = struct {
 
         _ = try self.parse_token(tokenizer.TokenType.LBRACE);
 
-        var statements = std.ArrayList(*Node).init(self.allocator);
+        var statements = std.ArrayList(*Node).init(self.arena);
         while (self.accept_parse(parse_statement)) |expr| {
             try statements.append(expr);
         }
@@ -218,7 +218,7 @@ pub const Parser = struct {
 
         _ = try self.parse_token(tokenizer.TokenType.LBRACE);
 
-        var statements = std.ArrayList(*Node).init(self.allocator);
+        var statements = std.ArrayList(*Node).init(self.arena);
         while (self.accept_parse(parse_statement)) |expr| {
             try statements.append(expr);
         }
@@ -354,7 +354,7 @@ pub const Parser = struct {
             .IDENTIFIER => |identifier_token| try self.create_node(.{
                 .PRIMARY_EXPRESSION = .{
                     .IDENTIFIER = .{
-                        .name = try self.allocator.dupe(u8, identifier_token),
+                        .name = try self.arena.dupe(u8, identifier_token),
                     },
                 },
             }),
@@ -375,12 +375,12 @@ pub const Parser = struct {
         _ = try self.parse_token(tokenizer.TokenType.ARROW);
         _ = try self.parse_token(tokenizer.TokenType.LBRACE);
 
-        var nodes = std.ArrayList(*Node).init(self.allocator);
+        var nodes = std.ArrayList(*Node).init(self.arena);
         while (self.accept_parse(parse_statement)) |expression| {
             try nodes.append(expression);
         }
 
-        std.debug.assert(nodes.getLast().STATEMENT.statement.* == .RETURN_STATEMENT);
+        if (nodes.getLast().STATEMENT.statement.* != .RETURN_STATEMENT) return ParserError.ParsingError;
 
         _ = try self.parse_token(tokenizer.TokenType.RBRACE);
 
@@ -393,7 +393,7 @@ pub const Parser = struct {
     // FunctionParameters ::= IDENTIFIER ("," IDENTIFIER)*
     fn parse_function_parameters(self: *Parser) ParserError![]*Node {
         errdefer if (!self.try_context) std.debug.print("Error parsing function parameters\n", .{});
-        var node_list = std.ArrayList(*Node).init(self.allocator);
+        var node_list = std.ArrayList(*Node).init(self.arena);
 
         var first = true;
         while (true) {
@@ -406,7 +406,7 @@ pub const Parser = struct {
             try node_list.append(try self.create_node(.{
                 .PRIMARY_EXPRESSION = .{
                     .IDENTIFIER = .{
-                        .name = try self.allocator.dupe(u8, ident.type.IDENTIFIER),
+                        .name = try self.arena.dupe(u8, ident.type.IDENTIFIER),
                     },
                 },
             }));
@@ -477,7 +477,7 @@ pub const Parser = struct {
     }
 
     fn create_node(self: *Parser, node_value: Node) !*Node {
-        const node = try self.allocator.create(Node);
+        const node = try self.arena.create(Node);
         node.* = node_value;
         return node;
     }