authorgravatar for andrew@ziglang.orgAndrew Kelley <andrew@ziglang.org> 2020-10-08 15:47:45-07:00
committergravatar for andrew@ziglang.orgAndrew Kelley <andrew@ziglang.org> 2020-10-08 15:47:45-07:00
log8b7539bd9554d25599ccff6f0e9ea79aa051946b
tree9157fafcbe37f904346fd73042be1d1d299d4da2
parentb5a36f676b1fd69f195d9f1eb6e35f3eb2f15946
parentb02341d6f58e0b8a87fc2ab589dcfd85e5dc96cd

Merge remote-tracking branch 'origin/master' into llvm11

Conflicts: src/clang.zig Master branch renamed an enum; this branch gave it an explicit tag type and explicitly initialized values. This commit combines the changes together.

45 files changed, 2689 insertions(+), 1445 deletions(-)

doc/docgen.zig+1
......@@ -808,6 +808,7 @@ fn tokenizeAndPrintRaw(docgen_tokenizer: *Tokenizer, out: anytype, source_token:
808808 .Keyword_noalias,
809809 .Keyword_noinline,
810810 .Keyword_nosuspend,
811 .Keyword_opaque,
811812 .Keyword_or,
812813 .Keyword_orelse,
813814 .Keyword_packed,
doc/langref.html.in+11-9
......@@ -1988,7 +1988,7 @@ test "null terminated array" {
19881988 <li>Supports slice syntax: {#syntax#}ptr[start..end]{#endsyntax#}</li>
19891989 <li>Supports pointer arithmetic: {#syntax#}ptr + x{#endsyntax#}, {#syntax#}ptr - x{#endsyntax#}</li>
19901990 <li>{#syntax#}T{#endsyntax#} must have a known size, which means that it cannot be
1991 {#syntax#}c_void{#endsyntax#} or any other {#link|opaque type|Opaque Types#}.</li>
1991 {#syntax#}c_void{#endsyntax#} or any other {#link|opaque type|opaque#}.</li>
19921992 </ul>
19931993 </li>
19941994 </ul>
......@@ -5545,7 +5545,7 @@ test "turn HashMap into a set with void" {
55455545 </p>
55465546 <p>
55475547 {#syntax#}void{#endsyntax#} is distinct from {#syntax#}c_void{#endsyntax#}, which is defined like this:
5548 {#syntax#}pub const c_void = @Type(.Opaque);{#endsyntax#}.
5548 {#syntax#}pub const c_void = opaque {};{#endsyntax#}.
55495549 {#syntax#}void{#endsyntax#} has a known size of 0 bytes, and {#syntax#}c_void{#endsyntax#} has an unknown, but non-zero, size.
55505550 </p>
55515551 <p>
......@@ -8471,7 +8471,7 @@ test "integer truncation" {
84718471 <li>{#link|Error Set Type#}</li>
84728472 <li>{#link|Error Union Type#}</li>
84738473 <li>{#link|Vectors#}</li>
8474 <li>{#link|Opaque Types#}</li>
8474 <li>{#link|opaque#}</li>
84758475 <li>{#link|@Frame#}</li>
84768476 <li>{#syntax#}anyframe{#endsyntax#}</li>
84778477 <li>{#link|struct#}</li>
......@@ -8547,17 +8547,18 @@ fn foo(comptime T: type, ptr: *T) T {
85478547 {#header_close#}
85488548 {#header_close#}
85498549
8550 {#header_open|Opaque Types#}
8550 {#header_open|opaque#}
85518551 <p>
8552 {#syntax#}@Type(.Opaque){#endsyntax#} creates a new type with an unknown (but non-zero) size and alignment.
8552 {#syntax#}opaque {}{#endsyntax#} declares a new type with an unknown (but non-zero) size and alignment.
8553 It can have declarations like structs, unions, or enums.
85538554 </p>
85548555 <p>
85558556 This is typically used for type safety when interacting with C code that does not expose struct details.
85568557 Example:
85578558 </p>
85588559 {#code_begin|test_err|expected type '*Derp', found '*Wat'#}
8559const Derp = @Type(.Opaque);
8560const Wat = @Type(.Opaque);
8560const Derp = opaque {};
8561const Wat = opaque {};
85618562
85628563extern fn bar(d: *Derp) void;
85638564fn foo(w: *Wat) callconv(.C) void {
......@@ -11193,7 +11194,7 @@ PtrTypeStart
1119311194ContainerDeclAuto &lt;- ContainerDeclType LBRACE ContainerMembers RBRACE
1119411195
1119511196ContainerDeclType
11196 &lt;- (KEYWORD_struct / KEYWORD_enum) (LPAREN Expr RPAREN)?
11197 &lt;- (KEYWORD_struct / KEYWORD_enum / KEYWORD_opaque) (LPAREN Expr RPAREN)?
1119711198 / KEYWORD_union (LPAREN (KEYWORD_enum (LPAREN Expr RPAREN)? / Expr) RPAREN)?
1119811199
1119911200# Alignment
......@@ -11340,6 +11341,7 @@ KEYWORD_inline &lt;- 'inline' end_of_word
1134011341KEYWORD_noalias &lt;- 'noalias' end_of_word
1134111342KEYWORD_nosuspend &lt;- 'nosuspend' end_of_word
1134211343KEYWORD_null &lt;- 'null' end_of_word
11344KEYWORD_opaque &lt;- 'opaque' end_of_word
1134311345KEYWORD_or &lt;- 'or' end_of_word
1134411346KEYWORD_orelse &lt;- 'orelse' end_of_word
1134511347KEYWORD_packed &lt;- 'packed' end_of_word
......@@ -11368,7 +11370,7 @@ keyword &lt;- KEYWORD_align / KEYWORD_and / KEYWORD_anyframe / KEYWORD_anytype
1136811370 / KEYWORD_defer / KEYWORD_else / KEYWORD_enum / KEYWORD_errdefer
1136911371 / KEYWORD_error / KEYWORD_export / KEYWORD_extern / KEYWORD_false
1137011372 / KEYWORD_fn / KEYWORD_for / KEYWORD_if / KEYWORD_inline
11371 / KEYWORD_noalias / KEYWORD_null / KEYWORD_or
11373 / KEYWORD_noalias / KEYWORD_null / KEYWORD_opaque / KEYWORD_or
1137211374 / KEYWORD_orelse / KEYWORD_packed / KEYWORD_pub
1137311375 / KEYWORD_resume / KEYWORD_return / KEYWORD_linksection
1137411376 / KEYWORD_struct / KEYWORD_suspend
lib/std/builtin.zig+7-2
......@@ -151,7 +151,6 @@ pub const Mode = enum {
151151pub const CallingConvention = enum {
152152 Unspecified,
153153 C,
154 Cold,
155154 Naked,
156155 Async,
157156 Interrupt,
......@@ -199,7 +198,7 @@ pub const TypeInfo = union(enum) {
199198 Union: Union,
200199 Fn: Fn,
201200 BoundFn: Fn,
202 Opaque: void,
201 Opaque: Opaque,
203202 Frame: Frame,
204203 AnyFrame: AnyFrame,
205204 Vector: Vector,
......@@ -360,6 +359,12 @@ pub const TypeInfo = union(enum) {
360359 args: []const FnArg,
361360 };
362361
362 /// This data structure is used by the Zig language code generation and
363 /// therefore must be kept in sync with the compiler implementation.
364 pub const Opaque = struct {
365 decls: []const Declaration,
366 };
367
363368 /// This data structure is used by the Zig language code generation and
364369 /// therefore must be kept in sync with the compiler implementation.
365370 pub const Frame = struct {
lib/std/c.zig+2-2
......@@ -329,8 +329,8 @@ pub extern "c" fn pthread_cond_signal(cond: *pthread_cond_t) c_int;
329329pub extern "c" fn pthread_cond_broadcast(cond: *pthread_cond_t) c_int;
330330pub extern "c" fn pthread_cond_destroy(cond: *pthread_cond_t) c_int;
331331
332pub const pthread_t = *@Type(.Opaque);
333pub const FILE = @Type(.Opaque);
332pub const pthread_t = *opaque {};
333pub const FILE = opaque {};
334334
335335pub extern "c" fn dlopen(path: [*:0]const u8, mode: c_int) ?*c_void;
336336pub extern "c" fn dlclose(handle: *c_void) c_int;
lib/std/crypto/aes.zig+9-1
......@@ -10,7 +10,15 @@ const builtin = std.builtin;
1010
1111const has_aesni = comptime std.Target.x86.featureSetHas(std.Target.current.cpu.features, .aes);
1212const has_avx = comptime std.Target.x86.featureSetHas(std.Target.current.cpu.features, .avx);
13const impl = if (std.Target.current.cpu.arch == .x86_64 and has_aesni and has_avx) @import("aes/aesni.zig") else @import("aes/soft.zig");
13const has_armaes = comptime std.Target.aarch64.featureSetHas(std.Target.current.cpu.features, .aes);
14const impl = if (std.Target.current.cpu.arch == .x86_64 and has_aesni and has_avx) impl: {
15 break :impl @import("aes/aesni.zig");
16} else if (std.Target.current.cpu.arch == .aarch64 and has_armaes)
17impl: {
18 break :impl @import("aes/armcrypto.zig");
19} else impl: {
20 break :impl @import("aes/soft.zig");
21};
1422
1523pub const Block = impl.Block;
1624pub const AESEncryptCtx = impl.AESEncryptCtx;
lib/std/crypto/aes/aesni.zig-1
......@@ -3,7 +3,6 @@
33// This file is part of [zig](https://ziglang.org/), which is MIT licensed.
44// The MIT license requires this copyright notice to be included in all copies
55// and substantial portions of the software.
6// Based on Go stdlib implementation
76
87const std = @import("../../std.zig");
98const mem = std.mem;
lib/std/crypto/aes/armcrypto.zig created+490
......@@ -0,0 +1,490 @@
1// SPDX-License-Identifier: MIT
2// Copyright (c) 2015-2020 Zig Contributors
3// This file is part of [zig](https://ziglang.org/), which is MIT licensed.
4// The MIT license requires this copyright notice to be included in all copies
5// and substantial portions of the software.
6
7const std = @import("../../std.zig");
8const mem = std.mem;
9const debug = std.debug;
10const Vector = std.meta.Vector;
11
12const BlockVec = Vector(2, u64);
13
14/// A single AES block.
15pub const Block = struct {
16 pub const block_size: usize = 16;
17
18 /// Internal representation of a block.
19 repr: BlockVec,
20
21 /// Convert a byte sequence into an internal representation.
22 pub inline fn fromBytes(bytes: *const [16]u8) Block {
23 const repr = mem.bytesToValue(BlockVec, bytes);
24 return Block{ .repr = repr };
25 }
26
27 /// Convert the internal representation of a block into a byte sequence.
28 pub inline fn toBytes(block: Block) [16]u8 {
29 return mem.toBytes(block.repr);
30 }
31
32 /// XOR the block with a byte sequence.
33 pub inline fn xorBytes(block: Block, bytes: *const [16]u8) [16]u8 {
34 const x = block.repr ^ fromBytes(bytes).repr;
35 return mem.toBytes(x);
36 }
37
38 const zero = Vector(2, u64){ 0, 0 };
39
40 /// Encrypt a block with a round key.
41 pub inline fn encrypt(block: Block, round_key: Block) Block {
42 return Block{
43 .repr = asm (
44 \\ mov %[out].16b, %[in].16b
45 \\ aese %[out].16b, %[zero].16b
46 \\ aesmc %[out].16b, %[out].16b
47 \\ eor %[out].16b, %[out].16b, %[rk].16b
48 : [out] "=&x" (-> BlockVec)
49 : [in] "x" (block.repr),
50 [rk] "x" (round_key.repr),
51 [zero] "x" (zero)
52 ),
53 };
54 }
55
56 /// Encrypt a block with the last round key.
57 pub inline fn encryptLast(block: Block, round_key: Block) Block {
58 return Block{
59 .repr = asm (
60 \\ mov %[out].16b, %[in].16b
61 \\ aese %[out].16b, %[zero].16b
62 \\ eor %[out].16b, %[out].16b, %[rk].16b
63 : [out] "=&x" (-> BlockVec)
64 : [in] "x" (block.repr),
65 [rk] "x" (round_key.repr),
66 [zero] "x" (zero)
67 ),
68 };
69 }
70
71 /// Decrypt a block with a round key.
72 pub inline fn decrypt(block: Block, inv_round_key: Block) Block {
73 return Block{
74 .repr = asm (
75 \\ mov %[out].16b, %[in].16b
76 \\ aesd %[out].16b, %[zero].16b
77 \\ aesimc %[out].16b, %[out].16b
78 \\ eor %[out].16b, %[out].16b, %[rk].16b
79 : [out] "=&x" (-> BlockVec)
80 : [in] "x" (block.repr),
81 [rk] "x" (inv_round_key.repr),
82 [zero] "x" (zero)
83 ),
84 };
85 }
86
87 /// Decrypt a block with the last round key.
88 pub inline fn decryptLast(block: Block, inv_round_key: Block) Block {
89 return Block{
90 .repr = asm (
91 \\ mov %[out].16b, %[in].16b
92 \\ aesd %[out].16b, %[zero].16b
93 \\ eor %[out].16b, %[out].16b, %[rk].16b
94 : [out] "=&x" (-> BlockVec)
95 : [in] "x" (block.repr),
96 [rk] "x" (inv_round_key.repr),
97 [zero] "x" (zero)
98 ),
99 };
100 }
101
102 /// Apply the bitwise XOR operation to the content of two blocks.
103 pub inline fn xorBlocks(block1: Block, block2: Block) Block {
104 return Block{ .repr = block1.repr ^ block2.repr };
105 }
106
107 /// Apply the bitwise AND operation to the content of two blocks.
108 pub inline fn andBlocks(block1: Block, block2: Block) Block {
109 return Block{ .repr = block1.repr & block2.repr };
110 }
111
112 /// Apply the bitwise OR operation to the content of two blocks.
113 pub inline fn orBlocks(block1: Block, block2: Block) Block {
114 return Block{ .repr = block1.repr | block2.repr };
115 }
116
117 /// Perform operations on multiple blocks in parallel.
118 pub const parallel = struct {
119 /// The recommended number of AES encryption/decryption to perform in parallel for the chosen implementation.
120 pub const optimal_parallel_blocks = 8;
121
122 /// Encrypt multiple blocks in parallel, each their own round key.
123 pub inline fn encryptParallel(comptime count: usize, blocks: [count]Block, round_keys: [count]Block) [count]Block {
124 comptime var i = 0;
125 var out: [count]Block = undefined;
126 inline while (i < count) : (i += 1) {
127 out[i] = blocks[i].encrypt(round_keys[i]);
128 }
129 return out;
130 }
131
132 /// Decrypt multiple blocks in parallel, each their own round key.
133 pub inline fn decryptParallel(comptime count: usize, blocks: [count]Block, round_keys: [count]Block) [count]Block {
134 comptime var i = 0;
135 var out: [count]Block = undefined;
136 inline while (i < count) : (i += 1) {
137 out[i] = blocks[i].decrypt(round_keys[i]);
138 }
139 return out;
140 }
141
142 /// Encrypt multple blocks in parallel with the same round key.
143 pub inline fn encryptWide(comptime count: usize, blocks: [count]Block, round_key: Block) [count]Block {
144 comptime var i = 0;
145 var out: [count]Block = undefined;
146 inline while (i < count) : (i += 1) {
147 out[i] = blocks[i].encrypt(round_key);
148 }
149 return out;
150 }
151
152 /// Decrypt multple blocks in parallel with the same round key.
153 pub inline fn decryptWide(comptime count: usize, blocks: [count]Block, round_key: Block) [count]Block {
154 comptime var i = 0;
155 var out: [count]Block = undefined;
156 inline while (i < count) : (i += 1) {
157 out[i] = blocks[i].decrypt(round_key);
158 }
159 return out;
160 }
161
162 /// Encrypt multple blocks in parallel with the same last round key.
163 pub inline fn encryptLastWide(comptime count: usize, blocks: [count]Block, round_key: Block) [count]Block {
164 comptime var i = 0;
165 var out: [count]Block = undefined;
166 inline while (i < count) : (i += 1) {
167 out[i] = blocks[i].encryptLast(round_key);
168 }
169 return out;
170 }
171
172 /// Decrypt multple blocks in parallel with the same last round key.
173 pub inline fn decryptLastWide(comptime count: usize, blocks: [count]Block, round_key: Block) [count]Block {
174 comptime var i = 0;
175 var out: [count]Block = undefined;
176 inline while (i < count) : (i += 1) {
177 out[i] = blocks[i].decryptLast(round_key);
178 }
179 return out;
180 }
181 };
182};
183
184fn KeySchedule(comptime AES: type) type {
185 std.debug.assert(AES.rounds == 10 or AES.rounds == 14);
186 const rounds = AES.rounds;
187
188 return struct {
189 const Self = @This();
190
191 const zero = Vector(2, u64){ 0, 0 };
192 const mask1 = @Vector(16, u8){ 13, 14, 15, 12, 13, 14, 15, 12, 13, 14, 15, 12, 13, 14, 15, 12 };
193 const mask2 = @Vector(16, u8){ 12, 13, 14, 15, 12, 13, 14, 15, 12, 13, 14, 15, 12, 13, 14, 15 };
194
195 round_keys: [rounds + 1]Block,
196
197 fn drc128(comptime rc: u8, t: BlockVec) BlockVec {
198 var v1: BlockVec = undefined;
199 var v2: BlockVec = undefined;
200 var v3: BlockVec = undefined;
201 var v4: BlockVec = undefined;
202
203 return asm (
204 \\ movi %[v2].4s, %[rc]
205 \\ tbl %[v4].16b, {%[t].16b}, %[mask].16b
206 \\ ext %[r].16b, %[zero].16b, %[t].16b, #12
207 \\ aese %[v4].16b, %[zero].16b
208 \\ eor %[v2].16b, %[r].16b, %[v2].16b
209 \\ ext %[r].16b, %[zero].16b, %[r].16b, #12
210 \\ eor %[v1].16b, %[v2].16b, %[t].16b
211 \\ ext %[v3].16b, %[zero].16b, %[r].16b, #12
212 \\ eor %[v1].16b, %[v1].16b, %[r].16b
213 \\ eor %[r].16b, %[v1].16b, %[v3].16b
214 \\ eor %[r].16b, %[r].16b, %[v4].16b
215 : [r] "=&x" (-> BlockVec),
216 [v1] "=&x" (v1),
217 [v2] "=&x" (v2),
218 [v3] "=&x" (v3),
219 [v4] "=&x" (v4)
220 : [rc] "N" (rc),
221 [t] "x" (t),
222 [zero] "x" (zero),
223 [mask] "x" (mask1)
224 );
225 }
226
227 fn drc256(comptime second: bool, comptime rc: u8, t: BlockVec, tx: BlockVec) BlockVec {
228 var v1: BlockVec = undefined;
229 var v2: BlockVec = undefined;
230 var v3: BlockVec = undefined;
231 var v4: BlockVec = undefined;
232
233 return asm (
234 \\ movi %[v2].4s, %[rc]
235 \\ tbl %[v4].16b, {%[t].16b}, %[mask].16b
236 \\ ext %[r].16b, %[zero].16b, %[tx].16b, #12
237 \\ aese %[v4].16b, %[zero].16b
238 \\ eor %[v1].16b, %[tx].16b, %[r].16b
239 \\ ext %[r].16b, %[zero].16b, %[r].16b, #12
240 \\ eor %[v1].16b, %[v1].16b, %[r].16b
241 \\ ext %[v3].16b, %[zero].16b, %[r].16b, #12
242 \\ eor %[v1].16b, %[v1].16b, %[v2].16b
243 \\ eor %[v1].16b, %[v1].16b, %[v3].16b
244 \\ eor %[r].16b, %[v1].16b, %[v4].16b
245 : [r] "=&x" (-> BlockVec),
246 [v1] "=&x" (v1),
247 [v2] "=&x" (v2),
248 [v3] "=&x" (v3),
249 [v4] "=&x" (v4)
250 : [rc] "N" (if (second) @as(u8, 0) else rc),
251 [t] "x" (t),
252 [tx] "x" (tx),
253 [zero] "x" (zero),
254 [mask] "x" (if (second) mask2 else mask1)
255 );
256 }
257
258 fn expand128(t1: *Block) Self {
259 var round_keys: [11]Block = undefined;
260 const rcs = [_]u8{ 1, 2, 4, 8, 16, 32, 64, 128, 27, 54 };
261 inline for (rcs) |rc, round| {
262 round_keys[round] = t1.*;
263 t1.repr = drc128(rc, t1.repr);
264 }
265 round_keys[rcs.len] = t1.*;
266 return Self{ .round_keys = round_keys };
267 }
268
269 fn expand256(t1: *Block, t2: *Block) Self {
270 var round_keys: [15]Block = undefined;
271 const rcs = [_]u8{ 1, 2, 4, 8, 16, 32 };
272 round_keys[0] = t1.*;
273 inline for (rcs) |rc, round| {
274 round_keys[round * 2 + 1] = t2.*;
275 t1.repr = drc256(false, rc, t2.repr, t1.repr);
276 round_keys[round * 2 + 2] = t1.*;
277 t2.repr = drc256(true, rc, t1.repr, t2.repr);
278 }
279 round_keys[rcs.len * 2 + 1] = t2.*;
280 t1.repr = drc256(false, 64, t2.repr, t1.repr);
281 round_keys[rcs.len * 2 + 2] = t1.*;
282 return Self{ .round_keys = round_keys };
283 }
284
285 /// Invert the key schedule.
286 pub fn invert(key_schedule: Self) Self {
287 const round_keys = &key_schedule.round_keys;
288 var inv_round_keys: [rounds + 1]Block = undefined;
289 inv_round_keys[0] = round_keys[rounds];
290 comptime var i = 1;
291 inline while (i < rounds) : (i += 1) {
292 inv_round_keys[i] = Block{
293 .repr = asm (
294 \\ aesimc %[inv_rk].16b, %[rk].16b
295 : [inv_rk] "=x" (-> BlockVec)
296 : [rk] "x" (round_keys[rounds - i].repr)
297 ),
298 };
299 }
300 inv_round_keys[rounds] = round_keys[0];
301 return Self{ .round_keys = inv_round_keys };
302 }
303 };
304}
305
306/// A context to perform encryption using the standard AES key schedule.
307pub fn AESEncryptCtx(comptime AES: type) type {
308 std.debug.assert(AES.key_bits == 128 or AES.key_bits == 256);
309 const rounds = AES.rounds;
310
311 return struct {
312 const Self = @This();
313 pub const block = AES.block;
314 pub const block_size = block.block_size;
315 key_schedule: KeySchedule(AES),
316
317 /// Create a new encryption context with the given key.
318 pub fn init(key: [AES.key_bits / 8]u8) Self {
319 var t1 = Block.fromBytes(key[0..16]);
320 const key_schedule = if (AES.key_bits == 128) ks: {
321 break :ks KeySchedule(AES).expand128(&t1);
322 } else ks: {
323 var t2 = Block.fromBytes(key[16..32]);
324 break :ks KeySchedule(AES).expand256(&t1, &t2);
325 };
326 return Self{
327 .key_schedule = key_schedule,
328 };
329 }
330
331 /// Encrypt a single block.
332 pub fn encrypt(ctx: Self, dst: *[16]u8, src: *const [16]u8) void {
333 const round_keys = ctx.key_schedule.round_keys;
334 var t = Block.fromBytes(src).xorBlocks(round_keys[0]);
335 comptime var i = 1;
336 inline while (i < rounds) : (i += 1) {
337 t = t.encrypt(round_keys[i]);
338 }
339 t = t.encryptLast(round_keys[rounds]);
340 dst.* = t.toBytes();
341 }
342
343 /// Encrypt+XOR a single block.
344 pub fn xor(ctx: Self, dst: *[16]u8, src: *const [16]u8, counter: [16]u8) void {
345 const round_keys = ctx.key_schedule.round_keys;
346 var t = Block.fromBytes(&counter).xorBlocks(round_keys[0]);
347 comptime var i = 1;
348 inline while (i < rounds) : (i += 1) {
349 t = t.encrypt(round_keys[i]);
350 }
351 t = t.encryptLast(round_keys[rounds]);
352 dst.* = t.xorBytes(src);
353 }
354
355 /// Encrypt multiple blocks, possibly leveraging parallelization.
356 pub fn encryptWide(ctx: Self, comptime count: usize, dst: *[16 * count]u8, src: *const [16 * count]u8) void {
357 const round_keys = ctx.key_schedule.round_keys;
358 var ts: [count]Block = undefined;
359 comptime var j = 0;
360 inline while (j < count) : (j += 1) {
361 ts[j] = Block.fromBytes(src[j * 16 .. j * 16 + 16][0..16]).xorBlocks(round_keys[0]);
362 }
363 comptime var i = 1;
364 inline while (i < rounds) : (i += 1) {
365 ts = Block.parallel.encryptWide(count, ts, round_keys[i]);
366 }
367 i = 1;
368 inline while (i < count) : (i += 1) {
369 ts = Block.parallel.encryptLastWide(count, ts, round_keys[i]);
370 }
371 j = 0;
372 inline while (j < count) : (j += 1) {
373 dst[16 * j .. 16 * j + 16].* = ts[j].toBytes();
374 }
375 }
376
377 /// Encrypt+XOR multiple blocks, possibly leveraging parallelization.
378 pub fn xorWide(ctx: Self, comptime count: usize, dst: *[16 * count]u8, src: *const [16 * count]u8, counters: [16 * count]u8) void {
379 const round_keys = ctx.key_schedule.round_keys;
380 var ts: [count]Block = undefined;
381 comptime var j = 0;
382 inline while (j < count) : (j += 1) {
383 ts[j] = Block.fromBytes(counters[j * 16 .. j * 16 + 16][0..16]).xorBlocks(round_keys[0]);
384 }
385 comptime var i = 1;
386 inline while (i < rounds) : (i += 1) {
387 ts = Block.parallel.encryptWide(count, ts, round_keys[i]);
388 }
389 ts = Block.parallel.encryptLastWide(count, ts, round_keys[i]);
390 j = 0;
391 inline while (j < count) : (j += 1) {
392 dst[16 * j .. 16 * j + 16].* = ts[j].xorBytes(src[16 * j .. 16 * j + 16]);
393 }
394 }
395 };
396}
397
398/// A context to perform decryption using the standard AES key schedule.
399pub fn AESDecryptCtx(comptime AES: type) type {
400 std.debug.assert(AES.key_bits == 128 or AES.key_bits == 256);
401 const rounds = AES.rounds;
402
403 return struct {
404 const Self = @This();
405 pub const block = AES.block;
406 pub const block_size = block.block_size;
407 key_schedule: KeySchedule(AES),
408
409 /// Create a decryption context from an existing encryption context.
410 pub fn initFromEnc(ctx: AESEncryptCtx(AES)) Self {
411 return Self{
412 .key_schedule = ctx.key_schedule.invert(),
413 };
414 }
415
416 /// Create a new decryption context with the given key.
417 pub fn init(key: [AES.key_bits / 8]u8) Self {
418 const enc_ctx = AESEncryptCtx(AES).init(key);
419 return initFromEnc(enc_ctx);
420 }
421
422 /// Decrypt a single block.
423 pub fn decrypt(ctx: Self, dst: *[16]u8, src: *const [16]u8) void {
424 const inv_round_keys = ctx.key_schedule.round_keys;
425 var t = Block.fromBytes(src).xorBlocks(inv_round_keys[0]);
426 comptime var i = 1;
427 inline while (i < rounds) : (i += 1) {
428 t = t.decrypt(inv_round_keys[i]);
429 }
430 t = t.decryptLast(inv_round_keys[rounds]);
431 dst.* = t.toBytes();
432 }
433
434 /// Decrypt multiple blocks, possibly leveraging parallelization.
435 pub fn decryptWide(ctx: Self, comptime count: usize, dst: *[16 * count]u8, src: *const [16 * count]u8) void {
436 const inv_round_keys = ctx.key_schedule.round_keys;
437 var ts: [count]Block = undefined;
438 comptime var j = 0;
439 inline while (j < count) : (j += 1) {
440 ts[j] = Block.fromBytes(src[j * 16 .. j * 16 + 16][0..16]).xorBlocks(inv_round_keys[0]);
441 }
442 comptime var i = 1;
443 inline while (i < rounds) : (i += 1) {
444 ts = Block.parallel.decryptWide(count, ts, inv_round_keys[i]);
445 }
446 i = 1;
447 inline while (i < count) : (i += 1) {
448 ts = Block.parallel.decryptLastWide(count, ts, inv_round_keys[i]);
449 }
450 j = 0;
451 inline while (j < count) : (j += 1) {
452 dst[16 * j .. 16 * j + 16].* = ts[j].toBytes();
453 }
454 }
455 };
456}
457
458/// AES-128 with the standard key schedule.
459pub const AES128 = struct {
460 pub const key_bits: usize = 128;
461 pub const rounds = ((key_bits - 64) / 32 + 8);
462 pub const block = Block;
463
464 /// Create a new context for encryption.
465 pub fn initEnc(key: [key_bits / 8]u8) AESEncryptCtx(AES128) {
466 return AESEncryptCtx(AES128).init(key);
467 }
468
469 /// Create a new context for decryption.
470 pub fn initDec(key: [key_bits / 8]u8) AESDecryptCtx(AES128) {
471 return AESDecryptCtx(AES128).init(key);
472 }
473};
474
475/// AES-256 with the standard key schedule.
476pub const AES256 = struct {
477 pub const key_bits: usize = 256;
478 pub const rounds = ((key_bits - 64) / 32 + 8);
479 pub const block = Block;
480
481 /// Create a new context for encryption.
482 pub fn initEnc(key: [key_bits / 8]u8) AESEncryptCtx(AES256) {
483 return AESEncryptCtx(AES256).init(key);
484 }
485
486 /// Create a new context for decryption.
487 pub fn initDec(key: [key_bits / 8]u8) AESDecryptCtx(AES256) {
488 return AESDecryptCtx(AES256).init(key);
489 }
490};
lib/std/crypto/ghash.zig+19-1
......@@ -105,6 +105,17 @@ pub const Ghash = struct {
105105 return product[0];
106106 }
107107
108 inline fn clmul_pmull(x: u64, y: u64) u64 {
109 const Vector = std.meta.Vector;
110 const product = asm (
111 \\ pmull %[out].1q, %[x].1d, %[y].1d
112 : [out] "=w" (-> Vector(2, u64))
113 : [x] "w" (@bitCast(Vector(2, u64), @as(u128, x))),
114 [y] "w" (@bitCast(Vector(2, u64), @as(u128, y)))
115 );
116 return product[0];
117 }
118
108119 fn clmul_soft(x: u64, y: u64) u64 {
109120 const x0 = x & 0x1111111111111111;
110121 const x1 = x & 0x2222222222222222;
......@@ -127,7 +138,14 @@ pub const Ghash = struct {
127138
128139 const has_pclmul = comptime std.Target.x86.featureSetHas(std.Target.current.cpu.features, .pclmul);
129140 const has_avx = comptime std.Target.x86.featureSetHas(std.Target.current.cpu.features, .avx);
130 const clmul = if (std.Target.current.cpu.arch == .x86_64 and has_pclmul and has_avx) clmul_pclmul else clmul_soft;
141 const has_armaes = comptime std.Target.aarch64.featureSetHas(std.Target.current.cpu.features, .aes);
142 const clmul = if (std.Target.current.cpu.arch == .x86_64 and has_pclmul and has_avx) impl: {
143 break :impl clmul_pclmul;
144 } else if (std.Target.current.cpu.arch == .aarch64 and has_armaes) impl: {
145 break :impl clmul_pmull;
146 } else impl: {
147 break :impl clmul_soft;
148 };
131149
132150 fn blocks(st: *Ghash, msg: []const u8) void {
133151 assert(msg.len % 16 == 0); // GHASH blocks() expects full blocks
lib/std/event.zig+2
......@@ -12,6 +12,7 @@ pub const Locked = @import("event/locked.zig").Locked;
1212pub const RwLock = @import("event/rwlock.zig").RwLock;
1313pub const RwLocked = @import("event/rwlocked.zig").RwLocked;
1414pub const Loop = @import("event/loop.zig").Loop;
15pub const WaitGroup = @import("event/WaitGroup.zig").WaitGroup;
1516
1617test "import event tests" {
1718 _ = @import("event/channel.zig");
......@@ -23,4 +24,5 @@ test "import event tests" {
2324 _ = @import("event/rwlock.zig");
2425 _ = @import("event/rwlocked.zig");
2526 _ = @import("event/loop.zig");
27 _ = @import("event/wait_group.zig");
2628}
lib/std/event/loop.zig+2
......@@ -660,9 +660,11 @@ pub const Loop = struct {
660660 const Wrapper = struct {
661661 const Args = @TypeOf(args);
662662 fn run(func_args: Args, loop: *Loop, allocator: *mem.Allocator) void {
663 loop.beginOneEvent();
663664 loop.yield();
664665 const result = @call(.{}, func, func_args);
665666 suspend {
667 loop.finishOneEvent();
666668 allocator.destroy(@frame());
667669 }
668670 }
lib/std/event/wait_group.zig created+120
......@@ -0,0 +1,120 @@
1// SPDX-License-Identifier: MIT
2// Copyright (c) 2015-2020 Zig Contributors
3// This file is part of [zig](https://ziglang.org/), which is MIT licensed.
4// The MIT license requires this copyright notice to be included in all copies
5// and substantial portions of the software.
6const std = @import("../std.zig");
7const builtin = @import("builtin");
8const Loop = std.event.Loop;
9
10/// A WaitGroup keeps track and waits for a group of async tasks to finish.
11/// Call `begin` when creating new tasks, and have tasks call `finish` when done.
12/// You can provide a count for both operations to perform them in bulk.
13/// Call `wait` to suspend until all tasks are completed.
14/// Multiple waiters are supported.
15///
16/// WaitGroup is an instance of WaitGroupGeneric, which takes in a bitsize
17/// for the internal counter. WaitGroup defaults to a `usize` counter.
18/// It's also possible to define a max value for the counter so that
19/// `begin` will return error.Overflow when the limit is reached, even
20/// if the integer type has not has not overflowed.
21/// By default `max_value` is set to std.math.maxInt(CounterType).
22pub const WaitGroup = WaitGroupGeneric(std.meta.bitCount(usize));
23
24pub fn WaitGroupGeneric(comptime counter_size: u16) type {
25 const CounterType = std.meta.Int(false, counter_size);
26
27 const global_event_loop = Loop.instance orelse
28 @compileError("std.event.WaitGroup currently only works with event-based I/O");
29
30 return struct {
31 counter: CounterType = 0,
32 max_counter: CounterType = std.math.maxInt(CounterType),
33 mutex: std.Mutex = .{},
34 waiters: ?*Waiter = null,
35 const Waiter = struct {
36 next: ?*Waiter,
37 tail: *Waiter,
38 node: Loop.NextTickNode,
39 };
40
41 const Self = @This();
42 pub fn begin(self: *Self, count: CounterType) error{Overflow}!void {
43 const held = self.mutex.acquire();
44 defer held.release();
45
46 const new_counter = try std.math.add(CounterType, self.counter, count);
47 if (new_counter > self.max_counter) return error.Overflow;
48 self.counter = new_counter;
49 }
50
51 pub fn finish(self: *Self, count: CounterType) void {
52 var waiters = blk: {
53 const held = self.mutex.acquire();
54 defer held.release();
55 self.counter = std.math.sub(CounterType, self.counter, count) catch unreachable;
56 if (self.counter == 0) {
57 const temp = self.waiters;
58 self.waiters = null;
59 break :blk temp;
60 }
61 break :blk null;
62 };
63
64 // We don't need to hold the lock to reschedule any potential waiter.
65 while (waiters) |w| {
66 const temp_w = w;
67 waiters = w.next;
68 global_event_loop.onNextTick(&temp_w.node);
69 }
70 }
71
72 pub fn wait(self: *Self) void {
73 const held = self.mutex.acquire();
74
75 if (self.counter == 0) {
76 held.release();
77 return;
78 }
79
80 var self_waiter: Waiter = undefined;
81 self_waiter.node.data = @frame();
82 if (self.waiters) |head| {
83 head.tail.next = &self_waiter;
84 head.tail = &self_waiter;
85 } else {
86 self.waiters = &self_waiter;
87 self_waiter.tail = &self_waiter;
88 self_waiter.next = null;
89 }
90 suspend {
91 held.release();
92 }
93 }
94 };
95}
96
97test "basic WaitGroup usage" {
98 if (!std.io.is_async) return error.SkipZigTest;
99
100 // TODO https://github.com/ziglang/zig/issues/1908
101 if (builtin.single_threaded) return error.SkipZigTest;
102
103 // TODO https://github.com/ziglang/zig/issues/3251
104 if (builtin.os.tag == .freebsd) return error.SkipZigTest;
105
106 var initial_wg = WaitGroup{};
107 var final_wg = WaitGroup{};
108
109 try initial_wg.begin(1);
110 try final_wg.begin(1);
111 var task_frame = async task(&initial_wg, &final_wg);
112 initial_wg.finish(1);
113 final_wg.wait();
114 await task_frame;
115}
116
117fn task(wg_i: *WaitGroup, wg_f: *WaitGroup) void {
118 wg_i.wait();
119 wg_f.finish(1);
120}
lib/std/fmt.zig+5-2
......@@ -1181,13 +1181,16 @@ fn bufPrintIntToSlice(buf: []u8, value: anytype, base: u8, uppercase: bool, opti
11811181 return buf[0..formatIntBuf(buf, value, base, uppercase, options)];
11821182}
11831183
1184pub fn comptimePrint(comptime fmt: []const u8, args: anytype) *const [count(fmt, args)]u8 {
1185 comptime var buf: [count(fmt, args)]u8 = undefined;
1184pub fn comptimePrint(comptime fmt: []const u8, args: anytype) *const [count(fmt, args):0]u8 {
1185 comptime var buf: [count(fmt, args):0]u8 = undefined;
11861186 _ = bufPrint(&buf, fmt, args) catch unreachable;
1187 buf[buf.len] = 0;
11871188 return &buf;
11881189}
11891190
11901191test "comptimePrint" {
1192 @setEvalBranchQuota(2000);
1193 std.testing.expectEqual(*const [3:0]u8, @TypeOf(comptime comptimePrint("{}", .{100})));
11911194 std.testing.expectEqualSlices(u8, "100", comptime comptimePrint("{}", .{100}));
11921195}
11931196
lib/std/math.zig+12-1
......@@ -110,7 +110,12 @@ pub fn approxEq(comptime T: type, x: T, y: T, epsilon: T) bool {
110110}
111111
112112pub fn doNotOptimizeAway(value: anytype) void {
113 mem.doNotOptimizeAway(value);
113 // TODO: use @declareSideEffect() when it is available.
114 // https://github.com/ziglang/zig/issues/6168
115 const T = @TypeOf(value);
116 var x: T = undefined;
117 const p = @ptrCast(*volatile T, &x);
118 p.* = x;
114119}
115120
116121pub fn raiseInvalid() void {
......@@ -1131,3 +1136,9 @@ test "compare between signed and unsigned" {
11311136 testing.expect(!compare(@as(u8, 255), .eq, @as(i8, -1)));
11321137 testing.expect(compare(@as(u8, 1), .eq, @as(u8, 1)));
11331138}
1139
1140test "math.comptime" {
1141 comptime const v = sin(@as(f32, 1)) + ln(@as(f32, 5));
1142 testing.expect(v == sin(@as(f32, 1)) + ln(@as(f32, 5)));
1143}
1144
lib/std/os/linux/bpf/kern.zig+25-25
......@@ -12,28 +12,28 @@ const in_bpf_program = switch (std.builtin.arch) {
1212
1313pub const helpers = if (in_bpf_program) @import("helpers.zig") else struct {};
1414
15pub const BpfSock = @Type(.Opaque);
16pub const BpfSockAddr = @Type(.Opaque);
17pub const FibLookup = @Type(.Opaque);
18pub const MapDef = @Type(.Opaque);
19pub const PerfEventData = @Type(.Opaque);
20pub const PerfEventValue = @Type(.Opaque);
21pub const PidNsInfo = @Type(.Opaque);
22pub const SeqFile = @Type(.Opaque);
23pub const SkBuff = @Type(.Opaque);
24pub const SkMsgMd = @Type(.Opaque);
25pub const SkReusePortMd = @Type(.Opaque);
26pub const Sock = @Type(.Opaque);
27pub const SockAddr = @Type(.Opaque);
28pub const SockOps = @Type(.Opaque);
29pub const SockTuple = @Type(.Opaque);
30pub const SpinLock = @Type(.Opaque);
31pub const SysCtl = @Type(.Opaque);
32pub const Tcp6Sock = @Type(.Opaque);
33pub const TcpRequestSock = @Type(.Opaque);
34pub const TcpSock = @Type(.Opaque);
35pub const TcpTimewaitSock = @Type(.Opaque);
36pub const TunnelKey = @Type(.Opaque);
37pub const Udp6Sock = @Type(.Opaque);
38pub const XdpMd = @Type(.Opaque);
39pub const XfrmState = @Type(.Opaque);
15pub const BpfSock = opaque {};
16pub const BpfSockAddr = opaque {};
17pub const FibLookup = opaque {};
18pub const MapDef = opaque {};
19pub const PerfEventData = opaque {};
20pub const PerfEventValue = opaque {};
21pub const PidNsInfo = opaque {};
22pub const SeqFile = opaque {};
23pub const SkBuff = opaque {};
24pub const SkMsgMd = opaque {};
25pub const SkReusePortMd = opaque {};
26pub const Sock = opaque {};
27pub const SockAddr = opaque {};
28pub const SockOps = opaque {};
29pub const SockTuple = opaque {};
30pub const SpinLock = opaque {};
31pub const SysCtl = opaque {};
32pub const Tcp6Sock = opaque {};
33pub const TcpRequestSock = opaque {};
34pub const TcpSock = opaque {};
35pub const TcpTimewaitSock = opaque {};
36pub const TunnelKey = opaque {};
37pub const Udp6Sock = opaque {};
38pub const XdpMd = opaque {};
39pub const XfrmState = opaque {};
lib/std/os/uefi.zig+3-3
......@@ -17,7 +17,7 @@ pub var handle: Handle = undefined;
1717pub var system_table: *tables.SystemTable = undefined;
1818
1919/// A handle to an event structure.
20pub const Event = *@Type(.Opaque);
20pub const Event = *opaque {};
2121
2222/// GUIDs must be align(8)
2323pub const Guid = extern struct {
......@@ -51,7 +51,7 @@ pub const Guid = extern struct {
5151};
5252
5353/// An EFI Handle represents a collection of related interfaces.
54pub const Handle = *@Type(.Opaque);
54pub const Handle = *opaque {};
5555
5656/// This structure represents time information.
5757pub const Time = extern struct {
......@@ -108,4 +108,4 @@ pub const TimeCapabilities = extern struct {
108108};
109109
110110/// File Handle as specified in the EFI Shell Spec
111pub const FileHandle = *@Type(.Opaque);
111pub const FileHandle = *opaque {};
lib/std/os/uefi/protocols/hii.zig+1-1
......@@ -6,7 +6,7 @@
66const uefi = @import("std").os.uefi;
77const Guid = uefi.Guid;
88
9pub const HIIHandle = *@Type(.Opaque);
9pub const HIIHandle = *opaque {};
1010
1111/// The header found at the start of each package.
1212pub const HIIPackageHeader = packed struct {
lib/std/os/windows/bits.zig+15-15
......@@ -32,16 +32,16 @@ pub const UCHAR = u8;
3232pub const FLOAT = f32;
3333pub const HANDLE = *c_void;
3434pub const HCRYPTPROV = ULONG_PTR;
35pub const HBRUSH = *@Type(.Opaque);
36pub const HCURSOR = *@Type(.Opaque);
37pub const HICON = *@Type(.Opaque);
38pub const HINSTANCE = *@Type(.Opaque);
39pub const HMENU = *@Type(.Opaque);
40pub const HMODULE = *@Type(.Opaque);
41pub const HWND = *@Type(.Opaque);
42pub const HDC = *@Type(.Opaque);
43pub const HGLRC = *@Type(.Opaque);
44pub const FARPROC = *@Type(.Opaque);
35pub const HBRUSH = *opaque {};
36pub const HCURSOR = *opaque {};
37pub const HICON = *opaque {};
38pub const HINSTANCE = *opaque {};
39pub const HMENU = *opaque {};
40pub const HMODULE = *opaque {};
41pub const HWND = *opaque {};
42pub const HDC = *opaque {};
43pub const HGLRC = *opaque {};
44pub const FARPROC = *opaque {};
4545pub const INT = c_int;
4646pub const LPBYTE = *BYTE;
4747pub const LPCH = *CHAR;
......@@ -81,7 +81,7 @@ pub const WPARAM = usize;
8181pub const LPARAM = ?*c_void;
8282pub const LRESULT = ?*c_void;
8383
84pub const va_list = *@Type(.Opaque);
84pub const va_list = *opaque {};
8585
8686pub const TRUE = 1;
8787pub const FALSE = 0;
......@@ -1175,10 +1175,10 @@ pub const UNICODE_STRING = extern struct {
11751175 Buffer: [*]WCHAR,
11761176};
11771177
1178const ACTIVATION_CONTEXT_DATA = @Type(.Opaque);
1179const ASSEMBLY_STORAGE_MAP = @Type(.Opaque);
1180const FLS_CALLBACK_INFO = @Type(.Opaque);
1181const RTL_BITMAP = @Type(.Opaque);
1178const ACTIVATION_CONTEXT_DATA = opaque {};
1179const ASSEMBLY_STORAGE_MAP = opaque {};
1180const FLS_CALLBACK_INFO = opaque {};
1181const RTL_BITMAP = opaque {};
11821182pub const PRTL_BITMAP = *RTL_BITMAP;
11831183const KAFFINITY = usize;
11841184
lib/std/os/windows/ws2_32.zig+1-1
......@@ -5,7 +5,7 @@
55// and substantial portions of the software.
66usingnamespace @import("bits.zig");
77
8pub const SOCKET = *@Type(.Opaque);
8pub const SOCKET = *opaque {};
99pub const INVALID_SOCKET = @intToPtr(SOCKET, ~@as(usize, 0));
1010pub const SOCKET_ERROR = -1;
1111
lib/std/zig/ast.zig+1-1
......@@ -288,7 +288,7 @@ pub const Error = union(enum) {
288288 pub const ExpectedVarDecl = SingleTokenError("Expected variable declaration, found '{}'");
289289 pub const ExpectedFn = SingleTokenError("Expected function, found '{}'");
290290 pub const ExpectedReturnType = SingleTokenError("Expected 'var' or return type expression, found '{}'");
291 pub const ExpectedAggregateKw = SingleTokenError("Expected '" ++ Token.Id.Keyword_struct.symbol() ++ "', '" ++ Token.Id.Keyword_union.symbol() ++ "', or '" ++ Token.Id.Keyword_enum.symbol() ++ "', found '{}'");
291 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 '{}'");
292292 pub const ExpectedEqOrSemi = SingleTokenError("Expected '=' or ';', found '{}'");
293293 pub const ExpectedSemiOrLBrace = SingleTokenError("Expected ';' or '{{', found '{}'");
294294 pub const ExpectedSemiOrElse = SingleTokenError("Expected ';' or 'else', found '{}'");
lib/std/zig/parse.zig+2-1
......@@ -2896,11 +2896,12 @@ const Parser = struct {
28962896 /// <- KEYWORD_struct
28972897 /// / KEYWORD_enum (LPAREN Expr RPAREN)?
28982898 /// / KEYWORD_union (LPAREN (KEYWORD_enum (LPAREN Expr RPAREN)? / Expr) RPAREN)?
2899 /// / KEYWORD_opaque
28992900 fn parseContainerDeclType(p: *Parser) !?ContainerDeclType {
29002901 const kind_token = p.nextToken();
29012902
29022903 const init_arg_expr = switch (p.token_ids[kind_token]) {
2903 .Keyword_struct => Node.ContainerDecl.InitArg{ .None = {} },
2904 .Keyword_struct, .Keyword_opaque => Node.ContainerDecl.InitArg{ .None = {} },
29042905 .Keyword_enum => blk: {
29052906 if (p.eatToken(.LParen) != null) {
29062907 const expr = try p.expectNode(parseExpr, .{
lib/std/zig/render.zig+13-1
......@@ -1492,7 +1492,19 @@ fn renderExpression(
14921492
14931493 // TODO remove after 0.7.0 release
14941494 if (mem.eql(u8, tree.tokenSlice(builtin_call.builtin_token), "@OpaqueType"))
1495 return ais.writer().writeAll("@Type(.Opaque)");
1495 return ais.writer().writeAll("opaque {}");
1496
1497 // TODO remove after 0.7.0 release
1498 {
1499 const params = builtin_call.paramsConst();
1500 if (mem.eql(u8, tree.tokenSlice(builtin_call.builtin_token), "@Type") and
1501 params.len == 1)
1502 {
1503 if (params[0].castTag(.EnumLiteral)) |enum_literal|
1504 if (mem.eql(u8, tree.tokenSlice(enum_literal.name), "Opaque"))
1505 return ais.writer().writeAll("opaque {}");
1506 }
1507 }
14961508
14971509 try renderToken(tree, ais, builtin_call.builtin_token, Space.None); // @name
14981510
lib/std/zig/tokenizer.zig+3
......@@ -47,6 +47,7 @@ pub const Token = struct {
4747 .{ "noinline", .Keyword_noinline },
4848 .{ "nosuspend", .Keyword_nosuspend },
4949 .{ "null", .Keyword_null },
50 .{ "opaque", .Keyword_opaque },
5051 .{ "or", .Keyword_or },
5152 .{ "orelse", .Keyword_orelse },
5253 .{ "packed", .Keyword_packed },
......@@ -173,6 +174,7 @@ pub const Token = struct {
173174 Keyword_noinline,
174175 Keyword_nosuspend,
175176 Keyword_null,
177 Keyword_opaque,
176178 Keyword_or,
177179 Keyword_orelse,
178180 Keyword_packed,
......@@ -296,6 +298,7 @@ pub const Token = struct {
296298 .Keyword_noinline => "noinline",
297299 .Keyword_nosuspend => "nosuspend",
298300 .Keyword_null => "null",
301 .Keyword_opaque => "opaque",
299302 .Keyword_or => "or",
300303 .Keyword_orelse => "orelse",
301304 .Keyword_packed => "packed",
src/clang.zig+929-521
......@@ -1,91 +1,901 @@
1const builtin = @import("builtin");
2
3pub const struct_ZigClangConditionalOperator = @Type(.Opaque);
4pub const struct_ZigClangBinaryConditionalOperator = @Type(.Opaque);
5pub const struct_ZigClangAbstractConditionalOperator = @Type(.Opaque);
6pub const struct_ZigClangAPInt = @Type(.Opaque);
7pub const struct_ZigClangAPSInt = @Type(.Opaque);
8pub const struct_ZigClangAPFloat = @Type(.Opaque);
9pub const struct_ZigClangASTContext = @Type(.Opaque);
10pub const struct_ZigClangASTUnit = @Type(.Opaque);
11pub const struct_ZigClangArraySubscriptExpr = @Type(.Opaque);
12pub const struct_ZigClangArrayType = @Type(.Opaque);
13pub const struct_ZigClangAttributedType = @Type(.Opaque);
14pub const struct_ZigClangBinaryOperator = @Type(.Opaque);
15pub const struct_ZigClangBreakStmt = @Type(.Opaque);
16pub const struct_ZigClangBuiltinType = @Type(.Opaque);
17pub const struct_ZigClangCStyleCastExpr = @Type(.Opaque);
18pub const struct_ZigClangCallExpr = @Type(.Opaque);
19pub const struct_ZigClangCaseStmt = @Type(.Opaque);
20pub const struct_ZigClangCompoundAssignOperator = @Type(.Opaque);
21pub const struct_ZigClangCompoundStmt = @Type(.Opaque);
22pub const struct_ZigClangConstantArrayType = @Type(.Opaque);
23pub const struct_ZigClangContinueStmt = @Type(.Opaque);
24pub const struct_ZigClangDecayedType = @Type(.Opaque);
25pub const ZigClangDecl = @Type(.Opaque);
26pub const struct_ZigClangDeclRefExpr = @Type(.Opaque);
27pub const struct_ZigClangDeclStmt = @Type(.Opaque);
28pub const struct_ZigClangDefaultStmt = @Type(.Opaque);
29pub const struct_ZigClangDiagnosticOptions = @Type(.Opaque);
30pub const struct_ZigClangDiagnosticsEngine = @Type(.Opaque);
31pub const struct_ZigClangDoStmt = @Type(.Opaque);
32pub const struct_ZigClangElaboratedType = @Type(.Opaque);
33pub const struct_ZigClangEnumConstantDecl = @Type(.Opaque);
34pub const struct_ZigClangEnumDecl = @Type(.Opaque);
35pub const struct_ZigClangEnumType = @Type(.Opaque);
36pub const struct_ZigClangExpr = @Type(.Opaque);
37pub const struct_ZigClangFieldDecl = @Type(.Opaque);
38pub const struct_ZigClangFileID = @Type(.Opaque);
39pub const struct_ZigClangForStmt = @Type(.Opaque);
40pub const struct_ZigClangFullSourceLoc = @Type(.Opaque);
41pub const struct_ZigClangFunctionDecl = @Type(.Opaque);
42pub const struct_ZigClangFunctionProtoType = @Type(.Opaque);
43pub const struct_ZigClangIfStmt = @Type(.Opaque);
44pub const struct_ZigClangImplicitCastExpr = @Type(.Opaque);
45pub const struct_ZigClangIncompleteArrayType = @Type(.Opaque);
46pub const struct_ZigClangIntegerLiteral = @Type(.Opaque);
47pub const struct_ZigClangMacroDefinitionRecord = @Type(.Opaque);
48pub const struct_ZigClangMacroExpansion = @Type(.Opaque);
49pub const struct_ZigClangMacroQualifiedType = @Type(.Opaque);
50pub const struct_ZigClangMemberExpr = @Type(.Opaque);
51pub const struct_ZigClangNamedDecl = @Type(.Opaque);
52pub const struct_ZigClangNone = @Type(.Opaque);
53pub const struct_ZigClangOpaqueValueExpr = @Type(.Opaque);
54pub const struct_ZigClangPCHContainerOperations = @Type(.Opaque);
55pub const struct_ZigClangParenExpr = @Type(.Opaque);
56pub const struct_ZigClangParenType = @Type(.Opaque);
57pub const struct_ZigClangParmVarDecl = @Type(.Opaque);
58pub const struct_ZigClangPointerType = @Type(.Opaque);
59pub const struct_ZigClangPreprocessedEntity = @Type(.Opaque);
60pub const struct_ZigClangRecordDecl = @Type(.Opaque);
61pub const struct_ZigClangRecordType = @Type(.Opaque);
62pub const struct_ZigClangReturnStmt = @Type(.Opaque);
63pub const struct_ZigClangSkipFunctionBodiesScope = @Type(.Opaque);
64pub const struct_ZigClangSourceManager = @Type(.Opaque);
65pub const struct_ZigClangSourceRange = @Type(.Opaque);
66pub const ZigClangStmt = @Type(.Opaque);
67pub const struct_ZigClangStringLiteral = @Type(.Opaque);
68pub const struct_ZigClangStringRef = @Type(.Opaque);
69pub const struct_ZigClangSwitchStmt = @Type(.Opaque);
70pub const struct_ZigClangTagDecl = @Type(.Opaque);
71pub const struct_ZigClangType = @Type(.Opaque);
72pub const struct_ZigClangTypedefNameDecl = @Type(.Opaque);
73pub const struct_ZigClangTypedefType = @Type(.Opaque);
74pub const struct_ZigClangUnaryExprOrTypeTraitExpr = @Type(.Opaque);
75pub const struct_ZigClangUnaryOperator = @Type(.Opaque);
76pub const struct_ZigClangValueDecl = @Type(.Opaque);
77pub const struct_ZigClangVarDecl = @Type(.Opaque);
78pub const struct_ZigClangWhileStmt = @Type(.Opaque);
79pub const struct_ZigClangFunctionType = @Type(.Opaque);
80pub const struct_ZigClangPredefinedExpr = @Type(.Opaque);
81pub const struct_ZigClangInitListExpr = @Type(.Opaque);
82pub const ZigClangPreprocessingRecord = @Type(.Opaque);
83pub const ZigClangFloatingLiteral = @Type(.Opaque);
84pub const ZigClangConstantExpr = @Type(.Opaque);
85pub const ZigClangCharacterLiteral = @Type(.Opaque);
86pub const ZigClangStmtExpr = @Type(.Opaque);
87
88pub const ZigClangBO = extern enum {
1pub const builtin = @import("builtin");
2
3pub const SourceLocation = extern struct {
4 ID: c_uint,
5
6 pub const eq = ZigClangSourceLocation_eq;
7 extern fn ZigClangSourceLocation_eq(a: SourceLocation, b: SourceLocation) bool;
8};
9
10pub const QualType = extern struct {
11 ptr: ?*c_void,
12
13 pub const getCanonicalType = ZigClangQualType_getCanonicalType;
14 extern fn ZigClangQualType_getCanonicalType(QualType) QualType;
15
16 pub const getTypePtr = ZigClangQualType_getTypePtr;
17 extern fn ZigClangQualType_getTypePtr(QualType) *const Type;
18
19 pub const getTypeClass = ZigClangQualType_getTypeClass;
20 extern fn ZigClangQualType_getTypeClass(QualType) TypeClass;
21
22 pub const addConst = ZigClangQualType_addConst;
23 extern fn ZigClangQualType_addConst(*QualType) void;
24
25 pub const eq = ZigClangQualType_eq;
26 extern fn ZigClangQualType_eq(QualType, arg1: QualType) bool;
27
28 pub const isConstQualified = ZigClangQualType_isConstQualified;
29 extern fn ZigClangQualType_isConstQualified(QualType) bool;
30
31 pub const isVolatileQualified = ZigClangQualType_isVolatileQualified;
32 extern fn ZigClangQualType_isVolatileQualified(QualType) bool;
33
34 pub const isRestrictQualified = ZigClangQualType_isRestrictQualified;
35 extern fn ZigClangQualType_isRestrictQualified(QualType) bool;
36};
37
38pub const APValueLValueBase = extern struct {
39 Ptr: ?*c_void,
40 CallIndex: c_uint,
41 Version: c_uint,
42
43 pub const dyn_cast_Expr = ZigClangAPValueLValueBase_dyn_cast_Expr;
44 extern fn ZigClangAPValueLValueBase_dyn_cast_Expr(APValueLValueBase) ?*const Expr;
45};
46
47pub const APValueKind = extern enum {
48 None,
49 Indeterminate,
50 Int,
51 Float,
52 FixedPoint,
53 ComplexInt,
54 ComplexFloat,
55 LValue,
56 Vector,
57 Array,
58 Struct,
59 Union,
60 MemberPointer,
61 AddrLabelDiff,
62};
63
64pub const APValue = extern struct {
65 Kind: APValueKind,
66 Data: if (builtin.os.tag == .windows and builtin.abi == .msvc) [52]u8 else [68]u8,
67
68 pub const getKind = ZigClangAPValue_getKind;
69 extern fn ZigClangAPValue_getKind(*const APValue) APValueKind;
70
71 pub const getInt = ZigClangAPValue_getInt;
72 extern fn ZigClangAPValue_getInt(*const APValue) *const APSInt;
73
74 pub const getArrayInitializedElts = ZigClangAPValue_getArrayInitializedElts;
75 extern fn ZigClangAPValue_getArrayInitializedElts(*const APValue) c_uint;
76
77 pub const getArraySize = ZigClangAPValue_getArraySize;
78 extern fn ZigClangAPValue_getArraySize(*const APValue) c_uint;
79
80 pub const getLValueBase = ZigClangAPValue_getLValueBase;
81 extern fn ZigClangAPValue_getLValueBase(*const APValue) APValueLValueBase;
82};
83
84pub const ExprEvalResult = extern struct {
85 HasSideEffects: bool,
86 HasUndefinedBehavior: bool,
87 SmallVectorImpl: ?*c_void,
88 Val: APValue,
89};
90
91pub const AbstractConditionalOperator = opaque {
92 pub const getCond = ZigClangAbstractConditionalOperator_getCond;
93 extern fn ZigClangAbstractConditionalOperator_getCond(*const AbstractConditionalOperator) *const Expr;
94
95 pub const getTrueExpr = ZigClangAbstractConditionalOperator_getTrueExpr;
96 extern fn ZigClangAbstractConditionalOperator_getTrueExpr(*const AbstractConditionalOperator) *const Expr;
97
98 pub const getFalseExpr = ZigClangAbstractConditionalOperator_getFalseExpr;
99 extern fn ZigClangAbstractConditionalOperator_getFalseExpr(*const AbstractConditionalOperator) *const Expr;
100};
101
102pub const APFloat = opaque {
103 pub const toString = ZigClangAPFloat_toString;
104 extern fn ZigClangAPFloat_toString(*const APFloat, precision: c_uint, maxPadding: c_uint, truncateZero: bool) [*:0]const u8;
105};
106
107pub const APInt = opaque {
108 pub const getLimitedValue = ZigClangAPInt_getLimitedValue;
109 extern fn ZigClangAPInt_getLimitedValue(*const APInt, limit: u64) u64;
110};
111
112pub const APSInt = opaque {
113 pub const isSigned = ZigClangAPSInt_isSigned;
114 extern fn ZigClangAPSInt_isSigned(*const APSInt) bool;
115
116 pub const isNegative = ZigClangAPSInt_isNegative;
117 extern fn ZigClangAPSInt_isNegative(*const APSInt) bool;
118
119 pub const negate = ZigClangAPSInt_negate;
120 extern fn ZigClangAPSInt_negate(*const APSInt) *const APSInt;
121
122 pub const free = ZigClangAPSInt_free;
123 extern fn ZigClangAPSInt_free(*const APSInt) void;
124
125 pub const getRawData = ZigClangAPSInt_getRawData;
126 extern fn ZigClangAPSInt_getRawData(*const APSInt) [*:0]const u64;
127
128 pub const getNumWords = ZigClangAPSInt_getNumWords;
129 extern fn ZigClangAPSInt_getNumWords(*const APSInt) c_uint;
130};
131
132pub const ASTContext = opaque {
133 pub const getPointerType = ZigClangASTContext_getPointerType;
134 extern fn ZigClangASTContext_getPointerType(*const ASTContext, T: QualType) QualType;
135};
136
137pub const ASTUnit = opaque {
138 pub const delete = ZigClangASTUnit_delete;
139 extern fn ZigClangASTUnit_delete(*ASTUnit) void;
140
141 pub const getASTContext = ZigClangASTUnit_getASTContext;
142 extern fn ZigClangASTUnit_getASTContext(*ASTUnit) *ASTContext;
143
144 pub const getSourceManager = ZigClangASTUnit_getSourceManager;
145 extern fn ZigClangASTUnit_getSourceManager(*ASTUnit) *SourceManager;
146
147 pub const visitLocalTopLevelDecls = ZigClangASTUnit_visitLocalTopLevelDecls;
148 extern fn ZigClangASTUnit_visitLocalTopLevelDecls(*ASTUnit, context: ?*c_void, Fn: ?fn (?*c_void, *const Decl) callconv(.C) bool) bool;
149
150 pub const getLocalPreprocessingEntities_begin = ZigClangASTUnit_getLocalPreprocessingEntities_begin;
151 extern fn ZigClangASTUnit_getLocalPreprocessingEntities_begin(*ASTUnit) PreprocessingRecord.iterator;
152
153 pub const getLocalPreprocessingEntities_end = ZigClangASTUnit_getLocalPreprocessingEntities_end;
154 extern fn ZigClangASTUnit_getLocalPreprocessingEntities_end(*ASTUnit) PreprocessingRecord.iterator;
155};
156
157pub const ArraySubscriptExpr = opaque {
158 pub const getBase = ZigClangArraySubscriptExpr_getBase;
159 extern fn ZigClangArraySubscriptExpr_getBase(*const ArraySubscriptExpr) *const Expr;
160
161 pub const getIdx = ZigClangArraySubscriptExpr_getIdx;
162 extern fn ZigClangArraySubscriptExpr_getIdx(*const ArraySubscriptExpr) *const Expr;
163};
164
165pub const ArrayType = opaque {
166 pub const getElementType = ZigClangArrayType_getElementType;
167 extern fn ZigClangArrayType_getElementType(*const ArrayType) QualType;
168};
169
170pub const AttributedType = opaque {
171 pub const getEquivalentType = ZigClangAttributedType_getEquivalentType;
172 extern fn ZigClangAttributedType_getEquivalentType(*const AttributedType) QualType;
173};
174
175pub const BinaryOperator = opaque {
176 pub const getOpcode = ZigClangBinaryOperator_getOpcode;
177 extern fn ZigClangBinaryOperator_getOpcode(*const BinaryOperator) BO;
178
179 pub const getBeginLoc = ZigClangBinaryOperator_getBeginLoc;
180 extern fn ZigClangBinaryOperator_getBeginLoc(*const BinaryOperator) SourceLocation;
181
182 pub const getLHS = ZigClangBinaryOperator_getLHS;
183 extern fn ZigClangBinaryOperator_getLHS(*const BinaryOperator) *const Expr;
184
185 pub const getRHS = ZigClangBinaryOperator_getRHS;
186 extern fn ZigClangBinaryOperator_getRHS(*const BinaryOperator) *const Expr;
187
188 pub const getType = ZigClangBinaryOperator_getType;
189 extern fn ZigClangBinaryOperator_getType(*const BinaryOperator) QualType;
190};
191
192pub const BinaryConditionalOperator = opaque {};
193
194pub const BreakStmt = opaque {};
195
196pub const BuiltinType = opaque {
197 pub const getKind = ZigClangBuiltinType_getKind;
198 extern fn ZigClangBuiltinType_getKind(*const BuiltinType) BuiltinTypeKind;
199};
200
201pub const CStyleCastExpr = opaque {
202 pub const getBeginLoc = ZigClangCStyleCastExpr_getBeginLoc;
203 extern fn ZigClangCStyleCastExpr_getBeginLoc(*const CStyleCastExpr) SourceLocation;
204
205 pub const getSubExpr = ZigClangCStyleCastExpr_getSubExpr;
206 extern fn ZigClangCStyleCastExpr_getSubExpr(*const CStyleCastExpr) *const Expr;
207
208 pub const getType = ZigClangCStyleCastExpr_getType;
209 extern fn ZigClangCStyleCastExpr_getType(*const CStyleCastExpr) QualType;
210};
211
212pub const CallExpr = opaque {
213 pub const getCallee = ZigClangCallExpr_getCallee;
214 extern fn ZigClangCallExpr_getCallee(*const CallExpr) *const Expr;
215
216 pub const getNumArgs = ZigClangCallExpr_getNumArgs;
217 extern fn ZigClangCallExpr_getNumArgs(*const CallExpr) c_uint;
218
219 pub const getArgs = ZigClangCallExpr_getArgs;
220 extern fn ZigClangCallExpr_getArgs(*const CallExpr) [*]const *const Expr;
221};
222
223pub const CaseStmt = opaque {
224 pub const getLHS = ZigClangCaseStmt_getLHS;
225 extern fn ZigClangCaseStmt_getLHS(*const CaseStmt) *const Expr;
226
227 pub const getRHS = ZigClangCaseStmt_getRHS;
228 extern fn ZigClangCaseStmt_getRHS(*const CaseStmt) ?*const Expr;
229
230 pub const getBeginLoc = ZigClangCaseStmt_getBeginLoc;
231 extern fn ZigClangCaseStmt_getBeginLoc(*const CaseStmt) SourceLocation;
232
233 pub const getSubStmt = ZigClangCaseStmt_getSubStmt;
234 extern fn ZigClangCaseStmt_getSubStmt(*const CaseStmt) *const Stmt;
235};
236
237pub const CharacterLiteral = opaque {
238 pub const getBeginLoc = ZigClangCharacterLiteral_getBeginLoc;
239 extern fn ZigClangCharacterLiteral_getBeginLoc(*const CharacterLiteral) SourceLocation;
240
241 pub const getKind = ZigClangCharacterLiteral_getKind;
242 extern fn ZigClangCharacterLiteral_getKind(*const CharacterLiteral) CharacterLiteral_CharacterKind;
243
244 pub const getValue = ZigClangCharacterLiteral_getValue;
245 extern fn ZigClangCharacterLiteral_getValue(*const CharacterLiteral) c_uint;
246};
247
248pub const CompoundAssignOperator = opaque {
249 pub const getType = ZigClangCompoundAssignOperator_getType;
250 extern fn ZigClangCompoundAssignOperator_getType(*const CompoundAssignOperator) QualType;
251
252 pub const getComputationLHSType = ZigClangCompoundAssignOperator_getComputationLHSType;
253 extern fn ZigClangCompoundAssignOperator_getComputationLHSType(*const CompoundAssignOperator) QualType;
254
255 pub const getComputationResultType = ZigClangCompoundAssignOperator_getComputationResultType;
256 extern fn ZigClangCompoundAssignOperator_getComputationResultType(*const CompoundAssignOperator) QualType;
257
258 pub const getBeginLoc = ZigClangCompoundAssignOperator_getBeginLoc;
259 extern fn ZigClangCompoundAssignOperator_getBeginLoc(*const CompoundAssignOperator) SourceLocation;
260
261 pub const getOpcode = ZigClangCompoundAssignOperator_getOpcode;
262 extern fn ZigClangCompoundAssignOperator_getOpcode(*const CompoundAssignOperator) BO;
263
264 pub const getLHS = ZigClangCompoundAssignOperator_getLHS;
265 extern fn ZigClangCompoundAssignOperator_getLHS(*const CompoundAssignOperator) *const Expr;
266
267 pub const getRHS = ZigClangCompoundAssignOperator_getRHS;
268 extern fn ZigClangCompoundAssignOperator_getRHS(*const CompoundAssignOperator) *const Expr;
269};
270
271pub const CompoundStmt = opaque {
272 pub const body_begin = ZigClangCompoundStmt_body_begin;
273 extern fn ZigClangCompoundStmt_body_begin(*const CompoundStmt) const_body_iterator;
274
275 pub const body_end = ZigClangCompoundStmt_body_end;
276 extern fn ZigClangCompoundStmt_body_end(*const CompoundStmt) const_body_iterator;
277
278 pub const const_body_iterator = [*]const *Stmt;
279};
280
281pub const ConditionalOperator = opaque {};
282
283pub const ConstantArrayType = opaque {
284 pub const getElementType = ZigClangConstantArrayType_getElementType;
285 extern fn ZigClangConstantArrayType_getElementType(*const ConstantArrayType) QualType;
286
287 pub const getSize = ZigClangConstantArrayType_getSize;
288 extern fn ZigClangConstantArrayType_getSize(*const ConstantArrayType) *const APInt;
289};
290
291pub const ConstantExpr = opaque {};
292
293pub const ContinueStmt = opaque {};
294
295pub const DecayedType = opaque {
296 pub const getDecayedType = ZigClangDecayedType_getDecayedType;
297 extern fn ZigClangDecayedType_getDecayedType(*const DecayedType) QualType;
298};
299
300pub const Decl = opaque {
301 pub const getLocation = ZigClangDecl_getLocation;
302 extern fn ZigClangDecl_getLocation(*const Decl) SourceLocation;
303
304 pub const castToNamedDecl = ZigClangDecl_castToNamedDecl;
305 extern fn ZigClangDecl_castToNamedDecl(decl: *const Decl) ?*const NamedDecl;
306
307 pub const getKind = ZigClangDecl_getKind;
308 extern fn ZigClangDecl_getKind(decl: *const Decl) DeclKind;
309
310 pub const getDeclKindName = ZigClangDecl_getDeclKindName;
311 extern fn ZigClangDecl_getDeclKindName(decl: *const Decl) [*:0]const u8;
312};
313
314pub const DeclRefExpr = opaque {
315 pub const getDecl = ZigClangDeclRefExpr_getDecl;
316 extern fn ZigClangDeclRefExpr_getDecl(*const DeclRefExpr) *const ValueDecl;
317
318 pub const getFoundDecl = ZigClangDeclRefExpr_getFoundDecl;
319 extern fn ZigClangDeclRefExpr_getFoundDecl(*const DeclRefExpr) *const NamedDecl;
320};
321
322pub const DeclStmt = opaque {
323 pub const decl_begin = ZigClangDeclStmt_decl_begin;
324 extern fn ZigClangDeclStmt_decl_begin(*const DeclStmt) const_decl_iterator;
325
326 pub const decl_end = ZigClangDeclStmt_decl_end;
327 extern fn ZigClangDeclStmt_decl_end(*const DeclStmt) const_decl_iterator;
328
329 pub const const_decl_iterator = [*]const *Decl;
330};
331
332pub const DefaultStmt = opaque {
333 pub const getSubStmt = ZigClangDefaultStmt_getSubStmt;
334 extern fn ZigClangDefaultStmt_getSubStmt(*const DefaultStmt) *const Stmt;
335};
336
337pub const DiagnosticOptions = opaque {};
338
339pub const DiagnosticsEngine = opaque {};
340
341pub const DoStmt = opaque {
342 pub const getCond = ZigClangDoStmt_getCond;
343 extern fn ZigClangDoStmt_getCond(*const DoStmt) *const Expr;
344
345 pub const getBody = ZigClangDoStmt_getBody;
346 extern fn ZigClangDoStmt_getBody(*const DoStmt) *const Stmt;
347};
348
349pub const ElaboratedType = opaque {
350 pub const getNamedType = ZigClangElaboratedType_getNamedType;
351 extern fn ZigClangElaboratedType_getNamedType(*const ElaboratedType) QualType;
352};
353
354pub const EnumConstantDecl = opaque {
355 pub const getInitExpr = ZigClangEnumConstantDecl_getInitExpr;
356 extern fn ZigClangEnumConstantDecl_getInitExpr(*const EnumConstantDecl) ?*const Expr;
357
358 pub const getInitVal = ZigClangEnumConstantDecl_getInitVal;
359 extern fn ZigClangEnumConstantDecl_getInitVal(*const EnumConstantDecl) *const APSInt;
360};
361
362pub const EnumDecl = opaque {
363 pub const getCanonicalDecl = ZigClangEnumDecl_getCanonicalDecl;
364 extern fn ZigClangEnumDecl_getCanonicalDecl(*const EnumDecl) ?*const TagDecl;
365
366 pub const getIntegerType = ZigClangEnumDecl_getIntegerType;
367 extern fn ZigClangEnumDecl_getIntegerType(*const EnumDecl) QualType;
368
369 pub const getDefinition = ZigClangEnumDecl_getDefinition;
370 extern fn ZigClangEnumDecl_getDefinition(*const EnumDecl) ?*const EnumDecl;
371
372 pub const getLocation = ZigClangEnumDecl_getLocation;
373 extern fn ZigClangEnumDecl_getLocation(*const EnumDecl) SourceLocation;
374
375 pub const enumerator_begin = ZigClangEnumDecl_enumerator_begin;
376 extern fn ZigClangEnumDecl_enumerator_begin(*const EnumDecl) enumerator_iterator;
377
378 pub const enumerator_end = ZigClangEnumDecl_enumerator_end;
379 extern fn ZigClangEnumDecl_enumerator_end(*const EnumDecl) enumerator_iterator;
380
381 pub const enumerator_iterator = extern struct {
382 ptr: *c_void,
383
384 pub const next = ZigClangEnumDecl_enumerator_iterator_next;
385 extern fn ZigClangEnumDecl_enumerator_iterator_next(enumerator_iterator) enumerator_iterator;
386
387 pub const deref = ZigClangEnumDecl_enumerator_iterator_deref;
388 extern fn ZigClangEnumDecl_enumerator_iterator_deref(enumerator_iterator) *const EnumConstantDecl;
389
390 pub const neq = ZigClangEnumDecl_enumerator_iterator_neq;
391 extern fn ZigClangEnumDecl_enumerator_iterator_neq(enumerator_iterator, enumerator_iterator) bool;
392 };
393};
394
395pub const EnumType = opaque {
396 pub const getDecl = ZigClangEnumType_getDecl;
397 extern fn ZigClangEnumType_getDecl(*const EnumType) *const EnumDecl;
398};
399
400pub const Expr = opaque {
401 pub const getStmtClass = ZigClangExpr_getStmtClass;
402 extern fn ZigClangExpr_getStmtClass(*const Expr) StmtClass;
403
404 pub const getType = ZigClangExpr_getType;
405 extern fn ZigClangExpr_getType(*const Expr) QualType;
406
407 pub const getBeginLoc = ZigClangExpr_getBeginLoc;
408 extern fn ZigClangExpr_getBeginLoc(*const Expr) SourceLocation;
409
410 pub const EvaluateAsConstantExpr = ZigClangExpr_EvaluateAsConstantExpr;
411 extern fn ZigClangExpr_EvaluateAsConstantExpr(*const Expr, *ExprEvalResult, Expr_ConstExprUsage, *const ASTContext) bool;
412};
413
414pub const FieldDecl = opaque {
415 pub const getCanonicalDecl = ZigClangFieldDecl_getCanonicalDecl;
416 extern fn ZigClangFieldDecl_getCanonicalDecl(*const FieldDecl) ?*const FieldDecl;
417
418 pub const getAlignedAttribute = ZigClangFieldDecl_getAlignedAttribute;
419 extern fn ZigClangFieldDecl_getAlignedAttribute(*const FieldDecl, *const ASTContext) c_uint;
420
421 pub const isAnonymousStructOrUnion = ZigClangFieldDecl_isAnonymousStructOrUnion;
422 extern fn ZigClangFieldDecl_isAnonymousStructOrUnion(*const FieldDecl) bool;
423
424 pub const isBitField = ZigClangFieldDecl_isBitField;
425 extern fn ZigClangFieldDecl_isBitField(*const FieldDecl) bool;
426
427 pub const getType = ZigClangFieldDecl_getType;
428 extern fn ZigClangFieldDecl_getType(*const FieldDecl) QualType;
429
430 pub const getLocation = ZigClangFieldDecl_getLocation;
431 extern fn ZigClangFieldDecl_getLocation(*const FieldDecl) SourceLocation;
432};
433
434pub const FileID = opaque {};
435
436pub const FloatingLiteral = opaque {
437 pub const getValueAsApproximateDouble = ZigClangAPFloat_getValueAsApproximateDouble;
438 extern fn ZigClangAPFloat_getValueAsApproximateDouble(*const FloatingLiteral) f64;
439};
440
441pub const ForStmt = opaque {
442 pub const getInit = ZigClangForStmt_getInit;
443 extern fn ZigClangForStmt_getInit(*const ForStmt) ?*const Stmt;
444
445 pub const getCond = ZigClangForStmt_getCond;
446 extern fn ZigClangForStmt_getCond(*const ForStmt) ?*const Expr;
447
448 pub const getInc = ZigClangForStmt_getInc;
449 extern fn ZigClangForStmt_getInc(*const ForStmt) ?*const Expr;
450
451 pub const getBody = ZigClangForStmt_getBody;
452 extern fn ZigClangForStmt_getBody(*const ForStmt) *const Stmt;
453};
454
455pub const FullSourceLoc = opaque {};
456
457pub const FunctionDecl = opaque {
458 pub const getType = ZigClangFunctionDecl_getType;
459 extern fn ZigClangFunctionDecl_getType(*const FunctionDecl) QualType;
460
461 pub const getLocation = ZigClangFunctionDecl_getLocation;
462 extern fn ZigClangFunctionDecl_getLocation(*const FunctionDecl) SourceLocation;
463
464 pub const hasBody = ZigClangFunctionDecl_hasBody;
465 extern fn ZigClangFunctionDecl_hasBody(*const FunctionDecl) bool;
466
467 pub const getStorageClass = ZigClangFunctionDecl_getStorageClass;
468 extern fn ZigClangFunctionDecl_getStorageClass(*const FunctionDecl) StorageClass;
469
470 pub const getParamDecl = ZigClangFunctionDecl_getParamDecl;
471 extern fn ZigClangFunctionDecl_getParamDecl(*const FunctionDecl, i: c_uint) *const ParmVarDecl;
472
473 pub const getBody = ZigClangFunctionDecl_getBody;
474 extern fn ZigClangFunctionDecl_getBody(*const FunctionDecl) *const Stmt;
475
476 pub const doesDeclarationForceExternallyVisibleDefinition = ZigClangFunctionDecl_doesDeclarationForceExternallyVisibleDefinition;
477 extern fn ZigClangFunctionDecl_doesDeclarationForceExternallyVisibleDefinition(*const FunctionDecl) bool;
478
479 pub const isThisDeclarationADefinition = ZigClangFunctionDecl_isThisDeclarationADefinition;
480 extern fn ZigClangFunctionDecl_isThisDeclarationADefinition(*const FunctionDecl) bool;
481
482 pub const doesThisDeclarationHaveABody = ZigClangFunctionDecl_doesThisDeclarationHaveABody;
483 extern fn ZigClangFunctionDecl_doesThisDeclarationHaveABody(*const FunctionDecl) bool;
484
485 pub const isInlineSpecified = ZigClangFunctionDecl_isInlineSpecified;
486 extern fn ZigClangFunctionDecl_isInlineSpecified(*const FunctionDecl) bool;
487
488 pub const isDefined = ZigClangFunctionDecl_isDefined;
489 extern fn ZigClangFunctionDecl_isDefined(*const FunctionDecl) bool;
490
491 pub const getDefinition = ZigClangFunctionDecl_getDefinition;
492 extern fn ZigClangFunctionDecl_getDefinition(*const FunctionDecl) ?*const FunctionDecl;
493
494 pub const getSectionAttribute = ZigClangFunctionDecl_getSectionAttribute;
495 extern fn ZigClangFunctionDecl_getSectionAttribute(*const FunctionDecl, len: *usize) ?[*]const u8;
496
497 pub const getCanonicalDecl = ZigClangFunctionDecl_getCanonicalDecl;
498 extern fn ZigClangFunctionDecl_getCanonicalDecl(*const FunctionDecl) ?*const FunctionDecl;
499
500 pub const getAlignedAttribute = ZigClangFunctionDecl_getAlignedAttribute;
501 extern fn ZigClangFunctionDecl_getAlignedAttribute(*const FunctionDecl, *const ASTContext) c_uint;
502};
503
504pub const FunctionProtoType = opaque {
505 pub const isVariadic = ZigClangFunctionProtoType_isVariadic;
506 extern fn ZigClangFunctionProtoType_isVariadic(*const FunctionProtoType) bool;
507
508 pub const getNumParams = ZigClangFunctionProtoType_getNumParams;
509 extern fn ZigClangFunctionProtoType_getNumParams(*const FunctionProtoType) c_uint;
510
511 pub const getParamType = ZigClangFunctionProtoType_getParamType;
512 extern fn ZigClangFunctionProtoType_getParamType(*const FunctionProtoType, i: c_uint) QualType;
513
514 pub const getReturnType = ZigClangFunctionProtoType_getReturnType;
515 extern fn ZigClangFunctionProtoType_getReturnType(*const FunctionProtoType) QualType;
516};
517
518pub const FunctionType = opaque {
519 pub const getNoReturnAttr = ZigClangFunctionType_getNoReturnAttr;
520 extern fn ZigClangFunctionType_getNoReturnAttr(*const FunctionType) bool;
521
522 pub const getCallConv = ZigClangFunctionType_getCallConv;
523 extern fn ZigClangFunctionType_getCallConv(*const FunctionType) CallingConv;
524
525 pub const getReturnType = ZigClangFunctionType_getReturnType;
526 extern fn ZigClangFunctionType_getReturnType(*const FunctionType) QualType;
527};
528
529pub const IfStmt = opaque {
530 pub const getThen = ZigClangIfStmt_getThen;
531 extern fn ZigClangIfStmt_getThen(*const IfStmt) *const Stmt;
532
533 pub const getElse = ZigClangIfStmt_getElse;
534 extern fn ZigClangIfStmt_getElse(*const IfStmt) ?*const Stmt;
535
536 pub const getCond = ZigClangIfStmt_getCond;
537 extern fn ZigClangIfStmt_getCond(*const IfStmt) *const Stmt;
538};
539
540pub const ImplicitCastExpr = opaque {
541 pub const getBeginLoc = ZigClangImplicitCastExpr_getBeginLoc;
542 extern fn ZigClangImplicitCastExpr_getBeginLoc(*const ImplicitCastExpr) SourceLocation;
543
544 pub const getCastKind = ZigClangImplicitCastExpr_getCastKind;
545 extern fn ZigClangImplicitCastExpr_getCastKind(*const ImplicitCastExpr) CK;
546
547 pub const getSubExpr = ZigClangImplicitCastExpr_getSubExpr;
548 extern fn ZigClangImplicitCastExpr_getSubExpr(*const ImplicitCastExpr) *const Expr;
549};
550
551pub const IncompleteArrayType = opaque {
552 pub const getElementType = ZigClangIncompleteArrayType_getElementType;
553 extern fn ZigClangIncompleteArrayType_getElementType(*const IncompleteArrayType) QualType;
554};
555
556pub const IntegerLiteral = opaque {
557 pub const EvaluateAsInt = ZigClangIntegerLiteral_EvaluateAsInt;
558 extern fn ZigClangIntegerLiteral_EvaluateAsInt(*const IntegerLiteral, *ExprEvalResult, *const ASTContext) bool;
559
560 pub const getBeginLoc = ZigClangIntegerLiteral_getBeginLoc;
561 extern fn ZigClangIntegerLiteral_getBeginLoc(*const IntegerLiteral) SourceLocation;
562
563 pub const isZero = ZigClangIntegerLiteral_isZero;
564 extern fn ZigClangIntegerLiteral_isZero(*const IntegerLiteral, *bool, *const ASTContext) bool;
565};
566
567pub const MacroDefinitionRecord = opaque {
568 pub const getName_getNameStart = ZigClangMacroDefinitionRecord_getName_getNameStart;
569 extern fn ZigClangMacroDefinitionRecord_getName_getNameStart(*const MacroDefinitionRecord) [*:0]const u8;
570
571 pub const getSourceRange_getBegin = ZigClangMacroDefinitionRecord_getSourceRange_getBegin;
572 extern fn ZigClangMacroDefinitionRecord_getSourceRange_getBegin(*const MacroDefinitionRecord) SourceLocation;
573
574 pub const getSourceRange_getEnd = ZigClangMacroDefinitionRecord_getSourceRange_getEnd;
575 extern fn ZigClangMacroDefinitionRecord_getSourceRange_getEnd(*const MacroDefinitionRecord) SourceLocation;
576};
577
578pub const MacroQualifiedType = opaque {
579 pub const getModifiedType = ZigClangMacroQualifiedType_getModifiedType;
580 extern fn ZigClangMacroQualifiedType_getModifiedType(*const MacroQualifiedType) QualType;
581};
582
583pub const MemberExpr = opaque {
584 pub const getBase = ZigClangMemberExpr_getBase;
585 extern fn ZigClangMemberExpr_getBase(*const MemberExpr) *const Expr;
586
587 pub const isArrow = ZigClangMemberExpr_isArrow;
588 extern fn ZigClangMemberExpr_isArrow(*const MemberExpr) bool;
589
590 pub const getMemberDecl = ZigClangMemberExpr_getMemberDecl;
591 extern fn ZigClangMemberExpr_getMemberDecl(*const MemberExpr) *const ValueDecl;
592};
593
594pub const NamedDecl = opaque {
595 pub const getName_bytes_begin = ZigClangNamedDecl_getName_bytes_begin;
596 extern fn ZigClangNamedDecl_getName_bytes_begin(decl: *const NamedDecl) [*:0]const u8;
597};
598
599pub const None = opaque {};
600
601pub const OpaqueValueExpr = opaque {
602 pub const getSourceExpr = ZigClangOpaqueValueExpr_getSourceExpr;
603 extern fn ZigClangOpaqueValueExpr_getSourceExpr(*const OpaqueValueExpr) ?*const Expr;
604};
605
606pub const PCHContainerOperations = opaque {};
607
608pub const ParenExpr = opaque {
609 pub const getSubExpr = ZigClangParenExpr_getSubExpr;
610 extern fn ZigClangParenExpr_getSubExpr(*const ParenExpr) *const Expr;
611};
612
613pub const ParenType = opaque {
614 pub const getInnerType = ZigClangParenType_getInnerType;
615 extern fn ZigClangParenType_getInnerType(*const ParenType) QualType;
616};
617
618pub const ParmVarDecl = opaque {
619 pub const getOriginalType = ZigClangParmVarDecl_getOriginalType;
620 extern fn ZigClangParmVarDecl_getOriginalType(*const ParmVarDecl) QualType;
621};
622
623pub const PointerType = opaque {};
624
625pub const PredefinedExpr = opaque {
626 pub const getFunctionName = ZigClangPredefinedExpr_getFunctionName;
627 extern fn ZigClangPredefinedExpr_getFunctionName(*const PredefinedExpr) *const StringLiteral;
628};
629
630pub const PreprocessedEntity = opaque {
631 pub const getKind = ZigClangPreprocessedEntity_getKind;
632 extern fn ZigClangPreprocessedEntity_getKind(*const PreprocessedEntity) PreprocessedEntity_EntityKind;
633};
634
635pub const PreprocessingRecord = opaque {
636 pub const iterator = extern struct {
637 I: c_int,
638 Self: *PreprocessingRecord,
639
640 pub const deref = ZigClangPreprocessingRecord_iterator_deref;
641 extern fn ZigClangPreprocessingRecord_iterator_deref(iterator) *PreprocessedEntity;
642 };
643};
644
645pub const RecordDecl = opaque {
646 pub const getCanonicalDecl = ZigClangRecordDecl_getCanonicalDecl;
647 extern fn ZigClangRecordDecl_getCanonicalDecl(*const RecordDecl) ?*const TagDecl;
648
649 pub const isUnion = ZigClangRecordDecl_isUnion;
650 extern fn ZigClangRecordDecl_isUnion(*const RecordDecl) bool;
651
652 pub const isStruct = ZigClangRecordDecl_isStruct;
653 extern fn ZigClangRecordDecl_isStruct(*const RecordDecl) bool;
654
655 pub const isAnonymousStructOrUnion = ZigClangRecordDecl_isAnonymousStructOrUnion;
656 extern fn ZigClangRecordDecl_isAnonymousStructOrUnion(record_decl: ?*const RecordDecl) bool;
657
658 pub const getPackedAttribute = ZigClangRecordDecl_getPackedAttribute;
659 extern fn ZigClangRecordDecl_getPackedAttribute(*const RecordDecl) bool;
660
661 pub const getDefinition = ZigClangRecordDecl_getDefinition;
662 extern fn ZigClangRecordDecl_getDefinition(*const RecordDecl) ?*const RecordDecl;
663
664 pub const getLocation = ZigClangRecordDecl_getLocation;
665 extern fn ZigClangRecordDecl_getLocation(*const RecordDecl) SourceLocation;
666
667 pub const field_begin = ZigClangRecordDecl_field_begin;
668 extern fn ZigClangRecordDecl_field_begin(*const RecordDecl) field_iterator;
669
670 pub const field_end = ZigClangRecordDecl_field_end;
671 extern fn ZigClangRecordDecl_field_end(*const RecordDecl) field_iterator;
672
673 pub const field_iterator = extern struct {
674 ptr: *c_void,
675
676 pub const next = ZigClangRecordDecl_field_iterator_next;
677 extern fn ZigClangRecordDecl_field_iterator_next(field_iterator) field_iterator;
678
679 pub const deref = ZigClangRecordDecl_field_iterator_deref;
680 extern fn ZigClangRecordDecl_field_iterator_deref(field_iterator) *const FieldDecl;
681
682 pub const neq = ZigClangRecordDecl_field_iterator_neq;
683 extern fn ZigClangRecordDecl_field_iterator_neq(field_iterator, field_iterator) bool;
684 };
685};
686
687pub const RecordType = opaque {
688 pub const getDecl = ZigClangRecordType_getDecl;
689 extern fn ZigClangRecordType_getDecl(*const RecordType) *const RecordDecl;
690};
691
692pub const ReturnStmt = opaque {
693 pub const getRetValue = ZigClangReturnStmt_getRetValue;
694 extern fn ZigClangReturnStmt_getRetValue(*const ReturnStmt) ?*const Expr;
695};
696
697pub const SkipFunctionBodiesScope = opaque {};
698
699pub const SourceManager = opaque {
700 pub const getSpellingLoc = ZigClangSourceManager_getSpellingLoc;
701 extern fn ZigClangSourceManager_getSpellingLoc(*const SourceManager, Loc: SourceLocation) SourceLocation;
702
703 pub const getFilename = ZigClangSourceManager_getFilename;
704 extern fn ZigClangSourceManager_getFilename(*const SourceManager, SpellingLoc: SourceLocation) ?[*:0]const u8;
705
706 pub const getSpellingLineNumber = ZigClangSourceManager_getSpellingLineNumber;
707 extern fn ZigClangSourceManager_getSpellingLineNumber(*const SourceManager, Loc: SourceLocation) c_uint;
708
709 pub const getSpellingColumnNumber = ZigClangSourceManager_getSpellingColumnNumber;
710 extern fn ZigClangSourceManager_getSpellingColumnNumber(*const SourceManager, Loc: SourceLocation) c_uint;
711
712 pub const getCharacterData = ZigClangSourceManager_getCharacterData;
713 extern fn ZigClangSourceManager_getCharacterData(*const SourceManager, SL: SourceLocation) [*:0]const u8;
714};
715
716pub const SourceRange = opaque {};
717
718pub const Stmt = opaque {
719 pub const getBeginLoc = ZigClangStmt_getBeginLoc;
720 extern fn ZigClangStmt_getBeginLoc(*const Stmt) SourceLocation;
721
722 pub const getStmtClass = ZigClangStmt_getStmtClass;
723 extern fn ZigClangStmt_getStmtClass(*const Stmt) StmtClass;
724
725 pub const classof_Expr = ZigClangStmt_classof_Expr;
726 extern fn ZigClangStmt_classof_Expr(*const Stmt) bool;
727};
728
729pub const StmtExpr = opaque {
730 pub const getSubStmt = ZigClangStmtExpr_getSubStmt;
731 extern fn ZigClangStmtExpr_getSubStmt(*const StmtExpr) *const CompoundStmt;
732};
733
734pub const StringLiteral = opaque {
735 pub const getKind = ZigClangStringLiteral_getKind;
736 extern fn ZigClangStringLiteral_getKind(*const StringLiteral) StringLiteral_StringKind;
737
738 pub const getString_bytes_begin_size = ZigClangStringLiteral_getString_bytes_begin_size;
739 extern fn ZigClangStringLiteral_getString_bytes_begin_size(*const StringLiteral, *usize) [*]const u8;
740};
741
742pub const StringRef = opaque {};
743
744pub const SwitchStmt = opaque {
745 pub const getConditionVariableDeclStmt = ZigClangSwitchStmt_getConditionVariableDeclStmt;
746 extern fn ZigClangSwitchStmt_getConditionVariableDeclStmt(*const SwitchStmt) ?*const DeclStmt;
747
748 pub const getCond = ZigClangSwitchStmt_getCond;
749 extern fn ZigClangSwitchStmt_getCond(*const SwitchStmt) *const Expr;
750
751 pub const getBody = ZigClangSwitchStmt_getBody;
752 extern fn ZigClangSwitchStmt_getBody(*const SwitchStmt) *const Stmt;
753
754 pub const isAllEnumCasesCovered = ZigClangSwitchStmt_isAllEnumCasesCovered;
755 extern fn ZigClangSwitchStmt_isAllEnumCasesCovered(*const SwitchStmt) bool;
756};
757
758pub const TagDecl = opaque {
759 pub const isThisDeclarationADefinition = ZigClangTagDecl_isThisDeclarationADefinition;
760 extern fn ZigClangTagDecl_isThisDeclarationADefinition(*const TagDecl) bool;
761};
762
763pub const Type = opaque {
764 pub const getTypeClass = ZigClangType_getTypeClass;
765 extern fn ZigClangType_getTypeClass(*const Type) TypeClass;
766
767 pub const getPointeeType = ZigClangType_getPointeeType;
768 extern fn ZigClangType_getPointeeType(*const Type) QualType;
769
770 pub const isVoidType = ZigClangType_isVoidType;
771 extern fn ZigClangType_isVoidType(*const Type) bool;
772
773 pub const isConstantArrayType = ZigClangType_isConstantArrayType;
774 extern fn ZigClangType_isConstantArrayType(*const Type) bool;
775
776 pub const isRecordType = ZigClangType_isRecordType;
777 extern fn ZigClangType_isRecordType(*const Type) bool;
778
779 pub const isIncompleteOrZeroLengthArrayType = ZigClangType_isIncompleteOrZeroLengthArrayType;
780 extern fn ZigClangType_isIncompleteOrZeroLengthArrayType(*const Type, *const ASTContext) bool;
781
782 pub const isArrayType = ZigClangType_isArrayType;
783 extern fn ZigClangType_isArrayType(*const Type) bool;
784
785 pub const isBooleanType = ZigClangType_isBooleanType;
786 extern fn ZigClangType_isBooleanType(*const Type) bool;
787
788 pub const getTypeClassName = ZigClangType_getTypeClassName;
789 extern fn ZigClangType_getTypeClassName(*const Type) [*:0]const u8;
790
791 pub const getAsArrayTypeUnsafe = ZigClangType_getAsArrayTypeUnsafe;
792 extern fn ZigClangType_getAsArrayTypeUnsafe(*const Type) *const ArrayType;
793
794 pub const getAsRecordType = ZigClangType_getAsRecordType;
795 extern fn ZigClangType_getAsRecordType(*const Type) ?*const RecordType;
796
797 pub const getAsUnionType = ZigClangType_getAsUnionType;
798 extern fn ZigClangType_getAsUnionType(*const Type) ?*const RecordType;
799};
800
801pub const TypedefNameDecl = opaque {
802 pub const getUnderlyingType = ZigClangTypedefNameDecl_getUnderlyingType;
803 extern fn ZigClangTypedefNameDecl_getUnderlyingType(*const TypedefNameDecl) QualType;
804
805 pub const getCanonicalDecl = ZigClangTypedefNameDecl_getCanonicalDecl;
806 extern fn ZigClangTypedefNameDecl_getCanonicalDecl(*const TypedefNameDecl) ?*const TypedefNameDecl;
807
808 pub const getLocation = ZigClangTypedefNameDecl_getLocation;
809 extern fn ZigClangTypedefNameDecl_getLocation(*const TypedefNameDecl) SourceLocation;
810};
811
812pub const TypedefType = opaque {
813 pub const getDecl = ZigClangTypedefType_getDecl;
814 extern fn ZigClangTypedefType_getDecl(*const TypedefType) *const TypedefNameDecl;
815};
816
817pub const UnaryExprOrTypeTraitExpr = opaque {
818 pub const getTypeOfArgument = ZigClangUnaryExprOrTypeTraitExpr_getTypeOfArgument;
819 extern fn ZigClangUnaryExprOrTypeTraitExpr_getTypeOfArgument(*const UnaryExprOrTypeTraitExpr) QualType;
820
821 pub const getBeginLoc = ZigClangUnaryExprOrTypeTraitExpr_getBeginLoc;
822 extern fn ZigClangUnaryExprOrTypeTraitExpr_getBeginLoc(*const UnaryExprOrTypeTraitExpr) SourceLocation;
823
824 pub const getKind = ZigClangUnaryExprOrTypeTraitExpr_getKind;
825 extern fn ZigClangUnaryExprOrTypeTraitExpr_getKind(*const UnaryExprOrTypeTraitExpr) UnaryExprOrTypeTrait_Kind;
826};
827
828pub const UnaryOperator = opaque {
829 pub const getOpcode = ZigClangUnaryOperator_getOpcode;
830 extern fn ZigClangUnaryOperator_getOpcode(*const UnaryOperator) UO;
831
832 pub const getType = ZigClangUnaryOperator_getType;
833 extern fn ZigClangUnaryOperator_getType(*const UnaryOperator) QualType;
834
835 pub const getSubExpr = ZigClangUnaryOperator_getSubExpr;
836 extern fn ZigClangUnaryOperator_getSubExpr(*const UnaryOperator) *const Expr;
837
838 pub const getBeginLoc = ZigClangUnaryOperator_getBeginLoc;
839 extern fn ZigClangUnaryOperator_getBeginLoc(*const UnaryOperator) SourceLocation;
840};
841
842pub const ValueDecl = opaque {};
843
844pub const VarDecl = opaque {
845 pub const getLocation = ZigClangVarDecl_getLocation;
846 extern fn ZigClangVarDecl_getLocation(*const VarDecl) SourceLocation;
847
848 pub const hasInit = ZigClangVarDecl_hasInit;
849 extern fn ZigClangVarDecl_hasInit(*const VarDecl) bool;
850
851 pub const getStorageClass = ZigClangVarDecl_getStorageClass;
852 extern fn ZigClangVarDecl_getStorageClass(*const VarDecl) StorageClass;
853
854 pub const getType = ZigClangVarDecl_getType;
855 extern fn ZigClangVarDecl_getType(*const VarDecl) QualType;
856
857 pub const getInit = ZigClangVarDecl_getInit;
858 extern fn ZigClangVarDecl_getInit(*const VarDecl) ?*const Expr;
859
860 pub const getTLSKind = ZigClangVarDecl_getTLSKind;
861 extern fn ZigClangVarDecl_getTLSKind(*const VarDecl) VarDecl_TLSKind;
862
863 pub const getCanonicalDecl = ZigClangVarDecl_getCanonicalDecl;
864 extern fn ZigClangVarDecl_getCanonicalDecl(*const VarDecl) ?*const VarDecl;
865
866 pub const getSectionAttribute = ZigClangVarDecl_getSectionAttribute;
867 extern fn ZigClangVarDecl_getSectionAttribute(*const VarDecl, len: *usize) ?[*]const u8;
868
869 pub const getAlignedAttribute = ZigClangVarDecl_getAlignedAttribute;
870 extern fn ZigClangVarDecl_getAlignedAttribute(*const VarDecl, *const ASTContext) c_uint;
871
872 pub const getTypeSourceInfo_getType = ZigClangVarDecl_getTypeSourceInfo_getType;
873 extern fn ZigClangVarDecl_getTypeSourceInfo_getType(*const VarDecl) QualType;
874};
875
876pub const WhileStmt = opaque {
877 pub const getCond = ZigClangWhileStmt_getCond;
878 extern fn ZigClangWhileStmt_getCond(*const WhileStmt) *const Expr;
879
880 pub const getBody = ZigClangWhileStmt_getBody;
881 extern fn ZigClangWhileStmt_getBody(*const WhileStmt) *const Stmt;
882};
883
884pub const InitListExpr = opaque {
885 pub const getInit = ZigClangInitListExpr_getInit;
886 extern fn ZigClangInitListExpr_getInit(*const InitListExpr, i: c_uint) *const Expr;
887
888 pub const getArrayFiller = ZigClangInitListExpr_getArrayFiller;
889 extern fn ZigClangInitListExpr_getArrayFiller(*const InitListExpr) *const Expr;
890
891 pub const getNumInits = ZigClangInitListExpr_getNumInits;
892 extern fn ZigClangInitListExpr_getNumInits(*const InitListExpr) c_uint;
893
894 pub const getInitializedFieldInUnion = ZigClangInitListExpr_getInitializedFieldInUnion;
895 extern fn ZigClangInitListExpr_getInitializedFieldInUnion(*const InitListExpr) ?*FieldDecl;
896};
897
898pub const BO = extern enum {
89899 PtrMemD,
90900 PtrMemI,
91901 Mul,
......@@ -121,7 +931,7 @@ pub const ZigClangBO = extern enum {
121931 Comma,
122932};
123933
124pub const ZigClangUO = extern enum {
934pub const UO = extern enum {
125935 PostInc,
126936 PostDec,
127937 PreInc,
......@@ -138,7 +948,7 @@ pub const ZigClangUO = extern enum {
138948 Coawait,
139949};
140950
141pub const ZigClangTypeClass = extern enum {
951pub const TypeClass = extern enum {
142952 Adjusted,
143953 Decayed,
144954 ConstantArray,
......@@ -193,7 +1003,7 @@ pub const ZigClangTypeClass = extern enum {
1931003 ExtVector,
1941004};
1951005
196const ZigClangStmtClass = extern enum {
1006const StmtClass = extern enum {
1971007 NoStmtClass,
1981008 GCCAsmStmtClass,
1991009 MSAsmStmtClass,
......@@ -410,7 +1220,7 @@ const ZigClangStmtClass = extern enum {
4101220 WhileStmtClass,
4111221};
4121222
413pub const ZigClangCK = extern enum {
1223pub const CK = extern enum {
4141224 Dependent,
4151225 BitCast,
4161226 LValueBitCast,
......@@ -475,24 +1285,7 @@ pub const ZigClangCK = extern enum {
4751285 IntToOCLSampler,
4761286};
4771287
478pub const ZigClangAPValueKind = extern enum {
479 None,
480 Indeterminate,
481 Int,
482 Float,
483 FixedPoint,
484 ComplexInt,
485 ComplexFloat,
486 LValue,
487 Vector,
488 Array,
489 Struct,
490 Union,
491 MemberPointer,
492 AddrLabelDiff,
493};
494
495pub const ZigClangDeclKind = extern enum {
1288pub const DeclKind = extern enum {
4961289 AccessSpec,
4971290 Block,
4981291 Captured,
......@@ -575,7 +1368,7 @@ pub const ZigClangDeclKind = extern enum {
5751368 TranslationUnit,
5761369};
5771370
578pub const ZigClangBuiltinTypeKind = extern enum {
1371pub const BuiltinTypeKind = extern enum {
5791372 OCLImage1dRO,
5801373 OCLImage1dArrayRO,
5811374 OCLImage1dBufferRO,
......@@ -747,7 +1540,7 @@ pub const ZigClangBuiltinTypeKind = extern enum {
7471540 OMPIterator,
7481541};
7491542
750pub const ZigClangCallingConv = extern enum {
1543pub const CallingConv = extern enum {
7511544 C,
7521545 X86StdCall,
7531546 X86FastCall,
......@@ -768,7 +1561,7 @@ pub const ZigClangCallingConv = extern enum {
7681561 AArch64VectorCall,
7691562};
7701563
771pub const ZigClangStorageClass = extern enum {
1564pub const StorageClass = extern enum {
7721565 None,
7731566 Extern,
7741567 Static,
......@@ -777,7 +1570,7 @@ pub const ZigClangStorageClass = extern enum {
7771570 Register,
7781571};
7791572
780pub const ZigClangAPFloat_roundingMode = extern enum(i8) {
1573pub const APFloat_roundingMode = extern enum(i8) {
7811574 TowardZero = 0,
7821575 NearestTiesToEven = 1,
7831576 TowardPositive = 2,
......@@ -787,7 +1580,7 @@ pub const ZigClangAPFloat_roundingMode = extern enum(i8) {
7871580 Invalid = -1,
7881581};
7891582
790pub const ZigClangStringLiteral_StringKind = extern enum {
1583pub const StringLiteral_StringKind = extern enum {
7911584 Ascii,
7921585 Wide,
7931586 UTF8,
......@@ -795,7 +1588,7 @@ pub const ZigClangStringLiteral_StringKind = extern enum {
7951588 UTF32,
7961589};
7971590
798pub const ZigClangCharacterLiteral_CharacterKind = extern enum {
1591pub const CharacterLiteral_CharacterKind = extern enum {
7991592 Ascii,
8001593 Wide,
8011594 UTF8,
......@@ -803,32 +1596,35 @@ pub const ZigClangCharacterLiteral_CharacterKind = extern enum {
8031596 UTF32,
8041597};
8051598
806pub const ZigClangRecordDecl_field_iterator = extern struct {
807 opaque: *c_void,
808};
809
810pub const ZigClangEnumDecl_enumerator_iterator = extern struct {
811 opaque: *c_void,
1599pub const VarDecl_TLSKind = extern enum {
1600 None,
1601 Static,
1602 Dynamic,
8121603};
8131604
814pub const ZigClangPreprocessingRecord_iterator = extern struct {
815 I: c_int,
816 Self: *ZigClangPreprocessingRecord,
1605pub const ElaboratedTypeKeyword = extern enum {
1606 Struct,
1607 Interface,
1608 Union,
1609 Class,
1610 Enum,
1611 Typename,
1612 None,
8171613};
8181614
819pub const ZigClangPreprocessedEntity_EntityKind = extern enum {
1615pub const PreprocessedEntity_EntityKind = extern enum {
8201616 InvalidKind,
8211617 MacroExpansionKind,
8221618 MacroDefinitionKind,
8231619 InclusionDirectiveKind,
8241620};
8251621
826pub const ZigClangExpr_ConstExprUsage = extern enum {
1622pub const Expr_ConstExprUsage = extern enum {
8271623 EvaluateForCodeGen,
8281624 EvaluateForMangling,
8291625};
8301626
831pub const ZigClangUnaryExprOrTypeTrait_Kind = extern enum {
1627pub const UnaryExprOrTypeTrait_Kind = extern enum {
8321628 SizeOf,
8331629 AlignOf,
8341630 VecStep,
......@@ -836,211 +1632,6 @@ pub const ZigClangUnaryExprOrTypeTrait_Kind = extern enum {
8361632 PreferredAlignOf,
8371633};
8381634
839pub extern fn ZigClangSourceManager_getSpellingLoc(self: ?*const struct_ZigClangSourceManager, Loc: struct_ZigClangSourceLocation) struct_ZigClangSourceLocation;
840pub extern fn ZigClangSourceManager_getFilename(self: *const struct_ZigClangSourceManager, SpellingLoc: struct_ZigClangSourceLocation) ?[*:0]const u8;
841pub extern fn ZigClangSourceManager_getSpellingLineNumber(self: ?*const struct_ZigClangSourceManager, Loc: struct_ZigClangSourceLocation) c_uint;
842pub extern fn ZigClangSourceManager_getSpellingColumnNumber(self: ?*const struct_ZigClangSourceManager, Loc: struct_ZigClangSourceLocation) c_uint;
843pub extern fn ZigClangSourceManager_getCharacterData(self: ?*const struct_ZigClangSourceManager, SL: struct_ZigClangSourceLocation) [*:0]const u8;
844pub extern fn ZigClangASTContext_getPointerType(self: ?*const struct_ZigClangASTContext, T: struct_ZigClangQualType) struct_ZigClangQualType;
845pub extern fn ZigClangASTUnit_getASTContext(self: ?*struct_ZigClangASTUnit) ?*struct_ZigClangASTContext;
846pub extern fn ZigClangASTUnit_getSourceManager(self: *struct_ZigClangASTUnit) *struct_ZigClangSourceManager;
847pub extern fn ZigClangASTUnit_visitLocalTopLevelDecls(self: *struct_ZigClangASTUnit, context: ?*c_void, Fn: ?fn (?*c_void, *const ZigClangDecl) callconv(.C) bool) bool;
848pub extern fn ZigClangRecordType_getDecl(record_ty: ?*const struct_ZigClangRecordType) *const struct_ZigClangRecordDecl;
849pub extern fn ZigClangTagDecl_isThisDeclarationADefinition(self: *const ZigClangTagDecl) bool;
850pub extern fn ZigClangEnumType_getDecl(record_ty: ?*const struct_ZigClangEnumType) *const struct_ZigClangEnumDecl;
851pub extern fn ZigClangRecordDecl_getCanonicalDecl(record_decl: ?*const struct_ZigClangRecordDecl) ?*const struct_ZigClangTagDecl;
852pub extern fn ZigClangFieldDecl_getCanonicalDecl(field_decl: ?*const struct_ZigClangFieldDecl) ?*const struct_ZigClangFieldDecl;
853pub extern fn ZigClangFieldDecl_getAlignedAttribute(field_decl: ?*const struct_ZigClangFieldDecl, *const ZigClangASTContext) c_uint;
854pub extern fn ZigClangEnumDecl_getCanonicalDecl(self: ?*const struct_ZigClangEnumDecl) ?*const struct_ZigClangTagDecl;
855pub extern fn ZigClangTypedefNameDecl_getCanonicalDecl(self: ?*const struct_ZigClangTypedefNameDecl) ?*const struct_ZigClangTypedefNameDecl;
856pub extern fn ZigClangFunctionDecl_getCanonicalDecl(self: ?*const struct_ZigClangFunctionDecl) ?*const struct_ZigClangFunctionDecl;
857pub extern fn ZigClangParmVarDecl_getOriginalType(self: ?*const struct_ZigClangParmVarDecl) struct_ZigClangQualType;
858pub extern fn ZigClangVarDecl_getCanonicalDecl(self: ?*const struct_ZigClangVarDecl) ?*const struct_ZigClangVarDecl;
859pub extern fn ZigClangVarDecl_getSectionAttribute(self: *const ZigClangVarDecl, len: *usize) ?[*]const u8;
860pub extern fn ZigClangFunctionDecl_getAlignedAttribute(self: *const ZigClangFunctionDecl, *const ZigClangASTContext) c_uint;
861pub extern fn ZigClangVarDecl_getAlignedAttribute(self: *const ZigClangVarDecl, *const ZigClangASTContext) c_uint;
862pub extern fn ZigClangRecordDecl_getPackedAttribute(self: ?*const struct_ZigClangRecordDecl) bool;
863pub extern fn ZigClangRecordDecl_getDefinition(self: ?*const struct_ZigClangRecordDecl) ?*const struct_ZigClangRecordDecl;
864pub extern fn ZigClangEnumDecl_getDefinition(self: ?*const struct_ZigClangEnumDecl) ?*const struct_ZigClangEnumDecl;
865pub extern fn ZigClangRecordDecl_getLocation(self: ?*const struct_ZigClangRecordDecl) struct_ZigClangSourceLocation;
866pub extern fn ZigClangEnumDecl_getLocation(self: ?*const struct_ZigClangEnumDecl) struct_ZigClangSourceLocation;
867pub extern fn ZigClangTypedefNameDecl_getLocation(self: ?*const struct_ZigClangTypedefNameDecl) struct_ZigClangSourceLocation;
868pub extern fn ZigClangDecl_getLocation(self: *const ZigClangDecl) ZigClangSourceLocation;
869pub extern fn ZigClangRecordDecl_isUnion(record_decl: ?*const struct_ZigClangRecordDecl) bool;
870pub extern fn ZigClangRecordDecl_isStruct(record_decl: ?*const struct_ZigClangRecordDecl) bool;
871pub extern fn ZigClangRecordDecl_isAnonymousStructOrUnion(record_decl: ?*const struct_ZigClangRecordDecl) bool;
872pub extern fn ZigClangRecordDecl_field_begin(*const struct_ZigClangRecordDecl) ZigClangRecordDecl_field_iterator;
873pub extern fn ZigClangRecordDecl_field_end(*const struct_ZigClangRecordDecl) ZigClangRecordDecl_field_iterator;
874pub extern fn ZigClangRecordDecl_field_iterator_next(ZigClangRecordDecl_field_iterator) ZigClangRecordDecl_field_iterator;
875pub extern fn ZigClangRecordDecl_field_iterator_deref(ZigClangRecordDecl_field_iterator) *const struct_ZigClangFieldDecl;
876pub extern fn ZigClangRecordDecl_field_iterator_neq(ZigClangRecordDecl_field_iterator, ZigClangRecordDecl_field_iterator) bool;
877pub extern fn ZigClangEnumDecl_getIntegerType(self: ?*const struct_ZigClangEnumDecl) struct_ZigClangQualType;
878pub extern fn ZigClangEnumDecl_enumerator_begin(*const ZigClangEnumDecl) ZigClangEnumDecl_enumerator_iterator;
879pub extern fn ZigClangEnumDecl_enumerator_end(*const ZigClangEnumDecl) ZigClangEnumDecl_enumerator_iterator;
880pub extern fn ZigClangEnumDecl_enumerator_iterator_next(ZigClangEnumDecl_enumerator_iterator) ZigClangEnumDecl_enumerator_iterator;
881pub extern fn ZigClangEnumDecl_enumerator_iterator_deref(ZigClangEnumDecl_enumerator_iterator) *const ZigClangEnumConstantDecl;
882pub extern fn ZigClangEnumDecl_enumerator_iterator_neq(ZigClangEnumDecl_enumerator_iterator, ZigClangEnumDecl_enumerator_iterator) bool;
883pub extern fn ZigClangDecl_castToNamedDecl(decl: *const ZigClangDecl) ?*const ZigClangNamedDecl;
884pub extern fn ZigClangNamedDecl_getName_bytes_begin(decl: ?*const struct_ZigClangNamedDecl) [*:0]const u8;
885pub extern fn ZigClangSourceLocation_eq(a: struct_ZigClangSourceLocation, b: struct_ZigClangSourceLocation) bool;
886pub extern fn ZigClangTypedefType_getDecl(self: ?*const struct_ZigClangTypedefType) *const struct_ZigClangTypedefNameDecl;
887pub extern fn ZigClangTypedefNameDecl_getUnderlyingType(self: ?*const struct_ZigClangTypedefNameDecl) struct_ZigClangQualType;
888pub extern fn ZigClangQualType_getCanonicalType(self: struct_ZigClangQualType) struct_ZigClangQualType;
889pub extern fn ZigClangQualType_getTypeClass(self: struct_ZigClangQualType) ZigClangTypeClass;
890pub extern fn ZigClangQualType_getTypePtr(self: struct_ZigClangQualType) *const struct_ZigClangType;
891pub extern fn ZigClangQualType_addConst(self: *struct_ZigClangQualType) void;
892pub extern fn ZigClangQualType_eq(self: struct_ZigClangQualType, arg1: struct_ZigClangQualType) bool;
893pub extern fn ZigClangQualType_isConstQualified(self: struct_ZigClangQualType) bool;
894pub extern fn ZigClangQualType_isVolatileQualified(self: struct_ZigClangQualType) bool;
895pub extern fn ZigClangQualType_isRestrictQualified(self: struct_ZigClangQualType) bool;
896pub extern fn ZigClangType_getTypeClass(self: ?*const struct_ZigClangType) ZigClangTypeClass;
897pub extern fn ZigClangType_getPointeeType(self: ?*const struct_ZigClangType) struct_ZigClangQualType;
898pub extern fn ZigClangType_isVoidType(self: ?*const struct_ZigClangType) bool;
899pub extern fn ZigClangType_isConstantArrayType(self: ?*const struct_ZigClangType) bool;
900pub extern fn ZigClangType_isRecordType(self: ?*const struct_ZigClangType) bool;
901pub extern fn ZigClangType_isIncompleteOrZeroLengthArrayType(self: ?*const struct_ZigClangType, *const ZigClangASTContext) bool;
902pub extern fn ZigClangType_isArrayType(self: ?*const struct_ZigClangType) bool;
903pub extern fn ZigClangType_isBooleanType(self: ?*const struct_ZigClangType) bool;
904pub extern fn ZigClangType_getTypeClassName(self: *const struct_ZigClangType) [*:0]const u8;
905pub extern fn ZigClangType_getAsArrayTypeUnsafe(self: *const ZigClangType) *const ZigClangArrayType;
906pub extern fn ZigClangType_getAsRecordType(self: *const ZigClangType) ?*const ZigClangRecordType;
907pub extern fn ZigClangType_getAsUnionType(self: *const ZigClangType) ?*const ZigClangRecordType;
908pub extern fn ZigClangStmt_getBeginLoc(self: *const ZigClangStmt) struct_ZigClangSourceLocation;
909pub extern fn ZigClangStmt_getStmtClass(self: ?*const ZigClangStmt) ZigClangStmtClass;
910pub extern fn ZigClangStmt_classof_Expr(self: ?*const ZigClangStmt) bool;
911pub extern fn ZigClangExpr_getStmtClass(self: *const struct_ZigClangExpr) ZigClangStmtClass;
912pub extern fn ZigClangExpr_getType(self: *const struct_ZigClangExpr) struct_ZigClangQualType;
913pub extern fn ZigClangExpr_getBeginLoc(self: *const struct_ZigClangExpr) struct_ZigClangSourceLocation;
914pub extern fn ZigClangInitListExpr_getInit(self: ?*const struct_ZigClangInitListExpr, i: c_uint) *const ZigClangExpr;
915pub extern fn ZigClangInitListExpr_getArrayFiller(self: ?*const struct_ZigClangInitListExpr) *const ZigClangExpr;
916pub extern fn ZigClangInitListExpr_getNumInits(self: ?*const struct_ZigClangInitListExpr) c_uint;
917pub extern fn ZigClangInitListExpr_getInitializedFieldInUnion(self: ?*const struct_ZigClangInitListExpr) ?*ZigClangFieldDecl;
918pub extern fn ZigClangAPValue_getKind(self: ?*const struct_ZigClangAPValue) ZigClangAPValueKind;
919pub extern fn ZigClangAPValue_getInt(self: ?*const struct_ZigClangAPValue) *const struct_ZigClangAPSInt;
920pub extern fn ZigClangAPValue_getArrayInitializedElts(self: ?*const struct_ZigClangAPValue) c_uint;
921pub extern fn ZigClangAPValue_getArraySize(self: ?*const struct_ZigClangAPValue) c_uint;
922pub extern fn ZigClangAPValue_getLValueBase(self: ?*const struct_ZigClangAPValue) struct_ZigClangAPValueLValueBase;
923pub extern fn ZigClangAPSInt_isSigned(self: *const struct_ZigClangAPSInt) bool;
924pub extern fn ZigClangAPSInt_isNegative(self: *const struct_ZigClangAPSInt) bool;
925pub extern fn ZigClangAPSInt_negate(self: *const struct_ZigClangAPSInt) *const struct_ZigClangAPSInt;
926pub extern fn ZigClangAPSInt_free(self: *const struct_ZigClangAPSInt) void;
927pub extern fn ZigClangAPSInt_getRawData(self: *const struct_ZigClangAPSInt) [*:0]const u64;
928pub extern fn ZigClangAPSInt_getNumWords(self: *const struct_ZigClangAPSInt) c_uint;
929
930pub extern fn ZigClangAPInt_getLimitedValue(self: *const struct_ZigClangAPInt, limit: u64) u64;
931pub extern fn ZigClangAPValueLValueBase_dyn_cast_Expr(self: struct_ZigClangAPValueLValueBase) ?*const struct_ZigClangExpr;
932pub extern fn ZigClangASTUnit_delete(self: ?*struct_ZigClangASTUnit) void;
933
934pub extern fn ZigClangFunctionDecl_getType(self: *const ZigClangFunctionDecl) struct_ZigClangQualType;
935pub extern fn ZigClangFunctionDecl_getLocation(self: *const ZigClangFunctionDecl) struct_ZigClangSourceLocation;
936pub extern fn ZigClangFunctionDecl_hasBody(self: *const ZigClangFunctionDecl) bool;
937pub extern fn ZigClangFunctionDecl_getStorageClass(self: *const ZigClangFunctionDecl) ZigClangStorageClass;
938pub extern fn ZigClangFunctionDecl_getParamDecl(self: *const ZigClangFunctionDecl, i: c_uint) *const struct_ZigClangParmVarDecl;
939pub extern fn ZigClangFunctionDecl_getBody(self: *const ZigClangFunctionDecl) *const ZigClangStmt;
940pub extern fn ZigClangFunctionDecl_doesDeclarationForceExternallyVisibleDefinition(self: *const ZigClangFunctionDecl) bool;
941pub extern fn ZigClangFunctionDecl_isThisDeclarationADefinition(self: *const ZigClangFunctionDecl) bool;
942pub extern fn ZigClangFunctionDecl_doesThisDeclarationHaveABody(self: *const ZigClangFunctionDecl) bool;
943pub extern fn ZigClangFunctionDecl_isInlineSpecified(self: *const ZigClangFunctionDecl) bool;
944pub extern fn ZigClangFunctionDecl_isDefined(self: *const ZigClangFunctionDecl) bool;
945pub extern fn ZigClangFunctionDecl_getDefinition(self: *const ZigClangFunctionDecl) ?*const struct_ZigClangFunctionDecl;
946pub extern fn ZigClangFunctionDecl_getSectionAttribute(self: *const ZigClangFunctionDecl, len: *usize) ?[*]const u8;
947
948pub extern fn ZigClangBuiltinType_getKind(self: *const struct_ZigClangBuiltinType) ZigClangBuiltinTypeKind;
949
950pub extern fn ZigClangFunctionType_getNoReturnAttr(self: *const ZigClangFunctionType) bool;
951pub extern fn ZigClangFunctionType_getCallConv(self: *const ZigClangFunctionType) ZigClangCallingConv;
952pub extern fn ZigClangFunctionType_getReturnType(self: *const ZigClangFunctionType) ZigClangQualType;
953
954pub extern fn ZigClangFunctionProtoType_isVariadic(self: *const struct_ZigClangFunctionProtoType) bool;
955pub extern fn ZigClangFunctionProtoType_getNumParams(self: *const struct_ZigClangFunctionProtoType) c_uint;
956pub extern fn ZigClangFunctionProtoType_getParamType(self: *const struct_ZigClangFunctionProtoType, i: c_uint) ZigClangQualType;
957pub extern fn ZigClangFunctionProtoType_getReturnType(self: *const ZigClangFunctionProtoType) ZigClangQualType;
958
959pub const ZigClangSourceLocation = struct_ZigClangSourceLocation;
960pub const ZigClangQualType = struct_ZigClangQualType;
961pub const ZigClangConditionalOperator = struct_ZigClangConditionalOperator;
962pub const ZigClangBinaryConditionalOperator = struct_ZigClangBinaryConditionalOperator;
963pub const ZigClangAbstractConditionalOperator = struct_ZigClangAbstractConditionalOperator;
964pub const ZigClangAPValueLValueBase = struct_ZigClangAPValueLValueBase;
965pub const ZigClangAPValue = struct_ZigClangAPValue;
966pub const ZigClangAPSInt = struct_ZigClangAPSInt;
967pub const ZigClangAPFloat = struct_ZigClangAPFloat;
968pub const ZigClangASTContext = struct_ZigClangASTContext;
969pub const ZigClangASTUnit = struct_ZigClangASTUnit;
970pub const ZigClangArraySubscriptExpr = struct_ZigClangArraySubscriptExpr;
971pub const ZigClangArrayType = struct_ZigClangArrayType;
972pub const ZigClangAttributedType = struct_ZigClangAttributedType;
973pub const ZigClangBinaryOperator = struct_ZigClangBinaryOperator;
974pub const ZigClangBreakStmt = struct_ZigClangBreakStmt;
975pub const ZigClangBuiltinType = struct_ZigClangBuiltinType;
976pub const ZigClangCStyleCastExpr = struct_ZigClangCStyleCastExpr;
977pub const ZigClangCallExpr = struct_ZigClangCallExpr;
978pub const ZigClangCaseStmt = struct_ZigClangCaseStmt;
979pub const ZigClangCompoundAssignOperator = struct_ZigClangCompoundAssignOperator;
980pub const ZigClangCompoundStmt = struct_ZigClangCompoundStmt;
981pub const ZigClangConstantArrayType = struct_ZigClangConstantArrayType;
982pub const ZigClangContinueStmt = struct_ZigClangContinueStmt;
983pub const ZigClangDecayedType = struct_ZigClangDecayedType;
984pub const ZigClangDeclRefExpr = struct_ZigClangDeclRefExpr;
985pub const ZigClangDeclStmt = struct_ZigClangDeclStmt;
986pub const ZigClangDefaultStmt = struct_ZigClangDefaultStmt;
987pub const ZigClangDiagnosticOptions = struct_ZigClangDiagnosticOptions;
988pub const ZigClangDiagnosticsEngine = struct_ZigClangDiagnosticsEngine;
989pub const ZigClangDoStmt = struct_ZigClangDoStmt;
990pub const ZigClangElaboratedType = struct_ZigClangElaboratedType;
991pub const ZigClangEnumConstantDecl = struct_ZigClangEnumConstantDecl;
992pub const ZigClangEnumDecl = struct_ZigClangEnumDecl;
993pub const ZigClangEnumType = struct_ZigClangEnumType;
994pub const ZigClangExpr = struct_ZigClangExpr;
995pub const ZigClangFieldDecl = struct_ZigClangFieldDecl;
996pub const ZigClangFileID = struct_ZigClangFileID;
997pub const ZigClangForStmt = struct_ZigClangForStmt;
998pub const ZigClangFullSourceLoc = struct_ZigClangFullSourceLoc;
999pub const ZigClangFunctionDecl = struct_ZigClangFunctionDecl;
1000pub const ZigClangFunctionProtoType = struct_ZigClangFunctionProtoType;
1001pub const ZigClangIfStmt = struct_ZigClangIfStmt;
1002pub const ZigClangImplicitCastExpr = struct_ZigClangImplicitCastExpr;
1003pub const ZigClangIncompleteArrayType = struct_ZigClangIncompleteArrayType;
1004pub const ZigClangIntegerLiteral = struct_ZigClangIntegerLiteral;
1005pub const ZigClangMacroDefinitionRecord = struct_ZigClangMacroDefinitionRecord;
1006pub const ZigClangMacroExpansion = struct_ZigClangMacroExpansion;
1007pub const ZigClangMacroQualifiedType = struct_ZigClangMacroQualifiedType;
1008pub const ZigClangMemberExpr = struct_ZigClangMemberExpr;
1009pub const ZigClangNamedDecl = struct_ZigClangNamedDecl;
1010pub const ZigClangNone = struct_ZigClangNone;
1011pub const ZigClangOpaqueValueExpr = struct_ZigClangOpaqueValueExpr;
1012pub const ZigClangPCHContainerOperations = struct_ZigClangPCHContainerOperations;
1013pub const ZigClangParenExpr = struct_ZigClangParenExpr;
1014pub const ZigClangParenType = struct_ZigClangParenType;
1015pub const ZigClangParmVarDecl = struct_ZigClangParmVarDecl;
1016pub const ZigClangPointerType = struct_ZigClangPointerType;
1017pub const ZigClangPreprocessedEntity = struct_ZigClangPreprocessedEntity;
1018pub const ZigClangRecordDecl = struct_ZigClangRecordDecl;
1019pub const ZigClangRecordType = struct_ZigClangRecordType;
1020pub const ZigClangReturnStmt = struct_ZigClangReturnStmt;
1021pub const ZigClangSkipFunctionBodiesScope = struct_ZigClangSkipFunctionBodiesScope;
1022pub const ZigClangSourceManager = struct_ZigClangSourceManager;
1023pub const ZigClangSourceRange = struct_ZigClangSourceRange;
1024pub const ZigClangStringLiteral = struct_ZigClangStringLiteral;
1025pub const ZigClangStringRef = struct_ZigClangStringRef;
1026pub const ZigClangSwitchStmt = struct_ZigClangSwitchStmt;
1027pub const ZigClangTagDecl = struct_ZigClangTagDecl;
1028pub const ZigClangType = struct_ZigClangType;
1029pub const ZigClangTypedefNameDecl = struct_ZigClangTypedefNameDecl;
1030pub const ZigClangTypedefType = struct_ZigClangTypedefType;
1031pub const ZigClangUnaryExprOrTypeTraitExpr = struct_ZigClangUnaryExprOrTypeTraitExpr;
1032pub const ZigClangUnaryOperator = struct_ZigClangUnaryOperator;
1033pub const ZigClangValueDecl = struct_ZigClangValueDecl;
1034pub const ZigClangVarDecl = struct_ZigClangVarDecl;
1035pub const ZigClangWhileStmt = struct_ZigClangWhileStmt;
1036pub const ZigClangFunctionType = struct_ZigClangFunctionType;
1037pub const ZigClangPredefinedExpr = struct_ZigClangPredefinedExpr;
1038pub const ZigClangInitListExpr = struct_ZigClangInitListExpr;
1039
1040pub const struct_ZigClangSourceLocation = extern struct {
1041 ID: c_uint,
1042};
1043
10441635pub const Stage2ErrorMsg = extern struct {
10451636 filename_ptr: ?[*]const u8,
10461637 filename_len: usize,
......@@ -1054,199 +1645,16 @@ pub const Stage2ErrorMsg = extern struct {
10541645 column: c_uint,
10551646 // byte offset into source
10561647 offset: c_uint,
1057};
10581648
1059pub const struct_ZigClangQualType = extern struct {
1060 ptr: ?*c_void,
1649 pub const delete = ZigClangErrorMsg_delete;
1650 extern fn ZigClangErrorMsg_delete(ptr: [*]Stage2ErrorMsg, len: usize) void;
10611651};
10621652
1063pub const struct_ZigClangAPValueLValueBase = extern struct {
1064 Ptr: ?*c_void,
1065 CallIndex: c_uint,
1066 Version: c_uint,
1067};
1068
1069pub extern fn ZigClangErrorMsg_delete(ptr: [*]Stage2ErrorMsg, len: usize) void;
1070
1071pub extern fn ZigClangLoadFromCommandLine(
1653pub const LoadFromCommandLine = ZigClangLoadFromCommandLine;
1654extern fn ZigClangLoadFromCommandLine(
10721655 args_begin: [*]?[*]const u8,
10731656 args_end: [*]?[*]const u8,
10741657 errors_ptr: *[*]Stage2ErrorMsg,
10751658 errors_len: *usize,
10761659 resources_path: [*:0]const u8,
1077) ?*ZigClangASTUnit;
1078
1079pub extern fn ZigClangDecl_getKind(decl: *const ZigClangDecl) ZigClangDeclKind;
1080pub extern fn ZigClangDecl_getDeclKindName(decl: *const ZigClangDecl) [*:0]const u8;
1081
1082pub const ZigClangCompoundStmt_const_body_iterator = [*]const *ZigClangStmt;
1083
1084pub extern fn ZigClangCompoundStmt_body_begin(self: *const ZigClangCompoundStmt) ZigClangCompoundStmt_const_body_iterator;
1085pub extern fn ZigClangCompoundStmt_body_end(self: *const ZigClangCompoundStmt) ZigClangCompoundStmt_const_body_iterator;
1086
1087pub const ZigClangDeclStmt_const_decl_iterator = [*]const *ZigClangDecl;
1088
1089pub extern fn ZigClangDeclStmt_decl_begin(self: *const ZigClangDeclStmt) ZigClangDeclStmt_const_decl_iterator;
1090pub extern fn ZigClangDeclStmt_decl_end(self: *const ZigClangDeclStmt) ZigClangDeclStmt_const_decl_iterator;
1091
1092pub extern fn ZigClangVarDecl_getLocation(self: *const struct_ZigClangVarDecl) ZigClangSourceLocation;
1093pub extern fn ZigClangVarDecl_hasInit(self: *const struct_ZigClangVarDecl) bool;
1094pub extern fn ZigClangVarDecl_getStorageClass(self: *const ZigClangVarDecl) ZigClangStorageClass;
1095pub extern fn ZigClangVarDecl_getType(self: ?*const struct_ZigClangVarDecl) struct_ZigClangQualType;
1096pub extern fn ZigClangVarDecl_getInit(*const ZigClangVarDecl) ?*const ZigClangExpr;
1097pub extern fn ZigClangVarDecl_getTLSKind(self: ?*const struct_ZigClangVarDecl) ZigClangVarDecl_TLSKind;
1098pub const ZigClangVarDecl_TLSKind = extern enum {
1099 None,
1100 Static,
1101 Dynamic,
1102};
1103
1104pub extern fn ZigClangImplicitCastExpr_getBeginLoc(*const ZigClangImplicitCastExpr) ZigClangSourceLocation;
1105pub extern fn ZigClangImplicitCastExpr_getCastKind(*const ZigClangImplicitCastExpr) ZigClangCK;
1106pub extern fn ZigClangImplicitCastExpr_getSubExpr(*const ZigClangImplicitCastExpr) *const ZigClangExpr;
1107
1108pub extern fn ZigClangArrayType_getElementType(*const ZigClangArrayType) ZigClangQualType;
1109pub extern fn ZigClangIncompleteArrayType_getElementType(*const ZigClangIncompleteArrayType) ZigClangQualType;
1110
1111pub extern fn ZigClangConstantArrayType_getElementType(self: *const struct_ZigClangConstantArrayType) ZigClangQualType;
1112pub extern fn ZigClangConstantArrayType_getSize(self: *const struct_ZigClangConstantArrayType) *const struct_ZigClangAPInt;
1113pub extern fn ZigClangDeclRefExpr_getDecl(*const ZigClangDeclRefExpr) *const ZigClangValueDecl;
1114pub extern fn ZigClangDeclRefExpr_getFoundDecl(*const ZigClangDeclRefExpr) *const ZigClangNamedDecl;
1115
1116pub extern fn ZigClangParenType_getInnerType(*const ZigClangParenType) ZigClangQualType;
1117
1118pub extern fn ZigClangElaboratedType_getNamedType(*const ZigClangElaboratedType) ZigClangQualType;
1119
1120pub extern fn ZigClangAttributedType_getEquivalentType(*const ZigClangAttributedType) ZigClangQualType;
1121
1122pub extern fn ZigClangMacroQualifiedType_getModifiedType(*const ZigClangMacroQualifiedType) ZigClangQualType;
1123
1124pub extern fn ZigClangCStyleCastExpr_getBeginLoc(*const ZigClangCStyleCastExpr) ZigClangSourceLocation;
1125pub extern fn ZigClangCStyleCastExpr_getSubExpr(*const ZigClangCStyleCastExpr) *const ZigClangExpr;
1126pub extern fn ZigClangCStyleCastExpr_getType(*const ZigClangCStyleCastExpr) ZigClangQualType;
1127
1128pub const ZigClangExprEvalResult = struct_ZigClangExprEvalResult;
1129pub const struct_ZigClangExprEvalResult = extern struct {
1130 HasSideEffects: bool,
1131 HasUndefinedBehavior: bool,
1132 SmallVectorImpl: ?*c_void,
1133 Val: ZigClangAPValue,
1134};
1135
1136pub const struct_ZigClangAPValue = extern struct {
1137 Kind: ZigClangAPValueKind,
1138 Data: if (builtin.os.tag == .windows and builtin.abi == .msvc) [52]u8 else [68]u8,
1139};
1140pub extern fn ZigClangVarDecl_getTypeSourceInfo_getType(self: *const struct_ZigClangVarDecl) struct_ZigClangQualType;
1141
1142pub extern fn ZigClangIntegerLiteral_EvaluateAsInt(*const ZigClangIntegerLiteral, *ZigClangExprEvalResult, *const ZigClangASTContext) bool;
1143pub extern fn ZigClangIntegerLiteral_getBeginLoc(*const ZigClangIntegerLiteral) ZigClangSourceLocation;
1144pub extern fn ZigClangIntegerLiteral_isZero(*const ZigClangIntegerLiteral, *bool, *const ZigClangASTContext) bool;
1145
1146pub extern fn ZigClangReturnStmt_getRetValue(*const ZigClangReturnStmt) ?*const ZigClangExpr;
1147
1148pub extern fn ZigClangBinaryOperator_getOpcode(*const ZigClangBinaryOperator) ZigClangBO;
1149pub extern fn ZigClangBinaryOperator_getBeginLoc(*const ZigClangBinaryOperator) ZigClangSourceLocation;
1150pub extern fn ZigClangBinaryOperator_getLHS(*const ZigClangBinaryOperator) *const ZigClangExpr;
1151pub extern fn ZigClangBinaryOperator_getRHS(*const ZigClangBinaryOperator) *const ZigClangExpr;
1152pub extern fn ZigClangBinaryOperator_getType(*const ZigClangBinaryOperator) ZigClangQualType;
1153
1154pub extern fn ZigClangDecayedType_getDecayedType(*const ZigClangDecayedType) ZigClangQualType;
1155
1156pub extern fn ZigClangStringLiteral_getKind(*const ZigClangStringLiteral) ZigClangStringLiteral_StringKind;
1157pub extern fn ZigClangStringLiteral_getString_bytes_begin_size(*const ZigClangStringLiteral, *usize) [*]const u8;
1158
1159pub extern fn ZigClangParenExpr_getSubExpr(*const ZigClangParenExpr) *const ZigClangExpr;
1160
1161pub extern fn ZigClangFieldDecl_isAnonymousStructOrUnion(*const struct_ZigClangFieldDecl) bool;
1162pub extern fn ZigClangFieldDecl_isBitField(*const struct_ZigClangFieldDecl) bool;
1163pub extern fn ZigClangFieldDecl_getType(*const struct_ZigClangFieldDecl) struct_ZigClangQualType;
1164pub extern fn ZigClangFieldDecl_getLocation(*const struct_ZigClangFieldDecl) struct_ZigClangSourceLocation;
1165
1166pub extern fn ZigClangEnumConstantDecl_getInitExpr(*const ZigClangEnumConstantDecl) ?*const ZigClangExpr;
1167pub extern fn ZigClangEnumConstantDecl_getInitVal(*const ZigClangEnumConstantDecl) *const ZigClangAPSInt;
1168
1169pub extern fn ZigClangASTUnit_getLocalPreprocessingEntities_begin(*ZigClangASTUnit) ZigClangPreprocessingRecord_iterator;
1170pub extern fn ZigClangASTUnit_getLocalPreprocessingEntities_end(*ZigClangASTUnit) ZigClangPreprocessingRecord_iterator;
1171pub extern fn ZigClangPreprocessingRecord_iterator_deref(ZigClangPreprocessingRecord_iterator) *ZigClangPreprocessedEntity;
1172pub extern fn ZigClangPreprocessedEntity_getKind(*const ZigClangPreprocessedEntity) ZigClangPreprocessedEntity_EntityKind;
1173
1174pub extern fn ZigClangMacroDefinitionRecord_getName_getNameStart(*const ZigClangMacroDefinitionRecord) [*:0]const u8;
1175pub extern fn ZigClangMacroDefinitionRecord_getSourceRange_getBegin(*const ZigClangMacroDefinitionRecord) ZigClangSourceLocation;
1176pub extern fn ZigClangMacroDefinitionRecord_getSourceRange_getEnd(*const ZigClangMacroDefinitionRecord) ZigClangSourceLocation;
1177
1178pub extern fn ZigClangMacroExpansion_getDefinition(*const ZigClangMacroExpansion) *const ZigClangMacroDefinitionRecord;
1179
1180pub extern fn ZigClangIfStmt_getThen(*const ZigClangIfStmt) *const ZigClangStmt;
1181pub extern fn ZigClangIfStmt_getElse(*const ZigClangIfStmt) ?*const ZigClangStmt;
1182pub extern fn ZigClangIfStmt_getCond(*const ZigClangIfStmt) *const ZigClangStmt;
1183
1184pub extern fn ZigClangWhileStmt_getCond(*const ZigClangWhileStmt) *const ZigClangExpr;
1185pub extern fn ZigClangWhileStmt_getBody(*const ZigClangWhileStmt) *const ZigClangStmt;
1186
1187pub extern fn ZigClangDoStmt_getCond(*const ZigClangDoStmt) *const ZigClangExpr;
1188pub extern fn ZigClangDoStmt_getBody(*const ZigClangDoStmt) *const ZigClangStmt;
1189
1190pub extern fn ZigClangForStmt_getInit(*const ZigClangForStmt) ?*const ZigClangStmt;
1191pub extern fn ZigClangForStmt_getCond(*const ZigClangForStmt) ?*const ZigClangExpr;
1192pub extern fn ZigClangForStmt_getInc(*const ZigClangForStmt) ?*const ZigClangExpr;
1193pub extern fn ZigClangForStmt_getBody(*const ZigClangForStmt) *const ZigClangStmt;
1194
1195pub extern fn ZigClangAPFloat_toString(self: *const ZigClangAPFloat, precision: c_uint, maxPadding: c_uint, truncateZero: bool) [*:0]const u8;
1196pub extern fn ZigClangAPFloat_getValueAsApproximateDouble(*const ZigClangFloatingLiteral) f64;
1197
1198pub extern fn ZigClangAbstractConditionalOperator_getCond(*const ZigClangAbstractConditionalOperator) *const ZigClangExpr;
1199pub extern fn ZigClangAbstractConditionalOperator_getTrueExpr(*const ZigClangAbstractConditionalOperator) *const ZigClangExpr;
1200pub extern fn ZigClangAbstractConditionalOperator_getFalseExpr(*const ZigClangAbstractConditionalOperator) *const ZigClangExpr;
1201
1202pub extern fn ZigClangSwitchStmt_getConditionVariableDeclStmt(*const ZigClangSwitchStmt) ?*const ZigClangDeclStmt;
1203pub extern fn ZigClangSwitchStmt_getCond(*const ZigClangSwitchStmt) *const ZigClangExpr;
1204pub extern fn ZigClangSwitchStmt_getBody(*const ZigClangSwitchStmt) *const ZigClangStmt;
1205pub extern fn ZigClangSwitchStmt_isAllEnumCasesCovered(*const ZigClangSwitchStmt) bool;
1206
1207pub extern fn ZigClangCaseStmt_getLHS(*const ZigClangCaseStmt) *const ZigClangExpr;
1208pub extern fn ZigClangCaseStmt_getRHS(*const ZigClangCaseStmt) ?*const ZigClangExpr;
1209pub extern fn ZigClangCaseStmt_getBeginLoc(*const ZigClangCaseStmt) ZigClangSourceLocation;
1210pub extern fn ZigClangCaseStmt_getSubStmt(*const ZigClangCaseStmt) *const ZigClangStmt;
1211
1212pub extern fn ZigClangDefaultStmt_getSubStmt(*const ZigClangDefaultStmt) *const ZigClangStmt;
1213
1214pub extern fn ZigClangExpr_EvaluateAsConstantExpr(*const ZigClangExpr, *ZigClangExprEvalResult, ZigClangExpr_ConstExprUsage, *const ZigClangASTContext) bool;
1215
1216pub extern fn ZigClangPredefinedExpr_getFunctionName(*const ZigClangPredefinedExpr) *const ZigClangStringLiteral;
1217
1218pub extern fn ZigClangCharacterLiteral_getBeginLoc(*const ZigClangCharacterLiteral) ZigClangSourceLocation;
1219pub extern fn ZigClangCharacterLiteral_getKind(*const ZigClangCharacterLiteral) ZigClangCharacterLiteral_CharacterKind;
1220pub extern fn ZigClangCharacterLiteral_getValue(*const ZigClangCharacterLiteral) c_uint;
1221
1222pub extern fn ZigClangStmtExpr_getSubStmt(*const ZigClangStmtExpr) *const ZigClangCompoundStmt;
1223
1224pub extern fn ZigClangMemberExpr_getBase(*const ZigClangMemberExpr) *const ZigClangExpr;
1225pub extern fn ZigClangMemberExpr_isArrow(*const ZigClangMemberExpr) bool;
1226pub extern fn ZigClangMemberExpr_getMemberDecl(*const ZigClangMemberExpr) *const ZigClangValueDecl;
1227
1228pub extern fn ZigClangArraySubscriptExpr_getBase(*const ZigClangArraySubscriptExpr) *const ZigClangExpr;
1229pub extern fn ZigClangArraySubscriptExpr_getIdx(*const ZigClangArraySubscriptExpr) *const ZigClangExpr;
1230
1231pub extern fn ZigClangCallExpr_getCallee(*const ZigClangCallExpr) *const ZigClangExpr;
1232pub extern fn ZigClangCallExpr_getNumArgs(*const ZigClangCallExpr) c_uint;
1233pub extern fn ZigClangCallExpr_getArgs(*const ZigClangCallExpr) [*]const *const ZigClangExpr;
1234
1235pub extern fn ZigClangUnaryExprOrTypeTraitExpr_getTypeOfArgument(*const ZigClangUnaryExprOrTypeTraitExpr) ZigClangQualType;
1236pub extern fn ZigClangUnaryExprOrTypeTraitExpr_getBeginLoc(*const ZigClangUnaryExprOrTypeTraitExpr) ZigClangSourceLocation;
1237pub extern fn ZigClangUnaryExprOrTypeTraitExpr_getKind(*const ZigClangUnaryExprOrTypeTraitExpr) ZigClangUnaryExprOrTypeTrait_Kind;
1238
1239pub extern fn ZigClangUnaryOperator_getOpcode(*const ZigClangUnaryOperator) ZigClangUO;
1240pub extern fn ZigClangUnaryOperator_getType(*const ZigClangUnaryOperator) ZigClangQualType;
1241pub extern fn ZigClangUnaryOperator_getSubExpr(*const ZigClangUnaryOperator) *const ZigClangExpr;
1242pub extern fn ZigClangUnaryOperator_getBeginLoc(*const ZigClangUnaryOperator) ZigClangSourceLocation;
1243
1244pub extern fn ZigClangOpaqueValueExpr_getSourceExpr(*const ZigClangOpaqueValueExpr) ?*const ZigClangExpr;
1245
1246pub extern fn ZigClangCompoundAssignOperator_getType(*const ZigClangCompoundAssignOperator) ZigClangQualType;
1247pub extern fn ZigClangCompoundAssignOperator_getComputationLHSType(*const ZigClangCompoundAssignOperator) ZigClangQualType;
1248pub extern fn ZigClangCompoundAssignOperator_getComputationResultType(*const ZigClangCompoundAssignOperator) ZigClangQualType;
1249pub extern fn ZigClangCompoundAssignOperator_getBeginLoc(*const ZigClangCompoundAssignOperator) ZigClangSourceLocation;
1250pub extern fn ZigClangCompoundAssignOperator_getOpcode(*const ZigClangCompoundAssignOperator) ZigClangBO;
1251pub extern fn ZigClangCompoundAssignOperator_getLHS(*const ZigClangCompoundAssignOperator) *const ZigClangExpr;
1252pub extern fn ZigClangCompoundAssignOperator_getRHS(*const ZigClangCompoundAssignOperator) *const ZigClangExpr;
1660) ?*ASTUnit;
src/clang_options_data.zig+34-6
......@@ -76,8 +76,22 @@ flagpd1("M"),
7676 .psl = false,
7777},
7878flagpd1("Mach"),
79flagpd1("O0"),
80flagpd1("O4"),
79.{
80 .name = "O0",
81 .syntax = .flag,
82 .zig_equivalent = .optimize,
83 .pd1 = true,
84 .pd2 = false,
85 .psl = false,
86},
87.{
88 .name = "O4",
89 .syntax = .flag,
90 .zig_equivalent = .optimize,
91 .pd1 = true,
92 .pd2 = false,
93 .psl = false,
94},
8195.{
8296 .name = "O",
8397 .syntax = .flag,
......@@ -2186,7 +2200,7 @@ flagpd1("fcuda-rdc"),
21862200.{
21872201 .name = "Os",
21882202 .syntax = .flag,
2189 .zig_equivalent = .other,
2203 .zig_equivalent = .optimize,
21902204 .pd1 = true,
21912205 .pd2 = false,
21922206 .psl = true,
......@@ -3377,7 +3391,14 @@ flagpd1("fxray-link-deps"),
33773391flagpd1("fzero-initialized-in-bss"),
33783392flagpd1("fzvector"),
33793393flagpd1("g0"),
3380flagpd1("g1"),
3394.{
3395 .name = "g1",
3396 .syntax = .flag,
3397 .zig_equivalent = .debug,
3398 .pd1 = true,
3399 .pd2 = false,
3400 .psl = false,
3401},
33813402flagpd1("g2"),
33823403flagpd1("g3"),
33833404.{
......@@ -3410,7 +3431,14 @@ flagpd1("ggdb3"),
34103431flagpd1("ggnu-pubnames"),
34113432flagpd1("ginline-line-tables"),
34123433flagpd1("gline-directives-only"),
3413flagpd1("gline-tables-only"),
3434.{
3435 .name = "gline-tables-only",
3436 .syntax = .flag,
3437 .zig_equivalent = .debug,
3438 .pd1 = true,
3439 .pd2 = false,
3440 .psl = false,
3441},
34143442flagpd1("glldb"),
34153443flagpd1("gmlt"),
34163444flagpd1("gmodules"),
......@@ -5535,7 +5563,7 @@ jspd1("iquote"),
55355563joinpd1("weak-l"),
55365564.{
55375565 .name = "Ofast",
5538 .syntax = .joined,
5566 .syntax = .flag,
55395567 .zig_equivalent = .optimize,
55405568 .pd1 = true,
55415569 .pd2 = false,
src/link/MachO.zig-21
......@@ -287,9 +287,6 @@ pub fn flushModule(self: *MachO, comp: *Compilation) !void {
287287 }
288288 const cmd = &self.load_commands.items[self.dylinker_cmd_index.?].Dylinker;
289289 off += cmd.name;
290 const padding = cmd.cmdsize - @sizeOf(macho.dylinker_command);
291 log.debug("writing LC_LOAD_DYLINKER padding of size {} at 0x{x}\n", .{ padding, off });
292 try self.addPadding(padding, off);
293290 log.debug("writing LC_LOAD_DYLINKER path to dyld at 0x{x}\n", .{off});
294291 try self.base.file.?.pwriteAll(mem.spanZ(DEFAULT_DYLD_PATH), off);
295292 }
......@@ -302,9 +299,6 @@ pub fn flushModule(self: *MachO, comp: *Compilation) !void {
302299 }
303300 const cmd = &self.load_commands.items[self.libsystem_cmd_index.?].Dylib;
304301 off += cmd.dylib.name;
305 const padding = cmd.cmdsize - @sizeOf(macho.dylib_command);
306 log.debug("writing LC_LOAD_DYLIB padding of size {} at 0x{x}\n", .{ padding, off });
307 try self.addPadding(padding, off);
308302 log.debug("writing LC_LOAD_DYLIB path to libSystem at 0x{x}\n", .{off});
309303 try self.base.file.?.pwriteAll(mem.spanZ(LIB_SYSTEM_PATH), off);
310304 }
......@@ -1264,21 +1258,6 @@ fn updateString(self: *MachO, old_str_off: u32, new_name: []const u8) !u32 {
12641258 return self.makeString(new_name);
12651259}
12661260
1267/// TODO This should not heap allocate, instead it should utilize a fixed size, statically allocated
1268/// global const array. You could even use pwritev to write the same buffer multiple times with only
1269/// 1 syscall if you needed to, for example, write 8192 bytes using a buffer of only 4096 bytes.
1270/// This size parameter should probably be a usize not u64.
1271fn addPadding(self: *MachO, size: u64, file_offset: u64) !void {
1272 if (size == 0) return;
1273
1274 const buf = try self.base.allocator.alloc(u8, @intCast(usize, size));
1275 defer self.base.allocator.free(buf);
1276
1277 mem.set(u8, buf[0..], 0);
1278
1279 try self.base.file.?.pwriteAll(buf, file_offset);
1280}
1281
12821261fn detectAllocCollision(self: *MachO, start: u64, size: u64) ?u64 {
12831262 const hdr_size: u64 = @sizeOf(macho.mach_header_64);
12841263 if (start < hdr_size) return hdr_size;
src/main.zig+17-7
......@@ -992,15 +992,20 @@ fn buildOutputType(
992992 },
993993 .optimize => {
994994 // Alright, what release mode do they want?
995 if (mem.eql(u8, it.only_arg, "Os")) {
995 const level = if (it.only_arg.len >= 1 and it.only_arg[0] == 'O') it.only_arg[1..] else it.only_arg;
996 if (mem.eql(u8, level, "s") or
997 mem.eql(u8, level, "z"))
998 {
996999 optimize_mode = .ReleaseSmall;
997 } else if (mem.eql(u8, it.only_arg, "O2") or
998 mem.eql(u8, it.only_arg, "O3") or
999 mem.eql(u8, it.only_arg, "O4"))
1000 } else if (mem.eql(u8, level, "1") or
1001 mem.eql(u8, level, "2") or
1002 mem.eql(u8, level, "3") or
1003 mem.eql(u8, level, "4") or
1004 mem.eql(u8, level, "fast"))
10001005 {
10011006 optimize_mode = .ReleaseFast;
1002 } else if (mem.eql(u8, it.only_arg, "Og") or
1003 mem.eql(u8, it.only_arg, "O0"))
1007 } else if (mem.eql(u8, level, "g") or
1008 mem.eql(u8, level, "0"))
10041009 {
10051010 optimize_mode = .Debug;
10061011 } else {
......@@ -1009,8 +1014,13 @@ fn buildOutputType(
10091014 },
10101015 .debug => {
10111016 strip = false;
1012 if (mem.eql(u8, it.only_arg, "-g")) {
1017 if (mem.eql(u8, it.only_arg, "g")) {
10131018 // We handled with strip = false above.
1019 } else if (mem.eql(u8, it.only_arg, "g1") or
1020 mem.eql(u8, it.only_arg, "gline-tables-only"))
1021 {
1022 // We handled with strip = false above. but we also want reduced debug info.
1023 try clang_argv.append("-gline-tables-only");
10141024 } else {
10151025 try clang_argv.appendSlice(it.other_args);
10161026 }
src/stage1/all_types.hpp+4-1
......@@ -72,7 +72,6 @@ enum PtrLen {
7272enum CallingConvention {
7373 CallingConventionUnspecified,
7474 CallingConventionC,
75 CallingConventionCold,
7675 CallingConventionNaked,
7776 CallingConventionAsync,
7877 CallingConventionInterrupt,
......@@ -1054,6 +1053,7 @@ enum ContainerKind {
10541053 ContainerKindStruct,
10551054 ContainerKindEnum,
10561055 ContainerKindUnion,
1056 ContainerKindOpaque,
10571057};
10581058
10591059enum ContainerLayout {
......@@ -1571,7 +1571,10 @@ enum OnePossibleValue {
15711571};
15721572
15731573struct ZigTypeOpaque {
1574 AstNode *decl_node;
15741575 Buf *bare_name;
1576
1577 ScopeDecls *decls_scope;
15751578};
15761579
15771580struct ZigTypeFnFrame {
src/stage1/analyze.cpp+81-35
......@@ -86,14 +86,18 @@ ZigType *new_type_table_entry(ZigTypeId id) {
8686}
8787
8888static ScopeDecls **get_container_scope_ptr(ZigType *type_entry) {
89 if (type_entry->id == ZigTypeIdStruct) {
90 return &type_entry->data.structure.decls_scope;
91 } else if (type_entry->id == ZigTypeIdEnum) {
92 return &type_entry->data.enumeration.decls_scope;
93 } else if (type_entry->id == ZigTypeIdUnion) {
94 return &type_entry->data.unionation.decls_scope;
89 switch (type_entry->id) {
90 case ZigTypeIdStruct:
91 return &type_entry->data.structure.decls_scope;
92 case ZigTypeIdEnum:
93 return &type_entry->data.enumeration.decls_scope;
94 case ZigTypeIdUnion:
95 return &type_entry->data.unionation.decls_scope;
96 case ZigTypeIdOpaque:
97 return &type_entry->data.opaque.decls_scope;
98 default:
99 zig_unreachable();
95100 }
96 zig_unreachable();
97101}
98102
99103static ScopeExpr *find_expr_scope(Scope *scope) {
......@@ -912,13 +916,17 @@ ZigType *get_opaque_type(CodeGen *g, Scope *scope, AstNode *source_node, const c
912916 ZigType *import = scope ? get_scope_import(scope) : nullptr;
913917 unsigned line = source_node ? (unsigned)(source_node->line + 1) : 0;
914918
919 // Note: duplicated in get_partial_container_type
915920 entry->llvm_type = LLVMInt8Type();
916921 entry->llvm_di_type = ZigLLVMCreateDebugForwardDeclType(g->dbuilder,
917922 ZigLLVMTag_DW_structure_type(), full_name,
918923 import ? ZigLLVMFileToScope(import->data.structure.root_struct->di_file) : nullptr,
919924 import ? import->data.structure.root_struct->di_file : nullptr,
920925 line);
926 entry->data.opaque.decl_node = source_node;
921927 entry->data.opaque.bare_name = bare_name;
928 entry->data.opaque.decls_scope = create_decls_scope(
929 g, source_node, scope, entry, import, &entry->name);
922930
923931 // The actual size is unknown, but the value must not be 0 because that
924932 // is how type_has_bits is determined.
......@@ -949,7 +957,6 @@ const char *calling_convention_name(CallingConvention cc) {
949957 switch (cc) {
950958 case CallingConventionUnspecified: return "Unspecified";
951959 case CallingConventionC: return "C";
952 case CallingConventionCold: return "Cold";
953960 case CallingConventionNaked: return "Naked";
954961 case CallingConventionAsync: return "Async";
955962 case CallingConventionInterrupt: return "Interrupt";
......@@ -971,7 +978,6 @@ bool calling_convention_allows_zig_types(CallingConvention cc) {
971978 case CallingConventionAsync:
972979 return true;
973980 case CallingConventionC:
974 case CallingConventionCold:
975981 case CallingConventionNaked:
976982 case CallingConventionInterrupt:
977983 case CallingConventionSignal:
......@@ -1080,6 +1086,8 @@ static ZigTypeId container_to_type(ContainerKind kind) {
10801086 return ZigTypeIdEnum;
10811087 case ContainerKindUnion:
10821088 return ZigTypeIdUnion;
1089 case ContainerKindOpaque:
1090 return ZigTypeIdOpaque;
10831091 }
10841092 zig_unreachable();
10851093}
......@@ -1121,6 +1129,22 @@ ZigType *get_partial_container_type(CodeGen *g, Scope *scope, ContainerKind kind
11211129 entry->data.unionation.decl_node = decl_node;
11221130 entry->data.unionation.layout = layout;
11231131 break;
1132 case ContainerKindOpaque: {
1133 ZigType *import = scope ? get_scope_import(scope) : nullptr;
1134 unsigned line = decl_node ? (unsigned)(decl_node->line + 1) : 0;
1135 // Note: duplicated in get_opaque_type
1136 entry->llvm_type = LLVMInt8Type();
1137 entry->llvm_di_type = ZigLLVMCreateDebugForwardDeclType(g->dbuilder,
1138 ZigLLVMTag_DW_structure_type(), full_name,
1139 import ? ZigLLVMFileToScope(import->data.structure.root_struct->di_file) : nullptr,
1140 import ? import->data.structure.root_struct->di_file : nullptr,
1141 line);
1142 entry->data.opaque.decl_node = decl_node;
1143 entry->abi_size = SIZE_MAX;
1144 entry->size_in_bits = SIZE_MAX;
1145 entry->abi_align = 1;
1146 break;
1147 }
11241148 }
11251149
11261150 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
17301754 return emit_error_unless_type_allowed_in_packed_container(g, type_entry, source_node, "union");
17311755}
17321756
1733Error type_allowed_in_extern(CodeGen *g, ZigType *type_entry, bool *result) {
1757Error type_allowed_in_extern(CodeGen *g, ZigType *type_entry, ExternPosition position, bool *result) {
17341758 Error err;
17351759 switch (type_entry->id) {
17361760 case ZigTypeIdInvalid:
......@@ -1749,8 +1773,10 @@ Error type_allowed_in_extern(CodeGen *g, ZigType *type_entry, bool *result) {
17491773 case ZigTypeIdAnyFrame:
17501774 *result = false;
17511775 return ErrorNone;
1752 case ZigTypeIdOpaque:
17531776 case ZigTypeIdUnreachable:
1777 *result = position == ExternPositionFunctionReturn;
1778 return ErrorNone;
1779 case ZigTypeIdOpaque:
17541780 case ZigTypeIdBool:
17551781 *result = true;
17561782 return ErrorNone;
......@@ -1768,23 +1794,27 @@ Error type_allowed_in_extern(CodeGen *g, ZigType *type_entry, bool *result) {
17681794 return ErrorNone;
17691795 }
17701796 case ZigTypeIdVector:
1771 return type_allowed_in_extern(g, type_entry->data.vector.elem_type, result);
1797 return type_allowed_in_extern(g, type_entry->data.vector.elem_type, ExternPositionOther, result);
17721798 case ZigTypeIdFloat:
17731799 *result = true;
17741800 return ErrorNone;
17751801 case ZigTypeIdArray:
1776 return type_allowed_in_extern(g, type_entry->data.array.child_type, result);
1802 if ((err = type_allowed_in_extern(g, type_entry->data.array.child_type, ExternPositionOther, result)))
1803 return err;
1804 *result = *result &&
1805 position != ExternPositionFunctionParameter &&
1806 position != ExternPositionFunctionReturn;
1807 return ErrorNone;
17771808 case ZigTypeIdFn:
17781809 *result = !calling_convention_allows_zig_types(type_entry->data.fn.fn_type_id.cc);
17791810 return ErrorNone;
17801811 case ZigTypeIdPointer:
17811812 if ((err = type_resolve(g, type_entry, ResolveStatusZeroBitsKnown)))
17821813 return err;
1783 if (!type_has_bits(g, type_entry)) {
1784 *result = false;
1785 return ErrorNone;
1786 }
1787 *result = true;
1814 bool has_bits;
1815 if ((err = type_has_bits2(g, type_entry, &has_bits)))
1816 return err;
1817 *result = has_bits;
17881818 return ErrorNone;
17891819 case ZigTypeIdStruct:
17901820 *result = type_entry->data.structure.layout == ContainerLayoutExtern ||
......@@ -1796,23 +1826,24 @@ Error type_allowed_in_extern(CodeGen *g, ZigType *type_entry, bool *result) {
17961826 *result = false;
17971827 return ErrorNone;
17981828 }
1799 if (!type_is_nonnull_ptr(g, child_type)) {
1829 bool is_nonnull_ptr;
1830 if ((err = type_is_nonnull_ptr2(g, child_type, &is_nonnull_ptr)))
1831 return err;
1832 if (!is_nonnull_ptr) {
18001833 *result = false;
18011834 return ErrorNone;
18021835 }
1803 return type_allowed_in_extern(g, child_type, result);
1836 return type_allowed_in_extern(g, child_type, ExternPositionOther, result);
18041837 }
18051838 case ZigTypeIdEnum: {
18061839 if ((err = type_resolve(g, type_entry, ResolveStatusZeroBitsKnown)))
18071840 return err;
18081841 ZigType *tag_int_type = type_entry->data.enumeration.tag_int_type;
1809 if (type_entry->data.enumeration.has_explicit_tag_type) {
1810 return type_allowed_in_extern(g, tag_int_type, result);
1811 } else {
1812 *result = type_entry->data.enumeration.layout == ContainerLayoutExtern ||
1813 type_entry->data.enumeration.layout == ContainerLayoutPacked;
1814 return ErrorNone;
1815 }
1842 if (type_entry->data.enumeration.has_explicit_tag_type)
1843 return type_allowed_in_extern(g, tag_int_type, position, result);
1844 *result = type_entry->data.enumeration.layout == ContainerLayoutExtern ||
1845 type_entry->data.enumeration.layout == ContainerLayoutPacked;
1846 return ErrorNone;
18161847 }
18171848 case ZigTypeIdUnion:
18181849 *result = type_entry->data.unionation.layout == ContainerLayoutExtern ||
......@@ -1909,7 +1940,7 @@ static ZigType *analyze_fn_type(CodeGen *g, AstNode *proto_node, Scope *child_sc
19091940
19101941 if (!calling_convention_allows_zig_types(fn_type_id.cc)) {
19111942 bool ok_type;
1912 if ((err = type_allowed_in_extern(g, type_entry, &ok_type)))
1943 if ((err = type_allowed_in_extern(g, type_entry, ExternPositionFunctionParameter, &ok_type)))
19131944 return g->builtin_types.entry_invalid;
19141945 if (!ok_type) {
19151946 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
20142045 if ((err = type_resolve(g, fn_type_id.return_type, ResolveStatusSizeKnown)))
20152046 return g->builtin_types.entry_invalid;
20162047 bool ok_type;
2017 if ((err = type_allowed_in_extern(g, fn_type_id.return_type, &ok_type)))
2048 if ((err = type_allowed_in_extern(g, fn_type_id.return_type, ExternPositionFunctionReturn, &ok_type)))
20182049 return g->builtin_types.entry_invalid;
20192050 if (!ok_type) {
20202051 add_node_error(g, fn_proto->return_type,
......@@ -2333,7 +2364,7 @@ static Error resolve_struct_type(CodeGen *g, ZigType *struct_type) {
23332364
23342365 if (struct_type->data.structure.layout == ContainerLayoutExtern) {
23352366 bool ok_type;
2336 if ((err = type_allowed_in_extern(g, field_type, &ok_type))) {
2367 if ((err = type_allowed_in_extern(g, field_type, ExternPositionOther, &ok_type))) {
23372368 struct_type->data.structure.resolve_status = ResolveStatusInvalid;
23382369 return ErrorSemanticAnalyzeFail;
23392370 }
......@@ -2588,7 +2619,7 @@ static Error type_is_valid_extern_enum_tag(CodeGen *g, ZigType *ty, bool *result
25882619 // signed char, a signed integer or an unsigned one. But GCC/Clang allow
25892620 // other integral types as a compiler extension so let's accomodate them
25902621 // aswell.
2591 return type_allowed_in_extern(g, ty, result);
2622 return type_allowed_in_extern(g, ty, ExternPositionOther, result);
25922623}
25932624
25942625static 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) {
34303461 return ErrorNone;
34313462}
34323463
3464static Error resolve_opaque_type(CodeGen *g, ZigType *opaque_type) {
3465 Error err = ErrorNone;
3466 AstNode *container_node = opaque_type->data.opaque.decl_node;
3467 if (container_node != nullptr) {
3468 assert(container_node->type == NodeTypeContainerDecl);
3469 AstNodeContainerDecl *container_decl = &container_node->data.container_decl;
3470 for (size_t i = 0; i < container_decl->fields.length; i++) {
3471 AstNode *field_node = container_decl->fields.items[i];
3472 add_node_error(g, field_node, buf_create_from_str("opaque types cannot have fields"));
3473 err = ErrorSemanticAnalyzeFail;
3474 }
3475 }
3476 return err;
3477}
3478
34333479void append_namespace_qualification(CodeGen *g, Buf *buf, ZigType *container_type) {
34343480 if (g->root_import == container_type || buf_len(&container_type->name) == 0) return;
34353481 buf_append_buf(buf, &container_type->name);
......@@ -3603,7 +3649,6 @@ static void resolve_decl_fn(CodeGen *g, TldFn *tld_fn) {
36033649 tld_fn->base.resolution = TldResolutionInvalid;
36043650 return;
36053651 case CallingConventionC:
3606 case CallingConventionCold:
36073652 case CallingConventionNaked:
36083653 case CallingConventionInterrupt:
36093654 case CallingConventionSignal:
......@@ -3896,6 +3941,8 @@ static Error resolve_decl_container(CodeGen *g, TldContainer *tld_container) {
38963941 return resolve_enum_zero_bits(g, tld_container->type_entry);
38973942 case ZigTypeIdUnion:
38983943 return resolve_union_type(g, tld_container->type_entry);
3944 case ZigTypeIdOpaque:
3945 return resolve_opaque_type(g, tld_container->type_entry);
38993946 default:
39003947 zig_unreachable();
39013948 }
......@@ -4462,6 +4509,7 @@ bool is_container(ZigType *type_entry) {
44624509 return type_entry->data.structure.special != StructSpecialSlice;
44634510 case ZigTypeIdEnum:
44644511 case ZigTypeIdUnion:
4512 case ZigTypeIdOpaque:
44654513 return true;
44664514 case ZigTypeIdPointer:
44674515 case ZigTypeIdMetaType:
......@@ -4481,7 +4529,6 @@ bool is_container(ZigType *type_entry) {
44814529 case ZigTypeIdErrorSet:
44824530 case ZigTypeIdFn:
44834531 case ZigTypeIdBoundFn:
4484 case ZigTypeIdOpaque:
44854532 case ZigTypeIdVector:
44864533 case ZigTypeIdFnFrame:
44874534 case ZigTypeIdAnyFrame:
......@@ -8168,6 +8215,7 @@ const char *container_string(ContainerKind kind) {
81688215 case ContainerKindEnum: return "enum";
81698216 case ContainerKindStruct: return "struct";
81708217 case ContainerKindUnion: return "union";
8218 case ContainerKindOpaque: return "opaque";
81718219 }
81728220 zig_unreachable();
81738221}
......@@ -8186,8 +8234,6 @@ Buf *type_bare_name(ZigType *type_entry) {
81868234 return &type_entry->name;
81878235 } else if (is_container(type_entry)) {
81888236 return get_container_scope(type_entry)->bare_name;
8189 } else if (type_entry->id == ZigTypeIdOpaque) {
8190 return type_entry->data.opaque.bare_name;
81918237 } else {
81928238 return &type_entry->name;
81938239 }
src/stage1/analyze.hpp+7-1
......@@ -50,7 +50,13 @@ bool handle_is_ptr(CodeGen *g, ZigType *type_entry);
5050bool type_has_bits(CodeGen *g, ZigType *type_entry);
5151Error type_has_bits2(CodeGen *g, ZigType *type_entry, bool *result);
5252
53Error type_allowed_in_extern(CodeGen *g, ZigType *type_entry, bool *result);
53enum ExternPosition {
54 ExternPositionFunctionParameter,
55 ExternPositionFunctionReturn,
56 ExternPositionOther, // array element, struct field, optional element, etc
57};
58
59Error type_allowed_in_extern(CodeGen *g, ZigType *type_entry, ExternPosition position, bool *result);
5460bool ptr_allows_addr_zero(ZigType *ptr_type);
5561
5662// Deprecated, use `type_is_nonnull_ptr2`
src/stage1/codegen.cpp+12-20
......@@ -161,12 +161,6 @@ static ZigLLVM_CallingConv get_llvm_cc(CodeGen *g, CallingConvention cc) {
161161 return ZigLLVM_Fast;
162162 case CallingConventionC:
163163 return ZigLLVM_C;
164 case CallingConventionCold:
165 if ((g->zig_target->arch == ZigLLVM_x86 ||
166 g->zig_target->arch == ZigLLVM_x86_64) &&
167 g->zig_target->os != OsWindows)
168 return ZigLLVM_Cold;
169 return ZigLLVM_C;
170164 case CallingConventionNaked:
171165 zig_unreachable();
172166 case CallingConventionStdcall:
......@@ -340,7 +334,6 @@ static bool cc_want_sret_attr(CallingConvention cc) {
340334 case CallingConventionNaked:
341335 zig_unreachable();
342336 case CallingConventionC:
343 case CallingConventionCold:
344337 case CallingConventionInterrupt:
345338 case CallingConventionSignal:
346339 case CallingConventionStdcall:
......@@ -449,7 +442,7 @@ static LLVMValueRef make_fn_llvm_value(CodeGen *g, ZigFn *fn) {
449442 ZigLLVMFunctionSetCallingConv(llvm_fn, get_llvm_cc(g, cc));
450443 }
451444
452 bool want_cold = fn->is_cold || cc == CallingConventionCold;
445 bool want_cold = fn->is_cold;
453446 if (want_cold) {
454447 ZigLLVMAddFunctionAttrCold(llvm_fn);
455448 }
......@@ -8819,18 +8812,17 @@ Buf *codegen_generate_builtin_source(CodeGen *g) {
88198812
88208813 static_assert(CallingConventionUnspecified == 0, "");
88218814 static_assert(CallingConventionC == 1, "");
8822 static_assert(CallingConventionCold == 2, "");
8823 static_assert(CallingConventionNaked == 3, "");
8824 static_assert(CallingConventionAsync == 4, "");
8825 static_assert(CallingConventionInterrupt == 5, "");
8826 static_assert(CallingConventionSignal == 6, "");
8827 static_assert(CallingConventionStdcall == 7, "");
8828 static_assert(CallingConventionFastcall == 8, "");
8829 static_assert(CallingConventionVectorcall == 9, "");
8830 static_assert(CallingConventionThiscall == 10, "");
8831 static_assert(CallingConventionAPCS == 11, "");
8832 static_assert(CallingConventionAAPCS == 12, "");
8833 static_assert(CallingConventionAAPCSVFP == 13, "");
8815 static_assert(CallingConventionNaked == 2, "");
8816 static_assert(CallingConventionAsync == 3, "");
8817 static_assert(CallingConventionInterrupt == 4, "");
8818 static_assert(CallingConventionSignal == 5, "");
8819 static_assert(CallingConventionStdcall == 6, "");
8820 static_assert(CallingConventionFastcall == 7, "");
8821 static_assert(CallingConventionVectorcall == 8, "");
8822 static_assert(CallingConventionThiscall == 9, "");
8823 static_assert(CallingConventionAPCS == 10, "");
8824 static_assert(CallingConventionAAPCS == 11, "");
8825 static_assert(CallingConventionAAPCSVFP == 12, "");
88348826
88358827 static_assert(FnInlineAuto == 0, "");
88368828 static_assert(FnInlineAlways == 1, "");
src/stage1/ir.cpp+45-7
......@@ -18917,7 +18917,6 @@ static IrInstGen *ir_analyze_instruction_export(IrAnalyze *ira, IrInstSrcExport
1891718917 add_error_note(ira->codegen, msg, fn_entry->proto_node, buf_sprintf("declared here"));
1891818918 } break;
1891918919 case CallingConventionC:
18920 case CallingConventionCold:
1892118920 case CallingConventionNaked:
1892218921 case CallingConventionInterrupt:
1892318922 case CallingConventionSignal:
......@@ -18965,7 +18964,7 @@ static IrInstGen *ir_analyze_instruction_export(IrAnalyze *ira, IrInstSrcExport
1896518964 break;
1896618965 case ZigTypeIdArray: {
1896718966 bool ok_type;
18968 if ((err = type_allowed_in_extern(ira->codegen, target->value->type->data.array.child_type, &ok_type)))
18967 if ((err = type_allowed_in_extern(ira->codegen, target->value->type->data.array.child_type, ExternPositionOther, &ok_type)))
1896918968 return ira->codegen->invalid_inst_gen;
1897018969
1897118970 if (!ok_type) {
......@@ -20103,7 +20102,7 @@ static IrInstGen *ir_analyze_store_ptr(IrAnalyze *ira, IrInst* source_instr,
2010320102 if (uncasted_value->value->type->id == ZigTypeIdErrorUnion ||
2010420103 uncasted_value->value->type->id == ZigTypeIdErrorSet)
2010520104 {
20106 ir_add_error(ira, source_instr, buf_sprintf("error is discarded"));
20105 ir_add_error(ira, source_instr, buf_sprintf("error is discarded. consider using `try`, `catch`, or `if`"));
2010720106 return ira->codegen->invalid_inst_gen;
2010820107 }
2010920108 return ir_const_void(ira, source_instr);
......@@ -22388,6 +22387,8 @@ static IrInstGen *ir_analyze_container_member_access_inner(IrAnalyze *ira,
2238822387 prefix_name = "enum ";
2238922388 } else if (bare_struct_type->id == ZigTypeIdUnion) {
2239022389 prefix_name = "union ";
22390 } else if (bare_struct_type->id == ZigTypeIdOpaque) {
22391 prefix_name = "opaque type ";
2239122392 } else {
2239222393 prefix_name = "";
2239322394 }
......@@ -22588,7 +22589,7 @@ static IrInstGen *ir_analyze_container_field_ptr(IrAnalyze *ira, Buf *field_name
2258822589 }
2258922590 }
2259022591
22591 if (bare_type->id == ZigTypeIdEnum) {
22592 if (bare_type->id == ZigTypeIdEnum || bare_type->id == ZigTypeIdOpaque) {
2259222593 return ir_analyze_container_member_access_inner(ira, bare_type, field_name,
2259322594 source_instr, container_ptr, container_ptr_src, container_type);
2259422595 }
......@@ -25184,7 +25185,6 @@ static Error ir_make_type_info_value(IrAnalyze *ira, IrInst* source_instr, ZigTy
2518425185 case ZigTypeIdEnumLiteral:
2518525186 case ZigTypeIdUndefined:
2518625187 case ZigTypeIdNull:
25187 case ZigTypeIdOpaque:
2518825188 result = ira->codegen->intern.for_void();
2518925189 break;
2519025190 case ZigTypeIdInt:
......@@ -25738,6 +25738,25 @@ static Error ir_make_type_info_value(IrAnalyze *ira, IrInst* source_instr, ZigTy
2573825738 if ((err = ir_make_type_info_value(ira, source_instr, fn_type, &result)))
2573925739 return err;
2574025740
25741 break;
25742 }
25743 case ZigTypeIdOpaque:
25744 {
25745 result = ira->codegen->pass1_arena->create<ZigValue>();
25746 result->special = ConstValSpecialStatic;
25747 result->type = ir_type_info_get_type(ira, "Opaque", nullptr);
25748
25749 ZigValue **fields = alloc_const_vals_ptrs(ira->codegen, 1);
25750 result->data.x_struct.fields = fields;
25751
25752 // decls: []TypeInfo.Declaration
25753 ensure_field_index(result->type, "decls", 0);
25754 if ((err = ir_make_type_info_decls(ira, source_instr, fields[0],
25755 type_entry->data.opaque.decls_scope, false)))
25756 {
25757 return err;
25758 }
25759
2574125760 break;
2574225761 }
2574325762 case ZigTypeIdFnFrame:
......@@ -26045,6 +26064,21 @@ static ZigType *type_info_to_type(IrAnalyze *ira, IrInst *source_instr, ZigTypeI
2604526064 return get_error_union_type(ira->codegen, err_set_type, payload_type);
2604626065 }
2604726066 case ZigTypeIdOpaque: {
26067 assert(payload->special == ConstValSpecialStatic);
26068 assert(payload->type == ir_type_info_get_type(ira, "Opaque", nullptr));
26069
26070 ZigValue *decls_value = get_const_field(ira, source_instr->source_node, payload, "decls", 0);
26071 if (decls_value == nullptr)
26072 return ira->codegen->invalid_inst_gen->value->type;
26073 assert(decls_value->special == ConstValSpecialStatic);
26074 assert(is_slice(decls_value->type));
26075 ZigValue *decls_len_value = decls_value->data.x_struct.fields[slice_len_index];
26076 size_t decls_len = bigint_as_usize(&decls_len_value->data.x_bigint);
26077 if (decls_len != 0) {
26078 ir_add_error(ira, source_instr, buf_create_from_str("TypeInfo.Struct.decls must be empty for @Type"));
26079 return ira->codegen->invalid_inst_gen->value->type;
26080 }
26081
2604826082 Buf *bare_name = buf_alloc();
2604926083 Buf *full_name = get_anon_type_name(ira->codegen,
2605026084 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,
2949329527 return ira->codegen->invalid_inst_gen;
2949429528
2949529529 if (statement_type->id != ZigTypeIdVoid && statement_type->id != ZigTypeIdUnreachable) {
29496 ir_add_error(ira, &instruction->base.base, buf_sprintf("expression value is ignored"));
29530 if(statement_type->id == ZigTypeIdErrorUnion || statement_type->id == ZigTypeIdErrorSet) {
29531 ir_add_error(ira, &instruction->base.base, buf_sprintf("error is ignored. consider using `try`, `catch`, or `if`"));
29532 }else{
29533 ir_add_error(ira, &instruction->base.base, buf_sprintf("expression value is ignored"));
29534 }
2949729535 }
2949829536
2949929537 return ir_const_void(ira, &instruction->base.base);
......@@ -32708,7 +32746,7 @@ static Error ir_resolve_lazy_raw(AstNode *source_node, ZigValue *val) {
3270832746 return ErrorSemanticAnalyzeFail;
3270932747 } else if (lazy_ptr_type->ptr_len == PtrLenC) {
3271032748 bool ok_type;
32711 if ((err = type_allowed_in_extern(ira->codegen, elem_type, &ok_type)))
32749 if ((err = type_allowed_in_extern(ira->codegen, elem_type, ExternPositionOther, &ok_type)))
3271232750 return err;
3271332751 if (!ok_type) {
3271432752 ir_add_error(ira, &lazy_ptr_type->elem_type->base,
src/stage1/parser.cpp+9
......@@ -2920,6 +2920,7 @@ static AstNode *ast_parse_container_decl_auto(ParseContext *pc) {
29202920// <- KEYWORD_struct
29212921// / KEYWORD_enum (LPAREN Expr RPAREN)?
29222922// / KEYWORD_union (LPAREN (KEYWORD_enum (LPAREN Expr RPAREN)? / Expr) RPAREN)?
2923// / KEYWORD_opaque
29232924static AstNode *ast_parse_container_decl_type(ParseContext *pc) {
29242925 Token *first = eat_token_if(pc, TokenIdKeywordStruct);
29252926 if (first != nullptr) {
......@@ -2929,6 +2930,14 @@ static AstNode *ast_parse_container_decl_type(ParseContext *pc) {
29292930 return res;
29302931 }
29312932
2933 first = eat_token_if(pc, TokenIdKeywordOpaque);
2934 if (first != nullptr) {
2935 AstNode *res = ast_create_node(pc, NodeTypeContainerDecl, first);
2936 res->data.container_decl.init_arg_expr = nullptr;
2937 res->data.container_decl.kind = ContainerKindOpaque;
2938 return res;
2939 }
2940
29322941 first = eat_token_if(pc, TokenIdKeywordEnum);
29332942 if (first != nullptr) {
29342943 AstNode *init_arg_expr = nullptr;
src/stage1/tokenizer.cpp+2
......@@ -133,6 +133,7 @@ static const struct ZigKeyword zig_keywords[] = {
133133 {"noinline", TokenIdKeywordNoInline},
134134 {"nosuspend", TokenIdKeywordNoSuspend},
135135 {"null", TokenIdKeywordNull},
136 {"opaque", TokenIdKeywordOpaque},
136137 {"or", TokenIdKeywordOr},
137138 {"orelse", TokenIdKeywordOrElse},
138139 {"packed", TokenIdKeywordPacked},
......@@ -1595,6 +1596,7 @@ const char * token_name(TokenId id) {
15951596 case TokenIdKeywordNoInline: return "noinline";
15961597 case TokenIdKeywordNoSuspend: return "nosuspend";
15971598 case TokenIdKeywordNull: return "null";
1599 case TokenIdKeywordOpaque: return "opaque";
15981600 case TokenIdKeywordOr: return "or";
15991601 case TokenIdKeywordOrElse: return "orelse";
16001602 case TokenIdKeywordPacked: return "packed";
src/stage1/tokenizer.hpp+1
......@@ -81,6 +81,7 @@ enum TokenId {
8181 TokenIdKeywordNoAlias,
8282 TokenIdKeywordNoSuspend,
8383 TokenIdKeywordNull,
84 TokenIdKeywordOpaque,
8485 TokenIdKeywordOr,
8586 TokenIdKeywordOrElse,
8687 TokenIdKeywordPacked,
src/translate_c.zig+682-682
......@@ -5,7 +5,7 @@ const std = @import("std");
55const assert = std.debug.assert;
66const ast = std.zig.ast;
77const Token = std.zig.Token;
8usingnamespace @import("clang.zig");
8const clang = @import("clang.zig");
99const ctok = std.c.tokenizer;
1010const CToken = std.c.Token;
1111const mem = std.mem;
......@@ -13,7 +13,7 @@ const math = std.math;
1313
1414const CallingConvention = std.builtin.CallingConvention;
1515
16pub const ClangErrMsg = Stage2ErrorMsg;
16pub const ClangErrMsg = clang.Stage2ErrorMsg;
1717
1818pub const Error = error{OutOfMemory};
1919const TypeError = Error || error{UnsupportedType};
......@@ -259,11 +259,11 @@ pub const Context = struct {
259259 errors: std.ArrayListUnmanaged(ast.Error),
260260 source_buffer: *std.ArrayList(u8),
261261 err: Error,
262 source_manager: *ZigClangSourceManager,
262 source_manager: *clang.SourceManager,
263263 decl_table: DeclTable,
264264 alias_list: AliasList,
265265 global_scope: *Scope.Root,
266 clang_context: *ZigClangASTContext,
266 clang_context: *clang.ASTContext,
267267 mangle_count: u32 = 0,
268268 root_decls: std.ArrayListUnmanaged(*ast.Node),
269269
......@@ -284,13 +284,13 @@ pub const Context = struct {
284284 }
285285
286286 /// Convert a clang source location to a file:line:column string
287 fn locStr(c: *Context, loc: ZigClangSourceLocation) ![]u8 {
288 const spelling_loc = ZigClangSourceManager_getSpellingLoc(c.source_manager, loc);
289 const filename_c = ZigClangSourceManager_getFilename(c.source_manager, spelling_loc);
287 fn locStr(c: *Context, loc: clang.SourceLocation) ![]u8 {
288 const spelling_loc = c.source_manager.getSpellingLoc(loc);
289 const filename_c = c.source_manager.getFilename(spelling_loc);
290290 const filename = if (filename_c) |s| try c.str(s) else @as([]const u8, "(no file)");
291291
292 const line = ZigClangSourceManager_getSpellingLineNumber(c.source_manager, spelling_loc);
293 const column = ZigClangSourceManager_getSpellingColumnNumber(c.source_manager, spelling_loc);
292 const line = c.source_manager.getSpellingLineNumber(spelling_loc);
293 const column = c.source_manager.getSpellingColumnNumber(spelling_loc);
294294 return std.fmt.allocPrint(c.arena, "{}:{}:{}", .{ filename, line, column });
295295 }
296296
......@@ -336,7 +336,7 @@ pub fn translate(
336336 errors: *[]ClangErrMsg,
337337 resources_path: [*:0]const u8,
338338) !*ast.Tree {
339 const ast_unit = ZigClangLoadFromCommandLine(
339 const ast_unit = clang.LoadFromCommandLine(
340340 args_begin,
341341 args_end,
342342 &errors.ptr,
......@@ -346,7 +346,7 @@ pub fn translate(
346346 if (errors.len == 0) return error.ASTUnitFailure;
347347 return error.SemanticAnalyzeFail;
348348 };
349 defer ZigClangASTUnit_delete(ast_unit);
349 defer ast_unit.delete();
350350
351351 var source_buffer = std.ArrayList(u8).init(gpa);
352352 defer source_buffer.deinit();
......@@ -360,12 +360,12 @@ pub fn translate(
360360 .gpa = gpa,
361361 .arena = &arena.allocator,
362362 .source_buffer = &source_buffer,
363 .source_manager = ZigClangASTUnit_getSourceManager(ast_unit),
363 .source_manager = ast_unit.getSourceManager(),
364364 .err = undefined,
365365 .decl_table = DeclTable.init(gpa),
366366 .alias_list = AliasList.init(gpa),
367367 .global_scope = try arena.allocator.create(Scope.Root),
368 .clang_context = ZigClangASTUnit_getASTContext(ast_unit).?,
368 .clang_context = ast_unit.getASTContext(),
369369 .global_names = std.StringArrayHashMap(void).init(gpa),
370370 .token_ids = .{},
371371 .token_locs = .{},
......@@ -383,7 +383,7 @@ pub fn translate(
383383
384384 try prepopulateGlobalNameTable(ast_unit, &context);
385385
386 if (!ZigClangASTUnit_visitLocalTopLevelDecls(ast_unit, &context, declVisitorC)) {
386 if (!ast_unit.visitLocalTopLevelDecls(&context, declVisitorC)) {
387387 return context.err;
388388 }
389389
......@@ -421,21 +421,21 @@ pub fn translate(
421421 return tree;
422422}
423423
424fn prepopulateGlobalNameTable(ast_unit: *ZigClangASTUnit, c: *Context) !void {
425 if (!ZigClangASTUnit_visitLocalTopLevelDecls(ast_unit, c, declVisitorNamesOnlyC)) {
424fn prepopulateGlobalNameTable(ast_unit: *clang.ASTUnit, c: *Context) !void {
425 if (!ast_unit.visitLocalTopLevelDecls(c, declVisitorNamesOnlyC)) {
426426 return c.err;
427427 }
428428
429429 // TODO if we see #undef, delete it from the table
430 var it = ZigClangASTUnit_getLocalPreprocessingEntities_begin(ast_unit);
431 const it_end = ZigClangASTUnit_getLocalPreprocessingEntities_end(ast_unit);
430 var it = ast_unit.getLocalPreprocessingEntities_begin();
431 const it_end = ast_unit.getLocalPreprocessingEntities_end();
432432
433433 while (it.I != it_end.I) : (it.I += 1) {
434 const entity = ZigClangPreprocessingRecord_iterator_deref(it);
435 switch (ZigClangPreprocessedEntity_getKind(entity)) {
434 const entity = it.deref();
435 switch (entity.getKind()) {
436436 .MacroDefinitionKind => {
437 const macro = @ptrCast(*ZigClangMacroDefinitionRecord, entity);
438 const raw_name = ZigClangMacroDefinitionRecord_getName_getNameStart(macro);
437 const macro = @ptrCast(*clang.MacroDefinitionRecord, entity);
438 const raw_name = macro.getName_getNameStart();
439439 const name = try c.str(raw_name);
440440 _ = try c.global_names.put(name, {});
441441 },
......@@ -444,7 +444,7 @@ fn prepopulateGlobalNameTable(ast_unit: *ZigClangASTUnit, c: *Context) !void {
444444 }
445445}
446446
447fn declVisitorNamesOnlyC(context: ?*c_void, decl: *const ZigClangDecl) callconv(.C) bool {
447fn declVisitorNamesOnlyC(context: ?*c_void, decl: *const clang.Decl) callconv(.C) bool {
448448 const c = @ptrCast(*Context, @alignCast(@alignOf(Context), context));
449449 declVisitorNamesOnly(c, decl) catch |err| {
450450 c.err = err;
......@@ -453,7 +453,7 @@ fn declVisitorNamesOnlyC(context: ?*c_void, decl: *const ZigClangDecl) callconv(
453453 return true;
454454}
455455
456fn declVisitorC(context: ?*c_void, decl: *const ZigClangDecl) callconv(.C) bool {
456fn declVisitorC(context: ?*c_void, decl: *const clang.Decl) callconv(.C) bool {
457457 const c = @ptrCast(*Context, @alignCast(@alignOf(Context), context));
458458 declVisitor(c, decl) catch |err| {
459459 c.err = err;
......@@ -462,61 +462,61 @@ fn declVisitorC(context: ?*c_void, decl: *const ZigClangDecl) callconv(.C) bool
462462 return true;
463463}
464464
465fn declVisitorNamesOnly(c: *Context, decl: *const ZigClangDecl) Error!void {
466 if (ZigClangDecl_castToNamedDecl(decl)) |named_decl| {
467 const decl_name = try c.str(ZigClangNamedDecl_getName_bytes_begin(named_decl));
465fn declVisitorNamesOnly(c: *Context, decl: *const clang.Decl) Error!void {
466 if (decl.castToNamedDecl()) |named_decl| {
467 const decl_name = try c.str(named_decl.getName_bytes_begin());
468468 _ = try c.global_names.put(decl_name, {});
469469 }
470470}
471471
472fn declVisitor(c: *Context, decl: *const ZigClangDecl) Error!void {
473 switch (ZigClangDecl_getKind(decl)) {
472fn declVisitor(c: *Context, decl: *const clang.Decl) Error!void {
473 switch (decl.getKind()) {
474474 .Function => {
475 return visitFnDecl(c, @ptrCast(*const ZigClangFunctionDecl, decl));
475 return visitFnDecl(c, @ptrCast(*const clang.FunctionDecl, decl));
476476 },
477477 .Typedef => {
478 _ = try transTypeDef(c, @ptrCast(*const ZigClangTypedefNameDecl, decl), true);
478 _ = try transTypeDef(c, @ptrCast(*const clang.TypedefNameDecl, decl), true);
479479 },
480480 .Enum => {
481 _ = try transEnumDecl(c, @ptrCast(*const ZigClangEnumDecl, decl));
481 _ = try transEnumDecl(c, @ptrCast(*const clang.EnumDecl, decl));
482482 },
483483 .Record => {
484 _ = try transRecordDecl(c, @ptrCast(*const ZigClangRecordDecl, decl));
484 _ = try transRecordDecl(c, @ptrCast(*const clang.RecordDecl, decl));
485485 },
486486 .Var => {
487 return visitVarDecl(c, @ptrCast(*const ZigClangVarDecl, decl), null);
487 return visitVarDecl(c, @ptrCast(*const clang.VarDecl, decl), null);
488488 },
489489 .Empty => {
490490 // Do nothing
491491 },
492492 else => {
493 const decl_name = try c.str(ZigClangDecl_getDeclKindName(decl));
494 try emitWarning(c, ZigClangDecl_getLocation(decl), "ignoring {} declaration", .{decl_name});
493 const decl_name = try c.str(decl.getDeclKindName());
494 try emitWarning(c, decl.getLocation(), "ignoring {} declaration", .{decl_name});
495495 },
496496 }
497497}
498498
499fn visitFnDecl(c: *Context, fn_decl: *const ZigClangFunctionDecl) Error!void {
500 const fn_name = try c.str(ZigClangNamedDecl_getName_bytes_begin(@ptrCast(*const ZigClangNamedDecl, fn_decl)));
499fn visitFnDecl(c: *Context, fn_decl: *const clang.FunctionDecl) Error!void {
500 const fn_name = try c.str(@ptrCast(*const clang.NamedDecl, fn_decl).getName_bytes_begin());
501501 if (c.global_scope.sym_table.contains(fn_name))
502502 return; // Avoid processing this decl twice
503503
504504 // Skip this declaration if a proper definition exists
505 if (!ZigClangFunctionDecl_isThisDeclarationADefinition(fn_decl)) {
506 if (ZigClangFunctionDecl_getDefinition(fn_decl)) |def|
505 if (!fn_decl.isThisDeclarationADefinition()) {
506 if (fn_decl.getDefinition()) |def|
507507 return visitFnDecl(c, def);
508508 }
509509
510510 const rp = makeRestorePoint(c);
511 const fn_decl_loc = ZigClangFunctionDecl_getLocation(fn_decl);
512 const has_body = ZigClangFunctionDecl_hasBody(fn_decl);
513 const storage_class = ZigClangFunctionDecl_getStorageClass(fn_decl);
511 const fn_decl_loc = fn_decl.getLocation();
512 const has_body = fn_decl.hasBody();
513 const storage_class = fn_decl.getStorageClass();
514514 const decl_ctx = FnDeclContext{
515515 .fn_name = fn_name,
516516 .has_body = has_body,
517517 .storage_class = storage_class,
518518 .is_export = switch (storage_class) {
519 .None => has_body and !ZigClangFunctionDecl_isInlineSpecified(fn_decl),
519 .None => has_body and !fn_decl.isInlineSpecified(),
520520 .Extern, .Static => false,
521521 .PrivateExtern => return failDecl(c, fn_decl_loc, fn_name, "unsupported storage class: private extern", .{}),
522522 .Auto => unreachable, // Not legal on functions
......@@ -524,27 +524,27 @@ fn visitFnDecl(c: *Context, fn_decl: *const ZigClangFunctionDecl) Error!void {
524524 },
525525 };
526526
527 var fn_qt = ZigClangFunctionDecl_getType(fn_decl);
527 var fn_qt = fn_decl.getType();
528528
529529 const fn_type = while (true) {
530 const fn_type = ZigClangQualType_getTypePtr(fn_qt);
530 const fn_type = fn_qt.getTypePtr();
531531
532 switch (ZigClangType_getTypeClass(fn_type)) {
532 switch (fn_type.getTypeClass()) {
533533 .Attributed => {
534 const attr_type = @ptrCast(*const ZigClangAttributedType, fn_type);
535 fn_qt = ZigClangAttributedType_getEquivalentType(attr_type);
534 const attr_type = @ptrCast(*const clang.AttributedType, fn_type);
535 fn_qt = attr_type.getEquivalentType();
536536 },
537537 .Paren => {
538 const paren_type = @ptrCast(*const ZigClangParenType, fn_type);
539 fn_qt = ZigClangParenType_getInnerType(paren_type);
538 const paren_type = @ptrCast(*const clang.ParenType, fn_type);
539 fn_qt = paren_type.getInnerType();
540540 },
541541 else => break fn_type,
542542 }
543543 } else unreachable;
544544
545 const proto_node = switch (ZigClangType_getTypeClass(fn_type)) {
545 const proto_node = switch (fn_type.getTypeClass()) {
546546 .FunctionProto => blk: {
547 const fn_proto_type = @ptrCast(*const ZigClangFunctionProtoType, fn_type);
547 const fn_proto_type = @ptrCast(*const clang.FunctionProtoType, fn_type);
548548 break :blk transFnProto(rp, fn_decl, fn_proto_type, fn_decl_loc, decl_ctx, true) catch |err| switch (err) {
549549 error.UnsupportedType => {
550550 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 {
553553 };
554554 },
555555 .FunctionNoProto => blk: {
556 const fn_no_proto_type = @ptrCast(*const ZigClangFunctionType, fn_type);
556 const fn_no_proto_type = @ptrCast(*const clang.FunctionType, fn_type);
557557 break :blk transFnNoProto(rp, fn_no_proto_type, fn_decl_loc, decl_ctx, true) catch |err| switch (err) {
558558 error.UnsupportedType => {
559559 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 {
561561 error.OutOfMemory => |e| return e,
562562 };
563563 },
564 else => return failDecl(c, fn_decl_loc, fn_name, "unable to resolve function type {}", .{ZigClangType_getTypeClass(fn_type)}),
564 else => return failDecl(c, fn_decl_loc, fn_name, "unable to resolve function type {}", .{fn_type.getTypeClass()}),
565565 };
566566
567567 if (!decl_ctx.has_body) {
......@@ -570,7 +570,7 @@ fn visitFnDecl(c: *Context, fn_decl: *const ZigClangFunctionDecl) Error!void {
570570 }
571571
572572 // actual function definition with body
573 const body_stmt = ZigClangFunctionDecl_getBody(fn_decl);
573 const body_stmt = fn_decl.getBody();
574574 var block_scope = try Scope.Block.init(rp.c, &c.global_scope.base, false);
575575 defer block_scope.deinit();
576576 var scope = &block_scope.base;
......@@ -582,9 +582,9 @@ fn visitFnDecl(c: *Context, fn_decl: *const ZigClangFunctionDecl) Error!void {
582582 else
583583 return failDecl(c, fn_decl_loc, fn_name, "function {} parameter has no name", .{fn_name});
584584
585 const c_param = ZigClangFunctionDecl_getParamDecl(fn_decl, param_id);
586 const qual_type = ZigClangParmVarDecl_getOriginalType(c_param);
587 const is_const = ZigClangQualType_isConstQualified(qual_type);
585 const c_param = fn_decl.getParamDecl(param_id);
586 const qual_type = c_param.getOriginalType();
587 const is_const = qual_type.isConstQualified();
588588
589589 const mangled_param_name = try block_scope.makeMangledName(c, param_name);
590590
......@@ -613,7 +613,7 @@ fn visitFnDecl(c: *Context, fn_decl: *const ZigClangFunctionDecl) Error!void {
613613 param_id += 1;
614614 }
615615
616 const casted_body = @ptrCast(*const ZigClangCompoundStmt, body_stmt);
616 const casted_body = @ptrCast(*const clang.CompoundStmt, body_stmt);
617617 transCompoundStmtInline(rp, &block_scope.base, casted_body, &block_scope) catch |err| switch (err) {
618618 error.OutOfMemory => |e| return e,
619619 error.UnsupportedTranslation,
......@@ -622,10 +622,10 @@ fn visitFnDecl(c: *Context, fn_decl: *const ZigClangFunctionDecl) Error!void {
622622 };
623623 // add return statement if the function didn't have one
624624 blk: {
625 const fn_ty = @ptrCast(*const ZigClangFunctionType, fn_type);
625 const fn_ty = @ptrCast(*const clang.FunctionType, fn_type);
626626
627 if (ZigClangFunctionType_getNoReturnAttr(fn_ty)) break :blk;
628 const return_qt = ZigClangFunctionType_getReturnType(fn_ty);
627 if (fn_ty.getNoReturnAttr()) break :blk;
628 const return_qt = fn_ty.getReturnType();
629629 if (isCVoid(return_qt)) break :blk;
630630
631631 if (block_scope.statements.items.len > 0) {
......@@ -649,7 +649,7 @@ fn visitFnDecl(c: *Context, fn_decl: *const ZigClangFunctionDecl) Error!void {
649649 .ltoken = try appendToken(rp.c, .Keyword_return, "return"),
650650 .tag = .Return,
651651 }, .{
652 .rhs = transZeroInitExpr(rp, scope, fn_decl_loc, ZigClangQualType_getTypePtr(return_qt)) catch |err| switch (err) {
652 .rhs = transZeroInitExpr(rp, scope, fn_decl_loc, return_qt.getTypePtr()) catch |err| switch (err) {
653653 error.OutOfMemory => |e| return e,
654654 error.UnsupportedTranslation,
655655 error.UnsupportedType,
......@@ -666,14 +666,14 @@ fn visitFnDecl(c: *Context, fn_decl: *const ZigClangFunctionDecl) Error!void {
666666}
667667
668668/// if mangled_name is not null, this var decl was declared in a block scope.
669fn visitVarDecl(c: *Context, var_decl: *const ZigClangVarDecl, mangled_name: ?[]const u8) Error!void {
670 const var_name = mangled_name orelse try c.str(ZigClangNamedDecl_getName_bytes_begin(@ptrCast(*const ZigClangNamedDecl, var_decl)));
669fn visitVarDecl(c: *Context, var_decl: *const clang.VarDecl, mangled_name: ?[]const u8) Error!void {
670 const var_name = mangled_name orelse try c.str(@ptrCast(*const clang.NamedDecl, var_decl).getName_bytes_begin());
671671 if (c.global_scope.sym_table.contains(var_name))
672672 return; // Avoid processing this decl twice
673673 const rp = makeRestorePoint(c);
674674 const visib_tok = if (mangled_name) |_| null else try appendToken(c, .Keyword_pub, "pub");
675675
676 const thread_local_token = if (ZigClangVarDecl_getTLSKind(var_decl) == .None)
676 const thread_local_token = if (var_decl.getTLSKind() == .None)
677677 null
678678 else
679679 try appendToken(c, .Keyword_threadlocal, "threadlocal");
......@@ -683,12 +683,12 @@ fn visitVarDecl(c: *Context, var_decl: *const ZigClangVarDecl, mangled_name: ?[]
683683 // TODO https://github.com/ziglang/zig/issues/3756
684684 // TODO https://github.com/ziglang/zig/issues/1802
685685 const checked_name = if (isZigPrimitiveType(var_name)) try std.fmt.allocPrint(c.arena, "{}_{}", .{ var_name, c.getMangle() }) else var_name;
686 const var_decl_loc = ZigClangVarDecl_getLocation(var_decl);
686 const var_decl_loc = var_decl.getLocation();
687687
688 const qual_type = ZigClangVarDecl_getTypeSourceInfo_getType(var_decl);
689 const storage_class = ZigClangVarDecl_getStorageClass(var_decl);
690 const is_const = ZigClangQualType_isConstQualified(qual_type);
691 const has_init = ZigClangVarDecl_hasInit(var_decl);
688 const qual_type = var_decl.getTypeSourceInfo_getType();
689 const storage_class = var_decl.getStorageClass();
690 const is_const = qual_type.isConstQualified();
691 const has_init = var_decl.hasInit();
692692
693693 // In C extern variables with initializers behave like Zig exports.
694694 // extern int foo = 2;
......@@ -725,7 +725,7 @@ fn visitVarDecl(c: *Context, var_decl: *const ZigClangVarDecl, mangled_name: ?[]
725725 // with the variable type.
726726 if (has_init) {
727727 eq_tok = try appendToken(c, .Equal, "=");
728 init_node = if (ZigClangVarDecl_getInit(var_decl)) |expr|
728 init_node = if (var_decl.getInit()) |expr|
729729 transExprCoercing(rp, &c.global_scope.base, expr, .used, .r_value) catch |err| switch (err) {
730730 error.UnsupportedTranslation,
731731 error.UnsupportedType,
......@@ -758,7 +758,7 @@ fn visitVarDecl(c: *Context, var_decl: *const ZigClangVarDecl, mangled_name: ?[]
758758
759759 const linksection_expr = blk: {
760760 var str_len: usize = undefined;
761 if (ZigClangVarDecl_getSectionAttribute(var_decl, &str_len)) |str_ptr| {
761 if (var_decl.getSectionAttribute(&str_len)) |str_ptr| {
762762 _ = try appendToken(rp.c, .Keyword_linksection, "linksection");
763763 _ = try appendToken(rp.c, .LParen, "(");
764764 const expr = try transCreateNodeStringLiteral(
......@@ -773,7 +773,7 @@ fn visitVarDecl(c: *Context, var_decl: *const ZigClangVarDecl, mangled_name: ?[]
773773 };
774774
775775 const align_expr = blk: {
776 const alignment = ZigClangVarDecl_getAlignedAttribute(var_decl, rp.c.clang_context);
776 const alignment = var_decl.getAlignedAttribute(rp.c.clang_context);
777777 if (alignment != 0) {
778778 _ = try appendToken(rp.c, .Keyword_align, "align");
779779 _ = try appendToken(rp.c, .LParen, "(");
......@@ -803,8 +803,8 @@ fn visitVarDecl(c: *Context, var_decl: *const ZigClangVarDecl, mangled_name: ?[]
803803 return addTopLevelDecl(c, checked_name, &node.base);
804804}
805805
806fn transTypeDefAsBuiltin(c: *Context, typedef_decl: *const ZigClangTypedefNameDecl, builtin_name: []const u8) !*ast.Node {
807 _ = try c.decl_table.put(@ptrToInt(ZigClangTypedefNameDecl_getCanonicalDecl(typedef_decl)), builtin_name);
806fn transTypeDefAsBuiltin(c: *Context, typedef_decl: *const clang.TypedefNameDecl, builtin_name: []const u8) !*ast.Node {
807 _ = try c.decl_table.put(@ptrToInt(typedef_decl.getCanonicalDecl()), builtin_name);
808808 return transCreateNodeIdentifier(c, builtin_name);
809809}
810810
......@@ -833,12 +833,12 @@ fn checkForBuiltinTypedef(checked_name: []const u8) ?[]const u8 {
833833 return null;
834834}
835835
836fn transTypeDef(c: *Context, typedef_decl: *const ZigClangTypedefNameDecl, top_level_visit: bool) Error!?*ast.Node {
837 if (c.decl_table.get(@ptrToInt(ZigClangTypedefNameDecl_getCanonicalDecl(typedef_decl)))) |name|
836fn transTypeDef(c: *Context, typedef_decl: *const clang.TypedefNameDecl, top_level_visit: bool) Error!?*ast.Node {
837 if (c.decl_table.get(@ptrToInt(typedef_decl.getCanonicalDecl()))) |name|
838838 return transCreateNodeIdentifier(c, name); // Avoid processing this decl twice
839839 const rp = makeRestorePoint(c);
840840
841 const typedef_name = try c.str(ZigClangNamedDecl_getName_bytes_begin(@ptrCast(*const ZigClangNamedDecl, typedef_decl)));
841 const typedef_name = try c.str(@ptrCast(*const clang.NamedDecl, typedef_decl).getName_bytes_begin());
842842
843843 // TODO https://github.com/ziglang/zig/issues/3756
844844 // TODO https://github.com/ziglang/zig/issues/1802
......@@ -851,7 +851,7 @@ fn transTypeDef(c: *Context, typedef_decl: *const ZigClangTypedefNameDecl, top_l
851851 return transCreateNodeIdentifier(c, checked_name);
852852 }
853853
854 _ = try c.decl_table.put(@ptrToInt(ZigClangTypedefNameDecl_getCanonicalDecl(typedef_decl)), checked_name);
854 _ = try c.decl_table.put(@ptrToInt(typedef_decl.getCanonicalDecl()), checked_name);
855855 const node = (try transCreateNodeTypedef(rp, typedef_decl, true, checked_name)) orelse return null;
856856 try addTopLevelDecl(c, checked_name, node);
857857 return transCreateNodeIdentifier(c, checked_name);
......@@ -859,7 +859,7 @@ fn transTypeDef(c: *Context, typedef_decl: *const ZigClangTypedefNameDecl, top_l
859859
860860fn transCreateNodeTypedef(
861861 rp: RestorePoint,
862 typedef_decl: *const ZigClangTypedefNameDecl,
862 typedef_decl: *const clang.TypedefNameDecl,
863863 toplevel: bool,
864864 checked_name: []const u8,
865865) Error!?*ast.Node {
......@@ -867,8 +867,8 @@ fn transCreateNodeTypedef(
867867 const mut_tok = try appendToken(rp.c, .Keyword_const, "const");
868868 const name_tok = try appendIdentifier(rp.c, checked_name);
869869 const eq_token = try appendToken(rp.c, .Equal, "=");
870 const child_qt = ZigClangTypedefNameDecl_getUnderlyingType(typedef_decl);
871 const typedef_loc = ZigClangTypedefNameDecl_getLocation(typedef_decl);
870 const child_qt = typedef_decl.getUnderlyingType();
871 const typedef_loc = typedef_decl.getLocation();
872872 const init_node = transQualType(rp, child_qt, typedef_loc) catch |err| switch (err) {
873873 error.UnsupportedType => {
874874 try failDecl(rp.c, typedef_loc, checked_name, "unable to resolve typedef child type", .{});
......@@ -890,12 +890,12 @@ fn transCreateNodeTypedef(
890890 return &node.base;
891891}
892892
893fn transRecordDecl(c: *Context, record_decl: *const ZigClangRecordDecl) Error!?*ast.Node {
894 if (c.decl_table.get(@ptrToInt(ZigClangRecordDecl_getCanonicalDecl(record_decl)))) |name|
893fn transRecordDecl(c: *Context, record_decl: *const clang.RecordDecl) Error!?*ast.Node {
894 if (c.decl_table.get(@ptrToInt(record_decl.getCanonicalDecl()))) |name|
895895 return try transCreateNodeIdentifier(c, name); // Avoid processing this decl twice
896 const record_loc = ZigClangRecordDecl_getLocation(record_decl);
896 const record_loc = record_decl.getLocation();
897897
898 var bare_name = try c.str(ZigClangNamedDecl_getName_bytes_begin(@ptrCast(*const ZigClangNamedDecl, record_decl)));
898 var bare_name = try c.str(@ptrCast(*const clang.NamedDecl, record_decl).getName_bytes_begin());
899899 var is_unnamed = false;
900900 // Record declarations such as `struct {...} x` have no name but they're not
901901 // anonymous hence here isAnonymousStructOrUnion is not needed
......@@ -906,10 +906,10 @@ fn transRecordDecl(c: *Context, record_decl: *const ZigClangRecordDecl) Error!?*
906906
907907 var container_kind_name: []const u8 = undefined;
908908 var container_kind: std.zig.Token.Id = undefined;
909 if (ZigClangRecordDecl_isUnion(record_decl)) {
909 if (record_decl.isUnion()) {
910910 container_kind_name = "union";
911911 container_kind = .Keyword_union;
912 } else if (ZigClangRecordDecl_isStruct(record_decl)) {
912 } else if (record_decl.isStruct()) {
913913 container_kind_name = "struct";
914914 container_kind = .Keyword_struct;
915915 } else {
......@@ -918,7 +918,7 @@ fn transRecordDecl(c: *Context, record_decl: *const ZigClangRecordDecl) Error!?*
918918 }
919919
920920 const name = try std.fmt.allocPrint(c.arena, "{}_{}", .{ container_kind_name, bare_name });
921 _ = try c.decl_table.put(@ptrToInt(ZigClangRecordDecl_getCanonicalDecl(record_decl)), name);
921 _ = try c.decl_table.put(@ptrToInt(record_decl.getCanonicalDecl()), name);
922922
923923 const visib_tok = if (!is_unnamed) try appendToken(c, .Keyword_pub, "pub") else null;
924924 const mut_tok = try appendToken(c, .Keyword_const, "const");
......@@ -929,13 +929,13 @@ fn transRecordDecl(c: *Context, record_decl: *const ZigClangRecordDecl) Error!?*
929929 var semicolon: ast.TokenIndex = undefined;
930930 const init_node = blk: {
931931 const rp = makeRestorePoint(c);
932 const record_def = ZigClangRecordDecl_getDefinition(record_decl) orelse {
933 const opaque = try transCreateNodeOpaqueType(c);
932 const record_def = record_decl.getDefinition() orelse {
933 const opaque_type = try transCreateNodeOpaqueType(c);
934934 semicolon = try appendToken(c, .Semicolon, ";");
935 break :blk opaque;
935 break :blk opaque_type;
936936 };
937937
938 const layout_tok = try if (ZigClangRecordDecl_getPackedAttribute(record_decl))
938 const layout_tok = try if (record_decl.getPackedAttribute())
939939 appendToken(c, .Keyword_packed, "packed")
940940 else
941941 appendToken(c, .Keyword_extern, "extern");
......@@ -946,30 +946,30 @@ fn transRecordDecl(c: *Context, record_decl: *const ZigClangRecordDecl) Error!?*
946946 defer fields_and_decls.deinit();
947947
948948 var unnamed_field_count: u32 = 0;
949 var it = ZigClangRecordDecl_field_begin(record_def);
950 const end_it = ZigClangRecordDecl_field_end(record_def);
951 while (ZigClangRecordDecl_field_iterator_neq(it, end_it)) : (it = ZigClangRecordDecl_field_iterator_next(it)) {
952 const field_decl = ZigClangRecordDecl_field_iterator_deref(it);
953 const field_loc = ZigClangFieldDecl_getLocation(field_decl);
954 const field_qt = ZigClangFieldDecl_getType(field_decl);
955
956 if (ZigClangFieldDecl_isBitField(field_decl)) {
957 const opaque = try transCreateNodeOpaqueType(c);
949 var it = record_def.field_begin();
950 const end_it = record_def.field_end();
951 while (it.neq(end_it)) : (it = it.next()) {
952 const field_decl = it.deref();
953 const field_loc = field_decl.getLocation();
954 const field_qt = field_decl.getType();
955
956 if (field_decl.isBitField()) {
957 const opaque_type = try transCreateNodeOpaqueType(c);
958958 semicolon = try appendToken(c, .Semicolon, ";");
959959 try emitWarning(c, field_loc, "{} demoted to opaque type - has bitfield", .{container_kind_name});
960 break :blk opaque;
960 break :blk opaque_type;
961961 }
962962
963 if (ZigClangType_isIncompleteOrZeroLengthArrayType(qualTypeCanon(field_qt), c.clang_context)) {
964 const opaque = try transCreateNodeOpaqueType(c);
963 if (qualTypeCanon(field_qt).isIncompleteOrZeroLengthArrayType(c.clang_context)) {
964 const opaque_type = try transCreateNodeOpaqueType(c);
965965 semicolon = try appendToken(c, .Semicolon, ";");
966966 try emitWarning(c, field_loc, "{} demoted to opaque type - has variable length array", .{container_kind_name});
967 break :blk opaque;
967 break :blk opaque_type;
968968 }
969969
970970 var is_anon = false;
971 var raw_name = try c.str(ZigClangNamedDecl_getName_bytes_begin(@ptrCast(*const ZigClangNamedDecl, field_decl)));
972 if (ZigClangFieldDecl_isAnonymousStructOrUnion(field_decl) or raw_name.len == 0) {
971 var raw_name = try c.str(@ptrCast(*const clang.NamedDecl, field_decl).getName_bytes_begin());
972 if (field_decl.isAnonymousStructOrUnion() or raw_name.len == 0) {
973973 // Context.getMangle() is not used here because doing so causes unpredictable field names for anonymous fields.
974974 raw_name = try std.fmt.allocPrint(c.arena, "unnamed_{}", .{unnamed_field_count});
975975 unnamed_field_count += 1;
......@@ -979,16 +979,16 @@ fn transRecordDecl(c: *Context, record_decl: *const ZigClangRecordDecl) Error!?*
979979 _ = try appendToken(c, .Colon, ":");
980980 const field_type = transQualType(rp, field_qt, field_loc) catch |err| switch (err) {
981981 error.UnsupportedType => {
982 const opaque = try transCreateNodeOpaqueType(c);
982 const opaque_type = try transCreateNodeOpaqueType(c);
983983 semicolon = try appendToken(c, .Semicolon, ";");
984984 try emitWarning(c, record_loc, "{} demoted to opaque type - unable to translate type of field {}", .{ container_kind_name, raw_name });
985 break :blk opaque;
985 break :blk opaque_type;
986986 },
987987 else => |e| return e,
988988 };
989989
990990 const align_expr = blk_2: {
991 const alignment = ZigClangFieldDecl_getAlignedAttribute(field_decl, rp.c.clang_context);
991 const alignment = field_decl.getAlignedAttribute(rp.c.clang_context);
992992 if (alignment != 0) {
993993 _ = try appendToken(rp.c, .Keyword_align, "align");
994994 _ = try appendToken(rp.c, .LParen, "(");
......@@ -1013,7 +1013,7 @@ fn transRecordDecl(c: *Context, record_decl: *const ZigClangRecordDecl) Error!?*
10131013
10141014 if (is_anon) {
10151015 _ = try c.decl_table.put(
1016 @ptrToInt(ZigClangFieldDecl_getCanonicalDecl(field_decl)),
1016 @ptrToInt(field_decl.getCanonicalDecl()),
10171017 raw_name,
10181018 );
10191019 }
......@@ -1051,13 +1051,13 @@ fn transRecordDecl(c: *Context, record_decl: *const ZigClangRecordDecl) Error!?*
10511051 return transCreateNodeIdentifier(c, name);
10521052}
10531053
1054fn transEnumDecl(c: *Context, enum_decl: *const ZigClangEnumDecl) Error!?*ast.Node {
1055 if (c.decl_table.get(@ptrToInt(ZigClangEnumDecl_getCanonicalDecl(enum_decl)))) |name|
1054fn transEnumDecl(c: *Context, enum_decl: *const clang.EnumDecl) Error!?*ast.Node {
1055 if (c.decl_table.get(@ptrToInt(enum_decl.getCanonicalDecl()))) |name|
10561056 return try transCreateNodeIdentifier(c, name); // Avoid processing this decl twice
10571057 const rp = makeRestorePoint(c);
1058 const enum_loc = ZigClangEnumDecl_getLocation(enum_decl);
1058 const enum_loc = enum_decl.getLocation();
10591059
1060 var bare_name = try c.str(ZigClangNamedDecl_getName_bytes_begin(@ptrCast(*const ZigClangNamedDecl, enum_decl)));
1060 var bare_name = try c.str(@ptrCast(*const clang.NamedDecl, enum_decl).getName_bytes_begin());
10611061 var is_unnamed = false;
10621062 if (bare_name.len == 0) {
10631063 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
10651065 }
10661066
10671067 const name = try std.fmt.allocPrint(c.arena, "enum_{}", .{bare_name});
1068 _ = try c.decl_table.put(@ptrToInt(ZigClangEnumDecl_getCanonicalDecl(enum_decl)), name);
1068 _ = try c.decl_table.put(@ptrToInt(enum_decl.getCanonicalDecl()), name);
10691069
10701070 const visib_tok = if (!is_unnamed) try appendToken(c, .Keyword_pub, "pub") else null;
10711071 const mut_tok = try appendToken(c, .Keyword_const, "const");
10721072 const name_tok = try appendIdentifier(c, name);
10731073 const eq_token = try appendToken(c, .Equal, "=");
10741074
1075 const init_node = if (ZigClangEnumDecl_getDefinition(enum_decl)) |enum_def| blk: {
1075 const init_node = if (enum_decl.getDefinition()) |enum_def| blk: {
10761076 var pure_enum = true;
1077 var it = ZigClangEnumDecl_enumerator_begin(enum_def);
1078 var end_it = ZigClangEnumDecl_enumerator_end(enum_def);
1079 while (ZigClangEnumDecl_enumerator_iterator_neq(it, end_it)) : (it = ZigClangEnumDecl_enumerator_iterator_next(it)) {
1080 const enum_const = ZigClangEnumDecl_enumerator_iterator_deref(it);
1081 if (ZigClangEnumConstantDecl_getInitExpr(enum_const)) |_| {
1077 var it = enum_def.enumerator_begin();
1078 var end_it = enum_def.enumerator_end();
1079 while (it.neq(end_it)) : (it = it.next()) {
1080 const enum_const = it.deref();
1081 if (enum_const.getInitExpr()) |_| {
10821082 pure_enum = false;
10831083 break;
10841084 }
......@@ -1090,7 +1090,7 @@ fn transEnumDecl(c: *Context, enum_decl: *const ZigClangEnumDecl) Error!?*ast.No
10901090 var fields_and_decls = std.ArrayList(*ast.Node).init(c.gpa);
10911091 defer fields_and_decls.deinit();
10921092
1093 const int_type = ZigClangEnumDecl_getIntegerType(enum_decl);
1093 const int_type = enum_decl.getIntegerType();
10941094 // The underlying type may be null in case of forward-declared enum
10951095 // types, while that's not ISO-C compliant many compilers allow this and
10961096 // 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
11151115
11161116 const lbrace_token = try appendToken(c, .LBrace, "{");
11171117
1118 it = ZigClangEnumDecl_enumerator_begin(enum_def);
1119 end_it = ZigClangEnumDecl_enumerator_end(enum_def);
1120 while (ZigClangEnumDecl_enumerator_iterator_neq(it, end_it)) : (it = ZigClangEnumDecl_enumerator_iterator_next(it)) {
1121 const enum_const = ZigClangEnumDecl_enumerator_iterator_deref(it);
1118 it = enum_def.enumerator_begin();
1119 end_it = enum_def.enumerator_end();
1120 while (it.neq(end_it)) : (it = it.next()) {
1121 const enum_const = it.deref();
11221122
1123 const enum_val_name = try c.str(ZigClangNamedDecl_getName_bytes_begin(@ptrCast(*const ZigClangNamedDecl, enum_const)));
1123 const enum_val_name = try c.str(@ptrCast(*const clang.NamedDecl, enum_const).getName_bytes_begin());
11241124
11251125 const field_name = if (!is_unnamed and mem.startsWith(u8, enum_val_name, bare_name))
11261126 enum_val_name[bare_name.len..]
......@@ -1131,7 +1131,7 @@ fn transEnumDecl(c: *Context, enum_decl: *const ZigClangEnumDecl) Error!?*ast.No
11311131
11321132 const int_node = if (!pure_enum) blk_2: {
11331133 _ = try appendToken(c, .Colon, "=");
1134 break :blk_2 try transCreateNodeAPInt(c, ZigClangEnumConstantDecl_getInitVal(enum_const));
1134 break :blk_2 try transCreateNodeAPInt(c, enum_const.getInitVal());
11351135 } else
11361136 null;
11371137
......@@ -1257,23 +1257,23 @@ const LRValue = enum {
12571257fn transStmt(
12581258 rp: RestorePoint,
12591259 scope: *Scope,
1260 stmt: *const ZigClangStmt,
1260 stmt: *const clang.Stmt,
12611261 result_used: ResultUsed,
12621262 lrvalue: LRValue,
12631263) TransError!*ast.Node {
1264 const sc = ZigClangStmt_getStmtClass(stmt);
1264 const sc = stmt.getStmtClass();
12651265 switch (sc) {
1266 .BinaryOperatorClass => return transBinaryOperator(rp, scope, @ptrCast(*const ZigClangBinaryOperator, stmt), result_used),
1267 .CompoundStmtClass => return transCompoundStmt(rp, scope, @ptrCast(*const ZigClangCompoundStmt, stmt)),
1268 .CStyleCastExprClass => return transCStyleCastExprClass(rp, scope, @ptrCast(*const ZigClangCStyleCastExpr, stmt), result_used, lrvalue),
1269 .DeclStmtClass => return transDeclStmt(rp, scope, @ptrCast(*const ZigClangDeclStmt, stmt)),
1270 .DeclRefExprClass => return transDeclRefExpr(rp, scope, @ptrCast(*const ZigClangDeclRefExpr, stmt), lrvalue),
1271 .ImplicitCastExprClass => return transImplicitCastExpr(rp, scope, @ptrCast(*const ZigClangImplicitCastExpr, stmt), result_used),
1272 .IntegerLiteralClass => return transIntegerLiteral(rp, scope, @ptrCast(*const ZigClangIntegerLiteral, stmt), result_used, .with_as),
1273 .ReturnStmtClass => return transReturnStmt(rp, scope, @ptrCast(*const ZigClangReturnStmt, stmt)),
1274 .StringLiteralClass => return transStringLiteral(rp, scope, @ptrCast(*const ZigClangStringLiteral, stmt), result_used),
1266 .BinaryOperatorClass => return transBinaryOperator(rp, scope, @ptrCast(*const clang.BinaryOperator, stmt), result_used),
1267 .CompoundStmtClass => return transCompoundStmt(rp, scope, @ptrCast(*const clang.CompoundStmt, stmt)),
1268 .CStyleCastExprClass => return transCStyleCastExprClass(rp, scope, @ptrCast(*const clang.CStyleCastExpr, stmt), result_used, lrvalue),
1269 .DeclStmtClass => return transDeclStmt(rp, scope, @ptrCast(*const clang.DeclStmt, stmt)),
1270 .DeclRefExprClass => return transDeclRefExpr(rp, scope, @ptrCast(*const clang.DeclRefExpr, stmt), lrvalue),
1271 .ImplicitCastExprClass => return transImplicitCastExpr(rp, scope, @ptrCast(*const clang.ImplicitCastExpr, stmt), result_used),
1272 .IntegerLiteralClass => return transIntegerLiteral(rp, scope, @ptrCast(*const clang.IntegerLiteral, stmt), result_used, .with_as),
1273 .ReturnStmtClass => return transReturnStmt(rp, scope, @ptrCast(*const clang.ReturnStmt, stmt)),
1274 .StringLiteralClass => return transStringLiteral(rp, scope, @ptrCast(*const clang.StringLiteral, stmt), result_used),
12751275 .ParenExprClass => {
1276 const expr = try transExpr(rp, scope, ZigClangParenExpr_getSubExpr(@ptrCast(*const ZigClangParenExpr, stmt)), .used, lrvalue);
1276 const expr = try transExpr(rp, scope, @ptrCast(*const clang.ParenExpr, stmt).getSubExpr(), .used, lrvalue);
12771277 if (expr.tag == .GroupedExpression) return maybeSuppressResult(rp, scope, result_used, expr);
12781278 const node = try rp.c.arena.create(ast.Node.GroupedExpression);
12791279 node.* = .{
......@@ -1283,11 +1283,11 @@ fn transStmt(
12831283 };
12841284 return maybeSuppressResult(rp, scope, result_used, &node.base);
12851285 },
1286 .InitListExprClass => return transInitListExpr(rp, scope, @ptrCast(*const ZigClangInitListExpr, stmt), result_used),
1287 .ImplicitValueInitExprClass => return transImplicitValueInitExpr(rp, scope, @ptrCast(*const ZigClangExpr, stmt), result_used),
1288 .IfStmtClass => return transIfStmt(rp, scope, @ptrCast(*const ZigClangIfStmt, stmt)),
1289 .WhileStmtClass => return transWhileLoop(rp, scope, @ptrCast(*const ZigClangWhileStmt, stmt)),
1290 .DoStmtClass => return transDoWhileLoop(rp, scope, @ptrCast(*const ZigClangDoStmt, stmt)),
1286 .InitListExprClass => return transInitListExpr(rp, scope, @ptrCast(*const clang.InitListExpr, stmt), result_used),
1287 .ImplicitValueInitExprClass => return transImplicitValueInitExpr(rp, scope, @ptrCast(*const clang.Expr, stmt), result_used),
1288 .IfStmtClass => return transIfStmt(rp, scope, @ptrCast(*const clang.IfStmt, stmt)),
1289 .WhileStmtClass => return transWhileLoop(rp, scope, @ptrCast(*const clang.WhileStmt, stmt)),
1290 .DoStmtClass => return transDoWhileLoop(rp, scope, @ptrCast(*const clang.DoStmt, stmt)),
12911291 .NullStmtClass => {
12921292 const block = try rp.c.createBlock(0);
12931293 block.rbrace = try appendToken(rp.c, .RBrace, "}");
......@@ -1295,29 +1295,29 @@ fn transStmt(
12951295 },
12961296 .ContinueStmtClass => return try transCreateNodeContinue(rp.c),
12971297 .BreakStmtClass => return transBreak(rp, scope),
1298 .ForStmtClass => return transForLoop(rp, scope, @ptrCast(*const ZigClangForStmt, stmt)),
1299 .FloatingLiteralClass => return transFloatingLiteral(rp, scope, @ptrCast(*const ZigClangFloatingLiteral, stmt), result_used),
1298 .ForStmtClass => return transForLoop(rp, scope, @ptrCast(*const clang.ForStmt, stmt)),
1299 .FloatingLiteralClass => return transFloatingLiteral(rp, scope, @ptrCast(*const clang.FloatingLiteral, stmt), result_used),
13001300 .ConditionalOperatorClass => {
1301 return transConditionalOperator(rp, scope, @ptrCast(*const ZigClangConditionalOperator, stmt), result_used);
1301 return transConditionalOperator(rp, scope, @ptrCast(*const clang.ConditionalOperator, stmt), result_used);
13021302 },
13031303 .BinaryConditionalOperatorClass => {
1304 return transBinaryConditionalOperator(rp, scope, @ptrCast(*const ZigClangBinaryConditionalOperator, stmt), result_used);
1304 return transBinaryConditionalOperator(rp, scope, @ptrCast(*const clang.BinaryConditionalOperator, stmt), result_used);
13051305 },
1306 .SwitchStmtClass => return transSwitch(rp, scope, @ptrCast(*const ZigClangSwitchStmt, stmt)),
1307 .CaseStmtClass => return transCase(rp, scope, @ptrCast(*const ZigClangCaseStmt, stmt)),
1308 .DefaultStmtClass => return transDefault(rp, scope, @ptrCast(*const ZigClangDefaultStmt, stmt)),
1309 .ConstantExprClass => return transConstantExpr(rp, scope, @ptrCast(*const ZigClangExpr, stmt), result_used),
1310 .PredefinedExprClass => return transPredefinedExpr(rp, scope, @ptrCast(*const ZigClangPredefinedExpr, stmt), result_used),
1311 .CharacterLiteralClass => return transCharLiteral(rp, scope, @ptrCast(*const ZigClangCharacterLiteral, stmt), result_used, .with_as),
1312 .StmtExprClass => return transStmtExpr(rp, scope, @ptrCast(*const ZigClangStmtExpr, stmt), result_used),
1313 .MemberExprClass => return transMemberExpr(rp, scope, @ptrCast(*const ZigClangMemberExpr, stmt), result_used),
1314 .ArraySubscriptExprClass => return transArrayAccess(rp, scope, @ptrCast(*const ZigClangArraySubscriptExpr, stmt), result_used),
1315 .CallExprClass => return transCallExpr(rp, scope, @ptrCast(*const ZigClangCallExpr, stmt), result_used),
1316 .UnaryExprOrTypeTraitExprClass => return transUnaryExprOrTypeTraitExpr(rp, scope, @ptrCast(*const ZigClangUnaryExprOrTypeTraitExpr, stmt), result_used),
1317 .UnaryOperatorClass => return transUnaryOperator(rp, scope, @ptrCast(*const ZigClangUnaryOperator, stmt), result_used),
1318 .CompoundAssignOperatorClass => return transCompoundAssignOperator(rp, scope, @ptrCast(*const ZigClangCompoundAssignOperator, stmt), result_used),
1306 .SwitchStmtClass => return transSwitch(rp, scope, @ptrCast(*const clang.SwitchStmt, stmt)),
1307 .CaseStmtClass => return transCase(rp, scope, @ptrCast(*const clang.CaseStmt, stmt)),
1308 .DefaultStmtClass => return transDefault(rp, scope, @ptrCast(*const clang.DefaultStmt, stmt)),
1309 .ConstantExprClass => return transConstantExpr(rp, scope, @ptrCast(*const clang.Expr, stmt), result_used),
1310 .PredefinedExprClass => return transPredefinedExpr(rp, scope, @ptrCast(*const clang.PredefinedExpr, stmt), result_used),
1311 .CharacterLiteralClass => return transCharLiteral(rp, scope, @ptrCast(*const clang.CharacterLiteral, stmt), result_used, .with_as),
1312 .StmtExprClass => return transStmtExpr(rp, scope, @ptrCast(*const clang.StmtExpr, stmt), result_used),
1313 .MemberExprClass => return transMemberExpr(rp, scope, @ptrCast(*const clang.MemberExpr, stmt), result_used),
1314 .ArraySubscriptExprClass => return transArrayAccess(rp, scope, @ptrCast(*const clang.ArraySubscriptExpr, stmt), result_used),
1315 .CallExprClass => return transCallExpr(rp, scope, @ptrCast(*const clang.CallExpr, stmt), result_used),
1316 .UnaryExprOrTypeTraitExprClass => return transUnaryExprOrTypeTraitExpr(rp, scope, @ptrCast(*const clang.UnaryExprOrTypeTraitExpr, stmt), result_used),
1317 .UnaryOperatorClass => return transUnaryOperator(rp, scope, @ptrCast(*const clang.UnaryOperator, stmt), result_used),
1318 .CompoundAssignOperatorClass => return transCompoundAssignOperator(rp, scope, @ptrCast(*const clang.CompoundAssignOperator, stmt), result_used),
13191319 .OpaqueValueExprClass => {
1320 const source_expr = ZigClangOpaqueValueExpr_getSourceExpr(@ptrCast(*const ZigClangOpaqueValueExpr, stmt)).?;
1320 const source_expr = @ptrCast(*const clang.OpaqueValueExpr, stmt).getSourceExpr().?;
13211321 const expr = try transExpr(rp, scope, source_expr, .used, lrvalue);
13221322 if (expr.tag == .GroupedExpression) return maybeSuppressResult(rp, scope, result_used, expr);
13231323 const node = try rp.c.arena.create(ast.Node.GroupedExpression);
......@@ -1332,7 +1332,7 @@ fn transStmt(
13321332 return revertAndWarn(
13331333 rp,
13341334 error.UnsupportedTranslation,
1335 ZigClangStmt_getBeginLoc(stmt),
1335 stmt.getBeginLoc(),
13361336 "TODO implement translation of stmt class {}",
13371337 .{@tagName(sc)},
13381338 );
......@@ -1343,24 +1343,24 @@ fn transStmt(
13431343fn transBinaryOperator(
13441344 rp: RestorePoint,
13451345 scope: *Scope,
1346 stmt: *const ZigClangBinaryOperator,
1346 stmt: *const clang.BinaryOperator,
13471347 result_used: ResultUsed,
13481348) TransError!*ast.Node {
1349 const op = ZigClangBinaryOperator_getOpcode(stmt);
1350 const qt = ZigClangBinaryOperator_getType(stmt);
1349 const op = stmt.getOpcode();
1350 const qt = stmt.getType();
13511351 var op_token: ast.TokenIndex = undefined;
13521352 var op_id: ast.Node.Tag = undefined;
13531353 switch (op) {
1354 .Assign => return try transCreateNodeAssign(rp, scope, result_used, ZigClangBinaryOperator_getLHS(stmt), ZigClangBinaryOperator_getRHS(stmt)),
1354 .Assign => return try transCreateNodeAssign(rp, scope, result_used, stmt.getLHS(), stmt.getRHS()),
13551355 .Comma => {
13561356 const block_scope = try scope.findBlockScope(rp.c);
13571357 const expr = block_scope.base.parent == scope;
13581358 const lparen = if (expr) try appendToken(rp.c, .LParen, "(") else undefined;
13591359
1360 const lhs = try transExpr(rp, &block_scope.base, ZigClangBinaryOperator_getLHS(stmt), .unused, .r_value);
1360 const lhs = try transExpr(rp, &block_scope.base, stmt.getLHS(), .unused, .r_value);
13611361 try block_scope.statements.append(lhs);
13621362
1363 const rhs = try transExpr(rp, &block_scope.base, ZigClangBinaryOperator_getRHS(stmt), .used, .r_value);
1363 const rhs = try transExpr(rp, &block_scope.base, stmt.getRHS(), .used, .r_value);
13641364 if (expr) {
13651365 _ = try appendToken(rp.c, .Semicolon, ";");
13661366 const break_node = try transCreateNodeBreak(rp.c, block_scope.label, rhs);
......@@ -1382,9 +1382,9 @@ fn transBinaryOperator(
13821382 if (cIsSignedInteger(qt)) {
13831383 // signed integer division uses @divTrunc
13841384 const div_trunc_node = try rp.c.createBuiltinCall("@divTrunc", 2);
1385 div_trunc_node.params()[0] = try transExpr(rp, scope, ZigClangBinaryOperator_getLHS(stmt), .used, .l_value);
1385 div_trunc_node.params()[0] = try transExpr(rp, scope, stmt.getLHS(), .used, .l_value);
13861386 _ = try appendToken(rp.c, .Comma, ",");
1387 const rhs = try transExpr(rp, scope, ZigClangBinaryOperator_getRHS(stmt), .used, .r_value);
1387 const rhs = try transExpr(rp, scope, stmt.getRHS(), .used, .r_value);
13881388 div_trunc_node.params()[1] = rhs;
13891389 div_trunc_node.rparen_token = try appendToken(rp.c, .RParen, ")");
13901390 return maybeSuppressResult(rp, scope, result_used, &div_trunc_node.base);
......@@ -1394,9 +1394,9 @@ fn transBinaryOperator(
13941394 if (cIsSignedInteger(qt)) {
13951395 // signed integer division uses @rem
13961396 const rem_node = try rp.c.createBuiltinCall("@rem", 2);
1397 rem_node.params()[0] = try transExpr(rp, scope, ZigClangBinaryOperator_getLHS(stmt), .used, .l_value);
1397 rem_node.params()[0] = try transExpr(rp, scope, stmt.getLHS(), .used, .l_value);
13981398 _ = try appendToken(rp.c, .Comma, ",");
1399 const rhs = try transExpr(rp, scope, ZigClangBinaryOperator_getRHS(stmt), .used, .r_value);
1399 const rhs = try transExpr(rp, scope, stmt.getRHS(), .used, .r_value);
14001400 rem_node.params()[1] = rhs;
14011401 rem_node.rparen_token = try appendToken(rp.c, .RParen, ")");
14021402 return maybeSuppressResult(rp, scope, result_used, &rem_node.base);
......@@ -1420,7 +1420,7 @@ fn transBinaryOperator(
14201420 },
14211421 else => {},
14221422 }
1423 const lhs_node = try transExpr(rp, scope, ZigClangBinaryOperator_getLHS(stmt), .used, .l_value);
1423 const lhs_node = try transExpr(rp, scope, stmt.getLHS(), .used, .l_value);
14241424 switch (op) {
14251425 .Add => {
14261426 if (cIsUnsignedInteger(qt)) {
......@@ -1498,7 +1498,7 @@ fn transBinaryOperator(
14981498 else => unreachable,
14991499 }
15001500
1501 const rhs_node = try transExpr(rp, scope, ZigClangBinaryOperator_getRHS(stmt), .used, .r_value);
1501 const rhs_node = try transExpr(rp, scope, stmt.getRHS(), .used, .r_value);
15021502
15031503 const lhs = if (isBoolRes(lhs_node)) init: {
15041504 const cast_node = try rp.c.createBuiltinCall("@boolToInt", 1);
......@@ -1520,18 +1520,18 @@ fn transBinaryOperator(
15201520fn transCompoundStmtInline(
15211521 rp: RestorePoint,
15221522 parent_scope: *Scope,
1523 stmt: *const ZigClangCompoundStmt,
1523 stmt: *const clang.CompoundStmt,
15241524 block: *Scope.Block,
15251525) TransError!void {
1526 var it = ZigClangCompoundStmt_body_begin(stmt);
1527 const end_it = ZigClangCompoundStmt_body_end(stmt);
1526 var it = stmt.body_begin();
1527 const end_it = stmt.body_end();
15281528 while (it != end_it) : (it += 1) {
15291529 const result = try transStmt(rp, parent_scope, it[0], .unused, .r_value);
15301530 try block.statements.append(result);
15311531 }
15321532}
15331533
1534fn transCompoundStmt(rp: RestorePoint, scope: *Scope, stmt: *const ZigClangCompoundStmt) TransError!*ast.Node {
1534fn transCompoundStmt(rp: RestorePoint, scope: *Scope, stmt: *const clang.CompoundStmt) TransError!*ast.Node {
15351535 var block_scope = try Scope.Block.init(rp.c, scope, false);
15361536 defer block_scope.deinit();
15371537 try transCompoundStmtInline(rp, &block_scope.base, stmt, &block_scope);
......@@ -1541,17 +1541,17 @@ fn transCompoundStmt(rp: RestorePoint, scope: *Scope, stmt: *const ZigClangCompo
15411541fn transCStyleCastExprClass(
15421542 rp: RestorePoint,
15431543 scope: *Scope,
1544 stmt: *const ZigClangCStyleCastExpr,
1544 stmt: *const clang.CStyleCastExpr,
15451545 result_used: ResultUsed,
15461546 lrvalue: LRValue,
15471547) TransError!*ast.Node {
1548 const sub_expr = ZigClangCStyleCastExpr_getSubExpr(stmt);
1548 const sub_expr = stmt.getSubExpr();
15491549 const cast_node = (try transCCast(
15501550 rp,
15511551 scope,
1552 ZigClangCStyleCastExpr_getBeginLoc(stmt),
1553 ZigClangCStyleCastExpr_getType(stmt),
1554 ZigClangExpr_getType(sub_expr),
1552 stmt.getBeginLoc(),
1553 stmt.getType(),
1554 sub_expr.getType(),
15551555 try transExpr(rp, scope, sub_expr, .used, lrvalue),
15561556 ));
15571557 return maybeSuppressResult(rp, scope, result_used, cast_node);
......@@ -1560,22 +1560,20 @@ fn transCStyleCastExprClass(
15601560fn transDeclStmtOne(
15611561 rp: RestorePoint,
15621562 scope: *Scope,
1563 decl: *const ZigClangDecl,
1563 decl: *const clang.Decl,
15641564 block_scope: *Scope.Block,
15651565) TransError!*ast.Node {
15661566 const c = rp.c;
15671567
1568 switch (ZigClangDecl_getKind(decl)) {
1568 switch (decl.getKind()) {
15691569 .Var => {
1570 const var_decl = @ptrCast(*const ZigClangVarDecl, decl);
1570 const var_decl = @ptrCast(*const clang.VarDecl, decl);
15711571
1572 const qual_type = ZigClangVarDecl_getTypeSourceInfo_getType(var_decl);
1573 const name = try c.str(ZigClangNamedDecl_getName_bytes_begin(
1574 @ptrCast(*const ZigClangNamedDecl, var_decl),
1575 ));
1572 const qual_type = var_decl.getTypeSourceInfo_getType();
1573 const name = try c.str(@ptrCast(*const clang.NamedDecl, var_decl).getName_bytes_begin());
15761574 const mangled_name = try block_scope.makeMangledName(c, name);
15771575
1578 switch (ZigClangVarDecl_getStorageClass(var_decl)) {
1576 switch (var_decl.getStorageClass()) {
15791577 .Extern, .Static => {
15801578 // This is actually a global variable, put it in the global scope and reference it.
15811579 // `_ = mangled_name;`
......@@ -1585,18 +1583,18 @@ fn transDeclStmtOne(
15851583 else => {},
15861584 }
15871585
1588 const mut_tok = if (ZigClangQualType_isConstQualified(qual_type))
1586 const mut_tok = if (qual_type.isConstQualified())
15891587 try appendToken(c, .Keyword_const, "const")
15901588 else
15911589 try appendToken(c, .Keyword_var, "var");
15921590 const name_tok = try appendIdentifier(c, mangled_name);
15931591
15941592 _ = try appendToken(c, .Colon, ":");
1595 const loc = ZigClangDecl_getLocation(decl);
1593 const loc = decl.getLocation();
15961594 const type_node = try transQualType(rp, qual_type, loc);
15971595
15981596 const eq_token = try appendToken(c, .Equal, "=");
1599 var init_node = if (ZigClangVarDecl_getInit(var_decl)) |expr|
1597 var init_node = if (var_decl.getInit()) |expr|
16001598 try transExprCoercing(rp, scope, expr, .used, .r_value)
16011599 else
16021600 try transCreateNodeUndefinedLiteral(c);
......@@ -1619,13 +1617,11 @@ fn transDeclStmtOne(
16191617 return &node.base;
16201618 },
16211619 .Typedef => {
1622 const typedef_decl = @ptrCast(*const ZigClangTypedefNameDecl, decl);
1623 const name = try c.str(ZigClangNamedDecl_getName_bytes_begin(
1624 @ptrCast(*const ZigClangNamedDecl, typedef_decl),
1625 ));
1620 const typedef_decl = @ptrCast(*const clang.TypedefNameDecl, decl);
1621 const name = try c.str(@ptrCast(*const clang.NamedDecl, typedef_decl).getName_bytes_begin());
16261622
1627 const underlying_qual = ZigClangTypedefNameDecl_getUnderlyingType(typedef_decl);
1628 const underlying_type = ZigClangQualType_getTypePtr(underlying_qual);
1623 const underlying_qual = typedef_decl.getUnderlyingType();
1624 const underlying_type = underlying_qual.getTypePtr();
16291625
16301626 const mangled_name = try block_scope.makeMangledName(c, name);
16311627 const node = (try transCreateNodeTypedef(rp, typedef_decl, false, mangled_name)) orelse
......@@ -1635,18 +1631,18 @@ fn transDeclStmtOne(
16351631 else => |kind| return revertAndWarn(
16361632 rp,
16371633 error.UnsupportedTranslation,
1638 ZigClangDecl_getLocation(decl),
1634 decl.getLocation(),
16391635 "TODO implement translation of DeclStmt kind {}",
16401636 .{@tagName(kind)},
16411637 ),
16421638 }
16431639}
16441640
1645fn transDeclStmt(rp: RestorePoint, scope: *Scope, stmt: *const ZigClangDeclStmt) TransError!*ast.Node {
1641fn transDeclStmt(rp: RestorePoint, scope: *Scope, stmt: *const clang.DeclStmt) TransError!*ast.Node {
16461642 const block_scope = scope.findBlockScope(rp.c) catch unreachable;
16471643
1648 var it = ZigClangDeclStmt_decl_begin(stmt);
1649 const end_it = ZigClangDeclStmt_decl_end(stmt);
1644 var it = stmt.decl_begin();
1645 const end_it = stmt.decl_end();
16501646 assert(it != end_it);
16511647 while (true) : (it += 1) {
16521648 const node = try transDeclStmtOne(rp, scope, it[0], block_scope);
......@@ -1663,11 +1659,11 @@ fn transDeclStmt(rp: RestorePoint, scope: *Scope, stmt: *const ZigClangDeclStmt)
16631659fn transDeclRefExpr(
16641660 rp: RestorePoint,
16651661 scope: *Scope,
1666 expr: *const ZigClangDeclRefExpr,
1662 expr: *const clang.DeclRefExpr,
16671663 lrvalue: LRValue,
16681664) TransError!*ast.Node {
1669 const value_decl = ZigClangDeclRefExpr_getDecl(expr);
1670 const name = try rp.c.str(ZigClangNamedDecl_getName_bytes_begin(@ptrCast(*const ZigClangNamedDecl, value_decl)));
1665 const value_decl = expr.getDecl();
1666 const name = try rp.c.str(@ptrCast(*const clang.NamedDecl, value_decl).getName_bytes_begin());
16711667 const mangled_name = scope.getAlias(name);
16721668 return transCreateNodeIdentifier(rp.c, mangled_name);
16731669}
......@@ -1675,17 +1671,17 @@ fn transDeclRefExpr(
16751671fn transImplicitCastExpr(
16761672 rp: RestorePoint,
16771673 scope: *Scope,
1678 expr: *const ZigClangImplicitCastExpr,
1674 expr: *const clang.ImplicitCastExpr,
16791675 result_used: ResultUsed,
16801676) TransError!*ast.Node {
16811677 const c = rp.c;
1682 const sub_expr = ZigClangImplicitCastExpr_getSubExpr(expr);
1683 const dest_type = getExprQualType(c, @ptrCast(*const ZigClangExpr, expr));
1678 const sub_expr = expr.getSubExpr();
1679 const dest_type = getExprQualType(c, @ptrCast(*const clang.Expr, expr));
16841680 const src_type = getExprQualType(c, sub_expr);
1685 switch (ZigClangImplicitCastExpr_getCastKind(expr)) {
1681 switch (expr.getCastKind()) {
16861682 .BitCast, .FloatingCast, .FloatingToIntegral, .IntegralToFloating, .IntegralCast, .PointerToIntegral, .IntegralToPointer => {
16871683 const sub_expr_node = try transExpr(rp, scope, sub_expr, .used, .r_value);
1688 return try transCCast(rp, scope, ZigClangImplicitCastExpr_getBeginLoc(expr), dest_type, src_type, sub_expr_node);
1684 return try transCCast(rp, scope, expr.getBeginLoc(), dest_type, src_type, sub_expr_node);
16891685 },
16901686 .LValueToRValue, .NoOp, .FunctionToPointerDecay => {
16911687 const sub_expr_node = try transExpr(rp, scope, sub_expr, .used, .r_value);
......@@ -1730,7 +1726,7 @@ fn transImplicitCastExpr(
17301726 else => |kind| return revertAndWarn(
17311727 rp,
17321728 error.UnsupportedTranslation,
1733 ZigClangStmt_getBeginLoc(@ptrCast(*const ZigClangStmt, expr)),
1729 @ptrCast(*const clang.Stmt, expr).getBeginLoc(),
17341730 "TODO implement translation of CastKind {}",
17351731 .{@tagName(kind)},
17361732 ),
......@@ -1740,15 +1736,15 @@ fn transImplicitCastExpr(
17401736fn transBoolExpr(
17411737 rp: RestorePoint,
17421738 scope: *Scope,
1743 expr: *const ZigClangExpr,
1739 expr: *const clang.Expr,
17441740 used: ResultUsed,
17451741 lrvalue: LRValue,
17461742 grouped: bool,
17471743) TransError!*ast.Node {
1748 if (ZigClangStmt_getStmtClass(@ptrCast(*const ZigClangStmt, expr)) == .IntegerLiteralClass) {
1744 if (@ptrCast(*const clang.Stmt, expr).getStmtClass() == .IntegerLiteralClass) {
17491745 var is_zero: bool = undefined;
1750 if (!ZigClangIntegerLiteral_isZero(@ptrCast(*const ZigClangIntegerLiteral, expr), &is_zero, rp.c.clang_context)) {
1751 return revertAndWarn(rp, error.UnsupportedTranslation, ZigClangExpr_getBeginLoc(expr), "invalid integer literal", .{});
1746 if (!(@ptrCast(*const clang.IntegerLiteral, expr).isZero(&is_zero, rp.c.clang_context))) {
1747 return revertAndWarn(rp, error.UnsupportedTranslation, expr.getBeginLoc(), "invalid integer literal", .{});
17521748 }
17531749 return try transCreateNodeBoolLiteral(rp.c, !is_zero);
17541750 }
......@@ -1769,8 +1765,8 @@ fn transBoolExpr(
17691765 return res;
17701766 }
17711767
1772 const ty = ZigClangQualType_getTypePtr(getExprQualType(rp.c, expr));
1773 const node = try finishBoolExpr(rp, scope, ZigClangExpr_getBeginLoc(expr), ty, res, used);
1768 const ty = getExprQualType(rp.c, expr).getTypePtr();
1769 const node = try finishBoolExpr(rp, scope, expr.getBeginLoc(), ty, res, used);
17741770
17751771 if (grouped) {
17761772 const rparen = try appendToken(rp.c, .RParen, ")");
......@@ -1786,16 +1782,16 @@ fn transBoolExpr(
17861782 }
17871783}
17881784
1789fn exprIsBooleanType(expr: *const ZigClangExpr) bool {
1790 return qualTypeIsBoolean(ZigClangExpr_getType(expr));
1785fn exprIsBooleanType(expr: *const clang.Expr) bool {
1786 return qualTypeIsBoolean(expr.getType());
17911787}
17921788
1793fn exprIsStringLiteral(expr: *const ZigClangExpr) bool {
1794 switch (ZigClangExpr_getStmtClass(expr)) {
1789fn exprIsStringLiteral(expr: *const clang.Expr) bool {
1790 switch (expr.getStmtClass()) {
17951791 .StringLiteralClass => return true,
17961792 .PredefinedExprClass => return true,
17971793 .UnaryOperatorClass => {
1798 const op_expr = ZigClangUnaryOperator_getSubExpr(@ptrCast(*const ZigClangUnaryOperator, expr));
1794 const op_expr = @ptrCast(*const clang.UnaryOperator, expr).getSubExpr();
17991795 return exprIsStringLiteral(op_expr);
18001796 },
18011797 else => return false,
......@@ -1825,16 +1821,16 @@ fn isBoolRes(res: *ast.Node) bool {
18251821fn finishBoolExpr(
18261822 rp: RestorePoint,
18271823 scope: *Scope,
1828 loc: ZigClangSourceLocation,
1829 ty: *const ZigClangType,
1824 loc: clang.SourceLocation,
1825 ty: *const clang.Type,
18301826 node: *ast.Node,
18311827 used: ResultUsed,
18321828) TransError!*ast.Node {
1833 switch (ZigClangType_getTypeClass(ty)) {
1829 switch (ty.getTypeClass()) {
18341830 .Builtin => {
1835 const builtin_ty = @ptrCast(*const ZigClangBuiltinType, ty);
1831 const builtin_ty = @ptrCast(*const clang.BuiltinType, ty);
18361832
1837 switch (ZigClangBuiltinType_getKind(builtin_ty)) {
1833 switch (builtin_ty.getKind()) {
18381834 .Bool => return node,
18391835 .Char_U,
18401836 .UChar,
......@@ -1879,10 +1875,10 @@ fn finishBoolExpr(
18791875 return transCreateNodeInfixOp(rp, scope, node, .BangEqual, op_token, rhs_node, used, false);
18801876 },
18811877 .Typedef => {
1882 const typedef_ty = @ptrCast(*const ZigClangTypedefType, ty);
1883 const typedef_decl = ZigClangTypedefType_getDecl(typedef_ty);
1884 const underlying_type = ZigClangTypedefNameDecl_getUnderlyingType(typedef_decl);
1885 return finishBoolExpr(rp, scope, loc, ZigClangQualType_getTypePtr(underlying_type), node, used);
1878 const typedef_ty = @ptrCast(*const clang.TypedefType, ty);
1879 const typedef_decl = typedef_ty.getDecl();
1880 const underlying_type = typedef_decl.getUnderlyingType();
1881 return finishBoolExpr(rp, scope, loc, underlying_type.getTypePtr(), node, used);
18861882 },
18871883 .Enum => {
18881884 const op_token = try appendToken(rp.c, .BangEqual, "!=");
......@@ -1890,9 +1886,9 @@ fn finishBoolExpr(
18901886 return transCreateNodeInfixOp(rp, scope, node, .BangEqual, op_token, rhs_node, used, false);
18911887 },
18921888 .Elaborated => {
1893 const elaborated_ty = @ptrCast(*const ZigClangElaboratedType, ty);
1894 const named_type = ZigClangElaboratedType_getNamedType(elaborated_ty);
1895 return finishBoolExpr(rp, scope, loc, ZigClangQualType_getTypePtr(named_type), node, used);
1889 const elaborated_ty = @ptrCast(*const clang.ElaboratedType, ty);
1890 const named_type = elaborated_ty.getNamedType();
1891 return finishBoolExpr(rp, scope, loc, named_type.getTypePtr(), node, used);
18961892 },
18971893 else => {},
18981894 }
......@@ -1906,18 +1902,18 @@ const SuppressCast = enum {
19061902fn transIntegerLiteral(
19071903 rp: RestorePoint,
19081904 scope: *Scope,
1909 expr: *const ZigClangIntegerLiteral,
1905 expr: *const clang.IntegerLiteral,
19101906 result_used: ResultUsed,
19111907 suppress_as: SuppressCast,
19121908) TransError!*ast.Node {
1913 var eval_result: ZigClangExprEvalResult = undefined;
1914 if (!ZigClangIntegerLiteral_EvaluateAsInt(expr, &eval_result, rp.c.clang_context)) {
1915 const loc = ZigClangIntegerLiteral_getBeginLoc(expr);
1909 var eval_result: clang.ExprEvalResult = undefined;
1910 if (!expr.EvaluateAsInt(&eval_result, rp.c.clang_context)) {
1911 const loc = expr.getBeginLoc();
19161912 return revertAndWarn(rp, error.UnsupportedTranslation, loc, "invalid integer literal", .{});
19171913 }
19181914
19191915 if (suppress_as == .no_as) {
1920 const int_lit_node = try transCreateNodeAPInt(rp.c, ZigClangAPValue_getInt(&eval_result.Val));
1916 const int_lit_node = try transCreateNodeAPInt(rp.c, eval_result.Val.getInt());
19211917 return maybeSuppressResult(rp, scope, result_used, int_lit_node);
19221918 }
19231919
......@@ -1932,12 +1928,12 @@ fn transIntegerLiteral(
19321928 // But the first step is to be correct, and the next step is to make the output more elegant.
19331929
19341930 // @as(T, x)
1935 const expr_base = @ptrCast(*const ZigClangExpr, expr);
1931 const expr_base = @ptrCast(*const clang.Expr, expr);
19361932 const as_node = try rp.c.createBuiltinCall("@as", 2);
1937 const ty_node = try transQualType(rp, ZigClangExpr_getType(expr_base), ZigClangExpr_getBeginLoc(expr_base));
1933 const ty_node = try transQualType(rp, expr_base.getType(), expr_base.getBeginLoc());
19381934 as_node.params()[0] = ty_node;
19391935 _ = try appendToken(rp.c, .Comma, ",");
1940 as_node.params()[1] = try transCreateNodeAPInt(rp.c, ZigClangAPValue_getInt(&eval_result.Val));
1936 as_node.params()[1] = try transCreateNodeAPInt(rp.c, eval_result.Val.getInt());
19411937
19421938 as_node.rparen_token = try appendToken(rp.c, .RParen, ")");
19431939 return maybeSuppressResult(rp, scope, result_used, &as_node.base);
......@@ -1946,10 +1942,10 @@ fn transIntegerLiteral(
19461942fn transReturnStmt(
19471943 rp: RestorePoint,
19481944 scope: *Scope,
1949 expr: *const ZigClangReturnStmt,
1945 expr: *const clang.ReturnStmt,
19501946) TransError!*ast.Node {
19511947 const return_kw = try appendToken(rp.c, .Keyword_return, "return");
1952 const rhs: ?*ast.Node = if (ZigClangReturnStmt_getRetValue(expr)) |val_expr|
1948 const rhs: ?*ast.Node = if (expr.getRetValue()) |val_expr|
19531949 try transExprCoercing(rp, scope, val_expr, .used, .r_value)
19541950 else
19551951 null;
......@@ -1966,14 +1962,14 @@ fn transReturnStmt(
19661962fn transStringLiteral(
19671963 rp: RestorePoint,
19681964 scope: *Scope,
1969 stmt: *const ZigClangStringLiteral,
1965 stmt: *const clang.StringLiteral,
19701966 result_used: ResultUsed,
19711967) TransError!*ast.Node {
1972 const kind = ZigClangStringLiteral_getKind(stmt);
1968 const kind = stmt.getKind();
19731969 switch (kind) {
19741970 .Ascii, .UTF8 => {
19751971 var len: usize = undefined;
1976 const bytes_ptr = ZigClangStringLiteral_getString_bytes_begin_size(stmt, &len);
1972 const bytes_ptr = stmt.getString_bytes_begin_size(&len);
19771973 const str = bytes_ptr[0..len];
19781974
19791975 var char_buf: [4]u8 = undefined;
......@@ -1996,7 +1992,7 @@ fn transStringLiteral(
19961992 .UTF16, .UTF32, .Wide => return revertAndWarn(
19971993 rp,
19981994 error.UnsupportedTranslation,
1999 ZigClangStmt_getBeginLoc(@ptrCast(*const ZigClangStmt, stmt)),
1995 @ptrCast(*const clang.Stmt, stmt).getBeginLoc(),
20001996 "TODO: support string literal kind {}",
20011997 .{kind},
20021998 ),
......@@ -2041,13 +2037,13 @@ fn escapeChar(c: u8, char_buf: *[4]u8) []const u8 {
20412037fn transCCast(
20422038 rp: RestorePoint,
20432039 scope: *Scope,
2044 loc: ZigClangSourceLocation,
2045 dst_type: ZigClangQualType,
2046 src_type: ZigClangQualType,
2040 loc: clang.SourceLocation,
2041 dst_type: clang.QualType,
2042 src_type: clang.QualType,
20472043 expr: *ast.Node,
20482044) !*ast.Node {
2049 if (ZigClangType_isVoidType(qualTypeCanon(dst_type))) return expr;
2050 if (ZigClangQualType_eq(dst_type, src_type)) return expr;
2045 if (qualTypeCanon(dst_type).isVoidType()) return expr;
2046 if (dst_type.eq(src_type)) return expr;
20512047 if (qualTypeIsPtr(dst_type) and qualTypeIsPtr(src_type))
20522048 return transCPtrCast(rp, loc, dst_type, src_type, expr);
20532049 if (cIsInteger(dst_type) and cIsInteger(src_type)) {
......@@ -2134,9 +2130,7 @@ fn transCCast(
21342130 builtin_node.rparen_token = try appendToken(rp.c, .RParen, ")");
21352131 return &builtin_node.base;
21362132 }
2137 if (ZigClangType_isBooleanType(qualTypeCanon(src_type)) and
2138 !ZigClangType_isBooleanType(qualTypeCanon(dst_type)))
2139 {
2133 if (qualTypeIsBoolean(src_type) and !qualTypeIsBoolean(dst_type)) {
21402134 // @boolToInt returns either a comptime_int or a u1
21412135 const builtin_node = try rp.c.createBuiltinCall("@boolToInt", 1);
21422136 builtin_node.params()[0] = expr;
......@@ -2166,7 +2160,7 @@ fn transCCast(
21662160
21672161 return &cast_node.base;
21682162 }
2169 if (ZigClangQualType_getTypeClass(ZigClangQualType_getCanonicalType(dst_type)) == .Enum) {
2163 if (dst_type.getCanonicalType().getTypeClass() == .Enum) {
21702164 const builtin_node = try rp.c.createBuiltinCall("@intToEnum", 2);
21712165 builtin_node.params()[0] = try transQualType(rp, dst_type, loc);
21722166 _ = try appendToken(rp.c, .Comma, ",");
......@@ -2174,8 +2168,8 @@ fn transCCast(
21742168 builtin_node.rparen_token = try appendToken(rp.c, .RParen, ")");
21752169 return &builtin_node.base;
21762170 }
2177 if (ZigClangQualType_getTypeClass(ZigClangQualType_getCanonicalType(src_type)) == .Enum and
2178 ZigClangQualType_getTypeClass(ZigClangQualType_getCanonicalType(dst_type)) != .Enum)
2171 if (src_type.getCanonicalType().getTypeClass() == .Enum and
2172 dst_type.getCanonicalType().getTypeClass() != .Enum)
21792173 {
21802174 const builtin_node = try rp.c.createBuiltinCall("@enumToInt", 1);
21812175 builtin_node.params()[0] = expr;
......@@ -2193,11 +2187,11 @@ fn transCCast(
21932187fn transExpr(
21942188 rp: RestorePoint,
21952189 scope: *Scope,
2196 expr: *const ZigClangExpr,
2190 expr: *const clang.Expr,
21972191 used: ResultUsed,
21982192 lrvalue: LRValue,
21992193) TransError!*ast.Node {
2200 return transStmt(rp, scope, @ptrCast(*const ZigClangStmt, expr), used, lrvalue);
2194 return transStmt(rp, scope, @ptrCast(*const clang.Stmt, expr), used, lrvalue);
22012195}
22022196
22032197/// Same as `transExpr` but with the knowledge that the operand will be type coerced, and therefore
......@@ -2205,21 +2199,21 @@ fn transExpr(
22052199fn transExprCoercing(
22062200 rp: RestorePoint,
22072201 scope: *Scope,
2208 expr: *const ZigClangExpr,
2202 expr: *const clang.Expr,
22092203 used: ResultUsed,
22102204 lrvalue: LRValue,
22112205) TransError!*ast.Node {
2212 switch (ZigClangStmt_getStmtClass(@ptrCast(*const ZigClangStmt, expr))) {
2206 switch (@ptrCast(*const clang.Stmt, expr).getStmtClass()) {
22132207 .IntegerLiteralClass => {
2214 return transIntegerLiteral(rp, scope, @ptrCast(*const ZigClangIntegerLiteral, expr), .used, .no_as);
2208 return transIntegerLiteral(rp, scope, @ptrCast(*const clang.IntegerLiteral, expr), .used, .no_as);
22152209 },
22162210 .CharacterLiteralClass => {
2217 return transCharLiteral(rp, scope, @ptrCast(*const ZigClangCharacterLiteral, expr), .used, .no_as);
2211 return transCharLiteral(rp, scope, @ptrCast(*const clang.CharacterLiteral, expr), .used, .no_as);
22182212 },
22192213 .UnaryOperatorClass => {
2220 const un_expr = @ptrCast(*const ZigClangUnaryOperator, expr);
2221 if (ZigClangUnaryOperator_getOpcode(un_expr) == .Extension) {
2222 return transExprCoercing(rp, scope, ZigClangUnaryOperator_getSubExpr(un_expr), used, lrvalue);
2214 const un_expr = @ptrCast(*const clang.UnaryOperator, expr);
2215 if (un_expr.getOpcode() == .Extension) {
2216 return transExprCoercing(rp, scope, un_expr.getSubExpr(), used, lrvalue);
22232217 }
22242218 },
22252219 else => {},
......@@ -2230,51 +2224,51 @@ fn transExprCoercing(
22302224fn transInitListExprRecord(
22312225 rp: RestorePoint,
22322226 scope: *Scope,
2233 loc: ZigClangSourceLocation,
2234 expr: *const ZigClangInitListExpr,
2235 ty: *const ZigClangType,
2227 loc: clang.SourceLocation,
2228 expr: *const clang.InitListExpr,
2229 ty: *const clang.Type,
22362230 used: ResultUsed,
22372231) TransError!*ast.Node {
22382232 var is_union_type = false;
22392233 // Unions and Structs are both represented as RecordDecl
2240 const record_ty = ZigClangType_getAsRecordType(ty) orelse
2234 const record_ty = ty.getAsRecordType() orelse
22412235 blk: {
22422236 is_union_type = true;
2243 break :blk ZigClangType_getAsUnionType(ty);
2237 break :blk ty.getAsUnionType();
22442238 } orelse unreachable;
2245 const record_decl = ZigClangRecordType_getDecl(record_ty);
2246 const record_def = ZigClangRecordDecl_getDefinition(record_decl) orelse
2239 const record_decl = record_ty.getDecl();
2240 const record_def = record_decl.getDefinition() orelse
22472241 unreachable;
22482242
22492243 const ty_node = try transType(rp, ty, loc);
2250 const init_count = ZigClangInitListExpr_getNumInits(expr);
2244 const init_count = expr.getNumInits();
22512245 var field_inits = std.ArrayList(*ast.Node).init(rp.c.gpa);
22522246 defer field_inits.deinit();
22532247
22542248 _ = try appendToken(rp.c, .LBrace, "{");
22552249
22562250 var init_i: c_uint = 0;
2257 var it = ZigClangRecordDecl_field_begin(record_def);
2258 const end_it = ZigClangRecordDecl_field_end(record_def);
2259 while (ZigClangRecordDecl_field_iterator_neq(it, end_it)) : (it = ZigClangRecordDecl_field_iterator_next(it)) {
2260 const field_decl = ZigClangRecordDecl_field_iterator_deref(it);
2251 var it = record_def.field_begin();
2252 const end_it = record_def.field_end();
2253 while (it.neq(end_it)) : (it = it.next()) {
2254 const field_decl = it.deref();
22612255
22622256 // The initializer for a union type has a single entry only
2263 if (is_union_type and field_decl != ZigClangInitListExpr_getInitializedFieldInUnion(expr)) {
2257 if (is_union_type and field_decl != expr.getInitializedFieldInUnion()) {
22642258 continue;
22652259 }
22662260
22672261 assert(init_i < init_count);
2268 const elem_expr = ZigClangInitListExpr_getInit(expr, init_i);
2262 const elem_expr = expr.getInit(init_i);
22692263 init_i += 1;
22702264
22712265 // Generate the field assignment expression:
22722266 // .field_name = expr
22732267 const period_tok = try appendToken(rp.c, .Period, ".");
22742268
2275 var raw_name = try rp.c.str(ZigClangNamedDecl_getName_bytes_begin(@ptrCast(*const ZigClangNamedDecl, field_decl)));
2276 if (ZigClangFieldDecl_isAnonymousStructOrUnion(field_decl)) {
2277 const name = rp.c.decl_table.get(@ptrToInt(ZigClangFieldDecl_getCanonicalDecl(field_decl))).?;
2269 var raw_name = try rp.c.str(@ptrCast(*const clang.NamedDecl, field_decl).getName_bytes_begin());
2270 if (field_decl.isAnonymousStructOrUnion()) {
2271 const name = rp.c.decl_table.get(@ptrToInt(field_decl.getCanonicalDecl())).?;
22782272 raw_name = try mem.dupe(rp.c.arena, u8, name);
22792273 }
22802274 const field_name_tok = try appendIdentifier(rp.c, raw_name);
......@@ -2304,8 +2298,8 @@ fn transInitListExprRecord(
23042298
23052299fn transCreateNodeArrayType(
23062300 rp: RestorePoint,
2307 source_loc: ZigClangSourceLocation,
2308 ty: *const ZigClangType,
2301 source_loc: clang.SourceLocation,
2302 ty: *const clang.Type,
23092303 len: anytype,
23102304) !*ast.Node {
23112305 const node = try rp.c.arena.create(ast.Node.ArrayType);
......@@ -2323,18 +2317,18 @@ fn transCreateNodeArrayType(
23232317fn transInitListExprArray(
23242318 rp: RestorePoint,
23252319 scope: *Scope,
2326 loc: ZigClangSourceLocation,
2327 expr: *const ZigClangInitListExpr,
2328 ty: *const ZigClangType,
2320 loc: clang.SourceLocation,
2321 expr: *const clang.InitListExpr,
2322 ty: *const clang.Type,
23292323 used: ResultUsed,
23302324) TransError!*ast.Node {
2331 const arr_type = ZigClangType_getAsArrayTypeUnsafe(ty);
2332 const child_qt = ZigClangArrayType_getElementType(arr_type);
2333 const init_count = ZigClangInitListExpr_getNumInits(expr);
2334 assert(ZigClangType_isConstantArrayType(@ptrCast(*const ZigClangType, arr_type)));
2335 const const_arr_ty = @ptrCast(*const ZigClangConstantArrayType, arr_type);
2336 const size_ap_int = ZigClangConstantArrayType_getSize(const_arr_ty);
2337 const all_count = ZigClangAPInt_getLimitedValue(size_ap_int, math.maxInt(usize));
2325 const arr_type = ty.getAsArrayTypeUnsafe();
2326 const child_qt = arr_type.getElementType();
2327 const init_count = expr.getNumInits();
2328 assert(@ptrCast(*const clang.Type, arr_type).isConstantArrayType());
2329 const const_arr_ty = @ptrCast(*const clang.ConstantArrayType, arr_type);
2330 const size_ap_int = const_arr_ty.getSize();
2331 const all_count = size_ap_int.getLimitedValue(math.maxInt(usize));
23382332 const leftover_count = all_count - init_count;
23392333
23402334 var init_node: *ast.Node.ArrayInitializer = undefined;
......@@ -2343,7 +2337,7 @@ fn transInitListExprArray(
23432337 const ty_node = try transCreateNodeArrayType(
23442338 rp,
23452339 loc,
2346 ZigClangQualType_getTypePtr(child_qt),
2340 child_qt.getTypePtr(),
23472341 init_count,
23482342 );
23492343 _ = try appendToken(rp.c, .LBrace, "{");
......@@ -2357,7 +2351,7 @@ fn transInitListExprArray(
23572351
23582352 var i: c_uint = 0;
23592353 while (i < init_count) : (i += 1) {
2360 const elem_expr = ZigClangInitListExpr_getInit(expr, i);
2354 const elem_expr = expr.getInit(i);
23612355 init_list[i] = try transExpr(rp, scope, elem_expr, .used, .r_value);
23622356 _ = try appendToken(rp.c, .Comma, ",");
23632357 }
......@@ -2368,7 +2362,7 @@ fn transInitListExprArray(
23682362 cat_tok = try appendToken(rp.c, .PlusPlus, "++");
23692363 }
23702364
2371 const ty_node = try transCreateNodeArrayType(rp, loc, ZigClangQualType_getTypePtr(child_qt), 1);
2365 const ty_node = try transCreateNodeArrayType(rp, loc, child_qt.getTypePtr(), 1);
23722366 _ = try appendToken(rp.c, .LBrace, "{");
23732367 const filler_init_node = try ast.Node.ArrayInitializer.alloc(rp.c.arena, 1);
23742368 filler_init_node.* = .{
......@@ -2376,7 +2370,7 @@ fn transInitListExprArray(
23762370 .rtoken = undefined,
23772371 .list_len = 1,
23782372 };
2379 const filler_val_expr = ZigClangInitListExpr_getArrayFiller(expr);
2373 const filler_val_expr = expr.getArrayFiller();
23802374 filler_init_node.list()[0] = try transExpr(rp, scope, filler_val_expr, .used, .r_value);
23812375 filler_init_node.rtoken = try appendToken(rp.c, .RBrace, "}");
23822376
......@@ -2411,14 +2405,14 @@ fn transInitListExprArray(
24112405fn transInitListExpr(
24122406 rp: RestorePoint,
24132407 scope: *Scope,
2414 expr: *const ZigClangInitListExpr,
2408 expr: *const clang.InitListExpr,
24152409 used: ResultUsed,
24162410) TransError!*ast.Node {
2417 const qt = getExprQualType(rp.c, @ptrCast(*const ZigClangExpr, expr));
2418 var qual_type = ZigClangQualType_getTypePtr(qt);
2419 const source_loc = ZigClangExpr_getBeginLoc(@ptrCast(*const ZigClangExpr, expr));
2411 const qt = getExprQualType(rp.c, @ptrCast(*const clang.Expr, expr));
2412 var qual_type = qt.getTypePtr();
2413 const source_loc = @ptrCast(*const clang.Expr, expr).getBeginLoc();
24202414
2421 if (ZigClangType_isRecordType(qual_type)) {
2415 if (qual_type.isRecordType()) {
24222416 return transInitListExprRecord(
24232417 rp,
24242418 scope,
......@@ -2427,7 +2421,7 @@ fn transInitListExpr(
24272421 qual_type,
24282422 used,
24292423 );
2430 } else if (ZigClangType_isArrayType(qual_type)) {
2424 } else if (qual_type.isArrayType()) {
24312425 return transInitListExprArray(
24322426 rp,
24332427 scope,
......@@ -2437,7 +2431,7 @@ fn transInitListExpr(
24372431 used,
24382432 );
24392433 } else {
2440 const type_name = rp.c.str(ZigClangType_getTypeClassName(qual_type));
2434 const type_name = rp.c.str(qual_type.getTypeClassName());
24412435 return revertAndWarn(rp, error.UnsupportedType, source_loc, "unsupported initlist type: '{}'", .{type_name});
24422436 }
24432437}
......@@ -2445,13 +2439,13 @@ fn transInitListExpr(
24452439fn transZeroInitExpr(
24462440 rp: RestorePoint,
24472441 scope: *Scope,
2448 source_loc: ZigClangSourceLocation,
2449 ty: *const ZigClangType,
2442 source_loc: clang.SourceLocation,
2443 ty: *const clang.Type,
24502444) TransError!*ast.Node {
2451 switch (ZigClangType_getTypeClass(ty)) {
2445 switch (ty.getTypeClass()) {
24522446 .Builtin => {
2453 const builtin_ty = @ptrCast(*const ZigClangBuiltinType, ty);
2454 switch (ZigClangBuiltinType_getKind(builtin_ty)) {
2447 const builtin_ty = @ptrCast(*const clang.BuiltinType, ty);
2448 switch (builtin_ty.getKind()) {
24552449 .Bool => return try transCreateNodeBoolLiteral(rp.c, false),
24562450 .Char_U,
24572451 .UChar,
......@@ -2479,15 +2473,13 @@ fn transZeroInitExpr(
24792473 },
24802474 .Pointer => return transCreateNodeNullLiteral(rp.c),
24812475 .Typedef => {
2482 const typedef_ty = @ptrCast(*const ZigClangTypedefType, ty);
2483 const typedef_decl = ZigClangTypedefType_getDecl(typedef_ty);
2476 const typedef_ty = @ptrCast(*const clang.TypedefType, ty);
2477 const typedef_decl = typedef_ty.getDecl();
24842478 return transZeroInitExpr(
24852479 rp,
24862480 scope,
24872481 source_loc,
2488 ZigClangQualType_getTypePtr(
2489 ZigClangTypedefNameDecl_getUnderlyingType(typedef_decl),
2490 ),
2482 typedef_decl.getUnderlyingType().getTypePtr(),
24912483 );
24922484 },
24932485 else => {},
......@@ -2499,19 +2491,19 @@ fn transZeroInitExpr(
24992491fn transImplicitValueInitExpr(
25002492 rp: RestorePoint,
25012493 scope: *Scope,
2502 expr: *const ZigClangExpr,
2494 expr: *const clang.Expr,
25032495 used: ResultUsed,
25042496) TransError!*ast.Node {
2505 const source_loc = ZigClangExpr_getBeginLoc(expr);
2497 const source_loc = expr.getBeginLoc();
25062498 const qt = getExprQualType(rp.c, expr);
2507 const ty = ZigClangQualType_getTypePtr(qt);
2499 const ty = qt.getTypePtr();
25082500 return transZeroInitExpr(rp, scope, source_loc, ty);
25092501}
25102502
25112503fn transIfStmt(
25122504 rp: RestorePoint,
25132505 scope: *Scope,
2514 stmt: *const ZigClangIfStmt,
2506 stmt: *const clang.IfStmt,
25152507) TransError!*ast.Node {
25162508 // if (c) t
25172509 // if (c) t else e
......@@ -2524,13 +2516,13 @@ fn transIfStmt(
25242516 },
25252517 };
25262518 defer cond_scope.deinit();
2527 const cond_expr = @ptrCast(*const ZigClangExpr, ZigClangIfStmt_getCond(stmt));
2519 const cond_expr = @ptrCast(*const clang.Expr, stmt.getCond());
25282520 if_node.condition = try transBoolExpr(rp, &cond_scope.base, cond_expr, .used, .r_value, false);
25292521 _ = try appendToken(rp.c, .RParen, ")");
25302522
2531 if_node.body = try transStmt(rp, scope, ZigClangIfStmt_getThen(stmt), .unused, .r_value);
2523 if_node.body = try transStmt(rp, scope, stmt.getThen(), .unused, .r_value);
25322524
2533 if (ZigClangIfStmt_getElse(stmt)) |expr| {
2525 if (stmt.getElse()) |expr| {
25342526 if_node.@"else" = try transCreateNodeElse(rp.c);
25352527 if_node.@"else".?.body = try transStmt(rp, scope, expr, .unused, .r_value);
25362528 }
......@@ -2541,7 +2533,7 @@ fn transIfStmt(
25412533fn transWhileLoop(
25422534 rp: RestorePoint,
25432535 scope: *Scope,
2544 stmt: *const ZigClangWhileStmt,
2536 stmt: *const clang.WhileStmt,
25452537) TransError!*ast.Node {
25462538 const while_node = try transCreateNodeWhile(rp.c);
25472539
......@@ -2552,7 +2544,7 @@ fn transWhileLoop(
25522544 },
25532545 };
25542546 defer cond_scope.deinit();
2555 const cond_expr = @ptrCast(*const ZigClangExpr, ZigClangWhileStmt_getCond(stmt));
2547 const cond_expr = @ptrCast(*const clang.Expr, stmt.getCond());
25562548 while_node.condition = try transBoolExpr(rp, &cond_scope.base, cond_expr, .used, .r_value, false);
25572549 _ = try appendToken(rp.c, .RParen, ")");
25582550
......@@ -2560,7 +2552,7 @@ fn transWhileLoop(
25602552 .parent = scope,
25612553 .id = .Loop,
25622554 };
2563 while_node.body = try transStmt(rp, &loop_scope, ZigClangWhileStmt_getBody(stmt), .unused, .r_value);
2555 while_node.body = try transStmt(rp, &loop_scope, stmt.getBody(), .unused, .r_value);
25642556 _ = try appendToken(rp.c, .Semicolon, ";");
25652557 return &while_node.base;
25662558}
......@@ -2568,7 +2560,7 @@ fn transWhileLoop(
25682560fn transDoWhileLoop(
25692561 rp: RestorePoint,
25702562 scope: *Scope,
2571 stmt: *const ZigClangDoStmt,
2563 stmt: *const clang.DoStmt,
25722564) TransError!*ast.Node {
25732565 const while_node = try transCreateNodeWhile(rp.c);
25742566
......@@ -2590,13 +2582,13 @@ fn transDoWhileLoop(
25902582 };
25912583 defer cond_scope.deinit();
25922584 const prefix_op = try transCreateNodeSimplePrefixOp(rp.c, .BoolNot, .Bang, "!");
2593 prefix_op.rhs = try transBoolExpr(rp, &cond_scope.base, @ptrCast(*const ZigClangExpr, ZigClangDoStmt_getCond(stmt)), .used, .r_value, true);
2585 prefix_op.rhs = try transBoolExpr(rp, &cond_scope.base, @ptrCast(*const clang.Expr, stmt.getCond()), .used, .r_value, true);
25942586 _ = try appendToken(rp.c, .RParen, ")");
25952587 if_node.condition = &prefix_op.base;
25962588 if_node.body = &(try transCreateNodeBreak(rp.c, null, null)).base;
25972589 _ = try appendToken(rp.c, .Semicolon, ";");
25982590
2599 const body_node = if (ZigClangStmt_getStmtClass(ZigClangDoStmt_getBody(stmt)) == .CompoundStmtClass) blk: {
2591 const body_node = if (stmt.getBody().getStmtClass() == .CompoundStmtClass) blk: {
26002592 // there's already a block in C, so we'll append our condition to it.
26012593 // c: do {
26022594 // c: a;
......@@ -2607,7 +2599,7 @@ fn transDoWhileLoop(
26072599 // zig: b;
26082600 // zig: if (!cond) break;
26092601 // zig: }
2610 const node = try transStmt(rp, &loop_scope, ZigClangDoStmt_getBody(stmt), .unused, .r_value);
2602 const node = try transStmt(rp, &loop_scope, stmt.getBody(), .unused, .r_value);
26112603 break :blk node.castTag(.Block).?;
26122604 } else blk: {
26132605 // the C statement is without a block, so we need to create a block to contain it.
......@@ -2621,7 +2613,7 @@ fn transDoWhileLoop(
26212613 new = true;
26222614 const block = try rp.c.createBlock(2);
26232615 block.statements_len = 1; // over-allocated so we can add another below
2624 block.statements()[0] = try transStmt(rp, &loop_scope, ZigClangDoStmt_getBody(stmt), .unused, .r_value);
2616 block.statements()[0] = try transStmt(rp, &loop_scope, stmt.getBody(), .unused, .r_value);
26252617 break :blk block;
26262618 };
26272619
......@@ -2637,7 +2629,7 @@ fn transDoWhileLoop(
26372629fn transForLoop(
26382630 rp: RestorePoint,
26392631 scope: *Scope,
2640 stmt: *const ZigClangForStmt,
2632 stmt: *const clang.ForStmt,
26412633) TransError!*ast.Node {
26422634 var loop_scope = Scope{
26432635 .parent = scope,
......@@ -2647,7 +2639,7 @@ fn transForLoop(
26472639 var block_scope: ?Scope.Block = null;
26482640 defer if (block_scope) |*bs| bs.deinit();
26492641
2650 if (ZigClangForStmt_getInit(stmt)) |init| {
2642 if (stmt.getInit()) |init| {
26512643 block_scope = try Scope.Block.init(rp.c, scope, false);
26522644 loop_scope.parent = &block_scope.?.base;
26532645 const init_node = try transStmt(rp, &block_scope.?.base, init, .unused, .r_value);
......@@ -2662,20 +2654,20 @@ fn transForLoop(
26622654 defer cond_scope.deinit();
26632655
26642656 const while_node = try transCreateNodeWhile(rp.c);
2665 while_node.condition = if (ZigClangForStmt_getCond(stmt)) |cond|
2657 while_node.condition = if (stmt.getCond()) |cond|
26662658 try transBoolExpr(rp, &cond_scope.base, cond, .used, .r_value, false)
26672659 else
26682660 try transCreateNodeBoolLiteral(rp.c, true);
26692661 _ = try appendToken(rp.c, .RParen, ")");
26702662
2671 if (ZigClangForStmt_getInc(stmt)) |incr| {
2663 if (stmt.getInc()) |incr| {
26722664 _ = try appendToken(rp.c, .Colon, ":");
26732665 _ = try appendToken(rp.c, .LParen, "(");
26742666 while_node.continue_expr = try transExpr(rp, &cond_scope.base, incr, .unused, .r_value);
26752667 _ = try appendToken(rp.c, .RParen, ")");
26762668 }
26772669
2678 while_node.body = try transStmt(rp, &loop_scope, ZigClangForStmt_getBody(stmt), .unused, .r_value);
2670 while_node.body = try transStmt(rp, &loop_scope, stmt.getBody(), .unused, .r_value);
26792671 if (block_scope) |*bs| {
26802672 try bs.statements.append(&while_node.base);
26812673 return try bs.complete(rp.c);
......@@ -2685,21 +2677,21 @@ fn transForLoop(
26852677 }
26862678}
26872679
2688fn getSwitchCaseCount(stmt: *const ZigClangSwitchStmt) usize {
2689 const body = ZigClangSwitchStmt_getBody(stmt);
2690 assert(ZigClangStmt_getStmtClass(body) == .CompoundStmtClass);
2691 const comp = @ptrCast(*const ZigClangCompoundStmt, body);
2680fn getSwitchCaseCount(stmt: *const clang.SwitchStmt) usize {
2681 const body = stmt.getBody();
2682 assert(body.getStmtClass() == .CompoundStmtClass);
2683 const comp = @ptrCast(*const clang.CompoundStmt, body);
26922684 // TODO https://github.com/ziglang/zig/issues/1738
2693 // return ZigClangCompoundStmt_body_end(comp) - ZigClangCompoundStmt_body_begin(comp);
2694 const start_addr = @ptrToInt(ZigClangCompoundStmt_body_begin(comp));
2695 const end_addr = @ptrToInt(ZigClangCompoundStmt_body_end(comp));
2696 return (end_addr - start_addr) / @sizeOf(*ZigClangStmt);
2685 // return comp.body_end() - comp.body_begin();
2686 const start_addr = @ptrToInt(comp.body_begin());
2687 const end_addr = @ptrToInt(comp.body_end());
2688 return (end_addr - start_addr) / @sizeOf(*clang.Stmt);
26972689}
26982690
26992691fn transSwitch(
27002692 rp: RestorePoint,
27012693 scope: *Scope,
2702 stmt: *const ZigClangSwitchStmt,
2694 stmt: *const clang.SwitchStmt,
27032695) TransError!*ast.Node {
27042696 const switch_tok = try appendToken(rp.c, .Keyword_switch, "switch");
27052697 _ = try appendToken(rp.c, .LParen, "(");
......@@ -2713,7 +2705,7 @@ fn transSwitch(
27132705 },
27142706 };
27152707 defer cond_scope.deinit();
2716 const switch_expr = try transExpr(rp, &cond_scope.base, ZigClangSwitchStmt_getCond(stmt), .used, .r_value);
2708 const switch_expr = try transExpr(rp, &cond_scope.base, stmt.getCond(), .used, .r_value);
27172709 _ = try appendToken(rp.c, .RParen, ")");
27182710 _ = try appendToken(rp.c, .LBrace, "{");
27192711 // reserve +1 case in case there is no default case
......@@ -2748,7 +2740,7 @@ fn transSwitch(
27482740 switch_scope.pending_block = try Scope.Block.init(rp.c, scope, false);
27492741 try switch_scope.pending_block.statements.append(&switch_node.base);
27502742
2751 const last = try transStmt(rp, &block_scope.base, ZigClangSwitchStmt_getBody(stmt), .unused, .r_value);
2743 const last = try transStmt(rp, &block_scope.base, stmt.getBody(), .unused, .r_value);
27522744 _ = try appendToken(rp.c, .Semicolon, ";");
27532745
27542746 // take all pending statements
......@@ -2776,7 +2768,7 @@ fn transSwitch(
27762768 _ = try appendToken(rp.c, .Comma, ",");
27772769
27782770 if (switch_scope.case_index >= switch_scope.cases.len)
2779 return revertAndWarn(rp, error.UnsupportedTranslation, ZigClangStmt_getBeginLoc(@ptrCast(*const ZigClangStmt, stmt)), "TODO complex switch cases", .{});
2771 return revertAndWarn(rp, error.UnsupportedTranslation, @ptrCast(*const clang.Stmt, stmt).getBeginLoc(), "TODO complex switch cases", .{});
27802772 switch_scope.cases[switch_scope.case_index] = &else_prong.base;
27812773 switch_scope.case_index += 1;
27822774 }
......@@ -2792,15 +2784,15 @@ fn transSwitch(
27922784fn transCase(
27932785 rp: RestorePoint,
27942786 scope: *Scope,
2795 stmt: *const ZigClangCaseStmt,
2787 stmt: *const clang.CaseStmt,
27962788) TransError!*ast.Node {
27972789 const block_scope = scope.findBlockScope(rp.c) catch unreachable;
27982790 const switch_scope = scope.getSwitch();
27992791 const label = try block_scope.makeMangledName(rp.c, "case");
28002792 _ = try appendToken(rp.c, .Semicolon, ";");
28012793
2802 const expr = if (ZigClangCaseStmt_getRHS(stmt)) |rhs| blk: {
2803 const lhs_node = try transExpr(rp, scope, ZigClangCaseStmt_getLHS(stmt), .used, .r_value);
2794 const expr = if (stmt.getRHS()) |rhs| blk: {
2795 const lhs_node = try transExpr(rp, scope, stmt.getLHS(), .used, .r_value);
28042796 const ellips = try appendToken(rp.c, .Ellipsis3, "...");
28052797 const rhs_node = try transExpr(rp, scope, rhs, .used, .r_value);
28062798
......@@ -2813,7 +2805,7 @@ fn transCase(
28132805 };
28142806 break :blk &node.base;
28152807 } else
2816 try transExpr(rp, scope, ZigClangCaseStmt_getLHS(stmt), .used, .r_value);
2808 try transExpr(rp, scope, stmt.getLHS(), .used, .r_value);
28172809
28182810 const switch_prong = try transCreateNodeSwitchCase(rp.c, expr);
28192811 switch_prong.expr = blk: {
......@@ -2823,7 +2815,7 @@ fn transCase(
28232815 _ = try appendToken(rp.c, .Comma, ",");
28242816
28252817 if (switch_scope.case_index >= switch_scope.cases.len)
2826 return revertAndWarn(rp, error.UnsupportedTranslation, ZigClangStmt_getBeginLoc(@ptrCast(*const ZigClangStmt, stmt)), "TODO complex switch cases", .{});
2818 return revertAndWarn(rp, error.UnsupportedTranslation, @ptrCast(*const clang.Stmt, stmt).getBeginLoc(), "TODO complex switch cases", .{});
28272819 switch_scope.cases[switch_scope.case_index] = &switch_prong.base;
28282820 switch_scope.case_index += 1;
28292821
......@@ -2840,13 +2832,13 @@ fn transCase(
28402832
28412833 try switch_scope.pending_block.statements.append(pending_node);
28422834
2843 return transStmt(rp, scope, ZigClangCaseStmt_getSubStmt(stmt), .unused, .r_value);
2835 return transStmt(rp, scope, stmt.getSubStmt(), .unused, .r_value);
28442836}
28452837
28462838fn transDefault(
28472839 rp: RestorePoint,
28482840 scope: *Scope,
2849 stmt: *const ZigClangDefaultStmt,
2841 stmt: *const clang.DefaultStmt,
28502842) TransError!*ast.Node {
28512843 const block_scope = scope.findBlockScope(rp.c) catch unreachable;
28522844 const switch_scope = scope.getSwitch();
......@@ -2861,7 +2853,7 @@ fn transDefault(
28612853 _ = try appendToken(rp.c, .Comma, ",");
28622854
28632855 if (switch_scope.case_index >= switch_scope.cases.len)
2864 return revertAndWarn(rp, error.UnsupportedTranslation, ZigClangStmt_getBeginLoc(@ptrCast(*const ZigClangStmt, stmt)), "TODO complex switch cases", .{});
2856 return revertAndWarn(rp, error.UnsupportedTranslation, @ptrCast(*const clang.Stmt, stmt).getBeginLoc(), "TODO complex switch cases", .{});
28652857 switch_scope.cases[switch_scope.case_index] = &else_prong.base;
28662858 switch_scope.case_index += 1;
28672859
......@@ -2877,26 +2869,26 @@ fn transDefault(
28772869 switch_scope.pending_block = try Scope.Block.init(rp.c, scope, false);
28782870 try switch_scope.pending_block.statements.append(pending_node);
28792871
2880 return transStmt(rp, scope, ZigClangDefaultStmt_getSubStmt(stmt), .unused, .r_value);
2872 return transStmt(rp, scope, stmt.getSubStmt(), .unused, .r_value);
28812873}
28822874
2883fn transConstantExpr(rp: RestorePoint, scope: *Scope, expr: *const ZigClangExpr, used: ResultUsed) TransError!*ast.Node {
2884 var result: ZigClangExprEvalResult = undefined;
2885 if (!ZigClangExpr_EvaluateAsConstantExpr(expr, &result, .EvaluateForCodeGen, rp.c.clang_context))
2886 return revertAndWarn(rp, error.UnsupportedTranslation, ZigClangExpr_getBeginLoc(expr), "invalid constant expression", .{});
2875fn transConstantExpr(rp: RestorePoint, scope: *Scope, expr: *const clang.Expr, used: ResultUsed) TransError!*ast.Node {
2876 var result: clang.ExprEvalResult = undefined;
2877 if (!expr.EvaluateAsConstantExpr(&result, .EvaluateForCodeGen, rp.c.clang_context))
2878 return revertAndWarn(rp, error.UnsupportedTranslation, expr.getBeginLoc(), "invalid constant expression", .{});
28872879
28882880 var val_node: ?*ast.Node = null;
2889 switch (ZigClangAPValue_getKind(&result.Val)) {
2881 switch (result.Val.getKind()) {
28902882 .Int => {
28912883 // See comment in `transIntegerLiteral` for why this code is here.
28922884 // @as(T, x)
2893 const expr_base = @ptrCast(*const ZigClangExpr, expr);
2885 const expr_base = @ptrCast(*const clang.Expr, expr);
28942886 const as_node = try rp.c.createBuiltinCall("@as", 2);
2895 const ty_node = try transQualType(rp, ZigClangExpr_getType(expr_base), ZigClangExpr_getBeginLoc(expr_base));
2887 const ty_node = try transQualType(rp, expr_base.getType(), expr_base.getBeginLoc());
28962888 as_node.params()[0] = ty_node;
28972889 _ = try appendToken(rp.c, .Comma, ",");
28982890
2899 const int_lit_node = try transCreateNodeAPInt(rp.c, ZigClangAPValue_getInt(&result.Val));
2891 const int_lit_node = try transCreateNodeAPInt(rp.c, result.Val.getInt());
29002892 as_node.params()[1] = int_lit_node;
29012893
29022894 as_node.rparen_token = try appendToken(rp.c, .RParen, ")");
......@@ -2904,26 +2896,26 @@ fn transConstantExpr(rp: RestorePoint, scope: *Scope, expr: *const ZigClangExpr,
29042896 return maybeSuppressResult(rp, scope, used, &as_node.base);
29052897 },
29062898 else => {
2907 return revertAndWarn(rp, error.UnsupportedTranslation, ZigClangExpr_getBeginLoc(expr), "unsupported constant expression kind", .{});
2899 return revertAndWarn(rp, error.UnsupportedTranslation, expr.getBeginLoc(), "unsupported constant expression kind", .{});
29082900 },
29092901 }
29102902}
29112903
2912fn transPredefinedExpr(rp: RestorePoint, scope: *Scope, expr: *const ZigClangPredefinedExpr, used: ResultUsed) TransError!*ast.Node {
2913 return transStringLiteral(rp, scope, ZigClangPredefinedExpr_getFunctionName(expr), used);
2904fn transPredefinedExpr(rp: RestorePoint, scope: *Scope, expr: *const clang.PredefinedExpr, used: ResultUsed) TransError!*ast.Node {
2905 return transStringLiteral(rp, scope, expr.getFunctionName(), used);
29142906}
29152907
29162908fn transCharLiteral(
29172909 rp: RestorePoint,
29182910 scope: *Scope,
2919 stmt: *const ZigClangCharacterLiteral,
2911 stmt: *const clang.CharacterLiteral,
29202912 result_used: ResultUsed,
29212913 suppress_as: SuppressCast,
29222914) TransError!*ast.Node {
2923 const kind = ZigClangCharacterLiteral_getKind(stmt);
2915 const kind = stmt.getKind();
29242916 const int_lit_node = switch (kind) {
29252917 .Ascii, .UTF8 => blk: {
2926 const val = ZigClangCharacterLiteral_getValue(stmt);
2918 const val = stmt.getValue();
29272919 if (kind == .Ascii) {
29282920 // C has a somewhat obscure feature called multi-character character
29292921 // constant
......@@ -2942,7 +2934,7 @@ fn transCharLiteral(
29422934 .UTF16, .UTF32, .Wide => return revertAndWarn(
29432935 rp,
29442936 error.UnsupportedTranslation,
2945 ZigClangStmt_getBeginLoc(@ptrCast(*const ZigClangStmt, stmt)),
2937 @ptrCast(*const clang.Stmt, stmt).getBeginLoc(),
29462938 "TODO: support character literal kind {}",
29472939 .{kind},
29482940 ),
......@@ -2952,9 +2944,9 @@ fn transCharLiteral(
29522944 }
29532945 // See comment in `transIntegerLiteral` for why this code is here.
29542946 // @as(T, x)
2955 const expr_base = @ptrCast(*const ZigClangExpr, stmt);
2947 const expr_base = @ptrCast(*const clang.Expr, stmt);
29562948 const as_node = try rp.c.createBuiltinCall("@as", 2);
2957 const ty_node = try transQualType(rp, ZigClangExpr_getType(expr_base), ZigClangExpr_getBeginLoc(expr_base));
2949 const ty_node = try transQualType(rp, expr_base.getType(), expr_base.getBeginLoc());
29582950 as_node.params()[0] = ty_node;
29592951 _ = try appendToken(rp.c, .Comma, ",");
29602952 as_node.params()[1] = int_lit_node;
......@@ -2963,8 +2955,8 @@ fn transCharLiteral(
29632955 return maybeSuppressResult(rp, scope, result_used, &as_node.base);
29642956}
29652957
2966fn transStmtExpr(rp: RestorePoint, scope: *Scope, stmt: *const ZigClangStmtExpr, used: ResultUsed) TransError!*ast.Node {
2967 const comp = ZigClangStmtExpr_getSubStmt(stmt);
2958fn transStmtExpr(rp: RestorePoint, scope: *Scope, stmt: *const clang.StmtExpr, used: ResultUsed) TransError!*ast.Node {
2959 const comp = stmt.getSubStmt();
29682960 if (used == .unused) {
29692961 return transCompoundStmt(rp, scope, comp);
29702962 }
......@@ -2972,8 +2964,8 @@ fn transStmtExpr(rp: RestorePoint, scope: *Scope, stmt: *const ZigClangStmtExpr,
29722964 var block_scope = try Scope.Block.init(rp.c, scope, true);
29732965 defer block_scope.deinit();
29742966
2975 var it = ZigClangCompoundStmt_body_begin(comp);
2976 const end_it = ZigClangCompoundStmt_body_end(comp);
2967 var it = comp.body_begin();
2968 const end_it = comp.body_end();
29772969 while (it != end_it - 1) : (it += 1) {
29782970 const result = try transStmt(rp, &block_scope.base, it[0], .unused, .r_value);
29792971 try block_scope.statements.append(result);
......@@ -2996,43 +2988,43 @@ fn transStmtExpr(rp: RestorePoint, scope: *Scope, stmt: *const ZigClangStmtExpr,
29962988 return maybeSuppressResult(rp, scope, used, &grouped_expr.base);
29972989}
29982990
2999fn transMemberExpr(rp: RestorePoint, scope: *Scope, stmt: *const ZigClangMemberExpr, result_used: ResultUsed) TransError!*ast.Node {
3000 var container_node = try transExpr(rp, scope, ZigClangMemberExpr_getBase(stmt), .used, .r_value);
2991fn transMemberExpr(rp: RestorePoint, scope: *Scope, stmt: *const clang.MemberExpr, result_used: ResultUsed) TransError!*ast.Node {
2992 var container_node = try transExpr(rp, scope, stmt.getBase(), .used, .r_value);
30012993
3002 if (ZigClangMemberExpr_isArrow(stmt)) {
2994 if (stmt.isArrow()) {
30032995 container_node = try transCreateNodePtrDeref(rp.c, container_node);
30042996 }
30052997
3006 const member_decl = ZigClangMemberExpr_getMemberDecl(stmt);
2998 const member_decl = stmt.getMemberDecl();
30072999 const name = blk: {
3008 const decl_kind = ZigClangDecl_getKind(@ptrCast(*const ZigClangDecl, member_decl));
3000 const decl_kind = @ptrCast(*const clang.Decl, member_decl).getKind();
30093001 // If we're referring to a anonymous struct/enum find the bogus name
30103002 // we've assigned to it during the RecordDecl translation
30113003 if (decl_kind == .Field) {
3012 const field_decl = @ptrCast(*const struct_ZigClangFieldDecl, member_decl);
3013 if (ZigClangFieldDecl_isAnonymousStructOrUnion(field_decl)) {
3014 const name = rp.c.decl_table.get(@ptrToInt(ZigClangFieldDecl_getCanonicalDecl(field_decl))).?;
3004 const field_decl = @ptrCast(*const clang.FieldDecl, member_decl);
3005 if (field_decl.isAnonymousStructOrUnion()) {
3006 const name = rp.c.decl_table.get(@ptrToInt(field_decl.getCanonicalDecl())).?;
30153007 break :blk try mem.dupe(rp.c.arena, u8, name);
30163008 }
30173009 }
3018 const decl = @ptrCast(*const ZigClangNamedDecl, member_decl);
3019 break :blk try rp.c.str(ZigClangNamedDecl_getName_bytes_begin(decl));
3010 const decl = @ptrCast(*const clang.NamedDecl, member_decl);
3011 break :blk try rp.c.str(decl.getName_bytes_begin());
30203012 };
30213013
30223014 const node = try transCreateNodeFieldAccess(rp.c, container_node, name);
30233015 return maybeSuppressResult(rp, scope, result_used, node);
30243016}
30253017
3026fn transArrayAccess(rp: RestorePoint, scope: *Scope, stmt: *const ZigClangArraySubscriptExpr, result_used: ResultUsed) TransError!*ast.Node {
3027 var base_stmt = ZigClangArraySubscriptExpr_getBase(stmt);
3018fn transArrayAccess(rp: RestorePoint, scope: *Scope, stmt: *const clang.ArraySubscriptExpr, result_used: ResultUsed) TransError!*ast.Node {
3019 var base_stmt = stmt.getBase();
30283020
30293021 // Unwrap the base statement if it's an array decayed to a bare pointer type
30303022 // so that we index the array itself
3031 if (ZigClangStmt_getStmtClass(@ptrCast(*const ZigClangStmt, base_stmt)) == .ImplicitCastExprClass) {
3032 const implicit_cast = @ptrCast(*const ZigClangImplicitCastExpr, base_stmt);
3023 if (@ptrCast(*const clang.Stmt, base_stmt).getStmtClass() == .ImplicitCastExprClass) {
3024 const implicit_cast = @ptrCast(*const clang.ImplicitCastExpr, base_stmt);
30333025
3034 if (ZigClangImplicitCastExpr_getCastKind(implicit_cast) == .ArrayToPointerDecay) {
3035 base_stmt = ZigClangImplicitCastExpr_getSubExpr(implicit_cast);
3026 if (implicit_cast.getCastKind() == .ArrayToPointerDecay) {
3027 base_stmt = implicit_cast.getSubExpr();
30363028 }
30373029 }
30383030
......@@ -3040,7 +3032,7 @@ fn transArrayAccess(rp: RestorePoint, scope: *Scope, stmt: *const ZigClangArrayS
30403032 const node = try transCreateNodeArrayAccess(rp.c, container_node);
30413033
30423034 // cast if the index is long long or signed
3043 const subscr_expr = ZigClangArraySubscriptExpr_getIdx(stmt);
3035 const subscr_expr = stmt.getIdx();
30443036 const qt = getExprQualType(rp.c, subscr_expr);
30453037 const is_longlong = cIsLongLongInteger(qt);
30463038 const is_signed = cIsSignedInteger(qt);
......@@ -3062,23 +3054,23 @@ fn transArrayAccess(rp: RestorePoint, scope: *Scope, stmt: *const ZigClangArrayS
30623054 return maybeSuppressResult(rp, scope, result_used, &node.base);
30633055}
30643056
3065fn transCallExpr(rp: RestorePoint, scope: *Scope, stmt: *const ZigClangCallExpr, result_used: ResultUsed) TransError!*ast.Node {
3066 const callee = ZigClangCallExpr_getCallee(stmt);
3057fn transCallExpr(rp: RestorePoint, scope: *Scope, stmt: *const clang.CallExpr, result_used: ResultUsed) TransError!*ast.Node {
3058 const callee = stmt.getCallee();
30673059 var raw_fn_expr = try transExpr(rp, scope, callee, .used, .r_value);
30683060
30693061 var is_ptr = false;
3070 const fn_ty = qualTypeGetFnProto(ZigClangExpr_getType(callee), &is_ptr);
3062 const fn_ty = qualTypeGetFnProto(callee.getType(), &is_ptr);
30713063
30723064 const fn_expr = if (is_ptr and fn_ty != null) blk: {
3073 if (ZigClangExpr_getStmtClass(callee) == .ImplicitCastExprClass) {
3074 const implicit_cast = @ptrCast(*const ZigClangImplicitCastExpr, callee);
3075
3076 if (ZigClangImplicitCastExpr_getCastKind(implicit_cast) == .FunctionToPointerDecay) {
3077 const subexpr = ZigClangImplicitCastExpr_getSubExpr(implicit_cast);
3078 if (ZigClangExpr_getStmtClass(subexpr) == .DeclRefExprClass) {
3079 const decl_ref = @ptrCast(*const ZigClangDeclRefExpr, subexpr);
3080 const named_decl = ZigClangDeclRefExpr_getFoundDecl(decl_ref);
3081 if (ZigClangDecl_getKind(@ptrCast(*const ZigClangDecl, named_decl)) == .Function) {
3065 if (callee.getStmtClass() == .ImplicitCastExprClass) {
3066 const implicit_cast = @ptrCast(*const clang.ImplicitCastExpr, callee);
3067
3068 if (implicit_cast.getCastKind() == .FunctionToPointerDecay) {
3069 const subexpr = implicit_cast.getSubExpr();
3070 if (subexpr.getStmtClass() == .DeclRefExprClass) {
3071 const decl_ref = @ptrCast(*const clang.DeclRefExpr, subexpr);
3072 const named_decl = decl_ref.getFoundDecl();
3073 if (@ptrCast(*const clang.Decl, named_decl).getKind() == .Function) {
30823074 break :blk raw_fn_expr;
30833075 }
30843076 }
......@@ -3088,11 +3080,11 @@ fn transCallExpr(rp: RestorePoint, scope: *Scope, stmt: *const ZigClangCallExpr,
30883080 } else
30893081 raw_fn_expr;
30903082
3091 const num_args = ZigClangCallExpr_getNumArgs(stmt);
3083 const num_args = stmt.getNumArgs();
30923084 const node = try rp.c.createCall(fn_expr, num_args);
30933085 const call_params = node.params();
30943086
3095 const args = ZigClangCallExpr_getArgs(stmt);
3087 const args = stmt.getArgs();
30963088 var i: usize = 0;
30973089 while (i < num_args) : (i += 1) {
30983090 if (i != 0) {
......@@ -3103,9 +3095,9 @@ fn transCallExpr(rp: RestorePoint, scope: *Scope, stmt: *const ZigClangCallExpr,
31033095 node.rtoken = try appendToken(rp.c, .RParen, ")");
31043096
31053097 if (fn_ty) |ty| {
3106 const canon = ZigClangQualType_getCanonicalType(ty.getReturnType());
3107 const ret_ty = ZigClangQualType_getTypePtr(canon);
3108 if (ZigClangType_isVoidType(ret_ty)) {
3098 const canon = ty.getReturnType().getCanonicalType();
3099 const ret_ty = canon.getTypePtr();
3100 if (ret_ty.isVoidType()) {
31093101 _ = try appendToken(rp.c, .Semicolon, ";");
31103102 return &node.base;
31113103 }
......@@ -3115,32 +3107,32 @@ fn transCallExpr(rp: RestorePoint, scope: *Scope, stmt: *const ZigClangCallExpr,
31153107}
31163108
31173109const ClangFunctionType = union(enum) {
3118 Proto: *const ZigClangFunctionProtoType,
3119 NoProto: *const ZigClangFunctionType,
3110 Proto: *const clang.FunctionProtoType,
3111 NoProto: *const clang.FunctionType,
31203112
3121 fn getReturnType(self: @This()) ZigClangQualType {
3113 fn getReturnType(self: @This()) clang.QualType {
31223114 switch (@as(@TagType(@This()), self)) {
3123 .Proto => return ZigClangFunctionProtoType_getReturnType(self.Proto),
3124 .NoProto => return ZigClangFunctionType_getReturnType(self.NoProto),
3115 .Proto => return self.Proto.getReturnType(),
3116 .NoProto => return self.NoProto.getReturnType(),
31253117 }
31263118 }
31273119};
31283120
3129fn qualTypeGetFnProto(qt: ZigClangQualType, is_ptr: *bool) ?ClangFunctionType {
3130 const canon = ZigClangQualType_getCanonicalType(qt);
3131 var ty = ZigClangQualType_getTypePtr(canon);
3121fn qualTypeGetFnProto(qt: clang.QualType, is_ptr: *bool) ?ClangFunctionType {
3122 const canon = qt.getCanonicalType();
3123 var ty = canon.getTypePtr();
31323124 is_ptr.* = false;
31333125
3134 if (ZigClangType_getTypeClass(ty) == .Pointer) {
3126 if (ty.getTypeClass() == .Pointer) {
31353127 is_ptr.* = true;
3136 const child_qt = ZigClangType_getPointeeType(ty);
3137 ty = ZigClangQualType_getTypePtr(child_qt);
3128 const child_qt = ty.getPointeeType();
3129 ty = child_qt.getTypePtr();
31383130 }
3139 if (ZigClangType_getTypeClass(ty) == .FunctionProto) {
3140 return ClangFunctionType{ .Proto = @ptrCast(*const ZigClangFunctionProtoType, ty) };
3131 if (ty.getTypeClass() == .FunctionProto) {
3132 return ClangFunctionType{ .Proto = @ptrCast(*const clang.FunctionProtoType, ty) };
31413133 }
3142 if (ZigClangType_getTypeClass(ty) == .FunctionNoProto) {
3143 return ClangFunctionType{ .NoProto = @ptrCast(*const ZigClangFunctionType, ty) };
3134 if (ty.getTypeClass() == .FunctionNoProto) {
3135 return ClangFunctionType{ .NoProto = @ptrCast(*const clang.FunctionType, ty) };
31443136 }
31453137 return null;
31463138}
......@@ -3148,17 +3140,17 @@ fn qualTypeGetFnProto(qt: ZigClangQualType, is_ptr: *bool) ?ClangFunctionType {
31483140fn transUnaryExprOrTypeTraitExpr(
31493141 rp: RestorePoint,
31503142 scope: *Scope,
3151 stmt: *const ZigClangUnaryExprOrTypeTraitExpr,
3143 stmt: *const clang.UnaryExprOrTypeTraitExpr,
31523144 result_used: ResultUsed,
31533145) TransError!*ast.Node {
3154 const loc = ZigClangUnaryExprOrTypeTraitExpr_getBeginLoc(stmt);
3146 const loc = stmt.getBeginLoc();
31553147 const type_node = try transQualType(
31563148 rp,
3157 ZigClangUnaryExprOrTypeTraitExpr_getTypeOfArgument(stmt),
3149 stmt.getTypeOfArgument(),
31583150 loc,
31593151 );
31603152
3161 const kind = ZigClangUnaryExprOrTypeTraitExpr_getKind(stmt);
3153 const kind = stmt.getKind();
31623154 const kind_str = switch (kind) {
31633155 .SizeOf => "@sizeOf",
31643156 .AlignOf => "@alignOf",
......@@ -3180,7 +3172,7 @@ fn transUnaryExprOrTypeTraitExpr(
31803172 return maybeSuppressResult(rp, scope, result_used, &builtin_node.base);
31813173}
31823174
3183fn qualTypeHasWrappingOverflow(qt: ZigClangQualType) bool {
3175fn qualTypeHasWrappingOverflow(qt: clang.QualType) bool {
31843176 if (cIsUnsignedInteger(qt)) {
31853177 // unsigned integer overflow wraps around.
31863178 return true;
......@@ -3190,22 +3182,22 @@ fn qualTypeHasWrappingOverflow(qt: ZigClangQualType) bool {
31903182 }
31913183}
31923184
3193fn transUnaryOperator(rp: RestorePoint, scope: *Scope, stmt: *const ZigClangUnaryOperator, used: ResultUsed) TransError!*ast.Node {
3194 const op_expr = ZigClangUnaryOperator_getSubExpr(stmt);
3195 switch (ZigClangUnaryOperator_getOpcode(stmt)) {
3196 .PostInc => if (qualTypeHasWrappingOverflow(ZigClangUnaryOperator_getType(stmt)))
3185fn transUnaryOperator(rp: RestorePoint, scope: *Scope, stmt: *const clang.UnaryOperator, used: ResultUsed) TransError!*ast.Node {
3186 const op_expr = stmt.getSubExpr();
3187 switch (stmt.getOpcode()) {
3188 .PostInc => if (qualTypeHasWrappingOverflow(stmt.getType()))
31973189 return transCreatePostCrement(rp, scope, stmt, .AssignAddWrap, .PlusPercentEqual, "+%=", used)
31983190 else
31993191 return transCreatePostCrement(rp, scope, stmt, .AssignAdd, .PlusEqual, "+=", used),
3200 .PostDec => if (qualTypeHasWrappingOverflow(ZigClangUnaryOperator_getType(stmt)))
3192 .PostDec => if (qualTypeHasWrappingOverflow(stmt.getType()))
32013193 return transCreatePostCrement(rp, scope, stmt, .AssignSubWrap, .MinusPercentEqual, "-%=", used)
32023194 else
32033195 return transCreatePostCrement(rp, scope, stmt, .AssignSub, .MinusEqual, "-=", used),
3204 .PreInc => if (qualTypeHasWrappingOverflow(ZigClangUnaryOperator_getType(stmt)))
3196 .PreInc => if (qualTypeHasWrappingOverflow(stmt.getType()))
32053197 return transCreatePreCrement(rp, scope, stmt, .AssignAddWrap, .PlusPercentEqual, "+%=", used)
32063198 else
32073199 return transCreatePreCrement(rp, scope, stmt, .AssignAdd, .PlusEqual, "+=", used),
3208 .PreDec => if (qualTypeHasWrappingOverflow(ZigClangUnaryOperator_getType(stmt)))
3200 .PreDec => if (qualTypeHasWrappingOverflow(stmt.getType()))
32093201 return transCreatePreCrement(rp, scope, stmt, .AssignSubWrap, .MinusPercentEqual, "-%=", used)
32103202 else
32113203 return transCreatePreCrement(rp, scope, stmt, .AssignSub, .MinusEqual, "-=", used),
......@@ -3217,7 +3209,7 @@ fn transUnaryOperator(rp: RestorePoint, scope: *Scope, stmt: *const ZigClangUnar
32173209 .Deref => {
32183210 const value_node = try transExpr(rp, scope, op_expr, used, .r_value);
32193211 var is_ptr = false;
3220 const fn_ty = qualTypeGetFnProto(ZigClangExpr_getType(op_expr), &is_ptr);
3212 const fn_ty = qualTypeGetFnProto(op_expr.getType(), &is_ptr);
32213213 if (fn_ty != null and is_ptr)
32223214 return value_node;
32233215 const unwrapped = try transCreateNodeUnwrapNull(rp.c, value_node);
......@@ -3225,18 +3217,18 @@ fn transUnaryOperator(rp: RestorePoint, scope: *Scope, stmt: *const ZigClangUnar
32253217 },
32263218 .Plus => return transExpr(rp, scope, op_expr, used, .r_value),
32273219 .Minus => {
3228 if (!qualTypeHasWrappingOverflow(ZigClangExpr_getType(op_expr))) {
3220 if (!qualTypeHasWrappingOverflow(op_expr.getType())) {
32293221 const op_node = try transCreateNodeSimplePrefixOp(rp.c, .Negation, .Minus, "-");
32303222 op_node.rhs = try transExpr(rp, scope, op_expr, .used, .r_value);
32313223 return &op_node.base;
3232 } else if (cIsUnsignedInteger(ZigClangExpr_getType(op_expr))) {
3224 } else if (cIsUnsignedInteger(op_expr.getType())) {
32333225 // we gotta emit 0 -% x
32343226 const zero = try transCreateNodeInt(rp.c, 0);
32353227 const token = try appendToken(rp.c, .MinusPercent, "-%");
32363228 const expr = try transExpr(rp, scope, op_expr, .used, .r_value);
32373229 return transCreateNodeInfixOp(rp, scope, zero, .SubWrap, token, expr, used, true);
32383230 } else
3239 return revertAndWarn(rp, error.UnsupportedTranslation, ZigClangUnaryOperator_getBeginLoc(stmt), "C negation with non float non integer", .{});
3231 return revertAndWarn(rp, error.UnsupportedTranslation, stmt.getBeginLoc(), "C negation with non float non integer", .{});
32403232 },
32413233 .Not => {
32423234 const op_node = try transCreateNodeSimplePrefixOp(rp.c, .BitNot, .Tilde, "~");
......@@ -3249,22 +3241,22 @@ fn transUnaryOperator(rp: RestorePoint, scope: *Scope, stmt: *const ZigClangUnar
32493241 return &op_node.base;
32503242 },
32513243 .Extension => {
3252 return transExpr(rp, scope, ZigClangUnaryOperator_getSubExpr(stmt), used, .l_value);
3244 return transExpr(rp, scope, stmt.getSubExpr(), used, .l_value);
32533245 },
3254 else => return revertAndWarn(rp, error.UnsupportedTranslation, ZigClangUnaryOperator_getBeginLoc(stmt), "unsupported C translation {}", .{ZigClangUnaryOperator_getOpcode(stmt)}),
3246 else => return revertAndWarn(rp, error.UnsupportedTranslation, stmt.getBeginLoc(), "unsupported C translation {}", .{stmt.getOpcode()}),
32553247 }
32563248}
32573249
32583250fn transCreatePreCrement(
32593251 rp: RestorePoint,
32603252 scope: *Scope,
3261 stmt: *const ZigClangUnaryOperator,
3253 stmt: *const clang.UnaryOperator,
32623254 op: ast.Node.Tag,
32633255 op_tok_id: std.zig.Token.Id,
32643256 bytes: []const u8,
32653257 used: ResultUsed,
32663258) TransError!*ast.Node {
3267 const op_expr = ZigClangUnaryOperator_getSubExpr(stmt);
3259 const op_expr = stmt.getSubExpr();
32683260
32693261 if (used == .unused) {
32703262 // common case
......@@ -3331,13 +3323,13 @@ fn transCreatePreCrement(
33313323fn transCreatePostCrement(
33323324 rp: RestorePoint,
33333325 scope: *Scope,
3334 stmt: *const ZigClangUnaryOperator,
3326 stmt: *const clang.UnaryOperator,
33353327 op: ast.Node.Tag,
33363328 op_tok_id: std.zig.Token.Id,
33373329 bytes: []const u8,
33383330 used: ResultUsed,
33393331) TransError!*ast.Node {
3340 const op_expr = ZigClangUnaryOperator_getSubExpr(stmt);
3332 const op_expr = stmt.getSubExpr();
33413333
33423334 if (used == .unused) {
33433335 // common case
......@@ -3422,17 +3414,17 @@ fn transCreatePostCrement(
34223414 return &grouped_expr.base;
34233415}
34243416
3425fn transCompoundAssignOperator(rp: RestorePoint, scope: *Scope, stmt: *const ZigClangCompoundAssignOperator, used: ResultUsed) TransError!*ast.Node {
3426 switch (ZigClangCompoundAssignOperator_getOpcode(stmt)) {
3427 .MulAssign => if (qualTypeHasWrappingOverflow(ZigClangCompoundAssignOperator_getType(stmt)))
3417fn transCompoundAssignOperator(rp: RestorePoint, scope: *Scope, stmt: *const clang.CompoundAssignOperator, used: ResultUsed) TransError!*ast.Node {
3418 switch (stmt.getOpcode()) {
3419 .MulAssign => if (qualTypeHasWrappingOverflow(stmt.getType()))
34283420 return transCreateCompoundAssign(rp, scope, stmt, .AssignMulWrap, .AsteriskPercentEqual, "*%=", .MulWrap, .AsteriskPercent, "*%", used)
34293421 else
34303422 return transCreateCompoundAssign(rp, scope, stmt, .AssignMul, .AsteriskEqual, "*=", .Mul, .Asterisk, "*", used),
3431 .AddAssign => if (qualTypeHasWrappingOverflow(ZigClangCompoundAssignOperator_getType(stmt)))
3423 .AddAssign => if (qualTypeHasWrappingOverflow(stmt.getType()))
34323424 return transCreateCompoundAssign(rp, scope, stmt, .AssignAddWrap, .PlusPercentEqual, "+%=", .AddWrap, .PlusPercent, "+%", used)
34333425 else
34343426 return transCreateCompoundAssign(rp, scope, stmt, .AssignAdd, .PlusEqual, "+=", .Add, .Plus, "+", used),
3435 .SubAssign => if (qualTypeHasWrappingOverflow(ZigClangCompoundAssignOperator_getType(stmt)))
3427 .SubAssign => if (qualTypeHasWrappingOverflow(stmt.getType()))
34363428 return transCreateCompoundAssign(rp, scope, stmt, .AssignSubWrap, .MinusPercentEqual, "-%=", .SubWrap, .MinusPercent, "-%", used)
34373429 else
34383430 return transCreateCompoundAssign(rp, scope, stmt, .AssignSub, .MinusPercentEqual, "-=", .Sub, .Minus, "-", used),
......@@ -3446,9 +3438,9 @@ fn transCompoundAssignOperator(rp: RestorePoint, scope: *Scope, stmt: *const Zig
34463438 else => return revertAndWarn(
34473439 rp,
34483440 error.UnsupportedTranslation,
3449 ZigClangCompoundAssignOperator_getBeginLoc(stmt),
3441 stmt.getBeginLoc(),
34503442 "unsupported C translation {}",
3451 .{ZigClangCompoundAssignOperator_getOpcode(stmt)},
3443 .{stmt.getOpcode()},
34523444 ),
34533445 }
34543446}
......@@ -3456,7 +3448,7 @@ fn transCompoundAssignOperator(rp: RestorePoint, scope: *Scope, stmt: *const Zig
34563448fn transCreateCompoundAssign(
34573449 rp: RestorePoint,
34583450 scope: *Scope,
3459 stmt: *const ZigClangCompoundAssignOperator,
3451 stmt: *const clang.CompoundAssignOperator,
34603452 assign_op: ast.Node.Tag,
34613453 assign_tok_id: std.zig.Token.Id,
34623454 assign_bytes: []const u8,
......@@ -3468,9 +3460,9 @@ fn transCreateCompoundAssign(
34683460 const is_shift = bin_op == .BitShiftLeft or bin_op == .BitShiftRight;
34693461 const is_div = bin_op == .Div;
34703462 const is_mod = bin_op == .Mod;
3471 const lhs = ZigClangCompoundAssignOperator_getLHS(stmt);
3472 const rhs = ZigClangCompoundAssignOperator_getRHS(stmt);
3473 const loc = ZigClangCompoundAssignOperator_getBeginLoc(stmt);
3463 const lhs = stmt.getLHS();
3464 const rhs = stmt.getRHS();
3465 const loc = stmt.getBeginLoc();
34743466 const lhs_qt = getExprQualType(rp.c, lhs);
34753467 const rhs_qt = getExprQualType(rp.c, rhs);
34763468 const is_signed = cIsSignedInteger(lhs_qt);
......@@ -3615,20 +3607,20 @@ fn transCreateCompoundAssign(
36153607
36163608fn transCPtrCast(
36173609 rp: RestorePoint,
3618 loc: ZigClangSourceLocation,
3619 dst_type: ZigClangQualType,
3620 src_type: ZigClangQualType,
3610 loc: clang.SourceLocation,
3611 dst_type: clang.QualType,
3612 src_type: clang.QualType,
36213613 expr: *ast.Node,
36223614) !*ast.Node {
3623 const ty = ZigClangQualType_getTypePtr(dst_type);
3624 const child_type = ZigClangType_getPointeeType(ty);
3625 const src_ty = ZigClangQualType_getTypePtr(src_type);
3626 const src_child_type = ZigClangType_getPointeeType(src_ty);
3627
3628 if ((ZigClangQualType_isConstQualified(src_child_type) and
3629 !ZigClangQualType_isConstQualified(child_type)) or
3630 (ZigClangQualType_isVolatileQualified(src_child_type) and
3631 !ZigClangQualType_isVolatileQualified(child_type)))
3615 const ty = dst_type.getTypePtr();
3616 const child_type = ty.getPointeeType();
3617 const src_ty = src_type.getTypePtr();
3618 const src_child_type = src_ty.getPointeeType();
3619
3620 if ((src_child_type.isConstQualified() and
3621 !child_type.isConstQualified()) or
3622 (src_child_type.isVolatileQualified() and
3623 !child_type.isVolatileQualified()))
36323624 {
36333625 // Casting away const or volatile requires us to use @intToPtr
36343626 const inttoptr_node = try rp.c.createBuiltinCall("@intToPtr", 2);
......@@ -3651,7 +3643,7 @@ fn transCPtrCast(
36513643 ptrcast_node.params()[0] = dst_type_node;
36523644 _ = try appendToken(rp.c, .Comma, ",");
36533645
3654 if (ZigClangType_isVoidType(qualTypeCanon(child_type))) {
3646 if (qualTypeCanon(child_type).isVoidType()) {
36553647 // void has 1-byte alignment, so @alignCast is not needed
36563648 ptrcast_node.params()[1] = expr;
36573649 } else if (typeIsOpaque(rp.c, qualTypeCanon(child_type), loc)) {
......@@ -3691,9 +3683,9 @@ fn transBreak(rp: RestorePoint, scope: *Scope) TransError!*ast.Node {
36913683 return &br.base;
36923684}
36933685
3694fn transFloatingLiteral(rp: RestorePoint, scope: *Scope, stmt: *const ZigClangFloatingLiteral, used: ResultUsed) TransError!*ast.Node {
3686fn transFloatingLiteral(rp: RestorePoint, scope: *Scope, stmt: *const clang.FloatingLiteral, used: ResultUsed) TransError!*ast.Node {
36953687 // TODO use something more accurate
3696 const dbl = ZigClangAPFloat_getValueAsApproximateDouble(stmt);
3688 const dbl = stmt.getValueAsApproximateDouble();
36973689 const node = try rp.c.arena.create(ast.Node.OneToken);
36983690 node.* = .{
36993691 .base = .{ .tag = .FloatLiteral },
......@@ -3702,13 +3694,13 @@ fn transFloatingLiteral(rp: RestorePoint, scope: *Scope, stmt: *const ZigClangFl
37023694 return maybeSuppressResult(rp, scope, used, &node.base);
37033695}
37043696
3705fn transBinaryConditionalOperator(rp: RestorePoint, scope: *Scope, stmt: *const ZigClangBinaryConditionalOperator, used: ResultUsed) TransError!*ast.Node {
3697fn transBinaryConditionalOperator(rp: RestorePoint, scope: *Scope, stmt: *const clang.BinaryConditionalOperator, used: ResultUsed) TransError!*ast.Node {
37063698 // GNU extension of the ternary operator where the middle expression is
37073699 // omitted, the conditition itself is returned if it evaluates to true
3708 const casted_stmt = @ptrCast(*const ZigClangAbstractConditionalOperator, stmt);
3709 const cond_expr = ZigClangAbstractConditionalOperator_getCond(casted_stmt);
3710 const true_expr = ZigClangAbstractConditionalOperator_getTrueExpr(casted_stmt);
3711 const false_expr = ZigClangAbstractConditionalOperator_getFalseExpr(casted_stmt);
3700 const casted_stmt = @ptrCast(*const clang.AbstractConditionalOperator, stmt);
3701 const cond_expr = casted_stmt.getCond();
3702 const true_expr = casted_stmt.getTrueExpr();
3703 const false_expr = casted_stmt.getFalseExpr();
37123704
37133705 // c: (cond_expr)?:(false_expr)
37143706 // zig: (blk: {
......@@ -3748,8 +3740,8 @@ fn transBinaryConditionalOperator(rp: RestorePoint, scope: *Scope, stmt: *const
37483740 defer cond_scope.deinit();
37493741 const tmp_var_node = try transCreateNodeIdentifier(rp.c, mangled_name);
37503742
3751 const ty = ZigClangQualType_getTypePtr(getExprQualType(rp.c, cond_expr));
3752 const cond_node = try finishBoolExpr(rp, &cond_scope.base, ZigClangExpr_getBeginLoc(cond_expr), ty, tmp_var_node, used);
3743 const ty = getExprQualType(rp.c, cond_expr).getTypePtr();
3744 const cond_node = try finishBoolExpr(rp, &cond_scope.base, cond_expr.getBeginLoc(), ty, tmp_var_node, used);
37533745 if_node.condition = cond_node;
37543746 _ = try appendToken(rp.c, .RParen, ")");
37553747
......@@ -3772,7 +3764,7 @@ fn transBinaryConditionalOperator(rp: RestorePoint, scope: *Scope, stmt: *const
37723764 return maybeSuppressResult(rp, scope, used, &grouped_expr.base);
37733765}
37743766
3775fn transConditionalOperator(rp: RestorePoint, scope: *Scope, stmt: *const ZigClangConditionalOperator, used: ResultUsed) TransError!*ast.Node {
3767fn transConditionalOperator(rp: RestorePoint, scope: *Scope, stmt: *const clang.ConditionalOperator, used: ResultUsed) TransError!*ast.Node {
37763768 const grouped = scope.id == .Condition;
37773769 const lparen = if (grouped) try appendToken(rp.c, .LParen, "(") else undefined;
37783770 const if_node = try transCreateNodeIf(rp.c);
......@@ -3784,10 +3776,10 @@ fn transConditionalOperator(rp: RestorePoint, scope: *Scope, stmt: *const ZigCla
37843776 };
37853777 defer cond_scope.deinit();
37863778
3787 const casted_stmt = @ptrCast(*const ZigClangAbstractConditionalOperator, stmt);
3788 const cond_expr = ZigClangAbstractConditionalOperator_getCond(casted_stmt);
3789 const true_expr = ZigClangAbstractConditionalOperator_getTrueExpr(casted_stmt);
3790 const false_expr = ZigClangAbstractConditionalOperator_getFalseExpr(casted_stmt);
3779 const casted_stmt = @ptrCast(*const clang.AbstractConditionalOperator, stmt);
3780 const cond_expr = casted_stmt.getCond();
3781 const true_expr = casted_stmt.getTrueExpr();
3782 const false_expr = casted_stmt.getFalseExpr();
37913783
37923784 if_node.condition = try transBoolExpr(rp, &cond_scope.base, cond_expr, .used, .r_value, false);
37933785 _ = try appendToken(rp.c, .RParen, ")");
......@@ -3845,22 +3837,22 @@ fn addTopLevelDecl(c: *Context, name: []const u8, decl_node: *ast.Node) !void {
38453837 _ = try c.global_scope.sym_table.put(name, decl_node);
38463838}
38473839
3848fn transQualType(rp: RestorePoint, qt: ZigClangQualType, source_loc: ZigClangSourceLocation) TypeError!*ast.Node {
3849 return transType(rp, ZigClangQualType_getTypePtr(qt), source_loc);
3840fn transQualType(rp: RestorePoint, qt: clang.QualType, source_loc: clang.SourceLocation) TypeError!*ast.Node {
3841 return transType(rp, qt.getTypePtr(), source_loc);
38503842}
38513843
38523844/// Produces a Zig AST node by translating a Clang QualType, respecting the width, but modifying the signed-ness.
38533845/// Asserts the type is an integer.
3854fn transQualTypeIntWidthOf(c: *Context, ty: ZigClangQualType, is_signed: bool) TypeError!*ast.Node {
3846fn transQualTypeIntWidthOf(c: *Context, ty: clang.QualType, is_signed: bool) TypeError!*ast.Node {
38553847 return transTypeIntWidthOf(c, qualTypeCanon(ty), is_signed);
38563848}
38573849
38583850/// Produces a Zig AST node by translating a Clang Type, respecting the width, but modifying the signed-ness.
38593851/// Asserts the type is an integer.
3860fn transTypeIntWidthOf(c: *Context, ty: *const ZigClangType, is_signed: bool) TypeError!*ast.Node {
3861 assert(ZigClangType_getTypeClass(ty) == .Builtin);
3862 const builtin_ty = @ptrCast(*const ZigClangBuiltinType, ty);
3863 return transCreateNodeIdentifier(c, switch (ZigClangBuiltinType_getKind(builtin_ty)) {
3852fn transTypeIntWidthOf(c: *Context, ty: *const clang.Type, is_signed: bool) TypeError!*ast.Node {
3853 assert(ty.getTypeClass() == .Builtin);
3854 const builtin_ty = @ptrCast(*const clang.BuiltinType, ty);
3855 return transCreateNodeIdentifier(c, switch (builtin_ty.getKind()) {
38643856 .Char_U, .Char_S, .UChar, .SChar, .Char8 => if (is_signed) "i8" else "u8",
38653857 .UShort, .Short => if (is_signed) "c_short" else "c_ushort",
38663858 .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
38733865 });
38743866}
38753867
3876fn isCBuiltinType(qt: ZigClangQualType, kind: ZigClangBuiltinTypeKind) bool {
3868fn isCBuiltinType(qt: clang.QualType, kind: clang.BuiltinTypeKind) bool {
38773869 const c_type = qualTypeCanon(qt);
3878 if (ZigClangType_getTypeClass(c_type) != .Builtin)
3870 if (c_type.getTypeClass() != .Builtin)
38793871 return false;
3880 const builtin_ty = @ptrCast(*const ZigClangBuiltinType, c_type);
3881 return ZigClangBuiltinType_getKind(builtin_ty) == kind;
3872 const builtin_ty = @ptrCast(*const clang.BuiltinType, c_type);
3873 return builtin_ty.getKind() == kind;
38823874}
38833875
3884fn qualTypeIsPtr(qt: ZigClangQualType) bool {
3885 return ZigClangType_getTypeClass(qualTypeCanon(qt)) == .Pointer;
3876fn qualTypeIsPtr(qt: clang.QualType) bool {
3877 return qualTypeCanon(qt).getTypeClass() == .Pointer;
38863878}
38873879
3888fn qualTypeIsBoolean(qt: ZigClangQualType) bool {
3889 return ZigClangType_isBooleanType(qualTypeCanon(qt));
3880fn qualTypeIsBoolean(qt: clang.QualType) bool {
3881 return qualTypeCanon(qt).isBooleanType();
38903882}
38913883
3892fn qualTypeIntBitWidth(rp: RestorePoint, qt: ZigClangQualType, source_loc: ZigClangSourceLocation) !u32 {
3893 const ty = ZigClangQualType_getTypePtr(qt);
3884fn qualTypeIntBitWidth(rp: RestorePoint, qt: clang.QualType, source_loc: clang.SourceLocation) !u32 {
3885 const ty = qt.getTypePtr();
38943886
3895 switch (ZigClangType_getTypeClass(ty)) {
3887 switch (ty.getTypeClass()) {
38963888 .Builtin => {
3897 const builtin_ty = @ptrCast(*const ZigClangBuiltinType, ty);
3889 const builtin_ty = @ptrCast(*const clang.BuiltinType, ty);
38983890
3899 switch (ZigClangBuiltinType_getKind(builtin_ty)) {
3891 switch (builtin_ty.getKind()) {
39003892 .Char_U,
39013893 .UChar,
39023894 .Char_S,
......@@ -3911,9 +3903,9 @@ fn qualTypeIntBitWidth(rp: RestorePoint, qt: ZigClangQualType, source_loc: ZigCl
39113903 unreachable;
39123904 },
39133905 .Typedef => {
3914 const typedef_ty = @ptrCast(*const ZigClangTypedefType, ty);
3915 const typedef_decl = ZigClangTypedefType_getDecl(typedef_ty);
3916 const type_name = try rp.c.str(ZigClangNamedDecl_getName_bytes_begin(@ptrCast(*const ZigClangNamedDecl, typedef_decl)));
3906 const typedef_ty = @ptrCast(*const clang.TypedefType, ty);
3907 const typedef_decl = typedef_ty.getDecl();
3908 const type_name = try rp.c.str(@ptrCast(*const clang.NamedDecl, typedef_decl).getName_bytes_begin());
39173909
39183910 if (mem.eql(u8, type_name, "uint8_t") or mem.eql(u8, type_name, "int8_t")) {
39193911 return 8;
......@@ -3933,7 +3925,7 @@ fn qualTypeIntBitWidth(rp: RestorePoint, qt: ZigClangQualType, source_loc: ZigCl
39333925 unreachable;
39343926}
39353927
3936fn qualTypeToLog2IntRef(rp: RestorePoint, qt: ZigClangQualType, source_loc: ZigClangSourceLocation) !*ast.Node {
3928fn qualTypeToLog2IntRef(rp: RestorePoint, qt: clang.QualType, source_loc: clang.SourceLocation) !*ast.Node {
39373929 const int_bit_width = try qualTypeIntBitWidth(rp, qt, source_loc);
39383930
39393931 if (int_bit_width != 0) {
......@@ -3980,83 +3972,83 @@ fn qualTypeToLog2IntRef(rp: RestorePoint, qt: ZigClangQualType, source_loc: ZigC
39803972 return &log2int_fn_call.base;
39813973}
39823974
3983fn qualTypeChildIsFnProto(qt: ZigClangQualType) bool {
3975fn qualTypeChildIsFnProto(qt: clang.QualType) bool {
39843976 const ty = qualTypeCanon(qt);
39853977
3986 switch (ZigClangType_getTypeClass(ty)) {
3978 switch (ty.getTypeClass()) {
39873979 .FunctionProto, .FunctionNoProto => return true,
39883980 else => return false,
39893981 }
39903982}
39913983
3992fn qualTypeCanon(qt: ZigClangQualType) *const ZigClangType {
3993 const canon = ZigClangQualType_getCanonicalType(qt);
3994 return ZigClangQualType_getTypePtr(canon);
3984fn qualTypeCanon(qt: clang.QualType) *const clang.Type {
3985 const canon = qt.getCanonicalType();
3986 return canon.getTypePtr();
39953987}
39963988
3997fn getExprQualType(c: *Context, expr: *const ZigClangExpr) ZigClangQualType {
3989fn getExprQualType(c: *Context, expr: *const clang.Expr) clang.QualType {
39983990 blk: {
39993991 // If this is a C `char *`, turn it into a `const char *`
4000 if (ZigClangExpr_getStmtClass(expr) != .ImplicitCastExprClass) break :blk;
4001 const cast_expr = @ptrCast(*const ZigClangImplicitCastExpr, expr);
4002 if (ZigClangImplicitCastExpr_getCastKind(cast_expr) != .ArrayToPointerDecay) break :blk;
4003 const sub_expr = ZigClangImplicitCastExpr_getSubExpr(cast_expr);
4004 if (ZigClangExpr_getStmtClass(sub_expr) != .StringLiteralClass) break :blk;
4005 const array_qt = ZigClangExpr_getType(sub_expr);
4006 const array_type = @ptrCast(*const ZigClangArrayType, ZigClangQualType_getTypePtr(array_qt));
4007 var pointee_qt = ZigClangArrayType_getElementType(array_type);
4008 ZigClangQualType_addConst(&pointee_qt);
4009 return ZigClangASTContext_getPointerType(c.clang_context, pointee_qt);
4010 }
4011 return ZigClangExpr_getType(expr);
4012}
4013
4014fn typeIsOpaque(c: *Context, ty: *const ZigClangType, loc: ZigClangSourceLocation) bool {
4015 switch (ZigClangType_getTypeClass(ty)) {
3992 if (expr.getStmtClass() != .ImplicitCastExprClass) break :blk;
3993 const cast_expr = @ptrCast(*const clang.ImplicitCastExpr, expr);
3994 if (cast_expr.getCastKind() != .ArrayToPointerDecay) break :blk;
3995 const sub_expr = cast_expr.getSubExpr();
3996 if (sub_expr.getStmtClass() != .StringLiteralClass) break :blk;
3997 const array_qt = sub_expr.getType();
3998 const array_type = @ptrCast(*const clang.ArrayType, array_qt.getTypePtr());
3999 var pointee_qt = array_type.getElementType();
4000 pointee_qt.addConst();
4001 return c.clang_context.getPointerType(pointee_qt);
4002 }
4003 return expr.getType();
4004}
4005
4006fn typeIsOpaque(c: *Context, ty: *const clang.Type, loc: clang.SourceLocation) bool {
4007 switch (ty.getTypeClass()) {
40164008 .Builtin => {
4017 const builtin_ty = @ptrCast(*const ZigClangBuiltinType, ty);
4018 return ZigClangBuiltinType_getKind(builtin_ty) == .Void;
4009 const builtin_ty = @ptrCast(*const clang.BuiltinType, ty);
4010 return builtin_ty.getKind() == .Void;
40194011 },
40204012 .Record => {
4021 const record_ty = @ptrCast(*const ZigClangRecordType, ty);
4022 const record_decl = ZigClangRecordType_getDecl(record_ty);
4023 const record_def = ZigClangRecordDecl_getDefinition(record_decl) orelse
4013 const record_ty = @ptrCast(*const clang.RecordType, ty);
4014 const record_decl = record_ty.getDecl();
4015 const record_def = record_decl.getDefinition() orelse
40244016 return true;
4025 var it = ZigClangRecordDecl_field_begin(record_def);
4026 const end_it = ZigClangRecordDecl_field_end(record_def);
4027 while (ZigClangRecordDecl_field_iterator_neq(it, end_it)) : (it = ZigClangRecordDecl_field_iterator_next(it)) {
4028 const field_decl = ZigClangRecordDecl_field_iterator_deref(it);
4017 var it = record_def.field_begin();
4018 const end_it = record_def.field_end();
4019 while (it.neq(end_it)) : (it = it.next()) {
4020 const field_decl = it.deref();
40294021
4030 if (ZigClangFieldDecl_isBitField(field_decl)) {
4022 if (field_decl.isBitField()) {
40314023 return true;
40324024 }
40334025 }
40344026 return false;
40354027 },
40364028 .Elaborated => {
4037 const elaborated_ty = @ptrCast(*const ZigClangElaboratedType, ty);
4038 const qt = ZigClangElaboratedType_getNamedType(elaborated_ty);
4039 return typeIsOpaque(c, ZigClangQualType_getTypePtr(qt), loc);
4029 const elaborated_ty = @ptrCast(*const clang.ElaboratedType, ty);
4030 const qt = elaborated_ty.getNamedType();
4031 return typeIsOpaque(c, qt.getTypePtr(), loc);
40404032 },
40414033 .Typedef => {
4042 const typedef_ty = @ptrCast(*const ZigClangTypedefType, ty);
4043 const typedef_decl = ZigClangTypedefType_getDecl(typedef_ty);
4044 const underlying_type = ZigClangTypedefNameDecl_getUnderlyingType(typedef_decl);
4045 return typeIsOpaque(c, ZigClangQualType_getTypePtr(underlying_type), loc);
4034 const typedef_ty = @ptrCast(*const clang.TypedefType, ty);
4035 const typedef_decl = typedef_ty.getDecl();
4036 const underlying_type = typedef_decl.getUnderlyingType();
4037 return typeIsOpaque(c, underlying_type.getTypePtr(), loc);
40464038 },
40474039 else => return false,
40484040 }
40494041}
40504042
4051fn cIsInteger(qt: ZigClangQualType) bool {
4043fn cIsInteger(qt: clang.QualType) bool {
40524044 return cIsSignedInteger(qt) or cIsUnsignedInteger(qt);
40534045}
40544046
4055fn cIsUnsignedInteger(qt: ZigClangQualType) bool {
4047fn cIsUnsignedInteger(qt: clang.QualType) bool {
40564048 const c_type = qualTypeCanon(qt);
4057 if (ZigClangType_getTypeClass(c_type) != .Builtin) return false;
4058 const builtin_ty = @ptrCast(*const ZigClangBuiltinType, c_type);
4059 return switch (ZigClangBuiltinType_getKind(builtin_ty)) {
4049 if (c_type.getTypeClass() != .Builtin) return false;
4050 const builtin_ty = @ptrCast(*const clang.BuiltinType, c_type);
4051 return switch (builtin_ty.getKind()) {
40604052 .Char_U,
40614053 .UChar,
40624054 .Char_S,
......@@ -4071,11 +4063,11 @@ fn cIsUnsignedInteger(qt: ZigClangQualType) bool {
40714063 };
40724064}
40734065
4074fn cIntTypeToIndex(qt: ZigClangQualType) u8 {
4066fn cIntTypeToIndex(qt: clang.QualType) u8 {
40754067 const c_type = qualTypeCanon(qt);
4076 assert(ZigClangType_getTypeClass(c_type) == .Builtin);
4077 const builtin_ty = @ptrCast(*const ZigClangBuiltinType, c_type);
4078 return switch (ZigClangBuiltinType_getKind(builtin_ty)) {
4068 assert(c_type.getTypeClass() == .Builtin);
4069 const builtin_ty = @ptrCast(*const clang.BuiltinType, c_type);
4070 return switch (builtin_ty.getKind()) {
40794071 .Bool, .Char_U, .Char_S, .UChar, .SChar, .Char8 => 1,
40804072 .WChar_U, .WChar_S => 2,
40814073 .UShort, .Short, .Char16 => 3,
......@@ -4087,17 +4079,17 @@ fn cIntTypeToIndex(qt: ZigClangQualType) u8 {
40874079 };
40884080}
40894081
4090fn cIntTypeCmp(a: ZigClangQualType, b: ZigClangQualType) math.Order {
4082fn cIntTypeCmp(a: clang.QualType, b: clang.QualType) math.Order {
40914083 const a_index = cIntTypeToIndex(a);
40924084 const b_index = cIntTypeToIndex(b);
40934085 return math.order(a_index, b_index);
40944086}
40954087
4096fn cIsSignedInteger(qt: ZigClangQualType) bool {
4088fn cIsSignedInteger(qt: clang.QualType) bool {
40974089 const c_type = qualTypeCanon(qt);
4098 if (ZigClangType_getTypeClass(c_type) != .Builtin) return false;
4099 const builtin_ty = @ptrCast(*const ZigClangBuiltinType, c_type);
4100 return switch (ZigClangBuiltinType_getKind(builtin_ty)) {
4090 if (c_type.getTypeClass() != .Builtin) return false;
4091 const builtin_ty = @ptrCast(*const clang.BuiltinType, c_type);
4092 return switch (builtin_ty.getKind()) {
41014093 .SChar,
41024094 .Short,
41034095 .Int,
......@@ -4110,11 +4102,11 @@ fn cIsSignedInteger(qt: ZigClangQualType) bool {
41104102 };
41114103}
41124104
4113fn cIsFloating(qt: ZigClangQualType) bool {
4105fn cIsFloating(qt: clang.QualType) bool {
41144106 const c_type = qualTypeCanon(qt);
4115 if (ZigClangType_getTypeClass(c_type) != .Builtin) return false;
4116 const builtin_ty = @ptrCast(*const ZigClangBuiltinType, c_type);
4117 return switch (ZigClangBuiltinType_getKind(builtin_ty)) {
4107 if (c_type.getTypeClass() != .Builtin) return false;
4108 const builtin_ty = @ptrCast(*const clang.BuiltinType, c_type);
4109 return switch (builtin_ty.getKind()) {
41184110 .Float,
41194111 .Double,
41204112 .Float128,
......@@ -4124,11 +4116,11 @@ fn cIsFloating(qt: ZigClangQualType) bool {
41244116 };
41254117}
41264118
4127fn cIsLongLongInteger(qt: ZigClangQualType) bool {
4119fn cIsLongLongInteger(qt: clang.QualType) bool {
41284120 const c_type = qualTypeCanon(qt);
4129 if (ZigClangType_getTypeClass(c_type) != .Builtin) return false;
4130 const builtin_ty = @ptrCast(*const ZigClangBuiltinType, c_type);
4131 return switch (ZigClangBuiltinType_getKind(builtin_ty)) {
4121 if (c_type.getTypeClass() != .Builtin) return false;
4122 const builtin_ty = @ptrCast(*const clang.BuiltinType, c_type);
4123 return switch (builtin_ty.getKind()) {
41324124 .LongLong, .ULongLong, .Int128, .UInt128 => true,
41334125 else => false,
41344126 };
......@@ -4137,8 +4129,8 @@ fn transCreateNodeAssign(
41374129 rp: RestorePoint,
41384130 scope: *Scope,
41394131 result_used: ResultUsed,
4140 lhs: *const ZigClangExpr,
4141 rhs: *const ZigClangExpr,
4132 lhs: *const clang.Expr,
4133 rhs: *const clang.Expr,
41424134) !*ast.Node {
41434135 // common case
41444136 // c: lhs = rhs
......@@ -4273,19 +4265,19 @@ fn transCreateNodeInfixOp(
42734265fn transCreateNodeBoolInfixOp(
42744266 rp: RestorePoint,
42754267 scope: *Scope,
4276 stmt: *const ZigClangBinaryOperator,
4268 stmt: *const clang.BinaryOperator,
42774269 op: ast.Node.Tag,
42784270 used: ResultUsed,
42794271 grouped: bool,
42804272) !*ast.Node {
42814273 std.debug.assert(op == .BoolAnd or op == .BoolOr);
42824274
4283 const lhs_hode = try transBoolExpr(rp, scope, ZigClangBinaryOperator_getLHS(stmt), .used, .l_value, true);
4275 const lhs_hode = try transBoolExpr(rp, scope, stmt.getLHS(), .used, .l_value, true);
42844276 const op_token = if (op == .BoolAnd)
42854277 try appendToken(rp.c, .Keyword_and, "and")
42864278 else
42874279 try appendToken(rp.c, .Keyword_or, "or");
4288 const rhs = try transBoolExpr(rp, scope, ZigClangBinaryOperator_getRHS(stmt), .used, .r_value, true);
4280 const rhs = try transBoolExpr(rp, scope, stmt.getRHS(), .used, .r_value, true);
42894281
42904282 return transCreateNodeInfixOp(
42914283 rp,
......@@ -4334,21 +4326,21 @@ fn transCreateNodePtrType(
43344326 return node;
43354327}
43364328
4337fn transCreateNodeAPInt(c: *Context, int: *const ZigClangAPSInt) !*ast.Node {
4338 const num_limbs = math.cast(usize, ZigClangAPSInt_getNumWords(int)) catch |err| switch (err) {
4329fn transCreateNodeAPInt(c: *Context, int: *const clang.APSInt) !*ast.Node {
4330 const num_limbs = math.cast(usize, int.getNumWords()) catch |err| switch (err) {
43394331 error.Overflow => return error.OutOfMemory,
43404332 };
43414333 var aps_int = int;
4342 const is_negative = ZigClangAPSInt_isSigned(int) and ZigClangAPSInt_isNegative(int);
4343 if (is_negative) aps_int = ZigClangAPSInt_negate(aps_int);
4334 const is_negative = int.isSigned() and int.isNegative();
4335 if (is_negative) aps_int = aps_int.negate();
43444336 defer if (is_negative) {
4345 ZigClangAPSInt_free(aps_int);
4337 aps_int.free();
43464338 };
43474339
43484340 const limbs = try c.arena.alloc(math.big.Limb, num_limbs);
43494341 defer c.arena.free(limbs);
43504342
4351 const data = ZigClangAPSInt_getRawData(aps_int);
4343 const data = aps_int.getRawData();
43524344 switch (@sizeOf(math.big.Limb)) {
43534345 8 => {
43544346 var i: usize = 0;
......@@ -4438,10 +4430,18 @@ fn transCreateNodeFloat(c: *Context, int: anytype) !*ast.Node {
44384430}
44394431
44404432fn transCreateNodeOpaqueType(c: *Context) !*ast.Node {
4441 const call_node = try c.createBuiltinCall("@Type", 1);
4442 call_node.params()[0] = try transCreateNodeEnumLiteral(c, "Opaque");
4443 call_node.rparen_token = try appendToken(c, .RParen, ")");
4444 return &call_node.base;
4433 const container_tok = try appendToken(c, .Keyword_opaque, "opaque");
4434 const lbrace_token = try appendToken(c, .LBrace, "{");
4435 const container_node = try ast.Node.ContainerDecl.alloc(c.arena, 0);
4436 container_node.* = .{
4437 .kind_token = container_tok,
4438 .layout_token = null,
4439 .lbrace_token = lbrace_token,
4440 .rbrace_token = try appendToken(c, .RBrace, "}"),
4441 .fields_and_decls_len = 0,
4442 .init_arg_expr = .None,
4443 };
4444 return &container_node.base;
44454445}
44464446
44474447fn 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 {
46894689fn transCreateNodeShiftOp(
46904690 rp: RestorePoint,
46914691 scope: *Scope,
4692 stmt: *const ZigClangBinaryOperator,
4692 stmt: *const clang.BinaryOperator,
46934693 op: ast.Node.Tag,
46944694 op_tok_id: std.zig.Token.Id,
46954695 bytes: []const u8,
46964696) !*ast.Node {
46974697 std.debug.assert(op == .BitShiftLeft or op == .BitShiftRight);
46984698
4699 const lhs_expr = ZigClangBinaryOperator_getLHS(stmt);
4700 const rhs_expr = ZigClangBinaryOperator_getRHS(stmt);
4701 const rhs_location = ZigClangExpr_getBeginLoc(rhs_expr);
4699 const lhs_expr = stmt.getLHS();
4700 const rhs_expr = stmt.getRHS();
4701 const rhs_location = rhs_expr.getBeginLoc();
47024702 // lhs >> @as(u5, rh)
47034703
47044704 const lhs = try transExpr(rp, scope, lhs_expr, .used, .l_value);
47054705 const op_token = try appendToken(rp.c, op_tok_id, bytes);
47064706
47074707 const cast_node = try rp.c.createBuiltinCall("@intCast", 2);
4708 const rhs_type = try qualTypeToLog2IntRef(rp, ZigClangBinaryOperator_getType(stmt), rhs_location);
4708 const rhs_type = try qualTypeToLog2IntRef(rp, stmt.getType(), rhs_location);
47094709 cast_node.params()[0] = rhs_type;
47104710 _ = try appendToken(rp.c, .Comma, ",");
47114711 const rhs = try transExprCoercing(rp, scope, rhs_expr, .used, .r_value);
......@@ -4764,11 +4764,11 @@ fn makeRestorePoint(c: *Context) RestorePoint {
47644764 };
47654765}
47664766
4767fn transType(rp: RestorePoint, ty: *const ZigClangType, source_loc: ZigClangSourceLocation) TypeError!*ast.Node {
4768 switch (ZigClangType_getTypeClass(ty)) {
4767fn transType(rp: RestorePoint, ty: *const clang.Type, source_loc: clang.SourceLocation) TypeError!*ast.Node {
4768 switch (ty.getTypeClass()) {
47694769 .Builtin => {
4770 const builtin_ty = @ptrCast(*const ZigClangBuiltinType, ty);
4771 return transCreateNodeIdentifier(rp.c, switch (ZigClangBuiltinType_getKind(builtin_ty)) {
4770 const builtin_ty = @ptrCast(*const clang.BuiltinType, ty);
4771 return transCreateNodeIdentifier(rp.c, switch (builtin_ty.getKind()) {
47724772 .Void => "c_void",
47734773 .Bool => "bool",
47744774 .Char_U, .UChar, .Char_S, .Char8 => "u8",
......@@ -4792,32 +4792,32 @@ fn transType(rp: RestorePoint, ty: *const ZigClangType, source_loc: ZigClangSour
47924792 });
47934793 },
47944794 .FunctionProto => {
4795 const fn_proto_ty = @ptrCast(*const ZigClangFunctionProtoType, ty);
4795 const fn_proto_ty = @ptrCast(*const clang.FunctionProtoType, ty);
47964796 const fn_proto = try transFnProto(rp, null, fn_proto_ty, source_loc, null, false);
47974797 return &fn_proto.base;
47984798 },
47994799 .FunctionNoProto => {
4800 const fn_no_proto_ty = @ptrCast(*const ZigClangFunctionType, ty);
4800 const fn_no_proto_ty = @ptrCast(*const clang.FunctionType, ty);
48014801 const fn_proto = try transFnNoProto(rp, fn_no_proto_ty, source_loc, null, false);
48024802 return &fn_proto.base;
48034803 },
48044804 .Paren => {
4805 const paren_ty = @ptrCast(*const ZigClangParenType, ty);
4806 return transQualType(rp, ZigClangParenType_getInnerType(paren_ty), source_loc);
4805 const paren_ty = @ptrCast(*const clang.ParenType, ty);
4806 return transQualType(rp, paren_ty.getInnerType(), source_loc);
48074807 },
48084808 .Pointer => {
4809 const child_qt = ZigClangType_getPointeeType(ty);
4809 const child_qt = ty.getPointeeType();
48104810 if (qualTypeChildIsFnProto(child_qt)) {
48114811 const optional_node = try transCreateNodeSimplePrefixOp(rp.c, .OptionalType, .QuestionMark, "?");
48124812 optional_node.rhs = try transQualType(rp, child_qt, source_loc);
48134813 return &optional_node.base;
48144814 }
4815 if (typeIsOpaque(rp.c, ZigClangQualType_getTypePtr(child_qt), source_loc)) {
4815 if (typeIsOpaque(rp.c, child_qt.getTypePtr(), source_loc)) {
48164816 const optional_node = try transCreateNodeSimplePrefixOp(rp.c, .OptionalType, .QuestionMark, "?");
48174817 const pointer_node = try transCreateNodePtrType(
48184818 rp.c,
4819 ZigClangQualType_isConstQualified(child_qt),
4820 ZigClangQualType_isVolatileQualified(child_qt),
4819 child_qt.isConstQualified(),
4820 child_qt.isVolatileQualified(),
48214821 .Asterisk,
48224822 );
48234823 optional_node.rhs = &pointer_node.base;
......@@ -4826,83 +4826,83 @@ fn transType(rp: RestorePoint, ty: *const ZigClangType, source_loc: ZigClangSour
48264826 }
48274827 const pointer_node = try transCreateNodePtrType(
48284828 rp.c,
4829 ZigClangQualType_isConstQualified(child_qt),
4830 ZigClangQualType_isVolatileQualified(child_qt),
4829 child_qt.isConstQualified(),
4830 child_qt.isVolatileQualified(),
48314831 .Identifier,
48324832 );
48334833 pointer_node.rhs = try transQualType(rp, child_qt, source_loc);
48344834 return &pointer_node.base;
48354835 },
48364836 .ConstantArray => {
4837 const const_arr_ty = @ptrCast(*const ZigClangConstantArrayType, ty);
4837 const const_arr_ty = @ptrCast(*const clang.ConstantArrayType, ty);
48384838
4839 const size_ap_int = ZigClangConstantArrayType_getSize(const_arr_ty);
4840 const size = ZigClangAPInt_getLimitedValue(size_ap_int, math.maxInt(usize));
4841 const elem_ty = ZigClangQualType_getTypePtr(ZigClangConstantArrayType_getElementType(const_arr_ty));
4839 const size_ap_int = const_arr_ty.getSize();
4840 const size = size_ap_int.getLimitedValue(math.maxInt(usize));
4841 const elem_ty = const_arr_ty.getElementType().getTypePtr();
48424842 return try transCreateNodeArrayType(rp, source_loc, elem_ty, size);
48434843 },
48444844 .IncompleteArray => {
4845 const incomplete_array_ty = @ptrCast(*const ZigClangIncompleteArrayType, ty);
4845 const incomplete_array_ty = @ptrCast(*const clang.IncompleteArrayType, ty);
48464846
4847 const child_qt = ZigClangIncompleteArrayType_getElementType(incomplete_array_ty);
4847 const child_qt = incomplete_array_ty.getElementType();
48484848 var node = try transCreateNodePtrType(
48494849 rp.c,
4850 ZigClangQualType_isConstQualified(child_qt),
4851 ZigClangQualType_isVolatileQualified(child_qt),
4850 child_qt.isConstQualified(),
4851 child_qt.isVolatileQualified(),
48524852 .Identifier,
48534853 );
48544854 node.rhs = try transQualType(rp, child_qt, source_loc);
48554855 return &node.base;
48564856 },
48574857 .Typedef => {
4858 const typedef_ty = @ptrCast(*const ZigClangTypedefType, ty);
4858 const typedef_ty = @ptrCast(*const clang.TypedefType, ty);
48594859
4860 const typedef_decl = ZigClangTypedefType_getDecl(typedef_ty);
4860 const typedef_decl = typedef_ty.getDecl();
48614861 return (try transTypeDef(rp.c, typedef_decl, false)) orelse
48624862 revertAndWarn(rp, error.UnsupportedType, source_loc, "unable to translate typedef declaration", .{});
48634863 },
48644864 .Record => {
4865 const record_ty = @ptrCast(*const ZigClangRecordType, ty);
4865 const record_ty = @ptrCast(*const clang.RecordType, ty);
48664866
4867 const record_decl = ZigClangRecordType_getDecl(record_ty);
4867 const record_decl = record_ty.getDecl();
48684868 return (try transRecordDecl(rp.c, record_decl)) orelse
48694869 revertAndWarn(rp, error.UnsupportedType, source_loc, "unable to resolve record declaration", .{});
48704870 },
48714871 .Enum => {
4872 const enum_ty = @ptrCast(*const ZigClangEnumType, ty);
4872 const enum_ty = @ptrCast(*const clang.EnumType, ty);
48734873
4874 const enum_decl = ZigClangEnumType_getDecl(enum_ty);
4874 const enum_decl = enum_ty.getDecl();
48754875 return (try transEnumDecl(rp.c, enum_decl)) orelse
48764876 revertAndWarn(rp, error.UnsupportedType, source_loc, "unable to translate enum declaration", .{});
48774877 },
48784878 .Elaborated => {
4879 const elaborated_ty = @ptrCast(*const ZigClangElaboratedType, ty);
4880 return transQualType(rp, ZigClangElaboratedType_getNamedType(elaborated_ty), source_loc);
4879 const elaborated_ty = @ptrCast(*const clang.ElaboratedType, ty);
4880 return transQualType(rp, elaborated_ty.getNamedType(), source_loc);
48814881 },
48824882 .Decayed => {
4883 const decayed_ty = @ptrCast(*const ZigClangDecayedType, ty);
4884 return transQualType(rp, ZigClangDecayedType_getDecayedType(decayed_ty), source_loc);
4883 const decayed_ty = @ptrCast(*const clang.DecayedType, ty);
4884 return transQualType(rp, decayed_ty.getDecayedType(), source_loc);
48854885 },
48864886 .Attributed => {
4887 const attributed_ty = @ptrCast(*const ZigClangAttributedType, ty);
4888 return transQualType(rp, ZigClangAttributedType_getEquivalentType(attributed_ty), source_loc);
4887 const attributed_ty = @ptrCast(*const clang.AttributedType, ty);
4888 return transQualType(rp, attributed_ty.getEquivalentType(), source_loc);
48894889 },
48904890 .MacroQualified => {
4891 const macroqualified_ty = @ptrCast(*const ZigClangMacroQualifiedType, ty);
4892 return transQualType(rp, ZigClangMacroQualifiedType_getModifiedType(macroqualified_ty), source_loc);
4891 const macroqualified_ty = @ptrCast(*const clang.MacroQualifiedType, ty);
4892 return transQualType(rp, macroqualified_ty.getModifiedType(), source_loc);
48934893 },
48944894 else => {
4895 const type_name = rp.c.str(ZigClangType_getTypeClassName(ty));
4895 const type_name = rp.c.str(ty.getTypeClassName());
48964896 return revertAndWarn(rp, error.UnsupportedType, source_loc, "unsupported type: '{}'", .{type_name});
48974897 },
48984898 }
48994899}
49004900
4901fn isCVoid(qt: ZigClangQualType) bool {
4902 const ty = ZigClangQualType_getTypePtr(qt);
4903 if (ZigClangType_getTypeClass(ty) == .Builtin) {
4904 const builtin_ty = @ptrCast(*const ZigClangBuiltinType, ty);
4905 return ZigClangBuiltinType_getKind(builtin_ty) == .Void;
4901fn isCVoid(qt: clang.QualType) bool {
4902 const ty = qt.getTypePtr();
4903 if (ty.getTypeClass() == .Builtin) {
4904 const builtin_ty = @ptrCast(*const clang.BuiltinType, ty);
4905 return builtin_ty.getKind() == .Void;
49064906 }
49074907 return false;
49084908}
......@@ -4910,16 +4910,16 @@ fn isCVoid(qt: ZigClangQualType) bool {
49104910const FnDeclContext = struct {
49114911 fn_name: []const u8,
49124912 has_body: bool,
4913 storage_class: ZigClangStorageClass,
4913 storage_class: clang.StorageClass,
49144914 is_export: bool,
49154915};
49164916
49174917fn transCC(
49184918 rp: RestorePoint,
4919 fn_ty: *const ZigClangFunctionType,
4920 source_loc: ZigClangSourceLocation,
4919 fn_ty: *const clang.FunctionType,
4920 source_loc: clang.SourceLocation,
49214921) !CallingConvention {
4922 const clang_cc = ZigClangFunctionType_getCallConv(fn_ty);
4922 const clang_cc = fn_ty.getCallConv();
49234923 switch (clang_cc) {
49244924 .C => return CallingConvention.C,
49254925 .X86StdCall => return CallingConvention.Stdcall,
......@@ -4940,22 +4940,22 @@ fn transCC(
49404940
49414941fn transFnProto(
49424942 rp: RestorePoint,
4943 fn_decl: ?*const ZigClangFunctionDecl,
4944 fn_proto_ty: *const ZigClangFunctionProtoType,
4945 source_loc: ZigClangSourceLocation,
4943 fn_decl: ?*const clang.FunctionDecl,
4944 fn_proto_ty: *const clang.FunctionProtoType,
4945 source_loc: clang.SourceLocation,
49464946 fn_decl_context: ?FnDeclContext,
49474947 is_pub: bool,
49484948) !*ast.Node.FnProto {
4949 const fn_ty = @ptrCast(*const ZigClangFunctionType, fn_proto_ty);
4949 const fn_ty = @ptrCast(*const clang.FunctionType, fn_proto_ty);
49504950 const cc = try transCC(rp, fn_ty, source_loc);
4951 const is_var_args = ZigClangFunctionProtoType_isVariadic(fn_proto_ty);
4951 const is_var_args = fn_proto_ty.isVariadic();
49524952 return finishTransFnProto(rp, fn_decl, fn_proto_ty, fn_ty, source_loc, fn_decl_context, is_var_args, cc, is_pub);
49534953}
49544954
49554955fn transFnNoProto(
49564956 rp: RestorePoint,
4957 fn_ty: *const ZigClangFunctionType,
4958 source_loc: ZigClangSourceLocation,
4957 fn_ty: *const clang.FunctionType,
4958 source_loc: clang.SourceLocation,
49594959 fn_decl_context: ?FnDeclContext,
49604960 is_pub: bool,
49614961) !*ast.Node.FnProto {
......@@ -4966,10 +4966,10 @@ fn transFnNoProto(
49664966
49674967fn finishTransFnProto(
49684968 rp: RestorePoint,
4969 fn_decl: ?*const ZigClangFunctionDecl,
4970 fn_proto_ty: ?*const ZigClangFunctionProtoType,
4971 fn_ty: *const ZigClangFunctionType,
4972 source_loc: ZigClangSourceLocation,
4969 fn_decl: ?*const clang.FunctionDecl,
4970 fn_proto_ty: ?*const clang.FunctionProtoType,
4971 fn_ty: *const clang.FunctionType,
4972 source_loc: clang.SourceLocation,
49734973 fn_decl_context: ?FnDeclContext,
49744974 is_var_args: bool,
49754975 cc: CallingConvention,
......@@ -4995,19 +4995,19 @@ fn finishTransFnProto(
49954995
49964996 var fn_params = std.ArrayList(ast.Node.FnProto.ParamDecl).init(rp.c.gpa);
49974997 defer fn_params.deinit();
4998 const param_count: usize = if (fn_proto_ty != null) ZigClangFunctionProtoType_getNumParams(fn_proto_ty.?) else 0;
4998 const param_count: usize = if (fn_proto_ty != null) fn_proto_ty.?.getNumParams() else 0;
49994999 try fn_params.ensureCapacity(param_count + 1); // +1 for possible var args node
50005000
50015001 var i: usize = 0;
50025002 while (i < param_count) : (i += 1) {
5003 const param_qt = ZigClangFunctionProtoType_getParamType(fn_proto_ty.?, @intCast(c_uint, i));
5003 const param_qt = fn_proto_ty.?.getParamType(@intCast(c_uint, i));
50045004
5005 const noalias_tok = if (ZigClangQualType_isRestrictQualified(param_qt)) try appendToken(rp.c, .Keyword_noalias, "noalias") else null;
5005 const noalias_tok = if (param_qt.isRestrictQualified()) try appendToken(rp.c, .Keyword_noalias, "noalias") else null;
50065006
50075007 const param_name_tok: ?ast.TokenIndex = blk: {
50085008 if (fn_decl) |decl| {
5009 const param = ZigClangFunctionDecl_getParamDecl(decl, @intCast(c_uint, i));
5010 const param_name: []const u8 = try rp.c.str(ZigClangNamedDecl_getName_bytes_begin(@ptrCast(*const ZigClangNamedDecl, param)));
5009 const param = decl.getParamDecl(@intCast(c_uint, i));
5010 const param_name: []const u8 = try rp.c.str(@ptrCast(*const clang.NamedDecl, param).getName_bytes_begin());
50115011 if (param_name.len < 1)
50125012 break :blk null;
50135013
......@@ -5045,7 +5045,7 @@ fn finishTransFnProto(
50455045 const linksection_expr = blk: {
50465046 if (fn_decl) |decl| {
50475047 var str_len: usize = undefined;
5048 if (ZigClangFunctionDecl_getSectionAttribute(decl, &str_len)) |str_ptr| {
5048 if (decl.getSectionAttribute(&str_len)) |str_ptr| {
50495049 _ = try appendToken(rp.c, .Keyword_linksection, "linksection");
50505050 _ = try appendToken(rp.c, .LParen, "(");
50515051 const expr = try transCreateNodeStringLiteral(
......@@ -5062,7 +5062,7 @@ fn finishTransFnProto(
50625062
50635063 const align_expr = blk: {
50645064 if (fn_decl) |decl| {
5065 const alignment = ZigClangFunctionDecl_getAlignedAttribute(decl, rp.c.clang_context);
5065 const alignment = decl.getAlignedAttribute(rp.c.clang_context);
50665066 if (alignment != 0) {
50675067 _ = try appendToken(rp.c, .Keyword_align, "align");
50685068 _ = try appendToken(rp.c, .LParen, "(");
......@@ -5085,10 +5085,10 @@ fn finishTransFnProto(
50855085 };
50865086
50875087 const return_type_node = blk: {
5088 if (ZigClangFunctionType_getNoReturnAttr(fn_ty)) {
5088 if (fn_ty.getNoReturnAttr()) {
50895089 break :blk try transCreateNodeIdentifier(rp.c, "noreturn");
50905090 } else {
5091 const return_qt = ZigClangFunctionType_getReturnType(fn_ty);
5091 const return_qt = fn_ty.getReturnType();
50925092 if (isCVoid(return_qt)) {
50935093 // convert primitive c_void to actual void (only for return type)
50945094 break :blk try transCreateNodeIdentifier(rp.c, "void");
......@@ -5136,7 +5136,7 @@ fn finishTransFnProto(
51365136fn revertAndWarn(
51375137 rp: RestorePoint,
51385138 err: anytype,
5139 source_loc: ZigClangSourceLocation,
5139 source_loc: clang.SourceLocation,
51405140 comptime format: []const u8,
51415141 args: anytype,
51425142) (@TypeOf(err) || error{OutOfMemory}) {
......@@ -5145,12 +5145,12 @@ fn revertAndWarn(
51455145 return err;
51465146}
51475147
5148fn emitWarning(c: *Context, loc: ZigClangSourceLocation, comptime format: []const u8, args: anytype) !void {
5148fn emitWarning(c: *Context, loc: clang.SourceLocation, comptime format: []const u8, args: anytype) !void {
51495149 const args_prefix = .{c.locStr(loc)};
51505150 _ = try appendTokenFmt(c, .LineComment, "// {}: warning: " ++ format, args_prefix ++ args);
51515151}
51525152
5153pub fn failDecl(c: *Context, loc: ZigClangSourceLocation, name: []const u8, comptime format: []const u8, args: anytype) !void {
5153pub fn failDecl(c: *Context, loc: clang.SourceLocation, name: []const u8, comptime format: []const u8, args: anytype) !void {
51545154 // pub const name = @compileError(msg);
51555155 const pub_tok = try appendToken(c, .Keyword_pub, "pub");
51565156 const const_tok = try appendToken(c, .Keyword_const, "const");
......@@ -5287,14 +5287,14 @@ fn transCreateNodeIdentifierUnchecked(c: *Context, name: []const u8) !*ast.Node
52875287}
52885288
52895289pub fn freeErrors(errors: []ClangErrMsg) void {
5290 ZigClangErrorMsg_delete(errors.ptr, errors.len);
5290 errors.ptr.delete(errors.len);
52915291}
52925292
52935293const MacroCtx = struct {
52945294 source: []const u8,
52955295 list: []const CToken,
52965296 i: usize = 0,
5297 loc: ZigClangSourceLocation,
5297 loc: clang.SourceLocation,
52985298 name: []const u8,
52995299
53005300 fn peek(self: *MacroCtx) ?CToken.Id {
......@@ -5318,22 +5318,22 @@ const MacroCtx = struct {
53185318 }
53195319};
53205320
5321fn transPreprocessorEntities(c: *Context, unit: *ZigClangASTUnit) Error!void {
5321fn transPreprocessorEntities(c: *Context, unit: *clang.ASTUnit) Error!void {
53225322 // TODO if we see #undef, delete it from the table
5323 var it = ZigClangASTUnit_getLocalPreprocessingEntities_begin(unit);
5324 const it_end = ZigClangASTUnit_getLocalPreprocessingEntities_end(unit);
5323 var it = unit.getLocalPreprocessingEntities_begin();
5324 const it_end = unit.getLocalPreprocessingEntities_end();
53255325 var tok_list = std.ArrayList(CToken).init(c.gpa);
53265326 defer tok_list.deinit();
53275327 const scope = c.global_scope;
53285328
53295329 while (it.I != it_end.I) : (it.I += 1) {
5330 const entity = ZigClangPreprocessingRecord_iterator_deref(it);
5330 const entity = it.deref();
53315331 tok_list.items.len = 0;
5332 switch (ZigClangPreprocessedEntity_getKind(entity)) {
5332 switch (entity.getKind()) {
53335333 .MacroDefinitionKind => {
5334 const macro = @ptrCast(*ZigClangMacroDefinitionRecord, entity);
5335 const raw_name = ZigClangMacroDefinitionRecord_getName_getNameStart(macro);
5336 const begin_loc = ZigClangMacroDefinitionRecord_getSourceRange_getBegin(macro);
5334 const macro = @ptrCast(*clang.MacroDefinitionRecord, entity);
5335 const raw_name = macro.getName_getNameStart();
5336 const begin_loc = macro.getSourceRange_getBegin();
53375337
53385338 const name = try c.str(raw_name);
53395339 // TODO https://github.com/ziglang/zig/issues/3756
......@@ -5343,7 +5343,7 @@ fn transPreprocessorEntities(c: *Context, unit: *ZigClangASTUnit) Error!void {
53435343 continue;
53445344 }
53455345
5346 const begin_c = ZigClangSourceManager_getCharacterData(c.source_manager, begin_loc);
5346 const begin_c = c.source_manager.getCharacterData(begin_loc);
53475347 const slice = begin_c[0..mem.len(begin_c)];
53485348
53495349 var tokenizer = std.c.Tokenizer{
src/zig_clang.h+2-1
......@@ -68,16 +68,17 @@ struct ZigClangExprEvalResult {
6868 ZigClangAPValue Val;
6969};
7070
71struct ZigClangAbstractConditionalOperator;
7172struct ZigClangAPFloat;
7273struct ZigClangAPInt;
7374struct ZigClangAPSInt;
74struct ZigClangAPValue;
7575struct ZigClangASTContext;
7676struct ZigClangASTUnit;
7777struct ZigClangArraySubscriptExpr;
7878struct ZigClangArrayType;
7979struct ZigClangAttributedType;
8080struct ZigClangBinaryOperator;
81struct ZigClangBinaryConditionalOperator;
8182struct ZigClangBreakStmt;
8283struct ZigClangBuiltinType;
8384struct ZigClangCStyleCastExpr;
test/compile_errors.zig+55-32
......@@ -2,6 +2,19 @@ const tests = @import("tests.zig");
22const std = @import("std");
33
44pub fn addCases(cases: *tests.CompileErrorContext) void {
5 cases.add("array in c exported function",
6 \\export fn zig_array(x: [10]u8) void {
7 \\ expect(std.mem.eql(u8, &x, "1234567890"));
8 \\}
9 \\
10 \\export fn zig_return_array() [10]u8 {
11 \\ return "1234567890".*;
12 \\}
13 , &[_][]const u8{
14 "tmp.zig:1:24: error: parameter of type '[10]u8' not allowed in function with calling convention 'C'",
15 "tmp.zig:5:30: error: return type '[10]u8' not allowed in function with calling convention 'C'",
16 });
17
518 cases.add("@Type for exhaustive enum with undefined tag type",
619 \\const TypeInfo = @import("builtin").TypeInfo;
720 \\const Tag = @Type(.{
......@@ -125,6 +138,31 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
125138 "tmp.zig:15:23: error: enum field missing: 'arst'",
126139 "tmp.zig:27:24: note: referenced here",
127140 });
141
142 cases.add("field access of opaque type",
143 \\const MyType = opaque {};
144 \\
145 \\export fn entry() bool {
146 \\ var x: i32 = 1;
147 \\ return bar(@ptrCast(*MyType, &x));
148 \\}
149 \\
150 \\fn bar(x: *MyType) bool {
151 \\ return x.blah;
152 \\}
153 , &[_][]const u8{
154 "tmp.zig:9:13: error: no member named 'blah' in opaque type 'MyType'",
155 });
156
157 cases.add("opaque type with field",
158 \\const Opaque = opaque { foo: i32 };
159 \\export fn entry() void {
160 \\ const foo: ?*Opaque = null;
161 \\}
162 , &[_][]const u8{
163 "tmp.zig:1:25: error: opaque types cannot have fields",
164 });
165
128166 cases.add("@Type(.Fn) with is_generic = true",
129167 \\const Foo = @Type(.{
130168 \\ .Fn = .{
......@@ -180,7 +218,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
180218 \\ .layout = .Auto,
181219 \\ .tag_type = null,
182220 \\ .fields = &[_]TypeInfo.UnionField{
183 \\ .{ .name = "foo", .field_type = @Type(.Opaque), .alignment = 1 },
221 \\ .{ .name = "foo", .field_type = opaque {}, .alignment = 1 },
184222 \\ },
185223 \\ .decls = &[_]TypeInfo.Declaration{},
186224 \\ },
......@@ -2287,7 +2325,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
22872325 \\ return error.OutOfMemory;
22882326 \\}
22892327 , &[_][]const u8{
2290 "tmp.zig:2:12: error: error is discarded",
2328 "tmp.zig:2:12: error: error is discarded. consider using `try`, `catch`, or `if`",
22912329 });
22922330
22932331 cases.add("volatile on global assembly",
......@@ -2338,9 +2376,9 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
23382376 \\ return error.Bad;
23392377 \\}
23402378 , &[_][]const u8{
2341 "tmp.zig:2:24: error: expression value is ignored",
2342 "tmp.zig:6:25: error: expression value is ignored",
2343 "tmp.zig:10:25: error: expression value is ignored",
2379 "tmp.zig:2:24: error: error is ignored. consider using `try`, `catch`, or `if`",
2380 "tmp.zig:6:25: error: error is ignored. consider using `try`, `catch`, or `if`",
2381 "tmp.zig:10:25: error: error is ignored. consider using `try`, `catch`, or `if`",
23442382 });
23452383
23462384 cases.add("empty while loop body",
......@@ -2613,7 +2651,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
26132651 });
26142652
26152653 cases.add("directly embedding opaque type in struct and union",
2616 \\const O = @Type(.Opaque);
2654 \\const O = opaque {};
26172655 \\const Foo = struct {
26182656 \\ o: O,
26192657 \\};
......@@ -2628,7 +2666,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
26282666 \\ var bar: Bar = undefined;
26292667 \\}
26302668 \\export fn c() void {
2631 \\ var baz: *@Type(.Opaque) = undefined;
2669 \\ var baz: *opaque {} = undefined;
26322670 \\ const qux = .{baz.*};
26332671 \\}
26342672 , &[_][]const u8{
......@@ -3592,7 +3630,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
35923630 });
35933631
35943632 cases.add("unknown length pointer to opaque",
3595 \\export const T = [*]@Type(.Opaque);
3633 \\export const T = [*]opaque {};
35963634 , &[_][]const u8{
35973635 "tmp.zig:1:21: error: unknown-length pointer to opaque",
35983636 });
......@@ -6236,7 +6274,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
62366274 \\}
62376275 \\fn bar() anyerror!i32 { return 0; }
62386276 , &[_][]const u8{
6239 "tmp.zig:2:14: error: expression value is ignored",
6277 "tmp.zig:2:14: error: error is ignored. consider using `try`, `catch`, or `if`",
62406278 });
62416279
62426280 cases.add("dereference an array",
......@@ -6827,8 +6865,8 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
68276865 "tmp.zig:2:31: error: index 2 outside array of size 2",
68286866 });
68296867
6830 cases.add("wrong pointer coerced to pointer to @Type(.Opaque)",
6831 \\const Derp = @Type(.Opaque);
6868 cases.add("wrong pointer coerced to pointer to opaque {}",
6869 \\const Derp = opaque {};
68326870 \\extern fn bar(d: *Derp) void;
68336871 \\export fn foo() void {
68346872 \\ var x = @as(u8, 1);
......@@ -6854,8 +6892,8 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
68546892 \\export fn entry5() void {
68556893 \\ var d = null;
68566894 \\}
6857 \\export fn entry6(opaque: *Opaque) void {
6858 \\ var e = opaque.*;
6895 \\export fn entry6(opaque_: *Opaque) void {
6896 \\ var e = opaque_.*;
68596897 \\}
68606898 \\export fn entry7() void {
68616899 \\ var f = i32;
......@@ -6866,7 +6904,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
68666904 \\export fn entry9() void {
68676905 \\ var z: noreturn = return;
68686906 \\}
6869 \\const Opaque = @Type(.Opaque);
6907 \\const Opaque = opaque {};
68706908 \\const Foo = struct {
68716909 \\ fn bar(self: *const Foo) void {}
68726910 \\};
......@@ -7019,21 +7057,6 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
70197057 "tmp.zig:37:29: error: cannot store runtime value in compile time variable",
70207058 });
70217059
7022 cases.add("field access of opaque type",
7023 \\const MyType = @Type(.Opaque);
7024 \\
7025 \\export fn entry() bool {
7026 \\ var x: i32 = 1;
7027 \\ return bar(@ptrCast(*MyType, &x));
7028 \\}
7029 \\
7030 \\fn bar(x: *MyType) bool {
7031 \\ return x.blah;
7032 \\}
7033 , &[_][]const u8{
7034 "tmp.zig:9:13: error: type '*MyType' does not support field access",
7035 });
7036
70377060 cases.add("invalid legacy unicode escape",
70387061 \\export fn entry() void {
70397062 \\ const a = '\U1234';
......@@ -7623,7 +7646,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
76237646 });
76247647
76257648 cases.add("function returning opaque type",
7626 \\const FooType = @Type(.Opaque);
7649 \\const FooType = opaque {};
76277650 \\export fn bar() !FooType {
76287651 \\ return error.InvalidValue;
76297652 \\}
......@@ -7641,7 +7664,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
76417664 });
76427665
76437666 cases.add("generic function returning opaque type",
7644 \\const FooType = @Type(.Opaque);
7667 \\const FooType = opaque {};
76457668 \\fn generic(comptime T: type) !T {
76467669 \\ return undefined;
76477670 \\}
......@@ -7665,7 +7688,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
76657688 });
76667689
76677690 cases.add("function parameter is opaque",
7668 \\const FooType = @Type(.Opaque);
7691 \\const FooType = opaque {};
76697692 \\export fn entry1() void {
76707693 \\ const someFuncPtr: fn (FooType) void = undefined;
76717694 \\}
test/gen_h.zig+1-1
......@@ -74,7 +74,7 @@ pub fn addCases(cases: *tests.GenHContext) void {
7474 });
7575
7676 cases.add("declare opaque type",
77 \\const Foo = @Type(.Opaque);
77 \\const Foo = opaque {};
7878 \\
7979 \\export fn entry(foo: ?*Foo) void { }
8080 , &[_][]const u8{
test/stage1/behavior/misc.zig+3-3
......@@ -438,8 +438,8 @@ export fn writeToVRam() void {
438438 vram[0] = 'X';
439439}
440440
441const OpaqueA = @Type(.Opaque);
442const OpaqueB = @Type(.Opaque);
441const OpaqueA = opaque {};
442const OpaqueB = opaque {};
443443test "opaque types" {
444444 expect(*OpaqueA != *OpaqueB);
445445 expect(mem.eql(u8, @typeName(OpaqueA), "OpaqueA"));
......@@ -704,7 +704,7 @@ test "auto created variables have correct alignment" {
704704 comptime expect(S.foo("\x7a\x7a\x7a\x7a") == 0x7a7a7a7a);
705705}
706706
707extern var opaque_extern_var: @Type(.Opaque);
707extern var opaque_extern_var: opaque {};
708708var var_to_export: u32 = 42;
709709test "extern variable with non-pointer opaque type" {
710710 @export(var_to_export, .{ .name = "opaque_extern_var" });
test/stage1/behavior/type.zig+11-2
......@@ -190,8 +190,17 @@ test "Type.ErrorUnion" {
190190}
191191
192192test "Type.Opaque" {
193 testing.expect(@Type(.Opaque) != @Type(.Opaque));
194 testing.expect(@typeInfo(@Type(.Opaque)) == .Opaque);
193 const Opaque = @Type(.{
194 .Opaque = .{
195 .decls = &[_]TypeInfo.Declaration{},
196 },
197 });
198 testing.expect(Opaque != opaque {});
199 testing.expectEqualSlices(
200 TypeInfo.Declaration,
201 &[_]TypeInfo.Declaration{},
202 @typeInfo(Opaque).Opaque.decls,
203 );
195204}
196205
197206test "Type.Vector" {
test/stage1/behavior/type_info.zig+16-1
......@@ -199,7 +199,7 @@ fn testUnion() void {
199199 expect(typeinfo_info.Union.tag_type.? == TypeId);
200200 expect(typeinfo_info.Union.fields.len == 25);
201201 expect(typeinfo_info.Union.fields[4].field_type == @TypeOf(@typeInfo(u8).Int));
202 expect(typeinfo_info.Union.decls.len == 21);
202 expect(typeinfo_info.Union.decls.len == 22);
203203
204204 const TestNoTagUnion = union {
205205 Foo: void,
......@@ -265,6 +265,21 @@ const TestStruct = packed struct {
265265 const Self = @This();
266266};
267267
268test "type info: opaque info" {
269 testOpaque();
270 comptime testOpaque();
271}
272
273fn testOpaque() void {
274 const Foo = opaque {
275 const A = 1;
276 fn b() void {}
277 };
278
279 const foo_info = @typeInfo(Foo);
280 expect(foo_info.Opaque.decls.len == 2);
281}
282
268283test "type info: function type info" {
269284 // wasm doesn't support align attributes on functions
270285 if (builtin.arch == .wasm32 or builtin.arch == .wasm64) return error.SkipZigTest;
test/stage1/c_abi/cfuncs.c-18
......@@ -28,8 +28,6 @@ void zig_ptr(void *);
2828
2929void zig_bool(bool);
3030
31void zig_array(uint8_t[10]);
32
3331struct BigStruct {
3432 uint64_t a;
3533 uint64_t b;
......@@ -97,9 +95,6 @@ void run_c_tests(void) {
9795
9896 zig_bool(true);
9997
100 uint8_t array[10] = {'1', '2', '3', '4', '5', '6', '7', '8', '9', '0'};
101 zig_array(array);
102
10398 {
10499 struct BigStruct s = {1, 2, 3, 4, 5};
105100 zig_big_struct(s);
......@@ -190,19 +185,6 @@ void c_five_floats(float a, float b, float c, float d, float e) {
190185 assert_or_panic(e == 5.0);
191186}
192187
193void c_array(uint8_t x[10]) {
194 assert_or_panic(x[0] == '1');
195 assert_or_panic(x[1] == '2');
196 assert_or_panic(x[2] == '3');
197 assert_or_panic(x[3] == '4');
198 assert_or_panic(x[4] == '5');
199 assert_or_panic(x[5] == '6');
200 assert_or_panic(x[6] == '7');
201 assert_or_panic(x[7] == '8');
202 assert_or_panic(x[8] == '9');
203 assert_or_panic(x[9] == '0');
204}
205
206188void c_big_struct(struct BigStruct x) {
207189 assert_or_panic(x.a == 1);
208190 assert_or_panic(x.b == 2);
test/stage1/c_abi/main.zig-11
......@@ -116,17 +116,6 @@ export fn zig_bool(x: bool) void {
116116 expect(x);
117117}
118118
119extern fn c_array([10]u8) void;
120
121test "C ABI array" {
122 var array: [10]u8 = "1234567890".*;
123 c_array(array);
124}
125
126export fn zig_array(x: [10]u8) void {
127 expect(std.mem.eql(u8, &x, "1234567890"));
128}
129
130119const BigStruct = extern struct {
131120 a: u64,
132121 b: u64,
test/translate_c.zig+7-7
......@@ -137,9 +137,9 @@ pub fn addCases(cases: *tests.TranslateCContext) void {
137137 \\struct foo { int x; int y[]; };
138138 \\struct bar { int x; int y[0]; };
139139 , &[_][]const u8{
140 \\pub const struct_foo = @Type(.Opaque);
140 \\pub const struct_foo = opaque {};
141141 ,
142 \\pub const struct_bar = @Type(.Opaque);
142 \\pub const struct_bar = opaque {};
143143 });
144144
145145 cases.add("nested loops without blocks",
......@@ -207,7 +207,7 @@ pub fn addCases(cases: *tests.TranslateCContext) void {
207207 \\pub const struct_arcan_shmif_page = //
208208 ,
209209 \\warning: unsupported type: 'Atomic'
210 \\ @Type(.Opaque); //
210 \\ opaque {}; //
211211 ,
212212 \\ warning: struct demoted to opaque type - unable to translate type of field abufused
213213 , // TODO should be `addr: *struct_arcan_shmif_page`
......@@ -386,8 +386,8 @@ pub fn addCases(cases: *tests.TranslateCContext) void {
386386 \\ struct opaque_2 *cast = (struct opaque_2 *)opaque;
387387 \\}
388388 , &[_][]const u8{
389 \\pub const struct_opaque = @Type(.Opaque);
390 \\pub const struct_opaque_2 = @Type(.Opaque);
389 \\pub const struct_opaque = opaque {};
390 \\pub const struct_opaque_2 = opaque {};
391391 \\pub export fn function(arg_opaque_1: ?*struct_opaque) void {
392392 \\ var opaque_1 = arg_opaque_1;
393393 \\ var cast: ?*struct_opaque_2 = @ptrCast(?*struct_opaque_2, opaque_1);
......@@ -628,7 +628,7 @@ pub fn addCases(cases: *tests.TranslateCContext) void {
628628 \\ struct Foo *foo;
629629 \\};
630630 , &[_][]const u8{
631 \\pub const struct_Foo = @Type(.Opaque);
631 \\pub const struct_Foo = opaque {};
632632 ,
633633 \\pub const struct_Bar = extern struct {
634634 \\ foo: ?*struct_Foo,
......@@ -705,7 +705,7 @@ pub fn addCases(cases: *tests.TranslateCContext) void {
705705 \\struct Foo;
706706 \\struct Foo *some_func(struct Foo *foo, int x);
707707 , &[_][]const u8{
708 \\pub const struct_Foo = @Type(.Opaque);
708 \\pub const struct_Foo = opaque {};
709709 ,
710710 \\pub extern fn some_func(foo: ?*struct_Foo, x: c_int) ?*struct_Foo;
711711 ,
tools/update_clang_options.zig+27-1
......@@ -130,6 +130,10 @@ const known_options = [_]KnownOpt{
130130 .name = "assemble",
131131 .ident = "asm_only",
132132 },
133 .{
134 .name = "O0",
135 .ident = "optimize",
136 },
133137 .{
134138 .name = "O1",
135139 .ident = "optimize",
......@@ -138,10 +142,20 @@ const known_options = [_]KnownOpt{
138142 .name = "O2",
139143 .ident = "optimize",
140144 },
145 // O3 is only detected from the joined "-O" option
146 .{
147 .name = "O4",
148 .ident = "optimize",
149 },
141150 .{
142151 .name = "Og",
143152 .ident = "optimize",
144153 },
154 .{
155 .name = "Os",
156 .ident = "optimize",
157 },
158 // Oz is only detected from the joined "-O" option
145159 .{
146160 .name = "O",
147161 .ident = "optimize",
......@@ -154,6 +168,14 @@ const known_options = [_]KnownOpt{
154168 .name = "optimize",
155169 .ident = "optimize",
156170 },
171 .{
172 .name = "g1",
173 .ident = "debug",
174 },
175 .{
176 .name = "gline-tables-only",
177 .ident = "debug",
178 },
157179 .{
158180 .name = "g",
159181 .ident = "debug",
......@@ -390,6 +412,10 @@ pub fn main() anyerror!void {
390412 // the only way.
391413 try stdout.print("flagpsl(\"{}\"),\n", .{name});
392414 } else if (knownOption(name)) |ident| {
415
416 // Workaround the fact that in 'Options.td' -Ofast is listed as 'joined'
417 const final_syntax = if (std.mem.eql(u8, name, "Ofast")) .flag else syntax;
418
393419 try stdout.print(
394420 \\.{{
395421 \\ .name = "{}",
......@@ -400,7 +426,7 @@ pub fn main() anyerror!void {
400426 \\ .psl = {},
401427 \\}},
402428 \\
403 , .{ name, syntax, ident, pd1, pd2, pslash });
429 , .{ name, final_syntax, ident, pd1, pd2, pslash });
404430 } else if (pd1 and !pd2 and !pslash and syntax == .flag) {
405431 try stdout.print("flagpd1(\"{}\"),\n", .{name});
406432 } else if (!pd1 and !pd2 and pslash and syntax == .flag) {