diff --git a/doc/docgen.zig b/doc/docgen.zig index 50523d0948..52f373f5b1 100644 --- a/doc/docgen.zig +++ b/doc/docgen.zig @@ -808,6 +808,7 @@ fn tokenizeAndPrintRaw(docgen_tokenizer: *Tokenizer, out: anytype, source_token: .Keyword_noalias, .Keyword_noinline, .Keyword_nosuspend, + .Keyword_opaque, .Keyword_or, .Keyword_orelse, .Keyword_packed, diff --git a/doc/langref.html.in b/doc/langref.html.in index 22faf7fd8f..021fc76289 100644 --- a/doc/langref.html.in +++ b/doc/langref.html.in @@ -1988,7 +1988,7 @@ test "null terminated array" {
  • Supports slice syntax: {#syntax#}ptr[start..end]{#endsyntax#}
  • Supports pointer arithmetic: {#syntax#}ptr + x{#endsyntax#}, {#syntax#}ptr - x{#endsyntax#}
  • {#syntax#}T{#endsyntax#} must have a known size, which means that it cannot be - {#syntax#}c_void{#endsyntax#} or any other {#link|opaque type|Opaque Types#}.
    • + {#syntax#}c_void{#endsyntax#} or any other {#link|opaque type|opaque#}. @@ -5545,7 +5545,7 @@ test "turn HashMap into a set with void" {

    {#syntax#}void{#endsyntax#} is distinct from {#syntax#}c_void{#endsyntax#}, which is defined like this: - {#syntax#}pub const c_void = @Type(.Opaque);{#endsyntax#}. + {#syntax#}pub const c_void = opaque {};{#endsyntax#}. {#syntax#}void{#endsyntax#} has a known size of 0 bytes, and {#syntax#}c_void{#endsyntax#} has an unknown, but non-zero, size.

    @@ -8471,7 +8471,7 @@ test "integer truncation" {

  • {#link|Error Set Type#}
  • {#link|Error Union Type#}
  • {#link|Vectors#}
    • -
  • {#link|Opaque Types#}
    • +
  • {#link|opaque#}
  • {#link|@Frame#}
  • {#syntax#}anyframe{#endsyntax#}
  • {#link|struct#}
    • @@ -8547,17 +8547,18 @@ fn foo(comptime T: type, ptr: *T) T { {#header_close#} {#header_close#} - {#header_open|Opaque Types#} + {#header_open|opaque#}

    - {#syntax#}@Type(.Opaque){#endsyntax#} creates a new type with an unknown (but non-zero) size and alignment. + {#syntax#}opaque {}{#endsyntax#} declares a new type with an unknown (but non-zero) size and alignment. + It can have declarations like structs, unions, or enums.

    This is typically used for type safety when interacting with C code that does not expose struct details. Example:

    {#code_begin|test_err|expected type '*Derp', found '*Wat'#} -const Derp = @Type(.Opaque); -const Wat = @Type(.Opaque); +const Derp = opaque {}; +const Wat = opaque {}; extern fn bar(d: *Derp) void; fn foo(w: *Wat) callconv(.C) void { @@ -11193,7 +11194,7 @@ PtrTypeStart ContainerDeclAuto <- ContainerDeclType LBRACE ContainerMembers RBRACE ContainerDeclType - <- (KEYWORD_struct / KEYWORD_enum) (LPAREN Expr RPAREN)? + <- (KEYWORD_struct / KEYWORD_enum / KEYWORD_opaque) (LPAREN Expr RPAREN)? / KEYWORD_union (LPAREN (KEYWORD_enum (LPAREN Expr RPAREN)? / Expr) RPAREN)? # Alignment @@ -11340,6 +11341,7 @@ KEYWORD_inline <- 'inline' end_of_word KEYWORD_noalias <- 'noalias' end_of_word KEYWORD_nosuspend <- 'nosuspend' end_of_word KEYWORD_null <- 'null' end_of_word +KEYWORD_opaque <- 'opaque' end_of_word KEYWORD_or <- 'or' end_of_word KEYWORD_orelse <- 'orelse' end_of_word KEYWORD_packed <- 'packed' end_of_word @@ -11368,7 +11370,7 @@ keyword <- KEYWORD_align / KEYWORD_and / KEYWORD_anyframe / KEYWORD_anytype / KEYWORD_defer / KEYWORD_else / KEYWORD_enum / KEYWORD_errdefer / KEYWORD_error / KEYWORD_export / KEYWORD_extern / KEYWORD_false / KEYWORD_fn / KEYWORD_for / KEYWORD_if / KEYWORD_inline - / KEYWORD_noalias / KEYWORD_null / KEYWORD_or + / KEYWORD_noalias / KEYWORD_null / KEYWORD_opaque / KEYWORD_or / KEYWORD_orelse / KEYWORD_packed / KEYWORD_pub / KEYWORD_resume / KEYWORD_return / KEYWORD_linksection / KEYWORD_struct / KEYWORD_suspend diff --git a/lib/std/builtin.zig b/lib/std/builtin.zig index 68bbbe3b2d..8543461f33 100644 --- a/lib/std/builtin.zig +++ b/lib/std/builtin.zig @@ -151,7 +151,6 @@ pub const Mode = enum { pub const CallingConvention = enum { Unspecified, C, - Cold, Naked, Async, Interrupt, @@ -199,7 +198,7 @@ pub const TypeInfo = union(enum) { Union: Union, Fn: Fn, BoundFn: Fn, - Opaque: void, + Opaque: Opaque, Frame: Frame, AnyFrame: AnyFrame, Vector: Vector, @@ -360,6 +359,12 @@ pub const TypeInfo = union(enum) { args: []const FnArg, }; + /// This data structure is used by the Zig language code generation and + /// therefore must be kept in sync with the compiler implementation. + pub const Opaque = struct { + decls: []const Declaration, + }; + /// This data structure is used by the Zig language code generation and /// therefore must be kept in sync with the compiler implementation. pub const Frame = struct { diff --git a/lib/std/c.zig b/lib/std/c.zig index 7cfc44714f..a75fcaa84b 100644 --- a/lib/std/c.zig +++ b/lib/std/c.zig @@ -329,8 +329,8 @@ pub extern "c" fn pthread_cond_signal(cond: *pthread_cond_t) c_int; pub extern "c" fn pthread_cond_broadcast(cond: *pthread_cond_t) c_int; pub extern "c" fn pthread_cond_destroy(cond: *pthread_cond_t) c_int; -pub const pthread_t = *@Type(.Opaque); -pub const FILE = @Type(.Opaque); +pub const pthread_t = *opaque {}; +pub const FILE = opaque {}; pub extern "c" fn dlopen(path: [*:0]const u8, mode: c_int) ?*c_void; pub extern "c" fn dlclose(handle: *c_void) c_int; diff --git a/lib/std/crypto/aes.zig b/lib/std/crypto/aes.zig index 7c509b297f..9040524939 100644 --- a/lib/std/crypto/aes.zig +++ b/lib/std/crypto/aes.zig @@ -10,7 +10,15 @@ const builtin = std.builtin; const has_aesni = comptime std.Target.x86.featureSetHas(std.Target.current.cpu.features, .aes); const has_avx = comptime std.Target.x86.featureSetHas(std.Target.current.cpu.features, .avx); -const impl = if (std.Target.current.cpu.arch == .x86_64 and has_aesni and has_avx) @import("aes/aesni.zig") else @import("aes/soft.zig"); +const has_armaes = comptime std.Target.aarch64.featureSetHas(std.Target.current.cpu.features, .aes); +const impl = if (std.Target.current.cpu.arch == .x86_64 and has_aesni and has_avx) impl: { + break :impl @import("aes/aesni.zig"); +} else if (std.Target.current.cpu.arch == .aarch64 and has_armaes) +impl: { + break :impl @import("aes/armcrypto.zig"); +} else impl: { + break :impl @import("aes/soft.zig"); +}; pub const Block = impl.Block; pub const AESEncryptCtx = impl.AESEncryptCtx; diff --git a/lib/std/crypto/aes/aesni.zig b/lib/std/crypto/aes/aesni.zig index 47dd029bec..c1c077a988 100644 --- a/lib/std/crypto/aes/aesni.zig +++ b/lib/std/crypto/aes/aesni.zig @@ -3,7 +3,6 @@ // This file is part of [zig](https://ziglang.org/), which is MIT licensed. // The MIT license requires this copyright notice to be included in all copies // and substantial portions of the software. -// Based on Go stdlib implementation const std = @import("../../std.zig"); const mem = std.mem; diff --git a/lib/std/crypto/aes/armcrypto.zig b/lib/std/crypto/aes/armcrypto.zig new file mode 100644 index 0000000000..b1d8252c94 --- /dev/null +++ b/lib/std/crypto/aes/armcrypto.zig @@ -0,0 +1,490 @@ +// SPDX-License-Identifier: MIT +// Copyright (c) 2015-2020 Zig Contributors +// This file is part of [zig](https://ziglang.org/), which is MIT licensed. +// The MIT license requires this copyright notice to be included in all copies +// and substantial portions of the software. + +const std = @import("../../std.zig"); +const mem = std.mem; +const debug = std.debug; +const Vector = std.meta.Vector; + +const BlockVec = Vector(2, u64); + +/// A single AES block. +pub const Block = struct { + pub const block_size: usize = 16; + + /// Internal representation of a block. + repr: BlockVec, + + /// Convert a byte sequence into an internal representation. + pub inline fn fromBytes(bytes: *const [16]u8) Block { + const repr = mem.bytesToValue(BlockVec, bytes); + return Block{ .repr = repr }; + } + + /// Convert the internal representation of a block into a byte sequence. + pub inline fn toBytes(block: Block) [16]u8 { + return mem.toBytes(block.repr); + } + + /// XOR the block with a byte sequence. + pub inline fn xorBytes(block: Block, bytes: *const [16]u8) [16]u8 { + const x = block.repr ^ fromBytes(bytes).repr; + return mem.toBytes(x); + } + + const zero = Vector(2, u64){ 0, 0 }; + + /// Encrypt a block with a round key. + pub inline fn encrypt(block: Block, round_key: Block) Block { + return Block{ + .repr = asm ( + \\ mov %[out].16b, %[in].16b + \\ aese %[out].16b, %[zero].16b + \\ aesmc %[out].16b, %[out].16b + \\ eor %[out].16b, %[out].16b, %[rk].16b + : [out] "=&x" (-> BlockVec) + : [in] "x" (block.repr), + [rk] "x" (round_key.repr), + [zero] "x" (zero) + ), + }; + } + + /// Encrypt a block with the last round key. + pub inline fn encryptLast(block: Block, round_key: Block) Block { + return Block{ + .repr = asm ( + \\ mov %[out].16b, %[in].16b + \\ aese %[out].16b, %[zero].16b + \\ eor %[out].16b, %[out].16b, %[rk].16b + : [out] "=&x" (-> BlockVec) + : [in] "x" (block.repr), + [rk] "x" (round_key.repr), + [zero] "x" (zero) + ), + }; + } + + /// Decrypt a block with a round key. + pub inline fn decrypt(block: Block, inv_round_key: Block) Block { + return Block{ + .repr = asm ( + \\ mov %[out].16b, %[in].16b + \\ aesd %[out].16b, %[zero].16b + \\ aesimc %[out].16b, %[out].16b + \\ eor %[out].16b, %[out].16b, %[rk].16b + : [out] "=&x" (-> BlockVec) + : [in] "x" (block.repr), + [rk] "x" (inv_round_key.repr), + [zero] "x" (zero) + ), + }; + } + + /// Decrypt a block with the last round key. + pub inline fn decryptLast(block: Block, inv_round_key: Block) Block { + return Block{ + .repr = asm ( + \\ mov %[out].16b, %[in].16b + \\ aesd %[out].16b, %[zero].16b + \\ eor %[out].16b, %[out].16b, %[rk].16b + : [out] "=&x" (-> BlockVec) + : [in] "x" (block.repr), + [rk] "x" (inv_round_key.repr), + [zero] "x" (zero) + ), + }; + } + + /// Apply the bitwise XOR operation to the content of two blocks. + pub inline fn xorBlocks(block1: Block, block2: Block) Block { + return Block{ .repr = block1.repr ^ block2.repr }; + } + + /// Apply the bitwise AND operation to the content of two blocks. + pub inline fn andBlocks(block1: Block, block2: Block) Block { + return Block{ .repr = block1.repr & block2.repr }; + } + + /// Apply the bitwise OR operation to the content of two blocks. + pub inline fn orBlocks(block1: Block, block2: Block) Block { + return Block{ .repr = block1.repr | block2.repr }; + } + + /// Perform operations on multiple blocks in parallel. + pub const parallel = struct { + /// The recommended number of AES encryption/decryption to perform in parallel for the chosen implementation. + pub const optimal_parallel_blocks = 8; + + /// Encrypt multiple blocks in parallel, each their own round key. + pub inline fn encryptParallel(comptime count: usize, blocks: [count]Block, round_keys: [count]Block) [count]Block { + comptime var i = 0; + var out: [count]Block = undefined; + inline while (i < count) : (i += 1) { + out[i] = blocks[i].encrypt(round_keys[i]); + } + return out; + } + + /// Decrypt multiple blocks in parallel, each their own round key. + pub inline fn decryptParallel(comptime count: usize, blocks: [count]Block, round_keys: [count]Block) [count]Block { + comptime var i = 0; + var out: [count]Block = undefined; + inline while (i < count) : (i += 1) { + out[i] = blocks[i].decrypt(round_keys[i]); + } + return out; + } + + /// Encrypt multple blocks in parallel with the same round key. + pub inline fn encryptWide(comptime count: usize, blocks: [count]Block, round_key: Block) [count]Block { + comptime var i = 0; + var out: [count]Block = undefined; + inline while (i < count) : (i += 1) { + out[i] = blocks[i].encrypt(round_key); + } + return out; + } + + /// Decrypt multple blocks in parallel with the same round key. + pub inline fn decryptWide(comptime count: usize, blocks: [count]Block, round_key: Block) [count]Block { + comptime var i = 0; + var out: [count]Block = undefined; + inline while (i < count) : (i += 1) { + out[i] = blocks[i].decrypt(round_key); + } + return out; + } + + /// Encrypt multple blocks in parallel with the same last round key. + pub inline fn encryptLastWide(comptime count: usize, blocks: [count]Block, round_key: Block) [count]Block { + comptime var i = 0; + var out: [count]Block = undefined; + inline while (i < count) : (i += 1) { + out[i] = blocks[i].encryptLast(round_key); + } + return out; + } + + /// Decrypt multple blocks in parallel with the same last round key. + pub inline fn decryptLastWide(comptime count: usize, blocks: [count]Block, round_key: Block) [count]Block { + comptime var i = 0; + var out: [count]Block = undefined; + inline while (i < count) : (i += 1) { + out[i] = blocks[i].decryptLast(round_key); + } + return out; + } + }; +}; + +fn KeySchedule(comptime AES: type) type { + std.debug.assert(AES.rounds == 10 or AES.rounds == 14); + const rounds = AES.rounds; + + return struct { + const Self = @This(); + + const zero = Vector(2, u64){ 0, 0 }; + const mask1 = @Vector(16, u8){ 13, 14, 15, 12, 13, 14, 15, 12, 13, 14, 15, 12, 13, 14, 15, 12 }; + const mask2 = @Vector(16, u8){ 12, 13, 14, 15, 12, 13, 14, 15, 12, 13, 14, 15, 12, 13, 14, 15 }; + + round_keys: [rounds + 1]Block, + + fn drc128(comptime rc: u8, t: BlockVec) BlockVec { + var v1: BlockVec = undefined; + var v2: BlockVec = undefined; + var v3: BlockVec = undefined; + var v4: BlockVec = undefined; + + return asm ( + \\ movi %[v2].4s, %[rc] + \\ tbl %[v4].16b, {%[t].16b}, %[mask].16b + \\ ext %[r].16b, %[zero].16b, %[t].16b, #12 + \\ aese %[v4].16b, %[zero].16b + \\ eor %[v2].16b, %[r].16b, %[v2].16b + \\ ext %[r].16b, %[zero].16b, %[r].16b, #12 + \\ eor %[v1].16b, %[v2].16b, %[t].16b + \\ ext %[v3].16b, %[zero].16b, %[r].16b, #12 + \\ eor %[v1].16b, %[v1].16b, %[r].16b + \\ eor %[r].16b, %[v1].16b, %[v3].16b + \\ eor %[r].16b, %[r].16b, %[v4].16b + : [r] "=&x" (-> BlockVec), + [v1] "=&x" (v1), + [v2] "=&x" (v2), + [v3] "=&x" (v3), + [v4] "=&x" (v4) + : [rc] "N" (rc), + [t] "x" (t), + [zero] "x" (zero), + [mask] "x" (mask1) + ); + } + + fn drc256(comptime second: bool, comptime rc: u8, t: BlockVec, tx: BlockVec) BlockVec { + var v1: BlockVec = undefined; + var v2: BlockVec = undefined; + var v3: BlockVec = undefined; + var v4: BlockVec = undefined; + + return asm ( + \\ movi %[v2].4s, %[rc] + \\ tbl %[v4].16b, {%[t].16b}, %[mask].16b + \\ ext %[r].16b, %[zero].16b, %[tx].16b, #12 + \\ aese %[v4].16b, %[zero].16b + \\ eor %[v1].16b, %[tx].16b, %[r].16b + \\ ext %[r].16b, %[zero].16b, %[r].16b, #12 + \\ eor %[v1].16b, %[v1].16b, %[r].16b + \\ ext %[v3].16b, %[zero].16b, %[r].16b, #12 + \\ eor %[v1].16b, %[v1].16b, %[v2].16b + \\ eor %[v1].16b, %[v1].16b, %[v3].16b + \\ eor %[r].16b, %[v1].16b, %[v4].16b + : [r] "=&x" (-> BlockVec), + [v1] "=&x" (v1), + [v2] "=&x" (v2), + [v3] "=&x" (v3), + [v4] "=&x" (v4) + : [rc] "N" (if (second) @as(u8, 0) else rc), + [t] "x" (t), + [tx] "x" (tx), + [zero] "x" (zero), + [mask] "x" (if (second) mask2 else mask1) + ); + } + + fn expand128(t1: *Block) Self { + var round_keys: [11]Block = undefined; + const rcs = [_]u8{ 1, 2, 4, 8, 16, 32, 64, 128, 27, 54 }; + inline for (rcs) |rc, round| { + round_keys[round] = t1.*; + t1.repr = drc128(rc, t1.repr); + } + round_keys[rcs.len] = t1.*; + return Self{ .round_keys = round_keys }; + } + + fn expand256(t1: *Block, t2: *Block) Self { + var round_keys: [15]Block = undefined; + const rcs = [_]u8{ 1, 2, 4, 8, 16, 32 }; + round_keys[0] = t1.*; + inline for (rcs) |rc, round| { + round_keys[round * 2 + 1] = t2.*; + t1.repr = drc256(false, rc, t2.repr, t1.repr); + round_keys[round * 2 + 2] = t1.*; + t2.repr = drc256(true, rc, t1.repr, t2.repr); + } + round_keys[rcs.len * 2 + 1] = t2.*; + t1.repr = drc256(false, 64, t2.repr, t1.repr); + round_keys[rcs.len * 2 + 2] = t1.*; + return Self{ .round_keys = round_keys }; + } + + /// Invert the key schedule. + pub fn invert(key_schedule: Self) Self { + const round_keys = &key_schedule.round_keys; + var inv_round_keys: [rounds + 1]Block = undefined; + inv_round_keys[0] = round_keys[rounds]; + comptime var i = 1; + inline while (i < rounds) : (i += 1) { + inv_round_keys[i] = Block{ + .repr = asm ( + \\ aesimc %[inv_rk].16b, %[rk].16b + : [inv_rk] "=x" (-> BlockVec) + : [rk] "x" (round_keys[rounds - i].repr) + ), + }; + } + inv_round_keys[rounds] = round_keys[0]; + return Self{ .round_keys = inv_round_keys }; + } + }; +} + +/// A context to perform encryption using the standard AES key schedule. +pub fn AESEncryptCtx(comptime AES: type) type { + std.debug.assert(AES.key_bits == 128 or AES.key_bits == 256); + const rounds = AES.rounds; + + return struct { + const Self = @This(); + pub const block = AES.block; + pub const block_size = block.block_size; + key_schedule: KeySchedule(AES), + + /// Create a new encryption context with the given key. + pub fn init(key: [AES.key_bits / 8]u8) Self { + var t1 = Block.fromBytes(key[0..16]); + const key_schedule = if (AES.key_bits == 128) ks: { + break :ks KeySchedule(AES).expand128(&t1); + } else ks: { + var t2 = Block.fromBytes(key[16..32]); + break :ks KeySchedule(AES).expand256(&t1, &t2); + }; + return Self{ + .key_schedule = key_schedule, + }; + } + + /// Encrypt a single block. + pub fn encrypt(ctx: Self, dst: *[16]u8, src: *const [16]u8) void { + const round_keys = ctx.key_schedule.round_keys; + var t = Block.fromBytes(src).xorBlocks(round_keys[0]); + comptime var i = 1; + inline while (i < rounds) : (i += 1) { + t = t.encrypt(round_keys[i]); + } + t = t.encryptLast(round_keys[rounds]); + dst.* = t.toBytes(); + } + + /// Encrypt+XOR a single block. + pub fn xor(ctx: Self, dst: *[16]u8, src: *const [16]u8, counter: [16]u8) void { + const round_keys = ctx.key_schedule.round_keys; + var t = Block.fromBytes(&counter).xorBlocks(round_keys[0]); + comptime var i = 1; + inline while (i < rounds) : (i += 1) { + t = t.encrypt(round_keys[i]); + } + t = t.encryptLast(round_keys[rounds]); + dst.* = t.xorBytes(src); + } + + /// Encrypt multiple blocks, possibly leveraging parallelization. + pub fn encryptWide(ctx: Self, comptime count: usize, dst: *[16 * count]u8, src: *const [16 * count]u8) void { + const round_keys = ctx.key_schedule.round_keys; + var ts: [count]Block = undefined; + comptime var j = 0; + inline while (j < count) : (j += 1) { + ts[j] = Block.fromBytes(src[j * 16 .. j * 16 + 16][0..16]).xorBlocks(round_keys[0]); + } + comptime var i = 1; + inline while (i < rounds) : (i += 1) { + ts = Block.parallel.encryptWide(count, ts, round_keys[i]); + } + i = 1; + inline while (i < count) : (i += 1) { + ts = Block.parallel.encryptLastWide(count, ts, round_keys[i]); + } + j = 0; + inline while (j < count) : (j += 1) { + dst[16 * j .. 16 * j + 16].* = ts[j].toBytes(); + } + } + + /// Encrypt+XOR multiple blocks, possibly leveraging parallelization. + pub fn xorWide(ctx: Self, comptime count: usize, dst: *[16 * count]u8, src: *const [16 * count]u8, counters: [16 * count]u8) void { + const round_keys = ctx.key_schedule.round_keys; + var ts: [count]Block = undefined; + comptime var j = 0; + inline while (j < count) : (j += 1) { + ts[j] = Block.fromBytes(counters[j * 16 .. j * 16 + 16][0..16]).xorBlocks(round_keys[0]); + } + comptime var i = 1; + inline while (i < rounds) : (i += 1) { + ts = Block.parallel.encryptWide(count, ts, round_keys[i]); + } + ts = Block.parallel.encryptLastWide(count, ts, round_keys[i]); + j = 0; + inline while (j < count) : (j += 1) { + dst[16 * j .. 16 * j + 16].* = ts[j].xorBytes(src[16 * j .. 16 * j + 16]); + } + } + }; +} + +/// A context to perform decryption using the standard AES key schedule. +pub fn AESDecryptCtx(comptime AES: type) type { + std.debug.assert(AES.key_bits == 128 or AES.key_bits == 256); + const rounds = AES.rounds; + + return struct { + const Self = @This(); + pub const block = AES.block; + pub const block_size = block.block_size; + key_schedule: KeySchedule(AES), + + /// Create a decryption context from an existing encryption context. + pub fn initFromEnc(ctx: AESEncryptCtx(AES)) Self { + return Self{ + .key_schedule = ctx.key_schedule.invert(), + }; + } + + /// Create a new decryption context with the given key. + pub fn init(key: [AES.key_bits / 8]u8) Self { + const enc_ctx = AESEncryptCtx(AES).init(key); + return initFromEnc(enc_ctx); + } + + /// Decrypt a single block. + pub fn decrypt(ctx: Self, dst: *[16]u8, src: *const [16]u8) void { + const inv_round_keys = ctx.key_schedule.round_keys; + var t = Block.fromBytes(src).xorBlocks(inv_round_keys[0]); + comptime var i = 1; + inline while (i < rounds) : (i += 1) { + t = t.decrypt(inv_round_keys[i]); + } + t = t.decryptLast(inv_round_keys[rounds]); + dst.* = t.toBytes(); + } + + /// Decrypt multiple blocks, possibly leveraging parallelization. + pub fn decryptWide(ctx: Self, comptime count: usize, dst: *[16 * count]u8, src: *const [16 * count]u8) void { + const inv_round_keys = ctx.key_schedule.round_keys; + var ts: [count]Block = undefined; + comptime var j = 0; + inline while (j < count) : (j += 1) { + ts[j] = Block.fromBytes(src[j * 16 .. j * 16 + 16][0..16]).xorBlocks(inv_round_keys[0]); + } + comptime var i = 1; + inline while (i < rounds) : (i += 1) { + ts = Block.parallel.decryptWide(count, ts, inv_round_keys[i]); + } + i = 1; + inline while (i < count) : (i += 1) { + ts = Block.parallel.decryptLastWide(count, ts, inv_round_keys[i]); + } + j = 0; + inline while (j < count) : (j += 1) { + dst[16 * j .. 16 * j + 16].* = ts[j].toBytes(); + } + } + }; +} + +/// AES-128 with the standard key schedule. +pub const AES128 = struct { + pub const key_bits: usize = 128; + pub const rounds = ((key_bits - 64) / 32 + 8); + pub const block = Block; + + /// Create a new context for encryption. + pub fn initEnc(key: [key_bits / 8]u8) AESEncryptCtx(AES128) { + return AESEncryptCtx(AES128).init(key); + } + + /// Create a new context for decryption. + pub fn initDec(key: [key_bits / 8]u8) AESDecryptCtx(AES128) { + return AESDecryptCtx(AES128).init(key); + } +}; + +/// AES-256 with the standard key schedule. +pub const AES256 = struct { + pub const key_bits: usize = 256; + pub const rounds = ((key_bits - 64) / 32 + 8); + pub const block = Block; + + /// Create a new context for encryption. + pub fn initEnc(key: [key_bits / 8]u8) AESEncryptCtx(AES256) { + return AESEncryptCtx(AES256).init(key); + } + + /// Create a new context for decryption. + pub fn initDec(key: [key_bits / 8]u8) AESDecryptCtx(AES256) { + return AESDecryptCtx(AES256).init(key); + } +}; diff --git a/lib/std/crypto/ghash.zig b/lib/std/crypto/ghash.zig index 04bc6a8275..83446f280b 100644 --- a/lib/std/crypto/ghash.zig +++ b/lib/std/crypto/ghash.zig @@ -105,6 +105,17 @@ pub const Ghash = struct { return product[0]; } + inline fn clmul_pmull(x: u64, y: u64) u64 { + const Vector = std.meta.Vector; + const product = asm ( + \\ pmull %[out].1q, %[x].1d, %[y].1d + : [out] "=w" (-> Vector(2, u64)) + : [x] "w" (@bitCast(Vector(2, u64), @as(u128, x))), + [y] "w" (@bitCast(Vector(2, u64), @as(u128, y))) + ); + return product[0]; + } + fn clmul_soft(x: u64, y: u64) u64 { const x0 = x & 0x1111111111111111; const x1 = x & 0x2222222222222222; @@ -127,7 +138,14 @@ pub const Ghash = struct { const has_pclmul = comptime std.Target.x86.featureSetHas(std.Target.current.cpu.features, .pclmul); const has_avx = comptime std.Target.x86.featureSetHas(std.Target.current.cpu.features, .avx); - const clmul = if (std.Target.current.cpu.arch == .x86_64 and has_pclmul and has_avx) clmul_pclmul else clmul_soft; + const has_armaes = comptime std.Target.aarch64.featureSetHas(std.Target.current.cpu.features, .aes); + const clmul = if (std.Target.current.cpu.arch == .x86_64 and has_pclmul and has_avx) impl: { + break :impl clmul_pclmul; + } else if (std.Target.current.cpu.arch == .aarch64 and has_armaes) impl: { + break :impl clmul_pmull; + } else impl: { + break :impl clmul_soft; + }; fn blocks(st: *Ghash, msg: []const u8) void { assert(msg.len % 16 == 0); // GHASH blocks() expects full blocks diff --git a/lib/std/event.zig b/lib/std/event.zig index 42f3176a1b..eeee8be65b 100644 --- a/lib/std/event.zig +++ b/lib/std/event.zig @@ -12,6 +12,7 @@ pub const Locked = @import("event/locked.zig").Locked; pub const RwLock = @import("event/rwlock.zig").RwLock; pub const RwLocked = @import("event/rwlocked.zig").RwLocked; pub const Loop = @import("event/loop.zig").Loop; +pub const WaitGroup = @import("event/WaitGroup.zig").WaitGroup; test "import event tests" { _ = @import("event/channel.zig"); @@ -23,4 +24,5 @@ test "import event tests" { _ = @import("event/rwlock.zig"); _ = @import("event/rwlocked.zig"); _ = @import("event/loop.zig"); + _ = @import("event/wait_group.zig"); } diff --git a/lib/std/event/loop.zig b/lib/std/event/loop.zig index 226d5f1d52..a064f711e2 100644 --- a/lib/std/event/loop.zig +++ b/lib/std/event/loop.zig @@ -660,9 +660,11 @@ pub const Loop = struct { const Wrapper = struct { const Args = @TypeOf(args); fn run(func_args: Args, loop: *Loop, allocator: *mem.Allocator) void { + loop.beginOneEvent(); loop.yield(); const result = @call(.{}, func, func_args); suspend { + loop.finishOneEvent(); allocator.destroy(@frame()); } } diff --git a/lib/std/event/wait_group.zig b/lib/std/event/wait_group.zig new file mode 100644 index 0000000000..f0222e7644 --- /dev/null +++ b/lib/std/event/wait_group.zig @@ -0,0 +1,120 @@ +// SPDX-License-Identifier: MIT +// Copyright (c) 2015-2020 Zig Contributors +// This file is part of [zig](https://ziglang.org/), which is MIT licensed. +// The MIT license requires this copyright notice to be included in all copies +// and substantial portions of the software. +const std = @import("../std.zig"); +const builtin = @import("builtin"); +const Loop = std.event.Loop; + +/// A WaitGroup keeps track and waits for a group of async tasks to finish. +/// Call `begin` when creating new tasks, and have tasks call `finish` when done. +/// You can provide a count for both operations to perform them in bulk. +/// Call `wait` to suspend until all tasks are completed. +/// Multiple waiters are supported. +/// +/// WaitGroup is an instance of WaitGroupGeneric, which takes in a bitsize +/// for the internal counter. WaitGroup defaults to a `usize` counter. +/// It's also possible to define a max value for the counter so that +/// `begin` will return error.Overflow when the limit is reached, even +/// if the integer type has not has not overflowed. +/// By default `max_value` is set to std.math.maxInt(CounterType). +pub const WaitGroup = WaitGroupGeneric(std.meta.bitCount(usize)); + +pub fn WaitGroupGeneric(comptime counter_size: u16) type { + const CounterType = std.meta.Int(false, counter_size); + + const global_event_loop = Loop.instance orelse + @compileError("std.event.WaitGroup currently only works with event-based I/O"); + + return struct { + counter: CounterType = 0, + max_counter: CounterType = std.math.maxInt(CounterType), + mutex: std.Mutex = .{}, + waiters: ?*Waiter = null, + const Waiter = struct { + next: ?*Waiter, + tail: *Waiter, + node: Loop.NextTickNode, + }; + + const Self = @This(); + pub fn begin(self: *Self, count: CounterType) error{Overflow}!void { + const held = self.mutex.acquire(); + defer held.release(); + + const new_counter = try std.math.add(CounterType, self.counter, count); + if (new_counter > self.max_counter) return error.Overflow; + self.counter = new_counter; + } + + pub fn finish(self: *Self, count: CounterType) void { + var waiters = blk: { + const held = self.mutex.acquire(); + defer held.release(); + self.counter = std.math.sub(CounterType, self.counter, count) catch unreachable; + if (self.counter == 0) { + const temp = self.waiters; + self.waiters = null; + break :blk temp; + } + break :blk null; + }; + + // We don't need to hold the lock to reschedule any potential waiter. + while (waiters) |w| { + const temp_w = w; + waiters = w.next; + global_event_loop.onNextTick(&temp_w.node); + } + } + + pub fn wait(self: *Self) void { + const held = self.mutex.acquire(); + + if (self.counter == 0) { + held.release(); + return; + } + + var self_waiter: Waiter = undefined; + self_waiter.node.data = @frame(); + if (self.waiters) |head| { + head.tail.next = &self_waiter; + head.tail = &self_waiter; + } else { + self.waiters = &self_waiter; + self_waiter.tail = &self_waiter; + self_waiter.next = null; + } + suspend { + held.release(); + } + } + }; +} + +test "basic WaitGroup usage" { + if (!std.io.is_async) return error.SkipZigTest; + + // TODO https://github.com/ziglang/zig/issues/1908 + if (builtin.single_threaded) return error.SkipZigTest; + + // TODO https://github.com/ziglang/zig/issues/3251 + if (builtin.os.tag == .freebsd) return error.SkipZigTest; + + var initial_wg = WaitGroup{}; + var final_wg = WaitGroup{}; + + try initial_wg.begin(1); + try final_wg.begin(1); + var task_frame = async task(&initial_wg, &final_wg); + initial_wg.finish(1); + final_wg.wait(); + await task_frame; +} + +fn task(wg_i: *WaitGroup, wg_f: *WaitGroup) void { + wg_i.wait(); + wg_f.finish(1); +} diff --git a/lib/std/fmt.zig b/lib/std/fmt.zig index ab2cc1577d..ce90f67585 100644 --- a/lib/std/fmt.zig +++ b/lib/std/fmt.zig @@ -1181,13 +1181,16 @@ fn bufPrintIntToSlice(buf: []u8, value: anytype, base: u8, uppercase: bool, opti return buf[0..formatIntBuf(buf, value, base, uppercase, options)]; } -pub fn comptimePrint(comptime fmt: []const u8, args: anytype) *const [count(fmt, args)]u8 { - comptime var buf: [count(fmt, args)]u8 = undefined; +pub fn comptimePrint(comptime fmt: []const u8, args: anytype) *const [count(fmt, args):0]u8 { + comptime var buf: [count(fmt, args):0]u8 = undefined; _ = bufPrint(&buf, fmt, args) catch unreachable; + buf[buf.len] = 0; return &buf; } test "comptimePrint" { + @setEvalBranchQuota(2000); + std.testing.expectEqual(*const [3:0]u8, @TypeOf(comptime comptimePrint("{}", .{100}))); std.testing.expectEqualSlices(u8, "100", comptime comptimePrint("{}", .{100})); } diff --git a/lib/std/math.zig b/lib/std/math.zig index f05c967b2d..a1db1309c9 100644 --- a/lib/std/math.zig +++ b/lib/std/math.zig @@ -110,7 +110,12 @@ pub fn approxEq(comptime T: type, x: T, y: T, epsilon: T) bool { } pub fn doNotOptimizeAway(value: anytype) void { - mem.doNotOptimizeAway(value); + // TODO: use @declareSideEffect() when it is available. + // https://github.com/ziglang/zig/issues/6168 + const T = @TypeOf(value); + var x: T = undefined; + const p = @ptrCast(*volatile T, &x); + p.* = x; } pub fn raiseInvalid() void { @@ -1131,3 +1136,9 @@ test "compare between signed and unsigned" { testing.expect(!compare(@as(u8, 255), .eq, @as(i8, -1))); testing.expect(compare(@as(u8, 1), .eq, @as(u8, 1))); } + +test "math.comptime" { + comptime const v = sin(@as(f32, 1)) + ln(@as(f32, 5)); + testing.expect(v == sin(@as(f32, 1)) + ln(@as(f32, 5))); +} + diff --git a/lib/std/os/linux/bpf/kern.zig b/lib/std/os/linux/bpf/kern.zig index 3bd605301a..a2e9d36aa1 100644 --- a/lib/std/os/linux/bpf/kern.zig +++ b/lib/std/os/linux/bpf/kern.zig @@ -12,28 +12,28 @@ const in_bpf_program = switch (std.builtin.arch) { pub const helpers = if (in_bpf_program) @import("helpers.zig") else struct {}; -pub const BpfSock = @Type(.Opaque); -pub const BpfSockAddr = @Type(.Opaque); -pub const FibLookup = @Type(.Opaque); -pub const MapDef = @Type(.Opaque); -pub const PerfEventData = @Type(.Opaque); -pub const PerfEventValue = @Type(.Opaque); -pub const PidNsInfo = @Type(.Opaque); -pub const SeqFile = @Type(.Opaque); -pub const SkBuff = @Type(.Opaque); -pub const SkMsgMd = @Type(.Opaque); -pub const SkReusePortMd = @Type(.Opaque); -pub const Sock = @Type(.Opaque); -pub const SockAddr = @Type(.Opaque); -pub const SockOps = @Type(.Opaque); -pub const SockTuple = @Type(.Opaque); -pub const SpinLock = @Type(.Opaque); -pub const SysCtl = @Type(.Opaque); -pub const Tcp6Sock = @Type(.Opaque); -pub const TcpRequestSock = @Type(.Opaque); -pub const TcpSock = @Type(.Opaque); -pub const TcpTimewaitSock = @Type(.Opaque); -pub const TunnelKey = @Type(.Opaque); -pub const Udp6Sock = @Type(.Opaque); -pub const XdpMd = @Type(.Opaque); -pub const XfrmState = @Type(.Opaque); +pub const BpfSock = opaque {}; +pub const BpfSockAddr = opaque {}; +pub const FibLookup = opaque {}; +pub const MapDef = opaque {}; +pub const PerfEventData = opaque {}; +pub const PerfEventValue = opaque {}; +pub const PidNsInfo = opaque {}; +pub const SeqFile = opaque {}; +pub const SkBuff = opaque {}; +pub const SkMsgMd = opaque {}; +pub const SkReusePortMd = opaque {}; +pub const Sock = opaque {}; +pub const SockAddr = opaque {}; +pub const SockOps = opaque {}; +pub const SockTuple = opaque {}; +pub const SpinLock = opaque {}; +pub const SysCtl = opaque {}; +pub const Tcp6Sock = opaque {}; +pub const TcpRequestSock = opaque {}; +pub const TcpSock = opaque {}; +pub const TcpTimewaitSock = opaque {}; +pub const TunnelKey = opaque {}; +pub const Udp6Sock = opaque {}; +pub const XdpMd = opaque {}; +pub const XfrmState = opaque {}; diff --git a/lib/std/os/uefi.zig b/lib/std/os/uefi.zig index 0127033db2..ba1544105c 100644 --- a/lib/std/os/uefi.zig +++ b/lib/std/os/uefi.zig @@ -17,7 +17,7 @@ pub var handle: Handle = undefined; pub var system_table: *tables.SystemTable = undefined; /// A handle to an event structure. -pub const Event = *@Type(.Opaque); +pub const Event = *opaque {}; /// GUIDs must be align(8) pub const Guid = extern struct { @@ -51,7 +51,7 @@ pub const Guid = extern struct { }; /// An EFI Handle represents a collection of related interfaces. -pub const Handle = *@Type(.Opaque); +pub const Handle = *opaque {}; /// This structure represents time information. pub const Time = extern struct { @@ -108,4 +108,4 @@ pub const TimeCapabilities = extern struct { }; /// File Handle as specified in the EFI Shell Spec -pub const FileHandle = *@Type(.Opaque); +pub const FileHandle = *opaque {}; diff --git a/lib/std/os/uefi/protocols/hii.zig b/lib/std/os/uefi/protocols/hii.zig index 960402828e..ed7c40d6ac 100644 --- a/lib/std/os/uefi/protocols/hii.zig +++ b/lib/std/os/uefi/protocols/hii.zig @@ -6,7 +6,7 @@ const uefi = @import("std").os.uefi; const Guid = uefi.Guid; -pub const HIIHandle = *@Type(.Opaque); +pub const HIIHandle = *opaque {}; /// The header found at the start of each package. pub const HIIPackageHeader = packed struct { diff --git a/lib/std/os/windows/bits.zig b/lib/std/os/windows/bits.zig index d22f42d6e8..bf786d5c91 100644 --- a/lib/std/os/windows/bits.zig +++ b/lib/std/os/windows/bits.zig @@ -32,16 +32,16 @@ pub const UCHAR = u8; pub const FLOAT = f32; pub const HANDLE = *c_void; pub const HCRYPTPROV = ULONG_PTR; -pub const HBRUSH = *@Type(.Opaque); -pub const HCURSOR = *@Type(.Opaque); -pub const HICON = *@Type(.Opaque); -pub const HINSTANCE = *@Type(.Opaque); -pub const HMENU = *@Type(.Opaque); -pub const HMODULE = *@Type(.Opaque); -pub const HWND = *@Type(.Opaque); -pub const HDC = *@Type(.Opaque); -pub const HGLRC = *@Type(.Opaque); -pub const FARPROC = *@Type(.Opaque); +pub const HBRUSH = *opaque {}; +pub const HCURSOR = *opaque {}; +pub const HICON = *opaque {}; +pub const HINSTANCE = *opaque {}; +pub const HMENU = *opaque {}; +pub const HMODULE = *opaque {}; +pub const HWND = *opaque {}; +pub const HDC = *opaque {}; +pub const HGLRC = *opaque {}; +pub const FARPROC = *opaque {}; pub const INT = c_int; pub const LPBYTE = *BYTE; pub const LPCH = *CHAR; @@ -81,7 +81,7 @@ pub const WPARAM = usize; pub const LPARAM = ?*c_void; pub const LRESULT = ?*c_void; -pub const va_list = *@Type(.Opaque); +pub const va_list = *opaque {}; pub const TRUE = 1; pub const FALSE = 0; @@ -1175,10 +1175,10 @@ pub const UNICODE_STRING = extern struct { Buffer: [*]WCHAR, }; -const ACTIVATION_CONTEXT_DATA = @Type(.Opaque); -const ASSEMBLY_STORAGE_MAP = @Type(.Opaque); -const FLS_CALLBACK_INFO = @Type(.Opaque); -const RTL_BITMAP = @Type(.Opaque); +const ACTIVATION_CONTEXT_DATA = opaque {}; +const ASSEMBLY_STORAGE_MAP = opaque {}; +const FLS_CALLBACK_INFO = opaque {}; +const RTL_BITMAP = opaque {}; pub const PRTL_BITMAP = *RTL_BITMAP; const KAFFINITY = usize; diff --git a/lib/std/os/windows/ws2_32.zig b/lib/std/os/windows/ws2_32.zig index ac21b6ffc9..19bfc0d83e 100644 --- a/lib/std/os/windows/ws2_32.zig +++ b/lib/std/os/windows/ws2_32.zig @@ -5,7 +5,7 @@ // and substantial portions of the software. usingnamespace @import("bits.zig"); -pub const SOCKET = *@Type(.Opaque); +pub const SOCKET = *opaque {}; pub const INVALID_SOCKET = @intToPtr(SOCKET, ~@as(usize, 0)); pub const SOCKET_ERROR = -1; diff --git a/lib/std/zig/ast.zig b/lib/std/zig/ast.zig index d8943adde0..0973877aa8 100644 --- a/lib/std/zig/ast.zig +++ b/lib/std/zig/ast.zig @@ -288,7 +288,7 @@ pub const Error = union(enum) { pub const ExpectedVarDecl = SingleTokenError("Expected variable declaration, found '{}'"); pub const ExpectedFn = SingleTokenError("Expected function, found '{}'"); pub const ExpectedReturnType = SingleTokenError("Expected 'var' or return type expression, found '{}'"); - pub const ExpectedAggregateKw = SingleTokenError("Expected '" ++ Token.Id.Keyword_struct.symbol() ++ "', '" ++ Token.Id.Keyword_union.symbol() ++ "', or '" ++ Token.Id.Keyword_enum.symbol() ++ "', found '{}'"); + pub const ExpectedAggregateKw = SingleTokenError("Expected '" ++ Token.Id.Keyword_struct.symbol() ++ "', '" ++ Token.Id.Keyword_union.symbol() ++ "', '" ++ Token.Id.Keyword_enum.symbol() ++ "', or '" ++ Token.Id.Keyword_opaque.symbol() ++ "', found '{}'"); pub const ExpectedEqOrSemi = SingleTokenError("Expected '=' or ';', found '{}'"); pub const ExpectedSemiOrLBrace = SingleTokenError("Expected ';' or '{{', found '{}'"); pub const ExpectedSemiOrElse = SingleTokenError("Expected ';' or 'else', found '{}'"); diff --git a/lib/std/zig/parse.zig b/lib/std/zig/parse.zig index 2af2ee4a45..467b06a5ca 100644 --- a/lib/std/zig/parse.zig +++ b/lib/std/zig/parse.zig @@ -2896,11 +2896,12 @@ const Parser = struct { /// <- KEYWORD_struct /// / KEYWORD_enum (LPAREN Expr RPAREN)? /// / KEYWORD_union (LPAREN (KEYWORD_enum (LPAREN Expr RPAREN)? / Expr) RPAREN)? + /// / KEYWORD_opaque fn parseContainerDeclType(p: *Parser) !?ContainerDeclType { const kind_token = p.nextToken(); const init_arg_expr = switch (p.token_ids[kind_token]) { - .Keyword_struct => Node.ContainerDecl.InitArg{ .None = {} }, + .Keyword_struct, .Keyword_opaque => Node.ContainerDecl.InitArg{ .None = {} }, .Keyword_enum => blk: { if (p.eatToken(.LParen) != null) { const expr = try p.expectNode(parseExpr, .{ diff --git a/lib/std/zig/render.zig b/lib/std/zig/render.zig index 67afbb77d9..8c8a2fc50b 100644 --- a/lib/std/zig/render.zig +++ b/lib/std/zig/render.zig @@ -1492,7 +1492,19 @@ fn renderExpression( // TODO remove after 0.7.0 release if (mem.eql(u8, tree.tokenSlice(builtin_call.builtin_token), "@OpaqueType")) - return ais.writer().writeAll("@Type(.Opaque)"); + return ais.writer().writeAll("opaque {}"); + + // TODO remove after 0.7.0 release + { + const params = builtin_call.paramsConst(); + if (mem.eql(u8, tree.tokenSlice(builtin_call.builtin_token), "@Type") and + params.len == 1) + { + if (params[0].castTag(.EnumLiteral)) |enum_literal| + if (mem.eql(u8, tree.tokenSlice(enum_literal.name), "Opaque")) + return ais.writer().writeAll("opaque {}"); + } + } try renderToken(tree, ais, builtin_call.builtin_token, Space.None); // @name diff --git a/lib/std/zig/tokenizer.zig b/lib/std/zig/tokenizer.zig index e40483c022..c8f33dbfaa 100644 --- a/lib/std/zig/tokenizer.zig +++ b/lib/std/zig/tokenizer.zig @@ -47,6 +47,7 @@ pub const Token = struct { .{ "noinline", .Keyword_noinline }, .{ "nosuspend", .Keyword_nosuspend }, .{ "null", .Keyword_null }, + .{ "opaque", .Keyword_opaque }, .{ "or", .Keyword_or }, .{ "orelse", .Keyword_orelse }, .{ "packed", .Keyword_packed }, @@ -173,6 +174,7 @@ pub const Token = struct { Keyword_noinline, Keyword_nosuspend, Keyword_null, + Keyword_opaque, Keyword_or, Keyword_orelse, Keyword_packed, @@ -296,6 +298,7 @@ pub const Token = struct { .Keyword_noinline => "noinline", .Keyword_nosuspend => "nosuspend", .Keyword_null => "null", + .Keyword_opaque => "opaque", .Keyword_or => "or", .Keyword_orelse => "orelse", .Keyword_packed => "packed", diff --git a/src/clang.zig b/src/clang.zig index b1e444845c..162da5d53c 100644 --- a/src/clang.zig +++ b/src/clang.zig @@ -1,91 +1,901 @@ -const builtin = @import("builtin"); +pub const builtin = @import("builtin"); -pub const struct_ZigClangConditionalOperator = @Type(.Opaque); -pub const struct_ZigClangBinaryConditionalOperator = @Type(.Opaque); -pub const struct_ZigClangAbstractConditionalOperator = @Type(.Opaque); -pub const struct_ZigClangAPInt = @Type(.Opaque); -pub const struct_ZigClangAPSInt = @Type(.Opaque); -pub const struct_ZigClangAPFloat = @Type(.Opaque); -pub const struct_ZigClangASTContext = @Type(.Opaque); -pub const struct_ZigClangASTUnit = @Type(.Opaque); -pub const struct_ZigClangArraySubscriptExpr = @Type(.Opaque); -pub const struct_ZigClangArrayType = @Type(.Opaque); -pub const struct_ZigClangAttributedType = @Type(.Opaque); -pub const struct_ZigClangBinaryOperator = @Type(.Opaque); -pub const struct_ZigClangBreakStmt = @Type(.Opaque); -pub const struct_ZigClangBuiltinType = @Type(.Opaque); -pub const struct_ZigClangCStyleCastExpr = @Type(.Opaque); -pub const struct_ZigClangCallExpr = @Type(.Opaque); -pub const struct_ZigClangCaseStmt = @Type(.Opaque); -pub const struct_ZigClangCompoundAssignOperator = @Type(.Opaque); -pub const struct_ZigClangCompoundStmt = @Type(.Opaque); -pub const struct_ZigClangConstantArrayType = @Type(.Opaque); -pub const struct_ZigClangContinueStmt = @Type(.Opaque); -pub const struct_ZigClangDecayedType = @Type(.Opaque); -pub const ZigClangDecl = @Type(.Opaque); -pub const struct_ZigClangDeclRefExpr = @Type(.Opaque); -pub const struct_ZigClangDeclStmt = @Type(.Opaque); -pub const struct_ZigClangDefaultStmt = @Type(.Opaque); -pub const struct_ZigClangDiagnosticOptions = @Type(.Opaque); -pub const struct_ZigClangDiagnosticsEngine = @Type(.Opaque); -pub const struct_ZigClangDoStmt = @Type(.Opaque); -pub const struct_ZigClangElaboratedType = @Type(.Opaque); -pub const struct_ZigClangEnumConstantDecl = @Type(.Opaque); -pub const struct_ZigClangEnumDecl = @Type(.Opaque); -pub const struct_ZigClangEnumType = @Type(.Opaque); -pub const struct_ZigClangExpr = @Type(.Opaque); -pub const struct_ZigClangFieldDecl = @Type(.Opaque); -pub const struct_ZigClangFileID = @Type(.Opaque); -pub const struct_ZigClangForStmt = @Type(.Opaque); -pub const struct_ZigClangFullSourceLoc = @Type(.Opaque); -pub const struct_ZigClangFunctionDecl = @Type(.Opaque); -pub const struct_ZigClangFunctionProtoType = @Type(.Opaque); -pub const struct_ZigClangIfStmt = @Type(.Opaque); -pub const struct_ZigClangImplicitCastExpr = @Type(.Opaque); -pub const struct_ZigClangIncompleteArrayType = @Type(.Opaque); -pub const struct_ZigClangIntegerLiteral = @Type(.Opaque); -pub const struct_ZigClangMacroDefinitionRecord = @Type(.Opaque); -pub const struct_ZigClangMacroExpansion = @Type(.Opaque); -pub const struct_ZigClangMacroQualifiedType = @Type(.Opaque); -pub const struct_ZigClangMemberExpr = @Type(.Opaque); -pub const struct_ZigClangNamedDecl = @Type(.Opaque); -pub const struct_ZigClangNone = @Type(.Opaque); -pub const struct_ZigClangOpaqueValueExpr = @Type(.Opaque); -pub const struct_ZigClangPCHContainerOperations = @Type(.Opaque); -pub const struct_ZigClangParenExpr = @Type(.Opaque); -pub const struct_ZigClangParenType = @Type(.Opaque); -pub const struct_ZigClangParmVarDecl = @Type(.Opaque); -pub const struct_ZigClangPointerType = @Type(.Opaque); -pub const struct_ZigClangPreprocessedEntity = @Type(.Opaque); -pub const struct_ZigClangRecordDecl = @Type(.Opaque); -pub const struct_ZigClangRecordType = @Type(.Opaque); -pub const struct_ZigClangReturnStmt = @Type(.Opaque); -pub const struct_ZigClangSkipFunctionBodiesScope = @Type(.Opaque); -pub const struct_ZigClangSourceManager = @Type(.Opaque); -pub const struct_ZigClangSourceRange = @Type(.Opaque); -pub const ZigClangStmt = @Type(.Opaque); -pub const struct_ZigClangStringLiteral = @Type(.Opaque); -pub const struct_ZigClangStringRef = @Type(.Opaque); -pub const struct_ZigClangSwitchStmt = @Type(.Opaque); -pub const struct_ZigClangTagDecl = @Type(.Opaque); -pub const struct_ZigClangType = @Type(.Opaque); -pub const struct_ZigClangTypedefNameDecl = @Type(.Opaque); -pub const struct_ZigClangTypedefType = @Type(.Opaque); -pub const struct_ZigClangUnaryExprOrTypeTraitExpr = @Type(.Opaque); -pub const struct_ZigClangUnaryOperator = @Type(.Opaque); -pub const struct_ZigClangValueDecl = @Type(.Opaque); -pub const struct_ZigClangVarDecl = @Type(.Opaque); -pub const struct_ZigClangWhileStmt = @Type(.Opaque); -pub const struct_ZigClangFunctionType = @Type(.Opaque); -pub const struct_ZigClangPredefinedExpr = @Type(.Opaque); -pub const struct_ZigClangInitListExpr = @Type(.Opaque); -pub const ZigClangPreprocessingRecord = @Type(.Opaque); -pub const ZigClangFloatingLiteral = @Type(.Opaque); -pub const ZigClangConstantExpr = @Type(.Opaque); -pub const ZigClangCharacterLiteral = @Type(.Opaque); -pub const ZigClangStmtExpr = @Type(.Opaque); +pub const SourceLocation = extern struct { + ID: c_uint, -pub const ZigClangBO = extern enum { + pub const eq = ZigClangSourceLocation_eq; + extern fn ZigClangSourceLocation_eq(a: SourceLocation, b: SourceLocation) bool; +}; + +pub const QualType = extern struct { + ptr: ?*c_void, + + pub const getCanonicalType = ZigClangQualType_getCanonicalType; + extern fn ZigClangQualType_getCanonicalType(QualType) QualType; + + pub const getTypePtr = ZigClangQualType_getTypePtr; + extern fn ZigClangQualType_getTypePtr(QualType) *const Type; + + pub const getTypeClass = ZigClangQualType_getTypeClass; + extern fn ZigClangQualType_getTypeClass(QualType) TypeClass; + + pub const addConst = ZigClangQualType_addConst; + extern fn ZigClangQualType_addConst(*QualType) void; + + pub const eq = ZigClangQualType_eq; + extern fn ZigClangQualType_eq(QualType, arg1: QualType) bool; + + pub const isConstQualified = ZigClangQualType_isConstQualified; + extern fn ZigClangQualType_isConstQualified(QualType) bool; + + pub const isVolatileQualified = ZigClangQualType_isVolatileQualified; + extern fn ZigClangQualType_isVolatileQualified(QualType) bool; + + pub const isRestrictQualified = ZigClangQualType_isRestrictQualified; + extern fn ZigClangQualType_isRestrictQualified(QualType) bool; +}; + +pub const APValueLValueBase = extern struct { + Ptr: ?*c_void, + CallIndex: c_uint, + Version: c_uint, + + pub const dyn_cast_Expr = ZigClangAPValueLValueBase_dyn_cast_Expr; + extern fn ZigClangAPValueLValueBase_dyn_cast_Expr(APValueLValueBase) ?*const Expr; +}; + +pub const APValueKind = extern enum { + None, + Indeterminate, + Int, + Float, + FixedPoint, + ComplexInt, + ComplexFloat, + LValue, + Vector, + Array, + Struct, + Union, + MemberPointer, + AddrLabelDiff, +}; + +pub const APValue = extern struct { + Kind: APValueKind, + Data: if (builtin.os.tag == .windows and builtin.abi == .msvc) [52]u8 else [68]u8, + + pub const getKind = ZigClangAPValue_getKind; + extern fn ZigClangAPValue_getKind(*const APValue) APValueKind; + + pub const getInt = ZigClangAPValue_getInt; + extern fn ZigClangAPValue_getInt(*const APValue) *const APSInt; + + pub const getArrayInitializedElts = ZigClangAPValue_getArrayInitializedElts; + extern fn ZigClangAPValue_getArrayInitializedElts(*const APValue) c_uint; + + pub const getArraySize = ZigClangAPValue_getArraySize; + extern fn ZigClangAPValue_getArraySize(*const APValue) c_uint; + + pub const getLValueBase = ZigClangAPValue_getLValueBase; + extern fn ZigClangAPValue_getLValueBase(*const APValue) APValueLValueBase; +}; + +pub const ExprEvalResult = extern struct { + HasSideEffects: bool, + HasUndefinedBehavior: bool, + SmallVectorImpl: ?*c_void, + Val: APValue, +}; + +pub const AbstractConditionalOperator = opaque { + pub const getCond = ZigClangAbstractConditionalOperator_getCond; + extern fn ZigClangAbstractConditionalOperator_getCond(*const AbstractConditionalOperator) *const Expr; + + pub const getTrueExpr = ZigClangAbstractConditionalOperator_getTrueExpr; + extern fn ZigClangAbstractConditionalOperator_getTrueExpr(*const AbstractConditionalOperator) *const Expr; + + pub const getFalseExpr = ZigClangAbstractConditionalOperator_getFalseExpr; + extern fn ZigClangAbstractConditionalOperator_getFalseExpr(*const AbstractConditionalOperator) *const Expr; +}; + +pub const APFloat = opaque { + pub const toString = ZigClangAPFloat_toString; + extern fn ZigClangAPFloat_toString(*const APFloat, precision: c_uint, maxPadding: c_uint, truncateZero: bool) [*:0]const u8; +}; + +pub const APInt = opaque { + pub const getLimitedValue = ZigClangAPInt_getLimitedValue; + extern fn ZigClangAPInt_getLimitedValue(*const APInt, limit: u64) u64; +}; + +pub const APSInt = opaque { + pub const isSigned = ZigClangAPSInt_isSigned; + extern fn ZigClangAPSInt_isSigned(*const APSInt) bool; + + pub const isNegative = ZigClangAPSInt_isNegative; + extern fn ZigClangAPSInt_isNegative(*const APSInt) bool; + + pub const negate = ZigClangAPSInt_negate; + extern fn ZigClangAPSInt_negate(*const APSInt) *const APSInt; + + pub const free = ZigClangAPSInt_free; + extern fn ZigClangAPSInt_free(*const APSInt) void; + + pub const getRawData = ZigClangAPSInt_getRawData; + extern fn ZigClangAPSInt_getRawData(*const APSInt) [*:0]const u64; + + pub const getNumWords = ZigClangAPSInt_getNumWords; + extern fn ZigClangAPSInt_getNumWords(*const APSInt) c_uint; +}; + +pub const ASTContext = opaque { + pub const getPointerType = ZigClangASTContext_getPointerType; + extern fn ZigClangASTContext_getPointerType(*const ASTContext, T: QualType) QualType; +}; + +pub const ASTUnit = opaque { + pub const delete = ZigClangASTUnit_delete; + extern fn ZigClangASTUnit_delete(*ASTUnit) void; + + pub const getASTContext = ZigClangASTUnit_getASTContext; + extern fn ZigClangASTUnit_getASTContext(*ASTUnit) *ASTContext; + + pub const getSourceManager = ZigClangASTUnit_getSourceManager; + extern fn ZigClangASTUnit_getSourceManager(*ASTUnit) *SourceManager; + + pub const visitLocalTopLevelDecls = ZigClangASTUnit_visitLocalTopLevelDecls; + extern fn ZigClangASTUnit_visitLocalTopLevelDecls(*ASTUnit, context: ?*c_void, Fn: ?fn (?*c_void, *const Decl) callconv(.C) bool) bool; + + pub const getLocalPreprocessingEntities_begin = ZigClangASTUnit_getLocalPreprocessingEntities_begin; + extern fn ZigClangASTUnit_getLocalPreprocessingEntities_begin(*ASTUnit) PreprocessingRecord.iterator; + + pub const getLocalPreprocessingEntities_end = ZigClangASTUnit_getLocalPreprocessingEntities_end; + extern fn ZigClangASTUnit_getLocalPreprocessingEntities_end(*ASTUnit) PreprocessingRecord.iterator; +}; + +pub const ArraySubscriptExpr = opaque { + pub const getBase = ZigClangArraySubscriptExpr_getBase; + extern fn ZigClangArraySubscriptExpr_getBase(*const ArraySubscriptExpr) *const Expr; + + pub const getIdx = ZigClangArraySubscriptExpr_getIdx; + extern fn ZigClangArraySubscriptExpr_getIdx(*const ArraySubscriptExpr) *const Expr; +}; + +pub const ArrayType = opaque { + pub const getElementType = ZigClangArrayType_getElementType; + extern fn ZigClangArrayType_getElementType(*const ArrayType) QualType; +}; + +pub const AttributedType = opaque { + pub const getEquivalentType = ZigClangAttributedType_getEquivalentType; + extern fn ZigClangAttributedType_getEquivalentType(*const AttributedType) QualType; +}; + +pub const BinaryOperator = opaque { + pub const getOpcode = ZigClangBinaryOperator_getOpcode; + extern fn ZigClangBinaryOperator_getOpcode(*const BinaryOperator) BO; + + pub const getBeginLoc = ZigClangBinaryOperator_getBeginLoc; + extern fn ZigClangBinaryOperator_getBeginLoc(*const BinaryOperator) SourceLocation; + + pub const getLHS = ZigClangBinaryOperator_getLHS; + extern fn ZigClangBinaryOperator_getLHS(*const BinaryOperator) *const Expr; + + pub const getRHS = ZigClangBinaryOperator_getRHS; + extern fn ZigClangBinaryOperator_getRHS(*const BinaryOperator) *const Expr; + + pub const getType = ZigClangBinaryOperator_getType; + extern fn ZigClangBinaryOperator_getType(*const BinaryOperator) QualType; +}; + +pub const BinaryConditionalOperator = opaque {}; + +pub const BreakStmt = opaque {}; + +pub const BuiltinType = opaque { + pub const getKind = ZigClangBuiltinType_getKind; + extern fn ZigClangBuiltinType_getKind(*const BuiltinType) BuiltinTypeKind; +}; + +pub const CStyleCastExpr = opaque { + pub const getBeginLoc = ZigClangCStyleCastExpr_getBeginLoc; + extern fn ZigClangCStyleCastExpr_getBeginLoc(*const CStyleCastExpr) SourceLocation; + + pub const getSubExpr = ZigClangCStyleCastExpr_getSubExpr; + extern fn ZigClangCStyleCastExpr_getSubExpr(*const CStyleCastExpr) *const Expr; + + pub const getType = ZigClangCStyleCastExpr_getType; + extern fn ZigClangCStyleCastExpr_getType(*const CStyleCastExpr) QualType; +}; + +pub const CallExpr = opaque { + pub const getCallee = ZigClangCallExpr_getCallee; + extern fn ZigClangCallExpr_getCallee(*const CallExpr) *const Expr; + + pub const getNumArgs = ZigClangCallExpr_getNumArgs; + extern fn ZigClangCallExpr_getNumArgs(*const CallExpr) c_uint; + + pub const getArgs = ZigClangCallExpr_getArgs; + extern fn ZigClangCallExpr_getArgs(*const CallExpr) [*]const *const Expr; +}; + +pub const CaseStmt = opaque { + pub const getLHS = ZigClangCaseStmt_getLHS; + extern fn ZigClangCaseStmt_getLHS(*const CaseStmt) *const Expr; + + pub const getRHS = ZigClangCaseStmt_getRHS; + extern fn ZigClangCaseStmt_getRHS(*const CaseStmt) ?*const Expr; + + pub const getBeginLoc = ZigClangCaseStmt_getBeginLoc; + extern fn ZigClangCaseStmt_getBeginLoc(*const CaseStmt) SourceLocation; + + pub const getSubStmt = ZigClangCaseStmt_getSubStmt; + extern fn ZigClangCaseStmt_getSubStmt(*const CaseStmt) *const Stmt; +}; + +pub const CharacterLiteral = opaque { + pub const getBeginLoc = ZigClangCharacterLiteral_getBeginLoc; + extern fn ZigClangCharacterLiteral_getBeginLoc(*const CharacterLiteral) SourceLocation; + + pub const getKind = ZigClangCharacterLiteral_getKind; + extern fn ZigClangCharacterLiteral_getKind(*const CharacterLiteral) CharacterLiteral_CharacterKind; + + pub const getValue = ZigClangCharacterLiteral_getValue; + extern fn ZigClangCharacterLiteral_getValue(*const CharacterLiteral) c_uint; +}; + +pub const CompoundAssignOperator = opaque { + pub const getType = ZigClangCompoundAssignOperator_getType; + extern fn ZigClangCompoundAssignOperator_getType(*const CompoundAssignOperator) QualType; + + pub const getComputationLHSType = ZigClangCompoundAssignOperator_getComputationLHSType; + extern fn ZigClangCompoundAssignOperator_getComputationLHSType(*const CompoundAssignOperator) QualType; + + pub const getComputationResultType = ZigClangCompoundAssignOperator_getComputationResultType; + extern fn ZigClangCompoundAssignOperator_getComputationResultType(*const CompoundAssignOperator) QualType; + + pub const getBeginLoc = ZigClangCompoundAssignOperator_getBeginLoc; + extern fn ZigClangCompoundAssignOperator_getBeginLoc(*const CompoundAssignOperator) SourceLocation; + + pub const getOpcode = ZigClangCompoundAssignOperator_getOpcode; + extern fn ZigClangCompoundAssignOperator_getOpcode(*const CompoundAssignOperator) BO; + + pub const getLHS = ZigClangCompoundAssignOperator_getLHS; + extern fn ZigClangCompoundAssignOperator_getLHS(*const CompoundAssignOperator) *const Expr; + + pub const getRHS = ZigClangCompoundAssignOperator_getRHS; + extern fn ZigClangCompoundAssignOperator_getRHS(*const CompoundAssignOperator) *const Expr; +}; + +pub const CompoundStmt = opaque { + pub const body_begin = ZigClangCompoundStmt_body_begin; + extern fn ZigClangCompoundStmt_body_begin(*const CompoundStmt) const_body_iterator; + + pub const body_end = ZigClangCompoundStmt_body_end; + extern fn ZigClangCompoundStmt_body_end(*const CompoundStmt) const_body_iterator; + + pub const const_body_iterator = [*]const *Stmt; +}; + +pub const ConditionalOperator = opaque {}; + +pub const ConstantArrayType = opaque { + pub const getElementType = ZigClangConstantArrayType_getElementType; + extern fn ZigClangConstantArrayType_getElementType(*const ConstantArrayType) QualType; + + pub const getSize = ZigClangConstantArrayType_getSize; + extern fn ZigClangConstantArrayType_getSize(*const ConstantArrayType) *const APInt; +}; + +pub const ConstantExpr = opaque {}; + +pub const ContinueStmt = opaque {}; + +pub const DecayedType = opaque { + pub const getDecayedType = ZigClangDecayedType_getDecayedType; + extern fn ZigClangDecayedType_getDecayedType(*const DecayedType) QualType; +}; + +pub const Decl = opaque { + pub const getLocation = ZigClangDecl_getLocation; + extern fn ZigClangDecl_getLocation(*const Decl) SourceLocation; + + pub const castToNamedDecl = ZigClangDecl_castToNamedDecl; + extern fn ZigClangDecl_castToNamedDecl(decl: *const Decl) ?*const NamedDecl; + + pub const getKind = ZigClangDecl_getKind; + extern fn ZigClangDecl_getKind(decl: *const Decl) DeclKind; + + pub const getDeclKindName = ZigClangDecl_getDeclKindName; + extern fn ZigClangDecl_getDeclKindName(decl: *const Decl) [*:0]const u8; +}; + +pub const DeclRefExpr = opaque { + pub const getDecl = ZigClangDeclRefExpr_getDecl; + extern fn ZigClangDeclRefExpr_getDecl(*const DeclRefExpr) *const ValueDecl; + + pub const getFoundDecl = ZigClangDeclRefExpr_getFoundDecl; + extern fn ZigClangDeclRefExpr_getFoundDecl(*const DeclRefExpr) *const NamedDecl; +}; + +pub const DeclStmt = opaque { + pub const decl_begin = ZigClangDeclStmt_decl_begin; + extern fn ZigClangDeclStmt_decl_begin(*const DeclStmt) const_decl_iterator; + + pub const decl_end = ZigClangDeclStmt_decl_end; + extern fn ZigClangDeclStmt_decl_end(*const DeclStmt) const_decl_iterator; + + pub const const_decl_iterator = [*]const *Decl; +}; + +pub const DefaultStmt = opaque { + pub const getSubStmt = ZigClangDefaultStmt_getSubStmt; + extern fn ZigClangDefaultStmt_getSubStmt(*const DefaultStmt) *const Stmt; +}; + +pub const DiagnosticOptions = opaque {}; + +pub const DiagnosticsEngine = opaque {}; + +pub const DoStmt = opaque { + pub const getCond = ZigClangDoStmt_getCond; + extern fn ZigClangDoStmt_getCond(*const DoStmt) *const Expr; + + pub const getBody = ZigClangDoStmt_getBody; + extern fn ZigClangDoStmt_getBody(*const DoStmt) *const Stmt; +}; + +pub const ElaboratedType = opaque { + pub const getNamedType = ZigClangElaboratedType_getNamedType; + extern fn ZigClangElaboratedType_getNamedType(*const ElaboratedType) QualType; +}; + +pub const EnumConstantDecl = opaque { + pub const getInitExpr = ZigClangEnumConstantDecl_getInitExpr; + extern fn ZigClangEnumConstantDecl_getInitExpr(*const EnumConstantDecl) ?*const Expr; + + pub const getInitVal = ZigClangEnumConstantDecl_getInitVal; + extern fn ZigClangEnumConstantDecl_getInitVal(*const EnumConstantDecl) *const APSInt; +}; + +pub const EnumDecl = opaque { + pub const getCanonicalDecl = ZigClangEnumDecl_getCanonicalDecl; + extern fn ZigClangEnumDecl_getCanonicalDecl(*const EnumDecl) ?*const TagDecl; + + pub const getIntegerType = ZigClangEnumDecl_getIntegerType; + extern fn ZigClangEnumDecl_getIntegerType(*const EnumDecl) QualType; + + pub const getDefinition = ZigClangEnumDecl_getDefinition; + extern fn ZigClangEnumDecl_getDefinition(*const EnumDecl) ?*const EnumDecl; + + pub const getLocation = ZigClangEnumDecl_getLocation; + extern fn ZigClangEnumDecl_getLocation(*const EnumDecl) SourceLocation; + + pub const enumerator_begin = ZigClangEnumDecl_enumerator_begin; + extern fn ZigClangEnumDecl_enumerator_begin(*const EnumDecl) enumerator_iterator; + + pub const enumerator_end = ZigClangEnumDecl_enumerator_end; + extern fn ZigClangEnumDecl_enumerator_end(*const EnumDecl) enumerator_iterator; + + pub const enumerator_iterator = extern struct { + ptr: *c_void, + + pub const next = ZigClangEnumDecl_enumerator_iterator_next; + extern fn ZigClangEnumDecl_enumerator_iterator_next(enumerator_iterator) enumerator_iterator; + + pub const deref = ZigClangEnumDecl_enumerator_iterator_deref; + extern fn ZigClangEnumDecl_enumerator_iterator_deref(enumerator_iterator) *const EnumConstantDecl; + + pub const neq = ZigClangEnumDecl_enumerator_iterator_neq; + extern fn ZigClangEnumDecl_enumerator_iterator_neq(enumerator_iterator, enumerator_iterator) bool; + }; +}; + +pub const EnumType = opaque { + pub const getDecl = ZigClangEnumType_getDecl; + extern fn ZigClangEnumType_getDecl(*const EnumType) *const EnumDecl; +}; + +pub const Expr = opaque { + pub const getStmtClass = ZigClangExpr_getStmtClass; + extern fn ZigClangExpr_getStmtClass(*const Expr) StmtClass; + + pub const getType = ZigClangExpr_getType; + extern fn ZigClangExpr_getType(*const Expr) QualType; + + pub const getBeginLoc = ZigClangExpr_getBeginLoc; + extern fn ZigClangExpr_getBeginLoc(*const Expr) SourceLocation; + + pub const EvaluateAsConstantExpr = ZigClangExpr_EvaluateAsConstantExpr; + extern fn ZigClangExpr_EvaluateAsConstantExpr(*const Expr, *ExprEvalResult, Expr_ConstExprUsage, *const ASTContext) bool; +}; + +pub const FieldDecl = opaque { + pub const getCanonicalDecl = ZigClangFieldDecl_getCanonicalDecl; + extern fn ZigClangFieldDecl_getCanonicalDecl(*const FieldDecl) ?*const FieldDecl; + + pub const getAlignedAttribute = ZigClangFieldDecl_getAlignedAttribute; + extern fn ZigClangFieldDecl_getAlignedAttribute(*const FieldDecl, *const ASTContext) c_uint; + + pub const isAnonymousStructOrUnion = ZigClangFieldDecl_isAnonymousStructOrUnion; + extern fn ZigClangFieldDecl_isAnonymousStructOrUnion(*const FieldDecl) bool; + + pub const isBitField = ZigClangFieldDecl_isBitField; + extern fn ZigClangFieldDecl_isBitField(*const FieldDecl) bool; + + pub const getType = ZigClangFieldDecl_getType; + extern fn ZigClangFieldDecl_getType(*const FieldDecl) QualType; + + pub const getLocation = ZigClangFieldDecl_getLocation; + extern fn ZigClangFieldDecl_getLocation(*const FieldDecl) SourceLocation; +}; + +pub const FileID = opaque {}; + +pub const FloatingLiteral = opaque { + pub const getValueAsApproximateDouble = ZigClangAPFloat_getValueAsApproximateDouble; + extern fn ZigClangAPFloat_getValueAsApproximateDouble(*const FloatingLiteral) f64; +}; + +pub const ForStmt = opaque { + pub const getInit = ZigClangForStmt_getInit; + extern fn ZigClangForStmt_getInit(*const ForStmt) ?*const Stmt; + + pub const getCond = ZigClangForStmt_getCond; + extern fn ZigClangForStmt_getCond(*const ForStmt) ?*const Expr; + + pub const getInc = ZigClangForStmt_getInc; + extern fn ZigClangForStmt_getInc(*const ForStmt) ?*const Expr; + + pub const getBody = ZigClangForStmt_getBody; + extern fn ZigClangForStmt_getBody(*const ForStmt) *const Stmt; +}; + +pub const FullSourceLoc = opaque {}; + +pub const FunctionDecl = opaque { + pub const getType = ZigClangFunctionDecl_getType; + extern fn ZigClangFunctionDecl_getType(*const FunctionDecl) QualType; + + pub const getLocation = ZigClangFunctionDecl_getLocation; + extern fn ZigClangFunctionDecl_getLocation(*const FunctionDecl) SourceLocation; + + pub const hasBody = ZigClangFunctionDecl_hasBody; + extern fn ZigClangFunctionDecl_hasBody(*const FunctionDecl) bool; + + pub const getStorageClass = ZigClangFunctionDecl_getStorageClass; + extern fn ZigClangFunctionDecl_getStorageClass(*const FunctionDecl) StorageClass; + + pub const getParamDecl = ZigClangFunctionDecl_getParamDecl; + extern fn ZigClangFunctionDecl_getParamDecl(*const FunctionDecl, i: c_uint) *const ParmVarDecl; + + pub const getBody = ZigClangFunctionDecl_getBody; + extern fn ZigClangFunctionDecl_getBody(*const FunctionDecl) *const Stmt; + + pub const doesDeclarationForceExternallyVisibleDefinition = ZigClangFunctionDecl_doesDeclarationForceExternallyVisibleDefinition; + extern fn ZigClangFunctionDecl_doesDeclarationForceExternallyVisibleDefinition(*const FunctionDecl) bool; + + pub const isThisDeclarationADefinition = ZigClangFunctionDecl_isThisDeclarationADefinition; + extern fn ZigClangFunctionDecl_isThisDeclarationADefinition(*const FunctionDecl) bool; + + pub const doesThisDeclarationHaveABody = ZigClangFunctionDecl_doesThisDeclarationHaveABody; + extern fn ZigClangFunctionDecl_doesThisDeclarationHaveABody(*const FunctionDecl) bool; + + pub const isInlineSpecified = ZigClangFunctionDecl_isInlineSpecified; + extern fn ZigClangFunctionDecl_isInlineSpecified(*const FunctionDecl) bool; + + pub const isDefined = ZigClangFunctionDecl_isDefined; + extern fn ZigClangFunctionDecl_isDefined(*const FunctionDecl) bool; + + pub const getDefinition = ZigClangFunctionDecl_getDefinition; + extern fn ZigClangFunctionDecl_getDefinition(*const FunctionDecl) ?*const FunctionDecl; + + pub const getSectionAttribute = ZigClangFunctionDecl_getSectionAttribute; + extern fn ZigClangFunctionDecl_getSectionAttribute(*const FunctionDecl, len: *usize) ?[*]const u8; + + pub const getCanonicalDecl = ZigClangFunctionDecl_getCanonicalDecl; + extern fn ZigClangFunctionDecl_getCanonicalDecl(*const FunctionDecl) ?*const FunctionDecl; + + pub const getAlignedAttribute = ZigClangFunctionDecl_getAlignedAttribute; + extern fn ZigClangFunctionDecl_getAlignedAttribute(*const FunctionDecl, *const ASTContext) c_uint; +}; + +pub const FunctionProtoType = opaque { + pub const isVariadic = ZigClangFunctionProtoType_isVariadic; + extern fn ZigClangFunctionProtoType_isVariadic(*const FunctionProtoType) bool; + + pub const getNumParams = ZigClangFunctionProtoType_getNumParams; + extern fn ZigClangFunctionProtoType_getNumParams(*const FunctionProtoType) c_uint; + + pub const getParamType = ZigClangFunctionProtoType_getParamType; + extern fn ZigClangFunctionProtoType_getParamType(*const FunctionProtoType, i: c_uint) QualType; + + pub const getReturnType = ZigClangFunctionProtoType_getReturnType; + extern fn ZigClangFunctionProtoType_getReturnType(*const FunctionProtoType) QualType; +}; + +pub const FunctionType = opaque { + pub const getNoReturnAttr = ZigClangFunctionType_getNoReturnAttr; + extern fn ZigClangFunctionType_getNoReturnAttr(*const FunctionType) bool; + + pub const getCallConv = ZigClangFunctionType_getCallConv; + extern fn ZigClangFunctionType_getCallConv(*const FunctionType) CallingConv; + + pub const getReturnType = ZigClangFunctionType_getReturnType; + extern fn ZigClangFunctionType_getReturnType(*const FunctionType) QualType; +}; + +pub const IfStmt = opaque { + pub const getThen = ZigClangIfStmt_getThen; + extern fn ZigClangIfStmt_getThen(*const IfStmt) *const Stmt; + + pub const getElse = ZigClangIfStmt_getElse; + extern fn ZigClangIfStmt_getElse(*const IfStmt) ?*const Stmt; + + pub const getCond = ZigClangIfStmt_getCond; + extern fn ZigClangIfStmt_getCond(*const IfStmt) *const Stmt; +}; + +pub const ImplicitCastExpr = opaque { + pub const getBeginLoc = ZigClangImplicitCastExpr_getBeginLoc; + extern fn ZigClangImplicitCastExpr_getBeginLoc(*const ImplicitCastExpr) SourceLocation; + + pub const getCastKind = ZigClangImplicitCastExpr_getCastKind; + extern fn ZigClangImplicitCastExpr_getCastKind(*const ImplicitCastExpr) CK; + + pub const getSubExpr = ZigClangImplicitCastExpr_getSubExpr; + extern fn ZigClangImplicitCastExpr_getSubExpr(*const ImplicitCastExpr) *const Expr; +}; + +pub const IncompleteArrayType = opaque { + pub const getElementType = ZigClangIncompleteArrayType_getElementType; + extern fn ZigClangIncompleteArrayType_getElementType(*const IncompleteArrayType) QualType; +}; + +pub const IntegerLiteral = opaque { + pub const EvaluateAsInt = ZigClangIntegerLiteral_EvaluateAsInt; + extern fn ZigClangIntegerLiteral_EvaluateAsInt(*const IntegerLiteral, *ExprEvalResult, *const ASTContext) bool; + + pub const getBeginLoc = ZigClangIntegerLiteral_getBeginLoc; + extern fn ZigClangIntegerLiteral_getBeginLoc(*const IntegerLiteral) SourceLocation; + + pub const isZero = ZigClangIntegerLiteral_isZero; + extern fn ZigClangIntegerLiteral_isZero(*const IntegerLiteral, *bool, *const ASTContext) bool; +}; + +pub const MacroDefinitionRecord = opaque { + pub const getName_getNameStart = ZigClangMacroDefinitionRecord_getName_getNameStart; + extern fn ZigClangMacroDefinitionRecord_getName_getNameStart(*const MacroDefinitionRecord) [*:0]const u8; + + pub const getSourceRange_getBegin = ZigClangMacroDefinitionRecord_getSourceRange_getBegin; + extern fn ZigClangMacroDefinitionRecord_getSourceRange_getBegin(*const MacroDefinitionRecord) SourceLocation; + + pub const getSourceRange_getEnd = ZigClangMacroDefinitionRecord_getSourceRange_getEnd; + extern fn ZigClangMacroDefinitionRecord_getSourceRange_getEnd(*const MacroDefinitionRecord) SourceLocation; +}; + +pub const MacroQualifiedType = opaque { + pub const getModifiedType = ZigClangMacroQualifiedType_getModifiedType; + extern fn ZigClangMacroQualifiedType_getModifiedType(*const MacroQualifiedType) QualType; +}; + +pub const MemberExpr = opaque { + pub const getBase = ZigClangMemberExpr_getBase; + extern fn ZigClangMemberExpr_getBase(*const MemberExpr) *const Expr; + + pub const isArrow = ZigClangMemberExpr_isArrow; + extern fn ZigClangMemberExpr_isArrow(*const MemberExpr) bool; + + pub const getMemberDecl = ZigClangMemberExpr_getMemberDecl; + extern fn ZigClangMemberExpr_getMemberDecl(*const MemberExpr) *const ValueDecl; +}; + +pub const NamedDecl = opaque { + pub const getName_bytes_begin = ZigClangNamedDecl_getName_bytes_begin; + extern fn ZigClangNamedDecl_getName_bytes_begin(decl: *const NamedDecl) [*:0]const u8; +}; + +pub const None = opaque {}; + +pub const OpaqueValueExpr = opaque { + pub const getSourceExpr = ZigClangOpaqueValueExpr_getSourceExpr; + extern fn ZigClangOpaqueValueExpr_getSourceExpr(*const OpaqueValueExpr) ?*const Expr; +}; + +pub const PCHContainerOperations = opaque {}; + +pub const ParenExpr = opaque { + pub const getSubExpr = ZigClangParenExpr_getSubExpr; + extern fn ZigClangParenExpr_getSubExpr(*const ParenExpr) *const Expr; +}; + +pub const ParenType = opaque { + pub const getInnerType = ZigClangParenType_getInnerType; + extern fn ZigClangParenType_getInnerType(*const ParenType) QualType; +}; + +pub const ParmVarDecl = opaque { + pub const getOriginalType = ZigClangParmVarDecl_getOriginalType; + extern fn ZigClangParmVarDecl_getOriginalType(*const ParmVarDecl) QualType; +}; + +pub const PointerType = opaque {}; + +pub const PredefinedExpr = opaque { + pub const getFunctionName = ZigClangPredefinedExpr_getFunctionName; + extern fn ZigClangPredefinedExpr_getFunctionName(*const PredefinedExpr) *const StringLiteral; +}; + +pub const PreprocessedEntity = opaque { + pub const getKind = ZigClangPreprocessedEntity_getKind; + extern fn ZigClangPreprocessedEntity_getKind(*const PreprocessedEntity) PreprocessedEntity_EntityKind; +}; + +pub const PreprocessingRecord = opaque { + pub const iterator = extern struct { + I: c_int, + Self: *PreprocessingRecord, + + pub const deref = ZigClangPreprocessingRecord_iterator_deref; + extern fn ZigClangPreprocessingRecord_iterator_deref(iterator) *PreprocessedEntity; + }; +}; + +pub const RecordDecl = opaque { + pub const getCanonicalDecl = ZigClangRecordDecl_getCanonicalDecl; + extern fn ZigClangRecordDecl_getCanonicalDecl(*const RecordDecl) ?*const TagDecl; + + pub const isUnion = ZigClangRecordDecl_isUnion; + extern fn ZigClangRecordDecl_isUnion(*const RecordDecl) bool; + + pub const isStruct = ZigClangRecordDecl_isStruct; + extern fn ZigClangRecordDecl_isStruct(*const RecordDecl) bool; + + pub const isAnonymousStructOrUnion = ZigClangRecordDecl_isAnonymousStructOrUnion; + extern fn ZigClangRecordDecl_isAnonymousStructOrUnion(record_decl: ?*const RecordDecl) bool; + + pub const getPackedAttribute = ZigClangRecordDecl_getPackedAttribute; + extern fn ZigClangRecordDecl_getPackedAttribute(*const RecordDecl) bool; + + pub const getDefinition = ZigClangRecordDecl_getDefinition; + extern fn ZigClangRecordDecl_getDefinition(*const RecordDecl) ?*const RecordDecl; + + pub const getLocation = ZigClangRecordDecl_getLocation; + extern fn ZigClangRecordDecl_getLocation(*const RecordDecl) SourceLocation; + + pub const field_begin = ZigClangRecordDecl_field_begin; + extern fn ZigClangRecordDecl_field_begin(*const RecordDecl) field_iterator; + + pub const field_end = ZigClangRecordDecl_field_end; + extern fn ZigClangRecordDecl_field_end(*const RecordDecl) field_iterator; + + pub const field_iterator = extern struct { + ptr: *c_void, + + pub const next = ZigClangRecordDecl_field_iterator_next; + extern fn ZigClangRecordDecl_field_iterator_next(field_iterator) field_iterator; + + pub const deref = ZigClangRecordDecl_field_iterator_deref; + extern fn ZigClangRecordDecl_field_iterator_deref(field_iterator) *const FieldDecl; + + pub const neq = ZigClangRecordDecl_field_iterator_neq; + extern fn ZigClangRecordDecl_field_iterator_neq(field_iterator, field_iterator) bool; + }; +}; + +pub const RecordType = opaque { + pub const getDecl = ZigClangRecordType_getDecl; + extern fn ZigClangRecordType_getDecl(*const RecordType) *const RecordDecl; +}; + +pub const ReturnStmt = opaque { + pub const getRetValue = ZigClangReturnStmt_getRetValue; + extern fn ZigClangReturnStmt_getRetValue(*const ReturnStmt) ?*const Expr; +}; + +pub const SkipFunctionBodiesScope = opaque {}; + +pub const SourceManager = opaque { + pub const getSpellingLoc = ZigClangSourceManager_getSpellingLoc; + extern fn ZigClangSourceManager_getSpellingLoc(*const SourceManager, Loc: SourceLocation) SourceLocation; + + pub const getFilename = ZigClangSourceManager_getFilename; + extern fn ZigClangSourceManager_getFilename(*const SourceManager, SpellingLoc: SourceLocation) ?[*:0]const u8; + + pub const getSpellingLineNumber = ZigClangSourceManager_getSpellingLineNumber; + extern fn ZigClangSourceManager_getSpellingLineNumber(*const SourceManager, Loc: SourceLocation) c_uint; + + pub const getSpellingColumnNumber = ZigClangSourceManager_getSpellingColumnNumber; + extern fn ZigClangSourceManager_getSpellingColumnNumber(*const SourceManager, Loc: SourceLocation) c_uint; + + pub const getCharacterData = ZigClangSourceManager_getCharacterData; + extern fn ZigClangSourceManager_getCharacterData(*const SourceManager, SL: SourceLocation) [*:0]const u8; +}; + +pub const SourceRange = opaque {}; + +pub const Stmt = opaque { + pub const getBeginLoc = ZigClangStmt_getBeginLoc; + extern fn ZigClangStmt_getBeginLoc(*const Stmt) SourceLocation; + + pub const getStmtClass = ZigClangStmt_getStmtClass; + extern fn ZigClangStmt_getStmtClass(*const Stmt) StmtClass; + + pub const classof_Expr = ZigClangStmt_classof_Expr; + extern fn ZigClangStmt_classof_Expr(*const Stmt) bool; +}; + +pub const StmtExpr = opaque { + pub const getSubStmt = ZigClangStmtExpr_getSubStmt; + extern fn ZigClangStmtExpr_getSubStmt(*const StmtExpr) *const CompoundStmt; +}; + +pub const StringLiteral = opaque { + pub const getKind = ZigClangStringLiteral_getKind; + extern fn ZigClangStringLiteral_getKind(*const StringLiteral) StringLiteral_StringKind; + + pub const getString_bytes_begin_size = ZigClangStringLiteral_getString_bytes_begin_size; + extern fn ZigClangStringLiteral_getString_bytes_begin_size(*const StringLiteral, *usize) [*]const u8; +}; + +pub const StringRef = opaque {}; + +pub const SwitchStmt = opaque { + pub const getConditionVariableDeclStmt = ZigClangSwitchStmt_getConditionVariableDeclStmt; + extern fn ZigClangSwitchStmt_getConditionVariableDeclStmt(*const SwitchStmt) ?*const DeclStmt; + + pub const getCond = ZigClangSwitchStmt_getCond; + extern fn ZigClangSwitchStmt_getCond(*const SwitchStmt) *const Expr; + + pub const getBody = ZigClangSwitchStmt_getBody; + extern fn ZigClangSwitchStmt_getBody(*const SwitchStmt) *const Stmt; + + pub const isAllEnumCasesCovered = ZigClangSwitchStmt_isAllEnumCasesCovered; + extern fn ZigClangSwitchStmt_isAllEnumCasesCovered(*const SwitchStmt) bool; +}; + +pub const TagDecl = opaque { + pub const isThisDeclarationADefinition = ZigClangTagDecl_isThisDeclarationADefinition; + extern fn ZigClangTagDecl_isThisDeclarationADefinition(*const TagDecl) bool; +}; + +pub const Type = opaque { + pub const getTypeClass = ZigClangType_getTypeClass; + extern fn ZigClangType_getTypeClass(*const Type) TypeClass; + + pub const getPointeeType = ZigClangType_getPointeeType; + extern fn ZigClangType_getPointeeType(*const Type) QualType; + + pub const isVoidType = ZigClangType_isVoidType; + extern fn ZigClangType_isVoidType(*const Type) bool; + + pub const isConstantArrayType = ZigClangType_isConstantArrayType; + extern fn ZigClangType_isConstantArrayType(*const Type) bool; + + pub const isRecordType = ZigClangType_isRecordType; + extern fn ZigClangType_isRecordType(*const Type) bool; + + pub const isIncompleteOrZeroLengthArrayType = ZigClangType_isIncompleteOrZeroLengthArrayType; + extern fn ZigClangType_isIncompleteOrZeroLengthArrayType(*const Type, *const ASTContext) bool; + + pub const isArrayType = ZigClangType_isArrayType; + extern fn ZigClangType_isArrayType(*const Type) bool; + + pub const isBooleanType = ZigClangType_isBooleanType; + extern fn ZigClangType_isBooleanType(*const Type) bool; + + pub const getTypeClassName = ZigClangType_getTypeClassName; + extern fn ZigClangType_getTypeClassName(*const Type) [*:0]const u8; + + pub const getAsArrayTypeUnsafe = ZigClangType_getAsArrayTypeUnsafe; + extern fn ZigClangType_getAsArrayTypeUnsafe(*const Type) *const ArrayType; + + pub const getAsRecordType = ZigClangType_getAsRecordType; + extern fn ZigClangType_getAsRecordType(*const Type) ?*const RecordType; + + pub const getAsUnionType = ZigClangType_getAsUnionType; + extern fn ZigClangType_getAsUnionType(*const Type) ?*const RecordType; +}; + +pub const TypedefNameDecl = opaque { + pub const getUnderlyingType = ZigClangTypedefNameDecl_getUnderlyingType; + extern fn ZigClangTypedefNameDecl_getUnderlyingType(*const TypedefNameDecl) QualType; + + pub const getCanonicalDecl = ZigClangTypedefNameDecl_getCanonicalDecl; + extern fn ZigClangTypedefNameDecl_getCanonicalDecl(*const TypedefNameDecl) ?*const TypedefNameDecl; + + pub const getLocation = ZigClangTypedefNameDecl_getLocation; + extern fn ZigClangTypedefNameDecl_getLocation(*const TypedefNameDecl) SourceLocation; +}; + +pub const TypedefType = opaque { + pub const getDecl = ZigClangTypedefType_getDecl; + extern fn ZigClangTypedefType_getDecl(*const TypedefType) *const TypedefNameDecl; +}; + +pub const UnaryExprOrTypeTraitExpr = opaque { + pub const getTypeOfArgument = ZigClangUnaryExprOrTypeTraitExpr_getTypeOfArgument; + extern fn ZigClangUnaryExprOrTypeTraitExpr_getTypeOfArgument(*const UnaryExprOrTypeTraitExpr) QualType; + + pub const getBeginLoc = ZigClangUnaryExprOrTypeTraitExpr_getBeginLoc; + extern fn ZigClangUnaryExprOrTypeTraitExpr_getBeginLoc(*const UnaryExprOrTypeTraitExpr) SourceLocation; + + pub const getKind = ZigClangUnaryExprOrTypeTraitExpr_getKind; + extern fn ZigClangUnaryExprOrTypeTraitExpr_getKind(*const UnaryExprOrTypeTraitExpr) UnaryExprOrTypeTrait_Kind; +}; + +pub const UnaryOperator = opaque { + pub const getOpcode = ZigClangUnaryOperator_getOpcode; + extern fn ZigClangUnaryOperator_getOpcode(*const UnaryOperator) UO; + + pub const getType = ZigClangUnaryOperator_getType; + extern fn ZigClangUnaryOperator_getType(*const UnaryOperator) QualType; + + pub const getSubExpr = ZigClangUnaryOperator_getSubExpr; + extern fn ZigClangUnaryOperator_getSubExpr(*const UnaryOperator) *const Expr; + + pub const getBeginLoc = ZigClangUnaryOperator_getBeginLoc; + extern fn ZigClangUnaryOperator_getBeginLoc(*const UnaryOperator) SourceLocation; +}; + +pub const ValueDecl = opaque {}; + +pub const VarDecl = opaque { + pub const getLocation = ZigClangVarDecl_getLocation; + extern fn ZigClangVarDecl_getLocation(*const VarDecl) SourceLocation; + + pub const hasInit = ZigClangVarDecl_hasInit; + extern fn ZigClangVarDecl_hasInit(*const VarDecl) bool; + + pub const getStorageClass = ZigClangVarDecl_getStorageClass; + extern fn ZigClangVarDecl_getStorageClass(*const VarDecl) StorageClass; + + pub const getType = ZigClangVarDecl_getType; + extern fn ZigClangVarDecl_getType(*const VarDecl) QualType; + + pub const getInit = ZigClangVarDecl_getInit; + extern fn ZigClangVarDecl_getInit(*const VarDecl) ?*const Expr; + + pub const getTLSKind = ZigClangVarDecl_getTLSKind; + extern fn ZigClangVarDecl_getTLSKind(*const VarDecl) VarDecl_TLSKind; + + pub const getCanonicalDecl = ZigClangVarDecl_getCanonicalDecl; + extern fn ZigClangVarDecl_getCanonicalDecl(*const VarDecl) ?*const VarDecl; + + pub const getSectionAttribute = ZigClangVarDecl_getSectionAttribute; + extern fn ZigClangVarDecl_getSectionAttribute(*const VarDecl, len: *usize) ?[*]const u8; + + pub const getAlignedAttribute = ZigClangVarDecl_getAlignedAttribute; + extern fn ZigClangVarDecl_getAlignedAttribute(*const VarDecl, *const ASTContext) c_uint; + + pub const getTypeSourceInfo_getType = ZigClangVarDecl_getTypeSourceInfo_getType; + extern fn ZigClangVarDecl_getTypeSourceInfo_getType(*const VarDecl) QualType; +}; + +pub const WhileStmt = opaque { + pub const getCond = ZigClangWhileStmt_getCond; + extern fn ZigClangWhileStmt_getCond(*const WhileStmt) *const Expr; + + pub const getBody = ZigClangWhileStmt_getBody; + extern fn ZigClangWhileStmt_getBody(*const WhileStmt) *const Stmt; +}; + +pub const InitListExpr = opaque { + pub const getInit = ZigClangInitListExpr_getInit; + extern fn ZigClangInitListExpr_getInit(*const InitListExpr, i: c_uint) *const Expr; + + pub const getArrayFiller = ZigClangInitListExpr_getArrayFiller; + extern fn ZigClangInitListExpr_getArrayFiller(*const InitListExpr) *const Expr; + + pub const getNumInits = ZigClangInitListExpr_getNumInits; + extern fn ZigClangInitListExpr_getNumInits(*const InitListExpr) c_uint; + + pub const getInitializedFieldInUnion = ZigClangInitListExpr_getInitializedFieldInUnion; + extern fn ZigClangInitListExpr_getInitializedFieldInUnion(*const InitListExpr) ?*FieldDecl; +}; + +pub const BO = extern enum { PtrMemD, PtrMemI, Mul, @@ -121,7 +931,7 @@ pub const ZigClangBO = extern enum { Comma, }; -pub const ZigClangUO = extern enum { +pub const UO = extern enum { PostInc, PostDec, PreInc, @@ -138,7 +948,7 @@ pub const ZigClangUO = extern enum { Coawait, }; -pub const ZigClangTypeClass = extern enum { +pub const TypeClass = extern enum { Adjusted, Decayed, ConstantArray, @@ -193,7 +1003,7 @@ pub const ZigClangTypeClass = extern enum { ExtVector, }; -const ZigClangStmtClass = extern enum { +const StmtClass = extern enum { NoStmtClass, GCCAsmStmtClass, MSAsmStmtClass, @@ -410,7 +1220,7 @@ const ZigClangStmtClass = extern enum { WhileStmtClass, }; -pub const ZigClangCK = extern enum { +pub const CK = extern enum { Dependent, BitCast, LValueBitCast, @@ -475,24 +1285,7 @@ pub const ZigClangCK = extern enum { IntToOCLSampler, }; -pub const ZigClangAPValueKind = extern enum { - None, - Indeterminate, - Int, - Float, - FixedPoint, - ComplexInt, - ComplexFloat, - LValue, - Vector, - Array, - Struct, - Union, - MemberPointer, - AddrLabelDiff, -}; - -pub const ZigClangDeclKind = extern enum { +pub const DeclKind = extern enum { AccessSpec, Block, Captured, @@ -575,7 +1368,7 @@ pub const ZigClangDeclKind = extern enum { TranslationUnit, }; -pub const ZigClangBuiltinTypeKind = extern enum { +pub const BuiltinTypeKind = extern enum { OCLImage1dRO, OCLImage1dArrayRO, OCLImage1dBufferRO, @@ -747,7 +1540,7 @@ pub const ZigClangBuiltinTypeKind = extern enum { OMPIterator, }; -pub const ZigClangCallingConv = extern enum { +pub const CallingConv = extern enum { C, X86StdCall, X86FastCall, @@ -768,7 +1561,7 @@ pub const ZigClangCallingConv = extern enum { AArch64VectorCall, }; -pub const ZigClangStorageClass = extern enum { +pub const StorageClass = extern enum { None, Extern, Static, @@ -777,7 +1570,7 @@ pub const ZigClangStorageClass = extern enum { Register, }; -pub const ZigClangAPFloat_roundingMode = extern enum(i8) { +pub const APFloat_roundingMode = extern enum(i8) { TowardZero = 0, NearestTiesToEven = 1, TowardPositive = 2, @@ -787,7 +1580,7 @@ pub const ZigClangAPFloat_roundingMode = extern enum(i8) { Invalid = -1, }; -pub const ZigClangStringLiteral_StringKind = extern enum { +pub const StringLiteral_StringKind = extern enum { Ascii, Wide, UTF8, @@ -795,7 +1588,7 @@ pub const ZigClangStringLiteral_StringKind = extern enum { UTF32, }; -pub const ZigClangCharacterLiteral_CharacterKind = extern enum { +pub const CharacterLiteral_CharacterKind = extern enum { Ascii, Wide, UTF8, @@ -803,32 +1596,35 @@ pub const ZigClangCharacterLiteral_CharacterKind = extern enum { UTF32, }; -pub const ZigClangRecordDecl_field_iterator = extern struct { - opaque: *c_void, +pub const VarDecl_TLSKind = extern enum { + None, + Static, + Dynamic, }; -pub const ZigClangEnumDecl_enumerator_iterator = extern struct { - opaque: *c_void, +pub const ElaboratedTypeKeyword = extern enum { + Struct, + Interface, + Union, + Class, + Enum, + Typename, + None, }; -pub const ZigClangPreprocessingRecord_iterator = extern struct { - I: c_int, - Self: *ZigClangPreprocessingRecord, -}; - -pub const ZigClangPreprocessedEntity_EntityKind = extern enum { +pub const PreprocessedEntity_EntityKind = extern enum { InvalidKind, MacroExpansionKind, MacroDefinitionKind, InclusionDirectiveKind, }; -pub const ZigClangExpr_ConstExprUsage = extern enum { +pub const Expr_ConstExprUsage = extern enum { EvaluateForCodeGen, EvaluateForMangling, }; -pub const ZigClangUnaryExprOrTypeTrait_Kind = extern enum { +pub const UnaryExprOrTypeTrait_Kind = extern enum { SizeOf, AlignOf, VecStep, @@ -836,211 +1632,6 @@ pub const ZigClangUnaryExprOrTypeTrait_Kind = extern enum { PreferredAlignOf, }; -pub extern fn ZigClangSourceManager_getSpellingLoc(self: ?*const struct_ZigClangSourceManager, Loc: struct_ZigClangSourceLocation) struct_ZigClangSourceLocation; -pub extern fn ZigClangSourceManager_getFilename(self: *const struct_ZigClangSourceManager, SpellingLoc: struct_ZigClangSourceLocation) ?[*:0]const u8; -pub extern fn ZigClangSourceManager_getSpellingLineNumber(self: ?*const struct_ZigClangSourceManager, Loc: struct_ZigClangSourceLocation) c_uint; -pub extern fn ZigClangSourceManager_getSpellingColumnNumber(self: ?*const struct_ZigClangSourceManager, Loc: struct_ZigClangSourceLocation) c_uint; -pub extern fn ZigClangSourceManager_getCharacterData(self: ?*const struct_ZigClangSourceManager, SL: struct_ZigClangSourceLocation) [*:0]const u8; -pub extern fn ZigClangASTContext_getPointerType(self: ?*const struct_ZigClangASTContext, T: struct_ZigClangQualType) struct_ZigClangQualType; -pub extern fn ZigClangASTUnit_getASTContext(self: ?*struct_ZigClangASTUnit) ?*struct_ZigClangASTContext; -pub extern fn ZigClangASTUnit_getSourceManager(self: *struct_ZigClangASTUnit) *struct_ZigClangSourceManager; -pub extern fn ZigClangASTUnit_visitLocalTopLevelDecls(self: *struct_ZigClangASTUnit, context: ?*c_void, Fn: ?fn (?*c_void, *const ZigClangDecl) callconv(.C) bool) bool; -pub extern fn ZigClangRecordType_getDecl(record_ty: ?*const struct_ZigClangRecordType) *const struct_ZigClangRecordDecl; -pub extern fn ZigClangTagDecl_isThisDeclarationADefinition(self: *const ZigClangTagDecl) bool; -pub extern fn ZigClangEnumType_getDecl(record_ty: ?*const struct_ZigClangEnumType) *const struct_ZigClangEnumDecl; -pub extern fn ZigClangRecordDecl_getCanonicalDecl(record_decl: ?*const struct_ZigClangRecordDecl) ?*const struct_ZigClangTagDecl; -pub extern fn ZigClangFieldDecl_getCanonicalDecl(field_decl: ?*const struct_ZigClangFieldDecl) ?*const struct_ZigClangFieldDecl; -pub extern fn ZigClangFieldDecl_getAlignedAttribute(field_decl: ?*const struct_ZigClangFieldDecl, *const ZigClangASTContext) c_uint; -pub extern fn ZigClangEnumDecl_getCanonicalDecl(self: ?*const struct_ZigClangEnumDecl) ?*const struct_ZigClangTagDecl; -pub extern fn ZigClangTypedefNameDecl_getCanonicalDecl(self: ?*const struct_ZigClangTypedefNameDecl) ?*const struct_ZigClangTypedefNameDecl; -pub extern fn ZigClangFunctionDecl_getCanonicalDecl(self: ?*const struct_ZigClangFunctionDecl) ?*const struct_ZigClangFunctionDecl; -pub extern fn ZigClangParmVarDecl_getOriginalType(self: ?*const struct_ZigClangParmVarDecl) struct_ZigClangQualType; -pub extern fn ZigClangVarDecl_getCanonicalDecl(self: ?*const struct_ZigClangVarDecl) ?*const struct_ZigClangVarDecl; -pub extern fn ZigClangVarDecl_getSectionAttribute(self: *const ZigClangVarDecl, len: *usize) ?[*]const u8; -pub extern fn ZigClangFunctionDecl_getAlignedAttribute(self: *const ZigClangFunctionDecl, *const ZigClangASTContext) c_uint; -pub extern fn ZigClangVarDecl_getAlignedAttribute(self: *const ZigClangVarDecl, *const ZigClangASTContext) c_uint; -pub extern fn ZigClangRecordDecl_getPackedAttribute(self: ?*const struct_ZigClangRecordDecl) bool; -pub extern fn ZigClangRecordDecl_getDefinition(self: ?*const struct_ZigClangRecordDecl) ?*const struct_ZigClangRecordDecl; -pub extern fn ZigClangEnumDecl_getDefinition(self: ?*const struct_ZigClangEnumDecl) ?*const struct_ZigClangEnumDecl; -pub extern fn ZigClangRecordDecl_getLocation(self: ?*const struct_ZigClangRecordDecl) struct_ZigClangSourceLocation; -pub extern fn ZigClangEnumDecl_getLocation(self: ?*const struct_ZigClangEnumDecl) struct_ZigClangSourceLocation; -pub extern fn ZigClangTypedefNameDecl_getLocation(self: ?*const struct_ZigClangTypedefNameDecl) struct_ZigClangSourceLocation; -pub extern fn ZigClangDecl_getLocation(self: *const ZigClangDecl) ZigClangSourceLocation; -pub extern fn ZigClangRecordDecl_isUnion(record_decl: ?*const struct_ZigClangRecordDecl) bool; -pub extern fn ZigClangRecordDecl_isStruct(record_decl: ?*const struct_ZigClangRecordDecl) bool; -pub extern fn ZigClangRecordDecl_isAnonymousStructOrUnion(record_decl: ?*const struct_ZigClangRecordDecl) bool; -pub extern fn ZigClangRecordDecl_field_begin(*const struct_ZigClangRecordDecl) ZigClangRecordDecl_field_iterator; -pub extern fn ZigClangRecordDecl_field_end(*const struct_ZigClangRecordDecl) ZigClangRecordDecl_field_iterator; -pub extern fn ZigClangRecordDecl_field_iterator_next(ZigClangRecordDecl_field_iterator) ZigClangRecordDecl_field_iterator; -pub extern fn ZigClangRecordDecl_field_iterator_deref(ZigClangRecordDecl_field_iterator) *const struct_ZigClangFieldDecl; -pub extern fn ZigClangRecordDecl_field_iterator_neq(ZigClangRecordDecl_field_iterator, ZigClangRecordDecl_field_iterator) bool; -pub extern fn ZigClangEnumDecl_getIntegerType(self: ?*const struct_ZigClangEnumDecl) struct_ZigClangQualType; -pub extern fn ZigClangEnumDecl_enumerator_begin(*const ZigClangEnumDecl) ZigClangEnumDecl_enumerator_iterator; -pub extern fn ZigClangEnumDecl_enumerator_end(*const ZigClangEnumDecl) ZigClangEnumDecl_enumerator_iterator; -pub extern fn ZigClangEnumDecl_enumerator_iterator_next(ZigClangEnumDecl_enumerator_iterator) ZigClangEnumDecl_enumerator_iterator; -pub extern fn ZigClangEnumDecl_enumerator_iterator_deref(ZigClangEnumDecl_enumerator_iterator) *const ZigClangEnumConstantDecl; -pub extern fn ZigClangEnumDecl_enumerator_iterator_neq(ZigClangEnumDecl_enumerator_iterator, ZigClangEnumDecl_enumerator_iterator) bool; -pub extern fn ZigClangDecl_castToNamedDecl(decl: *const ZigClangDecl) ?*const ZigClangNamedDecl; -pub extern fn ZigClangNamedDecl_getName_bytes_begin(decl: ?*const struct_ZigClangNamedDecl) [*:0]const u8; -pub extern fn ZigClangSourceLocation_eq(a: struct_ZigClangSourceLocation, b: struct_ZigClangSourceLocation) bool; -pub extern fn ZigClangTypedefType_getDecl(self: ?*const struct_ZigClangTypedefType) *const struct_ZigClangTypedefNameDecl; -pub extern fn ZigClangTypedefNameDecl_getUnderlyingType(self: ?*const struct_ZigClangTypedefNameDecl) struct_ZigClangQualType; -pub extern fn ZigClangQualType_getCanonicalType(self: struct_ZigClangQualType) struct_ZigClangQualType; -pub extern fn ZigClangQualType_getTypeClass(self: struct_ZigClangQualType) ZigClangTypeClass; -pub extern fn ZigClangQualType_getTypePtr(self: struct_ZigClangQualType) *const struct_ZigClangType; -pub extern fn ZigClangQualType_addConst(self: *struct_ZigClangQualType) void; -pub extern fn ZigClangQualType_eq(self: struct_ZigClangQualType, arg1: struct_ZigClangQualType) bool; -pub extern fn ZigClangQualType_isConstQualified(self: struct_ZigClangQualType) bool; -pub extern fn ZigClangQualType_isVolatileQualified(self: struct_ZigClangQualType) bool; -pub extern fn ZigClangQualType_isRestrictQualified(self: struct_ZigClangQualType) bool; -pub extern fn ZigClangType_getTypeClass(self: ?*const struct_ZigClangType) ZigClangTypeClass; -pub extern fn ZigClangType_getPointeeType(self: ?*const struct_ZigClangType) struct_ZigClangQualType; -pub extern fn ZigClangType_isVoidType(self: ?*const struct_ZigClangType) bool; -pub extern fn ZigClangType_isConstantArrayType(self: ?*const struct_ZigClangType) bool; -pub extern fn ZigClangType_isRecordType(self: ?*const struct_ZigClangType) bool; -pub extern fn ZigClangType_isIncompleteOrZeroLengthArrayType(self: ?*const struct_ZigClangType, *const ZigClangASTContext) bool; -pub extern fn ZigClangType_isArrayType(self: ?*const struct_ZigClangType) bool; -pub extern fn ZigClangType_isBooleanType(self: ?*const struct_ZigClangType) bool; -pub extern fn ZigClangType_getTypeClassName(self: *const struct_ZigClangType) [*:0]const u8; -pub extern fn ZigClangType_getAsArrayTypeUnsafe(self: *const ZigClangType) *const ZigClangArrayType; -pub extern fn ZigClangType_getAsRecordType(self: *const ZigClangType) ?*const ZigClangRecordType; -pub extern fn ZigClangType_getAsUnionType(self: *const ZigClangType) ?*const ZigClangRecordType; -pub extern fn ZigClangStmt_getBeginLoc(self: *const ZigClangStmt) struct_ZigClangSourceLocation; -pub extern fn ZigClangStmt_getStmtClass(self: ?*const ZigClangStmt) ZigClangStmtClass; -pub extern fn ZigClangStmt_classof_Expr(self: ?*const ZigClangStmt) bool; -pub extern fn ZigClangExpr_getStmtClass(self: *const struct_ZigClangExpr) ZigClangStmtClass; -pub extern fn ZigClangExpr_getType(self: *const struct_ZigClangExpr) struct_ZigClangQualType; -pub extern fn ZigClangExpr_getBeginLoc(self: *const struct_ZigClangExpr) struct_ZigClangSourceLocation; -pub extern fn ZigClangInitListExpr_getInit(self: ?*const struct_ZigClangInitListExpr, i: c_uint) *const ZigClangExpr; -pub extern fn ZigClangInitListExpr_getArrayFiller(self: ?*const struct_ZigClangInitListExpr) *const ZigClangExpr; -pub extern fn ZigClangInitListExpr_getNumInits(self: ?*const struct_ZigClangInitListExpr) c_uint; -pub extern fn ZigClangInitListExpr_getInitializedFieldInUnion(self: ?*const struct_ZigClangInitListExpr) ?*ZigClangFieldDecl; -pub extern fn ZigClangAPValue_getKind(self: ?*const struct_ZigClangAPValue) ZigClangAPValueKind; -pub extern fn ZigClangAPValue_getInt(self: ?*const struct_ZigClangAPValue) *const struct_ZigClangAPSInt; -pub extern fn ZigClangAPValue_getArrayInitializedElts(self: ?*const struct_ZigClangAPValue) c_uint; -pub extern fn ZigClangAPValue_getArraySize(self: ?*const struct_ZigClangAPValue) c_uint; -pub extern fn ZigClangAPValue_getLValueBase(self: ?*const struct_ZigClangAPValue) struct_ZigClangAPValueLValueBase; -pub extern fn ZigClangAPSInt_isSigned(self: *const struct_ZigClangAPSInt) bool; -pub extern fn ZigClangAPSInt_isNegative(self: *const struct_ZigClangAPSInt) bool; -pub extern fn ZigClangAPSInt_negate(self: *const struct_ZigClangAPSInt) *const struct_ZigClangAPSInt; -pub extern fn ZigClangAPSInt_free(self: *const struct_ZigClangAPSInt) void; -pub extern fn ZigClangAPSInt_getRawData(self: *const struct_ZigClangAPSInt) [*:0]const u64; -pub extern fn ZigClangAPSInt_getNumWords(self: *const struct_ZigClangAPSInt) c_uint; - -pub extern fn ZigClangAPInt_getLimitedValue(self: *const struct_ZigClangAPInt, limit: u64) u64; -pub extern fn ZigClangAPValueLValueBase_dyn_cast_Expr(self: struct_ZigClangAPValueLValueBase) ?*const struct_ZigClangExpr; -pub extern fn ZigClangASTUnit_delete(self: ?*struct_ZigClangASTUnit) void; - -pub extern fn ZigClangFunctionDecl_getType(self: *const ZigClangFunctionDecl) struct_ZigClangQualType; -pub extern fn ZigClangFunctionDecl_getLocation(self: *const ZigClangFunctionDecl) struct_ZigClangSourceLocation; -pub extern fn ZigClangFunctionDecl_hasBody(self: *const ZigClangFunctionDecl) bool; -pub extern fn ZigClangFunctionDecl_getStorageClass(self: *const ZigClangFunctionDecl) ZigClangStorageClass; -pub extern fn ZigClangFunctionDecl_getParamDecl(self: *const ZigClangFunctionDecl, i: c_uint) *const struct_ZigClangParmVarDecl; -pub extern fn ZigClangFunctionDecl_getBody(self: *const ZigClangFunctionDecl) *const ZigClangStmt; -pub extern fn ZigClangFunctionDecl_doesDeclarationForceExternallyVisibleDefinition(self: *const ZigClangFunctionDecl) bool; -pub extern fn ZigClangFunctionDecl_isThisDeclarationADefinition(self: *const ZigClangFunctionDecl) bool; -pub extern fn ZigClangFunctionDecl_doesThisDeclarationHaveABody(self: *const ZigClangFunctionDecl) bool; -pub extern fn ZigClangFunctionDecl_isInlineSpecified(self: *const ZigClangFunctionDecl) bool; -pub extern fn ZigClangFunctionDecl_isDefined(self: *const ZigClangFunctionDecl) bool; -pub extern fn ZigClangFunctionDecl_getDefinition(self: *const ZigClangFunctionDecl) ?*const struct_ZigClangFunctionDecl; -pub extern fn ZigClangFunctionDecl_getSectionAttribute(self: *const ZigClangFunctionDecl, len: *usize) ?[*]const u8; - -pub extern fn ZigClangBuiltinType_getKind(self: *const struct_ZigClangBuiltinType) ZigClangBuiltinTypeKind; - -pub extern fn ZigClangFunctionType_getNoReturnAttr(self: *const ZigClangFunctionType) bool; -pub extern fn ZigClangFunctionType_getCallConv(self: *const ZigClangFunctionType) ZigClangCallingConv; -pub extern fn ZigClangFunctionType_getReturnType(self: *const ZigClangFunctionType) ZigClangQualType; - -pub extern fn ZigClangFunctionProtoType_isVariadic(self: *const struct_ZigClangFunctionProtoType) bool; -pub extern fn ZigClangFunctionProtoType_getNumParams(self: *const struct_ZigClangFunctionProtoType) c_uint; -pub extern fn ZigClangFunctionProtoType_getParamType(self: *const struct_ZigClangFunctionProtoType, i: c_uint) ZigClangQualType; -pub extern fn ZigClangFunctionProtoType_getReturnType(self: *const ZigClangFunctionProtoType) ZigClangQualType; - -pub const ZigClangSourceLocation = struct_ZigClangSourceLocation; -pub const ZigClangQualType = struct_ZigClangQualType; -pub const ZigClangConditionalOperator = struct_ZigClangConditionalOperator; -pub const ZigClangBinaryConditionalOperator = struct_ZigClangBinaryConditionalOperator; -pub const ZigClangAbstractConditionalOperator = struct_ZigClangAbstractConditionalOperator; -pub const ZigClangAPValueLValueBase = struct_ZigClangAPValueLValueBase; -pub const ZigClangAPValue = struct_ZigClangAPValue; -pub const ZigClangAPSInt = struct_ZigClangAPSInt; -pub const ZigClangAPFloat = struct_ZigClangAPFloat; -pub const ZigClangASTContext = struct_ZigClangASTContext; -pub const ZigClangASTUnit = struct_ZigClangASTUnit; -pub const ZigClangArraySubscriptExpr = struct_ZigClangArraySubscriptExpr; -pub const ZigClangArrayType = struct_ZigClangArrayType; -pub const ZigClangAttributedType = struct_ZigClangAttributedType; -pub const ZigClangBinaryOperator = struct_ZigClangBinaryOperator; -pub const ZigClangBreakStmt = struct_ZigClangBreakStmt; -pub const ZigClangBuiltinType = struct_ZigClangBuiltinType; -pub const ZigClangCStyleCastExpr = struct_ZigClangCStyleCastExpr; -pub const ZigClangCallExpr = struct_ZigClangCallExpr; -pub const ZigClangCaseStmt = struct_ZigClangCaseStmt; -pub const ZigClangCompoundAssignOperator = struct_ZigClangCompoundAssignOperator; -pub const ZigClangCompoundStmt = struct_ZigClangCompoundStmt; -pub const ZigClangConstantArrayType = struct_ZigClangConstantArrayType; -pub const ZigClangContinueStmt = struct_ZigClangContinueStmt; -pub const ZigClangDecayedType = struct_ZigClangDecayedType; -pub const ZigClangDeclRefExpr = struct_ZigClangDeclRefExpr; -pub const ZigClangDeclStmt = struct_ZigClangDeclStmt; -pub const ZigClangDefaultStmt = struct_ZigClangDefaultStmt; -pub const ZigClangDiagnosticOptions = struct_ZigClangDiagnosticOptions; -pub const ZigClangDiagnosticsEngine = struct_ZigClangDiagnosticsEngine; -pub const ZigClangDoStmt = struct_ZigClangDoStmt; -pub const ZigClangElaboratedType = struct_ZigClangElaboratedType; -pub const ZigClangEnumConstantDecl = struct_ZigClangEnumConstantDecl; -pub const ZigClangEnumDecl = struct_ZigClangEnumDecl; -pub const ZigClangEnumType = struct_ZigClangEnumType; -pub const ZigClangExpr = struct_ZigClangExpr; -pub const ZigClangFieldDecl = struct_ZigClangFieldDecl; -pub const ZigClangFileID = struct_ZigClangFileID; -pub const ZigClangForStmt = struct_ZigClangForStmt; -pub const ZigClangFullSourceLoc = struct_ZigClangFullSourceLoc; -pub const ZigClangFunctionDecl = struct_ZigClangFunctionDecl; -pub const ZigClangFunctionProtoType = struct_ZigClangFunctionProtoType; -pub const ZigClangIfStmt = struct_ZigClangIfStmt; -pub const ZigClangImplicitCastExpr = struct_ZigClangImplicitCastExpr; -pub const ZigClangIncompleteArrayType = struct_ZigClangIncompleteArrayType; -pub const ZigClangIntegerLiteral = struct_ZigClangIntegerLiteral; -pub const ZigClangMacroDefinitionRecord = struct_ZigClangMacroDefinitionRecord; -pub const ZigClangMacroExpansion = struct_ZigClangMacroExpansion; -pub const ZigClangMacroQualifiedType = struct_ZigClangMacroQualifiedType; -pub const ZigClangMemberExpr = struct_ZigClangMemberExpr; -pub const ZigClangNamedDecl = struct_ZigClangNamedDecl; -pub const ZigClangNone = struct_ZigClangNone; -pub const ZigClangOpaqueValueExpr = struct_ZigClangOpaqueValueExpr; -pub const ZigClangPCHContainerOperations = struct_ZigClangPCHContainerOperations; -pub const ZigClangParenExpr = struct_ZigClangParenExpr; -pub const ZigClangParenType = struct_ZigClangParenType; -pub const ZigClangParmVarDecl = struct_ZigClangParmVarDecl; -pub const ZigClangPointerType = struct_ZigClangPointerType; -pub const ZigClangPreprocessedEntity = struct_ZigClangPreprocessedEntity; -pub const ZigClangRecordDecl = struct_ZigClangRecordDecl; -pub const ZigClangRecordType = struct_ZigClangRecordType; -pub const ZigClangReturnStmt = struct_ZigClangReturnStmt; -pub const ZigClangSkipFunctionBodiesScope = struct_ZigClangSkipFunctionBodiesScope; -pub const ZigClangSourceManager = struct_ZigClangSourceManager; -pub const ZigClangSourceRange = struct_ZigClangSourceRange; -pub const ZigClangStringLiteral = struct_ZigClangStringLiteral; -pub const ZigClangStringRef = struct_ZigClangStringRef; -pub const ZigClangSwitchStmt = struct_ZigClangSwitchStmt; -pub const ZigClangTagDecl = struct_ZigClangTagDecl; -pub const ZigClangType = struct_ZigClangType; -pub const ZigClangTypedefNameDecl = struct_ZigClangTypedefNameDecl; -pub const ZigClangTypedefType = struct_ZigClangTypedefType; -pub const ZigClangUnaryExprOrTypeTraitExpr = struct_ZigClangUnaryExprOrTypeTraitExpr; -pub const ZigClangUnaryOperator = struct_ZigClangUnaryOperator; -pub const ZigClangValueDecl = struct_ZigClangValueDecl; -pub const ZigClangVarDecl = struct_ZigClangVarDecl; -pub const ZigClangWhileStmt = struct_ZigClangWhileStmt; -pub const ZigClangFunctionType = struct_ZigClangFunctionType; -pub const ZigClangPredefinedExpr = struct_ZigClangPredefinedExpr; -pub const ZigClangInitListExpr = struct_ZigClangInitListExpr; - -pub const struct_ZigClangSourceLocation = extern struct { - ID: c_uint, -}; - pub const Stage2ErrorMsg = extern struct { filename_ptr: ?[*]const u8, filename_len: usize, @@ -1054,199 +1645,16 @@ pub const Stage2ErrorMsg = extern struct { column: c_uint, // byte offset into source offset: c_uint, + + pub const delete = ZigClangErrorMsg_delete; + extern fn ZigClangErrorMsg_delete(ptr: [*]Stage2ErrorMsg, len: usize) void; }; -pub const struct_ZigClangQualType = extern struct { - ptr: ?*c_void, -}; - -pub const struct_ZigClangAPValueLValueBase = extern struct { - Ptr: ?*c_void, - CallIndex: c_uint, - Version: c_uint, -}; - -pub extern fn ZigClangErrorMsg_delete(ptr: [*]Stage2ErrorMsg, len: usize) void; - -pub extern fn ZigClangLoadFromCommandLine( +pub const LoadFromCommandLine = ZigClangLoadFromCommandLine; +extern fn ZigClangLoadFromCommandLine( args_begin: [*]?[*]const u8, args_end: [*]?[*]const u8, errors_ptr: *[*]Stage2ErrorMsg, errors_len: *usize, resources_path: [*:0]const u8, -) ?*ZigClangASTUnit; - -pub extern fn ZigClangDecl_getKind(decl: *const ZigClangDecl) ZigClangDeclKind; -pub extern fn ZigClangDecl_getDeclKindName(decl: *const ZigClangDecl) [*:0]const u8; - -pub const ZigClangCompoundStmt_const_body_iterator = [*]const *ZigClangStmt; - -pub extern fn ZigClangCompoundStmt_body_begin(self: *const ZigClangCompoundStmt) ZigClangCompoundStmt_const_body_iterator; -pub extern fn ZigClangCompoundStmt_body_end(self: *const ZigClangCompoundStmt) ZigClangCompoundStmt_const_body_iterator; - -pub const ZigClangDeclStmt_const_decl_iterator = [*]const *ZigClangDecl; - -pub extern fn ZigClangDeclStmt_decl_begin(self: *const ZigClangDeclStmt) ZigClangDeclStmt_const_decl_iterator; -pub extern fn ZigClangDeclStmt_decl_end(self: *const ZigClangDeclStmt) ZigClangDeclStmt_const_decl_iterator; - -pub extern fn ZigClangVarDecl_getLocation(self: *const struct_ZigClangVarDecl) ZigClangSourceLocation; -pub extern fn ZigClangVarDecl_hasInit(self: *const struct_ZigClangVarDecl) bool; -pub extern fn ZigClangVarDecl_getStorageClass(self: *const ZigClangVarDecl) ZigClangStorageClass; -pub extern fn ZigClangVarDecl_getType(self: ?*const struct_ZigClangVarDecl) struct_ZigClangQualType; -pub extern fn ZigClangVarDecl_getInit(*const ZigClangVarDecl) ?*const ZigClangExpr; -pub extern fn ZigClangVarDecl_getTLSKind(self: ?*const struct_ZigClangVarDecl) ZigClangVarDecl_TLSKind; -pub const ZigClangVarDecl_TLSKind = extern enum { - None, - Static, - Dynamic, -}; - -pub extern fn ZigClangImplicitCastExpr_getBeginLoc(*const ZigClangImplicitCastExpr) ZigClangSourceLocation; -pub extern fn ZigClangImplicitCastExpr_getCastKind(*const ZigClangImplicitCastExpr) ZigClangCK; -pub extern fn ZigClangImplicitCastExpr_getSubExpr(*const ZigClangImplicitCastExpr) *const ZigClangExpr; - -pub extern fn ZigClangArrayType_getElementType(*const ZigClangArrayType) ZigClangQualType; -pub extern fn ZigClangIncompleteArrayType_getElementType(*const ZigClangIncompleteArrayType) ZigClangQualType; - -pub extern fn ZigClangConstantArrayType_getElementType(self: *const struct_ZigClangConstantArrayType) ZigClangQualType; -pub extern fn ZigClangConstantArrayType_getSize(self: *const struct_ZigClangConstantArrayType) *const struct_ZigClangAPInt; -pub extern fn ZigClangDeclRefExpr_getDecl(*const ZigClangDeclRefExpr) *const ZigClangValueDecl; -pub extern fn ZigClangDeclRefExpr_getFoundDecl(*const ZigClangDeclRefExpr) *const ZigClangNamedDecl; - -pub extern fn ZigClangParenType_getInnerType(*const ZigClangParenType) ZigClangQualType; - -pub extern fn ZigClangElaboratedType_getNamedType(*const ZigClangElaboratedType) ZigClangQualType; - -pub extern fn ZigClangAttributedType_getEquivalentType(*const ZigClangAttributedType) ZigClangQualType; - -pub extern fn ZigClangMacroQualifiedType_getModifiedType(*const ZigClangMacroQualifiedType) ZigClangQualType; - -pub extern fn ZigClangCStyleCastExpr_getBeginLoc(*const ZigClangCStyleCastExpr) ZigClangSourceLocation; -pub extern fn ZigClangCStyleCastExpr_getSubExpr(*const ZigClangCStyleCastExpr) *const ZigClangExpr; -pub extern fn ZigClangCStyleCastExpr_getType(*const ZigClangCStyleCastExpr) ZigClangQualType; - -pub const ZigClangExprEvalResult = struct_ZigClangExprEvalResult; -pub const struct_ZigClangExprEvalResult = extern struct { - HasSideEffects: bool, - HasUndefinedBehavior: bool, - SmallVectorImpl: ?*c_void, - Val: ZigClangAPValue, -}; - -pub const struct_ZigClangAPValue = extern struct { - Kind: ZigClangAPValueKind, - Data: if (builtin.os.tag == .windows and builtin.abi == .msvc) [52]u8 else [68]u8, -}; -pub extern fn ZigClangVarDecl_getTypeSourceInfo_getType(self: *const struct_ZigClangVarDecl) struct_ZigClangQualType; - -pub extern fn ZigClangIntegerLiteral_EvaluateAsInt(*const ZigClangIntegerLiteral, *ZigClangExprEvalResult, *const ZigClangASTContext) bool; -pub extern fn ZigClangIntegerLiteral_getBeginLoc(*const ZigClangIntegerLiteral) ZigClangSourceLocation; -pub extern fn ZigClangIntegerLiteral_isZero(*const ZigClangIntegerLiteral, *bool, *const ZigClangASTContext) bool; - -pub extern fn ZigClangReturnStmt_getRetValue(*const ZigClangReturnStmt) ?*const ZigClangExpr; - -pub extern fn ZigClangBinaryOperator_getOpcode(*const ZigClangBinaryOperator) ZigClangBO; -pub extern fn ZigClangBinaryOperator_getBeginLoc(*const ZigClangBinaryOperator) ZigClangSourceLocation; -pub extern fn ZigClangBinaryOperator_getLHS(*const ZigClangBinaryOperator) *const ZigClangExpr; -pub extern fn ZigClangBinaryOperator_getRHS(*const ZigClangBinaryOperator) *const ZigClangExpr; -pub extern fn ZigClangBinaryOperator_getType(*const ZigClangBinaryOperator) ZigClangQualType; - -pub extern fn ZigClangDecayedType_getDecayedType(*const ZigClangDecayedType) ZigClangQualType; - -pub extern fn ZigClangStringLiteral_getKind(*const ZigClangStringLiteral) ZigClangStringLiteral_StringKind; -pub extern fn ZigClangStringLiteral_getString_bytes_begin_size(*const ZigClangStringLiteral, *usize) [*]const u8; - -pub extern fn ZigClangParenExpr_getSubExpr(*const ZigClangParenExpr) *const ZigClangExpr; - -pub extern fn ZigClangFieldDecl_isAnonymousStructOrUnion(*const struct_ZigClangFieldDecl) bool; -pub extern fn ZigClangFieldDecl_isBitField(*const struct_ZigClangFieldDecl) bool; -pub extern fn ZigClangFieldDecl_getType(*const struct_ZigClangFieldDecl) struct_ZigClangQualType; -pub extern fn ZigClangFieldDecl_getLocation(*const struct_ZigClangFieldDecl) struct_ZigClangSourceLocation; - -pub extern fn ZigClangEnumConstantDecl_getInitExpr(*const ZigClangEnumConstantDecl) ?*const ZigClangExpr; -pub extern fn ZigClangEnumConstantDecl_getInitVal(*const ZigClangEnumConstantDecl) *const ZigClangAPSInt; - -pub extern fn ZigClangASTUnit_getLocalPreprocessingEntities_begin(*ZigClangASTUnit) ZigClangPreprocessingRecord_iterator; -pub extern fn ZigClangASTUnit_getLocalPreprocessingEntities_end(*ZigClangASTUnit) ZigClangPreprocessingRecord_iterator; -pub extern fn ZigClangPreprocessingRecord_iterator_deref(ZigClangPreprocessingRecord_iterator) *ZigClangPreprocessedEntity; -pub extern fn ZigClangPreprocessedEntity_getKind(*const ZigClangPreprocessedEntity) ZigClangPreprocessedEntity_EntityKind; - -pub extern fn ZigClangMacroDefinitionRecord_getName_getNameStart(*const ZigClangMacroDefinitionRecord) [*:0]const u8; -pub extern fn ZigClangMacroDefinitionRecord_getSourceRange_getBegin(*const ZigClangMacroDefinitionRecord) ZigClangSourceLocation; -pub extern fn ZigClangMacroDefinitionRecord_getSourceRange_getEnd(*const ZigClangMacroDefinitionRecord) ZigClangSourceLocation; - -pub extern fn ZigClangMacroExpansion_getDefinition(*const ZigClangMacroExpansion) *const ZigClangMacroDefinitionRecord; - -pub extern fn ZigClangIfStmt_getThen(*const ZigClangIfStmt) *const ZigClangStmt; -pub extern fn ZigClangIfStmt_getElse(*const ZigClangIfStmt) ?*const ZigClangStmt; -pub extern fn ZigClangIfStmt_getCond(*const ZigClangIfStmt) *const ZigClangStmt; - -pub extern fn ZigClangWhileStmt_getCond(*const ZigClangWhileStmt) *const ZigClangExpr; -pub extern fn ZigClangWhileStmt_getBody(*const ZigClangWhileStmt) *const ZigClangStmt; - -pub extern fn ZigClangDoStmt_getCond(*const ZigClangDoStmt) *const ZigClangExpr; -pub extern fn ZigClangDoStmt_getBody(*const ZigClangDoStmt) *const ZigClangStmt; - -pub extern fn ZigClangForStmt_getInit(*const ZigClangForStmt) ?*const ZigClangStmt; -pub extern fn ZigClangForStmt_getCond(*const ZigClangForStmt) ?*const ZigClangExpr; -pub extern fn ZigClangForStmt_getInc(*const ZigClangForStmt) ?*const ZigClangExpr; -pub extern fn ZigClangForStmt_getBody(*const ZigClangForStmt) *const ZigClangStmt; - -pub extern fn ZigClangAPFloat_toString(self: *const ZigClangAPFloat, precision: c_uint, maxPadding: c_uint, truncateZero: bool) [*:0]const u8; -pub extern fn ZigClangAPFloat_getValueAsApproximateDouble(*const ZigClangFloatingLiteral) f64; - -pub extern fn ZigClangAbstractConditionalOperator_getCond(*const ZigClangAbstractConditionalOperator) *const ZigClangExpr; -pub extern fn ZigClangAbstractConditionalOperator_getTrueExpr(*const ZigClangAbstractConditionalOperator) *const ZigClangExpr; -pub extern fn ZigClangAbstractConditionalOperator_getFalseExpr(*const ZigClangAbstractConditionalOperator) *const ZigClangExpr; - -pub extern fn ZigClangSwitchStmt_getConditionVariableDeclStmt(*const ZigClangSwitchStmt) ?*const ZigClangDeclStmt; -pub extern fn ZigClangSwitchStmt_getCond(*const ZigClangSwitchStmt) *const ZigClangExpr; -pub extern fn ZigClangSwitchStmt_getBody(*const ZigClangSwitchStmt) *const ZigClangStmt; -pub extern fn ZigClangSwitchStmt_isAllEnumCasesCovered(*const ZigClangSwitchStmt) bool; - -pub extern fn ZigClangCaseStmt_getLHS(*const ZigClangCaseStmt) *const ZigClangExpr; -pub extern fn ZigClangCaseStmt_getRHS(*const ZigClangCaseStmt) ?*const ZigClangExpr; -pub extern fn ZigClangCaseStmt_getBeginLoc(*const ZigClangCaseStmt) ZigClangSourceLocation; -pub extern fn ZigClangCaseStmt_getSubStmt(*const ZigClangCaseStmt) *const ZigClangStmt; - -pub extern fn ZigClangDefaultStmt_getSubStmt(*const ZigClangDefaultStmt) *const ZigClangStmt; - -pub extern fn ZigClangExpr_EvaluateAsConstantExpr(*const ZigClangExpr, *ZigClangExprEvalResult, ZigClangExpr_ConstExprUsage, *const ZigClangASTContext) bool; - -pub extern fn ZigClangPredefinedExpr_getFunctionName(*const ZigClangPredefinedExpr) *const ZigClangStringLiteral; - -pub extern fn ZigClangCharacterLiteral_getBeginLoc(*const ZigClangCharacterLiteral) ZigClangSourceLocation; -pub extern fn ZigClangCharacterLiteral_getKind(*const ZigClangCharacterLiteral) ZigClangCharacterLiteral_CharacterKind; -pub extern fn ZigClangCharacterLiteral_getValue(*const ZigClangCharacterLiteral) c_uint; - -pub extern fn ZigClangStmtExpr_getSubStmt(*const ZigClangStmtExpr) *const ZigClangCompoundStmt; - -pub extern fn ZigClangMemberExpr_getBase(*const ZigClangMemberExpr) *const ZigClangExpr; -pub extern fn ZigClangMemberExpr_isArrow(*const ZigClangMemberExpr) bool; -pub extern fn ZigClangMemberExpr_getMemberDecl(*const ZigClangMemberExpr) *const ZigClangValueDecl; - -pub extern fn ZigClangArraySubscriptExpr_getBase(*const ZigClangArraySubscriptExpr) *const ZigClangExpr; -pub extern fn ZigClangArraySubscriptExpr_getIdx(*const ZigClangArraySubscriptExpr) *const ZigClangExpr; - -pub extern fn ZigClangCallExpr_getCallee(*const ZigClangCallExpr) *const ZigClangExpr; -pub extern fn ZigClangCallExpr_getNumArgs(*const ZigClangCallExpr) c_uint; -pub extern fn ZigClangCallExpr_getArgs(*const ZigClangCallExpr) [*]const *const ZigClangExpr; - -pub extern fn ZigClangUnaryExprOrTypeTraitExpr_getTypeOfArgument(*const ZigClangUnaryExprOrTypeTraitExpr) ZigClangQualType; -pub extern fn ZigClangUnaryExprOrTypeTraitExpr_getBeginLoc(*const ZigClangUnaryExprOrTypeTraitExpr) ZigClangSourceLocation; -pub extern fn ZigClangUnaryExprOrTypeTraitExpr_getKind(*const ZigClangUnaryExprOrTypeTraitExpr) ZigClangUnaryExprOrTypeTrait_Kind; - -pub extern fn ZigClangUnaryOperator_getOpcode(*const ZigClangUnaryOperator) ZigClangUO; -pub extern fn ZigClangUnaryOperator_getType(*const ZigClangUnaryOperator) ZigClangQualType; -pub extern fn ZigClangUnaryOperator_getSubExpr(*const ZigClangUnaryOperator) *const ZigClangExpr; -pub extern fn ZigClangUnaryOperator_getBeginLoc(*const ZigClangUnaryOperator) ZigClangSourceLocation; - -pub extern fn ZigClangOpaqueValueExpr_getSourceExpr(*const ZigClangOpaqueValueExpr) ?*const ZigClangExpr; - -pub extern fn ZigClangCompoundAssignOperator_getType(*const ZigClangCompoundAssignOperator) ZigClangQualType; -pub extern fn ZigClangCompoundAssignOperator_getComputationLHSType(*const ZigClangCompoundAssignOperator) ZigClangQualType; -pub extern fn ZigClangCompoundAssignOperator_getComputationResultType(*const ZigClangCompoundAssignOperator) ZigClangQualType; -pub extern fn ZigClangCompoundAssignOperator_getBeginLoc(*const ZigClangCompoundAssignOperator) ZigClangSourceLocation; -pub extern fn ZigClangCompoundAssignOperator_getOpcode(*const ZigClangCompoundAssignOperator) ZigClangBO; -pub extern fn ZigClangCompoundAssignOperator_getLHS(*const ZigClangCompoundAssignOperator) *const ZigClangExpr; -pub extern fn ZigClangCompoundAssignOperator_getRHS(*const ZigClangCompoundAssignOperator) *const ZigClangExpr; +) ?*ASTUnit; diff --git a/src/clang_options_data.zig b/src/clang_options_data.zig index 5a3e3a0e87..09646b8c22 100644 --- a/src/clang_options_data.zig +++ b/src/clang_options_data.zig @@ -76,8 +76,22 @@ flagpd1("M"), .psl = false, }, flagpd1("Mach"), -flagpd1("O0"), -flagpd1("O4"), +.{ + .name = "O0", + .syntax = .flag, + .zig_equivalent = .optimize, + .pd1 = true, + .pd2 = false, + .psl = false, +}, +.{ + .name = "O4", + .syntax = .flag, + .zig_equivalent = .optimize, + .pd1 = true, + .pd2 = false, + .psl = false, +}, .{ .name = "O", .syntax = .flag, @@ -2186,7 +2200,7 @@ flagpd1("fcuda-rdc"), .{ .name = "Os", .syntax = .flag, - .zig_equivalent = .other, + .zig_equivalent = .optimize, .pd1 = true, .pd2 = false, .psl = true, @@ -3377,7 +3391,14 @@ flagpd1("fxray-link-deps"), flagpd1("fzero-initialized-in-bss"), flagpd1("fzvector"), flagpd1("g0"), -flagpd1("g1"), +.{ + .name = "g1", + .syntax = .flag, + .zig_equivalent = .debug, + .pd1 = true, + .pd2 = false, + .psl = false, +}, flagpd1("g2"), flagpd1("g3"), .{ @@ -3410,7 +3431,14 @@ flagpd1("ggdb3"), flagpd1("ggnu-pubnames"), flagpd1("ginline-line-tables"), flagpd1("gline-directives-only"), -flagpd1("gline-tables-only"), +.{ + .name = "gline-tables-only", + .syntax = .flag, + .zig_equivalent = .debug, + .pd1 = true, + .pd2 = false, + .psl = false, +}, flagpd1("glldb"), flagpd1("gmlt"), flagpd1("gmodules"), @@ -5535,7 +5563,7 @@ jspd1("iquote"), joinpd1("weak-l"), .{ .name = "Ofast", - .syntax = .joined, + .syntax = .flag, .zig_equivalent = .optimize, .pd1 = true, .pd2 = false, diff --git a/src/link/MachO.zig b/src/link/MachO.zig index 68307a5fc6..a1b9484e13 100644 --- a/src/link/MachO.zig +++ b/src/link/MachO.zig @@ -287,9 +287,6 @@ pub fn flushModule(self: *MachO, comp: *Compilation) !void { } const cmd = &self.load_commands.items[self.dylinker_cmd_index.?].Dylinker; off += cmd.name; - const padding = cmd.cmdsize - @sizeOf(macho.dylinker_command); - log.debug("writing LC_LOAD_DYLINKER padding of size {} at 0x{x}\n", .{ padding, off }); - try self.addPadding(padding, off); log.debug("writing LC_LOAD_DYLINKER path to dyld at 0x{x}\n", .{off}); try self.base.file.?.pwriteAll(mem.spanZ(DEFAULT_DYLD_PATH), off); } @@ -302,9 +299,6 @@ pub fn flushModule(self: *MachO, comp: *Compilation) !void { } const cmd = &self.load_commands.items[self.libsystem_cmd_index.?].Dylib; off += cmd.dylib.name; - const padding = cmd.cmdsize - @sizeOf(macho.dylib_command); - log.debug("writing LC_LOAD_DYLIB padding of size {} at 0x{x}\n", .{ padding, off }); - try self.addPadding(padding, off); log.debug("writing LC_LOAD_DYLIB path to libSystem at 0x{x}\n", .{off}); try self.base.file.?.pwriteAll(mem.spanZ(LIB_SYSTEM_PATH), off); } @@ -1264,21 +1258,6 @@ fn updateString(self: *MachO, old_str_off: u32, new_name: []const u8) !u32 { return self.makeString(new_name); } -/// TODO This should not heap allocate, instead it should utilize a fixed size, statically allocated -/// global const array. You could even use pwritev to write the same buffer multiple times with only -/// 1 syscall if you needed to, for example, write 8192 bytes using a buffer of only 4096 bytes. -/// This size parameter should probably be a usize not u64. -fn addPadding(self: *MachO, size: u64, file_offset: u64) !void { - if (size == 0) return; - - const buf = try self.base.allocator.alloc(u8, @intCast(usize, size)); - defer self.base.allocator.free(buf); - - mem.set(u8, buf[0..], 0); - - try self.base.file.?.pwriteAll(buf, file_offset); -} - fn detectAllocCollision(self: *MachO, start: u64, size: u64) ?u64 { const hdr_size: u64 = @sizeOf(macho.mach_header_64); if (start < hdr_size) return hdr_size; diff --git a/src/main.zig b/src/main.zig index b89ac3768e..8a3fb72102 100644 --- a/src/main.zig +++ b/src/main.zig @@ -992,15 +992,20 @@ fn buildOutputType( }, .optimize => { // Alright, what release mode do they want? - if (mem.eql(u8, it.only_arg, "Os")) { + const level = if (it.only_arg.len >= 1 and it.only_arg[0] == 'O') it.only_arg[1..] else it.only_arg; + if (mem.eql(u8, level, "s") or + mem.eql(u8, level, "z")) + { optimize_mode = .ReleaseSmall; - } else if (mem.eql(u8, it.only_arg, "O2") or - mem.eql(u8, it.only_arg, "O3") or - mem.eql(u8, it.only_arg, "O4")) + } else if (mem.eql(u8, level, "1") or + mem.eql(u8, level, "2") or + mem.eql(u8, level, "3") or + mem.eql(u8, level, "4") or + mem.eql(u8, level, "fast")) { optimize_mode = .ReleaseFast; - } else if (mem.eql(u8, it.only_arg, "Og") or - mem.eql(u8, it.only_arg, "O0")) + } else if (mem.eql(u8, level, "g") or + mem.eql(u8, level, "0")) { optimize_mode = .Debug; } else { @@ -1009,8 +1014,13 @@ fn buildOutputType( }, .debug => { strip = false; - if (mem.eql(u8, it.only_arg, "-g")) { + if (mem.eql(u8, it.only_arg, "g")) { // We handled with strip = false above. + } else if (mem.eql(u8, it.only_arg, "g1") or + mem.eql(u8, it.only_arg, "gline-tables-only")) + { + // We handled with strip = false above. but we also want reduced debug info. + try clang_argv.append("-gline-tables-only"); } else { try clang_argv.appendSlice(it.other_args); } diff --git a/src/stage1/all_types.hpp b/src/stage1/all_types.hpp index c9d7755942..89f3693a13 100644 --- a/src/stage1/all_types.hpp +++ b/src/stage1/all_types.hpp @@ -72,7 +72,6 @@ enum PtrLen { enum CallingConvention { CallingConventionUnspecified, CallingConventionC, - CallingConventionCold, CallingConventionNaked, CallingConventionAsync, CallingConventionInterrupt, @@ -1054,6 +1053,7 @@ enum ContainerKind { ContainerKindStruct, ContainerKindEnum, ContainerKindUnion, + ContainerKindOpaque, }; enum ContainerLayout { @@ -1571,7 +1571,10 @@ enum OnePossibleValue { }; struct ZigTypeOpaque { + AstNode *decl_node; Buf *bare_name; + + ScopeDecls *decls_scope; }; struct ZigTypeFnFrame { diff --git a/src/stage1/analyze.cpp b/src/stage1/analyze.cpp index 99af1db098..fb1360727c 100644 --- a/src/stage1/analyze.cpp +++ b/src/stage1/analyze.cpp @@ -86,14 +86,18 @@ ZigType *new_type_table_entry(ZigTypeId id) { } static ScopeDecls **get_container_scope_ptr(ZigType *type_entry) { - if (type_entry->id == ZigTypeIdStruct) { - return &type_entry->data.structure.decls_scope; - } else if (type_entry->id == ZigTypeIdEnum) { - return &type_entry->data.enumeration.decls_scope; - } else if (type_entry->id == ZigTypeIdUnion) { - return &type_entry->data.unionation.decls_scope; + switch (type_entry->id) { + case ZigTypeIdStruct: + return &type_entry->data.structure.decls_scope; + case ZigTypeIdEnum: + return &type_entry->data.enumeration.decls_scope; + case ZigTypeIdUnion: + return &type_entry->data.unionation.decls_scope; + case ZigTypeIdOpaque: + return &type_entry->data.opaque.decls_scope; + default: + zig_unreachable(); } - zig_unreachable(); } static ScopeExpr *find_expr_scope(Scope *scope) { @@ -912,13 +916,17 @@ ZigType *get_opaque_type(CodeGen *g, Scope *scope, AstNode *source_node, const c ZigType *import = scope ? get_scope_import(scope) : nullptr; unsigned line = source_node ? (unsigned)(source_node->line + 1) : 0; + // Note: duplicated in get_partial_container_type entry->llvm_type = LLVMInt8Type(); entry->llvm_di_type = ZigLLVMCreateDebugForwardDeclType(g->dbuilder, ZigLLVMTag_DW_structure_type(), full_name, import ? ZigLLVMFileToScope(import->data.structure.root_struct->di_file) : nullptr, import ? import->data.structure.root_struct->di_file : nullptr, line); + entry->data.opaque.decl_node = source_node; entry->data.opaque.bare_name = bare_name; + entry->data.opaque.decls_scope = create_decls_scope( + g, source_node, scope, entry, import, &entry->name); // The actual size is unknown, but the value must not be 0 because that // is how type_has_bits is determined. @@ -949,7 +957,6 @@ const char *calling_convention_name(CallingConvention cc) { switch (cc) { case CallingConventionUnspecified: return "Unspecified"; case CallingConventionC: return "C"; - case CallingConventionCold: return "Cold"; case CallingConventionNaked: return "Naked"; case CallingConventionAsync: return "Async"; case CallingConventionInterrupt: return "Interrupt"; @@ -971,7 +978,6 @@ bool calling_convention_allows_zig_types(CallingConvention cc) { case CallingConventionAsync: return true; case CallingConventionC: - case CallingConventionCold: case CallingConventionNaked: case CallingConventionInterrupt: case CallingConventionSignal: @@ -1080,6 +1086,8 @@ static ZigTypeId container_to_type(ContainerKind kind) { return ZigTypeIdEnum; case ContainerKindUnion: return ZigTypeIdUnion; + case ContainerKindOpaque: + return ZigTypeIdOpaque; } zig_unreachable(); } @@ -1121,6 +1129,22 @@ ZigType *get_partial_container_type(CodeGen *g, Scope *scope, ContainerKind kind entry->data.unionation.decl_node = decl_node; entry->data.unionation.layout = layout; break; + case ContainerKindOpaque: { + ZigType *import = scope ? get_scope_import(scope) : nullptr; + unsigned line = decl_node ? (unsigned)(decl_node->line + 1) : 0; + // Note: duplicated in get_opaque_type + entry->llvm_type = LLVMInt8Type(); + entry->llvm_di_type = ZigLLVMCreateDebugForwardDeclType(g->dbuilder, + ZigLLVMTag_DW_structure_type(), full_name, + import ? ZigLLVMFileToScope(import->data.structure.root_struct->di_file) : nullptr, + import ? import->data.structure.root_struct->di_file : nullptr, + line); + entry->data.opaque.decl_node = decl_node; + entry->abi_size = SIZE_MAX; + entry->size_in_bits = SIZE_MAX; + entry->abi_align = 1; + break; + } } buf_init_from_str(&entry->name, full_name); @@ -1730,7 +1754,7 @@ static Error emit_error_unless_type_allowed_in_packed_union(CodeGen *g, ZigType return emit_error_unless_type_allowed_in_packed_container(g, type_entry, source_node, "union"); } -Error type_allowed_in_extern(CodeGen *g, ZigType *type_entry, bool *result) { +Error type_allowed_in_extern(CodeGen *g, ZigType *type_entry, ExternPosition position, bool *result) { Error err; switch (type_entry->id) { case ZigTypeIdInvalid: @@ -1749,8 +1773,10 @@ Error type_allowed_in_extern(CodeGen *g, ZigType *type_entry, bool *result) { case ZigTypeIdAnyFrame: *result = false; return ErrorNone; - case ZigTypeIdOpaque: case ZigTypeIdUnreachable: + *result = position == ExternPositionFunctionReturn; + return ErrorNone; + case ZigTypeIdOpaque: case ZigTypeIdBool: *result = true; return ErrorNone; @@ -1768,23 +1794,27 @@ Error type_allowed_in_extern(CodeGen *g, ZigType *type_entry, bool *result) { return ErrorNone; } case ZigTypeIdVector: - return type_allowed_in_extern(g, type_entry->data.vector.elem_type, result); + return type_allowed_in_extern(g, type_entry->data.vector.elem_type, ExternPositionOther, result); case ZigTypeIdFloat: *result = true; return ErrorNone; case ZigTypeIdArray: - return type_allowed_in_extern(g, type_entry->data.array.child_type, result); + if ((err = type_allowed_in_extern(g, type_entry->data.array.child_type, ExternPositionOther, result))) + return err; + *result = *result && + position != ExternPositionFunctionParameter && + position != ExternPositionFunctionReturn; + return ErrorNone; case ZigTypeIdFn: *result = !calling_convention_allows_zig_types(type_entry->data.fn.fn_type_id.cc); return ErrorNone; case ZigTypeIdPointer: if ((err = type_resolve(g, type_entry, ResolveStatusZeroBitsKnown))) return err; - if (!type_has_bits(g, type_entry)) { - *result = false; - return ErrorNone; - } - *result = true; + bool has_bits; + if ((err = type_has_bits2(g, type_entry, &has_bits))) + return err; + *result = has_bits; return ErrorNone; case ZigTypeIdStruct: *result = type_entry->data.structure.layout == ContainerLayoutExtern || @@ -1796,23 +1826,24 @@ Error type_allowed_in_extern(CodeGen *g, ZigType *type_entry, bool *result) { *result = false; return ErrorNone; } - if (!type_is_nonnull_ptr(g, child_type)) { + bool is_nonnull_ptr; + if ((err = type_is_nonnull_ptr2(g, child_type, &is_nonnull_ptr))) + return err; + if (!is_nonnull_ptr) { *result = false; return ErrorNone; } - return type_allowed_in_extern(g, child_type, result); + return type_allowed_in_extern(g, child_type, ExternPositionOther, result); } case ZigTypeIdEnum: { if ((err = type_resolve(g, type_entry, ResolveStatusZeroBitsKnown))) return err; ZigType *tag_int_type = type_entry->data.enumeration.tag_int_type; - if (type_entry->data.enumeration.has_explicit_tag_type) { - return type_allowed_in_extern(g, tag_int_type, result); - } else { - *result = type_entry->data.enumeration.layout == ContainerLayoutExtern || - type_entry->data.enumeration.layout == ContainerLayoutPacked; - return ErrorNone; - } + if (type_entry->data.enumeration.has_explicit_tag_type) + return type_allowed_in_extern(g, tag_int_type, position, result); + *result = type_entry->data.enumeration.layout == ContainerLayoutExtern || + type_entry->data.enumeration.layout == ContainerLayoutPacked; + return ErrorNone; } case ZigTypeIdUnion: *result = type_entry->data.unionation.layout == ContainerLayoutExtern || @@ -1909,7 +1940,7 @@ static ZigType *analyze_fn_type(CodeGen *g, AstNode *proto_node, Scope *child_sc if (!calling_convention_allows_zig_types(fn_type_id.cc)) { bool ok_type; - if ((err = type_allowed_in_extern(g, type_entry, &ok_type))) + if ((err = type_allowed_in_extern(g, type_entry, ExternPositionFunctionParameter, &ok_type))) return g->builtin_types.entry_invalid; if (!ok_type) { add_node_error(g, param_node->data.param_decl.type, @@ -2014,7 +2045,7 @@ static ZigType *analyze_fn_type(CodeGen *g, AstNode *proto_node, Scope *child_sc if ((err = type_resolve(g, fn_type_id.return_type, ResolveStatusSizeKnown))) return g->builtin_types.entry_invalid; bool ok_type; - if ((err = type_allowed_in_extern(g, fn_type_id.return_type, &ok_type))) + if ((err = type_allowed_in_extern(g, fn_type_id.return_type, ExternPositionFunctionReturn, &ok_type))) return g->builtin_types.entry_invalid; if (!ok_type) { add_node_error(g, fn_proto->return_type, @@ -2333,7 +2364,7 @@ static Error resolve_struct_type(CodeGen *g, ZigType *struct_type) { if (struct_type->data.structure.layout == ContainerLayoutExtern) { bool ok_type; - if ((err = type_allowed_in_extern(g, field_type, &ok_type))) { + if ((err = type_allowed_in_extern(g, field_type, ExternPositionOther, &ok_type))) { struct_type->data.structure.resolve_status = ResolveStatusInvalid; return ErrorSemanticAnalyzeFail; } @@ -2588,7 +2619,7 @@ static Error type_is_valid_extern_enum_tag(CodeGen *g, ZigType *ty, bool *result // signed char, a signed integer or an unsigned one. But GCC/Clang allow // other integral types as a compiler extension so let's accomodate them // aswell. - return type_allowed_in_extern(g, ty, result); + return type_allowed_in_extern(g, ty, ExternPositionOther, result); } static Error resolve_enum_zero_bits(CodeGen *g, ZigType *enum_type) { @@ -3430,6 +3461,21 @@ static Error resolve_union_zero_bits(CodeGen *g, ZigType *union_type) { return ErrorNone; } +static Error resolve_opaque_type(CodeGen *g, ZigType *opaque_type) { + Error err = ErrorNone; + AstNode *container_node = opaque_type->data.opaque.decl_node; + if (container_node != nullptr) { + assert(container_node->type == NodeTypeContainerDecl); + AstNodeContainerDecl *container_decl = &container_node->data.container_decl; + for (size_t i = 0; i < container_decl->fields.length; i++) { + AstNode *field_node = container_decl->fields.items[i]; + add_node_error(g, field_node, buf_create_from_str("opaque types cannot have fields")); + err = ErrorSemanticAnalyzeFail; + } + } + return err; +} + void append_namespace_qualification(CodeGen *g, Buf *buf, ZigType *container_type) { if (g->root_import == container_type || buf_len(&container_type->name) == 0) return; buf_append_buf(buf, &container_type->name); @@ -3603,7 +3649,6 @@ static void resolve_decl_fn(CodeGen *g, TldFn *tld_fn) { tld_fn->base.resolution = TldResolutionInvalid; return; case CallingConventionC: - case CallingConventionCold: case CallingConventionNaked: case CallingConventionInterrupt: case CallingConventionSignal: @@ -3896,6 +3941,8 @@ static Error resolve_decl_container(CodeGen *g, TldContainer *tld_container) { return resolve_enum_zero_bits(g, tld_container->type_entry); case ZigTypeIdUnion: return resolve_union_type(g, tld_container->type_entry); + case ZigTypeIdOpaque: + return resolve_opaque_type(g, tld_container->type_entry); default: zig_unreachable(); } @@ -4462,6 +4509,7 @@ bool is_container(ZigType *type_entry) { return type_entry->data.structure.special != StructSpecialSlice; case ZigTypeIdEnum: case ZigTypeIdUnion: + case ZigTypeIdOpaque: return true; case ZigTypeIdPointer: case ZigTypeIdMetaType: @@ -4481,7 +4529,6 @@ bool is_container(ZigType *type_entry) { case ZigTypeIdErrorSet: case ZigTypeIdFn: case ZigTypeIdBoundFn: - case ZigTypeIdOpaque: case ZigTypeIdVector: case ZigTypeIdFnFrame: case ZigTypeIdAnyFrame: @@ -8168,6 +8215,7 @@ const char *container_string(ContainerKind kind) { case ContainerKindEnum: return "enum"; case ContainerKindStruct: return "struct"; case ContainerKindUnion: return "union"; + case ContainerKindOpaque: return "opaque"; } zig_unreachable(); } @@ -8186,8 +8234,6 @@ Buf *type_bare_name(ZigType *type_entry) { return &type_entry->name; } else if (is_container(type_entry)) { return get_container_scope(type_entry)->bare_name; - } else if (type_entry->id == ZigTypeIdOpaque) { - return type_entry->data.opaque.bare_name; } else { return &type_entry->name; } diff --git a/src/stage1/analyze.hpp b/src/stage1/analyze.hpp index 07601e6dea..d7a67826d5 100644 --- a/src/stage1/analyze.hpp +++ b/src/stage1/analyze.hpp @@ -50,7 +50,13 @@ bool handle_is_ptr(CodeGen *g, ZigType *type_entry); bool type_has_bits(CodeGen *g, ZigType *type_entry); Error type_has_bits2(CodeGen *g, ZigType *type_entry, bool *result); -Error type_allowed_in_extern(CodeGen *g, ZigType *type_entry, bool *result); +enum ExternPosition { + ExternPositionFunctionParameter, + ExternPositionFunctionReturn, + ExternPositionOther, // array element, struct field, optional element, etc +}; + +Error type_allowed_in_extern(CodeGen *g, ZigType *type_entry, ExternPosition position, bool *result); bool ptr_allows_addr_zero(ZigType *ptr_type); // Deprecated, use `type_is_nonnull_ptr2` diff --git a/src/stage1/codegen.cpp b/src/stage1/codegen.cpp index 9551edf3c0..9ed2ba9d73 100644 --- a/src/stage1/codegen.cpp +++ b/src/stage1/codegen.cpp @@ -161,12 +161,6 @@ static ZigLLVM_CallingConv get_llvm_cc(CodeGen *g, CallingConvention cc) { return ZigLLVM_Fast; case CallingConventionC: return ZigLLVM_C; - case CallingConventionCold: - if ((g->zig_target->arch == ZigLLVM_x86 || - g->zig_target->arch == ZigLLVM_x86_64) && - g->zig_target->os != OsWindows) - return ZigLLVM_Cold; - return ZigLLVM_C; case CallingConventionNaked: zig_unreachable(); case CallingConventionStdcall: @@ -340,7 +334,6 @@ static bool cc_want_sret_attr(CallingConvention cc) { case CallingConventionNaked: zig_unreachable(); case CallingConventionC: - case CallingConventionCold: case CallingConventionInterrupt: case CallingConventionSignal: case CallingConventionStdcall: @@ -449,7 +442,7 @@ static LLVMValueRef make_fn_llvm_value(CodeGen *g, ZigFn *fn) { ZigLLVMFunctionSetCallingConv(llvm_fn, get_llvm_cc(g, cc)); } - bool want_cold = fn->is_cold || cc == CallingConventionCold; + bool want_cold = fn->is_cold; if (want_cold) { ZigLLVMAddFunctionAttrCold(llvm_fn); } @@ -8819,18 +8812,17 @@ Buf *codegen_generate_builtin_source(CodeGen *g) { static_assert(CallingConventionUnspecified == 0, ""); static_assert(CallingConventionC == 1, ""); - static_assert(CallingConventionCold == 2, ""); - static_assert(CallingConventionNaked == 3, ""); - static_assert(CallingConventionAsync == 4, ""); - static_assert(CallingConventionInterrupt == 5, ""); - static_assert(CallingConventionSignal == 6, ""); - static_assert(CallingConventionStdcall == 7, ""); - static_assert(CallingConventionFastcall == 8, ""); - static_assert(CallingConventionVectorcall == 9, ""); - static_assert(CallingConventionThiscall == 10, ""); - static_assert(CallingConventionAPCS == 11, ""); - static_assert(CallingConventionAAPCS == 12, ""); - static_assert(CallingConventionAAPCSVFP == 13, ""); + static_assert(CallingConventionNaked == 2, ""); + static_assert(CallingConventionAsync == 3, ""); + static_assert(CallingConventionInterrupt == 4, ""); + static_assert(CallingConventionSignal == 5, ""); + static_assert(CallingConventionStdcall == 6, ""); + static_assert(CallingConventionFastcall == 7, ""); + static_assert(CallingConventionVectorcall == 8, ""); + static_assert(CallingConventionThiscall == 9, ""); + static_assert(CallingConventionAPCS == 10, ""); + static_assert(CallingConventionAAPCS == 11, ""); + static_assert(CallingConventionAAPCSVFP == 12, ""); static_assert(FnInlineAuto == 0, ""); static_assert(FnInlineAlways == 1, ""); diff --git a/src/stage1/ir.cpp b/src/stage1/ir.cpp index d407169542..62c52c8a97 100644 --- a/src/stage1/ir.cpp +++ b/src/stage1/ir.cpp @@ -18917,7 +18917,6 @@ static IrInstGen *ir_analyze_instruction_export(IrAnalyze *ira, IrInstSrcExport add_error_note(ira->codegen, msg, fn_entry->proto_node, buf_sprintf("declared here")); } break; case CallingConventionC: - case CallingConventionCold: case CallingConventionNaked: case CallingConventionInterrupt: case CallingConventionSignal: @@ -18965,7 +18964,7 @@ static IrInstGen *ir_analyze_instruction_export(IrAnalyze *ira, IrInstSrcExport break; case ZigTypeIdArray: { bool ok_type; - if ((err = type_allowed_in_extern(ira->codegen, target->value->type->data.array.child_type, &ok_type))) + if ((err = type_allowed_in_extern(ira->codegen, target->value->type->data.array.child_type, ExternPositionOther, &ok_type))) return ira->codegen->invalid_inst_gen; if (!ok_type) { @@ -20103,7 +20102,7 @@ static IrInstGen *ir_analyze_store_ptr(IrAnalyze *ira, IrInst* source_instr, if (uncasted_value->value->type->id == ZigTypeIdErrorUnion || uncasted_value->value->type->id == ZigTypeIdErrorSet) { - ir_add_error(ira, source_instr, buf_sprintf("error is discarded")); + ir_add_error(ira, source_instr, buf_sprintf("error is discarded. consider using `try`, `catch`, or `if`")); return ira->codegen->invalid_inst_gen; } return ir_const_void(ira, source_instr); @@ -22388,6 +22387,8 @@ static IrInstGen *ir_analyze_container_member_access_inner(IrAnalyze *ira, prefix_name = "enum "; } else if (bare_struct_type->id == ZigTypeIdUnion) { prefix_name = "union "; + } else if (bare_struct_type->id == ZigTypeIdOpaque) { + prefix_name = "opaque type "; } else { prefix_name = ""; } @@ -22588,7 +22589,7 @@ static IrInstGen *ir_analyze_container_field_ptr(IrAnalyze *ira, Buf *field_name } } - if (bare_type->id == ZigTypeIdEnum) { + if (bare_type->id == ZigTypeIdEnum || bare_type->id == ZigTypeIdOpaque) { return ir_analyze_container_member_access_inner(ira, bare_type, field_name, source_instr, container_ptr, container_ptr_src, container_type); } @@ -25184,7 +25185,6 @@ static Error ir_make_type_info_value(IrAnalyze *ira, IrInst* source_instr, ZigTy case ZigTypeIdEnumLiteral: case ZigTypeIdUndefined: case ZigTypeIdNull: - case ZigTypeIdOpaque: result = ira->codegen->intern.for_void(); break; case ZigTypeIdInt: @@ -25738,6 +25738,25 @@ static Error ir_make_type_info_value(IrAnalyze *ira, IrInst* source_instr, ZigTy if ((err = ir_make_type_info_value(ira, source_instr, fn_type, &result))) return err; + break; + } + case ZigTypeIdOpaque: + { + result = ira->codegen->pass1_arena->create(); + result->special = ConstValSpecialStatic; + result->type = ir_type_info_get_type(ira, "Opaque", nullptr); + + ZigValue **fields = alloc_const_vals_ptrs(ira->codegen, 1); + result->data.x_struct.fields = fields; + + // decls: []TypeInfo.Declaration + ensure_field_index(result->type, "decls", 0); + if ((err = ir_make_type_info_decls(ira, source_instr, fields[0], + type_entry->data.opaque.decls_scope, false))) + { + return err; + } + break; } case ZigTypeIdFnFrame: @@ -26045,6 +26064,21 @@ static ZigType *type_info_to_type(IrAnalyze *ira, IrInst *source_instr, ZigTypeI return get_error_union_type(ira->codegen, err_set_type, payload_type); } case ZigTypeIdOpaque: { + assert(payload->special == ConstValSpecialStatic); + assert(payload->type == ir_type_info_get_type(ira, "Opaque", nullptr)); + + ZigValue *decls_value = get_const_field(ira, source_instr->source_node, payload, "decls", 0); + if (decls_value == nullptr) + return ira->codegen->invalid_inst_gen->value->type; + assert(decls_value->special == ConstValSpecialStatic); + assert(is_slice(decls_value->type)); + ZigValue *decls_len_value = decls_value->data.x_struct.fields[slice_len_index]; + size_t decls_len = bigint_as_usize(&decls_len_value->data.x_bigint); + if (decls_len != 0) { + ir_add_error(ira, source_instr, buf_create_from_str("TypeInfo.Struct.decls must be empty for @Type")); + return ira->codegen->invalid_inst_gen->value->type; + } + Buf *bare_name = buf_alloc(); Buf *full_name = get_anon_type_name(ira->codegen, ira->old_irb.exec, "opaque", source_instr->scope, source_instr->source_node, bare_name); @@ -29493,7 +29527,11 @@ static IrInstGen *ir_analyze_instruction_check_statement_is_void(IrAnalyze *ira, return ira->codegen->invalid_inst_gen; if (statement_type->id != ZigTypeIdVoid && statement_type->id != ZigTypeIdUnreachable) { - ir_add_error(ira, &instruction->base.base, buf_sprintf("expression value is ignored")); + if(statement_type->id == ZigTypeIdErrorUnion || statement_type->id == ZigTypeIdErrorSet) { + ir_add_error(ira, &instruction->base.base, buf_sprintf("error is ignored. consider using `try`, `catch`, or `if`")); + }else{ + ir_add_error(ira, &instruction->base.base, buf_sprintf("expression value is ignored")); + } } return ir_const_void(ira, &instruction->base.base); @@ -32708,7 +32746,7 @@ static Error ir_resolve_lazy_raw(AstNode *source_node, ZigValue *val) { return ErrorSemanticAnalyzeFail; } else if (lazy_ptr_type->ptr_len == PtrLenC) { bool ok_type; - if ((err = type_allowed_in_extern(ira->codegen, elem_type, &ok_type))) + if ((err = type_allowed_in_extern(ira->codegen, elem_type, ExternPositionOther, &ok_type))) return err; if (!ok_type) { ir_add_error(ira, &lazy_ptr_type->elem_type->base, diff --git a/src/stage1/parser.cpp b/src/stage1/parser.cpp index 1253baf9ea..219f767a9c 100644 --- a/src/stage1/parser.cpp +++ b/src/stage1/parser.cpp @@ -2920,6 +2920,7 @@ static AstNode *ast_parse_container_decl_auto(ParseContext *pc) { // <- KEYWORD_struct // / KEYWORD_enum (LPAREN Expr RPAREN)? // / KEYWORD_union (LPAREN (KEYWORD_enum (LPAREN Expr RPAREN)? / Expr) RPAREN)? +// / KEYWORD_opaque static AstNode *ast_parse_container_decl_type(ParseContext *pc) { Token *first = eat_token_if(pc, TokenIdKeywordStruct); if (first != nullptr) { @@ -2929,6 +2930,14 @@ static AstNode *ast_parse_container_decl_type(ParseContext *pc) { return res; } + first = eat_token_if(pc, TokenIdKeywordOpaque); + if (first != nullptr) { + AstNode *res = ast_create_node(pc, NodeTypeContainerDecl, first); + res->data.container_decl.init_arg_expr = nullptr; + res->data.container_decl.kind = ContainerKindOpaque; + return res; + } + first = eat_token_if(pc, TokenIdKeywordEnum); if (first != nullptr) { AstNode *init_arg_expr = nullptr; diff --git a/src/stage1/tokenizer.cpp b/src/stage1/tokenizer.cpp index fa14dd40fa..f597acb701 100644 --- a/src/stage1/tokenizer.cpp +++ b/src/stage1/tokenizer.cpp @@ -133,6 +133,7 @@ static const struct ZigKeyword zig_keywords[] = { {"noinline", TokenIdKeywordNoInline}, {"nosuspend", TokenIdKeywordNoSuspend}, {"null", TokenIdKeywordNull}, + {"opaque", TokenIdKeywordOpaque}, {"or", TokenIdKeywordOr}, {"orelse", TokenIdKeywordOrElse}, {"packed", TokenIdKeywordPacked}, @@ -1595,6 +1596,7 @@ const char * token_name(TokenId id) { case TokenIdKeywordNoInline: return "noinline"; case TokenIdKeywordNoSuspend: return "nosuspend"; case TokenIdKeywordNull: return "null"; + case TokenIdKeywordOpaque: return "opaque"; case TokenIdKeywordOr: return "or"; case TokenIdKeywordOrElse: return "orelse"; case TokenIdKeywordPacked: return "packed"; diff --git a/src/stage1/tokenizer.hpp b/src/stage1/tokenizer.hpp index d8af21ee00..dc12242268 100644 --- a/src/stage1/tokenizer.hpp +++ b/src/stage1/tokenizer.hpp @@ -81,6 +81,7 @@ enum TokenId { TokenIdKeywordNoAlias, TokenIdKeywordNoSuspend, TokenIdKeywordNull, + TokenIdKeywordOpaque, TokenIdKeywordOr, TokenIdKeywordOrElse, TokenIdKeywordPacked, diff --git a/src/translate_c.zig b/src/translate_c.zig index 622b678343..982467aa8f 100644 --- a/src/translate_c.zig +++ b/src/translate_c.zig @@ -5,7 +5,7 @@ const std = @import("std"); const assert = std.debug.assert; const ast = std.zig.ast; const Token = std.zig.Token; -usingnamespace @import("clang.zig"); +const clang = @import("clang.zig"); const ctok = std.c.tokenizer; const CToken = std.c.Token; const mem = std.mem; @@ -13,7 +13,7 @@ const math = std.math; const CallingConvention = std.builtin.CallingConvention; -pub const ClangErrMsg = Stage2ErrorMsg; +pub const ClangErrMsg = clang.Stage2ErrorMsg; pub const Error = error{OutOfMemory}; const TypeError = Error || error{UnsupportedType}; @@ -259,11 +259,11 @@ pub const Context = struct { errors: std.ArrayListUnmanaged(ast.Error), source_buffer: *std.ArrayList(u8), err: Error, - source_manager: *ZigClangSourceManager, + source_manager: *clang.SourceManager, decl_table: DeclTable, alias_list: AliasList, global_scope: *Scope.Root, - clang_context: *ZigClangASTContext, + clang_context: *clang.ASTContext, mangle_count: u32 = 0, root_decls: std.ArrayListUnmanaged(*ast.Node), @@ -284,13 +284,13 @@ pub const Context = struct { } /// Convert a clang source location to a file:line:column string - fn locStr(c: *Context, loc: ZigClangSourceLocation) ![]u8 { - const spelling_loc = ZigClangSourceManager_getSpellingLoc(c.source_manager, loc); - const filename_c = ZigClangSourceManager_getFilename(c.source_manager, spelling_loc); + fn locStr(c: *Context, loc: clang.SourceLocation) ![]u8 { + const spelling_loc = c.source_manager.getSpellingLoc(loc); + const filename_c = c.source_manager.getFilename(spelling_loc); const filename = if (filename_c) |s| try c.str(s) else @as([]const u8, "(no file)"); - const line = ZigClangSourceManager_getSpellingLineNumber(c.source_manager, spelling_loc); - const column = ZigClangSourceManager_getSpellingColumnNumber(c.source_manager, spelling_loc); + const line = c.source_manager.getSpellingLineNumber(spelling_loc); + const column = c.source_manager.getSpellingColumnNumber(spelling_loc); return std.fmt.allocPrint(c.arena, "{}:{}:{}", .{ filename, line, column }); } @@ -336,7 +336,7 @@ pub fn translate( errors: *[]ClangErrMsg, resources_path: [*:0]const u8, ) !*ast.Tree { - const ast_unit = ZigClangLoadFromCommandLine( + const ast_unit = clang.LoadFromCommandLine( args_begin, args_end, &errors.ptr, @@ -346,7 +346,7 @@ pub fn translate( if (errors.len == 0) return error.ASTUnitFailure; return error.SemanticAnalyzeFail; }; - defer ZigClangASTUnit_delete(ast_unit); + defer ast_unit.delete(); var source_buffer = std.ArrayList(u8).init(gpa); defer source_buffer.deinit(); @@ -360,12 +360,12 @@ pub fn translate( .gpa = gpa, .arena = &arena.allocator, .source_buffer = &source_buffer, - .source_manager = ZigClangASTUnit_getSourceManager(ast_unit), + .source_manager = ast_unit.getSourceManager(), .err = undefined, .decl_table = DeclTable.init(gpa), .alias_list = AliasList.init(gpa), .global_scope = try arena.allocator.create(Scope.Root), - .clang_context = ZigClangASTUnit_getASTContext(ast_unit).?, + .clang_context = ast_unit.getASTContext(), .global_names = std.StringArrayHashMap(void).init(gpa), .token_ids = .{}, .token_locs = .{}, @@ -383,7 +383,7 @@ pub fn translate( try prepopulateGlobalNameTable(ast_unit, &context); - if (!ZigClangASTUnit_visitLocalTopLevelDecls(ast_unit, &context, declVisitorC)) { + if (!ast_unit.visitLocalTopLevelDecls(&context, declVisitorC)) { return context.err; } @@ -421,21 +421,21 @@ pub fn translate( return tree; } -fn prepopulateGlobalNameTable(ast_unit: *ZigClangASTUnit, c: *Context) !void { - if (!ZigClangASTUnit_visitLocalTopLevelDecls(ast_unit, c, declVisitorNamesOnlyC)) { +fn prepopulateGlobalNameTable(ast_unit: *clang.ASTUnit, c: *Context) !void { + if (!ast_unit.visitLocalTopLevelDecls(c, declVisitorNamesOnlyC)) { return c.err; } // TODO if we see #undef, delete it from the table - var it = ZigClangASTUnit_getLocalPreprocessingEntities_begin(ast_unit); - const it_end = ZigClangASTUnit_getLocalPreprocessingEntities_end(ast_unit); + var it = ast_unit.getLocalPreprocessingEntities_begin(); + const it_end = ast_unit.getLocalPreprocessingEntities_end(); while (it.I != it_end.I) : (it.I += 1) { - const entity = ZigClangPreprocessingRecord_iterator_deref(it); - switch (ZigClangPreprocessedEntity_getKind(entity)) { + const entity = it.deref(); + switch (entity.getKind()) { .MacroDefinitionKind => { - const macro = @ptrCast(*ZigClangMacroDefinitionRecord, entity); - const raw_name = ZigClangMacroDefinitionRecord_getName_getNameStart(macro); + const macro = @ptrCast(*clang.MacroDefinitionRecord, entity); + const raw_name = macro.getName_getNameStart(); const name = try c.str(raw_name); _ = try c.global_names.put(name, {}); }, @@ -444,7 +444,7 @@ fn prepopulateGlobalNameTable(ast_unit: *ZigClangASTUnit, c: *Context) !void { } } -fn declVisitorNamesOnlyC(context: ?*c_void, decl: *const ZigClangDecl) callconv(.C) bool { +fn declVisitorNamesOnlyC(context: ?*c_void, decl: *const clang.Decl) callconv(.C) bool { const c = @ptrCast(*Context, @alignCast(@alignOf(Context), context)); declVisitorNamesOnly(c, decl) catch |err| { c.err = err; @@ -453,7 +453,7 @@ fn declVisitorNamesOnlyC(context: ?*c_void, decl: *const ZigClangDecl) callconv( return true; } -fn declVisitorC(context: ?*c_void, decl: *const ZigClangDecl) callconv(.C) bool { +fn declVisitorC(context: ?*c_void, decl: *const clang.Decl) callconv(.C) bool { const c = @ptrCast(*Context, @alignCast(@alignOf(Context), context)); declVisitor(c, decl) catch |err| { c.err = err; @@ -462,61 +462,61 @@ fn declVisitorC(context: ?*c_void, decl: *const ZigClangDecl) callconv(.C) bool return true; } -fn declVisitorNamesOnly(c: *Context, decl: *const ZigClangDecl) Error!void { - if (ZigClangDecl_castToNamedDecl(decl)) |named_decl| { - const decl_name = try c.str(ZigClangNamedDecl_getName_bytes_begin(named_decl)); +fn declVisitorNamesOnly(c: *Context, decl: *const clang.Decl) Error!void { + if (decl.castToNamedDecl()) |named_decl| { + const decl_name = try c.str(named_decl.getName_bytes_begin()); _ = try c.global_names.put(decl_name, {}); } } -fn declVisitor(c: *Context, decl: *const ZigClangDecl) Error!void { - switch (ZigClangDecl_getKind(decl)) { +fn declVisitor(c: *Context, decl: *const clang.Decl) Error!void { + switch (decl.getKind()) { .Function => { - return visitFnDecl(c, @ptrCast(*const ZigClangFunctionDecl, decl)); + return visitFnDecl(c, @ptrCast(*const clang.FunctionDecl, decl)); }, .Typedef => { - _ = try transTypeDef(c, @ptrCast(*const ZigClangTypedefNameDecl, decl), true); + _ = try transTypeDef(c, @ptrCast(*const clang.TypedefNameDecl, decl), true); }, .Enum => { - _ = try transEnumDecl(c, @ptrCast(*const ZigClangEnumDecl, decl)); + _ = try transEnumDecl(c, @ptrCast(*const clang.EnumDecl, decl)); }, .Record => { - _ = try transRecordDecl(c, @ptrCast(*const ZigClangRecordDecl, decl)); + _ = try transRecordDecl(c, @ptrCast(*const clang.RecordDecl, decl)); }, .Var => { - return visitVarDecl(c, @ptrCast(*const ZigClangVarDecl, decl), null); + return visitVarDecl(c, @ptrCast(*const clang.VarDecl, decl), null); }, .Empty => { // Do nothing }, else => { - const decl_name = try c.str(ZigClangDecl_getDeclKindName(decl)); - try emitWarning(c, ZigClangDecl_getLocation(decl), "ignoring {} declaration", .{decl_name}); + const decl_name = try c.str(decl.getDeclKindName()); + try emitWarning(c, decl.getLocation(), "ignoring {} declaration", .{decl_name}); }, } } -fn visitFnDecl(c: *Context, fn_decl: *const ZigClangFunctionDecl) Error!void { - const fn_name = try c.str(ZigClangNamedDecl_getName_bytes_begin(@ptrCast(*const ZigClangNamedDecl, fn_decl))); +fn visitFnDecl(c: *Context, fn_decl: *const clang.FunctionDecl) Error!void { + const fn_name = try c.str(@ptrCast(*const clang.NamedDecl, fn_decl).getName_bytes_begin()); if (c.global_scope.sym_table.contains(fn_name)) return; // Avoid processing this decl twice // Skip this declaration if a proper definition exists - if (!ZigClangFunctionDecl_isThisDeclarationADefinition(fn_decl)) { - if (ZigClangFunctionDecl_getDefinition(fn_decl)) |def| + if (!fn_decl.isThisDeclarationADefinition()) { + if (fn_decl.getDefinition()) |def| return visitFnDecl(c, def); } const rp = makeRestorePoint(c); - const fn_decl_loc = ZigClangFunctionDecl_getLocation(fn_decl); - const has_body = ZigClangFunctionDecl_hasBody(fn_decl); - const storage_class = ZigClangFunctionDecl_getStorageClass(fn_decl); + const fn_decl_loc = fn_decl.getLocation(); + const has_body = fn_decl.hasBody(); + const storage_class = fn_decl.getStorageClass(); const decl_ctx = FnDeclContext{ .fn_name = fn_name, .has_body = has_body, .storage_class = storage_class, .is_export = switch (storage_class) { - .None => has_body and !ZigClangFunctionDecl_isInlineSpecified(fn_decl), + .None => has_body and !fn_decl.isInlineSpecified(), .Extern, .Static => false, .PrivateExtern => return failDecl(c, fn_decl_loc, fn_name, "unsupported storage class: private extern", .{}), .Auto => unreachable, // Not legal on functions @@ -524,27 +524,27 @@ fn visitFnDecl(c: *Context, fn_decl: *const ZigClangFunctionDecl) Error!void { }, }; - var fn_qt = ZigClangFunctionDecl_getType(fn_decl); + var fn_qt = fn_decl.getType(); const fn_type = while (true) { - const fn_type = ZigClangQualType_getTypePtr(fn_qt); + const fn_type = fn_qt.getTypePtr(); - switch (ZigClangType_getTypeClass(fn_type)) { + switch (fn_type.getTypeClass()) { .Attributed => { - const attr_type = @ptrCast(*const ZigClangAttributedType, fn_type); - fn_qt = ZigClangAttributedType_getEquivalentType(attr_type); + const attr_type = @ptrCast(*const clang.AttributedType, fn_type); + fn_qt = attr_type.getEquivalentType(); }, .Paren => { - const paren_type = @ptrCast(*const ZigClangParenType, fn_type); - fn_qt = ZigClangParenType_getInnerType(paren_type); + const paren_type = @ptrCast(*const clang.ParenType, fn_type); + fn_qt = paren_type.getInnerType(); }, else => break fn_type, } } else unreachable; - const proto_node = switch (ZigClangType_getTypeClass(fn_type)) { + const proto_node = switch (fn_type.getTypeClass()) { .FunctionProto => blk: { - const fn_proto_type = @ptrCast(*const ZigClangFunctionProtoType, fn_type); + const fn_proto_type = @ptrCast(*const clang.FunctionProtoType, fn_type); break :blk transFnProto(rp, fn_decl, fn_proto_type, fn_decl_loc, decl_ctx, true) catch |err| switch (err) { error.UnsupportedType => { return failDecl(c, fn_decl_loc, fn_name, "unable to resolve prototype of function", .{}); @@ -553,7 +553,7 @@ fn visitFnDecl(c: *Context, fn_decl: *const ZigClangFunctionDecl) Error!void { }; }, .FunctionNoProto => blk: { - const fn_no_proto_type = @ptrCast(*const ZigClangFunctionType, fn_type); + const fn_no_proto_type = @ptrCast(*const clang.FunctionType, fn_type); break :blk transFnNoProto(rp, fn_no_proto_type, fn_decl_loc, decl_ctx, true) catch |err| switch (err) { error.UnsupportedType => { return failDecl(c, fn_decl_loc, fn_name, "unable to resolve prototype of function", .{}); @@ -561,7 +561,7 @@ fn visitFnDecl(c: *Context, fn_decl: *const ZigClangFunctionDecl) Error!void { error.OutOfMemory => |e| return e, }; }, - else => return failDecl(c, fn_decl_loc, fn_name, "unable to resolve function type {}", .{ZigClangType_getTypeClass(fn_type)}), + else => return failDecl(c, fn_decl_loc, fn_name, "unable to resolve function type {}", .{fn_type.getTypeClass()}), }; if (!decl_ctx.has_body) { @@ -570,7 +570,7 @@ fn visitFnDecl(c: *Context, fn_decl: *const ZigClangFunctionDecl) Error!void { } // actual function definition with body - const body_stmt = ZigClangFunctionDecl_getBody(fn_decl); + const body_stmt = fn_decl.getBody(); var block_scope = try Scope.Block.init(rp.c, &c.global_scope.base, false); defer block_scope.deinit(); var scope = &block_scope.base; @@ -582,9 +582,9 @@ fn visitFnDecl(c: *Context, fn_decl: *const ZigClangFunctionDecl) Error!void { else return failDecl(c, fn_decl_loc, fn_name, "function {} parameter has no name", .{fn_name}); - const c_param = ZigClangFunctionDecl_getParamDecl(fn_decl, param_id); - const qual_type = ZigClangParmVarDecl_getOriginalType(c_param); - const is_const = ZigClangQualType_isConstQualified(qual_type); + const c_param = fn_decl.getParamDecl(param_id); + const qual_type = c_param.getOriginalType(); + const is_const = qual_type.isConstQualified(); const mangled_param_name = try block_scope.makeMangledName(c, param_name); @@ -613,7 +613,7 @@ fn visitFnDecl(c: *Context, fn_decl: *const ZigClangFunctionDecl) Error!void { param_id += 1; } - const casted_body = @ptrCast(*const ZigClangCompoundStmt, body_stmt); + const casted_body = @ptrCast(*const clang.CompoundStmt, body_stmt); transCompoundStmtInline(rp, &block_scope.base, casted_body, &block_scope) catch |err| switch (err) { error.OutOfMemory => |e| return e, error.UnsupportedTranslation, @@ -622,10 +622,10 @@ fn visitFnDecl(c: *Context, fn_decl: *const ZigClangFunctionDecl) Error!void { }; // add return statement if the function didn't have one blk: { - const fn_ty = @ptrCast(*const ZigClangFunctionType, fn_type); + const fn_ty = @ptrCast(*const clang.FunctionType, fn_type); - if (ZigClangFunctionType_getNoReturnAttr(fn_ty)) break :blk; - const return_qt = ZigClangFunctionType_getReturnType(fn_ty); + if (fn_ty.getNoReturnAttr()) break :blk; + const return_qt = fn_ty.getReturnType(); if (isCVoid(return_qt)) break :blk; if (block_scope.statements.items.len > 0) { @@ -649,7 +649,7 @@ fn visitFnDecl(c: *Context, fn_decl: *const ZigClangFunctionDecl) Error!void { .ltoken = try appendToken(rp.c, .Keyword_return, "return"), .tag = .Return, }, .{ - .rhs = transZeroInitExpr(rp, scope, fn_decl_loc, ZigClangQualType_getTypePtr(return_qt)) catch |err| switch (err) { + .rhs = transZeroInitExpr(rp, scope, fn_decl_loc, return_qt.getTypePtr()) catch |err| switch (err) { error.OutOfMemory => |e| return e, error.UnsupportedTranslation, error.UnsupportedType, @@ -666,14 +666,14 @@ fn visitFnDecl(c: *Context, fn_decl: *const ZigClangFunctionDecl) Error!void { } /// if mangled_name is not null, this var decl was declared in a block scope. -fn visitVarDecl(c: *Context, var_decl: *const ZigClangVarDecl, mangled_name: ?[]const u8) Error!void { - const var_name = mangled_name orelse try c.str(ZigClangNamedDecl_getName_bytes_begin(@ptrCast(*const ZigClangNamedDecl, var_decl))); +fn visitVarDecl(c: *Context, var_decl: *const clang.VarDecl, mangled_name: ?[]const u8) Error!void { + const var_name = mangled_name orelse try c.str(@ptrCast(*const clang.NamedDecl, var_decl).getName_bytes_begin()); if (c.global_scope.sym_table.contains(var_name)) return; // Avoid processing this decl twice const rp = makeRestorePoint(c); const visib_tok = if (mangled_name) |_| null else try appendToken(c, .Keyword_pub, "pub"); - const thread_local_token = if (ZigClangVarDecl_getTLSKind(var_decl) == .None) + const thread_local_token = if (var_decl.getTLSKind() == .None) null else try appendToken(c, .Keyword_threadlocal, "threadlocal"); @@ -683,12 +683,12 @@ fn visitVarDecl(c: *Context, var_decl: *const ZigClangVarDecl, mangled_name: ?[] // TODO https://github.com/ziglang/zig/issues/3756 // TODO https://github.com/ziglang/zig/issues/1802 const checked_name = if (isZigPrimitiveType(var_name)) try std.fmt.allocPrint(c.arena, "{}_{}", .{ var_name, c.getMangle() }) else var_name; - const var_decl_loc = ZigClangVarDecl_getLocation(var_decl); + const var_decl_loc = var_decl.getLocation(); - const qual_type = ZigClangVarDecl_getTypeSourceInfo_getType(var_decl); - const storage_class = ZigClangVarDecl_getStorageClass(var_decl); - const is_const = ZigClangQualType_isConstQualified(qual_type); - const has_init = ZigClangVarDecl_hasInit(var_decl); + const qual_type = var_decl.getTypeSourceInfo_getType(); + const storage_class = var_decl.getStorageClass(); + const is_const = qual_type.isConstQualified(); + const has_init = var_decl.hasInit(); // In C extern variables with initializers behave like Zig exports. // extern int foo = 2; @@ -725,7 +725,7 @@ fn visitVarDecl(c: *Context, var_decl: *const ZigClangVarDecl, mangled_name: ?[] // with the variable type. if (has_init) { eq_tok = try appendToken(c, .Equal, "="); - init_node = if (ZigClangVarDecl_getInit(var_decl)) |expr| + init_node = if (var_decl.getInit()) |expr| transExprCoercing(rp, &c.global_scope.base, expr, .used, .r_value) catch |err| switch (err) { error.UnsupportedTranslation, error.UnsupportedType, @@ -758,7 +758,7 @@ fn visitVarDecl(c: *Context, var_decl: *const ZigClangVarDecl, mangled_name: ?[] const linksection_expr = blk: { var str_len: usize = undefined; - if (ZigClangVarDecl_getSectionAttribute(var_decl, &str_len)) |str_ptr| { + if (var_decl.getSectionAttribute(&str_len)) |str_ptr| { _ = try appendToken(rp.c, .Keyword_linksection, "linksection"); _ = try appendToken(rp.c, .LParen, "("); const expr = try transCreateNodeStringLiteral( @@ -773,7 +773,7 @@ fn visitVarDecl(c: *Context, var_decl: *const ZigClangVarDecl, mangled_name: ?[] }; const align_expr = blk: { - const alignment = ZigClangVarDecl_getAlignedAttribute(var_decl, rp.c.clang_context); + const alignment = var_decl.getAlignedAttribute(rp.c.clang_context); if (alignment != 0) { _ = try appendToken(rp.c, .Keyword_align, "align"); _ = try appendToken(rp.c, .LParen, "("); @@ -803,8 +803,8 @@ fn visitVarDecl(c: *Context, var_decl: *const ZigClangVarDecl, mangled_name: ?[] return addTopLevelDecl(c, checked_name, &node.base); } -fn transTypeDefAsBuiltin(c: *Context, typedef_decl: *const ZigClangTypedefNameDecl, builtin_name: []const u8) !*ast.Node { - _ = try c.decl_table.put(@ptrToInt(ZigClangTypedefNameDecl_getCanonicalDecl(typedef_decl)), builtin_name); +fn transTypeDefAsBuiltin(c: *Context, typedef_decl: *const clang.TypedefNameDecl, builtin_name: []const u8) !*ast.Node { + _ = try c.decl_table.put(@ptrToInt(typedef_decl.getCanonicalDecl()), builtin_name); return transCreateNodeIdentifier(c, builtin_name); } @@ -833,12 +833,12 @@ fn checkForBuiltinTypedef(checked_name: []const u8) ?[]const u8 { return null; } -fn transTypeDef(c: *Context, typedef_decl: *const ZigClangTypedefNameDecl, top_level_visit: bool) Error!?*ast.Node { - if (c.decl_table.get(@ptrToInt(ZigClangTypedefNameDecl_getCanonicalDecl(typedef_decl)))) |name| +fn transTypeDef(c: *Context, typedef_decl: *const clang.TypedefNameDecl, top_level_visit: bool) Error!?*ast.Node { + if (c.decl_table.get(@ptrToInt(typedef_decl.getCanonicalDecl()))) |name| return transCreateNodeIdentifier(c, name); // Avoid processing this decl twice const rp = makeRestorePoint(c); - const typedef_name = try c.str(ZigClangNamedDecl_getName_bytes_begin(@ptrCast(*const ZigClangNamedDecl, typedef_decl))); + const typedef_name = try c.str(@ptrCast(*const clang.NamedDecl, typedef_decl).getName_bytes_begin()); // TODO https://github.com/ziglang/zig/issues/3756 // TODO https://github.com/ziglang/zig/issues/1802 @@ -851,7 +851,7 @@ fn transTypeDef(c: *Context, typedef_decl: *const ZigClangTypedefNameDecl, top_l return transCreateNodeIdentifier(c, checked_name); } - _ = try c.decl_table.put(@ptrToInt(ZigClangTypedefNameDecl_getCanonicalDecl(typedef_decl)), checked_name); + _ = try c.decl_table.put(@ptrToInt(typedef_decl.getCanonicalDecl()), checked_name); const node = (try transCreateNodeTypedef(rp, typedef_decl, true, checked_name)) orelse return null; try addTopLevelDecl(c, checked_name, node); return transCreateNodeIdentifier(c, checked_name); @@ -859,7 +859,7 @@ fn transTypeDef(c: *Context, typedef_decl: *const ZigClangTypedefNameDecl, top_l fn transCreateNodeTypedef( rp: RestorePoint, - typedef_decl: *const ZigClangTypedefNameDecl, + typedef_decl: *const clang.TypedefNameDecl, toplevel: bool, checked_name: []const u8, ) Error!?*ast.Node { @@ -867,8 +867,8 @@ fn transCreateNodeTypedef( const mut_tok = try appendToken(rp.c, .Keyword_const, "const"); const name_tok = try appendIdentifier(rp.c, checked_name); const eq_token = try appendToken(rp.c, .Equal, "="); - const child_qt = ZigClangTypedefNameDecl_getUnderlyingType(typedef_decl); - const typedef_loc = ZigClangTypedefNameDecl_getLocation(typedef_decl); + const child_qt = typedef_decl.getUnderlyingType(); + const typedef_loc = typedef_decl.getLocation(); const init_node = transQualType(rp, child_qt, typedef_loc) catch |err| switch (err) { error.UnsupportedType => { try failDecl(rp.c, typedef_loc, checked_name, "unable to resolve typedef child type", .{}); @@ -890,12 +890,12 @@ fn transCreateNodeTypedef( return &node.base; } -fn transRecordDecl(c: *Context, record_decl: *const ZigClangRecordDecl) Error!?*ast.Node { - if (c.decl_table.get(@ptrToInt(ZigClangRecordDecl_getCanonicalDecl(record_decl)))) |name| +fn transRecordDecl(c: *Context, record_decl: *const clang.RecordDecl) Error!?*ast.Node { + if (c.decl_table.get(@ptrToInt(record_decl.getCanonicalDecl()))) |name| return try transCreateNodeIdentifier(c, name); // Avoid processing this decl twice - const record_loc = ZigClangRecordDecl_getLocation(record_decl); + const record_loc = record_decl.getLocation(); - var bare_name = try c.str(ZigClangNamedDecl_getName_bytes_begin(@ptrCast(*const ZigClangNamedDecl, record_decl))); + var bare_name = try c.str(@ptrCast(*const clang.NamedDecl, record_decl).getName_bytes_begin()); var is_unnamed = false; // Record declarations such as `struct {...} x` have no name but they're not // anonymous hence here isAnonymousStructOrUnion is not needed @@ -906,10 +906,10 @@ fn transRecordDecl(c: *Context, record_decl: *const ZigClangRecordDecl) Error!?* var container_kind_name: []const u8 = undefined; var container_kind: std.zig.Token.Id = undefined; - if (ZigClangRecordDecl_isUnion(record_decl)) { + if (record_decl.isUnion()) { container_kind_name = "union"; container_kind = .Keyword_union; - } else if (ZigClangRecordDecl_isStruct(record_decl)) { + } else if (record_decl.isStruct()) { container_kind_name = "struct"; container_kind = .Keyword_struct; } else { @@ -918,7 +918,7 @@ fn transRecordDecl(c: *Context, record_decl: *const ZigClangRecordDecl) Error!?* } const name = try std.fmt.allocPrint(c.arena, "{}_{}", .{ container_kind_name, bare_name }); - _ = try c.decl_table.put(@ptrToInt(ZigClangRecordDecl_getCanonicalDecl(record_decl)), name); + _ = try c.decl_table.put(@ptrToInt(record_decl.getCanonicalDecl()), name); const visib_tok = if (!is_unnamed) try appendToken(c, .Keyword_pub, "pub") else null; const mut_tok = try appendToken(c, .Keyword_const, "const"); @@ -929,13 +929,13 @@ fn transRecordDecl(c: *Context, record_decl: *const ZigClangRecordDecl) Error!?* var semicolon: ast.TokenIndex = undefined; const init_node = blk: { const rp = makeRestorePoint(c); - const record_def = ZigClangRecordDecl_getDefinition(record_decl) orelse { - const opaque = try transCreateNodeOpaqueType(c); + const record_def = record_decl.getDefinition() orelse { + const opaque_type = try transCreateNodeOpaqueType(c); semicolon = try appendToken(c, .Semicolon, ";"); - break :blk opaque; + break :blk opaque_type; }; - const layout_tok = try if (ZigClangRecordDecl_getPackedAttribute(record_decl)) + const layout_tok = try if (record_decl.getPackedAttribute()) appendToken(c, .Keyword_packed, "packed") else appendToken(c, .Keyword_extern, "extern"); @@ -946,30 +946,30 @@ fn transRecordDecl(c: *Context, record_decl: *const ZigClangRecordDecl) Error!?* defer fields_and_decls.deinit(); var unnamed_field_count: u32 = 0; - var it = ZigClangRecordDecl_field_begin(record_def); - const end_it = ZigClangRecordDecl_field_end(record_def); - while (ZigClangRecordDecl_field_iterator_neq(it, end_it)) : (it = ZigClangRecordDecl_field_iterator_next(it)) { - const field_decl = ZigClangRecordDecl_field_iterator_deref(it); - const field_loc = ZigClangFieldDecl_getLocation(field_decl); - const field_qt = ZigClangFieldDecl_getType(field_decl); + var it = record_def.field_begin(); + const end_it = record_def.field_end(); + while (it.neq(end_it)) : (it = it.next()) { + const field_decl = it.deref(); + const field_loc = field_decl.getLocation(); + const field_qt = field_decl.getType(); - if (ZigClangFieldDecl_isBitField(field_decl)) { - const opaque = try transCreateNodeOpaqueType(c); + if (field_decl.isBitField()) { + const opaque_type = try transCreateNodeOpaqueType(c); semicolon = try appendToken(c, .Semicolon, ";"); try emitWarning(c, field_loc, "{} demoted to opaque type - has bitfield", .{container_kind_name}); - break :blk opaque; + break :blk opaque_type; } - if (ZigClangType_isIncompleteOrZeroLengthArrayType(qualTypeCanon(field_qt), c.clang_context)) { - const opaque = try transCreateNodeOpaqueType(c); + if (qualTypeCanon(field_qt).isIncompleteOrZeroLengthArrayType(c.clang_context)) { + const opaque_type = try transCreateNodeOpaqueType(c); semicolon = try appendToken(c, .Semicolon, ";"); try emitWarning(c, field_loc, "{} demoted to opaque type - has variable length array", .{container_kind_name}); - break :blk opaque; + break :blk opaque_type; } var is_anon = false; - var raw_name = try c.str(ZigClangNamedDecl_getName_bytes_begin(@ptrCast(*const ZigClangNamedDecl, field_decl))); - if (ZigClangFieldDecl_isAnonymousStructOrUnion(field_decl) or raw_name.len == 0) { + var raw_name = try c.str(@ptrCast(*const clang.NamedDecl, field_decl).getName_bytes_begin()); + if (field_decl.isAnonymousStructOrUnion() or raw_name.len == 0) { // Context.getMangle() is not used here because doing so causes unpredictable field names for anonymous fields. raw_name = try std.fmt.allocPrint(c.arena, "unnamed_{}", .{unnamed_field_count}); unnamed_field_count += 1; @@ -979,16 +979,16 @@ fn transRecordDecl(c: *Context, record_decl: *const ZigClangRecordDecl) Error!?* _ = try appendToken(c, .Colon, ":"); const field_type = transQualType(rp, field_qt, field_loc) catch |err| switch (err) { error.UnsupportedType => { - const opaque = try transCreateNodeOpaqueType(c); + const opaque_type = try transCreateNodeOpaqueType(c); semicolon = try appendToken(c, .Semicolon, ";"); try emitWarning(c, record_loc, "{} demoted to opaque type - unable to translate type of field {}", .{ container_kind_name, raw_name }); - break :blk opaque; + break :blk opaque_type; }, else => |e| return e, }; const align_expr = blk_2: { - const alignment = ZigClangFieldDecl_getAlignedAttribute(field_decl, rp.c.clang_context); + const alignment = field_decl.getAlignedAttribute(rp.c.clang_context); if (alignment != 0) { _ = try appendToken(rp.c, .Keyword_align, "align"); _ = try appendToken(rp.c, .LParen, "("); @@ -1013,7 +1013,7 @@ fn transRecordDecl(c: *Context, record_decl: *const ZigClangRecordDecl) Error!?* if (is_anon) { _ = try c.decl_table.put( - @ptrToInt(ZigClangFieldDecl_getCanonicalDecl(field_decl)), + @ptrToInt(field_decl.getCanonicalDecl()), raw_name, ); } @@ -1051,13 +1051,13 @@ fn transRecordDecl(c: *Context, record_decl: *const ZigClangRecordDecl) Error!?* return transCreateNodeIdentifier(c, name); } -fn transEnumDecl(c: *Context, enum_decl: *const ZigClangEnumDecl) Error!?*ast.Node { - if (c.decl_table.get(@ptrToInt(ZigClangEnumDecl_getCanonicalDecl(enum_decl)))) |name| +fn transEnumDecl(c: *Context, enum_decl: *const clang.EnumDecl) Error!?*ast.Node { + if (c.decl_table.get(@ptrToInt(enum_decl.getCanonicalDecl()))) |name| return try transCreateNodeIdentifier(c, name); // Avoid processing this decl twice const rp = makeRestorePoint(c); - const enum_loc = ZigClangEnumDecl_getLocation(enum_decl); + const enum_loc = enum_decl.getLocation(); - var bare_name = try c.str(ZigClangNamedDecl_getName_bytes_begin(@ptrCast(*const ZigClangNamedDecl, enum_decl))); + var bare_name = try c.str(@ptrCast(*const clang.NamedDecl, enum_decl).getName_bytes_begin()); var is_unnamed = false; if (bare_name.len == 0) { bare_name = try std.fmt.allocPrint(c.arena, "unnamed_{}", .{c.getMangle()}); @@ -1065,20 +1065,20 @@ fn transEnumDecl(c: *Context, enum_decl: *const ZigClangEnumDecl) Error!?*ast.No } const name = try std.fmt.allocPrint(c.arena, "enum_{}", .{bare_name}); - _ = try c.decl_table.put(@ptrToInt(ZigClangEnumDecl_getCanonicalDecl(enum_decl)), name); + _ = try c.decl_table.put(@ptrToInt(enum_decl.getCanonicalDecl()), name); const visib_tok = if (!is_unnamed) try appendToken(c, .Keyword_pub, "pub") else null; const mut_tok = try appendToken(c, .Keyword_const, "const"); const name_tok = try appendIdentifier(c, name); const eq_token = try appendToken(c, .Equal, "="); - const init_node = if (ZigClangEnumDecl_getDefinition(enum_decl)) |enum_def| blk: { + const init_node = if (enum_decl.getDefinition()) |enum_def| blk: { var pure_enum = true; - var it = ZigClangEnumDecl_enumerator_begin(enum_def); - var end_it = ZigClangEnumDecl_enumerator_end(enum_def); - while (ZigClangEnumDecl_enumerator_iterator_neq(it, end_it)) : (it = ZigClangEnumDecl_enumerator_iterator_next(it)) { - const enum_const = ZigClangEnumDecl_enumerator_iterator_deref(it); - if (ZigClangEnumConstantDecl_getInitExpr(enum_const)) |_| { + var it = enum_def.enumerator_begin(); + var end_it = enum_def.enumerator_end(); + while (it.neq(end_it)) : (it = it.next()) { + const enum_const = it.deref(); + if (enum_const.getInitExpr()) |_| { pure_enum = false; break; } @@ -1090,7 +1090,7 @@ fn transEnumDecl(c: *Context, enum_decl: *const ZigClangEnumDecl) Error!?*ast.No var fields_and_decls = std.ArrayList(*ast.Node).init(c.gpa); defer fields_and_decls.deinit(); - const int_type = ZigClangEnumDecl_getIntegerType(enum_decl); + const int_type = enum_decl.getIntegerType(); // The underlying type may be null in case of forward-declared enum // types, while that's not ISO-C compliant many compilers allow this and // default to the usual integer type used for all the enums. @@ -1115,12 +1115,12 @@ fn transEnumDecl(c: *Context, enum_decl: *const ZigClangEnumDecl) Error!?*ast.No const lbrace_token = try appendToken(c, .LBrace, "{"); - it = ZigClangEnumDecl_enumerator_begin(enum_def); - end_it = ZigClangEnumDecl_enumerator_end(enum_def); - while (ZigClangEnumDecl_enumerator_iterator_neq(it, end_it)) : (it = ZigClangEnumDecl_enumerator_iterator_next(it)) { - const enum_const = ZigClangEnumDecl_enumerator_iterator_deref(it); + it = enum_def.enumerator_begin(); + end_it = enum_def.enumerator_end(); + while (it.neq(end_it)) : (it = it.next()) { + const enum_const = it.deref(); - const enum_val_name = try c.str(ZigClangNamedDecl_getName_bytes_begin(@ptrCast(*const ZigClangNamedDecl, enum_const))); + const enum_val_name = try c.str(@ptrCast(*const clang.NamedDecl, enum_const).getName_bytes_begin()); const field_name = if (!is_unnamed and mem.startsWith(u8, enum_val_name, bare_name)) enum_val_name[bare_name.len..] @@ -1131,7 +1131,7 @@ fn transEnumDecl(c: *Context, enum_decl: *const ZigClangEnumDecl) Error!?*ast.No const int_node = if (!pure_enum) blk_2: { _ = try appendToken(c, .Colon, "="); - break :blk_2 try transCreateNodeAPInt(c, ZigClangEnumConstantDecl_getInitVal(enum_const)); + break :blk_2 try transCreateNodeAPInt(c, enum_const.getInitVal()); } else null; @@ -1257,23 +1257,23 @@ const LRValue = enum { fn transStmt( rp: RestorePoint, scope: *Scope, - stmt: *const ZigClangStmt, + stmt: *const clang.Stmt, result_used: ResultUsed, lrvalue: LRValue, ) TransError!*ast.Node { - const sc = ZigClangStmt_getStmtClass(stmt); + const sc = stmt.getStmtClass(); switch (sc) { - .BinaryOperatorClass => return transBinaryOperator(rp, scope, @ptrCast(*const ZigClangBinaryOperator, stmt), result_used), - .CompoundStmtClass => return transCompoundStmt(rp, scope, @ptrCast(*const ZigClangCompoundStmt, stmt)), - .CStyleCastExprClass => return transCStyleCastExprClass(rp, scope, @ptrCast(*const ZigClangCStyleCastExpr, stmt), result_used, lrvalue), - .DeclStmtClass => return transDeclStmt(rp, scope, @ptrCast(*const ZigClangDeclStmt, stmt)), - .DeclRefExprClass => return transDeclRefExpr(rp, scope, @ptrCast(*const ZigClangDeclRefExpr, stmt), lrvalue), - .ImplicitCastExprClass => return transImplicitCastExpr(rp, scope, @ptrCast(*const ZigClangImplicitCastExpr, stmt), result_used), - .IntegerLiteralClass => return transIntegerLiteral(rp, scope, @ptrCast(*const ZigClangIntegerLiteral, stmt), result_used, .with_as), - .ReturnStmtClass => return transReturnStmt(rp, scope, @ptrCast(*const ZigClangReturnStmt, stmt)), - .StringLiteralClass => return transStringLiteral(rp, scope, @ptrCast(*const ZigClangStringLiteral, stmt), result_used), + .BinaryOperatorClass => return transBinaryOperator(rp, scope, @ptrCast(*const clang.BinaryOperator, stmt), result_used), + .CompoundStmtClass => return transCompoundStmt(rp, scope, @ptrCast(*const clang.CompoundStmt, stmt)), + .CStyleCastExprClass => return transCStyleCastExprClass(rp, scope, @ptrCast(*const clang.CStyleCastExpr, stmt), result_used, lrvalue), + .DeclStmtClass => return transDeclStmt(rp, scope, @ptrCast(*const clang.DeclStmt, stmt)), + .DeclRefExprClass => return transDeclRefExpr(rp, scope, @ptrCast(*const clang.DeclRefExpr, stmt), lrvalue), + .ImplicitCastExprClass => return transImplicitCastExpr(rp, scope, @ptrCast(*const clang.ImplicitCastExpr, stmt), result_used), + .IntegerLiteralClass => return transIntegerLiteral(rp, scope, @ptrCast(*const clang.IntegerLiteral, stmt), result_used, .with_as), + .ReturnStmtClass => return transReturnStmt(rp, scope, @ptrCast(*const clang.ReturnStmt, stmt)), + .StringLiteralClass => return transStringLiteral(rp, scope, @ptrCast(*const clang.StringLiteral, stmt), result_used), .ParenExprClass => { - const expr = try transExpr(rp, scope, ZigClangParenExpr_getSubExpr(@ptrCast(*const ZigClangParenExpr, stmt)), .used, lrvalue); + const expr = try transExpr(rp, scope, @ptrCast(*const clang.ParenExpr, stmt).getSubExpr(), .used, lrvalue); if (expr.tag == .GroupedExpression) return maybeSuppressResult(rp, scope, result_used, expr); const node = try rp.c.arena.create(ast.Node.GroupedExpression); node.* = .{ @@ -1283,11 +1283,11 @@ fn transStmt( }; return maybeSuppressResult(rp, scope, result_used, &node.base); }, - .InitListExprClass => return transInitListExpr(rp, scope, @ptrCast(*const ZigClangInitListExpr, stmt), result_used), - .ImplicitValueInitExprClass => return transImplicitValueInitExpr(rp, scope, @ptrCast(*const ZigClangExpr, stmt), result_used), - .IfStmtClass => return transIfStmt(rp, scope, @ptrCast(*const ZigClangIfStmt, stmt)), - .WhileStmtClass => return transWhileLoop(rp, scope, @ptrCast(*const ZigClangWhileStmt, stmt)), - .DoStmtClass => return transDoWhileLoop(rp, scope, @ptrCast(*const ZigClangDoStmt, stmt)), + .InitListExprClass => return transInitListExpr(rp, scope, @ptrCast(*const clang.InitListExpr, stmt), result_used), + .ImplicitValueInitExprClass => return transImplicitValueInitExpr(rp, scope, @ptrCast(*const clang.Expr, stmt), result_used), + .IfStmtClass => return transIfStmt(rp, scope, @ptrCast(*const clang.IfStmt, stmt)), + .WhileStmtClass => return transWhileLoop(rp, scope, @ptrCast(*const clang.WhileStmt, stmt)), + .DoStmtClass => return transDoWhileLoop(rp, scope, @ptrCast(*const clang.DoStmt, stmt)), .NullStmtClass => { const block = try rp.c.createBlock(0); block.rbrace = try appendToken(rp.c, .RBrace, "}"); @@ -1295,29 +1295,29 @@ fn transStmt( }, .ContinueStmtClass => return try transCreateNodeContinue(rp.c), .BreakStmtClass => return transBreak(rp, scope), - .ForStmtClass => return transForLoop(rp, scope, @ptrCast(*const ZigClangForStmt, stmt)), - .FloatingLiteralClass => return transFloatingLiteral(rp, scope, @ptrCast(*const ZigClangFloatingLiteral, stmt), result_used), + .ForStmtClass => return transForLoop(rp, scope, @ptrCast(*const clang.ForStmt, stmt)), + .FloatingLiteralClass => return transFloatingLiteral(rp, scope, @ptrCast(*const clang.FloatingLiteral, stmt), result_used), .ConditionalOperatorClass => { - return transConditionalOperator(rp, scope, @ptrCast(*const ZigClangConditionalOperator, stmt), result_used); + return transConditionalOperator(rp, scope, @ptrCast(*const clang.ConditionalOperator, stmt), result_used); }, .BinaryConditionalOperatorClass => { - return transBinaryConditionalOperator(rp, scope, @ptrCast(*const ZigClangBinaryConditionalOperator, stmt), result_used); + return transBinaryConditionalOperator(rp, scope, @ptrCast(*const clang.BinaryConditionalOperator, stmt), result_used); }, - .SwitchStmtClass => return transSwitch(rp, scope, @ptrCast(*const ZigClangSwitchStmt, stmt)), - .CaseStmtClass => return transCase(rp, scope, @ptrCast(*const ZigClangCaseStmt, stmt)), - .DefaultStmtClass => return transDefault(rp, scope, @ptrCast(*const ZigClangDefaultStmt, stmt)), - .ConstantExprClass => return transConstantExpr(rp, scope, @ptrCast(*const ZigClangExpr, stmt), result_used), - .PredefinedExprClass => return transPredefinedExpr(rp, scope, @ptrCast(*const ZigClangPredefinedExpr, stmt), result_used), - .CharacterLiteralClass => return transCharLiteral(rp, scope, @ptrCast(*const ZigClangCharacterLiteral, stmt), result_used, .with_as), - .StmtExprClass => return transStmtExpr(rp, scope, @ptrCast(*const ZigClangStmtExpr, stmt), result_used), - .MemberExprClass => return transMemberExpr(rp, scope, @ptrCast(*const ZigClangMemberExpr, stmt), result_used), - .ArraySubscriptExprClass => return transArrayAccess(rp, scope, @ptrCast(*const ZigClangArraySubscriptExpr, stmt), result_used), - .CallExprClass => return transCallExpr(rp, scope, @ptrCast(*const ZigClangCallExpr, stmt), result_used), - .UnaryExprOrTypeTraitExprClass => return transUnaryExprOrTypeTraitExpr(rp, scope, @ptrCast(*const ZigClangUnaryExprOrTypeTraitExpr, stmt), result_used), - .UnaryOperatorClass => return transUnaryOperator(rp, scope, @ptrCast(*const ZigClangUnaryOperator, stmt), result_used), - .CompoundAssignOperatorClass => return transCompoundAssignOperator(rp, scope, @ptrCast(*const ZigClangCompoundAssignOperator, stmt), result_used), + .SwitchStmtClass => return transSwitch(rp, scope, @ptrCast(*const clang.SwitchStmt, stmt)), + .CaseStmtClass => return transCase(rp, scope, @ptrCast(*const clang.CaseStmt, stmt)), + .DefaultStmtClass => return transDefault(rp, scope, @ptrCast(*const clang.DefaultStmt, stmt)), + .ConstantExprClass => return transConstantExpr(rp, scope, @ptrCast(*const clang.Expr, stmt), result_used), + .PredefinedExprClass => return transPredefinedExpr(rp, scope, @ptrCast(*const clang.PredefinedExpr, stmt), result_used), + .CharacterLiteralClass => return transCharLiteral(rp, scope, @ptrCast(*const clang.CharacterLiteral, stmt), result_used, .with_as), + .StmtExprClass => return transStmtExpr(rp, scope, @ptrCast(*const clang.StmtExpr, stmt), result_used), + .MemberExprClass => return transMemberExpr(rp, scope, @ptrCast(*const clang.MemberExpr, stmt), result_used), + .ArraySubscriptExprClass => return transArrayAccess(rp, scope, @ptrCast(*const clang.ArraySubscriptExpr, stmt), result_used), + .CallExprClass => return transCallExpr(rp, scope, @ptrCast(*const clang.CallExpr, stmt), result_used), + .UnaryExprOrTypeTraitExprClass => return transUnaryExprOrTypeTraitExpr(rp, scope, @ptrCast(*const clang.UnaryExprOrTypeTraitExpr, stmt), result_used), + .UnaryOperatorClass => return transUnaryOperator(rp, scope, @ptrCast(*const clang.UnaryOperator, stmt), result_used), + .CompoundAssignOperatorClass => return transCompoundAssignOperator(rp, scope, @ptrCast(*const clang.CompoundAssignOperator, stmt), result_used), .OpaqueValueExprClass => { - const source_expr = ZigClangOpaqueValueExpr_getSourceExpr(@ptrCast(*const ZigClangOpaqueValueExpr, stmt)).?; + const source_expr = @ptrCast(*const clang.OpaqueValueExpr, stmt).getSourceExpr().?; const expr = try transExpr(rp, scope, source_expr, .used, lrvalue); if (expr.tag == .GroupedExpression) return maybeSuppressResult(rp, scope, result_used, expr); const node = try rp.c.arena.create(ast.Node.GroupedExpression); @@ -1332,7 +1332,7 @@ fn transStmt( return revertAndWarn( rp, error.UnsupportedTranslation, - ZigClangStmt_getBeginLoc(stmt), + stmt.getBeginLoc(), "TODO implement translation of stmt class {}", .{@tagName(sc)}, ); @@ -1343,24 +1343,24 @@ fn transStmt( fn transBinaryOperator( rp: RestorePoint, scope: *Scope, - stmt: *const ZigClangBinaryOperator, + stmt: *const clang.BinaryOperator, result_used: ResultUsed, ) TransError!*ast.Node { - const op = ZigClangBinaryOperator_getOpcode(stmt); - const qt = ZigClangBinaryOperator_getType(stmt); + const op = stmt.getOpcode(); + const qt = stmt.getType(); var op_token: ast.TokenIndex = undefined; var op_id: ast.Node.Tag = undefined; switch (op) { - .Assign => return try transCreateNodeAssign(rp, scope, result_used, ZigClangBinaryOperator_getLHS(stmt), ZigClangBinaryOperator_getRHS(stmt)), + .Assign => return try transCreateNodeAssign(rp, scope, result_used, stmt.getLHS(), stmt.getRHS()), .Comma => { const block_scope = try scope.findBlockScope(rp.c); const expr = block_scope.base.parent == scope; const lparen = if (expr) try appendToken(rp.c, .LParen, "(") else undefined; - const lhs = try transExpr(rp, &block_scope.base, ZigClangBinaryOperator_getLHS(stmt), .unused, .r_value); + const lhs = try transExpr(rp, &block_scope.base, stmt.getLHS(), .unused, .r_value); try block_scope.statements.append(lhs); - const rhs = try transExpr(rp, &block_scope.base, ZigClangBinaryOperator_getRHS(stmt), .used, .r_value); + const rhs = try transExpr(rp, &block_scope.base, stmt.getRHS(), .used, .r_value); if (expr) { _ = try appendToken(rp.c, .Semicolon, ";"); const break_node = try transCreateNodeBreak(rp.c, block_scope.label, rhs); @@ -1382,9 +1382,9 @@ fn transBinaryOperator( if (cIsSignedInteger(qt)) { // signed integer division uses @divTrunc const div_trunc_node = try rp.c.createBuiltinCall("@divTrunc", 2); - div_trunc_node.params()[0] = try transExpr(rp, scope, ZigClangBinaryOperator_getLHS(stmt), .used, .l_value); + div_trunc_node.params()[0] = try transExpr(rp, scope, stmt.getLHS(), .used, .l_value); _ = try appendToken(rp.c, .Comma, ","); - const rhs = try transExpr(rp, scope, ZigClangBinaryOperator_getRHS(stmt), .used, .r_value); + const rhs = try transExpr(rp, scope, stmt.getRHS(), .used, .r_value); div_trunc_node.params()[1] = rhs; div_trunc_node.rparen_token = try appendToken(rp.c, .RParen, ")"); return maybeSuppressResult(rp, scope, result_used, &div_trunc_node.base); @@ -1394,9 +1394,9 @@ fn transBinaryOperator( if (cIsSignedInteger(qt)) { // signed integer division uses @rem const rem_node = try rp.c.createBuiltinCall("@rem", 2); - rem_node.params()[0] = try transExpr(rp, scope, ZigClangBinaryOperator_getLHS(stmt), .used, .l_value); + rem_node.params()[0] = try transExpr(rp, scope, stmt.getLHS(), .used, .l_value); _ = try appendToken(rp.c, .Comma, ","); - const rhs = try transExpr(rp, scope, ZigClangBinaryOperator_getRHS(stmt), .used, .r_value); + const rhs = try transExpr(rp, scope, stmt.getRHS(), .used, .r_value); rem_node.params()[1] = rhs; rem_node.rparen_token = try appendToken(rp.c, .RParen, ")"); return maybeSuppressResult(rp, scope, result_used, &rem_node.base); @@ -1420,7 +1420,7 @@ fn transBinaryOperator( }, else => {}, } - const lhs_node = try transExpr(rp, scope, ZigClangBinaryOperator_getLHS(stmt), .used, .l_value); + const lhs_node = try transExpr(rp, scope, stmt.getLHS(), .used, .l_value); switch (op) { .Add => { if (cIsUnsignedInteger(qt)) { @@ -1498,7 +1498,7 @@ fn transBinaryOperator( else => unreachable, } - const rhs_node = try transExpr(rp, scope, ZigClangBinaryOperator_getRHS(stmt), .used, .r_value); + const rhs_node = try transExpr(rp, scope, stmt.getRHS(), .used, .r_value); const lhs = if (isBoolRes(lhs_node)) init: { const cast_node = try rp.c.createBuiltinCall("@boolToInt", 1); @@ -1520,18 +1520,18 @@ fn transBinaryOperator( fn transCompoundStmtInline( rp: RestorePoint, parent_scope: *Scope, - stmt: *const ZigClangCompoundStmt, + stmt: *const clang.CompoundStmt, block: *Scope.Block, ) TransError!void { - var it = ZigClangCompoundStmt_body_begin(stmt); - const end_it = ZigClangCompoundStmt_body_end(stmt); + var it = stmt.body_begin(); + const end_it = stmt.body_end(); while (it != end_it) : (it += 1) { const result = try transStmt(rp, parent_scope, it[0], .unused, .r_value); try block.statements.append(result); } } -fn transCompoundStmt(rp: RestorePoint, scope: *Scope, stmt: *const ZigClangCompoundStmt) TransError!*ast.Node { +fn transCompoundStmt(rp: RestorePoint, scope: *Scope, stmt: *const clang.CompoundStmt) TransError!*ast.Node { var block_scope = try Scope.Block.init(rp.c, scope, false); defer block_scope.deinit(); try transCompoundStmtInline(rp, &block_scope.base, stmt, &block_scope); @@ -1541,17 +1541,17 @@ fn transCompoundStmt(rp: RestorePoint, scope: *Scope, stmt: *const ZigClangCompo fn transCStyleCastExprClass( rp: RestorePoint, scope: *Scope, - stmt: *const ZigClangCStyleCastExpr, + stmt: *const clang.CStyleCastExpr, result_used: ResultUsed, lrvalue: LRValue, ) TransError!*ast.Node { - const sub_expr = ZigClangCStyleCastExpr_getSubExpr(stmt); + const sub_expr = stmt.getSubExpr(); const cast_node = (try transCCast( rp, scope, - ZigClangCStyleCastExpr_getBeginLoc(stmt), - ZigClangCStyleCastExpr_getType(stmt), - ZigClangExpr_getType(sub_expr), + stmt.getBeginLoc(), + stmt.getType(), + sub_expr.getType(), try transExpr(rp, scope, sub_expr, .used, lrvalue), )); return maybeSuppressResult(rp, scope, result_used, cast_node); @@ -1560,22 +1560,20 @@ fn transCStyleCastExprClass( fn transDeclStmtOne( rp: RestorePoint, scope: *Scope, - decl: *const ZigClangDecl, + decl: *const clang.Decl, block_scope: *Scope.Block, ) TransError!*ast.Node { const c = rp.c; - switch (ZigClangDecl_getKind(decl)) { + switch (decl.getKind()) { .Var => { - const var_decl = @ptrCast(*const ZigClangVarDecl, decl); + const var_decl = @ptrCast(*const clang.VarDecl, decl); - const qual_type = ZigClangVarDecl_getTypeSourceInfo_getType(var_decl); - const name = try c.str(ZigClangNamedDecl_getName_bytes_begin( - @ptrCast(*const ZigClangNamedDecl, var_decl), - )); + const qual_type = var_decl.getTypeSourceInfo_getType(); + const name = try c.str(@ptrCast(*const clang.NamedDecl, var_decl).getName_bytes_begin()); const mangled_name = try block_scope.makeMangledName(c, name); - switch (ZigClangVarDecl_getStorageClass(var_decl)) { + switch (var_decl.getStorageClass()) { .Extern, .Static => { // This is actually a global variable, put it in the global scope and reference it. // `_ = mangled_name;` @@ -1585,18 +1583,18 @@ fn transDeclStmtOne( else => {}, } - const mut_tok = if (ZigClangQualType_isConstQualified(qual_type)) + const mut_tok = if (qual_type.isConstQualified()) try appendToken(c, .Keyword_const, "const") else try appendToken(c, .Keyword_var, "var"); const name_tok = try appendIdentifier(c, mangled_name); _ = try appendToken(c, .Colon, ":"); - const loc = ZigClangDecl_getLocation(decl); + const loc = decl.getLocation(); const type_node = try transQualType(rp, qual_type, loc); const eq_token = try appendToken(c, .Equal, "="); - var init_node = if (ZigClangVarDecl_getInit(var_decl)) |expr| + var init_node = if (var_decl.getInit()) |expr| try transExprCoercing(rp, scope, expr, .used, .r_value) else try transCreateNodeUndefinedLiteral(c); @@ -1619,13 +1617,11 @@ fn transDeclStmtOne( return &node.base; }, .Typedef => { - const typedef_decl = @ptrCast(*const ZigClangTypedefNameDecl, decl); - const name = try c.str(ZigClangNamedDecl_getName_bytes_begin( - @ptrCast(*const ZigClangNamedDecl, typedef_decl), - )); + const typedef_decl = @ptrCast(*const clang.TypedefNameDecl, decl); + const name = try c.str(@ptrCast(*const clang.NamedDecl, typedef_decl).getName_bytes_begin()); - const underlying_qual = ZigClangTypedefNameDecl_getUnderlyingType(typedef_decl); - const underlying_type = ZigClangQualType_getTypePtr(underlying_qual); + const underlying_qual = typedef_decl.getUnderlyingType(); + const underlying_type = underlying_qual.getTypePtr(); const mangled_name = try block_scope.makeMangledName(c, name); const node = (try transCreateNodeTypedef(rp, typedef_decl, false, mangled_name)) orelse @@ -1635,18 +1631,18 @@ fn transDeclStmtOne( else => |kind| return revertAndWarn( rp, error.UnsupportedTranslation, - ZigClangDecl_getLocation(decl), + decl.getLocation(), "TODO implement translation of DeclStmt kind {}", .{@tagName(kind)}, ), } } -fn transDeclStmt(rp: RestorePoint, scope: *Scope, stmt: *const ZigClangDeclStmt) TransError!*ast.Node { +fn transDeclStmt(rp: RestorePoint, scope: *Scope, stmt: *const clang.DeclStmt) TransError!*ast.Node { const block_scope = scope.findBlockScope(rp.c) catch unreachable; - var it = ZigClangDeclStmt_decl_begin(stmt); - const end_it = ZigClangDeclStmt_decl_end(stmt); + var it = stmt.decl_begin(); + const end_it = stmt.decl_end(); assert(it != end_it); while (true) : (it += 1) { const node = try transDeclStmtOne(rp, scope, it[0], block_scope); @@ -1663,11 +1659,11 @@ fn transDeclStmt(rp: RestorePoint, scope: *Scope, stmt: *const ZigClangDeclStmt) fn transDeclRefExpr( rp: RestorePoint, scope: *Scope, - expr: *const ZigClangDeclRefExpr, + expr: *const clang.DeclRefExpr, lrvalue: LRValue, ) TransError!*ast.Node { - const value_decl = ZigClangDeclRefExpr_getDecl(expr); - const name = try rp.c.str(ZigClangNamedDecl_getName_bytes_begin(@ptrCast(*const ZigClangNamedDecl, value_decl))); + const value_decl = expr.getDecl(); + const name = try rp.c.str(@ptrCast(*const clang.NamedDecl, value_decl).getName_bytes_begin()); const mangled_name = scope.getAlias(name); return transCreateNodeIdentifier(rp.c, mangled_name); } @@ -1675,17 +1671,17 @@ fn transDeclRefExpr( fn transImplicitCastExpr( rp: RestorePoint, scope: *Scope, - expr: *const ZigClangImplicitCastExpr, + expr: *const clang.ImplicitCastExpr, result_used: ResultUsed, ) TransError!*ast.Node { const c = rp.c; - const sub_expr = ZigClangImplicitCastExpr_getSubExpr(expr); - const dest_type = getExprQualType(c, @ptrCast(*const ZigClangExpr, expr)); + const sub_expr = expr.getSubExpr(); + const dest_type = getExprQualType(c, @ptrCast(*const clang.Expr, expr)); const src_type = getExprQualType(c, sub_expr); - switch (ZigClangImplicitCastExpr_getCastKind(expr)) { + switch (expr.getCastKind()) { .BitCast, .FloatingCast, .FloatingToIntegral, .IntegralToFloating, .IntegralCast, .PointerToIntegral, .IntegralToPointer => { const sub_expr_node = try transExpr(rp, scope, sub_expr, .used, .r_value); - return try transCCast(rp, scope, ZigClangImplicitCastExpr_getBeginLoc(expr), dest_type, src_type, sub_expr_node); + return try transCCast(rp, scope, expr.getBeginLoc(), dest_type, src_type, sub_expr_node); }, .LValueToRValue, .NoOp, .FunctionToPointerDecay => { const sub_expr_node = try transExpr(rp, scope, sub_expr, .used, .r_value); @@ -1730,7 +1726,7 @@ fn transImplicitCastExpr( else => |kind| return revertAndWarn( rp, error.UnsupportedTranslation, - ZigClangStmt_getBeginLoc(@ptrCast(*const ZigClangStmt, expr)), + @ptrCast(*const clang.Stmt, expr).getBeginLoc(), "TODO implement translation of CastKind {}", .{@tagName(kind)}, ), @@ -1740,15 +1736,15 @@ fn transImplicitCastExpr( fn transBoolExpr( rp: RestorePoint, scope: *Scope, - expr: *const ZigClangExpr, + expr: *const clang.Expr, used: ResultUsed, lrvalue: LRValue, grouped: bool, ) TransError!*ast.Node { - if (ZigClangStmt_getStmtClass(@ptrCast(*const ZigClangStmt, expr)) == .IntegerLiteralClass) { + if (@ptrCast(*const clang.Stmt, expr).getStmtClass() == .IntegerLiteralClass) { var is_zero: bool = undefined; - if (!ZigClangIntegerLiteral_isZero(@ptrCast(*const ZigClangIntegerLiteral, expr), &is_zero, rp.c.clang_context)) { - return revertAndWarn(rp, error.UnsupportedTranslation, ZigClangExpr_getBeginLoc(expr), "invalid integer literal", .{}); + if (!(@ptrCast(*const clang.IntegerLiteral, expr).isZero(&is_zero, rp.c.clang_context))) { + return revertAndWarn(rp, error.UnsupportedTranslation, expr.getBeginLoc(), "invalid integer literal", .{}); } return try transCreateNodeBoolLiteral(rp.c, !is_zero); } @@ -1769,8 +1765,8 @@ fn transBoolExpr( return res; } - const ty = ZigClangQualType_getTypePtr(getExprQualType(rp.c, expr)); - const node = try finishBoolExpr(rp, scope, ZigClangExpr_getBeginLoc(expr), ty, res, used); + const ty = getExprQualType(rp.c, expr).getTypePtr(); + const node = try finishBoolExpr(rp, scope, expr.getBeginLoc(), ty, res, used); if (grouped) { const rparen = try appendToken(rp.c, .RParen, ")"); @@ -1786,16 +1782,16 @@ fn transBoolExpr( } } -fn exprIsBooleanType(expr: *const ZigClangExpr) bool { - return qualTypeIsBoolean(ZigClangExpr_getType(expr)); +fn exprIsBooleanType(expr: *const clang.Expr) bool { + return qualTypeIsBoolean(expr.getType()); } -fn exprIsStringLiteral(expr: *const ZigClangExpr) bool { - switch (ZigClangExpr_getStmtClass(expr)) { +fn exprIsStringLiteral(expr: *const clang.Expr) bool { + switch (expr.getStmtClass()) { .StringLiteralClass => return true, .PredefinedExprClass => return true, .UnaryOperatorClass => { - const op_expr = ZigClangUnaryOperator_getSubExpr(@ptrCast(*const ZigClangUnaryOperator, expr)); + const op_expr = @ptrCast(*const clang.UnaryOperator, expr).getSubExpr(); return exprIsStringLiteral(op_expr); }, else => return false, @@ -1825,16 +1821,16 @@ fn isBoolRes(res: *ast.Node) bool { fn finishBoolExpr( rp: RestorePoint, scope: *Scope, - loc: ZigClangSourceLocation, - ty: *const ZigClangType, + loc: clang.SourceLocation, + ty: *const clang.Type, node: *ast.Node, used: ResultUsed, ) TransError!*ast.Node { - switch (ZigClangType_getTypeClass(ty)) { + switch (ty.getTypeClass()) { .Builtin => { - const builtin_ty = @ptrCast(*const ZigClangBuiltinType, ty); + const builtin_ty = @ptrCast(*const clang.BuiltinType, ty); - switch (ZigClangBuiltinType_getKind(builtin_ty)) { + switch (builtin_ty.getKind()) { .Bool => return node, .Char_U, .UChar, @@ -1879,10 +1875,10 @@ fn finishBoolExpr( return transCreateNodeInfixOp(rp, scope, node, .BangEqual, op_token, rhs_node, used, false); }, .Typedef => { - const typedef_ty = @ptrCast(*const ZigClangTypedefType, ty); - const typedef_decl = ZigClangTypedefType_getDecl(typedef_ty); - const underlying_type = ZigClangTypedefNameDecl_getUnderlyingType(typedef_decl); - return finishBoolExpr(rp, scope, loc, ZigClangQualType_getTypePtr(underlying_type), node, used); + const typedef_ty = @ptrCast(*const clang.TypedefType, ty); + const typedef_decl = typedef_ty.getDecl(); + const underlying_type = typedef_decl.getUnderlyingType(); + return finishBoolExpr(rp, scope, loc, underlying_type.getTypePtr(), node, used); }, .Enum => { const op_token = try appendToken(rp.c, .BangEqual, "!="); @@ -1890,9 +1886,9 @@ fn finishBoolExpr( return transCreateNodeInfixOp(rp, scope, node, .BangEqual, op_token, rhs_node, used, false); }, .Elaborated => { - const elaborated_ty = @ptrCast(*const ZigClangElaboratedType, ty); - const named_type = ZigClangElaboratedType_getNamedType(elaborated_ty); - return finishBoolExpr(rp, scope, loc, ZigClangQualType_getTypePtr(named_type), node, used); + const elaborated_ty = @ptrCast(*const clang.ElaboratedType, ty); + const named_type = elaborated_ty.getNamedType(); + return finishBoolExpr(rp, scope, loc, named_type.getTypePtr(), node, used); }, else => {}, } @@ -1906,18 +1902,18 @@ const SuppressCast = enum { fn transIntegerLiteral( rp: RestorePoint, scope: *Scope, - expr: *const ZigClangIntegerLiteral, + expr: *const clang.IntegerLiteral, result_used: ResultUsed, suppress_as: SuppressCast, ) TransError!*ast.Node { - var eval_result: ZigClangExprEvalResult = undefined; - if (!ZigClangIntegerLiteral_EvaluateAsInt(expr, &eval_result, rp.c.clang_context)) { - const loc = ZigClangIntegerLiteral_getBeginLoc(expr); + var eval_result: clang.ExprEvalResult = undefined; + if (!expr.EvaluateAsInt(&eval_result, rp.c.clang_context)) { + const loc = expr.getBeginLoc(); return revertAndWarn(rp, error.UnsupportedTranslation, loc, "invalid integer literal", .{}); } if (suppress_as == .no_as) { - const int_lit_node = try transCreateNodeAPInt(rp.c, ZigClangAPValue_getInt(&eval_result.Val)); + const int_lit_node = try transCreateNodeAPInt(rp.c, eval_result.Val.getInt()); return maybeSuppressResult(rp, scope, result_used, int_lit_node); } @@ -1932,12 +1928,12 @@ fn transIntegerLiteral( // But the first step is to be correct, and the next step is to make the output more elegant. // @as(T, x) - const expr_base = @ptrCast(*const ZigClangExpr, expr); + const expr_base = @ptrCast(*const clang.Expr, expr); const as_node = try rp.c.createBuiltinCall("@as", 2); - const ty_node = try transQualType(rp, ZigClangExpr_getType(expr_base), ZigClangExpr_getBeginLoc(expr_base)); + const ty_node = try transQualType(rp, expr_base.getType(), expr_base.getBeginLoc()); as_node.params()[0] = ty_node; _ = try appendToken(rp.c, .Comma, ","); - as_node.params()[1] = try transCreateNodeAPInt(rp.c, ZigClangAPValue_getInt(&eval_result.Val)); + as_node.params()[1] = try transCreateNodeAPInt(rp.c, eval_result.Val.getInt()); as_node.rparen_token = try appendToken(rp.c, .RParen, ")"); return maybeSuppressResult(rp, scope, result_used, &as_node.base); @@ -1946,10 +1942,10 @@ fn transIntegerLiteral( fn transReturnStmt( rp: RestorePoint, scope: *Scope, - expr: *const ZigClangReturnStmt, + expr: *const clang.ReturnStmt, ) TransError!*ast.Node { const return_kw = try appendToken(rp.c, .Keyword_return, "return"); - const rhs: ?*ast.Node = if (ZigClangReturnStmt_getRetValue(expr)) |val_expr| + const rhs: ?*ast.Node = if (expr.getRetValue()) |val_expr| try transExprCoercing(rp, scope, val_expr, .used, .r_value) else null; @@ -1966,14 +1962,14 @@ fn transReturnStmt( fn transStringLiteral( rp: RestorePoint, scope: *Scope, - stmt: *const ZigClangStringLiteral, + stmt: *const clang.StringLiteral, result_used: ResultUsed, ) TransError!*ast.Node { - const kind = ZigClangStringLiteral_getKind(stmt); + const kind = stmt.getKind(); switch (kind) { .Ascii, .UTF8 => { var len: usize = undefined; - const bytes_ptr = ZigClangStringLiteral_getString_bytes_begin_size(stmt, &len); + const bytes_ptr = stmt.getString_bytes_begin_size(&len); const str = bytes_ptr[0..len]; var char_buf: [4]u8 = undefined; @@ -1996,7 +1992,7 @@ fn transStringLiteral( .UTF16, .UTF32, .Wide => return revertAndWarn( rp, error.UnsupportedTranslation, - ZigClangStmt_getBeginLoc(@ptrCast(*const ZigClangStmt, stmt)), + @ptrCast(*const clang.Stmt, stmt).getBeginLoc(), "TODO: support string literal kind {}", .{kind}, ), @@ -2041,13 +2037,13 @@ fn escapeChar(c: u8, char_buf: *[4]u8) []const u8 { fn transCCast( rp: RestorePoint, scope: *Scope, - loc: ZigClangSourceLocation, - dst_type: ZigClangQualType, - src_type: ZigClangQualType, + loc: clang.SourceLocation, + dst_type: clang.QualType, + src_type: clang.QualType, expr: *ast.Node, ) !*ast.Node { - if (ZigClangType_isVoidType(qualTypeCanon(dst_type))) return expr; - if (ZigClangQualType_eq(dst_type, src_type)) return expr; + if (qualTypeCanon(dst_type).isVoidType()) return expr; + if (dst_type.eq(src_type)) return expr; if (qualTypeIsPtr(dst_type) and qualTypeIsPtr(src_type)) return transCPtrCast(rp, loc, dst_type, src_type, expr); if (cIsInteger(dst_type) and cIsInteger(src_type)) { @@ -2134,9 +2130,7 @@ fn transCCast( builtin_node.rparen_token = try appendToken(rp.c, .RParen, ")"); return &builtin_node.base; } - if (ZigClangType_isBooleanType(qualTypeCanon(src_type)) and - !ZigClangType_isBooleanType(qualTypeCanon(dst_type))) - { + if (qualTypeIsBoolean(src_type) and !qualTypeIsBoolean(dst_type)) { // @boolToInt returns either a comptime_int or a u1 const builtin_node = try rp.c.createBuiltinCall("@boolToInt", 1); builtin_node.params()[0] = expr; @@ -2166,7 +2160,7 @@ fn transCCast( return &cast_node.base; } - if (ZigClangQualType_getTypeClass(ZigClangQualType_getCanonicalType(dst_type)) == .Enum) { + if (dst_type.getCanonicalType().getTypeClass() == .Enum) { const builtin_node = try rp.c.createBuiltinCall("@intToEnum", 2); builtin_node.params()[0] = try transQualType(rp, dst_type, loc); _ = try appendToken(rp.c, .Comma, ","); @@ -2174,8 +2168,8 @@ fn transCCast( builtin_node.rparen_token = try appendToken(rp.c, .RParen, ")"); return &builtin_node.base; } - if (ZigClangQualType_getTypeClass(ZigClangQualType_getCanonicalType(src_type)) == .Enum and - ZigClangQualType_getTypeClass(ZigClangQualType_getCanonicalType(dst_type)) != .Enum) + if (src_type.getCanonicalType().getTypeClass() == .Enum and + dst_type.getCanonicalType().getTypeClass() != .Enum) { const builtin_node = try rp.c.createBuiltinCall("@enumToInt", 1); builtin_node.params()[0] = expr; @@ -2193,11 +2187,11 @@ fn transCCast( fn transExpr( rp: RestorePoint, scope: *Scope, - expr: *const ZigClangExpr, + expr: *const clang.Expr, used: ResultUsed, lrvalue: LRValue, ) TransError!*ast.Node { - return transStmt(rp, scope, @ptrCast(*const ZigClangStmt, expr), used, lrvalue); + return transStmt(rp, scope, @ptrCast(*const clang.Stmt, expr), used, lrvalue); } /// Same as `transExpr` but with the knowledge that the operand will be type coerced, and therefore @@ -2205,21 +2199,21 @@ fn transExpr( fn transExprCoercing( rp: RestorePoint, scope: *Scope, - expr: *const ZigClangExpr, + expr: *const clang.Expr, used: ResultUsed, lrvalue: LRValue, ) TransError!*ast.Node { - switch (ZigClangStmt_getStmtClass(@ptrCast(*const ZigClangStmt, expr))) { + switch (@ptrCast(*const clang.Stmt, expr).getStmtClass()) { .IntegerLiteralClass => { - return transIntegerLiteral(rp, scope, @ptrCast(*const ZigClangIntegerLiteral, expr), .used, .no_as); + return transIntegerLiteral(rp, scope, @ptrCast(*const clang.IntegerLiteral, expr), .used, .no_as); }, .CharacterLiteralClass => { - return transCharLiteral(rp, scope, @ptrCast(*const ZigClangCharacterLiteral, expr), .used, .no_as); + return transCharLiteral(rp, scope, @ptrCast(*const clang.CharacterLiteral, expr), .used, .no_as); }, .UnaryOperatorClass => { - const un_expr = @ptrCast(*const ZigClangUnaryOperator, expr); - if (ZigClangUnaryOperator_getOpcode(un_expr) == .Extension) { - return transExprCoercing(rp, scope, ZigClangUnaryOperator_getSubExpr(un_expr), used, lrvalue); + const un_expr = @ptrCast(*const clang.UnaryOperator, expr); + if (un_expr.getOpcode() == .Extension) { + return transExprCoercing(rp, scope, un_expr.getSubExpr(), used, lrvalue); } }, else => {}, @@ -2230,51 +2224,51 @@ fn transExprCoercing( fn transInitListExprRecord( rp: RestorePoint, scope: *Scope, - loc: ZigClangSourceLocation, - expr: *const ZigClangInitListExpr, - ty: *const ZigClangType, + loc: clang.SourceLocation, + expr: *const clang.InitListExpr, + ty: *const clang.Type, used: ResultUsed, ) TransError!*ast.Node { var is_union_type = false; // Unions and Structs are both represented as RecordDecl - const record_ty = ZigClangType_getAsRecordType(ty) orelse + const record_ty = ty.getAsRecordType() orelse blk: { is_union_type = true; - break :blk ZigClangType_getAsUnionType(ty); + break :blk ty.getAsUnionType(); } orelse unreachable; - const record_decl = ZigClangRecordType_getDecl(record_ty); - const record_def = ZigClangRecordDecl_getDefinition(record_decl) orelse + const record_decl = record_ty.getDecl(); + const record_def = record_decl.getDefinition() orelse unreachable; const ty_node = try transType(rp, ty, loc); - const init_count = ZigClangInitListExpr_getNumInits(expr); + const init_count = expr.getNumInits(); var field_inits = std.ArrayList(*ast.Node).init(rp.c.gpa); defer field_inits.deinit(); _ = try appendToken(rp.c, .LBrace, "{"); var init_i: c_uint = 0; - var it = ZigClangRecordDecl_field_begin(record_def); - const end_it = ZigClangRecordDecl_field_end(record_def); - while (ZigClangRecordDecl_field_iterator_neq(it, end_it)) : (it = ZigClangRecordDecl_field_iterator_next(it)) { - const field_decl = ZigClangRecordDecl_field_iterator_deref(it); + var it = record_def.field_begin(); + const end_it = record_def.field_end(); + while (it.neq(end_it)) : (it = it.next()) { + const field_decl = it.deref(); // The initializer for a union type has a single entry only - if (is_union_type and field_decl != ZigClangInitListExpr_getInitializedFieldInUnion(expr)) { + if (is_union_type and field_decl != expr.getInitializedFieldInUnion()) { continue; } assert(init_i < init_count); - const elem_expr = ZigClangInitListExpr_getInit(expr, init_i); + const elem_expr = expr.getInit(init_i); init_i += 1; // Generate the field assignment expression: // .field_name = expr const period_tok = try appendToken(rp.c, .Period, "."); - var raw_name = try rp.c.str(ZigClangNamedDecl_getName_bytes_begin(@ptrCast(*const ZigClangNamedDecl, field_decl))); - if (ZigClangFieldDecl_isAnonymousStructOrUnion(field_decl)) { - const name = rp.c.decl_table.get(@ptrToInt(ZigClangFieldDecl_getCanonicalDecl(field_decl))).?; + var raw_name = try rp.c.str(@ptrCast(*const clang.NamedDecl, field_decl).getName_bytes_begin()); + if (field_decl.isAnonymousStructOrUnion()) { + const name = rp.c.decl_table.get(@ptrToInt(field_decl.getCanonicalDecl())).?; raw_name = try mem.dupe(rp.c.arena, u8, name); } const field_name_tok = try appendIdentifier(rp.c, raw_name); @@ -2304,8 +2298,8 @@ fn transInitListExprRecord( fn transCreateNodeArrayType( rp: RestorePoint, - source_loc: ZigClangSourceLocation, - ty: *const ZigClangType, + source_loc: clang.SourceLocation, + ty: *const clang.Type, len: anytype, ) !*ast.Node { const node = try rp.c.arena.create(ast.Node.ArrayType); @@ -2323,18 +2317,18 @@ fn transCreateNodeArrayType( fn transInitListExprArray( rp: RestorePoint, scope: *Scope, - loc: ZigClangSourceLocation, - expr: *const ZigClangInitListExpr, - ty: *const ZigClangType, + loc: clang.SourceLocation, + expr: *const clang.InitListExpr, + ty: *const clang.Type, used: ResultUsed, ) TransError!*ast.Node { - const arr_type = ZigClangType_getAsArrayTypeUnsafe(ty); - const child_qt = ZigClangArrayType_getElementType(arr_type); - const init_count = ZigClangInitListExpr_getNumInits(expr); - assert(ZigClangType_isConstantArrayType(@ptrCast(*const ZigClangType, arr_type))); - const const_arr_ty = @ptrCast(*const ZigClangConstantArrayType, arr_type); - const size_ap_int = ZigClangConstantArrayType_getSize(const_arr_ty); - const all_count = ZigClangAPInt_getLimitedValue(size_ap_int, math.maxInt(usize)); + const arr_type = ty.getAsArrayTypeUnsafe(); + const child_qt = arr_type.getElementType(); + const init_count = expr.getNumInits(); + assert(@ptrCast(*const clang.Type, arr_type).isConstantArrayType()); + const const_arr_ty = @ptrCast(*const clang.ConstantArrayType, arr_type); + const size_ap_int = const_arr_ty.getSize(); + const all_count = size_ap_int.getLimitedValue(math.maxInt(usize)); const leftover_count = all_count - init_count; var init_node: *ast.Node.ArrayInitializer = undefined; @@ -2343,7 +2337,7 @@ fn transInitListExprArray( const ty_node = try transCreateNodeArrayType( rp, loc, - ZigClangQualType_getTypePtr(child_qt), + child_qt.getTypePtr(), init_count, ); _ = try appendToken(rp.c, .LBrace, "{"); @@ -2357,7 +2351,7 @@ fn transInitListExprArray( var i: c_uint = 0; while (i < init_count) : (i += 1) { - const elem_expr = ZigClangInitListExpr_getInit(expr, i); + const elem_expr = expr.getInit(i); init_list[i] = try transExpr(rp, scope, elem_expr, .used, .r_value); _ = try appendToken(rp.c, .Comma, ","); } @@ -2368,7 +2362,7 @@ fn transInitListExprArray( cat_tok = try appendToken(rp.c, .PlusPlus, "++"); } - const ty_node = try transCreateNodeArrayType(rp, loc, ZigClangQualType_getTypePtr(child_qt), 1); + const ty_node = try transCreateNodeArrayType(rp, loc, child_qt.getTypePtr(), 1); _ = try appendToken(rp.c, .LBrace, "{"); const filler_init_node = try ast.Node.ArrayInitializer.alloc(rp.c.arena, 1); filler_init_node.* = .{ @@ -2376,7 +2370,7 @@ fn transInitListExprArray( .rtoken = undefined, .list_len = 1, }; - const filler_val_expr = ZigClangInitListExpr_getArrayFiller(expr); + const filler_val_expr = expr.getArrayFiller(); filler_init_node.list()[0] = try transExpr(rp, scope, filler_val_expr, .used, .r_value); filler_init_node.rtoken = try appendToken(rp.c, .RBrace, "}"); @@ -2411,14 +2405,14 @@ fn transInitListExprArray( fn transInitListExpr( rp: RestorePoint, scope: *Scope, - expr: *const ZigClangInitListExpr, + expr: *const clang.InitListExpr, used: ResultUsed, ) TransError!*ast.Node { - const qt = getExprQualType(rp.c, @ptrCast(*const ZigClangExpr, expr)); - var qual_type = ZigClangQualType_getTypePtr(qt); - const source_loc = ZigClangExpr_getBeginLoc(@ptrCast(*const ZigClangExpr, expr)); + const qt = getExprQualType(rp.c, @ptrCast(*const clang.Expr, expr)); + var qual_type = qt.getTypePtr(); + const source_loc = @ptrCast(*const clang.Expr, expr).getBeginLoc(); - if (ZigClangType_isRecordType(qual_type)) { + if (qual_type.isRecordType()) { return transInitListExprRecord( rp, scope, @@ -2427,7 +2421,7 @@ fn transInitListExpr( qual_type, used, ); - } else if (ZigClangType_isArrayType(qual_type)) { + } else if (qual_type.isArrayType()) { return transInitListExprArray( rp, scope, @@ -2437,7 +2431,7 @@ fn transInitListExpr( used, ); } else { - const type_name = rp.c.str(ZigClangType_getTypeClassName(qual_type)); + const type_name = rp.c.str(qual_type.getTypeClassName()); return revertAndWarn(rp, error.UnsupportedType, source_loc, "unsupported initlist type: '{}'", .{type_name}); } } @@ -2445,13 +2439,13 @@ fn transInitListExpr( fn transZeroInitExpr( rp: RestorePoint, scope: *Scope, - source_loc: ZigClangSourceLocation, - ty: *const ZigClangType, + source_loc: clang.SourceLocation, + ty: *const clang.Type, ) TransError!*ast.Node { - switch (ZigClangType_getTypeClass(ty)) { + switch (ty.getTypeClass()) { .Builtin => { - const builtin_ty = @ptrCast(*const ZigClangBuiltinType, ty); - switch (ZigClangBuiltinType_getKind(builtin_ty)) { + const builtin_ty = @ptrCast(*const clang.BuiltinType, ty); + switch (builtin_ty.getKind()) { .Bool => return try transCreateNodeBoolLiteral(rp.c, false), .Char_U, .UChar, @@ -2479,15 +2473,13 @@ fn transZeroInitExpr( }, .Pointer => return transCreateNodeNullLiteral(rp.c), .Typedef => { - const typedef_ty = @ptrCast(*const ZigClangTypedefType, ty); - const typedef_decl = ZigClangTypedefType_getDecl(typedef_ty); + const typedef_ty = @ptrCast(*const clang.TypedefType, ty); + const typedef_decl = typedef_ty.getDecl(); return transZeroInitExpr( rp, scope, source_loc, - ZigClangQualType_getTypePtr( - ZigClangTypedefNameDecl_getUnderlyingType(typedef_decl), - ), + typedef_decl.getUnderlyingType().getTypePtr(), ); }, else => {}, @@ -2499,19 +2491,19 @@ fn transZeroInitExpr( fn transImplicitValueInitExpr( rp: RestorePoint, scope: *Scope, - expr: *const ZigClangExpr, + expr: *const clang.Expr, used: ResultUsed, ) TransError!*ast.Node { - const source_loc = ZigClangExpr_getBeginLoc(expr); + const source_loc = expr.getBeginLoc(); const qt = getExprQualType(rp.c, expr); - const ty = ZigClangQualType_getTypePtr(qt); + const ty = qt.getTypePtr(); return transZeroInitExpr(rp, scope, source_loc, ty); } fn transIfStmt( rp: RestorePoint, scope: *Scope, - stmt: *const ZigClangIfStmt, + stmt: *const clang.IfStmt, ) TransError!*ast.Node { // if (c) t // if (c) t else e @@ -2524,13 +2516,13 @@ fn transIfStmt( }, }; defer cond_scope.deinit(); - const cond_expr = @ptrCast(*const ZigClangExpr, ZigClangIfStmt_getCond(stmt)); + const cond_expr = @ptrCast(*const clang.Expr, stmt.getCond()); if_node.condition = try transBoolExpr(rp, &cond_scope.base, cond_expr, .used, .r_value, false); _ = try appendToken(rp.c, .RParen, ")"); - if_node.body = try transStmt(rp, scope, ZigClangIfStmt_getThen(stmt), .unused, .r_value); + if_node.body = try transStmt(rp, scope, stmt.getThen(), .unused, .r_value); - if (ZigClangIfStmt_getElse(stmt)) |expr| { + if (stmt.getElse()) |expr| { if_node.@"else" = try transCreateNodeElse(rp.c); if_node.@"else".?.body = try transStmt(rp, scope, expr, .unused, .r_value); } @@ -2541,7 +2533,7 @@ fn transIfStmt( fn transWhileLoop( rp: RestorePoint, scope: *Scope, - stmt: *const ZigClangWhileStmt, + stmt: *const clang.WhileStmt, ) TransError!*ast.Node { const while_node = try transCreateNodeWhile(rp.c); @@ -2552,7 +2544,7 @@ fn transWhileLoop( }, }; defer cond_scope.deinit(); - const cond_expr = @ptrCast(*const ZigClangExpr, ZigClangWhileStmt_getCond(stmt)); + const cond_expr = @ptrCast(*const clang.Expr, stmt.getCond()); while_node.condition = try transBoolExpr(rp, &cond_scope.base, cond_expr, .used, .r_value, false); _ = try appendToken(rp.c, .RParen, ")"); @@ -2560,7 +2552,7 @@ fn transWhileLoop( .parent = scope, .id = .Loop, }; - while_node.body = try transStmt(rp, &loop_scope, ZigClangWhileStmt_getBody(stmt), .unused, .r_value); + while_node.body = try transStmt(rp, &loop_scope, stmt.getBody(), .unused, .r_value); _ = try appendToken(rp.c, .Semicolon, ";"); return &while_node.base; } @@ -2568,7 +2560,7 @@ fn transWhileLoop( fn transDoWhileLoop( rp: RestorePoint, scope: *Scope, - stmt: *const ZigClangDoStmt, + stmt: *const clang.DoStmt, ) TransError!*ast.Node { const while_node = try transCreateNodeWhile(rp.c); @@ -2590,13 +2582,13 @@ fn transDoWhileLoop( }; defer cond_scope.deinit(); const prefix_op = try transCreateNodeSimplePrefixOp(rp.c, .BoolNot, .Bang, "!"); - prefix_op.rhs = try transBoolExpr(rp, &cond_scope.base, @ptrCast(*const ZigClangExpr, ZigClangDoStmt_getCond(stmt)), .used, .r_value, true); + prefix_op.rhs = try transBoolExpr(rp, &cond_scope.base, @ptrCast(*const clang.Expr, stmt.getCond()), .used, .r_value, true); _ = try appendToken(rp.c, .RParen, ")"); if_node.condition = &prefix_op.base; if_node.body = &(try transCreateNodeBreak(rp.c, null, null)).base; _ = try appendToken(rp.c, .Semicolon, ";"); - const body_node = if (ZigClangStmt_getStmtClass(ZigClangDoStmt_getBody(stmt)) == .CompoundStmtClass) blk: { + const body_node = if (stmt.getBody().getStmtClass() == .CompoundStmtClass) blk: { // there's already a block in C, so we'll append our condition to it. // c: do { // c: a; @@ -2607,7 +2599,7 @@ fn transDoWhileLoop( // zig: b; // zig: if (!cond) break; // zig: } - const node = try transStmt(rp, &loop_scope, ZigClangDoStmt_getBody(stmt), .unused, .r_value); + const node = try transStmt(rp, &loop_scope, stmt.getBody(), .unused, .r_value); break :blk node.castTag(.Block).?; } else blk: { // the C statement is without a block, so we need to create a block to contain it. @@ -2621,7 +2613,7 @@ fn transDoWhileLoop( new = true; const block = try rp.c.createBlock(2); block.statements_len = 1; // over-allocated so we can add another below - block.statements()[0] = try transStmt(rp, &loop_scope, ZigClangDoStmt_getBody(stmt), .unused, .r_value); + block.statements()[0] = try transStmt(rp, &loop_scope, stmt.getBody(), .unused, .r_value); break :blk block; }; @@ -2637,7 +2629,7 @@ fn transDoWhileLoop( fn transForLoop( rp: RestorePoint, scope: *Scope, - stmt: *const ZigClangForStmt, + stmt: *const clang.ForStmt, ) TransError!*ast.Node { var loop_scope = Scope{ .parent = scope, @@ -2647,7 +2639,7 @@ fn transForLoop( var block_scope: ?Scope.Block = null; defer if (block_scope) |*bs| bs.deinit(); - if (ZigClangForStmt_getInit(stmt)) |init| { + if (stmt.getInit()) |init| { block_scope = try Scope.Block.init(rp.c, scope, false); loop_scope.parent = &block_scope.?.base; const init_node = try transStmt(rp, &block_scope.?.base, init, .unused, .r_value); @@ -2662,20 +2654,20 @@ fn transForLoop( defer cond_scope.deinit(); const while_node = try transCreateNodeWhile(rp.c); - while_node.condition = if (ZigClangForStmt_getCond(stmt)) |cond| + while_node.condition = if (stmt.getCond()) |cond| try transBoolExpr(rp, &cond_scope.base, cond, .used, .r_value, false) else try transCreateNodeBoolLiteral(rp.c, true); _ = try appendToken(rp.c, .RParen, ")"); - if (ZigClangForStmt_getInc(stmt)) |incr| { + if (stmt.getInc()) |incr| { _ = try appendToken(rp.c, .Colon, ":"); _ = try appendToken(rp.c, .LParen, "("); while_node.continue_expr = try transExpr(rp, &cond_scope.base, incr, .unused, .r_value); _ = try appendToken(rp.c, .RParen, ")"); } - while_node.body = try transStmt(rp, &loop_scope, ZigClangForStmt_getBody(stmt), .unused, .r_value); + while_node.body = try transStmt(rp, &loop_scope, stmt.getBody(), .unused, .r_value); if (block_scope) |*bs| { try bs.statements.append(&while_node.base); return try bs.complete(rp.c); @@ -2685,21 +2677,21 @@ fn transForLoop( } } -fn getSwitchCaseCount(stmt: *const ZigClangSwitchStmt) usize { - const body = ZigClangSwitchStmt_getBody(stmt); - assert(ZigClangStmt_getStmtClass(body) == .CompoundStmtClass); - const comp = @ptrCast(*const ZigClangCompoundStmt, body); +fn getSwitchCaseCount(stmt: *const clang.SwitchStmt) usize { + const body = stmt.getBody(); + assert(body.getStmtClass() == .CompoundStmtClass); + const comp = @ptrCast(*const clang.CompoundStmt, body); // TODO https://github.com/ziglang/zig/issues/1738 - // return ZigClangCompoundStmt_body_end(comp) - ZigClangCompoundStmt_body_begin(comp); - const start_addr = @ptrToInt(ZigClangCompoundStmt_body_begin(comp)); - const end_addr = @ptrToInt(ZigClangCompoundStmt_body_end(comp)); - return (end_addr - start_addr) / @sizeOf(*ZigClangStmt); + // return comp.body_end() - comp.body_begin(); + const start_addr = @ptrToInt(comp.body_begin()); + const end_addr = @ptrToInt(comp.body_end()); + return (end_addr - start_addr) / @sizeOf(*clang.Stmt); } fn transSwitch( rp: RestorePoint, scope: *Scope, - stmt: *const ZigClangSwitchStmt, + stmt: *const clang.SwitchStmt, ) TransError!*ast.Node { const switch_tok = try appendToken(rp.c, .Keyword_switch, "switch"); _ = try appendToken(rp.c, .LParen, "("); @@ -2713,7 +2705,7 @@ fn transSwitch( }, }; defer cond_scope.deinit(); - const switch_expr = try transExpr(rp, &cond_scope.base, ZigClangSwitchStmt_getCond(stmt), .used, .r_value); + const switch_expr = try transExpr(rp, &cond_scope.base, stmt.getCond(), .used, .r_value); _ = try appendToken(rp.c, .RParen, ")"); _ = try appendToken(rp.c, .LBrace, "{"); // reserve +1 case in case there is no default case @@ -2748,7 +2740,7 @@ fn transSwitch( switch_scope.pending_block = try Scope.Block.init(rp.c, scope, false); try switch_scope.pending_block.statements.append(&switch_node.base); - const last = try transStmt(rp, &block_scope.base, ZigClangSwitchStmt_getBody(stmt), .unused, .r_value); + const last = try transStmt(rp, &block_scope.base, stmt.getBody(), .unused, .r_value); _ = try appendToken(rp.c, .Semicolon, ";"); // take all pending statements @@ -2776,7 +2768,7 @@ fn transSwitch( _ = try appendToken(rp.c, .Comma, ","); if (switch_scope.case_index >= switch_scope.cases.len) - return revertAndWarn(rp, error.UnsupportedTranslation, ZigClangStmt_getBeginLoc(@ptrCast(*const ZigClangStmt, stmt)), "TODO complex switch cases", .{}); + return revertAndWarn(rp, error.UnsupportedTranslation, @ptrCast(*const clang.Stmt, stmt).getBeginLoc(), "TODO complex switch cases", .{}); switch_scope.cases[switch_scope.case_index] = &else_prong.base; switch_scope.case_index += 1; } @@ -2792,15 +2784,15 @@ fn transSwitch( fn transCase( rp: RestorePoint, scope: *Scope, - stmt: *const ZigClangCaseStmt, + stmt: *const clang.CaseStmt, ) TransError!*ast.Node { const block_scope = scope.findBlockScope(rp.c) catch unreachable; const switch_scope = scope.getSwitch(); const label = try block_scope.makeMangledName(rp.c, "case"); _ = try appendToken(rp.c, .Semicolon, ";"); - const expr = if (ZigClangCaseStmt_getRHS(stmt)) |rhs| blk: { - const lhs_node = try transExpr(rp, scope, ZigClangCaseStmt_getLHS(stmt), .used, .r_value); + const expr = if (stmt.getRHS()) |rhs| blk: { + const lhs_node = try transExpr(rp, scope, stmt.getLHS(), .used, .r_value); const ellips = try appendToken(rp.c, .Ellipsis3, "..."); const rhs_node = try transExpr(rp, scope, rhs, .used, .r_value); @@ -2813,7 +2805,7 @@ fn transCase( }; break :blk &node.base; } else - try transExpr(rp, scope, ZigClangCaseStmt_getLHS(stmt), .used, .r_value); + try transExpr(rp, scope, stmt.getLHS(), .used, .r_value); const switch_prong = try transCreateNodeSwitchCase(rp.c, expr); switch_prong.expr = blk: { @@ -2823,7 +2815,7 @@ fn transCase( _ = try appendToken(rp.c, .Comma, ","); if (switch_scope.case_index >= switch_scope.cases.len) - return revertAndWarn(rp, error.UnsupportedTranslation, ZigClangStmt_getBeginLoc(@ptrCast(*const ZigClangStmt, stmt)), "TODO complex switch cases", .{}); + return revertAndWarn(rp, error.UnsupportedTranslation, @ptrCast(*const clang.Stmt, stmt).getBeginLoc(), "TODO complex switch cases", .{}); switch_scope.cases[switch_scope.case_index] = &switch_prong.base; switch_scope.case_index += 1; @@ -2840,13 +2832,13 @@ fn transCase( try switch_scope.pending_block.statements.append(pending_node); - return transStmt(rp, scope, ZigClangCaseStmt_getSubStmt(stmt), .unused, .r_value); + return transStmt(rp, scope, stmt.getSubStmt(), .unused, .r_value); } fn transDefault( rp: RestorePoint, scope: *Scope, - stmt: *const ZigClangDefaultStmt, + stmt: *const clang.DefaultStmt, ) TransError!*ast.Node { const block_scope = scope.findBlockScope(rp.c) catch unreachable; const switch_scope = scope.getSwitch(); @@ -2861,7 +2853,7 @@ fn transDefault( _ = try appendToken(rp.c, .Comma, ","); if (switch_scope.case_index >= switch_scope.cases.len) - return revertAndWarn(rp, error.UnsupportedTranslation, ZigClangStmt_getBeginLoc(@ptrCast(*const ZigClangStmt, stmt)), "TODO complex switch cases", .{}); + return revertAndWarn(rp, error.UnsupportedTranslation, @ptrCast(*const clang.Stmt, stmt).getBeginLoc(), "TODO complex switch cases", .{}); switch_scope.cases[switch_scope.case_index] = &else_prong.base; switch_scope.case_index += 1; @@ -2877,26 +2869,26 @@ fn transDefault( switch_scope.pending_block = try Scope.Block.init(rp.c, scope, false); try switch_scope.pending_block.statements.append(pending_node); - return transStmt(rp, scope, ZigClangDefaultStmt_getSubStmt(stmt), .unused, .r_value); + return transStmt(rp, scope, stmt.getSubStmt(), .unused, .r_value); } -fn transConstantExpr(rp: RestorePoint, scope: *Scope, expr: *const ZigClangExpr, used: ResultUsed) TransError!*ast.Node { - var result: ZigClangExprEvalResult = undefined; - if (!ZigClangExpr_EvaluateAsConstantExpr(expr, &result, .EvaluateForCodeGen, rp.c.clang_context)) - return revertAndWarn(rp, error.UnsupportedTranslation, ZigClangExpr_getBeginLoc(expr), "invalid constant expression", .{}); +fn transConstantExpr(rp: RestorePoint, scope: *Scope, expr: *const clang.Expr, used: ResultUsed) TransError!*ast.Node { + var result: clang.ExprEvalResult = undefined; + if (!expr.EvaluateAsConstantExpr(&result, .EvaluateForCodeGen, rp.c.clang_context)) + return revertAndWarn(rp, error.UnsupportedTranslation, expr.getBeginLoc(), "invalid constant expression", .{}); var val_node: ?*ast.Node = null; - switch (ZigClangAPValue_getKind(&result.Val)) { + switch (result.Val.getKind()) { .Int => { // See comment in `transIntegerLiteral` for why this code is here. // @as(T, x) - const expr_base = @ptrCast(*const ZigClangExpr, expr); + const expr_base = @ptrCast(*const clang.Expr, expr); const as_node = try rp.c.createBuiltinCall("@as", 2); - const ty_node = try transQualType(rp, ZigClangExpr_getType(expr_base), ZigClangExpr_getBeginLoc(expr_base)); + const ty_node = try transQualType(rp, expr_base.getType(), expr_base.getBeginLoc()); as_node.params()[0] = ty_node; _ = try appendToken(rp.c, .Comma, ","); - const int_lit_node = try transCreateNodeAPInt(rp.c, ZigClangAPValue_getInt(&result.Val)); + const int_lit_node = try transCreateNodeAPInt(rp.c, result.Val.getInt()); as_node.params()[1] = int_lit_node; as_node.rparen_token = try appendToken(rp.c, .RParen, ")"); @@ -2904,26 +2896,26 @@ fn transConstantExpr(rp: RestorePoint, scope: *Scope, expr: *const ZigClangExpr, return maybeSuppressResult(rp, scope, used, &as_node.base); }, else => { - return revertAndWarn(rp, error.UnsupportedTranslation, ZigClangExpr_getBeginLoc(expr), "unsupported constant expression kind", .{}); + return revertAndWarn(rp, error.UnsupportedTranslation, expr.getBeginLoc(), "unsupported constant expression kind", .{}); }, } } -fn transPredefinedExpr(rp: RestorePoint, scope: *Scope, expr: *const ZigClangPredefinedExpr, used: ResultUsed) TransError!*ast.Node { - return transStringLiteral(rp, scope, ZigClangPredefinedExpr_getFunctionName(expr), used); +fn transPredefinedExpr(rp: RestorePoint, scope: *Scope, expr: *const clang.PredefinedExpr, used: ResultUsed) TransError!*ast.Node { + return transStringLiteral(rp, scope, expr.getFunctionName(), used); } fn transCharLiteral( rp: RestorePoint, scope: *Scope, - stmt: *const ZigClangCharacterLiteral, + stmt: *const clang.CharacterLiteral, result_used: ResultUsed, suppress_as: SuppressCast, ) TransError!*ast.Node { - const kind = ZigClangCharacterLiteral_getKind(stmt); + const kind = stmt.getKind(); const int_lit_node = switch (kind) { .Ascii, .UTF8 => blk: { - const val = ZigClangCharacterLiteral_getValue(stmt); + const val = stmt.getValue(); if (kind == .Ascii) { // C has a somewhat obscure feature called multi-character character // constant @@ -2942,7 +2934,7 @@ fn transCharLiteral( .UTF16, .UTF32, .Wide => return revertAndWarn( rp, error.UnsupportedTranslation, - ZigClangStmt_getBeginLoc(@ptrCast(*const ZigClangStmt, stmt)), + @ptrCast(*const clang.Stmt, stmt).getBeginLoc(), "TODO: support character literal kind {}", .{kind}, ), @@ -2952,9 +2944,9 @@ fn transCharLiteral( } // See comment in `transIntegerLiteral` for why this code is here. // @as(T, x) - const expr_base = @ptrCast(*const ZigClangExpr, stmt); + const expr_base = @ptrCast(*const clang.Expr, stmt); const as_node = try rp.c.createBuiltinCall("@as", 2); - const ty_node = try transQualType(rp, ZigClangExpr_getType(expr_base), ZigClangExpr_getBeginLoc(expr_base)); + const ty_node = try transQualType(rp, expr_base.getType(), expr_base.getBeginLoc()); as_node.params()[0] = ty_node; _ = try appendToken(rp.c, .Comma, ","); as_node.params()[1] = int_lit_node; @@ -2963,8 +2955,8 @@ fn transCharLiteral( return maybeSuppressResult(rp, scope, result_used, &as_node.base); } -fn transStmtExpr(rp: RestorePoint, scope: *Scope, stmt: *const ZigClangStmtExpr, used: ResultUsed) TransError!*ast.Node { - const comp = ZigClangStmtExpr_getSubStmt(stmt); +fn transStmtExpr(rp: RestorePoint, scope: *Scope, stmt: *const clang.StmtExpr, used: ResultUsed) TransError!*ast.Node { + const comp = stmt.getSubStmt(); if (used == .unused) { return transCompoundStmt(rp, scope, comp); } @@ -2972,8 +2964,8 @@ fn transStmtExpr(rp: RestorePoint, scope: *Scope, stmt: *const ZigClangStmtExpr, var block_scope = try Scope.Block.init(rp.c, scope, true); defer block_scope.deinit(); - var it = ZigClangCompoundStmt_body_begin(comp); - const end_it = ZigClangCompoundStmt_body_end(comp); + var it = comp.body_begin(); + const end_it = comp.body_end(); while (it != end_it - 1) : (it += 1) { const result = try transStmt(rp, &block_scope.base, it[0], .unused, .r_value); try block_scope.statements.append(result); @@ -2996,43 +2988,43 @@ fn transStmtExpr(rp: RestorePoint, scope: *Scope, stmt: *const ZigClangStmtExpr, return maybeSuppressResult(rp, scope, used, &grouped_expr.base); } -fn transMemberExpr(rp: RestorePoint, scope: *Scope, stmt: *const ZigClangMemberExpr, result_used: ResultUsed) TransError!*ast.Node { - var container_node = try transExpr(rp, scope, ZigClangMemberExpr_getBase(stmt), .used, .r_value); +fn transMemberExpr(rp: RestorePoint, scope: *Scope, stmt: *const clang.MemberExpr, result_used: ResultUsed) TransError!*ast.Node { + var container_node = try transExpr(rp, scope, stmt.getBase(), .used, .r_value); - if (ZigClangMemberExpr_isArrow(stmt)) { + if (stmt.isArrow()) { container_node = try transCreateNodePtrDeref(rp.c, container_node); } - const member_decl = ZigClangMemberExpr_getMemberDecl(stmt); + const member_decl = stmt.getMemberDecl(); const name = blk: { - const decl_kind = ZigClangDecl_getKind(@ptrCast(*const ZigClangDecl, member_decl)); + const decl_kind = @ptrCast(*const clang.Decl, member_decl).getKind(); // If we're referring to a anonymous struct/enum find the bogus name // we've assigned to it during the RecordDecl translation if (decl_kind == .Field) { - const field_decl = @ptrCast(*const struct_ZigClangFieldDecl, member_decl); - if (ZigClangFieldDecl_isAnonymousStructOrUnion(field_decl)) { - const name = rp.c.decl_table.get(@ptrToInt(ZigClangFieldDecl_getCanonicalDecl(field_decl))).?; + const field_decl = @ptrCast(*const clang.FieldDecl, member_decl); + if (field_decl.isAnonymousStructOrUnion()) { + const name = rp.c.decl_table.get(@ptrToInt(field_decl.getCanonicalDecl())).?; break :blk try mem.dupe(rp.c.arena, u8, name); } } - const decl = @ptrCast(*const ZigClangNamedDecl, member_decl); - break :blk try rp.c.str(ZigClangNamedDecl_getName_bytes_begin(decl)); + const decl = @ptrCast(*const clang.NamedDecl, member_decl); + break :blk try rp.c.str(decl.getName_bytes_begin()); }; const node = try transCreateNodeFieldAccess(rp.c, container_node, name); return maybeSuppressResult(rp, scope, result_used, node); } -fn transArrayAccess(rp: RestorePoint, scope: *Scope, stmt: *const ZigClangArraySubscriptExpr, result_used: ResultUsed) TransError!*ast.Node { - var base_stmt = ZigClangArraySubscriptExpr_getBase(stmt); +fn transArrayAccess(rp: RestorePoint, scope: *Scope, stmt: *const clang.ArraySubscriptExpr, result_used: ResultUsed) TransError!*ast.Node { + var base_stmt = stmt.getBase(); // Unwrap the base statement if it's an array decayed to a bare pointer type // so that we index the array itself - if (ZigClangStmt_getStmtClass(@ptrCast(*const ZigClangStmt, base_stmt)) == .ImplicitCastExprClass) { - const implicit_cast = @ptrCast(*const ZigClangImplicitCastExpr, base_stmt); + if (@ptrCast(*const clang.Stmt, base_stmt).getStmtClass() == .ImplicitCastExprClass) { + const implicit_cast = @ptrCast(*const clang.ImplicitCastExpr, base_stmt); - if (ZigClangImplicitCastExpr_getCastKind(implicit_cast) == .ArrayToPointerDecay) { - base_stmt = ZigClangImplicitCastExpr_getSubExpr(implicit_cast); + if (implicit_cast.getCastKind() == .ArrayToPointerDecay) { + base_stmt = implicit_cast.getSubExpr(); } } @@ -3040,7 +3032,7 @@ fn transArrayAccess(rp: RestorePoint, scope: *Scope, stmt: *const ZigClangArrayS const node = try transCreateNodeArrayAccess(rp.c, container_node); // cast if the index is long long or signed - const subscr_expr = ZigClangArraySubscriptExpr_getIdx(stmt); + const subscr_expr = stmt.getIdx(); const qt = getExprQualType(rp.c, subscr_expr); const is_longlong = cIsLongLongInteger(qt); const is_signed = cIsSignedInteger(qt); @@ -3062,23 +3054,23 @@ fn transArrayAccess(rp: RestorePoint, scope: *Scope, stmt: *const ZigClangArrayS return maybeSuppressResult(rp, scope, result_used, &node.base); } -fn transCallExpr(rp: RestorePoint, scope: *Scope, stmt: *const ZigClangCallExpr, result_used: ResultUsed) TransError!*ast.Node { - const callee = ZigClangCallExpr_getCallee(stmt); +fn transCallExpr(rp: RestorePoint, scope: *Scope, stmt: *const clang.CallExpr, result_used: ResultUsed) TransError!*ast.Node { + const callee = stmt.getCallee(); var raw_fn_expr = try transExpr(rp, scope, callee, .used, .r_value); var is_ptr = false; - const fn_ty = qualTypeGetFnProto(ZigClangExpr_getType(callee), &is_ptr); + const fn_ty = qualTypeGetFnProto(callee.getType(), &is_ptr); const fn_expr = if (is_ptr and fn_ty != null) blk: { - if (ZigClangExpr_getStmtClass(callee) == .ImplicitCastExprClass) { - const implicit_cast = @ptrCast(*const ZigClangImplicitCastExpr, callee); + if (callee.getStmtClass() == .ImplicitCastExprClass) { + const implicit_cast = @ptrCast(*const clang.ImplicitCastExpr, callee); - if (ZigClangImplicitCastExpr_getCastKind(implicit_cast) == .FunctionToPointerDecay) { - const subexpr = ZigClangImplicitCastExpr_getSubExpr(implicit_cast); - if (ZigClangExpr_getStmtClass(subexpr) == .DeclRefExprClass) { - const decl_ref = @ptrCast(*const ZigClangDeclRefExpr, subexpr); - const named_decl = ZigClangDeclRefExpr_getFoundDecl(decl_ref); - if (ZigClangDecl_getKind(@ptrCast(*const ZigClangDecl, named_decl)) == .Function) { + if (implicit_cast.getCastKind() == .FunctionToPointerDecay) { + const subexpr = implicit_cast.getSubExpr(); + if (subexpr.getStmtClass() == .DeclRefExprClass) { + const decl_ref = @ptrCast(*const clang.DeclRefExpr, subexpr); + const named_decl = decl_ref.getFoundDecl(); + if (@ptrCast(*const clang.Decl, named_decl).getKind() == .Function) { break :blk raw_fn_expr; } } @@ -3088,11 +3080,11 @@ fn transCallExpr(rp: RestorePoint, scope: *Scope, stmt: *const ZigClangCallExpr, } else raw_fn_expr; - const num_args = ZigClangCallExpr_getNumArgs(stmt); + const num_args = stmt.getNumArgs(); const node = try rp.c.createCall(fn_expr, num_args); const call_params = node.params(); - const args = ZigClangCallExpr_getArgs(stmt); + const args = stmt.getArgs(); var i: usize = 0; while (i < num_args) : (i += 1) { if (i != 0) { @@ -3103,9 +3095,9 @@ fn transCallExpr(rp: RestorePoint, scope: *Scope, stmt: *const ZigClangCallExpr, node.rtoken = try appendToken(rp.c, .RParen, ")"); if (fn_ty) |ty| { - const canon = ZigClangQualType_getCanonicalType(ty.getReturnType()); - const ret_ty = ZigClangQualType_getTypePtr(canon); - if (ZigClangType_isVoidType(ret_ty)) { + const canon = ty.getReturnType().getCanonicalType(); + const ret_ty = canon.getTypePtr(); + if (ret_ty.isVoidType()) { _ = try appendToken(rp.c, .Semicolon, ";"); return &node.base; } @@ -3115,32 +3107,32 @@ fn transCallExpr(rp: RestorePoint, scope: *Scope, stmt: *const ZigClangCallExpr, } const ClangFunctionType = union(enum) { - Proto: *const ZigClangFunctionProtoType, - NoProto: *const ZigClangFunctionType, + Proto: *const clang.FunctionProtoType, + NoProto: *const clang.FunctionType, - fn getReturnType(self: @This()) ZigClangQualType { + fn getReturnType(self: @This()) clang.QualType { switch (@as(@TagType(@This()), self)) { - .Proto => return ZigClangFunctionProtoType_getReturnType(self.Proto), - .NoProto => return ZigClangFunctionType_getReturnType(self.NoProto), + .Proto => return self.Proto.getReturnType(), + .NoProto => return self.NoProto.getReturnType(), } } }; -fn qualTypeGetFnProto(qt: ZigClangQualType, is_ptr: *bool) ?ClangFunctionType { - const canon = ZigClangQualType_getCanonicalType(qt); - var ty = ZigClangQualType_getTypePtr(canon); +fn qualTypeGetFnProto(qt: clang.QualType, is_ptr: *bool) ?ClangFunctionType { + const canon = qt.getCanonicalType(); + var ty = canon.getTypePtr(); is_ptr.* = false; - if (ZigClangType_getTypeClass(ty) == .Pointer) { + if (ty.getTypeClass() == .Pointer) { is_ptr.* = true; - const child_qt = ZigClangType_getPointeeType(ty); - ty = ZigClangQualType_getTypePtr(child_qt); + const child_qt = ty.getPointeeType(); + ty = child_qt.getTypePtr(); } - if (ZigClangType_getTypeClass(ty) == .FunctionProto) { - return ClangFunctionType{ .Proto = @ptrCast(*const ZigClangFunctionProtoType, ty) }; + if (ty.getTypeClass() == .FunctionProto) { + return ClangFunctionType{ .Proto = @ptrCast(*const clang.FunctionProtoType, ty) }; } - if (ZigClangType_getTypeClass(ty) == .FunctionNoProto) { - return ClangFunctionType{ .NoProto = @ptrCast(*const ZigClangFunctionType, ty) }; + if (ty.getTypeClass() == .FunctionNoProto) { + return ClangFunctionType{ .NoProto = @ptrCast(*const clang.FunctionType, ty) }; } return null; } @@ -3148,17 +3140,17 @@ fn qualTypeGetFnProto(qt: ZigClangQualType, is_ptr: *bool) ?ClangFunctionType { fn transUnaryExprOrTypeTraitExpr( rp: RestorePoint, scope: *Scope, - stmt: *const ZigClangUnaryExprOrTypeTraitExpr, + stmt: *const clang.UnaryExprOrTypeTraitExpr, result_used: ResultUsed, ) TransError!*ast.Node { - const loc = ZigClangUnaryExprOrTypeTraitExpr_getBeginLoc(stmt); + const loc = stmt.getBeginLoc(); const type_node = try transQualType( rp, - ZigClangUnaryExprOrTypeTraitExpr_getTypeOfArgument(stmt), + stmt.getTypeOfArgument(), loc, ); - const kind = ZigClangUnaryExprOrTypeTraitExpr_getKind(stmt); + const kind = stmt.getKind(); const kind_str = switch (kind) { .SizeOf => "@sizeOf", .AlignOf => "@alignOf", @@ -3180,7 +3172,7 @@ fn transUnaryExprOrTypeTraitExpr( return maybeSuppressResult(rp, scope, result_used, &builtin_node.base); } -fn qualTypeHasWrappingOverflow(qt: ZigClangQualType) bool { +fn qualTypeHasWrappingOverflow(qt: clang.QualType) bool { if (cIsUnsignedInteger(qt)) { // unsigned integer overflow wraps around. return true; @@ -3190,22 +3182,22 @@ fn qualTypeHasWrappingOverflow(qt: ZigClangQualType) bool { } } -fn transUnaryOperator(rp: RestorePoint, scope: *Scope, stmt: *const ZigClangUnaryOperator, used: ResultUsed) TransError!*ast.Node { - const op_expr = ZigClangUnaryOperator_getSubExpr(stmt); - switch (ZigClangUnaryOperator_getOpcode(stmt)) { - .PostInc => if (qualTypeHasWrappingOverflow(ZigClangUnaryOperator_getType(stmt))) +fn transUnaryOperator(rp: RestorePoint, scope: *Scope, stmt: *const clang.UnaryOperator, used: ResultUsed) TransError!*ast.Node { + const op_expr = stmt.getSubExpr(); + switch (stmt.getOpcode()) { + .PostInc => if (qualTypeHasWrappingOverflow(stmt.getType())) return transCreatePostCrement(rp, scope, stmt, .AssignAddWrap, .PlusPercentEqual, "+%=", used) else return transCreatePostCrement(rp, scope, stmt, .AssignAdd, .PlusEqual, "+=", used), - .PostDec => if (qualTypeHasWrappingOverflow(ZigClangUnaryOperator_getType(stmt))) + .PostDec => if (qualTypeHasWrappingOverflow(stmt.getType())) return transCreatePostCrement(rp, scope, stmt, .AssignSubWrap, .MinusPercentEqual, "-%=", used) else return transCreatePostCrement(rp, scope, stmt, .AssignSub, .MinusEqual, "-=", used), - .PreInc => if (qualTypeHasWrappingOverflow(ZigClangUnaryOperator_getType(stmt))) + .PreInc => if (qualTypeHasWrappingOverflow(stmt.getType())) return transCreatePreCrement(rp, scope, stmt, .AssignAddWrap, .PlusPercentEqual, "+%=", used) else return transCreatePreCrement(rp, scope, stmt, .AssignAdd, .PlusEqual, "+=", used), - .PreDec => if (qualTypeHasWrappingOverflow(ZigClangUnaryOperator_getType(stmt))) + .PreDec => if (qualTypeHasWrappingOverflow(stmt.getType())) return transCreatePreCrement(rp, scope, stmt, .AssignSubWrap, .MinusPercentEqual, "-%=", used) else return transCreatePreCrement(rp, scope, stmt, .AssignSub, .MinusEqual, "-=", used), @@ -3217,7 +3209,7 @@ fn transUnaryOperator(rp: RestorePoint, scope: *Scope, stmt: *const ZigClangUnar .Deref => { const value_node = try transExpr(rp, scope, op_expr, used, .r_value); var is_ptr = false; - const fn_ty = qualTypeGetFnProto(ZigClangExpr_getType(op_expr), &is_ptr); + const fn_ty = qualTypeGetFnProto(op_expr.getType(), &is_ptr); if (fn_ty != null and is_ptr) return value_node; const unwrapped = try transCreateNodeUnwrapNull(rp.c, value_node); @@ -3225,18 +3217,18 @@ fn transUnaryOperator(rp: RestorePoint, scope: *Scope, stmt: *const ZigClangUnar }, .Plus => return transExpr(rp, scope, op_expr, used, .r_value), .Minus => { - if (!qualTypeHasWrappingOverflow(ZigClangExpr_getType(op_expr))) { + if (!qualTypeHasWrappingOverflow(op_expr.getType())) { const op_node = try transCreateNodeSimplePrefixOp(rp.c, .Negation, .Minus, "-"); op_node.rhs = try transExpr(rp, scope, op_expr, .used, .r_value); return &op_node.base; - } else if (cIsUnsignedInteger(ZigClangExpr_getType(op_expr))) { + } else if (cIsUnsignedInteger(op_expr.getType())) { // we gotta emit 0 -% x const zero = try transCreateNodeInt(rp.c, 0); const token = try appendToken(rp.c, .MinusPercent, "-%"); const expr = try transExpr(rp, scope, op_expr, .used, .r_value); return transCreateNodeInfixOp(rp, scope, zero, .SubWrap, token, expr, used, true); } else - return revertAndWarn(rp, error.UnsupportedTranslation, ZigClangUnaryOperator_getBeginLoc(stmt), "C negation with non float non integer", .{}); + return revertAndWarn(rp, error.UnsupportedTranslation, stmt.getBeginLoc(), "C negation with non float non integer", .{}); }, .Not => { const op_node = try transCreateNodeSimplePrefixOp(rp.c, .BitNot, .Tilde, "~"); @@ -3249,22 +3241,22 @@ fn transUnaryOperator(rp: RestorePoint, scope: *Scope, stmt: *const ZigClangUnar return &op_node.base; }, .Extension => { - return transExpr(rp, scope, ZigClangUnaryOperator_getSubExpr(stmt), used, .l_value); + return transExpr(rp, scope, stmt.getSubExpr(), used, .l_value); }, - else => return revertAndWarn(rp, error.UnsupportedTranslation, ZigClangUnaryOperator_getBeginLoc(stmt), "unsupported C translation {}", .{ZigClangUnaryOperator_getOpcode(stmt)}), + else => return revertAndWarn(rp, error.UnsupportedTranslation, stmt.getBeginLoc(), "unsupported C translation {}", .{stmt.getOpcode()}), } } fn transCreatePreCrement( rp: RestorePoint, scope: *Scope, - stmt: *const ZigClangUnaryOperator, + stmt: *const clang.UnaryOperator, op: ast.Node.Tag, op_tok_id: std.zig.Token.Id, bytes: []const u8, used: ResultUsed, ) TransError!*ast.Node { - const op_expr = ZigClangUnaryOperator_getSubExpr(stmt); + const op_expr = stmt.getSubExpr(); if (used == .unused) { // common case @@ -3331,13 +3323,13 @@ fn transCreatePreCrement( fn transCreatePostCrement( rp: RestorePoint, scope: *Scope, - stmt: *const ZigClangUnaryOperator, + stmt: *const clang.UnaryOperator, op: ast.Node.Tag, op_tok_id: std.zig.Token.Id, bytes: []const u8, used: ResultUsed, ) TransError!*ast.Node { - const op_expr = ZigClangUnaryOperator_getSubExpr(stmt); + const op_expr = stmt.getSubExpr(); if (used == .unused) { // common case @@ -3422,17 +3414,17 @@ fn transCreatePostCrement( return &grouped_expr.base; } -fn transCompoundAssignOperator(rp: RestorePoint, scope: *Scope, stmt: *const ZigClangCompoundAssignOperator, used: ResultUsed) TransError!*ast.Node { - switch (ZigClangCompoundAssignOperator_getOpcode(stmt)) { - .MulAssign => if (qualTypeHasWrappingOverflow(ZigClangCompoundAssignOperator_getType(stmt))) +fn transCompoundAssignOperator(rp: RestorePoint, scope: *Scope, stmt: *const clang.CompoundAssignOperator, used: ResultUsed) TransError!*ast.Node { + switch (stmt.getOpcode()) { + .MulAssign => if (qualTypeHasWrappingOverflow(stmt.getType())) return transCreateCompoundAssign(rp, scope, stmt, .AssignMulWrap, .AsteriskPercentEqual, "*%=", .MulWrap, .AsteriskPercent, "*%", used) else return transCreateCompoundAssign(rp, scope, stmt, .AssignMul, .AsteriskEqual, "*=", .Mul, .Asterisk, "*", used), - .AddAssign => if (qualTypeHasWrappingOverflow(ZigClangCompoundAssignOperator_getType(stmt))) + .AddAssign => if (qualTypeHasWrappingOverflow(stmt.getType())) return transCreateCompoundAssign(rp, scope, stmt, .AssignAddWrap, .PlusPercentEqual, "+%=", .AddWrap, .PlusPercent, "+%", used) else return transCreateCompoundAssign(rp, scope, stmt, .AssignAdd, .PlusEqual, "+=", .Add, .Plus, "+", used), - .SubAssign => if (qualTypeHasWrappingOverflow(ZigClangCompoundAssignOperator_getType(stmt))) + .SubAssign => if (qualTypeHasWrappingOverflow(stmt.getType())) return transCreateCompoundAssign(rp, scope, stmt, .AssignSubWrap, .MinusPercentEqual, "-%=", .SubWrap, .MinusPercent, "-%", used) else return transCreateCompoundAssign(rp, scope, stmt, .AssignSub, .MinusPercentEqual, "-=", .Sub, .Minus, "-", used), @@ -3446,9 +3438,9 @@ fn transCompoundAssignOperator(rp: RestorePoint, scope: *Scope, stmt: *const Zig else => return revertAndWarn( rp, error.UnsupportedTranslation, - ZigClangCompoundAssignOperator_getBeginLoc(stmt), + stmt.getBeginLoc(), "unsupported C translation {}", - .{ZigClangCompoundAssignOperator_getOpcode(stmt)}, + .{stmt.getOpcode()}, ), } } @@ -3456,7 +3448,7 @@ fn transCompoundAssignOperator(rp: RestorePoint, scope: *Scope, stmt: *const Zig fn transCreateCompoundAssign( rp: RestorePoint, scope: *Scope, - stmt: *const ZigClangCompoundAssignOperator, + stmt: *const clang.CompoundAssignOperator, assign_op: ast.Node.Tag, assign_tok_id: std.zig.Token.Id, assign_bytes: []const u8, @@ -3468,9 +3460,9 @@ fn transCreateCompoundAssign( const is_shift = bin_op == .BitShiftLeft or bin_op == .BitShiftRight; const is_div = bin_op == .Div; const is_mod = bin_op == .Mod; - const lhs = ZigClangCompoundAssignOperator_getLHS(stmt); - const rhs = ZigClangCompoundAssignOperator_getRHS(stmt); - const loc = ZigClangCompoundAssignOperator_getBeginLoc(stmt); + const lhs = stmt.getLHS(); + const rhs = stmt.getRHS(); + const loc = stmt.getBeginLoc(); const lhs_qt = getExprQualType(rp.c, lhs); const rhs_qt = getExprQualType(rp.c, rhs); const is_signed = cIsSignedInteger(lhs_qt); @@ -3615,20 +3607,20 @@ fn transCreateCompoundAssign( fn transCPtrCast( rp: RestorePoint, - loc: ZigClangSourceLocation, - dst_type: ZigClangQualType, - src_type: ZigClangQualType, + loc: clang.SourceLocation, + dst_type: clang.QualType, + src_type: clang.QualType, expr: *ast.Node, ) !*ast.Node { - const ty = ZigClangQualType_getTypePtr(dst_type); - const child_type = ZigClangType_getPointeeType(ty); - const src_ty = ZigClangQualType_getTypePtr(src_type); - const src_child_type = ZigClangType_getPointeeType(src_ty); + const ty = dst_type.getTypePtr(); + const child_type = ty.getPointeeType(); + const src_ty = src_type.getTypePtr(); + const src_child_type = src_ty.getPointeeType(); - if ((ZigClangQualType_isConstQualified(src_child_type) and - !ZigClangQualType_isConstQualified(child_type)) or - (ZigClangQualType_isVolatileQualified(src_child_type) and - !ZigClangQualType_isVolatileQualified(child_type))) + if ((src_child_type.isConstQualified() and + !child_type.isConstQualified()) or + (src_child_type.isVolatileQualified() and + !child_type.isVolatileQualified())) { // Casting away const or volatile requires us to use @intToPtr const inttoptr_node = try rp.c.createBuiltinCall("@intToPtr", 2); @@ -3651,7 +3643,7 @@ fn transCPtrCast( ptrcast_node.params()[0] = dst_type_node; _ = try appendToken(rp.c, .Comma, ","); - if (ZigClangType_isVoidType(qualTypeCanon(child_type))) { + if (qualTypeCanon(child_type).isVoidType()) { // void has 1-byte alignment, so @alignCast is not needed ptrcast_node.params()[1] = expr; } else if (typeIsOpaque(rp.c, qualTypeCanon(child_type), loc)) { @@ -3691,9 +3683,9 @@ fn transBreak(rp: RestorePoint, scope: *Scope) TransError!*ast.Node { return &br.base; } -fn transFloatingLiteral(rp: RestorePoint, scope: *Scope, stmt: *const ZigClangFloatingLiteral, used: ResultUsed) TransError!*ast.Node { +fn transFloatingLiteral(rp: RestorePoint, scope: *Scope, stmt: *const clang.FloatingLiteral, used: ResultUsed) TransError!*ast.Node { // TODO use something more accurate - const dbl = ZigClangAPFloat_getValueAsApproximateDouble(stmt); + const dbl = stmt.getValueAsApproximateDouble(); const node = try rp.c.arena.create(ast.Node.OneToken); node.* = .{ .base = .{ .tag = .FloatLiteral }, @@ -3702,13 +3694,13 @@ fn transFloatingLiteral(rp: RestorePoint, scope: *Scope, stmt: *const ZigClangFl return maybeSuppressResult(rp, scope, used, &node.base); } -fn transBinaryConditionalOperator(rp: RestorePoint, scope: *Scope, stmt: *const ZigClangBinaryConditionalOperator, used: ResultUsed) TransError!*ast.Node { +fn transBinaryConditionalOperator(rp: RestorePoint, scope: *Scope, stmt: *const clang.BinaryConditionalOperator, used: ResultUsed) TransError!*ast.Node { // GNU extension of the ternary operator where the middle expression is // omitted, the conditition itself is returned if it evaluates to true - const casted_stmt = @ptrCast(*const ZigClangAbstractConditionalOperator, stmt); - const cond_expr = ZigClangAbstractConditionalOperator_getCond(casted_stmt); - const true_expr = ZigClangAbstractConditionalOperator_getTrueExpr(casted_stmt); - const false_expr = ZigClangAbstractConditionalOperator_getFalseExpr(casted_stmt); + const casted_stmt = @ptrCast(*const clang.AbstractConditionalOperator, stmt); + const cond_expr = casted_stmt.getCond(); + const true_expr = casted_stmt.getTrueExpr(); + const false_expr = casted_stmt.getFalseExpr(); // c: (cond_expr)?:(false_expr) // zig: (blk: { @@ -3748,8 +3740,8 @@ fn transBinaryConditionalOperator(rp: RestorePoint, scope: *Scope, stmt: *const defer cond_scope.deinit(); const tmp_var_node = try transCreateNodeIdentifier(rp.c, mangled_name); - const ty = ZigClangQualType_getTypePtr(getExprQualType(rp.c, cond_expr)); - const cond_node = try finishBoolExpr(rp, &cond_scope.base, ZigClangExpr_getBeginLoc(cond_expr), ty, tmp_var_node, used); + const ty = getExprQualType(rp.c, cond_expr).getTypePtr(); + const cond_node = try finishBoolExpr(rp, &cond_scope.base, cond_expr.getBeginLoc(), ty, tmp_var_node, used); if_node.condition = cond_node; _ = try appendToken(rp.c, .RParen, ")"); @@ -3772,7 +3764,7 @@ fn transBinaryConditionalOperator(rp: RestorePoint, scope: *Scope, stmt: *const return maybeSuppressResult(rp, scope, used, &grouped_expr.base); } -fn transConditionalOperator(rp: RestorePoint, scope: *Scope, stmt: *const ZigClangConditionalOperator, used: ResultUsed) TransError!*ast.Node { +fn transConditionalOperator(rp: RestorePoint, scope: *Scope, stmt: *const clang.ConditionalOperator, used: ResultUsed) TransError!*ast.Node { const grouped = scope.id == .Condition; const lparen = if (grouped) try appendToken(rp.c, .LParen, "(") else undefined; const if_node = try transCreateNodeIf(rp.c); @@ -3784,10 +3776,10 @@ fn transConditionalOperator(rp: RestorePoint, scope: *Scope, stmt: *const ZigCla }; defer cond_scope.deinit(); - const casted_stmt = @ptrCast(*const ZigClangAbstractConditionalOperator, stmt); - const cond_expr = ZigClangAbstractConditionalOperator_getCond(casted_stmt); - const true_expr = ZigClangAbstractConditionalOperator_getTrueExpr(casted_stmt); - const false_expr = ZigClangAbstractConditionalOperator_getFalseExpr(casted_stmt); + const casted_stmt = @ptrCast(*const clang.AbstractConditionalOperator, stmt); + const cond_expr = casted_stmt.getCond(); + const true_expr = casted_stmt.getTrueExpr(); + const false_expr = casted_stmt.getFalseExpr(); if_node.condition = try transBoolExpr(rp, &cond_scope.base, cond_expr, .used, .r_value, false); _ = try appendToken(rp.c, .RParen, ")"); @@ -3845,22 +3837,22 @@ fn addTopLevelDecl(c: *Context, name: []const u8, decl_node: *ast.Node) !void { _ = try c.global_scope.sym_table.put(name, decl_node); } -fn transQualType(rp: RestorePoint, qt: ZigClangQualType, source_loc: ZigClangSourceLocation) TypeError!*ast.Node { - return transType(rp, ZigClangQualType_getTypePtr(qt), source_loc); +fn transQualType(rp: RestorePoint, qt: clang.QualType, source_loc: clang.SourceLocation) TypeError!*ast.Node { + return transType(rp, qt.getTypePtr(), source_loc); } /// Produces a Zig AST node by translating a Clang QualType, respecting the width, but modifying the signed-ness. /// Asserts the type is an integer. -fn transQualTypeIntWidthOf(c: *Context, ty: ZigClangQualType, is_signed: bool) TypeError!*ast.Node { +fn transQualTypeIntWidthOf(c: *Context, ty: clang.QualType, is_signed: bool) TypeError!*ast.Node { return transTypeIntWidthOf(c, qualTypeCanon(ty), is_signed); } /// Produces a Zig AST node by translating a Clang Type, respecting the width, but modifying the signed-ness. /// Asserts the type is an integer. -fn transTypeIntWidthOf(c: *Context, ty: *const ZigClangType, is_signed: bool) TypeError!*ast.Node { - assert(ZigClangType_getTypeClass(ty) == .Builtin); - const builtin_ty = @ptrCast(*const ZigClangBuiltinType, ty); - return transCreateNodeIdentifier(c, switch (ZigClangBuiltinType_getKind(builtin_ty)) { +fn transTypeIntWidthOf(c: *Context, ty: *const clang.Type, is_signed: bool) TypeError!*ast.Node { + assert(ty.getTypeClass() == .Builtin); + const builtin_ty = @ptrCast(*const clang.BuiltinType, ty); + return transCreateNodeIdentifier(c, switch (builtin_ty.getKind()) { .Char_U, .Char_S, .UChar, .SChar, .Char8 => if (is_signed) "i8" else "u8", .UShort, .Short => if (is_signed) "c_short" else "c_ushort", .UInt, .Int => if (is_signed) "c_int" else "c_uint", @@ -3873,30 +3865,30 @@ fn transTypeIntWidthOf(c: *Context, ty: *const ZigClangType, is_signed: bool) Ty }); } -fn isCBuiltinType(qt: ZigClangQualType, kind: ZigClangBuiltinTypeKind) bool { +fn isCBuiltinType(qt: clang.QualType, kind: clang.BuiltinTypeKind) bool { const c_type = qualTypeCanon(qt); - if (ZigClangType_getTypeClass(c_type) != .Builtin) + if (c_type.getTypeClass() != .Builtin) return false; - const builtin_ty = @ptrCast(*const ZigClangBuiltinType, c_type); - return ZigClangBuiltinType_getKind(builtin_ty) == kind; + const builtin_ty = @ptrCast(*const clang.BuiltinType, c_type); + return builtin_ty.getKind() == kind; } -fn qualTypeIsPtr(qt: ZigClangQualType) bool { - return ZigClangType_getTypeClass(qualTypeCanon(qt)) == .Pointer; +fn qualTypeIsPtr(qt: clang.QualType) bool { + return qualTypeCanon(qt).getTypeClass() == .Pointer; } -fn qualTypeIsBoolean(qt: ZigClangQualType) bool { - return ZigClangType_isBooleanType(qualTypeCanon(qt)); +fn qualTypeIsBoolean(qt: clang.QualType) bool { + return qualTypeCanon(qt).isBooleanType(); } -fn qualTypeIntBitWidth(rp: RestorePoint, qt: ZigClangQualType, source_loc: ZigClangSourceLocation) !u32 { - const ty = ZigClangQualType_getTypePtr(qt); +fn qualTypeIntBitWidth(rp: RestorePoint, qt: clang.QualType, source_loc: clang.SourceLocation) !u32 { + const ty = qt.getTypePtr(); - switch (ZigClangType_getTypeClass(ty)) { + switch (ty.getTypeClass()) { .Builtin => { - const builtin_ty = @ptrCast(*const ZigClangBuiltinType, ty); + const builtin_ty = @ptrCast(*const clang.BuiltinType, ty); - switch (ZigClangBuiltinType_getKind(builtin_ty)) { + switch (builtin_ty.getKind()) { .Char_U, .UChar, .Char_S, @@ -3911,9 +3903,9 @@ fn qualTypeIntBitWidth(rp: RestorePoint, qt: ZigClangQualType, source_loc: ZigCl unreachable; }, .Typedef => { - const typedef_ty = @ptrCast(*const ZigClangTypedefType, ty); - const typedef_decl = ZigClangTypedefType_getDecl(typedef_ty); - const type_name = try rp.c.str(ZigClangNamedDecl_getName_bytes_begin(@ptrCast(*const ZigClangNamedDecl, typedef_decl))); + const typedef_ty = @ptrCast(*const clang.TypedefType, ty); + const typedef_decl = typedef_ty.getDecl(); + const type_name = try rp.c.str(@ptrCast(*const clang.NamedDecl, typedef_decl).getName_bytes_begin()); if (mem.eql(u8, type_name, "uint8_t") or mem.eql(u8, type_name, "int8_t")) { return 8; @@ -3933,7 +3925,7 @@ fn qualTypeIntBitWidth(rp: RestorePoint, qt: ZigClangQualType, source_loc: ZigCl unreachable; } -fn qualTypeToLog2IntRef(rp: RestorePoint, qt: ZigClangQualType, source_loc: ZigClangSourceLocation) !*ast.Node { +fn qualTypeToLog2IntRef(rp: RestorePoint, qt: clang.QualType, source_loc: clang.SourceLocation) !*ast.Node { const int_bit_width = try qualTypeIntBitWidth(rp, qt, source_loc); if (int_bit_width != 0) { @@ -3980,83 +3972,83 @@ fn qualTypeToLog2IntRef(rp: RestorePoint, qt: ZigClangQualType, source_loc: ZigC return &log2int_fn_call.base; } -fn qualTypeChildIsFnProto(qt: ZigClangQualType) bool { +fn qualTypeChildIsFnProto(qt: clang.QualType) bool { const ty = qualTypeCanon(qt); - switch (ZigClangType_getTypeClass(ty)) { + switch (ty.getTypeClass()) { .FunctionProto, .FunctionNoProto => return true, else => return false, } } -fn qualTypeCanon(qt: ZigClangQualType) *const ZigClangType { - const canon = ZigClangQualType_getCanonicalType(qt); - return ZigClangQualType_getTypePtr(canon); +fn qualTypeCanon(qt: clang.QualType) *const clang.Type { + const canon = qt.getCanonicalType(); + return canon.getTypePtr(); } -fn getExprQualType(c: *Context, expr: *const ZigClangExpr) ZigClangQualType { +fn getExprQualType(c: *Context, expr: *const clang.Expr) clang.QualType { blk: { // If this is a C `char *`, turn it into a `const char *` - if (ZigClangExpr_getStmtClass(expr) != .ImplicitCastExprClass) break :blk; - const cast_expr = @ptrCast(*const ZigClangImplicitCastExpr, expr); - if (ZigClangImplicitCastExpr_getCastKind(cast_expr) != .ArrayToPointerDecay) break :blk; - const sub_expr = ZigClangImplicitCastExpr_getSubExpr(cast_expr); - if (ZigClangExpr_getStmtClass(sub_expr) != .StringLiteralClass) break :blk; - const array_qt = ZigClangExpr_getType(sub_expr); - const array_type = @ptrCast(*const ZigClangArrayType, ZigClangQualType_getTypePtr(array_qt)); - var pointee_qt = ZigClangArrayType_getElementType(array_type); - ZigClangQualType_addConst(&pointee_qt); - return ZigClangASTContext_getPointerType(c.clang_context, pointee_qt); + if (expr.getStmtClass() != .ImplicitCastExprClass) break :blk; + const cast_expr = @ptrCast(*const clang.ImplicitCastExpr, expr); + if (cast_expr.getCastKind() != .ArrayToPointerDecay) break :blk; + const sub_expr = cast_expr.getSubExpr(); + if (sub_expr.getStmtClass() != .StringLiteralClass) break :blk; + const array_qt = sub_expr.getType(); + const array_type = @ptrCast(*const clang.ArrayType, array_qt.getTypePtr()); + var pointee_qt = array_type.getElementType(); + pointee_qt.addConst(); + return c.clang_context.getPointerType(pointee_qt); } - return ZigClangExpr_getType(expr); + return expr.getType(); } -fn typeIsOpaque(c: *Context, ty: *const ZigClangType, loc: ZigClangSourceLocation) bool { - switch (ZigClangType_getTypeClass(ty)) { +fn typeIsOpaque(c: *Context, ty: *const clang.Type, loc: clang.SourceLocation) bool { + switch (ty.getTypeClass()) { .Builtin => { - const builtin_ty = @ptrCast(*const ZigClangBuiltinType, ty); - return ZigClangBuiltinType_getKind(builtin_ty) == .Void; + const builtin_ty = @ptrCast(*const clang.BuiltinType, ty); + return builtin_ty.getKind() == .Void; }, .Record => { - const record_ty = @ptrCast(*const ZigClangRecordType, ty); - const record_decl = ZigClangRecordType_getDecl(record_ty); - const record_def = ZigClangRecordDecl_getDefinition(record_decl) orelse + const record_ty = @ptrCast(*const clang.RecordType, ty); + const record_decl = record_ty.getDecl(); + const record_def = record_decl.getDefinition() orelse return true; - var it = ZigClangRecordDecl_field_begin(record_def); - const end_it = ZigClangRecordDecl_field_end(record_def); - while (ZigClangRecordDecl_field_iterator_neq(it, end_it)) : (it = ZigClangRecordDecl_field_iterator_next(it)) { - const field_decl = ZigClangRecordDecl_field_iterator_deref(it); + var it = record_def.field_begin(); + const end_it = record_def.field_end(); + while (it.neq(end_it)) : (it = it.next()) { + const field_decl = it.deref(); - if (ZigClangFieldDecl_isBitField(field_decl)) { + if (field_decl.isBitField()) { return true; } } return false; }, .Elaborated => { - const elaborated_ty = @ptrCast(*const ZigClangElaboratedType, ty); - const qt = ZigClangElaboratedType_getNamedType(elaborated_ty); - return typeIsOpaque(c, ZigClangQualType_getTypePtr(qt), loc); + const elaborated_ty = @ptrCast(*const clang.ElaboratedType, ty); + const qt = elaborated_ty.getNamedType(); + return typeIsOpaque(c, qt.getTypePtr(), loc); }, .Typedef => { - const typedef_ty = @ptrCast(*const ZigClangTypedefType, ty); - const typedef_decl = ZigClangTypedefType_getDecl(typedef_ty); - const underlying_type = ZigClangTypedefNameDecl_getUnderlyingType(typedef_decl); - return typeIsOpaque(c, ZigClangQualType_getTypePtr(underlying_type), loc); + const typedef_ty = @ptrCast(*const clang.TypedefType, ty); + const typedef_decl = typedef_ty.getDecl(); + const underlying_type = typedef_decl.getUnderlyingType(); + return typeIsOpaque(c, underlying_type.getTypePtr(), loc); }, else => return false, } } -fn cIsInteger(qt: ZigClangQualType) bool { +fn cIsInteger(qt: clang.QualType) bool { return cIsSignedInteger(qt) or cIsUnsignedInteger(qt); } -fn cIsUnsignedInteger(qt: ZigClangQualType) bool { +fn cIsUnsignedInteger(qt: clang.QualType) bool { const c_type = qualTypeCanon(qt); - if (ZigClangType_getTypeClass(c_type) != .Builtin) return false; - const builtin_ty = @ptrCast(*const ZigClangBuiltinType, c_type); - return switch (ZigClangBuiltinType_getKind(builtin_ty)) { + if (c_type.getTypeClass() != .Builtin) return false; + const builtin_ty = @ptrCast(*const clang.BuiltinType, c_type); + return switch (builtin_ty.getKind()) { .Char_U, .UChar, .Char_S, @@ -4071,11 +4063,11 @@ fn cIsUnsignedInteger(qt: ZigClangQualType) bool { }; } -fn cIntTypeToIndex(qt: ZigClangQualType) u8 { +fn cIntTypeToIndex(qt: clang.QualType) u8 { const c_type = qualTypeCanon(qt); - assert(ZigClangType_getTypeClass(c_type) == .Builtin); - const builtin_ty = @ptrCast(*const ZigClangBuiltinType, c_type); - return switch (ZigClangBuiltinType_getKind(builtin_ty)) { + assert(c_type.getTypeClass() == .Builtin); + const builtin_ty = @ptrCast(*const clang.BuiltinType, c_type); + return switch (builtin_ty.getKind()) { .Bool, .Char_U, .Char_S, .UChar, .SChar, .Char8 => 1, .WChar_U, .WChar_S => 2, .UShort, .Short, .Char16 => 3, @@ -4087,17 +4079,17 @@ fn cIntTypeToIndex(qt: ZigClangQualType) u8 { }; } -fn cIntTypeCmp(a: ZigClangQualType, b: ZigClangQualType) math.Order { +fn cIntTypeCmp(a: clang.QualType, b: clang.QualType) math.Order { const a_index = cIntTypeToIndex(a); const b_index = cIntTypeToIndex(b); return math.order(a_index, b_index); } -fn cIsSignedInteger(qt: ZigClangQualType) bool { +fn cIsSignedInteger(qt: clang.QualType) bool { const c_type = qualTypeCanon(qt); - if (ZigClangType_getTypeClass(c_type) != .Builtin) return false; - const builtin_ty = @ptrCast(*const ZigClangBuiltinType, c_type); - return switch (ZigClangBuiltinType_getKind(builtin_ty)) { + if (c_type.getTypeClass() != .Builtin) return false; + const builtin_ty = @ptrCast(*const clang.BuiltinType, c_type); + return switch (builtin_ty.getKind()) { .SChar, .Short, .Int, @@ -4110,11 +4102,11 @@ fn cIsSignedInteger(qt: ZigClangQualType) bool { }; } -fn cIsFloating(qt: ZigClangQualType) bool { +fn cIsFloating(qt: clang.QualType) bool { const c_type = qualTypeCanon(qt); - if (ZigClangType_getTypeClass(c_type) != .Builtin) return false; - const builtin_ty = @ptrCast(*const ZigClangBuiltinType, c_type); - return switch (ZigClangBuiltinType_getKind(builtin_ty)) { + if (c_type.getTypeClass() != .Builtin) return false; + const builtin_ty = @ptrCast(*const clang.BuiltinType, c_type); + return switch (builtin_ty.getKind()) { .Float, .Double, .Float128, @@ -4124,11 +4116,11 @@ fn cIsFloating(qt: ZigClangQualType) bool { }; } -fn cIsLongLongInteger(qt: ZigClangQualType) bool { +fn cIsLongLongInteger(qt: clang.QualType) bool { const c_type = qualTypeCanon(qt); - if (ZigClangType_getTypeClass(c_type) != .Builtin) return false; - const builtin_ty = @ptrCast(*const ZigClangBuiltinType, c_type); - return switch (ZigClangBuiltinType_getKind(builtin_ty)) { + if (c_type.getTypeClass() != .Builtin) return false; + const builtin_ty = @ptrCast(*const clang.BuiltinType, c_type); + return switch (builtin_ty.getKind()) { .LongLong, .ULongLong, .Int128, .UInt128 => true, else => false, }; @@ -4137,8 +4129,8 @@ fn transCreateNodeAssign( rp: RestorePoint, scope: *Scope, result_used: ResultUsed, - lhs: *const ZigClangExpr, - rhs: *const ZigClangExpr, + lhs: *const clang.Expr, + rhs: *const clang.Expr, ) !*ast.Node { // common case // c: lhs = rhs @@ -4273,19 +4265,19 @@ fn transCreateNodeInfixOp( fn transCreateNodeBoolInfixOp( rp: RestorePoint, scope: *Scope, - stmt: *const ZigClangBinaryOperator, + stmt: *const clang.BinaryOperator, op: ast.Node.Tag, used: ResultUsed, grouped: bool, ) !*ast.Node { std.debug.assert(op == .BoolAnd or op == .BoolOr); - const lhs_hode = try transBoolExpr(rp, scope, ZigClangBinaryOperator_getLHS(stmt), .used, .l_value, true); + const lhs_hode = try transBoolExpr(rp, scope, stmt.getLHS(), .used, .l_value, true); const op_token = if (op == .BoolAnd) try appendToken(rp.c, .Keyword_and, "and") else try appendToken(rp.c, .Keyword_or, "or"); - const rhs = try transBoolExpr(rp, scope, ZigClangBinaryOperator_getRHS(stmt), .used, .r_value, true); + const rhs = try transBoolExpr(rp, scope, stmt.getRHS(), .used, .r_value, true); return transCreateNodeInfixOp( rp, @@ -4334,21 +4326,21 @@ fn transCreateNodePtrType( return node; } -fn transCreateNodeAPInt(c: *Context, int: *const ZigClangAPSInt) !*ast.Node { - const num_limbs = math.cast(usize, ZigClangAPSInt_getNumWords(int)) catch |err| switch (err) { +fn transCreateNodeAPInt(c: *Context, int: *const clang.APSInt) !*ast.Node { + const num_limbs = math.cast(usize, int.getNumWords()) catch |err| switch (err) { error.Overflow => return error.OutOfMemory, }; var aps_int = int; - const is_negative = ZigClangAPSInt_isSigned(int) and ZigClangAPSInt_isNegative(int); - if (is_negative) aps_int = ZigClangAPSInt_negate(aps_int); + const is_negative = int.isSigned() and int.isNegative(); + if (is_negative) aps_int = aps_int.negate(); defer if (is_negative) { - ZigClangAPSInt_free(aps_int); + aps_int.free(); }; const limbs = try c.arena.alloc(math.big.Limb, num_limbs); defer c.arena.free(limbs); - const data = ZigClangAPSInt_getRawData(aps_int); + const data = aps_int.getRawData(); switch (@sizeOf(math.big.Limb)) { 8 => { var i: usize = 0; @@ -4438,10 +4430,18 @@ fn transCreateNodeFloat(c: *Context, int: anytype) !*ast.Node { } fn transCreateNodeOpaqueType(c: *Context) !*ast.Node { - const call_node = try c.createBuiltinCall("@Type", 1); - call_node.params()[0] = try transCreateNodeEnumLiteral(c, "Opaque"); - call_node.rparen_token = try appendToken(c, .RParen, ")"); - return &call_node.base; + const container_tok = try appendToken(c, .Keyword_opaque, "opaque"); + const lbrace_token = try appendToken(c, .LBrace, "{"); + const container_node = try ast.Node.ContainerDecl.alloc(c.arena, 0); + container_node.* = .{ + .kind_token = container_tok, + .layout_token = null, + .lbrace_token = lbrace_token, + .rbrace_token = try appendToken(c, .RBrace, "}"), + .fields_and_decls_len = 0, + .init_arg_expr = .None, + }; + return &container_node.base; } fn transCreateNodeMacroFn(c: *Context, name: []const u8, ref: *ast.Node, proto_alias: *ast.Node.FnProto) !*ast.Node { @@ -4689,23 +4689,23 @@ fn transCreateNodeSwitchElse(c: *Context) !*ast.Node { fn transCreateNodeShiftOp( rp: RestorePoint, scope: *Scope, - stmt: *const ZigClangBinaryOperator, + stmt: *const clang.BinaryOperator, op: ast.Node.Tag, op_tok_id: std.zig.Token.Id, bytes: []const u8, ) !*ast.Node { std.debug.assert(op == .BitShiftLeft or op == .BitShiftRight); - const lhs_expr = ZigClangBinaryOperator_getLHS(stmt); - const rhs_expr = ZigClangBinaryOperator_getRHS(stmt); - const rhs_location = ZigClangExpr_getBeginLoc(rhs_expr); + const lhs_expr = stmt.getLHS(); + const rhs_expr = stmt.getRHS(); + const rhs_location = rhs_expr.getBeginLoc(); // lhs >> @as(u5, rh) const lhs = try transExpr(rp, scope, lhs_expr, .used, .l_value); const op_token = try appendToken(rp.c, op_tok_id, bytes); const cast_node = try rp.c.createBuiltinCall("@intCast", 2); - const rhs_type = try qualTypeToLog2IntRef(rp, ZigClangBinaryOperator_getType(stmt), rhs_location); + const rhs_type = try qualTypeToLog2IntRef(rp, stmt.getType(), rhs_location); cast_node.params()[0] = rhs_type; _ = try appendToken(rp.c, .Comma, ","); const rhs = try transExprCoercing(rp, scope, rhs_expr, .used, .r_value); @@ -4764,11 +4764,11 @@ fn makeRestorePoint(c: *Context) RestorePoint { }; } -fn transType(rp: RestorePoint, ty: *const ZigClangType, source_loc: ZigClangSourceLocation) TypeError!*ast.Node { - switch (ZigClangType_getTypeClass(ty)) { +fn transType(rp: RestorePoint, ty: *const clang.Type, source_loc: clang.SourceLocation) TypeError!*ast.Node { + switch (ty.getTypeClass()) { .Builtin => { - const builtin_ty = @ptrCast(*const ZigClangBuiltinType, ty); - return transCreateNodeIdentifier(rp.c, switch (ZigClangBuiltinType_getKind(builtin_ty)) { + const builtin_ty = @ptrCast(*const clang.BuiltinType, ty); + return transCreateNodeIdentifier(rp.c, switch (builtin_ty.getKind()) { .Void => "c_void", .Bool => "bool", .Char_U, .UChar, .Char_S, .Char8 => "u8", @@ -4792,32 +4792,32 @@ fn transType(rp: RestorePoint, ty: *const ZigClangType, source_loc: ZigClangSour }); }, .FunctionProto => { - const fn_proto_ty = @ptrCast(*const ZigClangFunctionProtoType, ty); + const fn_proto_ty = @ptrCast(*const clang.FunctionProtoType, ty); const fn_proto = try transFnProto(rp, null, fn_proto_ty, source_loc, null, false); return &fn_proto.base; }, .FunctionNoProto => { - const fn_no_proto_ty = @ptrCast(*const ZigClangFunctionType, ty); + const fn_no_proto_ty = @ptrCast(*const clang.FunctionType, ty); const fn_proto = try transFnNoProto(rp, fn_no_proto_ty, source_loc, null, false); return &fn_proto.base; }, .Paren => { - const paren_ty = @ptrCast(*const ZigClangParenType, ty); - return transQualType(rp, ZigClangParenType_getInnerType(paren_ty), source_loc); + const paren_ty = @ptrCast(*const clang.ParenType, ty); + return transQualType(rp, paren_ty.getInnerType(), source_loc); }, .Pointer => { - const child_qt = ZigClangType_getPointeeType(ty); + const child_qt = ty.getPointeeType(); if (qualTypeChildIsFnProto(child_qt)) { const optional_node = try transCreateNodeSimplePrefixOp(rp.c, .OptionalType, .QuestionMark, "?"); optional_node.rhs = try transQualType(rp, child_qt, source_loc); return &optional_node.base; } - if (typeIsOpaque(rp.c, ZigClangQualType_getTypePtr(child_qt), source_loc)) { + if (typeIsOpaque(rp.c, child_qt.getTypePtr(), source_loc)) { const optional_node = try transCreateNodeSimplePrefixOp(rp.c, .OptionalType, .QuestionMark, "?"); const pointer_node = try transCreateNodePtrType( rp.c, - ZigClangQualType_isConstQualified(child_qt), - ZigClangQualType_isVolatileQualified(child_qt), + child_qt.isConstQualified(), + child_qt.isVolatileQualified(), .Asterisk, ); optional_node.rhs = &pointer_node.base; @@ -4826,83 +4826,83 @@ fn transType(rp: RestorePoint, ty: *const ZigClangType, source_loc: ZigClangSour } const pointer_node = try transCreateNodePtrType( rp.c, - ZigClangQualType_isConstQualified(child_qt), - ZigClangQualType_isVolatileQualified(child_qt), + child_qt.isConstQualified(), + child_qt.isVolatileQualified(), .Identifier, ); pointer_node.rhs = try transQualType(rp, child_qt, source_loc); return &pointer_node.base; }, .ConstantArray => { - const const_arr_ty = @ptrCast(*const ZigClangConstantArrayType, ty); + const const_arr_ty = @ptrCast(*const clang.ConstantArrayType, ty); - const size_ap_int = ZigClangConstantArrayType_getSize(const_arr_ty); - const size = ZigClangAPInt_getLimitedValue(size_ap_int, math.maxInt(usize)); - const elem_ty = ZigClangQualType_getTypePtr(ZigClangConstantArrayType_getElementType(const_arr_ty)); + const size_ap_int = const_arr_ty.getSize(); + const size = size_ap_int.getLimitedValue(math.maxInt(usize)); + const elem_ty = const_arr_ty.getElementType().getTypePtr(); return try transCreateNodeArrayType(rp, source_loc, elem_ty, size); }, .IncompleteArray => { - const incomplete_array_ty = @ptrCast(*const ZigClangIncompleteArrayType, ty); + const incomplete_array_ty = @ptrCast(*const clang.IncompleteArrayType, ty); - const child_qt = ZigClangIncompleteArrayType_getElementType(incomplete_array_ty); + const child_qt = incomplete_array_ty.getElementType(); var node = try transCreateNodePtrType( rp.c, - ZigClangQualType_isConstQualified(child_qt), - ZigClangQualType_isVolatileQualified(child_qt), + child_qt.isConstQualified(), + child_qt.isVolatileQualified(), .Identifier, ); node.rhs = try transQualType(rp, child_qt, source_loc); return &node.base; }, .Typedef => { - const typedef_ty = @ptrCast(*const ZigClangTypedefType, ty); + const typedef_ty = @ptrCast(*const clang.TypedefType, ty); - const typedef_decl = ZigClangTypedefType_getDecl(typedef_ty); + const typedef_decl = typedef_ty.getDecl(); return (try transTypeDef(rp.c, typedef_decl, false)) orelse revertAndWarn(rp, error.UnsupportedType, source_loc, "unable to translate typedef declaration", .{}); }, .Record => { - const record_ty = @ptrCast(*const ZigClangRecordType, ty); + const record_ty = @ptrCast(*const clang.RecordType, ty); - const record_decl = ZigClangRecordType_getDecl(record_ty); + const record_decl = record_ty.getDecl(); return (try transRecordDecl(rp.c, record_decl)) orelse revertAndWarn(rp, error.UnsupportedType, source_loc, "unable to resolve record declaration", .{}); }, .Enum => { - const enum_ty = @ptrCast(*const ZigClangEnumType, ty); + const enum_ty = @ptrCast(*const clang.EnumType, ty); - const enum_decl = ZigClangEnumType_getDecl(enum_ty); + const enum_decl = enum_ty.getDecl(); return (try transEnumDecl(rp.c, enum_decl)) orelse revertAndWarn(rp, error.UnsupportedType, source_loc, "unable to translate enum declaration", .{}); }, .Elaborated => { - const elaborated_ty = @ptrCast(*const ZigClangElaboratedType, ty); - return transQualType(rp, ZigClangElaboratedType_getNamedType(elaborated_ty), source_loc); + const elaborated_ty = @ptrCast(*const clang.ElaboratedType, ty); + return transQualType(rp, elaborated_ty.getNamedType(), source_loc); }, .Decayed => { - const decayed_ty = @ptrCast(*const ZigClangDecayedType, ty); - return transQualType(rp, ZigClangDecayedType_getDecayedType(decayed_ty), source_loc); + const decayed_ty = @ptrCast(*const clang.DecayedType, ty); + return transQualType(rp, decayed_ty.getDecayedType(), source_loc); }, .Attributed => { - const attributed_ty = @ptrCast(*const ZigClangAttributedType, ty); - return transQualType(rp, ZigClangAttributedType_getEquivalentType(attributed_ty), source_loc); + const attributed_ty = @ptrCast(*const clang.AttributedType, ty); + return transQualType(rp, attributed_ty.getEquivalentType(), source_loc); }, .MacroQualified => { - const macroqualified_ty = @ptrCast(*const ZigClangMacroQualifiedType, ty); - return transQualType(rp, ZigClangMacroQualifiedType_getModifiedType(macroqualified_ty), source_loc); + const macroqualified_ty = @ptrCast(*const clang.MacroQualifiedType, ty); + return transQualType(rp, macroqualified_ty.getModifiedType(), source_loc); }, else => { - const type_name = rp.c.str(ZigClangType_getTypeClassName(ty)); + const type_name = rp.c.str(ty.getTypeClassName()); return revertAndWarn(rp, error.UnsupportedType, source_loc, "unsupported type: '{}'", .{type_name}); }, } } -fn isCVoid(qt: ZigClangQualType) bool { - const ty = ZigClangQualType_getTypePtr(qt); - if (ZigClangType_getTypeClass(ty) == .Builtin) { - const builtin_ty = @ptrCast(*const ZigClangBuiltinType, ty); - return ZigClangBuiltinType_getKind(builtin_ty) == .Void; +fn isCVoid(qt: clang.QualType) bool { + const ty = qt.getTypePtr(); + if (ty.getTypeClass() == .Builtin) { + const builtin_ty = @ptrCast(*const clang.BuiltinType, ty); + return builtin_ty.getKind() == .Void; } return false; } @@ -4910,16 +4910,16 @@ fn isCVoid(qt: ZigClangQualType) bool { const FnDeclContext = struct { fn_name: []const u8, has_body: bool, - storage_class: ZigClangStorageClass, + storage_class: clang.StorageClass, is_export: bool, }; fn transCC( rp: RestorePoint, - fn_ty: *const ZigClangFunctionType, - source_loc: ZigClangSourceLocation, + fn_ty: *const clang.FunctionType, + source_loc: clang.SourceLocation, ) !CallingConvention { - const clang_cc = ZigClangFunctionType_getCallConv(fn_ty); + const clang_cc = fn_ty.getCallConv(); switch (clang_cc) { .C => return CallingConvention.C, .X86StdCall => return CallingConvention.Stdcall, @@ -4940,22 +4940,22 @@ fn transCC( fn transFnProto( rp: RestorePoint, - fn_decl: ?*const ZigClangFunctionDecl, - fn_proto_ty: *const ZigClangFunctionProtoType, - source_loc: ZigClangSourceLocation, + fn_decl: ?*const clang.FunctionDecl, + fn_proto_ty: *const clang.FunctionProtoType, + source_loc: clang.SourceLocation, fn_decl_context: ?FnDeclContext, is_pub: bool, ) !*ast.Node.FnProto { - const fn_ty = @ptrCast(*const ZigClangFunctionType, fn_proto_ty); + const fn_ty = @ptrCast(*const clang.FunctionType, fn_proto_ty); const cc = try transCC(rp, fn_ty, source_loc); - const is_var_args = ZigClangFunctionProtoType_isVariadic(fn_proto_ty); + const is_var_args = fn_proto_ty.isVariadic(); return finishTransFnProto(rp, fn_decl, fn_proto_ty, fn_ty, source_loc, fn_decl_context, is_var_args, cc, is_pub); } fn transFnNoProto( rp: RestorePoint, - fn_ty: *const ZigClangFunctionType, - source_loc: ZigClangSourceLocation, + fn_ty: *const clang.FunctionType, + source_loc: clang.SourceLocation, fn_decl_context: ?FnDeclContext, is_pub: bool, ) !*ast.Node.FnProto { @@ -4966,10 +4966,10 @@ fn transFnNoProto( fn finishTransFnProto( rp: RestorePoint, - fn_decl: ?*const ZigClangFunctionDecl, - fn_proto_ty: ?*const ZigClangFunctionProtoType, - fn_ty: *const ZigClangFunctionType, - source_loc: ZigClangSourceLocation, + fn_decl: ?*const clang.FunctionDecl, + fn_proto_ty: ?*const clang.FunctionProtoType, + fn_ty: *const clang.FunctionType, + source_loc: clang.SourceLocation, fn_decl_context: ?FnDeclContext, is_var_args: bool, cc: CallingConvention, @@ -4995,19 +4995,19 @@ fn finishTransFnProto( var fn_params = std.ArrayList(ast.Node.FnProto.ParamDecl).init(rp.c.gpa); defer fn_params.deinit(); - const param_count: usize = if (fn_proto_ty != null) ZigClangFunctionProtoType_getNumParams(fn_proto_ty.?) else 0; + const param_count: usize = if (fn_proto_ty != null) fn_proto_ty.?.getNumParams() else 0; try fn_params.ensureCapacity(param_count + 1); // +1 for possible var args node var i: usize = 0; while (i < param_count) : (i += 1) { - const param_qt = ZigClangFunctionProtoType_getParamType(fn_proto_ty.?, @intCast(c_uint, i)); + const param_qt = fn_proto_ty.?.getParamType(@intCast(c_uint, i)); - const noalias_tok = if (ZigClangQualType_isRestrictQualified(param_qt)) try appendToken(rp.c, .Keyword_noalias, "noalias") else null; + const noalias_tok = if (param_qt.isRestrictQualified()) try appendToken(rp.c, .Keyword_noalias, "noalias") else null; const param_name_tok: ?ast.TokenIndex = blk: { if (fn_decl) |decl| { - const param = ZigClangFunctionDecl_getParamDecl(decl, @intCast(c_uint, i)); - const param_name: []const u8 = try rp.c.str(ZigClangNamedDecl_getName_bytes_begin(@ptrCast(*const ZigClangNamedDecl, param))); + const param = decl.getParamDecl(@intCast(c_uint, i)); + const param_name: []const u8 = try rp.c.str(@ptrCast(*const clang.NamedDecl, param).getName_bytes_begin()); if (param_name.len < 1) break :blk null; @@ -5045,7 +5045,7 @@ fn finishTransFnProto( const linksection_expr = blk: { if (fn_decl) |decl| { var str_len: usize = undefined; - if (ZigClangFunctionDecl_getSectionAttribute(decl, &str_len)) |str_ptr| { + if (decl.getSectionAttribute(&str_len)) |str_ptr| { _ = try appendToken(rp.c, .Keyword_linksection, "linksection"); _ = try appendToken(rp.c, .LParen, "("); const expr = try transCreateNodeStringLiteral( @@ -5062,7 +5062,7 @@ fn finishTransFnProto( const align_expr = blk: { if (fn_decl) |decl| { - const alignment = ZigClangFunctionDecl_getAlignedAttribute(decl, rp.c.clang_context); + const alignment = decl.getAlignedAttribute(rp.c.clang_context); if (alignment != 0) { _ = try appendToken(rp.c, .Keyword_align, "align"); _ = try appendToken(rp.c, .LParen, "("); @@ -5085,10 +5085,10 @@ fn finishTransFnProto( }; const return_type_node = blk: { - if (ZigClangFunctionType_getNoReturnAttr(fn_ty)) { + if (fn_ty.getNoReturnAttr()) { break :blk try transCreateNodeIdentifier(rp.c, "noreturn"); } else { - const return_qt = ZigClangFunctionType_getReturnType(fn_ty); + const return_qt = fn_ty.getReturnType(); if (isCVoid(return_qt)) { // convert primitive c_void to actual void (only for return type) break :blk try transCreateNodeIdentifier(rp.c, "void"); @@ -5136,7 +5136,7 @@ fn finishTransFnProto( fn revertAndWarn( rp: RestorePoint, err: anytype, - source_loc: ZigClangSourceLocation, + source_loc: clang.SourceLocation, comptime format: []const u8, args: anytype, ) (@TypeOf(err) || error{OutOfMemory}) { @@ -5145,12 +5145,12 @@ fn revertAndWarn( return err; } -fn emitWarning(c: *Context, loc: ZigClangSourceLocation, comptime format: []const u8, args: anytype) !void { +fn emitWarning(c: *Context, loc: clang.SourceLocation, comptime format: []const u8, args: anytype) !void { const args_prefix = .{c.locStr(loc)}; _ = try appendTokenFmt(c, .LineComment, "// {}: warning: " ++ format, args_prefix ++ args); } -pub fn failDecl(c: *Context, loc: ZigClangSourceLocation, name: []const u8, comptime format: []const u8, args: anytype) !void { +pub fn failDecl(c: *Context, loc: clang.SourceLocation, name: []const u8, comptime format: []const u8, args: anytype) !void { // pub const name = @compileError(msg); const pub_tok = try appendToken(c, .Keyword_pub, "pub"); const const_tok = try appendToken(c, .Keyword_const, "const"); @@ -5287,14 +5287,14 @@ fn transCreateNodeIdentifierUnchecked(c: *Context, name: []const u8) !*ast.Node } pub fn freeErrors(errors: []ClangErrMsg) void { - ZigClangErrorMsg_delete(errors.ptr, errors.len); + errors.ptr.delete(errors.len); } const MacroCtx = struct { source: []const u8, list: []const CToken, i: usize = 0, - loc: ZigClangSourceLocation, + loc: clang.SourceLocation, name: []const u8, fn peek(self: *MacroCtx) ?CToken.Id { @@ -5318,22 +5318,22 @@ const MacroCtx = struct { } }; -fn transPreprocessorEntities(c: *Context, unit: *ZigClangASTUnit) Error!void { +fn transPreprocessorEntities(c: *Context, unit: *clang.ASTUnit) Error!void { // TODO if we see #undef, delete it from the table - var it = ZigClangASTUnit_getLocalPreprocessingEntities_begin(unit); - const it_end = ZigClangASTUnit_getLocalPreprocessingEntities_end(unit); + var it = unit.getLocalPreprocessingEntities_begin(); + const it_end = unit.getLocalPreprocessingEntities_end(); var tok_list = std.ArrayList(CToken).init(c.gpa); defer tok_list.deinit(); const scope = c.global_scope; while (it.I != it_end.I) : (it.I += 1) { - const entity = ZigClangPreprocessingRecord_iterator_deref(it); + const entity = it.deref(); tok_list.items.len = 0; - switch (ZigClangPreprocessedEntity_getKind(entity)) { + switch (entity.getKind()) { .MacroDefinitionKind => { - const macro = @ptrCast(*ZigClangMacroDefinitionRecord, entity); - const raw_name = ZigClangMacroDefinitionRecord_getName_getNameStart(macro); - const begin_loc = ZigClangMacroDefinitionRecord_getSourceRange_getBegin(macro); + const macro = @ptrCast(*clang.MacroDefinitionRecord, entity); + const raw_name = macro.getName_getNameStart(); + const begin_loc = macro.getSourceRange_getBegin(); const name = try c.str(raw_name); // TODO https://github.com/ziglang/zig/issues/3756 @@ -5343,7 +5343,7 @@ fn transPreprocessorEntities(c: *Context, unit: *ZigClangASTUnit) Error!void { continue; } - const begin_c = ZigClangSourceManager_getCharacterData(c.source_manager, begin_loc); + const begin_c = c.source_manager.getCharacterData(begin_loc); const slice = begin_c[0..mem.len(begin_c)]; var tokenizer = std.c.Tokenizer{ diff --git a/src/zig_clang.h b/src/zig_clang.h index 1fbf7359de..41a9bb670c 100644 --- a/src/zig_clang.h +++ b/src/zig_clang.h @@ -68,16 +68,17 @@ struct ZigClangExprEvalResult { ZigClangAPValue Val; }; +struct ZigClangAbstractConditionalOperator; struct ZigClangAPFloat; struct ZigClangAPInt; struct ZigClangAPSInt; -struct ZigClangAPValue; struct ZigClangASTContext; struct ZigClangASTUnit; struct ZigClangArraySubscriptExpr; struct ZigClangArrayType; struct ZigClangAttributedType; struct ZigClangBinaryOperator; +struct ZigClangBinaryConditionalOperator; struct ZigClangBreakStmt; struct ZigClangBuiltinType; struct ZigClangCStyleCastExpr; diff --git a/test/compile_errors.zig b/test/compile_errors.zig index 816d569b4d..44ee58f002 100644 --- a/test/compile_errors.zig +++ b/test/compile_errors.zig @@ -2,6 +2,19 @@ const tests = @import("tests.zig"); const std = @import("std"); pub fn addCases(cases: *tests.CompileErrorContext) void { + cases.add("array in c exported function", + \\export fn zig_array(x: [10]u8) void { + \\ expect(std.mem.eql(u8, &x, "1234567890")); + \\} + \\ + \\export fn zig_return_array() [10]u8 { + \\ return "1234567890".*; + \\} + , &[_][]const u8{ + "tmp.zig:1:24: error: parameter of type '[10]u8' not allowed in function with calling convention 'C'", + "tmp.zig:5:30: error: return type '[10]u8' not allowed in function with calling convention 'C'", + }); + cases.add("@Type for exhaustive enum with undefined tag type", \\const TypeInfo = @import("builtin").TypeInfo; \\const Tag = @Type(.{ @@ -125,6 +138,31 @@ pub fn addCases(cases: *tests.CompileErrorContext) void { "tmp.zig:15:23: error: enum field missing: 'arst'", "tmp.zig:27:24: note: referenced here", }); + + cases.add("field access of opaque type", + \\const MyType = opaque {}; + \\ + \\export fn entry() bool { + \\ var x: i32 = 1; + \\ return bar(@ptrCast(*MyType, &x)); + \\} + \\ + \\fn bar(x: *MyType) bool { + \\ return x.blah; + \\} + , &[_][]const u8{ + "tmp.zig:9:13: error: no member named 'blah' in opaque type 'MyType'", + }); + + cases.add("opaque type with field", + \\const Opaque = opaque { foo: i32 }; + \\export fn entry() void { + \\ const foo: ?*Opaque = null; + \\} + , &[_][]const u8{ + "tmp.zig:1:25: error: opaque types cannot have fields", + }); + cases.add("@Type(.Fn) with is_generic = true", \\const Foo = @Type(.{ \\ .Fn = .{ @@ -180,7 +218,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void { \\ .layout = .Auto, \\ .tag_type = null, \\ .fields = &[_]TypeInfo.UnionField{ - \\ .{ .name = "foo", .field_type = @Type(.Opaque), .alignment = 1 }, + \\ .{ .name = "foo", .field_type = opaque {}, .alignment = 1 }, \\ }, \\ .decls = &[_]TypeInfo.Declaration{}, \\ }, @@ -2287,7 +2325,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void { \\ return error.OutOfMemory; \\} , &[_][]const u8{ - "tmp.zig:2:12: error: error is discarded", + "tmp.zig:2:12: error: error is discarded. consider using `try`, `catch`, or `if`", }); cases.add("volatile on global assembly", @@ -2338,9 +2376,9 @@ pub fn addCases(cases: *tests.CompileErrorContext) void { \\ return error.Bad; \\} , &[_][]const u8{ - "tmp.zig:2:24: error: expression value is ignored", - "tmp.zig:6:25: error: expression value is ignored", - "tmp.zig:10:25: error: expression value is ignored", + "tmp.zig:2:24: error: error is ignored. consider using `try`, `catch`, or `if`", + "tmp.zig:6:25: error: error is ignored. consider using `try`, `catch`, or `if`", + "tmp.zig:10:25: error: error is ignored. consider using `try`, `catch`, or `if`", }); cases.add("empty while loop body", @@ -2613,7 +2651,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void { }); cases.add("directly embedding opaque type in struct and union", - \\const O = @Type(.Opaque); + \\const O = opaque {}; \\const Foo = struct { \\ o: O, \\}; @@ -2628,7 +2666,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void { \\ var bar: Bar = undefined; \\} \\export fn c() void { - \\ var baz: *@Type(.Opaque) = undefined; + \\ var baz: *opaque {} = undefined; \\ const qux = .{baz.*}; \\} , &[_][]const u8{ @@ -3592,7 +3630,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void { }); cases.add("unknown length pointer to opaque", - \\export const T = [*]@Type(.Opaque); + \\export const T = [*]opaque {}; , &[_][]const u8{ "tmp.zig:1:21: error: unknown-length pointer to opaque", }); @@ -6236,7 +6274,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void { \\} \\fn bar() anyerror!i32 { return 0; } , &[_][]const u8{ - "tmp.zig:2:14: error: expression value is ignored", + "tmp.zig:2:14: error: error is ignored. consider using `try`, `catch`, or `if`", }); cases.add("dereference an array", @@ -6827,8 +6865,8 @@ pub fn addCases(cases: *tests.CompileErrorContext) void { "tmp.zig:2:31: error: index 2 outside array of size 2", }); - cases.add("wrong pointer coerced to pointer to @Type(.Opaque)", - \\const Derp = @Type(.Opaque); + cases.add("wrong pointer coerced to pointer to opaque {}", + \\const Derp = opaque {}; \\extern fn bar(d: *Derp) void; \\export fn foo() void { \\ var x = @as(u8, 1); @@ -6854,8 +6892,8 @@ pub fn addCases(cases: *tests.CompileErrorContext) void { \\export fn entry5() void { \\ var d = null; \\} - \\export fn entry6(opaque: *Opaque) void { - \\ var e = opaque.*; + \\export fn entry6(opaque_: *Opaque) void { + \\ var e = opaque_.*; \\} \\export fn entry7() void { \\ var f = i32; @@ -6866,7 +6904,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void { \\export fn entry9() void { \\ var z: noreturn = return; \\} - \\const Opaque = @Type(.Opaque); + \\const Opaque = opaque {}; \\const Foo = struct { \\ fn bar(self: *const Foo) void {} \\}; @@ -7019,21 +7057,6 @@ pub fn addCases(cases: *tests.CompileErrorContext) void { "tmp.zig:37:29: error: cannot store runtime value in compile time variable", }); - cases.add("field access of opaque type", - \\const MyType = @Type(.Opaque); - \\ - \\export fn entry() bool { - \\ var x: i32 = 1; - \\ return bar(@ptrCast(*MyType, &x)); - \\} - \\ - \\fn bar(x: *MyType) bool { - \\ return x.blah; - \\} - , &[_][]const u8{ - "tmp.zig:9:13: error: type '*MyType' does not support field access", - }); - cases.add("invalid legacy unicode escape", \\export fn entry() void { \\ const a = '\U1234'; @@ -7623,7 +7646,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void { }); cases.add("function returning opaque type", - \\const FooType = @Type(.Opaque); + \\const FooType = opaque {}; \\export fn bar() !FooType { \\ return error.InvalidValue; \\} @@ -7641,7 +7664,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void { }); cases.add("generic function returning opaque type", - \\const FooType = @Type(.Opaque); + \\const FooType = opaque {}; \\fn generic(comptime T: type) !T { \\ return undefined; \\} @@ -7665,7 +7688,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void { }); cases.add("function parameter is opaque", - \\const FooType = @Type(.Opaque); + \\const FooType = opaque {}; \\export fn entry1() void { \\ const someFuncPtr: fn (FooType) void = undefined; \\} diff --git a/test/gen_h.zig b/test/gen_h.zig index 7a86d914d7..2122558079 100644 --- a/test/gen_h.zig +++ b/test/gen_h.zig @@ -74,7 +74,7 @@ pub fn addCases(cases: *tests.GenHContext) void { }); cases.add("declare opaque type", - \\const Foo = @Type(.Opaque); + \\const Foo = opaque {}; \\ \\export fn entry(foo: ?*Foo) void { } , &[_][]const u8{ diff --git a/test/stage1/behavior/misc.zig b/test/stage1/behavior/misc.zig index a71d6f86f3..04087dd4af 100644 --- a/test/stage1/behavior/misc.zig +++ b/test/stage1/behavior/misc.zig @@ -438,8 +438,8 @@ export fn writeToVRam() void { vram[0] = 'X'; } -const OpaqueA = @Type(.Opaque); -const OpaqueB = @Type(.Opaque); +const OpaqueA = opaque {}; +const OpaqueB = opaque {}; test "opaque types" { expect(*OpaqueA != *OpaqueB); expect(mem.eql(u8, @typeName(OpaqueA), "OpaqueA")); @@ -704,7 +704,7 @@ test "auto created variables have correct alignment" { comptime expect(S.foo("\x7a\x7a\x7a\x7a") == 0x7a7a7a7a); } -extern var opaque_extern_var: @Type(.Opaque); +extern var opaque_extern_var: opaque {}; var var_to_export: u32 = 42; test "extern variable with non-pointer opaque type" { @export(var_to_export, .{ .name = "opaque_extern_var" }); diff --git a/test/stage1/behavior/type.zig b/test/stage1/behavior/type.zig index 60a23ffa94..53a47228db 100644 --- a/test/stage1/behavior/type.zig +++ b/test/stage1/behavior/type.zig @@ -190,8 +190,17 @@ test "Type.ErrorUnion" { } test "Type.Opaque" { - testing.expect(@Type(.Opaque) != @Type(.Opaque)); - testing.expect(@typeInfo(@Type(.Opaque)) == .Opaque); + const Opaque = @Type(.{ + .Opaque = .{ + .decls = &[_]TypeInfo.Declaration{}, + }, + }); + testing.expect(Opaque != opaque {}); + testing.expectEqualSlices( + TypeInfo.Declaration, + &[_]TypeInfo.Declaration{}, + @typeInfo(Opaque).Opaque.decls, + ); } test "Type.Vector" { diff --git a/test/stage1/behavior/type_info.zig b/test/stage1/behavior/type_info.zig index 8b413bf031..e663284d0d 100644 --- a/test/stage1/behavior/type_info.zig +++ b/test/stage1/behavior/type_info.zig @@ -199,7 +199,7 @@ fn testUnion() void { expect(typeinfo_info.Union.tag_type.? == TypeId); expect(typeinfo_info.Union.fields.len == 25); expect(typeinfo_info.Union.fields[4].field_type == @TypeOf(@typeInfo(u8).Int)); - expect(typeinfo_info.Union.decls.len == 21); + expect(typeinfo_info.Union.decls.len == 22); const TestNoTagUnion = union { Foo: void, @@ -265,6 +265,21 @@ const TestStruct = packed struct { const Self = @This(); }; +test "type info: opaque info" { + testOpaque(); + comptime testOpaque(); +} + +fn testOpaque() void { + const Foo = opaque { + const A = 1; + fn b() void {} + }; + + const foo_info = @typeInfo(Foo); + expect(foo_info.Opaque.decls.len == 2); +} + test "type info: function type info" { // wasm doesn't support align attributes on functions if (builtin.arch == .wasm32 or builtin.arch == .wasm64) return error.SkipZigTest; diff --git a/test/stage1/c_abi/cfuncs.c b/test/stage1/c_abi/cfuncs.c index 0e7bd2906f..0e8204779a 100644 --- a/test/stage1/c_abi/cfuncs.c +++ b/test/stage1/c_abi/cfuncs.c @@ -28,8 +28,6 @@ void zig_ptr(void *); void zig_bool(bool); -void zig_array(uint8_t[10]); - struct BigStruct { uint64_t a; uint64_t b; @@ -97,9 +95,6 @@ void run_c_tests(void) { zig_bool(true); - uint8_t array[10] = {'1', '2', '3', '4', '5', '6', '7', '8', '9', '0'}; - zig_array(array); - { struct BigStruct s = {1, 2, 3, 4, 5}; zig_big_struct(s); @@ -190,19 +185,6 @@ void c_five_floats(float a, float b, float c, float d, float e) { assert_or_panic(e == 5.0); } -void c_array(uint8_t x[10]) { - assert_or_panic(x[0] == '1'); - assert_or_panic(x[1] == '2'); - assert_or_panic(x[2] == '3'); - assert_or_panic(x[3] == '4'); - assert_or_panic(x[4] == '5'); - assert_or_panic(x[5] == '6'); - assert_or_panic(x[6] == '7'); - assert_or_panic(x[7] == '8'); - assert_or_panic(x[8] == '9'); - assert_or_panic(x[9] == '0'); -} - void c_big_struct(struct BigStruct x) { assert_or_panic(x.a == 1); assert_or_panic(x.b == 2); diff --git a/test/stage1/c_abi/main.zig b/test/stage1/c_abi/main.zig index 9090bb481e..18e9858da4 100644 --- a/test/stage1/c_abi/main.zig +++ b/test/stage1/c_abi/main.zig @@ -116,17 +116,6 @@ export fn zig_bool(x: bool) void { expect(x); } -extern fn c_array([10]u8) void; - -test "C ABI array" { - var array: [10]u8 = "1234567890".*; - c_array(array); -} - -export fn zig_array(x: [10]u8) void { - expect(std.mem.eql(u8, &x, "1234567890")); -} - const BigStruct = extern struct { a: u64, b: u64, diff --git a/test/translate_c.zig b/test/translate_c.zig index 4182dbaa13..8b9537b45d 100644 --- a/test/translate_c.zig +++ b/test/translate_c.zig @@ -137,9 +137,9 @@ pub fn addCases(cases: *tests.TranslateCContext) void { \\struct foo { int x; int y[]; }; \\struct bar { int x; int y[0]; }; , &[_][]const u8{ - \\pub const struct_foo = @Type(.Opaque); + \\pub const struct_foo = opaque {}; , - \\pub const struct_bar = @Type(.Opaque); + \\pub const struct_bar = opaque {}; }); cases.add("nested loops without blocks", @@ -207,7 +207,7 @@ pub fn addCases(cases: *tests.TranslateCContext) void { \\pub const struct_arcan_shmif_page = // , \\warning: unsupported type: 'Atomic' - \\ @Type(.Opaque); // + \\ opaque {}; // , \\ warning: struct demoted to opaque type - unable to translate type of field abufused , // TODO should be `addr: *struct_arcan_shmif_page` @@ -386,8 +386,8 @@ pub fn addCases(cases: *tests.TranslateCContext) void { \\ struct opaque_2 *cast = (struct opaque_2 *)opaque; \\} , &[_][]const u8{ - \\pub const struct_opaque = @Type(.Opaque); - \\pub const struct_opaque_2 = @Type(.Opaque); + \\pub const struct_opaque = opaque {}; + \\pub const struct_opaque_2 = opaque {}; \\pub export fn function(arg_opaque_1: ?*struct_opaque) void { \\ var opaque_1 = arg_opaque_1; \\ var cast: ?*struct_opaque_2 = @ptrCast(?*struct_opaque_2, opaque_1); @@ -628,7 +628,7 @@ pub fn addCases(cases: *tests.TranslateCContext) void { \\ struct Foo *foo; \\}; , &[_][]const u8{ - \\pub const struct_Foo = @Type(.Opaque); + \\pub const struct_Foo = opaque {}; , \\pub const struct_Bar = extern struct { \\ foo: ?*struct_Foo, @@ -705,7 +705,7 @@ pub fn addCases(cases: *tests.TranslateCContext) void { \\struct Foo; \\struct Foo *some_func(struct Foo *foo, int x); , &[_][]const u8{ - \\pub const struct_Foo = @Type(.Opaque); + \\pub const struct_Foo = opaque {}; , \\pub extern fn some_func(foo: ?*struct_Foo, x: c_int) ?*struct_Foo; , diff --git a/tools/update_clang_options.zig b/tools/update_clang_options.zig index 8b7811aa26..9510b6a075 100644 --- a/tools/update_clang_options.zig +++ b/tools/update_clang_options.zig @@ -130,6 +130,10 @@ const known_options = [_]KnownOpt{ .name = "assemble", .ident = "asm_only", }, + .{ + .name = "O0", + .ident = "optimize", + }, .{ .name = "O1", .ident = "optimize", @@ -138,10 +142,20 @@ const known_options = [_]KnownOpt{ .name = "O2", .ident = "optimize", }, + // O3 is only detected from the joined "-O" option + .{ + .name = "O4", + .ident = "optimize", + }, .{ .name = "Og", .ident = "optimize", }, + .{ + .name = "Os", + .ident = "optimize", + }, + // Oz is only detected from the joined "-O" option .{ .name = "O", .ident = "optimize", @@ -154,6 +168,14 @@ const known_options = [_]KnownOpt{ .name = "optimize", .ident = "optimize", }, + .{ + .name = "g1", + .ident = "debug", + }, + .{ + .name = "gline-tables-only", + .ident = "debug", + }, .{ .name = "g", .ident = "debug", @@ -390,6 +412,10 @@ pub fn main() anyerror!void { // the only way. try stdout.print("flagpsl(\"{}\"),\n", .{name}); } else if (knownOption(name)) |ident| { + + // Workaround the fact that in 'Options.td' -Ofast is listed as 'joined' + const final_syntax = if (std.mem.eql(u8, name, "Ofast")) .flag else syntax; + try stdout.print( \\.{{ \\ .name = "{}", @@ -400,7 +426,7 @@ pub fn main() anyerror!void { \\ .psl = {}, \\}}, \\ - , .{ name, syntax, ident, pd1, pd2, pslash }); + , .{ name, final_syntax, ident, pd1, pd2, pslash }); } else if (pd1 and !pd2 and !pslash and syntax == .flag) { try stdout.print("flagpd1(\"{}\"),\n", .{name}); } else if (!pd1 and !pd2 and pslash and syntax == .flag) {