| ... | @@ -3,23 +3,24 @@ | ... | @@ -3,23 +3,24 @@ |
| 3 | | 3 | |
| 4 | const std = @import("std"); | 4 | const std = @import("std"); |
| 5 | const assert = std.debug.assert; | 5 | const assert = std.debug.assert; |
| 6 | const ast = std.zig.ast; | | |
| 7 | const Token = std.zig.Token; | | |
| 8 | const clang = @import("clang.zig"); | 6 | const clang = @import("clang.zig"); |
| 9 | const ctok = std.c.tokenizer; | 7 | const ctok = std.c.tokenizer; |
| 10 | const CToken = std.c.Token; | 8 | const CToken = std.c.Token; |
| 11 | const mem = std.mem; | 9 | const mem = std.mem; |
| 12 | const math = std.math; | 10 | const math = std.math; |
| | 11 | const ast = @import("translate_c/ast.zig"); |
| | 12 | const Node = ast.Node; |
| | 13 | const Tag = Node.Tag; |
| 13 | | 14 | |
| 14 | const CallingConvention = std.builtin.CallingConvention; | 15 | const CallingConvention = std.builtin.CallingConvention; |
| 15 | | 16 | |
| 16 | pub const ClangErrMsg = clang.Stage2ErrorMsg; | 17 | pub const ClangErrMsg = clang.Stage2ErrorMsg; |
| 17 | | 18 | |
| 18 | pub const Error = error{OutOfMemory}; | 19 | pub const Error = std.mem.Allocator.Error; |
| 19 | const TypeError = Error || error{UnsupportedType}; | 20 | const TypeError = Error || error{UnsupportedType}; |
| 20 | const TransError = TypeError || error{UnsupportedTranslation}; | 21 | const TransError = TypeError || error{UnsupportedTranslation}; |
| 21 | | 22 | |
| 22 | const SymbolTable = std.StringArrayHashMap(*ast.Node); | 23 | const SymbolTable = std.StringArrayHashMap(Node); |
| 23 | const AliasList = std.ArrayList(struct { | 24 | const AliasList = std.ArrayList(struct { |
| 24 | alias: []const u8, | 25 | alias: []const u8, |
| 25 | name: []const u8, | 26 | name: []const u8, |
| ... | @@ -30,23 +31,11 @@ const Scope = struct { | ... | @@ -30,23 +31,11 @@ const Scope = struct { |
| 30 | parent: ?*Scope, | 31 | parent: ?*Scope, |
| 31 | | 32 | |
| 32 | const Id = enum { | 33 | const Id = enum { |
| 33 | Switch, | 34 | block, |
| 34 | Block, | 35 | root, |
| 35 | Root, | 36 | condition, |
| 36 | Condition, | 37 | loop, |
| 37 | Loop, | 38 | do_loop, |
| 38 | }; | | |
| 39 | | | |
| 40 | /// Represents an in-progress ast.Node.Switch. This struct is stack-allocated. | | |
| 41 | /// When it is deinitialized, it produces an ast.Node.Switch which is allocated | | |
| 42 | /// into the main arena. | | |
| 43 | const Switch = struct { | | |
| 44 | base: Scope, | | |
| 45 | pending_block: Block, | | |
| 46 | cases: []*ast.Node, | | |
| 47 | case_index: usize, | | |
| 48 | switch_label: ?[]const u8, | | |
| 49 | default_label: ?[]const u8, | | |
| 50 | }; | 39 | }; |
| 51 | | 40 | |
| 52 | /// Used for the scope of condition expressions, for example `if (cond)`. | 41 | /// Used for the scope of condition expressions, for example `if (cond)`. |
| ... | @@ -67,16 +56,15 @@ const Scope = struct { | ... | @@ -67,16 +56,15 @@ const Scope = struct { |
| 67 | } | 56 | } |
| 68 | }; | 57 | }; |
| 69 | | 58 | |
| 70 | /// Represents an in-progress ast.Node.Block. This struct is stack-allocated. | 59 | /// Represents an in-progress Node.Block. This struct is stack-allocated. |
| 71 | /// When it is deinitialized, it produces an ast.Node.Block which is allocated | 60 | /// When it is deinitialized, it produces an Node.Block which is allocated |
| 72 | /// into the main arena. | 61 | /// into the main arena. |
| 73 | const Block = struct { | 62 | const Block = struct { |
| 74 | base: Scope, | 63 | base: Scope, |
| 75 | statements: std.ArrayList(*ast.Node), | 64 | statements: std.ArrayList(Node), |
| 76 | variables: AliasList, | 65 | variables: AliasList, |
| 77 | label: ?ast.TokenIndex, | | |
| 78 | mangle_count: u32 = 0, | 66 | mangle_count: u32 = 0, |
| 79 | lbrace: ast.TokenIndex, | 67 | label: ?[]const u8 = null, |
| 80 | | 68 | |
| 81 | /// When the block corresponds to a function, keep track of the return type | 69 | /// When the block corresponds to a function, keep track of the return type |
| 82 | /// so that the return expression can be cast, if necessary | 70 | /// so that the return expression can be cast, if necessary |
| ... | @@ -85,17 +73,14 @@ const Scope = struct { | ... | @@ -85,17 +73,14 @@ const Scope = struct { |
| 85 | fn init(c: *Context, parent: *Scope, labeled: bool) !Block { | 73 | fn init(c: *Context, parent: *Scope, labeled: bool) !Block { |
| 86 | var blk = Block{ | 74 | var blk = Block{ |
| 87 | .base = .{ | 75 | .base = .{ |
| 88 | .id = .Block, | 76 | .id = .block, |
| 89 | .parent = parent, | 77 | .parent = parent, |
| 90 | }, | 78 | }, |
| 91 | .statements = std.ArrayList(*ast.Node).init(c.gpa), | 79 | .statements = std.ArrayList(Node).init(c.gpa), |
| 92 | .variables = AliasList.init(c.gpa), | 80 | .variables = AliasList.init(c.gpa), |
| 93 | .label = null, | | |
| 94 | .lbrace = try appendToken(c, .LBrace, "{"), | | |
| 95 | }; | 81 | }; |
| 96 | if (labeled) { | 82 | if (labeled) { |
| 97 | blk.label = try appendIdentifier(c, try blk.makeMangledName(c, "blk")); | 83 | blk.label = try blk.makeMangledName(c, "blk"); |
| 98 | _ = try appendToken(c, .Colon, ":"); | | |
| 99 | } | 84 | } |
| 100 | return blk; | 85 | return blk; |
| 101 | } | 86 | } |
| ... | @@ -106,31 +91,24 @@ const Scope = struct { | ... | @@ -106,31 +91,24 @@ const Scope = struct { |
| 106 | self.* = undefined; | 91 | self.* = undefined; |
| 107 | } | 92 | } |
| 108 | | 93 | |
| 109 | fn complete(self: *Block, c: *Context) !*ast.Node { | 94 | fn complete(self: *Block, c: *Context) !Node { |
| 110 | // We reserve 1 extra statement if the parent is a Loop. This is in case of | 95 | if (self.base.parent.?.id == .do_loop) { |
| 111 | // do while, we want to put `if (cond) break;` at the end. | 96 | // We reserve 1 extra statement if the parent is a do_loop. This is in case of |
| 112 | const alloc_len = self.statements.items.len + @boolToInt(self.base.parent.?.id == .Loop); | 97 | // do while, we want to put `if (cond) break;` at the end. |
| 113 | const rbrace = try appendToken(c, .RBrace, "}"); | 98 | const alloc_len = self.statements.items.len + @boolToInt(self.base.parent.?.id == .do_loop); |
| 114 | if (self.label) |label| { | 99 | var stmts = try c.arena.alloc(Node, alloc_len); |
| 115 | const node = try ast.Node.LabeledBlock.alloc(c.arena, alloc_len); | 100 | stmts.len = self.statements.items.len; |
| 116 | node.* = .{ | 101 | mem.copy(Node, stmts, self.statements.items); |
| 117 | .statements_len = self.statements.items.len, | 102 | return Tag.block.create(c.arena, .{ |
| 118 | .lbrace = self.lbrace, | 103 | .label = self.label, |
| 119 | .rbrace = rbrace, | 104 | .stmts = stmts, |
| 120 | .label = label, | 105 | }); |
| 121 | }; | | |
| 122 | mem.copy(*ast.Node, node.statements(), self.statements.items); | | |
| 123 | return &node.base; | | |
| 124 | } else { | | |
| 125 | const node = try ast.Node.Block.alloc(c.arena, alloc_len); | | |
| 126 | node.* = .{ | | |
| 127 | .statements_len = self.statements.items.len, | | |
| 128 | .lbrace = self.lbrace, | | |
| 129 | .rbrace = rbrace, | | |
| 130 | }; | | |
| 131 | mem.copy(*ast.Node, node.statements(), self.statements.items); | | |
| 132 | return &node.base; | | |
| 133 | } | 106 | } |
| | 107 | if (self.statements.items.len == 0) return Tag.empty_block.init(); |
| | 108 | return Tag.block.create(c.arena, .{ |
| | 109 | .label = self.label, |
| | 110 | .stmts = try c.arena.dupe(Node, self.statements.items), |
| | 111 | }); |
| 134 | } | 112 | } |
| 135 | | 113 | |
| 136 | /// Given the desired name, return a name that does not shadow anything from outer scopes. | 114 | /// Given the desired name, return a name that does not shadow anything from outer scopes. |
| ... | @@ -174,19 +152,27 @@ const Scope = struct { | ... | @@ -174,19 +152,27 @@ const Scope = struct { |
| 174 | sym_table: SymbolTable, | 152 | sym_table: SymbolTable, |
| 175 | macro_table: SymbolTable, | 153 | macro_table: SymbolTable, |
| 176 | context: *Context, | 154 | context: *Context, |
| | 155 | nodes: std.ArrayList(Node), |
| 177 | | 156 | |
| 178 | fn init(c: *Context) Root { | 157 | fn init(c: *Context) Root { |
| 179 | return .{ | 158 | return .{ |
| 180 | .base = .{ | 159 | .base = .{ |
| 181 | .id = .Root, | 160 | .id = .root, |
| 182 | .parent = null, | 161 | .parent = null, |
| 183 | }, | 162 | }, |
| 184 | .sym_table = SymbolTable.init(c.arena), | 163 | .sym_table = SymbolTable.init(c.gpa), |
| 185 | .macro_table = SymbolTable.init(c.arena), | 164 | .macro_table = SymbolTable.init(c.gpa), |
| 186 | .context = c, | 165 | .context = c, |
| | 166 | .nodes = std.ArrayList(Node).init(c.gpa), |
| 187 | }; | 167 | }; |
| 188 | } | 168 | } |
| 189 | | 169 | |
| | 170 | fn deinit(scope: *Root) void { |
| | 171 | scope.sym_table.deinit(); |
| | 172 | scope.macro_table.deinit(); |
| | 173 | scope.nodes.deinit(); |
| | 174 | } |
| | 175 | |
| 190 | /// Check if the global scope contains this name, without looking into the "future", e.g. | 176 | /// Check if the global scope contains this name, without looking into the "future", e.g. |
| 191 | /// ignore the preprocessed decl and macro names. | 177 | /// ignore the preprocessed decl and macro names. |
| 192 | fn containsNow(scope: *Root, name: []const u8) bool { | 178 | fn containsNow(scope: *Root, name: []const u8) bool { |
| ... | @@ -205,20 +191,20 @@ const Scope = struct { | ... | @@ -205,20 +191,20 @@ const Scope = struct { |
| 205 | var scope = inner; | 191 | var scope = inner; |
| 206 | while (true) { | 192 | while (true) { |
| 207 | switch (scope.id) { | 193 | switch (scope.id) { |
| 208 | .Root => unreachable, | 194 | .root => unreachable, |
| 209 | .Block => return @fieldParentPtr(Block, "base", scope), | 195 | .block => return @fieldParentPtr(Block, "base", scope), |
| 210 | .Condition => return @fieldParentPtr(Condition, "base", scope).getBlockScope(c), | 196 | .condition => return @fieldParentPtr(Condition, "base", scope).getBlockScope(c), |
| 211 | else => scope = scope.parent.?, | 197 | else => scope = scope.parent.?, |
| 212 | } | 198 | } |
| 213 | } | 199 | } |
| 214 | } | 200 | } |
| 215 | | 201 | |
| 216 | fn findBlockReturnType(inner: *Scope, c: *Context) ?clang.QualType { | 202 | fn findBlockReturnType(inner: *Scope, c: *Context) clang.QualType { |
| 217 | var scope = inner; | 203 | var scope = inner; |
| 218 | while (true) { | 204 | while (true) { |
| 219 | switch (scope.id) { | 205 | switch (scope.id) { |
| 220 | .Root => return null, | 206 | .root => unreachable, |
| 221 | .Block => { | 207 | .block => { |
| 222 | const block = @fieldParentPtr(Block, "base", scope); | 208 | const block = @fieldParentPtr(Block, "base", scope); |
| 223 | if (block.return_type) |qt| return qt; | 209 | if (block.return_type) |qt| return qt; |
| 224 | scope = scope.parent.?; | 210 | scope = scope.parent.?; |
| ... | @@ -230,17 +216,17 @@ const Scope = struct { | ... | @@ -230,17 +216,17 @@ const Scope = struct { |
| 230 | | 216 | |
| 231 | fn getAlias(scope: *Scope, name: []const u8) []const u8 { | 217 | fn getAlias(scope: *Scope, name: []const u8) []const u8 { |
| 232 | return switch (scope.id) { | 218 | return switch (scope.id) { |
| 233 | .Root => return name, | 219 | .root => return name, |
| 234 | .Block => @fieldParentPtr(Block, "base", scope).getAlias(name), | 220 | .block => @fieldParentPtr(Block, "base", scope).getAlias(name), |
| 235 | .Switch, .Loop, .Condition => scope.parent.?.getAlias(name), | 221 | .loop, .do_loop, .condition => scope.parent.?.getAlias(name), |
| 236 | }; | 222 | }; |
| 237 | } | 223 | } |
| 238 | | 224 | |
| 239 | fn contains(scope: *Scope, name: []const u8) bool { | 225 | fn contains(scope: *Scope, name: []const u8) bool { |
| 240 | return switch (scope.id) { | 226 | return switch (scope.id) { |
| 241 | .Root => @fieldParentPtr(Root, "base", scope).contains(name), | 227 | .root => @fieldParentPtr(Root, "base", scope).contains(name), |
| 242 | .Block => @fieldParentPtr(Block, "base", scope).contains(name), | 228 | .block => @fieldParentPtr(Block, "base", scope).contains(name), |
| 243 | .Switch, .Loop, .Condition => scope.parent.?.contains(name), | 229 | .loop, .do_loop, .condition => scope.parent.?.contains(name), |
| 244 | }; | 230 | }; |
| 245 | } | 231 | } |
| 246 | | 232 | |
| ... | @@ -248,20 +234,26 @@ const Scope = struct { | ... | @@ -248,20 +234,26 @@ const Scope = struct { |
| 248 | var scope = inner; | 234 | var scope = inner; |
| 249 | while (true) { | 235 | while (true) { |
| 250 | switch (scope.id) { | 236 | switch (scope.id) { |
| 251 | .Root => unreachable, | 237 | .root => unreachable, |
| 252 | .Switch => return scope, | 238 | .loop, .do_loop => return scope, |
| 253 | .Loop => return scope, | | |
| 254 | else => scope = scope.parent.?, | 239 | else => scope = scope.parent.?, |
| 255 | } | 240 | } |
| 256 | } | 241 | } |
| 257 | } | 242 | } |
| 258 | | 243 | |
| 259 | fn getSwitch(inner: *Scope) *Scope.Switch { | 244 | /// Appends a node to the first block scope if inside a function, or to the root tree if not. |
| | 245 | fn appendNode(inner: *Scope, node: Node) !void { |
| 260 | var scope = inner; | 246 | var scope = inner; |
| 261 | while (true) { | 247 | while (true) { |
| 262 | switch (scope.id) { | 248 | switch (scope.id) { |
| 263 | .Root => unreachable, | 249 | .root => { |
| 264 | .Switch => return @fieldParentPtr(Switch, "base", scope), | 250 | const root = @fieldParentPtr(Root, "base", scope); |
| | 251 | return root.nodes.append(node); |
| | 252 | }, |
| | 253 | .block => { |
| | 254 | const block = @fieldParentPtr(Block, "base", scope); |
| | 255 | return block.statements.append(node); |
| | 256 | }, |
| 265 | else => scope = scope.parent.?, | 257 | else => scope = scope.parent.?, |
| 266 | } | 258 | } |
| 267 | } | 259 | } |
| ... | @@ -271,18 +263,12 @@ const Scope = struct { | ... | @@ -271,18 +263,12 @@ const Scope = struct { |
| 271 | pub const Context = struct { | 263 | pub const Context = struct { |
| 272 | gpa: *mem.Allocator, | 264 | gpa: *mem.Allocator, |
| 273 | arena: *mem.Allocator, | 265 | arena: *mem.Allocator, |
| 274 | token_ids: std.ArrayListUnmanaged(Token.Id) = .{}, | | |
| 275 | token_locs: std.ArrayListUnmanaged(Token.Loc) = .{}, | | |
| 276 | errors: std.ArrayListUnmanaged(ast.Error) = .{}, | | |
| 277 | source_buffer: *std.ArrayList(u8), | | |
| 278 | err: Error, | | |
| 279 | source_manager: *clang.SourceManager, | 266 | source_manager: *clang.SourceManager, |
| 280 | decl_table: std.AutoArrayHashMapUnmanaged(usize, []const u8) = .{}, | 267 | decl_table: std.AutoArrayHashMapUnmanaged(usize, []const u8) = .{}, |
| 281 | alias_list: AliasList, | 268 | alias_list: AliasList, |
| 282 | global_scope: *Scope.Root, | 269 | global_scope: *Scope.Root, |
| 283 | clang_context: *clang.ASTContext, | 270 | clang_context: *clang.ASTContext, |
| 284 | mangle_count: u32 = 0, | 271 | mangle_count: u32 = 0, |
| 285 | root_decls: std.ArrayListUnmanaged(*ast.Node) = .{}, | | |
| 286 | opaque_demotes: std.AutoHashMapUnmanaged(usize, void) = .{}, | 272 | opaque_demotes: std.AutoHashMapUnmanaged(usize, void) = .{}, |
| 287 | | 273 | |
| 288 | /// This one is different than the root scope's name table. This contains | 274 | /// This one is different than the root scope's name table. This contains |
| ... | @@ -311,90 +297,15 @@ pub const Context = struct { | ... | @@ -311,90 +297,15 @@ pub const Context = struct { |
| 311 | const column = c.source_manager.getSpellingColumnNumber(spelling_loc); | 297 | const column = c.source_manager.getSpellingColumnNumber(spelling_loc); |
| 312 | return std.fmt.allocPrint(c.arena, "{s}:{d}:{d}", .{ filename, line, column }); | 298 | return std.fmt.allocPrint(c.arena, "{s}:{d}:{d}", .{ filename, line, column }); |
| 313 | } | 299 | } |
| 314 | | | |
| 315 | fn createCall(c: *Context, fn_expr: *ast.Node, params_len: ast.NodeIndex) !*ast.Node.Call { | | |
| 316 | _ = try appendToken(c, .LParen, "("); | | |
| 317 | const node = try ast.Node.Call.alloc(c.arena, params_len); | | |
| 318 | node.* = .{ | | |
| 319 | .lhs = fn_expr, | | |
| 320 | .params_len = params_len, | | |
| 321 | .async_token = null, | | |
| 322 | .rtoken = undefined, // set after appending args | | |
| 323 | }; | | |
| 324 | return node; | | |
| 325 | } | | |
| 326 | | | |
| 327 | fn createBuiltinCall(c: *Context, name: []const u8, params_len: ast.NodeIndex) !*ast.Node.BuiltinCall { | | |
| 328 | const builtin_token = try appendToken(c, .Builtin, name); | | |
| 329 | _ = try appendToken(c, .LParen, "("); | | |
| 330 | const node = try ast.Node.BuiltinCall.alloc(c.arena, params_len); | | |
| 331 | node.* = .{ | | |
| 332 | .builtin_token = builtin_token, | | |
| 333 | .params_len = params_len, | | |
| 334 | .rparen_token = undefined, // set after appending args | | |
| 335 | }; | | |
| 336 | return node; | | |
| 337 | } | | |
| 338 | | | |
| 339 | fn createBlock(c: *Context, statements_len: ast.NodeIndex) !*ast.Node.Block { | | |
| 340 | const block_node = try ast.Node.Block.alloc(c.arena, statements_len); | | |
| 341 | block_node.* = .{ | | |
| 342 | .lbrace = try appendToken(c, .LBrace, "{"), | | |
| 343 | .statements_len = statements_len, | | |
| 344 | .rbrace = undefined, | | |
| 345 | }; | | |
| 346 | return block_node; | | |
| 347 | } | | |
| 348 | }; | 300 | }; |
| 349 | | 301 | |
| 350 | fn addCBuiltinsNamespace(c: *Context) Error!void { | | |
| 351 | // pub usingnamespace @import("std").c.builtins; | | |
| 352 | const pub_tok = try appendToken(c, .Keyword_pub, "pub"); | | |
| 353 | const use_tok = try appendToken(c, .Keyword_usingnamespace, "usingnamespace"); | | |
| 354 | const import_tok = try appendToken(c, .Builtin, "@import"); | | |
| 355 | const lparen_tok = try appendToken(c, .LParen, "("); | | |
| 356 | const std_tok = try appendToken(c, .StringLiteral, "\"std\""); | | |
| 357 | const rparen_tok = try appendToken(c, .RParen, ")"); | | |
| 358 | | | |
| 359 | const std_node = try c.arena.create(ast.Node.OneToken); | | |
| 360 | std_node.* = .{ | | |
| 361 | .base = .{ .tag = .StringLiteral }, | | |
| 362 | .token = std_tok, | | |
| 363 | }; | | |
| 364 | | | |
| 365 | const call_node = try ast.Node.BuiltinCall.alloc(c.arena, 1); | | |
| 366 | call_node.* = .{ | | |
| 367 | .builtin_token = import_tok, | | |
| 368 | .params_len = 1, | | |
| 369 | .rparen_token = rparen_tok, | | |
| 370 | }; | | |
| 371 | call_node.params()[0] = &std_node.base; | | |
| 372 | | | |
| 373 | var access_chain = &call_node.base; | | |
| 374 | access_chain = try transCreateNodeFieldAccess(c, access_chain, "c"); | | |
| 375 | access_chain = try transCreateNodeFieldAccess(c, access_chain, "builtins"); | | |
| 376 | | | |
| 377 | const semi_tok = try appendToken(c, .Semicolon, ";"); | | |
| 378 | | | |
| 379 | const bytes = try c.gpa.alignedAlloc(u8, @alignOf(ast.Node.Use), @sizeOf(ast.Node.Use)); | | |
| 380 | const using_node = @ptrCast(*ast.Node.Use, bytes.ptr); | | |
| 381 | using_node.* = .{ | | |
| 382 | .doc_comments = null, | | |
| 383 | .visib_token = pub_tok, | | |
| 384 | .use_token = use_tok, | | |
| 385 | .expr = access_chain, | | |
| 386 | .semicolon_token = semi_tok, | | |
| 387 | }; | | |
| 388 | try c.root_decls.append(c.gpa, &using_node.base); | | |
| 389 | } | | |
| 390 | | | |
| 391 | pub fn translate( | 302 | pub fn translate( |
| 392 | gpa: *mem.Allocator, | 303 | gpa: *mem.Allocator, |
| 393 | args_begin: [*]?[*]const u8, | 304 | args_begin: [*]?[*]const u8, |
| 394 | args_end: [*]?[*]const u8, | 305 | args_end: [*]?[*]const u8, |
| 395 | errors: *[]ClangErrMsg, | 306 | errors: *[]ClangErrMsg, |
| 396 | resources_path: [*:0]const u8, | 307 | resources_path: [*:0]const u8, |
| 397 | ) !ast.Tree { | 308 | ) !std.zig.ast.Tree { |
| 398 | const ast_unit = clang.LoadFromCommandLine( | 309 | const ast_unit = clang.LoadFromCommandLine( |
| 399 | args_begin, | 310 | args_begin, |
| 400 | args_end, | 311 | args_end, |
| ... | @@ -407,28 +318,15 @@ pub fn translate( | ... | @@ -407,28 +318,15 @@ pub fn translate( |
| 407 | }; | 318 | }; |
| 408 | defer ast_unit.delete(); | 319 | defer ast_unit.delete(); |
| 409 | | 320 | |
| 410 | var source_buffer = std.ArrayList(u8).init(gpa); | | |
| 411 | defer source_buffer.deinit(); | | |
| 412 | | | |
| 413 | // For memory that has the same lifetime as the Tree that we return | 321 | // For memory that has the same lifetime as the Tree that we return |
| 414 | // from this function. | 322 | // from this function. |
| 415 | var arena = std.heap.ArenaAllocator.init(gpa); | 323 | var arena = std.heap.ArenaAllocator.init(gpa); |
| 416 | errdefer arena.deinit(); | 324 | errdefer arena.deinit(); |
| 417 | | 325 | |
| 418 | if (true) { | | |
| 419 | var x = false; | | |
| 420 | if (x) { | | |
| 421 | return error.OutOfMemory; | | |
| 422 | } | | |
| 423 | @panic("TODO update translate-c"); | | |
| 424 | } | | |
| 425 | | | |
| 426 | var context = Context{ | 326 | var context = Context{ |
| 427 | .gpa = gpa, | 327 | .gpa = gpa, |
| 428 | .arena = &arena.allocator, | 328 | .arena = &arena.allocator, |
| 429 | .source_buffer = &source_buffer, | | |
| 430 | .source_manager = ast_unit.getSourceManager(), | 329 | .source_manager = ast_unit.getSourceManager(), |
| 431 | .err = undefined, | | |
| 432 | .alias_list = AliasList.init(gpa), | 330 | .alias_list = AliasList.init(gpa), |
| 433 | .global_scope = try arena.allocator.create(Scope.Root), | 331 | .global_scope = try arena.allocator.create(Scope.Root), |
| 434 | .clang_context = ast_unit.getASTContext(), | 332 | .clang_context = ast_unit.getASTContext(), |
| ... | @@ -437,20 +335,17 @@ pub fn translate( | ... | @@ -437,20 +335,17 @@ pub fn translate( |
| 437 | defer { | 335 | defer { |
| 438 | context.decl_table.deinit(gpa); | 336 | context.decl_table.deinit(gpa); |
| 439 | context.alias_list.deinit(); | 337 | context.alias_list.deinit(); |
| 440 | context.token_ids.deinit(gpa); | | |
| 441 | context.token_locs.deinit(gpa); | | |
| 442 | context.errors.deinit(gpa); | | |
| 443 | context.global_names.deinit(gpa); | 338 | context.global_names.deinit(gpa); |
| 444 | context.root_decls.deinit(gpa); | | |
| 445 | context.opaque_demotes.deinit(gpa); | 339 | context.opaque_demotes.deinit(gpa); |
| | 340 | context.global_scope.deinit(); |
| 446 | } | 341 | } |
| 447 | | 342 | |
| 448 | try addCBuiltinsNamespace(&context); | 343 | try context.global_scope.nodes.append(Tag.usingnamespace_builtins.init()); |
| 449 | | 344 | |
| 450 | try prepopulateGlobalNameTable(ast_unit, &context); | 345 | try prepopulateGlobalNameTable(ast_unit, &context); |
| 451 | | 346 | |
| 452 | if (!ast_unit.visitLocalTopLevelDecls(&context, declVisitorC)) { | 347 | if (!ast_unit.visitLocalTopLevelDecls(&context, declVisitorC)) { |
| 453 | return context.err; | 348 | return error.OutOfMemory; |
| 454 | } | 349 | } |
| 455 | | 350 | |
| 456 | try transPreprocessorEntities(&context, ast_unit); | 351 | try transPreprocessorEntities(&context, ast_unit); |
| ... | @@ -458,38 +353,17 @@ pub fn translate( | ... | @@ -458,38 +353,17 @@ pub fn translate( |
| 458 | try addMacros(&context); | 353 | try addMacros(&context); |
| 459 | for (context.alias_list.items) |alias| { | 354 | for (context.alias_list.items) |alias| { |
| 460 | if (!context.global_scope.sym_table.contains(alias.alias)) { | 355 | if (!context.global_scope.sym_table.contains(alias.alias)) { |
| 461 | try createAlias(&context, alias); | 356 | const node = try Tag.alias.create(context.arena, .{ .actual = alias.alias, .mangled = alias.name }); |
| 462 | } | 357 | try addTopLevelDecl(&context, alias.alias, node); |
| 463 | } | | |
| 464 | | | |
| 465 | const eof_token = try appendToken(&context, .Eof, ""); | | |
| 466 | const root_node = try ast.Node.Root.create(&arena.allocator, context.root_decls.items.len, eof_token); | | |
| 467 | mem.copy(*ast.Node, root_node.decls(), context.root_decls.items); | | |
| 468 | | | |
| 469 | if (false) { | | |
| 470 | std.debug.warn("debug source:\n{s}\n==EOF==\ntokens:\n", .{source_buffer.items}); | | |
| 471 | for (context.token_ids.items) |token| { | | |
| 472 | std.debug.warn("{}\n", .{token}); | | |
| 473 | } | 358 | } |
| 474 | } | 359 | } |
| 475 | | 360 | |
| 476 | const tree = try arena.allocator.create(ast.Tree); | 361 | return ast.render(gpa, context.global_scope.nodes.items); |
| 477 | tree.* = .{ | | |
| 478 | .gpa = gpa, | | |
| 479 | .source = try arena.allocator.dupe(u8, source_buffer.items), | | |
| 480 | .token_ids = context.token_ids.toOwnedSlice(gpa), | | |
| 481 | .token_locs = context.token_locs.toOwnedSlice(gpa), | | |
| 482 | .errors = context.errors.toOwnedSlice(gpa), | | |
| 483 | .root_node = root_node, | | |
| 484 | .arena = arena.state, | | |
| 485 | .generated = true, | | |
| 486 | }; | | |
| 487 | return tree; | | |
| 488 | } | 362 | } |
| 489 | | 363 | |
| 490 | fn prepopulateGlobalNameTable(ast_unit: *clang.ASTUnit, c: *Context) !void { | 364 | fn prepopulateGlobalNameTable(ast_unit: *clang.ASTUnit, c: *Context) !void { |
| 491 | if (!ast_unit.visitLocalTopLevelDecls(c, declVisitorNamesOnlyC)) { | 365 | if (!ast_unit.visitLocalTopLevelDecls(c, declVisitorNamesOnlyC)) { |
| 492 | return c.err; | 366 | return error.OutOfMemory; |
| 493 | } | 367 | } |
| 494 | | 368 | |
| 495 | // TODO if we see #undef, delete it from the table | 369 | // TODO if we see #undef, delete it from the table |
| ... | @@ -512,19 +386,13 @@ fn prepopulateGlobalNameTable(ast_unit: *clang.ASTUnit, c: *Context) !void { | ... | @@ -512,19 +386,13 @@ fn prepopulateGlobalNameTable(ast_unit: *clang.ASTUnit, c: *Context) !void { |
| 512 | | 386 | |
| 513 | fn declVisitorNamesOnlyC(context: ?*c_void, decl: *const clang.Decl) callconv(.C) bool { | 387 | fn declVisitorNamesOnlyC(context: ?*c_void, decl: *const clang.Decl) callconv(.C) bool { |
| 514 | const c = @ptrCast(*Context, @alignCast(@alignOf(Context), context)); | 388 | const c = @ptrCast(*Context, @alignCast(@alignOf(Context), context)); |
| 515 | declVisitorNamesOnly(c, decl) catch |err| { | 389 | declVisitorNamesOnly(c, decl) catch return false; |
| 516 | c.err = err; | | |
| 517 | return false; | | |
| 518 | }; | | |
| 519 | return true; | 390 | return true; |
| 520 | } | 391 | } |
| 521 | | 392 | |
| 522 | fn declVisitorC(context: ?*c_void, decl: *const clang.Decl) callconv(.C) bool { | 393 | fn declVisitorC(context: ?*c_void, decl: *const clang.Decl) callconv(.C) bool { |
| 523 | const c = @ptrCast(*Context, @alignCast(@alignOf(Context), context)); | 394 | const c = @ptrCast(*Context, @alignCast(@alignOf(Context), context)); |
| 524 | declVisitor(c, decl) catch |err| { | 395 | declVisitor(c, decl) catch return false; |
| 525 | c.err = err; | | |
| 526 | return false; | | |
| 527 | }; | | |
| 528 | return true; | 396 | return true; |
| 529 | } | 397 | } |
| 530 | | 398 | |
| ... | @@ -541,13 +409,13 @@ fn declVisitor(c: *Context, decl: *const clang.Decl) Error!void { | ... | @@ -541,13 +409,13 @@ fn declVisitor(c: *Context, decl: *const clang.Decl) Error!void { |
| 541 | return visitFnDecl(c, @ptrCast(*const clang.FunctionDecl, decl)); | 409 | return visitFnDecl(c, @ptrCast(*const clang.FunctionDecl, decl)); |
| 542 | }, | 410 | }, |
| 543 | .Typedef => { | 411 | .Typedef => { |
| 544 | _ = try transTypeDef(c, @ptrCast(*const clang.TypedefNameDecl, decl), true); | 412 | try transTypeDef(c, &c.global_scope.base, @ptrCast(*const clang.TypedefNameDecl, decl)); |
| 545 | }, | 413 | }, |
| 546 | .Enum => { | 414 | .Enum => { |
| 547 | _ = try transEnumDecl(c, @ptrCast(*const clang.EnumDecl, decl)); | 415 | try transEnumDecl(c, &c.global_scope.base, @ptrCast(*const clang.EnumDecl, decl)); |
| 548 | }, | 416 | }, |
| 549 | .Record => { | 417 | .Record => { |
| 550 | _ = try transRecordDecl(c, @ptrCast(*const clang.RecordDecl, decl)); | 418 | try transRecordDecl(c, &c.global_scope.base, @ptrCast(*const clang.RecordDecl, decl)); |
| 551 | }, | 419 | }, |
| 552 | .Var => { | 420 | .Var => { |
| 553 | return visitVarDecl(c, @ptrCast(*const clang.VarDecl, decl), null); | 421 | return visitVarDecl(c, @ptrCast(*const clang.VarDecl, decl), null); |
| ... | @@ -557,7 +425,7 @@ fn declVisitor(c: *Context, decl: *const clang.Decl) Error!void { | ... | @@ -557,7 +425,7 @@ fn declVisitor(c: *Context, decl: *const clang.Decl) Error!void { |
| 557 | }, | 425 | }, |
| 558 | else => { | 426 | else => { |
| 559 | const decl_name = try c.str(decl.getDeclKindName()); | 427 | const decl_name = try c.str(decl.getDeclKindName()); |
| 560 | try emitWarning(c, decl.getLocation(), "ignoring {s} declaration", .{decl_name}); | 428 | try warn(c, &c.global_scope.base, decl.getLocation(), "ignoring {s} declaration", .{decl_name}); |
| 561 | }, | 429 | }, |
| 562 | } | 430 | } |
| 563 | } | 431 | } |
| ... | @@ -573,7 +441,6 @@ fn visitFnDecl(c: *Context, fn_decl: *const clang.FunctionDecl) Error!void { | ... | @@ -573,7 +441,6 @@ fn visitFnDecl(c: *Context, fn_decl: *const clang.FunctionDecl) Error!void { |
| 573 | return visitFnDecl(c, def); | 441 | return visitFnDecl(c, def); |
| 574 | } | 442 | } |
| 575 | | 443 | |
| 576 | const rp = makeRestorePoint(c); | | |
| 577 | const fn_decl_loc = fn_decl.getLocation(); | 444 | const fn_decl_loc = fn_decl.getLocation(); |
| 578 | const has_body = fn_decl.hasBody(); | 445 | const has_body = fn_decl.hasBody(); |
| 579 | const storage_class = fn_decl.getStorageClass(); | 446 | const storage_class = fn_decl.getStorageClass(); |
| ... | @@ -617,9 +484,9 @@ fn visitFnDecl(c: *Context, fn_decl: *const clang.FunctionDecl) Error!void { | ... | @@ -617,9 +484,9 @@ fn visitFnDecl(c: *Context, fn_decl: *const clang.FunctionDecl) Error!void { |
| 617 | decl_ctx.has_body = false; | 484 | decl_ctx.has_body = false; |
| 618 | decl_ctx.storage_class = .Extern; | 485 | decl_ctx.storage_class = .Extern; |
| 619 | decl_ctx.is_export = false; | 486 | decl_ctx.is_export = false; |
| 620 | try emitWarning(c, fn_decl_loc, "TODO unable to translate variadic function, demoted to declaration", .{}); | 487 | try warn(c, &c.global_scope.base, fn_decl_loc, "TODO unable to translate variadic function, demoted to extern", .{}); |
| 621 | } | 488 | } |
| 622 | break :blk transFnProto(rp, fn_decl, fn_proto_type, fn_decl_loc, decl_ctx, true) catch |err| switch (err) { | 489 | break :blk transFnProto(c, fn_decl, fn_proto_type, fn_decl_loc, decl_ctx, true) catch |err| switch (err) { |
| 623 | error.UnsupportedType => { | 490 | error.UnsupportedType => { |
| 624 | return failDecl(c, fn_decl_loc, fn_name, "unable to resolve prototype of function", .{}); | 491 | return failDecl(c, fn_decl_loc, fn_name, "unable to resolve prototype of function", .{}); |
| 625 | }, | 492 | }, |
| ... | @@ -628,7 +495,7 @@ fn visitFnDecl(c: *Context, fn_decl: *const clang.FunctionDecl) Error!void { | ... | @@ -628,7 +495,7 @@ fn visitFnDecl(c: *Context, fn_decl: *const clang.FunctionDecl) Error!void { |
| 628 | }, | 495 | }, |
| 629 | .FunctionNoProto => blk: { | 496 | .FunctionNoProto => blk: { |
| 630 | const fn_no_proto_type = @ptrCast(*const clang.FunctionType, fn_type); | 497 | const fn_no_proto_type = @ptrCast(*const clang.FunctionType, fn_type); |
| 631 | break :blk transFnNoProto(rp, fn_no_proto_type, fn_decl_loc, decl_ctx, true) catch |err| switch (err) { | 498 | break :blk transFnNoProto(c, fn_no_proto_type, fn_decl_loc, decl_ctx, true) catch |err| switch (err) { |
| 632 | error.UnsupportedType => { | 499 | error.UnsupportedType => { |
| 633 | return failDecl(c, fn_decl_loc, fn_name, "unable to resolve prototype of function", .{}); | 500 | return failDecl(c, fn_decl_loc, fn_name, "unable to resolve prototype of function", .{}); |
| 634 | }, | 501 | }, |
| ... | @@ -639,124 +506,99 @@ fn visitFnDecl(c: *Context, fn_decl: *const clang.FunctionDecl) Error!void { | ... | @@ -639,124 +506,99 @@ fn visitFnDecl(c: *Context, fn_decl: *const clang.FunctionDecl) Error!void { |
| 639 | }; | 506 | }; |
| 640 | | 507 | |
| 641 | if (!decl_ctx.has_body) { | 508 | if (!decl_ctx.has_body) { |
| 642 | const semi_tok = try appendToken(c, .Semicolon, ";"); | 509 | return addTopLevelDecl(c, fn_name, Node.initPayload(&proto_node.base)); |
| 643 | return addTopLevelDecl(c, fn_name, &proto_node.base); | | |
| 644 | } | 510 | } |
| 645 | | 511 | |
| 646 | // actual function definition with body | 512 | // actual function definition with body |
| 647 | const body_stmt = fn_decl.getBody(); | 513 | const body_stmt = fn_decl.getBody(); |
| 648 | var block_scope = try Scope.Block.init(rp.c, &c.global_scope.base, false); | 514 | var block_scope = try Scope.Block.init(c, &c.global_scope.base, false); |
| 649 | block_scope.return_type = return_qt; | 515 | block_scope.return_type = return_qt; |
| 650 | defer block_scope.deinit(); | 516 | defer block_scope.deinit(); |
| 651 | | 517 | |
| 652 | var scope = &block_scope.base; | 518 | var scope = &block_scope.base; |
| 653 | | 519 | |
| 654 | var param_id: c_uint = 0; | 520 | var param_id: c_uint = 0; |
| 655 | for (proto_node.params()) |*param, i| { | 521 | for (proto_node.data.params) |*param, i| { |
| 656 | const param_name = if (param.name_token) |name_tok| | 522 | const param_name = param.name orelse { |
| 657 | tokenSlice(c, name_tok) | 523 | proto_node.data.is_extern = true; |
| 658 | else | 524 | proto_node.data.is_export = false; |
| 659 | return failDecl(c, fn_decl_loc, fn_name, "function {s} parameter has no name", .{fn_name}); | 525 | try warn(c, &c.global_scope.base, fn_decl_loc, "function {s} parameter has no name, demoted to extern", .{fn_name}); |
| | 526 | return addTopLevelDecl(c, fn_name, Node.initPayload(&proto_node.base)); |
| | 527 | }; |
| 660 | | 528 | |
| 661 | const c_param = fn_decl.getParamDecl(param_id); | 529 | const c_param = fn_decl.getParamDecl(param_id); |
| 662 | const qual_type = c_param.getOriginalType(); | 530 | const qual_type = c_param.getOriginalType(); |
| 663 | const is_const = qual_type.isConstQualified(); | 531 | const is_const = qual_type.isConstQualified(); |
| 664 | | 532 | |
| 665 | const mangled_param_name = try block_scope.makeMangledName(c, param_name); | 533 | const mangled_param_name = try block_scope.makeMangledName(c, param_name); |
| | 534 | param.name = mangled_param_name; |
| 666 | | 535 | |
| 667 | if (!is_const) { | 536 | if (!is_const) { |
| 668 | const bare_arg_name = try std.fmt.allocPrint(c.arena, "arg_{s}", .{mangled_param_name}); | 537 | const bare_arg_name = try std.fmt.allocPrint(c.arena, "arg_{s}", .{mangled_param_name}); |
| 669 | const arg_name = try block_scope.makeMangledName(c, bare_arg_name); | 538 | const arg_name = try block_scope.makeMangledName(c, bare_arg_name); |
| | 539 | param.name = arg_name; |
| 670 | | 540 | |
| 671 | const mut_tok = try appendToken(c, .Keyword_var, "var"); | 541 | const redecl_node = try Tag.arg_redecl.create(c.arena, .{ .actual = mangled_param_name, .mangled = arg_name }); |
| 672 | const name_tok = try appendIdentifier(c, mangled_param_name); | 542 | try block_scope.statements.append(redecl_node); |
| 673 | const eq_token = try appendToken(c, .Equal, "="); | | |
| 674 | const init_node = try transCreateNodeIdentifier(c, arg_name); | | |
| 675 | const semicolon_token = try appendToken(c, .Semicolon, ";"); | | |
| 676 | const node = try ast.Node.VarDecl.create(c.arena, .{ | | |
| 677 | .mut_token = mut_tok, | | |
| 678 | .name_token = name_tok, | | |
| 679 | .semicolon_token = semicolon_token, | | |
| 680 | }, .{ | | |
| 681 | .eq_token = eq_token, | | |
| 682 | .init_node = init_node, | | |
| 683 | }); | | |
| 684 | try block_scope.statements.append(&node.base); | | |
| 685 | param.name_token = try appendIdentifier(c, arg_name); | | |
| 686 | _ = try appendToken(c, .Colon, ":"); | | |
| 687 | } | 543 | } |
| 688 | | 544 | |
| 689 | param_id += 1; | 545 | param_id += 1; |
| 690 | } | 546 | } |
| 691 | | 547 | |
| 692 | const casted_body = @ptrCast(*const clang.CompoundStmt, body_stmt); | 548 | const casted_body = @ptrCast(*const clang.CompoundStmt, body_stmt); |
| 693 | transCompoundStmtInline(rp, &block_scope.base, casted_body, &block_scope) catch |err| switch (err) { | 549 | transCompoundStmtInline(c, casted_body, &block_scope) catch |err| switch (err) { |
| 694 | error.OutOfMemory => |e| return e, | 550 | error.OutOfMemory => |e| return e, |
| 695 | error.UnsupportedTranslation, | 551 | error.UnsupportedTranslation, |
| 696 | error.UnsupportedType, | 552 | error.UnsupportedType, |
| 697 | => return failDecl(c, fn_decl_loc, fn_name, "unable to translate function", .{}), | 553 | => { |
| | 554 | proto_node.data.is_extern = true; |
| | 555 | proto_node.data.is_export = false; |
| | 556 | try warn(c, &c.global_scope.base, fn_decl_loc, "unable to translate function, demoted to extern", .{}); |
| | 557 | return addTopLevelDecl(c, fn_name, Node.initPayload(&proto_node.base)); |
| | 558 | }, |
| 698 | }; | 559 | }; |
| 699 | // add return statement if the function didn't have one | 560 | // add return statement if the function didn't have one |
| 700 | blk: { | 561 | blk: { |
| 701 | if (fn_ty.getNoReturnAttr()) break :blk; | 562 | const maybe_body = try block_scope.complete(c); |
| 702 | if (isCVoid(return_qt)) break :blk; | 563 | if (fn_ty.getNoReturnAttr() or isCVoid(return_qt) or maybe_body.isNoreturn(false)) { |
| 703 | | 564 | proto_node.data.body = maybe_body; |
| 704 | if (block_scope.statements.items.len > 0) { | 565 | break :blk; |
| 705 | var last = block_scope.statements.items[block_scope.statements.items.len - 1]; | | |
| 706 | while (true) { | | |
| 707 | switch (last.tag) { | | |
| 708 | .Block, .LabeledBlock => { | | |
| 709 | const stmts = last.blockStatements(); | | |
| 710 | if (stmts.len == 0) break; | | |
| 711 | | | |
| 712 | last = stmts[stmts.len - 1]; | | |
| 713 | }, | | |
| 714 | // no extra return needed | | |
| 715 | .Return => break :blk, | | |
| 716 | else => break, | | |
| 717 | } | | |
| 718 | } | | |
| 719 | } | 566 | } |
| 720 | | 567 | |
| 721 | const return_expr = try ast.Node.ControlFlowExpression.create(rp.c.arena, .{ | 568 | const rhs = transZeroInitExpr(c, scope, fn_decl_loc, return_qt.getTypePtr()) catch |err| switch (err) { |
| 722 | .ltoken = try appendToken(rp.c, .Keyword_return, "return"), | 569 | error.OutOfMemory => |e| return e, |
| 723 | .tag = .Return, | 570 | error.UnsupportedTranslation, |
| 724 | }, .{ | 571 | error.UnsupportedType, |
| 725 | .rhs = transZeroInitExpr(rp, scope, fn_decl_loc, return_qt.getTypePtr()) catch |err| switch (err) { | 572 | => { |
| 726 | error.OutOfMemory => |e| return e, | 573 | proto_node.data.is_extern = true; |
| 727 | error.UnsupportedTranslation, | 574 | proto_node.data.is_export = false; |
| 728 | error.UnsupportedType, | 575 | try warn(c, &c.global_scope.base, fn_decl_loc, "unable to create a return value for function, demoted to extern", .{}); |
| 729 | => return failDecl(c, fn_decl_loc, fn_name, "unable to create a return value for function", .{}), | 576 | return addTopLevelDecl(c, fn_name, Node.initPayload(&proto_node.base)); |
| 730 | }, | 577 | }, |
| 731 | }); | 578 | }; |
| 732 | _ = try appendToken(rp.c, .Semicolon, ";"); | 579 | const ret = try Tag.@"return".create(c.arena, rhs); |
| 733 | try block_scope.statements.append(&return_expr.base); | 580 | try block_scope.statements.append(ret); |
| | 581 | proto_node.data.body = try block_scope.complete(c); |
| 734 | } | 582 | } |
| 735 | | 583 | |
| 736 | const body_node = try block_scope.complete(rp.c); | 584 | return addTopLevelDecl(c, fn_name, Node.initPayload(&proto_node.base)); |
| 737 | proto_node.setBodyNode(body_node); | | |
| 738 | return addTopLevelDecl(c, fn_name, &proto_node.base); | | |
| 739 | } | 585 | } |
| 740 | | 586 | |
| 741 | fn transQualTypeMaybeInitialized(rp: RestorePoint, qt: clang.QualType, decl_init: ?*const clang.Expr, loc: clang.SourceLocation) TransError!*ast.Node { | 587 | fn transQualTypeMaybeInitialized(c: *Context, scope: *Scope, qt: clang.QualType, decl_init: ?*const clang.Expr, loc: clang.SourceLocation) TransError!Node { |
| 742 | return if (decl_init) |init_expr| | 588 | return if (decl_init) |init_expr| |
| 743 | transQualTypeInitialized(rp, qt, init_expr, loc) | 589 | transQualTypeInitialized(c, scope, qt, init_expr, loc) |
| 744 | else | 590 | else |
| 745 | transQualType(rp, qt, loc); | 591 | transQualType(c, scope, qt, loc); |
| 746 | } | 592 | } |
| | 593 | |
| 747 | /// if mangled_name is not null, this var decl was declared in a block scope. | 594 | /// if mangled_name is not null, this var decl was declared in a block scope. |
| 748 | fn visitVarDecl(c: *Context, var_decl: *const clang.VarDecl, mangled_name: ?[]const u8) Error!void { | 595 | fn visitVarDecl(c: *Context, var_decl: *const clang.VarDecl, mangled_name: ?[]const u8) Error!void { |
| 749 | const var_name = mangled_name orelse try c.str(@ptrCast(*const clang.NamedDecl, var_decl).getName_bytes_begin()); | 596 | const var_name = mangled_name orelse try c.str(@ptrCast(*const clang.NamedDecl, var_decl).getName_bytes_begin()); |
| 750 | if (c.global_scope.sym_table.contains(var_name)) | 597 | if (c.global_scope.sym_table.contains(var_name)) |
| 751 | return; // Avoid processing this decl twice | 598 | return; // Avoid processing this decl twice |
| 752 | const rp = makeRestorePoint(c); | | |
| 753 | const visib_tok = if (mangled_name) |_| null else try appendToken(c, .Keyword_pub, "pub"); | | |
| 754 | | | |
| 755 | const thread_local_token = if (var_decl.getTLSKind() == .None) | | |
| 756 | null | | |
| 757 | else | | |
| 758 | try appendToken(c, .Keyword_threadlocal, "threadlocal"); | | |
| 759 | | 599 | |
| | 600 | const is_pub = mangled_name == null; |
| | 601 | const is_threadlocal = var_decl.getTLSKind() != .None; |
| 760 | const scope = &c.global_scope.base; | 602 | const scope = &c.global_scope.base; |
| 761 | | 603 | |
| 762 | // TODO https://github.com/ziglang/zig/issues/3756 | 604 | // TODO https://github.com/ziglang/zig/issues/3756 |
| ... | @@ -775,211 +617,148 @@ fn visitVarDecl(c: *Context, var_decl: *const clang.VarDecl, mangled_name: ?[]co | ... | @@ -775,211 +617,148 @@ fn visitVarDecl(c: *Context, var_decl: *const clang.VarDecl, mangled_name: ?[]co |
| 775 | // does the same as: | 617 | // does the same as: |
| 776 | // extern int foo; | 618 | // extern int foo; |
| 777 | // int foo = 2; | 619 | // int foo = 2; |
| 778 | const extern_tok = if (storage_class == .Extern and !has_init) | 620 | var is_extern = storage_class == .Extern and !has_init; |
| 779 | try appendToken(c, .Keyword_extern, "extern") | 621 | var is_export = !is_extern and storage_class != .Static; |
| 780 | else if (storage_class != .Static) | | |
| 781 | try appendToken(c, .Keyword_export, "export") | | |
| 782 | else | | |
| 783 | null; | | |
| 784 | | | |
| 785 | const mut_tok = if (is_const) | | |
| 786 | try appendToken(c, .Keyword_const, "const") | | |
| 787 | else | | |
| 788 | try appendToken(c, .Keyword_var, "var"); | | |
| 789 | | | |
| 790 | const name_tok = try appendIdentifier(c, checked_name); | | |
| 791 | | 622 | |
| 792 | _ = try appendToken(c, .Colon, ":"); | 623 | const type_node = transQualTypeMaybeInitialized(c, scope, qual_type, decl_init, var_decl_loc) catch |err| switch (err) { |
| 793 | | | |
| 794 | const type_node = transQualTypeMaybeInitialized(rp, qual_type, decl_init, var_decl_loc) catch |err| switch (err) { | | |
| 795 | error.UnsupportedTranslation, error.UnsupportedType => { | 624 | error.UnsupportedTranslation, error.UnsupportedType => { |
| 796 | return failDecl(c, var_decl_loc, checked_name, "unable to resolve variable type", .{}); | 625 | return failDecl(c, var_decl_loc, checked_name, "unable to resolve variable type", .{}); |
| 797 | }, | 626 | }, |
| 798 | error.OutOfMemory => |e| return e, | 627 | error.OutOfMemory => |e| return e, |
| 799 | }; | 628 | }; |
| 800 | | 629 | |
| 801 | var eq_tok: ast.TokenIndex = undefined; | 630 | var init_node: ?Node = null; |
| 802 | var init_node: ?*ast.Node = null; | | |
| 803 | | 631 | |
| 804 | // If the initialization expression is not present, initialize with undefined. | 632 | // If the initialization expression is not present, initialize with undefined. |
| 805 | // If it is an integer literal, we can skip the @as since it will be redundant | 633 | // If it is an integer literal, we can skip the @as since it will be redundant |
| 806 | // with the variable type. | 634 | // with the variable type. |
| 807 | if (has_init) { | 635 | if (has_init) trans_init: { |
| 808 | eq_tok = try appendToken(c, .Equal, "="); | | |
| 809 | if (decl_init) |expr| { | 636 | if (decl_init) |expr| { |
| 810 | const node_or_error = if (expr.getStmtClass() == .StringLiteralClass) | 637 | const node_or_error = if (expr.getStmtClass() == .StringLiteralClass) |
| 811 | transStringLiteralAsArray(rp, &c.global_scope.base, @ptrCast(*const clang.StringLiteral, expr), zigArraySize(rp.c, type_node) catch 0) | 638 | transStringLiteralAsArray(c, scope, @ptrCast(*const clang.StringLiteral, expr), zigArraySize(c, type_node) catch 0) |
| 812 | else | 639 | else |
| 813 | transExprCoercing(rp, scope, expr, .used, .r_value); | 640 | transExprCoercing(c, scope, expr, .used); |
| 814 | init_node = node_or_error catch |err| switch (err) { | 641 | init_node = node_or_error catch |err| switch (err) { |
| 815 | error.UnsupportedTranslation, | 642 | error.UnsupportedTranslation, |
| 816 | error.UnsupportedType, | 643 | error.UnsupportedType, |
| 817 | => { | 644 | => { |
| 818 | return failDecl(c, var_decl_loc, checked_name, "unable to translate initializer", .{}); | 645 | is_extern = true; |
| | 646 | is_export = false; |
| | 647 | try warn(c, scope, var_decl_loc, "unable to translate variable initializer, demoted to extern", .{}); |
| | 648 | break :trans_init; |
| 819 | }, | 649 | }, |
| 820 | error.OutOfMemory => |e| return e, | 650 | error.OutOfMemory => |e| return e, |
| 821 | }; | 651 | }; |
| | 652 | if (!qualTypeIsBoolean(qual_type) and isBoolRes(init_node.?)) { |
| | 653 | init_node = try Tag.bool_to_int.create(c.arena, init_node.?); |
| | 654 | } |
| 822 | } else { | 655 | } else { |
| 823 | init_node = try transCreateNodeUndefinedLiteral(c); | 656 | init_node = Tag.undefined_literal.init(); |
| 824 | } | 657 | } |
| 825 | } else if (storage_class != .Extern) { | 658 | } else if (storage_class != .Extern) { |
| 826 | eq_tok = try appendToken(c, .Equal, "="); | | |
| 827 | // The C language specification states that variables with static or threadlocal | 659 | // The C language specification states that variables with static or threadlocal |
| 828 | // storage without an initializer are initialized to a zero value. | 660 | // storage without an initializer are initialized to a zero value. |
| 829 | | 661 | |
| 830 | // @import("std").mem.zeroes(T) | 662 | // @import("std").mem.zeroes(T) |
| 831 | const import_fn_call = try c.createBuiltinCall("@import", 1); | 663 | init_node = try Tag.std_mem_zeroes.create(c.arena, type_node); |
| 832 | const std_node = try transCreateNodeStringLiteral(c, "\"std\""); | | |
| 833 | import_fn_call.params()[0] = std_node; | | |
| 834 | import_fn_call.rparen_token = try appendToken(c, .RParen, ")"); | | |
| 835 | const inner_field_access = try transCreateNodeFieldAccess(c, &import_fn_call.base, "mem"); | | |
| 836 | const outer_field_access = try transCreateNodeFieldAccess(c, inner_field_access, "zeroes"); | | |
| 837 | | | |
| 838 | const zero_init_call = try c.createCall(outer_field_access, 1); | | |
| 839 | zero_init_call.params()[0] = type_node; | | |
| 840 | zero_init_call.rtoken = try appendToken(c, .RParen, ")"); | | |
| 841 | | | |
| 842 | init_node = &zero_init_call.base; | | |
| 843 | } | 664 | } |
| 844 | | 665 | |
| 845 | const linksection_expr = blk: { | 666 | const linksection_string = blk: { |
| 846 | var str_len: usize = undefined; | 667 | var str_len: usize = undefined; |
| 847 | if (var_decl.getSectionAttribute(&str_len)) |str_ptr| { | 668 | if (var_decl.getSectionAttribute(&str_len)) |str_ptr| { |
| 848 | _ = try appendToken(rp.c, .Keyword_linksection, "linksection"); | 669 | break :blk str_ptr[0..str_len]; |
| 849 | _ = try appendToken(rp.c, .LParen, "("); | | |
| 850 | const expr = try transCreateNodeStringLiteral( | | |
| 851 | rp.c, | | |
| 852 | try std.fmt.allocPrint(rp.c.arena, "\"{s}\"", .{str_ptr[0..str_len]}), | | |
| 853 | ); | | |
| 854 | _ = try appendToken(rp.c, .RParen, ")"); | | |
| 855 | | | |
| 856 | break :blk expr; | | |
| 857 | } | 670 | } |
| 858 | break :blk null; | 671 | break :blk null; |
| 859 | }; | 672 | }; |
| 860 | | 673 | |
| 861 | const align_expr = blk: { | 674 | const alignment = blk: { |
| 862 | const alignment = var_decl.getAlignedAttribute(rp.c.clang_context); | 675 | const alignment = var_decl.getAlignedAttribute(c.clang_context); |
| 863 | if (alignment != 0) { | 676 | if (alignment != 0) { |
| 864 | _ = try appendToken(rp.c, .Keyword_align, "align"); | | |
| 865 | _ = try appendToken(rp.c, .LParen, "("); | | |
| 866 | // Clang reports the alignment in bits | 677 | // Clang reports the alignment in bits |
| 867 | const expr = try transCreateNodeInt(rp.c, alignment / 8); | 678 | break :blk alignment / 8; |
| 868 | _ = try appendToken(rp.c, .RParen, ")"); | | |
| 869 | | | |
| 870 | break :blk expr; | | |
| 871 | } | 679 | } |
| 872 | break :blk null; | 680 | break :blk null; |
| 873 | }; | 681 | }; |
| 874 | | 682 | |
| 875 | const node = try ast.Node.VarDecl.create(c.arena, .{ | 683 | const node = try Tag.var_decl.create(c.arena, .{ |
| 876 | .name_token = name_tok, | 684 | .is_pub = is_pub, |
| 877 | .mut_token = mut_tok, | 685 | .is_const = is_const, |
| 878 | .semicolon_token = try appendToken(c, .Semicolon, ";"), | 686 | .is_extern = is_extern, |
| 879 | }, .{ | 687 | .is_export = is_export, |
| 880 | .visib_token = visib_tok, | 688 | .is_threadlocal = is_threadlocal, |
| 881 | .thread_local_token = thread_local_token, | 689 | .linksection_string = linksection_string, |
| 882 | .eq_token = eq_tok, | 690 | .alignment = alignment, |
| 883 | .extern_export_token = extern_tok, | 691 | .name = checked_name, |
| 884 | .type_node = type_node, | 692 | .type = type_node, |
| 885 | .align_node = align_expr, | 693 | .init = init_node, |
| 886 | .section_node = linksection_expr, | | |
| 887 | .init_node = init_node, | | |
| 888 | }); | 694 | }); |
| 889 | return addTopLevelDecl(c, checked_name, &node.base); | 695 | return addTopLevelDecl(c, checked_name, node); |
| 890 | } | 696 | } |
| 891 | | 697 | |
| 892 | fn transTypeDefAsBuiltin(c: *Context, typedef_decl: *const clang.TypedefNameDecl, builtin_name: []const u8) !*ast.Node { | 698 | const builtin_typedef_map = std.ComptimeStringMap([]const u8, .{ |
| 893 | _ = try c.decl_table.put(c.gpa, @ptrToInt(typedef_decl.getCanonicalDecl()), builtin_name); | 699 | .{ "uint8_t", "u8" }, |
| 894 | return transCreateNodeIdentifier(c, builtin_name); | 700 | .{ "int8_t", "i8" }, |
| 895 | } | 701 | .{ "uint16_t", "u16" }, |
| 896 | | 702 | .{ "int16_t", "i16" }, |
| 897 | fn checkForBuiltinTypedef(checked_name: []const u8) ?[]const u8 { | 703 | .{ "uint32_t", "u32" }, |
| 898 | const table = [_][2][]const u8{ | 704 | .{ "int32_t", "i32" }, |
| 899 | .{ "uint8_t", "u8" }, | 705 | .{ "uint64_t", "u64" }, |
| 900 | .{ "int8_t", "i8" }, | 706 | .{ "int64_t", "i64" }, |
| 901 | .{ "uint16_t", "u16" }, | 707 | .{ "intptr_t", "isize" }, |
| 902 | .{ "int16_t", "i16" }, | 708 | .{ "uintptr_t", "usize" }, |
| 903 | .{ "uint32_t", "u32" }, | 709 | .{ "ssize_t", "isize" }, |
| 904 | .{ "int32_t", "i32" }, | 710 | .{ "size_t", "usize" }, |
| 905 | .{ "uint64_t", "u64" }, | 711 | }); |
| 906 | .{ "int64_t", "i64" }, | | |
| 907 | .{ "intptr_t", "isize" }, | | |
| 908 | .{ "uintptr_t", "usize" }, | | |
| 909 | .{ "ssize_t", "isize" }, | | |
| 910 | .{ "size_t", "usize" }, | | |
| 911 | }; | | |
| 912 | | | |
| 913 | for (table) |entry| { | | |
| 914 | if (mem.eql(u8, checked_name, entry[0])) { | | |
| 915 | return entry[1]; | | |
| 916 | } | | |
| 917 | } | | |
| 918 | | | |
| 919 | return null; | | |
| 920 | } | | |
| 921 | | 712 | |
| 922 | fn transTypeDef(c: *Context, typedef_decl: *const clang.TypedefNameDecl, top_level_visit: bool) Error!?*ast.Node { | 713 | fn transTypeDef(c: *Context, scope: *Scope, typedef_decl: *const clang.TypedefNameDecl) Error!void { |
| 923 | if (c.decl_table.get(@ptrToInt(typedef_decl.getCanonicalDecl()))) |name| | 714 | if (c.decl_table.get(@ptrToInt(typedef_decl.getCanonicalDecl()))) |name| |
| 924 | return transCreateNodeIdentifier(c, name); // Avoid processing this decl twice | 715 | return; // Avoid processing this decl twice |
| 925 | const rp = makeRestorePoint(c); | 716 | const toplevel = scope.id == .root; |
| | 717 | const bs: *Scope.Block = if (!toplevel) try scope.findBlockScope(c) else undefined; |
| 926 | | 718 | |
| 927 | const typedef_name = try c.str(@ptrCast(*const clang.NamedDecl, typedef_decl).getName_bytes_begin()); | 719 | const bare_name = try c.str(@ptrCast(*const clang.NamedDecl, typedef_decl).getName_bytes_begin()); |
| 928 | | 720 | |
| 929 | // TODO https://github.com/ziglang/zig/issues/3756 | 721 | // TODO https://github.com/ziglang/zig/issues/3756 |
| 930 | // TODO https://github.com/ziglang/zig/issues/1802 | 722 | // TODO https://github.com/ziglang/zig/issues/1802 |
| 931 | const checked_name = if (isZigPrimitiveType(typedef_name)) try std.fmt.allocPrint(c.arena, "{s}_{d}", .{ typedef_name, c.getMangle() }) else typedef_name; | 723 | var name: []const u8 = if (isZigPrimitiveType(bare_name)) try std.fmt.allocPrint(c.arena, "{s}_{d}", .{ bare_name, c.getMangle() }) else bare_name; |
| 932 | if (checkForBuiltinTypedef(checked_name)) |builtin| { | 724 | if (builtin_typedef_map.get(name)) |builtin| { |
| 933 | return transTypeDefAsBuiltin(c, typedef_decl, builtin); | 725 | return c.decl_table.putNoClobber(c.gpa, @ptrToInt(typedef_decl.getCanonicalDecl()), builtin); |
| 934 | } | 726 | } |
| | 727 | if (!toplevel) name = try bs.makeMangledName(c, name); |
| | 728 | try c.decl_table.putNoClobber(c.gpa, @ptrToInt(typedef_decl.getCanonicalDecl()), name); |
| 935 | | 729 | |
| 936 | if (!top_level_visit) { | | |
| 937 | return transCreateNodeIdentifier(c, checked_name); | | |
| 938 | } | | |
| 939 | | | |
| 940 | _ = try c.decl_table.put(c.gpa, @ptrToInt(typedef_decl.getCanonicalDecl()), checked_name); | | |
| 941 | const node = (try transCreateNodeTypedef(rp, typedef_decl, true, checked_name)) orelse return null; | | |
| 942 | try addTopLevelDecl(c, checked_name, node); | | |
| 943 | return transCreateNodeIdentifier(c, checked_name); | | |
| 944 | } | | |
| 945 | | | |
| 946 | fn transCreateNodeTypedef( | | |
| 947 | rp: RestorePoint, | | |
| 948 | typedef_decl: *const clang.TypedefNameDecl, | | |
| 949 | toplevel: bool, | | |
| 950 | checked_name: []const u8, | | |
| 951 | ) Error!?*ast.Node { | | |
| 952 | const visib_tok = if (toplevel) try appendToken(rp.c, .Keyword_pub, "pub") else null; | | |
| 953 | const mut_tok = try appendToken(rp.c, .Keyword_const, "const"); | | |
| 954 | const name_tok = try appendIdentifier(rp.c, checked_name); | | |
| 955 | const eq_token = try appendToken(rp.c, .Equal, "="); | | |
| 956 | const child_qt = typedef_decl.getUnderlyingType(); | 730 | const child_qt = typedef_decl.getUnderlyingType(); |
| 957 | const typedef_loc = typedef_decl.getLocation(); | 731 | const typedef_loc = typedef_decl.getLocation(); |
| 958 | const init_node = transQualType(rp, child_qt, typedef_loc) catch |err| switch (err) { | 732 | const init_node = transQualType(c, scope, child_qt, typedef_loc) catch |err| switch (err) { |
| 959 | error.UnsupportedType => { | 733 | error.UnsupportedType => { |
| 960 | try failDecl(rp.c, typedef_loc, checked_name, "unable to resolve typedef child type", .{}); | 734 | return failDecl(c, typedef_loc, name, "unable to resolve typedef child type", .{}); |
| 961 | return null; | | |
| 962 | }, | 735 | }, |
| 963 | error.OutOfMemory => |e| return e, | 736 | error.OutOfMemory => |e| return e, |
| 964 | }; | 737 | }; |
| 965 | const semicolon_token = try appendToken(rp.c, .Semicolon, ";"); | 738 | |
| 966 | | 739 | const payload = try c.arena.create(ast.Payload.SimpleVarDecl); |
| 967 | const node = try ast.Node.VarDecl.create(rp.c.arena, .{ | 740 | payload.* = .{ |
| 968 | .name_token = name_tok, | 741 | .base = .{ .tag = ([2]Tag{ .var_simple, .pub_var_simple })[@boolToInt(toplevel)] }, |
| 969 | .mut_token = mut_tok, | 742 | .data = .{ |
| 970 | .semicolon_token = semicolon_token, | 743 | .name = name, |
| 971 | }, .{ | 744 | .init = init_node, |
| 972 | .visib_token = visib_tok, | 745 | }, |
| 973 | .eq_token = eq_token, | 746 | }; |
| 974 | .init_node = init_node, | 747 | const node = Node.initPayload(&payload.base); |
| 975 | }); | 748 | |
| 976 | return &node.base; | 749 | if (toplevel) { |
| | 750 | try addTopLevelDecl(c, name, node); |
| | 751 | } else { |
| | 752 | try scope.appendNode(node); |
| | 753 | } |
| 977 | } | 754 | } |
| 978 | | 755 | |
| 979 | fn transRecordDecl(c: *Context, record_decl: *const clang.RecordDecl) Error!?*ast.Node { | 756 | fn transRecordDecl(c: *Context, scope: *Scope, record_decl: *const clang.RecordDecl) Error!void { |
| 980 | if (c.decl_table.get(@ptrToInt(record_decl.getCanonicalDecl()))) |name| | 757 | if (c.decl_table.get(@ptrToInt(record_decl.getCanonicalDecl()))) |name| |
| 981 | return try transCreateNodeIdentifier(c, name); // Avoid processing this decl twice | 758 | return; // Avoid processing this decl twice |
| 982 | const record_loc = record_decl.getLocation(); | 759 | const record_loc = record_decl.getLocation(); |
| | 760 | const toplevel = scope.id == .root; |
| | 761 | const bs: *Scope.Block = if (!toplevel) try scope.findBlockScope(c) else undefined; |
| 983 | | 762 | |
| 984 | var bare_name = try c.str(@ptrCast(*const clang.NamedDecl, record_decl).getName_bytes_begin()); | 763 | var bare_name = try c.str(@ptrCast(*const clang.NamedDecl, record_decl).getName_bytes_begin()); |
| 985 | var is_unnamed = false; | 764 | var is_unnamed = false; |
| ... | @@ -991,46 +770,31 @@ fn transRecordDecl(c: *Context, record_decl: *const clang.RecordDecl) Error!?*as | ... | @@ -991,46 +770,31 @@ fn transRecordDecl(c: *Context, record_decl: *const clang.RecordDecl) Error!?*as |
| 991 | } | 770 | } |
| 992 | | 771 | |
| 993 | var container_kind_name: []const u8 = undefined; | 772 | var container_kind_name: []const u8 = undefined; |
| 994 | var container_kind: std.zig.Token.Id = undefined; | 773 | var is_union = false; |
| 995 | if (record_decl.isUnion()) { | 774 | if (record_decl.isUnion()) { |
| 996 | container_kind_name = "union"; | 775 | container_kind_name = "union"; |
| 997 | container_kind = .Keyword_union; | 776 | is_union = true; |
| 998 | } else if (record_decl.isStruct()) { | 777 | } else if (record_decl.isStruct()) { |
| 999 | container_kind_name = "struct"; | 778 | container_kind_name = "struct"; |
| 1000 | container_kind = .Keyword_struct; | | |
| 1001 | } else { | 779 | } else { |
| 1002 | try emitWarning(c, record_loc, "record {s} is not a struct or union", .{bare_name}); | 780 | try c.decl_table.putNoClobber(c.gpa, @ptrToInt(record_decl.getCanonicalDecl()), bare_name); |
| 1003 | return null; | 781 | return failDecl(c, record_loc, bare_name, "record {s} is not a struct or union", .{bare_name}); |
| 1004 | } | 782 | } |
| 1005 | | 783 | |
| 1006 | const name = try std.fmt.allocPrint(c.arena, "{s}_{s}", .{ container_kind_name, bare_name }); | 784 | var name: []const u8 = try std.fmt.allocPrint(c.arena, "{s}_{s}", .{ container_kind_name, bare_name }); |
| 1007 | _ = try c.decl_table.put(c.gpa, @ptrToInt(record_decl.getCanonicalDecl()), name); | 785 | if (!toplevel) name = try bs.makeMangledName(c, name); |
| 1008 | | 786 | try c.decl_table.putNoClobber(c.gpa, @ptrToInt(record_decl.getCanonicalDecl()), name); |
| 1009 | const visib_tok = if (!is_unnamed) try appendToken(c, .Keyword_pub, "pub") else null; | | |
| 1010 | const mut_tok = try appendToken(c, .Keyword_const, "const"); | | |
| 1011 | const name_tok = try appendIdentifier(c, name); | | |
| 1012 | | 787 | |
| 1013 | const eq_token = try appendToken(c, .Equal, "="); | 788 | const is_pub = toplevel and !is_unnamed; |
| 1014 | | | |
| 1015 | var semicolon: ast.TokenIndex = undefined; | | |
| 1016 | const init_node = blk: { | 789 | const init_node = blk: { |
| 1017 | const rp = makeRestorePoint(c); | | |
| 1018 | const record_def = record_decl.getDefinition() orelse { | 790 | const record_def = record_decl.getDefinition() orelse { |
| 1019 | _ = try c.opaque_demotes.put(c.gpa, @ptrToInt(record_decl.getCanonicalDecl()), {}); | 791 | _ = try c.opaque_demotes.put(c.gpa, @ptrToInt(record_decl.getCanonicalDecl()), {}); |
| 1020 | const opaque_type = try transCreateNodeOpaqueType(c); | 792 | break :blk Tag.opaque_literal.init(); |
| 1021 | semicolon = try appendToken(c, .Semicolon, ";"); | | |
| 1022 | break :blk opaque_type; | | |
| 1023 | }; | 793 | }; |
| 1024 | | 794 | |
| 1025 | const layout_tok = try if (record_decl.getPackedAttribute()) | 795 | const is_packed = record_decl.getPackedAttribute(); |
| 1026 | appendToken(c, .Keyword_packed, "packed") | 796 | var fields = std.ArrayList(ast.Payload.Record.Field).init(c.gpa); |
| 1027 | else | 797 | defer fields.deinit(); |
| 1028 | appendToken(c, .Keyword_extern, "extern"); | | |
| 1029 | const container_tok = try appendToken(c, container_kind, container_kind_name); | | |
| 1030 | const lbrace_token = try appendToken(c, .LBrace, "{"); | | |
| 1031 | | | |
| 1032 | var fields_and_decls = std.ArrayList(*ast.Node).init(c.gpa); | | |
| 1033 | defer fields_and_decls.deinit(); | | |
| 1034 | | 798 | |
| 1035 | var unnamed_field_count: u32 = 0; | 799 | var unnamed_field_count: u32 = 0; |
| 1036 | var it = record_def.field_begin(); | 800 | var it = record_def.field_begin(); |
| ... | @@ -1042,111 +806,88 @@ fn transRecordDecl(c: *Context, record_decl: *const clang.RecordDecl) Error!?*as | ... | @@ -1042,111 +806,88 @@ fn transRecordDecl(c: *Context, record_decl: *const clang.RecordDecl) Error!?*as |
| 1042 | | 806 | |
| 1043 | if (field_decl.isBitField()) { | 807 | if (field_decl.isBitField()) { |
| 1044 | _ = try c.opaque_demotes.put(c.gpa, @ptrToInt(record_decl.getCanonicalDecl()), {}); | 808 | _ = try c.opaque_demotes.put(c.gpa, @ptrToInt(record_decl.getCanonicalDecl()), {}); |
| 1045 | const opaque_type = try transCreateNodeOpaqueType(c); | 809 | try warn(c, scope, field_loc, "{s} demoted to opaque type - has bitfield", .{container_kind_name}); |
| 1046 | semicolon = try appendToken(c, .Semicolon, ";"); | 810 | break :blk Tag.opaque_literal.init(); |
| 1047 | try emitWarning(c, field_loc, "{s} demoted to opaque type - has bitfield", .{container_kind_name}); | | |
| 1048 | break :blk opaque_type; | | |
| 1049 | } | 811 | } |
| 1050 | | 812 | |
| 1051 | if (qualTypeCanon(field_qt).isIncompleteOrZeroLengthArrayType(c.clang_context)) { | 813 | if (qualTypeCanon(field_qt).isIncompleteOrZeroLengthArrayType(c.clang_context)) { |
| 1052 | _ = try c.opaque_demotes.put(c.gpa, @ptrToInt(record_decl.getCanonicalDecl()), {}); | 814 | _ = try c.opaque_demotes.put(c.gpa, @ptrToInt(record_decl.getCanonicalDecl()), {}); |
| 1053 | const opaque_type = try transCreateNodeOpaqueType(c); | 815 | try warn(c, scope, field_loc, "{s} demoted to opaque type - has variable length array", .{container_kind_name}); |
| 1054 | semicolon = try appendToken(c, .Semicolon, ";"); | 816 | break :blk Tag.opaque_literal.init(); |
| 1055 | try emitWarning(c, field_loc, "{s} demoted to opaque type - has variable length array", .{container_kind_name}); | | |
| 1056 | break :blk opaque_type; | | |
| 1057 | } | 817 | } |
| 1058 | | 818 | |
| 1059 | var is_anon = false; | 819 | var is_anon = false; |
| 1060 | var raw_name = try c.str(@ptrCast(*const clang.NamedDecl, field_decl).getName_bytes_begin()); | 820 | var field_name = try c.str(@ptrCast(*const clang.NamedDecl, field_decl).getName_bytes_begin()); |
| 1061 | if (field_decl.isAnonymousStructOrUnion() or raw_name.len == 0) { | 821 | if (field_decl.isAnonymousStructOrUnion() or field_name.len == 0) { |
| 1062 | // Context.getMangle() is not used here because doing so causes unpredictable field names for anonymous fields. | 822 | // Context.getMangle() is not used here because doing so causes unpredictable field names for anonymous fields. |
| 1063 | raw_name = try std.fmt.allocPrint(c.arena, "unnamed_{d}", .{unnamed_field_count}); | 823 | field_name = try std.fmt.allocPrint(c.arena, "unnamed_{d}", .{unnamed_field_count}); |
| 1064 | unnamed_field_count += 1; | 824 | unnamed_field_count += 1; |
| 1065 | is_anon = true; | 825 | is_anon = true; |
| 1066 | } | 826 | } |
| 1067 | const field_name = try appendIdentifier(c, raw_name); | 827 | const field_type = transQualType(c, scope, field_qt, field_loc) catch |err| switch (err) { |
| 1068 | _ = try appendToken(c, .Colon, ":"); | | |
| 1069 | const field_type = transQualType(rp, field_qt, field_loc) catch |err| switch (err) { | | |
| 1070 | error.UnsupportedType => { | 828 | error.UnsupportedType => { |
| 1071 | _ = try c.opaque_demotes.put(c.gpa, @ptrToInt(record_decl.getCanonicalDecl()), {}); | 829 | _ = try c.opaque_demotes.put(c.gpa, @ptrToInt(record_decl.getCanonicalDecl()), {}); |
| 1072 | const opaque_type = try transCreateNodeOpaqueType(c); | 830 | try warn(c, scope, record_loc, "{s} demoted to opaque type - unable to translate type of field {s}", .{ container_kind_name, field_name }); |
| 1073 | semicolon = try appendToken(c, .Semicolon, ";"); | 831 | break :blk Tag.opaque_literal.init(); |
| 1074 | try emitWarning(c, record_loc, "{s} demoted to opaque type - unable to translate type of field {s}", .{ container_kind_name, raw_name }); | | |
| 1075 | break :blk opaque_type; | | |
| 1076 | }, | 832 | }, |
| 1077 | else => |e| return e, | 833 | else => |e| return e, |
| 1078 | }; | 834 | }; |
| 1079 | | 835 | |
| 1080 | const align_expr = blk_2: { | 836 | const alignment = blk_2: { |
| 1081 | const alignment = field_decl.getAlignedAttribute(c.clang_context); | 837 | const alignment = field_decl.getAlignedAttribute(c.clang_context); |
| 1082 | if (alignment != 0) { | 838 | if (alignment != 0) { |
| 1083 | _ = try appendToken(c, .Keyword_align, "align"); | | |
| 1084 | _ = try appendToken(c, .LParen, "("); | | |
| 1085 | // Clang reports the alignment in bits | 839 | // Clang reports the alignment in bits |
| 1086 | const expr = try transCreateNodeInt(c, alignment / 8); | 840 | break :blk_2 alignment / 8; |
| 1087 | _ = try appendToken(c, .RParen, ")"); | | |
| 1088 | | | |
| 1089 | break :blk_2 expr; | | |
| 1090 | } | 841 | } |
| 1091 | break :blk_2 null; | 842 | break :blk_2 null; |
| 1092 | }; | 843 | }; |
| 1093 | | 844 | |
| 1094 | const field_node = try c.arena.create(ast.Node.ContainerField); | | |
| 1095 | field_node.* = .{ | | |
| 1096 | .doc_comments = null, | | |
| 1097 | .comptime_token = null, | | |
| 1098 | .name_token = field_name, | | |
| 1099 | .type_expr = field_type, | | |
| 1100 | .value_expr = null, | | |
| 1101 | .align_expr = align_expr, | | |
| 1102 | }; | | |
| 1103 | | | |
| 1104 | if (is_anon) { | 845 | if (is_anon) { |
| 1105 | _ = try c.decl_table.put( | 846 | try c.decl_table.putNoClobber(c.gpa, @ptrToInt(field_decl.getCanonicalDecl()), field_name); |
| 1106 | c.gpa, | | |
| 1107 | @ptrToInt(field_decl.getCanonicalDecl()), | | |
| 1108 | raw_name, | | |
| 1109 | ); | | |
| 1110 | } | 847 | } |
| 1111 | | 848 | |
| 1112 | try fields_and_decls.append(&field_node.base); | 849 | try fields.append(.{ |
| 1113 | _ = try appendToken(c, .Comma, ","); | 850 | .name = field_name, |
| | 851 | .type = field_type, |
| | 852 | .alignment = alignment, |
| | 853 | }); |
| 1114 | } | 854 | } |
| 1115 | const container_node = try ast.Node.ContainerDecl.alloc(c.arena, fields_and_decls.items.len); | 855 | |
| 1116 | container_node.* = .{ | 856 | const record_payload = try c.arena.create(ast.Payload.Record); |
| 1117 | .layout_token = layout_tok, | 857 | record_payload.* = .{ |
| 1118 | .kind_token = container_tok, | 858 | .base = .{ .tag = ([2]Tag{ .@"struct", .@"union" })[@boolToInt(is_union)] }, |
| 1119 | .init_arg_expr = .None, | 859 | .data = .{ |
| 1120 | .fields_and_decls_len = fields_and_decls.items.len, | 860 | .is_packed = is_packed, |
| 1121 | .lbrace_token = lbrace_token, | 861 | .fields = try c.arena.dupe(ast.Payload.Record.Field, fields.items), |
| 1122 | .rbrace_token = try appendToken(c, .RBrace, "}"), | 862 | }, |
| 1123 | }; | 863 | }; |
| 1124 | mem.copy(*ast.Node, container_node.fieldsAndDecls(), fields_and_decls.items); | 864 | break :blk Node.initPayload(&record_payload.base); |
| 1125 | semicolon = try appendToken(c, .Semicolon, ";"); | | |
| 1126 | break :blk &container_node.base; | | |
| 1127 | }; | 865 | }; |
| 1128 | | 866 | |
| 1129 | const node = try ast.Node.VarDecl.create(c.arena, .{ | 867 | const payload = try c.arena.create(ast.Payload.SimpleVarDecl); |
| 1130 | .name_token = name_tok, | 868 | payload.* = .{ |
| 1131 | .mut_token = mut_tok, | 869 | .base = .{ .tag = ([2]Tag{ .var_simple, .pub_var_simple })[@boolToInt(is_pub)] }, |
| 1132 | .semicolon_token = semicolon, | 870 | .data = .{ |
| 1133 | }, .{ | 871 | .name = name, |
| 1134 | .visib_token = visib_tok, | 872 | .init = init_node, |
| 1135 | .eq_token = eq_token, | 873 | }, |
| 1136 | .init_node = init_node, | 874 | }; |
| 1137 | }); | | |
| 1138 | | 875 | |
| 1139 | try addTopLevelDecl(c, name, &node.base); | 876 | if (toplevel) { |
| 1140 | if (!is_unnamed) | 877 | try addTopLevelDecl(c, name, Node.initPayload(&payload.base)); |
| 1141 | try c.alias_list.append(.{ .alias = bare_name, .name = name }); | 878 | if (!is_unnamed) |
| 1142 | return transCreateNodeIdentifier(c, name); | 879 | try c.alias_list.append(.{ .alias = bare_name, .name = name }); |
| | 880 | } else { |
| | 881 | try scope.appendNode(Node.initPayload(&payload.base)); |
| | 882 | } |
| 1143 | } | 883 | } |
| 1144 | | 884 | |
| 1145 | fn transEnumDecl(c: *Context, enum_decl: *const clang.EnumDecl) Error!?*ast.Node { | 885 | fn transEnumDecl(c: *Context, scope: *Scope, enum_decl: *const clang.EnumDecl) Error!void { |
| 1146 | if (c.decl_table.get(@ptrToInt(enum_decl.getCanonicalDecl()))) |name| | 886 | if (c.decl_table.get(@ptrToInt(enum_decl.getCanonicalDecl()))) |name| |
| 1147 | return try transCreateNodeIdentifier(c, name); // Avoid processing this decl twice | 887 | return; // Avoid processing this decl twice |
| 1148 | const rp = makeRestorePoint(c); | | |
| 1149 | const enum_loc = enum_decl.getLocation(); | 888 | const enum_loc = enum_decl.getLocation(); |
| | 889 | const toplevel = scope.id == .root; |
| | 890 | const bs: *Scope.Block = if (!toplevel) try scope.findBlockScope(c) else undefined; |
| 1150 | | 891 | |
| 1151 | var bare_name = try c.str(@ptrCast(*const clang.NamedDecl, enum_decl).getName_bytes_begin()); | 892 | var bare_name = try c.str(@ptrCast(*const clang.NamedDecl, enum_decl).getName_bytes_begin()); |
| 1152 | var is_unnamed = false; | 893 | var is_unnamed = false; |
| ... | @@ -1155,13 +896,13 @@ fn transEnumDecl(c: *Context, enum_decl: *const clang.EnumDecl) Error!?*ast.Node | ... | @@ -1155,13 +896,13 @@ fn transEnumDecl(c: *Context, enum_decl: *const clang.EnumDecl) Error!?*ast.Node |
| 1155 | is_unnamed = true; | 896 | is_unnamed = true; |
| 1156 | } | 897 | } |
| 1157 | | 898 | |
| 1158 | const name = try std.fmt.allocPrint(c.arena, "enum_{s}", .{bare_name}); | 899 | var name: []const u8 = try std.fmt.allocPrint(c.arena, "enum_{s}", .{bare_name}); |
| 1159 | _ = try c.decl_table.put(c.gpa, @ptrToInt(enum_decl.getCanonicalDecl()), name); | 900 | if (!toplevel) _ = try bs.makeMangledName(c, name); |
| | 901 | try c.decl_table.putNoClobber(c.gpa, @ptrToInt(enum_decl.getCanonicalDecl()), name); |
| 1160 | | 902 | |
| 1161 | const visib_tok = if (!is_unnamed) try appendToken(c, .Keyword_pub, "pub") else null; | 903 | const is_pub = toplevel and !is_unnamed; |
| 1162 | const mut_tok = try appendToken(c, .Keyword_const, "const"); | 904 | var redecls = std.ArrayList(Tag.enum_redecl.Data()).init(c.gpa); |
| 1163 | const name_tok = try appendIdentifier(c, name); | 905 | defer redecls.deinit(); |
| 1164 | const eq_token = try appendToken(c, .Equal, "="); | | |
| 1165 | | 906 | |
| 1166 | const init_node = if (enum_decl.getDefinition()) |enum_def| blk: { | 907 | const init_node = if (enum_decl.getDefinition()) |enum_def| blk: { |
| 1167 | var pure_enum = true; | 908 | var pure_enum = true; |
| ... | @@ -1175,11 +916,8 @@ fn transEnumDecl(c: *Context, enum_decl: *const clang.EnumDecl) Error!?*ast.Node | ... | @@ -1175,11 +916,8 @@ fn transEnumDecl(c: *Context, enum_decl: *const clang.EnumDecl) Error!?*ast.Node |
| 1175 | } | 916 | } |
| 1176 | } | 917 | } |
| 1177 | | 918 | |
| 1178 | const extern_tok = try appendToken(c, .Keyword_extern, "extern"); | 919 | var fields = std.ArrayList(ast.Payload.Enum.Field).init(c.gpa); |
| 1179 | const container_tok = try appendToken(c, .Keyword_enum, "enum"); | 920 | defer fields.deinit(); |
| 1180 | | | |
| 1181 | var fields_and_decls = std.ArrayList(*ast.Node).init(c.gpa); | | |
| 1182 | defer fields_and_decls.deinit(); | | |
| 1183 | | 921 | |
| 1184 | const int_type = enum_decl.getIntegerType(); | 922 | const int_type = enum_decl.getIntegerType(); |
| 1185 | // The underlying type may be null in case of forward-declared enum | 923 | // The underlying type may be null in case of forward-declared enum |
| ... | @@ -1187,30 +925,22 @@ fn transEnumDecl(c: *Context, enum_decl: *const clang.EnumDecl) Error!?*ast.Node | ... | @@ -1187,30 +925,22 @@ fn transEnumDecl(c: *Context, enum_decl: *const clang.EnumDecl) Error!?*ast.Node |
| 1187 | // default to the usual integer type used for all the enums. | 925 | // default to the usual integer type used for all the enums. |
| 1188 | | 926 | |
| 1189 | // default to c_int since msvc and gcc default to different types | 927 | // default to c_int since msvc and gcc default to different types |
| 1190 | _ = try appendToken(c, .LParen, "("); | 928 | const init_arg_expr = if (int_type.ptr != null and |
| 1191 | const init_arg_expr = ast.Node.ContainerDecl.InitArg{ | 929 | !isCBuiltinType(int_type, .UInt) and |
| 1192 | .Type = if (int_type.ptr != null and | 930 | !isCBuiltinType(int_type, .Int)) |
| 1193 | !isCBuiltinType(int_type, .UInt) and | 931 | transQualType(c, scope, int_type, enum_loc) catch |err| switch (err) { |
| 1194 | !isCBuiltinType(int_type, .Int)) | 932 | error.UnsupportedType => { |
| 1195 | transQualType(rp, int_type, enum_loc) catch |err| switch (err) { | 933 | return failDecl(c, enum_loc, name, "unable to translate enum tag type", .{}); |
| 1196 | error.UnsupportedType => { | 934 | }, |
| 1197 | try failDecl(c, enum_loc, name, "unable to translate enum tag type", .{}); | 935 | else => |e| return e, |
| 1198 | return null; | 936 | } |
| 1199 | }, | 937 | else |
| 1200 | else => |e| return e, | 938 | try Tag.type.create(c.arena, "c_int"); |
| 1201 | } | | |
| 1202 | else | | |
| 1203 | try transCreateNodeIdentifier(c, "c_int"), | | |
| 1204 | }; | | |
| 1205 | _ = try appendToken(c, .RParen, ")"); | | |
| 1206 | | | |
| 1207 | const lbrace_token = try appendToken(c, .LBrace, "{"); | | |
| 1208 | | 939 | |
| 1209 | it = enum_def.enumerator_begin(); | 940 | it = enum_def.enumerator_begin(); |
| 1210 | end_it = enum_def.enumerator_end(); | 941 | end_it = enum_def.enumerator_end(); |
| 1211 | while (it.neq(end_it)) : (it = it.next()) { | 942 | while (it.neq(end_it)) : (it = it.next()) { |
| 1212 | const enum_const = it.deref(); | 943 | const enum_const = it.deref(); |
| 1213 | | | |
| 1214 | const enum_val_name = try c.str(@ptrCast(*const clang.NamedDecl, enum_const).getName_bytes_begin()); | 944 | const enum_val_name = try c.str(@ptrCast(*const clang.NamedDecl, enum_const).getName_bytes_begin()); |
| 1215 | | 945 | |
| 1216 | const field_name = if (!is_unnamed and mem.startsWith(u8, enum_val_name, bare_name)) | 946 | const field_name = if (!is_unnamed and mem.startsWith(u8, enum_val_name, bare_name)) |
| ... | @@ -1218,123 +948,62 @@ fn transEnumDecl(c: *Context, enum_decl: *const clang.EnumDecl) Error!?*ast.Node | ... | @@ -1218,123 +948,62 @@ fn transEnumDecl(c: *Context, enum_decl: *const clang.EnumDecl) Error!?*ast.Node |
| 1218 | else | 948 | else |
| 1219 | enum_val_name; | 949 | enum_val_name; |
| 1220 | | 950 | |
| 1221 | const field_name_tok = try appendIdentifier(c, field_name); | 951 | const int_node = if (!pure_enum) |
| 1222 | | 952 | try transCreateNodeAPInt(c, enum_const.getInitVal()) |
| 1223 | const int_node = if (!pure_enum) blk_2: { | 953 | else |
| 1224 | _ = try appendToken(c, .Colon, "="); | | |
| 1225 | break :blk_2 try transCreateNodeAPInt(c, enum_const.getInitVal()); | | |
| 1226 | } else | | |
| 1227 | null; | 954 | null; |
| 1228 | | 955 | |
| 1229 | const field_node = try c.arena.create(ast.Node.ContainerField); | 956 | try fields.append(.{ |
| 1230 | field_node.* = .{ | 957 | .name = field_name, |
| 1231 | .doc_comments = null, | 958 | .value = int_node, |
| 1232 | .comptime_token = null, | 959 | }); |
| 1233 | .name_token = field_name_tok, | | |
| 1234 | .type_expr = null, | | |
| 1235 | .value_expr = int_node, | | |
| 1236 | .align_expr = null, | | |
| 1237 | }; | | |
| 1238 | | | |
| 1239 | try fields_and_decls.append(&field_node.base); | | |
| 1240 | _ = try appendToken(c, .Comma, ","); | | |
| 1241 | | 960 | |
| 1242 | // In C each enum value is in the global namespace. So we put them there too. | 961 | // In C each enum value is in the global namespace. So we put them there too. |
| 1243 | // At this point we can rely on the enum emitting successfully. | 962 | // At this point we can rely on the enum emitting successfully. |
| 1244 | const tld_visib_tok = try appendToken(c, .Keyword_pub, "pub"); | 963 | try redecls.append(.{ |
| 1245 | const tld_mut_tok = try appendToken(c, .Keyword_const, "const"); | 964 | .enum_val_name = enum_val_name, |
| 1246 | const tld_name_tok = try appendIdentifier(c, enum_val_name); | 965 | .field_name = field_name, |
| 1247 | const tld_eq_token = try appendToken(c, .Equal, "="); | 966 | .enum_name = name, |
| 1248 | const cast_node = try rp.c.createBuiltinCall("@enumToInt", 1); | | |
| 1249 | const enum_ident = try transCreateNodeIdentifier(c, name); | | |
| 1250 | const period_tok = try appendToken(c, .Period, "."); | | |
| 1251 | const field_ident = try transCreateNodeIdentifier(c, field_name); | | |
| 1252 | const field_access_node = try c.arena.create(ast.Node.SimpleInfixOp); | | |
| 1253 | field_access_node.* = .{ | | |
| 1254 | .base = .{ .tag = .Period }, | | |
| 1255 | .op_token = period_tok, | | |
| 1256 | .lhs = enum_ident, | | |
| 1257 | .rhs = field_ident, | | |
| 1258 | }; | | |
| 1259 | cast_node.params()[0] = &field_access_node.base; | | |
| 1260 | cast_node.rparen_token = try appendToken(rp.c, .RParen, ")"); | | |
| 1261 | const tld_init_node = &cast_node.base; | | |
| 1262 | const tld_semicolon_token = try appendToken(c, .Semicolon, ";"); | | |
| 1263 | const tld_node = try ast.Node.VarDecl.create(c.arena, .{ | | |
| 1264 | .name_token = tld_name_tok, | | |
| 1265 | .mut_token = tld_mut_tok, | | |
| 1266 | .semicolon_token = tld_semicolon_token, | | |
| 1267 | }, .{ | | |
| 1268 | .visib_token = tld_visib_tok, | | |
| 1269 | .eq_token = tld_eq_token, | | |
| 1270 | .init_node = tld_init_node, | | |
| 1271 | }); | 967 | }); |
| 1272 | try addTopLevelDecl(c, field_name, &tld_node.base); | | |
| 1273 | } | 968 | } |
| 1274 | // make non exhaustive | | |
| 1275 | const field_node = try c.arena.create(ast.Node.ContainerField); | | |
| 1276 | field_node.* = .{ | | |
| 1277 | .doc_comments = null, | | |
| 1278 | .comptime_token = null, | | |
| 1279 | .name_token = try appendIdentifier(c, "_"), | | |
| 1280 | .type_expr = null, | | |
| 1281 | .value_expr = null, | | |
| 1282 | .align_expr = null, | | |
| 1283 | }; | | |
| 1284 | | 969 | |
| 1285 | try fields_and_decls.append(&field_node.base); | 970 | break :blk try Tag.@"enum".create(c.arena, .{ |
| 1286 | _ = try appendToken(c, .Comma, ","); | 971 | .int_type = init_arg_expr, |
| 1287 | const container_node = try ast.Node.ContainerDecl.alloc(c.arena, fields_and_decls.items.len); | 972 | .fields = try c.arena.dupe(ast.Payload.Enum.Field, fields.items), |
| 1288 | container_node.* = .{ | 973 | }); |
| 1289 | .layout_token = extern_tok, | | |
| 1290 | .kind_token = container_tok, | | |
| 1291 | .init_arg_expr = init_arg_expr, | | |
| 1292 | .fields_and_decls_len = fields_and_decls.items.len, | | |
| 1293 | .lbrace_token = lbrace_token, | | |
| 1294 | .rbrace_token = try appendToken(c, .RBrace, "}"), | | |
| 1295 | }; | | |
| 1296 | mem.copy(*ast.Node, container_node.fieldsAndDecls(), fields_and_decls.items); | | |
| 1297 | break :blk &container_node.base; | | |
| 1298 | } else blk: { | 974 | } else blk: { |
| 1299 | _ = try c.opaque_demotes.put(c.gpa, @ptrToInt(enum_decl.getCanonicalDecl()), {}); | 975 | _ = try c.opaque_demotes.put(c.gpa, @ptrToInt(enum_decl.getCanonicalDecl()), {}); |
| 1300 | break :blk try transCreateNodeOpaqueType(c); | 976 | break :blk Tag.opaque_literal.init(); |
| 1301 | }; | 977 | }; |
| 1302 | | 978 | |
| 1303 | const semicolon_token = try appendToken(c, .Semicolon, ";"); | 979 | const payload = try c.arena.create(ast.Payload.SimpleVarDecl); |
| 1304 | const node = try ast.Node.VarDecl.create(c.arena, .{ | 980 | payload.* = .{ |
| 1305 | .name_token = name_tok, | 981 | .base = .{ .tag = ([2]Tag{ .var_simple, .pub_var_simple })[@boolToInt(is_pub)] }, |
| 1306 | .mut_token = mut_tok, | 982 | .data = .{ |
| 1307 | .semicolon_token = semicolon_token, | 983 | .name = name, |
| 1308 | }, .{ | 984 | .init = init_node, |
| 1309 | .visib_token = visib_tok, | 985 | }, |
| 1310 | .eq_token = eq_token, | 986 | }; |
| 1311 | .init_node = init_node, | | |
| 1312 | }); | | |
| 1313 | | 987 | |
| 1314 | try addTopLevelDecl(c, name, &node.base); | 988 | if (toplevel) { |
| 1315 | if (!is_unnamed) | 989 | try addTopLevelDecl(c, name, Node.initPayload(&payload.base)); |
| 1316 | try c.alias_list.append(.{ .alias = bare_name, .name = name }); | 990 | if (!is_unnamed) |
| 1317 | return transCreateNodeIdentifier(c, name); | 991 | try c.alias_list.append(.{ .alias = bare_name, .name = name }); |
| 1318 | } | 992 | } else { |
| 1319 | | 993 | try scope.appendNode(Node.initPayload(&payload.base)); |
| 1320 | fn createAlias(c: *Context, alias: anytype) !void { | 994 | } |
| 1321 | const visib_tok = try appendToken(c, .Keyword_pub, "pub"); | 995 | |
| 1322 | const mut_tok = try appendToken(c, .Keyword_const, "const"); | 996 | for (redecls.items) |redecl| { |
| 1323 | const name_tok = try appendIdentifier(c, alias.alias); | 997 | if (toplevel) { |
| 1324 | const eq_token = try appendToken(c, .Equal, "="); | 998 | try addTopLevelDecl(c, redecl.field_name, try Tag.pub_enum_redecl.create(c.arena, redecl)); |
| 1325 | const init_node = try transCreateNodeIdentifier(c, alias.name); | 999 | } else { |
| 1326 | const semicolon_token = try appendToken(c, .Semicolon, ";"); | 1000 | try scope.appendNode(try Tag.enum_redecl.create(c.arena, .{ |
| 1327 | | 1001 | .enum_val_name = try bs.makeMangledName(c, redecl.enum_val_name), |
| 1328 | const node = try ast.Node.VarDecl.create(c.arena, .{ | 1002 | .field_name = redecl.field_name, |
| 1329 | .name_token = name_tok, | 1003 | .enum_name = redecl.enum_name, |
| 1330 | .mut_token = mut_tok, | 1004 | })); |
| 1331 | .semicolon_token = semicolon_token, | 1005 | } |
| 1332 | }, .{ | 1006 | } |
| 1333 | .visib_token = visib_tok, | | |
| 1334 | .eq_token = eq_token, | | |
| 1335 | .init_node = init_node, | | |
| 1336 | }); | | |
| 1337 | return addTopLevelDecl(c, alias.alias, &node.base); | | |
| 1338 | } | 1007 | } |
| 1339 | | 1008 | |
| 1340 | const ResultUsed = enum { | 1009 | const ResultUsed = enum { |
| ... | @@ -1342,317 +1011,252 @@ const ResultUsed = enum { | ... | @@ -1342,317 +1011,252 @@ const ResultUsed = enum { |
| 1342 | unused, | 1011 | unused, |
| 1343 | }; | 1012 | }; |
| 1344 | | 1013 | |
| 1345 | const LRValue = enum { | | |
| 1346 | l_value, | | |
| 1347 | r_value, | | |
| 1348 | }; | | |
| 1349 | | | |
| 1350 | fn transStmt( | 1014 | fn transStmt( |
| 1351 | rp: RestorePoint, | 1015 | c: *Context, |
| 1352 | scope: *Scope, | 1016 | scope: *Scope, |
| 1353 | stmt: *const clang.Stmt, | 1017 | stmt: *const clang.Stmt, |
| 1354 | result_used: ResultUsed, | 1018 | result_used: ResultUsed, |
| 1355 | lrvalue: LRValue, | 1019 | ) TransError!Node { |
| 1356 | ) TransError!*ast.Node { | | |
| 1357 | const sc = stmt.getStmtClass(); | 1020 | const sc = stmt.getStmtClass(); |
| 1358 | switch (sc) { | 1021 | switch (sc) { |
| 1359 | .BinaryOperatorClass => return transBinaryOperator(rp, scope, @ptrCast(*const clang.BinaryOperator, stmt), result_used), | 1022 | .BinaryOperatorClass => return transBinaryOperator(c, scope, @ptrCast(*const clang.BinaryOperator, stmt), result_used), |
| 1360 | .CompoundStmtClass => return transCompoundStmt(rp, scope, @ptrCast(*const clang.CompoundStmt, stmt)), | 1023 | .CompoundStmtClass => return transCompoundStmt(c, scope, @ptrCast(*const clang.CompoundStmt, stmt)), |
| 1361 | .CStyleCastExprClass => return transCStyleCastExprClass(rp, scope, @ptrCast(*const clang.CStyleCastExpr, stmt), result_used, lrvalue), | 1024 | .CStyleCastExprClass => return transCStyleCastExprClass(c, scope, @ptrCast(*const clang.CStyleCastExpr, stmt), result_used), |
| 1362 | .DeclStmtClass => return transDeclStmt(rp, scope, @ptrCast(*const clang.DeclStmt, stmt)), | 1025 | .DeclStmtClass => return transDeclStmt(c, scope, @ptrCast(*const clang.DeclStmt, stmt)), |
| 1363 | .DeclRefExprClass => return transDeclRefExpr(rp, scope, @ptrCast(*const clang.DeclRefExpr, stmt), lrvalue), | 1026 | .DeclRefExprClass => return transDeclRefExpr(c, scope, @ptrCast(*const clang.DeclRefExpr, stmt)), |
| 1364 | .ImplicitCastExprClass => return transImplicitCastExpr(rp, scope, @ptrCast(*const clang.ImplicitCastExpr, stmt), result_used), | 1027 | .ImplicitCastExprClass => return transImplicitCastExpr(c, scope, @ptrCast(*const clang.ImplicitCastExpr, stmt), result_used), |
| 1365 | .IntegerLiteralClass => return transIntegerLiteral(rp, scope, @ptrCast(*const clang.IntegerLiteral, stmt), result_used, .with_as), | 1028 | .IntegerLiteralClass => return transIntegerLiteral(c, scope, @ptrCast(*const clang.IntegerLiteral, stmt), result_used, .with_as), |
| 1366 | .ReturnStmtClass => return transReturnStmt(rp, scope, @ptrCast(*const clang.ReturnStmt, stmt)), | 1029 | .ReturnStmtClass => return transReturnStmt(c, scope, @ptrCast(*const clang.ReturnStmt, stmt)), |
| 1367 | .StringLiteralClass => return transStringLiteral(rp, scope, @ptrCast(*const clang.StringLiteral, stmt), result_used), | 1030 | .StringLiteralClass => return transStringLiteral(c, scope, @ptrCast(*const clang.StringLiteral, stmt), result_used), |
| 1368 | .ParenExprClass => { | 1031 | .ParenExprClass => { |
| 1369 | const expr = try transExpr(rp, scope, @ptrCast(*const clang.ParenExpr, stmt).getSubExpr(), .used, lrvalue); | 1032 | const expr = try transExpr(c, scope, @ptrCast(*const clang.ParenExpr, stmt).getSubExpr(), .used); |
| 1370 | if (expr.tag == .GroupedExpression) return maybeSuppressResult(rp, scope, result_used, expr); | 1033 | return maybeSuppressResult(c, scope, result_used, expr); |
| 1371 | const node = try rp.c.arena.create(ast.Node.GroupedExpression); | 1034 | }, |
| 1372 | node.* = .{ | 1035 | .InitListExprClass => return transInitListExpr(c, scope, @ptrCast(*const clang.InitListExpr, stmt), result_used), |
| 1373 | .lparen = try appendToken(rp.c, .LParen, "("), | 1036 | .ImplicitValueInitExprClass => return transImplicitValueInitExpr(c, scope, @ptrCast(*const clang.Expr, stmt), result_used), |
| 1374 | .expr = expr, | 1037 | .IfStmtClass => return transIfStmt(c, scope, @ptrCast(*const clang.IfStmt, stmt)), |
| 1375 | .rparen = try appendToken(rp.c, .RParen, ")"), | 1038 | .WhileStmtClass => return transWhileLoop(c, scope, @ptrCast(*const clang.WhileStmt, stmt)), |
| 1376 | }; | 1039 | .DoStmtClass => return transDoWhileLoop(c, scope, @ptrCast(*const clang.DoStmt, stmt)), |
| 1377 | return maybeSuppressResult(rp, scope, result_used, &node.base); | | |
| 1378 | }, | | |
| 1379 | .InitListExprClass => return transInitListExpr(rp, scope, @ptrCast(*const clang.InitListExpr, stmt), result_used), | | |
| 1380 | .ImplicitValueInitExprClass => return transImplicitValueInitExpr(rp, scope, @ptrCast(*const clang.Expr, stmt), result_used), | | |
| 1381 | .IfStmtClass => return transIfStmt(rp, scope, @ptrCast(*const clang.IfStmt, stmt)), | | |
| 1382 | .WhileStmtClass => return transWhileLoop(rp, scope, @ptrCast(*const clang.WhileStmt, stmt)), | | |
| 1383 | .DoStmtClass => return transDoWhileLoop(rp, scope, @ptrCast(*const clang.DoStmt, stmt)), | | |
| 1384 | .NullStmtClass => { | 1040 | .NullStmtClass => { |
| 1385 | const block = try rp.c.createBlock(0); | 1041 | return Tag.empty_block.init(); |
| 1386 | block.rbrace = try appendToken(rp.c, .RBrace, "}"); | 1042 | }, |
| 1387 | return &block.base; | 1043 | .ContinueStmtClass => return Tag.@"continue".init(), |
| 1388 | }, | 1044 | .BreakStmtClass => return Tag.@"break".init(), |
| 1389 | .ContinueStmtClass => return try transCreateNodeContinue(rp.c), | 1045 | .ForStmtClass => return transForLoop(c, scope, @ptrCast(*const clang.ForStmt, stmt)), |
| 1390 | .BreakStmtClass => return transBreak(rp, scope), | 1046 | .FloatingLiteralClass => return transFloatingLiteral(c, scope, @ptrCast(*const clang.FloatingLiteral, stmt), result_used), |
| 1391 | .ForStmtClass => return transForLoop(rp, scope, @ptrCast(*const clang.ForStmt, stmt)), | | |
| 1392 | .FloatingLiteralClass => return transFloatingLiteral(rp, scope, @ptrCast(*const clang.FloatingLiteral, stmt), result_used), | | |
| 1393 | .ConditionalOperatorClass => { | 1047 | .ConditionalOperatorClass => { |
| 1394 | return transConditionalOperator(rp, scope, @ptrCast(*const clang.ConditionalOperator, stmt), result_used); | 1048 | return transConditionalOperator(c, scope, @ptrCast(*const clang.ConditionalOperator, stmt), result_used); |
| 1395 | }, | 1049 | }, |
| 1396 | .BinaryConditionalOperatorClass => { | 1050 | .BinaryConditionalOperatorClass => { |
| 1397 | return transBinaryConditionalOperator(rp, scope, @ptrCast(*const clang.BinaryConditionalOperator, stmt), result_used); | 1051 | return transBinaryConditionalOperator(c, scope, @ptrCast(*const clang.BinaryConditionalOperator, stmt), result_used); |
| 1398 | }, | 1052 | }, |
| 1399 | .SwitchStmtClass => return transSwitch(rp, scope, @ptrCast(*const clang.SwitchStmt, stmt)), | 1053 | .SwitchStmtClass => return transSwitch(c, scope, @ptrCast(*const clang.SwitchStmt, stmt)), |
| 1400 | .CaseStmtClass => return transCase(rp, scope, @ptrCast(*const clang.CaseStmt, stmt)), | 1054 | .CaseStmtClass, .DefaultStmtClass => { |
| 1401 | .DefaultStmtClass => return transDefault(rp, scope, @ptrCast(*const clang.DefaultStmt, stmt)), | 1055 | return fail(c, error.UnsupportedTranslation, stmt.getBeginLoc(), "TODO complex switch", .{}); |
| 1402 | .ConstantExprClass => return transConstantExpr(rp, scope, @ptrCast(*const clang.Expr, stmt), result_used), | 1056 | }, |
| 1403 | .PredefinedExprClass => return transPredefinedExpr(rp, scope, @ptrCast(*const clang.PredefinedExpr, stmt), result_used), | 1057 | .ConstantExprClass => return transConstantExpr(c, scope, @ptrCast(*const clang.Expr, stmt), result_used), |
| 1404 | .CharacterLiteralClass => return transCharLiteral(rp, scope, @ptrCast(*const clang.CharacterLiteral, stmt), result_used, .with_as), | 1058 | .PredefinedExprClass => return transPredefinedExpr(c, scope, @ptrCast(*const clang.PredefinedExpr, stmt), result_used), |
| 1405 | .StmtExprClass => return transStmtExpr(rp, scope, @ptrCast(*const clang.StmtExpr, stmt), result_used), | 1059 | .CharacterLiteralClass => return transCharLiteral(c, scope, @ptrCast(*const clang.CharacterLiteral, stmt), result_used, .with_as), |
| 1406 | .MemberExprClass => return transMemberExpr(rp, scope, @ptrCast(*const clang.MemberExpr, stmt), result_used), | 1060 | .StmtExprClass => return transStmtExpr(c, scope, @ptrCast(*const clang.StmtExpr, stmt), result_used), |
| 1407 | .ArraySubscriptExprClass => return transArrayAccess(rp, scope, @ptrCast(*const clang.ArraySubscriptExpr, stmt), result_used), | 1061 | .MemberExprClass => return transMemberExpr(c, scope, @ptrCast(*const clang.MemberExpr, stmt), result_used), |
| 1408 | .CallExprClass => return transCallExpr(rp, scope, @ptrCast(*const clang.CallExpr, stmt), result_used), | 1062 | .ArraySubscriptExprClass => return transArrayAccess(c, scope, @ptrCast(*const clang.ArraySubscriptExpr, stmt), result_used), |
| 1409 | .UnaryExprOrTypeTraitExprClass => return transUnaryExprOrTypeTraitExpr(rp, scope, @ptrCast(*const clang.UnaryExprOrTypeTraitExpr, stmt), result_used), | 1063 | .CallExprClass => return transCallExpr(c, scope, @ptrCast(*const clang.CallExpr, stmt), result_used), |
| 1410 | .UnaryOperatorClass => return transUnaryOperator(rp, scope, @ptrCast(*const clang.UnaryOperator, stmt), result_used), | 1064 | .UnaryExprOrTypeTraitExprClass => return transUnaryExprOrTypeTraitExpr(c, scope, @ptrCast(*const clang.UnaryExprOrTypeTraitExpr, stmt), result_used), |
| 1411 | .CompoundAssignOperatorClass => return transCompoundAssignOperator(rp, scope, @ptrCast(*const clang.CompoundAssignOperator, stmt), result_used), | 1065 | .UnaryOperatorClass => return transUnaryOperator(c, scope, @ptrCast(*const clang.UnaryOperator, stmt), result_used), |
| | 1066 | .CompoundAssignOperatorClass => return transCompoundAssignOperator(c, scope, @ptrCast(*const clang.CompoundAssignOperator, stmt), result_used), |
| 1412 | .OpaqueValueExprClass => { | 1067 | .OpaqueValueExprClass => { |
| 1413 | const source_expr = @ptrCast(*const clang.OpaqueValueExpr, stmt).getSourceExpr().?; | 1068 | const source_expr = @ptrCast(*const clang.OpaqueValueExpr, stmt).getSourceExpr().?; |
| 1414 | const expr = try transExpr(rp, scope, source_expr, .used, lrvalue); | 1069 | const expr = try transExpr(c, scope, source_expr, .used); |
| 1415 | if (expr.tag == .GroupedExpression) return maybeSuppressResult(rp, scope, result_used, expr); | 1070 | return maybeSuppressResult(c, scope, result_used, expr); |
| 1416 | const node = try rp.c.arena.create(ast.Node.GroupedExpression); | | |
| 1417 | node.* = .{ | | |
| 1418 | .lparen = try appendToken(rp.c, .LParen, "("), | | |
| 1419 | .expr = expr, | | |
| 1420 | .rparen = try appendToken(rp.c, .RParen, ")"), | | |
| 1421 | }; | | |
| 1422 | return maybeSuppressResult(rp, scope, result_used, &node.base); | | |
| 1423 | }, | 1071 | }, |
| 1424 | else => { | 1072 | else => { |
| 1425 | return revertAndWarn( | 1073 | return fail(c, error.UnsupportedTranslation, stmt.getBeginLoc(), "TODO implement translation of stmt class {s}", .{@tagName(sc)}); |
| 1426 | rp, | | |
| 1427 | error.UnsupportedTranslation, | | |
| 1428 | stmt.getBeginLoc(), | | |
| 1429 | "TODO implement translation of stmt class {s}", | | |
| 1430 | .{@tagName(sc)}, | | |
| 1431 | ); | | |
| 1432 | }, | 1074 | }, |
| 1433 | } | 1075 | } |
| 1434 | } | 1076 | } |
| 1435 | | 1077 | |
| 1436 | fn transBinaryOperator( | 1078 | fn transBinaryOperator( |
| 1437 | rp: RestorePoint, | 1079 | c: *Context, |
| 1438 | scope: *Scope, | 1080 | scope: *Scope, |
| 1439 | stmt: *const clang.BinaryOperator, | 1081 | stmt: *const clang.BinaryOperator, |
| 1440 | result_used: ResultUsed, | 1082 | result_used: ResultUsed, |
| 1441 | ) TransError!*ast.Node { | 1083 | ) TransError!Node { |
| 1442 | const op = stmt.getOpcode(); | 1084 | const op = stmt.getOpcode(); |
| 1443 | const qt = stmt.getType(); | 1085 | const qt = stmt.getType(); |
| 1444 | var op_token: ast.TokenIndex = undefined; | | |
| 1445 | var op_id: ast.Node.Tag = undefined; | | |
| 1446 | switch (op) { | 1086 | switch (op) { |
| 1447 | .Assign => return try transCreateNodeAssign(rp, scope, result_used, stmt.getLHS(), stmt.getRHS()), | 1087 | .Assign => return try transCreateNodeAssign(c, scope, result_used, stmt.getLHS(), stmt.getRHS()), |
| 1448 | .Comma => { | 1088 | .Comma => { |
| 1449 | var block_scope = try Scope.Block.init(rp.c, scope, true); | 1089 | var block_scope = try Scope.Block.init(c, scope, true); |
| 1450 | const lparen = try appendToken(rp.c, .LParen, "("); | 1090 | defer block_scope.deinit(); |
| 1451 | | 1091 | |
| 1452 | const lhs = try transExpr(rp, &block_scope.base, stmt.getLHS(), .unused, .r_value); | 1092 | const lhs = try transExpr(c, &block_scope.base, stmt.getLHS(), .unused); |
| 1453 | try block_scope.statements.append(lhs); | 1093 | try block_scope.statements.append(lhs); |
| 1454 | | 1094 | |
| 1455 | const rhs = try transExpr(rp, &block_scope.base, stmt.getRHS(), .used, .r_value); | 1095 | const rhs = try transExpr(c, &block_scope.base, stmt.getRHS(), .used); |
| 1456 | _ = try appendToken(rp.c, .Semicolon, ";"); | 1096 | const break_node = try Tag.break_val.create(c.arena, .{ |
| 1457 | const break_node = try transCreateNodeBreak(rp.c, block_scope.label, rhs); | 1097 | .label = block_scope.label, |
| 1458 | try block_scope.statements.append(&break_node.base); | 1098 | .val = rhs, |
| 1459 | const block_node = try block_scope.complete(rp.c); | 1099 | }); |
| 1460 | const rparen = try appendToken(rp.c, .RParen, ")"); | 1100 | try block_scope.statements.append(break_node); |
| 1461 | const grouped_expr = try rp.c.arena.create(ast.Node.GroupedExpression); | 1101 | const block_node = try block_scope.complete(c); |
| 1462 | grouped_expr.* = .{ | 1102 | return maybeSuppressResult(c, scope, result_used, block_node); |
| 1463 | .lparen = lparen, | | |
| 1464 | .expr = block_node, | | |
| 1465 | .rparen = rparen, | | |
| 1466 | }; | | |
| 1467 | return maybeSuppressResult(rp, scope, result_used, &grouped_expr.base); | | |
| 1468 | }, | 1103 | }, |
| 1469 | .Div => { | 1104 | .Div => { |
| 1470 | if (cIsSignedInteger(qt)) { | 1105 | if (cIsSignedInteger(qt)) { |
| 1471 | // signed integer division uses @divTrunc | 1106 | // signed integer division uses @divTrunc |
| 1472 | const div_trunc_node = try rp.c.createBuiltinCall("@divTrunc", 2); | 1107 | const lhs = try transExpr(c, scope, stmt.getLHS(), .used); |
| 1473 | div_trunc_node.params()[0] = try transExpr(rp, scope, stmt.getLHS(), .used, .l_value); | 1108 | const rhs = try transExpr(c, scope, stmt.getRHS(), .used); |
| 1474 | _ = try appendToken(rp.c, .Comma, ","); | 1109 | const div_trunc = try Tag.div_trunc.create(c.arena, .{ .lhs = lhs, .rhs = rhs }); |
| 1475 | const rhs = try transExpr(rp, scope, stmt.getRHS(), .used, .r_value); | 1110 | return maybeSuppressResult(c, scope, result_used, div_trunc); |
| 1476 | div_trunc_node.params()[1] = rhs; | | |
| 1477 | div_trunc_node.rparen_token = try appendToken(rp.c, .RParen, ")"); | | |
| 1478 | return maybeSuppressResult(rp, scope, result_used, &div_trunc_node.base); | | |
| 1479 | } | 1111 | } |
| 1480 | }, | 1112 | }, |
| 1481 | .Rem => { | 1113 | .Rem => { |
| 1482 | if (cIsSignedInteger(qt)) { | 1114 | if (cIsSignedInteger(qt)) { |
| 1483 | // signed integer division uses @rem | 1115 | // signed integer division uses @rem |
| 1484 | const rem_node = try rp.c.createBuiltinCall("@rem", 2); | 1116 | const lhs = try transExpr(c, scope, stmt.getLHS(), .used); |
| 1485 | rem_node.params()[0] = try transExpr(rp, scope, stmt.getLHS(), .used, .l_value); | 1117 | const rhs = try transExpr(c, scope, stmt.getRHS(), .used); |
| 1486 | _ = try appendToken(rp.c, .Comma, ","); | 1118 | const rem = try Tag.rem.create(c.arena, .{ .lhs = lhs, .rhs = rhs }); |
| 1487 | const rhs = try transExpr(rp, scope, stmt.getRHS(), .used, .r_value); | 1119 | return maybeSuppressResult(c, scope, result_used, rem); |
| 1488 | rem_node.params()[1] = rhs; | | |
| 1489 | rem_node.rparen_token = try appendToken(rp.c, .RParen, ")"); | | |
| 1490 | return maybeSuppressResult(rp, scope, result_used, &rem_node.base); | | |
| 1491 | } | 1120 | } |
| 1492 | }, | 1121 | }, |
| 1493 | .Shl => { | 1122 | .Shl => { |
| 1494 | const node = try transCreateNodeShiftOp(rp, scope, stmt, .BitShiftLeft, .AngleBracketAngleBracketLeft, "<<"); | 1123 | return transCreateNodeShiftOp(c, scope, stmt, .shl, result_used); |
| 1495 | return maybeSuppressResult(rp, scope, result_used, node); | | |
| 1496 | }, | 1124 | }, |
| 1497 | .Shr => { | 1125 | .Shr => { |
| 1498 | const node = try transCreateNodeShiftOp(rp, scope, stmt, .BitShiftRight, .AngleBracketAngleBracketRight, ">>"); | 1126 | return transCreateNodeShiftOp(c, scope, stmt, .shr, result_used); |
| 1499 | return maybeSuppressResult(rp, scope, result_used, node); | | |
| 1500 | }, | 1127 | }, |
| 1501 | .LAnd => { | 1128 | .LAnd => { |
| 1502 | const node = try transCreateNodeBoolInfixOp(rp, scope, stmt, .BoolAnd, result_used, true); | 1129 | return transCreateNodeBoolInfixOp(c, scope, stmt, .@"and", result_used); |
| 1503 | return maybeSuppressResult(rp, scope, result_used, node); | | |
| 1504 | }, | 1130 | }, |
| 1505 | .LOr => { | 1131 | .LOr => { |
| 1506 | const node = try transCreateNodeBoolInfixOp(rp, scope, stmt, .BoolOr, result_used, true); | 1132 | return transCreateNodeBoolInfixOp(c, scope, stmt, .@"or", result_used); |
| 1507 | return maybeSuppressResult(rp, scope, result_used, node); | | |
| 1508 | }, | 1133 | }, |
| 1509 | else => {}, | 1134 | else => {}, |
| 1510 | } | 1135 | } |
| 1511 | const lhs_node = try transExpr(rp, scope, stmt.getLHS(), .used, .l_value); | 1136 | var op_id: Tag = undefined; |
| 1512 | switch (op) { | 1137 | switch (op) { |
| 1513 | .Add => { | 1138 | .Add => { |
| 1514 | if (cIsUnsignedInteger(qt)) { | 1139 | if (cIsUnsignedInteger(qt)) { |
| 1515 | op_token = try appendToken(rp.c, .PlusPercent, "+%"); | 1140 | op_id = .add_wrap; |
| 1516 | op_id = .AddWrap; | | |
| 1517 | } else { | 1141 | } else { |
| 1518 | op_token = try appendToken(rp.c, .Plus, "+"); | 1142 | op_id = .add; |
| 1519 | op_id = .Add; | | |
| 1520 | } | 1143 | } |
| 1521 | }, | 1144 | }, |
| 1522 | .Sub => { | 1145 | .Sub => { |
| 1523 | if (cIsUnsignedInteger(qt)) { | 1146 | if (cIsUnsignedInteger(qt)) { |
| 1524 | op_token = try appendToken(rp.c, .MinusPercent, "-%"); | 1147 | op_id = .sub_wrap; |
| 1525 | op_id = .SubWrap; | | |
| 1526 | } else { | 1148 | } else { |
| 1527 | op_token = try appendToken(rp.c, .Minus, "-"); | 1149 | op_id = .sub; |
| 1528 | op_id = .Sub; | | |
| 1529 | } | 1150 | } |
| 1530 | }, | 1151 | }, |
| 1531 | .Mul => { | 1152 | .Mul => { |
| 1532 | if (cIsUnsignedInteger(qt)) { | 1153 | if (cIsUnsignedInteger(qt)) { |
| 1533 | op_token = try appendToken(rp.c, .AsteriskPercent, "*%"); | 1154 | op_id = .mul_wrap; |
| 1534 | op_id = .MulWrap; | | |
| 1535 | } else { | 1155 | } else { |
| 1536 | op_token = try appendToken(rp.c, .Asterisk, "*"); | 1156 | op_id = .mul; |
| 1537 | op_id = .Mul; | | |
| 1538 | } | 1157 | } |
| 1539 | }, | 1158 | }, |
| 1540 | .Div => { | 1159 | .Div => { |
| 1541 | // unsigned/float division uses the operator | 1160 | // unsigned/float division uses the operator |
| 1542 | op_id = .Div; | 1161 | op_id = .div; |
| 1543 | op_token = try appendToken(rp.c, .Slash, "/"); | | |
| 1544 | }, | 1162 | }, |
| 1545 | .Rem => { | 1163 | .Rem => { |
| 1546 | // unsigned/float division uses the operator | 1164 | // unsigned/float division uses the operator |
| 1547 | op_id = .Mod; | 1165 | op_id = .mod; |
| 1548 | op_token = try appendToken(rp.c, .Percent, "%"); | | |
| 1549 | }, | 1166 | }, |
| 1550 | .LT => { | 1167 | .LT => { |
| 1551 | op_id = .LessThan; | 1168 | op_id = .less_than; |
| 1552 | op_token = try appendToken(rp.c, .AngleBracketLeft, "<"); | | |
| 1553 | }, | 1169 | }, |
| 1554 | .GT => { | 1170 | .GT => { |
| 1555 | op_id = .GreaterThan; | 1171 | op_id = .greater_than; |
| 1556 | op_token = try appendToken(rp.c, .AngleBracketRight, ">"); | | |
| 1557 | }, | 1172 | }, |
| 1558 | .LE => { | 1173 | .LE => { |
| 1559 | op_id = .LessOrEqual; | 1174 | op_id = .less_than_equal; |
| 1560 | op_token = try appendToken(rp.c, .AngleBracketLeftEqual, "<="); | | |
| 1561 | }, | 1175 | }, |
| 1562 | .GE => { | 1176 | .GE => { |
| 1563 | op_id = .GreaterOrEqual; | 1177 | op_id = .greater_than_equal; |
| 1564 | op_token = try appendToken(rp.c, .AngleBracketRightEqual, ">="); | | |
| 1565 | }, | 1178 | }, |
| 1566 | .EQ => { | 1179 | .EQ => { |
| 1567 | op_id = .EqualEqual; | 1180 | op_id = .equal; |
| 1568 | op_token = try appendToken(rp.c, .EqualEqual, "=="); | | |
| 1569 | }, | 1181 | }, |
| 1570 | .NE => { | 1182 | .NE => { |
| 1571 | op_id = .BangEqual; | 1183 | op_id = .not_equal; |
| 1572 | op_token = try appendToken(rp.c, .BangEqual, "!="); | | |
| 1573 | }, | 1184 | }, |
| 1574 | .And => { | 1185 | .And => { |
| 1575 | op_id = .BitAnd; | 1186 | op_id = .bit_and; |
| 1576 | op_token = try appendToken(rp.c, .Ampersand, "&"); | | |
| 1577 | }, | 1187 | }, |
| 1578 | .Xor => { | 1188 | .Xor => { |
| 1579 | op_id = .BitXor; | 1189 | op_id = .bit_xor; |
| 1580 | op_token = try appendToken(rp.c, .Caret, "^"); | | |
| 1581 | }, | 1190 | }, |
| 1582 | .Or => { | 1191 | .Or => { |
| 1583 | op_id = .BitOr; | 1192 | op_id = .bit_or; |
| 1584 | op_token = try appendToken(rp.c, .Pipe, "|"); | | |
| 1585 | }, | 1193 | }, |
| 1586 | else => unreachable, | 1194 | else => unreachable, |
| 1587 | } | 1195 | } |
| 1588 | | 1196 | |
| 1589 | const rhs_node = try transExpr(rp, scope, stmt.getRHS(), .used, .r_value); | 1197 | const lhs_uncasted = try transExpr(c, scope, stmt.getLHS(), .used); |
| | 1198 | const rhs_uncasted = try transExpr(c, scope, stmt.getRHS(), .used); |
| 1590 | | 1199 | |
| 1591 | const lhs = if (isBoolRes(lhs_node)) init: { | 1200 | const lhs = if (isBoolRes(lhs_uncasted)) |
| 1592 | const cast_node = try rp.c.createBuiltinCall("@boolToInt", 1); | 1201 | try Tag.bool_to_int.create(c.arena, lhs_uncasted) |
| 1593 | cast_node.params()[0] = lhs_node; | 1202 | else |
| 1594 | cast_node.rparen_token = try appendToken(rp.c, .RParen, ")"); | 1203 | lhs_uncasted; |
| 1595 | break :init &cast_node.base; | | |
| 1596 | } else lhs_node; | | |
| 1597 | | 1204 | |
| 1598 | const rhs = if (isBoolRes(rhs_node)) init: { | 1205 | const rhs = if (isBoolRes(rhs_uncasted)) |
| 1599 | const cast_node = try rp.c.createBuiltinCall("@boolToInt", 1); | 1206 | try Tag.bool_to_int.create(c.arena, rhs_uncasted) |
| 1600 | cast_node.params()[0] = rhs_node; | 1207 | else |
| 1601 | cast_node.rparen_token = try appendToken(rp.c, .RParen, ")"); | 1208 | rhs_uncasted; |
| 1602 | break :init &cast_node.base; | | |
| 1603 | } else rhs_node; | | |
| 1604 | | 1209 | |
| 1605 | return transCreateNodeInfixOp(rp, scope, lhs, op_id, op_token, rhs, result_used, true); | 1210 | return transCreateNodeInfixOp(c, scope, op_id, lhs, rhs, result_used); |
| 1606 | } | 1211 | } |
| 1607 | | 1212 | |
| 1608 | fn transCompoundStmtInline( | 1213 | fn transCompoundStmtInline( |
| 1609 | rp: RestorePoint, | 1214 | c: *Context, |
| 1610 | parent_scope: *Scope, | | |
| 1611 | stmt: *const clang.CompoundStmt, | 1215 | stmt: *const clang.CompoundStmt, |
| 1612 | block: *Scope.Block, | 1216 | block: *Scope.Block, |
| 1613 | ) TransError!void { | 1217 | ) TransError!void { |
| 1614 | var it = stmt.body_begin(); | 1218 | var it = stmt.body_begin(); |
| 1615 | const end_it = stmt.body_end(); | 1219 | const end_it = stmt.body_end(); |
| 1616 | while (it != end_it) : (it += 1) { | 1220 | while (it != end_it) : (it += 1) { |
| 1617 | const result = try transStmt(rp, parent_scope, it[0], .unused, .r_value); | 1221 | const result = try transStmt(c, &block.base, it[0], .unused); |
| 1618 | try block.statements.append(result); | 1222 | switch (result.tag()) { |
| | 1223 | .declaration, .empty_block => {}, |
| | 1224 | else => try block.statements.append(result), |
| | 1225 | } |
| 1619 | } | 1226 | } |
| 1620 | } | 1227 | } |
| 1621 | | 1228 | |
| 1622 | fn transCompoundStmt(rp: RestorePoint, scope: *Scope, stmt: *const clang.CompoundStmt) TransError!*ast.Node { | 1229 | fn transCompoundStmt(c: *Context, scope: *Scope, stmt: *const clang.CompoundStmt) TransError!Node { |
| 1623 | var block_scope = try Scope.Block.init(rp.c, scope, false); | 1230 | var block_scope = try Scope.Block.init(c, scope, false); |
| 1624 | defer block_scope.deinit(); | 1231 | defer block_scope.deinit(); |
| 1625 | try transCompoundStmtInline(rp, &block_scope.base, stmt, &block_scope); | 1232 | try transCompoundStmtInline(c, stmt, &block_scope); |
| 1626 | return try block_scope.complete(rp.c); | 1233 | return try block_scope.complete(c); |
| 1627 | } | 1234 | } |
| 1628 | | 1235 | |
| 1629 | fn transCStyleCastExprClass( | 1236 | fn transCStyleCastExprClass( |
| 1630 | rp: RestorePoint, | 1237 | c: *Context, |
| 1631 | scope: *Scope, | 1238 | scope: *Scope, |
| 1632 | stmt: *const clang.CStyleCastExpr, | 1239 | stmt: *const clang.CStyleCastExpr, |
| 1633 | result_used: ResultUsed, | 1240 | result_used: ResultUsed, |
| 1634 | lrvalue: LRValue, | 1241 | ) TransError!Node { |
| 1635 | ) TransError!*ast.Node { | | |
| 1636 | const sub_expr = stmt.getSubExpr(); | 1242 | const sub_expr = stmt.getSubExpr(); |
| 1637 | const cast_node = (try transCCast( | 1243 | const cast_node = (try transCCast( |
| 1638 | rp, | 1244 | c, |
| 1639 | scope, | 1245 | scope, |
| 1640 | stmt.getBeginLoc(), | 1246 | stmt.getBeginLoc(), |
| 1641 | stmt.getType(), | 1247 | stmt.getType(), |
| 1642 | sub_expr.getType(), | 1248 | sub_expr.getType(), |
| 1643 | try transExpr(rp, scope, sub_expr, .used, lrvalue), | 1249 | try transExpr(c, scope, sub_expr, .used), |
| 1644 | )); | 1250 | )); |
| 1645 | return maybeSuppressResult(rp, scope, result_used, cast_node); | 1251 | return maybeSuppressResult(c, scope, result_used, cast_node); |
| 1646 | } | 1252 | } |
| 1647 | | 1253 | |
| 1648 | fn transDeclStmtOne( | 1254 | fn transDeclStmtOne( |
| 1649 | rp: RestorePoint, | 1255 | c: *Context, |
| 1650 | scope: *Scope, | 1256 | scope: *Scope, |
| 1651 | decl: *const clang.Decl, | 1257 | decl: *const clang.Decl, |
| 1652 | block_scope: *Scope.Block, | 1258 | block_scope: *Scope.Block, |
| 1653 | ) TransError!*ast.Node { | 1259 | ) TransError!void { |
| 1654 | const c = rp.c; | | |
| 1655 | | | |
| 1656 | switch (decl.getKind()) { | 1260 | switch (decl.getKind()) { |
| 1657 | .Var => { | 1261 | .Var => { |
| 1658 | const var_decl = @ptrCast(*const clang.VarDecl, decl); | 1262 | const var_decl = @ptrCast(*const clang.VarDecl, decl); |
| ... | @@ -1666,62 +1270,51 @@ fn transDeclStmtOne( | ... | @@ -1666,62 +1270,51 @@ fn transDeclStmtOne( |
| 1666 | .Extern, .Static => { | 1270 | .Extern, .Static => { |
| 1667 | // This is actually a global variable, put it in the global scope and reference it. | 1271 | // This is actually a global variable, put it in the global scope and reference it. |
| 1668 | // `_ = mangled_name;` | 1272 | // `_ = mangled_name;` |
| 1669 | try visitVarDecl(rp.c, var_decl, mangled_name); | 1273 | return visitVarDecl(c, var_decl, mangled_name); |
| 1670 | return try maybeSuppressResult(rp, scope, .unused, try transCreateNodeIdentifier(rp.c, mangled_name)); | | |
| 1671 | }, | 1274 | }, |
| 1672 | else => {}, | 1275 | else => {}, |
| 1673 | } | 1276 | } |
| 1674 | | 1277 | |
| 1675 | const mut_tok = if (qual_type.isConstQualified()) | 1278 | const is_const = qual_type.isConstQualified(); |
| 1676 | try appendToken(c, .Keyword_const, "const") | | |
| 1677 | else | | |
| 1678 | try appendToken(c, .Keyword_var, "var"); | | |
| 1679 | const name_tok = try appendIdentifier(c, mangled_name); | | |
| 1680 | | 1279 | |
| 1681 | _ = try appendToken(c, .Colon, ":"); | | |
| 1682 | const loc = decl.getLocation(); | 1280 | const loc = decl.getLocation(); |
| 1683 | const type_node = try transQualTypeMaybeInitialized(rp, qual_type, decl_init, loc); | 1281 | const type_node = try transQualTypeMaybeInitialized(c, scope, qual_type, decl_init, loc); |
| 1684 | | 1282 | |
| 1685 | const eq_token = try appendToken(c, .Equal, "="); | | |
| 1686 | var init_node = if (decl_init) |expr| | 1283 | var init_node = if (decl_init) |expr| |
| 1687 | if (expr.getStmtClass() == .StringLiteralClass) | 1284 | if (expr.getStmtClass() == .StringLiteralClass) |
| 1688 | try transStringLiteralAsArray(rp, scope, @ptrCast(*const clang.StringLiteral, expr), try zigArraySize(rp.c, type_node)) | 1285 | try transStringLiteralAsArray(c, scope, @ptrCast(*const clang.StringLiteral, expr), try zigArraySize(c, type_node)) |
| 1689 | else | 1286 | else |
| 1690 | try transExprCoercing(rp, scope, expr, .used, .r_value) | 1287 | try transExprCoercing(c, scope, expr, .used) |
| 1691 | else | 1288 | else |
| 1692 | try transCreateNodeUndefinedLiteral(c); | 1289 | Tag.undefined_literal.init(); |
| 1693 | if (!qualTypeIsBoolean(qual_type) and isBoolRes(init_node)) { | 1290 | if (!qualTypeIsBoolean(qual_type) and isBoolRes(init_node)) { |
| 1694 | const builtin_node = try rp.c.createBuiltinCall("@boolToInt", 1); | 1291 | init_node = try Tag.bool_to_int.create(c.arena, init_node); |
| 1695 | builtin_node.params()[0] = init_node; | | |
| 1696 | builtin_node.rparen_token = try appendToken(rp.c, .RParen, ")"); | | |
| 1697 | init_node = &builtin_node.base; | | |
| 1698 | } | 1292 | } |
| 1699 | const semicolon_token = try appendToken(c, .Semicolon, ";"); | 1293 | const node = try Tag.var_decl.create(c.arena, .{ |
| 1700 | const node = try ast.Node.VarDecl.create(c.arena, .{ | 1294 | .is_pub = false, |
| 1701 | .name_token = name_tok, | 1295 | .is_const = is_const, |
| 1702 | .mut_token = mut_tok, | 1296 | .is_extern = false, |
| 1703 | .semicolon_token = semicolon_token, | 1297 | .is_export = false, |
| 1704 | }, .{ | 1298 | .is_threadlocal = false, |
| 1705 | .eq_token = eq_token, | 1299 | .linksection_string = null, |
| 1706 | .type_node = type_node, | 1300 | .alignment = null, |
| 1707 | .init_node = init_node, | 1301 | .name = mangled_name, |
| | 1302 | .type = type_node, |
| | 1303 | .init = init_node, |
| 1708 | }); | 1304 | }); |
| 1709 | return &node.base; | 1305 | try block_scope.statements.append(node); |
| 1710 | }, | 1306 | }, |
| 1711 | .Typedef => { | 1307 | .Typedef => { |
| 1712 | const typedef_decl = @ptrCast(*const clang.TypedefNameDecl, decl); | 1308 | try transTypeDef(c, scope, @ptrCast(*const clang.TypedefNameDecl, decl)); |
| 1713 | const name = try c.str(@ptrCast(*const clang.NamedDecl, typedef_decl).getName_bytes_begin()); | 1309 | }, |
| 1714 | | 1310 | .Record => { |
| 1715 | const underlying_qual = typedef_decl.getUnderlyingType(); | 1311 | try transRecordDecl(c, scope, @ptrCast(*const clang.RecordDecl, decl)); |
| 1716 | const underlying_type = underlying_qual.getTypePtr(); | 1312 | }, |
| 1717 | | 1313 | .Enum => { |
| 1718 | const mangled_name = try block_scope.makeMangledName(c, name); | 1314 | try transEnumDecl(c, scope, @ptrCast(*const clang.EnumDecl, decl)); |
| 1719 | const node = (try transCreateNodeTypedef(rp, typedef_decl, false, mangled_name)) orelse | | |
| 1720 | return error.UnsupportedTranslation; | | |
| 1721 | return node; | | |
| 1722 | }, | 1315 | }, |
| 1723 | else => |kind| return revertAndWarn( | 1316 | else => |kind| return fail( |
| 1724 | rp, | 1317 | c, |
| 1725 | error.UnsupportedTranslation, | 1318 | error.UnsupportedTranslation, |
| 1726 | decl.getLocation(), | 1319 | decl.getLocation(), |
| 1727 | "TODO implement translation of DeclStmt kind {s}", | 1320 | "TODO implement translation of DeclStmt kind {s}", |
| ... | @@ -1730,96 +1323,86 @@ fn transDeclStmtOne( | ... | @@ -1730,96 +1323,86 @@ fn transDeclStmtOne( |
| 1730 | } | 1323 | } |
| 1731 | } | 1324 | } |
| 1732 | | 1325 | |
| 1733 | fn transDeclStmt(rp: RestorePoint, scope: *Scope, stmt: *const clang.DeclStmt) TransError!*ast.Node { | 1326 | fn transDeclStmt(c: *Context, scope: *Scope, stmt: *const clang.DeclStmt) TransError!Node { |
| 1734 | const block_scope = scope.findBlockScope(rp.c) catch unreachable; | 1327 | const block_scope = try scope.findBlockScope(c); |
| 1735 | | 1328 | |
| 1736 | var it = stmt.decl_begin(); | 1329 | var it = stmt.decl_begin(); |
| 1737 | const end_it = stmt.decl_end(); | 1330 | const end_it = stmt.decl_end(); |
| 1738 | assert(it != end_it); | 1331 | while (it != end_it) : (it += 1) { |
| 1739 | while (true) : (it += 1) { | 1332 | try transDeclStmtOne(c, scope, it[0], block_scope); |
| 1740 | const node = try transDeclStmtOne(rp, scope, it[0], block_scope); | | |
| 1741 | | | |
| 1742 | if (it + 1 == end_it) { | | |
| 1743 | return node; | | |
| 1744 | } else { | | |
| 1745 | try block_scope.statements.append(node); | | |
| 1746 | } | | |
| 1747 | } | 1333 | } |
| 1748 | unreachable; | 1334 | return Tag.declaration.init(); |
| 1749 | } | 1335 | } |
| 1750 | | 1336 | |
| 1751 | fn transDeclRefExpr( | 1337 | fn transDeclRefExpr( |
| 1752 | rp: RestorePoint, | 1338 | c: *Context, |
| 1753 | scope: *Scope, | 1339 | scope: *Scope, |
| 1754 | expr: *const clang.DeclRefExpr, | 1340 | expr: *const clang.DeclRefExpr, |
| 1755 | lrvalue: LRValue, | 1341 | ) TransError!Node { |
| 1756 | ) TransError!*ast.Node { | | |
| 1757 | const value_decl = expr.getDecl(); | 1342 | const value_decl = expr.getDecl(); |
| 1758 | const name = try rp.c.str(@ptrCast(*const clang.NamedDecl, value_decl).getName_bytes_begin()); | 1343 | const name = try c.str(@ptrCast(*const clang.NamedDecl, value_decl).getName_bytes_begin()); |
| 1759 | const mangled_name = scope.getAlias(name); | 1344 | const mangled_name = scope.getAlias(name); |
| 1760 | return transCreateNodeIdentifier(rp.c, mangled_name); | 1345 | return Tag.identifier.create(c.arena, mangled_name); |
| 1761 | } | 1346 | } |
| 1762 | | 1347 | |
| 1763 | fn transImplicitCastExpr( | 1348 | fn transImplicitCastExpr( |
| 1764 | rp: RestorePoint, | 1349 | c: *Context, |
| 1765 | scope: *Scope, | 1350 | scope: *Scope, |
| 1766 | expr: *const clang.ImplicitCastExpr, | 1351 | expr: *const clang.ImplicitCastExpr, |
| 1767 | result_used: ResultUsed, | 1352 | result_used: ResultUsed, |
| 1768 | ) TransError!*ast.Node { | 1353 | ) TransError!Node { |
| 1769 | const c = rp.c; | | |
| 1770 | const sub_expr = expr.getSubExpr(); | 1354 | const sub_expr = expr.getSubExpr(); |
| 1771 | const dest_type = getExprQualType(c, @ptrCast(*const clang.Expr, expr)); | 1355 | const dest_type = getExprQualType(c, @ptrCast(*const clang.Expr, expr)); |
| 1772 | const src_type = getExprQualType(c, sub_expr); | 1356 | const src_type = getExprQualType(c, sub_expr); |
| 1773 | switch (expr.getCastKind()) { | 1357 | switch (expr.getCastKind()) { |
| 1774 | .BitCast, .FloatingCast, .FloatingToIntegral, .IntegralToFloating, .IntegralCast, .PointerToIntegral, .IntegralToPointer => { | 1358 | .BitCast, .FloatingCast, .FloatingToIntegral, .IntegralToFloating, .IntegralCast, .PointerToIntegral, .IntegralToPointer => { |
| 1775 | const sub_expr_node = try transExpr(rp, scope, sub_expr, .used, .r_value); | 1359 | const sub_expr_node = try transExpr(c, scope, sub_expr, .used); |
| 1776 | return try transCCast(rp, scope, expr.getBeginLoc(), dest_type, src_type, sub_expr_node); | 1360 | const casted = try transCCast(c, scope, expr.getBeginLoc(), dest_type, src_type, sub_expr_node); |
| | 1361 | return maybeSuppressResult(c, scope, result_used, casted); |
| 1777 | }, | 1362 | }, |
| 1778 | .LValueToRValue, .NoOp, .FunctionToPointerDecay => { | 1363 | .LValueToRValue, .NoOp, .FunctionToPointerDecay => { |
| 1779 | const sub_expr_node = try transExpr(rp, scope, sub_expr, .used, .r_value); | 1364 | const sub_expr_node = try transExpr(c, scope, sub_expr, .used); |
| 1780 | return maybeSuppressResult(rp, scope, result_used, sub_expr_node); | 1365 | return maybeSuppressResult(c, scope, result_used, sub_expr_node); |
| 1781 | }, | 1366 | }, |
| 1782 | .ArrayToPointerDecay => { | 1367 | .ArrayToPointerDecay => { |
| 1783 | if (exprIsNarrowStringLiteral(sub_expr)) { | 1368 | if (exprIsNarrowStringLiteral(sub_expr)) { |
| 1784 | const sub_expr_node = try transExpr(rp, scope, sub_expr, .used, .r_value); | 1369 | const sub_expr_node = try transExpr(c, scope, sub_expr, .used); |
| 1785 | return maybeSuppressResult(rp, scope, result_used, sub_expr_node); | 1370 | return maybeSuppressResult(c, scope, result_used, sub_expr_node); |
| 1786 | } | 1371 | } |
| 1787 | | 1372 | |
| 1788 | const prefix_op = try transCreateNodeSimplePrefixOp(rp.c, .AddressOf, .Ampersand, "&"); | 1373 | const addr = try Tag.address_of.create(c.arena, try transExpr(c, scope, sub_expr, .used)); |
| 1789 | prefix_op.rhs = try transExpr(rp, scope, sub_expr, .used, .r_value); | 1374 | return maybeSuppressResult(c, scope, result_used, addr); |
| 1790 | | | |
| 1791 | return maybeSuppressResult(rp, scope, result_used, &prefix_op.base); | | |
| 1792 | }, | 1375 | }, |
| 1793 | .NullToPointer => { | 1376 | .NullToPointer => { |
| 1794 | return try transCreateNodeNullLiteral(rp.c); | 1377 | return Tag.null_literal.init(); |
| 1795 | }, | 1378 | }, |
| 1796 | .PointerToBoolean => { | 1379 | .PointerToBoolean => { |
| 1797 | // @ptrToInt(val) != 0 | 1380 | // @ptrToInt(val) != 0 |
| 1798 | const ptr_to_int = try rp.c.createBuiltinCall("@ptrToInt", 1); | 1381 | const ptr_to_int = try Tag.ptr_to_int.create(c.arena, try transExpr(c, scope, sub_expr, .used)); |
| 1799 | ptr_to_int.params()[0] = try transExpr(rp, scope, sub_expr, .used, .r_value); | | |
| 1800 | ptr_to_int.rparen_token = try appendToken(rp.c, .RParen, ")"); | | |
| 1801 | | 1382 | |
| 1802 | const op_token = try appendToken(rp.c, .BangEqual, "!="); | 1383 | const ne = try Tag.not_equal.create(c.arena, .{ .lhs = ptr_to_int, .rhs = Tag.zero_literal.init() }); |
| 1803 | const rhs_node = try transCreateNodeInt(rp.c, 0); | 1384 | return maybeSuppressResult(c, scope, result_used, ne); |
| 1804 | return transCreateNodeInfixOp(rp, scope, &ptr_to_int.base, .BangEqual, op_token, rhs_node, result_used, false); | | |
| 1805 | }, | 1385 | }, |
| 1806 | .IntegralToBoolean => { | 1386 | .IntegralToBoolean => { |
| 1807 | const sub_expr_node = try transExpr(rp, scope, sub_expr, .used, .r_value); | 1387 | const sub_expr_node = try transExpr(c, scope, sub_expr, .used); |
| 1808 | | 1388 | |
| 1809 | // The expression is already a boolean one, return it as-is | 1389 | // The expression is already a boolean one, return it as-is |
| 1810 | if (isBoolRes(sub_expr_node)) | 1390 | if (isBoolRes(sub_expr_node)) |
| 1811 | return sub_expr_node; | 1391 | return maybeSuppressResult(c, scope, result_used, sub_expr_node); |
| 1812 | | 1392 | |
| 1813 | // val != 0 | 1393 | // val != 0 |
| 1814 | const op_token = try appendToken(rp.c, .BangEqual, "!="); | 1394 | const ne = try Tag.not_equal.create(c.arena, .{ .lhs = sub_expr_node, .rhs = Tag.zero_literal.init() }); |
| 1815 | const rhs_node = try transCreateNodeInt(rp.c, 0); | 1395 | return maybeSuppressResult(c, scope, result_used, ne); |
| 1816 | return transCreateNodeInfixOp(rp, scope, sub_expr_node, .BangEqual, op_token, rhs_node, result_used, false); | | |
| 1817 | }, | 1396 | }, |
| 1818 | .BuiltinFnToFnPtr => { | 1397 | .BuiltinFnToFnPtr => { |
| 1819 | return transExpr(rp, scope, sub_expr, .used, .r_value); | 1398 | return transExpr(c, scope, sub_expr, result_used); |
| 1820 | }, | 1399 | }, |
| 1821 | else => |kind| return revertAndWarn( | 1400 | .ToVoid => { |
| 1822 | rp, | 1401 | // Should only appear in the rhs and lhs of a ConditionalOperator |
| | 1402 | return transExpr(c, scope, sub_expr, .unused); |
| | 1403 | }, |
| | 1404 | else => |kind| return fail( |
| | 1405 | c, |
| 1823 | error.UnsupportedTranslation, | 1406 | error.UnsupportedTranslation, |
| 1824 | @ptrCast(*const clang.Stmt, expr).getBeginLoc(), | 1407 | @ptrCast(*const clang.Stmt, expr).getBeginLoc(), |
| 1825 | "TODO implement translation of CastKind {s}", | 1408 | "TODO implement translation of CastKind {s}", |
| ... | @@ -1829,52 +1412,28 @@ fn transImplicitCastExpr( | ... | @@ -1829,52 +1412,28 @@ fn transImplicitCastExpr( |
| 1829 | } | 1412 | } |
| 1830 | | 1413 | |
| 1831 | fn transBoolExpr( | 1414 | fn transBoolExpr( |
| 1832 | rp: RestorePoint, | 1415 | c: *Context, |
| 1833 | scope: *Scope, | 1416 | scope: *Scope, |
| 1834 | expr: *const clang.Expr, | 1417 | expr: *const clang.Expr, |
| 1835 | used: ResultUsed, | 1418 | used: ResultUsed, |
| 1836 | lrvalue: LRValue, | 1419 | ) TransError!Node { |
| 1837 | grouped: bool, | | |
| 1838 | ) TransError!*ast.Node { | | |
| 1839 | if (@ptrCast(*const clang.Stmt, expr).getStmtClass() == .IntegerLiteralClass) { | 1420 | if (@ptrCast(*const clang.Stmt, expr).getStmtClass() == .IntegerLiteralClass) { |
| 1840 | var is_zero: bool = undefined; | 1421 | var is_zero: bool = undefined; |
| 1841 | if (!(@ptrCast(*const clang.IntegerLiteral, expr).isZero(&is_zero, rp.c.clang_context))) { | 1422 | if (!(@ptrCast(*const clang.IntegerLiteral, expr).isZero(&is_zero, c.clang_context))) { |
| 1842 | return revertAndWarn(rp, error.UnsupportedTranslation, expr.getBeginLoc(), "invalid integer literal", .{}); | 1423 | return fail(c, error.UnsupportedTranslation, expr.getBeginLoc(), "invalid integer literal", .{}); |
| 1843 | } | 1424 | } |
| 1844 | return try transCreateNodeBoolLiteral(rp.c, !is_zero); | 1425 | return Node{ .tag_if_small_enough = @enumToInt(([2]Tag{ .true_literal, .false_literal })[@boolToInt(is_zero)]) }; |
| 1845 | } | 1426 | } |
| 1846 | | 1427 | |
| 1847 | const lparen = if (grouped) | 1428 | var res = try transExpr(c, scope, expr, used); |
| 1848 | try appendToken(rp.c, .LParen, "(") | | |
| 1849 | else | | |
| 1850 | undefined; | | |
| 1851 | var res = try transExpr(rp, scope, expr, used, lrvalue); | | |
| 1852 | | | |
| 1853 | if (isBoolRes(res)) { | 1429 | if (isBoolRes(res)) { |
| 1854 | if (!grouped and res.tag == .GroupedExpression) { | 1430 | return maybeSuppressResult(c, scope, used, res); |
| 1855 | const group = @fieldParentPtr(ast.Node.GroupedExpression, "base", res); | | |
| 1856 | res = group.expr; | | |
| 1857 | // get zig fmt to work properly | | |
| 1858 | tokenSlice(rp.c, group.lparen)[0] = ')'; | | |
| 1859 | } | | |
| 1860 | return res; | | |
| 1861 | } | 1431 | } |
| 1862 | | 1432 | |
| 1863 | const ty = getExprQualType(rp.c, expr).getTypePtr(); | 1433 | const ty = getExprQualType(c, expr).getTypePtr(); |
| 1864 | const node = try finishBoolExpr(rp, scope, expr.getBeginLoc(), ty, res, used); | 1434 | const node = try finishBoolExpr(c, scope, expr.getBeginLoc(), ty, res, used); |
| 1865 | | 1435 | |
| 1866 | if (grouped) { | 1436 | return maybeSuppressResult(c, scope, used, node); |
| 1867 | const rparen = try appendToken(rp.c, .RParen, ")"); | | |
| 1868 | const grouped_expr = try rp.c.arena.create(ast.Node.GroupedExpression); | | |
| 1869 | grouped_expr.* = .{ | | |
| 1870 | .lparen = lparen, | | |
| 1871 | .expr = node, | | |
| 1872 | .rparen = rparen, | | |
| 1873 | }; | | |
| 1874 | return maybeSuppressResult(rp, scope, used, &grouped_expr.base); | | |
| 1875 | } else { | | |
| 1876 | return maybeSuppressResult(rp, scope, used, node); | | |
| 1877 | } | | |
| 1878 | } | 1437 | } |
| 1879 | | 1438 | |
| 1880 | fn exprIsBooleanType(expr: *const clang.Expr) bool { | 1439 | fn exprIsBooleanType(expr: *const clang.Expr) bool { |
| ... | @@ -1900,34 +1459,32 @@ fn exprIsNarrowStringLiteral(expr: *const clang.Expr) bool { | ... | @@ -1900,34 +1459,32 @@ fn exprIsNarrowStringLiteral(expr: *const clang.Expr) bool { |
| 1900 | } | 1459 | } |
| 1901 | } | 1460 | } |
| 1902 | | 1461 | |
| 1903 | fn isBoolRes(res: *ast.Node) bool { | 1462 | fn isBoolRes(res: Node) bool { |
| 1904 | switch (res.tag) { | 1463 | switch (res.tag()) { |
| 1905 | .BoolOr, | 1464 | .@"or", |
| 1906 | .BoolAnd, | 1465 | .@"and", |
| 1907 | .EqualEqual, | 1466 | .equal, |
| 1908 | .BangEqual, | 1467 | .not_equal, |
| 1909 | .LessThan, | 1468 | .less_than, |
| 1910 | .GreaterThan, | 1469 | .less_than_equal, |
| 1911 | .LessOrEqual, | 1470 | .greater_than, |
| 1912 | .GreaterOrEqual, | 1471 | .greater_than_equal, |
| 1913 | .BoolNot, | 1472 | .not, |
| 1914 | .BoolLiteral, | 1473 | .false_literal, |
| | 1474 | .true_literal, |
| 1915 | => return true, | 1475 | => return true, |
| 1916 | | | |
| 1917 | .GroupedExpression => return isBoolRes(@fieldParentPtr(ast.Node.GroupedExpression, "base", res).expr), | | |
| 1918 | | | |
| 1919 | else => return false, | 1476 | else => return false, |
| 1920 | } | 1477 | } |
| 1921 | } | 1478 | } |
| 1922 | | 1479 | |
| 1923 | fn finishBoolExpr( | 1480 | fn finishBoolExpr( |
| 1924 | rp: RestorePoint, | 1481 | c: *Context, |
| 1925 | scope: *Scope, | 1482 | scope: *Scope, |
| 1926 | loc: clang.SourceLocation, | 1483 | loc: clang.SourceLocation, |
| 1927 | ty: *const clang.Type, | 1484 | ty: *const clang.Type, |
| 1928 | node: *ast.Node, | 1485 | node: Node, |
| 1929 | used: ResultUsed, | 1486 | used: ResultUsed, |
| 1930 | ) TransError!*ast.Node { | 1487 | ) TransError!Node { |
| 1931 | switch (ty.getTypeClass()) { | 1488 | switch (ty.getTypeClass()) { |
| 1932 | .Builtin => { | 1489 | .Builtin => { |
| 1933 | const builtin_ty = @ptrCast(*const clang.BuiltinType, ty); | 1490 | const builtin_ty = @ptrCast(*const clang.BuiltinType, ty); |
| ... | @@ -1959,42 +1516,38 @@ fn finishBoolExpr( | ... | @@ -1959,42 +1516,38 @@ fn finishBoolExpr( |
| 1959 | .WChar_S, | 1516 | .WChar_S, |
| 1960 | .Float16, | 1517 | .Float16, |
| 1961 | => { | 1518 | => { |
| 1962 | const op_token = try appendToken(rp.c, .BangEqual, "!="); | 1519 | // node != 0 |
| 1963 | const rhs_node = try transCreateNodeInt(rp.c, 0); | 1520 | return Tag.not_equal.create(c.arena, .{ .lhs = node, .rhs = Tag.zero_literal.init() }); |
| 1964 | return transCreateNodeInfixOp(rp, scope, node, .BangEqual, op_token, rhs_node, used, false); | | |
| 1965 | }, | 1521 | }, |
| 1966 | .NullPtr => { | 1522 | .NullPtr => { |
| 1967 | const op_token = try appendToken(rp.c, .EqualEqual, "=="); | 1523 | // node == null |
| 1968 | const rhs_node = try transCreateNodeNullLiteral(rp.c); | 1524 | return Tag.equal.create(c.arena, .{ .lhs = node, .rhs = Tag.null_literal.init() }); |
| 1969 | return transCreateNodeInfixOp(rp, scope, node, .EqualEqual, op_token, rhs_node, used, false); | | |
| 1970 | }, | 1525 | }, |
| 1971 | else => {}, | 1526 | else => {}, |
| 1972 | } | 1527 | } |
| 1973 | }, | 1528 | }, |
| 1974 | .Pointer => { | 1529 | .Pointer => { |
| 1975 | const op_token = try appendToken(rp.c, .BangEqual, "!="); | 1530 | // node != null |
| 1976 | const rhs_node = try transCreateNodeNullLiteral(rp.c); | 1531 | return Tag.not_equal.create(c.arena, .{ .lhs = node, .rhs = Tag.null_literal.init() }); |
| 1977 | return transCreateNodeInfixOp(rp, scope, node, .BangEqual, op_token, rhs_node, used, false); | | |
| 1978 | }, | 1532 | }, |
| 1979 | .Typedef => { | 1533 | .Typedef => { |
| 1980 | const typedef_ty = @ptrCast(*const clang.TypedefType, ty); | 1534 | const typedef_ty = @ptrCast(*const clang.TypedefType, ty); |
| 1981 | const typedef_decl = typedef_ty.getDecl(); | 1535 | const typedef_decl = typedef_ty.getDecl(); |
| 1982 | const underlying_type = typedef_decl.getUnderlyingType(); | 1536 | const underlying_type = typedef_decl.getUnderlyingType(); |
| 1983 | return finishBoolExpr(rp, scope, loc, underlying_type.getTypePtr(), node, used); | 1537 | return finishBoolExpr(c, scope, loc, underlying_type.getTypePtr(), node, used); |
| 1984 | }, | 1538 | }, |
| 1985 | .Enum => { | 1539 | .Enum => { |
| 1986 | const op_token = try appendToken(rp.c, .BangEqual, "!="); | 1540 | // node != 0 |
| 1987 | const rhs_node = try transCreateNodeInt(rp.c, 0); | 1541 | return Tag.not_equal.create(c.arena, .{ .lhs = node, .rhs = Tag.zero_literal.init() }); |
| 1988 | return transCreateNodeInfixOp(rp, scope, node, .BangEqual, op_token, rhs_node, used, false); | | |
| 1989 | }, | 1542 | }, |
| 1990 | .Elaborated => { | 1543 | .Elaborated => { |
| 1991 | const elaborated_ty = @ptrCast(*const clang.ElaboratedType, ty); | 1544 | const elaborated_ty = @ptrCast(*const clang.ElaboratedType, ty); |
| 1992 | const named_type = elaborated_ty.getNamedType(); | 1545 | const named_type = elaborated_ty.getNamedType(); |
| 1993 | return finishBoolExpr(rp, scope, loc, named_type.getTypePtr(), node, used); | 1546 | return finishBoolExpr(c, scope, loc, named_type.getTypePtr(), node, used); |
| 1994 | }, | 1547 | }, |
| 1995 | else => {}, | 1548 | else => {}, |
| 1996 | } | 1549 | } |
| 1997 | return revertAndWarn(rp, error.UnsupportedType, loc, "unsupported bool expression type", .{}); | 1550 | return fail(c, error.UnsupportedType, loc, "unsupported bool expression type", .{}); |
| 1998 | } | 1551 | } |
| 1999 | | 1552 | |
| 2000 | const SuppressCast = enum { | 1553 | const SuppressCast = enum { |
| ... | @@ -2002,21 +1555,21 @@ const SuppressCast = enum { | ... | @@ -2002,21 +1555,21 @@ const SuppressCast = enum { |
| 2002 | no_as, | 1555 | no_as, |
| 2003 | }; | 1556 | }; |
| 2004 | fn transIntegerLiteral( | 1557 | fn transIntegerLiteral( |
| 2005 | rp: RestorePoint, | 1558 | c: *Context, |
| 2006 | scope: *Scope, | 1559 | scope: *Scope, |
| 2007 | expr: *const clang.IntegerLiteral, | 1560 | expr: *const clang.IntegerLiteral, |
| 2008 | result_used: ResultUsed, | 1561 | result_used: ResultUsed, |
| 2009 | suppress_as: SuppressCast, | 1562 | suppress_as: SuppressCast, |
| 2010 | ) TransError!*ast.Node { | 1563 | ) TransError!Node { |
| 2011 | var eval_result: clang.ExprEvalResult = undefined; | 1564 | var eval_result: clang.ExprEvalResult = undefined; |
| 2012 | if (!expr.EvaluateAsInt(&eval_result, rp.c.clang_context)) { | 1565 | if (!expr.EvaluateAsInt(&eval_result, c.clang_context)) { |
| 2013 | const loc = expr.getBeginLoc(); | 1566 | const loc = expr.getBeginLoc(); |
| 2014 | return revertAndWarn(rp, error.UnsupportedTranslation, loc, "invalid integer literal", .{}); | 1567 | return fail(c, error.UnsupportedTranslation, loc, "invalid integer literal", .{}); |
| 2015 | } | 1568 | } |
| 2016 | | 1569 | |
| 2017 | if (suppress_as == .no_as) { | 1570 | if (suppress_as == .no_as) { |
| 2018 | const int_lit_node = try transCreateNodeAPInt(rp.c, eval_result.Val.getInt()); | 1571 | const int_lit_node = try transCreateNodeAPInt(c, eval_result.Val.getInt()); |
| 2019 | return maybeSuppressResult(rp, scope, result_used, int_lit_node); | 1572 | return maybeSuppressResult(c, scope, result_used, int_lit_node); |
| 2020 | } | 1573 | } |
| 2021 | | 1574 | |
| 2022 | // Integer literals in C have types, and this can matter for several reasons. | 1575 | // Integer literals in C have types, and this can matter for several reasons. |
| ... | @@ -2031,115 +1584,61 @@ fn transIntegerLiteral( | ... | @@ -2031,115 +1584,61 @@ fn transIntegerLiteral( |
| 2031 | | 1584 | |
| 2032 | // @as(T, x) | 1585 | // @as(T, x) |
| 2033 | const expr_base = @ptrCast(*const clang.Expr, expr); | 1586 | const expr_base = @ptrCast(*const clang.Expr, expr); |
| 2034 | const as_node = try rp.c.createBuiltinCall("@as", 2); | 1587 | const ty_node = try transQualType(c, scope, expr_base.getType(), expr_base.getBeginLoc()); |
| 2035 | const ty_node = try transQualType(rp, expr_base.getType(), expr_base.getBeginLoc()); | 1588 | const rhs = try transCreateNodeAPInt(c, eval_result.Val.getInt()); |
| 2036 | as_node.params()[0] = ty_node; | 1589 | const as = try Tag.as.create(c.arena, .{ .lhs = ty_node, .rhs = rhs }); |
| 2037 | _ = try appendToken(rp.c, .Comma, ","); | 1590 | return maybeSuppressResult(c, scope, result_used, as); |
| 2038 | as_node.params()[1] = try transCreateNodeAPInt(rp.c, eval_result.Val.getInt()); | | |
| 2039 | | | |
| 2040 | as_node.rparen_token = try appendToken(rp.c, .RParen, ")"); | | |
| 2041 | return maybeSuppressResult(rp, scope, result_used, &as_node.base); | | |
| 2042 | } | | |
| 2043 | | | |
| 2044 | /// In C if a function has return type `int` and the return value is a boolean | | |
| 2045 | /// expression, there is no implicit cast. So the translated Zig will need to | | |
| 2046 | /// call @boolToInt | | |
| 2047 | fn zigShouldCastBooleanReturnToInt(node: ?*ast.Node, qt: ?clang.QualType) bool { | | |
| 2048 | if (node == null or qt == null) return false; | | |
| 2049 | return isBoolRes(node.?) and cIsNativeInt(qt.?); | | |
| 2050 | } | 1591 | } |
| 2051 | | 1592 | |
| 2052 | fn transReturnStmt( | 1593 | fn transReturnStmt( |
| 2053 | rp: RestorePoint, | 1594 | c: *Context, |
| 2054 | scope: *Scope, | 1595 | scope: *Scope, |
| 2055 | expr: *const clang.ReturnStmt, | 1596 | expr: *const clang.ReturnStmt, |
| 2056 | ) TransError!*ast.Node { | 1597 | ) TransError!Node { |
| 2057 | const return_kw = try appendToken(rp.c, .Keyword_return, "return"); | 1598 | const val_expr = expr.getRetValue() orelse |
| 2058 | var rhs: ?*ast.Node = if (expr.getRetValue()) |val_expr| | 1599 | return Tag.return_void.init(); |
| 2059 | try transExprCoercing(rp, scope, val_expr, .used, .r_value) | 1600 | |
| 2060 | else | 1601 | var rhs = try transExprCoercing(c, scope, val_expr, .used); |
| 2061 | null; | 1602 | const return_qt = scope.findBlockReturnType(c); |
| 2062 | const return_qt = scope.findBlockReturnType(rp.c); | 1603 | if (isBoolRes(rhs) and !qualTypeIsBoolean(return_qt)) { |
| 2063 | if (zigShouldCastBooleanReturnToInt(rhs, return_qt)) { | 1604 | rhs = try Tag.bool_to_int.create(c.arena, rhs); |
| 2064 | const bool_to_int_node = try rp.c.createBuiltinCall("@boolToInt", 1); | 1605 | } |
| 2065 | bool_to_int_node.params()[0] = rhs.?; | 1606 | return Tag.@"return".create(c.arena, rhs); |
| 2066 | bool_to_int_node.rparen_token = try appendToken(rp.c, .RParen, ")"); | | |
| 2067 | | | |
| 2068 | rhs = &bool_to_int_node.base; | | |
| 2069 | } | | |
| 2070 | const return_expr = try ast.Node.ControlFlowExpression.create(rp.c.arena, .{ | | |
| 2071 | .ltoken = return_kw, | | |
| 2072 | .tag = .Return, | | |
| 2073 | }, .{ | | |
| 2074 | .rhs = rhs, | | |
| 2075 | }); | | |
| 2076 | _ = try appendToken(rp.c, .Semicolon, ";"); | | |
| 2077 | return &return_expr.base; | | |
| 2078 | } | 1607 | } |
| 2079 | | 1608 | |
| 2080 | fn transStringLiteral( | 1609 | fn transStringLiteral( |
| 2081 | rp: RestorePoint, | 1610 | c: *Context, |
| 2082 | scope: *Scope, | 1611 | scope: *Scope, |
| 2083 | stmt: *const clang.StringLiteral, | 1612 | stmt: *const clang.StringLiteral, |
| 2084 | result_used: ResultUsed, | 1613 | result_used: ResultUsed, |
| 2085 | ) TransError!*ast.Node { | 1614 | ) TransError!Node { |
| 2086 | const kind = stmt.getKind(); | 1615 | const kind = stmt.getKind(); |
| 2087 | switch (kind) { | 1616 | switch (kind) { |
| 2088 | .Ascii, .UTF8 => { | 1617 | .Ascii, .UTF8 => { |
| 2089 | var len: usize = undefined; | 1618 | var len: usize = undefined; |
| 2090 | const bytes_ptr = stmt.getString_bytes_begin_size(&len); | 1619 | const bytes_ptr = stmt.getString_bytes_begin_size(&len); |
| 2091 | const str = bytes_ptr[0..len]; | | |
| 2092 | | 1620 | |
| 2093 | const token = try appendTokenFmt(rp.c, .StringLiteral, "\"{}\"", .{std.zig.fmtEscapes(str)}); | 1621 | const str = try std.fmt.allocPrint(c.arena, "\"{}\"", .{std.zig.fmtEscapes(bytes_ptr[0..len])}); |
| 2094 | const node = try rp.c.arena.create(ast.Node.OneToken); | 1622 | const node = try Tag.string_literal.create(c.arena, str); |
| 2095 | node.* = .{ | 1623 | return maybeSuppressResult(c, scope, result_used, node); |
| 2096 | .base = .{ .tag = .StringLiteral }, | | |
| 2097 | .token = token, | | |
| 2098 | }; | | |
| 2099 | return maybeSuppressResult(rp, scope, result_used, &node.base); | | |
| 2100 | }, | 1624 | }, |
| 2101 | .UTF16, .UTF32, .Wide => { | 1625 | .UTF16, .UTF32, .Wide => { |
| 2102 | const node = try transWideStringLiteral(rp, scope, stmt); | 1626 | const str_type = @tagName(stmt.getKind()); |
| 2103 | return maybeSuppressResult(rp, scope, result_used, node); | 1627 | const name = try std.fmt.allocPrint(c.arena, "zig.{s}_string_{d}", .{ str_type, c.getMangle() }); |
| | 1628 | const lit_array = try transStringLiteralAsArray(c, scope, stmt, stmt.getLength() + 1); |
| | 1629 | |
| | 1630 | const decl = try Tag.var_simple.create(c.arena, .{ .name = name, .init = lit_array }); |
| | 1631 | try scope.appendNode(decl); |
| | 1632 | const node = try Tag.identifier.create(c.arena, name); |
| | 1633 | return maybeSuppressResult(c, scope, result_used, node); |
| 2104 | }, | 1634 | }, |
| 2105 | } | 1635 | } |
| 2106 | } | 1636 | } |
| 2107 | | 1637 | |
| 2108 | /// Translates a wide string literal as a global "anonymous" array of the relevant-sized | | |
| 2109 | /// integer type + null terminator, and returns an identifier node for it | | |
| 2110 | fn transWideStringLiteral(rp: RestorePoint, scope: *Scope, stmt: *const clang.StringLiteral) TransError!*ast.Node { | | |
| 2111 | const str_type = @tagName(stmt.getKind()); | | |
| 2112 | const mangle = rp.c.getMangle(); | | |
| 2113 | const name = try std.fmt.allocPrint(rp.c.arena, "zig.{s}_string_{d}", .{ str_type, mangle }); | | |
| 2114 | | | |
| 2115 | const const_tok = try appendToken(rp.c, .Keyword_const, "const"); | | |
| 2116 | const name_tok = try appendIdentifier(rp.c, name); | | |
| 2117 | const eq_tok = try appendToken(rp.c, .Equal, "="); | | |
| 2118 | var semi_tok: ast.TokenIndex = undefined; | | |
| 2119 | | | |
| 2120 | const lit_array = try transStringLiteralAsArray(rp, scope, stmt, stmt.getLength() + 1); | | |
| 2121 | | | |
| 2122 | semi_tok = try appendToken(rp.c, .Semicolon, ";"); | | |
| 2123 | const var_decl_node = try ast.Node.VarDecl.create(rp.c.arena, .{ | | |
| 2124 | .name_token = name_tok, | | |
| 2125 | .mut_token = const_tok, | | |
| 2126 | .semicolon_token = semi_tok, | | |
| 2127 | }, .{ | | |
| 2128 | .visib_token = null, | | |
| 2129 | .eq_token = eq_tok, | | |
| 2130 | .init_node = lit_array, | | |
| 2131 | }); | | |
| 2132 | try addTopLevelDecl(rp.c, name, &var_decl_node.base); | | |
| 2133 | return transCreateNodeIdentifier(rp.c, name); | | |
| 2134 | } | | |
| 2135 | | | |
| 2136 | /// Parse the size of an array back out from an ast Node. | 1638 | /// Parse the size of an array back out from an ast Node. |
| 2137 | fn zigArraySize(c: *Context, node: *ast.Node) TransError!usize { | 1639 | fn zigArraySize(c: *Context, node: Node) TransError!usize { |
| 2138 | if (node.castTag(.ArrayType)) |array| { | 1640 | if (node.castTag(.array_type)) |array| { |
| 2139 | if (array.len_expr.castTag(.IntegerLiteral)) |int_lit| { | 1641 | return array.data.len; |
| 2140 | const tok = tokenSlice(c, int_lit.token); | | |
| 2141 | return std.fmt.parseUnsigned(usize, tok, 10) catch error.UnsupportedTranslation; | | |
| 2142 | } | | |
| 2143 | } | 1642 | } |
| 2144 | return error.UnsupportedTranslation; | 1643 | return error.UnsupportedTranslation; |
| 2145 | } | 1644 | } |
| ... | @@ -2150,11 +1649,11 @@ fn zigArraySize(c: *Context, node: *ast.Node) TransError!usize { | ... | @@ -2150,11 +1649,11 @@ fn zigArraySize(c: *Context, node: *ast.Node) TransError!usize { |
| 2150 | /// than the array, truncate the string. If the array is larger than the | 1649 | /// than the array, truncate the string. If the array is larger than the |
| 2151 | /// string literal, pad the array with 0's | 1650 | /// string literal, pad the array with 0's |
| 2152 | fn transStringLiteralAsArray( | 1651 | fn transStringLiteralAsArray( |
| 2153 | rp: RestorePoint, | 1652 | c: *Context, |
| 2154 | scope: *Scope, | 1653 | scope: *Scope, |
| 2155 | stmt: *const clang.StringLiteral, | 1654 | stmt: *const clang.StringLiteral, |
| 2156 | array_size: usize, | 1655 | array_size: usize, |
| 2157 | ) TransError!*ast.Node { | 1656 | ) TransError!Node { |
| 2158 | if (array_size == 0) return error.UnsupportedType; | 1657 | if (array_size == 0) return error.UnsupportedType; |
| 2159 | | 1658 | |
| 2160 | const str_length = stmt.getLength(); | 1659 | const str_length = stmt.getLength(); |
| ... | @@ -2163,40 +1662,25 @@ fn transStringLiteralAsArray( | ... | @@ -2163,40 +1662,25 @@ fn transStringLiteralAsArray( |
| 2163 | const ty = expr_base.getType().getTypePtr(); | 1662 | const ty = expr_base.getType().getTypePtr(); |
| 2164 | const const_arr_ty = @ptrCast(*const clang.ConstantArrayType, ty); | 1663 | const const_arr_ty = @ptrCast(*const clang.ConstantArrayType, ty); |
| 2165 | | 1664 | |
| 2166 | const ty_node = try rp.c.arena.create(ast.Node.ArrayType); | 1665 | const elem_type = try transQualType(c, scope, const_arr_ty.getElementType(), expr_base.getBeginLoc()); |
| 2167 | const op_token = try appendToken(rp.c, .LBracket, "["); | 1666 | const arr_type = try Tag.array_type.create(c.arena, .{ .len = array_size, .elem_type = elem_type }); |
| 2168 | const len_expr = try transCreateNodeInt(rp.c, array_size); | 1667 | const init_list = try c.arena.alloc(Node, array_size); |
| 2169 | _ = try appendToken(rp.c, .RBracket, "]"); | | |
| 2170 | | | |
| 2171 | ty_node.* = .{ | | |
| 2172 | .op_token = op_token, | | |
| 2173 | .rhs = try transQualType(rp, const_arr_ty.getElementType(), expr_base.getBeginLoc()), | | |
| 2174 | .len_expr = len_expr, | | |
| 2175 | }; | | |
| 2176 | _ = try appendToken(rp.c, .LBrace, "{"); | | |
| 2177 | var init_node = try ast.Node.ArrayInitializer.alloc(rp.c.arena, array_size); | | |
| 2178 | init_node.* = .{ | | |
| 2179 | .lhs = &ty_node.base, | | |
| 2180 | .rtoken = undefined, | | |
| 2181 | .list_len = array_size, | | |
| 2182 | }; | | |
| 2183 | const init_list = init_node.list(); | | |
| 2184 | | 1668 | |
| 2185 | var i: c_uint = 0; | 1669 | var i: c_uint = 0; |
| 2186 | const kind = stmt.getKind(); | 1670 | const kind = stmt.getKind(); |
| 2187 | const narrow = kind == .Ascii or kind == .UTF8; | 1671 | const narrow = kind == .Ascii or kind == .UTF8; |
| 2188 | while (i < str_length and i < array_size) : (i += 1) { | 1672 | while (i < str_length and i < array_size) : (i += 1) { |
| 2189 | const code_unit = stmt.getCodeUnit(i); | 1673 | const code_unit = stmt.getCodeUnit(i); |
| 2190 | init_list[i] = try transCreateCharLitNode(rp.c, narrow, code_unit); | 1674 | init_list[i] = try transCreateCharLitNode(c, narrow, code_unit); |
| 2191 | _ = try appendToken(rp.c, .Comma, ","); | | |
| 2192 | } | 1675 | } |
| 2193 | while (i < array_size) : (i += 1) { | 1676 | while (i < array_size) : (i += 1) { |
| 2194 | init_list[i] = try transCreateNodeInt(rp.c, 0); | 1677 | init_list[i] = try transCreateNodeNumber(c, 0, .int); |
| 2195 | _ = try appendToken(rp.c, .Comma, ","); | | |
| 2196 | } | 1678 | } |
| 2197 | init_node.rtoken = try appendToken(rp.c, .RBrace, "}"); | | |
| 2198 | | 1679 | |
| 2199 | return &init_node.base; | 1680 | return Tag.array_init.create(c.arena, .{ |
| | 1681 | .cond = arr_type, |
| | 1682 | .cases = init_list, |
| | 1683 | }); |
| 2200 | } | 1684 | } |
| 2201 | | 1685 | |
| 2202 | fn cIsEnum(qt: clang.QualType) bool { | 1686 | fn cIsEnum(qt: clang.QualType) bool { |
| ... | @@ -2215,217 +1699,180 @@ fn cIntTypeForEnum(enum_qt: clang.QualType) clang.QualType { | ... | @@ -2215,217 +1699,180 @@ fn cIntTypeForEnum(enum_qt: clang.QualType) clang.QualType { |
| 2215 | } | 1699 | } |
| 2216 | | 1700 | |
| 2217 | fn transCCast( | 1701 | fn transCCast( |
| 2218 | rp: RestorePoint, | 1702 | c: *Context, |
| 2219 | scope: *Scope, | 1703 | scope: *Scope, |
| 2220 | loc: clang.SourceLocation, | 1704 | loc: clang.SourceLocation, |
| 2221 | dst_type: clang.QualType, | 1705 | dst_type: clang.QualType, |
| 2222 | src_type: clang.QualType, | 1706 | src_type: clang.QualType, |
| 2223 | expr: *ast.Node, | 1707 | expr: Node, |
| 2224 | ) !*ast.Node { | 1708 | ) !Node { |
| 2225 | if (qualTypeCanon(dst_type).isVoidType()) return expr; | 1709 | if (qualTypeCanon(dst_type).isVoidType()) return expr; |
| 2226 | if (dst_type.eq(src_type)) return expr; | 1710 | if (dst_type.eq(src_type)) return expr; |
| 2227 | if (qualTypeIsPtr(dst_type) and qualTypeIsPtr(src_type)) | 1711 | if (qualTypeIsPtr(dst_type) and qualTypeIsPtr(src_type)) |
| 2228 | return transCPtrCast(rp, loc, dst_type, src_type, expr); | 1712 | return transCPtrCast(c, scope, loc, dst_type, src_type, expr); |
| | 1713 | |
| | 1714 | const dst_node = try transQualType(c, scope, dst_type, loc); |
| 2229 | if (cIsInteger(dst_type) and (cIsInteger(src_type) or cIsEnum(src_type))) { | 1715 | if (cIsInteger(dst_type) and (cIsInteger(src_type) or cIsEnum(src_type))) { |
| 2230 | // 1. If src_type is an enum, determine the underlying signed int type | 1716 | // 1. If src_type is an enum, determine the underlying signed int type |
| 2231 | // 2. Extend or truncate without changing signed-ness. | 1717 | // 2. Extend or truncate without changing signed-ness. |
| 2232 | // 3. Bit-cast to correct signed-ness | 1718 | // 3. Bit-cast to correct signed-ness |
| 2233 | const src_type_is_signed = cIsSignedInteger(src_type) or cIsEnum(src_type); | 1719 | const src_type_is_signed = cIsSignedInteger(src_type) or cIsEnum(src_type); |
| 2234 | const src_int_type = if (cIsInteger(src_type)) src_type else cIntTypeForEnum(src_type); | 1720 | const src_int_type = if (cIsInteger(src_type)) src_type else cIntTypeForEnum(src_type); |
| 2235 | var src_int_expr = if (cIsInteger(src_type)) expr else try transEnumToInt(rp.c, expr); | 1721 | var src_int_expr = if (cIsInteger(src_type)) expr else try Tag.enum_to_int.create(c.arena, expr); |
| 2236 | | | |
| 2237 | // @bitCast(dest_type, intermediate_value) | | |
| 2238 | const cast_node = try rp.c.createBuiltinCall("@bitCast", 2); | | |
| 2239 | cast_node.params()[0] = try transQualType(rp, dst_type, loc); | | |
| 2240 | _ = try appendToken(rp.c, .Comma, ","); | | |
| 2241 | | 1722 | |
| 2242 | if (isBoolRes(src_int_expr)) { | 1723 | if (isBoolRes(src_int_expr)) { |
| 2243 | const bool_to_int_node = try rp.c.createBuiltinCall("@boolToInt", 1); | 1724 | src_int_expr = try Tag.bool_to_int.create(c.arena, src_int_expr); |
| 2244 | bool_to_int_node.params()[0] = src_int_expr; | | |
| 2245 | bool_to_int_node.rparen_token = try appendToken(rp.c, .RParen, ")"); | | |
| 2246 | src_int_expr = &bool_to_int_node.base; | | |
| 2247 | } | 1725 | } |
| 2248 | | 1726 | |
| 2249 | switch (cIntTypeCmp(dst_type, src_int_type)) { | 1727 | switch (cIntTypeCmp(dst_type, src_int_type)) { |
| 2250 | .lt => { | 1728 | .lt => { |
| 2251 | // @truncate(SameSignSmallerInt, src_int_expr) | 1729 | // @truncate(SameSignSmallerInt, src_int_expr) |
| 2252 | const trunc_node = try rp.c.createBuiltinCall("@truncate", 2); | 1730 | const ty_node = try transQualTypeIntWidthOf(c, dst_type, src_type_is_signed); |
| 2253 | const ty_node = try transQualTypeIntWidthOf(rp.c, dst_type, src_type_is_signed); | 1731 | src_int_expr = try Tag.truncate.create(c.arena, .{ .lhs = ty_node, .rhs = src_int_expr }); |
| 2254 | trunc_node.params()[0] = ty_node; | | |
| 2255 | _ = try appendToken(rp.c, .Comma, ","); | | |
| 2256 | trunc_node.params()[1] = src_int_expr; | | |
| 2257 | trunc_node.rparen_token = try appendToken(rp.c, .RParen, ")"); | | |
| 2258 | | | |
| 2259 | cast_node.params()[1] = &trunc_node.base; | | |
| 2260 | }, | 1732 | }, |
| 2261 | .gt => { | 1733 | .gt => { |
| 2262 | // @as(SameSignBiggerInt, src_int_expr) | 1734 | // @as(SameSignBiggerInt, src_int_expr) |
| 2263 | const as_node = try rp.c.createBuiltinCall("@as", 2); | 1735 | const ty_node = try transQualTypeIntWidthOf(c, dst_type, src_type_is_signed); |
| 2264 | const ty_node = try transQualTypeIntWidthOf(rp.c, dst_type, src_type_is_signed); | 1736 | src_int_expr = try Tag.as.create(c.arena, .{ .lhs = ty_node, .rhs = src_int_expr }); |
| 2265 | as_node.params()[0] = ty_node; | | |
| 2266 | _ = try appendToken(rp.c, .Comma, ","); | | |
| 2267 | as_node.params()[1] = src_int_expr; | | |
| 2268 | as_node.rparen_token = try appendToken(rp.c, .RParen, ")"); | | |
| 2269 | | | |
| 2270 | cast_node.params()[1] = &as_node.base; | | |
| 2271 | }, | 1737 | }, |
| 2272 | .eq => { | 1738 | .eq => { |
| 2273 | cast_node.params()[1] = src_int_expr; | 1739 | // src_int_expr = src_int_expr |
| 2274 | }, | 1740 | }, |
| 2275 | } | 1741 | } |
| 2276 | cast_node.rparen_token = try appendToken(rp.c, .RParen, ")"); | 1742 | // @bitCast(dest_type, intermediate_value) |
| 2277 | return &cast_node.base; | 1743 | return Tag.bit_cast.create(c.arena, .{ .lhs = dst_node, .rhs = src_int_expr }); |
| 2278 | } | 1744 | } |
| 2279 | if (cIsInteger(dst_type) and qualTypeIsPtr(src_type)) { | 1745 | if (cIsInteger(dst_type) and qualTypeIsPtr(src_type)) { |
| 2280 | // @intCast(dest_type, @ptrToInt(val)) | 1746 | // @intCast(dest_type, @ptrToInt(val)) |
| 2281 | const cast_node = try rp.c.createBuiltinCall("@intCast", 2); | 1747 | const ptr_to_int = try Tag.ptr_to_int.create(c.arena, expr); |
| 2282 | cast_node.params()[0] = try transQualType(rp, dst_type, loc); | 1748 | return Tag.int_cast.create(c.arena, .{ .lhs = dst_node, .rhs = ptr_to_int }); |
| 2283 | _ = try appendToken(rp.c, .Comma, ","); | | |
| 2284 | const builtin_node = try rp.c.createBuiltinCall("@ptrToInt", 1); | | |
| 2285 | builtin_node.params()[0] = expr; | | |
| 2286 | builtin_node.rparen_token = try appendToken(rp.c, .RParen, ")"); | | |
| 2287 | cast_node.params()[1] = &builtin_node.base; | | |
| 2288 | cast_node.rparen_token = try appendToken(rp.c, .RParen, ")"); | | |
| 2289 | return &cast_node.base; | | |
| 2290 | } | 1749 | } |
| 2291 | if (cIsInteger(src_type) and qualTypeIsPtr(dst_type)) { | 1750 | if (cIsInteger(src_type) and qualTypeIsPtr(dst_type)) { |
| 2292 | // @intToPtr(dest_type, val) | 1751 | // @intToPtr(dest_type, val) |
| 2293 | const builtin_node = try rp.c.createBuiltinCall("@intToPtr", 2); | 1752 | return Tag.int_to_ptr.create(c.arena, .{ .lhs = dst_node, .rhs = expr }); |
| 2294 | builtin_node.params()[0] = try transQualType(rp, dst_type, loc); | | |
| 2295 | _ = try appendToken(rp.c, .Comma, ","); | | |
| 2296 | builtin_node.params()[1] = expr; | | |
| 2297 | builtin_node.rparen_token = try appendToken(rp.c, .RParen, ")"); | | |
| 2298 | return &builtin_node.base; | | |
| 2299 | } | 1753 | } |
| 2300 | if (cIsFloating(src_type) and cIsFloating(dst_type)) { | 1754 | if (cIsFloating(src_type) and cIsFloating(dst_type)) { |
| 2301 | const builtin_node = try rp.c.createBuiltinCall("@floatCast", 2); | 1755 | // @floatCast(dest_type, val) |
| 2302 | builtin_node.params()[0] = try transQualType(rp, dst_type, loc); | 1756 | return Tag.float_cast.create(c.arena, .{ .lhs = dst_node, .rhs = expr }); |
| 2303 | _ = try appendToken(rp.c, .Comma, ","); | | |
| 2304 | builtin_node.params()[1] = expr; | | |
| 2305 | builtin_node.rparen_token = try appendToken(rp.c, .RParen, ")"); | | |
| 2306 | return &builtin_node.base; | | |
| 2307 | } | 1757 | } |
| 2308 | if (cIsFloating(src_type) and !cIsFloating(dst_type)) { | 1758 | if (cIsFloating(src_type) and !cIsFloating(dst_type)) { |
| 2309 | const builtin_node = try rp.c.createBuiltinCall("@floatToInt", 2); | 1759 | // @floatToInt(dest_type, val) |
| 2310 | builtin_node.params()[0] = try transQualType(rp, dst_type, loc); | 1760 | return Tag.float_to_int.create(c.arena, .{ .lhs = dst_node, .rhs = expr }); |
| 2311 | _ = try appendToken(rp.c, .Comma, ","); | | |
| 2312 | builtin_node.params()[1] = expr; | | |
| 2313 | builtin_node.rparen_token = try appendToken(rp.c, .RParen, ")"); | | |
| 2314 | return &builtin_node.base; | | |
| 2315 | } | 1761 | } |
| 2316 | if (!cIsFloating(src_type) and cIsFloating(dst_type)) { | 1762 | if (!cIsFloating(src_type) and cIsFloating(dst_type)) { |
| 2317 | const builtin_node = try rp.c.createBuiltinCall("@intToFloat", 2); | 1763 | // @intToFloat(dest_type, val) |
| 2318 | builtin_node.params()[0] = try transQualType(rp, dst_type, loc); | 1764 | return Tag.int_to_float.create(c.arena, .{ .lhs = dst_node, .rhs = expr }); |
| 2319 | _ = try appendToken(rp.c, .Comma, ","); | | |
| 2320 | builtin_node.params()[1] = expr; | | |
| 2321 | builtin_node.rparen_token = try appendToken(rp.c, .RParen, ")"); | | |
| 2322 | return &builtin_node.base; | | |
| 2323 | } | 1765 | } |
| 2324 | if (qualTypeIsBoolean(src_type) and !qualTypeIsBoolean(dst_type)) { | 1766 | if (qualTypeIsBoolean(src_type) and !qualTypeIsBoolean(dst_type)) { |
| 2325 | // @boolToInt returns either a comptime_int or a u1 | 1767 | // @boolToInt returns either a comptime_int or a u1 |
| 2326 | // TODO: if dst_type is 1 bit & signed (bitfield) we need @bitCast | 1768 | // TODO: if dst_type is 1 bit & signed (bitfield) we need @bitCast |
| 2327 | // instead of @as | 1769 | // instead of @as |
| 2328 | const builtin_node = try rp.c.createBuiltinCall("@boolToInt", 1); | 1770 | const bool_to_int = try Tag.bool_to_int.create(c.arena, expr); |
| 2329 | builtin_node.params()[0] = expr; | 1771 | return Tag.as.create(c.arena, .{ .lhs = dst_node, .rhs = bool_to_int }); |
| 2330 | builtin_node.rparen_token = try appendToken(rp.c, .RParen, ")"); | | |
| 2331 | | | |
| 2332 | const as_node = try rp.c.createBuiltinCall("@as", 2); | | |
| 2333 | as_node.params()[0] = try transQualType(rp, dst_type, loc); | | |
| 2334 | _ = try appendToken(rp.c, .Comma, ","); | | |
| 2335 | as_node.params()[1] = &builtin_node.base; | | |
| 2336 | as_node.rparen_token = try appendToken(rp.c, .RParen, ")"); | | |
| 2337 | | | |
| 2338 | return &as_node.base; | | |
| 2339 | } | 1772 | } |
| 2340 | if (cIsEnum(dst_type)) { | 1773 | if (cIsEnum(dst_type)) { |
| 2341 | const builtin_node = try rp.c.createBuiltinCall("@intToEnum", 2); | 1774 | // @intToEnum(dest_type, val) |
| 2342 | builtin_node.params()[0] = try transQualType(rp, dst_type, loc); | 1775 | return Tag.int_to_enum.create(c.arena, .{ .lhs = dst_node, .rhs = expr }); |
| 2343 | _ = try appendToken(rp.c, .Comma, ","); | | |
| 2344 | builtin_node.params()[1] = expr; | | |
| 2345 | builtin_node.rparen_token = try appendToken(rp.c, .RParen, ")"); | | |
| 2346 | return &builtin_node.base; | | |
| 2347 | } | 1776 | } |
| 2348 | if (cIsEnum(src_type) and !cIsEnum(dst_type)) { | 1777 | if (cIsEnum(src_type) and !cIsEnum(dst_type)) { |
| 2349 | return transEnumToInt(rp.c, expr); | 1778 | // @enumToInt(val) |
| | 1779 | return Tag.enum_to_int.create(c.arena, expr); |
| 2350 | } | 1780 | } |
| 2351 | const cast_node = try rp.c.createBuiltinCall("@as", 2); | 1781 | // @as(dest_type, val) |
| 2352 | cast_node.params()[0] = try transQualType(rp, dst_type, loc); | 1782 | return Tag.as.create(c.arena, .{ .lhs = dst_node, .rhs = expr }); |
| 2353 | _ = try appendToken(rp.c, .Comma, ","); | | |
| 2354 | cast_node.params()[1] = expr; | | |
| 2355 | cast_node.rparen_token = try appendToken(rp.c, .RParen, ")"); | | |
| 2356 | return &cast_node.base; | | |
| 2357 | } | | |
| 2358 | | | |
| 2359 | fn transEnumToInt(c: *Context, enum_expr: *ast.Node) TypeError!*ast.Node { | | |
| 2360 | const builtin_node = try c.createBuiltinCall("@enumToInt", 1); | | |
| 2361 | builtin_node.params()[0] = enum_expr; | | |
| 2362 | builtin_node.rparen_token = try appendToken(c, .RParen, ")"); | | |
| 2363 | return &builtin_node.base; | | |
| 2364 | } | 1783 | } |
| 2365 | | 1784 | |
| 2366 | fn transExpr( | 1785 | fn transExpr(c: *Context, scope: *Scope, expr: *const clang.Expr, used: ResultUsed) TransError!Node { |
| 2367 | rp: RestorePoint, | 1786 | return transStmt(c, scope, @ptrCast(*const clang.Stmt, expr), used); |
| 2368 | scope: *Scope, | | |
| 2369 | expr: *const clang.Expr, | | |
| 2370 | used: ResultUsed, | | |
| 2371 | lrvalue: LRValue, | | |
| 2372 | ) TransError!*ast.Node { | | |
| 2373 | return transStmt(rp, scope, @ptrCast(*const clang.Stmt, expr), used, lrvalue); | | |
| 2374 | } | 1787 | } |
| 2375 | | 1788 | |
| 2376 | /// Same as `transExpr` but with the knowledge that the operand will be type coerced, and therefore | 1789 | /// Same as `transExpr` but with the knowledge that the operand will be type coerced, and therefore |
| 2377 | /// an `@as` would be redundant. This is used to prevent redundant `@as` in integer literals. | 1790 | /// an `@as` would be redundant. This is used to prevent redundant `@as` in integer literals. |
| 2378 | fn transExprCoercing( | 1791 | fn transExprCoercing(c: *Context, scope: *Scope, expr: *const clang.Expr, used: ResultUsed) TransError!Node { |
| 2379 | rp: RestorePoint, | | |
| 2380 | scope: *Scope, | | |
| 2381 | expr: *const clang.Expr, | | |
| 2382 | used: ResultUsed, | | |
| 2383 | lrvalue: LRValue, | | |
| 2384 | ) TransError!*ast.Node { | | |
| 2385 | switch (@ptrCast(*const clang.Stmt, expr).getStmtClass()) { | 1792 | switch (@ptrCast(*const clang.Stmt, expr).getStmtClass()) { |
| 2386 | .IntegerLiteralClass => { | 1793 | .IntegerLiteralClass => { |
| 2387 | return transIntegerLiteral(rp, scope, @ptrCast(*const clang.IntegerLiteral, expr), .used, .no_as); | 1794 | return transIntegerLiteral(c, scope, @ptrCast(*const clang.IntegerLiteral, expr), .used, .no_as); |
| 2388 | }, | 1795 | }, |
| 2389 | .CharacterLiteralClass => { | 1796 | .CharacterLiteralClass => { |
| 2390 | return transCharLiteral(rp, scope, @ptrCast(*const clang.CharacterLiteral, expr), .used, .no_as); | 1797 | return transCharLiteral(c, scope, @ptrCast(*const clang.CharacterLiteral, expr), .used, .no_as); |
| 2391 | }, | 1798 | }, |
| 2392 | .UnaryOperatorClass => { | 1799 | .UnaryOperatorClass => { |
| 2393 | const un_expr = @ptrCast(*const clang.UnaryOperator, expr); | 1800 | const un_expr = @ptrCast(*const clang.UnaryOperator, expr); |
| 2394 | if (un_expr.getOpcode() == .Extension) { | 1801 | if (un_expr.getOpcode() == .Extension) { |
| 2395 | return transExprCoercing(rp, scope, un_expr.getSubExpr(), used, lrvalue); | 1802 | return transExprCoercing(c, scope, un_expr.getSubExpr(), used); |
| | 1803 | } |
| | 1804 | }, |
| | 1805 | .ImplicitCastExprClass => { |
| | 1806 | const cast_expr = @ptrCast(*const clang.ImplicitCastExpr, expr); |
| | 1807 | const sub_expr = cast_expr.getSubExpr(); |
| | 1808 | switch (@ptrCast(*const clang.Stmt, sub_expr).getStmtClass()) { |
| | 1809 | .IntegerLiteralClass, .CharacterLiteralClass => switch (cast_expr.getCastKind()) { |
| | 1810 | .IntegralToFloating => return transExprCoercing(c, scope, sub_expr, used), |
| | 1811 | .IntegralCast => { |
| | 1812 | const dest_type = getExprQualType(c, expr); |
| | 1813 | if (literalFitsInType(c, sub_expr, dest_type)) |
| | 1814 | return transExprCoercing(c, scope, sub_expr, used); |
| | 1815 | }, |
| | 1816 | else => {}, |
| | 1817 | }, |
| | 1818 | else => {}, |
| 2396 | } | 1819 | } |
| 2397 | }, | 1820 | }, |
| 2398 | else => {}, | 1821 | else => {}, |
| 2399 | } | 1822 | } |
| 2400 | return transExpr(rp, scope, expr, .used, .r_value); | 1823 | return transExpr(c, scope, expr, .used); |
| 2401 | } | 1824 | } |
| 2402 | | 1825 | |
| 2403 | fn transInitListExprRecord( | 1826 | fn literalFitsInType(c: *Context, expr: *const clang.Expr, qt: clang.QualType) bool { |
| 2404 | rp: RestorePoint, | 1827 | var width = qualTypeIntBitWidth(c, qt) catch 8; |
| 2405 | scope: *Scope, | 1828 | if (width == 0) width = 8; // Byte is the smallest type. |
| 2406 | loc: clang.SourceLocation, | 1829 | const is_signed = cIsSignedInteger(qt); |
| 2407 | expr: *const clang.InitListExpr, | 1830 | const width_max_int = (@as(u64, 1) << math.lossyCast(u6, width - @boolToInt(is_signed))) - 1; |
| 2408 | ty: *const clang.Type, | 1831 | |
| 2409 | used: ResultUsed, | 1832 | switch (@ptrCast(*const clang.Stmt, expr).getStmtClass()) { |
| 2410 | ) TransError!*ast.Node { | 1833 | .CharacterLiteralClass => { |
| 2411 | var is_union_type = false; | 1834 | const char_lit = @ptrCast(*const clang.CharacterLiteral, expr); |
| 2412 | // Unions and Structs are both represented as RecordDecl | 1835 | const val = char_lit.getValue(); |
| 2413 | const record_ty = ty.getAsRecordType() orelse | 1836 | // If the val is less than the max int then it fits. |
| 2414 | blk: { | 1837 | return val <= width_max_int; |
| 2415 | is_union_type = true; | 1838 | }, |
| | 1839 | .IntegerLiteralClass => { |
| | 1840 | const int_lit = @ptrCast(*const clang.IntegerLiteral, expr); |
| | 1841 | var eval_result: clang.ExprEvalResult = undefined; |
| | 1842 | if (!int_lit.EvaluateAsInt(&eval_result, c.clang_context)) { |
| | 1843 | return false; |
| | 1844 | } |
| | 1845 | |
| | 1846 | const int = eval_result.Val.getInt(); |
| | 1847 | return int.lessThanEqual(width_max_int); |
| | 1848 | }, |
| | 1849 | else => unreachable, |
| | 1850 | } |
| | 1851 | } |
| | 1852 | |
| | 1853 | fn transInitListExprRecord( |
| | 1854 | c: *Context, |
| | 1855 | scope: *Scope, |
| | 1856 | loc: clang.SourceLocation, |
| | 1857 | expr: *const clang.InitListExpr, |
| | 1858 | ty: *const clang.Type, |
| | 1859 | ) TransError!Node { |
| | 1860 | var is_union_type = false; |
| | 1861 | // Unions and Structs are both represented as RecordDecl |
| | 1862 | const record_ty = ty.getAsRecordType() orelse |
| | 1863 | blk: { |
| | 1864 | is_union_type = true; |
| 2416 | break :blk ty.getAsUnionType(); | 1865 | break :blk ty.getAsUnionType(); |
| 2417 | } orelse unreachable; | 1866 | } orelse unreachable; |
| 2418 | const record_decl = record_ty.getDecl(); | 1867 | const record_decl = record_ty.getDecl(); |
| 2419 | const record_def = record_decl.getDefinition() orelse | 1868 | const record_def = record_decl.getDefinition() orelse |
| 2420 | unreachable; | 1869 | unreachable; |
| 2421 | | 1870 | |
| 2422 | const ty_node = try transType(rp, ty, loc); | 1871 | const ty_node = try transType(c, scope, ty, loc); |
| 2423 | const init_count = expr.getNumInits(); | 1872 | const init_count = expr.getNumInits(); |
| 2424 | var field_inits = std.ArrayList(*ast.Node).init(rp.c.gpa); | 1873 | var field_inits = std.ArrayList(ast.Payload.ContainerInit.Initializer).init(c.gpa); |
| 2425 | defer field_inits.deinit(); | 1874 | defer field_inits.deinit(); |
| 2426 | | 1875 | |
| 2427 | _ = try appendToken(rp.c, .LBrace, "{"); | | |
| 2428 | | | |
| 2429 | var init_i: c_uint = 0; | 1876 | var init_i: c_uint = 0; |
| 2430 | var it = record_def.field_begin(); | 1877 | var it = record_def.field_begin(); |
| 2431 | const end_it = record_def.field_end(); | 1878 | const end_it = record_def.field_end(); |
| ... | @@ -2443,78 +1890,34 @@ fn transInitListExprRecord( | ... | @@ -2443,78 +1890,34 @@ fn transInitListExprRecord( |
| 2443 | | 1890 | |
| 2444 | // Generate the field assignment expression: | 1891 | // Generate the field assignment expression: |
| 2445 | // .field_name = expr | 1892 | // .field_name = expr |
| 2446 | const period_tok = try appendToken(rp.c, .Period, "."); | 1893 | var raw_name = try c.str(@ptrCast(*const clang.NamedDecl, field_decl).getName_bytes_begin()); |
| 2447 | | | |
| 2448 | var raw_name = try rp.c.str(@ptrCast(*const clang.NamedDecl, field_decl).getName_bytes_begin()); | | |
| 2449 | if (field_decl.isAnonymousStructOrUnion()) { | 1894 | if (field_decl.isAnonymousStructOrUnion()) { |
| 2450 | const name = rp.c.decl_table.get(@ptrToInt(field_decl.getCanonicalDecl())).?; | 1895 | const name = c.decl_table.get(@ptrToInt(field_decl.getCanonicalDecl())).?; |
| 2451 | raw_name = try mem.dupe(rp.c.arena, u8, name); | 1896 | raw_name = try mem.dupe(c.arena, u8, name); |
| 2452 | } | 1897 | } |
| 2453 | const field_name_tok = try appendIdentifier(rp.c, raw_name); | | |
| 2454 | | 1898 | |
| 2455 | _ = try appendToken(rp.c, .Equal, "="); | 1899 | try field_inits.append(.{ |
| 2456 | | 1900 | .name = raw_name, |
| 2457 | const field_init_node = try rp.c.arena.create(ast.Node.FieldInitializer); | 1901 | .value = try transExpr(c, scope, elem_expr, .used), |
| 2458 | field_init_node.* = .{ | 1902 | }); |
| 2459 | .period_token = period_tok, | | |
| 2460 | .name_token = field_name_tok, | | |
| 2461 | .expr = try transExpr(rp, scope, elem_expr, .used, .r_value), | | |
| 2462 | }; | | |
| 2463 | | | |
| 2464 | try field_inits.append(&field_init_node.base); | | |
| 2465 | _ = try appendToken(rp.c, .Comma, ","); | | |
| 2466 | } | 1903 | } |
| 2467 | | 1904 | |
| 2468 | const node = try ast.Node.StructInitializer.alloc(rp.c.arena, field_inits.items.len); | 1905 | return Tag.container_init.create(c.arena, .{ |
| 2469 | node.* = .{ | | |
| 2470 | .lhs = ty_node, | 1906 | .lhs = ty_node, |
| 2471 | .rtoken = try appendToken(rp.c, .RBrace, "}"), | 1907 | .inits = try c.arena.dupe(ast.Payload.ContainerInit.Initializer, field_inits.items), |
| 2472 | .list_len = field_inits.items.len, | 1908 | }); |
| 2473 | }; | | |
| 2474 | mem.copy(*ast.Node, node.list(), field_inits.items); | | |
| 2475 | return &node.base; | | |
| 2476 | } | | |
| 2477 | | | |
| 2478 | fn transCreateNodeArrayType( | | |
| 2479 | rp: RestorePoint, | | |
| 2480 | source_loc: clang.SourceLocation, | | |
| 2481 | ty: *const clang.Type, | | |
| 2482 | len: anytype, | | |
| 2483 | ) !*ast.Node { | | |
| 2484 | const node = try rp.c.arena.create(ast.Node.ArrayType); | | |
| 2485 | const op_token = try appendToken(rp.c, .LBracket, "["); | | |
| 2486 | const len_expr = try transCreateNodeInt(rp.c, len); | | |
| 2487 | _ = try appendToken(rp.c, .RBracket, "]"); | | |
| 2488 | node.* = .{ | | |
| 2489 | .op_token = op_token, | | |
| 2490 | .rhs = try transType(rp, ty, source_loc), | | |
| 2491 | .len_expr = len_expr, | | |
| 2492 | }; | | |
| 2493 | return &node.base; | | |
| 2494 | } | | |
| 2495 | | | |
| 2496 | fn transCreateEmptyArray(rp: RestorePoint, loc: clang.SourceLocation, ty: *const clang.Type) TransError!*ast.Node { | | |
| 2497 | const ty_node = try transCreateNodeArrayType(rp, loc, ty, 0); | | |
| 2498 | _ = try appendToken(rp.c, .LBrace, "{"); | | |
| 2499 | const filler_init_node = try ast.Node.ArrayInitializer.alloc(rp.c.arena, 0); | | |
| 2500 | filler_init_node.* = .{ | | |
| 2501 | .lhs = ty_node, | | |
| 2502 | .rtoken = try appendToken(rp.c, .RBrace, "}"), | | |
| 2503 | .list_len = 0, | | |
| 2504 | }; | | |
| 2505 | return &filler_init_node.base; | | |
| 2506 | } | 1909 | } |
| 2507 | | 1910 | |
| 2508 | fn transInitListExprArray( | 1911 | fn transInitListExprArray( |
| 2509 | rp: RestorePoint, | 1912 | c: *Context, |
| 2510 | scope: *Scope, | 1913 | scope: *Scope, |
| 2511 | loc: clang.SourceLocation, | 1914 | loc: clang.SourceLocation, |
| 2512 | expr: *const clang.InitListExpr, | 1915 | expr: *const clang.InitListExpr, |
| 2513 | ty: *const clang.Type, | 1916 | ty: *const clang.Type, |
| 2514 | used: ResultUsed, | 1917 | ) TransError!Node { |
| 2515 | ) TransError!*ast.Node { | | |
| 2516 | const arr_type = ty.getAsArrayTypeUnsafe(); | 1918 | const arr_type = ty.getAsArrayTypeUnsafe(); |
| 2517 | const child_qt = arr_type.getElementType(); | 1919 | const child_qt = arr_type.getElementType(); |
| | 1920 | const child_type = try transQualType(c, scope, child_qt, loc); |
| 2518 | const init_count = expr.getNumInits(); | 1921 | const init_count = expr.getNumInits(); |
| 2519 | assert(@ptrCast(*const clang.Type, arr_type).isConstantArrayType()); | 1922 | assert(@ptrCast(*const clang.Type, arr_type).isConstantArrayType()); |
| 2520 | const const_arr_ty = @ptrCast(*const clang.ConstantArrayType, arr_type); | 1923 | const const_arr_ty = @ptrCast(*const clang.ConstantArrayType, arr_type); |
| ... | @@ -2523,125 +1926,83 @@ fn transInitListExprArray( | ... | @@ -2523,125 +1926,83 @@ fn transInitListExprArray( |
| 2523 | const leftover_count = all_count - init_count; | 1926 | const leftover_count = all_count - init_count; |
| 2524 | | 1927 | |
| 2525 | if (all_count == 0) { | 1928 | if (all_count == 0) { |
| 2526 | return transCreateEmptyArray(rp, loc, child_qt.getTypePtr()); | 1929 | return Tag.empty_array.create(c.arena, child_type); |
| 2527 | } | 1930 | } |
| 2528 | | 1931 | |
| 2529 | var init_node: *ast.Node.ArrayInitializer = undefined; | 1932 | const init_node = if (init_count != 0) blk: { |
| 2530 | var cat_tok: ast.TokenIndex = undefined; | 1933 | const init_list = try c.arena.alloc(Node, init_count); |
| 2531 | if (init_count != 0) { | | |
| 2532 | const ty_node = try transCreateNodeArrayType( | | |
| 2533 | rp, | | |
| 2534 | loc, | | |
| 2535 | child_qt.getTypePtr(), | | |
| 2536 | init_count, | | |
| 2537 | ); | | |
| 2538 | _ = try appendToken(rp.c, .LBrace, "{"); | | |
| 2539 | init_node = try ast.Node.ArrayInitializer.alloc(rp.c.arena, init_count); | | |
| 2540 | init_node.* = .{ | | |
| 2541 | .lhs = ty_node, | | |
| 2542 | .rtoken = undefined, | | |
| 2543 | .list_len = init_count, | | |
| 2544 | }; | | |
| 2545 | const init_list = init_node.list(); | | |
| 2546 | | 1934 | |
| 2547 | var i: c_uint = 0; | 1935 | for (init_list) |*init, i| { |
| 2548 | while (i < init_count) : (i += 1) { | 1936 | const elem_expr = expr.getInit(@intCast(c_uint, i)); |
| 2549 | const elem_expr = expr.getInit(i); | 1937 | init.* = try transExprCoercing(c, scope, elem_expr, .used); |
| 2550 | init_list[i] = try transExpr(rp, scope, elem_expr, .used, .r_value); | | |
| 2551 | _ = try appendToken(rp.c, .Comma, ","); | | |
| 2552 | } | 1938 | } |
| 2553 | init_node.rtoken = try appendToken(rp.c, .RBrace, "}"); | 1939 | const init_node = try Tag.array_init.create(c.arena, .{ |
| | 1940 | .cond = try Tag.array_type.create(c.arena, .{ .len = init_count, .elem_type = child_type }), |
| | 1941 | .cases = init_list, |
| | 1942 | }); |
| 2554 | if (leftover_count == 0) { | 1943 | if (leftover_count == 0) { |
| 2555 | return &init_node.base; | 1944 | return init_node; |
| 2556 | } | 1945 | } |
| 2557 | cat_tok = try appendToken(rp.c, .PlusPlus, "++"); | 1946 | break :blk init_node; |
| 2558 | } | 1947 | } else null; |
| 2559 | | 1948 | |
| 2560 | const ty_node = try transCreateNodeArrayType(rp, loc, child_qt.getTypePtr(), 1); | | |
| 2561 | _ = try appendToken(rp.c, .LBrace, "{"); | | |
| 2562 | const filler_init_node = try ast.Node.ArrayInitializer.alloc(rp.c.arena, 1); | | |
| 2563 | filler_init_node.* = .{ | | |
| 2564 | .lhs = ty_node, | | |
| 2565 | .rtoken = undefined, | | |
| 2566 | .list_len = 1, | | |
| 2567 | }; | | |
| 2568 | const filler_val_expr = expr.getArrayFiller(); | 1949 | const filler_val_expr = expr.getArrayFiller(); |
| 2569 | filler_init_node.list()[0] = try transExpr(rp, scope, filler_val_expr, .used, .r_value); | 1950 | const filler_node = try Tag.array_filler.create(c.arena, .{ |
| 2570 | filler_init_node.rtoken = try appendToken(rp.c, .RBrace, "}"); | 1951 | .type = child_type, |
| 2571 | | 1952 | .filler = try transExprCoercing(c, scope, filler_val_expr, .used), |
| 2572 | const rhs_node = if (leftover_count == 1) | 1953 | .count = leftover_count, |
| 2573 | &filler_init_node.base | 1954 | }); |
| 2574 | else blk: { | | |
| 2575 | const mul_tok = try appendToken(rp.c, .AsteriskAsterisk, "**"); | | |
| 2576 | const mul_node = try rp.c.arena.create(ast.Node.SimpleInfixOp); | | |
| 2577 | mul_node.* = .{ | | |
| 2578 | .base = .{ .tag = .ArrayMult }, | | |
| 2579 | .op_token = mul_tok, | | |
| 2580 | .lhs = &filler_init_node.base, | | |
| 2581 | .rhs = try transCreateNodeInt(rp.c, leftover_count), | | |
| 2582 | }; | | |
| 2583 | break :blk &mul_node.base; | | |
| 2584 | }; | | |
| 2585 | | 1955 | |
| 2586 | if (init_count == 0) { | 1956 | if (init_node) |some| { |
| 2587 | return rhs_node; | 1957 | return Tag.array_cat.create(c.arena, .{ .lhs = some, .rhs = filler_node }); |
| | 1958 | } else { |
| | 1959 | return filler_node; |
| 2588 | } | 1960 | } |
| 2589 | | | |
| 2590 | const cat_node = try rp.c.arena.create(ast.Node.SimpleInfixOp); | | |
| 2591 | cat_node.* = .{ | | |
| 2592 | .base = .{ .tag = .ArrayCat }, | | |
| 2593 | .op_token = cat_tok, | | |
| 2594 | .lhs = &init_node.base, | | |
| 2595 | .rhs = rhs_node, | | |
| 2596 | }; | | |
| 2597 | return &cat_node.base; | | |
| 2598 | } | 1961 | } |
| 2599 | | 1962 | |
| 2600 | fn transInitListExpr( | 1963 | fn transInitListExpr( |
| 2601 | rp: RestorePoint, | 1964 | c: *Context, |
| 2602 | scope: *Scope, | 1965 | scope: *Scope, |
| 2603 | expr: *const clang.InitListExpr, | 1966 | expr: *const clang.InitListExpr, |
| 2604 | used: ResultUsed, | 1967 | used: ResultUsed, |
| 2605 | ) TransError!*ast.Node { | 1968 | ) TransError!Node { |
| 2606 | const qt = getExprQualType(rp.c, @ptrCast(*const clang.Expr, expr)); | 1969 | const qt = getExprQualType(c, @ptrCast(*const clang.Expr, expr)); |
| 2607 | var qual_type = qt.getTypePtr(); | 1970 | var qual_type = qt.getTypePtr(); |
| 2608 | const source_loc = @ptrCast(*const clang.Expr, expr).getBeginLoc(); | 1971 | const source_loc = @ptrCast(*const clang.Expr, expr).getBeginLoc(); |
| 2609 | | 1972 | |
| 2610 | if (qual_type.isRecordType()) { | 1973 | if (qual_type.isRecordType()) { |
| 2611 | return transInitListExprRecord( | 1974 | return maybeSuppressResult(c, scope, used, try transInitListExprRecord( |
| 2612 | rp, | 1975 | c, |
| 2613 | scope, | 1976 | scope, |
| 2614 | source_loc, | 1977 | source_loc, |
| 2615 | expr, | 1978 | expr, |
| 2616 | qual_type, | 1979 | qual_type, |
| 2617 | used, | 1980 | )); |
| 2618 | ); | | |
| 2619 | } else if (qual_type.isArrayType()) { | 1981 | } else if (qual_type.isArrayType()) { |
| 2620 | return transInitListExprArray( | 1982 | return maybeSuppressResult(c, scope, used, try transInitListExprArray( |
| 2621 | rp, | 1983 | c, |
| 2622 | scope, | 1984 | scope, |
| 2623 | source_loc, | 1985 | source_loc, |
| 2624 | expr, | 1986 | expr, |
| 2625 | qual_type, | 1987 | qual_type, |
| 2626 | used, | 1988 | )); |
| 2627 | ); | | |
| 2628 | } else { | 1989 | } else { |
| 2629 | const type_name = rp.c.str(qual_type.getTypeClassName()); | 1990 | const type_name = c.str(qual_type.getTypeClassName()); |
| 2630 | return revertAndWarn(rp, error.UnsupportedType, source_loc, "unsupported initlist type: '{s}'", .{type_name}); | 1991 | return fail(c, error.UnsupportedType, source_loc, "unsupported initlist type: '{s}'", .{type_name}); |
| 2631 | } | 1992 | } |
| 2632 | } | 1993 | } |
| 2633 | | 1994 | |
| 2634 | fn transZeroInitExpr( | 1995 | fn transZeroInitExpr( |
| 2635 | rp: RestorePoint, | 1996 | c: *Context, |
| 2636 | scope: *Scope, | 1997 | scope: *Scope, |
| 2637 | source_loc: clang.SourceLocation, | 1998 | source_loc: clang.SourceLocation, |
| 2638 | ty: *const clang.Type, | 1999 | ty: *const clang.Type, |
| 2639 | ) TransError!*ast.Node { | 2000 | ) TransError!Node { |
| 2640 | switch (ty.getTypeClass()) { | 2001 | switch (ty.getTypeClass()) { |
| 2641 | .Builtin => { | 2002 | .Builtin => { |
| 2642 | const builtin_ty = @ptrCast(*const clang.BuiltinType, ty); | 2003 | const builtin_ty = @ptrCast(*const clang.BuiltinType, ty); |
| 2643 | switch (builtin_ty.getKind()) { | 2004 | switch (builtin_ty.getKind()) { |
| 2644 | .Bool => return try transCreateNodeBoolLiteral(rp.c, false), | 2005 | .Bool => return Tag.false_literal.init(), |
| 2645 | .Char_U, | 2006 | .Char_U, |
| 2646 | .UChar, | 2007 | .UChar, |
| 2647 | .Char_S, | 2008 | .Char_S, |
| ... | @@ -2662,126 +2023,112 @@ fn transZeroInitExpr( | ... | @@ -2662,126 +2023,112 @@ fn transZeroInitExpr( |
| 2662 | .Float128, | 2023 | .Float128, |
| 2663 | .Float16, | 2024 | .Float16, |
| 2664 | .LongDouble, | 2025 | .LongDouble, |
| 2665 | => return transCreateNodeInt(rp.c, 0), | 2026 | => return Tag.zero_literal.init(), |
| 2666 | else => return revertAndWarn(rp, error.UnsupportedType, source_loc, "unsupported builtin type", .{}), | 2027 | else => return fail(c, error.UnsupportedType, source_loc, "unsupported builtin type", .{}), |
| 2667 | } | 2028 | } |
| 2668 | }, | 2029 | }, |
| 2669 | .Pointer => return transCreateNodeNullLiteral(rp.c), | 2030 | .Pointer => return Tag.null_literal.init(), |
| 2670 | .Typedef => { | 2031 | .Typedef => { |
| 2671 | const typedef_ty = @ptrCast(*const clang.TypedefType, ty); | 2032 | const typedef_ty = @ptrCast(*const clang.TypedefType, ty); |
| 2672 | const typedef_decl = typedef_ty.getDecl(); | 2033 | const typedef_decl = typedef_ty.getDecl(); |
| 2673 | return transZeroInitExpr( | 2034 | return transZeroInitExpr( |
| 2674 | rp, | 2035 | c, |
| 2675 | scope, | 2036 | scope, |
| 2676 | source_loc, | 2037 | source_loc, |
| 2677 | typedef_decl.getUnderlyingType().getTypePtr(), | 2038 | typedef_decl.getUnderlyingType().getTypePtr(), |
| 2678 | ); | 2039 | ); |
| 2679 | }, | 2040 | }, |
| 2680 | else => {}, | 2041 | else => return Tag.std_mem_zeroes.create(c.arena, try transType(c, scope, ty, source_loc)), |
| 2681 | } | 2042 | } |
| 2682 | | | |
| 2683 | return revertAndWarn(rp, error.UnsupportedType, source_loc, "type does not have an implicit init value", .{}); | | |
| 2684 | } | 2043 | } |
| 2685 | | 2044 | |
| 2686 | fn transImplicitValueInitExpr( | 2045 | fn transImplicitValueInitExpr( |
| 2687 | rp: RestorePoint, | 2046 | c: *Context, |
| 2688 | scope: *Scope, | 2047 | scope: *Scope, |
| 2689 | expr: *const clang.Expr, | 2048 | expr: *const clang.Expr, |
| 2690 | used: ResultUsed, | 2049 | used: ResultUsed, |
| 2691 | ) TransError!*ast.Node { | 2050 | ) TransError!Node { |
| 2692 | const source_loc = expr.getBeginLoc(); | 2051 | const source_loc = expr.getBeginLoc(); |
| 2693 | const qt = getExprQualType(rp.c, expr); | 2052 | const qt = getExprQualType(c, expr); |
| 2694 | const ty = qt.getTypePtr(); | 2053 | const ty = qt.getTypePtr(); |
| 2695 | return transZeroInitExpr(rp, scope, source_loc, ty); | 2054 | return transZeroInitExpr(c, scope, source_loc, ty); |
| 2696 | } | 2055 | } |
| 2697 | | 2056 | |
| 2698 | fn transIfStmt( | 2057 | fn transIfStmt( |
| 2699 | rp: RestorePoint, | 2058 | c: *Context, |
| 2700 | scope: *Scope, | 2059 | scope: *Scope, |
| 2701 | stmt: *const clang.IfStmt, | 2060 | stmt: *const clang.IfStmt, |
| 2702 | ) TransError!*ast.Node { | 2061 | ) TransError!Node { |
| 2703 | // if (c) t | 2062 | // if (c) t |
| 2704 | // if (c) t else e | 2063 | // if (c) t else e |
| 2705 | const if_node = try transCreateNodeIf(rp.c); | | |
| 2706 | | | |
| 2707 | var cond_scope = Scope.Condition{ | 2064 | var cond_scope = Scope.Condition{ |
| 2708 | .base = .{ | 2065 | .base = .{ |
| 2709 | .parent = scope, | 2066 | .parent = scope, |
| 2710 | .id = .Condition, | 2067 | .id = .condition, |
| 2711 | }, | 2068 | }, |
| 2712 | }; | 2069 | }; |
| 2713 | defer cond_scope.deinit(); | 2070 | defer cond_scope.deinit(); |
| 2714 | const cond_expr = @ptrCast(*const clang.Expr, stmt.getCond()); | 2071 | const cond_expr = @ptrCast(*const clang.Expr, stmt.getCond()); |
| 2715 | if_node.condition = try transBoolExpr(rp, &cond_scope.base, cond_expr, .used, .r_value, false); | 2072 | const cond = try transBoolExpr(c, &cond_scope.base, cond_expr, .used); |
| 2716 | _ = try appendToken(rp.c, .RParen, ")"); | | |
| 2717 | | 2073 | |
| 2718 | if_node.body = try transStmt(rp, scope, stmt.getThen(), .unused, .r_value); | 2074 | const then_body = try transStmt(c, scope, stmt.getThen(), .unused); |
| 2719 | | 2075 | const else_body = if (stmt.getElse()) |expr| |
| 2720 | if (stmt.getElse()) |expr| { | 2076 | try transStmt(c, scope, expr, .unused) |
| 2721 | if_node.@"else" = try transCreateNodeElse(rp.c); | 2077 | else |
| 2722 | if_node.@"else".?.body = try transStmt(rp, scope, expr, .unused, .r_value); | 2078 | null; |
| 2723 | } | 2079 | return Tag.@"if".create(c.arena, .{ .cond = cond, .then = then_body, .@"else" = else_body }); |
| 2724 | _ = try appendToken(rp.c, .Semicolon, ";"); | | |
| 2725 | return &if_node.base; | | |
| 2726 | } | 2080 | } |
| 2727 | | 2081 | |
| 2728 | fn transWhileLoop( | 2082 | fn transWhileLoop( |
| 2729 | rp: RestorePoint, | 2083 | c: *Context, |
| 2730 | scope: *Scope, | 2084 | scope: *Scope, |
| 2731 | stmt: *const clang.WhileStmt, | 2085 | stmt: *const clang.WhileStmt, |
| 2732 | ) TransError!*ast.Node { | 2086 | ) TransError!Node { |
| 2733 | const while_node = try transCreateNodeWhile(rp.c); | | |
| 2734 | | | |
| 2735 | var cond_scope = Scope.Condition{ | 2087 | var cond_scope = Scope.Condition{ |
| 2736 | .base = .{ | 2088 | .base = .{ |
| 2737 | .parent = scope, | 2089 | .parent = scope, |
| 2738 | .id = .Condition, | 2090 | .id = .condition, |
| 2739 | }, | 2091 | }, |
| 2740 | }; | 2092 | }; |
| 2741 | defer cond_scope.deinit(); | 2093 | defer cond_scope.deinit(); |
| 2742 | const cond_expr = @ptrCast(*const clang.Expr, stmt.getCond()); | 2094 | const cond_expr = @ptrCast(*const clang.Expr, stmt.getCond()); |
| 2743 | while_node.condition = try transBoolExpr(rp, &cond_scope.base, cond_expr, .used, .r_value, false); | 2095 | const cond = try transBoolExpr(c, &cond_scope.base, cond_expr, .used); |
| 2744 | _ = try appendToken(rp.c, .RParen, ")"); | | |
| 2745 | | 2096 | |
| 2746 | var loop_scope = Scope{ | 2097 | var loop_scope = Scope{ |
| 2747 | .parent = scope, | 2098 | .parent = scope, |
| 2748 | .id = .Loop, | 2099 | .id = .loop, |
| 2749 | }; | 2100 | }; |
| 2750 | while_node.body = try transStmt(rp, &loop_scope, stmt.getBody(), .unused, .r_value); | 2101 | const body = try transStmt(c, &loop_scope, stmt.getBody(), .unused); |
| 2751 | _ = try appendToken(rp.c, .Semicolon, ";"); | 2102 | return Tag.@"while".create(c.arena, .{ .cond = cond, .body = body, .cont_expr = null }); |
| 2752 | return &while_node.base; | | |
| 2753 | } | 2103 | } |
| 2754 | | 2104 | |
| 2755 | fn transDoWhileLoop( | 2105 | fn transDoWhileLoop( |
| 2756 | rp: RestorePoint, | 2106 | c: *Context, |
| 2757 | scope: *Scope, | 2107 | scope: *Scope, |
| 2758 | stmt: *const clang.DoStmt, | 2108 | stmt: *const clang.DoStmt, |
| 2759 | ) TransError!*ast.Node { | 2109 | ) TransError!Node { |
| 2760 | const while_node = try transCreateNodeWhile(rp.c); | | |
| 2761 | | | |
| 2762 | while_node.condition = try transCreateNodeBoolLiteral(rp.c, true); | | |
| 2763 | _ = try appendToken(rp.c, .RParen, ")"); | | |
| 2764 | var new = false; | | |
| 2765 | var loop_scope = Scope{ | 2110 | var loop_scope = Scope{ |
| 2766 | .parent = scope, | 2111 | .parent = scope, |
| 2767 | .id = .Loop, | 2112 | .id = .do_loop, |
| 2768 | }; | 2113 | }; |
| 2769 | | 2114 | |
| 2770 | // if (!cond) break; | 2115 | // if (!cond) break; |
| 2771 | const if_node = try transCreateNodeIf(rp.c); | | |
| 2772 | var cond_scope = Scope.Condition{ | 2116 | var cond_scope = Scope.Condition{ |
| 2773 | .base = .{ | 2117 | .base = .{ |
| 2774 | .parent = scope, | 2118 | .parent = scope, |
| 2775 | .id = .Condition, | 2119 | .id = .condition, |
| 2776 | }, | 2120 | }, |
| 2777 | }; | 2121 | }; |
| 2778 | defer cond_scope.deinit(); | 2122 | defer cond_scope.deinit(); |
| 2779 | const prefix_op = try transCreateNodeSimplePrefixOp(rp.c, .BoolNot, .Bang, "!"); | 2123 | const cond = try transBoolExpr(c, &cond_scope.base, @ptrCast(*const clang.Expr, stmt.getCond()), .used); |
| 2780 | prefix_op.rhs = try transBoolExpr(rp, &cond_scope.base, @ptrCast(*const clang.Expr, stmt.getCond()), .used, .r_value, true); | 2124 | const if_not_break = switch (cond.tag()) { |
| 2781 | _ = try appendToken(rp.c, .RParen, ")"); | 2125 | .false_literal => return transStmt(c, scope, stmt.getBody(), .unused), |
| 2782 | if_node.condition = &prefix_op.base; | 2126 | .true_literal => { |
| 2783 | if_node.body = &(try transCreateNodeBreak(rp.c, null, null)).base; | 2127 | const body_node = try transStmt(c, scope, stmt.getBody(), .unused); |
| 2784 | _ = try appendToken(rp.c, .Semicolon, ";"); | 2128 | return Tag.while_true.create(c.arena, body_node); |
| | 2129 | }, |
| | 2130 | else => try Tag.if_not_break.create(c.arena, cond), |
| | 2131 | }; |
| 2785 | | 2132 | |
| 2786 | const body_node = if (stmt.getBody().getStmtClass() == .CompoundStmtClass) blk: { | 2133 | const body_node = if (stmt.getBody().getStmtClass() == .CompoundStmtClass) blk: { |
| 2787 | // there's already a block in C, so we'll append our condition to it. | 2134 | // there's already a block in C, so we'll append our condition to it. |
| ... | @@ -2794,8 +2141,11 @@ fn transDoWhileLoop( | ... | @@ -2794,8 +2141,11 @@ fn transDoWhileLoop( |
| 2794 | // zig: b; | 2141 | // zig: b; |
| 2795 | // zig: if (!cond) break; | 2142 | // zig: if (!cond) break; |
| 2796 | // zig: } | 2143 | // zig: } |
| 2797 | const node = try transStmt(rp, &loop_scope, stmt.getBody(), .unused, .r_value); | 2144 | const node = try transStmt(c, &loop_scope, stmt.getBody(), .unused); |
| 2798 | break :blk node.castTag(.Block).?; | 2145 | const block = node.castTag(.block).?; |
| | 2146 | block.data.stmts.len += 1; // This is safe since we reserve one extra space in Scope.Block.complete. |
| | 2147 | block.data.stmts[block.data.stmts.len - 1] = if_not_break; |
| | 2148 | break :blk node; |
| 2799 | } else blk: { | 2149 | } else blk: { |
| 2800 | // the C statement is without a block, so we need to create a block to contain it. | 2150 | // the C statement is without a block, so we need to create a block to contain it. |
| 2801 | // c: do | 2151 | // c: do |
| ... | @@ -2805,387 +2155,355 @@ fn transDoWhileLoop( | ... | @@ -2805,387 +2155,355 @@ fn transDoWhileLoop( |
| 2805 | // zig: a; | 2155 | // zig: a; |
| 2806 | // zig: if (!cond) break; | 2156 | // zig: if (!cond) break; |
| 2807 | // zig: } | 2157 | // zig: } |
| 2808 | new = true; | 2158 | const statements = try c.arena.alloc(Node, 2); |
| 2809 | const block = try rp.c.createBlock(2); | 2159 | statements[0] = try transStmt(c, &loop_scope, stmt.getBody(), .unused); |
| 2810 | block.statements_len = 1; // over-allocated so we can add another below | 2160 | statements[1] = if_not_break; |
| 2811 | block.statements()[0] = try transStmt(rp, &loop_scope, stmt.getBody(), .unused, .r_value); | 2161 | break :blk try Tag.block.create(c.arena, .{ .label = null, .stmts = statements }); |
| 2812 | break :blk block; | | |
| 2813 | }; | 2162 | }; |
| 2814 | | 2163 | return Tag.while_true.create(c.arena, body_node); |
| 2815 | // In both cases above, we reserved 1 extra statement. | | |
| 2816 | body_node.statements_len += 1; | | |
| 2817 | body_node.statements()[body_node.statements_len - 1] = &if_node.base; | | |
| 2818 | if (new) | | |
| 2819 | body_node.rbrace = try appendToken(rp.c, .RBrace, "}"); | | |
| 2820 | while_node.body = &body_node.base; | | |
| 2821 | return &while_node.base; | | |
| 2822 | } | 2164 | } |
| 2823 | | 2165 | |
| 2824 | fn transForLoop( | 2166 | fn transForLoop( |
| 2825 | rp: RestorePoint, | 2167 | c: *Context, |
| 2826 | scope: *Scope, | 2168 | scope: *Scope, |
| 2827 | stmt: *const clang.ForStmt, | 2169 | stmt: *const clang.ForStmt, |
| 2828 | ) TransError!*ast.Node { | 2170 | ) TransError!Node { |
| 2829 | var loop_scope = Scope{ | 2171 | var loop_scope = Scope{ |
| 2830 | .parent = scope, | 2172 | .parent = scope, |
| 2831 | .id = .Loop, | 2173 | .id = .loop, |
| 2832 | }; | 2174 | }; |
| 2833 | | 2175 | |
| 2834 | var block_scope: ?Scope.Block = null; | 2176 | var block_scope: ?Scope.Block = null; |
| 2835 | defer if (block_scope) |*bs| bs.deinit(); | 2177 | defer if (block_scope) |*bs| bs.deinit(); |
| 2836 | | 2178 | |
| 2837 | if (stmt.getInit()) |init| { | 2179 | if (stmt.getInit()) |init| { |
| 2838 | block_scope = try Scope.Block.init(rp.c, scope, false); | 2180 | block_scope = try Scope.Block.init(c, scope, false); |
| 2839 | loop_scope.parent = &block_scope.?.base; | 2181 | loop_scope.parent = &block_scope.?.base; |
| 2840 | const init_node = try transStmt(rp, &block_scope.?.base, init, .unused, .r_value); | 2182 | const init_node = try transStmt(c, &block_scope.?.base, init, .unused); |
| 2841 | try block_scope.?.statements.append(init_node); | 2183 | if (init_node.tag() != .declaration) try block_scope.?.statements.append(init_node); |
| 2842 | } | 2184 | } |
| 2843 | var cond_scope = Scope.Condition{ | 2185 | var cond_scope = Scope.Condition{ |
| 2844 | .base = .{ | 2186 | .base = .{ |
| 2845 | .parent = &loop_scope, | 2187 | .parent = &loop_scope, |
| 2846 | .id = .Condition, | 2188 | .id = .condition, |
| 2847 | }, | 2189 | }, |
| 2848 | }; | 2190 | }; |
| 2849 | defer cond_scope.deinit(); | 2191 | defer cond_scope.deinit(); |
| 2850 | | 2192 | |
| 2851 | const while_node = try transCreateNodeWhile(rp.c); | 2193 | const cond = if (stmt.getCond()) |cond| |
| 2852 | while_node.condition = if (stmt.getCond()) |cond| | 2194 | try transBoolExpr(c, &cond_scope.base, cond, .used) |
| 2853 | try transBoolExpr(rp, &cond_scope.base, cond, .used, .r_value, false) | | |
| 2854 | else | 2195 | else |
| 2855 | try transCreateNodeBoolLiteral(rp.c, true); | 2196 | Tag.true_literal.init(); |
| 2856 | _ = try appendToken(rp.c, .RParen, ")"); | | |
| 2857 | | 2197 | |
| 2858 | if (stmt.getInc()) |incr| { | 2198 | const cont_expr = if (stmt.getInc()) |incr| |
| 2859 | _ = try appendToken(rp.c, .Colon, ":"); | 2199 | try transExpr(c, &cond_scope.base, incr, .unused) |
| 2860 | _ = try appendToken(rp.c, .LParen, "("); | 2200 | else |
| 2861 | while_node.continue_expr = try transExpr(rp, &cond_scope.base, incr, .unused, .r_value); | 2201 | null; |
| 2862 | _ = try appendToken(rp.c, .RParen, ")"); | | |
| 2863 | } | | |
| 2864 | | 2202 | |
| 2865 | while_node.body = try transStmt(rp, &loop_scope, stmt.getBody(), .unused, .r_value); | 2203 | const body = try transStmt(c, &loop_scope, stmt.getBody(), .unused); |
| | 2204 | const while_node = try Tag.@"while".create(c.arena, .{ .cond = cond, .body = body, .cont_expr = cont_expr }); |
| 2866 | if (block_scope) |*bs| { | 2205 | if (block_scope) |*bs| { |
| 2867 | try bs.statements.append(&while_node.base); | 2206 | try bs.statements.append(while_node); |
| 2868 | return try bs.complete(rp.c); | 2207 | return try bs.complete(c); |
| 2869 | } else { | 2208 | } else { |
| 2870 | _ = try appendToken(rp.c, .Semicolon, ";"); | 2209 | return while_node; |
| 2871 | return &while_node.base; | | |
| 2872 | } | 2210 | } |
| 2873 | } | 2211 | } |
| 2874 | | 2212 | |
| 2875 | fn getSwitchCaseCount(stmt: *const clang.SwitchStmt) usize { | | |
| 2876 | const body = stmt.getBody(); | | |
| 2877 | assert(body.getStmtClass() == .CompoundStmtClass); | | |
| 2878 | const comp = @ptrCast(*const clang.CompoundStmt, body); | | |
| 2879 | // TODO https://github.com/ziglang/zig/issues/1738 | | |
| 2880 | // return comp.body_end() - comp.body_begin(); | | |
| 2881 | const start_addr = @ptrToInt(comp.body_begin()); | | |
| 2882 | const end_addr = @ptrToInt(comp.body_end()); | | |
| 2883 | return (end_addr - start_addr) / @sizeOf(*clang.Stmt); | | |
| 2884 | } | | |
| 2885 | | | |
| 2886 | fn transSwitch( | 2213 | fn transSwitch( |
| 2887 | rp: RestorePoint, | 2214 | c: *Context, |
| 2888 | scope: *Scope, | 2215 | scope: *Scope, |
| 2889 | stmt: *const clang.SwitchStmt, | 2216 | stmt: *const clang.SwitchStmt, |
| 2890 | ) TransError!*ast.Node { | 2217 | ) TransError!Node { |
| 2891 | const switch_tok = try appendToken(rp.c, .Keyword_switch, "switch"); | | |
| 2892 | _ = try appendToken(rp.c, .LParen, "("); | | |
| 2893 | | | |
| 2894 | const cases_len = getSwitchCaseCount(stmt); | | |
| 2895 | | | |
| 2896 | var cond_scope = Scope.Condition{ | 2218 | var cond_scope = Scope.Condition{ |
| 2897 | .base = .{ | 2219 | .base = .{ |
| 2898 | .parent = scope, | 2220 | .parent = scope, |
| 2899 | .id = .Condition, | 2221 | .id = .condition, |
| 2900 | }, | 2222 | }, |
| 2901 | }; | 2223 | }; |
| 2902 | defer cond_scope.deinit(); | 2224 | defer cond_scope.deinit(); |
| 2903 | const switch_expr = try transExpr(rp, &cond_scope.base, stmt.getCond(), .used, .r_value); | 2225 | const switch_expr = try transExpr(c, &cond_scope.base, stmt.getCond(), .used); |
| 2904 | _ = try appendToken(rp.c, .RParen, ")"); | | |
| 2905 | _ = try appendToken(rp.c, .LBrace, "{"); | | |
| 2906 | // reserve +1 case in case there is no default case | | |
| 2907 | const switch_node = try ast.Node.Switch.alloc(rp.c.arena, cases_len + 1); | | |
| 2908 | switch_node.* = .{ | | |
| 2909 | .switch_token = switch_tok, | | |
| 2910 | .expr = switch_expr, | | |
| 2911 | .cases_len = cases_len + 1, | | |
| 2912 | .rbrace = try appendToken(rp.c, .RBrace, "}"), | | |
| 2913 | }; | | |
| 2914 | | 2226 | |
| 2915 | var switch_scope = Scope.Switch{ | 2227 | var cases = std.ArrayList(Node).init(c.gpa); |
| 2916 | .base = .{ | 2228 | defer cases.deinit(); |
| 2917 | .id = .Switch, | 2229 | var has_default = false; |
| 2918 | .parent = scope, | | |
| 2919 | }, | | |
| 2920 | .cases = switch_node.cases(), | | |
| 2921 | .case_index = 0, | | |
| 2922 | .pending_block = undefined, | | |
| 2923 | .default_label = null, | | |
| 2924 | .switch_label = null, | | |
| 2925 | }; | | |
| 2926 | | 2230 | |
| 2927 | // tmp block that all statements will go before being picked up by a case or default | 2231 | const body = stmt.getBody(); |
| 2928 | var block_scope = try Scope.Block.init(rp.c, &switch_scope.base, false); | 2232 | assert(body.getStmtClass() == .CompoundStmtClass); |
| 2929 | defer block_scope.deinit(); | 2233 | const compound_stmt = @ptrCast(*const clang.CompoundStmt, body); |
| | 2234 | var it = compound_stmt.body_begin(); |
| | 2235 | const end_it = compound_stmt.body_end(); |
| | 2236 | // Iterate over switch body and collect all cases. |
| | 2237 | // Fallthrough is handled by duplicating statements. |
| | 2238 | while (it != end_it) : (it += 1) { |
| | 2239 | switch (it[0].getStmtClass()) { |
| | 2240 | .CaseStmtClass => { |
| | 2241 | var items = std.ArrayList(Node).init(c.gpa); |
| | 2242 | defer items.deinit(); |
| | 2243 | const sub = try transCaseStmt(c, scope, it[0], &items); |
| | 2244 | const res = try transSwitchProngStmt(c, scope, sub, it, end_it); |
| | 2245 | |
| | 2246 | if (items.items.len == 0) { |
| | 2247 | has_default = true; |
| | 2248 | const switch_else = try Tag.switch_else.create(c.arena, res); |
| | 2249 | try cases.append(switch_else); |
| | 2250 | } else { |
| | 2251 | const switch_prong = try Tag.switch_prong.create(c.arena, .{ |
| | 2252 | .cases = try c.arena.dupe(Node, items.items), |
| | 2253 | .cond = res, |
| | 2254 | }); |
| | 2255 | try cases.append(switch_prong); |
| | 2256 | } |
| | 2257 | }, |
| | 2258 | .DefaultStmtClass => { |
| | 2259 | has_default = true; |
| | 2260 | const default_stmt = @ptrCast(*const clang.DefaultStmt, it[0]); |
| | 2261 | |
| | 2262 | var sub = default_stmt.getSubStmt(); |
| | 2263 | while (true) switch (sub.getStmtClass()) { |
| | 2264 | .CaseStmtClass => sub = @ptrCast(*const clang.CaseStmt, sub).getSubStmt(), |
| | 2265 | .DefaultStmtClass => sub = @ptrCast(*const clang.DefaultStmt, sub).getSubStmt(), |
| | 2266 | else => break, |
| | 2267 | }; |
| 2930 | | 2268 | |
| 2931 | // Note that we do not defer a deinit here; the switch_scope.pending_block field | 2269 | const res = try transSwitchProngStmt(c, scope, sub, it, end_it); |
| 2932 | // has its own memory management. This resource is freed inside `transCase` and | | |
| 2933 | // then the final pending_block is freed at the bottom of this function with | | |
| 2934 | // pending_block.deinit(). | | |
| 2935 | switch_scope.pending_block = try Scope.Block.init(rp.c, scope, false); | | |
| 2936 | try switch_scope.pending_block.statements.append(&switch_node.base); | | |
| 2937 | | | |
| 2938 | const last = try transStmt(rp, &block_scope.base, stmt.getBody(), .unused, .r_value); | | |
| 2939 | _ = try appendToken(rp.c, .Semicolon, ";"); | | |
| 2940 | | | |
| 2941 | // take all pending statements | | |
| 2942 | const last_block_stmts = last.cast(ast.Node.Block).?.statements(); | | |
| 2943 | try switch_scope.pending_block.statements.ensureCapacity( | | |
| 2944 | switch_scope.pending_block.statements.items.len + last_block_stmts.len, | | |
| 2945 | ); | | |
| 2946 | for (last_block_stmts) |n| { | | |
| 2947 | switch_scope.pending_block.statements.appendAssumeCapacity(n); | | |
| 2948 | } | | |
| 2949 | | | |
| 2950 | if (switch_scope.default_label == null) { | | |
| 2951 | switch_scope.switch_label = try block_scope.makeMangledName(rp.c, "switch"); | | |
| 2952 | } | | |
| 2953 | if (switch_scope.switch_label) |l| { | | |
| 2954 | switch_scope.pending_block.label = try appendIdentifier(rp.c, l); | | |
| 2955 | _ = try appendToken(rp.c, .Colon, ":"); | | |
| 2956 | } | | |
| 2957 | if (switch_scope.default_label == null) { | | |
| 2958 | const else_prong = try transCreateNodeSwitchCase(rp.c, try transCreateNodeSwitchElse(rp.c)); | | |
| 2959 | else_prong.expr = blk: { | | |
| 2960 | var br = try CtrlFlow.init(rp.c, .Break, switch_scope.switch_label.?); | | |
| 2961 | break :blk &(try br.finish(null)).base; | | |
| 2962 | }; | | |
| 2963 | _ = try appendToken(rp.c, .Comma, ","); | | |
| 2964 | | 2270 | |
| 2965 | if (switch_scope.case_index >= switch_scope.cases.len) | 2271 | const switch_else = try Tag.switch_else.create(c.arena, res); |
| 2966 | return revertAndWarn(rp, error.UnsupportedTranslation, @ptrCast(*const clang.Stmt, stmt).getBeginLoc(), "TODO complex switch cases", .{}); | 2272 | try cases.append(switch_else); |
| 2967 | switch_scope.cases[switch_scope.case_index] = &else_prong.base; | 2273 | }, |
| 2968 | switch_scope.case_index += 1; | 2274 | else => {}, // collected in transSwitchProngStmt |
| | 2275 | } |
| 2969 | } | 2276 | } |
| 2970 | // We overallocated in case there was no default, so now we correct | | |
| 2971 | // the number of cases in the AST node. | | |
| 2972 | switch_node.cases_len = switch_scope.case_index; | | |
| 2973 | | 2277 | |
| 2974 | const result_node = try switch_scope.pending_block.complete(rp.c); | 2278 | if (!has_default) { |
| 2975 | switch_scope.pending_block.deinit(); | 2279 | const else_prong = try Tag.switch_else.create(c.arena, Tag.@"break".init()); |
| 2976 | return result_node; | 2280 | try cases.append(else_prong); |
| 2977 | } | 2281 | } |
| 2978 | | | |
| 2979 | fn transCase( | | |
| 2980 | rp: RestorePoint, | | |
| 2981 | scope: *Scope, | | |
| 2982 | stmt: *const clang.CaseStmt, | | |
| 2983 | ) TransError!*ast.Node { | | |
| 2984 | const block_scope = scope.findBlockScope(rp.c) catch unreachable; | | |
| 2985 | const switch_scope = scope.getSwitch(); | | |
| 2986 | const label = try block_scope.makeMangledName(rp.c, "case"); | | |
| 2987 | _ = try appendToken(rp.c, .Semicolon, ";"); | | |
| 2988 | | | |
| 2989 | const expr = if (stmt.getRHS()) |rhs| blk: { | | |
| 2990 | const lhs_node = try transExpr(rp, scope, stmt.getLHS(), .used, .r_value); | | |
| 2991 | const ellips = try appendToken(rp.c, .Ellipsis3, "..."); | | |
| 2992 | const rhs_node = try transExpr(rp, scope, rhs, .used, .r_value); | | |
| 2993 | | | |
| 2994 | const node = try rp.c.arena.create(ast.Node.SimpleInfixOp); | | |
| 2995 | node.* = .{ | | |
| 2996 | .base = .{ .tag = .Range }, | | |
| 2997 | .op_token = ellips, | | |
| 2998 | .lhs = lhs_node, | | |
| 2999 | .rhs = rhs_node, | | |
| 3000 | }; | | |
| 3001 | break :blk &node.base; | | |
| 3002 | } else | | |
| 3003 | try transExpr(rp, scope, stmt.getLHS(), .used, .r_value); | | |
| 3004 | | | |
| 3005 | const switch_prong = try transCreateNodeSwitchCase(rp.c, expr); | | |
| 3006 | switch_prong.expr = blk: { | | |
| 3007 | var br = try CtrlFlow.init(rp.c, .Break, label); | | |
| 3008 | break :blk &(try br.finish(null)).base; | | |
| 3009 | }; | | |
| 3010 | _ = try appendToken(rp.c, .Comma, ","); | | |
| 3011 | | 2282 | |
| 3012 | if (switch_scope.case_index >= switch_scope.cases.len) | 2283 | return Tag.@"switch".create(c.arena, .{ |
| 3013 | return revertAndWarn(rp, error.UnsupportedTranslation, @ptrCast(*const clang.Stmt, stmt).getBeginLoc(), "TODO complex switch cases", .{}); | 2284 | .cond = switch_expr, |
| 3014 | switch_scope.cases[switch_scope.case_index] = &switch_prong.base; | 2285 | .cases = try c.arena.dupe(Node, cases.items), |
| 3015 | switch_scope.case_index += 1; | 2286 | }); |
| | 2287 | } |
| 3016 | | 2288 | |
| 3017 | switch_scope.pending_block.label = try appendIdentifier(rp.c, label); | 2289 | /// Collects all items for this case, returns the first statement after the labels. |
| 3018 | _ = try appendToken(rp.c, .Colon, ":"); | 2290 | /// If items ends up empty, the prong should be translated as an else. |
| | 2291 | fn transCaseStmt(c: *Context, scope: *Scope, stmt: *const clang.Stmt, items: *std.ArrayList(Node)) TransError!*const clang.Stmt { |
| | 2292 | var sub = stmt; |
| | 2293 | var seen_default = false; |
| | 2294 | while (true) { |
| | 2295 | switch (sub.getStmtClass()) { |
| | 2296 | .DefaultStmtClass => { |
| | 2297 | seen_default = true; |
| | 2298 | items.items.len = 0; |
| | 2299 | const default_stmt = @ptrCast(*const clang.DefaultStmt, sub); |
| | 2300 | sub = default_stmt.getSubStmt(); |
| | 2301 | }, |
| | 2302 | .CaseStmtClass => { |
| | 2303 | const case_stmt = @ptrCast(*const clang.CaseStmt, sub); |
| 3019 | | 2304 | |
| 3020 | // take all pending statements | 2305 | if (seen_default) { |
| 3021 | try switch_scope.pending_block.statements.appendSlice(block_scope.statements.items); | 2306 | items.items.len = 0; |
| 3022 | block_scope.statements.shrinkAndFree(0); | 2307 | sub = case_stmt.getSubStmt(); |
| | 2308 | continue; |
| | 2309 | } |
| 3023 | | 2310 | |
| 3024 | const pending_node = try switch_scope.pending_block.complete(rp.c); | 2311 | const expr = if (case_stmt.getRHS()) |rhs| blk: { |
| 3025 | switch_scope.pending_block.deinit(); | 2312 | const lhs_node = try transExprCoercing(c, scope, case_stmt.getLHS(), .used); |
| 3026 | switch_scope.pending_block = try Scope.Block.init(rp.c, scope, false); | 2313 | const rhs_node = try transExprCoercing(c, scope, rhs, .used); |
| 3027 | | 2314 | |
| 3028 | try switch_scope.pending_block.statements.append(pending_node); | 2315 | break :blk try Tag.ellipsis3.create(c.arena, .{ .lhs = lhs_node, .rhs = rhs_node }); |
| | 2316 | } else |
| | 2317 | try transExprCoercing(c, scope, case_stmt.getLHS(), .used); |
| 3029 | | 2318 | |
| 3030 | return transStmt(rp, scope, stmt.getSubStmt(), .unused, .r_value); | 2319 | try items.append(expr); |
| | 2320 | sub = case_stmt.getSubStmt(); |
| | 2321 | }, |
| | 2322 | else => return sub, |
| | 2323 | } |
| | 2324 | } |
| 3031 | } | 2325 | } |
| 3032 | | 2326 | |
| 3033 | fn transDefault( | 2327 | /// Collects all statements seen by this case into a block. |
| 3034 | rp: RestorePoint, | 2328 | /// Avoids creating a block if the first statement is a break or return. |
| | 2329 | fn transSwitchProngStmt( |
| | 2330 | c: *Context, |
| 3035 | scope: *Scope, | 2331 | scope: *Scope, |
| 3036 | stmt: *const clang.DefaultStmt, | 2332 | stmt: *const clang.Stmt, |
| 3037 | ) TransError!*ast.Node { | 2333 | parent_it: clang.CompoundStmt.ConstBodyIterator, |
| 3038 | const block_scope = scope.findBlockScope(rp.c) catch unreachable; | 2334 | parent_end_it: clang.CompoundStmt.ConstBodyIterator, |
| 3039 | const switch_scope = scope.getSwitch(); | 2335 | ) TransError!Node { |
| 3040 | switch_scope.default_label = try block_scope.makeMangledName(rp.c, "default"); | 2336 | switch (stmt.getStmtClass()) { |
| 3041 | _ = try appendToken(rp.c, .Semicolon, ";"); | 2337 | .BreakStmtClass => return Tag.empty_block.init(), |
| 3042 | | 2338 | .ReturnStmtClass => return transStmt(c, scope, stmt, .unused), |
| 3043 | const else_prong = try transCreateNodeSwitchCase(rp.c, try transCreateNodeSwitchElse(rp.c)); | 2339 | .CaseStmtClass, .DefaultStmtClass => unreachable, |
| 3044 | else_prong.expr = blk: { | 2340 | else => { |
| 3045 | var br = try CtrlFlow.init(rp.c, .Break, switch_scope.default_label.?); | 2341 | var block_scope = try Scope.Block.init(c, scope, false); |
| 3046 | break :blk &(try br.finish(null)).base; | 2342 | defer block_scope.deinit(); |
| 3047 | }; | | |
| 3048 | _ = try appendToken(rp.c, .Comma, ","); | | |
| 3049 | | | |
| 3050 | if (switch_scope.case_index >= switch_scope.cases.len) | | |
| 3051 | return revertAndWarn(rp, error.UnsupportedTranslation, @ptrCast(*const clang.Stmt, stmt).getBeginLoc(), "TODO complex switch cases", .{}); | | |
| 3052 | switch_scope.cases[switch_scope.case_index] = &else_prong.base; | | |
| 3053 | switch_scope.case_index += 1; | | |
| 3054 | | | |
| 3055 | switch_scope.pending_block.label = try appendIdentifier(rp.c, switch_scope.default_label.?); | | |
| 3056 | _ = try appendToken(rp.c, .Colon, ":"); | | |
| 3057 | | | |
| 3058 | // take all pending statements | | |
| 3059 | try switch_scope.pending_block.statements.appendSlice(block_scope.statements.items); | | |
| 3060 | block_scope.statements.shrinkAndFree(0); | | |
| 3061 | | 2343 | |
| 3062 | const pending_node = try switch_scope.pending_block.complete(rp.c); | 2344 | // we do not need to translate `stmt` since it is the first stmt of `parent_it` |
| 3063 | switch_scope.pending_block.deinit(); | 2345 | try transSwitchProngStmtInline(c, &block_scope, parent_it, parent_end_it); |
| 3064 | switch_scope.pending_block = try Scope.Block.init(rp.c, scope, false); | 2346 | return try block_scope.complete(c); |
| 3065 | try switch_scope.pending_block.statements.append(pending_node); | 2347 | }, |
| | 2348 | } |
| | 2349 | } |
| 3066 | | 2350 | |
| 3067 | return transStmt(rp, scope, stmt.getSubStmt(), .unused, .r_value); | 2351 | /// Collects all statements seen by this case into a block. |
| | 2352 | fn transSwitchProngStmtInline( |
| | 2353 | c: *Context, |
| | 2354 | block: *Scope.Block, |
| | 2355 | start_it: clang.CompoundStmt.ConstBodyIterator, |
| | 2356 | end_it: clang.CompoundStmt.ConstBodyIterator, |
| | 2357 | ) TransError!void { |
| | 2358 | var it = start_it; |
| | 2359 | while (it != end_it) : (it += 1) { |
| | 2360 | switch (it[0].getStmtClass()) { |
| | 2361 | .ReturnStmtClass => { |
| | 2362 | const result = try transStmt(c, &block.base, it[0], .unused); |
| | 2363 | try block.statements.append(result); |
| | 2364 | return; |
| | 2365 | }, |
| | 2366 | .BreakStmtClass => return, |
| | 2367 | .CaseStmtClass => { |
| | 2368 | var sub = @ptrCast(*const clang.CaseStmt, it[0]).getSubStmt(); |
| | 2369 | while (true) switch (sub.getStmtClass()) { |
| | 2370 | .CaseStmtClass => sub = @ptrCast(*const clang.CaseStmt, sub).getSubStmt(), |
| | 2371 | .DefaultStmtClass => sub = @ptrCast(*const clang.DefaultStmt, sub).getSubStmt(), |
| | 2372 | else => break, |
| | 2373 | }; |
| | 2374 | const result = try transStmt(c, &block.base, sub, .unused); |
| | 2375 | assert(result.tag() != .declaration); |
| | 2376 | try block.statements.append(result); |
| | 2377 | }, |
| | 2378 | .DefaultStmtClass => { |
| | 2379 | var sub = @ptrCast(*const clang.DefaultStmt, it[0]).getSubStmt(); |
| | 2380 | while (true) switch (sub.getStmtClass()) { |
| | 2381 | .CaseStmtClass => sub = @ptrCast(*const clang.CaseStmt, sub).getSubStmt(), |
| | 2382 | .DefaultStmtClass => sub = @ptrCast(*const clang.DefaultStmt, sub).getSubStmt(), |
| | 2383 | else => break, |
| | 2384 | }; |
| | 2385 | const result = try transStmt(c, &block.base, sub, .unused); |
| | 2386 | assert(result.tag() != .declaration); |
| | 2387 | try block.statements.append(result); |
| | 2388 | }, |
| | 2389 | .CompoundStmtClass => { |
| | 2390 | const compound_stmt = @ptrCast(*const clang.CompoundStmt, it[0]); |
| | 2391 | var child_block = try Scope.Block.init(c, &block.base, false); |
| | 2392 | defer child_block.deinit(); |
| | 2393 | |
| | 2394 | try transCompoundStmtInline(c, compound_stmt, &child_block); |
| | 2395 | const result = try child_block.complete(c); |
| | 2396 | try block.statements.append(result); |
| | 2397 | if (result.isNoreturn(true)) { |
| | 2398 | return; |
| | 2399 | } |
| | 2400 | }, |
| | 2401 | else => { |
| | 2402 | const result = try transStmt(c, &block.base, it[0], .unused); |
| | 2403 | switch (result.tag()) { |
| | 2404 | .declaration, .empty_block => {}, |
| | 2405 | else => try block.statements.append(result), |
| | 2406 | } |
| | 2407 | }, |
| | 2408 | } |
| | 2409 | } |
| | 2410 | return; |
| 3068 | } | 2411 | } |
| 3069 | | 2412 | |
| 3070 | fn transConstantExpr(rp: RestorePoint, scope: *Scope, expr: *const clang.Expr, used: ResultUsed) TransError!*ast.Node { | 2413 | fn transConstantExpr(c: *Context, scope: *Scope, expr: *const clang.Expr, used: ResultUsed) TransError!Node { |
| 3071 | var result: clang.ExprEvalResult = undefined; | 2414 | var result: clang.ExprEvalResult = undefined; |
| 3072 | if (!expr.EvaluateAsConstantExpr(&result, .EvaluateForCodeGen, rp.c.clang_context)) | 2415 | if (!expr.evaluateAsConstantExpr(&result, .EvaluateForCodeGen, c.clang_context)) |
| 3073 | return revertAndWarn(rp, error.UnsupportedTranslation, expr.getBeginLoc(), "invalid constant expression", .{}); | 2416 | return fail(c, error.UnsupportedTranslation, expr.getBeginLoc(), "invalid constant expression", .{}); |
| 3074 | | 2417 | |
| 3075 | var val_node: ?*ast.Node = null; | | |
| 3076 | switch (result.Val.getKind()) { | 2418 | switch (result.Val.getKind()) { |
| 3077 | .Int => { | 2419 | .Int => { |
| 3078 | // See comment in `transIntegerLiteral` for why this code is here. | 2420 | // See comment in `transIntegerLiteral` for why this code is here. |
| 3079 | // @as(T, x) | 2421 | // @as(T, x) |
| 3080 | const expr_base = @ptrCast(*const clang.Expr, expr); | 2422 | const expr_base = @ptrCast(*const clang.Expr, expr); |
| 3081 | const as_node = try rp.c.createBuiltinCall("@as", 2); | 2423 | const as_node = try Tag.as.create(c.arena, .{ |
| 3082 | const ty_node = try transQualType(rp, expr_base.getType(), expr_base.getBeginLoc()); | 2424 | .lhs = try transQualType(c, scope, expr_base.getType(), expr_base.getBeginLoc()), |
| 3083 | as_node.params()[0] = ty_node; | 2425 | .rhs = try transCreateNodeAPInt(c, result.Val.getInt()), |
| 3084 | _ = try appendToken(rp.c, .Comma, ","); | 2426 | }); |
| 3085 | | 2427 | return maybeSuppressResult(c, scope, used, as_node); |
| 3086 | const int_lit_node = try transCreateNodeAPInt(rp.c, result.Val.getInt()); | | |
| 3087 | as_node.params()[1] = int_lit_node; | | |
| 3088 | | | |
| 3089 | as_node.rparen_token = try appendToken(rp.c, .RParen, ")"); | | |
| 3090 | | | |
| 3091 | return maybeSuppressResult(rp, scope, used, &as_node.base); | | |
| 3092 | }, | 2428 | }, |
| 3093 | else => { | 2429 | else => { |
| 3094 | return revertAndWarn(rp, error.UnsupportedTranslation, expr.getBeginLoc(), "unsupported constant expression kind", .{}); | 2430 | return fail(c, error.UnsupportedTranslation, expr.getBeginLoc(), "unsupported constant expression kind", .{}); |
| 3095 | }, | 2431 | }, |
| 3096 | } | 2432 | } |
| 3097 | } | 2433 | } |
| 3098 | | 2434 | |
| 3099 | fn transPredefinedExpr(rp: RestorePoint, scope: *Scope, expr: *const clang.PredefinedExpr, used: ResultUsed) TransError!*ast.Node { | 2435 | fn transPredefinedExpr(c: *Context, scope: *Scope, expr: *const clang.PredefinedExpr, used: ResultUsed) TransError!Node { |
| 3100 | return transStringLiteral(rp, scope, expr.getFunctionName(), used); | 2436 | return transStringLiteral(c, scope, expr.getFunctionName(), used); |
| 3101 | } | 2437 | } |
| 3102 | | 2438 | |
| 3103 | fn transCreateCharLitNode(c: *Context, narrow: bool, val: u32) TransError!*ast.Node { | 2439 | fn transCreateCharLitNode(c: *Context, narrow: bool, val: u32) TransError!Node { |
| 3104 | const node = try c.arena.create(ast.Node.OneToken); | 2440 | return Tag.char_literal.create(c.arena, if (narrow) |
| 3105 | node.* = .{ | 2441 | try std.fmt.allocPrint(c.arena, "'{s}'", .{std.zig.fmtEscapes(&.{@intCast(u8, val)})}) |
| 3106 | .base = .{ .tag = .CharLiteral }, | 2442 | else |
| 3107 | .token = undefined, | 2443 | try std.fmt.allocPrint(c.arena, "'\\u{{{x}}}'", .{val})); |
| 3108 | }; | | |
| 3109 | if (narrow) { | | |
| 3110 | const val_array = [_]u8{@intCast(u8, val)}; | | |
| 3111 | node.token = try appendTokenFmt(c, .CharLiteral, "'{}'", .{std.zig.fmtEscapes(&val_array)}); | | |
| 3112 | } else { | | |
| 3113 | node.token = try appendTokenFmt(c, .CharLiteral, "'\\u{{{x}}}'", .{val}); | | |
| 3114 | } | | |
| 3115 | return &node.base; | | |
| 3116 | } | 2444 | } |
| 3117 | | 2445 | |
| 3118 | fn transCharLiteral( | 2446 | fn transCharLiteral( |
| 3119 | rp: RestorePoint, | 2447 | c: *Context, |
| 3120 | scope: *Scope, | 2448 | scope: *Scope, |
| 3121 | stmt: *const clang.CharacterLiteral, | 2449 | stmt: *const clang.CharacterLiteral, |
| 3122 | result_used: ResultUsed, | 2450 | result_used: ResultUsed, |
| 3123 | suppress_as: SuppressCast, | 2451 | suppress_as: SuppressCast, |
| 3124 | ) TransError!*ast.Node { | 2452 | ) TransError!Node { |
| 3125 | const kind = stmt.getKind(); | 2453 | const kind = stmt.getKind(); |
| 3126 | const val = stmt.getValue(); | 2454 | const val = stmt.getValue(); |
| 3127 | const narrow = kind == .Ascii or kind == .UTF8; | 2455 | const narrow = kind == .Ascii or kind == .UTF8; |
| 3128 | // C has a somewhat obscure feature called multi-character character constant | 2456 | // C has a somewhat obscure feature called multi-character character constant |
| 3129 | // e.g. 'abcd' | 2457 | // e.g. 'abcd' |
| 3130 | const int_lit_node = if (kind == .Ascii and val > 255) | 2458 | const int_lit_node = if (kind == .Ascii and val > 255) |
| 3131 | try transCreateNodeInt(rp.c, val) | 2459 | try transCreateNodeNumber(c, val, .int) |
| 3132 | else | 2460 | else |
| 3133 | try transCreateCharLitNode(rp.c, narrow, val); | 2461 | try transCreateCharLitNode(c, narrow, val); |
| 3134 | | 2462 | |
| 3135 | if (suppress_as == .no_as) { | 2463 | if (suppress_as == .no_as) { |
| 3136 | return maybeSuppressResult(rp, scope, result_used, int_lit_node); | 2464 | return maybeSuppressResult(c, scope, result_used, int_lit_node); |
| 3137 | } | 2465 | } |
| 3138 | // See comment in `transIntegerLiteral` for why this code is here. | 2466 | // See comment in `transIntegerLiteral` for why this code is here. |
| 3139 | // @as(T, x) | 2467 | // @as(T, x) |
| 3140 | const expr_base = @ptrCast(*const clang.Expr, stmt); | 2468 | const expr_base = @ptrCast(*const clang.Expr, stmt); |
| 3141 | const as_node = try rp.c.createBuiltinCall("@as", 2); | 2469 | const as_node = try Tag.as.create(c.arena, .{ |
| 3142 | const ty_node = try transQualType(rp, expr_base.getType(), expr_base.getBeginLoc()); | 2470 | .lhs = try transQualType(c, scope, expr_base.getType(), expr_base.getBeginLoc()), |
| 3143 | as_node.params()[0] = ty_node; | 2471 | .rhs = int_lit_node, |
| 3144 | _ = try appendToken(rp.c, .Comma, ","); | 2472 | }); |
| 3145 | as_node.params()[1] = int_lit_node; | 2473 | return maybeSuppressResult(c, scope, result_used, as_node); |
| 3146 | | | |
| 3147 | as_node.rparen_token = try appendToken(rp.c, .RParen, ")"); | | |
| 3148 | return maybeSuppressResult(rp, scope, result_used, &as_node.base); | | |
| 3149 | } | 2474 | } |
| 3150 | | 2475 | |
| 3151 | fn transStmtExpr(rp: RestorePoint, scope: *Scope, stmt: *const clang.StmtExpr, used: ResultUsed) TransError!*ast.Node { | 2476 | fn transStmtExpr(c: *Context, scope: *Scope, stmt: *const clang.StmtExpr, used: ResultUsed) TransError!Node { |
| 3152 | const comp = stmt.getSubStmt(); | 2477 | const comp = stmt.getSubStmt(); |
| 3153 | if (used == .unused) { | 2478 | if (used == .unused) { |
| 3154 | return transCompoundStmt(rp, scope, comp); | 2479 | return transCompoundStmt(c, scope, comp); |
| 3155 | } | 2480 | } |
| 3156 | const lparen = try appendToken(rp.c, .LParen, "("); | 2481 | var block_scope = try Scope.Block.init(c, scope, true); |
| 3157 | var block_scope = try Scope.Block.init(rp.c, scope, true); | | |
| 3158 | defer block_scope.deinit(); | 2482 | defer block_scope.deinit(); |
| 3159 | | 2483 | |
| 3160 | var it = comp.body_begin(); | 2484 | var it = comp.body_begin(); |
| 3161 | const end_it = comp.body_end(); | 2485 | const end_it = comp.body_end(); |
| 3162 | while (it != end_it - 1) : (it += 1) { | 2486 | while (it != end_it - 1) : (it += 1) { |
| 3163 | const result = try transStmt(rp, &block_scope.base, it[0], .unused, .r_value); | 2487 | const result = try transStmt(c, &block_scope.base, it[0], .unused); |
| 3164 | try block_scope.statements.append(result); | 2488 | switch (result.tag()) { |
| | 2489 | .declaration, .empty_block => {}, |
| | 2490 | else => try block_scope.statements.append(result), |
| | 2491 | } |
| 3165 | } | 2492 | } |
| 3166 | const break_node = blk: { | 2493 | const break_node = try Tag.break_val.create(c.arena, .{ |
| 3167 | var tmp = try CtrlFlow.init(rp.c, .Break, "blk"); | 2494 | .label = block_scope.label, |
| 3168 | const rhs = try transStmt(rp, &block_scope.base, it[0], .used, .r_value); | 2495 | .val = try transStmt(c, &block_scope.base, it[0], .used), |
| 3169 | break :blk try tmp.finish(rhs); | 2496 | }); |
| 3170 | }; | 2497 | try block_scope.statements.append(break_node); |
| 3171 | _ = try appendToken(rp.c, .Semicolon, ";"); | 2498 | const res = try block_scope.complete(c); |
| 3172 | try block_scope.statements.append(&break_node.base); | 2499 | return maybeSuppressResult(c, scope, used, res); |
| 3173 | const block_node = try block_scope.complete(rp.c); | | |
| 3174 | const rparen = try appendToken(rp.c, .RParen, ")"); | | |
| 3175 | const grouped_expr = try rp.c.arena.create(ast.Node.GroupedExpression); | | |
| 3176 | grouped_expr.* = .{ | | |
| 3177 | .lparen = lparen, | | |
| 3178 | .expr = block_node, | | |
| 3179 | .rparen = rparen, | | |
| 3180 | }; | | |
| 3181 | return maybeSuppressResult(rp, scope, used, &grouped_expr.base); | | |
| 3182 | } | 2500 | } |
| 3183 | | 2501 | |
| 3184 | fn transMemberExpr(rp: RestorePoint, scope: *Scope, stmt: *const clang.MemberExpr, result_used: ResultUsed) TransError!*ast.Node { | 2502 | fn transMemberExpr(c: *Context, scope: *Scope, stmt: *const clang.MemberExpr, result_used: ResultUsed) TransError!Node { |
| 3185 | var container_node = try transExpr(rp, scope, stmt.getBase(), .used, .r_value); | 2503 | var container_node = try transExpr(c, scope, stmt.getBase(), .used); |
| 3186 | | 2504 | |
| 3187 | if (stmt.isArrow()) { | 2505 | if (stmt.isArrow()) { |
| 3188 | container_node = try transCreateNodePtrDeref(rp.c, container_node); | 2506 | container_node = try Tag.deref.create(c.arena, container_node); |
| 3189 | } | 2507 | } |
| 3190 | | 2508 | |
| 3191 | const member_decl = stmt.getMemberDecl(); | 2509 | const member_decl = stmt.getMemberDecl(); |
| ... | @@ -3196,19 +2514,18 @@ fn transMemberExpr(rp: RestorePoint, scope: *Scope, stmt: *const clang.MemberExp | ... | @@ -3196,19 +2514,18 @@ fn transMemberExpr(rp: RestorePoint, scope: *Scope, stmt: *const clang.MemberExp |
| 3196 | if (decl_kind == .Field) { | 2514 | if (decl_kind == .Field) { |
| 3197 | const field_decl = @ptrCast(*const clang.FieldDecl, member_decl); | 2515 | const field_decl = @ptrCast(*const clang.FieldDecl, member_decl); |
| 3198 | if (field_decl.isAnonymousStructOrUnion()) { | 2516 | if (field_decl.isAnonymousStructOrUnion()) { |
| 3199 | const name = rp.c.decl_table.get(@ptrToInt(field_decl.getCanonicalDecl())).?; | 2517 | const name = c.decl_table.get(@ptrToInt(field_decl.getCanonicalDecl())).?; |
| 3200 | break :blk try mem.dupe(rp.c.arena, u8, name); | 2518 | break :blk try mem.dupe(c.arena, u8, name); |
| 3201 | } | 2519 | } |
| 3202 | } | 2520 | } |
| 3203 | const decl = @ptrCast(*const clang.NamedDecl, member_decl); | 2521 | const decl = @ptrCast(*const clang.NamedDecl, member_decl); |
| 3204 | break :blk try rp.c.str(decl.getName_bytes_begin()); | 2522 | break :blk try c.str(decl.getName_bytes_begin()); |
| 3205 | }; | 2523 | }; |
| 3206 | | 2524 | const node = try Tag.field_access.create(c.arena, .{ .lhs = container_node, .field_name = name }); |
| 3207 | const node = try transCreateNodeFieldAccess(rp.c, container_node, name); | 2525 | return maybeSuppressResult(c, scope, result_used, node); |
| 3208 | return maybeSuppressResult(rp, scope, result_used, node); | | |
| 3209 | } | 2526 | } |
| 3210 | | 2527 | |
| 3211 | fn transArrayAccess(rp: RestorePoint, scope: *Scope, stmt: *const clang.ArraySubscriptExpr, result_used: ResultUsed) TransError!*ast.Node { | 2528 | fn transArrayAccess(c: *Context, scope: *Scope, stmt: *const clang.ArraySubscriptExpr, result_used: ResultUsed) TransError!Node { |
| 3212 | var base_stmt = stmt.getBase(); | 2529 | var base_stmt = stmt.getBase(); |
| 3213 | | 2530 | |
| 3214 | // Unwrap the base statement if it's an array decayed to a bare pointer type | 2531 | // Unwrap the base statement if it's an array decayed to a bare pointer type |
| ... | @@ -3221,30 +2538,26 @@ fn transArrayAccess(rp: RestorePoint, scope: *Scope, stmt: *const clang.ArraySub | ... | @@ -3221,30 +2538,26 @@ fn transArrayAccess(rp: RestorePoint, scope: *Scope, stmt: *const clang.ArraySub |
| 3221 | } | 2538 | } |
| 3222 | } | 2539 | } |
| 3223 | | 2540 | |
| 3224 | const container_node = try transExpr(rp, scope, base_stmt, .used, .r_value); | 2541 | const container_node = try transExpr(c, scope, base_stmt, .used); |
| 3225 | const node = try transCreateNodeArrayAccess(rp.c, container_node); | | |
| 3226 | | 2542 | |
| 3227 | // cast if the index is long long or signed | 2543 | // cast if the index is long long or signed |
| 3228 | const subscr_expr = stmt.getIdx(); | 2544 | const subscr_expr = stmt.getIdx(); |
| 3229 | const qt = getExprQualType(rp.c, subscr_expr); | 2545 | const qt = getExprQualType(c, subscr_expr); |
| 3230 | const is_longlong = cIsLongLongInteger(qt); | 2546 | const is_longlong = cIsLongLongInteger(qt); |
| 3231 | const is_signed = cIsSignedInteger(qt); | 2547 | const is_signed = cIsSignedInteger(qt); |
| 3232 | | 2548 | |
| 3233 | if (is_longlong or is_signed) { | 2549 | const rhs = if (is_longlong or is_signed) blk: { |
| 3234 | const cast_node = try rp.c.createBuiltinCall("@intCast", 2); | | |
| 3235 | // check if long long first so that signed long long doesn't just become unsigned long long | 2550 | // check if long long first so that signed long long doesn't just become unsigned long long |
| 3236 | var typeid_node = if (is_longlong) try transCreateNodeIdentifier(rp.c, "usize") else try transQualTypeIntWidthOf(rp.c, qt, false); | 2551 | var typeid_node = if (is_longlong) try Tag.identifier.create(c.arena, "usize") else try transQualTypeIntWidthOf(c, qt, false); |
| 3237 | cast_node.params()[0] = typeid_node; | 2552 | break :blk try Tag.int_cast.create(c.arena, .{ .lhs = typeid_node, .rhs = try transExpr(c, scope, subscr_expr, .used) }); |
| 3238 | _ = try appendToken(rp.c, .Comma, ","); | 2553 | } else |
| 3239 | cast_node.params()[1] = try transExpr(rp, scope, subscr_expr, .used, .r_value); | 2554 | try transExpr(c, scope, subscr_expr, .used); |
| 3240 | cast_node.rparen_token = try appendToken(rp.c, .RParen, ")"); | 2555 | |
| 3241 | node.rtoken = try appendToken(rp.c, .RBrace, "]"); | 2556 | const node = try Tag.array_access.create(c.arena, .{ |
| 3242 | node.index_expr = &cast_node.base; | 2557 | .lhs = container_node, |
| 3243 | } else { | 2558 | .rhs = rhs, |
| 3244 | node.index_expr = try transExpr(rp, scope, subscr_expr, .used, .r_value); | 2559 | }); |
| 3245 | node.rtoken = try appendToken(rp.c, .RBrace, "]"); | 2560 | return maybeSuppressResult(c, scope, result_used, node); |
| 3246 | } | | |
| 3247 | return maybeSuppressResult(rp, scope, result_used, &node.base); | | |
| 3248 | } | 2561 | } |
| 3249 | | 2562 | |
| 3250 | /// Check if an expression is ultimately a reference to a function declaration | 2563 | /// Check if an expression is ultimately a reference to a function declaration |
| ... | @@ -3279,29 +2592,25 @@ fn cIsFunctionDeclRef(expr: *const clang.Expr) bool { | ... | @@ -3279,29 +2592,25 @@ fn cIsFunctionDeclRef(expr: *const clang.Expr) bool { |
| 3279 | } | 2592 | } |
| 3280 | } | 2593 | } |
| 3281 | | 2594 | |
| 3282 | fn transCallExpr(rp: RestorePoint, scope: *Scope, stmt: *const clang.CallExpr, result_used: ResultUsed) TransError!*ast.Node { | 2595 | fn transCallExpr(c: *Context, scope: *Scope, stmt: *const clang.CallExpr, result_used: ResultUsed) TransError!Node { |
| 3283 | const callee = stmt.getCallee(); | 2596 | const callee = stmt.getCallee(); |
| 3284 | var raw_fn_expr = try transExpr(rp, scope, callee, .used, .r_value); | 2597 | var raw_fn_expr = try transExpr(c, scope, callee, .used); |
| 3285 | | 2598 | |
| 3286 | var is_ptr = false; | 2599 | var is_ptr = false; |
| 3287 | const fn_ty = qualTypeGetFnProto(callee.getType(), &is_ptr); | 2600 | const fn_ty = qualTypeGetFnProto(callee.getType(), &is_ptr); |
| 3288 | | 2601 | |
| 3289 | const fn_expr = if (is_ptr and fn_ty != null and !cIsFunctionDeclRef(callee)) | 2602 | const fn_expr = if (is_ptr and fn_ty != null and !cIsFunctionDeclRef(callee)) |
| 3290 | try transCreateNodeUnwrapNull(rp.c, raw_fn_expr) | 2603 | try Tag.unwrap.create(c.arena, raw_fn_expr) |
| 3291 | else | 2604 | else |
| 3292 | raw_fn_expr; | 2605 | raw_fn_expr; |
| 3293 | | 2606 | |
| 3294 | const num_args = stmt.getNumArgs(); | 2607 | const num_args = stmt.getNumArgs(); |
| 3295 | const node = try rp.c.createCall(fn_expr, num_args); | 2608 | const args = try c.arena.alloc(Node, num_args); |
| 3296 | const call_params = node.params(); | | |
| 3297 | | 2609 | |
| 3298 | const args = stmt.getArgs(); | 2610 | const c_args = stmt.getArgs(); |
| 3299 | var i: usize = 0; | 2611 | var i: usize = 0; |
| 3300 | while (i < num_args) : (i += 1) { | 2612 | while (i < num_args) : (i += 1) { |
| 3301 | if (i != 0) { | 2613 | var arg = try transExpr(c, scope, c_args[i], .used); |
| 3302 | _ = try appendToken(rp.c, .Comma, ","); | | |
| 3303 | } | | |
| 3304 | var call_param = try transExpr(rp, scope, args[i], .used, .r_value); | | |
| 3305 | | 2614 | |
| 3306 | // In C the result type of a boolean expression is int. If this result is passed as | 2615 | // In C the result type of a boolean expression is int. If this result is passed as |
| 3307 | // an argument to a function whose parameter is also int, there is no cast. Therefore | 2616 | // an argument to a function whose parameter is also int, there is no cast. Therefore |
| ... | @@ -3312,31 +2621,26 @@ fn transCallExpr(rp: RestorePoint, scope: *Scope, stmt: *const clang.CallExpr, r | ... | @@ -3312,31 +2621,26 @@ fn transCallExpr(rp: RestorePoint, scope: *Scope, stmt: *const clang.CallExpr, r |
| 3312 | const param_count = fn_proto.getNumParams(); | 2621 | const param_count = fn_proto.getNumParams(); |
| 3313 | if (i < param_count) { | 2622 | if (i < param_count) { |
| 3314 | const param_qt = fn_proto.getParamType(@intCast(c_uint, i)); | 2623 | const param_qt = fn_proto.getParamType(@intCast(c_uint, i)); |
| 3315 | if (isBoolRes(call_param) and cIsNativeInt(param_qt)) { | 2624 | if (isBoolRes(arg) and cIsNativeInt(param_qt)) { |
| 3316 | const builtin_node = try rp.c.createBuiltinCall("@boolToInt", 1); | 2625 | arg = try Tag.bool_to_int.create(c.arena, arg); |
| 3317 | builtin_node.params()[0] = call_param; | | |
| 3318 | builtin_node.rparen_token = try appendToken(rp.c, .RParen, ")"); | | |
| 3319 | call_param = &builtin_node.base; | | |
| 3320 | } | 2626 | } |
| 3321 | } | 2627 | } |
| 3322 | }, | 2628 | }, |
| 3323 | else => {}, | 2629 | else => {}, |
| 3324 | } | 2630 | } |
| 3325 | } | 2631 | } |
| 3326 | call_params[i] = call_param; | 2632 | args[i] = arg; |
| 3327 | } | 2633 | } |
| 3328 | node.rtoken = try appendToken(rp.c, .RParen, ")"); | 2634 | const node = try Tag.call.create(c.arena, .{ .lhs = fn_expr, .args = args }); |
| 3329 | | | |
| 3330 | if (fn_ty) |ty| { | 2635 | if (fn_ty) |ty| { |
| 3331 | const canon = ty.getReturnType().getCanonicalType(); | 2636 | const canon = ty.getReturnType().getCanonicalType(); |
| 3332 | const ret_ty = canon.getTypePtr(); | 2637 | const ret_ty = canon.getTypePtr(); |
| 3333 | if (ret_ty.isVoidType()) { | 2638 | if (ret_ty.isVoidType()) { |
| 3334 | _ = try appendToken(rp.c, .Semicolon, ";"); | 2639 | return node; |
| 3335 | return &node.base; | | |
| 3336 | } | 2640 | } |
| 3337 | } | 2641 | } |
| 3338 | | 2642 | |
| 3339 | return maybeSuppressResult(rp, scope, result_used, &node.base); | 2643 | return maybeSuppressResult(c, scope, result_used, node); |
| 3340 | } | 2644 | } |
| 3341 | | 2645 | |
| 3342 | const ClangFunctionType = union(enum) { | 2646 | const ClangFunctionType = union(enum) { |
| ... | @@ -3371,38 +2675,29 @@ fn qualTypeGetFnProto(qt: clang.QualType, is_ptr: *bool) ?ClangFunctionType { | ... | @@ -3371,38 +2675,29 @@ fn qualTypeGetFnProto(qt: clang.QualType, is_ptr: *bool) ?ClangFunctionType { |
| 3371 | } | 2675 | } |
| 3372 | | 2676 | |
| 3373 | fn transUnaryExprOrTypeTraitExpr( | 2677 | fn transUnaryExprOrTypeTraitExpr( |
| 3374 | rp: RestorePoint, | 2678 | c: *Context, |
| 3375 | scope: *Scope, | 2679 | scope: *Scope, |
| 3376 | stmt: *const clang.UnaryExprOrTypeTraitExpr, | 2680 | stmt: *const clang.UnaryExprOrTypeTraitExpr, |
| 3377 | result_used: ResultUsed, | 2681 | result_used: ResultUsed, |
| 3378 | ) TransError!*ast.Node { | 2682 | ) TransError!Node { |
| 3379 | const loc = stmt.getBeginLoc(); | 2683 | const loc = stmt.getBeginLoc(); |
| 3380 | const type_node = try transQualType( | 2684 | const type_node = try transQualType(c, scope, stmt.getTypeOfArgument(), loc); |
| 3381 | rp, | | |
| 3382 | stmt.getTypeOfArgument(), | | |
| 3383 | loc, | | |
| 3384 | ); | | |
| 3385 | | 2685 | |
| 3386 | const kind = stmt.getKind(); | 2686 | const kind = stmt.getKind(); |
| 3387 | const kind_str = switch (kind) { | 2687 | switch (kind) { |
| 3388 | .SizeOf => "@sizeOf", | 2688 | .SizeOf => return Tag.sizeof.create(c.arena, type_node), |
| 3389 | .AlignOf => "@alignOf", | 2689 | .AlignOf => return Tag.alignof.create(c.arena, type_node), |
| 3390 | .PreferredAlignOf, | 2690 | .PreferredAlignOf, |
| 3391 | .VecStep, | 2691 | .VecStep, |
| 3392 | .OpenMPRequiredSimdAlign, | 2692 | .OpenMPRequiredSimdAlign, |
| 3393 | => return revertAndWarn( | 2693 | => return fail( |
| 3394 | rp, | 2694 | c, |
| 3395 | error.UnsupportedTranslation, | 2695 | error.UnsupportedTranslation, |
| 3396 | loc, | 2696 | loc, |
| 3397 | "Unsupported type trait kind {}", | 2697 | "Unsupported type trait kind {}", |
| 3398 | .{kind}, | 2698 | .{kind}, |
| 3399 | ), | 2699 | ), |
| 3400 | }; | 2700 | } |
| 3401 | | | |
| 3402 | const builtin_node = try rp.c.createBuiltinCall(kind_str, 1); | | |
| 3403 | builtin_node.params()[0] = type_node; | | |
| 3404 | builtin_node.rparen_token = try appendToken(rp.c, .RParen, ")"); | | |
| 3405 | return maybeSuppressResult(rp, scope, result_used, &builtin_node.base); | | |
| 3406 | } | 2701 | } |
| 3407 | | 2702 | |
| 3408 | fn qualTypeHasWrappingOverflow(qt: clang.QualType) bool { | 2703 | fn qualTypeHasWrappingOverflow(qt: clang.QualType) bool { |
| ... | @@ -3415,95 +2710,79 @@ fn qualTypeHasWrappingOverflow(qt: clang.QualType) bool { | ... | @@ -3415,95 +2710,79 @@ fn qualTypeHasWrappingOverflow(qt: clang.QualType) bool { |
| 3415 | } | 2710 | } |
| 3416 | } | 2711 | } |
| 3417 | | 2712 | |
| 3418 | fn transUnaryOperator(rp: RestorePoint, scope: *Scope, stmt: *const clang.UnaryOperator, used: ResultUsed) TransError!*ast.Node { | 2713 | fn transUnaryOperator(c: *Context, scope: *Scope, stmt: *const clang.UnaryOperator, used: ResultUsed) TransError!Node { |
| 3419 | const op_expr = stmt.getSubExpr(); | 2714 | const op_expr = stmt.getSubExpr(); |
| 3420 | switch (stmt.getOpcode()) { | 2715 | switch (stmt.getOpcode()) { |
| 3421 | .PostInc => if (qualTypeHasWrappingOverflow(stmt.getType())) | 2716 | .PostInc => if (qualTypeHasWrappingOverflow(stmt.getType())) |
| 3422 | return transCreatePostCrement(rp, scope, stmt, .AssignAddWrap, .PlusPercentEqual, "+%=", used) | 2717 | return transCreatePostCrement(c, scope, stmt, .add_wrap_assign, used) |
| 3423 | else | 2718 | else |
| 3424 | return transCreatePostCrement(rp, scope, stmt, .AssignAdd, .PlusEqual, "+=", used), | 2719 | return transCreatePostCrement(c, scope, stmt, .add_assign, used), |
| 3425 | .PostDec => if (qualTypeHasWrappingOverflow(stmt.getType())) | 2720 | .PostDec => if (qualTypeHasWrappingOverflow(stmt.getType())) |
| 3426 | return transCreatePostCrement(rp, scope, stmt, .AssignSubWrap, .MinusPercentEqual, "-%=", used) | 2721 | return transCreatePostCrement(c, scope, stmt, .sub_wrap_assign, used) |
| 3427 | else | 2722 | else |
| 3428 | return transCreatePostCrement(rp, scope, stmt, .AssignSub, .MinusEqual, "-=", used), | 2723 | return transCreatePostCrement(c, scope, stmt, .sub_assign, used), |
| 3429 | .PreInc => if (qualTypeHasWrappingOverflow(stmt.getType())) | 2724 | .PreInc => if (qualTypeHasWrappingOverflow(stmt.getType())) |
| 3430 | return transCreatePreCrement(rp, scope, stmt, .AssignAddWrap, .PlusPercentEqual, "+%=", used) | 2725 | return transCreatePreCrement(c, scope, stmt, .add_wrap_assign, used) |
| 3431 | else | 2726 | else |
| 3432 | return transCreatePreCrement(rp, scope, stmt, .AssignAdd, .PlusEqual, "+=", used), | 2727 | return transCreatePreCrement(c, scope, stmt, .add_assign, used), |
| 3433 | .PreDec => if (qualTypeHasWrappingOverflow(stmt.getType())) | 2728 | .PreDec => if (qualTypeHasWrappingOverflow(stmt.getType())) |
| 3434 | return transCreatePreCrement(rp, scope, stmt, .AssignSubWrap, .MinusPercentEqual, "-%=", used) | 2729 | return transCreatePreCrement(c, scope, stmt, .sub_wrap_assign, used) |
| 3435 | else | 2730 | else |
| 3436 | return transCreatePreCrement(rp, scope, stmt, .AssignSub, .MinusEqual, "-=", used), | 2731 | return transCreatePreCrement(c, scope, stmt, .sub_assign, used), |
| 3437 | .AddrOf => { | 2732 | .AddrOf => { |
| 3438 | if (cIsFunctionDeclRef(op_expr)) { | 2733 | if (cIsFunctionDeclRef(op_expr)) { |
| 3439 | return transExpr(rp, scope, op_expr, used, .r_value); | 2734 | return transExpr(c, scope, op_expr, used); |
| 3440 | } | 2735 | } |
| 3441 | const op_node = try transCreateNodeSimplePrefixOp(rp.c, .AddressOf, .Ampersand, "&"); | 2736 | return Tag.address_of.create(c.arena, try transExpr(c, scope, op_expr, used)); |
| 3442 | op_node.rhs = try transExpr(rp, scope, op_expr, used, .r_value); | | |
| 3443 | return &op_node.base; | | |
| 3444 | }, | 2737 | }, |
| 3445 | .Deref => { | 2738 | .Deref => { |
| 3446 | const value_node = try transExpr(rp, scope, op_expr, used, .r_value); | 2739 | const node = try transExpr(c, scope, op_expr, used); |
| 3447 | var is_ptr = false; | 2740 | var is_ptr = false; |
| 3448 | const fn_ty = qualTypeGetFnProto(op_expr.getType(), &is_ptr); | 2741 | const fn_ty = qualTypeGetFnProto(op_expr.getType(), &is_ptr); |
| 3449 | if (fn_ty != null and is_ptr) | 2742 | if (fn_ty != null and is_ptr) |
| 3450 | return value_node; | 2743 | return node; |
| 3451 | const unwrapped = try transCreateNodeUnwrapNull(rp.c, value_node); | 2744 | const unwrapped = try Tag.unwrap.create(c.arena, node); |
| 3452 | return transCreateNodePtrDeref(rp.c, unwrapped); | 2745 | return Tag.deref.create(c.arena, unwrapped); |
| 3453 | }, | 2746 | }, |
| 3454 | .Plus => return transExpr(rp, scope, op_expr, used, .r_value), | 2747 | .Plus => return transExpr(c, scope, op_expr, used), |
| 3455 | .Minus => { | 2748 | .Minus => { |
| 3456 | if (!qualTypeHasWrappingOverflow(op_expr.getType())) { | 2749 | if (!qualTypeHasWrappingOverflow(op_expr.getType())) { |
| 3457 | const op_node = try transCreateNodeSimplePrefixOp(rp.c, .Negation, .Minus, "-"); | 2750 | return Tag.negate.create(c.arena, try transExpr(c, scope, op_expr, .used)); |
| 3458 | op_node.rhs = try transExpr(rp, scope, op_expr, .used, .r_value); | | |
| 3459 | return &op_node.base; | | |
| 3460 | } else if (cIsUnsignedInteger(op_expr.getType())) { | 2751 | } else if (cIsUnsignedInteger(op_expr.getType())) { |
| 3461 | // we gotta emit 0 -% x | 2752 | // use -% x for unsigned integers |
| 3462 | const zero = try transCreateNodeInt(rp.c, 0); | 2753 | return Tag.negate_wrap.create(c.arena, try transExpr(c, scope, op_expr, .used)); |
| 3463 | const token = try appendToken(rp.c, .MinusPercent, "-%"); | | |
| 3464 | const expr = try transExpr(rp, scope, op_expr, .used, .r_value); | | |
| 3465 | return transCreateNodeInfixOp(rp, scope, zero, .SubWrap, token, expr, used, true); | | |
| 3466 | } else | 2754 | } else |
| 3467 | return revertAndWarn(rp, error.UnsupportedTranslation, stmt.getBeginLoc(), "C negation with non float non integer", .{}); | 2755 | return fail(c, error.UnsupportedTranslation, stmt.getBeginLoc(), "C negation with non float non integer", .{}); |
| 3468 | }, | 2756 | }, |
| 3469 | .Not => { | 2757 | .Not => { |
| 3470 | const op_node = try transCreateNodeSimplePrefixOp(rp.c, .BitNot, .Tilde, "~"); | 2758 | return Tag.bit_not.create(c.arena, try transExpr(c, scope, op_expr, .used)); |
| 3471 | op_node.rhs = try transExpr(rp, scope, op_expr, .used, .r_value); | | |
| 3472 | return &op_node.base; | | |
| 3473 | }, | 2759 | }, |
| 3474 | .LNot => { | 2760 | .LNot => { |
| 3475 | const op_node = try transCreateNodeSimplePrefixOp(rp.c, .BoolNot, .Bang, "!"); | 2761 | return Tag.not.create(c.arena, try transBoolExpr(c, scope, op_expr, .used)); |
| 3476 | op_node.rhs = try transBoolExpr(rp, scope, op_expr, .used, .r_value, true); | | |
| 3477 | return &op_node.base; | | |
| 3478 | }, | 2762 | }, |
| 3479 | .Extension => { | 2763 | .Extension => { |
| 3480 | return transExpr(rp, scope, stmt.getSubExpr(), used, .l_value); | 2764 | return transExpr(c, scope, stmt.getSubExpr(), used); |
| 3481 | }, | 2765 | }, |
| 3482 | else => return revertAndWarn(rp, error.UnsupportedTranslation, stmt.getBeginLoc(), "unsupported C translation {}", .{stmt.getOpcode()}), | 2766 | else => return fail(c, error.UnsupportedTranslation, stmt.getBeginLoc(), "unsupported C translation {}", .{stmt.getOpcode()}), |
| 3483 | } | 2767 | } |
| 3484 | } | 2768 | } |
| 3485 | | 2769 | |
| 3486 | fn transCreatePreCrement( | 2770 | fn transCreatePreCrement( |
| 3487 | rp: RestorePoint, | 2771 | c: *Context, |
| 3488 | scope: *Scope, | 2772 | scope: *Scope, |
| 3489 | stmt: *const clang.UnaryOperator, | 2773 | stmt: *const clang.UnaryOperator, |
| 3490 | op: ast.Node.Tag, | 2774 | op: Tag, |
| 3491 | op_tok_id: std.zig.Token.Id, | | |
| 3492 | bytes: []const u8, | | |
| 3493 | used: ResultUsed, | 2775 | used: ResultUsed, |
| 3494 | ) TransError!*ast.Node { | 2776 | ) TransError!Node { |
| 3495 | const op_expr = stmt.getSubExpr(); | 2777 | const op_expr = stmt.getSubExpr(); |
| 3496 | | 2778 | |
| 3497 | if (used == .unused) { | 2779 | if (used == .unused) { |
| 3498 | // common case | 2780 | // common case |
| 3499 | // c: ++expr | 2781 | // c: ++expr |
| 3500 | // zig: expr += 1 | 2782 | // zig: expr += 1 |
| 3501 | const expr = try transExpr(rp, scope, op_expr, .used, .r_value); | 2783 | const lhs = try transExpr(c, scope, op_expr, .used); |
| 3502 | const token = try appendToken(rp.c, op_tok_id, bytes); | 2784 | const rhs = Tag.one_literal.init(); |
| 3503 | const one = try transCreateNodeInt(rp.c, 1); | 2785 | return transCreateNodeInfixOp(c, scope, op, lhs, rhs, .used); |
| 3504 | if (scope.id != .Condition) | | |
| 3505 | _ = try appendToken(rp.c, .Semicolon, ";"); | | |
| 3506 | return transCreateNodeInfixOp(rp, scope, expr, op, token, one, .used, false); | | |
| 3507 | } | 2786 | } |
| 3508 | // worst case | 2787 | // worst case |
| 3509 | // c: ++expr | 2788 | // c: ++expr |
| ... | @@ -3512,71 +2791,44 @@ fn transCreatePreCrement( | ... | @@ -3512,71 +2791,44 @@ fn transCreatePreCrement( |
| 3512 | // zig: _ref.* += 1; | 2791 | // zig: _ref.* += 1; |
| 3513 | // zig: break :blk _ref.* | 2792 | // zig: break :blk _ref.* |
| 3514 | // zig: }) | 2793 | // zig: }) |
| 3515 | var block_scope = try Scope.Block.init(rp.c, scope, true); | 2794 | var block_scope = try Scope.Block.init(c, scope, true); |
| 3516 | defer block_scope.deinit(); | 2795 | defer block_scope.deinit(); |
| 3517 | const ref = try block_scope.makeMangledName(rp.c, "ref"); | 2796 | const ref = try block_scope.makeMangledName(c, "ref"); |
| 3518 | | | |
| 3519 | const mut_tok = try appendToken(rp.c, .Keyword_const, "const"); | | |
| 3520 | const name_tok = try appendIdentifier(rp.c, ref); | | |
| 3521 | const eq_token = try appendToken(rp.c, .Equal, "="); | | |
| 3522 | const rhs_node = try transCreateNodeSimplePrefixOp(rp.c, .AddressOf, .Ampersand, "&"); | | |
| 3523 | rhs_node.rhs = try transExpr(rp, scope, op_expr, .used, .r_value); | | |
| 3524 | const init_node = &rhs_node.base; | | |
| 3525 | const semicolon_token = try appendToken(rp.c, .Semicolon, ";"); | | |
| 3526 | const node = try ast.Node.VarDecl.create(rp.c.arena, .{ | | |
| 3527 | .name_token = name_tok, | | |
| 3528 | .mut_token = mut_tok, | | |
| 3529 | .semicolon_token = semicolon_token, | | |
| 3530 | }, .{ | | |
| 3531 | .eq_token = eq_token, | | |
| 3532 | .init_node = init_node, | | |
| 3533 | }); | | |
| 3534 | try block_scope.statements.append(&node.base); | | |
| 3535 | | | |
| 3536 | const lhs_node = try transCreateNodeIdentifier(rp.c, ref); | | |
| 3537 | const ref_node = try transCreateNodePtrDeref(rp.c, lhs_node); | | |
| 3538 | _ = try appendToken(rp.c, .Semicolon, ";"); | | |
| 3539 | const token = try appendToken(rp.c, op_tok_id, bytes); | | |
| 3540 | const one = try transCreateNodeInt(rp.c, 1); | | |
| 3541 | _ = try appendToken(rp.c, .Semicolon, ";"); | | |
| 3542 | const assign = try transCreateNodeInfixOp(rp, scope, ref_node, op, token, one, .used, false); | | |
| 3543 | try block_scope.statements.append(assign); | | |
| 3544 | | 2797 | |
| 3545 | const break_node = try transCreateNodeBreak(rp.c, block_scope.label, ref_node); | 2798 | const expr = try transExpr(c, &block_scope.base, op_expr, .used); |
| 3546 | try block_scope.statements.append(&break_node.base); | 2799 | const addr_of = try Tag.address_of.create(c.arena, expr); |
| 3547 | const block_node = try block_scope.complete(rp.c); | 2800 | const ref_decl = try Tag.var_simple.create(c.arena, .{ .name = ref, .init = addr_of }); |
| 3548 | // semicolon must immediately follow rbrace because it is the last token in a block | 2801 | try block_scope.statements.append(ref_decl); |
| 3549 | _ = try appendToken(rp.c, .Semicolon, ";"); | 2802 | |
| 3550 | const grouped_expr = try rp.c.arena.create(ast.Node.GroupedExpression); | 2803 | const lhs_node = try Tag.identifier.create(c.arena, ref); |
| 3551 | grouped_expr.* = .{ | 2804 | const ref_node = try Tag.deref.create(c.arena, lhs_node); |
| 3552 | .lparen = try appendToken(rp.c, .LParen, "("), | 2805 | const node = try transCreateNodeInfixOp(c, &block_scope.base, op, ref_node, Tag.one_literal.init(), .used); |
| 3553 | .expr = block_node, | 2806 | try block_scope.statements.append(node); |
| 3554 | .rparen = try appendToken(rp.c, .RParen, ")"), | 2807 | |
| 3555 | }; | 2808 | const break_node = try Tag.break_val.create(c.arena, .{ |
| 3556 | return &grouped_expr.base; | 2809 | .label = block_scope.label, |
| | 2810 | .val = ref_node, |
| | 2811 | }); |
| | 2812 | try block_scope.statements.append(break_node); |
| | 2813 | return block_scope.complete(c); |
| 3557 | } | 2814 | } |
| 3558 | | 2815 | |
| 3559 | fn transCreatePostCrement( | 2816 | fn transCreatePostCrement( |
| 3560 | rp: RestorePoint, | 2817 | c: *Context, |
| 3561 | scope: *Scope, | 2818 | scope: *Scope, |
| 3562 | stmt: *const clang.UnaryOperator, | 2819 | stmt: *const clang.UnaryOperator, |
| 3563 | op: ast.Node.Tag, | 2820 | op: Tag, |
| 3564 | op_tok_id: std.zig.Token.Id, | | |
| 3565 | bytes: []const u8, | | |
| 3566 | used: ResultUsed, | 2821 | used: ResultUsed, |
| 3567 | ) TransError!*ast.Node { | 2822 | ) TransError!Node { |
| 3568 | const op_expr = stmt.getSubExpr(); | 2823 | const op_expr = stmt.getSubExpr(); |
| 3569 | | 2824 | |
| 3570 | if (used == .unused) { | 2825 | if (used == .unused) { |
| 3571 | // common case | 2826 | // common case |
| 3572 | // c: ++expr | 2827 | // c: expr++ |
| 3573 | // zig: expr += 1 | 2828 | // zig: expr += 1 |
| 3574 | const expr = try transExpr(rp, scope, op_expr, .used, .r_value); | 2829 | const lhs = try transExpr(c, scope, op_expr, .used); |
| 3575 | const token = try appendToken(rp.c, op_tok_id, bytes); | 2830 | const rhs = Tag.one_literal.init(); |
| 3576 | const one = try transCreateNodeInt(rp.c, 1); | 2831 | return transCreateNodeInfixOp(c, scope, op, lhs, rhs, .used); |
| 3577 | if (scope.id != .Condition) | | |
| 3578 | _ = try appendToken(rp.c, .Semicolon, ";"); | | |
| 3579 | return transCreateNodeInfixOp(rp, scope, expr, op, token, one, .used, false); | | |
| 3580 | } | 2832 | } |
| 3581 | // worst case | 2833 | // worst case |
| 3582 | // c: expr++ | 2834 | // c: expr++ |
| ... | @@ -3586,93 +2838,56 @@ fn transCreatePostCrement( | ... | @@ -3586,93 +2838,56 @@ fn transCreatePostCrement( |
| 3586 | // zig: _ref.* += 1; | 2838 | // zig: _ref.* += 1; |
| 3587 | // zig: break :blk _tmp | 2839 | // zig: break :blk _tmp |
| 3588 | // zig: }) | 2840 | // zig: }) |
| 3589 | var block_scope = try Scope.Block.init(rp.c, scope, true); | 2841 | var block_scope = try Scope.Block.init(c, scope, true); |
| 3590 | defer block_scope.deinit(); | 2842 | defer block_scope.deinit(); |
| 3591 | const ref = try block_scope.makeMangledName(rp.c, "ref"); | 2843 | const ref = try block_scope.makeMangledName(c, "ref"); |
| 3592 | | | |
| 3593 | const mut_tok = try appendToken(rp.c, .Keyword_const, "const"); | | |
| 3594 | const name_tok = try appendIdentifier(rp.c, ref); | | |
| 3595 | const eq_token = try appendToken(rp.c, .Equal, "="); | | |
| 3596 | const rhs_node = try transCreateNodeSimplePrefixOp(rp.c, .AddressOf, .Ampersand, "&"); | | |
| 3597 | rhs_node.rhs = try transExpr(rp, scope, op_expr, .used, .r_value); | | |
| 3598 | const init_node = &rhs_node.base; | | |
| 3599 | const semicolon_token = try appendToken(rp.c, .Semicolon, ";"); | | |
| 3600 | const node = try ast.Node.VarDecl.create(rp.c.arena, .{ | | |
| 3601 | .name_token = name_tok, | | |
| 3602 | .mut_token = mut_tok, | | |
| 3603 | .semicolon_token = semicolon_token, | | |
| 3604 | }, .{ | | |
| 3605 | .eq_token = eq_token, | | |
| 3606 | .init_node = init_node, | | |
| 3607 | }); | | |
| 3608 | try block_scope.statements.append(&node.base); | | |
| 3609 | | | |
| 3610 | const lhs_node = try transCreateNodeIdentifier(rp.c, ref); | | |
| 3611 | const ref_node = try transCreateNodePtrDeref(rp.c, lhs_node); | | |
| 3612 | _ = try appendToken(rp.c, .Semicolon, ";"); | | |
| 3613 | | | |
| 3614 | const tmp = try block_scope.makeMangledName(rp.c, "tmp"); | | |
| 3615 | const tmp_mut_tok = try appendToken(rp.c, .Keyword_const, "const"); | | |
| 3616 | const tmp_name_tok = try appendIdentifier(rp.c, tmp); | | |
| 3617 | const tmp_eq_token = try appendToken(rp.c, .Equal, "="); | | |
| 3618 | const tmp_init_node = ref_node; | | |
| 3619 | const tmp_semicolon_token = try appendToken(rp.c, .Semicolon, ";"); | | |
| 3620 | const tmp_node = try ast.Node.VarDecl.create(rp.c.arena, .{ | | |
| 3621 | .name_token = tmp_name_tok, | | |
| 3622 | .mut_token = tmp_mut_tok, | | |
| 3623 | .semicolon_token = semicolon_token, | | |
| 3624 | }, .{ | | |
| 3625 | .eq_token = tmp_eq_token, | | |
| 3626 | .init_node = tmp_init_node, | | |
| 3627 | }); | | |
| 3628 | try block_scope.statements.append(&tmp_node.base); | | |
| 3629 | | 2844 | |
| 3630 | const token = try appendToken(rp.c, op_tok_id, bytes); | 2845 | const expr = try transExpr(c, &block_scope.base, op_expr, .used); |
| 3631 | const one = try transCreateNodeInt(rp.c, 1); | 2846 | const addr_of = try Tag.address_of.create(c.arena, expr); |
| 3632 | _ = try appendToken(rp.c, .Semicolon, ";"); | 2847 | const ref_decl = try Tag.var_simple.create(c.arena, .{ .name = ref, .init = addr_of }); |
| 3633 | const assign = try transCreateNodeInfixOp(rp, scope, ref_node, op, token, one, .used, false); | 2848 | try block_scope.statements.append(ref_decl); |
| 3634 | try block_scope.statements.append(assign); | | |
| 3635 | | 2849 | |
| 3636 | const break_node = blk: { | 2850 | const lhs_node = try Tag.identifier.create(c.arena, ref); |
| 3637 | var tmp_ctrl_flow = try CtrlFlow.initToken(rp.c, .Break, block_scope.label); | 2851 | const ref_node = try Tag.deref.create(c.arena, lhs_node); |
| 3638 | const rhs = try transCreateNodeIdentifier(rp.c, tmp); | 2852 | |
| 3639 | break :blk try tmp_ctrl_flow.finish(rhs); | 2853 | const tmp = try block_scope.makeMangledName(c, "tmp"); |
| 3640 | }; | 2854 | const tmp_decl = try Tag.var_simple.create(c.arena, .{ .name = tmp, .init = ref_node }); |
| 3641 | try block_scope.statements.append(&break_node.base); | 2855 | try block_scope.statements.append(tmp_decl); |
| 3642 | _ = try appendToken(rp.c, .Semicolon, ";"); | 2856 | |
| 3643 | const block_node = try block_scope.complete(rp.c); | 2857 | const node = try transCreateNodeInfixOp(c, &block_scope.base, op, ref_node, Tag.one_literal.init(), .used); |
| 3644 | const grouped_expr = try rp.c.arena.create(ast.Node.GroupedExpression); | 2858 | try block_scope.statements.append(node); |
| 3645 | grouped_expr.* = .{ | 2859 | |
| 3646 | .lparen = try appendToken(rp.c, .LParen, "("), | 2860 | const break_node = try Tag.break_val.create(c.arena, .{ |
| 3647 | .expr = block_node, | 2861 | .label = block_scope.label, |
| 3648 | .rparen = try appendToken(rp.c, .RParen, ")"), | 2862 | .val = try Tag.identifier.create(c.arena, tmp), |
| 3649 | }; | 2863 | }); |
| 3650 | return &grouped_expr.base; | 2864 | try block_scope.statements.append(break_node); |
| | 2865 | return block_scope.complete(c); |
| 3651 | } | 2866 | } |
| 3652 | | 2867 | |
| 3653 | fn transCompoundAssignOperator(rp: RestorePoint, scope: *Scope, stmt: *const clang.CompoundAssignOperator, used: ResultUsed) TransError!*ast.Node { | 2868 | fn transCompoundAssignOperator(c: *Context, scope: *Scope, stmt: *const clang.CompoundAssignOperator, used: ResultUsed) TransError!Node { |
| 3654 | switch (stmt.getOpcode()) { | 2869 | switch (stmt.getOpcode()) { |
| 3655 | .MulAssign => if (qualTypeHasWrappingOverflow(stmt.getType())) | 2870 | .MulAssign => if (qualTypeHasWrappingOverflow(stmt.getType())) |
| 3656 | return transCreateCompoundAssign(rp, scope, stmt, .AssignMulWrap, .AsteriskPercentEqual, "*%=", .MulWrap, .AsteriskPercent, "*%", used) | 2871 | return transCreateCompoundAssign(c, scope, stmt, .mul_wrap_assign, used) |
| 3657 | else | 2872 | else |
| 3658 | return transCreateCompoundAssign(rp, scope, stmt, .AssignMul, .AsteriskEqual, "*=", .Mul, .Asterisk, "*", used), | 2873 | return transCreateCompoundAssign(c, scope, stmt, .mul_assign, used), |
| 3659 | .AddAssign => if (qualTypeHasWrappingOverflow(stmt.getType())) | 2874 | .AddAssign => if (qualTypeHasWrappingOverflow(stmt.getType())) |
| 3660 | return transCreateCompoundAssign(rp, scope, stmt, .AssignAddWrap, .PlusPercentEqual, "+%=", .AddWrap, .PlusPercent, "+%", used) | 2875 | return transCreateCompoundAssign(c, scope, stmt, .add_wrap_assign, used) |
| 3661 | else | 2876 | else |
| 3662 | return transCreateCompoundAssign(rp, scope, stmt, .AssignAdd, .PlusEqual, "+=", .Add, .Plus, "+", used), | 2877 | return transCreateCompoundAssign(c, scope, stmt, .add_assign, used), |
| 3663 | .SubAssign => if (qualTypeHasWrappingOverflow(stmt.getType())) | 2878 | .SubAssign => if (qualTypeHasWrappingOverflow(stmt.getType())) |
| 3664 | return transCreateCompoundAssign(rp, scope, stmt, .AssignSubWrap, .MinusPercentEqual, "-%=", .SubWrap, .MinusPercent, "-%", used) | 2879 | return transCreateCompoundAssign(c, scope, stmt, .sub_wrap_assign, used) |
| 3665 | else | 2880 | else |
| 3666 | return transCreateCompoundAssign(rp, scope, stmt, .AssignSub, .MinusPercentEqual, "-=", .Sub, .Minus, "-", used), | 2881 | return transCreateCompoundAssign(c, scope, stmt, .sub_assign, used), |
| 3667 | .DivAssign => return transCreateCompoundAssign(rp, scope, stmt, .AssignDiv, .SlashEqual, "/=", .Div, .Slash, "/", used), | 2882 | .DivAssign => return transCreateCompoundAssign(c, scope, stmt, .div_assign, used), |
| 3668 | .RemAssign => return transCreateCompoundAssign(rp, scope, stmt, .AssignMod, .PercentEqual, "%=", .Mod, .Percent, "%", used), | 2883 | .RemAssign => return transCreateCompoundAssign(c, scope, stmt, .mod_assign, used), |
| 3669 | .ShlAssign => return transCreateCompoundAssign(rp, scope, stmt, .AssignBitShiftLeft, .AngleBracketAngleBracketLeftEqual, "<<=", .BitShiftLeft, .AngleBracketAngleBracketLeft, "<<", used), | 2884 | .ShlAssign => return transCreateCompoundAssign(c, scope, stmt, .shl_assign, used), |
| 3670 | .ShrAssign => return transCreateCompoundAssign(rp, scope, stmt, .AssignBitShiftRight, .AngleBracketAngleBracketRightEqual, ">>=", .BitShiftRight, .AngleBracketAngleBracketRight, ">>", used), | 2885 | .ShrAssign => return transCreateCompoundAssign(c, scope, stmt, .shr_assign, used), |
| 3671 | .AndAssign => return transCreateCompoundAssign(rp, scope, stmt, .AssignBitAnd, .AmpersandEqual, "&=", .BitAnd, .Ampersand, "&", used), | 2886 | .AndAssign => return transCreateCompoundAssign(c, scope, stmt, .bit_and_assign, used), |
| 3672 | .XorAssign => return transCreateCompoundAssign(rp, scope, stmt, .AssignBitXor, .CaretEqual, "^=", .BitXor, .Caret, "^", used), | 2887 | .XorAssign => return transCreateCompoundAssign(c, scope, stmt, .bit_xor_assign, used), |
| 3673 | .OrAssign => return transCreateCompoundAssign(rp, scope, stmt, .AssignBitOr, .PipeEqual, "|=", .BitOr, .Pipe, "|", used), | 2888 | .OrAssign => return transCreateCompoundAssign(c, scope, stmt, .bit_or_assign, used), |
| 3674 | else => return revertAndWarn( | 2889 | else => return fail( |
| 3675 | rp, | 2890 | c, |
| 3676 | error.UnsupportedTranslation, | 2891 | error.UnsupportedTranslation, |
| 3677 | stmt.getBeginLoc(), | 2892 | stmt.getBeginLoc(), |
| 3678 | "unsupported C translation {}", | 2893 | "unsupported C translation {}", |
| ... | @@ -3682,25 +2897,20 @@ fn transCompoundAssignOperator(rp: RestorePoint, scope: *Scope, stmt: *const cla | ... | @@ -3682,25 +2897,20 @@ fn transCompoundAssignOperator(rp: RestorePoint, scope: *Scope, stmt: *const cla |
| 3682 | } | 2897 | } |
| 3683 | | 2898 | |
| 3684 | fn transCreateCompoundAssign( | 2899 | fn transCreateCompoundAssign( |
| 3685 | rp: RestorePoint, | 2900 | c: *Context, |
| 3686 | scope: *Scope, | 2901 | scope: *Scope, |
| 3687 | stmt: *const clang.CompoundAssignOperator, | 2902 | stmt: *const clang.CompoundAssignOperator, |
| 3688 | assign_op: ast.Node.Tag, | 2903 | op: Tag, |
| 3689 | assign_tok_id: std.zig.Token.Id, | | |
| 3690 | assign_bytes: []const u8, | | |
| 3691 | bin_op: ast.Node.Tag, | | |
| 3692 | bin_tok_id: std.zig.Token.Id, | | |
| 3693 | bin_bytes: []const u8, | | |
| 3694 | used: ResultUsed, | 2904 | used: ResultUsed, |
| 3695 | ) TransError!*ast.Node { | 2905 | ) TransError!Node { |
| 3696 | const is_shift = bin_op == .BitShiftLeft or bin_op == .BitShiftRight; | 2906 | const is_shift = op == .shl_assign or op == .shr_assign; |
| 3697 | const is_div = bin_op == .Div; | 2907 | const is_div = op == .div_assign; |
| 3698 | const is_mod = bin_op == .Mod; | 2908 | const is_mod = op == .mod_assign; |
| 3699 | const lhs = stmt.getLHS(); | 2909 | const lhs = stmt.getLHS(); |
| 3700 | const rhs = stmt.getRHS(); | 2910 | const rhs = stmt.getRHS(); |
| 3701 | const loc = stmt.getBeginLoc(); | 2911 | const loc = stmt.getBeginLoc(); |
| 3702 | const lhs_qt = getExprQualType(rp.c, lhs); | 2912 | const lhs_qt = getExprQualType(c, lhs); |
| 3703 | const rhs_qt = getExprQualType(rp.c, rhs); | 2913 | const rhs_qt = getExprQualType(c, rhs); |
| 3704 | const is_signed = cIsSignedInteger(lhs_qt); | 2914 | const is_signed = cIsSignedInteger(lhs_qt); |
| 3705 | const requires_int_cast = blk: { | 2915 | const requires_int_cast = blk: { |
| 3706 | const are_integers = cIsInteger(lhs_qt) and cIsInteger(rhs_qt); | 2916 | const are_integers = cIsInteger(lhs_qt) and cIsInteger(rhs_qt); |
| ... | @@ -3712,146 +2922,100 @@ fn transCreateCompoundAssign( | ... | @@ -3712,146 +2922,100 @@ fn transCreateCompoundAssign( |
| 3712 | // c: lhs += rhs | 2922 | // c: lhs += rhs |
| 3713 | // zig: lhs += rhs | 2923 | // zig: lhs += rhs |
| 3714 | if ((is_mod or is_div) and is_signed) { | 2924 | if ((is_mod or is_div) and is_signed) { |
| 3715 | const op_token = try appendToken(rp.c, .Equal, "="); | 2925 | const lhs_node = try transExpr(c, scope, lhs, .used); |
| 3716 | const op_node = try rp.c.arena.create(ast.Node.SimpleInfixOp); | 2926 | const rhs_node = try transExpr(c, scope, rhs, .used); |
| 3717 | const builtin = if (is_mod) "@rem" else "@divTrunc"; | 2927 | const builtin = if (is_mod) |
| 3718 | const builtin_node = try rp.c.createBuiltinCall(builtin, 2); | 2928 | try Tag.rem.create(c.arena, .{ .lhs = lhs_node, .rhs = rhs_node }) |
| 3719 | const lhs_node = try transExpr(rp, scope, lhs, .used, .l_value); | 2929 | else |
| 3720 | builtin_node.params()[0] = lhs_node; | 2930 | try Tag.div_trunc.create(c.arena, .{ .lhs = lhs_node, .rhs = rhs_node }); |
| 3721 | _ = try appendToken(rp.c, .Comma, ","); | 2931 | |
| 3722 | builtin_node.params()[1] = try transExpr(rp, scope, rhs, .used, .r_value); | 2932 | return transCreateNodeInfixOp(c, scope, .assign, lhs_node, builtin, .used); |
| 3723 | builtin_node.rparen_token = try appendToken(rp.c, .RParen, ")"); | | |
| 3724 | op_node.* = .{ | | |
| 3725 | .base = .{ .tag = .Assign }, | | |
| 3726 | .op_token = op_token, | | |
| 3727 | .lhs = lhs_node, | | |
| 3728 | .rhs = &builtin_node.base, | | |
| 3729 | }; | | |
| 3730 | _ = try appendToken(rp.c, .Semicolon, ";"); | | |
| 3731 | return &op_node.base; | | |
| 3732 | } | 2933 | } |
| 3733 | | 2934 | |
| 3734 | const lhs_node = try transExpr(rp, scope, lhs, .used, .l_value); | 2935 | const lhs_node = try transExpr(c, scope, lhs, .used); |
| 3735 | const eq_token = try appendToken(rp.c, assign_tok_id, assign_bytes); | | |
| 3736 | var rhs_node = if (is_shift or requires_int_cast) | 2936 | var rhs_node = if (is_shift or requires_int_cast) |
| 3737 | try transExprCoercing(rp, scope, rhs, .used, .r_value) | 2937 | try transExprCoercing(c, scope, rhs, .used) |
| 3738 | else | 2938 | else |
| 3739 | try transExpr(rp, scope, rhs, .used, .r_value); | 2939 | try transExpr(c, scope, rhs, .used); |
| 3740 | | 2940 | |
| 3741 | if (is_shift or requires_int_cast) { | 2941 | if (is_shift or requires_int_cast) { |
| 3742 | const cast_node = try rp.c.createBuiltinCall("@intCast", 2); | 2942 | // @intCast(rhs) |
| 3743 | const cast_to_type = if (is_shift) | 2943 | const cast_to_type = if (is_shift) |
| 3744 | try qualTypeToLog2IntRef(rp, getExprQualType(rp.c, rhs), loc) | 2944 | try qualTypeToLog2IntRef(c, scope, getExprQualType(c, rhs), loc) |
| 3745 | else | 2945 | else |
| 3746 | try transQualType(rp, getExprQualType(rp.c, lhs), loc); | 2946 | try transQualType(c, scope, getExprQualType(c, lhs), loc); |
| 3747 | cast_node.params()[0] = cast_to_type; | 2947 | |
| 3748 | _ = try appendToken(rp.c, .Comma, ","); | 2948 | rhs_node = try Tag.int_cast.create(c.arena, .{ .lhs = cast_to_type, .rhs = rhs_node }); |
| 3749 | cast_node.params()[1] = rhs_node; | | |
| 3750 | cast_node.rparen_token = try appendToken(rp.c, .RParen, ")"); | | |
| 3751 | rhs_node = &cast_node.base; | | |
| 3752 | } | 2949 | } |
| 3753 | if (scope.id != .Condition) | 2950 | |
| 3754 | _ = try appendToken(rp.c, .Semicolon, ";"); | 2951 | return transCreateNodeInfixOp(c, scope, op, lhs_node, rhs_node, .used); |
| 3755 | return transCreateNodeInfixOp(rp, scope, lhs_node, assign_op, eq_token, rhs_node, .used, false); | | |
| 3756 | } | 2952 | } |
| 3757 | // worst case | 2953 | // worst case |
| 3758 | // c: lhs += rhs | 2954 | // c: lhs += rhs |
| 3759 | // zig: (blk: { | 2955 | // zig: (blk: { |
| 3760 | // zig: const _ref = &lhs; | 2956 | // zig: const _ref = &lhs; |
| 3761 | // zig: _ref.* = _ref.* + rhs; | 2957 | // zig: _ref.* += rhs; |
| 3762 | // zig: break :blk _ref.* | 2958 | // zig: break :blk _ref.* |
| 3763 | // zig: }) | 2959 | // zig: }) |
| 3764 | var block_scope = try Scope.Block.init(rp.c, scope, true); | 2960 | var block_scope = try Scope.Block.init(c, scope, true); |
| 3765 | defer block_scope.deinit(); | 2961 | defer block_scope.deinit(); |
| 3766 | const ref = try block_scope.makeMangledName(rp.c, "ref"); | 2962 | const ref = try block_scope.makeMangledName(c, "ref"); |
| 3767 | | | |
| 3768 | const mut_tok = try appendToken(rp.c, .Keyword_const, "const"); | | |
| 3769 | const name_tok = try appendIdentifier(rp.c, ref); | | |
| 3770 | const eq_token = try appendToken(rp.c, .Equal, "="); | | |
| 3771 | const addr_node = try transCreateNodeSimplePrefixOp(rp.c, .AddressOf, .Ampersand, "&"); | | |
| 3772 | addr_node.rhs = try transExpr(rp, scope, lhs, .used, .l_value); | | |
| 3773 | const init_node = &addr_node.base; | | |
| 3774 | const semicolon_token = try appendToken(rp.c, .Semicolon, ";"); | | |
| 3775 | const node = try ast.Node.VarDecl.create(rp.c.arena, .{ | | |
| 3776 | .name_token = name_tok, | | |
| 3777 | .mut_token = mut_tok, | | |
| 3778 | .semicolon_token = semicolon_token, | | |
| 3779 | }, .{ | | |
| 3780 | .eq_token = eq_token, | | |
| 3781 | .init_node = init_node, | | |
| 3782 | }); | | |
| 3783 | try block_scope.statements.append(&node.base); | | |
| 3784 | | 2963 | |
| 3785 | const lhs_node = try transCreateNodeIdentifier(rp.c, ref); | 2964 | const expr = try transExpr(c, &block_scope.base, lhs, .used); |
| 3786 | const ref_node = try transCreateNodePtrDeref(rp.c, lhs_node); | 2965 | const addr_of = try Tag.address_of.create(c.arena, expr); |
| 3787 | _ = try appendToken(rp.c, .Semicolon, ";"); | 2966 | const ref_decl = try Tag.var_simple.create(c.arena, .{ .name = ref, .init = addr_of }); |
| | 2967 | try block_scope.statements.append(ref_decl); |
| | 2968 | |
| | 2969 | const lhs_node = try Tag.identifier.create(c.arena, ref); |
| | 2970 | const ref_node = try Tag.deref.create(c.arena, lhs_node); |
| 3788 | | 2971 | |
| 3789 | if ((is_mod or is_div) and is_signed) { | 2972 | if ((is_mod or is_div) and is_signed) { |
| 3790 | const op_token = try appendToken(rp.c, .Equal, "="); | 2973 | const rhs_node = try transExpr(c, &block_scope.base, rhs, .used); |
| 3791 | const op_node = try rp.c.arena.create(ast.Node.SimpleInfixOp); | 2974 | const builtin = if (is_mod) |
| 3792 | const builtin = if (is_mod) "@rem" else "@divTrunc"; | 2975 | try Tag.rem.create(c.arena, .{ .lhs = ref_node, .rhs = rhs_node }) |
| 3793 | const builtin_node = try rp.c.createBuiltinCall(builtin, 2); | 2976 | else |
| 3794 | builtin_node.params()[0] = try transCreateNodePtrDeref(rp.c, lhs_node); | 2977 | try Tag.div_trunc.create(c.arena, .{ .lhs = ref_node, .rhs = rhs_node }); |
| 3795 | _ = try appendToken(rp.c, .Comma, ","); | 2978 | |
| 3796 | builtin_node.params()[1] = try transExpr(rp, scope, rhs, .used, .r_value); | 2979 | const assign = try transCreateNodeInfixOp(c, &block_scope.base, .assign, ref_node, builtin, .used); |
| 3797 | builtin_node.rparen_token = try appendToken(rp.c, .RParen, ")"); | 2980 | try block_scope.statements.append(assign); |
| 3798 | _ = try appendToken(rp.c, .Semicolon, ";"); | | |
| 3799 | op_node.* = .{ | | |
| 3800 | .base = .{ .tag = .Assign }, | | |
| 3801 | .op_token = op_token, | | |
| 3802 | .lhs = ref_node, | | |
| 3803 | .rhs = &builtin_node.base, | | |
| 3804 | }; | | |
| 3805 | _ = try appendToken(rp.c, .Semicolon, ";"); | | |
| 3806 | try block_scope.statements.append(&op_node.base); | | |
| 3807 | } else { | 2981 | } else { |
| 3808 | const bin_token = try appendToken(rp.c, bin_tok_id, bin_bytes); | 2982 | var rhs_node = try transExpr(c, &block_scope.base, rhs, .used); |
| 3809 | var rhs_node = try transExpr(rp, scope, rhs, .used, .r_value); | | |
| 3810 | | 2983 | |
| 3811 | if (is_shift or requires_int_cast) { | 2984 | if (is_shift or requires_int_cast) { |
| 3812 | const cast_node = try rp.c.createBuiltinCall("@intCast", 2); | 2985 | // @intCast(rhs) |
| 3813 | const cast_to_type = if (is_shift) | 2986 | const cast_to_type = if (is_shift) |
| 3814 | try qualTypeToLog2IntRef(rp, getExprQualType(rp.c, rhs), loc) | 2987 | try qualTypeToLog2IntRef(c, scope, getExprQualType(c, rhs), loc) |
| 3815 | else | 2988 | else |
| 3816 | try transQualType(rp, getExprQualType(rp.c, lhs), loc); | 2989 | try transQualType(c, scope, getExprQualType(c, lhs), loc); |
| 3817 | cast_node.params()[0] = cast_to_type; | | |
| 3818 | _ = try appendToken(rp.c, .Comma, ","); | | |
| 3819 | cast_node.params()[1] = rhs_node; | | |
| 3820 | cast_node.rparen_token = try appendToken(rp.c, .RParen, ")"); | | |
| 3821 | rhs_node = &cast_node.base; | | |
| 3822 | } | | |
| 3823 | | 2990 | |
| 3824 | const rhs_bin = try transCreateNodeInfixOp(rp, scope, ref_node, bin_op, bin_token, rhs_node, .used, false); | 2991 | rhs_node = try Tag.int_cast.create(c.arena, .{ .lhs = cast_to_type, .rhs = rhs_node }); |
| 3825 | _ = try appendToken(rp.c, .Semicolon, ";"); | 2992 | } |
| 3826 | | 2993 | |
| 3827 | const ass_eq_token = try appendToken(rp.c, .Equal, "="); | 2994 | const assign = try transCreateNodeInfixOp(c, &block_scope.base, op, ref_node, rhs_node, .used); |
| 3828 | const assign = try transCreateNodeInfixOp(rp, scope, ref_node, .Assign, ass_eq_token, rhs_bin, .used, false); | | |
| 3829 | try block_scope.statements.append(assign); | 2995 | try block_scope.statements.append(assign); |
| 3830 | } | 2996 | } |
| 3831 | | 2997 | |
| 3832 | const break_node = try transCreateNodeBreak(rp.c, block_scope.label, ref_node); | 2998 | const break_node = try Tag.break_val.create(c.arena, .{ |
| 3833 | try block_scope.statements.append(&break_node.base); | 2999 | .label = block_scope.label, |
| 3834 | const block_node = try block_scope.complete(rp.c); | 3000 | .val = ref_node, |
| 3835 | const grouped_expr = try rp.c.arena.create(ast.Node.GroupedExpression); | 3001 | }); |
| 3836 | grouped_expr.* = .{ | 3002 | try block_scope.statements.append(break_node); |
| 3837 | .lparen = try appendToken(rp.c, .LParen, "("), | 3003 | return block_scope.complete(c); |
| 3838 | .expr = block_node, | | |
| 3839 | .rparen = try appendToken(rp.c, .RParen, ")"), | | |
| 3840 | }; | | |
| 3841 | return &grouped_expr.base; | | |
| 3842 | } | 3004 | } |
| 3843 | | 3005 | |
| 3844 | fn transCPtrCast( | 3006 | fn transCPtrCast( |
| 3845 | rp: RestorePoint, | 3007 | c: *Context, |
| | 3008 | scope: *Scope, |
| 3846 | loc: clang.SourceLocation, | 3009 | loc: clang.SourceLocation, |
| 3847 | dst_type: clang.QualType, | 3010 | dst_type: clang.QualType, |
| 3848 | src_type: clang.QualType, | 3011 | src_type: clang.QualType, |
| 3849 | expr: *ast.Node, | 3012 | expr: Node, |
| 3850 | ) !*ast.Node { | 3013 | ) !Node { |
| 3851 | const ty = dst_type.getTypePtr(); | 3014 | const ty = dst_type.getTypePtr(); |
| 3852 | const child_type = ty.getPointeeType(); | 3015 | const child_type = ty.getPointeeType(); |
| 3853 | const src_ty = src_type.getTypePtr(); | 3016 | const src_ty = src_type.getTypePtr(); |
| 3854 | const src_child_type = src_ty.getPointeeType(); | 3017 | const src_child_type = src_ty.getPointeeType(); |
| | 3018 | const dst_type_node = try transType(c, scope, ty, loc); |
| 3855 | | 3019 | |
| 3856 | if ((src_child_type.isConstQualified() and | 3020 | if ((src_child_type.isConstQualified() and |
| 3857 | !child_type.isConstQualified()) or | 3021 | !child_type.isConstQualified()) or |
| ... | @@ -3859,80 +3023,47 @@ fn transCPtrCast( | ... | @@ -3859,80 +3023,47 @@ fn transCPtrCast( |
| 3859 | !child_type.isVolatileQualified())) | 3023 | !child_type.isVolatileQualified())) |
| 3860 | { | 3024 | { |
| 3861 | // Casting away const or volatile requires us to use @intToPtr | 3025 | // Casting away const or volatile requires us to use @intToPtr |
| 3862 | const inttoptr_node = try rp.c.createBuiltinCall("@intToPtr", 2); | 3026 | const ptr_to_int = try Tag.ptr_to_int.create(c.arena, expr); |
| 3863 | const dst_type_node = try transType(rp, ty, loc); | 3027 | const int_to_ptr = try Tag.int_to_ptr.create(c.arena, .{ .lhs = dst_type_node, .rhs = ptr_to_int }); |
| 3864 | inttoptr_node.params()[0] = dst_type_node; | 3028 | return int_to_ptr; |
| 3865 | _ = try appendToken(rp.c, .Comma, ","); | | |
| 3866 | | | |
| 3867 | const ptrtoint_node = try rp.c.createBuiltinCall("@ptrToInt", 1); | | |
| 3868 | ptrtoint_node.params()[0] = expr; | | |
| 3869 | ptrtoint_node.rparen_token = try appendToken(rp.c, .RParen, ")"); | | |
| 3870 | | | |
| 3871 | inttoptr_node.params()[1] = &ptrtoint_node.base; | | |
| 3872 | inttoptr_node.rparen_token = try appendToken(rp.c, .RParen, ")"); | | |
| 3873 | return &inttoptr_node.base; | | |
| 3874 | } else { | 3029 | } else { |
| 3875 | // Implicit downcasting from higher to lower alignment values is forbidden, | 3030 | // Implicit downcasting from higher to lower alignment values is forbidden, |
| 3876 | // use @alignCast to side-step this problem | 3031 | // use @alignCast to side-step this problem |
| 3877 | const ptrcast_node = try rp.c.createBuiltinCall("@ptrCast", 2); | 3032 | const rhs = if (qualTypeCanon(child_type).isVoidType()) |
| 3878 | const dst_type_node = try transType(rp, ty, loc); | | |
| 3879 | ptrcast_node.params()[0] = dst_type_node; | | |
| 3880 | _ = try appendToken(rp.c, .Comma, ","); | | |
| 3881 | | | |
| 3882 | if (qualTypeCanon(child_type).isVoidType()) { | | |
| 3883 | // void has 1-byte alignment, so @alignCast is not needed | 3033 | // void has 1-byte alignment, so @alignCast is not needed |
| 3884 | ptrcast_node.params()[1] = expr; | 3034 | expr |
| 3885 | } else if (typeIsOpaque(rp.c, qualTypeCanon(child_type), loc)) { | 3035 | else if (typeIsOpaque(c, qualTypeCanon(child_type), loc)) |
| 3886 | // For opaque types a ptrCast is enough | 3036 | // For opaque types a ptrCast is enough |
| 3887 | ptrcast_node.params()[1] = expr; | 3037 | expr |
| 3888 | } else { | 3038 | else blk: { |
| 3889 | const aligncast_node = try rp.c.createBuiltinCall("@alignCast", 2); | 3039 | const child_type_node = try transQualType(c, scope, child_type, loc); |
| 3890 | const alignof_node = try rp.c.createBuiltinCall("@alignOf", 1); | 3040 | const alignof = try Tag.alignof.create(c.arena, child_type_node); |
| 3891 | const child_type_node = try transQualType(rp, child_type, loc); | 3041 | const align_cast = try Tag.align_cast.create(c.arena, .{ .lhs = alignof, .rhs = expr }); |
| 3892 | alignof_node.params()[0] = child_type_node; | 3042 | break :blk align_cast; |
| 3893 | alignof_node.rparen_token = try appendToken(rp.c, .RParen, ")"); | 3043 | }; |
| 3894 | aligncast_node.params()[0] = &alignof_node.base; | 3044 | return Tag.ptr_cast.create(c.arena, .{ .lhs = dst_type_node, .rhs = rhs }); |
| 3895 | _ = try appendToken(rp.c, .Comma, ","); | | |
| 3896 | aligncast_node.params()[1] = expr; | | |
| 3897 | aligncast_node.rparen_token = try appendToken(rp.c, .RParen, ")"); | | |
| 3898 | ptrcast_node.params()[1] = &aligncast_node.base; | | |
| 3899 | } | | |
| 3900 | ptrcast_node.rparen_token = try appendToken(rp.c, .RParen, ")"); | | |
| 3901 | | | |
| 3902 | return &ptrcast_node.base; | | |
| 3903 | } | 3045 | } |
| 3904 | } | 3046 | } |
| 3905 | | 3047 | |
| 3906 | fn transBreak(rp: RestorePoint, scope: *Scope) TransError!*ast.Node { | 3048 | fn transFloatingLiteral(c: *Context, scope: *Scope, stmt: *const clang.FloatingLiteral, used: ResultUsed) TransError!Node { |
| 3907 | const break_scope = scope.getBreakableScope(); | | |
| 3908 | const label_text: ?[]const u8 = if (break_scope.id == .Switch) blk: { | | |
| 3909 | const swtch = @fieldParentPtr(Scope.Switch, "base", break_scope); | | |
| 3910 | const block_scope = try scope.findBlockScope(rp.c); | | |
| 3911 | swtch.switch_label = try block_scope.makeMangledName(rp.c, "switch"); | | |
| 3912 | break :blk swtch.switch_label; | | |
| 3913 | } else | | |
| 3914 | null; | | |
| 3915 | | | |
| 3916 | var cf = try CtrlFlow.init(rp.c, .Break, label_text); | | |
| 3917 | const br = try cf.finish(null); | | |
| 3918 | _ = try appendToken(rp.c, .Semicolon, ";"); | | |
| 3919 | return &br.base; | | |
| 3920 | } | | |
| 3921 | | | |
| 3922 | fn transFloatingLiteral(rp: RestorePoint, scope: *Scope, stmt: *const clang.FloatingLiteral, used: ResultUsed) TransError!*ast.Node { | | |
| 3923 | // TODO use something more accurate | 3049 | // TODO use something more accurate |
| 3924 | const dbl = stmt.getValueAsApproximateDouble(); | 3050 | var dbl = stmt.getValueAsApproximateDouble(); |
| 3925 | const node = try rp.c.arena.create(ast.Node.OneToken); | 3051 | const is_negative = dbl < 0; |
| 3926 | node.* = .{ | 3052 | if (is_negative) dbl = -dbl; |
| 3927 | .base = .{ .tag = .FloatLiteral }, | 3053 | const str = try std.fmt.allocPrint(c.arena, "{d}", .{dbl}); |
| 3928 | .token = try appendTokenFmt(rp.c, .FloatLiteral, "{d}", .{dbl}), | 3054 | var node = if (dbl == std.math.floor(dbl)) |
| 3929 | }; | 3055 | try Tag.integer_literal.create(c.arena, str) |
| 3930 | return maybeSuppressResult(rp, scope, used, &node.base); | 3056 | else |
| | 3057 | try Tag.float_literal.create(c.arena, str); |
| | 3058 | if (is_negative) node = try Tag.negate.create(c.arena, node); |
| | 3059 | return maybeSuppressResult(c, scope, used, node); |
| 3931 | } | 3060 | } |
| 3932 | | 3061 | |
| 3933 | fn transBinaryConditionalOperator(rp: RestorePoint, scope: *Scope, stmt: *const clang.BinaryConditionalOperator, used: ResultUsed) TransError!*ast.Node { | 3062 | fn transBinaryConditionalOperator(c: *Context, scope: *Scope, stmt: *const clang.BinaryConditionalOperator, used: ResultUsed) TransError!Node { |
| 3934 | // GNU extension of the ternary operator where the middle expression is | 3063 | // GNU extension of the ternary operator where the middle expression is |
| 3935 | // omitted, the conditition itself is returned if it evaluates to true | 3064 | // omitted, the conditition itself is returned if it evaluates to true |
| | 3065 | const qt = @ptrCast(*const clang.Expr, stmt).getType(); |
| | 3066 | const res_is_bool = qualTypeIsBoolean(qt); |
| 3936 | const casted_stmt = @ptrCast(*const clang.AbstractConditionalOperator, stmt); | 3067 | const casted_stmt = @ptrCast(*const clang.AbstractConditionalOperator, stmt); |
| 3937 | const cond_expr = casted_stmt.getCond(); | 3068 | const cond_expr = casted_stmt.getCond(); |
| 3938 | const true_expr = casted_stmt.getTrueExpr(); | 3069 | const true_expr = casted_stmt.getTrueExpr(); |
| ... | @@ -3943,184 +3074,149 @@ fn transBinaryConditionalOperator(rp: RestorePoint, scope: *Scope, stmt: *const | ... | @@ -3943,184 +3074,149 @@ fn transBinaryConditionalOperator(rp: RestorePoint, scope: *Scope, stmt: *const |
| 3943 | // const _cond_temp = (cond_expr); | 3074 | // const _cond_temp = (cond_expr); |
| 3944 | // break :blk if (_cond_temp) _cond_temp else (false_expr); | 3075 | // break :blk if (_cond_temp) _cond_temp else (false_expr); |
| 3945 | // }) | 3076 | // }) |
| 3946 | const lparen = try appendToken(rp.c, .LParen, "("); | 3077 | var block_scope = try Scope.Block.init(c, scope, true); |
| 3947 | | | |
| 3948 | var block_scope = try Scope.Block.init(rp.c, scope, true); | | |
| 3949 | defer block_scope.deinit(); | 3078 | defer block_scope.deinit(); |
| 3950 | | 3079 | |
| 3951 | const mangled_name = try block_scope.makeMangledName(rp.c, "cond_temp"); | 3080 | const mangled_name = try block_scope.makeMangledName(c, "cond_temp"); |
| 3952 | const mut_tok = try appendToken(rp.c, .Keyword_const, "const"); | 3081 | const init_node = try transExpr(c, &block_scope.base, cond_expr, .used); |
| 3953 | const name_tok = try appendIdentifier(rp.c, mangled_name); | 3082 | const ref_decl = try Tag.var_simple.create(c.arena, .{ .name = mangled_name, .init = init_node }); |
| 3954 | const eq_token = try appendToken(rp.c, .Equal, "="); | 3083 | try block_scope.statements.append(ref_decl); |
| 3955 | const init_node = try transExpr(rp, &block_scope.base, cond_expr, .used, .r_value); | | |
| 3956 | const semicolon_token = try appendToken(rp.c, .Semicolon, ";"); | | |
| 3957 | const tmp_var = try ast.Node.VarDecl.create(rp.c.arena, .{ | | |
| 3958 | .name_token = name_tok, | | |
| 3959 | .mut_token = mut_tok, | | |
| 3960 | .semicolon_token = semicolon_token, | | |
| 3961 | }, .{ | | |
| 3962 | .eq_token = eq_token, | | |
| 3963 | .init_node = init_node, | | |
| 3964 | }); | | |
| 3965 | try block_scope.statements.append(&tmp_var.base); | | |
| 3966 | | | |
| 3967 | var break_node_tmp = try CtrlFlow.initToken(rp.c, .Break, block_scope.label); | | |
| 3968 | | 3084 | |
| 3969 | const if_node = try transCreateNodeIf(rp.c); | | |
| 3970 | var cond_scope = Scope.Condition{ | 3085 | var cond_scope = Scope.Condition{ |
| 3971 | .base = .{ | 3086 | .base = .{ |
| 3972 | .parent = &block_scope.base, | 3087 | .parent = &block_scope.base, |
| 3973 | .id = .Condition, | 3088 | .id = .condition, |
| 3974 | }, | 3089 | }, |
| 3975 | }; | 3090 | }; |
| 3976 | defer cond_scope.deinit(); | 3091 | defer cond_scope.deinit(); |
| 3977 | const tmp_var_node = try transCreateNodeIdentifier(rp.c, mangled_name); | 3092 | |
| 3978 | | 3093 | const cond_ident = try Tag.identifier.create(c.arena, mangled_name); |
| 3979 | const ty = getExprQualType(rp.c, cond_expr).getTypePtr(); | 3094 | const ty = getExprQualType(c, cond_expr).getTypePtr(); |
| 3980 | const cond_node = try finishBoolExpr(rp, &cond_scope.base, cond_expr.getBeginLoc(), ty, tmp_var_node, used); | 3095 | const cond_node = try finishBoolExpr(c, &cond_scope.base, cond_expr.getBeginLoc(), ty, cond_ident, .used); |
| 3981 | if_node.condition = cond_node; | 3096 | var then_body = cond_ident; |
| 3982 | _ = try appendToken(rp.c, .RParen, ")"); | 3097 | if (!res_is_bool and isBoolRes(init_node)) { |
| 3983 | | 3098 | then_body = try Tag.bool_to_int.create(c.arena, then_body); |
| 3984 | if_node.body = try transCreateNodeIdentifier(rp.c, mangled_name); | 3099 | } |
| 3985 | if_node.@"else" = try transCreateNodeElse(rp.c); | 3100 | |
| 3986 | if_node.@"else".?.body = try transExpr(rp, &block_scope.base, false_expr, .used, .r_value); | 3101 | var else_body = try transExpr(c, &block_scope.base, false_expr, .used); |
| 3987 | _ = try appendToken(rp.c, .Semicolon, ";"); | 3102 | if (!res_is_bool and isBoolRes(else_body)) { |
| 3988 | | 3103 | else_body = try Tag.bool_to_int.create(c.arena, else_body); |
| 3989 | const break_node = try break_node_tmp.finish(&if_node.base); | 3104 | } |
| 3990 | _ = try appendToken(rp.c, .Semicolon, ";"); | 3105 | const if_node = try Tag.@"if".create(c.arena, .{ |
| 3991 | try block_scope.statements.append(&break_node.base); | 3106 | .cond = cond_node, |
| 3992 | const block_node = try block_scope.complete(rp.c); | 3107 | .then = then_body, |
| 3993 | | 3108 | .@"else" = else_body, |
| 3994 | const grouped_expr = try rp.c.arena.create(ast.Node.GroupedExpression); | 3109 | }); |
| 3995 | grouped_expr.* = .{ | 3110 | const break_node = try Tag.break_val.create(c.arena, .{ |
| 3996 | .lparen = lparen, | 3111 | .label = block_scope.label, |
| 3997 | .expr = block_node, | 3112 | .val = if_node, |
| 3998 | .rparen = try appendToken(rp.c, .RParen, ")"), | 3113 | }); |
| 3999 | }; | 3114 | try block_scope.statements.append(break_node); |
| 4000 | return maybeSuppressResult(rp, scope, used, &grouped_expr.base); | 3115 | const res = try block_scope.complete(c); |
| | 3116 | return maybeSuppressResult(c, scope, used, res); |
| 4001 | } | 3117 | } |
| 4002 | | 3118 | |
| 4003 | fn transConditionalOperator(rp: RestorePoint, scope: *Scope, stmt: *const clang.ConditionalOperator, used: ResultUsed) TransError!*ast.Node { | 3119 | fn transConditionalOperator(c: *Context, scope: *Scope, stmt: *const clang.ConditionalOperator, used: ResultUsed) TransError!Node { |
| 4004 | const grouped = scope.id == .Condition; | | |
| 4005 | const lparen = if (grouped) try appendToken(rp.c, .LParen, "(") else undefined; | | |
| 4006 | const if_node = try transCreateNodeIf(rp.c); | | |
| 4007 | var cond_scope = Scope.Condition{ | 3120 | var cond_scope = Scope.Condition{ |
| 4008 | .base = .{ | 3121 | .base = .{ |
| 4009 | .parent = scope, | 3122 | .parent = scope, |
| 4010 | .id = .Condition, | 3123 | .id = .condition, |
| 4011 | }, | 3124 | }, |
| 4012 | }; | 3125 | }; |
| 4013 | defer cond_scope.deinit(); | 3126 | defer cond_scope.deinit(); |
| 4014 | | 3127 | |
| | 3128 | const qt = @ptrCast(*const clang.Expr, stmt).getType(); |
| | 3129 | const res_is_bool = qualTypeIsBoolean(qt); |
| 4015 | const casted_stmt = @ptrCast(*const clang.AbstractConditionalOperator, stmt); | 3130 | const casted_stmt = @ptrCast(*const clang.AbstractConditionalOperator, stmt); |
| 4016 | const cond_expr = casted_stmt.getCond(); | 3131 | const cond_expr = casted_stmt.getCond(); |
| 4017 | const true_expr = casted_stmt.getTrueExpr(); | 3132 | const true_expr = casted_stmt.getTrueExpr(); |
| 4018 | const false_expr = casted_stmt.getFalseExpr(); | 3133 | const false_expr = casted_stmt.getFalseExpr(); |
| 4019 | | 3134 | |
| 4020 | if_node.condition = try transBoolExpr(rp, &cond_scope.base, cond_expr, .used, .r_value, false); | 3135 | const cond = try transBoolExpr(c, &cond_scope.base, cond_expr, .used); |
| 4021 | _ = try appendToken(rp.c, .RParen, ")"); | | |
| 4022 | | 3136 | |
| 4023 | if_node.body = try transExpr(rp, scope, true_expr, .used, .r_value); | 3137 | var then_body = try transExpr(c, scope, true_expr, used); |
| 4024 | | 3138 | if (!res_is_bool and isBoolRes(then_body)) { |
| 4025 | if_node.@"else" = try transCreateNodeElse(rp.c); | 3139 | then_body = try Tag.bool_to_int.create(c.arena, then_body); |
| 4026 | if_node.@"else".?.body = try transExpr(rp, scope, false_expr, .used, .r_value); | 3140 | } |
| 4027 | | 3141 | |
| 4028 | if (grouped) { | 3142 | var else_body = try transExpr(c, scope, false_expr, used); |
| 4029 | const rparen = try appendToken(rp.c, .RParen, ")"); | 3143 | if (!res_is_bool and isBoolRes(else_body)) { |
| 4030 | const grouped_expr = try rp.c.arena.create(ast.Node.GroupedExpression); | 3144 | else_body = try Tag.bool_to_int.create(c.arena, else_body); |
| 4031 | grouped_expr.* = .{ | | |
| 4032 | .lparen = lparen, | | |
| 4033 | .expr = &if_node.base, | | |
| 4034 | .rparen = rparen, | | |
| 4035 | }; | | |
| 4036 | return maybeSuppressResult(rp, scope, used, &grouped_expr.base); | | |
| 4037 | } else { | | |
| 4038 | return maybeSuppressResult(rp, scope, used, &if_node.base); | | |
| 4039 | } | 3145 | } |
| | 3146 | |
| | 3147 | const if_node = try Tag.@"if".create(c.arena, .{ |
| | 3148 | .cond = cond, |
| | 3149 | .then = then_body, |
| | 3150 | .@"else" = else_body, |
| | 3151 | }); |
| | 3152 | // Clang inserts ImplicitCast(ToVoid)'s to both rhs and lhs so we don't need to supress the result here. |
| | 3153 | return if_node; |
| 4040 | } | 3154 | } |
| 4041 | | 3155 | |
| 4042 | fn maybeSuppressResult( | 3156 | fn maybeSuppressResult( |
| 4043 | rp: RestorePoint, | 3157 | c: *Context, |
| 4044 | scope: *Scope, | 3158 | scope: *Scope, |
| 4045 | used: ResultUsed, | 3159 | used: ResultUsed, |
| 4046 | result: *ast.Node, | 3160 | result: Node, |
| 4047 | ) TransError!*ast.Node { | 3161 | ) TransError!Node { |
| 4048 | if (used == .used) return result; | 3162 | if (used == .used) return result; |
| 4049 | if (scope.id != .Condition) { | 3163 | return Tag.discard.create(c.arena, result); |
| 4050 | // NOTE: This is backwards, but the semicolon must immediately follow the node. | | |
| 4051 | _ = try appendToken(rp.c, .Semicolon, ";"); | | |
| 4052 | } else { // TODO is there a way to avoid this hack? | | |
| 4053 | // this parenthesis must come immediately following the node | | |
| 4054 | _ = try appendToken(rp.c, .RParen, ")"); | | |
| 4055 | // these need to come before _ | | |
| 4056 | _ = try appendToken(rp.c, .Colon, ":"); | | |
| 4057 | _ = try appendToken(rp.c, .LParen, "("); | | |
| 4058 | } | | |
| 4059 | const lhs = try transCreateNodeIdentifier(rp.c, "_"); | | |
| 4060 | const op_token = try appendToken(rp.c, .Equal, "="); | | |
| 4061 | const op_node = try rp.c.arena.create(ast.Node.SimpleInfixOp); | | |
| 4062 | op_node.* = .{ | | |
| 4063 | .base = .{ .tag = .Assign }, | | |
| 4064 | .op_token = op_token, | | |
| 4065 | .lhs = lhs, | | |
| 4066 | .rhs = result, | | |
| 4067 | }; | | |
| 4068 | return &op_node.base; | | |
| 4069 | } | 3164 | } |
| 4070 | | 3165 | |
| 4071 | fn addTopLevelDecl(c: *Context, name: []const u8, decl_node: *ast.Node) !void { | 3166 | fn addTopLevelDecl(c: *Context, name: []const u8, decl_node: Node) !void { |
| 4072 | try c.root_decls.append(c.gpa, decl_node); | | |
| 4073 | _ = try c.global_scope.sym_table.put(name, decl_node); | 3167 | _ = try c.global_scope.sym_table.put(name, decl_node); |
| | 3168 | try c.global_scope.nodes.append(decl_node); |
| 4074 | } | 3169 | } |
| 4075 | | 3170 | |
| 4076 | /// Translate a qual type for a variable with an initializer. The initializer | 3171 | /// Translate a qual type for a variable with an initializer. The initializer |
| 4077 | /// only matters for incomplete arrays, since the size of the array is determined | 3172 | /// only matters for incomplete arrays, since the size of the array is determined |
| 4078 | /// by the size of the initializer | 3173 | /// by the size of the initializer |
| 4079 | fn transQualTypeInitialized( | 3174 | fn transQualTypeInitialized( |
| 4080 | rp: RestorePoint, | 3175 | c: *Context, |
| | 3176 | scope: *Scope, |
| 4081 | qt: clang.QualType, | 3177 | qt: clang.QualType, |
| 4082 | decl_init: *const clang.Expr, | 3178 | decl_init: *const clang.Expr, |
| 4083 | source_loc: clang.SourceLocation, | 3179 | source_loc: clang.SourceLocation, |
| 4084 | ) TypeError!*ast.Node { | 3180 | ) TypeError!Node { |
| 4085 | const ty = qt.getTypePtr(); | 3181 | const ty = qt.getTypePtr(); |
| 4086 | if (ty.getTypeClass() == .IncompleteArray) { | 3182 | if (ty.getTypeClass() == .IncompleteArray) { |
| 4087 | const incomplete_array_ty = @ptrCast(*const clang.IncompleteArrayType, ty); | 3183 | const incomplete_array_ty = @ptrCast(*const clang.IncompleteArrayType, ty); |
| 4088 | const elem_ty = incomplete_array_ty.getElementType().getTypePtr(); | 3184 | const elem_ty = try transType(c, scope, incomplete_array_ty.getElementType().getTypePtr(), source_loc); |
| 4089 | | 3185 | |
| 4090 | switch (decl_init.getStmtClass()) { | 3186 | switch (decl_init.getStmtClass()) { |
| 4091 | .StringLiteralClass => { | 3187 | .StringLiteralClass => { |
| 4092 | const string_lit = @ptrCast(*const clang.StringLiteral, decl_init); | 3188 | const string_lit = @ptrCast(*const clang.StringLiteral, decl_init); |
| 4093 | const string_lit_size = string_lit.getLength() + 1; // +1 for null terminator | 3189 | const string_lit_size = string_lit.getLength() + 1; // +1 for null terminator |
| 4094 | const array_size = @intCast(usize, string_lit_size); | 3190 | const array_size = @intCast(usize, string_lit_size); |
| 4095 | return transCreateNodeArrayType(rp, source_loc, elem_ty, array_size); | 3191 | return Tag.array_type.create(c.arena, .{ .len = array_size, .elem_type = elem_ty }); |
| 4096 | }, | 3192 | }, |
| 4097 | .InitListExprClass => { | 3193 | .InitListExprClass => { |
| 4098 | const init_expr = @ptrCast(*const clang.InitListExpr, decl_init); | 3194 | const init_expr = @ptrCast(*const clang.InitListExpr, decl_init); |
| 4099 | const size = init_expr.getNumInits(); | 3195 | const size = init_expr.getNumInits(); |
| 4100 | return transCreateNodeArrayType(rp, source_loc, elem_ty, size); | 3196 | return Tag.array_type.create(c.arena, .{ .len = size, .elem_type = elem_ty }); |
| 4101 | }, | 3197 | }, |
| 4102 | else => {}, | 3198 | else => {}, |
| 4103 | } | 3199 | } |
| 4104 | } | 3200 | } |
| 4105 | return transQualType(rp, qt, source_loc); | 3201 | return transQualType(c, scope, qt, source_loc); |
| 4106 | } | 3202 | } |
| 4107 | | 3203 | |
| 4108 | fn transQualType(rp: RestorePoint, qt: clang.QualType, source_loc: clang.SourceLocation) TypeError!*ast.Node { | 3204 | fn transQualType(c: *Context, scope: *Scope, qt: clang.QualType, source_loc: clang.SourceLocation) TypeError!Node { |
| 4109 | return transType(rp, qt.getTypePtr(), source_loc); | 3205 | return transType(c, scope, qt.getTypePtr(), source_loc); |
| 4110 | } | 3206 | } |
| 4111 | | 3207 | |
| 4112 | /// Produces a Zig AST node by translating a Clang QualType, respecting the width, but modifying the signed-ness. | 3208 | /// Produces a Zig AST node by translating a Clang QualType, respecting the width, but modifying the signed-ness. |
| 4113 | /// Asserts the type is an integer. | 3209 | /// Asserts the type is an integer. |
| 4114 | fn transQualTypeIntWidthOf(c: *Context, ty: clang.QualType, is_signed: bool) TypeError!*ast.Node { | 3210 | fn transQualTypeIntWidthOf(c: *Context, ty: clang.QualType, is_signed: bool) TypeError!Node { |
| 4115 | return transTypeIntWidthOf(c, qualTypeCanon(ty), is_signed); | 3211 | return transTypeIntWidthOf(c, qualTypeCanon(ty), is_signed); |
| 4116 | } | 3212 | } |
| 4117 | | 3213 | |
| 4118 | /// Produces a Zig AST node by translating a Clang Type, respecting the width, but modifying the signed-ness. | 3214 | /// Produces a Zig AST node by translating a Clang Type, respecting the width, but modifying the signed-ness. |
| 4119 | /// Asserts the type is an integer. | 3215 | /// Asserts the type is an integer. |
| 4120 | fn transTypeIntWidthOf(c: *Context, ty: *const clang.Type, is_signed: bool) TypeError!*ast.Node { | 3216 | fn transTypeIntWidthOf(c: *Context, ty: *const clang.Type, is_signed: bool) TypeError!Node { |
| 4121 | assert(ty.getTypeClass() == .Builtin); | 3217 | assert(ty.getTypeClass() == .Builtin); |
| 4122 | const builtin_ty = @ptrCast(*const clang.BuiltinType, ty); | 3218 | const builtin_ty = @ptrCast(*const clang.BuiltinType, ty); |
| 4123 | return transCreateNodeIdentifier(c, switch (builtin_ty.getKind()) { | 3219 | return Tag.type.create(c.arena, switch (builtin_ty.getKind()) { |
| 4124 | .Char_U, .Char_S, .UChar, .SChar, .Char8 => if (is_signed) "i8" else "u8", | 3220 | .Char_U, .Char_S, .UChar, .SChar, .Char8 => if (is_signed) "i8" else "u8", |
| 4125 | .UShort, .Short => if (is_signed) "c_short" else "c_ushort", | 3221 | .UShort, .Short => if (is_signed) "c_short" else "c_ushort", |
| 4126 | .UInt, .Int => if (is_signed) "c_int" else "c_uint", | 3222 | .UInt, .Int => if (is_signed) "c_int" else "c_uint", |
| ... | @@ -4149,7 +3245,7 @@ fn qualTypeIsBoolean(qt: clang.QualType) bool { | ... | @@ -4149,7 +3245,7 @@ fn qualTypeIsBoolean(qt: clang.QualType) bool { |
| 4149 | return qualTypeCanon(qt).isBooleanType(); | 3245 | return qualTypeCanon(qt).isBooleanType(); |
| 4150 | } | 3246 | } |
| 4151 | | 3247 | |
| 4152 | fn qualTypeIntBitWidth(rp: RestorePoint, qt: clang.QualType, source_loc: clang.SourceLocation) !u32 { | 3248 | fn qualTypeIntBitWidth(c: *Context, qt: clang.QualType) !u32 { |
| 4153 | const ty = qt.getTypePtr(); | 3249 | const ty = qt.getTypePtr(); |
| 4154 | | 3250 | |
| 4155 | switch (ty.getTypeClass()) { | 3251 | switch (ty.getTypeClass()) { |
| ... | @@ -4173,7 +3269,7 @@ fn qualTypeIntBitWidth(rp: RestorePoint, qt: clang.QualType, source_loc: clang.S | ... | @@ -4173,7 +3269,7 @@ fn qualTypeIntBitWidth(rp: RestorePoint, qt: clang.QualType, source_loc: clang.S |
| 4173 | .Typedef => { | 3269 | .Typedef => { |
| 4174 | const typedef_ty = @ptrCast(*const clang.TypedefType, ty); | 3270 | const typedef_ty = @ptrCast(*const clang.TypedefType, ty); |
| 4175 | const typedef_decl = typedef_ty.getDecl(); | 3271 | const typedef_decl = typedef_ty.getDecl(); |
| 4176 | const type_name = try rp.c.str(@ptrCast(*const clang.NamedDecl, typedef_decl).getName_bytes_begin()); | 3272 | const type_name = try c.str(@ptrCast(*const clang.NamedDecl, typedef_decl).getName_bytes_begin()); |
| 4177 | | 3273 | |
| 4178 | if (mem.eql(u8, type_name, "uint8_t") or mem.eql(u8, type_name, "int8_t")) { | 3274 | if (mem.eql(u8, type_name, "uint8_t") or mem.eql(u8, type_name, "int8_t")) { |
| 4179 | return 8; | 3275 | return 8; |
| ... | @@ -4189,55 +3285,19 @@ fn qualTypeIntBitWidth(rp: RestorePoint, qt: clang.QualType, source_loc: clang.S | ... | @@ -4189,55 +3285,19 @@ fn qualTypeIntBitWidth(rp: RestorePoint, qt: clang.QualType, source_loc: clang.S |
| 4189 | }, | 3285 | }, |
| 4190 | else => return 0, | 3286 | else => return 0, |
| 4191 | } | 3287 | } |
| 4192 | | | |
| 4193 | unreachable; | | |
| 4194 | } | 3288 | } |
| 4195 | | 3289 | |
| 4196 | fn qualTypeToLog2IntRef(rp: RestorePoint, qt: clang.QualType, source_loc: clang.SourceLocation) !*ast.Node { | 3290 | fn qualTypeToLog2IntRef(c: *Context, scope: *Scope, qt: clang.QualType, source_loc: clang.SourceLocation) !Node { |
| 4197 | const int_bit_width = try qualTypeIntBitWidth(rp, qt, source_loc); | 3291 | const int_bit_width = try qualTypeIntBitWidth(c, qt); |
| 4198 | | 3292 | |
| 4199 | if (int_bit_width != 0) { | 3293 | if (int_bit_width != 0) { |
| 4200 | // we can perform the log2 now. | 3294 | // we can perform the log2 now. |
| 4201 | const cast_bit_width = math.log2_int(u64, int_bit_width); | 3295 | const cast_bit_width = math.log2_int(u64, int_bit_width); |
| 4202 | const node = try rp.c.arena.create(ast.Node.OneToken); | 3296 | return Tag.log2_int_type.create(c.arena, cast_bit_width); |
| 4203 | node.* = .{ | 3297 | } |
| 4204 | .base = .{ .tag = .IntegerLiteral }, | | |
| 4205 | .token = try appendTokenFmt(rp.c, .Identifier, "u{d}", .{cast_bit_width}), | | |
| 4206 | }; | | |
| 4207 | return &node.base; | | |
| 4208 | } | | |
| 4209 | | | |
| 4210 | const zig_type_node = try transQualType(rp, qt, source_loc); | | |
| 4211 | | | |
| 4212 | // @import("std").math.Log2Int(c_long); | | |
| 4213 | // | | |
| 4214 | // FnCall | | |
| 4215 | // FieldAccess | | |
| 4216 | // FieldAccess | | |
| 4217 | // FnCall (.builtin = true) | | |
| 4218 | // Symbol "import" | | |
| 4219 | // StringLiteral "std" | | |
| 4220 | // Symbol "math" | | |
| 4221 | // Symbol "Log2Int" | | |
| 4222 | // Symbol <zig_type_node> (var from above) | | |
| 4223 | | | |
| 4224 | const import_fn_call = try rp.c.createBuiltinCall("@import", 1); | | |
| 4225 | const std_token = try appendToken(rp.c, .StringLiteral, "\"std\""); | | |
| 4226 | const std_node = try rp.c.arena.create(ast.Node.OneToken); | | |
| 4227 | std_node.* = .{ | | |
| 4228 | .base = .{ .tag = .StringLiteral }, | | |
| 4229 | .token = std_token, | | |
| 4230 | }; | | |
| 4231 | import_fn_call.params()[0] = &std_node.base; | | |
| 4232 | import_fn_call.rparen_token = try appendToken(rp.c, .RParen, ")"); | | |
| 4233 | | | |
| 4234 | const inner_field_access = try transCreateNodeFieldAccess(rp.c, &import_fn_call.base, "math"); | | |
| 4235 | const outer_field_access = try transCreateNodeFieldAccess(rp.c, inner_field_access, "Log2Int"); | | |
| 4236 | const log2int_fn_call = try rp.c.createCall(outer_field_access, 1); | | |
| 4237 | log2int_fn_call.params()[0] = zig_type_node; | | |
| 4238 | log2int_fn_call.rtoken = try appendToken(rp.c, .RParen, ")"); | | |
| 4239 | | 3298 | |
| 4240 | return &log2int_fn_call.base; | 3299 | const zig_type = try transQualType(c, scope, qt, source_loc); |
| | 3300 | return Tag.std_math_Log2Int.create(c.arena, zig_type); |
| 4241 | } | 3301 | } |
| 4242 | | 3302 | |
| 4243 | fn qualTypeChildIsFnProto(qt: clang.QualType) bool { | 3303 | fn qualTypeChildIsFnProto(qt: clang.QualType) bool { |
| ... | @@ -4401,28 +3461,22 @@ fn cIsLongLongInteger(qt: clang.QualType) bool { | ... | @@ -4401,28 +3461,22 @@ fn cIsLongLongInteger(qt: clang.QualType) bool { |
| 4401 | }; | 3461 | }; |
| 4402 | } | 3462 | } |
| 4403 | fn transCreateNodeAssign( | 3463 | fn transCreateNodeAssign( |
| 4404 | rp: RestorePoint, | 3464 | c: *Context, |
| 4405 | scope: *Scope, | 3465 | scope: *Scope, |
| 4406 | result_used: ResultUsed, | 3466 | result_used: ResultUsed, |
| 4407 | lhs: *const clang.Expr, | 3467 | lhs: *const clang.Expr, |
| 4408 | rhs: *const clang.Expr, | 3468 | rhs: *const clang.Expr, |
| 4409 | ) !*ast.Node { | 3469 | ) !Node { |
| 4410 | // common case | 3470 | // common case |
| 4411 | // c: lhs = rhs | 3471 | // c: lhs = rhs |
| 4412 | // zig: lhs = rhs | 3472 | // zig: lhs = rhs |
| 4413 | if (result_used == .unused) { | 3473 | if (result_used == .unused) { |
| 4414 | const lhs_node = try transExpr(rp, scope, lhs, .used, .l_value); | 3474 | const lhs_node = try transExpr(c, scope, lhs, .used); |
| 4415 | const eq_token = try appendToken(rp.c, .Equal, "="); | 3475 | var rhs_node = try transExprCoercing(c, scope, rhs, .used); |
| 4416 | var rhs_node = try transExprCoercing(rp, scope, rhs, .used, .r_value); | | |
| 4417 | if (!exprIsBooleanType(lhs) and isBoolRes(rhs_node)) { | 3476 | if (!exprIsBooleanType(lhs) and isBoolRes(rhs_node)) { |
| 4418 | const builtin_node = try rp.c.createBuiltinCall("@boolToInt", 1); | 3477 | rhs_node = try Tag.bool_to_int.create(c.arena, rhs_node); |
| 4419 | builtin_node.params()[0] = rhs_node; | | |
| 4420 | builtin_node.rparen_token = try appendToken(rp.c, .RParen, ")"); | | |
| 4421 | rhs_node = &builtin_node.base; | | |
| 4422 | } | 3478 | } |
| 4423 | if (scope.id != .Condition) | 3479 | return transCreateNodeInfixOp(c, scope, .assign, lhs_node, rhs_node, .used); |
| 4424 | _ = try appendToken(rp.c, .Semicolon, ";"); | | |
| 4425 | return transCreateNodeInfixOp(rp, scope, lhs_node, .Assign, eq_token, rhs_node, .used, false); | | |
| 4426 | } | 3480 | } |
| 4427 | | 3481 | |
| 4428 | // worst case | 3482 | // worst case |
| ... | @@ -4432,176 +3486,62 @@ fn transCreateNodeAssign( | ... | @@ -4432,176 +3486,62 @@ fn transCreateNodeAssign( |
| 4432 | // zig: lhs = _tmp; | 3486 | // zig: lhs = _tmp; |
| 4433 | // zig: break :blk _tmp | 3487 | // zig: break :blk _tmp |
| 4434 | // zig: }) | 3488 | // zig: }) |
| 4435 | var block_scope = try Scope.Block.init(rp.c, scope, true); | 3489 | var block_scope = try Scope.Block.init(c, scope, true); |
| 4436 | defer block_scope.deinit(); | 3490 | defer block_scope.deinit(); |
| 4437 | | 3491 | |
| 4438 | const tmp = try block_scope.makeMangledName(rp.c, "tmp"); | 3492 | const tmp = try block_scope.makeMangledName(c, "tmp"); |
| 4439 | const mut_tok = try appendToken(rp.c, .Keyword_const, "const"); | 3493 | const rhs_node = try transExpr(c, &block_scope.base, rhs, .used); |
| 4440 | const name_tok = try appendIdentifier(rp.c, tmp); | 3494 | const tmp_decl = try Tag.var_simple.create(c.arena, .{ .name = tmp, .init = rhs_node }); |
| 4441 | const eq_token = try appendToken(rp.c, .Equal, "="); | 3495 | try block_scope.statements.append(tmp_decl); |
| 4442 | var rhs_node = try transExpr(rp, &block_scope.base, rhs, .used, .r_value); | | |
| 4443 | if (!exprIsBooleanType(lhs) and isBoolRes(rhs_node)) { | | |
| 4444 | const builtin_node = try rp.c.createBuiltinCall("@boolToInt", 1); | | |
| 4445 | builtin_node.params()[0] = rhs_node; | | |
| 4446 | builtin_node.rparen_token = try appendToken(rp.c, .RParen, ")"); | | |
| 4447 | rhs_node = &builtin_node.base; | | |
| 4448 | } | | |
| 4449 | const init_node = rhs_node; | | |
| 4450 | const semicolon_token = try appendToken(rp.c, .Semicolon, ";"); | | |
| 4451 | const node = try ast.Node.VarDecl.create(rp.c.arena, .{ | | |
| 4452 | .name_token = name_tok, | | |
| 4453 | .mut_token = mut_tok, | | |
| 4454 | .semicolon_token = semicolon_token, | | |
| 4455 | }, .{ | | |
| 4456 | .eq_token = eq_token, | | |
| 4457 | .init_node = init_node, | | |
| 4458 | }); | | |
| 4459 | try block_scope.statements.append(&node.base); | | |
| 4460 | | | |
| 4461 | const lhs_node = try transExpr(rp, &block_scope.base, lhs, .used, .l_value); | | |
| 4462 | const lhs_eq_token = try appendToken(rp.c, .Equal, "="); | | |
| 4463 | const ident = try transCreateNodeIdentifier(rp.c, tmp); | | |
| 4464 | _ = try appendToken(rp.c, .Semicolon, ";"); | | |
| 4465 | | | |
| 4466 | const assign = try transCreateNodeInfixOp(rp, &block_scope.base, lhs_node, .Assign, lhs_eq_token, ident, .used, false); | | |
| 4467 | try block_scope.statements.append(assign); | | |
| 4468 | | | |
| 4469 | const break_node = blk: { | | |
| 4470 | var tmp_ctrl_flow = try CtrlFlow.init(rp.c, .Break, tokenSlice(rp.c, block_scope.label.?)); | | |
| 4471 | const rhs_expr = try transCreateNodeIdentifier(rp.c, tmp); | | |
| 4472 | break :blk try tmp_ctrl_flow.finish(rhs_expr); | | |
| 4473 | }; | | |
| 4474 | _ = try appendToken(rp.c, .Semicolon, ";"); | | |
| 4475 | try block_scope.statements.append(&break_node.base); | | |
| 4476 | const block_node = try block_scope.complete(rp.c); | | |
| 4477 | // semicolon must immediately follow rbrace because it is the last token in a block | | |
| 4478 | _ = try appendToken(rp.c, .Semicolon, ";"); | | |
| 4479 | return block_node; | | |
| 4480 | } | | |
| 4481 | | | |
| 4482 | fn transCreateNodeFieldAccess(c: *Context, container: *ast.Node, field_name: []const u8) !*ast.Node { | | |
| 4483 | const field_access_node = try c.arena.create(ast.Node.SimpleInfixOp); | | |
| 4484 | field_access_node.* = .{ | | |
| 4485 | .base = .{ .tag = .Period }, | | |
| 4486 | .op_token = try appendToken(c, .Period, "."), | | |
| 4487 | .lhs = container, | | |
| 4488 | .rhs = try transCreateNodeIdentifier(c, field_name), | | |
| 4489 | }; | | |
| 4490 | return &field_access_node.base; | | |
| 4491 | } | | |
| 4492 | | 3496 | |
| 4493 | fn transCreateNodeSimplePrefixOp( | 3497 | const lhs_node = try transExpr(c, &block_scope.base, lhs, .used); |
| 4494 | c: *Context, | 3498 | const tmp_ident = try Tag.identifier.create(c.arena, tmp); |
| 4495 | comptime tag: ast.Node.Tag, | 3499 | const assign = try transCreateNodeInfixOp(c, &block_scope.base, .assign, lhs_node, tmp_ident, .used); |
| 4496 | op_tok_id: std.zig.Token.Id, | 3500 | try block_scope.statements.append(assign); |
| 4497 | bytes: []const u8, | 3501 | |
| 4498 | ) !*ast.Node.SimplePrefixOp { | 3502 | const break_node = try Tag.break_val.create(c.arena, .{ |
| 4499 | const node = try c.arena.create(ast.Node.SimplePrefixOp); | 3503 | .label = block_scope.label, |
| 4500 | node.* = .{ | 3504 | .val = tmp_ident, |
| 4501 | .base = .{ .tag = tag }, | 3505 | }); |
| 4502 | .op_token = try appendToken(c, op_tok_id, bytes), | 3506 | try block_scope.statements.append(break_node); |
| 4503 | .rhs = undefined, // translate and set afterward | 3507 | return block_scope.complete(c); |
| 4504 | }; | | |
| 4505 | return node; | | |
| 4506 | } | 3508 | } |
| 4507 | | 3509 | |
| 4508 | fn transCreateNodeInfixOp( | 3510 | fn transCreateNodeInfixOp( |
| 4509 | rp: RestorePoint, | 3511 | c: *Context, |
| 4510 | scope: *Scope, | 3512 | scope: *Scope, |
| 4511 | lhs_node: *ast.Node, | 3513 | op: Tag, |
| 4512 | op: ast.Node.Tag, | 3514 | lhs: Node, |
| 4513 | op_token: ast.TokenIndex, | 3515 | rhs: Node, |
| 4514 | rhs_node: *ast.Node, | | |
| 4515 | used: ResultUsed, | 3516 | used: ResultUsed, |
| 4516 | grouped: bool, | 3517 | ) !Node { |
| 4517 | ) !*ast.Node { | 3518 | const payload = try c.arena.create(ast.Payload.BinOp); |
| 4518 | var lparen = if (grouped) | 3519 | payload.* = .{ |
| 4519 | try appendToken(rp.c, .LParen, "(") | | |
| 4520 | else | | |
| 4521 | null; | | |
| 4522 | const node = try rp.c.arena.create(ast.Node.SimpleInfixOp); | | |
| 4523 | node.* = .{ | | |
| 4524 | .base = .{ .tag = op }, | 3520 | .base = .{ .tag = op }, |
| 4525 | .op_token = op_token, | 3521 | .data = .{ |
| 4526 | .lhs = lhs_node, | 3522 | .lhs = lhs, |
| 4527 | .rhs = rhs_node, | 3523 | .rhs = rhs, |
| 4528 | }; | 3524 | }, |
| 4529 | if (!grouped) return maybeSuppressResult(rp, scope, used, &node.base); | | |
| 4530 | const rparen = try appendToken(rp.c, .RParen, ")"); | | |
| 4531 | const grouped_expr = try rp.c.arena.create(ast.Node.GroupedExpression); | | |
| 4532 | grouped_expr.* = .{ | | |
| 4533 | .lparen = lparen.?, | | |
| 4534 | .expr = &node.base, | | |
| 4535 | .rparen = rparen, | | |
| 4536 | }; | 3525 | }; |
| 4537 | return maybeSuppressResult(rp, scope, used, &grouped_expr.base); | 3526 | return maybeSuppressResult(c, scope, used, Node.initPayload(&payload.base)); |
| 4538 | } | 3527 | } |
| 4539 | | 3528 | |
| 4540 | fn transCreateNodeBoolInfixOp( | 3529 | fn transCreateNodeBoolInfixOp( |
| 4541 | rp: RestorePoint, | 3530 | c: *Context, |
| 4542 | scope: *Scope, | 3531 | scope: *Scope, |
| 4543 | stmt: *const clang.BinaryOperator, | 3532 | stmt: *const clang.BinaryOperator, |
| 4544 | op: ast.Node.Tag, | 3533 | op: Tag, |
| 4545 | used: ResultUsed, | 3534 | used: ResultUsed, |
| 4546 | grouped: bool, | 3535 | ) !Node { |
| 4547 | ) !*ast.Node { | 3536 | std.debug.assert(op == .@"and" or op == .@"or"); |
| 4548 | std.debug.assert(op == .BoolAnd or op == .BoolOr); | | |
| 4549 | | | |
| 4550 | const lhs_hode = try transBoolExpr(rp, scope, stmt.getLHS(), .used, .l_value, true); | | |
| 4551 | const op_token = if (op == .BoolAnd) | | |
| 4552 | try appendToken(rp.c, .Keyword_and, "and") | | |
| 4553 | else | | |
| 4554 | try appendToken(rp.c, .Keyword_or, "or"); | | |
| 4555 | const rhs = try transBoolExpr(rp, scope, stmt.getRHS(), .used, .r_value, true); | | |
| 4556 | | 3537 | |
| 4557 | return transCreateNodeInfixOp( | 3538 | const lhs = try transBoolExpr(c, scope, stmt.getLHS(), .used); |
| 4558 | rp, | 3539 | const rhs = try transBoolExpr(c, scope, stmt.getRHS(), .used); |
| 4559 | scope, | | |
| 4560 | lhs_hode, | | |
| 4561 | op, | | |
| 4562 | op_token, | | |
| 4563 | rhs, | | |
| 4564 | used, | | |
| 4565 | grouped, | | |
| 4566 | ); | | |
| 4567 | } | | |
| 4568 | | 3540 | |
| 4569 | fn transCreateNodePtrType( | 3541 | return transCreateNodeInfixOp(c, scope, op, lhs, rhs, used); |
| 4570 | c: *Context, | | |
| 4571 | is_const: bool, | | |
| 4572 | is_volatile: bool, | | |
| 4573 | op_tok_id: std.zig.Token.Id, | | |
| 4574 | ) !*ast.Node.PtrType { | | |
| 4575 | const node = try c.arena.create(ast.Node.PtrType); | | |
| 4576 | const op_token = switch (op_tok_id) { | | |
| 4577 | .LBracket => blk: { | | |
| 4578 | const lbracket = try appendToken(c, .LBracket, "["); | | |
| 4579 | _ = try appendToken(c, .Asterisk, "*"); | | |
| 4580 | _ = try appendToken(c, .RBracket, "]"); | | |
| 4581 | break :blk lbracket; | | |
| 4582 | }, | | |
| 4583 | .Identifier => blk: { | | |
| 4584 | const lbracket = try appendToken(c, .LBracket, "["); // Rendering checks if this token + 2 == .Identifier, so needs to return this token | | |
| 4585 | _ = try appendToken(c, .Asterisk, "*"); | | |
| 4586 | _ = try appendIdentifier(c, "c"); | | |
| 4587 | _ = try appendToken(c, .RBracket, "]"); | | |
| 4588 | break :blk lbracket; | | |
| 4589 | }, | | |
| 4590 | .Asterisk => try appendToken(c, .Asterisk, "*"), | | |
| 4591 | else => unreachable, | | |
| 4592 | }; | | |
| 4593 | node.* = .{ | | |
| 4594 | .op_token = op_token, | | |
| 4595 | .ptr_info = .{ | | |
| 4596 | .const_token = if (is_const) try appendToken(c, .Keyword_const, "const") else null, | | |
| 4597 | .volatile_token = if (is_volatile) try appendToken(c, .Keyword_volatile, "volatile") else null, | | |
| 4598 | }, | | |
| 4599 | .rhs = undefined, // translate and set afterward | | |
| 4600 | }; | | |
| 4601 | return node; | | |
| 4602 | } | 3542 | } |
| 4603 | | 3543 | |
| 4604 | fn transCreateNodeAPInt(c: *Context, int: *const clang.APSInt) !*ast.Node { | 3544 | fn transCreateNodeAPInt(c: *Context, int: *const clang.APSInt) !Node { |
| 4605 | const num_limbs = math.cast(usize, int.getNumWords()) catch |err| switch (err) { | 3545 | const num_limbs = math.cast(usize, int.getNumWords()) catch |err| switch (err) { |
| 4606 | error.Overflow => return error.OutOfMemory, | 3546 | error.Overflow => return error.OutOfMemory, |
| 4607 | }; | 3547 | }; |
| ... | @@ -4637,418 +3577,96 @@ fn transCreateNodeAPInt(c: *Context, int: *const clang.APSInt) !*ast.Node { | ... | @@ -4637,418 +3577,96 @@ fn transCreateNodeAPInt(c: *Context, int: *const clang.APSInt) !*ast.Node { |
| 4637 | else => @compileError("unimplemented"), | 3577 | else => @compileError("unimplemented"), |
| 4638 | } | 3578 | } |
| 4639 | | 3579 | |
| 4640 | const big: math.big.int.Const = .{ .limbs = limbs, .positive = !is_negative }; | 3580 | const big: math.big.int.Const = .{ .limbs = limbs, .positive = true }; |
| 4641 | const str = big.toStringAlloc(c.arena, 10, false) catch |err| switch (err) { | 3581 | const str = big.toStringAlloc(c.arena, 10, false) catch |err| switch (err) { |
| 4642 | error.OutOfMemory => return error.OutOfMemory, | 3582 | error.OutOfMemory => return error.OutOfMemory, |
| 4643 | }; | 3583 | }; |
| 4644 | defer c.arena.free(str); | 3584 | const res = try Tag.integer_literal.create(c.arena, str); |
| 4645 | const token = try appendToken(c, .IntegerLiteral, str); | 3585 | if (is_negative) return Tag.negate.create(c.arena, res); |
| 4646 | const node = try c.arena.create(ast.Node.OneToken); | 3586 | return res; |
| 4647 | node.* = .{ | | |
| 4648 | .base = .{ .tag = .IntegerLiteral }, | | |
| 4649 | .token = token, | | |
| 4650 | }; | | |
| 4651 | return &node.base; | | |
| 4652 | } | | |
| 4653 | | | |
| 4654 | fn transCreateNodeUndefinedLiteral(c: *Context) !*ast.Node { | | |
| 4655 | const token = try appendToken(c, .Keyword_undefined, "undefined"); | | |
| 4656 | const node = try c.arena.create(ast.Node.OneToken); | | |
| 4657 | node.* = .{ | | |
| 4658 | .base = .{ .tag = .UndefinedLiteral }, | | |
| 4659 | .token = token, | | |
| 4660 | }; | | |
| 4661 | return &node.base; | | |
| 4662 | } | | |
| 4663 | | | |
| 4664 | fn transCreateNodeNullLiteral(c: *Context) !*ast.Node { | | |
| 4665 | const token = try appendToken(c, .Keyword_null, "null"); | | |
| 4666 | const node = try c.arena.create(ast.Node.OneToken); | | |
| 4667 | node.* = .{ | | |
| 4668 | .base = .{ .tag = .NullLiteral }, | | |
| 4669 | .token = token, | | |
| 4670 | }; | | |
| 4671 | return &node.base; | | |
| 4672 | } | 3587 | } |
| 4673 | | 3588 | |
| 4674 | fn transCreateNodeBoolLiteral(c: *Context, value: bool) !*ast.Node { | 3589 | fn transCreateNodeNumber(c: *Context, num: anytype, num_kind: enum { int, float }) !Node { |
| 4675 | const token = if (value) | 3590 | const fmt_s = if (comptime std.meta.trait.isNumber(@TypeOf(num))) "{d}" else "{s}"; |
| 4676 | try appendToken(c, .Keyword_true, "true") | 3591 | const str = try std.fmt.allocPrint(c.arena, fmt_s, .{num}); |
| | 3592 | if (num_kind == .float) |
| | 3593 | return Tag.float_literal.create(c.arena, str) |
| 4677 | else | 3594 | else |
| 4678 | try appendToken(c, .Keyword_false, "false"); | 3595 | return Tag.integer_literal.create(c.arena, str); |
| 4679 | const node = try c.arena.create(ast.Node.OneToken); | | |
| 4680 | node.* = .{ | | |
| 4681 | .base = .{ .tag = .BoolLiteral }, | | |
| 4682 | .token = token, | | |
| 4683 | }; | | |
| 4684 | return &node.base; | | |
| 4685 | } | | |
| 4686 | | | |
| 4687 | fn transCreateNodeInt(c: *Context, int: anytype) !*ast.Node { | | |
| 4688 | const fmt_s = if (comptime std.meta.trait.isIntegerNumber(@TypeOf(int))) "{d}" else "{s}"; | | |
| 4689 | const token = try appendTokenFmt(c, .IntegerLiteral, fmt_s, .{int}); | | |
| 4690 | const node = try c.arena.create(ast.Node.OneToken); | | |
| 4691 | node.* = .{ | | |
| 4692 | .base = .{ .tag = .IntegerLiteral }, | | |
| 4693 | .token = token, | | |
| 4694 | }; | | |
| 4695 | return &node.base; | | |
| 4696 | } | 3596 | } |
| 4697 | | 3597 | |
| 4698 | fn transCreateNodeFloat(c: *Context, str: []const u8) !*ast.Node { | 3598 | fn transCreateNodeMacroFn(c: *Context, name: []const u8, ref: Node, proto_alias: *ast.Payload.Func) !Node { |
| 4699 | const token = try appendTokenFmt(c, .FloatLiteral, "{s}", .{str}); | | |
| 4700 | const node = try c.arena.create(ast.Node.OneToken); | | |
| 4701 | node.* = .{ | | |
| 4702 | .base = .{ .tag = .FloatLiteral }, | | |
| 4703 | .token = token, | | |
| 4704 | }; | | |
| 4705 | return &node.base; | | |
| 4706 | } | | |
| 4707 | | | |
| 4708 | fn transCreateNodeOpaqueType(c: *Context) !*ast.Node { | | |
| 4709 | const container_tok = try appendToken(c, .Keyword_opaque, "opaque"); | | |
| 4710 | const lbrace_token = try appendToken(c, .LBrace, "{"); | | |
| 4711 | const container_node = try ast.Node.ContainerDecl.alloc(c.arena, 0); | | |
| 4712 | container_node.* = .{ | | |
| 4713 | .kind_token = container_tok, | | |
| 4714 | .layout_token = null, | | |
| 4715 | .lbrace_token = lbrace_token, | | |
| 4716 | .rbrace_token = try appendToken(c, .RBrace, "}"), | | |
| 4717 | .fields_and_decls_len = 0, | | |
| 4718 | .init_arg_expr = .None, | | |
| 4719 | }; | | |
| 4720 | return &container_node.base; | | |
| 4721 | } | | |
| 4722 | | | |
| 4723 | fn transCreateNodeMacroFn(c: *Context, name: []const u8, ref: *ast.Node, proto_alias: *ast.Node.FnProto) !*ast.Node { | | |
| 4724 | const scope = &c.global_scope.base; | 3599 | const scope = &c.global_scope.base; |
| 4725 | | 3600 | |
| 4726 | const pub_tok = try appendToken(c, .Keyword_pub, "pub"); | 3601 | var fn_params = std.ArrayList(ast.Payload.Param).init(c.gpa); |
| 4727 | const fn_tok = try appendToken(c, .Keyword_fn, "fn"); | | |
| 4728 | const name_tok = try appendIdentifier(c, name); | | |
| 4729 | _ = try appendToken(c, .LParen, "("); | | |
| 4730 | | | |
| 4731 | var fn_params = std.ArrayList(ast.Node.FnProto.ParamDecl).init(c.gpa); | | |
| 4732 | defer fn_params.deinit(); | 3602 | defer fn_params.deinit(); |
| 4733 | | 3603 | |
| 4734 | for (proto_alias.params()) |param, i| { | 3604 | for (proto_alias.data.params) |param, i| { |
| 4735 | if (i != 0) { | 3605 | const param_name = param.name orelse |
| 4736 | _ = try appendToken(c, .Comma, ","); | 3606 | try std.fmt.allocPrint(c.arena, "arg_{d}", .{c.getMangle()}); |
| 4737 | } | | |
| 4738 | const param_name_tok = param.name_token orelse | | |
| 4739 | try appendTokenFmt(c, .Identifier, "arg_{d}", .{c.getMangle()}); | | |
| 4740 | | | |
| 4741 | _ = try appendToken(c, .Colon, ":"); | | |
| 4742 | | 3607 | |
| 4743 | (try fn_params.addOne()).* = .{ | 3608 | try fn_params.append(.{ |
| 4744 | .doc_comments = null, | 3609 | .name = param_name, |
| 4745 | .comptime_token = null, | 3610 | .type = param.type, |
| 4746 | .noalias_token = param.noalias_token, | 3611 | .is_noalias = param.is_noalias, |
| 4747 | .name_token = param_name_tok, | 3612 | }); |
| 4748 | .param_type = param.param_type, | | |
| 4749 | }; | | |
| 4750 | } | 3613 | } |
| 4751 | | 3614 | |
| 4752 | _ = try appendToken(c, .RParen, ")"); | 3615 | const init = if (ref.castTag(.var_decl)) |v| |
| 4753 | | 3616 | v.data.init.? |
| 4754 | _ = try appendToken(c, .Keyword_callconv, "callconv"); | 3617 | else if (ref.castTag(.var_simple) orelse ref.castTag(.pub_var_simple)) |v| |
| 4755 | _ = try appendToken(c, .LParen, "("); | 3618 | v.data.init |
| 4756 | const callconv_expr = try transCreateNodeEnumLiteral(c, "Inline"); | 3619 | else |
| 4757 | _ = try appendToken(c, .RParen, ")"); | 3620 | unreachable; |
| 4758 | | | |
| 4759 | const block_lbrace = try appendToken(c, .LBrace, "{"); | | |
| 4760 | | | |
| 4761 | const return_kw = try appendToken(c, .Keyword_return, "return"); | | |
| 4762 | const unwrap_expr = try transCreateNodeUnwrapNull(c, ref.cast(ast.Node.VarDecl).?.getInitNode().?); | | |
| 4763 | | | |
| 4764 | const call_expr = try c.createCall(unwrap_expr, fn_params.items.len); | | |
| 4765 | const call_params = call_expr.params(); | | |
| 4766 | | 3621 | |
| | 3622 | const unwrap_expr = try Tag.unwrap.create(c.arena, init); |
| | 3623 | const args = try c.arena.alloc(Node, fn_params.items.len); |
| 4767 | for (fn_params.items) |param, i| { | 3624 | for (fn_params.items) |param, i| { |
| 4768 | if (i != 0) { | 3625 | args[i] = try Tag.identifier.create(c.arena, param.name.?); |
| 4769 | _ = try appendToken(c, .Comma, ","); | | |
| 4770 | } | | |
| 4771 | call_params[i] = try transCreateNodeIdentifier(c, tokenSlice(c, param.name_token.?)); | | |
| 4772 | } | 3626 | } |
| 4773 | call_expr.rtoken = try appendToken(c, .RParen, ")"); | 3627 | const call_expr = try Tag.call.create(c.arena, .{ |
| 4774 | | 3628 | .lhs = unwrap_expr, |
| 4775 | const return_expr = try ast.Node.ControlFlowExpression.create(c.arena, .{ | 3629 | .args = args, |
| 4776 | .ltoken = return_kw, | | |
| 4777 | .tag = .Return, | | |
| 4778 | }, .{ | | |
| 4779 | .rhs = &call_expr.base, | | |
| 4780 | }); | 3630 | }); |
| 4781 | _ = try appendToken(c, .Semicolon, ";"); | 3631 | const return_expr = try Tag.@"return".create(c.arena, call_expr); |
| 4782 | | 3632 | const block = try Tag.block_single.create(c.arena, return_expr); |
| 4783 | const block = try ast.Node.Block.alloc(c.arena, 1); | 3633 | |
| 4784 | block.* = .{ | 3634 | return Tag.pub_inline_fn.create(c.arena, .{ |
| 4785 | .lbrace = block_lbrace, | 3635 | .name = name, |
| 4786 | .statements_len = 1, | 3636 | .params = try c.arena.dupe(ast.Payload.Param, fn_params.items), |
| 4787 | .rbrace = try appendToken(c, .RBrace, "}"), | 3637 | .return_type = proto_alias.data.return_type, |
| 4788 | }; | 3638 | .body = block, |
| 4789 | block.statements()[0] = &return_expr.base; | | |
| 4790 | | | |
| 4791 | const fn_proto = try ast.Node.FnProto.create(c.arena, .{ | | |
| 4792 | .params_len = fn_params.items.len, | | |
| 4793 | .fn_token = fn_tok, | | |
| 4794 | .return_type = proto_alias.return_type, | | |
| 4795 | }, .{ | | |
| 4796 | .visib_token = pub_tok, | | |
| 4797 | .name_token = name_tok, | | |
| 4798 | .body_node = &block.base, | | |
| 4799 | .callconv_expr = callconv_expr, | | |
| 4800 | }); | 3639 | }); |
| 4801 | mem.copy(ast.Node.FnProto.ParamDecl, fn_proto.params(), fn_params.items); | | |
| 4802 | return &fn_proto.base; | | |
| 4803 | } | | |
| 4804 | | | |
| 4805 | fn transCreateNodeUnwrapNull(c: *Context, wrapped: *ast.Node) !*ast.Node { | | |
| 4806 | _ = try appendToken(c, .Period, "."); | | |
| 4807 | const qm = try appendToken(c, .QuestionMark, "?"); | | |
| 4808 | const node = try c.arena.create(ast.Node.SimpleSuffixOp); | | |
| 4809 | node.* = .{ | | |
| 4810 | .base = .{ .tag = .UnwrapOptional }, | | |
| 4811 | .lhs = wrapped, | | |
| 4812 | .rtoken = qm, | | |
| 4813 | }; | | |
| 4814 | return &node.base; | | |
| 4815 | } | | |
| 4816 | | | |
| 4817 | fn transCreateNodeEnumLiteral(c: *Context, name: []const u8) !*ast.Node { | | |
| 4818 | const node = try c.arena.create(ast.Node.EnumLiteral); | | |
| 4819 | node.* = .{ | | |
| 4820 | .dot = try appendToken(c, .Period, "."), | | |
| 4821 | .name = try appendIdentifier(c, name), | | |
| 4822 | }; | | |
| 4823 | return &node.base; | | |
| 4824 | } | | |
| 4825 | | | |
| 4826 | fn transCreateNodeStringLiteral(c: *Context, str: []const u8) !*ast.Node { | | |
| 4827 | const node = try c.arena.create(ast.Node.OneToken); | | |
| 4828 | node.* = .{ | | |
| 4829 | .base = .{ .tag = .StringLiteral }, | | |
| 4830 | .token = try appendToken(c, .StringLiteral, str), | | |
| 4831 | }; | | |
| 4832 | return &node.base; | | |
| 4833 | } | | |
| 4834 | | | |
| 4835 | fn transCreateNodeIf(c: *Context) !*ast.Node.If { | | |
| 4836 | const if_tok = try appendToken(c, .Keyword_if, "if"); | | |
| 4837 | _ = try appendToken(c, .LParen, "("); | | |
| 4838 | const node = try c.arena.create(ast.Node.If); | | |
| 4839 | node.* = .{ | | |
| 4840 | .if_token = if_tok, | | |
| 4841 | .condition = undefined, | | |
| 4842 | .payload = null, | | |
| 4843 | .body = undefined, | | |
| 4844 | .@"else" = null, | | |
| 4845 | }; | | |
| 4846 | return node; | | |
| 4847 | } | | |
| 4848 | | | |
| 4849 | fn transCreateNodeElse(c: *Context) !*ast.Node.Else { | | |
| 4850 | const node = try c.arena.create(ast.Node.Else); | | |
| 4851 | node.* = .{ | | |
| 4852 | .else_token = try appendToken(c, .Keyword_else, "else"), | | |
| 4853 | .payload = null, | | |
| 4854 | .body = undefined, | | |
| 4855 | }; | | |
| 4856 | return node; | | |
| 4857 | } | | |
| 4858 | | | |
| 4859 | fn transCreateNodeBreak( | | |
| 4860 | c: *Context, | | |
| 4861 | label: ?ast.TokenIndex, | | |
| 4862 | rhs: ?*ast.Node, | | |
| 4863 | ) !*ast.Node.ControlFlowExpression { | | |
| 4864 | var ctrl_flow = try CtrlFlow.init(c, .Break, if (label) |l| tokenSlice(c, l) else null); | | |
| 4865 | return ctrl_flow.finish(rhs); | | |
| 4866 | } | | |
| 4867 | | | |
| 4868 | const CtrlFlow = struct { | | |
| 4869 | c: *Context, | | |
| 4870 | ltoken: ast.TokenIndex, | | |
| 4871 | label_token: ?ast.TokenIndex, | | |
| 4872 | tag: ast.Node.Tag, | | |
| 4873 | | | |
| 4874 | /// Does everything except the RHS. | | |
| 4875 | fn init(c: *Context, tag: ast.Node.Tag, label: ?[]const u8) !CtrlFlow { | | |
| 4876 | const kw: Token.Id = switch (tag) { | | |
| 4877 | .Break => .Keyword_break, | | |
| 4878 | .Continue => .Keyword_continue, | | |
| 4879 | .Return => .Keyword_return, | | |
| 4880 | else => unreachable, | | |
| 4881 | }; | | |
| 4882 | const kw_text = switch (tag) { | | |
| 4883 | .Break => "break", | | |
| 4884 | .Continue => "continue", | | |
| 4885 | .Return => "return", | | |
| 4886 | else => unreachable, | | |
| 4887 | }; | | |
| 4888 | const ltoken = try appendToken(c, kw, kw_text); | | |
| 4889 | const label_token = if (label) |l| blk: { | | |
| 4890 | _ = try appendToken(c, .Colon, ":"); | | |
| 4891 | break :blk try appendIdentifier(c, l); | | |
| 4892 | } else null; | | |
| 4893 | return CtrlFlow{ | | |
| 4894 | .c = c, | | |
| 4895 | .ltoken = ltoken, | | |
| 4896 | .label_token = label_token, | | |
| 4897 | .tag = tag, | | |
| 4898 | }; | | |
| 4899 | } | | |
| 4900 | | | |
| 4901 | fn initToken(c: *Context, tag: ast.Node.Tag, label: ?ast.TokenIndex) !CtrlFlow { | | |
| 4902 | const other_token = label orelse return init(c, tag, null); | | |
| 4903 | const loc = c.token_locs.items[other_token]; | | |
| 4904 | const label_name = c.source_buffer.items[loc.start..loc.end]; | | |
| 4905 | return init(c, tag, label_name); | | |
| 4906 | } | | |
| 4907 | | | |
| 4908 | fn finish(self: *CtrlFlow, rhs: ?*ast.Node) !*ast.Node.ControlFlowExpression { | | |
| 4909 | return ast.Node.ControlFlowExpression.create(self.c.arena, .{ | | |
| 4910 | .ltoken = self.ltoken, | | |
| 4911 | .tag = self.tag, | | |
| 4912 | }, .{ | | |
| 4913 | .label = self.label_token, | | |
| 4914 | .rhs = rhs, | | |
| 4915 | }); | | |
| 4916 | } | | |
| 4917 | }; | | |
| 4918 | | | |
| 4919 | fn transCreateNodeWhile(c: *Context) !*ast.Node.While { | | |
| 4920 | const while_tok = try appendToken(c, .Keyword_while, "while"); | | |
| 4921 | _ = try appendToken(c, .LParen, "("); | | |
| 4922 | | | |
| 4923 | const node = try c.arena.create(ast.Node.While); | | |
| 4924 | node.* = .{ | | |
| 4925 | .label = null, | | |
| 4926 | .inline_token = null, | | |
| 4927 | .while_token = while_tok, | | |
| 4928 | .condition = undefined, | | |
| 4929 | .payload = null, | | |
| 4930 | .continue_expr = null, | | |
| 4931 | .body = undefined, | | |
| 4932 | .@"else" = null, | | |
| 4933 | }; | | |
| 4934 | return node; | | |
| 4935 | } | | |
| 4936 | | | |
| 4937 | fn transCreateNodeContinue(c: *Context) !*ast.Node { | | |
| 4938 | const ltoken = try appendToken(c, .Keyword_continue, "continue"); | | |
| 4939 | const node = try ast.Node.ControlFlowExpression.create(c.arena, .{ | | |
| 4940 | .ltoken = ltoken, | | |
| 4941 | .tag = .Continue, | | |
| 4942 | }, .{}); | | |
| 4943 | _ = try appendToken(c, .Semicolon, ";"); | | |
| 4944 | return &node.base; | | |
| 4945 | } | | |
| 4946 | | | |
| 4947 | fn transCreateNodeSwitchCase(c: *Context, lhs: *ast.Node) !*ast.Node.SwitchCase { | | |
| 4948 | const arrow_tok = try appendToken(c, .EqualAngleBracketRight, "=>"); | | |
| 4949 | | | |
| 4950 | const node = try ast.Node.SwitchCase.alloc(c.arena, 1); | | |
| 4951 | node.* = .{ | | |
| 4952 | .items_len = 1, | | |
| 4953 | .arrow_token = arrow_tok, | | |
| 4954 | .payload = null, | | |
| 4955 | .expr = undefined, | | |
| 4956 | }; | | |
| 4957 | node.items()[0] = lhs; | | |
| 4958 | return node; | | |
| 4959 | } | | |
| 4960 | | | |
| 4961 | fn transCreateNodeSwitchElse(c: *Context) !*ast.Node { | | |
| 4962 | const node = try c.arena.create(ast.Node.SwitchElse); | | |
| 4963 | node.* = .{ | | |
| 4964 | .token = try appendToken(c, .Keyword_else, "else"), | | |
| 4965 | }; | | |
| 4966 | return &node.base; | | |
| 4967 | } | 3640 | } |
| 4968 | | 3641 | |
| 4969 | fn transCreateNodeShiftOp( | 3642 | fn transCreateNodeShiftOp( |
| 4970 | rp: RestorePoint, | 3643 | c: *Context, |
| 4971 | scope: *Scope, | 3644 | scope: *Scope, |
| 4972 | stmt: *const clang.BinaryOperator, | 3645 | stmt: *const clang.BinaryOperator, |
| 4973 | op: ast.Node.Tag, | 3646 | op: Tag, |
| 4974 | op_tok_id: std.zig.Token.Id, | 3647 | used: ResultUsed, |
| 4975 | bytes: []const u8, | 3648 | ) !Node { |
| 4976 | ) !*ast.Node { | 3649 | std.debug.assert(op == .shl or op == .shr); |
| 4977 | std.debug.assert(op == .BitShiftLeft or op == .BitShiftRight); | | |
| 4978 | | 3650 | |
| 4979 | const lhs_expr = stmt.getLHS(); | 3651 | const lhs_expr = stmt.getLHS(); |
| 4980 | const rhs_expr = stmt.getRHS(); | 3652 | const rhs_expr = stmt.getRHS(); |
| 4981 | const rhs_location = rhs_expr.getBeginLoc(); | 3653 | const rhs_location = rhs_expr.getBeginLoc(); |
| 4982 | // lhs >> @as(u5, rh) | 3654 | // lhs >> @as(u5, rh) |
| 4983 | | 3655 | |
| 4984 | const lhs = try transExpr(rp, scope, lhs_expr, .used, .l_value); | 3656 | const lhs = try transExpr(c, scope, lhs_expr, .used); |
| 4985 | const op_token = try appendToken(rp.c, op_tok_id, bytes); | | |
| 4986 | | | |
| 4987 | const cast_node = try rp.c.createBuiltinCall("@intCast", 2); | | |
| 4988 | const rhs_type = try qualTypeToLog2IntRef(rp, stmt.getType(), rhs_location); | | |
| 4989 | cast_node.params()[0] = rhs_type; | | |
| 4990 | _ = try appendToken(rp.c, .Comma, ","); | | |
| 4991 | const rhs = try transExprCoercing(rp, scope, rhs_expr, .used, .r_value); | | |
| 4992 | cast_node.params()[1] = rhs; | | |
| 4993 | cast_node.rparen_token = try appendToken(rp.c, .RParen, ")"); | | |
| 4994 | | | |
| 4995 | const node = try rp.c.arena.create(ast.Node.SimpleInfixOp); | | |
| 4996 | node.* = .{ | | |
| 4997 | .base = .{ .tag = op }, | | |
| 4998 | .op_token = op_token, | | |
| 4999 | .lhs = lhs, | | |
| 5000 | .rhs = &cast_node.base, | | |
| 5001 | }; | | |
| 5002 | | | |
| 5003 | return &node.base; | | |
| 5004 | } | | |
| 5005 | | | |
| 5006 | fn transCreateNodePtrDeref(c: *Context, lhs: *ast.Node) !*ast.Node { | | |
| 5007 | const node = try c.arena.create(ast.Node.SimpleSuffixOp); | | |
| 5008 | node.* = .{ | | |
| 5009 | .base = .{ .tag = .Deref }, | | |
| 5010 | .lhs = lhs, | | |
| 5011 | .rtoken = try appendToken(c, .PeriodAsterisk, ".*"), | | |
| 5012 | }; | | |
| 5013 | return &node.base; | | |
| 5014 | } | | |
| 5015 | | | |
| 5016 | fn transCreateNodeArrayAccess(c: *Context, lhs: *ast.Node) !*ast.Node.ArrayAccess { | | |
| 5017 | _ = try appendToken(c, .LBrace, "["); | | |
| 5018 | const node = try c.arena.create(ast.Node.ArrayAccess); | | |
| 5019 | node.* = .{ | | |
| 5020 | .lhs = lhs, | | |
| 5021 | .index_expr = undefined, | | |
| 5022 | .rtoken = undefined, | | |
| 5023 | }; | | |
| 5024 | return node; | | |
| 5025 | } | | |
| 5026 | | | |
| 5027 | const RestorePoint = struct { | | |
| 5028 | c: *Context, | | |
| 5029 | token_index: ast.TokenIndex, | | |
| 5030 | src_buf_index: usize, | | |
| 5031 | | 3657 | |
| 5032 | fn activate(self: RestorePoint) void { | 3658 | const rhs_type = try qualTypeToLog2IntRef(c, scope, stmt.getType(), rhs_location); |
| 5033 | self.c.token_ids.shrinkAndFree(self.c.gpa, self.token_index); | 3659 | const rhs = try transExprCoercing(c, scope, rhs_expr, .used); |
| 5034 | self.c.token_locs.shrinkAndFree(self.c.gpa, self.token_index); | 3660 | const rhs_casted = try Tag.int_cast.create(c.arena, .{ .lhs = rhs_type, .rhs = rhs }); |
| 5035 | self.c.source_buffer.shrinkAndFree(self.src_buf_index); | | |
| 5036 | } | | |
| 5037 | }; | | |
| 5038 | | 3661 | |
| 5039 | fn makeRestorePoint(c: *Context) RestorePoint { | 3662 | return transCreateNodeInfixOp(c, scope, op, lhs, rhs_casted, used); |
| 5040 | return RestorePoint{ | | |
| 5041 | .c = c, | | |
| 5042 | .token_index = c.token_ids.items.len, | | |
| 5043 | .src_buf_index = c.source_buffer.items.len, | | |
| 5044 | }; | | |
| 5045 | } | 3663 | } |
| 5046 | | 3664 | |
| 5047 | fn transType(rp: RestorePoint, ty: *const clang.Type, source_loc: clang.SourceLocation) TypeError!*ast.Node { | 3665 | fn transType(c: *Context, scope: *Scope, ty: *const clang.Type, source_loc: clang.SourceLocation) TypeError!Node { |
| 5048 | switch (ty.getTypeClass()) { | 3666 | switch (ty.getTypeClass()) { |
| 5049 | .Builtin => { | 3667 | .Builtin => { |
| 5050 | const builtin_ty = @ptrCast(*const clang.BuiltinType, ty); | 3668 | const builtin_ty = @ptrCast(*const clang.BuiltinType, ty); |
| 5051 | return transCreateNodeIdentifier(rp.c, switch (builtin_ty.getKind()) { | 3669 | return Tag.type.create(c.arena, switch (builtin_ty.getKind()) { |
| 5052 | .Void => "c_void", | 3670 | .Void => "c_void", |
| 5053 | .Bool => "bool", | 3671 | .Bool => "bool", |
| 5054 | .Char_U, .UChar, .Char_S, .Char8 => "u8", | 3672 | .Char_U, .UChar, .Char_S, .Char8 => "u8", |
| ... | @@ -5068,112 +3686,100 @@ fn transType(rp: RestorePoint, ty: *const clang.Type, source_loc: clang.SourceLo | ... | @@ -5068,112 +3686,100 @@ fn transType(rp: RestorePoint, ty: *const clang.Type, source_loc: clang.SourceLo |
| 5068 | .Float128 => "f128", | 3686 | .Float128 => "f128", |
| 5069 | .Float16 => "f16", | 3687 | .Float16 => "f16", |
| 5070 | .LongDouble => "c_longdouble", | 3688 | .LongDouble => "c_longdouble", |
| 5071 | else => return revertAndWarn(rp, error.UnsupportedType, source_loc, "unsupported builtin type", .{}), | 3689 | else => return fail(c, error.UnsupportedType, source_loc, "unsupported builtin type", .{}), |
| 5072 | }); | 3690 | }); |
| 5073 | }, | 3691 | }, |
| 5074 | .FunctionProto => { | 3692 | .FunctionProto => { |
| 5075 | const fn_proto_ty = @ptrCast(*const clang.FunctionProtoType, ty); | 3693 | const fn_proto_ty = @ptrCast(*const clang.FunctionProtoType, ty); |
| 5076 | const fn_proto = try transFnProto(rp, null, fn_proto_ty, source_loc, null, false); | 3694 | const fn_proto = try transFnProto(c, null, fn_proto_ty, source_loc, null, false); |
| 5077 | return &fn_proto.base; | 3695 | return Node.initPayload(&fn_proto.base); |
| 5078 | }, | 3696 | }, |
| 5079 | .FunctionNoProto => { | 3697 | .FunctionNoProto => { |
| 5080 | const fn_no_proto_ty = @ptrCast(*const clang.FunctionType, ty); | 3698 | const fn_no_proto_ty = @ptrCast(*const clang.FunctionType, ty); |
| 5081 | const fn_proto = try transFnNoProto(rp, fn_no_proto_ty, source_loc, null, false); | 3699 | const fn_proto = try transFnNoProto(c, fn_no_proto_ty, source_loc, null, false); |
| 5082 | return &fn_proto.base; | 3700 | return Node.initPayload(&fn_proto.base); |
| 5083 | }, | 3701 | }, |
| 5084 | .Paren => { | 3702 | .Paren => { |
| 5085 | const paren_ty = @ptrCast(*const clang.ParenType, ty); | 3703 | const paren_ty = @ptrCast(*const clang.ParenType, ty); |
| 5086 | return transQualType(rp, paren_ty.getInnerType(), source_loc); | 3704 | return transQualType(c, scope, paren_ty.getInnerType(), source_loc); |
| 5087 | }, | 3705 | }, |
| 5088 | .Pointer => { | 3706 | .Pointer => { |
| 5089 | const child_qt = ty.getPointeeType(); | 3707 | const child_qt = ty.getPointeeType(); |
| 5090 | if (qualTypeChildIsFnProto(child_qt)) { | 3708 | if (qualTypeChildIsFnProto(child_qt)) { |
| 5091 | const optional_node = try transCreateNodeSimplePrefixOp(rp.c, .OptionalType, .QuestionMark, "?"); | 3709 | return Tag.optional_type.create(c.arena, try transQualType(c, scope, child_qt, source_loc)); |
| 5092 | optional_node.rhs = try transQualType(rp, child_qt, source_loc); | | |
| 5093 | return &optional_node.base; | | |
| 5094 | } | 3710 | } |
| 5095 | if (typeIsOpaque(rp.c, child_qt.getTypePtr(), source_loc) or qualTypeWasDemotedToOpaque(rp.c, child_qt)) { | 3711 | const is_const = child_qt.isConstQualified(); |
| 5096 | const optional_node = try transCreateNodeSimplePrefixOp(rp.c, .OptionalType, .QuestionMark, "?"); | 3712 | const is_volatile = child_qt.isVolatileQualified(); |
| 5097 | const pointer_node = try transCreateNodePtrType( | 3713 | const elem_type = try transQualType(c, scope, child_qt, source_loc); |
| 5098 | rp.c, | 3714 | if (typeIsOpaque(c, child_qt.getTypePtr(), source_loc) or qualTypeWasDemotedToOpaque(c, child_qt)) { |
| 5099 | child_qt.isConstQualified(), | 3715 | const ptr = try Tag.single_pointer.create(c.arena, .{ .is_const = is_const, .is_volatile = is_volatile, .elem_type = elem_type }); |
| 5100 | child_qt.isVolatileQualified(), | 3716 | return Tag.optional_type.create(c.arena, ptr); |
| 5101 | .Asterisk, | | |
| 5102 | ); | | |
| 5103 | optional_node.rhs = &pointer_node.base; | | |
| 5104 | pointer_node.rhs = try transQualType(rp, child_qt, source_loc); | | |
| 5105 | return &optional_node.base; | | |
| 5106 | } | 3717 | } |
| 5107 | const pointer_node = try transCreateNodePtrType( | 3718 | |
| 5108 | rp.c, | 3719 | return Tag.c_pointer.create(c.arena, .{ .is_const = is_const, .is_volatile = is_volatile, .elem_type = elem_type }); |
| 5109 | child_qt.isConstQualified(), | | |
| 5110 | child_qt.isVolatileQualified(), | | |
| 5111 | .Identifier, | | |
| 5112 | ); | | |
| 5113 | pointer_node.rhs = try transQualType(rp, child_qt, source_loc); | | |
| 5114 | return &pointer_node.base; | | |
| 5115 | }, | 3720 | }, |
| 5116 | .ConstantArray => { | 3721 | .ConstantArray => { |
| 5117 | const const_arr_ty = @ptrCast(*const clang.ConstantArrayType, ty); | 3722 | const const_arr_ty = @ptrCast(*const clang.ConstantArrayType, ty); |
| 5118 | | 3723 | |
| 5119 | const size_ap_int = const_arr_ty.getSize(); | 3724 | const size_ap_int = const_arr_ty.getSize(); |
| 5120 | const size = size_ap_int.getLimitedValue(math.maxInt(usize)); | 3725 | const size = size_ap_int.getLimitedValue(math.maxInt(usize)); |
| 5121 | const elem_ty = const_arr_ty.getElementType().getTypePtr(); | 3726 | const elem_type = try transType(c, scope, const_arr_ty.getElementType().getTypePtr(), source_loc); |
| 5122 | return try transCreateNodeArrayType(rp, source_loc, elem_ty, size); | 3727 | |
| | 3728 | return Tag.array_type.create(c.arena, .{ .len = size, .elem_type = elem_type }); |
| 5123 | }, | 3729 | }, |
| 5124 | .IncompleteArray => { | 3730 | .IncompleteArray => { |
| 5125 | const incomplete_array_ty = @ptrCast(*const clang.IncompleteArrayType, ty); | 3731 | const incomplete_array_ty = @ptrCast(*const clang.IncompleteArrayType, ty); |
| 5126 | | 3732 | |
| 5127 | const child_qt = incomplete_array_ty.getElementType(); | 3733 | const child_qt = incomplete_array_ty.getElementType(); |
| 5128 | var node = try transCreateNodePtrType( | 3734 | const is_const = child_qt.isConstQualified(); |
| 5129 | rp.c, | 3735 | const is_volatile = child_qt.isVolatileQualified(); |
| 5130 | child_qt.isConstQualified(), | 3736 | const elem_type = try transQualType(c, scope, child_qt, source_loc); |
| 5131 | child_qt.isVolatileQualified(), | 3737 | |
| 5132 | .Identifier, | 3738 | return Tag.c_pointer.create(c.arena, .{ .is_const = is_const, .is_volatile = is_volatile, .elem_type = elem_type }); |
| 5133 | ); | | |
| 5134 | node.rhs = try transQualType(rp, child_qt, source_loc); | | |
| 5135 | return &node.base; | | |
| 5136 | }, | 3739 | }, |
| 5137 | .Typedef => { | 3740 | .Typedef => { |
| 5138 | const typedef_ty = @ptrCast(*const clang.TypedefType, ty); | 3741 | const typedef_ty = @ptrCast(*const clang.TypedefType, ty); |
| 5139 | | 3742 | |
| 5140 | const typedef_decl = typedef_ty.getDecl(); | 3743 | const typedef_decl = typedef_ty.getDecl(); |
| 5141 | return (try transTypeDef(rp.c, typedef_decl, false)) orelse | 3744 | try transTypeDef(c, scope, typedef_decl); |
| 5142 | revertAndWarn(rp, error.UnsupportedType, source_loc, "unable to translate typedef declaration", .{}); | 3745 | const name = c.decl_table.get(@ptrToInt(typedef_decl.getCanonicalDecl())).?; |
| | 3746 | return Tag.identifier.create(c.arena, name); |
| 5143 | }, | 3747 | }, |
| 5144 | .Record => { | 3748 | .Record => { |
| 5145 | const record_ty = @ptrCast(*const clang.RecordType, ty); | 3749 | const record_ty = @ptrCast(*const clang.RecordType, ty); |
| 5146 | | 3750 | |
| 5147 | const record_decl = record_ty.getDecl(); | 3751 | const record_decl = record_ty.getDecl(); |
| 5148 | return (try transRecordDecl(rp.c, record_decl)) orelse | 3752 | try transRecordDecl(c, scope, record_decl); |
| 5149 | revertAndWarn(rp, error.UnsupportedType, source_loc, "unable to resolve record declaration", .{}); | 3753 | const name = c.decl_table.get(@ptrToInt(record_decl.getCanonicalDecl())).?; |
| | 3754 | return Tag.identifier.create(c.arena, name); |
| 5150 | }, | 3755 | }, |
| 5151 | .Enum => { | 3756 | .Enum => { |
| 5152 | const enum_ty = @ptrCast(*const clang.EnumType, ty); | 3757 | const enum_ty = @ptrCast(*const clang.EnumType, ty); |
| 5153 | | 3758 | |
| 5154 | const enum_decl = enum_ty.getDecl(); | 3759 | const enum_decl = enum_ty.getDecl(); |
| 5155 | return (try transEnumDecl(rp.c, enum_decl)) orelse | 3760 | try transEnumDecl(c, scope, enum_decl); |
| 5156 | revertAndWarn(rp, error.UnsupportedType, source_loc, "unable to translate enum declaration", .{}); | 3761 | const name = c.decl_table.get(@ptrToInt(enum_decl.getCanonicalDecl())).?; |
| | 3762 | return Tag.identifier.create(c.arena, name); |
| 5157 | }, | 3763 | }, |
| 5158 | .Elaborated => { | 3764 | .Elaborated => { |
| 5159 | const elaborated_ty = @ptrCast(*const clang.ElaboratedType, ty); | 3765 | const elaborated_ty = @ptrCast(*const clang.ElaboratedType, ty); |
| 5160 | return transQualType(rp, elaborated_ty.getNamedType(), source_loc); | 3766 | return transQualType(c, scope, elaborated_ty.getNamedType(), source_loc); |
| 5161 | }, | 3767 | }, |
| 5162 | .Decayed => { | 3768 | .Decayed => { |
| 5163 | const decayed_ty = @ptrCast(*const clang.DecayedType, ty); | 3769 | const decayed_ty = @ptrCast(*const clang.DecayedType, ty); |
| 5164 | return transQualType(rp, decayed_ty.getDecayedType(), source_loc); | 3770 | return transQualType(c, scope, decayed_ty.getDecayedType(), source_loc); |
| 5165 | }, | 3771 | }, |
| 5166 | .Attributed => { | 3772 | .Attributed => { |
| 5167 | const attributed_ty = @ptrCast(*const clang.AttributedType, ty); | 3773 | const attributed_ty = @ptrCast(*const clang.AttributedType, ty); |
| 5168 | return transQualType(rp, attributed_ty.getEquivalentType(), source_loc); | 3774 | return transQualType(c, scope, attributed_ty.getEquivalentType(), source_loc); |
| 5169 | }, | 3775 | }, |
| 5170 | .MacroQualified => { | 3776 | .MacroQualified => { |
| 5171 | const macroqualified_ty = @ptrCast(*const clang.MacroQualifiedType, ty); | 3777 | const macroqualified_ty = @ptrCast(*const clang.MacroQualifiedType, ty); |
| 5172 | return transQualType(rp, macroqualified_ty.getModifiedType(), source_loc); | 3778 | return transQualType(c, scope, macroqualified_ty.getModifiedType(), source_loc); |
| 5173 | }, | 3779 | }, |
| 5174 | else => { | 3780 | else => { |
| 5175 | const type_name = rp.c.str(ty.getTypeClassName()); | 3781 | const type_name = c.str(ty.getTypeClassName()); |
| 5176 | return revertAndWarn(rp, error.UnsupportedType, source_loc, "unsupported type: '{s}'", .{type_name}); | 3782 | return fail(c, error.UnsupportedType, source_loc, "unsupported type: '{s}'", .{type_name}); |
| 5177 | }, | 3783 | }, |
| 5178 | } | 3784 | } |
| 5179 | } | 3785 | } |
| ... | @@ -5239,7 +3845,7 @@ const FnDeclContext = struct { | ... | @@ -5239,7 +3845,7 @@ const FnDeclContext = struct { |
| 5239 | }; | 3845 | }; |
| 5240 | | 3846 | |
| 5241 | fn transCC( | 3847 | fn transCC( |
| 5242 | rp: RestorePoint, | 3848 | c: *Context, |
| 5243 | fn_ty: *const clang.FunctionType, | 3849 | fn_ty: *const clang.FunctionType, |
| 5244 | source_loc: clang.SourceLocation, | 3850 | source_loc: clang.SourceLocation, |
| 5245 | ) !CallingConvention { | 3851 | ) !CallingConvention { |
| ... | @@ -5252,8 +3858,8 @@ fn transCC( | ... | @@ -5252,8 +3858,8 @@ fn transCC( |
| 5252 | .X86ThisCall => return CallingConvention.Thiscall, | 3858 | .X86ThisCall => return CallingConvention.Thiscall, |
| 5253 | .AAPCS => return CallingConvention.AAPCS, | 3859 | .AAPCS => return CallingConvention.AAPCS, |
| 5254 | .AAPCS_VFP => return CallingConvention.AAPCSVFP, | 3860 | .AAPCS_VFP => return CallingConvention.AAPCSVFP, |
| 5255 | else => return revertAndWarn( | 3861 | else => return fail( |
| 5256 | rp, | 3862 | c, |
| 5257 | error.UnsupportedType, | 3863 | error.UnsupportedType, |
| 5258 | source_loc, | 3864 | source_loc, |
| 5259 | "unsupported calling convention: {s}", | 3865 | "unsupported calling convention: {s}", |
| ... | @@ -5263,33 +3869,33 @@ fn transCC( | ... | @@ -5263,33 +3869,33 @@ fn transCC( |
| 5263 | } | 3869 | } |
| 5264 | | 3870 | |
| 5265 | fn transFnProto( | 3871 | fn transFnProto( |
| 5266 | rp: RestorePoint, | 3872 | c: *Context, |
| 5267 | fn_decl: ?*const clang.FunctionDecl, | 3873 | fn_decl: ?*const clang.FunctionDecl, |
| 5268 | fn_proto_ty: *const clang.FunctionProtoType, | 3874 | fn_proto_ty: *const clang.FunctionProtoType, |
| 5269 | source_loc: clang.SourceLocation, | 3875 | source_loc: clang.SourceLocation, |
| 5270 | fn_decl_context: ?FnDeclContext, | 3876 | fn_decl_context: ?FnDeclContext, |
| 5271 | is_pub: bool, | 3877 | is_pub: bool, |
| 5272 | ) !*ast.Node.FnProto { | 3878 | ) !*ast.Payload.Func { |
| 5273 | const fn_ty = @ptrCast(*const clang.FunctionType, fn_proto_ty); | 3879 | const fn_ty = @ptrCast(*const clang.FunctionType, fn_proto_ty); |
| 5274 | const cc = try transCC(rp, fn_ty, source_loc); | 3880 | const cc = try transCC(c, fn_ty, source_loc); |
| 5275 | const is_var_args = fn_proto_ty.isVariadic(); | 3881 | const is_var_args = fn_proto_ty.isVariadic(); |
| 5276 | return finishTransFnProto(rp, fn_decl, fn_proto_ty, fn_ty, source_loc, fn_decl_context, is_var_args, cc, is_pub); | 3882 | return finishTransFnProto(c, fn_decl, fn_proto_ty, fn_ty, source_loc, fn_decl_context, is_var_args, cc, is_pub); |
| 5277 | } | 3883 | } |
| 5278 | | 3884 | |
| 5279 | fn transFnNoProto( | 3885 | fn transFnNoProto( |
| 5280 | rp: RestorePoint, | 3886 | c: *Context, |
| 5281 | fn_ty: *const clang.FunctionType, | 3887 | fn_ty: *const clang.FunctionType, |
| 5282 | source_loc: clang.SourceLocation, | 3888 | source_loc: clang.SourceLocation, |
| 5283 | fn_decl_context: ?FnDeclContext, | 3889 | fn_decl_context: ?FnDeclContext, |
| 5284 | is_pub: bool, | 3890 | is_pub: bool, |
| 5285 | ) !*ast.Node.FnProto { | 3891 | ) !*ast.Payload.Func { |
| 5286 | const cc = try transCC(rp, fn_ty, source_loc); | 3892 | const cc = try transCC(c, fn_ty, source_loc); |
| 5287 | const is_var_args = if (fn_decl_context) |ctx| (!ctx.is_export and ctx.storage_class != .Static) else true; | 3893 | const is_var_args = if (fn_decl_context) |ctx| (!ctx.is_export and ctx.storage_class != .Static) else true; |
| 5288 | return finishTransFnProto(rp, null, null, fn_ty, source_loc, fn_decl_context, is_var_args, cc, is_pub); | 3894 | return finishTransFnProto(c, null, null, fn_ty, source_loc, fn_decl_context, is_var_args, cc, is_pub); |
| 5289 | } | 3895 | } |
| 5290 | | 3896 | |
| 5291 | fn finishTransFnProto( | 3897 | fn finishTransFnProto( |
| 5292 | rp: RestorePoint, | 3898 | c: *Context, |
| 5293 | fn_decl: ?*const clang.FunctionDecl, | 3899 | fn_decl: ?*const clang.FunctionDecl, |
| 5294 | fn_proto_ty: ?*const clang.FunctionProtoType, | 3900 | fn_proto_ty: ?*const clang.FunctionProtoType, |
| 5295 | fn_ty: *const clang.FunctionType, | 3901 | fn_ty: *const clang.FunctionType, |
| ... | @@ -5298,128 +3904,78 @@ fn finishTransFnProto( | ... | @@ -5298,128 +3904,78 @@ fn finishTransFnProto( |
| 5298 | is_var_args: bool, | 3904 | is_var_args: bool, |
| 5299 | cc: CallingConvention, | 3905 | cc: CallingConvention, |
| 5300 | is_pub: bool, | 3906 | is_pub: bool, |
| 5301 | ) !*ast.Node.FnProto { | 3907 | ) !*ast.Payload.Func { |
| 5302 | const is_export = if (fn_decl_context) |ctx| ctx.is_export else false; | 3908 | const is_export = if (fn_decl_context) |ctx| ctx.is_export else false; |
| 5303 | const is_extern = if (fn_decl_context) |ctx| !ctx.has_body else false; | 3909 | const is_extern = if (fn_decl_context) |ctx| !ctx.has_body else false; |
| | 3910 | const scope = &c.global_scope.base; |
| 5304 | | 3911 | |
| 5305 | // TODO check for always_inline attribute | 3912 | // TODO check for always_inline attribute |
| 5306 | // TODO check for align attribute | 3913 | // TODO check for align attribute |
| 5307 | | 3914 | |
| 5308 | // pub extern fn name(...) T | 3915 | var fn_params = std.ArrayList(ast.Payload.Param).init(c.gpa); |
| 5309 | const pub_tok = if (is_pub) try appendToken(rp.c, .Keyword_pub, "pub") else null; | | |
| 5310 | const extern_export_inline_tok = if (is_export) | | |
| 5311 | try appendToken(rp.c, .Keyword_export, "export") | | |
| 5312 | else if (is_extern) | | |
| 5313 | try appendToken(rp.c, .Keyword_extern, "extern") | | |
| 5314 | else | | |
| 5315 | null; | | |
| 5316 | const fn_tok = try appendToken(rp.c, .Keyword_fn, "fn"); | | |
| 5317 | const name_tok = if (fn_decl_context) |ctx| try appendIdentifier(rp.c, ctx.fn_name) else null; | | |
| 5318 | const lparen_tok = try appendToken(rp.c, .LParen, "("); | | |
| 5319 | | | |
| 5320 | var fn_params = std.ArrayList(ast.Node.FnProto.ParamDecl).init(rp.c.gpa); | | |
| 5321 | defer fn_params.deinit(); | 3916 | defer fn_params.deinit(); |
| 5322 | const param_count: usize = if (fn_proto_ty != null) fn_proto_ty.?.getNumParams() else 0; | 3917 | const param_count: usize = if (fn_proto_ty != null) fn_proto_ty.?.getNumParams() else 0; |
| 5323 | try fn_params.ensureCapacity(param_count + 1); // +1 for possible var args node | 3918 | try fn_params.ensureCapacity(param_count); |
| 5324 | | 3919 | |
| 5325 | var i: usize = 0; | 3920 | var i: usize = 0; |
| 5326 | while (i < param_count) : (i += 1) { | 3921 | while (i < param_count) : (i += 1) { |
| 5327 | const param_qt = fn_proto_ty.?.getParamType(@intCast(c_uint, i)); | 3922 | const param_qt = fn_proto_ty.?.getParamType(@intCast(c_uint, i)); |
| | 3923 | const is_noalias = param_qt.isRestrictQualified(); |
| 5328 | | 3924 | |
| 5329 | const noalias_tok = if (param_qt.isRestrictQualified()) try appendToken(rp.c, .Keyword_noalias, "noalias") else null; | 3925 | const param_name: ?[]const u8 = |
| 5330 | | 3926 | if (fn_decl) |decl| |
| 5331 | const param_name_tok: ?ast.TokenIndex = blk: { | 3927 | blk: { |
| 5332 | if (fn_decl) |decl| { | 3928 | const param = decl.getParamDecl(@intCast(c_uint, i)); |
| 5333 | const param = decl.getParamDecl(@intCast(c_uint, i)); | 3929 | const param_name: []const u8 = try c.str(@ptrCast(*const clang.NamedDecl, param).getName_bytes_begin()); |
| 5334 | const param_name: []const u8 = try rp.c.str(@ptrCast(*const clang.NamedDecl, param).getName_bytes_begin()); | 3930 | if (param_name.len < 1) |
| 5335 | if (param_name.len < 1) | 3931 | break :blk null; |
| 5336 | break :blk null; | | |
| 5337 | | | |
| 5338 | const result = try appendIdentifier(rp.c, param_name); | | |
| 5339 | _ = try appendToken(rp.c, .Colon, ":"); | | |
| 5340 | break :blk result; | | |
| 5341 | } | | |
| 5342 | break :blk null; | | |
| 5343 | }; | | |
| 5344 | | 3932 | |
| 5345 | const type_node = try transQualType(rp, param_qt, source_loc); | 3933 | break :blk param_name; |
| | 3934 | } else null; |
| | 3935 | const type_node = try transQualType(c, scope, param_qt, source_loc); |
| 5346 | | 3936 | |
| 5347 | fn_params.addOneAssumeCapacity().* = .{ | 3937 | fn_params.addOneAssumeCapacity().* = .{ |
| 5348 | .doc_comments = null, | 3938 | .is_noalias = is_noalias, |
| 5349 | .comptime_token = null, | 3939 | .name = param_name, |
| 5350 | .noalias_token = noalias_tok, | 3940 | .type = type_node, |
| 5351 | .name_token = param_name_tok, | | |
| 5352 | .param_type = .{ .type_expr = type_node }, | | |
| 5353 | }; | 3941 | }; |
| 5354 | | | |
| 5355 | if (i + 1 < param_count) { | | |
| 5356 | _ = try appendToken(rp.c, .Comma, ","); | | |
| 5357 | } | | |
| 5358 | } | 3942 | } |
| 5359 | | 3943 | |
| 5360 | const var_args_token: ?ast.TokenIndex = if (is_var_args) blk: { | 3944 | const linksection_string = blk: { |
| 5361 | if (param_count > 0) { | | |
| 5362 | _ = try appendToken(rp.c, .Comma, ","); | | |
| 5363 | } | | |
| 5364 | break :blk try appendToken(rp.c, .Ellipsis3, "..."); | | |
| 5365 | } else null; | | |
| 5366 | | | |
| 5367 | const rparen_tok = try appendToken(rp.c, .RParen, ")"); | | |
| 5368 | | | |
| 5369 | const linksection_expr = blk: { | | |
| 5370 | if (fn_decl) |decl| { | 3945 | if (fn_decl) |decl| { |
| 5371 | var str_len: usize = undefined; | 3946 | var str_len: usize = undefined; |
| 5372 | if (decl.getSectionAttribute(&str_len)) |str_ptr| { | 3947 | if (decl.getSectionAttribute(&str_len)) |str_ptr| { |
| 5373 | _ = try appendToken(rp.c, .Keyword_linksection, "linksection"); | 3948 | break :blk str_ptr[0..str_len]; |
| 5374 | _ = try appendToken(rp.c, .LParen, "("); | | |
| 5375 | const expr = try transCreateNodeStringLiteral( | | |
| 5376 | rp.c, | | |
| 5377 | try std.fmt.allocPrint(rp.c.arena, "\"{s}\"", .{str_ptr[0..str_len]}), | | |
| 5378 | ); | | |
| 5379 | _ = try appendToken(rp.c, .RParen, ")"); | | |
| 5380 | | | |
| 5381 | break :blk expr; | | |
| 5382 | } | 3949 | } |
| 5383 | } | 3950 | } |
| 5384 | break :blk null; | 3951 | break :blk null; |
| 5385 | }; | 3952 | }; |
| 5386 | | 3953 | |
| 5387 | const align_expr = blk: { | 3954 | const alignment = blk: { |
| 5388 | if (fn_decl) |decl| { | 3955 | if (fn_decl) |decl| { |
| 5389 | const alignment = decl.getAlignedAttribute(rp.c.clang_context); | 3956 | const alignment = decl.getAlignedAttribute(c.clang_context); |
| 5390 | if (alignment != 0) { | 3957 | if (alignment != 0) { |
| 5391 | _ = try appendToken(rp.c, .Keyword_align, "align"); | | |
| 5392 | _ = try appendToken(rp.c, .LParen, "("); | | |
| 5393 | // Clang reports the alignment in bits | 3958 | // Clang reports the alignment in bits |
| 5394 | const expr = try transCreateNodeInt(rp.c, alignment / 8); | 3959 | break :blk alignment / 8; |
| 5395 | _ = try appendToken(rp.c, .RParen, ")"); | | |
| 5396 | | | |
| 5397 | break :blk expr; | | |
| 5398 | } | 3960 | } |
| 5399 | } | 3961 | } |
| 5400 | break :blk null; | 3962 | break :blk null; |
| 5401 | }; | 3963 | }; |
| 5402 | | 3964 | |
| 5403 | const callconv_expr = if ((is_export or is_extern) and cc == .C) null else blk: { | 3965 | const explicit_callconv = if ((is_export or is_extern) and cc == .C) null else cc; |
| 5404 | _ = try appendToken(rp.c, .Keyword_callconv, "callconv"); | | |
| 5405 | _ = try appendToken(rp.c, .LParen, "("); | | |
| 5406 | const expr = try transCreateNodeEnumLiteral(rp.c, @tagName(cc)); | | |
| 5407 | _ = try appendToken(rp.c, .RParen, ")"); | | |
| 5408 | break :blk expr; | | |
| 5409 | }; | | |
| 5410 | | 3966 | |
| 5411 | const return_type_node = blk: { | 3967 | const return_type_node = blk: { |
| 5412 | if (fn_ty.getNoReturnAttr()) { | 3968 | if (fn_ty.getNoReturnAttr()) { |
| 5413 | break :blk try transCreateNodeIdentifier(rp.c, "noreturn"); | 3969 | break :blk Tag.noreturn_type.init(); |
| 5414 | } else { | 3970 | } else { |
| 5415 | const return_qt = fn_ty.getReturnType(); | 3971 | const return_qt = fn_ty.getReturnType(); |
| 5416 | if (isCVoid(return_qt)) { | 3972 | if (isCVoid(return_qt)) { |
| 5417 | // convert primitive c_void to actual void (only for return type) | 3973 | // convert primitive c_void to actual void (only for return type) |
| 5418 | break :blk try transCreateNodeIdentifier(rp.c, "void"); | 3974 | break :blk Tag.void_type.init(); |
| 5419 | } else { | 3975 | } else { |
| 5420 | break :blk transQualType(rp, return_qt, source_loc) catch |err| switch (err) { | 3976 | break :blk transQualType(c, scope, return_qt, source_loc) catch |err| switch (err) { |
| 5421 | error.UnsupportedType => { | 3977 | error.UnsupportedType => { |
| 5422 | try emitWarning(rp.c, source_loc, "unsupported function proto return type", .{}); | 3978 | try warn(c, scope, source_loc, "unsupported function proto return type", .{}); |
| 5423 | return err; | 3979 | return err; |
| 5424 | }, | 3980 | }, |
| 5425 | error.OutOfMemory => |e| return e, | 3981 | error.OutOfMemory => |e| return e, |
| ... | @@ -5427,116 +3983,57 @@ fn finishTransFnProto( | ... | @@ -5427,116 +3983,57 @@ fn finishTransFnProto( |
| 5427 | } | 3983 | } |
| 5428 | } | 3984 | } |
| 5429 | }; | 3985 | }; |
| | 3986 | const name: ?[]const u8 = if (fn_decl_context) |ctx| ctx.fn_name else null; |
| | 3987 | const payload = try c.arena.create(ast.Payload.Func); |
| | 3988 | payload.* = .{ |
| | 3989 | .base = .{ .tag = .func }, |
| | 3990 | .data = .{ |
| | 3991 | .is_pub = is_pub, |
| | 3992 | .is_extern = is_extern, |
| | 3993 | .is_export = is_export, |
| | 3994 | .is_var_args = is_var_args, |
| | 3995 | .name = name, |
| | 3996 | .linksection_string = linksection_string, |
| | 3997 | .explicit_callconv = explicit_callconv, |
| | 3998 | .params = try c.arena.dupe(ast.Payload.Param, fn_params.items), |
| | 3999 | .return_type = return_type_node, |
| | 4000 | .body = null, |
| | 4001 | .alignment = alignment, |
| | 4002 | }, |
| | 4003 | }; |
| | 4004 | return payload; |
| | 4005 | } |
| 5430 | | 4006 | |
| 5431 | // We need to reserve an undefined (but non-null) body node to set later. | 4007 | fn warn(c: *Context, scope: *Scope, loc: clang.SourceLocation, comptime format: []const u8, args: anytype) !void { |
| 5432 | var body_node: ?*ast.Node = null; | 4008 | const args_prefix = .{c.locStr(loc)}; |
| 5433 | if (fn_decl_context) |ctx| { | 4009 | const value = try std.fmt.allocPrint(c.arena, "// {s}: warning: " ++ format, args_prefix ++ args); |
| 5434 | if (ctx.has_body) { | 4010 | try scope.appendNode(try Tag.warning.create(c.arena, value)); |
| 5435 | // TODO: we should be able to use undefined here but | | |
| 5436 | // it causes a bug. This is undefined without zig language | | |
| 5437 | // being aware of it. | | |
| 5438 | body_node = @intToPtr(*ast.Node, 0x08); | | |
| 5439 | } | | |
| 5440 | } | | |
| 5441 | | | |
| 5442 | const fn_proto = try ast.Node.FnProto.create(rp.c.arena, .{ | | |
| 5443 | .params_len = fn_params.items.len, | | |
| 5444 | .return_type = .{ .Explicit = return_type_node }, | | |
| 5445 | .fn_token = fn_tok, | | |
| 5446 | }, .{ | | |
| 5447 | .visib_token = pub_tok, | | |
| 5448 | .name_token = name_tok, | | |
| 5449 | .extern_export_inline_token = extern_export_inline_tok, | | |
| 5450 | .align_expr = align_expr, | | |
| 5451 | .section_expr = linksection_expr, | | |
| 5452 | .callconv_expr = callconv_expr, | | |
| 5453 | .body_node = body_node, | | |
| 5454 | .var_args_token = var_args_token, | | |
| 5455 | }); | | |
| 5456 | mem.copy(ast.Node.FnProto.ParamDecl, fn_proto.params(), fn_params.items); | | |
| 5457 | return fn_proto; | | |
| 5458 | } | 4011 | } |
| 5459 | | 4012 | |
| 5460 | fn revertAndWarn( | 4013 | fn fail( |
| 5461 | rp: RestorePoint, | 4014 | c: *Context, |
| 5462 | err: anytype, | 4015 | err: anytype, |
| 5463 | source_loc: clang.SourceLocation, | 4016 | source_loc: clang.SourceLocation, |
| 5464 | comptime format: []const u8, | 4017 | comptime format: []const u8, |
| 5465 | args: anytype, | 4018 | args: anytype, |
| 5466 | ) (@TypeOf(err) || error{OutOfMemory}) { | 4019 | ) (@TypeOf(err) || error{OutOfMemory}) { |
| 5467 | rp.activate(); | 4020 | try warn(c, &c.global_scope.base, source_loc, format, args); |
| 5468 | try emitWarning(rp.c, source_loc, format, args); | | |
| 5469 | return err; | 4021 | return err; |
| 5470 | } | 4022 | } |
| 5471 | | 4023 | |
| 5472 | fn emitWarning(c: *Context, loc: clang.SourceLocation, comptime format: []const u8, args: anytype) !void { | 4024 | pub fn failDecl(c: *Context, loc: clang.SourceLocation, name: []const u8, comptime format: []const u8, args: anytype) Error!void { |
| 5473 | const args_prefix = .{c.locStr(loc)}; | 4025 | // location |
| 5474 | _ = try appendTokenFmt(c, .LineComment, "// {s}: warning: " ++ format, args_prefix ++ args); | | |
| 5475 | } | | |
| 5476 | | | |
| 5477 | pub fn failDecl(c: *Context, loc: clang.SourceLocation, name: []const u8, comptime format: []const u8, args: anytype) !void { | | |
| 5478 | // pub const name = @compileError(msg); | 4026 | // pub const name = @compileError(msg); |
| 5479 | const pub_tok = try appendToken(c, .Keyword_pub, "pub"); | 4027 | const fail_msg = try std.fmt.allocPrint(c.arena, format, args); |
| 5480 | const const_tok = try appendToken(c, .Keyword_const, "const"); | 4028 | try addTopLevelDecl(c, name, try Tag.fail_decl.create(c.arena, .{ .actual = name, .mangled = fail_msg })); |
| 5481 | const name_tok = try appendIdentifier(c, name); | 4029 | const location_comment = try std.fmt.allocPrint(c.arena, "// {s}", .{c.locStr(loc)}); |
| 5482 | const eq_tok = try appendToken(c, .Equal, "="); | 4030 | try c.global_scope.nodes.append(try Tag.warning.create(c.arena, location_comment)); |
| 5483 | const builtin_tok = try appendToken(c, .Builtin, "@compileError"); | | |
| 5484 | const lparen_tok = try appendToken(c, .LParen, "("); | | |
| 5485 | const msg_tok = try appendTokenFmt(c, .StringLiteral, "\"" ++ format ++ "\"", args); | | |
| 5486 | const rparen_tok = try appendToken(c, .RParen, ")"); | | |
| 5487 | const semi_tok = try appendToken(c, .Semicolon, ";"); | | |
| 5488 | _ = try appendTokenFmt(c, .LineComment, "// {s}", .{c.locStr(loc)}); | | |
| 5489 | | | |
| 5490 | const msg_node = try c.arena.create(ast.Node.OneToken); | | |
| 5491 | msg_node.* = .{ | | |
| 5492 | .base = .{ .tag = .StringLiteral }, | | |
| 5493 | .token = msg_tok, | | |
| 5494 | }; | | |
| 5495 | | | |
| 5496 | const call_node = try ast.Node.BuiltinCall.alloc(c.arena, 1); | | |
| 5497 | call_node.* = .{ | | |
| 5498 | .builtin_token = builtin_tok, | | |
| 5499 | .params_len = 1, | | |
| 5500 | .rparen_token = rparen_tok, | | |
| 5501 | }; | | |
| 5502 | call_node.params()[0] = &msg_node.base; | | |
| 5503 | | | |
| 5504 | const var_decl_node = try ast.Node.VarDecl.create(c.arena, .{ | | |
| 5505 | .name_token = name_tok, | | |
| 5506 | .mut_token = const_tok, | | |
| 5507 | .semicolon_token = semi_tok, | | |
| 5508 | }, .{ | | |
| 5509 | .visib_token = pub_tok, | | |
| 5510 | .eq_token = eq_tok, | | |
| 5511 | .init_node = &call_node.base, | | |
| 5512 | }); | | |
| 5513 | try addTopLevelDecl(c, name, &var_decl_node.base); | | |
| 5514 | } | | |
| 5515 | | | |
| 5516 | fn appendToken(c: *Context, token_id: Token.Id, bytes: []const u8) !ast.TokenIndex { | | |
| 5517 | std.debug.assert(token_id != .Identifier); // use appendIdentifier | | |
| 5518 | return appendTokenFmt(c, token_id, "{s}", .{bytes}); | | |
| 5519 | } | 4031 | } |
| 5520 | | 4032 | |
| 5521 | fn appendTokenFmt(c: *Context, token_id: Token.Id, comptime format: []const u8, args: anytype) !ast.TokenIndex { | 4033 | pub fn freeErrors(errors: []ClangErrMsg) void { |
| 5522 | assert(token_id != .Invalid); | 4034 | errors.ptr.delete(errors.len); |
| 5523 | | | |
| 5524 | try c.token_ids.ensureCapacity(c.gpa, c.token_ids.items.len + 1); | | |
| 5525 | try c.token_locs.ensureCapacity(c.gpa, c.token_locs.items.len + 1); | | |
| 5526 | | | |
| 5527 | const start_index = c.source_buffer.items.len; | | |
| 5528 | try c.source_buffer.writer().print(format ++ " ", args); | | |
| 5529 | | | |
| 5530 | c.token_ids.appendAssumeCapacity(token_id); | | |
| 5531 | c.token_locs.appendAssumeCapacity(.{ | | |
| 5532 | .start = start_index, | | |
| 5533 | .end = c.source_buffer.items.len - 1, // back up before the space | | |
| 5534 | }); | | |
| 5535 | | | |
| 5536 | return c.token_ids.items.len - 1; | | |
| 5537 | } | 4035 | } |
| 5538 | | 4036 | |
| 5539 | // TODO hook up with codegen | | |
| 5540 | fn isZigPrimitiveType(name: []const u8) bool { | 4037 | fn isZigPrimitiveType(name: []const u8) bool { |
| 5541 | if (name.len > 1 and (name[0] == 'u' or name[0] == 'i')) { | 4038 | if (name.len > 1 and (name[0] == 'u' or name[0] == 'i')) { |
| 5542 | for (name[1..]) |c| { | 4039 | for (name[1..]) |c| { |
| ... | @@ -5547,56 +4044,7 @@ fn isZigPrimitiveType(name: []const u8) bool { | ... | @@ -5547,56 +4044,7 @@ fn isZigPrimitiveType(name: []const u8) bool { |
| 5547 | } | 4044 | } |
| 5548 | return true; | 4045 | return true; |
| 5549 | } | 4046 | } |
| 5550 | // void is invalid in c so it doesn't need to be checked. | 4047 | return @import("astgen.zig").simple_types.has(name); |
| 5551 | return mem.eql(u8, name, "comptime_float") or | | |
| 5552 | mem.eql(u8, name, "comptime_int") or | | |
| 5553 | mem.eql(u8, name, "bool") or | | |
| 5554 | mem.eql(u8, name, "isize") or | | |
| 5555 | mem.eql(u8, name, "usize") or | | |
| 5556 | mem.eql(u8, name, "f16") or | | |
| 5557 | mem.eql(u8, name, "f32") or | | |
| 5558 | mem.eql(u8, name, "f64") or | | |
| 5559 | mem.eql(u8, name, "f128") or | | |
| 5560 | mem.eql(u8, name, "c_longdouble") or | | |
| 5561 | mem.eql(u8, name, "noreturn") or | | |
| 5562 | mem.eql(u8, name, "type") or | | |
| 5563 | mem.eql(u8, name, "anyerror") or | | |
| 5564 | mem.eql(u8, name, "c_short") or | | |
| 5565 | mem.eql(u8, name, "c_ushort") or | | |
| 5566 | mem.eql(u8, name, "c_int") or | | |
| 5567 | mem.eql(u8, name, "c_uint") or | | |
| 5568 | mem.eql(u8, name, "c_long") or | | |
| 5569 | mem.eql(u8, name, "c_ulong") or | | |
| 5570 | mem.eql(u8, name, "c_longlong") or | | |
| 5571 | mem.eql(u8, name, "c_ulonglong"); | | |
| 5572 | } | | |
| 5573 | | | |
| 5574 | fn appendIdentifier(c: *Context, name: []const u8) !ast.TokenIndex { | | |
| 5575 | return appendTokenFmt(c, .Identifier, "{}", .{std.zig.fmtId(name)}); | | |
| 5576 | } | | |
| 5577 | | | |
| 5578 | fn transCreateNodeIdentifier(c: *Context, name: []const u8) !*ast.Node { | | |
| 5579 | const token_index = try appendIdentifier(c, name); | | |
| 5580 | const identifier = try c.arena.create(ast.Node.OneToken); | | |
| 5581 | identifier.* = .{ | | |
| 5582 | .base = .{ .tag = .Identifier }, | | |
| 5583 | .token = token_index, | | |
| 5584 | }; | | |
| 5585 | return &identifier.base; | | |
| 5586 | } | | |
| 5587 | | | |
| 5588 | fn transCreateNodeIdentifierUnchecked(c: *Context, name: []const u8) !*ast.Node { | | |
| 5589 | const token_index = try appendTokenFmt(c, .Identifier, "{s}", .{name}); | | |
| 5590 | const identifier = try c.arena.create(ast.Node.OneToken); | | |
| 5591 | identifier.* = .{ | | |
| 5592 | .base = .{ .tag = .Identifier }, | | |
| 5593 | .token = token_index, | | |
| 5594 | }; | | |
| 5595 | return &identifier.base; | | |
| 5596 | } | | |
| 5597 | | | |
| 5598 | pub fn freeErrors(errors: []ClangErrMsg) void { | | |
| 5599 | errors.ptr.delete(errors.len); | | |
| 5600 | } | 4048 | } |
| 5601 | | 4049 | |
| 5602 | const MacroCtx = struct { | 4050 | const MacroCtx = struct { |
| ... | @@ -5717,27 +4165,13 @@ fn transPreprocessorEntities(c: *Context, unit: *clang.ASTUnit) Error!void { | ... | @@ -5717,27 +4165,13 @@ fn transPreprocessorEntities(c: *Context, unit: *clang.ASTUnit) Error!void { |
| 5717 | fn transMacroDefine(c: *Context, m: *MacroCtx) ParseError!void { | 4165 | fn transMacroDefine(c: *Context, m: *MacroCtx) ParseError!void { |
| 5718 | const scope = &c.global_scope.base; | 4166 | const scope = &c.global_scope.base; |
| 5719 | | 4167 | |
| 5720 | const visib_tok = try appendToken(c, .Keyword_pub, "pub"); | | |
| 5721 | const mut_tok = try appendToken(c, .Keyword_const, "const"); | | |
| 5722 | const name_tok = try appendIdentifier(c, m.name); | | |
| 5723 | const eq_token = try appendToken(c, .Equal, "="); | | |
| 5724 | | | |
| 5725 | const init_node = try parseCExpr(c, m, scope); | 4168 | const init_node = try parseCExpr(c, m, scope); |
| 5726 | const last = m.next().?; | 4169 | const last = m.next().?; |
| 5727 | if (last != .Eof and last != .Nl) | 4170 | if (last != .Eof and last != .Nl) |
| 5728 | return m.fail(c, "unable to translate C expr: unexpected token .{s}", .{@tagName(last)}); | 4171 | return m.fail(c, "unable to translate C expr: unexpected token .{s}", .{@tagName(last)}); |
| 5729 | | 4172 | |
| 5730 | const semicolon_token = try appendToken(c, .Semicolon, ";"); | 4173 | const var_decl = try Tag.pub_var_simple.create(c.arena, .{ .name = m.name, .init = init_node }); |
| 5731 | const node = try ast.Node.VarDecl.create(c.arena, .{ | 4174 | _ = try c.global_scope.macro_table.put(m.name, var_decl); |
| 5732 | .name_token = name_tok, | | |
| 5733 | .mut_token = mut_tok, | | |
| 5734 | .semicolon_token = semicolon_token, | | |
| 5735 | }, .{ | | |
| 5736 | .visib_token = visib_tok, | | |
| 5737 | .eq_token = eq_token, | | |
| 5738 | .init_node = init_node, | | |
| 5739 | }); | | |
| 5740 | _ = try c.global_scope.macro_table.put(m.name, &node.base); | | |
| 5741 | } | 4175 | } |
| 5742 | | 4176 | |
| 5743 | fn transMacroFnDefine(c: *Context, m: *MacroCtx) ParseError!void { | 4177 | fn transMacroFnDefine(c: *Context, m: *MacroCtx) ParseError!void { |
| ... | @@ -5745,16 +4179,11 @@ fn transMacroFnDefine(c: *Context, m: *MacroCtx) ParseError!void { | ... | @@ -5745,16 +4179,11 @@ fn transMacroFnDefine(c: *Context, m: *MacroCtx) ParseError!void { |
| 5745 | defer block_scope.deinit(); | 4179 | defer block_scope.deinit(); |
| 5746 | const scope = &block_scope.base; | 4180 | const scope = &block_scope.base; |
| 5747 | | 4181 | |
| 5748 | const pub_tok = try appendToken(c, .Keyword_pub, "pub"); | | |
| 5749 | const fn_tok = try appendToken(c, .Keyword_fn, "fn"); | | |
| 5750 | const name_tok = try appendIdentifier(c, m.name); | | |
| 5751 | _ = try appendToken(c, .LParen, "("); | | |
| 5752 | | | |
| 5753 | if (m.next().? != .LParen) { | 4182 | if (m.next().? != .LParen) { |
| 5754 | return m.fail(c, "unable to translate C expr: expected '('", .{}); | 4183 | return m.fail(c, "unable to translate C expr: expected '('", .{}); |
| 5755 | } | 4184 | } |
| 5756 | | 4185 | |
| 5757 | var fn_params = std.ArrayList(ast.Node.FnProto.ParamDecl).init(c.gpa); | 4186 | var fn_params = std.ArrayList(ast.Payload.Param).init(c.gpa); |
| 5758 | defer fn_params.deinit(); | 4187 | defer fn_params.deinit(); |
| 5759 | | 4188 | |
| 5760 | while (true) { | 4189 | while (true) { |
| ... | @@ -5762,120 +4191,82 @@ fn transMacroFnDefine(c: *Context, m: *MacroCtx) ParseError!void { | ... | @@ -5762,120 +4191,82 @@ fn transMacroFnDefine(c: *Context, m: *MacroCtx) ParseError!void { |
| 5762 | _ = m.next(); | 4191 | _ = m.next(); |
| 5763 | | 4192 | |
| 5764 | const mangled_name = try block_scope.makeMangledName(c, m.slice()); | 4193 | const mangled_name = try block_scope.makeMangledName(c, m.slice()); |
| 5765 | const param_name_tok = try appendIdentifier(c, mangled_name); | 4194 | try fn_params.append(.{ |
| 5766 | _ = try appendToken(c, .Colon, ":"); | 4195 | .is_noalias = false, |
| 5767 | | 4196 | .name = mangled_name, |
| 5768 | const any_type = try c.arena.create(ast.Node.OneToken); | 4197 | .type = Tag.@"anytype".init(), |
| 5769 | any_type.* = .{ | 4198 | }); |
| 5770 | .base = .{ .tag = .AnyType }, | | |
| 5771 | .token = try appendToken(c, .Keyword_anytype, "anytype"), | | |
| 5772 | }; | | |
| 5773 | | | |
| 5774 | (try fn_params.addOne()).* = .{ | | |
| 5775 | .doc_comments = null, | | |
| 5776 | .comptime_token = null, | | |
| 5777 | .noalias_token = null, | | |
| 5778 | .name_token = param_name_tok, | | |
| 5779 | .param_type = .{ .any_type = &any_type.base }, | | |
| 5780 | }; | | |
| 5781 | | 4199 | |
| 5782 | if (m.peek().? != .Comma) break; | 4200 | if (m.peek().? != .Comma) break; |
| 5783 | _ = m.next(); | 4201 | _ = m.next(); |
| 5784 | _ = try appendToken(c, .Comma, ","); | | |
| 5785 | } | 4202 | } |
| 5786 | | 4203 | |
| 5787 | if (m.next().? != .RParen) { | 4204 | if (m.next().? != .RParen) { |
| 5788 | return m.fail(c, "unable to translate C expr: expected ')'", .{}); | 4205 | return m.fail(c, "unable to translate C expr: expected ')'", .{}); |
| 5789 | } | 4206 | } |
| 5790 | | 4207 | |
| 5791 | _ = try appendToken(c, .RParen, ")"); | | |
| 5792 | | | |
| 5793 | _ = try appendToken(c, .Keyword_callconv, "callconv"); | | |
| 5794 | _ = try appendToken(c, .LParen, "("); | | |
| 5795 | const callconv_expr = try transCreateNodeEnumLiteral(c, "Inline"); | | |
| 5796 | _ = try appendToken(c, .RParen, ")"); | | |
| 5797 | | | |
| 5798 | const type_of = try c.createBuiltinCall("@TypeOf", 1); | | |
| 5799 | | | |
| 5800 | const return_kw = try appendToken(c, .Keyword_return, "return"); | | |
| 5801 | const expr = try parseCExpr(c, m, scope); | 4208 | const expr = try parseCExpr(c, m, scope); |
| 5802 | const last = m.next().?; | 4209 | const last = m.next().?; |
| 5803 | if (last != .Eof and last != .Nl) | 4210 | if (last != .Eof and last != .Nl) |
| 5804 | return m.fail(c, "unable to translate C expr: unexpected token .{s}", .{@tagName(last)}); | 4211 | return m.fail(c, "unable to translate C expr: unexpected token .{s}", .{@tagName(last)}); |
| 5805 | _ = try appendToken(c, .Semicolon, ";"); | 4212 | |
| 5806 | const type_of_arg = if (!expr.tag.isBlock()) expr else blk: { | 4213 | const typeof_arg = if (expr.castTag(.block)) |some| blk: { |
| 5807 | const stmts = expr.blockStatements(); | 4214 | const stmts = some.data.stmts; |
| 5808 | const blk_last = stmts[stmts.len - 1]; | 4215 | const blk_last = stmts[stmts.len - 1]; |
| 5809 | const br = blk_last.cast(ast.Node.ControlFlowExpression).?; | 4216 | const br = blk_last.castTag(.break_val).?; |
| 5810 | break :blk br.getRHS().?; | 4217 | break :blk br.data.val; |
| 5811 | }; | 4218 | } else expr; |
| 5812 | type_of.params()[0] = type_of_arg; | 4219 | const return_type = if (typeof_arg.castTag(.std_meta_cast)) |some| |
| 5813 | type_of.rparen_token = try appendToken(c, .RParen, ")"); | 4220 | some.data.lhs |
| 5814 | const return_expr = try ast.Node.ControlFlowExpression.create(c.arena, .{ | 4221 | else |
| 5815 | .ltoken = return_kw, | 4222 | try Tag.typeof.create(c.arena, typeof_arg); |
| 5816 | .tag = .Return, | | |
| 5817 | }, .{ | | |
| 5818 | .rhs = expr, | | |
| 5819 | }); | | |
| 5820 | | 4223 | |
| 5821 | try block_scope.statements.append(&return_expr.base); | 4224 | const return_expr = try Tag.@"return".create(c.arena, expr); |
| 5822 | const block_node = try block_scope.complete(c); | 4225 | try block_scope.statements.append(return_expr); |
| 5823 | const fn_proto = try ast.Node.FnProto.create(c.arena, .{ | | |
| 5824 | .fn_token = fn_tok, | | |
| 5825 | .params_len = fn_params.items.len, | | |
| 5826 | .return_type = .{ .Explicit = &type_of.base }, | | |
| 5827 | }, .{ | | |
| 5828 | .visib_token = pub_tok, | | |
| 5829 | .name_token = name_tok, | | |
| 5830 | .body_node = block_node, | | |
| 5831 | .callconv_expr = callconv_expr, | | |
| 5832 | }); | | |
| 5833 | mem.copy(ast.Node.FnProto.ParamDecl, fn_proto.params(), fn_params.items); | | |
| 5834 | | 4226 | |
| 5835 | _ = try c.global_scope.macro_table.put(m.name, &fn_proto.base); | 4227 | const fn_decl = try Tag.pub_inline_fn.create(c.arena, .{ |
| | 4228 | .name = m.name, |
| | 4229 | .params = try c.arena.dupe(ast.Payload.Param, fn_params.items), |
| | 4230 | .return_type = return_type, |
| | 4231 | .body = try block_scope.complete(c), |
| | 4232 | }); |
| | 4233 | _ = try c.global_scope.macro_table.put(m.name, fn_decl); |
| 5836 | } | 4234 | } |
| 5837 | | 4235 | |
| 5838 | const ParseError = Error || error{ParseError}; | 4236 | const ParseError = Error || error{ParseError}; |
| 5839 | | 4237 | |
| 5840 | fn parseCExpr(c: *Context, m: *MacroCtx, scope: *Scope) ParseError!*ast.Node { | 4238 | fn parseCExpr(c: *Context, m: *MacroCtx, scope: *Scope) ParseError!Node { |
| 5841 | // TODO parseCAssignExpr here | 4239 | // TODO parseCAssignExpr here |
| 5842 | const node = try parseCCondExpr(c, m, scope); | 4240 | const node = try parseCCondExpr(c, m, scope); |
| 5843 | if (m.next().? != .Comma) { | 4241 | if (m.next().? != .Comma) { |
| 5844 | m.i -= 1; | 4242 | m.i -= 1; |
| 5845 | return node; | 4243 | return node; |
| 5846 | } | 4244 | } |
| 5847 | _ = try appendToken(c, .Semicolon, ";"); | | |
| 5848 | var block_scope = try Scope.Block.init(c, scope, true); | 4245 | var block_scope = try Scope.Block.init(c, scope, true); |
| 5849 | defer block_scope.deinit(); | 4246 | defer block_scope.deinit(); |
| 5850 | | 4247 | |
| 5851 | var last = node; | 4248 | var last = node; |
| 5852 | while (true) { | 4249 | while (true) { |
| 5853 | // suppress result | 4250 | // suppress result |
| 5854 | const lhs = try transCreateNodeIdentifier(c, "_"); | 4251 | const ignore = try Tag.discard.create(c.arena, last); |
| 5855 | const op_token = try appendToken(c, .Equal, "="); | 4252 | try block_scope.statements.append(ignore); |
| 5856 | const op_node = try c.arena.create(ast.Node.SimpleInfixOp); | | |
| 5857 | op_node.* = .{ | | |
| 5858 | .base = .{ .tag = .Assign }, | | |
| 5859 | .op_token = op_token, | | |
| 5860 | .lhs = lhs, | | |
| 5861 | .rhs = last, | | |
| 5862 | }; | | |
| 5863 | try block_scope.statements.append(&op_node.base); | | |
| 5864 | | 4253 | |
| 5865 | last = try parseCCondExpr(c, m, scope); | 4254 | last = try parseCCondExpr(c, m, scope); |
| 5866 | _ = try appendToken(c, .Semicolon, ";"); | | |
| 5867 | if (m.next().? != .Comma) { | 4255 | if (m.next().? != .Comma) { |
| 5868 | m.i -= 1; | 4256 | m.i -= 1; |
| 5869 | break; | 4257 | break; |
| 5870 | } | 4258 | } |
| 5871 | } | 4259 | } |
| 5872 | | 4260 | |
| 5873 | const break_node = try transCreateNodeBreak(c, block_scope.label, last); | 4261 | const break_node = try Tag.break_val.create(c.arena, .{ |
| 5874 | try block_scope.statements.append(&break_node.base); | 4262 | .label = block_scope.label, |
| | 4263 | .val = last, |
| | 4264 | }); |
| | 4265 | try block_scope.statements.append(break_node); |
| 5875 | return try block_scope.complete(c); | 4266 | return try block_scope.complete(c); |
| 5876 | } | 4267 | } |
| 5877 | | 4268 | |
| 5878 | fn parseCNumLit(c: *Context, m: *MacroCtx) ParseError!*ast.Node { | 4269 | fn parseCNumLit(c: *Context, m: *MacroCtx) ParseError!Node { |
| 5879 | var lit_bytes = m.slice(); | 4270 | var lit_bytes = m.slice(); |
| 5880 | | 4271 | |
| 5881 | switch (m.list[m.i].id) { | 4272 | switch (m.list[m.i].id) { |
| ... | @@ -5895,11 +4286,10 @@ fn parseCNumLit(c: *Context, m: *MacroCtx) ParseError!*ast.Node { | ... | @@ -5895,11 +4286,10 @@ fn parseCNumLit(c: *Context, m: *MacroCtx) ParseError!*ast.Node { |
| 5895 | } | 4286 | } |
| 5896 | | 4287 | |
| 5897 | if (suffix == .none) { | 4288 | if (suffix == .none) { |
| 5898 | return transCreateNodeInt(c, lit_bytes); | 4289 | return transCreateNodeNumber(c, lit_bytes, .int); |
| 5899 | } | 4290 | } |
| 5900 | | 4291 | |
| 5901 | const cast_node = try c.createBuiltinCall("@as", 2); | 4292 | const type_node = try Tag.type.create(c.arena, switch (suffix) { |
| 5902 | cast_node.params()[0] = try transCreateNodeIdentifier(c, switch (suffix) { | | |
| 5903 | .u => "c_uint", | 4293 | .u => "c_uint", |
| 5904 | .l => "c_long", | 4294 | .l => "c_long", |
| 5905 | .lu => "c_ulong", | 4295 | .lu => "c_ulong", |
| ... | @@ -5913,27 +4303,22 @@ fn parseCNumLit(c: *Context, m: *MacroCtx) ParseError!*ast.Node { | ... | @@ -5913,27 +4303,22 @@ fn parseCNumLit(c: *Context, m: *MacroCtx) ParseError!*ast.Node { |
| 5913 | .llu => 3, | 4303 | .llu => 3, |
| 5914 | else => unreachable, | 4304 | else => unreachable, |
| 5915 | }]; | 4305 | }]; |
| 5916 | _ = try appendToken(c, .Comma, ","); | 4306 | const rhs = try transCreateNodeNumber(c, lit_bytes, .int); |
| 5917 | cast_node.params()[1] = try transCreateNodeInt(c, lit_bytes); | 4307 | return Tag.as.create(c.arena, .{ .lhs = type_node, .rhs = rhs }); |
| 5918 | cast_node.rparen_token = try appendToken(c, .RParen, ")"); | | |
| 5919 | return &cast_node.base; | | |
| 5920 | }, | 4308 | }, |
| 5921 | .FloatLiteral => |suffix| { | 4309 | .FloatLiteral => |suffix| { |
| 5922 | if (lit_bytes[0] == '.') | 4310 | if (lit_bytes[0] == '.') |
| 5923 | lit_bytes = try std.fmt.allocPrint(c.arena, "0{s}", .{lit_bytes}); | 4311 | lit_bytes = try std.fmt.allocPrint(c.arena, "0{s}", .{lit_bytes}); |
| 5924 | if (suffix == .none) { | 4312 | if (suffix == .none) { |
| 5925 | return transCreateNodeFloat(c, lit_bytes); | 4313 | return transCreateNodeNumber(c, lit_bytes, .float); |
| 5926 | } | 4314 | } |
| 5927 | const cast_node = try c.createBuiltinCall("@as", 2); | 4315 | const type_node = try Tag.type.create(c.arena, switch (suffix) { |
| 5928 | cast_node.params()[0] = try transCreateNodeIdentifier(c, switch (suffix) { | | |
| 5929 | .f => "f32", | 4316 | .f => "f32", |
| 5930 | .l => "c_longdouble", | 4317 | .l => "c_longdouble", |
| 5931 | else => unreachable, | 4318 | else => unreachable, |
| 5932 | }); | 4319 | }); |
| 5933 | _ = try appendToken(c, .Comma, ","); | 4320 | const rhs = try transCreateNodeNumber(c, lit_bytes[0 .. lit_bytes.len - 1], .float); |
| 5934 | cast_node.params()[1] = try transCreateNodeFloat(c, lit_bytes[0 .. lit_bytes.len - 1]); | 4321 | return Tag.as.create(c.arena, .{ .lhs = type_node, .rhs = rhs }); |
| 5935 | cast_node.rparen_token = try appendToken(c, .RParen, ")"); | | |
| 5936 | return &cast_node.base; | | |
| 5937 | }, | 4322 | }, |
| 5938 | else => unreachable, | 4323 | else => unreachable, |
| 5939 | } | 4324 | } |
| ... | @@ -6099,79 +4484,62 @@ fn zigifyEscapeSequences(ctx: *Context, m: *MacroCtx) ![]const u8 { | ... | @@ -6099,79 +4484,62 @@ fn zigifyEscapeSequences(ctx: *Context, m: *MacroCtx) ![]const u8 { |
| 6099 | return bytes[0..i]; | 4484 | return bytes[0..i]; |
| 6100 | } | 4485 | } |
| 6101 | | 4486 | |
| 6102 | fn parseCPrimaryExprInner(c: *Context, m: *MacroCtx, scope: *Scope) ParseError!*ast.Node { | 4487 | fn parseCPrimaryExprInner(c: *Context, m: *MacroCtx, scope: *Scope) ParseError!Node { |
| 6103 | const tok = m.next().?; | 4488 | const tok = m.next().?; |
| 6104 | const slice = m.slice(); | 4489 | const slice = m.slice(); |
| 6105 | switch (tok) { | 4490 | switch (tok) { |
| 6106 | .CharLiteral => { | 4491 | .CharLiteral => { |
| 6107 | if (slice[0] != '\'' or slice[1] == '\\' or slice.len == 3) { | 4492 | if (slice[0] != '\'' or slice[1] == '\\' or slice.len == 3) { |
| 6108 | const token = try appendToken(c, .CharLiteral, try zigifyEscapeSequences(c, m)); | 4493 | return Tag.char_literal.create(c.arena, try zigifyEscapeSequences(c, m)); |
| 6109 | const node = try c.arena.create(ast.Node.OneToken); | | |
| 6110 | node.* = .{ | | |
| 6111 | .base = .{ .tag = .CharLiteral }, | | |
| 6112 | .token = token, | | |
| 6113 | }; | | |
| 6114 | return &node.base; | | |
| 6115 | } else { | 4494 | } else { |
| 6116 | const token = try appendTokenFmt(c, .IntegerLiteral, "0x{x}", .{slice[1 .. slice.len - 1]}); | 4495 | const str = try std.fmt.allocPrint(c.arena, "0x{x}", .{slice[1 .. slice.len - 1]}); |
| 6117 | const node = try c.arena.create(ast.Node.OneToken); | 4496 | return Tag.integer_literal.create(c.arena, str); |
| 6118 | node.* = .{ | | |
| 6119 | .base = .{ .tag = .IntegerLiteral }, | | |
| 6120 | .token = token, | | |
| 6121 | }; | | |
| 6122 | return &node.base; | | |
| 6123 | } | 4497 | } |
| 6124 | }, | 4498 | }, |
| 6125 | .StringLiteral => { | 4499 | .StringLiteral => { |
| 6126 | const token = try appendToken(c, .StringLiteral, try zigifyEscapeSequences(c, m)); | 4500 | return Tag.string_literal.create(c.arena, try zigifyEscapeSequences(c, m)); |
| 6127 | const node = try c.arena.create(ast.Node.OneToken); | | |
| 6128 | node.* = .{ | | |
| 6129 | .base = .{ .tag = .StringLiteral }, | | |
| 6130 | .token = token, | | |
| 6131 | }; | | |
| 6132 | return &node.base; | | |
| 6133 | }, | 4501 | }, |
| 6134 | .IntegerLiteral, .FloatLiteral => { | 4502 | .IntegerLiteral, .FloatLiteral => { |
| 6135 | return parseCNumLit(c, m); | 4503 | return parseCNumLit(c, m); |
| 6136 | }, | 4504 | }, |
| 6137 | // eventually this will be replaced by std.c.parse which will handle these correctly | 4505 | // eventually this will be replaced by std.c.parse which will handle these correctly |
| 6138 | .Keyword_void => return transCreateNodeIdentifierUnchecked(c, "c_void"), | 4506 | .Keyword_void => return Tag.type.create(c.arena, "c_void"), |
| 6139 | .Keyword_bool => return transCreateNodeIdentifierUnchecked(c, "bool"), | 4507 | .Keyword_bool => return Tag.type.create(c.arena, "bool"), |
| 6140 | .Keyword_double => return transCreateNodeIdentifierUnchecked(c, "f64"), | 4508 | .Keyword_double => return Tag.type.create(c.arena, "f64"), |
| 6141 | .Keyword_long => return transCreateNodeIdentifierUnchecked(c, "c_long"), | 4509 | .Keyword_long => return Tag.type.create(c.arena, "c_long"), |
| 6142 | .Keyword_int => return transCreateNodeIdentifierUnchecked(c, "c_int"), | 4510 | .Keyword_int => return Tag.type.create(c.arena, "c_int"), |
| 6143 | .Keyword_float => return transCreateNodeIdentifierUnchecked(c, "f32"), | 4511 | .Keyword_float => return Tag.type.create(c.arena, "f32"), |
| 6144 | .Keyword_short => return transCreateNodeIdentifierUnchecked(c, "c_short"), | 4512 | .Keyword_short => return Tag.type.create(c.arena, "c_short"), |
| 6145 | .Keyword_char => return transCreateNodeIdentifierUnchecked(c, "u8"), | 4513 | .Keyword_char => return Tag.type.create(c.arena, "u8"), |
| 6146 | .Keyword_unsigned => if (m.next()) |t| switch (t) { | 4514 | .Keyword_unsigned => if (m.next()) |t| switch (t) { |
| 6147 | .Keyword_char => return transCreateNodeIdentifierUnchecked(c, "u8"), | 4515 | .Keyword_char => return Tag.type.create(c.arena, "u8"), |
| 6148 | .Keyword_short => return transCreateNodeIdentifierUnchecked(c, "c_ushort"), | 4516 | .Keyword_short => return Tag.type.create(c.arena, "c_ushort"), |
| 6149 | .Keyword_int => return transCreateNodeIdentifierUnchecked(c, "c_uint"), | 4517 | .Keyword_int => return Tag.type.create(c.arena, "c_uint"), |
| 6150 | .Keyword_long => if (m.peek() != null and m.peek().? == .Keyword_long) { | 4518 | .Keyword_long => if (m.peek() != null and m.peek().? == .Keyword_long) { |
| 6151 | _ = m.next(); | 4519 | _ = m.next(); |
| 6152 | return transCreateNodeIdentifierUnchecked(c, "c_ulonglong"); | 4520 | return Tag.type.create(c.arena, "c_ulonglong"); |
| 6153 | } else return transCreateNodeIdentifierUnchecked(c, "c_ulong"), | 4521 | } else return Tag.type.create(c.arena, "c_ulong"), |
| 6154 | else => { | 4522 | else => { |
| 6155 | m.i -= 1; | 4523 | m.i -= 1; |
| 6156 | return transCreateNodeIdentifierUnchecked(c, "c_uint"); | 4524 | return Tag.type.create(c.arena, "c_uint"); |
| 6157 | }, | 4525 | }, |
| 6158 | } else { | 4526 | } else { |
| 6159 | return transCreateNodeIdentifierUnchecked(c, "c_uint"); | 4527 | return Tag.type.create(c.arena, "c_uint"); |
| 6160 | }, | 4528 | }, |
| 6161 | .Keyword_signed => if (m.next()) |t| switch (t) { | 4529 | .Keyword_signed => if (m.next()) |t| switch (t) { |
| 6162 | .Keyword_char => return transCreateNodeIdentifierUnchecked(c, "i8"), | 4530 | .Keyword_char => return Tag.type.create(c.arena, "i8"), |
| 6163 | .Keyword_short => return transCreateNodeIdentifierUnchecked(c, "c_short"), | 4531 | .Keyword_short => return Tag.type.create(c.arena, "c_short"), |
| 6164 | .Keyword_int => return transCreateNodeIdentifierUnchecked(c, "c_int"), | 4532 | .Keyword_int => return Tag.type.create(c.arena, "c_int"), |
| 6165 | .Keyword_long => if (m.peek() != null and m.peek().? == .Keyword_long) { | 4533 | .Keyword_long => if (m.peek() != null and m.peek().? == .Keyword_long) { |
| 6166 | _ = m.next(); | 4534 | _ = m.next(); |
| 6167 | return transCreateNodeIdentifierUnchecked(c, "c_longlong"); | 4535 | return Tag.type.create(c.arena, "c_longlong"); |
| 6168 | } else return transCreateNodeIdentifierUnchecked(c, "c_long"), | 4536 | } else return Tag.type.create(c.arena, "c_long"), |
| 6169 | else => { | 4537 | else => { |
| 6170 | m.i -= 1; | 4538 | m.i -= 1; |
| 6171 | return transCreateNodeIdentifierUnchecked(c, "c_int"); | 4539 | return Tag.type.create(c.arena, "c_int"); |
| 6172 | }, | 4540 | }, |
| 6173 | } else { | 4541 | } else { |
| 6174 | return transCreateNodeIdentifierUnchecked(c, "c_int"); | 4542 | return Tag.type.create(c.arena, "c_int"); |
| 6175 | }, | 4543 | }, |
| 6176 | .Keyword_enum, .Keyword_struct, .Keyword_union => { | 4544 | .Keyword_enum, .Keyword_struct, .Keyword_union => { |
| 6177 | // struct Foo will be declared as struct_Foo by transRecordDecl | 4545 | // struct Foo will be declared as struct_Foo by transRecordDecl |
| ... | @@ -6181,17 +4549,12 @@ fn parseCPrimaryExprInner(c: *Context, m: *MacroCtx, scope: *Scope) ParseError!* | ... | @@ -6181,17 +4549,12 @@ fn parseCPrimaryExprInner(c: *Context, m: *MacroCtx, scope: *Scope) ParseError!* |
| 6181 | return error.ParseError; | 4549 | return error.ParseError; |
| 6182 | } | 4550 | } |
| 6183 | | 4551 | |
| 6184 | const ident_token = try appendTokenFmt(c, .Identifier, "{s}_{s}", .{ slice, m.slice() }); | 4552 | const name = try std.fmt.allocPrint(c.arena, "{s}_{s}", .{ slice, m.slice() }); |
| 6185 | const identifier = try c.arena.create(ast.Node.OneToken); | 4553 | return Tag.identifier.create(c.arena, name); |
| 6186 | identifier.* = .{ | | |
| 6187 | .base = .{ .tag = .Identifier }, | | |
| 6188 | .token = ident_token, | | |
| 6189 | }; | | |
| 6190 | return &identifier.base; | | |
| 6191 | }, | 4554 | }, |
| 6192 | .Identifier => { | 4555 | .Identifier => { |
| 6193 | const mangled_name = scope.getAlias(slice); | 4556 | const mangled_name = scope.getAlias(slice); |
| 6194 | return transCreateNodeIdentifier(c, checkForBuiltinTypedef(mangled_name) orelse mangled_name); | 4557 | return Tag.identifier.create(c.arena, builtin_typedef_map.get(mangled_name) orelse mangled_name); |
| 6195 | }, | 4558 | }, |
| 6196 | .LParen => { | 4559 | .LParen => { |
| 6197 | const inner_node = try parseCExpr(c, m, scope); | 4560 | const inner_node = try parseCExpr(c, m, scope); |
| ... | @@ -6221,10 +4584,6 @@ fn parseCPrimaryExprInner(c: *Context, m: *MacroCtx, scope: *Scope) ParseError!* | ... | @@ -6221,10 +4584,6 @@ fn parseCPrimaryExprInner(c: *Context, m: *MacroCtx, scope: *Scope) ParseError!* |
| 6221 | }, | 4584 | }, |
| 6222 | else => return inner_node, | 4585 | else => return inner_node, |
| 6223 | } | 4586 | } |
| 6224 | | | |
| 6225 | // hack to get zig fmt to render a comma in builtin calls | | |
| 6226 | _ = try appendToken(c, .Comma, ","); | | |
| 6227 | | | |
| 6228 | const node_to_cast = try parseCExpr(c, m, scope); | 4587 | const node_to_cast = try parseCExpr(c, m, scope); |
| 6229 | | 4588 | |
| 6230 | if (saw_l_paren and m.next().? != .RParen) { | 4589 | if (saw_l_paren and m.next().? != .RParen) { |
| ... | @@ -6232,28 +4591,7 @@ fn parseCPrimaryExprInner(c: *Context, m: *MacroCtx, scope: *Scope) ParseError!* | ... | @@ -6232,28 +4591,7 @@ fn parseCPrimaryExprInner(c: *Context, m: *MacroCtx, scope: *Scope) ParseError!* |
| 6232 | return error.ParseError; | 4591 | return error.ParseError; |
| 6233 | } | 4592 | } |
| 6234 | | 4593 | |
| 6235 | const lparen = try appendToken(c, .LParen, "("); | 4594 | return Tag.std_meta_cast.create(c.arena, .{ .lhs = inner_node, .rhs = node_to_cast }); |
| 6236 | | | |
| 6237 | //(@import("std").meta.cast(dest, x)) | | |
| 6238 | const import_fn_call = try c.createBuiltinCall("@import", 1); | | |
| 6239 | const std_node = try transCreateNodeStringLiteral(c, "\"std\""); | | |
| 6240 | import_fn_call.params()[0] = std_node; | | |
| 6241 | import_fn_call.rparen_token = try appendToken(c, .RParen, ")"); | | |
| 6242 | const inner_field_access = try transCreateNodeFieldAccess(c, &import_fn_call.base, "meta"); | | |
| 6243 | const outer_field_access = try transCreateNodeFieldAccess(c, inner_field_access, "cast"); | | |
| 6244 | | | |
| 6245 | const cast_fn_call = try c.createCall(outer_field_access, 2); | | |
| 6246 | cast_fn_call.params()[0] = inner_node; | | |
| 6247 | cast_fn_call.params()[1] = node_to_cast; | | |
| 6248 | cast_fn_call.rtoken = try appendToken(c, .RParen, ")"); | | |
| 6249 | | | |
| 6250 | const group_node = try c.arena.create(ast.Node.GroupedExpression); | | |
| 6251 | group_node.* = .{ | | |
| 6252 | .lparen = lparen, | | |
| 6253 | .expr = &cast_fn_call.base, | | |
| 6254 | .rparen = try appendToken(c, .RParen, ")"), | | |
| 6255 | }; | | |
| 6256 | return &group_node.base; | | |
| 6257 | }, | 4595 | }, |
| 6258 | else => { | 4596 | else => { |
| 6259 | try m.fail(c, "unable to translate C expr: unexpected token .{s}", .{@tagName(tok)}); | 4597 | try m.fail(c, "unable to translate C expr: unexpected token .{s}", .{@tagName(tok)}); |
| ... | @@ -6262,447 +4600,256 @@ fn parseCPrimaryExprInner(c: *Context, m: *MacroCtx, scope: *Scope) ParseError!* | ... | @@ -6262,447 +4600,256 @@ fn parseCPrimaryExprInner(c: *Context, m: *MacroCtx, scope: *Scope) ParseError!* |
| 6262 | } | 4600 | } |
| 6263 | } | 4601 | } |
| 6264 | | 4602 | |
| 6265 | fn parseCPrimaryExpr(c: *Context, m: *MacroCtx, scope: *Scope) ParseError!*ast.Node { | 4603 | fn parseCPrimaryExpr(c: *Context, m: *MacroCtx, scope: *Scope) ParseError!Node { |
| 6266 | var node = try parseCPrimaryExprInner(c, m, scope); | 4604 | var node = try parseCPrimaryExprInner(c, m, scope); |
| 6267 | // In C the preprocessor would handle concatting strings while expanding macros. | 4605 | // In C the preprocessor would handle concatting strings while expanding macros. |
| 6268 | // This should do approximately the same by concatting any strings and identifiers | 4606 | // This should do approximately the same by concatting any strings and identifiers |
| 6269 | // after a primary expression. | 4607 | // after a primary expression. |
| 6270 | while (true) { | 4608 | while (true) { |
| 6271 | var op_token: ast.TokenIndex = undefined; | | |
| 6272 | var op_id: ast.Node.Tag = undefined; | | |
| 6273 | switch (m.peek().?) { | 4609 | switch (m.peek().?) { |
| 6274 | .StringLiteral, .Identifier => {}, | 4610 | .StringLiteral, .Identifier => {}, |
| 6275 | else => break, | 4611 | else => break, |
| 6276 | } | 4612 | } |
| 6277 | const op_node = try c.arena.create(ast.Node.SimpleInfixOp); | 4613 | node = try Tag.array_cat.create(c.arena, .{ .lhs = node, .rhs = try parseCPrimaryExprInner(c, m, scope) }); |
| 6278 | op_node.* = .{ | | |
| 6279 | .base = .{ .tag = .ArrayCat }, | | |
| 6280 | .op_token = try appendToken(c, .PlusPlus, "++"), | | |
| 6281 | .lhs = node, | | |
| 6282 | .rhs = try parseCPrimaryExprInner(c, m, scope), | | |
| 6283 | }; | | |
| 6284 | node = &op_node.base; | | |
| 6285 | } | 4614 | } |
| 6286 | return node; | 4615 | return node; |
| 6287 | } | 4616 | } |
| 6288 | | 4617 | |
| 6289 | fn nodeIsInfixOp(tag: ast.Node.Tag) bool { | 4618 | fn macroBoolToInt(c: *Context, node: Node) !Node { |
| 6290 | return switch (tag) { | | |
| 6291 | .Add, | | |
| 6292 | .AddWrap, | | |
| 6293 | .ArrayCat, | | |
| 6294 | .ArrayMult, | | |
| 6295 | .Assign, | | |
| 6296 | .AssignBitAnd, | | |
| 6297 | .AssignBitOr, | | |
| 6298 | .AssignBitShiftLeft, | | |
| 6299 | .AssignBitShiftRight, | | |
| 6300 | .AssignBitXor, | | |
| 6301 | .AssignDiv, | | |
| 6302 | .AssignSub, | | |
| 6303 | .AssignSubWrap, | | |
| 6304 | .AssignMod, | | |
| 6305 | .AssignAdd, | | |
| 6306 | .AssignAddWrap, | | |
| 6307 | .AssignMul, | | |
| 6308 | .AssignMulWrap, | | |
| 6309 | .BangEqual, | | |
| 6310 | .BitAnd, | | |
| 6311 | .BitOr, | | |
| 6312 | .BitShiftLeft, | | |
| 6313 | .BitShiftRight, | | |
| 6314 | .BitXor, | | |
| 6315 | .BoolAnd, | | |
| 6316 | .BoolOr, | | |
| 6317 | .Div, | | |
| 6318 | .EqualEqual, | | |
| 6319 | .ErrorUnion, | | |
| 6320 | .GreaterOrEqual, | | |
| 6321 | .GreaterThan, | | |
| 6322 | .LessOrEqual, | | |
| 6323 | .LessThan, | | |
| 6324 | .MergeErrorSets, | | |
| 6325 | .Mod, | | |
| 6326 | .Mul, | | |
| 6327 | .MulWrap, | | |
| 6328 | .Period, | | |
| 6329 | .Range, | | |
| 6330 | .Sub, | | |
| 6331 | .SubWrap, | | |
| 6332 | .UnwrapOptional, | | |
| 6333 | .Catch, | | |
| 6334 | => true, | | |
| 6335 | | | |
| 6336 | else => false, | | |
| 6337 | }; | | |
| 6338 | } | | |
| 6339 | | | |
| 6340 | fn macroBoolToInt(c: *Context, node: *ast.Node) !*ast.Node { | | |
| 6341 | if (!isBoolRes(node)) { | 4619 | if (!isBoolRes(node)) { |
| 6342 | if (!nodeIsInfixOp(node.tag)) return node; | 4620 | return node; |
| 6343 | | | |
| 6344 | const group_node = try c.arena.create(ast.Node.GroupedExpression); | | |
| 6345 | group_node.* = .{ | | |
| 6346 | .lparen = try appendToken(c, .LParen, "("), | | |
| 6347 | .expr = node, | | |
| 6348 | .rparen = try appendToken(c, .RParen, ")"), | | |
| 6349 | }; | | |
| 6350 | return &group_node.base; | | |
| 6351 | } | 4621 | } |
| 6352 | | 4622 | |
| 6353 | const builtin_node = try c.createBuiltinCall("@boolToInt", 1); | 4623 | return Tag.bool_to_int.create(c.arena, node); |
| 6354 | builtin_node.params()[0] = node; | | |
| 6355 | builtin_node.rparen_token = try appendToken(c, .RParen, ")"); | | |
| 6356 | return &builtin_node.base; | | |
| 6357 | } | 4624 | } |
| 6358 | | 4625 | |
| 6359 | fn macroIntToBool(c: *Context, node: *ast.Node) !*ast.Node { | 4626 | fn macroIntToBool(c: *Context, node: Node) !Node { |
| 6360 | if (isBoolRes(node)) { | 4627 | if (isBoolRes(node)) { |
| 6361 | if (!nodeIsInfixOp(node.tag)) return node; | 4628 | return node; |
| 6362 | | | |
| 6363 | const group_node = try c.arena.create(ast.Node.GroupedExpression); | | |
| 6364 | group_node.* = .{ | | |
| 6365 | .lparen = try appendToken(c, .LParen, "("), | | |
| 6366 | .expr = node, | | |
| 6367 | .rparen = try appendToken(c, .RParen, ")"), | | |
| 6368 | }; | | |
| 6369 | return &group_node.base; | | |
| 6370 | } | 4629 | } |
| 6371 | | 4630 | |
| 6372 | const op_token = try appendToken(c, .BangEqual, "!="); | 4631 | return Tag.not_equal.create(c.arena, .{ .lhs = node, .rhs = Tag.zero_literal.init() }); |
| 6373 | const zero = try transCreateNodeInt(c, 0); | | |
| 6374 | const res = try c.arena.create(ast.Node.SimpleInfixOp); | | |
| 6375 | res.* = .{ | | |
| 6376 | .base = .{ .tag = .BangEqual }, | | |
| 6377 | .op_token = op_token, | | |
| 6378 | .lhs = node, | | |
| 6379 | .rhs = zero, | | |
| 6380 | }; | | |
| 6381 | const group_node = try c.arena.create(ast.Node.GroupedExpression); | | |
| 6382 | group_node.* = .{ | | |
| 6383 | .lparen = try appendToken(c, .LParen, "("), | | |
| 6384 | .expr = &res.base, | | |
| 6385 | .rparen = try appendToken(c, .RParen, ")"), | | |
| 6386 | }; | | |
| 6387 | return &group_node.base; | | |
| 6388 | } | | |
| 6389 | | | |
| 6390 | fn macroGroup(c: *Context, node: *ast.Node) !*ast.Node { | | |
| 6391 | if (!nodeIsInfixOp(node.tag)) return node; | | |
| 6392 | | | |
| 6393 | const group_node = try c.arena.create(ast.Node.GroupedExpression); | | |
| 6394 | group_node.* = .{ | | |
| 6395 | .lparen = try appendToken(c, .LParen, "("), | | |
| 6396 | .expr = node, | | |
| 6397 | .rparen = try appendToken(c, .RParen, ")"), | | |
| 6398 | }; | | |
| 6399 | return &group_node.base; | | |
| 6400 | } | 4632 | } |
| 6401 | | 4633 | |
| 6402 | fn parseCCondExpr(c: *Context, m: *MacroCtx, scope: *Scope) ParseError!*ast.Node { | 4634 | fn parseCCondExpr(c: *Context, m: *MacroCtx, scope: *Scope) ParseError!Node { |
| 6403 | const node = try parseCOrExpr(c, m, scope); | 4635 | const node = try parseCOrExpr(c, m, scope); |
| 6404 | if (m.peek().? != .QuestionMark) { | 4636 | if (m.peek().? != .QuestionMark) { |
| 6405 | return node; | 4637 | return node; |
| 6406 | } | 4638 | } |
| 6407 | _ = m.next(); | 4639 | _ = m.next(); |
| 6408 | | 4640 | |
| 6409 | // must come immediately after expr | 4641 | const then_body = try parseCOrExpr(c, m, scope); |
| 6410 | _ = try appendToken(c, .RParen, ")"); | | |
| 6411 | const if_node = try transCreateNodeIf(c); | | |
| 6412 | if_node.condition = node; | | |
| 6413 | if_node.body = try parseCOrExpr(c, m, scope); | | |
| 6414 | if (m.next().? != .Colon) { | 4642 | if (m.next().? != .Colon) { |
| 6415 | try m.fail(c, "unable to translate C expr: expected ':'", .{}); | 4643 | try m.fail(c, "unable to translate C expr: expected ':'", .{}); |
| 6416 | return error.ParseError; | 4644 | return error.ParseError; |
| 6417 | } | 4645 | } |
| 6418 | if_node.@"else" = try transCreateNodeElse(c); | 4646 | const else_body = try parseCCondExpr(c, m, scope); |
| 6419 | if_node.@"else".?.body = try parseCCondExpr(c, m, scope); | 4647 | return Tag.@"if".create(c.arena, .{ .cond = node, .then = then_body, .@"else" = else_body }); |
| 6420 | return &if_node.base; | | |
| 6421 | } | 4648 | } |
| 6422 | | 4649 | |
| 6423 | fn parseCOrExpr(c: *Context, m: *MacroCtx, scope: *Scope) ParseError!*ast.Node { | 4650 | fn parseCOrExpr(c: *Context, m: *MacroCtx, scope: *Scope) ParseError!Node { |
| 6424 | var node = try parseCAndExpr(c, m, scope); | 4651 | var node = try parseCAndExpr(c, m, scope); |
| 6425 | while (m.next().? == .PipePipe) { | 4652 | while (m.next().? == .PipePipe) { |
| 6426 | const lhs_node = try macroIntToBool(c, node); | 4653 | const lhs = try macroIntToBool(c, node); |
| 6427 | const op_token = try appendToken(c, .Keyword_or, "or"); | 4654 | const rhs = try macroIntToBool(c, try parseCAndExpr(c, m, scope)); |
| 6428 | const rhs_node = try parseCAndExpr(c, m, scope); | 4655 | node = try Tag.@"or".create(c.arena, .{ .lhs = lhs, .rhs = rhs }); |
| 6429 | const op_node = try c.arena.create(ast.Node.SimpleInfixOp); | | |
| 6430 | op_node.* = .{ | | |
| 6431 | .base = .{ .tag = .BoolOr }, | | |
| 6432 | .op_token = op_token, | | |
| 6433 | .lhs = lhs_node, | | |
| 6434 | .rhs = try macroIntToBool(c, rhs_node), | | |
| 6435 | }; | | |
| 6436 | node = &op_node.base; | | |
| 6437 | } | 4656 | } |
| 6438 | m.i -= 1; | 4657 | m.i -= 1; |
| 6439 | return node; | 4658 | return node; |
| 6440 | } | 4659 | } |
| 6441 | | 4660 | |
| 6442 | fn parseCAndExpr(c: *Context, m: *MacroCtx, scope: *Scope) ParseError!*ast.Node { | 4661 | fn parseCAndExpr(c: *Context, m: *MacroCtx, scope: *Scope) ParseError!Node { |
| 6443 | var node = try parseCBitOrExpr(c, m, scope); | 4662 | var node = try parseCBitOrExpr(c, m, scope); |
| 6444 | while (m.next().? == .AmpersandAmpersand) { | 4663 | while (m.next().? == .AmpersandAmpersand) { |
| 6445 | const lhs_node = try macroIntToBool(c, node); | 4664 | const lhs = try macroIntToBool(c, node); |
| 6446 | const op_token = try appendToken(c, .Keyword_and, "and"); | 4665 | const rhs = try macroIntToBool(c, try parseCBitOrExpr(c, m, scope)); |
| 6447 | const rhs_node = try parseCBitOrExpr(c, m, scope); | 4666 | node = try Tag.@"and".create(c.arena, .{ .lhs = lhs, .rhs = rhs }); |
| 6448 | const op_node = try c.arena.create(ast.Node.SimpleInfixOp); | | |
| 6449 | op_node.* = .{ | | |
| 6450 | .base = .{ .tag = .BoolAnd }, | | |
| 6451 | .op_token = op_token, | | |
| 6452 | .lhs = lhs_node, | | |
| 6453 | .rhs = try macroIntToBool(c, rhs_node), | | |
| 6454 | }; | | |
| 6455 | node = &op_node.base; | | |
| 6456 | } | 4667 | } |
| 6457 | m.i -= 1; | 4668 | m.i -= 1; |
| 6458 | return node; | 4669 | return node; |
| 6459 | } | 4670 | } |
| 6460 | | 4671 | |
| 6461 | fn parseCBitOrExpr(c: *Context, m: *MacroCtx, scope: *Scope) ParseError!*ast.Node { | 4672 | fn parseCBitOrExpr(c: *Context, m: *MacroCtx, scope: *Scope) ParseError!Node { |
| 6462 | var node = try parseCBitXorExpr(c, m, scope); | 4673 | var node = try parseCBitXorExpr(c, m, scope); |
| 6463 | while (m.next().? == .Pipe) { | 4674 | while (m.next().? == .Pipe) { |
| 6464 | const lhs_node = try macroBoolToInt(c, node); | 4675 | const lhs = try macroBoolToInt(c, node); |
| 6465 | const op_token = try appendToken(c, .Pipe, "|"); | 4676 | const rhs = try macroBoolToInt(c, try parseCBitXorExpr(c, m, scope)); |
| 6466 | const rhs_node = try parseCBitXorExpr(c, m, scope); | 4677 | node = try Tag.bit_or.create(c.arena, .{ .lhs = lhs, .rhs = rhs }); |
| 6467 | const op_node = try c.arena.create(ast.Node.SimpleInfixOp); | | |
| 6468 | op_node.* = .{ | | |
| 6469 | .base = .{ .tag = .BitOr }, | | |
| 6470 | .op_token = op_token, | | |
| 6471 | .lhs = lhs_node, | | |
| 6472 | .rhs = try macroBoolToInt(c, rhs_node), | | |
| 6473 | }; | | |
| 6474 | node = &op_node.base; | | |
| 6475 | } | 4678 | } |
| 6476 | m.i -= 1; | 4679 | m.i -= 1; |
| 6477 | return node; | 4680 | return node; |
| 6478 | } | 4681 | } |
| 6479 | | 4682 | |
| 6480 | fn parseCBitXorExpr(c: *Context, m: *MacroCtx, scope: *Scope) ParseError!*ast.Node { | 4683 | fn parseCBitXorExpr(c: *Context, m: *MacroCtx, scope: *Scope) ParseError!Node { |
| 6481 | var node = try parseCBitAndExpr(c, m, scope); | 4684 | var node = try parseCBitAndExpr(c, m, scope); |
| 6482 | while (m.next().? == .Caret) { | 4685 | while (m.next().? == .Caret) { |
| 6483 | const lhs_node = try macroBoolToInt(c, node); | 4686 | const lhs = try macroBoolToInt(c, node); |
| 6484 | const op_token = try appendToken(c, .Caret, "^"); | 4687 | const rhs = try macroBoolToInt(c, try parseCBitAndExpr(c, m, scope)); |
| 6485 | const rhs_node = try parseCBitAndExpr(c, m, scope); | 4688 | node = try Tag.bit_xor.create(c.arena, .{ .lhs = lhs, .rhs = rhs }); |
| 6486 | const op_node = try c.arena.create(ast.Node.SimpleInfixOp); | | |
| 6487 | op_node.* = .{ | | |
| 6488 | .base = .{ .tag = .BitXor }, | | |
| 6489 | .op_token = op_token, | | |
| 6490 | .lhs = lhs_node, | | |
| 6491 | .rhs = try macroBoolToInt(c, rhs_node), | | |
| 6492 | }; | | |
| 6493 | node = &op_node.base; | | |
| 6494 | } | 4689 | } |
| 6495 | m.i -= 1; | 4690 | m.i -= 1; |
| 6496 | return node; | 4691 | return node; |
| 6497 | } | 4692 | } |
| 6498 | | 4693 | |
| 6499 | fn parseCBitAndExpr(c: *Context, m: *MacroCtx, scope: *Scope) ParseError!*ast.Node { | 4694 | fn parseCBitAndExpr(c: *Context, m: *MacroCtx, scope: *Scope) ParseError!Node { |
| 6500 | var node = try parseCEqExpr(c, m, scope); | 4695 | var node = try parseCEqExpr(c, m, scope); |
| 6501 | while (m.next().? == .Ampersand) { | 4696 | while (m.next().? == .Ampersand) { |
| 6502 | const lhs_node = try macroBoolToInt(c, node); | 4697 | const lhs = try macroBoolToInt(c, node); |
| 6503 | const op_token = try appendToken(c, .Ampersand, "&"); | 4698 | const rhs = try macroBoolToInt(c, try parseCEqExpr(c, m, scope)); |
| 6504 | const rhs_node = try parseCEqExpr(c, m, scope); | 4699 | node = try Tag.bit_and.create(c.arena, .{ .lhs = lhs, .rhs = rhs }); |
| 6505 | const op_node = try c.arena.create(ast.Node.SimpleInfixOp); | | |
| 6506 | op_node.* = .{ | | |
| 6507 | .base = .{ .tag = .BitAnd }, | | |
| 6508 | .op_token = op_token, | | |
| 6509 | .lhs = lhs_node, | | |
| 6510 | .rhs = try macroBoolToInt(c, rhs_node), | | |
| 6511 | }; | | |
| 6512 | node = &op_node.base; | | |
| 6513 | } | 4700 | } |
| 6514 | m.i -= 1; | 4701 | m.i -= 1; |
| 6515 | return node; | 4702 | return node; |
| 6516 | } | 4703 | } |
| 6517 | | 4704 | |
| 6518 | fn parseCEqExpr(c: *Context, m: *MacroCtx, scope: *Scope) ParseError!*ast.Node { | 4705 | fn parseCEqExpr(c: *Context, m: *MacroCtx, scope: *Scope) ParseError!Node { |
| 6519 | var node = try parseCRelExpr(c, m, scope); | 4706 | var node = try parseCRelExpr(c, m, scope); |
| 6520 | while (true) { | 4707 | while (true) { |
| 6521 | var op_token: ast.TokenIndex = undefined; | | |
| 6522 | var op_id: ast.Node.Tag = undefined; | | |
| 6523 | switch (m.peek().?) { | 4708 | switch (m.peek().?) { |
| 6524 | .BangEqual => { | 4709 | .BangEqual => { |
| 6525 | op_token = try appendToken(c, .BangEqual, "!="); | 4710 | _ = m.next(); |
| 6526 | op_id = .BangEqual; | 4711 | const lhs = try macroBoolToInt(c, node); |
| | 4712 | const rhs = try macroBoolToInt(c, try parseCRelExpr(c, m, scope)); |
| | 4713 | node = try Tag.not_equal.create(c.arena, .{ .lhs = lhs, .rhs = rhs }); |
| 6527 | }, | 4714 | }, |
| 6528 | .EqualEqual => { | 4715 | .EqualEqual => { |
| 6529 | op_token = try appendToken(c, .EqualEqual, "=="); | 4716 | _ = m.next(); |
| 6530 | op_id = .EqualEqual; | 4717 | const lhs = try macroBoolToInt(c, node); |
| | 4718 | const rhs = try macroBoolToInt(c, try parseCRelExpr(c, m, scope)); |
| | 4719 | node = try Tag.equal.create(c.arena, .{ .lhs = lhs, .rhs = rhs }); |
| 6531 | }, | 4720 | }, |
| 6532 | else => return node, | 4721 | else => return node, |
| 6533 | } | 4722 | } |
| 6534 | _ = m.next(); | | |
| 6535 | const lhs_node = try macroBoolToInt(c, node); | | |
| 6536 | const rhs_node = try parseCRelExpr(c, m, scope); | | |
| 6537 | const op_node = try c.arena.create(ast.Node.SimpleInfixOp); | | |
| 6538 | op_node.* = .{ | | |
| 6539 | .base = .{ .tag = op_id }, | | |
| 6540 | .op_token = op_token, | | |
| 6541 | .lhs = lhs_node, | | |
| 6542 | .rhs = try macroBoolToInt(c, rhs_node), | | |
| 6543 | }; | | |
| 6544 | node = &op_node.base; | | |
| 6545 | } | 4723 | } |
| 6546 | } | 4724 | } |
| 6547 | | 4725 | |
| 6548 | fn parseCRelExpr(c: *Context, m: *MacroCtx, scope: *Scope) ParseError!*ast.Node { | 4726 | fn parseCRelExpr(c: *Context, m: *MacroCtx, scope: *Scope) ParseError!Node { |
| 6549 | var node = try parseCShiftExpr(c, m, scope); | 4727 | var node = try parseCShiftExpr(c, m, scope); |
| 6550 | while (true) { | 4728 | while (true) { |
| 6551 | var op_token: ast.TokenIndex = undefined; | | |
| 6552 | var op_id: ast.Node.Tag = undefined; | | |
| 6553 | switch (m.peek().?) { | 4729 | switch (m.peek().?) { |
| 6554 | .AngleBracketRight => { | 4730 | .AngleBracketRight => { |
| 6555 | op_token = try appendToken(c, .AngleBracketRight, ">"); | 4731 | _ = m.next(); |
| 6556 | op_id = .GreaterThan; | 4732 | const lhs = try macroBoolToInt(c, node); |
| | 4733 | const rhs = try macroBoolToInt(c, try parseCShiftExpr(c, m, scope)); |
| | 4734 | node = try Tag.greater_than.create(c.arena, .{ .lhs = lhs, .rhs = rhs }); |
| 6557 | }, | 4735 | }, |
| 6558 | .AngleBracketRightEqual => { | 4736 | .AngleBracketRightEqual => { |
| 6559 | op_token = try appendToken(c, .AngleBracketRightEqual, ">="); | 4737 | _ = m.next(); |
| 6560 | op_id = .GreaterOrEqual; | 4738 | const lhs = try macroBoolToInt(c, node); |
| | 4739 | const rhs = try macroBoolToInt(c, try parseCShiftExpr(c, m, scope)); |
| | 4740 | node = try Tag.greater_than_equal.create(c.arena, .{ .lhs = lhs, .rhs = rhs }); |
| 6561 | }, | 4741 | }, |
| 6562 | .AngleBracketLeft => { | 4742 | .AngleBracketLeft => { |
| 6563 | op_token = try appendToken(c, .AngleBracketLeft, "<"); | 4743 | _ = m.next(); |
| 6564 | op_id = .LessThan; | 4744 | const lhs = try macroBoolToInt(c, node); |
| | 4745 | const rhs = try macroBoolToInt(c, try parseCShiftExpr(c, m, scope)); |
| | 4746 | node = try Tag.less_than.create(c.arena, .{ .lhs = lhs, .rhs = rhs }); |
| 6565 | }, | 4747 | }, |
| 6566 | .AngleBracketLeftEqual => { | 4748 | .AngleBracketLeftEqual => { |
| 6567 | op_token = try appendToken(c, .AngleBracketLeftEqual, "<="); | 4749 | _ = m.next(); |
| 6568 | op_id = .LessOrEqual; | 4750 | const lhs = try macroBoolToInt(c, node); |
| | 4751 | const rhs = try macroBoolToInt(c, try parseCShiftExpr(c, m, scope)); |
| | 4752 | node = try Tag.less_than_equal.create(c.arena, .{ .lhs = lhs, .rhs = rhs }); |
| 6569 | }, | 4753 | }, |
| 6570 | else => return node, | 4754 | else => return node, |
| 6571 | } | 4755 | } |
| 6572 | _ = m.next(); | | |
| 6573 | const lhs_node = try macroBoolToInt(c, node); | | |
| 6574 | const rhs_node = try parseCShiftExpr(c, m, scope); | | |
| 6575 | const op_node = try c.arena.create(ast.Node.SimpleInfixOp); | | |
| 6576 | op_node.* = .{ | | |
| 6577 | .base = .{ .tag = op_id }, | | |
| 6578 | .op_token = op_token, | | |
| 6579 | .lhs = lhs_node, | | |
| 6580 | .rhs = try macroBoolToInt(c, rhs_node), | | |
| 6581 | }; | | |
| 6582 | node = &op_node.base; | | |
| 6583 | } | 4756 | } |
| 6584 | } | 4757 | } |
| 6585 | | 4758 | |
| 6586 | fn parseCShiftExpr(c: *Context, m: *MacroCtx, scope: *Scope) ParseError!*ast.Node { | 4759 | fn parseCShiftExpr(c: *Context, m: *MacroCtx, scope: *Scope) ParseError!Node { |
| 6587 | var node = try parseCAddSubExpr(c, m, scope); | 4760 | var node = try parseCAddSubExpr(c, m, scope); |
| 6588 | while (true) { | 4761 | while (true) { |
| 6589 | var op_token: ast.TokenIndex = undefined; | | |
| 6590 | var op_id: ast.Node.Tag = undefined; | | |
| 6591 | switch (m.peek().?) { | 4762 | switch (m.peek().?) { |
| 6592 | .AngleBracketAngleBracketLeft => { | 4763 | .AngleBracketAngleBracketLeft => { |
| 6593 | op_token = try appendToken(c, .AngleBracketAngleBracketLeft, "<<"); | 4764 | _ = m.next(); |
| 6594 | op_id = .BitShiftLeft; | 4765 | const lhs = try macroBoolToInt(c, node); |
| | 4766 | const rhs = try macroBoolToInt(c, try parseCAddSubExpr(c, m, scope)); |
| | 4767 | node = try Tag.shl.create(c.arena, .{ .lhs = lhs, .rhs = rhs }); |
| 6595 | }, | 4768 | }, |
| 6596 | .AngleBracketAngleBracketRight => { | 4769 | .AngleBracketAngleBracketRight => { |
| 6597 | op_token = try appendToken(c, .AngleBracketAngleBracketRight, ">>"); | 4770 | _ = m.next(); |
| 6598 | op_id = .BitShiftRight; | 4771 | const lhs = try macroBoolToInt(c, node); |
| | 4772 | const rhs = try macroBoolToInt(c, try parseCAddSubExpr(c, m, scope)); |
| | 4773 | node = try Tag.shr.create(c.arena, .{ .lhs = lhs, .rhs = rhs }); |
| 6599 | }, | 4774 | }, |
| 6600 | else => return node, | 4775 | else => return node, |
| 6601 | } | 4776 | } |
| 6602 | _ = m.next(); | | |
| 6603 | const lhs_node = try macroBoolToInt(c, node); | | |
| 6604 | const rhs_node = try parseCAddSubExpr(c, m, scope); | | |
| 6605 | const op_node = try c.arena.create(ast.Node.SimpleInfixOp); | | |
| 6606 | op_node.* = .{ | | |
| 6607 | .base = .{ .tag = op_id }, | | |
| 6608 | .op_token = op_token, | | |
| 6609 | .lhs = lhs_node, | | |
| 6610 | .rhs = try macroBoolToInt(c, rhs_node), | | |
| 6611 | }; | | |
| 6612 | node = &op_node.base; | | |
| 6613 | } | 4777 | } |
| 6614 | } | 4778 | } |
| 6615 | | 4779 | |
| 6616 | fn parseCAddSubExpr(c: *Context, m: *MacroCtx, scope: *Scope) ParseError!*ast.Node { | 4780 | fn parseCAddSubExpr(c: *Context, m: *MacroCtx, scope: *Scope) ParseError!Node { |
| 6617 | var node = try parseCMulExpr(c, m, scope); | 4781 | var node = try parseCMulExpr(c, m, scope); |
| 6618 | while (true) { | 4782 | while (true) { |
| 6619 | var op_token: ast.TokenIndex = undefined; | | |
| 6620 | var op_id: ast.Node.Tag = undefined; | | |
| 6621 | switch (m.peek().?) { | 4783 | switch (m.peek().?) { |
| 6622 | .Plus => { | 4784 | .Plus => { |
| 6623 | op_token = try appendToken(c, .Plus, "+"); | 4785 | _ = m.next(); |
| 6624 | op_id = .Add; | 4786 | const lhs = try macroBoolToInt(c, node); |
| | 4787 | const rhs = try macroBoolToInt(c, try parseCMulExpr(c, m, scope)); |
| | 4788 | node = try Tag.add.create(c.arena, .{ .lhs = lhs, .rhs = rhs }); |
| 6625 | }, | 4789 | }, |
| 6626 | .Minus => { | 4790 | .Minus => { |
| 6627 | op_token = try appendToken(c, .Minus, "-"); | 4791 | _ = m.next(); |
| 6628 | op_id = .Sub; | 4792 | const lhs = try macroBoolToInt(c, node); |
| | 4793 | const rhs = try macroBoolToInt(c, try parseCMulExpr(c, m, scope)); |
| | 4794 | node = try Tag.sub.create(c.arena, .{ .lhs = lhs, .rhs = rhs }); |
| 6629 | }, | 4795 | }, |
| 6630 | else => return node, | 4796 | else => return node, |
| 6631 | } | 4797 | } |
| 6632 | _ = m.next(); | | |
| 6633 | const lhs_node = try macroBoolToInt(c, node); | | |
| 6634 | const rhs_node = try parseCMulExpr(c, m, scope); | | |
| 6635 | const op_node = try c.arena.create(ast.Node.SimpleInfixOp); | | |
| 6636 | op_node.* = .{ | | |
| 6637 | .base = .{ .tag = op_id }, | | |
| 6638 | .op_token = op_token, | | |
| 6639 | .lhs = lhs_node, | | |
| 6640 | .rhs = try macroBoolToInt(c, rhs_node), | | |
| 6641 | }; | | |
| 6642 | node = &op_node.base; | | |
| 6643 | } | 4798 | } |
| 6644 | } | 4799 | } |
| 6645 | | 4800 | |
| 6646 | fn parseCMulExpr(c: *Context, m: *MacroCtx, scope: *Scope) ParseError!*ast.Node { | 4801 | fn parseCMulExpr(c: *Context, m: *MacroCtx, scope: *Scope) ParseError!Node { |
| 6647 | var node = try parseCUnaryExpr(c, m, scope); | 4802 | var node = try parseCUnaryExpr(c, m, scope); |
| 6648 | while (true) { | 4803 | while (true) { |
| 6649 | var op_token: ast.TokenIndex = undefined; | | |
| 6650 | var op_id: ast.Node.Tag = undefined; | | |
| 6651 | switch (m.next().?) { | 4804 | switch (m.next().?) { |
| 6652 | .Asterisk => { | 4805 | .Asterisk => { |
| 6653 | if (m.peek().? == .RParen) { | 4806 | const next = m.peek().?; |
| | 4807 | if (next == .RParen or next == .Nl or next == .Eof) { |
| 6654 | // type *) | 4808 | // type *) |
| 6655 | | 4809 | |
| 6656 | // hack to get zig fmt to render a comma in builtin calls | | |
| 6657 | _ = try appendToken(c, .Comma, ","); | | |
| 6658 | | | |
| 6659 | // last token of `node` | 4810 | // last token of `node` |
| 6660 | const prev_id = m.list[m.i - 1].id; | 4811 | const prev_id = m.list[m.i - 1].id; |
| 6661 | | 4812 | |
| 6662 | if (prev_id == .Keyword_void) { | 4813 | if (prev_id == .Keyword_void) { |
| 6663 | const ptr = try transCreateNodePtrType(c, false, false, .Asterisk); | 4814 | const ptr = try Tag.single_pointer.create(c.arena, .{ |
| 6664 | ptr.rhs = node; | 4815 | .is_const = false, |
| 6665 | const optional_node = try transCreateNodeSimplePrefixOp(c, .OptionalType, .QuestionMark, "?"); | 4816 | .is_volatile = false, |
| 6666 | optional_node.rhs = &ptr.base; | 4817 | .elem_type = node, |
| 6667 | return &optional_node.base; | 4818 | }); |
| | 4819 | return Tag.optional_type.create(c.arena, ptr); |
| 6668 | } else { | 4820 | } else { |
| 6669 | const ptr = try transCreateNodePtrType(c, false, false, Token.Id.Identifier); | 4821 | return Tag.c_pointer.create(c.arena, .{ |
| 6670 | ptr.rhs = node; | 4822 | .is_const = false, |
| 6671 | return &ptr.base; | 4823 | .is_volatile = false, |
| | 4824 | .elem_type = node, |
| | 4825 | }); |
| 6672 | } | 4826 | } |
| 6673 | } else { | 4827 | } else { |
| 6674 | // expr * expr | 4828 | // expr * expr |
| 6675 | op_token = try appendToken(c, .Asterisk, "*"); | 4829 | const lhs = try macroBoolToInt(c, node); |
| 6676 | op_id = .BitShiftLeft; | 4830 | const rhs = try macroBoolToInt(c, try parseCUnaryExpr(c, m, scope)); |
| | 4831 | node = try Tag.mul.create(c.arena, .{ .lhs = lhs, .rhs = rhs }); |
| 6677 | } | 4832 | } |
| 6678 | }, | 4833 | }, |
| 6679 | .Slash => { | 4834 | .Slash => { |
| 6680 | op_id = .Div; | 4835 | const lhs = try macroBoolToInt(c, node); |
| 6681 | op_token = try appendToken(c, .Slash, "/"); | 4836 | const rhs = try macroBoolToInt(c, try parseCUnaryExpr(c, m, scope)); |
| | 4837 | node = try Tag.div.create(c.arena, .{ .lhs = lhs, .rhs = rhs }); |
| 6682 | }, | 4838 | }, |
| 6683 | .Percent => { | 4839 | .Percent => { |
| 6684 | op_id = .Mod; | 4840 | const lhs = try macroBoolToInt(c, node); |
| 6685 | op_token = try appendToken(c, .Percent, "%"); | 4841 | const rhs = try macroBoolToInt(c, try parseCUnaryExpr(c, m, scope)); |
| | 4842 | node = try Tag.mod.create(c.arena, .{ .lhs = lhs, .rhs = rhs }); |
| 6686 | }, | 4843 | }, |
| 6687 | else => { | 4844 | else => { |
| 6688 | m.i -= 1; | 4845 | m.i -= 1; |
| 6689 | return node; | 4846 | return node; |
| 6690 | }, | 4847 | }, |
| 6691 | } | 4848 | } |
| 6692 | const lhs_node = try macroBoolToInt(c, node); | | |
| 6693 | const rhs_node = try parseCUnaryExpr(c, m, scope); | | |
| 6694 | const op_node = try c.arena.create(ast.Node.SimpleInfixOp); | | |
| 6695 | op_node.* = .{ | | |
| 6696 | .base = .{ .tag = op_id }, | | |
| 6697 | .op_token = op_token, | | |
| 6698 | .lhs = lhs_node, | | |
| 6699 | .rhs = try macroBoolToInt(c, rhs_node), | | |
| 6700 | }; | | |
| 6701 | node = &op_node.base; | | |
| 6702 | } | 4849 | } |
| 6703 | } | 4850 | } |
| 6704 | | 4851 | |
| 6705 | fn parseCPostfixExpr(c: *Context, m: *MacroCtx, scope: *Scope) ParseError!*ast.Node { | 4852 | fn parseCPostfixExpr(c: *Context, m: *MacroCtx, scope: *Scope) ParseError!Node { |
| 6706 | var node = try parseCPrimaryExpr(c, m, scope); | 4853 | var node = try parseCPrimaryExpr(c, m, scope); |
| 6707 | while (true) { | 4854 | while (true) { |
| 6708 | switch (m.next().?) { | 4855 | switch (m.next().?) { |
| ... | @@ -6712,38 +4859,33 @@ fn parseCPostfixExpr(c: *Context, m: *MacroCtx, scope: *Scope) ParseError!*ast.N | ... | @@ -6712,38 +4859,33 @@ fn parseCPostfixExpr(c: *Context, m: *MacroCtx, scope: *Scope) ParseError!*ast.N |
| 6712 | return error.ParseError; | 4859 | return error.ParseError; |
| 6713 | } | 4860 | } |
| 6714 | | 4861 | |
| 6715 | node = try transCreateNodeFieldAccess(c, node, m.slice()); | 4862 | node = try Tag.field_access.create(c.arena, .{ .lhs = node, .field_name = m.slice() }); |
| 6716 | continue; | | |
| 6717 | }, | 4863 | }, |
| 6718 | .Arrow => { | 4864 | .Arrow => { |
| 6719 | if (m.next().? != .Identifier) { | 4865 | if (m.next().? != .Identifier) { |
| 6720 | try m.fail(c, "unable to translate C expr: expected identifier", .{}); | 4866 | try m.fail(c, "unable to translate C expr: expected identifier", .{}); |
| 6721 | return error.ParseError; | 4867 | return error.ParseError; |
| 6722 | } | 4868 | } |
| 6723 | const deref = try transCreateNodePtrDeref(c, node); | 4869 | |
| 6724 | node = try transCreateNodeFieldAccess(c, deref, m.slice()); | 4870 | const deref = try Tag.deref.create(c.arena, node); |
| 6725 | continue; | 4871 | node = try Tag.field_access.create(c.arena, .{ .lhs = deref, .field_name = m.slice() }); |
| 6726 | }, | 4872 | }, |
| 6727 | .LBracket => { | 4873 | .LBracket => { |
| 6728 | const arr_node = try transCreateNodeArrayAccess(c, node); | 4874 | const index = try macroBoolToInt(c, try parseCExpr(c, m, scope)); |
| 6729 | arr_node.index_expr = try parseCExpr(c, m, scope); | 4875 | node = try Tag.array_access.create(c.arena, .{ .lhs = node, .rhs = index }); |
| 6730 | arr_node.rtoken = try appendToken(c, .RBracket, "]"); | | |
| 6731 | node = &arr_node.base; | | |
| 6732 | if (m.next().? != .RBracket) { | 4876 | if (m.next().? != .RBracket) { |
| 6733 | try m.fail(c, "unable to translate C expr: expected ']'", .{}); | 4877 | try m.fail(c, "unable to translate C expr: expected ']'", .{}); |
| 6734 | return error.ParseError; | 4878 | return error.ParseError; |
| 6735 | } | 4879 | } |
| 6736 | continue; | | |
| 6737 | }, | 4880 | }, |
| 6738 | .LParen => { | 4881 | .LParen => { |
| 6739 | _ = try appendToken(c, .LParen, "("); | 4882 | var args = std.ArrayList(Node).init(c.gpa); |
| 6740 | var call_params = std.ArrayList(*ast.Node).init(c.gpa); | 4883 | defer args.deinit(); |
| 6741 | defer call_params.deinit(); | | |
| 6742 | while (true) { | 4884 | while (true) { |
| 6743 | const arg = try parseCCondExpr(c, m, scope); | 4885 | const arg = try parseCCondExpr(c, m, scope); |
| 6744 | try call_params.append(arg); | 4886 | try args.append(arg); |
| 6745 | switch (m.next().?) { | 4887 | switch (m.next().?) { |
| 6746 | .Comma => _ = try appendToken(c, .Comma, ","), | 4888 | .Comma => {}, |
| 6747 | .RParen => break, | 4889 | .RParen => break, |
| 6748 | else => { | 4890 | else => { |
| 6749 | try m.fail(c, "unable to translate C expr: expected ',' or ')'", .{}); | 4891 | try m.fail(c, "unable to translate C expr: expected ',' or ')'", .{}); |
| ... | @@ -6751,32 +4893,17 @@ fn parseCPostfixExpr(c: *Context, m: *MacroCtx, scope: *Scope) ParseError!*ast.N | ... | @@ -6751,32 +4893,17 @@ fn parseCPostfixExpr(c: *Context, m: *MacroCtx, scope: *Scope) ParseError!*ast.N |
| 6751 | }, | 4893 | }, |
| 6752 | } | 4894 | } |
| 6753 | } | 4895 | } |
| 6754 | const call_node = try ast.Node.Call.alloc(c.arena, call_params.items.len); | 4896 | node = try Tag.call.create(c.arena, .{ .lhs = node, .args = try c.arena.dupe(Node, args.items) }); |
| 6755 | call_node.* = .{ | | |
| 6756 | .lhs = node, | | |
| 6757 | .params_len = call_params.items.len, | | |
| 6758 | .async_token = null, | | |
| 6759 | .rtoken = try appendToken(c, .RParen, ")"), | | |
| 6760 | }; | | |
| 6761 | mem.copy(*ast.Node, call_node.params(), call_params.items); | | |
| 6762 | node = &call_node.base; | | |
| 6763 | continue; | | |
| 6764 | }, | 4897 | }, |
| 6765 | .LBrace => { | 4898 | .LBrace => { |
| 6766 | // must come immediately after `node` | 4899 | var init_vals = std.ArrayList(Node).init(c.gpa); |
| 6767 | _ = try appendToken(c, .Comma, ","); | | |
| 6768 | | | |
| 6769 | const dot = try appendToken(c, .Period, "."); | | |
| 6770 | _ = try appendToken(c, .LBrace, "{"); | | |
| 6771 | | | |
| 6772 | var init_vals = std.ArrayList(*ast.Node).init(c.gpa); | | |
| 6773 | defer init_vals.deinit(); | 4900 | defer init_vals.deinit(); |
| 6774 | | 4901 | |
| 6775 | while (true) { | 4902 | while (true) { |
| 6776 | const val = try parseCCondExpr(c, m, scope); | 4903 | const val = try parseCCondExpr(c, m, scope); |
| 6777 | try init_vals.append(val); | 4904 | try init_vals.append(val); |
| 6778 | switch (m.next().?) { | 4905 | switch (m.next().?) { |
| 6779 | .Comma => _ = try appendToken(c, .Comma, ","), | 4906 | .Comma => {}, |
| 6780 | .RBrace => break, | 4907 | .RBrace => break, |
| 6781 | else => { | 4908 | else => { |
| 6782 | try m.fail(c, "unable to translate C expr: expected ',' or '}}'", .{}); | 4909 | try m.fail(c, "unable to translate C expr: expected ',' or '}}'", .{}); |
| ... | @@ -6784,29 +4911,8 @@ fn parseCPostfixExpr(c: *Context, m: *MacroCtx, scope: *Scope) ParseError!*ast.N | ... | @@ -6784,29 +4911,8 @@ fn parseCPostfixExpr(c: *Context, m: *MacroCtx, scope: *Scope) ParseError!*ast.N |
| 6784 | }, | 4911 | }, |
| 6785 | } | 4912 | } |
| 6786 | } | 4913 | } |
| 6787 | const tuple_node = try ast.Node.StructInitializerDot.alloc(c.arena, init_vals.items.len); | 4914 | const tuple_node = try Tag.tuple.create(c.arena, try c.arena.dupe(Node, init_vals.items)); |
| 6788 | tuple_node.* = .{ | 4915 | node = try Tag.std_mem_zeroinit.create(c.arena, .{ .lhs = node, .rhs = tuple_node }); |
| 6789 | .dot = dot, | | |
| 6790 | .list_len = init_vals.items.len, | | |
| 6791 | .rtoken = try appendToken(c, .RBrace, "}"), | | |
| 6792 | }; | | |
| 6793 | mem.copy(*ast.Node, tuple_node.list(), init_vals.items); | | |
| 6794 | | | |
| 6795 | //(@import("std").mem.zeroInit(T, .{x})) | | |
| 6796 | const import_fn_call = try c.createBuiltinCall("@import", 1); | | |
| 6797 | const std_node = try transCreateNodeStringLiteral(c, "\"std\""); | | |
| 6798 | import_fn_call.params()[0] = std_node; | | |
| 6799 | import_fn_call.rparen_token = try appendToken(c, .RParen, ")"); | | |
| 6800 | const inner_field_access = try transCreateNodeFieldAccess(c, &import_fn_call.base, "mem"); | | |
| 6801 | const outer_field_access = try transCreateNodeFieldAccess(c, inner_field_access, "zeroInit"); | | |
| 6802 | | | |
| 6803 | const zero_init_call = try c.createCall(outer_field_access, 2); | | |
| 6804 | zero_init_call.params()[0] = node; | | |
| 6805 | zero_init_call.params()[1] = &tuple_node.base; | | |
| 6806 | zero_init_call.rtoken = try appendToken(c, .RParen, ")"); | | |
| 6807 | | | |
| 6808 | node = &zero_init_call.base; | | |
| 6809 | continue; | | |
| 6810 | }, | 4916 | }, |
| 6811 | .PlusPlus, .MinusMinus => { | 4917 | .PlusPlus, .MinusMinus => { |
| 6812 | try m.fail(c, "TODO postfix inc/dec expr", .{}); | 4918 | try m.fail(c, "TODO postfix inc/dec expr", .{}); |
| ... | @@ -6820,35 +4926,31 @@ fn parseCPostfixExpr(c: *Context, m: *MacroCtx, scope: *Scope) ParseError!*ast.N | ... | @@ -6820,35 +4926,31 @@ fn parseCPostfixExpr(c: *Context, m: *MacroCtx, scope: *Scope) ParseError!*ast.N |
| 6820 | } | 4926 | } |
| 6821 | } | 4927 | } |
| 6822 | | 4928 | |
| 6823 | fn parseCUnaryExpr(c: *Context, m: *MacroCtx, scope: *Scope) ParseError!*ast.Node { | 4929 | fn parseCUnaryExpr(c: *Context, m: *MacroCtx, scope: *Scope) ParseError!Node { |
| 6824 | switch (m.next().?) { | 4930 | switch (m.next().?) { |
| 6825 | .Bang => { | 4931 | .Bang => { |
| 6826 | const node = try transCreateNodeSimplePrefixOp(c, .BoolNot, .Bang, "!"); | 4932 | const operand = try macroIntToBool(c, try parseCUnaryExpr(c, m, scope)); |
| 6827 | node.rhs = try macroIntToBool(c, try parseCUnaryExpr(c, m, scope)); | 4933 | return Tag.not.create(c.arena, operand); |
| 6828 | return &node.base; | | |
| 6829 | }, | 4934 | }, |
| 6830 | .Minus => { | 4935 | .Minus => { |
| 6831 | const node = try transCreateNodeSimplePrefixOp(c, .Negation, .Minus, "-"); | 4936 | const operand = try macroBoolToInt(c, try parseCUnaryExpr(c, m, scope)); |
| 6832 | node.rhs = try macroBoolToInt(c, try parseCUnaryExpr(c, m, scope)); | 4937 | return Tag.negate.create(c.arena, operand); |
| 6833 | return &node.base; | | |
| 6834 | }, | 4938 | }, |
| 6835 | .Plus => return try parseCUnaryExpr(c, m, scope), | 4939 | .Plus => return try parseCUnaryExpr(c, m, scope), |
| 6836 | .Tilde => { | 4940 | .Tilde => { |
| 6837 | const node = try transCreateNodeSimplePrefixOp(c, .BitNot, .Tilde, "~"); | 4941 | const operand = try macroBoolToInt(c, try parseCUnaryExpr(c, m, scope)); |
| 6838 | node.rhs = try macroBoolToInt(c, try parseCUnaryExpr(c, m, scope)); | 4942 | return Tag.bit_not.create(c.arena, operand); |
| 6839 | return &node.base; | | |
| 6840 | }, | 4943 | }, |
| 6841 | .Asterisk => { | 4944 | .Asterisk => { |
| 6842 | const node = try macroGroup(c, try parseCUnaryExpr(c, m, scope)); | 4945 | const operand = try parseCUnaryExpr(c, m, scope); |
| 6843 | return try transCreateNodePtrDeref(c, node); | 4946 | return Tag.deref.create(c.arena, operand); |
| 6844 | }, | 4947 | }, |
| 6845 | .Ampersand => { | 4948 | .Ampersand => { |
| 6846 | const node = try transCreateNodeSimplePrefixOp(c, .AddressOf, .Ampersand, "&"); | 4949 | const operand = try parseCUnaryExpr(c, m, scope); |
| 6847 | node.rhs = try macroGroup(c, try parseCUnaryExpr(c, m, scope)); | 4950 | return Tag.address_of.create(c.arena, operand); |
| 6848 | return &node.base; | | |
| 6849 | }, | 4951 | }, |
| 6850 | .Keyword_sizeof => { | 4952 | .Keyword_sizeof => { |
| 6851 | const inner = if (m.peek().? == .LParen) blk: { | 4953 | const operand = if (m.peek().? == .LParen) blk: { |
| 6852 | _ = m.next(); | 4954 | _ = m.next(); |
| 6853 | // C grammar says this should be 'type-name' but we have to | 4955 | // C grammar says this should be 'type-name' but we have to |
| 6854 | // use parseCMulExpr to correctly handle pointer types. | 4956 | // use parseCMulExpr to correctly handle pointer types. |
| ... | @@ -6860,18 +4962,7 @@ fn parseCUnaryExpr(c: *Context, m: *MacroCtx, scope: *Scope) ParseError!*ast.Nod | ... | @@ -6860,18 +4962,7 @@ fn parseCUnaryExpr(c: *Context, m: *MacroCtx, scope: *Scope) ParseError!*ast.Nod |
| 6860 | break :blk inner; | 4962 | break :blk inner; |
| 6861 | } else try parseCUnaryExpr(c, m, scope); | 4963 | } else try parseCUnaryExpr(c, m, scope); |
| 6862 | | 4964 | |
| 6863 | //(@import("std").meta.sizeof(dest, x)) | 4965 | return Tag.std_meta_sizeof.create(c.arena, operand); |
| 6864 | const import_fn_call = try c.createBuiltinCall("@import", 1); | | |
| 6865 | const std_node = try transCreateNodeStringLiteral(c, "\"std\""); | | |
| 6866 | import_fn_call.params()[0] = std_node; | | |
| 6867 | import_fn_call.rparen_token = try appendToken(c, .RParen, ")"); | | |
| 6868 | const inner_field_access = try transCreateNodeFieldAccess(c, &import_fn_call.base, "meta"); | | |
| 6869 | const outer_field_access = try transCreateNodeFieldAccess(c, inner_field_access, "sizeof"); | | |
| 6870 | | | |
| 6871 | const sizeof_call = try c.createCall(outer_field_access, 1); | | |
| 6872 | sizeof_call.params()[0] = inner; | | |
| 6873 | sizeof_call.rtoken = try appendToken(c, .RParen, ")"); | | |
| 6874 | return &sizeof_call.base; | | |
| 6875 | }, | 4966 | }, |
| 6876 | .Keyword_alignof => { | 4967 | .Keyword_alignof => { |
| 6877 | // TODO this won't work if using <stdalign.h>'s | 4968 | // TODO this won't work if using <stdalign.h>'s |
| ... | @@ -6882,16 +4973,13 @@ fn parseCUnaryExpr(c: *Context, m: *MacroCtx, scope: *Scope) ParseError!*ast.Nod | ... | @@ -6882,16 +4973,13 @@ fn parseCUnaryExpr(c: *Context, m: *MacroCtx, scope: *Scope) ParseError!*ast.Nod |
| 6882 | } | 4973 | } |
| 6883 | // C grammar says this should be 'type-name' but we have to | 4974 | // C grammar says this should be 'type-name' but we have to |
| 6884 | // use parseCMulExpr to correctly handle pointer types. | 4975 | // use parseCMulExpr to correctly handle pointer types. |
| 6885 | const inner = try parseCMulExpr(c, m, scope); | 4976 | const operand = try parseCMulExpr(c, m, scope); |
| 6886 | if (m.next().? != .RParen) { | 4977 | if (m.next().? != .RParen) { |
| 6887 | try m.fail(c, "unable to translate C expr: expected ')'", .{}); | 4978 | try m.fail(c, "unable to translate C expr: expected ')'", .{}); |
| 6888 | return error.ParseError; | 4979 | return error.ParseError; |
| 6889 | } | 4980 | } |
| 6890 | | 4981 | |
| 6891 | const builtin_call = try c.createBuiltinCall("@alignOf", 1); | 4982 | return Tag.alignof.create(c.arena, operand); |
| 6892 | builtin_call.params()[0] = inner; | | |
| 6893 | builtin_call.rparen_token = try appendToken(c, .RParen, ")"); | | |
| 6894 | return &builtin_call.base; | | |
| 6895 | }, | 4983 | }, |
| 6896 | .PlusPlus, .MinusMinus => { | 4984 | .PlusPlus, .MinusMinus => { |
| 6897 | try m.fail(c, "TODO unary inc/dec expr", .{}); | 4985 | try m.fail(c, "TODO unary inc/dec expr", .{}); |
| ... | @@ -6904,51 +4992,40 @@ fn parseCUnaryExpr(c: *Context, m: *MacroCtx, scope: *Scope) ParseError!*ast.Nod | ... | @@ -6904,51 +4992,40 @@ fn parseCUnaryExpr(c: *Context, m: *MacroCtx, scope: *Scope) ParseError!*ast.Nod |
| 6904 | } | 4992 | } |
| 6905 | } | 4993 | } |
| 6906 | | 4994 | |
| 6907 | fn tokenSlice(c: *Context, token: ast.TokenIndex) []u8 { | 4995 | fn getContainer(c: *Context, node: Node) ?Node { |
| 6908 | const tok = c.token_locs.items[token]; | 4996 | switch (node.tag()) { |
| 6909 | const slice = c.source_buffer.items[tok.start..tok.end]; | 4997 | .@"union", |
| 6910 | return if (mem.startsWith(u8, slice, "@\"")) | 4998 | .@"struct", |
| 6911 | slice[2 .. slice.len - 1] | 4999 | .@"enum", |
| 6912 | else | 5000 | .address_of, |
| 6913 | slice; | 5001 | .bit_not, |
| 6914 | } | 5002 | .not, |
| 6915 | | 5003 | .optional_type, |
| 6916 | fn getContainer(c: *Context, node: *ast.Node) ?*ast.Node { | 5004 | .negate, |
| 6917 | switch (node.tag) { | 5005 | .negate_wrap, |
| 6918 | .ContainerDecl, | 5006 | .array_type, |
| 6919 | .AddressOf, | 5007 | .c_pointer, |
| 6920 | .Await, | 5008 | .single_pointer, |
| 6921 | .BitNot, | | |
| 6922 | .BoolNot, | | |
| 6923 | .OptionalType, | | |
| 6924 | .Negation, | | |
| 6925 | .NegationWrap, | | |
| 6926 | .Resume, | | |
| 6927 | .Try, | | |
| 6928 | .ArrayType, | | |
| 6929 | .ArrayTypeSentinel, | | |
| 6930 | .PtrType, | | |
| 6931 | .SliceType, | | |
| 6932 | => return node, | 5009 | => return node, |
| 6933 | | 5010 | |
| 6934 | .Identifier => { | 5011 | .identifier => { |
| 6935 | const ident = node.castTag(.Identifier).?; | 5012 | const ident = node.castTag(.identifier).?; |
| 6936 | if (c.global_scope.sym_table.get(tokenSlice(c, ident.token))) |value| { | 5013 | if (c.global_scope.sym_table.get(ident.data)) |value| { |
| 6937 | if (value.cast(ast.Node.VarDecl)) |var_decl| | 5014 | if (value.castTag(.var_decl)) |var_decl| |
| 6938 | return getContainer(c, var_decl.getInitNode().?); | 5015 | return getContainer(c, var_decl.data.init.?); |
| | 5016 | if (value.castTag(.var_simple) orelse value.castTag(.pub_var_simple)) |var_decl| |
| | 5017 | return getContainer(c, var_decl.data.init); |
| 6939 | } | 5018 | } |
| 6940 | }, | 5019 | }, |
| 6941 | | 5020 | |
| 6942 | .Period => { | 5021 | .field_access => { |
| 6943 | const infix = node.castTag(.Period).?; | 5022 | const field_access = node.castTag(.field_access).?; |
| 6944 | | 5023 | |
| 6945 | if (getContainerTypeOf(c, infix.lhs)) |ty_node| { | 5024 | if (getContainerTypeOf(c, field_access.data.lhs)) |ty_node| { |
| 6946 | if (ty_node.cast(ast.Node.ContainerDecl)) |container| { | 5025 | if (ty_node.castTag(.@"struct") orelse ty_node.castTag(.@"union")) |container| { |
| 6947 | for (container.fieldsAndDecls()) |field_ref| { | 5026 | for (container.data.fields) |field| { |
| 6948 | const field = field_ref.cast(ast.Node.ContainerField).?; | 5027 | if (mem.eql(u8, field.name, field_access.data.field_name)) { |
| 6949 | const ident = infix.rhs.castTag(.Identifier).?; | 5028 | return getContainer(c, field.type); |
| 6950 | if (mem.eql(u8, tokenSlice(c, field.name_token), tokenSlice(c, ident.token))) { | | |
| 6951 | return getContainer(c, field.type_expr.?); | | |
| 6952 | } | 5029 | } |
| 6953 | } | 5030 | } |
| 6954 | } | 5031 | } |
| ... | @@ -6960,22 +5037,19 @@ fn getContainer(c: *Context, node: *ast.Node) ?*ast.Node { | ... | @@ -6960,22 +5037,19 @@ fn getContainer(c: *Context, node: *ast.Node) ?*ast.Node { |
| 6960 | return null; | 5037 | return null; |
| 6961 | } | 5038 | } |
| 6962 | | 5039 | |
| 6963 | fn getContainerTypeOf(c: *Context, ref: *ast.Node) ?*ast.Node { | 5040 | fn getContainerTypeOf(c: *Context, ref: Node) ?Node { |
| 6964 | if (ref.castTag(.Identifier)) |ident| { | 5041 | if (ref.castTag(.identifier)) |ident| { |
| 6965 | if (c.global_scope.sym_table.get(tokenSlice(c, ident.token))) |value| { | 5042 | if (c.global_scope.sym_table.get(ident.data)) |value| { |
| 6966 | if (value.cast(ast.Node.VarDecl)) |var_decl| { | 5043 | if (value.castTag(.var_decl)) |var_decl| { |
| 6967 | if (var_decl.getTypeNode()) |ty| | 5044 | return getContainer(c, var_decl.data.type); |
| 6968 | return getContainer(c, ty); | | |
| 6969 | } | 5045 | } |
| 6970 | } | 5046 | } |
| 6971 | } else if (ref.castTag(.Period)) |infix| { | 5047 | } else if (ref.castTag(.field_access)) |field_access| { |
| 6972 | if (getContainerTypeOf(c, infix.lhs)) |ty_node| { | 5048 | if (getContainerTypeOf(c, field_access.data.lhs)) |ty_node| { |
| 6973 | if (ty_node.cast(ast.Node.ContainerDecl)) |container| { | 5049 | if (ty_node.castTag(.@"struct") orelse ty_node.castTag(.@"union")) |container| { |
| 6974 | for (container.fieldsAndDecls()) |field_ref| { | 5050 | for (container.data.fields) |field| { |
| 6975 | const field = field_ref.cast(ast.Node.ContainerField).?; | 5051 | if (mem.eql(u8, field.name, field_access.data.field_name)) { |
| 6976 | const ident = infix.rhs.castTag(.Identifier).?; | 5052 | return getContainer(c, field.type); |
| 6977 | if (mem.eql(u8, tokenSlice(c, field.name_token), tokenSlice(c, ident.token))) { | | |
| 6978 | return getContainer(c, field.type_expr.?); | | |
| 6979 | } | 5053 | } |
| 6980 | } | 5054 | } |
| 6981 | } else | 5055 | } else |
| ... | @@ -6985,11 +5059,16 @@ fn getContainerTypeOf(c: *Context, ref: *ast.Node) ?*ast.Node { | ... | @@ -6985,11 +5059,16 @@ fn getContainerTypeOf(c: *Context, ref: *ast.Node) ?*ast.Node { |
| 6985 | return null; | 5059 | return null; |
| 6986 | } | 5060 | } |
| 6987 | | 5061 | |
| 6988 | fn getFnProto(c: *Context, ref: *ast.Node) ?*ast.Node.FnProto { | 5062 | fn getFnProto(c: *Context, ref: Node) ?*ast.Payload.Func { |
| 6989 | const init = if (ref.cast(ast.Node.VarDecl)) |v| v.getInitNode().? else return null; | 5063 | const init = if (ref.castTag(.var_decl)) |v| |
| | 5064 | v.data.init orelse return null |
| | 5065 | else if (ref.castTag(.var_simple) orelse ref.castTag(.pub_var_simple)) |v| |
| | 5066 | v.data.init |
| | 5067 | else |
| | 5068 | return null; |
| 6990 | if (getContainerTypeOf(c, init)) |ty_node| { | 5069 | if (getContainerTypeOf(c, init)) |ty_node| { |
| 6991 | if (ty_node.castTag(.OptionalType)) |prefix| { | 5070 | if (ty_node.castTag(.optional_type)) |prefix| { |
| 6992 | if (prefix.rhs.cast(ast.Node.FnProto)) |fn_proto| { | 5071 | if (prefix.data.castTag(.func)) |fn_proto| { |
| 6993 | return fn_proto; | 5072 | return fn_proto; |
| 6994 | } | 5073 | } |
| 6995 | } | 5074 | } |
Veikka Tuominen <git@vexu.eu> 2021-02-19 13:03:29+02:00
GitHub <noreply@github.com> 2021-02-19 13:03:29+02:00
Signed by PGP key 4AEE18F83AFDEB23