Compare commits
4 commits
2cb328c3f9
...
a081de93ce
Author | SHA1 | Date | |
---|---|---|---|
a081de93ce | |||
7e41d03eb9 | |||
76d888bde8 | |||
c3d3486163 |
8 changed files with 112 additions and 38 deletions
|
@ -7,8 +7,8 @@ fn f() i32 {
|
|||
return 2;
|
||||
}
|
||||
|
||||
fn f2() i32 {
|
||||
return f() + 2;
|
||||
fn f2() i64 {
|
||||
return 1301;
|
||||
}
|
||||
|
||||
enum B {
|
||||
|
|
|
@ -16,8 +16,13 @@ pub const TypeSolver = struct {
|
|||
err_tok: ?Token = null,
|
||||
hadError: bool = false,
|
||||
|
||||
pub fn init(allocator: *std.mem.Allocator) TypeSolver {
|
||||
return TypeSolver{ .allocator = allocator };
|
||||
err_ctx_buffer: []u8,
|
||||
|
||||
pub fn init(allocator: *std.mem.Allocator) !TypeSolver {
|
||||
return TypeSolver{
|
||||
.allocator = allocator,
|
||||
.err_ctx_buffer = try allocator.alloc(u8, 512),
|
||||
};
|
||||
}
|
||||
|
||||
fn setErrContext(self: *@This(), comptime fmt: ?[]const u8, args: ...) void {
|
||||
|
@ -26,9 +31,11 @@ pub const TypeSolver = struct {
|
|||
return;
|
||||
}
|
||||
|
||||
// TODO allocate buffer on init() and use it
|
||||
var buf = self.allocator.alloc(u8, 256) catch unreachable;
|
||||
self.err_ctx = std.fmt.bufPrint(buf, fmt.?, args) catch unreachable;
|
||||
self.err_ctx = std.fmt.bufPrint(
|
||||
self.err_ctx_buffer,
|
||||
fmt.?,
|
||||
args,
|
||||
) catch unreachable;
|
||||
}
|
||||
|
||||
fn setErrToken(self: *@This(), tok: ?Token) void {
|
||||
|
@ -38,7 +45,7 @@ pub const TypeSolver = struct {
|
|||
fn doError(self: *@This(), comptime fmt: []const u8, args: ...) void {
|
||||
self.hadError = true;
|
||||
|
||||
std.debug.warn("type error");
|
||||
std.debug.warn("analysis error");
|
||||
if (self.err_tok) |tok| {
|
||||
std.debug.warn(" at line {}", tok.line);
|
||||
}
|
||||
|
@ -53,35 +60,41 @@ pub const TypeSolver = struct {
|
|||
}
|
||||
|
||||
/// Resolve a type in global scope
|
||||
/// Properly resolves composite (currently opaque) types to structs/enums.
|
||||
fn resolveGlobalType(
|
||||
self: *@This(),
|
||||
ctx: *comp.CompilationContext,
|
||||
identifier: []const u8,
|
||||
) ?SymbolUnderlyingType {
|
||||
// assume the identifier references a builtin
|
||||
// first, we assume the identifier is for a simple type
|
||||
// if we fail (and this always returns OpaqueType as a fallback),
|
||||
// we take it and find something in global scope
|
||||
var typ = ctx.solveType(identifier);
|
||||
|
||||
switch (typ) {
|
||||
.OpaqueType => |val| {
|
||||
// solve for opaque so it isnt opaque
|
||||
var sym = ctx.symbol_table.get(val);
|
||||
if (sym != null)
|
||||
return switch (sym.?.value) {
|
||||
.Struct => SymbolUnderlyingType{ .Struct = val },
|
||||
.Enum => SymbolUnderlyingType{ .Enum = val },
|
||||
|
||||
else => blk: {
|
||||
self.doError(
|
||||
"expected struct or enum for type '{}', got {}",
|
||||
val,
|
||||
sym,
|
||||
);
|
||||
break :blk null;
|
||||
},
|
||||
};
|
||||
if (sym == null) {
|
||||
self.doError("Unknown type: '{}'", val);
|
||||
return null;
|
||||
}
|
||||
|
||||
self.doError("Unknown type: '{}'", val);
|
||||
return null;
|
||||
return switch (sym.?.value) {
|
||||
.Struct => SymbolUnderlyingType{ .Struct = val },
|
||||
.Enum => SymbolUnderlyingType{ .Enum = val },
|
||||
|
||||
// TODO name resolution
|
||||
|
||||
else => blk: {
|
||||
self.doError(
|
||||
"expected struct or enum for '{}', got {}",
|
||||
val,
|
||||
@tagName(comp.SymbolType(sym.?.value)),
|
||||
);
|
||||
break :blk null;
|
||||
},
|
||||
};
|
||||
},
|
||||
|
||||
else => return typ,
|
||||
|
@ -102,6 +115,7 @@ pub const TypeSolver = struct {
|
|||
}
|
||||
}
|
||||
|
||||
/// Compare if the given type names are equal.
|
||||
fn compositeIdentifierEqual(
|
||||
self: *@This(),
|
||||
typ_enum: comp.SymbolUnderlyingTypeEnum,
|
||||
|
@ -195,7 +209,9 @@ pub const TypeSolver = struct {
|
|||
.Bool => SymbolUnderlyingType{ .Bool = {} },
|
||||
|
||||
// TODO determine its i64 depending of parseInt results
|
||||
.Integer => SymbolUnderlyingType{ .Integer32 = {} },
|
||||
.Integer32 => SymbolUnderlyingType{ .Integer32 = {} },
|
||||
.Integer64 => SymbolUnderlyingType{ .Integer64 = {} },
|
||||
.Float => SymbolUnderlyingType{ .Double = {} },
|
||||
|
||||
else => unreachable,
|
||||
};
|
|
@ -83,7 +83,10 @@ pub const UnaryExpr = struct {
|
|||
|
||||
pub const LiteralExpr = union(enum) {
|
||||
Bool: bool,
|
||||
Integer: []const u8,
|
||||
|
||||
Integer32: i32,
|
||||
Integer64: i64,
|
||||
|
||||
Float: []const u8,
|
||||
String: []const u8,
|
||||
Array: ExprList,
|
||||
|
|
|
@ -227,7 +227,8 @@ pub fn printExpr(expr: *const Expr) void {
|
|||
.Literal => |literal| {
|
||||
switch (literal) {
|
||||
.Bool => |val| std.debug.warn("{}", val),
|
||||
.Integer => |val| std.debug.warn("{}", val),
|
||||
.Integer32 => |val| std.debug.warn("{}", val),
|
||||
.Integer64 => |val| std.debug.warn("{}", val),
|
||||
.Float => |val| std.debug.warn("{}", val),
|
||||
.String => |val| std.debug.warn("'{}'", val),
|
||||
.Array => |exprs| {
|
||||
|
@ -362,6 +363,7 @@ fn prettyType(typ: SymbolUnderlyingType) []const u8 {
|
|||
.Integer32 => "i32",
|
||||
.Integer64 => "i64",
|
||||
.Bool => "bool",
|
||||
.Double => "double",
|
||||
|
||||
.OpaqueType => |ident| retWithName("opaque", ident),
|
||||
.Struct => |ident| retWithName("struct", ident),
|
||||
|
|
|
@ -2,7 +2,7 @@ const std = @import("std");
|
|||
const ast = @import("ast.zig");
|
||||
const llvm = @import("llvm.zig");
|
||||
const comp = @import("comp_ctx.zig");
|
||||
const types = @import("types.zig");
|
||||
// const analysis = @import("analysis.zig");
|
||||
|
||||
fn sliceify(non_slice: ?[*]const u8) []const u8 {
|
||||
if (non_slice == null) return "";
|
||||
|
@ -85,10 +85,17 @@ pub const Codegen = struct {
|
|||
.Literal => |literal| blk: {
|
||||
break :blk switch (literal) {
|
||||
// TODO other literals
|
||||
.Integer => |val| blk2: {
|
||||
var val_cstr = try std.cstr.addNullByte(self.allocator, val);
|
||||
break :blk2 llvm.LLVMConstIntOfString(llvm.LLVMInt32Type(), val_cstr.ptr, 10);
|
||||
},
|
||||
.Integer32 => |val| llvm.LLVMConstInt(
|
||||
llvm.LLVMInt32Type(),
|
||||
@intCast(c_ulonglong, val),
|
||||
10,
|
||||
),
|
||||
.Integer64 => |val| llvm.LLVMConstInt(
|
||||
llvm.LLVMInt64Type(),
|
||||
@intCast(c_ulonglong, val),
|
||||
10,
|
||||
),
|
||||
|
||||
.Float => |val| blk2: {
|
||||
var val_cstr = try std.cstr.addNullByte(self.allocator, val);
|
||||
break :blk2 llvm.LLVMConstRealOfString(llvm.LLVMDoubleType(), val_cstr.ptr);
|
||||
|
|
|
@ -9,6 +9,7 @@ pub const TypeList = std.ArrayList(SymbolUnderlyingType);
|
|||
pub const SymbolUnderlyingTypeEnum = enum {
|
||||
Integer32,
|
||||
Integer64,
|
||||
Double,
|
||||
Bool,
|
||||
|
||||
// opaque unsolved identifier
|
||||
|
@ -22,6 +23,7 @@ pub const SymbolUnderlyingTypeEnum = enum {
|
|||
pub const SymbolUnderlyingType = union(SymbolUnderlyingTypeEnum) {
|
||||
Integer32: void,
|
||||
Integer64: void,
|
||||
Double: void,
|
||||
Bool: void,
|
||||
OpaqueType: []const u8,
|
||||
|
||||
|
|
|
@ -4,7 +4,7 @@ const scanners = @import("scanners.zig");
|
|||
const parsers = @import("parsers.zig");
|
||||
const printer = @import("ast_printer.zig");
|
||||
const codegen = @import("codegen.zig");
|
||||
const types = @import("types.zig");
|
||||
const analysis = @import("analysis.zig");
|
||||
|
||||
pub const Result = enum {
|
||||
Ok,
|
||||
|
@ -50,7 +50,7 @@ pub fn run(allocator: *std.mem.Allocator, slice: []const u8) !Result {
|
|||
std.debug.warn("parse tree\n");
|
||||
printer.printNode(root, 0);
|
||||
|
||||
var solver = types.TypeSolver.init(allocator);
|
||||
var solver = try analysis.TypeSolver.init(allocator);
|
||||
var ctx = try solver.pass(root);
|
||||
|
||||
std.debug.warn("symbol table\n");
|
||||
|
|
|
@ -14,6 +14,7 @@ const TokenType = tokens.TokenType;
|
|||
pub const ParseError = error{
|
||||
CompileError,
|
||||
UnknownOperator,
|
||||
InvalidInteger,
|
||||
};
|
||||
|
||||
const Node = ast.Node;
|
||||
|
@ -356,11 +357,22 @@ pub const Parser = struct {
|
|||
return expr;
|
||||
}
|
||||
|
||||
fn mkInteger(self: *Parser, val: []const u8) !*ast.Expr {
|
||||
fn mkInt32(self: *Parser, val: i32) !*ast.Expr {
|
||||
var expr = try self.allocator.create(Expr);
|
||||
expr.* = Expr{
|
||||
.Literal = ast.LiteralExpr{
|
||||
.Integer = val,
|
||||
.Integer32 = val,
|
||||
},
|
||||
};
|
||||
|
||||
return expr;
|
||||
}
|
||||
|
||||
fn mkInt64(self: *Parser, val: i64) !*ast.Expr {
|
||||
var expr = try self.allocator.create(Expr);
|
||||
expr.* = Expr{
|
||||
.Literal = ast.LiteralExpr{
|
||||
.Integer64 = val,
|
||||
},
|
||||
};
|
||||
|
||||
|
@ -1124,8 +1136,40 @@ pub const Parser = struct {
|
|||
.False => try self.mkBool(false),
|
||||
.True => try self.mkBool(true),
|
||||
|
||||
.Integer => try self.mkInteger(lexeme),
|
||||
.Integer => blk: {
|
||||
// hacky, but it works. the old approach was doing
|
||||
// parseInt(i64) on the catch block of parseInt(i32)
|
||||
var i32_num_opt: ?i32 = std.fmt.parseInt(i32, lexeme, 10) catch null;
|
||||
var i64_num: i64 = std.fmt.parseInt(i64, lexeme, 10) catch |err| {
|
||||
return self.doError(
|
||||
"Invalid integer (not 32bit or 64bit) '{}': {}",
|
||||
lexeme,
|
||||
err,
|
||||
);
|
||||
};
|
||||
|
||||
if (i32_num_opt) |i32_num| {
|
||||
break :blk try self.mkInt32(i32_num);
|
||||
} else {
|
||||
break :blk try self.mkInt64(i64_num);
|
||||
}
|
||||
|
||||
// old one
|
||||
|
||||
//break :blk try self.mkInt32(std.fmt.parseInt(i32, lexeme, 10) catch |err32| {
|
||||
// break :blk try self.mkInt64(std.fmt.parseInt(i64, lexeme, 10) catch |err64| {
|
||||
// return self.doError(
|
||||
// "Invalid integer (not 32bit or 64bit) '{}': {}",
|
||||
// lexeme,
|
||||
// err64,
|
||||
// );
|
||||
// });
|
||||
//});
|
||||
},
|
||||
|
||||
// TODO std.fmt.parseFloat
|
||||
.Float => try self.mkFloat(lexeme),
|
||||
|
||||
.String => try self.mkString(lexeme),
|
||||
.Identifier => try self.mkVariable(self.peek()),
|
||||
|
||||
|
|
Loading…
Reference in a new issue