1418 lines
47 KiB
Zig
1418 lines
47 KiB
Zig
const Compilation = @This();
|
|
|
|
const std = @import("std");
|
|
const assert = std.debug.assert;
|
|
const equal = std.mem.eql;
|
|
|
|
const Allocator = std.mem.Allocator;
|
|
|
|
const data_structures = @import("data_structures.zig");
|
|
const ArrayList = data_structures.ArrayList;
|
|
const AutoHashMap = data_structures.AutoHashMap;
|
|
const BlockList = data_structures.BlockList;
|
|
const HashMap = data_structures.HashMap;
|
|
const SegmentedList = data_structures.SegmentedList;
|
|
const StringKeyMap = data_structures.StringKeyMap;
|
|
const StringHashMap = data_structures.StringHashMap;
|
|
const StringArrayHashMap = data_structures.StringArrayHashMap;
|
|
|
|
const lexical_analyzer = @import("frontend/lexical_analyzer.zig");
|
|
const Token = lexical_analyzer.Token;
|
|
const syntactic_analyzer = @import("frontend/syntactic_analyzer.zig");
|
|
const Node = syntactic_analyzer.Node;
|
|
const semantic_analyzer = @import("frontend/semantic_analyzer.zig");
|
|
const intermediate_representation = @import("backend/intermediate_representation.zig");
|
|
const c_transpiler = @import("backend/c_transpiler.zig");
|
|
const emit = @import("backend/emit.zig");
|
|
|
|
test {
|
|
_ = lexical_analyzer;
|
|
_ = syntactic_analyzer;
|
|
_ = semantic_analyzer;
|
|
_ = data_structures;
|
|
}
|
|
|
|
base_allocator: Allocator,
|
|
cwd_absolute_path: []const u8,
|
|
directory_absolute_path: []const u8,
|
|
executable_absolute_path: []const u8,
|
|
build_directory: std.fs.Dir,
|
|
|
|
const cache_dir_name = "cache";
|
|
const installation_dir_name = "installation";
|
|
|
|
const ArgumentParsingError = error{
|
|
main_package_path_not_specified,
|
|
};
|
|
|
|
fn reportUnterminatedArgumentError(string: []const u8) noreturn {
|
|
std.debug.panic("Unterminated argument: {s}", .{string});
|
|
}
|
|
|
|
fn parseArguments(allocator: Allocator) !Compilation.Module.Descriptor {
|
|
const arguments = (try std.process.argsAlloc(allocator))[1..];
|
|
|
|
var maybe_executable_path: ?[]const u8 = null;
|
|
var maybe_main_package_path: ?[]const u8 = null;
|
|
var target_triplet: []const u8 = "x86_64-linux-gnu";
|
|
var transpile_to_c: ?bool = null;
|
|
|
|
var i: usize = 0;
|
|
while (i < arguments.len) : (i += 1) {
|
|
const current_argument = arguments[i];
|
|
if (equal(u8, current_argument, "-o")) {
|
|
if (i + 1 != arguments.len) {
|
|
maybe_executable_path = arguments[i + 1];
|
|
assert(maybe_executable_path.?.len != 0);
|
|
i += 1;
|
|
} else {
|
|
reportUnterminatedArgumentError(current_argument);
|
|
}
|
|
} else if (equal(u8, current_argument, "-target")) {
|
|
if (i + 1 != arguments.len) {
|
|
target_triplet = arguments[i + 1];
|
|
i += 1;
|
|
} else {
|
|
reportUnterminatedArgumentError(current_argument);
|
|
}
|
|
} else if (equal(u8, current_argument, "-log")) {
|
|
if (i + 1 != arguments.len) {
|
|
i += 1;
|
|
|
|
var log_argument_iterator = std.mem.splitScalar(u8, arguments[i], ',');
|
|
|
|
while (log_argument_iterator.next()) |log_argument| {
|
|
var log_argument_splitter = std.mem.splitScalar(u8, log_argument, '.');
|
|
const log_scope_candidate = log_argument_splitter.next() orelse unreachable;
|
|
var recognized_scope = false;
|
|
|
|
inline for (@typeInfo(LoggerScope).Enum.fields) |logger_scope_enum_field| {
|
|
const log_scope = @field(LoggerScope, logger_scope_enum_field.name);
|
|
|
|
if (equal(u8, @tagName(log_scope), log_scope_candidate)) {
|
|
const LogScope = getLoggerScopeType(log_scope);
|
|
|
|
if (log_argument_splitter.next()) |particular_log_candidate| {
|
|
var recognized_particular = false;
|
|
inline for (@typeInfo(LogScope.Logger).Enum.fields) |particular_log_field| {
|
|
const particular_log = @field(LogScope.Logger, particular_log_field.name);
|
|
|
|
if (equal(u8, particular_log_candidate, @tagName(particular_log))) {
|
|
LogScope.Logger.bitset.setPresent(particular_log, true);
|
|
recognized_particular = true;
|
|
}
|
|
} else if (!recognized_particular) std.debug.panic("Unrecognized particular log \"{s}\" in scope {s}", .{ particular_log_candidate, @tagName(log_scope) });
|
|
} else {
|
|
// LogScope.Logger.bitset = @TypeOf(LogScope.Logger.bitset).initFull();
|
|
}
|
|
|
|
logger_bitset.setPresent(log_scope, true);
|
|
|
|
recognized_scope = true;
|
|
}
|
|
} else if (!recognized_scope) std.debug.panic("Unrecognized log scope: {s}", .{log_scope_candidate});
|
|
}
|
|
} else {
|
|
reportUnterminatedArgumentError(current_argument);
|
|
}
|
|
} else if (equal(u8, current_argument, "-transpile_to_c")) {
|
|
if (i + 1 != arguments.len) {
|
|
i += 1;
|
|
|
|
const arg = arguments[i];
|
|
if (std.mem.eql(u8, arg, "true")) {
|
|
transpile_to_c = true;
|
|
} else if (std.mem.eql(u8, arg, "false")) {
|
|
transpile_to_c = false;
|
|
} else {
|
|
unreachable;
|
|
}
|
|
} else {
|
|
reportUnterminatedArgumentError(current_argument);
|
|
}
|
|
} else {
|
|
maybe_main_package_path = current_argument;
|
|
}
|
|
}
|
|
|
|
const main_package_path = maybe_main_package_path orelse return error.main_package_path_not_specified;
|
|
|
|
const executable_path = maybe_executable_path orelse blk: {
|
|
const executable_name = std.fs.path.basename(main_package_path[0 .. main_package_path.len - "/main.nat".len]);
|
|
assert(executable_name.len > 0);
|
|
const result = try std.mem.concat(allocator, u8, &.{ "nat/", executable_name });
|
|
break :blk result;
|
|
};
|
|
|
|
const cross_target = try std.zig.CrossTarget.parse(.{ .arch_os_abi = target_triplet });
|
|
const target = cross_target.toTarget();
|
|
|
|
return .{
|
|
.main_package_path = main_package_path,
|
|
.executable_path = executable_path,
|
|
.target = target,
|
|
.transpile_to_c = transpile_to_c orelse true,
|
|
};
|
|
}
|
|
|
|
pub fn init(allocator: Allocator) !void {
|
|
const compilation: *Compilation = try allocator.create(Compilation);
|
|
|
|
const self_exe_path = try std.fs.selfExePathAlloc(allocator);
|
|
const self_exe_dir_path = std.fs.path.dirname(self_exe_path).?;
|
|
compilation.* = .{
|
|
.base_allocator = allocator,
|
|
.cwd_absolute_path = try realpathAlloc(allocator, "."),
|
|
.executable_absolute_path = self_exe_path,
|
|
.directory_absolute_path = self_exe_dir_path,
|
|
.build_directory = try std.fs.cwd().makeOpenPath("nat", .{}),
|
|
};
|
|
|
|
try compilation.build_directory.makePath(cache_dir_name);
|
|
try compilation.build_directory.makePath(installation_dir_name);
|
|
|
|
const compilation_descriptor = try parseArguments(allocator);
|
|
|
|
try compilation.compileModule(compilation_descriptor);
|
|
}
|
|
|
|
pub const Struct = struct {
|
|
scope: Scope.Index,
|
|
fields: ArrayList(ContainerField.Index) = .{},
|
|
backing_type: Type.Index,
|
|
|
|
pub const List = BlockList(@This());
|
|
pub const Index = List.Index;
|
|
pub const Allocation = List.Allocation;
|
|
};
|
|
|
|
pub const ContainerField = struct {
|
|
name: u32,
|
|
type: Type.Index,
|
|
default_value: Value.Index,
|
|
parent: Type.Index,
|
|
|
|
pub const List = BlockList(@This());
|
|
pub const Index = List.Index;
|
|
pub const Allocation = List.Allocation;
|
|
};
|
|
|
|
pub const ContainerInitialization = struct {
|
|
field_initializations: ArrayList(Value.Index),
|
|
type: Type.Index,
|
|
|
|
pub const List = BlockList(@This());
|
|
pub const Index = List.Index;
|
|
pub const Allocation = List.Allocation;
|
|
};
|
|
|
|
pub const Enum = struct {
|
|
scope: Scope.Index,
|
|
fields: ArrayList(Enum.Field.Index) = .{},
|
|
type: Type.Index,
|
|
|
|
pub const Field = struct {
|
|
name: u32,
|
|
value: Value.Index,
|
|
parent: Enum.Index,
|
|
|
|
pub const List = BlockList(@This());
|
|
pub const Index = Enum.Field.List.Index;
|
|
pub const Allocation = Enum.Field.List.Allocation;
|
|
};
|
|
|
|
pub const List = BlockList(@This());
|
|
pub const Index = List.Index;
|
|
pub const Allocation = List.Allocation;
|
|
};
|
|
|
|
pub const Array = struct {
|
|
element_type: Type.Index,
|
|
element_count: u32,
|
|
|
|
pub const List = BlockList(@This());
|
|
pub const Index = List.Index;
|
|
pub const Allocation = List.Allocation;
|
|
};
|
|
|
|
pub const Type = union(enum) {
|
|
any,
|
|
void,
|
|
noreturn,
|
|
bool,
|
|
type,
|
|
comptime_int,
|
|
integer: Type.Integer,
|
|
slice: Type.Slice,
|
|
pointer: Pointer,
|
|
@"struct": Struct.Index,
|
|
@"enum": Enum.Index,
|
|
function: Function.Prototype.Index,
|
|
array: Array,
|
|
optional: Optional,
|
|
|
|
const Optional = struct {
|
|
element_type: Type.Index,
|
|
};
|
|
|
|
pub const Slice = struct {
|
|
element_type: Type.Index,
|
|
@"const": bool,
|
|
};
|
|
|
|
pub const Pointer = struct {
|
|
element_type: Type.Index,
|
|
many: bool,
|
|
@"const": bool,
|
|
};
|
|
|
|
pub const List = BlockList(@This());
|
|
pub const Index = List.Index;
|
|
pub const Allocation = List.Allocation;
|
|
|
|
pub const Integer = struct {
|
|
bit_count: u16,
|
|
signedness: Signedness,
|
|
pub const Signedness = enum(u1) {
|
|
unsigned = 0,
|
|
signed = 1,
|
|
};
|
|
|
|
pub fn getSize(integer: Integer) u64 {
|
|
return integer.bit_count / @bitSizeOf(u8) + @intFromBool(integer.bit_count % @bitSizeOf(u8) != 0);
|
|
}
|
|
|
|
pub fn getIndex(integer: Integer) Compilation.Type.Index {
|
|
return .{
|
|
.block = 0,
|
|
.element = @ctz(integer.bit_count) - @ctz(@as(u8, 8)) + @as(u6, switch (integer.signedness) {
|
|
.signed => Compilation.HardwareSignedIntegerType.offset,
|
|
.unsigned => Compilation.HardwareUnsignedIntegerType.offset,
|
|
}),
|
|
};
|
|
}
|
|
|
|
// pub fn get(bit_count: u16, comptime signedness: Signedness) @This().Type(signedness) {
|
|
// _ = bit_count;
|
|
// }
|
|
|
|
fn Type(comptime signedness: Signedness) type {
|
|
return switch (signedness) {
|
|
.unsigned => HardwareUnsignedIntegerType,
|
|
.signed => HardwareSignedIntegerType,
|
|
};
|
|
}
|
|
};
|
|
|
|
pub fn getSize(type_info: Type) u64 {
|
|
return switch (type_info) {
|
|
.integer => |integer| integer.getSize(),
|
|
.pointer => 8,
|
|
.comptime_int => @panic("This call should never happen"),
|
|
else => |t| @panic(@tagName(t)),
|
|
};
|
|
}
|
|
|
|
pub fn getBitSize(type_info: Type) u64 {
|
|
return switch (type_info) {
|
|
.integer => |integer| integer.bit_count,
|
|
.pointer => 8,
|
|
.bool => 1,
|
|
.comptime_int => @panic("This call should never happen"),
|
|
else => |t| @panic(@tagName(t)),
|
|
};
|
|
}
|
|
|
|
pub fn getAlignment(type_info: Type) u64 {
|
|
return switch (type_info) {
|
|
.integer => |integer| @min(16, integer.getSize()),
|
|
.pointer => 8,
|
|
else => |t| @panic(@tagName(t)),
|
|
};
|
|
}
|
|
|
|
pub const any = FixedTypeKeyword.any.toType();
|
|
pub const @"void" = FixedTypeKeyword.void.toType();
|
|
pub const boolean = FixedTypeKeyword.bool.toType();
|
|
pub const ssize = FixedTypeKeyword.ssize.toType();
|
|
pub const @"usize" = FixedTypeKeyword.usize.toType();
|
|
pub const @"noreturn" = FixedTypeKeyword.noreturn.toType();
|
|
pub const @"type" = FixedTypeKeyword.type.toType();
|
|
pub const @"comptime_int" = FixedTypeKeyword.comptime_int.toType();
|
|
pub const string_literal = ExtraCommonType.string_literal.toType();
|
|
pub const @"u8" = Type.Integer.getIndex(.{
|
|
.bit_count = 8,
|
|
.signedness = .unsigned,
|
|
});
|
|
pub const @"u16" = Type.Integer.getIndex(.{
|
|
.bit_count = 16,
|
|
.signedness = .unsigned,
|
|
});
|
|
pub const @"u32" = Type.Integer.getIndex(.{
|
|
.bit_count = 32,
|
|
.signedness = .unsigned,
|
|
});
|
|
pub const @"u64" = Type.Integer.getIndex(.{
|
|
.bit_count = 64,
|
|
.signedness = .unsigned,
|
|
});
|
|
};
|
|
|
|
// Each time an enum is added here, a corresponding insertion in the initialization must be made
|
|
pub const Intrinsic = enum {
|
|
//@"asm", this is processed separately as it need special parsing
|
|
@"error",
|
|
import,
|
|
syscall,
|
|
cast,
|
|
};
|
|
|
|
pub const FixedTypeKeyword = enum {
|
|
void,
|
|
noreturn,
|
|
bool,
|
|
usize,
|
|
ssize,
|
|
type,
|
|
comptime_int,
|
|
any,
|
|
|
|
const offset = 0;
|
|
|
|
fn toType(fixed_type_keyword: FixedTypeKeyword) Type.Index {
|
|
return Type.Index.fromInteger(offset + @intFromEnum(fixed_type_keyword));
|
|
}
|
|
};
|
|
|
|
pub const HardwareUnsignedIntegerType = enum {
|
|
u8,
|
|
u16,
|
|
u32,
|
|
u64,
|
|
|
|
pub const offset = @typeInfo(FixedTypeKeyword).Enum.fields.len;
|
|
};
|
|
|
|
pub const HardwareSignedIntegerType = enum {
|
|
s8,
|
|
s16,
|
|
s32,
|
|
s64,
|
|
|
|
pub const offset = HardwareUnsignedIntegerType.offset + @typeInfo(HardwareUnsignedIntegerType).Enum.fields.len;
|
|
};
|
|
|
|
pub const ExtraCommonType = enum {
|
|
string_literal,
|
|
pub const offset = HardwareSignedIntegerType.offset + @typeInfo(HardwareSignedIntegerType).Enum.fields.len;
|
|
|
|
fn toType(t: ExtraCommonType) Type.Index {
|
|
return Type.Index.fromInteger(offset + @intFromEnum(t));
|
|
}
|
|
};
|
|
|
|
pub const extra_common_type_data = blk: {
|
|
var result: [@typeInfo(ExtraCommonType).Enum.fields.len]Type = undefined;
|
|
result[@intFromEnum(ExtraCommonType.string_literal)] = .{
|
|
.pointer = .{
|
|
.many = true,
|
|
.@"const" = true,
|
|
.element_type = Type.u8,
|
|
},
|
|
};
|
|
|
|
break :blk result;
|
|
};
|
|
|
|
/// A scope contains a bunch of declarations
|
|
pub const Scope = struct {
|
|
declarations: data_structures.AutoArrayHashMap(u32, Declaration.Index) = .{},
|
|
parent: Scope.Index,
|
|
file: File.Index,
|
|
token: Token.Index,
|
|
type: Type.Index = Type.Index.invalid,
|
|
|
|
pub const List = BlockList(@This());
|
|
pub const Index = List.Index;
|
|
pub const Allocation = List.Allocation;
|
|
};
|
|
|
|
pub const ScopeType = enum(u1) {
|
|
local = 0,
|
|
global = 1,
|
|
};
|
|
|
|
pub const Mutability = enum(u1) {
|
|
@"const",
|
|
@"var",
|
|
};
|
|
|
|
pub const Declaration = struct {
|
|
scope_type: ScopeType,
|
|
mutability: Mutability,
|
|
init_value: Value.Index,
|
|
name: u32,
|
|
argument_index: ?u32,
|
|
type: Type.Index,
|
|
scope: Scope.Index,
|
|
|
|
pub const Reference = struct {
|
|
value: Declaration.Index,
|
|
type: Type.Index,
|
|
};
|
|
|
|
pub const List = BlockList(@This());
|
|
pub const Index = List.Index;
|
|
pub const Allocation = List.Allocation;
|
|
};
|
|
|
|
pub const Function = struct {
|
|
scope: Scope.Index,
|
|
body: Block.Index,
|
|
prototype: Type.Index,
|
|
|
|
pub const Prototype = struct {
|
|
arguments: ?[]const Declaration.Index,
|
|
return_type: Type.Index,
|
|
attributes: Attributes = .{},
|
|
|
|
pub const List = BlockList(@This());
|
|
pub const Index = Prototype.List.Index;
|
|
|
|
pub const Attributes = packed struct {
|
|
@"extern": bool = false,
|
|
@"export": bool = false,
|
|
@"inline": Inline = .none,
|
|
calling_convention: CallingConvention = .system_v,
|
|
|
|
pub const Inline = enum {
|
|
none,
|
|
suggestion_optimizer,
|
|
force_semantic,
|
|
force_optimizer,
|
|
};
|
|
};
|
|
};
|
|
|
|
pub fn getBodyBlock(function: Function, module: *Module) *Block {
|
|
return module.blocks.get(function.body);
|
|
}
|
|
|
|
pub const List = BlockList(@This());
|
|
pub const Index = List.Index;
|
|
pub const Allocation = List.Allocation;
|
|
};
|
|
|
|
pub const Block = struct {
|
|
statements: ArrayList(Value.Index) = .{},
|
|
reaches_end: bool,
|
|
pub const List = BlockList(@This());
|
|
pub const Index = List.Index;
|
|
pub const Allocation = List.Allocation;
|
|
};
|
|
|
|
pub const Loop = struct {
|
|
pre: Value.Index,
|
|
condition: Value.Index,
|
|
body: Value.Index,
|
|
post: Value.Index,
|
|
reaches_end: bool,
|
|
|
|
pub const List = BlockList(@This());
|
|
pub const Index = List.Index;
|
|
pub const Allocation = List.Allocation;
|
|
};
|
|
|
|
const Unresolved = struct {
|
|
node_index: Node.Index,
|
|
};
|
|
|
|
pub const Assignment = struct {
|
|
destination: Value.Index,
|
|
source: Value.Index,
|
|
operation: Operation,
|
|
|
|
const Operation = enum {
|
|
none,
|
|
add,
|
|
};
|
|
|
|
pub const List = BlockList(@This());
|
|
pub const Index = List.Index;
|
|
pub const Allocation = List.Allocation;
|
|
};
|
|
|
|
pub const Syscall = struct {
|
|
number: Value.Index,
|
|
arguments: [6]Value.Index,
|
|
argument_count: u8,
|
|
|
|
pub fn getArguments(syscall: *const Syscall) []const Value.Index {
|
|
return syscall.arguments[0..syscall.argument_count];
|
|
}
|
|
|
|
pub const List = BlockList(@This());
|
|
pub const Index = List.Index;
|
|
pub const Allocation = List.Allocation;
|
|
};
|
|
|
|
pub const Call = struct {
|
|
value: Value.Index,
|
|
arguments: ArgumentList.Index,
|
|
type: Type.Index,
|
|
|
|
pub const List = BlockList(@This());
|
|
pub const Index = List.Index;
|
|
pub const Allocation = List.Allocation;
|
|
};
|
|
|
|
pub const ArgumentList = struct {
|
|
array: ArrayList(Value.Index),
|
|
pub const List = BlockList(@This());
|
|
pub const Index = List.Index;
|
|
pub const Allocation = List.Allocation;
|
|
};
|
|
|
|
pub const Return = struct {
|
|
value: Value.Index,
|
|
pub const List = BlockList(@This());
|
|
pub const Index = List.Index;
|
|
pub const Allocation = List.Allocation;
|
|
};
|
|
|
|
pub const Cast = struct {
|
|
value: Value.Index,
|
|
type: Type.Index,
|
|
|
|
pub const List = BlockList(@This());
|
|
pub const Index = List.Index;
|
|
pub const Allocation = List.Allocation;
|
|
};
|
|
|
|
pub const BinaryOperation = struct {
|
|
left: Value.Index,
|
|
right: Value.Index,
|
|
type: Type.Index,
|
|
id: Id,
|
|
|
|
pub const List = BlockList(@This());
|
|
pub const Index = List.Index;
|
|
pub const Allocation = List.Allocation;
|
|
|
|
pub const Id = enum {
|
|
add,
|
|
sub,
|
|
bit_and,
|
|
bit_xor,
|
|
bit_or,
|
|
multiply,
|
|
divide,
|
|
shift_left,
|
|
shift_right,
|
|
compare_equal,
|
|
compare_greater_than,
|
|
compare_greater_or_equal,
|
|
compare_less_than,
|
|
compare_less_or_equal,
|
|
};
|
|
};
|
|
|
|
pub const UnaryOperation = struct {
|
|
value: Value.Index,
|
|
type: Type.Index,
|
|
id: Id,
|
|
|
|
pub const List = BlockList(@This());
|
|
pub const Index = List.Index;
|
|
pub const Allocation = List.Allocation;
|
|
|
|
pub const Id = enum {
|
|
boolean_not,
|
|
negation,
|
|
address_of,
|
|
pointer_dereference,
|
|
};
|
|
};
|
|
|
|
pub const CallingConvention = enum {
|
|
system_v,
|
|
naked,
|
|
};
|
|
|
|
pub const Branch = struct {
|
|
expression: Value.Index,
|
|
taken_expression: Value.Index,
|
|
not_taken_expression: Value.Index,
|
|
reaches_end: bool,
|
|
|
|
pub const List = BlockList(@This());
|
|
pub const Index = List.Index;
|
|
pub const Allocation = List.Allocation;
|
|
};
|
|
|
|
pub const FieldAccess = struct {
|
|
declaration_reference: Value.Index,
|
|
field: ContainerField.Index,
|
|
|
|
pub const List = BlockList(@This());
|
|
pub const Index = List.Index;
|
|
pub const Allocation = List.Allocation;
|
|
};
|
|
|
|
pub const Range = struct {
|
|
start: Value.Index,
|
|
end: Value.Index,
|
|
};
|
|
|
|
pub const Slice = struct {
|
|
sliceable: Value.Index,
|
|
range: Range,
|
|
type: Type.Index,
|
|
|
|
pub const Access = struct {
|
|
value: Value.Index,
|
|
field: Field,
|
|
type: Type.Index,
|
|
|
|
pub const List = BlockList(@This());
|
|
pub const Index = Slice.Access.List.Index;
|
|
pub const Allocation = Slice.Access.List.Allocation;
|
|
};
|
|
|
|
pub const Field = enum {
|
|
ptr,
|
|
len,
|
|
};
|
|
|
|
pub const List = BlockList(@This());
|
|
pub const Index = List.Index;
|
|
pub const Allocation = List.Allocation;
|
|
};
|
|
|
|
pub const IndexedAccess = struct {
|
|
indexed_expression: Value.Index,
|
|
index_expression: Value.Index,
|
|
|
|
pub const List = BlockList(@This());
|
|
pub const Index = List.Index;
|
|
pub const Allocation = List.Allocation;
|
|
};
|
|
|
|
pub const OptionalCheck = struct {
|
|
value: Value.Index,
|
|
|
|
pub const List = BlockList(@This());
|
|
pub const Index = List.Index;
|
|
pub const Allocation = List.Allocation;
|
|
};
|
|
|
|
pub const OptionalUnwrap = struct {
|
|
value: Value.Index,
|
|
|
|
pub const List = BlockList(@This());
|
|
pub const Index = List.Index;
|
|
pub const Allocation = List.Allocation;
|
|
};
|
|
|
|
pub const Assembly = struct {
|
|
pub const Instruction = struct {
|
|
id: u32,
|
|
operands: []const Operand,
|
|
|
|
pub const List = BlockList(@This());
|
|
pub const Index = List.Index;
|
|
pub const Allocation = List.Allocation;
|
|
};
|
|
|
|
pub const Operand = union(enum) {
|
|
register: u32,
|
|
number_literal: u64,
|
|
value_index: Value.Index,
|
|
};
|
|
|
|
pub const Block = struct {
|
|
instructions: []const Assembly.Instruction.Index,
|
|
|
|
pub const List = BlockList(@This());
|
|
pub const Index = List.Index;
|
|
pub const Allocation = List.Allocation;
|
|
};
|
|
|
|
pub const x86_64 = struct {
|
|
pub const Instruction = enum {
|
|
@"and",
|
|
call,
|
|
xor,
|
|
};
|
|
|
|
pub const Register = enum {
|
|
ebp,
|
|
rsp,
|
|
};
|
|
};
|
|
};
|
|
|
|
pub const Value = union(enum) {
|
|
void,
|
|
bool: bool,
|
|
undefined,
|
|
@"unreachable",
|
|
pointer_null_literal,
|
|
optional_null_literal,
|
|
unresolved: Unresolved,
|
|
declaration: Declaration.Index,
|
|
declaration_reference: Declaration.Reference,
|
|
loop: Loop.Index,
|
|
function_definition: Function.Index,
|
|
function_declaration: Function.Index,
|
|
block: Block.Index,
|
|
assign: Assignment.Index,
|
|
type: Type.Index,
|
|
integer: Integer,
|
|
syscall: Syscall.Index,
|
|
call: Call.Index,
|
|
argument_list: ArgumentList,
|
|
@"return": Return.Index,
|
|
argument: Declaration.Index,
|
|
string_literal: u32,
|
|
enum_field: Enum.Field.Index,
|
|
extern_function: Function.Prototype.Index,
|
|
sign_extend: Cast.Index,
|
|
zero_extend: Cast.Index,
|
|
binary_operation: BinaryOperation.Index,
|
|
unary_operation: UnaryOperation.Index,
|
|
branch: Branch.Index,
|
|
cast: Cast.Index,
|
|
container_initialization: ContainerInitialization.Index,
|
|
field_access: FieldAccess.Index,
|
|
slice_access: Slice.Access.Index,
|
|
indexed_access: IndexedAccess.Index,
|
|
optional_check: OptionalCheck.Index,
|
|
optional_unwrap: OptionalUnwrap.Index,
|
|
slice: Slice.Index,
|
|
assembly_block: Assembly.Block.Index,
|
|
|
|
pub const List = BlockList(@This());
|
|
pub const Index = List.Index;
|
|
pub const Allocation = List.Allocation;
|
|
|
|
pub const Integer = struct {
|
|
value: u64,
|
|
type: Type.Index,
|
|
signedness: Type.Integer.Signedness,
|
|
|
|
pub fn getBitCount(integer: Integer, module: *Module) u16 {
|
|
return module.types.get(integer.type).integer.bit_count;
|
|
}
|
|
};
|
|
|
|
pub fn isComptime(value: *Value, module: *Module) bool {
|
|
return switch (value.*) {
|
|
.integer => |integer| integer.type.eq(Type.comptime_int),
|
|
.declaration_reference => |declaration_reference| module.declarations.get(declaration_reference.value).mutability == .@"const" and isComptime(module.values.get(module.declarations.get(declaration_reference.value).init_value), module),
|
|
.bool, .void, .undefined, .function_definition, .type, .enum_field => true,
|
|
// TODO:
|
|
.call,
|
|
.syscall,
|
|
.binary_operation,
|
|
.container_initialization,
|
|
.cast,
|
|
.optional_unwrap,
|
|
.pointer_null_literal,
|
|
.indexed_access,
|
|
=> false,
|
|
// TODO:
|
|
else => |t| @panic(@tagName(t)),
|
|
};
|
|
}
|
|
|
|
pub fn getType(value: Value, module: *Module) Type.Index {
|
|
const result = switch (value) {
|
|
.call => |call_index| module.calls.get(call_index).type,
|
|
.integer => |integer| integer.type,
|
|
.declaration_reference => |declaration_reference| declaration_reference.type,
|
|
.string_literal => |string_literal_hash| module.string_literal_types.get(@intCast(module.getStringLiteral(string_literal_hash).?.len)).?,
|
|
.type => Type.type,
|
|
.enum_field => |enum_field_index| module.enums.get(module.enum_fields.get(enum_field_index).parent).type,
|
|
.function_definition => |function_index| module.function_definitions.get(function_index).prototype,
|
|
.function_declaration => |function_index| module.function_declarations.get(function_index).prototype,
|
|
.binary_operation => |binary_operation| module.binary_operations.get(binary_operation).type,
|
|
.bool => Type.boolean,
|
|
.declaration => Type.void,
|
|
.container_initialization => |container_initialization| module.container_initializations.get(container_initialization).type,
|
|
.syscall => Type.usize,
|
|
.unary_operation => |unary_operation_index| module.unary_operations.get(unary_operation_index).type,
|
|
.pointer_null_literal => semantic_analyzer.optional_pointer_to_any_type,
|
|
.optional_null_literal => semantic_analyzer.optional_any,
|
|
.field_access => |field_access_index| module.container_fields.get(module.field_accesses.get(field_access_index).field).type,
|
|
.cast => |cast_index| module.casts.get(cast_index).type,
|
|
.slice => |slice_index| module.slices.get(slice_index).type,
|
|
.slice_access => |slice_access_index| module.slice_accesses.get(slice_access_index).type,
|
|
.optional_check => Type.boolean,
|
|
.indexed_access => |indexed_access_index| blk: {
|
|
const indexed_expression = module.values.get(module.indexed_accesses.get(indexed_access_index).indexed_expression);
|
|
const indexed_expression_type_index = indexed_expression.getType(module);
|
|
const indexed_expression_type = module.types.get(indexed_expression_type_index);
|
|
break :blk switch (indexed_expression_type.*) {
|
|
.slice => |slice| slice.element_type,
|
|
else => |t| @panic(@tagName(t)),
|
|
};
|
|
},
|
|
else => |t| @panic(@tagName(t)),
|
|
};
|
|
|
|
return result;
|
|
}
|
|
|
|
const TypeCheckError = error{
|
|
integer_size,
|
|
pointer_many_differ,
|
|
pointer_element_type_differ,
|
|
};
|
|
};
|
|
|
|
pub const Module = struct {
|
|
main_package: *Package,
|
|
import_table: StringArrayHashMap(*File) = .{},
|
|
string_table: StringKeyMap([]const u8) = .{},
|
|
declarations: BlockList(Declaration) = .{},
|
|
structs: BlockList(Struct) = .{},
|
|
scopes: BlockList(Scope) = .{},
|
|
files: BlockList(File) = .{},
|
|
values: BlockList(Value) = .{},
|
|
function_definitions: BlockList(Function) = .{},
|
|
function_declarations: BlockList(Function) = .{},
|
|
function_prototypes: BlockList(Function.Prototype) = .{},
|
|
types: BlockList(Type) = .{},
|
|
blocks: BlockList(Block) = .{},
|
|
loops: BlockList(Loop) = .{},
|
|
assignments: BlockList(Assignment) = .{},
|
|
syscalls: BlockList(Syscall) = .{},
|
|
calls: BlockList(Call) = .{},
|
|
argument_lists: BlockList(ArgumentList) = .{},
|
|
returns: BlockList(Return) = .{},
|
|
string_literals: StringKeyMap([]const u8) = .{},
|
|
enums: BlockList(Enum) = .{},
|
|
enum_fields: BlockList(Enum.Field) = .{},
|
|
container_fields: BlockList(ContainerField) = .{},
|
|
container_initializations: BlockList(ContainerInitialization) = .{},
|
|
function_map: data_structures.AutoArrayHashMap(Function.Index, Declaration.Index) = .{},
|
|
type_map: data_structures.AutoArrayHashMap(Type.Index, Declaration.Index) = .{},
|
|
arrays: BlockList(Array) = .{},
|
|
casts: BlockList(Cast) = .{},
|
|
binary_operations: BlockList(BinaryOperation) = .{},
|
|
unary_operations: BlockList(UnaryOperation) = .{},
|
|
branches: BlockList(Branch) = .{},
|
|
field_accesses: BlockList(FieldAccess) = .{},
|
|
slices: BlockList(Slice) = .{},
|
|
slice_accesses: BlockList(Slice.Access) = .{},
|
|
indexed_accesses: BlockList(IndexedAccess) = .{},
|
|
optional_checks: BlockList(OptionalCheck) = .{},
|
|
optional_unwraps: BlockList(OptionalUnwrap) = .{},
|
|
assembly_blocks: BlockList(Assembly.Block) = .{},
|
|
assembly_instructions: BlockList(Assembly.Instruction) = .{},
|
|
non_primitive_integer_types: data_structures.AutoArrayHashMap(Type.Integer, Type.Index) = .{},
|
|
string_literal_types: data_structures.AutoArrayHashMap(u32, Type.Index) = .{},
|
|
slice_types: data_structures.AutoArrayHashMap(Type.Slice, Type.Index) = .{},
|
|
pointer_types: data_structures.AutoArrayHashMap(Type.Pointer, Type.Index) = .{},
|
|
optional_types: data_structures.AutoArrayHashMap(Type.Index, Type.Index) = .{},
|
|
array_types: data_structures.AutoArrayHashMap(Array, Type.Index) = .{},
|
|
entry_point: Function.Index = Function.Index.invalid,
|
|
descriptor: Descriptor,
|
|
|
|
pub const Descriptor = struct {
|
|
main_package_path: []const u8,
|
|
executable_path: []const u8,
|
|
target: std.Target,
|
|
transpile_to_c: bool,
|
|
};
|
|
|
|
const ImportFileResult = struct {
|
|
ptr: *File,
|
|
index: File.Index,
|
|
is_new: bool,
|
|
};
|
|
|
|
const ImportPackageResult = struct {
|
|
file: ImportFileResult,
|
|
is_package: bool,
|
|
};
|
|
|
|
pub fn importFile(module: *Module, allocator: Allocator, current_file_index: File.Index, import_name: []const u8) !ImportPackageResult {
|
|
logln(.compilation, .import, "import: '{s}'\n", .{import_name});
|
|
if (equal(u8, import_name, "std")) {
|
|
return module.importPackage(allocator, module.main_package.dependencies.get("std").?);
|
|
}
|
|
|
|
if (equal(u8, import_name, "builtin")) {
|
|
return module.importPackage(allocator, module.main_package.dependencies.get("builtin").?);
|
|
}
|
|
|
|
if (equal(u8, import_name, "main")) {
|
|
return module.importPackage(allocator, module.main_package);
|
|
}
|
|
|
|
const current_file = module.files.get(current_file_index);
|
|
if (current_file.package.dependencies.get(import_name)) |package| {
|
|
return module.importPackage(allocator, package);
|
|
}
|
|
|
|
if (!std.mem.endsWith(u8, import_name, ".nat")) {
|
|
unreachable;
|
|
}
|
|
|
|
const current_file_relative_path_to_package_directory = std.fs.path.dirname(current_file.relative_path) orelse "";
|
|
const import_file_relative_path = try std.fs.path.join(allocator, &.{ current_file_relative_path_to_package_directory, import_name });
|
|
const full_path = try std.fs.path.join(allocator, &.{ current_file.package.directory.path, import_file_relative_path });
|
|
const file_relative_path = import_file_relative_path;
|
|
const package = current_file.package;
|
|
const import_file = try module.getFile(allocator, full_path, file_relative_path, package);
|
|
|
|
try import_file.ptr.addFileReference(allocator, current_file);
|
|
|
|
const result = ImportPackageResult{
|
|
.file = import_file,
|
|
.is_package = false,
|
|
};
|
|
|
|
return result;
|
|
}
|
|
|
|
fn getFile(module: *Module, allocator: Allocator, full_path: []const u8, relative_path: []const u8, package: *Package) !ImportFileResult {
|
|
const path_lookup = try module.import_table.getOrPut(allocator, full_path);
|
|
const file, const index = switch (path_lookup.found_existing) {
|
|
true => blk: {
|
|
const result = path_lookup.value_ptr.*;
|
|
const index = module.files.indexOf(result);
|
|
break :blk .{
|
|
result,
|
|
index,
|
|
};
|
|
},
|
|
false => blk: {
|
|
const file_allocation = try module.files.append(allocator, File{
|
|
.relative_path = relative_path,
|
|
.package = package,
|
|
});
|
|
logln(.compilation, .new_file, "Adding file #{}: {s}\n", .{ file_allocation.index.uniqueInteger(), full_path });
|
|
path_lookup.value_ptr.* = file_allocation.ptr;
|
|
// break :blk file;
|
|
break :blk .{
|
|
file_allocation.ptr,
|
|
file_allocation.index,
|
|
};
|
|
},
|
|
};
|
|
|
|
return .{
|
|
.ptr = file,
|
|
.index = index,
|
|
.is_new = !path_lookup.found_existing,
|
|
};
|
|
}
|
|
|
|
pub fn importPackage(module: *Module, allocator: Allocator, package: *Package) !ImportPackageResult {
|
|
const full_path = try std.fs.path.resolve(allocator, &.{ package.directory.path, package.source_path });
|
|
logln(.compilation, .import, "Import full path: {s}\n", .{full_path});
|
|
const import_file = try module.getFile(allocator, full_path, package.source_path, package);
|
|
try import_file.ptr.addPackageReference(allocator, package);
|
|
|
|
return .{
|
|
.file = import_file,
|
|
.is_package = true,
|
|
};
|
|
}
|
|
|
|
pub fn generateAbstractSyntaxTreeForFile(module: *Module, allocator: Allocator, file_index: File.Index) !void {
|
|
const file = module.files.get(file_index);
|
|
const source_file = file.package.directory.handle.openFile(file.relative_path, .{}) catch |err| {
|
|
std.debug.panic("Can't find file {s} in directory {s} for error {s}", .{ file.relative_path, file.package.directory.path, @errorName(err) });
|
|
};
|
|
|
|
const file_size = try source_file.getEndPos();
|
|
var file_buffer = try allocator.alloc(u8, file_size);
|
|
|
|
const read_byte_count = try source_file.readAll(file_buffer);
|
|
assert(read_byte_count == file_size);
|
|
source_file.close();
|
|
|
|
//TODO: adjust file maximum size
|
|
file.source_code = file_buffer[0..read_byte_count];
|
|
file.status = .loaded_into_memory;
|
|
|
|
try file.lex(allocator, file_index);
|
|
try file.parse(allocator, file_index);
|
|
}
|
|
|
|
fn getString(map: *StringKeyMap([]const u8), key: u32) ?[]const u8 {
|
|
return map.getValue(key);
|
|
}
|
|
|
|
fn addString(map: *StringKeyMap([]const u8), allocator: Allocator, string: []const u8) !u32 {
|
|
const lookup_result = try map.getOrPut(allocator, string, string);
|
|
return lookup_result.key;
|
|
}
|
|
|
|
pub fn getName(module: *Module, key: u32) ?[]const u8 {
|
|
return getString(&module.string_table, key);
|
|
}
|
|
|
|
pub fn addName(module: *Module, allocator: Allocator, name: []const u8) !u32 {
|
|
return addString(&module.string_table, allocator, name);
|
|
}
|
|
|
|
pub fn getStringLiteral(module: *Module, key: u32) ?[]const u8 {
|
|
return getString(&module.string_literals, key);
|
|
}
|
|
|
|
pub fn addStringLiteral(module: *Module, allocator: Allocator, string_literal: []const u8) !u32 {
|
|
const result = addString(&module.string_literals, allocator, string_literal);
|
|
|
|
const len: u32 = @intCast(string_literal.len);
|
|
// try analyzer.module.
|
|
const string_literal_type_gop = try module.string_literal_types.getOrPut(allocator, len);
|
|
if (!string_literal_type_gop.found_existing) {
|
|
const array = Array{
|
|
.element_type = Type.u8,
|
|
.element_count = len,
|
|
};
|
|
const array_type_gop = try module.array_types.getOrPut(allocator, array);
|
|
if (!array_type_gop.found_existing) {
|
|
const array_type_allocation = try module.types.append(allocator, .{
|
|
.array = array,
|
|
});
|
|
array_type_gop.value_ptr.* = array_type_allocation.index;
|
|
}
|
|
|
|
const array_type_index = array_type_gop.value_ptr.*;
|
|
const pointer_type_allocation = try module.types.append(allocator, .{
|
|
.pointer = .{
|
|
.@"const" = true,
|
|
.many = true,
|
|
.element_type = array_type_index,
|
|
},
|
|
});
|
|
string_literal_type_gop.value_ptr.* = pointer_type_allocation.index;
|
|
}
|
|
|
|
return result;
|
|
}
|
|
};
|
|
|
|
fn pathFromCwd(compilation: *const Compilation, relative_path: []const u8) ![]const u8 {
|
|
return std.fs.path.join(compilation.base_allocator, &.{ compilation.cwd_absolute_path, relative_path });
|
|
}
|
|
|
|
fn pathFromCompiler(compilation: *const Compilation, relative_path: []const u8) ![]const u8 {
|
|
return std.fs.path.join(compilation.base_allocator, &.{ compilation.directory_absolute_path, relative_path });
|
|
}
|
|
|
|
fn realpathAlloc(allocator: Allocator, pathname: []const u8) ![]const u8 {
|
|
var path_buffer: [std.fs.MAX_PATH_BYTES]u8 = undefined;
|
|
const realpathInStack = try std.os.realpath(pathname, &path_buffer);
|
|
return allocator.dupe(u8, realpathInStack);
|
|
}
|
|
|
|
pub fn compileModule(compilation: *Compilation, descriptor: Module.Descriptor) !void {
|
|
// TODO: generate an actual file
|
|
const builtin_file_name = "builtin.nat";
|
|
var cache_dir = try compilation.build_directory.openDir("cache", .{});
|
|
const builtin_file = try cache_dir.createFile(builtin_file_name, .{});
|
|
try builtin_file.writer().print(
|
|
\\const builtin = #import("std").builtin;
|
|
\\const cpu = builtin.Cpu.{s};
|
|
\\const os = builtin.Os.{s};
|
|
\\const abi = builtin.Abi.{s};
|
|
\\
|
|
, .{
|
|
@tagName(descriptor.target.cpu.arch),
|
|
@tagName(descriptor.target.os.tag),
|
|
@tagName(descriptor.target.abi),
|
|
});
|
|
builtin_file.close();
|
|
|
|
const module: *Module = try compilation.base_allocator.create(Module);
|
|
module.* = Module{
|
|
.main_package = blk: {
|
|
const result = try compilation.base_allocator.create(Package);
|
|
const main_package_absolute_directory_path = try compilation.pathFromCwd(std.fs.path.dirname(descriptor.main_package_path).?);
|
|
result.* = .{
|
|
.directory = .{
|
|
.handle = try std.fs.openDirAbsolute(main_package_absolute_directory_path, .{}),
|
|
.path = main_package_absolute_directory_path,
|
|
},
|
|
.source_path = try compilation.base_allocator.dupe(u8, std.fs.path.basename(descriptor.main_package_path)),
|
|
};
|
|
break :blk result;
|
|
},
|
|
.descriptor = descriptor,
|
|
};
|
|
|
|
const std_package_dir = "lib/std";
|
|
|
|
const package_descriptors = [2]struct {
|
|
name: []const u8,
|
|
directory_path: []const u8,
|
|
}{
|
|
.{
|
|
.name = "std",
|
|
.directory_path = try compilation.pathFromCwd(std_package_dir),
|
|
},
|
|
.{
|
|
.name = "builtin",
|
|
.directory_path = blk: {
|
|
const result = try cache_dir.realpathAlloc(compilation.base_allocator, ".");
|
|
cache_dir.close();
|
|
break :blk result;
|
|
},
|
|
},
|
|
};
|
|
|
|
var packages: [package_descriptors.len]*Package = undefined;
|
|
for (package_descriptors, &packages) |package_descriptor, *package_ptr| {
|
|
const package = try compilation.base_allocator.create(Package);
|
|
package.* = .{
|
|
.directory = .{
|
|
.path = package_descriptor.directory_path,
|
|
.handle = try std.fs.openDirAbsolute(package_descriptor.directory_path, .{}),
|
|
},
|
|
.source_path = try std.mem.concat(compilation.base_allocator, u8, &.{ package_descriptor.name, ".nat" }),
|
|
};
|
|
|
|
try module.main_package.addDependency(compilation.base_allocator, package_descriptor.name, package);
|
|
|
|
package_ptr.* = package;
|
|
}
|
|
|
|
assert(module.main_package.dependencies.size == 2);
|
|
|
|
_ = try module.importPackage(compilation.base_allocator, module.main_package.dependencies.get("std").?);
|
|
|
|
for (module.import_table.values()) |import| {
|
|
try module.generateAbstractSyntaxTreeForFile(compilation.base_allocator, module.files.indexOf(import));
|
|
}
|
|
|
|
inline for (@typeInfo(FixedTypeKeyword).Enum.fields) |enum_field| {
|
|
_ = try module.types.append(compilation.base_allocator, switch (@field(FixedTypeKeyword, enum_field.name)) {
|
|
.usize => @unionInit(Type, "integer", .{
|
|
.bit_count = 64,
|
|
.signedness = .unsigned,
|
|
}),
|
|
.ssize => @unionInit(Type, "integer", .{
|
|
.bit_count = 64,
|
|
.signedness = .signed,
|
|
}),
|
|
else => @unionInit(Type, enum_field.name, {}),
|
|
});
|
|
}
|
|
|
|
inline for (@typeInfo(HardwareUnsignedIntegerType).Enum.fields) |enum_field| {
|
|
_ = try module.types.append(compilation.base_allocator, .{
|
|
.integer = .{
|
|
.signedness = .unsigned,
|
|
.bit_count = switch (@field(HardwareUnsignedIntegerType, enum_field.name)) {
|
|
.u8 => 8,
|
|
.u16 => 16,
|
|
.u32 => 32,
|
|
.u64 => 64,
|
|
},
|
|
},
|
|
});
|
|
}
|
|
|
|
inline for (@typeInfo(HardwareSignedIntegerType).Enum.fields) |enum_field| {
|
|
_ = try module.types.append(compilation.base_allocator, .{
|
|
.integer = .{
|
|
.signedness = .signed,
|
|
.bit_count = switch (@field(HardwareSignedIntegerType, enum_field.name)) {
|
|
.s8 => 8,
|
|
.s16 => 16,
|
|
.s32 => 32,
|
|
.s64 => 64,
|
|
},
|
|
},
|
|
});
|
|
}
|
|
|
|
for (extra_common_type_data) |type_data| {
|
|
_ = try module.types.append(compilation.base_allocator, type_data);
|
|
}
|
|
semantic_analyzer.pointer_to_any_type = (try module.types.append(compilation.base_allocator, .{
|
|
.pointer = .{
|
|
.element_type = Type.any,
|
|
.many = false,
|
|
.@"const" = true,
|
|
},
|
|
})).index;
|
|
semantic_analyzer.optional_pointer_to_any_type = (try module.types.append(compilation.base_allocator, .{
|
|
.optional = .{
|
|
.element_type = semantic_analyzer.pointer_to_any_type,
|
|
},
|
|
})).index;
|
|
semantic_analyzer.optional_any = (try module.types.append(compilation.base_allocator, .{
|
|
.optional = .{
|
|
.element_type = Type.any,
|
|
},
|
|
})).index;
|
|
|
|
semantic_analyzer.unreachable_index = (try module.values.append(compilation.base_allocator, .@"unreachable")).index;
|
|
semantic_analyzer.pointer_null_index = (try module.values.append(compilation.base_allocator, .pointer_null_literal)).index;
|
|
semantic_analyzer.optional_null_index = (try module.values.append(compilation.base_allocator, .optional_null_literal)).index;
|
|
|
|
const value_allocation = try module.values.append(compilation.base_allocator, .{
|
|
.unresolved = .{
|
|
.node_index = .{ .value = 0 },
|
|
},
|
|
});
|
|
|
|
try semantic_analyzer.initialize(compilation, module, packages[0], value_allocation.ptr);
|
|
|
|
if (descriptor.transpile_to_c) {
|
|
try c_transpiler.initialize(compilation, module, descriptor);
|
|
} else {
|
|
unreachable;
|
|
// const ir = try intermediate_representation.initialize(compilation, module);
|
|
//
|
|
// switch (descriptor.target.cpu.arch) {
|
|
// inline else => |arch| try emit.get(arch).initialize(compilation.base_allocator, ir, descriptor),
|
|
// }
|
|
}
|
|
}
|
|
|
|
fn generateAST() !void {}
|
|
|
|
pub const Directory = struct {
|
|
handle: std.fs.Dir,
|
|
path: []const u8,
|
|
};
|
|
|
|
pub const Package = struct {
|
|
directory: Directory,
|
|
/// Relative to the package main directory
|
|
source_path: []const u8,
|
|
dependencies: StringHashMap(*Package) = .{},
|
|
|
|
fn addDependency(package: *Package, allocator: Allocator, package_name: []const u8, new_dependency: *Package) !void {
|
|
try package.dependencies.ensureUnusedCapacity(allocator, 1);
|
|
package.dependencies.putAssumeCapacityNoClobber(package_name, new_dependency);
|
|
}
|
|
};
|
|
|
|
pub const File = struct {
|
|
status: Status = .not_loaded,
|
|
source_code: []const u8 = &.{},
|
|
lexical_analyzer_result: lexical_analyzer.Result = undefined,
|
|
syntactic_analyzer_result: syntactic_analyzer.Result = undefined,
|
|
package_references: ArrayList(*Package) = .{},
|
|
file_references: ArrayList(*File) = .{},
|
|
type: Type.Index = Type.Index.invalid,
|
|
relative_path: []const u8,
|
|
package: *Package,
|
|
|
|
pub const List = BlockList(@This());
|
|
pub const Index = List.Index;
|
|
|
|
const Status = enum {
|
|
not_loaded,
|
|
loaded_into_memory,
|
|
lexed,
|
|
parsed,
|
|
};
|
|
|
|
fn addPackageReference(file: *File, allocator: Allocator, package: *Package) !void {
|
|
for (file.package_references.items) |other| {
|
|
if (other == package) return;
|
|
}
|
|
|
|
try file.package_references.insert(allocator, 0, package);
|
|
}
|
|
|
|
fn addFileReference(file: *File, allocator: Allocator, affected: *File) !void {
|
|
try file.file_references.append(allocator, affected);
|
|
}
|
|
|
|
fn lex(file: *File, allocator: Allocator, file_index: File.Index) !void {
|
|
assert(file.status == .loaded_into_memory);
|
|
file.lexical_analyzer_result = try lexical_analyzer.analyze(allocator, file.source_code, file_index);
|
|
// if (!@import("builtin").is_test) {
|
|
// print("[LEXICAL ANALYSIS] {} ns\n", .{file.lexical_analyzer_result.time});
|
|
// }
|
|
file.status = .lexed;
|
|
}
|
|
|
|
fn parse(file: *File, allocator: Allocator, file_index: File.Index) !void {
|
|
assert(file.status == .lexed);
|
|
file.syntactic_analyzer_result = try syntactic_analyzer.analyze(allocator, file.lexical_analyzer_result.tokens.items, file.source_code, file_index);
|
|
// if (!@import("builtin").is_test) {
|
|
// print("[SYNTACTIC ANALYSIS] {} ns\n", .{file.syntactic_analyzer_result.time});
|
|
// }
|
|
file.status = .parsed;
|
|
}
|
|
};
|
|
|
|
const LoggerScope = enum {
|
|
compilation,
|
|
lexer,
|
|
parser,
|
|
sema,
|
|
ir,
|
|
codegen,
|
|
c,
|
|
};
|
|
|
|
const Logger = enum {
|
|
import,
|
|
new_file,
|
|
arguments,
|
|
var bitset = std.EnumSet(Logger).initEmpty();
|
|
};
|
|
|
|
fn getLoggerScopeType(comptime logger_scope: LoggerScope) type {
|
|
comptime {
|
|
return switch (logger_scope) {
|
|
.compilation => @This(),
|
|
.lexer => lexical_analyzer,
|
|
.parser => syntactic_analyzer,
|
|
.sema => semantic_analyzer,
|
|
.ir => intermediate_representation,
|
|
.codegen => emit,
|
|
.c => c_transpiler,
|
|
};
|
|
}
|
|
}
|
|
|
|
var logger_bitset = std.EnumSet(LoggerScope).initEmpty();
|
|
|
|
var writer = std.io.getStdErr().writer();
|
|
|
|
fn shouldLog(comptime logger_scope: LoggerScope, logger: getLoggerScopeType(logger_scope).Logger) bool {
|
|
return logger_bitset.contains(logger_scope) and getLoggerScopeType(logger_scope).Logger.bitset.contains(logger);
|
|
}
|
|
|
|
pub fn logln(comptime logger_scope: LoggerScope, logger: getLoggerScopeType(logger_scope).Logger, comptime format: []const u8, arguments: anytype) void {
|
|
if (shouldLog(logger_scope, logger)) {
|
|
log(logger_scope, logger, format, arguments);
|
|
writer.writeByte('\n') catch unreachable;
|
|
}
|
|
}
|
|
|
|
pub fn log(comptime logger_scope: LoggerScope, logger: getLoggerScopeType(logger_scope).Logger, comptime format: []const u8, arguments: anytype) void {
|
|
if (shouldLog(logger_scope, logger)) {
|
|
std.fmt.format(writer, format, arguments) catch unreachable;
|
|
}
|
|
}
|
|
|
|
pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, return_address: ?usize) noreturn {
|
|
const print_stack_trace = false;
|
|
switch (print_stack_trace) {
|
|
true => @call(.always_inline, std.builtin.default_panic, .{ message, stack_trace, return_address }),
|
|
false => {
|
|
writer.writeAll("\nPANIC: ") catch {};
|
|
writer.writeAll(message) catch {};
|
|
writer.writeByte('\n') catch {};
|
|
@breakpoint();
|
|
std.os.abort();
|
|
},
|
|
}
|
|
}
|