Commit 66bbd75a83
Changed files (2)
src
translate_c
src/translate_c/ast.zig
@@ -47,7 +47,6 @@ pub const Node = extern union {
field_access,
array_access,
call,
- std_mem_zeroes,
var_decl,
func,
warning,
@@ -57,6 +56,7 @@ pub const Node = extern union {
@"struct",
@"union",
array_init,
+ tuple,
container_init,
std_meta_cast,
discard,
@@ -162,6 +162,8 @@ pub const Node = extern union {
deref,
block,
+ /// { operand }
+ block_single,
@"break",
sizeof,
@@ -173,8 +175,12 @@ pub const Node = extern union {
single_pointer,
array_type,
- /// @import("std").mem.zeroes(T)
+ /// @import("std").meta.sizeof(operand)
+ std_meta_sizeof,
+ /// @import("std").mem.zeroes(operand)
std_mem_zeroes,
+ /// @import("std").mem.zeroInit(lhs, rhs)
+ std_mem_zeroinit,
// pub const name = @compileError(msg);
fail_decl,
// var actual = mangled;
@@ -188,6 +194,9 @@ pub const Node = extern union {
/// pub const enum_field_name = @enumToInt(enum_name.field_name);
enum_redecl,
+ /// pub inline fn name(params) return_type body
+ pub_inline_fn,
+
/// [0]type{}
empty_array,
/// [1]type{val} ** count
@@ -195,6 +204,7 @@ pub const Node = extern union {
/// _ = operand;
ignore,
+ @"anytype",
pub const last_no_payload_tag = Tag.usingnamespace_builtins;
pub const no_payload_count = @enumToInt(last_no_payload_tag) + 1;
@@ -213,6 +223,7 @@ pub const Node = extern union {
.one_literal,
.void_type,
.noreturn_type,
+ .@"anytype",
=> @compileError("Type Tag " ++ @tagName(t) ++ " has no payload"),
.std_mem_zeroes,
@@ -234,6 +245,7 @@ pub const Node = extern union {
.if_not_break,
.switch_else,
.ignore,
+ .block_single,
=> Payload.UnOp,
.add,
@@ -302,6 +314,8 @@ pub const Node = extern union {
.field_access,
.assign,
.align_cast,
+ .array_access,
+ .std_mem_zeroinit,
=> Payload.BinOp,
.number_literal,
@@ -325,7 +339,7 @@ pub const Node = extern union {
.func => Payload.Func,
.@"enum" => Payload.Enum,
.@"struct", .@"union" => Payload.Record,
- .array_init => Payload.ArrayInit,
+ .array_init, .tuple => Payload.ArrayInit,
.container_init => Payload.ContainerInit,
.std_meta_cast => Payload.Infix,
.block => Payload.Block,
@@ -336,6 +350,7 @@ pub const Node = extern union {
.typedef, .pub_typedef, .var_simple, .pub_var_simple => Payload.SimpleVarDecl,
.enum_redecl => Payload.EnumRedecl,
.array_filler => Payload.ArrayFiller,
+ .pub_inline_fn => Payload.PubInlineFn,
};
}
@@ -488,12 +503,12 @@ pub const Payload = struct {
body: ?Node,
alignment: ?c_uint,
},
+ };
- pub const Param = struct {
- is_noalias: bool,
- name: ?[]const u8,
- type: Node,
- };
+ pub const Param = struct {
+ is_noalias: bool,
+ name: ?[]const u8,
+ type: Node,
};
pub const Enum = struct {
@@ -598,6 +613,16 @@ pub const Payload = struct {
count: usize,
},
};
+
+ pub const PubInlineFn = struct {
+ base: Node,
+ data: struct {
+ name: []const u8,
+ params: []Param,
+ return_type: Node,
+ body: Node,
+ },
+ };
};
/// Converts the nodes into a Zig ast.
src/translate_c.zig
@@ -3512,86 +3512,48 @@ fn transCreateNodeNumber(c: *Context, int: anytype) !Node {
return Node.int_literal.create(c.arena, str);
}
-fn transCreateNodeMacroFn(c: *Context, name: []const u8, ref: *ast.Node, proto_alias: *ast.Node.FnProto) !*ast.Node {
+fn transCreateNodeMacroFn(c: *Context, name: []const u8, ref: Node, proto_alias: *ast.Payload.Func) !Node {
const scope = &c.global_scope.base;
- const pub_tok = try appendToken(c, .Keyword_pub, "pub");
- const fn_tok = try appendToken(c, .Keyword_fn, "fn");
- const name_tok = try appendIdentifier(c, name);
- _ = try appendToken(c, .LParen, "(");
-
- var fn_params = std.ArrayList(ast.Node.FnProto.ParamDecl).init(c.gpa);
+ var fn_params = std.ArrayList(Node).init(c.gpa);
defer fn_params.deinit();
for (proto_alias.params()) |param, i| {
- if (i != 0) {
- _ = try appendToken(c, .Comma, ",");
- }
- const param_name_tok = param.name_token orelse
- try appendTokenFmt(c, .Identifier, "arg_{d}", .{c.getMangle()});
+ const param_name = param.name orelse
+ try std.fmt.allocPrint(c.arena, "arg_{d}", .{c.getMangle()});
- _ = try appendToken(c, .Colon, ":");
-
- (try fn_params.addOne()).* = .{
- .doc_comments = null,
- .comptime_token = null,
- .noalias_token = param.noalias_token,
- .name_token = param_name_tok,
- .param_type = param.param_type,
- };
+ try fn_params.append(.{
+ .name = param_name,
+ .type = param.type,
+ .is_noalias = param.is_noalias,
+ });
}
- _ = try appendToken(c, .RParen, ")");
-
- _ = try appendToken(c, .Keyword_callconv, "callconv");
- _ = try appendToken(c, .LParen, "(");
- const callconv_expr = try transCreateNodeEnumLiteral(c, "Inline");
- _ = try appendToken(c, .RParen, ")");
-
- const block_lbrace = try appendToken(c, .LBrace, "{");
-
- const return_kw = try appendToken(c, .Keyword_return, "return");
- const unwrap_expr = try transCreateNodeUnwrapNull(c, ref.cast(ast.Node.VarDecl).?.getInitNode().?);
-
- const call_expr = try c.createCall(unwrap_expr, fn_params.items.len);
- const call_params = call_expr.params();
+ const init = if (value.castTag(.var_decl)) |v|
+ v.data.init
+ else if (value.castTag(.var_simple) orelse value.castTag(.pub_var_simple)) |v|
+ v.data.init
+ else
+ unreachable;
+ const unwrap_expr = try Node.unwrap.create(c.arena, init);
+ const call_params = try c.arena.alloc(Node, fn_params.items.len);
for (fn_params.items) |param, i| {
- if (i != 0) {
- _ = try appendToken(c, .Comma, ",");
- }
- call_params[i] = try transCreateNodeIdentifier(c, tokenSlice(c, param.name_token.?));
+ call_params[i] = try Node.identifier.create(c.arena, param.name);
}
- call_expr.rtoken = try appendToken(c, .RParen, ")");
-
- const return_expr = try ast.Node.ControlFlowExpression.create(c.arena, .{
- .ltoken = return_kw,
- .tag = .Return,
- }, .{
- .rhs = &call_expr.base,
+ const call_expr = try Node.call.create(c.arean, .{
+ .lhs = unwrap_expr,
+ .args = call_params,
});
- _ = try appendToken(c, .Semicolon, ";");
+ const return_expr = try Node.@"return".create(c.arean, call_expr);
+ const block = try Node.block_single.create(c.arean, return_expr);
- const block = try ast.Node.Block.alloc(c.arena, 1);
- block.* = .{
- .lbrace = block_lbrace,
- .statements_len = 1,
- .rbrace = try appendToken(c, .RBrace, "}"),
- };
- block.statements()[0] = &return_expr.base;
-
- const fn_proto = try ast.Node.FnProto.create(c.arena, .{
- .params_len = fn_params.items.len,
- .fn_token = fn_tok,
+ return Node.pub_inline_fn.create(c.arena, .{
+ .name = name,
+ .params = try c.arena.dupe(ast.Node.Param, fn_params.items),
.return_type = proto_alias.return_type,
- }, .{
- .visib_token = pub_tok,
- .name_token = name_tok,
- .body_node = &block.base,
- .callconv_expr = callconv_expr,
+ .body = block,
});
- mem.copy(ast.Node.FnProto.ParamDecl, fn_proto.params(), fn_params.items);
- return &fn_proto.base;
}
fn transCreateNodeShiftOp(
@@ -4108,27 +4070,13 @@ fn transPreprocessorEntities(c: *Context, unit: *clang.ASTUnit) Error!void {
fn transMacroDefine(c: *Context, m: *MacroCtx) ParseError!void {
const scope = &c.global_scope.base;
- const visib_tok = try appendToken(c, .Keyword_pub, "pub");
- const mut_tok = try appendToken(c, .Keyword_const, "const");
- const name_tok = try appendIdentifier(c, m.name);
- const eq_token = try appendToken(c, .Equal, "=");
-
const init_node = try parseCExpr(c, m, scope);
const last = m.next().?;
if (last != .Eof and last != .Nl)
return m.fail(c, "unable to translate C expr: unexpected token .{s}", .{@tagName(last)});
- const semicolon_token = try appendToken(c, .Semicolon, ";");
- const node = try ast.Node.VarDecl.create(c.arena, .{
- .name_token = name_tok,
- .mut_token = mut_tok,
- .semicolon_token = semicolon_token,
- }, .{
- .visib_token = visib_tok,
- .eq_token = eq_token,
- .init_node = init_node,
- });
- _ = try c.global_scope.macro_table.put(m.name, &node.base);
+ const var_decl = try Node.pub_var_simple.create(c.arena, .{ .name = m.name, .init = init_node });
+ _ = try c.global_scope.macro_table.put(m.name, var_decl);
}
fn transMacroFnDefine(c: *Context, m: *MacroCtx) ParseError!void {
@@ -4136,16 +4084,11 @@ fn transMacroFnDefine(c: *Context, m: *MacroCtx) ParseError!void {
defer block_scope.deinit();
const scope = &block_scope.base;
- const pub_tok = try appendToken(c, .Keyword_pub, "pub");
- const fn_tok = try appendToken(c, .Keyword_fn, "fn");
- const name_tok = try appendIdentifier(c, m.name);
- _ = try appendToken(c, .LParen, "(");
-
if (m.next().? != .LParen) {
return m.fail(c, "unable to translate C expr: expected '('", .{});
}
- var fn_params = std.ArrayList(ast.Node.FnProto.ParamDecl).init(c.gpa);
+ var fn_params = std.ArrayList(ast.Payload.Param).init(c.gpa);
defer fn_params.deinit();
while (true) {
@@ -4153,120 +4096,78 @@ fn transMacroFnDefine(c: *Context, m: *MacroCtx) ParseError!void {
_ = m.next();
const mangled_name = try block_scope.makeMangledName(c, m.slice());
- const param_name_tok = try appendIdentifier(c, mangled_name);
- _ = try appendToken(c, .Colon, ":");
-
- const any_type = try c.arena.create(ast.Node.OneToken);
- any_type.* = .{
- .base = .{ .tag = .AnyType },
- .token = try appendToken(c, .Keyword_anytype, "anytype"),
- };
-
- (try fn_params.addOne()).* = .{
- .doc_comments = null,
- .comptime_token = null,
- .noalias_token = null,
- .name_token = param_name_tok,
- .param_type = .{ .any_type = &any_type.base },
- };
+ try fn_params.append(.{
+ .is_noalias = false,
+ .name = mangled_name,
+ .type = Node.@"anytype".init(),
+ });
if (m.peek().? != .Comma) break;
_ = m.next();
- _ = try appendToken(c, .Comma, ",");
}
if (m.next().? != .RParen) {
return m.fail(c, "unable to translate C expr: expected ')'", .{});
}
- _ = try appendToken(c, .RParen, ")");
-
- _ = try appendToken(c, .Keyword_callconv, "callconv");
- _ = try appendToken(c, .LParen, "(");
- const callconv_expr = try transCreateNodeEnumLiteral(c, "Inline");
- _ = try appendToken(c, .RParen, ")");
-
- const type_of = try c.createBuiltinCall("@TypeOf", 1);
-
- const return_kw = try appendToken(c, .Keyword_return, "return");
const expr = try parseCExpr(c, m, scope);
const last = m.next().?;
if (last != .Eof and last != .Nl)
return m.fail(c, "unable to translate C expr: unexpected token .{s}", .{@tagName(last)});
- _ = try appendToken(c, .Semicolon, ";");
- const type_of_arg = if (!expr.tag.isBlock()) expr else blk: {
- const stmts = expr.blockStatements();
- const blk_last = stmts[stmts.len - 1];
- const br = blk_last.cast(ast.Node.ControlFlowExpression).?;
- break :blk br.getRHS().?;
- };
- type_of.params()[0] = type_of_arg;
- type_of.rparen_token = try appendToken(c, .RParen, ")");
- const return_expr = try ast.Node.ControlFlowExpression.create(c.arena, .{
- .ltoken = return_kw,
- .tag = .Return,
- }, .{
- .rhs = expr,
- });
+ const typeof_arg = if (expr.castTag(.block)) |some| blk: {
+ const stmts = some.data.stmts;
+ const blk_last = stmts[stmts.len - 1];
+ const br = blk_last.castTag(.break_val).?;
+ break :blk br.data;
+ } else expr;
+ const typeof = try Node.typeof.create(c.arean, typeof_arg);
+ const return_expr = try Node.@"return".create(c.arena, expr);
try block_scope.statements.append(&return_expr.base);
- const block_node = try block_scope.complete(c);
- const fn_proto = try ast.Node.FnProto.create(c.arena, .{
- .fn_token = fn_tok,
- .params_len = fn_params.items.len,
- .return_type = .{ .Explicit = &type_of.base },
- }, .{
- .visib_token = pub_tok,
- .name_token = name_tok,
- .body_node = block_node,
- .callconv_expr = callconv_expr,
+
+ const fn_decl = try Node.pub_inline_fn.create(c.arena, .{
+ .name = m.name,
+ .params = try c.arena.dupe(ast.Payload.Param, fn_params.items),
+ .return_type = typeof,
+ .body = try block_scope.complete(c),
});
- mem.copy(ast.Node.FnProto.ParamDecl, fn_proto.params(), fn_params.items);
-
_ = try c.global_scope.macro_table.put(m.name, &fn_proto.base);
}
const ParseError = Error || error{ParseError};
-fn parseCExpr(c: *Context, m: *MacroCtx, scope: *Scope) ParseError!*ast.Node {
+fn parseCExpr(c: *Context, m: *MacroCtx, scope: *Scope) ParseError!Node {
// TODO parseCAssignExpr here
const node = try parseCCondExpr(c, m, scope);
if (m.next().? != .Comma) {
m.i -= 1;
return node;
}
- _ = try appendToken(c, .Semicolon, ";");
var block_scope = try Scope.Block.init(c, scope, true);
defer block_scope.deinit();
var last = node;
while (true) {
// suppress result
- const lhs = try transCreateNodeIdentifier(c, "_");
- const op_token = try appendToken(c, .Equal, "=");
- const op_node = try c.arena.create(ast.Node.SimpleInfixOp);
- op_node.* = .{
- .base = .{ .tag = .Assign },
- .op_token = op_token,
- .lhs = lhs,
- .rhs = last,
- };
- try block_scope.statements.append(&op_node.base);
+ const ignore = try Node.ignore.create(c.arena, last);
+ try block_scope.statements.append(ignore);
last = try parseCCondExpr(c, m, scope);
- _ = try appendToken(c, .Semicolon, ";");
if (m.next().? != .Comma) {
m.i -= 1;
break;
}
}
- const break_node = try transCreateNodeBreak(c, block_scope.label, last);
- try block_scope.statements.append(&break_node.base);
+ const break_node = try Node.break_val.create(c.arena, .{
+ .label = block_scope.label,
+ .val = last,
+ });
+ try block_scope.statements.append(break_node);
return try block_scope.complete(c);
}
-fn parseCNumLit(c: *Context, m: *MacroCtx) ParseError!*ast.Node {
+fn parseCNumLit(c: *Context, m: *MacroCtx) ParseError!Node {
var lit_bytes = m.slice();
switch (m.list[m.i].id) {
@@ -4286,11 +4187,10 @@ fn parseCNumLit(c: *Context, m: *MacroCtx) ParseError!*ast.Node {
}
if (suffix == .none) {
- return transCreateNodeInt(c, lit_bytes);
+ return transCreateNodeNumber(c, lit_bytes);
}
- const cast_node = try c.createBuiltinCall("@as", 2);
- cast_node.params()[0] = try transCreateNodeIdentifier(c, switch (suffix) {
+ const type_node = try Node.type.create(c.arena, switch (suffix) {
.u => "c_uint",
.l => "c_long",
.lu => "c_ulong",
@@ -4304,27 +4204,22 @@ fn parseCNumLit(c: *Context, m: *MacroCtx) ParseError!*ast.Node {
.llu => 3,
else => unreachable,
}];
- _ = try appendToken(c, .Comma, ",");
- cast_node.params()[1] = try transCreateNodeInt(c, lit_bytes);
- cast_node.rparen_token = try appendToken(c, .RParen, ")");
- return &cast_node.base;
+ const rhs = try transCreateNodeNumber(c, lit_bytes);
+ return Node.as.create(c.arena, .{ .lhs = type_node, .rhs = rhs });
},
.FloatLiteral => |suffix| {
if (lit_bytes[0] == '.')
lit_bytes = try std.fmt.allocPrint(c.arena, "0{s}", .{lit_bytes});
if (suffix == .none) {
- return transCreateNodeFloat(c, lit_bytes);
+ return transCreateNodeNumber(c, lit_bytes);
}
- const cast_node = try c.createBuiltinCall("@as", 2);
- cast_node.params()[0] = try transCreateNodeIdentifier(c, switch (suffix) {
+ const type_node = try Node.type.create(c.arena, switch (suffix) {
.f => "f32",
.l => "c_longdouble",
else => unreachable,
});
- _ = try appendToken(c, .Comma, ",");
- cast_node.params()[1] = try transCreateNodeFloat(c, lit_bytes[0 .. lit_bytes.len - 1]);
- cast_node.rparen_token = try appendToken(c, .RParen, ")");
- return &cast_node.base;
+ const rhs = try transCreateNodeNumber(c, lit_bytes[0 .. lit_bytes.len - 1]);
+ return Node.as.create(c.arena, .{ .lhs = type_node, .rhs = rhs });
},
else => unreachable,
}
@@ -4490,79 +4385,62 @@ fn zigifyEscapeSequences(ctx: *Context, m: *MacroCtx) ![]const u8 {
return bytes[0..i];
}
-fn parseCPrimaryExprInner(c: *Context, m: *MacroCtx, scope: *Scope) ParseError!*ast.Node {
+fn parseCPrimaryExprInner(c: *Context, m: *MacroCtx, scope: *Scope) ParseError!Node {
const tok = m.next().?;
const slice = m.slice();
switch (tok) {
.CharLiteral => {
if (slice[0] != '\'' or slice[1] == '\\' or slice.len == 3) {
- const token = try appendToken(c, .CharLiteral, try zigifyEscapeSequences(c, m));
- const node = try c.arena.create(ast.Node.OneToken);
- node.* = .{
- .base = .{ .tag = .CharLiteral },
- .token = token,
- };
- return &node.base;
+ return Node.char_literal.create(c.arena, try zigifyEscapeSequences(c, m));
} else {
- const token = try appendTokenFmt(c, .IntegerLiteral, "0x{x}", .{slice[1 .. slice.len - 1]});
- const node = try c.arena.create(ast.Node.OneToken);
- node.* = .{
- .base = .{ .tag = .IntegerLiteral },
- .token = token,
- };
- return &node.base;
+ const str = try std.fmt.allocPrint(c.arena, "0x{x}", .{slice[1 .. slice.len - 1]});
+ return Node.int_literal.create(c.arena, str);
}
},
.StringLiteral => {
- const token = try appendToken(c, .StringLiteral, try zigifyEscapeSequences(c, m));
- const node = try c.arena.create(ast.Node.OneToken);
- node.* = .{
- .base = .{ .tag = .StringLiteral },
- .token = token,
- };
- return &node.base;
+ return Node.string_literal.create(c.arena, try zigifyEscapeSequences(c, m));
},
.IntegerLiteral, .FloatLiteral => {
return parseCNumLit(c, m);
},
// eventually this will be replaced by std.c.parse which will handle these correctly
- .Keyword_void => return transCreateNodeIdentifierUnchecked(c, "c_void"),
- .Keyword_bool => return transCreateNodeIdentifierUnchecked(c, "bool"),
- .Keyword_double => return transCreateNodeIdentifierUnchecked(c, "f64"),
- .Keyword_long => return transCreateNodeIdentifierUnchecked(c, "c_long"),
- .Keyword_int => return transCreateNodeIdentifierUnchecked(c, "c_int"),
- .Keyword_float => return transCreateNodeIdentifierUnchecked(c, "f32"),
- .Keyword_short => return transCreateNodeIdentifierUnchecked(c, "c_short"),
- .Keyword_char => return transCreateNodeIdentifierUnchecked(c, "u8"),
+ .Keyword_void => return Node.type.create(c.arena, "c_void"),
+ .Keyword_bool => return Node.type.create(c.arena, "bool"),
+ .Keyword_double => return Node.type.create(c.arena, "f64"),
+ .Keyword_long => return Node.type.create(c.arena, "c_long"),
+ .Keyword_int => return Node.type.create(c.arena, "c_int"),
+ .Keyword_float => return Node.type.create(c.arena, "f32"),
+ .Keyword_short => return Node.type.create(c.arena, "c_short"),
+ .Keyword_char => return Node.type.create(c.arena, "u8"),
.Keyword_unsigned => if (m.next()) |t| switch (t) {
- .Keyword_char => return transCreateNodeIdentifierUnchecked(c, "u8"),
- .Keyword_short => return transCreateNodeIdentifierUnchecked(c, "c_ushort"),
- .Keyword_int => return transCreateNodeIdentifierUnchecked(c, "c_uint"),
+ .Keyword_char => return Node.type.create(c.arena, "u8"),
+ .Keyword_short => return Node.type.create(c.arena, "c_ushort"),
+ .Keyword_int => return Node.type.create(c.arena, "c_uint"),
.Keyword_long => if (m.peek() != null and m.peek().? == .Keyword_long) {
_ = m.next();
- return transCreateNodeIdentifierUnchecked(c, "c_ulonglong");
- } else return transCreateNodeIdentifierUnchecked(c, "c_ulong"),
+ return Node.type.create(c.arena, "c_ulonglong");
+ } else return Node.type.create(c.arena, "c_ulong"),
else => {
m.i -= 1;
- return transCreateNodeIdentifierUnchecked(c, "c_uint");
+ return Node.type.create(c.arena, "c_uint");
},
} else {
- return transCreateNodeIdentifierUnchecked(c, "c_uint");
+ return Node.type.create(c.arena, "c_uint");
},
.Keyword_signed => if (m.next()) |t| switch (t) {
- .Keyword_char => return transCreateNodeIdentifierUnchecked(c, "i8"),
- .Keyword_short => return transCreateNodeIdentifierUnchecked(c, "c_short"),
- .Keyword_int => return transCreateNodeIdentifierUnchecked(c, "c_int"),
+ .Keyword_char => return Node.type.create(c.arena, "i8"),
+ .Keyword_short => return Node.type.create(c.arena, "c_short"),
+ .Keyword_int => return Node.type.create(c.arena, "c_int"),
.Keyword_long => if (m.peek() != null and m.peek().? == .Keyword_long) {
_ = m.next();
- return transCreateNodeIdentifierUnchecked(c, "c_longlong");
- } else return transCreateNodeIdentifierUnchecked(c, "c_long"),
+ return Node.type.create(c.arena, "c_longlong");
+ } else return Node.type.create(c.arena, "c_long"),
else => {
m.i -= 1;
- return transCreateNodeIdentifierUnchecked(c, "c_int");
+ return Node.type.create(c.arena, "c_int");
},
} else {
- return transCreateNodeIdentifierUnchecked(c, "c_int");
+ return Node.type.create(c.arena, "c_int");
},
.Keyword_enum, .Keyword_struct, .Keyword_union => {
// struct Foo will be declared as struct_Foo by transRecordDecl
@@ -4572,17 +4450,12 @@ fn parseCPrimaryExprInner(c: *Context, m: *MacroCtx, scope: *Scope) ParseError!*
return error.ParseError;
}
- const ident_token = try appendTokenFmt(c, .Identifier, "{s}_{s}", .{ slice, m.slice() });
- const identifier = try c.arena.create(ast.Node.OneToken);
- identifier.* = .{
- .base = .{ .tag = .Identifier },
- .token = ident_token,
- };
- return &identifier.base;
+ const name = try std.fmt.allocPrint(c.arena, "{s}_{s}", .{ slice, m.slice() });
+ return Node.identifier.create(c.arena, name);
},
.Identifier => {
const mangled_name = scope.getAlias(slice);
- return transCreateNodeIdentifier(c, checkForBuiltinTypedef(mangled_name) orelse mangled_name);
+ return Node.identifier.create(c.arena, builtin_typedef_map.get(mangled_name) orelse mangled_name);
},
.LParen => {
const inner_node = try parseCExpr(c, m, scope);
@@ -4612,10 +4485,6 @@ fn parseCPrimaryExprInner(c: *Context, m: *MacroCtx, scope: *Scope) ParseError!*
},
else => return inner_node,
}
-
- // hack to get zig fmt to render a comma in builtin calls
- _ = try appendToken(c, .Comma, ",");
-
const node_to_cast = try parseCExpr(c, m, scope);
if (saw_l_paren and m.next().? != .RParen) {
@@ -4623,28 +4492,7 @@ fn parseCPrimaryExprInner(c: *Context, m: *MacroCtx, scope: *Scope) ParseError!*
return error.ParseError;
}
- const lparen = try appendToken(c, .LParen, "(");
-
- //(@import("std").meta.cast(dest, x))
- const import_fn_call = try c.createBuiltinCall("@import", 1);
- const std_node = try transCreateNodeStringLiteral(c, "\"std\"");
- import_fn_call.params()[0] = std_node;
- import_fn_call.rparen_token = try appendToken(c, .RParen, ")");
- const inner_field_access = try transCreateNodeFieldAccess(c, &import_fn_call.base, "meta");
- const outer_field_access = try transCreateNodeFieldAccess(c, inner_field_access, "cast");
-
- const cast_fn_call = try c.createCall(outer_field_access, 2);
- cast_fn_call.params()[0] = inner_node;
- cast_fn_call.params()[1] = node_to_cast;
- cast_fn_call.rtoken = try appendToken(c, .RParen, ")");
-
- const group_node = try c.arena.create(ast.Node.GroupedExpression);
- group_node.* = .{
- .lparen = lparen,
- .expr = &cast_fn_call.base,
- .rparen = try appendToken(c, .RParen, ")"),
- };
- return &group_node.base;
+ return Node.std_meta_cast.create(c.arena, .{ .lhs = inner_node, .rhs = node_to_cast });
},
else => {
try m.fail(c, "unable to translate C expr: unexpected token .{s}", .{@tagName(tok)});
@@ -4653,447 +4501,255 @@ fn parseCPrimaryExprInner(c: *Context, m: *MacroCtx, scope: *Scope) ParseError!*
}
}
-fn parseCPrimaryExpr(c: *Context, m: *MacroCtx, scope: *Scope) ParseError!*ast.Node {
+fn parseCPrimaryExpr(c: *Context, m: *MacroCtx, scope: *Scope) ParseError!Node {
var node = try parseCPrimaryExprInner(c, m, scope);
// In C the preprocessor would handle concatting strings while expanding macros.
// This should do approximately the same by concatting any strings and identifiers
// after a primary expression.
while (true) {
- var op_token: ast.TokenIndex = undefined;
- var op_id: ast.Node.Tag = undefined;
switch (m.peek().?) {
.StringLiteral, .Identifier => {},
else => break,
}
- const op_node = try c.arena.create(ast.Node.SimpleInfixOp);
- op_node.* = .{
- .base = .{ .tag = .ArrayCat },
- .op_token = try appendToken(c, .PlusPlus, "++"),
- .lhs = node,
- .rhs = try parseCPrimaryExprInner(c, m, scope),
- };
- node = &op_node.base;
+ node = try Node.array_cat.create(c.arena, .{ .lhs = node, .rhs = try parseCPrimaryExprInner(c, m, scope) });
}
return node;
}
-fn nodeIsInfixOp(tag: ast.Node.Tag) bool {
- return switch (tag) {
- .Add,
- .AddWrap,
- .ArrayCat,
- .ArrayMult,
- .Assign,
- .AssignBitAnd,
- .AssignBitOr,
- .AssignBitShiftLeft,
- .AssignBitShiftRight,
- .AssignBitXor,
- .AssignDiv,
- .AssignSub,
- .AssignSubWrap,
- .AssignMod,
- .AssignAdd,
- .AssignAddWrap,
- .AssignMul,
- .AssignMulWrap,
- .BangEqual,
- .BitAnd,
- .BitOr,
- .BitShiftLeft,
- .BitShiftRight,
- .BitXor,
- .BoolAnd,
- .BoolOr,
- .Div,
- .EqualEqual,
- .ErrorUnion,
- .GreaterOrEqual,
- .GreaterThan,
- .LessOrEqual,
- .LessThan,
- .MergeErrorSets,
- .Mod,
- .Mul,
- .MulWrap,
- .Period,
- .Range,
- .Sub,
- .SubWrap,
- .UnwrapOptional,
- .Catch,
- => true,
-
- else => false,
- };
-}
-
-fn macroBoolToInt(c: *Context, node: *ast.Node) !*ast.Node {
+fn macroBoolToInt(c: *Context, node: Node) !Node {
if (!isBoolRes(node)) {
- if (!nodeIsInfixOp(node.tag)) return node;
-
- const group_node = try c.arena.create(ast.Node.GroupedExpression);
- group_node.* = .{
- .lparen = try appendToken(c, .LParen, "("),
- .expr = node,
- .rparen = try appendToken(c, .RParen, ")"),
- };
- return &group_node.base;
+ return node;
}
- const builtin_node = try c.createBuiltinCall("@boolToInt", 1);
- builtin_node.params()[0] = node;
- builtin_node.rparen_token = try appendToken(c, .RParen, ")");
- return &builtin_node.base;
+ return Node.bool_to_int.create(c.arena, node);
}
-fn macroIntToBool(c: *Context, node: *ast.Node) !*ast.Node {
+fn macroIntToBool(c: *Context, node: Node) !Node {
if (isBoolRes(node)) {
- if (!nodeIsInfixOp(node.tag)) return node;
-
- const group_node = try c.arena.create(ast.Node.GroupedExpression);
- group_node.* = .{
- .lparen = try appendToken(c, .LParen, "("),
- .expr = node,
- .rparen = try appendToken(c, .RParen, ")"),
- };
- return &group_node.base;
+ return node;
}
- const op_token = try appendToken(c, .BangEqual, "!=");
- const zero = try transCreateNodeInt(c, 0);
- const res = try c.arena.create(ast.Node.SimpleInfixOp);
- res.* = .{
- .base = .{ .tag = .BangEqual },
- .op_token = op_token,
- .lhs = node,
- .rhs = zero,
- };
- const group_node = try c.arena.create(ast.Node.GroupedExpression);
- group_node.* = .{
- .lparen = try appendToken(c, .LParen, "("),
- .expr = &res.base,
- .rparen = try appendToken(c, .RParen, ")"),
- };
- return &group_node.base;
-}
-
-fn macroGroup(c: *Context, node: *ast.Node) !*ast.Node {
- if (!nodeIsInfixOp(node.tag)) return node;
-
- const group_node = try c.arena.create(ast.Node.GroupedExpression);
- group_node.* = .{
- .lparen = try appendToken(c, .LParen, "("),
- .expr = node,
- .rparen = try appendToken(c, .RParen, ")"),
- };
- return &group_node.base;
+ return Node.not_equal.create(c.arena, .{ .lhs = node, .rhs = Node.zero_literal.init() });
}
-fn parseCCondExpr(c: *Context, m: *MacroCtx, scope: *Scope) ParseError!*ast.Node {
+fn parseCCondExpr(c: *Context, m: *MacroCtx, scope: *Scope) ParseError!Node {
const node = try parseCOrExpr(c, m, scope);
if (m.peek().? != .QuestionMark) {
return node;
}
_ = m.next();
- // must come immediately after expr
- _ = try appendToken(c, .RParen, ")");
- const if_node = try transCreateNodeIf(c);
- if_node.condition = node;
- if_node.body = try parseCOrExpr(c, m, scope);
+ const then_body = try parseCOrExpr(c, m, scope);
if (m.next().? != .Colon) {
try m.fail(c, "unable to translate C expr: expected ':'", .{});
return error.ParseError;
}
- if_node.@"else" = try transCreateNodeElse(c);
- if_node.@"else".?.body = try parseCCondExpr(c, m, scope);
- return &if_node.base;
+ const else_body = try parseCCondExpr(c, m, scope);
+ return Node.@"if".create(c.arena, .{ .cond = node, .then = then_body, .@"else" = else_body });
}
-fn parseCOrExpr(c: *Context, m: *MacroCtx, scope: *Scope) ParseError!*ast.Node {
+fn parseCOrExpr(c: *Context, m: *MacroCtx, scope: *Scope) ParseError!Node {
var node = try parseCAndExpr(c, m, scope);
while (m.next().? == .PipePipe) {
- const lhs_node = try macroIntToBool(c, node);
- const op_token = try appendToken(c, .Keyword_or, "or");
- const rhs_node = try parseCAndExpr(c, m, scope);
- const op_node = try c.arena.create(ast.Node.SimpleInfixOp);
- op_node.* = .{
- .base = .{ .tag = .BoolOr },
- .op_token = op_token,
- .lhs = lhs_node,
- .rhs = try macroIntToBool(c, rhs_node),
- };
- node = &op_node.base;
+ const lhs = try macroIntToBool(c, node);
+ const rhs = try macroIntToBool(c, try parseCAndExpr(c, m, scope));
+ node = try Node.@"or".create(c.arena, .{ .lhs = lhs, .rhs = rhs });
}
m.i -= 1;
return node;
}
-fn parseCAndExpr(c: *Context, m: *MacroCtx, scope: *Scope) ParseError!*ast.Node {
+fn parseCAndExpr(c: *Context, m: *MacroCtx, scope: *Scope) ParseError!Node {
var node = try parseCBitOrExpr(c, m, scope);
while (m.next().? == .AmpersandAmpersand) {
- const lhs_node = try macroIntToBool(c, node);
- const op_token = try appendToken(c, .Keyword_and, "and");
- const rhs_node = try parseCBitOrExpr(c, m, scope);
- const op_node = try c.arena.create(ast.Node.SimpleInfixOp);
- op_node.* = .{
- .base = .{ .tag = .BoolAnd },
- .op_token = op_token,
- .lhs = lhs_node,
- .rhs = try macroIntToBool(c, rhs_node),
- };
- node = &op_node.base;
+ const lhs = try macroIntToBool(c, node);
+ const rhs = try macroIntToBool(c, try parseCBitOrExpr(c, m, scope));
+ node = try Node.@"and".create(c.arena, .{ .lhs = lhs, .rhs = rhs });
}
m.i -= 1;
return node;
}
-fn parseCBitOrExpr(c: *Context, m: *MacroCtx, scope: *Scope) ParseError!*ast.Node {
+fn parseCBitOrExpr(c: *Context, m: *MacroCtx, scope: *Scope) ParseError!Node {
var node = try parseCBitXorExpr(c, m, scope);
while (m.next().? == .Pipe) {
- const lhs_node = try macroBoolToInt(c, node);
- const op_token = try appendToken(c, .Pipe, "|");
- const rhs_node = try parseCBitXorExpr(c, m, scope);
- const op_node = try c.arena.create(ast.Node.SimpleInfixOp);
- op_node.* = .{
- .base = .{ .tag = .BitOr },
- .op_token = op_token,
- .lhs = lhs_node,
- .rhs = try macroBoolToInt(c, rhs_node),
- };
- node = &op_node.base;
+ const lhs = try macroBoolToInt(c, node);
+ const rhs = try macroBoolToInt(c, try parseCBitXorExpr(c, m, scope));
+ node = try Node.bit_or.create(c.arena, .{ .lhs = lhs, .rhs = rhs });
}
m.i -= 1;
return node;
}
-fn parseCBitXorExpr(c: *Context, m: *MacroCtx, scope: *Scope) ParseError!*ast.Node {
+fn parseCBitXorExpr(c: *Context, m: *MacroCtx, scope: *Scope) ParseError!Node {
var node = try parseCBitAndExpr(c, m, scope);
while (m.next().? == .Caret) {
- const lhs_node = try macroBoolToInt(c, node);
- const op_token = try appendToken(c, .Caret, "^");
- const rhs_node = try parseCBitAndExpr(c, m, scope);
- const op_node = try c.arena.create(ast.Node.SimpleInfixOp);
- op_node.* = .{
- .base = .{ .tag = .BitXor },
- .op_token = op_token,
- .lhs = lhs_node,
- .rhs = try macroBoolToInt(c, rhs_node),
- };
- node = &op_node.base;
+ const lhs = try macroBoolToInt(c, node);
+ const rhs = try macroBoolToInt(c, try parseCBitAndExpr(c, m, scope));
+ node = try Node.bit_xor.create(c.arena, .{ .lhs = lhs, .rhs = rhs });
}
m.i -= 1;
return node;
}
-fn parseCBitAndExpr(c: *Context, m: *MacroCtx, scope: *Scope) ParseError!*ast.Node {
+fn parseCBitAndExpr(c: *Context, m: *MacroCtx, scope: *Scope) ParseError!Node {
var node = try parseCEqExpr(c, m, scope);
while (m.next().? == .Ampersand) {
- const lhs_node = try macroBoolToInt(c, node);
- const op_token = try appendToken(c, .Ampersand, "&");
- const rhs_node = try parseCEqExpr(c, m, scope);
- const op_node = try c.arena.create(ast.Node.SimpleInfixOp);
- op_node.* = .{
- .base = .{ .tag = .BitAnd },
- .op_token = op_token,
- .lhs = lhs_node,
- .rhs = try macroBoolToInt(c, rhs_node),
- };
- node = &op_node.base;
+ const lhs = try macroBoolToInt(c, node);
+ const rhs = try macroBoolToInt(c, try parseCEqExpr(c, m, scope));
+ node = try Node.bit_and.create(c.arena, .{ .lhs = lhs, .rhs = rhs });
}
m.i -= 1;
return node;
}
-fn parseCEqExpr(c: *Context, m: *MacroCtx, scope: *Scope) ParseError!*ast.Node {
+fn parseCEqExpr(c: *Context, m: *MacroCtx, scope: *Scope) ParseError!Node {
var node = try parseCRelExpr(c, m, scope);
while (true) {
- var op_token: ast.TokenIndex = undefined;
- var op_id: ast.Node.Tag = undefined;
switch (m.peek().?) {
.BangEqual => {
- op_token = try appendToken(c, .BangEqual, "!=");
- op_id = .BangEqual;
+ _ = m.next();
+ const lhs = try macroBoolToInt(c, node);
+ const rhs = try macroBoolToInt(c, try parseCRelExpr(c, m, scope));
+ node = try Node.not_equal.create(c.arena, .{ .lhs = lhs, .rhs = rhs });
},
.EqualEqual => {
- op_token = try appendToken(c, .EqualEqual, "==");
- op_id = .EqualEqual;
+ _ = m.next();
+ const lhs = try macroBoolToInt(c, node);
+ const rhs = try macroBoolToInt(c, try parseCRelExpr(c, m, scope));
+ node = try Node.equal.create(c.arena, .{ .lhs = lhs, .rhs = rhs });
},
else => return node,
}
- _ = m.next();
- const lhs_node = try macroBoolToInt(c, node);
- const rhs_node = try parseCRelExpr(c, m, scope);
- const op_node = try c.arena.create(ast.Node.SimpleInfixOp);
- op_node.* = .{
- .base = .{ .tag = op_id },
- .op_token = op_token,
- .lhs = lhs_node,
- .rhs = try macroBoolToInt(c, rhs_node),
- };
- node = &op_node.base;
}
}
-fn parseCRelExpr(c: *Context, m: *MacroCtx, scope: *Scope) ParseError!*ast.Node {
+fn parseCRelExpr(c: *Context, m: *MacroCtx, scope: *Scope) ParseError!Node {
var node = try parseCShiftExpr(c, m, scope);
while (true) {
- var op_token: ast.TokenIndex = undefined;
- var op_id: ast.Node.Tag = undefined;
switch (m.peek().?) {
.AngleBracketRight => {
- op_token = try appendToken(c, .AngleBracketRight, ">");
- op_id = .GreaterThan;
+ _ = m.next();
+ const lhs = try macroBoolToInt(c, node);
+ const rhs = try macroBoolToInt(c, try parseCShiftExpr(c, m, scope));
+ node = try Node.greater_than.create(c.arena, .{ .lhs = lhs, .rhs = rhs });
},
.AngleBracketRightEqual => {
- op_token = try appendToken(c, .AngleBracketRightEqual, ">=");
- op_id = .GreaterOrEqual;
+ _ = m.next();
+ const lhs = try macroBoolToInt(c, node);
+ const rhs = try macroBoolToInt(c, try parseCShiftExpr(c, m, scope));
+ node = try Node.greater_than_equal.create(c.arena, .{ .lhs = lhs, .rhs = rhs });
},
.AngleBracketLeft => {
- op_token = try appendToken(c, .AngleBracketLeft, "<");
- op_id = .LessThan;
+ _ = m.next();
+ const lhs = try macroBoolToInt(c, node);
+ const rhs = try macroBoolToInt(c, try parseCShiftExpr(c, m, scope));
+ node = try Node.less_than.create(c.arena, .{ .lhs = lhs, .rhs = rhs });
},
.AngleBracketLeftEqual => {
- op_token = try appendToken(c, .AngleBracketLeftEqual, "<=");
- op_id = .LessOrEqual;
+ _ = m.next();
+ const lhs = try macroBoolToInt(c, node);
+ const rhs = try macroBoolToInt(c, try parseCShiftExpr(c, m, scope));
+ node = try Node.less_than_equal.create(c.arena, .{ .lhs = lhs, .rhs = rhs });
},
else => return node,
}
- _ = m.next();
- const lhs_node = try macroBoolToInt(c, node);
- const rhs_node = try parseCShiftExpr(c, m, scope);
- const op_node = try c.arena.create(ast.Node.SimpleInfixOp);
- op_node.* = .{
- .base = .{ .tag = op_id },
- .op_token = op_token,
- .lhs = lhs_node,
- .rhs = try macroBoolToInt(c, rhs_node),
- };
- node = &op_node.base;
}
}
-fn parseCShiftExpr(c: *Context, m: *MacroCtx, scope: *Scope) ParseError!*ast.Node {
+fn parseCShiftExpr(c: *Context, m: *MacroCtx, scope: *Scope) ParseError!Node {
var node = try parseCAddSubExpr(c, m, scope);
while (true) {
- var op_token: ast.TokenIndex = undefined;
- var op_id: ast.Node.Tag = undefined;
switch (m.peek().?) {
.AngleBracketAngleBracketLeft => {
- op_token = try appendToken(c, .AngleBracketAngleBracketLeft, "<<");
- op_id = .BitShiftLeft;
+ _ = m.next();
+ const lhs = try macroBoolToInt(c, node);
+ const rhs = try macroBoolToInt(c, try parseCAddSubExpr(c, m, scope));
+ node = try Node.shl.create(c.arena, .{ .lhs = lhs, .rhs = rhs });
},
.AngleBracketAngleBracketRight => {
- op_token = try appendToken(c, .AngleBracketAngleBracketRight, ">>");
- op_id = .BitShiftRight;
+ _ = m.next();
+ const lhs = try macroBoolToInt(c, node);
+ const rhs = try macroBoolToInt(c, try parseCAddSubExpr(c, m, scope));
+ node = try Node.shr.create(c.arena, .{ .lhs = lhs, .rhs = rhs });
},
else => return node,
}
- _ = m.next();
- const lhs_node = try macroBoolToInt(c, node);
- const rhs_node = try parseCAddSubExpr(c, m, scope);
- const op_node = try c.arena.create(ast.Node.SimpleInfixOp);
- op_node.* = .{
- .base = .{ .tag = op_id },
- .op_token = op_token,
- .lhs = lhs_node,
- .rhs = try macroBoolToInt(c, rhs_node),
- };
- node = &op_node.base;
}
}
-fn parseCAddSubExpr(c: *Context, m: *MacroCtx, scope: *Scope) ParseError!*ast.Node {
+fn parseCAddSubExpr(c: *Context, m: *MacroCtx, scope: *Scope) ParseError!Node {
var node = try parseCMulExpr(c, m, scope);
while (true) {
- var op_token: ast.TokenIndex = undefined;
- var op_id: ast.Node.Tag = undefined;
switch (m.peek().?) {
.Plus => {
- op_token = try appendToken(c, .Plus, "+");
- op_id = .Add;
+ _ = m.next();
+ const lhs = try macroBoolToInt(c, node);
+ const rhs = try macroBoolToInt(c, try parseCMulExpr(c, m, scope));
+ node = try Node.add.create(c.arena, .{ .lhs = lhs, .rhs = rhs });
},
.Minus => {
- op_token = try appendToken(c, .Minus, "-");
- op_id = .Sub;
+ _ = m.next();
+ const lhs = try macroBoolToInt(c, node);
+ const rhs = try macroBoolToInt(c, try parseCMulExpr(c, m, scope));
+ node = try Node.sub.create(c.arena, .{ .lhs = lhs, .rhs = rhs });
},
else => return node,
}
- _ = m.next();
- const lhs_node = try macroBoolToInt(c, node);
- const rhs_node = try parseCMulExpr(c, m, scope);
- const op_node = try c.arena.create(ast.Node.SimpleInfixOp);
- op_node.* = .{
- .base = .{ .tag = op_id },
- .op_token = op_token,
- .lhs = lhs_node,
- .rhs = try macroBoolToInt(c, rhs_node),
- };
- node = &op_node.base;
}
}
-fn parseCMulExpr(c: *Context, m: *MacroCtx, scope: *Scope) ParseError!*ast.Node {
+fn parseCMulExpr(c: *Context, m: *MacroCtx, scope: *Scope) ParseError!Node {
var node = try parseCUnaryExpr(c, m, scope);
while (true) {
- var op_token: ast.TokenIndex = undefined;
- var op_id: ast.Node.Tag = undefined;
switch (m.next().?) {
.Asterisk => {
if (m.peek().? == .RParen) {
// type *)
- // hack to get zig fmt to render a comma in builtin calls
- _ = try appendToken(c, .Comma, ",");
-
// last token of `node`
const prev_id = m.list[m.i - 1].id;
if (prev_id == .Keyword_void) {
- const ptr = try transCreateNodePtrType(c, false, false, .Asterisk);
- ptr.rhs = node;
- const optional_node = try transCreateNodeSimplePrefixOp(c, .OptionalType, .QuestionMark, "?");
- optional_node.rhs = &ptr.base;
- return &optional_node.base;
+ const ptr = try Node.single_pointer.create(c.arena, .{
+ .is_const = false,
+ .is_volatile = false,
+ .elem_type = node,
+ });
+ return Node.optional_type.create(c.arena, ptr);
} else {
- const ptr = try transCreateNodePtrType(c, false, false, Token.Id.Identifier);
- ptr.rhs = node;
- return &ptr.base;
+ return Node.c_pointer.create(c.arena, .{
+ .is_const = false,
+ .is_volatile = false,
+ .elem_type = node,
+ });
}
} else {
// expr * expr
- op_token = try appendToken(c, .Asterisk, "*");
- op_id = .BitShiftLeft;
+ const lhs = try macroBoolToInt(c, node);
+ const rhs = try macroBoolToInt(c, try parseCUnaryExpr(c, m, scope));
+ node = try Node.mul.create(c.arena, .{ .lhs = lhs, .rhs = rhs });
}
},
.Slash => {
- op_id = .Div;
- op_token = try appendToken(c, .Slash, "/");
+ const lhs = try macroBoolToInt(c, node);
+ const rhs = try macroBoolToInt(c, try parseCUnaryExpr(c, m, scope));
+ node = try Node.div.create(c.arena, .{ .lhs = lhs, .rhs = rhs });
},
.Percent => {
- op_id = .Mod;
- op_token = try appendToken(c, .Percent, "%");
+ const lhs = try macroBoolToInt(c, node);
+ const rhs = try macroBoolToInt(c, try parseCUnaryExpr(c, m, scope));
+ node = try Node.mod.create(c.arena, .{ .lhs = lhs, .rhs = rhs });
},
else => {
m.i -= 1;
return node;
},
}
- const lhs_node = try macroBoolToInt(c, node);
- const rhs_node = try parseCUnaryExpr(c, m, scope);
- const op_node = try c.arena.create(ast.Node.SimpleInfixOp);
- op_node.* = .{
- .base = .{ .tag = op_id },
- .op_token = op_token,
- .lhs = lhs_node,
- .rhs = try macroBoolToInt(c, rhs_node),
- };
- node = &op_node.base;
}
}
-fn parseCPostfixExpr(c: *Context, m: *MacroCtx, scope: *Scope) ParseError!*ast.Node {
+fn parseCPostfixExpr(c: *Context, m: *MacroCtx, scope: *Scope) ParseError!Node {
var node = try parseCPrimaryExpr(c, m, scope);
while (true) {
switch (m.next().?) {
@@ -5103,38 +4759,31 @@ fn parseCPostfixExpr(c: *Context, m: *MacroCtx, scope: *Scope) ParseError!*ast.N
return error.ParseError;
}
- node = try transCreateNodeFieldAccess(c, node, m.slice());
- continue;
+ const ident = try Node.identifier.create(c.arena, m.slice());
+ node = try Node.field_access.create(c.arena, .{ .lhs = node, .rhs = ident });
},
.Arrow => {
if (m.next().? != .Identifier) {
try m.fail(c, "unable to translate C expr: expected identifier", .{});
return error.ParseError;
}
- const deref = try transCreateNodePtrDeref(c, node);
- node = try transCreateNodeFieldAccess(c, deref, m.slice());
- continue;
+
+ const deref = try Node.deref.create(c.arena, node);
+ const ident = try Node.identifier.create(c.arena, m.slice());
+ node = try Node.field_access.create(c.arena, .{ .lhs = deref, .rhs = ident });
},
.LBracket => {
- const arr_node = try transCreateNodeArrayAccess(c, node);
- arr_node.index_expr = try parseCExpr(c, m, scope);
- arr_node.rtoken = try appendToken(c, .RBracket, "]");
- node = &arr_node.base;
- if (m.next().? != .RBracket) {
- try m.fail(c, "unable to translate C expr: expected ']'", .{});
- return error.ParseError;
- }
- continue;
+ const index = try macroBoolToInt(c, try parseCExpr(c, m, scope));
+ node = try Node.array_access.create(c.arena, .{ .lhs = node, .rhs = index });
},
.LParen => {
- _ = try appendToken(c, .LParen, "(");
- var call_params = std.ArrayList(*ast.Node).init(c.gpa);
+ var call_params = std.ArrayList(Node).init(c.gpa);
defer call_params.deinit();
while (true) {
const arg = try parseCCondExpr(c, m, scope);
try call_params.append(arg);
switch (m.next().?) {
- .Comma => _ = try appendToken(c, .Comma, ","),
+ .Comma => {},
.RParen => break,
else => {
try m.fail(c, "unable to translate C expr: expected ',' or ')'", .{});
@@ -5142,32 +4791,17 @@ fn parseCPostfixExpr(c: *Context, m: *MacroCtx, scope: *Scope) ParseError!*ast.N
},
}
}
- const call_node = try ast.Node.Call.alloc(c.arena, call_params.items.len);
- call_node.* = .{
- .lhs = node,
- .params_len = call_params.items.len,
- .async_token = null,
- .rtoken = try appendToken(c, .RParen, ")"),
- };
- mem.copy(*ast.Node, call_node.params(), call_params.items);
- node = &call_node.base;
- continue;
+ node = try Node.call.create(c.arena, .{ .lhs = node, .rhs = try c.arena.dupe(Node, call_params.items) });
},
.LBrace => {
- // must come immediately after `node`
- _ = try appendToken(c, .Comma, ",");
-
- const dot = try appendToken(c, .Period, ".");
- _ = try appendToken(c, .LBrace, "{");
-
- var init_vals = std.ArrayList(*ast.Node).init(c.gpa);
+ var init_vals = std.ArrayList(Node).init(c.gpa);
defer init_vals.deinit();
while (true) {
const val = try parseCCondExpr(c, m, scope);
try init_vals.append(val);
switch (m.next().?) {
- .Comma => _ = try appendToken(c, .Comma, ","),
+ .Comma => {},
.RBrace => break,
else => {
try m.fail(c, "unable to translate C expr: expected ',' or '}}'", .{});
@@ -5175,29 +4809,8 @@ fn parseCPostfixExpr(c: *Context, m: *MacroCtx, scope: *Scope) ParseError!*ast.N
},
}
}
- const tuple_node = try ast.Node.StructInitializerDot.alloc(c.arena, init_vals.items.len);
- tuple_node.* = .{
- .dot = dot,
- .list_len = init_vals.items.len,
- .rtoken = try appendToken(c, .RBrace, "}"),
- };
- mem.copy(*ast.Node, tuple_node.list(), init_vals.items);
-
- //(@import("std").mem.zeroInit(T, .{x}))
- const import_fn_call = try c.createBuiltinCall("@import", 1);
- const std_node = try transCreateNodeStringLiteral(c, "\"std\"");
- import_fn_call.params()[0] = std_node;
- import_fn_call.rparen_token = try appendToken(c, .RParen, ")");
- const inner_field_access = try transCreateNodeFieldAccess(c, &import_fn_call.base, "mem");
- const outer_field_access = try transCreateNodeFieldAccess(c, inner_field_access, "zeroInit");
-
- const zero_init_call = try c.createCall(outer_field_access, 2);
- zero_init_call.params()[0] = node;
- zero_init_call.params()[1] = &tuple_node.base;
- zero_init_call.rtoken = try appendToken(c, .RParen, ")");
-
- node = &zero_init_call.base;
- continue;
+ const tuple_node = try Node.tuple.create(c.arena, try c.arena.dupe(Node, init_vals.items));
+ node = try Node.std_mem_zeroinit.create(c.arena, .{ .lhs = node, .rhs = tuple_node });
},
.PlusPlus, .MinusMinus => {
try m.fail(c, "TODO postfix inc/dec expr", .{});
@@ -5211,35 +4824,31 @@ fn parseCPostfixExpr(c: *Context, m: *MacroCtx, scope: *Scope) ParseError!*ast.N
}
}
-fn parseCUnaryExpr(c: *Context, m: *MacroCtx, scope: *Scope) ParseError!*ast.Node {
+fn parseCUnaryExpr(c: *Context, m: *MacroCtx, scope: *Scope) ParseError!Node {
switch (m.next().?) {
.Bang => {
- const node = try transCreateNodeSimplePrefixOp(c, .BoolNot, .Bang, "!");
- node.rhs = try macroIntToBool(c, try parseCUnaryExpr(c, m, scope));
- return &node.base;
+ const operand = try macroIntToBool(c, try parseCUnaryExpr(c, m, scope));
+ return Node.not.create(c.arena, operand);
},
.Minus => {
- const node = try transCreateNodeSimplePrefixOp(c, .Negation, .Minus, "-");
- node.rhs = try macroBoolToInt(c, try parseCUnaryExpr(c, m, scope));
- return &node.base;
+ const operand = try macroBoolToInt(c, try parseCUnaryExpr(c, m, scope));
+ return Node.negate.create(c.arena, operand);
},
.Plus => return try parseCUnaryExpr(c, m, scope),
.Tilde => {
- const node = try transCreateNodeSimplePrefixOp(c, .BitNot, .Tilde, "~");
- node.rhs = try macroBoolToInt(c, try parseCUnaryExpr(c, m, scope));
- return &node.base;
+ const operand = try macroBoolToInt(c, try parseCUnaryExpr(c, m, scope));
+ return Node.bit_not.create(c.arena, operand);
},
.Asterisk => {
- const node = try macroGroup(c, try parseCUnaryExpr(c, m, scope));
- return try transCreateNodePtrDeref(c, node);
+ const operand = try parseCUnaryExpr(c, m, scope);
+ return Node.deref.create(c.arena, operand);
},
.Ampersand => {
- const node = try transCreateNodeSimplePrefixOp(c, .AddressOf, .Ampersand, "&");
- node.rhs = try macroGroup(c, try parseCUnaryExpr(c, m, scope));
- return &node.base;
+ const operand = try parseCUnaryExpr(c, m, scope);
+ return Node.address_of.create(c.arena, operand);
},
.Keyword_sizeof => {
- const inner = if (m.peek().? == .LParen) blk: {
+ const operand = if (m.peek().? == .LParen) blk: {
_ = m.next();
// C grammar says this should be 'type-name' but we have to
// use parseCMulExpr to correctly handle pointer types.
@@ -5251,18 +4860,7 @@ fn parseCUnaryExpr(c: *Context, m: *MacroCtx, scope: *Scope) ParseError!*ast.Nod
break :blk inner;
} else try parseCUnaryExpr(c, m, scope);
- //(@import("std").meta.sizeof(dest, x))
- const import_fn_call = try c.createBuiltinCall("@import", 1);
- const std_node = try transCreateNodeStringLiteral(c, "\"std\"");
- import_fn_call.params()[0] = std_node;
- import_fn_call.rparen_token = try appendToken(c, .RParen, ")");
- const inner_field_access = try transCreateNodeFieldAccess(c, &import_fn_call.base, "meta");
- const outer_field_access = try transCreateNodeFieldAccess(c, inner_field_access, "sizeof");
-
- const sizeof_call = try c.createCall(outer_field_access, 1);
- sizeof_call.params()[0] = inner;
- sizeof_call.rtoken = try appendToken(c, .RParen, ")");
- return &sizeof_call.base;
+ return Node.std_meta_sizeof.create(c.arena, operand);
},
.Keyword_alignof => {
// TODO this won't work if using <stdalign.h>'s
@@ -5273,16 +4871,13 @@ fn parseCUnaryExpr(c: *Context, m: *MacroCtx, scope: *Scope) ParseError!*ast.Nod
}
// C grammar says this should be 'type-name' but we have to
// use parseCMulExpr to correctly handle pointer types.
- const inner = try parseCMulExpr(c, m, scope);
+ const operand = try parseCMulExpr(c, m, scope);
if (m.next().? != .RParen) {
try m.fail(c, "unable to translate C expr: expected ')'", .{});
return error.ParseError;
}
- const builtin_call = try c.createBuiltinCall("@alignOf", 1);
- builtin_call.params()[0] = inner;
- builtin_call.rparen_token = try appendToken(c, .RParen, ")");
- return &builtin_call.base;
+ return Node.alignof.create(c.arena, operand);
},
.PlusPlus, .MinusMinus => {
try m.fail(c, "TODO unary inc/dec expr", .{});
@@ -5295,50 +4890,40 @@ fn parseCUnaryExpr(c: *Context, m: *MacroCtx, scope: *Scope) ParseError!*ast.Nod
}
}
-fn tokenSlice(c: *Context, token: ast.TokenIndex) []u8 {
- const tok = c.token_locs.items[token];
- const slice = c.source_buffer.items[tok.start..tok.end];
- return if (mem.startsWith(u8, slice, "@\""))
- slice[2 .. slice.len - 1]
- else
- slice;
-}
-
-fn getContainer(c: *Context, node: *ast.Node) ?*ast.Node {
- switch (node.tag) {
- .ContainerDecl,
- .AddressOf,
- .Await,
- .BitNot,
- .BoolNot,
- .OptionalType,
- .Negation,
- .NegationWrap,
- .Resume,
- .Try,
- .ArrayType,
- .ArrayTypeSentinel,
- .PtrType,
- .SliceType,
+fn getContainer(c: *Context, node: Node) ?Node {
+ switch (node.tag()) {
+ .@"union",
+ .@"struct",
+ .@"enum",
+ .address_of,
+ .bit_not,
+ .not,
+ .optional_type,
+ .negate,
+ .negate_wrap,
+ .array_type,
+ .c_pointer,
+ .single_pointer,
=> return node,
- .Identifier => {
- const ident = node.castTag(.Identifier).?;
- if (c.global_scope.sym_table.get(tokenSlice(c, ident.token))) |value| {
- if (value.cast(ast.Node.VarDecl)) |var_decl|
- return getContainer(c, var_decl.getInitNode().?);
+ .identifier => {
+ const ident = node.castTag(.identifier).?;
+ if (c.global_scope.sym_table.get(ident.data)) |value| {
+ if (value.castTag(.var_decl)) |var_decl|
+ return getContainer(c, var_decl.data.init);
+ if (value.castTag(.var_simple) orelse value.castTag(.pub_var_simple)) |var_decl|
+ return getContainer(c, var_decl.data.init);
}
},
- .Period => {
- const infix = node.castTag(.Period).?;
+ .field_access => {
+ const infix = node.castTag(.field_access).?;
- if (getContainerTypeOf(c, infix.lhs)) |ty_node| {
- if (ty_node.cast(ast.Node.ContainerDecl)) |container| {
- for (container.fieldsAndDecls()) |field_ref| {
- const field = field_ref.cast(ast.Node.ContainerField).?;
- const ident = infix.rhs.castTag(.Identifier).?;
- if (mem.eql(u8, tokenSlice(c, field.name_token), tokenSlice(c, ident.token))) {
+ if (getContainerTypeOf(c, infix.data.lhs)) |ty_node| {
+ if (ty_node.castTag(.@"struct") orelse ty_node.castTag(.@"union")) |container| {
+ for (container.data.fields) |field| {
+ const ident = infix.data.rhs.castTag(.identifier).?;
+ if (mem.eql(u8, field.data.name, field.data)) {
return getContainer(c, field.type_expr.?);
}
}
@@ -5351,22 +4936,20 @@ fn getContainer(c: *Context, node: *ast.Node) ?*ast.Node {
return null;
}
-fn getContainerTypeOf(c: *Context, ref: *ast.Node) ?*ast.Node {
- if (ref.castTag(.Identifier)) |ident| {
- if (c.global_scope.sym_table.get(tokenSlice(c, ident.token))) |value| {
- if (value.cast(ast.Node.VarDecl)) |var_decl| {
- if (var_decl.getTypeNode()) |ty|
- return getContainer(c, ty);
+fn getContainerTypeOf(c: *Context, ref: Node) ?Node {
+ if (ref.castTag(.identifier)) |ident| {
+ if (c.global_scope.sym_table.get(ident.data)) |value| {
+ if (value.castTag(.var_decl)) |var_decl| {
+ return getContainer(c, var_decl.data.type);
}
}
- } else if (ref.castTag(.Period)) |infix| {
- if (getContainerTypeOf(c, infix.lhs)) |ty_node| {
- if (ty_node.cast(ast.Node.ContainerDecl)) |container| {
- for (container.fieldsAndDecls()) |field_ref| {
- const field = field_ref.cast(ast.Node.ContainerField).?;
- const ident = infix.rhs.castTag(.Identifier).?;
- if (mem.eql(u8, tokenSlice(c, field.name_token), tokenSlice(c, ident.token))) {
- return getContainer(c, field.type_expr.?);
+ } else if (ref.castTag(.field_access)) |infix| {
+ if (getContainerTypeOf(c, infix.data.lhs)) |ty_node| {
+ if (ty_node.castTag(.@"struct") orelse ty_node.castTag(.@"union")) |container| {
+ for (container.data.fields) |field| {
+ const ident = infix.data.rhs.castTag(.identifier).?;
+ if (mem.eql(u8, field.name, ident.data)) {
+ return getContainer(c, field.type);
}
}
} else
@@ -5376,11 +4959,16 @@ fn getContainerTypeOf(c: *Context, ref: *ast.Node) ?*ast.Node {
return null;
}
-fn getFnProto(c: *Context, ref: *ast.Node) ?*ast.Node.FnProto {
- const init = if (ref.cast(ast.Node.VarDecl)) |v| v.getInitNode().? else return null;
+fn getFnProto(c: *Context, ref: Node) ?*ast.Payload.Func {
+ const init = if (value.castTag(.var_decl)) |v|
+ v.data.init
+ else if (value.castTag(.var_simple) orelse value.castTag(.pub_var_simple)) |v|
+ v.data.init
+ else
+ return null;
if (getContainerTypeOf(c, init)) |ty_node| {
- if (ty_node.castTag(.OptionalType)) |prefix| {
- if (prefix.rhs.cast(ast.Node.FnProto)) |fn_proto| {
+ if (ty_node.castTag(.optional_type)) |prefix| {
+ if (prefix.data.castTag(.func)) |fn_proto| {
return fn_proto;
}
}