birth-software/nativity
1
0
Fork 0
Code Issues 1 Pull Requests Actions Packages Projects Releases Wiki Activity

Merge pull request #169 from birth-software/arena-changes

Browse Source 
Arena changes
This commit is contained in:
David 2024-04-26 08:25:24 -06:00 committed by GitHub
commit f4a26be735
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
8 changed files with 2385 additions and 2326 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3239
bootstrap/Compilation.zig
View File

File diff suppressed because it is too large Load Diff

407
bootstrap/backend/llvm.zig
View File

File diff suppressed because it is too large Load Diff

60
bootstrap/frontend/lexer.zig
View File

@ -3,10 +3,11 @@ const Allocator = std.mem.Allocator;
const assert = std.debug.assert; const assert = std.debug.assert;
const log = std.log; const log = std.log;
const data_structures = @import("../library.zig"); const library = @import("../library.zig");
const enumFromString = data_structures.enumFromString; const byte_equal = library.byte_equal;
const MyAllocator = data_structures.MyAllocator; const enumFromString = library.enumFromString;
const UnpinnedArray = data_structures.UnpinnedArray; const MyAllocator = library.MyAllocator;
const PinnedArray = library.PinnedArray;
const Compilation = @import("../Compilation.zig"); const Compilation = @import("../Compilation.zig");
const File = Compilation.File; const File = Compilation.File;
@ -43,31 +44,31 @@ pub const Logger = enum {
}); });
}; };
pub fn analyze(allocator: *MyAllocator, text: []const u8, token_buffer: *Token.Buffer) !Result { pub fn analyze(text: []const u8, token_buffer: *Token.Buffer) !Result {
assert(text.len <= std.math.maxInt(u32)); assert(text.len <= std.math.maxInt(u32));
const len: u32 = @intCast(text.len); const len: u32 = @intCast(text.len);
var lexer = Result{ var lexer = Result{
.offset = token_buffer.getOffset(), .offset = @enumFromInt(token_buffer.tokens.length),
.line_offset = token_buffer.getLineOffset(), .line_offset = token_buffer.line_offsets.length,
.count = 0, .count = 0,
.line_count = 0, .line_count = 0,
}; };
const time_start = std.time.Instant.now() catch unreachable; const time_start = std.time.Instant.now() catch unreachable;
try token_buffer.line_offsets.append(allocator, 0); _ = token_buffer.line_offsets.append(0);
for (text, 0..) |byte, index| { for (text, 0..) |byte, index| {
if (byte == '\n') { if (byte == '\n') {
try token_buffer.line_offsets.append(allocator, @intCast(index + 1)); _ = token_buffer.line_offsets.append(@intCast(index + 1));
} }
} }
var index: u32 = 0; var index: u32 = 0;
var line_index: u32 = lexer.line_offset; var line_index: u32 = lexer.line_offset;
try token_buffer.ensure_with_capacity(allocator, len / 3); // try token_buffer.ensure_with_capacity(allocator, len / 3);
// logln(.lexer, .end, "START LEXER - TOKEN OFFSET: {} - LINE OFFSET: {}", .{ Token.unwrap(lexer.offset), lexer.line_offset }); // logln(.lexer, .end, "START LEXER - TOKEN OFFSET: {} - LINE OFFSET: {}", .{ Token.unwrap(lexer.offset), lexer.line_offset });
@ -110,7 +111,7 @@ pub fn analyze(allocator: *MyAllocator, text: []const u8, token_buffer: *Token.B
const string = text[start_index..][0 .. index - start_index]; const string = text[start_index..][0 .. index - start_index];
break :blk if (enumFromString(Compilation.FixedKeyword, string)) |fixed_keyword| switch (fixed_keyword) { break :blk if (enumFromString(Compilation.FixedKeyword, string)) |fixed_keyword| switch (fixed_keyword) {
inline else => |comptime_fixed_keyword| @field(Token.Id, "fixed_keyword_" ++ @tagName(comptime_fixed_keyword)), inline else => |comptime_fixed_keyword| @field(Token.Id, "fixed_keyword_" ++ @tagName(comptime_fixed_keyword)),
} else if (data_structures.byte_equal(string, "_")) .discard else .identifier; } else if (byte_equal(string, "_")) .discard else .identifier;
}, },
'0'...'9' => blk: { '0'...'9' => blk: {
// Detect other non-decimal literals // Detect other non-decimal literals
@ -481,7 +482,7 @@ pub fn analyze(allocator: *MyAllocator, text: []const u8, token_buffer: *Token.B
}, },
// Asm statement (special treatment) // Asm statement (special treatment)
'`' => { '`' => {
token_buffer.append_with_capacity(.{ _ = token_buffer.tokens.append(.{
.id = .operator_backtick, .id = .operator_backtick,
.line = line_index, .line = line_index,
.offset = start_index, .offset = start_index,
@ -495,6 +496,7 @@ pub fn analyze(allocator: *MyAllocator, text: []const u8, token_buffer: *Token.B
const start_ch = text[start_i]; const start_ch = text[start_i];
switch (start_ch) { switch (start_ch) {
'\r' => index += 1,
'\n' => { '\n' => {
index += 1; index += 1;
line_index += 1; line_index += 1;
@ -508,7 +510,7 @@ pub fn analyze(allocator: *MyAllocator, text: []const u8, token_buffer: *Token.B
} }
} }
token_buffer.append_with_capacity(.{ _ = token_buffer.tokens.append(.{
.id = .identifier, .id = .identifier,
.offset = start_i, .offset = start_i,
.length = index - start_i, .length = index - start_i,
@ -516,7 +518,7 @@ pub fn analyze(allocator: *MyAllocator, text: []const u8, token_buffer: *Token.B
}); });
}, },
',' => { ',' => {
token_buffer.append_with_capacity(.{ _ = token_buffer.tokens.append(.{
.id = .operator_comma, .id = .operator_comma,
.line = line_index, .line = line_index,
.offset = start_i, .offset = start_i,
@ -525,7 +527,7 @@ pub fn analyze(allocator: *MyAllocator, text: []const u8, token_buffer: *Token.B
index += 1; index += 1;
}, },
';' => { ';' => {
token_buffer.append_with_capacity(.{ _ = token_buffer.tokens.append(.{
.id = .operator_semicolon, .id = .operator_semicolon,
.line = line_index, .line = line_index,
.offset = start_i, .offset = start_i,
@ -534,7 +536,7 @@ pub fn analyze(allocator: *MyAllocator, text: []const u8, token_buffer: *Token.B
index += 1; index += 1;
}, },
'{' => { '{' => {
token_buffer.append_with_capacity(.{ _ = token_buffer.tokens.append(.{
.id = .operator_left_brace, .id = .operator_left_brace,
.line = line_index, .line = line_index,
.offset = start_i, .offset = start_i,
@ -543,7 +545,7 @@ pub fn analyze(allocator: *MyAllocator, text: []const u8, token_buffer: *Token.B
index += 1; index += 1;
}, },
'}' => { '}' => {
token_buffer.append_with_capacity(.{ _ = token_buffer.tokens.append(.{
.id = .operator_right_brace, .id = .operator_right_brace,
.line = line_index, .line = line_index,
.offset = start_i, .offset = start_i,
@ -572,7 +574,7 @@ pub fn analyze(allocator: *MyAllocator, text: []const u8, token_buffer: *Token.B
} }
} }
token_buffer.append_with_capacity(.{ _ = token_buffer.tokens.append(.{
.id = .number_literal, .id = .number_literal,
.line = line_index, .line = line_index,
.offset = start_i, .offset = start_i,
@ -582,11 +584,18 @@ pub fn analyze(allocator: *MyAllocator, text: []const u8, token_buffer: *Token.B
else => unreachable, else => unreachable,
} }
}, },
else => unreachable, else => {
var ch_array : [64]u8 = undefined;
try Compilation.write(.panic, "TODO char: 0x");
const ch_fmt = library.format_int(&ch_array, start_ch, 16, false);
try Compilation.write(.panic, ch_fmt);
try Compilation.write(.panic, "\n");
std.posix.exit(0);
},
} }
} }
token_buffer.append_with_capacity(.{ _ = token_buffer.tokens.append(.{
.id = .operator_backtick, .id = .operator_backtick,
.line = line_index, .line = line_index,
.length = 1, .length = 1,
@ -606,21 +615,16 @@ pub fn analyze(allocator: *MyAllocator, text: []const u8, token_buffer: *Token.B
const end_index = index; const end_index = index;
const token_length = end_index - start_index; const token_length = end_index - start_index;
token_buffer.append_with_capacity(.{ _ = token_buffer.tokens.append(.{
.id = token_id, .id = token_id,
.offset = start_index, .offset = start_index,
.length = token_length, .length = token_length,
.line = line_index, .line = line_index,
}); });
// const line_offset = token_buffer.line_offsets.pointer[line_index];
// const column = start_index - line_offset;
// logln(.lexer, .new_token, "T at line {}, column {}, byte offset {}, with length {} -line offset: {}- ({s})", .{ line_index, column, start_index, token_length, line_offset, @tagName(token_id) });
} }
// logln(.lexer, .end, "END LEXER - TOKEN OFFSET: {} - LINE OFFSET: {}", .{ Token.unwrap(lexer.offset), lexer.line_offset }); lexer.count = token_buffer.tokens.length - @intFromEnum(lexer.offset);
lexer.line_count = token_buffer.line_offsets.length - lexer.line_offset;
lexer.count = Token.sub(token_buffer.getOffset(), lexer.offset);
lexer.line_count = token_buffer.getLineOffset() - lexer.line_offset;
const time_end = std.time.Instant.now() catch unreachable; const time_end = std.time.Instant.now() catch unreachable;
lexer.time = time_end.since(time_start); lexer.time = time_end.since(time_start);

240
bootstrap/frontend/parser.zig
View File

@ -2,10 +2,14 @@ const std = @import("std");
const Allocator = std.mem.Allocator; const Allocator = std.mem.Allocator;
const assert = std.debug.assert; const assert = std.debug.assert;
const data_structures = @import("../library.zig"); const library = @import("../library.zig");
const UnpinnedArray = data_structures.UnpinnedArray; const Arena = library.Arena;
const BlockList = data_structures.BlockList; const byte_equal = library.byte_equal;
const enumFromString = data_structures.enumFromString; const BlockList = library.BlockList;
const BoundedArray = library.BoundedArray;
const enumFromString = library.enumFromString;
const PinnedArray = library.PinnedArray;
const MyAllocator = library.MyAllocator;
const lexer = @import("lexer.zig"); const lexer = @import("lexer.zig");
@ -62,8 +66,10 @@ pub const Node = struct {
token: Token.Index, token: Token.Index,
id: Id, id: Id,
pub const List = BlockList(@This(), enum {}); // TODO: this is dangerous
pub usingnamespace List.Index; pub const StackList = BoundedArray(Node.Index, 512);
pub const Index = PinnedArray(Node).Index;
pub const Range = struct { pub const Range = struct {
start: u32, start: u32,
@ -226,11 +232,12 @@ const Analyzer = struct {
lexer: lexer.Result, lexer: lexer.Result,
token_i: Token.Index, token_i: Token.Index,
token_buffer: *Token.Buffer, token_buffer: *Token.Buffer,
nodes: *Node.List, nodes: *PinnedArray(Node),
node_lists: *UnpinnedArray(UnpinnedArray(Node.Index)), node_lists: *PinnedArray([]const Node.Index),
source_file: []const u8, source_file: []const u8,
allocator: Allocator, allocator: Allocator,
my_allocator: *data_structures.MyAllocator, my_allocator: *MyAllocator,
arena: *Arena,
suffix_depth: usize = 0, suffix_depth: usize = 0,
fn expectToken(analyzer: *Analyzer, expected_token_id: Token.Id) !Token.Index { fn expectToken(analyzer: *Analyzer, expected_token_id: Token.Id) !Token.Index {
@ -259,18 +266,14 @@ const Analyzer = struct {
} }
fn getTokenOffset(analyzer: *Analyzer, token_index: Token.Index) u32 { fn getTokenOffset(analyzer: *Analyzer, token_index: Token.Index) u32 {
const index = Token.unwrap(token_index); const token = analyzer.token_buffer.tokens.get(token_index);
assert(index < analyzer.token_buffer.length); return token.offset;
const offset = analyzer.token_buffer.offsets[index];
return offset;
} }
fn peekTokenAhead(analyzer: *Analyzer, ahead_offset: u32) Token.Id { fn peekTokenAhead(analyzer: *Analyzer, ahead_offset: u32) Token.Id {
const token_index = Token.addInt(analyzer.token_i, ahead_offset); const index = @intFromEnum(analyzer.token_i) + ahead_offset;
const index = Token.unwrap(token_index); const token = analyzer.token_buffer.tokens.get_unchecked(index);
assert(index < analyzer.token_buffer.length); return token.id;
const token = analyzer.token_buffer.ids[index];
return token;
} }
fn peekToken(analyzer: *Analyzer) Token.Id { fn peekToken(analyzer: *Analyzer) Token.Id {
@ -280,11 +283,11 @@ const Analyzer = struct {
fn hasTokens(analyzer: *Analyzer) bool { fn hasTokens(analyzer: *Analyzer) bool {
const token_end = analyzer.getTokenEnd(); const token_end = analyzer.getTokenEnd();
return Token.unwrap(analyzer.token_i) < token_end; return @intFromEnum(analyzer.token_i) < token_end;
} }
fn getTokenEnd(analyzer: *const Analyzer) u32 { fn getTokenEnd(analyzer: *const Analyzer) u32 {
return @intFromEnum(Token.addInt(analyzer.lexer.offset, analyzer.lexer.count)); return @intFromEnum(analyzer.lexer.offset) + analyzer.lexer.count;
} }
fn consumeToken(analyzer: *Analyzer) void { fn consumeToken(analyzer: *Analyzer) void {
@ -292,29 +295,26 @@ const Analyzer = struct {
} }
fn consumeTokens(analyzer: *Analyzer, token_count: u32) void { fn consumeTokens(analyzer: *Analyzer, token_count: u32) void {
assert(Token.unwrap(Token.addInt(analyzer.token_i, token_count)) <= analyzer.getTokenEnd()); assert((@intFromEnum(analyzer.token_i) + token_count) <= analyzer.getTokenEnd());
// log(.parser, .consume_token, "Consuming {} {s}: ", .{ token_count, if (token_count == 1) "token" else "tokens" }); // log(.parser, .consume_token, "Consuming {} {s}: ", .{ token_count, if (token_count == 1) "token" else "tokens" });
for (0..token_count) |i_usize| { // for (0..token_count) |i_usize| {
const i: u32 = @intCast(i_usize); // const i: u32 = @intCast(i_usize);
const token_id = analyzer.peekTokenAhead(i); // const token_id = analyzer.peekTokenAhead(i);
_ = token_id; // autofix // _ = token_id; // autofix
const token_index = Token.addInt(analyzer.token_i, i); // const token_index = @intFromEnum(analyzer.token_i) + i;
const token_bytes = analyzer.bytes(token_index); // const token_bytes = analyzer.bytes(token_index);
_ = token_bytes; // autofix // _ = token_bytes; // autofix
// log(.parser, .consume_token, "{s}, '{s}'", .{ @tagName(token_id), token_bytes }); // // log(.parser, .consume_token, "{s}, '{s}'", .{ @tagName(token_id), token_bytes });
} // }
// log(.parser, .consume_token, "\n", .{}); // log(.parser, .consume_token, "\n", .{});
analyzer.token_i = Token.addInt(analyzer.token_i, token_count); analyzer.token_i = @enumFromInt(@intFromEnum(analyzer.token_i) + token_count);
} }
fn bytes(analyzer: *const Analyzer, token_index: Token.Index) []const u8 { fn bytes(analyzer: *const Analyzer, token_index: Token.Index) []const u8 {
const index = Token.unwrap(token_index); const token = analyzer.token_buffer.tokens.get(token_index);
assert(index < analyzer.token_buffer.length); const slice = analyzer.source_file[token.offset..][0..token.length];
const offset = analyzer.token_buffer.offsets[index];
const len = analyzer.token_buffer.lengths[index];
const slice = analyzer.source_file[offset..][0..len];
return slice; return slice;
} }
@ -340,13 +340,14 @@ const Analyzer = struct {
const attribute_node_index: Node.Index = if (analyzer.peekToken() == .operator_colon) b: { const attribute_node_index: Node.Index = if (analyzer.peekToken() == .operator_colon) b: {
analyzer.consumeToken(); analyzer.consumeToken();
var list = UnpinnedArray(Node.Index){}; var stack_list = Node.StackList{};
while (analyzer.peekToken() != .operator_assign) { while (analyzer.peekToken() != .operator_assign) {
const identifier = try analyzer.expectToken(.identifier); const identifier = try analyzer.expectToken(.identifier);
const identifier_name = analyzer.bytes(identifier); const identifier_name = analyzer.bytes(identifier);
const attribute_node = inline for (@typeInfo(Compilation.Debug.Declaration.Global.Attribute).Enum.fields) |enum_field| { const attribute_node = inline for (@typeInfo(Compilation.Debug.Declaration.Global.Attribute).Enum.fields) |enum_field| {
if (data_structures.byte_equal(identifier_name, enum_field.name)) { if (byte_equal(identifier_name, enum_field.name)) {
const attribute = @field(Compilation.Debug.Declaration.Global.Attribute, enum_field.name); const attribute = @field(Compilation.Debug.Declaration.Global.Attribute, enum_field.name);
const attribute_node = switch (attribute) { const attribute_node = switch (attribute) {
.@"export", .@"export",
@ -361,7 +362,8 @@ const Analyzer = struct {
break attribute_node; break attribute_node;
} }
} else @panic(identifier_name); } else @panic(identifier_name);
try list.append(analyzer.my_allocator, attribute_node);
stack_list.appendAssumeCapacity(attribute_node);
switch (analyzer.peekToken()) { switch (analyzer.peekToken()) {
.operator_assign => {}, .operator_assign => {},
@ -370,7 +372,7 @@ const Analyzer = struct {
} }
} }
break :b try analyzer.nodeList(list); break :b try analyzer.nodeList(&stack_list);
} else .null; } else .null;
break :blk try analyzer.addNode(.{ break :blk try analyzer.addNode(.{
@ -427,14 +429,14 @@ const Analyzer = struct {
fn functionPrototype(analyzer: *Analyzer) !Node.Index { fn functionPrototype(analyzer: *Analyzer) !Node.Index {
const token = analyzer.token_i; const token = analyzer.token_i;
var attribute_and_return_type_node_list = UnpinnedArray(Node.Index){}; var attribute_and_return_type_node_list = Node.StackList{};
while (analyzer.peekToken() != .operator_left_parenthesis) { while (analyzer.peekToken() != .operator_left_parenthesis) {
const identifier = try analyzer.expectToken(.identifier); const identifier = try analyzer.expectToken(.identifier);
const identifier_name = analyzer.bytes(identifier); const identifier_name = analyzer.bytes(identifier);
const attribute_node = inline for (@typeInfo(Compilation.Function.Attribute).Enum.fields) |enum_field| { const attribute_node = inline for (@typeInfo(Compilation.Function.Attribute).Enum.fields) |enum_field| {
if (data_structures.byte_equal(identifier_name, enum_field.name)) { if (byte_equal(identifier_name, enum_field.name)) {
const attribute = @field(Compilation.Function.Attribute, enum_field.name); const attribute = @field(Compilation.Function.Attribute, enum_field.name);
const attribute_node = switch (attribute) { const attribute_node = switch (attribute) {
.naked => try analyzer.addNode(.{ .naked => try analyzer.addNode(.{
@ -460,7 +462,7 @@ const Analyzer = struct {
} }
} else @panic(identifier_name); } else @panic(identifier_name);
try attribute_and_return_type_node_list.append(analyzer.my_allocator, attribute_node); attribute_and_return_type_node_list.appendAssumeCapacity(attribute_node);
if (analyzer.peekToken() == .operator_comma) analyzer.consumeToken(); if (analyzer.peekToken() == .operator_comma) analyzer.consumeToken();
} }
@ -469,13 +471,13 @@ const Analyzer = struct {
const arguments = try analyzer.argumentList(.operator_left_parenthesis, .operator_right_parenthesis); const arguments = try analyzer.argumentList(.operator_left_parenthesis, .operator_right_parenthesis);
const return_type = try analyzer.typeExpression(); const return_type = try analyzer.typeExpression();
try attribute_and_return_type_node_list.append(analyzer.my_allocator, return_type); attribute_and_return_type_node_list.appendAssumeCapacity(return_type);
const function_prototype = try analyzer.addNode(.{ const function_prototype = try analyzer.addNode(.{
.id = .function_prototype, .id = .function_prototype,
.token = token, .token = token,
.left = arguments, .left = arguments,
.right = try analyzer.nodeList(attribute_and_return_type_node_list), .right = try analyzer.nodeList(&attribute_and_return_type_node_list),
}); });
return function_prototype; return function_prototype;
@ -486,7 +488,7 @@ const Analyzer = struct {
_ = try analyzer.expectToken(start_token); _ = try analyzer.expectToken(start_token);
} }
var list = UnpinnedArray(Node.Index){}; var list = Node.StackList{};
while (analyzer.peekToken() != end_token) { while (analyzer.peekToken() != end_token) {
const identifier_token = analyzer.token_i; const identifier_token = analyzer.token_i;
@ -508,7 +510,7 @@ const Analyzer = struct {
analyzer.consumeToken(); analyzer.consumeToken();
} }
try list.append(analyzer.my_allocator, try analyzer.addNode(.{ list.appendAssumeCapacity(try analyzer.addNode(.{
.id = id, .id = id,
.token = identifier_token, .token = identifier_token,
.left = type_expression, .left = type_expression,
@ -518,8 +520,8 @@ const Analyzer = struct {
_ = try analyzer.expectToken(end_token); _ = try analyzer.expectToken(end_token);
if (list.length != 0) { if (list.len != 0) {
return try analyzer.nodeList(list); return try analyzer.nodeList(&list);
} else { } else {
return Node.Index.null; return Node.Index.null;
} }
@ -533,7 +535,7 @@ const Analyzer = struct {
fn block(analyzer: *Analyzer) anyerror!Node.Index { fn block(analyzer: *Analyzer) anyerror!Node.Index {
const left_brace = try analyzer.expectToken(.operator_left_brace); const left_brace = try analyzer.expectToken(.operator_left_brace);
var list = UnpinnedArray(Node.Index){}; var list = Node.StackList{};
while (analyzer.peekToken() != .operator_right_brace) { while (analyzer.peekToken() != .operator_right_brace) {
const first_statement_token = analyzer.peekToken(); const first_statement_token = analyzer.peekToken();
@ -550,7 +552,7 @@ const Analyzer = struct {
=> try analyzer.symbolDeclaration(), => try analyzer.symbolDeclaration(),
}; };
try list.append(analyzer.my_allocator, statement_index); list.appendAssumeCapacity(statement_index);
} }
_ = try analyzer.expectToken(.operator_right_brace); _ = try analyzer.expectToken(.operator_right_brace);
@ -558,7 +560,7 @@ const Analyzer = struct {
return try analyzer.addNode(.{ return try analyzer.addNode(.{
.id = .block, .id = .block,
.token = left_brace, .token = left_brace,
.left = try analyzer.nodeList(list), .left = try analyzer.nodeList(&list),
.right = Node.Index.null, .right = Node.Index.null,
}); });
} }
@ -596,7 +598,7 @@ const Analyzer = struct {
// logln(.parser, .@"switch", "Parsed switch expression...", .{}); // logln(.parser, .@"switch", "Parsed switch expression...", .{});
_ = try analyzer.expectToken(.operator_left_brace); _ = try analyzer.expectToken(.operator_left_brace);
var list = UnpinnedArray(Node.Index){}; var list = Node.StackList{};
while (analyzer.peekToken() != .operator_right_brace) { while (analyzer.peekToken() != .operator_right_brace) {
const case_token = analyzer.token_i; const case_token = analyzer.token_i;
@ -607,7 +609,7 @@ const Analyzer = struct {
break :blk Node.Index.null; break :blk Node.Index.null;
}, },
else => blk: { else => blk: {
var array_list = UnpinnedArray(Node.Index){}; var array_list = Node.StackList{};
while (true) { while (true) {
const token = analyzer.token_i; const token = analyzer.token_i;
const left = try analyzer.expression(); const left = try analyzer.expression();
@ -625,7 +627,7 @@ const Analyzer = struct {
else => left, else => left,
}; };
try array_list.append(analyzer.my_allocator, switch_case_node); array_list.appendAssumeCapacity(switch_case_node);
switch (analyzer.peekToken()) { switch (analyzer.peekToken()) {
.operator_comma => analyzer.consumeToken(), .operator_comma => analyzer.consumeToken(),
@ -634,10 +636,10 @@ const Analyzer = struct {
} }
} }
break :blk switch (array_list.length) { break :blk switch (array_list.len) {
0 => unreachable, 0 => unreachable,
1 => array_list.pointer[0], 1 => array_list.buffer[0],
else => try analyzer.nodeList(array_list), else => try analyzer.nodeList(&array_list),
}; };
}, },
}; };
@ -658,7 +660,7 @@ const Analyzer = struct {
.right = expr, .right = expr,
}); });
try list.append(analyzer.my_allocator, node); list.appendAssumeCapacity(node);
} }
_ = try analyzer.expectToken(.operator_right_brace); _ = try analyzer.expectToken(.operator_right_brace);
@ -667,7 +669,7 @@ const Analyzer = struct {
.id = .@"switch", .id = .@"switch",
.token = switch_token, .token = switch_token,
.left = switch_expression, .left = switch_expression,
.right = try analyzer.nodeList(list), .right = try analyzer.nodeList(&list),
}); });
} }
@ -743,7 +745,7 @@ const Analyzer = struct {
const token = try analyzer.expectToken(.fixed_keyword_for); const token = try analyzer.expectToken(.fixed_keyword_for);
_ = try analyzer.expectToken(.operator_left_parenthesis); _ = try analyzer.expectToken(.operator_left_parenthesis);
var for_expression_list = UnpinnedArray(Node.Index){}; var for_expression_list = Node.StackList{};
while (analyzer.peekToken() != .operator_right_parenthesis) { while (analyzer.peekToken() != .operator_right_parenthesis) {
const expression_token = analyzer.token_i; const expression_token = analyzer.token_i;
@ -768,7 +770,7 @@ const Analyzer = struct {
else => |t| @panic(@tagName(t)), else => |t| @panic(@tagName(t)),
}; };
try for_expression_list.append(analyzer.my_allocator, node_index); for_expression_list.appendAssumeCapacity(node_index);
switch (analyzer.peekToken()) { switch (analyzer.peekToken()) {
.operator_comma => analyzer.consumeToken(), .operator_comma => analyzer.consumeToken(),
@ -781,7 +783,7 @@ const Analyzer = struct {
_ = try analyzer.expectToken(.operator_bar); _ = try analyzer.expectToken(.operator_bar);
var payload_nodes = UnpinnedArray(Node.Index){}; var payload_nodes = Node.StackList{};
while (analyzer.peekToken() != .operator_bar) { while (analyzer.peekToken() != .operator_bar) {
const payload_token = analyzer.token_i; const payload_token = analyzer.token_i;
@ -799,7 +801,7 @@ const Analyzer = struct {
else => |t| @panic(@tagName(t)), else => |t| @panic(@tagName(t)),
} }
try payload_nodes.append(analyzer.my_allocator, try analyzer.addNode(.{ payload_nodes.appendAssumeCapacity(try analyzer.addNode(.{
.id = id, .id = id,
.token = payload_token, .token = payload_token,
.left = Node.Index.null, .left = Node.Index.null,
@ -809,15 +811,15 @@ const Analyzer = struct {
_ = try analyzer.expectToken(.operator_bar); _ = try analyzer.expectToken(.operator_bar);
if (payload_nodes.length != for_expression_list.length) { if (payload_nodes.len != for_expression_list.len) {
unreachable; unreachable;
} }
const for_condition_node = try analyzer.addNode(.{ const for_condition_node = try analyzer.addNode(.{
.id = .for_condition, .id = .for_condition,
.token = token, .token = token,
.left = try analyzer.nodeList(for_expression_list), .left = try analyzer.nodeList(&for_expression_list),
.right = try analyzer.nodeList(payload_nodes), .right = try analyzer.nodeList(&payload_nodes),
}); });
const true_expression = switch (analyzer.peekToken()) { const true_expression = switch (analyzer.peekToken()) {
@ -933,22 +935,22 @@ const Analyzer = struct {
const intrinsic_name = analyzer.bytes(intrinsic_token)[1..]; const intrinsic_name = analyzer.bytes(intrinsic_token)[1..];
const intrinsic_id = inline for (@typeInfo(Compilation.IntrinsicId).Enum.fields) |enum_field| { const intrinsic_id = inline for (@typeInfo(Compilation.IntrinsicId).Enum.fields) |enum_field| {
if (data_structures.byte_equal(enum_field.name, intrinsic_name)) { if (byte_equal(enum_field.name, intrinsic_name)) {
break @field(Compilation.IntrinsicId, enum_field.name); break @field(Compilation.IntrinsicId, enum_field.name);
} }
} else @panic(intrinsic_name); } else @panic(intrinsic_name);
var list = UnpinnedArray(Node.Index){}; var list = Node.StackList{};
if (intrinsic_id == .@"asm") { if (intrinsic_id == .@"asm") {
const backtick = try analyzer.expectToken(.operator_backtick); const backtick = try analyzer.expectToken(.operator_backtick);
var instruction_list = UnpinnedArray(Node.Index){}; var instruction_list = Node.StackList{};
while (analyzer.peekToken() != .operator_backtick) { while (analyzer.peekToken() != .operator_backtick) {
const instruction_token = analyzer.token_i; const instruction_token = analyzer.token_i;
const instruction_name = try analyzer.identifierNode(); const instruction_name = try analyzer.identifierNode();
var operand_list = UnpinnedArray(Node.Index){}; var operand_list = Node.StackList{};
while (analyzer.peekToken() != .operator_semicolon) { while (analyzer.peekToken() != .operator_semicolon) {
const node = switch (analyzer.peekToken()) { const node = switch (analyzer.peekToken()) {
.identifier => try analyzer.addNode(.{ .identifier => try analyzer.addNode(.{
@ -990,7 +992,7 @@ const Analyzer = struct {
.operator_semicolon => {}, .operator_semicolon => {},
else => |t| @panic(@tagName(t)), else => |t| @panic(@tagName(t)),
} }
try operand_list.append(analyzer.my_allocator, node); operand_list.appendAssumeCapacity(node);
} }
analyzer.consumeToken(); analyzer.consumeToken();
@ -999,10 +1001,10 @@ const Analyzer = struct {
.id = .assembly_instruction, .id = .assembly_instruction,
.token = instruction_token, .token = instruction_token,
.left = instruction_name, .left = instruction_name,
.right = try analyzer.nodeList(operand_list), .right = try analyzer.nodeList(&operand_list),
}); });
try instruction_list.append(analyzer.my_allocator, instruction); instruction_list.appendAssumeCapacity(instruction);
} }
_ = try analyzer.expectToken(.operator_backtick); _ = try analyzer.expectToken(.operator_backtick);
@ -1011,15 +1013,15 @@ const Analyzer = struct {
const assembly_block = try analyzer.addNode(.{ const assembly_block = try analyzer.addNode(.{
.id = .assembly_code_block, .id = .assembly_code_block,
.token = backtick, .token = backtick,
.left = try analyzer.nodeList(instruction_list), .left = try analyzer.nodeList(&instruction_list),
.right = .null, .right = .null,
}); });
try list.append(analyzer.my_allocator, assembly_block); list.appendAssumeCapacity(assembly_block);
const intrinsic = try analyzer.addNode(.{ const intrinsic = try analyzer.addNode(.{
.id = .intrinsic, .id = .intrinsic,
.token = intrinsic_token, .token = intrinsic_token,
.left = try analyzer.nodeList(list), .left = try analyzer.nodeList(&list),
.right = @enumFromInt(@intFromEnum(intrinsic_id)), .right = @enumFromInt(@intFromEnum(intrinsic_id)),
}); });
@ -1027,7 +1029,7 @@ const Analyzer = struct {
} else { } else {
while (analyzer.peekToken() != .operator_right_parenthesis) { while (analyzer.peekToken() != .operator_right_parenthesis) {
const parameter = try analyzer.expression(); const parameter = try analyzer.expression();
try list.append(analyzer.my_allocator, parameter); list.appendAssumeCapacity(parameter);
switch (analyzer.peekToken()) { switch (analyzer.peekToken()) {
.operator_comma => analyzer.consumeToken(), .operator_comma => analyzer.consumeToken(),
@ -1043,7 +1045,7 @@ const Analyzer = struct {
return try analyzer.addNode(.{ return try analyzer.addNode(.{
.id = .intrinsic, .id = .intrinsic,
.token = intrinsic_token, .token = intrinsic_token,
.left = try analyzer.nodeList(list), .left = try analyzer.nodeList(&list),
.right = @enumFromInt(@intFromEnum(intrinsic_id)), .right = @enumFromInt(@intFromEnum(intrinsic_id)),
}); });
} }
@ -1454,7 +1456,7 @@ const Analyzer = struct {
fn pointerOrArrayTypeExpression(analyzer: *Analyzer, expected: PointerOrArrayTypeExpectedExpression) !Node.Index { fn pointerOrArrayTypeExpression(analyzer: *Analyzer, expected: PointerOrArrayTypeExpectedExpression) !Node.Index {
const first = analyzer.token_i; const first = analyzer.token_i;
var list = UnpinnedArray(Node.Index){}; var list = Node.StackList{};
const expression_type: Node.Id = switch (expected) { const expression_type: Node.Id = switch (expected) {
.single_pointer_type => blk: { .single_pointer_type => blk: {
@ -1463,7 +1465,7 @@ const Analyzer = struct {
break :blk .pointer_type; break :blk .pointer_type;
}, },
.many_pointer_type => blk: { .many_pointer_type => blk: {
try list.append(analyzer.my_allocator, try analyzer.addNode(.{ list.appendAssumeCapacity(try analyzer.addNode(.{
.id = .many_pointer_expression, .id = .many_pointer_expression,
.token = analyzer.token_i, .token = analyzer.token_i,
.left = Node.Index.null, .left = Node.Index.null,
@ -1473,7 +1475,7 @@ const Analyzer = struct {
_ = try analyzer.expectToken(.operator_ampersand); _ = try analyzer.expectToken(.operator_ampersand);
switch (analyzer.peekToken()) { switch (analyzer.peekToken()) {
.operator_right_bracket => {}, .operator_right_bracket => {},
.operator_colon => try list.append(analyzer.my_allocator, try analyzer.parseTermination()), .operator_colon => list.appendAssumeCapacity(try analyzer.parseTermination()),
else => |t| @panic(@tagName(t)), else => |t| @panic(@tagName(t)),
} }
_ = try analyzer.expectToken(.operator_right_bracket); _ = try analyzer.expectToken(.operator_right_bracket);
@ -1488,17 +1490,17 @@ const Analyzer = struct {
break :blk .slice_type; break :blk .slice_type;
}, },
.operator_colon => { .operator_colon => {
try list.append(analyzer.my_allocator, try analyzer.parseTermination()); list.appendAssumeCapacity(try analyzer.parseTermination());
_ = try analyzer.expectToken(.operator_right_bracket); _ = try analyzer.expectToken(.operator_right_bracket);
break :blk .slice_type; break :blk .slice_type;
}, },
else => { else => {
const length_expression = try analyzer.expression(); const length_expression = try analyzer.expression();
try list.append(analyzer.my_allocator, length_expression); list.appendAssumeCapacity(length_expression);
switch (analyzer.peekToken()) { switch (analyzer.peekToken()) {
.operator_right_bracket => {}, .operator_right_bracket => {},
.operator_colon => try list.append(analyzer.my_allocator, try analyzer.parseTermination()), .operator_colon => list.appendAssumeCapacity(try analyzer.parseTermination()),
else => |t| @panic(@tagName(t)), else => |t| @panic(@tagName(t)),
} }
@ -1523,17 +1525,17 @@ const Analyzer = struct {
analyzer.consumeTokens(@intFromBool(analyzer.peekToken() == .fixed_keyword_const)); analyzer.consumeTokens(@intFromBool(analyzer.peekToken() == .fixed_keyword_const));
if (const_node != .null) { if (const_node != .null) {
try list.append(analyzer.my_allocator, const_node); list.appendAssumeCapacity(const_node);
} }
} else { } else {
assert(list.length > 0); assert(list.len > 0);
} }
const type_expression = try analyzer.typeExpression(); const type_expression = try analyzer.typeExpression();
assert(type_expression != .null); assert(type_expression != .null);
try list.append(analyzer.my_allocator, type_expression); list.appendAssumeCapacity(type_expression);
const node_list = try analyzer.nodeList(list); const node_list = try analyzer.nodeList(&list);
const node = Node{ const node = Node{
.id = expression_type, .id = expression_type,
@ -1542,15 +1544,7 @@ const Analyzer = struct {
.right = Node.Index.null, .right = Node.Index.null,
}; };
// logln(.parser, .pointer_like_type_expression, "ARRAY START\n===========", .{});
// for (list.slice()) |ni| {
// const n = analyzer.nodes.get(ni);
// logln(.parser, .pointer_like_type_expression, "{s} node element: {s}", .{ @tagName(expression_type), @tagName(n.id) });
// }
// logln(.parser, .pointer_like_type_expression, "ARRAY END\n=========", .{});
const node_index = try analyzer.addNode(node); const node_index = try analyzer.addNode(node);
// logln(.parser, .pointer_like_type_expression, "Pointer end", .{});
switch (analyzer.peekToken()) { switch (analyzer.peekToken()) {
.operator_comma, .operator_comma,
@ -1642,7 +1636,7 @@ const Analyzer = struct {
const left_parenthesis = analyzer.token_i; const left_parenthesis = analyzer.token_i;
analyzer.consumeToken(); analyzer.consumeToken();
var expression_list = UnpinnedArray(Node.Index){}; var expression_list = Node.StackList{};
// logln(.parser, .suffix, "[DEPTH={}] Initializating suffix call-like expression", .{analyzer.suffix_depth}); // logln(.parser, .suffix, "[DEPTH={}] Initializating suffix call-like expression", .{analyzer.suffix_depth});
while (analyzer.peekToken() != .operator_right_parenthesis) { while (analyzer.peekToken() != .operator_right_parenthesis) {
const current_token = analyzer.token_i; const current_token = analyzer.token_i;
@ -1661,7 +1655,7 @@ const Analyzer = struct {
}); });
} }
try expression_list.append(analyzer.my_allocator, parameter); expression_list.appendAssumeCapacity(parameter);
switch (analyzer.peekToken()) { switch (analyzer.peekToken()) {
.operator_right_parenthesis => {}, .operator_right_parenthesis => {},
@ -1681,7 +1675,7 @@ const Analyzer = struct {
.id = .call, .id = .call,
.token = left_parenthesis, .token = left_parenthesis,
.left = result, .left = result,
.right = try analyzer.nodeList(expression_list), .right = try analyzer.nodeList(&expression_list),
}); });
} else { } else {
return result; return result;
@ -1695,7 +1689,7 @@ const Analyzer = struct {
fn containerLiteral(analyzer: *Analyzer, type_node: Node.Index) anyerror!Node.Index { fn containerLiteral(analyzer: *Analyzer, type_node: Node.Index) anyerror!Node.Index {
const token = try analyzer.expectToken(.operator_left_brace); const token = try analyzer.expectToken(.operator_left_brace);
var list = UnpinnedArray(Node.Index){}; var list = Node.StackList{};
const InitializationType = enum { const InitializationType = enum {
anonymous, anonymous,
@ -1724,7 +1718,7 @@ const Analyzer = struct {
.right = Node.Index.null, .right = Node.Index.null,
}); });
try list.append(analyzer.my_allocator, field_initialization); list.appendAssumeCapacity(field_initialization);
switch (analyzer.peekToken()) { switch (analyzer.peekToken()) {
.operator_comma => analyzer.consumeToken(), .operator_comma => analyzer.consumeToken(),
else => {}, else => {},
@ -1735,7 +1729,7 @@ const Analyzer = struct {
else => |t| @panic(@tagName(t)), else => |t| @panic(@tagName(t)),
}, },
else => blk: { else => blk: {
try list.append(analyzer.my_allocator, try analyzer.anonymousExpression()); list.appendAssumeCapacity(try analyzer.anonymousExpression());
_ = try analyzer.expectToken(.operator_comma); _ = try analyzer.expectToken(.operator_comma);
break :blk .anonymous; break :blk .anonymous;
}, },
@ -1752,7 +1746,7 @@ const Analyzer = struct {
else => {}, else => {},
} }
try list.append(analyzer.my_allocator, field_expression_initializer); list.appendAssumeCapacity(field_expression_initializer);
break :blk .anonymous; break :blk .anonymous;
}, },
else => |t| @panic(@tagName(t)), else => |t| @panic(@tagName(t)),
@ -1796,7 +1790,7 @@ const Analyzer = struct {
}, },
.token = token, .token = token,
.left = type_node, .left = type_node,
.right = try analyzer.nodeList(list), .right = try analyzer.nodeList(&list),
}); });
} }
@ -1814,7 +1808,7 @@ const Analyzer = struct {
fn processContainerType(analyzer: *Analyzer, maybe_token_id: ?Token.Id) !Node.Index { fn processContainerType(analyzer: *Analyzer, maybe_token_id: ?Token.Id) !Node.Index {
const token_i = if (maybe_token_id) |tid| try analyzer.expectToken(tid) else analyzer.token_i; const token_i = if (maybe_token_id) |tid| try analyzer.expectToken(tid) else analyzer.token_i;
assert(Token.unwrap(analyzer.token_i) < analyzer.token_buffer.length); assert(@intFromEnum(analyzer.token_i) < analyzer.token_buffer.tokens.length);
const token_id = maybe_token_id orelse .fixed_keyword_struct; const token_id = maybe_token_id orelse .fixed_keyword_struct;
const container_type: Compilation.ContainerType = switch (token_id) { const container_type: Compilation.ContainerType = switch (token_id) {
.fixed_keyword_struct => .@"struct", .fixed_keyword_struct => .@"struct",
@ -1832,10 +1826,10 @@ const Analyzer = struct {
const parameters_node = if (analyzer.hasTokens() and analyzer.peekToken() == .operator_left_parenthesis) b: { const parameters_node = if (analyzer.hasTokens() and analyzer.peekToken() == .operator_left_parenthesis) b: {
analyzer.consumeToken(); analyzer.consumeToken();
var list = UnpinnedArray(Node.Index){}; var list = Node.StackList{};
while (analyzer.peekToken() != .operator_right_parenthesis) { while (analyzer.peekToken() != .operator_right_parenthesis) {
const parameter_node = try analyzer.expression(); const parameter_node = try analyzer.expression();
try list.append(analyzer.my_allocator, parameter_node); list.appendAssumeCapacity(parameter_node);
switch (analyzer.peekToken()) { switch (analyzer.peekToken()) {
.operator_comma => analyzer.consumeToken(), .operator_comma => analyzer.consumeToken(),
else => {}, else => {},
@ -1844,11 +1838,11 @@ const Analyzer = struct {
analyzer.consumeToken(); analyzer.consumeToken();
break :b try analyzer.nodeList(list); break :b try analyzer.nodeList(&list);
} else Node.Index.null; } else Node.Index.null;
if (maybe_token_id) |_| _ = try analyzer.expectToken(.operator_left_brace); if (maybe_token_id) |_| _ = try analyzer.expectToken(.operator_left_brace);
var node_list = UnpinnedArray(Node.Index){}; var list = Node.StackList{};
while (analyzer.hasTokens() and analyzer.peekToken() != .operator_right_brace) { while (analyzer.hasTokens() and analyzer.peekToken() != .operator_right_brace) {
const first = analyzer.token_i; const first = analyzer.token_i;
@ -1933,7 +1927,7 @@ const Analyzer = struct {
// logln(.parser, .container_members, "Container member {s}", .{@tagName(member_node.id)}); // logln(.parser, .container_members, "Container member {s}", .{@tagName(member_node.id)});
assert(member_node.id != .identifier); assert(member_node.id != .identifier);
try node_list.append(analyzer.my_allocator, member_node_index); list.appendAssumeCapacity(member_node_index);
} }
if (maybe_token_id) |_| _ = try analyzer.expectToken(.operator_right_brace); if (maybe_token_id) |_| _ = try analyzer.expectToken(.operator_right_brace);
@ -1953,7 +1947,7 @@ const Analyzer = struct {
return try analyzer.addNode(.{ return try analyzer.addNode(.{
.id = node_id, .id = node_id,
.token = token_i, .token = token_i,
.left = try analyzer.nodeList(node_list), .left = try analyzer.nodeList(&list),
.right = parameters_node, .right = parameters_node,
}); });
} }
@ -2141,7 +2135,7 @@ const Analyzer = struct {
} else Node.Index.null; } else Node.Index.null;
_ = try analyzer.expectToken(.operator_left_brace); _ = try analyzer.expectToken(.operator_left_brace);
var list = UnpinnedArray(Node.Index){}; var list = Node.StackList{};
while (analyzer.peekToken() != .operator_right_brace) { while (analyzer.peekToken() != .operator_right_brace) {
const tok_i = analyzer.token_i; const tok_i = analyzer.token_i;
@ -2167,7 +2161,7 @@ const Analyzer = struct {
.right = value_associated, .right = value_associated,
}); });
try list.append(analyzer.my_allocator, error_field_node); list.appendAssumeCapacity(error_field_node);
} }
analyzer.consumeToken(); analyzer.consumeToken();
@ -2175,7 +2169,7 @@ const Analyzer = struct {
break :blk try analyzer.addNode(.{ break :blk try analyzer.addNode(.{
.id = .error_type, .id = .error_type,
.token = token_i, .token = token_i,
.left = try analyzer.nodeList(list), .left = try analyzer.nodeList(&list),
.right = backing_type, .right = backing_type,
}); });
}, },
@ -2323,7 +2317,7 @@ const Analyzer = struct {
.right = blk: { .right = blk: {
const t = analyzer.token_i; const t = analyzer.token_i;
analyzer.consumeToken(); analyzer.consumeToken();
break :blk Node.wrap(Token.unwrap(t)); break :blk @enumFromInt(@intFromEnum(t));
}, },
}), }),
else => |t| @panic(@tagName(t)), else => |t| @panic(@tagName(t)),
@ -2335,7 +2329,8 @@ const Analyzer = struct {
} }
fn addNode(analyzer: *Analyzer, node: Node) !Node.Index { fn addNode(analyzer: *Analyzer, node: Node) !Node.Index {
const node_index = try analyzer.nodes.append(analyzer.my_allocator, node); const node_pointer = analyzer.nodes.append(node);
const node_index = analyzer.nodes.get_index(node_pointer);
// logln(.parser, .node_creation, "Adding node #{} {s} to file #{} (left: {}, right: {})", .{ Node.unwrap(node_index), @tagName(node.id), File.unwrap(analyzer.file_index), switch (node.left) { // logln(.parser, .node_creation, "Adding node #{} {s} to file #{} (left: {}, right: {})", .{ Node.unwrap(node_index), @tagName(node.id), File.unwrap(analyzer.file_index), switch (node.left) {
// .null => 0xffff_ffff, // .null => 0xffff_ffff,
// else => Node.unwrap(node.left), // else => Node.unwrap(node.left),
@ -2358,12 +2353,14 @@ const Analyzer = struct {
return node_index; return node_index;
} }
fn nodeList(analyzer: *Analyzer, node_list: UnpinnedArray(Node.Index)) !Node.Index { fn nodeList(analyzer: *Analyzer, stack_list: *Node.StackList) !Node.Index {
const heap_list = try analyzer.arena.new_array(Node.Index, stack_list.len);
@memcpy(heap_list, stack_list.slice());
const index = analyzer.node_lists.length; const index = analyzer.node_lists.length;
try analyzer.node_lists.append(analyzer.my_allocator, node_list); _ = analyzer.node_lists.append(heap_list);
return try analyzer.addNode(.{ return try analyzer.addNode(.{
.id = .node_list, .id = .node_list,
.token = Token.wrap(0), .token = @enumFromInt(0),
.left = @enumFromInt(index), .left = @enumFromInt(index),
.right = Node.Index.null, .right = Node.Index.null,
}); });
@ -2384,7 +2381,7 @@ const Analyzer = struct {
}; };
// Here it is assumed that left brace is consumed // Here it is assumed that left brace is consumed
pub fn analyze(allocator: Allocator, my_allocator: *data_structures.MyAllocator, lexer_result: lexer.Result, source_file: []const u8, token_buffer: *Token.Buffer, node_list: *Node.List, node_lists: *UnpinnedArray(UnpinnedArray(Node.Index))) !Result { pub fn analyze(allocator: Allocator, my_allocator: *MyAllocator, arena: *Arena, lexer_result: lexer.Result, source_file: []const u8, token_buffer: *Token.Buffer, node_list: *PinnedArray(Node), node_lists: *PinnedArray([]const Node.Index)) !Result {
const start = std.time.Instant.now() catch unreachable; const start = std.time.Instant.now() catch unreachable;
var analyzer = Analyzer{ var analyzer = Analyzer{
.lexer = lexer_result, .lexer = lexer_result,
@ -2396,6 +2393,7 @@ pub fn analyze(allocator: Allocator, my_allocator: *data_structures.MyAllocator,
.my_allocator = my_allocator, .my_allocator = my_allocator,
.nodes = node_list, .nodes = node_list,
.node_lists = node_lists, .node_lists = node_lists,
.arena = arena,
}; };
const main_node_index = try analyzer.processContainerType(null); const main_node_index = try analyzer.processContainerType(null);

556
bootstrap/library.zig
View File

@ -11,13 +11,13 @@ pub fn assert(ok: bool) void {
pub const Allocator = std.mem.Allocator; pub const Allocator = std.mem.Allocator;
pub const BoundedArray = std.BoundedArray; pub const BoundedArray = std.BoundedArray;
pub const Arena = struct{ pub const Arena = struct {
position: u64, position: u64,
commit_position: u64, commit_position: u64,
alignment: u64, alignment: u64,
size: u64, size: u64,
pub const Temporary = struct{ pub const Temporary = struct {
arena: *Arena, arena: *Arena,
position: u64, position: u64,
}; };
@ -26,7 +26,7 @@ pub const Arena = struct{
pub fn init(requested_size: u64) !*Arena { pub fn init(requested_size: u64) !*Arena {
var size = requested_size; var size = requested_size;
const size_roundup_granularity = 64 * 1024 * 1024; const size_roundup_granularity = commit_granularity;
size += size_roundup_granularity - 1; size += size_roundup_granularity - 1;
size -= size % size_roundup_granularity; size -= size % size_roundup_granularity;
const initial_commit_size = commit_granularity; const initial_commit_size = commit_granularity;
@ -35,7 +35,7 @@ pub const Arena = struct{
const reserved_memory = try reserve(size); const reserved_memory = try reserve(size);
try commit(reserved_memory, initial_commit_size); try commit(reserved_memory, initial_commit_size);
const arena: *Arena = @ptrCast(reserved_memory); const arena: *Arena = @alignCast(@ptrCast(reserved_memory));
arena.* = .{ arena.* = .{
.position = @sizeOf(Arena), .position = @sizeOf(Arena),
.commit_position = initial_commit_size, .commit_position = initial_commit_size,
@ -55,7 +55,7 @@ pub const Arena = struct{
const result = base + arena.position + alignment; const result = base + arena.position + alignment;
arena.position += size + alignment; arena.position += size + alignment;
if (arena.commit_position < arena.position - arena.commit_position) { if (arena.commit_position < arena.position) {
var size_to_commit = arena.position - arena.commit_position; var size_to_commit = arena.position - arena.commit_position;
size_to_commit += commit_granularity - 1; size_to_commit += commit_granularity - 1;
size_to_commit -= size_to_commit % commit_granularity; size_to_commit -= size_to_commit % commit_granularity;
@ -71,127 +71,205 @@ pub const Arena = struct{
} }
} }
pub inline fn new(arena: *Arena, comptime T: type) !*T{ pub inline fn new(arena: *Arena, comptime T: type) !*T {
const result: *T = @ptrCast(try arena.allocate(@sizeOf(T))); const result: *T = @ptrCast(@alignCast(try arena.allocate(@sizeOf(T))));
return result; return result;
} }
pub inline fn new_array(arena: *Arena, comptime T: type, count: usize) ![]T { pub inline fn new_array(arena: *Arena, comptime T: type, count: usize) ![]T {
const result: [*]T = @ptrCast(try arena.allocate(@sizeOf(T) * count)); const result: [*]T = @ptrCast(@alignCast(try arena.allocate(@sizeOf(T) * count)));
return result; return result[0..count];
} }
}; };
pub fn reserve(size: u64) ![*]u8{ pub fn DynamicBoundedArray(comptime T: type) type {
return struct {
pointer: [*]T = @constCast((&[_]T{}).ptr),
length: u32 = 0,
capacity: u32 = 0,
const Array = @This();
pub fn init(arena: *Arena, count: u32) !Array {
const array = try arena.new_array(T, count);
return Array{
.pointer = array.ptr,
.length = 0,
.capacity = count,
};
}
pub fn append(array: *Array, item: T) void {
const index = array.length;
assert(index < array.capacity);
array.pointer[index] = item;
array.length += 1;
}
pub fn append_slice(array: *Array, items: []const T) void {
const count: u32 = @intCast(items.len);
const index = array.length;
assert(index + count <= array.capacity);
@memcpy(array.pointer[index..][0..count], items);
array.length += count;
}
pub fn slice(array: *Array) []T {
return array.pointer[0..array.length];
}
};
}
const pinned_array_page_size = 2 * 1024 * 1024;
const pinned_array_max_size = std.math.maxInt(u32) - pinned_array_page_size;
const pinned_array_default_granularity = pinned_array_page_size;
// This must be used with big arrays, which are not resizeable (can't be cleared)
pub fn PinnedArray(comptime T: type) type {
return PinnedArrayAdvanced(T, null);
}
// This must be used with big arrays, which are not resizeable (can't be cleared)
pub fn PinnedArrayAdvanced(comptime T: type, comptime MaybeIndex: ?type) type {
return struct {
pointer: [*]T = @constCast((&[_]T{}).ptr),
length: u32 = 0,
granularity: u32 = 0,
pub const Index = if (MaybeIndex) |I| getIndexForType(T, I) else enum(u32) {
null = 0xffff_ffff,
_,
};
const Array = @This();
pub fn const_slice(array: *const Array) []const T {
return array.pointer[0..array.length];
}
pub fn slice(array: *Array) []T {
return array.pointer[0..array.length];
}
pub fn get_unchecked(array: *Array, index: u32) *T {
const array_slice = array.slice();
return &array_slice[index];
}
pub fn get(array: *Array, index: Index) *T {
assert(index != .null);
const i = @intFromEnum(index);
return array.get_unchecked(i);
}
pub fn get_index(array: *Array, item: *T) Index {
const many_item: [*]T = @ptrCast(item);
const result = @intFromPtr(many_item) - @intFromPtr(array.pointer);
assert(result < pinned_array_max_size);
return @enumFromInt(@divExact(result, @sizeOf(T)));
}
pub fn init(granularity: u32) !Array {
assert(granularity & 0xfff == 0);
const raw_ptr = try reserve(pinned_array_max_size);
try commit(raw_ptr, granularity);
return Array{
.pointer = @alignCast(@ptrCast(raw_ptr)),
.length = 0,
.granularity = granularity,
};
}
pub fn init_with_default_granularity() !Array {
return try Array.init(pinned_array_default_granularity);
}
pub fn ensure_capacity(array: *Array, additional: u32) void {
const length = array.length;
const size = length * @sizeOf(T);
const granularity_aligned_size = align_forward(size, array.granularity);
const new_size = size + additional * @sizeOf(T);
if (granularity_aligned_size < new_size) {
assert((length + additional) * @sizeOf(T) <= pinned_array_max_size);
const new_granularity_aligned_size = align_forward(new_size, array.granularity);
const ptr: [*]u8 = @ptrCast(array.pointer);
commit(ptr + granularity_aligned_size, new_granularity_aligned_size - granularity_aligned_size) catch unreachable;
}
}
pub fn append(array: *Array, item: T) *T {
array.ensure_capacity(1);
return array.append_with_capacity(item);
}
pub fn append_index(array: *Array, item: T) Index {
return array.get_index(array.append(item));
}
pub fn append_slice(array: *Array, items: []const T) void {
array.ensure_capacity(@intCast(items.len));
array.append_slice_with_capacity(items);
}
pub fn append_with_capacity(array: *Array, item: T) *T {
const index = array.length;
assert(index * @sizeOf(T) < pinned_array_max_size);
array.length += 1;
const ptr = &array.pointer[index];
ptr.* = item;
return ptr;
}
pub fn append_slice_with_capacity(array: *Array, items: []const T) void {
const index = array.length;
const count: u32 = @intCast(items.len);
assert((index + count - 1) * @sizeOf(T) < pinned_array_max_size);
array.length += count;
@memcpy(array.pointer[index..][0..count], items);
}
pub fn insert(array: *@This(), index: u32, item: T) void {
assert(index < array.length);
array.ensure_capacity(1);
const src = array.slice()[index..];
array.length += 1;
const dst = array.slice()[index + 1..];
copy_backwards(T, dst, src);
array.slice()[index] = item;
}
};
}
pub fn reserve(size: u64) ![*]u8 {
return switch (os) { return switch (os) {
.linux, .macos => try std.posix.mmap(null, size, std.posix.PROT.NONE, .{ .linux, .macos => (try std.posix.mmap(null, size, std.posix.PROT.NONE, .{
.ANONYMOUS = true, .ANONYMOUS = true,
.TYPE = .PRIVATE, .TYPE = .PRIVATE,
}, -1, 0), }, -1, 0)).ptr,
.windows => @ptrCast(try std.os.windows.VirtualAlloc(null, size, std.os.windows.MEM_RESERVE, std.os.windows.PAGE_READWRITE)),
else => @compileError("OS not supported"), else => @compileError("OS not supported"),
}; };
} }
pub fn commit(bytes: [*]u8, size: u64) !void{ pub fn commit(bytes: [*]u8, size: u64) !void {
const slice = bytes[0..size]; const slice = bytes[0..size];
return switch (os) { return switch (os) {
.linux, .macos => try std.posix.mprotect(@alignCast(slice), std.posix.PROT.WRITE | std.posix.PROT.READ), .linux, .macos => try std.posix.mprotect(@alignCast(slice), std.posix.PROT.WRITE | std.posix.PROT.READ),
.windows => _ = try std.os.windows.VirtualAlloc(bytes, size, std.os.windows.MEM_COMMIT, std.os.windows.PAGE_READWRITE),
else => @compileError("OS not supported"), else => @compileError("OS not supported"),
}; };
} }
pub fn BlockList(comptime T: type, comptime E: type) type {
const item_count = 64;
return struct {
blocks: UnpinnedArray(*Block) = .{},
len: usize = 0,
const Block = BoundedArray(T, item_count);
const List = @This();
pub const Index = getIndexForType(T, E);
pub const ElementIndex = Index.Index;
pub fn wrapSplit(block: usize, element: usize) ElementIndex {
return @enumFromInt(block * item_count + element);
}
pub fn get(list: *List, index: ElementIndex) *T {
assert(index != .null);
const i: u32 = @intFromEnum(index);
const block_index = i / item_count;
const element_index = i % item_count;
assert(block_index < list.blocks.length);
const block = list.blocks.pointer[block_index];
const block_slice = block.buffer[0..block.len];
const element = &block_slice[element_index];
return element;
}
pub fn append(list: *List, allocator: *MyAllocator, element: T) !ElementIndex {
const result = try list.addOne(allocator);
list.get(result).* = element;
return result;
}
pub fn addOne(list: *List, allocator: *MyAllocator) !ElementIndex {
const block_index = try list.getFreeBlock(allocator);
assert(block_index < list.blocks.length);
const block = list.blocks.pointer[block_index];
const index = block.len;
_ = try block.addOne();
list.len += 1;
return @enumFromInt(block_index * item_count + index);
}
fn getFreeBlock(list: *List, allocator: *MyAllocator) !usize {
for (list.blocks.slice(), 0..) |block, i| {
block.ensureUnusedCapacity(1) catch continue;
return i;
} else {
const new_block = try allocator.allocate_one(Block);
new_block.* = .{};
const block_index = list.blocks.length;
try list.blocks.append(allocator, new_block);
return block_index;
}
}
pub fn indexOf(list: *List, elem: *const T) ElementIndex {
const address = @intFromPtr(elem);
for (list.blocks.items, 0..) |block, block_index| {
const base = @intFromPtr(&block.buffer[0]);
const top = base + @sizeOf(T) * item_count;
if (address >= base and address < top) {
const result: u32 = @intCast(block_index * item_count + @divExact(address - base, @sizeOf(T)));
return Index.wrap(result);
}
}
@panic("not found");
}
};
}
pub fn getIndexForType(comptime T: type, comptime E: type) type { pub fn getIndexForType(comptime T: type, comptime E: type) type {
assert(@typeInfo(E) == .Enum); assert(@typeInfo(E) == .Enum);
_ = T; _ = T;
const MAX = std.math.maxInt(IndexType); const MAX = std.math.maxInt(u32);
const EnumField = std.builtin.Type.EnumField; const EnumField = std.builtin.Type.EnumField;
comptime var fields: []const EnumField = &.{}; comptime var fields: []const EnumField = &.{};
// comptime var enum_value: comptime_int = 0; // comptime var enum_value: comptime_int = 0;
fields = fields ++ @typeInfo(E).Enum.fields; fields = fields ++ @typeInfo(E).Enum.fields;
// for (names) |name| {
// fields = fields ++ [1]EnumField{.{
// .name = name,
// .value = enum_value,
// }};
// enum_value += 1;
// }
fields = fields ++ [1]EnumField{.{ fields = fields ++ [1]EnumField{.{
.name = "null", .name = "null",
.value = MAX, .value = MAX,
@ -199,47 +277,17 @@ pub fn getIndexForType(comptime T: type, comptime E: type) type {
const Result = @Type(.{ const Result = @Type(.{
.Enum = .{ .Enum = .{
.tag_type = IndexType, .tag_type = u32,
.fields = fields, .fields = fields,
.decls = &.{}, .decls = &.{},
.is_exhaustive = false, .is_exhaustive = false,
}, },
}); });
return struct { return Result;
pub const Index = Result;
pub fn unwrap(this: Index) IndexType {
assert(this != .null);
return @intFromEnum(this);
}
pub fn wrap(value: IndexType) Index {
assert(value < MAX);
return @enumFromInt(value);
}
pub fn addInt(this: Index, value: IndexType) Index {
const this_int = @intFromEnum(this);
return @enumFromInt(this_int + value);
}
pub fn subInt(this: Index, value: IndexType) IndexType {
const this_int = @intFromEnum(this);
return this_int - value;
}
pub fn add(a: Index, b: Index) Index {
return @enumFromInt(@intFromEnum(a) + @intFromEnum(b));
}
pub fn sub(a: Index, b: Index) IndexType {
return @intFromEnum(a) - @intFromEnum(b);
}
};
} }
pub fn my_hash(bytes: []const u8) IndexType { pub fn my_hash(bytes: []const u8) u32 {
const fnv_offset = 14695981039346656037; const fnv_offset = 14695981039346656037;
const fnv_prime = 1099511628211; const fnv_prime = 1099511628211;
var result: u64 = fnv_offset; var result: u64 = fnv_offset;
@ -301,47 +349,37 @@ pub fn byte_equal_terminated(a: [*:0]const u8, b: [*:0]const u8) bool {
return byte_equal(a_slice, b_slice); return byte_equal(a_slice, b_slice);
} }
const MapResult = struct { const pinned_hash_map_page_size = 2 * 1024 * 1024;
key_pointer: *anyopaque, const pinned_hash_map_max_size = std.math.maxInt(u32) - pinned_hash_map_page_size;
value_pointer: *anyopaque, const pinned_hash_map_default_granularity = pinned_hash_map_page_size;
capacity: IndexType,
};
fn ensure_capacity_hashmap(allocator: *MyAllocator, current_capacity: IndexType, desired_capacity: IndexType, key_pointer: [*]u8, value_pointer: [*]u8, length: IndexType, key_size: IndexType, key_alignment: u16, value_size: IndexType, value_alignment: u16) !MapResult { pub fn PinnedHashMap(comptime K: type, comptime V: type) type {
var new_capacity = @max(current_capacity, initial_item_count);
while (new_capacity < desired_capacity) {
new_capacity *= factor;
}
if (new_capacity > current_capacity) {
const old_key_slice = key_pointer[0 .. length * key_size];
const old_value_slice = value_pointer[0 .. length * value_size];
const new_key_slice = try allocator.reallocate(old_key_slice, new_capacity * key_size, key_alignment);
const new_value_slice = try allocator.reallocate(old_value_slice, new_capacity * value_size, value_alignment);
return .{
.key_pointer = new_key_slice.ptr,
.value_pointer = new_value_slice.ptr,
.capacity = new_capacity,
};
} else {
return .{
.capacity = current_capacity,
.key_pointer = key_pointer,
.value_pointer = value_pointer,
};
}
}
pub fn MyHashMap(comptime K: type, comptime V: type) type {
// const K = []const u8;
return struct { return struct {
key_pointer: [*]K = undefined, key_pointer: [*]K,
value_pointer: [*]V = undefined, value_pointer: [*]V,
length: IndexType = 0, length: u32,
capacity: IndexType = 0, granularity: u32,
committed: u32,
pub fn get_pointer(map: *@This(), key: K) ?*V { const Map = @This();
pub fn init(granularity: u32) !Map {
assert(granularity & 0xfff == 0);
const key_raw_pointer = try reserve(pinned_hash_map_max_size);
try commit(key_raw_pointer, granularity);
const value_raw_pointer = try reserve(pinned_hash_map_max_size);
try commit(value_raw_pointer, granularity);
return Map{
.key_pointer = @alignCast(@ptrCast(key_raw_pointer)),
.value_pointer = @alignCast(@ptrCast(value_raw_pointer)),
.length = 0,
.granularity = granularity,
.committed = 1,
};
}
pub fn get_pointer(map: *Map, key: K) ?*V {
for (map.keys(), 0..) |k, i| { for (map.keys(), 0..) |k, i| {
const is_equal = switch (@typeInfo(K)) { const is_equal = switch (@typeInfo(K)) {
.Pointer => |pointer| switch (pointer.size) { .Pointer => |pointer| switch (pointer.size) {
@ -368,35 +406,57 @@ pub fn MyHashMap(comptime K: type, comptime V: type) type {
} }
} }
pub fn put(map: *@This(), allocator: *MyAllocator, key: K, value: V) !void { pub fn put(map: *@This(), key: K, value: V) !void {
if (map.get_pointer(key)) |value_ptr| { if (map.get_pointer(key)) |value_pointer| {
value_ptr.* = value; value_pointer.* = value;
} else { } else {
const len = map.length; const len = map.length;
try map.ensure_capacity(allocator, len + 1); map.ensure_capacity(len + 1);
map.put_at_with_capacity(len, key, value); map.put_at_with_capacity(len, key, value);
} }
} }
pub fn put_no_clobber(map: *@This(), allocator: *MyAllocator, key: K, value: V) !void { pub fn put_no_clobber(map: *@This(), key: K, value: V) !void {
assert(map.get_pointer(key) == null); assert(map.get_pointer(key) == null);
const len = map.length; const len = map.length;
try map.ensure_capacity(allocator, len + 1); map.ensure_capacity(len + 1);
map.put_at_with_capacity(len, key, value); map.put_at_with_capacity(len, key, value);
} }
fn put_at_with_capacity(map: *@This(), index: IndexType, key: K, value: V) void { fn put_at_with_capacity(map: *@This(), index: u32, key: K, value: V) void {
map.length += 1; map.length += 1;
assert(index < map.length); assert(index < map.length);
map.key_pointer[index] = key; map.key_pointer[index] = key;
map.value_pointer[index] = value; map.value_pointer[index] = value;
} }
pub fn ensure_capacity(map: *@This(), allocator: *MyAllocator, desired_capacity: IndexType) !void { fn ensure_capacity(map: *Map, additional: u32) void {
const result = try ensure_capacity_hashmap(allocator, map.capacity, desired_capacity, @ptrCast(map.key_pointer), @ptrCast(map.value_pointer), map.length, @sizeOf(K), @alignOf(K), @sizeOf(V), @alignOf(V)); const length = map.length;
map.capacity = result.capacity; assert((length + additional) * @sizeOf(K) <= pinned_array_max_size);
map.key_pointer = @ptrCast(@alignCast(result.key_pointer));
map.value_pointer = @ptrCast(@alignCast(result.value_pointer)); {
const key_size = length * @sizeOf(K);
const key_granularity_aligned_size = align_forward(key_size, map.granularity);
const key_new_size = key_size + additional * @sizeOf(K);
if (key_granularity_aligned_size < key_new_size) {
const new_key_granularity_aligned_size = align_forward(key_new_size, map.granularity);
const key_pointer: [*]u8 = @ptrCast(map.key_pointer);
commit(key_pointer + key_granularity_aligned_size, new_key_granularity_aligned_size - key_granularity_aligned_size) catch unreachable;
}
}
{
const value_size = length * @sizeOf(V);
const value_granularity_aligned_size = align_forward(value_size, map.granularity);
const value_new_size = value_size + additional * @sizeOf(K);
if (value_granularity_aligned_size < value_new_size) {
const new_value_granularity_aligned_size = align_forward(value_new_size, map.granularity);
const value_pointer: [*]u8 = @ptrCast(map.value_pointer);
commit(value_pointer + value_granularity_aligned_size, new_value_granularity_aligned_size - value_granularity_aligned_size) catch unreachable;
}
}
} }
pub fn keys(map: *@This()) []K { pub fn keys(map: *@This()) []K {
@ -406,6 +466,10 @@ pub fn MyHashMap(comptime K: type, comptime V: type) type {
pub fn values(map: *@This()) []V { pub fn values(map: *@This()) []V {
return map.value_pointer[0..map.length]; return map.value_pointer[0..map.length];
} }
pub fn clear(map: *Map) void {
map.length = 0;
}
}; };
} }
@ -530,105 +594,6 @@ pub const PageAllocator = struct {
} }
}; };
pub const IndexType = if (@sizeOf(usize) >= 8) u32 else usize;
const ArrayCapacity = struct {
pointer: *anyopaque,
capacity: IndexType,
};
fn ensure_capacity_array(allocator: *MyAllocator, current_capacity: IndexType, desired_capacity: IndexType, pointer: [*]u8, length: IndexType, element_size: IndexType, element_alignment: u16) !ArrayCapacity {
var new_capacity = @max(current_capacity, initial_item_count);
while (new_capacity < desired_capacity) {
new_capacity *= factor;
}
if (new_capacity > current_capacity) {
const old_byte_slice = pointer[0 .. length * element_size];
const new_byte_capacity = new_capacity * element_size;
const new_slice = try allocator.reallocate(old_byte_slice, new_byte_capacity, element_alignment);
return .{
.pointer = new_slice.ptr,
.capacity = new_capacity,
};
} else {
return .{
.pointer = pointer,
.capacity = current_capacity,
};
}
}
const initial_item_count = 16;
const factor = 2;
pub fn UnpinnedArray(comptime T: type) type {
return struct {
pointer: [*]T = undefined,
length: IndexType = 0,
capacity: IndexType = 0,
pub fn initialize_with_capacity(allocator: *MyAllocator, item_count: IndexType) !@This() {
var array = @This(){};
try array.ensure_capacity(allocator, item_count);
return array;
}
pub fn ensure_capacity(array: *@This(), allocator: *MyAllocator, desired_capacity: IndexType) !void {
const result = try ensure_capacity_array(allocator, array.capacity, desired_capacity, @ptrCast(array.pointer), array.length, @sizeOf(T), @alignOf(T));
array.pointer = @ptrCast(@alignCast(result.pointer));
array.capacity = result.capacity;
}
pub fn append(array: *@This(), allocator: *MyAllocator, item: T) !void {
try array.ensure_capacity(allocator, array.length + 1);
array.append_with_capacity(item);
}
pub fn append_slice(array: *@This(), allocator: *MyAllocator, items: []const T) !void {
try array.ensure_capacity(allocator, @intCast(array.length + items.len));
@memcpy(array.pointer[array.length..][0..items.len], items);
array.length += @intCast(items.len);
}
pub fn append_with_capacity(array: *@This(), item: T) void {
assert(array.length < array.capacity);
array.pointer[array.length] = item;
array.length += 1;
}
pub fn slice(array: *@This()) []T {
return array.pointer[0..array.length];
}
pub fn insert(array: *@This(), allocator: *MyAllocator, index: IndexType, item: T) !void {
assert(index < array.length);
if (array.length + 1 <= array.capacity) {
const after_count = array.length - index;
copy_backwards(T, array.pointer[index + 1 ..][0..after_count], array.pointer[index..][0..after_count]);
} else {
const new_capacity = array.capacity * 2;
const new_slice = try allocator.allocate(new_capacity * @sizeOf(T), @alignOf(T));
const new_typed_slice: []T = @as([*]T, @ptrCast(@alignCast(new_slice.ptr)))[0..new_capacity];
@memcpy(new_typed_slice[0..index], array.pointer[0..index]);
const after_count = array.length - index;
@memcpy(new_typed_slice[index + 1 ..][0..after_count], array.pointer[index..][0..after_count]);
try allocator.free(@as([*]u8, @ptrCast(@alignCast(array.slice().ptr)))[0 .. array.capacity * @sizeOf(T)]);
array.pointer = new_typed_slice.ptr;
array.capacity = new_capacity;
}
array.pointer[index] = item;
array.length += 1;
}
pub fn pop(array: *@This()) T {
assert(array.length > 0);
array.length -= 1;
return array.pointer[array.length];
}
};
}
fn copy_backwards(comptime T: type, destination: []T, source: []const T) void { fn copy_backwards(comptime T: type, destination: []T, source: []const T) void {
@setRuntimeSafety(false); @setRuntimeSafety(false);
assert(destination.len >= source.len); assert(destination.len >= source.len);
@ -639,41 +604,6 @@ fn copy_backwards(comptime T: type, destination: []T, source: []const T) void {
} }
} }
test {
var page_allocator = PageAllocator{};
const allocator = &page_allocator.allocator;
var foo = UnpinnedArray(u32){};
try foo.append(allocator, 1);
try foo.append(allocator, 1);
try foo.append(allocator, 1);
try foo.append(allocator, 1);
try foo.append(allocator, 1);
try foo.append(allocator, 1);
try foo.append(allocator, 1);
try foo.append(allocator, 1);
try foo.append(allocator, 1);
try foo.append(allocator, 1);
try foo.append(allocator, 1);
try foo.append(allocator, 1);
try foo.append(allocator, 1);
try foo.append(allocator, 1);
try foo.append(allocator, 1);
try foo.append(allocator, 1);
try foo.append(allocator, 1);
try foo.append(allocator, 1);
try foo.append(allocator, 1);
try foo.append(allocator, 1);
try foo.append(allocator, 1);
try foo.append(allocator, 1);
try foo.append(allocator, 1);
try foo.append(allocator, 1);
try foo.append(allocator, 1);
try foo.append(allocator, 1);
try foo.append(allocator, 1);
try foo.append(allocator, 1);
try foo.append(allocator, 1);
}
pub fn equal(a: anytype, b: @TypeOf(a)) bool { pub fn equal(a: anytype, b: @TypeOf(a)) bool {
const T = @TypeOf(a); const T = @TypeOf(a);

92
bootstrap/linker/lld.zig
View File

@ -3,97 +3,97 @@ const assert = std.debug.assert;
const linker = @import("linker.zig"); const linker = @import("linker.zig");
const library = @import("../library.zig"); const library = @import("../library.zig");
const UnpinnedArray = library.UnpinnedArray; const PinnedArray = library.PinnedArray;
const Compilation = @import("../Compilation.zig"); const Compilation = @import("../Compilation.zig");
const write = Compilation.write; const write = Compilation.write;
pub fn link(context: *const Compilation.Context, options: linker.Options) !void { pub fn link(context: *const Compilation.Context, options: linker.Options) !void {
assert(options.backend == .lld); assert(options.backend == .lld);
var argv = UnpinnedArray([]const u8){}; var argv = try PinnedArray([]const u8).init_with_default_granularity();
const driver_program = switch (@import("builtin").os.tag) { const driver_program = switch (@import("builtin").os.tag) {
.windows => "lld-link", .windows => "lld-link",
.linux => "ld.lld", .linux => "ld.lld",
.macos => "ld64.lld", .macos => "ld64.lld",
else => @compileError("OS not supported"), else => @compileError("OS not supported"),
}; };
try argv.append(context.my_allocator, driver_program); _ = argv.append(driver_program);
try argv.append(context.my_allocator, "--error-limit=0"); _ = argv.append("--error-limit=0");
// const output_path = out_path orelse "a.out"; // const output_path = out_path orelse "a.out";
try argv.append(context.my_allocator, "-o"); _ = argv.append("-o");
try argv.append(context.my_allocator, options.output_file_path); _ = argv.append(options.output_file_path);
try argv.append_slice(context.my_allocator, options.extra_arguments); argv.append_slice(options.extra_arguments);
for (options.objects) |object| { for (options.objects) |object| {
try argv.append(context.my_allocator, object.path); _ = argv.append(object.path);
} }
const ci = @import("configuration").ci; const ci = @import("configuration").ci;
switch (@import("builtin").os.tag) { switch (@import("builtin").os.tag) {
.macos => { .macos => {
try argv.append(context.my_allocator, "-dynamic"); _ = argv.append("-dynamic");
try argv.append_slice(context.my_allocator, &.{ "-platform_version", "macos", "13.4.1", "13.3" }); argv.append_slice(&.{ "-platform_version", "macos", "13.4.1", "13.3" });
try argv.append(context.my_allocator, "-arch"); _ = argv.append("-arch");
try argv.append(context.my_allocator, switch (@import("builtin").cpu.arch) { _ = argv.append(switch (@import("builtin").cpu.arch) {
.aarch64 => "arm64", .aarch64 => "arm64",
else => |t| @panic(@tagName(t)), else => |t| @panic(@tagName(t)),
}); });
try argv.append_slice(context.my_allocator, &.{ "-syslibroot", "/Library/Developer/CommandLineTools/SDKs/MacOSX.sdk" }); argv.append_slice(&.{ "-syslibroot", "/Library/Developer/CommandLineTools/SDKs/MacOSX.sdk" });
if (!library.ends_with_slice(options.output_file_path, ".dylib")) { if (!library.ends_with_slice(options.output_file_path, ".dylib")) {
try argv.append_slice(context.my_allocator, &.{ "-e", "_main" }); argv.append_slice(&.{ "-e", "_main" });
} }
try argv.append(context.my_allocator, "-lSystem"); _ = argv.append("-lSystem");
if (options.link_libcpp) { if (options.link_libcpp) {
try argv.append(context.my_allocator, "-L/Library/Developer/CommandLineTools/SDKs/MacOSX13.3.sdk/usr/lib"); _ = argv.append("-L/Library/Developer/CommandLineTools/SDKs/MacOSX13.3.sdk/usr/lib");
try argv.append(context.my_allocator, "-lc++"); _ = argv.append("-lc++");
} }
}, },
.linux => { .linux => {
if (ci) { if (ci) {
if (options.link_libcpp) { if (options.link_libcpp) {
assert(options.link_libc); assert(options.link_libc);
try argv.append(context.my_allocator, "/lib/x86_64-linux-gnu/libstdc++.so.6"); _ = argv.append("/lib/x86_64-linux-gnu/libstdc++.so.6");
} }
if (options.link_libc) { if (options.link_libc) {
try argv.append(context.my_allocator, "/lib/x86_64-linux-gnu/crt1.o"); _ = argv.append("/lib/x86_64-linux-gnu/crt1.o");
try argv.append(context.my_allocator, "/lib/x86_64-linux-gnu/crti.o"); _ = argv.append("/lib/x86_64-linux-gnu/crti.o");
try argv.append_slice(context.my_allocator, &.{ "-L", "/lib/x86_64-linux-gnu" }); argv.append_slice(&.{ "-L", "/lib/x86_64-linux-gnu" });
try argv.append_slice(context.my_allocator, &.{ "-dynamic-linker", "/lib64/ld-linux-x86-64.so.2" }); argv.append_slice(&.{ "-dynamic-linker", "/lib64/ld-linux-x86-64.so.2" });
try argv.append(context.my_allocator, "--as-needed"); _ = argv.append("--as-needed");
try argv.append(context.my_allocator, "-lm"); _ = argv.append("-lm");
try argv.append(context.my_allocator, "-lpthread"); _ = argv.append("-lpthread");
try argv.append(context.my_allocator, "-lc"); _ = argv.append("-lc");
try argv.append(context.my_allocator, "-ldl"); _ = argv.append("-ldl");
try argv.append(context.my_allocator, "-lrt"); _ = argv.append("-lrt");
try argv.append(context.my_allocator, "-lutil"); _ = argv.append("-lutil");
try argv.append(context.my_allocator, "/lib/x86_64-linux-gnu/crtn.o"); _ = argv.append("/lib/x86_64-linux-gnu/crtn.o");
} }
} else { } else {
if (options.link_libcpp) { if (options.link_libcpp) {
assert(options.link_libc); assert(options.link_libc);
try argv.append(context.my_allocator, "/usr/lib/libstdc++.so"); _ = argv.append("/usr/lib/libstdc++.so");
} }
if (options.link_libc) { if (options.link_libc) {
try argv.append(context.my_allocator, "/usr/lib/crt1.o"); _ = argv.append("/usr/lib/crt1.o");
try argv.append(context.my_allocator, "/usr/lib/crti.o"); _ = argv.append("/usr/lib/crti.o");
try argv.append_slice(context.my_allocator, &.{ "-L", "/usr/lib" }); argv.append_slice(&.{ "-L", "/usr/lib" });
try argv.append_slice(context.my_allocator, &.{ "-dynamic-linker", "/lib64/ld-linux-x86-64.so.2" }); argv.append_slice(&.{ "-dynamic-linker", "/lib64/ld-linux-x86-64.so.2" });
try argv.append(context.my_allocator, "--as-needed"); _ = argv.append("--as-needed");
try argv.append(context.my_allocator, "-lm"); _ = argv.append("-lm");
try argv.append(context.my_allocator, "-lpthread"); _ = argv.append("-lpthread");
try argv.append(context.my_allocator, "-lc"); _ = argv.append("-lc");
try argv.append(context.my_allocator, "-ldl"); _ = argv.append("-ldl");
try argv.append(context.my_allocator, "-lrt"); _ = argv.append("-lrt");
try argv.append(context.my_allocator, "-lutil"); _ = argv.append("-lutil");
try argv.append(context.my_allocator, "/usr/lib/crtn.o"); _ = argv.append("/usr/lib/crtn.o");
} }
} }
}, },
@ -102,10 +102,10 @@ pub fn link(context: *const Compilation.Context, options: linker.Options) !void
} }
for (options.libraries) |lib| { for (options.libraries) |lib| {
try argv.append(context.my_allocator, try std.mem.concat(context.allocator, u8, &.{ "-l", lib.path })); _ = argv.append(try std.mem.concat(context.allocator, u8, &.{ "-l", lib.path }));
} }
const argv_zero_terminated = try Compilation.argsCopyZ(context.allocator, argv.slice()); const argv_zero_terminated = try Compilation.argsCopyZ(context.allocator, argv.const_slice());
var stdout_ptr: [*]const u8 = undefined; var stdout_ptr: [*]const u8 = undefined;
var stdout_len: usize = 0; var stdout_len: usize = 0;
@ -121,7 +121,7 @@ pub fn link(context: *const Compilation.Context, options: linker.Options) !void
if (!result) { if (!result) {
const stdout = stdout_ptr[0..stdout_len]; const stdout = stdout_ptr[0..stdout_len];
const stderr = stderr_ptr[0..stderr_len]; const stderr = stderr_ptr[0..stderr_len];
for (argv.slice()) |arg| { for (argv.const_slice()) |arg| {
try write(.panic, arg); try write(.panic, arg);
try write(.panic, " "); try write(.panic, " ");
} }

33
bootstrap/main.zig
View File

@ -26,26 +26,21 @@ var my_allocator = PageAllocator{};
pub fn main() !void { pub fn main() !void {
var arena_allocator = std.heap.ArenaAllocator.init(std.heap.page_allocator); var arena_allocator = std.heap.ArenaAllocator.init(std.heap.page_allocator);
const allocator = arena_allocator.allocator(); const allocator = arena_allocator.allocator();
var arg_it = try std.process.ArgIterator.initWithAllocator(allocator); const arguments: []const []const u8 = try std.process.argsAlloc(allocator);
var args = library.UnpinnedArray([]const u8){};
const context = try Compilation.createContext(allocator, &my_allocator.allocator); const context = try Compilation.createContext(allocator, &my_allocator.allocator);
while (arg_it.next()) |arg| { // const debug_args = false;
try args.append(context.my_allocator, arg); // if (debug_args and @import("builtin").os.tag != .windows) {
} // assert(arguments.len > 0);
const arguments = args.slice(); // const home_dir = std.posix.getenv("HOME") orelse unreachable;
const debug_args = false; // const timestamp = std.time.milliTimestamp();
if (debug_args and @import("builtin").os.tag != .windows) { // var argument_list = PinnedArray(u8){};
assert(arguments.len > 0); // for (arguments) |arg| {
const home_dir = std.posix.getenv("HOME") orelse unreachable; // argument_list.append_slice(context.my_allocator, arg) catch {};
const timestamp = std.time.milliTimestamp(); // argument_list.append(context.my_allocator, ' ') catch {};
var argument_list = std.ArrayList(u8).init(std.heap.page_allocator); // }
for (arguments) |arg| { // argument_list.append(context.my_allocator, '\n') catch {};
argument_list.appendSlice(arg) catch {}; // std.fs.cwd().writeFile(std.fmt.allocPrint(std.heap.page_allocator, "{s}/dev/nativity/nat/invocation_log_{}", .{ home_dir, timestamp }) catch unreachable, argument_list.slice()) catch {};
argument_list.append(' ') catch {}; // }
}
argument_list.append('\n') catch {};
std.fs.cwd().writeFile(std.fmt.allocPrint(std.heap.page_allocator, "{s}/dev/nativity/nat/invocation_log_{}", .{ home_dir, timestamp }) catch unreachable, argument_list.items) catch {};
}
if (arguments.len <= 1) { if (arguments.len <= 1) {
return error.InvalidInput; return error.InvalidInput;

2
lib/std/std.nat
View File

@ -141,7 +141,7 @@ const Arena = struct{
const result = base + arena.position + alignment; const result = base + arena.position + alignment;
arena.position += size + alignment; arena.position += size + alignment;
if (arena.commit_position < arena.position - arena.commit_position) { if (arena.commit_position < arena.position) {
var size_to_commit = arena.position - arena.commit_position; var size_to_commit = arena.position - arena.commit_position;
size_to_commit += commit_granularity - 1; size_to_commit += commit_granularity - 1;
size_to_commit -= size_to_commit % commit_granularity; size_to_commit -= size_to_commit % commit_granularity;