Merge pull request #102 from birth-software/avoid-bloat
Avoid Zig standard library bloat
This commit is contained in:
David
GitHub
commit
79fee952ff
File diff suppressed because it is too large
Load Diff
File diff suppressed because it is too large
Load Diff
@ -1,286 +0,0 @@
|
||||
const std = @import("std");
|
||||
const assert = std.debug.assert;
|
||||
|
||||
pub const Allocator = std.mem.Allocator;
|
||||
pub const AutoArrayHashMap = std.AutoArrayHashMapUnmanaged;
|
||||
pub const ArrayList = std.ArrayListUnmanaged;
|
||||
pub const ArrayListAligned = std.ArrayListAlignedUnmanaged;
|
||||
pub const AutoHashMap = std.AutoHashMapUnmanaged;
|
||||
pub const BoundedArray = std.BoundedArray;
|
||||
pub const HashMap = std.HashMapUnmanaged;
|
||||
pub const StringHashMap = std.StringHashMapUnmanaged;
|
||||
pub const StringArrayHashMap = std.StringArrayHashMapUnmanaged;
|
||||
|
||||
pub fn BlockList(comptime T: type, comptime E: type) type {
|
||||
const item_count = 64;
|
||||
|
||||
return struct {
|
||||
blocks: ArrayList(*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 const append = switch (list_type) {
|
||||
// .index => appendIndexed,
|
||||
// .pointer => appendPointer,
|
||||
// };
|
||||
// pub const addOne = switch (list_type) {
|
||||
// .index => addOneIndexed,
|
||||
// .pointer => addOnePointer,
|
||||
// };
|
||||
|
||||
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;
|
||||
const block = list.blocks.items[block_index];
|
||||
const block_slice = block.buffer[0..block.len];
|
||||
const element = &block_slice[element_index];
|
||||
return element;
|
||||
}
|
||||
|
||||
pub fn append(list: *List, allocator: Allocator, element: T) !ElementIndex {
|
||||
const result = try list.addOne(allocator);
|
||||
list.get(result).* = element;
|
||||
return result;
|
||||
}
|
||||
|
||||
pub fn addOne(list: *List, allocator: Allocator) !ElementIndex {
|
||||
const block_index = try list.getFreeBlock(allocator);
|
||||
const block = list.blocks.items[block_index];
|
||||
const index = block.len;
|
||||
_ = try block.addOne();
|
||||
return @enumFromInt(block_index * item_count + index);
|
||||
}
|
||||
|
||||
fn getFreeBlock(list: *List, allocator: Allocator) !usize {
|
||||
for (list.blocks.items, 0..) |block, i| {
|
||||
block.ensureUnusedCapacity(1) catch continue;
|
||||
return i;
|
||||
} else {
|
||||
const new_block = try allocator.create(Block);
|
||||
new_block.* = .{};
|
||||
const block_index = list.blocks.items.len;
|
||||
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 {
|
||||
assert(@typeInfo(E) == .Enum);
|
||||
_ = T;
|
||||
const IndexType = u32;
|
||||
const MAX = std.math.maxInt(IndexType);
|
||||
|
||||
const EnumField = std.builtin.Type.EnumField;
|
||||
comptime var fields: []const EnumField = &.{};
|
||||
// comptime var enum_value: comptime_int = 0;
|
||||
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{.{
|
||||
.name = "null",
|
||||
.value = MAX,
|
||||
}};
|
||||
|
||||
const Result = @Type(.{
|
||||
.Enum = .{
|
||||
.tag_type = IndexType,
|
||||
.fields = fields,
|
||||
.decls = &.{},
|
||||
.is_exhaustive = false,
|
||||
},
|
||||
});
|
||||
|
||||
return struct {
|
||||
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 const ListType = enum {
|
||||
index,
|
||||
pointer,
|
||||
};
|
||||
|
||||
pub fn enumFromString(comptime E: type, string: []const u8) ?E {
|
||||
return inline for (@typeInfo(E).Enum.fields) |enum_field| {
|
||||
if (std.mem.eql(u8, string, enum_field.name)) {
|
||||
break @field(E, enum_field.name);
|
||||
}
|
||||
} else null;
|
||||
}
|
||||
|
||||
pub fn hash(string: []const u8) u32 {
|
||||
const string_key: u32 = @truncate(std.hash.Wyhash.hash(0, string));
|
||||
return string_key;
|
||||
}
|
||||
|
||||
pub fn StringKeyMap(comptime Value: type) type {
|
||||
return struct {
|
||||
list: std.MultiArrayList(Data) = .{},
|
||||
const Key = u32;
|
||||
const Data = struct {
|
||||
key: Key,
|
||||
value: Value,
|
||||
};
|
||||
|
||||
pub fn length(string_map: *@This()) usize {
|
||||
return string_map.list.len;
|
||||
}
|
||||
|
||||
fn hash(string: []const u8) Key {
|
||||
const string_key: Key = @truncate(std.hash.Wyhash.hash(0, string));
|
||||
return string_key;
|
||||
}
|
||||
|
||||
pub fn getKey(string_map: *const @This(), string: []const u8) ?Key {
|
||||
return if (string_map.getKeyPtr(string)) |key_ptr| key_ptr.* else null;
|
||||
}
|
||||
|
||||
pub fn getKeyPtr(string_map: *const @This(), string_key: Key) ?*const Key {
|
||||
for (string_map.list.items(.key)) |*key_ptr| {
|
||||
if (key_ptr.* == string_key) {
|
||||
return key_ptr;
|
||||
}
|
||||
} else {
|
||||
return null;
|
||||
}
|
||||
}
|
||||
|
||||
pub fn getValue(string_map: *const @This(), key: Key) ?Value {
|
||||
if (string_map.getKeyPtr(key)) |key_ptr| {
|
||||
const index = string_map.indexOfKey(key_ptr);
|
||||
return string_map.list.items(.value)[index];
|
||||
} else {
|
||||
return null;
|
||||
}
|
||||
}
|
||||
|
||||
pub fn indexOfKey(string_map: *const @This(), key_ptr: *const Key) usize {
|
||||
return @divExact(@intFromPtr(key_ptr) - @intFromPtr(string_map.list.items(.key).ptr), @sizeOf(Key));
|
||||
}
|
||||
|
||||
const GOP = struct {
|
||||
key: Key,
|
||||
found_existing: bool,
|
||||
};
|
||||
|
||||
pub fn getOrPut(string_map: *@This(), allocator: Allocator, string: []const u8, value: Value) !GOP {
|
||||
const string_key: Key = @truncate(std.hash.Wyhash.hash(0, string));
|
||||
for (string_map.list.items(.key)) |key| {
|
||||
if (key == string_key) return .{
|
||||
.key = string_key,
|
||||
.found_existing = true,
|
||||
};
|
||||
} else {
|
||||
try string_map.list.append(allocator, .{
|
||||
.key = string_key,
|
||||
.value = value,
|
||||
});
|
||||
|
||||
return .{
|
||||
.key = string_key,
|
||||
.found_existing = false,
|
||||
};
|
||||
}
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
const page_size = std.mem.page_size;
|
||||
extern fn pthread_jit_write_protect_np(enabled: bool) void;
|
||||
|
||||
pub fn mmap(size: usize, flags: packed struct {
|
||||
executable: bool = false,
|
||||
}) ![]align(page_size) u8 {
|
||||
return switch (@import("builtin").os.tag) {
|
||||
.windows => blk: {
|
||||
const windows = std.os.windows;
|
||||
break :blk @as([*]align(page_size) u8, @ptrCast(@alignCast(try windows.VirtualAlloc(null, size, windows.MEM_COMMIT | windows.MEM_RESERVE, windows.PAGE_EXECUTE_READWRITE))))[0..size];
|
||||
},
|
||||
.linux, .macos => |os_tag| blk: {
|
||||
const jit = switch (os_tag) {
|
||||
.macos => 0x800,
|
||||
.linux => 0,
|
||||
else => unreachable,
|
||||
};
|
||||
const execute_flag: switch (os_tag) {
|
||||
.linux => u32,
|
||||
.macos => c_int,
|
||||
else => unreachable,
|
||||
} = if (flags.executable) std.os.PROT.EXEC else 0;
|
||||
const protection_flags: u32 = @intCast(std.os.PROT.READ | std.os.PROT.WRITE | execute_flag);
|
||||
const mmap_flags = std.os.MAP.ANONYMOUS | std.os.MAP.PRIVATE | jit;
|
||||
|
||||
const result = try std.os.mmap(null, size, protection_flags, mmap_flags, -1, 0);
|
||||
if (@import("builtin").cpu.arch == .aarch64 and @import("builtin").os.tag == .macos) {
|
||||
if (flags.executable) {
|
||||
pthread_jit_write_protect_np(false);
|
||||
}
|
||||
}
|
||||
|
||||
break :blk result;
|
||||
},
|
||||
else => @compileError("OS not supported"),
|
||||
};
|
||||
}
|
||||
@ -3,11 +3,9 @@ const Allocator = std.mem.Allocator;
|
||||
const assert = std.debug.assert;
|
||||
const log = std.log;
|
||||
|
||||
const equal = std.mem.eql;
|
||||
|
||||
const data_structures = @import("../data_structures.zig");
|
||||
const ArrayList = data_structures.ArrayList;
|
||||
const data_structures = @import("../library.zig");
|
||||
const enumFromString = data_structures.enumFromString;
|
||||
const MyAllocator = data_structures.MyAllocator;
|
||||
|
||||
const Compilation = @import("../Compilation.zig");
|
||||
const File = Compilation.File;
|
||||
@ -27,11 +25,6 @@ pub const Result = struct {
|
||||
count: u32,
|
||||
line_offset: u32,
|
||||
line_count: u32,
|
||||
// ids: ArrayList(Token.Id) = .{},
|
||||
// token_lines: ArrayList(u32) = .{},
|
||||
// file_line_offsets: ArrayList(u32) = .{},
|
||||
// token_offsets: ArrayList(u32) = .{},
|
||||
// token_lengths: ArrayList(u32) = .{},
|
||||
time: u64 = 0,
|
||||
};
|
||||
|
||||
@ -49,7 +42,7 @@ pub const Logger = enum {
|
||||
});
|
||||
};
|
||||
|
||||
pub fn analyze(allocator: Allocator, text: []const u8, token_buffer: *Token.Buffer) !Result {
|
||||
pub fn analyze(allocator: *MyAllocator, text: []const u8, token_buffer: *Token.Buffer) !Result {
|
||||
assert(text.len <= std.math.maxInt(u32));
|
||||
const len: u32 = @intCast(text.len);
|
||||
|
||||
@ -73,9 +66,9 @@ pub fn analyze(allocator: Allocator, text: []const u8, token_buffer: *Token.Buff
|
||||
var index: u32 = 0;
|
||||
var line_index: u32 = lexer.line_offset;
|
||||
|
||||
try token_buffer.tokens.ensureUnusedCapacity(allocator, text.len / 4);
|
||||
try token_buffer.ensure_with_capacity(allocator, len / 4);
|
||||
|
||||
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 });
|
||||
|
||||
while (index < len) {
|
||||
const start_index = index;
|
||||
@ -116,7 +109,7 @@ pub fn analyze(allocator: Allocator, text: []const u8, token_buffer: *Token.Buff
|
||||
const string = text[start_index..][0 .. index - start_index];
|
||||
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)),
|
||||
} else if (equal(u8, string, "_")) .discard else .identifier;
|
||||
} else if (data_structures.byte_equal( string, "_")) .discard else .identifier;
|
||||
},
|
||||
'0'...'9' => blk: {
|
||||
// Detect other non-decimal literals
|
||||
@ -404,25 +397,26 @@ pub fn analyze(allocator: Allocator, text: []const u8, token_buffer: *Token.Buff
|
||||
break :blk .operator_dollar;
|
||||
},
|
||||
else => |ch| {
|
||||
std.debug.panic("NI: '{c}'", .{ch});
|
||||
const ch_arr = [1]u8{ch};
|
||||
@panic(&ch_arr);
|
||||
},
|
||||
};
|
||||
|
||||
const end_index = index;
|
||||
const token_length = end_index - start_index;
|
||||
|
||||
token_buffer.tokens.appendAssumeCapacity(.{
|
||||
token_buffer.append_with_capacity(.{
|
||||
.id = token_id,
|
||||
.offset = start_index,
|
||||
.length = token_length,
|
||||
.line = line_index,
|
||||
});
|
||||
const line_offset = token_buffer.line_offsets.items[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) });
|
||||
// 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 });
|
||||
// logln(.lexer, .end, "END LEXER - TOKEN OFFSET: {} - LINE OFFSET: {}", .{ Token.unwrap(lexer.offset), lexer.line_offset });
|
||||
|
||||
lexer.count = Token.sub(token_buffer.getOffset(), lexer.offset);
|
||||
lexer.line_count = token_buffer.getLineOffset() - lexer.line_offset;
|
||||
|
||||
@ -1,19 +1,16 @@
|
||||
const std = @import("std");
|
||||
const Allocator = std.mem.Allocator;
|
||||
const assert = std.debug.assert;
|
||||
const equal = std.mem.eql;
|
||||
const panic = std.debug.panic;
|
||||
|
||||
const data_structures = @import("../data_structures.zig");
|
||||
const ArrayList = data_structures.ArrayList;
|
||||
const data_structures = @import("../library.zig");
|
||||
const UnpinnedArray = data_structures.UnpinnedArray;
|
||||
const BlockList = data_structures.BlockList;
|
||||
const enumFromString = data_structures.enumFromString;
|
||||
const HashMap = data_structures.HashMap;
|
||||
|
||||
const lexer = @import("lexer.zig");
|
||||
|
||||
const Compilation = @import("../Compilation.zig");
|
||||
const log = Compilation.log;
|
||||
// const log = Compilation.log;
|
||||
const logln = Compilation.logln;
|
||||
const Token = Compilation.Token;
|
||||
|
||||
@ -204,9 +201,10 @@ const Analyzer = struct {
|
||||
token_i: Token.Index,
|
||||
token_buffer: *Token.Buffer,
|
||||
nodes: *Node.List,
|
||||
node_lists: *ArrayList(ArrayList(Node.Index)),
|
||||
node_lists: *UnpinnedArray(UnpinnedArray(Node.Index)),
|
||||
source_file: []const u8,
|
||||
allocator: Allocator,
|
||||
my_allocator: *data_structures.MyAllocator,
|
||||
suffix_depth: usize = 0,
|
||||
|
||||
fn expectToken(analyzer: *Analyzer, expected_token_id: Token.Id) !Token.Index {
|
||||
@ -218,9 +216,9 @@ const Analyzer = struct {
|
||||
const result = token_i;
|
||||
return result;
|
||||
} else {
|
||||
const file_offset = analyzer.getTokenOffset(token_i);
|
||||
const file_chunk = analyzer.source_file[file_offset..];
|
||||
std.debug.print("Unexpected token {s} when expected {s}\n| |\n v \n```\n{s}\n```", .{ @tagName(token_id), @tagName(expected_token_id), file_chunk });
|
||||
// const file_offset = analyzer.getTokenOffset(token_i);
|
||||
// const file_chunk = analyzer.source_file[file_offset..];
|
||||
// std.debug.print("Unexpected token {s} when expected {s}\n| |\n v \n```\n{s}\n```", .{ @tagName(token_id), @tagName(expected_token_id), file_chunk });
|
||||
@breakpoint();
|
||||
return error.unexpected_token;
|
||||
}
|
||||
@ -228,13 +226,16 @@ const Analyzer = struct {
|
||||
|
||||
fn getTokenOffset(analyzer: *Analyzer, token_index: Token.Index) u32 {
|
||||
const index = Token.unwrap(token_index);
|
||||
const offset = analyzer.token_buffer.tokens.items(.offset)[index];
|
||||
assert(index < analyzer.token_buffer.length);
|
||||
const offset = analyzer.token_buffer.offsets[index];
|
||||
return offset;
|
||||
}
|
||||
|
||||
fn peekTokenAhead(analyzer: *Analyzer, ahead_offset: u32) Token.Id {
|
||||
const token_index = Token.addInt(analyzer.token_i, ahead_offset);
|
||||
const token = analyzer.token_buffer.tokens.items(.id)[Token.unwrap(token_index)];
|
||||
const index =Token.unwrap(token_index);
|
||||
assert(index < analyzer.token_buffer.length);
|
||||
const token = analyzer.token_buffer.ids[index];
|
||||
return token;
|
||||
}
|
||||
|
||||
@ -258,24 +259,27 @@ const Analyzer = struct {
|
||||
|
||||
fn consumeTokens(analyzer: *Analyzer, token_count: u32) void {
|
||||
assert(Token.unwrap(Token.addInt(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| {
|
||||
const i: u32 = @intCast(i_usize);
|
||||
const token_id = analyzer.peekTokenAhead(i);
|
||||
_ = token_id; // autofix
|
||||
const token_index = Token.addInt(analyzer.token_i, i);
|
||||
const token_bytes = analyzer.bytes(token_index);
|
||||
log(.parser, .consume_token, "{s}, '{s}'", .{ @tagName(token_id), token_bytes });
|
||||
_ = token_bytes; // autofix
|
||||
// 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);
|
||||
}
|
||||
|
||||
fn bytes(analyzer: *const Analyzer, token_index: Token.Index) []const u8 {
|
||||
const index = Token.unwrap(token_index);
|
||||
const offset = analyzer.token_buffer.tokens.items(.offset)[index];
|
||||
const len = analyzer.token_buffer.tokens.items(.length)[index];
|
||||
assert(index < analyzer.token_buffer.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;
|
||||
}
|
||||
@ -290,9 +294,10 @@ const Analyzer = struct {
|
||||
analyzer.consumeToken();
|
||||
const declaration_name_token = try analyzer.expectToken(.identifier);
|
||||
const declaration_name = analyzer.bytes(declaration_name_token);
|
||||
logln(.parser, .symbol_declaration, "Starting parsing declaration \"{s}\"", .{declaration_name});
|
||||
_ = declaration_name; // autofix
|
||||
// logln(.parser, .symbol_declaration, "Starting parsing declaration \"{s}\"", .{declaration_name});
|
||||
|
||||
logln(.parser, .symbol_declaration, "Current token: {}", .{analyzer.peekToken()});
|
||||
// logln(.parser, .symbol_declaration, "Current token: {}", .{analyzer.peekToken()});
|
||||
|
||||
const metadata_node_index = switch (analyzer.peekToken()) {
|
||||
.operator_colon => blk: {
|
||||
@ -301,13 +306,13 @@ const Analyzer = struct {
|
||||
const attribute_node_index: Node.Index = if (analyzer.peekToken() == .operator_colon) b: {
|
||||
analyzer.consumeToken();
|
||||
|
||||
var list = ArrayList(Node.Index){};
|
||||
var list = UnpinnedArray(Node.Index){};
|
||||
while (analyzer.peekToken() != .operator_assign) {
|
||||
const identifier = try analyzer.expectToken(.identifier);
|
||||
const identifier_name = analyzer.bytes(identifier);
|
||||
|
||||
const attribute_node = inline for (@typeInfo(Compilation.Debug.Declaration.Global.Attribute).Enum.fields) |enum_field| {
|
||||
if (equal(u8, identifier_name, enum_field.name)) {
|
||||
if (data_structures.byte_equal(identifier_name, enum_field.name)) {
|
||||
const attribute = @field(Compilation.Debug.Declaration.Global.Attribute, enum_field.name);
|
||||
const attribute_node = switch (attribute) {
|
||||
.@"export",
|
||||
@ -321,8 +326,8 @@ const Analyzer = struct {
|
||||
};
|
||||
break attribute_node;
|
||||
}
|
||||
} else panic("Unknown symbol attribute: {s}", .{identifier_name});
|
||||
try list.append(analyzer.allocator, attribute_node);
|
||||
} else @panic(identifier_name);
|
||||
try list.append(analyzer.my_allocator, attribute_node);
|
||||
|
||||
switch (analyzer.peekToken()) {
|
||||
.operator_assign => {},
|
||||
@ -362,7 +367,7 @@ const Analyzer = struct {
|
||||
.right = init_node_index,
|
||||
};
|
||||
|
||||
logln(.parser, .symbol_declaration, "Adding declaration \"{s}\" with init node of type: {s}", .{ declaration_name, @tagName(init_node.id) });
|
||||
// logln(.parser, .symbol_declaration, "Adding declaration \"{s}\" with init node of type: {s}", .{ declaration_name, @tagName(init_node.id) });
|
||||
|
||||
return try analyzer.addNode(declaration);
|
||||
}
|
||||
@ -388,14 +393,14 @@ const Analyzer = struct {
|
||||
|
||||
fn functionPrototype(analyzer: *Analyzer) !Node.Index {
|
||||
const token = analyzer.token_i;
|
||||
var attribute_and_return_type_node_list = ArrayList(Node.Index){};
|
||||
var attribute_and_return_type_node_list = UnpinnedArray(Node.Index){};
|
||||
|
||||
while (analyzer.peekToken() != .operator_left_parenthesis) {
|
||||
const identifier = try analyzer.expectToken(.identifier);
|
||||
const identifier_name = analyzer.bytes(identifier);
|
||||
|
||||
const attribute_node = inline for (@typeInfo(Compilation.Function.Attribute).Enum.fields) |enum_field| {
|
||||
if (equal(u8, identifier_name, enum_field.name)) {
|
||||
if (data_structures.byte_equal(identifier_name, enum_field.name)) {
|
||||
const attribute = @field(Compilation.Function.Attribute, enum_field.name);
|
||||
const attribute_node = switch (attribute) {
|
||||
.naked,
|
||||
@ -409,9 +414,9 @@ const Analyzer = struct {
|
||||
};
|
||||
break attribute_node;
|
||||
}
|
||||
} else panic("Unknown function attribute: {s}", .{identifier_name});
|
||||
} else @panic(identifier_name);
|
||||
|
||||
try attribute_and_return_type_node_list.append(analyzer.allocator, attribute_node);
|
||||
try attribute_and_return_type_node_list.append(analyzer.my_allocator, attribute_node);
|
||||
|
||||
if (analyzer.peekToken() == .operator_comma) analyzer.consumeToken();
|
||||
}
|
||||
@ -420,7 +425,7 @@ const Analyzer = struct {
|
||||
|
||||
const arguments = try analyzer.argumentList(.operator_left_parenthesis, .operator_right_parenthesis);
|
||||
const return_type = try analyzer.typeExpression();
|
||||
try attribute_and_return_type_node_list.append(analyzer.allocator, return_type);
|
||||
try attribute_and_return_type_node_list.append(analyzer.my_allocator, return_type);
|
||||
|
||||
const function_prototype = try analyzer.addNode(.{
|
||||
.id = .function_prototype,
|
||||
@ -437,7 +442,7 @@ const Analyzer = struct {
|
||||
_ = try analyzer.expectToken(start_token);
|
||||
}
|
||||
|
||||
var list = ArrayList(Node.Index){};
|
||||
var list = UnpinnedArray(Node.Index){};
|
||||
|
||||
while (analyzer.peekToken() != end_token) {
|
||||
const identifier = try analyzer.expectToken(.identifier);
|
||||
@ -448,7 +453,7 @@ const Analyzer = struct {
|
||||
analyzer.consumeToken();
|
||||
}
|
||||
|
||||
try list.append(analyzer.allocator, try analyzer.addNode(.{
|
||||
try list.append(analyzer.my_allocator, try analyzer.addNode(.{
|
||||
.id = .argument_declaration,
|
||||
.token = identifier,
|
||||
.left = type_expression,
|
||||
@ -458,7 +463,7 @@ const Analyzer = struct {
|
||||
|
||||
_ = try analyzer.expectToken(end_token);
|
||||
|
||||
if (list.items.len != 0) {
|
||||
if (list.length != 0) {
|
||||
return try analyzer.nodeList(list);
|
||||
} else {
|
||||
return Node.Index.null;
|
||||
@ -473,11 +478,11 @@ const Analyzer = struct {
|
||||
|
||||
fn block(analyzer: *Analyzer) anyerror!Node.Index {
|
||||
const left_brace = try analyzer.expectToken(.operator_left_brace);
|
||||
var list = ArrayList(Node.Index){};
|
||||
var list = UnpinnedArray(Node.Index){};
|
||||
|
||||
while (analyzer.peekToken() != .operator_right_brace) {
|
||||
const first_statement_token = analyzer.peekToken();
|
||||
logln(.parser, .block, "First statement token: {s}", .{@tagName(first_statement_token)});
|
||||
// logln(.parser, .block, "First statement token: {s}", .{@tagName(first_statement_token)});
|
||||
const statement_index = switch (first_statement_token) {
|
||||
else => try analyzer.assignExpressionStatement(),
|
||||
// .identifier => switch (analyzer.peekTokenAhead(1)) {
|
||||
@ -506,10 +511,10 @@ const Analyzer = struct {
|
||||
// else => |t| @panic(@tagName(t)),
|
||||
};
|
||||
|
||||
const node = analyzer.nodes.get(statement_index);
|
||||
logln(.parser, .block, "Adding statement: {s}", .{@tagName(node.id)});
|
||||
// const node = analyzer.nodes.get(statement_index);
|
||||
// logln(.parser, .block, "Adding statement: {s}", .{@tagName(node.id)});
|
||||
|
||||
try list.append(analyzer.allocator, statement_index);
|
||||
try list.append(analyzer.my_allocator, statement_index);
|
||||
}
|
||||
|
||||
_ = try analyzer.expectToken(.operator_right_brace);
|
||||
@ -541,30 +546,30 @@ const Analyzer = struct {
|
||||
}
|
||||
|
||||
fn switchExpression(analyzer: *Analyzer) anyerror!Node.Index {
|
||||
logln(.parser, .@"switch", "Parsing switch...", .{});
|
||||
// logln(.parser, .@"switch", "Parsing switch...", .{});
|
||||
const switch_token = analyzer.token_i;
|
||||
analyzer.consumeToken();
|
||||
_ = try analyzer.expectToken(.operator_left_parenthesis);
|
||||
const switch_expression = try analyzer.expression();
|
||||
_ = try analyzer.expectToken(.operator_right_parenthesis);
|
||||
logln(.parser, .@"switch", "Parsed switch expression...", .{});
|
||||
// logln(.parser, .@"switch", "Parsed switch expression...", .{});
|
||||
_ = try analyzer.expectToken(.operator_left_brace);
|
||||
|
||||
var list = ArrayList(Node.Index){};
|
||||
var list = UnpinnedArray(Node.Index){};
|
||||
|
||||
while (analyzer.peekToken() != .operator_right_brace) {
|
||||
const case_token = analyzer.token_i;
|
||||
logln(.parser, .@"switch", "Parsing switch case...", .{});
|
||||
// logln(.parser, .@"switch", "Parsing switch case...", .{});
|
||||
const case_node = switch (analyzer.peekToken()) {
|
||||
.fixed_keyword_else => blk: {
|
||||
analyzer.consumeToken();
|
||||
break :blk Node.Index.null;
|
||||
},
|
||||
else => blk: {
|
||||
var array_list = ArrayList(Node.Index){};
|
||||
var array_list = UnpinnedArray(Node.Index){};
|
||||
while (true) {
|
||||
const switch_case_node = try analyzer.expression();
|
||||
try array_list.append(analyzer.allocator, switch_case_node);
|
||||
try array_list.append(analyzer.my_allocator, switch_case_node);
|
||||
switch (analyzer.peekToken()) {
|
||||
.operator_comma => analyzer.consumeToken(),
|
||||
.operator_switch_case => break,
|
||||
@ -572,9 +577,9 @@ const Analyzer = struct {
|
||||
}
|
||||
}
|
||||
|
||||
break :blk switch (array_list.items.len) {
|
||||
break :blk switch (array_list.length) {
|
||||
0 => unreachable,
|
||||
1 => array_list.items[0],
|
||||
1 => array_list.pointer[0],
|
||||
else => try analyzer.nodeList(array_list),
|
||||
};
|
||||
},
|
||||
@ -596,7 +601,7 @@ const Analyzer = struct {
|
||||
.right = expr,
|
||||
});
|
||||
|
||||
try list.append(analyzer.allocator, node);
|
||||
try list.append(analyzer.my_allocator, node);
|
||||
}
|
||||
|
||||
_ = try analyzer.expectToken(.operator_right_brace);
|
||||
@ -670,7 +675,7 @@ const Analyzer = struct {
|
||||
const token = try analyzer.expectToken(.fixed_keyword_for);
|
||||
_ = try analyzer.expectToken(.operator_left_parenthesis);
|
||||
|
||||
var for_expression_list = ArrayList(Node.Index){};
|
||||
var for_expression_list = UnpinnedArray(Node.Index){};
|
||||
|
||||
while (analyzer.peekToken() != .operator_right_parenthesis) {
|
||||
const expression_token = analyzer.token_i;
|
||||
@ -699,7 +704,7 @@ const Analyzer = struct {
|
||||
else => |t| @panic(@tagName(t)),
|
||||
};
|
||||
|
||||
try for_expression_list.append(analyzer.allocator, node_index);
|
||||
try for_expression_list.append(analyzer.my_allocator, node_index);
|
||||
|
||||
switch (analyzer.peekToken()) {
|
||||
.operator_comma => analyzer.consumeToken(),
|
||||
@ -712,7 +717,7 @@ const Analyzer = struct {
|
||||
|
||||
_ = try analyzer.expectToken(.operator_bar);
|
||||
|
||||
var payload_nodes = ArrayList(Node.Index){};
|
||||
var payload_nodes = UnpinnedArray(Node.Index){};
|
||||
|
||||
while (analyzer.peekToken() != .operator_bar) {
|
||||
const payload_token = analyzer.token_i;
|
||||
@ -730,7 +735,7 @@ const Analyzer = struct {
|
||||
else => |t| @panic(@tagName(t)),
|
||||
}
|
||||
|
||||
try payload_nodes.append(analyzer.allocator, try analyzer.addNode(.{
|
||||
try payload_nodes.append(analyzer.my_allocator, try analyzer.addNode(.{
|
||||
.id = id,
|
||||
.token = payload_token,
|
||||
.left = Node.Index.null,
|
||||
@ -740,7 +745,7 @@ const Analyzer = struct {
|
||||
|
||||
_ = try analyzer.expectToken(.operator_bar);
|
||||
|
||||
if (payload_nodes.items.len != for_expression_list.items.len) {
|
||||
if (payload_nodes.length != for_expression_list.length) {
|
||||
unreachable;
|
||||
}
|
||||
|
||||
@ -804,7 +809,7 @@ const Analyzer = struct {
|
||||
.right = right,
|
||||
};
|
||||
|
||||
logln(.parser, .assign, "assign:\nleft: {}.\nright: {}", .{ node.left, node.right });
|
||||
// logln(.parser, .assign, "assign:\nleft: {}.\nright: {}", .{ node.left, node.right });
|
||||
return try analyzer.addNode(node);
|
||||
// .operator_equal => .operator_assign,
|
||||
// .operator_add => switch (analyzer.peekTokenAhead(1)) {
|
||||
@ -872,19 +877,19 @@ const Analyzer = struct {
|
||||
const intrinsic_name = analyzer.bytes(intrinsic_token)[1..];
|
||||
|
||||
const intrinsic_id = inline for (@typeInfo(Compilation.IntrinsicId).Enum.fields) |enum_field| {
|
||||
if (equal(u8, enum_field.name, intrinsic_name)) {
|
||||
if (data_structures.byte_equal(enum_field.name, intrinsic_name)) {
|
||||
break @field(Compilation.IntrinsicId, enum_field.name);
|
||||
}
|
||||
} else @panic(intrinsic_name);
|
||||
|
||||
var list = ArrayList(Node.Index){};
|
||||
var list = UnpinnedArray(Node.Index){};
|
||||
|
||||
if (intrinsic_id == .@"asm") {
|
||||
_ = try analyzer.expectToken(.operator_left_brace);
|
||||
|
||||
while (analyzer.peekToken() != .operator_right_brace) {
|
||||
const instruction_token = try analyzer.expectToken(.identifier);
|
||||
var operand_list = ArrayList(Node.Index){};
|
||||
var operand_list = UnpinnedArray(Node.Index){};
|
||||
|
||||
while (analyzer.peekToken() != .operator_semicolon) {
|
||||
const asm_operand = try analyzer.parseAsmOperand();
|
||||
@ -893,12 +898,12 @@ const Analyzer = struct {
|
||||
.operator_comma => analyzer.consumeToken(),
|
||||
else => |t| @panic(@tagName(t)),
|
||||
}
|
||||
try operand_list.append(analyzer.allocator, asm_operand);
|
||||
try operand_list.append(analyzer.my_allocator, asm_operand);
|
||||
}
|
||||
|
||||
_ = try analyzer.expectToken(.operator_semicolon);
|
||||
|
||||
try list.append(analyzer.allocator, try analyzer.addNode(.{
|
||||
try list.append(analyzer.my_allocator, try analyzer.addNode(.{
|
||||
.id = .assembly_statement,
|
||||
.token = instruction_token,
|
||||
.left = try analyzer.nodeList(operand_list),
|
||||
@ -911,7 +916,7 @@ const Analyzer = struct {
|
||||
} else {
|
||||
while (analyzer.peekToken() != .operator_right_parenthesis) {
|
||||
const parameter = try analyzer.expression();
|
||||
try list.append(analyzer.allocator, parameter);
|
||||
try list.append(analyzer.my_allocator, parameter);
|
||||
|
||||
switch (analyzer.peekToken()) {
|
||||
.operator_comma => analyzer.consumeToken(),
|
||||
@ -1019,10 +1024,10 @@ const Analyzer = struct {
|
||||
fn expressionPrecedence(analyzer: *Analyzer, minimum_precedence: i32) !Node.Index {
|
||||
assert(minimum_precedence >= 0);
|
||||
var result = try analyzer.prefixExpression();
|
||||
if (result != .null) {
|
||||
const prefix_node = analyzer.nodes.get(result);
|
||||
logln(.parser, .precedence, "Prefix: {s}", .{@tagName(prefix_node.id)});
|
||||
}
|
||||
// if (result != .null) {
|
||||
// const prefix_node = analyzer.nodes.get(result);
|
||||
// logln(.parser, .precedence, "Prefix: {s}", .{@tagName(prefix_node.id)});
|
||||
// }
|
||||
|
||||
var banned_precedence: i32 = -1;
|
||||
|
||||
@ -1072,16 +1077,16 @@ const Analyzer = struct {
|
||||
else => |t| @panic(@tagName(t)),
|
||||
};
|
||||
|
||||
logln(.parser, .precedence, "Precedence operator: {s}", .{@tagName(operator)});
|
||||
// logln(.parser, .precedence, "Precedence operator: {s}", .{@tagName(operator)});
|
||||
|
||||
const precedence = operator_precedence.get(operator);
|
||||
if (precedence < minimum_precedence) {
|
||||
logln(.parser, .precedence, "Breaking for minimum_precedence", .{});
|
||||
// logln(.parser, .precedence, "Breaking for minimum_precedence", .{});
|
||||
break;
|
||||
}
|
||||
|
||||
if (precedence < banned_precedence) {
|
||||
logln(.parser, .precedence, "Breaking for banned_precedence", .{});
|
||||
// logln(.parser, .precedence, "Breaking for banned_precedence", .{});
|
||||
break;
|
||||
}
|
||||
|
||||
@ -1089,7 +1094,7 @@ const Analyzer = struct {
|
||||
analyzer.consumeToken();
|
||||
|
||||
// TODO: fix this
|
||||
logln(.parser, .precedence, "Going for right in expressionPrecedence with operator {s}", .{@tagName(operator)});
|
||||
// logln(.parser, .precedence, "Going for right in expressionPrecedence with operator {s}", .{@tagName(operator)});
|
||||
const right = try analyzer.expressionPrecedence(precedence + 1);
|
||||
|
||||
const node_id = operator_node_id.get(operator);
|
||||
@ -1182,7 +1187,8 @@ const Analyzer = struct {
|
||||
// todo:?
|
||||
.operator_left_brace => try analyzer.block(),
|
||||
.fixed_keyword_if => try analyzer.ifExpression(),
|
||||
else => |id| std.debug.panic("WARN: By default, calling curlySuffixExpression with {s}", .{@tagName(id)}),
|
||||
else => |id| @panic(@tagName(id)),
|
||||
//else => |id| std.debug.panic("WARN: By default, calling curlySuffixExpression with {s}", .{@tagName(id)}),
|
||||
};
|
||||
|
||||
return result;
|
||||
@ -1262,7 +1268,7 @@ const Analyzer = struct {
|
||||
fn pointerOrArrayTypeExpression(analyzer: *Analyzer, expected: PointerOrArrayTypeExpectedExpression) !Node.Index {
|
||||
const first = analyzer.token_i;
|
||||
|
||||
var list = ArrayList(Node.Index){};
|
||||
var list = UnpinnedArray(Node.Index){};
|
||||
|
||||
const expression_type: Node.Id = switch (expected) {
|
||||
.single_pointer_type => blk: {
|
||||
@ -1271,7 +1277,7 @@ const Analyzer = struct {
|
||||
break :blk .pointer_type;
|
||||
},
|
||||
.many_pointer_type => blk: {
|
||||
try list.append(analyzer.allocator, try analyzer.addNode(.{
|
||||
try list.append(analyzer.my_allocator, try analyzer.addNode(.{
|
||||
.id = .many_pointer_expression,
|
||||
.token = analyzer.token_i,
|
||||
.left = Node.Index.null,
|
||||
@ -1281,7 +1287,7 @@ const Analyzer = struct {
|
||||
_ = try analyzer.expectToken(.operator_ampersand);
|
||||
switch (analyzer.peekToken()) {
|
||||
.operator_right_bracket => {},
|
||||
.operator_colon => try list.append(analyzer.allocator, try analyzer.parseTermination()),
|
||||
.operator_colon => try list.append(analyzer.my_allocator, try analyzer.parseTermination()),
|
||||
else => |t| @panic(@tagName(t)),
|
||||
}
|
||||
_ = try analyzer.expectToken(.operator_right_bracket);
|
||||
@ -1296,17 +1302,17 @@ const Analyzer = struct {
|
||||
break :blk .slice_type;
|
||||
},
|
||||
.operator_colon => {
|
||||
try list.append(analyzer.allocator, try analyzer.parseTermination());
|
||||
try list.append(analyzer.my_allocator, try analyzer.parseTermination());
|
||||
_ = try analyzer.expectToken(.operator_right_bracket);
|
||||
break :blk .slice_type;
|
||||
},
|
||||
else => {
|
||||
const length_expression = try analyzer.expression();
|
||||
try list.append(analyzer.allocator, length_expression);
|
||||
try list.append(analyzer.my_allocator, length_expression);
|
||||
|
||||
switch (analyzer.peekToken()) {
|
||||
.operator_right_bracket => {},
|
||||
.operator_colon => try list.append(analyzer.allocator, try analyzer.parseTermination()),
|
||||
.operator_colon => try list.append(analyzer.my_allocator, try analyzer.parseTermination()),
|
||||
else => |t| @panic(@tagName(t)),
|
||||
}
|
||||
|
||||
@ -1331,15 +1337,15 @@ const Analyzer = struct {
|
||||
analyzer.consumeTokens(@intFromBool(analyzer.peekToken() == .fixed_keyword_const));
|
||||
|
||||
if (const_node != .null) {
|
||||
try list.append(analyzer.allocator, const_node);
|
||||
try list.append(analyzer.my_allocator, const_node);
|
||||
}
|
||||
} else {
|
||||
assert(list.items.len > 0);
|
||||
assert(list.length > 0);
|
||||
}
|
||||
|
||||
const type_expression = try analyzer.typeExpression();
|
||||
assert(type_expression != .null);
|
||||
try list.append(analyzer.allocator, type_expression);
|
||||
try list.append(analyzer.my_allocator, type_expression);
|
||||
|
||||
const node_list = try analyzer.nodeList(list);
|
||||
|
||||
@ -1350,15 +1356,15 @@ const Analyzer = struct {
|
||||
.right = Node.Index.null,
|
||||
};
|
||||
|
||||
logln(.parser, .pointer_like_type_expression, "ARRAY START\n===========", .{});
|
||||
for (list.items) |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=========", .{});
|
||||
// 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);
|
||||
logln(.parser, .pointer_like_type_expression, "Pointer end", .{});
|
||||
// logln(.parser, .pointer_like_type_expression, "Pointer end", .{});
|
||||
|
||||
switch (analyzer.peekToken()) {
|
||||
.operator_comma,
|
||||
@ -1449,8 +1455,8 @@ const Analyzer = struct {
|
||||
const left_parenthesis = analyzer.token_i;
|
||||
analyzer.consumeToken();
|
||||
|
||||
var expression_list = ArrayList(Node.Index){};
|
||||
logln(.parser, .suffix, "[DEPTH={}] Initializating suffix call-like expression", .{analyzer.suffix_depth});
|
||||
var expression_list = UnpinnedArray(Node.Index){};
|
||||
// logln(.parser, .suffix, "[DEPTH={}] Initializating suffix call-like expression", .{analyzer.suffix_depth});
|
||||
while (analyzer.peekToken() != .operator_right_parenthesis) {
|
||||
const current_token = analyzer.token_i;
|
||||
// logln(.parser, .suffix, "[DEPTH={}] First token: {s}", .{ analyzer.suffix_depth, @tagName(analyzer.tokens[current_token].id) });
|
||||
@ -1468,19 +1474,19 @@ const Analyzer = struct {
|
||||
});
|
||||
}
|
||||
|
||||
try expression_list.append(analyzer.allocator, parameter);
|
||||
try expression_list.append(analyzer.my_allocator, parameter);
|
||||
|
||||
switch (analyzer.peekToken()) {
|
||||
.operator_right_parenthesis => {},
|
||||
.operator_comma => analyzer.consumeToken(),
|
||||
.operator_colon, .operator_right_brace, .operator_right_bracket => unreachable,
|
||||
.operator_dot => panic("[DEPTH={}] Unexpected period", .{analyzer.suffix_depth}),
|
||||
.operator_dot => @panic("Unexpected period"), //panic("[DEPTH={}] Unexpected period", .{analyzer.suffix_depth}),
|
||||
else => |t| @panic(@tagName(t)),
|
||||
}
|
||||
}
|
||||
|
||||
logln(.parser, .suffix, "[DEPTH={}] Ending suffix call-like expression", .{analyzer.suffix_depth});
|
||||
logln(.parser, .suffix, "Callee node: {s}", .{@tagName(analyzer.nodes.get(result).id)});
|
||||
// logln(.parser, .suffix, "[DEPTH={}] Ending suffix call-like expression", .{analyzer.suffix_depth});
|
||||
// logln(.parser, .suffix, "Callee node: {s}", .{@tagName(analyzer.nodes.get(result).id)});
|
||||
|
||||
_ = try analyzer.expectToken(.operator_right_parenthesis);
|
||||
// const is_comma = analyzer.tokens[analyzer.token_i].id == .comma;
|
||||
@ -1502,7 +1508,7 @@ const Analyzer = struct {
|
||||
fn containerLiteral(analyzer: *Analyzer, type_node: Node.Index) anyerror!Node.Index {
|
||||
const token = try analyzer.expectToken(.operator_left_brace);
|
||||
|
||||
var list = ArrayList(Node.Index){};
|
||||
var list = UnpinnedArray(Node.Index){};
|
||||
|
||||
const InitializationType = enum {
|
||||
anonymous,
|
||||
@ -1531,7 +1537,7 @@ const Analyzer = struct {
|
||||
.right = Node.Index.null,
|
||||
});
|
||||
|
||||
try list.append(analyzer.allocator, field_initialization);
|
||||
try list.append(analyzer.my_allocator, field_initialization);
|
||||
_ = try analyzer.expectToken(.operator_comma);
|
||||
|
||||
break :blk .container_field_names;
|
||||
@ -1539,7 +1545,7 @@ const Analyzer = struct {
|
||||
else => |t| @panic(@tagName(t)),
|
||||
},
|
||||
else => blk: {
|
||||
try list.append(analyzer.allocator, try analyzer.anonymousExpression());
|
||||
try list.append(analyzer.my_allocator, try analyzer.anonymousExpression());
|
||||
_ = try analyzer.expectToken(.operator_comma);
|
||||
break :blk .anonymous;
|
||||
},
|
||||
@ -1556,7 +1562,7 @@ const Analyzer = struct {
|
||||
else => {},
|
||||
}
|
||||
|
||||
try list.append(analyzer.allocator, field_expression_initializer);
|
||||
try list.append(analyzer.my_allocator, field_expression_initializer);
|
||||
break :blk .anonymous;
|
||||
},
|
||||
else => |t| @panic(@tagName(t)),
|
||||
@ -1618,7 +1624,7 @@ const Analyzer = struct {
|
||||
|
||||
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;
|
||||
assert(Token.unwrap(analyzer.token_i) < analyzer.token_buffer.tokens.len);
|
||||
assert(Token.unwrap(analyzer.token_i) < analyzer.token_buffer.length);
|
||||
const token_id = maybe_token_id orelse .fixed_keyword_struct;
|
||||
const container_type: Compilation.ContainerType = switch (token_id) {
|
||||
.fixed_keyword_struct => .@"struct",
|
||||
@ -1640,11 +1646,11 @@ const Analyzer = struct {
|
||||
} else Node.Index.null;
|
||||
|
||||
if (maybe_token_id) |_| _ = try analyzer.expectToken(.operator_left_brace);
|
||||
var node_list = ArrayList(Node.Index){};
|
||||
var node_list = UnpinnedArray(Node.Index){};
|
||||
|
||||
while (analyzer.hasTokens() and analyzer.peekToken() != .operator_right_brace) {
|
||||
const first = analyzer.token_i;
|
||||
logln(.parser, .container_members, "First token for container member: {s}", .{@tagName(analyzer.peekToken())});
|
||||
// logln(.parser, .container_members, "First token for container member: {s}", .{@tagName(analyzer.peekToken())});
|
||||
|
||||
const member_node_index: Node.Index = switch (analyzer.peekToken()) {
|
||||
.fixed_keyword_comptime => switch (analyzer.peekTokenAhead(1)) {
|
||||
@ -1717,23 +1723,25 @@ const Analyzer = struct {
|
||||
};
|
||||
|
||||
const member_node = analyzer.nodes.get(member_node_index);
|
||||
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);
|
||||
|
||||
try node_list.append(analyzer.allocator, member_node_index);
|
||||
try node_list.append(analyzer.my_allocator, member_node_index);
|
||||
}
|
||||
|
||||
if (maybe_token_id) |_| _ = try analyzer.expectToken(.operator_right_brace);
|
||||
|
||||
for (node_list.items, 0..) |member_node_index, index| {
|
||||
const member_node = analyzer.nodes.get(member_node_index);
|
||||
if (member_node.id == .identifier) {
|
||||
const token_offset = analyzer.getTokenOffset(member_node.token);
|
||||
std.debug.print("Node index #{} (list index {}):\n```\n{s}\n```\n", .{ Node.unwrap(member_node_index), index, analyzer.source_file[token_offset..] });
|
||||
// std.debug.print("ID: {s}\n", .{analyzer.bytes(member_node.token)});
|
||||
unreachable;
|
||||
}
|
||||
}
|
||||
// for (node_list.slice(), 0..) |member_node_index, index| {
|
||||
// _ = index; // autofix
|
||||
// const member_node = analyzer.nodes.get(member_node_index);
|
||||
// if (member_node.id == .identifier) {
|
||||
// const token_offset = analyzer.getTokenOffset(member_node.token);
|
||||
// _ = token_offset; // autofix
|
||||
// // std.debug.print("Node index #{} (list index {}):\n```\n{s}\n```\n", .{ Node.unwrap(member_node_index), index, analyzer.source_file[token_offset..] });
|
||||
// // std.debug.print("ID: {s}\n", .{analyzer.bytes(member_node.token)});
|
||||
// unreachable;
|
||||
// }
|
||||
// }
|
||||
|
||||
return try analyzer.addNode(.{
|
||||
.id = node_id,
|
||||
@ -1893,11 +1901,11 @@ const Analyzer = struct {
|
||||
analyzer.consumeToken();
|
||||
if (analyzer.peekToken() == .operator_left_brace) {
|
||||
analyzer.consumeToken();
|
||||
var list = ArrayList(Node.Index){};
|
||||
var list = UnpinnedArray(Node.Index){};
|
||||
|
||||
while (analyzer.peekToken() != .operator_right_brace) {
|
||||
const identifier = try analyzer.identifierNode();
|
||||
try list.append(analyzer.allocator, identifier);
|
||||
try list.append(analyzer.my_allocator, identifier);
|
||||
const comma = try analyzer.expectToken(.operator_comma);
|
||||
_ = comma; // autofix
|
||||
}
|
||||
@ -1917,7 +1925,7 @@ const Analyzer = struct {
|
||||
}
|
||||
},
|
||||
else => |t| switch (t) {
|
||||
.identifier => std.debug.panic("{s}: {s}", .{ @tagName(t), analyzer.bytes(token_i) }),
|
||||
.identifier => @panic(analyzer.bytes(token_i)),
|
||||
else => @panic(@tagName(t)),
|
||||
},
|
||||
};
|
||||
@ -2039,7 +2047,7 @@ const Analyzer = struct {
|
||||
}
|
||||
|
||||
fn addNode(analyzer: *Analyzer, node: Node) !Node.Index {
|
||||
const node_index = try analyzer.nodes.append(analyzer.allocator, node);
|
||||
const node_index = try analyzer.nodes.append(analyzer.my_allocator, node);
|
||||
// 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,
|
||||
// else => Node.unwrap(node.left),
|
||||
@ -2062,9 +2070,9 @@ const Analyzer = struct {
|
||||
return node_index;
|
||||
}
|
||||
|
||||
fn nodeList(analyzer: *Analyzer, node_list: ArrayList(Node.Index)) !Node.Index {
|
||||
const index = analyzer.node_lists.items.len;
|
||||
try analyzer.node_lists.append(analyzer.allocator, node_list);
|
||||
fn nodeList(analyzer: *Analyzer, node_list: UnpinnedArray(Node.Index)) !Node.Index {
|
||||
const index = analyzer.node_lists.length;
|
||||
try analyzer.node_lists.append(analyzer.my_allocator, node_list);
|
||||
return try analyzer.addNode(.{
|
||||
.id = .node_list,
|
||||
.token = Token.wrap(0),
|
||||
@ -2087,7 +2095,7 @@ const Analyzer = struct {
|
||||
};
|
||||
|
||||
// Here it is assumed that left brace is consumed
|
||||
pub fn analyze(allocator: Allocator, lexer_result: lexer.Result, source_file: []const u8, token_buffer: *Token.Buffer, node_list: *Node.List, node_lists: *ArrayList(ArrayList(Node.Index))) !Result {
|
||||
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 {
|
||||
const start = std.time.Instant.now() catch unreachable;
|
||||
var analyzer = Analyzer{
|
||||
.lexer = lexer_result,
|
||||
@ -2096,6 +2104,7 @@ pub fn analyze(allocator: Allocator, lexer_result: lexer.Result, source_file: []
|
||||
// .file_index = file_index,
|
||||
.token_i = lexer_result.offset,
|
||||
.allocator = allocator,
|
||||
.my_allocator = my_allocator,
|
||||
.nodes = node_list,
|
||||
.node_lists = node_lists,
|
||||
};
|
||||
|
||||
720
bootstrap/library.zig
Normal file
720
bootstrap/library.zig
Normal file
@ -0,0 +1,720 @@
|
||||
const std = @import("std");
|
||||
const builtin = @import("builtin");
|
||||
const os = builtin.os.tag;
|
||||
const arch = builtin.cpu.arch;
|
||||
|
||||
pub fn assert(ok: bool) void {
|
||||
if (!ok) unreachable;
|
||||
}
|
||||
|
||||
pub const Allocator = std.mem.Allocator;
|
||||
pub const BoundedArray = std.BoundedArray;
|
||||
|
||||
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();
|
||||
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 {
|
||||
assert(@typeInfo(E) == .Enum);
|
||||
_ = T;
|
||||
const MAX = std.math.maxInt(IndexType);
|
||||
|
||||
const EnumField = std.builtin.Type.EnumField;
|
||||
comptime var fields: []const EnumField = &.{};
|
||||
// comptime var enum_value: comptime_int = 0;
|
||||
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{.{
|
||||
.name = "null",
|
||||
.value = MAX,
|
||||
}};
|
||||
|
||||
const Result = @Type(.{
|
||||
.Enum = .{
|
||||
.tag_type = IndexType,
|
||||
.fields = fields,
|
||||
.decls = &.{},
|
||||
.is_exhaustive = false,
|
||||
},
|
||||
});
|
||||
|
||||
return struct {
|
||||
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 {
|
||||
const fnv_offset = 14695981039346656037;
|
||||
const fnv_prime = 1099511628211;
|
||||
var result: u64 = fnv_offset;
|
||||
|
||||
for (bytes) |byte| {
|
||||
result ^= byte;
|
||||
result *%= fnv_prime;
|
||||
}
|
||||
|
||||
return @truncate(result);
|
||||
}
|
||||
|
||||
fn CopyPtrAttrs(
|
||||
comptime source: type,
|
||||
comptime size: std.builtin.Type.Pointer.Size,
|
||||
comptime child: type,
|
||||
) type {
|
||||
const info = @typeInfo(source).Pointer;
|
||||
return @Type(.{
|
||||
.Pointer = .{
|
||||
.size = size,
|
||||
.is_const = info.is_const,
|
||||
.is_volatile = info.is_volatile,
|
||||
.is_allowzero = info.is_allowzero,
|
||||
.alignment = info.alignment,
|
||||
.address_space = info.address_space,
|
||||
.child = child,
|
||||
.sentinel = null,
|
||||
},
|
||||
});
|
||||
}
|
||||
|
||||
fn AsBytesReturnType(comptime P: type) type {
|
||||
const size = @sizeOf(std.meta.Child(P));
|
||||
return CopyPtrAttrs(P, .One, [size]u8);
|
||||
}
|
||||
|
||||
/// Given a pointer to a single item, returns a slice of the underlying bytes, preserving pointer attributes.
|
||||
pub fn asBytes(ptr: anytype) AsBytesReturnType(@TypeOf(ptr)) {
|
||||
return @ptrCast(@alignCast(ptr));
|
||||
}
|
||||
|
||||
pub fn byte_equal(a: []const u8, b: []const u8) bool {
|
||||
if (a.len != b.len) return false;
|
||||
|
||||
if (a.len != b.len) return false;
|
||||
if (a.len == 0 or a.ptr == b.ptr) return true;
|
||||
|
||||
for (a, b) |byte_a, byte_b| {
|
||||
if (byte_a != byte_b) return false;
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
const MapResult = struct{
|
||||
key_pointer: *anyopaque,
|
||||
value_pointer: *anyopaque,
|
||||
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 {
|
||||
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 {
|
||||
key_pointer: [*]K = undefined,
|
||||
value_pointer: [*]V = undefined,
|
||||
length: IndexType = 0,
|
||||
capacity: IndexType = 0,
|
||||
|
||||
pub fn get_pointer(map: *@This(), key: K) ?*V {
|
||||
for (map.keys(), 0..) |k, i| {
|
||||
const is_equal = switch (@typeInfo(K)) {
|
||||
.Pointer => |pointer| switch (pointer.size) {
|
||||
.Slice => byte_equal(k, key),
|
||||
else => k == key,
|
||||
},
|
||||
.Struct => equal(k, key),
|
||||
else => k == key,
|
||||
};
|
||||
|
||||
if (is_equal) {
|
||||
return &map.value_pointer[i];
|
||||
}
|
||||
}
|
||||
|
||||
return null;
|
||||
}
|
||||
|
||||
pub fn get(map: *@This(), key: K) ?V {
|
||||
if (map.get_pointer(key)) |p| {
|
||||
return p.*;
|
||||
} else {
|
||||
return null;
|
||||
}
|
||||
}
|
||||
|
||||
pub fn put(map: *@This(), allocator: *MyAllocator, key: K, value: V) !void {
|
||||
if (map.get_pointer(key)) |value_ptr| {
|
||||
value_ptr.* = value;
|
||||
} else {
|
||||
const len = map.length;
|
||||
try map.ensure_capacity(allocator, len + 1);
|
||||
map.put_at_with_capacity(len, key, value);
|
||||
}
|
||||
}
|
||||
|
||||
pub fn put_no_clobber(map: *@This(), allocator: *MyAllocator, key: K, value: V) !void {
|
||||
assert(map.get_pointer(key) == null);
|
||||
const len = map.length;
|
||||
try map.ensure_capacity(allocator, len + 1);
|
||||
map.put_at_with_capacity(len, key, value);
|
||||
}
|
||||
|
||||
fn put_at_with_capacity(map: *@This(), index: IndexType, key: K, value: V) void {
|
||||
map.length += 1;
|
||||
assert(index < map.length);
|
||||
map.key_pointer[index] = key;
|
||||
map.value_pointer[index] = value;
|
||||
}
|
||||
|
||||
pub fn ensure_capacity(map: *@This(), allocator: *MyAllocator, desired_capacity: IndexType) !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));
|
||||
map.capacity = result.capacity;
|
||||
map.key_pointer = @ptrCast(@alignCast(result.key_pointer));
|
||||
map.value_pointer = @ptrCast(@alignCast(result.value_pointer));
|
||||
}
|
||||
|
||||
pub fn keys(map: *@This()) []K{
|
||||
return map.key_pointer[0..map.length];
|
||||
}
|
||||
|
||||
pub fn values(map: *@This()) []V{
|
||||
return map.value_pointer[0..map.length];
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
pub const ListType = enum {
|
||||
index,
|
||||
pointer,
|
||||
};
|
||||
|
||||
pub fn enumFromString(comptime E: type, string: []const u8) ?E {
|
||||
return inline for (@typeInfo(E).Enum.fields) |enum_field| {
|
||||
if (byte_equal(string, enum_field.name)) {
|
||||
break @field(E, enum_field.name);
|
||||
}
|
||||
} else null;
|
||||
}
|
||||
|
||||
const page_size = std.mem.page_size;
|
||||
extern fn pthread_jit_write_protect_np(enabled: bool) void;
|
||||
|
||||
pub fn allocate_virtual_memory(size: usize, flags: packed struct {
|
||||
executable: bool = false,
|
||||
}) ![]align(page_size) u8 {
|
||||
return switch (os) {
|
||||
.windows => blk: {
|
||||
const windows = std.os.windows;
|
||||
break :blk @as([*]align(page_size) u8, @ptrCast(@alignCast(try windows.VirtualAlloc(null, size, windows.MEM_COMMIT | windows.MEM_RESERVE, windows.PAGE_EXECUTE_READWRITE))))[0..size];
|
||||
},
|
||||
.linux, .macos => |os_tag| blk: {
|
||||
const jit = switch (os_tag) {
|
||||
.macos => 0x800,
|
||||
.linux => 0,
|
||||
else => @compileError("OS not supported"),
|
||||
};
|
||||
_ = jit; // autofix
|
||||
const execute_flag: switch (os_tag) {
|
||||
.linux => u32,
|
||||
.macos => c_int,
|
||||
else => @compileError("OS not supported"),
|
||||
} = if (flags.executable) std.os.PROT.EXEC else 0;
|
||||
const protection_flags: u32 = @intCast(std.os.PROT.READ | std.os.PROT.WRITE | execute_flag);
|
||||
|
||||
const result = try std.os.mmap(null, size, protection_flags, .{
|
||||
.TYPE = .PRIVATE,
|
||||
.ANONYMOUS = true,
|
||||
}, -1, 0);
|
||||
if (arch == .aarch64 and os == .macos) {
|
||||
if (flags.executable) {
|
||||
pthread_jit_write_protect_np(false);
|
||||
}
|
||||
}
|
||||
|
||||
break :blk result;
|
||||
},
|
||||
else => @compileError("OS not supported"),
|
||||
};
|
||||
}
|
||||
|
||||
pub fn free_virtual_memory(slice: []const align(0x1000) u8) void {
|
||||
switch (os) {
|
||||
.windows => {
|
||||
std.os.windows.VirtualFree(slice.ptr, slice.len, std.os.windows.MEM_RELEASE);
|
||||
},
|
||||
else => {
|
||||
std.os.munmap(slice);
|
||||
},
|
||||
}
|
||||
}
|
||||
|
||||
pub const MyAllocator = struct{
|
||||
handler: *const fn(allocator: *MyAllocator, old_ptr: ?[*]u8, old_size: usize, new_size: usize, alignment: u16) Error![*]u8,
|
||||
|
||||
pub fn allocate_one(allocator: *MyAllocator, comptime T: type) !*T {
|
||||
const slice = try allocator.allocate(@sizeOf(T), @alignOf(T));
|
||||
assert(slice.len == @sizeOf(T));
|
||||
return @ptrCast(@alignCast(&slice.ptr[0]));
|
||||
}
|
||||
|
||||
pub fn allocate(allocator: *MyAllocator, size: usize, alignment: u16) ![]u8 {
|
||||
const ptr = try allocator.handler(allocator, null, 0, size, alignment);
|
||||
return ptr[0..size];
|
||||
}
|
||||
|
||||
pub fn free(allocator: *MyAllocator, bytes: []u8) !void {
|
||||
_ = try allocator.handler(allocator, bytes.ptr, bytes.len, 0, 0);
|
||||
}
|
||||
|
||||
pub fn reallocate(allocator: *MyAllocator, bytes: []u8, size: usize, alignment: u16) ![]u8 {
|
||||
const new_ptr = try allocator.handler(allocator, bytes.ptr, bytes.len, size, alignment);
|
||||
return new_ptr[0..size];
|
||||
}
|
||||
|
||||
pub fn duplicate_bytes(allocator: *MyAllocator, bytes: []const u8) ![]u8 {
|
||||
const slice = try allocator.allocate(bytes.len, 0);
|
||||
@memcpy(slice, bytes);
|
||||
return slice;
|
||||
}
|
||||
|
||||
const Error = error{
|
||||
allocation_failed,
|
||||
};
|
||||
};
|
||||
|
||||
pub const PageAllocator = struct{
|
||||
allocator: MyAllocator = .{ .handler = handler },
|
||||
|
||||
fn handler(allocator: *MyAllocator, maybe_old_ptr: ?[*]u8, old_size: usize, new_size: usize, alignment: u16) MyAllocator.Error![*]u8 {
|
||||
_ = allocator; // autofix
|
||||
_ = alignment; // autofix
|
||||
const maybe_new_slice: ?[]u8 = if (new_size > 0) allocate_virtual_memory(new_size, .{}) catch return MyAllocator.Error.allocation_failed else null;
|
||||
|
||||
if (maybe_old_ptr) |old_ptr| {
|
||||
const old_slice = old_ptr[0..old_size];
|
||||
if (maybe_new_slice) |new_slice| {
|
||||
@memcpy(new_slice[0..old_size], old_slice);
|
||||
free_virtual_memory(@ptrCast(@alignCast(old_slice)));
|
||||
return new_slice.ptr;
|
||||
} else {
|
||||
return old_slice.ptr;
|
||||
}
|
||||
} else {
|
||||
return (maybe_new_slice orelse unreachable).ptr;
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
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 {
|
||||
@setRuntimeSafety(false);
|
||||
assert(destination.len >= source.len);
|
||||
var i = source.len;
|
||||
while (i > 0) {
|
||||
i -= 1;
|
||||
destination[i] = source[i];
|
||||
}
|
||||
}
|
||||
|
||||
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 {
|
||||
const T = @TypeOf(a);
|
||||
|
||||
switch (@typeInfo(T)) {
|
||||
.Struct => |info| {
|
||||
inline for (info.fields) |field_info| {
|
||||
if (!equal(@field(a, field_info.name), @field(b, field_info.name))) return false;
|
||||
}
|
||||
return true;
|
||||
},
|
||||
.ErrorUnion => {
|
||||
if (a) |a_p| {
|
||||
if (b) |b_p| return equal(a_p, b_p) else |_| return false;
|
||||
} else |a_e| {
|
||||
if (b) |_| return false else |b_e| return a_e == b_e;
|
||||
}
|
||||
},
|
||||
.Union => |info| {
|
||||
if (info.tag_type) |UnionTag| {
|
||||
const tag_a = activeTag(a);
|
||||
const tag_b = activeTag(b);
|
||||
if (tag_a != tag_b) return false;
|
||||
|
||||
inline for (info.fields) |field_info| {
|
||||
if (@field(UnionTag, field_info.name) == tag_a) {
|
||||
return equal(@field(a, field_info.name), @field(b, field_info.name));
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
@compileError("cannot compare untagged union type " ++ @typeName(T));
|
||||
},
|
||||
.Array => {
|
||||
if (a.len != b.len) return false;
|
||||
for (a, 0..) |e, i|
|
||||
if (!equal(e, b[i])) return false;
|
||||
return true;
|
||||
},
|
||||
.Vector => |info| {
|
||||
var i: usize = 0;
|
||||
while (i < info.len) : (i += 1) {
|
||||
if (!equal(a[i], b[i])) return false;
|
||||
}
|
||||
return true;
|
||||
},
|
||||
.Pointer => |info| {
|
||||
return switch (info.size) {
|
||||
.One, .Many, .C => a == b,
|
||||
.Slice => a.ptr == b.ptr and a.len == b.len,
|
||||
};
|
||||
},
|
||||
.Optional => {
|
||||
if (a == null and b == null) return true;
|
||||
if (a == null or b == null) return false;
|
||||
return equal(a.?, b.?);
|
||||
},
|
||||
else => return a == b,
|
||||
}
|
||||
}
|
||||
|
||||
pub fn Tag(comptime T: type) type {
|
||||
return switch (@typeInfo(T)) {
|
||||
.Enum => |info| info.tag_type,
|
||||
.Union => |info| info.tag_type orelse @compileError(@typeName(T) ++ " has no tag type"),
|
||||
else => @compileError("expected enum or union type, found '" ++ @typeName(T) ++ "'"),
|
||||
};
|
||||
}
|
||||
|
||||
///Returns the active tag of a tagged union
|
||||
pub fn activeTag(u: anytype) Tag(@TypeOf(u)) {
|
||||
const T = @TypeOf(u);
|
||||
return @as(Tag(T), u);
|
||||
}
|
||||
|
||||
pub fn missingCase(e: anytype) noreturn {
|
||||
@panic(@tagName(e));
|
||||
}
|
||||
// Converts values in the range [0, 100) to a string.
|
||||
fn digits2(value: usize) [2]u8 {
|
||||
return ("0001020304050607080910111213141516171819" ++
|
||||
"2021222324252627282930313233343536373839" ++
|
||||
"4041424344454647484950515253545556575859" ++
|
||||
"6061626364656667686970717273747576777879" ++
|
||||
"8081828384858687888990919293949596979899")[value * 2 ..][0..2].*;
|
||||
}
|
||||
|
||||
pub fn digit_to_char(digit: u8) u8 {
|
||||
return switch (digit) {
|
||||
0...9 => digit + '0',
|
||||
10...35 => digit + ((@as(u8, 'a')) - 10),
|
||||
else => unreachable,
|
||||
};
|
||||
}
|
||||
|
||||
pub fn format_int(buffer: []u8, value: u64, base: u8, signed: bool) []u8 {
|
||||
assert(base >= 2);
|
||||
|
||||
var a: u64 = value;
|
||||
var index: usize = buffer.len;
|
||||
|
||||
if (base == 10) {
|
||||
while (a >= 100) : (a = @divTrunc(a, 100)) {
|
||||
index -= 2;
|
||||
buffer[index..][0..2].* = digits2(@as(usize, @intCast(a % 100)));
|
||||
}
|
||||
|
||||
if (a < 10) {
|
||||
index -= 1;
|
||||
buffer[index] = '0' + @as(u8, @intCast(a));
|
||||
} else {
|
||||
index -= 2;
|
||||
buffer[index..][0..2].* = digits2(@as(usize, @intCast(a)));
|
||||
}
|
||||
} else {
|
||||
while (true) {
|
||||
const digit = a % base;
|
||||
index -= 1;
|
||||
buffer[index] = digit_to_char(@as(u8, @intCast(digit)));
|
||||
a /= base;
|
||||
if (a == 0) break;
|
||||
}
|
||||
}
|
||||
|
||||
if (signed) {
|
||||
index -= 1;
|
||||
buffer[index] = '-';
|
||||
}
|
||||
|
||||
return buffer[index..];
|
||||
}
|
||||
|
||||
pub fn span(ptr: [*:0]const u8) [:0]const u8 {
|
||||
var len: usize = 0;
|
||||
while (ptr[len] != 0) {
|
||||
len += 1;
|
||||
}
|
||||
return ptr[0..len:0];
|
||||
}
|
||||
@ -1,21 +1,44 @@
|
||||
const std = @import("std");
|
||||
const Allocator = std.mem.Allocator;
|
||||
const equal = std.mem.eql;
|
||||
|
||||
const Compilation = @import("Compilation.zig");
|
||||
pub const panic = Compilation.panic;
|
||||
|
||||
const library = @import("library.zig");
|
||||
const byte_equal = library.byte_equal;
|
||||
const MyAllocator = library.MyAllocator;
|
||||
const PageAllocator = library.PageAllocator;
|
||||
|
||||
const env_detecting_libc_paths = "NATIVITY_IS_DETECTING_LIBC_PATHS";
|
||||
|
||||
test {
|
||||
_ = library;
|
||||
}
|
||||
|
||||
fn todo() noreturn {
|
||||
@setCold(true);
|
||||
@panic("TODO");
|
||||
}
|
||||
|
||||
pub fn main() !void {
|
||||
var my_allocator = PageAllocator{};
|
||||
pub export fn main(c_argc: c_int, c_argv: [*][*:0]c_char, c_envp: [*:null]?[*:0]c_char) callconv(.C) c_int {
|
||||
_ = c_envp; // autofix
|
||||
const argument_count: usize = @intCast(c_argc);
|
||||
const argument_values: [*][*:0]u8 = @ptrCast(c_argv);
|
||||
const arguments = argument_values[0..argument_count];
|
||||
if (entry_point(arguments)) |_| {
|
||||
return 0;
|
||||
} else |err| {
|
||||
const error_name: []const u8 = @errorName(err);
|
||||
_ = error_name; // autofix
|
||||
return 1;
|
||||
}
|
||||
}
|
||||
|
||||
pub fn entry_point(arguments: [][*:0]u8) !void {
|
||||
var arena_allocator = std.heap.ArenaAllocator.init(std.heap.page_allocator);
|
||||
const allocator = arena_allocator.allocator();
|
||||
const arguments = try std.process.argsAlloc(allocator);
|
||||
// const arguments = try std.process.argsAlloc(allocator);
|
||||
|
||||
if (arguments.len <= 1) {
|
||||
return error.InvalidInput;
|
||||
@ -25,32 +48,30 @@ pub fn main() !void {
|
||||
todo();
|
||||
}
|
||||
|
||||
const command = arguments[1];
|
||||
const command = library.span(arguments[1]);
|
||||
const command_arguments = arguments[2..];
|
||||
|
||||
if (equal(u8, command, "build")) {
|
||||
const context = try Compilation.createContext(allocator);
|
||||
const context = try Compilation.createContext(allocator, &my_allocator.allocator);
|
||||
if (byte_equal(command, "build")) {
|
||||
try Compilation.compileBuildExecutable(context, command_arguments);
|
||||
} else if (equal(u8, command, "clang") or equal(u8, command, "-cc1") or equal(u8, command, "-cc1as")) {
|
||||
} else if (byte_equal(command, "clang") or byte_equal(command, "-cc1") or byte_equal(command, "-cc1as")) {
|
||||
// const exit_code = try clangMain(allocator, arguments);
|
||||
// std.process.exit(exit_code);
|
||||
} else if (equal(u8, command, "cc")) {
|
||||
} else if (byte_equal(command, "cc")) {
|
||||
// TODO: transform our arguments to Clang and invoke it
|
||||
todo();
|
||||
} else if (equal(u8, command, "c++")) {
|
||||
} else if (byte_equal(command, "c++")) {
|
||||
// TODO: transform our arguments to Clang and invoke it
|
||||
todo();
|
||||
} else if (equal(u8, command, "exe")) {
|
||||
const context = try Compilation.createContext(allocator);
|
||||
} else if (byte_equal(command, "exe")) {
|
||||
try Compilation.buildExecutable(context, command_arguments, .{
|
||||
.is_test = false,
|
||||
});
|
||||
} else if (equal(u8, command, "lib")) {
|
||||
} else if (byte_equal(command, "lib")) {
|
||||
todo();
|
||||
} else if (equal(u8, command, "obj")) {
|
||||
} else if (byte_equal(command, "obj")) {
|
||||
todo();
|
||||
} else if (equal(u8, command, "test")) {
|
||||
const context = try Compilation.createContext(allocator);
|
||||
} else if (byte_equal(command, "test")) {
|
||||
try Compilation.buildExecutable(context, command_arguments, .{
|
||||
.is_test = true,
|
||||
});
|
||||
|
||||
25
build.zig
25
build.zig
@ -27,6 +27,7 @@ pub fn build(b: *std.Build) !void {
|
||||
compiler.formatted_panics = print_stack_trace;
|
||||
compiler.root_module.unwind_tables = print_stack_trace;
|
||||
compiler.root_module.omit_frame_pointer = false;
|
||||
compiler.root_module.error_tracing = false;
|
||||
compiler.want_lto = false;
|
||||
|
||||
compiler.linkLibC();
|
||||
@ -414,6 +415,23 @@ pub fn build(b: *std.Build) !void {
|
||||
debug_command.addArgs(args);
|
||||
test_command.addArgs(args);
|
||||
}
|
||||
//
|
||||
// const tests = b.addTest(.{
|
||||
// .name = "nat_test",
|
||||
// .root_source_file = .{ .path = "bootstrap/main.zig" },
|
||||
// .target = target,
|
||||
// .optimize = optimization,
|
||||
// });
|
||||
// tests.root_module.addOptions("configuration", compiler_options);
|
||||
// tests.formatted_panics = print_stack_trace;
|
||||
// tests.root_module.unwind_tables = print_stack_trace;
|
||||
// tests.root_module.omit_frame_pointer = false;
|
||||
// tests.want_lto = false;
|
||||
//
|
||||
//
|
||||
// const run_tests = b.addRunArtifact(tests);
|
||||
// b.installArtifact(tests);
|
||||
// run_tests.step.dependOn(b.getInstallStep());
|
||||
|
||||
const run_step = b.step("run", "Test the Nativity compiler");
|
||||
run_step.dependOn(&run_command.step);
|
||||
@ -421,4 +439,11 @@ pub fn build(b: *std.Build) !void {
|
||||
debug_step.dependOn(&debug_command.step);
|
||||
const test_step = b.step("test", "Test the Nativity compiler");
|
||||
test_step.dependOn(&test_command.step);
|
||||
|
||||
// const test_lib = b.step("test_lib", "Test the Nativity Zig library");
|
||||
// test_lib.dependOn(&run_tests.step);
|
||||
|
||||
const test_all = b.step("test_all", "Test all");
|
||||
// test_all.dependOn(&run_tests.step);
|
||||
test_all.dependOn(&test_command.step);
|
||||
}
|
||||
|
||||
@ -95,7 +95,8 @@ pub fn main() !void {
|
||||
try request.wait();
|
||||
|
||||
if (request.response.status != .ok) {
|
||||
std.debug.panic("Status: {s} when fetching TAR {s}", .{@tagName(request.response.status), url});
|
||||
@panic("Failure when fetching TAR");
|
||||
//std.debug.panic("Status: {s} when fetching TAR {s}", .{@tagName(request.response.status), url});
|
||||
}
|
||||
|
||||
var decompression = try std.compress.xz.decompress(allocator, request.reader());
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user