feat: semantics for if statements and multi-prong if statements
This commit is contained in:
Brett Broadhurst
parent
9658c8a308
commit
ce5385ebac
6 changed files with 553 additions and 317 deletions
612
src/AstGen.zig
612
src/AstGen.zig
|
|
@ -40,6 +40,11 @@ const Scope = struct {
|
|||
astgen: *AstGen,
|
||||
decls: std.AutoHashMapUnmanaged(Ir.NullTerminatedString, Decl),
|
||||
|
||||
pub const Decl = struct {
|
||||
decl_node: *const Ast.Node,
|
||||
inst_index: Ir.Inst.Index,
|
||||
};
|
||||
|
||||
pub fn deinit(self: *Scope) void {
|
||||
const gpa = self.astgen.gpa;
|
||||
self.decls.deinit(gpa);
|
||||
|
|
@ -75,13 +80,18 @@ const GenIr = struct {
|
|||
|
||||
const unstacked_top = std.math.maxInt(usize);
|
||||
|
||||
pub fn unstack(self: *GenIr) void {
|
||||
fn unstack(self: *GenIr) void {
|
||||
if (self.instructions_top != unstacked_top) {
|
||||
self.instructions.items.len = self.instructions_top;
|
||||
self.instructions_top = unstacked_top;
|
||||
}
|
||||
}
|
||||
|
||||
fn isEmpty(self: *const GenIr) bool {
|
||||
return (self.instructions_top == unstacked_top) or
|
||||
(self.instructions.items.len == self.instructions_top);
|
||||
}
|
||||
|
||||
fn instructionsSlice(self: *const GenIr) []Ir.Inst.Index {
|
||||
return if (self.instructions_top == unstacked_top)
|
||||
&[0]Ir.Inst.Index{}
|
||||
|
|
@ -89,6 +99,18 @@ const GenIr = struct {
|
|||
self.instructions.items[self.instructions_top..];
|
||||
}
|
||||
|
||||
fn instructionsSliceUpto(
|
||||
self: *const GenIr,
|
||||
stacked_block: *const GenIr,
|
||||
) []Ir.Inst.Index {
|
||||
return if (self.instructions_top == unstacked_top)
|
||||
&[0]Ir.Inst.Index{}
|
||||
else if (self.instructions == stacked_block.instructions and stacked_block.instructions_top != unstacked_top)
|
||||
self.instructions.items[self.instructions_top..stacked_block.instructions_top]
|
||||
else
|
||||
self.instructions.items[self.instructions_top..];
|
||||
}
|
||||
|
||||
fn fail(
|
||||
self: *GenIr,
|
||||
tag: Ast.Error.Tag,
|
||||
|
|
@ -97,7 +119,7 @@ const GenIr = struct {
|
|||
return self.astgen.fail(tag, node);
|
||||
}
|
||||
|
||||
pub fn makeSubBlock(self: *GenIr) GenIr {
|
||||
fn makeSubBlock(self: *GenIr) GenIr {
|
||||
return .{
|
||||
.astgen = self.astgen,
|
||||
.instructions = self.instructions,
|
||||
|
|
@ -105,7 +127,7 @@ const GenIr = struct {
|
|||
};
|
||||
}
|
||||
|
||||
pub fn add(gi: *GenIr, inst: Ir.Inst) !Ir.Inst.Index {
|
||||
fn add(gi: *GenIr, inst: Ir.Inst) !Ir.Inst.Index {
|
||||
const gpa = gi.astgen.gpa;
|
||||
try gi.instructions.ensureUnusedCapacity(gpa, 1);
|
||||
try gi.astgen.instructions.ensureUnusedCapacity(gpa, 1);
|
||||
|
|
@ -116,53 +138,38 @@ const GenIr = struct {
|
|||
return inst_index;
|
||||
}
|
||||
|
||||
pub fn addInt(gi: *GenIr, value: u64) !Ir.Inst.Index {
|
||||
return add(gi, .{
|
||||
.tag = .integer,
|
||||
.data = .{ .integer = .{
|
||||
.value = value,
|
||||
} },
|
||||
});
|
||||
fn addInt(gi: *GenIr, value: u64) !Ir.Inst.Index {
|
||||
return add(gi, .{ .tag = .integer, .data = .{
|
||||
.integer = .{ .value = value },
|
||||
} });
|
||||
}
|
||||
|
||||
pub fn addUnaryNode(
|
||||
gi: *GenIr,
|
||||
tag: Ir.Inst.Tag,
|
||||
arg: Ir.Inst.Index,
|
||||
) !Ir.Inst.Index {
|
||||
return add(gi, .{
|
||||
.tag = tag,
|
||||
.data = .{ .un = .{
|
||||
.lhs = arg,
|
||||
} },
|
||||
});
|
||||
fn addUnaryNode(gi: *GenIr, tag: Ir.Inst.Tag, arg: Ir.Inst.Index) !Ir.Inst.Index {
|
||||
return add(gi, .{ .tag = tag, .data = .{
|
||||
.un = .{ .lhs = arg },
|
||||
} });
|
||||
}
|
||||
|
||||
pub fn addBinaryNode(
|
||||
fn addBinaryNode(
|
||||
gi: *GenIr,
|
||||
tag: Ir.Inst.Tag,
|
||||
lhs: Ir.Inst.Index,
|
||||
rhs: Ir.Inst.Index,
|
||||
) !Ir.Inst.Index {
|
||||
return add(gi, .{
|
||||
.tag = tag,
|
||||
.data = .{ .bin = .{
|
||||
.lhs = lhs,
|
||||
.rhs = rhs,
|
||||
} },
|
||||
});
|
||||
return add(gi, .{ .tag = tag, .data = .{
|
||||
.bin = .{ .lhs = lhs, .rhs = rhs },
|
||||
} });
|
||||
}
|
||||
|
||||
pub fn addDeclRef(gi: *GenIr, decl_ref: Ir.NullTerminatedString) !Ir.Inst.Index {
|
||||
return add(gi, .{
|
||||
.tag = .decl_ref,
|
||||
.data = .{ .string = .{
|
||||
fn addDeclRef(gi: *GenIr, decl_ref: Ir.NullTerminatedString) !Ir.Inst.Index {
|
||||
return add(gi, .{ .tag = .decl_ref, .data = .{
|
||||
.string = .{
|
||||
.start = decl_ref,
|
||||
} },
|
||||
});
|
||||
},
|
||||
} });
|
||||
}
|
||||
|
||||
pub fn makePayloadNode(gi: *GenIr, tag: Ir.Inst.Tag) !Ir.Inst.Index {
|
||||
fn makePayloadNode(gi: *GenIr, tag: Ir.Inst.Tag) !Ir.Inst.Index {
|
||||
const gpa = gi.astgen.gpa;
|
||||
const inst_index: Ir.Inst.Index = @enumFromInt(gi.astgen.instructions.items.len);
|
||||
try gi.astgen.instructions.append(gpa, .{
|
||||
|
|
@ -174,80 +181,113 @@ const GenIr = struct {
|
|||
return inst_index;
|
||||
}
|
||||
|
||||
pub fn makeDeclaration(gi: *GenIr) !Ir.Inst.Index {
|
||||
fn makeDeclaration(gi: *GenIr) !Ir.Inst.Index {
|
||||
return makePayloadNode(gi, .declaration);
|
||||
}
|
||||
|
||||
pub fn makeBlockInst(gi: *GenIr) !Ir.Inst.Index {
|
||||
fn makeBlockInst(gi: *GenIr) !Ir.Inst.Index {
|
||||
return makePayloadNode(gi, .block);
|
||||
}
|
||||
|
||||
pub fn addKnot(gi: *GenIr) !Ir.Inst.Index {
|
||||
const astgen = gi.astgen;
|
||||
const gpa = astgen.gpa;
|
||||
const body = gi.instructionsSlice();
|
||||
fn addKnot(self: *GenIr) !Ir.Inst.Index {
|
||||
const gpa = self.astgen.gpa;
|
||||
const body = self.instructionsSlice();
|
||||
const extra_len = @typeInfo(Ir.Inst.Knot).@"struct".fields.len + body.len;
|
||||
try astgen.extra.ensureUnusedCapacity(gpa, extra_len);
|
||||
try self.astgen.extra.ensureUnusedCapacity(gpa, extra_len);
|
||||
|
||||
const knot_node = try makePayloadNode(gi, .decl_knot);
|
||||
const inst_data = &astgen.instructions.items[@intFromEnum(knot_node)].data;
|
||||
inst_data.payload.payload_index = astgen.addExtraAssumeCapacity(
|
||||
const knot_node = try makePayloadNode(self, .decl_knot);
|
||||
const inst_data = &self.astgen.instructions.items[@intFromEnum(knot_node)].data;
|
||||
inst_data.payload.payload_index = self.astgen.addExtraAssumeCapacity(
|
||||
Ir.Inst.Knot{ .body_len = @intCast(body.len) },
|
||||
);
|
||||
|
||||
for (body) |inst_index| {
|
||||
astgen.extra.appendAssumeCapacity(@intFromEnum(inst_index));
|
||||
}
|
||||
self.astgen.appendBlockBody(body);
|
||||
return knot_node;
|
||||
}
|
||||
|
||||
pub fn addVar(gi: *GenIr) !Ir.Inst.Index {
|
||||
const astgen = gi.astgen;
|
||||
const gpa = astgen.gpa;
|
||||
const new_index: Ir.Inst.Index = @enumFromInt(astgen.instructions.items.len);
|
||||
|
||||
try astgen.instructions.ensureUnusedCapacity(gpa, 1);
|
||||
try gi.instructions.ensureUnusedCapacity(gpa, 1);
|
||||
|
||||
gi.astgen.instructions.appendAssumeCapacity(.{
|
||||
.tag = .decl_var,
|
||||
.data = .{
|
||||
.payload = .{ .payload_index = undefined },
|
||||
},
|
||||
});
|
||||
|
||||
const body = gi.instructionsSlice();
|
||||
fn addVar(self: *GenIr) !Ir.Inst.Index {
|
||||
const gpa = self.astgen.gpa;
|
||||
const new_index: Ir.Inst.Index = @enumFromInt(self.astgen.instructions.items.len);
|
||||
const body = self.instructionsSlice();
|
||||
const extra_len = @typeInfo(Ir.Inst.Var).@"struct".fields.len + body.len;
|
||||
try astgen.extra.ensureUnusedCapacity(gpa, extra_len);
|
||||
try self.astgen.extra.ensureUnusedCapacity(gpa, extra_len);
|
||||
try self.astgen.instructions.ensureUnusedCapacity(gpa, 1);
|
||||
try self.instructions.ensureUnusedCapacity(gpa, 1);
|
||||
|
||||
const inst_data = &astgen.instructions.items[@intFromEnum(new_index)].data;
|
||||
inst_data.payload.payload_index = astgen.addExtraAssumeCapacity(
|
||||
Ir.Inst.Var{ .body_len = @intCast(body.len) },
|
||||
);
|
||||
self.astgen.instructions.appendAssumeCapacity(.{ .tag = .decl_var, .data = .{
|
||||
.payload = .{ .payload_index = self.astgen.addExtraAssumeCapacity(
|
||||
Ir.Inst.Var{ .body_len = @intCast(body.len) },
|
||||
) },
|
||||
} });
|
||||
|
||||
for (body) |inst_index| {
|
||||
astgen.extra.appendAssumeCapacity(@intFromEnum(inst_index));
|
||||
}
|
||||
|
||||
gi.instructions.appendAssumeCapacity(new_index);
|
||||
self.astgen.appendBlockBody(body);
|
||||
self.instructions.appendAssumeCapacity(new_index);
|
||||
return new_index;
|
||||
}
|
||||
|
||||
pub fn setBlockBody(gi: *GenIr, inst: Ir.Inst.Index) !void {
|
||||
const astgen = gi.astgen;
|
||||
const gpa = astgen.gpa;
|
||||
const body = gi.instructionsSlice();
|
||||
const extra_len = @typeInfo(Ir.Inst.Block).@"struct".fields.len + body.len;
|
||||
try astgen.extra.ensureUnusedCapacity(gpa, extra_len);
|
||||
fn addCondBr(self: *GenIr, tag: Ir.Inst.Tag) !Ir.Inst.Index {
|
||||
const gpa = self.astgen.gpa;
|
||||
try self.instructions.ensureUnusedCapacity(gpa, 1);
|
||||
try self.astgen.instructions.ensureUnusedCapacity(gpa, 1);
|
||||
|
||||
const inst_data = &astgen.instructions.items[@intFromEnum(inst)].data;
|
||||
inst_data.payload.payload_index = astgen.addExtraAssumeCapacity(
|
||||
const new_index: Ir.Inst.Index = @enumFromInt(self.astgen.instructions.items.len);
|
||||
self.astgen.instructions.appendAssumeCapacity(.{
|
||||
.tag = tag,
|
||||
.data = .{ .payload = .{
|
||||
.payload_index = undefined,
|
||||
} },
|
||||
});
|
||||
self.instructions.appendAssumeCapacity(new_index);
|
||||
return new_index;
|
||||
}
|
||||
|
||||
fn addBreak(
|
||||
self: *GenIr,
|
||||
tag: Ir.Inst.Tag,
|
||||
block_inst: Ir.Inst.Index,
|
||||
) !Ir.Inst.Index {
|
||||
const gpa = self.astgen.gpa;
|
||||
try self.instructions.ensureUnusedCapacity(gpa, 1);
|
||||
|
||||
const new_index = try self.makeBreak(tag, block_inst);
|
||||
self.instructions.appendAssumeCapacity(new_index);
|
||||
return new_index;
|
||||
}
|
||||
|
||||
fn makeBreak(
|
||||
self: *GenIr,
|
||||
tag: Ir.Inst.Tag,
|
||||
block_inst: Ir.Inst.Index,
|
||||
) !Ir.Inst.Index {
|
||||
const gpa = self.astgen.gpa;
|
||||
const extra_len = @typeInfo(Ir.Inst.Break).@"struct".fields.len;
|
||||
try self.astgen.instructions.ensureUnusedCapacity(gpa, 1);
|
||||
try self.astgen.extra.ensureUnusedCapacity(gpa, extra_len);
|
||||
|
||||
const new_index: Ir.Inst.Index = @enumFromInt(self.astgen.instructions.items.len);
|
||||
self.astgen.instructions.appendAssumeCapacity(.{
|
||||
.tag = tag,
|
||||
.data = .{ .payload = .{
|
||||
.payload_index = self.astgen.addExtraAssumeCapacity(
|
||||
Ir.Inst.Break{ .block_inst = block_inst },
|
||||
),
|
||||
} },
|
||||
});
|
||||
return new_index;
|
||||
}
|
||||
|
||||
fn setBlockBody(self: *GenIr, inst: Ir.Inst.Index) !void {
|
||||
const gpa = self.astgen.gpa;
|
||||
const body = self.instructionsSlice();
|
||||
const extra_len = @typeInfo(Ir.Inst.Block).@"struct".fields.len + body.len;
|
||||
try self.astgen.extra.ensureUnusedCapacity(gpa, extra_len);
|
||||
|
||||
const inst_data = &self.astgen.instructions.items[@intFromEnum(inst)].data;
|
||||
inst_data.payload.payload_index = self.astgen.addExtraAssumeCapacity(
|
||||
Ir.Inst.Block{ .body_len = @intCast(body.len) },
|
||||
);
|
||||
for (body) |inst_index| {
|
||||
astgen.extra.appendAssumeCapacity(@intFromEnum(inst_index));
|
||||
}
|
||||
gi.unstack();
|
||||
self.astgen.appendBlockBody(body);
|
||||
self.unstack();
|
||||
}
|
||||
};
|
||||
|
||||
|
|
@ -289,6 +329,36 @@ fn setDeclaration(
|
|||
args.body_gi.unstack();
|
||||
}
|
||||
|
||||
fn setCondBrPayload(
|
||||
condbr: Ir.Inst.Index,
|
||||
cond: Ir.Inst.Index,
|
||||
then_block: *GenIr,
|
||||
else_block: *GenIr,
|
||||
) !void {
|
||||
defer then_block.unstack();
|
||||
defer else_block.unstack();
|
||||
const astgen = then_block.astgen;
|
||||
const then_body = then_block.instructionsSliceUpto(else_block);
|
||||
const else_body = else_block.instructionsSlice();
|
||||
const then_body_len = then_body.len;
|
||||
const else_body_len = else_body.len;
|
||||
const extra_len =
|
||||
@typeInfo(Ir.Inst.CondBr).@"struct".fields.len + then_body_len + else_body_len;
|
||||
try astgen.extra.ensureUnusedCapacity(astgen.gpa, extra_len);
|
||||
|
||||
const inst_data = &astgen.instructions.items[@intFromEnum(condbr)].data;
|
||||
inst_data.payload.payload_index = astgen.addExtraAssumeCapacity(
|
||||
Ir.Inst.CondBr{
|
||||
.condition = cond,
|
||||
.then_body_len = @intCast(then_body_len),
|
||||
.else_body_len = @intCast(else_body_len),
|
||||
},
|
||||
);
|
||||
|
||||
astgen.appendBlockBody(then_body);
|
||||
astgen.appendBlockBody(else_body);
|
||||
}
|
||||
|
||||
fn addExtraAssumeCapacity(astgen: *AstGen, extra: anytype) u32 {
|
||||
const fields = std.meta.fields(@TypeOf(extra));
|
||||
const extra_index: u32 = @intCast(astgen.extra.items.len);
|
||||
|
|
@ -329,6 +399,12 @@ fn fail(
|
|||
return error.SemanticError;
|
||||
}
|
||||
|
||||
fn appendBlockBody(self: *AstGen, body: []const Ir.Inst.Index) void {
|
||||
for (body) |inst_index| {
|
||||
self.extra.appendAssumeCapacity(@intFromEnum(inst_index));
|
||||
}
|
||||
}
|
||||
|
||||
fn sliceFromNode(astgen: *const AstGen, node: *const Ast.Node) []const u8 {
|
||||
assert(node.loc.start <= node.loc.end);
|
||||
const source_bytes = astgen.tree.source;
|
||||
|
|
@ -454,39 +530,79 @@ fn identifier(gi: *GenIr, scope: *Scope, node: *const Ast.Node) InnerError!Ir.In
|
|||
return gi.addDeclRef(str);
|
||||
}
|
||||
|
||||
fn expr(gen: *GenIr, scope: *Scope, optional_expr: ?*const Ast.Node) InnerError!Ir.Inst.Index {
|
||||
fn expr(block: *GenIr, scope: *Scope, optional_expr: ?*const Ast.Node) InnerError!Ir.Inst.Index {
|
||||
const expr_node = optional_expr orelse unreachable;
|
||||
switch (expr_node.tag) {
|
||||
.true_literal => return trueLiteral(gen),
|
||||
.false_literal => return falseLiteral(gen),
|
||||
.number_literal => return numberLiteral(gen, expr_node),
|
||||
.string_literal => return stringLiteral(gen, expr_node),
|
||||
.string_expr => return stringExpr(gen, expr_node),
|
||||
.identifier => return identifier(gen, scope, expr_node),
|
||||
.add_expr => return binaryOp(gen, scope, expr_node, .add),
|
||||
.subtract_expr => return binaryOp(gen, scope, expr_node, .sub),
|
||||
.multiply_expr => return binaryOp(gen, scope, expr_node, .mul),
|
||||
.divide_expr => return binaryOp(gen, scope, expr_node, .div),
|
||||
.mod_expr => return binaryOp(gen, scope, expr_node, .mod),
|
||||
.negate_expr => return unaryOp(gen, scope, expr_node, .neg),
|
||||
//.logical_and_expr => return logicalOp(gen, scope, expr_node, .jmp_f),
|
||||
//.logical_or_expr => return logicalOp(gen, scope, expr_node, .jmp_t),
|
||||
//.logical_not_expr => return unaryOp(gen, scope, expr_node, .not),
|
||||
//.logical_equality_expr => return binaryOp(gen, scope, expr_node, .cmp_eq),
|
||||
//.logical_inequality_expr => {
|
||||
// return binaryOp(gen, scope, expr_node, .cmp_eq);
|
||||
//},
|
||||
//.logical_greater_expr => return binaryOp(gen, scope, expr_node, .cmp_gt),
|
||||
//.logical_greater_or_equal_expr => return binaryOp(gen, scope, expr_node, .cmp_gte),
|
||||
//.logical_lesser_expr => return binaryOp(gen, scope, expr_node, .cmp_lt),
|
||||
//.logical_lesser_or_equal_expr => return binaryOp(gen, scope, expr_node, .cmp_lte),
|
||||
else => unreachable,
|
||||
.file => unreachable,
|
||||
.true_literal => return trueLiteral(block),
|
||||
.false_literal => return falseLiteral(block),
|
||||
.number_literal => return numberLiteral(block, expr_node),
|
||||
.string_literal => return stringLiteral(block, expr_node),
|
||||
.string_expr => return stringExpr(block, expr_node),
|
||||
.empty_string => return stringLiteral(block, expr_node),
|
||||
.identifier => return identifier(block, scope, expr_node),
|
||||
.add_expr => return binaryOp(block, scope, expr_node, .add),
|
||||
.subtract_expr => return binaryOp(block, scope, expr_node, .sub),
|
||||
.multiply_expr => return binaryOp(block, scope, expr_node, .mul),
|
||||
.divide_expr => return binaryOp(block, scope, expr_node, .div),
|
||||
.mod_expr => return binaryOp(block, scope, expr_node, .mod),
|
||||
.negate_expr => return unaryOp(block, scope, expr_node, .neg),
|
||||
.logical_and_expr => unreachable,
|
||||
.logical_or_expr => unreachable,
|
||||
.logical_not_expr => return unaryOp(block, scope, expr_node, .not),
|
||||
.logical_equality_expr => return binaryOp(block, scope, expr_node, .cmp_eq),
|
||||
.logical_inequality_expr => return binaryOp(block, scope, expr_node, .cmp_neq),
|
||||
.logical_greater_expr => return binaryOp(block, scope, expr_node, .cmp_gt),
|
||||
.logical_greater_or_equal_expr => return binaryOp(block, scope, expr_node, .cmp_gte),
|
||||
.logical_lesser_expr => return binaryOp(block, scope, expr_node, .cmp_lt),
|
||||
.logical_lesser_or_equal_expr => return binaryOp(block, scope, expr_node, .cmp_lte),
|
||||
.call_expr => unreachable,
|
||||
.choice_expr => unreachable,
|
||||
.choice_start_expr => unreachable,
|
||||
.choice_option_expr => unreachable,
|
||||
.choice_inner_expr => unreachable,
|
||||
.divert_expr => unreachable,
|
||||
.selector_expr => unreachable,
|
||||
.assign_stmt => unreachable,
|
||||
.block_stmt => unreachable,
|
||||
.content_stmt => unreachable,
|
||||
.divert_stmt => unreachable,
|
||||
.return_stmt => unreachable,
|
||||
.expr_stmt => unreachable,
|
||||
.choice_stmt => unreachable,
|
||||
.choice_star_stmt => unreachable,
|
||||
.choice_plus_stmt => unreachable,
|
||||
.gather_point_stmt => unreachable,
|
||||
.gathered_stmt => unreachable,
|
||||
.function_prototype => unreachable,
|
||||
.stitch_prototype => unreachable,
|
||||
.knot_prototype => unreachable,
|
||||
.function_decl => unreachable,
|
||||
.stitch_decl => unreachable,
|
||||
.knot_decl => unreachable,
|
||||
.const_decl => unreachable,
|
||||
.var_decl => unreachable,
|
||||
.list_decl => unreachable,
|
||||
.temp_decl => unreachable,
|
||||
.parameter_decl => unreachable,
|
||||
.ref_parameter_decl => unreachable,
|
||||
.argument_list => unreachable,
|
||||
.parameter_list => unreachable,
|
||||
.switch_stmt => unreachable,
|
||||
.switch_case => unreachable,
|
||||
.if_stmt => unreachable,
|
||||
.multi_if_stmt => unreachable,
|
||||
.if_branch => unreachable,
|
||||
.else_branch => unreachable,
|
||||
.content => unreachable,
|
||||
.inline_logic_expr => unreachable,
|
||||
.invalid => unreachable,
|
||||
}
|
||||
}
|
||||
|
||||
fn exprStmt(gen: *GenIr, scope: *Scope, stmt_node: *const Ast.Node) InnerError!Ir.Inst.Index {
|
||||
// TODO: Maybe we should introduce a unary node type to avoid optional checks?
|
||||
const expr_node = stmt_node.data.bin.lhs orelse unreachable;
|
||||
const expr_node = stmt_node.data.bin.lhs.?;
|
||||
return expr(gen, scope, expr_node);
|
||||
}
|
||||
|
||||
|
|
@ -517,125 +633,6 @@ fn validateSwitchProngs(gen: *GenIr, stmt_node: *const Ast.Node) InnerError!void
|
|||
}
|
||||
}
|
||||
|
||||
fn ifStmt(gen: *GenIr, parent_scope: *Scope, stmt_node: *const Ast.Node) InnerError!void {
|
||||
const case_list = stmt_node.data.switch_stmt.cases;
|
||||
const eval_expr = stmt_node.data.switch_stmt.condition_expr;
|
||||
if (eval_expr) |expr_node| {
|
||||
try validateSwitchProngs(gen, stmt_node);
|
||||
|
||||
const first_prong = case_list[0];
|
||||
const last_prong = case_list[case_list.len - 1];
|
||||
const then_stmt: *const Ast.Node = first_prong;
|
||||
const else_stmt: ?*const Ast.Node = if (first_prong == last_prong)
|
||||
null
|
||||
else
|
||||
last_prong;
|
||||
|
||||
var child_scope = try gen.astgen.createScope(parent_scope);
|
||||
defer child_scope.deinit();
|
||||
try expr(gen, child_scope, expr_node);
|
||||
|
||||
const else_label = try gen.makeLabel();
|
||||
const end_label = try gen.makeLabel();
|
||||
const then_br = try gen.emitJumpInst(.jmp_f);
|
||||
_ = try gen.makeFixup(.{
|
||||
.mode = .relative,
|
||||
.label_index = else_label,
|
||||
.code_offset = then_br,
|
||||
});
|
||||
try gen.emitSimpleInst(.pop);
|
||||
try blockStmt(gen, child_scope, then_stmt);
|
||||
|
||||
const else_br = try gen.emitJumpInst(.jmp);
|
||||
_ = try gen.makeFixup(.{
|
||||
.mode = .relative,
|
||||
.label_index = end_label,
|
||||
.code_offset = else_br,
|
||||
});
|
||||
gen.setLabel(else_label);
|
||||
try gen.emitSimpleInst(.pop);
|
||||
|
||||
if (else_stmt) |else_node| {
|
||||
const block_stmt = else_node.data.bin.rhs;
|
||||
try blockStmt(gen, child_scope, block_stmt);
|
||||
}
|
||||
gen.setLabel(end_label);
|
||||
} else {
|
||||
return gen.fail(.expected_expression, stmt_node);
|
||||
}
|
||||
}
|
||||
|
||||
fn multiIfStmt(
|
||||
gen: *GenIr,
|
||||
parent_scope: *Scope,
|
||||
stmt_node: *const Ast.Node,
|
||||
) InnerError!void {
|
||||
const gpa = gen.astgen.gpa;
|
||||
try validateSwitchProngs(gen, stmt_node);
|
||||
const case_list = stmt_node.data.switch_stmt.cases;
|
||||
// NOTE: We're going to create an array of label indexes here, since we
|
||||
// may create additional labels while traversing nested expressions.
|
||||
var label_list: std.ArrayList(usize) = .empty;
|
||||
defer label_list.deinit(gpa);
|
||||
try label_list.ensureUnusedCapacity(gpa, case_list.len);
|
||||
|
||||
var child_scope = try gen.astgen.createScope(parent_scope);
|
||||
defer child_scope.deinit();
|
||||
|
||||
const exit_label = try gen.makeLabel();
|
||||
gen.setExit(exit_label);
|
||||
|
||||
for (case_list) |case_stmt| {
|
||||
const label_index = try gen.makeLabel();
|
||||
switch (case_stmt.tag) {
|
||||
.if_branch => {
|
||||
const lhs = case_stmt.data.bin.lhs orelse unreachable;
|
||||
try expr(gen, child_scope, lhs);
|
||||
|
||||
const fixup_offset = try gen.emitJumpInst(.jmp_t);
|
||||
_ = try gen.makeFixup(.{
|
||||
.mode = .relative,
|
||||
.label_index = label_index,
|
||||
.code_offset = fixup_offset,
|
||||
});
|
||||
try gen.emitSimpleInst(.pop);
|
||||
},
|
||||
.else_branch => {
|
||||
const fixup_offset = try gen.emitJumpInst(.jmp);
|
||||
_ = try gen.makeFixup(.{
|
||||
.mode = .relative,
|
||||
.label_index = label_index,
|
||||
.code_offset = fixup_offset,
|
||||
});
|
||||
},
|
||||
else => unreachable,
|
||||
}
|
||||
}
|
||||
for (case_list, label_list.items) |case_stmt, label_index| {
|
||||
const body_stmt = case_stmt.data.bin.rhs;
|
||||
switch (case_stmt.tag) {
|
||||
.if_branch => {
|
||||
gen.setLabel(label_index);
|
||||
try gen.emitSimpleInst(.pop);
|
||||
},
|
||||
.else_branch => {
|
||||
gen.setLabel(label_index);
|
||||
},
|
||||
else => unreachable,
|
||||
}
|
||||
try blockStmt(gen, child_scope, body_stmt);
|
||||
|
||||
const fixup_inst = try gen.emitJumpInst(.jmp);
|
||||
_ = try gen.makeFixup(.{
|
||||
.mode = .relative,
|
||||
.label_index = gen.exit_label,
|
||||
.code_offset = fixup_inst,
|
||||
});
|
||||
}
|
||||
|
||||
gen.setLabel(gen.exit_label);
|
||||
}
|
||||
|
||||
fn switchStmt(
|
||||
gen: *GenIr,
|
||||
parent_scope: *Scope,
|
||||
|
|
@ -721,6 +718,105 @@ fn switchStmt(
|
|||
gen.setLabel(gen.exit_label);
|
||||
}
|
||||
|
||||
fn ifStmt(
|
||||
parent_block: *GenIr,
|
||||
scope: *Scope,
|
||||
stmt_node: *const Ast.Node,
|
||||
) InnerError!Ir.Inst.Index {
|
||||
const astgen = parent_block.astgen;
|
||||
const cond_expr = stmt_node.data.switch_stmt.condition_expr.?;
|
||||
try validateSwitchProngs(parent_block, stmt_node);
|
||||
|
||||
const case_list = stmt_node.data.switch_stmt.cases;
|
||||
const then_node = case_list[0];
|
||||
const last_prong = case_list[case_list.len - 1];
|
||||
|
||||
var block_scope = parent_block.makeSubBlock();
|
||||
defer block_scope.unstack();
|
||||
|
||||
const cond_inst = try expr(&block_scope, scope, cond_expr);
|
||||
const condbr = try block_scope.addCondBr(.condbr);
|
||||
const block = try parent_block.makeBlockInst();
|
||||
try block_scope.setBlockBody(block); // unstacks block
|
||||
try parent_block.instructions.append(astgen.gpa, block);
|
||||
|
||||
var then_block = parent_block.makeSubBlock();
|
||||
defer then_block.unstack();
|
||||
|
||||
try blockStmt(&then_block, scope, then_node);
|
||||
_ = try then_block.addBreak(.@"break", block);
|
||||
|
||||
var else_block = parent_block.makeSubBlock();
|
||||
defer else_block.unstack();
|
||||
|
||||
if (then_node == last_prong) {
|
||||
_ = try else_block.addBreak(.@"break", block);
|
||||
} else {
|
||||
const block_node = last_prong.data.bin.rhs.?;
|
||||
try blockStmt(&else_block, scope, block_node);
|
||||
}
|
||||
|
||||
try setCondBrPayload(condbr, cond_inst, &then_block, &else_block);
|
||||
return @enumFromInt(0);
|
||||
}
|
||||
|
||||
fn ifChain(
|
||||
parent_block: *GenIr,
|
||||
scope: *Scope,
|
||||
branch_list: []const *Ast.Node,
|
||||
) InnerError!Ir.Inst.Index {
|
||||
const gpa = parent_block.astgen.gpa;
|
||||
if (branch_list.len == 0) return @enumFromInt(0);
|
||||
if (branch_list[0].data.bin.lhs == null) {
|
||||
const body_node = branch_list[0].data.bin.rhs.?;
|
||||
try blockStmt(parent_block, scope, body_node);
|
||||
return @enumFromInt(0);
|
||||
}
|
||||
|
||||
var block_scope = parent_block.makeSubBlock();
|
||||
defer block_scope.unstack();
|
||||
|
||||
const branch = branch_list[0];
|
||||
const cond_expr = branch.data.bin.lhs.?;
|
||||
const body_node = branch.data.bin.rhs.?;
|
||||
const cond_inst = try expr(&block_scope, scope, cond_expr);
|
||||
const condbr = try block_scope.addCondBr(.condbr);
|
||||
const block_inst = try parent_block.makeBlockInst();
|
||||
try block_scope.setBlockBody(block_inst);
|
||||
try parent_block.instructions.append(gpa, block_inst);
|
||||
|
||||
var then_block = parent_block.makeSubBlock();
|
||||
defer then_block.unstack();
|
||||
try blockStmt(&then_block, scope, body_node);
|
||||
_ = try then_block.addBreak(.@"break", block_inst);
|
||||
|
||||
var else_block = parent_block.makeSubBlock();
|
||||
defer else_block.unstack();
|
||||
const next_branches = branch_list[1..];
|
||||
_ = try ifChain(parent_block, scope, next_branches);
|
||||
_ = try else_block.addBreak(.@"break", block_inst);
|
||||
try setCondBrPayload(condbr, cond_inst, &then_block, &else_block);
|
||||
return @enumFromInt(0);
|
||||
}
|
||||
|
||||
fn multiIfStmt(
|
||||
parent_block: *GenIr,
|
||||
scope: *Scope,
|
||||
stmt_node: *const Ast.Node,
|
||||
) InnerError!Ir.Inst.Index {
|
||||
try validateSwitchProngs(parent_block, stmt_node);
|
||||
|
||||
const branch_list = stmt_node.data.switch_stmt.cases;
|
||||
if (branch_list[0].data.bin.lhs == null) {
|
||||
const branch = branch_list[0];
|
||||
const body_node = branch.data.bin.rhs.?;
|
||||
try blockStmt(parent_block, scope, body_node);
|
||||
return @enumFromInt(0);
|
||||
}
|
||||
_ = try ifChain(parent_block, scope, branch_list);
|
||||
return @enumFromInt(0);
|
||||
}
|
||||
|
||||
fn inlineLogicExpr(
|
||||
gen: *GenIr,
|
||||
scope: *Scope,
|
||||
|
|
@ -731,34 +827,29 @@ fn inlineLogicExpr(
|
|||
return expr(gen, scope, main_node);
|
||||
}
|
||||
|
||||
fn contentExpr(gi: *GenIr, scope: *Scope, expr_node: *const Ast.Node) InnerError!Ir.Inst.Index {
|
||||
const astgen = gi.astgen;
|
||||
const gpa = astgen.gpa;
|
||||
const block_inst = try gi.makeBlockInst();
|
||||
try gi.instructions.append(gpa, block_inst);
|
||||
|
||||
var sub_block = gi.makeSubBlock();
|
||||
defer sub_block.unstack();
|
||||
fn contentExpr(block: *GenIr, scope: *Scope, expr_node: *const Ast.Node) InnerError!Ir.Inst.Index {
|
||||
// FIXME: This is a placeholder until we figure out what this function should be returning.
|
||||
var last_inst: Ir.Inst.Index = undefined;
|
||||
// TODO: Make sure that this is not nullable.
|
||||
const node_list = expr_node.data.list.items orelse unreachable;
|
||||
const node_list = expr_node.data.list.items.?;
|
||||
for (node_list) |child_node| {
|
||||
_ = switch (child_node.tag) {
|
||||
.string_literal => try stringLiteral(&sub_block, child_node),
|
||||
.inline_logic_expr => try inlineLogicExpr(&sub_block, scope, child_node),
|
||||
//.if_stmt => try ifStmt(gen, scope, child_node),
|
||||
//.multi_if_stmt => try multiIfStmt(gen, scope, child_node),
|
||||
last_inst = switch (child_node.tag) {
|
||||
.string_literal => try stringLiteral(block, child_node),
|
||||
.inline_logic_expr => try inlineLogicExpr(block, scope, child_node),
|
||||
.if_stmt => try ifStmt(block, scope, child_node),
|
||||
.multi_if_stmt => try multiIfStmt(block, scope, child_node),
|
||||
//.switch_stmt => try switchStmt(gen, scope, child_node),
|
||||
else => unreachable,
|
||||
};
|
||||
last_inst = try block.add(.{ .tag = .content_push, .data = undefined });
|
||||
}
|
||||
try sub_block.setBlockBody(block_inst);
|
||||
return block_inst;
|
||||
return last_inst;
|
||||
}
|
||||
|
||||
fn contentStmt(gen: *GenIr, scope: *Scope, stmt_node: *const Ast.Node) InnerError!Ir.Inst.Index {
|
||||
const expr_node = stmt_node.data.bin.lhs orelse unreachable;
|
||||
const expr_ref = try contentExpr(gen, scope, expr_node);
|
||||
return gen.addUnaryNode(.content, expr_ref);
|
||||
return gen.addUnaryNode(.content_flush, expr_ref);
|
||||
}
|
||||
|
||||
fn assignStmt(gi: *GenIr, scope: *Scope, stmt_node: *const Ast.Node) InnerError!void {
|
||||
|
|
@ -909,22 +1000,10 @@ fn blockInner(gi: *GenIr, parent_scope: *Scope, stmt_list: []*Ast.Node) !void {
|
|||
}
|
||||
}
|
||||
|
||||
fn blockStmt(
|
||||
parent_gi: *GenIr,
|
||||
scope: *Scope,
|
||||
stmt_node: *const Ast.Node,
|
||||
) InnerError!void {
|
||||
const gpa = parent_gi.astgen.gpa;
|
||||
const block_inst = try parent_gi.makeBlockInst();
|
||||
try parent_gi.instructions.append(gpa, block_inst);
|
||||
|
||||
var gi = parent_gi.makeSubBlock();
|
||||
defer gi.unstack();
|
||||
|
||||
fn blockStmt(block: *GenIr, scope: *Scope, stmt_node: *const Ast.Node) InnerError!void {
|
||||
// TODO: Make sure that this value is concrete to omit check.
|
||||
const block_stmts = stmt_node.data.list.items orelse unreachable;
|
||||
try blockInner(&gi, scope, block_stmts);
|
||||
try gi.setBlockBody(block_inst);
|
||||
const block_stmts = stmt_node.data.list.items.?;
|
||||
try blockInner(block, scope, block_stmts);
|
||||
}
|
||||
|
||||
const main_knot_name: [:0]const u8 = "$__main__$";
|
||||
|
|
@ -1018,11 +1097,6 @@ fn file(root_gi: *GenIr, scope: *Scope, file_node: *const Ast.Node) InnerError!v
|
|||
return file_scope.setBlockBody(file_inst);
|
||||
}
|
||||
|
||||
pub const Decl = struct {
|
||||
decl_node: *const Ast.Node,
|
||||
inst_index: Ir.Inst.Index,
|
||||
};
|
||||
|
||||
/// Perform code generation via tree-walk.
|
||||
pub fn generate(gpa: std.mem.Allocator, tree: *const Ast) !Ir {
|
||||
var astgen: AstGen = .{
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue